Added features to dyninstAPI library, including the ability to delete
[dyninst.git] / dyninstAPI / src / BPatch_image.C
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 #include <stdio.h>
43 #include <assert.h>
44 #include <string.h>
45
46 #include "process.h"
47 #include "symtab.h"
48
49 #include "BPatch.h"
50 #include "BPatch_image.h"
51 #include "BPatch_type.h"
52
53
54 /*
55  * BPatch_image::BPatch_image
56  *
57  * Construct a BPatch_image for the given process.
58  */
59
60 BPatch_image::BPatch_image(process *_proc) : proc(_proc)
61 {
62 }
63
64
65 /*
66  * BPatch_image::getProcedures
67  *
68  * Returns a list of all procedures in the image upon success, and NULL
69  * upon failure.
70  */
71 BPatch_Vector<BPatch_function *> *BPatch_image::getProcedures()
72 {
73     BPatch_Vector<BPatch_function *> *proclist =
74         new BPatch_Vector<BPatch_function *>;
75
76     if (proclist == NULL) return NULL;
77
78     // XXX Maybe getIncludedFunction instead?  Depends on what we want
79     //     to do to support the MDL exclude_lib function.
80     // XXX Also, what should we do about getting rid of this?  Should
81     //     the BPatch_functions already be made and kept around as long
82     //     as the process is, so the user doesn't have to delete them?
83     vector<function_base *> *funcs = proc->getAllFunctions();
84
85     for (unsigned int f = 0; f < funcs->size(); f++) {
86         BPatch_function *bpfunc = new BPatch_function((*funcs)[f]);
87         proclist->push_back(bpfunc);
88     }
89
90     return proclist;
91 }
92
93
94 /*
95  * BPatch_image::findProcedurePoint
96  *
97  * Returns a vector of the instrumentation points from a procedure that are
98  * identified by the paramteres.
99  *
100  * name         The name of the procedure in which to look up the points.
101  * loc          The points within the procedure to return.  The following
102  *              values are valid for this parameter:
103  *                BPatch_entry         The function's entry point.
104  *                BPatch_exit          The function's exit point(s).
105  *                BPatch_subroutine    The points at which the procedure calls
106  *                                     other procedures.
107  *                BPatch_longJump      The points at which the procedure make
108  *                                     long jump calls.
109  *                BPatch_allLocations  All of the points described above.
110  */
111 BPatch_Vector<BPatch_point*> *BPatch_image::findProcedurePoint(
112         const char *name, const BPatch_procedureLocation loc)
113 {
114     /*
115      * XXXX We'd like to get a list of the functions with the name:
116     vector<function_base *> flist;
117
118     if (!proc->findFunction(name, flist))
119         return NULL;
120      * but we don't seem to have a way to do that right now.
121      */
122
123     function_base *func = proc->findOneFunction(name);
124
125     BPatch_Vector<BPatch_point*> *result = new BPatch_Vector<BPatch_point *>;
126
127 //    for (unsigned func_num = 0; func_num < flist.size(); func_num++) {
128         if (loc == BPatch_entry || loc == BPatch_allLocations) {
129             BPatch_point *new_point = new BPatch_point(func->funcEntry(proc));
130             result->push_back(new_point);
131         }
132         if (loc ==  BPatch_exit || loc == BPatch_allLocations) {
133             const vector<instPoint *> &points = func->funcExits(proc);
134             for (unsigned i = 0; i < points.size(); i++) {
135                 BPatch_point *new_point = new BPatch_point(points[i]);
136                 result->push_back(new_point);
137             }
138         }
139         if (loc ==  BPatch_subroutine || loc == BPatch_allLocations) {
140             const vector<instPoint *> &points = func->funcCalls(proc);
141             for (unsigned i = 0; i < points.size(); i++) {
142                 BPatch_point *new_point = new BPatch_point(points[i]);
143                 result->push_back(new_point);
144             }
145         }
146         if (loc ==  BPatch_longJump /* || loc == BPatch_allLocations */) {
147             /* XXX Not yet implemented */
148             assert( 0 );
149         }
150 //    }
151
152     return result;
153 }
154
155
156 /*
157  * BPatch_image::findFunction
158  *
159  * Returns a BPatch_function* representing the named function upon success,
160  * and NULL upon failure.
161  *
162  * name         The name of function to look up.
163  */
164 BPatch_function *BPatch_image::findFunction(const char *name)
165 {
166     function_base *func = proc->findOneFunction(name);
167
168     if (func == NULL)
169         return NULL;
170
171     return new BPatch_function(func);
172 }
173
174
175 /*
176  * BPatch_image::findVariable
177  *
178  * Returns a BPatch_variableExpr* representing the given variable in the
179  * application image.  If no such variable exists, returns NULL.
180  *
181  * name         The name of the variable to look up.
182  *
183  * First look for the name with an `_' prepended to it, and if that is not
184  *   found try the original name.
185  */
186 BPatch_variableExpr *BPatch_image::findVariable(const char *name)
187 {
188     string full_name = string("_") + string(name);
189
190     Symbol syminfo;
191     if (!proc->getSymbolInfo(full_name, syminfo)) {
192         string short_name(name);
193         if (!proc->getSymbolInfo(short_name, syminfo)) {
194             return NULL;
195         }
196     }
197
198     // XXX Need to find out type and use it
199     BPatch_type *type = BPatch::bpatch->type_Untyped;
200
201     return new BPatch_variableExpr((void *)syminfo.addr(), type);
202 }
203
204 /*
205  * BPatch_image::findType
206  *
207  * Returns a BPatch_type* representing the named type.  If no such type
208  * exists, returns NULL.
209  *
210  * name         The name of type to look up.
211  */
212 BPatch_type *BPatch_image::findType(const char *name)
213 {
214     assert(BPatch::bpatch != NULL);
215     return BPatch::bpatch->stdTypes->findType(name);
216
217     /*
218      * XXX When we have the info we need from the symbol table, we'll add some
219      * more code here that checks it if "name" isn't found in the standard
220      * types.
221      */
222 }