RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-19 19:12:56 +02:00
Code Issues Projects Releases Wiki Activity

[WebAssembly] Factor out WasmTableType in binary format

Browse Source 
This commit factors out a WasmTableType definition from WasmTable, as is
the case for WasmGlobal and other data types.  Also add support for
extracting the SymbolName for a table from the linking section's symbol
table.

Differential Revision: https://reviews.llvm.org/D91849
This commit is contained in:
Andy Wingo 2020-11-25 07:54:31 -08:00 committed by Sam Clegg
parent f72c2ac23b
commit 867314455d
4 changed files with 40 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
include/llvm/BinaryFormat/Wasm.h
View File

@ -67,12 +67,17 @@ struct WasmLimits {
uint64_t Maximum; uint64_t Maximum;
}; };
struct WasmTable { struct WasmTableType {
uint32_t Index;
uint8_t ElemType; uint8_t ElemType;
WasmLimits Limits; WasmLimits Limits;
}; };
struct WasmTable {
uint32_t Index;
WasmTableType Type;
StringRef SymbolName; // from the "linking" section
};
struct WasmInitExpr { struct WasmInitExpr {
uint8_t Opcode; uint8_t Opcode;
union { union {
@ -115,7 +120,7 @@ struct WasmImport {
union { union {
uint32_t SigIndex; uint32_t SigIndex;
WasmGlobalType Global; WasmGlobalType Global;
WasmTable Table; WasmTableType Table;
WasmLimits Memory; WasmLimits Memory;
WasmEventType Event; WasmEventType Event;
}; };

14
lib/MC/WasmObjectWriter.cpp
View File

@ -848,11 +848,11 @@ void WasmObjectWriter::writeTableSection(ArrayRef<wasm::WasmTable> Tables) {
encodeULEB128(Tables.size(), W->OS); encodeULEB128(Tables.size(), W->OS);
for (const wasm::WasmTable &Table : Tables) { for (const wasm::WasmTable &Table : Tables) {
encodeULEB128(Table.ElemType, W->OS); encodeULEB128(Table.Type.ElemType, W->OS);
encodeULEB128(Table.Limits.Flags, W->OS); encodeULEB128(Table.Type.Limits.Flags, W->OS);
encodeULEB128(Table.Limits.Initial, W->OS); encodeULEB128(Table.Type.Limits.Initial, W->OS);
if (Table.Limits.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX) if (Table.Type.Limits.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
encodeULEB128(Table.Limits.Maximum, W->OS); encodeULEB128(Table.Type.Limits.Maximum, W->OS);
} }
endSection(Section); endSection(Section);
} }
@ -1527,10 +1527,10 @@ uint64_t WasmObjectWriter::writeOneObject(MCAssembler &Asm,
if (WS.isDefined()) { if (WS.isDefined()) {
assert(WasmIndices.count(&WS) == 0); assert(WasmIndices.count(&WS) == 0);
wasm::WasmTable Table; wasm::WasmTable Table;
Table.ElemType = static_cast<uint8_t>(WS.getTableType());
Table.Index = NumTableImports + Tables.size(); Table.Index = NumTableImports + Tables.size();
Table.Type.ElemType = static_cast<uint8_t>(WS.getTableType());
// FIXME: Work on custom limits is ongoing // FIXME: Work on custom limits is ongoing
Table.Limits = {wasm::WASM_LIMITS_FLAG_NONE, 0, 0}; Table.Type.Limits = {wasm::WASM_LIMITS_FLAG_NONE, 0, 0};
WasmIndices[&WS] = Table.Index; WasmIndices[&WS] = Table.Index;
Tables.push_back(Table); Tables.push_back(Table);

23
lib/Object/WasmObjectFile.cpp
View File

@ -214,12 +214,11 @@ static wasm::WasmLimits readLimits(WasmObjectFile::ReadContext &Ctx) {
return Result; return Result;
} }
static wasm::WasmTable readTable(WasmObjectFile::ReadContext &Ctx) { static wasm::WasmTableType readTableType(WasmObjectFile::ReadContext &Ctx) {
wasm::WasmTable Table; wasm::WasmTableType TableType;
Table.ElemType = readUint8(Ctx); TableType.ElemType = readUint8(Ctx);
Table.Limits = readLimits(Ctx); TableType.Limits = readLimits(Ctx);
// The caller needs to set Table.Index field for Table return TableType;
return Table;
} }
static Error readSection(WasmSection &Section, WasmObjectFile::ReadContext &Ctx, static Error readSection(WasmSection &Section, WasmObjectFile::ReadContext &Ctx,
@ -597,7 +596,9 @@ Error WasmObjectFile::parseLinkingSectionSymtab(ReadContext &Ctx) {
Info.Name = readString(Ctx); Info.Name = readString(Ctx);
unsigned TableIndex = Info.ElementIndex - NumImportedTables; unsigned TableIndex = Info.ElementIndex - NumImportedTables;
wasm::WasmTable &Table = Tables[TableIndex]; wasm::WasmTable &Table = Tables[TableIndex];
TableType = Table.ElemType; TableType = Table.Type.ElemType;
if (Table.SymbolName.empty())
Table.SymbolName = Info.Name;
} else { } else {
return make_error<GenericBinaryError>("undefined table symbol", return make_error<GenericBinaryError>("undefined table symbol",
object_error::parse_failed); object_error::parse_failed);
@ -1014,8 +1015,7 @@ Error WasmObjectFile::parseImportSection(ReadContext &Ctx) {
HasMemory64 = true; HasMemory64 = true;
break; break;
case wasm::WASM_EXTERNAL_TABLE: { case wasm::WASM_EXTERNAL_TABLE: {
Im.Table = readTable(Ctx); Im.Table = readTableType(Ctx);
Im.Table.Index = NumImportedTables + Tables.size();
NumImportedTables++; NumImportedTables++;
auto ElemType = Im.Table.ElemType; auto ElemType = Im.Table.ElemType;
if (ElemType != wasm::WASM_TYPE_FUNCREF && if (ElemType != wasm::WASM_TYPE_FUNCREF &&
@ -1063,10 +1063,11 @@ Error WasmObjectFile::parseTableSection(ReadContext &Ctx) {
uint32_t Count = readVaruint32(Ctx); uint32_t Count = readVaruint32(Ctx);
Tables.reserve(Count); Tables.reserve(Count);
while (Count--) { while (Count--) {
wasm::WasmTable T = readTable(Ctx); wasm::WasmTable T;
T.Type = readTableType(Ctx);
T.Index = NumImportedTables + Tables.size(); T.Index = NumImportedTables + Tables.size();
Tables.push_back(T); Tables.push_back(T);
auto ElemType = Tables.back().ElemType; auto ElemType = Tables.back().Type.ElemType;
if (ElemType != wasm::WASM_TYPE_FUNCREF && if (ElemType != wasm::WASM_TYPE_FUNCREF &&
ElemType != wasm::WASM_TYPE_EXTERNREF) { ElemType != wasm::WASM_TYPE_EXTERNREF) {
return make_error<GenericBinaryError>("Invalid table element type", return make_error<GenericBinaryError>("Invalid table element type",

25
tools/obj2yaml/wasm2yaml.cpp
View File

@ -31,16 +31,6 @@ public:
} // namespace } // namespace
static WasmYAML::Table makeTable(const wasm::WasmTable &Table) {
WasmYAML::Table T;
T.ElemType = Table.ElemType;
T.TableLimits.Flags = Table.Limits.Flags;
T.TableLimits.Initial = Table.Limits.Initial;
T.TableLimits.Maximum = Table.Limits.Maximum;
T.Index = Table.Index;
return T;
}
static WasmYAML::Limits makeLimits(const wasm::WasmLimits &Limits) { static WasmYAML::Limits makeLimits(const wasm::WasmLimits &Limits) {
WasmYAML::Limits L; WasmYAML::Limits L;
L.Flags = Limits.Flags; L.Flags = Limits.Flags;
@ -49,6 +39,15 @@ static WasmYAML::Limits makeLimits(const wasm::WasmLimits &Limits) {
return L; return L;
} }
static WasmYAML::Table makeTable(uint32_t Index,
const wasm::WasmTableType &Type) {
WasmYAML::Table T;
T.Index = Index;
T.ElemType = Type.ElemType;
T.TableLimits = makeLimits(Type.Limits);
return T;
}
std::unique_ptr<WasmYAML::CustomSection> std::unique_ptr<WasmYAML::CustomSection>
WasmDumper::dumpCustomSection(const WasmSection &WasmSec) { WasmDumper::dumpCustomSection(const WasmSection &WasmSec) {
std::unique_ptr<WasmYAML::CustomSection> CustomSec; std::unique_ptr<WasmYAML::CustomSection> CustomSec;
@ -234,7 +233,9 @@ ErrorOr<WasmYAML::Object *> WasmDumper::dump() {
Im.EventImport.SigIndex = Import.Event.SigIndex; Im.EventImport.SigIndex = Import.Event.SigIndex;
break; break;
case wasm::WASM_EXTERNAL_TABLE: case wasm::WASM_EXTERNAL_TABLE:
Im.TableImport = makeTable(Import.Table); // FIXME: Currently we always output an index of 0 for any imported
// table.
Im.TableImport = makeTable(0, Import.Table);
break; break;
case wasm::WASM_EXTERNAL_MEMORY: case wasm::WASM_EXTERNAL_MEMORY:
Im.Memory = makeLimits(Import.Memory); Im.Memory = makeLimits(Import.Memory);
@ -256,7 +257,7 @@ ErrorOr<WasmYAML::Object *> WasmDumper::dump() {
case wasm::WASM_SEC_TABLE: { case wasm::WASM_SEC_TABLE: {
auto TableSec = std::make_unique<WasmYAML::TableSection>(); auto TableSec = std::make_unique<WasmYAML::TableSection>();
for (const wasm::WasmTable &Table : Obj.tables()) { for (const wasm::WasmTable &Table : Obj.tables()) {
TableSec->Tables.push_back(makeTable(Table)); TableSec->Tables.push_back(makeTable(Table.Index, Table.Type));
} }
S = std::move(TableSec); S = std::move(TableSec);
break; break;