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