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