mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-14 11:32:34 +00:00
Factor code out to the TransformUtils library
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2516 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
5a4337a8fc
commit
2ed01d8f0b
@ -12,91 +12,13 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Transforms/Scalar/ConstantProp.h"
|
||||
#include "llvm/Transforms/Utils/Local.h"
|
||||
#include "llvm/ConstantHandling.h"
|
||||
#include "llvm/Function.h"
|
||||
#include "llvm/BasicBlock.h"
|
||||
#include "llvm/iTerminators.h"
|
||||
#include "llvm/Instruction.h"
|
||||
#include "llvm/Pass.h"
|
||||
#include "llvm/Support/InstIterator.h"
|
||||
#include <set>
|
||||
|
||||
// FIXME: ConstantFoldInstruction & ConstantFoldTerminator should be moved out
|
||||
// to the Transformations library.
|
||||
|
||||
// ConstantFoldInstruction - If an instruction references constants, try to fold
|
||||
// them together...
|
||||
//
|
||||
bool doConstantPropogation(BasicBlock *BB, BasicBlock::iterator &II) {
|
||||
Instruction *Inst = *II;
|
||||
if (Constant *C = ConstantFoldInstruction(Inst)) {
|
||||
// Replaces all of the uses of a variable with uses of the constant.
|
||||
Inst->replaceAllUsesWith(C);
|
||||
|
||||
// Remove the instruction from the basic block...
|
||||
delete BB->getInstList().remove(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.
|
||||
//
|
||||
bool ConstantFoldTerminator(BasicBlock *BB, BasicBlock::iterator &II,
|
||||
TerminatorInst *T) {
|
||||
// Branch - See if we are conditional jumping on constant
|
||||
if (BranchInst *BI = dyn_cast<BranchInst>(T)) {
|
||||
if (BI->isUnconditional()) return false; // Can't optimize uncond branch
|
||||
BasicBlock *Dest1 = cast<BasicBlock>(BI->getOperand(0));
|
||||
BasicBlock *Dest2 = cast<BasicBlock>(BI->getOperand(1));
|
||||
|
||||
if (ConstantBool *Cond = dyn_cast<ConstantBool>(BI->getCondition())) {
|
||||
// Are we branching on constant?
|
||||
// YES. Change to unconditional branch...
|
||||
BasicBlock *Destination = Cond->getValue() ? Dest1 : Dest2;
|
||||
BasicBlock *OldDest = Cond->getValue() ? Dest2 : Dest1;
|
||||
|
||||
//cerr << "Function: " << T->getParent()->getParent()
|
||||
// << "\nRemoving branch from " << T->getParent()
|
||||
// << "\n\nTo: " << OldDest << endl;
|
||||
|
||||
// Let the basic block know that we are letting go of it. Based on this,
|
||||
// it will adjust it's PHI nodes.
|
||||
assert(BI->getParent() && "Terminator not inserted in block!");
|
||||
OldDest->removePredecessor(BI->getParent());
|
||||
|
||||
// Set the unconditional destination, and change the insn to be an
|
||||
// unconditional branch.
|
||||
BI->setUnconditionalDest(Destination);
|
||||
II = BB->end()-1; // Update instruction iterator!
|
||||
return true;
|
||||
}
|
||||
#if 0
|
||||
// FIXME: TODO: This doesn't work if the destination has PHI nodes with
|
||||
// different incoming values on each branch!
|
||||
//
|
||||
else if (Dest2 == Dest1) { // Conditional branch to same location?
|
||||
// This branch matches something like this:
|
||||
// br bool %cond, label %Dest, label %Dest
|
||||
// and changes it into: br label %Dest
|
||||
|
||||
// Let the basic block know that we are letting go of one copy of it.
|
||||
assert(BI->getParent() && "Terminator not inserted in block!");
|
||||
Dest1->removePredecessor(BI->getParent());
|
||||
|
||||
// Change a conditional branch to unconditional.
|
||||
BI->setUnconditionalDest(Dest1);
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
namespace {
|
||||
struct ConstantPropogation : public FunctionPass {
|
||||
const char *getPassName() const { return "Simple Constant Propogation"; }
|
||||
|
@ -10,31 +10,12 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Transforms/Scalar/DCE.h"
|
||||
#include "llvm/Transforms/Utils/Local.h"
|
||||
#include "llvm/Instruction.h"
|
||||
#include "llvm/Pass.h"
|
||||
#include "llvm/InstrTypes.h"
|
||||
#include "llvm/Function.h"
|
||||
#include "llvm/Support/InstIterator.h"
|
||||
#include <set>
|
||||
|
||||
static inline bool isInstDead(Instruction *I) {
|
||||
return I->use_empty() && !I->hasSideEffects() && !isa<TerminatorInst>(I);
|
||||
}
|
||||
|
||||
// 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 dceInstruction(BasicBlock::InstListType &BBIL,
|
||||
BasicBlock::iterator &BBI) {
|
||||
// Look for un"used" definitions...
|
||||
if (isInstDead(*BBI)) {
|
||||
delete BBIL.remove(BBI); // Bye bye
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// DeadInstElimination pass implementation
|
||||
//
|
||||
@ -95,7 +76,7 @@ bool DCE::runOnFunction(Function *F) {
|
||||
Instruction *I = WorkList.back();
|
||||
WorkList.pop_back();
|
||||
|
||||
if (isInstDead(I)) { // If the instruction is dead...
|
||||
if (isInstructionTriviallyDead(I)) { // If the instruction is dead...
|
||||
// Loop over all of the values that the instruction uses, if there are
|
||||
// instructions being used, add them to the worklist, because they might
|
||||
// go dead after this one is removed.
|
||||
|
Loading…
Reference in New Issue
Block a user