added SL_WEAK, and change_size method
[dyninst.git] / common / h / Symbol.h
1 /*
2  * Copyright (c) 1996 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 /************************************************************************
43  * Symbol.h: symbol table objects.
44 ************************************************************************/
45
46
47 \f
48
49
50 #if !defined(_Symbol_h_)
51 #define _Symbol_h_
52
53
54 \f
55
56
57 /************************************************************************
58  * header files.
59 ************************************************************************/
60
61 #include <util/h/String.h>
62 #include <util/h/Types.h>
63
64
65 \f
66
67
68 /************************************************************************
69  * class Symbol
70 ************************************************************************/
71
72 class Symbol {
73 public:
74     enum SymbolType {
75         PDST_UNKNOWN,
76         PDST_FUNCTION,
77         PDST_OBJECT,
78         PDST_MODULE,
79         PDST_NOTYPE
80     };
81
82     enum SymbolLinkage {
83         SL_UNKNOWN,
84         SL_GLOBAL,
85         SL_LOCAL,
86         SL_WEAK
87     };
88
89     enum SymbolTag {
90         TAG_UNKNOWN,
91         TAG_USER,
92         TAG_LIBRARY,
93         TAG_INTERNAL
94     };
95
96      Symbol ();
97      Symbol (unsigned);
98      Symbol (const string &, const string &, SymbolType, SymbolLinkage,
99              Address, const bool, unsigned size = 0);
100      Symbol (const Symbol &);
101     ~Symbol ();
102
103     Symbol&        operator= (const Symbol &);
104     bool          operator== (const Symbol &) const;
105
106     const string&       name ()               const;
107     const string&     module ()               const;
108     SymbolType          type ()               const;
109     SymbolLinkage    linkage ()               const;
110     Address             addr ()               const;
111     unsigned            size ()               const;
112     bool              kludge ()               const;
113     SymbolTag&           tag ()               const;
114     void        change_size(unsigned ns){ size_ = ns;}
115
116     friend
117     ostream&      operator<< (ostream &os, const Symbol &s) {
118       return os << "{"
119         << " name="    << s.name_
120         << " module="  << s.module_
121         << " type="    << (unsigned) s.type_
122         << " linkage=" << (unsigned) s.linkage_
123         << " addr="    << s.addr_
124         << " tag="     << (unsigned) s.tag_
125         << " kludge="  << s.kludge_
126         << " }" << endl;
127     }
128
129
130
131 private:
132     string        name_;
133     string        module_;
134     SymbolType    type_;
135     SymbolLinkage linkage_;
136     Address       addr_;
137     unsigned      size_;  // size of this symbol. This is NOT available on
138                           // all platforms.
139     SymbolTag     tag_;
140     bool          kludge_;
141 };
142
143 inline
144 Symbol::Symbol()
145     : name_("*bad-symbol*"), module_("*bad-module*"),
146     type_(PDST_UNKNOWN), linkage_(SL_UNKNOWN), addr_(0), size_(0),
147     tag_(TAG_UNKNOWN), kludge_(false) {
148 }
149
150 inline
151 Symbol::Symbol(unsigned)
152     : name_("*bad-symbol*"), module_("*bad-module*"),
153     type_(PDST_UNKNOWN), linkage_(SL_UNKNOWN), addr_(0), size_(0),
154     tag_(TAG_UNKNOWN), kludge_(false) {
155 }
156
157 inline
158 Symbol::Symbol(const string& iname, const string& imodule,
159     SymbolType itype, SymbolLinkage ilinkage, Address iaddr, const bool ikl,
160     unsigned size)
161     : name_(iname), module_(imodule),
162     type_(itype), linkage_(ilinkage), addr_(iaddr), size_(size),
163     tag_(TAG_UNKNOWN), kludge_(ikl) {
164 }
165
166 inline
167 Symbol::Symbol(const Symbol& s)
168     : name_(s.name_), module_(s.module_),
169     type_(s.type_), linkage_(s.linkage_), addr_(s.addr_), size_(s.size_),
170     tag_(s.tag_), kludge_(s.kludge_) {
171 }
172
173 inline
174 Symbol::~Symbol() {
175 }
176
177 inline
178 Symbol&
179 Symbol::operator=(const Symbol& s) {
180     name_    = s.name_;
181     module_  = s.module_;
182     type_    = s.type_;
183     linkage_ = s.linkage_;
184     addr_    = s.addr_;
185     size_    = s.size_;
186     tag_     = s.tag_;
187     kludge_  = s.kludge_;
188
189     return *this;
190 }
191
192 inline
193 bool
194 Symbol::operator==(const Symbol& s) const {
195     // explicitly ignore tags when comparing symbols
196     return ((name_   == s.name_)
197         && (module_  == s.module_)
198         && (type_    == s.type_)
199         && (linkage_ == s.linkage_)
200         && (addr_    == s.addr_)
201         && (size_    == s.size_)
202         && (kludge_  == s.kludge_));
203 }
204
205 inline
206 const string&
207 Symbol::name() const {
208     return name_;
209 }
210
211 inline
212 const string&
213 Symbol::module() const {
214     return module_;
215 }
216
217 inline
218 Symbol::SymbolType
219 Symbol::type() const {
220     return type_;
221 }
222
223 inline
224 Symbol::SymbolLinkage
225 Symbol::linkage() const {
226     return linkage_;
227 }
228
229 inline
230 Address
231 Symbol::addr() const {
232     return addr_;
233 }
234
235 inline
236 unsigned
237 Symbol::size() const {
238     return size_;
239 }
240
241 inline
242 Symbol::SymbolTag&
243 Symbol::tag() const {
244     return (SymbolTag &) tag_;
245 }
246
247 inline
248 bool
249 Symbol::kludge() const {
250     return kludge_;
251 }
252
253
254 \f
255
256
257 #endif /* !defined(_Symbol_h_) */