LLVM  4.0.0
ArgumentPromotion.cpp
Go to the documentation of this file.
1 //===-- ArgumentPromotion.cpp - Promote by-reference 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 promotes "by reference" arguments to be "by value" arguments. In
11 // practice, this means looking for internal functions that have pointer
12 // arguments. If it can prove, through the use of alias analysis, that an
13 // argument is *only* loaded, then it can pass the value into the function
14 // instead of the address of the value. This can cause recursive simplification
15 // of code and lead to the elimination of allocas (especially in C++ template
16 // code like the STL).
17 //
18 // This pass also handles aggregate arguments that are passed into a function,
19 // scalarizing them if the elements of the aggregate are only loaded. Note that
20 // by default it refuses to scalarize aggregates which would require passing in
21 // more than three operands to the function, because passing thousands of
22 // operands for a large array or structure is unprofitable! This limit can be
23 // configured or disabled, however.
24 //
25 // Note that this transformation could also be done for arguments that are only
26 // stored to (returning the value instead), but does not currently. This case
27 // would be best handled when and if LLVM begins supporting multiple return
28 // values from functions.
29 //
30 //===----------------------------------------------------------------------===//
31 
32 #include "llvm/Transforms/IPO.h"
34 #include "llvm/ADT/Statistic.h"
35 #include "llvm/ADT/StringExtras.h"
41 #include "llvm/Analysis/Loads.h"
43 #include "llvm/IR/CFG.h"
44 #include "llvm/IR/CallSite.h"
45 #include "llvm/IR/Constants.h"
46 #include "llvm/IR/DataLayout.h"
47 #include "llvm/IR/DebugInfo.h"
48 #include "llvm/IR/DerivedTypes.h"
49 #include "llvm/IR/Instructions.h"
50 #include "llvm/IR/LLVMContext.h"
51 #include "llvm/IR/Module.h"
52 #include "llvm/Support/Debug.h"
54 #include <set>
55 using namespace llvm;
56 
57 #define DEBUG_TYPE "argpromotion"
58 
59 STATISTIC(NumArgumentsPromoted , "Number of pointer arguments promoted");
60 STATISTIC(NumAggregatesPromoted, "Number of aggregate arguments promoted");
61 STATISTIC(NumByValArgsPromoted , "Number of byval arguments promoted");
62 STATISTIC(NumArgumentsDead , "Number of dead pointer args eliminated");
63 
64 namespace {
65  /// ArgPromotion - The 'by reference' to 'by value' argument promotion pass.
66  ///
67  struct ArgPromotion : public CallGraphSCCPass {
68  void getAnalysisUsage(AnalysisUsage &AU) const override {
73  }
74 
75  bool runOnSCC(CallGraphSCC &SCC) override;
76  static char ID; // Pass identification, replacement for typeid
77  explicit ArgPromotion(unsigned maxElements = 3)
78  : CallGraphSCCPass(ID), maxElements(maxElements) {
80  }
81 
82  private:
83 
85  bool doInitialization(CallGraph &CG) override;
86  /// The maximum number of elements to expand, or 0 for unlimited.
87  unsigned maxElements;
88  };
89 }
90 
91 /// A vector used to hold the indices of a single GEP instruction
92 typedef std::vector<uint64_t> IndicesVector;
93 
94 static CallGraphNode *
96  function_ref<AAResults &(Function &F)> AARGetter,
97  unsigned MaxElements);
98 static bool isDenselyPacked(Type *type, const DataLayout &DL);
99 static bool canPaddingBeAccessed(Argument *Arg);
100 static bool isSafeToPromoteArgument(Argument *Arg, bool isByVal, AAResults &AAR,
101  unsigned MaxElements);
102 static CallGraphNode *
104  SmallPtrSetImpl<Argument *> &ByValArgsToTransform, CallGraph &CG);
105 
106 char ArgPromotion::ID = 0;
107 INITIALIZE_PASS_BEGIN(ArgPromotion, "argpromotion",
108  "Promote 'by reference' arguments to scalars", false, false)
113  "Promote 'by reference' arguments to scalars", false, false)
114 
115 Pass *llvm::createArgumentPromotionPass(unsigned maxElements) {
116  return new ArgPromotion(maxElements);
117 }
118 
119 static bool runImpl(CallGraphSCC &SCC, CallGraph &CG,
120  function_ref<AAResults &(Function &F)> AARGetter,
121  unsigned MaxElements) {
122  bool Changed = false, LocalChange;
123 
124  do { // Iterate until we stop promoting from this SCC.
125  LocalChange = false;
126  // Attempt to promote arguments from all functions in this SCC.
127  for (CallGraphNode *OldNode : SCC) {
128  if (CallGraphNode *NewNode =
129  PromoteArguments(OldNode, CG, AARGetter, MaxElements)) {
130  LocalChange = true;
131  SCC.ReplaceNode(OldNode, NewNode);
132  }
133  }
134  Changed |= LocalChange; // Remember that we changed something.
135  } while (LocalChange);
136 
137  return Changed;
138 }
139 
140 bool ArgPromotion::runOnSCC(CallGraphSCC &SCC) {
141  if (skipSCC(SCC))
142  return false;
143 
144  // Get the callgraph information that we need to update to reflect our
145  // changes.
146  CallGraph &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();
147 
148  // We compute dedicated AA results for each function in the SCC as needed. We
149  // use a lambda referencing external objects so that they live long enough to
150  // be queried, but we re-use them each time.
153  auto AARGetter = [&](Function &F) -> AAResults & {
155  AAR.emplace(createLegacyPMAAResults(*this, F, *BAR));
156  return *AAR;
157  };
158 
159  return runImpl(SCC, CG, AARGetter, maxElements);
160 }
161 
162 /// \brief Checks if a type could have padding bytes.
163 static bool isDenselyPacked(Type *type, const DataLayout &DL) {
164 
165  // There is no size information, so be conservative.
166  if (!type->isSized())
167  return false;
168 
169  // If the alloc size is not equal to the storage size, then there are padding
170  // bytes. For x86_fp80 on x86-64, size: 80 alloc size: 128.
171  if (DL.getTypeSizeInBits(type) != DL.getTypeAllocSizeInBits(type))
172  return false;
173 
174  if (!isa<CompositeType>(type))
175  return true;
176 
177  // For homogenous sequential types, check for padding within members.
178  if (SequentialType *seqTy = dyn_cast<SequentialType>(type))
179  return isDenselyPacked(seqTy->getElementType(), DL);
180 
181  // Check for padding within and between elements of a struct.
182  StructType *StructTy = cast<StructType>(type);
183  const StructLayout *Layout = DL.getStructLayout(StructTy);
184  uint64_t StartPos = 0;
185  for (unsigned i = 0, E = StructTy->getNumElements(); i < E; ++i) {
186  Type *ElTy = StructTy->getElementType(i);
187  if (!isDenselyPacked(ElTy, DL))
188  return false;
189  if (StartPos != Layout->getElementOffsetInBits(i))
190  return false;
191  StartPos += DL.getTypeAllocSizeInBits(ElTy);
192  }
193 
194  return true;
195 }
196 
197 /// \brief Checks if the padding bytes of an argument could be accessed.
198 static bool canPaddingBeAccessed(Argument *arg) {
199 
200  assert(arg->hasByValAttr());
201 
202  // Track all the pointers to the argument to make sure they are not captured.
203  SmallPtrSet<Value *, 16> PtrValues;
204  PtrValues.insert(arg);
205 
206  // Track all of the stores.
208 
209  // Scan through the uses recursively to make sure the pointer is always used
210  // sanely.
211  SmallVector<Value *, 16> WorkList;
212  WorkList.insert(WorkList.end(), arg->user_begin(), arg->user_end());
213  while (!WorkList.empty()) {
214  Value *V = WorkList.back();
215  WorkList.pop_back();
216  if (isa<GetElementPtrInst>(V) || isa<PHINode>(V)) {
217  if (PtrValues.insert(V).second)
218  WorkList.insert(WorkList.end(), V->user_begin(), V->user_end());
219  } else if (StoreInst *Store = dyn_cast<StoreInst>(V)) {
220  Stores.push_back(Store);
221  } else if (!isa<LoadInst>(V)) {
222  return true;
223  }
224  }
225 
226 // Check to make sure the pointers aren't captured
227  for (StoreInst *Store : Stores)
228  if (PtrValues.count(Store->getValueOperand()))
229  return true;
230 
231  return false;
232 }
233 
234 /// PromoteArguments - This method checks the specified function to see if there
235 /// are any promotable arguments and if it is safe to promote the function (for
236 /// example, all callers are direct). If safe to promote some arguments, it
237 /// calls the DoPromotion method.
238 ///
239 static CallGraphNode *
241  function_ref<AAResults &(Function &F)> AARGetter,
242  unsigned MaxElements) {
243  Function *F = CGN->getFunction();
244 
245  // Make sure that it is local to this module.
246  if (!F || !F->hasLocalLinkage()) return nullptr;
247 
248  // Don't promote arguments for variadic functions. Adding, removing, or
249  // changing non-pack parameters can change the classification of pack
250  // parameters. Frontends encode that classification at the call site in the
251  // IR, while in the callee the classification is determined dynamically based
252  // on the number of registers consumed so far.
253  if (F->isVarArg()) return nullptr;
254 
255  // First check: see if there are any pointer arguments! If not, quick exit.
256  SmallVector<Argument*, 16> PointerArgs;
257  for (Argument &I : F->args())
258  if (I.getType()->isPointerTy())
259  PointerArgs.push_back(&I);
260  if (PointerArgs.empty()) return nullptr;
261 
262  // Second check: make sure that all callers are direct callers. We can't
263  // transform functions that have indirect callers. Also see if the function
264  // is self-recursive.
265  bool isSelfRecursive = false;
266  for (Use &U : F->uses()) {
267  CallSite CS(U.getUser());
268  // Must be a direct call.
269  if (CS.getInstruction() == nullptr || !CS.isCallee(&U)) return nullptr;
270 
271  if (CS.getInstruction()->getParent()->getParent() == F)
272  isSelfRecursive = true;
273  }
274 
275  const DataLayout &DL = F->getParent()->getDataLayout();
276 
277  AAResults &AAR = AARGetter(*F);
278 
279  // Check to see which arguments are promotable. If an argument is promotable,
280  // add it to ArgsToPromote.
281  SmallPtrSet<Argument*, 8> ArgsToPromote;
282  SmallPtrSet<Argument*, 8> ByValArgsToTransform;
283  for (Argument *PtrArg : PointerArgs) {
284  Type *AgTy = cast<PointerType>(PtrArg->getType())->getElementType();
285 
286  // Replace sret attribute with noalias. This reduces register pressure by
287  // avoiding a register copy.
288  if (PtrArg->hasStructRetAttr()) {
289  unsigned ArgNo = PtrArg->getArgNo();
290  F->setAttributes(
291  F->getAttributes()
292  .removeAttribute(F->getContext(), ArgNo + 1, Attribute::StructRet)
293  .addAttribute(F->getContext(), ArgNo + 1, Attribute::NoAlias));
294  for (Use &U : F->uses()) {
295  CallSite CS(U.getUser());
296  CS.setAttributes(
297  CS.getAttributes()
298  .removeAttribute(F->getContext(), ArgNo + 1,
299  Attribute::StructRet)
300  .addAttribute(F->getContext(), ArgNo + 1, Attribute::NoAlias));
301  }
302  }
303 
304  // If this is a byval argument, and if the aggregate type is small, just
305  // pass the elements, which is always safe, if the passed value is densely
306  // packed or if we can prove the padding bytes are never accessed. This does
307  // not apply to inalloca.
308  bool isSafeToPromote =
309  PtrArg->hasByValAttr() &&
310  (isDenselyPacked(AgTy, DL) || !canPaddingBeAccessed(PtrArg));
311  if (isSafeToPromote) {
312  if (StructType *STy = dyn_cast<StructType>(AgTy)) {
313  if (MaxElements > 0 && STy->getNumElements() > MaxElements) {
314  DEBUG(dbgs() << "argpromotion disable promoting argument '"
315  << PtrArg->getName() << "' because it would require adding more"
316  << " than " << MaxElements << " arguments to the function.\n");
317  continue;
318  }
319 
320  // If all the elements are single-value types, we can promote it.
321  bool AllSimple = true;
322  for (const auto *EltTy : STy->elements()) {
323  if (!EltTy->isSingleValueType()) {
324  AllSimple = false;
325  break;
326  }
327  }
328 
329  // Safe to transform, don't even bother trying to "promote" it.
330  // Passing the elements as a scalar will allow sroa to hack on
331  // the new alloca we introduce.
332  if (AllSimple) {
333  ByValArgsToTransform.insert(PtrArg);
334  continue;
335  }
336  }
337  }
338 
339  // If the argument is a recursive type and we're in a recursive
340  // function, we could end up infinitely peeling the function argument.
341  if (isSelfRecursive) {
342  if (StructType *STy = dyn_cast<StructType>(AgTy)) {
343  bool RecursiveType = false;
344  for (const auto *EltTy : STy->elements()) {
345  if (EltTy == PtrArg->getType()) {
346  RecursiveType = true;
347  break;
348  }
349  }
350  if (RecursiveType)
351  continue;
352  }
353  }
354 
355  // Otherwise, see if we can promote the pointer to its value.
356  if (isSafeToPromoteArgument(PtrArg, PtrArg->hasByValOrInAllocaAttr(), AAR,
357  MaxElements))
358  ArgsToPromote.insert(PtrArg);
359  }
360 
361  // No promotable pointer arguments.
362  if (ArgsToPromote.empty() && ByValArgsToTransform.empty())
363  return nullptr;
364 
365  return DoPromotion(F, ArgsToPromote, ByValArgsToTransform, CG);
366 }
367 
368 /// AllCallersPassInValidPointerForArgument - Return true if we can prove that
369 /// all callees pass in a valid pointer for the specified function argument.
371  Function *Callee = Arg->getParent();
372  const DataLayout &DL = Callee->getParent()->getDataLayout();
373 
374  unsigned ArgNo = Arg->getArgNo();
375 
376  // Look at all call sites of the function. At this point we know we only have
377  // direct callees.
378  for (User *U : Callee->users()) {
379  CallSite CS(U);
380  assert(CS && "Should only have direct calls!");
381 
382  if (!isDereferenceablePointer(CS.getArgument(ArgNo), DL))
383  return false;
384  }
385  return true;
386 }
387 
388 /// Returns true if Prefix is a prefix of longer. That means, Longer has a size
389 /// that is greater than or equal to the size of prefix, and each of the
390 /// elements in Prefix is the same as the corresponding elements in Longer.
391 ///
392 /// This means it also returns true when Prefix and Longer are equal!
393 static bool IsPrefix(const IndicesVector &Prefix, const IndicesVector &Longer) {
394  if (Prefix.size() > Longer.size())
395  return false;
396  return std::equal(Prefix.begin(), Prefix.end(), Longer.begin());
397 }
398 
399 
400 /// Checks if Indices, or a prefix of Indices, is in Set.
401 static bool PrefixIn(const IndicesVector &Indices,
402  std::set<IndicesVector> &Set) {
403  std::set<IndicesVector>::iterator Low;
404  Low = Set.upper_bound(Indices);
405  if (Low != Set.begin())
406  Low--;
407  // Low is now the last element smaller than or equal to Indices. This means
408  // it points to a prefix of Indices (possibly Indices itself), if such
409  // prefix exists.
410  //
411  // This load is safe if any prefix of its operands is safe to load.
412  return Low != Set.end() && IsPrefix(*Low, Indices);
413 }
414 
415 /// Mark the given indices (ToMark) as safe in the given set of indices
416 /// (Safe). Marking safe usually means adding ToMark to Safe. However, if there
417 /// is already a prefix of Indices in Safe, Indices are implicitely marked safe
418 /// already. Furthermore, any indices that Indices is itself a prefix of, are
419 /// removed from Safe (since they are implicitely safe because of Indices now).
420 static void MarkIndicesSafe(const IndicesVector &ToMark,
421  std::set<IndicesVector> &Safe) {
422  std::set<IndicesVector>::iterator Low;
423  Low = Safe.upper_bound(ToMark);
424  // Guard against the case where Safe is empty
425  if (Low != Safe.begin())
426  Low--;
427  // Low is now the last element smaller than or equal to Indices. This
428  // means it points to a prefix of Indices (possibly Indices itself), if
429  // such prefix exists.
430  if (Low != Safe.end()) {
431  if (IsPrefix(*Low, ToMark))
432  // If there is already a prefix of these indices (or exactly these
433  // indices) marked a safe, don't bother adding these indices
434  return;
435 
436  // Increment Low, so we can use it as a "insert before" hint
437  ++Low;
438  }
439  // Insert
440  Low = Safe.insert(Low, ToMark);
441  ++Low;
442  // If there we're a prefix of longer index list(s), remove those
443  std::set<IndicesVector>::iterator End = Safe.end();
444  while (Low != End && IsPrefix(ToMark, *Low)) {
445  std::set<IndicesVector>::iterator Remove = Low;
446  ++Low;
447  Safe.erase(Remove);
448  }
449 }
450 
451 /// isSafeToPromoteArgument - As you might guess from the name of this method,
452 /// it checks to see if it is both safe and useful to promote the argument.
453 /// This method limits promotion of aggregates to only promote up to three
454 /// elements of the aggregate in order to avoid exploding the number of
455 /// arguments passed in.
456 static bool isSafeToPromoteArgument(Argument *Arg, bool isByValOrInAlloca,
457  AAResults &AAR, unsigned MaxElements) {
458  typedef std::set<IndicesVector> GEPIndicesSet;
459 
460  // Quick exit for unused arguments
461  if (Arg->use_empty())
462  return true;
463 
464  // We can only promote this argument if all of the uses are loads, or are GEP
465  // instructions (with constant indices) that are subsequently loaded.
466  //
467  // Promoting the argument causes it to be loaded in the caller
468  // unconditionally. This is only safe if we can prove that either the load
469  // would have happened in the callee anyway (ie, there is a load in the entry
470  // block) or the pointer passed in at every call site is guaranteed to be
471  // valid.
472  // In the former case, invalid loads can happen, but would have happened
473  // anyway, in the latter case, invalid loads won't happen. This prevents us
474  // from introducing an invalid load that wouldn't have happened in the
475  // original code.
476  //
477  // This set will contain all sets of indices that are loaded in the entry
478  // block, and thus are safe to unconditionally load in the caller.
479  //
480  // This optimization is also safe for InAlloca parameters, because it verifies
481  // that the address isn't captured.
482  GEPIndicesSet SafeToUnconditionallyLoad;
483 
484  // This set contains all the sets of indices that we are planning to promote.
485  // This makes it possible to limit the number of arguments added.
486  GEPIndicesSet ToPromote;
487 
488  // If the pointer is always valid, any load with first index 0 is valid.
489  if (isByValOrInAlloca || AllCallersPassInValidPointerForArgument(Arg))
490  SafeToUnconditionallyLoad.insert(IndicesVector(1, 0));
491 
492  // First, iterate the entry block and mark loads of (geps of) arguments as
493  // safe.
494  BasicBlock &EntryBlock = Arg->getParent()->front();
495  // Declare this here so we can reuse it
496  IndicesVector Indices;
497  for (Instruction &I : EntryBlock)
498  if (LoadInst *LI = dyn_cast<LoadInst>(&I)) {
499  Value *V = LI->getPointerOperand();
500  if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(V)) {
501  V = GEP->getPointerOperand();
502  if (V == Arg) {
503  // This load actually loads (part of) Arg? Check the indices then.
504  Indices.reserve(GEP->getNumIndices());
505  for (User::op_iterator II = GEP->idx_begin(), IE = GEP->idx_end();
506  II != IE; ++II)
507  if (ConstantInt *CI = dyn_cast<ConstantInt>(*II))
508  Indices.push_back(CI->getSExtValue());
509  else
510  // We found a non-constant GEP index for this argument? Bail out
511  // right away, can't promote this argument at all.
512  return false;
513 
514  // Indices checked out, mark them as safe
515  MarkIndicesSafe(Indices, SafeToUnconditionallyLoad);
516  Indices.clear();
517  }
518  } else if (V == Arg) {
519  // Direct loads are equivalent to a GEP with a single 0 index.
520  MarkIndicesSafe(IndicesVector(1, 0), SafeToUnconditionallyLoad);
521  }
522  }
523 
524  // Now, iterate all uses of the argument to see if there are any uses that are
525  // not (GEP+)loads, or any (GEP+)loads that are not safe to promote.
527  IndicesVector Operands;
528  for (Use &U : Arg->uses()) {
529  User *UR = U.getUser();
530  Operands.clear();
531  if (LoadInst *LI = dyn_cast<LoadInst>(UR)) {
532  // Don't hack volatile/atomic loads
533  if (!LI->isSimple()) return false;
534  Loads.push_back(LI);
535  // Direct loads are equivalent to a GEP with a zero index and then a load.
536  Operands.push_back(0);
537  } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(UR)) {
538  if (GEP->use_empty()) {
539  // Dead GEP's cause trouble later. Just remove them if we run into
540  // them.
541  GEP->eraseFromParent();
542  // TODO: This runs the above loop over and over again for dead GEPs
543  // Couldn't we just do increment the UI iterator earlier and erase the
544  // use?
545  return isSafeToPromoteArgument(Arg, isByValOrInAlloca, AAR,
546  MaxElements);
547  }
548 
549  // Ensure that all of the indices are constants.
550  for (User::op_iterator i = GEP->idx_begin(), e = GEP->idx_end();
551  i != e; ++i)
552  if (ConstantInt *C = dyn_cast<ConstantInt>(*i))
553  Operands.push_back(C->getSExtValue());
554  else
555  return false; // Not a constant operand GEP!
556 
557  // Ensure that the only users of the GEP are load instructions.
558  for (User *GEPU : GEP->users())
559  if (LoadInst *LI = dyn_cast<LoadInst>(GEPU)) {
560  // Don't hack volatile/atomic loads
561  if (!LI->isSimple()) return false;
562  Loads.push_back(LI);
563  } else {
564  // Other uses than load?
565  return false;
566  }
567  } else {
568  return false; // Not a load or a GEP.
569  }
570 
571  // Now, see if it is safe to promote this load / loads of this GEP. Loading
572  // is safe if Operands, or a prefix of Operands, is marked as safe.
573  if (!PrefixIn(Operands, SafeToUnconditionallyLoad))
574  return false;
575 
576  // See if we are already promoting a load with these indices. If not, check
577  // to make sure that we aren't promoting too many elements. If so, nothing
578  // to do.
579  if (ToPromote.find(Operands) == ToPromote.end()) {
580  if (MaxElements > 0 && ToPromote.size() == MaxElements) {
581  DEBUG(dbgs() << "argpromotion not promoting argument '"
582  << Arg->getName() << "' because it would require adding more "
583  << "than " << MaxElements << " arguments to the function.\n");
584  // We limit aggregate promotion to only promoting up to a fixed number
585  // of elements of the aggregate.
586  return false;
587  }
588  ToPromote.insert(std::move(Operands));
589  }
590  }
591 
592  if (Loads.empty()) return true; // No users, this is a dead argument.
593 
594  // Okay, now we know that the argument is only used by load instructions and
595  // it is safe to unconditionally perform all of them. Use alias analysis to
596  // check to see if the pointer is guaranteed to not be modified from entry of
597  // the function to each of the load instructions.
598 
599  // Because there could be several/many load instructions, remember which
600  // blocks we know to be transparent to the load.
602 
603  for (LoadInst *Load : Loads) {
604  // Check to see if the load is invalidated from the start of the block to
605  // the load itself.
606  BasicBlock *BB = Load->getParent();
607 
609  if (AAR.canInstructionRangeModRef(BB->front(), *Load, Loc, MRI_Mod))
610  return false; // Pointer is invalidated!
611 
612  // Now check every path from the entry block to the load for transparency.
613  // To do this, we perform a depth first search on the inverse CFG from the
614  // loading block.
615  for (BasicBlock *P : predecessors(BB)) {
616  for (BasicBlock *TranspBB : inverse_depth_first_ext(P, TranspBlocks))
617  if (AAR.canBasicBlockModify(*TranspBB, Loc))
618  return false;
619  }
620  }
621 
622  // If the path from the entry of the function to each load is free of
623  // instructions that potentially invalidate the load, we can make the
624  // transformation!
625  return true;
626 }
627 
628 /// DoPromotion - This method actually performs the promotion of the specified
629 /// arguments, and returns the new function. At this point, we know that it's
630 /// safe to do so.
631 static CallGraphNode *
633  SmallPtrSetImpl<Argument *> &ByValArgsToTransform, CallGraph &CG) {
634 
635  // Start by computing a new prototype for the function, which is the same as
636  // the old function, but has modified arguments.
637  FunctionType *FTy = F->getFunctionType();
638  std::vector<Type*> Params;
639 
640  typedef std::set<std::pair<Type *, IndicesVector>> ScalarizeTable;
641 
642  // ScalarizedElements - If we are promoting a pointer that has elements
643  // accessed out of it, keep track of which elements are accessed so that we
644  // can add one argument for each.
645  //
646  // Arguments that are directly loaded will have a zero element value here, to
647  // handle cases where there are both a direct load and GEP accesses.
648  //
649  std::map<Argument*, ScalarizeTable> ScalarizedElements;
650 
651  // OriginalLoads - Keep track of a representative load instruction from the
652  // original function so that we can tell the alias analysis implementation
653  // what the new GEP/Load instructions we are inserting look like.
654  // We need to keep the original loads for each argument and the elements
655  // of the argument that are accessed.
656  std::map<std::pair<Argument*, IndicesVector>, LoadInst*> OriginalLoads;
657 
658  // Attribute - Keep track of the parameter attributes for the arguments
659  // that we are *not* promoting. For the ones that we do promote, the parameter
660  // attributes are lost
661  SmallVector<AttributeSet, 8> AttributesVec;
662  const AttributeSet &PAL = F->getAttributes();
663 
664  // Add any return attributes.
666  AttributesVec.push_back(AttributeSet::get(F->getContext(),
667  PAL.getRetAttributes()));
668 
669  // First, determine the new argument list
670  unsigned ArgIndex = 1;
671  for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E;
672  ++I, ++ArgIndex) {
673  if (ByValArgsToTransform.count(&*I)) {
674  // Simple byval argument? Just add all the struct element types.
675  Type *AgTy = cast<PointerType>(I->getType())->getElementType();
676  StructType *STy = cast<StructType>(AgTy);
677  Params.insert(Params.end(), STy->element_begin(), STy->element_end());
678  ++NumByValArgsPromoted;
679  } else if (!ArgsToPromote.count(&*I)) {
680  // Unchanged argument
681  Params.push_back(I->getType());
682  AttributeSet attrs = PAL.getParamAttributes(ArgIndex);
683  if (attrs.hasAttributes(ArgIndex)) {
684  AttrBuilder B(attrs, ArgIndex);
685  AttributesVec.
686  push_back(AttributeSet::get(F->getContext(), Params.size(), B));
687  }
688  } else if (I->use_empty()) {
689  // Dead argument (which are always marked as promotable)
690  ++NumArgumentsDead;
691  } else {
692  // Okay, this is being promoted. This means that the only uses are loads
693  // or GEPs which are only used by loads
694 
695  // In this table, we will track which indices are loaded from the argument
696  // (where direct loads are tracked as no indices).
697  ScalarizeTable &ArgIndices = ScalarizedElements[&*I];
698  for (User *U : I->users()) {
699  Instruction *UI = cast<Instruction>(U);
700  Type *SrcTy;
701  if (LoadInst *L = dyn_cast<LoadInst>(UI))
702  SrcTy = L->getType();
703  else
704  SrcTy = cast<GetElementPtrInst>(UI)->getSourceElementType();
705  IndicesVector Indices;
706  Indices.reserve(UI->getNumOperands() - 1);
707  // Since loads will only have a single operand, and GEPs only a single
708  // non-index operand, this will record direct loads without any indices,
709  // and gep+loads with the GEP indices.
710  for (User::op_iterator II = UI->op_begin() + 1, IE = UI->op_end();
711  II != IE; ++II)
712  Indices.push_back(cast<ConstantInt>(*II)->getSExtValue());
713  // GEPs with a single 0 index can be merged with direct loads
714  if (Indices.size() == 1 && Indices.front() == 0)
715  Indices.clear();
716  ArgIndices.insert(std::make_pair(SrcTy, Indices));
717  LoadInst *OrigLoad;
718  if (LoadInst *L = dyn_cast<LoadInst>(UI))
719  OrigLoad = L;
720  else
721  // Take any load, we will use it only to update Alias Analysis
722  OrigLoad = cast<LoadInst>(UI->user_back());
723  OriginalLoads[std::make_pair(&*I, Indices)] = OrigLoad;
724  }
725 
726  // Add a parameter to the function for each element passed in.
727  for (const auto &ArgIndex : ArgIndices) {
728  // not allowed to dereference ->begin() if size() is 0
729  Params.push_back(GetElementPtrInst::getIndexedType(
730  cast<PointerType>(I->getType()->getScalarType())->getElementType(),
731  ArgIndex.second));
732  assert(Params.back());
733  }
734 
735  if (ArgIndices.size() == 1 && ArgIndices.begin()->second.empty())
736  ++NumArgumentsPromoted;
737  else
738  ++NumAggregatesPromoted;
739  }
740  }
741 
742  // Add any function attributes.
744  AttributesVec.push_back(AttributeSet::get(FTy->getContext(),
745  PAL.getFnAttributes()));
746 
747  Type *RetTy = FTy->getReturnType();
748 
749  // Construct the new function type using the new arguments.
750  FunctionType *NFTy = FunctionType::get(RetTy, Params, FTy->isVarArg());
751 
752  // Create the new function body and insert it into the module.
753  Function *NF = Function::Create(NFTy, F->getLinkage(), F->getName());
754  NF->copyAttributesFrom(F);
755 
756  // Patch the pointer to LLVM function in debug info descriptor.
757  NF->setSubprogram(F->getSubprogram());
758  F->setSubprogram(nullptr);
759 
760  DEBUG(dbgs() << "ARG PROMOTION: Promoting to:" << *NF << "\n"
761  << "From: " << *F);
762 
763  // Recompute the parameter attributes list based on the new arguments for
764  // the function.
765  NF->setAttributes(AttributeSet::get(F->getContext(), AttributesVec));
766  AttributesVec.clear();
767 
768  F->getParent()->getFunctionList().insert(F->getIterator(), NF);
769  NF->takeName(F);
770 
771  // Get a new callgraph node for NF.
772  CallGraphNode *NF_CGN = CG.getOrInsertFunction(NF);
773 
774  // Loop over all of the callers of the function, transforming the call sites
775  // to pass in the loaded pointers.
776  //
778  while (!F->use_empty()) {
779  CallSite CS(F->user_back());
780  assert(CS.getCalledFunction() == F);
781  Instruction *Call = CS.getInstruction();
782  const AttributeSet &CallPAL = CS.getAttributes();
783 
784  // Add any return attributes.
786  AttributesVec.push_back(AttributeSet::get(F->getContext(),
787  CallPAL.getRetAttributes()));
788 
789  // Loop over the operands, inserting GEP and loads in the caller as
790  // appropriate.
791  CallSite::arg_iterator AI = CS.arg_begin();
792  ArgIndex = 1;
793  for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end();
794  I != E; ++I, ++AI, ++ArgIndex)
795  if (!ArgsToPromote.count(&*I) && !ByValArgsToTransform.count(&*I)) {
796  Args.push_back(*AI); // Unmodified argument
797 
798  if (CallPAL.hasAttributes(ArgIndex)) {
799  AttrBuilder B(CallPAL, ArgIndex);
800  AttributesVec.
801  push_back(AttributeSet::get(F->getContext(), Args.size(), B));
802  }
803  } else if (ByValArgsToTransform.count(&*I)) {
804  // Emit a GEP and load for each element of the struct.
805  Type *AgTy = cast<PointerType>(I->getType())->getElementType();
806  StructType *STy = cast<StructType>(AgTy);
807  Value *Idxs[2] = {
808  ConstantInt::get(Type::getInt32Ty(F->getContext()), 0), nullptr };
809  for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
810  Idxs[1] = ConstantInt::get(Type::getInt32Ty(F->getContext()), i);
812  STy, *AI, Idxs, (*AI)->getName() + "." + Twine(i), Call);
813  // TODO: Tell AA about the new values?
814  Args.push_back(new LoadInst(Idx, Idx->getName()+".val", Call));
815  }
816  } else if (!I->use_empty()) {
817  // Non-dead argument: insert GEPs and loads as appropriate.
818  ScalarizeTable &ArgIndices = ScalarizedElements[&*I];
819  // Store the Value* version of the indices in here, but declare it now
820  // for reuse.
821  std::vector<Value*> Ops;
822  for (const auto &ArgIndex : ArgIndices) {
823  Value *V = *AI;
824  LoadInst *OrigLoad =
825  OriginalLoads[std::make_pair(&*I, ArgIndex.second)];
826  if (!ArgIndex.second.empty()) {
827  Ops.reserve(ArgIndex.second.size());
828  Type *ElTy = V->getType();
829  for (unsigned long II : ArgIndex.second) {
830  // Use i32 to index structs, and i64 for others (pointers/arrays).
831  // This satisfies GEP constraints.
832  Type *IdxTy = (ElTy->isStructTy() ?
835  Ops.push_back(ConstantInt::get(IdxTy, II));
836  // Keep track of the type we're currently indexing.
837  if (auto *ElPTy = dyn_cast<PointerType>(ElTy))
838  ElTy = ElPTy->getElementType();
839  else
840  ElTy = cast<CompositeType>(ElTy)->getTypeAtIndex(II);
841  }
842  // And create a GEP to extract those indices.
843  V = GetElementPtrInst::Create(ArgIndex.first, V, Ops,
844  V->getName() + ".idx", Call);
845  Ops.clear();
846  }
847  // Since we're replacing a load make sure we take the alignment
848  // of the previous load.
849  LoadInst *newLoad = new LoadInst(V, V->getName()+".val", Call);
850  newLoad->setAlignment(OrigLoad->getAlignment());
851  // Transfer the AA info too.
852  AAMDNodes AAInfo;
853  OrigLoad->getAAMetadata(AAInfo);
854  newLoad->setAAMetadata(AAInfo);
855 
856  Args.push_back(newLoad);
857  }
858  }
859 
860  // Push any varargs arguments on the list.
861  for (; AI != CS.arg_end(); ++AI, ++ArgIndex) {
862  Args.push_back(*AI);
863  if (CallPAL.hasAttributes(ArgIndex)) {
864  AttrBuilder B(CallPAL, ArgIndex);
865  AttributesVec.
866  push_back(AttributeSet::get(F->getContext(), Args.size(), B));
867  }
868  }
869 
870  // Add any function attributes.
872  AttributesVec.push_back(AttributeSet::get(Call->getContext(),
873  CallPAL.getFnAttributes()));
874 
876  CS.getOperandBundlesAsDefs(OpBundles);
877 
878  Instruction *New;
879  if (InvokeInst *II = dyn_cast<InvokeInst>(Call)) {
880  New = InvokeInst::Create(NF, II->getNormalDest(), II->getUnwindDest(),
881  Args, OpBundles, "", Call);
882  cast<InvokeInst>(New)->setCallingConv(CS.getCallingConv());
883  cast<InvokeInst>(New)->setAttributes(AttributeSet::get(II->getContext(),
884  AttributesVec));
885  } else {
886  New = CallInst::Create(NF, Args, OpBundles, "", Call);
887  cast<CallInst>(New)->setCallingConv(CS.getCallingConv());
888  cast<CallInst>(New)->setAttributes(AttributeSet::get(New->getContext(),
889  AttributesVec));
890  cast<CallInst>(New)->setTailCallKind(
891  cast<CallInst>(Call)->getTailCallKind());
892  }
893  New->setDebugLoc(Call->getDebugLoc());
894  Args.clear();
895  AttributesVec.clear();
896 
897  // Update the callgraph to know that the callsite has been transformed.
898  CallGraphNode *CalleeNode = CG[Call->getParent()->getParent()];
899  CalleeNode->replaceCallEdge(CS, CallSite(New), NF_CGN);
900 
901  if (!Call->use_empty()) {
902  Call->replaceAllUsesWith(New);
903  New->takeName(Call);
904  }
905 
906  // Finally, remove the old call from the program, reducing the use-count of
907  // F.
908  Call->eraseFromParent();
909  }
910 
911  // Since we have now created the new function, splice the body of the old
912  // function right into the new function, leaving the old rotting hulk of the
913  // function empty.
914  NF->getBasicBlockList().splice(NF->begin(), F->getBasicBlockList());
915 
916  // Loop over the argument list, transferring uses of the old arguments over to
917  // the new arguments, also transferring over the names as well.
918  //
919  for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(),
920  I2 = NF->arg_begin(); I != E; ++I) {
921  if (!ArgsToPromote.count(&*I) && !ByValArgsToTransform.count(&*I)) {
922  // If this is an unmodified argument, move the name and users over to the
923  // new version.
924  I->replaceAllUsesWith(&*I2);
925  I2->takeName(&*I);
926  ++I2;
927  continue;
928  }
929 
930  if (ByValArgsToTransform.count(&*I)) {
931  // In the callee, we create an alloca, and store each of the new incoming
932  // arguments into the alloca.
933  Instruction *InsertPt = &NF->begin()->front();
934 
935  // Just add all the struct element types.
936  Type *AgTy = cast<PointerType>(I->getType())->getElementType();
937  Value *TheAlloca = new AllocaInst(AgTy, nullptr, "", InsertPt);
938  StructType *STy = cast<StructType>(AgTy);
939  Value *Idxs[2] = {
940  ConstantInt::get(Type::getInt32Ty(F->getContext()), 0), nullptr };
941 
942  for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
943  Idxs[1] = ConstantInt::get(Type::getInt32Ty(F->getContext()), i);
945  AgTy, TheAlloca, Idxs, TheAlloca->getName() + "." + Twine(i),
946  InsertPt);
947  I2->setName(I->getName()+"."+Twine(i));
948  new StoreInst(&*I2++, Idx, InsertPt);
949  }
950 
951  // Anything that used the arg should now use the alloca.
952  I->replaceAllUsesWith(TheAlloca);
953  TheAlloca->takeName(&*I);
954 
955  // If the alloca is used in a call, we must clear the tail flag since
956  // the callee now uses an alloca from the caller.
957  for (User *U : TheAlloca->users()) {
959  if (!Call)
960  continue;
961  Call->setTailCall(false);
962  }
963  continue;
964  }
965 
966  if (I->use_empty())
967  continue;
968 
969  // Otherwise, if we promoted this argument, then all users are load
970  // instructions (or GEPs with only load users), and all loads should be
971  // using the new argument that we added.
972  ScalarizeTable &ArgIndices = ScalarizedElements[&*I];
973 
974  while (!I->use_empty()) {
975  if (LoadInst *LI = dyn_cast<LoadInst>(I->user_back())) {
976  assert(ArgIndices.begin()->second.empty() &&
977  "Load element should sort to front!");
978  I2->setName(I->getName()+".val");
979  LI->replaceAllUsesWith(&*I2);
980  LI->eraseFromParent();
981  DEBUG(dbgs() << "*** Promoted load of argument '" << I->getName()
982  << "' in function '" << F->getName() << "'\n");
983  } else {
984  GetElementPtrInst *GEP = cast<GetElementPtrInst>(I->user_back());
985  IndicesVector Operands;
986  Operands.reserve(GEP->getNumIndices());
987  for (User::op_iterator II = GEP->idx_begin(), IE = GEP->idx_end();
988  II != IE; ++II)
989  Operands.push_back(cast<ConstantInt>(*II)->getSExtValue());
990 
991  // GEPs with a single 0 index can be merged with direct loads
992  if (Operands.size() == 1 && Operands.front() == 0)
993  Operands.clear();
994 
995  Function::arg_iterator TheArg = I2;
996  for (ScalarizeTable::iterator It = ArgIndices.begin();
997  It->second != Operands; ++It, ++TheArg) {
998  assert(It != ArgIndices.end() && "GEP not handled??");
999  }
1000 
1001  std::string NewName = I->getName();
1002  for (unsigned i = 0, e = Operands.size(); i != e; ++i) {
1003  NewName += "." + utostr(Operands[i]);
1004  }
1005  NewName += ".val";
1006  TheArg->setName(NewName);
1007 
1008  DEBUG(dbgs() << "*** Promoted agg argument '" << TheArg->getName()
1009  << "' of function '" << NF->getName() << "'\n");
1010 
1011  // All of the uses must be load instructions. Replace them all with
1012  // the argument specified by ArgNo.
1013  while (!GEP->use_empty()) {
1014  LoadInst *L = cast<LoadInst>(GEP->user_back());
1015  L->replaceAllUsesWith(&*TheArg);
1016  L->eraseFromParent();
1017  }
1018  GEP->eraseFromParent();
1019  }
1020  }
1021 
1022  // Increment I2 past all of the arguments added for this promoted pointer.
1023  std::advance(I2, ArgIndices.size());
1024  }
1025 
1026  NF_CGN->stealCalledFunctionsFrom(CG[F]);
1027 
1028  // Now that the old function is dead, delete it. If there is a dangling
1029  // reference to the CallgraphNode, just leave the dead function around for
1030  // someone else to nuke.
1031  CallGraphNode *CGN = CG[F];
1032  if (CGN->getNumReferences() == 0)
1033  delete CG.removeFunctionFromModule(CGN);
1034  else
1036 
1037  return NF_CGN;
1038 }
1039 
1040 bool ArgPromotion::doInitialization(CallGraph &CG) {
1042 }
MachineLoop * L
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:81
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:76
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:102
LinkageTypes getLinkage() const
Definition: GlobalValue.h:429
iterator_range< use_iterator > uses()
Definition: Value.h:326
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
STATISTIC(NumFunctions,"Total number of functions")
AttributeSet getParamAttributes(unsigned Index) const
The attributes for the specified index are returned.
Definition: Attributes.cpp:968
size_t i
BasicAAResult createLegacyPMBasicAAResult(Pass &P, Function &F)
A helper for the legacy pass manager to create a BasicAAResult object populated to the best of our ab...
unsigned getNumOperands() const
Definition: User.h:167
This class represents a function call, abstracting a target machine's calling convention.
size_type count(PtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:380
An immutable pass that tracks lazily created AssumptionCache objects.
virtual bool doInitialization(CallGraph &CG)
doInitialization - This method is called before the SCC's of the program has been processed...
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:83
static bool isDenselyPacked(Type *type, const DataLayout &DL)
Checks if a type could have padding bytes.
Externally visible function.
Definition: GlobalValue.h:49
arg_iterator arg_end()
Definition: Function.h:559
iterator_range< idf_ext_iterator< T, SetTy > > inverse_depth_first_ext(const T &G, SetTy &S)
const Instruction & front() const
Definition: BasicBlock.h:240
The two locations do not alias at all.
Definition: AliasAnalysis.h:79
An instruction for reading from memory.
Definition: Instructions.h:164
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:170
Hexagon Common GEP
A node in the call graph for a module.
Definition: CallGraph.h:171
void getAnalysisUsage(AnalysisUsage &Info) const override
getAnalysisUsage - For this class, we declare that we require and preserve the call graph...
unsigned getNumIndices() const
The access modifies the value stored in memory.
op_iterator op_begin()
Definition: User.h:205
uint64_t getTypeAllocSizeInBits(Type *Ty) const
Returns the offset in bits between successive objects of the specified type, including alignment padd...
Definition: DataLayout.h:418
AttributeSet getRetAttributes() const
The attributes for the ret value are returned.
Definition: Attributes.cpp:976
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:191
Function * getFunction() const
Returns the function that this call graph node represents.
Definition: CallGraph.h:191
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:345
unsigned getNumReferences() const
Returns the number of other CallGraphNodes in this CallGraph that reference this node in their callee...
Definition: CallGraph.h:202
element_iterator element_end() const
Definition: DerivedTypes.h:280
INITIALIZE_PASS_BEGIN(ArgPromotion,"argpromotion","Promote 'by reference' arguments to scalars", false, false) INITIALIZE_PASS_END(ArgPromotion
AnalysisUsage & addRequired()
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
Definition: DataLayout.h:496
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:53
Promote by reference arguments to scalars
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
const StructLayout * getStructLayout(StructType *Ty) const
Returns a StructLayout object, indicating the alignment of the struct, its size, and the offsets of i...
Definition: DataLayout.cpp:566
Class to represent struct types.
Definition: DerivedTypes.h:199
void replaceCallEdge(CallSite CS, CallSite NewCS, CallGraphNode *NewNode)
Replaces the edge in the node for the specified call site with a new one.
Definition: CallGraph.cpp:246
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
void initializeArgPromotionPass(PassRegistry &)
static void advance(T &it, size_t Val)
Pass * createArgumentPromotionPass(unsigned maxElements=3)
createArgumentPromotionPass - This pass promotes "by reference" arguments to be passed by value if th...
Function * removeFunctionFromModule(CallGraphNode *CGN)
Unlink the function from this module, returning it.
Definition: CallGraph.cpp:137
element_iterator element_begin() const
Definition: DerivedTypes.h:279
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:257
AAResults createLegacyPMAAResults(Pass &P, Function &F, BasicAAResult &BAR)
A helper for the legacy pass manager to create a AAResults object populated to the best of our abilit...
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:60
This file provides interfaces used to build and manipulate a call graph, which is a very useful tool ...
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
static bool isSafeToPromoteArgument(Argument *Arg, bool isByVal, AAResults &AAR, unsigned MaxElements)
isSafeToPromoteArgument - As you might guess from the name of this method, it checks to see if it is ...
op_iterator idx_begin()
Definition: Instructions.h:956
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 std::string utostr(uint64_t X, bool isNeg=false)
Definition: StringExtras.h:79
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
An instruction for storing to memory.
Definition: Instructions.h:300
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:401
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:263
virtual bool doInitialization(Module &)
doInitialization - Virtual method overridden by subclasses to do any necessary initialization before ...
Definition: Pass.h:110
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
Definition: Type.h:254
an instruction for type-safe pointer arithmetic to access elements of arrays and structs ...
Definition: Instructions.h:830
#define P(N)
static MemoryLocation get(const LoadInst *LI)
Return a location with information about the memory reference by the given instruction.
void setSubprogram(DISubprogram *SP)
Set the attached subprogram.
Definition: Metadata.cpp:1454
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:256
The ModulePass which wraps up a CallGraph and the logic to build it.
Definition: CallGraph.h:328
void setAAMetadata(const AAMDNodes &N)
Sets the metadata on this instruction from the AAMDNodes structure.
Definition: Metadata.cpp:1222
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
const Function * getParent() const
Definition: Argument.h:48
bool canInstructionRangeModRef(const Instruction &I1, const Instruction &I2, const MemoryLocation &Loc, const ModRefInfo Mode)
Check if it is possible for the execution of the specified instructions to mod(according to the mode)...
void stealCalledFunctionsFrom(CallGraphNode *N)
Moves all the callee information from N to this node.
Definition: CallGraph.h:229
Type * getElementType(unsigned N) const
Definition: DerivedTypes.h:290
This file contains the declarations for the subclasses of Constant, which represent the different fla...
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:368
Represent the analysis usage information of a pass.
op_iterator op_end()
Definition: User.h:207
static bool canPaddingBeAccessed(Argument *Arg)
Checks if the padding bytes of an argument could be accessed.
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE,"Assign register bank of generic virtual registers", false, false) RegBankSelect
static const unsigned End
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
void setAlignment(unsigned Align)
LLVM_NODISCARD bool empty() const
Definition: SmallPtrSet.h:98
void setTailCall(bool isTC=true)
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:654
void getAAResultsAnalysisUsage(AnalysisUsage &AU)
A helper for the legacy pass manager to populate AU to add uses to make sure the analyses required by...
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:857
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)
bool hasByValAttr() const
Return true if this argument has the byval attribute on it in its containing function.
Definition: Function.cpp:85
const FunctionListType & getFunctionList() const
Get the Module's list of functions (constant).
Definition: Module.h:478
Representation for a specific memory location.
This is the superclass of the array and vector type classes.
Definition: DerivedTypes.h:319
Iterator for intrusive lists based on ilist_node.
const BasicBlockListType & getBasicBlockList() const
Definition: Function.h:512
This is the shared class of boolean and integer constants.
Definition: Constants.h:88
ValTy * getArgument(unsigned ArgNo) const
Definition: CallSite.h:178
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
Instruction * user_back()
Specialize the methods defined in Value, as we know that an instruction can only be used by other ins...
Definition: Instruction.h:59
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:625
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:558
pred_range predecessors(BasicBlock *BB)
Definition: IR/CFG.h:110
void setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:424
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
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
static CallGraphNode * PromoteArguments(CallGraphNode *CGN, CallGraph &CG, function_ref< AAResults &(Function &F)> AARGetter, unsigned MaxElements)
PromoteArguments - This method checks the specified function to see if there are any promotable argum...
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1458
StringRef getName() const
Return the name for this struct type if it has an identity.
Definition: Type.cpp:510
iterator_range< user_iterator > users()
Definition: Value.h:370
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:464
AttributeSet removeAttribute(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const
Remove the specified attribute at the specified index from this attribute list.
Definition: Attributes.cpp:845
void setAttributes(AttributeSet Attrs)
Set the attribute list for this Function.
Definition: Function.h:179
bool isStructTy() const
True if this is an instance of StructType.
Definition: Type.h:207
static Type * getIndexedType(Type *Ty, ArrayRef< Value * > IdxList)
Returns the type of the element that would be loaded with a load instruction with the specified param...
static void MarkIndicesSafe(const IndicesVector &ToMark, std::set< IndicesVector > &Safe)
Mark the given indices (ToMark) as safe in the given set of indices (Safe).
static bool PrefixIn(const IndicesVector &Indices, std::set< IndicesVector > &Set)
Checks if Indices, or a prefix of Indices, is in Set.
bool isDereferenceablePointer(const Value *V, const DataLayout &DL, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr)
Return true if this is always a dereferenceable pointer.
Definition: Loads.cpp:143
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:384
The basic data container for the call graph of a Module of IR.
Definition: CallGraph.h:76
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:119
iterator insert(iterator where, pointer New)
Definition: ilist.h:241
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:169
std::vector< uint64_t > IndicesVector
A vector used to hold the indices of a single GEP instruction.
bool hasAttributes(unsigned Index) const
Return true if attribute exists at the given index.
unsigned getAlignment() const
Return the alignment of the access that is being performed.
Definition: Instructions.h:227
void getAAMetadata(AAMDNodes &N, bool Merge=false) const
Fills the AAMDNodes structure with AA metadata from this instruction.
static bool runImpl(CallGraphSCC &SCC, CallGraph &CG, function_ref< AAResults &(Function &F)> AARGetter, unsigned MaxElements)
#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
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
static CallGraphNode * DoPromotion(Function *F, SmallPtrSetImpl< Argument * > &ArgsToPromote, SmallPtrSetImpl< Argument * > &ByValArgsToTransform, CallGraph &CG)
DoPromotion - This method actually performs the promotion of the specified arguments, and returns the new function.
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())
user_iterator user_begin()
Definition: Value.h:346
const BasicBlock & front() const
Definition: Function.h:542
static bool AllCallersPassInValidPointerForArgument(Argument *Arg)
AllCallersPassInValidPointerForArgument - Return true if we can prove that all callees pass in a vali...
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:537
LLVM Value Representation.
Definition: Value.h:71
CallGraphSCC - This is a single SCC that a CallGraphSCCPass is run on.
CallGraphNode * getOrInsertFunction(const Function *F)
Similar to operator[], but this will insert a new CallGraphNode for F if one does not already exist...
Definition: CallGraph.cpp:165
unsigned getArgNo() const
Return the index of this formal argument in its containing function.
Definition: Function.cpp:57
uint64_t getTypeSizeInBits(Type *Ty) const
Size examples:
Definition: DataLayout.h:533
Invoke instruction.
#define DEBUG(X)
Definition: Debug.h:100
Promote by reference arguments to false
static bool IsPrefix(const IndicesVector &Prefix, const IndicesVector &Longer)
Returns true if Prefix is a prefix of longer.
This is the interface for LLVM's primary stateless and local alias analysis.
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, const Twine &N="", Module *M=nullptr)
Definition: Function.h:117
unsigned getNumElements() const
Random access to the elements.
Definition: DerivedTypes.h:289
void emplace(ArgTypes &&...Args)
Create a new object by constructing it in place with the given arguments.
Definition: Optional.h:75
bool isVarArg() const
isVarArg - Return true if this function takes a variable number of arguments.
Definition: Function.cpp:234
bool canBasicBlockModify(const BasicBlock &BB, const MemoryLocation &Loc)
Check if it is possible for execution of the specified basic block to modify the location Loc...
iterator_range< arg_iterator > args()
Definition: Function.h:568
User * user_back()
Definition: Value.h:356
an instruction to allocate memory on the stack
Definition: Instructions.h:60
AttributeSet getFnAttributes() const
The function attributes are returned.
Definition: Attributes.cpp:985
user_iterator user_end()
Definition: Value.h:354