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