- Updates to extract type info from executables in Coff format
[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.15 2000/01/11 21:57:16 altinel 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     void        setModule(string& module) { module_ = module; }
124
125     friend
126     ostream&      operator<< (ostream &os, const Symbol &s) {
127       return os << "{"
128         << " name="    << s.name_
129         << " module="  << s.module_
130         << " type="    << (unsigned) s.type_
131         << " linkage=" << (unsigned) s.linkage_
132         << " addr="    << s.addr_
133         << " tag="     << (unsigned) s.tag_
134         << " kludge="  << s.kludge_
135         << " }" << endl;
136     }
137
138
139
140 private:
141     string        name_;
142     string        module_;
143     SymbolType    type_;
144     SymbolLinkage linkage_;
145     Address       addr_;
146     unsigned      size_;  // size of this symbol. This is NOT available on
147                           // all platforms.
148     SymbolTag     tag_;
149     bool          kludge_;
150 };
151
152 inline
153 Symbol::Symbol()
154    : //name_("*bad-symbol*"), module_("*bad-module*"),
155     type_(PDST_UNKNOWN), linkage_(SL_UNKNOWN), addr_(0), size_(0),
156     tag_(TAG_UNKNOWN), kludge_(false) {
157    // note: this ctor is called surprisingly often (when we have
158    // vectors of Symbols and/or dictionaries of Symbols).  So, make it fast.
159 }
160
161 inline
162 Symbol::Symbol(unsigned)
163    : //name_("*bad-symbol*"), module_("*bad-module*"),
164     type_(PDST_UNKNOWN), linkage_(SL_UNKNOWN), addr_(0), size_(0),
165     tag_(TAG_UNKNOWN), kludge_(false) {
166 }
167
168 inline
169 Symbol::Symbol(const string& iname, const string& imodule,
170     SymbolType itype, SymbolLinkage ilinkage, Address iaddr, const bool ikl,
171     unsigned size)
172     : name_(iname), module_(imodule),
173     type_(itype), linkage_(ilinkage), addr_(iaddr), size_(size),
174     tag_(TAG_UNKNOWN), kludge_(ikl) {
175 }
176
177 inline
178 Symbol::Symbol(const Symbol& s)
179     : name_(s.name_), module_(s.module_),
180     type_(s.type_), linkage_(s.linkage_), addr_(s.addr_), size_(s.size_),
181     tag_(s.tag_), kludge_(s.kludge_) {
182 }
183
184 inline
185 Symbol::~Symbol() {
186 }
187
188 inline
189 Symbol&
190 Symbol::operator=(const Symbol& s) {
191     name_    = s.name_;
192     module_  = s.module_;
193     type_    = s.type_;
194     linkage_ = s.linkage_;
195     addr_    = s.addr_;
196     size_    = s.size_;
197     tag_     = s.tag_;
198     kludge_  = s.kludge_;
199
200     return *this;
201 }
202
203 inline
204 bool
205 Symbol::operator==(const Symbol& s) const {
206     // explicitly ignore tags when comparing symbols
207     return ((name_   == s.name_)
208         && (module_  == s.module_)
209         && (type_    == s.type_)
210         && (linkage_ == s.linkage_)
211         && (addr_    == s.addr_)
212         && (size_    == s.size_)
213         && (kludge_  == s.kludge_));
214 }
215
216 inline
217 const string&
218 Symbol::name() const {
219     return name_;
220 }
221
222 inline
223 const string&
224 Symbol::module() const {
225     return module_;
226 }
227
228 inline
229 Symbol::SymbolType
230 Symbol::type() const {
231     return type_;
232 }
233
234 inline
235 Symbol::SymbolLinkage
236 Symbol::linkage() const {
237     return linkage_;
238 }
239
240 inline
241 Address
242 Symbol::addr() const {
243     return addr_;
244 }
245
246 inline
247 unsigned
248 Symbol::size() const {
249     return size_;
250 }
251
252 inline
253 Symbol::SymbolTag&
254 Symbol::tag() const {
255     return (SymbolTag &) tag_;
256 }
257
258 inline
259 bool
260 Symbol::kludge() const {
261     return kludge_;
262 }
263
264
265 \f
266
267
268 #endif /* !defined(_Symbol_h_) */