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