xref: /freebsd/contrib/llvm-project/llvm/include/llvm/IR/ModuleSummaryIndexYAML.h (revision 0fca6ea1d4eea4c934cfff25ac9ee8ad6fe95583) 
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(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,
43                           WholeProgramDevirtResolution::ByArg::Kind &value) {
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 
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",
102                 WholeProgramDevirtResolution::BranchFunnel);
103   }
104 };
105 
106 template <> struct MappingTraits<WholeProgramDevirtResolution> {
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 
138 struct FunctionSummaryYaml {
139   unsigned Linkage, Visibility;
140   bool NotEligibleToImport, Live, IsLocal, CanAutoHide;
141   unsigned ImportType;
142   std::vector<uint64_t> Refs;
143   std::vector<uint64_t> TypeTests;
144   std::vector<FunctionSummary::VFuncId> TypeTestAssumeVCalls,
145       TypeCheckedLoadVCalls;
146   std::vector<FunctionSummary::ConstVCall> TypeTestAssumeConstVCalls,
147       TypeCheckedLoadConstVCalls;
148 };
149 
150 } // End yaml namespace
151 } // End llvm namespace
152 
153 namespace llvm {
154 namespace yaml {
155 
156 template <> struct MappingTraits<FunctionSummary::VFuncId> {
157   static void mapping(IO &io, FunctionSummary::VFuncId& id) {
158     io.mapOptional("GUID", id.GUID);
159     io.mapOptional("Offset", id.Offset);
160   }
161 };
162 
163 template <> struct MappingTraits<FunctionSummary::ConstVCall> {
164   static void mapping(IO &io, FunctionSummary::ConstVCall& id) {
165     io.mapOptional("VFunc", id.VFunc);
166     io.mapOptional("Args", id.Args);
167   }
168 };
169 
170 } // End yaml namespace
171 } // End llvm namespace
172 
173 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummary::VFuncId)
174 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummary::ConstVCall)
175 
176 namespace llvm {
177 namespace yaml {
178 
179 template <> struct MappingTraits<FunctionSummaryYaml> {
180   static void mapping(IO &io, FunctionSummaryYaml& summary) {
181     io.mapOptional("Linkage", summary.Linkage);
182     io.mapOptional("Visibility", summary.Visibility);
183     io.mapOptional("NotEligibleToImport", summary.NotEligibleToImport);
184     io.mapOptional("Live", summary.Live);
185     io.mapOptional("Local", summary.IsLocal);
186     io.mapOptional("CanAutoHide", summary.CanAutoHide);
187     io.mapOptional("ImportType", summary.ImportType);
188     io.mapOptional("Refs", summary.Refs);
189     io.mapOptional("TypeTests", summary.TypeTests);
190     io.mapOptional("TypeTestAssumeVCalls", summary.TypeTestAssumeVCalls);
191     io.mapOptional("TypeCheckedLoadVCalls", summary.TypeCheckedLoadVCalls);
192     io.mapOptional("TypeTestAssumeConstVCalls",
193                    summary.TypeTestAssumeConstVCalls);
194     io.mapOptional("TypeCheckedLoadConstVCalls",
195                    summary.TypeCheckedLoadConstVCalls);
196   }
197 };
198 
199 } // End yaml namespace
200 } // End llvm namespace
201 
202 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummaryYaml)
203 
204 namespace llvm {
205 namespace yaml {
206 
207 // FIXME: Add YAML mappings for the rest of the module summary.
208 template <> struct CustomMappingTraits<GlobalValueSummaryMapTy> {
209   static void inputOne(IO &io, StringRef Key, GlobalValueSummaryMapTy &V) {
210     std::vector<FunctionSummaryYaml> FSums;
211     io.mapRequired(Key.str().c_str(), FSums);
212     uint64_t KeyInt;
213     if (Key.getAsInteger(0, KeyInt)) {
214       io.setError("key not an integer");
215       return;
216     }
217     if (!V.count(KeyInt))
218       V.emplace(KeyInt, /*IsAnalysis=*/false);
219     auto &Elem = V.find(KeyInt)->second;
220     for (auto &FSum : FSums) {
221       std::vector<ValueInfo> Refs;
222       for (auto &RefGUID : FSum.Refs) {
223         if (!V.count(RefGUID))
224           V.emplace(RefGUID, /*IsAnalysis=*/false);
225         Refs.push_back(ValueInfo(/*IsAnalysis=*/false, &*V.find(RefGUID)));
226       }
227       Elem.SummaryList.push_back(std::make_unique<FunctionSummary>(
228           GlobalValueSummary::GVFlags(
229               static_cast<GlobalValue::LinkageTypes>(FSum.Linkage),
230               static_cast<GlobalValue::VisibilityTypes>(FSum.Visibility),
231               FSum.NotEligibleToImport, FSum.Live, FSum.IsLocal,
232               FSum.CanAutoHide,
233               static_cast<GlobalValueSummary::ImportKind>(FSum.ImportType)),
234           /*NumInsts=*/0, FunctionSummary::FFlags{}, /*EntryCount=*/0, Refs,
235           ArrayRef<FunctionSummary::EdgeTy>{}, std::move(FSum.TypeTests),
236           std::move(FSum.TypeTestAssumeVCalls),
237           std::move(FSum.TypeCheckedLoadVCalls),
238           std::move(FSum.TypeTestAssumeConstVCalls),
239           std::move(FSum.TypeCheckedLoadConstVCalls),
240           ArrayRef<FunctionSummary::ParamAccess>{}, ArrayRef<CallsiteInfo>{},
241           ArrayRef<AllocInfo>{}));
242     }
243   }
244   static void output(IO &io, GlobalValueSummaryMapTy &V) {
245     for (auto &P : V) {
246       std::vector<FunctionSummaryYaml> FSums;
247       for (auto &Sum : P.second.SummaryList) {
248         if (auto *FSum = dyn_cast<FunctionSummary>(Sum.get())) {
249           std::vector<uint64_t> Refs;
250           for (auto &VI : FSum->refs())
251             Refs.push_back(VI.getGUID());
252           FSums.push_back(FunctionSummaryYaml{
253               FSum->flags().Linkage, FSum->flags().Visibility,
254               static_cast<bool>(FSum->flags().NotEligibleToImport),
255               static_cast<bool>(FSum->flags().Live),
256               static_cast<bool>(FSum->flags().DSOLocal),
257               static_cast<bool>(FSum->flags().CanAutoHide),
258               FSum->flags().ImportType, Refs, FSum->type_tests(),
259               FSum->type_test_assume_vcalls(), FSum->type_checked_load_vcalls(),
260               FSum->type_test_assume_const_vcalls(),
261               FSum->type_checked_load_const_vcalls()});
262           }
263       }
264       if (!FSums.empty())
265         io.mapRequired(llvm::utostr(P.first).c_str(), FSums);
266     }
267   }
268 };
269 
270 template <> struct CustomMappingTraits<TypeIdSummaryMapTy> {
271   static void inputOne(IO &io, StringRef Key, TypeIdSummaryMapTy &V) {
272     TypeIdSummary TId;
273     io.mapRequired(Key.str().c_str(), TId);
274     V.insert({GlobalValue::getGUID(Key), {std::string(Key), TId}});
275   }
276   static void output(IO &io, TypeIdSummaryMapTy &V) {
277     for (auto &TidIter : V)
278       io.mapRequired(TidIter.second.first.c_str(), TidIter.second.second);
279   }
280 };
281 
282 template <> struct MappingTraits<ModuleSummaryIndex> {
283   static void mapping(IO &io, ModuleSummaryIndex& index) {
284     io.mapOptional("GlobalValueMap", index.GlobalValueMap);
285     io.mapOptional("TypeIdMap", index.TypeIdMap);
286     io.mapOptional("WithGlobalValueDeadStripping",
287                    index.WithGlobalValueDeadStripping);
288 
289     if (io.outputting()) {
290       std::vector<std::string> CfiFunctionDefs(index.CfiFunctionDefs.begin(),
291                                                index.CfiFunctionDefs.end());
292       io.mapOptional("CfiFunctionDefs", CfiFunctionDefs);
293       std::vector<std::string> CfiFunctionDecls(index.CfiFunctionDecls.begin(),
294                                                 index.CfiFunctionDecls.end());
295       io.mapOptional("CfiFunctionDecls", CfiFunctionDecls);
296     } else {
297       std::vector<std::string> CfiFunctionDefs;
298       io.mapOptional("CfiFunctionDefs", CfiFunctionDefs);
299       index.CfiFunctionDefs = {CfiFunctionDefs.begin(), CfiFunctionDefs.end()};
300       std::vector<std::string> CfiFunctionDecls;
301       io.mapOptional("CfiFunctionDecls", CfiFunctionDecls);
302       index.CfiFunctionDecls = {CfiFunctionDecls.begin(),
303                                 CfiFunctionDecls.end()};
304     }
305   }
306 };
307 
308 } // End yaml namespace
309 } // End llvm namespace
310 
311 #endif
312