mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-26 12:43:36 +01:00
cee0963ebc
Followup to https://reviews.llvm.org/D91769 which added support for names globals. Differential Revision: https://reviews.llvm.org/D92909
579 lines
14 KiB
C++
579 lines
14 KiB
C++
//===- WasmYAML.h - Wasm YAMLIO implementation ------------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file
|
|
/// This file declares classes for handling the YAML representation
|
|
/// of wasm binaries.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_OBJECTYAML_WASMYAML_H
|
|
#define LLVM_OBJECTYAML_WASMYAML_H
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/BinaryFormat/Wasm.h"
|
|
#include "llvm/ObjectYAML/YAML.h"
|
|
#include "llvm/Support/Casting.h"
|
|
#include <cstdint>
|
|
#include <memory>
|
|
#include <vector>
|
|
|
|
namespace llvm {
|
|
namespace WasmYAML {
|
|
|
|
LLVM_YAML_STRONG_TYPEDEF(uint32_t, SectionType)
|
|
LLVM_YAML_STRONG_TYPEDEF(uint32_t, ValueType)
|
|
LLVM_YAML_STRONG_TYPEDEF(uint32_t, TableType)
|
|
LLVM_YAML_STRONG_TYPEDEF(uint32_t, SignatureForm)
|
|
LLVM_YAML_STRONG_TYPEDEF(uint32_t, ExportKind)
|
|
LLVM_YAML_STRONG_TYPEDEF(uint32_t, Opcode)
|
|
LLVM_YAML_STRONG_TYPEDEF(uint32_t, RelocType)
|
|
LLVM_YAML_STRONG_TYPEDEF(uint32_t, SymbolFlags)
|
|
LLVM_YAML_STRONG_TYPEDEF(uint32_t, SymbolKind)
|
|
LLVM_YAML_STRONG_TYPEDEF(uint32_t, SegmentFlags)
|
|
LLVM_YAML_STRONG_TYPEDEF(uint32_t, LimitFlags)
|
|
LLVM_YAML_STRONG_TYPEDEF(uint32_t, ComdatKind)
|
|
LLVM_YAML_STRONG_TYPEDEF(uint32_t, FeaturePolicyPrefix)
|
|
|
|
struct FileHeader {
|
|
yaml::Hex32 Version;
|
|
};
|
|
|
|
struct Limits {
|
|
LimitFlags Flags;
|
|
yaml::Hex32 Initial;
|
|
yaml::Hex32 Maximum;
|
|
};
|
|
|
|
struct Table {
|
|
TableType ElemType;
|
|
Limits TableLimits;
|
|
uint32_t Index;
|
|
};
|
|
|
|
struct Export {
|
|
StringRef Name;
|
|
ExportKind Kind;
|
|
uint32_t Index;
|
|
};
|
|
|
|
struct ElemSegment {
|
|
uint32_t TableIndex;
|
|
wasm::WasmInitExpr Offset;
|
|
std::vector<uint32_t> Functions;
|
|
};
|
|
|
|
struct Global {
|
|
uint32_t Index;
|
|
ValueType Type;
|
|
bool Mutable;
|
|
wasm::WasmInitExpr InitExpr;
|
|
};
|
|
|
|
struct Event {
|
|
uint32_t Index;
|
|
uint32_t Attribute;
|
|
uint32_t SigIndex;
|
|
};
|
|
|
|
struct Import {
|
|
StringRef Module;
|
|
StringRef Field;
|
|
ExportKind Kind;
|
|
union {
|
|
uint32_t SigIndex;
|
|
Global GlobalImport;
|
|
Table TableImport;
|
|
Limits Memory;
|
|
Event EventImport;
|
|
};
|
|
};
|
|
|
|
struct LocalDecl {
|
|
ValueType Type;
|
|
uint32_t Count;
|
|
};
|
|
|
|
struct Function {
|
|
uint32_t Index;
|
|
std::vector<LocalDecl> Locals;
|
|
yaml::BinaryRef Body;
|
|
};
|
|
|
|
struct Relocation {
|
|
RelocType Type;
|
|
uint32_t Index;
|
|
// TODO(wvo): this would strictly be better as Hex64, but that will change
|
|
// all existing obj2yaml output.
|
|
yaml::Hex32 Offset;
|
|
int64_t Addend;
|
|
};
|
|
|
|
struct DataSegment {
|
|
uint32_t SectionOffset;
|
|
uint32_t InitFlags;
|
|
uint32_t MemoryIndex;
|
|
wasm::WasmInitExpr Offset;
|
|
yaml::BinaryRef Content;
|
|
};
|
|
|
|
struct NameEntry {
|
|
uint32_t Index;
|
|
StringRef Name;
|
|
};
|
|
|
|
struct ProducerEntry {
|
|
std::string Name;
|
|
std::string Version;
|
|
};
|
|
|
|
struct FeatureEntry {
|
|
FeaturePolicyPrefix Prefix;
|
|
std::string Name;
|
|
};
|
|
|
|
struct SegmentInfo {
|
|
uint32_t Index;
|
|
StringRef Name;
|
|
uint32_t Alignment;
|
|
SegmentFlags Flags;
|
|
};
|
|
|
|
struct Signature {
|
|
uint32_t Index;
|
|
SignatureForm Form = wasm::WASM_TYPE_FUNC;
|
|
std::vector<ValueType> ParamTypes;
|
|
std::vector<ValueType> ReturnTypes;
|
|
};
|
|
|
|
struct SymbolInfo {
|
|
uint32_t Index;
|
|
StringRef Name;
|
|
SymbolKind Kind;
|
|
SymbolFlags Flags;
|
|
union {
|
|
uint32_t ElementIndex;
|
|
wasm::WasmDataReference DataRef;
|
|
};
|
|
};
|
|
|
|
struct InitFunction {
|
|
uint32_t Priority;
|
|
uint32_t Symbol;
|
|
};
|
|
|
|
struct ComdatEntry {
|
|
ComdatKind Kind;
|
|
uint32_t Index;
|
|
};
|
|
|
|
struct Comdat {
|
|
StringRef Name;
|
|
std::vector<ComdatEntry> Entries;
|
|
};
|
|
|
|
struct Section {
|
|
explicit Section(SectionType SecType) : Type(SecType) {}
|
|
virtual ~Section();
|
|
|
|
SectionType Type;
|
|
std::vector<Relocation> Relocations;
|
|
};
|
|
|
|
struct CustomSection : Section {
|
|
explicit CustomSection(StringRef Name)
|
|
: Section(wasm::WASM_SEC_CUSTOM), Name(Name) {}
|
|
|
|
static bool classof(const Section *S) {
|
|
return S->Type == wasm::WASM_SEC_CUSTOM;
|
|
}
|
|
|
|
StringRef Name;
|
|
yaml::BinaryRef Payload;
|
|
};
|
|
|
|
struct DylinkSection : CustomSection {
|
|
DylinkSection() : CustomSection("dylink") {}
|
|
|
|
static bool classof(const Section *S) {
|
|
auto C = dyn_cast<CustomSection>(S);
|
|
return C && C->Name == "dylink";
|
|
}
|
|
|
|
uint32_t MemorySize;
|
|
uint32_t MemoryAlignment;
|
|
uint32_t TableSize;
|
|
uint32_t TableAlignment;
|
|
std::vector<StringRef> Needed;
|
|
};
|
|
|
|
struct NameSection : CustomSection {
|
|
NameSection() : CustomSection("name") {}
|
|
|
|
static bool classof(const Section *S) {
|
|
auto C = dyn_cast<CustomSection>(S);
|
|
return C && C->Name == "name";
|
|
}
|
|
|
|
std::vector<NameEntry> FunctionNames;
|
|
std::vector<NameEntry> GlobalNames;
|
|
std::vector<NameEntry> DataSegmentNames;
|
|
};
|
|
|
|
struct LinkingSection : CustomSection {
|
|
LinkingSection() : CustomSection("linking") {}
|
|
|
|
static bool classof(const Section *S) {
|
|
auto C = dyn_cast<CustomSection>(S);
|
|
return C && C->Name == "linking";
|
|
}
|
|
|
|
uint32_t Version;
|
|
std::vector<SymbolInfo> SymbolTable;
|
|
std::vector<SegmentInfo> SegmentInfos;
|
|
std::vector<InitFunction> InitFunctions;
|
|
std::vector<Comdat> Comdats;
|
|
};
|
|
|
|
struct ProducersSection : CustomSection {
|
|
ProducersSection() : CustomSection("producers") {}
|
|
|
|
static bool classof(const Section *S) {
|
|
auto C = dyn_cast<CustomSection>(S);
|
|
return C && C->Name == "producers";
|
|
}
|
|
|
|
std::vector<ProducerEntry> Languages;
|
|
std::vector<ProducerEntry> Tools;
|
|
std::vector<ProducerEntry> SDKs;
|
|
};
|
|
|
|
struct TargetFeaturesSection : CustomSection {
|
|
TargetFeaturesSection() : CustomSection("target_features") {}
|
|
|
|
static bool classof(const Section *S) {
|
|
auto C = dyn_cast<CustomSection>(S);
|
|
return C && C->Name == "target_features";
|
|
}
|
|
|
|
std::vector<FeatureEntry> Features;
|
|
};
|
|
|
|
struct TypeSection : Section {
|
|
TypeSection() : Section(wasm::WASM_SEC_TYPE) {}
|
|
|
|
static bool classof(const Section *S) {
|
|
return S->Type == wasm::WASM_SEC_TYPE;
|
|
}
|
|
|
|
std::vector<Signature> Signatures;
|
|
};
|
|
|
|
struct ImportSection : Section {
|
|
ImportSection() : Section(wasm::WASM_SEC_IMPORT) {}
|
|
|
|
static bool classof(const Section *S) {
|
|
return S->Type == wasm::WASM_SEC_IMPORT;
|
|
}
|
|
|
|
std::vector<Import> Imports;
|
|
};
|
|
|
|
struct FunctionSection : Section {
|
|
FunctionSection() : Section(wasm::WASM_SEC_FUNCTION) {}
|
|
|
|
static bool classof(const Section *S) {
|
|
return S->Type == wasm::WASM_SEC_FUNCTION;
|
|
}
|
|
|
|
std::vector<uint32_t> FunctionTypes;
|
|
};
|
|
|
|
struct TableSection : Section {
|
|
TableSection() : Section(wasm::WASM_SEC_TABLE) {}
|
|
|
|
static bool classof(const Section *S) {
|
|
return S->Type == wasm::WASM_SEC_TABLE;
|
|
}
|
|
|
|
std::vector<Table> Tables;
|
|
};
|
|
|
|
struct MemorySection : Section {
|
|
MemorySection() : Section(wasm::WASM_SEC_MEMORY) {}
|
|
|
|
static bool classof(const Section *S) {
|
|
return S->Type == wasm::WASM_SEC_MEMORY;
|
|
}
|
|
|
|
std::vector<Limits> Memories;
|
|
};
|
|
|
|
struct EventSection : Section {
|
|
EventSection() : Section(wasm::WASM_SEC_EVENT) {}
|
|
|
|
static bool classof(const Section *S) {
|
|
return S->Type == wasm::WASM_SEC_EVENT;
|
|
}
|
|
|
|
std::vector<Event> Events;
|
|
};
|
|
|
|
struct GlobalSection : Section {
|
|
GlobalSection() : Section(wasm::WASM_SEC_GLOBAL) {}
|
|
|
|
static bool classof(const Section *S) {
|
|
return S->Type == wasm::WASM_SEC_GLOBAL;
|
|
}
|
|
|
|
std::vector<Global> Globals;
|
|
};
|
|
|
|
struct ExportSection : Section {
|
|
ExportSection() : Section(wasm::WASM_SEC_EXPORT) {}
|
|
|
|
static bool classof(const Section *S) {
|
|
return S->Type == wasm::WASM_SEC_EXPORT;
|
|
}
|
|
|
|
std::vector<Export> Exports;
|
|
};
|
|
|
|
struct StartSection : Section {
|
|
StartSection() : Section(wasm::WASM_SEC_START) {}
|
|
|
|
static bool classof(const Section *S) {
|
|
return S->Type == wasm::WASM_SEC_START;
|
|
}
|
|
|
|
uint32_t StartFunction;
|
|
};
|
|
|
|
struct ElemSection : Section {
|
|
ElemSection() : Section(wasm::WASM_SEC_ELEM) {}
|
|
|
|
static bool classof(const Section *S) {
|
|
return S->Type == wasm::WASM_SEC_ELEM;
|
|
}
|
|
|
|
std::vector<ElemSegment> Segments;
|
|
};
|
|
|
|
struct CodeSection : Section {
|
|
CodeSection() : Section(wasm::WASM_SEC_CODE) {}
|
|
|
|
static bool classof(const Section *S) {
|
|
return S->Type == wasm::WASM_SEC_CODE;
|
|
}
|
|
|
|
std::vector<Function> Functions;
|
|
};
|
|
|
|
struct DataSection : Section {
|
|
DataSection() : Section(wasm::WASM_SEC_DATA) {}
|
|
|
|
static bool classof(const Section *S) {
|
|
return S->Type == wasm::WASM_SEC_DATA;
|
|
}
|
|
|
|
std::vector<DataSegment> Segments;
|
|
};
|
|
|
|
struct DataCountSection : Section {
|
|
DataCountSection() : Section(wasm::WASM_SEC_DATACOUNT) {}
|
|
|
|
static bool classof(const Section *S) {
|
|
return S->Type == wasm::WASM_SEC_DATACOUNT;
|
|
}
|
|
|
|
uint32_t Count;
|
|
};
|
|
|
|
struct Object {
|
|
FileHeader Header;
|
|
std::vector<std::unique_ptr<Section>> Sections;
|
|
};
|
|
|
|
} // end namespace WasmYAML
|
|
} // end namespace llvm
|
|
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::WasmYAML::Section>)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Signature)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ValueType)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Table)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Import)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Export)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ElemSegment)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Limits)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::DataSegment)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Global)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Function)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::LocalDecl)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Relocation)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::NameEntry)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ProducerEntry)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::FeatureEntry)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SegmentInfo)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SymbolInfo)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::InitFunction)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ComdatEntry)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Comdat)
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Event)
|
|
|
|
namespace llvm {
|
|
namespace yaml {
|
|
|
|
template <> struct MappingTraits<WasmYAML::FileHeader> {
|
|
static void mapping(IO &IO, WasmYAML::FileHeader &FileHdr);
|
|
};
|
|
|
|
template <> struct MappingTraits<std::unique_ptr<WasmYAML::Section>> {
|
|
static void mapping(IO &IO, std::unique_ptr<WasmYAML::Section> &Section);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::Object> {
|
|
static void mapping(IO &IO, WasmYAML::Object &Object);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::Import> {
|
|
static void mapping(IO &IO, WasmYAML::Import &Import);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::Export> {
|
|
static void mapping(IO &IO, WasmYAML::Export &Export);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::Global> {
|
|
static void mapping(IO &IO, WasmYAML::Global &Global);
|
|
};
|
|
|
|
template <> struct ScalarBitSetTraits<WasmYAML::LimitFlags> {
|
|
static void bitset(IO &IO, WasmYAML::LimitFlags &Value);
|
|
};
|
|
|
|
template <> struct ScalarBitSetTraits<WasmYAML::SymbolFlags> {
|
|
static void bitset(IO &IO, WasmYAML::SymbolFlags &Value);
|
|
};
|
|
|
|
template <> struct ScalarEnumerationTraits<WasmYAML::SymbolKind> {
|
|
static void enumeration(IO &IO, WasmYAML::SymbolKind &Kind);
|
|
};
|
|
|
|
template <> struct ScalarBitSetTraits<WasmYAML::SegmentFlags> {
|
|
static void bitset(IO &IO, WasmYAML::SegmentFlags &Value);
|
|
};
|
|
|
|
template <> struct ScalarEnumerationTraits<WasmYAML::SectionType> {
|
|
static void enumeration(IO &IO, WasmYAML::SectionType &Type);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::Signature> {
|
|
static void mapping(IO &IO, WasmYAML::Signature &Signature);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::Table> {
|
|
static void mapping(IO &IO, WasmYAML::Table &Table);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::Limits> {
|
|
static void mapping(IO &IO, WasmYAML::Limits &Limits);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::Function> {
|
|
static void mapping(IO &IO, WasmYAML::Function &Function);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::Relocation> {
|
|
static void mapping(IO &IO, WasmYAML::Relocation &Relocation);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::NameEntry> {
|
|
static void mapping(IO &IO, WasmYAML::NameEntry &NameEntry);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::ProducerEntry> {
|
|
static void mapping(IO &IO, WasmYAML::ProducerEntry &ProducerEntry);
|
|
};
|
|
|
|
template <> struct ScalarEnumerationTraits<WasmYAML::FeaturePolicyPrefix> {
|
|
static void enumeration(IO &IO, WasmYAML::FeaturePolicyPrefix &Prefix);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::FeatureEntry> {
|
|
static void mapping(IO &IO, WasmYAML::FeatureEntry &FeatureEntry);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::SegmentInfo> {
|
|
static void mapping(IO &IO, WasmYAML::SegmentInfo &SegmentInfo);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::LocalDecl> {
|
|
static void mapping(IO &IO, WasmYAML::LocalDecl &LocalDecl);
|
|
};
|
|
|
|
template <> struct MappingTraits<wasm::WasmInitExpr> {
|
|
static void mapping(IO &IO, wasm::WasmInitExpr &Expr);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::DataSegment> {
|
|
static void mapping(IO &IO, WasmYAML::DataSegment &Segment);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::ElemSegment> {
|
|
static void mapping(IO &IO, WasmYAML::ElemSegment &Segment);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::SymbolInfo> {
|
|
static void mapping(IO &IO, WasmYAML::SymbolInfo &Info);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::InitFunction> {
|
|
static void mapping(IO &IO, WasmYAML::InitFunction &Init);
|
|
};
|
|
|
|
template <> struct ScalarEnumerationTraits<WasmYAML::ComdatKind> {
|
|
static void enumeration(IO &IO, WasmYAML::ComdatKind &Kind);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::ComdatEntry> {
|
|
static void mapping(IO &IO, WasmYAML::ComdatEntry &ComdatEntry);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::Comdat> {
|
|
static void mapping(IO &IO, WasmYAML::Comdat &Comdat);
|
|
};
|
|
|
|
template <> struct ScalarEnumerationTraits<WasmYAML::ValueType> {
|
|
static void enumeration(IO &IO, WasmYAML::ValueType &Type);
|
|
};
|
|
|
|
template <> struct ScalarEnumerationTraits<WasmYAML::ExportKind> {
|
|
static void enumeration(IO &IO, WasmYAML::ExportKind &Kind);
|
|
};
|
|
|
|
template <> struct ScalarEnumerationTraits<WasmYAML::TableType> {
|
|
static void enumeration(IO &IO, WasmYAML::TableType &Type);
|
|
};
|
|
|
|
template <> struct ScalarEnumerationTraits<WasmYAML::Opcode> {
|
|
static void enumeration(IO &IO, WasmYAML::Opcode &Opcode);
|
|
};
|
|
|
|
template <> struct ScalarEnumerationTraits<WasmYAML::RelocType> {
|
|
static void enumeration(IO &IO, WasmYAML::RelocType &Kind);
|
|
};
|
|
|
|
template <> struct MappingTraits<WasmYAML::Event> {
|
|
static void mapping(IO &IO, WasmYAML::Event &Event);
|
|
};
|
|
|
|
} // end namespace yaml
|
|
} // end namespace llvm
|
|
|
|
#endif // LLVM_OBJECTYAML_WASMYAML_H
|