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