diff options
Diffstat (limited to 'deps/v8/src/wasm/wasm-module-builder.cc')
| -rw-r--r-- | deps/v8/src/wasm/wasm-module-builder.cc | 314 |
1 files changed, 186 insertions, 128 deletions
diff --git a/deps/v8/src/wasm/wasm-module-builder.cc b/deps/v8/src/wasm/wasm-module-builder.cc index eb253219ad..7dd6b1c7b2 100644 --- a/deps/v8/src/wasm/wasm-module-builder.cc +++ b/deps/v8/src/wasm/wasm-module-builder.cc @@ -16,7 +16,7 @@ #include "src/wasm/wasm-module.h" #include "src/wasm/wasm-opcodes.h" -#include "src/common/v8memory.h" +#include "src/base/memory.h" namespace v8 { namespace internal { @@ -26,18 +26,18 @@ namespace { // Emit a section code and the size as a padded varint that can be patched // later. -size_t EmitSection(SectionCode code, ZoneBuffer& buffer) { +size_t EmitSection(SectionCode code, ZoneBuffer* buffer) { // Emit the section code. - buffer.write_u8(code); + buffer->write_u8(code); // Emit a placeholder for the length. - return buffer.reserve_u32v(); + return buffer->reserve_u32v(); } // Patch the size of a section after it's finished. -void FixupSection(ZoneBuffer& buffer, size_t start) { - buffer.patch_u32v(start, static_cast<uint32_t>(buffer.offset() - start - - kPaddedVarInt32Size)); +void FixupSection(ZoneBuffer* buffer, size_t start) { + buffer->patch_u32v(start, static_cast<uint32_t>(buffer->offset() - start - + kPaddedVarInt32Size)); } } // namespace @@ -186,22 +186,22 @@ void WasmFunctionBuilder::DeleteCodeAfter(size_t position) { body_.Truncate(position); } -void WasmFunctionBuilder::WriteSignature(ZoneBuffer& buffer) const { - buffer.write_u32v(signature_index_); +void WasmFunctionBuilder::WriteSignature(ZoneBuffer* buffer) const { + buffer->write_u32v(signature_index_); } -void WasmFunctionBuilder::WriteBody(ZoneBuffer& buffer) const { +void WasmFunctionBuilder::WriteBody(ZoneBuffer* buffer) const { size_t locals_size = locals_.Size(); - buffer.write_size(locals_size + body_.size()); - buffer.EnsureSpace(locals_size); - byte** ptr = buffer.pos_ptr(); + buffer->write_size(locals_size + body_.size()); + buffer->EnsureSpace(locals_size); + byte** ptr = buffer->pos_ptr(); locals_.Emit(*ptr); (*ptr) += locals_size; // UGLY: manual bump of position pointer if (body_.size() > 0) { - size_t base = buffer.offset(); - buffer.write(body_.begin(), body_.size()); + size_t base = buffer->offset(); + buffer->write(body_.begin(), body_.size()); for (DirectCallIndex call : direct_calls_) { - buffer.patch_u32v( + buffer->patch_u32v( base + call.offset, call.direct_index + static_cast<uint32_t>(builder_->function_imports_.size())); @@ -209,29 +209,29 @@ void WasmFunctionBuilder::WriteBody(ZoneBuffer& buffer) const { } } -void WasmFunctionBuilder::WriteAsmWasmOffsetTable(ZoneBuffer& buffer) const { +void WasmFunctionBuilder::WriteAsmWasmOffsetTable(ZoneBuffer* buffer) const { if (asm_func_start_source_position_ == 0 && asm_offsets_.size() == 0) { - buffer.write_size(0); + buffer->write_size(0); return; } size_t locals_enc_size = LEBHelper::sizeof_u32v(locals_.Size()); size_t func_start_size = LEBHelper::sizeof_u32v(asm_func_start_source_position_); - buffer.write_size(asm_offsets_.size() + locals_enc_size + func_start_size); + buffer->write_size(asm_offsets_.size() + locals_enc_size + func_start_size); // Offset of the recorded byte offsets. DCHECK_GE(kMaxUInt32, locals_.Size()); - buffer.write_u32v(static_cast<uint32_t>(locals_.Size())); + buffer->write_u32v(static_cast<uint32_t>(locals_.Size())); // Start position of the function. - buffer.write_u32v(asm_func_start_source_position_); - buffer.write(asm_offsets_.begin(), asm_offsets_.size()); + buffer->write_u32v(asm_func_start_source_position_); + buffer->write(asm_offsets_.begin(), asm_offsets_.size()); } WasmModuleBuilder::WasmModuleBuilder(Zone* zone) : zone_(zone), signatures_(zone), function_imports_(zone), - function_exports_(zone), global_imports_(zone), + exports_(zone), functions_(zone), data_segments_(zone), indirect_functions_(zone), @@ -274,7 +274,10 @@ uint32_t WasmModuleBuilder::AllocateIndirectFunctions(uint32_t count) { if (count > FLAG_wasm_max_table_size - index) { return std::numeric_limits<uint32_t>::max(); } - indirect_functions_.resize(indirect_functions_.size() + count); + DCHECK(max_table_size_ == 0 || + indirect_functions_.size() + count <= max_table_size_); + indirect_functions_.resize(indirect_functions_.size() + count, + WasmElemSegment::kNullIndex); return index; } @@ -283,15 +286,23 @@ void WasmModuleBuilder::SetIndirectFunction(uint32_t indirect, indirect_functions_[indirect] = direct; } +void WasmModuleBuilder::SetMaxTableSize(uint32_t max) { + DCHECK_GE(FLAG_wasm_max_table_size, max); + DCHECK_GE(max, indirect_functions_.size()); + max_table_size_ = max; +} + uint32_t WasmModuleBuilder::AddImport(Vector<const char> name, FunctionSig* sig) { + DCHECK(adding_imports_allowed_); function_imports_.push_back({name, AddSignature(sig)}); return static_cast<uint32_t>(function_imports_.size() - 1); } uint32_t WasmModuleBuilder::AddGlobalImport(Vector<const char> name, - ValueType type) { - global_imports_.push_back({name, ValueTypes::ValueTypeCodeFor(type)}); + ValueType type, bool mutability) { + global_imports_.push_back( + {name, ValueTypes::ValueTypeCodeFor(type), mutability}); return static_cast<uint32_t>(global_imports_.size() - 1); } @@ -300,14 +311,33 @@ void WasmModuleBuilder::MarkStartFunction(WasmFunctionBuilder* function) { } void WasmModuleBuilder::AddExport(Vector<const char> name, - WasmFunctionBuilder* function) { - function_exports_.push_back({name, function->func_index()}); + ImportExportKindCode kind, uint32_t index) { + DCHECK_LE(index, std::numeric_limits<int>::max()); + exports_.push_back({name, kind, static_cast<int>(index)}); +} + +uint32_t WasmModuleBuilder::AddExportedGlobal(ValueType type, bool mutability, + const WasmInitExpr& init, + Vector<const char> name) { + uint32_t index = AddGlobal(type, mutability, init); + AddExport(name, kExternalGlobal, index); + return index; +} + +void WasmModuleBuilder::ExportImportedFunction(Vector<const char> name, + int import_index) { +#if DEBUG + // The size of function_imports_ must not change any more. + adding_imports_allowed_ = false; +#endif + exports_.push_back( + {name, kExternalFunction, + import_index - static_cast<int>(function_imports_.size())}); } -uint32_t WasmModuleBuilder::AddGlobal(ValueType type, bool exported, - bool mutability, +uint32_t WasmModuleBuilder::AddGlobal(ValueType type, bool mutability, const WasmInitExpr& init) { - globals_.push_back({type, exported, mutability, init}); + globals_.push_back({type, mutability, init}); return static_cast<uint32_t>(globals_.size() - 1); } @@ -322,25 +352,25 @@ void WasmModuleBuilder::SetMaxMemorySize(uint32_t value) { void WasmModuleBuilder::SetHasSharedMemory() { has_shared_memory_ = true; } -void WasmModuleBuilder::WriteTo(ZoneBuffer& buffer) const { +void WasmModuleBuilder::WriteTo(ZoneBuffer* buffer) const { // == Emit magic ============================================================= - buffer.write_u32(kWasmMagic); - buffer.write_u32(kWasmVersion); + buffer->write_u32(kWasmMagic); + buffer->write_u32(kWasmVersion); // == Emit signatures ======================================================== if (signatures_.size() > 0) { size_t start = EmitSection(kTypeSectionCode, buffer); - buffer.write_size(signatures_.size()); + buffer->write_size(signatures_.size()); for (FunctionSig* sig : signatures_) { - buffer.write_u8(kWasmFunctionTypeCode); - buffer.write_size(sig->parameter_count()); + buffer->write_u8(kWasmFunctionTypeCode); + buffer->write_size(sig->parameter_count()); for (auto param : sig->parameters()) { - buffer.write_u8(ValueTypes::ValueTypeCodeFor(param)); + buffer->write_u8(ValueTypes::ValueTypeCodeFor(param)); } - buffer.write_size(sig->return_count()); + buffer->write_size(sig->return_count()); for (auto ret : sig->returns()) { - buffer.write_u8(ValueTypes::ValueTypeCodeFor(ret)); + buffer->write_u8(ValueTypes::ValueTypeCodeFor(ret)); } } FixupSection(buffer, start); @@ -349,19 +379,19 @@ void WasmModuleBuilder::WriteTo(ZoneBuffer& buffer) const { // == Emit imports =========================================================== if (global_imports_.size() + function_imports_.size() > 0) { size_t start = EmitSection(kImportSectionCode, buffer); - buffer.write_size(global_imports_.size() + function_imports_.size()); + buffer->write_size(global_imports_.size() + function_imports_.size()); for (auto import : global_imports_) { - buffer.write_u32v(0); // module name (length) - buffer.write_string(import.name); // field name - buffer.write_u8(kExternalGlobal); - buffer.write_u8(import.type_code); - buffer.write_u8(0); // immutable + buffer->write_u32v(0); // module name (length) + buffer->write_string(import.name); // field name + buffer->write_u8(kExternalGlobal); + buffer->write_u8(import.type_code); + buffer->write_u8(import.mutability ? 1 : 0); } for (auto import : function_imports_) { - buffer.write_u32v(0); // module name (length) - buffer.write_string(import.name); // field name - buffer.write_u8(kExternalFunction); - buffer.write_u32v(import.sig_index); + buffer->write_u32v(0); // module name (length) + buffer->write_string(import.name); // field name + buffer->write_u8(kExternalFunction); + buffer->write_u32v(import.sig_index); } FixupSection(buffer, start); } @@ -370,7 +400,7 @@ void WasmModuleBuilder::WriteTo(ZoneBuffer& buffer) const { uint32_t num_function_names = 0; if (functions_.size() > 0) { size_t start = EmitSection(kFunctionSectionCode, buffer); - buffer.write_size(functions_.size()); + buffer->write_size(functions_.size()); for (auto* function : functions_) { function->WriteSignature(buffer); if (!function->name_.empty()) ++num_function_names; @@ -381,28 +411,31 @@ void WasmModuleBuilder::WriteTo(ZoneBuffer& buffer) const { // == emit function table ==================================================== if (indirect_functions_.size() > 0) { size_t start = EmitSection(kTableSectionCode, buffer); - buffer.write_u8(1); // table count - buffer.write_u8(kLocalAnyFunc); - buffer.write_u8(kHasMaximumFlag); - buffer.write_size(indirect_functions_.size()); - buffer.write_size(indirect_functions_.size()); + buffer->write_u8(1); // table count + buffer->write_u8(kLocalFuncRef); + buffer->write_u8(kHasMaximumFlag); + buffer->write_size(indirect_functions_.size()); + size_t max = + max_table_size_ > 0 ? max_table_size_ : indirect_functions_.size(); + DCHECK_GE(max, indirect_functions_.size()); + buffer->write_size(max); FixupSection(buffer, start); } // == emit memory declaration ================================================ { size_t start = EmitSection(kMemorySectionCode, buffer); - buffer.write_u8(1); // memory count + buffer->write_u8(1); // memory count if (has_shared_memory_) { - buffer.write_u8(has_max_memory_size_ ? MemoryFlags::kSharedAndMaximum - : MemoryFlags::kSharedNoMaximum); + buffer->write_u8(has_max_memory_size_ ? MemoryFlags::kSharedAndMaximum + : MemoryFlags::kSharedNoMaximum); } else { - buffer.write_u8(has_max_memory_size_ ? MemoryFlags::kMaximum - : MemoryFlags::kNoMaximum); + buffer->write_u8(has_max_memory_size_ ? MemoryFlags::kMaximum + : MemoryFlags::kNoMaximum); } - buffer.write_u32v(min_memory_size_); + buffer->write_u32v(min_memory_size_); if (has_max_memory_size_) { - buffer.write_u32v(max_memory_size_); + buffer->write_u32v(max_memory_size_); } FixupSection(buffer, start); } @@ -410,76 +443,90 @@ void WasmModuleBuilder::WriteTo(ZoneBuffer& buffer) const { // == Emit globals =========================================================== if (globals_.size() > 0) { size_t start = EmitSection(kGlobalSectionCode, buffer); - buffer.write_size(globals_.size()); + buffer->write_size(globals_.size()); for (auto global : globals_) { - buffer.write_u8(ValueTypes::ValueTypeCodeFor(global.type)); - buffer.write_u8(global.mutability ? 1 : 0); + buffer->write_u8(ValueTypes::ValueTypeCodeFor(global.type)); + buffer->write_u8(global.mutability ? 1 : 0); switch (global.init.kind) { case WasmInitExpr::kI32Const: DCHECK_EQ(kWasmI32, global.type); - buffer.write_u8(kExprI32Const); - buffer.write_i32v(global.init.val.i32_const); + buffer->write_u8(kExprI32Const); + buffer->write_i32v(global.init.val.i32_const); break; case WasmInitExpr::kI64Const: DCHECK_EQ(kWasmI64, global.type); - buffer.write_u8(kExprI64Const); - buffer.write_i64v(global.init.val.i64_const); + buffer->write_u8(kExprI64Const); + buffer->write_i64v(global.init.val.i64_const); break; case WasmInitExpr::kF32Const: DCHECK_EQ(kWasmF32, global.type); - buffer.write_u8(kExprF32Const); - buffer.write_f32(global.init.val.f32_const); + buffer->write_u8(kExprF32Const); + buffer->write_f32(global.init.val.f32_const); break; case WasmInitExpr::kF64Const: DCHECK_EQ(kWasmF64, global.type); - buffer.write_u8(kExprF64Const); - buffer.write_f64(global.init.val.f64_const); + buffer->write_u8(kExprF64Const); + buffer->write_f64(global.init.val.f64_const); break; case WasmInitExpr::kGlobalIndex: - buffer.write_u8(kExprGetGlobal); - buffer.write_u32v(global.init.val.global_index); + buffer->write_u8(kExprGetGlobal); + buffer->write_u32v(global.init.val.global_index); break; default: { // No initializer, emit a default value. switch (global.type) { case kWasmI32: - buffer.write_u8(kExprI32Const); + buffer->write_u8(kExprI32Const); // LEB encoding of 0. - buffer.write_u8(0); + buffer->write_u8(0); break; case kWasmI64: - buffer.write_u8(kExprI64Const); + buffer->write_u8(kExprI64Const); // LEB encoding of 0. - buffer.write_u8(0); + buffer->write_u8(0); break; case kWasmF32: - buffer.write_u8(kExprF32Const); - buffer.write_f32(0.f); + buffer->write_u8(kExprF32Const); + buffer->write_f32(0.f); break; case kWasmF64: - buffer.write_u8(kExprF64Const); - buffer.write_f64(0.); + buffer->write_u8(kExprF64Const); + buffer->write_f64(0.); break; default: UNREACHABLE(); } } } - buffer.write_u8(kExprEnd); + buffer->write_u8(kExprEnd); } FixupSection(buffer, start); } // == emit exports =========================================================== - if (!function_exports_.empty()) { + if (exports_.size() > 0) { size_t start = EmitSection(kExportSectionCode, buffer); - buffer.write_size(function_exports_.size()); - for (auto function_export : function_exports_) { - buffer.write_string(function_export.name); - buffer.write_u8(kExternalFunction); - buffer.write_size(function_export.function_index + - function_imports_.size()); + buffer->write_size(exports_.size()); + for (auto ex : exports_) { + buffer->write_string(ex.name); + buffer->write_u8(ex.kind); + switch (ex.kind) { + case kExternalFunction: + buffer->write_size(ex.index + function_imports_.size()); + break; + case kExternalGlobal: + buffer->write_size(ex.index + global_imports_.size()); + break; + case kExternalMemory: + case kExternalTable: + // The WasmModuleBuilder doesn't support importing tables or memories + // yet, so there is no index offset to add. + buffer->write_size(ex.index); + break; + case kExternalException: + UNREACHABLE(); + } } FixupSection(buffer, start); } @@ -487,22 +534,33 @@ void WasmModuleBuilder::WriteTo(ZoneBuffer& buffer) const { // == emit start function index ============================================== if (start_function_index_ >= 0) { size_t start = EmitSection(kStartSectionCode, buffer); - buffer.write_size(start_function_index_ + function_imports_.size()); + buffer->write_size(start_function_index_ + function_imports_.size()); FixupSection(buffer, start); } // == emit function table elements =========================================== if (indirect_functions_.size() > 0) { size_t start = EmitSection(kElementSectionCode, buffer); - buffer.write_u8(1); // count of entries - buffer.write_u8(0); // table index - buffer.write_u8(kExprI32Const); // offset - buffer.write_u32v(0); - buffer.write_u8(kExprEnd); - buffer.write_size(indirect_functions_.size()); // element count - - for (auto index : indirect_functions_) { - buffer.write_size(index + function_imports_.size()); + buffer->write_u8(1); // count of entries + buffer->write_u8(0); // table index + uint32_t first_element = 0; + while (first_element < indirect_functions_.size() && + indirect_functions_[first_element] == WasmElemSegment::kNullIndex) { + first_element++; + } + uint32_t last_element = + static_cast<uint32_t>(indirect_functions_.size() - 1); + while (last_element >= first_element && + indirect_functions_[last_element] == WasmElemSegment::kNullIndex) { + last_element--; + } + buffer->write_u8(kExprI32Const); // offset + buffer->write_u32v(first_element); + buffer->write_u8(kExprEnd); + uint32_t element_count = last_element - first_element + 1; + buffer->write_size(element_count); + for (uint32_t i = first_element; i <= last_element; i++) { + buffer->write_size(indirect_functions_[i] + function_imports_.size()); } FixupSection(buffer, start); @@ -518,18 +576,18 @@ void WasmModuleBuilder::WriteTo(ZoneBuffer& buffer) const { } if (emit_compilation_hints) { // Emit the section code. - buffer.write_u8(kUnknownSectionCode); + buffer->write_u8(kUnknownSectionCode); // Emit a placeholder for section length. - size_t start = buffer.reserve_u32v(); + size_t start = buffer->reserve_u32v(); // Emit custom section name. - buffer.write_string(CStrVector("compilationHints")); + buffer->write_string(CStrVector("compilationHints")); // Emit hint count. - buffer.write_size(functions_.size()); + buffer->write_size(functions_.size()); // Emit hint bytes. for (auto* fn : functions_) { uint8_t hint_byte = fn->hint_ != kNoCompilationHint ? fn->hint_ : kDefaultCompilationHint; - buffer.write_u8(hint_byte); + buffer->write_u8(hint_byte); } FixupSection(buffer, start); } @@ -537,7 +595,7 @@ void WasmModuleBuilder::WriteTo(ZoneBuffer& buffer) const { // == emit code ============================================================== if (functions_.size() > 0) { size_t start = EmitSection(kCodeSectionCode, buffer); - buffer.write_size(functions_.size()); + buffer->write_size(functions_.size()); for (auto* function : functions_) { function->WriteBody(buffer); } @@ -547,15 +605,15 @@ void WasmModuleBuilder::WriteTo(ZoneBuffer& buffer) const { // == emit data segments ===================================================== if (data_segments_.size() > 0) { size_t start = EmitSection(kDataSectionCode, buffer); - buffer.write_size(data_segments_.size()); + buffer->write_size(data_segments_.size()); for (auto segment : data_segments_) { - buffer.write_u8(0); // linear memory segment - buffer.write_u8(kExprI32Const); // initializer expression for dest - buffer.write_u32v(segment.dest); - buffer.write_u8(kExprEnd); - buffer.write_u32v(static_cast<uint32_t>(segment.data.size())); - buffer.write(&segment.data[0], segment.data.size()); + buffer->write_u8(0); // linear memory segment + buffer->write_u8(kExprI32Const); // initializer expression for dest + buffer->write_u32v(segment.dest); + buffer->write_u8(kExprEnd); + buffer->write_u32v(static_cast<uint32_t>(segment.data.size())); + buffer->write(&segment.data[0], segment.data.size()); } FixupSection(buffer, start); } @@ -563,33 +621,33 @@ void WasmModuleBuilder::WriteTo(ZoneBuffer& buffer) const { // == Emit names ============================================================= if (num_function_names > 0 || !function_imports_.empty()) { // Emit the section code. - buffer.write_u8(kUnknownSectionCode); + buffer->write_u8(kUnknownSectionCode); // Emit a placeholder for the length. - size_t start = buffer.reserve_u32v(); + size_t start = buffer->reserve_u32v(); // Emit the section string. - buffer.write_string(CStrVector("name")); + buffer->write_string(CStrVector("name")); // Emit a subsection for the function names. - buffer.write_u8(NameSectionKindCode::kFunction); + buffer->write_u8(NameSectionKindCode::kFunction); // Emit a placeholder for the subsection length. - size_t functions_start = buffer.reserve_u32v(); + size_t functions_start = buffer->reserve_u32v(); // Emit the function names. // Imports are always named. uint32_t num_imports = static_cast<uint32_t>(function_imports_.size()); - buffer.write_size(num_imports + num_function_names); + buffer->write_size(num_imports + num_function_names); uint32_t function_index = 0; for (; function_index < num_imports; ++function_index) { const WasmFunctionImport* import = &function_imports_[function_index]; DCHECK(!import->name.empty()); - buffer.write_u32v(function_index); - buffer.write_string(import->name); + buffer->write_u32v(function_index); + buffer->write_string(import->name); } if (num_function_names > 0) { for (auto* function : functions_) { DCHECK_EQ(function_index, function->func_index() + function_imports_.size()); if (!function->name_.empty()) { - buffer.write_u32v(function_index); - buffer.write_string(function->name_); + buffer->write_u32v(function_index); + buffer->write_string(function->name_); } ++function_index; } @@ -599,15 +657,15 @@ void WasmModuleBuilder::WriteTo(ZoneBuffer& buffer) const { } } -void WasmModuleBuilder::WriteAsmJsOffsetTable(ZoneBuffer& buffer) const { +void WasmModuleBuilder::WriteAsmJsOffsetTable(ZoneBuffer* buffer) const { // == Emit asm.js offset table =============================================== - buffer.write_size(functions_.size()); + buffer->write_size(functions_.size()); // Emit the offset table per function. for (auto* function : functions_) { function->WriteAsmWasmOffsetTable(buffer); } // Append a 0 to indicate that this is an encoded table. - buffer.write_u8(0); + buffer->write_u8(0); } } // namespace wasm } // namespace internal |