Add DebugLoc-aware constructors for SDNode derived

[oota-llvm.git] / include / llvm / CodeGen / MachineBasicBlock.h

diff --git a/include/llvm/CodeGen/MachineBasicBlock.h b/include/llvm/CodeGen/MachineBasicBlock.h
index f0f9d54af54e829b7e07dd1a5fe3b5793f96dff0..54ac47008f231acd9a07ea296a6a1ddc11a24b27 100644 (file)
--- a/include/llvm/CodeGen/MachineBasicBlock.h
+++ b/include/llvm/CodeGen/MachineBasicBlock.h
@@ -19,30 +19,35 @@
 #include "llvm/Support/Streams.h"
 
 namespace llvm {
-  class MachineFunction;
+
+class BasicBlock;
+class MachineFunction;
 
 template <>
-struct alist_traits<MachineInstr, MachineInstr> {
-protected:
+struct ilist_traits<MachineInstr> : public ilist_default_traits<MachineInstr> {
+private:
+  mutable MachineInstr Sentinel;
+
   // this is only set by the MachineBasicBlock owning the LiveList
   friend class MachineBasicBlock;
   MachineBasicBlock* Parent;
 
-  typedef alist_iterator<MachineInstr> iterator;
-
 public:
-  alist_traits<MachineInstr, MachineInstr>() : Parent(0) { }
+  MachineInstr *createSentinel() const { return &Sentinel; }
+  void destroySentinel(MachineInstr *) const {}
 
   void addNodeToList(MachineInstr* N);
   void removeNodeFromList(MachineInstr* N);
-  void transferNodesFromList(alist_traits &, iterator, iterator);
+  void transferNodesFromList(ilist_traits &SrcTraits,
+                             ilist_iterator<MachineInstr> first,
+                             ilist_iterator<MachineInstr> last);
   void deleteNode(MachineInstr *N);
+private:
+  void createNode(const MachineInstr &);
 };
 
-class BasicBlock;
-
-class MachineBasicBlock {
-  typedef alist<MachineInstr> Instructions;
+class MachineBasicBlock : public ilist_node<MachineBasicBlock> {
+  typedef ilist<MachineInstr> Instructions;
   Instructions Insts;
   const BasicBlock *BB;
   int Number;
@@ -65,6 +70,10 @@ class MachineBasicBlock {
   /// exception handler.
   bool IsLandingPad;
 
+  // Intrusive list support
+  friend struct ilist_sentinel_traits<MachineBasicBlock>;
+  MachineBasicBlock() {}
+
   explicit MachineBasicBlock(MachineFunction &mf, const BasicBlock *bb);
 
   ~MachineBasicBlock();
@@ -93,6 +102,8 @@ public:
 
   MachineInstr& front() { return Insts.front(); }
   MachineInstr& back()  { return Insts.back(); }
+  const MachineInstr& front() const { return Insts.front(); }
+  const MachineInstr& back()  const { return Insts.back(); }
 
   iterator                begin()       { return Insts.begin();  }
   const_iterator          begin() const { return Insts.begin();  }
@@ -225,6 +236,13 @@ public:
   /// block.
   bool isSuccessor(MachineBasicBlock *MBB) const;
 
+  /// isLayoutSuccessor - Return true if the specified MBB will be emitted
+  /// immediately after this block, such that if this block exits by
+  /// falling through, control will transfer to the specified MBB. Note
+  /// that MBB need not be a successor at all, for example if this block
+  /// ends with an unconditional branch to some other block.
+  bool isLayoutSuccessor(MachineBasicBlock *MBB) const;
+
   /// getFirstTerminator - returns an iterator to the first terminator
   /// instruction of this basic block. If a terminator does not exist,
   /// it returns end()
@@ -245,6 +263,12 @@ public:
   MachineInstr *remove(MachineInstr *I)  { return Insts.remove(I); }
   void clear()                           { Insts.clear(); }
 
+  /// splice - Take an instruction from MBB 'Other' at the position From,
+  /// and insert it into this MBB right before 'where'.
+  void splice(iterator where, MachineBasicBlock *Other, iterator From) {
+    Insts.splice(where, Other->Insts, From);
+  }
+
   /// splice - Take a block of instructions from MBB 'Other' in the range [From,
   /// To), and insert them into this MBB right before 'where'.
   void splice(iterator where, MachineBasicBlock *Other, iterator From,
@@ -287,7 +311,7 @@ public:
   void setNumber(int N) { Number = N; }
 
 private:   // Methods used to maintain doubly linked list of blocks...
-  friend struct alist_traits<MachineBasicBlock>;
+  friend struct ilist_traits<MachineBasicBlock>;
 
   // Machine-CFG mutators