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