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