added support for parsing relocation entries and procedure_linkage_table
[dyninst.git] / common / h / Object.h
1 /*
2  * Copyright (c) 1996 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  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 /************************************************************************
43  * Object.h: interface to objects, symbols, lines and instructions.
44 ************************************************************************/
45
46
47 #if !defined(_Object_h_)
48 #define _Object_h_
49
50 /************************************************************************
51  * header files.
52 ************************************************************************/
53
54 #include <util/h/Dictionary.h>
55 #include <util/h/String.h>
56 // trace data streams
57 #include <util/h/ByteArray.h>
58 #include <util/h/Symbol.h>
59 #include <util/h/Types.h>
60 #include <util/h/Vector.h>
61 #include "util/h/lprintf.h"
62
63 // relocation information for calls to functions not in this image
64 // on sparc-solaris: target_addr_ = rel_addr_ = PLT entry addr
65 // on x86-solaris: target_addr_ = PLT entry addr
66 //                 rel_addr_ =  GOT entry addr  corr. to PLT_entry
67 class relocationEntry {
68 public:
69     relocationEntry():target_addr_(0),rel_addr_(0),name_(0){}   
70     relocationEntry(Address ta,Address ra, string n):target_addr_(ta),
71         rel_addr_(ra),name_(n){}   
72     relocationEntry(const relocationEntry& ra): target_addr_(ra.target_addr_), 
73         rel_addr_(ra.rel_addr_), name_(ra.name_) { }
74     ~relocationEntry(){}
75
76     const relocationEntry& operator= (const relocationEntry &ra) {
77         target_addr_ = ra.target_addr_; rel_addr_ = ra.rel_addr_; 
78         name_ = ra.name_; 
79         return *this;
80     }
81     Address target_addr() const { return target_addr_; }
82     Address rel_addr() const { return rel_addr_; }
83     const string &name() const { return name_; }
84
85 private:
86    Address target_addr_;        // target address of call instruction 
87    Address rel_addr_;           // address of corresponding relocation entry 
88    string  name_;
89 };
90
91 /************************************************************************
92  * class AObject
93 ************************************************************************/
94
95 class AObject {
96 public:
97
98     unsigned  nsymbols () const { return symbols_.size(); }
99
100     bool      get_symbol (const string &name, Symbol &symbol) {
101         if (!symbols_.defines(name)) {
102             return false;
103         }
104         symbol = symbols_[name];
105         return true;
106     }
107
108     const Word*       code_ptr () const { return code_ptr_; } 
109     unsigned          code_off () const { return code_off_; }
110     unsigned          code_len () const { return code_len_; }
111
112     const Word*       data_ptr () const { return data_ptr_; }
113     unsigned          data_off () const { return data_off_; }
114     unsigned          data_len () const { return data_len_; }
115
116     virtual  bool   needs_function_binding()  const;
117     virtual  bool   get_func_binding_table(vector<relocationEntry> &) const;
118     
119 protected:
120     // explicitly protected
121     AObject(const string file , void (*err_func)(const char *)): file_(file), 
122         symbols_(string::hash), code_ptr_(0), code_off_(0), code_len_(0), 
123         data_ptr_(0), data_off_(0), data_len_(0),err_func_(err_func){} 
124
125     AObject(const AObject &obj): file_(obj.file_), symbols_(obj.symbols_), 
126         code_ptr_(obj.code_ptr_), code_off_(obj.code_off_), 
127         code_len_(obj.code_len_), data_ptr_(obj.data_ptr_), 
128         data_off_(obj.data_off_), data_len_(obj.data_len_), 
129         err_func_(obj.err_func_) {}   
130
131     AObject&  operator= (const AObject &obj) {   
132
133          if (this == &obj) { return *this; }
134          file_      = obj.file_;        symbols_   = obj.symbols_;
135          code_ptr_  = obj.code_ptr_;    code_off_  = obj.code_off_;
136          code_len_  = obj.code_len_;    data_ptr_  = obj.data_ptr_;
137          data_off_  = obj.data_off_;    data_len_  = obj.data_len_;
138          err_func_  = obj.err_func_;
139          return *this;
140     }
141
142     string                          file_;
143     dictionary_hash<string, Symbol> symbols_;
144
145     Word*    code_ptr_;
146     unsigned code_off_;
147     unsigned code_len_;
148
149     Word*    data_ptr_;
150     unsigned data_off_;
151     unsigned data_len_;
152
153     void (*err_func_)(const char*);
154
155 private:
156     friend class SymbolIter;
157 };
158
159 /************************************************************************
160  * include the architecture-operating system specific object files.
161 ************************************************************************/
162
163 #undef HAVE_SPECIFIC_OBJECT
164
165 #if defined(hppa1_1_hp_hpux)
166 #include <util/h/Object-hpux.h>
167 #define HAVE_SPECIFIC_OBJECT
168 #endif /* defined(hppa1_1_hp_hpux) */
169
170 #if defined(sparc_sun_solaris2_4) || defined(i386_unknown_solaris2_5)
171 #include <util/h/Object-elf32.h>
172 #define HAVE_SPECIFIC_OBJECT
173 #endif /* defined(sparc_sun_solaris2_4) */
174
175 #if defined(sparc_sun_sunos4_1_3)
176 #include <util/h/Object-bsd.h>
177 #define HAVE_SPECIFIC_OBJECT
178 #endif /* defined(sparc_sun_sunos4_1_3) */
179
180 #if defined(sparc_tmc_cmost7_3)
181 #include <util/h/Object-cm5.h>
182 #define HAVE_SPECIFIC_OBJECT
183 #endif /* defined(sparc_tmc_cmost7_3) */
184
185 #if defined(rs6000_ibm_aix3_2) || defined(rs6000_ibm_aix4_1)
186 #include <util/h/Object-aix.h>
187 #define HAVE_SPECIFIC_OBJECT
188 #endif /* defined(sparc_tmc_cmost7_3) */
189
190 #if defined(i386_unknown_nt4_0)
191 #include <util/h/Object-nt.h>
192 #define HAVE_SPECIFIC_OBJECT
193 #endif /* defined(i386_unknown_nt4_0) */
194
195 #if !defined(HAVE_SPECIFIC_OBJECT)
196 #error "unable to locate system-specific object files"
197 #endif /* !defined(HAVE_SPECIFIC_OBJECT) */
198
199 /************************************************************************
200  * class SymbolIter
201 ************************************************************************/
202
203 class SymbolIter {
204 public:
205      SymbolIter (const Object &obj):  si_(obj.symbols_) {}
206     ~SymbolIter () {}
207
208     bool  next (string &name, Symbol &sym) { return si_.next(name, sym); } 
209     void  reset () { si_.reset(); }
210
211 private:
212     dictionary_hash_iter<string, Symbol> si_;
213
214     SymbolIter            (const SymbolIter &); // explicitly disallowed
215     SymbolIter& operator= (const SymbolIter &); // explicitly disallowed
216 };
217
218 #endif /* !defined(_Object_h_) */