Remove incorrect export declaration
[dyninst.git] / patchAPI / h / PatchObject.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 /* Plugin Interface */
31
32 #ifndef PATCHAPI_H_DYNINST_OBJECT_H_
33 #define PATCHAPI_H_DYNINST_OBJECT_H_
34
35 #include "PatchCommon.h"
36 #include "CFGMaker.h"
37
38 namespace Dyninst {
39 namespace PatchAPI {
40
41 class PatchFunction;
42 class PatchCallback;
43 class PatchParseCallback;
44
45 /* PatchObject represents a binary object, which could be either a library or
46    executable. It is also an instrumentation  unit. */
47 class PATCHAPI_EXPORT PatchObject {
48   friend class AddrSpace;
49   friend class PatchParseCallback;
50
51   public:
52     static PatchObject* create(ParseAPI::CodeObject* co, Address base,
53                                                CFGMaker* cm = NULL,
54                                                PatchCallback *cb = NULL);
55
56     static PatchObject* clone(PatchObject* par_obj, Address base,
57                                                CFGMaker* cm = NULL,
58                                                PatchCallback *cb = NULL);
59
60     virtual ~PatchObject();
61
62     typedef std::vector<PatchFunction *> funclist;
63     typedef std::map<const ParseAPI::Function*, PatchFunction*> FuncMap;
64     typedef std::map<const ParseAPI::Block*, PatchBlock*> BlockMap;
65     typedef std::map<const ParseAPI::Edge*, PatchEdge*> EdgeMap;
66
67     std::string format() const;
68
69     // Getters and setter
70     Address codeBase() const { return codeBase_; }
71     Address codeOffsetToAddr(Address offset) const;
72     Address addrMask() const;
73     ParseAPI::CodeObject* co() const { return co_; }
74     //ParseAPI::CodeSource* cs() const { return cs_; }
75     AddrSpace* addrSpace() const { return addr_space_; }
76     void setAddrSpace(AddrSpace* as);
77     PatchMgrPtr mgr() const;
78
79     // Function
80     PatchFunction *getFunc(ParseAPI::Function *, bool create = true);
81     void addFunc(PatchFunction*);
82     void removeFunc(PatchFunction*);
83     void removeFunc(ParseAPI::Function *);
84     template <class Iter> 
85         void funcs(Iter iter); 
86     // Block
87     PatchBlock *getBlock(ParseAPI::Block*, bool create = true);
88     void addBlock(PatchBlock*);
89     void removeBlock(PatchBlock*);
90     void removeBlock(ParseAPI::Block*);
91     template <class Iter>
92      void blocks(Iter iter); 
93
94     // Edge
95     PatchEdge *getEdge(ParseAPI::Edge*, PatchBlock* = NULL, PatchBlock* = NULL, bool create = true);
96     void addEdge(PatchEdge*);
97     void removeEdge(PatchEdge*);
98     void removeEdge(ParseAPI::Edge*);
99     template <class Iter>
100       void edges(Iter iter); 
101
102     PatchCallback *cb() const { return cb_; }
103
104     bool consistency(const AddrSpace *as) const;
105
106
107   protected:
108     ParseAPI::CodeObject* co_;
109     Address codeBase_;
110     AddrSpace* addr_space_;
111     FuncMap funcs_;
112     BlockMap blocks_;
113     EdgeMap edges_;
114     CFGMaker* cfg_maker_;
115
116     PatchObject(ParseAPI::CodeObject* o, Address a, CFGMaker* cm, PatchCallback *cb = NULL);
117     PatchObject(const PatchObject* par_obj, Address a, CFGMaker* cm, PatchCallback *cb = NULL);
118     void copyCFG(PatchObject* par_obj);
119     bool splitBlock(PatchBlock *first, ParseAPI::Block *second);
120
121     void createFuncs();
122     void createBlocks();
123     void createEdges();
124
125     PatchCallback *cb_;
126     PatchParseCallback *pcb_;
127 };
128
129 template <class Iter>
130    void PatchObject::funcs(Iter iter) {
131    createFuncs();
132    for (FuncMap::iterator tmp = funcs_.begin(); tmp != funcs_.end(); ++tmp) {
133       *iter = tmp->second;
134       ++iter;
135    }
136 }
137
138 template <class Iter>
139    void PatchObject::blocks(Iter iter) {
140    createBlocks();
141    for (BlockMap::iterator tmp = blocks_.begin(); tmp != blocks_.end(); ++tmp) {
142       *iter = tmp->second;
143       ++iter;
144    }
145 }
146
147 template <class Iter>
148    void PatchObject::edges(Iter iter) {
149    createEdges();
150    for (EdgeMap::iterator tmp = edges_.begin(); tmp != edges_.end(); ++tmp) {
151       *iter = tmp->second;
152       ++iter;
153    }
154 }
155
156
157
158 }
159 }
160
161 #endif  // PATCHAPI_H_DYNINST_MODULE_H_