extended parseThat to use new addressSpace abstraction
[dyninst.git] / dyninstAPI / h / BPatch_addressSpace.h
1 /*
2  * Copyright (c) 1996-2004 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 #ifndef _BPatch_addressSpace_h_
43 #define _BPatch_addressSpace_h_
44
45 #include "BPatch_snippet.h"
46 #include "BPatch_dll.h"
47 #include "BPatch_Vector.h"
48 #include "BPatch_eventLock.h"
49 #include "BPatch_point.h"
50
51 #include "BPatch_callbacks.h"
52
53 #include <vector>
54
55 #include <stdio.h>
56 #include <signal.h>
57
58 class AddressSpace;
59 class miniTrampHandle;
60 class miniTramp;
61 class BPatch;
62 class BPatch_funcMap;
63 class BPatch_instpMap;
64 class int_function;
65 struct batchInsertionRecord;
66
67 typedef enum{
68   TRADITIONAL_PROCESS, STATIC_EDITOR
69     } processType;
70
71
72 #ifdef DYNINST_CLASS_NAME
73 #undef DYNINST_CLASS_NAME
74 #endif
75 #define DYNINST_CLASS_NAME BPatchSnippetHandle
76 class BPATCH_DLL_EXPORT BPatchSnippetHandle : public BPatch_eventLock {
77     friend class BPatch_point;
78     friend class BPatch_image;
79     friend class BPatch_process;
80     friend class BPatch_binaryEdit;
81     friend class BPatch_addressSpace;
82     friend class BPatch_thread;
83
84 private:    
85     // Process this snippet maps to, grandfathered in 
86     BPatch_process *proc_;
87
88     // Address Space snippet belogns to
89     BPatch_addressSpace *addSpace_;
90
91     // low-level mappings for removal
92     BPatch_Vector<miniTramp *> mtHandles_;
93
94     //  a flag for catchuo
95     bool catchupNeeded;
96     //  and a list of threads to apply catchup to
97     BPatch_Vector<BPatch_thread *> catchup_threads;
98     
99     BPatchSnippetHandle(BPatch_addressSpace * addSpace);
100     //BPatchSnippetHandle(BPatch_process *proc);
101
102     void addMiniTramp(miniTramp *m) { mtHandles_.push_back(m); }
103     
104 public:
105
106     API_EXPORT_DTOR(_dtor, (),
107     ~,BPatchSnippetHandle,());
108
109     // Returns whether the installed miniTramps use traps.
110     // Not 100% accurate due to internal Dyninst design; we can
111     // have multiple instances of instrumentation due to function
112     // relocation.
113     API_EXPORT(Int, (), bool, usesTrap, ());
114
115     
116     API_EXPORT(Int, (),
117     BPatch_process *, getProcess, ());
118     
119     
120     API_EXPORT(Int, (),
121     BPatch_addressSpace *, getAddressSpace, ());
122     
123     
124     API_EXPORT(Int, (),
125     BPatch_Vector<BPatch_thread *> &, getCatchupThreads, ());
126    
127 };
128
129 #ifdef DYNINST_CLASS_NAME
130 #undef DYNINST_CLASS_NAME
131 #endif
132 #define DYNINST_CLASS_NAME BPatch_addressSpace
133
134 class BPATCH_DLL_EXPORT BPatch_addressSpace : public BPatch_eventLock {
135     friend class BPatch;
136     friend class BPatch_image;
137     friend class BPatch_function;
138     friend class BPatch_frame;
139     friend class BPatch_module;
140     friend class BPatch_basicBlock;
141     friend class BPatch_flowGraph;
142     friend class BPatch_loopTreeNode;
143     friend class BPatch_point;
144     friend class BPatch_funcCallExpr;
145     friend class BPatch_eventMailbox;
146     friend class BPatch_instruction;
147   
148  protected:
149     
150   BPatch_function *findOrCreateBPFunc(int_function *ifunc, 
151                                       BPatch_module *bpmod);
152
153   BPatch_point *findOrCreateBPPoint(BPatch_function *bpfunc, instPoint *ip,
154                                             BPatch_procedureLocation pointType);
155   
156   BPatch_Vector<batchInsertionRecord *> *pendingInsertions;
157
158   BPatch_funcMap *func_map;
159   BPatch_instpMap *instp_map;
160   
161   BPatch_image *image;
162
163   //  AddressSpace * as;
164   
165  
166  public:
167
168   BPatch_addressSpace();
169
170   virtual AddressSpace * getAS() = 0;
171
172   virtual ~BPatch_addressSpace();
173
174   // Distinguishes between BPatch_process and BPatch_binaryEdit
175   virtual bool getType() = 0;  
176
177   // Returns back bools for variables that are BPatch_process member variables,
178   //   the return value is hardcoded for BPatch_binaryEdit
179   virtual bool getTerminated() = 0;
180   virtual bool getMutationsActive() = 0;
181
182   //Insert snippet functions are virtual right now ... can be moved up to BPatch_addressSpace
183   //   if the implementations are the same
184   virtual BPatchSnippetHandle * insertSnippet(const BPatch_snippet &expr, BPatch_point &point,
185                                               BPatch_snippetOrder order = BPatch_firstSnippet) = 0;
186   
187   virtual BPatchSnippetHandle * insertSnippet(const BPatch_snippet &expr, BPatch_point &point,
188                                               BPatch_callWhen when,
189                                               BPatch_snippetOrder order = BPatch_firstSnippet) = 0;
190
191   virtual BPatchSnippetHandle * insertSnippet(const BPatch_snippet &expr,
192                                               const BPatch_Vector<BPatch_point *> &points,
193                                               BPatch_snippetOrder order = BPatch_firstSnippet) = 0;
194   
195   
196   virtual BPatchSnippetHandle * insertSnippet(const BPatch_snippet &expr,
197                                               const BPatch_Vector<BPatch_point *> &points,
198                                               BPatch_callWhen when,
199                                               BPatch_snippetOrder order = BPatch_firstSnippet) = 0;
200   
201   virtual void beginInsertionSet() = 0;
202
203   virtual bool finalizeInsertionSet(bool atomic, bool *modified) = 0;
204  
205
206   //  BPatch_process::deleteSnippet
207   //  
208   //  Remove instrumentation from the mutatee process
209
210   API_EXPORT(Int, (handle),
211              bool,deleteSnippet,(BPatchSnippetHandle *handle));
212
213   //  BPatch_process::replaceCode
214   //
215   //  Replace a point (must be an instruction...) with a given BPatch_snippet
216
217     API_EXPORT(Int, (point, snippet), 
218     bool, replaceCode, (BPatch_point *point, BPatch_snippet *snippet));
219
220     //  BPatch_process::replaceFunctionCall
221     //  
222     //  Replace function call at one point with another
223
224     API_EXPORT(Int, (point, newFunc),
225     bool,replaceFunctionCall,(BPatch_point &point, BPatch_function &newFunc));
226
227     //  BPatch_process::removeFunctionCall
228     //  
229     //  Remove function call at one point 
230
231     API_EXPORT(Int, (point),
232     bool,removeFunctionCall,(BPatch_point &point));
233
234     //  BPatch_process::replaceFunction
235     //  
236     //  Replace all calls to a function with calls to another
237
238     API_EXPORT(Int, (oldFunc, newFunc),
239     bool,replaceFunction,(BPatch_function &oldFunc, BPatch_function &newFunc));
240
241     //  BPatch_process::getSourceLines
242     //  
243     //  Method that retrieves the line number and file name corresponding 
244     //  to an address
245
246     API_EXPORT(Int, (addr, lines),
247     bool,getSourceLines,(unsigned long addr, BPatch_Vector< BPatch_statement > & lines ));
248     
249     // BPatch_process::getAddressRanges
250     //
251     // Method that retrieves address range(s) for a given filename and line number.
252     
253     API_EXPORT(Int, (fileName, lineNo, ranges),
254     bool,getAddressRanges,(const char * fileName, unsigned int lineNo, std::vector< std::pair< unsigned long, unsigned long > > & ranges ));
255         
256     //  BPatch_process::findFunctionByAddr
257     //  
258     //  Returns the function containing an address
259
260     API_EXPORT(Int, (addr),
261     BPatch_function *,findFunctionByAddr,(void *addr));
262
263      //  BPatch_process::getImage
264     //
265     //  Obtain BPatch_image associated with this BPatch_process
266
267     API_EXPORT(Int, (),
268     BPatch_image *,getImage,());
269
270
271     //  BPatch_process::malloc
272     //  
273     //  Allocate memory for a new variable in the mutatee process
274
275     API_EXPORT(Int, (n),
276     BPatch_variableExpr *,malloc,(int n));
277
278     //  BPatch_process::malloc
279     //  
280     //  Allocate memory for a new variable in the mutatee process
281
282     API_EXPORT(ByType, (type),
283     BPatch_variableExpr *,malloc,(const BPatch_type &type));
284
285     //  BPatch_process::free
286     //  
287     //  Free memory allocated by Dyninst in the mutatee process
288
289     API_EXPORT(Int, (ptr),
290     bool,free,(BPatch_variableExpr &ptr));
291
292
293 };
294
295 #endif