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