/* * Copyright 2016 WebAssembly Community Group participants * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "binary-reader.h" #include #include #include #include #include #include #include #include "allocator.h" #include "binary.h" #include "config.h" #include "stream.h" #include "vector.h" #if HAVE_ALLOCA #include #endif #define INDENT_SIZE 2 #define INITIAL_PARAM_TYPES_CAPACITY 128 #define INITIAL_BR_TABLE_TARGET_CAPACITY 1000 typedef uint32_t Uint32; WASM_DEFINE_VECTOR(type, WasmType) WASM_DEFINE_VECTOR(uint32, Uint32); #define CALLBACK_CTX(member, ...) \ RAISE_ERROR_UNLESS( \ WASM_SUCCEEDED( \ ctx->reader->member \ ? ctx->reader->member(get_user_context(ctx), __VA_ARGS__) \ : WASM_OK), \ #member " callback failed") #define CALLBACK_CTX0(member) \ RAISE_ERROR_UNLESS( \ WASM_SUCCEEDED(ctx->reader->member \ ? ctx->reader->member(get_user_context(ctx)) \ : WASM_OK), \ #member " callback failed") #define CALLBACK_SECTION(member, section_size) \ CALLBACK_CTX(member, section_size) #define CALLBACK0(member) \ RAISE_ERROR_UNLESS( \ WASM_SUCCEEDED(ctx->reader->member \ ? ctx->reader->member(ctx->reader->user_data) \ : WASM_OK), \ #member " callback failed") #define CALLBACK(member, ...) \ RAISE_ERROR_UNLESS( \ WASM_SUCCEEDED( \ ctx->reader->member \ ? ctx->reader->member(__VA_ARGS__, ctx->reader->user_data) \ : WASM_OK), \ #member " callback failed") #define FORWARD0(member) \ return ctx->reader->member ? ctx->reader->member(ctx->reader->user_data) \ : WASM_OK #define FORWARD_CTX0(member) \ if (!ctx->reader->member) \ return WASM_OK; \ WasmBinaryReaderContext new_ctx = *context; \ new_ctx.user_data = ctx->reader->user_data; \ return ctx->reader->member(&new_ctx); #define FORWARD_CTX(member, ...) \ if (!ctx->reader->member) \ return WASM_OK; \ WasmBinaryReaderContext new_ctx = *context; \ new_ctx.user_data = ctx->reader->user_data; \ return ctx->reader->member(&new_ctx, __VA_ARGS__); #define FORWARD(member, ...) \ return ctx->reader->member \ ? ctx->reader->member(__VA_ARGS__, ctx->reader->user_data) \ : WASM_OK #define RAISE_ERROR(...) \ (ctx->reader->on_error ? raise_error(ctx, __VA_ARGS__) : (void)0) #define RAISE_ERROR_UNLESS(cond, ...) \ if (!(cond)) \ RAISE_ERROR(__VA_ARGS__); #define V(NAME, name, code) [code] = #NAME, static const char* s_section_name[] = {WASM_FOREACH_BINARY_SECTION(V)}; #undef V typedef struct Context { WasmAllocator* allocator; const uint8_t* data; size_t data_size; size_t offset; size_t read_end; /* Either the section end or data_size. */ WasmBinaryReaderContext user_ctx; WasmBinaryReader* reader; jmp_buf error_jmp_buf; WasmTypeVector param_types; Uint32Vector target_depths; const WasmReadBinaryOptions* options; WasmBinarySection last_section_code; uint32_t num_signatures; uint32_t num_imports; uint32_t num_func_imports; uint32_t num_table_imports; uint32_t num_memory_imports; uint32_t num_global_imports; uint32_t num_function_signatures; uint32_t num_tables; uint32_t num_memories; uint32_t num_globals; uint32_t num_exports; uint32_t num_function_bodies; } Context; typedef struct LoggingContext { WasmStream* stream; WasmBinaryReader* reader; int indent; } LoggingContext; static WasmBinaryReaderContext* get_user_context(Context* ctx) { ctx->user_ctx.user_data = ctx->reader->user_data; ctx->user_ctx.data = ctx->data; ctx->user_ctx.size = ctx->data_size; ctx->user_ctx.offset = ctx->offset; return &ctx->user_ctx; } static void WASM_PRINTF_FORMAT(2, 3) raise_error(Context* ctx, const char* format, ...) { WASM_SNPRINTF_ALLOCA(buffer, length, format); assert(ctx->reader->on_error); ctx->reader->on_error(get_user_context(ctx), buffer); longjmp(ctx->error_jmp_buf, 1); } #define IN_SIZE(type) \ if (ctx->offset + sizeof(type) > ctx->read_end) { \ RAISE_ERROR("unable to read " #type ": %s", desc); \ } \ memcpy(out_value, ctx->data + ctx->offset, sizeof(type)); \ ctx->offset += sizeof(type) static void in_u8(Context* ctx, uint8_t* out_value, const char* desc) { IN_SIZE(uint8_t); } static void in_u32(Context* ctx, uint32_t* out_value, const char* desc) { IN_SIZE(uint32_t); } static void in_f32(Context* ctx, uint32_t* out_value, const char* desc) { IN_SIZE(float); } static void in_f64(Context* ctx, uint64_t* out_value, const char* desc) { IN_SIZE(double); } #undef IN_SIZE #define BYTE_AT(type, i, shift) (((type)p[i] & 0x7f) << (shift)) #define LEB128_1(type) (BYTE_AT(type, 0, 0)) #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) #define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) #define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) #define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type)) #define LEB128_8(type) (BYTE_AT(type, 7, 49) | LEB128_7(type)) #define LEB128_9(type) (BYTE_AT(type, 8, 56) | LEB128_8(type)) #define LEB128_10(type) (BYTE_AT(type, 9, 63) | LEB128_9(type)) #define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) #define SIGN_EXTEND(type, value, sign_bit) \ ((type)((value) << SHIFT_AMOUNT(type, sign_bit)) >> \ SHIFT_AMOUNT(type, sign_bit)) size_t wasm_read_u32_leb128(const uint8_t* p, const uint8_t* end, uint32_t* out_value) { if (p < end && (p[0] & 0x80) == 0) { *out_value = LEB128_1(uint32_t); return 1; } else if (p + 1 < end && (p[1] & 0x80) == 0) { *out_value = LEB128_2(uint32_t); return 2; } else if (p + 2 < end && (p[2] & 0x80) == 0) { *out_value = LEB128_3(uint32_t); return 3; } else if (p + 3 < end && (p[3] & 0x80) == 0) { *out_value = LEB128_4(uint32_t); return 4; } else if (p + 4 < end && (p[4] & 0x80) == 0) { /* the top bits set represent values > 32 bits */ if (p[4] & 0xf0) return 0; *out_value = LEB128_5(uint32_t); return 5; } else { /* past the end */ *out_value = 0; return 0; } } static void in_u32_leb128(Context* ctx, uint32_t* out_value, const char* desc) { const uint8_t* p = ctx->data + ctx->offset; const uint8_t* end = ctx->data + ctx->read_end; size_t bytes_read = wasm_read_u32_leb128(p, end, out_value); if (!bytes_read) RAISE_ERROR("unable to read u32 leb128: %s", desc); ctx->offset += bytes_read; } size_t wasm_read_i32_leb128(const uint8_t* p, const uint8_t* end, uint32_t* out_value) { if (p < end && (p[0] & 0x80) == 0) { uint32_t result = LEB128_1(uint32_t); *out_value = SIGN_EXTEND(int32_t, result, 6); return 1; } else if (p + 1 < end && (p[1] & 0x80) == 0) { uint32_t result = LEB128_2(uint32_t); *out_value = SIGN_EXTEND(int32_t, result, 13); return 2; } else if (p + 2 < end && (p[2] & 0x80) == 0) { uint32_t result = LEB128_3(uint32_t); *out_value = SIGN_EXTEND(int32_t, result, 20); return 3; } else if (p + 3 < end && (p[3] & 0x80) == 0) { uint32_t result = LEB128_4(uint32_t); *out_value = SIGN_EXTEND(int32_t, result, 27); return 4; } else if (p + 4 < end && (p[4] & 0x80) == 0) { /* the top bits should be a sign-extension of the sign bit */ WasmBool sign_bit_set = (p[4] & 0x8); int top_bits = p[4] & 0xf0; if ((sign_bit_set && top_bits != 0x70) || (!sign_bit_set && top_bits != 0)) { return 0; } uint32_t result = LEB128_5(uint32_t); *out_value = result; return 5; } else { /* past the end */ return 0; } } static void in_i32_leb128(Context* ctx, uint32_t* out_value, const char* desc) { const uint8_t* p = ctx->data + ctx->offset; const uint8_t* end = ctx->data + ctx->read_end; size_t bytes_read = wasm_read_i32_leb128(p, end, out_value); if (!bytes_read) RAISE_ERROR("unable to read i32 leb128: %s", desc); ctx->offset += bytes_read; } static void in_i64_leb128(Context* ctx, uint64_t* out_value, const char* desc) { const uint8_t* p = ctx->data + ctx->offset; const uint8_t* end = ctx->data + ctx->read_end; if (p < end && (p[0] & 0x80) == 0) { uint64_t result = LEB128_1(uint64_t); *out_value = SIGN_EXTEND(int64_t, result, 6); ctx->offset += 1; } else if (p + 1 < end && (p[1] & 0x80) == 0) { uint64_t result = LEB128_2(uint64_t); *out_value = SIGN_EXTEND(int64_t, result, 13); ctx->offset += 2; } else if (p + 2 < end && (p[2] & 0x80) == 0) { uint64_t result = LEB128_3(uint64_t); *out_value = SIGN_EXTEND(int64_t, result, 20); ctx->offset += 3; } else if (p + 3 < end && (p[3] & 0x80) == 0) { uint64_t result = LEB128_4(uint64_t); *out_value = SIGN_EXTEND(int64_t, result, 27); ctx->offset += 4; } else if (p + 4 < end && (p[4] & 0x80) == 0) { uint64_t result = LEB128_5(uint64_t); *out_value = SIGN_EXTEND(int64_t, result, 34); ctx->offset += 5; } else if (p + 5 < end && (p[5] & 0x80) == 0) { uint64_t result = LEB128_6(uint64_t); *out_value = SIGN_EXTEND(int64_t, result, 41); ctx->offset += 6; } else if (p + 6 < end && (p[6] & 0x80) == 0) { uint64_t result = LEB128_7(uint64_t); *out_value = SIGN_EXTEND(int64_t, result, 48); ctx->offset += 7; } else if (p + 7 < end && (p[7] & 0x80) == 0) { uint64_t result = LEB128_8(uint64_t); *out_value = SIGN_EXTEND(int64_t, result, 55); ctx->offset += 8; } else if (p + 8 < end && (p[8] & 0x80) == 0) { uint64_t result = LEB128_9(uint64_t); *out_value = SIGN_EXTEND(int64_t, result, 62); ctx->offset += 9; } else if (p + 9 < end && (p[9] & 0x80) == 0) { /* the top bits should be a sign-extension of the sign bit */ WasmBool sign_bit_set = (p[9] & 0x1); int top_bits = p[9] & 0xfe; if ((sign_bit_set && top_bits != 0x7e) || (!sign_bit_set && top_bits != 0)) { RAISE_ERROR("invalid i64 leb128: %s", desc); } uint64_t result = LEB128_10(uint64_t); *out_value = result; ctx->offset += 10; } else { /* past the end */ RAISE_ERROR("unable to read i64 leb128: %s", desc); } } #undef BYTE_AT #undef LEB128_1 #undef LEB128_2 #undef LEB128_3 #undef LEB128_4 #undef LEB128_5 #undef LEB128_6 #undef LEB128_7 #undef LEB128_8 #undef LEB128_9 #undef LEB128_10 #undef SHIFT_AMOUNT #undef SIGN_EXTEND static void in_type(Context* ctx, WasmType* out_value, const char* desc) { uint32_t type = 0; in_i32_leb128(ctx, &type, desc); /* Must be in the vs7 range: [-128, 127). */ if ((int32_t)type < -128 || (int32_t)type > 127) RAISE_ERROR("invalid type: %d", type); *out_value = type; } static void in_str(Context* ctx, WasmStringSlice* out_str, const char* desc) { uint32_t str_len = 0; in_u32_leb128(ctx, &str_len, "string length"); if (ctx->offset + str_len > ctx->read_end) RAISE_ERROR("unable to read string: %s", desc); out_str->start = (const char*)ctx->data + ctx->offset; out_str->length = str_len; ctx->offset += str_len; } static void in_bytes(Context* ctx, const void** out_data, uint32_t* out_data_size, const char* desc) { uint32_t data_size = 0; in_u32_leb128(ctx, &data_size, "data size"); if (ctx->offset + data_size > ctx->read_end) RAISE_ERROR("unable to read data: %s", desc); *out_data = (const uint8_t*)ctx->data + ctx->offset; *out_data_size = data_size; ctx->offset += data_size; } static WasmBool is_valid_external_kind(uint8_t kind) { return kind < WASM_NUM_EXTERNAL_KINDS; } static WasmBool is_concrete_type(WasmType type) { switch (type) { case WASM_TYPE_I32: case WASM_TYPE_I64: case WASM_TYPE_F32: case WASM_TYPE_F64: return WASM_TRUE; default: return WASM_FALSE; } } static WasmBool is_inline_sig_type(WasmType type) { return is_concrete_type(type) || type == WASM_TYPE_VOID; } static uint32_t num_total_funcs(Context* ctx) { return ctx->num_func_imports + ctx->num_function_signatures; } static uint32_t num_total_tables(Context* ctx) { return ctx->num_table_imports + ctx->num_tables; } static uint32_t num_total_memories(Context* ctx) { return ctx->num_memory_imports + ctx->num_memories; } static uint32_t num_total_globals(Context* ctx) { return ctx->num_global_imports + ctx->num_globals; } static void destroy_context(Context* ctx) { wasm_destroy_type_vector(ctx->allocator, &ctx->param_types); wasm_destroy_uint32_vector(ctx->allocator, &ctx->target_depths); } /* Logging */ static void indent(LoggingContext* ctx) { ctx->indent += INDENT_SIZE; } static void dedent(LoggingContext* ctx) { ctx->indent -= INDENT_SIZE; assert(ctx->indent >= 0); } static void write_indent(LoggingContext* ctx) { static char s_indent[] = " " " "; static size_t s_indent_len = sizeof(s_indent) - 1; size_t indent = ctx->indent; while (indent > s_indent_len) { wasm_write_data(ctx->stream, s_indent, s_indent_len, NULL); indent -= s_indent_len; } if (indent > 0) { wasm_write_data(ctx->stream, s_indent, indent, NULL); } } #define LOGF_NOINDENT(...) wasm_writef(ctx->stream, __VA_ARGS__) #define LOGF(...) \ do { \ write_indent(ctx); \ LOGF_NOINDENT(__VA_ARGS__); \ } while (0) static void logging_on_error(WasmBinaryReaderContext* ctx, const char* message) { LoggingContext* logging_ctx = ctx->user_data; if (logging_ctx->reader->on_error) { WasmBinaryReaderContext new_ctx = *ctx; new_ctx.user_data = logging_ctx->reader->user_data; logging_ctx->reader->on_error(&new_ctx, message); } } static WasmResult logging_begin_custom_section(WasmBinaryReaderContext* context, uint32_t size, WasmStringSlice section_name) { LoggingContext* ctx = context->user_data; LOGF("begin_custom_section: '" PRIstringslice "' size=%d\n", WASM_PRINTF_STRING_SLICE_ARG(section_name), size); indent(ctx); FORWARD_CTX(begin_custom_section, size, section_name); } #define LOGGING_BEGIN(name) \ static WasmResult logging_begin_##name(WasmBinaryReaderContext* context, \ uint32_t size) { \ LoggingContext* ctx = context->user_data; \ LOGF("begin_" #name "\n"); \ indent(ctx); \ FORWARD_CTX(begin_##name, size); \ } #define LOGGING_END(name) \ static WasmResult logging_end_##name(WasmBinaryReaderContext* context) { \ LoggingContext* ctx = context->user_data; \ dedent(ctx); \ LOGF("end_" #name "\n"); \ FORWARD_CTX0(end_##name); \ } #define LOGGING_UINT32(name) \ static WasmResult logging_##name(uint32_t value, void* user_data) { \ LoggingContext* ctx = user_data; \ LOGF(#name "(%u)\n", value); \ FORWARD(name, value); \ } #define LOGGING_UINT32_DESC(name, desc) \ static WasmResult logging_##name(uint32_t value, void* user_data) { \ LoggingContext* ctx = user_data; \ LOGF(#name "(" desc ": %u)\n", value); \ FORWARD(name, value); \ } #define LOGGING_UINT32_UINT32(name, desc0, desc1) \ static WasmResult logging_##name(uint32_t value0, uint32_t value1, \ void* user_data) { \ LoggingContext* ctx = user_data; \ LOGF(#name "(" desc0 ": %u, " desc1 ": %u)\n", value0, value1); \ FORWARD(name, value0, value1); \ } #define LOGGING_UINT32_UINT32_CTX(name, desc0, desc1) \ static WasmResult logging_##name(WasmBinaryReaderContext* context, \ uint32_t value0, uint32_t value1) { \ LoggingContext* ctx = context->user_data; \ LOGF(#name "(" desc0 ": %u, " desc1 ": %u)\n", value0, value1); \ FORWARD_CTX(name, value0, value1); \ } #define LOGGING_OPCODE(name) \ static WasmResult logging_##name(WasmOpcode opcode, void* user_data) { \ LoggingContext* ctx = user_data; \ LOGF(#name "(\"%s\" (%u))\n", wasm_get_opcode_name(opcode), opcode); \ FORWARD(name, opcode); \ } #define LOGGING0(name) \ static WasmResult logging_##name(void* user_data) { \ LoggingContext* ctx = user_data; \ LOGF(#name "\n"); \ FORWARD0(name); \ } LOGGING_UINT32(begin_module) LOGGING0(end_module) LOGGING_END(custom_section) LOGGING_BEGIN(signature_section) LOGGING_UINT32(on_signature_count) LOGGING_END(signature_section) LOGGING_BEGIN(import_section) LOGGING_UINT32(on_import_count) LOGGING_UINT32_UINT32(on_import_func, "index", "sig_index") LOGGING_END(import_section) LOGGING_BEGIN(function_signatures_section) LOGGING_UINT32(on_function_signatures_count) LOGGING_UINT32_UINT32(on_function_signature, "index", "sig_index") LOGGING_END(function_signatures_section) LOGGING_BEGIN(table_section) LOGGING_UINT32(on_table_count) LOGGING_END(table_section) LOGGING_BEGIN(memory_section) LOGGING_UINT32(on_memory_count) LOGGING_END(memory_section) LOGGING_BEGIN(global_section) LOGGING_UINT32(on_global_count) LOGGING_UINT32(begin_global_init_expr) LOGGING_UINT32(end_global_init_expr) LOGGING_UINT32(end_global) LOGGING_END(global_section) LOGGING_BEGIN(export_section) LOGGING_UINT32(on_export_count) LOGGING_END(export_section) LOGGING_BEGIN(start_section) LOGGING_UINT32(on_start_function) LOGGING_END(start_section) LOGGING_BEGIN(function_bodies_section) LOGGING_UINT32(on_function_bodies_count) LOGGING_UINT32(begin_function_body) LOGGING_UINT32(end_function_body) LOGGING_UINT32(on_local_decl_count) LOGGING_OPCODE(on_binary_expr) LOGGING_UINT32_DESC(on_call_expr, "func_index") LOGGING_UINT32_DESC(on_call_import_expr, "import_index") LOGGING_UINT32_DESC(on_call_indirect_expr, "sig_index") LOGGING_OPCODE(on_compare_expr) LOGGING_OPCODE(on_convert_expr) LOGGING0(on_current_memory_expr) LOGGING0(on_drop_expr) LOGGING0(on_else_expr) LOGGING0(on_end_expr) LOGGING_UINT32_DESC(on_get_global_expr, "index") LOGGING_UINT32_DESC(on_get_local_expr, "index") LOGGING0(on_grow_memory_expr) LOGGING0(on_nop_expr) LOGGING0(on_return_expr) LOGGING0(on_select_expr) LOGGING_UINT32_DESC(on_set_global_expr, "index") LOGGING_UINT32_DESC(on_set_local_expr, "index") LOGGING_UINT32_DESC(on_tee_local_expr, "index") LOGGING0(on_unreachable_expr) LOGGING_OPCODE(on_unary_expr) LOGGING_END(function_bodies_section) LOGGING_BEGIN(elem_section) LOGGING_UINT32(on_elem_segment_count) LOGGING_UINT32_UINT32(begin_elem_segment, "index", "table_index") LOGGING_UINT32(begin_elem_segment_init_expr) LOGGING_UINT32(end_elem_segment_init_expr) LOGGING_UINT32_UINT32_CTX(on_elem_segment_function_index_count, "index", "count") LOGGING_UINT32_UINT32(on_elem_segment_function_index, "index", "func_index") LOGGING_UINT32(end_elem_segment) LOGGING_END(elem_section) LOGGING_BEGIN(data_section) LOGGING_UINT32(on_data_segment_count) LOGGING_UINT32_UINT32(begin_data_segment, "index", "memory_index") LOGGING_UINT32(begin_data_segment_init_expr) LOGGING_UINT32(end_data_segment_init_expr) LOGGING_UINT32(end_data_segment) LOGGING_END(data_section) LOGGING_BEGIN(names_section) LOGGING_UINT32(on_function_names_count) LOGGING_UINT32_UINT32(on_local_names_count, "index", "count") LOGGING_END(names_section) LOGGING_UINT32_UINT32(on_init_expr_get_global_expr, "index", "global_index") static void sprint_limits(char* dst, size_t size, const WasmLimits* limits) { int result; if (limits->has_max) { result = wasm_snprintf(dst, size, "initial: %" PRIu64 ", max: %" PRIu64, limits->initial, limits->max); } else { result = wasm_snprintf(dst, size, "initial: %" PRIu64, limits->initial); } WASM_USE(result); assert((size_t)result < size); } static void log_types(LoggingContext* ctx, uint32_t type_count, WasmType* types) { uint32_t i; LOGF_NOINDENT("["); for (i = 0; i < type_count; ++i) { LOGF_NOINDENT("%s", wasm_get_type_name(types[i])); if (i != type_count - 1) LOGF_NOINDENT(", "); } LOGF_NOINDENT("]"); } static WasmResult logging_on_signature(uint32_t index, uint32_t param_count, WasmType* param_types, uint32_t result_count, WasmType* result_types, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_signature(index: %u, params: ", index); log_types(ctx, param_count, param_types); LOGF_NOINDENT(", results: "); log_types(ctx, result_count, result_types); LOGF_NOINDENT(")\n"); FORWARD(on_signature, index, param_count, param_types, result_count, result_types); } static WasmResult logging_on_import(uint32_t index, WasmStringSlice module_name, WasmStringSlice field_name, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_import(index: %u, module: \"" PRIstringslice "\", field: \"" PRIstringslice "\")\n", index, WASM_PRINTF_STRING_SLICE_ARG(module_name), WASM_PRINTF_STRING_SLICE_ARG(field_name)); FORWARD(on_import, index, module_name, field_name); } static WasmResult logging_on_import_table(uint32_t index, WasmType elem_type, const WasmLimits* elem_limits, void* user_data) { LoggingContext* ctx = user_data; char buf[100]; sprint_limits(buf, sizeof(buf), elem_limits); LOGF("on_import_table(index: %u, elem_type: %s, %s)\n", index, wasm_get_type_name(elem_type), buf); FORWARD(on_import_table, index, elem_type, elem_limits); } static WasmResult logging_on_import_memory(uint32_t index, const WasmLimits* page_limits, void* user_data) { LoggingContext* ctx = user_data; char buf[100]; sprint_limits(buf, sizeof(buf), page_limits); LOGF("on_import_memory(index: %u, %s)\n", index, buf); FORWARD(on_import_memory, index, page_limits); } static WasmResult logging_on_import_global(uint32_t index, WasmType type, WasmBool mutable_, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_import_global(index: %u, type: %s, mutable: %s)\n", index, wasm_get_type_name(type), mutable_ ? "true" : "false"); FORWARD(on_import_global, index, type, mutable_); } static WasmResult logging_on_table(uint32_t index, WasmType elem_type, const WasmLimits* elem_limits, void* user_data) { LoggingContext* ctx = user_data; char buf[100]; sprint_limits(buf, sizeof(buf), elem_limits); LOGF("on_table(index: %u, elem_type: %s, %s)\n", index, wasm_get_type_name(elem_type), buf); FORWARD(on_table, index, elem_type, elem_limits); } static WasmResult logging_on_memory(uint32_t index, const WasmLimits* page_limits, void* user_data) { LoggingContext* ctx = user_data; char buf[100]; sprint_limits(buf, sizeof(buf), page_limits); LOGF("on_memory(index: %u, %s)\n", index, buf); FORWARD(on_memory, index, page_limits); } static WasmResult logging_begin_global(uint32_t index, WasmType type, WasmBool mutable_, void* user_data) { LoggingContext* ctx = user_data; LOGF("begin_global(index: %u, type: %s, mutable: %s)\n", index, wasm_get_type_name(type), mutable_ ? "true" : "false"); FORWARD(begin_global, index, type, mutable_); } static WasmResult logging_on_export(uint32_t index, WasmExternalKind kind, uint32_t item_index, WasmStringSlice name, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_export(index: %u, kind: %s, item_index: %u, name: \"" PRIstringslice "\")\n", index, wasm_get_kind_name(kind), item_index, WASM_PRINTF_STRING_SLICE_ARG(name)); FORWARD(on_export, index, kind, item_index, name); } static WasmResult logging_begin_function_body_pass(uint32_t index, uint32_t pass, void* user_data) { LoggingContext* ctx = user_data; LOGF("begin_function_body_pass(index: %u, pass: %u)\n", index, pass); indent(ctx); FORWARD(begin_function_body_pass, index, pass); } static WasmResult logging_on_local_decl(uint32_t decl_index, uint32_t count, WasmType type, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_local_decl(index: %u, count: %u, type: %s)\n", decl_index, count, wasm_get_type_name(type)); FORWARD(on_local_decl, decl_index, count, type); } static WasmResult logging_on_block_expr(uint32_t num_types, WasmType* sig_types, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_block_expr(sig: "); log_types(ctx, num_types, sig_types); LOGF_NOINDENT(")\n"); FORWARD(on_block_expr, num_types, sig_types); } static WasmResult logging_on_br_expr(uint32_t depth, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_br_expr(depth: %u)\n", depth); FORWARD(on_br_expr, depth); } static WasmResult logging_on_br_if_expr(uint32_t depth, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_br_if_expr(depth: %u)\n", depth); FORWARD(on_br_if_expr, depth); } static WasmResult logging_on_br_table_expr(WasmBinaryReaderContext* context, uint32_t num_targets, uint32_t* target_depths, uint32_t default_target_depth) { LoggingContext* ctx = context->user_data; LOGF("on_br_table_expr(num_targets: %u, depths: [", num_targets); uint32_t i; for (i = 0; i < num_targets; ++i) { LOGF_NOINDENT("%u", target_depths[i]); if (i != num_targets - 1) LOGF_NOINDENT(", "); } LOGF_NOINDENT("], default: %u)\n", default_target_depth); FORWARD_CTX(on_br_table_expr, num_targets, target_depths, default_target_depth); } static WasmResult logging_on_f32_const_expr(uint32_t value_bits, void* user_data) { LoggingContext* ctx = user_data; float value; memcpy(&value, &value_bits, sizeof(value)); LOGF("on_f32_const_expr(%g (0x04%x))\n", value, value_bits); FORWARD(on_f32_const_expr, value_bits); } static WasmResult logging_on_f64_const_expr(uint64_t value_bits, void* user_data) { LoggingContext* ctx = user_data; double value; memcpy(&value, &value_bits, sizeof(value)); LOGF("on_f64_const_expr(%g (0x08%" PRIx64 "))\n", value, value_bits); FORWARD(on_f64_const_expr, value_bits); } static WasmResult logging_on_i32_const_expr(uint32_t value, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_i32_const_expr(%u (0x%x))\n", value, value); FORWARD(on_i32_const_expr, value); } static WasmResult logging_on_i64_const_expr(uint64_t value, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_i64_const_expr(%" PRIu64 " (0x%" PRIx64 "))\n", value, value); FORWARD(on_i64_const_expr, value); } static WasmResult logging_on_if_expr(uint32_t num_types, WasmType* sig_types, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_if_expr(sig: "); log_types(ctx, num_types, sig_types); LOGF_NOINDENT(")\n"); FORWARD(on_if_expr, num_types, sig_types); } static WasmResult logging_on_load_expr(WasmOpcode opcode, uint32_t alignment_log2, uint32_t offset, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_load_expr(opcode: \"%s\" (%u), align log2: %u, offset: %u)\n", wasm_get_opcode_name(opcode), opcode, alignment_log2, offset); FORWARD(on_load_expr, opcode, alignment_log2, offset); } static WasmResult logging_on_loop_expr(uint32_t num_types, WasmType* sig_types, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_loop_expr(sig: "); log_types(ctx, num_types, sig_types); LOGF_NOINDENT(")\n"); FORWARD(on_loop_expr, num_types, sig_types); } static WasmResult logging_on_store_expr(WasmOpcode opcode, uint32_t alignment_log2, uint32_t offset, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_store_expr(opcode: \"%s\" (%u), align log2: %u, offset: %u)\n", wasm_get_opcode_name(opcode), opcode, alignment_log2, offset); FORWARD(on_store_expr, opcode, alignment_log2, offset); } static WasmResult logging_end_function_body_pass(uint32_t index, uint32_t pass, void* user_data) { LoggingContext* ctx = user_data; dedent(ctx); LOGF("end_function_body_pass(index: %u, pass: %u)\n", index, pass); FORWARD(end_function_body_pass, index, pass); } static WasmResult logging_on_data_segment_data(uint32_t index, const void* data, uint32_t size, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_data_segment_data(index:%u, size:%u)\n", index, size); FORWARD(on_data_segment_data, index, data, size); } static WasmResult logging_on_function_name(uint32_t index, WasmStringSlice name, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_function_name(index: %u, name: \"" PRIstringslice "\")\n", index, WASM_PRINTF_STRING_SLICE_ARG(name)); FORWARD(on_function_name, index, name); } static WasmResult logging_on_local_name(uint32_t func_index, uint32_t local_index, WasmStringSlice name, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_local_name(func_index: %u, local_index: %u, name: \"" PRIstringslice "\")\n", func_index, local_index, WASM_PRINTF_STRING_SLICE_ARG(name)); FORWARD(on_local_name, func_index, local_index, name); } static WasmResult logging_on_init_expr_f32_const_expr(uint32_t index, uint32_t value_bits, void* user_data) { LoggingContext* ctx = user_data; float value; memcpy(&value, &value_bits, sizeof(value)); LOGF("on_init_expr_f32_const_expr(index: %u, value: %g (0x04%x))\n", index, value, value_bits); FORWARD(on_init_expr_f32_const_expr, index, value_bits); } static WasmResult logging_on_init_expr_f64_const_expr(uint32_t index, uint64_t value_bits, void* user_data) { LoggingContext* ctx = user_data; double value; memcpy(&value, &value_bits, sizeof(value)); LOGF("on_init_expr_f64_const_expr(index: %u value: %g (0x08%" PRIx64 "))\n", index, value, value_bits); FORWARD(on_init_expr_f64_const_expr, index, value_bits); } static WasmResult logging_on_init_expr_i32_const_expr(uint32_t index, uint32_t value, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_init_expr_i32_const_expr(index: %u, value: %u)\n", index, value); FORWARD(on_init_expr_i32_const_expr, index, value); } static WasmResult logging_on_init_expr_i64_const_expr(uint32_t index, uint64_t value, void* user_data) { LoggingContext* ctx = user_data; LOGF("on_init_expr_i64_const_expr(index: %u, value: %" PRIu64 ")\n", index, value); FORWARD(on_init_expr_i64_const_expr, index, value); } static WasmBinaryReader s_logging_binary_reader = { .user_data = NULL, .on_error = logging_on_error, .begin_module = logging_begin_module, .end_module = logging_end_module, .begin_custom_section = logging_begin_custom_section, .end_custom_section = logging_end_custom_section, .begin_signature_section = logging_begin_signature_section, .on_signature_count = logging_on_signature_count, .on_signature = logging_on_signature, .end_signature_section = logging_end_signature_section, .begin_import_section = logging_begin_import_section, .on_import_count = logging_on_import_count, .on_import = logging_on_import, .on_import_func = logging_on_import_func, .on_import_table = logging_on_import_table, .on_import_memory = logging_on_import_memory, .on_import_global = logging_on_import_global, .end_import_section = logging_end_import_section, .begin_function_signatures_section = logging_begin_function_signatures_section, .on_function_signatures_count = logging_on_function_signatures_count, .on_function_signature = logging_on_function_signature, .end_function_signatures_section = logging_end_function_signatures_section, .begin_table_section = logging_begin_table_section, .on_table_count = logging_on_table_count, .on_table = logging_on_table, .end_table_section = logging_end_table_section, .begin_memory_section = logging_begin_memory_section, .on_memory_count = logging_on_memory_count, .on_memory = logging_on_memory, .end_memory_section = logging_end_memory_section, .begin_global_section = logging_begin_global_section, .on_global_count = logging_on_global_count, .begin_global = logging_begin_global, .begin_global_init_expr = logging_begin_global_init_expr, .end_global_init_expr = logging_end_global_init_expr, .end_global = logging_end_global, .end_global_section = logging_end_global_section, .begin_export_section = logging_begin_export_section, .on_export_count = logging_on_export_count, .on_export = logging_on_export, .end_export_section = logging_end_export_section, .begin_start_section = logging_begin_start_section, .on_start_function = logging_on_start_function, .end_start_section = logging_end_start_section, .begin_function_bodies_section = logging_begin_function_bodies_section, .on_function_bodies_count = logging_on_function_bodies_count, .begin_function_body_pass = logging_begin_function_body_pass, .begin_function_body = logging_begin_function_body, .on_local_decl_count = logging_on_local_decl_count, .on_local_decl = logging_on_local_decl, .on_binary_expr = logging_on_binary_expr, .on_block_expr = logging_on_block_expr, .on_br_expr = logging_on_br_expr, .on_br_if_expr = logging_on_br_if_expr, .on_br_table_expr = logging_on_br_table_expr, .on_call_expr = logging_on_call_expr, .on_call_import_expr = logging_on_call_import_expr, .on_call_indirect_expr = logging_on_call_indirect_expr, .on_compare_expr = logging_on_compare_expr, .on_convert_expr = logging_on_convert_expr, .on_drop_expr = logging_on_drop_expr, .on_else_expr = logging_on_else_expr, .on_end_expr = logging_on_end_expr, .on_f32_const_expr = logging_on_f32_const_expr, .on_f64_const_expr = logging_on_f64_const_expr, .on_get_global_expr = logging_on_get_global_expr, .on_get_local_expr = logging_on_get_local_expr, .on_grow_memory_expr = logging_on_grow_memory_expr, .on_i32_const_expr = logging_on_i32_const_expr, .on_i64_const_expr = logging_on_i64_const_expr, .on_if_expr = logging_on_if_expr, .on_load_expr = logging_on_load_expr, .on_loop_expr = logging_on_loop_expr, .on_current_memory_expr = logging_on_current_memory_expr, .on_nop_expr = logging_on_nop_expr, .on_return_expr = logging_on_return_expr, .on_select_expr = logging_on_select_expr, .on_set_global_expr = logging_on_set_global_expr, .on_set_local_expr = logging_on_set_local_expr, .on_store_expr = logging_on_store_expr, .on_tee_local_expr = logging_on_tee_local_expr, .on_unary_expr = logging_on_unary_expr, .on_unreachable_expr = logging_on_unreachable_expr, .end_function_body = logging_end_function_body, .end_function_body_pass = logging_end_function_body_pass, .end_function_bodies_section = logging_end_function_bodies_section, .begin_elem_section = logging_begin_elem_section, .on_elem_segment_count = logging_on_elem_segment_count, .begin_elem_segment = logging_begin_elem_segment, .begin_elem_segment_init_expr = logging_begin_elem_segment_init_expr, .end_elem_segment_init_expr = logging_end_elem_segment_init_expr, .on_elem_segment_function_index_count = logging_on_elem_segment_function_index_count, .on_elem_segment_function_index = logging_on_elem_segment_function_index, .end_elem_segment = logging_end_elem_segment, .end_elem_section = logging_end_elem_section, .begin_data_section = logging_begin_data_section, .on_data_segment_count = logging_on_data_segment_count, .begin_data_segment = logging_begin_data_segment, .begin_data_segment_init_expr = logging_begin_data_segment_init_expr, .end_data_segment_init_expr = logging_end_data_segment_init_expr, .on_data_segment_data = logging_on_data_segment_data, .end_data_segment = logging_end_data_segment, .end_data_section = logging_end_data_section, .begin_names_section = logging_begin_names_section, .on_function_names_count = logging_on_function_names_count, .on_function_name = logging_on_function_name, .on_local_names_count = logging_on_local_names_count, .on_local_name = logging_on_local_name, .end_names_section = logging_end_names_section, .on_init_expr_f32_const_expr = logging_on_init_expr_f32_const_expr, .on_init_expr_f64_const_expr = logging_on_init_expr_f64_const_expr, .on_init_expr_get_global_expr = logging_on_init_expr_get_global_expr, .on_init_expr_i32_const_expr = logging_on_init_expr_i32_const_expr, .on_init_expr_i64_const_expr = logging_on_init_expr_i64_const_expr, }; static void read_init_expr(Context* ctx, uint32_t index) { uint8_t opcode; in_u8(ctx, &opcode, "opcode"); switch (opcode) { case WASM_OPCODE_I32_CONST: { uint32_t value = 0; in_i32_leb128(ctx, &value, "init_expr i32.const value"); CALLBACK(on_init_expr_i32_const_expr, index, value); break; } case WASM_OPCODE_I64_CONST: { uint64_t value = 0; in_i64_leb128(ctx, &value, "init_expr i64.const value"); CALLBACK(on_init_expr_i64_const_expr, index, value); break; } case WASM_OPCODE_F32_CONST: { uint32_t value_bits = 0; in_f32(ctx, &value_bits, "init_expr f32.const value"); CALLBACK(on_init_expr_f32_const_expr, index, value_bits); break; } case WASM_OPCODE_F64_CONST: { uint64_t value_bits = 0; in_f64(ctx, &value_bits, "init_expr f64.const value"); CALLBACK(on_init_expr_f64_const_expr, index, value_bits); break; } case WASM_OPCODE_GET_GLOBAL: { uint32_t global_index; in_u32_leb128(ctx, &global_index, "init_expr get_global index"); CALLBACK(on_init_expr_get_global_expr, index, global_index); break; } case WASM_OPCODE_END: return; default: RAISE_ERROR("unexpected opcode in initializer expression: %d (0x%x)", opcode, opcode); break; } in_u8(ctx, &opcode, "opcode"); RAISE_ERROR_UNLESS(opcode == WASM_OPCODE_END, "expected END opcode after initializer expression"); } static void read_table(Context* ctx, WasmType* out_elem_type, WasmLimits* out_elem_limits) { in_type(ctx, out_elem_type, "table elem type"); RAISE_ERROR_UNLESS(*out_elem_type == WASM_TYPE_ANYFUNC, "table elem type must by anyfunc"); uint32_t flags; uint32_t initial; uint32_t max = 0; in_u32_leb128(ctx, &flags, "table flags"); in_u32_leb128(ctx, &initial, "table initial elem count"); WasmBool has_max = flags & WASM_BINARY_LIMITS_HAS_MAX_FLAG; if (has_max) { in_u32_leb128(ctx, &max, "table max elem count"); RAISE_ERROR_UNLESS(initial <= max, "table initial elem count must be <= max elem count"); } out_elem_limits->has_max = has_max; out_elem_limits->initial = initial; out_elem_limits->max = max; } static void read_memory(Context* ctx, WasmLimits* out_page_limits) { uint32_t flags; uint32_t initial; uint32_t max = 0; in_u32_leb128(ctx, &flags, "memory flags"); in_u32_leb128(ctx, &initial, "memory initial page count"); WasmBool has_max = flags & WASM_BINARY_LIMITS_HAS_MAX_FLAG; RAISE_ERROR_UNLESS(initial <= WASM_MAX_PAGES, "invalid memory initial size"); if (has_max) { in_u32_leb128(ctx, &max, "memory max page count"); RAISE_ERROR_UNLESS(max <= WASM_MAX_PAGES, "invalid memory max size"); RAISE_ERROR_UNLESS(initial <= max, "memory initial size must be <= max size"); } out_page_limits->has_max = has_max; out_page_limits->initial = initial; out_page_limits->max = max; } static void read_global_header(Context* ctx, WasmType* out_type, WasmBool* out_mutable) { WasmType global_type; uint8_t mutable_; in_type(ctx, &global_type, "global type"); RAISE_ERROR_UNLESS(is_concrete_type(global_type), "expected valid global type"); in_u8(ctx, &mutable_, "global mutability"); RAISE_ERROR_UNLESS(mutable_ <= 1, "global mutability must be 0 or 1"); *out_type = global_type; *out_mutable = mutable_; } static void read_function_body(Context* ctx, uint32_t end_offset) { WasmBool seen_end_opcode = WASM_FALSE; while (ctx->offset < end_offset) { uint8_t opcode; in_u8(ctx, &opcode, "opcode"); CALLBACK_CTX(on_opcode, opcode); switch (opcode) { case WASM_OPCODE_UNREACHABLE: CALLBACK0(on_unreachable_expr); CALLBACK_CTX0(on_opcode_bare); break; case WASM_OPCODE_BLOCK: { WasmType sig_type; in_type(ctx, &sig_type, "block signature type"); RAISE_ERROR_UNLESS(is_inline_sig_type(sig_type), "expected valid block signature type"); uint32_t num_types = sig_type == WASM_TYPE_VOID ? 0 : 1; CALLBACK(on_block_expr, num_types, &sig_type); CALLBACK_CTX(on_opcode_block_sig, num_types, &sig_type); break; } case WASM_OPCODE_LOOP: { WasmType sig_type; in_type(ctx, &sig_type, "loop signature type"); RAISE_ERROR_UNLESS(is_inline_sig_type(sig_type), "expected valid block signature type"); uint32_t num_types = sig_type == WASM_TYPE_VOID ? 0 : 1; CALLBACK(on_loop_expr, num_types, &sig_type); CALLBACK_CTX(on_opcode_block_sig, num_types, &sig_type); break; } case WASM_OPCODE_IF: { WasmType sig_type; in_type(ctx, &sig_type, "if signature type"); RAISE_ERROR_UNLESS(is_inline_sig_type(sig_type), "expected valid block signature type"); uint32_t num_types = sig_type == WASM_TYPE_VOID ? 0 : 1; CALLBACK(on_if_expr, num_types, &sig_type); CALLBACK_CTX(on_opcode_block_sig, num_types, &sig_type); break; } case WASM_OPCODE_ELSE: CALLBACK0(on_else_expr); CALLBACK_CTX0(on_opcode_bare); break; case WASM_OPCODE_SELECT: CALLBACK0(on_select_expr); CALLBACK_CTX0(on_opcode_bare); break; case WASM_OPCODE_BR: { uint32_t depth; in_u32_leb128(ctx, &depth, "br depth"); CALLBACK(on_br_expr, depth); CALLBACK_CTX(on_opcode_uint32, depth); break; } case WASM_OPCODE_BR_IF: { uint32_t depth; in_u32_leb128(ctx, &depth, "br_if depth"); CALLBACK(on_br_if_expr, depth); CALLBACK_CTX(on_opcode_uint32, depth); break; } case WASM_OPCODE_BR_TABLE: { uint32_t num_targets; in_u32_leb128(ctx, &num_targets, "br_table target count"); if (num_targets > ctx->target_depths.capacity) { wasm_reserve_uint32s(ctx->allocator, &ctx->target_depths, num_targets); ctx->target_depths.size = num_targets; } uint32_t i; for (i = 0; i < num_targets; ++i) { uint32_t target_depth; in_u32_leb128(ctx, &target_depth, "br_table target depth"); ctx->target_depths.data[i] = target_depth; } uint32_t default_target_depth; in_u32_leb128(ctx, &default_target_depth, "br_table default target depth"); CALLBACK_CTX(on_br_table_expr, num_targets, ctx->target_depths.data, default_target_depth); break; } case WASM_OPCODE_RETURN: CALLBACK0(on_return_expr); CALLBACK_CTX0(on_opcode_bare); break; case WASM_OPCODE_NOP: CALLBACK0(on_nop_expr); CALLBACK_CTX0(on_opcode_bare); break; case WASM_OPCODE_DROP: CALLBACK0(on_drop_expr); CALLBACK_CTX0(on_opcode_bare); break; case WASM_OPCODE_END: if (ctx->offset == end_offset) seen_end_opcode = WASM_TRUE; else CALLBACK0(on_end_expr); break; case WASM_OPCODE_I32_CONST: { uint32_t value = 0; in_i32_leb128(ctx, &value, "i32.const value"); CALLBACK(on_i32_const_expr, value); CALLBACK_CTX(on_opcode_uint32, value); break; } case WASM_OPCODE_I64_CONST: { uint64_t value = 0; in_i64_leb128(ctx, &value, "i64.const value"); CALLBACK(on_i64_const_expr, value); CALLBACK_CTX(on_opcode_uint64, value); break; } case WASM_OPCODE_F32_CONST: { uint32_t value_bits = 0; in_f32(ctx, &value_bits, "f32.const value"); CALLBACK(on_f32_const_expr, value_bits); CALLBACK_CTX(on_opcode_f32, value_bits); break; } case WASM_OPCODE_F64_CONST: { uint64_t value_bits = 0; in_f64(ctx, &value_bits, "f64.const value"); CALLBACK(on_f64_const_expr, value_bits); CALLBACK_CTX(on_opcode_f64, value_bits); break; } case WASM_OPCODE_GET_GLOBAL: { uint32_t global_index; in_u32_leb128(ctx, &global_index, "get_global global index"); CALLBACK(on_get_global_expr, global_index); CALLBACK_CTX(on_opcode_uint32, global_index); break; } case WASM_OPCODE_GET_LOCAL: { uint32_t local_index; in_u32_leb128(ctx, &local_index, "get_local local index"); CALLBACK(on_get_local_expr, local_index); CALLBACK_CTX(on_opcode_uint32, local_index); break; } case WASM_OPCODE_SET_GLOBAL: { uint32_t global_index; in_u32_leb128(ctx, &global_index, "set_global global index"); CALLBACK(on_set_global_expr, global_index); CALLBACK_CTX(on_opcode_uint32, global_index); break; } case WASM_OPCODE_SET_LOCAL: { uint32_t local_index; in_u32_leb128(ctx, &local_index, "set_local local index"); CALLBACK(on_set_local_expr, local_index); CALLBACK_CTX(on_opcode_uint32, local_index); break; } case WASM_OPCODE_CALL: { uint32_t func_index; in_u32_leb128(ctx, &func_index, "call function index"); RAISE_ERROR_UNLESS(func_index < num_total_funcs(ctx), "invalid call function index"); CALLBACK(on_call_expr, func_index); CALLBACK_CTX(on_opcode_uint32, func_index); break; } case WASM_OPCODE_CALL_INDIRECT: { uint32_t sig_index; in_u32_leb128(ctx, &sig_index, "call_indirect signature index"); RAISE_ERROR_UNLESS(sig_index < ctx->num_signatures, "invalid call_indirect signature index"); uint32_t reserved; in_u32_leb128(ctx, &reserved, "call_indirect reserved"); RAISE_ERROR_UNLESS(reserved == 0, "call_indirect reserved value must be 0"); CALLBACK(on_call_indirect_expr, sig_index); CALLBACK_CTX(on_opcode_uint32_uint32, sig_index, reserved); break; } case WASM_OPCODE_TEE_LOCAL: { uint32_t local_index; in_u32_leb128(ctx, &local_index, "tee_local local index"); CALLBACK(on_tee_local_expr, local_index); CALLBACK_CTX(on_opcode_uint32, local_index); break; } case WASM_OPCODE_I32_LOAD8_S: case WASM_OPCODE_I32_LOAD8_U: case WASM_OPCODE_I32_LOAD16_S: case WASM_OPCODE_I32_LOAD16_U: case WASM_OPCODE_I64_LOAD8_S: case WASM_OPCODE_I64_LOAD8_U: case WASM_OPCODE_I64_LOAD16_S: case WASM_OPCODE_I64_LOAD16_U: case WASM_OPCODE_I64_LOAD32_S: case WASM_OPCODE_I64_LOAD32_U: case WASM_OPCODE_I32_LOAD: case WASM_OPCODE_I64_LOAD: case WASM_OPCODE_F32_LOAD: case WASM_OPCODE_F64_LOAD: { uint32_t alignment_log2; in_u32_leb128(ctx, &alignment_log2, "load alignment"); uint32_t offset; in_u32_leb128(ctx, &offset, "load offset"); CALLBACK(on_load_expr, opcode, alignment_log2, offset); CALLBACK_CTX(on_opcode_uint32_uint32, alignment_log2, offset); break; } case WASM_OPCODE_I32_STORE8: case WASM_OPCODE_I32_STORE16: case WASM_OPCODE_I64_STORE8: case WASM_OPCODE_I64_STORE16: case WASM_OPCODE_I64_STORE32: case WASM_OPCODE_I32_STORE: case WASM_OPCODE_I64_STORE: case WASM_OPCODE_F32_STORE: case WASM_OPCODE_F64_STORE: { uint32_t alignment_log2; in_u32_leb128(ctx, &alignment_log2, "store alignment"); uint32_t offset; in_u32_leb128(ctx, &offset, "store offset"); CALLBACK(on_store_expr, opcode, alignment_log2, offset); CALLBACK_CTX(on_opcode_uint32_uint32, alignment_log2, offset); break; } case WASM_OPCODE_CURRENT_MEMORY: { uint32_t reserved; in_u32_leb128(ctx, &reserved, "current_memory reserved"); RAISE_ERROR_UNLESS(reserved == 0, "current_memory reserved value must be 0"); CALLBACK0(on_current_memory_expr); CALLBACK_CTX(on_opcode_uint32, reserved); break; } case WASM_OPCODE_GROW_MEMORY: { uint32_t reserved; in_u32_leb128(ctx, &reserved, "grow_memory reserved"); RAISE_ERROR_UNLESS(reserved == 0, "grow_memory reserved value must be 0"); CALLBACK0(on_grow_memory_expr); CALLBACK_CTX(on_opcode_uint32, reserved); break; } case WASM_OPCODE_I32_ADD: case WASM_OPCODE_I32_SUB: case WASM_OPCODE_I32_MUL: case WASM_OPCODE_I32_DIV_S: case WASM_OPCODE_I32_DIV_U: case WASM_OPCODE_I32_REM_S: case WASM_OPCODE_I32_REM_U: case WASM_OPCODE_I32_AND: case WASM_OPCODE_I32_OR: case WASM_OPCODE_I32_XOR: case WASM_OPCODE_I32_SHL: case WASM_OPCODE_I32_SHR_U: case WASM_OPCODE_I32_SHR_S: case WASM_OPCODE_I32_ROTR: case WASM_OPCODE_I32_ROTL: case WASM_OPCODE_I64_ADD: case WASM_OPCODE_I64_SUB: case WASM_OPCODE_I64_MUL: case WASM_OPCODE_I64_DIV_S: case WASM_OPCODE_I64_DIV_U: case WASM_OPCODE_I64_REM_S: case WASM_OPCODE_I64_REM_U: case WASM_OPCODE_I64_AND: case WASM_OPCODE_I64_OR: case WASM_OPCODE_I64_XOR: case WASM_OPCODE_I64_SHL: case WASM_OPCODE_I64_SHR_U: case WASM_OPCODE_I64_SHR_S: case WASM_OPCODE_I64_ROTR: case WASM_OPCODE_I64_ROTL: case WASM_OPCODE_F32_ADD: case WASM_OPCODE_F32_SUB: case WASM_OPCODE_F32_MUL: case WASM_OPCODE_F32_DIV: case WASM_OPCODE_F32_MIN: case WASM_OPCODE_F32_MAX: case WASM_OPCODE_F32_COPYSIGN: case WASM_OPCODE_F64_ADD: case WASM_OPCODE_F64_SUB: case WASM_OPCODE_F64_MUL: case WASM_OPCODE_F64_DIV: case WASM_OPCODE_F64_MIN: case WASM_OPCODE_F64_MAX: case WASM_OPCODE_F64_COPYSIGN: CALLBACK(on_binary_expr, opcode); CALLBACK_CTX0(on_opcode_bare); break; case WASM_OPCODE_I32_EQ: case WASM_OPCODE_I32_NE: case WASM_OPCODE_I32_LT_S: case WASM_OPCODE_I32_LE_S: case WASM_OPCODE_I32_LT_U: case WASM_OPCODE_I32_LE_U: case WASM_OPCODE_I32_GT_S: case WASM_OPCODE_I32_GE_S: case WASM_OPCODE_I32_GT_U: case WASM_OPCODE_I32_GE_U: case WASM_OPCODE_I64_EQ: case WASM_OPCODE_I64_NE: case WASM_OPCODE_I64_LT_S: case WASM_OPCODE_I64_LE_S: case WASM_OPCODE_I64_LT_U: case WASM_OPCODE_I64_LE_U: case WASM_OPCODE_I64_GT_S: case WASM_OPCODE_I64_GE_S: case WASM_OPCODE_I64_GT_U: case WASM_OPCODE_I64_GE_U: case WASM_OPCODE_F32_EQ: case WASM_OPCODE_F32_NE: case WASM_OPCODE_F32_LT: case WASM_OPCODE_F32_LE: case WASM_OPCODE_F32_GT: case WASM_OPCODE_F32_GE: case WASM_OPCODE_F64_EQ: case WASM_OPCODE_F64_NE: case WASM_OPCODE_F64_LT: case WASM_OPCODE_F64_LE: case WASM_OPCODE_F64_GT: case WASM_OPCODE_F64_GE: CALLBACK(on_compare_expr, opcode); CALLBACK_CTX0(on_opcode_bare); break; case WASM_OPCODE_I32_CLZ: case WASM_OPCODE_I32_CTZ: case WASM_OPCODE_I32_POPCNT: case WASM_OPCODE_I64_CLZ: case WASM_OPCODE_I64_CTZ: case WASM_OPCODE_I64_POPCNT: case WASM_OPCODE_F32_ABS: case WASM_OPCODE_F32_NEG: case WASM_OPCODE_F32_CEIL: case WASM_OPCODE_F32_FLOOR: case WASM_OPCODE_F32_TRUNC: case WASM_OPCODE_F32_NEAREST: case WASM_OPCODE_F32_SQRT: case WASM_OPCODE_F64_ABS: case WASM_OPCODE_F64_NEG: case WASM_OPCODE_F64_CEIL: case WASM_OPCODE_F64_FLOOR: case WASM_OPCODE_F64_TRUNC: case WASM_OPCODE_F64_NEAREST: case WASM_OPCODE_F64_SQRT: CALLBACK(on_unary_expr, opcode); CALLBACK_CTX0(on_opcode_bare); break; case WASM_OPCODE_I32_TRUNC_S_F32: case WASM_OPCODE_I32_TRUNC_S_F64: case WASM_OPCODE_I32_TRUNC_U_F32: case WASM_OPCODE_I32_TRUNC_U_F64: case WASM_OPCODE_I32_WRAP_I64: case WASM_OPCODE_I64_TRUNC_S_F32: case WASM_OPCODE_I64_TRUNC_S_F64: case WASM_OPCODE_I64_TRUNC_U_F32: case WASM_OPCODE_I64_TRUNC_U_F64: case WASM_OPCODE_I64_EXTEND_S_I32: case WASM_OPCODE_I64_EXTEND_U_I32: case WASM_OPCODE_F32_CONVERT_S_I32: case WASM_OPCODE_F32_CONVERT_U_I32: case WASM_OPCODE_F32_CONVERT_S_I64: case WASM_OPCODE_F32_CONVERT_U_I64: case WASM_OPCODE_F32_DEMOTE_F64: case WASM_OPCODE_F32_REINTERPRET_I32: case WASM_OPCODE_F64_CONVERT_S_I32: case WASM_OPCODE_F64_CONVERT_U_I32: case WASM_OPCODE_F64_CONVERT_S_I64: case WASM_OPCODE_F64_CONVERT_U_I64: case WASM_OPCODE_F64_PROMOTE_F32: case WASM_OPCODE_F64_REINTERPRET_I64: case WASM_OPCODE_I32_REINTERPRET_F32: case WASM_OPCODE_I64_REINTERPRET_F64: case WASM_OPCODE_I32_EQZ: case WASM_OPCODE_I64_EQZ: CALLBACK(on_convert_expr, opcode); CALLBACK_CTX0(on_opcode_bare); break; default: RAISE_ERROR("unexpected opcode: %d (0x%x)", opcode, opcode); } } RAISE_ERROR_UNLESS(ctx->offset == end_offset, "function body longer than given size"); RAISE_ERROR_UNLESS(seen_end_opcode, "function body must end with END opcode"); } static void read_custom_section(Context* ctx, uint32_t section_size) { WasmStringSlice section_name; in_str(ctx, §ion_name, "section name"); CALLBACK_CTX(begin_custom_section, section_size, section_name); WasmBool name_section_ok = ctx->last_section_code >= WASM_BINARY_SECTION_IMPORT; if (ctx->options->read_debug_names && name_section_ok && strncmp(section_name.start, WASM_BINARY_SECTION_NAME, section_name.length) == 0) { CALLBACK_SECTION(begin_names_section, section_size); uint32_t i, num_functions; in_u32_leb128(ctx, &num_functions, "function name count"); RAISE_ERROR_UNLESS(num_functions <= num_total_funcs(ctx), "function name count > function signature count"); CALLBACK(on_function_names_count, num_functions); for (i = 0; i < num_functions; ++i) { WasmStringSlice function_name; in_str(ctx, &function_name, "function name"); CALLBACK(on_function_name, i, function_name); uint32_t num_locals; in_u32_leb128(ctx, &num_locals, "local name count"); CALLBACK(on_local_names_count, i, num_locals); uint32_t j; for (j = 0; j < num_locals; ++j) { WasmStringSlice local_name; in_str(ctx, &local_name, "local name"); CALLBACK(on_local_name, i, j, local_name); } } CALLBACK0(end_names_section); } else { /* This is an unknown custom section, skip it. */ ctx->offset = ctx->read_end; } CALLBACK_CTX0(end_custom_section); } static void read_type_section(Context* ctx, uint32_t section_size) { CALLBACK_SECTION(begin_signature_section, section_size); uint32_t i; in_u32_leb128(ctx, &ctx->num_signatures, "type count"); CALLBACK(on_signature_count, ctx->num_signatures); for (i = 0; i < ctx->num_signatures; ++i) { WasmType form; in_type(ctx, &form, "type form"); RAISE_ERROR_UNLESS(form == WASM_TYPE_FUNC, "unexpected type form"); uint32_t num_params; in_u32_leb128(ctx, &num_params, "function param count"); if (num_params > ctx->param_types.capacity) wasm_reserve_types(ctx->allocator, &ctx->param_types, num_params); uint32_t j; for (j = 0; j < num_params; ++j) { WasmType param_type; in_type(ctx, ¶m_type, "function param type"); RAISE_ERROR_UNLESS(is_concrete_type(param_type), "expected valid param type"); ctx->param_types.data[j] = param_type; } uint32_t num_results; in_u32_leb128(ctx, &num_results, "function result count"); RAISE_ERROR_UNLESS(num_results <= 1, "result count must be 0 or 1"); WasmType result_type = WASM_TYPE_VOID; if (num_results) { in_type(ctx, &result_type, "function result type"); RAISE_ERROR_UNLESS(is_concrete_type(result_type), "expected valid result type"); } CALLBACK(on_signature, i, num_params, ctx->param_types.data, num_results, &result_type); } CALLBACK_CTX0(end_signature_section); } static void read_import_section(Context* ctx, uint32_t section_size) { CALLBACK_SECTION(begin_import_section, section_size); uint32_t i; in_u32_leb128(ctx, &ctx->num_imports, "import count"); CALLBACK(on_import_count, ctx->num_imports); for (i = 0; i < ctx->num_imports; ++i) { WasmStringSlice module_name; in_str(ctx, &module_name, "import module name"); WasmStringSlice field_name; in_str(ctx, &field_name, "import field name"); CALLBACK(on_import, i, module_name, field_name); uint32_t kind; in_u32_leb128(ctx, &kind, "import kind"); switch (kind) { case WASM_EXTERNAL_KIND_FUNC: { uint32_t sig_index; in_u32_leb128(ctx, &sig_index, "import signature index"); RAISE_ERROR_UNLESS(sig_index < ctx->num_signatures, "invalid import signature index"); CALLBACK(on_import_func, i, sig_index); ctx->num_func_imports++; break; } case WASM_EXTERNAL_KIND_TABLE: { WasmType elem_type; WasmLimits elem_limits; read_table(ctx, &elem_type, &elem_limits); CALLBACK(on_import_table, i, elem_type, &elem_limits); ctx->num_table_imports++; break; } case WASM_EXTERNAL_KIND_MEMORY: { WasmLimits page_limits; read_memory(ctx, &page_limits); CALLBACK(on_import_memory, i, &page_limits); ctx->num_memory_imports++; break; } case WASM_EXTERNAL_KIND_GLOBAL: { WasmType type; WasmBool mutable_; read_global_header(ctx, &type, &mutable_); CALLBACK(on_import_global, i, type, mutable_); ctx->num_global_imports++; break; } default: RAISE_ERROR("invalid import kind: %d", kind); } } CALLBACK_CTX0(end_import_section); } static void read_function_section(Context* ctx, uint32_t section_size) { CALLBACK_SECTION(begin_function_signatures_section, section_size); uint32_t i; in_u32_leb128(ctx, &ctx->num_function_signatures, "function signature count"); CALLBACK(on_function_signatures_count, ctx->num_function_signatures); for (i = 0; i < ctx->num_function_signatures; ++i) { uint32_t sig_index; in_u32_leb128(ctx, &sig_index, "function signature index"); RAISE_ERROR_UNLESS(sig_index < ctx->num_signatures, "invalid function signature index: %d", sig_index); CALLBACK(on_function_signature, i, sig_index); } CALLBACK_CTX0(end_function_signatures_section); } static void read_table_section(Context* ctx, uint32_t section_size) { CALLBACK_SECTION(begin_table_section, section_size); uint32_t i; in_u32_leb128(ctx, &ctx->num_tables, "table count"); RAISE_ERROR_UNLESS(ctx->num_tables <= 1, "table count (%d) must be 0 or 1", ctx->num_tables); CALLBACK(on_table_count, ctx->num_tables); for (i = 0; i < ctx->num_tables; ++i) { WasmType elem_type; WasmLimits elem_limits; read_table(ctx, &elem_type, &elem_limits); CALLBACK(on_table, i, elem_type, &elem_limits); } CALLBACK_CTX0(end_table_section); } static void read_memory_section(Context* ctx, uint32_t section_size) { CALLBACK_SECTION(begin_memory_section, section_size); uint32_t i; in_u32_leb128(ctx, &ctx->num_memories, "memory count"); RAISE_ERROR_UNLESS(ctx->num_memories <= 1, "memory count must be 0 or 1"); CALLBACK(on_memory_count, ctx->num_memories); for (i = 0; i < ctx->num_memories; ++i) { WasmLimits page_limits; read_memory(ctx, &page_limits); CALLBACK(on_memory, i, &page_limits); } CALLBACK_CTX0(end_memory_section); } static void read_global_section(Context* ctx, uint32_t section_size) { CALLBACK_SECTION(begin_global_section, section_size); uint32_t i; in_u32_leb128(ctx, &ctx->num_globals, "global count"); CALLBACK(on_global_count, ctx->num_globals); for (i = 0; i < ctx->num_globals; ++i) { WasmType global_type; WasmBool mutable_; read_global_header(ctx, &global_type, &mutable_); CALLBACK(begin_global, i, global_type, mutable_); CALLBACK(begin_global_init_expr, i); read_init_expr(ctx, i); CALLBACK(end_global_init_expr, i); CALLBACK(end_global, i); } CALLBACK_CTX0(end_global_section); } static void read_export_section(Context* ctx, uint32_t section_size) { CALLBACK_SECTION(begin_export_section, section_size); uint32_t i; in_u32_leb128(ctx, &ctx->num_exports, "export count"); CALLBACK(on_export_count, ctx->num_exports); for (i = 0; i < ctx->num_exports; ++i) { WasmStringSlice name; in_str(ctx, &name, "export item name"); uint8_t external_kind; in_u8(ctx, &external_kind, "export external kind"); RAISE_ERROR_UNLESS(is_valid_external_kind(external_kind), "invalid export external kind"); uint32_t item_index; in_u32_leb128(ctx, &item_index, "export item index"); switch (external_kind) { case WASM_EXTERNAL_KIND_FUNC: RAISE_ERROR_UNLESS(item_index < num_total_funcs(ctx), "invalid export func index"); break; case WASM_EXTERNAL_KIND_TABLE: RAISE_ERROR_UNLESS(item_index < num_total_tables(ctx), "invalid export table index"); break; case WASM_EXTERNAL_KIND_MEMORY: RAISE_ERROR_UNLESS(item_index < num_total_memories(ctx), "invalid export memory index"); break; case WASM_EXTERNAL_KIND_GLOBAL: RAISE_ERROR_UNLESS(item_index < num_total_globals(ctx), "invalid export global index"); break; case WASM_NUM_EXTERNAL_KINDS: assert(0); break; } CALLBACK(on_export, i, external_kind, item_index, name); } CALLBACK_CTX0(end_export_section); } static void read_start_section(Context* ctx, uint32_t section_size) { CALLBACK_SECTION(begin_start_section, section_size); uint32_t func_index; in_u32_leb128(ctx, &func_index, "start function index"); RAISE_ERROR_UNLESS(func_index < num_total_funcs(ctx), "invalid start function index"); CALLBACK(on_start_function, func_index); CALLBACK_CTX0(end_start_section); } static void read_elem_section(Context* ctx, uint32_t section_size) { CALLBACK_SECTION(begin_elem_section, section_size); uint32_t i, num_elem_segments; in_u32_leb128(ctx, &num_elem_segments, "elem segment count"); CALLBACK(on_elem_segment_count, num_elem_segments); RAISE_ERROR_UNLESS(num_elem_segments == 0 || num_total_tables(ctx) > 0, "elem section without table section"); for (i = 0; i < num_elem_segments; ++i) { uint32_t table_index; in_u32_leb128(ctx, &table_index, "elem segment table index"); CALLBACK(begin_elem_segment, i, table_index); CALLBACK(begin_elem_segment_init_expr, i); read_init_expr(ctx, i); CALLBACK(end_elem_segment_init_expr, i); uint32_t j, num_function_indexes; in_u32_leb128(ctx, &num_function_indexes, "elem segment function index count"); CALLBACK_CTX(on_elem_segment_function_index_count, i, num_function_indexes); for (j = 0; j < num_function_indexes; ++j) { uint32_t func_index; in_u32_leb128(ctx, &func_index, "elem segment function index"); CALLBACK(on_elem_segment_function_index, i, func_index); } CALLBACK(end_elem_segment, i); } CALLBACK_CTX0(end_elem_section); } static void read_code_section(Context* ctx, uint32_t section_size) { CALLBACK_SECTION(begin_function_bodies_section, section_size); uint32_t i; in_u32_leb128(ctx, &ctx->num_function_bodies, "function body count"); RAISE_ERROR_UNLESS(ctx->num_function_signatures == ctx->num_function_bodies, "function signature count != function body count"); CALLBACK(on_function_bodies_count, ctx->num_function_bodies); for (i = 0; i < ctx->num_function_bodies; ++i) { uint32_t func_offset = ctx->offset; ctx->offset = func_offset; CALLBACK(begin_function_body, i); uint32_t body_size; in_u32_leb128(ctx, &body_size, "function body size"); uint32_t body_start_offset = ctx->offset; uint32_t end_offset = body_start_offset + body_size; uint32_t num_local_decls; in_u32_leb128(ctx, &num_local_decls, "local declaration count"); CALLBACK(on_local_decl_count, num_local_decls); uint32_t k; for (k = 0; k < num_local_decls; ++k) { uint32_t num_local_types; in_u32_leb128(ctx, &num_local_types, "local type count"); WasmType local_type; in_type(ctx, &local_type, "local type"); RAISE_ERROR_UNLESS(is_concrete_type(local_type), "expected valid local type"); CALLBACK(on_local_decl, k, num_local_types, local_type); } read_function_body(ctx, end_offset); CALLBACK(end_function_body, i); } CALLBACK_CTX0(end_function_bodies_section); } static void read_data_section(Context* ctx, uint32_t section_size) { CALLBACK_SECTION(begin_data_section, section_size); uint32_t i, num_data_segments; in_u32_leb128(ctx, &num_data_segments, "data segment count"); CALLBACK(on_data_segment_count, num_data_segments); RAISE_ERROR_UNLESS(num_data_segments == 0 || num_total_memories(ctx) > 0, "data section without memory section"); for (i = 0; i < num_data_segments; ++i) { uint32_t memory_index; in_u32_leb128(ctx, &memory_index, "data segment memory index"); CALLBACK(begin_data_segment, i, memory_index); CALLBACK(begin_data_segment_init_expr, i); read_init_expr(ctx, i); CALLBACK(end_data_segment_init_expr, i); uint32_t data_size; const void* data; in_bytes(ctx, &data, &data_size, "data segment data"); CALLBACK(on_data_segment_data, i, data, data_size); CALLBACK(end_data_segment, i); } CALLBACK_CTX0(end_data_section); } static void read_sections(Context* ctx) { while (ctx->offset < ctx->data_size) { uint32_t section_code; uint32_t section_size; /* Temporarily reset read_end to the full data size so the next section * can be read. */ ctx->read_end = ctx->data_size; in_u32_leb128(ctx, §ion_code, "section code"); in_u32_leb128(ctx, §ion_size, "section size"); ctx->read_end = ctx->offset + section_size; if (ctx->read_end > ctx->data_size) RAISE_ERROR("invalid section size: extends past end"); if (ctx->last_section_code != WASM_NUM_BINARY_SECTIONS && section_code != WASM_BINARY_SECTION_CUSTOM && section_code <= ctx->last_section_code) { RAISE_ERROR("section %s out of order", s_section_name[section_code]); } CALLBACK_CTX(begin_section, section_code, section_size); #define V(NAME, name, code) \ case WASM_BINARY_SECTION_##NAME: \ read_##name##_section(ctx, section_size); \ break; switch (section_code) { WASM_FOREACH_BINARY_SECTION(V) default: RAISE_ERROR("invalid section code: %u; max is %u", section_code, WASM_NUM_BINARY_SECTIONS - 1); } #undef V if (ctx->offset != ctx->read_end) { RAISE_ERROR("unfinished section (expected end: 0x%" PRIzx ")", ctx->read_end); } ctx->last_section_code = section_code; } } WasmResult wasm_read_binary(WasmAllocator* allocator, const void* data, size_t size, WasmBinaryReader* reader, uint32_t num_function_passes, const WasmReadBinaryOptions* options) { LoggingContext logging_context; WASM_ZERO_MEMORY(logging_context); logging_context.reader = reader; logging_context.stream = options->log_stream; WasmBinaryReader logging_reader = s_logging_binary_reader; logging_reader.user_data = &logging_context; Context context; WASM_ZERO_MEMORY(context); /* all the macros assume a Context* named ctx */ Context* ctx = &context; ctx->allocator = allocator; ctx->data = data; ctx->data_size = ctx->read_end = size; ctx->reader = options->log_stream ? &logging_reader : reader; ctx->options = options; ctx->last_section_code = WASM_NUM_BINARY_SECTIONS; if (setjmp(ctx->error_jmp_buf) == 1) { destroy_context(ctx); return WASM_ERROR; } wasm_reserve_types(allocator, &ctx->param_types, INITIAL_PARAM_TYPES_CAPACITY); wasm_reserve_uint32s(allocator, &ctx->target_depths, INITIAL_BR_TABLE_TARGET_CAPACITY); uint32_t magic; in_u32(ctx, &magic, "magic"); RAISE_ERROR_UNLESS(magic == WASM_BINARY_MAGIC, "bad magic value"); uint32_t version; in_u32(ctx, &version, "version"); RAISE_ERROR_UNLESS(version == WASM_BINARY_VERSION, "bad wasm file version: %#x (expected %#x)", version, WASM_BINARY_VERSION); CALLBACK(begin_module, version); read_sections(ctx); CALLBACK0(end_module); destroy_context(ctx); return WASM_OK; }