Members/tobaru/cbc/CbC_llvm: lib/Transforms/IPO/DeadArgumentElimination.cpp comparison

comparison lib/Transforms/IPO/DeadArgumentElimination.cpp @ 80:67baa08a3894

update to LLVM 3.6

author	Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
date	Thu, 25 Sep 2014 16:56:18 +0900
parents	54457678186b
children	60c9769439b8

comparison

equal deleted inserted replaced

-:9e74acfe8c42
+:67baa08a3894
 // This pass is often useful as a cleanup pass to run after aggressive
 // interprocedural passes, which add possibly-dead arguments or return values.
 //
 //===----------------------------------------------------------------------===//
-#define DEBUG_TYPE "deadargelim"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringExtras.h"
-#include "llvm/DIBuilder.h"
+#include "llvm/IR/CallSite.h"
-#include "llvm/DebugInfo.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/Constant.h"
+#include "llvm/IR/DIBuilder.h"
+#include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Pass.h"
-#include "llvm/Support/CallSite.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <map>
 #include <set>
+#include <tuple>
 using namespace llvm;
+#define DEBUG_TYPE "deadargelim"
 STATISTIC(NumArgumentsEliminated, "Number of unread args removed");
 STATISTIC(NumRetValsEliminated  , "Number of unused return values removed");
 STATISTIC(NumArgumentsReplacedWithUndef,
 "Number of unread args replaced with undef");
 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)
+return std::tie(F, Idx, IsArg) < std::tie(O.F, O.Idx, O.IsArg);
-return F < O.F;
-else if (Idx != O.Idx)
-return Idx < O.Idx;
-else
-return IsArg < O.IsArg;
 }
 /// Make RetOrArg comparable, so we can easily iterate the multimap.
 bool operator==(const RetOrArg &O) const {
 return F == O.F && Idx == O.Idx && IsArg == O.IsArg;
 // the function is replaced with another one, we should patch the pointer
 // to LLVM function in metadata.
 // As the code generation for module is finished (and DIBuilder is
 // finalized) we assume that subprogram descriptors won't be changed, and
 // they are stored in map for short duration anyway.
-typedef DenseMap<Function*, DISubprogram> FunctionDIMap;
+DenseMap<const Function *, DISubprogram> FunctionDIs;
-FunctionDIMap FunctionDIs;
 protected:
 // DAH uses this to specify a different ID.
 explicit DAE(char &ID) : ModulePass(ID) {}
 static char ID; // Pass identification, replacement for typeid
 DAE() : ModulePass(ID) {
 initializeDAEPass(*PassRegistry::getPassRegistry());
 }
-bool runOnModule(Module &M);
+bool runOnModule(Module &M) override;
 virtual bool ShouldHackArguments() const { return false; }
 private:
 Liveness MarkIfNotLive(RetOrArg Use, UseVector &MaybeLiveUses);
-Liveness SurveyUse(Value::const_use_iterator U, UseVector &MaybeLiveUses,
+Liveness SurveyUse(const Use *U, UseVector &MaybeLiveUses,
 unsigned RetValNum = 0);
 Liveness SurveyUses(const Value *V, UseVector &MaybeLiveUses);
-void CollectFunctionDIs(Module &M);
 void SurveyFunction(const Function &F);
 void MarkValue(const RetOrArg &RA, Liveness L,
 const UseVector &MaybeLiveUses);
 void MarkLive(const RetOrArg &RA);
 void MarkLive(const Function &F);
 /// by bugpoint.
 struct DAH : public DAE {
 static char ID;
 DAH() : DAE(ID) {}
-virtual bool ShouldHackArguments() const { return true; }
+bool ShouldHackArguments() const override { return true; }
 };
 }
 char DAH::ID = 0;
 INITIALIZE_PASS(DAH, "deadarghaX0r",
 /// which are not used by the body of the function.
 ///
 ModulePass *llvm::createDeadArgEliminationPass() { return new DAE(); }
 ModulePass *llvm::createDeadArgHackingPass() { return new DAH(); }
-/// CollectFunctionDIs - Map each function in the module to its debug info
-/// descriptor.
-void DAE::CollectFunctionDIs(Module &M) {
-FunctionDIs.clear();
-for (Module::named_metadata_iterator I = M.named_metadata_begin(),
-E = M.named_metadata_end(); I != E; ++I) {
-NamedMDNode &NMD = *I;
-for (unsigned MDIndex = 0, MDNum = NMD.getNumOperands();
-MDIndex < MDNum; ++MDIndex) {
-MDNode *Node = NMD.getOperand(MDIndex);
-if (!DIDescriptor(Node).isCompileUnit())
-continue;
-DICompileUnit CU(Node);
-const DIArray &SPs = CU.getSubprograms();
-for (unsigned SPIndex = 0, SPNum = SPs.getNumElements();
-SPIndex < SPNum; ++SPIndex) {
-DISubprogram SP(SPs.getElement(SPIndex));
-assert((!SP || SP.isSubprogram()) &&
-"A MDNode in subprograms of a CU should be null or a DISubprogram.");
-if (!SP)
-continue;
-if (Function *F = SP.getFunction())
-FunctionDIs[F] = SP;
-}
-}
-}
-}
 /// DeleteDeadVarargs - If this is an function that takes a ... list, and if
 /// llvm.vastart is never called, the varargs list is dead for the function.
 bool DAE::DeleteDeadVarargs(Function &Fn) {
 assert(Fn.getFunctionType()->isVarArg() && "Function isn't varargs!");
 if (Fn.isDeclaration() || !Fn.hasLocalLinkage()) return false;
 // Ensure that the function is only directly called.
 if (Fn.hasAddressTaken())
 return false;
 // Okay, we know we can transform this function if safe.  Scan its body
-// looking for calls to llvm.vastart.
+// looking for calls marked musttail or calls to llvm.vastart.
 for (Function::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) {
 for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) {
-if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
+CallInst *CI = dyn_cast<CallInst>(I);
+if (!CI)
+continue;
+if (CI->isMustTailCall())
+return false;
+if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(CI)) {
 if (II->getIntrinsicID() == Intrinsic::vastart)
 return false;
 }
 }
 }
 // Loop over all of the callers of the function, transforming the call sites
 // to pass in a smaller number of arguments into the new function.
 //
 std::vector<Value*> Args;
-for (Value::use_iterator I = Fn.use_begin(), E = Fn.use_end(); I != E; ) {
+for (Value::user_iterator I = Fn.user_begin(), E = Fn.user_end(); I != E; ) {
 CallSite CS(*I++);
 if (!CS)
 continue;
 Instruction *Call = CS.getInstruction();
 I->replaceAllUsesWith(I2);
 I2->takeName(I);
 }
 // Patch the pointer to LLVM function in debug info descriptor.
-FunctionDIMap::iterator DI = FunctionDIs.find(&Fn);
+auto DI = FunctionDIs.find(&Fn);
 if (DI != FunctionDIs.end())
 DI->second.replaceFunction(NF);
 // Fix up any BlockAddresses that refer to the function.
 Fn.replaceAllUsesWith(ConstantExpr::getBitCast(NF, Fn.getType()));
 SmallVector<unsigned, 8> UnusedArgs;
 for (Function::arg_iterator I = Fn.arg_begin(), E = Fn.arg_end();
 I != E; ++I) {
 Argument *Arg = I;
-if (Arg->use_empty() && !Arg->hasByValAttr())
+if (Arg->use_empty() && !Arg->hasByValOrInAllocaAttr())
 UnusedArgs.push_back(Arg->getArgNo());
 }
 if (UnusedArgs.empty())
 return false;
 bool Changed = false;
-for (Function::use_iterator I = Fn.use_begin(), E = Fn.use_end();
+for (Use &U : Fn.uses()) {
-I != E; ++I) {
+CallSite CS(U.getUser());
-CallSite CS(*I);
+if (!CS || !CS.isCallee(&U))
-if (!CS || !CS.isCallee(I))
 continue;
 // Now go through all unused args and replace them with "undef".
 for (unsigned I = 0, E = UnusedArgs.size(); I != E; ++I) {
 unsigned ArgNo = UnusedArgs[I];
 /// if it causes the used value to become MaybeLive.
 ///
 /// 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::const_use_iterator U,
+DAE::Liveness DAE::SurveyUse(const Use *U,
 UseVector &MaybeLiveUses, unsigned RetValNum) {
-const User *V = *U;
+const User *V = U->getUser();
 if (const ReturnInst *RI = dyn_cast<ReturnInst>(V)) {
 // The value is returned from a function. It's only live when the
 // function's return value is live. We use RetValNum here, for the case
 // that U is really a use of an insertvalue instruction that uses the
 // original Use.
 RetOrArg Use = CreateRet(RI->getParent()->getParent(), RetValNum);
 // We might be live, depending on the liveness of Use.
 return MarkIfNotLive(Use, MaybeLiveUses);
 }
 if (const InsertValueInst *IV = dyn_cast<InsertValueInst>(V)) {
-if (U.getOperandNo() != InsertValueInst::getAggregateOperandIndex()
+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.
 RetValNum = *IV->idx_begin();
 // 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 = MaybeLive;
-for (Value::const_use_iterator I = IV->use_begin(),
+for (const Use &UU : IV->uses()) {
-E = V->use_end(); I != E; ++I) {
+Result = SurveyUse(&UU, MaybeLiveUses, RetValNum);
-Result = SurveyUse(I, MaybeLiveUses, RetValNum);
 if (Result == Live)
 break;
 }
 return Result;
 }
 if (ArgNo >= F->getFunctionType()->getNumParams())
 // The value is passed in through a vararg! Must be live.
 return Live;
 assert(CS.getArgument(ArgNo)
-== CS->getOperand(U.getOperandNo())
+== CS->getOperand(U->getOperandNo())
 && "Argument is not where we expected it");
 // Value passed to a normal call. It's only live when the corresponding
 // argument to the called function turns out live.
 RetOrArg Use = CreateArg(F, ArgNo);
 /// be ignored (since it might not be complete).
 DAE::Liveness DAE::SurveyUses(const Value *V, UseVector &MaybeLiveUses) {
 // Assume it's dead (which will only hold if there are no uses at all..).
 Liveness Result = MaybeLive;
 // Check each use.
-for (Value::const_use_iterator I = V->use_begin(),
+for (const Use &U : V->uses()) {
-E = V->use_end(); I != E; ++I) {
+Result = SurveyUse(&U, MaybeLiveUses);
-Result = SurveyUse(I, MaybeLiveUses);
 if (Result == Live)
 break;
 }
 return Result;
 }
 //
 // 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(const Function &F) {
+// Functions with inalloca parameters are expecting args in a particular
+// register and memory layout.
+if (F.getAttributes().hasAttrSomewhere(Attribute::InAlloca)) {
+MarkLive(F);
+return;
+}
 unsigned RetCount = NumRetVals(&F);
 // Assume all return values are dead
 typedef SmallVector<Liveness, 5> RetVals;
 RetVals RetValLiveness(RetCount, MaybeLive);
 // Keep track of the number of live retvals, so we can skip checks once all
 // of them turn out to be live.
 unsigned NumLiveRetVals = 0;
 Type *STy = dyn_cast<StructType>(F.getReturnType());
 // Loop all uses of the function.
-for (Value::const_use_iterator I = F.use_begin(), E = F.use_end();
+for (const Use &U : F.uses()) {
-I != E; ++I) {
 // If the function is PASSED IN as an argument, its address has been
 // taken.
-ImmutableCallSite CS(*I);
+ImmutableCallSite CS(U.getUser());
-if (!CS || !CS.isCallee(I)) {
+if (!CS || !CS.isCallee(&U)) {
 MarkLive(F);
 return;
 }
 // If this use is anything other than a call site, the function is alive.
 // 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 (STy) {
 // Check all uses of the return value.
-for (Value::const_use_iterator I = TheCall->use_begin(),
+for (const User *U : TheCall->users()) {
-E = TheCall->use_end(); I != E; ++I) {
+const ExtractValueInst *Ext = dyn_cast<ExtractValueInst>(U);
-const ExtractValueInst *Ext = dyn_cast<ExtractValueInst>(*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.
 unsigned Idx = *Ext->idx_begin();
 if (RetValLiveness[Idx] != Live) {
 }
 }
 // Find out the new return value.
 Type *RetTy = FTy->getReturnType();
-Type *NRetTy = NULL;
+Type *NRetTy = nullptr;
 unsigned RetCount = NumRetVals(F);
 // -1 means unused, other numbers are the new index
 SmallVector<int, 5> NewRetIdxs(RetCount, -1);
 std::vector<Type*> RetTypes;
 // Loop over all of the callers of the function, transforming the call sites
 // to pass in a smaller number of arguments into the new function.
 //
 std::vector<Value*> Args;
 while (!F->use_empty()) {
-CallSite CS(F->use_back());
+CallSite CS(F->user_back());
 Instruction *Call = CS.getInstruction();
 AttributesVec.clear();
 const AttributeSet &CallPAL = CS.getAttributes();
 for (Function::iterator BB = NF->begin(), E = NF->end(); BB != E; ++BB)
 if (ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator())) {
 Value *RetVal;
 if (NFTy->getReturnType()->isVoidTy()) {
-RetVal = 0;
+RetVal = nullptr;
 } else {
 assert (RetTy->isStructTy());
 // The original return value was a struct, insert
 // extractvalue/insertvalue chains to extract only the values we need
 // to return and insert them into our new result.
 ReturnInst::Create(F->getContext(), RetVal, RI);
 BB->getInstList().erase(RI);
 }
 // Patch the pointer to LLVM function in debug info descriptor.
-FunctionDIMap::iterator DI = FunctionDIs.find(F);
+auto DI = FunctionDIs.find(F);
 if (DI != FunctionDIs.end())
 DI->second.replaceFunction(NF);
 // Now that the old function is dead, delete it.
 F->eraseFromParent();
 bool DAE::runOnModule(Module &M) {
 bool Changed = false;
 // Collect debug info descriptors for functions.
-CollectFunctionDIs(M);
+FunctionDIs = makeSubprogramMap(M);
 // First pass: Do a simple check to see if any functions can have their "..."
 // removed.  We can do this if they never call va_start.  This loop cannot be
 // fused with the next loop, because deleting a function invalidates
 // information computed while surveying other functions.

Mercurial > hg > Members > tobaru > cbc > CbC_llvm

comparison lib/Transforms/IPO/DeadArgumentElimination.cpp @ 80:67baa08a3894