Merge branch 'master' of legendre@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 "Annotatable.h"
47 #include "Serialization.h"
48
49 #ifndef CASE_RETURN_STR
50 #define CASE_RETURN_STR(x) case x: return #x
51 #endif
52
53
54 namespace Dyninst{
55 namespace SymtabAPI{
56
57 class Module;
58 class typeCommon;
59 class localVarCollection;
60 class Region;
61 class Aggregate;
62 class Function;
63 class Variable;
64 class Type;
65 class typeCollection;
66 class Symtab;
67
68 /************************************************************************
69  * class Symbol
70 ************************************************************************/
71
72 class Symbol : public Serializable,
73                public AnnotatableSparse 
74 {
75    friend class typeCommon;
76    friend class Symtab;
77    friend class AObject;
78    friend class Object;
79    friend class Aggregate;
80    friend class relocationEntry;
81
82    friend std::string parseStabString(Module *, int linenum, char *, int, 
83          typeCommon *);
84
85    public:
86
87    enum SymbolType {
88       ST_UNKNOWN,
89       ST_FUNCTION,
90       ST_OBJECT,
91       ST_MODULE,
92       ST_SECTION,
93       ST_TLS,
94       ST_DELETED,
95       ST_NOTYPE,
96    };
97
98    static const char *symbolType2Str(SymbolType t);
99
100    enum SymbolLinkage {
101       SL_UNKNOWN,
102       SL_GLOBAL,
103       SL_LOCAL,
104       SL_WEAK
105    };
106
107    static const char *symbolLinkage2Str(SymbolLinkage t);
108
109    enum SymbolTag {
110       TAG_UNKNOWN,
111       TAG_USER,
112       TAG_LIBRARY,
113       TAG_INTERNAL
114    };
115
116    static const char *symbolTag2Str(SymbolTag t);
117
118    enum SymbolVisibility {
119        SV_UNKNOWN,
120        SV_DEFAULT,
121        SV_INTERNAL,
122        SV_HIDDEN,
123        SV_PROTECTED
124    };
125    static const char *symbolVisibility2Str(SymbolVisibility t);
126
127    SYMTAB_EXPORT Symbol();
128
129    SYMTAB_EXPORT static Symbol *magicEmitElfSymbol();
130
131    SYMTAB_EXPORT Symbol (const std::string name,
132                          SymbolType t,
133                          SymbolLinkage l,
134                          SymbolVisibility v,
135                          Offset o,
136                          Module *module = NULL, 
137                          Region *r = NULL, 
138                          unsigned s = 0,
139                          bool d = false,
140                          bool a = false,
141                          int index= -1,
142                          int strindex = -1);
143    SYMTAB_EXPORT ~Symbol();
144
145    SYMTAB_EXPORT bool          operator== (const Symbol &) const;
146
147    /***********************************************************
148      Name Output Functions
149     ***********************************************************/                
150    SYMTAB_EXPORT const std::string&      getMangledName () const;
151    SYMTAB_EXPORT const std::string&      getPrettyName() const;
152    SYMTAB_EXPORT const std::string&      getTypedName() const;
153
154    SYMTAB_EXPORT Module *getModule() const { return module_; } 
155    SYMTAB_EXPORT Symtab *getSymtab() const;
156    SYMTAB_EXPORT SymbolType getType () const { return type_; }
157    SYMTAB_EXPORT SymbolLinkage getLinkage () const { return linkage_; }
158    SYMTAB_EXPORT Offset getOffset() const { return offset_; }
159    SYMTAB_EXPORT Offset getPtrOffset() const { return ptr_offset_; }
160    SYMTAB_EXPORT unsigned getSize() const { return size_; }
161    SYMTAB_EXPORT Region *getRegion() const { return region_; }
162
163    SYMTAB_EXPORT bool isInDynSymtab() const { return (type_ != ST_DELETED) && isDynamic_; }
164    SYMTAB_EXPORT bool isInSymtab() const { return (type_ != ST_DELETED) && !isDynamic_; }
165    SYMTAB_EXPORT bool isAbsolute() const { return isAbsolute_; }
166
167    SYMTAB_EXPORT bool              isFunction()            const;
168    SYMTAB_EXPORT bool              setFunction(Function * func);
169    SYMTAB_EXPORT Function *        getFunction()           const;
170
171    SYMTAB_EXPORT bool              isVariable()            const;
172    SYMTAB_EXPORT bool              setVariable(Variable *var);
173    SYMTAB_EXPORT Variable *        getVariable()           const;
174
175    SYMTAB_EXPORT SymbolVisibility getVisibility() const { return visibility_; }
176
177    SYMTAB_EXPORT int getIndex() const { return index_; }
178    SYMTAB_EXPORT bool setIndex(int index) { index_ = index; return true; }
179    SYMTAB_EXPORT int getStrIndex() const { return strindex_; }
180    SYMTAB_EXPORT bool setStrIndex(int strindex) { strindex_ = strindex; return true; }
181    SYMTAB_EXPORT void setReferringSymbol (Symbol *referringSymbol);
182    SYMTAB_EXPORT Symbol* getReferringSymbol ();
183
184    //////////////// Modification
185    SYMTAB_EXPORT bool setOffset (Offset newOffset);
186    SYMTAB_EXPORT bool setPtrOffset (Offset newOffset);
187    SYMTAB_EXPORT bool setSize(unsigned ns);
188    SYMTAB_EXPORT bool setModule(Module *mod);
189
190    SYMTAB_EXPORT bool setMangledName(std::string &name); 
191    SYMTAB_EXPORT bool setPrettyName(std::string &name); 
192    SYMTAB_EXPORT bool setTypedName(std::string &name); 
193
194    SYMTAB_EXPORT bool setSymbolType(SymbolType sType);
195
196    SYMTAB_EXPORT SymbolTag            tag ()               const;
197    SYMTAB_EXPORT bool  setDynamic(bool d) { isDynamic_ = d; return true;}
198    SYMTAB_EXPORT bool  setAbsolute(bool a) { isAbsolute_ = a; return true; }
199
200    SYMTAB_EXPORT bool  setVersionFileName(std::string &fileName);
201    SYMTAB_EXPORT bool  setVersions(std::vector<std::string> &vers);
202    SYMTAB_EXPORT bool  setVersionNum(unsigned verNum);
203
204    SYMTAB_EXPORT bool  getVersionFileName(std::string &fileName);
205    SYMTAB_EXPORT bool  getVersions(std::vector<std::string> *&vers);
206    SYMTAB_EXPORT bool  getVersionNum(unsigned &verNum);
207
208    friend
209       std::ostream& operator<< (std::ostream &os, const Symbol &s);
210
211    //////////// DEPRECATED
212    SYMTAB_EXPORT Region            *getSec ()              const { return getRegion(); }
213    SYMTAB_EXPORT Offset            getAddr ()              const { return getOffset(); }
214    SYMTAB_EXPORT const std::string&getModuleName ()        const;
215    SYMTAB_EXPORT const std::string &getName() const { return getMangledName(); }
216    SYMTAB_EXPORT bool setAddr (Offset newAddr) { return setOffset(newAddr); }
217    SYMTAB_EXPORT bool   setModuleName(std::string) { return false; }
218
219
220    public:
221    static std::string emptyString;
222    int getInternalType() { return internal_type_; }
223    void setInternalType(int i) { internal_type_ = i; }
224
225    private:
226
227    Module*       module_;
228    SymbolType    type_;
229    int           internal_type_;
230    SymbolLinkage linkage_;
231    SymbolVisibility visibility_;
232    Offset        offset_;
233    Offset        ptr_offset_;  // Function descriptor offset.  Not available on all platforms.
234    Region*       region_;
235    Symbol*       referring_;
236    unsigned      size_;  // size of this symbol. This is NOT available on all platforms.
237
238    bool          isDynamic_;
239    bool          isAbsolute_;
240
241    Aggregate *   aggregate_; // Pointer to Function or Variable container, if appropriate.
242
243    std::string mangledName_;
244    std::string prettyName_;
245    std::string typedName_;
246
247    SymbolTag     tag_;
248    int index_;
249    int strindex_;
250
251    std::vector<std::string> verNames_;
252
253    void restore_module_and_region(SerializerBase *, 
254                    std::string &, Offset) THROW_SPEC (SerializerError);
255
256    public:
257
258    SYMTAB_EXPORT Serializable * serialize_impl(SerializerBase *, 
259                    const char *tag = "Symbol") THROW_SPEC (SerializerError);
260 };
261
262 class LookupInterface 
263 {
264    public:
265       SYMTAB_EXPORT LookupInterface();
266       SYMTAB_EXPORT virtual bool getAllSymbolsByType(std::vector<Symbol *> &ret,
267             Symbol::SymbolType sType) = 0;
268       SYMTAB_EXPORT virtual bool findSymbolByType(std::vector<Symbol *> &ret,
269             const std::string name,
270             Symbol::SymbolType sType,
271             bool isMangled = false,
272             bool isRegex = false,
273             bool checkCase = false) = 0;
274       SYMTAB_EXPORT virtual bool findType(Type *&type, std::string name) = 0;
275       SYMTAB_EXPORT virtual bool findVariableType(Type *&type, std::string name)= 0;
276
277       SYMTAB_EXPORT virtual ~LookupInterface();
278 };
279
280
281 }//namespace SymtabAPI
282 }//namespace Dyninst
283
284 #endif /* !defined(_Symbol_h_) */