More gcc 4.8 fixes.
[dyninst.git] / dyninstAPI / h / BPatch_addressSpace.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 #ifndef _BPatch_addressSpace_h_
32 #define _BPatch_addressSpace_h_
33
34 #include "boost/shared_ptr.hpp"
35 #include "BPatch_dll.h"
36 #include "BPatch_Vector.h"
37 #include "BPatch_enums.h"
38 #include "BPatch_instruction.h" // for register type
39 #include "BPatch_callbacks.h"
40
41 #include <vector>
42
43 #include <stdio.h>
44 #include <signal.h>
45
46 // PatchAPI stuffs
47 //#include "Command.h"
48
49 class BPatch_addressSpace;
50
51 namespace Dyninst {
52   namespace PatchAPI { 
53     class PatchMgr;
54     class DynAddrSpace;
55     class Patcher;
56     class Instance;
57     class PatchFunction;
58     class Point;
59     typedef boost::shared_ptr<PatchMgr> PatchMgrPtr;
60     typedef boost::shared_ptr<DynAddrSpace> DynAddrSpacePtr;
61     typedef boost::shared_ptr<Instance> InstancePtr;
62     BPATCH_DLL_EXPORT PatchMgrPtr convert(const BPatch_addressSpace *);
63   };
64   namespace SymtabAPI {
65     class Symbol;
66   };
67 }
68
69
70 class BPatch_statement;
71 class BPatch_snippet;
72 class BPatch_point;
73 class BPatch_variableExpr;
74 class BPatch_type;
75 class AddressSpace;
76 class miniTrampHandle;
77 class miniTramp;
78 class BPatch;
79 class BPatch_image;
80
81 struct batchInsertionRecord;
82 class instPoint;
83 class int_variable;
84
85 typedef enum{
86   TRADITIONAL_PROCESS, STATIC_EDITOR
87 } processType;
88
89
90 class BPATCH_DLL_EXPORT BPatchSnippetHandle {
91   friend class BPatch_point;
92   friend class BPatch_image;
93   friend class BPatch_process;
94   friend class BPatch_binaryEdit;
95   friend class BPatch_addressSpace;
96   friend class BPatch_thread;
97
98  private:    
99   // Address Space snippet belogns to
100   BPatch_addressSpace *addSpace_;
101
102   // low-level mappings for removal
103   std::vector<Dyninst::PatchAPI::InstancePtr> instances_;
104
105   //  a flag for catchup
106   bool catchupNeeded;
107   //  and a list of threads to apply catchup to
108   BPatch_Vector<BPatch_thread *> catchup_threads;
109     
110   BPatchSnippetHandle(BPatch_addressSpace * addSpace);
111
112   void addInstance(Dyninst::PatchAPI::InstancePtr p) { instances_.push_back(p); }
113     
114  public:
115  
116   ~BPatchSnippetHandle();
117
118   // Returns whether the installed miniTramps use traps.
119   // Not 100% accurate due to internal Dyninst design; we can
120   // have multiple instances of instrumentation due to function
121   // relocation.
122   bool usesTrap();
123   bool isEmpty() 
124   {
125     return instances_.empty();
126   }
127   
128
129   // mtHandles_ is not empty, , returns the function that the 
130   // instrumentation was added to 
131   BPatch_function * getFunc ();
132
133   BPatch_addressSpace * getAddressSpace();
134
135   BPatch_process * getProcess();
136     
137   BPatch_Vector<BPatch_thread *> & getCatchupThreads();
138
139 };
140
141 class BPATCH_DLL_EXPORT BPatch_addressSpace {
142   friend class BPatch;
143   friend class BPatch_image;
144   friend class BPatch_function;
145   friend class BPatch_frame;
146   friend class BPatch_module;
147   friend class BPatch_basicBlock;
148   friend class BPatch_flowGraph;
149   friend class BPatch_loopTreeNode;
150   friend class BPatch_point;
151   friend class BPatch_funcCallExpr;
152   friend class BPatch_eventMailbox;
153   friend class BPatch_instruction;
154   friend Dyninst::PatchAPI::PatchMgrPtr Dyninst::PatchAPI::convert(const BPatch_addressSpace *);
155   
156  public:
157     
158   BPatch_function *findOrCreateBPFunc(Dyninst::PatchAPI::PatchFunction *ifunc, 
159                                       BPatch_module *bpmod);
160
161   BPatch_point *findOrCreateBPPoint(BPatch_function *bpfunc, 
162                                     Dyninst::PatchAPI::Point *ip,
163                                     BPatch_procedureLocation pointType);
164
165   BPatch_variableExpr *findOrCreateVariable(int_variable *v,
166                                             BPatch_type *type = NULL);
167
168  protected:
169   
170   
171   // These callbacks are triggered by lower-level code and forward
172   // calls up to the findOrCreate functions.
173   static BPatch_function *createBPFuncCB(AddressSpace *p,
174                                          Dyninst::PatchAPI::PatchFunction *f);
175   static BPatch_point *createBPPointCB(AddressSpace *p,
176                                        Dyninst::PatchAPI::PatchFunction *f,
177                                        Dyninst::PatchAPI::Point *ip, 
178                                        int type);
179
180   BPatch_Vector<batchInsertionRecord *> *pendingInsertions;
181
182   BPatch_image *image;
183
184   //  AddressSpace * as;
185   
186   std::vector<BPatch_register> registers_;
187
188  protected:
189   virtual void getAS(std::vector<AddressSpace *> &as) = 0;
190
191  public:
192
193   BPatch_addressSpace();
194
195
196   virtual ~BPatch_addressSpace();
197
198   // Distinguishes between BPatch_process and BPatch_binaryEdit
199   virtual bool getType() = 0;  
200
201   // Returns back bools for variables that are BPatch_process member variables,
202   //   the return value is hardcoded for BPatch_binaryEdit
203   virtual bool getTerminated() = 0;
204   virtual bool getMutationsActive() = 0;
205
206   // internal functions, do not use //
207   BPatch_module *findModuleByAddr(Dyninst::Address addr);//doesn't cause parsing
208   bool findFuncsByRange(Dyninst::Address startAddr,
209                         Dyninst::Address endAddr,
210                         std::set<BPatch_function*> &funcs);
211   // end internal functions........ //
212
213
214   //  BPatch_addressSpace::insertSnippet
215   //  
216   //  Insert new code into the mutatee
217   virtual BPatchSnippetHandle * insertSnippet(const BPatch_snippet &expr, 
218                                               BPatch_point &point,
219                                               BPatch_snippetOrder order = BPatch_firstSnippet);
220   
221   //BPatch_addressSpace::insertSnippet
222       
223   //Insert new code into the mutatee, specifying "when" (before/after point)
224
225   virtual BPatchSnippetHandle* insertSnippet(const BPatch_snippet &expr, 
226                                              BPatch_point &point,
227                                              BPatch_callWhen when,
228                                              BPatch_snippetOrder order = BPatch_firstSnippet);
229     
230   //BPatch_addressSpace::insertSnippet
231       
232   //Insert new code into the mutatee at multiple points
233
234   virtual BPatchSnippetHandle * insertSnippet(const BPatch_snippet &expr,
235                                               const BPatch_Vector<BPatch_point *> &points,
236                                               BPatch_snippetOrder order = BPatch_firstSnippet);
237     
238   // BPatch_addressSpace::insertSnippet
239       
240   //Insert new code into the mutatee at multiple points, specifying "when"
241
242   virtual BPatchSnippetHandle * insertSnippet(const BPatch_snippet &expr,
243                                               const BPatch_Vector<BPatch_point *> &points,
244                                               BPatch_callWhen when,
245                                               BPatch_snippetOrder order = BPatch_firstSnippet);
246
247
248
249   
250   virtual void beginInsertionSet() = 0;
251
252   virtual bool finalizeInsertionSet(bool atomic, bool *modified = NULL) = 0;
253  
254
255   //  BPatch_addressSpace::deleteSnippet
256   //  
257   //  Remove instrumentation from the mutatee process
258
259   bool deleteSnippet(BPatchSnippetHandle *handle);
260
261   //  BPatch_addressSpace::replaceCode
262   //
263   //  Replace a point (must be an instruction...) with a given BPatch_snippet
264
265   bool  replaceCode(BPatch_point *point, BPatch_snippet *snippet);
266
267   //  BPatch_addressSpace::replaceFunctionCall
268   //  
269   //  Replace function call at one point with another
270
271   bool replaceFunctionCall(BPatch_point &point, BPatch_function &newFunc);
272
273   //  BPatch_addressSpace::removeFunctionCall
274   //  
275   //  Remove function call at one point 
276
277   bool removeFunctionCall(BPatch_point &point);
278
279   //  BPatch_addressSpace::replaceFunction
280   //  
281   //  Replace all calls to a function with calls to another
282
283   bool replaceFunction(BPatch_function &oldFunc, BPatch_function &newFunc);
284
285   // BPatch_addressSpace::revertReplaceFunction
286   //
287   // Undo the operation of a replace function
288   bool  revertReplaceFunction(BPatch_function &oldFunc);
289
290   // BPatch_addressSpace::wrapFunction
291   //
292   // Replace oldFunc with newFunc as above; however, also rename oldFunc
293   // to the provided name so it can still be reached. 
294
295   bool wrapFunction(BPatch_function *oldFunc, BPatch_function *newFunc, Dyninst::SymtabAPI::Symbol *clone);
296
297   // BPatch_addressSpace::revertWrapFunction
298   //
299   // Undo the operations of a wrapFunction, restoring the original
300   // functionality
301
302   bool revertWrapFunction(BPatch_function *wrappedFunc);
303
304   //  BPatch_addressSpace::getSourceLines
305   //  
306   //  Method that retrieves the line number and file name corresponding 
307   //  to an address
308
309   bool getSourceLines(unsigned long addr, BPatch_Vector< BPatch_statement > & lines );
310     
311   // BPatch_addressSpace::getAddressRanges
312   //
313   // Method that retrieves address range(s) for a given filename and line number.
314     
315   bool getAddressRanges(const char * fileName, unsigned int lineNo, std::vector< std::pair< unsigned long, unsigned long > > & ranges );
316
317   //  DEPRECATED:
318   //  BPatch_addressSpace::findFunctionByAddr
319   //  
320   //  Returns the function containing an address
321
322   BPatch_function * findFunctionByAddr(void *addr);
323
324   //  BPatch_addressSpace::findFunctionByEntry
325   //  
326   //  Returns the function starting at the given address
327
328   BPatch_function * findFunctionByEntry(Dyninst::Address entry);
329
330   //  BPatch_addressSpace::findFunctionsByAddr
331   //  
332   //  Returns the functions containing an address 
333   //  (multiple functions are returned when code is shared)
334
335   bool  findFunctionsByAddr(Dyninst::Address addr, 
336                             std::vector<BPatch_function*> &funcs);
337
338   //  BPatch_addressSpace::getImage
339   //
340   //  Obtain BPatch_image associated with this BPatch_addressSpace
341
342   BPatch_image * getImage();
343
344
345   //  BPatch_addressSpace::malloc
346   //  
347   //  Allocate memory for a new variable in the mutatee process
348
349   BPatch_variableExpr * malloc(int n, std::string name = std::string(""));
350
351   //  BPatch_addressSpace::malloc
352   //  
353   //  Allocate memory for a new variable in the mutatee process
354   
355   BPatch_variableExpr * malloc(const BPatch_type &type, std::string name = std::string(""));
356   
357   BPatch_variableExpr * createVariable(Dyninst::Address at_addr, 
358                                        BPatch_type *type,
359                                        std::string var_name = std::string(""),
360                                        BPatch_module *in_module = NULL);
361
362   //  BPatch_addressSpace::free
363   //  
364   //  Free memory allocated by Dyninst in the mutatee process
365   
366   bool free(BPatch_variableExpr &ptr);
367
368   // BPatch_addressSpace::createVariable
369   // 
370   // Wrap an existing piece of allocated memory with a BPatch_variableExpr.
371   // Used (for instance) by the shared memory library to wrap its externally
372   // allocated memory for use by BPatch.
373   BPatch_variableExpr * createVariable(std::string name, 
374                                        Dyninst::Address addr, 
375                                        BPatch_type *type = NULL);
376   bool  getRegisters(std::vector<BPatch_register> &regs);
377
378   bool  createRegister_NP(std::string regName, BPatch_register &reg); 
379
380   void allowTraps(bool allowtraps);
381
382   //  BPatch_addressSpace::loadLibrary
383   //  
384   //  Load a shared library into the mutatee's address space
385   //  Returns true if successful
386   //
387   //  the reload argument is used by save the world to determine
388   //  if this library should be reloaded by the mutated binary
389   //  when it starts up. this is up to the user because loading
390   //  an extra shared library could hide access to the 'correct'
391   //  function by redefining a function  
392
393   virtual BPatch_object * loadLibrary(const char *libname, bool reload = false) = 0;
394
395   // BPatch_addressSpace::isStaticExecutable
396   //
397   // Returns true if the underlying image represents a 
398   // statically-linked executable, false otherwise
399   bool  isStaticExecutable();
400 };
401
402
403 #endif