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