LLVM  14.0.0git
InlineAdvisor.h
Go to the documentation of this file.
1 //===- InlineAdvisor.h - Inlining decision making abstraction -*- C++ ---*-===//
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 #ifndef LLVM_ANALYSIS_INLINEADVISOR_H
10 #define LLVM_ANALYSIS_INLINEADVISOR_H
11 
15 #include "llvm/Config/llvm-config.h"
16 #include "llvm/IR/PassManager.h"
17 #include <memory>
18 #include <unordered_set>
19 
20 namespace llvm {
21 class BasicBlock;
22 class CallBase;
23 class Function;
24 class Module;
25 class OptimizationRemarkEmitter;
26 struct ReplayInlinerSettings;
27 
28 /// There are 3 scenarios we can use the InlineAdvisor:
29 /// - Default - use manual heuristics.
30 ///
31 /// - Release mode, the expected mode for production, day to day deployments.
32 /// In this mode, when building the compiler, we also compile a pre-trained ML
33 /// model to native code, and link it as a static library. This mode has low
34 /// overhead and no additional dependencies for the compiler runtime.
35 ///
36 /// - Development mode, for training new models.
37 /// In this mode, we trade off runtime performance for flexibility. This mode
38 /// requires the full C Tensorflow API library, and evaluates models
39 /// dynamically. This mode also permits generating training logs, for offline
40 /// training.
42 
43 class InlineAdvisor;
44 /// Capture state between an inlining decision having had been made, and
45 /// its impact being observable. When collecting model training data, this
46 /// allows recording features/decisions/partial reward data sets.
47 ///
48 /// Derivations of this type are expected to be tightly coupled with their
49 /// InliningAdvisors. The base type implements the minimal contractual
50 /// obligations.
51 class InlineAdvice {
52 public:
55 
56  InlineAdvice(InlineAdvice &&) = delete;
57  InlineAdvice(const InlineAdvice &) = delete;
58  virtual ~InlineAdvice() {
59  assert(Recorded && "InlineAdvice should have been informed of the "
60  "inliner's decision in all cases");
61  }
62 
63  /// Exactly one of the record* APIs must be called. Implementers may extend
64  /// behavior by implementing the corresponding record*Impl.
65  ///
66  /// Call after inlining succeeded, and did not result in deleting the callee.
67  void recordInlining();
68 
69  /// Call after inlining succeeded, and results in the callee being
70  /// delete-able, meaning, it has no more users, and will be cleaned up
71  /// subsequently.
73 
74  /// Call after the decision for a call site was to not inline.
76  markRecorded();
78  }
79 
80  /// Call to indicate inlining was not attempted.
82  markRecorded();
84  }
85 
86  /// Get the inlining recommendation.
88  const DebugLoc &getOriginalCallSiteDebugLoc() const { return DLoc; }
89  const BasicBlock *getOriginalCallSiteBasicBlock() const { return Block; }
90 
91 protected:
92  virtual void recordInliningImpl() {}
94  virtual void recordUnsuccessfulInliningImpl(const InlineResult &Result) {}
96 
98  /// Caller and Callee are pre-inlining.
99  Function *const Caller;
100  Function *const Callee;
101 
102  // Capture the context of CB before inlining, as a successful inlining may
103  // change that context, and we want to report success or failure in the
104  // original context.
105  const DebugLoc DLoc;
106  const BasicBlock *const Block;
109 
110 private:
111  void markRecorded() {
112  assert(!Recorded && "Recording should happen exactly once");
113  Recorded = true;
114  }
115  void recordInlineStatsIfNeeded();
116 
117  bool Recorded = false;
118 };
119 
121 public:
124  bool EmitRemarks = true)
125  : InlineAdvice(Advisor, CB, ORE, OIC.hasValue()), OriginalCB(&CB),
126  OIC(OIC), EmitRemarks(EmitRemarks) {}
127 
128 private:
129  void recordUnsuccessfulInliningImpl(const InlineResult &Result) override;
130  void recordInliningWithCalleeDeletedImpl() override;
131  void recordInliningImpl() override;
132 
133 private:
134  CallBase *const OriginalCB;
136  bool EmitRemarks;
137 };
138 
139 /// Interface for deciding whether to inline a call site or not.
141 public:
142  InlineAdvisor(InlineAdvisor &&) = delete;
143  virtual ~InlineAdvisor();
144 
145  /// Get an InlineAdvice containing a recommendation on whether to
146  /// inline or not. \p CB is assumed to be a direct call. \p FAM is assumed to
147  /// be up-to-date wrt previous inlining decisions. \p MandatoryOnly indicates
148  /// only mandatory (always-inline) call sites should be recommended - this
149  /// allows the InlineAdvisor track such inlininings.
150  /// Returns:
151  /// - An InlineAdvice with the inlining recommendation.
152  /// - Null when no recommendation is made (https://reviews.llvm.org/D110658).
153  /// TODO: Consider removing the Null return scenario by incorporating the
154  /// SampleProfile inliner into an InlineAdvisor
155  std::unique_ptr<InlineAdvice> getAdvice(CallBase &CB,
156  bool MandatoryOnly = false);
157 
158  /// This must be called when the Inliner pass is entered, to allow the
159  /// InlineAdvisor update internal state, as result of function passes run
160  /// between Inliner pass runs (for the same module).
161  virtual void onPassEntry() {}
162 
163  /// This must be called when the Inliner pass is exited, as function passes
164  /// may be run subsequently. This allows an implementation of InlineAdvisor
165  /// to prepare for a partial update, based on the optional SCC.
166  virtual void onPassExit(LazyCallGraph::SCC *SCC = nullptr) {}
167 
168  /// Support for printer pass
169  virtual void print(raw_ostream &OS) const {
170  OS << "Unimplemented InlineAdvisor print\n";
171  }
172 
173 protected:
175  virtual std::unique_ptr<InlineAdvice> getAdviceImpl(CallBase &CB) = 0;
176  virtual std::unique_ptr<InlineAdvice> getMandatoryAdvice(CallBase &CB,
177  bool Advice);
178 
181  std::unique_ptr<ImportedFunctionsInliningStatistics> ImportedFunctionsStats;
182 
184 
188 
190 
191 private:
192  friend class InlineAdvice;
193 };
194 
195 /// The default (manual heuristics) implementation of the InlineAdvisor. This
196 /// implementation does not need to keep state between inliner pass runs, and is
197 /// reusable as-is for inliner pass test scenarios, as well as for regular use.
199 public:
201  InlineParams Params)
202  : InlineAdvisor(M, FAM), Params(Params) {}
203 
204 private:
205  std::unique_ptr<InlineAdvice> getAdviceImpl(CallBase &CB) override;
206 
207  InlineParams Params;
208 };
209 
210 /// The InlineAdvisorAnalysis is a module pass because the InlineAdvisor
211 /// needs to capture state right before inlining commences over a module.
212 class InlineAdvisorAnalysis : public AnalysisInfoMixin<InlineAdvisorAnalysis> {
213 public:
214  static AnalysisKey Key;
215  InlineAdvisorAnalysis() = default;
216  struct Result {
220  // Check whether the analysis has been explicitly invalidated. Otherwise,
221  // it's stateless and remains preserved.
222  auto PAC = PA.getChecker<InlineAdvisorAnalysis>();
223  return !PAC.preservedWhenStateless();
224  }
226  const ReplayInlinerSettings &ReplaySettings);
227  InlineAdvisor *getAdvisor() const { return Advisor.get(); }
228 
229  private:
230  Module &M;
232  std::unique_ptr<InlineAdvisor> Advisor;
233  };
234 
236 };
237 
238 /// Printer pass for the FunctionPropertiesAnalysis results.
240  : public PassInfoMixin<InlineAdvisorAnalysisPrinterPass> {
241  raw_ostream &OS;
242 
243 public:
245 
247 };
248 
249 std::unique_ptr<InlineAdvisor>
251 
252 std::unique_ptr<InlineAdvisor>
254  std::function<bool(CallBase &)> GetDefaultAdvice);
255 
256 // Default (manual policy) decision making helper APIs. Shared with the legacy
257 // pass manager inliner.
258 
259 /// Return the cost only if the inliner should attempt to inline at the given
260 /// CallSite. If we return the cost, we will emit an optimisation remark later
261 /// using that cost, so we won't do so from this function. Return None if
262 /// inlining should not be attempted.
263 Optional<InlineCost>
264 shouldInline(CallBase &CB, function_ref<InlineCost(CallBase &CB)> GetInlineCost,
265  OptimizationRemarkEmitter &ORE, bool EnableDeferral = true);
266 
267 /// Emit ORE message.
268 void emitInlinedInto(OptimizationRemarkEmitter &ORE, DebugLoc DLoc,
269  const BasicBlock *Block, const Function &Callee,
270  const Function &Caller, bool IsMandatory,
271  function_ref<void(OptimizationRemark &)> ExtraContext = {},
272  const char *PassName = nullptr);
273 
274 /// Emit ORE message based in cost (default heuristic).
275 void emitInlinedIntoBasedOnCost(OptimizationRemarkEmitter &ORE, DebugLoc DLoc,
276  const BasicBlock *Block, const Function &Callee,
277  const Function &Caller, const InlineCost &IC,
278  bool ForProfileContext = false,
279  const char *PassName = nullptr);
280 
281 /// Add location info to ORE message.
282 void addLocationToRemarks(OptimizationRemark &Remark, DebugLoc DLoc);
283 
284 /// Set the inline-remark attribute.
285 void setInlineRemark(CallBase &CB, StringRef Message);
286 
287 /// Utility for extracting the inline cost message to a string.
288 std::string inlineCostStr(const InlineCost &IC);
289 } // namespace llvm
290 #endif // LLVM_ANALYSIS_INLINEADVISOR_H
llvm::InlineAdvisor::print
virtual void print(raw_ostream &OS) const
Support for printer pass.
Definition: InlineAdvisor.h:169
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:155
llvm::InlineAdvice::recordInlining
void recordInlining()
Exactly one of the record* APIs must be called.
Definition: InlineAdvisor.cpp:172
llvm::InlineAdvisorAnalysis::Result::getAdvisor
InlineAdvisor * getAdvisor() const
Definition: InlineAdvisor.h:227
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:22
llvm::getReleaseModeAdvisor
std::unique_ptr< InlineAdvisor > getReleaseModeAdvisor(Module &M, ModuleAnalysisManager &MAM)
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::InlineAdvisor::ImportedFunctionsStats
std::unique_ptr< ImportedFunctionsInliningStatistics > ImportedFunctionsStats
Definition: InlineAdvisor.h:181
llvm::InlineAdvisor::M
Module & M
Definition: InlineAdvisor.h:179
llvm::PassInfoMixin
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:374
llvm::Function
Definition: Function.h:62
llvm::InlineAdvisorAnalysis::run
Result run(Module &M, ModuleAnalysisManager &MAM)
Definition: InlineAdvisor.h:235
llvm::InlineAdvisorAnalysisPrinterPass::run
PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM)
Definition: InlineAdvisor.cpp:563
llvm::InlineAdvice::Caller
Function *const Caller
Caller and Callee are pre-inlining.
Definition: InlineAdvisor.h:99
llvm::emitInlinedIntoBasedOnCost
void emitInlinedIntoBasedOnCost(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 based in cost (default heuristic).
Definition: InlineAdvisor.cpp:488
llvm::InlineAdvice::~InlineAdvice
virtual ~InlineAdvice()
Definition: InlineAdvisor.h:58
llvm::InlineAdvisorAnalysisPrinterPass::InlineAdvisorAnalysisPrinterPass
InlineAdvisorAnalysisPrinterPass(raw_ostream &OS)
Definition: InlineAdvisor.h:244
llvm::ModuleAnalysisManager
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
Definition: PassManager.h:916
llvm::Optional
Definition: APInt.h:33
llvm::InlineParams
Thresholds to tune inline cost analysis.
Definition: InlineCost.h:184
llvm::InlineAdvisor::MandatoryInliningKind::Always
@ Always
llvm::InlineAdvisor::MandatoryInliningKind::Never
@ Never
llvm::DefaultInlineAdvice
Definition: InlineAdvisor.h:120
llvm::addLocationToRemarks
void addLocationToRemarks(OptimizationRemark &Remark, DebugLoc DLoc)
Add location info to ORE message.
Definition: InlineAdvisor.cpp:444
llvm::InlineAdvisor::getCallerORE
OptimizationRemarkEmitter & getCallerORE(CallBase &CB)
Definition: InlineAdvisor.cpp:558
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::InlineAdvisorAnalysisPrinterPass
Printer pass for the FunctionPropertiesAnalysis results.
Definition: InlineAdvisor.h:239
ImportedFunctionsInliningStatistics.h
llvm::emitInlinedInto
void emitInlinedInto(OptimizationRemarkEmitter &ORE, DebugLoc DLoc, const BasicBlock *Block, const Function &Callee, const Function &Caller, bool IsMandatory, function_ref< void(OptimizationRemark &)> ExtraContext={}, const char *PassName=nullptr)
Emit ORE message.
Definition: InlineAdvisor.cpp:470
llvm::InlineAdvice::IsInliningRecommended
const bool IsInliningRecommended
Definition: InlineAdvisor.h:108
llvm::LazyCallGraph::SCC
An SCC of the call graph.
Definition: LazyCallGraph.h:422
llvm::InlineAdvisor::onPassExit
virtual void onPassExit(LazyCallGraph::SCC *SCC=nullptr)
This must be called when the Inliner pass is exited, as function passes may be run subsequently.
Definition: InlineAdvisor.h:166
llvm::InlineAdvice::ORE
OptimizationRemarkEmitter & ORE
Definition: InlineAdvisor.h:107
llvm::DefaultInlineAdvisor
The default (manual heuristics) implementation of the InlineAdvisor.
Definition: InlineAdvisor.h:198
int
Clang compiles this i1 i64 store i64 i64 store i64 i64 store i64 i64 store i64 align Which gets codegen d xmm0 movaps rbp movaps rbp movaps rbp movaps rbp rbp rbp rbp rbp It would be better to have movq s of instead of the movaps s LLVM produces ret int
Definition: README.txt:536
MAM
ModuleAnalysisManager MAM
Definition: PassBuilderBindings.cpp:61
llvm::DefaultInlineAdvisor::DefaultInlineAdvisor
DefaultInlineAdvisor(Module &M, FunctionAnalysisManager &FAM, InlineParams Params)
Definition: InlineAdvisor.h:200
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:54
llvm::InlineAdvice::getOriginalCallSiteBasicBlock
const BasicBlock * getOriginalCallSiteBasicBlock() const
Definition: InlineAdvisor.h:89
llvm::AnalysisManager::Invalidator
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:670
LazyCallGraph.h
llvm::InlineAdvisor::MandatoryInliningKind
MandatoryInliningKind
Definition: InlineAdvisor.h:183
llvm::InlineAdvisorAnalysis::Result
Definition: InlineAdvisor.h:216
llvm::InlineAdvice
Capture state between an inlining decision having had been made, and its impact being observable.
Definition: InlineAdvisor.h:51
llvm::InliningAdvisorMode
InliningAdvisorMode
There are 3 scenarios we can use the InlineAdvisor:
Definition: InlineAdvisor.h:41
llvm::InlineAdvisor::InlineAdvisor
InlineAdvisor(InlineAdvisor &&)=delete
llvm::InlineAdvice::recordUnattemptedInlining
void recordUnattemptedInlining()
Call to indicate inlining was not attempted.
Definition: InlineAdvisor.h:81
llvm::InlineAdvice::recordInliningWithCalleeDeleted
void recordInliningWithCalleeDeleted()
Call after inlining succeeded, and results in the callee being delete-able, meaning,...
Definition: InlineAdvisor.cpp:178
llvm::AnalysisKey
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:72
llvm::InlineAdvice::Block
const BasicBlock *const Block
Definition: InlineAdvisor.h:106
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:343
llvm::InlineAdvice::DLoc
const DebugLoc DLoc
Definition: InlineAdvisor.h:105
InlineCost.h
llvm::ISD::BasicBlock
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:71
Mode
SI Whole Quad Mode
Definition: SIWholeQuadMode.cpp:262
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:83
llvm::InliningAdvisorMode::Development
@ Development
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::AnalysisInfoMixin
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:397
llvm::InlineAdvice::recordUnsuccessfulInliningImpl
virtual void recordUnsuccessfulInliningImpl(const InlineResult &Result)
Definition: InlineAdvisor.h:94
llvm::InlineAdvice::isInliningRecommended
bool isInliningRecommended() const
Get the inlining recommendation.
Definition: InlineAdvisor.h:87
llvm::AMDGPU::CPol::SCC
@ SCC
Definition: SIDefines.h:296
llvm::InlineAdvisor::MandatoryInliningKind::NotMandatory
@ NotMandatory
llvm::InlineAdvisorAnalysis::Result::Result
Result(Module &M, ModuleAnalysisManager &MAM)
Definition: InlineAdvisor.h:217
llvm::OptimizationRemarkEmitter
The optimization diagnostic interface.
Definition: OptimizationRemarkEmitter.h:33
llvm::InlineAdvisor::onPassEntry
virtual void onPassEntry()
This must be called when the Inliner pass is entered, to allow the InlineAdvisor update internal stat...
Definition: InlineAdvisor.h:161
llvm::InlineAdvisor
Interface for deciding whether to inline a call site or not.
Definition: InlineAdvisor.h:140
llvm::InlineAdvisorAnalysis::InlineAdvisorAnalysis
InlineAdvisorAnalysis()=default
llvm::InlineAdvice::recordUnattemptedInliningImpl
virtual void recordUnattemptedInliningImpl()
Definition: InlineAdvisor.h:95
Module
Machine Check Debug Module
Definition: MachineCheckDebugify.cpp:122
llvm::InlineAdvice::recordInliningWithCalleeDeletedImpl
virtual void recordInliningWithCalleeDeletedImpl()
Definition: InlineAdvisor.h:93
llvm::InlineAdvisor::getMandatoryAdvice
virtual std::unique_ptr< InlineAdvice > getMandatoryAdvice(CallBase &CB, bool Advice)
Definition: InlineAdvisor.cpp:519
llvm::InlineAdvisor::FAM
FunctionAnalysisManager & FAM
Definition: InlineAdvisor.h:180
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:548
llvm::InlineAdvisor::getAdviceImpl
virtual std::unique_ptr< InlineAdvice > getAdviceImpl(CallBase &CB)=0
PassManager.h
llvm::inlineCostStr
std::string inlineCostStr(const InlineCost &IC)
Utility for extracting the inline cost message to a string.
Definition: InlineAdvisor.cpp:336
llvm::InlineAdvisor::getMandatoryKind
static MandatoryInliningKind getMandatoryKind(CallBase &CB, FunctionAnalysisManager &FAM, OptimizationRemarkEmitter &ORE)
Definition: InlineAdvisor.cpp:526
llvm::InlineAdvisorAnalysis
The InlineAdvisorAnalysis is a module pass because the InlineAdvisor needs to capture state right bef...
Definition: InlineAdvisor.h:212
llvm::InlineAdvisorAnalysis::Key
static AnalysisKey Key
Definition: InlineAdvisor.h:214
llvm::InliningAdvisorMode::Default
@ Default
llvm::getDevelopmentModeAdvisor
std::unique_ptr< InlineAdvisor > getDevelopmentModeAdvisor(Module &M, ModuleAnalysisManager &MAM, std::function< bool(CallBase &)> GetDefaultAdvice)
llvm::InlineAdvice::InlineAdvice
InlineAdvice(InlineAdvisor *Advisor, CallBase &CB, OptimizationRemarkEmitter &ORE, bool IsInliningRecommended)
Definition: InlineAdvisor.cpp:160
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1176
llvm::PreservedAnalyses::getChecker
PreservedAnalysisChecker getChecker() const
Build a checker for this PreservedAnalyses and the specified analysis type.
Definition: PassManager.h:313
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:44
llvm::InliningAdvisorMode::Release
@ Release
llvm::DefaultInlineAdvice::DefaultInlineAdvice
DefaultInlineAdvice(InlineAdvisor *Advisor, CallBase &CB, Optional< InlineCost > OIC, OptimizationRemarkEmitter &ORE, bool EmitRemarks=true)
Definition: InlineAdvisor.h:122
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
llvm::InlineAdvice::getOriginalCallSiteDebugLoc
const DebugLoc & getOriginalCallSiteDebugLoc() const
Definition: InlineAdvisor.h:88
llvm::InlineAdvice::Advisor
InlineAdvisor *const Advisor
Definition: InlineAdvisor.h:97
llvm::InlineResult
InlineResult is basically true or false.
Definition: InlineCost.h:158
llvm::InlineAdvice::Callee
Function *const Callee
Definition: InlineAdvisor.h:100
llvm::ReplayInlinerSettings
Replay Inliner Setup.
Definition: ReplayInlineAdvisor.h:43
llvm::InlineAdvice::recordUnsuccessfulInlining
void recordUnsuccessfulInlining(const InlineResult &Result)
Call after the decision for a call site was to not inline.
Definition: InlineAdvisor.h:75
llvm::InlineAdvisor::~InlineAdvisor
virtual ~InlineAdvisor()
Definition: InlineAdvisor.cpp:511
PassName
static const char PassName[]
Definition: X86LowerAMXIntrinsics.cpp:670
llvm::codeview::PublicSymFlags::Function
@ Function
llvm::InlineAdvisorAnalysis::Result::tryCreate
bool tryCreate(InlineParams Params, InliningAdvisorMode Mode, const ReplayInlinerSettings &ReplaySettings)
Definition: InlineAdvisor.cpp:186
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:356
llvm::InlineAdvisorAnalysis::Result::invalidate
bool invalidate(Module &, const PreservedAnalyses &PA, ModuleAnalysisManager::Invalidator &)
Definition: InlineAdvisor.h:218