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

Visit instructions deterministically. Use a FIFO so as to approximately

Browse Source 
visit instructions before their uses, since InstructionSimplify does a
better job in that case.  All this prompted by Frits van Bommel.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@122343 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan Sands
2010-12-21 17:08:55 +00:00
parent 2965e69e04
commit 1cd0f4637b
1 changed files with 21 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -24,6 +24,7 @@
#include "llvm/Target/TargetData.h" #include "llvm/Target/TargetData.h"
#include "llvm/Transforms/Scalar.h" #include "llvm/Transforms/Scalar.h"
#include "llvm/Transforms/Utils/Local.h" #include "llvm/Transforms/Utils/Local.h"
#include <queue>
using namespace llvm; using namespace llvm;
STATISTIC(NumSimplified, "Number of redundant instructions removed"); STATISTIC(NumSimplified, "Number of redundant instructions removed");
@ -45,8 +46,9 @@ namespace {
const DominatorTree *DT = getAnalysisIfAvailable<DominatorTree>(); const DominatorTree *DT = getAnalysisIfAvailable<DominatorTree>();
bool Changed = false; bool Changed = false;
// Add all interesting instructions to the worklist. // Add all interesting instructions to the worklist. These are processed
std::set<Instruction*> Worklist; // in FIFO order, so instructions are usually visited before their uses.
std::queue<Instruction*> Worklist;
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
for (BasicBlock::iterator BI = BB->begin(), BE = BB->end(); BI != BE;) { for (BasicBlock::iterator BI = BB->begin(), BE = BB->end(); BI != BE;) {
Instruction *I = BI++; Instruction *I = BI++;
@ -57,30 +59,38 @@ namespace {
continue; continue;
} }
// Add all others to the worklist. // Add all others to the worklist.
Worklist.insert(I); Worklist.push(I);
} }
// Simplify everything in the worklist until the cows come home. // Simplify everything in the worklist until the cows come home.
while (!Worklist.empty()) { while (!Worklist.empty()) {
Instruction *I = *Worklist.begin(); Instruction *I = Worklist.front();
Worklist.erase(Worklist.begin()); Worklist.pop();
// Don't bother simplifying unused instructions.
if (I->use_empty()) continue;
Value *V = SimplifyInstruction(I, TD, DT); Value *V = SimplifyInstruction(I, TD, DT);
if (!V) continue; if (!V) continue;
// This instruction simplifies! Replace it with its simplification and // This instruction simplifies! Replace it with its simplification and
// add all uses to the worklist, since they may now simplify. // add all uses to the worklist, since they may now simplify.
++NumSimplified;
I->replaceAllUsesWith(V); I->replaceAllUsesWith(V);
for (Value::use_iterator UI = I->use_begin(), UE = I->use_end(); for (Value::use_iterator UI = I->use_begin(), UE = I->use_end();
UI != UE; ++UI) UI != UE; ++UI)
// In unreachable code an instruction can use itself, in which case Worklist.push(cast<Instruction>(*UI));
// don't add it to the worklist since we are about to erase it.
if (*UI != I) Worklist.insert(cast<Instruction>(*UI));
if (isInstructionTriviallyDead(I))
I->eraseFromParent();
++NumSimplified;
Changed = true; Changed = true;
} }
// Finally, run over the function zapping any dead instructions.
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
for (BasicBlock::iterator BI = BB->begin(), BE = BB->end(); BI != BE;) {
Instruction *I = BI++;
if (isInstructionTriviallyDead(I)) {
I->eraseFromParent();
Changed = true;
}
}
return Changed; return Changed;
} }
}; };