3 files changed, 31 insertions, 32 deletions

diff --git a/llvm/lib/Target/X86/X86FastISel.cpp b/llvm/lib/Target/X86/X86FastISel.cpp
index 658b65dba73..9b784b44497 100644
--- a/llvm/lib/Target/X86/X86FastISel.cpp
+++ b/llvm/lib/Target/X86/X86FastISel.cpp
@@ -30,34 +30,27 @@ class X86FastISel : public FastISel {
   const X86Subtarget *Subtarget;
     
 public:
-  explicit X86FastISel(MachineFunction &mf) : FastISel(mf) {
+  explicit X86FastISel(MachineFunction &mf,
+                       DenseMap<const Value *, unsigned> &vm,
+                       DenseMap<const BasicBlock *, MachineBasicBlock *> &bm)
+    : FastISel(mf, vm, bm) {
     Subtarget = &TM.getSubtarget<X86Subtarget>();
   }
 
-  virtual bool
-    TargetSelectInstruction(Instruction *I,
-                            DenseMap<const Value *, unsigned> &ValueMap,
-                      DenseMap<const BasicBlock *, MachineBasicBlock *> &MBBMap,
-                            MachineBasicBlock *MBB);
+  virtual bool TargetSelectInstruction(Instruction *I);
 
 #include "X86GenFastISel.inc"
 
 private:
-  bool X86SelectConstAddr(Value *V,
-                          DenseMap<const Value *, unsigned> &ValueMap,
-                          MachineBasicBlock *MBB, unsigned &Op0);
+  bool X86SelectConstAddr(Value *V, unsigned &Op0);
 
-  bool X86SelectLoad(Instruction *I,
-                     DenseMap<const Value *, unsigned> &ValueMap,
-                     MachineBasicBlock *MBB);
+  bool X86SelectLoad(Instruction *I);
 };
 
 /// X86SelectConstAddr - Select and emit code to materialize constant address.
 /// 
 bool X86FastISel::X86SelectConstAddr(Value *V,
-                                    DenseMap<const Value *, unsigned> &ValueMap,
-                                    MachineBasicBlock *MBB,
-                                    unsigned &Op0) {
+                                     unsigned &Op0) {
   // FIXME: Only GlobalAddress for now.
   GlobalValue *GV = dyn_cast<GlobalValue>(V);
   if (!GV)
@@ -84,9 +77,7 @@ bool X86FastISel::X86SelectConstAddr(Value *V,
 
 /// X86SelectLoad - Select and emit code to implement load instructions.
 ///
-bool X86FastISel::X86SelectLoad(Instruction *I,
-                                DenseMap<const Value *, unsigned> &ValueMap,
-                                MachineBasicBlock *MBB)  {
+bool X86FastISel::X86SelectLoad(Instruction *I)  {
   MVT VT = MVT::getMVT(I->getType(), /*HandleUnknown=*/true);
   if (VT == MVT::Other || !VT.isSimple())
     // Unhandled type. Halt "fast" selection and bail.
@@ -102,10 +93,10 @@ bool X86FastISel::X86SelectLoad(Instruction *I,
     return false;
 
   Value *V = I->getOperand(0);
-  unsigned Op0 = getRegForValue(V, ValueMap);
+  unsigned Op0 = getRegForValue(V);
   if (Op0 == 0) {
     // Handle constant load address.
-    if (!isa<Constant>(V) || !X86SelectConstAddr(V, ValueMap, MBB, Op0))
+    if (!isa<Constant>(V) || !X86SelectConstAddr(V, Op0))
       // Unhandled operand. Halt "fast" selection and bail.
       return false;    
   }
@@ -164,27 +155,26 @@ bool X86FastISel::X86SelectLoad(Instruction *I,
   else
     AM.GV = cast<GlobalValue>(V);
   addFullAddress(BuildMI(MBB, TII.get(Opc), ResultReg), AM);
-  UpdateValueMap(I, ResultReg, ValueMap);
+  UpdateValueMap(I, ResultReg);
   return true;
 }
 
 
 bool
-X86FastISel::TargetSelectInstruction(Instruction *I,
-                                  DenseMap<const Value *, unsigned> &ValueMap,
-                      DenseMap<const BasicBlock *, MachineBasicBlock *> &MBBMap,
-                                  MachineBasicBlock *MBB)  {
+X86FastISel::TargetSelectInstruction(Instruction *I)  {
   switch (I->getOpcode()) {
   default: break;
   case Instruction::Load:
-    return X86SelectLoad(I, ValueMap, MBB);
+    return X86SelectLoad(I);
   }
 
   return false;
 }
 
 namespace llvm {
-  llvm::FastISel *X86::createFastISel(MachineFunction &mf) {
-    return new X86FastISel(mf);
+  llvm::FastISel *X86::createFastISel(MachineFunction &mf,
+                        DenseMap<const Value *, unsigned> &vm,
+                        DenseMap<const BasicBlock *, MachineBasicBlock *> &bm) {
+    return new X86FastISel(mf, vm, bm);
   }
 }
diff --git a/llvm/lib/Target/X86/X86ISelLowering.cpp b/llvm/lib/Target/X86/X86ISelLowering.cpp
index dceed6fa239..2cdd93c66b5 100644
--- a/llvm/lib/Target/X86/X86ISelLowering.cpp
+++ b/llvm/lib/Target/X86/X86ISelLowering.cpp
@@ -1879,8 +1879,12 @@ bool X86TargetLowering::IsEligibleForTailCallOptimization(SDValue Call,
   return false;
 }
 
-FastISel *X86TargetLowering::createFastISel(MachineFunction &mf) {
-  return X86::createFastISel(mf);
+FastISel *
+X86TargetLowering::createFastISel(MachineFunction &mf,
+                                  DenseMap<const Value *, unsigned> &vm,
+                                  DenseMap<const BasicBlock *,
+                                           MachineBasicBlock *> &bm) {
+  return X86::createFastISel(mf, vm, bm);
 }
 
 
diff --git a/llvm/lib/Target/X86/X86ISelLowering.h b/llvm/lib/Target/X86/X86ISelLowering.h
index c50769c6853..e83132d0071 100644
--- a/llvm/lib/Target/X86/X86ISelLowering.h
+++ b/llvm/lib/Target/X86/X86ISelLowering.h
@@ -470,7 +470,10 @@ namespace llvm {
 
     /// createFastISel - This method returns a target specific FastISel object,
     /// or null if the target does not support "fast" ISel.
-    virtual FastISel *createFastISel(MachineFunction &mf);
+    virtual FastISel *
+    createFastISel(MachineFunction &mf,
+                   DenseMap<const Value *, unsigned> &,
+                   DenseMap<const BasicBlock *, MachineBasicBlock *> &);
     
   private:
     /// Subtarget - Keep a pointer to the X86Subtarget around so that we can
@@ -598,7 +601,9 @@ namespace llvm {
   };
 
   namespace X86 {
-    FastISel *createFastISel(MachineFunction &mf);
+    FastISel *createFastISel(MachineFunction &mf,
+                           DenseMap<const Value *, unsigned> &,
+                           DenseMap<const BasicBlock *, MachineBasicBlock *> &);
   }
 }