Change MachineBasicBlock's to not be Annotations, instead they are kept as

part of a linked list tracked by MachineFunction.  MachineBasicBlock::get
is now linear time instead of constant time, and thus is deprecated!


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

include/llvm/CodeGen/MachineBasicBlock.h

@@ -7,31 +7,28 @@
 #ifndef LLVM_CODEGEN_MACHINEBASICBLOCK_H
 #define LLVM_CODEGEN_MACHINEBASICBLOCK_H
 
-#include "llvm/Annotation.h"
 #include <vector>
 class BasicBlock;
 class MachineInstr;
 template <typename T> struct ilist_traits;
 
-extern AnnotationID MCFBB_AID;
+class MachineBasicBlock {
-
-class MachineBasicBlock : public Annotation {
   std::vector<MachineInstr*> Insts;
   MachineBasicBlock *Prev, *Next;
+  BasicBlock *BB;
 public:
-  MachineBasicBlock() : Annotation(MCFBB_AID) {}
+  MachineBasicBlock(BasicBlock *bb = 0) : Prev(0), Next(0), BB(bb) {}
   ~MachineBasicBlock() {}
   
-  // Static methods to retrieve or destroy the MachineBasicBlock
+  // get - This deprecated static method returns the MachineBasicBlock object
-  // object for a given basic block.
+  // for the specified BasicBlock.
-  static MachineBasicBlock& get(const BasicBlock *BB) {
+  //
-    return *(MachineBasicBlock*)
+  static MachineBasicBlock& get(const BasicBlock *BB);
-      ((Annotable*)BB)->getOrCreateAnnotation(MCFBB_AID);
+
-  }
+  /// getBasicBlock - Return the LLVM basic block that this instance
-  
+  /// corresponded to originally.
-  static void destroy(const BasicBlock *BB) {
+  ///
-    ((Annotable*)BB)->deleteAnnotation(MCFBB_AID);
+  BasicBlock *getBasicBlock() const { return BB; }
-  }
   
   typedef std::vector<MachineInstr*>::iterator                iterator;
   typedef std::vector<MachineInstr*>::const_iterator    const_iterator;

include/llvm/CodeGen/MachineFunction.h

@@ -10,6 +10,7 @@
 #define LLVM_CODEGEN_MACHINEFUNCTION_H
 
 #include "llvm/CodeGen/MachineBasicBlock.h"
+#include "llvm/Annotation.h"
 #include "Support/NonCopyable.h"
 #include "Support/HashExtras.h"
 #include "Support/hash_set"
@@ -59,9 +60,38 @@ public:
   static MachineFunction& construct(const Function *method,
                                          const TargetMachine &target);
   static void destruct(const Function *F);
-  static MachineFunction& get(const Function* function);
+  static MachineFunction& get(const Function *F);
-  
 
+  // Provide accessors for the MachineBasicBlock list...
+  typedef iplist<MachineBasicBlock> BasicBlockListType;
+  typedef BasicBlockListType::iterator iterator;
+  typedef BasicBlockListType::const_iterator const_iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef std::reverse_iterator<iterator>             reverse_iterator;
+
+  // Provide accessors for basic blocks...
+  const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
+        BasicBlockListType &getBasicBlockList()       { return BasicBlocks; }
+ 
+  //===--------------------------------------------------------------------===//
+  // BasicBlock iterator forwarding functions
+  //
+  iterator                 begin()       { return BasicBlocks.begin(); }
+  const_iterator           begin() const { return BasicBlocks.begin(); }
+  iterator                 end  ()       { return BasicBlocks.end();   }
+  const_iterator           end  () const { return BasicBlocks.end();   }
+
+  reverse_iterator        rbegin()       { return BasicBlocks.rbegin(); }
+  const_reverse_iterator  rbegin() const { return BasicBlocks.rbegin(); }
+  reverse_iterator        rend  ()       { return BasicBlocks.rend();   }
+  const_reverse_iterator  rend  () const { return BasicBlocks.rend();   }
+
+  unsigned                  size() const { return BasicBlocks.size(); }
+  bool                     empty() const { return BasicBlocks.empty(); }
+  const MachineBasicBlock &front() const { return BasicBlocks.front(); }
+        MachineBasicBlock &front()       { return BasicBlocks.front(); }
+  const MachineBasicBlock &back() const { return BasicBlocks.back(); }
+        MachineBasicBlock &back()       { return BasicBlocks.back(); }
 
   //===--------------------------------------------------------------------===//
   //

lib/CodeGen/InstrSelection/InstrSelection.cpp

@@ -139,14 +139,20 @@ bool InstructionSelection::runOnFunction(Function &F)
     }
   
   //
-  // Record instructions in the vector for each basic block
+  // Create the MachineBasicBlock records and add all of the MachineInstrs
+  // defined in the MachineCodeForInstruction objects to also live in the
+  // MachineBasicBlock objects.
   // 
-  for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI)
+  MachineFunction &MF = MachineFunction::get(&F);
+  for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI) {
+    MachineBasicBlock *MCBB = new MachineBasicBlock(BI);
+    MF.getBasicBlockList().push_back(MCBB);
+
     for (BasicBlock::iterator II = BI->begin(); II != BI->end(); ++II) {
       MachineCodeForInstruction &mvec = MachineCodeForInstruction::get(II);
-      MachineBasicBlock &MCBB = MachineBasicBlock::get(BI);
+      MCBB->insert(MCBB->end(), mvec.begin(), mvec.end());
-      MCBB.insert(MCBB.end(), mvec.begin(), mvec.end());
     }
+  }
 
   // Insert phi elimination code
   InsertCodeForPhis(F);

lib/CodeGen/MachineBasicBlock.cpp

@@ -1,23 +0,0 @@
-//===-- MachineBasicBlock.cpp ---------------------------------------------===//
-// 
-// Collect the sequence of machine instructions for a basic block.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/CodeGen/MachineBasicBlock.h"
-
-AnnotationID MCFBB_AID(
-             AnnotationManager::getID("CodeGen::MachineBasicBlock"));
-
-static Annotation *CreateMCFBB(AnnotationID AID, const Annotable *, void *) {
-  assert(AID == MCFBB_AID);
-  return new MachineBasicBlock();  // Invoke constructor!
-}
-
-// Register the annotation with the annotation factory
-static struct MCFBBInitializer {
-  MCFBBInitializer() {
-    AnnotationManager::registerAnnotationFactory(MCFBB_AID, &CreateMCFBB);
-  }
-} RegisterCreateMCFBB;
-

lib/CodeGen/MachineFunction.cpp

@@ -72,6 +72,21 @@ Pass *createMachineCodeDestructionPass() {
 }
 
 
+// get - This deprecated static method returns the MachineBasicBlock object
+// for the specified BasicBlock.
+//
+MachineBasicBlock& MachineBasicBlock::get(const BasicBlock *BB) {
+  const Function *F = BB->getParent();
+  MachineFunction &MF = MachineFunction::get(F);
+
+  for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I)
+    if (I->getBasicBlock() == BB)
+      return *I;
+  assert(0 && "MachineBasicBlock object not found for specified block!");
+  return get(BB);
+}
+
+
 //===---------------------------------------------------------------------===//
 // MachineFunction implementation
 //===---------------------------------------------------------------------===//

lib/Target/SparcV9/InstrSelection/InstrSelection.cpp

@@ -139,14 +139,20 @@ bool InstructionSelection::runOnFunction(Function &F)
     }
   
   //
-  // Record instructions in the vector for each basic block
+  // Create the MachineBasicBlock records and add all of the MachineInstrs
+  // defined in the MachineCodeForInstruction objects to also live in the
+  // MachineBasicBlock objects.
   // 
-  for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI)
+  MachineFunction &MF = MachineFunction::get(&F);
+  for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI) {
+    MachineBasicBlock *MCBB = new MachineBasicBlock(BI);
+    MF.getBasicBlockList().push_back(MCBB);
+
     for (BasicBlock::iterator II = BI->begin(); II != BI->end(); ++II) {
       MachineCodeForInstruction &mvec = MachineCodeForInstruction::get(II);
-      MachineBasicBlock &MCBB = MachineBasicBlock::get(BI);
+      MCBB->insert(MCBB->end(), mvec.begin(), mvec.end());
-      MCBB.insert(MCBB.end(), mvec.begin(), mvec.end());
     }
+  }
 
   // Insert phi elimination code
   InsertCodeForPhis(F);