//===- WasmYAML.cpp - Wasm YAMLIO implementation --------------------------===// // // 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 // //===----------------------------------------------------------------------===// // // This file defines classes for handling the YAML representation of wasm. // //===----------------------------------------------------------------------===// #include "llvm/ObjectYAML/WasmYAML.h" #include "llvm/ADT/StringRef.h" #include "llvm/BinaryFormat/Wasm.h" #include "llvm/Support/Casting.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/YAMLTraits.h" namespace llvm { namespace WasmYAML { // Declared here rather than in the header to comply with: // http://llvm.org/docs/CodingStandards.html#provide-a-virtual-method-anchor-for-classes-in-headers Section::~Section() = default; } // end namespace WasmYAML namespace yaml { void MappingTraits::mapping( IO &IO, WasmYAML::FileHeader &FileHdr) { IO.mapRequired("Version", FileHdr.Version); } void MappingTraits::mapping(IO &IO, WasmYAML::Object &Object) { IO.setContext(&Object); IO.mapTag("!WASM", true); IO.mapRequired("FileHeader", Object.Header); IO.mapOptional("Sections", Object.Sections); IO.setContext(nullptr); } static void commonSectionMapping(IO &IO, WasmYAML::Section &Section) { IO.mapRequired("Type", Section.Type); IO.mapOptional("Relocations", Section.Relocations); IO.mapOptional("HeaderSecSizeEncodingLen", Section.HeaderSecSizeEncodingLen); } static void sectionMapping(IO &IO, WasmYAML::DylinkSection &Section) { commonSectionMapping(IO, Section); IO.mapRequired("Name", Section.Name); IO.mapRequired("MemorySize", Section.MemorySize); IO.mapRequired("MemoryAlignment", Section.MemoryAlignment); IO.mapRequired("TableSize", Section.TableSize); IO.mapRequired("TableAlignment", Section.TableAlignment); IO.mapRequired("Needed", Section.Needed); IO.mapOptional("ImportInfo", Section.ImportInfo); IO.mapOptional("ExportInfo", Section.ExportInfo); } static void sectionMapping(IO &IO, WasmYAML::NameSection &Section) { commonSectionMapping(IO, Section); IO.mapRequired("Name", Section.Name); IO.mapOptional("FunctionNames", Section.FunctionNames); IO.mapOptional("GlobalNames", Section.GlobalNames); IO.mapOptional("DataSegmentNames", Section.DataSegmentNames); } static void sectionMapping(IO &IO, WasmYAML::LinkingSection &Section) { commonSectionMapping(IO, Section); IO.mapRequired("Name", Section.Name); IO.mapRequired("Version", Section.Version); IO.mapOptional("SymbolTable", Section.SymbolTable); IO.mapOptional("SegmentInfo", Section.SegmentInfos); IO.mapOptional("InitFunctions", Section.InitFunctions); IO.mapOptional("Comdats", Section.Comdats); } static void sectionMapping(IO &IO, WasmYAML::ProducersSection &Section) { commonSectionMapping(IO, Section); IO.mapRequired("Name", Section.Name); IO.mapOptional("Languages", Section.Languages); IO.mapOptional("Tools", Section.Tools); IO.mapOptional("SDKs", Section.SDKs); } static void sectionMapping(IO &IO, WasmYAML::TargetFeaturesSection &Section) { commonSectionMapping(IO, Section); IO.mapRequired("Name", Section.Name); IO.mapRequired("Features", Section.Features); } static void sectionMapping(IO &IO, WasmYAML::CustomSection &Section) { commonSectionMapping(IO, Section); IO.mapRequired("Name", Section.Name); IO.mapRequired("Payload", Section.Payload); } static void sectionMapping(IO &IO, WasmYAML::TypeSection &Section) { commonSectionMapping(IO, Section); IO.mapOptional("Signatures", Section.Signatures); } static void sectionMapping(IO &IO, WasmYAML::ImportSection &Section) { commonSectionMapping(IO, Section); IO.mapOptional("Imports", Section.Imports); } static void sectionMapping(IO &IO, WasmYAML::FunctionSection &Section) { commonSectionMapping(IO, Section); IO.mapOptional("FunctionTypes", Section.FunctionTypes); } static void sectionMapping(IO &IO, WasmYAML::TableSection &Section) { commonSectionMapping(IO, Section); IO.mapOptional("Tables", Section.Tables); } static void sectionMapping(IO &IO, WasmYAML::MemorySection &Section) { commonSectionMapping(IO, Section); IO.mapOptional("Memories", Section.Memories); } static void sectionMapping(IO &IO, WasmYAML::TagSection &Section) { commonSectionMapping(IO, Section); IO.mapOptional("TagTypes", Section.TagTypes); } static void sectionMapping(IO &IO, WasmYAML::GlobalSection &Section) { commonSectionMapping(IO, Section); IO.mapOptional("Globals", Section.Globals); } static void sectionMapping(IO &IO, WasmYAML::ExportSection &Section) { commonSectionMapping(IO, Section); IO.mapOptional("Exports", Section.Exports); } static void sectionMapping(IO &IO, WasmYAML::StartSection &Section) { commonSectionMapping(IO, Section); IO.mapOptional("StartFunction", Section.StartFunction); } static void sectionMapping(IO &IO, WasmYAML::ElemSection &Section) { commonSectionMapping(IO, Section); IO.mapOptional("Segments", Section.Segments); } static void sectionMapping(IO &IO, WasmYAML::CodeSection &Section) { commonSectionMapping(IO, Section); IO.mapRequired("Functions", Section.Functions); } static void sectionMapping(IO &IO, WasmYAML::DataSection &Section) { commonSectionMapping(IO, Section); IO.mapRequired("Segments", Section.Segments); } static void sectionMapping(IO &IO, WasmYAML::DataCountSection &Section) { commonSectionMapping(IO, Section); IO.mapRequired("Count", Section.Count); } void MappingTraits>::mapping( IO &IO, std::unique_ptr &Section) { WasmYAML::SectionType SectionType; if (IO.outputting()) SectionType = Section->Type; else IO.mapRequired("Type", SectionType); switch (SectionType) { case wasm::WASM_SEC_CUSTOM: { StringRef SectionName; if (IO.outputting()) { auto CustomSection = cast(Section.get()); SectionName = CustomSection->Name; } else { IO.mapRequired("Name", SectionName); } if (SectionName == "dylink" || SectionName == "dylink.0") { if (!IO.outputting()) Section.reset(new WasmYAML::DylinkSection()); sectionMapping(IO, *cast(Section.get())); } else if (SectionName == "linking") { if (!IO.outputting()) Section.reset(new WasmYAML::LinkingSection()); sectionMapping(IO, *cast(Section.get())); } else if (SectionName == "name") { if (!IO.outputting()) Section.reset(new WasmYAML::NameSection()); sectionMapping(IO, *cast(Section.get())); } else if (SectionName == "producers") { if (!IO.outputting()) Section.reset(new WasmYAML::ProducersSection()); sectionMapping(IO, *cast(Section.get())); } else if (SectionName == "target_features") { if (!IO.outputting()) Section.reset(new WasmYAML::TargetFeaturesSection()); sectionMapping(IO, *cast(Section.get())); } else { if (!IO.outputting()) Section.reset(new WasmYAML::CustomSection(SectionName)); sectionMapping(IO, *cast(Section.get())); } break; } case wasm::WASM_SEC_TYPE: if (!IO.outputting()) Section.reset(new WasmYAML::TypeSection()); sectionMapping(IO, *cast(Section.get())); break; case wasm::WASM_SEC_IMPORT: if (!IO.outputting()) Section.reset(new WasmYAML::ImportSection()); sectionMapping(IO, *cast(Section.get())); break; case wasm::WASM_SEC_FUNCTION: if (!IO.outputting()) Section.reset(new WasmYAML::FunctionSection()); sectionMapping(IO, *cast(Section.get())); break; case wasm::WASM_SEC_TABLE: if (!IO.outputting()) Section.reset(new WasmYAML::TableSection()); sectionMapping(IO, *cast(Section.get())); break; case wasm::WASM_SEC_MEMORY: if (!IO.outputting()) Section.reset(new WasmYAML::MemorySection()); sectionMapping(IO, *cast(Section.get())); break; case wasm::WASM_SEC_TAG: if (!IO.outputting()) Section.reset(new WasmYAML::TagSection()); sectionMapping(IO, *cast(Section.get())); break; case wasm::WASM_SEC_GLOBAL: if (!IO.outputting()) Section.reset(new WasmYAML::GlobalSection()); sectionMapping(IO, *cast(Section.get())); break; case wasm::WASM_SEC_EXPORT: if (!IO.outputting()) Section.reset(new WasmYAML::ExportSection()); sectionMapping(IO, *cast(Section.get())); break; case wasm::WASM_SEC_START: if (!IO.outputting()) Section.reset(new WasmYAML::StartSection()); sectionMapping(IO, *cast(Section.get())); break; case wasm::WASM_SEC_ELEM: if (!IO.outputting()) Section.reset(new WasmYAML::ElemSection()); sectionMapping(IO, *cast(Section.get())); break; case wasm::WASM_SEC_CODE: if (!IO.outputting()) Section.reset(new WasmYAML::CodeSection()); sectionMapping(IO, *cast(Section.get())); break; case wasm::WASM_SEC_DATA: if (!IO.outputting()) Section.reset(new WasmYAML::DataSection()); sectionMapping(IO, *cast(Section.get())); break; case wasm::WASM_SEC_DATACOUNT: if (!IO.outputting()) Section.reset(new WasmYAML::DataCountSection()); sectionMapping(IO, *cast(Section.get())); break; default: llvm_unreachable("Unknown section type"); } } void ScalarEnumerationTraits::enumeration( IO &IO, WasmYAML::SectionType &Type) { #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_SEC_##X); ECase(CUSTOM); ECase(TYPE); ECase(IMPORT); ECase(FUNCTION); ECase(TABLE); ECase(MEMORY); ECase(GLOBAL); ECase(TAG); ECase(EXPORT); ECase(START); ECase(ELEM); ECase(CODE); ECase(DATA); ECase(DATACOUNT); #undef ECase } void MappingTraits::mapping( IO &IO, WasmYAML::Signature &Signature) { IO.mapRequired("Index", Signature.Index); IO.mapRequired("ParamTypes", Signature.ParamTypes); IO.mapRequired("ReturnTypes", Signature.ReturnTypes); } void MappingTraits::mapping(IO &IO, WasmYAML::Table &Table) { IO.mapRequired("Index", Table.Index); IO.mapRequired("ElemType", Table.ElemType); IO.mapRequired("Limits", Table.TableLimits); } void MappingTraits::mapping(IO &IO, WasmYAML::Function &Function) { IO.mapRequired("Index", Function.Index); IO.mapRequired("Locals", Function.Locals); IO.mapRequired("Body", Function.Body); } void MappingTraits::mapping( IO &IO, WasmYAML::Relocation &Relocation) { IO.mapRequired("Type", Relocation.Type); IO.mapRequired("Index", Relocation.Index); IO.mapRequired("Offset", Relocation.Offset); IO.mapOptional("Addend", Relocation.Addend, 0); } void MappingTraits::mapping( IO &IO, WasmYAML::NameEntry &NameEntry) { IO.mapRequired("Index", NameEntry.Index); IO.mapRequired("Name", NameEntry.Name); } void MappingTraits::mapping( IO &IO, WasmYAML::ProducerEntry &ProducerEntry) { IO.mapRequired("Name", ProducerEntry.Name); IO.mapRequired("Version", ProducerEntry.Version); } void ScalarEnumerationTraits::enumeration( IO &IO, WasmYAML::FeaturePolicyPrefix &Kind) { #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_FEATURE_PREFIX_##X); ECase(USED); ECase(REQUIRED); ECase(DISALLOWED); #undef ECase } void MappingTraits::mapping( IO &IO, WasmYAML::FeatureEntry &FeatureEntry) { IO.mapRequired("Prefix", FeatureEntry.Prefix); IO.mapRequired("Name", FeatureEntry.Name); } void MappingTraits::mapping( IO &IO, WasmYAML::SegmentInfo &SegmentInfo) { IO.mapRequired("Index", SegmentInfo.Index); IO.mapRequired("Name", SegmentInfo.Name); IO.mapRequired("Alignment", SegmentInfo.Alignment); IO.mapRequired("Flags", SegmentInfo.Flags); } void MappingTraits::mapping( IO &IO, WasmYAML::LocalDecl &LocalDecl) { IO.mapRequired("Type", LocalDecl.Type); IO.mapRequired("Count", LocalDecl.Count); } void MappingTraits::mapping(IO &IO, WasmYAML::Limits &Limits) { IO.mapOptional("Flags", Limits.Flags, 0); IO.mapRequired("Minimum", Limits.Minimum); if (!IO.outputting() || Limits.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX) IO.mapOptional("Maximum", Limits.Maximum); } void MappingTraits::mapping( IO &IO, WasmYAML::ElemSegment &Segment) { IO.mapOptional("Flags", Segment.Flags, 0); if (!IO.outputting() || Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER) IO.mapOptional("TableNumber", Segment.TableNumber); if (!IO.outputting() || Segment.Flags & wasm::WASM_ELEM_SEGMENT_MASK_HAS_ELEM_KIND) IO.mapOptional("ElemKind", Segment.ElemKind); // TODO: Omit "offset" for passive segments? It's neither meaningful nor // encoded. IO.mapRequired("Offset", Segment.Offset); IO.mapRequired("Functions", Segment.Functions); } void MappingTraits::mapping(IO &IO, WasmYAML::Import &Import) { IO.mapRequired("Module", Import.Module); IO.mapRequired("Field", Import.Field); IO.mapRequired("Kind", Import.Kind); if (Import.Kind == wasm::WASM_EXTERNAL_FUNCTION || Import.Kind == wasm::WASM_EXTERNAL_TAG) { IO.mapRequired("SigIndex", Import.SigIndex); } else if (Import.Kind == wasm::WASM_EXTERNAL_GLOBAL) { IO.mapRequired("GlobalType", Import.GlobalImport.Type); IO.mapRequired("GlobalMutable", Import.GlobalImport.Mutable); } else if (Import.Kind == wasm::WASM_EXTERNAL_TABLE) { IO.mapRequired("Table", Import.TableImport); } else if (Import.Kind == wasm::WASM_EXTERNAL_MEMORY) { IO.mapRequired("Memory", Import.Memory); } else { llvm_unreachable("unhandled import type"); } } void MappingTraits::mapping(IO &IO, WasmYAML::Export &Export) { IO.mapRequired("Name", Export.Name); IO.mapRequired("Kind", Export.Kind); IO.mapRequired("Index", Export.Index); } void MappingTraits::mapping(IO &IO, WasmYAML::Global &Global) { IO.mapRequired("Index", Global.Index); IO.mapRequired("Type", Global.Type); IO.mapRequired("Mutable", Global.Mutable); IO.mapRequired("InitExpr", Global.Init); } void MappingTraits::mapping(IO &IO, WasmYAML::InitExpr &Expr) { IO.mapOptional("Extended", Expr.Extended, false); if (Expr.Extended) { IO.mapRequired("Body", Expr.Body); } else { WasmYAML::Opcode Op = Expr.Inst.Opcode; IO.mapRequired("Opcode", Op); Expr.Inst.Opcode = Op; switch (Expr.Inst.Opcode) { case wasm::WASM_OPCODE_I32_CONST: IO.mapRequired("Value", Expr.Inst.Value.Int32); break; case wasm::WASM_OPCODE_I64_CONST: IO.mapRequired("Value", Expr.Inst.Value.Int64); break; case wasm::WASM_OPCODE_F32_CONST: IO.mapRequired("Value", Expr.Inst.Value.Float32); break; case wasm::WASM_OPCODE_F64_CONST: IO.mapRequired("Value", Expr.Inst.Value.Float64); break; case wasm::WASM_OPCODE_GLOBAL_GET: IO.mapRequired("Index", Expr.Inst.Value.Global); break; case wasm::WASM_OPCODE_REF_NULL: { WasmYAML::ValueType Ty = wasm::WASM_TYPE_EXTERNREF; IO.mapRequired("Type", Ty); break; } } } } void MappingTraits::mapping( IO &IO, WasmYAML::DataSegment &Segment) { IO.mapOptional("SectionOffset", Segment.SectionOffset); IO.mapRequired("InitFlags", Segment.InitFlags); if (Segment.InitFlags & wasm::WASM_DATA_SEGMENT_HAS_MEMINDEX) { IO.mapRequired("MemoryIndex", Segment.MemoryIndex); } else { Segment.MemoryIndex = 0; } if ((Segment.InitFlags & wasm::WASM_DATA_SEGMENT_IS_PASSIVE) == 0) { IO.mapRequired("Offset", Segment.Offset); } else { Segment.Offset.Inst.Opcode = wasm::WASM_OPCODE_I32_CONST; Segment.Offset.Inst.Value.Int32 = 0; } IO.mapRequired("Content", Segment.Content); } void MappingTraits::mapping( IO &IO, WasmYAML::InitFunction &Init) { IO.mapRequired("Priority", Init.Priority); IO.mapRequired("Symbol", Init.Symbol); } void ScalarEnumerationTraits::enumeration( IO &IO, WasmYAML::ComdatKind &Kind) { #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_COMDAT_##X); ECase(FUNCTION); ECase(DATA); ECase(SECTION); #undef ECase } void MappingTraits::mapping( IO &IO, WasmYAML::ComdatEntry &ComdatEntry) { IO.mapRequired("Kind", ComdatEntry.Kind); IO.mapRequired("Index", ComdatEntry.Index); } void MappingTraits::mapping(IO &IO, WasmYAML::Comdat &Comdat) { IO.mapRequired("Name", Comdat.Name); IO.mapRequired("Entries", Comdat.Entries); } void MappingTraits::mapping(IO &IO, WasmYAML::SymbolInfo &Info) { IO.mapRequired("Index", Info.Index); IO.mapRequired("Kind", Info.Kind); if (Info.Kind != wasm::WASM_SYMBOL_TYPE_SECTION) IO.mapRequired("Name", Info.Name); IO.mapRequired("Flags", Info.Flags); if (Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION) { IO.mapRequired("Function", Info.ElementIndex); } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_GLOBAL) { IO.mapRequired("Global", Info.ElementIndex); } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_TABLE) { IO.mapRequired("Table", Info.ElementIndex); } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_TAG) { IO.mapRequired("Tag", Info.ElementIndex); } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_DATA) { if ((Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) { if ((Info.Flags & wasm::WASM_SYMBOL_ABSOLUTE) == 0) { IO.mapRequired("Segment", Info.DataRef.Segment); } IO.mapOptional("Offset", Info.DataRef.Offset, 0u); IO.mapRequired("Size", Info.DataRef.Size); } } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_SECTION) { IO.mapRequired("Section", Info.ElementIndex); } else { llvm_unreachable("unsupported symbol kind"); } } void MappingTraits::mapping( IO &IO, WasmYAML::DylinkImportInfo &Info) { IO.mapRequired("Module", Info.Module); IO.mapRequired("Field", Info.Field); IO.mapRequired("Flags", Info.Flags); } void MappingTraits::mapping( IO &IO, WasmYAML::DylinkExportInfo &Info) { IO.mapRequired("Name", Info.Name); IO.mapRequired("Flags", Info.Flags); } void ScalarBitSetTraits::bitset( IO &IO, WasmYAML::LimitFlags &Value) { #define BCase(X) IO.bitSetCase(Value, #X, wasm::WASM_LIMITS_FLAG_##X) BCase(HAS_MAX); BCase(IS_SHARED); BCase(IS_64); #undef BCase } void ScalarBitSetTraits::bitset( IO &IO, WasmYAML::SegmentFlags &Value) { #define BCase(X) IO.bitSetCase(Value, #X, wasm::WASM_SEG_FLAG_##X) BCase(STRINGS); BCase(TLS); BCase(RETAIN); #undef BCase } void ScalarBitSetTraits::bitset( IO &IO, WasmYAML::SymbolFlags &Value) { #define BCaseMask(M, X) \ IO.maskedBitSetCase(Value, #X, wasm::WASM_SYMBOL_##X, wasm::WASM_SYMBOL_##M) // BCaseMask(BINDING_MASK, BINDING_GLOBAL); BCaseMask(BINDING_MASK, BINDING_WEAK); BCaseMask(BINDING_MASK, BINDING_LOCAL); // BCaseMask(VISIBILITY_MASK, VISIBILITY_DEFAULT); BCaseMask(VISIBILITY_MASK, VISIBILITY_HIDDEN); BCaseMask(UNDEFINED, UNDEFINED); BCaseMask(EXPORTED, EXPORTED); BCaseMask(EXPLICIT_NAME, EXPLICIT_NAME); BCaseMask(NO_STRIP, NO_STRIP); BCaseMask(TLS, TLS); BCaseMask(ABSOLUTE, ABSOLUTE); #undef BCaseMask } void ScalarEnumerationTraits::enumeration( IO &IO, WasmYAML::SymbolKind &Kind) { #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_SYMBOL_TYPE_##X); ECase(FUNCTION); ECase(DATA); ECase(GLOBAL); ECase(TABLE); ECase(SECTION); ECase(TAG); #undef ECase } void ScalarEnumerationTraits::enumeration( IO &IO, WasmYAML::ValueType &Type) { #define CONCAT(X) (uint32_t) wasm::ValType::X #define ECase(X) IO.enumCase(Type, #X, CONCAT(X)); ECase(I32); ECase(I64); ECase(F32); ECase(F64); ECase(V128); ECase(FUNCREF); ECase(EXTERNREF); ECase(EXNREF); ECase(OTHERREF); #undef ECase } void ScalarEnumerationTraits::enumeration( IO &IO, WasmYAML::ExportKind &Kind) { #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_EXTERNAL_##X); ECase(FUNCTION); ECase(TABLE); ECase(MEMORY); ECase(GLOBAL); ECase(TAG); #undef ECase } void ScalarEnumerationTraits::enumeration( IO &IO, WasmYAML::Opcode &Code) { #define ECase(X) IO.enumCase(Code, #X, wasm::WASM_OPCODE_##X); ECase(END); ECase(I32_CONST); ECase(I64_CONST); ECase(F64_CONST); ECase(F32_CONST); ECase(GLOBAL_GET); ECase(REF_NULL); #undef ECase } void ScalarEnumerationTraits::enumeration( IO &IO, WasmYAML::TableType &Type) { #define CONCAT(X) (uint32_t) wasm::ValType::X #define ECase(X) IO.enumCase(Type, #X, CONCAT(X)); ECase(FUNCREF); ECase(EXTERNREF); ECase(EXNREF); ECase(OTHERREF); #undef ECase } void ScalarEnumerationTraits::enumeration( IO &IO, WasmYAML::RelocType &Type) { #define WASM_RELOC(name, value) IO.enumCase(Type, #name, wasm::name); #include "llvm/BinaryFormat/WasmRelocs.def" #undef WASM_RELOC IO.enumFallback(Type); } } // end namespace yaml } // end namespace llvm