diff options
Diffstat (limited to 'src/binary-reader-interpreter.c')
| -rw-r--r-- | src/binary-reader-interpreter.c | 1106 |
1 files changed, 553 insertions, 553 deletions
diff --git a/src/binary-reader-interpreter.c b/src/binary-reader-interpreter.c index 891cc7c6..c27e440b 100644 --- a/src/binary-reader-interpreter.c +++ b/src/binary-reader-interpreter.c @@ -36,8 +36,8 @@ #define CHECK_RESULT(expr) \ do { \ - if (WASM_FAILED(expr)) \ - return WASM_ERROR; \ + if (WABT_FAILED(expr)) \ + return WABT_ERROR; \ } while (0) #define CHECK_DEPTH(ctx, depth) \ @@ -45,7 +45,7 @@ if ((depth) >= (ctx)->label_stack.size) { \ print_error((ctx), "invalid depth: %d (max %" PRIzd ")", (depth), \ ((ctx)->label_stack.size)); \ - return WASM_ERROR; \ + return WABT_ERROR; \ } \ } while (0) @@ -56,7 +56,7 @@ if ((local_index) >= max_local_index) { \ print_error((ctx), "invalid local_index: %d (max %d)", (local_index), \ max_local_index); \ - return WASM_ERROR; \ + return WABT_ERROR; \ } \ } while (0) @@ -66,7 +66,7 @@ if ((global_index) >= max_global_index) { \ print_error((ctx), "invalid global_index: %d (max %d)", (global_index), \ max_global_index); \ - return WASM_ERROR; \ + return WABT_ERROR; \ } \ } while (0) @@ -76,11 +76,11 @@ #define RETURN_OK_IF_TOP_TYPE_IS_ANY(ctx) \ if (top_type_is_any(ctx)) \ - return WASM_OK + return WABT_OK typedef uint32_t Uint32; -WASM_DEFINE_VECTOR(uint32, Uint32); -WASM_DEFINE_VECTOR(uint32_vector, Uint32Vector); +WABT_DEFINE_VECTOR(uint32, Uint32); +WABT_DEFINE_VECTOR(uint32_vector, Uint32Vector); typedef enum LabelType { LABEL_TYPE_FUNC, @@ -92,27 +92,27 @@ typedef enum LabelType { typedef struct Label { LabelType label_type; - WasmTypeVector sig; + WabtTypeVector sig; uint32_t type_stack_limit; uint32_t offset; /* branch location in the istream */ uint32_t fixup_offset; } Label; -WASM_DEFINE_VECTOR(label, Label); +WABT_DEFINE_VECTOR(label, Label); typedef struct Context { - WasmAllocator* allocator; - WasmBinaryReader* reader; - WasmBinaryErrorHandler* error_handler; - WasmAllocator* memory_allocator; - WasmInterpreterEnvironment* env; - WasmInterpreterModule* module; - WasmInterpreterFunc* current_func; - WasmTypeVector type_stack; + WabtAllocator* allocator; + WabtBinaryReader* reader; + WabtBinaryErrorHandler* error_handler; + WabtAllocator* memory_allocator; + WabtInterpreterEnvironment* env; + WabtInterpreterModule* module; + WabtInterpreterFunc* current_func; + WabtTypeVector type_stack; LabelVector label_stack; Uint32VectorVector func_fixups; Uint32VectorVector depth_fixups; uint32_t depth; - WasmMemoryWriter istream_writer; + WabtMemoryWriter istream_writer; uint32_t istream_offset; /* mappings from module index space to env index space; this won't just be a * translation, because imported values will be resolved as well */ @@ -124,10 +124,10 @@ typedef struct Context { uint32_t num_global_imports; /* values cached in the Context so they can be shared between callbacks */ - WasmInterpreterTypedValue init_expr_value; + WabtInterpreterTypedValue init_expr_value; uint32_t table_offset; - WasmBool is_host_import; - WasmInterpreterModule* host_import_module; + WabtBool is_host_import; + WabtInterpreterModule* host_import_module; uint32_t import_env_index; } Context; @@ -147,10 +147,10 @@ static void handle_error(uint32_t offset, const char* message, Context* ctx) { } } -static void WASM_PRINTF_FORMAT(2, 3) +static void WABT_PRINTF_FORMAT(2, 3) print_error(Context* ctx, const char* format, ...) { - WASM_SNPRINTF_ALLOCA(buffer, length, format); - handle_error(WASM_INVALID_OFFSET, buffer, ctx); + WABT_SNPRINTF_ALLOCA(buffer, length, format); + handle_error(WABT_INVALID_OFFSET, buffer, ctx); } static uint32_t translate_sig_index_to_env(Context* ctx, uint32_t sig_index) { @@ -158,14 +158,14 @@ static uint32_t translate_sig_index_to_env(Context* ctx, uint32_t sig_index) { return ctx->sig_index_mapping.data[sig_index]; } -static WasmInterpreterFuncSignature* get_signature_by_env_index( +static WabtInterpreterFuncSignature* get_signature_by_env_index( Context* ctx, uint32_t sig_index) { assert(sig_index < ctx->env->sigs.size); return &ctx->env->sigs.data[sig_index]; } -static WasmInterpreterFuncSignature* get_signature_by_module_index( +static WabtInterpreterFuncSignature* get_signature_by_module_index( Context* ctx, uint32_t sig_index) { return get_signature_by_env_index(ctx, @@ -183,13 +183,13 @@ static uint32_t translate_module_func_index_to_defined(Context* ctx, return func_index - ctx->num_func_imports; } -static WasmInterpreterFunc* get_func_by_env_index(Context* ctx, +static WabtInterpreterFunc* get_func_by_env_index(Context* ctx, uint32_t func_index) { assert(func_index < ctx->env->funcs.size); return &ctx->env->funcs.data[func_index]; } -static WasmInterpreterFunc* get_func_by_module_index(Context* ctx, +static WabtInterpreterFunc* get_func_by_module_index(Context* ctx, uint32_t func_index) { return get_func_by_env_index(ctx, translate_func_index_to_env(ctx, func_index)); @@ -201,25 +201,25 @@ static uint32_t translate_global_index_to_env(Context* ctx, return ctx->global_index_mapping.data[global_index]; } -static WasmInterpreterGlobal* get_global_by_env_index(Context* ctx, +static WabtInterpreterGlobal* get_global_by_env_index(Context* ctx, uint32_t global_index) { assert(global_index < ctx->env->globals.size); return &ctx->env->globals.data[global_index]; } -static WasmInterpreterGlobal* get_global_by_module_index( +static WabtInterpreterGlobal* get_global_by_module_index( Context* ctx, uint32_t global_index) { return get_global_by_env_index( ctx, translate_global_index_to_env(ctx, global_index)); } -static WasmType get_global_type_by_module_index(Context* ctx, +static WabtType get_global_type_by_module_index(Context* ctx, uint32_t global_index) { return get_global_by_module_index(ctx, global_index)->typed_value.type; } -static WasmType get_local_type_by_index(WasmInterpreterFunc* func, +static WabtType get_local_type_by_index(WabtInterpreterFunc* func, uint32_t local_index) { assert(!func->is_host); assert(local_index < func->defined.param_and_local_types.size); @@ -235,7 +235,7 @@ static uint32_t get_istream_offset(Context* ctx) { return ctx->istream_offset; } -static WasmResult emit_data_at(Context* ctx, +static WabtResult emit_data_at(Context* ctx, size_t offset, const void* data, size_t size) { @@ -243,86 +243,86 @@ static WasmResult emit_data_at(Context* ctx, offset, data, size, ctx->istream_writer.base.user_data); } -static WasmResult emit_data(Context* ctx, const void* data, size_t size) { +static WabtResult emit_data(Context* ctx, const void* data, size_t size) { CHECK_RESULT(emit_data_at(ctx, ctx->istream_offset, data, size)); ctx->istream_offset += size; - return WASM_OK; + return WABT_OK; } -static WasmResult emit_opcode(Context* ctx, WasmOpcode opcode) { +static WabtResult emit_opcode(Context* ctx, WabtOpcode opcode) { return emit_data(ctx, &opcode, sizeof(uint8_t)); } -static WasmResult emit_i8(Context* ctx, uint8_t value) { +static WabtResult emit_i8(Context* ctx, uint8_t value) { return emit_data(ctx, &value, sizeof(value)); } -static WasmResult emit_i32(Context* ctx, uint32_t value) { +static WabtResult emit_i32(Context* ctx, uint32_t value) { return emit_data(ctx, &value, sizeof(value)); } -static WasmResult emit_i64(Context* ctx, uint64_t value) { +static WabtResult emit_i64(Context* ctx, uint64_t value) { return emit_data(ctx, &value, sizeof(value)); } -static WasmResult emit_i32_at(Context* ctx, uint32_t offset, uint32_t value) { +static WabtResult emit_i32_at(Context* ctx, uint32_t offset, uint32_t value) { return emit_data_at(ctx, offset, &value, sizeof(value)); } -static WasmResult emit_drop_keep(Context* ctx, uint32_t drop, uint8_t keep) { +static WabtResult emit_drop_keep(Context* ctx, uint32_t drop, uint8_t keep) { assert(drop != UINT32_MAX); assert(keep <= 1); if (drop > 0) { if (drop == 1 && keep == 0) { LOGF("%3" PRIzd ": drop\n", ctx->type_stack.size); - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_DROP)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_DROP)); } else { LOGF("%3" PRIzd ": drop_keep %u %u\n", ctx->type_stack.size, drop, keep); - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_DROP_KEEP)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_DROP_KEEP)); CHECK_RESULT(emit_i32(ctx, drop)); CHECK_RESULT(emit_i8(ctx, keep)); } } - return WASM_OK; + return WABT_OK; } -static WasmResult append_fixup(Context* ctx, +static WabtResult append_fixup(Context* ctx, Uint32VectorVector* fixups_vector, uint32_t index) { if (index >= fixups_vector->size) - wasm_resize_uint32_vector_vector(ctx->allocator, fixups_vector, index + 1); + wabt_resize_uint32_vector_vector(ctx->allocator, fixups_vector, index + 1); Uint32Vector* fixups = &fixups_vector->data[index]; uint32_t offset = get_istream_offset(ctx); - wasm_append_uint32_value(ctx->allocator, fixups, &offset); - return WASM_OK; + wabt_append_uint32_value(ctx->allocator, fixups, &offset); + return WABT_OK; } -static WasmResult emit_br_offset(Context* ctx, +static WabtResult emit_br_offset(Context* ctx, uint32_t depth, uint32_t offset) { - if (offset == WASM_INVALID_OFFSET) + if (offset == WABT_INVALID_OFFSET) CHECK_RESULT(append_fixup(ctx, &ctx->depth_fixups, depth)); CHECK_RESULT(emit_i32(ctx, offset)); - return WASM_OK; + return WABT_OK; } static uint32_t get_label_br_arity(Label* label) { return label->label_type != LABEL_TYPE_LOOP ? label->sig.size : 0; } -static WasmResult emit_br(Context* ctx, uint32_t depth) { +static WabtResult emit_br(Context* ctx, uint32_t depth) { Label* label = get_label(ctx, depth); uint32_t arity = get_label_br_arity(label); assert(ctx->type_stack.size >= label->type_stack_limit + arity); uint32_t drop_count = (ctx->type_stack.size - label->type_stack_limit) - arity; CHECK_RESULT(emit_drop_keep(ctx, drop_count, arity)); - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_BR)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_BR)); CHECK_RESULT(emit_br_offset(ctx, depth, label->offset)); - return WASM_OK; + return WABT_OK; } -static WasmResult emit_br_table_offset(Context* ctx, uint32_t depth) { +static WabtResult emit_br_table_offset(Context* ctx, uint32_t depth) { Label* label = get_label(ctx, depth); uint32_t arity = get_label_br_arity(label); assert(ctx->type_stack.size >= label->type_stack_limit + arity); @@ -331,14 +331,14 @@ static WasmResult emit_br_table_offset(Context* ctx, uint32_t depth) { CHECK_RESULT(emit_br_offset(ctx, depth, label->offset)); CHECK_RESULT(emit_i32(ctx, drop_count)); CHECK_RESULT(emit_i8(ctx, arity)); - return WASM_OK; + return WABT_OK; } -static WasmResult fixup_top_label(Context* ctx, uint32_t offset) { +static WabtResult fixup_top_label(Context* ctx, uint32_t offset) { uint32_t top = ctx->label_stack.size - 1; if (top >= ctx->depth_fixups.size) { /* nothing to fixup */ - return WASM_OK; + return WABT_OK; } Uint32Vector* fixups = &ctx->depth_fixups.data[top]; @@ -348,126 +348,126 @@ static WasmResult fixup_top_label(Context* ctx, uint32_t offset) { /* reduce the size to 0 in case this gets reused. Keep the allocations for * later use */ fixups->size = 0; - return WASM_OK; + return WABT_OK; } -static WasmResult emit_func_offset(Context* ctx, - WasmInterpreterFunc* func, +static WabtResult emit_func_offset(Context* ctx, + WabtInterpreterFunc* func, uint32_t func_index) { - if (func->defined.offset == WASM_INVALID_OFFSET) { + if (func->defined.offset == WABT_INVALID_OFFSET) { uint32_t defined_index = translate_module_func_index_to_defined(ctx, func_index); CHECK_RESULT(append_fixup(ctx, &ctx->func_fixups, defined_index)); } CHECK_RESULT(emit_i32(ctx, func->defined.offset)); - return WASM_OK; + return WABT_OK; } -static void on_error(WasmBinaryReaderContext* ctx, const char* message) { +static void on_error(WabtBinaryReaderContext* ctx, const char* message) { handle_error(ctx->offset, message, ctx->user_data); } -static WasmResult on_signature_count(uint32_t count, void* user_data) { +static WabtResult on_signature_count(uint32_t count, void* user_data) { Context* ctx = user_data; - wasm_resize_uint32_vector(ctx->allocator, &ctx->sig_index_mapping, count); + wabt_resize_uint32_vector(ctx->allocator, &ctx->sig_index_mapping, count); uint32_t i; for (i = 0; i < count; ++i) ctx->sig_index_mapping.data[i] = ctx->env->sigs.size + i; - wasm_resize_interpreter_func_signature_vector(ctx->allocator, &ctx->env->sigs, + wabt_resize_interpreter_func_signature_vector(ctx->allocator, &ctx->env->sigs, ctx->env->sigs.size + count); - return WASM_OK; + return WABT_OK; } -static WasmResult on_signature(uint32_t index, +static WabtResult on_signature(uint32_t index, uint32_t param_count, - WasmType* param_types, + WabtType* param_types, uint32_t result_count, - WasmType* result_types, + WabtType* result_types, void* user_data) { Context* ctx = user_data; - WasmInterpreterFuncSignature* sig = get_signature_by_module_index(ctx, index); + WabtInterpreterFuncSignature* sig = get_signature_by_module_index(ctx, index); - wasm_reserve_types(ctx->allocator, &sig->param_types, param_count); + wabt_reserve_types(ctx->allocator, &sig->param_types, param_count); sig->param_types.size = param_count; - memcpy(sig->param_types.data, param_types, param_count * sizeof(WasmType)); + memcpy(sig->param_types.data, param_types, param_count * sizeof(WabtType)); - wasm_reserve_types(ctx->allocator, &sig->result_types, result_count); + wabt_reserve_types(ctx->allocator, &sig->result_types, result_count); sig->result_types.size = result_count; - memcpy(sig->result_types.data, result_types, result_count * sizeof(WasmType)); - return WASM_OK; + memcpy(sig->result_types.data, result_types, result_count * sizeof(WabtType)); + return WABT_OK; } -static WasmResult on_import_count(uint32_t count, void* user_data) { +static WabtResult on_import_count(uint32_t count, void* user_data) { Context* ctx = user_data; - wasm_new_interpreter_import_array(ctx->allocator, + wabt_new_interpreter_import_array(ctx->allocator, &ctx->module->defined.imports, count); - return WASM_OK; + return WABT_OK; } -static WasmResult on_import(uint32_t index, - WasmStringSlice module_name, - WasmStringSlice field_name, +static WabtResult on_import(uint32_t index, + WabtStringSlice module_name, + WabtStringSlice field_name, void* user_data) { Context* ctx = user_data; assert(index < ctx->module->defined.imports.size); - WasmInterpreterImport* import = &ctx->module->defined.imports.data[index]; - import->module_name = wasm_dup_string_slice(ctx->allocator, module_name); - import->field_name = wasm_dup_string_slice(ctx->allocator, field_name); - int module_index = wasm_find_binding_index_by_name( + WabtInterpreterImport* import = &ctx->module->defined.imports.data[index]; + import->module_name = wabt_dup_string_slice(ctx->allocator, module_name); + import->field_name = wabt_dup_string_slice(ctx->allocator, field_name); + int module_index = wabt_find_binding_index_by_name( &ctx->env->registered_module_bindings, &import->module_name); if (module_index < 0) { print_error(ctx, "unknown import module \"" PRIstringslice "\"", - WASM_PRINTF_STRING_SLICE_ARG(import->module_name)); - return WASM_ERROR; + WABT_PRINTF_STRING_SLICE_ARG(import->module_name)); + return WABT_ERROR; } assert((size_t)module_index < ctx->env->modules.size); - WasmInterpreterModule* module = &ctx->env->modules.data[module_index]; + WabtInterpreterModule* module = &ctx->env->modules.data[module_index]; if (module->is_host) { /* We don't yet know the kind of a host import module, so just assume it * exists for now. We'll fail later (in on_import_* below) if it doesn't * exist). */ - ctx->is_host_import = WASM_TRUE; + ctx->is_host_import = WABT_TRUE; ctx->host_import_module = module; } else { - WasmInterpreterExport* export = - wasm_get_interpreter_export_by_name(module, &import->field_name); + WabtInterpreterExport* export = + wabt_get_interpreter_export_by_name(module, &import->field_name); if (!export) { print_error(ctx, "unknown module field \"" PRIstringslice "\"", - WASM_PRINTF_STRING_SLICE_ARG(import->field_name)); - return WASM_ERROR; + WABT_PRINTF_STRING_SLICE_ARG(import->field_name)); + return WABT_ERROR; } import->kind = export->kind; - ctx->is_host_import = WASM_FALSE; + ctx->is_host_import = WABT_FALSE; ctx->import_env_index = export->index; } - return WASM_OK; + return WABT_OK; } -static WasmResult check_import_kind(Context* ctx, - WasmInterpreterImport* import, - WasmExternalKind expected_kind) { +static WabtResult check_import_kind(Context* ctx, + WabtInterpreterImport* import, + WabtExternalKind expected_kind) { if (import->kind != expected_kind) { print_error(ctx, "expected import \"" PRIstringslice "." PRIstringslice "\" to have kind %s, not %s", - WASM_PRINTF_STRING_SLICE_ARG(import->module_name), - WASM_PRINTF_STRING_SLICE_ARG(import->field_name), - wasm_get_kind_name(expected_kind), - wasm_get_kind_name(import->kind)); - return WASM_ERROR; + WABT_PRINTF_STRING_SLICE_ARG(import->module_name), + WABT_PRINTF_STRING_SLICE_ARG(import->field_name), + wabt_get_kind_name(expected_kind), + wabt_get_kind_name(import->kind)); + return WABT_ERROR; } - return WASM_OK; + return WABT_OK; } -static WasmResult check_import_limits(Context* ctx, - const WasmLimits* declared_limits, - const WasmLimits* actual_limits) { +static WabtResult check_import_limits(Context* ctx, + const WabtLimits* declared_limits, + const WabtLimits* actual_limits) { if (actual_limits->initial < declared_limits->initial) { print_error(ctx, "actual size (%" PRIu64 ") smaller than declared (%" PRIu64 ")", actual_limits->initial, declared_limits->initial); - return WASM_ERROR; + return WABT_ERROR; } if (declared_limits->has_max) { @@ -475,39 +475,39 @@ static WasmResult check_import_limits(Context* ctx, print_error(ctx, "max size (unspecified) larger than declared (%" PRIu64 ")", declared_limits->max); - return WASM_ERROR; + return WABT_ERROR; } else if (actual_limits->max > declared_limits->max) { print_error(ctx, "max size (%" PRIu64 ") larger than declared (%" PRIu64 ")", actual_limits->max, declared_limits->max); - return WASM_ERROR; + return WABT_ERROR; } } - return WASM_OK; + return WABT_OK; } -static WasmResult append_export(Context* ctx, - WasmInterpreterModule* module, - WasmExternalKind kind, +static WabtResult append_export(Context* ctx, + WabtInterpreterModule* module, + WabtExternalKind kind, uint32_t item_index, - WasmStringSlice name) { - if (wasm_find_binding_index_by_name(&module->export_bindings, &name) != -1) { + WabtStringSlice name) { + if (wabt_find_binding_index_by_name(&module->export_bindings, &name) != -1) { print_error(ctx, "duplicate export \"" PRIstringslice "\"", - WASM_PRINTF_STRING_SLICE_ARG(name)); - return WASM_ERROR; + WABT_PRINTF_STRING_SLICE_ARG(name)); + return WABT_ERROR; } - WasmInterpreterExport* export = - wasm_append_interpreter_export(ctx->allocator, &module->exports); - export->name = wasm_dup_string_slice(ctx->allocator, name); + WabtInterpreterExport* export = + wabt_append_interpreter_export(ctx->allocator, &module->exports); + export->name = wabt_dup_string_slice(ctx->allocator, name); export->kind = kind; export->index = item_index; - WasmBinding* binding = wasm_insert_binding( + WabtBinding* binding = wabt_insert_binding( ctx->allocator, &module->export_bindings, &export->name); binding->index = module->exports.size - 1; - return WASM_OK; + return WABT_OK; } static void on_host_import_print_error(const char* msg, void* user_data) { @@ -515,92 +515,92 @@ static void on_host_import_print_error(const char* msg, void* user_data) { print_error(ctx, "%s", msg); } -static WasmPrintErrorCallback make_print_error_callback(Context* ctx) { - WasmPrintErrorCallback result; +static WabtPrintErrorCallback make_print_error_callback(Context* ctx) { + WabtPrintErrorCallback result; result.print_error = on_host_import_print_error; result.user_data = ctx; return result; } -static WasmResult on_import_func(uint32_t import_index, +static WabtResult on_import_func(uint32_t import_index, uint32_t func_index, uint32_t sig_index, void* user_data) { Context* ctx = user_data; assert(import_index < ctx->module->defined.imports.size); - WasmInterpreterImport* import = + WabtInterpreterImport* import = &ctx->module->defined.imports.data[import_index]; assert(sig_index < ctx->env->sigs.size); import->func.sig_index = translate_sig_index_to_env(ctx, sig_index); uint32_t func_env_index; if (ctx->is_host_import) { - WasmInterpreterFunc* func = - wasm_append_interpreter_func(ctx->allocator, &ctx->env->funcs); - func->is_host = WASM_TRUE; + WabtInterpreterFunc* func = + wabt_append_interpreter_func(ctx->allocator, &ctx->env->funcs); + func->is_host = WABT_TRUE; func->sig_index = import->func.sig_index; func->host.module_name = import->module_name; func->host.field_name = import->field_name; - WasmInterpreterHostImportDelegate* host_delegate = + WabtInterpreterHostImportDelegate* host_delegate = &ctx->host_import_module->host.import_delegate; - WasmInterpreterFuncSignature* sig = &ctx->env->sigs.data[func->sig_index]; + WabtInterpreterFuncSignature* sig = &ctx->env->sigs.data[func->sig_index]; CHECK_RESULT(host_delegate->import_func(import, func, sig, make_print_error_callback(ctx), host_delegate->user_data)); assert(func->host.callback); func_env_index = ctx->env->funcs.size - 1; - append_export(ctx, ctx->host_import_module, WASM_EXTERNAL_KIND_FUNC, + append_export(ctx, ctx->host_import_module, WABT_EXTERNAL_KIND_FUNC, func_env_index, import->field_name); } else { - CHECK_RESULT(check_import_kind(ctx, import, WASM_EXTERNAL_KIND_FUNC)); + CHECK_RESULT(check_import_kind(ctx, import, WABT_EXTERNAL_KIND_FUNC)); assert(ctx->import_env_index < ctx->env->funcs.size); - WasmInterpreterFunc* func = &ctx->env->funcs.data[ctx->import_env_index]; - if (!wasm_func_signatures_are_equal(ctx->env, import->func.sig_index, + WabtInterpreterFunc* func = &ctx->env->funcs.data[ctx->import_env_index]; + if (!wabt_func_signatures_are_equal(ctx->env, import->func.sig_index, func->sig_index)) { print_error(ctx, "import signature mismatch"); - return WASM_ERROR; + return WABT_ERROR; } func_env_index = ctx->import_env_index; } - wasm_append_uint32_value(ctx->allocator, &ctx->func_index_mapping, + wabt_append_uint32_value(ctx->allocator, &ctx->func_index_mapping, &func_env_index); ctx->num_func_imports++; - return WASM_OK; + return WABT_OK; } -static void init_table_func_indexes(Context* ctx, WasmInterpreterTable* table) { - wasm_new_uint32_array(ctx->allocator, &table->func_indexes, +static void init_table_func_indexes(Context* ctx, WabtInterpreterTable* table) { + wabt_new_uint32_array(ctx->allocator, &table->func_indexes, table->limits.initial); size_t i; for (i = 0; i < table->func_indexes.size; ++i) - table->func_indexes.data[i] = WASM_INVALID_INDEX; + table->func_indexes.data[i] = WABT_INVALID_INDEX; } -static WasmResult on_import_table(uint32_t import_index, +static WabtResult on_import_table(uint32_t import_index, uint32_t table_index, - WasmType elem_type, - const WasmLimits* elem_limits, + WabtType elem_type, + const WabtLimits* elem_limits, void* user_data) { Context* ctx = user_data; - if (ctx->module->table_index != WASM_INVALID_INDEX) { + if (ctx->module->table_index != WABT_INVALID_INDEX) { print_error(ctx, "only one table allowed"); - return WASM_ERROR; + return WABT_ERROR; } assert(import_index < ctx->module->defined.imports.size); - WasmInterpreterImport* import = + WabtInterpreterImport* import = &ctx->module->defined.imports.data[import_index]; if (ctx->is_host_import) { - WasmInterpreterTable* table = - wasm_append_interpreter_table(ctx->allocator, &ctx->env->tables); + WabtInterpreterTable* table = + wabt_append_interpreter_table(ctx->allocator, &ctx->env->tables); table->limits = *elem_limits; init_table_func_indexes(ctx, table); - WasmInterpreterHostImportDelegate* host_delegate = + WabtInterpreterHostImportDelegate* host_delegate = &ctx->host_import_module->host.import_delegate; CHECK_RESULT(host_delegate->import_table(import, table, make_print_error_callback(ctx), @@ -609,40 +609,40 @@ static WasmResult on_import_table(uint32_t import_index, CHECK_RESULT(check_import_limits(ctx, elem_limits, &table->limits)); ctx->module->table_index = ctx->env->tables.size - 1; - append_export(ctx, ctx->host_import_module, WASM_EXTERNAL_KIND_TABLE, + append_export(ctx, ctx->host_import_module, WABT_EXTERNAL_KIND_TABLE, ctx->module->table_index, import->field_name); } else { - CHECK_RESULT(check_import_kind(ctx, import, WASM_EXTERNAL_KIND_TABLE)); + CHECK_RESULT(check_import_kind(ctx, import, WABT_EXTERNAL_KIND_TABLE)); assert(ctx->import_env_index < ctx->env->tables.size); - WasmInterpreterTable* table = &ctx->env->tables.data[ctx->import_env_index]; + WabtInterpreterTable* table = &ctx->env->tables.data[ctx->import_env_index]; CHECK_RESULT(check_import_limits(ctx, elem_limits, &table->limits)); import->table.limits = *elem_limits; ctx->module->table_index = ctx->import_env_index; } - return WASM_OK; + return WABT_OK; } -static WasmResult on_import_memory(uint32_t import_index, +static WabtResult on_import_memory(uint32_t import_index, uint32_t memory_index, - const WasmLimits* page_limits, + const WabtLimits* page_limits, void* user_data) { Context* ctx = user_data; - if (ctx->module->memory_index != WASM_INVALID_INDEX) { + if (ctx->module->memory_index != WABT_INVALID_INDEX) { print_error(ctx, "only one memory allowed"); - return WASM_ERROR; + return WABT_ERROR; } assert(import_index < ctx->module->defined.imports.size); - WasmInterpreterImport* import = + WabtInterpreterImport* import = &ctx->module->defined.imports.data[import_index]; if (ctx->is_host_import) { - WasmInterpreterMemory* memory = - wasm_append_interpreter_memory(ctx->allocator, &ctx->env->memories); + WabtInterpreterMemory* memory = + wabt_append_interpreter_memory(ctx->allocator, &ctx->env->memories); memory->allocator = ctx->memory_allocator; - WasmInterpreterHostImportDelegate* host_delegate = + WabtInterpreterHostImportDelegate* host_delegate = &ctx->host_import_module->host.import_delegate; CHECK_RESULT(host_delegate->import_memory(import, memory, make_print_error_callback(ctx), @@ -652,330 +652,330 @@ static WasmResult on_import_memory(uint32_t import_index, CHECK_RESULT(check_import_limits(ctx, page_limits, &memory->page_limits)); ctx->module->memory_index = ctx->env->memories.size - 1; - append_export(ctx, ctx->host_import_module, WASM_EXTERNAL_KIND_MEMORY, + append_export(ctx, ctx->host_import_module, WABT_EXTERNAL_KIND_MEMORY, ctx->module->memory_index, import->field_name); } else { - CHECK_RESULT(check_import_kind(ctx, import, WASM_EXTERNAL_KIND_MEMORY)); + CHECK_RESULT(check_import_kind(ctx, import, WABT_EXTERNAL_KIND_MEMORY)); assert(ctx->import_env_index < ctx->env->memories.size); - WasmInterpreterMemory* memory = + WabtInterpreterMemory* memory = &ctx->env->memories.data[ctx->import_env_index]; CHECK_RESULT(check_import_limits(ctx, page_limits, &memory->page_limits)); import->memory.limits = *page_limits; ctx->module->memory_index = ctx->import_env_index; } - return WASM_OK; + return WABT_OK; } -static WasmResult on_import_global(uint32_t import_index, +static WabtResult on_import_global(uint32_t import_index, uint32_t global_index, - WasmType type, - WasmBool mutable, + WabtType type, + WabtBool mutable, void* user_data) { Context* ctx = user_data; assert(import_index < ctx->module->defined.imports.size); - WasmInterpreterImport* import = + WabtInterpreterImport* import = &ctx->module->defined.imports.data[import_index]; uint32_t global_env_index = ctx->env->globals.size - 1; if (ctx->is_host_import) { - WasmInterpreterGlobal* global = - wasm_append_interpreter_global(ctx->allocator, &ctx->env->globals); + WabtInterpreterGlobal* global = + wabt_append_interpreter_global(ctx->allocator, &ctx->env->globals); global->typed_value.type = type; global->mutable_ = mutable; - WasmInterpreterHostImportDelegate* host_delegate = + WabtInterpreterHostImportDelegate* host_delegate = &ctx->host_import_module->host.import_delegate; CHECK_RESULT(host_delegate->import_global(import, global, make_print_error_callback(ctx), host_delegate->user_data)); global_env_index = ctx->env->globals.size - 1; - append_export(ctx, ctx->host_import_module, WASM_EXTERNAL_KIND_GLOBAL, + append_export(ctx, ctx->host_import_module, WABT_EXTERNAL_KIND_GLOBAL, global_env_index, import->field_name); } else { - CHECK_RESULT(check_import_kind(ctx, import, WASM_EXTERNAL_KIND_GLOBAL)); + CHECK_RESULT(check_import_kind(ctx, import, WABT_EXTERNAL_KIND_GLOBAL)); // TODO: check type and mutability import->global.type = type; import->global.mutable_ = mutable; global_env_index = ctx->import_env_index; } - wasm_append_uint32_value(ctx->allocator, &ctx->global_index_mapping, + wabt_append_uint32_value(ctx->allocator, &ctx->global_index_mapping, &global_env_index); ctx->num_global_imports++; - return WASM_OK; + return WABT_OK; } -static WasmResult on_function_signatures_count(uint32_t count, +static WabtResult on_function_signatures_count(uint32_t count, void* user_data) { Context* ctx = user_data; size_t old_size = ctx->func_index_mapping.size; - wasm_resize_uint32_vector(ctx->allocator, &ctx->func_index_mapping, + wabt_resize_uint32_vector(ctx->allocator, &ctx->func_index_mapping, old_size + count); uint32_t i; for (i = 0; i < count; ++i) ctx->func_index_mapping.data[old_size + i] = ctx->env->funcs.size + i; - wasm_resize_interpreter_func_vector(ctx->allocator, &ctx->env->funcs, + wabt_resize_interpreter_func_vector(ctx->allocator, &ctx->env->funcs, ctx->env->funcs.size + count); - wasm_resize_uint32_vector_vector(ctx->allocator, &ctx->func_fixups, count); - return WASM_OK; + wabt_resize_uint32_vector_vector(ctx->allocator, &ctx->func_fixups, count); + return WABT_OK; } -static WasmResult on_function_signature(uint32_t index, +static WabtResult on_function_signature(uint32_t index, uint32_t sig_index, void* user_data) { Context* ctx = user_data; - WasmInterpreterFunc* func = get_func_by_module_index(ctx, index); - func->defined.offset = WASM_INVALID_OFFSET; + WabtInterpreterFunc* func = get_func_by_module_index(ctx, index); + func->defined.offset = WABT_INVALID_OFFSET; func->sig_index = translate_sig_index_to_env(ctx, sig_index); - return WASM_OK; + return WABT_OK; } -static WasmResult on_table(uint32_t index, - WasmType elem_type, - const WasmLimits* elem_limits, +static WabtResult on_table(uint32_t index, + WabtType elem_type, + const WabtLimits* elem_limits, void* user_data) { Context* ctx = user_data; - if (ctx->module->table_index != WASM_INVALID_INDEX) { + if (ctx->module->table_index != WABT_INVALID_INDEX) { print_error(ctx, "only one table allowed"); - return WASM_ERROR; + return WABT_ERROR; } - WasmInterpreterTable* table = - wasm_append_interpreter_table(ctx->allocator, &ctx->env->tables); + WabtInterpreterTable* table = + wabt_append_interpreter_table(ctx->allocator, &ctx->env->tables); table->limits = *elem_limits; init_table_func_indexes(ctx, table); ctx->module->table_index = ctx->env->tables.size - 1; - return WASM_OK; + return WABT_OK; } -static WasmResult on_memory(uint32_t index, - const WasmLimits* page_limits, +static WabtResult on_memory(uint32_t index, + const WabtLimits* page_limits, void* user_data) { Context* ctx = user_data; - if (ctx->module->memory_index != WASM_INVALID_INDEX) { + if (ctx->module->memory_index != WABT_INVALID_INDEX) { print_error(ctx, "only one memory allowed"); - return WASM_ERROR; + return WABT_ERROR; } - WasmInterpreterMemory* memory = - wasm_append_interpreter_memory(ctx->allocator, &ctx->env->memories); + WabtInterpreterMemory* memory = + wabt_append_interpreter_memory(ctx->allocator, &ctx->env->memories); memory->allocator = ctx->memory_allocator; memory->page_limits = *page_limits; - memory->byte_size = page_limits->initial * WASM_PAGE_SIZE; - memory->data = wasm_alloc_zero(ctx->memory_allocator, memory->byte_size, - WASM_DEFAULT_ALIGN); + memory->byte_size = page_limits->initial * WABT_PAGE_SIZE; + memory->data = wabt_alloc_zero(ctx->memory_allocator, memory->byte_size, + WABT_DEFAULT_ALIGN); ctx->module->memory_index = ctx->env->memories.size - 1; - return WASM_OK; + return WABT_OK; } -static WasmResult on_global_count(uint32_t count, void* user_data) { +static WabtResult on_global_count(uint32_t count, void* user_data) { Context* ctx = user_data; size_t old_size = ctx->global_index_mapping.size; - wasm_resize_uint32_vector(ctx->allocator, &ctx->global_index_mapping, + wabt_resize_uint32_vector(ctx->allocator, &ctx->global_index_mapping, old_size + count); uint32_t i; for (i = 0; i < count; ++i) ctx->global_index_mapping.data[old_size + i] = ctx->env->globals.size + i; - wasm_resize_interpreter_global_vector(ctx->allocator, &ctx->env->globals, + wabt_resize_interpreter_global_vector(ctx->allocator, &ctx->env->globals, ctx->env->globals.size + count); - return WASM_OK; + return WABT_OK; } -static WasmResult begin_global(uint32_t index, - WasmType type, - WasmBool mutable_, +static WabtResult begin_global(uint32_t index, + WabtType type, + WabtBool mutable_, void* user_data) { Context* ctx = user_data; - WasmInterpreterGlobal* global = get_global_by_module_index(ctx, index); + WabtInterpreterGlobal* global = get_global_by_module_index(ctx, index); global->typed_value.type = type; global->mutable_ = mutable_; - return WASM_OK; + return WABT_OK; } -static WasmResult end_global_init_expr(uint32_t index, void* user_data) { +static WabtResult end_global_init_expr(uint32_t index, void* user_data) { Context* ctx = user_data; - WasmInterpreterGlobal* global = get_global_by_module_index(ctx, index); + WabtInterpreterGlobal* global = get_global_by_module_index(ctx, index); if (ctx->init_expr_value.type != global->typed_value.type) { print_error(ctx, "type mismatch in global, expected %s but got %s.", - wasm_get_type_name(global->typed_value.type), - wasm_get_type_name(ctx->init_expr_value.type)); - return WASM_ERROR; + wabt_get_type_name(global->typed_value.type), + wabt_get_type_name(ctx->init_expr_value.type)); + return WABT_ERROR; } global->typed_value = ctx->init_expr_value; - return WASM_OK; + return WABT_OK; } -static WasmResult on_init_expr_f32_const_expr(uint32_t index, +static WabtResult on_init_expr_f32_const_expr(uint32_t index, uint32_t value_bits, void* user_data) { Context* ctx = user_data; - ctx->init_expr_value.type = WASM_TYPE_F32; + ctx->init_expr_value.type = WABT_TYPE_F32; ctx->init_expr_value.value.f32_bits = value_bits; - return WASM_OK; + return WABT_OK; } -static WasmResult on_init_expr_f64_const_expr(uint32_t index, +static WabtResult on_init_expr_f64_const_expr(uint32_t index, uint64_t value_bits, void* user_data) { Context* ctx = user_data; - ctx->init_expr_value.type = WASM_TYPE_F64; + ctx->init_expr_value.type = WABT_TYPE_F64; ctx->init_expr_value.value.f64_bits = value_bits; - return WASM_OK; + return WABT_OK; } -static WasmResult on_init_expr_get_global_expr(uint32_t index, +static WabtResult on_init_expr_get_global_expr(uint32_t index, uint32_t global_index, void* user_data) { Context* ctx = user_data; if (global_index >= ctx->num_global_imports) { print_error(ctx, "initializer expression can only reference an imported global"); - return WASM_ERROR; + return WABT_ERROR; } - WasmInterpreterGlobal* ref_global = + WabtInterpreterGlobal* ref_global = get_global_by_module_index(ctx, global_index); if (ref_global->mutable_) { print_error(ctx, "initializer expression cannot reference a mutable global"); - return WASM_ERROR; + return WABT_ERROR; } ctx->init_expr_value = ref_global->typed_value; - return WASM_OK; + return WABT_OK; } -static WasmResult on_init_expr_i32_const_expr(uint32_t index, +static WabtResult on_init_expr_i32_const_expr(uint32_t index, uint32_t value, void* user_data) { Context* ctx = user_data; - ctx->init_expr_value.type = WASM_TYPE_I32; + ctx->init_expr_value.type = WABT_TYPE_I32; ctx->init_expr_value.value.i32 = value; - return WASM_OK; + return WABT_OK; } -static WasmResult on_init_expr_i64_const_expr(uint32_t index, +static WabtResult on_init_expr_i64_const_expr(uint32_t index, uint64_t value, void* user_data) { Context* ctx = user_data; - ctx->init_expr_value.type = WASM_TYPE_I64; + ctx->init_expr_value.type = WABT_TYPE_I64; ctx->init_expr_value.value.i64 = value; - return WASM_OK; + return WABT_OK; } -static WasmResult on_export(uint32_t index, - WasmExternalKind kind, +static WabtResult on_export(uint32_t index, + WabtExternalKind kind, uint32_t item_index, - WasmStringSlice name, + WabtStringSlice name, void* user_data) { Context* ctx = user_data; switch (kind) { - case WASM_EXTERNAL_KIND_FUNC: + case WABT_EXTERNAL_KIND_FUNC: item_index = translate_func_index_to_env(ctx, item_index); break; - case WASM_EXTERNAL_KIND_TABLE: + case WABT_EXTERNAL_KIND_TABLE: item_index = ctx->module->table_index; break; - case WASM_EXTERNAL_KIND_MEMORY: + case WABT_EXTERNAL_KIND_MEMORY: item_index = ctx->module->memory_index; break; - case WASM_EXTERNAL_KIND_GLOBAL: { + case WABT_EXTERNAL_KIND_GLOBAL: { item_index = translate_global_index_to_env(ctx, item_index); - WasmInterpreterGlobal* global = &ctx->env->globals.data[item_index]; + WabtInterpreterGlobal* global = &ctx->env->globals.data[item_index]; if (global->mutable_) { print_error(ctx, "mutable globals cannot be exported"); - return WASM_ERROR; + return WABT_ERROR; } break; } - case WASM_NUM_EXTERNAL_KINDS: + case WABT_NUM_EXTERNAL_KINDS: assert(0); break; } return append_export(ctx, ctx->module, kind, item_index, name); } -static WasmResult on_start_function(uint32_t func_index, void* user_data) { +static WabtResult on_start_function(uint32_t func_index, void* user_data) { Context* ctx = user_data; uint32_t start_func_index = translate_func_index_to_env(ctx, func_index); - WasmInterpreterFunc* start_func = + WabtInterpreterFunc* start_func = get_func_by_env_index(ctx, start_func_index); - WasmInterpreterFuncSignature* sig = + WabtInterpreterFuncSignature* sig = get_signature_by_env_index(ctx, start_func->sig_index); if (sig->param_types.size != 0) { print_error(ctx, "start function must be nullary"); - return WASM_ERROR; + return WABT_ERROR; } if (sig->result_types.size != 0) { print_error(ctx, "start function must not return anything"); - return WASM_ERROR; + return WABT_ERROR; } ctx->module->defined.start_func_index = start_func_index; - return WASM_OK; + return WABT_OK; } -static WasmResult end_elem_segment_init_expr(uint32_t index, void* user_data) { +static WabtResult end_elem_segment_init_expr(uint32_t index, void* user_data) { Context* ctx = user_data; - if (ctx->init_expr_value.type != WASM_TYPE_I32) { + if (ctx->init_expr_value.type != WABT_TYPE_I32) { print_error(ctx, "type mismatch in elem segment, expected i32 but got %s", - wasm_get_type_name(ctx->init_expr_value.type)); - return WASM_ERROR; + wabt_get_type_name(ctx->init_expr_value.type)); + return WABT_ERROR; } ctx->table_offset = ctx->init_expr_value.value.i32; - return WASM_OK; + return WABT_OK; } -static WasmResult on_elem_segment_function_index_check(uint32_t index, +static WabtResult on_elem_segment_function_index_check(uint32_t index, uint32_t func_index, void* user_data) { Context* ctx = user_data; - assert(ctx->module->table_index != WASM_INVALID_INDEX); - WasmInterpreterTable* table = + assert(ctx->module->table_index != WABT_INVALID_INDEX); + WabtInterpreterTable* table = &ctx->env->tables.data[ctx->module->table_index]; if (ctx->table_offset >= table->func_indexes.size) { print_error(ctx, "elem segment offset is out of bounds: %u >= max value %" PRIzd, ctx->table_offset, table->func_indexes.size); - return WASM_ERROR; + return WABT_ERROR; } uint32_t max_func_index = ctx->func_index_mapping.size; if (func_index >= max_func_index) { print_error(ctx, "invalid func_index: %d (max %d)", func_index, max_func_index); - return WASM_ERROR; + return WABT_ERROR; } table->func_indexes.data[ctx->table_offset++] = translate_func_index_to_env(ctx, func_index); - return WASM_OK; + return WABT_OK; } -static WasmResult on_elem_segment_function_index(uint32_t index, +static WabtResult on_elem_segment_function_index(uint32_t index, uint32_t func_index, void* user_data) { Context* ctx = user_data; - assert(ctx->module->table_index != WASM_INVALID_INDEX); - WasmInterpreterTable* table = + assert(ctx->module->table_index != WABT_INVALID_INDEX); + WabtInterpreterTable* table = &ctx->env->tables.data[ctx->module->table_index]; table->func_indexes.data[ctx->table_offset++] = translate_func_index_to_env(ctx, func_index); - return WASM_OK; + return WABT_OK; } -static WasmResult on_data_segment_data_check(uint32_t index, +static WabtResult on_data_segment_data_check(uint32_t index, const void* src_data, uint32_t size, void* user_data) { Context* ctx = user_data; - assert(ctx->module->memory_index != WASM_INVALID_INDEX); - WasmInterpreterMemory* memory = + assert(ctx->module->memory_index != WABT_INVALID_INDEX); + WabtInterpreterMemory* memory = &ctx->env->memories.data[ctx->module->memory_index]; - if (ctx->init_expr_value.type != WASM_TYPE_I32) { + if (ctx->init_expr_value.type != WABT_TYPE_I32) { print_error(ctx, "type mismatch in data segment, expected i32 but got %s", - wasm_get_type_name(ctx->init_expr_value.type)); - return WASM_ERROR; + wabt_get_type_name(ctx->init_expr_value.type)); + return WABT_ERROR; } uint32_t address = ctx->init_expr_value.value.i32; uint64_t end_address = (uint64_t)address + (uint64_t)size; @@ -983,23 +983,23 @@ static WasmResult on_data_segment_data_check(uint32_t index, print_error(ctx, "data segment is out of bounds: [%u, %" PRIu64 ") >= max value %u", address, end_address, memory->byte_size); - return WASM_ERROR; + return WABT_ERROR; } - return WASM_OK; + return WABT_OK; } -static WasmResult on_data_segment_data(uint32_t index, +static WabtResult on_data_segment_data(uint32_t index, const void* src_data, uint32_t size, void* user_data) { Context* ctx = user_data; - assert(ctx->module->memory_index != WASM_INVALID_INDEX); - WasmInterpreterMemory* memory = + assert(ctx->module->memory_index != WABT_INVALID_INDEX); + WabtInterpreterMemory* memory = &ctx->env->memories.data[ctx->module->memory_index]; uint32_t address = ctx->init_expr_value.value.i32; uint8_t* dst_data = memory->data; memcpy(&dst_data[address], src_data, size); - return WASM_OK; + return WABT_OK; } static uint32_t translate_depth(Context* ctx, uint32_t depth) { @@ -1009,26 +1009,26 @@ static uint32_t translate_depth(Context* ctx, uint32_t depth) { static void push_label(Context* ctx, LabelType label_type, - const WasmTypeVector* sig, + const WabtTypeVector* sig, uint32_t offset, uint32_t fixup_offset) { - Label* label = wasm_append_label(ctx->allocator, &ctx->label_stack); + Label* label = wabt_append_label(ctx->allocator, &ctx->label_stack); label->label_type = label_type; - wasm_extend_types(ctx->allocator, &label->sig, sig); + wabt_extend_types(ctx->allocator, &label->sig, sig); label->type_stack_limit = ctx->type_stack.size; label->offset = offset; label->fixup_offset = fixup_offset; LOGF(" : +depth %" PRIzd "\n", ctx->label_stack.size - 1); } -static void wasm_destroy_label(WasmAllocator* allocator, Label* label) { - wasm_destroy_type_vector(allocator, &label->sig); +static void wabt_destroy_label(WabtAllocator* allocator, Label* label) { + wabt_destroy_type_vector(allocator, &label->sig); } static void pop_label(Context* ctx) { LOGF(" : -depth %" PRIzd "\n", ctx->label_stack.size - 1); Label* label = top_label(ctx); - wasm_destroy_label(ctx->allocator, label); + wabt_destroy_label(ctx->allocator, label); ctx->label_stack.size--; /* reduce the depth_fixups stack as well, but it may be smaller than * label_stack so only do it conditionally. */ @@ -1037,35 +1037,35 @@ static void pop_label(Context* ctx) { uint32_t to = ctx->depth_fixups.size; uint32_t i; for (i = from; i < to; ++i) - wasm_destroy_uint32_vector(ctx->allocator, &ctx->depth_fixups.data[i]); + wabt_destroy_uint32_vector(ctx->allocator, &ctx->depth_fixups.data[i]); ctx->depth_fixups.size = ctx->label_stack.size; } } -static WasmType top_type(Context* ctx) { +static WabtType top_type(Context* ctx) { Label* label = top_label(ctx); - WASM_USE(label); + WABT_USE(label); assert(ctx->type_stack.size > label->type_stack_limit); return ctx->type_stack.data[ctx->type_stack.size - 1]; } -static WasmBool top_type_is_any(Context* ctx) { +static WabtBool top_type_is_any(Context* ctx) { if (ctx->type_stack.size > ctx->current_func->defined.param_and_local_types.size) { - WasmType top_type = ctx->type_stack.data[ctx->type_stack.size - 1]; - if (top_type == WASM_TYPE_ANY) - return WASM_TRUE; + WabtType top_type = ctx->type_stack.data[ctx->type_stack.size - 1]; + if (top_type == WABT_TYPE_ANY) + return WABT_TRUE; } - return WASM_FALSE; + return WABT_FALSE; } -/* TODO(binji): share a lot of the type-checking code w/ wasm-ast-checker.c */ -/* TODO(binji): flip actual + expected types, to match wasm-ast-checker.c */ +/* TODO(binji): share a lot of the type-checking code w/ wabt-ast-checker.c */ +/* TODO(binji): flip actual + expected types, to match wabt-ast-checker.c */ static size_t type_stack_limit(Context* ctx) { return top_label(ctx)->type_stack_limit; } -static WasmResult check_type_stack_limit(Context* ctx, +static WabtResult check_type_stack_limit(Context* ctx, size_t expected, const char* desc) { RETURN_OK_IF_TOP_TYPE_IS_ANY(ctx); @@ -1075,12 +1075,12 @@ static WasmResult check_type_stack_limit(Context* ctx, print_error(ctx, "type stack size too small at %s. got %" PRIzd ", expected at least %" PRIzd, desc, avail, expected); - return WASM_ERROR; + return WABT_ERROR; } - return WASM_OK; + return WABT_OK; } -static WasmResult check_type_stack_limit_exact(Context* ctx, +static WabtResult check_type_stack_limit_exact(Context* ctx, size_t expected, const char* desc) { RETURN_OK_IF_TOP_TYPE_IS_ANY(ctx); @@ -1089,30 +1089,30 @@ static WasmResult check_type_stack_limit_exact(Context* ctx, if (expected != avail) { print_error(ctx, "type stack at end of %s is %" PRIzd ". expected %" PRIzd, desc, avail, expected); - return WASM_ERROR; + return WABT_ERROR; } - return WASM_OK; + return WABT_OK; } static void reset_type_stack_to_limit(Context* ctx) { ctx->type_stack.size = type_stack_limit(ctx); } -static WasmResult check_type(Context* ctx, - WasmType expected, - WasmType actual, +static WabtResult check_type(Context* ctx, + WabtType expected, + WabtType actual, const char* desc) { RETURN_OK_IF_TOP_TYPE_IS_ANY(ctx); if (expected != actual) { print_error(ctx, "type mismatch in %s, expected %s but got %s.", desc, - wasm_get_type_name(expected), wasm_get_type_name(actual)); - return WASM_ERROR; + wabt_get_type_name(expected), wabt_get_type_name(actual)); + return WABT_ERROR; } - return WASM_OK; + return WABT_OK; } -static WasmResult check_n_types(Context* ctx, - const WasmTypeVector* expected, +static WabtResult check_n_types(Context* ctx, + const WabtTypeVector* expected, const char* desc) { RETURN_OK_IF_TOP_TYPE_IS_ANY(ctx); CHECK_RESULT(check_type_stack_limit(ctx, expected->size, desc)); @@ -1123,85 +1123,85 @@ static WasmResult check_n_types(Context* ctx, * type_stack must be [ ..., f64, i32, f32, i32] */ size_t i; for (i = 0; i < expected->size; ++i) { - WasmType actual = + WabtType actual = ctx->type_stack.data[ctx->type_stack.size - expected->size + i]; CHECK_RESULT( check_type(ctx, expected->data[expected->size - i - 1], actual, desc)); } - return WASM_OK; + return WABT_OK; } -static WasmType pop_type(Context* ctx) { - WasmType type = top_type(ctx); - if (type != WASM_TYPE_ANY) { +static WabtType pop_type(Context* ctx) { + WabtType type = top_type(ctx); + if (type != WABT_TYPE_ANY) { LOGF("%3" PRIzd "->%3" PRIzd ": pop %s\n", ctx->type_stack.size, - ctx->type_stack.size - 1, wasm_get_type_name(type)); + ctx->type_stack.size - 1, wabt_get_type_name(type)); ctx->type_stack.size--; } return type; } -static void push_type(Context* ctx, WasmType type) { +static void push_type(Context* ctx, WabtType type) { RETURN_IF_TOP_TYPE_IS_ANY(ctx); - if (type != WASM_TYPE_VOID) { + if (type != WABT_TYPE_VOID) { LOGF("%3" PRIzd "->%3" PRIzd ": push %s\n", ctx->type_stack.size, - ctx->type_stack.size + 1, wasm_get_type_name(type)); - wasm_append_type_value(ctx->allocator, &ctx->type_stack, &type); + ctx->type_stack.size + 1, wabt_get_type_name(type)); + wabt_append_type_value(ctx->allocator, &ctx->type_stack, &type); } } -static void push_types(Context* ctx, const WasmTypeVector* types) { +static void push_types(Context* ctx, const WabtTypeVector* types) { RETURN_IF_TOP_TYPE_IS_ANY(ctx); size_t i; for (i = 0; i < types->size; ++i) push_type(ctx, types->data[i]); } -static WasmResult pop_and_check_1_type(Context* ctx, - WasmType expected, +static WabtResult pop_and_check_1_type(Context* ctx, + WabtType expected, const char* desc) { RETURN_OK_IF_TOP_TYPE_IS_ANY(ctx); - if (WASM_SUCCEEDED(check_type_stack_limit(ctx, 1, desc))) { - WasmType actual = pop_type(ctx); + if (WABT_SUCCEEDED(check_type_stack_limit(ctx, 1, desc))) { + WabtType actual = pop_type(ctx); CHECK_RESULT(check_type(ctx, expected, actual, desc)); - return WASM_OK; + return WABT_OK; } - return WASM_ERROR; + return WABT_ERROR; } -static WasmResult pop_and_check_2_types(Context* ctx, - WasmType expected1, - WasmType expected2, +static WabtResult pop_and_check_2_types(Context* ctx, + WabtType expected1, + WabtType expected2, const char* desc) { RETURN_OK_IF_TOP_TYPE_IS_ANY(ctx); - if (WASM_SUCCEEDED(check_type_stack_limit(ctx, 2, desc))) { - WasmType actual2 = pop_type(ctx); - WasmType actual1 = pop_type(ctx); + if (WABT_SUCCEEDED(check_type_stack_limit(ctx, 2, desc))) { + WabtType actual2 = pop_type(ctx); + WabtType actual1 = pop_type(ctx); CHECK_RESULT(check_type(ctx, expected1, actual1, desc)); CHECK_RESULT(check_type(ctx, expected2, actual2, desc)); - return WASM_OK; + return WABT_OK; } - return WASM_ERROR; + return WABT_ERROR; } -static WasmResult check_opcode1(Context* ctx, WasmOpcode opcode) { +static WabtResult check_opcode1(Context* ctx, WabtOpcode opcode) { RETURN_OK_IF_TOP_TYPE_IS_ANY(ctx); - CHECK_RESULT(pop_and_check_1_type(ctx, wasm_get_opcode_param_type_1(opcode), - wasm_get_opcode_name(opcode))); - push_type(ctx, wasm_get_opcode_result_type(opcode)); - return WASM_OK; + CHECK_RESULT(pop_and_check_1_type(ctx, wabt_get_opcode_param_type_1(opcode), + wabt_get_opcode_name(opcode))); + push_type(ctx, wabt_get_opcode_result_type(opcode)); + return WABT_OK; } -static WasmResult check_opcode2(Context* ctx, WasmOpcode opcode) { +static WabtResult check_opcode2(Context* ctx, WabtOpcode opcode) { RETURN_OK_IF_TOP_TYPE_IS_ANY(ctx); - CHECK_RESULT(pop_and_check_2_types(ctx, wasm_get_opcode_param_type_1(opcode), - wasm_get_opcode_param_type_2(opcode), - wasm_get_opcode_name(opcode))); - push_type(ctx, wasm_get_opcode_result_type(opcode)); - return WASM_OK; + CHECK_RESULT(pop_and_check_2_types(ctx, wabt_get_opcode_param_type_1(opcode), + wabt_get_opcode_param_type_2(opcode), + wabt_get_opcode_name(opcode))); + push_type(ctx, wabt_get_opcode_result_type(opcode)); + return WABT_OK; } -static WasmResult drop_types_for_return(Context* ctx, uint32_t arity) { +static WabtResult drop_types_for_return(Context* ctx, uint32_t arity) { RETURN_OK_IF_TOP_TYPE_IS_ANY(ctx); /* drop the locals and params, but keep the return value, if any. */ if (ctx->type_stack.size >= arity) { @@ -1213,17 +1213,17 @@ static WasmResult drop_types_for_return(Context* ctx, uint32_t arity) { * return. In that case the type stack should be empty */ assert(ctx->type_stack.size == 0); } - return WASM_OK; + return WABT_OK; } -static WasmResult begin_function_body(WasmBinaryReaderContext* context, +static WabtResult begin_function_body(WabtBinaryReaderContext* context, uint32_t index) { Context* ctx = context->user_data; - WasmInterpreterFunc* func = get_func_by_module_index(ctx, index); - WasmInterpreterFuncSignature* sig = + WabtInterpreterFunc* func = get_func_by_module_index(ctx, index); + WabtInterpreterFuncSignature* sig = get_signature_by_env_index(ctx, func->sig_index); - func->is_host = WASM_FALSE; + func->is_host = WABT_FALSE; func->defined.offset = get_istream_offset(ctx); func->defined.local_decl_count = 0; func->defined.local_count = 0; @@ -1243,24 +1243,24 @@ static WasmResult begin_function_body(WasmBinaryReaderContext* context, /* append param types */ for (i = 0; i < sig->param_types.size; ++i) { - WasmType type = sig->param_types.data[i]; - wasm_append_type_value(ctx->allocator, &func->defined.param_and_local_types, + WabtType type = sig->param_types.data[i]; + wabt_append_type_value(ctx->allocator, &func->defined.param_and_local_types, &type); - wasm_append_type_value(ctx->allocator, &ctx->type_stack, &type); + wabt_append_type_value(ctx->allocator, &ctx->type_stack, &type); } /* push implicit func label (equivalent to return) */ - push_label(ctx, LABEL_TYPE_FUNC, &sig->result_types, WASM_INVALID_OFFSET, - WASM_INVALID_OFFSET); - return WASM_OK; + push_label(ctx, LABEL_TYPE_FUNC, &sig->result_types, WABT_INVALID_OFFSET, + WABT_INVALID_OFFSET); + return WABT_OK; } -static WasmResult end_function_body(uint32_t index, void* user_data) { +static WabtResult end_function_body(uint32_t index, void* user_data) { Context* ctx = user_data; Label* label = top_label(ctx); if (!label || label->label_type != LABEL_TYPE_FUNC) { print_error(ctx, "unexpected function end"); - return WASM_ERROR; + return WABT_ERROR; } CHECK_RESULT(check_n_types(ctx, &label->sig, "implicit return")); @@ -1276,150 +1276,150 @@ static WasmResult end_function_body(uint32_t index, void* user_data) { push_types(ctx, &label->sig); } CHECK_RESULT(drop_types_for_return(ctx, label->sig.size)); - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_RETURN)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_RETURN)); pop_label(ctx); ctx->current_func = NULL; ctx->type_stack.size = 0; - return WASM_OK; + return WABT_OK; } -static WasmResult on_local_decl_count(uint32_t count, void* user_data) { +static WabtResult on_local_decl_count(uint32_t count, void* user_data) { Context* ctx = user_data; - WasmInterpreterFunc* func = ctx->current_func; + WabtInterpreterFunc* func = ctx->current_func; func->defined.local_decl_count = count; - return WASM_OK; + return WABT_OK; } -static WasmResult on_local_decl(uint32_t decl_index, +static WabtResult on_local_decl(uint32_t decl_index, uint32_t count, - WasmType type, + WabtType type, void* user_data) { Context* ctx = user_data; LOGF("%3" PRIzd ": alloca\n", ctx->type_stack.size); - WasmInterpreterFunc* func = ctx->current_func; + WabtInterpreterFunc* func = ctx->current_func; func->defined.local_count += count; uint32_t i; for (i = 0; i < count; ++i) { - wasm_append_type_value(ctx->allocator, &func->defined.param_and_local_types, + wabt_append_type_value(ctx->allocator, &func->defined.param_and_local_types, &type); push_type(ctx, type); } if (decl_index == func->defined.local_decl_count - 1) { /* last local declaration, allocate space for all locals. */ - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_ALLOCA)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_ALLOCA)); CHECK_RESULT(emit_i32(ctx, func->defined.local_count)); /* fixup the function label's type_stack_limit to include these values. */ Label* label = top_label(ctx); assert(label->label_type == LABEL_TYPE_FUNC); label->type_stack_limit += func->defined.local_count; } - return WASM_OK; + return WABT_OK; } -static WasmResult check_has_memory(Context* ctx, WasmOpcode opcode) { - if (ctx->module->memory_index == WASM_INVALID_INDEX) { +static WabtResult check_has_memory(Context* ctx, WabtOpcode opcode) { + if (ctx->module->memory_index == WABT_INVALID_INDEX) { print_error(ctx, "%s requires an imported or defined memory.", - wasm_get_opcode_name(opcode)); - return WASM_ERROR; + wabt_get_opcode_name(opcode)); + return WABT_ERROR; } - return WASM_OK; + return WABT_OK; } -static WasmResult check_align(Context* ctx, +static WabtResult check_align(Context* ctx, uint32_t alignment_log2, uint32_t natural_alignment) { if (alignment_log2 >= 32 || (1U << alignment_log2) > natural_alignment) { print_error(ctx, "alignment must not be larger than natural alignment (%u)", natural_alignment); - return WASM_ERROR; + return WABT_ERROR; } - return WASM_OK; + return WABT_OK; } -static WasmResult on_unary_expr(WasmOpcode opcode, void* user_data) { +static WabtResult on_unary_expr(WabtOpcode opcode, void* user_data) { Context* ctx = user_data; CHECK_RESULT(check_opcode1(ctx, opcode)); CHECK_RESULT(emit_opcode(ctx, opcode)); - return WASM_OK; + return WABT_OK; } -static WasmResult on_binary_expr(WasmOpcode opcode, void* user_data) { +static WabtResult on_binary_expr(WabtOpcode opcode, void* user_data) { Context* ctx = user_data; CHECK_RESULT(check_opcode2(ctx, opcode)); CHECK_RESULT(emit_opcode(ctx, opcode)); - return WASM_OK; + return WABT_OK; } -static WasmResult on_block_expr(uint32_t num_types, - WasmType* sig_types, +static WabtResult on_block_expr(uint32_t num_types, + WabtType* sig_types, void* user_data) { Context* ctx = user_data; - WasmTypeVector sig; + WabtTypeVector sig; sig.size = num_types; sig.data = sig_types; - push_label(ctx, LABEL_TYPE_BLOCK, &sig, WASM_INVALID_OFFSET, - WASM_INVALID_OFFSET); - return WASM_OK; + push_label(ctx, LABEL_TYPE_BLOCK, &sig, WABT_INVALID_OFFSET, + WABT_INVALID_OFFSET); + return WABT_OK; } -static WasmResult on_loop_expr(uint32_t num_types, - WasmType* sig_types, +static WabtResult on_loop_expr(uint32_t num_types, + WabtType* sig_types, void* user_data) { Context* ctx = user_data; - WasmTypeVector sig; + WabtTypeVector sig; sig.size = num_types; sig.data = sig_types; push_label(ctx, LABEL_TYPE_LOOP, &sig, get_istream_offset(ctx), - WASM_INVALID_OFFSET); - return WASM_OK; + WABT_INVALID_OFFSET); + return WABT_OK; } -static WasmResult on_if_expr(uint32_t num_types, - WasmType* sig_types, +static WabtResult on_if_expr(uint32_t num_types, + WabtType* sig_types, void* user_data) { Context* ctx = user_data; CHECK_RESULT(check_type_stack_limit(ctx, 1, "if")); - CHECK_RESULT(pop_and_check_1_type(ctx, WASM_TYPE_I32, "if")); - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_BR_UNLESS)); + CHECK_RESULT(pop_and_check_1_type(ctx, WABT_TYPE_I32, "if")); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_BR_UNLESS)); uint32_t fixup_offset = get_istream_offset(ctx); - CHECK_RESULT(emit_i32(ctx, WASM_INVALID_OFFSET)); + CHECK_RESULT(emit_i32(ctx, WABT_INVALID_OFFSET)); - WasmTypeVector sig; + WabtTypeVector sig; sig.size = num_types; sig.data = sig_types; - push_label(ctx, LABEL_TYPE_IF, &sig, WASM_INVALID_OFFSET, fixup_offset); - return WASM_OK; + push_label(ctx, LABEL_TYPE_IF, &sig, WABT_INVALID_OFFSET, fixup_offset); + return WABT_OK; } -static WasmResult on_else_expr(void* user_data) { +static WabtResult on_else_expr(void* user_data) { Context* ctx = user_data; Label* label = top_label(ctx); if (!label || label->label_type != LABEL_TYPE_IF) { print_error(ctx, "unexpected else operator"); - return WASM_ERROR; + return WABT_ERROR; } CHECK_RESULT(check_n_types(ctx, &label->sig, "if true branch")); label->label_type = LABEL_TYPE_ELSE; uint32_t fixup_cond_offset = label->fixup_offset; - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_BR)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_BR)); label->fixup_offset = get_istream_offset(ctx); - CHECK_RESULT(emit_i32(ctx, WASM_INVALID_OFFSET)); + CHECK_RESULT(emit_i32(ctx, WABT_INVALID_OFFSET)); CHECK_RESULT(emit_i32_at(ctx, fixup_cond_offset, get_istream_offset(ctx))); /* reset the type stack for the other branch arm */ ctx->type_stack.size = label->type_stack_limit; - return WASM_OK; + return WABT_OK; } -static WasmResult on_end_expr(void* user_data) { +static WabtResult on_end_expr(void* user_data) { Context* ctx = user_data; Label* label = top_label(ctx); if (!label) { print_error(ctx, "unexpected end operator"); - return WASM_ERROR; + return WABT_ERROR; } const char* desc = NULL; @@ -1442,7 +1442,7 @@ static WasmResult on_end_expr(void* user_data) { case LABEL_TYPE_FUNC: print_error(ctx, "unexpected end operator"); - return WASM_ERROR; + return WABT_ERROR; } CHECK_RESULT(check_n_types(ctx, &label->sig, desc)); @@ -1451,10 +1451,10 @@ static WasmResult on_end_expr(void* user_data) { reset_type_stack_to_limit(ctx); push_types(ctx, &label->sig); pop_label(ctx); - return WASM_OK; + return WABT_OK; } -static WasmResult on_br_expr(uint32_t depth, void* user_data) { +static WabtResult on_br_expr(uint32_t depth, void* user_data) { Context* ctx = user_data; CHECK_DEPTH(ctx, depth); depth = translate_depth(ctx, depth); @@ -1463,41 +1463,41 @@ static WasmResult on_br_expr(uint32_t depth, void* user_data) { CHECK_RESULT(check_n_types(ctx, &label->sig, "br")); CHECK_RESULT(emit_br(ctx, depth)); reset_type_stack_to_limit(ctx); - push_type(ctx, WASM_TYPE_ANY); - return WASM_OK; + push_type(ctx, WABT_TYPE_ANY); + return WABT_OK; } -static WasmResult on_br_if_expr(uint32_t depth, void* user_data) { +static WabtResult on_br_if_expr(uint32_t depth, void* user_data) { Context* ctx = user_data; CHECK_DEPTH(ctx, depth); depth = translate_depth(ctx, depth); - CHECK_RESULT(pop_and_check_1_type(ctx, WASM_TYPE_I32, "br_if")); + CHECK_RESULT(pop_and_check_1_type(ctx, WABT_TYPE_I32, "br_if")); Label* label = get_label(ctx, depth); if (label->label_type != LABEL_TYPE_LOOP) CHECK_RESULT(check_n_types(ctx, &label->sig, "br_if")); /* flip the br_if so if <cond> is true it can drop values from the stack */ - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_BR_UNLESS)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_BR_UNLESS)); uint32_t fixup_br_offset = get_istream_offset(ctx); - CHECK_RESULT(emit_i32(ctx, WASM_INVALID_OFFSET)); + CHECK_RESULT(emit_i32(ctx, WABT_INVALID_OFFSET)); CHECK_RESULT(emit_br(ctx, depth)); CHECK_RESULT(emit_i32_at(ctx, fixup_br_offset, get_istream_offset(ctx))); - return WASM_OK; + return WABT_OK; } -static WasmResult on_br_table_expr(WasmBinaryReaderContext* context, +static WabtResult on_br_table_expr(WabtBinaryReaderContext* context, uint32_t num_targets, uint32_t* target_depths, uint32_t default_target_depth) { Context* ctx = context->user_data; - CHECK_RESULT(pop_and_check_1_type(ctx, WASM_TYPE_I32, "br_table")); - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_BR_TABLE)); + CHECK_RESULT(pop_and_check_1_type(ctx, WABT_TYPE_I32, "br_table")); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_BR_TABLE)); CHECK_RESULT(emit_i32(ctx, num_targets)); uint32_t fixup_table_offset = get_istream_offset(ctx); - CHECK_RESULT(emit_i32(ctx, WASM_INVALID_OFFSET)); + CHECK_RESULT(emit_i32(ctx, WABT_INVALID_OFFSET)); /* not necessary for the interpreter, but it makes it easier to disassemble. * This opcode specifies how many bytes of data follow. */ - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_DATA)); - CHECK_RESULT(emit_i32(ctx, (num_targets + 1) * WASM_TABLE_ENTRY_SIZE)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_DATA)); + CHECK_RESULT(emit_i32(ctx, (num_targets + 1) * WABT_TABLE_ENTRY_SIZE)); CHECK_RESULT(emit_i32_at(ctx, fixup_table_offset, get_istream_offset(ctx))); uint32_t i; @@ -1511,245 +1511,245 @@ static WasmResult on_br_table_expr(WasmBinaryReaderContext* context, } reset_type_stack_to_limit(ctx); - push_type(ctx, WASM_TYPE_ANY); - return WASM_OK; + push_type(ctx, WABT_TYPE_ANY); + return WABT_OK; } -static WasmResult on_call_expr(uint32_t func_index, void* user_data) { +static WabtResult on_call_expr(uint32_t func_index, void* user_data) { Context* ctx = user_data; - WasmInterpreterFunc* func = get_func_by_module_index(ctx, func_index); - WasmInterpreterFuncSignature* sig = + WabtInterpreterFunc* func = get_func_by_module_index(ctx, func_index); + WabtInterpreterFuncSignature* sig = get_signature_by_env_index(ctx, func->sig_index); CHECK_RESULT(check_type_stack_limit(ctx, sig->param_types.size, "call")); uint32_t i; for (i = sig->param_types.size; i > 0; --i) { - WasmType arg = pop_type(ctx); + WabtType arg = pop_type(ctx); CHECK_RESULT(check_type(ctx, sig->param_types.data[i - 1], arg, "call")); } if (func->is_host) { - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_CALL_HOST)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_CALL_HOST)); CHECK_RESULT(emit_i32(ctx, translate_func_index_to_env(ctx, func_index))); } else { - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_CALL)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_CALL)); CHECK_RESULT(emit_func_offset(ctx, func, func_index)); } push_types(ctx, &sig->result_types); - return WASM_OK; + return WABT_OK; } -static WasmResult on_call_indirect_expr(uint32_t sig_index, void* user_data) { +static WabtResult on_call_indirect_expr(uint32_t sig_index, void* user_data) { Context* ctx = user_data; - if (ctx->module->table_index == WASM_INVALID_INDEX) { + if (ctx->module->table_index == WABT_INVALID_INDEX) { print_error(ctx, "found call_indirect operator, but no table"); - return WASM_ERROR; + return WABT_ERROR; } - WasmInterpreterFuncSignature* sig = + WabtInterpreterFuncSignature* sig = get_signature_by_module_index(ctx, sig_index); - CHECK_RESULT(pop_and_check_1_type(ctx, WASM_TYPE_I32, "call_indirect")); + CHECK_RESULT(pop_and_check_1_type(ctx, WABT_TYPE_I32, "call_indirect")); CHECK_RESULT( check_type_stack_limit(ctx, sig->param_types.size, "call_indirect")); uint32_t i; for (i = sig->param_types.size; i > 0; --i) { - WasmType arg = pop_type(ctx); + WabtType arg = pop_type(ctx); CHECK_RESULT( check_type(ctx, sig->param_types.data[i - 1], arg, "call_indirect")); } - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_CALL_INDIRECT)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_CALL_INDIRECT)); CHECK_RESULT(emit_i32(ctx, ctx->module->table_index)); CHECK_RESULT(emit_i32(ctx, translate_sig_index_to_env(ctx, sig_index))); push_types(ctx, &sig->result_types); - return WASM_OK; + return WABT_OK; } -static WasmResult on_drop_expr(void* user_data) { +static WabtResult on_drop_expr(void* user_data) { Context* ctx = user_data; CHECK_RESULT(check_type_stack_limit(ctx, 1, "drop")); - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_DROP)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_DROP)); pop_type(ctx); - return WASM_OK; + return WABT_OK; } -static WasmResult on_i32_const_expr(uint32_t value, void* user_data) { +static WabtResult on_i32_const_expr(uint32_t value, void* user_data) { Context* ctx = user_data; - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_I32_CONST)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_I32_CONST)); CHECK_RESULT(emit_i32(ctx, value)); - push_type(ctx, WASM_TYPE_I32); - return WASM_OK; + push_type(ctx, WABT_TYPE_I32); + return WABT_OK; } -static WasmResult on_i64_const_expr(uint64_t value, void* user_data) { +static WabtResult on_i64_const_expr(uint64_t value, void* user_data) { Context* ctx = user_data; - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_I64_CONST)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_I64_CONST)); CHECK_RESULT(emit_i64(ctx, value)); - push_type(ctx, WASM_TYPE_I64); - return WASM_OK; + push_type(ctx, WABT_TYPE_I64); + return WABT_OK; } -static WasmResult on_f32_const_expr(uint32_t value_bits, void* user_data) { +static WabtResult on_f32_const_expr(uint32_t value_bits, void* user_data) { Context* ctx = user_data; - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_F32_CONST)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_F32_CONST)); CHECK_RESULT(emit_i32(ctx, value_bits)); - push_type(ctx, WASM_TYPE_F32); - return WASM_OK; + push_type(ctx, WABT_TYPE_F32); + return WABT_OK; } -static WasmResult on_f64_const_expr(uint64_t value_bits, void* user_data) { +static WabtResult on_f64_const_expr(uint64_t value_bits, void* user_data) { Context* ctx = user_data; - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_F64_CONST)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_F64_CONST)); CHECK_RESULT(emit_i64(ctx, value_bits)); - push_type(ctx, WASM_TYPE_F64); - return WASM_OK; + push_type(ctx, WABT_TYPE_F64); + return WABT_OK; } -static WasmResult on_get_global_expr(uint32_t global_index, void* user_data) { +static WabtResult on_get_global_expr(uint32_t global_index, void* user_data) { Context* ctx = user_data; CHECK_GLOBAL(ctx, global_index); - WasmType type = get_global_type_by_module_index(ctx, global_index); - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_GET_GLOBAL)); + WabtType type = get_global_type_by_module_index(ctx, global_index); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_GET_GLOBAL)); CHECK_RESULT(emit_i32(ctx, translate_global_index_to_env(ctx, global_index))); push_type(ctx, type); - return WASM_OK; + return WABT_OK; } -static WasmResult on_set_global_expr(uint32_t global_index, void* user_data) { +static WabtResult on_set_global_expr(uint32_t global_index, void* user_data) { Context* ctx = user_data; CHECK_GLOBAL(ctx, global_index); - WasmInterpreterGlobal* global = get_global_by_module_index(ctx, global_index); - if (global->mutable_ != WASM_TRUE) { + WabtInterpreterGlobal* global = get_global_by_module_index(ctx, global_index); + if (global->mutable_ != WABT_TRUE) { print_error(ctx, "can't set_global on immutable global at index %u.", global_index); - return WASM_ERROR; + return WABT_ERROR; } CHECK_RESULT( pop_and_check_1_type(ctx, global->typed_value.type, "set_global")); - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_SET_GLOBAL)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_SET_GLOBAL)); CHECK_RESULT(emit_i32(ctx, translate_global_index_to_env(ctx, global_index))); - return WASM_OK; + return WABT_OK; } -static WasmResult on_get_local_expr(uint32_t local_index, void* user_data) { +static WabtResult on_get_local_expr(uint32_t local_index, void* user_data) { Context* ctx = user_data; CHECK_LOCAL(ctx, local_index); - WasmType type = get_local_type_by_index(ctx->current_func, local_index); - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_GET_LOCAL)); + WabtType type = get_local_type_by_index(ctx->current_func, local_index); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_GET_LOCAL)); CHECK_RESULT(emit_i32(ctx, translate_local_index(ctx, local_index))); push_type(ctx, type); - return WASM_OK; + return WABT_OK; } -static WasmResult on_set_local_expr(uint32_t local_index, void* user_data) { +static WabtResult on_set_local_expr(uint32_t local_index, void* user_data) { Context* ctx = user_data; CHECK_LOCAL(ctx, local_index); - WasmType type = get_local_type_by_index(ctx->current_func, local_index); + WabtType type = get_local_type_by_index(ctx->current_func, local_index); CHECK_RESULT(pop_and_check_1_type(ctx, type, "set_local")); - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_SET_LOCAL)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_SET_LOCAL)); CHECK_RESULT(emit_i32(ctx, translate_local_index(ctx, local_index))); - return WASM_OK; + return WABT_OK; } -static WasmResult on_tee_local_expr(uint32_t local_index, void* user_data) { +static WabtResult on_tee_local_expr(uint32_t local_index, void* user_data) { Context* ctx = user_data; CHECK_LOCAL(ctx, local_index); - WasmType type = get_local_type_by_index(ctx->current_func, local_index); + WabtType type = get_local_type_by_index(ctx->current_func, local_index); CHECK_RESULT(check_type_stack_limit(ctx, 1, "tee_local")); - WasmType value = top_type(ctx); + WabtType value = top_type(ctx); CHECK_RESULT(check_type(ctx, type, value, "tee_local")); - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_TEE_LOCAL)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_TEE_LOCAL)); CHECK_RESULT(emit_i32(ctx, translate_local_index(ctx, local_index))); - return WASM_OK; + return WABT_OK; } -static WasmResult on_grow_memory_expr(void* user_data) { +static WabtResult on_grow_memory_expr(void* user_data) { Context* ctx = user_data; - CHECK_RESULT(check_has_memory(ctx, WASM_OPCODE_GROW_MEMORY)); - CHECK_RESULT(pop_and_check_1_type(ctx, WASM_TYPE_I32, "grow_memory")); - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_GROW_MEMORY)); + CHECK_RESULT(check_has_memory(ctx, WABT_OPCODE_GROW_MEMORY)); + CHECK_RESULT(pop_and_check_1_type(ctx, WABT_TYPE_I32, "grow_memory")); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_GROW_MEMORY)); CHECK_RESULT(emit_i32(ctx, ctx->module->memory_index)); - push_type(ctx, WASM_TYPE_I32); - return WASM_OK; + push_type(ctx, WABT_TYPE_I32); + return WABT_OK; } -static WasmResult on_load_expr(WasmOpcode opcode, +static WabtResult on_load_expr(WabtOpcode opcode, uint32_t alignment_log2, uint32_t offset, void* user_data) { Context* ctx = user_data; CHECK_RESULT(check_has_memory(ctx, opcode)); CHECK_RESULT( - check_align(ctx, alignment_log2, wasm_get_opcode_memory_size(opcode))); + check_align(ctx, alignment_log2, wabt_get_opcode_memory_size(opcode))); CHECK_RESULT(check_opcode1(ctx, opcode)); CHECK_RESULT(emit_opcode(ctx, opcode)); CHECK_RESULT(emit_i32(ctx, ctx->module->memory_index)); CHECK_RESULT(emit_i32(ctx, offset)); - return WASM_OK; + return WABT_OK; } -static WasmResult on_store_expr(WasmOpcode opcode, +static WabtResult on_store_expr(WabtOpcode opcode, uint32_t alignment_log2, uint32_t offset, void* user_data) { Context* ctx = user_data; CHECK_RESULT(check_has_memory(ctx, opcode)); CHECK_RESULT( - check_align(ctx, alignment_log2, wasm_get_opcode_memory_size(opcode))); + check_align(ctx, alignment_log2, wabt_get_opcode_memory_size(opcode))); CHECK_RESULT(check_opcode2(ctx, opcode)); CHECK_RESULT(emit_opcode(ctx, opcode)); CHECK_RESULT(emit_i32(ctx, ctx->module->memory_index)); CHECK_RESULT(emit_i32(ctx, offset)); - return WASM_OK; + return WABT_OK; } -static WasmResult on_current_memory_expr(void* user_data) { +static WabtResult on_current_memory_expr(void* user_data) { Context* ctx = user_data; - CHECK_RESULT(check_has_memory(ctx, WASM_OPCODE_CURRENT_MEMORY)); - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_CURRENT_MEMORY)); + CHECK_RESULT(check_has_memory(ctx, WABT_OPCODE_CURRENT_MEMORY)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_CURRENT_MEMORY)); CHECK_RESULT(emit_i32(ctx, ctx->module->memory_index)); - push_type(ctx, WASM_TYPE_I32); - return WASM_OK; + push_type(ctx, WABT_TYPE_I32); + return WABT_OK; } -static WasmResult on_nop_expr(void* user_data) { - return WASM_OK; +static WabtResult on_nop_expr(void* user_data) { + return WABT_OK; } -static WasmResult on_return_expr(void* user_data) { +static WabtResult on_return_expr(void* user_data) { Context* ctx = user_data; - WasmInterpreterFuncSignature* sig = + WabtInterpreterFuncSignature* sig = get_signature_by_env_index(ctx, ctx->current_func->sig_index); CHECK_RESULT(check_n_types(ctx, &sig->result_types, "return")); CHECK_RESULT(drop_types_for_return(ctx, sig->result_types.size)); - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_RETURN)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_RETURN)); reset_type_stack_to_limit(ctx); - push_type(ctx, WASM_TYPE_ANY); - return WASM_OK; + push_type(ctx, WABT_TYPE_ANY); + return WABT_OK; } -static WasmResult on_select_expr(void* user_data) { +static WabtResult on_select_expr(void* user_data) { Context* ctx = user_data; - CHECK_RESULT(pop_and_check_1_type(ctx, WASM_TYPE_I32, "select")); + CHECK_RESULT(pop_and_check_1_type(ctx, WABT_TYPE_I32, "select")); CHECK_RESULT(check_type_stack_limit(ctx, 2, "select")); - WasmType right = pop_type(ctx); - WasmType left = pop_type(ctx); + WabtType right = pop_type(ctx); + WabtType left = pop_type(ctx); CHECK_RESULT(check_type(ctx, left, right, "select")); - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_SELECT)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_SELECT)); push_type(ctx, left); - return WASM_OK; + return WABT_OK; } -static WasmResult on_unreachable_expr(void* user_data) { +static WabtResult on_unreachable_expr(void* user_data) { Context* ctx = user_data; - CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_UNREACHABLE)); + CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_UNREACHABLE)); reset_type_stack_to_limit(ctx); - push_type(ctx, WASM_TYPE_ANY); - return WASM_OK; + push_type(ctx, WABT_TYPE_ANY); + return WABT_OK; } -static WasmBinaryReader s_binary_reader = { +static WabtBinaryReader s_binary_reader = { .user_data = NULL, .on_error = on_error, @@ -1828,7 +1828,7 @@ static WasmBinaryReader s_binary_reader = { }; /* Second pass to assign data and elem segments after they are checked above. */ -static WasmBinaryReader s_binary_reader_segments = { +static WabtBinaryReader s_binary_reader_segments = { .user_data = NULL, .on_error = on_error, @@ -1844,35 +1844,35 @@ static WasmBinaryReader s_binary_reader_segments = { }; static void destroy_context(Context* ctx) { - wasm_destroy_type_vector(ctx->allocator, &ctx->type_stack); - WASM_DESTROY_VECTOR_AND_ELEMENTS(ctx->allocator, ctx->label_stack, label); - WASM_DESTROY_VECTOR_AND_ELEMENTS(ctx->allocator, ctx->depth_fixups, + wabt_destroy_type_vector(ctx->allocator, &ctx->type_stack); + WABT_DESTROY_VECTOR_AND_ELEMENTS(ctx->allocator, ctx->label_stack, label); + WABT_DESTROY_VECTOR_AND_ELEMENTS(ctx->allocator, ctx->depth_fixups, uint32_vector); - WASM_DESTROY_VECTOR_AND_ELEMENTS(ctx->allocator, ctx->func_fixups, + WABT_DESTROY_VECTOR_AND_ELEMENTS(ctx->allocator, ctx->func_fixups, uint32_vector); - wasm_destroy_uint32_vector(ctx->allocator, &ctx->sig_index_mapping); - wasm_destroy_uint32_vector(ctx->allocator, &ctx->func_index_mapping); - wasm_destroy_uint32_vector(ctx->allocator, &ctx->global_index_mapping); + wabt_destroy_uint32_vector(ctx->allocator, &ctx->sig_index_mapping); + wabt_destroy_uint32_vector(ctx->allocator, &ctx->func_index_mapping); + wabt_destroy_uint32_vector(ctx->allocator, &ctx->global_index_mapping); } -WasmResult wasm_read_binary_interpreter(WasmAllocator* allocator, - WasmAllocator* memory_allocator, - WasmInterpreterEnvironment* env, +WabtResult wabt_read_binary_interpreter(WabtAllocator* allocator, + WabtAllocator* memory_allocator, + WabtInterpreterEnvironment* env, const void* data, size_t size, - const WasmReadBinaryOptions* options, - WasmBinaryErrorHandler* error_handler, - WasmInterpreterModule** out_module) { + const WabtReadBinaryOptions* options, + WabtBinaryErrorHandler* error_handler, + WabtInterpreterModule** out_module) { Context ctx; - WasmBinaryReader reader; + WabtBinaryReader reader; - WasmInterpreterEnvironmentMark mark = wasm_mark_interpreter_environment(env); + WabtInterpreterEnvironmentMark mark = wabt_mark_interpreter_environment(env); - WasmInterpreterModule* module = - wasm_append_interpreter_module(allocator, &env->modules); + WabtInterpreterModule* module = + wabt_append_interpreter_module(allocator, &env->modules); - WASM_ZERO_MEMORY(ctx); - WASM_ZERO_MEMORY(reader); + WABT_ZERO_MEMORY(ctx); + WABT_ZERO_MEMORY(reader); ctx.allocator = allocator; ctx.reader = &reader; @@ -1880,35 +1880,35 @@ WasmResult wasm_read_binary_interpreter(WasmAllocator* allocator, ctx.memory_allocator = memory_allocator; ctx.env = env; ctx.module = module; - ctx.module->is_host = WASM_FALSE; - ctx.module->table_index = WASM_INVALID_INDEX; - ctx.module->memory_index = WASM_INVALID_INDEX; - ctx.module->defined.start_func_index = WASM_INVALID_INDEX; + ctx.module->is_host = WABT_FALSE; + ctx.module->table_index = WABT_INVALID_INDEX; + ctx.module->memory_index = WABT_INVALID_INDEX; + ctx.module->defined.start_func_index = WABT_INVALID_INDEX; ctx.module->defined.istream_start = env->istream.size; ctx.istream_offset = env->istream.size; CHECK_RESULT( - wasm_init_mem_writer_existing(&ctx.istream_writer, &env->istream)); + wabt_init_mem_writer_existing(&ctx.istream_writer, &env->istream)); reader = s_binary_reader; reader.user_data = &ctx; const uint32_t num_function_passes = 1; - WasmResult result = wasm_read_binary(allocator, data, size, &reader, + WabtResult result = wabt_read_binary(allocator, data, size, &reader, num_function_passes, options); - wasm_steal_mem_writer_output_buffer(&ctx.istream_writer, &env->istream); - if (WASM_SUCCEEDED(result)) { + wabt_steal_mem_writer_output_buffer(&ctx.istream_writer, &env->istream); + if (WABT_SUCCEEDED(result)) { /* Another pass on the read binary to assign data and elem segments. */ reader = s_binary_reader_segments; reader.user_data = &ctx; - result = wasm_read_binary(allocator, data, size, &reader, + result = wabt_read_binary(allocator, data, size, &reader, num_function_passes, options); - assert(WASM_SUCCEEDED(result)); + assert(WABT_SUCCEEDED(result)); env->istream.size = ctx.istream_offset; ctx.module->defined.istream_end = env->istream.size; *out_module = module; } else { - wasm_reset_interpreter_environment_to_mark(allocator, env, mark); + wabt_reset_interpreter_environment_to_mark(allocator, env, mark); *out_module = NULL; } destroy_context(&ctx); |