Changes in directory llvm/lib/Bytecode/Reader:
Reader.cpp updated: 1.187 -> 1.188
Reader.h updated: 1.27 -> 1.28
---
Log message:
Fix auto-upgrade of intrinsics to work properly with both assembly and
bytecode reading. This code is crufty, the result of much hacking to get things
working correctly. Cleanup patches will follow.
---
Diffs of the changes: (+33 -18)
Reader.cpp | 45 ++++++++++++++++++++++++++++++---------------
Reader.h | 6 +++---
2 files changed, 33 insertions(+), 18 deletions(-)
Index: llvm/lib/Bytecode/Reader/Reader.cpp
diff -u llvm/lib/Bytecode/Reader/Reader.cpp:1.187
llvm/lib/Bytecode/Reader/Reader.cpp:1.188
--- llvm/lib/Bytecode/Reader/Reader.cpp:1.187 Wed Jan 25 17:08:15 2006
+++ llvm/lib/Bytecode/Reader/Reader.cpp Fri Jan 27 05:49:27 2006
@@ -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);
Index: llvm/lib/Bytecode/Reader/Reader.h
diff -u llvm/lib/Bytecode/Reader/Reader.h:1.27
llvm/lib/Bytecode/Reader/Reader.h:1.28
--- llvm/lib/Bytecode/Reader/Reader.h:1.27 Wed Jan 25 17:08:15 2006
+++ llvm/lib/Bytecode/Reader/Reader.h Fri Jan 27 05:49:27 2006
@@ -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
_______________________________________________
llvm-commits mailing list
llvm-commits@cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
