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