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