LLVM  15.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 const int InstrCost = 5;
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 } // namespace InlineConstants
62 
63 // The cost-benefit pair computed by cost-benefit analysis.
65 public:
66  CostBenefitPair(APInt Cost, APInt Benefit) : Cost(Cost), Benefit(Benefit) {}
67 
68  const APInt &getCost() const { return Cost; }
69 
70  const APInt &getBenefit() const { return Benefit; }
71 
72 private:
73  APInt Cost;
74  APInt Benefit;
75 };
76 
77 /// Represents the cost of inlining a function.
78 ///
79 /// This supports special values for functions which should "always" or
80 /// "never" be inlined. Otherwise, the cost represents a unitless amount;
81 /// smaller values increase the likelihood of the function being inlined.
82 ///
83 /// Objects of this type also provide the adjusted threshold for inlining
84 /// based on the information available for a particular callsite. They can be
85 /// directly tested to determine if inlining should occur given the cost and
86 /// threshold for this cost metric.
87 class InlineCost {
88  enum SentinelValues { AlwaysInlineCost = INT_MIN, NeverInlineCost = INT_MAX };
89 
90  /// The estimated cost of inlining this callsite.
91  int Cost = 0;
92 
93  /// The adjusted threshold against which this cost was computed.
94  int Threshold = 0;
95 
96  /// Must be set for Always and Never instances.
97  const char *Reason = nullptr;
98 
99  /// The cost-benefit pair computed by cost-benefit analysis.
100  Optional<CostBenefitPair> CostBenefit = None;
101 
102  // Trivial constructor, interesting logic in the factory functions below.
103  InlineCost(int Cost, int Threshold, const char *Reason = nullptr,
104  Optional<CostBenefitPair> CostBenefit = None)
105  : Cost(Cost), Threshold(Threshold), Reason(Reason),
106  CostBenefit(CostBenefit) {
107  assert((isVariable() || Reason) &&
108  "Reason must be provided for Never or Always");
109  }
110 
111 public:
112  static InlineCost get(int Cost, int Threshold) {
113  assert(Cost > AlwaysInlineCost && "Cost crosses sentinel value");
114  assert(Cost < NeverInlineCost && "Cost crosses sentinel value");
115  return InlineCost(Cost, Threshold);
116  }
117  static InlineCost getAlways(const char *Reason,
118  Optional<CostBenefitPair> CostBenefit = None) {
119  return InlineCost(AlwaysInlineCost, 0, Reason, CostBenefit);
120  }
121  static InlineCost getNever(const char *Reason,
122  Optional<CostBenefitPair> CostBenefit = None) {
123  return InlineCost(NeverInlineCost, 0, Reason, CostBenefit);
124  }
125 
126  /// Test whether the inline cost is low enough for inlining.
127  explicit operator bool() const { return Cost < Threshold; }
128 
129  bool isAlways() const { return Cost == AlwaysInlineCost; }
130  bool isNever() const { return Cost == NeverInlineCost; }
131  bool isVariable() const { return !isAlways() && !isNever(); }
132 
133  /// Get the inline cost estimate.
134  /// It is an error to call this on an "always" or "never" InlineCost.
135  int getCost() const {
136  assert(isVariable() && "Invalid access of InlineCost");
137  return Cost;
138  }
139 
140  /// Get the threshold against which the cost was computed
141  int getThreshold() const {
142  assert(isVariable() && "Invalid access of InlineCost");
143  return Threshold;
144  }
145 
146  /// Get the cost-benefit pair which was computed by cost-benefit analysis
147  Optional<CostBenefitPair> getCostBenefit() const { return CostBenefit; }
148 
149  /// Get the reason of Always or Never.
150  const char *getReason() const {
151  assert((Reason || isVariable()) &&
152  "InlineCost reason must be set for Always or Never");
153  return Reason;
154  }
155 
156  /// Get the cost delta from the threshold for inlining.
157  /// Only valid if the cost is of the variable kind. Returns a negative
158  /// value if the cost is too high to inline.
159  int getCostDelta() const { return Threshold - getCost(); }
160 };
161 
162 /// InlineResult is basically true or false. For false results the message
163 /// describes a reason.
165  const char *Message = nullptr;
166  InlineResult(const char *Message = nullptr) : Message(Message) {}
167 
168 public:
169  static InlineResult success() { return {}; }
170  static InlineResult failure(const char *Reason) {
171  return InlineResult(Reason);
172  }
173  bool isSuccess() const { return Message == nullptr; }
174  const char *getFailureReason() const {
175  assert(!isSuccess() &&
176  "getFailureReason should only be called in failure cases");
177  return Message;
178  }
179 };
180 
181 /// Thresholds to tune inline cost analysis. The inline cost analysis decides
182 /// the condition to apply a threshold and applies it. Otherwise,
183 /// DefaultThreshold is used. If a threshold is Optional, it is applied only
184 /// when it has a valid value. Typically, users of inline cost analysis
185 /// obtain an InlineParams object through one of the \c getInlineParams methods
186 /// and pass it to \c getInlineCost. Some specialized versions of inliner
187 /// (such as the pre-inliner) might have custom logic to compute \c InlineParams
188 /// object.
189 
190 struct InlineParams {
191  /// The default threshold to start with for a callee.
193 
194  /// Threshold to use for callees with inline hint.
196 
197  /// Threshold to use for cold callees.
199 
200  /// Threshold to use when the caller is optimized for size.
202 
203  /// Threshold to use when the caller is optimized for minsize.
205 
206  /// Threshold to use when the callsite is considered hot.
208 
209  /// Threshold to use when the callsite is considered hot relative to function
210  /// entry.
212 
213  /// Threshold to use when the callsite is considered cold.
215 
216  /// Compute inline cost even when the cost has exceeded the threshold.
218 
219  /// Indicate whether we should allow inline deferral.
221 
222  /// Indicate whether we allow inlining for recursive call.
224 };
225 
227 
228 /// Generate the parameters to tune the inline cost analysis based only on the
229 /// commandline options.
231 
232 /// Generate the parameters to tune the inline cost analysis based on command
233 /// line options. If -inline-threshold option is not explicitly passed,
234 /// \p Threshold is used as the default threshold.
235 InlineParams getInlineParams(int Threshold);
236 
237 /// Generate the parameters to tune the inline cost analysis based on command
238 /// line options. If -inline-threshold option is not explicitly passed,
239 /// the default threshold is computed from \p OptLevel and \p SizeOptLevel.
240 /// An \p OptLevel value above 3 is considered an aggressive optimization mode.
241 /// \p SizeOptLevel of 1 corresponds to the -Os flag and 2 corresponds to
242 /// the -Oz flag.
243 InlineParams getInlineParams(unsigned OptLevel, unsigned SizeOptLevel);
244 
245 /// Return the cost associated with a callsite, including parameter passing
246 /// and the call/return instruction.
247 int getCallsiteCost(CallBase &Call, const DataLayout &DL);
248 
249 /// Get an InlineCost object representing the cost of inlining this
250 /// callsite.
251 ///
252 /// Note that a default threshold is passed into this function. This threshold
253 /// could be modified based on callsite's properties and only costs below this
254 /// new threshold are computed with any accuracy. The new threshold can be
255 /// used to bound the computation necessary to determine whether the cost is
256 /// sufficiently low to warrant inlining.
257 ///
258 /// Also note that calling this function *dynamically* computes the cost of
259 /// inlining the callsite. It is an expensive, heavyweight call.
261 getInlineCost(CallBase &Call, const InlineParams &Params,
262  TargetTransformInfo &CalleeTTI,
263  function_ref<AssumptionCache &(Function &)> GetAssumptionCache,
264  function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
265  function_ref<BlockFrequencyInfo &(Function &)> GetBFI = nullptr,
266  ProfileSummaryInfo *PSI = nullptr,
267  OptimizationRemarkEmitter *ORE = nullptr);
268 
269 /// Get an InlineCost with the callee explicitly specified.
270 /// This allows you to calculate the cost of inlining a function via a
271 /// pointer. This behaves exactly as the version with no explicit callee
272 /// parameter in all other respects.
273 //
275 getInlineCost(CallBase &Call, Function *Callee, const InlineParams &Params,
276  TargetTransformInfo &CalleeTTI,
277  function_ref<AssumptionCache &(Function &)> GetAssumptionCache,
278  function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
279  function_ref<BlockFrequencyInfo &(Function &)> GetBFI = nullptr,
280  ProfileSummaryInfo *PSI = nullptr,
281  OptimizationRemarkEmitter *ORE = nullptr);
282 
283 /// Returns InlineResult::success() if the call site should be always inlined
284 /// because of user directives, and the inlining is viable. Returns
285 /// InlineResult::failure() if the inlining may never happen because of user
286 /// directives or incompatibilities detectable without needing callee traversal.
287 /// Otherwise returns None, meaning that inlining should be decided based on
288 /// other criteria (e.g. cost modeling).
290  CallBase &Call, Function *Callee, TargetTransformInfo &CalleeTTI,
291  function_ref<const TargetLibraryInfo &(Function &)> GetTLI);
292 
293 /// Get the cost estimate ignoring thresholds. This is similar to getInlineCost
294 /// when passed InlineParams::ComputeFullInlineCost, or a non-null ORE. It
295 /// uses default InlineParams otherwise.
296 /// Contrary to getInlineCost, which makes a threshold-based final evaluation of
297 /// should/shouldn't inline, captured in InlineResult, getInliningCostEstimate
298 /// returns:
299 /// - None, if the inlining cannot happen (is illegal)
300 /// - an integer, representing the cost.
302  CallBase &Call, TargetTransformInfo &CalleeTTI,
303  function_ref<AssumptionCache &(Function &)> GetAssumptionCache,
304  function_ref<BlockFrequencyInfo &(Function &)> GetBFI = nullptr,
305  ProfileSummaryInfo *PSI = nullptr,
306  OptimizationRemarkEmitter *ORE = nullptr);
307 
308 /// Get the expanded cost features. The features are returned unconditionally,
309 /// even if inlining is impossible.
311  CallBase &Call, TargetTransformInfo &CalleeTTI,
312  function_ref<AssumptionCache &(Function &)> GetAssumptionCache,
313  function_ref<BlockFrequencyInfo &(Function &)> GetBFI = nullptr,
314  ProfileSummaryInfo *PSI = nullptr,
315  OptimizationRemarkEmitter *ORE = nullptr);
316 
317 /// Minimal filter to detect invalid constructs for inlining.
319 
320 // This pass is used to annotate instructions during the inline process for
321 // debugging and analysis. The main purpose of the pass is to see and test
322 // inliner's decisions when creating new optimizations to InlineCost.
324  : PassInfoMixin<InlineCostAnnotationPrinterPass> {
326 
327 public:
330 };
331 } // namespace llvm
332 
333 #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:129
llvm::InlineCost::getCost
int getCost() const
Get the inline cost estimate.
Definition: InlineCost.h:135
llvm::InlineResult::success
static InlineResult success()
Definition: InlineCost.h:169
llvm::InlineCostAnnotationPrinterPass::InlineCostAnnotationPrinterPass
InlineCostAnnotationPrinterPass(raw_ostream &OS)
Definition: InlineCost.h:328
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::getStringFnAttrAsInt
Optional< int > getStringFnAttrAsInt(CallBase &CB, StringRef AttrKind)
Definition: InlineCost.cpp:149
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:192
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:211
llvm::TargetTransformInfo
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Definition: TargetTransformInfo.h:168
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:117
llvm::Optional
Definition: APInt.h:33
llvm::isInlineViable
InlineResult isInlineViable(Function &Callee)
Minimal filter to detect invalid constructs for inlining.
Definition: InlineCost.cpp:2942
llvm::InlineParams
Thresholds to tune inline cost analysis.
Definition: InlineCost.h:190
llvm::InlineCost::getThreshold
int getThreshold() const
Get the threshold against which the cost was computed.
Definition: InlineCost.h:141
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:198
llvm::InlineCost::isNever
bool isNever() const
Definition: InlineCost.h:130
llvm::InlineParams::OptMinSizeThreshold
Optional< int > OptMinSizeThreshold
Threshold to use when the caller is optimized for minsize.
Definition: InlineCost.h:204
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:217
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:2776
llvm::InlineCost
Represents the cost of inlining a function.
Definition: InlineCost.h:87
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::InlineResult::isSuccess
bool isSuccess() const
Definition: InlineCost.h:173
llvm::InlineCostAnnotationPrinterPass::run
PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM)
Definition: InlineCost.cpp:3083
STLFunctionalExtras.h
llvm::InlineCost::get
static InlineCost get(int Cost, int Threshold)
Definition: InlineCost.h:112
llvm::getInlineParams
InlineParams getInlineParams()
Generate the parameters to tune the inline cost analysis based only on the commandline options.
Definition: InlineCost.cpp:3054
llvm::InlineConstants::InstrCost
const int InstrCost
Definition: InlineCost.h:47
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::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:159
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::InlineCostAnnotationPrinterPass::OS
raw_ostream & OS
Definition: InlineCost.h:325
llvm::InlineParams::ColdCallSiteThreshold
Optional< int > ColdCallSiteThreshold
Threshold to use when the callsite is considered cold.
Definition: InlineCost.h:214
llvm::InlineCost::getNever
static InlineCost getNever(const char *Reason, Optional< CostBenefitPair > CostBenefit=None)
Definition: InlineCost.h:121
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:75
llvm::InlineCostAnnotationPrinterPass
Definition: InlineCost.h:323
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:150
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:174
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:2824
llvm::InlineParams::HintThreshold
Optional< int > HintThreshold
Threshold to use for callees with inline hint.
Definition: InlineCost.h:195
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:2811
llvm::InlineCost::getCostBenefit
Optional< CostBenefitPair > getCostBenefit() const
Get the cost-benefit pair which was computed by cost-benefit analysis.
Definition: InlineCost.h:147
llvm::CostBenefitPair::CostBenefitPair
CostBenefitPair(APInt Cost, APInt Benefit)
Definition: InlineCost.h:66
llvm::CostBenefitPair::getCost
const APInt & getCost() const
Definition: InlineCost.h:68
PassManager.h
llvm::TargetLibraryInfo
Provides information about what library functions are available for the current target.
Definition: TargetLibraryInfo.h:222
llvm::InlineResult::failure
static InlineResult failure(const char *Reason)
Definition: InlineCost.h:170
llvm::InlineConstants::OptMinSizeThreshold
const int OptMinSizeThreshold
Use when minsize (-Oz) is specified.
Definition: InlineCost.h:41
llvm::CostBenefitPair
Definition: InlineCost.h:64
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:2786
llvm::getCallsiteCost
int getCallsiteCost(CallBase &Call, const DataLayout &DL)
Return the cost associated with a callsite, including parameter passing and the call/return instructi...
Definition: InlineCost.cpp:2743
llvm::InlineConstants::LastCallToStaticBonus
const int LastCallToStaticBonus
Definition: InlineCost.h:50
llvm::CostBenefitPair::getBenefit
const APInt & getBenefit() const
Definition: InlineCost.h:70
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:131
InlineModelFeatureMaps.h
llvm::InlineParams::HotCallSiteThreshold
Optional< int > HotCallSiteThreshold
Threshold to use when the callsite is considered hot.
Definition: InlineCost.h:207
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:220
llvm::InlineParams::AllowRecursiveCall
Optional< bool > AllowRecursiveCall
Indicate whether we allow inlining for recursive call.
Definition: InlineCost.h:223
llvm::InlineConstants::LoopPenalty
const int LoopPenalty
Definition: InlineCost.h:49
llvm::InlineResult
InlineResult is basically true or false.
Definition: InlineCost.h:164
llvm::InlineParams::OptSizeThreshold
Optional< int > OptSizeThreshold
Threshold to use when the caller is optimized for size.
Definition: InlineCost.h:201
llvm::codeview::PublicSymFlags::Function
@ Function