LLVM  4.0.0
Inliner.cpp
Go to the documentation of this file.
1 //===- Inliner.cpp - Code common to all inliners --------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the mechanics required to implement inlining without
11 // missing any calls and updating the call graph. The decisions of which calls
12 // are profitable to inline are implemented elsewhere.
13 //
14 //===----------------------------------------------------------------------===//
15 
17 #include "llvm/ADT/SmallPtrSet.h"
18 #include "llvm/ADT/Statistic.h"
27 #include "llvm/IR/CallSite.h"
28 #include "llvm/IR/DataLayout.h"
29 #include "llvm/IR/DiagnosticInfo.h"
30 #include "llvm/IR/InstIterator.h"
31 #include "llvm/IR/Instructions.h"
32 #include "llvm/IR/IntrinsicInst.h"
33 #include "llvm/IR/Module.h"
34 #include "llvm/Support/Debug.h"
39 using namespace llvm;
40 
41 #define DEBUG_TYPE "inline"
42 
43 STATISTIC(NumInlined, "Number of functions inlined");
44 STATISTIC(NumCallsDeleted, "Number of call sites deleted, not inlined");
45 STATISTIC(NumDeleted, "Number of functions deleted because all callers found");
46 STATISTIC(NumMergedAllocas, "Number of allocas merged together");
47 
48 // This weirdly named statistic tracks the number of times that, when attempting
49 // to inline a function A into B, we analyze the callers of B in order to see
50 // if those would be more profitable and blocked inline steps.
51 STATISTIC(NumCallerCallersAnalyzed, "Number of caller-callers analyzed");
52 
53 /// Flag to disable manual alloca merging.
54 ///
55 /// Merging of allocas was originally done as a stack-size saving technique
56 /// prior to LLVM's code generator having support for stack coloring based on
57 /// lifetime markers. It is now in the process of being removed. To experiment
58 /// with disabling it and relying fully on lifetime marker based stack
59 /// coloring, you can pass this flag to LLVM.
60 static cl::opt<bool>
61  DisableInlinedAllocaMerging("disable-inlined-alloca-merging",
62  cl::init(false), cl::Hidden);
63 
64 namespace {
66  No = 0,
67  Basic = 1,
68  Verbose = 2,
69 };
70 
71 cl::opt<InlinerFunctionImportStatsOpts> InlinerFunctionImportStats(
72  "inliner-function-import-stats",
73  cl::init(InlinerFunctionImportStatsOpts::No),
75  "basic statistics"),
76  clEnumValN(InlinerFunctionImportStatsOpts::Verbose, "verbose",
77  "printing of statistics for each inlined function")),
78  cl::Hidden, cl::desc("Enable inliner stats for imported functions"));
79 } // namespace
80 
82  : CallGraphSCCPass(ID), InsertLifetime(true) {}
83 
84 LegacyInlinerBase::LegacyInlinerBase(char &ID, bool InsertLifetime)
85  : CallGraphSCCPass(ID), InsertLifetime(InsertLifetime) {}
86 
87 /// For this class, we declare that we require and preserve the call graph.
88 /// If the derived class implements this method, it should
89 /// always explicitly call the implementation here.
96 }
97 
99 
100 /// Look at all of the allocas that we inlined through this call site. If we
101 /// have already inlined other allocas through other calls into this function,
102 /// then we know that they have disjoint lifetimes and that we can merge them.
103 ///
104 /// There are many heuristics possible for merging these allocas, and the
105 /// different options have different tradeoffs. One thing that we *really*
106 /// don't want to hurt is SRoA: once inlining happens, often allocas are no
107 /// longer address taken and so they can be promoted.
108 ///
109 /// Our "solution" for that is to only merge allocas whose outermost type is an
110 /// array type. These are usually not promoted because someone is using a
111 /// variable index into them. These are also often the most important ones to
112 /// merge.
113 ///
114 /// A better solution would be to have real memory lifetime markers in the IR
115 /// and not have the inliner do any merging of allocas at all. This would
116 /// allow the backend to do proper stack slot coloring of all allocas that
117 /// *actually make it to the backend*, which is really what we want.
118 ///
119 /// Because we don't have this information, we do this simple and useful hack.
121  Function *Caller, InlineFunctionInfo &IFI,
122  InlinedArrayAllocasTy &InlinedArrayAllocas, int InlineHistory) {
123  SmallPtrSet<AllocaInst *, 16> UsedAllocas;
124 
125  // When processing our SCC, check to see if CS was inlined from some other
126  // call site. For example, if we're processing "A" in this code:
127  // A() { B() }
128  // B() { x = alloca ... C() }
129  // C() { y = alloca ... }
130  // Assume that C was not inlined into B initially, and so we're processing A
131  // and decide to inline B into A. Doing this makes an alloca available for
132  // reuse and makes a callsite (C) available for inlining. When we process
133  // the C call site we don't want to do any alloca merging between X and Y
134  // because their scopes are not disjoint. We could make this smarter by
135  // keeping track of the inline history for each alloca in the
136  // InlinedArrayAllocas but this isn't likely to be a significant win.
137  if (InlineHistory != -1) // Only do merging for top-level call sites in SCC.
138  return;
139 
140  // Loop over all the allocas we have so far and see if they can be merged with
141  // a previously inlined alloca. If not, remember that we had it.
142  for (unsigned AllocaNo = 0, e = IFI.StaticAllocas.size(); AllocaNo != e;
143  ++AllocaNo) {
144  AllocaInst *AI = IFI.StaticAllocas[AllocaNo];
145 
146  // Don't bother trying to merge array allocations (they will usually be
147  // canonicalized to be an allocation *of* an array), or allocations whose
148  // type is not itself an array (because we're afraid of pessimizing SRoA).
150  if (!ATy || AI->isArrayAllocation())
151  continue;
152 
153  // Get the list of all available allocas for this array type.
154  std::vector<AllocaInst *> &AllocasForType = InlinedArrayAllocas[ATy];
155 
156  // Loop over the allocas in AllocasForType to see if we can reuse one. Note
157  // that we have to be careful not to reuse the same "available" alloca for
158  // multiple different allocas that we just inlined, we use the 'UsedAllocas'
159  // set to keep track of which "available" allocas are being used by this
160  // function. Also, AllocasForType can be empty of course!
161  bool MergedAwayAlloca = false;
162  for (AllocaInst *AvailableAlloca : AllocasForType) {
163 
164  unsigned Align1 = AI->getAlignment(),
165  Align2 = AvailableAlloca->getAlignment();
166 
167  // The available alloca has to be in the right function, not in some other
168  // function in this SCC.
169  if (AvailableAlloca->getParent() != AI->getParent())
170  continue;
171 
172  // If the inlined function already uses this alloca then we can't reuse
173  // it.
174  if (!UsedAllocas.insert(AvailableAlloca).second)
175  continue;
176 
177  // Otherwise, we *can* reuse it, RAUW AI into AvailableAlloca and declare
178  // success!
179  DEBUG(dbgs() << " ***MERGED ALLOCA: " << *AI
180  << "\n\t\tINTO: " << *AvailableAlloca << '\n');
181 
182  // Move affected dbg.declare calls immediately after the new alloca to
183  // avoid the situation when a dbg.declare precedes its alloca.
184  if (auto *L = LocalAsMetadata::getIfExists(AI))
185  if (auto *MDV = MetadataAsValue::getIfExists(AI->getContext(), L))
186  for (User *U : MDV->users())
187  if (DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(U))
188  DDI->moveBefore(AvailableAlloca->getNextNode());
189 
190  AI->replaceAllUsesWith(AvailableAlloca);
191 
192  if (Align1 != Align2) {
193  if (!Align1 || !Align2) {
194  const DataLayout &DL = Caller->getParent()->getDataLayout();
195  unsigned TypeAlign = DL.getABITypeAlignment(AI->getAllocatedType());
196 
197  Align1 = Align1 ? Align1 : TypeAlign;
198  Align2 = Align2 ? Align2 : TypeAlign;
199  }
200 
201  if (Align1 > Align2)
202  AvailableAlloca->setAlignment(AI->getAlignment());
203  }
204 
205  AI->eraseFromParent();
206  MergedAwayAlloca = true;
207  ++NumMergedAllocas;
208  IFI.StaticAllocas[AllocaNo] = nullptr;
209  break;
210  }
211 
212  // If we already nuked the alloca, we're done with it.
213  if (MergedAwayAlloca)
214  continue;
215 
216  // If we were unable to merge away the alloca either because there are no
217  // allocas of the right type available or because we reused them all
218  // already, remember that this alloca came from an inlined function and mark
219  // it used so we don't reuse it for other allocas from this inline
220  // operation.
221  AllocasForType.push_back(AI);
222  UsedAllocas.insert(AI);
223  }
224 }
225 
226 /// If it is possible to inline the specified call site,
227 /// do so and update the CallGraph for this operation.
228 ///
229 /// This function also does some basic book-keeping to update the IR. The
230 /// InlinedArrayAllocas map keeps track of any allocas that are already
231 /// available from other functions inlined into the caller. If we are able to
232 /// inline this call site we attempt to reuse already available allocas or add
233 /// any new allocas to the set if not possible.
235  CallSite CS, InlineFunctionInfo &IFI,
236  InlinedArrayAllocasTy &InlinedArrayAllocas, int InlineHistory,
237  bool InsertLifetime, function_ref<AAResults &(Function &)> &AARGetter,
238  ImportedFunctionsInliningStatistics &ImportedFunctionsStats) {
239  Function *Callee = CS.getCalledFunction();
240  Function *Caller = CS.getCaller();
241 
242  AAResults &AAR = AARGetter(*Callee);
243 
244  // Try to inline the function. Get the list of static allocas that were
245  // inlined.
246  if (!InlineFunction(CS, IFI, &AAR, InsertLifetime))
247  return false;
248 
249  if (InlinerFunctionImportStats != InlinerFunctionImportStatsOpts::No)
250  ImportedFunctionsStats.recordInline(*Caller, *Callee);
251 
253 
255  mergeInlinedArrayAllocas(Caller, IFI, InlinedArrayAllocas, InlineHistory);
256 
257  return true;
258 }
259 
260 /// Return true if inlining of CS can block the caller from being
261 /// inlined which is proved to be more beneficial. \p IC is the
262 /// estimated inline cost associated with callsite \p CS.
263 /// \p TotalAltCost will be set to the estimated cost of inlining the caller
264 /// if \p CS is suppressed for inlining.
265 static bool
267  int &TotalSecondaryCost,
268  function_ref<InlineCost(CallSite CS)> GetInlineCost) {
269 
270  // For now we only handle local or inline functions.
271  if (!Caller->hasLocalLinkage() && !Caller->hasLinkOnceODRLinkage())
272  return false;
273  // Try to detect the case where the current inlining candidate caller (call
274  // it B) is a static or linkonce-ODR function and is an inlining candidate
275  // elsewhere, and the current candidate callee (call it C) is large enough
276  // that inlining it into B would make B too big to inline later. In these
277  // circumstances it may be best not to inline C into B, but to inline B into
278  // its callers.
279  //
280  // This only applies to static and linkonce-ODR functions because those are
281  // expected to be available for inlining in the translation units where they
282  // are used. Thus we will always have the opportunity to make local inlining
283  // decisions. Importantly the linkonce-ODR linkage covers inline functions
284  // and templates in C++.
285  //
286  // FIXME: All of this logic should be sunk into getInlineCost. It relies on
287  // the internal implementation of the inline cost metrics rather than
288  // treating them as truly abstract units etc.
289  TotalSecondaryCost = 0;
290  // The candidate cost to be imposed upon the current function.
291  int CandidateCost = IC.getCost() - (InlineConstants::CallPenalty + 1);
292  // This bool tracks what happens if we do NOT inline C into B.
293  bool callerWillBeRemoved = Caller->hasLocalLinkage();
294  // This bool tracks what happens if we DO inline C into B.
295  bool inliningPreventsSomeOuterInline = false;
296  for (User *U : Caller->users()) {
297  CallSite CS2(U);
298 
299  // If this isn't a call to Caller (it could be some other sort
300  // of reference) skip it. Such references will prevent the caller
301  // from being removed.
302  if (!CS2 || CS2.getCalledFunction() != Caller) {
303  callerWillBeRemoved = false;
304  continue;
305  }
306 
307  InlineCost IC2 = GetInlineCost(CS2);
308  ++NumCallerCallersAnalyzed;
309  if (!IC2) {
310  callerWillBeRemoved = false;
311  continue;
312  }
313  if (IC2.isAlways())
314  continue;
315 
316  // See if inlining of the original callsite would erase the cost delta of
317  // this callsite. We subtract off the penalty for the call instruction,
318  // which we would be deleting.
319  if (IC2.getCostDelta() <= CandidateCost) {
320  inliningPreventsSomeOuterInline = true;
321  TotalSecondaryCost += IC2.getCost();
322  }
323  }
324  // If all outer calls to Caller would get inlined, the cost for the last
325  // one is set very low by getInlineCost, in anticipation that Caller will
326  // be removed entirely. We did not account for this above unless there
327  // is only one caller of Caller.
328  if (callerWillBeRemoved && !Caller->use_empty())
329  TotalSecondaryCost -= InlineConstants::LastCallToStaticBonus;
330 
331  if (inliningPreventsSomeOuterInline && TotalSecondaryCost < IC.getCost())
332  return true;
333 
334  return false;
335 }
336 
337 /// Return true if the inliner should attempt to inline at the given CallSite.
338 static bool shouldInline(CallSite CS,
339  function_ref<InlineCost(CallSite CS)> GetInlineCost,
341  using namespace ore;
342  InlineCost IC = GetInlineCost(CS);
344  Function *Callee = CS.getCalledFunction();
345 
346  if (IC.isAlways()) {
347  DEBUG(dbgs() << " Inlining: cost=always"
348  << ", Call: " << *CS.getInstruction() << "\n");
349  ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "AlwaysInline", Call)
350  << NV("Callee", Callee)
351  << " should always be inlined (cost=always)");
352  return true;
353  }
354 
355  if (IC.isNever()) {
356  DEBUG(dbgs() << " NOT Inlining: cost=never"
357  << ", Call: " << *CS.getInstruction() << "\n");
358  ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "NeverInline", Call)
359  << NV("Callee", Callee)
360  << " should never be inlined (cost=never)");
361  return false;
362  }
363 
364  Function *Caller = CS.getCaller();
365  if (!IC) {
366  DEBUG(dbgs() << " NOT Inlining: cost=" << IC.getCost()
367  << ", thres=" << (IC.getCostDelta() + IC.getCost())
368  << ", Call: " << *CS.getInstruction() << "\n");
370  << NV("Callee", Callee) << " too costly to inline (cost="
371  << NV("Cost", IC.getCost()) << ", threshold="
372  << NV("Threshold", IC.getCostDelta() + IC.getCost()) << ")");
373  return false;
374  }
375 
376  int TotalSecondaryCost = 0;
377  if (shouldBeDeferred(Caller, CS, IC, TotalSecondaryCost, GetInlineCost)) {
378  DEBUG(dbgs() << " NOT Inlining: " << *CS.getInstruction()
379  << " Cost = " << IC.getCost()
380  << ", outer Cost = " << TotalSecondaryCost << '\n');
382  "IncreaseCostInOtherContexts", Call)
383  << "Not inlining. Cost of inlining " << NV("Callee", Callee)
384  << " increases the cost of inlining " << NV("Caller", Caller)
385  << " in other contexts");
386  return false;
387  }
388 
389  DEBUG(dbgs() << " Inlining: cost=" << IC.getCost()
390  << ", thres=" << (IC.getCostDelta() + IC.getCost())
391  << ", Call: " << *CS.getInstruction() << '\n');
392  ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "CanBeInlined", Call)
393  << NV("Callee", Callee) << " can be inlined into "
394  << NV("Caller", Caller) << " with cost=" << NV("Cost", IC.getCost())
395  << " (threshold="
396  << NV("Threshold", IC.getCostDelta() + IC.getCost()) << ")");
397  return true;
398 }
399 
400 /// Return true if the specified inline history ID
401 /// indicates an inline history that includes the specified function.
403  Function *F, int InlineHistoryID,
404  const SmallVectorImpl<std::pair<Function *, int>> &InlineHistory) {
405  while (InlineHistoryID != -1) {
406  assert(unsigned(InlineHistoryID) < InlineHistory.size() &&
407  "Invalid inline history ID");
408  if (InlineHistory[InlineHistoryID].first == F)
409  return true;
410  InlineHistoryID = InlineHistory[InlineHistoryID].second;
411  }
412  return false;
413 }
414 
416  if (InlinerFunctionImportStats != InlinerFunctionImportStatsOpts::No)
418  return false; // No changes to CallGraph.
419 }
420 
422  if (skipSCC(SCC))
423  return false;
424  return inlineCalls(SCC);
425 }
426 
427 static bool
429  std::function<AssumptionCache &(Function &)> GetAssumptionCache,
431  bool InsertLifetime,
432  function_ref<InlineCost(CallSite CS)> GetInlineCost,
433  function_ref<AAResults &(Function &)> AARGetter,
434  ImportedFunctionsInliningStatistics &ImportedFunctionsStats) {
435  SmallPtrSet<Function *, 8> SCCFunctions;
436  DEBUG(dbgs() << "Inliner visiting SCC:");
437  for (CallGraphNode *Node : SCC) {
438  Function *F = Node->getFunction();
439  if (F)
440  SCCFunctions.insert(F);
441  DEBUG(dbgs() << " " << (F ? F->getName() : "INDIRECTNODE"));
442  }
443 
444  // Scan through and identify all call sites ahead of time so that we only
445  // inline call sites in the original functions, not call sites that result
446  // from inlining other functions.
448 
449  // When inlining a callee produces new call sites, we want to keep track of
450  // the fact that they were inlined from the callee. This allows us to avoid
451  // infinite inlining in some obscure cases. To represent this, we use an
452  // index into the InlineHistory vector.
453  SmallVector<std::pair<Function *, int>, 8> InlineHistory;
454 
455  for (CallGraphNode *Node : SCC) {
456  Function *F = Node->getFunction();
457  if (!F || F->isDeclaration())
458  continue;
459 
461  for (BasicBlock &BB : *F)
462  for (Instruction &I : BB) {
463  CallSite CS(cast<Value>(&I));
464  // If this isn't a call, or it is a call to an intrinsic, it can
465  // never be inlined.
466  if (!CS || isa<IntrinsicInst>(I))
467  continue;
468 
469  // If this is a direct call to an external function, we can never inline
470  // it. If it is an indirect call, inlining may resolve it to be a
471  // direct call, so we keep it.
472  if (Function *Callee = CS.getCalledFunction())
473  if (Callee->isDeclaration()) {
474  using namespace ore;
475  ORE.emit(OptimizationRemarkMissed(DEBUG_TYPE, "NoDefinition", &I)
476  << NV("Callee", Callee) << " will not be inlined into "
477  << NV("Caller", CS.getCaller())
478  << " because its definition is unavailable"
479  << setIsVerbose());
480  continue;
481  }
482 
483  CallSites.push_back(std::make_pair(CS, -1));
484  }
485  }
486 
487  DEBUG(dbgs() << ": " << CallSites.size() << " call sites.\n");
488 
489  // If there are no calls in this function, exit early.
490  if (CallSites.empty())
491  return false;
492 
493  // Now that we have all of the call sites, move the ones to functions in the
494  // current SCC to the end of the list.
495  unsigned FirstCallInSCC = CallSites.size();
496  for (unsigned i = 0; i < FirstCallInSCC; ++i)
497  if (Function *F = CallSites[i].first.getCalledFunction())
498  if (SCCFunctions.count(F))
499  std::swap(CallSites[i--], CallSites[--FirstCallInSCC]);
500 
501  InlinedArrayAllocasTy InlinedArrayAllocas;
502  InlineFunctionInfo InlineInfo(&CG, &GetAssumptionCache);
503 
504  // Now that we have all of the call sites, loop over them and inline them if
505  // it looks profitable to do so.
506  bool Changed = false;
507  bool LocalChange;
508  do {
509  LocalChange = false;
510  // Iterate over the outer loop because inlining functions can cause indirect
511  // calls to become direct calls.
512  // CallSites may be modified inside so ranged for loop can not be used.
513  for (unsigned CSi = 0; CSi != CallSites.size(); ++CSi) {
514  CallSite CS = CallSites[CSi].first;
515 
516  Function *Caller = CS.getCaller();
517  Function *Callee = CS.getCalledFunction();
518 
519  // If this call site is dead and it is to a readonly function, we should
520  // just delete the call instead of trying to inline it, regardless of
521  // size. This happens because IPSCCP propagates the result out of the
522  // call and then we're left with the dead call.
523  if (isInstructionTriviallyDead(CS.getInstruction(), &TLI)) {
524  DEBUG(dbgs() << " -> Deleting dead call: " << *CS.getInstruction()
525  << "\n");
526  // Update the call graph by deleting the edge from Callee to Caller.
527  CG[Caller]->removeCallEdgeFor(CS);
529  ++NumCallsDeleted;
530  } else {
531  // We can only inline direct calls to non-declarations.
532  if (!Callee || Callee->isDeclaration())
533  continue;
534 
535  // If this call site was obtained by inlining another function, verify
536  // that the include path for the function did not include the callee
537  // itself. If so, we'd be recursively inlining the same function,
538  // which would provide the same callsites, which would cause us to
539  // infinitely inline.
540  int InlineHistoryID = CallSites[CSi].second;
541  if (InlineHistoryID != -1 &&
542  InlineHistoryIncludes(Callee, InlineHistoryID, InlineHistory))
543  continue;
544 
545  // Get DebugLoc to report. CS will be invalid after Inliner.
546  DebugLoc DLoc = CS.getInstruction()->getDebugLoc();
547  BasicBlock *Block = CS.getParent();
548  // FIXME for new PM: because of the old PM we currently generate ORE and
549  // in turn BFI on demand. With the new PM, the ORE dependency should
550  // just become a regular analysis dependency.
551  OptimizationRemarkEmitter ORE(Caller);
552 
553  // If the policy determines that we should inline this function,
554  // try to do so.
555  using namespace ore;
556  if (!shouldInline(CS, GetInlineCost, ORE)) {
557  ORE.emit(
558  OptimizationRemarkMissed(DEBUG_TYPE, "NotInlined", DLoc, Block)
559  << NV("Callee", Callee) << " will not be inlined into "
560  << NV("Caller", Caller));
561  continue;
562  }
563 
564  // Attempt to inline the function.
565  if (!InlineCallIfPossible(CS, InlineInfo, InlinedArrayAllocas,
566  InlineHistoryID, InsertLifetime, AARGetter,
567  ImportedFunctionsStats)) {
568  ORE.emit(
569  OptimizationRemarkMissed(DEBUG_TYPE, "NotInlined", DLoc, Block)
570  << NV("Callee", Callee) << " will not be inlined into "
571  << NV("Caller", Caller));
572  continue;
573  }
574  ++NumInlined;
575 
576  // Report the inline decision.
577  ORE.emit(OptimizationRemark(DEBUG_TYPE, "Inlined", DLoc, Block)
578  << NV("Callee", Callee) << " inlined into "
579  << NV("Caller", Caller));
580 
581  // If inlining this function gave us any new call sites, throw them
582  // onto our worklist to process. They are useful inline candidates.
583  if (!InlineInfo.InlinedCalls.empty()) {
584  // Create a new inline history entry for this, so that we remember
585  // that these new callsites came about due to inlining Callee.
586  int NewHistoryID = InlineHistory.size();
587  InlineHistory.push_back(std::make_pair(Callee, InlineHistoryID));
588 
589  for (Value *Ptr : InlineInfo.InlinedCalls)
590  CallSites.push_back(std::make_pair(CallSite(Ptr), NewHistoryID));
591  }
592  }
593 
594  // If we inlined or deleted the last possible call site to the function,
595  // delete the function body now.
596  if (Callee && Callee->use_empty() && Callee->hasLocalLinkage() &&
597  // TODO: Can remove if in SCC now.
598  !SCCFunctions.count(Callee) &&
599 
600  // The function may be apparently dead, but if there are indirect
601  // callgraph references to the node, we cannot delete it yet, this
602  // could invalidate the CGSCC iterator.
603  CG[Callee]->getNumReferences() == 0) {
604  DEBUG(dbgs() << " -> Deleting dead function: " << Callee->getName()
605  << "\n");
606  CallGraphNode *CalleeNode = CG[Callee];
607 
608  // Remove any call graph edges from the callee to its callees.
609  CalleeNode->removeAllCalledFunctions();
610 
611  // Removing the node for callee from the call graph and delete it.
612  delete CG.removeFunctionFromModule(CalleeNode);
613  ++NumDeleted;
614  }
615 
616  // Remove this call site from the list. If possible, use
617  // swap/pop_back for efficiency, but do not use it if doing so would
618  // move a call site to a function in this SCC before the
619  // 'FirstCallInSCC' barrier.
620  if (SCC.isSingular()) {
621  CallSites[CSi] = CallSites.back();
622  CallSites.pop_back();
623  } else {
624  CallSites.erase(CallSites.begin() + CSi);
625  }
626  --CSi;
627 
628  Changed = true;
629  LocalChange = true;
630  }
631  } while (LocalChange);
632 
633  return Changed;
634 }
635 
637  CallGraph &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();
638  ACT = &getAnalysis<AssumptionCacheTracker>();
639  PSI = getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
640  auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
641  // We compute dedicated AA results for each function in the SCC as needed. We
642  // use a lambda referencing external objects so that they live long enough to
643  // be queried, but we re-use them each time.
646  auto AARGetter = [&](Function &F) -> AAResults & {
648  AAR.emplace(createLegacyPMAAResults(*this, F, *BAR));
649  return *AAR;
650  };
651  auto GetAssumptionCache = [&](Function &F) -> AssumptionCache & {
652  return ACT->getAssumptionCache(F);
653  };
654  return inlineCallsImpl(SCC, CG, GetAssumptionCache, PSI, TLI, InsertLifetime,
655  [this](CallSite CS) { return getInlineCost(CS); },
656  AARGetter, ImportedFunctionsStats);
657 }
658 
659 /// Remove now-dead linkonce functions at the end of
660 /// processing to avoid breaking the SCC traversal.
662  if (InlinerFunctionImportStats != InlinerFunctionImportStatsOpts::No)
663  ImportedFunctionsStats.dump(InlinerFunctionImportStats ==
664  InlinerFunctionImportStatsOpts::Verbose);
665  return removeDeadFunctions(CG);
666 }
667 
668 /// Remove dead functions that are not included in DNR (Do Not Remove) list.
670  bool AlwaysInlineOnly) {
671  SmallVector<CallGraphNode *, 16> FunctionsToRemove;
672  SmallVector<Function *, 16> DeadFunctionsInComdats;
673 
674  auto RemoveCGN = [&](CallGraphNode *CGN) {
675  // Remove any call graph edges from the function to its callees.
676  CGN->removeAllCalledFunctions();
677 
678  // Remove any edges from the external node to the function's call graph
679  // node. These edges might have been made irrelegant due to
680  // optimization of the program.
682 
683  // Removing the node for callee from the call graph and delete it.
684  FunctionsToRemove.push_back(CGN);
685  };
686 
687  // Scan for all of the functions, looking for ones that should now be removed
688  // from the program. Insert the dead ones in the FunctionsToRemove set.
689  for (const auto &I : CG) {
690  CallGraphNode *CGN = I.second.get();
691  Function *F = CGN->getFunction();
692  if (!F || F->isDeclaration())
693  continue;
694 
695  // Handle the case when this function is called and we only want to care
696  // about always-inline functions. This is a bit of a hack to share code
697  // between here and the InlineAlways pass.
698  if (AlwaysInlineOnly && !F->hasFnAttribute(Attribute::AlwaysInline))
699  continue;
700 
701  // If the only remaining users of the function are dead constants, remove
702  // them.
704 
705  if (!F->isDefTriviallyDead())
706  continue;
707 
708  // It is unsafe to drop a function with discardable linkage from a COMDAT
709  // without also dropping the other members of the COMDAT.
710  // The inliner doesn't visit non-function entities which are in COMDAT
711  // groups so it is unsafe to do so *unless* the linkage is local.
712  if (!F->hasLocalLinkage()) {
713  if (F->hasComdat()) {
714  DeadFunctionsInComdats.push_back(F);
715  continue;
716  }
717  }
718 
719  RemoveCGN(CGN);
720  }
721  if (!DeadFunctionsInComdats.empty()) {
722  // Filter out the functions whose comdats remain alive.
723  filterDeadComdatFunctions(CG.getModule(), DeadFunctionsInComdats);
724  // Remove the rest.
725  for (Function *F : DeadFunctionsInComdats)
726  RemoveCGN(CG[F]);
727  }
728 
729  if (FunctionsToRemove.empty())
730  return false;
731 
732  // Now that we know which functions to delete, do so. We didn't want to do
733  // this inline, because that would invalidate our CallGraph::iterator
734  // objects. :(
735  //
736  // Note that it doesn't matter that we are iterating over a non-stable order
737  // here to do this, it doesn't matter which order the functions are deleted
738  // in.
739  array_pod_sort(FunctionsToRemove.begin(), FunctionsToRemove.end());
740  FunctionsToRemove.erase(
741  std::unique(FunctionsToRemove.begin(), FunctionsToRemove.end()),
742  FunctionsToRemove.end());
743  for (CallGraphNode *CGN : FunctionsToRemove) {
744  delete CG.removeFunctionFromModule(CGN);
745  ++NumDeleted;
746  }
747  return true;
748 }
749 
752  CGSCCUpdateResult &UR) {
755  .getManager();
756  const ModuleAnalysisManager &MAM =
757  AM.getResult<ModuleAnalysisManagerCGSCCProxy>(InitialC, CG).getManager();
758  bool Changed = false;
759 
760  assert(InitialC.size() > 0 && "Cannot handle an empty SCC!");
761  Module &M = *InitialC.begin()->getFunction().getParent();
763 
764  std::function<AssumptionCache &(Function &)> GetAssumptionCache =
765  [&](Function &F) -> AssumptionCache & {
766  return FAM.getResult<AssumptionAnalysis>(F);
767  };
768 
769  // Setup the data structure used to plumb customization into the
770  // `InlineFunction` routine.
771  InlineFunctionInfo IFI(/*cg=*/nullptr, &GetAssumptionCache);
772 
773  auto GetInlineCost = [&](CallSite CS) {
774  Function &Callee = *CS.getCalledFunction();
775  auto &CalleeTTI = FAM.getResult<TargetIRAnalysis>(Callee);
776  return getInlineCost(CS, Params, CalleeTTI, GetAssumptionCache, PSI);
777  };
778 
779  // We use a worklist of nodes to process so that we can handle if the SCC
780  // structure changes and some nodes are no longer part of the current SCC. We
781  // also need to use an updatable pointer for the SCC as a consequence.
783  for (auto &N : InitialC)
784  Nodes.push_back(&N);
785  auto *C = &InitialC;
786  auto *RC = &C->getOuterRefSCC();
787 
788  // We also use a secondary worklist of call sites within a particular node to
789  // allow quickly continuing to inline through newly inlined call sites where
790  // possible.
792 
793  // When inlining a callee produces new call sites, we want to keep track of
794  // the fact that they were inlined from the callee. This allows us to avoid
795  // infinite inlining in some obscure cases. To represent this, we use an
796  // index into the InlineHistory vector.
797  SmallVector<std::pair<Function *, int>, 16> InlineHistory;
798 
799  // Track a set vector of inlined callees so that we can augment the caller
800  // with all of their edges in the call graph before pruning out the ones that
801  // got simplified away.
802  SmallSetVector<Function *, 4> InlinedCallees;
803 
804  // Track the dead functions to delete once finished with inlining calls. We
805  // defer deleting these to make it easier to handle the call graph updates.
806  SmallVector<Function *, 4> DeadFunctions;
807 
808  do {
809  auto &N = *Nodes.pop_back_val();
810  if (CG.lookupSCC(N) != C)
811  continue;
812  Function &F = N.getFunction();
813  if (F.hasFnAttribute(Attribute::OptimizeNone))
814  continue;
815 
816  // Get the remarks emission analysis for the caller.
818 
819  // We want to generally process call sites top-down in order for
820  // simplifications stemming from replacing the call with the returned value
821  // after inlining to be visible to subsequent inlining decisions. So we
822  // walk the function backwards and then process the back of the vector.
823  // FIXME: Using reverse is a really bad way to do this. Instead we should
824  // do an actual PO walk of the function body.
825  for (Instruction &I : reverse(instructions(F)))
826  if (auto CS = CallSite(&I))
827  if (Function *Callee = CS.getCalledFunction())
828  if (!Callee->isDeclaration())
829  Calls.push_back({CS, -1});
830 
831  bool DidInline = false;
832  while (!Calls.empty()) {
833  int InlineHistoryID;
834  CallSite CS;
835  std::tie(CS, InlineHistoryID) = Calls.pop_back_val();
836  Function &Callee = *CS.getCalledFunction();
837 
838  if (InlineHistoryID != -1 &&
839  InlineHistoryIncludes(&Callee, InlineHistoryID, InlineHistory))
840  continue;
841 
842  // Check whether we want to inline this callsite.
843  if (!shouldInline(CS, GetInlineCost, ORE))
844  continue;
845 
846  if (!InlineFunction(CS, IFI))
847  continue;
848  DidInline = true;
849  InlinedCallees.insert(&Callee);
850 
851  // Add any new callsites to defined functions to the worklist.
852  if (!IFI.InlinedCallSites.empty()) {
853  int NewHistoryID = InlineHistory.size();
854  InlineHistory.push_back({&Callee, InlineHistoryID});
855  for (CallSite &CS : reverse(IFI.InlinedCallSites))
856  if (Function *NewCallee = CS.getCalledFunction())
857  if (!NewCallee->isDeclaration())
858  Calls.push_back({CS, NewHistoryID});
859  }
860 
861  // Merge the attributes based on the inlining.
863 
864  // For local functions, check whether this makes the callee trivially
865  // dead. In that case, we can drop the body of the function eagerly
866  // which may reduce the number of callers of other functions to one,
867  // changing inline cost thresholds.
868  if (Callee.hasLocalLinkage()) {
869  // To check this we also need to nuke any dead constant uses (perhaps
870  // made dead by this operation on other functions).
871  Callee.removeDeadConstantUsers();
872  if (Callee.use_empty()) {
873  // Clear the body and queue the function itself for deletion when we
874  // finish inlining and call graph updates.
875  // Note that after this point, it is an error to do anything other
876  // than use the callee's address or delete it.
877  Callee.dropAllReferences();
878  assert(find(DeadFunctions, &Callee) == DeadFunctions.end() &&
879  "Cannot put cause a function to become dead twice!");
880  DeadFunctions.push_back(&Callee);
881  }
882  }
883  }
884 
885  if (!DidInline)
886  continue;
887  Changed = true;
888 
889  // Add all the inlined callees' edges as ref edges to the caller. These are
890  // by definition trivial edges as we always have *some* transitive ref edge
891  // chain. While in some cases these edges are direct calls inside the
892  // callee, they have to be modeled in the inliner as reference edges as
893  // there may be a reference edge anywhere along the chain from the current
894  // caller to the callee that causes the whole thing to appear like
895  // a (transitive) reference edge that will require promotion to a call edge
896  // below.
897  for (Function *InlinedCallee : InlinedCallees) {
898  LazyCallGraph::Node &CalleeN = *CG.lookup(*InlinedCallee);
899  for (LazyCallGraph::Edge &E : CalleeN)
900  RC->insertTrivialRefEdge(N, *E.getNode());
901  }
902  InlinedCallees.clear();
903 
904  // At this point, since we have made changes we have at least removed
905  // a call instruction. However, in the process we do some incremental
906  // simplification of the surrounding code. This simplification can
907  // essentially do all of the same things as a function pass and we can
908  // re-use the exact same logic for updating the call graph to reflect the
909  // change..
911  RC = &C->getOuterRefSCC();
912  } while (!Nodes.empty());
913 
914  // Now that we've finished inlining all of the calls across this SCC, delete
915  // all of the trivially dead functions, updating the call graph and the CGSCC
916  // pass manager in the process.
917  //
918  // Note that this walks a pointer set which has non-deterministic order but
919  // that is OK as all we do is delete things and add pointers to unordered
920  // sets.
921  for (Function *DeadF : DeadFunctions) {
922  // Get the necessary information out of the call graph and nuke the
923  // function there.
924  auto &DeadC = *CG.lookupSCC(*CG.lookup(*DeadF));
925  auto &DeadRC = DeadC.getOuterRefSCC();
926  CG.removeDeadFunction(*DeadF);
927 
928  // Mark the relevant parts of the call graph as invalid so we don't visit
929  // them.
930  UR.InvalidatedSCCs.insert(&DeadC);
931  UR.InvalidatedRefSCCs.insert(&DeadRC);
932 
933  // And delete the actual function from the module.
934  M.getFunctionList().erase(DeadF);
935  }
936  return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all();
937 }
MachineLoop * L
InlinerFunctionImportStatsOpts
Definition: Inliner.cpp:65
bool isDefTriviallyDead() const
isDefTriviallyDead - Return true if it is trivially safe to remove this function definition from the ...
Definition: Function.cpp:1191
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:76
SCC * lookupSCC(Node &N) const
Lookup a function's SCC in the graph.
bool isAlways() const
Definition: InlineCost.h:96
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:102
FunTy * getCaller() const
getCaller - Return the caller function for this call site
Definition: CallSite.h:262
bool doFinalization(CallGraph &CG) override
Remove now-dead linkonce functions at the end of processing to avoid breaking the SCC traversal...
Definition: Inliner.cpp:661
bool hasComdat() const
Definition: GlobalObject.h:91
void setModuleInfo(const Module &M)
Set information like AllFunctions, ImportedFunctions, ModuleName.
Diagnostic information for missed-optimization remarks.
DiagnosticInfoOptimizationBase::Argument NV
STATISTIC(NumFunctions,"Total number of functions")
size_t i
static bool InlineHistoryIncludes(Function *F, int InlineHistoryID, const SmallVectorImpl< std::pair< Function *, int >> &InlineHistory)
Return true if the specified inline history ID indicates an inline history that includes the specifie...
Definition: Inliner.cpp:402
BasicAAResult createLegacyPMBasicAAResult(Pass &P, Function &F)
A helper for the legacy pass manager to create a BasicAAResult object populated to the best of our ab...
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
void recordInline(const Function &Caller, const Function &Callee)
Record inline of.
virtual InlineCost getInlineCost(CallSite CS)=0
This method must be implemented by the subclass to determine the cost of inlining the specified call ...
Analysis providing profile information.
BBTy * getParent() const
Get the basic block containing the call site.
Definition: CallSite.h:98
size_type count(PtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:380
An immutable pass that tracks lazily created AssumptionCache objects.
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:83
A cache of .assume calls within a function.
Analysis pass providing the TargetTransformInfo.
A debug info location.
Definition: DebugLoc.h:34
Calculate and dump ThinLTO specific inliner stats.
InlineFunctionInfo - This class captures the data input to the InlineFunction call, and records the auxiliary results produced by it.
Definition: Cloning.h:177
static void mergeInlinedArrayAllocas(Function *Caller, InlineFunctionInfo &IFI, InlinedArrayAllocasTy &InlinedArrayAllocas, int InlineHistory)
Look at all of the allocas that we inlined through this call site.
Definition: Inliner.cpp:120
A proxy from a FunctionAnalysisManager to an SCC.
A node in the call graph for a module.
Definition: CallGraph.h:171
void getAnalysisUsage(AnalysisUsage &Info) const override
getAnalysisUsage - For this class, we declare that we require and preserve the call graph...
Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager...
Represents the cost of inlining a function.
Definition: InlineCost.h:63
Module & getModule() const
Returns the module the call graph corresponds to.
Definition: CallGraph.h:120
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:191
Function * getFunction() const
Returns the function that this call graph node represents.
Definition: CallGraph.h:191
bool InlineFunction(CallInst *C, InlineFunctionInfo &IFI, AAResults *CalleeAAR=nullptr, bool InsertLifetime=true)
InlineFunction - This function inlines the called function into the basic block of the caller...
bool isArrayAllocation() const
Return true if there is an allocation size parameter to the allocation instruction that is not 1...
PassT::Result * getCachedResult(IRUnitT &IR) const
Get the cached result of an analysis pass for a given IR unit.
Definition: PassManager.h:670
AnalysisUsage & addRequired()
bool runOnSCC(CallGraphSCC &SCC) override
Main run interface method, this implements the interface required by the Pass class.
Definition: Inliner.cpp:421
int getCost() const
Get the inline cost estimate.
Definition: InlineCost.h:102
An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
InlineCost getInlineCost(CallSite CS, const InlineParams &Params, TargetTransformInfo &CalleeTTI, std::function< AssumptionCache &(Function &)> &GetAssumptionCache, ProfileSummaryInfo *PSI)
Get an InlineCost object representing the cost of inlining this callsite.
Diagnostic information for optimization analysis remarks.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:32
Function * removeFunctionFromModule(CallGraphNode *CGN)
Unlink the function from this module, returning it.
Definition: CallGraph.cpp:137
PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM, LazyCallGraph &CG, CGSCCUpdateResult &UR)
Definition: Inliner.cpp:750
void filterDeadComdatFunctions(Module &M, SmallVectorImpl< Function * > &DeadComdatFunctions)
Filter out potentially dead comdat functions where other entries keep the entire comdat group alive...
AAResults createLegacyPMAAResults(Pass &P, Function &F, BasicAAResult &BAR)
A helper for the legacy pass manager to create a AAResults object populated to the best of our abilit...
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:60
auto reverse(ContainerTy &&C, typename std::enable_if< has_rbegin< ContainerTy >::value >::type *=nullptr) -> decltype(make_range(C.rbegin(), C.rend()))
Definition: STLExtras.h:241
This file provides interfaces used to build and manipulate a call graph, which is a very useful tool ...
#define F(x, y, z)
Definition: MD5.cpp:51
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:136
Class to represent array types.
Definition: DerivedTypes.h:345
A lazily constructed view of the call graph of a module.
const int LastCallToStaticBonus
Definition: InlineCost.h:45
DiagnosticInfoOptimizationBase::setIsVerbose setIsVerbose
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:401
int getCostDelta() const
Get the cost delta from the threshold for inlining.
Definition: InlineCost.h:110
const int CallPenalty
Definition: InlineCost.h:44
#define DEBUG_TYPE
Definition: Inliner.cpp:41
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition: PassManager.h:110
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
ValuesClass values(OptsTy...Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
Definition: CommandLine.h:615
SmallVector< CallSite, 8 > InlinedCallSites
All of the new call sites inlined into the caller.
Definition: Cloning.h:202
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:395
void array_pod_sort(IteratorTy Start, IteratorTy End)
array_pod_sort - This sorts an array with the specified start and end extent.
Definition: STLExtras.h:689
void getAnalysisUsage(AnalysisUsage &Info) const override
For this class, we declare that we require and preserve the call graph.
Definition: Inliner.cpp:90
void removeAnyCallEdgeTo(CallGraphNode *Callee)
Removes all call edges from this node to the specified callee function.
Definition: CallGraph.cpp:218
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:107
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs...ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:653
static MetadataAsValue * getIfExists(LLVMContext &Context, Metadata *MD)
Definition: Metadata.cpp:82
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
bool inlineCalls(CallGraphSCC &SCC)
This function performs the main work of the pass.
Definition: Inliner.cpp:636
An analysis pass based on the new PM to deliver ProfileSummaryInfo.
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:115
unsigned getAlignment() const
Return the alignment of the memory that is being allocated by the instruction.
Definition: Instructions.h:109
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:368
Diagnostic information for applied optimization remarks.
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:259
Represent the analysis usage information of a pass.
SmallVector< WeakVH, 8 > InlinedCalls
InlinedCalls - InlineFunction fills this in with callsites that were inlined from the callee...
Definition: Cloning.h:195
A node in the call graph.
A class used to represent edges in the call graph.
iterator erase(const_iterator CI)
Definition: SmallVector.h:431
bool doInitialization(CallGraph &CG) override
doInitialization - This method is called before the SCC's of the program has been processed...
Definition: Inliner.cpp:415
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:654
void getAAResultsAnalysisUsage(AnalysisUsage &AU)
A helper for the legacy pass manager to populate AU to add uses to make sure the analyses required by...
A function analysis which provides an AssumptionCache.
unsigned getABITypeAlignment(Type *Ty) const
Returns the minimum ABI-required alignment for the specified type.
Definition: DataLayout.cpp:689
static bool inlineCallsImpl(CallGraphSCC &SCC, CallGraph &CG, std::function< AssumptionCache &(Function &)> GetAssumptionCache, ProfileSummaryInfo *PSI, TargetLibraryInfo &TLI, bool InsertLifetime, function_ref< InlineCost(CallSite CS)> GetInlineCost, function_ref< AAResults &(Function &)> AARGetter, ImportedFunctionsInliningStatistics &ImportedFunctionsStats)
Definition: Inliner.cpp:428
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:292
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:425
ImportedFunctionsInliningStatistics ImportedFunctionsStats
Definition: Inliner.h:77
void emit(DiagnosticInfoOptimizationBase &OptDiag)
The new interface to emit remarks.
auto find(R &&Range, const T &Val) -> decltype(std::begin(Range))
Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:757
InstrTy * getInstruction() const
Definition: CallSite.h:93
An analysis over an "inner" IR unit that provides access to an analysis manager over a "outer" IR uni...
Definition: PassManager.h:1017
static cl::opt< bool > DisableInlinedAllocaMerging("disable-inlined-alloca-merging", cl::init(false), cl::Hidden)
Flag to disable manual alloca merging.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
Module.h This file contains the declarations for the Module class.
Provides information about what library functions are available for the current target.
static LocalAsMetadata * getIfExists(Value *Local)
Definition: Metadata.h:422
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:382
AssumptionCacheTracker * ACT
Definition: Inliner.h:75
bool removeDeadFunctions(CallGraph &CG, bool AlwaysInlineOnly=false)
Remove dead functions.
Definition: Inliner.cpp:669
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
void mergeAttributesForInlining(Function &Caller, const Function &Callee)
Merge caller's and callee's attributes.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:586
void dump(bool Verbose)
Dump stats computed with InlinerStatistics class.
iterator_range< user_iterator > users()
Definition: Value.h:370
static bool InlineCallIfPossible(CallSite CS, InlineFunctionInfo &IFI, InlinedArrayAllocasTy &InlinedArrayAllocas, int InlineHistory, bool InsertLifetime, function_ref< AAResults &(Function &)> &AARGetter, ImportedFunctionsInliningStatistics &ImportedFunctionsStats)
If it is possible to inline the specified call site, do so and update the CallGraph for this operatio...
Definition: Inliner.cpp:234
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:590
Basic Alias true
SmallVector< AllocaInst *, 4 > StaticAllocas
StaticAllocas - InlineFunction fills this in with all static allocas that get copied into the caller...
Definition: Cloning.h:191
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:384
The basic data container for the call graph of a Module of IR.
Definition: CallGraph.h:76
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:119
LegacyInlinerBase(char &ID)
Definition: Inliner.cpp:81
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:226
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:188
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:135
bool hasLinkOnceODRLinkage() const
Definition: GlobalValue.h:406
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:287
static bool shouldInline(CallSite CS, function_ref< InlineCost(CallSite CS)> GetInlineCost, OptimizationRemarkEmitter &ORE)
Return true if the inliner should attempt to inline at the given CallSite.
Definition: Inliner.cpp:338
bool hasLocalLinkage() const
Definition: GlobalValue.h:415
bool use_empty() const
Definition: Value.h:299
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void removeDeadConstantUsers() const
If there are any dead constant users dangling off of this constant, remove them.
Definition: Constants.cpp:463
FunTy * getCalledFunction() const
getCalledFunction - Return the function being called if this is a direct call, otherwise return null ...
Definition: CallSite.h:110
bool skipSCC(CallGraphSCC &SCC) const
Optional passes call this function to check whether the pass should be skipped.
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:537
bool isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI=nullptr)
Return true if the result produced by the instruction is not used, and the instruction has no side ef...
Definition: Local.cpp:288
LLVM Value Representation.
Definition: Value.h:71
An SCC of the call graph.
CallGraphSCC - This is a single SCC that a CallGraphSCCPass is run on.
#define DEBUG(X)
Definition: Debug.h:100
AssumptionCache & getAssumptionCache(Function &F)
Get the cached assumptions for a function.
print Print MemDeps of function
This is the interface for LLVM's primary stateless and local alias analysis.
inst_range instructions(Function *F)
Definition: InstIterator.h:132
A container for analyses that lazily runs them and caches their results.
bool isNever() const
Definition: InlineCost.h:97
static bool shouldBeDeferred(Function *Caller, CallSite CS, InlineCost IC, int &TotalSecondaryCost, function_ref< InlineCost(CallSite CS)> GetInlineCost)
Return true if inlining of CS can block the caller from being inlined which is proved to be more bene...
Definition: Inliner.cpp:266
int * Ptr
void emplace(ArgTypes &&...Args)
Create a new object by constructing it in place with the given arguments.
Definition: Optional.h:75
Type * getAllocatedType() const
Return the type that is being allocated by the instruction.
Definition: Instructions.h:102
LazyCallGraph::SCC & updateCGAndAnalysisManagerForFunctionPass(LazyCallGraph &G, LazyCallGraph::SCC &C, LazyCallGraph::Node &N, CGSCCAnalysisManager &AM, CGSCCUpdateResult &UR, bool DebugLogging=false)
Helper to update the call graph after running a function pass.
CallGraphNode * getExternalCallingNode() const
Returns the CallGraphNode which is used to represent undetermined calls into the callgraph.
Definition: CallGraph.h:143
This represents the llvm.dbg.declare instruction.
Definition: IntrinsicInst.h:89
The optimization diagnostic interface.
const BasicBlock * getParent() const
Definition: Instruction.h:62
DenseMap< ArrayType *, std::vector< AllocaInst * > > InlinedArrayAllocasTy
Definition: Inliner.cpp:98
an instruction to allocate memory on the stack
Definition: Instructions.h:60