Rewrote uses of deprecated `MachineFunction::get(BasicBlock *BB)'.

[oota-llvm.git] / lib / Target / SparcV9 / RegAlloc / LiveRangeInfo.cpp

diff --git a/lib/Target/SparcV9/RegAlloc/LiveRangeInfo.cpp b/lib/Target/SparcV9/RegAlloc/LiveRangeInfo.cpp
index 07e6a467d1825e4b3700bcf4d7af59f198cb3ce8..4e47bfb9e7ad01c33df5d6f2f1648f6baf9b0544 100644 (file)
--- a/lib/Target/SparcV9/RegAlloc/LiveRangeInfo.cpp
+++ b/lib/Target/SparcV9/RegAlloc/LiveRangeInfo.cpp
@@ -8,10 +8,10 @@
 #include "llvm/CodeGen/RegAllocCommon.h"
 #include "llvm/CodeGen/RegClass.h"
 #include "llvm/CodeGen/MachineInstr.h"
-#include "llvm/CodeGen/MachineBasicBlock.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/MachineInstrInfo.h"
 #include "llvm/Function.h"
-#include "llvm/BasicBlock.h"
 #include "Support/SetOperations.h"
 using std::cerr;
 
@@ -110,7 +110,7 @@ LiveRangeInfo::createOrAddToLiveRange(const Value* Def, bool isCC /* = false*/)
 
   // check if the LR is already there (because of multiple defs)
   if (!DefRange) { 
-    DefRange = this->createNewLiveRange(Def, isCC);
+    DefRange = createNewLiveRange(Def, isCC);
   } else {                          // live range already exists
     DefRange->insert(Def);          // add the operand to the range
     LiveRangeMap[Def] = DefRange;   // make operand point to merged set
@@ -134,7 +134,7 @@ void LiveRangeInfo::constructLiveRanges() {
   // first find the live ranges for all incoming args of the function since
   // those LRs start from the start of the function
   for (Function::const_aiterator AI = Meth->abegin(); AI != Meth->aend(); ++AI)
-    this->createNewLiveRange(AI, /*isCC*/ false);
+    createNewLiveRange(AI, /*isCC*/ false);
 
   // Now suggest hardware registers for these function args 
   MRI.suggestRegs4MethodArgs(Meth, *this);
@@ -146,13 +146,13 @@ void LiveRangeInfo::constructLiveRanges() {
   // 
   // Also, find CALL and RETURN instructions, which need extra work.
   //
-  for (Function::const_iterator BBI=Meth->begin(); BBI != Meth->end(); ++BBI){
-    // get the vector of machine instructions for this basic block.
-    MachineBasicBlock& MIVec = MachineBasicBlock::get(BBI);
+  MachineFunction &MF = MachineFunction::get(Meth);
+  for (MachineFunction::iterator BBI = MF.begin(); BBI != MF.end(); ++BBI) {
+    MachineBasicBlock &MBB = *BBI;
 
     // iterate over all the machine instructions in BB
-    for(MachineBasicBlock::iterator MInstIterator = MIVec.begin();
-        MInstIterator != MIVec.end(); ++MInstIterator) {  
+    for(MachineBasicBlock::iterator MInstIterator = MBB.begin();
+        MInstIterator != MBB.end(); ++MInstIterator) {  
       MachineInstr *MInst = *MInstIterator; 
 
       // If the machine instruction is a  call/return instruction, add it to
@@ -160,7 +160,7 @@ void LiveRangeInfo::constructLiveRanges() {
       // 
       if(TM.getInstrInfo().isReturn(MInst->getOpCode()) ||
         TM.getInstrInfo().isCall(MInst->getOpCode()))
-       CallRetInstrList.push_back( MInst ); 
+       CallRetInstrList.push_back(MInst); 
  
       // iterate over explicit MI operands and create a new LR
       // for each operand that is defined by the instruction
@@ -168,9 +168,9 @@ void LiveRangeInfo::constructLiveRanges() {
              OpE = MInst->end(); OpI != OpE; ++OpI)
        if (OpI.isDef()) {     
          const Value *Def = *OpI;
-          bool isCC = (OpI.getMachineOperand().getOperandType()
+          bool isCC = (OpI.getMachineOperand().getType()
                        == MachineOperand::MO_CCRegister);
-          this->createOrAddToLiveRange(Def, isCC);
+          createOrAddToLiveRange(Def, isCC);
        }
 
       // iterate over implicit MI operands and create a new LR
@@ -178,7 +178,7 @@ void LiveRangeInfo::constructLiveRanges() {
       for (unsigned i = 0; i < MInst->getNumImplicitRefs(); ++i) 
        if (MInst->implicitRefIsDefined(i)) {     
          const Value *Def = MInst->getImplicitRef(i);
-          this->createOrAddToLiveRange(Def, /*isCC*/ false);
+          createOrAddToLiveRange(Def, /*isCC*/ false);
        }
 
     } // for all machine instructions in the BB
@@ -248,35 +248,30 @@ void LiveRangeInfo::coalesceLRs()
   if(DEBUG_RA >= RA_DEBUG_LiveRanges) 
     cerr << "\nCoalescing LRs ...\n";
 
-  for(Function::const_iterator BBI = Meth->begin(), BBE = Meth->end();
-      BBI != BBE; ++BBI) {
-
-    // get the iterator for machine instructions
-    const MachineBasicBlock& MIVec = MachineBasicBlock::get(BBI);
-    MachineBasicBlock::const_iterator MInstIterator = MIVec.begin();
+  MachineFunction &MF = MachineFunction::get(Meth);
+  for (MachineFunction::iterator BBI = MF.begin(); BBI != MF.end(); ++BBI) {
+    MachineBasicBlock &MBB = *BBI;
 
     // iterate over all the machine instructions in BB
-    for( ; MInstIterator != MIVec.end(); ++MInstIterator) {  
-      const MachineInstr * MInst = *MInstIterator; 
+    for(MachineBasicBlock::iterator MII = MBB.begin(); MII != MBB.end(); ++MII){
+      const MachineInstr *MI = *MII;
 
       if( DEBUG_RA >= RA_DEBUG_LiveRanges) {
        cerr << " *Iterating over machine instr ";
-       MInst->dump();
+       MI->dump();
        cerr << "\n";
       }
 
-
       // iterate over  MI operands to find defs
-      for(MachineInstr::const_val_op_iterator DefI = MInst->begin(),
-            DefE = MInst->end(); DefI != DefE; ++DefI) {
+      for(MachineInstr::const_val_op_iterator DefI = MI->begin(),
+            DefE = MI->end(); DefI != DefE; ++DefI) {
        if (DefI.isDef()) {            // iff this operand is a def
          LiveRange *LROfDef = getLiveRangeForValue( *DefI );
          RegClass *RCOfDef = LROfDef->getRegClass();
 
-         MachineInstr::const_val_op_iterator UseI = MInst->begin(),
-            UseE = MInst->end();
-         for( ; UseI != UseE; ++UseI){ // for all uses
-
+         MachineInstr::const_val_op_iterator UseI = MI->begin(),
+            UseE = MI->end();
+         for( ; UseI != UseE; ++UseI) { // for all uses
            LiveRange *LROfUse = getLiveRangeForValue( *UseI );
            if (!LROfUse) {             // if LR of use is not found
              //don't warn about labels