2001-06-06 22:29:01 +02:00
|
|
|
//===- DCE.cpp - Code to perform dead code elimination --------------------===//
|
2005-04-22 01:48:37 +02:00
|
|
|
//
|
2003-10-20 21:43:21 +02:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 21:36:04 +01:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-22 01:48:37 +02:00
|
|
|
//
|
2003-10-20 21:43:21 +02:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-06-06 22:29:01 +02:00
|
|
|
//
|
2002-05-07 06:24:11 +02:00
|
|
|
// This file implements dead inst elimination and dead code elimination.
|
2001-06-06 22:29:01 +02:00
|
|
|
//
|
2002-05-07 06:24:11 +02:00
|
|
|
// Dead Inst Elimination performs a single pass over the function removing
|
|
|
|
// instructions that are obviously dead. Dead Code Elimination is similar, but
|
|
|
|
// it rechecks instructions that were used by removed instructions to see if
|
|
|
|
// they are newly dead.
|
2001-06-06 22:29:01 +02:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2002-05-07 22:03:00 +02:00
|
|
|
#include "llvm/Transforms/Scalar.h"
|
2015-09-30 19:49:49 +02:00
|
|
|
#include "llvm/ADT/SetVector.h"
|
2012-12-03 17:50:05 +01:00
|
|
|
#include "llvm/ADT/Statistic.h"
|
2014-03-04 11:30:26 +01:00
|
|
|
#include "llvm/IR/InstIterator.h"
|
2013-01-02 12:36:10 +01:00
|
|
|
#include "llvm/IR/Instruction.h"
|
2002-02-26 22:46:54 +01:00
|
|
|
#include "llvm/Pass.h"
|
2015-01-15 03:16:27 +01:00
|
|
|
#include "llvm/Analysis/TargetLibraryInfo.h"
|
2012-12-03 17:50:05 +01:00
|
|
|
#include "llvm/Transforms/Utils/Local.h"
|
2004-01-09 07:02:20 +01:00
|
|
|
using namespace llvm;
|
2003-11-11 23:41:34 +01:00
|
|
|
|
2014-04-22 04:55:47 +02:00
|
|
|
#define DEBUG_TYPE "dce"
|
|
|
|
|
2006-12-19 22:40:18 +01:00
|
|
|
STATISTIC(DIEEliminated, "Number of insts removed by DIE pass");
|
|
|
|
STATISTIC(DCEEliminated, "Number of insts removed");
|
2002-05-10 17:38:35 +02:00
|
|
|
|
2006-12-19 22:40:18 +01:00
|
|
|
namespace {
|
2002-10-02 00:38:41 +02:00
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
// DeadInstElimination pass implementation
|
|
|
|
//
|
2009-09-02 08:11:42 +02:00
|
|
|
struct DeadInstElimination : public BasicBlockPass {
|
2007-05-06 15:37:16 +02:00
|
|
|
static char ID; // Pass identification, replacement for typeid
|
2010-10-19 19:21:58 +02:00
|
|
|
DeadInstElimination() : BasicBlockPass(ID) {
|
|
|
|
initializeDeadInstEliminationPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2014-03-05 10:10:37 +01:00
|
|
|
bool runOnBasicBlock(BasicBlock &BB) override {
|
2014-02-06 01:07:05 +01:00
|
|
|
if (skipOptnoneFunction(BB))
|
|
|
|
return false;
|
2015-01-15 11:41:28 +01:00
|
|
|
auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>();
|
|
|
|
TargetLibraryInfo *TLI = TLIP ? &TLIP->getTLI() : nullptr;
|
2002-05-07 06:24:11 +02:00
|
|
|
bool Changed = false;
|
2008-11-27 23:46:09 +01:00
|
|
|
for (BasicBlock::iterator DI = BB.begin(); DI != BB.end(); ) {
|
2015-10-13 20:26:00 +02:00
|
|
|
Instruction *Inst = &*DI++;
|
2012-08-29 17:32:21 +02:00
|
|
|
if (isInstructionTriviallyDead(Inst, TLI)) {
|
2008-11-27 23:46:09 +01:00
|
|
|
Inst->eraseFromParent();
|
2002-05-07 06:24:11 +02:00
|
|
|
Changed = true;
|
2002-05-10 17:38:35 +02:00
|
|
|
++DIEEliminated;
|
2008-11-27 23:46:09 +01:00
|
|
|
}
|
|
|
|
}
|
2002-05-07 06:24:11 +02:00
|
|
|
return Changed;
|
|
|
|
}
|
2002-04-29 16:57:45 +02:00
|
|
|
|
2014-03-05 10:10:37 +01:00
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
2002-10-21 22:00:28 +02:00
|
|
|
AU.setPreservesCFG();
|
2002-05-07 06:24:11 +02:00
|
|
|
}
|
|
|
|
};
|
2015-06-23 11:49:53 +02:00
|
|
|
}
|
2002-02-26 22:46:54 +01:00
|
|
|
|
2008-05-13 02:00:25 +02:00
|
|
|
char DeadInstElimination::ID = 0;
|
2010-07-22 00:09:45 +02:00
|
|
|
INITIALIZE_PASS(DeadInstElimination, "die",
|
2010-10-08 00:25:06 +02:00
|
|
|
"Dead Instruction Elimination", false, false)
|
2008-05-13 02:00:25 +02:00
|
|
|
|
2007-01-26 00:23:25 +01:00
|
|
|
Pass *llvm::createDeadInstEliminationPass() {
|
2002-02-26 22:46:54 +01:00
|
|
|
return new DeadInstElimination();
|
2002-01-23 06:48:24 +01:00
|
|
|
}
|
|
|
|
|
2001-06-07 18:59:26 +02:00
|
|
|
|
2002-05-07 06:24:11 +02:00
|
|
|
namespace {
|
2006-12-19 22:40:18 +01:00
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
// DeadCodeElimination pass implementation
|
|
|
|
//
|
2002-05-07 06:24:11 +02:00
|
|
|
struct DCE : public FunctionPass {
|
2007-05-06 15:37:16 +02:00
|
|
|
static char ID; // Pass identification, replacement for typeid
|
2010-10-19 19:21:58 +02:00
|
|
|
DCE() : FunctionPass(ID) {
|
|
|
|
initializeDCEPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2007-05-01 23:15:47 +02:00
|
|
|
|
2014-03-05 10:10:37 +01:00
|
|
|
bool runOnFunction(Function &F) override;
|
2001-06-28 01:41:11 +02:00
|
|
|
|
2014-03-05 10:10:37 +01:00
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
2002-10-21 22:00:28 +02:00
|
|
|
AU.setPreservesCFG();
|
2001-06-28 01:41:11 +02:00
|
|
|
}
|
2002-05-07 06:24:11 +02:00
|
|
|
};
|
2015-06-23 11:49:53 +02:00
|
|
|
}
|
2001-06-07 18:59:26 +02:00
|
|
|
|
2008-05-13 02:00:25 +02:00
|
|
|
char DCE::ID = 0;
|
2010-10-08 00:25:06 +02:00
|
|
|
INITIALIZE_PASS(DCE, "dce", "Dead Code Elimination", false, false)
|
2008-05-13 02:00:25 +02:00
|
|
|
|
2015-09-30 19:49:49 +02:00
|
|
|
static bool DCEInstruction(Instruction *I,
|
|
|
|
SmallSetVector<Instruction *, 16> &WorkList,
|
|
|
|
const TargetLibraryInfo *TLI) {
|
|
|
|
if (isInstructionTriviallyDead(I, TLI)) {
|
|
|
|
// Null out all of the instruction's operands to see if any operand becomes
|
|
|
|
// dead as we go.
|
|
|
|
for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
|
|
|
|
Value *OpV = I->getOperand(i);
|
|
|
|
I->setOperand(i, nullptr);
|
|
|
|
|
|
|
|
if (!OpV->use_empty() || I == OpV)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// If the operand is an instruction that became dead as we nulled out the
|
|
|
|
// operand, and if it is 'trivially' dead, delete it in a future loop
|
|
|
|
// iteration.
|
|
|
|
if (Instruction *OpI = dyn_cast<Instruction>(OpV))
|
|
|
|
if (isInstructionTriviallyDead(OpI, TLI))
|
|
|
|
WorkList.insert(OpI);
|
|
|
|
}
|
|
|
|
|
|
|
|
I->eraseFromParent();
|
|
|
|
++DCEEliminated;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2002-06-25 18:13:24 +02:00
|
|
|
bool DCE::runOnFunction(Function &F) {
|
2014-02-06 01:07:05 +01:00
|
|
|
if (skipOptnoneFunction(F))
|
|
|
|
return false;
|
|
|
|
|
2015-01-15 11:41:28 +01:00
|
|
|
auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>();
|
|
|
|
TargetLibraryInfo *TLI = TLIP ? &TLIP->getTLI() : nullptr;
|
2012-08-29 17:32:21 +02:00
|
|
|
|
2005-05-08 20:45:26 +02:00
|
|
|
bool MadeChange = false;
|
2015-09-30 19:49:49 +02:00
|
|
|
SmallSetVector<Instruction *, 16> WorkList;
|
|
|
|
// Iterate over the original function, only adding insts to the worklist
|
|
|
|
// if they actually need to be revisited. This avoids having to pre-init
|
|
|
|
// the worklist with the entire function's worth of instructions.
|
|
|
|
for (inst_iterator FI = inst_begin(F), FE = inst_end(F); FI != FE;) {
|
|
|
|
Instruction *I = &*FI;
|
|
|
|
++FI;
|
|
|
|
|
|
|
|
// We're visiting this instruction now, so make sure it's not in the
|
|
|
|
// worklist from an earlier visit.
|
|
|
|
if (!WorkList.count(I))
|
|
|
|
MadeChange |= DCEInstruction(I, WorkList, TLI);
|
|
|
|
}
|
|
|
|
|
2002-05-07 06:24:11 +02:00
|
|
|
while (!WorkList.empty()) {
|
2015-09-30 19:49:49 +02:00
|
|
|
Instruction *I = WorkList.pop_back_val();
|
|
|
|
MadeChange |= DCEInstruction(I, WorkList, TLI);
|
2001-07-28 19:51:49 +02:00
|
|
|
}
|
2005-05-08 20:45:26 +02:00
|
|
|
return MadeChange;
|
2002-02-26 22:46:54 +01:00
|
|
|
}
|
|
|
|
|
2004-07-27 19:43:21 +02:00
|
|
|
FunctionPass *llvm::createDeadCodeEliminationPass() {
|
2002-05-07 06:24:11 +02:00
|
|
|
return new DCE();
|
2002-02-26 22:46:54 +01:00
|
|
|
}
|
2003-11-11 23:41:34 +01:00
|
|
|
|