Server : Apache/2.4.6 (CentOS) OpenSSL/1.0.2k-fips PHP/7.4.20 System : Linux st2.domain.com 3.10.0-1127.10.1.el7.x86_64 #1 SMP Wed Jun 3 14:28:03 UTC 2020 x86_64 User : apache ( 48) PHP Version : 7.4.20 Disable Function : NONE Directory : /home/real/node-v13.0.1/deps/v8/src/wasm/ |
// Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/codegen/signature.h"
#include "src/handles/handles.h"
#include "src/init/v8.h"
#include "src/objects/objects-inl.h"
#include "src/zone/zone-containers.h"
#include "src/wasm/function-body-decoder.h"
#include "src/wasm/leb-helper.h"
#include "src/wasm/wasm-constants.h"
#include "src/wasm/wasm-module-builder.h"
#include "src/wasm/wasm-module.h"
#include "src/wasm/wasm-opcodes.h"
#include "src/base/memory.h"
namespace v8 {
namespace internal {
namespace wasm {
namespace {
// Emit a section code and the size as a padded varint that can be patched
// later.
size_t EmitSection(SectionCode code, ZoneBuffer* buffer) {
// Emit the section code.
buffer->write_u8(code);
// Emit a placeholder for the length.
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));
}
} // namespace
WasmFunctionBuilder::WasmFunctionBuilder(WasmModuleBuilder* builder)
: builder_(builder),
locals_(builder->zone()),
signature_index_(0),
func_index_(static_cast<uint32_t>(builder->functions_.size())),
body_(builder->zone(), 256),
i32_temps_(builder->zone()),
i64_temps_(builder->zone()),
f32_temps_(builder->zone()),
f64_temps_(builder->zone()),
direct_calls_(builder->zone()),
asm_offsets_(builder->zone(), 8) {}
void WasmFunctionBuilder::EmitI32V(int32_t val) { body_.write_i32v(val); }
void WasmFunctionBuilder::EmitU32V(uint32_t val) { body_.write_u32v(val); }
void WasmFunctionBuilder::SetSignature(FunctionSig* sig) {
DCHECK(!locals_.has_sig());
locals_.set_sig(sig);
signature_index_ = builder_->AddSignature(sig);
}
uint32_t WasmFunctionBuilder::AddLocal(ValueType type) {
DCHECK(locals_.has_sig());
return locals_.AddLocals(1, type);
}
void WasmFunctionBuilder::EmitGetLocal(uint32_t local_index) {
EmitWithU32V(kExprGetLocal, local_index);
}
void WasmFunctionBuilder::EmitSetLocal(uint32_t local_index) {
EmitWithU32V(kExprSetLocal, local_index);
}
void WasmFunctionBuilder::EmitTeeLocal(uint32_t local_index) {
EmitWithU32V(kExprTeeLocal, local_index);
}
void WasmFunctionBuilder::EmitCode(const byte* code, uint32_t code_size) {
body_.write(code, code_size);
}
void WasmFunctionBuilder::Emit(WasmOpcode opcode) { body_.write_u8(opcode); }
void WasmFunctionBuilder::EmitWithU8(WasmOpcode opcode, const byte immediate) {
body_.write_u8(opcode);
body_.write_u8(immediate);
}
void WasmFunctionBuilder::EmitWithU8U8(WasmOpcode opcode, const byte imm1,
const byte imm2) {
body_.write_u8(opcode);
body_.write_u8(imm1);
body_.write_u8(imm2);
}
void WasmFunctionBuilder::EmitWithI32V(WasmOpcode opcode, int32_t immediate) {
body_.write_u8(opcode);
body_.write_i32v(immediate);
}
void WasmFunctionBuilder::EmitWithU32V(WasmOpcode opcode, uint32_t immediate) {
body_.write_u8(opcode);
body_.write_u32v(immediate);
}
void WasmFunctionBuilder::EmitI32Const(int32_t value) {
EmitWithI32V(kExprI32Const, value);
}
void WasmFunctionBuilder::EmitI64Const(int64_t value) {
body_.write_u8(kExprI64Const);
body_.write_i64v(value);
}
void WasmFunctionBuilder::EmitF32Const(float value) {
body_.write_u8(kExprF32Const);
body_.write_f32(value);
}
void WasmFunctionBuilder::EmitF64Const(double value) {
body_.write_u8(kExprF64Const);
body_.write_f64(value);
}
void WasmFunctionBuilder::EmitDirectCallIndex(uint32_t index) {
DirectCallIndex call;
call.offset = body_.size();
call.direct_index = index;
direct_calls_.push_back(call);
byte placeholder_bytes[kMaxVarInt32Size] = {0};
EmitCode(placeholder_bytes, arraysize(placeholder_bytes));
}
void WasmFunctionBuilder::SetName(Vector<const char> name) { name_ = name; }
void WasmFunctionBuilder::AddAsmWasmOffset(size_t call_position,
size_t to_number_position) {
// We only want to emit one mapping per byte offset.
DCHECK(asm_offsets_.size() == 0 || body_.size() > last_asm_byte_offset_);
DCHECK_LE(body_.size(), kMaxUInt32);
uint32_t byte_offset = static_cast<uint32_t>(body_.size());
asm_offsets_.write_u32v(byte_offset - last_asm_byte_offset_);
last_asm_byte_offset_ = byte_offset;
DCHECK_GE(std::numeric_limits<uint32_t>::max(), call_position);
uint32_t call_position_u32 = static_cast<uint32_t>(call_position);
asm_offsets_.write_i32v(call_position_u32 - last_asm_source_position_);
DCHECK_GE(std::numeric_limits<uint32_t>::max(), to_number_position);
uint32_t to_number_position_u32 = static_cast<uint32_t>(to_number_position);
asm_offsets_.write_i32v(to_number_position_u32 - call_position_u32);
last_asm_source_position_ = to_number_position_u32;
}
void WasmFunctionBuilder::SetAsmFunctionStartPosition(
size_t function_position) {
DCHECK_EQ(0, asm_func_start_source_position_);
DCHECK_GE(std::numeric_limits<uint32_t>::max(), function_position);
uint32_t function_position_u32 = static_cast<uint32_t>(function_position);
// Must be called before emitting any asm.js source position.
DCHECK_EQ(0, asm_offsets_.size());
asm_func_start_source_position_ = function_position_u32;
last_asm_source_position_ = function_position_u32;
}
void WasmFunctionBuilder::SetCompilationHint(
WasmCompilationHintStrategy strategy, WasmCompilationHintTier baseline,
WasmCompilationHintTier top_tier) {
uint8_t hint_byte = static_cast<uint8_t>(strategy) |
static_cast<uint8_t>(baseline) << 2 |
static_cast<uint8_t>(top_tier) << 4;
DCHECK_NE(hint_byte, kNoCompilationHint);
hint_ = hint_byte;
}
void WasmFunctionBuilder::DeleteCodeAfter(size_t position) {
DCHECK_LE(position, body_.size());
body_.Truncate(position);
}
void WasmFunctionBuilder::WriteSignature(ZoneBuffer* buffer) const {
buffer->write_u32v(signature_index_);
}
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();
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());
for (DirectCallIndex call : direct_calls_) {
buffer->patch_u32v(
base + call.offset,
call.direct_index +
static_cast<uint32_t>(builder_->function_imports_.size()));
}
}
}
void WasmFunctionBuilder::WriteAsmWasmOffsetTable(ZoneBuffer* buffer) const {
if (asm_func_start_source_position_ == 0 && asm_offsets_.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);
// Offset of the recorded byte offsets.
DCHECK_GE(kMaxUInt32, 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());
}
WasmModuleBuilder::WasmModuleBuilder(Zone* zone)
: zone_(zone),
signatures_(zone),
function_imports_(zone),
global_imports_(zone),
exports_(zone),
functions_(zone),
tables_(zone),
data_segments_(zone),
indirect_functions_(zone),
globals_(zone),
signature_map_(zone),
start_function_index_(-1),
min_memory_size_(16),
max_memory_size_(0),
has_max_memory_size_(false),
has_shared_memory_(false) {}
WasmFunctionBuilder* WasmModuleBuilder::AddFunction(FunctionSig* sig) {
functions_.push_back(new (zone_) WasmFunctionBuilder(this));
// Add the signature if one was provided here.
if (sig) functions_.back()->SetSignature(sig);
return functions_.back();
}
void WasmModuleBuilder::AddDataSegment(const byte* data, uint32_t size,
uint32_t dest) {
data_segments_.push_back({ZoneVector<byte>(zone()), dest});
ZoneVector<byte>& vec = data_segments_.back().data;
for (uint32_t i = 0; i < size; i++) {
vec.push_back(data[i]);
}
}
uint32_t WasmModuleBuilder::AddSignature(FunctionSig* sig) {
auto sig_entry = signature_map_.find(*sig);
if (sig_entry != signature_map_.end()) return sig_entry->second;
uint32_t index = static_cast<uint32_t>(signatures_.size());
signature_map_.emplace(*sig, index);
signatures_.push_back(sig);
return index;
}
uint32_t WasmModuleBuilder::AllocateIndirectFunctions(uint32_t count) {
DCHECK(allocating_indirect_functions_allowed_);
uint32_t index = static_cast<uint32_t>(indirect_functions_.size());
DCHECK_GE(FLAG_wasm_max_table_size, index);
if (count > FLAG_wasm_max_table_size - index) {
return std::numeric_limits<uint32_t>::max();
}
uint32_t new_size = static_cast<uint32_t>(indirect_functions_.size()) + count;
DCHECK(max_table_size_ == 0 || new_size <= max_table_size_);
indirect_functions_.resize(new_size, WasmElemSegment::kNullIndex);
uint32_t max = max_table_size_ > 0 ? max_table_size_ : new_size;
if (tables_.empty()) {
// This cannot use {AddTable} because that would flip the
// {allocating_indirect_functions_allowed_} flag.
tables_.push_back({kWasmFuncRef, new_size, max, true});
} else {
// There can only be the indirect function table so far, otherwise the
// {allocating_indirect_functions_allowed_} flag would have been false.
DCHECK_EQ(1u, tables_.size());
DCHECK_EQ(kWasmFuncRef, tables_[0].type);
DCHECK(tables_[0].has_maximum);
tables_[0].min_size = new_size;
tables_[0].max_size = max;
}
return index;
}
void WasmModuleBuilder::SetIndirectFunction(uint32_t indirect,
uint32_t direct) {
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;
DCHECK(allocating_indirect_functions_allowed_);
if (!tables_.empty()) {
tables_[0].max_size = max;
}
}
uint32_t WasmModuleBuilder::AddTable(ValueType type, uint32_t min_size) {
#if DEBUG
allocating_indirect_functions_allowed_ = false;
#endif
tables_.push_back({type, min_size, 0, false});
return static_cast<uint32_t>(tables_.size() - 1);
}
uint32_t WasmModuleBuilder::AddTable(ValueType type, uint32_t min_size,
uint32_t max_size) {
#if DEBUG
allocating_indirect_functions_allowed_ = false;
#endif
tables_.push_back({type, min_size, max_size, true});
return static_cast<uint32_t>(tables_.size() - 1);
}
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, bool mutability) {
global_imports_.push_back(
{name, ValueTypes::ValueTypeCodeFor(type), mutability});
return static_cast<uint32_t>(global_imports_.size() - 1);
}
void WasmModuleBuilder::MarkStartFunction(WasmFunctionBuilder* function) {
start_function_index_ = function->func_index();
}
void WasmModuleBuilder::AddExport(Vector<const char> name,
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 mutability,
const WasmInitExpr& init) {
globals_.push_back({type, mutability, init});
return static_cast<uint32_t>(globals_.size() - 1);
}
void WasmModuleBuilder::SetMinMemorySize(uint32_t value) {
min_memory_size_ = value;
}
void WasmModuleBuilder::SetMaxMemorySize(uint32_t value) {
has_max_memory_size_ = true;
max_memory_size_ = value;
}
void WasmModuleBuilder::SetHasSharedMemory() { has_shared_memory_ = true; }
void WasmModuleBuilder::WriteTo(ZoneBuffer* buffer) const {
// == Emit magic =============================================================
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());
for (FunctionSig* sig : signatures_) {
buffer->write_u8(kWasmFunctionTypeCode);
buffer->write_size(sig->parameter_count());
for (auto param : sig->parameters()) {
buffer->write_u8(ValueTypes::ValueTypeCodeFor(param));
}
buffer->write_size(sig->return_count());
for (auto ret : sig->returns()) {
buffer->write_u8(ValueTypes::ValueTypeCodeFor(ret));
}
}
FixupSection(buffer, start);
}
// == 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());
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(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);
}
FixupSection(buffer, start);
}
// == Emit function signatures ===============================================
uint32_t num_function_names = 0;
if (functions_.size() > 0) {
size_t start = EmitSection(kFunctionSectionCode, buffer);
buffer->write_size(functions_.size());
for (auto* function : functions_) {
function->WriteSignature(buffer);
if (!function->name_.empty()) ++num_function_names;
}
FixupSection(buffer, start);
}
// == Emit tables ============================================================
if (tables_.size() > 0) {
size_t start = EmitSection(kTableSectionCode, buffer);
buffer->write_size(tables_.size());
for (const WasmTable& table : tables_) {
buffer->write_u8(ValueTypes::ValueTypeCodeFor(table.type));
buffer->write_u8(table.has_maximum ? kHasMaximumFlag : kNoMaximumFlag);
buffer->write_size(table.min_size);
if (table.has_maximum) buffer->write_size(table.max_size);
}
FixupSection(buffer, start);
}
// == Emit memory declaration ================================================
{
size_t start = EmitSection(kMemorySectionCode, buffer);
buffer->write_u8(1); // memory count
if (has_shared_memory_) {
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_u32v(min_memory_size_);
if (has_max_memory_size_) {
buffer->write_u32v(max_memory_size_);
}
FixupSection(buffer, start);
}
// == Emit globals ===========================================================
if (globals_.size() > 0) {
size_t start = EmitSection(kGlobalSectionCode, buffer);
buffer->write_size(globals_.size());
for (auto global : globals_) {
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);
break;
case WasmInitExpr::kI64Const:
DCHECK_EQ(kWasmI64, global.type);
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);
break;
case WasmInitExpr::kF64Const:
DCHECK_EQ(kWasmF64, global.type);
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);
break;
case WasmInitExpr::kRefNullConst:
buffer->write_u8(kExprRefNull);
break;
case WasmInitExpr::kRefFuncConst:
UNIMPLEMENTED();
break;
case WasmInitExpr::kNone: {
// No initializer, emit a default value.
switch (global.type) {
case kWasmI32:
buffer->write_u8(kExprI32Const);
// LEB encoding of 0.
buffer->write_u8(0);
break;
case kWasmI64:
buffer->write_u8(kExprI64Const);
// LEB encoding of 0.
buffer->write_u8(0);
break;
case kWasmF32:
buffer->write_u8(kExprF32Const);
buffer->write_f32(0.f);
break;
case kWasmF64:
buffer->write_u8(kExprF64Const);
buffer->write_f64(0.);
break;
default:
UNREACHABLE();
}
}
}
buffer->write_u8(kExprEnd);
}
FixupSection(buffer, start);
}
// == emit exports ===========================================================
if (exports_.size() > 0) {
size_t start = EmitSection(kExportSectionCode, buffer);
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);
}
// == emit start function index ==============================================
if (start_function_index_ >= 0) {
size_t start = EmitSection(kStartSectionCode, buffer);
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
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);
}
// == emit compilation hints section =========================================
bool emit_compilation_hints = false;
for (auto* fn : functions_) {
if (fn->hint_ != kNoCompilationHint) {
emit_compilation_hints = true;
break;
}
}
if (emit_compilation_hints) {
// Emit the section code.
buffer->write_u8(kUnknownSectionCode);
// Emit a placeholder for section length.
size_t start = buffer->reserve_u32v();
// Emit custom section name.
buffer->write_string(CStrVector("compilationHints"));
// Emit hint count.
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);
}
FixupSection(buffer, start);
}
// == emit code ==============================================================
if (functions_.size() > 0) {
size_t start = EmitSection(kCodeSectionCode, buffer);
buffer->write_size(functions_.size());
for (auto* function : functions_) {
function->WriteBody(buffer);
}
FixupSection(buffer, start);
}
// == emit data segments =====================================================
if (data_segments_.size() > 0) {
size_t start = EmitSection(kDataSectionCode, buffer);
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());
}
FixupSection(buffer, start);
}
// == Emit names =============================================================
if (num_function_names > 0 || !function_imports_.empty()) {
// Emit the section code.
buffer->write_u8(kUnknownSectionCode);
// Emit a placeholder for the length.
size_t start = buffer->reserve_u32v();
// Emit the section string.
buffer->write_string(CStrVector("name"));
// Emit a subsection for the function names.
buffer->write_u8(NameSectionKindCode::kFunction);
// Emit a placeholder for the subsection length.
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);
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);
}
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_);
}
++function_index;
}
}
FixupSection(buffer, functions_start);
FixupSection(buffer, start);
}
}
void WasmModuleBuilder::WriteAsmJsOffsetTable(ZoneBuffer* buffer) const {
// == Emit asm.js offset table ===============================================
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);
}
} // namespace wasm
} // namespace internal
} // namespace v8