LLVM  13.0.0git
InlineAdvisor.cpp
Go to the documentation of this file.
1 //===- InlineAdvisor.cpp - analysis pass implementation -------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements InlineAdvisorAnalysis and DefaultInlineAdvisor, and
10 // related types.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "llvm/ADT/Statistic.h"
23 #include "llvm/IR/Instructions.h"
26 
27 using namespace llvm;
28 #define DEBUG_TYPE "inline"
29 
30 // This weirdly named statistic tracks the number of times that, when attempting
31 // to inline a function A into B, we analyze the callers of B in order to see
32 // if those would be more profitable and blocked inline steps.
33 STATISTIC(NumCallerCallersAnalyzed, "Number of caller-callers analyzed");
34 
35 /// Flag to add inline messages as callsite attributes 'inline-remark'.
36 static cl::opt<bool>
37  InlineRemarkAttribute("inline-remark-attribute", cl::init(false),
38  cl::Hidden,
39  cl::desc("Enable adding inline-remark attribute to"
40  " callsites processed by inliner but decided"
41  " to be not inlined"));
42 
43 // An integer used to limit the cost of inline deferral. The default negative
44 // number tells shouldBeDeferred to only take the secondary cost into account.
45 static cl::opt<int>
46  InlineDeferralScale("inline-deferral-scale",
47  cl::desc("Scale to limit the cost of inline deferral"),
48  cl::init(2), cl::Hidden);
49 
51 
52 void DefaultInlineAdvice::recordUnsuccessfulInliningImpl(
53  const InlineResult &Result) {
54  using namespace ore;
55  llvm::setInlineRemark(*OriginalCB, std::string(Result.getFailureReason()) +
56  "; " + inlineCostStr(*OIC));
57  ORE.emit([&]() {
58  return OptimizationRemarkMissed(DEBUG_TYPE, "NotInlined", DLoc, Block)
59  << NV("Callee", Callee) << " will not be inlined into "
60  << NV("Caller", Caller) << ": "
61  << NV("Reason", Result.getFailureReason());
62  });
63 }
64 
65 void DefaultInlineAdvice::recordInliningWithCalleeDeletedImpl() {
66  if (EmitRemarks)
68 }
69 
70 void DefaultInlineAdvice::recordInliningImpl() {
71  if (EmitRemarks)
73 }
74 
76  CallBase &CB, FunctionAnalysisManager &FAM, const InlineParams &Params) {
77  Function &Caller = *CB.getCaller();
78  ProfileSummaryInfo *PSI =
80  .getCachedResult<ProfileSummaryAnalysis>(
81  *CB.getParent()->getParent()->getParent());
82 
84  auto GetAssumptionCache = [&](Function &F) -> AssumptionCache & {
86  };
87  auto GetBFI = [&](Function &F) -> BlockFrequencyInfo & {
89  };
90  auto GetTLI = [&](Function &F) -> const TargetLibraryInfo & {
92  };
93 
94  auto GetInlineCost = [&](CallBase &CB) {
96  auto &CalleeTTI = FAM.getResult<TargetIRAnalysis>(Callee);
97  bool RemarksEnabled =
99  DEBUG_TYPE);
100  return getInlineCost(CB, Params, CalleeTTI, GetAssumptionCache, GetTLI,
101  GetBFI, PSI, RemarksEnabled ? &ORE : nullptr);
102  };
103  return llvm::shouldInline(CB, GetInlineCost, ORE,
104  Params.EnableDeferral.getValueOr(false));
105 }
106 
107 std::unique_ptr<InlineAdvice>
108 DefaultInlineAdvisor::getAdviceImpl(CallBase &CB) {
109  auto OIC = getDefaultInlineAdvice(CB, FAM, Params);
110  return std::make_unique<DefaultInlineAdvice>(
111  this, CB, OIC,
113 }
114 
118  : Advisor(Advisor), Caller(CB.getCaller()), Callee(CB.getCalledFunction()),
119  DLoc(CB.getDebugLoc()), Block(CB.getParent()), ORE(ORE),
121 
122 void InlineAdvisor::markFunctionAsDeleted(Function *F) {
123  assert((!DeletedFunctions.count(F)) &&
124  "Cannot put cause a function to become dead twice!");
125  DeletedFunctions.insert(F);
126 }
127 
129  for (auto *F : DeletedFunctions)
130  delete F;
131  DeletedFunctions.clear();
132 }
133 
134 void InlineAdvice::recordInlineStatsIfNeeded() {
136  Advisor->ImportedFunctionsStats->recordInline(*Caller, *Callee);
137 }
138 
140  markRecorded();
141  recordInlineStatsIfNeeded();
143 }
144 
146  markRecorded();
147  recordInlineStatsIfNeeded();
148  Advisor->markFunctionAsDeleted(Callee);
150 }
151 
153 
156  StringRef ReplayFile) {
157  auto &FAM = MAM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
158  switch (Mode) {
160  Advisor.reset(new DefaultInlineAdvisor(M, FAM, Params));
161  // Restrict replay to default advisor, ML advisors are stateful so
162  // replay will need augmentations to interleave with them correctly.
163  if (!ReplayFile.empty()) {
164  Advisor = std::make_unique<ReplayInlineAdvisor>(
165  M, FAM, M.getContext(), std::move(Advisor), ReplayFile,
166  /* EmitRemarks =*/true);
167  }
168  break;
170 #ifdef LLVM_HAVE_TF_API
171  Advisor =
172  llvm::getDevelopmentModeAdvisor(M, MAM, [&FAM, Params](CallBase &CB) {
173  auto OIC = getDefaultInlineAdvice(CB, FAM, Params);
174  return OIC.hasValue();
175  });
176 #endif
177  break;
179 #ifdef LLVM_HAVE_TF_AOT
180  Advisor = llvm::getReleaseModeAdvisor(M, MAM);
181 #endif
182  break;
183  }
184 
185  return !!Advisor;
186 }
187 
188 /// Return true if inlining of CB can block the caller from being
189 /// inlined which is proved to be more beneficial. \p IC is the
190 /// estimated inline cost associated with callsite \p CB.
191 /// \p TotalSecondaryCost will be set to the estimated cost of inlining the
192 /// caller if \p CB is suppressed for inlining.
193 static bool
194 shouldBeDeferred(Function *Caller, InlineCost IC, int &TotalSecondaryCost,
195  function_ref<InlineCost(CallBase &CB)> GetInlineCost) {
196  // For now we only handle local or inline functions.
197  if (!Caller->hasLocalLinkage() && !Caller->hasLinkOnceODRLinkage())
198  return false;
199  // If the cost of inlining CB is non-positive, it is not going to prevent the
200  // caller from being inlined into its callers and hence we don't need to
201  // defer.
202  if (IC.getCost() <= 0)
203  return false;
204  // Try to detect the case where the current inlining candidate caller (call
205  // it B) is a static or linkonce-ODR function and is an inlining candidate
206  // elsewhere, and the current candidate callee (call it C) is large enough
207  // that inlining it into B would make B too big to inline later. In these
208  // circumstances it may be best not to inline C into B, but to inline B into
209  // its callers.
210  //
211  // This only applies to static and linkonce-ODR functions because those are
212  // expected to be available for inlining in the translation units where they
213  // are used. Thus we will always have the opportunity to make local inlining
214  // decisions. Importantly the linkonce-ODR linkage covers inline functions
215  // and templates in C++.
216  //
217  // FIXME: All of this logic should be sunk into getInlineCost. It relies on
218  // the internal implementation of the inline cost metrics rather than
219  // treating them as truly abstract units etc.
220  TotalSecondaryCost = 0;
221  // The candidate cost to be imposed upon the current function.
222  int CandidateCost = IC.getCost() - 1;
223  // If the caller has local linkage and can be inlined to all its callers, we
224  // can apply a huge negative bonus to TotalSecondaryCost.
225  bool ApplyLastCallBonus = Caller->hasLocalLinkage() && !Caller->hasOneUse();
226  // This bool tracks what happens if we DO inline C into B.
227  bool InliningPreventsSomeOuterInline = false;
228  unsigned NumCallerUsers = 0;
229  for (User *U : Caller->users()) {
230  CallBase *CS2 = dyn_cast<CallBase>(U);
231 
232  // If this isn't a call to Caller (it could be some other sort
233  // of reference) skip it. Such references will prevent the caller
234  // from being removed.
235  if (!CS2 || CS2->getCalledFunction() != Caller) {
236  ApplyLastCallBonus = false;
237  continue;
238  }
239 
240  InlineCost IC2 = GetInlineCost(*CS2);
241  ++NumCallerCallersAnalyzed;
242  if (!IC2) {
243  ApplyLastCallBonus = false;
244  continue;
245  }
246  if (IC2.isAlways())
247  continue;
248 
249  // See if inlining of the original callsite would erase the cost delta of
250  // this callsite. We subtract off the penalty for the call instruction,
251  // which we would be deleting.
252  if (IC2.getCostDelta() <= CandidateCost) {
253  InliningPreventsSomeOuterInline = true;
254  TotalSecondaryCost += IC2.getCost();
255  NumCallerUsers++;
256  }
257  }
258 
259  if (!InliningPreventsSomeOuterInline)
260  return false;
261 
262  // If all outer calls to Caller would get inlined, the cost for the last
263  // one is set very low by getInlineCost, in anticipation that Caller will
264  // be removed entirely. We did not account for this above unless there
265  // is only one caller of Caller.
266  if (ApplyLastCallBonus)
267  TotalSecondaryCost -= InlineConstants::LastCallToStaticBonus;
268 
269  // If InlineDeferralScale is negative, then ignore the cost of primary
270  // inlining -- IC.getCost() multiplied by the number of callers to Caller.
271  if (InlineDeferralScale < 0)
272  return TotalSecondaryCost < IC.getCost();
273 
274  int TotalCost = TotalSecondaryCost + IC.getCost() * NumCallerUsers;
275  int Allowance = IC.getCost() * InlineDeferralScale;
276  return TotalCost < Allowance;
277 }
278 
279 namespace llvm {
281  return R << Arg.Val;
282 }
283 
284 template <class RemarkT>
285 RemarkT &operator<<(RemarkT &&R, const InlineCost &IC) {
286  using namespace ore;
287  if (IC.isAlways()) {
288  R << "(cost=always)";
289  } else if (IC.isNever()) {
290  R << "(cost=never)";
291  } else {
292  R << "(cost=" << ore::NV("Cost", IC.getCost())
293  << ", threshold=" << ore::NV("Threshold", IC.getThreshold()) << ")";
294  }
295  if (const char *Reason = IC.getReason())
296  R << ": " << ore::NV("Reason", Reason);
297  return R;
298 }
299 } // namespace llvm
300 
301 std::string llvm::inlineCostStr(const InlineCost &IC) {
302  std::string Buffer;
303  raw_string_ostream Remark(Buffer);
304  Remark << IC;
305  return Remark.str();
306 }
307 
310  return;
311 
312  Attribute Attr = Attribute::get(CB.getContext(), "inline-remark", Message);
314 }
315 
316 /// Return the cost only if the inliner should attempt to inline at the given
317 /// CallSite. If we return the cost, we will emit an optimisation remark later
318 /// using that cost, so we won't do so from this function. Return None if
319 /// inlining should not be attempted.
322  function_ref<InlineCost(CallBase &CB)> GetInlineCost,
323  OptimizationRemarkEmitter &ORE, bool EnableDeferral) {
324  using namespace ore;
325 
326  InlineCost IC = GetInlineCost(CB);
327  Instruction *Call = &CB;
329  Function *Caller = CB.getCaller();
330 
331  if (IC.isAlways()) {
332  LLVM_DEBUG(dbgs() << " Inlining " << inlineCostStr(IC)
333  << ", Call: " << CB << "\n");
334  return IC;
335  }
336 
337  if (!IC) {
338  LLVM_DEBUG(dbgs() << " NOT Inlining " << inlineCostStr(IC)
339  << ", Call: " << CB << "\n");
340  if (IC.isNever()) {
341  ORE.emit([&]() {
342  return OptimizationRemarkMissed(DEBUG_TYPE, "NeverInline", Call)
343  << NV("Callee", Callee) << " not inlined into "
344  << NV("Caller", Caller) << " because it should never be inlined "
345  << IC;
346  });
347  } else {
348  ORE.emit([&]() {
349  return OptimizationRemarkMissed(DEBUG_TYPE, "TooCostly", Call)
350  << NV("Callee", Callee) << " not inlined into "
351  << NV("Caller", Caller) << " because too costly to inline "
352  << IC;
353  });
354  }
356  return None;
357  }
358 
359  int TotalSecondaryCost = 0;
360  if (EnableDeferral &&
361  shouldBeDeferred(Caller, IC, TotalSecondaryCost, GetInlineCost)) {
362  LLVM_DEBUG(dbgs() << " NOT Inlining: " << CB
363  << " Cost = " << IC.getCost()
364  << ", outer Cost = " << TotalSecondaryCost << '\n');
365  ORE.emit([&]() {
366  return OptimizationRemarkMissed(DEBUG_TYPE, "IncreaseCostInOtherContexts",
367  Call)
368  << "Not inlining. Cost of inlining " << NV("Callee", Callee)
369  << " increases the cost of inlining " << NV("Caller", Caller)
370  << " in other contexts";
371  });
372  setInlineRemark(CB, "deferred");
373  // IC does not bool() to false, so get an InlineCost that will.
374  // This will not be inspected to make an error message.
375  return None;
376  }
377 
378  LLVM_DEBUG(dbgs() << " Inlining " << inlineCostStr(IC) << ", Call: " << CB
379  << '\n');
380  return IC;
381 }
382 
384  std::string Buffer;
385  raw_string_ostream CallSiteLoc(Buffer);
386  bool First = true;
387  for (DILocation *DIL = DLoc.get(); DIL; DIL = DIL->getInlinedAt()) {
388  if (!First)
389  CallSiteLoc << " @ ";
390  // Note that negative line offset is actually possible, but we use
391  // unsigned int to match line offset representation in remarks so
392  // it's directly consumable by relay advisor.
393  uint32_t Offset =
394  DIL->getLine() - DIL->getScope()->getSubprogram()->getLine();
395  uint32_t Discriminator = DIL->getBaseDiscriminator();
396  StringRef Name = DIL->getScope()->getSubprogram()->getLinkageName();
397  if (Name.empty())
398  Name = DIL->getScope()->getSubprogram()->getName();
399  CallSiteLoc << Name.str() << ":" << llvm::utostr(Offset) << ":"
400  << llvm::utostr(DIL->getColumn());
401  if (Discriminator)
402  CallSiteLoc << "." << llvm::utostr(Discriminator);
403  First = false;
404  }
405 
406  return CallSiteLoc.str();
407 }
408 
410  if (!DLoc.get()) {
411  return;
412  }
413 
414  bool First = true;
415  Remark << " at callsite ";
416  for (DILocation *DIL = DLoc.get(); DIL; DIL = DIL->getInlinedAt()) {
417  if (!First)
418  Remark << " @ ";
419  unsigned int Offset = DIL->getLine();
420  Offset -= DIL->getScope()->getSubprogram()->getLine();
421  unsigned int Discriminator = DIL->getBaseDiscriminator();
422  StringRef Name = DIL->getScope()->getSubprogram()->getLinkageName();
423  if (Name.empty())
424  Name = DIL->getScope()->getSubprogram()->getName();
425  Remark << Name << ":" << ore::NV("Line", Offset) << ":"
426  << ore::NV("Column", DIL->getColumn());
427  if (Discriminator)
428  Remark << "." << ore::NV("Disc", Discriminator);
429  First = false;
430  }
431 
432  Remark << ";";
433 }
434 
436  const BasicBlock *Block, const Function &Callee,
437  const Function &Caller, const InlineCost &IC,
438  bool ForProfileContext, const char *PassName) {
439  ORE.emit([&]() {
440  bool AlwaysInline = IC.isAlways();
441  StringRef RemarkName = AlwaysInline ? "AlwaysInline" : "Inlined";
443  DLoc, Block);
444  Remark << ore::NV("Callee", &Callee) << " inlined into ";
445  Remark << ore::NV("Caller", &Caller);
446  if (ForProfileContext)
447  Remark << " to match profiling context";
448  Remark << " with " << IC;
450  return Remark;
451  });
452 }
453 
455  : M(M), FAM(FAM) {
458  std::make_unique<ImportedFunctionsInliningStatistics>();
459  ImportedFunctionsStats->setModuleInfo(M);
460  }
461 }
462 
468  }
469 
471 }
472 
473 std::unique_ptr<InlineAdvice> InlineAdvisor::getMandatoryAdvice(CallBase &CB,
474  bool Advice) {
475  return std::make_unique<InlineAdvice>(this, CB, getCallerORE(CB), Advice);
476 }
477 
481  auto &Callee = *CB.getCalledFunction();
482 
483  auto GetTLI = [&](Function &F) -> const TargetLibraryInfo & {
485  };
486 
487  auto &TIR = FAM.getResult<TargetIRAnalysis>(Callee);
488 
489  auto TrivialDecision =
491 
492  if (TrivialDecision.hasValue()) {
493  if (TrivialDecision->isSuccess())
495  else
497  }
499 }
500 
501 std::unique_ptr<InlineAdvice> InlineAdvisor::getAdvice(CallBase &CB,
502  bool MandatoryOnly) {
503  if (!MandatoryOnly)
504  return getAdviceImpl(CB);
505  bool Advice = CB.getCaller() != CB.getCalledFunction() &&
508  return getMandatoryAdvice(CB, Advice);
509 }
510 
513 }
llvm::InlineCost::isAlways
bool isAlways() const
Definition: InlineCost.h:102
llvm::OuterAnalysisManagerProxy
An analysis over an "inner" IR unit that provides access to an analysis manager over a "outer" IR uni...
Definition: PassManager.h:1051
llvm::InlineCost::getCost
int getCost() const
Get the inline cost estimate.
Definition: InlineCost.h:108
llvm::TargetIRAnalysis
Analysis pass providing the TargetTransformInfo.
Definition: TargetTransformInfo.h:2320
llvm::OptimizationRemarkMissed
Diagnostic information for missed-optimization remarks.
Definition: DiagnosticInfo.h:729
llvm::InlineAdvice::recordInlining
void recordInlining()
Exactly one of the record* APIs must be called.
Definition: InlineAdvisor.cpp:139
llvm::InlineAdvisor::freeDeletedFunctions
void freeDeletedFunctions()
We may want to defer deleting functions to after the inlining for a whole module has finished.
Definition: InlineAdvisor.cpp:128
llvm
Definition: AllocatorList.h:23
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::InlineAdvisorAnalysis::Result::tryCreate
bool tryCreate(InlineParams Params, InliningAdvisorMode Mode, StringRef ReplayFile)
Definition: InlineAdvisor.cpp:154
llvm::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
llvm::getCallSiteLocation
std::string getCallSiteLocation(DebugLoc DLoc)
get call site location as string
Definition: InlineAdvisor.cpp:383
llvm::InlineAdvisor::ImportedFunctionsStats
std::unique_ptr< ImportedFunctionsInliningStatistics > ImportedFunctionsStats
Definition: InlineAdvisor.h:172
llvm::BasicBlock::getParent
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:107
llvm::InlineAdvisor::M
Module & M
Definition: InlineAdvisor.h:170
llvm::AnalysisManager::getResult
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:769
DebugInfoMetadata.h
llvm::DiagnosticHandler::isMissedOptRemarkEnabled
virtual bool isMissedOptRemarkEnabled(StringRef PassName) const
Return true if missed optimization remarks are enabled, override to provide different implementation.
Definition: DiagnosticHandler.cpp:78
llvm::Function
Definition: Function.h:61
llvm::Attribute
Definition: Attributes.h:52
llvm::raw_string_ostream
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:614
llvm::InlinerFunctionImportStatsOpts::Verbose
@ Verbose
llvm::Attribute::get
static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)
Return a uniquified Attribute object.
Definition: Attributes.cpp:92
Statistic.h
llvm::InlineAdvice::Caller
Function *const Caller
Caller and Callee are pre-inlining.
Definition: InlineAdvisor.h:99
OptimizationRemarkEmitter.h
FAM
FunctionAnalysisManager FAM
Definition: PassBuilderBindings.cpp:59
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:143
llvm::DILocation
Debug location.
Definition: DebugInfoMetadata.h:1562
llvm::Function::getContext
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
Definition: Function.cpp:327
llvm::Optional< llvm::InlineCost >
llvm::InlineParams
Thresholds to tune inline cost analysis.
Definition: InlineCost.h:160
llvm::InlineAdvisor::MandatoryInliningKind::Always
@ Always
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::InlineAdvisor::MandatoryInliningKind::Never
@ Never
llvm::ore::NV
DiagnosticInfoOptimizationBase::Argument NV
Definition: OptimizationRemarkEmitter.h:136
llvm::InlineCost::getThreshold
int getThreshold() const
Get the threshold against which the cost was computed.
Definition: InlineCost.h:114
llvm::InlineCost::isNever
bool isNever() const
Definition: InlineCost.h:103
llvm::addLocationToRemarks
void addLocationToRemarks(OptimizationRemark &Remark, DebugLoc DLoc)
Add location info to ORE message.
Definition: InlineAdvisor.cpp:409
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:122
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::InlineAdvisor::getCallerORE
OptimizationRemarkEmitter & getCallerORE(CallBase &CB)
Definition: InlineAdvisor.cpp:511
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:206
CommandLine.h
llvm::BlockFrequencyInfo
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
Definition: BlockFrequencyInfo.h:37
llvm::InlinerFunctionImportStatsOpts::No
@ No
llvm::InlineAdvice::IsInliningRecommended
const bool IsInliningRecommended
Definition: InlineAdvisor.h:108
InlineRemarkAttribute
static cl::opt< bool > InlineRemarkAttribute("inline-remark-attribute", cl::init(false), cl::Hidden, cl::desc("Enable adding inline-remark attribute to" " callsites processed by inliner but decided" " to be not inlined"))
Flag to add inline messages as callsite attributes 'inline-remark'.
llvm::getInlineCost
InlineCost getInlineCost(CallBase &Call, const InlineParams &Params, TargetTransformInfo &CalleeTTI, function_ref< AssumptionCache &(Function &)> GetAssumptionCache, function_ref< const TargetLibraryInfo &(Function &)> GetTLI, function_ref< BlockFrequencyInfo &(Function &)> GetBFI=nullptr, ProfileSummaryInfo *PSI=nullptr, OptimizationRemarkEmitter *ORE=nullptr)
Get an InlineCost object representing the cost of inlining this callsite.
Definition: InlineCost.cpp:2473
llvm::InlineAdvice::ORE
OptimizationRemarkEmitter & ORE
Definition: InlineAdvisor.h:107
llvm::User
Definition: User.h:44
llvm::DefaultInlineAdvisor
The default (manual heuristics) implementation of the InlineAdvisor.
Definition: InlineAdvisor.h:204
llvm::CallBase::getCalledFunction
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation.
Definition: InstrTypes.h:1396
llvm::InlineCost
Represents the cost of inlining a function.
Definition: InlineCost.h:67
TargetLibraryInfo.h
First
into llvm powi allowing the code generator to produce balanced multiplication trees First
Definition: README.txt:54
InlineAdvisor.h
llvm::Instruction
Definition: Instruction.h:45
llvm::STATISTIC
STATISTIC(NumFunctions, "Total number of functions")
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:50
llvm::operator<<
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:230
llvm::BlockFrequencyAnalysis
Analysis pass which computes BlockFrequencyInfo.
Definition: BlockFrequencyInfo.h:112
llvm::None
const NoneType None
Definition: None.h:23
llvm::CallBase::getCaller
Function * getCaller()
Helper to get the caller (the parent function).
Definition: Instructions.cpp:278
llvm::ProfileSummaryInfo
Analysis providing profile information.
Definition: ProfileSummaryInfo.h:39
llvm::InlineAdvisor::MandatoryInliningKind
MandatoryInliningKind
Definition: InlineAdvisor.h:187
getCalledFunction
static const Function * getCalledFunction(const Value *V, bool LookThroughBitCast, bool &IsNoBuiltin)
Definition: MemoryBuiltins.cpp:117
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:168
llvm::emitInlinedInto
void emitInlinedInto(OptimizationRemarkEmitter &ORE, DebugLoc DLoc, const BasicBlock *Block, const Function &Callee, const Function &Caller, const InlineCost &IC, bool ForProfileContext=false, const char *PassName=nullptr)
Emit ORE message.
Definition: InlineAdvisor.cpp:435
llvm::LLVMContext::getDiagHandlerPtr
const DiagnosticHandler * getDiagHandlerPtr() const
getDiagHandlerPtr - Returns const raw pointer of DiagnosticHandler set by setDiagnosticHandler.
Definition: LLVMContext.cpp:343
llvm::HighlightColor::Remark
@ Remark
llvm::Optional::getValueOr
constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION
Definition: Optional.h:297
llvm::cl::opt< bool >
ReplayInlineAdvisor.h
llvm::InliningAdvisorMode
InliningAdvisorMode
There are 3 scenarios we can use the InlineAdvisor:
Definition: InlineAdvisor.h:39
shouldBeDeferred
static bool shouldBeDeferred(Function *Caller, InlineCost IC, int &TotalSecondaryCost, function_ref< InlineCost(CallBase &CB)> GetInlineCost)
Return true if inlining of CB can block the caller from being inlined which is proved to be more bene...
Definition: InlineAdvisor.cpp:194
llvm::DiagnosticInfoOptimizationBase::Argument
Used in the streaming interface as the general argument type.
Definition: DiagnosticInfo.h:421
llvm::InlineAdvisor::InlineAdvisor
InlineAdvisor(InlineAdvisor &&)=delete
ProfileSummaryInfo.h
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:572
llvm::InlineAdvice::recordInliningWithCalleeDeleted
void recordInliningWithCalleeDeleted()
Call after inlining succeeded, and resulted in deleting the callee.
Definition: InlineAdvisor.cpp:145
llvm::AssumptionAnalysis
A function analysis which provides an AssumptionCache.
Definition: AssumptionCache.h:169
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::AnalysisKey
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:72
llvm::DebugLoc::get
DILocation * get() const
Get the underlying DILocation.
Definition: DebugLoc.cpp:21
llvm::InlineAdvice::Block
const BasicBlock *const Block
Definition: InlineAdvisor.h:106
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:443
llvm::InlineCost::getCostDelta
int getCostDelta() const
Get the cost delta from the threshold for inlining.
Definition: InlineCost.h:129
llvm::InlineAdvice::recordInliningImpl
virtual void recordInliningImpl()
Definition: InlineAdvisor.h:92
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::setInlineRemark
void setInlineRemark(CallBase &CB, StringRef Message)
Set the inline-remark attribute.
Definition: InlineAdvisor.cpp:308
llvm::OptimizationRemarkEmitter::emit
void emit(DiagnosticInfoOptimizationBase &OptDiag)
Output the remark via the diagnostic handler and to the optimization record file.
Definition: OptimizationRemarkEmitter.cpp:77
llvm::InlineAdvice::DLoc
const DebugLoc DLoc
Definition: InlineAdvisor.h:105
InlineCost.h
Mode
SI Whole Quad Mode
Definition: SIWholeQuadMode.cpp:262
llvm::InliningAdvisorMode::Development
@ Development
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
getDebugLoc
static DebugLoc getDebugLoc(MachineBasicBlock::instr_iterator FirstMI, MachineBasicBlock::instr_iterator LastMI)
Return the first found DebugLoc that has a DILocation, given a range of instructions.
Definition: MachineInstrBundle.cpp:109
llvm::InlineAdvisor::MandatoryInliningKind::NotMandatory
@ NotMandatory
llvm::OptimizationRemarkEmitter
The optimization diagnostic interface.
Definition: OptimizationRemarkEmitter.h:33
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::InlineCost::getReason
const char * getReason() const
Get the reason of Always or Never.
Definition: InlineCost.h:120
llvm::AssumptionCache
A cache of @llvm.assume calls within a function.
Definition: AssumptionCache.h:41
llvm::InlineAdvisor
Interface for deciding whether to inline a call site or not.
Definition: InlineAdvisor.h:140
getParent
static const Function * getParent(const Value *V)
Definition: BasicAliasAnalysis.cpp:767
uint32_t
llvm::Value::getContext
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:965
llvm::InlineAdvice::recordInliningWithCalleeDeletedImpl
virtual void recordInliningWithCalleeDeletedImpl()
Definition: InlineAdvisor.h:93
InlinerFunctionImportStats
cl::opt< InlinerFunctionImportStatsOpts > InlinerFunctionImportStats
InlineDeferralScale
static cl::opt< int > InlineDeferralScale("inline-deferral-scale", cl::desc("Scale to limit the cost of inline deferral"), cl::init(2), cl::Hidden)
Callee
amdgpu Simplify well known AMD library false FunctionCallee Callee
Definition: AMDGPULibCalls.cpp:206
llvm::InlineAdvisor::getMandatoryAdvice
virtual std::unique_ptr< InlineAdvice > getMandatoryAdvice(CallBase &CB, bool Advice)
Definition: InlineAdvisor.cpp:473
llvm::getAttributeBasedInliningDecision
Optional< InlineResult > getAttributeBasedInliningDecision(CallBase &Call, Function *Callee, TargetTransformInfo &CalleeTTI, function_ref< const TargetLibraryInfo &(Function &)> GetTLI)
Returns InlineResult::success() if the call site should be always inlined because of user directives,...
Definition: InlineCost.cpp:2508
llvm::InlineAdvisor::FAM
FunctionAnalysisManager & FAM
Definition: InlineAdvisor.h:171
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::InlineAdvisor::getAdvice
std::unique_ptr< InlineAdvice > getAdvice(CallBase &CB, bool MandatoryOnly=false)
Get an InlineAdvice containing a recommendation on whether to inline or not.
Definition: InlineAdvisor.cpp:501
llvm::Module::getContext
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:261
llvm::InlineAdvisor::getAdviceImpl
virtual std::unique_ptr< InlineAdvice > getAdviceImpl(CallBase &CB)=0
llvm::TargetLibraryInfo
Provides information about what library functions are available for the current target.
Definition: TargetLibraryInfo.h:219
llvm::inlineCostStr
std::string inlineCostStr(const InlineCost &IC)
Utility for extracting the inline cost message to a string.
Definition: InlineAdvisor.cpp:301
llvm::InlineAdvisor::getMandatoryKind
static MandatoryInliningKind getMandatoryKind(CallBase &CB, FunctionAnalysisManager &FAM, OptimizationRemarkEmitter &ORE)
Definition: InlineAdvisor.cpp:479
llvm::AttributeList::FunctionIndex
@ FunctionIndex
Definition: Attributes.h:389
llvm::OptimizationRemark
Diagnostic information for applied optimization remarks.
Definition: DiagnosticInfo.h:684
Instructions.h
llvm::InlineConstants::LastCallToStaticBonus
const int LastCallToStaticBonus
Definition: InlineCost.h:47
llvm::InlineAdvisorAnalysis::Key
static AnalysisKey Key
Definition: InlineAdvisor.h:222
llvm::InliningAdvisorMode::Default
@ Default
llvm::Instruction::getParent
const BasicBlock * getParent() const
Definition: Instruction.h:94
TargetTransformInfo.h
llvm::InlineAdvice::InlineAdvice
InlineAdvice(InlineAdvisor *Advisor, CallBase &CB, OptimizationRemarkEmitter &ORE, bool IsInliningRecommended)
Definition: InlineAdvisor.cpp:115
llvm::CallBase::addAttribute
void addAttribute(unsigned i, Attribute::AttrKind Kind)
adds the attribute to the list of attributes.
Definition: InstrTypes.h:1492
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1164
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:44
llvm::InnerAnalysisManagerProxy
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
Definition: PassManager.h:926
llvm::InliningAdvisorMode::Release
@ Release
DEBUG_TYPE
#define DEBUG_TYPE
Definition: InlineAdvisor.cpp:28
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
llvm::cl::desc
Definition: CommandLine.h:414
raw_ostream.h
llvm::InlineParams::EnableDeferral
Optional< bool > EnableDeferral
Indicate whether we should allow inline deferral.
Definition: InlineCost.h:190
getDefaultInlineAdvice
static llvm::Optional< llvm::InlineCost > getDefaultInlineAdvice(CallBase &CB, FunctionAnalysisManager &FAM, const InlineParams &Params)
Definition: InlineAdvisor.cpp:75
llvm::raw_string_ostream::str
std::string & str()
Flushes the stream contents to the target string and returns the string's reference.
Definition: raw_ostream.h:632
llvm::InlineAdvice::Advisor
InlineAdvisor *const Advisor
Definition: InlineAdvisor.h:97
llvm::OptimizationRemarkEmitterAnalysis
Definition: OptimizationRemarkEmitter.h:164
llvm::InlineResult
InlineResult is basically true or false.
Definition: InlineCost.h:134
llvm::InlineAdvice::Callee
Function *const Callee
Definition: InlineAdvisor.h:100
llvm::TargetLibraryAnalysis
Analysis pass providing the TargetLibraryInfo.
Definition: TargetLibraryInfo.h:438
llvm::InlineAdvisor::~InlineAdvisor
virtual ~InlineAdvisor()
Definition: InlineAdvisor.cpp:463
PassName
static const char PassName[]
Definition: X86LowerAMXIntrinsics.cpp:669
llvm::shouldInline
Optional< InlineCost > shouldInline(CallBase &CB, function_ref< InlineCost(CallBase &CB)> GetInlineCost, OptimizationRemarkEmitter &ORE, bool EnableDeferral=true)
Return the cost only if the inliner should attempt to inline at the given CallSite.
Definition: InlineAdvisor.cpp:321