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