//===-- Local.cpp - Functions to perform local transformations ------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
//===----------------------------------------------------------------------===//
//
// This family of functions perform various local transformations to the
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
#include "llvm/Instructions.h"
+#include "llvm/Intrinsics.h"
+#include "llvm/IntrinsicInst.h"
+#include "llvm/Analysis/ConstantFolding.h"
+#include "llvm/Target/TargetData.h"
+#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/Support/MathExtras.h"
+#include <cerrno>
using namespace llvm;
//===----------------------------------------------------------------------===//
/// doConstantPropagation - If an instruction references constants, try to fold
/// them together...
///
-bool llvm::doConstantPropagation(BasicBlock::iterator &II) {
- if (Constant *C = ConstantFoldInstruction(II)) {
+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;
}
-/// ConstantFoldInstruction - Attempt to constant fold the specified
-/// instruction. If successful, the constant result is returned, if not, null
-/// is returned. Note that this function can only fail when attempting to fold
-/// instructions like loads and stores, which have no constant expression form.
-///
-Constant *llvm::ConstantFoldInstruction(Instruction *I) {
- if (PHINode *PN = dyn_cast<PHINode>(I)) {
- if (PN->getNumIncomingValues() == 0)
- return Constant::getNullValue(PN->getType());
-
- Constant *Result = dyn_cast<Constant>(PN->getIncomingValue(0));
- if (Result == 0) return 0;
-
- // Handle PHI nodes specially here...
- for (unsigned i = 1, e = PN->getNumIncomingValues(); i != e; ++i)
- if (PN->getIncomingValue(i) != Result && PN->getIncomingValue(i) != PN)
- return 0; // Not all the same incoming constants...
-
- // If we reach here, all incoming values are the same constant.
- return Result;
- }
-
- Constant *Op0 = 0, *Op1 = 0;
- switch (I->getNumOperands()) {
- default:
- case 2:
- Op1 = dyn_cast<Constant>(I->getOperand(1));
- if (Op1 == 0) return 0; // Not a constant?, can't fold
- case 1:
- Op0 = dyn_cast<Constant>(I->getOperand(0));
- if (Op0 == 0) return 0; // Not a constant?, can't fold
- break;
- case 0: return 0;
- }
-
- if (isa<BinaryOperator>(I) || isa<ShiftInst>(I))
- return ConstantExpr::get(I->getOpcode(), Op0, Op1);
-
- switch (I->getOpcode()) {
- default: return 0;
- case Instruction::Cast:
- return ConstantExpr::getCast(Op0, I->getType());
- case Instruction::Select:
- if (Constant *Op2 = dyn_cast<Constant>(I->getOperand(2)))
- return ConstantExpr::getSelect(Op0, Op1, Op2);
- return 0;
- case Instruction::GetElementPtr:
- std::vector<Constant*> IdxList;
- IdxList.reserve(I->getNumOperands()-1);
- if (Op1) IdxList.push_back(Op1);
- for (unsigned i = 2, e = I->getNumOperands(); i != e; ++i)
- if (Constant *C = dyn_cast<Constant>(I->getOperand(i)))
- IdxList.push_back(C);
- else
- return 0; // Non-constant operand
- return ConstantExpr::getGetElementPtr(Op0, IdxList);
- }
-}
-
// ConstantFoldTerminator - If a terminator instruction is predicated on a
// constant value, convert it into an unconditional branch to the constant
// destination.
//
bool llvm::ConstantFoldTerminator(BasicBlock *BB) {
TerminatorInst *T = BB->getTerminator();
-
+
// 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())) {
+ if (ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition())) {
// Are we branching on constant?
// YES. Change to unconditional branch...
- BasicBlock *Destination = Cond->getValue() ? Dest1 : Dest2;
- BasicBlock *OldDest = Cond->getValue() ? Dest2 : Dest1;
+ BasicBlock *Destination = Cond->getZExtValue() ? Dest1 : Dest2;
+ BasicBlock *OldDest = Cond->getZExtValue() ? Dest2 : Dest1;
- //cerr << "Function: " << T->getParent()->getParent()
- // << "\nRemoving branch from " << T->getParent()
+ //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,
BI->setUnconditionalDest(Destination);
return true;
} else if (Dest2 == Dest1) { // Conditional branch to same location?
- // This branch matches something like this:
+ // This branch matches something like this:
// br bool %cond, label %Dest, label %Dest
// and changes it into: br label %Dest
// now.
if (TheOnlyDest) {
// Insert the new branch..
- new BranchInst(TheOnlyDest, SI);
+ BranchInst::Create(TheOnlyDest, SI);
BasicBlock *BB = SI->getParent();
// Remove entries from PHI nodes which we no longer branch to...
} else if (SI->getNumSuccessors() == 2) {
// Otherwise, we can fold this switch into a conditional branch
// instruction if it has only one non-default destination.
- Value *Cond = new SetCondInst(Instruction::SetEQ, SI->getCondition(),
- SI->getSuccessorValue(1), "cond", SI);
+ Value *Cond = new ICmpInst(ICmpInst::ICMP_EQ, SI->getCondition(),
+ SI->getSuccessorValue(1), "cond", SI);
// Insert the new branch...
- new BranchInst(SI->getSuccessor(1), SI->getSuccessor(0), Cond, SI);
+ BranchInst::Create(SI->getSuccessor(1), SI->getSuccessor(0), Cond, SI);
// Delete the old switch...
SI->getParent()->getInstList().erase(SI);
}
-
//===----------------------------------------------------------------------===//
// Local dead code elimination...
//
bool llvm::isInstructionTriviallyDead(Instruction *I) {
- return I->use_empty() && !I->mayWriteToMemory() && !isa<TerminatorInst>(I);
+ if (!I->use_empty() || isa<TerminatorInst>(I)) return false;
+
+ if (!I->mayWriteToMemory())
+ return true;
+
+ // Special case intrinsics that "may write to memory" but can be deleted when
+ // dead.
+ if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I))
+ // Safe to delete llvm.stacksave if dead.
+ if (II->getIntrinsicID() == Intrinsic::stacksave)
+ return true;
+
+ return false;
}
// dceInstruction - Inspect the instruction at *BBI and figure out if it's
}
return false;
}
-
-//===----------------------------------------------------------------------===//
-// PHI Instruction Simplification
-//
-
-/// hasConstantValue - If the specified PHI node always merges together the same
-/// value, return the value, otherwise return null.
-///
-Value *llvm::hasConstantValue(PHINode *PN) {
- // If the PHI node only has one incoming value, eliminate the PHI node...
- if (PN->getNumIncomingValues() == 1)
- return PN->getIncomingValue(0);
-
- // Otherwise if all of the incoming values are the same for the PHI, replace
- // the PHI node with the incoming value.
- //
- Value *InVal = 0;
- for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
- if (PN->getIncomingValue(i) != PN) // Not the PHI node itself...
- if (InVal && PN->getIncomingValue(i) != InVal)
- return 0; // Not the same, bail out.
- else
- InVal = PN->getIncomingValue(i);
-
- // The only case that could cause InVal to be null is if we have a PHI node
- // that only has entries for itself. In this case, there is no entry into the
- // loop, so kill the PHI.
- //
- if (InVal == 0) InVal = Constant::getNullValue(PN->getType());
-
- // All of the incoming values are the same, return the value now.
- return InVal;
-}