diff --git a/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp b/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp
index 42698ad..32d48f6 100644
--- a/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp
+++ b/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp
@@ -11,6 +11,7 @@
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineInstrAnnot.h"
 #include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineFunctionInfo.h"
 #include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Target/TargetMachine.h"
@@ -508,7 +509,7 @@
 	continue;
 
       // Reset tmp stack positions so they can be reused for each machine instr.
-      MF.popAllTempValues(TM);  
+      MF.getInfo()->popAllTempValues();  
 	
       // Now insert speical instructions (if necessary) for call/return
       // instructions. 
@@ -658,7 +659,7 @@
   RegClass *RC = LR->getRegClass();
   const ValueSet &LVSetBef = LVI->getLiveVarSetBeforeMInst(MInst, BB);
 
-  MF.pushTempValue(TM, MRI.getSpilledRegSize(RegType) );
+  MF.getInfo()->pushTempValue(MRI.getSpilledRegSize(RegType) );
   
   vector<MachineInstr*> MIBef, MIAft;
   vector<MachineInstr*> AdIMid;
@@ -749,7 +750,7 @@
     // we couldn't find an unused register. Generate code to free up a reg by
     // saving it on stack and restoring after the instruction
     
-    int TmpOff = MF.pushTempValue(TM,  MRI.getSpilledRegSize(RegType) );
+    int TmpOff = MF.getInfo()->pushTempValue(MRI.getSpilledRegSize(RegType));
     
     RegU = getUniRegNotUsedByThisInst(RC, MInst);
     
@@ -1093,7 +1094,7 @@
     if (HMI->first && HMI->second) {
       LiveRange *L = HMI->second;      // get the LiveRange
       if (!L->hasColor()) {   //  NOTE: ** allocating the size of long Type **
-        int stackOffset = MF.allocateSpilledValue(TM, Type::LongTy);
+        int stackOffset = MF.getInfo()->allocateSpilledValue(Type::LongTy);
         L->setSpillOffFromFP(stackOffset);
         if (DEBUG_RA)
           cerr << "  LR# " << L->getUserIGNode()->getIndex()
@@ -1159,12 +1160,12 @@
   for (unsigned rc=0; rc < NumOfRegClasses ; rc++)  
     RegClassList[rc]->colorAllRegs();    
 
-  // Atter grpah coloring, if some LRs did not receive a color (i.e, spilled)
+  // Atter graph coloring, if some LRs did not receive a color (i.e, spilled)
   // a poistion for such spilled LRs
   //
   allocateStackSpace4SpilledLRs();
 
-  MF.popAllTempValues(TM);  // TODO **Check
+  MF.getInfo()->popAllTempValues();  // TODO **Check
 
   // color incoming args - if the correct color was not received
   // insert code to copy to the correct register
diff --git a/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp b/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp
index 42698ad..32d48f6 100644
--- a/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp
+++ b/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp
@@ -11,6 +11,7 @@
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineInstrAnnot.h"
 #include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineFunctionInfo.h"
 #include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Target/TargetMachine.h"
@@ -508,7 +509,7 @@
 	continue;
 
       // Reset tmp stack positions so they can be reused for each machine instr.
-      MF.popAllTempValues(TM);  
+      MF.getInfo()->popAllTempValues();  
 	
       // Now insert speical instructions (if necessary) for call/return
       // instructions. 
@@ -658,7 +659,7 @@
   RegClass *RC = LR->getRegClass();
   const ValueSet &LVSetBef = LVI->getLiveVarSetBeforeMInst(MInst, BB);
 
-  MF.pushTempValue(TM, MRI.getSpilledRegSize(RegType) );
+  MF.getInfo()->pushTempValue(MRI.getSpilledRegSize(RegType) );
   
   vector<MachineInstr*> MIBef, MIAft;
   vector<MachineInstr*> AdIMid;
@@ -749,7 +750,7 @@
     // we couldn't find an unused register. Generate code to free up a reg by
     // saving it on stack and restoring after the instruction
     
-    int TmpOff = MF.pushTempValue(TM,  MRI.getSpilledRegSize(RegType) );
+    int TmpOff = MF.getInfo()->pushTempValue(MRI.getSpilledRegSize(RegType));
     
     RegU = getUniRegNotUsedByThisInst(RC, MInst);
     
@@ -1093,7 +1094,7 @@
     if (HMI->first && HMI->second) {
       LiveRange *L = HMI->second;      // get the LiveRange
       if (!L->hasColor()) {   //  NOTE: ** allocating the size of long Type **
-        int stackOffset = MF.allocateSpilledValue(TM, Type::LongTy);
+        int stackOffset = MF.getInfo()->allocateSpilledValue(Type::LongTy);
         L->setSpillOffFromFP(stackOffset);
         if (DEBUG_RA)
           cerr << "  LR# " << L->getUserIGNode()->getIndex()
@@ -1159,12 +1160,12 @@
   for (unsigned rc=0; rc < NumOfRegClasses ; rc++)  
     RegClassList[rc]->colorAllRegs();    
 
-  // Atter grpah coloring, if some LRs did not receive a color (i.e, spilled)
+  // Atter graph coloring, if some LRs did not receive a color (i.e, spilled)
   // a poistion for such spilled LRs
   //
   allocateStackSpace4SpilledLRs();
 
-  MF.popAllTempValues(TM);  // TODO **Check
+  MF.getInfo()->popAllTempValues();  // TODO **Check
 
   // color incoming args - if the correct color was not received
   // insert code to copy to the correct register
