LLVM 19.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
15namespace llvm {
16namespace yaml {
17
18template <> struct ScalarEnumerationTraits<TypeTestResolution::Kind> {
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
29template <> 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
40template <>
41struct ScalarEnumerationTraits<WholeProgramDevirtResolution::ByArg::Kind> {
42 static void enumeration(IO &io,
44 io.enumCase(value, "Indir", WholeProgramDevirtResolution::ByArg::Indir);
45 io.enumCase(value, "UniformRetVal",
46 WholeProgramDevirtResolution::ByArg::UniformRetVal);
47 io.enumCase(value, "UniqueRetVal",
48 WholeProgramDevirtResolution::ByArg::UniqueRetVal);
49 io.enumCase(value, "VirtualConstProp",
50 WholeProgramDevirtResolution::ByArg::VirtualConstProp);
51 }
52};
53
54template <> 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
63template <>
64struct 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
97template <> struct ScalarEnumerationTraits<WholeProgramDevirtResolution::Kind> {
99 io.enumCase(value, "Indir", WholeProgramDevirtResolution::Indir);
100 io.enumCase(value, "SingleImpl", WholeProgramDevirtResolution::SingleImpl);
101 io.enumCase(value, "BranchFunnel",
102 WholeProgramDevirtResolution::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
114template <>
115struct 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
131template <> 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
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
152namespace llvm {
153namespace yaml {
154
155template <> 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
162template <> 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
172LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummary::VFuncId)
173LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummary::ConstVCall)
174
175namespace llvm {
176namespace yaml {
177
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",
192 io.mapOptional("TypeCheckedLoadConstVCalls",
194 }
195};
196
197} // End yaml namespace
198} // End llvm namespace
199
200LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummaryYaml)
201
202namespace llvm {
203namespace yaml {
204
205// FIXME: Add YAML mappings for the rest of the module summary.
206template <> 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),
239 }
240 }
241 static void output(IO &io, GlobalValueSummaryMapTy &V) {
242 for (auto &P : V) {
243 std::vector<FunctionSummaryYaml> FSums;
244 for (auto &Sum : P.second.SummaryList) {
245 if (auto *FSum = dyn_cast<FunctionSummary>(Sum.get())) {
246 std::vector<uint64_t> Refs;
247 for (auto &VI : FSum->refs())
248 Refs.push_back(VI.getGUID());
249 FSums.push_back(FunctionSummaryYaml{
250 FSum->flags().Linkage, FSum->flags().Visibility,
251 static_cast<bool>(FSum->flags().NotEligibleToImport),
252 static_cast<bool>(FSum->flags().Live),
253 static_cast<bool>(FSum->flags().DSOLocal),
254 static_cast<bool>(FSum->flags().CanAutoHide), Refs,
255 FSum->type_tests(), FSum->type_test_assume_vcalls(),
256 FSum->type_checked_load_vcalls(),
257 FSum->type_test_assume_const_vcalls(),
258 FSum->type_checked_load_const_vcalls()});
259 }
260 }
261 if (!FSums.empty())
262 io.mapRequired(llvm::utostr(P.first).c_str(), FSums);
263 }
264 }
265};
266
267template <> struct CustomMappingTraits<TypeIdSummaryMapTy> {
268 static void inputOne(IO &io, StringRef Key, TypeIdSummaryMapTy &V) {
269 TypeIdSummary TId;
270 io.mapRequired(Key.str().c_str(), TId);
271 V.insert({GlobalValue::getGUID(Key), {std::string(Key), TId}});
272 }
273 static void output(IO &io, TypeIdSummaryMapTy &V) {
274 for (auto &TidIter : V)
275 io.mapRequired(TidIter.second.first.c_str(), TidIter.second.second);
276 }
277};
278
280 static void mapping(IO &io, ModuleSummaryIndex& index) {
281 io.mapOptional("GlobalValueMap", index.GlobalValueMap);
282 io.mapOptional("TypeIdMap", index.TypeIdMap);
283 io.mapOptional("WithGlobalValueDeadStripping",
284 index.WithGlobalValueDeadStripping);
285
286 if (io.outputting()) {
287 std::vector<std::string> CfiFunctionDefs(index.CfiFunctionDefs.begin(),
288 index.CfiFunctionDefs.end());
289 io.mapOptional("CfiFunctionDefs", CfiFunctionDefs);
290 std::vector<std::string> CfiFunctionDecls(index.CfiFunctionDecls.begin(),
291 index.CfiFunctionDecls.end());
292 io.mapOptional("CfiFunctionDecls", CfiFunctionDecls);
293 } else {
294 std::vector<std::string> CfiFunctionDefs;
295 io.mapOptional("CfiFunctionDefs", CfiFunctionDefs);
296 index.CfiFunctionDefs = {CfiFunctionDefs.begin(), CfiFunctionDefs.end()};
297 std::vector<std::string> CfiFunctionDecls;
298 io.mapOptional("CfiFunctionDecls", CfiFunctionDecls);
299 index.CfiFunctionDecls = {CfiFunctionDecls.begin(),
300 CfiFunctionDecls.end()};
301 }
302 }
303};
304
305} // End yaml namespace
306} // End llvm namespace
307
308#endif
Given that RA is a live value
ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...
#define P(N)
#define LLVM_YAML_IS_SEQUENCE_VECTOR(type)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
Function summary information to aid decisions and implementation of importing.
VisibilityTypes
An enumeration for the kinds of visibility of global values.
Definition: GlobalValue.h:66
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:51
Class to hold module path string table and global value map, and encapsulate methods for operating on...
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
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).
std::map< GlobalValue::GUID, GlobalValueSummaryInfo > GlobalValueSummaryMapTy
Map from global value GUID to corresponding summary structures.
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
A specification for a virtual function call with all constant integer arguments.
Flags specific to function summaries.
An "identifier" for a virtual function.
Group flags (Linkage, NotEligibleToImport, etc.) as a bitfield.
std::map< uint64_t, WholeProgramDevirtResolution > WPDRes
Mapping from byte offset to whole-program devirt resolution for that (typeid, byte offset) pair.
TypeTestResolution TTRes
Kind
Specifies which kind of type check we should emit for this byte array.
unsigned SizeM1BitWidth
Range of size-1 expressed as a bit width.
enum llvm::TypeTestResolution::Kind TheKind
Struct that holds a reference to a particular GUID in a global value summary.
uint64_t Info
Additional information for the resolution:
enum llvm::WholeProgramDevirtResolution::ByArg::Kind TheKind
enum llvm::WholeProgramDevirtResolution::Kind TheKind
std::map< std::vector< uint64_t >, ByArg > ResByArg
Resolutions for calls with all constant integer arguments (excluding the first argument,...
static void output(IO &io, GlobalValueSummaryMapTy &V)
static void inputOne(IO &io, StringRef Key, GlobalValueSummaryMapTy &V)
static void output(IO &io, TypeIdSummaryMapTy &V)
static void inputOne(IO &io, StringRef Key, TypeIdSummaryMapTy &V)
static void inputOne(IO &io, StringRef Key, std::map< std::vector< uint64_t >, WholeProgramDevirtResolution::ByArg > &V)
static void output(IO &io, std::map< std::vector< uint64_t >, WholeProgramDevirtResolution::ByArg > &V)
static void inputOne(IO &io, StringRef Key, std::map< uint64_t, WholeProgramDevirtResolution > &V)
static void output(IO &io, std::map< uint64_t, WholeProgramDevirtResolution > &V)
std::vector< FunctionSummary::ConstVCall > TypeTestAssumeConstVCalls
std::vector< FunctionSummary::VFuncId > TypeCheckedLoadVCalls
std::vector< FunctionSummary::ConstVCall > TypeCheckedLoadConstVCalls
std::vector< FunctionSummary::VFuncId > TypeTestAssumeVCalls
static void mapping(IO &io, FunctionSummaryYaml &summary)
static void mapping(IO &io, FunctionSummary::ConstVCall &id)
static void mapping(IO &io, FunctionSummary::VFuncId &id)
static void mapping(IO &io, ModuleSummaryIndex &index)
static void mapping(IO &io, TypeIdSummary &summary)
static void mapping(IO &io, TypeTestResolution &res)
static void mapping(IO &io, WholeProgramDevirtResolution &res)
static void mapping(IO &io, WholeProgramDevirtResolution::ByArg &res)
static void enumeration(IO &io, TypeTestResolution::Kind &value)
static void enumeration(IO &io, WholeProgramDevirtResolution::ByArg::Kind &value)
static void enumeration(IO &io, WholeProgramDevirtResolution::Kind &value)