LCOV - code coverage report
Current view: top level - include/llvm/IR - ModuleSummaryIndexYAML.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 118 124 95.2 %
Date: 2018-06-17 00:07:59 Functions: 19 19 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13