Fix bad merge
[dyninst.git] / dyninstAPI / src / block.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
31 #if !defined(_DYN_BLOCK_H_)
32 #define _DYN_BLOCK_H_
33
34 #include "parse-cfg.h"
35 #include "parseAPI/h/CFG.h"
36 #include "instPoint.h"
37 #include "PatchCFG.h"
38 #include "mapped_object.h"
39
40 class block_instance;
41 class func_instance;
42 class parse_func;
43 class BPatch_edge;
44 class mapped_object;
45
46
47 class edge_instance : public Dyninst::PatchAPI::PatchEdge {
48   friend class block_instance;
49   friend class func_instance;
50   friend class mapped_object;
51
52   public:
53     block_instance *src() const;
54     block_instance *trg() const;
55     AddressSpace *proc();
56     edge_instance(ParseAPI::Edge *edge, block_instance *src, block_instance *trg);
57     edge_instance(const edge_instance *parent, mapped_object *child);
58     ~edge_instance();
59 };
60
61 // This is somewhat mangled, but allows Dyninst to access the
62 // iteration predicates of Dyninst without having to go back and
63 // template that code. Just wrap a ParseAPI predicate in a
64 // EdgePredicateAdapter and *poof* you're using edge_instances
65 // instead of ParseAPI edges...
66
67 class EdgePredicateAdapter 
68    : public ParseAPI::iterator_predicate <
69   edge_instance *,
70   edge_instance * > {
71   public:
72   EdgePredicateAdapter() : int_(NULL) {};
73   EdgePredicateAdapter(ParseAPI::EdgePredicate *intPred) : int_(intPred) {};
74    virtual ~EdgePredicateAdapter() {};
75    virtual bool pred_impl(edge_instance * const e) const { return int_->pred_impl(e->edge()); };
76
77   private:
78    ParseAPI::EdgePredicate *int_;
79 };
80
81 class block_instance : public Dyninst::PatchAPI::PatchBlock {
82   friend class mapped_object;
83
84   public:
85   //typedef std::vector<edge_instance *> edges;
86   //typedef std::vector<edge_instance *> edgelist;
87
88     block_instance(ParseAPI::Block *ib, mapped_object *obj);
89     block_instance(const block_instance *parent, mapped_object *child);
90     ~block_instance();
91
92     // Up-accessors
93     mapped_object *obj() const { return SCAST_MO(obj_); }
94     AddressSpace *addrSpace() const;
95     AddressSpace *proc() const { return addrSpace(); }
96
97     template<class OutputIterator> 
98        void getFuncs(OutputIterator result);
99
100     void triggerModified();
101     void setNotAbruptEnd();
102     parse_block * llb() const { return SCAST_PB(block_); }
103     void *getPtrToInstruction(Address addr) const;
104
105     //const edgelist &sources();
106     //const edgelist &targets();
107
108     // Shortcuts
109     edge_instance *getTarget();
110     edge_instance *getFallthrough();
111     // NULL if not conclusive
112     block_instance *getFallthroughBlock();
113
114     func_instance *callee();
115     std::string calleeName();
116
117     int id() const;
118
119     // Functions to avoid
120     // These are convinence wrappers for really expensive
121     // lookups, and thus should be avoided. 
122     func_instance *entryOfFunc() const;
123     bool isFuncExit() const;
124     // static void destroy(block_instance *b); // doesn't need to do anything
125
126     virtual void markModified();
127
128  private:
129     void updateCallTarget(func_instance *func);
130     func_instance *findFunction(ParseAPI::Function *);
131
132     // edges srcs_;
133     // edges trgs_;
134
135 };
136
137 template <class OutputIterator>
138 void block_instance::getFuncs(OutputIterator result) {
139    std::vector<ParseAPI::Function *> pFuncs;
140    llb()->getFuncs(pFuncs);
141    for (unsigned i = 0; i < pFuncs.size(); ++i) {
142       func_instance *func = findFunction(pFuncs[i]);
143       *result = func;
144       ++result;
145    }
146 }
147
148 struct BlockInstanceAddrCompare {
149    bool operator()(block_instance * const &b1,
150                    block_instance * const &b2) const {
151       return (b1->start() < b2->start());
152    }
153 };
154
155 typedef std::set<block_instance *, BlockInstanceAddrCompare> AddrOrderedBlockSet;
156
157
158
159 #endif