1 //===-- llvm/ModuleSummaryIndexYAML.h - YAML I/O for summary ----*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef LLVM_IR_MODULESUMMARYINDEXYAML_H
11 #define LLVM_IR_MODULESUMMARYINDEXYAML_H
12 
13 #include "llvm/IR/ModuleSummaryIndex.h"
14 #include "llvm/Support/YAMLTraits.h"
15 
16 namespace llvm {
17 namespace yaml {
18 
19 template <> struct ScalarEnumerationTraits<TypeTestResolution::Kind> {
20   static void enumeration(IO &io, TypeTestResolution::Kind &value) {
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   }
102 };
103 
104 template <> struct MappingTraits<WholeProgramDevirtResolution> {
105   static void mapping(IO &io, WholeProgramDevirtResolution &res) {
106     io.mapOptional("Kind", res.TheKind);
107     io.mapOptional("SingleImplName", res.SingleImplName);
108     io.mapOptional("ResByArg", res.ResByArg);
109   }
110 };
111 
112 template <>
113 struct CustomMappingTraits<std::map<uint64_t, WholeProgramDevirtResolution>> {
114   static void inputOne(IO &io, StringRef Key,
115                        std::map<uint64_t, WholeProgramDevirtResolution> &V) {
116     uint64_t KeyInt;
117     if (Key.getAsInteger(0, KeyInt)) {
118       io.setError("key not an integer");
119       return;
120     }
121     io.mapRequired(Key.str().c_str(), V[KeyInt]);
122   }
123   static void output(IO &io, std::map<uint64_t, WholeProgramDevirtResolution> &V) {
124     for (auto &P : V)
125       io.mapRequired(llvm::utostr(P.first).c_str(), P.second);
126   }
127 };
128 
129 template <> struct MappingTraits<TypeIdSummary> {
130   static void mapping(IO &io, TypeIdSummary& summary) {
131     io.mapOptional("TTRes", summary.TTRes);
132     io.mapOptional("WPDRes", summary.WPDRes);
133   }
134 };
135 
136 struct FunctionSummaryYaml {
137   unsigned Linkage;
138   bool NotEligibleToImport, Live, IsLocal;
139   std::vector<uint64_t> TypeTests;
140   std::vector<FunctionSummary::VFuncId> TypeTestAssumeVCalls,
141       TypeCheckedLoadVCalls;
142   std::vector<FunctionSummary::ConstVCall> TypeTestAssumeConstVCalls,
143       TypeCheckedLoadConstVCalls;
144 };
145 
146 } // End yaml namespace
147 } // End llvm namespace
148 
149 namespace llvm {
150 namespace yaml {
151 
152 template <> struct MappingTraits<FunctionSummary::VFuncId> {
153   static void mapping(IO &io, FunctionSummary::VFuncId& id) {
154     io.mapOptional("GUID", id.GUID);
155     io.mapOptional("Offset", id.Offset);
156   }
157 };
158 
159 template <> struct MappingTraits<FunctionSummary::ConstVCall> {
160   static void mapping(IO &io, FunctionSummary::ConstVCall& id) {
161     io.mapOptional("VFunc", id.VFunc);
162     io.mapOptional("Args", id.Args);
163   }
164 };
165 
166 } // End yaml namespace
167 } // End llvm namespace
168 
169 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummary::VFuncId)
170 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummary::ConstVCall)
171 
172 namespace llvm {
173 namespace yaml {
174 
175 template <> struct MappingTraits<FunctionSummaryYaml> {
176   static void mapping(IO &io, FunctionSummaryYaml& summary) {
177     io.mapOptional("Linkage", summary.Linkage);
178     io.mapOptional("NotEligibleToImport", summary.NotEligibleToImport);
179     io.mapOptional("Live", summary.Live);
180     io.mapOptional("Local", summary.IsLocal);
181     io.mapOptional("TypeTests", summary.TypeTests);
182     io.mapOptional("TypeTestAssumeVCalls", summary.TypeTestAssumeVCalls);
183     io.mapOptional("TypeCheckedLoadVCalls", summary.TypeCheckedLoadVCalls);
184     io.mapOptional("TypeTestAssumeConstVCalls",
185                    summary.TypeTestAssumeConstVCalls);
186     io.mapOptional("TypeCheckedLoadConstVCalls",
187                    summary.TypeCheckedLoadConstVCalls);
188   }
189 };
190 
191 } // End yaml namespace
192 } // End llvm namespace
193 
194 LLVM_YAML_IS_STRING_MAP(TypeIdSummary)
195 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummaryYaml)
196 
197 namespace llvm {
198 namespace yaml {
199 
200 // FIXME: Add YAML mappings for the rest of the module summary.
201 template <> struct CustomMappingTraits<GlobalValueSummaryMapTy> {
202   static void inputOne(IO &io, StringRef Key, GlobalValueSummaryMapTy &V) {
203     std::vector<FunctionSummaryYaml> FSums;
204     io.mapRequired(Key.str().c_str(), FSums);
205     uint64_t KeyInt;
206     if (Key.getAsInteger(0, KeyInt)) {
207       io.setError("key not an integer");
208       return;
209     }
210     auto &Elem = V[KeyInt];
211     for (auto &FSum : FSums) {
212       Elem.SummaryList.push_back(llvm::make_unique<FunctionSummary>(
213           GlobalValueSummary::GVFlags(
214               static_cast<GlobalValue::LinkageTypes>(FSum.Linkage),
215               FSum.NotEligibleToImport, FSum.Live, FSum.IsLocal),
216           0, FunctionSummary::FFlags{}, ArrayRef<ValueInfo>{},
217           ArrayRef<FunctionSummary::EdgeTy>{}, std::move(FSum.TypeTests),
218           std::move(FSum.TypeTestAssumeVCalls),
219           std::move(FSum.TypeCheckedLoadVCalls),
220           std::move(FSum.TypeTestAssumeConstVCalls),
221           std::move(FSum.TypeCheckedLoadConstVCalls)));
222     }
223   }
224   static void output(IO &io, GlobalValueSummaryMapTy &V) {
225     for (auto &P : V) {
226       std::vector<FunctionSummaryYaml> FSums;
227       for (auto &Sum : P.second.SummaryList) {
228         if (auto *FSum = dyn_cast<FunctionSummary>(Sum.get()))
229           FSums.push_back(FunctionSummaryYaml{
230               FSum->flags().Linkage,
231               static_cast<bool>(FSum->flags().NotEligibleToImport),
232               static_cast<bool>(FSum->flags().Live),
233               static_cast<bool>(FSum->flags().DSOLocal), FSum->type_tests(),
234               FSum->type_test_assume_vcalls(), FSum->type_checked_load_vcalls(),
235               FSum->type_test_assume_const_vcalls(),
236               FSum->type_checked_load_const_vcalls()});
237       }
238       if (!FSums.empty())
239         io.mapRequired(llvm::utostr(P.first).c_str(), FSums);
240     }
241   }
242 };
243 
244 template <> struct MappingTraits<ModuleSummaryIndex> {
245   static void mapping(IO &io, ModuleSummaryIndex& index) {
246     io.mapOptional("GlobalValueMap", index.GlobalValueMap);
247     io.mapOptional("TypeIdMap", index.TypeIdMap);
248     io.mapOptional("WithGlobalValueDeadStripping",
249                    index.WithGlobalValueDeadStripping);
250 
251     if (io.outputting()) {
252       std::vector<std::string> CfiFunctionDefs(index.CfiFunctionDefs.begin(),
253                                                index.CfiFunctionDefs.end());
254       io.mapOptional("CfiFunctionDefs", CfiFunctionDefs);
255       std::vector<std::string> CfiFunctionDecls(index.CfiFunctionDecls.begin(),
256                                                 index.CfiFunctionDecls.end());
257       io.mapOptional("CfiFunctionDecls", CfiFunctionDecls);
258     } else {
259       std::vector<std::string> CfiFunctionDefs;
260       io.mapOptional("CfiFunctionDefs", CfiFunctionDefs);
261       index.CfiFunctionDefs = {CfiFunctionDefs.begin(), CfiFunctionDefs.end()};
262       std::vector<std::string> CfiFunctionDecls;
263       io.mapOptional("CfiFunctionDecls", CfiFunctionDecls);
264       index.CfiFunctionDecls = {CfiFunctionDecls.begin(),
265                                 CfiFunctionDecls.end()};
266     }
267   }
268 };
269 
270 } // End yaml namespace
271 } // End llvm namespace
272 
273 #endif
274