6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-01 00:33:09 +00:00
Code Issues Projects Releases Wiki Activity

Cosmetic change.

Browse Source 
Do not use "ValueMap" as a name for a local variable or an argument.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@106698 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Devang Patel 2010-06-23 23:55:51 +00:00
parent 71339c965c
commit 29d3dd8a64
7 changed files with 116 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
include/llvm/Transforms/Utils/Cloning.h
View File

@ -46,7 +46,7 @@ class AllocaInst;
/// CloneModule - Return an exact copy of the specified module /// CloneModule - Return an exact copy of the specified module
/// ///
Module *CloneModule(const Module *M); Module *CloneModule(const Module *M);
Module *CloneModule(const Module *M, DenseMap<const Value*, Value*> &ValueMap); Module *CloneModule(const Module *M, DenseMap<const Value*, Value*> &VMap);
/// ClonedCodeInfo - This struct can be used to capture information about code /// ClonedCodeInfo - This struct can be used to capture information about code
/// being cloned, while it is being cloned. /// being cloned, while it is being cloned.
@ -89,7 +89,7 @@ struct ClonedCodeInfo {
/// incoming edges. /// incoming edges.
/// ///
/// The correlation between instructions in the source and result basic blocks /// The correlation between instructions in the source and result basic blocks
/// is recorded in the ValueMap map. /// is recorded in the VMap map.
/// ///
/// If you have a particular suffix you'd like to use to add to any cloned /// If you have a particular suffix you'd like to use to add to any cloned
/// names, specify it as the optional third parameter. /// names, specify it as the optional third parameter.
@ -102,34 +102,34 @@ struct ClonedCodeInfo {
/// parameter. /// parameter.
/// ///
BasicBlock *CloneBasicBlock(const BasicBlock *BB, BasicBlock *CloneBasicBlock(const BasicBlock *BB,
DenseMap<const Value*, Value*> &ValueMap, DenseMap<const Value*, Value*> &VMap,
const Twine &NameSuffix = "", Function *F = 0, const Twine &NameSuffix = "", Function *F = 0,
ClonedCodeInfo *CodeInfo = 0); ClonedCodeInfo *CodeInfo = 0);
/// CloneLoop - Clone Loop. Clone dominator info for loop insiders. Populate /// CloneLoop - Clone Loop. Clone dominator info for loop insiders. Populate
/// ValueMap using old blocks to new blocks mapping. /// VMap using old blocks to new blocks mapping.
Loop *CloneLoop(Loop *L, LPPassManager *LPM, LoopInfo *LI, Loop *CloneLoop(Loop *L, LPPassManager *LPM, LoopInfo *LI,
DenseMap<const Value *, Value *> &ValueMap, Pass *P); DenseMap<const Value *, Value *> &VMap, Pass *P);
/// CloneFunction - Return a copy of the specified function, but without /// CloneFunction - Return a copy of the specified function, but without
/// embedding the function into another module. Also, any references specified /// embedding the function into another module. Also, any references specified
/// in the ValueMap are changed to refer to their mapped value instead of the /// in the VMap are changed to refer to their mapped value instead of the
/// original one. If any of the arguments to the function are in the ValueMap, /// original one. If any of the arguments to the function are in the VMap,
/// the arguments are deleted from the resultant function. The ValueMap is /// the arguments are deleted from the resultant function. The VMap is
/// updated to include mappings from all of the instructions and basicblocks in /// updated to include mappings from all of the instructions and basicblocks in
/// the function from their old to new values. The final argument captures /// the function from their old to new values. The final argument captures
/// information about the cloned code if non-null. /// information about the cloned code if non-null.
/// ///
Function *CloneFunction(const Function *F, Function *CloneFunction(const Function *F,
DenseMap<const Value*, Value*> &ValueMap, DenseMap<const Value*, Value*> &VMap,
ClonedCodeInfo *CodeInfo = 0); ClonedCodeInfo *CodeInfo = 0);
/// CloneFunction - Version of the function that doesn't need the ValueMap. /// CloneFunction - Version of the function that doesn't need the VMap.
/// ///
inline Function *CloneFunction(const Function *F, ClonedCodeInfo *CodeInfo = 0){ inline Function *CloneFunction(const Function *F, ClonedCodeInfo *CodeInfo = 0){
DenseMap<const Value*, Value*> ValueMap; DenseMap<const Value*, Value*> VMap;
return CloneFunction(F, ValueMap, CodeInfo); return CloneFunction(F, VMap, CodeInfo);
} }
/// Clone OldFunc into NewFunc, transforming the old arguments into references /// Clone OldFunc into NewFunc, transforming the old arguments into references
@ -139,7 +139,7 @@ inline Function *CloneFunction(const Function *F, ClonedCodeInfo *CodeInfo = 0){
/// specified suffix to all values cloned. /// specified suffix to all values cloned.
/// ///
void CloneFunctionInto(Function *NewFunc, const Function *OldFunc, void CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
DenseMap<const Value*, Value*> &ValueMap, DenseMap<const Value*, Value*> &VMap,
SmallVectorImpl<ReturnInst*> &Returns, SmallVectorImpl<ReturnInst*> &Returns,
const char *NameSuffix = "", const char *NameSuffix = "",
ClonedCodeInfo *CodeInfo = 0); ClonedCodeInfo *CodeInfo = 0);
@ -152,7 +152,7 @@ void CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
/// dead. Since this doesn't produce an exactly copy of the input, it can't be /// dead. Since this doesn't produce an exactly copy of the input, it can't be
/// used for things like CloneFunction or CloneModule. /// used for things like CloneFunction or CloneModule.
void CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc, void CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc,
DenseMap<const Value*, Value*> &ValueMap, DenseMap<const Value*, Value*> &VMap,
SmallVectorImpl<ReturnInst*> &Returns, SmallVectorImpl<ReturnInst*> &Returns,
const char *NameSuffix = "", const char *NameSuffix = "",
ClonedCodeInfo *CodeInfo = 0, ClonedCodeInfo *CodeInfo = 0,

98
lib/Transforms/Utils/CloneFunction.cpp
View File

@ -32,7 +32,7 @@ using namespace llvm;
// CloneBasicBlock - See comments in Cloning.h // CloneBasicBlock - See comments in Cloning.h
BasicBlock *llvm::CloneBasicBlock(const BasicBlock *BB, BasicBlock *llvm::CloneBasicBlock(const BasicBlock *BB,
DenseMap<const Value*, Value*> &ValueMap, DenseMap<const Value*, Value*> &VMap,
const Twine &NameSuffix, Function *F, const Twine &NameSuffix, Function *F,
ClonedCodeInfo *CodeInfo) { ClonedCodeInfo *CodeInfo) {
BasicBlock *NewBB = BasicBlock::Create(BB->getContext(), "", F); BasicBlock *NewBB = BasicBlock::Create(BB->getContext(), "", F);
@ -47,7 +47,7 @@ BasicBlock *llvm::CloneBasicBlock(const BasicBlock *BB,
if (II->hasName()) if (II->hasName())
NewInst->setName(II->getName()+NameSuffix); NewInst->setName(II->getName()+NameSuffix);
NewBB->getInstList().push_back(NewInst); NewBB->getInstList().push_back(NewInst);
ValueMap[II] = NewInst; // Add instruction map to value. VMap[II] = NewInst; // Add instruction map to value.
hasCalls |= (isa<CallInst>(II) && !isa<DbgInfoIntrinsic>(II)); hasCalls |= (isa<CallInst>(II) && !isa<DbgInfoIntrinsic>(II));
if (const AllocaInst *AI = dyn_cast<AllocaInst>(II)) { if (const AllocaInst *AI = dyn_cast<AllocaInst>(II)) {
@ -72,7 +72,7 @@ BasicBlock *llvm::CloneBasicBlock(const BasicBlock *BB,
// ArgMap values. // ArgMap values.
// //
void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc, void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
DenseMap<const Value*, Value*> &ValueMap, DenseMap<const Value*, Value*> &VMap,
SmallVectorImpl<ReturnInst*> &Returns, SmallVectorImpl<ReturnInst*> &Returns,
const char *NameSuffix, ClonedCodeInfo *CodeInfo) { const char *NameSuffix, ClonedCodeInfo *CodeInfo) {
assert(NameSuffix && "NameSuffix cannot be null!"); assert(NameSuffix && "NameSuffix cannot be null!");
@ -80,17 +80,17 @@ void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
#ifndef NDEBUG #ifndef NDEBUG
for (Function::const_arg_iterator I = OldFunc->arg_begin(), for (Function::const_arg_iterator I = OldFunc->arg_begin(),
E = OldFunc->arg_end(); I != E; ++I) E = OldFunc->arg_end(); I != E; ++I)
assert(ValueMap.count(I) && "No mapping from source argument specified!"); assert(VMap.count(I) && "No mapping from source argument specified!");
#endif #endif
// Clone any attributes. // Clone any attributes.
if (NewFunc->arg_size() == OldFunc->arg_size()) if (NewFunc->arg_size() == OldFunc->arg_size())
NewFunc->copyAttributesFrom(OldFunc); NewFunc->copyAttributesFrom(OldFunc);
else { else {
//Some arguments were deleted with the ValueMap. Copy arguments one by one //Some arguments were deleted with the VMap. Copy arguments one by one
for (Function::const_arg_iterator I = OldFunc->arg_begin(), for (Function::const_arg_iterator I = OldFunc->arg_begin(),
E = OldFunc->arg_end(); I != E; ++I) E = OldFunc->arg_end(); I != E; ++I)
if (Argument* Anew = dyn_cast<Argument>(ValueMap[I])) if (Argument* Anew = dyn_cast<Argument>(VMap[I]))
Anew->addAttr( OldFunc->getAttributes() Anew->addAttr( OldFunc->getAttributes()
.getParamAttributes(I->getArgNo() + 1)); .getParamAttributes(I->getArgNo() + 1));
NewFunc->setAttributes(NewFunc->getAttributes() NewFunc->setAttributes(NewFunc->getAttributes()
@ -111,43 +111,43 @@ void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
const BasicBlock &BB = *BI; const BasicBlock &BB = *BI;
// Create a new basic block and copy instructions into it! // Create a new basic block and copy instructions into it!
BasicBlock *CBB = CloneBasicBlock(&BB, ValueMap, NameSuffix, NewFunc, BasicBlock *CBB = CloneBasicBlock(&BB, VMap, NameSuffix, NewFunc,
CodeInfo); CodeInfo);
ValueMap[&BB] = CBB; // Add basic block mapping. VMap[&BB] = CBB; // Add basic block mapping.
if (ReturnInst *RI = dyn_cast<ReturnInst>(CBB->getTerminator())) if (ReturnInst *RI = dyn_cast<ReturnInst>(CBB->getTerminator()))
Returns.push_back(RI); Returns.push_back(RI);
} }
// Loop over all of the instructions in the function, fixing up operand // Loop over all of the instructions in the function, fixing up operand
// references as we go. This uses ValueMap to do all the hard work. // references as we go. This uses VMap to do all the hard work.
// //
for (Function::iterator BB = cast<BasicBlock>(ValueMap[OldFunc->begin()]), for (Function::iterator BB = cast<BasicBlock>(VMap[OldFunc->begin()]),
BE = NewFunc->end(); BB != BE; ++BB) BE = NewFunc->end(); BB != BE; ++BB)
// Loop over all instructions, fixing each one as we find it... // Loop over all instructions, fixing each one as we find it...
for (BasicBlock::iterator II = BB->begin(); II != BB->end(); ++II) for (BasicBlock::iterator II = BB->begin(); II != BB->end(); ++II)
RemapInstruction(II, ValueMap); RemapInstruction(II, VMap);
} }
/// CloneFunction - Return a copy of the specified function, but without /// CloneFunction - Return a copy of the specified function, but without
/// embedding the function into another module. Also, any references specified /// embedding the function into another module. Also, any references specified
/// in the ValueMap are changed to refer to their mapped value instead of the /// in the VMap are changed to refer to their mapped value instead of the
/// original one. If any of the arguments to the function are in the ValueMap, /// original one. If any of the arguments to the function are in the VMap,
/// the arguments are deleted from the resultant function. The ValueMap is /// the arguments are deleted from the resultant function. The VMap is
/// updated to include mappings from all of the instructions and basicblocks in /// updated to include mappings from all of the instructions and basicblocks in
/// the function from their old to new values. /// the function from their old to new values.
/// ///
Function *llvm::CloneFunction(const Function *F, Function *llvm::CloneFunction(const Function *F,
DenseMap<const Value*, Value*> &ValueMap, DenseMap<const Value*, Value*> &VMap,
ClonedCodeInfo *CodeInfo) { ClonedCodeInfo *CodeInfo) {
std::vector<const Type*> ArgTypes; std::vector<const Type*> ArgTypes;
// The user might be deleting arguments to the function by specifying them in // The user might be deleting arguments to the function by specifying them in
// the ValueMap. If so, we need to not add the arguments to the arg ty vector // the VMap. If so, we need to not add the arguments to the arg ty vector
// //
for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
I != E; ++I) I != E; ++I)
if (ValueMap.count(I) == 0) // Haven't mapped the argument to anything yet? if (VMap.count(I) == 0) // Haven't mapped the argument to anything yet?
ArgTypes.push_back(I->getType()); ArgTypes.push_back(I->getType());
// Create a new function type... // Create a new function type...
@ -161,13 +161,13 @@ Function *llvm::CloneFunction(const Function *F,
Function::arg_iterator DestI = NewF->arg_begin(); Function::arg_iterator DestI = NewF->arg_begin();
for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
I != E; ++I) I != E; ++I)
if (ValueMap.count(I) == 0) { // Is this argument preserved? if (VMap.count(I) == 0) { // Is this argument preserved?
DestI->setName(I->getName()); // Copy the name over... DestI->setName(I->getName()); // Copy the name over...
ValueMap[I] = DestI++; // Add mapping to ValueMap VMap[I] = DestI++; // Add mapping to VMap
} }
SmallVector<ReturnInst*, 8> Returns; // Ignore returns cloned. SmallVector<ReturnInst*, 8> Returns; // Ignore returns cloned.
CloneFunctionInto(NewF, F, ValueMap, Returns, "", CodeInfo); CloneFunctionInto(NewF, F, VMap, Returns, "", CodeInfo);
return NewF; return NewF;
} }
@ -179,7 +179,7 @@ namespace {
struct PruningFunctionCloner { struct PruningFunctionCloner {
Function *NewFunc; Function *NewFunc;
const Function *OldFunc; const Function *OldFunc;
DenseMap<const Value*, Value*> &ValueMap; DenseMap<const Value*, Value*> &VMap;
SmallVectorImpl<ReturnInst*> &Returns; SmallVectorImpl<ReturnInst*> &Returns;
const char *NameSuffix; const char *NameSuffix;
ClonedCodeInfo *CodeInfo; ClonedCodeInfo *CodeInfo;
@ -191,7 +191,7 @@ namespace {
const char *nameSuffix, const char *nameSuffix,
ClonedCodeInfo *codeInfo, ClonedCodeInfo *codeInfo,
const TargetData *td) const TargetData *td)
: NewFunc(newFunc), OldFunc(oldFunc), ValueMap(valueMap), Returns(returns), : NewFunc(newFunc), OldFunc(oldFunc), VMap(valueMap), Returns(returns),
NameSuffix(nameSuffix), CodeInfo(codeInfo), TD(td) { NameSuffix(nameSuffix), CodeInfo(codeInfo), TD(td) {
} }
@ -202,7 +202,7 @@ namespace {
public: public:
/// ConstantFoldMappedInstruction - Constant fold the specified instruction, /// ConstantFoldMappedInstruction - Constant fold the specified instruction,
/// mapping its operands through ValueMap if they are available. /// mapping its operands through VMap if they are available.
Constant *ConstantFoldMappedInstruction(const Instruction *I); Constant *ConstantFoldMappedInstruction(const Instruction *I);
}; };
} }
@ -211,7 +211,7 @@ namespace {
/// anything that it can reach. /// anything that it can reach.
void PruningFunctionCloner::CloneBlock(const BasicBlock *BB, void PruningFunctionCloner::CloneBlock(const BasicBlock *BB,
std::vector<const BasicBlock*> &ToClone){ std::vector<const BasicBlock*> &ToClone){
Value *&BBEntry = ValueMap[BB]; Value *&BBEntry = VMap[BB];
// Have we already cloned this block? // Have we already cloned this block?
if (BBEntry) return; if (BBEntry) return;
@ -230,7 +230,7 @@ void PruningFunctionCloner::CloneBlock(const BasicBlock *BB,
// If this instruction constant folds, don't bother cloning the instruction, // If this instruction constant folds, don't bother cloning the instruction,
// instead, just add the constant to the value map. // instead, just add the constant to the value map.
if (Constant *C = ConstantFoldMappedInstruction(II)) { if (Constant *C = ConstantFoldMappedInstruction(II)) {
ValueMap[II] = C; VMap[II] = C;
continue; continue;
} }
@ -238,7 +238,7 @@ void PruningFunctionCloner::CloneBlock(const BasicBlock *BB,
if (II->hasName()) if (II->hasName())
NewInst->setName(II->getName()+NameSuffix); NewInst->setName(II->getName()+NameSuffix);
NewBB->getInstList().push_back(NewInst); NewBB->getInstList().push_back(NewInst);
ValueMap[II] = NewInst; // Add instruction map to value. VMap[II] = NewInst; // Add instruction map to value.
hasCalls |= (isa<CallInst>(II) && !isa<DbgInfoIntrinsic>(II)); hasCalls |= (isa<CallInst>(II) && !isa<DbgInfoIntrinsic>(II));
if (const AllocaInst *AI = dyn_cast<AllocaInst>(II)) { if (const AllocaInst *AI = dyn_cast<AllocaInst>(II)) {
@ -258,12 +258,12 @@ void PruningFunctionCloner::CloneBlock(const BasicBlock *BB,
ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition()); ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition());
// Or is a known constant in the caller... // Or is a known constant in the caller...
if (Cond == 0) if (Cond == 0)
Cond = dyn_cast_or_null<ConstantInt>(ValueMap[BI->getCondition()]); Cond = dyn_cast_or_null<ConstantInt>(VMap[BI->getCondition()]);
// Constant fold to uncond branch! // Constant fold to uncond branch!
if (Cond) { if (Cond) {
BasicBlock *Dest = BI->getSuccessor(!Cond->getZExtValue()); BasicBlock *Dest = BI->getSuccessor(!Cond->getZExtValue());
ValueMap[OldTI] = BranchInst::Create(Dest, NewBB); VMap[OldTI] = BranchInst::Create(Dest, NewBB);
ToClone.push_back(Dest); ToClone.push_back(Dest);
TerminatorDone = true; TerminatorDone = true;
} }
@ -272,10 +272,10 @@ void PruningFunctionCloner::CloneBlock(const BasicBlock *BB,
// If switching on a value known constant in the caller. // If switching on a value known constant in the caller.
ConstantInt *Cond = dyn_cast<ConstantInt>(SI->getCondition()); ConstantInt *Cond = dyn_cast<ConstantInt>(SI->getCondition());
if (Cond == 0) // Or known constant after constant prop in the callee... if (Cond == 0) // Or known constant after constant prop in the callee...
Cond = dyn_cast_or_null<ConstantInt>(ValueMap[SI->getCondition()]); Cond = dyn_cast_or_null<ConstantInt>(VMap[SI->getCondition()]);
if (Cond) { // Constant fold to uncond branch! if (Cond) { // Constant fold to uncond branch!
BasicBlock *Dest = SI->getSuccessor(SI->findCaseValue(Cond)); BasicBlock *Dest = SI->getSuccessor(SI->findCaseValue(Cond));
ValueMap[OldTI] = BranchInst::Create(Dest, NewBB); VMap[OldTI] = BranchInst::Create(Dest, NewBB);
ToClone.push_back(Dest); ToClone.push_back(Dest);
TerminatorDone = true; TerminatorDone = true;
} }
@ -286,7 +286,7 @@ void PruningFunctionCloner::CloneBlock(const BasicBlock *BB,
if (OldTI->hasName()) if (OldTI->hasName())
NewInst->setName(OldTI->getName()+NameSuffix); NewInst->setName(OldTI->getName()+NameSuffix);
NewBB->getInstList().push_back(NewInst); NewBB->getInstList().push_back(NewInst);
ValueMap[OldTI] = NewInst; // Add instruction map to value. VMap[OldTI] = NewInst; // Add instruction map to value.
// Recursively clone any reachable successor blocks. // Recursively clone any reachable successor blocks.
const TerminatorInst *TI = BB->getTerminator(); const TerminatorInst *TI = BB->getTerminator();
@ -307,13 +307,13 @@ void PruningFunctionCloner::CloneBlock(const BasicBlock *BB,
} }
/// ConstantFoldMappedInstruction - Constant fold the specified instruction, /// ConstantFoldMappedInstruction - Constant fold the specified instruction,
/// mapping its operands through ValueMap if they are available. /// mapping its operands through VMap if they are available.
Constant *PruningFunctionCloner:: Constant *PruningFunctionCloner::
ConstantFoldMappedInstruction(const Instruction *I) { ConstantFoldMappedInstruction(const Instruction *I) {
SmallVector<Constant*, 8> Ops; SmallVector<Constant*, 8> Ops;
for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
if (Constant *Op = dyn_cast_or_null<Constant>(MapValue(I->getOperand(i), if (Constant *Op = dyn_cast_or_null<Constant>(MapValue(I->getOperand(i),
ValueMap))) VMap)))
Ops.push_back(Op); Ops.push_back(Op);
else else
return 0; // All operands not constant! return 0; // All operands not constant!
@ -363,7 +363,7 @@ static MDNode *UpdateInlinedAtInfo(MDNode *InsnMD, MDNode *TheCallMD) {
/// dead. Since this doesn't produce an exact copy of the input, it can't be /// dead. Since this doesn't produce an exact copy of the input, it can't be
/// used for things like CloneFunction or CloneModule. /// used for things like CloneFunction or CloneModule.
void llvm::CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc, void llvm::CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc,
DenseMap<const Value*, Value*> &ValueMap, DenseMap<const Value*, Value*> &VMap,
SmallVectorImpl<ReturnInst*> &Returns, SmallVectorImpl<ReturnInst*> &Returns,
const char *NameSuffix, const char *NameSuffix,
ClonedCodeInfo *CodeInfo, ClonedCodeInfo *CodeInfo,
@ -374,10 +374,10 @@ void llvm::CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc,
#ifndef NDEBUG #ifndef NDEBUG
for (Function::const_arg_iterator II = OldFunc->arg_begin(), for (Function::const_arg_iterator II = OldFunc->arg_begin(),
E = OldFunc->arg_end(); II != E; ++II) E = OldFunc->arg_end(); II != E; ++II)
assert(ValueMap.count(II) && "No mapping from source argument specified!"); assert(VMap.count(II) && "No mapping from source argument specified!");
#endif #endif
PruningFunctionCloner PFC(NewFunc, OldFunc, ValueMap, Returns, PruningFunctionCloner PFC(NewFunc, OldFunc, VMap, Returns,
NameSuffix, CodeInfo, TD); NameSuffix, CodeInfo, TD);
// Clone the entry block, and anything recursively reachable from it. // Clone the entry block, and anything recursively reachable from it.
@ -397,14 +397,14 @@ void llvm::CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc,
SmallVector<const PHINode*, 16> PHIToResolve; SmallVector<const PHINode*, 16> PHIToResolve;
for (Function::const_iterator BI = OldFunc->begin(), BE = OldFunc->end(); for (Function::const_iterator BI = OldFunc->begin(), BE = OldFunc->end();
BI != BE; ++BI) { BI != BE; ++BI) {
BasicBlock *NewBB = cast_or_null<BasicBlock>(ValueMap[BI]); BasicBlock *NewBB = cast_or_null<BasicBlock>(VMap[BI]);
if (NewBB == 0) continue; // Dead block. if (NewBB == 0) continue; // Dead block.
// Add the new block to the new function. // Add the new block to the new function.
NewFunc->getBasicBlockList().push_back(NewBB); NewFunc->getBasicBlockList().push_back(NewBB);
// Loop over all of the instructions in the block, fixing up operand // Loop over all of the instructions in the block, fixing up operand
// references as we go. This uses ValueMap to do all the hard work. // references as we go. This uses VMap to do all the hard work.
// //
BasicBlock::iterator I = NewBB->begin(); BasicBlock::iterator I = NewBB->begin();
@ -455,7 +455,7 @@ void llvm::CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc,
I->setMetadata(DbgKind, 0); I->setMetadata(DbgKind, 0);
} }
} }
RemapInstruction(I, ValueMap); RemapInstruction(I, VMap);
} }
} }
@ -465,19 +465,19 @@ void llvm::CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc,
const PHINode *OPN = PHIToResolve[phino]; const PHINode *OPN = PHIToResolve[phino];
unsigned NumPreds = OPN->getNumIncomingValues(); unsigned NumPreds = OPN->getNumIncomingValues();
const BasicBlock *OldBB = OPN->getParent(); const BasicBlock *OldBB = OPN->getParent();
BasicBlock *NewBB = cast<BasicBlock>(ValueMap[OldBB]); BasicBlock *NewBB = cast<BasicBlock>(VMap[OldBB]);
// Map operands for blocks that are live and remove operands for blocks // Map operands for blocks that are live and remove operands for blocks
// that are dead. // that are dead.
for (; phino != PHIToResolve.size() && for (; phino != PHIToResolve.size() &&
PHIToResolve[phino]->getParent() == OldBB; ++phino) { PHIToResolve[phino]->getParent() == OldBB; ++phino) {
OPN = PHIToResolve[phino]; OPN = PHIToResolve[phino];
PHINode *PN = cast<PHINode>(ValueMap[OPN]); PHINode *PN = cast<PHINode>(VMap[OPN]);
for (unsigned pred = 0, e = NumPreds; pred != e; ++pred) { for (unsigned pred = 0, e = NumPreds; pred != e; ++pred) {
if (BasicBlock *MappedBlock = if (BasicBlock *MappedBlock =
cast_or_null<BasicBlock>(ValueMap[PN->getIncomingBlock(pred)])) { cast_or_null<BasicBlock>(VMap[PN->getIncomingBlock(pred)])) {
Value *InVal = MapValue(PN->getIncomingValue(pred), Value *InVal = MapValue(PN->getIncomingValue(pred),
ValueMap); VMap);
assert(InVal && "Unknown input value?"); assert(InVal && "Unknown input value?");
PN->setIncomingValue(pred, InVal); PN->setIncomingValue(pred, InVal);
PN->setIncomingBlock(pred, MappedBlock); PN->setIncomingBlock(pred, MappedBlock);
@ -531,15 +531,15 @@ void llvm::CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc,
while ((PN = dyn_cast<PHINode>(I++))) { while ((PN = dyn_cast<PHINode>(I++))) {
Value *NV = UndefValue::get(PN->getType()); Value *NV = UndefValue::get(PN->getType());
PN->replaceAllUsesWith(NV); PN->replaceAllUsesWith(NV);
assert(ValueMap[OldI] == PN && "ValueMap mismatch"); assert(VMap[OldI] == PN && "VMap mismatch");
ValueMap[OldI] = NV; VMap[OldI] = NV;
PN->eraseFromParent(); PN->eraseFromParent();
++OldI; ++OldI;
} }
} }
// NOTE: We cannot eliminate single entry phi nodes here, because of // NOTE: We cannot eliminate single entry phi nodes here, because of
// ValueMap. Single entry phi nodes can have multiple ValueMap entries // VMap. Single entry phi nodes can have multiple VMap entries
// pointing at them. Thus, deleting one would require scanning the ValueMap // pointing at them. Thus, deleting one would require scanning the VMap
// to update any entries in it that would require that. This would be // to update any entries in it that would require that. This would be
// really slow. // really slow.
} }
@ -548,14 +548,14 @@ void llvm::CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc,
// and zap unconditional fall-through branches. This happen all the time when // and zap unconditional fall-through branches. This happen all the time when
// specializing code: code specialization turns conditional branches into // specializing code: code specialization turns conditional branches into
// uncond branches, and this code folds them. // uncond branches, and this code folds them.
Function::iterator I = cast<BasicBlock>(ValueMap[&OldFunc->getEntryBlock()]); Function::iterator I = cast<BasicBlock>(VMap[&OldFunc->getEntryBlock()]);
while (I != NewFunc->end()) { while (I != NewFunc->end()) {
BranchInst *BI = dyn_cast<BranchInst>(I->getTerminator()); BranchInst *BI = dyn_cast<BranchInst>(I->getTerminator());
if (!BI || BI->isConditional()) { ++I; continue; } if (!BI || BI->isConditional()) { ++I; continue; }
// Note that we can't eliminate uncond branches if the destination has // Note that we can't eliminate uncond branches if the destination has
// single-entry PHI nodes. Eliminating the single-entry phi nodes would // single-entry PHI nodes. Eliminating the single-entry phi nodes would
// require scanning the ValueMap to update any entries that point to the phi // require scanning the VMap to update any entries that point to the phi
// node. // node.
BasicBlock *Dest = BI->getSuccessor(0); BasicBlock *Dest = BI->getSuccessor(0);
if (!Dest->getSinglePredecessor() || isa<PHINode>(Dest->begin())) { if (!Dest->getSinglePredecessor() || isa<PHINode>(Dest->begin())) {

32
lib/Transforms/Utils/CloneLoop.cpp
View File

@ -23,13 +23,13 @@ using namespace llvm;
/// CloneDominatorInfo - Clone basicblock's dominator tree and, if available, /// CloneDominatorInfo - Clone basicblock's dominator tree and, if available,
/// dominance info. It is expected that basic block is already cloned. /// dominance info. It is expected that basic block is already cloned.
static void CloneDominatorInfo(BasicBlock *BB, static void CloneDominatorInfo(BasicBlock *BB,
DenseMap<const Value *, Value *> &ValueMap, DenseMap<const Value *, Value *> &VMap,
DominatorTree *DT, DominatorTree *DT,
DominanceFrontier *DF) { DominanceFrontier *DF) {
assert (DT && "DominatorTree is not available"); assert (DT && "DominatorTree is not available");
DenseMap<const Value *, Value*>::iterator BI = ValueMap.find(BB); DenseMap<const Value *, Value*>::iterator BI = VMap.find(BB);
assert (BI != ValueMap.end() && "BasicBlock clone is missing"); assert (BI != VMap.end() && "BasicBlock clone is missing");
BasicBlock *NewBB = cast<BasicBlock>(BI->second); BasicBlock *NewBB = cast<BasicBlock>(BI->second);
// NewBB already got dominator info. // NewBB already got dominator info.
@ -43,11 +43,11 @@ static void CloneDominatorInfo(BasicBlock *BB,
// NewBB's dominator is either BB's dominator or BB's dominator's clone. // NewBB's dominator is either BB's dominator or BB's dominator's clone.
BasicBlock *NewBBDom = BBDom; BasicBlock *NewBBDom = BBDom;
DenseMap<const Value *, Value*>::iterator BBDomI = ValueMap.find(BBDom); DenseMap<const Value *, Value*>::iterator BBDomI = VMap.find(BBDom);
if (BBDomI != ValueMap.end()) { if (BBDomI != VMap.end()) {
NewBBDom = cast<BasicBlock>(BBDomI->second); NewBBDom = cast<BasicBlock>(BBDomI->second);
if (!DT->getNode(NewBBDom)) if (!DT->getNode(NewBBDom))
CloneDominatorInfo(BBDom, ValueMap, DT, DF); CloneDominatorInfo(BBDom, VMap, DT, DF);
} }
DT->addNewBlock(NewBB, NewBBDom); DT->addNewBlock(NewBB, NewBBDom);
@ -60,8 +60,8 @@ static void CloneDominatorInfo(BasicBlock *BB,
for (DominanceFrontier::DomSetType::iterator I = S.begin(), E = S.end(); for (DominanceFrontier::DomSetType::iterator I = S.begin(), E = S.end();
I != E; ++I) { I != E; ++I) {
BasicBlock *DB = *I; BasicBlock *DB = *I;
DenseMap<const Value*, Value*>::iterator IDM = ValueMap.find(DB); DenseMap<const Value*, Value*>::iterator IDM = VMap.find(DB);
if (IDM != ValueMap.end()) if (IDM != VMap.end())
NewDFSet.insert(cast<BasicBlock>(IDM->second)); NewDFSet.insert(cast<BasicBlock>(IDM->second));
else else
NewDFSet.insert(DB); NewDFSet.insert(DB);
@ -71,10 +71,10 @@ static void CloneDominatorInfo(BasicBlock *BB,
} }
} }
/// CloneLoop - Clone Loop. Clone dominator info. Populate ValueMap /// CloneLoop - Clone Loop. Clone dominator info. Populate VMap
/// using old blocks to new blocks mapping. /// using old blocks to new blocks mapping.
Loop *llvm::CloneLoop(Loop *OrigL, LPPassManager *LPM, LoopInfo *LI, Loop *llvm::CloneLoop(Loop *OrigL, LPPassManager *LPM, LoopInfo *LI,
DenseMap<const Value *, Value *> &ValueMap, Pass *P) { DenseMap<const Value *, Value *> &VMap, Pass *P) {
DominatorTree *DT = NULL; DominatorTree *DT = NULL;
DominanceFrontier *DF = NULL; DominanceFrontier *DF = NULL;
@ -104,8 +104,8 @@ Loop *llvm::CloneLoop(Loop *OrigL, LPPassManager *LPM, LoopInfo *LI,
for (Loop::block_iterator I = L->block_begin(), E = L->block_end(); for (Loop::block_iterator I = L->block_begin(), E = L->block_end();
I != E; ++I) { I != E; ++I) {
BasicBlock *BB = *I; BasicBlock *BB = *I;
BasicBlock *NewBB = CloneBasicBlock(BB, ValueMap, ".clone"); BasicBlock *NewBB = CloneBasicBlock(BB, VMap, ".clone");
ValueMap[BB] = NewBB; VMap[BB] = NewBB;
if (P) if (P)
LPM->cloneBasicBlockSimpleAnalysis(BB, NewBB, L); LPM->cloneBasicBlockSimpleAnalysis(BB, NewBB, L);
NewLoop->addBasicBlockToLoop(NewBB, LI->getBase()); NewLoop->addBasicBlockToLoop(NewBB, LI->getBase());
@ -117,7 +117,7 @@ Loop *llvm::CloneLoop(Loop *OrigL, LPPassManager *LPM, LoopInfo *LI,
for (Loop::block_iterator I = L->block_begin(), E = L->block_end(); for (Loop::block_iterator I = L->block_begin(), E = L->block_end();
I != E; ++I) { I != E; ++I) {
BasicBlock *BB = *I; BasicBlock *BB = *I;
CloneDominatorInfo(BB, ValueMap, DT, DF); CloneDominatorInfo(BB, VMap, DT, DF);
} }
// Process sub loops // Process sub loops
@ -125,7 +125,7 @@ Loop *llvm::CloneLoop(Loop *OrigL, LPPassManager *LPM, LoopInfo *LI,
LoopNest.push_back(*I); LoopNest.push_back(*I);
} while (!LoopNest.empty()); } while (!LoopNest.empty());
// Remap instructions to reference operands from ValueMap. // Remap instructions to reference operands from VMap.
for(SmallVector<BasicBlock *, 16>::iterator NBItr = NewBlocks.begin(), for(SmallVector<BasicBlock *, 16>::iterator NBItr = NewBlocks.begin(),
NBE = NewBlocks.end(); NBItr != NBE; ++NBItr) { NBE = NewBlocks.end(); NBItr != NBE; ++NBItr) {
BasicBlock *NB = *NBItr; BasicBlock *NB = *NBItr;
@ -135,8 +135,8 @@ Loop *llvm::CloneLoop(Loop *OrigL, LPPassManager *LPM, LoopInfo *LI,
for (unsigned index = 0, num_ops = Insn->getNumOperands(); for (unsigned index = 0, num_ops = Insn->getNumOperands();
index != num_ops; ++index) { index != num_ops; ++index) {
Value *Op = Insn->getOperand(index); Value *Op = Insn->getOperand(index);
DenseMap<const Value *, Value *>::iterator OpItr = ValueMap.find(Op); DenseMap<const Value *, Value *>::iterator OpItr = VMap.find(Op);
if (OpItr != ValueMap.end()) if (OpItr != VMap.end())
Insn->setOperand(index, OpItr->second); Insn->setOperand(index, OpItr->second);
} }
} }

32
lib/Transforms/Utils/CloneModule.cpp
View File

@ -28,12 +28,12 @@ using namespace llvm;
Module *llvm::CloneModule(const Module *M) { Module *llvm::CloneModule(const Module *M) {
// Create the value map that maps things from the old module over to the new // Create the value map that maps things from the old module over to the new
// module. // module.
DenseMap<const Value*, Value*> ValueMap; DenseMap<const Value*, Value*> VMap;
return CloneModule(M, ValueMap); return CloneModule(M, VMap);
} }
Module *llvm::CloneModule(const Module *M, Module *llvm::CloneModule(const Module *M,
DenseMap<const Value*, Value*> &ValueMap) { DenseMap<const Value*, Value*> &VMap) {
// First off, we need to create the new module... // First off, we need to create the new module...
Module *New = new Module(M->getModuleIdentifier(), M->getContext()); Module *New = new Module(M->getModuleIdentifier(), M->getContext());
New->setDataLayout(M->getDataLayout()); New->setDataLayout(M->getDataLayout());
@ -51,7 +51,7 @@ Module *llvm::CloneModule(const Module *M,
New->addLibrary(*I); New->addLibrary(*I);
// Loop over all of the global variables, making corresponding globals in the // Loop over all of the global variables, making corresponding globals in the
// new module. Here we add them to the ValueMap and to the new Module. We // new module. Here we add them to the VMap and to the new Module. We
// don't worry about attributes or initializers, they will come later. // don't worry about attributes or initializers, they will come later.
// //
for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); for (Module::const_global_iterator I = M->global_begin(), E = M->global_end();
@ -62,7 +62,7 @@ Module *llvm::CloneModule(const Module *M,
GlobalValue::ExternalLinkage, 0, GlobalValue::ExternalLinkage, 0,
I->getName()); I->getName());
GV->setAlignment(I->getAlignment()); GV->setAlignment(I->getAlignment());
ValueMap[I] = GV; VMap[I] = GV;
} }
// Loop over the functions in the module, making external functions as before // Loop over the functions in the module, making external functions as before
@ -71,13 +71,13 @@ Module *llvm::CloneModule(const Module *M,
Function::Create(cast<FunctionType>(I->getType()->getElementType()), Function::Create(cast<FunctionType>(I->getType()->getElementType()),
GlobalValue::ExternalLinkage, I->getName(), New); GlobalValue::ExternalLinkage, I->getName(), New);
NF->copyAttributesFrom(I); NF->copyAttributesFrom(I);
ValueMap[I] = NF; VMap[I] = NF;
} }
// Loop over the aliases in the module // Loop over the aliases in the module
for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end();
I != E; ++I) I != E; ++I)
ValueMap[I] = new GlobalAlias(I->getType(), GlobalAlias::ExternalLinkage, VMap[I] = new GlobalAlias(I->getType(), GlobalAlias::ExternalLinkage,
I->getName(), NULL, New); I->getName(), NULL, New);
// Now that all of the things that global variable initializer can refer to // Now that all of the things that global variable initializer can refer to
@ -86,10 +86,10 @@ Module *llvm::CloneModule(const Module *M,
// //
for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); for (Module::const_global_iterator I = M->global_begin(), E = M->global_end();
I != E; ++I) { I != E; ++I) {
GlobalVariable *GV = cast<GlobalVariable>(ValueMap[I]); GlobalVariable *GV = cast<GlobalVariable>(VMap[I]);
if (I->hasInitializer()) if (I->hasInitializer())
GV->setInitializer(cast<Constant>(MapValue(I->getInitializer(), GV->setInitializer(cast<Constant>(MapValue(I->getInitializer(),
ValueMap))); VMap)));
GV->setLinkage(I->getLinkage()); GV->setLinkage(I->getLinkage());
GV->setThreadLocal(I->isThreadLocal()); GV->setThreadLocal(I->isThreadLocal());
GV->setConstant(I->isConstant()); GV->setConstant(I->isConstant());
@ -98,17 +98,17 @@ Module *llvm::CloneModule(const Module *M,
// Similarly, copy over function bodies now... // Similarly, copy over function bodies now...
// //
for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) { for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) {
Function *F = cast<Function>(ValueMap[I]); Function *F = cast<Function>(VMap[I]);
if (!I->isDeclaration()) { if (!I->isDeclaration()) {
Function::arg_iterator DestI = F->arg_begin(); Function::arg_iterator DestI = F->arg_begin();
for (Function::const_arg_iterator J = I->arg_begin(); J != I->arg_end(); for (Function::const_arg_iterator J = I->arg_begin(); J != I->arg_end();
++J) { ++J) {
DestI->setName(J->getName()); DestI->setName(J->getName());
ValueMap[J] = DestI++; VMap[J] = DestI++;
} }
SmallVector<ReturnInst*, 8> Returns; // Ignore returns cloned. SmallVector<ReturnInst*, 8> Returns; // Ignore returns cloned.
CloneFunctionInto(F, I, ValueMap, Returns); CloneFunctionInto(F, I, VMap, Returns);
} }
F->setLinkage(I->getLinkage()); F->setLinkage(I->getLinkage());
@ -117,10 +117,10 @@ Module *llvm::CloneModule(const Module *M,
// And aliases // And aliases
for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end();
I != E; ++I) { I != E; ++I) {
GlobalAlias *GA = cast<GlobalAlias>(ValueMap[I]); GlobalAlias *GA = cast<GlobalAlias>(VMap[I]);
GA->setLinkage(I->getLinkage()); GA->setLinkage(I->getLinkage());
if (const Constant* C = I->getAliasee()) if (const Constant* C = I->getAliasee())
GA->setAliasee(cast<Constant>(MapValue(C, ValueMap))); GA->setAliasee(cast<Constant>(MapValue(C, VMap)));
} }
// And named metadata.... // And named metadata....
@ -129,7 +129,7 @@ Module *llvm::CloneModule(const Module *M,
const NamedMDNode &NMD = *I; const NamedMDNode &NMD = *I;
SmallVector<MDNode*, 4> MDs; SmallVector<MDNode*, 4> MDs;
for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i) for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i)
MDs.push_back(cast<MDNode>(MapValue(NMD.getOperand(i), ValueMap))); MDs.push_back(cast<MDNode>(MapValue(NMD.getOperand(i), VMap)));
NamedMDNode::Create(New->getContext(), NMD.getName(), NamedMDNode::Create(New->getContext(), NMD.getName(),
MDs.data(), MDs.size(), New); MDs.data(), MDs.size(), New);
} }
@ -144,7 +144,7 @@ Module *llvm::CloneModule(const Module *M,
BI->getAllMetadata(MDs); BI->getAllMetadata(MDs);
for (SmallVector<std::pair<unsigned, MDNode *>, 4>::iterator for (SmallVector<std::pair<unsigned, MDNode *>, 4>::iterator
MDI = MDs.begin(), MDE = MDs.end(); MDI != MDE; ++MDI) { MDI = MDs.begin(), MDE = MDs.end(); MDI != MDE; ++MDI) {
Value *MappedValue = MapValue(MDI->second, ValueMap); Value *MappedValue = MapValue(MDI->second, VMap);
if (MDI->second != MappedValue && MappedValue) if (MDI->second != MappedValue && MappedValue)
BI->setMetadata(MDI->first, cast<MDNode>(MappedValue)); BI->setMetadata(MDI->first, cast<MDNode>(MappedValue));
} }

16
lib/Transforms/Utils/InlineFunction.cpp
View File

@ -169,7 +169,7 @@ static void HandleInlinedInvoke(InvokeInst *II, BasicBlock *FirstNewBlock,
/// some edges of the callgraph may remain. /// some edges of the callgraph may remain.
static void UpdateCallGraphAfterInlining(CallSite CS, static void UpdateCallGraphAfterInlining(CallSite CS,
Function::iterator FirstNewBlock, Function::iterator FirstNewBlock,
DenseMap<const Value*, Value*> &ValueMap, DenseMap<const Value*, Value*> &VMap,
InlineFunctionInfo &IFI) { InlineFunctionInfo &IFI) {
CallGraph &CG = *IFI.CG; CallGraph &CG = *IFI.CG;
const Function *Caller = CS.getInstruction()->getParent()->getParent(); const Function *Caller = CS.getInstruction()->getParent()->getParent();
@ -192,9 +192,9 @@ static void UpdateCallGraphAfterInlining(CallSite CS,
for (; I != E; ++I) { for (; I != E; ++I) {
const Value *OrigCall = I->first; const Value *OrigCall = I->first;
DenseMap<const Value*, Value*>::iterator VMI = ValueMap.find(OrigCall); DenseMap<const Value*, Value*>::iterator VMI = VMap.find(OrigCall);
// Only copy the edge if the call was inlined! // Only copy the edge if the call was inlined!
if (VMI == ValueMap.end() || VMI->second == 0) if (VMI == VMap.end() || VMI->second == 0)
continue; continue;
// If the call was inlined, but then constant folded, there is no edge to // If the call was inlined, but then constant folded, there is no edge to
@ -285,8 +285,8 @@ bool llvm::InlineFunction(CallSite CS, InlineFunctionInfo &IFI) {
ClonedCodeInfo InlinedFunctionInfo; ClonedCodeInfo InlinedFunctionInfo;
Function::iterator FirstNewBlock; Function::iterator FirstNewBlock;
{ // Scope to destroy ValueMap after cloning. { // Scope to destroy VMap after cloning.
DenseMap<const Value*, Value*> ValueMap; DenseMap<const Value*, Value*> VMap;
assert(CalledFunc->arg_size() == CS.arg_size() && assert(CalledFunc->arg_size() == CS.arg_size() &&
"No varargs calls can be inlined!"); "No varargs calls can be inlined!");
@ -357,14 +357,14 @@ bool llvm::InlineFunction(CallSite CS, InlineFunctionInfo &IFI) {
MustClearTailCallFlags = true; MustClearTailCallFlags = true;
} }
ValueMap[I] = ActualArg; VMap[I] = ActualArg;
} }
// We want the inliner to prune the code as it copies. We would LOVE to // We want the inliner to prune the code as it copies. We would LOVE to
// have no dead or constant instructions leftover after inlining occurs // have no dead or constant instructions leftover after inlining occurs
// (which can happen, e.g., because an argument was constant), but we'll be // (which can happen, e.g., because an argument was constant), but we'll be
// happy with whatever the cloner can do. // happy with whatever the cloner can do.
CloneAndPruneFunctionInto(Caller, CalledFunc, ValueMap, Returns, ".i", CloneAndPruneFunctionInto(Caller, CalledFunc, VMap, Returns, ".i",
&InlinedFunctionInfo, IFI.TD, TheCall); &InlinedFunctionInfo, IFI.TD, TheCall);
// Remember the first block that is newly cloned over. // Remember the first block that is newly cloned over.
@ -372,7 +372,7 @@ bool llvm::InlineFunction(CallSite CS, InlineFunctionInfo &IFI) {
// Update the callgraph if requested. // Update the callgraph if requested.
if (IFI.CG) if (IFI.CG)
UpdateCallGraphAfterInlining(CS, FirstNewBlock, ValueMap, IFI); UpdateCallGraphAfterInlining(CS, FirstNewBlock, VMap, IFI);
} }
// If there are any alloca instructions in the block that used to be the entry // If there are any alloca instructions in the block that used to be the entry

18
lib/Transforms/Utils/LoopUnroll.cpp
View File

@ -37,13 +37,13 @@ STATISTIC(NumCompletelyUnrolled, "Number of loops completely unrolled");
STATISTIC(NumUnrolled, "Number of loops unrolled (completely or otherwise)"); STATISTIC(NumUnrolled, "Number of loops unrolled (completely or otherwise)");
/// RemapInstruction - Convert the instruction operands from referencing the /// RemapInstruction - Convert the instruction operands from referencing the
/// current values into those specified by ValueMap. /// current values into those specified by VMap.
static inline void RemapInstruction(Instruction *I, static inline void RemapInstruction(Instruction *I,
DenseMap<const Value *, Value*> &ValueMap) { DenseMap<const Value *, Value*> &VMap) {
for (unsigned op = 0, E = I->getNumOperands(); op != E; ++op) { for (unsigned op = 0, E = I->getNumOperands(); op != E; ++op) {
Value *Op = I->getOperand(op); Value *Op = I->getOperand(op);
DenseMap<const Value *, Value*>::iterator It = ValueMap.find(Op); DenseMap<const Value *, Value*>::iterator It = VMap.find(Op);
if (It != ValueMap.end()) if (It != VMap.end())
I->setOperand(op, It->second); I->setOperand(op, It->second);
} }
} }
@ -205,26 +205,26 @@ bool llvm::UnrollLoop(Loop *L, unsigned Count, LoopInfo* LI, LPPassManager* LPM)
for (std::vector<BasicBlock*>::iterator BB = LoopBlocks.begin(), for (std::vector<BasicBlock*>::iterator BB = LoopBlocks.begin(),
E = LoopBlocks.end(); BB != E; ++BB) { E = LoopBlocks.end(); BB != E; ++BB) {
ValueToValueMapTy ValueMap; ValueToValueMapTy VMap;
BasicBlock *New = CloneBasicBlock(*BB, ValueMap, "." + Twine(It)); BasicBlock *New = CloneBasicBlock(*BB, VMap, "." + Twine(It));
Header->getParent()->getBasicBlockList().push_back(New); Header->getParent()->getBasicBlockList().push_back(New);
// Loop over all of the PHI nodes in the block, changing them to use the // Loop over all of the PHI nodes in the block, changing them to use the
// incoming values from the previous block. // incoming values from the previous block.
if (*BB == Header) if (*BB == Header)
for (unsigned i = 0, e = OrigPHINode.size(); i != e; ++i) { for (unsigned i = 0, e = OrigPHINode.size(); i != e; ++i) {
PHINode *NewPHI = cast<PHINode>(ValueMap[OrigPHINode[i]]); PHINode *NewPHI = cast<PHINode>(VMap[OrigPHINode[i]]);
Value *InVal = NewPHI->getIncomingValueForBlock(LatchBlock); Value *InVal = NewPHI->getIncomingValueForBlock(LatchBlock);
if (Instruction *InValI = dyn_cast<Instruction>(InVal)) if (Instruction *InValI = dyn_cast<Instruction>(InVal))
if (It > 1 && L->contains(InValI)) if (It > 1 && L->contains(InValI))
InVal = LastValueMap[InValI]; InVal = LastValueMap[InValI];
ValueMap[OrigPHINode[i]] = InVal; VMap[OrigPHINode[i]] = InVal;
New->getInstList().erase(NewPHI); New->getInstList().erase(NewPHI);
} }
// Update our running map of newest clones // Update our running map of newest clones
LastValueMap[*BB] = New; LastValueMap[*BB] = New;
for (ValueToValueMapTy::iterator VI = ValueMap.begin(), VE = ValueMap.end(); for (ValueToValueMapTy::iterator VI = VMap.begin(), VE = VMap.end();
VI != VE; ++VI) VI != VE; ++VI)
LastValueMap[VI->first] = VI->second; LastValueMap[VI->first] = VI->second;

8
lib/Transforms/Utils/ValueMapper.cpp
View File

@ -28,7 +28,7 @@ Value *llvm::MapValue(const Value *V, ValueToValueMapTy &VM) {
// DenseMap. This includes any recursive calls to MapValue. // DenseMap. This includes any recursive calls to MapValue.
// Global values and non-function-local metadata do not need to be seeded into // Global values and non-function-local metadata do not need to be seeded into
// the ValueMap if they are using the identity mapping. // the VM if they are using the identity mapping.
if (isa<GlobalValue>(V) || isa<InlineAsm>(V) || isa<MDString>(V) || if (isa<GlobalValue>(V) || isa<InlineAsm>(V) || isa<MDString>(V) ||
(isa<MDNode>(V) && !cast<MDNode>(V)->isFunctionLocal())) (isa<MDNode>(V) && !cast<MDNode>(V)->isFunctionLocal()))
return VMSlot = const_cast<Value*>(V); return VMSlot = const_cast<Value*>(V);
@ -125,11 +125,11 @@ Value *llvm::MapValue(const Value *V, ValueToValueMapTy &VM) {
} }
/// RemapInstruction - Convert the instruction operands from referencing the /// RemapInstruction - Convert the instruction operands from referencing the
/// current values into those specified by ValueMap. /// current values into those specified by VMap.
/// ///
void llvm::RemapInstruction(Instruction *I, ValueToValueMapTy &ValueMap) { void llvm::RemapInstruction(Instruction *I, ValueToValueMapTy &VMap) {
for (User::op_iterator op = I->op_begin(), E = I->op_end(); op != E; ++op) { for (User::op_iterator op = I->op_begin(), E = I->op_end(); op != E; ++op) {
Value *V = MapValue(*op, ValueMap); Value *V = MapValue(*op, VMap);
assert(V && "Referenced value not in value map!"); assert(V && "Referenced value not in value map!");
*op = V; *op = V;
} }