contrib/llvm/include/llvm/IR/ModuleSummaryIndexYAML.h

   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   }
  34 };
  35
  36 template <>
  37 struct ScalarEnumerationTraits<WholeProgramDevirtResolution::ByArg::Kind> {
  38   static void enumeration(IO &io,
  39                           WholeProgramDevirtResolution::ByArg::Kind &value) {
  40     io.enumCase(value, "Indir", WholeProgramDevirtResolution::ByArg::Indir);
  41     io.enumCase(value, "UniformRetVal",
  42                 WholeProgramDevirtResolution::ByArg::UniformRetVal);
  43     io.enumCase(value, "UniqueRetVal",
  44                 WholeProgramDevirtResolution::ByArg::UniqueRetVal);
  45     io.enumCase(value, "VirtualConstProp",
  46                 WholeProgramDevirtResolution::ByArg::VirtualConstProp);
  47   }
  48 };
  49
  50 template <> struct MappingTraits<WholeProgramDevirtResolution::ByArg> {
  51   static void mapping(IO &io, WholeProgramDevirtResolution::ByArg &res) {
  52     io.mapOptional("Kind", res.TheKind);
  53     io.mapOptional("Info", res.Info);
  54   }
  55 };
  56
  57 template <>
  58 struct CustomMappingTraits<
  59     std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg>> {
  60   static void inputOne(
  61       IO &io, StringRef Key,
  62       std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg> &V) {
  63     std::vector<uint64_t> Args;
  64     std::pair<StringRef, StringRef> P = {"", Key};
  65     while (!P.second.empty()) {
  66       P = P.second.split(',');
  67       uint64_t Arg;
  68       if (P.first.getAsInteger(0, Arg)) {
  69         io.setError("key not an integer");
  70         return;
  71       }
  72       Args.push_back(Arg);
  73     }
  74     io.mapRequired(Key.str().c_str(), V[Args]);
  75   }
  76   static void output(
  77       IO &io,
  78       std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg> &V) {
  79     for (auto &P : V) {
  80       std::string Key;
  81       for (uint64_t Arg : P.first) {
  82         if (!Key.empty())
  83           Key += ',';
  84         Key += llvm::utostr(Arg);
  85       }
  86       io.mapRequired(Key.c_str(), P.second);
  87     }
  88   }
  89 };
  90
  91 template <> struct ScalarEnumerationTraits<WholeProgramDevirtResolution::Kind> {
  92   static void enumeration(IO &io, WholeProgramDevirtResolution::Kind &value) {
  93     io.enumCase(value, "Indir", WholeProgramDevirtResolution::Indir);
  94     io.enumCase(value, "SingleImpl", WholeProgramDevirtResolution::SingleImpl);
  95   }
  96 };
  97
  98 template <> struct MappingTraits<WholeProgramDevirtResolution> {
  99   static void mapping(IO &io, WholeProgramDevirtResolution &res) {
 100     io.mapOptional("Kind", res.TheKind);
 101     io.mapOptional("SingleImplName", res.SingleImplName);
 102     io.mapOptional("ResByArg", res.ResByArg);
 103   }
 104 };
 105
 106 template <>
 107 struct CustomMappingTraits<std::map<uint64_t, WholeProgramDevirtResolution>> {
 108   static void inputOne(IO &io, StringRef Key,
 109                        std::map<uint64_t, WholeProgramDevirtResolution> &V) {
 110     uint64_t KeyInt;
 111     if (Key.getAsInteger(0, KeyInt)) {
 112       io.setError("key not an integer");
 113       return;
 114     }
 115     io.mapRequired(Key.str().c_str(), V[KeyInt]);
 116   }
 117   static void output(IO &io, std::map<uint64_t, WholeProgramDevirtResolution> &V) {
 118     for (auto &P : V)
 119       io.mapRequired(llvm::utostr(P.first).c_str(), P.second);
 120   }
 121 };
 122
 123 template <> struct MappingTraits<TypeIdSummary> {
 124   static void mapping(IO &io, TypeIdSummary& summary) {
 125     io.mapOptional("TTRes", summary.TTRes);
 126     io.mapOptional("WPDRes", summary.WPDRes);
 127   }
 128 };
 129
 130 struct FunctionSummaryYaml {
 131   unsigned Linkage;
 132   bool NotEligibleToImport, Live;
 133   std::vector<uint64_t> TypeTests;
 134   std::vector<FunctionSummary::VFuncId> TypeTestAssumeVCalls,
 135       TypeCheckedLoadVCalls;
 136   std::vector<FunctionSummary::ConstVCall> TypeTestAssumeConstVCalls,
 137       TypeCheckedLoadConstVCalls;
 138 };
 139
 140 } // End yaml namespace
 141 } // End llvm namespace
 142
 143 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint64_t)
 144
 145 namespace llvm {
 146 namespace yaml {
 147
 148 template <> struct MappingTraits<FunctionSummary::VFuncId> {
 149   static void mapping(IO &io, FunctionSummary::VFuncId& id) {
 150     io.mapOptional("GUID", id.GUID);
 151     io.mapOptional("Offset", id.Offset);
 152   }
 153 };
 154
 155 template <> struct MappingTraits<FunctionSummary::ConstVCall> {
 156   static void mapping(IO &io, FunctionSummary::ConstVCall& id) {
 157     io.mapOptional("VFunc", id.VFunc);
 158     io.mapOptional("Args", id.Args);
 159   }
 160 };
 161
 162 } // End yaml namespace
 163 } // End llvm namespace
 164
 165 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummary::VFuncId)
 166 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummary::ConstVCall)
 167
 168 namespace llvm {
 169 namespace yaml {
 170
 171 template <> struct MappingTraits<FunctionSummaryYaml> {
 172   static void mapping(IO &io, FunctionSummaryYaml& summary) {
 173     io.mapOptional("Linkage", summary.Linkage);
 174     io.mapOptional("NotEligibleToImport", summary.NotEligibleToImport);
 175     io.mapOptional("Live", summary.Live);
 176     io.mapOptional("TypeTests", summary.TypeTests);
 177     io.mapOptional("TypeTestAssumeVCalls", summary.TypeTestAssumeVCalls);
 178     io.mapOptional("TypeCheckedLoadVCalls", summary.TypeCheckedLoadVCalls);
 179     io.mapOptional("TypeTestAssumeConstVCalls",
 180                    summary.TypeTestAssumeConstVCalls);
 181     io.mapOptional("TypeCheckedLoadConstVCalls",
 182                    summary.TypeCheckedLoadConstVCalls);
 183   }
 184 };
 185
 186 } // End yaml namespace
 187 } // End llvm namespace
 188
 189 LLVM_YAML_IS_STRING_MAP(TypeIdSummary)
 190 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummaryYaml)
 191
 192 namespace llvm {
 193 namespace yaml {
 194
 195 // FIXME: Add YAML mappings for the rest of the module summary.
 196 template <> struct CustomMappingTraits<GlobalValueSummaryMapTy> {
 197   static void inputOne(IO &io, StringRef Key, GlobalValueSummaryMapTy &V) {
 198     std::vector<FunctionSummaryYaml> FSums;
 199     io.mapRequired(Key.str().c_str(), FSums);
 200     uint64_t KeyInt;
 201     if (Key.getAsInteger(0, KeyInt)) {
 202       io.setError("key not an integer");
 203       return;
 204     }
 205     auto &Elem = V[KeyInt];
 206     for (auto &FSum : FSums) {
 207       Elem.SummaryList.push_back(llvm::make_unique<FunctionSummary>(
 208           GlobalValueSummary::GVFlags(
 209               static_cast<GlobalValue::LinkageTypes>(FSum.Linkage),
 210               FSum.NotEligibleToImport, FSum.Live),
 211           0, ArrayRef<ValueInfo>{}, ArrayRef<FunctionSummary::EdgeTy>{},
 212           std::move(FSum.TypeTests), std::move(FSum.TypeTestAssumeVCalls),
 213           std::move(FSum.TypeCheckedLoadVCalls),
 214           std::move(FSum.TypeTestAssumeConstVCalls),
 215           std::move(FSum.TypeCheckedLoadConstVCalls)));
 216     }
 217   }
 218   static void output(IO &io, GlobalValueSummaryMapTy &V) {
 219     for (auto &P : V) {
 220       std::vector<FunctionSummaryYaml> FSums;
 221       for (auto &Sum : P.second.SummaryList) {
 222         if (auto *FSum = dyn_cast<FunctionSummary>(Sum.get()))
 223           FSums.push_back(FunctionSummaryYaml{
 224               FSum->flags().Linkage,
 225               static_cast<bool>(FSum->flags().NotEligibleToImport),
 226               static_cast<bool>(FSum->flags().Live), FSum->type_tests(),
 227               FSum->type_test_assume_vcalls(), FSum->type_checked_load_vcalls(),
 228               FSum->type_test_assume_const_vcalls(),
 229               FSum->type_checked_load_const_vcalls()});
 230       }
 231       if (!FSums.empty())
 232         io.mapRequired(llvm::utostr(P.first).c_str(), FSums);
 233     }
 234   }
 235 };
 236
 237 template <> struct MappingTraits<ModuleSummaryIndex> {
 238   static void mapping(IO &io, ModuleSummaryIndex& index) {
 239     io.mapOptional("GlobalValueMap", index.GlobalValueMap);
 240     io.mapOptional("TypeIdMap", index.TypeIdMap);
 241     io.mapOptional("WithGlobalValueDeadStripping",
 242                    index.WithGlobalValueDeadStripping);
 243   }
 244 };
 245
 246 } // End yaml namespace
 247 } // End llvm namespace
 248
 249 #endif