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