Function wrapping implementation and Symtab extensions for undefined symbols
[dyninst.git] / patchAPI / h / PatchCallback.h
1 /* PatchAPI has a CFG that it uses to specify instrumentation
2    and modification. Users may extend this CFG by deriving
3    their own classes, or annotate it with their own data. To
4    inform users when the CFG changes we provide a callback
5    interface. */
6
7 #if !defined(_PATCH_CALLBACK_H_)
8 #define _PATCH_CALLBACK_H_
9
10 #include <vector>
11
12
13 namespace Dyninst {
14 namespace PatchAPI {
15
16 class PatchObject;
17 class PatchFunction;
18 class PatchBlock;
19 class PatchEdge;
20 class Point;
21
22 class PatchCallback {
23
24   public:
25   PatchCallback() : batching_(false) {};
26    virtual ~PatchCallback() {};
27
28    typedef enum {
29       source,
30       target } edge_type_t;
31
32    // Users override these to provide their callbacks
33   protected:
34    virtual void destroy_cb(PatchBlock *) {};
35    virtual void destroy_cb(PatchEdge *) {};
36    virtual void destroy_cb(PatchFunction *) {};
37    virtual void destroy_cb(PatchObject *) {};
38
39
40    virtual void create_cb(PatchBlock *) {};
41    virtual void create_cb(PatchEdge *) {};
42    virtual void create_cb(PatchFunction *) {};
43    virtual void create_cb(PatchObject *) {};
44
45    // Some more abstract ones
46    virtual void split_block_cb(PatchBlock *, PatchBlock *) {};
47
48    virtual void remove_edge_cb(PatchBlock *, PatchEdge *, edge_type_t) {};
49    virtual void add_edge_cb(PatchBlock *, PatchEdge *, edge_type_t) {};
50
51    virtual void remove_block_cb(PatchFunction *, PatchBlock *) {};
52    virtual void add_block_cb(PatchFunction *, PatchBlock *) {};
53
54    // Points
55    virtual void destroy_cb(Point *) {};
56    virtual void create_cb(Point *) {};
57    // If we split a block, we may change the block a Point belongs to. 
58    virtual void change_cb(Point *, PatchBlock *, PatchBlock *) {};
59
60   public:
61    // And these methods are used by PatchAPI and should not be overridden.
62    void batch_begin();
63    void batch_end();
64
65    void destroy(PatchBlock *);
66    void destroy(PatchEdge *);
67    void destroy(PatchFunction *);
68    void destroy(PatchObject *);
69
70    void create(PatchBlock *); 
71    void create(PatchEdge *); 
72    void create(PatchFunction *); 
73    void create(PatchObject *); 
74
75    void split_block(PatchBlock *, PatchBlock *);
76    void remove_edge(PatchBlock *, PatchEdge *, edge_type_t);
77    void add_edge(PatchBlock *, PatchEdge *, edge_type_t);
78    
79    void remove_block(PatchFunction *, PatchBlock *);
80    void add_block(PatchFunction *, PatchBlock *);
81
82    void destroy(Point *);
83    void create(Point *);
84    void change(Point *, PatchBlock *, PatchBlock *);
85
86
87   private:
88
89    bool batching_;
90
91    typedef enum { removed, added } mod_t;
92    struct BlockMod {
93       PatchBlock *block;
94       PatchEdge *edge;
95       edge_type_t type;
96       mod_t mod;
97    BlockMod(PatchBlock *b, PatchEdge *e, edge_type_t t, mod_t m) : block(b), edge(e), type(t), mod(m) {};
98    };
99
100    struct FuncMod {
101       PatchFunction *func;
102       PatchBlock *block;
103       mod_t mod;
104    FuncMod(PatchFunction *f, PatchBlock *b, mod_t m) : func(f), block(b), mod(m) {};
105    };
106
107    struct PointMod {
108       Point *point;
109       PatchBlock *old_block;
110       PatchBlock *new_block;
111    PointMod(Point *p, PatchBlock *ob, PatchBlock *nb) : point(p), old_block(ob), new_block(nb) {};
112    };
113
114    typedef std::pair<PatchBlock *, PatchBlock *> BlockSplit;
115    std::vector<PatchEdge *> destroyedEdges_;
116    std::vector<PatchBlock *> destroyedBlocks_;
117    std::vector<PatchFunction *> destroyedFuncs_;
118    std::vector<PatchObject *> destroyedObjects_;
119
120    std::vector<PatchEdge *> createdEdges_;
121    std::vector<PatchBlock *> createdBlocks_;
122    std::vector<PatchFunction *> createdFuncs_;
123    std::vector<PatchObject *> createdObjects_;
124
125    std::vector<BlockMod> blockMods_;
126    std::vector<FuncMod> funcMods_;
127    std::vector<BlockSplit> blockSplits_;
128
129    std::vector<Point *> destroyedPoints_;
130    std::vector<Point *> createdPoints_;
131    std::vector<PointMod> pointMods_;
132 };
133
134 };
135 };
136
137 #endif