Merge branch 'master' of git.dyninst.org:/pub/dyninst
[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 #include "Collections.h"
47 #include "Type.h"
48
49 #include "Annotatable.h"
50 #include "Serialization.h"
51
52 #ifndef CASE_RETURN_STR
53 #define CASE_RETURN_STR(x) case x: return #x
54 #endif
55
56
57 #if 0
58 typedef struct {} symbol_file_name_a;
59 typedef struct {} symbol_version_names_a;
60 typedef struct {} symbol_variables_a;
61 typedef struct {} symbol_parameters_a;
62 #endif
63
64 namespace Dyninst{
65 namespace SymtabAPI{
66
67 class Module;
68 class typeCommon;
69 class localVarCollection;
70 class Region;
71 class Aggregate;
72 class Function;
73 class Variable;
74
75 /************************************************************************
76  * class Symbol
77 ************************************************************************/
78
79 class Symbol : public Serializable,
80                public AnnotatableSparse 
81 {
82    friend class typeCommon;
83    friend class Symtab;
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_NOTYPE
97    };
98
99    static const char *symbolType2Str(SymbolType t);
100
101    enum SymbolLinkage {
102       SL_UNKNOWN,
103       SL_GLOBAL,
104       SL_LOCAL,
105       SL_WEAK
106    };
107
108    static const char *symbolLinkage2Str(SymbolLinkage t);
109
110    enum SymbolTag {
111       TAG_UNKNOWN,
112       TAG_USER,
113       TAG_LIBRARY,
114       TAG_INTERNAL
115    };
116
117    static const char *symbolTag2Str(SymbolTag t);
118
119    enum SymbolVisibility {
120        SV_UNKNOWN,
121        SV_DEFAULT,
122        SV_INTERNAL,
123        SV_HIDDEN,
124        SV_PROTECTED
125    };
126
127    static const char *symbolVisibility2Str(SymbolVisibility t);
128
129    DLLEXPORT Symbol (); // note: this ctor is called surprisingly often!
130    DLLEXPORT Symbol (unsigned);
131    DLLEXPORT Symbol (const std::string name,const std::string modulename, SymbolType, SymbolLinkage, SymbolVisibility,
132          Offset, Region *sec = NULL, unsigned size = 0, bool isInDynsymtab_ = false, 
133          bool isInSymtab_ = true, bool isAbsolute_ = false);
134    DLLEXPORT Symbol (const std::string name,Module *module, SymbolType, SymbolLinkage, SymbolVisibility,
135          Offset, Region *sec = NULL, unsigned size = 0, bool isInDynsymtab_ = false,
136          bool isInSymtab_ = true, bool isAbsolute_ = false);
137    DLLEXPORT Symbol (const Symbol &);
138    DLLEXPORT ~Symbol();
139
140    DLLEXPORT Symbol&        operator= (const Symbol &);
141    DLLEXPORT bool          operator== (const Symbol &) const;
142
143    DLLEXPORT const std::string&getModuleName ()        const;
144    DLLEXPORT Module*            getModule()                     const; 
145    DLLEXPORT SymbolType        getType ()              const;
146    DLLEXPORT SymbolLinkage     getLinkage ()           const;
147    DLLEXPORT SymbolVisibility  getVisibility ()        const;
148    DLLEXPORT Offset            getAddr ()              const;
149    DLLEXPORT Region                 *getSec ()              const;
150    DLLEXPORT bool              isInDynSymtab()         const;
151    DLLEXPORT bool              isInSymtab()            const;
152    DLLEXPORT bool              isAbsolute()            const;
153
154    DLLEXPORT bool              isFunction()            const;
155    DLLEXPORT bool              setFunction(Function * func);
156    DLLEXPORT Function *        getFunction()           const;
157
158    DLLEXPORT bool              isVariable()            const;
159    DLLEXPORT bool              setVariable(Variable *var);
160    DLLEXPORT Variable *        getVariable()           const;
161
162    /***********************************************************
163      Name Output Functions
164     ***********************************************************/                
165    DLLEXPORT const std::string&      getMangledName ()              const;
166    DLLEXPORT const std::string&      getPrettyName()            const;
167    DLLEXPORT const std::string&      getTypedName()             const;
168
169    /* Deprecated */
170    DLLEXPORT const std::string &getName() const { return getMangledName(); }
171
172    DLLEXPORT bool setAddr (Offset newAddr);
173
174    DLLEXPORT bool setSymbolType(SymbolType sType);
175
176    DLLEXPORT unsigned            getSize ()               const;
177    DLLEXPORT SymbolTag            tag ()               const;
178    DLLEXPORT bool       setSize(unsigned ns);
179    DLLEXPORT bool       setModuleName(std::string module);
180    DLLEXPORT bool       setModule(Module *mod);
181    DLLEXPORT bool  setDynSymtab();
182    DLLEXPORT bool  clearDynSymtab();
183    DLLEXPORT bool  setIsInSymtab();
184    DLLEXPORT bool  clearIsInSymtab();
185    DLLEXPORT bool  setIsAbsolute();
186    DLLEXPORT bool  clearIsAbsolute();
187
188    DLLEXPORT bool  setVersionFileName(std::string &fileName);
189    DLLEXPORT bool  setVersions(std::vector<std::string> &vers);
190    DLLEXPORT bool  setVersionNum(unsigned verNum);
191    DLLEXPORT bool  getVersionFileName(std::string &fileName);
192    DLLEXPORT bool  getVersions(std::vector<std::string> *&vers);
193    DLLEXPORT bool  VersionNum(unsigned &verNum);
194
195    friend
196       std::ostream& operator<< (std::ostream &os, const Symbol &s);
197
198    public:
199    static std::string emptyString;
200
201
202    private:
203    void setPrettyName(std::string pN) { prettyName_ = pN; };
204    void setTypedName(std::string tN) { typedName_ = tN; };
205
206    Module*       module_;
207    SymbolType    type_;
208    SymbolLinkage linkage_;
209    SymbolVisibility visibility_;
210    Offset        addr_;
211    Region*      sec_;
212    unsigned      size_;  // size of this symbol. This is NOT available on all platforms.
213    bool          isInDynsymtab_;
214    bool          isInSymtab_;
215    bool          isAbsolute_;
216
217    Aggregate *   aggregate_; // Pointer to Function or Variable container, if appropriate.
218
219    std::string mangledName_;
220    std::string prettyName_;
221    std::string typedName_;
222
223    SymbolTag     tag_;
224    int           framePtrRegNum_;
225    Type          *retType_;
226    // Module Objects are created in Symtab and not in Object.
227    // So we need a way to store the name of the module in 
228    // which the symbol is present.
229    std::string moduleName_;  
230    std::string fileName_;
231
232 #if !defined (USE_ANNOTATIONS)
233    std::vector<std::string> verNames_;
234 #endif
235
236    public:
237    DLLEXPORT void serialize(SerializerBase *, const char *tag = "Symbol");
238 };
239
240 inline
241 Symbol::Symbol(unsigned)
242    : //name_("*bad-symbol*"), module_("*bad-module*"),
243    module_(NULL), type_(ST_UNKNOWN), linkage_(SL_UNKNOWN), addr_(0), sec_(NULL), size_(0), 
244    isInDynsymtab_(false), isInSymtab_(true), isAbsolute_(false), tag_(TAG_UNKNOWN),
245    retType_(NULL), moduleName_("")
246    //vars_(NULL), params_(NULL) 
247 {
248 }
249 #if 0
250    inline
251 Symbol::Symbol(unsigned)
252    : //name_("*bad-symbol*"), module_("*bad-module*"),
253    module_(NULL), type_(ST_UNKNOWN), linkage_(SL_UNKNOWN), addr_(0), sec_(NULL), size_(0), upPtr_(NULL),
254    isInDynsymtab_(false), isInSymtab_(true), tag_(TAG_UNKNOWN), retType_(NULL), moduleName_(""), 
255    vars_(NULL), params_(NULL) {
256    }
257 #endif
258
259 inline
260 bool
261 Symbol::operator==(const Symbol& s) const 
262 {
263    // explicitly ignore tags when comparing symbols
264    return ((module_  == s.module_)
265          && (type_    == s.type_)
266          && (linkage_ == s.linkage_)
267          && (addr_    == s.addr_)
268          && (sec_     == s.sec_)
269          && (size_    == s.size_)
270 #if 0
271          && (upPtr_    == s.upPtr_)
272 #endif
273          && (isInDynsymtab_ == s.isInDynsymtab_)
274          && (isInSymtab_ == s.isInSymtab_)
275          && (isAbsolute_ == s.isAbsolute_)
276          && (retType_    == s.retType_)
277          && (mangledName_ == s.mangledName_)
278          && (prettyName_ == s.prettyName_)
279          && (typedName_ == s.typedName_)
280          && (moduleName_ == s.moduleName_));
281 }
282
283 class LookupInterface 
284 {
285    public:
286       DLLEXPORT LookupInterface();
287       DLLEXPORT virtual bool getAllSymbolsByType(std::vector<Symbol *> &ret,
288             Symbol::SymbolType sType) = 0;
289       DLLEXPORT virtual bool findSymbolByType(std::vector<Symbol *> &ret,
290             const std::string name,
291             Symbol::SymbolType sType,
292             bool isMangled = false,
293             bool isRegex = false,
294             bool checkCase = false) = 0;
295       DLLEXPORT virtual bool findType(Type *&type, std::string name) = 0;
296       DLLEXPORT virtual bool findVariableType(Type *&type, std::string name)= 0;
297
298       DLLEXPORT virtual ~LookupInterface();
299 };
300
301
302 }//namespace SymtabAPI
303 }//namespace Dyninst
304
305 #endif /* !defined(_Symbol_h_) */