mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-25 04:02:41 +01:00
396740fa88
This means that we can use a shorter instruction sequence in the case where the size is a power of two and on the boundary between two representations. Differential Revision: https://reviews.llvm.org/D28421 llvm-svn: 291706
112 lines
3.3 KiB
C++
112 lines
3.3 KiB
C++
//===-- llvm/ModuleSummaryIndexYAML.h - YAML I/O for summary ----*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_IR_MODULESUMMARYINDEXYAML_H
|
|
#define LLVM_IR_MODULESUMMARYINDEXYAML_H
|
|
|
|
#include "llvm/IR/ModuleSummaryIndex.h"
|
|
#include "llvm/Support/YAMLTraits.h"
|
|
|
|
namespace llvm {
|
|
namespace yaml {
|
|
|
|
template <> struct ScalarEnumerationTraits<TypeTestResolution::Kind> {
|
|
static void enumeration(IO &io, TypeTestResolution::Kind &value) {
|
|
io.enumCase(value, "Unsat", TypeTestResolution::Unsat);
|
|
io.enumCase(value, "ByteArray", TypeTestResolution::ByteArray);
|
|
io.enumCase(value, "Inline", TypeTestResolution::Inline);
|
|
io.enumCase(value, "Single", TypeTestResolution::Single);
|
|
io.enumCase(value, "AllOnes", TypeTestResolution::AllOnes);
|
|
}
|
|
};
|
|
|
|
template <> struct MappingTraits<TypeTestResolution> {
|
|
static void mapping(IO &io, TypeTestResolution &res) {
|
|
io.mapOptional("Kind", res.TheKind);
|
|
io.mapOptional("SizeM1BitWidth", res.SizeM1BitWidth);
|
|
}
|
|
};
|
|
|
|
template <> struct MappingTraits<TypeIdSummary> {
|
|
static void mapping(IO &io, TypeIdSummary& summary) {
|
|
io.mapOptional("TTRes", summary.TTRes);
|
|
}
|
|
};
|
|
|
|
struct FunctionSummaryYaml {
|
|
std::vector<uint64_t> TypeTests;
|
|
};
|
|
|
|
} // End yaml namespace
|
|
} // End llvm namespace
|
|
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(uint64_t)
|
|
|
|
namespace llvm {
|
|
namespace yaml {
|
|
|
|
template <> struct MappingTraits<FunctionSummaryYaml> {
|
|
static void mapping(IO &io, FunctionSummaryYaml& summary) {
|
|
io.mapOptional("TypeTests", summary.TypeTests);
|
|
}
|
|
};
|
|
|
|
} // End yaml namespace
|
|
} // End llvm namespace
|
|
|
|
LLVM_YAML_IS_STRING_MAP(TypeIdSummary)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummaryYaml)
|
|
|
|
namespace llvm {
|
|
namespace yaml {
|
|
|
|
// FIXME: Add YAML mappings for the rest of the module summary.
|
|
template <> struct CustomMappingTraits<GlobalValueSummaryMapTy> {
|
|
static void inputOne(IO &io, StringRef Key, GlobalValueSummaryMapTy &V) {
|
|
std::vector<FunctionSummaryYaml> FSums;
|
|
io.mapRequired(Key.str().c_str(), FSums);
|
|
uint64_t KeyInt;
|
|
if (Key.getAsInteger(0, KeyInt)) {
|
|
io.setError("key not an integer");
|
|
return;
|
|
}
|
|
auto &Elem = V[KeyInt];
|
|
for (auto &FSum : FSums) {
|
|
GlobalValueSummary::GVFlags GVFlags(GlobalValue::ExternalLinkage, false,
|
|
false);
|
|
Elem.push_back(llvm::make_unique<FunctionSummary>(
|
|
GVFlags, 0, ArrayRef<ValueInfo>{},
|
|
ArrayRef<FunctionSummary::EdgeTy>{}, std::move(FSum.TypeTests)));
|
|
}
|
|
}
|
|
static void output(IO &io, GlobalValueSummaryMapTy &V) {
|
|
for (auto &P : V) {
|
|
std::vector<FunctionSummaryYaml> FSums;
|
|
for (auto &Sum : P.second) {
|
|
if (auto *FSum = dyn_cast<FunctionSummary>(Sum.get()))
|
|
FSums.push_back(FunctionSummaryYaml{FSum->type_tests()});
|
|
}
|
|
if (!FSums.empty())
|
|
io.mapRequired(llvm::utostr(P.first).c_str(), FSums);
|
|
}
|
|
}
|
|
};
|
|
|
|
template <> struct MappingTraits<ModuleSummaryIndex> {
|
|
static void mapping(IO &io, ModuleSummaryIndex& index) {
|
|
io.mapOptional("GlobalValueMap", index.GlobalValueMap);
|
|
io.mapOptional("TypeIdMap", index.TypeIdMap);
|
|
}
|
|
};
|
|
|
|
} // End yaml namespace
|
|
} // End llvm namespace
|
|
|
|
#endif
|