windows build fixes and some more work on symtab serialization
[dyninst.git] / symtabAPI / h / Symtab.h
1 /*
2  * Copyright (c) 1996-2007 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
30  */
31
32 #ifndef __SYMTAB_H__
33 #define __SYMTAB_H__
34  
35 #include "Symbol.h"
36 #include "LineInformation.h"
37 #include "Region.h"
38
39 #include "Annotatable.h"
40 #include "Serialization.h"
41
42 class MappedFile;
43
44 namespace Dyninst{
45 namespace SymtabAPI{
46
47 class Archive;
48 class builtInTypeCollection;
49
50 class ExceptionBlock;
51 class Object;
52 class localVar;
53 class relocationEntry;
54
55 class MemRegReader {
56  public:
57    virtual bool ReadMem(Address addr, void *buffer, unsigned size) = 0;
58    virtual bool GetReg(MachRegister reg, MachRegisterVal &val) = 0;
59    virtual ~MemRegReader();
60 };
61
62 class Symtab : public LookupInterface,
63                public Serializable,
64                public AnnotatableSparse
65 {
66
67    friend class Archive;
68    friend class Symbol;
69    friend class Function;
70    friend class Variable;
71    friend class Module;
72    friend class Region;
73    friend class emitElf;
74    friend class emitElf64;
75    friend class emitWin;
76    friend class Aggregate;
77
78  public:
79
80    /***** Public Member Functions *****/
81    public:
82    SYMTAB_EXPORT Symtab(MappedFile *);
83
84    SYMTAB_EXPORT Symtab();
85
86    SYMTAB_EXPORT Symtab(const Symtab& obj);
87
88    SYMTAB_EXPORT static bool openFile(Symtab *&obj, std::string filename);
89    SYMTAB_EXPORT static bool openFile(Symtab *&obj,char *mem_image, size_t size);
90
91    SYMTAB_EXPORT 
92    void serialize(SerializerBase *sb, const char *tag = "Symtab") THROW_SPEC (SerializerError);
93    static bool setup_module_up_ptrs(SerializerBase *,Symtab *st);
94    static bool fixup_relocation_symbols(SerializerBase *,Symtab *st);
95
96    SYMTAB_EXPORT bool exportXML(std::string filename);
97    SYMTAB_EXPORT bool exportBin(std::string filename);
98    static Symtab *importBin(std::string filename);
99    SYMTAB_EXPORT bool getRegValueAtFrame(Address pc, 
100                                      Dyninst::MachRegister reg, 
101                                      Dyninst::MachRegisterVal &reg_result,
102                                      MemRegReader *reader);
103    SYMTAB_EXPORT bool hasStackwalkDebugInfo();
104
105    /**************************************
106     *** LOOKUP FUNCTIONS *****************
107     **************************************/
108
109    // Symbol
110
111    SYMTAB_EXPORT virtual bool findSymbolByType(std::vector<Symbol *> &ret, 
112                                                const std::string name,
113                                                Symbol::SymbolType sType, 
114                                                NameType nameType = anyName,
115                                                bool isRegex = false, 
116                                                bool checkCase = false);
117    SYMTAB_EXPORT virtual bool getAllSymbols(std::vector<Symbol *> &ret);
118    SYMTAB_EXPORT virtual bool getAllSymbolsByType(std::vector<Symbol *> &ret, 
119          Symbol::SymbolType sType);
120
121    Symbol *findSymbolByIndex(unsigned);
122
123    // Return all undefined symbols in the binary. Currently used for finding
124    // the .o's in a static archive that have definitions of these symbols
125    SYMTAB_EXPORT bool getAllUndefinedSymbols(std::vector<Symbol *> &ret);
126
127    // Inversely, return all non-undefined symbols in the binary
128    SYMTAB_EXPORT bool getAllDefinedSymbols(std::vector<Symbol *> &ret);
129
130    // Function
131
132    SYMTAB_EXPORT bool findFuncByEntryOffset(Function *&ret, const Offset offset);
133    SYMTAB_EXPORT bool findFunctionsByName(std::vector<Function *> &ret, const std::string name,
134                                       NameType nameType = anyName, 
135                                       bool isRegex = false,
136                                       bool checkCase = true);
137    SYMTAB_EXPORT bool getAllFunctions(std::vector<Function *>&ret);
138    SYMTAB_EXPORT bool getContainingFunction(Offset offset, Function* &func);
139
140    // Variable
141    SYMTAB_EXPORT bool findVariableByOffset(Variable *&ret, const Offset offset);
142    SYMTAB_EXPORT bool findVariablesByName(std::vector<Variable *> &ret, const std::string name,
143                                       NameType nameType = anyName, 
144                                       bool isRegex = false, 
145                                       bool checkCase = true);
146    SYMTAB_EXPORT bool getAllVariables(std::vector<Variable *> &ret);
147
148    // Module
149
150    SYMTAB_EXPORT bool getAllModules(std::vector<Module *>&ret);
151    SYMTAB_EXPORT bool findModuleByOffset(Module *&ret, Offset off);
152    SYMTAB_EXPORT bool findModuleByName(Module *&ret, const std::string name);
153    SYMTAB_EXPORT Module *getDefaultModule();
154
155    // Region
156
157    SYMTAB_EXPORT bool getCodeRegions(std::vector<Region *>&ret);
158    SYMTAB_EXPORT bool getDataRegions(std::vector<Region *>&ret);
159    SYMTAB_EXPORT bool getAllRegions(std::vector<Region *>&ret);
160    SYMTAB_EXPORT bool getAllNewRegions(std::vector<Region *>&ret);
161    //  change me to use a hash
162    SYMTAB_EXPORT bool findRegion(Region *&ret, std::string regname);
163    SYMTAB_EXPORT bool findRegionByEntry(Region *&ret, const Offset offset);
164    SYMTAB_EXPORT Region *findEnclosingRegion(const Offset offset);
165
166    // Exceptions
167    SYMTAB_EXPORT bool findException(ExceptionBlock &excp,Offset addr);
168    SYMTAB_EXPORT bool getAllExceptions(std::vector<ExceptionBlock *> &exceptions);
169    SYMTAB_EXPORT bool findCatchBlock(ExceptionBlock &excp, Offset addr, 
170          unsigned size = 0);
171
172    // Relocation entries
173    SYMTAB_EXPORT bool getFuncBindingTable(std::vector<relocationEntry> &fbt) const;
174
175    /**************************************
176     *** SYMBOL ADDING FUNCS **************
177     **************************************/
178
179    SYMTAB_EXPORT bool addSymbol(Symbol *newsym);
180    SYMTAB_EXPORT bool addSymbol(Symbol *newSym, Symbol *referringSymbol);
181    SYMTAB_EXPORT Function *createFunction(std::string name, Offset offset, size_t size, Module *mod = NULL);
182    SYMTAB_EXPORT Variable *createVariable(std::string name, Offset offset, size_t size, Module *mod = NULL);
183
184    SYMTAB_EXPORT bool deleteFunction(Function *func);
185    SYMTAB_EXPORT bool deleteVariable(Variable *var);
186
187
188    /*****Query Functions*****/
189    SYMTAB_EXPORT bool isExec() const;
190    SYMTAB_EXPORT bool isStripped();
191    SYMTAB_EXPORT ObjectType getObjectType() const;
192
193    SYMTAB_EXPORT bool isCode(const Offset where) const;
194    SYMTAB_EXPORT bool isData(const Offset where) const;
195    SYMTAB_EXPORT bool isValidOffset(const Offset where) const;
196
197    SYMTAB_EXPORT bool isNativeCompiler() const;
198    SYMTAB_EXPORT bool getMappedRegions(std::vector<Region *> &mappedRegs) const;
199
200    /***** Line Number Information *****/
201    SYMTAB_EXPORT bool getAddressRanges(std::vector<std::pair<Offset, Offset> >&ranges,
202          std::string lineSource, unsigned int LineNo);
203    SYMTAB_EXPORT bool getSourceLines(std::vector<LineNoTuple> &lines, 
204          Offset addressInRange);
205    SYMTAB_EXPORT bool addLine(std::string lineSource, unsigned int lineNo,
206          unsigned int lineOffset, Offset lowInclAddr,
207          Offset highExclAddr);
208    SYMTAB_EXPORT bool addAddressRange(Offset lowInclAddr, Offset highExclAddr, std::string lineSource,
209          unsigned int lineNo, unsigned int lineOffset = 0);
210
211    /***** Type Information *****/
212    SYMTAB_EXPORT virtual bool findType(Type *&type, std::string name);
213    SYMTAB_EXPORT virtual Type *findType(unsigned type_id);
214    SYMTAB_EXPORT virtual bool findVariableType(Type *&type, std::string name);
215
216    SYMTAB_EXPORT bool addType(Type *typ);
217
218    SYMTAB_EXPORT static std::vector<Type *> *getAllstdTypes();
219    SYMTAB_EXPORT static std::vector<Type *> *getAllbuiltInTypes();
220
221    SYMTAB_EXPORT void parseTypesNow();
222
223    /***** Local Variable Information *****/
224    SYMTAB_EXPORT bool findLocalVariable(std::vector<localVar *>&vars, std::string name);
225
226    /***** Relocation Sections *****/
227    SYMTAB_EXPORT bool hasRel() const;
228    SYMTAB_EXPORT bool hasRela() const;
229
230    /***** Write Back binary functions *****/
231    SYMTAB_EXPORT bool emitSymbols(Object *linkedFile, std::string filename, unsigned flag = 0);
232    SYMTAB_EXPORT bool addRegion(Offset vaddr, void *data, unsigned int dataSize, 
233          std::string name, Region::RegionType rType_, bool loadable = false);
234    SYMTAB_EXPORT bool addRegion(Region *newreg);
235    SYMTAB_EXPORT bool emit(std::string filename, unsigned flag = 0);
236
237    SYMTAB_EXPORT void addDynLibSubstitution(std::string oldName, std::string newName);
238    SYMTAB_EXPORT std::string getDynLibSubstitution(std::string name);
239
240    SYMTAB_EXPORT bool getSegments(std::vector<Segment> &segs) const;
241    SYMTAB_EXPORT bool updateCode(void *buffer, unsigned size);
242    SYMTAB_EXPORT bool updateData(void *buffer, unsigned size);
243    SYMTAB_EXPORT Offset getFreeOffset(unsigned size);
244
245    /***** Data Member Access *****/
246    SYMTAB_EXPORT std::string file() const;
247    SYMTAB_EXPORT std::string name() const;
248
249    SYMTAB_EXPORT char *mem_image() const;
250
251    SYMTAB_EXPORT Offset imageOffset() const;
252    SYMTAB_EXPORT Offset dataOffset() const;
253    SYMTAB_EXPORT Offset dataLength() const;
254    SYMTAB_EXPORT Offset imageLength() const;
255    //   SYMTAB_EXPORT char*  image_ptr ()  const;
256    //   SYMTAB_EXPORT char*  data_ptr ()  const;
257
258    SYMTAB_EXPORT const char*  getInterpreterName() const;
259
260    SYMTAB_EXPORT unsigned getAddressWidth() const;
261    SYMTAB_EXPORT Offset getLoadOffset() const;
262    SYMTAB_EXPORT Offset getEntryOffset() const;
263    SYMTAB_EXPORT Offset getBaseOffset() const;
264    SYMTAB_EXPORT Offset getTOCoffset() const;
265
266    SYMTAB_EXPORT std::string getDefaultNamespacePrefix() const;
267
268    SYMTAB_EXPORT unsigned getNumberofRegions() const;
269    SYMTAB_EXPORT unsigned getNumberofSymbols() const;
270
271    SYMTAB_EXPORT std::vector<std::string> &getDependencies();
272
273    /***** Error Handling *****/
274    SYMTAB_EXPORT static SymtabError getLastSymtabError();
275    SYMTAB_EXPORT static std::string printError(SymtabError serr);
276
277    SYMTAB_EXPORT ~Symtab();
278
279    bool delSymbol(Symbol *sym) { return deleteSymbol(sym); }
280    bool deleteSymbol(Symbol *sym); 
281
282    static builtInTypeCollection *builtInTypes;
283    static typeCollection *stdTypes;
284
285    Symbol *getSymbolByIndex(unsigned);
286    protected:
287    Symtab(std::string filename, std::string member_name, Offset offset, bool &err, void *base = NULL);
288    Symtab(char *img, size_t size, std::string member_name, Offset offset, bool &err, void *base = NULL);
289
290    /***** Private Member Functions *****/
291    private:
292    SYMTAB_EXPORT Symtab(std::string filename, bool &err); 
293    SYMTAB_EXPORT Symtab(char *mem_image, size_t image_size, bool &err);
294
295    SYMTAB_EXPORT bool extractInfo(Object *linkedFile);
296
297    // Parsing code
298
299    bool extractSymbolsFromFile(Object *linkedFile, std::vector<Symbol *> &raw_syms);
300    bool fixSymModules(std::vector<Symbol *> &raw_syms);
301    bool demangleSymbols(std::vector<Symbol *> &rawsyms);
302    bool createIndices(std::vector<Symbol *> &raw_syms);
303    bool createAggregates();
304
305    bool fixSymModule(Symbol *&sym);
306    bool demangleSymbol(Symbol *&sym);
307    bool addSymbolToIndices(Symbol *&sym);
308    bool addSymbolToAggregates(Symbol *&sym);
309    bool updateIndices(Symbol *sym, std::string newName, NameType nameType);
310
311
312    void setModuleLanguages(dyn_hash_map<std::string, supportedLanguages> *mod_langs);
313
314    void setupTypes();
315    static void setupStdTypes();
316
317    bool buildDemangledName( const std::string &mangled, 
318          std::string &pretty,
319          std::string &typed,
320          bool nativeCompiler, 
321          supportedLanguages lang );
322
323    // Change the type of a symbol after the fact
324    bool changeType(Symbol *sym, Symbol::SymbolType oldType);
325
326    bool changeSymbolOffset(Symbol *sym, Offset newOffset);
327    bool deleteSymbolFromIndices(Symbol *sym);
328
329    bool changeAggregateOffset(Aggregate *agg, Offset oldOffset, Offset newOffset);
330    bool deleteAggregate(Aggregate *agg);
331
332    // Used by binaryEdit.C...
333  public:
334    SYMTAB_EXPORT Module *getOrCreateModule(const std::string &modName, 
335                                            const Offset modAddr);
336  private:
337    void createDefaultModule();
338
339    Module *newModule(const std::string &name, const Offset addr, supportedLanguages lang);
340    
341    //bool buildFunctionLists(std::vector <Symbol *> &raw_funcs);
342    //void enterFunctionInTables(Symbol *func, bool wasSymtab);
343
344
345    bool addSymtabVariables();
346
347    void checkPPC64DescriptorSymbols(Object *linkedFile);
348
349
350    void parseLineInformation();
351    void parseTypes();
352    bool setDefaultNamespacePrefix(std::string &str);
353
354    bool addUserRegion(Region *newreg);
355    bool addUserType(Type *newtypeg);
356
357    /***** Private Data Members *****/
358    private:
359    std::string member_name_;
360    Offset member_offset_;
361    MappedFile *mf;
362    MappedFile *mfForDebugInfo;
363
364    Offset imageOffset_;
365    unsigned imageLen_;
366    Offset dataOffset_;
367    unsigned dataLen_;
368
369    bool is_a_out;
370    Offset main_call_addr_; // address of call to main()
371
372    bool nativeCompiler;
373
374    unsigned address_width_;
375    char *code_ptr_;
376    char *data_ptr_;
377    std::string interpreter_name_;
378    Offset entry_address_;
379    Offset base_address_;
380    Offset load_address_;
381    Offset toc_offset_;
382    ObjectType object_type_;
383    bool is_eel_;
384    std::vector<Segment> segments_;
385    //  make sure is_a_out is set before calling symbolsToFunctions
386
387    // A std::vector of all Symtabs. Used to avoid duplicating
388    // a Symtab that already exists.
389    static std::vector<Symtab *> allSymtabs;
390    std::string defaultNamespacePrefix;
391
392    //sections
393    unsigned no_of_sections;
394    std::vector<Region *> regions_;
395    std::vector<Region *> codeRegions_;
396    std::vector<Region *> dataRegions_;
397    dyn_hash_map <Offset, Region *> regionsByEntryAddr;
398
399    //Point where new loadable sections will be inserted
400    unsigned newSectionInsertPoint;
401
402    //symbols
403    unsigned no_of_symbols;
404
405    // Indices
406
407    std::vector<Symbol *> everyDefinedSymbol;
408    // Subset of the above
409    std::vector<Symbol *> userAddedSymbols;
410    // hashtable for looking up undefined symbols in the dynamic symbol
411    // tale. Entries are referred by the relocation table entries
412    // NOT a subset of everyDefinedSymbol
413    std::map <std::string, std::vector<Symbol *> > undefDynSyms;
414
415    // Symbols by offsets in the symbol table
416    dyn_hash_map <Offset, std::vector<Symbol *> > symsByOffset;
417
418    // The raw name from the symbol table
419    dyn_hash_map <std::string, std::vector<Symbol *> > symsByMangledName;
420
421    // The name after we've run it through the demangler
422    dyn_hash_map <std::string, std::vector<Symbol *> > symsByPrettyName;
423
424    // The name after we've derived the parameter types
425    dyn_hash_map <std::string, std::vector<Symbol *> > symsByTypedName;
426
427    // We also need per-Aggregate indices
428    bool sorted_everyFunction;
429    std::vector<Function *> everyFunction;
430    // Since Functions are unique by address we require this structure to
431    // efficiently track them.
432    dyn_hash_map <Offset, Function *> funcsByOffset;
433
434    // Similar for Variables
435    std::vector<Variable *> everyVariable;
436    dyn_hash_map <Offset, Variable *> varsByOffset;
437
438    // For now, skip the index-by-name structures. We can use the Symbol
439    // ones instead. 
440    /*
441    dyn_hash_map <std::string, std::vector<Function *> *> funcsByMangledName;
442    dyn_hash_map <std::string, std::vector<Function *> *> funcsByPrettyName;
443    dyn_hash_map <std::string, std::vector<Function *> *> funcsByTypedName;
444    */
445
446    //dyn_hash_map <Offset, std::vector<Function *> > funcsByEntryAddr;
447    // note, a prettyName is not unique, it may map to a function appearing
448    // in several modules.  Also only contains instrumentable functions....
449    //dyn_hash_map <std::string, std::vector<Function *>*> funcsByPretty;
450    // Hash table holding functions by mangled name.
451    // Should contain same functions as funcsByPretty....
452    //dyn_hash_map <std::string, std::vector<Function *>*> funcsByMangled;
453    // A way to iterate over all the functions efficiently
454    //std::vector<Symbol *> everyUniqueFunction;
455    //std::vector<Function *> allFunctions;
456    // And the counterpart "ones that are there right away"
457    //std::vector<Symbol *> exportedFunctions;
458
459    //dyn_hash_map <Address, Function *> funcsByAddr;
460    dyn_hash_map <std::string, Module *> modsByFileName;
461    dyn_hash_map <std::string, Module *> modsByFullName;
462    std::vector<Module *> _mods;
463
464    // Variables indexed by pretty (non-mangled) name
465    /*
466    dyn_hash_map <std::string, std::vector <Symbol *> *> varsByPretty;
467    dyn_hash_map <std::string, std::vector <Symbol *> *> varsByMangled;
468    dyn_hash_map <Offset, Symbol *> varsByAddr;
469    std::vector<Symbol *> everyUniqueVariable;
470    */
471
472    //dyn_hash_map <std::string, std::vector <Symbol *> *> modsByName;
473    //std::vector<Module *> _mods;
474
475
476    std::vector<relocationEntry > relocation_table_;
477    std::vector<ExceptionBlock *> excpBlocks;
478
479    std::vector<std::string> deps_;
480
481    //Line Information valid flag;
482    bool isLineInfoValid_;
483    //type info valid flag
484    bool isTypeInfoValid_;
485
486    int nlines_;
487    unsigned long fdptr_;
488    char *lines_;
489    char *stabstr_;
490    int nstabs_;
491    void *stabs_;
492    char *stringpool_;
493
494    //Relocation sections
495    bool hasRel_;
496    bool hasRela_;
497
498    //Don't use obj_private, use getObject() instead.
499  public:
500    Object *getObject();
501  private:
502    Object *obj_private;
503
504    // dynamic library name substitutions
505    std::map <std::string, std::string> dynLibSubs;
506
507    public:
508    Type *type_Error;
509    Type *type_Untyped;
510
511  public:
512    /********************************************************************/
513    /**** DEPRECATED ****************************************************/
514    /********************************************************************/
515    dyn_hash_map <std::string, Module *> &getModsByFileName()
516    {
517       return modsByFileName;
518    }
519    dyn_hash_map <std::string, Module *> &getModsByFullName()
520    {
521       return modsByFullName;
522    }
523    
524    SYMTAB_EXPORT bool findFuncByEntryOffset(std::vector<Symbol *>&ret, const Offset offset);
525    SYMTAB_EXPORT virtual bool findSymbolByType(std::vector<Symbol *> &ret, 
526                                            const std::string name,
527                                            Symbol::SymbolType sType, 
528                                            bool isMangled = false,
529                                            bool isRegex = false, 
530                                            bool checkCase = false);
531
532
533
534 };
535
536 /**
537  * Used to represent something like a C++ try/catch block.  
538  * Currently only used on Linux/x86
539  **/
540 SYMTAB_EXPORT  std::ostream &operator<<(std::ostream &os, const ExceptionBlock &q);
541
542 class ExceptionBlock : public Serializable, public AnnotatableSparse {
543
544    public:
545       SYMTAB_EXPORT 
546           void serialize(SerializerBase *sb, const char *tag = "exceptionBlock") THROW_SPEC (SerializerError);
547       SYMTAB_EXPORT ExceptionBlock(Offset tStart, unsigned tSize, Offset cStart);
548       SYMTAB_EXPORT ExceptionBlock(Offset cStart);
549       SYMTAB_EXPORT ExceptionBlock(const ExceptionBlock &eb);
550       SYMTAB_EXPORT ~ExceptionBlock();
551       SYMTAB_EXPORT ExceptionBlock();
552
553       SYMTAB_EXPORT bool hasTry() const;
554       SYMTAB_EXPORT Offset tryStart() const;
555       SYMTAB_EXPORT Offset tryEnd() const;
556       SYMTAB_EXPORT Offset trySize() const;
557       SYMTAB_EXPORT Offset catchStart() const;
558       SYMTAB_EXPORT bool contains(Offset a) const;
559
560       friend SYMTAB_EXPORT std::ostream &operator<<(std::ostream &os, const ExceptionBlock &q);
561    private:
562       Offset tryStart_;
563       unsigned trySize_;
564       Offset catchStart_;
565       bool hasTry_;
566 };
567
568 // relocation information for calls to functions not in this image
569 // on sparc-solaris: target_addr_ = rel_addr_ = PLT entry addr
570 // on x86-solaris: target_addr_ = PLT entry addr
571 //                 rel_addr_ =  GOT entry addr  corr. to PLT_entry
572 SYMTAB_EXPORT std::ostream &operator<<(std::ostream &os, const relocationEntry &q);
573
574 class relocationEntry : public Serializable, public AnnotatableSparse {
575    public:
576
577       SYMTAB_EXPORT relocationEntry();
578       SYMTAB_EXPORT relocationEntry(Offset ta, Offset ra, Offset add, std::string n, Symbol *dynref = NULL, unsigned long relType = 0);
579       SYMTAB_EXPORT relocationEntry(Offset ta, Offset ra, std::string n, Symbol *dynref = NULL, unsigned long relType = 0);
580       SYMTAB_EXPORT relocationEntry(Offset ra, std::string n, Symbol *dynref = NULL, unsigned long relType = 0, Region::RegionType rtype = Region::RT_REL);
581
582       SYMTAB_EXPORT relocationEntry(const relocationEntry& ra);
583
584       SYMTAB_EXPORT const relocationEntry& operator= (const relocationEntry &ra);
585       SYMTAB_EXPORT 
586           void serialize(SerializerBase *sb, const char *tag = "relocationEntry") THROW_SPEC (SerializerError);
587
588       SYMTAB_EXPORT Offset target_addr() const;
589       SYMTAB_EXPORT Offset rel_addr() const;
590       SYMTAB_EXPORT Offset addend() const;
591       SYMTAB_EXPORT Region::RegionType regionType() const;
592       SYMTAB_EXPORT void setAddend(const Offset);
593       SYMTAB_EXPORT void setRegionType(const Region::RegionType);
594       SYMTAB_EXPORT const std::string &name() const;
595       SYMTAB_EXPORT Symbol *getDynSym() const;
596       SYMTAB_EXPORT bool addDynSym(Symbol *dynref);
597       SYMTAB_EXPORT unsigned long getRelType() const;
598
599       // dump output.  Currently setup as a debugging aid, not really
600       //  for object persistance....
601       //SYMTAB_EXPORT std::ostream & operator<<(std::ostream &s) const;
602       friend SYMTAB_EXPORT std::ostream &operator<<(std::ostream &os, const relocationEntry &q);
603
604       enum {pltrel = 1, dynrel = 2} relocationType;
605
606    private:
607       Offset target_addr_;      // target address of call instruction 
608       Offset rel_addr_;         // address of corresponding relocation entry 
609       Offset addend_;       // addend (from RELA entries)
610       Region::RegionType rtype_;        // RT_REL vs. RT_RELA
611       std::string  name_;
612       Symbol *dynref_;
613       unsigned long relType_;
614 };
615
616 SYMTAB_EXPORT SerializerBase *nonpublic_make_bin_symtab_serializer(Symtab *t, std::string file);
617 SYMTAB_EXPORT SerializerBase *nonpublic_make_bin_symtab_deserializer(Symtab *t, std::string file);
618 SYMTAB_EXPORT void nonpublic_free_bin_symtab_serializer(SerializerBase *sb);
619
620 }//namespace SymtabAPI
621
622 }//namespace Dyninst
623 #endif