make variable and parameter lists annotations to class Symbol instead of class members
[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.14 2008/04/27 06:54:23 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 <string>
46 #include <vector>
47 #include <algorithm>
48 #include <iostream>
49
50 #include "symutil.h"
51 #include "Type.h"
52
53 #include "Annotatable.h"
54 #ifndef CASE_RETURN_STR
55 #define CASE_RETURN_STR(x) case x: return #x
56 #endif
57
58
59 typedef struct {} symbol_file_name_a;
60 typedef struct {} symbol_version_names_a;
61 typedef struct {} symbol_variables_a;
62 typedef struct {} symbol_parameters_a;
63
64 namespace Dyninst{
65 namespace SymtabAPI{
66
67 class Region;
68 class Module;
69 class typeCommon;
70 class localVarCollection;
71
72
73 /************************************************************************
74  * class Symbol
75 ************************************************************************/
76
77 class Symbol : public Annotatable <std::string, symbol_file_name_a, false>,
78                public Annotatable <std::vector<std::string>, symbol_version_names_a, false>,
79                public Annotatable <localVarCollection, symbol_variables_a, true>,
80                public Annotatable <localVarCollection, symbol_parameters_a, true> {
81     friend class typeCommon;
82     friend class Symtab;
83     friend class SymtabTranslatorBase;
84     friend class SymtabTranslatorBin;
85
86     friend std::string parseStabString(Module *, int linenum, char *, int, 
87                               typeCommon *);
88 public:
89     enum SymbolType {
90         ST_UNKNOWN,
91         ST_FUNCTION,
92         ST_OBJECT,
93         ST_MODULE,
94         ST_NOTYPE
95     };
96
97     static char *symbolType2Str(SymbolType t) {
98        switch(t) {
99           CASE_RETURN_STR(ST_UNKNOWN);
100           CASE_RETURN_STR(ST_FUNCTION);
101           CASE_RETURN_STR(ST_OBJECT);
102           CASE_RETURN_STR(ST_MODULE);
103           CASE_RETURN_STR(ST_NOTYPE);
104        }
105        return "invalid symbol type";
106     }
107
108     enum SymbolLinkage {
109        SL_UNKNOWN,
110        SL_GLOBAL,
111        SL_LOCAL,
112         SL_WEAK
113     };
114
115     static char *symbolLinkage2Str(SymbolLinkage t) {
116        switch(t) {
117           CASE_RETURN_STR(SL_UNKNOWN);
118           CASE_RETURN_STR(SL_GLOBAL);
119           CASE_RETURN_STR(SL_LOCAL);
120           CASE_RETURN_STR(SL_WEAK);
121        }
122        return "invalid symbol linkage";
123     }
124
125     enum SymbolTag {
126        TAG_UNKNOWN,
127        TAG_USER,
128        TAG_LIBRARY,
129        TAG_INTERNAL
130     };
131
132     static char *symbolTag2Str(SymbolTag t) {
133        switch(t) {
134           CASE_RETURN_STR(TAG_UNKNOWN);
135           CASE_RETURN_STR(TAG_USER);
136           CASE_RETURN_STR(TAG_LIBRARY);
137           CASE_RETURN_STR(TAG_INTERNAL);
138        }
139        return "invalid symbol tag";
140     }
141
142     DLLEXPORT Symbol (); // note: this ctor is called surprisingly often!
143     DLLEXPORT Symbol (unsigned);
144     DLLEXPORT Symbol (const std::string name,const std::string modulename, SymbolType, SymbolLinkage,
145           Offset, Region *sec = NULL, unsigned size = 0, bool isInDynsymtab_ = false, 
146           bool isInSymtab_ = true);
147     DLLEXPORT Symbol (const std::string name,Module *module, SymbolType, SymbolLinkage,
148           Offset, Region *sec = NULL, unsigned size = 0, bool isInDynsymtab_ = false,
149           bool isInSymtab_ = true);
150 #if 0
151     DLLEXPORT Symbol (const std::string name,const std::string modulename, SymbolType, SymbolLinkage,
152           Offset, Region *sec = NULL, unsigned size = 0, void *upPtr = NULL, bool isInDynsymtab_ = false, 
153           bool isInSymtab_ = true);
154     DLLEXPORT Symbol (const std::string name,Module *module, SymbolType, SymbolLinkage,
155           Offset, Region *sec = NULL, unsigned size = 0, void *upPtr = NULL, bool isInDynsymtab_ = false,
156           bool isInSymtab_ = true);
157 #endif
158     DLLEXPORT Symbol (const Symbol &);
159     DLLEXPORT ~Symbol();
160
161     DLLEXPORT Symbol&        operator= (const Symbol &);
162     DLLEXPORT bool          operator== (const Symbol &) const;
163
164         DLLEXPORT const std::string&getModuleName ()        const;
165     DLLEXPORT Module*           getModule()                     const; 
166     DLLEXPORT SymbolType        getType ()              const;
167     DLLEXPORT SymbolLinkage     getLinkage ()           const;
168     DLLEXPORT Offset            getAddr ()              const;
169     DLLEXPORT Region                *getSec ()              const;
170     DLLEXPORT bool              isInDynSymtab()         const;
171     DLLEXPORT bool              isInSymtab()            const;
172     
173     
174     /***********************************************************
175         Name Output Functions
176     ***********************************************************/                
177     DLLEXPORT const std::string&      getName ()              const;
178     DLLEXPORT const std::string&        getPrettyName()         const;
179     DLLEXPORT const std::string&        getTypedName()          const;
180     
181     DLLEXPORT const std::vector<std::string>&   getAllMangledNames()    const;
182     DLLEXPORT const std::vector<std::string>&   getAllPrettyNames()     const;
183     DLLEXPORT const std::vector<std::string>&   getAllTypedNames()      const;
184
185     DLLEXPORT bool setAddr (Offset newAddr);
186
187     DLLEXPORT bool setSymbolType(SymbolType sType);
188    
189     DLLEXPORT unsigned            getSize ()               const;
190     DLLEXPORT SymbolTag            tag ()               const;
191     DLLEXPORT bool      setSize(unsigned ns);
192     DLLEXPORT bool      setModuleName(std::string module);
193     DLLEXPORT bool      setModule(Module *mod);
194 #if 0
195     DLLEXPORT bool      setUpPtr(void *newUpPtr);
196     DLLEXPORT void                      *getUpPtr()                     const;
197 #endif
198     DLLEXPORT bool  setDynSymtab();
199     DLLEXPORT bool  clearDynSymtab();
200     DLLEXPORT bool  setIsInSymtab();
201     DLLEXPORT bool  clearIsInSymtab();
202
203     DLLEXPORT Type  *getReturnType();
204     DLLEXPORT bool      setReturnType(Type *);
205     DLLEXPORT bool  setFramePtrRegnum(int regnum);
206     DLLEXPORT int   getFramePtrRegnum();
207     DLLEXPORT bool  setVersionFileName(std::string &fileName);
208     DLLEXPORT bool  setVersions(std::vector<std::string> &vers);
209     DLLEXPORT bool  setVersionNum(unsigned verNum);
210     DLLEXPORT bool  getVersionFileName(std::string &fileName);
211     DLLEXPORT bool  getVersions(std::vector<std::string> *&vers);
212     DLLEXPORT bool  VersionNum(unsigned &verNum);
213     
214     // Bool: returns true if the name is new (and therefore added)
215     DLLEXPORT bool addMangledName(std::string name, bool isPrimary = false);
216     DLLEXPORT bool addPrettyName(std::string name, bool isPrimary = false);
217     DLLEXPORT bool addTypedName(std::string name, bool isPrimary = false);
218
219     /***** Local Variable Information *****/
220     DLLEXPORT bool findLocalVariable(std::vector<localVar *>&vars, std::string name);
221     DLLEXPORT bool getLocalVariables(std::vector<localVar *>&vars);
222     DLLEXPORT bool getParams(std::vector<localVar *>&params);
223     
224     friend
225     std::ostream& operator<< (std::ostream &os, const Symbol &s);
226
227 public:
228     static std::string emptyString;
229
230     //  convenience functions, not really meant to be called outside symtabAPI
231     bool addLocalVar(localVar *);
232     bool addParam(localVar *);
233     
234 private:
235     Module*       module_;
236     SymbolType    type_;
237     SymbolLinkage linkage_;
238     Offset        addr_;
239     Region*      sec_;
240     unsigned      size_;  // size of this symbol. This is NOT available on all platforms.
241 #if 0
242     void*         upPtr_;
243 #endif
244     bool          isInDynsymtab_;
245     bool          isInSymtab_;
246
247     std::vector<std::string> mangledNames;
248     std::vector<std::string> prettyNames;
249     std::vector<std::string> typedNames;
250     SymbolTag     tag_;
251     int           framePtrRegNum_;
252     Type          *retType_;
253     // Module Objects are created in Symtab and not in Object.
254     // So we need a way to store the name of the module in 
255     // which the symbol is present.
256     std::string moduleName_;  
257
258 public:
259 #if 0
260     localVarCollection *vars_;
261     localVarCollection *params_;
262 #endif
263 };
264
265 inline
266 Symbol::Symbol(unsigned)
267    : //name_("*bad-symbol*"), module_("*bad-module*"),
268     module_(NULL), type_(ST_UNKNOWN), linkage_(SL_UNKNOWN), addr_(0), sec_(NULL), size_(0), 
269     isInDynsymtab_(false), isInSymtab_(true), tag_(TAG_UNKNOWN), retType_(NULL), moduleName_("")
270     //vars_(NULL), params_(NULL) 
271 {
272 }
273 #if 0
274 inline
275 Symbol::Symbol(unsigned)
276    : //name_("*bad-symbol*"), module_("*bad-module*"),
277     module_(NULL), type_(ST_UNKNOWN), linkage_(SL_UNKNOWN), addr_(0), sec_(NULL), size_(0), upPtr_(NULL),
278     isInDynsymtab_(false), isInSymtab_(true), tag_(TAG_UNKNOWN), retType_(NULL), moduleName_(""), 
279     vars_(NULL), params_(NULL) {
280 }
281 #endif
282
283 inline
284 bool
285 Symbol::operator==(const Symbol& s) const {
286     // explicitly ignore tags when comparing symbols
287     return ((module_  == s.module_)
288         && (type_    == s.type_)
289         && (linkage_ == s.linkage_)
290         && (addr_    == s.addr_)
291         && (sec_     == s.sec_)
292         && (size_    == s.size_)
293 #if 0
294         && (upPtr_    == s.upPtr_)
295 #endif
296     && (isInDynsymtab_ == s.isInDynsymtab_)
297     && (isInSymtab_ == s.isInSymtab_)
298         && (retType_    == s.retType_)
299         && (mangledNames == s.mangledNames)
300         && (prettyNames == s.prettyNames)
301         && (typedNames == s.typedNames)
302         && (moduleName_ == s.moduleName_));
303 }
304
305 }//namespace SymtabAPI
306 }//namespace Dyninst
307
308 #endif /* !defined(_Symbol_h_) */