Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 14 | pmbaty | 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 | 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("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", |
||
| 193 | 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.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>( |
||
| 226 | 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=*/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), |
||
| 237 | ArrayRef<FunctionSummary::ParamAccess>{}, ArrayRef<CallsiteInfo>{}, |
||
| 238 | 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>(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 | |||
| 267 | template <> 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 | |||
| 279 | template <> struct MappingTraits<ModuleSummaryIndex> { |
||
| 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 |