[llvm-commits] [llvm] r85818 - in /llvm/trunk: include/llvm/Support/StandardPasses.h lib/Transforms/Scalar/SCCP.cpp
Chris Lattner
sabre at nondot.org
Mon Nov 2 11:31:11 PST 2009
Author: lattner
Date: Mon Nov 2 13:31:10 2009
New Revision: 85818
URL: http://llvm.org/viewvc/llvm-project?rev=85818&view=rev
Log:
revert r8579[56], which are causing unhappiness in buildbot land.
Modified:
llvm/trunk/include/llvm/Support/StandardPasses.h
llvm/trunk/lib/Transforms/Scalar/SCCP.cpp
Modified: llvm/trunk/include/llvm/Support/StandardPasses.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/StandardPasses.h?rev=85818&r1=85817&r2=85818&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Support/StandardPasses.h (original)
+++ llvm/trunk/include/llvm/Support/StandardPasses.h Mon Nov 2 13:31:10 2009
@@ -99,6 +99,7 @@
if (UnitAtATime) {
PM->add(createGlobalOptimizerPass()); // Optimize out global vars
+ PM->add(createIPConstantPropagationPass()); // IP CP
PM->add(createIPSCCPPass()); // IP SCCP
PM->add(createDeadArgEliminationPass()); // Dead argument elimination
}
Modified: llvm/trunk/lib/Transforms/Scalar/SCCP.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/SCCP.cpp?rev=85818&r1=85817&r2=85818&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/SCCP.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/SCCP.cpp Mon Nov 2 13:31:10 2009
@@ -25,6 +25,7 @@
#include "llvm/Instructions.h"
#include "llvm/Pass.h"
#include "llvm/Analysis/ConstantFolding.h"
+#include "llvm/Analysis/MemoryBuiltins.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/Target/TargetData.h"
@@ -226,6 +227,7 @@
/// and out of the specified function (which cannot have its address taken),
/// this method must be called.
void AddTrackedFunction(Function *F) {
+ assert(F->hasLocalLinkage() && "Can only track internal functions!");
// Add an entry, F -> undef.
if (const StructType *STy = dyn_cast<StructType>(F->getReturnType())) {
for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i)
@@ -378,9 +380,11 @@
// instruction that was just changed state somehow. Based on this
// information, we need to update the specified user of this instruction.
//
- void OperandChangedState(Instruction *I) {
- if (BBExecutable.count(I->getParent())) // Inst is executable?
- visit(*I);
+ void OperandChangedState(User *U) {
+ // Only instructions use other variable values!
+ Instruction &I = cast<Instruction>(*U);
+ if (BBExecutable.count(I.getParent())) // Inst is executable?
+ visit(I);
}
/// RemoveFromOverdefinedPHIs - If I has any entries in the
@@ -424,6 +428,8 @@
void visitLoadInst (LoadInst &I);
void visitGetElementPtrInst(GetElementPtrInst &I);
void visitCallInst (CallInst &I) {
+ if (isFreeCall(&I))
+ return;
visitCallSite(CallSite::get(&I));
}
void visitInvokeInst (InvokeInst &II) {
@@ -650,19 +656,19 @@
markConstant(&PN, OperandVal); // Acquire operand value
}
-
-
-
void SCCPSolver::visitReturnInst(ReturnInst &I) {
if (I.getNumOperands() == 0) return; // ret void
Function *F = I.getParent()->getParent();
-
// If we are tracking the return value of this function, merge it in.
+ if (!F->hasLocalLinkage())
+ return;
+
if (!TrackedRetVals.empty()) {
DenseMap<Function*, LatticeVal>::iterator TFRVI =
TrackedRetVals.find(F);
- if (TFRVI != TrackedRetVals.end()) {
+ if (TFRVI != TrackedRetVals.end() &&
+ !TFRVI->second.isOverdefined()) {
mergeInValue(TFRVI->second, F, getValueState(I.getOperand(0)));
return;
}
@@ -1158,14 +1164,14 @@
// The common case is that we aren't tracking the callee, either because we
// are not doing interprocedural analysis or the callee is indirect, or is
// external. Handle these cases first.
- if (F == 0 || F->isDeclaration()) {
+ if (F == 0 || !F->hasLocalLinkage()) {
CallOverdefined:
// Void return and not tracking callee, just bail.
if (I->getType()->isVoidTy()) return;
// Otherwise, if we have a single return value case, and if the function is
// a declaration, maybe we can constant fold it.
- if (F && F->isDeclaration() && !isa<StructType>(I->getType()) &&
+ if (!isa<StructType>(I->getType()) && F && F->isDeclaration() &&
canConstantFoldCallTo(F)) {
SmallVector<Constant*, 8> Operands;
@@ -1229,7 +1235,7 @@
// common path above.
goto CallOverdefined;
}
-
+
// Finally, if this is the first call to the function hit, mark its entry
// block executable.
MarkBlockExecutable(F->begin());
@@ -1238,8 +1244,6 @@
CallSite::arg_iterator CAI = CS.arg_begin();
for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end();
AI != E; ++AI, ++CAI) {
- // If this argument is byval, and if the function is not readonly, there
- // will be an implicit copy formed of the input aggregate.
if (AI->hasByValAttr() && !F->onlyReadsMemory()) {
markOverdefined(AI);
continue;
@@ -1269,8 +1273,7 @@
//
for (Value::use_iterator UI = I->use_begin(), E = I->use_end();
UI != E; ++UI)
- if (Instruction *I = dyn_cast<Instruction>(*UI))
- OperandChangedState(I);
+ OperandChangedState(*UI);
}
// Process the instruction work list.
@@ -1289,8 +1292,7 @@
if (!getValueState(I).isOverdefined())
for (Value::use_iterator UI = I->use_begin(), E = I->use_end();
UI != E; ++UI)
- if (Instruction *I = dyn_cast<Instruction>(*UI))
- OperandChangedState(I);
+ OperandChangedState(*UI);
}
// Process the basic block work list.
@@ -1648,25 +1650,14 @@
if (F->isDeclaration())
continue;
- // If this is a strong or ODR definition of this function, then we can
- // propagate information about its result into callsites of it.
- if (!F->mayBeOverridden() &&
- !isa<StructType>(F->getReturnType()))
+ if (!F->hasLocalLinkage() || AddressIsTaken(F)) {
+ Solver.MarkBlockExecutable(F->begin());
+ for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end();
+ AI != E; ++AI)
+ Solver.markOverdefined(AI);
+ } else {
Solver.AddTrackedFunction(F);
-
- // If this function only has direct calls that we can see, we can track its
- // arguments and return value aggressively, and can assume it is not called
- // unless we see evidence to the contrary.
- if (F->hasLocalLinkage() && !AddressIsTaken(F))
- continue;
-
- // Assume the function is called.
- Solver.MarkBlockExecutable(F->begin());
-
- // Assume nothing about the incoming arguments.
- for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end();
- AI != E; ++AI)
- Solver.markOverdefined(AI);
+ }
}
// Loop over global variables. We inform the solver about any internal global
@@ -1814,21 +1805,16 @@
// TODO: Process multiple value ret instructions also.
const DenseMap<Function*, LatticeVal> &RV = Solver.getTrackedRetVals();
for (DenseMap<Function*, LatticeVal>::const_iterator I = RV.begin(),
- E = RV.end(); I != E; ++I) {
- Function *F = I->first;
- if (I->second.isOverdefined() || F->getReturnType()->isVoidTy())
- continue;
-
- // We can only do this if we know that nothing else can call the function.
- if (!F->hasLocalLinkage() || AddressIsTaken(F))
- continue;
-
- for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
- if (ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator()))
- if (!isa<UndefValue>(RI->getOperand(0)))
- RI->setOperand(0, UndefValue::get(F->getReturnType()));
- }
-
+ E = RV.end(); I != E; ++I)
+ if (!I->second.isOverdefined() &&
+ !I->first->getReturnType()->isVoidTy()) {
+ Function *F = I->first;
+ for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
+ if (ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator()))
+ if (!isa<UndefValue>(RI->getOperand(0)))
+ RI->setOperand(0, UndefValue::get(F->getReturnType()));
+ }
+
// If we infered constant or undef values for globals variables, we can delete
// the global and any stores that remain to it.
const DenseMap<GlobalVariable*, LatticeVal> &TG = Solver.getTrackedGlobals();
More information about the llvm-commits
mailing list