mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-26 04:32:44 +01:00
7e35d3e5e5
Summary: This adds support for the 'event section' specified in the exception handling proposal. (This was named 'exception section' first, but later renamed to 'event section' to take possibilities of other kinds of events into consideration. But currently we only store exception info in this section.) The event section is added between the global section and the export section. This is for ease of validation per request of the V8 team. This patch: - Creates the event symbol type, which is a weak symbol - Makes 'throw' instruction take the event symbol '__cpp_exception' - Adds relocation support for events - Adds WasmObjectWriter / WasmObjectFile (Reader) support - Adds obj2yaml / yaml2obj support - Adds '.eventtype' printing support Reviewers: dschuff, sbc100, aardappel Subscribers: jgravelle-google, sunfish, llvm-commits Differential Revision: https://reviews.llvm.org/D54096 llvm-svn: 346825
581 lines
19 KiB
C++
581 lines
19 KiB
C++
//===- yaml2wasm - Convert YAML to a Wasm object file --------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file
|
|
/// The Wasm component of yaml2obj.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
|
|
#include "llvm/ObjectYAML/ObjectYAML.h"
|
|
#include "llvm/Support/Endian.h"
|
|
#include "llvm/Support/LEB128.h"
|
|
|
|
using namespace llvm;
|
|
|
|
/// This parses a yaml stream that represents a Wasm object file.
|
|
/// See docs/yaml2obj for the yaml scheema.
|
|
class WasmWriter {
|
|
public:
|
|
WasmWriter(WasmYAML::Object &Obj) : Obj(Obj) {}
|
|
int writeWasm(raw_ostream &OS);
|
|
|
|
private:
|
|
int writeRelocSection(raw_ostream &OS, WasmYAML::Section &Sec,
|
|
uint32_t SectionIndex);
|
|
|
|
int writeSectionContent(raw_ostream &OS, WasmYAML::CustomSection &Section);
|
|
int writeSectionContent(raw_ostream &OS, WasmYAML::TypeSection &Section);
|
|
int writeSectionContent(raw_ostream &OS, WasmYAML::ImportSection &Section);
|
|
int writeSectionContent(raw_ostream &OS, WasmYAML::FunctionSection &Section);
|
|
int writeSectionContent(raw_ostream &OS, WasmYAML::TableSection &Section);
|
|
int writeSectionContent(raw_ostream &OS, WasmYAML::MemorySection &Section);
|
|
int writeSectionContent(raw_ostream &OS, WasmYAML::GlobalSection &Section);
|
|
int writeSectionContent(raw_ostream &OS, WasmYAML::EventSection &Section);
|
|
int writeSectionContent(raw_ostream &OS, WasmYAML::ExportSection &Section);
|
|
int writeSectionContent(raw_ostream &OS, WasmYAML::StartSection &Section);
|
|
int writeSectionContent(raw_ostream &OS, WasmYAML::ElemSection &Section);
|
|
int writeSectionContent(raw_ostream &OS, WasmYAML::CodeSection &Section);
|
|
int writeSectionContent(raw_ostream &OS, WasmYAML::DataSection &Section);
|
|
|
|
// Custom section types
|
|
int writeSectionContent(raw_ostream &OS, WasmYAML::NameSection &Section);
|
|
int writeSectionContent(raw_ostream &OS, WasmYAML::LinkingSection &Section);
|
|
WasmYAML::Object &Obj;
|
|
uint32_t NumImportedFunctions = 0;
|
|
uint32_t NumImportedGlobals = 0;
|
|
uint32_t NumImportedEvents = 0;
|
|
};
|
|
|
|
static int writeUint64(raw_ostream &OS, uint64_t Value) {
|
|
char Data[sizeof(Value)];
|
|
support::endian::write64le(Data, Value);
|
|
OS.write(Data, sizeof(Data));
|
|
return 0;
|
|
}
|
|
|
|
static int writeUint32(raw_ostream &OS, uint32_t Value) {
|
|
char Data[sizeof(Value)];
|
|
support::endian::write32le(Data, Value);
|
|
OS.write(Data, sizeof(Data));
|
|
return 0;
|
|
}
|
|
|
|
static int writeUint8(raw_ostream &OS, uint8_t Value) {
|
|
char Data[sizeof(Value)];
|
|
memcpy(Data, &Value, sizeof(Data));
|
|
OS.write(Data, sizeof(Data));
|
|
return 0;
|
|
}
|
|
|
|
static int writeStringRef(const StringRef &Str, raw_ostream &OS) {
|
|
encodeULEB128(Str.size(), OS);
|
|
OS << Str;
|
|
return 0;
|
|
}
|
|
|
|
static int writeLimits(const WasmYAML::Limits &Lim, raw_ostream &OS) {
|
|
writeUint8(OS, Lim.Flags);
|
|
encodeULEB128(Lim.Initial, OS);
|
|
if (Lim.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
|
|
encodeULEB128(Lim.Maximum, OS);
|
|
return 0;
|
|
}
|
|
|
|
static int writeInitExpr(const wasm::WasmInitExpr &InitExpr, raw_ostream &OS) {
|
|
writeUint8(OS, InitExpr.Opcode);
|
|
switch (InitExpr.Opcode) {
|
|
case wasm::WASM_OPCODE_I32_CONST:
|
|
encodeSLEB128(InitExpr.Value.Int32, OS);
|
|
break;
|
|
case wasm::WASM_OPCODE_I64_CONST:
|
|
encodeSLEB128(InitExpr.Value.Int64, OS);
|
|
break;
|
|
case wasm::WASM_OPCODE_F32_CONST:
|
|
writeUint32(OS, InitExpr.Value.Float32);
|
|
break;
|
|
case wasm::WASM_OPCODE_F64_CONST:
|
|
writeUint64(OS, InitExpr.Value.Float64);
|
|
break;
|
|
case wasm::WASM_OPCODE_GET_GLOBAL:
|
|
encodeULEB128(InitExpr.Value.Global, OS);
|
|
break;
|
|
default:
|
|
errs() << "Unknown opcode in init_expr: " << InitExpr.Opcode << "\n";
|
|
return 1;
|
|
}
|
|
writeUint8(OS, wasm::WASM_OPCODE_END);
|
|
return 0;
|
|
}
|
|
|
|
class SubSectionWriter {
|
|
raw_ostream &OS;
|
|
std::string OutString;
|
|
raw_string_ostream StringStream;
|
|
|
|
public:
|
|
SubSectionWriter(raw_ostream &OS) : OS(OS), StringStream(OutString) {}
|
|
|
|
void Done() {
|
|
StringStream.flush();
|
|
encodeULEB128(OutString.size(), OS);
|
|
OS << OutString;
|
|
OutString.clear();
|
|
}
|
|
|
|
raw_ostream &GetStream() { return StringStream; }
|
|
};
|
|
|
|
int WasmWriter::writeSectionContent(raw_ostream &OS,
|
|
WasmYAML::LinkingSection &Section) {
|
|
writeStringRef(Section.Name, OS);
|
|
encodeULEB128(Section.Version, OS);
|
|
|
|
SubSectionWriter SubSection(OS);
|
|
|
|
// SYMBOL_TABLE subsection
|
|
if (Section.SymbolTable.size()) {
|
|
writeUint8(OS, wasm::WASM_SYMBOL_TABLE);
|
|
|
|
encodeULEB128(Section.SymbolTable.size(), SubSection.GetStream());
|
|
#ifndef NDEBUG
|
|
uint32_t SymbolIndex = 0;
|
|
#endif
|
|
for (const WasmYAML::SymbolInfo &Info : Section.SymbolTable) {
|
|
assert(Info.Index == SymbolIndex++);
|
|
writeUint8(SubSection.GetStream(), Info.Kind);
|
|
encodeULEB128(Info.Flags, SubSection.GetStream());
|
|
switch (Info.Kind) {
|
|
case wasm::WASM_SYMBOL_TYPE_FUNCTION:
|
|
case wasm::WASM_SYMBOL_TYPE_GLOBAL:
|
|
case wasm::WASM_SYMBOL_TYPE_EVENT:
|
|
encodeULEB128(Info.ElementIndex, SubSection.GetStream());
|
|
if ((Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0)
|
|
writeStringRef(Info.Name, SubSection.GetStream());
|
|
break;
|
|
case wasm::WASM_SYMBOL_TYPE_DATA:
|
|
writeStringRef(Info.Name, SubSection.GetStream());
|
|
if ((Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) {
|
|
encodeULEB128(Info.DataRef.Segment, SubSection.GetStream());
|
|
encodeULEB128(Info.DataRef.Offset, SubSection.GetStream());
|
|
encodeULEB128(Info.DataRef.Size, SubSection.GetStream());
|
|
}
|
|
break;
|
|
case wasm::WASM_SYMBOL_TYPE_SECTION:
|
|
encodeULEB128(Info.ElementIndex, SubSection.GetStream());
|
|
break;
|
|
default:
|
|
llvm_unreachable("unexpected kind");
|
|
}
|
|
}
|
|
|
|
SubSection.Done();
|
|
}
|
|
|
|
// SEGMENT_NAMES subsection
|
|
if (Section.SegmentInfos.size()) {
|
|
writeUint8(OS, wasm::WASM_SEGMENT_INFO);
|
|
encodeULEB128(Section.SegmentInfos.size(), SubSection.GetStream());
|
|
for (const WasmYAML::SegmentInfo &SegmentInfo : Section.SegmentInfos) {
|
|
writeStringRef(SegmentInfo.Name, SubSection.GetStream());
|
|
encodeULEB128(SegmentInfo.Alignment, SubSection.GetStream());
|
|
encodeULEB128(SegmentInfo.Flags, SubSection.GetStream());
|
|
}
|
|
SubSection.Done();
|
|
}
|
|
|
|
// INIT_FUNCS subsection
|
|
if (Section.InitFunctions.size()) {
|
|
writeUint8(OS, wasm::WASM_INIT_FUNCS);
|
|
encodeULEB128(Section.InitFunctions.size(), SubSection.GetStream());
|
|
for (const WasmYAML::InitFunction &Func : Section.InitFunctions) {
|
|
encodeULEB128(Func.Priority, SubSection.GetStream());
|
|
encodeULEB128(Func.Symbol, SubSection.GetStream());
|
|
}
|
|
SubSection.Done();
|
|
}
|
|
|
|
// COMDAT_INFO subsection
|
|
if (Section.Comdats.size()) {
|
|
writeUint8(OS, wasm::WASM_COMDAT_INFO);
|
|
encodeULEB128(Section.Comdats.size(), SubSection.GetStream());
|
|
for (const auto &C : Section.Comdats) {
|
|
writeStringRef(C.Name, SubSection.GetStream());
|
|
encodeULEB128(0, SubSection.GetStream()); // flags for future use
|
|
encodeULEB128(C.Entries.size(), SubSection.GetStream());
|
|
for (const WasmYAML::ComdatEntry &Entry : C.Entries) {
|
|
writeUint8(SubSection.GetStream(), Entry.Kind);
|
|
encodeULEB128(Entry.Index, SubSection.GetStream());
|
|
}
|
|
}
|
|
SubSection.Done();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int WasmWriter::writeSectionContent(raw_ostream &OS,
|
|
WasmYAML::NameSection &Section) {
|
|
writeStringRef(Section.Name, OS);
|
|
if (Section.FunctionNames.size()) {
|
|
writeUint8(OS, wasm::WASM_NAMES_FUNCTION);
|
|
|
|
SubSectionWriter SubSection(OS);
|
|
|
|
encodeULEB128(Section.FunctionNames.size(), SubSection.GetStream());
|
|
for (const WasmYAML::NameEntry &NameEntry : Section.FunctionNames) {
|
|
encodeULEB128(NameEntry.Index, SubSection.GetStream());
|
|
writeStringRef(NameEntry.Name, SubSection.GetStream());
|
|
}
|
|
|
|
SubSection.Done();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int WasmWriter::writeSectionContent(raw_ostream &OS,
|
|
WasmYAML::CustomSection &Section) {
|
|
if (auto S = dyn_cast<WasmYAML::NameSection>(&Section)) {
|
|
if (auto Err = writeSectionContent(OS, *S))
|
|
return Err;
|
|
} else if (auto S = dyn_cast<WasmYAML::LinkingSection>(&Section)) {
|
|
if (auto Err = writeSectionContent(OS, *S))
|
|
return Err;
|
|
} else {
|
|
writeStringRef(Section.Name, OS);
|
|
Section.Payload.writeAsBinary(OS);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int WasmWriter::writeSectionContent(raw_ostream &OS,
|
|
WasmYAML::TypeSection &Section) {
|
|
encodeULEB128(Section.Signatures.size(), OS);
|
|
uint32_t ExpectedIndex = 0;
|
|
for (const WasmYAML::Signature &Sig : Section.Signatures) {
|
|
if (Sig.Index != ExpectedIndex) {
|
|
errs() << "Unexpected type index: " << Sig.Index << "\n";
|
|
return 1;
|
|
}
|
|
++ExpectedIndex;
|
|
writeUint8(OS, Sig.Form);
|
|
encodeULEB128(Sig.ParamTypes.size(), OS);
|
|
for (auto ParamType : Sig.ParamTypes)
|
|
writeUint8(OS, ParamType);
|
|
if (Sig.ReturnType == wasm::WASM_TYPE_NORESULT) {
|
|
encodeULEB128(0, OS);
|
|
} else {
|
|
encodeULEB128(1, OS);
|
|
writeUint8(OS, Sig.ReturnType);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int WasmWriter::writeSectionContent(raw_ostream &OS,
|
|
WasmYAML::ImportSection &Section) {
|
|
encodeULEB128(Section.Imports.size(), OS);
|
|
for (const WasmYAML::Import &Import : Section.Imports) {
|
|
writeStringRef(Import.Module, OS);
|
|
writeStringRef(Import.Field, OS);
|
|
writeUint8(OS, Import.Kind);
|
|
switch (Import.Kind) {
|
|
case wasm::WASM_EXTERNAL_FUNCTION:
|
|
encodeULEB128(Import.SigIndex, OS);
|
|
NumImportedFunctions++;
|
|
break;
|
|
case wasm::WASM_EXTERNAL_GLOBAL:
|
|
writeUint8(OS, Import.GlobalImport.Type);
|
|
writeUint8(OS, Import.GlobalImport.Mutable);
|
|
NumImportedGlobals++;
|
|
break;
|
|
case wasm::WASM_EXTERNAL_EVENT:
|
|
writeUint32(OS, Import.EventImport.Attribute);
|
|
writeUint32(OS, Import.EventImport.SigIndex);
|
|
NumImportedGlobals++;
|
|
break;
|
|
case wasm::WASM_EXTERNAL_MEMORY:
|
|
writeLimits(Import.Memory, OS);
|
|
break;
|
|
case wasm::WASM_EXTERNAL_TABLE:
|
|
writeUint8(OS, Import.TableImport.ElemType);
|
|
writeLimits(Import.TableImport.TableLimits, OS);
|
|
break;
|
|
default:
|
|
errs() << "Unknown import type: " << Import.Kind << "\n";
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int WasmWriter::writeSectionContent(raw_ostream &OS,
|
|
WasmYAML::FunctionSection &Section) {
|
|
encodeULEB128(Section.FunctionTypes.size(), OS);
|
|
for (uint32_t FuncType : Section.FunctionTypes) {
|
|
encodeULEB128(FuncType, OS);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int WasmWriter::writeSectionContent(raw_ostream &OS,
|
|
WasmYAML::ExportSection &Section) {
|
|
encodeULEB128(Section.Exports.size(), OS);
|
|
for (const WasmYAML::Export &Export : Section.Exports) {
|
|
writeStringRef(Export.Name, OS);
|
|
writeUint8(OS, Export.Kind);
|
|
encodeULEB128(Export.Index, OS);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int WasmWriter::writeSectionContent(raw_ostream &OS,
|
|
WasmYAML::StartSection &Section) {
|
|
encodeULEB128(Section.StartFunction, OS);
|
|
return 0;
|
|
}
|
|
|
|
int WasmWriter::writeSectionContent(raw_ostream &OS,
|
|
WasmYAML::TableSection &Section) {
|
|
encodeULEB128(Section.Tables.size(), OS);
|
|
for (auto &Table : Section.Tables) {
|
|
writeUint8(OS, Table.ElemType);
|
|
writeLimits(Table.TableLimits, OS);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int WasmWriter::writeSectionContent(raw_ostream &OS,
|
|
WasmYAML::MemorySection &Section) {
|
|
encodeULEB128(Section.Memories.size(), OS);
|
|
for (const WasmYAML::Limits &Mem : Section.Memories) {
|
|
writeLimits(Mem, OS);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int WasmWriter::writeSectionContent(raw_ostream &OS,
|
|
WasmYAML::GlobalSection &Section) {
|
|
encodeULEB128(Section.Globals.size(), OS);
|
|
uint32_t ExpectedIndex = NumImportedGlobals;
|
|
for (auto &Global : Section.Globals) {
|
|
if (Global.Index != ExpectedIndex) {
|
|
errs() << "Unexpected global index: " << Global.Index << "\n";
|
|
return 1;
|
|
}
|
|
++ExpectedIndex;
|
|
writeUint8(OS, Global.Type);
|
|
writeUint8(OS, Global.Mutable);
|
|
writeInitExpr(Global.InitExpr, OS);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int WasmWriter::writeSectionContent(raw_ostream &OS,
|
|
WasmYAML::EventSection &Section) {
|
|
encodeULEB128(Section.Events.size(), OS);
|
|
uint32_t ExpectedIndex = NumImportedEvents;
|
|
for (auto &Event : Section.Events) {
|
|
if (Event.Index != ExpectedIndex) {
|
|
errs() << "Unexpected event index: " << Event.Index << "\n";
|
|
return 1;
|
|
}
|
|
++ExpectedIndex;
|
|
encodeULEB128(Event.Attribute, OS);
|
|
encodeULEB128(Event.SigIndex, OS);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int WasmWriter::writeSectionContent(raw_ostream &OS,
|
|
WasmYAML::ElemSection &Section) {
|
|
encodeULEB128(Section.Segments.size(), OS);
|
|
for (auto &Segment : Section.Segments) {
|
|
encodeULEB128(Segment.TableIndex, OS);
|
|
writeInitExpr(Segment.Offset, OS);
|
|
|
|
encodeULEB128(Segment.Functions.size(), OS);
|
|
for (auto &Function : Segment.Functions) {
|
|
encodeULEB128(Function, OS);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int WasmWriter::writeSectionContent(raw_ostream &OS,
|
|
WasmYAML::CodeSection &Section) {
|
|
encodeULEB128(Section.Functions.size(), OS);
|
|
uint32_t ExpectedIndex = NumImportedFunctions;
|
|
for (auto &Func : Section.Functions) {
|
|
std::string OutString;
|
|
raw_string_ostream StringStream(OutString);
|
|
if (Func.Index != ExpectedIndex) {
|
|
errs() << "Unexpected function index: " << Func.Index << "\n";
|
|
return 1;
|
|
}
|
|
++ExpectedIndex;
|
|
|
|
encodeULEB128(Func.Locals.size(), StringStream);
|
|
for (auto &LocalDecl : Func.Locals) {
|
|
encodeULEB128(LocalDecl.Count, StringStream);
|
|
writeUint8(StringStream, LocalDecl.Type);
|
|
}
|
|
|
|
Func.Body.writeAsBinary(StringStream);
|
|
|
|
// Write the section size followed by the content
|
|
StringStream.flush();
|
|
encodeULEB128(OutString.size(), OS);
|
|
OS << OutString;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int WasmWriter::writeSectionContent(raw_ostream &OS,
|
|
WasmYAML::DataSection &Section) {
|
|
encodeULEB128(Section.Segments.size(), OS);
|
|
for (auto &Segment : Section.Segments) {
|
|
encodeULEB128(Segment.MemoryIndex, OS);
|
|
writeInitExpr(Segment.Offset, OS);
|
|
encodeULEB128(Segment.Content.binary_size(), OS);
|
|
Segment.Content.writeAsBinary(OS);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int WasmWriter::writeRelocSection(raw_ostream &OS, WasmYAML::Section &Sec,
|
|
uint32_t SectionIndex) {
|
|
switch (Sec.Type) {
|
|
case wasm::WASM_SEC_CODE:
|
|
writeStringRef("reloc.CODE", OS);
|
|
break;
|
|
case wasm::WASM_SEC_DATA:
|
|
writeStringRef("reloc.DATA", OS);
|
|
break;
|
|
case wasm::WASM_SEC_CUSTOM: {
|
|
auto CustomSection = dyn_cast<WasmYAML::CustomSection>(&Sec);
|
|
if (!CustomSection->Name.startswith(".debug_")) {
|
|
llvm_unreachable("not yet implemented (only for debug sections)");
|
|
return 1;
|
|
}
|
|
|
|
writeStringRef(("reloc." + CustomSection->Name).str(), OS);
|
|
break;
|
|
}
|
|
default:
|
|
llvm_unreachable("not yet implemented");
|
|
return 1;
|
|
}
|
|
|
|
encodeULEB128(SectionIndex, OS);
|
|
encodeULEB128(Sec.Relocations.size(), OS);
|
|
|
|
for (auto Reloc : Sec.Relocations) {
|
|
writeUint8(OS, Reloc.Type);
|
|
encodeULEB128(Reloc.Offset, OS);
|
|
encodeULEB128(Reloc.Index, OS);
|
|
switch (Reloc.Type) {
|
|
case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
|
|
case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
|
|
case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
|
|
case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
|
|
case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32:
|
|
encodeULEB128(Reloc.Addend, OS);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int WasmWriter::writeWasm(raw_ostream &OS) {
|
|
// Write headers
|
|
OS.write(wasm::WasmMagic, sizeof(wasm::WasmMagic));
|
|
writeUint32(OS, Obj.Header.Version);
|
|
|
|
// Write each section
|
|
for (const std::unique_ptr<WasmYAML::Section> &Sec : Obj.Sections) {
|
|
encodeULEB128(Sec->Type, OS);
|
|
std::string OutString;
|
|
raw_string_ostream StringStream(OutString);
|
|
if (auto S = dyn_cast<WasmYAML::CustomSection>(Sec.get())) {
|
|
if (auto Err = writeSectionContent(StringStream, *S))
|
|
return Err;
|
|
} else if (auto S = dyn_cast<WasmYAML::TypeSection>(Sec.get())) {
|
|
if (auto Err = writeSectionContent(StringStream, *S))
|
|
return Err;
|
|
} else if (auto S = dyn_cast<WasmYAML::ImportSection>(Sec.get())) {
|
|
if (auto Err = writeSectionContent(StringStream, *S))
|
|
return Err;
|
|
} else if (auto S = dyn_cast<WasmYAML::FunctionSection>(Sec.get())) {
|
|
if (auto Err = writeSectionContent(StringStream, *S))
|
|
return Err;
|
|
} else if (auto S = dyn_cast<WasmYAML::TableSection>(Sec.get())) {
|
|
if (auto Err = writeSectionContent(StringStream, *S))
|
|
return Err;
|
|
} else if (auto S = dyn_cast<WasmYAML::MemorySection>(Sec.get())) {
|
|
if (auto Err = writeSectionContent(StringStream, *S))
|
|
return Err;
|
|
} else if (auto S = dyn_cast<WasmYAML::GlobalSection>(Sec.get())) {
|
|
if (auto Err = writeSectionContent(StringStream, *S))
|
|
return Err;
|
|
} else if (auto S = dyn_cast<WasmYAML::EventSection>(Sec.get())) {
|
|
if (auto Err = writeSectionContent(StringStream, *S))
|
|
return Err;
|
|
} else if (auto S = dyn_cast<WasmYAML::ExportSection>(Sec.get())) {
|
|
if (auto Err = writeSectionContent(StringStream, *S))
|
|
return Err;
|
|
} else if (auto S = dyn_cast<WasmYAML::StartSection>(Sec.get())) {
|
|
if (auto Err = writeSectionContent(StringStream, *S))
|
|
return Err;
|
|
} else if (auto S = dyn_cast<WasmYAML::ElemSection>(Sec.get())) {
|
|
if (auto Err = writeSectionContent(StringStream, *S))
|
|
return Err;
|
|
} else if (auto S = dyn_cast<WasmYAML::CodeSection>(Sec.get())) {
|
|
if (auto Err = writeSectionContent(StringStream, *S))
|
|
return Err;
|
|
} else if (auto S = dyn_cast<WasmYAML::DataSection>(Sec.get())) {
|
|
if (auto Err = writeSectionContent(StringStream, *S))
|
|
return Err;
|
|
} else {
|
|
errs() << "Unknown section type: " << Sec->Type << "\n";
|
|
return 1;
|
|
}
|
|
StringStream.flush();
|
|
|
|
// Write the section size followed by the content
|
|
encodeULEB128(OutString.size(), OS);
|
|
OS << OutString;
|
|
}
|
|
|
|
// write reloc sections for any section that have relocations
|
|
uint32_t SectionIndex = 0;
|
|
for (const std::unique_ptr<WasmYAML::Section> &Sec : Obj.Sections) {
|
|
if (Sec->Relocations.empty()) {
|
|
SectionIndex++;
|
|
continue;
|
|
}
|
|
|
|
writeUint8(OS, wasm::WASM_SEC_CUSTOM);
|
|
std::string OutString;
|
|
raw_string_ostream StringStream(OutString);
|
|
writeRelocSection(StringStream, *Sec, SectionIndex++);
|
|
StringStream.flush();
|
|
|
|
encodeULEB128(OutString.size(), OS);
|
|
OS << OutString;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int yaml2wasm(llvm::WasmYAML::Object &Doc, raw_ostream &Out) {
|
|
WasmWriter Writer(Doc);
|
|
|
|
return Writer.writeWasm(Out);
|
|
}
|