Update copyright to LGPL on all files
[dyninst.git] / dyninstAPI / h / BPatch_basicBlockLoop.h
1 /*
2  * Copyright (c) 1996-2009 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  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 #ifndef _BPatch_basicBlockLoop_h
33 #define _BPatch_basicBlockLoop_h
34
35 #include <stdlib.h>
36 #include <string>
37 #include "Annotatable.h"
38 #include "BPatch_dll.h"
39 #include "BPatch_Vector.h"
40 #include "BPatch_Set.h"
41 #include "BPatch_basicBlock.h"
42 #include "BPatch_eventLock.h"
43 #include "BPatch_flowGraph.h" 
44
45 /** class to represent the loops composed of machine code basic 
46   * blocks in the executable (Natural loops)
47   *
48   * @see BPatch_basicBlock
49   * @see BPatch_flowGraph
50   */
51
52 class BPatch_variableExpr;
53 class BPatch_loopTreeNode;
54
55 #ifdef DYNINST_CLASS_NAME
56 #undef DYNINST_CLASS_NAME
57 #endif
58 #define DYNINST_CLASS_NAME BPatch_basicBlockLoop
59
60 class BPATCH_DLL_EXPORT BPatch_basicBlockLoop : 
61    public BPatch_eventLock, 
62    public Dyninst::AnnotatableSparse 
63 {
64         friend class BPatch_flowGraph;
65         friend std::ostream& operator<<(std::ostream&,BPatch_basicBlockLoop&);
66         friend void dfsCreateLoopHierarchy(BPatch_loopTreeNode * parent,
67                                            BPatch_Vector<BPatch_basicBlockLoop *> &loops,
68                                            std::string level);
69
70 private:
71         BPatch_edge *backEdge;
72
73         // the flow graph this loop is part of
74         BPatch_flowGraph *flowGraph;
75
76         /** set of loops that are contained (nested) in this loop. */
77         BPatch_Set<BPatch_basicBlockLoop*> containedLoops;
78
79         /** the basic blocks in the loop */
80         BPatch_Set<BPatch_basicBlock*> basicBlocks;
81
82
83 public:
84         /** If loop which directly encloses this loop. NULL if no such loop */
85         BPatch_basicBlockLoop* parent;
86
87         /** BPatch_basicBlockLoop::containsAddress    */
88         /** Return true if the given address is within the range of
89             this loop's basicBlocks */
90         API_EXPORT(Int, (addr),
91
92         bool,containsAddress,(unsigned long addr));
93           
94         /** Return true if the given address is within the range of
95             this loop's basicBlocks or its children */
96         API_EXPORT(Int, (addr),
97                    
98         bool,containsAddressInclusive,(unsigned long addr));
99
100
101         /** BPatch_basicBlockLoop::getBackEdge    */
102         /** return the back edge which defines this loop */
103         API_EXPORT(Int, (),
104
105         BPatch_edge *,getBackEdge,());
106
107         /** BPatch_basicBlockLoop::getContainedLoops    */
108         /** returns vector of contained loops */
109         API_EXPORT(Int, (loops),
110
111         bool,getContainedLoops,(BPatch_Vector<BPatch_basicBlockLoop*> &loops));
112
113         /** BPatch_basicBlockLoop::getOuterLoops    */
114         /** returns vector of outer contained loops */
115         API_EXPORT(Int, (loops),
116
117         bool,getOuterLoops,(BPatch_Vector<BPatch_basicBlockLoop*> &loops) );
118
119         /** BPatch_basicBlockLoop::getLoopBasicBlocks    */
120         /** returns all basic blocks in the loop */
121         API_EXPORT(Int, (blocks),
122
123         bool,getLoopBasicBlocks,(BPatch_Vector<BPatch_basicBlock*> &blocks));
124
125         /** BPatch_basicBlockLoop::getLoopBasicBlocksExclusive    */
126         /** returns all basic blocks in this loop, exluding the blocks
127             of its sub loops. */
128         API_EXPORT(Int, (blocks),
129
130         bool,getLoopBasicBlocksExclusive,(BPatch_Vector<BPatch_basicBlock*> &blocks));
131
132         /** does this loop or its subloops contain the given block? */
133         API_EXPORT(Int, (b),
134
135         bool,hasBlock,(BPatch_basicBlock *b));
136
137         /** does this loop contain the given block? */
138         API_EXPORT(Int, (b),
139
140         bool,hasBlockExclusive,(BPatch_basicBlock *b));
141
142         /** BPatch_basicBlockLoop::hasAncestor    */
143         /** returns true if this loop is a descendant of the given loop */
144         API_EXPORT(Int, (loop),
145
146         bool,hasAncestor,(BPatch_basicBlockLoop *loop));
147
148         /** returns the flow graph this loop is in */
149         API_EXPORT(Int, (),
150
151         BPatch_flowGraph *,getFlowGraph,());
152
153         /** BPatch_basicBlockLoop::getLoopHead    */
154         /** returns the head basic block of the loop */
155         API_EXPORT(Int, (),
156
157         BPatch_basicBlock *,getLoopHead,());
158
159         /** BPatch_basicBlockLoop::getLoopIterators    */
160         /** method that returns the variables used as iterator */
161         /** not implemented yet */
162         API_EXPORT(Int, (),
163
164         BPatch_Set<BPatch_variableExpr*> *,getLoopIterators,());
165
166         /** BPatch_basicBlockLoop::~BPatch_basicBlockLoop    */
167         /** destructor for the class */
168
169         public:  ~BPatch_basicBlockLoop() { }
170
171 private:
172 // internal use only
173         /** constructor of class */
174         BPatch_basicBlockLoop(BPatch_flowGraph *);
175
176         /** constructor of the class */
177         BPatch_basicBlockLoop(BPatch_edge *, BPatch_flowGraph *);
178
179         /** get either contained or outer loops, determined by outerMostOnly */
180         bool getLoops(BPatch_Vector<BPatch_basicBlockLoop*>&, 
181                       bool outerMostOnly) const;
182 };
183
184 #endif /*_BPatch_basicBlockLoop_h_*/