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 | |
12 | #include "llvm/IR/ModuleSummaryIndex.h" |
13 | #include "llvm/Support/YAMLTraits.h" |
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(Val&: value, Str: "Unknown" , ConstVal: TypeTestResolution::Unknown); |
21 | io.enumCase(Val&: value, Str: "Unsat" , ConstVal: TypeTestResolution::Unsat); |
22 | io.enumCase(Val&: value, Str: "ByteArray" , ConstVal: TypeTestResolution::ByteArray); |
23 | io.enumCase(Val&: value, Str: "Inline" , ConstVal: TypeTestResolution::Inline); |
24 | io.enumCase(Val&: value, Str: "Single" , ConstVal: TypeTestResolution::Single); |
25 | io.enumCase(Val&: value, Str: "AllOnes" , ConstVal: TypeTestResolution::AllOnes); |
26 | } |
27 | }; |
28 | |
29 | template <> struct MappingTraits<TypeTestResolution> { |
30 | static void mapping(IO &io, TypeTestResolution &res) { |
31 | io.mapOptional(Key: "Kind" , Val&: res.TheKind); |
32 | io.mapOptional(Key: "SizeM1BitWidth" , Val&: res.SizeM1BitWidth); |
33 | io.mapOptional(Key: "AlignLog2" , Val&: res.AlignLog2); |
34 | io.mapOptional(Key: "SizeM1" , Val&: res.SizeM1); |
35 | io.mapOptional(Key: "BitMask" , Val&: res.BitMask); |
36 | io.mapOptional(Key: "InlineBits" , Val&: res.InlineBits); |
37 | } |
38 | }; |
39 | |
40 | template <> |
41 | struct ScalarEnumerationTraits<WholeProgramDevirtResolution::ByArg::Kind> { |
42 | static void enumeration(IO &io, |
43 | WholeProgramDevirtResolution::ByArg::Kind &value) { |
44 | io.enumCase(Val&: value, Str: "Indir" , ConstVal: WholeProgramDevirtResolution::ByArg::Indir); |
45 | io.enumCase(Val&: value, Str: "UniformRetVal" , |
46 | ConstVal: WholeProgramDevirtResolution::ByArg::UniformRetVal); |
47 | io.enumCase(Val&: value, Str: "UniqueRetVal" , |
48 | ConstVal: WholeProgramDevirtResolution::ByArg::UniqueRetVal); |
49 | io.enumCase(Val&: value, Str: "VirtualConstProp" , |
50 | ConstVal: WholeProgramDevirtResolution::ByArg::VirtualConstProp); |
51 | } |
52 | }; |
53 | |
54 | template <> struct MappingTraits<WholeProgramDevirtResolution::ByArg> { |
55 | static void mapping(IO &io, WholeProgramDevirtResolution::ByArg &res) { |
56 | io.mapOptional(Key: "Kind" , Val&: res.TheKind); |
57 | io.mapOptional(Key: "Info" , Val&: res.Info); |
58 | io.mapOptional(Key: "Byte" , Val&: res.Byte); |
59 | io.mapOptional(Key: "Bit" , Val&: 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(Separator: ','); |
73 | uint64_t Arg; |
74 | if (P.first.getAsInteger(Radix: 0, Result&: Arg)) { |
75 | io.setError("key not an integer" ); |
76 | return; |
77 | } |
78 | Args.push_back(x: Arg); |
79 | } |
80 | io.mapRequired(Key: Key.str().c_str(), Val&: 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(X: Arg); |
91 | } |
92 | io.mapRequired(Key: Key.c_str(), Val&: P.second); |
93 | } |
94 | } |
95 | }; |
96 | |
97 | template <> struct ScalarEnumerationTraits<WholeProgramDevirtResolution::Kind> { |
98 | static void enumeration(IO &io, WholeProgramDevirtResolution::Kind &value) { |
99 | io.enumCase(Val&: value, Str: "Indir" , ConstVal: WholeProgramDevirtResolution::Indir); |
100 | io.enumCase(Val&: value, Str: "SingleImpl" , ConstVal: WholeProgramDevirtResolution::SingleImpl); |
101 | io.enumCase(Val&: value, Str: "BranchFunnel" , |
102 | ConstVal: WholeProgramDevirtResolution::BranchFunnel); |
103 | } |
104 | }; |
105 | |
106 | template <> struct MappingTraits<WholeProgramDevirtResolution> { |
107 | static void mapping(IO &io, WholeProgramDevirtResolution &res) { |
108 | io.mapOptional(Key: "Kind" , Val&: res.TheKind); |
109 | io.mapOptional(Key: "SingleImplName" , Val&: res.SingleImplName); |
110 | io.mapOptional(Key: "ResByArg" , Val&: 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(Radix: 0, Result&: KeyInt)) { |
120 | io.setError("key not an integer" ); |
121 | return; |
122 | } |
123 | io.mapRequired(Key: Key.str().c_str(), Val&: V[KeyInt]); |
124 | } |
125 | static void output(IO &io, std::map<uint64_t, WholeProgramDevirtResolution> &V) { |
126 | for (auto &P : V) |
127 | io.mapRequired(Key: llvm::utostr(X: P.first).c_str(), Val&: P.second); |
128 | } |
129 | }; |
130 | |
131 | template <> struct MappingTraits<TypeIdSummary> { |
132 | static void mapping(IO &io, TypeIdSummary& summary) { |
133 | io.mapOptional(Key: "TTRes" , Val&: summary.TTRes); |
134 | io.mapOptional(Key: "WPDRes" , Val&: summary.WPDRes); |
135 | } |
136 | }; |
137 | |
138 | struct FunctionSummaryYaml { |
139 | unsigned Linkage, Visibility; |
140 | bool NotEligibleToImport, Live, IsLocal, CanAutoHide; |
141 | std::vector<uint64_t> Refs; |
142 | std::vector<uint64_t> TypeTests; |
143 | std::vector<FunctionSummary::VFuncId> TypeTestAssumeVCalls, |
144 | TypeCheckedLoadVCalls; |
145 | std::vector<FunctionSummary::ConstVCall> TypeTestAssumeConstVCalls, |
146 | TypeCheckedLoadConstVCalls; |
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(Key: "GUID" , Val&: id.GUID); |
158 | io.mapOptional(Key: "Offset" , Val&: id.Offset); |
159 | } |
160 | }; |
161 | |
162 | template <> struct MappingTraits<FunctionSummary::ConstVCall> { |
163 | static void mapping(IO &io, FunctionSummary::ConstVCall& id) { |
164 | io.mapOptional(Key: "VFunc" , Val&: id.VFunc); |
165 | io.mapOptional(Key: "Args" , Val&: 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(Key: "Linkage" , Val&: summary.Linkage); |
181 | io.mapOptional(Key: "Visibility" , Val&: summary.Visibility); |
182 | io.mapOptional(Key: "NotEligibleToImport" , Val&: summary.NotEligibleToImport); |
183 | io.mapOptional(Key: "Live" , Val&: summary.Live); |
184 | io.mapOptional(Key: "Local" , Val&: summary.IsLocal); |
185 | io.mapOptional(Key: "CanAutoHide" , Val&: summary.CanAutoHide); |
186 | io.mapOptional(Key: "Refs" , Val&: summary.Refs); |
187 | io.mapOptional(Key: "TypeTests" , Val&: summary.TypeTests); |
188 | io.mapOptional(Key: "TypeTestAssumeVCalls" , Val&: summary.TypeTestAssumeVCalls); |
189 | io.mapOptional(Key: "TypeCheckedLoadVCalls" , Val&: summary.TypeCheckedLoadVCalls); |
190 | io.mapOptional(Key: "TypeTestAssumeConstVCalls" , |
191 | Val&: summary.TypeTestAssumeConstVCalls); |
192 | io.mapOptional(Key: "TypeCheckedLoadConstVCalls" , |
193 | Val&: summary.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: Key.str().c_str(), Val&: FSums); |
210 | uint64_t KeyInt; |
211 | if (Key.getAsInteger(Radix: 0, Result&: KeyInt)) { |
212 | io.setError("key not an integer" ); |
213 | return; |
214 | } |
215 | if (!V.count(x: KeyInt)) |
216 | V.emplace(args&: KeyInt, /*IsAnalysis=*/args: false); |
217 | auto &Elem = V.find(x: KeyInt)->second; |
218 | for (auto &FSum : FSums) { |
219 | std::vector<ValueInfo> Refs; |
220 | for (auto &RefGUID : FSum.Refs) { |
221 | if (!V.count(x: RefGUID)) |
222 | V.emplace(args&: RefGUID, /*IsAnalysis=*/args: false); |
223 | Refs.push_back(x: ValueInfo(/*IsAnalysis=*/false, &*V.find(x: RefGUID))); |
224 | } |
225 | Elem.SummaryList.push_back(x: std::make_unique<FunctionSummary>( |
226 | args: GlobalValueSummary::GVFlags( |
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=*/args: 0, args: FunctionSummary::FFlags{}, /*EntryCount=*/args: 0, args&: Refs, |
232 | args: ArrayRef<FunctionSummary::EdgeTy>{}, args: std::move(FSum.TypeTests), |
233 | args: std::move(FSum.TypeTestAssumeVCalls), |
234 | args: std::move(FSum.TypeCheckedLoadVCalls), |
235 | args: std::move(FSum.TypeTestAssumeConstVCalls), |
236 | args: std::move(FSum.TypeCheckedLoadConstVCalls), |
237 | args: ArrayRef<FunctionSummary::ParamAccess>{}, args: ArrayRef<CallsiteInfo>{}, |
238 | args: ArrayRef<AllocInfo>{})); |
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>(Val: Sum.get())) { |
246 | std::vector<uint64_t> Refs; |
247 | for (auto &VI : FSum->refs()) |
248 | Refs.push_back(x: VI.getGUID()); |
249 | FSums.push_back(x: FunctionSummaryYaml{ |
250 | .Linkage: FSum->flags().Linkage, .Visibility: FSum->flags().Visibility, |
251 | .NotEligibleToImport: static_cast<bool>(FSum->flags().NotEligibleToImport), |
252 | .Live: static_cast<bool>(FSum->flags().Live), |
253 | .IsLocal: static_cast<bool>(FSum->flags().DSOLocal), |
254 | .CanAutoHide: static_cast<bool>(FSum->flags().CanAutoHide), .Refs: Refs, |
255 | .TypeTests: FSum->type_tests(), .TypeTestAssumeVCalls: FSum->type_test_assume_vcalls(), |
256 | .TypeCheckedLoadVCalls: FSum->type_checked_load_vcalls(), |
257 | .TypeTestAssumeConstVCalls: FSum->type_test_assume_const_vcalls(), |
258 | .TypeCheckedLoadConstVCalls: FSum->type_checked_load_const_vcalls()}); |
259 | } |
260 | } |
261 | if (!FSums.empty()) |
262 | io.mapRequired(Key: llvm::utostr(X: P.first).c_str(), Val&: FSums); |
263 | } |
264 | } |
265 | }; |
266 | |
267 | template <> struct CustomMappingTraits<TypeIdSummaryMapTy> { |
268 | static void inputOne(IO &io, StringRef Key, TypeIdSummaryMapTy &V) { |
269 | TypeIdSummary TId; |
270 | io.mapRequired(Key: Key.str().c_str(), Val&: TId); |
271 | V.insert(x: {GlobalValue::getGUID(GlobalName: Key), {std::string(Key), TId}}); |
272 | } |
273 | static void output(IO &io, TypeIdSummaryMapTy &V) { |
274 | for (auto &TidIter : V) |
275 | io.mapRequired(Key: TidIter.second.first.c_str(), Val&: TidIter.second.second); |
276 | } |
277 | }; |
278 | |
279 | template <> struct MappingTraits<ModuleSummaryIndex> { |
280 | static void mapping(IO &io, ModuleSummaryIndex& index) { |
281 | io.mapOptional(Key: "GlobalValueMap" , Val&: index.GlobalValueMap); |
282 | io.mapOptional(Key: "TypeIdMap" , Val&: index.TypeIdMap); |
283 | io.mapOptional(Key: "WithGlobalValueDeadStripping" , |
284 | Val&: index.WithGlobalValueDeadStripping); |
285 | |
286 | if (io.outputting()) { |
287 | std::vector<std::string> CfiFunctionDefs(index.CfiFunctionDefs.begin(), |
288 | index.CfiFunctionDefs.end()); |
289 | io.mapOptional(Key: "CfiFunctionDefs" , Val&: CfiFunctionDefs); |
290 | std::vector<std::string> CfiFunctionDecls(index.CfiFunctionDecls.begin(), |
291 | index.CfiFunctionDecls.end()); |
292 | io.mapOptional(Key: "CfiFunctionDecls" , Val&: CfiFunctionDecls); |
293 | } else { |
294 | std::vector<std::string> CfiFunctionDefs; |
295 | io.mapOptional(Key: "CfiFunctionDefs" , Val&: CfiFunctionDefs); |
296 | index.CfiFunctionDefs = {CfiFunctionDefs.begin(), CfiFunctionDefs.end()}; |
297 | std::vector<std::string> CfiFunctionDecls; |
298 | io.mapOptional(Key: "CfiFunctionDecls" , Val&: CfiFunctionDecls); |
299 | index.CfiFunctionDecls = {CfiFunctionDecls.begin(), |
300 | CfiFunctionDecls.end()}; |
301 | } |
302 | } |
303 | }; |
304 | |
305 | } // End yaml namespace |
306 | } // End llvm namespace |
307 | |
308 | #endif |
309 | |