windows build fixes and some more work on symtab serialization
[dyninst.git] / symtabAPI / h / Symbol.h
1 /*
2  * Copyright (c) 1996-2007 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  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
30  */
31
32 /************************************************************************
33  * $Id: Symbol.h,v 1.20 2008/11/03 15:19:24 jaw Exp $
34  * Symbol.h: symbol table objects.
35 ************************************************************************/
36
37 #if !defined(_Symbol_h_)
38 #define _Symbol_h_
39
40
41 /************************************************************************
42  * header files.
43 ************************************************************************/
44
45 #include "symutil.h"
46 #if 0
47 #include "Collections.h"
48 #include "Type.h"
49 #endif
50
51 #include "Annotatable.h"
52 #include "Serialization.h"
53
54 #ifndef CASE_RETURN_STR
55 #define CASE_RETURN_STR(x) case x: return #x
56 #endif
57
58
59 namespace Dyninst{
60 namespace SymtabAPI{
61
62 class Module;
63 class typeCommon;
64 class localVarCollection;
65 class Region;
66 class Aggregate;
67 class Function;
68 class Variable;
69 class Type;
70 class typeCollection;
71
72 /************************************************************************
73  * class Symbol
74 ************************************************************************/
75
76 class Symbol : public Serializable,
77                public AnnotatableSparse 
78 {
79    friend class typeCommon;
80    friend class Symtab;
81    friend class AObject;
82    friend class Object;
83    friend class Aggregate;
84
85    friend std::string parseStabString(Module *, int linenum, char *, int, 
86          typeCommon *);
87
88    public:
89
90    enum SymbolType {
91       ST_UNKNOWN,
92       ST_FUNCTION,
93       ST_OBJECT,
94       ST_MODULE,
95       ST_SECTION,
96       ST_DELETED,
97       ST_NOTYPE
98    };
99
100    static const char *symbolType2Str(SymbolType t);
101
102    enum SymbolLinkage {
103       SL_UNKNOWN,
104       SL_GLOBAL,
105       SL_LOCAL,
106       SL_WEAK
107    };
108
109    static const char *symbolLinkage2Str(SymbolLinkage t);
110
111    enum SymbolTag {
112       TAG_UNKNOWN,
113       TAG_USER,
114       TAG_LIBRARY,
115       TAG_INTERNAL
116    };
117
118    static const char *symbolTag2Str(SymbolTag t);
119
120    enum SymbolVisibility {
121        SV_UNKNOWN,
122        SV_DEFAULT,
123        SV_INTERNAL,
124        SV_HIDDEN,
125        SV_PROTECTED
126    };
127    static const char *symbolVisibility2Str(SymbolVisibility t);
128
129    SYMTAB_EXPORT Symbol () :
130        module_(NULL),
131        type_(ST_NOTYPE),
132        linkage_(SL_UNKNOWN),
133        visibility_(SV_UNKNOWN),
134        offset_(0),
135        region_(NULL),
136        size_(0),
137        isDynamic_(false),
138        isAbsolute_(false),
139        aggregate_(NULL),
140        mangledName_(Symbol::emptyString),
141        prettyName_(Symbol::emptyString),
142        typedName_(Symbol::emptyString),
143        tag_(TAG_UNKNOWN) {}
144
145    SYMTAB_EXPORT static Symbol *magicEmitElfSymbol();
146
147    SYMTAB_EXPORT Symbol (const std::string name,
148                          SymbolType t,
149                          SymbolLinkage l,
150                          SymbolVisibility v,
151                          Offset o,
152                          Module *module = NULL, 
153                          Region *r = NULL, 
154                          unsigned s = 0,
155                          bool d = false,
156                          bool a = false) :
157        module_(module),
158        type_(t),
159        linkage_(l),
160        visibility_(v),
161        offset_(o),
162        region_(r),
163        size_(s),
164        isDynamic_(d),
165        isAbsolute_(a),
166        aggregate_(NULL),
167        mangledName_(name),
168        prettyName_(name),
169        typedName_(name),
170        tag_(TAG_UNKNOWN) {
171
172    }
173
174    SYMTAB_EXPORT ~Symbol();
175
176    SYMTAB_EXPORT bool          operator== (const Symbol &) const;
177
178    /***********************************************************
179      Name Output Functions
180     ***********************************************************/                
181    SYMTAB_EXPORT const std::string&      getMangledName () const;
182    SYMTAB_EXPORT const std::string&      getPrettyName() const;
183    SYMTAB_EXPORT const std::string&      getTypedName() const;
184
185    SYMTAB_EXPORT Module *getModule() const { return module_; } 
186    SYMTAB_EXPORT SymbolType getType () const { return type_; }
187    SYMTAB_EXPORT SymbolLinkage getLinkage () const { return linkage_; }
188    SYMTAB_EXPORT Offset getOffset() const { return offset_; }
189    SYMTAB_EXPORT Offset getPtrOffset() const { return ptr_offset_; }
190    SYMTAB_EXPORT unsigned getSize() const { return size_; }
191    SYMTAB_EXPORT Region *getRegion() const { return region_; }
192
193    SYMTAB_EXPORT bool isInDynSymtab() const { return isDynamic_; }
194    SYMTAB_EXPORT bool isInSymtab() const { return isInDynSymtab(); }
195    SYMTAB_EXPORT bool isAbsolute() const { return isAbsolute_; }
196
197    SYMTAB_EXPORT bool              isFunction()            const;
198    SYMTAB_EXPORT bool              setFunction(Function * func);
199    SYMTAB_EXPORT Function *        getFunction()           const;
200
201    SYMTAB_EXPORT bool              isVariable()            const;
202    SYMTAB_EXPORT bool              setVariable(Variable *var);
203    SYMTAB_EXPORT Variable *        getVariable()           const;
204
205    SYMTAB_EXPORT SymbolVisibility getVisibility() const { return visibility_; }
206
207
208    //////////////// Modification
209    SYMTAB_EXPORT bool setOffset (Offset newOffset);
210    SYMTAB_EXPORT bool setPtrOffset (Offset newOffset);
211    SYMTAB_EXPORT bool setSize(unsigned ns);
212    SYMTAB_EXPORT bool setModule(Module *mod);
213
214    SYMTAB_EXPORT bool setMangledName(std::string &name); 
215    SYMTAB_EXPORT bool setPrettyName(std::string &name); 
216    SYMTAB_EXPORT bool setTypedName(std::string &name); 
217
218    SYMTAB_EXPORT bool setSymbolType(SymbolType sType);
219
220    SYMTAB_EXPORT SymbolTag            tag ()               const;
221    SYMTAB_EXPORT bool  setDynamic(bool d) { isDynamic_ = d; return true;}
222    SYMTAB_EXPORT bool  setAbsolute(bool a) { isAbsolute_ = a; return true; }
223
224    SYMTAB_EXPORT bool  setVersionFileName(std::string &fileName);
225    SYMTAB_EXPORT bool  setVersions(std::vector<std::string> &vers);
226    SYMTAB_EXPORT bool  setVersionNum(unsigned verNum);
227
228    SYMTAB_EXPORT bool  getVersionFileName(std::string &fileName);
229    SYMTAB_EXPORT bool  getVersions(std::vector<std::string> *&vers);
230    SYMTAB_EXPORT bool  getVersionNum(unsigned &verNum);
231
232    friend
233       std::ostream& operator<< (std::ostream &os, const Symbol &s);
234
235    //////////// DEPRECATED
236    SYMTAB_EXPORT Region            *getSec ()              const { return getRegion(); }
237    SYMTAB_EXPORT Offset            getAddr ()              const { return getOffset(); }
238    SYMTAB_EXPORT const std::string&getModuleName ()        const;
239    SYMTAB_EXPORT const std::string &getName() const { return getMangledName(); }
240    SYMTAB_EXPORT bool setAddr (Offset newAddr) { return setOffset(newAddr); }
241    SYMTAB_EXPORT bool   setModuleName(std::string) { return false; }
242
243
244    public:
245    static std::string emptyString;
246
247
248    private:
249
250    Module*       module_;
251    SymbolType    type_;
252    SymbolLinkage linkage_;
253    SymbolVisibility visibility_;
254    Offset        offset_;
255    Offset        ptr_offset_;  // Function descriptor offset.  Not available on all platforms.
256    Region*       region_;
257    unsigned      size_;  // size of this symbol. This is NOT available on all platforms.
258
259    bool          isDynamic_;
260    bool          isAbsolute_;
261
262    Aggregate *   aggregate_; // Pointer to Function or Variable container, if appropriate.
263
264    std::string mangledName_;
265    std::string prettyName_;
266    std::string typedName_;
267
268    SymbolTag     tag_;
269    unsigned index_;
270
271 #if !defined (USE_ANNOTATIONS)
272    std::vector<std::string> verNames_;
273 #endif
274
275    void restore_module_and_region(SerializerBase *, std::string &, Offset) THROW_SPEC (SerializerError);
276    public:
277    SYMTAB_EXPORT 
278            void serialize(SerializerBase *, const char *tag = "Symbol") THROW_SPEC (SerializerError);
279 };
280
281 #if 0
282 inline
283 Symbol::Symbol(unsigned)
284     : //name_("*bad-symbol*"), module_("*bad-module*"),
285     module_(NULL), type_(ST_UNKNOWN), linkage_(SL_UNKNOWN), addr_(0), sec_(NULL), size_(0), 
286     isInDynsymtab_(false), isInSymtab_(true), isAbsolute_(false), tag_(TAG_UNKNOWN),
287     retType_(NULL), moduleName_("")
288    //vars_(NULL), params_(NULL) 
289 {
290 }
291 #endif
292
293 class LookupInterface 
294 {
295    public:
296       SYMTAB_EXPORT LookupInterface();
297       SYMTAB_EXPORT virtual bool getAllSymbolsByType(std::vector<Symbol *> &ret,
298             Symbol::SymbolType sType) = 0;
299       SYMTAB_EXPORT virtual bool findSymbolByType(std::vector<Symbol *> &ret,
300             const std::string name,
301             Symbol::SymbolType sType,
302             bool isMangled = false,
303             bool isRegex = false,
304             bool checkCase = false) = 0;
305       SYMTAB_EXPORT virtual bool findType(Type *&type, std::string name) = 0;
306       SYMTAB_EXPORT virtual bool findVariableType(Type *&type, std::string name)= 0;
307
308       SYMTAB_EXPORT virtual ~LookupInterface();
309 };
310
311
312 }//namespace SymtabAPI
313 }//namespace Dyninst
314
315 #endif /* !defined(_Symbol_h_) */