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 (const Use &I : llvm::drop_begin(UI->operands()))
181  Indices.push_back(cast<ConstantInt>(I)->getSExtValue());
182  // GEPs with a single 0 index can be merged with direct loads
183  if (Indices.size() == 1 && Indices.front() == 0)
184  Indices.clear();
185  ArgIndices.insert(std::make_pair(SrcTy, Indices));
186  LoadInst *OrigLoad;
187  if (LoadInst *L = dyn_cast<LoadInst>(UI))
188  OrigLoad = L;
189  else
190  // Take any load, we will use it only to update Alias Analysis
191  OrigLoad = cast<LoadInst>(UI->user_back());
192  OriginalLoads[std::make_pair(&*I, Indices)] = OrigLoad;
193  }
194 
195  // Add a parameter to the function for each element passed in.
196  for (const auto &ArgIndex : ArgIndices) {
197  // not allowed to dereference ->begin() if size() is 0
198  Params.push_back(GetElementPtrInst::getIndexedType(
199  cast<PointerType>(I->getType())->getElementType(),
200  ArgIndex.second));
201  ArgAttrVec.push_back(AttributeSet());
202  assert(Params.back());
203  }
204 
205  if (ArgIndices.size() == 1 && ArgIndices.begin()->second.empty())
206  ++NumArgumentsPromoted;
207  else
208  ++NumAggregatesPromoted;
209  }
210  }
211 
212  Type *RetTy = FTy->getReturnType();
213 
214  // Construct the new function type using the new arguments.
215  FunctionType *NFTy = FunctionType::get(RetTy, Params, FTy->isVarArg());
216 
217  // Create the new function body and insert it into the module.
218  Function *NF = Function::Create(NFTy, F->getLinkage(), F->getAddressSpace(),
219  F->getName());
220  NF->copyAttributesFrom(F);
221  NF->copyMetadata(F, 0);
222 
223  // The new function will have the !dbg metadata copied from the original
224  // function. The original function may not be deleted, and dbg metadata need
225  // to be unique so we need to drop it.
226  F->setSubprogram(nullptr);
227 
228  LLVM_DEBUG(dbgs() << "ARG PROMOTION: Promoting to:" << *NF << "\n"
229  << "From: " << *F);
230 
231  // Recompute the parameter attributes list based on the new arguments for
232  // the function.
233  NF->setAttributes(AttributeList::get(F->getContext(), PAL.getFnAttrs(),
234  PAL.getRetAttrs(), ArgAttrVec));
235  ArgAttrVec.clear();
236 
237  F->getParent()->getFunctionList().insert(F->getIterator(), NF);
238  NF->takeName(F);
239 
240  // Loop over all of the callers of the function, transforming the call sites
241  // to pass in the loaded pointers.
242  //
244  const DataLayout &DL = F->getParent()->getDataLayout();
245  while (!F->use_empty()) {
246  CallBase &CB = cast<CallBase>(*F->user_back());
247  assert(CB.getCalledFunction() == F);
248  const AttributeList &CallPAL = CB.getAttributes();
249  IRBuilder<NoFolder> IRB(&CB);
250 
251  // Loop over the operands, inserting GEP and loads in the caller as
252  // appropriate.
253  auto AI = CB.arg_begin();
254  ArgNo = 0;
255  for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E;
256  ++I, ++AI, ++ArgNo)
257  if (!ArgsToPromote.count(&*I) && !ByValArgsToTransform.count(&*I)) {
258  Args.push_back(*AI); // Unmodified argument
259  ArgAttrVec.push_back(CallPAL.getParamAttrs(ArgNo));
260  } else if (ByValArgsToTransform.count(&*I)) {
261  // Emit a GEP and load for each element of the struct.
262  Type *AgTy = I->getParamByValType();
263  StructType *STy = cast<StructType>(AgTy);
264  Value *Idxs[2] = {
265  ConstantInt::get(Type::getInt32Ty(F->getContext()), 0), nullptr};
266  const StructLayout *SL = DL.getStructLayout(STy);
267  Align StructAlign = *I->getParamAlign();
268  for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
269  Idxs[1] = ConstantInt::get(Type::getInt32Ty(F->getContext()), i);
270  auto *Idx =
271  IRB.CreateGEP(STy, *AI, Idxs, (*AI)->getName() + "." + Twine(i));
272  // TODO: Tell AA about the new values?
273  Align Alignment =
274  commonAlignment(StructAlign, SL->getElementOffset(i));
275  Args.push_back(IRB.CreateAlignedLoad(
276  STy->getElementType(i), Idx, Alignment, Idx->getName() + ".val"));
277  ArgAttrVec.push_back(AttributeSet());
278  }
279  } else if (!I->use_empty()) {
280  // Non-dead argument: insert GEPs and loads as appropriate.
281  ScalarizeTable &ArgIndices = ScalarizedElements[&*I];
282  // Store the Value* version of the indices in here, but declare it now
283  // for reuse.
284  std::vector<Value *> Ops;
285  for (const auto &ArgIndex : ArgIndices) {
286  Value *V = *AI;
287  LoadInst *OrigLoad =
288  OriginalLoads[std::make_pair(&*I, ArgIndex.second)];
289  if (!ArgIndex.second.empty()) {
290  Ops.reserve(ArgIndex.second.size());
291  Type *ElTy = V->getType();
292  for (auto II : ArgIndex.second) {
293  // Use i32 to index structs, and i64 for others (pointers/arrays).
294  // This satisfies GEP constraints.
295  Type *IdxTy =
296  (ElTy->isStructTy() ? Type::getInt32Ty(F->getContext())
297  : Type::getInt64Ty(F->getContext()));
298  Ops.push_back(ConstantInt::get(IdxTy, II));
299  // Keep track of the type we're currently indexing.
300  if (auto *ElPTy = dyn_cast<PointerType>(ElTy))
301  ElTy = ElPTy->getElementType();
302  else
303  ElTy = GetElementPtrInst::getTypeAtIndex(ElTy, II);
304  }
305  // And create a GEP to extract those indices.
306  V = IRB.CreateGEP(ArgIndex.first, V, Ops, V->getName() + ".idx");
307  Ops.clear();
308  }
309  // Since we're replacing a load make sure we take the alignment
310  // of the previous load.
311  LoadInst *newLoad =
312  IRB.CreateLoad(OrigLoad->getType(), V, V->getName() + ".val");
313  newLoad->setAlignment(OrigLoad->getAlign());
314  // Transfer the AA info too.
315  newLoad->setAAMetadata(OrigLoad->getAAMetadata());
316 
317  Args.push_back(newLoad);
318  ArgAttrVec.push_back(AttributeSet());
319  }
320  }
321 
322  // Push any varargs arguments on the list.
323  for (; AI != CB.arg_end(); ++AI, ++ArgNo) {
324  Args.push_back(*AI);
325  ArgAttrVec.push_back(CallPAL.getParamAttrs(ArgNo));
326  }
327 
329  CB.getOperandBundlesAsDefs(OpBundles);
330 
331  CallBase *NewCS = nullptr;
332  if (InvokeInst *II = dyn_cast<InvokeInst>(&CB)) {
333  NewCS = InvokeInst::Create(NF, II->getNormalDest(), II->getUnwindDest(),
334  Args, OpBundles, "", &CB);
335  } else {
336  auto *NewCall = CallInst::Create(NF, Args, OpBundles, "", &CB);
337  NewCall->setTailCallKind(cast<CallInst>(&CB)->getTailCallKind());
338  NewCS = NewCall;
339  }
340  NewCS->setCallingConv(CB.getCallingConv());
341  NewCS->setAttributes(AttributeList::get(F->getContext(),
342  CallPAL.getFnAttrs(),
343  CallPAL.getRetAttrs(), ArgAttrVec));
344  NewCS->copyMetadata(CB, {LLVMContext::MD_prof, LLVMContext::MD_dbg});
345  Args.clear();
346  ArgAttrVec.clear();
347 
348  // Update the callgraph to know that the callsite has been transformed.
349  if (ReplaceCallSite)
350  (*ReplaceCallSite)(CB, *NewCS);
351 
352  if (!CB.use_empty()) {
353  CB.replaceAllUsesWith(NewCS);
354  NewCS->takeName(&CB);
355  }
356 
357  // Finally, remove the old call from the program, reducing the use-count of
358  // F.
359  CB.eraseFromParent();
360  }
361 
362  // Since we have now created the new function, splice the body of the old
363  // function right into the new function, leaving the old rotting hulk of the
364  // function empty.
365  NF->getBasicBlockList().splice(NF->begin(), F->getBasicBlockList());
366 
367  // Loop over the argument list, transferring uses of the old arguments over to
368  // the new arguments, also transferring over the names as well.
369  for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(),
370  I2 = NF->arg_begin();
371  I != E; ++I) {
372  if (!ArgsToPromote.count(&*I) && !ByValArgsToTransform.count(&*I)) {
373  // If this is an unmodified argument, move the name and users over to the
374  // new version.
375  I->replaceAllUsesWith(&*I2);
376  I2->takeName(&*I);
377  ++I2;
378  continue;
379  }
380 
381  if (ByValArgsToTransform.count(&*I)) {
382  // In the callee, we create an alloca, and store each of the new incoming
383  // arguments into the alloca.
384  Instruction *InsertPt = &NF->begin()->front();
385 
386  // Just add all the struct element types.
387  Type *AgTy = I->getParamByValType();
388  Align StructAlign = *I->getParamAlign();
389  Value *TheAlloca = new AllocaInst(AgTy, DL.getAllocaAddrSpace(), nullptr,
390  StructAlign, "", InsertPt);
391  StructType *STy = cast<StructType>(AgTy);
392  Value *Idxs[2] = {ConstantInt::get(Type::getInt32Ty(F->getContext()), 0),
393  nullptr};
394  const StructLayout *SL = DL.getStructLayout(STy);
395 
396  for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
397  Idxs[1] = ConstantInt::get(Type::getInt32Ty(F->getContext()), i);
399  AgTy, TheAlloca, Idxs, TheAlloca->getName() + "." + Twine(i),
400  InsertPt);
401  I2->setName(I->getName() + "." + Twine(i));
402  Align Alignment = commonAlignment(StructAlign, SL->getElementOffset(i));
403  new StoreInst(&*I2++, Idx, false, Alignment, InsertPt);
404  }
405 
406  // Anything that used the arg should now use the alloca.
407  I->replaceAllUsesWith(TheAlloca);
408  TheAlloca->takeName(&*I);
409  continue;
410  }
411 
412  // There potentially are metadata uses for things like llvm.dbg.value.
413  // Replace them with undef, after handling the other regular uses.
414  auto RauwUndefMetadata = make_scope_exit(
415  [&]() { I->replaceAllUsesWith(UndefValue::get(I->getType())); });
416 
417  if (I->use_empty())
418  continue;
419 
420  // Otherwise, if we promoted this argument, then all users are load
421  // instructions (or GEPs with only load users), and all loads should be
422  // using the new argument that we added.
423  ScalarizeTable &ArgIndices = ScalarizedElements[&*I];
424 
425  while (!I->use_empty()) {
426  if (LoadInst *LI = dyn_cast<LoadInst>(I->user_back())) {
427  assert(ArgIndices.begin()->second.empty() &&
428  "Load element should sort to front!");
429  I2->setName(I->getName() + ".val");
430  LI->replaceAllUsesWith(&*I2);
431  LI->eraseFromParent();
432  LLVM_DEBUG(dbgs() << "*** Promoted load of argument '" << I->getName()
433  << "' in function '" << F->getName() << "'\n");
434  } else {
435  GetElementPtrInst *GEP = cast<GetElementPtrInst>(I->user_back());
436  assert(!GEP->use_empty() &&
437  "GEPs without uses should be cleaned up already");
439  Operands.reserve(GEP->getNumIndices());
440  for (const Use &Idx : GEP->indices())
441  Operands.push_back(cast<ConstantInt>(Idx)->getSExtValue());
442 
443  // GEPs with a single 0 index can be merged with direct loads
444  if (Operands.size() == 1 && Operands.front() == 0)
445  Operands.clear();
446 
447  Function::arg_iterator TheArg = I2;
448  for (ScalarizeTable::iterator It = ArgIndices.begin();
449  It->second != Operands; ++It, ++TheArg) {
450  assert(It != ArgIndices.end() && "GEP not handled??");
451  }
452 
453  TheArg->setName(formatv("{0}.{1:$[.]}.val", I->getName(),
454  make_range(Operands.begin(), Operands.end())));
455 
456  LLVM_DEBUG(dbgs() << "*** Promoted agg argument '" << TheArg->getName()
457  << "' of function '" << NF->getName() << "'\n");
458 
459  // All of the uses must be load instructions. Replace them all with
460  // the argument specified by ArgNo.
461  while (!GEP->use_empty()) {
462  LoadInst *L = cast<LoadInst>(GEP->user_back());
463  L->replaceAllUsesWith(&*TheArg);
464  L->eraseFromParent();
465  }
466  GEP->eraseFromParent();
467  }
468  }
469  // Increment I2 past all of the arguments added for this promoted pointer.
470  std::advance(I2, ArgIndices.size());
471  }
472 
473  return NF;
474 }
475 
476 /// Return true if we can prove that all callees pass in a valid pointer for the
477 /// specified function argument.
479  Function *Callee = Arg->getParent();
480  const DataLayout &DL = Callee->getParent()->getDataLayout();
481 
482  unsigned ArgNo = Arg->getArgNo();
483 
484  // Look at all call sites of the function. At this point we know we only have
485  // direct callees.
486  for (User *U : Callee->users()) {
487  CallBase &CB = cast<CallBase>(*U);
488 
489  if (!isDereferenceablePointer(CB.getArgOperand(ArgNo), Ty, DL))
490  return false;
491  }
492  return true;
493 }
494 
495 /// Returns true if Prefix is a prefix of longer. That means, Longer has a size
496 /// that is greater than or equal to the size of prefix, and each of the
497 /// elements in Prefix is the same as the corresponding elements in Longer.
498 ///
499 /// This means it also returns true when Prefix and Longer are equal!
500 static bool isPrefix(const IndicesVector &Prefix, const IndicesVector &Longer) {
501  if (Prefix.size() > Longer.size())
502  return false;
503  return std::equal(Prefix.begin(), Prefix.end(), Longer.begin());
504 }
505 
506 /// Checks if Indices, or a prefix of Indices, is in Set.
507 static bool prefixIn(const IndicesVector &Indices,
508  std::set<IndicesVector> &Set) {
509  std::set<IndicesVector>::iterator Low;
510  Low = Set.upper_bound(Indices);
511  if (Low != Set.begin())
512  Low--;
513  // Low is now the last element smaller than or equal to Indices. This means
514  // it points to a prefix of Indices (possibly Indices itself), if such
515  // prefix exists.
516  //
517  // This load is safe if any prefix of its operands is safe to load.
518  return Low != Set.end() && isPrefix(*Low, Indices);
519 }
520 
521 /// Mark the given indices (ToMark) as safe in the given set of indices
522 /// (Safe). Marking safe usually means adding ToMark to Safe. However, if there
523 /// is already a prefix of Indices in Safe, Indices are implicitely marked safe
524 /// already. Furthermore, any indices that Indices is itself a prefix of, are
525 /// removed from Safe (since they are implicitely safe because of Indices now).
526 static void markIndicesSafe(const IndicesVector &ToMark,
527  std::set<IndicesVector> &Safe) {
528  std::set<IndicesVector>::iterator Low;
529  Low = Safe.upper_bound(ToMark);
530  // Guard against the case where Safe is empty
531  if (Low != Safe.begin())
532  Low--;
533  // Low is now the last element smaller than or equal to Indices. This
534  // means it points to a prefix of Indices (possibly Indices itself), if
535  // such prefix exists.
536  if (Low != Safe.end()) {
537  if (isPrefix(*Low, ToMark))
538  // If there is already a prefix of these indices (or exactly these
539  // indices) marked a safe, don't bother adding these indices
540  return;
541 
542  // Increment Low, so we can use it as a "insert before" hint
543  ++Low;
544  }
545  // Insert
546  Low = Safe.insert(Low, ToMark);
547  ++Low;
548  // If there we're a prefix of longer index list(s), remove those
549  std::set<IndicesVector>::iterator End = Safe.end();
550  while (Low != End && isPrefix(ToMark, *Low)) {
551  std::set<IndicesVector>::iterator Remove = Low;
552  ++Low;
553  Safe.erase(Remove);
554  }
555 }
556 
557 /// isSafeToPromoteArgument - As you might guess from the name of this method,
558 /// it checks to see if it is both safe and useful to promote the argument.
559 /// This method limits promotion of aggregates to only promote up to three
560 /// elements of the aggregate in order to avoid exploding the number of
561 /// arguments passed in.
562 static bool isSafeToPromoteArgument(Argument *Arg, Type *ByValTy, AAResults &AAR,
563  unsigned MaxElements) {
564  using GEPIndicesSet = std::set<IndicesVector>;
565 
566  // Quick exit for unused arguments
567  if (Arg->use_empty())
568  return true;
569 
570  // We can only promote this argument if all of the uses are loads, or are GEP
571  // instructions (with constant indices) that are subsequently loaded.
572  //
573  // Promoting the argument causes it to be loaded in the caller
574  // unconditionally. This is only safe if we can prove that either the load
575  // would have happened in the callee anyway (ie, there is a load in the entry
576  // block) or the pointer passed in at every call site is guaranteed to be
577  // valid.
578  // In the former case, invalid loads can happen, but would have happened
579  // anyway, in the latter case, invalid loads won't happen. This prevents us
580  // from introducing an invalid load that wouldn't have happened in the
581  // original code.
582  //
583  // This set will contain all sets of indices that are loaded in the entry
584  // block, and thus are safe to unconditionally load in the caller.
585  GEPIndicesSet SafeToUnconditionallyLoad;
586 
587  // This set contains all the sets of indices that we are planning to promote.
588  // This makes it possible to limit the number of arguments added.
589  GEPIndicesSet ToPromote;
590 
591  // If the pointer is always valid, any load with first index 0 is valid.
592 
593  if (ByValTy)
594  SafeToUnconditionallyLoad.insert(IndicesVector(1, 0));
595 
596  // Whenever a new underlying type for the operand is found, make sure it's
597  // consistent with the GEPs and loads we've already seen and, if necessary,
598  // use it to see if all incoming pointers are valid (which implies the 0-index
599  // is safe).
600  Type *BaseTy = ByValTy;
601  auto UpdateBaseTy = [&](Type *NewBaseTy) {
602  if (BaseTy)
603  return BaseTy == NewBaseTy;
604 
605  BaseTy = NewBaseTy;
607  assert(SafeToUnconditionallyLoad.empty());
608  SafeToUnconditionallyLoad.insert(IndicesVector(1, 0));
609  }
610 
611  return true;
612  };
613 
614  // First, iterate the entry block and mark loads of (geps of) arguments as
615  // safe.
616  BasicBlock &EntryBlock = Arg->getParent()->front();
617  // Declare this here so we can reuse it
618  IndicesVector Indices;
619  for (Instruction &I : EntryBlock)
620  if (LoadInst *LI = dyn_cast<LoadInst>(&I)) {
621  Value *V = LI->getPointerOperand();
622  if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(V)) {
623  V = GEP->getPointerOperand();
624  if (V == Arg) {
625  // This load actually loads (part of) Arg? Check the indices then.
626  Indices.reserve(GEP->getNumIndices());
627  for (Use &Idx : GEP->indices())
628  if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx))
629  Indices.push_back(CI->getSExtValue());
630  else
631  // We found a non-constant GEP index for this argument? Bail out
632  // right away, can't promote this argument at all.
633  return false;
634 
635  if (!UpdateBaseTy(GEP->getSourceElementType()))
636  return false;
637 
638  // Indices checked out, mark them as safe
639  markIndicesSafe(Indices, SafeToUnconditionallyLoad);
640  Indices.clear();
641  }
642  } else if (V == Arg) {
643  // Direct loads are equivalent to a GEP with a single 0 index.
644  markIndicesSafe(IndicesVector(1, 0), SafeToUnconditionallyLoad);
645 
646  if (BaseTy && LI->getType() != BaseTy)
647  return false;
648 
649  BaseTy = LI->getType();
650  }
651  }
652 
653  // Now, iterate all uses of the argument to see if there are any uses that are
654  // not (GEP+)loads, or any (GEP+)loads that are not safe to promote.
657  for (Use &U : Arg->uses()) {
658  User *UR = U.getUser();
659  Operands.clear();
660  if (LoadInst *LI = dyn_cast<LoadInst>(UR)) {
661  // Don't hack volatile/atomic loads
662  if (!LI->isSimple())
663  return false;
664  Loads.push_back(LI);
665  // Direct loads are equivalent to a GEP with a zero index and then a load.
666  Operands.push_back(0);
667 
668  if (!UpdateBaseTy(LI->getType()))
669  return false;
670  } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(UR)) {
671  if (GEP->use_empty()) {
672  // Dead GEP's cause trouble later. Just remove them if we run into
673  // them.
674  continue;
675  }
676 
677  if (!UpdateBaseTy(GEP->getSourceElementType()))
678  return false;
679 
680  // Ensure that all of the indices are constants.
681  for (Use &Idx : GEP->indices())
682  if (ConstantInt *C = dyn_cast<ConstantInt>(Idx))
683  Operands.push_back(C->getSExtValue());
684  else
685  return false; // Not a constant operand GEP!
686 
687  // Ensure that the only users of the GEP are load instructions.
688  for (User *GEPU : GEP->users())
689  if (LoadInst *LI = dyn_cast<LoadInst>(GEPU)) {
690  // Don't hack volatile/atomic loads
691  if (!LI->isSimple())
692  return false;
693  Loads.push_back(LI);
694  } else {
695  // Other uses than load?
696  return false;
697  }
698  } else {
699  return false; // Not a load or a GEP.
700  }
701 
702  // Now, see if it is safe to promote this load / loads of this GEP. Loading
703  // is safe if Operands, or a prefix of Operands, is marked as safe.
704  if (!prefixIn(Operands, SafeToUnconditionallyLoad))
705  return false;
706 
707  // See if we are already promoting a load with these indices. If not, check
708  // to make sure that we aren't promoting too many elements. If so, nothing
709  // to do.
710  if (ToPromote.find(Operands) == ToPromote.end()) {
711  if (MaxElements > 0 && ToPromote.size() == MaxElements) {
712  LLVM_DEBUG(dbgs() << "argpromotion not promoting argument '"
713  << Arg->getName()
714  << "' because it would require adding more "
715  << "than " << MaxElements
716  << " arguments to the function.\n");
717  // We limit aggregate promotion to only promoting up to a fixed number
718  // of elements of the aggregate.
719  return false;
720  }
721  ToPromote.insert(std::move(Operands));
722  }
723  }
724 
725  if (Loads.empty())
726  return true; // No users, this is a dead argument.
727 
728  // Okay, now we know that the argument is only used by load instructions and
729  // it is safe to unconditionally perform all of them. Use alias analysis to
730  // check to see if the pointer is guaranteed to not be modified from entry of
731  // the function to each of the load instructions.
732 
733  // Because there could be several/many load instructions, remember which
734  // blocks we know to be transparent to the load.
736 
737  for (LoadInst *Load : Loads) {
738  // Check to see if the load is invalidated from the start of the block to
739  // the load itself.
740  BasicBlock *BB = Load->getParent();
741 
743  if (AAR.canInstructionRangeModRef(BB->front(), *Load, Loc, ModRefInfo::Mod))
744  return false; // Pointer is invalidated!
745 
746  // Now check every path from the entry block to the load for transparency.
747  // To do this, we perform a depth first search on the inverse CFG from the
748  // loading block.
749  for (BasicBlock *P : predecessors(BB)) {
750  for (BasicBlock *TranspBB : inverse_depth_first_ext(P, TranspBlocks))
751  if (AAR.canBasicBlockModify(*TranspBB, Loc))
752  return false;
753  }
754  }
755 
756  // If the path from the entry of the function to each load is free of
757  // instructions that potentially invalidate the load, we can make the
758  // transformation!
759  return true;
760 }
761 
763  // There is no size information, so be conservative.
764  if (!type->isSized())
765  return false;
766 
767  // If the alloc size is not equal to the storage size, then there are padding
768  // bytes. For x86_fp80 on x86-64, size: 80 alloc size: 128.
769  if (DL.getTypeSizeInBits(type) != DL.getTypeAllocSizeInBits(type))
770  return false;
771 
772  // FIXME: This isn't the right way to check for padding in vectors with
773  // non-byte-size elements.
774  if (VectorType *seqTy = dyn_cast<VectorType>(type))
775  return isDenselyPacked(seqTy->getElementType(), DL);
776 
777  // For array types, check for padding within members.
778  if (ArrayType *seqTy = dyn_cast<ArrayType>(type))
779  return isDenselyPacked(seqTy->getElementType(), DL);
780 
781  if (!isa<StructType>(type))
782  return true;
783 
784  // Check for padding within and between elements of a struct.
785  StructType *StructTy = cast<StructType>(type);
786  const StructLayout *Layout = DL.getStructLayout(StructTy);
787  uint64_t StartPos = 0;
788  for (unsigned i = 0, E = StructTy->getNumElements(); i < E; ++i) {
789  Type *ElTy = StructTy->getElementType(i);
790  if (!isDenselyPacked(ElTy, DL))
791  return false;
792  if (StartPos != Layout->getElementOffsetInBits(i))
793  return false;
794  StartPos += DL.getTypeAllocSizeInBits(ElTy);
795  }
796 
797  return true;
798 }
799 
800 /// Checks if the padding bytes of an argument could be accessed.
801 static bool canPaddingBeAccessed(Argument *arg) {
802  assert(arg->hasByValAttr());
803 
804  // Track all the pointers to the argument to make sure they are not captured.
805  SmallPtrSet<Value *, 16> PtrValues;
806  PtrValues.insert(arg);
807 
808  // Track all of the stores.
810 
811  // Scan through the uses recursively to make sure the pointer is always used
812  // sanely.
813  SmallVector<Value *, 16> WorkList(arg->users());
814  while (!WorkList.empty()) {
815  Value *V = WorkList.pop_back_val();
816  if (isa<GetElementPtrInst>(V) || isa<PHINode>(V)) {
817  if (PtrValues.insert(V).second)
818  llvm::append_range(WorkList, V->users());
819  } else if (StoreInst *Store = dyn_cast<StoreInst>(V)) {
820  Stores.push_back(Store);
821  } else if (!isa<LoadInst>(V)) {
822  return true;
823  }
824  }
825 
826  // Check to make sure the pointers aren't captured
827  for (StoreInst *Store : Stores)
828  if (PtrValues.count(Store->getValueOperand()))
829  return true;
830 
831  return false;
832 }
833 
835  const Function &F, const TargetTransformInfo &TTI,
836  SmallPtrSetImpl<Argument *> &ArgsToPromote,
837  SmallPtrSetImpl<Argument *> &ByValArgsToTransform) {
838  // TODO: Check individual arguments so we can promote a subset?
840  for (Argument *Arg : ArgsToPromote)
841  Types.push_back(Arg->getType()->getPointerElementType());
842  for (Argument *Arg : ByValArgsToTransform)
843  Types.push_back(Arg->getParamByValType());
844 
845  for (const Use &U : F.uses()) {
846  CallBase *CB = dyn_cast<CallBase>(U.getUser());
847  if (!CB)
848  return false;
849  const Function *Caller = CB->getCaller();
850  const Function *Callee = CB->getCalledFunction();
851  if (!TTI.areTypesABICompatible(Caller, Callee, Types))
852  return false;
853  }
854  return true;
855 }
856 
857 /// PromoteArguments - This method checks the specified function to see if there
858 /// are any promotable arguments and if it is safe to promote the function (for
859 /// example, all callers are direct). If safe to promote some arguments, it
860 /// calls the DoPromotion method.
861 static Function *
863  unsigned MaxElements,
864  Optional<function_ref<void(CallBase &OldCS, CallBase &NewCS)>>
865  ReplaceCallSite,
866  const TargetTransformInfo &TTI) {
867  // Don't perform argument promotion for naked functions; otherwise we can end
868  // up removing parameters that are seemingly 'not used' as they are referred
869  // to in the assembly.
870  if(F->hasFnAttribute(Attribute::Naked))
871  return nullptr;
872 
873  // Make sure that it is local to this module.
874  if (!F->hasLocalLinkage())
875  return nullptr;
876 
877  // Don't promote arguments for variadic functions. Adding, removing, or
878  // changing non-pack parameters can change the classification of pack
879  // parameters. Frontends encode that classification at the call site in the
880  // IR, while in the callee the classification is determined dynamically based
881  // on the number of registers consumed so far.
882  if (F->isVarArg())
883  return nullptr;
884 
885  // Don't transform functions that receive inallocas, as the transformation may
886  // not be safe depending on calling convention.
887  if (F->getAttributes().hasAttrSomewhere(Attribute::InAlloca))
888  return nullptr;
889 
890  // First check: see if there are any pointer arguments! If not, quick exit.
891  SmallVector<Argument *, 16> PointerArgs;
892  for (Argument &I : F->args())
893  if (I.getType()->isPointerTy())
894  PointerArgs.push_back(&I);
895  if (PointerArgs.empty())
896  return nullptr;
897 
898  // Second check: make sure that all callers are direct callers. We can't
899  // transform functions that have indirect callers. Also see if the function
900  // is self-recursive and check that target features are compatible.
901  bool isSelfRecursive = false;
902  for (Use &U : F->uses()) {
903  CallBase *CB = dyn_cast<CallBase>(U.getUser());
904  // Must be a direct call.
905  if (CB == nullptr || !CB->isCallee(&U))
906  return nullptr;
907 
908  // Can't change signature of musttail callee
909  if (CB->isMustTailCall())
910  return nullptr;
911 
912  if (CB->getParent()->getParent() == F)
913  isSelfRecursive = true;
914  }
915 
916  // Can't change signature of musttail caller
917  // FIXME: Support promoting whole chain of musttail functions
918  for (BasicBlock &BB : *F)
919  if (BB.getTerminatingMustTailCall())
920  return nullptr;
921 
922  const DataLayout &DL = F->getParent()->getDataLayout();
923 
924  AAResults &AAR = AARGetter(*F);
925 
926  // Check to see which arguments are promotable. If an argument is promotable,
927  // add it to ArgsToPromote.
928  SmallPtrSet<Argument *, 8> ArgsToPromote;
929  SmallPtrSet<Argument *, 8> ByValArgsToTransform;
930  for (Argument *PtrArg : PointerArgs) {
931  Type *AgTy = cast<PointerType>(PtrArg->getType())->getElementType();
932 
933  // Replace sret attribute with noalias. This reduces register pressure by
934  // avoiding a register copy.
935  if (PtrArg->hasStructRetAttr()) {
936  unsigned ArgNo = PtrArg->getArgNo();
937  F->removeParamAttr(ArgNo, Attribute::StructRet);
938  F->addParamAttr(ArgNo, Attribute::NoAlias);
939  for (Use &U : F->uses()) {
940  CallBase &CB = cast<CallBase>(*U.getUser());
941  CB.removeParamAttr(ArgNo, Attribute::StructRet);
942  CB.addParamAttr(ArgNo, Attribute::NoAlias);
943  }
944  }
945 
946  // If this is a byval argument, and if the aggregate type is small, just
947  // pass the elements, which is always safe, if the passed value is densely
948  // packed or if we can prove the padding bytes are never accessed.
949  //
950  // Only handle arguments with specified alignment; if it's unspecified, the
951  // actual alignment of the argument is target-specific.
952  bool isSafeToPromote = PtrArg->hasByValAttr() && PtrArg->getParamAlign() &&
954  !canPaddingBeAccessed(PtrArg));
955  if (isSafeToPromote) {
956  if (StructType *STy = dyn_cast<StructType>(AgTy)) {
957  if (MaxElements > 0 && STy->getNumElements() > MaxElements) {
958  LLVM_DEBUG(dbgs() << "argpromotion disable promoting argument '"
959  << PtrArg->getName()
960  << "' because it would require adding more"
961  << " than " << MaxElements
962  << " arguments to the function.\n");
963  continue;
964  }
965 
966  // If all the elements are single-value types, we can promote it.
967  bool AllSimple = true;
968  for (const auto *EltTy : STy->elements()) {
969  if (!EltTy->isSingleValueType()) {
970  AllSimple = false;
971  break;
972  }
973  }
974 
975  // Safe to transform, don't even bother trying to "promote" it.
976  // Passing the elements as a scalar will allow sroa to hack on
977  // the new alloca we introduce.
978  if (AllSimple) {
979  ByValArgsToTransform.insert(PtrArg);
980  continue;
981  }
982  }
983  }
984 
985  // If the argument is a recursive type and we're in a recursive
986  // function, we could end up infinitely peeling the function argument.
987  if (isSelfRecursive) {
988  if (StructType *STy = dyn_cast<StructType>(AgTy)) {
989  bool RecursiveType =
990  llvm::is_contained(STy->elements(), PtrArg->getType());
991  if (RecursiveType)
992  continue;
993  }
994  }
995 
996  // Otherwise, see if we can promote the pointer to its value.
997  Type *ByValTy =
998  PtrArg->hasByValAttr() ? PtrArg->getParamByValType() : nullptr;
999  if (isSafeToPromoteArgument(PtrArg, ByValTy, AAR, MaxElements))
1000  ArgsToPromote.insert(PtrArg);
1001  }
1002 
1003  // No promotable pointer arguments.
1004  if (ArgsToPromote.empty() && ByValArgsToTransform.empty())
1005  return nullptr;
1006 
1008  *F, TTI, ArgsToPromote, ByValArgsToTransform))
1009  return nullptr;
1010 
1011  return doPromotion(F, ArgsToPromote, ByValArgsToTransform, ReplaceCallSite);
1012 }
1013 
1016  LazyCallGraph &CG,
1017  CGSCCUpdateResult &UR) {
1018  bool Changed = false, LocalChange;
1019 
1020  // Iterate until we stop promoting from this SCC.
1021  do {
1022  LocalChange = false;
1023 
1025  AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C, CG).getManager();
1026 
1027  for (LazyCallGraph::Node &N : C) {
1028  Function &OldF = N.getFunction();
1029 
1030  // FIXME: This lambda must only be used with this function. We should
1031  // skip the lambda and just get the AA results directly.
1032  auto AARGetter = [&](Function &F) -> AAResults & {
1033  assert(&F == &OldF && "Called with an unexpected function!");
1034  return FAM.getResult<AAManager>(F);
1035  };
1036 
1038  Function *NewF =
1039  promoteArguments(&OldF, AARGetter, MaxElements, None, TTI);
1040  if (!NewF)
1041  continue;
1042  LocalChange = true;
1043 
1044  // Directly substitute the functions in the call graph. Note that this
1045  // requires the old function to be completely dead and completely
1046  // replaced by the new function. It does no call graph updates, it merely
1047  // swaps out the particular function mapped to a particular node in the
1048  // graph.
1049  C.getOuterRefSCC().replaceNodeFunction(N, *NewF);
1050  FAM.clear(OldF, OldF.getName());
1051  OldF.eraseFromParent();
1052 
1053  PreservedAnalyses FuncPA;
1054  FuncPA.preserveSet<CFGAnalyses>();
1055  for (auto *U : NewF->users()) {
1056  auto *UserF = cast<CallBase>(U)->getFunction();
1057  FAM.invalidate(*UserF, FuncPA);
1058  }
1059  }
1060 
1061  Changed |= LocalChange;
1062  } while (LocalChange);
1063 
1064  if (!Changed)
1065  return PreservedAnalyses::all();
1066 
1067  PreservedAnalyses PA;
1068  // We've cleared out analyses for deleted functions.
1070  // We've manually invalidated analyses for functions we've modified.
1072  return PA;
1073 }
1074 
1075 namespace {
1076 
1077 /// ArgPromotion - The 'by reference' to 'by value' argument promotion pass.
1078 struct ArgPromotion : public CallGraphSCCPass {
1079  // Pass identification, replacement for typeid
1080  static char ID;
1081 
1082  explicit ArgPromotion(unsigned MaxElements = 3)
1083  : CallGraphSCCPass(ID), MaxElements(MaxElements) {
1085  }
1086 
1087  void getAnalysisUsage(AnalysisUsage &AU) const override {
1093  }
1094 
1095  bool runOnSCC(CallGraphSCC &SCC) override;
1096 
1097 private:
1099 
1100  bool doInitialization(CallGraph &CG) override;
1101 
1102  /// The maximum number of elements to expand, or 0 for unlimited.
1103  unsigned MaxElements;
1104 };
1105 
1106 } // end anonymous namespace
1107 
1108 char ArgPromotion::ID = 0;
1109 
1110 INITIALIZE_PASS_BEGIN(ArgPromotion, "argpromotion",
1111  "Promote 'by reference' arguments to scalars", false,
1112  false)
1118  "Promote 'by reference' arguments to scalars", false, false)
1119 
1120 Pass *llvm::createArgumentPromotionPass(unsigned MaxElements) {
1121  return new ArgPromotion(MaxElements);
1122 }
1123 
1124 bool ArgPromotion::runOnSCC(CallGraphSCC &SCC) {
1125  if (skipSCC(SCC))
1126  return false;
1127 
1128  // Get the callgraph information that we need to update to reflect our
1129  // changes.
1130  CallGraph &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();
1131 
1132  LegacyAARGetter AARGetter(*this);
1133 
1134  bool Changed = false, LocalChange;
1135 
1136  // Iterate until we stop promoting from this SCC.
1137  do {
1138  LocalChange = false;
1139  // Attempt to promote arguments from all functions in this SCC.
1140  for (CallGraphNode *OldNode : SCC) {
1141  Function *OldF = OldNode->getFunction();
1142  if (!OldF)
1143  continue;
1144 
1145  auto ReplaceCallSite = [&](CallBase &OldCS, CallBase &NewCS) {
1146  Function *Caller = OldCS.getParent()->getParent();
1147  CallGraphNode *NewCalleeNode =
1148  CG.getOrInsertFunction(NewCS.getCalledFunction());
1149  CallGraphNode *CallerNode = CG[Caller];
1150  CallerNode->replaceCallEdge(cast<CallBase>(OldCS),
1151  cast<CallBase>(NewCS), NewCalleeNode);
1152  };
1153 
1154  const TargetTransformInfo &TTI =
1155  getAnalysis<TargetTransformInfoWrapperPass>().getTTI(*OldF);
1156  if (Function *NewF = promoteArguments(OldF, AARGetter, MaxElements,
1157  {ReplaceCallSite}, TTI)) {
1158  LocalChange = true;
1159 
1160  // Update the call graph for the newly promoted function.
1161  CallGraphNode *NewNode = CG.getOrInsertFunction(NewF);
1162  NewNode->stealCalledFunctionsFrom(OldNode);
1163  if (OldNode->getNumReferences() == 0)
1164  delete CG.removeFunctionFromModule(OldNode);
1165  else
1167 
1168  // And updat ethe SCC we're iterating as well.
1169  SCC.ReplaceNode(OldNode, NewNode);
1170  }
1171  }
1172  // Remember that we changed something.
1173  Changed |= LocalChange;
1174  } while (LocalChange);
1175 
1176  return Changed;
1177 }
1178 
1179 bool ArgPromotion::doInitialization(CallGraph &CG) {
1181 }
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:1287
llvm::TargetIRAnalysis
Analysis pass providing the TargetTransformInfo.
Definition: TargetTransformInfo.h:2418
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
This is an optimization pass for GlobalISel generic memory operations.
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:375
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:3813
llvm::make_range
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Definition: iterator_range.h:53
llvm::drop_begin
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
Definition: STLExtras.h:321
NoFolder.h
Optional.h
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:113
type
Metadata.h
llvm::User::operands
op_range operands()
Definition: User.h:242
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:783
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:700
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:834
Loads.h
llvm::Function
Definition: Function.h:62
llvm::AnalysisManager::invalidate
void invalidate(IRUnitT &IR, const PreservedAnalyses &PA)
Invalidate cached analyses for an IR unit.
Definition: PassManagerImpl.h:89
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:1177
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:2518
llvm::AllAnalysesOn
This templated class represents "all analyses that operate over <a particular IR unit>" (e....
Definition: PassManager.h:93
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:363
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:1029
llvm::CallGraph
The basic data container for the call graph of a Module of IR.
Definition: CallGraph.h:73
FAM
FunctionAnalysisManager FAM
Definition: PassBuilderBindings.cpp:59
to
Should compile to
Definition: README.txt:449
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:404
llvm::CallBase::getAttributes
AttributeList getAttributes() const
Return the parameter attributes for this call.
Definition: InstrTypes.h:1473
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:1406
llvm::AttributeList::getFnAttrs
AttributeSet getFnAttrs() const
The function attributes are returned.
Definition: Attributes.cpp:1384
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:839
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:1318
llvm::SmallVectorImpl::pop_back_val
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:644
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:1681
llvm::CallBase::addParamAttr
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Adds the attribute to the indicated argument.
Definition: InstrTypes.h:1525
BasicAliasAnalysis.h
llvm::LoadInst::getAlign
Align getAlign() const
Return the alignment of the access that is being performed.
Definition: Instructions.h:228
Use.h
llvm::Type::getInt32Ty
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:241
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:507
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:991
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::ArgumentPromotionPass::run
PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM, LazyCallGraph &CG, CGSCCUpdateResult &UR)
Definition: ArgumentPromotion.cpp:1014
llvm::FunctionType::isVarArg
bool isVarArg() const
Definition: DerivedTypes.h:123
scalars
Promote by reference arguments to scalars
Definition: ArgumentPromotion.cpp:1118
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:185
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:1567
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:507
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:1398
llvm::CallBase::setAttributes
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
Definition: InstrTypes.h:1477
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:1664
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:1521
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:657
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::predecessors
auto predecessors(MachineBasicBlock *BB)
Definition: MachineSSAContext.h:32
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:376
llvm::UndefValue::get
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1804
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:932
SmallPtrSet.h
llvm::Instruction::getAAMetadata
AAMDNodes getAAMetadata() const
Returns the AA metadata for this instruction.
Definition: Metadata.cpp:1370
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
FormatVariadic.h
llvm::CallBase::getCallingConv
CallingConv::ID getCallingConv() const
Definition: InstrTypes.h:1454
llvm::TargetTransformInfo::areTypesABICompatible
bool areTypesABICompatible(const Function *Caller, const Function *Callee, const ArrayRef< Type * > &Types) const
Definition: TargetTransformInfo.cpp:995
llvm::None
const NoneType None
Definition: None.h:23
llvm::Value::use_empty
bool use_empty() const
Definition: Value.h:344
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:3769
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:223
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:309
llvm::AttributeList::getRetAttrs
AttributeSet getRetAttrs() const
The attributes for the ret value are returned.
Definition: Attributes.cpp:1380
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:465
uint64_t
llvm::StructLayout
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
Definition: DataLayout.h:622
llvm::SPII::Store
@ Store
Definition: SparcInstrInfo.h:33
llvm::TargetTransformInfoWrapperPass
Wrapper pass for TargetTransformInfo.
Definition: TargetTransformInfo.h:2474
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)
llvm::PreservedAnalyses::preserve
void preserve()
Mark an analysis as preserved.
Definition: PassManager.h:176
IPO.h
llvm::GlobalObject::copyMetadata
void copyMetadata(const GlobalObject *Src, unsigned Offset)
Copy metadata from Src, adjusting offsets by Offset.
Definition: Metadata.cpp:1466
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:790
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:58
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:933
llvm::LoadInst::setAlignment
void setAlignment(Align Align)
Definition: Instructions.h:232
canPaddingBeAccessed
static bool canPaddingBeAccessed(Argument *arg)
Checks if the padding bytes of an argument could be accessed.
Definition: ArgumentPromotion.cpp:801
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:642
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:1714
llvm::GlobalValue::setLinkage
void setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:460
llvm::Function::Create
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:139
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::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:1120
llvm::CallBase::arg_end
User::op_iterator arg_end()
Return the iterator pointing to the end of the argument list.
Definition: InstrTypes.h:1324
llvm::SPII::Load
@ Load
Definition: SparcInstrInfo.h:32
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:137
llvm::df_iterator_default_set
Definition: DepthFirstIterator.h:69
llvm::AMDGPU::CPol::SCC
@ SCC
Definition: SIDefines.h:296
llvm::GetElementPtrInst::Create
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:959
llvm::AssumptionCacheTracker
An immutable pass that tracks lazily created AssumptionCache objects.
Definition: AssumptionCache.h:202
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:255
llvm::CFGAnalyses
Represents analyses that only rely on functions' control flow.
Definition: PassManager.h:116
llvm::Value::replaceAllUsesWith
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:532
llvm::append_range
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Definition: STLExtras.h:1846
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:309
llvm::LoadInst
An instruction for reading from memory.
Definition: Instructions.h:180
llvm::Function::begin
iterator begin()
Definition: Function.h:723
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:1740
Argument.h
Callee
amdgpu Simplify well known AMD library false FunctionCallee Callee
Definition: AMDGPULibCalls.cpp:185
Attributes.h
isPrefix
static bool isPrefix(const IndicesVector &Prefix, const IndicesVector &Longer)
Returns true if Prefix is a prefix of longer.
Definition: ArgumentPromotion.cpp:500
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:242
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:652
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 AA metadata on this instruction from the AAMDNodes structure.
Definition: Metadata.cpp:1379
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:1728
argpromotion
argpromotion
Definition: ArgumentPromotion.cpp:1117
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:862
PassManager.h
llvm::SmallVectorImpl::clear
void clear()
Definition: SmallVector.h:581
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:1768
llvm::Function::arg_begin
arg_iterator arg_begin()
Definition: Function.h:738
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:762
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:562
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::PreservedAnalyses::preserveSet
void preserveSet()
Mark an analysis set as preserved.
Definition: PassManager.h:191
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:211
llvm::AttributeSet
Definition: Attributes.h:271
SmallVector.h
User.h
llvm::CallBase::getArgOperand
Value * getArgOperand(unsigned i) const
Definition: InstrTypes.h:1343
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:526
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:780
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:1176
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:382
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:1376
llvm::FunctionAnalysisManagerCGSCCProxy
A proxy from a FunctionAnalysisManager to an SCC.
Definition: CGSCCPassManager.h:408
Value.h
llvm::Function::setAttributes
void setAttributes(AttributeList Attrs)
Set the attribute list for this Function.
Definition: Function.h:319
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:202
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:478
llvm::FunctionType::getReturnType
Type * getReturnType() const
Definition: DerivedTypes.h:124
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
Debug.h
llvm::Value::users
iterator_range< user_iterator > users()
Definition: Value.h:421
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:1458
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:38
llvm::SmallVectorImpl::insert
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:782
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