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