6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-09-30 04:56:49 +00:00
Code Issues Projects Releases Wiki Activity

remove doConstantPropagation and dceInstruction, they are just

Browse Source 
wrappers around the interesting code and use an obscure iterator
abstraction that dates back many many years.

Move EraseDeadInstructions to Transforms/Utils and name it
RecursivelyDeleteTriviallyDeadInstructions.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@60191 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2008-11-27 22:57:53 +00:00
parent 15678533f3
commit 3481f24c06
3 changed files with 34 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
include/llvm/Transforms/Utils/Local.h
View File

@ -26,14 +26,9 @@ class ConstantExpr;
class TargetData;
//===----------------------------------------------------------------------===//
// Local constant propagation...
// Local constant propagation.
//
/// doConstantPropagation - Constant prop a specific instruction. Returns true
/// and potentially moves the iterator if constant propagation was performed.
///
bool doConstantPropagation(BasicBlock::iterator &I, const TargetData *TD = 0);
/// ConstantFoldTerminator - If a terminator instruction is predicated on a
/// constant value, convert it into an unconditional branch to the constant
/// destination. This is a nontrivial operation because the successors of this
@ -42,7 +37,7 @@ bool doConstantPropagation(BasicBlock::iterator &I, const TargetData *TD = 0);
bool ConstantFoldTerminator(BasicBlock *BB);
//===----------------------------------------------------------------------===//
// Local dead code elimination...
// Local dead code elimination.
//
/// isInstructionTriviallyDead - Return true if the result produced by the
@ -50,14 +45,12 @@ bool ConstantFoldTerminator(BasicBlock *BB);
///
bool isInstructionTriviallyDead(Instruction *I);
/// dceInstruction - Inspect the instruction at *BBI and figure out if it
/// isTriviallyDead. If so, remove the instruction and update the iterator to
/// point to the instruction that immediately succeeded the original
/// instruction.
///
bool dceInstruction(BasicBlock::iterator &BBI);
/// RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a
/// trivially dead instruction, delete it. If that makes any of its operands
/// trivially dead, delete them too, recursively.
void RecursivelyDeleteTriviallyDeadInstructions(Value *V);
//===----------------------------------------------------------------------===//
// Control Flow Graph Restructuring...
//

22
lib/Transforms/Scalar/CodeGenPrepare.cpp
View File

@ -454,26 +454,6 @@ static bool OptimizeCmpExpression(CmpInst *CI) {
return MadeChange;
}
/// EraseDeadInstructions - Erase any dead instructions, recursively.
static void EraseDeadInstructions(Value *V) {
Instruction *I = dyn_cast<Instruction>(V);
if (!I || !I->use_empty()) return;
SmallPtrSet<Instruction*, 16> Insts;
Insts.insert(I);
while (!Insts.empty()) {
I = *Insts.begin();
Insts.erase(I);
if (isInstructionTriviallyDead(I)) {
for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
if (Instruction *U = dyn_cast<Instruction>(I->getOperand(i)))
Insts.insert(U);
I->eraseFromParent();
}
}
}
//===----------------------------------------------------------------------===//
// Addressing Mode Analysis and Optimization
//===----------------------------------------------------------------------===//
@ -1234,7 +1214,7 @@ bool CodeGenPrepare::OptimizeMemoryInst(Instruction *MemoryInst, Value *Addr,
MemoryInst->replaceUsesOfWith(Addr, SunkAddr);
if (Addr->use_empty())
EraseDeadInstructions(Addr);
RecursivelyDeleteTriviallyDeadInstructions(Addr);
return true;
}

55
lib/Transforms/Utils/Local.cpp
View File

@ -22,30 +22,13 @@
#include "llvm/Target/TargetData.h"
#include "llvm/Support/GetElementPtrTypeIterator.h"
#include "llvm/Support/MathExtras.h"
#include <cerrno>
#include "llvm/ADT/SmallPtrSet.h"
using namespace llvm;
//===----------------------------------------------------------------------===//
// Local constant propagation...
// Local constant propagation.
//
/// doConstantPropagation - If an instruction references constants, try to fold
/// them together...
///
bool llvm::doConstantPropagation(BasicBlock::iterator &II,
const TargetData *TD) {
if (Constant *C = ConstantFoldInstruction(II, TD)) {
// Replaces all of the uses of a variable with uses of the constant.
II->replaceAllUsesWith(C);
// Remove the instruction from the basic block...
II = II->getParent()->getInstList().erase(II);
return true;
}
return false;
}
// ConstantFoldTerminator - If a terminator instruction is predicated on a
// constant value, convert it into an unconditional branch to the constant
// destination.
@ -171,6 +154,9 @@ bool llvm::ConstantFoldTerminator(BasicBlock *BB) {
// Local dead code elimination...
//
/// isInstructionTriviallyDead - Return true if the result produced by the
/// instruction is not used, and the instruction has no side effects.
///
bool llvm::isInstructionTriviallyDead(Instruction *I) {
if (!I->use_empty() || isa<TerminatorInst>(I)) return false;
@ -187,20 +173,29 @@ bool llvm::isInstructionTriviallyDead(Instruction *I) {
return false;
}
// dceInstruction - Inspect the instruction at *BBI and figure out if it's
// [trivially] dead. If so, remove the instruction and update the iterator
// to point to the instruction that immediately succeeded the original
// instruction.
//
bool llvm::dceInstruction(BasicBlock::iterator &BBI) {
// Look for un"used" definitions...
if (isInstructionTriviallyDead(BBI)) {
BBI = BBI->getParent()->getInstList().erase(BBI); // Bye bye
return true;
/// RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a
/// trivially dead instruction, delete it. If that makes any of its operands
/// trivially dead, delete them too, recursively.
void llvm::RecursivelyDeleteTriviallyDeadInstructions(Value *V) {
Instruction *I = dyn_cast<Instruction>(V);
if (!I || !I->use_empty()) return;
SmallPtrSet<Instruction*, 16> Insts;
Insts.insert(I);
while (!Insts.empty()) {
I = *Insts.begin();
Insts.erase(I);
if (isInstructionTriviallyDead(I)) {
for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
if (Instruction *U = dyn_cast<Instruction>(I->getOperand(i)))
Insts.insert(U);
I->eraseFromParent();
}
}
return false;
}
//===----------------------------------------------------------------------===//
// Control Flow Graph Restructuring...
//