LLVM  13.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 <string>
86 #include <utility>
87 #include <vector>
88 
89 using namespace llvm;
90 
91 #define DEBUG_TYPE "argpromotion"
92 
93 STATISTIC(NumArgumentsPromoted, "Number of pointer arguments promoted");
94 STATISTIC(NumAggregatesPromoted, "Number of aggregate arguments promoted");
95 STATISTIC(NumByValArgsPromoted, "Number of byval arguments promoted");
96 STATISTIC(NumArgumentsDead, "Number of dead pointer args eliminated");
97 
98 /// A vector used to hold the indices of a single GEP instruction
99 using IndicesVector = std::vector<uint64_t>;
100 
101 /// DoPromotion - This method actually performs the promotion of the specified
102 /// arguments, and returns the new function. At this point, we know that it's
103 /// safe to do so.
104 static Function *
106  SmallPtrSetImpl<Argument *> &ByValArgsToTransform,
107  Optional<function_ref<void(CallBase &OldCS, CallBase &NewCS)>>
108  ReplaceCallSite) {
109  // Start by computing a new prototype for the function, which is the same as
110  // the old function, but has modified arguments.
111  FunctionType *FTy = F->getFunctionType();
112  std::vector<Type *> Params;
113 
114  using ScalarizeTable = std::set<std::pair<Type *, IndicesVector>>;
115 
116  // ScalarizedElements - If we are promoting a pointer that has elements
117  // accessed out of it, keep track of which elements are accessed so that we
118  // can add one argument for each.
119  //
120  // Arguments that are directly loaded will have a zero element value here, to
121  // handle cases where there are both a direct load and GEP accesses.
122  std::map<Argument *, ScalarizeTable> ScalarizedElements;
123 
124  // OriginalLoads - Keep track of a representative load instruction from the
125  // original function so that we can tell the alias analysis implementation
126  // what the new GEP/Load instructions we are inserting look like.
127  // We need to keep the original loads for each argument and the elements
128  // of the argument that are accessed.
129  std::map<std::pair<Argument *, IndicesVector>, LoadInst *> OriginalLoads;
130 
131  // Attribute - Keep track of the parameter attributes for the arguments
132  // that we are *not* promoting. For the ones that we do promote, the parameter
133  // attributes are lost
134  SmallVector<AttributeSet, 8> ArgAttrVec;
135  AttributeList PAL = F->getAttributes();
136 
137  // First, determine the new argument list
138  unsigned ArgNo = 0;
139  for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E;
140  ++I, ++ArgNo) {
141  if (ByValArgsToTransform.count(&*I)) {
142  // Simple byval argument? Just add all the struct element types.
143  Type *AgTy = cast<PointerType>(I->getType())->getElementType();
144  StructType *STy = cast<StructType>(AgTy);
145  llvm::append_range(Params, STy->elements());
146  ArgAttrVec.insert(ArgAttrVec.end(), STy->getNumElements(),
147  AttributeSet());
148  ++NumByValArgsPromoted;
149  } else if (!ArgsToPromote.count(&*I)) {
150  // Unchanged argument
151  Params.push_back(I->getType());
152  ArgAttrVec.push_back(PAL.getParamAttributes(ArgNo));
153  } else if (I->use_empty()) {
154  // Dead argument (which are always marked as promotable)
155  ++NumArgumentsDead;
156  } else {
157  // Okay, this is being promoted. This means that the only uses are loads
158  // or GEPs which are only used by loads
159 
160  // In this table, we will track which indices are loaded from the argument
161  // (where direct loads are tracked as no indices).
162  ScalarizeTable &ArgIndices = ScalarizedElements[&*I];
163  for (User *U : make_early_inc_range(I->users())) {
164  Instruction *UI = cast<Instruction>(U);
165  Type *SrcTy;
166  if (LoadInst *L = dyn_cast<LoadInst>(UI))
167  SrcTy = L->getType();
168  else
169  SrcTy = cast<GetElementPtrInst>(UI)->getSourceElementType();
170  // Skip dead GEPs and remove them.
171  if (isa<GetElementPtrInst>(UI) && UI->use_empty()) {
172  UI->eraseFromParent();
173  continue;
174  }
175 
176  IndicesVector Indices;
177  Indices.reserve(UI->getNumOperands() - 1);
178  // Since loads will only have a single operand, and GEPs only a single
179  // non-index operand, this will record direct loads without any indices,
180  // and gep+loads with the GEP indices.
181  for (User::op_iterator II = UI->op_begin() + 1, IE = UI->op_end();
182  II != IE; ++II)
183  Indices.push_back(cast<ConstantInt>(*II)->getSExtValue());
184  // GEPs with a single 0 index can be merged with direct loads
185  if (Indices.size() == 1 && Indices.front() == 0)
186  Indices.clear();
187  ArgIndices.insert(std::make_pair(SrcTy, Indices));
188  LoadInst *OrigLoad;
189  if (LoadInst *L = dyn_cast<LoadInst>(UI))
190  OrigLoad = L;
191  else
192  // Take any load, we will use it only to update Alias Analysis
193  OrigLoad = cast<LoadInst>(UI->user_back());
194  OriginalLoads[std::make_pair(&*I, Indices)] = OrigLoad;
195  }
196 
197  // Add a parameter to the function for each element passed in.
198  for (const auto &ArgIndex : ArgIndices) {
199  // not allowed to dereference ->begin() if size() is 0
200  Params.push_back(GetElementPtrInst::getIndexedType(
201  cast<PointerType>(I->getType())->getElementType(),
202  ArgIndex.second));
203  ArgAttrVec.push_back(AttributeSet());
204  assert(Params.back());
205  }
206 
207  if (ArgIndices.size() == 1 && ArgIndices.begin()->second.empty())
208  ++NumArgumentsPromoted;
209  else
210  ++NumAggregatesPromoted;
211  }
212  }
213 
214  Type *RetTy = FTy->getReturnType();
215 
216  // Construct the new function type using the new arguments.
217  FunctionType *NFTy = FunctionType::get(RetTy, Params, FTy->isVarArg());
218 
219  // Create the new function body and insert it into the module.
220  Function *NF = Function::Create(NFTy, F->getLinkage(), F->getAddressSpace(),
221  F->getName());
222  NF->copyAttributesFrom(F);
223  NF->copyMetadata(F, 0);
224 
225  // The new function will have the !dbg metadata copied from the original
226  // function. The original function may not be deleted, and dbg metadata need
227  // to be unique so we need to drop it.
228  F->setSubprogram(nullptr);
229 
230  LLVM_DEBUG(dbgs() << "ARG PROMOTION: Promoting to:" << *NF << "\n"
231  << "From: " << *F);
232 
233  // Recompute the parameter attributes list based on the new arguments for
234  // the function.
235  NF->setAttributes(AttributeList::get(F->getContext(), PAL.getFnAttributes(),
236  PAL.getRetAttributes(), ArgAttrVec));
237  ArgAttrVec.clear();
238 
239  F->getParent()->getFunctionList().insert(F->getIterator(), NF);
240  NF->takeName(F);
241 
242  // Loop over all of the callers of the function, transforming the call sites
243  // to pass in the loaded pointers.
244  //
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.getParamAttributes(ArgNo));
261  } else if (ByValArgsToTransform.count(&*I)) {
262  // Emit a GEP and load for each element of the struct.
263  Type *AgTy = cast<PointerType>(I->getType())->getElementType();
264  StructType *STy = cast<StructType>(AgTy);
265  Value *Idxs[2] = {
266  ConstantInt::get(Type::getInt32Ty(F->getContext()), 0), nullptr};
267  for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
268  Idxs[1] = ConstantInt::get(Type::getInt32Ty(F->getContext()), i);
269  auto *Idx =
270  IRB.CreateGEP(STy, *AI, Idxs, (*AI)->getName() + "." + Twine(i));
271  // TODO: Tell AA about the new values?
272  Args.push_back(IRB.CreateLoad(STy->getElementType(i), Idx,
273  Idx->getName() + ".val"));
274  ArgAttrVec.push_back(AttributeSet());
275  }
276  } else if (!I->use_empty()) {
277  // Non-dead argument: insert GEPs and loads as appropriate.
278  ScalarizeTable &ArgIndices = ScalarizedElements[&*I];
279  // Store the Value* version of the indices in here, but declare it now
280  // for reuse.
281  std::vector<Value *> Ops;
282  for (const auto &ArgIndex : ArgIndices) {
283  Value *V = *AI;
284  LoadInst *OrigLoad =
285  OriginalLoads[std::make_pair(&*I, ArgIndex.second)];
286  if (!ArgIndex.second.empty()) {
287  Ops.reserve(ArgIndex.second.size());
288  Type *ElTy = V->getType();
289  for (auto II : ArgIndex.second) {
290  // Use i32 to index structs, and i64 for others (pointers/arrays).
291  // This satisfies GEP constraints.
292  Type *IdxTy =
293  (ElTy->isStructTy() ? Type::getInt32Ty(F->getContext())
294  : Type::getInt64Ty(F->getContext()));
295  Ops.push_back(ConstantInt::get(IdxTy, II));
296  // Keep track of the type we're currently indexing.
297  if (auto *ElPTy = dyn_cast<PointerType>(ElTy))
298  ElTy = ElPTy->getElementType();
299  else
300  ElTy = GetElementPtrInst::getTypeAtIndex(ElTy, II);
301  }
302  // And create a GEP to extract those indices.
303  V = IRB.CreateGEP(ArgIndex.first, V, Ops, V->getName() + ".idx");
304  Ops.clear();
305  }
306  // Since we're replacing a load make sure we take the alignment
307  // of the previous load.
308  LoadInst *newLoad =
309  IRB.CreateLoad(OrigLoad->getType(), V, V->getName() + ".val");
310  newLoad->setAlignment(OrigLoad->getAlign());
311  // Transfer the AA info too.
312  AAMDNodes AAInfo;
313  OrigLoad->getAAMetadata(AAInfo);
314  newLoad->setAAMetadata(AAInfo);
315 
316  Args.push_back(newLoad);
317  ArgAttrVec.push_back(AttributeSet());
318  }
319  }
320 
321  // Push any varargs arguments on the list.
322  for (; AI != CB.arg_end(); ++AI, ++ArgNo) {
323  Args.push_back(*AI);
324  ArgAttrVec.push_back(CallPAL.getParamAttributes(ArgNo));
325  }
326 
328  CB.getOperandBundlesAsDefs(OpBundles);
329 
330  CallBase *NewCS = nullptr;
331  if (InvokeInst *II = dyn_cast<InvokeInst>(&CB)) {
332  NewCS = InvokeInst::Create(NF, II->getNormalDest(), II->getUnwindDest(),
333  Args, OpBundles, "", &CB);
334  } else {
335  auto *NewCall = CallInst::Create(NF, Args, OpBundles, "", &CB);
336  NewCall->setTailCallKind(cast<CallInst>(&CB)->getTailCallKind());
337  NewCS = NewCall;
338  }
339  NewCS->setCallingConv(CB.getCallingConv());
340  NewCS->setAttributes(
341  AttributeList::get(F->getContext(), CallPAL.getFnAttributes(),
342  CallPAL.getRetAttributes(), ArgAttrVec));
343  NewCS->copyMetadata(CB, {LLVMContext::MD_prof, LLVMContext::MD_dbg});
344  Args.clear();
345  ArgAttrVec.clear();
346 
347  // Update the callgraph to know that the callsite has been transformed.
348  if (ReplaceCallSite)
349  (*ReplaceCallSite)(CB, *NewCS);
350 
351  if (!CB.use_empty()) {
352  CB.replaceAllUsesWith(NewCS);
353  NewCS->takeName(&CB);
354  }
355 
356  // Finally, remove the old call from the program, reducing the use-count of
357  // F.
358  CB.eraseFromParent();
359  }
360 
361  const DataLayout &DL = F->getParent()->getDataLayout();
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 = cast<PointerType>(I->getType())->getElementType();
389  Value *TheAlloca = new AllocaInst(
390  AgTy, DL.getAllocaAddrSpace(), nullptr,
391  I->getParamAlign().getValueOr(DL.getPrefTypeAlign(AgTy)), "",
392  InsertPt);
393  StructType *STy = cast<StructType>(AgTy);
394  Value *Idxs[2] = {ConstantInt::get(Type::getInt32Ty(F->getContext()), 0),
395  nullptr};
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  new StoreInst(&*I2++, Idx, InsertPt);
404  }
405 
406  // Anything that used the arg should now use the alloca.
407  I->replaceAllUsesWith(TheAlloca);
408  TheAlloca->takeName(&*I);
409 
410  // If the alloca is used in a call, we must clear the tail flag since
411  // the callee now uses an alloca from the caller.
412  for (User *U : TheAlloca->users()) {
413  CallInst *Call = dyn_cast<CallInst>(U);
414  if (!Call)
415  continue;
416  Call->setTailCall(false);
417  }
418  continue;
419  }
420 
421  // There potentially are metadata uses for things like llvm.dbg.value.
422  // Replace them with undef, after handling the other regular uses.
423  auto RauwUndefMetadata = make_scope_exit(
424  [&]() { I->replaceAllUsesWith(UndefValue::get(I->getType())); });
425 
426  if (I->use_empty())
427  continue;
428 
429  // Otherwise, if we promoted this argument, then all users are load
430  // instructions (or GEPs with only load users), and all loads should be
431  // using the new argument that we added.
432  ScalarizeTable &ArgIndices = ScalarizedElements[&*I];
433 
434  while (!I->use_empty()) {
435  if (LoadInst *LI = dyn_cast<LoadInst>(I->user_back())) {
436  assert(ArgIndices.begin()->second.empty() &&
437  "Load element should sort to front!");
438  I2->setName(I->getName() + ".val");
439  LI->replaceAllUsesWith(&*I2);
440  LI->eraseFromParent();
441  LLVM_DEBUG(dbgs() << "*** Promoted load of argument '" << I->getName()
442  << "' in function '" << F->getName() << "'\n");
443  } else {
444  GetElementPtrInst *GEP = cast<GetElementPtrInst>(I->user_back());
445  assert(!GEP->use_empty() &&
446  "GEPs without uses should be cleaned up already");
448  Operands.reserve(GEP->getNumIndices());
449  for (const Use &Idx : GEP->indices())
450  Operands.push_back(cast<ConstantInt>(Idx)->getSExtValue());
451 
452  // GEPs with a single 0 index can be merged with direct loads
453  if (Operands.size() == 1 && Operands.front() == 0)
454  Operands.clear();
455 
456  Function::arg_iterator TheArg = I2;
457  for (ScalarizeTable::iterator It = ArgIndices.begin();
458  It->second != Operands; ++It, ++TheArg) {
459  assert(It != ArgIndices.end() && "GEP not handled??");
460  }
461 
462  TheArg->setName(formatv("{0}.{1:$[.]}.val", I->getName(),
463  make_range(Operands.begin(), Operands.end())));
464 
465  LLVM_DEBUG(dbgs() << "*** Promoted agg argument '" << TheArg->getName()
466  << "' of function '" << NF->getName() << "'\n");
467 
468  // All of the uses must be load instructions. Replace them all with
469  // the argument specified by ArgNo.
470  while (!GEP->use_empty()) {
471  LoadInst *L = cast<LoadInst>(GEP->user_back());
472  L->replaceAllUsesWith(&*TheArg);
473  L->eraseFromParent();
474  }
475  GEP->eraseFromParent();
476  }
477  }
478  // Increment I2 past all of the arguments added for this promoted pointer.
479  std::advance(I2, ArgIndices.size());
480  }
481 
482  return NF;
483 }
484 
485 /// Return true if we can prove that all callees pass in a valid pointer for the
486 /// specified function argument.
488  Function *Callee = Arg->getParent();
489  const DataLayout &DL = Callee->getParent()->getDataLayout();
490 
491  unsigned ArgNo = Arg->getArgNo();
492 
493  // Look at all call sites of the function. At this point we know we only have
494  // direct callees.
495  for (User *U : Callee->users()) {
496  CallBase &CB = cast<CallBase>(*U);
497 
498  if (!isDereferenceablePointer(CB.getArgOperand(ArgNo), Ty, DL))
499  return false;
500  }
501  return true;
502 }
503 
504 /// Returns true if Prefix is a prefix of longer. That means, Longer has a size
505 /// that is greater than or equal to the size of prefix, and each of the
506 /// elements in Prefix is the same as the corresponding elements in Longer.
507 ///
508 /// This means it also returns true when Prefix and Longer are equal!
509 static bool isPrefix(const IndicesVector &Prefix, const IndicesVector &Longer) {
510  if (Prefix.size() > Longer.size())
511  return false;
512  return std::equal(Prefix.begin(), Prefix.end(), Longer.begin());
513 }
514 
515 /// Checks if Indices, or a prefix of Indices, is in Set.
516 static bool prefixIn(const IndicesVector &Indices,
517  std::set<IndicesVector> &Set) {
518  std::set<IndicesVector>::iterator Low;
519  Low = Set.upper_bound(Indices);
520  if (Low != Set.begin())
521  Low--;
522  // Low is now the last element smaller than or equal to Indices. This means
523  // it points to a prefix of Indices (possibly Indices itself), if such
524  // prefix exists.
525  //
526  // This load is safe if any prefix of its operands is safe to load.
527  return Low != Set.end() && isPrefix(*Low, Indices);
528 }
529 
530 /// Mark the given indices (ToMark) as safe in the given set of indices
531 /// (Safe). Marking safe usually means adding ToMark to Safe. However, if there
532 /// is already a prefix of Indices in Safe, Indices are implicitely marked safe
533 /// already. Furthermore, any indices that Indices is itself a prefix of, are
534 /// removed from Safe (since they are implicitely safe because of Indices now).
535 static void markIndicesSafe(const IndicesVector &ToMark,
536  std::set<IndicesVector> &Safe) {
537  std::set<IndicesVector>::iterator Low;
538  Low = Safe.upper_bound(ToMark);
539  // Guard against the case where Safe is empty
540  if (Low != Safe.begin())
541  Low--;
542  // Low is now the last element smaller than or equal to Indices. This
543  // means it points to a prefix of Indices (possibly Indices itself), if
544  // such prefix exists.
545  if (Low != Safe.end()) {
546  if (isPrefix(*Low, ToMark))
547  // If there is already a prefix of these indices (or exactly these
548  // indices) marked a safe, don't bother adding these indices
549  return;
550 
551  // Increment Low, so we can use it as a "insert before" hint
552  ++Low;
553  }
554  // Insert
555  Low = Safe.insert(Low, ToMark);
556  ++Low;
557  // If there we're a prefix of longer index list(s), remove those
558  std::set<IndicesVector>::iterator End = Safe.end();
559  while (Low != End && isPrefix(ToMark, *Low)) {
560  std::set<IndicesVector>::iterator Remove = Low;
561  ++Low;
562  Safe.erase(Remove);
563  }
564 }
565 
566 /// isSafeToPromoteArgument - As you might guess from the name of this method,
567 /// it checks to see if it is both safe and useful to promote the argument.
568 /// This method limits promotion of aggregates to only promote up to three
569 /// elements of the aggregate in order to avoid exploding the number of
570 /// arguments passed in.
571 static bool isSafeToPromoteArgument(Argument *Arg, Type *ByValTy, AAResults &AAR,
572  unsigned MaxElements) {
573  using GEPIndicesSet = std::set<IndicesVector>;
574 
575  // Quick exit for unused arguments
576  if (Arg->use_empty())
577  return true;
578 
579  // We can only promote this argument if all of the uses are loads, or are GEP
580  // instructions (with constant indices) that are subsequently loaded.
581  //
582  // Promoting the argument causes it to be loaded in the caller
583  // unconditionally. This is only safe if we can prove that either the load
584  // would have happened in the callee anyway (ie, there is a load in the entry
585  // block) or the pointer passed in at every call site is guaranteed to be
586  // valid.
587  // In the former case, invalid loads can happen, but would have happened
588  // anyway, in the latter case, invalid loads won't happen. This prevents us
589  // from introducing an invalid load that wouldn't have happened in the
590  // original code.
591  //
592  // This set will contain all sets of indices that are loaded in the entry
593  // block, and thus are safe to unconditionally load in the caller.
594  GEPIndicesSet SafeToUnconditionallyLoad;
595 
596  // This set contains all the sets of indices that we are planning to promote.
597  // This makes it possible to limit the number of arguments added.
598  GEPIndicesSet ToPromote;
599 
600  // If the pointer is always valid, any load with first index 0 is valid.
601 
602  if (ByValTy)
603  SafeToUnconditionallyLoad.insert(IndicesVector(1, 0));
604 
605  // Whenever a new underlying type for the operand is found, make sure it's
606  // consistent with the GEPs and loads we've already seen and, if necessary,
607  // use it to see if all incoming pointers are valid (which implies the 0-index
608  // is safe).
609  Type *BaseTy = ByValTy;
610  auto UpdateBaseTy = [&](Type *NewBaseTy) {
611  if (BaseTy)
612  return BaseTy == NewBaseTy;
613 
614  BaseTy = NewBaseTy;
616  assert(SafeToUnconditionallyLoad.empty());
617  SafeToUnconditionallyLoad.insert(IndicesVector(1, 0));
618  }
619 
620  return true;
621  };
622 
623  // First, iterate the entry block and mark loads of (geps of) arguments as
624  // safe.
625  BasicBlock &EntryBlock = Arg->getParent()->front();
626  // Declare this here so we can reuse it
627  IndicesVector Indices;
628  for (Instruction &I : EntryBlock)
629  if (LoadInst *LI = dyn_cast<LoadInst>(&I)) {
630  Value *V = LI->getPointerOperand();
631  if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(V)) {
632  V = GEP->getPointerOperand();
633  if (V == Arg) {
634  // This load actually loads (part of) Arg? Check the indices then.
635  Indices.reserve(GEP->getNumIndices());
636  for (Use &Idx : GEP->indices())
637  if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx))
638  Indices.push_back(CI->getSExtValue());
639  else
640  // We found a non-constant GEP index for this argument? Bail out
641  // right away, can't promote this argument at all.
642  return false;
643 
644  if (!UpdateBaseTy(GEP->getSourceElementType()))
645  return false;
646 
647  // Indices checked out, mark them as safe
648  markIndicesSafe(Indices, SafeToUnconditionallyLoad);
649  Indices.clear();
650  }
651  } else if (V == Arg) {
652  // Direct loads are equivalent to a GEP with a single 0 index.
653  markIndicesSafe(IndicesVector(1, 0), SafeToUnconditionallyLoad);
654 
655  if (BaseTy && LI->getType() != BaseTy)
656  return false;
657 
658  BaseTy = LI->getType();
659  }
660  }
661 
662  // Now, iterate all uses of the argument to see if there are any uses that are
663  // not (GEP+)loads, or any (GEP+)loads that are not safe to promote.
666  for (Use &U : Arg->uses()) {
667  User *UR = U.getUser();
668  Operands.clear();
669  if (LoadInst *LI = dyn_cast<LoadInst>(UR)) {
670  // Don't hack volatile/atomic loads
671  if (!LI->isSimple())
672  return false;
673  Loads.push_back(LI);
674  // Direct loads are equivalent to a GEP with a zero index and then a load.
675  Operands.push_back(0);
676 
677  if (!UpdateBaseTy(LI->getType()))
678  return false;
679  } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(UR)) {
680  if (GEP->use_empty()) {
681  // Dead GEP's cause trouble later. Just remove them if we run into
682  // them.
683  continue;
684  }
685 
686  if (!UpdateBaseTy(GEP->getSourceElementType()))
687  return false;
688 
689  // Ensure that all of the indices are constants.
690  for (Use &Idx : GEP->indices())
691  if (ConstantInt *C = dyn_cast<ConstantInt>(Idx))
692  Operands.push_back(C->getSExtValue());
693  else
694  return false; // Not a constant operand GEP!
695 
696  // Ensure that the only users of the GEP are load instructions.
697  for (User *GEPU : GEP->users())
698  if (LoadInst *LI = dyn_cast<LoadInst>(GEPU)) {
699  // Don't hack volatile/atomic loads
700  if (!LI->isSimple())
701  return false;
702  Loads.push_back(LI);
703  } else {
704  // Other uses than load?
705  return false;
706  }
707  } else {
708  return false; // Not a load or a GEP.
709  }
710 
711  // Now, see if it is safe to promote this load / loads of this GEP. Loading
712  // is safe if Operands, or a prefix of Operands, is marked as safe.
713  if (!prefixIn(Operands, SafeToUnconditionallyLoad))
714  return false;
715 
716  // See if we are already promoting a load with these indices. If not, check
717  // to make sure that we aren't promoting too many elements. If so, nothing
718  // to do.
719  if (ToPromote.find(Operands) == ToPromote.end()) {
720  if (MaxElements > 0 && ToPromote.size() == MaxElements) {
721  LLVM_DEBUG(dbgs() << "argpromotion not promoting argument '"
722  << Arg->getName()
723  << "' because it would require adding more "
724  << "than " << MaxElements
725  << " arguments to the function.\n");
726  // We limit aggregate promotion to only promoting up to a fixed number
727  // of elements of the aggregate.
728  return false;
729  }
730  ToPromote.insert(std::move(Operands));
731  }
732  }
733 
734  if (Loads.empty())
735  return true; // No users, this is a dead argument.
736 
737  // Okay, now we know that the argument is only used by load instructions and
738  // it is safe to unconditionally perform all of them. Use alias analysis to
739  // check to see if the pointer is guaranteed to not be modified from entry of
740  // the function to each of the load instructions.
741 
742  // Because there could be several/many load instructions, remember which
743  // blocks we know to be transparent to the load.
745 
746  for (LoadInst *Load : Loads) {
747  // Check to see if the load is invalidated from the start of the block to
748  // the load itself.
749  BasicBlock *BB = Load->getParent();
750 
752  if (AAR.canInstructionRangeModRef(BB->front(), *Load, Loc, ModRefInfo::Mod))
753  return false; // Pointer is invalidated!
754 
755  // Now check every path from the entry block to the load for transparency.
756  // To do this, we perform a depth first search on the inverse CFG from the
757  // loading block.
758  for (BasicBlock *P : predecessors(BB)) {
759  for (BasicBlock *TranspBB : inverse_depth_first_ext(P, TranspBlocks))
760  if (AAR.canBasicBlockModify(*TranspBB, Loc))
761  return false;
762  }
763  }
764 
765  // If the path from the entry of the function to each load is free of
766  // instructions that potentially invalidate the load, we can make the
767  // transformation!
768  return true;
769 }
770 
772  // There is no size information, so be conservative.
773  if (!type->isSized())
774  return false;
775 
776  // If the alloc size is not equal to the storage size, then there are padding
777  // bytes. For x86_fp80 on x86-64, size: 80 alloc size: 128.
778  if (DL.getTypeSizeInBits(type) != DL.getTypeAllocSizeInBits(type))
779  return false;
780 
781  // FIXME: This isn't the right way to check for padding in vectors with
782  // non-byte-size elements.
783  if (VectorType *seqTy = dyn_cast<VectorType>(type))
784  return isDenselyPacked(seqTy->getElementType(), DL);
785 
786  // For array types, check for padding within members.
787  if (ArrayType *seqTy = dyn_cast<ArrayType>(type))
788  return isDenselyPacked(seqTy->getElementType(), DL);
789 
790  if (!isa<StructType>(type))
791  return true;
792 
793  // Check for padding within and between elements of a struct.
794  StructType *StructTy = cast<StructType>(type);
795  const StructLayout *Layout = DL.getStructLayout(StructTy);
796  uint64_t StartPos = 0;
797  for (unsigned i = 0, E = StructTy->getNumElements(); i < E; ++i) {
798  Type *ElTy = StructTy->getElementType(i);
799  if (!isDenselyPacked(ElTy, DL))
800  return false;
801  if (StartPos != Layout->getElementOffsetInBits(i))
802  return false;
803  StartPos += DL.getTypeAllocSizeInBits(ElTy);
804  }
805 
806  return true;
807 }
808 
809 /// Checks if the padding bytes of an argument could be accessed.
810 static bool canPaddingBeAccessed(Argument *arg) {
811  assert(arg->hasByValAttr());
812 
813  // Track all the pointers to the argument to make sure they are not captured.
814  SmallPtrSet<Value *, 16> PtrValues;
815  PtrValues.insert(arg);
816 
817  // Track all of the stores.
819 
820  // Scan through the uses recursively to make sure the pointer is always used
821  // sanely.
822  SmallVector<Value *, 16> WorkList(arg->users());
823  while (!WorkList.empty()) {
824  Value *V = WorkList.pop_back_val();
825  if (isa<GetElementPtrInst>(V) || isa<PHINode>(V)) {
826  if (PtrValues.insert(V).second)
827  llvm::append_range(WorkList, V->users());
828  } else if (StoreInst *Store = dyn_cast<StoreInst>(V)) {
829  Stores.push_back(Store);
830  } else if (!isa<LoadInst>(V)) {
831  return true;
832  }
833  }
834 
835  // Check to make sure the pointers aren't captured
836  for (StoreInst *Store : Stores)
837  if (PtrValues.count(Store->getValueOperand()))
838  return true;
839 
840  return false;
841 }
842 
844  const Function &F, const TargetTransformInfo &TTI,
845  SmallPtrSetImpl<Argument *> &ArgsToPromote,
846  SmallPtrSetImpl<Argument *> &ByValArgsToTransform) {
847  for (const Use &U : F.uses()) {
848  CallBase *CB = dyn_cast<CallBase>(U.getUser());
849  if (!CB)
850  return false;
851  const Function *Caller = CB->getCaller();
852  const Function *Callee = CB->getCalledFunction();
853  if (!TTI.areFunctionArgsABICompatible(Caller, Callee, ArgsToPromote) ||
854  !TTI.areFunctionArgsABICompatible(Caller, Callee, ByValArgsToTransform))
855  return false;
856  }
857  return true;
858 }
859 
860 /// PromoteArguments - This method checks the specified function to see if there
861 /// are any promotable arguments and if it is safe to promote the function (for
862 /// example, all callers are direct). If safe to promote some arguments, it
863 /// calls the DoPromotion method.
864 static Function *
866  unsigned MaxElements,
867  Optional<function_ref<void(CallBase &OldCS, CallBase &NewCS)>>
868  ReplaceCallSite,
869  const TargetTransformInfo &TTI) {
870  // Don't perform argument promotion for naked functions; otherwise we can end
871  // up removing parameters that are seemingly 'not used' as they are referred
872  // to in the assembly.
873  if(F->hasFnAttribute(Attribute::Naked))
874  return nullptr;
875 
876  // Make sure that it is local to this module.
877  if (!F->hasLocalLinkage())
878  return nullptr;
879 
880  // Don't promote arguments for variadic functions. Adding, removing, or
881  // changing non-pack parameters can change the classification of pack
882  // parameters. Frontends encode that classification at the call site in the
883  // IR, while in the callee the classification is determined dynamically based
884  // on the number of registers consumed so far.
885  if (F->isVarArg())
886  return nullptr;
887 
888  // Don't transform functions that receive inallocas, as the transformation may
889  // not be safe depending on calling convention.
890  if (F->getAttributes().hasAttrSomewhere(Attribute::InAlloca))
891  return nullptr;
892 
893  // First check: see if there are any pointer arguments! If not, quick exit.
894  SmallVector<Argument *, 16> PointerArgs;
895  for (Argument &I : F->args())
896  if (I.getType()->isPointerTy())
897  PointerArgs.push_back(&I);
898  if (PointerArgs.empty())
899  return nullptr;
900 
901  // Second check: make sure that all callers are direct callers. We can't
902  // transform functions that have indirect callers. Also see if the function
903  // is self-recursive and check that target features are compatible.
904  bool isSelfRecursive = false;
905  for (Use &U : F->uses()) {
906  CallBase *CB = dyn_cast<CallBase>(U.getUser());
907  // Must be a direct call.
908  if (CB == nullptr || !CB->isCallee(&U))
909  return nullptr;
910 
911  // Can't change signature of musttail callee
912  if (CB->isMustTailCall())
913  return nullptr;
914 
915  if (CB->getParent()->getParent() == F)
916  isSelfRecursive = true;
917  }
918 
919  // Can't change signature of musttail caller
920  // FIXME: Support promoting whole chain of musttail functions
921  for (BasicBlock &BB : *F)
922  if (BB.getTerminatingMustTailCall())
923  return nullptr;
924 
925  const DataLayout &DL = F->getParent()->getDataLayout();
926 
927  AAResults &AAR = AARGetter(*F);
928 
929  // Check to see which arguments are promotable. If an argument is promotable,
930  // add it to ArgsToPromote.
931  SmallPtrSet<Argument *, 8> ArgsToPromote;
932  SmallPtrSet<Argument *, 8> ByValArgsToTransform;
933  for (Argument *PtrArg : PointerArgs) {
934  Type *AgTy = cast<PointerType>(PtrArg->getType())->getElementType();
935 
936  // Replace sret attribute with noalias. This reduces register pressure by
937  // avoiding a register copy.
938  if (PtrArg->hasStructRetAttr()) {
939  unsigned ArgNo = PtrArg->getArgNo();
940  F->removeParamAttr(ArgNo, Attribute::StructRet);
941  F->addParamAttr(ArgNo, Attribute::NoAlias);
942  for (Use &U : F->uses()) {
943  CallBase &CB = cast<CallBase>(*U.getUser());
944  CB.removeParamAttr(ArgNo, Attribute::StructRet);
945  CB.addParamAttr(ArgNo, Attribute::NoAlias);
946  }
947  }
948 
949  // If this is a byval argument, and if the aggregate type is small, just
950  // pass the elements, which is always safe, if the passed value is densely
951  // packed or if we can prove the padding bytes are never accessed.
952  bool isSafeToPromote = PtrArg->hasByValAttr() &&
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 
1024  for (LazyCallGraph::Node &N : C) {
1025  Function &OldF = N.getFunction();
1026 
1028  AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C, CG).getManager();
1029  // FIXME: This lambda must only be used with this function. We should
1030  // skip the lambda and just get the AA results directly.
1031  auto AARGetter = [&](Function &F) -> AAResults & {
1032  assert(&F == &OldF && "Called with an unexpected function!");
1033  return FAM.getResult<AAManager>(F);
1034  };
1035 
1036  const TargetTransformInfo &TTI = FAM.getResult<TargetIRAnalysis>(OldF);
1037  Function *NewF =
1038  promoteArguments(&OldF, AARGetter, MaxElements, None, TTI);
1039  if (!NewF)
1040  continue;
1041  LocalChange = true;
1042 
1043  // Directly substitute the functions in the call graph. Note that this
1044  // requires the old function to be completely dead and completely
1045  // replaced by the new function. It does no call graph updates, it merely
1046  // swaps out the particular function mapped to a particular node in the
1047  // graph.
1048  C.getOuterRefSCC().replaceNodeFunction(N, *NewF);
1049  FAM.clear(OldF, OldF.getName());
1050  OldF.eraseFromParent();
1051  }
1052 
1053  Changed |= LocalChange;
1054  } while (LocalChange);
1055 
1056  if (!Changed)
1057  return PreservedAnalyses::all();
1058 
1059  return PreservedAnalyses::none();
1060 }
1061 
1062 namespace {
1063 
1064 /// ArgPromotion - The 'by reference' to 'by value' argument promotion pass.
1065 struct ArgPromotion : public CallGraphSCCPass {
1066  // Pass identification, replacement for typeid
1067  static char ID;
1068 
1069  explicit ArgPromotion(unsigned MaxElements = 3)
1070  : CallGraphSCCPass(ID), MaxElements(MaxElements) {
1072  }
1073 
1074  void getAnalysisUsage(AnalysisUsage &AU) const override {
1080  }
1081 
1082  bool runOnSCC(CallGraphSCC &SCC) override;
1083 
1084 private:
1086 
1087  bool doInitialization(CallGraph &CG) override;
1088 
1089  /// The maximum number of elements to expand, or 0 for unlimited.
1090  unsigned MaxElements;
1091 };
1092 
1093 } // end anonymous namespace
1094 
1095 char ArgPromotion::ID = 0;
1096 
1097 INITIALIZE_PASS_BEGIN(ArgPromotion, "argpromotion",
1098  "Promote 'by reference' arguments to scalars", false,
1099  false)
1105  "Promote 'by reference' arguments to scalars", false, false)
1106 
1107 Pass *llvm::createArgumentPromotionPass(unsigned MaxElements) {
1108  return new ArgPromotion(MaxElements);
1109 }
1110 
1111 bool ArgPromotion::runOnSCC(CallGraphSCC &SCC) {
1112  if (skipSCC(SCC))
1113  return false;
1114 
1115  // Get the callgraph information that we need to update to reflect our
1116  // changes.
1117  CallGraph &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();
1118 
1119  LegacyAARGetter AARGetter(*this);
1120 
1121  bool Changed = false, LocalChange;
1122 
1123  // Iterate until we stop promoting from this SCC.
1124  do {
1125  LocalChange = false;
1126  // Attempt to promote arguments from all functions in this SCC.
1127  for (CallGraphNode *OldNode : SCC) {
1128  Function *OldF = OldNode->getFunction();
1129  if (!OldF)
1130  continue;
1131 
1132  auto ReplaceCallSite = [&](CallBase &OldCS, CallBase &NewCS) {
1133  Function *Caller = OldCS.getParent()->getParent();
1134  CallGraphNode *NewCalleeNode =
1135  CG.getOrInsertFunction(NewCS.getCalledFunction());
1136  CallGraphNode *CallerNode = CG[Caller];
1137  CallerNode->replaceCallEdge(cast<CallBase>(OldCS),
1138  cast<CallBase>(NewCS), NewCalleeNode);
1139  };
1140 
1141  const TargetTransformInfo &TTI =
1142  getAnalysis<TargetTransformInfoWrapperPass>().getTTI(*OldF);
1143  if (Function *NewF = promoteArguments(OldF, AARGetter, MaxElements,
1144  {ReplaceCallSite}, TTI)) {
1145  LocalChange = true;
1146 
1147  // Update the call graph for the newly promoted function.
1148  CallGraphNode *NewNode = CG.getOrInsertFunction(NewF);
1149  NewNode->stealCalledFunctionsFrom(OldNode);
1150  if (OldNode->getNumReferences() == 0)
1151  delete CG.removeFunctionFromModule(OldNode);
1152  else
1154 
1155  // And updat ethe SCC we're iterating as well.
1156  SCC.ReplaceNode(OldNode, NewNode);
1157  }
1158  }
1159  // Remember that we changed something.
1160  Changed |= LocalChange;
1161  } while (LocalChange);
1162 
1163  return Changed;
1164 }
1165 
1166 bool ArgPromotion::doInitialization(CallGraph &CG) {
1168 }
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:1221
llvm::TargetIRAnalysis
Analysis pass providing the TargetTransformInfo.
Definition: TargetTransformInfo.h:2265
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
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:361
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:3730
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:161
llvm::Function::getBasicBlockList
const BasicBlockListType & getBasicBlockList() const
Get the underlying elements of the Function...
Definition: Function.h:745
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:843
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:337
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:2586
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:328
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:1203
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:959
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::AAMDNodes
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:651
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:46
Module.h
llvm::AttributeList
Definition: Attributes.h:385
llvm::CallBase::getAttributes
AttributeList getAttributes() const
Return the parameter attributes for this call.
Definition: InstrTypes.h:1472
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:1404
llvm::CallBase::isMustTailCall
bool isMustTailCall() const
Tests if this call site must be tail call optimized.
Definition: Instructions.cpp:294
llvm::Optional
Definition: APInt.h:34
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:800
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:1306
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:359
llvm::CallBase::addParamAttr
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Adds the attribute to the indicated argument.
Definition: InstrTypes.h:1507
BasicAliasAnalysis.h
llvm::LoadInst::getAlign
Align getAlign() const
Return the alignment of the access that is being performed.
Definition: Instructions.h:222
INITIALIZE_PASS_END
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
Definition: RegBankSelect.cpp:69
Use.h
llvm::Type::getInt32Ty
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:204
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:516
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:122
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:56
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:122
scalars
Promote by reference arguments to scalars
Definition: ArgumentPromotion.cpp:1105
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:132
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:205
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:77
llvm::CallBase::removeParamAttr
void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Removes the attribute from the given argument.
Definition: InstrTypes.h:1543
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:421
Constants.h
llvm::AAResults
Definition: AliasAnalysis.h:456
llvm::Instruction::getAAMetadata
void getAAMetadata(AAMDNodes &N, bool Merge=false) const
Fills the AAMDNodes structure with AA metadata from this instruction.
Definition: TypeBasedAliasAnalysis.cpp:524
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
llvm::AttributeList::getFnAttributes
AttributeSet getFnAttributes() const
The function attributes are returned.
Definition: Attributes.cpp:1562
InstrTypes.h
llvm::CallBase::getCalledFunction
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation.
Definition: InstrTypes.h:1396
llvm::CallBase::setAttributes
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
Definition: InstrTypes.h:1476
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:1638
llvm::AnalysisManager::clear
void clear(IRUnitT &IR, llvm::StringRef Name)
Clear any cached analysis results for a single unit of IR.
Definition: PassManagerImpl.h:38
llvm::CallInst::Create
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:1493
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:658
llvm::AttributeList::getParamAttributes
AttributeSet getParamAttributes(unsigned ArgNo) const
The attributes for the argument or parameter at the given index are returned.
Definition: Attributes.cpp:1554
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:647
llvm::Value::setName
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:370
llvm::UndefValue::get
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1770
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:885
SmallPtrSet.h
llvm::CallGraphNode
A node in the call graph for a module.
Definition: CallGraph.h:167
LazyCallGraph.h
FormatVariadic.h
llvm::CallBase::getCallingConv
CallingConv::ID getCallingConv() const
Definition: InstrTypes.h:1453
llvm::None
const NoneType None
Definition: None.h:23
llvm::Value::use_empty
bool use_empty() const
Definition: Value.h:357
Type.h
llvm::CallBase::getCaller
Function * getCaller()
Helper to get the caller (the parent function).
Definition: Instructions.cpp:278
CFG.h
Operands
mir Rename Register Operands
Definition: MIRNamerPass.cpp:78
llvm::InvokeInst
Invoke instruction.
Definition: Instructions.h:3686
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:176
llvm::VectorType
Base class of all SIMD vector types.
Definition: DerivedTypes.h:391
BasicBlock.h
llvm::StoreInst
An instruction for storing to memory.
Definition: Instructions.h:303
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:657
llvm::TargetLibraryInfoWrapperPass
Definition: TargetLibraryInfo.h:446
llvm::StructLayout
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
Definition: DataLayout.h:623
llvm::TargetTransformInfoWrapperPass
Wrapper pass for TargetTransformInfo.
Definition: TargetTransformInfo.h:2321
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:1451
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:785
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:105
llvm::GetElementPtrInst
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
Definition: Instructions.h:905
llvm::LoadInst::setAlignment
void setAlignment(Align Align)
Definition: Instructions.h:226
canPaddingBeAccessed
static bool canPaddingBeAccessed(Argument *arg)
Checks if the padding bytes of an argument could be accessed.
Definition: ArgumentPromotion.cpp:810
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:581
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:1570
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:137
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:1107
llvm::CallBase::arg_end
User::op_iterator arg_end()
Return the iterator pointing to the end of the argument list.
Definition: InstrTypes.h:1312
llvm::LazyCallGraph::Node
A node in the call graph.
Definition: LazyCallGraph.h:317
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:135
llvm::df_iterator_default_set
Definition: DepthFirstIterator.h:69
llvm::AMDGPU::CPol::SCC
@ SCC
Definition: SIDefines.h:285
llvm::GetElementPtrInst::Create
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:931
llvm::AssumptionCacheTracker
An immutable pass that tracks lazily created AssumptionCache objects.
Definition: AssumptionCache.h:200
llvm::SPII::Load
@ Load
Definition: SparcInstrInfo.h:32
None.h
IndicesVector
std::vector< uint64_t > IndicesVector
A vector used to hold the indices of a single GEP instruction.
Definition: ArgumentPromotion.cpp:99
DataLayout.h
llvm::StructType
Class to represent struct types.
Definition: DerivedTypes.h:212
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:526
llvm::append_range
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Definition: STLExtras.h:1690
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:298
llvm::LoadInst
An instruction for reading from memory.
Definition: Instructions.h:174
llvm::Function::begin
iterator begin()
Definition: Function.h:768
llvm::SPII::Store
@ Store
Definition: SparcInstrInfo.h:33
llvm::StructType::getNumElements
unsigned getNumElements() const
Random access to the elements.
Definition: DerivedTypes.h:329
Argument.h
Callee
amdgpu Simplify well known AMD library false FunctionCallee Callee
Definition: AMDGPULibCalls.cpp:205
Attributes.h
isPrefix
static bool isPrefix(const IndicesVector &Prefix, const IndicesVector &Longer)
Returns true if Prefix is a prefix of longer.
Definition: ArgumentPromotion.cpp:509
llvm::CGSCCUpdateResult
Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager...
Definition: CGSCCPassManager.h:232
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
llvm::Type::getInt64Ty
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:205
llvm::StructType::elements
ArrayRef< Type * > elements() const
Definition: DerivedTypes.h:321
llvm::PreservedAnalyses::all
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:161
Casting.h
llvm::Argument::hasByValAttr
bool hasByValAttr() const
Return true if this argument has the byval attribute.
Definition: Function.cpp:105
llvm::Instruction::setAAMetadata
void setAAMetadata(const AAMDNodes &N)
Sets the metadata on this instruction from the AAMDNodes structure.
Definition: Metadata.cpp:1364
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:1717
argpromotion
argpromotion
Definition: ArgumentPromotion.cpp:1104
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:865
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:1757
llvm::Function::arg_begin
arg_iterator arg_begin()
Definition: Function.h:783
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:771
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:571
llvm::GlobalValue::ExternalLinkage
@ ExternalLinkage
Externally visible function.
Definition: GlobalValue.h:48
CallGraph.h
llvm::AttributeList::getRetAttributes
AttributeSet getRetAttributes() const
The attributes for the ret value are returned.
Definition: Attributes.cpp:1558
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:223
llvm::AttributeSet
Definition: Attributes.h:254
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:1341
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:535
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:775
ScopeExit.h
llvm::StructType::getElementType
Type * getElementType(unsigned N) const
Definition: DerivedTypes.h:330
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1164
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:43
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1450
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:171
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:376
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:61
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:112
raw_ostream.h
llvm::FunctionAnalysisManagerCGSCCProxy
A proxy from a FunctionAnalysisManager to an SCC.
Definition: CGSCCPassManager.h:392
llvm::IRBuilderBase::CreateGEP
Value * CreateGEP(Value *Ptr, ArrayRef< Value * > IdxList, const Twine &Name="")
Definition: IRBuilder.h:1769
Value.h
llvm::Function::setAttributes
void setAttributes(AttributeList Attrs)
Set the attribute list for this Function.
Definition: Function.h:242
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:272
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:487
llvm::FunctionType::getReturnType
Type * getReturnType() const
Definition: DerivedTypes.h:123
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
Debug.h
llvm::Value::users
iterator_range< user_iterator > users()
Definition: Value.h:434
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:1457
llvm::FunctionType
Class to represent function types.
Definition: DerivedTypes.h:102
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::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