added setAddr() method (aix needs it)
[dyninst.git] / pdutil / 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 // trace data streams
63 #include "util/h/ByteArray.h"
64 #include "util/h/Types.h"
65
66
67 \f
68
69
70 /************************************************************************
71  * class Symbol
72 ************************************************************************/
73
74 class Symbol {
75 public:
76     enum SymbolType {
77         PDST_UNKNOWN,
78         PDST_FUNCTION,
79         PDST_OBJECT,
80         PDST_MODULE,
81         PDST_NOTYPE
82     };
83
84     enum SymbolLinkage {
85         SL_UNKNOWN,
86         SL_GLOBAL,
87         SL_LOCAL,
88         SL_WEAK
89     };
90
91     enum SymbolTag {
92         TAG_UNKNOWN,
93         TAG_USER,
94         TAG_LIBRARY,
95         TAG_INTERNAL
96     };
97
98    Symbol (); // note: this ctor is called surprisingly often!
99      Symbol (unsigned);
100      Symbol (const string &name, const string &modulename, SymbolType, SymbolLinkage,
101              Address, const bool, unsigned size = 0);
102      Symbol (const Symbol &);
103     ~Symbol ();
104
105     Symbol&        operator= (const Symbol &);
106     bool          operator== (const Symbol &) const;
107
108     const string&       name ()               const;
109     const string&     module ()               const;
110     SymbolType          type ()               const;
111     SymbolLinkage    linkage ()               const;
112     Address             addr ()               const;
113
114    void setAddr (Address newAddr) {
115       addr_ = newAddr;
116    }
117    
118     unsigned            size ()               const;
119     bool              kludge ()               const;
120     SymbolTag&           tag ()               const;
121     void        change_size(unsigned ns){ size_ = ns;}
122
123     friend
124     ostream&      operator<< (ostream &os, const Symbol &s) {
125       return os << "{"
126         << " name="    << s.name_
127         << " module="  << s.module_
128         << " type="    << (unsigned) s.type_
129         << " linkage=" << (unsigned) s.linkage_
130         << " addr="    << s.addr_
131         << " tag="     << (unsigned) s.tag_
132         << " kludge="  << s.kludge_
133         << " }" << endl;
134     }
135
136
137
138 private:
139     string        name_;
140     string        module_;
141     SymbolType    type_;
142     SymbolLinkage linkage_;
143     Address       addr_;
144     unsigned      size_;  // size of this symbol. This is NOT available on
145                           // all platforms.
146     SymbolTag     tag_;
147     bool          kludge_;
148 };
149
150 inline
151 Symbol::Symbol()
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    // note: this ctor is called surprisingly often (when we have
156    // vectors of Symbols and/or dictionaries of Symbols).  So, make it fast.
157 }
158
159 inline
160 Symbol::Symbol(unsigned)
161    : //name_("*bad-symbol*"), module_("*bad-module*"),
162     type_(PDST_UNKNOWN), linkage_(SL_UNKNOWN), addr_(0), size_(0),
163     tag_(TAG_UNKNOWN), kludge_(false) {
164 }
165
166 inline
167 Symbol::Symbol(const string& iname, const string& imodule,
168     SymbolType itype, SymbolLinkage ilinkage, Address iaddr, const bool ikl,
169     unsigned size)
170     : name_(iname), module_(imodule),
171     type_(itype), linkage_(ilinkage), addr_(iaddr), size_(size),
172     tag_(TAG_UNKNOWN), kludge_(ikl) {
173 }
174
175 inline
176 Symbol::Symbol(const Symbol& s)
177     : name_(s.name_), module_(s.module_),
178     type_(s.type_), linkage_(s.linkage_), addr_(s.addr_), size_(s.size_),
179     tag_(s.tag_), kludge_(s.kludge_) {
180 }
181
182 inline
183 Symbol::~Symbol() {
184 }
185
186 inline
187 Symbol&
188 Symbol::operator=(const Symbol& s) {
189     name_    = s.name_;
190     module_  = s.module_;
191     type_    = s.type_;
192     linkage_ = s.linkage_;
193     addr_    = s.addr_;
194     size_    = s.size_;
195     tag_     = s.tag_;
196     kludge_  = s.kludge_;
197
198     return *this;
199 }
200
201 inline
202 bool
203 Symbol::operator==(const Symbol& s) const {
204     // explicitly ignore tags when comparing symbols
205     return ((name_   == s.name_)
206         && (module_  == s.module_)
207         && (type_    == s.type_)
208         && (linkage_ == s.linkage_)
209         && (addr_    == s.addr_)
210         && (size_    == s.size_)
211         && (kludge_  == s.kludge_));
212 }
213
214 inline
215 const string&
216 Symbol::name() const {
217     return name_;
218 }
219
220 inline
221 const string&
222 Symbol::module() const {
223     return module_;
224 }
225
226 inline
227 Symbol::SymbolType
228 Symbol::type() const {
229     return type_;
230 }
231
232 inline
233 Symbol::SymbolLinkage
234 Symbol::linkage() const {
235     return linkage_;
236 }
237
238 inline
239 Address
240 Symbol::addr() const {
241     return addr_;
242 }
243
244 inline
245 unsigned
246 Symbol::size() const {
247     return size_;
248 }
249
250 inline
251 Symbol::SymbolTag&
252 Symbol::tag() const {
253     return (SymbolTag &) tag_;
254 }
255
256 inline
257 bool
258 Symbol::kludge() const {
259     return kludge_;
260 }
261
262
263 \f
264
265
266 #endif /* !defined(_Symbol_h_) */