Function wrapping implementation and Symtab extensions for undefined symbols
[dyninst.git] / dyninstAPI / h / BPatch_function.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
32 #ifndef _BPatch_function_h_
33 #define _BPatch_function_h_
34
35 #include "Annotatable.h"
36 #include "BPatch_dll.h"
37 #include "BPatch_Vector.h"
38 #include "BPatch_Set.h"
39 #include "BPatch_enums.h"
40 #include "BPatch_type.h"
41 #include "BPatch_module.h"
42 #include "BPatch_eventLock.h"
43 #include "BPatch_memoryAccess_NP.h"
44 //#include "BPatch_dependenceGraphNode.h"
45 // class BPatch_dependenceGraphNode;
46
47 class func_instance;
48 class process;
49 class InstrucIter;
50
51 class BPatch_localVarCollection;
52 class BPatch_function;
53 class BPatch_point;
54 class BPatch_flowGraph;
55
56 class BPatchTranslatorBase;
57 class ParameterType;
58 class ReturnParameterType;
59
60 namespace Dyninst {
61   namespace ParseAPI {
62     class Function;
63   };
64   namespace PatchAPI {
65      class PatchFunction;
66   };
67 };
68
69 #ifdef DYNINST_CLASS_NAME
70 #undef DYNINST_CLASS_NAME
71 #endif
72 #define DYNINST_CLASS_NAME BPatch_function
73
74 class BPATCH_DLL_EXPORT BPatch_function : 
75    public BPatch_sourceObj, 
76    public BPatch_eventLock,
77    public Dyninst::AnnotatableSparse
78 {
79     friend class BPatch_flowGraph;
80     friend class InstrucIter;
81     friend class BPatch_basicBlock;
82     friend class BPatch_asyncEventHandler;
83     friend class BPatch_image;
84     friend class BPatch_thread;
85     friend class BPatch_process;
86     friend class BPatch_binaryEdit;
87     friend class BPatch_addressSpace;
88     friend class BPatch_point;
89     friend BPatch_Vector<BPatch_point*> *findPoint(
90                      const BPatch_Set<BPatch_opCode>& ops,
91                                                    InstrucIter &ii, 
92                                                    BPatch_process *proc,
93                                                    BPatch_function *bpf);
94
95     //BPatch_process *proc;
96     BPatch_addressSpace *addSpace;
97     AddressSpace *lladdSpace;
98     BPatch_type *retType;
99     BPatch_module *mod;
100     BPatch_flowGraph* cfg;
101     bool cfgCreated;
102     bool liveInit;
103
104     BPatch_point* createMemInstPoint(void *addr, BPatch_memoryAccess* ma);
105
106     func_instance *func;
107     bool varsAndParamsValid;
108
109 private:
110    void constructVarsAndParams();
111
112    void identifyParamDependencies(BPatch_function* callee, void* calleeAddress);
113
114 #if defined(_MSC_VER)
115 #pragma warning(push)
116 #pragma warning(disable:4251) 
117 #endif
118    // Disable warning that these vectors cannot be used externally, 
119    // which is irrelevant since the vectors are private
120    std::map<BPatch_localVar *, BPatch_variableExpr *> local_vars;
121    BPatch_Vector<BPatch_localVar *> params;
122 #if defined(_MSC_VER)
123 #pragma warning(pop)
124 #endif
125
126   public:
127    //dynC internal use only
128    bool hasParamDebugInfo();
129
130 public:
131     virtual     ~BPatch_function();
132
133     // The following are for internal use by the library only:
134     func_instance *lowlevel_func() const { return func; }
135     BPatch_process *getProc() const;
136     BPatch_addressSpace *getAddSpace() const { return addSpace; }
137
138     BPatch_function(BPatch_addressSpace *_addSpace, func_instance *_func, 
139                     BPatch_module *mod = NULL);
140     BPatch_function(BPatch_addressSpace *_addSpace, func_instance *_func,
141                     BPatch_type * _retType, 
142                     BPatch_module *);
143     bool getSourceObj(BPatch_Vector<BPatch_sourceObj *> &);
144     BPatch_sourceObj *getObjParent();
145     BPatch_localVarCollection * localVariables;
146     BPatch_localVarCollection * funcParameters;
147     void setReturnType(BPatch_type * _retType){retType = _retType;}
148     void setModule(BPatch_module *module) { if (this->mod == NULL) this->mod = module;}
149     void removeCFG() { cfg = NULL; }
150     void getUnresolvedControlTransfers(BPatch_Vector<BPatch_point *> &unresolvedCF);
151     void getAbruptEndPoints(BPatch_Vector<BPatch_point *> &abruptEnds);
152     void getCallerPoints(BPatch_Vector<BPatch_point*>& callerPoints);
153     void getAllPoints(BPatch_Vector<BPatch_point*>& allPoints);
154
155     void getEntryPoints(BPatch_Vector<BPatch_point *> &entryPoints);
156     void getExitPoints(BPatch_Vector<BPatch_point *> &entryPoints);
157     void getCallPoints(BPatch_Vector<BPatch_point *> &entryPoints);
158
159     bool setHandlerFaultAddrAddr(Dyninst::Address addr, bool set);
160     void fixHandlerReturnAddr(Dyninst::Address addr);
161     bool removeInstrumentation(bool useInsertionSet);
162     bool parseNewEdge(Dyninst::Address source, Dyninst::Address target);
163     void relocateFunction();
164     bool getSharedFuncs(std::set<BPatch_function*> &funcs);
165
166     void addParam(Dyninst::SymtabAPI::localVar *lvar);
167
168 //    void addParam(const char * _name, BPatch_type *_type, int _linenum,
169 //                  long _frameOffset, int _reg = -1,
170 //                  BPatch_storageClass _sc = BPatch_storageFrameOffset);
171     void fixupUnknown(BPatch_module *);
172     
173
174         // This isn't so much for internal use only, but it *should*
175         // remain undocumented for now.
176     bool containsSharedBlocks();
177
178
179
180     // End of functions for internal use only
181     
182
183     // For users of the library:
184
185     API_EXPORT(Str, (), std::string, getName, ());
186
187     //  BPatch_function::getName
188     //  Returns <demangled> name of function
189     API_EXPORT(Buffer, (s, len),     
190
191     char *,getName,(char *s, int len));
192
193
194     //  BPatch_function::getMangledName
195     //  Returns mangled name of function, same as getName for non-c++ mutatees
196     API_EXPORT(Int, (s, len),
197
198     char *,getMangledName,(char *s, int len));
199
200     //  BPatch_function::getTypedName
201     //  Returns demanged name of function (with type string), may be empty
202     API_EXPORT(Int, (s, len),
203
204     char *,getTypedName,(char *s, int len));
205
206     // BPatch_function::getNames
207     // Adds all names of the function (inc. weak symbols) to the
208     // provided vector. Names are represented as const char *s,
209     // and do not require cleanup by the user.
210
211     API_EXPORT(Int, (names),
212     bool, getNames, (BPatch_Vector<const char *> &names));
213
214     // BPatch_function::getMangledNames
215     // Adds all mangled names of the function (inc. weak symbols) to
216     // the provided vector. Names are represented as const char *s,
217     // and do not require cleanup by the user.
218
219     API_EXPORT(Int, (names),
220     bool, getMangledNames, (BPatch_Vector<const char *> &names));
221
222     //  BPatch_function::getBaseAddr
223     //  Returns base address of function
224     API_EXPORT(Int, (),
225
226     void *,getBaseAddr,(void));
227
228     //  BPatch_function::getReturnType
229     //  Returns the <BPatch_type> return type of this function
230
231     API_EXPORT(Int, (),
232
233     BPatch_type *,getReturnType,());
234
235     //  BPatch_function::getModule
236     //  Returns the BPatch_module to which this function belongs
237
238     API_EXPORT(Int, (),
239
240     BPatch_module *,getModule,());
241     
242     //  BPatch_function::getParams
243     //  Returns a vector of BPatch_localVar, representing this function's parameters
244
245     API_EXPORT(Int, (),
246
247     BPatch_Vector<BPatch_localVar *> *,getParams,());
248
249     //  BPatch_function::getVars
250     //  Returns a vector of local variables in this functions
251
252     API_EXPORT(Int, (),
253
254     BPatch_Vector<BPatch_localVar *> *,getVars,());
255
256     //  BPatch_function::findPoint
257     //  Returns a vector of inst points, corresponding to the given BPatch_procedureLocation
258
259     API_EXPORT(Int, (loc),
260
261     BPatch_Vector<BPatch_point *> *,findPoint,(CONST_EXPORT BPatch_procedureLocation loc));
262
263     //  BPatch_function::findPoint
264     //  Returns a vector of inst points, corresponding to the given set of op codes
265
266     API_EXPORT(ByOp, (ops),
267
268     BPatch_Vector<BPatch_point *> *,findPoint,(const BPatch_Set<BPatch_opCode>& ops));
269
270     //  BPatch_function::findLocalVar
271     //  Returns a BPatch_localVar, if a match for <name> is found
272
273     API_EXPORT(Int, (name),
274
275     BPatch_localVar *,findLocalVar,(const char * name));
276
277     //  BPatch_function::findLocalParam
278     //  Returns a BPatch_localVar, if a match for <name> is found
279
280     API_EXPORT(Int, (name),
281
282     BPatch_localVar *,findLocalParam,(const char * name));
283
284     //  BPatch_function::findVariable
285     //  Returns a set of variables matching <name> at the scope of this function
286     //  -- or global scope, if nothing found in this scope 
287
288     API_EXPORT(Int, (name),
289     BPatch_Vector<BPatch_variableExpr *> *,findVariable,(const char *name));
290
291     API_EXPORT(Int, (name, vars),
292     bool, findVariable,(const char *name, BPatch_Vector<BPatch_variableExpr*> &vars));
293
294     //  BPatch_function::getVariables
295     //  This returns false, and should probably not exist.  See getVars.
296     //  is this defined, what variables should be returned??
297     //  FIXME (delete me)
298
299     API_EXPORT(Int, (vect),
300
301     bool,getVariables,(BPatch_Vector<BPatch_variableExpr *> &vect));
302
303     //  BPatch_function::getModuleName
304     //  Returns name of module this function belongs to
305
306     API_EXPORT(Int, (name, maxLen),
307
308     char *,getModuleName,(char *name, int maxLen));
309
310     //  BPatch_function::isInstrumentable
311     //  
312     // Returns true if the function is instrumentable.
313
314
315     API_EXPORT(Int, (),
316
317     bool,isInstrumentable,());
318
319     //  BPatch_function::isSharedLib
320     //  Returns true if this function lives in a shared library
321
322     API_EXPORT(Int, (),
323
324     bool,isSharedLib,());
325
326     //  BPatch_function::getCFG
327     //  
328     //  method to create the control flow graph for the function
329
330     API_EXPORT(Int, (),
331
332     BPatch_flowGraph*,getCFG,());
333
334     API_EXPORT(Int, (name, isPrimary, isMangled),
335     const char *, addName, (const char *name, bool isPrimary = true, bool isMangled = false));           
336
337     //  Return native pointer to the function. 
338     //  Allocates and returns a special type of BPatch_variableExpr.
339     API_EXPORT( Int, (), BPatch_variableExpr *, getFunctionRef, () );
340
341     // Get all functions that share a block (or any code, but it will
342     // always be a block) with this function.
343     API_EXPORT( Int, (funcs), bool, findOverlapping, (BPatch_Vector<BPatch_function *> &funcs));
344
345     //  Get the underlying ParseAPI Function
346     API_EXPORT( Int, (), Dyninst::ParseAPI::Function *, getParseAPIFunc, () );
347     //  Get the underlying PatchAPI Function
348     API_EXPORT( Int, (), Dyninst::PatchAPI::PatchFunction *, getPatchAPIFunc, () );
349
350
351     API_EXPORT(Int, (start, end),
352     bool,getAddressRange,(void * &start, void * &end));
353
354     API_EXPORT(Int, (start, end),
355                bool,getAddressRange,(Dyninst::Address &start, Dyninst::Address &end));
356 };
357
358 #endif /* _BPatch_function_h_ */