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
|
//===-- 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"
namespace llvm {
// ilist_traits
template <>
class ilist_traits<MachineInstr>
{
typedef ilist_traits<MachineInstr> self;
// 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() { return new MachineInstr(0, 0); }
void addNodeToList(MachineInstr* N) {
assert(N->parent == 0 && "machine instruction already in a basic block");
N->parent = parent;
}
void removeNodeFromList(MachineInstr* N) {
assert(N->parent != 0 && "machine instruction not in a basic block");
N->parent = 0;
}
void transferNodesFromList(iplist<MachineInstr, self>& toList,
ilist_iterator<MachineInstr> first,
ilist_iterator<MachineInstr> last) {
if (parent != toList.parent)
for (; first != last; ++first)
first->parent = toList.parent;
}
};
class BasicBlock;
class MachineBasicBlock {
public:
typedef ilist<MachineInstr> Instructions;
Instructions Insts;
MachineBasicBlock *Prev, *Next;
const BasicBlock *BB;
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; }
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(); }
const MachineInstr& operator[](unsigned i) const {
const_iterator it = Insts.begin();
std::advance(it, i);
return *it;
}
MachineInstr& operator[](unsigned i) {
iterator it = Insts.begin();
std::advance(it, i);
return *it;
}
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(); }
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(iterator &I) { return Insts.remove(I); }
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; }
};
} // End llvm namespace
#endif
|
