LLVM  3.7.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"
24 #include "llvm/IR/CallSite.h"
25 #include "llvm/IR/DataLayout.h"
26 #include "llvm/IR/DiagnosticInfo.h"
27 #include "llvm/IR/Instructions.h"
28 #include "llvm/IR/IntrinsicInst.h"
29 #include "llvm/IR/Module.h"
31 #include "llvm/Support/Debug.h"
35 using namespace llvm;
36 
37 #define DEBUG_TYPE "inline"
38 
39 STATISTIC(NumInlined, "Number of functions inlined");
40 STATISTIC(NumCallsDeleted, "Number of call sites deleted, not inlined");
41 STATISTIC(NumDeleted, "Number of functions deleted because all callers found");
42 STATISTIC(NumMergedAllocas, "Number of allocas merged together");
43 
44 // This weirdly named statistic tracks the number of times that, when attempting
45 // to inline a function A into B, we analyze the callers of B in order to see
46 // if those would be more profitable and blocked inline steps.
47 STATISTIC(NumCallerCallersAnalyzed, "Number of caller-callers analyzed");
48 
49 static cl::opt<int>
50 InlineLimit("inline-threshold", cl::Hidden, cl::init(225), cl::ZeroOrMore,
51  cl::desc("Control the amount of inlining to perform (default = 225)"));
52 
53 static cl::opt<int>
54 HintThreshold("inlinehint-threshold", cl::Hidden, cl::init(325),
55  cl::desc("Threshold for inlining functions with inline hint"));
56 
57 // We instroduce this threshold to help performance of instrumentation based
58 // PGO before we actually hook up inliner with analysis passes such as BPI and
59 // BFI.
60 static cl::opt<int>
61 ColdThreshold("inlinecold-threshold", cl::Hidden, cl::init(225),
62  cl::desc("Threshold for inlining functions with cold attribute"));
63 
64 // Threshold to use when optsize is specified (and there is no -inline-limit).
65 const int OptSizeThreshold = 75;
66 
68  : CallGraphSCCPass(ID), InlineThreshold(InlineLimit), InsertLifetime(true) {}
69 
70 Inliner::Inliner(char &ID, int Threshold, bool InsertLifetime)
71  : CallGraphSCCPass(ID), InlineThreshold(InlineLimit.getNumOccurrences() > 0 ?
72  InlineLimit : Threshold),
73  InsertLifetime(InsertLifetime) {}
74 
75 /// For this class, we declare that we require and preserve the call graph.
76 /// If the derived class implements this method, it should
77 /// always explicitly call the implementation here.
82 }
83 
84 
87 
88 /// \brief If the inlined function had a higher stack protection level than the
89 /// calling function, then bump up the caller's stack protection level.
90 static void AdjustCallerSSPLevel(Function *Caller, Function *Callee) {
91  // If upgrading the SSP attribute, clear out the old SSP Attributes first.
92  // Having multiple SSP attributes doesn't actually hurt, but it adds useless
93  // clutter to the IR.
94  AttrBuilder B;
98  AttributeSet OldSSPAttr = AttributeSet::get(Caller->getContext(),
100  B);
101 
102  if (Callee->hasFnAttribute(Attribute::SafeStack)) {
103  Caller->removeAttributes(AttributeSet::FunctionIndex, OldSSPAttr);
105  } else if (Callee->hasFnAttribute(Attribute::StackProtectReq) &&
107  Caller->removeAttributes(AttributeSet::FunctionIndex, OldSSPAttr);
109  } else if (Callee->hasFnAttribute(Attribute::StackProtectStrong) &&
112  Caller->removeAttributes(AttributeSet::FunctionIndex, OldSSPAttr);
114  } else if (Callee->hasFnAttribute(Attribute::StackProtect) &&
119 }
120 
121 /// If it is possible to inline the specified call site,
122 /// do so and update the CallGraph for this operation.
123 ///
124 /// This function also does some basic book-keeping to update the IR. The
125 /// InlinedArrayAllocas map keeps track of any allocas that are already
126 /// available from other functions inlined into the caller. If we are able to
127 /// inline this call site we attempt to reuse already available allocas or add
128 /// any new allocas to the set if not possible.
130  InlinedArrayAllocasTy &InlinedArrayAllocas,
131  int InlineHistory, bool InsertLifetime) {
132  Function *Callee = CS.getCalledFunction();
133  Function *Caller = CS.getCaller();
134 
135  // Try to inline the function. Get the list of static allocas that were
136  // inlined.
137  if (!InlineFunction(CS, IFI, InsertLifetime))
138  return false;
139 
140  AdjustCallerSSPLevel(Caller, Callee);
141 
142  // Look at all of the allocas that we inlined through this call site. If we
143  // have already inlined other allocas through other calls into this function,
144  // then we know that they have disjoint lifetimes and that we can merge them.
145  //
146  // There are many heuristics possible for merging these allocas, and the
147  // different options have different tradeoffs. One thing that we *really*
148  // don't want to hurt is SRoA: once inlining happens, often allocas are no
149  // longer address taken and so they can be promoted.
150  //
151  // Our "solution" for that is to only merge allocas whose outermost type is an
152  // array type. These are usually not promoted because someone is using a
153  // variable index into them. These are also often the most important ones to
154  // merge.
155  //
156  // A better solution would be to have real memory lifetime markers in the IR
157  // and not have the inliner do any merging of allocas at all. This would
158  // allow the backend to do proper stack slot coloring of all allocas that
159  // *actually make it to the backend*, which is really what we want.
160  //
161  // Because we don't have this information, we do this simple and useful hack.
162  //
163  SmallPtrSet<AllocaInst*, 16> UsedAllocas;
164 
165  // When processing our SCC, check to see if CS was inlined from some other
166  // call site. For example, if we're processing "A" in this code:
167  // A() { B() }
168  // B() { x = alloca ... C() }
169  // C() { y = alloca ... }
170  // Assume that C was not inlined into B initially, and so we're processing A
171  // and decide to inline B into A. Doing this makes an alloca available for
172  // reuse and makes a callsite (C) available for inlining. When we process
173  // the C call site we don't want to do any alloca merging between X and Y
174  // because their scopes are not disjoint. We could make this smarter by
175  // keeping track of the inline history for each alloca in the
176  // InlinedArrayAllocas but this isn't likely to be a significant win.
177  if (InlineHistory != -1) // Only do merging for top-level call sites in SCC.
178  return true;
179 
180  // Loop over all the allocas we have so far and see if they can be merged with
181  // a previously inlined alloca. If not, remember that we had it.
182  for (unsigned AllocaNo = 0, e = IFI.StaticAllocas.size();
183  AllocaNo != e; ++AllocaNo) {
184  AllocaInst *AI = IFI.StaticAllocas[AllocaNo];
185 
186  // Don't bother trying to merge array allocations (they will usually be
187  // canonicalized to be an allocation *of* an array), or allocations whose
188  // type is not itself an array (because we're afraid of pessimizing SRoA).
190  if (!ATy || AI->isArrayAllocation())
191  continue;
192 
193  // Get the list of all available allocas for this array type.
194  std::vector<AllocaInst*> &AllocasForType = InlinedArrayAllocas[ATy];
195 
196  // Loop over the allocas in AllocasForType to see if we can reuse one. Note
197  // that we have to be careful not to reuse the same "available" alloca for
198  // multiple different allocas that we just inlined, we use the 'UsedAllocas'
199  // set to keep track of which "available" allocas are being used by this
200  // function. Also, AllocasForType can be empty of course!
201  bool MergedAwayAlloca = false;
202  for (AllocaInst *AvailableAlloca : AllocasForType) {
203 
204  unsigned Align1 = AI->getAlignment(),
205  Align2 = AvailableAlloca->getAlignment();
206 
207  // The available alloca has to be in the right function, not in some other
208  // function in this SCC.
209  if (AvailableAlloca->getParent() != AI->getParent())
210  continue;
211 
212  // If the inlined function already uses this alloca then we can't reuse
213  // it.
214  if (!UsedAllocas.insert(AvailableAlloca).second)
215  continue;
216 
217  // Otherwise, we *can* reuse it, RAUW AI into AvailableAlloca and declare
218  // success!
219  DEBUG(dbgs() << " ***MERGED ALLOCA: " << *AI << "\n\t\tINTO: "
220  << *AvailableAlloca << '\n');
221 
222  AI->replaceAllUsesWith(AvailableAlloca);
223 
224  if (Align1 != Align2) {
225  if (!Align1 || !Align2) {
226  const DataLayout &DL = Caller->getParent()->getDataLayout();
227  unsigned TypeAlign = DL.getABITypeAlignment(AI->getAllocatedType());
228 
229  Align1 = Align1 ? Align1 : TypeAlign;
230  Align2 = Align2 ? Align2 : TypeAlign;
231  }
232 
233  if (Align1 > Align2)
234  AvailableAlloca->setAlignment(AI->getAlignment());
235  }
236 
237  AI->eraseFromParent();
238  MergedAwayAlloca = true;
239  ++NumMergedAllocas;
240  IFI.StaticAllocas[AllocaNo] = nullptr;
241  break;
242  }
243 
244  // If we already nuked the alloca, we're done with it.
245  if (MergedAwayAlloca)
246  continue;
247 
248  // If we were unable to merge away the alloca either because there are no
249  // allocas of the right type available or because we reused them all
250  // already, remember that this alloca came from an inlined function and mark
251  // it used so we don't reuse it for other allocas from this inline
252  // operation.
253  AllocasForType.push_back(AI);
254  UsedAllocas.insert(AI);
255  }
256 
257  return true;
258 }
259 
261  int thres = InlineThreshold; // -inline-threshold or else selected by
262  // overall opt level
263 
264  // If -inline-threshold is not given, listen to the optsize attribute when it
265  // would decrease the threshold.
266  Function *Caller = CS.getCaller();
267  bool OptSize = Caller && !Caller->isDeclaration() &&
269  if (!(InlineLimit.getNumOccurrences() > 0) && OptSize &&
270  OptSizeThreshold < thres)
271  thres = OptSizeThreshold;
272 
273  // Listen to the inlinehint attribute when it would increase the threshold
274  // and the caller does not need to minimize its size.
275  Function *Callee = CS.getCalledFunction();
276  bool InlineHint = Callee && !Callee->isDeclaration() &&
278  if (InlineHint && HintThreshold > thres &&
280  thres = HintThreshold;
281 
282  // Listen to the cold attribute when it would decrease the threshold.
283  bool ColdCallee = Callee && !Callee->isDeclaration() &&
285  // Command line argument for InlineLimit will override the default
286  // ColdThreshold. If we have -inline-threshold but no -inlinecold-threshold,
287  // do not use the default cold threshold even if it is smaller.
288  if ((InlineLimit.getNumOccurrences() == 0 ||
289  ColdThreshold.getNumOccurrences() > 0) && ColdCallee &&
290  ColdThreshold < thres)
291  thres = ColdThreshold;
292 
293  return thres;
294 }
295 
296 static void emitAnalysis(CallSite CS, const Twine &Msg) {
297  Function *Caller = CS.getCaller();
298  LLVMContext &Ctx = Caller->getContext();
299  DebugLoc DLoc = CS.getInstruction()->getDebugLoc();
300  emitOptimizationRemarkAnalysis(Ctx, DEBUG_TYPE, *Caller, DLoc, Msg);
301 }
302 
303 /// Return true if the inliner should attempt to inline at the given CallSite.
304 bool Inliner::shouldInline(CallSite CS) {
305  InlineCost IC = getInlineCost(CS);
306 
307  if (IC.isAlways()) {
308  DEBUG(dbgs() << " Inlining: cost=always"
309  << ", Call: " << *CS.getInstruction() << "\n");
311  " should always be inlined (cost=always)");
312  return true;
313  }
314 
315  if (IC.isNever()) {
316  DEBUG(dbgs() << " NOT Inlining: cost=never"
317  << ", Call: " << *CS.getInstruction() << "\n");
319  " should never be inlined (cost=never)"));
320  return false;
321  }
322 
323  Function *Caller = CS.getCaller();
324  if (!IC) {
325  DEBUG(dbgs() << " NOT Inlining: cost=" << IC.getCost()
326  << ", thres=" << (IC.getCostDelta() + IC.getCost())
327  << ", Call: " << *CS.getInstruction() << "\n");
329  " too costly to inline (cost=") +
330  Twine(IC.getCost()) + ", threshold=" +
331  Twine(IC.getCostDelta() + IC.getCost()) + ")");
332  return false;
333  }
334 
335  // Try to detect the case where the current inlining candidate caller (call
336  // it B) is a static or linkonce-ODR function and is an inlining candidate
337  // elsewhere, and the current candidate callee (call it C) is large enough
338  // that inlining it into B would make B too big to inline later. In these
339  // circumstances it may be best not to inline C into B, but to inline B into
340  // its callers.
341  //
342  // This only applies to static and linkonce-ODR functions because those are
343  // expected to be available for inlining in the translation units where they
344  // are used. Thus we will always have the opportunity to make local inlining
345  // decisions. Importantly the linkonce-ODR linkage covers inline functions
346  // and templates in C++.
347  //
348  // FIXME: All of this logic should be sunk into getInlineCost. It relies on
349  // the internal implementation of the inline cost metrics rather than
350  // treating them as truly abstract units etc.
351  if (Caller->hasLocalLinkage() || Caller->hasLinkOnceODRLinkage()) {
352  int TotalSecondaryCost = 0;
353  // The candidate cost to be imposed upon the current function.
354  int CandidateCost = IC.getCost() - (InlineConstants::CallPenalty + 1);
355  // This bool tracks what happens if we do NOT inline C into B.
356  bool callerWillBeRemoved = Caller->hasLocalLinkage();
357  // This bool tracks what happens if we DO inline C into B.
358  bool inliningPreventsSomeOuterInline = false;
359  for (User *U : Caller->users()) {
360  CallSite CS2(U);
361 
362  // If this isn't a call to Caller (it could be some other sort
363  // of reference) skip it. Such references will prevent the caller
364  // from being removed.
365  if (!CS2 || CS2.getCalledFunction() != Caller) {
366  callerWillBeRemoved = false;
367  continue;
368  }
369 
370  InlineCost IC2 = getInlineCost(CS2);
371  ++NumCallerCallersAnalyzed;
372  if (!IC2) {
373  callerWillBeRemoved = false;
374  continue;
375  }
376  if (IC2.isAlways())
377  continue;
378 
379  // See if inlining or original callsite would erase the cost delta of
380  // this callsite. We subtract off the penalty for the call instruction,
381  // which we would be deleting.
382  if (IC2.getCostDelta() <= CandidateCost) {
383  inliningPreventsSomeOuterInline = true;
384  TotalSecondaryCost += IC2.getCost();
385  }
386  }
387  // If all outer calls to Caller would get inlined, the cost for the last
388  // one is set very low by getInlineCost, in anticipation that Caller will
389  // be removed entirely. We did not account for this above unless there
390  // is only one caller of Caller.
391  if (callerWillBeRemoved && !Caller->use_empty())
392  TotalSecondaryCost += InlineConstants::LastCallToStaticBonus;
393 
394  if (inliningPreventsSomeOuterInline && TotalSecondaryCost < IC.getCost()) {
395  DEBUG(dbgs() << " NOT Inlining: " << *CS.getInstruction() <<
396  " Cost = " << IC.getCost() <<
397  ", outer Cost = " << TotalSecondaryCost << '\n');
398  emitAnalysis(
399  CS, Twine("Not inlining. Cost of inlining " +
400  CS.getCalledFunction()->getName() +
401  " increases the cost of inlining " +
402  CS.getCaller()->getName() + " in other contexts"));
403  return false;
404  }
405  }
406 
407  DEBUG(dbgs() << " Inlining: cost=" << IC.getCost()
408  << ", thres=" << (IC.getCostDelta() + IC.getCost())
409  << ", Call: " << *CS.getInstruction() << '\n');
410  emitAnalysis(
411  CS, CS.getCalledFunction()->getName() + Twine(" can be inlined into ") +
412  CS.getCaller()->getName() + " with cost=" + Twine(IC.getCost()) +
413  " (threshold=" + Twine(IC.getCostDelta() + IC.getCost()) + ")");
414  return true;
415 }
416 
417 /// Return true if the specified inline history ID
418 /// indicates an inline history that includes the specified function.
419 static bool InlineHistoryIncludes(Function *F, int InlineHistoryID,
420  const SmallVectorImpl<std::pair<Function*, int> > &InlineHistory) {
421  while (InlineHistoryID != -1) {
422  assert(unsigned(InlineHistoryID) < InlineHistory.size() &&
423  "Invalid inline history ID");
424  if (InlineHistory[InlineHistoryID].first == F)
425  return true;
426  InlineHistoryID = InlineHistory[InlineHistoryID].second;
427  }
428  return false;
429 }
430 
432  CallGraph &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();
433  AssumptionCacheTracker *ACT = &getAnalysis<AssumptionCacheTracker>();
434  auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>();
435  const TargetLibraryInfo *TLI = TLIP ? &TLIP->getTLI() : nullptr;
436  AliasAnalysis *AA = &getAnalysis<AliasAnalysis>();
437 
438  SmallPtrSet<Function*, 8> SCCFunctions;
439  DEBUG(dbgs() << "Inliner visiting SCC:");
440  for (CallGraphNode *Node : SCC) {
441  Function *F = Node->getFunction();
442  if (F) SCCFunctions.insert(F);
443  DEBUG(dbgs() << " " << (F ? F->getName() : "INDIRECTNODE"));
444  }
445 
446  // Scan through and identify all call sites ahead of time so that we only
447  // inline call sites in the original functions, not call sites that result
448  // from inlining other functions.
450 
451  // When inlining a callee produces new call sites, we want to keep track of
452  // the fact that they were inlined from the callee. This allows us to avoid
453  // infinite inlining in some obscure cases. To represent this, we use an
454  // index into the InlineHistory vector.
455  SmallVector<std::pair<Function*, int>, 8> InlineHistory;
456 
457  for (CallGraphNode *Node : SCC) {
458  Function *F = Node->getFunction();
459  if (!F) continue;
460 
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.
473  continue;
474 
475  CallSites.push_back(std::make_pair(CS, -1));
476  }
477  }
478 
479  DEBUG(dbgs() << ": " << CallSites.size() << " call sites.\n");
480 
481  // If there are no calls in this function, exit early.
482  if (CallSites.empty())
483  return false;
484 
485  // Now that we have all of the call sites, move the ones to functions in the
486  // current SCC to the end of the list.
487  unsigned FirstCallInSCC = CallSites.size();
488  for (unsigned i = 0; i < FirstCallInSCC; ++i)
489  if (Function *F = CallSites[i].first.getCalledFunction())
490  if (SCCFunctions.count(F))
491  std::swap(CallSites[i--], CallSites[--FirstCallInSCC]);
492 
493 
494  InlinedArrayAllocasTy InlinedArrayAllocas;
495  InlineFunctionInfo InlineInfo(&CG, AA, ACT);
496 
497  // Now that we have all of the call sites, loop over them and inline them if
498  // it looks profitable to do so.
499  bool Changed = false;
500  bool LocalChange;
501  do {
502  LocalChange = false;
503  // Iterate over the outer loop because inlining functions can cause indirect
504  // calls to become direct calls.
505  // CallSites may be modified inside so ranged for loop can not be used.
506  for (unsigned CSi = 0; CSi != CallSites.size(); ++CSi) {
507  CallSite CS = CallSites[CSi].first;
508 
509  Function *Caller = CS.getCaller();
510  Function *Callee = CS.getCalledFunction();
511 
512  // If this call site is dead and it is to a readonly function, we should
513  // just delete the call instead of trying to inline it, regardless of
514  // size. This happens because IPSCCP propagates the result out of the
515  // call and then we're left with the dead call.
517  DEBUG(dbgs() << " -> Deleting dead call: "
518  << *CS.getInstruction() << "\n");
519  // Update the call graph by deleting the edge from Callee to Caller.
520  CG[Caller]->removeCallEdgeFor(CS);
522  ++NumCallsDeleted;
523  } else {
524  // We can only inline direct calls to non-declarations.
525  if (!Callee || Callee->isDeclaration()) continue;
526 
527  // If this call site was obtained by inlining another function, verify
528  // that the include path for the function did not include the callee
529  // itself. If so, we'd be recursively inlining the same function,
530  // which would provide the same callsites, which would cause us to
531  // infinitely inline.
532  int InlineHistoryID = CallSites[CSi].second;
533  if (InlineHistoryID != -1 &&
534  InlineHistoryIncludes(Callee, InlineHistoryID, InlineHistory))
535  continue;
536 
537  LLVMContext &CallerCtx = Caller->getContext();
538 
539  // Get DebugLoc to report. CS will be invalid after Inliner.
540  DebugLoc DLoc = CS.getInstruction()->getDebugLoc();
541 
542  // If the policy determines that we should inline this function,
543  // try to do so.
544  if (!shouldInline(CS)) {
545  emitOptimizationRemarkMissed(CallerCtx, DEBUG_TYPE, *Caller, DLoc,
546  Twine(Callee->getName() +
547  " will not be inlined into " +
548  Caller->getName()));
549  continue;
550  }
551 
552  // Attempt to inline the function.
553  if (!InlineCallIfPossible(CS, InlineInfo, InlinedArrayAllocas,
554  InlineHistoryID, InsertLifetime)) {
555  emitOptimizationRemarkMissed(CallerCtx, DEBUG_TYPE, *Caller, DLoc,
556  Twine(Callee->getName() +
557  " will not be inlined into " +
558  Caller->getName()));
559  continue;
560  }
561  ++NumInlined;
562 
563  // Report the inline decision.
565  CallerCtx, DEBUG_TYPE, *Caller, DLoc,
566  Twine(Callee->getName() + " inlined into " + Caller->getName()));
567 
568  // If inlining this function gave us any new call sites, throw them
569  // onto our worklist to process. They are useful inline candidates.
570  if (!InlineInfo.InlinedCalls.empty()) {
571  // Create a new inline history entry for this, so that we remember
572  // that these new callsites came about due to inlining Callee.
573  int NewHistoryID = InlineHistory.size();
574  InlineHistory.push_back(std::make_pair(Callee, InlineHistoryID));
575 
576  for (Value *Ptr : InlineInfo.InlinedCalls)
577  CallSites.push_back(std::make_pair(CallSite(Ptr), NewHistoryID));
578  }
579  }
580 
581  // If we inlined or deleted the last possible call site to the function,
582  // delete the function body now.
583  if (Callee && Callee->use_empty() && Callee->hasLocalLinkage() &&
584  // TODO: Can remove if in SCC now.
585  !SCCFunctions.count(Callee) &&
586 
587  // The function may be apparently dead, but if there are indirect
588  // callgraph references to the node, we cannot delete it yet, this
589  // could invalidate the CGSCC iterator.
590  CG[Callee]->getNumReferences() == 0) {
591  DEBUG(dbgs() << " -> Deleting dead function: "
592  << Callee->getName() << "\n");
593  CallGraphNode *CalleeNode = CG[Callee];
594 
595  // Remove any call graph edges from the callee to its callees.
596  CalleeNode->removeAllCalledFunctions();
597 
598  // Removing the node for callee from the call graph and delete it.
599  delete CG.removeFunctionFromModule(CalleeNode);
600  ++NumDeleted;
601  }
602 
603  // Remove this call site from the list. If possible, use
604  // swap/pop_back for efficiency, but do not use it if doing so would
605  // move a call site to a function in this SCC before the
606  // 'FirstCallInSCC' barrier.
607  if (SCC.isSingular()) {
608  CallSites[CSi] = CallSites.back();
609  CallSites.pop_back();
610  } else {
611  CallSites.erase(CallSites.begin()+CSi);
612  }
613  --CSi;
614 
615  Changed = true;
616  LocalChange = true;
617  }
618  } while (LocalChange);
619 
620  return Changed;
621 }
622 
623 /// Remove now-dead linkonce functions at the end of
624 /// processing to avoid breaking the SCC traversal.
626  return removeDeadFunctions(CG);
627 }
628 
629 /// Remove dead functions that are not included in DNR (Do Not Remove) list.
630 bool Inliner::removeDeadFunctions(CallGraph &CG, bool AlwaysInlineOnly) {
631  SmallVector<CallGraphNode*, 16> FunctionsToRemove;
632  SmallVector<CallGraphNode *, 16> DeadFunctionsInComdats;
633  SmallDenseMap<const Comdat *, int, 16> ComdatEntriesAlive;
634 
635  auto RemoveCGN = [&](CallGraphNode *CGN) {
636  // Remove any call graph edges from the function to its callees.
637  CGN->removeAllCalledFunctions();
638 
639  // Remove any edges from the external node to the function's call graph
640  // node. These edges might have been made irrelegant due to
641  // optimization of the program.
643 
644  // Removing the node for callee from the call graph and delete it.
645  FunctionsToRemove.push_back(CGN);
646  };
647 
648  // Scan for all of the functions, looking for ones that should now be removed
649  // from the program. Insert the dead ones in the FunctionsToRemove set.
650  for (auto I : CG) {
651  CallGraphNode *CGN = I.second;
652  Function *F = CGN->getFunction();
653  if (!F || F->isDeclaration())
654  continue;
655 
656  // Handle the case when this function is called and we only want to care
657  // about always-inline functions. This is a bit of a hack to share code
658  // between here and the InlineAlways pass.
659  if (AlwaysInlineOnly && !F->hasFnAttribute(Attribute::AlwaysInline))
660  continue;
661 
662  // If the only remaining users of the function are dead constants, remove
663  // them.
665 
666  if (!F->isDefTriviallyDead())
667  continue;
668 
669  // It is unsafe to drop a function with discardable linkage from a COMDAT
670  // without also dropping the other members of the COMDAT.
671  // The inliner doesn't visit non-function entities which are in COMDAT
672  // groups so it is unsafe to do so *unless* the linkage is local.
673  if (!F->hasLocalLinkage()) {
674  if (const Comdat *C = F->getComdat()) {
675  --ComdatEntriesAlive[C];
676  DeadFunctionsInComdats.push_back(CGN);
677  continue;
678  }
679  }
680 
681  RemoveCGN(CGN);
682  }
683  if (!DeadFunctionsInComdats.empty()) {
684  // Count up all the entities in COMDAT groups
685  auto ComdatGroupReferenced = [&](const Comdat *C) {
686  auto I = ComdatEntriesAlive.find(C);
687  if (I != ComdatEntriesAlive.end())
688  ++(I->getSecond());
689  };
690  for (const Function &F : CG.getModule())
691  if (const Comdat *C = F.getComdat())
692  ComdatGroupReferenced(C);
693  for (const GlobalVariable &GV : CG.getModule().globals())
694  if (const Comdat *C = GV.getComdat())
695  ComdatGroupReferenced(C);
696  for (const GlobalAlias &GA : CG.getModule().aliases())
697  if (const Comdat *C = GA.getComdat())
698  ComdatGroupReferenced(C);
699  for (CallGraphNode *CGN : DeadFunctionsInComdats) {
700  Function *F = CGN->getFunction();
701  const Comdat *C = F->getComdat();
702  int NumAlive = ComdatEntriesAlive[C];
703  // We can remove functions in a COMDAT group if the entire group is dead.
704  assert(NumAlive >= 0);
705  if (NumAlive > 0)
706  continue;
707 
708  RemoveCGN(CGN);
709  }
710  }
711 
712  if (FunctionsToRemove.empty())
713  return false;
714 
715  // Now that we know which functions to delete, do so. We didn't want to do
716  // this inline, because that would invalidate our CallGraph::iterator
717  // objects. :(
718  //
719  // Note that it doesn't matter that we are iterating over a non-stable order
720  // here to do this, it doesn't matter which order the functions are deleted
721  // in.
722  array_pod_sort(FunctionsToRemove.begin(), FunctionsToRemove.end());
723  FunctionsToRemove.erase(std::unique(FunctionsToRemove.begin(),
724  FunctionsToRemove.end()),
725  FunctionsToRemove.end());
726  for (CallGraphNode *CGN : FunctionsToRemove) {
727  delete CG.removeFunctionFromModule(CGN);
728  ++NumDeleted;
729  }
730  return true;
731 }
bool isDefTriviallyDead() const
isDefTriviallyDead - Return true if it is trivially safe to remove this function definition from the ...
Definition: Function.cpp:900
iplist< Instruction >::iterator eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing basic block and deletes it...
Definition: Instruction.cpp:70
bool isAlways() const
Definition: InlineCost.h:84
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
unsigned getInlineThreshold() const
This method returns the value specified by the -inline-threshold value, specified on the command line...
Definition: InlinerPass.h:53
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:223
STATISTIC(NumFunctions,"Total number of functions")
bool InlineFunction(CallInst *C, InlineFunctionInfo &IFI, bool InsertLifetime=true)
InlineFunction - This function inlines the called function into the basic block of the caller...
InstrTy * getInstruction() const
Definition: CallSite.h:82
An immutable pass that tracks lazily created AssumptionCache objects.
Source said inlining was desirable.
Definition: Attributes.h:77
bool removeDeadFunctions(CallGraph &CG, bool AlwaysInlineOnly=false)
removeDeadFunctions - Remove dead functions.
Definition: Inliner.cpp:630
A debug info location.
Definition: DebugLoc.h:34
F(f)
FunTy * getCaller() const
getCaller - Return the caller function for this call site
Definition: CallSite.h:170
bool doFinalization(CallGraph &CG) override
Remove now-dead linkonce functions at the end of processing to avoid breaking the SCC traversal...
Definition: Inliner.cpp:625
AttrBuilder & addAttribute(Attribute::AttrKind Val)
Add an attribute to the builder.
InlineFunctionInfo - This class captures the data input to the InlineFunction call, and records the auxiliary results produced by it.
Definition: Cloning.h:193
A node in the call graph for a module.
Definition: CallGraph.h:166
void getAnalysisUsage(AnalysisUsage &Info) const override
getAnalysisUsage - For this class, we declare that we require and preserve the call graph...
void emitOptimizationRemark(LLVMContext &Ctx, const char *PassName, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg)
Emit an optimization-applied message.
Represents the cost of inlining a function.
Definition: InlineCost.h:51
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:188
Function * getFunction() const
Returns the function that this call graph node represents.
Definition: CallGraph.h:186
bool isArrayAllocation() const
isArrayAllocation - Return true if there is an allocation size parameter to the allocation instructio...
AnalysisUsage & addRequired()
DenseMap< ArrayType *, std::vector< AllocaInst * > > InlinedArrayAllocasTy
Definition: Inliner.cpp:86
void emitOptimizationRemarkAnalysis(LLVMContext &Ctx, const char *PassName, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg)
Emit an optimization analysis remark message.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:79
int getCost() const
Get the inline cost estimate.
Definition: InlineCost.h:90
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APInt.h:33
Function * removeFunctionFromModule(CallGraphNode *CGN)
Unlink the function from this module, returning it.
Definition: CallGraph.cpp:133
void addFnAttr(Attribute::AttrKind N)
Add function attributes to this function.
Definition: Function.h:187
This file provides interfaces used to build and manipulate a call graph, which is a very useful tool ...
const int OptSizeThreshold
Definition: Inliner.cpp:65
void emitOptimizationRemarkMissed(LLVMContext &Ctx, const char *PassName, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg)
Emit an optimization-missed message.
Safe Stack protection.
Definition: Attributes.h:113
bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const
Definition: SmallVector.h:57
ArrayType - Class to represent array types.
Definition: DerivedTypes.h:336
void getAnalysisUsage(AnalysisUsage &Info) const override
getAnalysisUsage - For this class, we declare that we require and preserve the call graph...
Definition: Inliner.cpp:78
const int LastCallToStaticBonus
Definition: InlineCost.h:33
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:351
int getCostDelta() const
Get the cost delta from the threshold for inlining.
Definition: InlineCost.h:98
void removeAttributes(unsigned i, AttributeSet attr)
removes the attributes from the list of attributes.
Definition: Function.cpp:353
const int CallPenalty
Definition: InlineCost.h:32
Stack protection.
Definition: Attributes.h:110
#define DEBUG_TYPE
Definition: Inliner.cpp:37
static cl::opt< int > InlineLimit("inline-threshold", cl::Hidden, cl::init(225), cl::ZeroOrMore, cl::desc("Control the amount of inlining to perform (default = 225)"))
static cl::opt< int > ColdThreshold("inlinecold-threshold", cl::Hidden, cl::init(225), cl::desc("Threshold for inlining functions with cold attribute"))
#define true
Definition: ConvertUTF.c:66
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:325
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:287
void removeAnyCallEdgeTo(CallGraphNode *Callee)
Removes all call edges from this node to the specified callee function.
Definition: CallGraph.cpp:215
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:41
FunTy * getCalledFunction() const
getCalledFunction - Return the function being called if this is a direct call, otherwise return null ...
Definition: CallSite.h:99
const Comdat * getComdat() const
Definition: GlobalObject.h:61
unsigned getAlignment() const
getAlignment - Return the alignment of the memory that is being allocated by the instruction.
Definition: Instructions.h:130
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:264
const DebugLoc & getDebugLoc() const
getDebugLoc - Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:230
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:212
Marks function as being in a cold path.
Definition: Attributes.h:75
static void AdjustCallerSSPLevel(Function *Caller, Function *Callee)
If the inlined function had a higher stack protection level than the calling function, then bump up the caller's stack protection level.
Definition: Inliner.cpp:90
iterator erase(iterator I)
Definition: SmallVector.h:455
bool runOnSCC(CallGraphSCC &SCC) override
runOnSCC - This method should be implemented by the subclass to perform whatever action is necessary ...
Definition: Inliner.cpp:431
virtual InlineCost getInlineCost(CallSite CS)=0
getInlineCost - This method must be implemented by the subclass to determine the cost of inlining the...
unsigned getABITypeAlignment(Type *Ty) const
Returns the minimum ABI-required alignment for the specified type.
Definition: DataLayout.cpp:674
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:299
static void emitAnalysis(CallSite CS, const Twine &Msg)
Definition: Inliner.cpp:296
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Module.h This file contains the declarations for the Module class.
Provides information about what library functions are available for the current target.
static cl::opt< int > HintThreshold("inlinehint-threshold", cl::Hidden, cl::init(325), cl::desc("Threshold for inlining functions with inline hint"))
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:123
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:576
iterator_range< user_iterator > users()
Definition: Value.h:300
static bool InlineCallIfPossible(CallSite CS, InlineFunctionInfo &IFI, InlinedArrayAllocasTy &InlinedArrayAllocas, int InlineHistory, bool InsertLifetime)
If it is possible to inline the specified call site, do so and update the CallGraph for this operatio...
Definition: Inliner.cpp:129
LLVM_ATTRIBUTE_UNUSED_RESULT std::enable_if< !is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:285
SmallVector< AllocaInst *, 4 > StaticAllocas
StaticAllocas - InlineFunction fills this in with all static allocas that get copied into the caller...
Definition: Cloning.h:208
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:372
The basic data container for the call graph of a Module of IR.
Definition: CallGraph.h:75
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:217
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:128
#define I(x, y, z)
Definition: MD5.cpp:54
Strong Stack protection.
Definition: Attributes.h:112
bool hasLinkOnceODRLinkage() const
Definition: GlobalValue.h:267
bool hasLocalLinkage() const
Definition: GlobalValue.h:280
static int const Threshold
TODO: Write a new FunctionPass AliasAnalysis so that it can keep a cache.
bool use_empty() const
Definition: Value.h:275
void removeDeadConstantUsers() const
removeDeadConstantUsers - If there are any dead constant users dangling off of this constant...
Definition: Constants.cpp:487
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:365
bool isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI=nullptr)
isInstructionTriviallyDead - Return true if the result produced by the instruction is not used...
Definition: Local.cpp:282
LLVM Value Representation.
Definition: Value.h:69
CallGraphSCC - This is a single SCC that a CallGraphSCCPass is run on.
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:419
#define DEBUG(X)
Definition: Debug.h:92
Inliner(char &ID)
Definition: Inliner.cpp:67
bool isNever() const
Definition: InlineCost.h:85
Type * getAllocatedType() const
getAllocatedType - Return the type that is being allocated by the instruction.
Definition: Instructions.h:122
CallGraphNode * getExternalCallingNode() const
Returns the CallGraphNode which is used to represent undetermined calls into the callgraph.
Definition: CallGraph.h:140
Stack protection required.
Definition: Attributes.h:111
const BasicBlock * getParent() const
Definition: Instruction.h:72
AllocaInst - an instruction to allocate memory on the stack.
Definition: Instructions.h:76
Function must be optimized for size first.
Definition: Attributes.h:80