Fixes Windows build errors cause by my last commit
[dyninst.git] / symtabAPI / h / Symtab.h
1 /*
2  * Copyright (c) 1996-2009 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 #ifndef __SYMTAB_H__
33 #define __SYMTAB_H__
34
35 #include <set>
36
37 #include "Symbol.h"
38 #include "Module.h"
39 #include "Region.h"
40
41 #include "Annotatable.h"
42 #include "Serialization.h"
43
44 #include "ProcReader.h"
45
46 class MappedFile;
47
48 namespace Dyninst {
49 namespace SymtabAPI {
50
51 class Archive;
52 class builtInTypeCollection;
53
54 class ExceptionBlock;
55 class Object;
56 class localVar;
57 class relocationEntry;
58 class Type;
59
60 typedef Dyninst::ProcessReader MemRegReader;
61
62 class Symtab : public LookupInterface,
63                public Serializable,
64                public AnnotatableSparse
65 {
66
67    friend class Archive;
68    friend class Symbol;
69    friend class Function;
70    friend class Variable;
71    friend class Module;
72    friend class Region;
73    friend class emitElf;
74    friend class emitElf64;
75    friend class emitElfStatic;
76    friend class emitWin;
77    friend class Aggregate;
78    friend class relocationEntry;
79
80  public:
81
82    /***** Public Member Functions *****/
83    public:
84    SYMTAB_EXPORT Symtab(MappedFile *);
85
86    SYMTAB_EXPORT Symtab();
87
88    SYMTAB_EXPORT Symtab(const Symtab& obj);
89    SYMTAB_EXPORT Symtab(char *mem_image, size_t image_size, bool &err);
90
91    SYMTAB_EXPORT static bool openFile(Symtab *&obj, std::string filename);
92    SYMTAB_EXPORT static bool openFile(Symtab *&obj,char *mem_image, size_t size);
93    SYMTAB_EXPORT static Symtab *findOpenSymtab(std::string filename);
94    SYMTAB_EXPORT static bool closeSymtab(Symtab *);
95
96    SYMTAB_EXPORT Serializable * serialize_impl(SerializerBase *sb, 
97                    const char *tag = "Symtab") THROW_SPEC (SerializerError);
98    void rebuild_symbol_hashes(SerializerBase *);
99    void rebuild_funcvar_hashes(SerializerBase *);
100    void rebuild_module_hashes(SerializerBase *);
101    void rebuild_region_indexes(SerializerBase *) THROW_SPEC(SerializerError);
102    static bool setup_module_up_ptrs(SerializerBase *,Symtab *st);
103    static bool fixup_relocation_symbols(SerializerBase *,Symtab *st);
104
105    SYMTAB_EXPORT bool exportXML(std::string filename);
106    SYMTAB_EXPORT bool exportBin(std::string filename);
107    static Symtab *importBin(std::string filename);
108    SYMTAB_EXPORT bool getRegValueAtFrame(Address pc, 
109                                      Dyninst::MachRegister reg, 
110                                      Dyninst::MachRegisterVal &reg_result,
111                                      MemRegReader *reader);
112    SYMTAB_EXPORT bool hasStackwalkDebugInfo();
113
114    /**************************************
115     *** LOOKUP FUNCTIONS *****************
116     **************************************/
117
118    // Symbol
119
120    SYMTAB_EXPORT virtual bool findSymbol(std::vector<Symbol *> &ret, 
121                                          const std::string name,
122                                          Symbol::SymbolType sType = Symbol::ST_UNKNOWN,
123                                          NameType nameType = anyName,
124                                          bool isRegex = false, 
125                                          bool checkCase = false);
126    SYMTAB_EXPORT virtual bool getAllSymbols(std::vector<Symbol *> &ret);
127    SYMTAB_EXPORT virtual bool getAllSymbolsByType(std::vector<Symbol *> &ret, 
128          Symbol::SymbolType sType);
129
130    std::vector<Symbol *> *findSymbolByOffset(Offset);
131
132    // Return all undefined symbols in the binary. Currently used for finding
133    // the .o's in a static archive that have definitions of these symbols
134    SYMTAB_EXPORT bool getAllUndefinedSymbols(std::vector<Symbol *> &ret);
135
136    // Inversely, return all non-undefined symbols in the binary
137    SYMTAB_EXPORT bool getAllDefinedSymbols(std::vector<Symbol *> &ret);
138
139    // Function
140
141    SYMTAB_EXPORT bool findFuncByEntryOffset(Function *&ret, const Offset offset);
142    SYMTAB_EXPORT bool findFunctionsByName(std::vector<Function *> &ret, const std::string name,
143                                           NameType nameType = anyName, 
144                                           bool isRegex = false,
145                                           bool checkCase = true);
146    SYMTAB_EXPORT bool getAllFunctions(std::vector<Function *>&ret);
147    SYMTAB_EXPORT bool getContainingFunction(Offset offset, Function* &func);
148
149    // Variable
150    SYMTAB_EXPORT bool findVariableByOffset(Variable *&ret, const Offset offset);
151    SYMTAB_EXPORT bool findVariablesByName(std::vector<Variable *> &ret, const std::string name,
152                                           NameType nameType = anyName, 
153                                           bool isRegex = false, 
154                                           bool checkCase = true);
155    SYMTAB_EXPORT bool getAllVariables(std::vector<Variable *> &ret);
156
157    // Module
158
159    SYMTAB_EXPORT bool getAllModules(std::vector<Module *>&ret);
160    SYMTAB_EXPORT bool findModuleByOffset(Module *&ret, Offset off);
161    SYMTAB_EXPORT bool findModuleByName(Module *&ret, const std::string name);
162    SYMTAB_EXPORT Module *getDefaultModule();
163
164    // Region
165
166    SYMTAB_EXPORT bool getCodeRegions(std::vector<Region *>&ret);
167    SYMTAB_EXPORT bool getDataRegions(std::vector<Region *>&ret);
168    SYMTAB_EXPORT bool getAllRegions(std::vector<Region *>&ret);
169    SYMTAB_EXPORT bool getAllNewRegions(std::vector<Region *>&ret);
170    //  change me to use a hash
171    SYMTAB_EXPORT bool findRegion(Region *&ret, std::string regname);
172    SYMTAB_EXPORT bool findRegion(Region *&ret, const Offset addr, const unsigned long size);
173    SYMTAB_EXPORT bool findRegionByEntry(Region *&ret, const Offset offset);
174    SYMTAB_EXPORT Region *findEnclosingRegion(const Offset offset);
175
176    // Exceptions
177    SYMTAB_EXPORT bool findException(ExceptionBlock &excp,Offset addr);
178    SYMTAB_EXPORT bool getAllExceptions(std::vector<ExceptionBlock *> &exceptions);
179    SYMTAB_EXPORT bool findCatchBlock(ExceptionBlock &excp, Offset addr, 
180          unsigned size = 0);
181
182    // Relocation entries
183    SYMTAB_EXPORT bool getFuncBindingTable(std::vector<relocationEntry> &fbt) const;
184    SYMTAB_EXPORT bool updateFuncBindingTable(Offset stub_addr, Offset plt_addr);
185
186    /**************************************
187     *** SYMBOL ADDING FUNCS **************
188     **************************************/
189
190    SYMTAB_EXPORT bool addSymbol(Symbol *newsym);
191    SYMTAB_EXPORT bool addSymbol(Symbol *newSym, Symbol *referringSymbol);
192    SYMTAB_EXPORT Function *createFunction(std::string name, Offset offset, size_t size, Module *mod = NULL);
193    SYMTAB_EXPORT Variable *createVariable(std::string name, Offset offset, size_t size, Module *mod = NULL);
194
195    SYMTAB_EXPORT bool deleteFunction(Function *func);
196    SYMTAB_EXPORT bool deleteVariable(Variable *var);
197
198
199    /*****Query Functions*****/
200    SYMTAB_EXPORT bool isExec() const;
201    SYMTAB_EXPORT bool isStripped();
202    SYMTAB_EXPORT ObjectType getObjectType() const;
203    SYMTAB_EXPORT Dyninst::Architecture getArchitecture();
204    SYMTAB_EXPORT bool isCode(const Offset where) const;
205    SYMTAB_EXPORT bool isData(const Offset where) const;
206    SYMTAB_EXPORT bool isValidOffset(const Offset where) const;
207
208    SYMTAB_EXPORT bool isNativeCompiler() const;
209    SYMTAB_EXPORT bool getMappedRegions(std::vector<Region *> &mappedRegs) const;
210
211    /***** Line Number Information *****/
212    SYMTAB_EXPORT bool getAddressRanges(std::vector<std::pair<Offset, Offset> >&ranges,
213          std::string lineSource, unsigned int LineNo);
214    SYMTAB_EXPORT bool getSourceLines(std::vector<Statement *> &lines, 
215          Offset addressInRange);
216    SYMTAB_EXPORT bool addLine(std::string lineSource, unsigned int lineNo,
217          unsigned int lineOffset, Offset lowInclAddr,
218          Offset highExclAddr);
219    SYMTAB_EXPORT bool addAddressRange(Offset lowInclAddr, Offset highExclAddr, std::string lineSource,
220          unsigned int lineNo, unsigned int lineOffset = 0);
221    SYMTAB_EXPORT void setTruncateLinePaths(bool value);
222    SYMTAB_EXPORT bool getTruncateLinePaths();
223
224    /***** Type Information *****/
225    SYMTAB_EXPORT virtual bool findType(Type *&type, std::string name);
226    SYMTAB_EXPORT virtual Type *findType(unsigned type_id);
227    SYMTAB_EXPORT virtual bool findVariableType(Type *&type, std::string name);
228
229    SYMTAB_EXPORT bool addType(Type *typ);
230
231    SYMTAB_EXPORT static std::vector<Type *> *getAllstdTypes();
232    SYMTAB_EXPORT static std::vector<Type *> *getAllbuiltInTypes();
233
234    SYMTAB_EXPORT void parseTypesNow();
235
236    /***** Local Variable Information *****/
237    SYMTAB_EXPORT bool findLocalVariable(std::vector<localVar *>&vars, std::string name);
238
239    /***** Relocation Sections *****/
240    SYMTAB_EXPORT bool hasRel() const;
241    SYMTAB_EXPORT bool hasRela() const;
242    SYMTAB_EXPORT bool hasReldyn() const;
243    SYMTAB_EXPORT bool hasReladyn() const;
244    SYMTAB_EXPORT bool hasRelplt() const;
245    SYMTAB_EXPORT bool hasRelaplt() const;
246    
247    SYMTAB_EXPORT bool isStaticBinary() const;
248
249    /***** Write Back binary functions *****/
250    SYMTAB_EXPORT bool emitSymbols(Object *linkedFile, std::string filename, unsigned flag = 0);
251    SYMTAB_EXPORT bool addRegion(Offset vaddr, void *data, unsigned int dataSize, 
252          std::string name, Region::RegionType rType_, bool loadable = false,
253          unsigned long memAlign = sizeof(unsigned), bool tls = false);
254    SYMTAB_EXPORT bool addRegion(Region *newreg);
255    SYMTAB_EXPORT bool emit(std::string filename, unsigned flag = 0);
256
257    SYMTAB_EXPORT void addDynLibSubstitution(std::string oldName, std::string newName);
258    SYMTAB_EXPORT std::string getDynLibSubstitution(std::string name);
259
260    SYMTAB_EXPORT bool getSegments(std::vector<Segment> &segs) const;
261    
262    SYMTAB_EXPORT void fixup_code_and_data(Offset newImageOffset,
263                                           Offset newImageLength,
264                                           Offset newDataOffset,
265                                           Offset newDataLength);
266    SYMTAB_EXPORT bool fixup_RegionAddr(const char* name, Offset memOffset, long memSize);
267    SYMTAB_EXPORT bool fixup_SymbolAddr(const char* name, Offset newOffset);
268    SYMTAB_EXPORT bool updateRegion(const char* name, void *buffer, unsigned size);
269    SYMTAB_EXPORT bool updateCode(void *buffer, unsigned size);
270    SYMTAB_EXPORT bool updateData(void *buffer, unsigned size);
271    SYMTAB_EXPORT Offset getFreeOffset(unsigned size);
272
273    SYMTAB_EXPORT bool addLibraryPrereq(std::string libname);
274    SYMTAB_EXPORT bool addSysVDynamic(long name, long value);
275
276    SYMTAB_EXPORT bool addLinkingResource(Archive *library);
277    SYMTAB_EXPORT bool getLinkingResources(std::vector<Archive *> &libs);
278
279    SYMTAB_EXPORT bool addExternalSymbolReference(Symbol *externalSym, Region *localRegion, relocationEntry localRel);
280
281    /***** Data Member Access *****/
282    SYMTAB_EXPORT std::string file() const;
283    SYMTAB_EXPORT std::string name() const;
284    SYMTAB_EXPORT std::string memberName() const;
285
286    SYMTAB_EXPORT char *mem_image() const;
287
288    SYMTAB_EXPORT Offset imageOffset() const;
289    SYMTAB_EXPORT Offset dataOffset() const;
290    SYMTAB_EXPORT Offset dataLength() const;
291    SYMTAB_EXPORT Offset imageLength() const;
292    //   SYMTAB_EXPORT char*  image_ptr ()  const;
293    //   SYMTAB_EXPORT char*  data_ptr ()  const;
294    SYMTAB_EXPORT Offset getInitOffset();
295    SYMTAB_EXPORT Offset getFiniOffset();
296
297    SYMTAB_EXPORT const char*  getInterpreterName() const;
298
299    SYMTAB_EXPORT unsigned getAddressWidth() const;
300    SYMTAB_EXPORT Offset getLoadOffset() const;
301    SYMTAB_EXPORT Offset getEntryOffset() const;
302    SYMTAB_EXPORT Offset getBaseOffset() const;
303    SYMTAB_EXPORT Offset getTOCoffset() const;
304    SYMTAB_EXPORT Address getLoadAddress();
305
306    SYMTAB_EXPORT std::string getDefaultNamespacePrefix() const;
307
308    SYMTAB_EXPORT unsigned getNumberofRegions() const;
309    SYMTAB_EXPORT unsigned getNumberofSymbols() const;
310
311    SYMTAB_EXPORT std::vector<std::string> &getDependencies();
312
313    SYMTAB_EXPORT Archive *getParentArchive() const;
314
315    /***** Error Handling *****/
316    SYMTAB_EXPORT static SymtabError getLastSymtabError();
317    SYMTAB_EXPORT static std::string printError(SymtabError serr);
318
319    SYMTAB_EXPORT ~Symtab();
320
321    bool delSymbol(Symbol *sym) { return deleteSymbol(sym); }
322    bool deleteSymbol(Symbol *sym); 
323
324    static builtInTypeCollection *builtInTypes;
325    static typeCollection *stdTypes;
326
327    Symbol *getSymbolByIndex(unsigned);
328    protected:
329    Symtab(std::string filename, std::string member_name, Offset offset, bool &err, void *base = NULL);
330    Symtab(char *img, size_t size, std::string member_name, Offset offset, bool &err, void *base = NULL);
331
332    /***** Private Member Functions *****/
333    private:
334    SYMTAB_EXPORT Symtab(std::string filename, bool &err); 
335
336    SYMTAB_EXPORT bool extractInfo(Object *linkedFile);
337
338    // Parsing code
339
340    bool extractSymbolsFromFile(Object *linkedFile, std::vector<Symbol *> &raw_syms);
341    bool fixSymModules(std::vector<Symbol *> &raw_syms);
342    bool demangleSymbols(std::vector<Symbol *> &rawsyms);
343    bool createIndices(std::vector<Symbol *> &raw_syms);
344    bool createAggregates();
345
346    bool fixSymModule(Symbol *&sym);
347    bool demangleSymbol(Symbol *&sym);
348    bool addSymbolToIndices(Symbol *&sym);
349    bool addSymbolToAggregates(Symbol *&sym);
350    bool doNotAggregate(Symbol *&sym);
351    bool updateIndices(Symbol *sym, std::string newName, NameType nameType);
352
353
354    void setModuleLanguages(dyn_hash_map<std::string, supportedLanguages> *mod_langs);
355
356    void setupTypes();
357    static void setupStdTypes();
358
359    bool buildDemangledName( const std::string &mangled, 
360          std::string &pretty,
361          std::string &typed,
362          bool nativeCompiler, 
363          supportedLanguages lang );
364
365    // Change the type of a symbol after the fact
366    bool changeType(Symbol *sym, Symbol::SymbolType oldType);
367
368    bool changeSymbolOffset(Symbol *sym, Offset newOffset);
369    bool deleteSymbolFromIndices(Symbol *sym);
370
371    bool changeAggregateOffset(Aggregate *agg, Offset oldOffset, Offset newOffset);
372    bool deleteAggregate(Aggregate *agg);
373
374    // Used by binaryEdit.C...
375  public:
376    SYMTAB_EXPORT bool canBeShared();
377    SYMTAB_EXPORT Module *getOrCreateModule(const std::string &modName, 
378                                            const Offset modAddr);
379
380  public:
381    //Only valid on ELF formats
382    SYMTAB_EXPORT Offset getElfDynamicOffset();
383    
384  private:
385    void createDefaultModule();
386
387    Module *newModule(const std::string &name, const Offset addr, supportedLanguages lang);
388    
389    //bool buildFunctionLists(std::vector <Symbol *> &raw_funcs);
390    //void enterFunctionInTables(Symbol *func, bool wasSymtab);
391
392
393    bool addSymtabVariables();
394
395    void checkPPC64DescriptorSymbols(Object *linkedFile);
396
397
398    void parseLineInformation();
399    void parseTypes();
400    bool setDefaultNamespacePrefix(std::string &str);
401
402    bool addUserRegion(Region *newreg);
403    bool addUserType(Type *newtypeg);
404
405    /***** Private Data Members *****/
406    private:
407    std::string member_name_;
408    Offset member_offset_;
409    Archive * parentArchive_;
410    MappedFile *mf;
411    MappedFile *mfForDebugInfo;
412
413    Offset imageOffset_;
414    unsigned imageLen_;
415    Offset dataOffset_;
416    unsigned dataLen_;
417
418    bool is_a_out;
419    Offset main_call_addr_; // address of call to main()
420
421    bool nativeCompiler;
422
423    unsigned address_width_;
424    char *code_ptr_;
425    char *data_ptr_;
426    std::string interpreter_name_;
427    Offset entry_address_;
428    Offset base_address_;
429    Offset load_address_;
430    Offset toc_offset_;
431    ObjectType object_type_;
432    bool is_eel_;
433    std::vector<Segment> segments_;
434    //  make sure is_a_out is set before calling symbolsToFunctions
435
436    // A std::vector of all Symtabs. Used to avoid duplicating
437    // a Symtab that already exists.
438    static std::vector<Symtab *> allSymtabs;
439    std::string defaultNamespacePrefix;
440
441    //sections
442    unsigned no_of_sections;
443    std::vector<Region *> regions_;
444    std::vector<Region *> codeRegions_;
445    std::vector<Region *> dataRegions_;
446    dyn_hash_map <Offset, Region *> regionsByEntryAddr;
447
448    //Point where new loadable sections will be inserted
449    unsigned newSectionInsertPoint;
450
451    //symbols
452    unsigned no_of_symbols;
453
454    // Indices
455
456    std::vector<Symbol *> everyDefinedSymbol;
457    // Subset of the above
458    std::vector<Symbol *> userAddedSymbols;
459    // hashtable for looking up undefined symbols in the dynamic symbol
460    // tale. Entries are referred by the relocation table entries
461    // NOT a subset of everyDefinedSymbol
462    std::map <std::string, std::vector<Symbol *> > undefDynSyms;
463
464    // Symbols by offsets in the symbol table
465    dyn_hash_map <Offset, std::vector<Symbol *> > symsByOffset;
466
467    // The raw name from the symbol table
468    dyn_hash_map <std::string, std::vector<Symbol *> > symsByMangledName;
469
470    // The name after we've run it through the demangler
471    dyn_hash_map <std::string, std::vector<Symbol *> > symsByPrettyName;
472
473    // The name after we've derived the parameter types
474    dyn_hash_map <std::string, std::vector<Symbol *> > symsByTypedName;
475
476    // We also need per-Aggregate indices
477    bool sorted_everyFunction;
478    std::vector<Function *> everyFunction;
479    // Since Functions are unique by address we require this structure to
480    // efficiently track them.
481    dyn_hash_map <Offset, Function *> funcsByOffset;
482
483    // Similar for Variables
484    std::vector<Variable *> everyVariable;
485    dyn_hash_map <Offset, Variable *> varsByOffset;
486
487    // For now, skip the index-by-name structures. We can use the Symbol
488    // ones instead. 
489    /*
490    dyn_hash_map <std::string, std::vector<Function *> *> funcsByMangledName;
491    dyn_hash_map <std::string, std::vector<Function *> *> funcsByPrettyName;
492    dyn_hash_map <std::string, std::vector<Function *> *> funcsByTypedName;
493    */
494
495    //dyn_hash_map <Offset, std::vector<Function *> > funcsByEntryAddr;
496    // note, a prettyName is not unique, it may map to a function appearing
497    // in several modules.  Also only contains instrumentable functions....
498    //dyn_hash_map <std::string, std::vector<Function *>*> funcsByPretty;
499    // Hash table holding functions by mangled name.
500    // Should contain same functions as funcsByPretty....
501    //dyn_hash_map <std::string, std::vector<Function *>*> funcsByMangled;
502    // A way to iterate over all the functions efficiently
503    //std::vector<Symbol *> everyUniqueFunction;
504    //std::vector<Function *> allFunctions;
505    // And the counterpart "ones that are there right away"
506    //std::vector<Symbol *> exportedFunctions;
507
508    //dyn_hash_map <Address, Function *> funcsByAddr;
509    dyn_hash_map <std::string, Module *> modsByFileName;
510    dyn_hash_map <std::string, Module *> modsByFullName;
511    std::vector<Module *> _mods;
512
513    // Variables indexed by pretty (non-mangled) name
514    /*
515    dyn_hash_map <std::string, std::vector <Symbol *> *> varsByPretty;
516    dyn_hash_map <std::string, std::vector <Symbol *> *> varsByMangled;
517    dyn_hash_map <Offset, Symbol *> varsByAddr;
518    std::vector<Symbol *> everyUniqueVariable;
519    */
520
521    //dyn_hash_map <std::string, std::vector <Symbol *> *> modsByName;
522    //std::vector<Module *> _mods;
523
524
525    std::vector<relocationEntry > relocation_table_;
526    std::vector<ExceptionBlock *> excpBlocks;
527
528    std::vector<std::string> deps_;
529
530    // This set is used during static linking to satisfy dependencies
531    std::vector<Archive *> linkingResources_;
532
533    // This set represents Symtabs referenced by a new external Symbol
534    bool getExplicitSymtabRefs(std::set<Symtab *> &refs);
535    std::set<Symtab *> explicitSymtabRefs_;
536
537    //Line Information valid flag;
538    bool isLineInfoValid_;
539    //type info valid flag
540    bool isTypeInfoValid_;
541
542    int nlines_;
543    unsigned long fdptr_;
544    char *lines_;
545    char *stabstr_;
546    int nstabs_;
547    void *stabs_;
548    char *stringpool_;
549
550    //Relocation sections
551    bool hasRel_;
552    bool hasRela_;
553    bool hasReldyn_;
554    bool hasReladyn_;
555    bool hasRelplt_;
556    bool hasRelaplt_;
557
558    bool isStaticBinary_;
559
560
561    //Don't use obj_private, use getObject() instead.
562  public:
563    Object *getObject();
564  private:
565    Object *obj_private;
566
567    // dynamic library name substitutions
568    std::map <std::string, std::string> dynLibSubs;
569
570    public:
571    static Type *type_Error;
572    static Type *type_Untyped;
573
574  private:
575     unsigned _ref_cnt;
576
577  public:
578    /********************************************************************/
579    /**** DEPRECATED ****************************************************/
580    /********************************************************************/
581    dyn_hash_map <std::string, Module *> &getModsByFileName()
582    {
583       return modsByFileName;
584    }
585    dyn_hash_map <std::string, Module *> &getModsByFullName()
586    {
587       return modsByFullName;
588    }
589    
590    SYMTAB_EXPORT bool findFuncByEntryOffset(std::vector<Symbol *>&ret, const Offset offset);
591    SYMTAB_EXPORT virtual bool findSymbolByType(std::vector<Symbol *> &ret, 
592                                                const std::string name,
593                                                Symbol::SymbolType sType, 
594                                                bool isMangled = false,
595                                                bool isRegex = false, 
596                                                bool checkCase = false);
597 };
598
599 /**
600  * Used to represent something like a C++ try/catch block.  
601  * Currently only used on Linux/x86
602  **/
603 SYMTAB_EXPORT  std::ostream &operator<<(std::ostream &os, const ExceptionBlock &q);
604
605 class ExceptionBlock : public Serializable, public AnnotatableSparse {
606
607    public:
608           SYMTAB_EXPORT Serializable * serialize_impl(SerializerBase *sb, 
609                           const char *tag = "exceptionBlock") THROW_SPEC (SerializerError);
610       SYMTAB_EXPORT ExceptionBlock(Offset tStart, unsigned tSize, Offset cStart);
611       SYMTAB_EXPORT ExceptionBlock(Offset cStart);
612       SYMTAB_EXPORT ExceptionBlock(const ExceptionBlock &eb);
613       SYMTAB_EXPORT ~ExceptionBlock();
614       SYMTAB_EXPORT ExceptionBlock();
615
616       SYMTAB_EXPORT bool hasTry() const;
617       SYMTAB_EXPORT Offset tryStart() const;
618       SYMTAB_EXPORT Offset tryEnd() const;
619       SYMTAB_EXPORT Offset trySize() const;
620       SYMTAB_EXPORT Offset catchStart() const;
621       SYMTAB_EXPORT bool contains(Offset a) const;
622
623       friend SYMTAB_EXPORT std::ostream &operator<<(std::ostream &os, const ExceptionBlock &q);
624    private:
625       Offset tryStart_;
626       unsigned trySize_;
627       Offset catchStart_;
628       bool hasTry_;
629 };
630
631 // relocation information for calls to functions not in this image
632 // on sparc-solaris: target_addr_ = rel_addr_ = PLT entry addr
633 // on x86-solaris: target_addr_ = PLT entry addr
634 //                 rel_addr_ =  GOT entry addr  corr. to PLT_entry
635 SYMTAB_EXPORT std::ostream &operator<<(std::ostream &os, const relocationEntry &q);
636
637 class relocationEntry : public Serializable, public AnnotatableSparse {
638    public:
639
640       SYMTAB_EXPORT relocationEntry();
641       SYMTAB_EXPORT relocationEntry(Offset ta, Offset ra, Offset add, 
642                           std::string n, Symbol *dynref = NULL, unsigned long relType = 0);
643       SYMTAB_EXPORT relocationEntry(Offset ta, Offset ra, std::string n, 
644                           Symbol *dynref = NULL, unsigned long relType = 0);
645       SYMTAB_EXPORT relocationEntry(Offset ra, std::string n, Symbol *dynref = NULL, 
646                           unsigned long relType = 0, Region::RegionType rtype = Region::RT_REL);
647       SYMTAB_EXPORT relocationEntry(Offset ta, Offset ra, Offset add,
648                           std::string n, Symbol *dynref = NULL, unsigned long relType = 0,
649                           Region::RegionType rtype = Region::RT_REL);
650
651       SYMTAB_EXPORT const relocationEntry& operator= (const relocationEntry &ra);
652
653           SYMTAB_EXPORT Serializable * serialize_impl(SerializerBase *sb, 
654                           const char *tag = "relocationEntry") THROW_SPEC (SerializerError);
655
656       SYMTAB_EXPORT Offset target_addr() const;
657       SYMTAB_EXPORT Offset rel_addr() const;
658       SYMTAB_EXPORT Offset addend() const;
659       SYMTAB_EXPORT Region::RegionType regionType() const;
660       SYMTAB_EXPORT const std::string &name() const;
661       SYMTAB_EXPORT Symbol *getDynSym() const;
662       SYMTAB_EXPORT bool addDynSym(Symbol *dynref);
663       SYMTAB_EXPORT unsigned long getRelType() const;
664
665       SYMTAB_EXPORT void setTargetAddr(const Offset);
666       SYMTAB_EXPORT void setRelAddr(const Offset);
667       SYMTAB_EXPORT void setAddend(const Offset);
668       SYMTAB_EXPORT void setRegionType(const Region::RegionType);
669       SYMTAB_EXPORT void setName(const std::string &newName);
670
671       // dump output.  Currently setup as a debugging aid, not really
672       //  for object persistance....
673       //SYMTAB_EXPORT std::ostream & operator<<(std::ostream &s) const;
674       friend SYMTAB_EXPORT std::ostream &operator<<(std::ostream &os, const relocationEntry &q);
675
676       enum {pltrel = 1, dynrel = 2} relocationType;
677       SYMTAB_EXPORT bool operator==(const relocationEntry &) const;
678
679       // Architecture-specific functions
680       SYMTAB_EXPORT static unsigned long getGlobalRelType(unsigned addressWidth);
681       static const char *relType2Str(unsigned long r, unsigned addressWidth = sizeof(Address));
682
683    private:
684       Offset target_addr_;      // target address of call instruction 
685       Offset rel_addr_;         // address of corresponding relocation entry 
686       Offset addend_;       // addend (from RELA entries)
687       Region::RegionType rtype_;        // RT_REL vs. RT_RELA
688       std::string  name_;
689       Symbol *dynref_;
690       unsigned long relType_;
691 };
692
693 #if 1
694 #if 1
695 SYMTAB_EXPORT SerializerBase *nonpublic_make_bin_symtab_serializer(Symtab *t, std::string file);
696 SYMTAB_EXPORT SerializerBase *nonpublic_make_bin_symtab_deserializer(Symtab *t, std::string file);
697 SYMTAB_EXPORT void nonpublic_free_bin_symtab_serializer(SerializerBase *sb);
698 #else
699
700 template <class T>
701 SerializerBase *nonpublic_make_bin_serializer(T *t, std::string file)
702 {
703         SerializerBin<T> *ser;
704         ser = new SerializerBin<T>(t, "SerializerBin", file, sd_serialize, true);
705         T *test_st = ser->getScope();
706         assert(test_st == t);
707         return ser;
708 }
709
710 template <class T>
711 SerializerBase *nonpublic_make_bin_deserializer(T *t, std::string file)
712 {
713         SerializerBin<T> *ser;
714         ser = new SerializerBin<T>(t, "DeserializerBin", file, sd_deserialize, true);
715         T *test_st = ser->getScope();
716         assert(test_st == t);
717         return ser;
718 }
719
720 template <class T>
721 void nonpublic_free_bin_serializer(SerializerBase *sb)
722 {
723         SerializerBin<T> *sbin = dynamic_cast<SerializerBin<T> *>(sb);
724         if (sbin)
725         {
726                 delete(sbin);
727         }
728         else
729                 fprintf(stderr, "%s[%d]:  FIXME\n", FILE__, __LINE__);
730
731 }
732 #endif
733 #endif
734
735 }//namespace SymtabAPI
736
737 }//namespace Dyninst
738 #endif