added support for parsing shared object files for sparc-solaris platform
[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     };
87
88     enum SymbolTag {
89         TAG_UNKNOWN,
90         TAG_USER,
91         TAG_LIBRARY,
92         TAG_INTERNAL
93     };
94
95      Symbol ();
96      Symbol (unsigned);
97      Symbol (const string &, const string &, SymbolType, SymbolLinkage,
98              Address, const bool, unsigned size = 0);
99      Symbol (const Symbol &);
100     ~Symbol ();
101
102     Symbol&        operator= (const Symbol &);
103     bool          operator== (const Symbol &) const;
104
105     const string&       name ()               const;
106     const string&     module ()               const;
107     SymbolType          type ()               const;
108     SymbolLinkage    linkage ()               const;
109     Address             addr ()               const;
110     unsigned            size ()               const;
111     bool              kludge ()               const;
112     SymbolTag&           tag ()               const;
113
114     friend
115     ostream&      operator<< (ostream &os, const Symbol &s) {
116       return os << "{"
117         << " name="    << s.name_
118         << " module="  << s.module_
119         << " type="    << (unsigned) s.type_
120         << " linkage=" << (unsigned) s.linkage_
121         << " addr="    << s.addr_
122         << " tag="     << (unsigned) s.tag_
123         << " kludge="  << s.kludge_
124         << " }" << endl;
125     }
126
127
128
129 private:
130     string        name_;
131     string        module_;
132     SymbolType    type_;
133     SymbolLinkage linkage_;
134     Address       addr_;
135     unsigned      size_;  // size of this symbol. This is NOT available on
136                           // all platforms.
137     SymbolTag     tag_;
138     bool          kludge_;
139 };
140
141 inline
142 Symbol::Symbol()
143     : name_("*bad-symbol*"), module_("*bad-module*"),
144     type_(PDST_UNKNOWN), linkage_(SL_UNKNOWN), addr_(0), size_(0),
145     tag_(TAG_UNKNOWN), kludge_(false) {
146 }
147
148 inline
149 Symbol::Symbol(unsigned)
150     : name_("*bad-symbol*"), module_("*bad-module*"),
151     type_(PDST_UNKNOWN), linkage_(SL_UNKNOWN), addr_(0), size_(0),
152     tag_(TAG_UNKNOWN), kludge_(false) {
153 }
154
155 inline
156 Symbol::Symbol(const string& iname, const string& imodule,
157     SymbolType itype, SymbolLinkage ilinkage, Address iaddr, const bool ikl,
158     unsigned size)
159     : name_(iname), module_(imodule),
160     type_(itype), linkage_(ilinkage), addr_(iaddr), size_(size),
161     tag_(TAG_UNKNOWN), kludge_(ikl) {
162 }
163
164 inline
165 Symbol::Symbol(const Symbol& s)
166     : name_(s.name_), module_(s.module_),
167     type_(s.type_), linkage_(s.linkage_), addr_(s.addr_), size_(s.size_),
168     tag_(s.tag_), kludge_(s.kludge_) {
169 }
170
171 inline
172 Symbol::~Symbol() {
173 }
174
175 inline
176 Symbol&
177 Symbol::operator=(const Symbol& s) {
178     name_    = s.name_;
179     module_  = s.module_;
180     type_    = s.type_;
181     linkage_ = s.linkage_;
182     addr_    = s.addr_;
183     size_    = s.size_;
184     tag_     = s.tag_;
185     kludge_  = s.kludge_;
186
187     return *this;
188 }
189
190 inline
191 bool
192 Symbol::operator==(const Symbol& s) const {
193     // explicitly ignore tags when comparing symbols
194     return ((name_   == s.name_)
195         && (module_  == s.module_)
196         && (type_    == s.type_)
197         && (linkage_ == s.linkage_)
198         && (addr_    == s.addr_)
199         && (size_    == s.size_)
200         && (kludge_  == s.kludge_));
201 }
202
203 inline
204 const string&
205 Symbol::name() const {
206     return name_;
207 }
208
209 inline
210 const string&
211 Symbol::module() const {
212     return module_;
213 }
214
215 inline
216 Symbol::SymbolType
217 Symbol::type() const {
218     return type_;
219 }
220
221 inline
222 Symbol::SymbolLinkage
223 Symbol::linkage() const {
224     return linkage_;
225 }
226
227 inline
228 Address
229 Symbol::addr() const {
230     return addr_;
231 }
232
233 inline
234 unsigned
235 Symbol::size() const {
236     return size_;
237 }
238
239 inline
240 Symbol::SymbolTag&
241 Symbol::tag() const {
242     return (SymbolTag &) tag_;
243 }
244
245 inline
246 bool
247 Symbol::kludge() const {
248     return kludge_;
249 }
250
251
252 \f
253
254
255 #endif /* !defined(_Symbol_h_) */