diff --git a/lib/Bytecode/Reader/Reader.cpp b/lib/Bytecode/Reader/Reader.cpp
index d142aac..f9ac0ba 100644
--- a/lib/Bytecode/Reader/Reader.cpp
+++ b/lib/Bytecode/Reader/Reader.cpp
@@ -861,7 +861,6 @@
     Result = new CallInst(F, Params);
     if (isTailCall) cast<CallInst>(Result)->setTailCall();
     if (CallingConv) cast<CallInst>(Result)->setCallingConv(CallingConv);
-    isCall = true;
     break;
   }
   case 56:                     // Invoke with encoded CC
@@ -1034,13 +1033,6 @@
 
   BB->getInstList().push_back(Result);
 
-  if (this->hasUpgradedIntrinsicFunctions && isCall)
-    if (Instruction* inst = UpgradeIntrinsicCall(cast<CallInst>(Result))) {
-      Result->replaceAllUsesWith(inst);
-      Result->eraseFromParent();
-      Result = inst;
-    }
-
   unsigned TypeSlot;
   if (Result->getType() == InstTy)
     TypeSlot = iType;
@@ -1862,6 +1854,25 @@
     delete PlaceHolder;
   }
 
+  // If upgraded intrinsic functions were detected during reading of the 
+  // module information, then we need to look for instructions that need to
+  // be upgraded. This can't be done while the instructions are read in because
+  // additional instructions inserted mess up the slot numbering.
+  if (!upgradedFunctions.empty()) {
+    for (Function::iterator BI = F->begin(), BE = F->end(); BI != BE; ++BI) 
+      for (BasicBlock::iterator II = BI->begin(), IE = BI->end(); 
+           II != IE; ++II)
+        if (CallInst* CI = dyn_cast<CallInst>(II)) {
+          std::map<Function*,Function*>::iterator FI = 
+            upgradedFunctions.find(CI->getCalledFunction());
+          if (FI != upgradedFunctions.end()) {
+            Instruction* newI = UpgradeIntrinsicCall(CI,FI->second);
+            CI->replaceAllUsesWith(newI);
+            CI->eraseFromParent();
+          }
+        }
+  }
+
   // Clear out function-level types...
   FunctionTypes.clear();
   CompactionTypes.clear();
@@ -1937,6 +1948,7 @@
     ++Fi;
   }
   LazyFunctionLoadMap.clear();
+
 }
 
 /// Parse the global type list
@@ -2055,13 +2067,6 @@
     Function *Func = new Function(FTy, GlobalValue::ExternalLinkage,
                                   "", TheModule);
 
-    // Replace with upgraded intrinsic function, if applicable.
-    if (Function* upgrdF = UpgradeIntrinsicFunction(Func)) {
-      hasUpgradedIntrinsicFunctions = true;
-      Func->eraseFromParent();
-      Func = upgrdF;
-    }
-
     insertValue(Func, (FnSignature & (~0U >> 1)) >> 5, ModuleValues);
 
     // Flags are not used yet.
@@ -2433,6 +2438,16 @@
     if (hasFunctions())
       error("Function expected, but bytecode stream ended!");
 
+    // Look for intrinsic functions to upgrade, upgrade them, and save the
+    // mapping from old function to new for use later when instructions are
+    // converted.
+    for (Module::iterator FI = TheModule->begin(), FE = TheModule->end();
+         FI != FE; ++FI)
+      if (Function* newF = UpgradeIntrinsicFunction(FI)) {
+        upgradedFunctions.insert(std::make_pair(FI,newF));
+        FI->setName("");
+      }
+
     // Tell the handler we're done with the module
     if (Handler)
       Handler->handleModuleEnd(ModuleID);
diff --git a/lib/Bytecode/Reader/Reader.h b/lib/Bytecode/Reader/Reader.h
index 21eb846..ffc251b 100644
--- a/lib/Bytecode/Reader/Reader.h
+++ b/lib/Bytecode/Reader/Reader.h
@@ -323,9 +323,9 @@
 
   /// In release 1.7 we changed intrinsic functions to not be overloaded. There
   /// is no bytecode change for this, but to optimize the auto-upgrade of calls
-  /// to intrinsic functions, we set this flag to identify when a module has
-  /// been read that contains intrinsics that were upgraded.
-  bool hasUpgradedIntrinsicFunctions;
+  /// to intrinsic functions, we save a mapping of old function definitions to
+  /// the new ones so call instructions can be upgraded efficiently.
+  std::map<Function*,Function*> upgradedFunctions;
 
   /// CompactionTypes - If a compaction table is active in the current function,
   /// this is the mapping that it contains.  We keep track of what resolved type