Commiting Aishwarya's work in allowing StackwalkerAPI users to change the system...
[dyninst.git] / dynutil / h / SymReader.h
1 /*
2  * Copyright (c) 1996-2011 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 #if !defined SYM_READER_H_
32 #define SYM_READER_H_
33
34 #include "dyntypes.h"
35 #include <string>
36
37 class Elf_X;
38
39 namespace Dyninst
40 {
41
42 class SymbolReaderFactory;
43
44 /**
45  * Symbol_t is an anonymous struct that any SymReader can use for a symbol 
46  * handle.  Some symbol readers may not want to store the objects behind a 
47  * 'void*' on the heap, so we're making Symbol_t big enough that it could 
48  * act as a full symbol handle.  Or a SymReader could just choose fill in one
49  * of the void pointers as a handle to a heap object, if it's comfortable
50  * doing so.
51  **/
52 typedef struct {
53    void *v1;
54    void *v2;
55    int i1;
56    int i2;
57 } Symbol_t;
58
59 typedef struct {
60    void *v1;
61    void *v2;
62    int i1;
63    int i2;
64 } Section_t;
65
66 typedef struct {
67    Dyninst::Offset file_offset;
68    Dyninst::Address mem_addr;
69    size_t file_size;
70    size_t mem_size;
71    int type;
72    int perms;
73 } SymRegion;
74
75 /**
76  * This may seem like a clunky interface in places, but it was designed such 
77  * that the underlying implementation could be made re-enterant safe (so it 
78  * could be called from a signal handler).
79  **/
80 class SymReader
81 {
82  protected:
83    SymReader() {}
84    virtual ~SymReader() {}
85  public:
86    virtual Symbol_t getSymbolByName(std::string symname) = 0;
87    virtual Symbol_t getContainingSymbol(Dyninst::Offset offset) = 0;
88    virtual std::string getInterpreterName() = 0;
89    virtual unsigned getAddressWidth() = 0;
90    
91    virtual unsigned numRegions() = 0;
92    virtual bool getRegion(unsigned num, SymRegion &reg) = 0; 
93
94    virtual Dyninst::Offset getSymbolOffset(const Symbol_t &sym) = 0;
95    virtual std::string getSymbolName(const Symbol_t &sym) = 0;
96    virtual std::string getDemangledName(const Symbol_t &sym) = 0;
97    virtual unsigned long getSymbolSize(const Symbol_t &sym) = 0;
98    virtual bool isValidSymbol(const Symbol_t &sym) = 0;
99
100    virtual Section_t getSectionByName(std::string name) = 0;
101    virtual Section_t getSectionByAddress(Dyninst::Address addr) = 0;
102    virtual Dyninst::Address getSectionAddress(Section_t sec) = 0;
103    virtual std::string getSectionName(Section_t sec) = 0;
104    virtual bool isValidSection(Section_t sec) = 0;
105
106    virtual Dyninst::Offset imageOffset() = 0;
107    virtual Dyninst::Offset dataOffset() = 0;
108
109    virtual Elf_X *getElfHandle() { return NULL; }
110 };
111
112 class SymbolReaderFactory
113 {
114  public:
115    SymbolReaderFactory() {}
116    virtual ~SymbolReaderFactory() {}
117    virtual SymReader *openSymbolReader(std::string pathname) = 0;
118    virtual SymReader *openSymbolReader(const char *buffer, unsigned long size) = 0;
119    virtual bool closeSymbolReader(SymReader *sr) = 0;
120 };
121
122 }
123
124 extern "C" {
125    Dyninst::SymbolReaderFactory *getSymReaderFactory();
126 }
127
128 #endif