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