diff options
Diffstat (limited to 'deps/v8/src/wasm/wasm-module.h')
| -rw-r--r-- | deps/v8/src/wasm/wasm-module.h | 174 |
1 files changed, 127 insertions, 47 deletions
diff --git a/deps/v8/src/wasm/wasm-module.h b/deps/v8/src/wasm/wasm-module.h index 5f5777cebe..4e5aa78486 100644 --- a/deps/v8/src/wasm/wasm-module.h +++ b/deps/v8/src/wasm/wasm-module.h @@ -22,22 +22,81 @@ namespace wasm { const size_t kMaxModuleSize = 1024 * 1024 * 1024; const size_t kMaxFunctionSize = 128 * 1024; const size_t kMaxStringSize = 256; - -enum WasmSectionDeclCode { - kDeclMemory = 0x00, - kDeclSignatures = 0x01, - kDeclFunctions = 0x02, - kDeclGlobals = 0x03, - kDeclDataSegments = 0x04, - kDeclFunctionTable = 0x05, - kDeclEnd = 0x06, - kDeclStartFunction = 0x07, - kDeclImportTable = 0x08, - kDeclWLL = 0x11, +const uint32_t kWasmMagic = 0x6d736100; +const uint32_t kWasmVersion = 0x0a; + +// WebAssembly sections are named as strings in the binary format, but +// internally V8 uses an enum to handle them. +// +// Entries have the form F(enumerator, string). +#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") + +// 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) +#undef F + 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); }; -static const int kMaxModuleSectionCode = 0x11; - enum WasmFunctionDeclBit { kDeclFunctionName = 0x01, kDeclFunctionImport = 0x02, @@ -47,15 +106,15 @@ enum WasmFunctionDeclBit { // Constants for fixed-size elements within a module. static const size_t kDeclMemorySize = 3; -static const size_t kDeclGlobalSize = 6; static const size_t kDeclDataSegmentSize = 13; // Static representation of a WASM function. struct WasmFunction { FunctionSig* sig; // signature of the function. uint32_t func_index; // index into the function table. - uint16_t sig_index; // index into the signature table. + uint32_t sig_index; // index into the signature table. uint32_t name_offset; // offset in the module bytes of the name, if any. + uint32_t name_length; // length in bytes of the name. uint32_t code_start_offset; // offset in the module bytes of code start. uint32_t code_end_offset; // offset in the module bytes of code end. uint16_t local_i32_count; // number of i32 local variables. @@ -69,14 +128,24 @@ struct WasmFunction { // Static representation of an imported WASM function. struct WasmImport { FunctionSig* sig; // signature of the function. - uint16_t sig_index; // index into the signature table. + uint32_t sig_index; // index into the signature table. uint32_t module_name_offset; // offset in module bytes of the module name. + uint32_t module_name_length; // length in bytes of the module name. uint32_t function_name_offset; // offset in module bytes of the import name. + uint32_t function_name_length; // length in bytes of the import name. +}; + +// Static representation of an exported WASM function. +struct WasmExport { + uint32_t func_index; // index into the function table. + uint32_t name_offset; // offset in module bytes of the name to export. + uint32_t name_length; // length in bytes of the exported name. }; // Static representation of a wasm global variable. struct WasmGlobal { uint32_t name_offset; // offset in the module bytes of the name, if any. + uint32_t name_length; // length in bytes of the global name. MachineType type; // type of the global. uint32_t offset; // offset from beginning of globals area. bool exported; // true if this global is exported. @@ -90,35 +159,46 @@ struct WasmDataSegment { bool init; // true if loaded upon instantiation. }; +enum ModuleOrigin { kWasmOrigin, kAsmJsOrigin }; + // Static representation of a module. struct WasmModule { - static const uint8_t kMinMemSize = 12; // Minimum memory size = 4kb - static const uint8_t kMaxMemSize = 30; // Maximum memory size = 1gb + static const uint32_t kPageSize = 0x10000; // Page size, 64kb. + static const uint32_t kMinMemPages = 1; // Minimum memory size = 64kb + static const uint32_t kMaxMemPages = 16384; // Maximum memory size = 1gb Isolate* shared_isolate; // isolate for storing shared code. const byte* module_start; // starting address for the module bytes. const byte* module_end; // end address for the module bytes. - uint8_t min_mem_size_log2; // minimum size of the memory (log base 2). - uint8_t max_mem_size_log2; // maximum size of the memory (log base 2). + uint32_t min_mem_pages; // minimum size of the memory in 64k pages. + uint32_t max_mem_pages; // maximum size of the memory in 64k pages. bool mem_export; // true if the memory is exported. bool mem_external; // true if the memory is external. int start_function_index; // start function, if any. + ModuleOrigin origin; // origin of the module - std::vector<WasmGlobal>* globals; // globals in this module. - std::vector<FunctionSig*>* signatures; // signatures in this module. - std::vector<WasmFunction>* functions; // functions in this module. - std::vector<WasmDataSegment>* data_segments; // data segments in this module. - std::vector<uint16_t>* function_table; // function table. - std::vector<WasmImport>* import_table; // import table. + std::vector<WasmGlobal> globals; // globals in this module. + std::vector<FunctionSig*> signatures; // signatures in this module. + std::vector<WasmFunction> functions; // functions in this module. + std::vector<WasmDataSegment> data_segments; // data segments in this module. + std::vector<uint16_t> function_table; // function table. + std::vector<WasmImport> import_table; // import table. + std::vector<WasmExport> export_table; // export table. WasmModule(); - ~WasmModule(); - // Get a pointer to a string stored in the module bytes representing a name. - const char* GetName(uint32_t offset) const { - if (offset == 0) return "<?>"; // no name. - CHECK(BoundsCheck(offset, offset + 1)); - return reinterpret_cast<const char*>(module_start + offset); + // Get a string stored in the module bytes representing a name. + WasmName GetName(uint32_t offset, uint32_t length) const { + if (length == 0) return {"<?>", 3}; // no name. + CHECK(BoundsCheck(offset, offset + length)); + return {reinterpret_cast<const char*>(module_start + offset), length}; + } + + // Get a string stored in the module bytes representing a name. + WasmName GetNameOrNull(uint32_t offset, uint32_t length) const { + if (length == 0) return {NULL, 0}; // no name. + CHECK(BoundsCheck(offset, offset + length)); + return {reinterpret_cast<const char*>(module_start + offset), length}; } // Checks the given offset range is contained within the module bytes. @@ -141,8 +221,8 @@ struct WasmModuleInstance { Handle<JSArrayBuffer> mem_buffer; // Handle to array buffer of memory. Handle<JSArrayBuffer> globals_buffer; // Handle to array buffer of globals. Handle<FixedArray> function_table; // indirect function table. - std::vector<Handle<Code>>* function_code; // code objects for each function. - std::vector<Handle<Code>>* import_code; // code objects for each import. + std::vector<Handle<Code>> function_code; // code objects for each function. + std::vector<Handle<Code>> import_code; // code objects for each import. // -- raw memory ------------------------------------------------------------ byte* mem_start; // start of linear memory. size_t mem_size; // size of the linear memory. @@ -152,7 +232,6 @@ struct WasmModuleInstance { explicit WasmModuleInstance(WasmModule* m) : module(m), - function_code(nullptr), mem_start(nullptr), mem_size(0), globals_start(nullptr), @@ -168,41 +247,42 @@ struct ModuleEnv { WasmModule* module; WasmModuleInstance* instance; WasmLinker* linker; - bool asm_js; // true if the module originated from asm.js. + ModuleOrigin origin; bool IsValidGlobal(uint32_t index) { - return module && index < module->globals->size(); + return module && index < module->globals.size(); } bool IsValidFunction(uint32_t index) { - return module && index < module->functions->size(); + return module && index < module->functions.size(); } bool IsValidSignature(uint32_t index) { - return module && index < module->signatures->size(); + return module && index < module->signatures.size(); } bool IsValidImport(uint32_t index) { - return module && index < module->import_table->size(); + return module && index < module->import_table.size(); } MachineType GetGlobalType(uint32_t index) { DCHECK(IsValidGlobal(index)); - return module->globals->at(index).type; + return module->globals[index].type; } FunctionSig* GetFunctionSignature(uint32_t index) { DCHECK(IsValidFunction(index)); - return module->functions->at(index).sig; + return module->functions[index].sig; } FunctionSig* GetImportSignature(uint32_t index) { DCHECK(IsValidImport(index)); - return module->import_table->at(index).sig; + return module->import_table[index].sig; } FunctionSig* GetSignature(uint32_t index) { DCHECK(IsValidSignature(index)); - return module->signatures->at(index); + return module->signatures[index]; } size_t FunctionTableSize() { - return module && module->function_table ? module->function_table->size() - : 0; + return module ? module->function_table.size() : 0; } + bool asm_js() { return origin == kAsmJsOrigin; } + Handle<Code> GetFunctionCode(uint32_t index); Handle<Code> GetImportCode(uint32_t index); Handle<FixedArray> GetFunctionTable(); |