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