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

Simplify this pass by using a depth-first iterator to ensure that all

Browse Source 
operands are visited before the instructions themselves.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@122647 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan Sands 2010-12-31 17:49:05 +00:00
parent fea0b8b666
commit 8a3d29cf10
1 changed files with 20 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -18,13 +18,13 @@
#include "llvm/Function.h"
#include "llvm/Pass.h"
#include "llvm/Type.h"
#include "llvm/ADT/DepthFirstIterator.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Analysis/Dominators.h"
#include "llvm/Analysis/InstructionSimplify.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Transforms/Utils/Local.h"
#include <queue>
using namespace llvm;
STATISTIC(NumSimplified, "Number of redundant instructions removed");
@ -42,49 +42,30 @@ namespace {
/// runOnFunction - Remove instructions that simplify.
bool runOnFunction(Function &F) {
const TargetData *TD = getAnalysisIfAvailable<TargetData>();
const DominatorTree *DT = getAnalysisIfAvailable<DominatorTree>();
const TargetData *TD = getAnalysisIfAvailable<TargetData>();
bool Changed = false;
bool LocalChanged;
// Add all interesting instructions to the worklist. These are processed
// 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 (BasicBlock::iterator BI = BB->begin(), BE = BB->end(); BI != BE;) {
Instruction *I = BI++;
// Zap any dead instructions.
if (isInstructionTriviallyDead(I)) {
I->eraseFromParent();
Changed = true;
continue;
do {
LocalChanged = false;
for (df_iterator<BasicBlock*> DI = df_begin(&F.getEntryBlock()),
DE = df_end(&F.getEntryBlock()); DI != DE; ++DI)
for (BasicBlock::iterator BI = DI->begin(), BE = DI->end(); BI != BE;) {
Instruction *I = BI++;
// Don't bother simplifying unused instructions.
if (!I->use_empty())
if (Value *V = SimplifyInstruction(I, TD, DT)) {
I->replaceAllUsesWith(V);
LocalChanged = true;
++NumSimplified;
}
LocalChanged |= RecursivelyDeleteTriviallyDeadInstructions(I);
}
// Add all others to the worklist.
Worklist.push(I);
}
// Simplify everything in the worklist until the cows come home.
while (!Worklist.empty()) {
Instruction *I = Worklist.front();
Worklist.pop();
// Don't bother simplifying unused instructions.
if (I->use_empty()) continue;
Value *V = SimplifyInstruction(I, TD, DT);
if (!V) continue;
// This instruction simplifies! Replace it with its simplification and
// add all uses to the worklist, since they may now simplify.
++NumSimplified;
I->replaceAllUsesWith(V);
for (Value::use_iterator UI = I->use_begin(), UE = I->use_end();
UI != UE; ++UI)
Worklist.push(cast<Instruction>(*UI));
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;)
Changed |= RecursivelyDeleteTriviallyDeadInstructions(BI++);
Changed |= LocalChanged;
} while (LocalChanged);
return Changed;
}