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