Pool-allocation for MachineInstrs, MachineBasicBlocks, and

MachineMemOperands. The pools are owned by MachineFunctions.

This drastically reduces the number of calls to malloc/free made
during the "Emit" phase of scheduling, as well as later phases
in CodeGen. Combined with other changes, this speeds up the
"instruction selection" phase of CodeGen by 10% in some cases.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@53212 91177308-0d34-0410-b5e6-96231b3b80d8

lib/CodeGen/MachineBasicBlock.cpp

@@ -18,12 +18,12 @@
 #include "llvm/Target/TargetData.h"
 #include "llvm/Target/TargetInstrDesc.h"
 #include "llvm/Target/TargetMachine.h"
-#include "llvm/Support/LeakDetector.h"
 #include <algorithm>
 using namespace llvm;
 
-MachineBasicBlock::~MachineBasicBlock() {
-  LeakDetector::removeGarbageObject(this);
+MachineBasicBlock::MachineBasicBlock(MachineFunction &mf, const BasicBlock *bb)
+  : BB(bb), Number(-1), xParent(&mf), Alignment(0), IsLandingPad(false) {
+  Insts.getTraits().Parent = this;
 }
 
 std::ostream& llvm::operator<<(std::ostream &OS, const MachineBasicBlock &MBB) {
@@ -38,98 +38,83 @@ std::ostream& llvm::operator<<(std::ostream &OS, const MachineBasicBlock &MBB) {
 /// MBBs start out as #-1. When a MBB is added to a MachineFunction, it
 /// gets the next available unique MBB number. If it is removed from a
 /// MachineFunction, it goes back to being #-1.
-void ilist_traits<MachineBasicBlock>::addNodeToList(MachineBasicBlock* N) {
-  assert(N->getParent() == 0 && "machine instruction already in a basic block");
-  N->setParent(Parent);
-  N->Number = Parent->addToMBBNumbering(N);
+void alist_traits<MachineBasicBlock>::addNodeToList(MachineBasicBlock* N) {
+  MachineFunction &MF = *N->getParent();
+  N->Number = MF.addToMBBNumbering(N);
 
   // Make sure the instructions have their operands in the reginfo lists.
-  MachineRegisterInfo &RegInfo = Parent->getRegInfo();
+  MachineRegisterInfo &RegInfo = MF.getRegInfo();
   for (MachineBasicBlock::iterator I = N->begin(), E = N->end(); I != E; ++I)
     I->AddRegOperandsToUseLists(RegInfo);
-    
-  LeakDetector::removeGarbageObject(N);
 }
 
-void ilist_traits<MachineBasicBlock>::removeNodeFromList(MachineBasicBlock* N) {
-  assert(N->getParent() != 0 && "machine instruction not in a basic block");
+void alist_traits<MachineBasicBlock>::removeNodeFromList(MachineBasicBlock* N) {
   N->getParent()->removeFromMBBNumbering(N->Number);
   N->Number = -1;
-  N->setParent(0);
-  
-  // Make sure the instructions have their operands removed from the reginfo
-  // lists.
-  for (MachineBasicBlock::iterator I = N->begin(), E = N->end(); I != E; ++I)
-    I->RemoveRegOperandsFromUseLists();
-  
-  LeakDetector::addGarbageObject(N);
 }
 
 
-MachineInstr* ilist_traits<MachineInstr>::createSentinel() {
-  MachineInstr* dummy = new MachineInstr();
-  LeakDetector::removeGarbageObject(dummy);
-  return dummy;
-}
-
 /// addNodeToList (MI) - When we add an instruction to a basic block
 /// list, we update its parent pointer and add its operands from reg use/def
 /// lists if appropriate.
-void ilist_traits<MachineInstr>::addNodeToList(MachineInstr* N) {
+void alist_traits<MachineInstr>::addNodeToList(MachineInstr* N) {
   assert(N->getParent() == 0 && "machine instruction already in a basic block");
-  N->setParent(parent);
-  LeakDetector::removeGarbageObject(N);
+  N->setParent(Parent);
   
-  // If the block is in a function, add the instruction's register operands to
-  // their corresponding use/def lists.
-  if (MachineFunction *MF = parent->getParent())
-    N->AddRegOperandsToUseLists(MF->getRegInfo());
+  // Add the instruction's register operands to their corresponding
+  // use/def lists.
+  MachineFunction *MF = Parent->getParent();
+  N->AddRegOperandsToUseLists(MF->getRegInfo());
 }
 
 /// removeNodeFromList (MI) - When we remove an instruction from a basic block
 /// list, we update its parent pointer and remove its operands from reg use/def
 /// lists if appropriate.
-void ilist_traits<MachineInstr>::removeNodeFromList(MachineInstr* N) {
+void alist_traits<MachineInstr>::removeNodeFromList(MachineInstr* N) {
   assert(N->getParent() != 0 && "machine instruction not in a basic block");
-  // If this block is in a function, remove from the use/def lists.
-  if (parent->getParent() != 0)
-    N->RemoveRegOperandsFromUseLists();
+
+  // Remove from the use/def lists.
+  N->RemoveRegOperandsFromUseLists();
   
   N->setParent(0);
-  LeakDetector::addGarbageObject(N);
 }
 
 /// transferNodesFromList (MI) - When moving a range of instructions from one
 /// MBB list to another, we need to update the parent pointers and the use/def
 /// lists.
-void ilist_traits<MachineInstr>::transferNodesFromList(
-      iplist<MachineInstr, ilist_traits<MachineInstr> >& fromList,
-      ilist_iterator<MachineInstr> first,
-      ilist_iterator<MachineInstr> last) {
+void alist_traits<MachineInstr>::transferNodesFromList(
+      alist_traits<MachineInstr>& fromList,
+      MachineBasicBlock::iterator first,
+      MachineBasicBlock::iterator last) {
   // Splice within the same MBB -> no change.
-  if (parent == fromList.parent) return;
+  if (Parent == fromList.Parent) return;
 
   // If splicing between two blocks within the same function, just update the
   // parent pointers.
-  if (parent->getParent() == fromList.parent->getParent()) {
+  if (Parent->getParent() == fromList.Parent->getParent()) {
     for (; first != last; ++first)
-      first->setParent(parent);
+      first->setParent(Parent);
     return;
   }
   
   // Otherwise, we have to update the parent and the use/def lists.  The common
   // case when this occurs is if we're splicing from a block in a MF to a block
   // that is not in an MF.
-  bool HasOldMF = fromList.parent->getParent() != 0;
-  MachineFunction *NewMF = parent->getParent();
+  bool HasOldMF = fromList.Parent->getParent() != 0;
+  MachineFunction *NewMF = Parent->getParent();
   
   for (; first != last; ++first) {
     if (HasOldMF) first->RemoveRegOperandsFromUseLists();
-    first->setParent(parent);
+    first->setParent(Parent);
     if (NewMF) first->AddRegOperandsToUseLists(NewMF->getRegInfo());
   }
 }
 
+void alist_traits<MachineInstr>::deleteNode(MachineInstr* MI) {
+  assert(!MI->getParent() && "MI is still in a block!");
+  Parent->getParent()->DeleteMachineInstr(MI);
+}
+
 MachineBasicBlock::iterator MachineBasicBlock::getFirstTerminator() {
   iterator I = end();
   while (I != begin() && (--I)->getDesc().isTerminator())
@@ -211,14 +196,12 @@ bool MachineBasicBlock::isLiveIn(unsigned Reg) const {
 }
 
 void MachineBasicBlock::moveBefore(MachineBasicBlock *NewAfter) {
-  MachineFunction::BasicBlockListType &BBList =getParent()->getBasicBlockList();
-  getParent()->getBasicBlockList().splice(NewAfter, BBList, this);
+  getParent()->splice(NewAfter, this);
 }
 
 void MachineBasicBlock::moveAfter(MachineBasicBlock *NewBefore) {
-  MachineFunction::BasicBlockListType &BBList =getParent()->getBasicBlockList();
   MachineFunction::iterator BBI = NewBefore;
-  getParent()->getBasicBlockList().splice(++BBI, BBList, this);
+  getParent()->splice(++BBI, this);
 }
 
 
@@ -271,6 +254,23 @@ bool MachineBasicBlock::isSuccessor(MachineBasicBlock *MBB) const {
   return I != Successors.end();
 }
 
+/// removeFromParent - This method unlinks 'this' from the containing function,
+/// and returns it, but does not delete it.
+MachineBasicBlock *MachineBasicBlock::removeFromParent() {
+  assert(getParent() && "Not embedded in a function!");
+  getParent()->remove(this);
+  return this;
+}
+
+
+/// eraseFromParent - This method unlinks 'this' from the containing function,
+/// and deletes it.
+void MachineBasicBlock::eraseFromParent() {
+  assert(getParent() && "Not embedded in a function!");
+  getParent()->erase(this);
+}
+
+
 /// ReplaceUsesOfBlockWith - Given a machine basic block that branched to
 /// 'Old', change the code and CFG so that it branches to 'New' instead.
 void MachineBasicBlock::ReplaceUsesOfBlockWith(MachineBasicBlock *Old,
@@ -309,7 +309,7 @@ bool MachineBasicBlock::CorrectExtraCFGEdges(MachineBasicBlock *DestA,
   bool MadeChange = false;
   bool AddedFallThrough = false;
 
-  MachineBasicBlock *FallThru = getNext();
+  MachineFunction::iterator FallThru = next(MachineFunction::iterator(this));
   
   // If this block ends with a conditional branch that falls through to its
   // successor, set DestB as the successor.