Remove incorrect export declaration
[dyninst.git] / patchAPI / h / PatchMgr.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 /* Public Interface */
31
32 #ifndef PATCHAPI_H_PATCHMGR_H_
33 #define PATCHAPI_H_PATCHMGR_H_
34
35
36
37 #include "PatchCommon.h"
38 #include "Point.h"
39 #include "Instrumenter.h"
40 #include "PatchCFG.h"
41 #include "Buffer.h"
42
43 namespace Dyninst {
44 namespace PatchAPI {
45
46 /* Interfaces for point query, snippet insertion and removal in batch
47    mode */
48
49 class PatchObject;
50 class PatchMgr;
51 class PatchFunction;
52 class PatchBlock;
53
54 struct Scope {
55    PatchObject *obj;
56    PatchFunction *func;
57    PatchBlock *block;
58    bool wholeProgram;
59 Scope(PatchBlock *b) : obj(NULL), func(NULL), block(b), wholeProgram(false) {};
60 Scope(PatchFunction *f, PatchBlock *b) : obj(NULL), func(f), block(b), wholeProgram(false) {};
61 Scope(PatchFunction *f) : obj(NULL), func(f), block(NULL), wholeProgram(false) {};
62 };
63
64
65 class PATCHAPI_EXPORT PatchMgr : public boost::enable_shared_from_this<PatchMgr> {
66   friend class Point;
67   friend class PatchObject; // for splitting blocks as that is _not_ public.
68   typedef std::pair<PatchFunction *, PatchBlock *> BlockInstance;
69   typedef std::pair<PatchFunction *, InsnLoc_t> InsnInstance;
70   typedef std::vector<PatchFunction *> Functions;
71   typedef std::vector<PatchBlock *> Blocks;
72   typedef std::vector<PatchEdge *> Edges;
73   typedef std::vector<BlockInstance> BlockInstances;
74   typedef std::vector<InsnInstance> InsnInstances;
75   typedef std::vector<CallSite_t> CallSites;
76   typedef std::vector<ExitSite_t> ExitSites;
77   typedef std::vector<InsnLoc_t> Insns;
78   typedef std::vector<Point::Type> EnumeratedTypes;
79
80   public:
81   typedef boost::shared_ptr<PatchMgr> Ptr;
82   typedef std::pair<Location, Point::Type> Candidate;
83   typedef std::vector<Candidate> Candidates;
84
85   static void version(int &major, int &minor, int &maintenance);
86
87     PatchMgr(AddrSpace* as,  Instrumenter* inst, PointMaker* pf);
88     virtual ~PatchMgr();
89     static PatchMgrPtr create(AddrSpace* as,
90                                               Instrumenter* inst = NULL,
91                                               PointMaker* pf = NULL);
92
93     // Default implementation for filter function,
94     // used in findPoins and removeSnippets
95     template <class T>
96     class IdentityFilterFunc {
97       public:
98        bool operator()(Point::Type, Location, T) { return true;}
99     };
100
101     // Query Points:
102
103     // Direct interface; specify a Location and a unique Type, receive a Point.
104     Point *findPoint(Location loc,
105                                      Point::Type type,
106                                      bool create = true);
107     // And accumulation version
108     template <class OutputIterator> 
109     bool findPoint(Location loc,
110                    Point::Type type,
111                    OutputIterator outputIter,
112                    bool create = true);
113
114     // Group interface with one degree of freedom: the Type can be a composition.
115     template <class FilterFunc, class FilterArgument, class OutputIterator>
116     bool findPoints(Location loc,
117                     Point::Type types,
118                     FilterFunc filter_func,
119                     FilterArgument filter_arg,
120                     OutputIterator outputIter,
121                     bool create = true);
122
123     template <class OutputIterator>
124     bool findPoints(Location loc,
125                     Point::Type types,
126                     OutputIterator outputIter,
127                     bool create = true);
128
129     // Group interface with two degrees of freedom: Locations are wildcarded
130     // and Type can be a composition. Instead, users provide a Scope and a
131     // FilterFunc that guide which Locations will be considered.
132     template <class FilterFunc, class FilterArgument, class OutputIterator>
133     bool findPoints(Scope scope,
134                     Point::Type types,
135                     FilterFunc filter_func,
136                     FilterArgument filter_arg,
137                     OutputIterator output_iter,
138                     bool create = true);
139
140     // Use default identity filter function
141     template <class OutputIterator>
142     bool findPoints(Scope scope,
143                     Point::Type types,
144                     OutputIterator output_iter,
145                     bool create = true);
146
147     // Snippet instance removal
148     // Return false if no point if found
149     bool removeSnippet(InstancePtr);
150
151     // Delete ALL snippets at certain points.
152     // This uses the same filter-based interface as findPoints.
153     template <class FilterFunc, class FilterArgument>
154     bool removeSnippets(Scope scope,
155                         Point::Type types,
156                         FilterFunc filter_func,
157                         FilterArgument filter_arg) {
158       PointSet points;
159       if (!findPoints(scope, types, filter_func, filter_arg,
160                       inserter(points, points.begin()) ) ) return false;
161
162        for (PointIter p = points.begin(); p != points.end(); p++) {
163          (*p)->clear();
164        }
165        return true;
166     }
167
168     void destroy(Point *);
169
170     // Use default identity filter function.
171     bool removeSnippets(Scope scope,
172                         Point::Type types) {
173       IdentityFilterFunc<char*> filter_func;
174       char *foo = NULL;
175       return removeSnippets<IdentityFilterFunc<char *>, char*>(scope, types, filter_func, foo);
176     }
177
178     // Getters
179     AddrSpace* as() const { return as_; }
180     PointMaker* pointMaker() const { return point_maker_; }
181     Instrumenter* instrumenter() const { return instor_; }
182     //----------------------------------------------------
183     // Mapping order: Scope -> Type -> Point Set
184     //   The Scope x Type provides us a list of matching locations;
185     //   we then filter those locations. Points are stored in
186     //   their contexts (e.g., Functions or Blocks). 
187     //----------------------------------------------------
188     bool getCandidates(Scope &, Point::Type types, Candidates &ret);
189
190     bool consistency() const;
191
192   private:
193
194     bool findInsnPointsByType(Location *, Point::Type, PointSet&, bool create = true);
195     bool findBlockPointsByType(Location *, Point::Type, PointSet&, bool create = true);
196     bool findEdgePointsByType(Location *, Point::Type, PointSet&, bool create = true);
197     bool findFuncPointsByType(Location *, Point::Type, PointSet&, bool create = true);
198     bool findFuncSitePointsByType(Location *, Point::Type, PointSet&, bool create = true);
199
200     bool wantFuncs(Scope &scope, Point::Type types);
201     bool wantCallSites(Scope &scope, Point::Type types);
202     bool wantExitSites(Scope &scope, Point::Type types);
203     bool wantBlocks(Scope &scope, Point::Type types);
204     bool wantEdges(Scope &scope, Point::Type types);
205     bool wantInsns(Scope &scope, Point::Type types);
206     bool wantBlockInstances(Scope &scope, Point::Type types);
207     //bool wantEdgeInstances(Scope &scope, Point::Type types);
208     bool wantInsnInstances(Scope &scope, Point::Type types);
209
210     void getFuncCandidates(Scope &scope, Point::Type types, Candidates &ret);
211     void getCallSiteCandidates(Scope &scope, Point::Type types, Candidates &ret);
212     void getExitSiteCandidates(Scope &scope, Point::Type types, Candidates &ret);
213     void getBlockCandidates(Scope &scope, Point::Type types, Candidates &ret);
214     void getEdgeCandidates(Scope &scope, Point::Type types, Candidates &ret);
215     void getInsnCandidates(Scope &scope, Point::Type types, Candidates &ret);
216     void getBlockInstanceCandidates(Scope &scope, Point::Type types, Candidates &ret);
217     //bool getEdgeInstanceCandidates(Scope &scope, Point::Type types, Candidates &ret);
218     void getInsnInstanceCandidates(Scope &scope, Point::Type types, Candidates &ret);
219
220     void getFuncs(Scope &scope, Functions &funcs);
221     void getCallSites(Scope &scope, CallSites &Sites);
222     void getExitSites(Scope &scope, ExitSites &Sites);
223     void getBlocks(Scope &scope, Blocks &blocks);
224     void getEdges(Scope &scope, Edges &edges);
225     void getInsns(Scope &scope, Insns &insns);
226     void getBlockInstances(Scope &scope, BlockInstances &blocks);
227     //bool getEdgeInstances(Scope &scope, EdgeCandidates &edges);
228     void getInsnInstances(Scope &scope, InsnInstances &insns);
229
230     void enumerateTypes(Point::Type types, EnumeratedTypes &out);
231
232     bool match(Point *, Location *);
233     bool verify(Location &loc);
234     PointMaker* point_maker_;
235     Instrumenter* instor_;
236     AddrSpace* as_;
237
238 };
239
240
241 template <class FilterFunc, class FilterArgument, class OutputIterator>
242 bool PatchMgr::findPoints(Scope scope,
243                           Point::Type types,
244                           FilterFunc filter_func,
245                           FilterArgument filter_arg,
246                           OutputIterator output_iter,
247                           bool create) {
248    Candidates candidates;
249    if (!getCandidates(scope, types, candidates)) return false;
250    for (Candidates::iterator c = candidates.begin();
251         c != candidates.end(); ++c) {
252       if (filter_func(c->second, c->first, filter_arg)) {
253          if (!findPoint(c->first, c->second, output_iter, create)) {
254             return false;
255          }
256       }
257    }
258    return true;
259 };
260
261 template <class FilterFunc, class FilterArgument, class OutputIterator>
262 bool PatchMgr::findPoints(Location loc, Point::Type types,
263                 FilterFunc filter_func, FilterArgument filter_arg,
264                 OutputIterator outputIter, bool create) {
265    EnumeratedTypes tmp;
266    enumerateTypes(types, tmp);
267    for (EnumeratedTypes::iterator iter = tmp.begin();
268         iter != tmp.end(); ++iter) {
269       if (filter_func(*iter, loc, filter_arg)) {
270          if (!findPoint(loc, *iter, outputIter, create)) return false;
271       }
272    }
273    return true;
274 }
275
276 template <class OutputIterator>
277 bool PatchMgr::findPoints(Location loc, Point::Type types,
278                           OutputIterator outputIter, bool create) {
279    IdentityFilterFunc<char *> filter_func;
280    char *dummy = NULL;
281    return findPoints(loc, types, filter_func, dummy, outputIter, create);
282 };
283
284 // Use default identity filter function
285 template <class OutputIterator>
286 bool PatchMgr::findPoints(Scope scope,
287                           Point::Type types,
288                           OutputIterator output_iter,
289                           bool create) {
290    IdentityFilterFunc<char*> filter_func;
291    char* dummy = NULL;
292    return findPoints<IdentityFilterFunc<char*>, char*, OutputIterator>
293       (scope, types, filter_func, dummy, output_iter, create);
294 };
295
296 template <class OutputIterator>
297 bool PatchMgr::findPoint(Location loc, Point::Type type,
298                OutputIterator outputIter,
299                bool create) {
300    Point *p = findPoint(loc, type, create);
301    if (p) {
302       *outputIter = p;
303       ++outputIter;
304    }
305    return (!create || p);
306 };
307
308
309 };
310 };
311
312
313
314 #endif  // PATCHAPI_H_PATCHMGR_H_
315