From 7e43b3be885579c46fe6d2f8a7c57cf88fa13a25 Mon Sep 17 00:00:00 2001 From: Matthijs Kooijman Date: Fri, 20 Jun 2008 15:34:07 +0000 Subject: 80 column and trailing whitespace fixes. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@52539 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/IPO/DeadArgumentElimination.cpp | 121 +++++++++++++++---------- 1 file changed, 72 insertions(+), 49 deletions(-) (limited to 'lib/Transforms/IPO') diff --git a/lib/Transforms/IPO/DeadArgumentElimination.cpp b/lib/Transforms/IPO/DeadArgumentElimination.cpp index d7febc50c8..e742f924e9 100644 --- a/lib/Transforms/IPO/DeadArgumentElimination.cpp +++ b/lib/Transforms/IPO/DeadArgumentElimination.cpp @@ -48,11 +48,12 @@ 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), IsArg(IsArg) {} + RetOrArg(const Function* F, unsigned Idx, bool IsArg) : F(F), Idx(Idx), + IsArg(IsArg) {} const Function *F; unsigned Idx; bool IsArg; - + /// Make RetOrArg comparable, so we can put it into a map bool operator<(const RetOrArg &O) const { if (F != O.F) @@ -68,7 +69,7 @@ namespace { return F == O.F && Idx == O.Idx && IsArg == O.IsArg; } }; - + /// Liveness enum - During our initial pass over the program, we determine /// that things are either definately alive, definately dead, or in need of /// interprocedural analysis (MaybeLive). @@ -76,13 +77,17 @@ namespace { enum Liveness { Live, MaybeLive, Dead }; /// Convenience wrapper - RetOrArg CreateRet(const Function *F, unsigned Idx) { return RetOrArg(F, Idx, false); } + RetOrArg CreateRet(const Function *F, unsigned Idx) { + return RetOrArg(F, Idx, false); + } /// Convenience wrapper - RetOrArg CreateArg(const Function *F, unsigned Idx) { return RetOrArg(F, Idx, true); } + RetOrArg CreateArg(const Function *F, unsigned Idx) { + return RetOrArg(F, Idx, true); + } typedef std::multimap UseMap; /// This map maps a return value or argument to all return values or - /// arguments it uses. + /// arguments it uses. /// For example (indices are left out for clarity): /// - Uses[ret F] = ret G /// This means that F calls G, and F returns the value returned by G. @@ -100,7 +105,7 @@ namespace { /// This set contains all values that have been determined to be live LiveSet LiveValues; - + typedef SmallVector UseVector; public: @@ -112,11 +117,13 @@ namespace { private: Liveness IsMaybeLive(RetOrArg Use, UseVector &MaybeLiveUses); - Liveness SurveyUse(Value::use_iterator U, UseVector &MaybeLiveUses, unsigned RetValNum = 0); + Liveness SurveyUse(Value::use_iterator U, UseVector &MaybeLiveUses, + unsigned RetValNum = 0); Liveness SurveyUses(Value *V, UseVector &MaybeLiveUses); void SurveyFunction(Function &F); - void MarkValue(const RetOrArg &RA, Liveness L, const UseVector &MaybeLiveUses); + void MarkValue(const RetOrArg &RA, Liveness L, + const UseVector &MaybeLiveUses); void MarkLive(RetOrArg RA); bool RemoveDeadStuffFromFunction(Function *F); bool DeleteDeadVarargs(Function &Fn); @@ -291,7 +298,8 @@ DAE::Liveness DAE::IsMaybeLive(RetOrArg Use, UseVector &MaybeLiveUses) { /// 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 /// it at 0. -DAE::Liveness DAE::SurveyUse(Value::use_iterator U, UseVector &MaybeLiveUses, unsigned RetValNum) { +DAE::Liveness DAE::SurveyUse(Value::use_iterator U, UseVector &MaybeLiveUses, + unsigned RetValNum) { Value *V = *U; if (ReturnInst *RI = dyn_cast(V)) { // The value is returned from another function. It's only live when the @@ -299,9 +307,10 @@ DAE::Liveness DAE::SurveyUse(Value::use_iterator U, UseVector &MaybeLiveUses, un RetOrArg Use = CreateRet(RI->getParent()->getParent(), RetValNum); // We might be live, depending on the liveness of Use return IsMaybeLive(Use, MaybeLiveUses); - } + } if (InsertValueInst *IV = dyn_cast(V)) { - if (U.getOperandNo() != InsertValueInst::getAggregateOperandIndex() && IV->hasIndices()) + if (U.getOperandNo() != InsertValueInst::getAggregateOperandIndex() + && IV->hasIndices()) // The use we are examining is inserted into an aggregate. Our liveness // depends on all uses of that aggregate, but if it is used as a return // value, only index at which we were inserted counts. @@ -309,7 +318,7 @@ DAE::Liveness DAE::SurveyUse(Value::use_iterator U, UseVector &MaybeLiveUses, un // Note that if we are used as the aggregate operand to the insertvalue, // we don't change RetValNum, but do survey all our uses. - + Liveness Result = Dead; for (Value::use_iterator I = IV->use_begin(), E = V->use_end(); I != E; ++I) { @@ -324,7 +333,7 @@ DAE::Liveness DAE::SurveyUse(Value::use_iterator U, UseVector &MaybeLiveUses, un Function *F = CS.getCalledFunction(); if (F) { // Used in a direct call - + // Check for vararg. Do - 1 to skip the first operand to call (the // function itself). if (U.getOperandNo() - 1 >= F->getFunctionType()->getNumParams()) @@ -384,10 +393,11 @@ void DAE::SurveyFunction(Function &F) { typedef SmallVector RetUses; // Intialized to a list of RetCount empty lists RetUses MaybeLiveRetUses(RetCount); - + for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) if (ReturnInst *RI = dyn_cast(BB->getTerminator())) - if (RI->getNumOperands() != 0 && RI->getOperand(0)->getType() != F.getFunctionType()->getReturnType()) { + if (RI->getNumOperands() != 0 && RI->getOperand(0)->getType() + != F.getFunctionType()->getReturnType()) { // We don't support old style multiple return values FunctionIntrinsicallyLive = true; break; @@ -417,20 +427,20 @@ void DAE::SurveyFunction(Function &F) { FunctionIntrinsicallyLive = true; break; } - + // If we end up here, we are looking at a direct call to our function. - + // Now, check how our return value(s) is/are used in this caller. Don't // bother checking return values if all of them are live already - if (NumLiveRetVals != RetCount) { + if (NumLiveRetVals != RetCount) { if (STy) { // Check all uses of the return value for (Value::use_iterator I = TheCall->use_begin(), E = TheCall->use_end(); I != E; ++I) { ExtractValueInst *Ext = dyn_cast(*I); if (Ext && Ext->hasIndices()) { - // This use uses a part of our return value, survey the uses of that - // part and store the results for this index only. + // This use uses a part of our return value, survey the uses of + // that part and store the results for this index only. unsigned Idx = *Ext->idx_begin(); if (RetValLiveness[Idx] != Live) { RetValLiveness[Idx] = SurveyUses(Ext, MaybeLiveRetUses[Idx]); @@ -468,7 +478,7 @@ void DAE::SurveyFunction(Function &F) { MarkLive(CreateRet(&F, i)); return; } - + // Now we've inspected all callers, record the liveness of our return values. for (unsigned i = 0, e = RetValLiveness.size(); i != e; ++i) { RetOrArg Ret = CreateRet(&F, i); @@ -480,7 +490,7 @@ void DAE::SurveyFunction(Function &F) { // Now, check all of our arguments unsigned i = 0; UseVector MaybeLiveArgUses; - for (Function::arg_iterator AI = F.arg_begin(), + for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); AI != E; ++AI, ++i) { // See what the effect of this use is (recording any uses that cause // MaybeLive in MaybeLiveArgUses) @@ -496,7 +506,8 @@ void DAE::SurveyFunction(Function &F) { /// MarkValue - This function marks the liveness of RA depending on L. If L is /// MaybeLive, it also records any uses in MaybeLiveUses such that RA will be /// marked live if any use in MaybeLiveUses gets marked live later on. -void DAE::MarkValue(const RetOrArg &RA, Liveness L, const UseVector &MaybeLiveUses) { +void DAE::MarkValue(const RetOrArg &RA, Liveness L, + const UseVector &MaybeLiveUses) { switch (L) { case Live: MarkLive(RA); break; case MaybeLive: @@ -504,7 +515,7 @@ void DAE::MarkValue(const RetOrArg &RA, Liveness L, const UseVector &MaybeLiveUs // Note any uses of this value, so this return value can be // marked live whenever one of the uses becomes live. UseMap::iterator Where = Uses.begin(); - for (UseVector::const_iterator UI = MaybeLiveUses.begin(), + for (UseVector::const_iterator UI = MaybeLiveUses.begin(), UE = MaybeLiveUses.end(); UI != UE; ++UI) Where = Uses.insert(Where, UseMap::value_type(*UI, RA)); break; @@ -521,9 +532,11 @@ void DAE::MarkLive(RetOrArg RA) { return; // We were already marked Live if (RA.IsArg) - DOUT << "DAE - Marking argument " << RA.Idx << " to function " << RA.F->getNameStart() << " live\n"; + DOUT << "DAE - Marking argument " << RA.Idx << " to function " + << RA.F->getNameStart() << " live\n"; else - DOUT << "DAE - Marking return value " << RA.Idx << " of function " << RA.F->getNameStart() << " live\n"; + DOUT << "DAE - Marking return value " << RA.Idx << " of function " + << RA.F->getNameStart() << " live\n"; // We don't use upper_bound (or equal_range) here, because our recursive call // to ourselves is likely to mark the upper_bound (which is the first value @@ -562,9 +575,9 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { // The existing function return attributes. ParameterAttributes RAttrs = PAL.getParamAttrs(0); - + // Find out the new return value - + const Type *RetTy = FTy->getReturnType(); const Type *NRetTy; unsigned RetCount = NumRetVals(F); @@ -584,7 +597,8 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { NewRetIdxs[i] = RetTypes.size() - 1; } else { ++NumRetValsEliminated; - DOUT << "DAE - Removing return value " << i << " from " << F->getNameStart() << "\n"; + DOUT << "DAE - Removing return value " << i << " from " + << F->getNameStart() << "\n"; Changed = true; } } @@ -594,17 +608,18 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { RetTypes.push_back(RetTy); NewRetIdxs[0] = 0; } else { - DOUT << "DAE - Removing return value from " << F->getNameStart() << "\n"; + DOUT << "DAE - Removing return value from " << F->getNameStart() + << "\n"; ++NumRetValsEliminated; Changed = true; - } - if (RetTypes.size() > 1 || (STy && STy->getNumElements() == RetTypes.size())) + } + if (RetTypes.size() > 1 || STy && STy->getNumElements() == RetTypes.size()) // More than one return type? Return a struct with them. Also, if we used // to return a struct and didn't change the number of return values, // return a struct again. This prevents chaning {something} into something // and {} into void. // Make the new struct packed if we used to return a packed struct - // already. + // already. NRetTy = StructType::get(RetTypes, STy->isPacked()); else if (RetTypes.size() == 1) // One return type? Just a simple value then, but only if we didn't use to @@ -616,12 +631,12 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { } else { NRetTy = Type::VoidTy; } - + // Remove any incompatible attributes RAttrs &= ~ParamAttr::typeIncompatible(NRetTy); if (RAttrs) ParamAttrsVec.push_back(ParamAttrsWithIndex::get(0, RAttrs)); - + // Remember which arguments are still alive SmallVector ArgAlive(FTy->getNumParams(), false); // Construct the new parameter list from non-dead arguments. Also construct @@ -634,14 +649,15 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { if (LiveValues.erase(Arg)) { Params.push_back(I->getType()); ArgAlive[i] = true; - + // Get the original parameter attributes (skipping the first one, that is // for the return value if (ParameterAttributes Attrs = PAL.getParamAttrs(i + 1)) ParamAttrsVec.push_back(ParamAttrsWithIndex::get(Params.size(), Attrs)); } else { ++NumArgumentsEliminated; - DOUT << "DAE - Removing argument " << i << " (" << I->getNameStart() << ") from " << F->getNameStart() << "\n"; + DOUT << "DAE - Removing argument " << i << " (" << I->getNameStart() + << ") from " << F->getNameStart() << "\n"; Changed = true; } } @@ -663,14 +679,15 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { // Create the new function type based on the recomputed parameters. FunctionType *NFTy = FunctionType::get(NRetTy, Params, FTy->isVarArg()); - + // No change? if (NFTy == FTy) return false; // The function type is only allowed to be different if we actually left out // an argument or return value - assert(Changed && "Function type changed while no arguments or retrurn values were removed!"); + assert(Changed && "Function type changed while no arguments or retrurn values" + "were removed!"); // Create the new function body and insert it into the module... Function *NF = Function::Create(NFTy, F->getLinkage()); @@ -702,7 +719,7 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { // Declare these outside of the loops, so we can reuse them for the second // loop, which loops the varargs CallSite::arg_iterator I = CS.arg_begin(); - unsigned i = 0; + unsigned i = 0; // Loop over those operands, corresponding to the normal arguments to the // original function, and add those that are still alive. for (unsigned e = FTy->getNumParams(); i != e; ++I, ++i) @@ -759,11 +776,13 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { // all extractvalue instructions). for (Value::use_iterator I = Call->use_begin(), E = Call->use_end(); I != E;) { - assert(isa(*I) && "Return value not only used by extractvalue?"); + assert(isa(*I) && "Return value not only used by" + "extractvalue?"); ExtractValueInst *EV = cast(*I); // Increment now, since we're about to throw away this use. ++I; - assert(EV->hasIndices() && "Return value used by extractvalue without indices?"); + assert(EV->hasIndices() && "Return value used by extractvalue without" + "indices?"); unsigned Idx = *EV->idx_begin(); if (NewRetIdxs[Idx] != -1) { if (RetTypes.size() > 1) { @@ -771,7 +790,9 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { // instruction with the first index updated std::vector NewIdxs(EV->idx_begin(), EV->idx_end()); NewIdxs[0] = NewRetIdxs[Idx]; - Value *NEV = ExtractValueInst::Create(New, NewIdxs.begin(), NewIdxs.end(), "retval", EV); + Value *NEV = ExtractValueInst::Create(New, NewIdxs.begin(), + NewIdxs.end(), "retval", + EV); EV->replaceAllUsesWith(NEV); EV->eraseFromParent(); } else { @@ -788,7 +809,7 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { } } New->takeName(Call); - } + } } // Finally, remove the old call from the program, reducing the use-count of @@ -839,19 +860,21 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { RetVal = llvm::UndefValue::get(NRetTy); for (unsigned i = 0; i != RetCount; ++i) if (NewRetIdxs[i] != -1) { - ExtractValueInst *EV = ExtractValueInst::Create(OldRet, i, "newret", RI); + ExtractValueInst *EV = ExtractValueInst::Create(OldRet, i, + "newret", RI); if (RetTypes.size() > 1) { // We're still returning a struct, so reinsert the value into // our new return value at the new index - RetVal = InsertValueInst::Create(RetVal, EV, NewRetIdxs[i], "oldret"); + RetVal = InsertValueInst::Create(RetVal, EV, NewRetIdxs[i], + "oldret"); } else { // We are now only returning a simple value, so just return the // extracted value RetVal = EV; } - } - } + } + } // Replace the return instruction with one returning the new return // value (possibly 0 if we became void). ReturnInst::Create(RetVal, RI); -- cgit v1.2.3