Rename the symbol reader getRegions to getSegments, since the desired return is an...
[dyninst.git] / symtabAPI / src / Object-elf.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 /************************************************************************
32  * $Id: Object-elf.h,v 1.21 2008/06/23 18:45:42 legendre Exp $
33  * Object-elf.h: Object class for ELF file format
34 ************************************************************************/
35
36
37 #if !defined(_Object_elf_h_)
38 #define _Object_elf_h_
39
40 #if defined(USES_DWARF_DEBUG)
41 //#include "dwarf.h"
42 #include "libdwarf.h"
43 #endif
44
45 #include<vector>
46 #include "common/h/headers.h"
47 #include "common/h/Types.h"
48 #include "common/h/MappedFile.h"
49 #include "common/h/IntervalTree.h"
50
51 #if 0
52 #include "symtabAPI/h/Symbol.h"
53 #include "symtabAPI/h/Symtab.h"
54 #endif
55
56
57 #include <elf.h>
58 #include <libelf.h>
59 #include <string>
60
61 #include "elf/h/Elf_X.h"
62
63 #include <fcntl.h>
64 #include <stdlib.h>
65 #include <unistd.h>
66 #include <set>
67 #include <sys/types.h>
68 #include <sys/mman.h>
69 #include <sys/stat.h>
70
71
72 namespace Dyninst{
73
74 namespace Dwarf {
75    class DwarfFrameParser;
76    typedef boost::shared_ptr<DwarfFrameParser> DwarfFrameParserPtr;
77 }
78
79 namespace SymtabAPI{
80 /*
81  * The standard symbol table in an elf file is the .symtab section. This section does
82  * not have information to find the module to which a global symbol belongs, so we must
83  * also read the .stab section to get this info.
84  */
85
86 // Declarations for the .stab section.
87 // These are not declared in any system header files, so we must provide our own
88 // declarations. The declarations below were taken from:
89 //       SPARCWorks 3.0.x Debugger Interface, July 1994
90 // 
91 struct stab32 {
92     unsigned int name;  // stabstr table index for this symbol
93     unsigned char type; // type of this symbol
94     unsigned char other;
95     unsigned short desc;
96     unsigned int val;   // value of this symbol -- usually zero. The real value must
97                         // be obtained from the symtab section
98 };
99 struct stab64 {
100     // XXX ELF stabs are currently not implementing actual 64-bit support
101     //     on AMD-64, for which this separation was introduced. Until we
102     //     start seeing stab records with fields of the appropriate length,
103     //     we should assume the smaller records.
104     //unsigned long name; // stabstr table index for this symbol
105     unsigned int name; // stabstr table index for this symbol
106     unsigned char type; // type of this symbol
107     unsigned char other;
108     unsigned short desc;
109     //unsigned long val;
110     unsigned int val;  // value of this symbol -- usually zero. The real value must
111                         // be obtained from the symtab section
112 };
113
114 // 
115 // Extended to a class for 32/64-bit stab entries at runtime. - Ray
116 // 
117 class stab_entry {
118   public:
119     stab_entry(void *_stabptr = 0, const char *_stabstr = 0, long _nsyms = 0)
120         : stabptr(_stabptr), stabstr(_stabstr), nsyms(_nsyms) { }
121     virtual ~stab_entry() {};
122
123     virtual const char *name(int i) = 0;
124     virtual unsigned long nameIdx(int i) = 0;
125     virtual unsigned char type(int i) = 0;
126     virtual unsigned char other(int i) = 0;
127     virtual unsigned short desc(int i) = 0;
128     virtual unsigned long val(int i) = 0;
129
130     unsigned long count() { return nsyms; }
131     void setStringBase(const char *ptr) { stabstr = const_cast<char *>(ptr); }
132     const char *getStringBase() { return stabstr; }
133
134   protected:
135     void *stabptr;
136     const char *stabstr;
137     long nsyms;
138 };
139
140 class stab_entry_32 : public stab_entry {
141   public:
142     stab_entry_32(void *_stabptr = 0, const char *_stabstr = 0, long _nsyms = 0)
143         : stab_entry(_stabptr, _stabstr, _nsyms) { }
144     virtual ~stab_entry_32() {};
145
146     const char *name(int i = 0) { 
147        if (!stabptr) {
148           fprintf(stderr, "%s[%d]:  warning, accessing uninitialized stab_entry\n",
149                 FILE__, __LINE__);
150           return "bad_name";
151        }
152        return stabstr + ((stab32 *)stabptr)[i].name; 
153     }
154     unsigned long nameIdx(int i = 0) {
155        if (!stabptr) {
156           fprintf(stderr, "%s[%d]:  warning, accessing uninitialized stab_entry\n",
157                 FILE__, __LINE__);
158           return 0L;
159        }
160        return ((stab32 *)stabptr)[i].name; 
161     }
162     unsigned char type(int i = 0) {
163        if (!stabptr) {
164           fprintf(stderr, "%s[%d]:  warning, accessing uninitialized stab_entry\n",
165                 FILE__, __LINE__);
166           return 0;
167        }
168        return ((stab32 *)stabptr)[i].type; 
169     }
170     unsigned char other(int i = 0) {
171        if (!stabptr) {
172           fprintf(stderr, "%s[%d]:  warning, accessing uninitialized stab_entry\n",
173                 FILE__, __LINE__);
174           return 0;
175        }
176        return ((stab32 *)stabptr)[i].other; 
177     }
178     unsigned short desc(int i = 0) { 
179        if (!stabptr) {
180           fprintf(stderr, "%s[%d]:  warning, accessing uninitialized stab_entry\n",
181                 FILE__, __LINE__);
182           return 0;
183        }
184        return ((stab32 *)stabptr)[i].desc; 
185     }
186     unsigned long val(int i = 0) { 
187        if (!stabptr) {
188           fprintf(stderr, "%s[%d]:  warning, accessing uninitialized stab_entry\n",
189                 FILE__, __LINE__);
190           return 0L;
191        }
192        return ((stab32 *)stabptr)[i].val; 
193     }
194 };
195
196 class stab_entry_64 : public stab_entry {
197   public:
198     stab_entry_64(void *_stabptr = 0, const char *_stabstr = 0, long _nsyms = 0)
199         : stab_entry(_stabptr, _stabstr, _nsyms) { }
200     virtual ~stab_entry_64() {};
201
202     const char *name(int i = 0) { 
203        if (!stabptr) {
204           fprintf(stderr, "%s[%d]:  warning, accessing uninitialized stab_entry\n",
205                 FILE__, __LINE__);
206           return "bad_name";
207        }
208        return stabstr + ((stab64 *)stabptr)[i].name; 
209     }
210     unsigned long nameIdx(int i = 0) {
211        if (!stabptr) {
212           fprintf(stderr, "%s[%d]:  warning, accessing uninitialized stab_entry\n",
213                 FILE__, __LINE__);
214           return 0L;
215        }
216        return ((stab64 *)stabptr)[i].name; 
217     }
218     unsigned char type(int i = 0) {
219        if (!stabptr) {
220           fprintf(stderr, "%s[%d]:  warning, accessing uninitialized stab_entry\n",
221                 FILE__, __LINE__);
222           return 0;
223        }
224        return ((stab64 *)stabptr)[i].type; 
225     }
226     unsigned char other(int i = 0) { 
227        if (!stabptr) {
228           fprintf(stderr, "%s[%d]:  warning, accessing uninitialized stab_entry\n",
229                 FILE__, __LINE__);
230           return 0;
231        }
232        return ((stab64 *)stabptr)[i].other; 
233     }
234     unsigned short desc(int i = 0) { 
235        if (!stabptr) {
236           fprintf(stderr, "%s[%d]:  warning, accessing uninitialized stab_entry\n",
237                 FILE__, __LINE__);
238           return 0;
239        }
240        return ((stab64 *)stabptr)[i].desc; 
241     }
242     unsigned long val(int i = 0) { 
243        if (!stabptr) {
244           fprintf(stderr, "%s[%d]:  warning, accessing uninitialized stab_entry\n",
245                 FILE__, __LINE__);
246           return 0L;
247        }
248        return ((stab64 *)stabptr)[i].val; 
249     }
250 };
251
252 // Types 
253 #define N_UNDF  0x00 /* start of object file */
254 #define N_GSYM  0x20 /* global symbol */
255 #define N_FUN   0x24 /* function or procedure */
256 #define N_STSYM 0x26 /* initialized static symbol */
257 #define N_LCSYM 0x28 /* unitialized static symbol */
258 #define N_ROSYM 0x2c /* read-only static symbol */
259 #define N_OPT   0x3c /* compiler options */
260 #define N_ENDM  0x62 /* end module */
261 #define N_SO    0x64 /* source directory and file */
262 #define N_ENTRY 0xa4 /* fortran alternate subroutine entry point */
263 #define N_BCOMM 0xe2 /* start fortran named common block */
264 #define N_ECOMM 0xe4 /* start fortran named common block */
265
266 // Language code -- the desc field in a N_SO entry is a language code
267 #define N_SO_AS      1 /* assembler source */
268 #define N_SO_C       2 /* K & R C source */
269 #define N_SO_ANSI_C  3 /* ANSI C source */
270 #define N_SO_CC      4 /* C++ source */
271 #define N_SO_FORTRAN 5 /* fortran source */
272 #define N_SO_PASCAL  6 /* Pascal source */
273 #define N_SO_F90     7 /* Fortran90 source */
274
275 //line information data
276 #define N_SLINE  0x44 /* line number in text segment */
277 #define N_SOL    0x84 /* name of the include file*/
278
279 // Symbol descriptors
280 // The format of a name is "<name>:<symbol descriptor><rest of name>
281 // The following are the descriptors of interest
282 #define SD_GLOBAL_FUN 'F' /* global function or procedure */
283 #define SD_PROTOTYPE  'P'  /* function prototypes */
284 #define SD_GLOBAL_VAR 'G' /* global variable */
285
286 // end of stab declarations
287
288 class pdElfShdr;
289
290 class Symtab;
291 class Region;
292 class Object;
293
294 class DwarfHandle {
295    friend class Object;
296  private:
297    Dwarf::DwarfFrameParserPtr sw;
298    Object *obj;
299    typedef enum {
300       dwarf_status_uninitialized,
301       dwarf_status_error,
302       dwarf_status_ok
303    } dwarf_status_t;
304    dwarf_status_t init_dwarf_status;
305    Dwarf_Debug dbg_data;
306  public:
307   DwarfHandle(Object *obj_);
308   ~DwarfHandle();
309
310   Dwarf_Debug *dbg();
311   Dwarf::DwarfFrameParserPtr frameParser() { return sw; } 
312 };
313
314 class Object : public AObject {
315   friend class DwarfHandle;
316  public:
317   Object() : dwarf(this) {}
318   Object(MappedFile *, MappedFile *, bool, void (*)(const char *) = log_msg, bool alloc_syms = true);
319   Object(MappedFile *, MappedFile *, dyn_hash_map<std::string, LineInformation> &, std::vector<Region *> &, void (*)(const char *) = log_msg);
320   Object(MappedFile *, MappedFile *, std::string &member_name, Offset offset,   
321           void (*)(const char *) = log_msg, void *base = NULL, bool alloc_syms = true);
322   Object(const Object &);
323   virtual ~Object();
324   //const Object& operator=(const Object &);
325
326   bool emitDriver(Symtab *obj, std::string fName, std::vector<Symbol *>&allSymbols, unsigned flag);  
327   
328   const char *elf_vaddr_to_ptr(Offset vaddr) const;
329   bool hasStabInfo() const { return ! ( !stab_off_ || !stab_size_ || !stabstr_off_ ); }
330   bool hasDwarfInfo() const { return dwarvenDebugInfo; }
331   stab_entry * get_stab_info() const;
332   const char * getFileName() const { return mf->filename().c_str(); }
333   void getModuleLanguageInfo(dyn_hash_map<std::string, supportedLanguages> *mod_langs);
334   void parseFileLineInfo(Symtab *obj, dyn_hash_map<std::string, LineInformation> &li);
335   void parseTypeInfo(Symtab *obj);
336
337   bool needs_function_binding() const { return (plt_addr_ > 0); } 
338   bool get_func_binding_table(std::vector<relocationEntry> &fbt) const;
339   bool get_func_binding_table_ptr(const std::vector<relocationEntry> *&fbt) const;
340   void getDependencies(std::vector<std::string> &deps);
341   std::vector<std::string> &libsRMd();
342
343   bool addRelocationEntry(relocationEntry &re);
344
345   Dwarf_Debug dwarf_dbg();
346
347   //getLoadAddress may return 0 on shared objects
348   Offset getLoadAddress() const { return loadAddress_; }
349
350   Offset getEntryAddress() const { return entryAddress_; }
351   // To be changed later - Giri
352   Offset getBaseAddress() const { return 0; }
353   static bool truncateLineFilenames;
354
355   void insertPrereqLibrary(std::string libname);
356   bool removePrereqLibrary(std::string libname);
357   void insertDynamicEntry(long name, long value);
358  
359   virtual char *mem_image() const 
360   {
361      assert(mf);
362      return (char *)mf->base_addr();
363   }
364
365   SYMTAB_EXPORT ObjectType objType() const;
366   const char *interpreter_name() const;
367
368
369   // On most platforms, the TOC offset doesn't exist and is thus null. 
370   // On PPC64, it varies _by function_ and is used to point into the GOT,
371   // a big data table. We can look it up by parsing the OPD, a function
372   // descriptor table. 
373   Offset getTOCoffset(Offset off) const;
374
375   // This is an override for the whole thing; we could do per-function but 
376   // we're missing a _lot_ of hardware for that. 
377   void setTOCoffset(Offset off);
378
379   const std::ostream &dump_state_info(std::ostream &s);
380   bool isEEL() { return EEL; }
381
382         //to determine if a mutation falls in the text section of
383         // a shared library
384         bool isinText(Offset addr, Offset baseaddr) const { 
385                 //printf(" baseaddr %x TESTING %x %x \n", baseaddr, text_addr_ + baseaddr  , text_addr_ + baseaddr + text_size_ );
386                 if(addr > text_addr_ + baseaddr     &&
387                    addr < text_addr_ + baseaddr + text_size_ ) {
388                         return true;
389                 }
390                 return false;
391         } 
392         // to determine where in the .plt this function is listed 
393         // returns an offset from the base address of the object
394         // so the entry can easily be located in memory
395         Offset getPltSlot(std::string funcName) const ;
396         Offset textAddress(){ return text_addr_;}
397         bool isText( Offset addr ) const
398         {
399             if( addr >= text_addr_ && addr <= text_addr_ + text_size_ )
400                 return true;
401             return false;
402         }
403
404    Dyninst::Architecture getArch();
405
406         bool is_offset_in_plt(Offset offset) const;
407     Elf_X_Shdr *getRegionHdrByAddr(Offset addr);
408     int getRegionHdrIndexByAddr(Offset addr);
409     Elf_X_Shdr *getRegionHdrByIndex(unsigned index);
410     bool isRegionPresent(Offset segmentStart, Offset segmentSize, unsigned newPerms);
411
412     bool getRegValueAtFrame(Address pc, 
413                             Dyninst::MachRegister reg, 
414                             Dyninst::MachRegisterVal &reg_result,
415                             MemRegReader *reader);
416     bool hasFrameDebugInfo();
417     
418     bool convertDebugOffset(Offset off, Offset &new_off);
419
420     std::vector< std::vector<Offset> > getMoveSecAddrRange() const {return moveSecAddrRange;};
421     dyn_hash_map<int, Region*> getTagRegionMapping() const { return secTagRegionMapping;}
422
423     bool hasReldyn() const {return hasReldyn_;}
424     bool hasReladyn() const {return hasReladyn_;}
425     bool hasRelplt() const {return hasRelplt_;}
426     bool hasRelaplt() const {return hasRelaplt_;}
427     bool isBlueGeneP() const {return isBlueGeneP_;}
428     bool isBlueGeneQ() const {return isBlueGeneQ_;}
429     bool hasNoteSection() const {return hasNoteSection_;}
430     Region::RegionType getRelType() const { return relType_; }
431
432     Offset getTextAddr() const {return text_addr_;}
433     Offset getSymtabAddr() const {return symtab_addr_;}
434     Offset getStrtabAddr() const {return strtab_addr_;}
435     Offset getDynamicAddr() const {return dynamic_addr_;}
436     Offset getDynsymSize() const {return dynsym_size_;}
437     Offset getElfHashAddr() const {return elf_hash_addr_;}
438     Offset getGnuHashAddr() const {return gnu_hash_addr_;}
439     Offset getRelPLTAddr() const { return rel_plt_addr_; }
440     Offset getRelPLTSize() const { return rel_plt_size_; }
441     Offset getRelDynAddr() const { return rel_addr_; }
442     Offset getRelDynSize() const { return rel_size_; }
443
444     std::vector<relocationEntry> &getPLTRelocs() { return fbt_; }
445     std::vector<relocationEntry> &getDynRelocs() { return relocation_table_; }
446
447     Offset getInitAddr() const {return init_addr_; }
448     Offset getFiniAddr() const { return fini_addr_; }
449
450     virtual void setTruncateLinePaths(bool value);
451     virtual bool getTruncateLinePaths();
452     
453     Elf_X * getElfHandle() { return &elfHdr; }
454
455     unsigned gotSize() const { return got_size_; }
456     Offset gotAddr() const { return got_addr_; }
457
458     virtual void getSegmentsSymReader(std::vector<SymSegment> &segs); 
459
460   private:
461   static void log_elferror (void (*)(const char *), const char *);
462     
463   Elf_X    elfHdr;
464
465   Elf_X    elfHdrForDebugInfo;
466  
467   std::vector< std::vector<Offset> > moveSecAddrRange;
468   dyn_hash_map<Offset, int> secAddrTagMapping;
469   dyn_hash_map<int, unsigned long> secTagSizeMapping;
470   dyn_hash_map<int, Region*> secTagRegionMapping;
471
472   bool hasReldyn_;
473   bool hasReladyn_;
474   bool hasRelplt_;
475   bool hasRelaplt_;
476   Region::RegionType relType_;
477
478   bool isBlueGeneP_;
479   bool isBlueGeneQ_;
480   bool hasNoteSection_;
481
482   Offset   elf_hash_addr_;       //.hash section 
483   Offset   gnu_hash_addr_;       //.gnu.hash section 
484
485   Offset   dynamic_offset_;
486   size_t   dynamic_size_;
487   size_t   dynsym_size_;
488   Offset   init_addr_;
489   Offset   fini_addr_;
490   Offset   text_addr_;   //.text section 
491   Offset   text_size_;   //.text section size
492   Offset   symtab_addr_;
493   Offset   strtab_addr_;
494   Offset   dynamic_addr_;        //.dynamic section
495   Offset   dynsym_addr_;        // .dynsym section
496   Offset   dynstr_addr_;        // .dynstr section
497   Offset   got_addr_;           // global offset table
498   unsigned got_size_;           // global offset table
499   Offset   plt_addr_;           // procedure linkage table
500   unsigned plt_size_;           // procedure linkage table
501   unsigned plt_entry_size_;     // procedure linkage table
502   Offset   rel_plt_addr_;       // .rel[a].plt section
503   unsigned rel_plt_size_;       // .rel[a].plt section
504   unsigned rel_plt_entry_size_; // .rel[a].plt section
505   Offset    rel_addr_;
506   unsigned  rel_size_;       // DT_REL/DT_RELA in dynamic section
507   unsigned  rel_entry_size_; // DT_REL/DT_RELA in dynamic section
508   Offset   opd_addr_;
509   unsigned opd_size_;
510
511   Offset   stab_off_;           // .stab section
512   unsigned stab_size_;          // .stab section
513   Offset   stabstr_off_;        // .stabstr section
514
515   Offset   stab_indx_off_;       // .stab.index section
516   unsigned  stab_indx_size_;     // .stab.index section
517   Offset   stabstr_indx_off_;    // .stabstr.index section
518
519   bool      dwarvenDebugInfo;    // is DWARF debug info present?
520   Offset   loadAddress_;      // The object may specify a load address
521                                //   Set to 0 if it may load anywhere
522   Offset entryAddress_;
523   char *interpreter_name_;
524   bool  isStripped;
525   bool usesDebugFile;
526
527   std::map<Offset, Offset> TOC_table_;
528
529   public:
530   DwarfHandle dwarf;
531   private:
532
533   bool      EEL;                 // true if EEL rewritten
534   bool      did_open;           // true if the file has been mmapped
535   ObjectType obj_type_;
536
537   // for sparc-solaris this is a table of PLT entry addr, function_name
538   // for x86-solaris this is a table of GOT entry addr, function_name
539   // on sparc-solaris the runtime linker modifies the PLT entry when it
540   // binds a function, on X86 the PLT entry is not modified, but it uses
541   // an indirect jump to a GOT entry that is modified when the function 
542   // is bound....is this correct???? or should it be <PLTentry_addr, name> 
543   // for both?
544   std::vector<relocationEntry> relocation_table_;
545   std::vector<relocationEntry> fbt_;
546
547   // all section headers, sorted by address
548   // we use these to do a better job of finding the end of symbols
549   std::vector<Elf_X_Shdr*> allRegionHdrs;
550   std::vector<Elf_X_Shdr*> allRegionHdrsByShndx;
551
552   // Symbol version mappings. used to store symbol version names.
553   dyn_hash_map<unsigned, std::vector<std::string> >versionMapping;
554   dyn_hash_map<unsigned, std::string> versionFileNameMapping;
555
556   std::vector<std::string> deps_;
557   std::vector<std::string> rmd_deps;
558
559   bool loaded_elf( Offset &, Offset &,
560                     Elf_X_Shdr* &,
561                     Elf_X_Shdr* &, Elf_X_Shdr* &, 
562                     Elf_X_Shdr* &, Elf_X_Shdr* &, 
563                     Elf_X_Shdr* &, Elf_X_Shdr* &, 
564                     Elf_X_Shdr*& rel_plt_scnp, Elf_X_Shdr*& plt_scnp, 
565                     Elf_X_Shdr*& got_scnp, Elf_X_Shdr*& dynsym_scnp,
566                     Elf_X_Shdr*& dynstr_scnp, Elf_X_Shdr*& dynamic_scnp, Elf_X_Shdr*& eh_frame,
567                     Elf_X_Shdr*& gcc_except, Elf_X_Shdr *& interp_scnp,
568                    Elf_X_Shdr *&opd_scnp,
569           bool a_out=false);
570   
571   Symbol *handle_opd_symbol(Region *opd, Symbol *sym);
572   void handle_opd_relocations();
573   void parse_opd(Elf_X_Shdr *);
574   void parseStabFileLineInfo(Symtab *, dyn_hash_map<std::string, LineInformation> &li);
575   void parseDwarfFileLineInfo(dyn_hash_map<std::string, LineInformation> &li);
576
577   void parseDwarfTypes(Symtab *obj);
578   void parseStabTypes(Symtab *obj);
579
580   void load_object(bool);
581   void load_shared_object(bool);
582
583   // initialize relocation_table_ from .rel[a].plt section entries 
584   bool get_relocation_entries(Elf_X_Shdr *&rel_plt_scnp,
585                               Elf_X_Shdr *&dynsym_scnp, 
586                               Elf_X_Shdr *&dynstr_scnp);
587
588   bool get_relocationDyn_entries( unsigned rel_index,
589                      Elf_X_Shdr *&dynsym_scnp,
590                      Elf_X_Shdr *&dynstr_scnp );
591
592   // Parses sections with relocations and links these relocations to
593   // existing symbols
594   bool parse_all_relocations(Elf_X &, Elf_X_Shdr *, Elf_X_Shdr *,
595           Elf_X_Shdr *, Elf_X_Shdr *);
596   
597   void parseDynamic(Elf_X_Shdr *& dyn_scnp, Elf_X_Shdr *&dynsym_scnp, 
598                     Elf_X_Shdr *&dynstr_scnp);
599   
600   bool parse_symbols(Elf_X_Data &symdata, Elf_X_Data &strdata,
601                      Elf_X_Shdr* bssscnp,
602                      Elf_X_Shdr* symscnp,
603                      bool shared_library,
604                      std::string module);
605   
606   void parse_dynamicSymbols( Elf_X_Shdr *& dyn_scnp, Elf_X_Data &symdata,
607                              Elf_X_Data &strdata, bool shared_library,
608                              std::string module);
609
610   void find_code_and_data(Elf_X &elf,
611        Offset txtaddr, Offset dataddr);
612   //void insert_symbols_static(std::vector<Symbol *> &allsymbols);
613   bool fix_global_symbol_modules_static_stab(Elf_X_Shdr *stabscnp,
614                                              Elf_X_Shdr *stabstrscnp);
615   bool fix_global_symbol_modules_static_dwarf();
616
617   void get_valid_memory_areas(Elf_X &elf);
618
619   MappedFile *findMappedFileForDebugInfo();
620   bool find_catch_blocks(Elf_X_Shdr *eh_frame, Elf_X_Shdr *except_scn,
621                          Address textaddr, Address dataaddr,
622                          std::vector<ExceptionBlock> &catch_addrs);
623
624 #if defined(USES_DWARF_DEBUG)
625   std::string find_symbol(std::string name); 
626   bool fixSymbolsInModule(Dwarf_Debug dbg, std::string & moduleName, Dwarf_Die dieEntry);
627   unsigned fixSymbolsInModuleByRange(IntervalTree<Dwarf_Addr, std::string> &module_ranges);
628 #endif
629
630  public:
631   struct DbgAddrConversion_t {
632      DbgAddrConversion_t() : dbg_offset(0x0), dbg_size(0x0), orig_offset(0x0) {}
633      std::string name;
634      Offset dbg_offset;
635      unsigned dbg_size;
636      Offset orig_offset;
637   };
638  private:
639   bool DbgSectionMapSorted;
640   std::vector<DbgAddrConversion_t> DebugSectionMap;
641
642  public:  
643   std::set<std::string> prereq_libs;
644   std::vector<std::pair<long, long> > new_dynamic_entries;
645 };
646
647 //const char *pdelf_get_shnames(Elf *elfp, bool is64);
648
649 }//namespace SymtabAPI
650 }//namespace Dyninst
651
652 #endif /* !defined(_Object_elf_h_) */