LLVM  14.0.0git
ModuleSummaryIndexYAML.h
Go to the documentation of this file.
1 //===-- llvm/ModuleSummaryIndexYAML.h - YAML I/O for summary ----*- 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_IR_MODULESUMMARYINDEXYAML_H
10 #define LLVM_IR_MODULESUMMARYINDEXYAML_H
11 
14 
15 namespace llvm {
16 namespace yaml {
17 
18 template <> struct ScalarEnumerationTraits<TypeTestResolution::Kind> {
19  static void enumeration(IO &io, TypeTestResolution::Kind &value) {
20  io.enumCase(value, "Unknown", TypeTestResolution::Unknown);
21  io.enumCase(value, "Unsat", TypeTestResolution::Unsat);
22  io.enumCase(value, "ByteArray", TypeTestResolution::ByteArray);
23  io.enumCase(value, "Inline", TypeTestResolution::Inline);
24  io.enumCase(value, "Single", TypeTestResolution::Single);
25  io.enumCase(value, "AllOnes", TypeTestResolution::AllOnes);
26  }
27 };
28 
29 template <> struct MappingTraits<TypeTestResolution> {
30  static void mapping(IO &io, TypeTestResolution &res) {
31  io.mapOptional("Kind", res.TheKind);
32  io.mapOptional("SizeM1BitWidth", res.SizeM1BitWidth);
33  io.mapOptional("AlignLog2", res.AlignLog2);
34  io.mapOptional("SizeM1", res.SizeM1);
35  io.mapOptional("BitMask", res.BitMask);
36  io.mapOptional("InlineBits", res.InlineBits);
37  }
38 };
39 
40 template <>
41 struct ScalarEnumerationTraits<WholeProgramDevirtResolution::ByArg::Kind> {
42  static void enumeration(IO &io,
44  io.enumCase(value, "Indir", WholeProgramDevirtResolution::ByArg::Indir);
45  io.enumCase(value, "UniformRetVal",
47  io.enumCase(value, "UniqueRetVal",
49  io.enumCase(value, "VirtualConstProp",
51  }
52 };
53 
54 template <> struct MappingTraits<WholeProgramDevirtResolution::ByArg> {
55  static void mapping(IO &io, WholeProgramDevirtResolution::ByArg &res) {
56  io.mapOptional("Kind", res.TheKind);
57  io.mapOptional("Info", res.Info);
58  io.mapOptional("Byte", res.Byte);
59  io.mapOptional("Bit", res.Bit);
60  }
61 };
62 
63 template <>
64 struct CustomMappingTraits<
65  std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg>> {
66  static void inputOne(
67  IO &io, StringRef Key,
68  std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg> &V) {
69  std::vector<uint64_t> Args;
70  std::pair<StringRef, StringRef> P = {"", Key};
71  while (!P.second.empty()) {
72  P = P.second.split(',');
73  uint64_t Arg;
74  if (P.first.getAsInteger(0, Arg)) {
75  io.setError("key not an integer");
76  return;
77  }
78  Args.push_back(Arg);
79  }
80  io.mapRequired(Key.str().c_str(), V[Args]);
81  }
82  static void output(
83  IO &io,
84  std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg> &V) {
85  for (auto &P : V) {
86  std::string Key;
87  for (uint64_t Arg : P.first) {
88  if (!Key.empty())
89  Key += ',';
90  Key += llvm::utostr(Arg);
91  }
92  io.mapRequired(Key.c_str(), P.second);
93  }
94  }
95 };
96 
97 template <> struct ScalarEnumerationTraits<WholeProgramDevirtResolution::Kind> {
98  static void enumeration(IO &io, WholeProgramDevirtResolution::Kind &value) {
99  io.enumCase(value, "Indir", WholeProgramDevirtResolution::Indir);
100  io.enumCase(value, "SingleImpl", WholeProgramDevirtResolution::SingleImpl);
101  io.enumCase(value, "BranchFunnel",
103  }
104 };
105 
107  static void mapping(IO &io, WholeProgramDevirtResolution &res) {
108  io.mapOptional("Kind", res.TheKind);
109  io.mapOptional("SingleImplName", res.SingleImplName);
110  io.mapOptional("ResByArg", res.ResByArg);
111  }
112 };
113 
114 template <>
115 struct CustomMappingTraits<std::map<uint64_t, WholeProgramDevirtResolution>> {
116  static void inputOne(IO &io, StringRef Key,
117  std::map<uint64_t, WholeProgramDevirtResolution> &V) {
118  uint64_t KeyInt;
119  if (Key.getAsInteger(0, KeyInt)) {
120  io.setError("key not an integer");
121  return;
122  }
123  io.mapRequired(Key.str().c_str(), V[KeyInt]);
124  }
125  static void output(IO &io, std::map<uint64_t, WholeProgramDevirtResolution> &V) {
126  for (auto &P : V)
127  io.mapRequired(llvm::utostr(P.first).c_str(), P.second);
128  }
129 };
130 
131 template <> struct MappingTraits<TypeIdSummary> {
132  static void mapping(IO &io, TypeIdSummary& summary) {
133  io.mapOptional("TTRes", summary.TTRes);
134  io.mapOptional("WPDRes", summary.WPDRes);
135  }
136 };
137 
139  unsigned Linkage, Visibility;
141  std::vector<uint64_t> Refs;
142  std::vector<uint64_t> TypeTests;
143  std::vector<FunctionSummary::VFuncId> TypeTestAssumeVCalls,
145  std::vector<FunctionSummary::ConstVCall> TypeTestAssumeConstVCalls,
147 };
148 
149 } // End yaml namespace
150 } // End llvm namespace
151 
152 namespace llvm {
153 namespace yaml {
154 
155 template <> struct MappingTraits<FunctionSummary::VFuncId> {
156  static void mapping(IO &io, FunctionSummary::VFuncId& id) {
157  io.mapOptional("GUID", id.GUID);
158  io.mapOptional("Offset", id.Offset);
159  }
160 };
161 
162 template <> struct MappingTraits<FunctionSummary::ConstVCall> {
163  static void mapping(IO &io, FunctionSummary::ConstVCall& id) {
164  io.mapOptional("VFunc", id.VFunc);
165  io.mapOptional("Args", id.Args);
166  }
167 };
168 
169 } // End yaml namespace
170 } // End llvm namespace
171 
172 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummary::VFuncId)
173 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummary::ConstVCall)
174 
175 namespace llvm {
176 namespace yaml {
177 
178 template <> struct MappingTraits<FunctionSummaryYaml> {
179  static void mapping(IO &io, FunctionSummaryYaml& summary) {
180  io.mapOptional("Linkage", summary.Linkage);
181  io.mapOptional("Visibility", summary.Visibility);
182  io.mapOptional("NotEligibleToImport", summary.NotEligibleToImport);
183  io.mapOptional("Live", summary.Live);
184  io.mapOptional("Local", summary.IsLocal);
185  io.mapOptional("CanAutoHide", summary.CanAutoHide);
186  io.mapOptional("Refs", summary.Refs);
187  io.mapOptional("TypeTests", summary.TypeTests);
188  io.mapOptional("TypeTestAssumeVCalls", summary.TypeTestAssumeVCalls);
189  io.mapOptional("TypeCheckedLoadVCalls", summary.TypeCheckedLoadVCalls);
190  io.mapOptional("TypeTestAssumeConstVCalls",
191  summary.TypeTestAssumeConstVCalls);
192  io.mapOptional("TypeCheckedLoadConstVCalls",
194  }
195 };
196 
197 } // End yaml namespace
198 } // End llvm namespace
199 
200 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummaryYaml)
201 
202 namespace llvm {
203 namespace yaml {
204 
205 // FIXME: Add YAML mappings for the rest of the module summary.
206 template <> struct CustomMappingTraits<GlobalValueSummaryMapTy> {
207  static void inputOne(IO &io, StringRef Key, GlobalValueSummaryMapTy &V) {
208  std::vector<FunctionSummaryYaml> FSums;
209  io.mapRequired(Key.str().c_str(), FSums);
210  uint64_t KeyInt;
211  if (Key.getAsInteger(0, KeyInt)) {
212  io.setError("key not an integer");
213  return;
214  }
215  if (!V.count(KeyInt))
216  V.emplace(KeyInt, /*IsAnalysis=*/false);
217  auto &Elem = V.find(KeyInt)->second;
218  for (auto &FSum : FSums) {
219  std::vector<ValueInfo> Refs;
220  for (auto &RefGUID : FSum.Refs) {
221  if (!V.count(RefGUID))
222  V.emplace(RefGUID, /*IsAnalysis=*/false);
223  Refs.push_back(ValueInfo(/*IsAnalysis=*/false, &*V.find(RefGUID)));
224  }
225  Elem.SummaryList.push_back(std::make_unique<FunctionSummary>(
227  static_cast<GlobalValue::LinkageTypes>(FSum.Linkage),
228  static_cast<GlobalValue::VisibilityTypes>(FSum.Visibility),
229  FSum.NotEligibleToImport, FSum.Live, FSum.IsLocal,
230  FSum.CanAutoHide),
231  /*NumInsts=*/0, FunctionSummary::FFlags{}, /*EntryCount=*/0, Refs,
232  ArrayRef<FunctionSummary::EdgeTy>{}, std::move(FSum.TypeTests),
233  std::move(FSum.TypeTestAssumeVCalls),
234  std::move(FSum.TypeCheckedLoadVCalls),
235  std::move(FSum.TypeTestAssumeConstVCalls),
236  std::move(FSum.TypeCheckedLoadConstVCalls),
238  }
239  }
240  static void output(IO &io, GlobalValueSummaryMapTy &V) {
241  for (auto &P : V) {
242  std::vector<FunctionSummaryYaml> FSums;
243  for (auto &Sum : P.second.SummaryList) {
244  if (auto *FSum = dyn_cast<FunctionSummary>(Sum.get())) {
245  std::vector<uint64_t> Refs;
246  for (auto &VI : FSum->refs())
247  Refs.push_back(VI.getGUID());
248  FSums.push_back(FunctionSummaryYaml{
249  FSum->flags().Linkage, FSum->flags().Visibility,
250  static_cast<bool>(FSum->flags().NotEligibleToImport),
251  static_cast<bool>(FSum->flags().Live),
252  static_cast<bool>(FSum->flags().DSOLocal),
253  static_cast<bool>(FSum->flags().CanAutoHide), Refs,
254  FSum->type_tests(), FSum->type_test_assume_vcalls(),
255  FSum->type_checked_load_vcalls(),
256  FSum->type_test_assume_const_vcalls(),
257  FSum->type_checked_load_const_vcalls()});
258  }
259  }
260  if (!FSums.empty())
261  io.mapRequired(llvm::utostr(P.first).c_str(), FSums);
262  }
263  }
264 };
265 
266 template <> struct CustomMappingTraits<TypeIdSummaryMapTy> {
267  static void inputOne(IO &io, StringRef Key, TypeIdSummaryMapTy &V) {
268  TypeIdSummary TId;
269  io.mapRequired(Key.str().c_str(), TId);
270  V.insert({GlobalValue::getGUID(Key), {std::string(Key), TId}});
271  }
272  static void output(IO &io, TypeIdSummaryMapTy &V) {
273  for (auto TidIter = V.begin(); TidIter != V.end(); TidIter++)
274  io.mapRequired(TidIter->second.first.c_str(), TidIter->second.second);
275  }
276 };
277 
278 template <> struct MappingTraits<ModuleSummaryIndex> {
279  static void mapping(IO &io, ModuleSummaryIndex& index) {
280  io.mapOptional("GlobalValueMap", index.GlobalValueMap);
281  io.mapOptional("TypeIdMap", index.TypeIdMap);
282  io.mapOptional("WithGlobalValueDeadStripping",
283  index.WithGlobalValueDeadStripping);
284 
285  if (io.outputting()) {
286  std::vector<std::string> CfiFunctionDefs(index.CfiFunctionDefs.begin(),
287  index.CfiFunctionDefs.end());
288  io.mapOptional("CfiFunctionDefs", CfiFunctionDefs);
289  std::vector<std::string> CfiFunctionDecls(index.CfiFunctionDecls.begin(),
290  index.CfiFunctionDecls.end());
291  io.mapOptional("CfiFunctionDecls", CfiFunctionDecls);
292  } else {
293  std::vector<std::string> CfiFunctionDefs;
294  io.mapOptional("CfiFunctionDefs", CfiFunctionDefs);
295  index.CfiFunctionDefs = {CfiFunctionDefs.begin(), CfiFunctionDefs.end()};
296  std::vector<std::string> CfiFunctionDecls;
297  io.mapOptional("CfiFunctionDecls", CfiFunctionDecls);
298  index.CfiFunctionDecls = {CfiFunctionDecls.begin(),
299  CfiFunctionDecls.end()};
300  }
301  }
302 };
303 
304 } // End yaml namespace
305 } // End llvm namespace
306 
307 #endif
llvm::WholeProgramDevirtResolution::ResByArg
std::map< std::vector< uint64_t >, ByArg > ResByArg
Resolutions for calls with all constant integer arguments (excluding the first argument,...
Definition: ModuleSummaryIndex.h:973
llvm::yaml::MappingTraits< FunctionSummaryYaml >::mapping
static void mapping(IO &io, FunctionSummaryYaml &summary)
Definition: ModuleSummaryIndexYAML.h:179
llvm::yaml::MappingTraits< TypeTestResolution >::mapping
static void mapping(IO &io, TypeTestResolution &res)
Definition: ModuleSummaryIndexYAML.h:30
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::WholeProgramDevirtResolution::ByArg::TheKind
enum llvm::WholeProgramDevirtResolution::ByArg::Kind TheKind
llvm::GlobalValueSummaryMapTy
std::map< GlobalValue::GUID, GlobalValueSummaryInfo > GlobalValueSummaryMapTy
Map from global value GUID to corresponding summary structures.
Definition: ModuleSummaryIndex.h:164
llvm::yaml::CustomMappingTraits< std::map< std::vector< uint64_t >, WholeProgramDevirtResolution::ByArg > >::inputOne
static void inputOne(IO &io, StringRef Key, std::map< std::vector< uint64_t >, WholeProgramDevirtResolution::ByArg > &V)
Definition: ModuleSummaryIndexYAML.h:66
llvm::TypeTestResolution::Kind
Kind
Specifies which kind of type check we should emit for this byte array.
Definition: ModuleSummaryIndex.h:913
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::yaml::CustomMappingTraits< std::map< uint64_t, WholeProgramDevirtResolution > >::output
static void output(IO &io, std::map< uint64_t, WholeProgramDevirtResolution > &V)
Definition: ModuleSummaryIndexYAML.h:125
llvm::TypeTestResolution::InlineBits
uint64_t InlineBits
Definition: ModuleSummaryIndex.h:936
llvm::TypeTestResolution::Unsat
@ Unsat
Unsatisfiable type (i.e. no global has this type metadata)
Definition: ModuleSummaryIndex.h:914
llvm::yaml::FunctionSummaryYaml::Linkage
unsigned Linkage
Definition: ModuleSummaryIndexYAML.h:139
LLVM_YAML_IS_SEQUENCE_VECTOR
#define LLVM_YAML_IS_SEQUENCE_VECTOR(type)
llvm::TypeTestResolution::AllOnes
@ AllOnes
All-ones bit vector ("Eliminating Bit Vector Checks for All-Ones Bit Vectors")
Definition: ModuleSummaryIndex.h:918
llvm::yaml::MappingTraits< WholeProgramDevirtResolution::ByArg >::mapping
static void mapping(IO &io, WholeProgramDevirtResolution::ByArg &res)
Definition: ModuleSummaryIndexYAML.h:55
llvm::yaml::MappingTraits< WholeProgramDevirtResolution >::mapping
static void mapping(IO &io, WholeProgramDevirtResolution &res)
Definition: ModuleSummaryIndexYAML.h:107
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::GlobalValue::LinkageTypes
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:47
llvm::yaml::MappingTraits
Definition: ModuleSummaryIndex.h:52
ModuleSummaryIndex.h
llvm::yaml::FunctionSummaryYaml::TypeTests
std::vector< uint64_t > TypeTests
Definition: ModuleSummaryIndexYAML.h:142
llvm::GlobalValueSummary::GVFlags
Group flags (Linkage, NotEligibleToImport, etc.) as a bitfield.
Definition: ModuleSummaryIndex.h:296
llvm::FunctionSummary::ConstVCall
A specification for a virtual function call with all constant integer arguments.
Definition: ModuleSummaryIndex.h:537
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:206
llvm::yaml::FunctionSummaryYaml::Visibility
unsigned Visibility
Definition: ModuleSummaryIndexYAML.h:139
llvm::yaml::MappingTraits< FunctionSummary::VFuncId >::mapping
static void mapping(IO &io, FunctionSummary::VFuncId &id)
Definition: ModuleSummaryIndexYAML.h:156
llvm::GlobalValue::VisibilityTypes
VisibilityTypes
An enumeration for the kinds of visibility of global values.
Definition: GlobalValue.h:62
llvm::yaml::FunctionSummaryYaml::Live
bool Live
Definition: ModuleSummaryIndexYAML.h:140
llvm::WholeProgramDevirtResolution::ByArg::Kind
Kind
Definition: ModuleSummaryIndex.h:951
llvm::AMDGPU::PALMD::Key
Key
PAL metadata keys.
Definition: AMDGPUMetadata.h:481
llvm::WholeProgramDevirtResolution::ByArg::Byte
uint32_t Byte
Definition: ModuleSummaryIndex.h:967
llvm::WholeProgramDevirtResolution::Kind
Kind
Definition: ModuleSummaryIndex.h:940
llvm::WholeProgramDevirtResolution::BranchFunnel
@ BranchFunnel
When retpoline mitigation is enabled, use a branch funnel that is defined in the merged module.
Definition: ModuleSummaryIndex.h:943
llvm::TypeTestResolution::BitMask
uint8_t BitMask
Definition: ModuleSummaryIndex.h:935
llvm::TypeTestResolution::Inline
@ Inline
Inlined bit vector ("Short Inline Bit Vectors")
Definition: ModuleSummaryIndex.h:916
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::WholeProgramDevirtResolution::SingleImpl
@ SingleImpl
Single implementation devirtualization.
Definition: ModuleSummaryIndex.h:942
llvm::ValueInfo
Struct that holds a reference to a particular GUID in a global value summary.
Definition: ModuleSummaryIndex.h:168
llvm::TypeTestResolution::AlignLog2
uint64_t AlignLog2
Definition: ModuleSummaryIndex.h:933
llvm::WholeProgramDevirtResolution::SingleImplName
std::string SingleImplName
Definition: ModuleSummaryIndex.h:948
llvm::TypeTestResolution::Single
@ Single
Single element (last example in "Short Inline Bit Vectors")
Definition: ModuleSummaryIndex.h:917
llvm::WholeProgramDevirtResolution::ByArg::UniformRetVal
@ UniformRetVal
Uniform return value optimization.
Definition: ModuleSummaryIndex.h:953
llvm::FunctionSummary::VFuncId
An "identifier" for a virtual function.
Definition: ModuleSummaryIndex.h:529
llvm::yaml::CustomMappingTraits< std::map< std::vector< uint64_t >, WholeProgramDevirtResolution::ByArg > >::output
static void output(IO &io, std::map< std::vector< uint64_t >, WholeProgramDevirtResolution::ByArg > &V)
Definition: ModuleSummaryIndexYAML.h:82
VI
@ VI
Definition: SIInstrInfo.cpp:7679
llvm::WholeProgramDevirtResolution::ByArg::Indir
@ Indir
Just do a regular virtual call.
Definition: ModuleSummaryIndex.h:952
llvm::WholeProgramDevirtResolution::Indir
@ Indir
Just do a regular virtual call.
Definition: ModuleSummaryIndex.h:941
index
splat index
Definition: README_ALTIVEC.txt:181
uint64_t
llvm::yaml::FunctionSummaryYaml::TypeTestAssumeConstVCalls
std::vector< FunctionSummary::ConstVCall > TypeTestAssumeConstVCalls
Definition: ModuleSummaryIndexYAML.h:145
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::WholeProgramDevirtResolution::ByArg::UniqueRetVal
@ UniqueRetVal
Unique return value optimization.
Definition: ModuleSummaryIndex.h:954
llvm::TypeIdSummary
Definition: ModuleSummaryIndex.h:976
llvm::yaml::MappingTraits< TypeIdSummary >::mapping
static void mapping(IO &io, TypeIdSummary &summary)
Definition: ModuleSummaryIndexYAML.h:132
llvm::yaml::FunctionSummaryYaml::TypeCheckedLoadVCalls
std::vector< FunctionSummary::VFuncId > TypeCheckedLoadVCalls
Definition: ModuleSummaryIndexYAML.h:144
llvm::yaml::CustomMappingTraits< std::map< uint64_t, WholeProgramDevirtResolution > >::inputOne
static void inputOne(IO &io, StringRef Key, std::map< uint64_t, WholeProgramDevirtResolution > &V)
Definition: ModuleSummaryIndexYAML.h:116
llvm::FunctionSummary::FFlags
Flags specific to function summaries.
Definition: ModuleSummaryIndex.h:563
llvm::yaml::FunctionSummaryYaml
Definition: ModuleSummaryIndexYAML.h:138
YAMLTraits.h
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::yaml::FunctionSummaryYaml::Refs
std::vector< uint64_t > Refs
Definition: ModuleSummaryIndexYAML.h:141
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::yaml::ScalarEnumerationTraits< WholeProgramDevirtResolution::Kind >::enumeration
static void enumeration(IO &io, WholeProgramDevirtResolution::Kind &value)
Definition: ModuleSummaryIndexYAML.h:98
llvm::yaml::FunctionSummaryYaml::TypeCheckedLoadConstVCalls
std::vector< FunctionSummary::ConstVCall > TypeCheckedLoadConstVCalls
Definition: ModuleSummaryIndexYAML.h:146
llvm::TypeTestResolution
Definition: ModuleSummaryIndex.h:908
llvm::TypeTestResolution::TheKind
enum llvm::TypeTestResolution::Kind TheKind
llvm::TypeTestResolution::Unknown
@ Unknown
Unknown (analysis not performed, don't lower)
Definition: ModuleSummaryIndex.h:920
llvm::yaml::FunctionSummaryYaml::IsLocal
bool IsLocal
Definition: ModuleSummaryIndexYAML.h:140
llvm::yaml::FunctionSummaryYaml::CanAutoHide
bool CanAutoHide
Definition: ModuleSummaryIndexYAML.h:140
llvm::WholeProgramDevirtResolution::ByArg
Definition: ModuleSummaryIndex.h:950
llvm::FunctionSummary
Function summary information to aid decisions and implementation of importing.
Definition: ModuleSummaryIndex.h:513
llvm::TypeTestResolution::SizeM1
uint64_t SizeM1
Definition: ModuleSummaryIndex.h:934
std
Definition: BitVector.h:838
llvm::yaml::MappingTraits< ModuleSummaryIndex >::mapping
static void mapping(IO &io, ModuleSummaryIndex &index)
Definition: ModuleSummaryIndexYAML.h:279
llvm::GlobalValue::getGUID
GUID getGUID() const
Return a 64-bit global unique ID constructed from global value name (i.e.
Definition: GlobalValue.h:511
llvm::WholeProgramDevirtResolution::ByArg::Info
uint64_t Info
Additional information for the resolution:
Definition: ModuleSummaryIndex.h:962
llvm::WholeProgramDevirtResolution::ByArg::VirtualConstProp
@ VirtualConstProp
Virtual constant propagation.
Definition: ModuleSummaryIndex.h:955
llvm::TypeIdSummary::WPDRes
std::map< uint64_t, WholeProgramDevirtResolution > WPDRes
Mapping from byte offset to whole-program devirt resolution for that (typeid, byte offset) pair.
Definition: ModuleSummaryIndex.h:981
llvm::WholeProgramDevirtResolution::TheKind
enum llvm::WholeProgramDevirtResolution::Kind TheKind
llvm::TypeIdSummary::TTRes
TypeTestResolution TTRes
Definition: ModuleSummaryIndex.h:977
llvm::ModuleSummaryIndex
Class to hold module path string table and global value map, and encapsulate methods for operating on...
Definition: ModuleSummaryIndex.h:1030
llvm::yaml::FunctionSummaryYaml::TypeTestAssumeVCalls
std::vector< FunctionSummary::VFuncId > TypeTestAssumeVCalls
Definition: ModuleSummaryIndexYAML.h:143
llvm::yaml::ScalarEnumerationTraits< WholeProgramDevirtResolution::ByArg::Kind >::enumeration
static void enumeration(IO &io, WholeProgramDevirtResolution::ByArg::Kind &value)
Definition: ModuleSummaryIndexYAML.h:42
llvm::yaml::FunctionSummaryYaml::NotEligibleToImport
bool NotEligibleToImport
Definition: ModuleSummaryIndexYAML.h:140
llvm::yaml::ScalarEnumerationTraits< TypeTestResolution::Kind >::enumeration
static void enumeration(IO &io, TypeTestResolution::Kind &value)
Definition: ModuleSummaryIndexYAML.h:19
llvm::WholeProgramDevirtResolution
Definition: ModuleSummaryIndex.h:939
llvm::yaml::CustomMappingTraits< TypeIdSummaryMapTy >::output
static void output(IO &io, TypeIdSummaryMapTy &V)
Definition: ModuleSummaryIndexYAML.h:272
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:389
llvm::TypeTestResolution::ByteArray
@ ByteArray
Test a byte array (first example)
Definition: ModuleSummaryIndex.h:915
llvm::TypeIdSummaryMapTy
std::multimap< GlobalValue::GUID, std::pair< std::string, TypeIdSummary > > TypeIdSummaryMapTy
Map of a type GUID to type id string and summary (multimap used in case of GUID conflicts).
Definition: ModuleSummaryIndex.h:1003
llvm::WholeProgramDevirtResolution::ByArg::Bit
uint32_t Bit
Definition: ModuleSummaryIndex.h:968
llvm::yaml::CustomMappingTraits< TypeIdSummaryMapTy >::inputOne
static void inputOne(IO &io, StringRef Key, TypeIdSummaryMapTy &V)
Definition: ModuleSummaryIndexYAML.h:267
llvm::yaml::MappingTraits< FunctionSummary::ConstVCall >::mapping
static void mapping(IO &io, FunctionSummary::ConstVCall &id)
Definition: ModuleSummaryIndexYAML.h:163
llvm::TypeTestResolution::SizeM1BitWidth
unsigned SizeM1BitWidth
Range of size-1 expressed as a bit width.
Definition: ModuleSummaryIndex.h:926
llvm::yaml::CustomMappingTraits< GlobalValueSummaryMapTy >::inputOne
static void inputOne(IO &io, StringRef Key, GlobalValueSummaryMapTy &V)
Definition: ModuleSummaryIndexYAML.h:207
llvm::yaml::CustomMappingTraits< GlobalValueSummaryMapTy >::output
static void output(IO &io, GlobalValueSummaryMapTy &V)
Definition: ModuleSummaryIndexYAML.h:240