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