AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

wasm: use strings for section names

Browse Source 
This will require an equivalent sexpr-wasm change.

See:
https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#high-level-structure

R=titzer@chromium.org, binji@chronium.org

Review URL: https://codereview.chromium.org/1765843002

Cr-Commit-Position: refs/heads/master@{#34668}
This commit is contained in:
jfb 2016-03-10 04:36:42 -08:00 committed by Commit bot
parent 4bbd051acc
commit abbdca947f
10 changed files with 797 additions and 470 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/flag-definitions.h
View File

@ -478,6 +478,7 @@ DEFINE_BOOL(turbo_stress_instruction_scheduling, false,
// Flags for native WebAssembly.
DEFINE_BOOL(expose_wasm, false, "expose WASM interface to JavaScript")
DEFINE_BOOL(trace_wasm_encoder, false, "trace encoding of wasm code")
DEFINE_BOOL(trace_wasm_decoder, false, "trace decoding of wasm code")
DEFINE_BOOL(trace_wasm_decode_time, false, "trace decoding time of wasm code")
DEFINE_BOOL(trace_wasm_compiler, false, "trace compiling of wasm code")

1
src/wasm/decoder.h
View File

@ -303,6 +303,7 @@ class Decoder {
Result<T> toResult(T val) {
Result<T> result;
if (error_pc_) {
TRACE("Result error: %s\n", error_msg_.get());
result.error_code = kError;
result.start = start_;
result.error_pc = error_pc_;

159
src/wasm/encoder.cc
View File

@ -16,6 +16,15 @@
#include "src/v8memory.h"
#if DEBUG
#define TRACE(...) \
do { \
if (FLAG_trace_wasm_decoder) PrintF(__VA_ARGS__); \
} while (false)
#else
#define TRACE(...)
#endif
namespace v8 {
namespace internal {
namespace wasm {
@ -41,6 +50,11 @@ void EmitUint32(byte** b, uint32_t x) {
*b += 4;
}
// Sections all start with a size, but it's unknown at the start.
// We generate a large varint which we then fixup later when the size is known.
//
// TODO(jfb) Not strictly necessary since sizes are calculated ahead of time.
const size_t padded_varint = 5;
void EmitVarInt(byte** b, size_t val) {
while (true) {
@ -65,8 +79,37 @@ size_t SizeOfVarInt(size_t value) {
return size;
}
} // namespace
void FixupSection(byte* start, byte* end) {
// Same as EmitVarInt, but fixed-width with zeroes in the MSBs.
size_t val = end - start - padded_varint;
TRACE(" fixup %u\n", (unsigned)val);
for (size_t pos = 0; pos != padded_varint; ++pos) {
size_t next = val >> 7;
byte out = static_cast<byte>(val & 0x7f);
if (pos != padded_varint - 1) {
*(start++) = 0x80 | out;
val = next;
} else {
*(start++) = out;
// TODO(jfb) check that the pre-allocated fixup size isn't overflowed.
}
}
}
// Returns the start of the section, where the section VarInt size is.
byte* EmitSection(WasmSection::Code code, byte** b) {
byte* start = *b;
const char* name = WasmSection::getName(code);
size_t length = WasmSection::getNameLength(code);
TRACE("emit section: %s\n", name);
for (size_t padding = 0; padding != padded_varint; ++padding) {
EmitUint8(b, 0xff); // Will get fixed up later.
}
EmitVarInt(b, length); // Section name string size.
for (size_t i = 0; i != length; ++i) EmitUint8(b, name[i]);
return start;
}
} // namespace
struct WasmFunctionBuilder::Type {
bool param_;
@ -498,57 +541,83 @@ struct Sizes {
body_size += body;
}
void AddSection(size_t size) {
if (size > 0) {
Add(1, 0);
Add(SizeOfVarInt(size), 0);
}
void AddSection(WasmSection::Code code, size_t other_size) {
Add(padded_varint + SizeOfVarInt(WasmSection::getNameLength(code)) +
WasmSection::getNameLength(code),
0);
if (other_size) Add(SizeOfVarInt(other_size), 0);
}
};
WasmModuleIndex* WasmModuleWriter::WriteTo(Zone* zone) const {
Sizes sizes = {0, 0};
sizes.Add(2 * sizeof(uint32_t), 0); // header
sizes.Add(1, 0);
sizes.AddSection(WasmSection::Code::Memory, 0);
sizes.Add(kDeclMemorySize, 0);
TRACE("Size after memory: %u, %u\n", (unsigned)sizes.header_size,
(unsigned)sizes.body_size);
sizes.AddSection(signatures_.size());
for (auto sig : signatures_) {
sizes.Add(1 + SizeOfVarInt(sig->parameter_count()) + sig->parameter_count(),
0);
}
sizes.AddSection(globals_.size());
if (globals_.size() > 0) {
sizes.AddSection(WasmSection::Code::Globals, globals_.size());
/* These globals never have names, so are always 3 bytes. */
sizes.Add(3 * globals_.size(), 0);
TRACE("Size after globals: %u, %u\n", (unsigned)sizes.header_size,
(unsigned)sizes.body_size);
}
sizes.AddSection(functions_.size());
for (auto function : functions_) {
sizes.Add(function->HeaderSize() + function->BodySize(),
function->NameSize());
if (signatures_.size() > 0) {
sizes.AddSection(WasmSection::Code::Signatures, signatures_.size());
for (auto sig : signatures_) {
sizes.Add(
1 + SizeOfVarInt(sig->parameter_count()) + sig->parameter_count(), 0);
}
TRACE("Size after signatures: %u, %u\n", (unsigned)sizes.header_size,
(unsigned)sizes.body_size);
}
if (functions_.size() > 0) {
sizes.AddSection(WasmSection::Code::Functions, functions_.size());
for (auto function : functions_) {
sizes.Add(function->HeaderSize() + function->BodySize(),
function->NameSize());
}
TRACE("Size after functions: %u, %u\n", (unsigned)sizes.header_size,
(unsigned)sizes.body_size);
}
if (start_function_index_ >= 0) {
sizes.Add(1, 0);
sizes.AddSection(WasmSection::Code::StartFunction, 0);
sizes.Add(SizeOfVarInt(start_function_index_), 0);
TRACE("Size after start: %u, %u\n", (unsigned)sizes.header_size,
(unsigned)sizes.body_size);
}
sizes.AddSection(data_segments_.size());
for (auto segment : data_segments_) {
sizes.Add(segment->HeaderSize(), segment->BodySize());
if (data_segments_.size() > 0) {
sizes.AddSection(WasmSection::Code::DataSegments, data_segments_.size());
for (auto segment : data_segments_) {
sizes.Add(segment->HeaderSize(), segment->BodySize());
}
TRACE("Size after data segments: %u, %u\n", (unsigned)sizes.header_size,
(unsigned)sizes.body_size);
}
sizes.AddSection(indirect_functions_.size());
for (auto function_index : indirect_functions_) {
sizes.Add(SizeOfVarInt(function_index), 0);
if (indirect_functions_.size() > 0) {
sizes.AddSection(WasmSection::Code::FunctionTable,
indirect_functions_.size());
for (auto function_index : indirect_functions_) {
sizes.Add(SizeOfVarInt(function_index), 0);
}
TRACE("Size after indirect functions: %u, %u\n",
(unsigned)sizes.header_size, (unsigned)sizes.body_size);
}
if (sizes.body_size > 0) sizes.Add(1, 0);
if (sizes.body_size > 0) {
sizes.AddSection(WasmSection::Code::End, 0);
TRACE("Size after end: %u, %u\n", (unsigned)sizes.header_size,
(unsigned)sizes.body_size);
}
ZoneVector<uint8_t> buffer_vector(sizes.total(), zone);
byte* buffer = &buffer_vector[0];
@ -556,18 +625,23 @@ WasmModuleIndex* WasmModuleWriter::WriteTo(Zone* zone) const {
byte* body = buffer + sizes.header_size;
// -- emit magic -------------------------------------------------------------
TRACE("emit magic\n");
EmitUint32(&header, kWasmMagic);
EmitUint32(&header, kWasmVersion);
// -- emit memory declaration ------------------------------------------------
EmitUint8(&header, kDeclMemory);
EmitVarInt(&header, 16); // min memory size
EmitVarInt(&header, 16); // max memory size
EmitUint8(&header, 0); // memory export
{
byte* section = EmitSection(WasmSection::Code::Memory, &header);
EmitVarInt(&header, 16); // min memory size
EmitVarInt(&header, 16); // max memory size
EmitUint8(&header, 0); // memory export
static_assert(kDeclMemorySize == 3, "memory size must match emit above");
FixupSection(section, header);
}
// -- emit globals -----------------------------------------------------------
if (globals_.size() > 0) {
EmitUint8(&header, kDeclGlobals);
byte* section = EmitSection(WasmSection::Code::Globals, &header);
EmitVarInt(&header, globals_.size());
for (auto global : globals_) {
@ -575,11 +649,12 @@ WasmModuleIndex* WasmModuleWriter::WriteTo(Zone* zone) const {
EmitUint8(&header, WasmOpcodes::MemTypeCodeFor(global.first));
EmitUint8(&header, global.second);
}
FixupSection(section, header);
}
// -- emit signatures --------------------------------------------------------
if (signatures_.size() > 0) {
EmitUint8(&header, kDeclSignatures);
byte* section = EmitSection(WasmSection::Code::Signatures, &header);
EmitVarInt(&header, signatures_.size());
for (FunctionSig* sig : signatures_) {
@ -593,45 +668,53 @@ WasmModuleIndex* WasmModuleWriter::WriteTo(Zone* zone) const {
EmitUint8(&header, WasmOpcodes::LocalTypeCodeFor(sig->GetParam(j)));
}
}
FixupSection(section, header);
}
// -- emit functions ---------------------------------------------------------
if (functions_.size() > 0) {
EmitUint8(&header, kDeclFunctions);
byte* section = EmitSection(WasmSection::Code::Functions, &header);
EmitVarInt(&header, functions_.size());
for (auto func : functions_) {
func->Serialize(buffer, &header, &body);
}
FixupSection(section, header);
}
// -- emit start function index ----------------------------------------------
if (start_function_index_ >= 0) {
EmitUint8(&header, kDeclStartFunction);
byte* section = EmitSection(WasmSection::Code::StartFunction, &header);
EmitVarInt(&header, start_function_index_);
FixupSection(section, header);
}
// -- emit data segments -----------------------------------------------------
if (data_segments_.size() > 0) {
EmitUint8(&header, kDeclDataSegments);
byte* section = EmitSection(WasmSection::Code::DataSegments, &header);
EmitVarInt(&header, data_segments_.size());
for (auto segment : data_segments_) {
segment->Serialize(buffer, &header, &body);
}
FixupSection(section, header);
}
// -- emit function table ----------------------------------------------------
if (indirect_functions_.size() > 0) {
EmitUint8(&header, kDeclFunctionTable);
byte* section = EmitSection(WasmSection::Code::FunctionTable, &header);
EmitVarInt(&header, indirect_functions_.size());
for (auto index : indirect_functions_) {
EmitVarInt(&header, index);
}
FixupSection(section, header);
}
if (sizes.body_size > 0) EmitUint8(&header, kDeclEnd);
if (sizes.body_size > 0) {
byte* section = EmitSection(WasmSection::Code::End, &header);
FixupSection(section, header);
}
return new (zone) WasmModuleIndex(buffer, buffer + sizes.total());
}

134
src/wasm/module-decoder.cc
View File

@ -51,7 +51,7 @@ class ModuleDecoder : public Decoder {
module->mem_external = false;
module->origin = origin_;
bool sections[kMaxModuleSectionCode] = {false};
bool sections[(size_t)WasmSection::Code::Max] = {false};
const byte* pos = pc_;
uint32_t magic_word = consume_u32("wasm magic");
@ -77,33 +77,48 @@ class ModuleDecoder : public Decoder {
// Decode the module sections.
while (pc_ < limit_) {
TRACE("DecodeSection\n");
uint8_t section_u8 = consume_u8("section");
pos = pc_;
if (section_u8 >= kMaxModuleSectionCode) {
int length;
uint32_t section_length = consume_u32v(&length, "section size");
int section_string_leb_length = 0;
uint32_t section_string_length = 0;
WasmSection::Code section = consume_section_name(
&section_string_leb_length, &section_string_length);
uint32_t string_and_leb_length =
section_string_leb_length + section_string_length;
if (string_and_leb_length > section_length) {
error(pos, pos,
"section string of size %u longer than total section bytes %u",
string_and_leb_length, section_length);
break;
}
if (section == WasmSection::Code::Max) {
// Skip unknown section.
int length;
uint32_t section_bytes = consume_u32v(&length, "section size");
consume_bytes(section_bytes);
uint32_t skip = section_length - string_and_leb_length;
TRACE("skipping %u bytes from unknown section\n", skip);
consume_bytes(skip);
continue;
}
// Each section should appear at most once.
auto section = static_cast<WasmSectionDeclCode>(section_u8);
CheckForPreviousSection(sections, section, false);
sections[section] = true;
sections[(size_t)section] = true;
switch (section) {
case kDeclEnd:
case WasmSection::Code::End:
// Terminate section decoding.
limit_ = pc_;
break;
case kDeclMemory:
case WasmSection::Code::Memory:
int length;
module->min_mem_pages = consume_u32v(&length, "min memory");
module->max_mem_pages = consume_u32v(&length, "max memory");
module->mem_export = consume_u8("export memory") != 0;
break;
case kDeclSignatures: {
case WasmSection::Code::Signatures: {
int length;
uint32_t signatures_count = consume_u32v(&length, "signatures count");
module->signatures.reserve(SafeReserve(signatures_count));
@ -117,9 +132,10 @@ class ModuleDecoder : public Decoder {
}
break;
}
case kDeclFunctionSignatures: {
case WasmSection::Code::FunctionSignatures: {
// Functions require a signature table first.
CheckForPreviousSection(sections, kDeclSignatures, true);
CheckForPreviousSection(sections, WasmSection::Code::Signatures,
true);
int length;
uint32_t functions_count = consume_u32v(&length, "functions count");
module->functions.reserve(SafeReserve(functions_count));
@ -131,9 +147,10 @@ class ModuleDecoder : public Decoder {
}
break;
}
case kDeclFunctionBodies: {
case WasmSection::Code::FunctionBodies: {
// Function bodies should follow signatures.
CheckForPreviousSection(sections, kDeclFunctionSignatures, true);
CheckForPreviousSection(sections,
WasmSection::Code::FunctionSignatures, true);
int length;
const byte* pos = pc_;
uint32_t functions_count = consume_u32v(&length, "functions count");
@ -159,9 +176,10 @@ class ModuleDecoder : public Decoder {
}
break;
}
case kDeclFunctions: {
case WasmSection::Code::Functions: {
// Functions require a signature table first.
CheckForPreviousSection(sections, kDeclSignatures, true);
CheckForPreviousSection(sections, WasmSection::Code::Signatures,
true);
int length;
uint32_t functions_count = consume_u32v(&length, "functions count");
module->functions.reserve(SafeReserve(functions_count));
@ -194,9 +212,10 @@ class ModuleDecoder : public Decoder {
}
break;
}
case kDeclNames: {
case WasmSection::Code::Names: {
// Names correspond to functions.
CheckForPreviousSection(sections, kDeclFunctionSignatures, true);
CheckForPreviousSection(sections,
WasmSection::Code::FunctionSignatures, true);
int length;
const byte* pos = pc_;
uint32_t functions_count = consume_u32v(&length, "functions count");
@ -223,7 +242,7 @@ class ModuleDecoder : public Decoder {
}
break;
}
case kDeclGlobals: {
case WasmSection::Code::Globals: {
int length;
uint32_t globals_count = consume_u32v(&length, "globals count");
module->globals.reserve(SafeReserve(globals_count));
@ -238,7 +257,7 @@ class ModuleDecoder : public Decoder {
}
break;
}
case kDeclDataSegments: {
case WasmSection::Code::DataSegments: {
int length;
uint32_t data_segments_count =
consume_u32v(&length, "data segments count");
@ -254,7 +273,7 @@ class ModuleDecoder : public Decoder {
}
break;
}
case kDeclFunctionTable: {
case WasmSection::Code::FunctionTable: {
// An indirect function table requires functions first.
CheckForFunctions(module, section);
int length;
@ -275,7 +294,7 @@ class ModuleDecoder : public Decoder {
}
break;
}
case kDeclStartFunction: {
case WasmSection::Code::StartFunction: {
// Declares a start function for a module.
CheckForFunctions(module, section);
if (module->start_function_index >= 0) {
@ -291,9 +310,10 @@ class ModuleDecoder : public Decoder {
}
break;
}
case kDeclImportTable: {
case WasmSection::Code::ImportTable: {
// Declares an import table.
CheckForPreviousSection(sections, kDeclSignatures, true);
CheckForPreviousSection(sections, WasmSection::Code::Signatures,
true);
int length;
uint32_t import_table_count =
consume_u32v(&length, "import table count");
@ -319,7 +339,7 @@ class ModuleDecoder : public Decoder {
}
break;
}
case kDeclExportTable: {
case WasmSection::Code::ExportTable: {
// Declares an export table.
CheckForFunctions(module, section);
int length;
@ -341,7 +361,7 @@ class ModuleDecoder : public Decoder {
}
break;
}
case kMaxModuleSectionCode:
case WasmSection::Code::Max:
UNREACHABLE(); // Already skipped unknown sections.
}
}
@ -355,41 +375,23 @@ class ModuleDecoder : public Decoder {
return count < kMaxReserve ? count : kMaxReserve;
}
const char* SectionName(WasmSectionDeclCode section) {
switch (section) {
case kDeclMemory:
return "memory";
case kDeclSignatures:
return "signatures";
case kDeclFunctions:
return "function declaration";
case kDeclGlobals:
return "global variable";
case kDeclDataSegments:
return "data segment";
case kDeclFunctionTable:
return "function table";
default:
return "";
}
}
void CheckForFunctions(WasmModule* module, WasmSectionDeclCode section) {
void CheckForFunctions(WasmModule* module, WasmSection::Code section) {
if (module->functions.size() == 0) {
error(pc_ - 1, nullptr, "functions must appear before section %s",
SectionName(section));
WasmSection::getName(section));
}
}
void CheckForPreviousSection(bool* sections, WasmSectionDeclCode section,
void CheckForPreviousSection(bool* sections, WasmSection::Code section,
bool present) {
if (section >= kMaxModuleSectionCode) return;
if (sections[section] == present) return;
const char* name = SectionName(section);
if (section >= WasmSection::Code::Max) return;
if (sections[(size_t)section] == present) return;
if (present) {
error(pc_ - 1, nullptr, "required %s section missing", name);
error(pc_ - 1, nullptr, "required %s section missing",
WasmSection::getName(section));
} else {
error(pc_ - 1, nullptr, "%s section already present", name);
error(pc_ - 1, nullptr, "%s section already present",
WasmSection::getName(section));
}
}
@ -606,6 +608,30 @@ class ModuleDecoder : public Decoder {
return func_index;
}
// Reads a section name.
WasmSection::Code consume_section_name(int* string_leb_length,
uint32_t* string_length) {
*string_length = consume_u32v(string_leb_length, "name length");
const byte* start = pc_;
consume_bytes(*string_length);
if (failed()) {
TRACE("Section name of length %u couldn't be read\n", *string_length);
return WasmSection::Code::Max;
}
// TODO(jfb) Linear search, it may be better to do a common-prefix search.
for (WasmSection::Code i = WasmSection::begin(); i != WasmSection::end();
i = WasmSection::next(i)) {
if (WasmSection::getNameLength(i) == *string_length &&
0 == memcmp(WasmSection::getName(i), start, *string_length)) {
return i;
}
}
TRACE("Unknown section: '");
for (uint32_t i = 0; i != *string_length; ++i) TRACE("%c", *(start + i));
TRACE("'\n");
return WasmSection::Code::Max;
}
// Reads a single 8-bit integer, interpreting it as a local type.
LocalType consume_local_type() {
byte val = consume_u8("local type");

30
src/wasm/wasm-module.cc
View File

@ -19,6 +19,36 @@ namespace v8 {
namespace internal {
namespace wasm {
static const char* wasmSections[] = {
#define F(enumerator, string) string,
FOR_EACH_WASM_SECTION_TYPE(F)
#undef F
};
static uint8_t wasmSectionsLengths[]{
#define F(enumerator, string) sizeof(string) - 1,
FOR_EACH_WASM_SECTION_TYPE(F)
#undef F
};
static_assert(sizeof(wasmSections) / sizeof(wasmSections[0]) ==
(size_t)WasmSection::Code::Max,
"expected enum WasmSection::Code to be monotonic from 0");
WasmSection::Code WasmSection::begin() { return (WasmSection::Code)0; }
WasmSection::Code WasmSection::end() { return WasmSection::Code::Max; }
WasmSection::Code WasmSection::next(WasmSection::Code code) {
return (WasmSection::Code)(1 + (uint32_t)code);
}
const char* WasmSection::getName(WasmSection::Code code) {
return wasmSections[(size_t)code];
}
size_t WasmSection::getNameLength(WasmSection::Code code) {
return wasmSectionsLengths[(size_t)code];
}
std::ostream& operator<<(std::ostream& os, const WasmModule& module) {
os << "WASM module with ";
os << (module.min_mem_pages * module.kPageSize) << " min mem";

80
src/wasm/wasm-module.h
View File

@ -29,26 +29,72 @@ const uint32_t kWasmVersion = 0x0a;
// internally V8 uses an enum to handle them.
//
// Entries have the form F(enumerator, string).
#define FOR_EACH_WASM_SECTION_TYPE(F) \
F(kDeclMemory, "memory") \
F(kDeclSignatures, "signatures") \
F(kDeclFunctions, "functions") \
F(kDeclGlobals, "globals") \
F(kDeclDataSegments, "data_segments") \
F(kDeclFunctionTable, "function_table") \
F(kDeclEnd, "end") \
F(kDeclStartFunction, "start_function") \
F(kDeclImportTable, "import_table") \
F(kDeclExportTable, "export_table") \
F(kDeclFunctionSignatures, "function_signatures") \
F(kDeclFunctionBodies, "function_bodies") \
F(kDeclNames, "names")
#define FOR_EACH_WASM_SECTION_TYPE(F) \
F(Memory, "memory") \
F(Signatures, "signatures") \
F(Functions, "functions") \
F(Globals, "globals") \
F(DataSegments, "data_segments") \
F(FunctionTable, "function_table") \
F(End, "end") \
F(StartFunction, "start_function") \
F(ImportTable, "import_table") \
F(ExportTable, "export_table") \
F(FunctionSignatures, "function_signatures") \
F(FunctionBodies, "function_bodies") \
F(Names, "names")
enum WasmSectionDeclCode : uint32_t {
// Contants for the above section types: {LEB128 length, characters...}.
#define WASM_SECTION_MEMORY 6, 'm', 'e', 'm', 'o', 'r', 'y'
#define WASM_SECTION_SIGNATURES \
10, 's', 'i', 'g', 'n', 'a', 't', 'u', 'r', 'e', 's'
#define WASM_SECTION_FUNCTIONS 9, 'f', 'u', 'n', 'c', 't', 'i', 'o', 'n', 's'
#define WASM_SECTION_GLOBALS 7, 'g', 'l', 'o', 'b', 'a', 'l', 's'
#define WASM_SECTION_DATA_SEGMENTS \
13, 'd', 'a', 't', 'a', '_', 's', 'e', 'g', 'm', 'e', 'n', 't', 's'
#define WASM_SECTION_FUNCTION_TABLE \
14, 'f', 'u', 'n', 'c', 't', 'i', 'o', 'n', '_', 't', 'a', 'b', 'l', 'e'
#define WASM_SECTION_END 3, 'e', 'n', 'd'
#define WASM_SECTION_START_FUNCTION \
14, 's', 't', 'a', 'r', 't', '_', 'f', 'u', 'n', 'c', 't', 'i', 'o', 'n'
#define WASM_SECTION_IMPORT_TABLE \
12, 'i', 'm', 'p', 'o', 'r', 't', '_', 't', 'a', 'b', 'l', 'e'
#define WASM_SECTION_EXPORT_TABLE \
12, 'e', 'x', 'p', 'o', 'r', 't', '_', 't', 'a', 'b', 'l', 'e'
#define WASM_SECTION_FUNCTION_SIGNATURES \
19, 'f', 'u', 'n', 'c', 't', 'i', 'o', 'n', '_', 's', 'i', 'g', 'n', 'a', \
't', 'u', 'r', 'e', 's'
#define WASM_SECTION_FUNCTION_BODIES \
15, 'f', 'u', 'n', 'c', 't', 'i', 'o', 'n', '_', 'b', 'o', 'd', 'i', 'e', 's'
#define WASM_SECTION_NAMES 5, 'n', 'a', 'm', 'e', 's'
// Constants for the above section headers' size (LEB128 + characters).
#define WASM_SECTION_MEMORY_SIZE ((size_t)7)
#define WASM_SECTION_SIGNATURES_SIZE ((size_t)11)
#define WASM_SECTION_FUNCTIONS_SIZE ((size_t)10)
#define WASM_SECTION_GLOBALS_SIZE ((size_t)8)
#define WASM_SECTION_DATA_SEGMENTS_SIZE ((size_t)14)
#define WASM_SECTION_FUNCTION_TABLE_SIZE ((size_t)15)
#define WASM_SECTION_END_SIZE ((size_t)4)
#define WASM_SECTION_START_FUNCTION_SIZE ((size_t)15)
#define WASM_SECTION_IMPORT_TABLE_SIZE ((size_t)13)
#define WASM_SECTION_EXPORT_TABLE_SIZE ((size_t)13)
#define WASM_SECTION_FUNCTION_SIGNATURES_SIZE ((size_t)20)
#define WASM_SECTION_FUNCTION_BODIES_SIZE ((size_t)16)
#define WASM_SECTION_NAMES_SIZE ((size_t)6)
struct WasmSection {
enum class Code : uint32_t {
#define F(enumerator, string) enumerator,
FOR_EACH_WASM_SECTION_TYPE(F)
FOR_EACH_WASM_SECTION_TYPE(F)
#undef F
kMaxModuleSectionCode
Max
};
static WasmSection::Code begin();
static WasmSection::Code end();
static WasmSection::Code next(WasmSection::Code code);
static const char* getName(Code code);
static size_t getNameLength(Code code);
};
enum WasmFunctionDeclBit {

18
test/cctest/wasm/test-run-wasm-module.cc
View File

@ -38,15 +38,17 @@ TEST(Run_WasmModule_CallAdd_rev) {
static const byte data[] = {
WASM_MODULE_HEADER,
// sig#0 ------------------------------------------
kDeclSignatures, 2, 0, kLocalI32, // void -> int
2, kLocalI32, kLocalI32, kLocalI32, // int,int -> int
WASM_SECTION_SIGNATURES_SIZE + 7, // Section size.
WASM_SECTION_SIGNATURES, 2, 0, kLocalI32, // void -> int
2, kLocalI32, kLocalI32, kLocalI32, // int,int -> int
// func#0 (main) ----------------------------------
kDeclFunctions, 2, kDeclFunctionExport, 0, 0, // sig index
7, 0, // body size
0, // locals
kExprCallFunction, 1, // --
kExprI8Const, 77, // --
kExprI8Const, 22, // --
WASM_SECTION_FUNCTIONS_SIZE + 24, WASM_SECTION_FUNCTIONS, 2,
kDeclFunctionExport, 0, 0, // sig index
7, 0, // body size
0, // locals
kExprCallFunction, 1, // --
kExprI8Const, 77, // --
kExprI8Const, 22, // --
// func#1 -----------------------------------------
0, // no name, not exported
1, 0, // sig index

7
test/mjsunit/wasm/wasm-constants.js
View File

@ -57,14 +57,19 @@ var kDeclFunctions = 0x02;
var kDeclGlobals = 0x03;
var kDeclDataSegments = 0x04;
var kDeclFunctionTable = 0x05;
var kDeclEnd = 0x06;
var kDeclStartFunction = 0x07;
var kDeclImportTable = 0x08;
var kDeclExportTable = 0x09;
var kDeclEnd = 0x06;
var kDeclFunctionSignatures = 0x0a;
var kDeclFunctionBodies = 0x0b;
var kDeclNames = 0x0c;
var section_names = [
"memory", "signatures", "functions", "globals", "data_segments",
"function_table", "end", "start_function", "import_table", "export_table",
"function_signatures", "function_bodies", "names"];
// Function declaration flags
var kDeclFunctionName = 0x01;
var kDeclFunctionImport = 0x02;

212
test/mjsunit/wasm/wasm-module-builder.js
View File

@ -131,162 +131,184 @@ function emit_bytes(bytes, data) {
}
}
function emit_section(bytes, section_code, content_generator) {
// Start the section in a temporary buffer: its full length isn't know yet.
var tmp_bytes = [];
emit_string(tmp_bytes, section_names[section_code]);
content_generator(tmp_bytes);
// Now that we know the section length, emit it and copy the section.
emit_varint(bytes, tmp_bytes.length);
Array.prototype.push.apply(bytes, tmp_bytes);
}
WasmModuleBuilder.prototype.toArray = function(debug) {
// Add header bytes
var bytes = [];
bytes = bytes.concat([kWasmH0, kWasmH1, kWasmH2, kWasmH3,
kWasmV0, kWasmV1, kWasmV2, kWasmV3]);
var wasm = this;
// Add memory section
if (this.memory != undefined) {
if (wasm.memory != undefined) {
if (debug) print("emitting memory @ " + bytes.length);
emit_u8(bytes, kDeclMemory);
emit_varint(bytes, this.memory.min);
emit_varint(bytes, this.memory.max);
emit_u8(bytes, this.memory.exp ? 1 : 0);
emit_section(bytes, kDeclMemory, function(bytes) {
emit_varint(bytes, wasm.memory.min);
emit_varint(bytes, wasm.memory.max);
emit_u8(bytes, wasm.memory.exp ? 1 : 0);
});
}
// Add signatures section
if (this.signatures.length > 0) {
if (wasm.signatures.length > 0) {
if (debug) print("emitting signatures @ " + bytes.length);
emit_u8(bytes, kDeclSignatures);
emit_varint(bytes, this.signatures.length);
for (sig of this.signatures) {
var params = sig.length - 1;
emit_varint(bytes, params);
for (var j = 0; j < sig.length; j++) {
emit_u8(bytes, sig[j]);
emit_section(bytes, kDeclSignatures, function(bytes) {
emit_varint(bytes, wasm.signatures.length);
for (sig of wasm.signatures) {
var params = sig.length - 1;
emit_varint(bytes, params);
for (var j = 0; j < sig.length; j++) {
emit_u8(bytes, sig[j]);
}
}
}
});
}
// Add imports section
if (this.imports.length > 0) {
if (wasm.imports.length > 0) {
if (debug) print("emitting imports @ " + bytes.length);
emit_u8(bytes, kDeclImportTable);
emit_varint(bytes, this.imports.length);
for (imp of this.imports) {
emit_varint(bytes, imp.sig_index);
emit_string(bytes, imp.module);
emit_string(bytes, imp.name || '');
}
emit_section(bytes, kDeclImportTable, function(bytes) {
emit_varint(bytes, wasm.imports.length);
for (imp of wasm.imports) {
emit_varint(bytes, imp.sig_index);
emit_string(bytes, imp.module);
emit_string(bytes, imp.name || '');
}
});
}
// Add functions section
var names = false;
var exports = 0;
if (this.functions.length > 0) {
if (wasm.functions.length > 0) {
var has_names = false;
// emit function signatures
if (debug) print("emitting function sigs @ " + bytes.length);
emit_u8(bytes, kDeclFunctionSignatures);
emit_varint(bytes, this.functions.length);
for (func of this.functions) {
has_names = has_names || (func.name != undefined &&
func.name.length > 0);
exports += func.exports.length;
emit_section(bytes, kDeclFunctionSignatures, function(bytes) {
emit_varint(bytes, wasm.functions.length);
for (func of wasm.functions) {
has_names = has_names || (func.name != undefined &&
func.name.length > 0);
exports += func.exports.length;
emit_varint(bytes, func.sig_index);
}
emit_varint(bytes, func.sig_index);
}
});
// emit function bodies
if (debug) print("emitting function bodies @ " + bytes.length);
emit_u8(bytes, kDeclFunctionBodies);
emit_varint(bytes, this.functions.length);
for (func of this.functions) {
// Function body length will be patched later.
var local_decls = [];
var l = func.locals;
if (l != undefined) {
var local_decls_count = 0;
if (l.i32_count > 0) {
local_decls.push({count: l.i32_count, type: kAstI32});
}
if (l.i64_count > 0) {
local_decls.push({count: l.i64_count, type: kAstI64});
}
if (l.f32_count > 0) {
local_decls.push({count: l.f32_count, type: kAstF32});
}
if (l.f64_count > 0) {
local_decls.push({count: l.f64_count, type: kAstF64});
}
}
var header = new Array();
emit_section(bytes, kDeclFunctionBodies, function(bytes) {
emit_varint(bytes, wasm.functions.length);
for (func of wasm.functions) {
// Function body length will be patched later.
var local_decls = [];
var l = func.locals;
if (l != undefined) {
var local_decls_count = 0;
if (l.i32_count > 0) {
local_decls.push({count: l.i32_count, type: kAstI32});
}
if (l.i64_count > 0) {
local_decls.push({count: l.i64_count, type: kAstI64});
}
if (l.f32_count > 0) {
local_decls.push({count: l.f32_count, type: kAstF32});
}
if (l.f64_count > 0) {
local_decls.push({count: l.f64_count, type: kAstF64});
}
}
var header = new Array();
emit_varint(header, local_decls.length);
for (decl of local_decls) {
emit_varint(header, decl.count);
emit_u8(header, decl.type);
}
emit_varint(header, local_decls.length);
for (decl of local_decls) {
emit_varint(header, decl.count);
emit_u8(header, decl.type);
}
emit_varint(bytes, header.length + func.body.length);
emit_bytes(bytes, header);
emit_bytes(bytes, func.body);
}
emit_varint(bytes, header.length + func.body.length);
emit_bytes(bytes, header);
emit_bytes(bytes, func.body);
}
});
}
// emit function names
if (has_names) {
if (debug) print("emitting names @ " + bytes.length);
emit_u8(bytes, kDeclNames);
emit_varint(bytes, this.functions.length);
for (func of this.functions) {
var name = func.name == undefined ? "" : func.name;
emit_string(bytes, name);
emit_u8(bytes, 0); // local names count == 0
}
emit_section(bytes, kDeclNames, function(bytes) {
emit_varint(bytes, wasm.functions.length);
for (func of wasm.functions) {
var name = func.name == undefined ? "" : func.name;
emit_string(bytes, name);
emit_u8(bytes, 0); // local names count == 0
}
});
}
// Add start function section.
if (this.start_index != undefined) {
if (wasm.start_index != undefined) {
if (debug) print("emitting start function @ " + bytes.length);
emit_u8(bytes, kDeclStartFunction);
emit_varint(bytes, this.start_index);
emit_section(bytes, kDeclStartFunction, function(bytes) {
emit_varint(bytes, wasm.start_index);
});
}
if (this.function_table.length > 0) {
if (wasm.function_table.length > 0) {
if (debug) print("emitting function table @ " + bytes.length);
emit_u8(bytes, kDeclFunctionTable);
emit_varint(bytes, this.function_table.length);
for (index of this.function_table) {
emit_varint(bytes, index);
}
emit_section(bytes, kDeclFunctionTable, function(bytes) {
emit_varint(bytes, wasm.function_table.length);
for (index of wasm.function_table) {
emit_varint(bytes, index);
}
});
}
if (exports > 0) {
if (debug) print("emitting exports @ " + bytes.length);
emit_u8(bytes, kDeclExportTable);
emit_varint(bytes, exports);
for (func of this.functions) {
for (exp of func.exports) {
emit_varint(bytes, func.index);
emit_string(bytes, exp);
emit_section(bytes, kDeclExportTable, function(bytes) {
emit_varint(bytes, exports);
for (func of wasm.functions) {
for (exp of func.exports) {
emit_varint(bytes, func.index);
emit_string(bytes, exp);
}
}
}
});
}
if (this.data_segments.length > 0) {
if (wasm.data_segments.length > 0) {
if (debug) print("emitting data segments @ " + bytes.length);
emit_u8(bytes, kDeclDataSegments);
emit_varint(bytes, this.data_segments.length);
for (seg of this.data_segments) {
emit_varint(bytes, seg.addr);
emit_varint(bytes, seg.data.length);
emit_bytes(bytes, seg.data);
}
emit_section(bytes, kDeclDataSegments, function(bytes) {
emit_varint(bytes, wasm.data_segments.length);
for (seg of wasm.data_segments) {
emit_varint(bytes, seg.addr);
emit_varint(bytes, seg.data.length);
emit_bytes(bytes, seg.data);
}
});
}
// Emit any explicitly added sections
for (exp of this.explicit) {
for (exp of wasm.explicit) {
if (debug) print("emitting explicit @ " + bytes.length);
emit_bytes(bytes, exp);
}
// End the module.
if (debug) print("emitting end @ " + bytes.length);
emit_u8(bytes, kDeclEnd);
emit_section(bytes, kDeclEnd, function(bytes) {});
return bytes;
}

625
test/unittests/wasm/module-decoder-unittest.cc
View File

File diff suppressed because it is too large Load Diff