From 3774c91854bcbfddb8c1b01b41841984d2c7ed32 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Mon, 2 Nov 2009 19:31:10 +0000 Subject: [PATCH] revert r8579[56], which are causing unhappiness in buildbot land. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@85818 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Support/StandardPasses.h | 1 + lib/Transforms/Scalar/SCCP.cpp | 86 +++++++++++---------------- 2 files changed, 37 insertions(+), 50 deletions(-) diff --git a/include/llvm/Support/StandardPasses.h b/include/llvm/Support/StandardPasses.h index 843f2ed598d..86065a07359 100644 --- a/include/llvm/Support/StandardPasses.h +++ b/include/llvm/Support/StandardPasses.h @@ -99,6 +99,7 @@ namespace llvm { 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 } diff --git a/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp index 42791d660d6..c11380abf5e 100644 --- a/lib/Transforms/Scalar/SCCP.cpp +++ b/lib/Transforms/Scalar/SCCP.cpp @@ -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 @@ public: /// 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(F->getReturnType())) { for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) @@ -378,9 +380,11 @@ private: // 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(*U); + if (BBExecutable.count(I.getParent())) // Inst is executable? + visit(I); } /// RemoveFromOverdefinedPHIs - If I has any entries in the @@ -424,6 +428,8 @@ private: 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 @@ void SCCPSolver::visitPHINode(PHINode &PN) { 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::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 @@ void SCCPSolver::visitCallSite(CallSite CS) { // 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(I->getType()) && + if (!isa(I->getType()) && F && F->isDeclaration() && canConstantFoldCallTo(F)) { SmallVector Operands; @@ -1229,7 +1235,7 @@ CallOverdefined: // 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 @@ CallOverdefined: 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 @@ void SCCPSolver::Solve() { // for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E; ++UI) - if (Instruction *I = dyn_cast(*UI)) - OperandChangedState(I); + OperandChangedState(*UI); } // Process the instruction work list. @@ -1289,8 +1292,7 @@ void SCCPSolver::Solve() { if (!getValueState(I).isOverdefined()) for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E; ++UI) - if (Instruction *I = dyn_cast(*UI)) - OperandChangedState(I); + OperandChangedState(*UI); } // Process the basic block work list. @@ -1648,25 +1650,14 @@ bool IPSCCP::runOnModule(Module &M) { 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(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 @@ bool IPSCCP::runOnModule(Module &M) { // TODO: Process multiple value ret instructions also. const DenseMap &RV = Solver.getTrackedRetVals(); for (DenseMap::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(BB->getTerminator())) - if (!isa(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(BB->getTerminator())) + if (!isa(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 &TG = Solver.getTrackedGlobals();