LLVM  14.0.0git
ArgumentPromotion.cpp
Go to the documentation of this file.
1 //===- ArgumentPromotion.cpp - Promote by-reference arguments -------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This pass promotes "by reference" arguments to be "by value" arguments. In
10 // practice, this means looking for internal functions that have pointer
11 // arguments. If it can prove, through the use of alias analysis, that an
12 // argument is *only* loaded, then it can pass the value into the function
13 // instead of the address of the value. This can cause recursive simplification
14 // of code and lead to the elimination of allocas (especially in C++ template
15 // code like the STL).
16 //
17 // This pass also handles aggregate arguments that are passed into a function,
18 // scalarizing them if the elements of the aggregate are only loaded. Note that
19 // by default it refuses to scalarize aggregates which would require passing in
20 // more than three operands to the function, because passing thousands of
21 // operands for a large array or structure is unprofitable! This limit can be
22 // configured or disabled, however.
23 //
24 // Note that this transformation could also be done for arguments that are only
25 // stored to (returning the value instead), but does not currently. This case
26 // would be best handled when and if LLVM begins supporting multiple return
27 // values from functions.
28 //
29 //===----------------------------------------------------------------------===//
30 
33 #include "llvm/ADT/None.h"
34 #include "llvm/ADT/Optional.h"
35 #include "llvm/ADT/STLExtras.h"
36 #include "llvm/ADT/ScopeExit.h"
37 #include "llvm/ADT/SmallPtrSet.h"
38 #include "llvm/ADT/SmallVector.h"
39 #include "llvm/ADT/Statistic.h"
40 #include "llvm/ADT/Twine.h"
47 #include "llvm/Analysis/Loads.h"
51 #include "llvm/IR/Argument.h"
52 #include "llvm/IR/Attributes.h"
53 #include "llvm/IR/BasicBlock.h"
54 #include "llvm/IR/CFG.h"
55 #include "llvm/IR/Constants.h"
56 #include "llvm/IR/DataLayout.h"
57 #include "llvm/IR/DerivedTypes.h"
58 #include "llvm/IR/Function.h"
59 #include "llvm/IR/IRBuilder.h"
60 #include "llvm/IR/InstrTypes.h"
61 #include "llvm/IR/Instruction.h"
62 #include "llvm/IR/Instructions.h"
63 #include "llvm/IR/Metadata.h"
64 #include "llvm/IR/Module.h"
65 #include "llvm/IR/NoFolder.h"
66 #include "llvm/IR/PassManager.h"
67 #include "llvm/IR/Type.h"
68 #include "llvm/IR/Use.h"
69 #include "llvm/IR/User.h"
70 #include "llvm/IR/Value.h"
71 #include "llvm/InitializePasses.h"
72 #include "llvm/Pass.h"
73 #include "llvm/Support/Casting.h"
74 #include "llvm/Support/Debug.h"
77 #include "llvm/Transforms/IPO.h"
78 #include <algorithm>
79 #include <cassert>
80 #include <cstdint>
81 #include <functional>
82 #include <iterator>
83 #include <map>
84 #include <set>
85 #include <utility>
86 #include <vector>
87 
88 using namespace llvm;
89 
90 #define DEBUG_TYPE "argpromotion"
91 
92 STATISTIC(NumArgumentsPromoted, "Number of pointer arguments promoted");
93 STATISTIC(NumAggregatesPromoted, "Number of aggregate arguments promoted");
94 STATISTIC(NumByValArgsPromoted, "Number of byval arguments promoted");
95 STATISTIC(NumArgumentsDead, "Number of dead pointer args eliminated");
96 
97 /// A vector used to hold the indices of a single GEP instruction
98 using IndicesVector = std::vector<uint64_t>;
99 
100 /// DoPromotion - This method actually performs the promotion of the specified
101 /// arguments, and returns the new function. At this point, we know that it's
102 /// safe to do so.
103 static Function *
105  SmallPtrSetImpl<Argument *> &ByValArgsToTransform,
106  Optional<function_ref<void(CallBase &OldCS, CallBase &NewCS)>>
107  ReplaceCallSite) {
108  // Start by computing a new prototype for the function, which is the same as
109  // the old function, but has modified arguments.
110  FunctionType *FTy = F->getFunctionType();
111  std::vector<Type *> Params;
112 
113  using ScalarizeTable = std::set<std::pair<Type *, IndicesVector>>;
114 
115  // ScalarizedElements - If we are promoting a pointer that has elements
116  // accessed out of it, keep track of which elements are accessed so that we
117  // can add one argument for each.
118  //
119  // Arguments that are directly loaded will have a zero element value here, to
120  // handle cases where there are both a direct load and GEP accesses.
121  std::map<Argument *, ScalarizeTable> ScalarizedElements;
122 
123  // OriginalLoads - Keep track of a representative load instruction from the
124  // original function so that we can tell the alias analysis implementation
125  // what the new GEP/Load instructions we are inserting look like.
126  // We need to keep the original loads for each argument and the elements
127  // of the argument that are accessed.
128  std::map<std::pair<Argument *, IndicesVector>, LoadInst *> OriginalLoads;
129 
130  // Attribute - Keep track of the parameter attributes for the arguments
131  // that we are *not* promoting. For the ones that we do promote, the parameter
132  // attributes are lost
133  SmallVector<AttributeSet, 8> ArgAttrVec;
134  AttributeList PAL = F->getAttributes();
135 
136  // First, determine the new argument list
137  unsigned ArgNo = 0;
138  for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E;
139  ++I, ++ArgNo) {
140  if (ByValArgsToTransform.count(&*I)) {
141  // Simple byval argument? Just add all the struct element types.
142  Type *AgTy = I->getParamByValType();
143  StructType *STy = cast<StructType>(AgTy);
144  llvm::append_range(Params, STy->elements());
145  ArgAttrVec.insert(ArgAttrVec.end(), STy->getNumElements(),
146  AttributeSet());
147  ++NumByValArgsPromoted;
148  } else if (!ArgsToPromote.count(&*I)) {
149  // Unchanged argument
150  Params.push_back(I->getType());
151  ArgAttrVec.push_back(PAL.getParamAttrs(ArgNo));
152  } else if (I->use_empty()) {
153  // Dead argument (which are always marked as promotable)
154  ++NumArgumentsDead;
155  } else {
156  // Okay, this is being promoted. This means that the only uses are loads
157  // or GEPs which are only used by loads
158 
159  // In this table, we will track which indices are loaded from the argument
160  // (where direct loads are tracked as no indices).
161  ScalarizeTable &ArgIndices = ScalarizedElements[&*I];
162  for (User *U : make_early_inc_range(I->users())) {
163  Instruction *UI = cast<Instruction>(U);
164  Type *SrcTy;
165  if (LoadInst *L = dyn_cast<LoadInst>(UI))
166  SrcTy = L->getType();
167  else
168  SrcTy = cast<GetElementPtrInst>(UI)->getSourceElementType();
169  // Skip dead GEPs and remove them.
170  if (isa<GetElementPtrInst>(UI) && UI->use_empty()) {
171  UI->eraseFromParent();
172  continue;
173  }
174 
175  IndicesVector Indices;
176  Indices.reserve(UI->getNumOperands() - 1);
177  // Since loads will only have a single operand, and GEPs only a single
178  // non-index operand, this will record direct loads without any indices,
179  // and gep+loads with the GEP indices.
180  for (User::op_iterator II = UI->op_begin() + 1, IE = UI->op_end();
181  II != IE; ++II)
182  Indices.push_back(cast<ConstantInt>(*II)->getSExtValue());
183  // GEPs with a single 0 index can be merged with direct loads
184  if (Indices.size() == 1 && Indices.front() == 0)
185  Indices.clear();
186  ArgIndices.insert(std::make_pair(SrcTy, Indices));
187  LoadInst *OrigLoad;
188  if (LoadInst *L = dyn_cast<LoadInst>(UI))
189  OrigLoad = L;
190  else
191  // Take any load, we will use it only to update Alias Analysis
192  OrigLoad = cast<LoadInst>(UI->user_back());
193  OriginalLoads[std::make_pair(&*I, Indices)] = OrigLoad;
194  }
195 
196  // Add a parameter to the function for each element passed in.
197  for (const auto &ArgIndex : ArgIndices) {
198  // not allowed to dereference ->begin() if size() is 0
199  Params.push_back(GetElementPtrInst::getIndexedType(
200  cast<PointerType>(I->getType())->getElementType(),
201  ArgIndex.second));
202  ArgAttrVec.push_back(AttributeSet());
203  assert(Params.back());
204  }
205 
206  if (ArgIndices.size() == 1 && ArgIndices.begin()->second.empty())
207  ++NumArgumentsPromoted;
208  else
209  ++NumAggregatesPromoted;
210  }
211  }
212 
213  Type *RetTy = FTy->getReturnType();
214 
215  // Construct the new function type using the new arguments.
216  FunctionType *NFTy = FunctionType::get(RetTy, Params, FTy->isVarArg());
217 
218  // Create the new function body and insert it into the module.
219  Function *NF = Function::Create(NFTy, F->getLinkage(), F->getAddressSpace(),
220  F->getName());
221  NF->copyAttributesFrom(F);
222  NF->copyMetadata(F, 0);
223 
224  // The new function will have the !dbg metadata copied from the original
225  // function. The original function may not be deleted, and dbg metadata need
226  // to be unique so we need to drop it.
227  F->setSubprogram(nullptr);
228 
229  LLVM_DEBUG(dbgs() << "ARG PROMOTION: Promoting to:" << *NF << "\n"
230  << "From: " << *F);
231 
232  // Recompute the parameter attributes list based on the new arguments for
233  // the function.
234  NF->setAttributes(AttributeList::get(F->getContext(), PAL.getFnAttrs(),
235  PAL.getRetAttrs(), ArgAttrVec));
236  ArgAttrVec.clear();
237 
238  F->getParent()->getFunctionList().insert(F->getIterator(), NF);
239  NF->takeName(F);
240 
241  // Loop over all of the callers of the function, transforming the call sites
242  // to pass in the loaded pointers.
243  //
245  const DataLayout &DL = F->getParent()->getDataLayout();
246  while (!F->use_empty()) {
247  CallBase &CB = cast<CallBase>(*F->user_back());
248  assert(CB.getCalledFunction() == F);
249  const AttributeList &CallPAL = CB.getAttributes();
250  IRBuilder<NoFolder> IRB(&CB);
251 
252  // Loop over the operands, inserting GEP and loads in the caller as
253  // appropriate.
254  auto AI = CB.arg_begin();
255  ArgNo = 0;
256  for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E;
257  ++I, ++AI, ++ArgNo)
258  if (!ArgsToPromote.count(&*I) && !ByValArgsToTransform.count(&*I)) {
259  Args.push_back(*AI); // Unmodified argument
260  ArgAttrVec.push_back(CallPAL.getParamAttrs(ArgNo));
261  } else if (ByValArgsToTransform.count(&*I)) {
262  // Emit a GEP and load for each element of the struct.
263  Type *AgTy = I->getParamByValType();
264  StructType *STy = cast<StructType>(AgTy);
265  Value *Idxs[2] = {
266  ConstantInt::get(Type::getInt32Ty(F->getContext()), 0), nullptr};
267  const StructLayout *SL = DL.getStructLayout(STy);
268  Align StructAlign = *I->getParamAlign();
269  for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
270  Idxs[1] = ConstantInt::get(Type::getInt32Ty(F->getContext()), i);
271  auto *Idx =
272  IRB.CreateGEP(STy, *AI, Idxs, (*AI)->getName() + "." + Twine(i));
273  // TODO: Tell AA about the new values?
274  Align Alignment =
275  commonAlignment(StructAlign, SL->getElementOffset(i));
276  Args.push_back(IRB.CreateAlignedLoad(
277  STy->getElementType(i), Idx, Alignment, Idx->getName() + ".val"));
278  ArgAttrVec.push_back(AttributeSet());
279  }
280  } else if (!I->use_empty()) {
281  // Non-dead argument: insert GEPs and loads as appropriate.
282  ScalarizeTable &ArgIndices = ScalarizedElements[&*I];
283  // Store the Value* version of the indices in here, but declare it now
284  // for reuse.
285  std::vector<Value *> Ops;
286  for (const auto &ArgIndex : ArgIndices) {
287  Value *V = *AI;
288  LoadInst *OrigLoad =
289  OriginalLoads[std::make_pair(&*I, ArgIndex.second)];
290  if (!ArgIndex.second.empty()) {
291  Ops.reserve(ArgIndex.second.size());
292  Type *ElTy = V->getType();
293  for (auto II : ArgIndex.second) {
294  // Use i32 to index structs, and i64 for others (pointers/arrays).
295  // This satisfies GEP constraints.
296  Type *IdxTy =
297  (ElTy->isStructTy() ? Type::getInt32Ty(F->getContext())
298  : Type::getInt64Ty(F->getContext()));
299  Ops.push_back(ConstantInt::get(IdxTy, II));
300  // Keep track of the type we're currently indexing.
301  if (auto *ElPTy = dyn_cast<PointerType>(ElTy))
302  ElTy = ElPTy->getElementType();
303  else
304  ElTy = GetElementPtrInst::getTypeAtIndex(ElTy, II);
305  }
306  // And create a GEP to extract those indices.
307  V = IRB.CreateGEP(ArgIndex.first, V, Ops, V->getName() + ".idx");
308  Ops.clear();
309  }
310  // Since we're replacing a load make sure we take the alignment
311  // of the previous load.
312  LoadInst *newLoad =
313  IRB.CreateLoad(OrigLoad->getType(), V, V->getName() + ".val");
314  newLoad->setAlignment(OrigLoad->getAlign());
315  // Transfer the AA info too.
316  newLoad->setAAMetadata(OrigLoad->getAAMetadata());
317 
318  Args.push_back(newLoad);
319  ArgAttrVec.push_back(AttributeSet());
320  }
321  }
322 
323  // Push any varargs arguments on the list.
324  for (; AI != CB.arg_end(); ++AI, ++ArgNo) {
325  Args.push_back(*AI);
326  ArgAttrVec.push_back(CallPAL.getParamAttrs(ArgNo));
327  }
328 
330  CB.getOperandBundlesAsDefs(OpBundles);
331 
332  CallBase *NewCS = nullptr;
333  if (InvokeInst *II = dyn_cast<InvokeInst>(&CB)) {
334  NewCS = InvokeInst::Create(NF, II->getNormalDest(), II->getUnwindDest(),
335  Args, OpBundles, "", &CB);
336  } else {
337  auto *NewCall = CallInst::Create(NF, Args, OpBundles, "", &CB);
338  NewCall->setTailCallKind(cast<CallInst>(&CB)->getTailCallKind());
339  NewCS = NewCall;
340  }
341  NewCS->setCallingConv(CB.getCallingConv());
342  NewCS->setAttributes(AttributeList::get(F->getContext(),
343  CallPAL.getFnAttrs(),
344  CallPAL.getRetAttrs(), ArgAttrVec));
345  NewCS->copyMetadata(CB, {LLVMContext::MD_prof, LLVMContext::MD_dbg});
346  Args.clear();
347  ArgAttrVec.clear();
348 
349  // Update the callgraph to know that the callsite has been transformed.
350  if (ReplaceCallSite)
351  (*ReplaceCallSite)(CB, *NewCS);
352 
353  if (!CB.use_empty()) {
354  CB.replaceAllUsesWith(NewCS);
355  NewCS->takeName(&CB);
356  }
357 
358  // Finally, remove the old call from the program, reducing the use-count of
359  // F.
360  CB.eraseFromParent();
361  }
362 
363  // Since we have now created the new function, splice the body of the old
364  // function right into the new function, leaving the old rotting hulk of the
365  // function empty.
366  NF->getBasicBlockList().splice(NF->begin(), F->getBasicBlockList());
367 
368  // Loop over the argument list, transferring uses of the old arguments over to
369  // the new arguments, also transferring over the names as well.
370  for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(),
371  I2 = NF->arg_begin();
372  I != E; ++I) {
373  if (!ArgsToPromote.count(&*I) && !ByValArgsToTransform.count(&*I)) {
374  // If this is an unmodified argument, move the name and users over to the
375  // new version.
376  I->replaceAllUsesWith(&*I2);
377  I2->takeName(&*I);
378  ++I2;
379  continue;
380  }
381 
382  if (ByValArgsToTransform.count(&*I)) {
383  // In the callee, we create an alloca, and store each of the new incoming
384  // arguments into the alloca.
385  Instruction *InsertPt = &NF->begin()->front();
386 
387  // Just add all the struct element types.
388  Type *AgTy = I->getParamByValType();
389  Align StructAlign = *I->getParamAlign();
390  Value *TheAlloca = new AllocaInst(AgTy, DL.getAllocaAddrSpace(), nullptr,
391  StructAlign, "", InsertPt);
392  StructType *STy = cast<StructType>(AgTy);
393  Value *Idxs[2] = {ConstantInt::get(Type::getInt32Ty(F->getContext()), 0),
394  nullptr};
395  const StructLayout *SL = DL.getStructLayout(STy);
396 
397  for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
398  Idxs[1] = ConstantInt::get(Type::getInt32Ty(F->getContext()), i);
400  AgTy, TheAlloca, Idxs, TheAlloca->getName() + "." + Twine(i),
401  InsertPt);
402  I2->setName(I->getName() + "." + Twine(i));
403  Align Alignment = commonAlignment(StructAlign, SL->getElementOffset(i));
404  new StoreInst(&*I2++, Idx, false, Alignment, InsertPt);
405  }
406 
407  // Anything that used the arg should now use the alloca.
408  I->replaceAllUsesWith(TheAlloca);
409  TheAlloca->takeName(&*I);
410  continue;
411  }
412 
413  // There potentially are metadata uses for things like llvm.dbg.value.
414  // Replace them with undef, after handling the other regular uses.
415  auto RauwUndefMetadata = make_scope_exit(
416  [&]() { I->replaceAllUsesWith(UndefValue::get(I->getType())); });
417 
418  if (I->use_empty())
419  continue;
420 
421  // Otherwise, if we promoted this argument, then all users are load
422  // instructions (or GEPs with only load users), and all loads should be
423  // using the new argument that we added.
424  ScalarizeTable &ArgIndices = ScalarizedElements[&*I];
425 
426  while (!I->use_empty()) {
427  if (LoadInst *LI = dyn_cast<LoadInst>(I->user_back())) {
428  assert(ArgIndices.begin()->second.empty() &&
429  "Load element should sort to front!");
430  I2->setName(I->getName() + ".val");
431  LI->replaceAllUsesWith(&*I2);
432  LI->eraseFromParent();
433  LLVM_DEBUG(dbgs() << "*** Promoted load of argument '" << I->getName()
434  << "' in function '" << F->getName() << "'\n");
435  } else {
436  GetElementPtrInst *GEP = cast<GetElementPtrInst>(I->user_back());
437  assert(!GEP->use_empty() &&
438  "GEPs without uses should be cleaned up already");
440  Operands.reserve(GEP->getNumIndices());
441  for (const Use &Idx : GEP->indices())
442  Operands.push_back(cast<ConstantInt>(Idx)->getSExtValue());
443 
444  // GEPs with a single 0 index can be merged with direct loads
445  if (Operands.size() == 1 && Operands.front() == 0)
446  Operands.clear();
447 
448  Function::arg_iterator TheArg = I2;
449  for (ScalarizeTable::iterator It = ArgIndices.begin();
450  It->second != Operands; ++It, ++TheArg) {
451  assert(It != ArgIndices.end() && "GEP not handled??");
452  }
453 
454  TheArg->setName(formatv("{0}.{1:$[.]}.val", I->getName(),
455  make_range(Operands.begin(), Operands.end())));
456 
457  LLVM_DEBUG(dbgs() << "*** Promoted agg argument '" << TheArg->getName()
458  << "' of function '" << NF->getName() << "'\n");
459 
460  // All of the uses must be load instructions. Replace them all with
461  // the argument specified by ArgNo.
462  while (!GEP->use_empty()) {
463  LoadInst *L = cast<LoadInst>(GEP->user_back());
464  L->replaceAllUsesWith(&*TheArg);
465  L->eraseFromParent();
466  }
467  GEP->eraseFromParent();
468  }
469  }
470  // Increment I2 past all of the arguments added for this promoted pointer.
471  std::advance(I2, ArgIndices.size());
472  }
473 
474  return NF;
475 }
476 
477 /// Return true if we can prove that all callees pass in a valid pointer for the
478 /// specified function argument.
480  Function *Callee = Arg->getParent();
481  const DataLayout &DL = Callee->getParent()->getDataLayout();
482 
483  unsigned ArgNo = Arg->getArgNo();
484 
485  // Look at all call sites of the function. At this point we know we only have
486  // direct callees.
487  for (User *U : Callee->users()) {
488  CallBase &CB = cast<CallBase>(*U);
489 
490  if (!isDereferenceablePointer(CB.getArgOperand(ArgNo), Ty, DL))
491  return false;
492  }
493  return true;
494 }
495 
496 /// Returns true if Prefix is a prefix of longer. That means, Longer has a size
497 /// that is greater than or equal to the size of prefix, and each of the
498 /// elements in Prefix is the same as the corresponding elements in Longer.
499 ///
500 /// This means it also returns true when Prefix and Longer are equal!
501 static bool isPrefix(const IndicesVector &Prefix, const IndicesVector &Longer) {
502  if (Prefix.size() > Longer.size())
503  return false;
504  return std::equal(Prefix.begin(), Prefix.end(), Longer.begin());
505 }
506 
507 /// Checks if Indices, or a prefix of Indices, is in Set.
508 static bool prefixIn(const IndicesVector &Indices,
509  std::set<IndicesVector> &Set) {
510  std::set<IndicesVector>::iterator Low;
511  Low = Set.upper_bound(Indices);
512  if (Low != Set.begin())
513  Low--;
514  // Low is now the last element smaller than or equal to Indices. This means
515  // it points to a prefix of Indices (possibly Indices itself), if such
516  // prefix exists.
517  //
518  // This load is safe if any prefix of its operands is safe to load.
519  return Low != Set.end() && isPrefix(*Low, Indices);
520 }
521 
522 /// Mark the given indices (ToMark) as safe in the given set of indices
523 /// (Safe). Marking safe usually means adding ToMark to Safe. However, if there
524 /// is already a prefix of Indices in Safe, Indices are implicitely marked safe
525 /// already. Furthermore, any indices that Indices is itself a prefix of, are
526 /// removed from Safe (since they are implicitely safe because of Indices now).
527 static void markIndicesSafe(const IndicesVector &ToMark,
528  std::set<IndicesVector> &Safe) {
529  std::set<IndicesVector>::iterator Low;
530  Low = Safe.upper_bound(ToMark);
531  // Guard against the case where Safe is empty
532  if (Low != Safe.begin())
533  Low--;
534  // Low is now the last element smaller than or equal to Indices. This
535  // means it points to a prefix of Indices (possibly Indices itself), if
536  // such prefix exists.
537  if (Low != Safe.end()) {
538  if (isPrefix(*Low, ToMark))
539  // If there is already a prefix of these indices (or exactly these
540  // indices) marked a safe, don't bother adding these indices
541  return;
542 
543  // Increment Low, so we can use it as a "insert before" hint
544  ++Low;
545  }
546  // Insert
547  Low = Safe.insert(Low, ToMark);
548  ++Low;
549  // If there we're a prefix of longer index list(s), remove those
550  std::set<IndicesVector>::iterator End = Safe.end();
551  while (Low != End && isPrefix(ToMark, *Low)) {
552  std::set<IndicesVector>::iterator Remove = Low;
553  ++Low;
554  Safe.erase(Remove);
555  }
556 }
557 
558 /// isSafeToPromoteArgument - As you might guess from the name of this method,
559 /// it checks to see if it is both safe and useful to promote the argument.
560 /// This method limits promotion of aggregates to only promote up to three
561 /// elements of the aggregate in order to avoid exploding the number of
562 /// arguments passed in.
563 static bool isSafeToPromoteArgument(Argument *Arg, Type *ByValTy, AAResults &AAR,
564  unsigned MaxElements) {
565  using GEPIndicesSet = std::set<IndicesVector>;
566 
567  // Quick exit for unused arguments
568  if (Arg->use_empty())
569  return true;
570 
571  // We can only promote this argument if all of the uses are loads, or are GEP
572  // instructions (with constant indices) that are subsequently loaded.
573  //
574  // Promoting the argument causes it to be loaded in the caller
575  // unconditionally. This is only safe if we can prove that either the load
576  // would have happened in the callee anyway (ie, there is a load in the entry
577  // block) or the pointer passed in at every call site is guaranteed to be
578  // valid.
579  // In the former case, invalid loads can happen, but would have happened
580  // anyway, in the latter case, invalid loads won't happen. This prevents us
581  // from introducing an invalid load that wouldn't have happened in the
582  // original code.
583  //
584  // This set will contain all sets of indices that are loaded in the entry
585  // block, and thus are safe to unconditionally load in the caller.
586  GEPIndicesSet SafeToUnconditionallyLoad;
587 
588  // This set contains all the sets of indices that we are planning to promote.
589  // This makes it possible to limit the number of arguments added.
590  GEPIndicesSet ToPromote;
591 
592  // If the pointer is always valid, any load with first index 0 is valid.
593 
594  if (ByValTy)
595  SafeToUnconditionallyLoad.insert(IndicesVector(1, 0));
596 
597  // Whenever a new underlying type for the operand is found, make sure it's
598  // consistent with the GEPs and loads we've already seen and, if necessary,
599  // use it to see if all incoming pointers are valid (which implies the 0-index
600  // is safe).
601  Type *BaseTy = ByValTy;
602  auto UpdateBaseTy = [&](Type *NewBaseTy) {
603  if (BaseTy)
604  return BaseTy == NewBaseTy;
605 
606  BaseTy = NewBaseTy;
608  assert(SafeToUnconditionallyLoad.empty());
609  SafeToUnconditionallyLoad.insert(IndicesVector(1, 0));
610  }
611 
612  return true;
613  };
614 
615  // First, iterate the entry block and mark loads of (geps of) arguments as
616  // safe.
617  BasicBlock &EntryBlock = Arg->getParent()->front();
618  // Declare this here so we can reuse it
619  IndicesVector Indices;
620  for (Instruction &I : EntryBlock)
621  if (LoadInst *LI = dyn_cast<LoadInst>(&I)) {
622  Value *V = LI->getPointerOperand();
623  if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(V)) {
624  V = GEP->getPointerOperand();
625  if (V == Arg) {
626  // This load actually loads (part of) Arg? Check the indices then.
627  Indices.reserve(GEP->getNumIndices());
628  for (Use &Idx : GEP->indices())
629  if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx))
630  Indices.push_back(CI->getSExtValue());
631  else
632  // We found a non-constant GEP index for this argument? Bail out
633  // right away, can't promote this argument at all.
634  return false;
635 
636  if (!UpdateBaseTy(GEP->getSourceElementType()))
637  return false;
638 
639  // Indices checked out, mark them as safe
640  markIndicesSafe(Indices, SafeToUnconditionallyLoad);
641  Indices.clear();
642  }
643  } else if (V == Arg) {
644  // Direct loads are equivalent to a GEP with a single 0 index.
645  markIndicesSafe(IndicesVector(1, 0), SafeToUnconditionallyLoad);
646 
647  if (BaseTy && LI->getType() != BaseTy)
648  return false;
649 
650  BaseTy = LI->getType();
651  }
652  }
653 
654  // Now, iterate all uses of the argument to see if there are any uses that are
655  // not (GEP+)loads, or any (GEP+)loads that are not safe to promote.
658  for (Use &U : Arg->uses()) {
659  User *UR = U.getUser();
660  Operands.clear();
661  if (LoadInst *LI = dyn_cast<LoadInst>(UR)) {
662  // Don't hack volatile/atomic loads
663  if (!LI->isSimple())
664  return false;
665  Loads.push_back(LI);
666  // Direct loads are equivalent to a GEP with a zero index and then a load.
667  Operands.push_back(0);
668 
669  if (!UpdateBaseTy(LI->getType()))
670  return false;
671  } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(UR)) {
672  if (GEP->use_empty()) {
673  // Dead GEP's cause trouble later. Just remove them if we run into
674  // them.
675  continue;
676  }
677 
678  if (!UpdateBaseTy(GEP->getSourceElementType()))
679  return false;
680 
681  // Ensure that all of the indices are constants.
682  for (Use &Idx : GEP->indices())
683  if (ConstantInt *C = dyn_cast<ConstantInt>(Idx))
684  Operands.push_back(C->getSExtValue());
685  else
686  return false; // Not a constant operand GEP!
687 
688  // Ensure that the only users of the GEP are load instructions.
689  for (User *GEPU : GEP->users())
690  if (LoadInst *LI = dyn_cast<LoadInst>(GEPU)) {
691  // Don't hack volatile/atomic loads
692  if (!LI->isSimple())
693  return false;
694  Loads.push_back(LI);
695  } else {
696  // Other uses than load?
697  return false;
698  }
699  } else {
700  return false; // Not a load or a GEP.
701  }
702 
703  // Now, see if it is safe to promote this load / loads of this GEP. Loading
704  // is safe if Operands, or a prefix of Operands, is marked as safe.
705  if (!prefixIn(Operands, SafeToUnconditionallyLoad))
706  return false;
707 
708  // See if we are already promoting a load with these indices. If not, check
709  // to make sure that we aren't promoting too many elements. If so, nothing
710  // to do.
711  if (ToPromote.find(Operands) == ToPromote.end()) {
712  if (MaxElements > 0 && ToPromote.size() == MaxElements) {
713  LLVM_DEBUG(dbgs() << "argpromotion not promoting argument '"
714  << Arg->getName()
715  << "' because it would require adding more "
716  << "than " << MaxElements
717  << " arguments to the function.\n");
718  // We limit aggregate promotion to only promoting up to a fixed number
719  // of elements of the aggregate.
720  return false;
721  }
722  ToPromote.insert(std::move(Operands));
723  }
724  }
725 
726  if (Loads.empty())
727  return true; // No users, this is a dead argument.
728 
729  // Okay, now we know that the argument is only used by load instructions and
730  // it is safe to unconditionally perform all of them. Use alias analysis to
731  // check to see if the pointer is guaranteed to not be modified from entry of
732  // the function to each of the load instructions.
733 
734  // Because there could be several/many load instructions, remember which
735  // blocks we know to be transparent to the load.
737 
738  for (LoadInst *Load : Loads) {
739  // Check to see if the load is invalidated from the start of the block to
740  // the load itself.
741  BasicBlock *BB = Load->getParent();
742 
744  if (AAR.canInstructionRangeModRef(BB->front(), *Load, Loc, ModRefInfo::Mod))
745  return false; // Pointer is invalidated!
746 
747  // Now check every path from the entry block to the load for transparency.
748  // To do this, we perform a depth first search on the inverse CFG from the
749  // loading block.
750  for (BasicBlock *P : predecessors(BB)) {
751  for (BasicBlock *TranspBB : inverse_depth_first_ext(P, TranspBlocks))
752  if (AAR.canBasicBlockModify(*TranspBB, Loc))
753  return false;
754  }
755  }
756 
757  // If the path from the entry of the function to each load is free of
758  // instructions that potentially invalidate the load, we can make the
759  // transformation!
760  return true;
761 }
762 
764  // There is no size information, so be conservative.
765  if (!type->isSized())
766  return false;
767 
768  // If the alloc size is not equal to the storage size, then there are padding
769  // bytes. For x86_fp80 on x86-64, size: 80 alloc size: 128.
770  if (DL.getTypeSizeInBits(type) != DL.getTypeAllocSizeInBits(type))
771  return false;
772 
773  // FIXME: This isn't the right way to check for padding in vectors with
774  // non-byte-size elements.
775  if (VectorType *seqTy = dyn_cast<VectorType>(type))
776  return isDenselyPacked(seqTy->getElementType(), DL);
777 
778  // For array types, check for padding within members.
779  if (ArrayType *seqTy = dyn_cast<ArrayType>(type))
780  return isDenselyPacked(seqTy->getElementType(), DL);
781 
782  if (!isa<StructType>(type))
783  return true;
784 
785  // Check for padding within and between elements of a struct.
786  StructType *StructTy = cast<StructType>(type);
787  const StructLayout *Layout = DL.getStructLayout(StructTy);
788  uint64_t StartPos = 0;
789  for (unsigned i = 0, E = StructTy->getNumElements(); i < E; ++i) {
790  Type *ElTy = StructTy->getElementType(i);
791  if (!isDenselyPacked(ElTy, DL))
792  return false;
793  if (StartPos != Layout->getElementOffsetInBits(i))
794  return false;
795  StartPos += DL.getTypeAllocSizeInBits(ElTy);
796  }
797 
798  return true;
799 }
800 
801 /// Checks if the padding bytes of an argument could be accessed.
802 static bool canPaddingBeAccessed(Argument *arg) {
803  assert(arg->hasByValAttr());
804 
805  // Track all the pointers to the argument to make sure they are not captured.
806  SmallPtrSet<Value *, 16> PtrValues;
807  PtrValues.insert(arg);
808 
809  // Track all of the stores.
811 
812  // Scan through the uses recursively to make sure the pointer is always used
813  // sanely.
814  SmallVector<Value *, 16> WorkList(arg->users());
815  while (!WorkList.empty()) {
816  Value *V = WorkList.pop_back_val();
817  if (isa<GetElementPtrInst>(V) || isa<PHINode>(V)) {
818  if (PtrValues.insert(V).second)
819  llvm::append_range(WorkList, V->users());
820  } else if (StoreInst *Store = dyn_cast<StoreInst>(V)) {
821  Stores.push_back(Store);
822  } else if (!isa<LoadInst>(V)) {
823  return true;
824  }
825  }
826 
827  // Check to make sure the pointers aren't captured
828  for (StoreInst *Store : Stores)
829  if (PtrValues.count(Store->getValueOperand()))
830  return true;
831 
832  return false;
833 }
834 
836  const Function &F, const TargetTransformInfo &TTI,
837  SmallPtrSetImpl<Argument *> &ArgsToPromote,
838  SmallPtrSetImpl<Argument *> &ByValArgsToTransform) {
839  for (const Use &U : F.uses()) {
840  CallBase *CB = dyn_cast<CallBase>(U.getUser());
841  if (!CB)
842  return false;
843  const Function *Caller = CB->getCaller();
844  const Function *Callee = CB->getCalledFunction();
845  if (!TTI.areFunctionArgsABICompatible(Caller, Callee, ArgsToPromote) ||
846  !TTI.areFunctionArgsABICompatible(Caller, Callee, ByValArgsToTransform))
847  return false;
848  }
849  return true;
850 }
851 
852 /// PromoteArguments - This method checks the specified function to see if there
853 /// are any promotable arguments and if it is safe to promote the function (for
854 /// example, all callers are direct). If safe to promote some arguments, it
855 /// calls the DoPromotion method.
856 static Function *
858  unsigned MaxElements,
859  Optional<function_ref<void(CallBase &OldCS, CallBase &NewCS)>>
860  ReplaceCallSite,
861  const TargetTransformInfo &TTI) {
862  // Don't perform argument promotion for naked functions; otherwise we can end
863  // up removing parameters that are seemingly 'not used' as they are referred
864  // to in the assembly.
865  if(F->hasFnAttribute(Attribute::Naked))
866  return nullptr;
867 
868  // Make sure that it is local to this module.
869  if (!F->hasLocalLinkage())
870  return nullptr;
871 
872  // Don't promote arguments for variadic functions. Adding, removing, or
873  // changing non-pack parameters can change the classification of pack
874  // parameters. Frontends encode that classification at the call site in the
875  // IR, while in the callee the classification is determined dynamically based
876  // on the number of registers consumed so far.
877  if (F->isVarArg())
878  return nullptr;
879 
880  // Don't transform functions that receive inallocas, as the transformation may
881  // not be safe depending on calling convention.
882  if (F->getAttributes().hasAttrSomewhere(Attribute::InAlloca))
883  return nullptr;
884 
885  // First check: see if there are any pointer arguments! If not, quick exit.
886  SmallVector<Argument *, 16> PointerArgs;
887  for (Argument &I : F->args())
888  if (I.getType()->isPointerTy())
889  PointerArgs.push_back(&I);
890  if (PointerArgs.empty())
891  return nullptr;
892 
893  // Second check: make sure that all callers are direct callers. We can't
894  // transform functions that have indirect callers. Also see if the function
895  // is self-recursive and check that target features are compatible.
896  bool isSelfRecursive = false;
897  for (Use &U : F->uses()) {
898  CallBase *CB = dyn_cast<CallBase>(U.getUser());
899  // Must be a direct call.
900  if (CB == nullptr || !CB->isCallee(&U))
901  return nullptr;
902 
903  // Can't change signature of musttail callee
904  if (CB->isMustTailCall())
905  return nullptr;
906 
907  if (CB->getParent()->getParent() == F)
908  isSelfRecursive = true;
909  }
910 
911  // Can't change signature of musttail caller
912  // FIXME: Support promoting whole chain of musttail functions
913  for (BasicBlock &BB : *F)
914  if (BB.getTerminatingMustTailCall())
915  return nullptr;
916 
917  const DataLayout &DL = F->getParent()->getDataLayout();
918 
919  AAResults &AAR = AARGetter(*F);
920 
921  // Check to see which arguments are promotable. If an argument is promotable,
922  // add it to ArgsToPromote.
923  SmallPtrSet<Argument *, 8> ArgsToPromote;
924  SmallPtrSet<Argument *, 8> ByValArgsToTransform;
925  for (Argument *PtrArg : PointerArgs) {
926  Type *AgTy = cast<PointerType>(PtrArg->getType())->getElementType();
927 
928  // Replace sret attribute with noalias. This reduces register pressure by
929  // avoiding a register copy.
930  if (PtrArg->hasStructRetAttr()) {
931  unsigned ArgNo = PtrArg->getArgNo();
932  F->removeParamAttr(ArgNo, Attribute::StructRet);
933  F->addParamAttr(ArgNo, Attribute::NoAlias);
934  for (Use &U : F->uses()) {
935  CallBase &CB = cast<CallBase>(*U.getUser());
936  CB.removeParamAttr(ArgNo, Attribute::StructRet);
937  CB.addParamAttr(ArgNo, Attribute::NoAlias);
938  }
939  }
940 
941  // If this is a byval argument, and if the aggregate type is small, just
942  // pass the elements, which is always safe, if the passed value is densely
943  // packed or if we can prove the padding bytes are never accessed.
944  //
945  // Only handle arguments with specified alignment; if it's unspecified, the
946  // actual alignment of the argument is target-specific.
947  bool isSafeToPromote = PtrArg->hasByValAttr() && PtrArg->getParamAlign() &&
949  !canPaddingBeAccessed(PtrArg));
950  if (isSafeToPromote) {
951  if (StructType *STy = dyn_cast<StructType>(AgTy)) {
952  if (MaxElements > 0 && STy->getNumElements() > MaxElements) {
953  LLVM_DEBUG(dbgs() << "argpromotion disable promoting argument '"
954  << PtrArg->getName()
955  << "' because it would require adding more"
956  << " than " << MaxElements
957  << " arguments to the function.\n");
958  continue;
959  }
960 
961  // If all the elements are single-value types, we can promote it.
962  bool AllSimple = true;
963  for (const auto *EltTy : STy->elements()) {
964  if (!EltTy->isSingleValueType()) {
965  AllSimple = false;
966  break;
967  }
968  }
969 
970  // Safe to transform, don't even bother trying to "promote" it.
971  // Passing the elements as a scalar will allow sroa to hack on
972  // the new alloca we introduce.
973  if (AllSimple) {
974  ByValArgsToTransform.insert(PtrArg);
975  continue;
976  }
977  }
978  }
979 
980  // If the argument is a recursive type and we're in a recursive
981  // function, we could end up infinitely peeling the function argument.
982  if (isSelfRecursive) {
983  if (StructType *STy = dyn_cast<StructType>(AgTy)) {
984  bool RecursiveType =
985  llvm::is_contained(STy->elements(), PtrArg->getType());
986  if (RecursiveType)
987  continue;
988  }
989  }
990 
991  // Otherwise, see if we can promote the pointer to its value.
992  Type *ByValTy =
993  PtrArg->hasByValAttr() ? PtrArg->getParamByValType() : nullptr;
994  if (isSafeToPromoteArgument(PtrArg, ByValTy, AAR, MaxElements))
995  ArgsToPromote.insert(PtrArg);
996  }
997 
998  // No promotable pointer arguments.
999  if (ArgsToPromote.empty() && ByValArgsToTransform.empty())
1000  return nullptr;
1001 
1003  *F, TTI, ArgsToPromote, ByValArgsToTransform))
1004  return nullptr;
1005 
1006  return doPromotion(F, ArgsToPromote, ByValArgsToTransform, ReplaceCallSite);
1007 }
1008 
1011  LazyCallGraph &CG,
1012  CGSCCUpdateResult &UR) {
1013  bool Changed = false, LocalChange;
1014 
1015  // Iterate until we stop promoting from this SCC.
1016  do {
1017  LocalChange = false;
1018 
1019  for (LazyCallGraph::Node &N : C) {
1020  Function &OldF = N.getFunction();
1021 
1023  AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C, CG).getManager();
1024  // FIXME: This lambda must only be used with this function. We should
1025  // skip the lambda and just get the AA results directly.
1026  auto AARGetter = [&](Function &F) -> AAResults & {
1027  assert(&F == &OldF && "Called with an unexpected function!");
1028  return FAM.getResult<AAManager>(F);
1029  };
1030 
1032  Function *NewF =
1033  promoteArguments(&OldF, AARGetter, MaxElements, None, TTI);
1034  if (!NewF)
1035  continue;
1036  LocalChange = true;
1037 
1038  // Directly substitute the functions in the call graph. Note that this
1039  // requires the old function to be completely dead and completely
1040  // replaced by the new function. It does no call graph updates, it merely
1041  // swaps out the particular function mapped to a particular node in the
1042  // graph.
1043  C.getOuterRefSCC().replaceNodeFunction(N, *NewF);
1044  FAM.clear(OldF, OldF.getName());
1045  OldF.eraseFromParent();
1046  }
1047 
1048  Changed |= LocalChange;
1049  } while (LocalChange);
1050 
1051  if (!Changed)
1052  return PreservedAnalyses::all();
1053 
1054  return PreservedAnalyses::none();
1055 }
1056 
1057 namespace {
1058 
1059 /// ArgPromotion - The 'by reference' to 'by value' argument promotion pass.
1060 struct ArgPromotion : public CallGraphSCCPass {
1061  // Pass identification, replacement for typeid
1062  static char ID;
1063 
1064  explicit ArgPromotion(unsigned MaxElements = 3)
1065  : CallGraphSCCPass(ID), MaxElements(MaxElements) {
1067  }
1068 
1069  void getAnalysisUsage(AnalysisUsage &AU) const override {
1075  }
1076 
1077  bool runOnSCC(CallGraphSCC &SCC) override;
1078 
1079 private:
1081 
1082  bool doInitialization(CallGraph &CG) override;
1083 
1084  /// The maximum number of elements to expand, or 0 for unlimited.
1085  unsigned MaxElements;
1086 };
1087 
1088 } // end anonymous namespace
1089 
1090 char ArgPromotion::ID = 0;
1091 
1092 INITIALIZE_PASS_BEGIN(ArgPromotion, "argpromotion",
1093  "Promote 'by reference' arguments to scalars", false,
1094  false)
1100  "Promote 'by reference' arguments to scalars", false, false)
1101 
1102 Pass *llvm::createArgumentPromotionPass(unsigned MaxElements) {
1103  return new ArgPromotion(MaxElements);
1104 }
1105 
1106 bool ArgPromotion::runOnSCC(CallGraphSCC &SCC) {
1107  if (skipSCC(SCC))
1108  return false;
1109 
1110  // Get the callgraph information that we need to update to reflect our
1111  // changes.
1112  CallGraph &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();
1113 
1114  LegacyAARGetter AARGetter(*this);
1115 
1116  bool Changed = false, LocalChange;
1117 
1118  // Iterate until we stop promoting from this SCC.
1119  do {
1120  LocalChange = false;
1121  // Attempt to promote arguments from all functions in this SCC.
1122  for (CallGraphNode *OldNode : SCC) {
1123  Function *OldF = OldNode->getFunction();
1124  if (!OldF)
1125  continue;
1126 
1127  auto ReplaceCallSite = [&](CallBase &OldCS, CallBase &NewCS) {
1128  Function *Caller = OldCS.getParent()->getParent();
1129  CallGraphNode *NewCalleeNode =
1130  CG.getOrInsertFunction(NewCS.getCalledFunction());
1131  CallGraphNode *CallerNode = CG[Caller];
1132  CallerNode->replaceCallEdge(cast<CallBase>(OldCS),
1133  cast<CallBase>(NewCS), NewCalleeNode);
1134  };
1135 
1136  const TargetTransformInfo &TTI =
1137  getAnalysis<TargetTransformInfoWrapperPass>().getTTI(*OldF);
1138  if (Function *NewF = promoteArguments(OldF, AARGetter, MaxElements,
1139  {ReplaceCallSite}, TTI)) {
1140  LocalChange = true;
1141 
1142  // Update the call graph for the newly promoted function.
1143  CallGraphNode *NewNode = CG.getOrInsertFunction(NewF);
1144  NewNode->stealCalledFunctionsFrom(OldNode);
1145  if (OldNode->getNumReferences() == 0)
1146  delete CG.removeFunctionFromModule(OldNode);
1147  else
1149 
1150  // And updat ethe SCC we're iterating as well.
1151  SCC.ReplaceNode(OldNode, NewNode);
1152  }
1153  }
1154  // Remember that we changed something.
1155  Changed |= LocalChange;
1156  } while (LocalChange);
1157 
1158  return Changed;
1159 }
1160 
1161 bool ArgPromotion::doInitialization(CallGraph &CG) {
1163 }
i
i
Definition: README.txt:29
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:155
llvm::Argument
This class represents an incoming formal argument to a Function.
Definition: Argument.h:29
AssumptionCache.h
llvm::AAManager
A manager for alias analyses.
Definition: AliasAnalysis.h:1233
llvm::TargetIRAnalysis
Analysis pass providing the TargetTransformInfo.
Definition: TargetTransformInfo.h:2331
llvm::predecessors
pred_range predecessors(BasicBlock *BB)
Definition: CFG.h:127
llvm::initializeArgPromotionPass
void initializeArgPromotionPass(PassRegistry &)
llvm::MemoryLocation::get
static MemoryLocation get(const LoadInst *LI)
Return a location with information about the memory reference by the given instruction.
Definition: MemoryLocation.cpp:37
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::CallBase::getOperandBundlesAsDefs
void getOperandBundlesAsDefs(SmallVectorImpl< OperandBundleDef > &Defs) const
Return the list of operand bundles attached to this instruction as a vector of OperandBundleDefs.
Definition: Instructions.cpp:363
llvm::InvokeInst::Create
static InvokeInst * Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr, Instruction *InsertBefore=nullptr)
Definition: Instructions.h:3785
llvm::make_range
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Definition: iterator_range.h:53
NoFolder.h
Optional.h
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:112
type
Metadata.h
llvm::BasicBlock::getParent
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:107
llvm::AnalysisManager::getResult
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:785
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:164
llvm::Function::getBasicBlockList
const BasicBlockListType & getBasicBlockList() const
Get the underlying elements of the Function...
Definition: Function.h:710
llvm::ArgumentPromotionPass::areFunctionArgsABICompatible
static bool areFunctionArgsABICompatible(const Function &F, const TargetTransformInfo &TTI, SmallPtrSetImpl< Argument * > &ArgsToPromote, SmallPtrSetImpl< Argument * > &ByValArgsToTransform)
Check if callers and the callee F agree how promoted arguments would be passed.
Definition: ArgumentPromotion.cpp:835
Loads.h
llvm::Function
Definition: Function.h:61
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
Pass.h
llvm::Function::eraseFromParent
void eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing module and deletes it.
Definition: Function.cpp:365
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
Statistic.h
llvm::TargetTransformInfo
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Definition: TargetTransformInfo.h:168
llvm::IRBuilder
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:2647
llvm::FunctionType::get
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:325
llvm::AttributeList::get
static AttributeList get(LLVMContext &C, ArrayRef< std::pair< unsigned, Attribute >> Attrs)
Create an AttributeList with the specified parameters in it.
Definition: Attributes.cpp:1040
llvm::CallGraph
The basic data container for the call graph of a Module of IR.
Definition: CallGraph.h:73
llvm::TargetTransformInfo::areFunctionArgsABICompatible
bool areFunctionArgsABICompatible(const Function *Caller, const Function *Callee, SmallPtrSetImpl< Argument * > &Args) const
Definition: TargetTransformInfo.cpp:967
FAM
FunctionAnalysisManager FAM
Definition: PassBuilderBindings.cpp:59
to
Should compile to
Definition: README.txt:449
llvm::PreservedAnalyses::none
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition: PassManager.h:158
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
Module.h
llvm::AttributeList
Definition: Attributes.h:398
llvm::CallBase::getAttributes
AttributeList getAttributes() const
Return the parameter attributes for this call.
Definition: InstrTypes.h:1468
llvm::CallBase::isCallee
bool isCallee(Value::const_user_iterator UI) const
Determine whether the passed iterator points to the callee operand's Use.
Definition: InstrTypes.h:1401
llvm::AttributeList::getFnAttrs
AttributeSet getFnAttrs() const
The function attributes are returned.
Definition: Attributes.cpp:1391
llvm::CallBase::isMustTailCall
bool isMustTailCall() const
Tests if this call site must be tail call optimized.
Definition: Instructions.cpp:298
llvm::Optional
Definition: APInt.h:33
llvm::SmallPtrSet< Value *, 16 >
llvm::Instruction::copyMetadata
void copyMetadata(const Instruction &SrcInst, ArrayRef< unsigned > WL=ArrayRef< unsigned >())
Copy metadata from SrcInst to this instruction.
Definition: Instruction.cpp:829
STLExtras.h
llvm::CallBase::arg_begin
User::op_iterator arg_begin()
Return the iterator pointing to the beginning of the argument list.
Definition: InstrTypes.h:1303
llvm::SmallVectorImpl::pop_back_val
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:635
llvm::ArrayType
Class to represent array types.
Definition: DerivedTypes.h:357
llvm::IRBuilderBase::CreateAlignedLoad
LoadInst * CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, const char *Name)
Definition: IRBuilder.h:1703
llvm::CallBase::addParamAttr
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Adds the attribute to the indicated argument.
Definition: InstrTypes.h:1520
BasicAliasAnalysis.h
llvm::LoadInst::getAlign
Align getAlign() const
Return the alignment of the access that is being performed.
Definition: Instructions.h:223
Use.h
llvm::Type::getInt32Ty
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:203
prefixIn
static bool prefixIn(const IndicesVector &Indices, std::set< IndicesVector > &Set)
Checks if Indices, or a prefix of Indices, is in Set.
Definition: ArgumentPromotion.cpp:508
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:101
DepthFirstIterator.h
llvm::getAAResultsAnalysisUsage
void getAAResultsAnalysisUsage(AnalysisUsage &AU)
A helper for the legacy pass manager to populate AU to add uses to make sure the analyses required by...
Definition: AliasAnalysis.cpp:989
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::ArgumentPromotionPass::run
PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM, LazyCallGraph &CG, CGSCCUpdateResult &UR)
Definition: ArgumentPromotion.cpp:1009
llvm::FunctionType::isVarArg
bool isVarArg() const
Definition: DerivedTypes.h:123
scalars
Promote by reference arguments to scalars
Definition: ArgumentPromotion.cpp:1100
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::lltok::equal
@ equal
Definition: LLToken.h:25
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::CallGraph::getOrInsertFunction
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:175
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:206
Instruction.h
llvm::formatv
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
Definition: FormatVariadic.h:250
llvm::ConstantInt
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
llvm::CallBase::removeParamAttr
void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Removes the attribute from the given argument.
Definition: InstrTypes.h:1562
llvm::CallGraphSCCPass::doInitialization
virtual bool doInitialization(CallGraph &CG)
doInitialization - This method is called before the SCC's of the program has been processed,...
Definition: CallGraphSCCPass.h:48
llvm::CallGraphSCC
CallGraphSCC - This is a single SCC that a CallGraphSCCPass is run on.
Definition: CallGraphSCCPass.h:87
llvm::PassRegistry::getPassRegistry
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Definition: PassRegistry.cpp:31
llvm::LazyCallGraph::SCC
An SCC of the call graph.
Definition: LazyCallGraph.h:422
Constants.h
llvm::AAResults
Definition: AliasAnalysis.h:456
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::User
Definition: User.h:44
ArgumentPromotion.h
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
Twine.h
InstrTypes.h
llvm::CallBase::getCalledFunction
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation.
Definition: InstrTypes.h:1393
llvm::CallBase::setAttributes
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
Definition: InstrTypes.h:1472
llvm::IRBuilderBase::CreateLoad
LoadInst * CreateLoad(Type *Ty, Value *Ptr, const char *Name)
Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of converting the string to 'bool...
Definition: IRBuilder.h:1660
llvm::AnalysisManager::clear
void clear(IRUnitT &IR, llvm::StringRef Name)
Clear any cached analysis results for a single unit of IR.
Definition: PassManagerImpl.h:36
llvm::CallInst::Create
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:1518
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
llvm::StructLayout::getElementOffsetInBits
uint64_t getElementOffsetInBits(unsigned Idx) const
Definition: DataLayout.h:639
TargetLibraryInfo.h
false
Definition: StackSlotColoring.cpp:142
llvm::make_scope_exit
LLVM_NODISCARD detail::scope_exit< typename std::decay< Callable >::type > make_scope_exit(Callable &&F)
Definition: ScopeExit.h:58
llvm::Instruction
Definition: Instruction.h:45
llvm::isDereferenceablePointer
bool isDereferenceablePointer(const Value *V, Type *Ty, const DataLayout &DL, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Return true if this is always a dereferenceable pointer.
Definition: Loads.cpp:234
llvm::STATISTIC
STATISTIC(NumFunctions, "Total number of functions")
llvm::Function::copyAttributesFrom
void copyAttributesFrom(const Function *Src)
copyAttributesFrom - copy all additional attributes (those not needed to create a Function) from the ...
Definition: Function.cpp:712
llvm::Value::setName
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:364
llvm::UndefValue::get
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1771
llvm::ConstantInt::get
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:900
SmallPtrSet.h
llvm::Instruction::getAAMetadata
AAMDNodes getAAMetadata() const
Returns the AA metadata for this instruction.
Definition: TypeBasedAliasAnalysis.cpp:533
llvm::CallGraphNode
A node in the call graph for a module.
Definition: CallGraph.h:167
LazyCallGraph.h
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::SPII::Load
@ Load
Definition: SparcInstrInfo.h:32
FormatVariadic.h
llvm::CallBase::getCallingConv
CallingConv::ID getCallingConv() const
Definition: InstrTypes.h:1449
llvm::None
const NoneType None
Definition: None.h:23
llvm::Value::use_empty
bool use_empty() const
Definition: Value.h:345
Type.h
llvm::CallBase::getCaller
Function * getCaller()
Helper to get the caller (the parent function).
Definition: Instructions.cpp:282
INITIALIZE_PASS_END
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:58
CFG.h
Operands
mir Rename Register Operands
Definition: MIRNamerPass.cpp:78
llvm::InvokeInst
Invoke instruction.
Definition: Instructions.h:3741
llvm::ARM_PROC::IE
@ IE
Definition: ARMBaseInfo.h:27
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:168
llvm::VectorType
Base class of all SIMD vector types.
Definition: DerivedTypes.h:389
BasicBlock.h
llvm::StoreInst
An instruction for storing to memory.
Definition: Instructions.h:304
llvm::AttributeList::getRetAttrs
AttributeSet getRetAttrs() const
The attributes for the ret value are returned.
Definition: Attributes.cpp:1387
llvm::Instruction::eraseFromParent
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:78
llvm::CallGraphSCCPass::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &Info) const override
getAnalysisUsage - For this class, we declare that we require and preserve the call graph.
Definition: CallGraphSCCPass.cpp:659
llvm::TargetLibraryInfoWrapperPass
Definition: TargetLibraryInfo.h:463
uint64_t
llvm::StructLayout
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
Definition: DataLayout.h:604
llvm::TargetTransformInfoWrapperPass
Wrapper pass for TargetTransformInfo.
Definition: TargetTransformInfo.h:2387
llvm::Instruction::user_back
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:91
INITIALIZE_PASS_DEPENDENCY
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
IPO.h
llvm::GlobalObject::copyMetadata
void copyMetadata(const GlobalObject *Src, unsigned Offset)
Copy metadata from Src, adjusting offsets by Offset.
Definition: Metadata.cpp:1457
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
MemoryLocation.h
CGSCCPassManager.h
llvm::AAResults::canInstructionRangeModRef
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)...
Definition: AliasAnalysis.cpp:788
llvm::CallGraphWrapperPass
The ModulePass which wraps up a CallGraph and the logic to build it.
Definition: CallGraph.h:337
I
#define I(x, y, z)
Definition: MD5.cpp:59
INITIALIZE_PASS_BEGIN
INITIALIZE_PASS_BEGIN(ArgPromotion, "argpromotion", "Promote 'by reference' arguments to scalars", false, false) INITIALIZE_PASS_END(ArgPromotion
doPromotion
static Function * doPromotion(Function *F, SmallPtrSetImpl< Argument * > &ArgsToPromote, SmallPtrSetImpl< Argument * > &ByValArgsToTransform, Optional< function_ref< void(CallBase &OldCS, CallBase &NewCS)>> ReplaceCallSite)
DoPromotion - This method actually performs the promotion of the specified arguments,...
Definition: ArgumentPromotion.cpp:104
llvm::GetElementPtrInst
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
Definition: Instructions.h:928
llvm::LoadInst::setAlignment
void setAlignment(Align Align)
Definition: Instructions.h:227
canPaddingBeAccessed
static bool canPaddingBeAccessed(Argument *arg)
Checks if the padding bytes of an argument could be accessed.
Definition: ArgumentPromotion.cpp:802
llvm::make_early_inc_range
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
Definition: STLExtras.h:572
llvm::is_contained
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:1612
llvm::GlobalValue::setLinkage
void setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:454
llvm::Function::Create
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:138
IRBuilder.h
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::CallGraph::removeFunctionFromModule
Function * removeFunctionFromModule(CallGraphNode *CGN)
Unlink the function from this module, returning it.
Definition: CallGraph.cpp:162
llvm::SPII::Store
@ Store
Definition: SparcInstrInfo.h:33
llvm::TTI
TargetTransformInfo TTI
Definition: TargetTransformInfo.h:163
llvm::createArgumentPromotionPass
Pass * createArgumentPromotionPass(unsigned maxElements=3)
createArgumentPromotionPass - This pass promotes "by reference" arguments to be passed by value if th...
Definition: ArgumentPromotion.cpp:1102
llvm::CallBase::arg_end
User::op_iterator arg_end()
Return the iterator pointing to the end of the argument list.
Definition: InstrTypes.h:1309
llvm::LazyCallGraph::Node
A node in the call graph.
Definition: LazyCallGraph.h:318
llvm::SmallPtrSetImpl::count
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:382
llvm::Function::getFunction
const Function & getFunction() const
Definition: Function.h:136
llvm::df_iterator_default_set
Definition: DepthFirstIterator.h:69
llvm::AMDGPU::CPol::SCC
@ SCC
Definition: SIDefines.h:292
llvm::GetElementPtrInst::Create
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:954
llvm::AssumptionCacheTracker
An immutable pass that tracks lazily created AssumptionCache objects.
Definition: AssumptionCache.h:200
None.h
IndicesVector
std::vector< uint64_t > IndicesVector
A vector used to hold the indices of a single GEP instruction.
Definition: ArgumentPromotion.cpp:98
DataLayout.h
llvm::StructType
Class to represent struct types.
Definition: DerivedTypes.h:213
llvm::Pass::doInitialization
virtual bool doInitialization(Module &)
doInitialization - Virtual method overridden by subclasses to do any necessary initialization before ...
Definition: Pass.h:116
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:256
llvm::Value::replaceAllUsesWith
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:520
llvm::append_range
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Definition: STLExtras.h:1744
llvm::ModRefInfo::Mod
@ Mod
The access may modify the value stored in memory.
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
CallGraphSCCPass.h
llvm::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:297
llvm::LoadInst
An instruction for reading from memory.
Definition: Instructions.h:175
llvm::Function::begin
iterator begin()
Definition: Function.h:733
llvm::StructType::getNumElements
unsigned getNumElements() const
Random access to the elements.
Definition: DerivedTypes.h:327
llvm::IRBuilderBase::CreateGEP
Value * CreateGEP(Type *Ty, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &Name="")
Definition: IRBuilder.h:1799
Argument.h
Callee
amdgpu Simplify well known AMD library false FunctionCallee Callee
Definition: AMDGPULibCalls.cpp:206
Attributes.h
isPrefix
static bool isPrefix(const IndicesVector &Prefix, const IndicesVector &Longer)
Returns true if Prefix is a prefix of longer.
Definition: ArgumentPromotion.cpp:501
llvm::CGSCCUpdateResult
Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager...
Definition: CGSCCPassManager.h:238
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::commonAlignment
Align commonAlignment(Align A, Align B)
Returns the alignment that satisfies both alignments.
Definition: Alignment.h:211
llvm::Type::getInt64Ty
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:204
llvm::StructType::elements
ArrayRef< Type * > elements() const
Definition: DerivedTypes.h:319
llvm::PreservedAnalyses::all
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:161
llvm::StructLayout::getElementOffset
uint64_t getElementOffset(unsigned Idx) const
Definition: DataLayout.h:634
Casting.h
llvm::Argument::hasByValAttr
bool hasByValAttr() const
Return true if this argument has the byval attribute.
Definition: Function.cpp:110
llvm::Instruction::setAAMetadata
void setAAMetadata(const AAMDNodes &N)
Sets the metadata on this instruction from the AAMDNodes structure.
Definition: Metadata.cpp:1370
llvm::GetElementPtrInst::getTypeAtIndex
static Type * getTypeAtIndex(Type *Ty, Value *Idx)
Return the type of the element at the given index of an indexable type.
Definition: Instructions.cpp:1720
argpromotion
argpromotion
Definition: ArgumentPromotion.cpp:1099
Function.h
llvm::CallGraphSCCPass
Definition: CallGraphSCCPass.h:34
promoteArguments
static Function * promoteArguments(Function *F, function_ref< AAResults &(Function &F)> AARGetter, unsigned MaxElements, Optional< function_ref< void(CallBase &OldCS, CallBase &NewCS)>> ReplaceCallSite, const TargetTransformInfo &TTI)
PromoteArguments - This method checks the specified function to see if there are any promotable argum...
Definition: ArgumentPromotion.cpp:857
PassManager.h
llvm::SmallVectorImpl::clear
void clear()
Definition: SmallVector.h:585
llvm::GetElementPtrInst::getIndexedType
static Type * getIndexedType(Type *Ty, ArrayRef< Value * > IdxList)
Returns the result type of a getelementptr with the given source element type and indexes.
Definition: Instructions.cpp:1760
llvm::Function::arg_begin
arg_iterator arg_begin()
Definition: Function.h:748
arguments
we compile this esp call L1 $pb L1 esp je LBB1_2 esp ret but is currently always computed in the entry block It would be better to sink the picbase computation down into the block for the as it is the only one that uses it This happens for a lot of code with early outs Another example is loads of arguments
Definition: README.txt:425
llvm::ArgumentPromotionPass::isDenselyPacked
static bool isDenselyPacked(Type *type, const DataLayout &DL)
Checks if a type could have padding bytes.
Definition: ArgumentPromotion.cpp:763
isSafeToPromoteArgument
static bool isSafeToPromoteArgument(Argument *Arg, Type *ByValTy, AAResults &AAR, unsigned MaxElements)
isSafeToPromoteArgument - As you might guess from the name of this method, it checks to see if it is ...
Definition: ArgumentPromotion.cpp:563
llvm::GlobalValue::ExternalLinkage
@ ExternalLinkage
Externally visible function.
Definition: GlobalValue.h:48
CallGraph.h
llvm::Pass
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:91
Instructions.h
llvm::User::getNumOperands
unsigned getNumOperands() const
Definition: User.h:191
llvm::Type::isStructTy
bool isStructTy() const
True if this is an instance of StructType.
Definition: Type.h:222
llvm::AttributeSet
Definition: Attributes.h:266
SmallVector.h
User.h
llvm::User::op_begin
op_iterator op_begin()
Definition: User.h:234
llvm::CallBase::getArgOperand
Value * getArgOperand(unsigned i) const
Definition: InstrTypes.h:1338
llvm::SmallPtrSetImplBase::empty
LLVM_NODISCARD bool empty() const
Definition: SmallPtrSet.h:91
N
#define N
llvm::Instruction::getParent
const BasicBlock * getParent() const
Definition: Instruction.h:94
markIndicesSafe
static void markIndicesSafe(const IndicesVector &ToMark, std::set< IndicesVector > &Safe)
Mark the given indices (ToMark) as safe in the given set of indices (Safe).
Definition: ArgumentPromotion.cpp:527
TargetTransformInfo.h
llvm::AAResults::canBasicBlockModify
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.
Definition: AliasAnalysis.cpp:778
ScopeExit.h
llvm::StructType::getElementType
Type * getElementType(unsigned N) const
Definition: DerivedTypes.h:328
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1161
DerivedTypes.h
llvm::SmallPtrSetImpl
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:343
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:44
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
GEP
Hexagon Common GEP
Definition: HexagonCommonGEP.cpp:172
llvm::AnalysisUsage::addRequired
AnalysisUsage & addRequired()
Definition: PassAnalysisSupport.h:75
llvm::Value::takeName
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:370
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:389
llvm::AllocaInst
an instruction to allocate memory on the stack
Definition: Instructions.h:62
llvm::inverse_depth_first_ext
iterator_range< idf_ext_iterator< T, SetTy > > inverse_depth_first_ext(const T &G, SetTy &S)
Definition: DepthFirstIterator.h:302
llvm::LazyCallGraph
A lazily constructed view of the call graph of a module.
Definition: LazyCallGraph.h:113
raw_ostream.h
llvm::AttributeList::getParamAttrs
AttributeSet getParamAttrs(unsigned ArgNo) const
The attributes for the argument or parameter at the given index are returned.
Definition: Attributes.cpp:1383
llvm::FunctionAnalysisManagerCGSCCProxy
A proxy from a FunctionAnalysisManager to an SCC.
Definition: CGSCCPassManager.h:405
Value.h
llvm::Function::setAttributes
void setAttributes(AttributeList Attrs)
Set the attribute list for this Function.
Definition: Function.h:329
llvm::LegacyAARGetter
This class is a functor to be used in legacy module or SCC passes for computing AA results for a func...
Definition: BasicAliasAnalysis.h:271
InitializePasses.h
allCallersPassValidPointerForArgument
static bool allCallersPassValidPointerForArgument(Argument *Arg, Type *Ty)
Return true if we can prove that all callees pass in a valid pointer for the specified function argum...
Definition: ArgumentPromotion.cpp:479
llvm::FunctionType::getReturnType
Type * getReturnType() const
Definition: DerivedTypes.h:124
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
Debug.h
llvm::Value::users
iterator_range< user_iterator > users()
Definition: Value.h:422
llvm::CallGraphNode::stealCalledFunctionsFrom
void stealCalledFunctionsFrom(CallGraphNode *N)
Moves all the callee information from N to this node.
Definition: CallGraph.h:236
llvm::MemoryLocation
Representation for a specific memory location.
Definition: MemoryLocation.h:209
llvm::CallBase::setCallingConv
void setCallingConv(CallingConv::ID CC)
Definition: InstrTypes.h:1453
llvm::FunctionType
Class to represent function types.
Definition: DerivedTypes.h:103
llvm::Use
A Use represents the edge between a Value definition and its users.
Definition: Use.h:44
llvm::SmallPtrSetImpl::insert
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:364
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37
llvm::User::op_end
op_iterator op_end()
Definition: User.h:236
llvm::SmallVectorImpl::insert
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:773
llvm::CallGraphNode::replaceCallEdge
void replaceCallEdge(CallBase &Call, CallBase &NewCall, CallGraphNode *NewNode)
Replaces the edge in the node for the specified call site with a new one.
Definition: CallGraph.cpp:262