From 44540740aeafcae8c5d030000e7fd468f01d0da9 Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Sat, 23 Jan 2010 20:32:12 +0000 Subject: Speculatively revert r94322 to see if it fixes darwin selfhost buildbot. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@94331 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/IPO/DeadArgumentElimination.cpp | 93 +++++++------------------- 1 file changed, 23 insertions(+), 70 deletions(-) (limited to 'lib/Transforms') diff --git a/lib/Transforms/IPO/DeadArgumentElimination.cpp b/lib/Transforms/IPO/DeadArgumentElimination.cpp index d99dd7fd94..1749b1eff3 100644 --- a/lib/Transforms/IPO/DeadArgumentElimination.cpp +++ b/lib/Transforms/IPO/DeadArgumentElimination.cpp @@ -30,7 +30,6 @@ #include "llvm/Support/CallSite.h" #include "llvm/Support/Debug.h" #include "llvm/Support/raw_ostream.h" -#include "llvm/Transforms/Utils/Local.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/Statistic.h" #include "llvm/ADT/StringExtras.h" @@ -51,7 +50,7 @@ namespace { /// argument. Used so that arguments and return values can be used /// interchangably. struct RetOrArg { - RetOrArg(const Function *F, unsigned Idx, bool IsArg) : F(F), Idx(Idx), + RetOrArg(const Function* F, unsigned Idx, bool IsArg) : F(F), Idx(Idx), IsArg(IsArg) {} const Function *F; unsigned Idx; @@ -141,7 +140,6 @@ namespace { void MarkLive(const Function &F); void PropagateLiveness(const RetOrArg &RA); bool RemoveDeadStuffFromFunction(Function *F); - bool RemoveDeadParamsFromCallersOf(Function *F); bool DeleteDeadVarargs(Function &Fn); }; } @@ -282,7 +280,7 @@ bool DAE::DeleteDeadVarargs(Function &Fn) { /// for void functions and 1 for functions not returning a struct. It returns /// the number of struct elements for functions returning a struct. static unsigned NumRetVals(const Function *F) { - if (F->getReturnType()->isVoidTy()) + if (F->getReturnType() == Type::getVoidTy(F->getContext())) return 0; else if (const StructType *STy = dyn_cast(F->getReturnType())) return STy->getNumElements(); @@ -307,7 +305,7 @@ DAE::Liveness DAE::MarkIfNotLive(RetOrArg Use, UseVector &MaybeLiveUses) { /// SurveyUse - This looks at a single use of an argument or return value /// and determines if it should be alive or not. Adds this use to MaybeLiveUses -/// if it causes the used value to become MaybeLive. +/// if it causes the used value to become MaybeAlive. /// /// RetValNum is the return value number to use when this use is used in a /// return instruction. This is used in the recursion, you should always leave @@ -398,7 +396,7 @@ DAE::Liveness DAE::SurveyUses(Value *V, UseVector &MaybeLiveUses) { // any callers use the return value. This fills in the LiveValues set and Uses // map. // -// We consider arguments of overridable functions to be intrinsically alive as +// We consider arguments of non-internal functions to be intrinsically alive as // well as arguments to functions which have their "address taken". // void DAE::SurveyFunction(Function &F) { @@ -422,16 +420,9 @@ void DAE::SurveyFunction(Function &F) { return; } - if ((F.isDeclaration() || F.mayBeOverridden()) && - (!ShouldHackArguments() || F.isIntrinsic())) { + if (!F.hasLocalLinkage() && (!ShouldHackArguments() || F.isIntrinsic())) { MarkLive(F); return; - } else if (!F.hasLocalLinkage()) { - DEBUG(dbgs() << "DAE - Intrinsically live return from " << F.getName() - << "\n"); - // Mark the return values alive. - for (unsigned i = 0, e = NumRetVals(&F); i != e; ++i) - MarkLive(CreateRet(&F, i)); } DEBUG(dbgs() << "DAE - Inspecting callers for fn: " << F.getName() << "\n"); @@ -540,14 +531,14 @@ void DAE::MarkValue(const RetOrArg &RA, Liveness L, /// values (according to Uses) live as well. void DAE::MarkLive(const Function &F) { DEBUG(dbgs() << "DAE - Intrinsically live fn: " << F.getName() << "\n"); - // Mark the function as live. - LiveFunctions.insert(&F); - // Mark all arguments as live. - for (unsigned i = 0, e = F.arg_size(); i != e; ++i) - PropagateLiveness(CreateArg(&F, i)); - // Mark all return values as live. - for (unsigned i = 0, e = NumRetVals(&F); i != e; ++i) - PropagateLiveness(CreateRet(&F, i)); + // Mark the function as live. + LiveFunctions.insert(&F); + // Mark all arguments as live. + for (unsigned i = 0, e = F.arg_size(); i != e; ++i) + PropagateLiveness(CreateArg(&F, i)); + // Mark all return values as live. + for (unsigned i = 0, e = NumRetVals(&F); i != e; ++i) + PropagateLiveness(CreateRet(&F, i)); } /// MarkLive - Mark the given return value or argument as live. Additionally, @@ -612,8 +603,8 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { // -1 means unused, other numbers are the new index SmallVector NewRetIdxs(RetCount, -1); std::vector RetTypes; - if (RetTy->isVoidTy()) { - NRetTy = RetTy; + if (RetTy == Type::getVoidTy(F->getContext())) { + NRetTy = Type::getVoidTy(F->getContext()); } else { const StructType *STy = dyn_cast(RetTy); if (STy) @@ -662,7 +653,7 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { // values. Otherwise, ensure that we don't have any conflicting attributes // here. Currently, this should not be possible, but special handling might be // required when new return value attributes are added. - if (NRetTy->isVoidTy()) + if (NRetTy == Type::getVoidTy(F->getContext())) RAttrs &= ~Attribute::typeIncompatible(NRetTy); else assert((RAttrs & Attribute::typeIncompatible(NRetTy)) == 0 @@ -714,7 +705,8 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { } // Create the new function type based on the recomputed parameters. - FunctionType *NFTy = FunctionType::get(NRetTy, Params, FTy->isVarArg()); + FunctionType *NFTy = FunctionType::get(NRetTy, Params, + FTy->isVarArg()); // No change? if (NFTy == FTy) @@ -799,7 +791,7 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { // Return type not changed? Just replace users then. Call->replaceAllUsesWith(New); New->takeName(Call); - } else if (New->getType()->isVoidTy()) { + } else if (New->getType() == Type::getVoidTy(F->getContext())) { // Our return value has uses, but they will get removed later on. // Replace by null for now. Call->replaceAllUsesWith(Constant::getNullValue(Call->getType())); @@ -875,7 +867,7 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { if (ReturnInst *RI = dyn_cast(BB->getTerminator())) { Value *RetVal; - if (NFTy->getReturnType()->isVoidTy()) { + if (NFTy->getReturnType() == Type::getVoidTy(F->getContext())) { RetVal = 0; } else { assert (isa(RetTy)); @@ -916,42 +908,6 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { return true; } -bool DAE::RemoveDeadParamsFromCallersOf(Function *F) { - // Don't modify fully live functions - if (LiveFunctions.count(F)) - return false; - - // Make a list of the dead arguments. - SmallVector ArgDead; - unsigned i = 0; - for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); - I != E; ++I, ++i) { - RetOrArg Arg = CreateArg(F, i); - if (!LiveValues.count(Arg)) - ArgDead.push_back(i); - } - if (ArgDead.empty()) - return false; - - bool MadeChange = false; - for (Function::use_iterator I = F->use_begin(), E = F->use_end(); - I != E; ++I) { - CallSite CS = CallSite::get(*I); - if (CS.getInstruction() && CS.isCallee(I)) { - for (unsigned i = 0, e = ArgDead.size(); i != e; ++i) { - Value *A = CS.getArgument(ArgDead[i]); - if (!isa(A)) { - MadeChange = true; - CS.setArgument(ArgDead[i], UndefValue::get(A->getType())); - RecursivelyDeleteTriviallyDeadInstructions(A); - } - } - } - } - - return MadeChange; -} - bool DAE::runOnModule(Module &M) { bool Changed = false; @@ -975,15 +931,12 @@ bool DAE::runOnModule(Module &M) { SurveyFunction(*I); // Now, remove all dead arguments and return values from each function in - // turn. + // turn for (Module::iterator I = M.begin(), E = M.end(); I != E; ) { - // Increment now, because the function will probably get removed (ie. + // Increment now, because the function will probably get removed (ie // replaced by a new one). Function *F = I++; - if (F->hasLocalLinkage()) - Changed |= RemoveDeadStuffFromFunction(F); - else - Changed |= RemoveDeadParamsFromCallersOf(F); + Changed |= RemoveDeadStuffFromFunction(F); } return Changed; } -- cgit v1.2.3