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