LLVM  4.0.0
DeadArgumentElimination.cpp
Go to the documentation of this file.
1 //===-- DeadArgumentElimination.cpp - Eliminate dead arguments ------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This pass deletes dead arguments from internal functions. Dead argument
11 // elimination removes arguments which are directly dead, as well as arguments
12 // only passed into function calls as dead arguments of other functions. This
13 // pass also deletes dead return values in a similar way.
14 //
15 // This pass is often useful as a cleanup pass to run after aggressive
16 // interprocedural passes, which add possibly-dead arguments or return values.
17 //
18 //===----------------------------------------------------------------------===//
19 
21 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/ADT/Statistic.h"
23 #include "llvm/ADT/StringExtras.h"
24 #include "llvm/IR/CallSite.h"
25 #include "llvm/IR/CallingConv.h"
26 #include "llvm/IR/Constant.h"
27 #include "llvm/IR/DIBuilder.h"
28 #include "llvm/IR/DebugInfo.h"
29 #include "llvm/IR/DerivedTypes.h"
30 #include "llvm/IR/Instructions.h"
31 #include "llvm/IR/IntrinsicInst.h"
32 #include "llvm/IR/LLVMContext.h"
33 #include "llvm/IR/Module.h"
34 #include "llvm/Pass.h"
35 #include "llvm/Support/Debug.h"
37 #include "llvm/Transforms/IPO.h"
39 #include <set>
40 #include <tuple>
41 using namespace llvm;
42 
43 #define DEBUG_TYPE "deadargelim"
44 
45 STATISTIC(NumArgumentsEliminated, "Number of unread args removed");
46 STATISTIC(NumRetValsEliminated , "Number of unused return values removed");
47 STATISTIC(NumArgumentsReplacedWithUndef,
48  "Number of unread args replaced with undef");
49 namespace {
50  /// DAE - The dead argument elimination pass.
51  ///
52  class DAE : public ModulePass {
53  protected:
54  // DAH uses this to specify a different ID.
55  explicit DAE(char &ID) : ModulePass(ID) {}
56 
57  public:
58  static char ID; // Pass identification, replacement for typeid
59  DAE() : ModulePass(ID) {
61  }
62 
63  bool runOnModule(Module &M) override {
64  if (skipModule(M))
65  return false;
66  DeadArgumentEliminationPass DAEP(ShouldHackArguments());
67  ModuleAnalysisManager DummyMAM;
68  PreservedAnalyses PA = DAEP.run(M, DummyMAM);
69  return !PA.areAllPreserved();
70  }
71 
72  virtual bool ShouldHackArguments() const { return false; }
73  };
74 }
75 
76 
77 char DAE::ID = 0;
78 INITIALIZE_PASS(DAE, "deadargelim", "Dead Argument Elimination", false, false)
79 
80 namespace {
81  /// DAH - DeadArgumentHacking pass - Same as dead argument elimination, but
82  /// deletes arguments to functions which are external. This is only for use
83  /// by bugpoint.
84  struct DAH : public DAE {
85  static char ID;
86  DAH() : DAE(ID) {}
87 
88  bool ShouldHackArguments() const override { return true; }
89  };
90 }
91 
92 char DAH::ID = 0;
93 INITIALIZE_PASS(DAH, "deadarghaX0r",
94  "Dead Argument Hacking (BUGPOINT USE ONLY; DO NOT USE)",
95  false, false)
96 
97 /// createDeadArgEliminationPass - This pass removes arguments from functions
98 /// which are not used by the body of the function.
99 ///
100 ModulePass *llvm::createDeadArgEliminationPass() { return new DAE(); }
102 
103 /// DeleteDeadVarargs - If this is an function that takes a ... list, and if
104 /// llvm.vastart is never called, the varargs list is dead for the function.
105 bool DeadArgumentEliminationPass::DeleteDeadVarargs(Function &Fn) {
106  assert(Fn.getFunctionType()->isVarArg() && "Function isn't varargs!");
107  if (Fn.isDeclaration() || !Fn.hasLocalLinkage()) return false;
108 
109  // Ensure that the function is only directly called.
110  if (Fn.hasAddressTaken())
111  return false;
112 
113  // Don't touch naked functions. The assembly might be using an argument, or
114  // otherwise rely on the frame layout in a way that this analysis will not
115  // see.
116  if (Fn.hasFnAttribute(Attribute::Naked)) {
117  return false;
118  }
119 
120  // Okay, we know we can transform this function if safe. Scan its body
121  // looking for calls marked musttail or calls to llvm.vastart.
122  for (BasicBlock &BB : Fn) {
123  for (Instruction &I : BB) {
124  CallInst *CI = dyn_cast<CallInst>(&I);
125  if (!CI)
126  continue;
127  if (CI->isMustTailCall())
128  return false;
129  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(CI)) {
130  if (II->getIntrinsicID() == Intrinsic::vastart)
131  return false;
132  }
133  }
134  }
135 
136  // If we get here, there are no calls to llvm.vastart in the function body,
137  // remove the "..." and adjust all the calls.
138 
139  // Start by computing a new prototype for the function, which is the same as
140  // the old function, but doesn't have isVarArg set.
141  FunctionType *FTy = Fn.getFunctionType();
142 
143  std::vector<Type*> Params(FTy->param_begin(), FTy->param_end());
145  Params, false);
146  unsigned NumArgs = Params.size();
147 
148  // Create the new function body and insert it into the module...
149  Function *NF = Function::Create(NFTy, Fn.getLinkage());
150  NF->copyAttributesFrom(&Fn);
151  NF->setComdat(Fn.getComdat());
152  Fn.getParent()->getFunctionList().insert(Fn.getIterator(), NF);
153  NF->takeName(&Fn);
154 
155  // Loop over all of the callers of the function, transforming the call sites
156  // to pass in a smaller number of arguments into the new function.
157  //
158  std::vector<Value*> Args;
159  for (Value::user_iterator I = Fn.user_begin(), E = Fn.user_end(); I != E; ) {
160  CallSite CS(*I++);
161  if (!CS)
162  continue;
163  Instruction *Call = CS.getInstruction();
164 
165  // Pass all the same arguments.
166  Args.assign(CS.arg_begin(), CS.arg_begin() + NumArgs);
167 
168  // Drop any attributes that were on the vararg arguments.
169  AttributeSet PAL = CS.getAttributes();
170  if (!PAL.isEmpty() && PAL.getSlotIndex(PAL.getNumSlots() - 1) > NumArgs) {
171  SmallVector<AttributeSet, 8> AttributesVec;
172  for (unsigned i = 0; PAL.getSlotIndex(i) <= NumArgs; ++i)
173  AttributesVec.push_back(PAL.getSlotAttributes(i));
175  AttributesVec.push_back(AttributeSet::get(Fn.getContext(),
176  PAL.getFnAttributes()));
177  PAL = AttributeSet::get(Fn.getContext(), AttributesVec);
178  }
179 
181  CS.getOperandBundlesAsDefs(OpBundles);
182 
183  Instruction *New;
184  if (InvokeInst *II = dyn_cast<InvokeInst>(Call)) {
185  New = InvokeInst::Create(NF, II->getNormalDest(), II->getUnwindDest(),
186  Args, OpBundles, "", Call);
187  cast<InvokeInst>(New)->setCallingConv(CS.getCallingConv());
188  cast<InvokeInst>(New)->setAttributes(PAL);
189  } else {
190  New = CallInst::Create(NF, Args, OpBundles, "", Call);
191  cast<CallInst>(New)->setCallingConv(CS.getCallingConv());
192  cast<CallInst>(New)->setAttributes(PAL);
193  cast<CallInst>(New)->setTailCallKind(
194  cast<CallInst>(Call)->getTailCallKind());
195  }
196  New->setDebugLoc(Call->getDebugLoc());
197 
198  Args.clear();
199 
200  if (!Call->use_empty())
201  Call->replaceAllUsesWith(New);
202 
203  New->takeName(Call);
204 
205  // Finally, remove the old call from the program, reducing the use-count of
206  // F.
207  Call->eraseFromParent();
208  }
209 
210  // Since we have now created the new function, splice the body of the old
211  // function right into the new function, leaving the old rotting hulk of the
212  // function empty.
213  NF->getBasicBlockList().splice(NF->begin(), Fn.getBasicBlockList());
214 
215  // Loop over the argument list, transferring uses of the old arguments over to
216  // the new arguments, also transferring over the names as well. While we're at
217  // it, remove the dead arguments from the DeadArguments list.
218  //
219  for (Function::arg_iterator I = Fn.arg_begin(), E = Fn.arg_end(),
220  I2 = NF->arg_begin(); I != E; ++I, ++I2) {
221  // Move the name and users over to the new version.
222  I->replaceAllUsesWith(&*I2);
223  I2->takeName(&*I);
224  }
225 
226  // Patch the pointer to LLVM function in debug info descriptor.
227  NF->setSubprogram(Fn.getSubprogram());
228 
229  // Fix up any BlockAddresses that refer to the function.
230  Fn.replaceAllUsesWith(ConstantExpr::getBitCast(NF, Fn.getType()));
231  // Delete the bitcast that we just created, so that NF does not
232  // appear to be address-taken.
234  // Finally, nuke the old function.
235  Fn.eraseFromParent();
236  return true;
237 }
238 
239 /// RemoveDeadArgumentsFromCallers - Checks if the given function has any
240 /// arguments that are unused, and changes the caller parameters to be undefined
241 /// instead.
242 bool DeadArgumentEliminationPass::RemoveDeadArgumentsFromCallers(Function &Fn) {
243  // We cannot change the arguments if this TU does not define the function or
244  // if the linker may choose a function body from another TU, even if the
245  // nominal linkage indicates that other copies of the function have the same
246  // semantics. In the below example, the dead load from %p may not have been
247  // eliminated from the linker-chosen copy of f, so replacing %p with undef
248  // in callers may introduce undefined behavior.
249  //
250  // define linkonce_odr void @f(i32* %p) {
251  // %v = load i32 %p
252  // ret void
253  // }
254  if (!Fn.hasExactDefinition())
255  return false;
256 
257  // Functions with local linkage should already have been handled, except the
258  // fragile (variadic) ones which we can improve here.
259  if (Fn.hasLocalLinkage() && !Fn.getFunctionType()->isVarArg())
260  return false;
261 
262  // Don't touch naked functions. The assembly might be using an argument, or
263  // otherwise rely on the frame layout in a way that this analysis will not
264  // see.
265  if (Fn.hasFnAttribute(Attribute::Naked))
266  return false;
267 
268  if (Fn.use_empty())
269  return false;
270 
271  SmallVector<unsigned, 8> UnusedArgs;
272  for (Argument &Arg : Fn.args()) {
273  if (!Arg.hasSwiftErrorAttr() && Arg.use_empty() && !Arg.hasByValOrInAllocaAttr())
274  UnusedArgs.push_back(Arg.getArgNo());
275  }
276 
277  if (UnusedArgs.empty())
278  return false;
279 
280  bool Changed = false;
281 
282  for (Use &U : Fn.uses()) {
283  CallSite CS(U.getUser());
284  if (!CS || !CS.isCallee(&U))
285  continue;
286 
287  // Now go through all unused args and replace them with "undef".
288  for (unsigned I = 0, E = UnusedArgs.size(); I != E; ++I) {
289  unsigned ArgNo = UnusedArgs[I];
290 
291  Value *Arg = CS.getArgument(ArgNo);
292  CS.setArgument(ArgNo, UndefValue::get(Arg->getType()));
293  ++NumArgumentsReplacedWithUndef;
294  Changed = true;
295  }
296  }
297 
298  return Changed;
299 }
300 
301 /// Convenience function that returns the number of return values. It returns 0
302 /// for void functions and 1 for functions not returning a struct. It returns
303 /// the number of struct elements for functions returning a struct.
304 static unsigned NumRetVals(const Function *F) {
305  Type *RetTy = F->getReturnType();
306  if (RetTy->isVoidTy())
307  return 0;
308  else if (StructType *STy = dyn_cast<StructType>(RetTy))
309  return STy->getNumElements();
310  else if (ArrayType *ATy = dyn_cast<ArrayType>(RetTy))
311  return ATy->getNumElements();
312  else
313  return 1;
314 }
315 
316 /// Returns the sub-type a function will return at a given Idx. Should
317 /// correspond to the result type of an ExtractValue instruction executed with
318 /// just that one Idx (i.e. only top-level structure is considered).
319 static Type *getRetComponentType(const Function *F, unsigned Idx) {
320  Type *RetTy = F->getReturnType();
321  assert(!RetTy->isVoidTy() && "void type has no subtype");
322 
323  if (StructType *STy = dyn_cast<StructType>(RetTy))
324  return STy->getElementType(Idx);
325  else if (ArrayType *ATy = dyn_cast<ArrayType>(RetTy))
326  return ATy->getElementType();
327  else
328  return RetTy;
329 }
330 
331 /// MarkIfNotLive - This checks Use for liveness in LiveValues. If Use is not
332 /// live, it adds Use to the MaybeLiveUses argument. Returns the determined
333 /// liveness of Use.
335 DeadArgumentEliminationPass::MarkIfNotLive(RetOrArg Use,
336  UseVector &MaybeLiveUses) {
337  // We're live if our use or its Function is already marked as live.
338  if (LiveFunctions.count(Use.F) || LiveValues.count(Use))
339  return Live;
340 
341  // We're maybe live otherwise, but remember that we must become live if
342  // Use becomes live.
343  MaybeLiveUses.push_back(Use);
344  return MaybeLive;
345 }
346 
347 
348 /// SurveyUse - This looks at a single use of an argument or return value
349 /// and determines if it should be alive or not. Adds this use to MaybeLiveUses
350 /// if it causes the used value to become MaybeLive.
351 ///
352 /// RetValNum is the return value number to use when this use is used in a
353 /// return instruction. This is used in the recursion, you should always leave
354 /// it at 0.
356 DeadArgumentEliminationPass::SurveyUse(const Use *U, UseVector &MaybeLiveUses,
357  unsigned RetValNum) {
358  const User *V = U->getUser();
359  if (const ReturnInst *RI = dyn_cast<ReturnInst>(V)) {
360  // The value is returned from a function. It's only live when the
361  // function's return value is live. We use RetValNum here, for the case
362  // that U is really a use of an insertvalue instruction that uses the
363  // original Use.
364  const Function *F = RI->getParent()->getParent();
365  if (RetValNum != -1U) {
366  RetOrArg Use = CreateRet(F, RetValNum);
367  // We might be live, depending on the liveness of Use.
368  return MarkIfNotLive(Use, MaybeLiveUses);
369  } else {
371  for (unsigned i = 0; i < NumRetVals(F); ++i) {
372  RetOrArg Use = CreateRet(F, i);
373  // We might be live, depending on the liveness of Use. If any
374  // sub-value is live, then the entire value is considered live. This
375  // is a conservative choice, and better tracking is possible.
377  MarkIfNotLive(Use, MaybeLiveUses);
378  if (Result != Live)
379  Result = SubResult;
380  }
381  return Result;
382  }
383  }
384  if (const InsertValueInst *IV = dyn_cast<InsertValueInst>(V)) {
385  if (U->getOperandNo() != InsertValueInst::getAggregateOperandIndex()
386  && IV->hasIndices())
387  // The use we are examining is inserted into an aggregate. Our liveness
388  // depends on all uses of that aggregate, but if it is used as a return
389  // value, only index at which we were inserted counts.
390  RetValNum = *IV->idx_begin();
391 
392  // Note that if we are used as the aggregate operand to the insertvalue,
393  // we don't change RetValNum, but do survey all our uses.
394 
395  Liveness Result = MaybeLive;
396  for (const Use &UU : IV->uses()) {
397  Result = SurveyUse(&UU, MaybeLiveUses, RetValNum);
398  if (Result == Live)
399  break;
400  }
401  return Result;
402  }
403 
404  if (auto CS = ImmutableCallSite(V)) {
405  const Function *F = CS.getCalledFunction();
406  if (F) {
407  // Used in a direct call.
408 
409  // The function argument is live if it is used as a bundle operand.
410  if (CS.isBundleOperand(U))
411  return Live;
412 
413  // Find the argument number. We know for sure that this use is an
414  // argument, since if it was the function argument this would be an
415  // indirect call and the we know can't be looking at a value of the
416  // label type (for the invoke instruction).
417  unsigned ArgNo = CS.getArgumentNo(U);
418 
419  if (ArgNo >= F->getFunctionType()->getNumParams())
420  // The value is passed in through a vararg! Must be live.
421  return Live;
422 
423  assert(CS.getArgument(ArgNo)
424  == CS->getOperand(U->getOperandNo())
425  && "Argument is not where we expected it");
426 
427  // Value passed to a normal call. It's only live when the corresponding
428  // argument to the called function turns out live.
429  RetOrArg Use = CreateArg(F, ArgNo);
430  return MarkIfNotLive(Use, MaybeLiveUses);
431  }
432  }
433  // Used in any other way? Value must be live.
434  return Live;
435 }
436 
437 /// SurveyUses - This looks at all the uses of the given value
438 /// Returns the Liveness deduced from the uses of this value.
439 ///
440 /// Adds all uses that cause the result to be MaybeLive to MaybeLiveRetUses. If
441 /// the result is Live, MaybeLiveUses might be modified but its content should
442 /// be ignored (since it might not be complete).
444 DeadArgumentEliminationPass::SurveyUses(const Value *V,
445  UseVector &MaybeLiveUses) {
446  // Assume it's dead (which will only hold if there are no uses at all..).
447  Liveness Result = MaybeLive;
448  // Check each use.
449  for (const Use &U : V->uses()) {
450  Result = SurveyUse(&U, MaybeLiveUses);
451  if (Result == Live)
452  break;
453  }
454  return Result;
455 }
456 
457 // SurveyFunction - This performs the initial survey of the specified function,
458 // checking out whether or not it uses any of its incoming arguments or whether
459 // any callers use the return value. This fills in the LiveValues set and Uses
460 // map.
461 //
462 // We consider arguments of non-internal functions to be intrinsically alive as
463 // well as arguments to functions which have their "address taken".
464 //
465 void DeadArgumentEliminationPass::SurveyFunction(const Function &F) {
466  // Functions with inalloca parameters are expecting args in a particular
467  // register and memory layout.
468  if (F.getAttributes().hasAttrSomewhere(Attribute::InAlloca)) {
469  MarkLive(F);
470  return;
471  }
472 
473  // Don't touch naked functions. The assembly might be using an argument, or
474  // otherwise rely on the frame layout in a way that this analysis will not
475  // see.
476  if (F.hasFnAttribute(Attribute::Naked)) {
477  MarkLive(F);
478  return;
479  }
480 
481  unsigned RetCount = NumRetVals(&F);
482  // Assume all return values are dead
483  typedef SmallVector<Liveness, 5> RetVals;
484  RetVals RetValLiveness(RetCount, MaybeLive);
485 
486  typedef SmallVector<UseVector, 5> RetUses;
487  // These vectors map each return value to the uses that make it MaybeLive, so
488  // we can add those to the Uses map if the return value really turns out to be
489  // MaybeLive. Initialized to a list of RetCount empty lists.
490  RetUses MaybeLiveRetUses(RetCount);
491 
492  for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
493  if (const ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator()))
494  if (RI->getNumOperands() != 0 && RI->getOperand(0)->getType()
495  != F.getFunctionType()->getReturnType()) {
496  // We don't support old style multiple return values.
497  MarkLive(F);
498  return;
499  }
500 
501  if (!F.hasLocalLinkage() && (!ShouldHackArguments || F.isIntrinsic())) {
502  MarkLive(F);
503  return;
504  }
505 
506  DEBUG(dbgs() << "DeadArgumentEliminationPass - Inspecting callers for fn: "
507  << F.getName() << "\n");
508  // Keep track of the number of live retvals, so we can skip checks once all
509  // of them turn out to be live.
510  unsigned NumLiveRetVals = 0;
511  // Loop all uses of the function.
512  for (const Use &U : F.uses()) {
513  // If the function is PASSED IN as an argument, its address has been
514  // taken.
516  if (!CS || !CS.isCallee(&U)) {
517  MarkLive(F);
518  return;
519  }
520 
521  // If this use is anything other than a call site, the function is alive.
522  const Instruction *TheCall = CS.getInstruction();
523  if (!TheCall) { // Not a direct call site?
524  MarkLive(F);
525  return;
526  }
527 
528  // If we end up here, we are looking at a direct call to our function.
529 
530  // Now, check how our return value(s) is/are used in this caller. Don't
531  // bother checking return values if all of them are live already.
532  if (NumLiveRetVals == RetCount)
533  continue;
534 
535  // Check all uses of the return value.
536  for (const Use &U : TheCall->uses()) {
537  if (ExtractValueInst *Ext = dyn_cast<ExtractValueInst>(U.getUser())) {
538  // This use uses a part of our return value, survey the uses of
539  // that part and store the results for this index only.
540  unsigned Idx = *Ext->idx_begin();
541  if (RetValLiveness[Idx] != Live) {
542  RetValLiveness[Idx] = SurveyUses(Ext, MaybeLiveRetUses[Idx]);
543  if (RetValLiveness[Idx] == Live)
544  NumLiveRetVals++;
545  }
546  } else {
547  // Used by something else than extractvalue. Survey, but assume that the
548  // result applies to all sub-values.
549  UseVector MaybeLiveAggregateUses;
550  if (SurveyUse(&U, MaybeLiveAggregateUses) == Live) {
551  NumLiveRetVals = RetCount;
552  RetValLiveness.assign(RetCount, Live);
553  break;
554  } else {
555  for (unsigned i = 0; i != RetCount; ++i) {
556  if (RetValLiveness[i] != Live)
557  MaybeLiveRetUses[i].append(MaybeLiveAggregateUses.begin(),
558  MaybeLiveAggregateUses.end());
559  }
560  }
561  }
562  }
563  }
564 
565  // Now we've inspected all callers, record the liveness of our return values.
566  for (unsigned i = 0; i != RetCount; ++i)
567  MarkValue(CreateRet(&F, i), RetValLiveness[i], MaybeLiveRetUses[i]);
568 
569  DEBUG(dbgs() << "DeadArgumentEliminationPass - Inspecting args for fn: "
570  << F.getName() << "\n");
571 
572  // Now, check all of our arguments.
573  unsigned i = 0;
574  UseVector MaybeLiveArgUses;
576  E = F.arg_end(); AI != E; ++AI, ++i) {
577  Liveness Result;
578  if (F.getFunctionType()->isVarArg()) {
579  // Variadic functions will already have a va_arg function expanded inside
580  // them, making them potentially very sensitive to ABI changes resulting
581  // from removing arguments entirely, so don't. For example AArch64 handles
582  // register and stack HFAs very differently, and this is reflected in the
583  // IR which has already been generated.
584  Result = Live;
585  } else {
586  // See what the effect of this use is (recording any uses that cause
587  // MaybeLive in MaybeLiveArgUses).
588  Result = SurveyUses(&*AI, MaybeLiveArgUses);
589  }
590 
591  // Mark the result.
592  MarkValue(CreateArg(&F, i), Result, MaybeLiveArgUses);
593  // Clear the vector again for the next iteration.
594  MaybeLiveArgUses.clear();
595  }
596 }
597 
598 /// MarkValue - This function marks the liveness of RA depending on L. If L is
599 /// MaybeLive, it also takes all uses in MaybeLiveUses and records them in Uses,
600 /// such that RA will be marked live if any use in MaybeLiveUses gets marked
601 /// live later on.
602 void DeadArgumentEliminationPass::MarkValue(const RetOrArg &RA, Liveness L,
603  const UseVector &MaybeLiveUses) {
604  switch (L) {
605  case Live: MarkLive(RA); break;
606  case MaybeLive:
607  {
608  // Note any uses of this value, so this return value can be
609  // marked live whenever one of the uses becomes live.
610  for (const auto &MaybeLiveUse : MaybeLiveUses)
611  Uses.insert(std::make_pair(MaybeLiveUse, RA));
612  break;
613  }
614  }
615 }
616 
617 /// MarkLive - Mark the given Function as alive, meaning that it cannot be
618 /// changed in any way. Additionally,
619 /// mark any values that are used as this function's parameters or by its return
620 /// values (according to Uses) live as well.
621 void DeadArgumentEliminationPass::MarkLive(const Function &F) {
622  DEBUG(dbgs() << "DeadArgumentEliminationPass - Intrinsically live fn: "
623  << F.getName() << "\n");
624  // Mark the function as live.
625  LiveFunctions.insert(&F);
626  // Mark all arguments as live.
627  for (unsigned i = 0, e = F.arg_size(); i != e; ++i)
628  PropagateLiveness(CreateArg(&F, i));
629  // Mark all return values as live.
630  for (unsigned i = 0, e = NumRetVals(&F); i != e; ++i)
631  PropagateLiveness(CreateRet(&F, i));
632 }
633 
634 /// MarkLive - Mark the given return value or argument as live. Additionally,
635 /// mark any values that are used by this value (according to Uses) live as
636 /// well.
637 void DeadArgumentEliminationPass::MarkLive(const RetOrArg &RA) {
638  if (LiveFunctions.count(RA.F))
639  return; // Function was already marked Live.
640 
641  if (!LiveValues.insert(RA).second)
642  return; // We were already marked Live.
643 
644  DEBUG(dbgs() << "DeadArgumentEliminationPass - Marking "
645  << RA.getDescription() << " live\n");
646  PropagateLiveness(RA);
647 }
648 
649 /// PropagateLiveness - Given that RA is a live value, propagate it's liveness
650 /// to any other values it uses (according to Uses).
651 void DeadArgumentEliminationPass::PropagateLiveness(const RetOrArg &RA) {
652  // We don't use upper_bound (or equal_range) here, because our recursive call
653  // to ourselves is likely to cause the upper_bound (which is the first value
654  // not belonging to RA) to become erased and the iterator invalidated.
655  UseMap::iterator Begin = Uses.lower_bound(RA);
656  UseMap::iterator E = Uses.end();
657  UseMap::iterator I;
658  for (I = Begin; I != E && I->first == RA; ++I)
659  MarkLive(I->second);
660 
661  // Erase RA from the Uses map (from the lower bound to wherever we ended up
662  // after the loop).
663  Uses.erase(Begin, I);
664 }
665 
666 // RemoveDeadStuffFromFunction - Remove any arguments and return values from F
667 // that are not in LiveValues. Transform the function and all of the callees of
668 // the function to not have these arguments and return values.
669 //
670 bool DeadArgumentEliminationPass::RemoveDeadStuffFromFunction(Function *F) {
671  // Don't modify fully live functions
672  if (LiveFunctions.count(F))
673  return false;
674 
675  // Start by computing a new prototype for the function, which is the same as
676  // the old function, but has fewer arguments and a different return type.
677  FunctionType *FTy = F->getFunctionType();
678  std::vector<Type*> Params;
679 
680  // Keep track of if we have a live 'returned' argument
681  bool HasLiveReturnedArg = false;
682 
683  // Set up to build a new list of parameter attributes.
684  SmallVector<AttributeSet, 8> AttributesVec;
685  const AttributeSet &PAL = F->getAttributes();
686 
687  // Remember which arguments are still alive.
688  SmallVector<bool, 10> ArgAlive(FTy->getNumParams(), false);
689  // Construct the new parameter list from non-dead arguments. Also construct
690  // a new set of parameter attributes to correspond. Skip the first parameter
691  // attribute, since that belongs to the return value.
692  unsigned i = 0;
693  for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end();
694  I != E; ++I, ++i) {
695  RetOrArg Arg = CreateArg(F, i);
696  if (LiveValues.erase(Arg)) {
697  Params.push_back(I->getType());
698  ArgAlive[i] = true;
699 
700  // Get the original parameter attributes (skipping the first one, that is
701  // for the return value.
702  if (PAL.hasAttributes(i + 1)) {
703  AttrBuilder B(PAL, i + 1);
704  if (B.contains(Attribute::Returned))
705  HasLiveReturnedArg = true;
706  AttributesVec.
707  push_back(AttributeSet::get(F->getContext(), Params.size(), B));
708  }
709  } else {
710  ++NumArgumentsEliminated;
711  DEBUG(dbgs() << "DeadArgumentEliminationPass - Removing argument " << i
712  << " (" << I->getName() << ") from " << F->getName()
713  << "\n");
714  }
715  }
716 
717  // Find out the new return value.
718  Type *RetTy = FTy->getReturnType();
719  Type *NRetTy = nullptr;
720  unsigned RetCount = NumRetVals(F);
721 
722  // -1 means unused, other numbers are the new index
723  SmallVector<int, 5> NewRetIdxs(RetCount, -1);
724  std::vector<Type*> RetTypes;
725 
726  // If there is a function with a live 'returned' argument but a dead return
727  // value, then there are two possible actions:
728  // 1) Eliminate the return value and take off the 'returned' attribute on the
729  // argument.
730  // 2) Retain the 'returned' attribute and treat the return value (but not the
731  // entire function) as live so that it is not eliminated.
732  //
733  // It's not clear in the general case which option is more profitable because,
734  // even in the absence of explicit uses of the return value, code generation
735  // is free to use the 'returned' attribute to do things like eliding
736  // save/restores of registers across calls. Whether or not this happens is
737  // target and ABI-specific as well as depending on the amount of register
738  // pressure, so there's no good way for an IR-level pass to figure this out.
739  //
740  // Fortunately, the only places where 'returned' is currently generated by
741  // the FE are places where 'returned' is basically free and almost always a
742  // performance win, so the second option can just be used always for now.
743  //
744  // This should be revisited if 'returned' is ever applied more liberally.
745  if (RetTy->isVoidTy() || HasLiveReturnedArg) {
746  NRetTy = RetTy;
747  } else {
748  // Look at each of the original return values individually.
749  for (unsigned i = 0; i != RetCount; ++i) {
750  RetOrArg Ret = CreateRet(F, i);
751  if (LiveValues.erase(Ret)) {
752  RetTypes.push_back(getRetComponentType(F, i));
753  NewRetIdxs[i] = RetTypes.size() - 1;
754  } else {
755  ++NumRetValsEliminated;
756  DEBUG(dbgs() << "DeadArgumentEliminationPass - Removing return value "
757  << i << " from " << F->getName() << "\n");
758  }
759  }
760  if (RetTypes.size() > 1) {
761  // More than one return type? Reduce it down to size.
762  if (StructType *STy = dyn_cast<StructType>(RetTy)) {
763  // Make the new struct packed if we used to return a packed struct
764  // already.
765  NRetTy = StructType::get(STy->getContext(), RetTypes, STy->isPacked());
766  } else {
767  assert(isa<ArrayType>(RetTy) && "unexpected multi-value return");
768  NRetTy = ArrayType::get(RetTypes[0], RetTypes.size());
769  }
770  } else if (RetTypes.size() == 1)
771  // One return type? Just a simple value then, but only if we didn't use to
772  // return a struct with that simple value before.
773  NRetTy = RetTypes.front();
774  else if (RetTypes.size() == 0)
775  // No return types? Make it void, but only if we didn't use to return {}.
776  NRetTy = Type::getVoidTy(F->getContext());
777  }
778 
779  assert(NRetTy && "No new return type found?");
780 
781  // The existing function return attributes.
782  AttributeSet RAttrs = PAL.getRetAttributes();
783 
784  // Remove any incompatible attributes, but only if we removed all return
785  // values. Otherwise, ensure that we don't have any conflicting attributes
786  // here. Currently, this should not be possible, but special handling might be
787  // required when new return value attributes are added.
788  if (NRetTy->isVoidTy())
789  RAttrs = RAttrs.removeAttributes(NRetTy->getContext(),
792  else
794  overlaps(AttributeFuncs::typeIncompatible(NRetTy)) &&
795  "Return attributes no longer compatible?");
796 
798  AttributesVec.push_back(AttributeSet::get(NRetTy->getContext(), RAttrs));
799 
801  AttributesVec.push_back(AttributeSet::get(F->getContext(),
802  PAL.getFnAttributes()));
803 
804  // Reconstruct the AttributesList based on the vector we constructed.
805  AttributeSet NewPAL = AttributeSet::get(F->getContext(), AttributesVec);
806 
807  // Create the new function type based on the recomputed parameters.
808  FunctionType *NFTy = FunctionType::get(NRetTy, Params, FTy->isVarArg());
809 
810  // No change?
811  if (NFTy == FTy)
812  return false;
813 
814  // Create the new function body and insert it into the module...
815  Function *NF = Function::Create(NFTy, F->getLinkage());
816  NF->copyAttributesFrom(F);
817  NF->setComdat(F->getComdat());
818  NF->setAttributes(NewPAL);
819  // Insert the new function before the old function, so we won't be processing
820  // it again.
821  F->getParent()->getFunctionList().insert(F->getIterator(), NF);
822  NF->takeName(F);
823 
824  // Loop over all of the callers of the function, transforming the call sites
825  // to pass in a smaller number of arguments into the new function.
826  //
827  std::vector<Value*> Args;
828  while (!F->use_empty()) {
829  CallSite CS(F->user_back());
830  Instruction *Call = CS.getInstruction();
831 
832  AttributesVec.clear();
833  const AttributeSet &CallPAL = CS.getAttributes();
834 
835  // The call return attributes.
836  AttributeSet RAttrs = CallPAL.getRetAttributes();
837 
838  // Adjust in case the function was changed to return void.
839  RAttrs = RAttrs.removeAttributes(NRetTy->getContext(),
843  AttributesVec.push_back(AttributeSet::get(NF->getContext(), RAttrs));
844 
845  // Declare these outside of the loops, so we can reuse them for the second
846  // loop, which loops the varargs.
847  CallSite::arg_iterator I = CS.arg_begin();
848  unsigned i = 0;
849  // Loop over those operands, corresponding to the normal arguments to the
850  // original function, and add those that are still alive.
851  for (unsigned e = FTy->getNumParams(); i != e; ++I, ++i)
852  if (ArgAlive[i]) {
853  Args.push_back(*I);
854  // Get original parameter attributes, but skip return attributes.
855  if (CallPAL.hasAttributes(i + 1)) {
856  AttrBuilder B(CallPAL, i + 1);
857  // If the return type has changed, then get rid of 'returned' on the
858  // call site. The alternative is to make all 'returned' attributes on
859  // call sites keep the return value alive just like 'returned'
860  // attributes on function declaration but it's less clearly a win
861  // and this is not an expected case anyway
862  if (NRetTy != RetTy && B.contains(Attribute::Returned))
863  B.removeAttribute(Attribute::Returned);
864  AttributesVec.
865  push_back(AttributeSet::get(F->getContext(), Args.size(), B));
866  }
867  }
868 
869  // Push any varargs arguments on the list. Don't forget their attributes.
870  for (CallSite::arg_iterator E = CS.arg_end(); I != E; ++I, ++i) {
871  Args.push_back(*I);
872  if (CallPAL.hasAttributes(i + 1)) {
873  AttrBuilder B(CallPAL, i + 1);
874  AttributesVec.
875  push_back(AttributeSet::get(F->getContext(), Args.size(), B));
876  }
877  }
878 
880  AttributesVec.push_back(AttributeSet::get(Call->getContext(),
881  CallPAL.getFnAttributes()));
882 
883  // Reconstruct the AttributesList based on the vector we constructed.
884  AttributeSet NewCallPAL = AttributeSet::get(F->getContext(), AttributesVec);
885 
887  CS.getOperandBundlesAsDefs(OpBundles);
888 
889  Instruction *New;
890  if (InvokeInst *II = dyn_cast<InvokeInst>(Call)) {
891  New = InvokeInst::Create(NF, II->getNormalDest(), II->getUnwindDest(),
892  Args, OpBundles, "", Call->getParent());
893  cast<InvokeInst>(New)->setCallingConv(CS.getCallingConv());
894  cast<InvokeInst>(New)->setAttributes(NewCallPAL);
895  } else {
896  New = CallInst::Create(NF, Args, OpBundles, "", Call);
897  cast<CallInst>(New)->setCallingConv(CS.getCallingConv());
898  cast<CallInst>(New)->setAttributes(NewCallPAL);
899  cast<CallInst>(New)->setTailCallKind(
900  cast<CallInst>(Call)->getTailCallKind());
901  }
902  New->setDebugLoc(Call->getDebugLoc());
903 
904  Args.clear();
905 
906  if (!Call->use_empty()) {
907  if (New->getType() == Call->getType()) {
908  // Return type not changed? Just replace users then.
909  Call->replaceAllUsesWith(New);
910  New->takeName(Call);
911  } else if (New->getType()->isVoidTy()) {
912  // Our return value has uses, but they will get removed later on.
913  // Replace by null for now.
914  if (!Call->getType()->isX86_MMXTy())
915  Call->replaceAllUsesWith(Constant::getNullValue(Call->getType()));
916  } else {
917  assert((RetTy->isStructTy() || RetTy->isArrayTy()) &&
918  "Return type changed, but not into a void. The old return type"
919  " must have been a struct or an array!");
920  Instruction *InsertPt = Call;
921  if (InvokeInst *II = dyn_cast<InvokeInst>(Call)) {
922  BasicBlock *NewEdge = SplitEdge(New->getParent(), II->getNormalDest());
923  InsertPt = &*NewEdge->getFirstInsertionPt();
924  }
925 
926  // We used to return a struct or array. Instead of doing smart stuff
927  // with all the uses, we will just rebuild it using extract/insertvalue
928  // chaining and let instcombine clean that up.
929  //
930  // Start out building up our return value from undef
931  Value *RetVal = UndefValue::get(RetTy);
932  for (unsigned i = 0; i != RetCount; ++i)
933  if (NewRetIdxs[i] != -1) {
934  Value *V;
935  if (RetTypes.size() > 1)
936  // We are still returning a struct, so extract the value from our
937  // return value
938  V = ExtractValueInst::Create(New, NewRetIdxs[i], "newret",
939  InsertPt);
940  else
941  // We are now returning a single element, so just insert that
942  V = New;
943  // Insert the value at the old position
944  RetVal = InsertValueInst::Create(RetVal, V, i, "oldret", InsertPt);
945  }
946  // Now, replace all uses of the old call instruction with the return
947  // struct we built
948  Call->replaceAllUsesWith(RetVal);
949  New->takeName(Call);
950  }
951  }
952 
953  // Finally, remove the old call from the program, reducing the use-count of
954  // F.
955  Call->eraseFromParent();
956  }
957 
958  // Since we have now created the new function, splice the body of the old
959  // function right into the new function, leaving the old rotting hulk of the
960  // function empty.
961  NF->getBasicBlockList().splice(NF->begin(), F->getBasicBlockList());
962 
963  // Loop over the argument list, transferring uses of the old arguments over to
964  // the new arguments, also transferring over the names as well.
965  i = 0;
966  for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(),
967  I2 = NF->arg_begin(); I != E; ++I, ++i)
968  if (ArgAlive[i]) {
969  // If this is a live argument, move the name and users over to the new
970  // version.
971  I->replaceAllUsesWith(&*I2);
972  I2->takeName(&*I);
973  ++I2;
974  } else {
975  // If this argument is dead, replace any uses of it with null constants
976  // (these are guaranteed to become unused later on).
977  if (!I->getType()->isX86_MMXTy())
978  I->replaceAllUsesWith(Constant::getNullValue(I->getType()));
979  }
980 
981  // If we change the return value of the function we must rewrite any return
982  // instructions. Check this now.
983  if (F->getReturnType() != NF->getReturnType())
984  for (BasicBlock &BB : *NF)
985  if (ReturnInst *RI = dyn_cast<ReturnInst>(BB.getTerminator())) {
986  Value *RetVal;
987 
988  if (NFTy->getReturnType()->isVoidTy()) {
989  RetVal = nullptr;
990  } else {
991  assert(RetTy->isStructTy() || RetTy->isArrayTy());
992  // The original return value was a struct or array, insert
993  // extractvalue/insertvalue chains to extract only the values we need
994  // to return and insert them into our new result.
995  // This does generate messy code, but we'll let it to instcombine to
996  // clean that up.
997  Value *OldRet = RI->getOperand(0);
998  // Start out building up our return value from undef
999  RetVal = UndefValue::get(NRetTy);
1000  for (unsigned i = 0; i != RetCount; ++i)
1001  if (NewRetIdxs[i] != -1) {
1003  "oldret", RI);
1004  if (RetTypes.size() > 1) {
1005  // We're still returning a struct, so reinsert the value into
1006  // our new return value at the new index
1007 
1008  RetVal = InsertValueInst::Create(RetVal, EV, NewRetIdxs[i],
1009  "newret", RI);
1010  } else {
1011  // We are now only returning a simple value, so just return the
1012  // extracted value.
1013  RetVal = EV;
1014  }
1015  }
1016  }
1017  // Replace the return instruction with one returning the new return
1018  // value (possibly 0 if we became void).
1019  ReturnInst::Create(F->getContext(), RetVal, RI);
1020  BB.getInstList().erase(RI);
1021  }
1022 
1023  // Patch the pointer to LLVM function in debug info descriptor.
1024  NF->setSubprogram(F->getSubprogram());
1025 
1026  // Now that the old function is dead, delete it.
1027  F->eraseFromParent();
1028 
1029  return true;
1030 }
1031 
1034  bool Changed = false;
1035 
1036  // First pass: Do a simple check to see if any functions can have their "..."
1037  // removed. We can do this if they never call va_start. This loop cannot be
1038  // fused with the next loop, because deleting a function invalidates
1039  // information computed while surveying other functions.
1040  DEBUG(dbgs() << "DeadArgumentEliminationPass - Deleting dead varargs\n");
1041  for (Module::iterator I = M.begin(), E = M.end(); I != E; ) {
1042  Function &F = *I++;
1043  if (F.getFunctionType()->isVarArg())
1044  Changed |= DeleteDeadVarargs(F);
1045  }
1046 
1047  // Second phase:loop through the module, determining which arguments are live.
1048  // We assume all arguments are dead unless proven otherwise (allowing us to
1049  // determine that dead arguments passed into recursive functions are dead).
1050  //
1051  DEBUG(dbgs() << "DeadArgumentEliminationPass - Determining liveness\n");
1052  for (auto &F : M)
1053  SurveyFunction(F);
1054 
1055  // Now, remove all dead arguments and return values from each function in
1056  // turn.
1057  for (Module::iterator I = M.begin(), E = M.end(); I != E; ) {
1058  // Increment now, because the function will probably get removed (ie.
1059  // replaced by a new one).
1060  Function *F = &*I++;
1061  Changed |= RemoveDeadStuffFromFunction(F);
1062  }
1063 
1064  // Finally, look for any unused parameters in functions with non-local
1065  // linkage and replace the passed in parameters with undef.
1066  for (auto &F : M)
1067  Changed |= RemoveDeadArgumentsFromCallers(F);
1068 
1069  if (!Changed)
1070  return PreservedAnalyses::all();
1071  return PreservedAnalyses::none();
1072 }
MachineLoop * L
Return a value (possibly void), from a function.
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:76
LinkageTypes getLinkage() const
Definition: GlobalValue.h:429
iterator_range< use_iterator > uses()
Definition: Value.h:326
This instruction extracts a struct member or array element value from an aggregate value...
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:226
LLVM Argument representation.
Definition: Argument.h:34
Eliminate dead arguments (and return values) from functions.
STATISTIC(NumFunctions,"Total number of functions")
size_t i
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Definition: DerivedTypes.h:137
iterator end()
Definition: Function.h:537
This class represents a function call, abstracting a target machine's calling convention.
bool isIntrinsic() const
isIntrinsic - Returns true if the function's name starts with "llvm.".
Definition: Function.h:151
bool hasExactDefinition() const
Return true if this global has an exact defintion.
Definition: GlobalValue.h:386
RetOrArg CreateArg(const Function *F, unsigned Idx)
Convenience wrapper.
Type * getReturnType() const
Returns the type of the ret val.
Definition: Function.cpp:238
arg_iterator arg_end()
Definition: Function.h:559
LiveSet LiveValues
This set contains all values that have been determined to be live.
size_t arg_size() const
Definition: Function.cpp:327
AttributeSet getRetAttributes() const
The attributes for the ret value are returned.
Definition: Attributes.cpp:976
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Definition: Constants.cpp:195
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:191
static ReturnInst * Create(LLVMContext &C, Value *retVal=nullptr, Instruction *InsertBefore=nullptr)
Class to represent struct types.
Definition: DerivedTypes.h:199
ModulePass * createDeadArgHackingPass()
DeadArgHacking pass - Same as DAE, but delete arguments of external functions as well.
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
param_iterator param_end() const
Definition: DerivedTypes.h:127
bool isMustTailCall() const
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:60
user_iterator_impl< User > user_iterator
Definition: Value.h:340
Class to represent function types.
Definition: DerivedTypes.h:102
#define F(x, y, z)
Definition: MD5.cpp:51
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:128
Class to represent array types.
Definition: DerivedTypes.h:345
void setComdat(Comdat *C)
Definition: GlobalObject.h:94
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:291
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:401
bool isArrayTy() const
True if this is an instance of ArrayType.
Definition: Type.h:210
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:263
iterator begin()
Definition: Function.h:535
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition: PassManager.h:110
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1695
unsigned getNumSlots() const
Return the number of slots used in this attribute list.
void setSubprogram(DISubprogram *SP)
Set the attached subprogram.
Definition: Metadata.cpp:1454
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:107
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:256
static unsigned getAggregateOperandIndex()
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
AttributeSet getSlotAttributes(unsigned Slot) const
Return the attributes at the given slot.
static ExtractValueInst * Create(Value *Agg, ArrayRef< unsigned > Idxs, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
const Comdat * getComdat() const
Definition: GlobalObject.h:92
param_iterator param_begin() const
Definition: DerivedTypes.h:126
ModulePass * createDeadArgEliminationPass()
createDeadArgEliminationPass - This pass removes arguments from functions which are not used by the b...
void initializeDAEPass(PassRegistry &)
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:259
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:154
void splice(iterator where, iplist_impl &L2)
Definition: ilist.h:342
User * getUser() const
Returns the User that contains this Use.
Definition: Use.cpp:41
void copyAttributesFrom(const GlobalValue *Src) override
copyAttributesFrom - copy all additional attributes (those not needed to create a Function) from the ...
Definition: Function.cpp:431
arg_iterator arg_begin()
Definition: Function.h:550
self_iterator getIterator()
Definition: ilist_node.h:81
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1337
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:113
bool areAllPreserved() const
Test whether all analyses are preserved (and none are abandoned).
Definition: PassManager.h:267
User::op_iterator arg_iterator
arg_iterator - The type of iterator to use when looping over actual arguments at this call site...
Definition: CallSite.h:205
static InvokeInst * Create(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr, Instruction *InsertBefore=nullptr)
const FunctionListType & getFunctionList() const
Get the Module's list of functions (constant).
Definition: Module.h:478
static unsigned NumRetVals(const Function *F)
Convenience function that returns the number of return values.
Iterator for intrusive lists based on ilist_node.
const BasicBlockListType & getBasicBlockList() const
Definition: Function.h:512
static StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
Definition: Type.cpp:330
static CallInst * Create(Value *Func, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > Bundles=None, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:230
static Type * getRetComponentType(const Function *F, unsigned Idx)
Returns the sub-type a function will return at a given Idx.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
AttributeSet getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:176
AttributeSet removeAttributes(LLVMContext &C, unsigned Index, AttributeSet Attrs) const
Remove the specified attributes at the specified index from this attribute list.
Definition: Attributes.cpp:857
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1458
UseMap Uses
This maps a return value or argument to any MaybeLive return values or arguments it uses...
LiveFuncSet LiveFunctions
This set contains all values that are cannot be changed in any way.
void eraseFromParent() override
eraseFromParent - This method unlinks 'this' from the containing module and deletes it...
Definition: Function.cpp:246
void setAttributes(AttributeSet Attrs)
Set the attribute list for this Function.
Definition: Function.h:179
RetOrArg CreateRet(const Function *F, unsigned Idx)
Convenience wrapper.
bool isStructTy() const
True if this is an instance of StructType.
Definition: Type.h:207
INITIALIZE_PASS(DAH,"deadarghaX0r","Dead Argument Hacking (BUGPOINT USE ONLY; DO NOT USE)", false, false) ModulePass *llvm
createDeadArgEliminationPass - This pass removes arguments from functions which are not used by the b...
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:259
iterator insert(iterator where, pointer New)
Definition: ilist.h:241
bool hasAddressTaken(const User **=nullptr) const
hasAddressTaken - returns true if there are any uses of this function other than direct calls or invo...
Definition: Function.cpp:1171
iterator end()
Definition: Module.h:537
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:226
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:188
unsigned getSlotIndex(unsigned Slot) const
Return the index for the given slot.
bool hasAttributes(unsigned Index) const
Return true if attribute exists at the given index.
static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
ImmutableCallSite - establish a view to a call site for examination.
Definition: CallSite.h:665
bool ShouldHackArguments
This allows this pass to do double-duty as the dead arg hacking pass (used only by bugpoint)...
#define I(x, y, z)
Definition: MD5.cpp:54
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:135
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.cpp:230
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:235
bool hasAttrSomewhere(Attribute::AttrKind Kind, unsigned *Index=nullptr) const
Return true if the specified attribute is set for at least one parameter or for the return value...
iterator begin()
Definition: Module.h:535
static ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
Definition: Type.cpp:606
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:287
bool hasLocalLinkage() const
Definition: GlobalValue.h:415
bool isVarArg() const
Definition: DerivedTypes.h:122
bool use_empty() const
Definition: Value.h:299
Type * getReturnType() const
Definition: DerivedTypes.h:123
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Liveness
Liveness enum - During our initial pass over the program, we determine that things are either alive o...
void removeDeadConstantUsers() const
If there are any dead constant users dangling off of this constant, remove them.
Definition: Constants.cpp:463
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:537
LLVM Value Representation.
Definition: Value.h:71
AttrBuilder typeIncompatible(Type *Ty)
Which attributes cannot be applied to a type.
Invoke instruction.
#define DEBUG(X)
Definition: Debug.h:100
BasicBlock * SplitEdge(BasicBlock *From, BasicBlock *To, DominatorTree *DT=nullptr, LoopInfo *LI=nullptr)
Split the edge connecting specified block.
A container for analyses that lazily runs them and caches their results.
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, const Twine &N="", Module *M=nullptr)
Definition: Function.h:117
iterator getFirstInsertionPt()
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
Definition: BasicBlock.cpp:209
bool isEmpty() const
Return true if there are no attributes.
Definition: Attributes.h:400
const BasicBlock * getParent() const
Definition: Instruction.h:62
iterator_range< arg_iterator > args()
Definition: Function.h:568
User * user_back()
Definition: Value.h:356
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:44
bool isVoidTy() const
Return true if this is 'void'.
Definition: Type.h:139
This instruction inserts a struct field of array element value into an aggregate value.
PreservedAnalyses run(Module &M, ModuleAnalysisManager &)
AttributeSet getFnAttributes() const
The function attributes are returned.
Definition: Attributes.cpp:985