Compile fix after removing deprecated SymtabAPI methods.
[dyninst.git] / symtabAPI / h / Symbol.h
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  * 
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  * 
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  * 
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  * 
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  * 
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 /************************************************************************
32  * $Id: Symbol.h,v 1.20 2008/11/03 15:19:24 jaw Exp $
33  * Symbol.h: symbol table objects.
34 ************************************************************************/
35
36 #if !defined(_Symbol_h_)
37 #define _Symbol_h_
38
39
40 /************************************************************************
41  * header files.
42 ************************************************************************/
43
44 #include "symutil.h"
45 #include "Annotatable.h"
46 #include "Serialization.h"
47
48 #ifndef CASE_RETURN_STR
49 #define CASE_RETURN_STR(x) case x: return #x
50 #endif
51
52
53 namespace Dyninst{
54 namespace SymtabAPI{
55
56 class Module;
57 class typeCommon;
58 class localVarCollection;
59 class Region;
60 class Aggregate;
61 class Function;
62 class Variable;
63 class Type;
64 class typeCollection;
65 class Symtab;
66
67 /************************************************************************
68  * class Symbol
69 ************************************************************************/
70
71 class Symbol : public Serializable,
72                public AnnotatableSparse 
73 {
74    friend class typeCommon;
75    friend class Symtab;
76    friend class AObject;
77    friend class Object;
78    friend class Aggregate;
79    friend class relocationEntry;
80
81    friend std::string parseStabString(Module *, int linenum, char *, int, 
82          typeCommon *);
83
84    public:
85
86    enum SymbolType {
87       ST_UNKNOWN,
88       ST_FUNCTION,
89       ST_OBJECT,
90       ST_MODULE,
91       ST_SECTION,
92       ST_TLS,
93       ST_DELETED,
94       ST_NOTYPE
95    };
96
97    static const char *symbolType2Str(SymbolType t);
98
99    enum SymbolLinkage {
100       SL_UNKNOWN,
101       SL_GLOBAL,
102       SL_LOCAL,
103       SL_WEAK
104    };
105
106    static const char *symbolLinkage2Str(SymbolLinkage t);
107
108    enum SymbolTag {
109       TAG_UNKNOWN,
110       TAG_USER,
111       TAG_LIBRARY,
112       TAG_INTERNAL
113    };
114
115    static const char *symbolTag2Str(SymbolTag t);
116
117    enum SymbolVisibility {
118        SV_UNKNOWN,
119        SV_DEFAULT,
120        SV_INTERNAL,
121        SV_HIDDEN,
122        SV_PROTECTED
123    };
124    static const char *symbolVisibility2Str(SymbolVisibility t);
125
126    SYMTAB_EXPORT Symbol();
127
128    SYMTAB_EXPORT static Symbol *magicEmitElfSymbol();
129
130    SYMTAB_EXPORT Symbol (const std::string& name,
131                          SymbolType t,
132                          SymbolLinkage l,
133                          SymbolVisibility v,
134                          Offset o,
135                          Module *module = NULL, 
136                          Region *r = NULL, 
137                          unsigned s = 0,
138                          bool d = false,
139                          bool a = false,
140                          int index= -1,
141                          int strindex = -1,
142                          bool cs = false);
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 Offset getLocalTOC() const { return localTOC_; }
161    SYMTAB_EXPORT unsigned getSize() const { return size_; }
162    SYMTAB_EXPORT Region *getRegion() const { return region_; }
163
164    SYMTAB_EXPORT bool isInDynSymtab() const { return (type_ != ST_DELETED) && isDynamic_; }
165    SYMTAB_EXPORT bool isInSymtab() const { return (type_ != ST_DELETED) && !isDynamic_; }
166    SYMTAB_EXPORT bool isAbsolute() const { return isAbsolute_; }
167    SYMTAB_EXPORT bool isCommonStorage() const { return isCommonStorage_; }
168
169    SYMTAB_EXPORT bool              isFunction()            const;
170    SYMTAB_EXPORT bool              setFunction(Function * func);
171    SYMTAB_EXPORT Function *        getFunction()           const;
172
173    SYMTAB_EXPORT bool              isVariable()            const;
174    SYMTAB_EXPORT bool              setVariable(Variable *var);
175    SYMTAB_EXPORT Variable *        getVariable()           const;
176
177    SYMTAB_EXPORT SymbolVisibility getVisibility() const { return visibility_; }
178
179    SYMTAB_EXPORT int getIndex() const { return index_; }
180    SYMTAB_EXPORT bool setIndex(int index) { index_ = index; return true; }
181    SYMTAB_EXPORT int getStrIndex() const { return strindex_; }
182    SYMTAB_EXPORT bool setStrIndex(int strindex) { strindex_ = strindex; return true; }
183    SYMTAB_EXPORT void setReferringSymbol (Symbol *referringSymbol);
184    SYMTAB_EXPORT Symbol* getReferringSymbol ();
185
186    //////////////// Modification
187    SYMTAB_EXPORT bool setOffset (Offset newOffset);
188    SYMTAB_EXPORT bool setPtrOffset (Offset newOffset);
189    SYMTAB_EXPORT bool setLocalTOC (Offset localTOC);
190    SYMTAB_EXPORT bool setSize(unsigned ns);
191    SYMTAB_EXPORT bool setRegion(Region *r);
192    SYMTAB_EXPORT bool setModule(Module *mod);
193
194    SYMTAB_EXPORT bool setMangledName(std::string name);
195
196    SYMTAB_EXPORT bool setSymbolType(SymbolType sType);
197
198    SYMTAB_EXPORT SymbolTag            tag ()               const;
199    SYMTAB_EXPORT bool  setDynamic(bool d) { isDynamic_ = d; return true;}
200    SYMTAB_EXPORT bool  setAbsolute(bool a) { isAbsolute_ = a; return true; }
201    SYMTAB_EXPORT bool  setCommonStorage(bool cs) { isCommonStorage_ = cs; return true; }
202
203    SYMTAB_EXPORT bool  setVersionFileName(std::string &fileName);
204    SYMTAB_EXPORT bool  setVersions(std::vector<std::string> &vers);
205    SYMTAB_EXPORT bool  setVersionNum(unsigned verNum);
206    SYMTAB_EXPORT void setVersionHidden() { versionHidden_ = true; }
207
208    SYMTAB_EXPORT bool  getVersionFileName(std::string &fileName);
209    SYMTAB_EXPORT bool  getVersions(std::vector<std::string> *&vers);
210    SYMTAB_EXPORT bool  getVersionNum(unsigned &verNum);
211    SYMTAB_EXPORT bool  getVersionHidden() { return versionHidden_; }
212
213    friend
214       std::ostream& operator<< (std::ostream &os, const Symbol &s);
215
216    public:
217    static std::string emptyString;
218    int getInternalType() { return internal_type_; }
219    void setInternalType(int i) { internal_type_ = i; }
220
221    private:
222
223    Module*       module_;
224    SymbolType    type_;
225    int           internal_type_;
226    SymbolLinkage linkage_;
227    SymbolVisibility visibility_;
228    Offset        offset_;
229    Offset        ptr_offset_;  // Function descriptor offset.  Not available on all platforms.
230    Offset        localTOC_;
231    Region*       region_;
232    Symbol*       referring_;
233    unsigned      size_;  // size of this symbol. This is NOT available on all platforms.
234
235    bool          isDynamic_;
236    bool          isAbsolute_;
237
238    Aggregate *   aggregate_; // Pointer to Function or Variable container, if appropriate.
239
240    std::string mangledName_;
241    std::string prettyName_;
242    std::string typedName_;
243
244    SymbolTag     tag_;
245    int index_;
246    int strindex_;
247
248    bool          isCommonStorage_;
249
250    std::vector<std::string> verNames_;
251
252    bool versionHidden_;
253
254    void restore_module_and_region(SerializerBase *, 
255                    std::string &, Offset) THROW_SPEC (SerializerError);
256
257    public:
258
259    SYMTAB_EXPORT Serializable * serialize_impl(SerializerBase *, 
260                    const char *tag = "Symbol") THROW_SPEC (SerializerError);
261 };
262
263 class LookupInterface 
264 {
265    public:
266       SYMTAB_EXPORT LookupInterface();
267       SYMTAB_EXPORT virtual bool getAllSymbolsByType(std::vector<Symbol *> &ret,
268             Symbol::SymbolType sType) = 0;
269       SYMTAB_EXPORT virtual bool findSymbol(std::vector<Symbol *> &ret,
270                                             const std::string& name,
271                                             Symbol::SymbolType sType = Symbol::ST_UNKNOWN,
272                                             NameType nameType = anyName,
273                                             bool isRegex = false,
274                                             bool checkCase = false,
275                                             bool includeUndefined = false) = 0;
276       SYMTAB_EXPORT virtual bool findType(Type *&type, std::string name) = 0;
277       SYMTAB_EXPORT virtual bool findVariableType(Type *&type, std::string name)= 0;
278
279       SYMTAB_EXPORT virtual ~LookupInterface();
280 };
281
282 std::ostream& operator<< (std::ostream &os, const Symbol &s);
283
284 }//namespace SymtabAPI
285 }//namespace Dyninst
286
287 #endif /* !defined(_Symbol_h_) */