6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-19 18:24:00 +00:00
Code Issues Projects Releases Wiki Activity

Revamp the ValueMapper interfaces in a couple ways:

Browse Source 
1. Take a flags argument instead of a bool.  This makes
   it more clear to the reader what it is used for.
2. Add a flag that says that "remapping a value not in the
   map is ok".
3. Reimplement MapValue to share a bunch of code and be a lot
   more efficient.  For lookup failures, don't drop null values
   into the map.
4. Using the new flag a bunch of code can vaporize in LinkModules
   and LoopUnswitch, kill it.

No functionality change.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@123058 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
2011-01-08 08:15:20 +00:00
parent 6ccb365293
commit b5fa5fcecc
7 changed files with 108 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
lib/Linker/LinkModules.cpp
View File

@ -451,8 +451,7 @@ static void LinkNamedMDNodes(Module *Dest, Module *Src,
// Add Src elements into Dest node.
for (unsigned i = 0, e = SrcNMD->getNumOperands(); i != e; ++i)
DestNMD->addOperand(cast<MDNode>(MapValue(SrcNMD->getOperand(i),
ValueMap,
true)));
ValueMap)));
}
}
@ -814,9 +813,9 @@ static bool LinkGlobalInits(Module *Dest, const Module *Src,
const GlobalVariable *SGV = I;
if (SGV->hasInitializer()) { // Only process initialized GV's
// Figure out what the initializer looks like in the dest module...
// Figure out what the initializer looks like in the dest module.
Constant *SInit =
cast<Constant>(MapValue(SGV->getInitializer(), ValueMap, true));
cast<Constant>(MapValue(SGV->getInitializer(), ValueMap));
// Grab destination global variable or alias.
GlobalValue *DGV = cast<GlobalValue>(ValueMap[SGV]->stripPointerCasts());
@ -996,32 +995,10 @@ static bool LinkFunctionBody(Function *Dest, Function *Src,
// At this point, all of the instructions and values of the function are now
// copied over. The only problem is that they are still referencing values in
// the Source function as operands. Loop through all of the operands of the
// functions and patch them up to point to the local versions...
//
// This is the same as RemapInstruction, except that it avoids remapping
// instruction and basic block operands.
//
// functions and patch them up to point to the local versions.
for (Function::iterator BB = Dest->begin(), BE = Dest->end(); BB != BE; ++BB)
for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) {
// Remap operands.
for (Instruction::op_iterator OI = I->op_begin(), OE = I->op_end();
OI != OE; ++OI)
if (!isa<Instruction>(*OI) && !isa<BasicBlock>(*OI))
*OI = MapValue(*OI, ValueMap, true);
// Remap attached metadata.
SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
I->getAllMetadata(MDs);
for (SmallVectorImpl<std::pair<unsigned, MDNode *> >::iterator
MI = MDs.begin(), ME = MDs.end(); MI != ME; ++MI) {
Value *Old = MI->second;
if (!isa<Instruction>(Old) && !isa<BasicBlock>(Old)) {
Value *New = MapValue(Old, ValueMap, true);
if (New != Old)
I->setMetadata(MI->first, cast<MDNode>(New));
}
}
}
for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
RemapInstruction(I, ValueMap, RF_IgnoreMissingEntries);
// There is no need to map the arguments anymore.
for (Function::arg_iterator I = Src->arg_begin(), E = Src->arg_end();