1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
//===-- llvm/CodeGen/MachineBasicBlock.h ------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Collect the sequence of machine instructions for a basic block.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_MACHINEBASICBLOCK_H
#define LLVM_CODEGEN_MACHINEBASICBLOCK_H
#include "llvm/CodeGen/MachineInstr.h"
#include "Support/ilist"
#include <iosfwd>
namespace llvm {
class MachineFunction;
// ilist_traits
template <>
class ilist_traits<MachineInstr> {
// this is only set by the MachineBasicBlock owning the ilist
friend class MachineBasicBlock;
MachineBasicBlock* parent;
public:
ilist_traits<MachineInstr>() : parent(0) { }
static MachineInstr* getPrev(MachineInstr* N) { return N->prev; }
static MachineInstr* getNext(MachineInstr* N) { return N->next; }
static const MachineInstr*
getPrev(const MachineInstr* N) { return N->prev; }
static const MachineInstr*
getNext(const MachineInstr* N) { return N->next; }
static void setPrev(MachineInstr* N, MachineInstr* prev) { N->prev = prev; }
static void setNext(MachineInstr* N, MachineInstr* next) { N->next = next; }
static MachineInstr* createNode();
void addNodeToList(MachineInstr* N);
void removeNodeFromList(MachineInstr* N);
void transferNodesFromList(
iplist<MachineInstr, ilist_traits<MachineInstr> >& toList,
ilist_iterator<MachineInstr> first,
ilist_iterator<MachineInstr> last);
};
class BasicBlock;
class MachineBasicBlock {
public:
typedef ilist<MachineInstr> Instructions;
Instructions Insts;
MachineBasicBlock *Prev, *Next;
const BasicBlock *BB;
std::vector<MachineBasicBlock *> Predecessors;
std::vector<MachineBasicBlock *> Successors;
public:
MachineBasicBlock(const BasicBlock *bb = 0) : Prev(0), Next(0), BB(bb) {
Insts.parent = this;
}
~MachineBasicBlock() {}
/// getBasicBlock - Return the LLVM basic block that this instance
/// corresponded to originally.
///
const BasicBlock *getBasicBlock() const { return BB; }
/// getParent - Return the MachineFunction containing this basic block.
///
const MachineFunction *getParent() const;
typedef ilist<MachineInstr>::iterator iterator;
typedef ilist<MachineInstr>::const_iterator const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
unsigned size() const { return Insts.size(); }
bool empty() const { return Insts.empty(); }
MachineInstr& front() { return Insts.front(); }
MachineInstr& back() { return Insts.back(); }
iterator begin() { return Insts.begin(); }
const_iterator begin() const { return Insts.begin(); }
iterator end() { return Insts.end(); }
const_iterator end() const { return Insts.end(); }
reverse_iterator rbegin() { return Insts.rbegin(); }
const_reverse_iterator rbegin() const { return Insts.rbegin(); }
reverse_iterator rend () { return Insts.rend(); }
const_reverse_iterator rend () const { return Insts.rend(); }
// Machine-CFG iterators
typedef std::vector<MachineBasicBlock *>::iterator pred_iterator;
typedef std::vector<MachineBasicBlock *>::const_iterator const_pred_iterator;
typedef std::vector<MachineBasicBlock *>::iterator succ_iterator;
typedef std::vector<MachineBasicBlock *>::const_iterator const_succ_iterator;
pred_iterator pred_begin() { return Predecessors.begin (); }
const_pred_iterator pred_begin() const { return Predecessors.begin (); }
pred_iterator pred_end() { return Predecessors.end (); }
const_pred_iterator pred_end() const { return Predecessors.end (); }
unsigned pred_size() const { return Predecessors.size (); }
succ_iterator succ_begin() { return Successors.begin (); }
const_succ_iterator succ_begin() const { return Successors.begin (); }
succ_iterator succ_end() { return Successors.end (); }
const_succ_iterator succ_end() const { return Successors.end (); }
unsigned succ_size() const { return Successors.size (); }
// Machine-CFG mutators
/// addSuccessor - Add succ as a successor of this MachineBasicBlock.
/// The Predecessors list of succ is automatically updated.
///
void addSuccessor (MachineBasicBlock *succ) {
assert (std::find (Successors.begin (), Successors.end (), succ)
== Successors.end ()
&& "Trying to addSuccessor a MBB which is already my successor");
Successors.push_back (succ);
succ->addPredecessor (this);
}
/// removeSuccessor - Remove succ from the successors list of this
/// MachineBasicBlock. The Predecessors list of succ is automatically updated.
///
void removeSuccessor (MachineBasicBlock *succ) {
succ->removePredecessor (this);
std::vector<MachineBasicBlock *>::iterator goner =
std::find (Successors.begin(), Successors.end (), succ);
assert (goner != Successors.end ()
&& "Trying to removeSuccessor a MBB which isn't my successor");
Successors.erase (goner);
}
/// getFirstTerminator - returns an iterator to the first terminator
/// instruction of this basic block. If a terminator does not exist,
/// it returns end()
iterator getFirstTerminator();
void push_back(MachineInstr *MI) { Insts.push_back(MI); }
template<typename IT>
void insert(iterator I, IT S, IT E) { Insts.insert(I, S, E); }
iterator insert(iterator I, MachineInstr *M) { return Insts.insert(I, M); }
// erase - Remove the specified element or range from the instruction list.
// These functions delete any instructions removed.
//
iterator erase(iterator I) { return Insts.erase(I); }
iterator erase(iterator I, iterator E) { return Insts.erase(I, E); }
MachineInstr *remove(MachineInstr *I) { return Insts.remove(I); }
void clear() { Insts.clear(); }
// Debugging methods.
void dump() const;
void print(std::ostream &OS) const;
private: // Methods used to maintain doubly linked list of blocks...
friend class ilist_traits<MachineBasicBlock>;
MachineBasicBlock *getPrev() const { return Prev; }
MachineBasicBlock *getNext() const { return Next; }
void setPrev(MachineBasicBlock *P) { Prev = P; }
void setNext(MachineBasicBlock *N) { Next = N; }
// Machine-CFG mutators
/// addPredecessor - Remove pred as a predecessor of this MachineBasicBlock.
/// Don't do this unless you know what you're doing, because it doesn't
/// update pred's successors list. Use pred->addSuccessor instead.
///
void addPredecessor (MachineBasicBlock *pred) {
assert(std::find (Predecessors.begin (), Predecessors.end (), pred)
== Predecessors.end ()
&& "Trying to addPredecessor a MBB which is already my predecessor");
Predecessors.push_back (pred);
}
/// removePredecessor - Remove pred as a predecessor of this
/// MachineBasicBlock. Don't do this unless you know what you're
/// doing, because it doesn't update pred's successors list. Use
/// pred->removeSuccessor instead.
///
void removePredecessor (MachineBasicBlock *pred) {
std::vector<MachineBasicBlock *>::iterator goner =
std::find (Predecessors.begin(), Predecessors.end (), pred);
assert (goner != Predecessors.end ()
&& "Trying to removePredecessor a MBB which isn't my predecessor");
Predecessors.erase (goner);
}
};
} // End llvm namespace
#endif
|
