LLVM  16.0.0git
InlineCost.h
Go to the documentation of this file.
1 //===- InlineCost.h - Cost analysis for inliner -----------------*- 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 // This file implements heuristics for inlining decisions.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_ANALYSIS_INLINECOST_H
14 #define LLVM_ANALYSIS_INLINECOST_H
15 
16 #include "llvm/ADT/APInt.h"
17 #include "llvm/ADT/Optional.h"
20 #include "llvm/IR/PassManager.h"
21 #include <cassert>
22 #include <climits>
23 
24 namespace llvm {
25 class AssumptionCache;
26 class OptimizationRemarkEmitter;
27 class BlockFrequencyInfo;
28 class CallBase;
29 class DataLayout;
30 class Function;
31 class ProfileSummaryInfo;
32 class TargetTransformInfo;
33 class TargetLibraryInfo;
34 
35 namespace InlineConstants {
36 // Various thresholds used by inline cost analysis.
37 /// Use when optsize (-Os) is specified.
38 const int OptSizeThreshold = 50;
39 
40 /// Use when minsize (-Oz) is specified.
41 const int OptMinSizeThreshold = 5;
42 
43 /// Use when -O3 is specified.
44 const int OptAggressiveThreshold = 250;
45 
46 // Various magic constants used to adjust heuristics.
47 int getInstrCost();
48 const int IndirectCallThreshold = 100;
49 const int LoopPenalty = 25;
50 const int LastCallToStaticBonus = 15000;
51 const int ColdccPenalty = 2000;
52 /// Do not inline functions which allocate this many bytes on the stack
53 /// when the caller is recursive.
54 const unsigned TotalAllocaSizeRecursiveCaller = 1024;
55 /// Do not inline dynamic allocas that have been constant propagated to be
56 /// static allocas above this amount in bytes.
58 
60  "function-inline-cost-multiplier";
61 
62 const char MaxInlineStackSizeAttributeName[] = "inline-max-stacksize";
63 } // namespace InlineConstants
64 
65 // The cost-benefit pair computed by cost-benefit analysis.
67 public:
68  CostBenefitPair(APInt Cost, APInt Benefit) : Cost(Cost), Benefit(Benefit) {}
69 
70  const APInt &getCost() const { return Cost; }
71 
72  const APInt &getBenefit() const { return Benefit; }
73 
74 private:
75  APInt Cost;
76  APInt Benefit;
77 };
78 
79 /// Represents the cost of inlining a function.
80 ///
81 /// This supports special values for functions which should "always" or
82 /// "never" be inlined. Otherwise, the cost represents a unitless amount;
83 /// smaller values increase the likelihood of the function being inlined.
84 ///
85 /// Objects of this type also provide the adjusted threshold for inlining
86 /// based on the information available for a particular callsite. They can be
87 /// directly tested to determine if inlining should occur given the cost and
88 /// threshold for this cost metric.
89 class InlineCost {
90  enum SentinelValues { AlwaysInlineCost = INT_MIN, NeverInlineCost = INT_MAX };
91 
92  /// The estimated cost of inlining this callsite.
93  int Cost = 0;
94 
95  /// The adjusted threshold against which this cost was computed.
96  int Threshold = 0;
97 
98  /// Must be set for Always and Never instances.
99  const char *Reason = nullptr;
100 
101  /// The cost-benefit pair computed by cost-benefit analysis.
102  Optional<CostBenefitPair> CostBenefit = None;
103 
104  // Trivial constructor, interesting logic in the factory functions below.
105  InlineCost(int Cost, int Threshold, const char *Reason = nullptr,
106  Optional<CostBenefitPair> CostBenefit = None)
107  : Cost(Cost), Threshold(Threshold), Reason(Reason),
108  CostBenefit(CostBenefit) {
109  assert((isVariable() || Reason) &&
110  "Reason must be provided for Never or Always");
111  }
112 
113 public:
114  static InlineCost get(int Cost, int Threshold) {
115  assert(Cost > AlwaysInlineCost && "Cost crosses sentinel value");
116  assert(Cost < NeverInlineCost && "Cost crosses sentinel value");
117  return InlineCost(Cost, Threshold);
118  }
119  static InlineCost getAlways(const char *Reason,
120  Optional<CostBenefitPair> CostBenefit = None) {
121  return InlineCost(AlwaysInlineCost, 0, Reason, CostBenefit);
122  }
123  static InlineCost getNever(const char *Reason,
124  Optional<CostBenefitPair> CostBenefit = None) {
125  return InlineCost(NeverInlineCost, 0, Reason, CostBenefit);
126  }
127 
128  /// Test whether the inline cost is low enough for inlining.
129  explicit operator bool() const { return Cost < Threshold; }
130 
131  bool isAlways() const { return Cost == AlwaysInlineCost; }
132  bool isNever() const { return Cost == NeverInlineCost; }
133  bool isVariable() const { return !isAlways() && !isNever(); }
134 
135  /// Get the inline cost estimate.
136  /// It is an error to call this on an "always" or "never" InlineCost.
137  int getCost() const {
138  assert(isVariable() && "Invalid access of InlineCost");
139  return Cost;
140  }
141 
142  /// Get the threshold against which the cost was computed
143  int getThreshold() const {
144  assert(isVariable() && "Invalid access of InlineCost");
145  return Threshold;
146  }
147 
148  /// Get the cost-benefit pair which was computed by cost-benefit analysis
149  Optional<CostBenefitPair> getCostBenefit() const { return CostBenefit; }
150 
151  /// Get the reason of Always or Never.
152  const char *getReason() const {
153  assert((Reason || isVariable()) &&
154  "InlineCost reason must be set for Always or Never");
155  return Reason;
156  }
157 
158  /// Get the cost delta from the threshold for inlining.
159  /// Only valid if the cost is of the variable kind. Returns a negative
160  /// value if the cost is too high to inline.
161  int getCostDelta() const { return Threshold - getCost(); }
162 };
163 
164 /// InlineResult is basically true or false. For false results the message
165 /// describes a reason.
167  const char *Message = nullptr;
168  InlineResult(const char *Message = nullptr) : Message(Message) {}
169 
170 public:
171  static InlineResult success() { return {}; }
172  static InlineResult failure(const char *Reason) {
173  return InlineResult(Reason);
174  }
175  bool isSuccess() const { return Message == nullptr; }
176  const char *getFailureReason() const {
177  assert(!isSuccess() &&
178  "getFailureReason should only be called in failure cases");
179  return Message;
180  }
181 };
182 
183 /// Thresholds to tune inline cost analysis. The inline cost analysis decides
184 /// the condition to apply a threshold and applies it. Otherwise,
185 /// DefaultThreshold is used. If a threshold is Optional, it is applied only
186 /// when it has a valid value. Typically, users of inline cost analysis
187 /// obtain an InlineParams object through one of the \c getInlineParams methods
188 /// and pass it to \c getInlineCost. Some specialized versions of inliner
189 /// (such as the pre-inliner) might have custom logic to compute \c InlineParams
190 /// object.
191 
192 struct InlineParams {
193  /// The default threshold to start with for a callee.
195 
196  /// Threshold to use for callees with inline hint.
198 
199  /// Threshold to use for cold callees.
201 
202  /// Threshold to use when the caller is optimized for size.
204 
205  /// Threshold to use when the caller is optimized for minsize.
207 
208  /// Threshold to use when the callsite is considered hot.
210 
211  /// Threshold to use when the callsite is considered hot relative to function
212  /// entry.
214 
215  /// Threshold to use when the callsite is considered cold.
217 
218  /// Compute inline cost even when the cost has exceeded the threshold.
220 
221  /// Indicate whether we should allow inline deferral.
223 
224  /// Indicate whether we allow inlining for recursive call.
226 };
227 
229 
230 /// Generate the parameters to tune the inline cost analysis based only on the
231 /// commandline options.
233 
234 /// Generate the parameters to tune the inline cost analysis based on command
235 /// line options. If -inline-threshold option is not explicitly passed,
236 /// \p Threshold is used as the default threshold.
237 InlineParams getInlineParams(int Threshold);
238 
239 /// Generate the parameters to tune the inline cost analysis based on command
240 /// line options. If -inline-threshold option is not explicitly passed,
241 /// the default threshold is computed from \p OptLevel and \p SizeOptLevel.
242 /// An \p OptLevel value above 3 is considered an aggressive optimization mode.
243 /// \p SizeOptLevel of 1 corresponds to the -Os flag and 2 corresponds to
244 /// the -Oz flag.
245 InlineParams getInlineParams(unsigned OptLevel, unsigned SizeOptLevel);
246 
247 /// Return the cost associated with a callsite, including parameter passing
248 /// and the call/return instruction.
249 int getCallsiteCost(const CallBase &Call, const DataLayout &DL);
250 
251 /// Get an InlineCost object representing the cost of inlining this
252 /// callsite.
253 ///
254 /// Note that a default threshold is passed into this function. This threshold
255 /// could be modified based on callsite's properties and only costs below this
256 /// new threshold are computed with any accuracy. The new threshold can be
257 /// used to bound the computation necessary to determine whether the cost is
258 /// sufficiently low to warrant inlining.
259 ///
260 /// Also note that calling this function *dynamically* computes the cost of
261 /// inlining the callsite. It is an expensive, heavyweight call.
263 getInlineCost(CallBase &Call, const InlineParams &Params,
264  TargetTransformInfo &CalleeTTI,
265  function_ref<AssumptionCache &(Function &)> GetAssumptionCache,
266  function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
267  function_ref<BlockFrequencyInfo &(Function &)> GetBFI = nullptr,
268  ProfileSummaryInfo *PSI = nullptr,
269  OptimizationRemarkEmitter *ORE = nullptr);
270 
271 /// Get an InlineCost with the callee explicitly specified.
272 /// This allows you to calculate the cost of inlining a function via a
273 /// pointer. This behaves exactly as the version with no explicit callee
274 /// parameter in all other respects.
275 //
277 getInlineCost(CallBase &Call, Function *Callee, const InlineParams &Params,
278  TargetTransformInfo &CalleeTTI,
279  function_ref<AssumptionCache &(Function &)> GetAssumptionCache,
280  function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
281  function_ref<BlockFrequencyInfo &(Function &)> GetBFI = nullptr,
282  ProfileSummaryInfo *PSI = nullptr,
283  OptimizationRemarkEmitter *ORE = nullptr);
284 
285 /// Returns InlineResult::success() if the call site should be always inlined
286 /// because of user directives, and the inlining is viable. Returns
287 /// InlineResult::failure() if the inlining may never happen because of user
288 /// directives or incompatibilities detectable without needing callee traversal.
289 /// Otherwise returns None, meaning that inlining should be decided based on
290 /// other criteria (e.g. cost modeling).
292  CallBase &Call, Function *Callee, TargetTransformInfo &CalleeTTI,
293  function_ref<const TargetLibraryInfo &(Function &)> GetTLI);
294 
295 /// Get the cost estimate ignoring thresholds. This is similar to getInlineCost
296 /// when passed InlineParams::ComputeFullInlineCost, or a non-null ORE. It
297 /// uses default InlineParams otherwise.
298 /// Contrary to getInlineCost, which makes a threshold-based final evaluation of
299 /// should/shouldn't inline, captured in InlineResult, getInliningCostEstimate
300 /// returns:
301 /// - None, if the inlining cannot happen (is illegal)
302 /// - an integer, representing the cost.
304  CallBase &Call, TargetTransformInfo &CalleeTTI,
305  function_ref<AssumptionCache &(Function &)> GetAssumptionCache,
306  function_ref<BlockFrequencyInfo &(Function &)> GetBFI = nullptr,
307  ProfileSummaryInfo *PSI = nullptr,
308  OptimizationRemarkEmitter *ORE = nullptr);
309 
310 /// Get the expanded cost features. The features are returned unconditionally,
311 /// even if inlining is impossible.
313  CallBase &Call, TargetTransformInfo &CalleeTTI,
314  function_ref<AssumptionCache &(Function &)> GetAssumptionCache,
315  function_ref<BlockFrequencyInfo &(Function &)> GetBFI = nullptr,
316  ProfileSummaryInfo *PSI = nullptr,
317  OptimizationRemarkEmitter *ORE = nullptr);
318 
319 /// Minimal filter to detect invalid constructs for inlining.
321 
322 // This pass is used to annotate instructions during the inline process for
323 // debugging and analysis. The main purpose of the pass is to see and test
324 // inliner's decisions when creating new optimizations to InlineCost.
326  : PassInfoMixin<InlineCostAnnotationPrinterPass> {
328 
329 public:
332 };
333 } // namespace llvm
334 
335 #endif
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
llvm::InlineCost::isAlways
bool isAlways() const
Definition: InlineCost.h:131
llvm::InlineCost::getCost
int getCost() const
Get the inline cost estimate.
Definition: InlineCost.h:137
llvm::InlineResult::success
static InlineResult success()
Definition: InlineCost.h:171
llvm::InlineCostAnnotationPrinterPass::InlineCostAnnotationPrinterPass
InlineCostAnnotationPrinterPass(raw_ostream &OS)
Definition: InlineCost.h:330
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::getStringFnAttrAsInt
Optional< int > getStringFnAttrAsInt(CallBase &CB, StringRef AttrKind)
Definition: InlineCost.cpp:173
Optional.h
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:113
llvm::InlineParams::DefaultThreshold
int DefaultThreshold
The default threshold to start with for a callee.
Definition: InlineCost.h:194
llvm::PassInfoMixin
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:371
llvm::Function
Definition: Function.h:60
llvm::InlineParams::LocallyHotCallSiteThreshold
Optional< int > LocallyHotCallSiteThreshold
Threshold to use when the callsite is considered hot relative to function entry.
Definition: InlineCost.h:213
llvm::TargetTransformInfo
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Definition: TargetTransformInfo.h:172
FAM
FunctionAnalysisManager FAM
Definition: PassBuilderBindings.cpp:59
APInt.h
llvm::InlineConstants::OptSizeThreshold
const int OptSizeThreshold
Use when optsize (-Os) is specified.
Definition: InlineCost.h:38
llvm::InlineCost::getAlways
static InlineCost getAlways(const char *Reason, Optional< CostBenefitPair > CostBenefit=None)
Definition: InlineCost.h:119
llvm::Optional
Definition: APInt.h:33
llvm::isInlineViable
InlineResult isInlineViable(Function &Callee)
Minimal filter to detect invalid constructs for inlining.
Definition: InlineCost.cpp:2981
llvm::InlineParams
Thresholds to tune inline cost analysis.
Definition: InlineCost.h:192
llvm::InlineCost::getThreshold
int getThreshold() const
Get the threshold against which the cost was computed.
Definition: InlineCost.h:143
llvm::InlineConstants::FunctionInlineCostMultiplierAttributeName
const char FunctionInlineCostMultiplierAttributeName[]
Definition: InlineCost.h:59
llvm::InlineParams::ColdThreshold
Optional< int > ColdThreshold
Threshold to use for cold callees.
Definition: InlineCost.h:200
llvm::InlineCost::isNever
bool isNever() const
Definition: InlineCost.h:132
llvm::InlineParams::OptMinSizeThreshold
Optional< int > OptMinSizeThreshold
Threshold to use when the caller is optimized for minsize.
Definition: InlineCost.h:206
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::InlineParams::ComputeFullInlineCost
Optional< bool > ComputeFullInlineCost
Compute inline cost even when the cost has exceeded the threshold.
Definition: InlineCost.h:219
llvm::BlockFrequencyInfo
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
Definition: BlockFrequencyInfo.h:37
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:2815
InlinePriorityMode::Cost
@ Cost
llvm::InlineCost
Represents the cost of inlining a function.
Definition: InlineCost.h:89
llvm::InlineConstants::getInstrCost
int getInstrCost()
Definition: InlineCost.cpp:182
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
llvm::InlineResult::isSuccess
bool isSuccess() const
Definition: InlineCost.h:175
llvm::InlineCostAnnotationPrinterPass::run
PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM)
Definition: InlineCost.cpp:3122
STLFunctionalExtras.h
llvm::InlineCost::get
static InlineCost get(int Cost, int Threshold)
Definition: InlineCost.h:114
llvm::getInlineParams
InlineParams getInlineParams()
Generate the parameters to tune the inline cost analysis based only on the commandline options.
Definition: InlineCost.cpp:3093
llvm::None
const NoneType None
Definition: None.h:24
llvm::ProfileSummaryInfo
Analysis providing profile information.
Definition: ProfileSummaryInfo.h:39
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLFunctionalExtras.h:36
llvm::InlineConstants::MaxInlineStackSizeAttributeName
const char MaxInlineStackSizeAttributeName[]
Definition: InlineCost.h:62
llvm::InlineConstants::IndirectCallThreshold
const int IndirectCallThreshold
Definition: InlineCost.h:48
uint64_t
llvm::InlineConstants::OptAggressiveThreshold
const int OptAggressiveThreshold
Use when -O3 is specified.
Definition: InlineCost.h:44
llvm::InlineCost::getCostDelta
int getCostDelta() const
Get the cost delta from the threshold for inlining.
Definition: InlineCost.h:161
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::InlineCostAnnotationPrinterPass::OS
raw_ostream & OS
Definition: InlineCost.h:327
llvm::InlineParams::ColdCallSiteThreshold
Optional< int > ColdCallSiteThreshold
Threshold to use when the callsite is considered cold.
Definition: InlineCost.h:216
llvm::InlineCost::getNever
static InlineCost getNever(const char *Reason, Optional< CostBenefitPair > CostBenefit=None)
Definition: InlineCost.h:123
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:75
llvm::InlineCostAnnotationPrinterPass
Definition: InlineCost.h:325
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:50
llvm::InlineCost::getReason
const char * getReason() const
Get the reason of Always or Never.
Definition: InlineCost.h:152
llvm::AssumptionCache
A cache of @llvm.assume calls within a function.
Definition: AssumptionCache.h:42
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::InlineResult::getFailureReason
const char * getFailureReason() const
Definition: InlineCost.h:176
llvm::InlineConstants::MaxSimplifiedDynamicAllocaToInline
const uint64_t MaxSimplifiedDynamicAllocaToInline
Do not inline dynamic allocas that have been constant propagated to be static allocas above this amou...
Definition: InlineCost.h:57
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:2863
llvm::InlineParams::HintThreshold
Optional< int > HintThreshold
Threshold to use for callees with inline hint.
Definition: InlineCost.h:197
llvm::InlineConstants::ColdccPenalty
const int ColdccPenalty
Definition: InlineCost.h:51
llvm::getInliningCostFeatures
Optional< InlineCostFeatures > getInliningCostFeatures(CallBase &Call, TargetTransformInfo &CalleeTTI, function_ref< AssumptionCache &(Function &)> GetAssumptionCache, function_ref< BlockFrequencyInfo &(Function &)> GetBFI=nullptr, ProfileSummaryInfo *PSI=nullptr, OptimizationRemarkEmitter *ORE=nullptr)
Get the expanded cost features.
Definition: InlineCost.cpp:2850
llvm::InlineCost::getCostBenefit
Optional< CostBenefitPair > getCostBenefit() const
Get the cost-benefit pair which was computed by cost-benefit analysis.
Definition: InlineCost.h:149
llvm::CostBenefitPair::CostBenefitPair
CostBenefitPair(APInt Cost, APInt Benefit)
Definition: InlineCost.h:68
llvm::CostBenefitPair::getCost
const APInt & getCost() const
Definition: InlineCost.h:70
PassManager.h
llvm::TargetLibraryInfo
Provides information about what library functions are available for the current target.
Definition: TargetLibraryInfo.h:222
llvm::getCallsiteCost
int getCallsiteCost(const CallBase &Call, const DataLayout &DL)
Return the cost associated with a callsite, including parameter passing and the call/return instructi...
Definition: InlineCost.cpp:2781
llvm::InlineResult::failure
static InlineResult failure(const char *Reason)
Definition: InlineCost.h:172
llvm::InlineConstants::OptMinSizeThreshold
const int OptMinSizeThreshold
Use when minsize (-Oz) is specified.
Definition: InlineCost.h:41
llvm::CostBenefitPair
Definition: InlineCost.h:66
llvm::getInliningCostEstimate
Optional< int > getInliningCostEstimate(CallBase &Call, TargetTransformInfo &CalleeTTI, function_ref< AssumptionCache &(Function &)> GetAssumptionCache, function_ref< BlockFrequencyInfo &(Function &)> GetBFI=nullptr, ProfileSummaryInfo *PSI=nullptr, OptimizationRemarkEmitter *ORE=nullptr)
Get the cost estimate ignoring thresholds.
Definition: InlineCost.cpp:2825
llvm::InlineConstants::LastCallToStaticBonus
const int LastCallToStaticBonus
Definition: InlineCost.h:50
llvm::CostBenefitPair::getBenefit
const APInt & getBenefit() const
Definition: InlineCost.h:72
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1174
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:42
llvm::InlineCost::isVariable
bool isVariable() const
Definition: InlineCost.h:133
InlineModelFeatureMaps.h
llvm::InlineParams::HotCallSiteThreshold
Optional< int > HotCallSiteThreshold
Threshold to use when the callsite is considered hot.
Definition: InlineCost.h:209
llvm::InlineConstants::TotalAllocaSizeRecursiveCaller
const unsigned TotalAllocaSizeRecursiveCaller
Do not inline functions which allocate this many bytes on the stack when the caller is recursive.
Definition: InlineCost.h:54
llvm::InlineParams::EnableDeferral
Optional< bool > EnableDeferral
Indicate whether we should allow inline deferral.
Definition: InlineCost.h:222
llvm::InlineParams::AllowRecursiveCall
Optional< bool > AllowRecursiveCall
Indicate whether we allow inlining for recursive call.
Definition: InlineCost.h:225
llvm::InlineConstants::LoopPenalty
const int LoopPenalty
Definition: InlineCost.h:49
llvm::InlineResult
InlineResult is basically true or false.
Definition: InlineCost.h:166
llvm::InlineParams::OptSizeThreshold
Optional< int > OptSizeThreshold
Threshold to use when the caller is optimized for size.
Definition: InlineCost.h:203
llvm::codeview::PublicSymFlags::Function
@ Function