gnh1201/wasm-micro-runtime
1
0
Fork 0
mirror of https://github.com/bytecodealliance/wasm-micro-runtime.git synced 2025-05-09 05:06:17 +00:00
Code Issues Actions 9 Packages Projects Releases Wiki Activity

Enable ref types and bulk memory by default for wamrc (#838)

Browse Source 
Enable ref types feature and bulk memory feature by default for wamrc
and provide "--disable-ref-types", "--disable-bulk-memory"  to disable
them.
And remove the ref_type_flag option in wasm_loader.c which is used to
control whether to enable ref types or not when ENABLE_REF_TYPES
macro is enabled in wamrc. As the wasm binary format with ref types
is compatible with the binary format before, we can remove the option.
Also update the spec test scripts.
This commit is contained in:
liang.he 2021-11-18 17:42:49 +08:00 committed by GitHub
parent 5d48a18614
commit 1dccf39d16
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 312 additions and 576 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
core/iwasm/compilation/aot_compiler.c
View File

@ -106,6 +106,28 @@ read_leb(const uint8 *buf, const uint8 *buf_end, uint32 *p_offset,
res = (int64)res64; \ res = (int64)res64; \
} while (0) } while (0)
/**
* Since Wamrc uses a full feature Wasm loader,
* add a post-validator here to run checks according
* to options, like enable_tail_call, enable_ref_types,
* and so on.
*/
static bool
aot_validate_wasm(AOTCompContext *comp_ctx)
{
if (!comp_ctx->enable_ref_types) {
/* Doesn't support multiple tables unless enabling reference type */
if (comp_ctx->comp_data->import_table_count
+ comp_ctx->comp_data->table_count
> 1) {
aot_set_last_error("multiple tables");
return false;
}
}
return true;
}
#define COMPILE_ATOMIC_RMW(OP, NAME) \ #define COMPILE_ATOMIC_RMW(OP, NAME) \
case WASM_OP_ATOMIC_RMW_I32_##NAME: \ case WASM_OP_ATOMIC_RMW_I32_##NAME: \
bytes = 4; \ bytes = 4; \
@ -976,7 +998,13 @@ aot_compile_func(AOTCompContext *comp_ctx, uint32 func_index)
read_leb_uint32(frame_ip, frame_ip_end, opcode1); read_leb_uint32(frame_ip, frame_ip_end, opcode1);
opcode = (uint32)opcode1; opcode = (uint32)opcode1;
/* TODO: --enable-bulk-memory ? */ #if WASM_ENABLE_BULK_MEMORY != 0
if (WASM_OP_MEMORY_INIT <= opcode
&& opcode <= WASM_OP_MEMORY_FILL
&& !comp_ctx->enable_bulk_memory) {
goto unsupport_bulk_memory;
}
#endif
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
if (WASM_OP_TABLE_INIT <= opcode && opcode <= WASM_OP_TABLE_FILL if (WASM_OP_TABLE_INIT <= opcode && opcode <= WASM_OP_TABLE_FILL
@ -2457,7 +2485,7 @@ aot_compile_func(AOTCompContext *comp_ctx, uint32 func_index)
} }
default: default:
aot_set_last_error("unsupported opcode"); aot_set_last_error("unsupported SIMD opcode");
return false; return false;
} }
break; break;
@ -2488,14 +2516,21 @@ aot_compile_func(AOTCompContext *comp_ctx, uint32 func_index)
#if WASM_ENABLE_SIMD != 0 #if WASM_ENABLE_SIMD != 0
unsupport_simd: unsupport_simd:
aot_set_last_error("SIMD instruction was found, " aot_set_last_error("SIMD instruction was found, "
"try adding --enable-simd option?"); "try removing --disable-simd option");
return false; return false;
#endif #endif
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
unsupport_ref_types: unsupport_ref_types:
aot_set_last_error("reference type instruction was found, " aot_set_last_error("reference type instruction was found, "
"try adding --enable-ref-types option?"); "try removing --disable-ref-types option");
return false;
#endif
#if WASM_ENABLE_BULK_MEMORY != 0
unsupport_bulk_memory:
aot_set_last_error("bulk memory instruction was found, "
"try removing --disable-bulk-memory option");
return false; return false;
#endif #endif
@ -2510,6 +2545,10 @@ aot_compile_wasm(AOTCompContext *comp_ctx)
bool ret; bool ret;
uint32 i; uint32 i;
if (!aot_validate_wasm(comp_ctx)) {
return false;
}
bh_print_time("Begin to compile WASM bytecode to LLVM IR"); bh_print_time("Begin to compile WASM bytecode to LLVM IR");
for (i = 0; i < comp_ctx->func_ctx_count; i++) for (i = 0; i < comp_ctx->func_ctx_count; i++)
@ -2636,11 +2675,6 @@ aot_emit_object_file(AOTCompContext *comp_ctx, char *file_name)
return true; return true;
} }
#if WASM_ENABLE_REF_TYPES != 0
extern void
wasm_set_ref_types_flag(bool enable);
#endif
typedef struct AOTFileMap { typedef struct AOTFileMap {
uint8 *wasm_file_buf; uint8 *wasm_file_buf;
uint32 wasm_file_size; uint32 wasm_file_size;
@ -2743,10 +2777,6 @@ aot_compile_wasm_file(const uint8 *wasm_file_buf, uint32 wasm_file_size,
option.enable_aux_stack_frame = true; option.enable_aux_stack_frame = true;
#endif #endif
#if WASM_ENABLE_REF_TYPES != 0
wasm_set_ref_types_flag(option.enable_ref_types);
#endif
memset(&init_args, 0, sizeof(RuntimeInitArgs)); memset(&init_args, 0, sizeof(RuntimeInitArgs));
init_args.mem_alloc_type = Alloc_With_Allocator; init_args.mem_alloc_type = Alloc_With_Allocator;

348
core/iwasm/interpreter/wasm_loader.c
View File

@ -212,8 +212,7 @@ is_32bit_type(uint8 type)
{ {
if (type == VALUE_TYPE_I32 || type == VALUE_TYPE_F32 if (type == VALUE_TYPE_I32 || type == VALUE_TYPE_F32
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
|| (wasm_get_ref_types_flag() || type == VALUE_TYPE_FUNCREF || type == VALUE_TYPE_EXTERNREF
&& (type == VALUE_TYPE_FUNCREF || type == VALUE_TYPE_EXTERNREF))
#endif #endif
) )
return true; return true;
@ -234,8 +233,7 @@ is_value_type(uint8 type)
if (type == VALUE_TYPE_I32 || type == VALUE_TYPE_I64 if (type == VALUE_TYPE_I32 || type == VALUE_TYPE_I64
|| type == VALUE_TYPE_F32 || type == VALUE_TYPE_F64 || type == VALUE_TYPE_F32 || type == VALUE_TYPE_F64
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
|| (wasm_get_ref_types_flag() || type == VALUE_TYPE_FUNCREF || type == VALUE_TYPE_EXTERNREF
&& (type == VALUE_TYPE_FUNCREF || type == VALUE_TYPE_EXTERNREF))
#endif #endif
#if WASM_ENABLE_SIMD != 0 #if WASM_ENABLE_SIMD != 0
#if (WASM_ENABLE_WAMR_COMPILER != 0) || (WASM_ENABLE_JIT != 0) #if (WASM_ENABLE_WAMR_COMPILER != 0) || (WASM_ENABLE_JIT != 0)
@ -480,10 +478,6 @@ load_init_expr(const uint8 **p_buf, const uint8 *buf_end,
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
case INIT_EXPR_TYPE_FUNCREF_CONST: case INIT_EXPR_TYPE_FUNCREF_CONST:
{ {
if (!wasm_get_ref_types_flag()) {
goto illegal_opcode;
}
if (type != VALUE_TYPE_FUNCREF) if (type != VALUE_TYPE_FUNCREF)
goto fail_type_mismatch; goto fail_type_mismatch;
read_leb_uint32(p, p_end, init_expr->u.ref_index); read_leb_uint32(p, p_end, init_expr->u.ref_index);
@ -493,10 +487,6 @@ load_init_expr(const uint8 **p_buf, const uint8 *buf_end,
{ {
uint8 reftype; uint8 reftype;
if (!wasm_get_ref_types_flag()) {
goto illegal_opcode;
}
CHECK_BUF(p, p_end, 1); CHECK_BUF(p, p_end, 1);
reftype = read_uint8(p); reftype = read_uint8(p);
if (reftype != type) if (reftype != type)
@ -512,9 +502,6 @@ load_init_expr(const uint8 **p_buf, const uint8 *buf_end,
break; break;
default: default:
{ {
#if WASM_ENABLE_REF_TYPES != 0
illegal_opcode:
#endif
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"illegal opcode " "illegal opcode "
"or constant expression required " "or constant expression required "
@ -1133,8 +1120,7 @@ load_table_import(const uint8 **p_buf, const uint8 *buf_end,
declare_elem_type = read_uint8(p); declare_elem_type = read_uint8(p);
if (VALUE_TYPE_FUNCREF != declare_elem_type if (VALUE_TYPE_FUNCREF != declare_elem_type
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
&& (wasm_get_ref_types_flag() && VALUE_TYPE_EXTERNREF != declare_elem_type
&& VALUE_TYPE_EXTERNREF != declare_elem_type)
#endif #endif
) { ) {
set_error_buf(error_buf, error_buf_size, "incompatible import type"); set_error_buf(error_buf, error_buf_size, "incompatible import type");
@ -1432,8 +1418,7 @@ load_table(const uint8 **p_buf, const uint8 *buf_end, WASMTable *table,
table->elem_type = read_uint8(p); table->elem_type = read_uint8(p);
if (VALUE_TYPE_FUNCREF != table->elem_type if (VALUE_TYPE_FUNCREF != table->elem_type
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
&& (wasm_get_ref_types_flag() && VALUE_TYPE_EXTERNREF != table->elem_type
&& VALUE_TYPE_EXTERNREF != table->elem_type)
#endif #endif
) { ) {
set_error_buf(error_buf, error_buf_size, "incompatible import type"); set_error_buf(error_buf, error_buf_size, "incompatible import type");
@ -1610,16 +1595,13 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
read_leb_uint32(p, p_end, u32); read_leb_uint32(p, p_end, u32);
module->import_table_count++; module->import_table_count++;
if ( #if WASM_ENABLE_REF_TYPES == 0
#if WASM_ENABLE_REF_TYPES != 0 if (module->import_table_count > 1) {
!wasm_get_ref_types_flag() &&
#endif
module->import_table_count > 1) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"multiple tables"); "multiple tables");
return false; return false;
} }
#endif
break; break;
case IMPORT_KIND_MEMORY: /* import memory */ case IMPORT_KIND_MEMORY: /* import memory */
@ -1930,8 +1912,8 @@ load_function_section(const uint8 *buf, const uint8 *buf_end,
#endif #endif
#endif #endif
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
&& (wasm_get_ref_types_flag() && type != VALUE_TYPE_FUNCREF && type != VALUE_TYPE_FUNCREF
&& type != VALUE_TYPE_EXTERNREF) && type != VALUE_TYPE_EXTERNREF
#endif #endif
) { ) {
if (type == VALUE_TYPE_V128) if (type == VALUE_TYPE_V128)
@ -1998,15 +1980,13 @@ load_table_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
WASMTable *table; WASMTable *table;
read_leb_uint32(p, p_end, table_count); read_leb_uint32(p, p_end, table_count);
if ( #if WASM_ENABLE_REF_TYPES == 0
#if WASM_ENABLE_REF_TYPES != 0 if (module->import_table_count + table_count > 1) {
!wasm_get_ref_types_flag() &&
#endif
module->import_table_count + table_count > 1) {
/* a total of one table is allowed */ /* a total of one table is allowed */
set_error_buf(error_buf, error_buf_size, "multiple tables"); set_error_buf(error_buf, error_buf_size, "multiple tables");
return false; return false;
} }
#endif
if (table_count) { if (table_count) {
module->table_count = table_count; module->table_count = table_count;
@ -2261,14 +2241,12 @@ static bool
check_table_index(const WASMModule *module, uint32 table_index, char *error_buf, check_table_index(const WASMModule *module, uint32 table_index, char *error_buf,
uint32 error_buf_size) uint32 error_buf_size)
{ {
if ( #if WASM_ENABLE_REF_TYPES == 0
#if WASM_ENABLE_REF_TYPES != 0 if (table_index != 0) {
!wasm_get_ref_types_flag() &&
#endif
table_index != 0) {
set_error_buf(error_buf, error_buf_size, "zero byte expected"); set_error_buf(error_buf, error_buf_size, "zero byte expected");
return false; return false;
} }
#endif
if (table_index >= module->import_table_count + module->table_count) { if (table_index >= module->import_table_count + module->table_count) {
set_error_buf_v(error_buf, error_buf_size, "unknown table %d", set_error_buf_v(error_buf, error_buf_size, "unknown table %d",
@ -2347,21 +2325,15 @@ load_func_index_vec(const uint8 **p_buf, const uint8 *buf_end,
InitializerExpression init_expr = { 0 }; InitializerExpression init_expr = { 0 };
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
if (!wasm_get_ref_types_flag()) { if (!use_init_expr) {
read_leb_uint32(p, p_end, function_index); read_leb_uint32(p, p_end, function_index);
} }
else { else {
if (!use_init_expr) { if (!load_init_expr(&p, p_end, &init_expr, table_segment->elem_type,
read_leb_uint32(p, p_end, function_index); error_buf, error_buf_size))
} return false;
else {
if (!load_init_expr(&p, p_end, &init_expr,
table_segment->elem_type, error_buf,
error_buf_size))
return false;
function_index = init_expr.u.ref_index; function_index = init_expr.u.ref_index;
}
} }
#else #else
read_leb_uint32(p, p_end, function_index); read_leb_uint32(p, p_end, function_index);
@ -2412,100 +2384,90 @@ load_table_segment_section(const uint8 *buf, const uint8 *buf_end,
} }
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
if (wasm_get_ref_types_flag()) { read_leb_uint32(p, p_end, table_segment->mode);
read_leb_uint32(p, p_end, table_segment->mode); /* last three bits */
/* last three bits */ table_segment->mode = table_segment->mode & 0x07;
table_segment->mode = table_segment->mode & 0x07; switch (table_segment->mode) {
switch (table_segment->mode) { /* elemkind/elemtype + active */
/* elemkind/elemtype + active */ case 0:
case 0: case 4:
case 4: table_segment->elem_type = VALUE_TYPE_FUNCREF;
table_segment->elem_type = VALUE_TYPE_FUNCREF; table_segment->table_index = 0;
table_segment->table_index = 0;
if (!check_table_index(module, if (!check_table_index(module, table_segment->table_index,
table_segment->table_index, error_buf, error_buf_size))
error_buf, error_buf_size))
return false;
if (!load_init_expr(
&p, p_end, &table_segment->base_offset,
VALUE_TYPE_I32, error_buf, error_buf_size))
return false;
if (!load_func_index_vec(
&p, p_end, module, table_segment,
table_segment->mode == 0 ? false : true,
error_buf, error_buf_size))
return false;
break;
/* elemkind + passive/declarative */
case 1:
case 3:
if (!load_elem_type(&p, p_end,
&table_segment->elem_type, true,
error_buf, error_buf_size))
return false;
if (!load_func_index_vec(&p, p_end, module,
table_segment, false,
error_buf, error_buf_size))
return false;
break;
/* elemkind/elemtype + table_idx + active */
case 2:
case 6:
if (!load_table_index(&p, p_end, module,
&table_segment->table_index,
error_buf, error_buf_size))
return false;
if (!load_init_expr(
&p, p_end, &table_segment->base_offset,
VALUE_TYPE_I32, error_buf, error_buf_size))
return false;
if (!load_elem_type(
&p, p_end, &table_segment->elem_type,
table_segment->mode == 2 ? true : false,
error_buf, error_buf_size))
return false;
if (!load_func_index_vec(
&p, p_end, module, table_segment,
table_segment->mode == 2 ? false : true,
error_buf, error_buf_size))
return false;
break;
case 5:
case 7:
if (!load_elem_type(&p, p_end,
&table_segment->elem_type, false,
error_buf, error_buf_size))
return false;
if (!load_func_index_vec(&p, p_end, module,
table_segment, true, error_buf,
error_buf_size))
return false;
break;
default:
set_error_buf(error_buf, error_buf_size,
"unknown element segment kind");
return false; return false;
} if (!load_init_expr(&p, p_end, &table_segment->base_offset,
VALUE_TYPE_I32, error_buf,
error_buf_size))
return false;
if (!load_func_index_vec(&p, p_end, module, table_segment,
table_segment->mode == 0 ? false
: true,
error_buf, error_buf_size))
return false;
break;
/* elemkind + passive/declarative */
case 1:
case 3:
if (!load_elem_type(&p, p_end, &table_segment->elem_type,
true, error_buf, error_buf_size))
return false;
if (!load_func_index_vec(&p, p_end, module, table_segment,
false, error_buf, error_buf_size))
return false;
break;
/* elemkind/elemtype + table_idx + active */
case 2:
case 6:
if (!load_table_index(&p, p_end, module,
&table_segment->table_index,
error_buf, error_buf_size))
return false;
if (!load_init_expr(&p, p_end, &table_segment->base_offset,
VALUE_TYPE_I32, error_buf,
error_buf_size))
return false;
if (!load_elem_type(&p, p_end, &table_segment->elem_type,
table_segment->mode == 2 ? true : false,
error_buf, error_buf_size))
return false;
if (!load_func_index_vec(&p, p_end, module, table_segment,
table_segment->mode == 2 ? false
: true,
error_buf, error_buf_size))
return false;
break;
case 5:
case 7:
if (!load_elem_type(&p, p_end, &table_segment->elem_type,
false, error_buf, error_buf_size))
return false;
if (!load_func_index_vec(&p, p_end, module, table_segment,
true, error_buf, error_buf_size))
return false;
break;
default:
set_error_buf(error_buf, error_buf_size,
"unknown element segment kind");
return false;
} }
else #else
/*
* like: 00 41 05 0b 04 00 01 00 01
* for: (elem 0 (offset (i32.const 5)) $f1 $f2 $f1 $f2)
*/
if (!load_table_index(&p, p_end, module,
&table_segment->table_index, error_buf,
error_buf_size))
return false;
if (!load_init_expr(&p, p_end, &table_segment->base_offset,
VALUE_TYPE_I32, error_buf, error_buf_size))
return false;
if (!load_func_index_vec(&p, p_end, module, table_segment, false,
error_buf, error_buf_size))
return false;
#endif /* WASM_ENABLE_REF_TYPES != 0 */ #endif /* WASM_ENABLE_REF_TYPES != 0 */
{
/*
* like: 00 41 05 0b 04 00 01 00 01
* for: (elem 0 (offset (i32.const 5)) $f1 $f2 $f1 $f2)
*/
if (!load_table_index(&p, p_end, module,
&table_segment->table_index, error_buf,
error_buf_size))
return false;
if (!load_init_expr(&p, p_end, &table_segment->base_offset,
VALUE_TYPE_I32, error_buf, error_buf_size))
return false;
if (!load_func_index_vec(&p, p_end, module, table_segment,
false, error_buf, error_buf_size))
return false;
}
} }
} }
@ -3755,41 +3717,21 @@ wasm_loader_find_block_addr(WASMExecEnv *exec_env, BlockAddr *block_addr_cache,
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
case WASM_OP_SELECT_T: case WASM_OP_SELECT_T:
if (!wasm_get_ref_types_flag()) {
return false;
}
skip_leb_uint32(p, p_end); /* vec length */ skip_leb_uint32(p, p_end); /* vec length */
CHECK_BUF(p, p_end, 1); CHECK_BUF(p, p_end, 1);
u8 = read_uint8(p); /* typeidx */ u8 = read_uint8(p); /* typeidx */
break; break;
case WASM_OP_TABLE_GET: case WASM_OP_TABLE_GET:
case WASM_OP_TABLE_SET: case WASM_OP_TABLE_SET:
if (!wasm_get_ref_types_flag()) {
return false;
}
skip_leb_uint32(p, p_end); /* table index */ skip_leb_uint32(p, p_end); /* table index */
break; break;
case WASM_OP_REF_NULL: case WASM_OP_REF_NULL:
if (!wasm_get_ref_types_flag()) {
return false;
}
CHECK_BUF(p, p_end, 1); CHECK_BUF(p, p_end, 1);
u8 = read_uint8(p); /* type */ u8 = read_uint8(p); /* type */
break; break;
case WASM_OP_REF_IS_NULL: case WASM_OP_REF_IS_NULL:
if (!wasm_get_ref_types_flag()) {
return false;
}
break; break;
case WASM_OP_REF_FUNC: case WASM_OP_REF_FUNC:
if (!wasm_get_ref_types_flag()) {
return false;
}
skip_leb_uint32(p, p_end); /* func index */ skip_leb_uint32(p, p_end); /* func index */
break; break;
#endif /* WASM_ENABLE_REF_TYPES */ #endif /* WASM_ENABLE_REF_TYPES */
@ -4022,27 +3964,18 @@ wasm_loader_find_block_addr(WASMExecEnv *exec_env, BlockAddr *block_addr_cache,
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
case WASM_OP_TABLE_INIT: case WASM_OP_TABLE_INIT:
case WASM_OP_TABLE_COPY: case WASM_OP_TABLE_COPY:
if (!wasm_get_ref_types_flag()) {
return false;
}
/* tableidx */ /* tableidx */
skip_leb_uint32(p, p_end); skip_leb_uint32(p, p_end);
/* elemidx */ /* elemidx */
skip_leb_uint32(p, p_end); skip_leb_uint32(p, p_end);
break; break;
case WASM_OP_ELEM_DROP: case WASM_OP_ELEM_DROP:
if (!wasm_get_ref_types_flag()) {
return false;
}
/* elemidx */ /* elemidx */
skip_leb_uint32(p, p_end); skip_leb_uint32(p, p_end);
break; break;
case WASM_OP_TABLE_SIZE: case WASM_OP_TABLE_SIZE:
case WASM_OP_TABLE_GROW: case WASM_OP_TABLE_GROW:
case WASM_OP_TABLE_FILL: case WASM_OP_TABLE_FILL:
if (!wasm_get_ref_types_flag()) {
return false;
}
skip_leb_uint32(p, p_end); /* table idx */ skip_leb_uint32(p, p_end); /* table idx */
break; break;
#endif /* WASM_ENABLE_REF_TYPES */ #endif /* WASM_ENABLE_REF_TYPES */
@ -6216,17 +6149,8 @@ get_table_seg_elem_type(const WASMModule *module, uint32 table_seg_idx,
uint32 error_buf_size) uint32 error_buf_size)
{ {
if (table_seg_idx >= module->table_seg_count) { if (table_seg_idx >= module->table_seg_count) {
#if WASM_ENABLE_REF_TYPES != 0 set_error_buf_v(error_buf, error_buf_size, "unknown elem segment %u",
if (!wasm_get_ref_types_flag()) { table_seg_idx);
set_error_buf(error_buf, error_buf_size, "unknown table segment");
}
else {
set_error_buf_v(error_buf, error_buf_size,
"unknown elem segment %u", table_seg_idx);
}
#else
set_error_buf(error_buf, error_buf_size, "unknown table segment");
#endif
return false; return false;
} }
@ -6774,14 +6698,7 @@ re_scan:
read_leb_uint32(p, p_end, type_idx); read_leb_uint32(p, p_end, type_idx);
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
if (!wasm_get_ref_types_flag()) { read_leb_uint32(p, p_end, table_idx);
CHECK_BUF(p, p_end, 1);
table_idx = read_uint8(p);
}
else {
read_leb_uint32(p, p_end, table_idx);
}
#else #else
CHECK_BUF(p, p_end, 1); CHECK_BUF(p, p_end, 1);
table_idx = read_uint8(p); table_idx = read_uint8(p);
@ -7037,10 +6954,6 @@ re_scan:
{ {
uint8 vec_len, ref_type; uint8 vec_len, ref_type;
if (!wasm_get_ref_types_flag()) {
goto unsupported_opcode;
}
read_leb_uint32(p, p_end, vec_len); read_leb_uint32(p, p_end, vec_len);
if (!vec_len) { if (!vec_len) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
@ -7125,10 +7038,6 @@ re_scan:
{ {
uint8 decl_ref_type; uint8 decl_ref_type;
if (!wasm_get_ref_types_flag()) {
goto unsupported_opcode;
}
read_leb_uint32(p, p_end, table_idx); read_leb_uint32(p, p_end, table_idx);
if (!get_table_elem_type(module, table_idx, &decl_ref_type, if (!get_table_elem_type(module, table_idx, &decl_ref_type,
error_buf, error_buf_size)) error_buf, error_buf_size))
@ -7158,10 +7067,6 @@ re_scan:
{ {
uint8 ref_type; uint8 ref_type;
if (!wasm_get_ref_types_flag()) {
goto unsupported_opcode;
}
CHECK_BUF(p, p_end, 1); CHECK_BUF(p, p_end, 1);
ref_type = read_uint8(p); ref_type = read_uint8(p);
if (ref_type != VALUE_TYPE_FUNCREF if (ref_type != VALUE_TYPE_FUNCREF
@ -7178,10 +7083,6 @@ re_scan:
} }
case WASM_OP_REF_IS_NULL: case WASM_OP_REF_IS_NULL:
{ {
if (!wasm_get_ref_types_flag()) {
goto unsupported_opcode;
}
#if WASM_ENABLE_FAST_INTERP != 0 #if WASM_ENABLE_FAST_INTERP != 0
if (!wasm_loader_pop_frame_ref_offset(loader_ctx, if (!wasm_loader_pop_frame_ref_offset(loader_ctx,
VALUE_TYPE_FUNCREF, VALUE_TYPE_FUNCREF,
@ -7205,10 +7106,6 @@ re_scan:
} }
case WASM_OP_REF_FUNC: case WASM_OP_REF_FUNC:
{ {
if (!wasm_get_ref_types_flag()) {
goto unsupported_opcode;
}
read_leb_uint32(p, p_end, func_idx); read_leb_uint32(p, p_end, func_idx);
if (!check_function_index(module, func_idx, error_buf, if (!check_function_index(module, func_idx, error_buf,
@ -8071,10 +7968,6 @@ re_scan:
{ {
uint8 seg_ref_type = 0, tbl_ref_type = 0; uint8 seg_ref_type = 0, tbl_ref_type = 0;
if (!wasm_get_ref_types_flag()) {
goto unsupported_opcode;
}
read_leb_uint32(p, p_end, table_seg_idx); read_leb_uint32(p, p_end, table_seg_idx);
read_leb_uint32(p, p_end, table_idx); read_leb_uint32(p, p_end, table_idx);
@ -8105,10 +7998,6 @@ re_scan:
} }
case WASM_OP_ELEM_DROP: case WASM_OP_ELEM_DROP:
{ {
if (!wasm_get_ref_types_flag()) {
goto unsupported_opcode;
}
read_leb_uint32(p, p_end, table_seg_idx); read_leb_uint32(p, p_end, table_seg_idx);
if (!get_table_seg_elem_type(module, table_seg_idx, if (!get_table_seg_elem_type(module, table_seg_idx,
NULL, error_buf, NULL, error_buf,
@ -8124,10 +8013,6 @@ re_scan:
uint8 src_ref_type, dst_ref_type; uint8 src_ref_type, dst_ref_type;
uint32 src_tbl_idx, dst_tbl_idx; uint32 src_tbl_idx, dst_tbl_idx;
if (!wasm_get_ref_types_flag()) {
goto unsupported_opcode;
}
read_leb_uint32(p, p_end, src_tbl_idx); read_leb_uint32(p, p_end, src_tbl_idx);
if (!get_table_elem_type(module, src_tbl_idx, if (!get_table_elem_type(module, src_tbl_idx,
&src_ref_type, error_buf, &src_ref_type, error_buf,
@ -8157,10 +8042,6 @@ re_scan:
} }
case WASM_OP_TABLE_SIZE: case WASM_OP_TABLE_SIZE:
{ {
if (!wasm_get_ref_types_flag()) {
goto unsupported_opcode;
}
read_leb_uint32(p, p_end, table_idx); read_leb_uint32(p, p_end, table_idx);
/* TODO: shall we create a new function to check /* TODO: shall we create a new function to check
table idx instead of using below function? */ table idx instead of using below function? */
@ -8180,10 +8061,6 @@ re_scan:
{ {
uint8 decl_ref_type; uint8 decl_ref_type;
if (!wasm_get_ref_types_flag()) {
goto unsupported_opcode;
}
read_leb_uint32(p, p_end, table_idx); read_leb_uint32(p, p_end, table_idx);
if (!get_table_elem_type(module, table_idx, if (!get_table_elem_type(module, table_idx,
&decl_ref_type, error_buf, &decl_ref_type, error_buf,
@ -9018,9 +8895,6 @@ re_scan:
#endif /* end of WASM_ENABLE_SHARED_MEMORY */ #endif /* end of WASM_ENABLE_SHARED_MEMORY */
default: default:
#if WASM_ENABLE_REF_TYPES != 0
unsupported_opcode:
#endif
set_error_buf_v(error_buf, error_buf_size, "%s %02x", set_error_buf_v(error_buf, error_buf_size, "%s %02x",
"unsupported opcode", opcode); "unsupported opcode", opcode);
goto fail; goto fail;
@ -9086,19 +8960,3 @@ fail:
(void)align; (void)align;
return return_value; return return_value;
} }
#if WASM_ENABLE_REF_TYPES != 0
static bool ref_types_flag = true;
void
wasm_set_ref_types_flag(bool enable)
{
ref_types_flag = enable;
}
bool
wasm_get_ref_types_flag()
{
return ref_types_flag;
}
#endif

8
core/iwasm/interpreter/wasm_loader.h
View File

@ -70,14 +70,6 @@ wasm_loader_find_block_addr(WASMExecEnv *exec_env, BlockAddr *block_addr_cache,
uint8 block_type, uint8 **p_else_addr, uint8 block_type, uint8 **p_else_addr,
uint8 **p_end_addr); uint8 **p_end_addr);
#if WASM_ENABLE_REF_TYPES != 0
void
wasm_set_ref_types_flag(bool enable);
bool
wasm_get_ref_types_flag();
#endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

350
core/iwasm/interpreter/wasm_mini_loader.c
View File

@ -45,8 +45,7 @@ is_32bit_type(uint8 type)
{ {
if (type == VALUE_TYPE_I32 || type == VALUE_TYPE_F32 if (type == VALUE_TYPE_I32 || type == VALUE_TYPE_F32
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
|| (wasm_get_ref_types_flag() || type == VALUE_TYPE_FUNCREF || type == VALUE_TYPE_EXTERNREF)
&& (type == VALUE_TYPE_FUNCREF || type == VALUE_TYPE_EXTERNREF))
#endif #endif
) )
return true; return true;
@ -268,10 +267,6 @@ load_init_expr(const uint8 **p_buf, const uint8 *buf_end,
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
case INIT_EXPR_TYPE_FUNCREF_CONST: case INIT_EXPR_TYPE_FUNCREF_CONST:
{ {
if (!wasm_get_ref_types_flag()) {
return false;
}
bh_assert(type == VALUE_TYPE_FUNCREF); bh_assert(type == VALUE_TYPE_FUNCREF);
read_leb_uint32(p, p_end, init_expr->u.ref_index); read_leb_uint32(p, p_end, init_expr->u.ref_index);
break; break;
@ -280,10 +275,6 @@ load_init_expr(const uint8 **p_buf, const uint8 *buf_end,
{ {
uint8 reftype; uint8 reftype;
if (!wasm_get_ref_types_flag()) {
return false;
}
CHECK_BUF(p, p_end, 1); CHECK_BUF(p, p_end, 1);
reftype = read_uint8(p); reftype = read_uint8(p);
@ -459,8 +450,7 @@ load_table_import(const uint8 **p_buf, const uint8 *buf_end,
declare_elem_type = read_uint8(p); declare_elem_type = read_uint8(p);
bh_assert(VALUE_TYPE_FUNCREF == declare_elem_type bh_assert(VALUE_TYPE_FUNCREF == declare_elem_type
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
|| (wasm_get_ref_types_flag() || VALUE_TYPE_EXTERNREF == declare_elem_type
&& VALUE_TYPE_EXTERNREF == declare_elem_type)
#endif #endif
); );
@ -585,8 +575,7 @@ load_table(const uint8 **p_buf, const uint8 *buf_end, WASMTable *table,
table->elem_type = read_uint8(p); table->elem_type = read_uint8(p);
bh_assert((VALUE_TYPE_FUNCREF == table->elem_type) bh_assert((VALUE_TYPE_FUNCREF == table->elem_type)
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
|| (wasm_get_ref_types_flag() || VALUE_TYPE_EXTERNREF == table->elem_type
&& VALUE_TYPE_EXTERNREF == table->elem_type)
#endif #endif
); );
@ -709,12 +698,9 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
if (flags & 1) if (flags & 1)
read_leb_uint32(p, p_end, u32); read_leb_uint32(p, p_end, u32);
module->import_table_count++; module->import_table_count++;
bh_assert( #if WASM_ENABLE_REF_TYPES == 0
#if WASM_ENABLE_REF_TYPES != 0 bh_assert(module->import_table_count <= 1);
wasm_get_ref_types_flag() ||
#endif #endif
module->import_table_count <= 1);
break; break;
case IMPORT_KIND_MEMORY: /* import memory */ case IMPORT_KIND_MEMORY: /* import memory */
@ -988,9 +974,8 @@ load_function_section(const uint8 *buf, const uint8 *buf_end,
type = read_uint8(p_code); type = read_uint8(p_code);
bh_assert((type >= VALUE_TYPE_F64 && type <= VALUE_TYPE_I32) bh_assert((type >= VALUE_TYPE_F64 && type <= VALUE_TYPE_I32)
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
|| (wasm_get_ref_types_flag() || type == VALUE_TYPE_FUNCREF
&& (type == VALUE_TYPE_FUNCREF || type == VALUE_TYPE_EXTERNREF
|| type == VALUE_TYPE_EXTERNREF))
#endif #endif
); );
for (k = 0; k < sub_local_count; k++) { for (k = 0; k < sub_local_count; k++) {
@ -1034,11 +1019,9 @@ load_table_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
WASMTable *table; WASMTable *table;
read_leb_uint32(p, p_end, table_count); read_leb_uint32(p, p_end, table_count);
bh_assert( #if WASM_ENABLE_REF_TYPES == 0
#if WASM_ENABLE_REF_TYPES != 0 bh_assert(module->import_table_count + table_count <= 1);
wasm_get_ref_types_flag() ||
#endif #endif
module->import_table_count + table_count <= 1);
if (table_count) { if (table_count) {
module->table_count = table_count; module->table_count = table_count;
@ -1234,13 +1217,11 @@ static bool
check_table_index(const WASMModule *module, uint32 table_index, char *error_buf, check_table_index(const WASMModule *module, uint32 table_index, char *error_buf,
uint32 error_buf_size) uint32 error_buf_size)
{ {
if ( #if WASM_ENABLE_REF_TYPES == 0
#if WASM_ENABLE_REF_TYPES != 0 if (table_index != 0) {
!wasm_get_ref_types_flag() &&
#endif
table_index != 0) {
return false; return false;
} }
#endif
if (table_index >= module->import_table_count + module->table_count) { if (table_index >= module->import_table_count + module->table_count) {
return false; return false;
@ -1315,21 +1296,15 @@ load_func_index_vec(const uint8 **p_buf, const uint8 *buf_end,
InitializerExpression init_expr = { 0 }; InitializerExpression init_expr = { 0 };
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
if (!wasm_get_ref_types_flag()) { if (!use_init_expr) {
read_leb_uint32(p, p_end, function_index); read_leb_uint32(p, p_end, function_index);
} }
else { else {
if (!use_init_expr) { if (!load_init_expr(&p, p_end, &init_expr, table_segment->elem_type,
read_leb_uint32(p, p_end, function_index); error_buf, error_buf_size))
} return false;
else {
if (!load_init_expr(&p, p_end, &init_expr,
table_segment->elem_type, error_buf,
error_buf_size))
return false;
function_index = init_expr.u.ref_index; function_index = init_expr.u.ref_index;
}
} }
#else #else
read_leb_uint32(p, p_end, function_index); read_leb_uint32(p, p_end, function_index);
@ -1373,111 +1348,100 @@ load_table_segment_section(const uint8 *buf, const uint8 *buf_end,
bh_assert(p < p_end); bh_assert(p < p_end);
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
if (wasm_get_ref_types_flag()) { read_leb_uint32(p, p_end, table_segment->mode);
read_leb_uint32(p, p_end, table_segment->mode); /* last three bits */
/* last three bits */ table_segment->mode = table_segment->mode & 0x07;
table_segment->mode = table_segment->mode & 0x07; switch (table_segment->mode) {
switch (table_segment->mode) { /* elemkind/elemtype + active */
/* elemkind/elemtype + active */ case 0:
case 0: case 4:
case 4: table_segment->elem_type = VALUE_TYPE_FUNCREF;
table_segment->elem_type = VALUE_TYPE_FUNCREF; table_segment->table_index = 0;
table_segment->table_index = 0;
if (!check_table_index(module, if (!check_table_index(module, table_segment->table_index,
table_segment->table_index, error_buf, error_buf_size))
error_buf, error_buf_size))
return false;
if (!load_init_expr(
&p, p_end, &table_segment->base_offset,
VALUE_TYPE_I32, error_buf, error_buf_size))
return false;
if (!load_func_index_vec(
&p, p_end, module, table_segment,
table_segment->mode == 0 ? false : true,
error_buf, error_buf_size))
return false;
break;
/* elemkind + passive/declarative */
case 1:
case 3:
if (!load_elem_type(&p, p_end,
&table_segment->elem_type, true,
error_buf, error_buf_size))
return false;
if (!load_func_index_vec(&p, p_end, module,
table_segment, false,
error_buf, error_buf_size))
return false;
break;
/* elemkind/elemtype + table_idx + active */
case 2:
case 6:
if (!load_table_index(&p, p_end, module,
&table_segment->table_index,
error_buf, error_buf_size))
return false;
if (!load_init_expr(
&p, p_end, &table_segment->base_offset,
VALUE_TYPE_I32, error_buf, error_buf_size))
return false;
if (!load_elem_type(
&p, p_end, &table_segment->elem_type,
table_segment->mode == 2 ? true : false,
error_buf, error_buf_size))
return false;
if (!load_func_index_vec(
&p, p_end, module, table_segment,
table_segment->mode == 2 ? false : true,
error_buf, error_buf_size))
return false;
break;
case 5:
case 7:
if (!load_elem_type(&p, p_end,
&table_segment->elem_type, false,
error_buf, error_buf_size))
return false;
if (!load_func_index_vec(&p, p_end, module,
table_segment, true, error_buf,
error_buf_size))
return false;
break;
default:
return false; return false;
}
if (!load_init_expr(&p, p_end, &table_segment->base_offset,
VALUE_TYPE_I32, error_buf,
error_buf_size))
return false;
if (!load_func_index_vec(&p, p_end, module, table_segment,
table_segment->mode == 0 ? false
: true,
error_buf, error_buf_size))
return false;
break;
/* elemkind + passive/declarative */
case 1:
case 3:
if (!load_elem_type(&p, p_end, &table_segment->elem_type,
true, error_buf, error_buf_size))
return false;
if (!load_func_index_vec(&p, p_end, module, table_segment,
false, error_buf, error_buf_size))
return false;
break;
/* elemkind/elemtype + table_idx + active */
case 2:
case 6:
if (!load_table_index(&p, p_end, module,
&table_segment->table_index,
error_buf, error_buf_size))
return false;
if (!load_init_expr(&p, p_end, &table_segment->base_offset,
VALUE_TYPE_I32, error_buf,
error_buf_size))
return false;
if (!load_elem_type(&p, p_end, &table_segment->elem_type,
table_segment->mode == 2 ? true : false,
error_buf, error_buf_size))
return false;
if (!load_func_index_vec(&p, p_end, module, table_segment,
table_segment->mode == 2 ? false
: true,
error_buf, error_buf_size))
return false;
break;
case 5:
case 7:
if (!load_elem_type(&p, p_end, &table_segment->elem_type,
false, error_buf, error_buf_size))
return false;
if (!load_func_index_vec(&p, p_end, module, table_segment,
true, error_buf, error_buf_size))
return false;
break;
default:
return false;
} }
else #else
read_leb_uint32(p, p_end, table_index);
bh_assert(table_index
< module->import_table_count + module->table_count);
table_segment->table_index = table_index;
/* initialize expression */
if (!load_init_expr(&p, p_end, &(table_segment->base_offset),
VALUE_TYPE_I32, error_buf, error_buf_size))
return false;
read_leb_uint32(p, p_end, function_count);
table_segment->function_count = function_count;
total_size = sizeof(uint32) * (uint64)function_count;
if (total_size > 0
&& !(table_segment->func_indexes = (uint32 *)loader_malloc(
total_size, error_buf, error_buf_size))) {
return false;
}
if (!load_func_index_vec(&p, p_end, module, table_segment,
table_segment->mode == 0 ? false : true,
error_buf, error_buf_size))
return false;
#endif /* WASM_ENABLE_REF_TYPES != 0 */ #endif /* WASM_ENABLE_REF_TYPES != 0 */
{
read_leb_uint32(p, p_end, table_index);
bh_assert(table_index
< module->import_table_count + module->table_count);
table_segment->table_index = table_index;
/* initialize expression */
if (!load_init_expr(&p, p_end, &(table_segment->base_offset),
VALUE_TYPE_I32, error_buf, error_buf_size))
return false;
read_leb_uint32(p, p_end, function_count);
table_segment->function_count = function_count;
total_size = sizeof(uint32) * (uint64)function_count;
if (total_size > 0
&& !(table_segment->func_indexes = (uint32 *)loader_malloc(
total_size, error_buf, error_buf_size))) {
return false;
}
if (!load_func_index_vec(&p, p_end, module, table_segment,
table_segment->mode == 0 ? false
: true,
error_buf, error_buf_size))
return false;
}
} }
} }
@ -2605,41 +2569,21 @@ wasm_loader_find_block_addr(WASMExecEnv *exec_env, BlockAddr *block_addr_cache,
break; break;
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
case WASM_OP_SELECT_T: case WASM_OP_SELECT_T:
if (!wasm_get_ref_types_flag()) {
return false;
}
skip_leb_uint32(p, p_end); /* vec length */ skip_leb_uint32(p, p_end); /* vec length */
CHECK_BUF(p, p_end, 1); CHECK_BUF(p, p_end, 1);
u8 = read_uint8(p); /* typeidx */ u8 = read_uint8(p); /* typeidx */
break; break;
case WASM_OP_TABLE_GET: case WASM_OP_TABLE_GET:
case WASM_OP_TABLE_SET: case WASM_OP_TABLE_SET:
if (!wasm_get_ref_types_flag()) {
return false;
}
skip_leb_uint32(p, p_end); /* table index */ skip_leb_uint32(p, p_end); /* table index */
break; break;
case WASM_OP_REF_NULL: case WASM_OP_REF_NULL:
if (!wasm_get_ref_types_flag()) {
return false;
}
CHECK_BUF(p, p_end, 1); CHECK_BUF(p, p_end, 1);
u8 = read_uint8(p); /* type */ u8 = read_uint8(p); /* type */
break; break;
case WASM_OP_REF_IS_NULL: case WASM_OP_REF_IS_NULL:
if (!wasm_get_ref_types_flag()) {
return false;
}
break; break;
case WASM_OP_REF_FUNC: case WASM_OP_REF_FUNC:
if (!wasm_get_ref_types_flag()) {
return false;
}
skip_leb_uint32(p, p_end); /* func index */ skip_leb_uint32(p, p_end); /* func index */
break; break;
#endif /* WASM_ENABLE_REF_TYPES */ #endif /* WASM_ENABLE_REF_TYPES */
@ -2872,27 +2816,18 @@ wasm_loader_find_block_addr(WASMExecEnv *exec_env, BlockAddr *block_addr_cache,
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
case WASM_OP_TABLE_INIT: case WASM_OP_TABLE_INIT:
case WASM_OP_TABLE_COPY: case WASM_OP_TABLE_COPY:
if (!wasm_get_ref_types_flag()) {
return false;
}
/* tableidx */ /* tableidx */
skip_leb_uint32(p, p_end); skip_leb_uint32(p, p_end);
/* elemidx */ /* elemidx */
skip_leb_uint32(p, p_end); skip_leb_uint32(p, p_end);
break; break;
case WASM_OP_ELEM_DROP: case WASM_OP_ELEM_DROP:
if (!wasm_get_ref_types_flag()) {
return false;
}
/* elemidx */ /* elemidx */
skip_leb_uint32(p, p_end); skip_leb_uint32(p, p_end);
break; break;
case WASM_OP_TABLE_SIZE: case WASM_OP_TABLE_SIZE:
case WASM_OP_TABLE_GROW: case WASM_OP_TABLE_GROW:
case WASM_OP_TABLE_FILL: case WASM_OP_TABLE_FILL:
if (!wasm_get_ref_types_flag()) {
return false;
}
skip_leb_uint32(p, p_end); /* table idx */ skip_leb_uint32(p, p_end); /* table idx */
break; break;
#endif /* WASM_ENABLE_REF_TYPES */ #endif /* WASM_ENABLE_REF_TYPES */
@ -4486,8 +4421,7 @@ is_value_type(uint8 type)
if (type == VALUE_TYPE_I32 || type == VALUE_TYPE_I64 if (type == VALUE_TYPE_I32 || type == VALUE_TYPE_I64
|| type == VALUE_TYPE_F32 || type == VALUE_TYPE_F64 || type == VALUE_TYPE_F32 || type == VALUE_TYPE_F64
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
|| (wasm_get_ref_types_flag() || type == VALUE_TYPE_FUNCREF || type == VALUE_TYPE_EXTERNREF
&& (type == VALUE_TYPE_FUNCREF || type == VALUE_TYPE_EXTERNREF))
#endif #endif
) )
return true; return true;
@ -5274,14 +5208,7 @@ re_scan:
read_leb_uint32(p, p_end, type_idx); read_leb_uint32(p, p_end, type_idx);
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
if (!wasm_get_ref_types_flag()) { read_leb_uint32(p, p_end, table_idx);
CHECK_BUF(p, p_end, 1);
table_idx = read_uint8(p);
}
else {
read_leb_uint32(p, p_end, table_idx);
}
#else #else
CHECK_BUF(p, p_end, 1); CHECK_BUF(p, p_end, 1);
table_idx = read_uint8(p); table_idx = read_uint8(p);
@ -5478,10 +5405,6 @@ re_scan:
{ {
uint8 vec_len, ref_type; uint8 vec_len, ref_type;
if (!wasm_get_ref_types_flag()) {
goto fail;
}
read_leb_uint32(p, p_end, vec_len); read_leb_uint32(p, p_end, vec_len);
if (!vec_len) { if (!vec_len) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
@ -5557,11 +5480,6 @@ re_scan:
uint8 decl_ref_type; uint8 decl_ref_type;
uint32 table_idx; uint32 table_idx;
if (!wasm_get_ref_types_flag()) {
goto fail;
;
}
read_leb_uint32(p, p_end, table_idx); read_leb_uint32(p, p_end, table_idx);
if (!get_table_elem_type(module, table_idx, &decl_ref_type, if (!get_table_elem_type(module, table_idx, &decl_ref_type,
error_buf, error_buf_size)) error_buf, error_buf_size))
@ -5591,11 +5509,6 @@ re_scan:
{ {
uint8 ref_type; uint8 ref_type;
if (!wasm_get_ref_types_flag()) {
goto fail;
;
}
CHECK_BUF(p, p_end, 1); CHECK_BUF(p, p_end, 1);
ref_type = read_uint8(p); ref_type = read_uint8(p);
if (ref_type != VALUE_TYPE_FUNCREF if (ref_type != VALUE_TYPE_FUNCREF
@ -5612,11 +5525,6 @@ re_scan:
} }
case WASM_OP_REF_IS_NULL: case WASM_OP_REF_IS_NULL:
{ {
if (!wasm_get_ref_types_flag()) {
goto fail;
;
}
#if WASM_ENABLE_FAST_INTERP != 0 #if WASM_ENABLE_FAST_INTERP != 0
if (!wasm_loader_pop_frame_ref_offset(loader_ctx, if (!wasm_loader_pop_frame_ref_offset(loader_ctx,
VALUE_TYPE_FUNCREF, VALUE_TYPE_FUNCREF,
@ -5641,11 +5549,6 @@ re_scan:
case WASM_OP_REF_FUNC: case WASM_OP_REF_FUNC:
{ {
uint32 func_idx = 0; uint32 func_idx = 0;
if (!wasm_get_ref_types_flag()) {
goto fail;
;
}
read_leb_uint32(p, p_end, func_idx); read_leb_uint32(p, p_end, func_idx);
if (!check_function_index(module, func_idx, error_buf, if (!check_function_index(module, func_idx, error_buf,
@ -6399,10 +6302,6 @@ re_scan:
uint8 seg_ref_type, tbl_ref_type; uint8 seg_ref_type, tbl_ref_type;
uint32 table_seg_idx, table_idx; uint32 table_seg_idx, table_idx;
if (!wasm_get_ref_types_flag()) {
goto fail;
}
read_leb_uint32(p, p_end, table_seg_idx); read_leb_uint32(p, p_end, table_seg_idx);
read_leb_uint32(p, p_end, table_idx); read_leb_uint32(p, p_end, table_idx);
@ -6434,10 +6333,6 @@ re_scan:
case WASM_OP_ELEM_DROP: case WASM_OP_ELEM_DROP:
{ {
uint32 table_seg_idx; uint32 table_seg_idx;
if (!wasm_get_ref_types_flag()) {
goto fail;
}
read_leb_uint32(p, p_end, table_seg_idx); read_leb_uint32(p, p_end, table_seg_idx);
if (!get_table_seg_elem_type(module, table_seg_idx, if (!get_table_seg_elem_type(module, table_seg_idx,
NULL, error_buf, NULL, error_buf,
@ -6453,10 +6348,6 @@ re_scan:
uint8 src_ref_type, dst_ref_type; uint8 src_ref_type, dst_ref_type;
uint32 src_tbl_idx, dst_tbl_idx; uint32 src_tbl_idx, dst_tbl_idx;
if (!wasm_get_ref_types_flag()) {
goto fail;
}
read_leb_uint32(p, p_end, src_tbl_idx); read_leb_uint32(p, p_end, src_tbl_idx);
if (!get_table_elem_type(module, src_tbl_idx, if (!get_table_elem_type(module, src_tbl_idx,
&src_ref_type, error_buf, &src_ref_type, error_buf,
@ -6487,9 +6378,6 @@ re_scan:
case WASM_OP_TABLE_SIZE: case WASM_OP_TABLE_SIZE:
{ {
uint32 table_idx; uint32 table_idx;
if (!wasm_get_ref_types_flag()) {
goto fail;
}
read_leb_uint32(p, p_end, table_idx); read_leb_uint32(p, p_end, table_idx);
/* TODO: shall we create a new function to check /* TODO: shall we create a new function to check
@ -6511,10 +6399,6 @@ re_scan:
uint8 decl_ref_type; uint8 decl_ref_type;
uint32 table_idx; uint32 table_idx;
if (!wasm_get_ref_types_flag()) {
goto fail;
}
read_leb_uint32(p, p_end, table_idx); read_leb_uint32(p, p_end, table_idx);
if (!get_table_elem_type(module, table_idx, if (!get_table_elem_type(module, table_idx,
&decl_ref_type, error_buf, &decl_ref_type, error_buf,
@ -6759,19 +6643,3 @@ fail:
#endif #endif
return return_value; return return_value;
} }
#if WASM_ENABLE_REF_TYPES != 0
static bool ref_types_flag = true;
void
wasm_set_ref_types_flag(bool enable)
{
ref_types_flag = enable;
}
bool
wasm_get_ref_types_flag()
{
return ref_types_flag;
}
#endif

4
doc/build_wasm_app.md
View File

@ -269,7 +269,7 @@ Usage: wamrc [options] -o output_file wasm_file
object Native object file object Native object file
llvmir-unopt Unoptimized LLVM IR llvmir-unopt Unoptimized LLVM IR
llvmir-opt Optimized LLVM IR llvmir-opt Optimized LLVM IR
--enable-bulk-memory Enable the post-MVP bulk memory feature --disable-bulk-memory Disable the MVP bulk memory feature
--enable-multi-thread Enable multi-thread feature, the dependent features bulk-memory and --enable-multi-thread Enable multi-thread feature, the dependent features bulk-memory and
thread-mgr will be enabled automatically thread-mgr will be enabled automatically
--enable-tail-call Enable the post-MVP tail call feature --enable-tail-call Enable the post-MVP tail call feature
@ -277,7 +277,7 @@ Usage: wamrc [options] -o output_file wasm_file
currently 128-bit SIMD is only supported for x86-64 target, currently 128-bit SIMD is only supported for x86-64 target,
and by default it is enabled in x86-64 target and disabled and by default it is enabled in x86-64 target and disabled
in other targets in other targets
--enable-ref-types Enable the post-MVP reference types feature --disable-ref-types Disable the MVP reference types feature
--disable-aux-stack-check Disable auxiliary stack overflow/underflow check --disable-aux-stack-check Disable auxiliary stack overflow/underflow check
--enable-dump-call-stack Enable stack trace feature --enable-dump-call-stack Enable stack trace feature
--enable-perf-profiling Enable function performance profiling --enable-perf-profiling Enable function performance profiling

2
samples/wasm-c-api/CMakeLists.txt
View File

@ -157,7 +157,7 @@ foreach(EX ${EXAMPLES})
# generate .aot file # generate .aot file
if(${WAMR_BUILD_AOT} EQUAL 1) if(${WAMR_BUILD_AOT} EQUAL 1)
add_custom_target(${EX}_AOT add_custom_target(${EX}_AOT
COMMAND ${WAMRC} --enable-ref-types -o ${PROJECT_BINARY_DIR}/${EX}.aot COMMAND ${WAMRC} -o ${PROJECT_BINARY_DIR}/${EX}.aot
${PROJECT_BINARY_DIR}/${EX}.wasm ${PROJECT_BINARY_DIR}/${EX}.wasm
DEPENDS ${EX}_WASM DEPENDS ${EX}_WASM
BYPRODUCTS ${PROJECT_BINARY_DIR}/${EX}.aot BYPRODUCTS ${PROJECT_BINARY_DIR}/${EX}.aot

44
tests/wamr-test-suites/spec-test-script/all.py
View File

@ -49,7 +49,7 @@ def ignore_the_case(
aot_flag=False, aot_flag=False,
sgx_flag=False, sgx_flag=False,
multi_module_flag=False, multi_module_flag=False,
reference_type_flag=True, multi_thread_flag=False,
simd_flag=False, simd_flag=False,
): ):
if case_name in ["comments", "inline-module", "names"]: if case_name in ["comments", "inline-module", "names"]:
@ -98,7 +98,7 @@ def test_case(
aot_flag=False, aot_flag=False,
sgx_flag=False, sgx_flag=False,
multi_module_flag=False, multi_module_flag=False,
reference_type_flag=True, multi_thread_flag=False,
simd_flag=False, simd_flag=False,
clean_up_flag=True, clean_up_flag=True,
verbose_flag=True, verbose_flag=True,
@ -112,7 +112,7 @@ def test_case(
aot_flag, aot_flag,
sgx_flag, sgx_flag,
multi_module_flag, multi_module_flag,
reference_type_flag, multi_thread_flag,
simd_flag, simd_flag,
): ):
return True return True
@ -130,8 +130,8 @@ def test_case(
CMD.append("--aot-target") CMD.append("--aot-target")
CMD.append(target) CMD.append(target)
if reference_type_flag: if multi_thread_flag:
CMD.append("--ref_types") CMD.append("--multi-thread")
if sgx_flag: if sgx_flag:
CMD.append("--sgx") CMD.append("--sgx")
@ -193,7 +193,7 @@ def test_suite(
aot_flag=False, aot_flag=False,
sgx_flag=False, sgx_flag=False,
multi_module_flag=False, multi_module_flag=False,
reference_type_flag=True, multi_thread_flag=False,
simd_flag=False, simd_flag=False,
clean_up_flag=True, clean_up_flag=True,
verbose_flag=True, verbose_flag=True,
@ -215,7 +215,7 @@ def test_suite(
aot_flag, aot_flag,
sgx_flag, sgx_flag,
multi_module_flag, multi_module_flag,
reference_type_flag, multi_thread_flag,
simd_flag, simd_flag,
clean_up_flag, clean_up_flag,
verbose_flag, verbose_flag,
@ -237,7 +237,7 @@ def test_suite_parallelly(
aot_flag=False, aot_flag=False,
sgx_flag=False, sgx_flag=False,
multi_module_flag=False, multi_module_flag=False,
reference_type_flag=True, multi_thread_flag=False,
simd_flag=False, simd_flag=False,
clean_up_flag=False, clean_up_flag=False,
verbose_flag=False, verbose_flag=False,
@ -264,7 +264,7 @@ def test_suite_parallelly(
aot_flag, aot_flag,
sgx_flag, sgx_flag,
multi_module_flag, multi_module_flag,
reference_type_flag, multi_thread_flag,
simd_flag, simd_flag,
clean_up_flag, clean_up_flag,
verbose_flag, verbose_flag,
@ -310,11 +310,11 @@ def main():
help="Specify Target ", help="Specify Target ",
) )
parser.add_argument( parser.add_argument(
"-r", "-p",
action="store_true", action="store_true",
default=False, default=False,
dest="reference_type_flag", dest="multi_thread_flag",
help="Running with the Reference-type feature", help="Running with the Multi-Thread feature",
) )
parser.add_argument( parser.add_argument(
"-S", "-S",
@ -337,13 +337,6 @@ def main():
dest="sgx_flag", dest="sgx_flag",
help="Running with SGX environment", help="Running with SGX environment",
) )
parser.add_argument(
"--parl",
action="store_true",
default=False,
dest="parl_flag",
help="To run whole test suite parallelly",
)
parser.add_argument( parser.add_argument(
"--no_clean_up", "--no_clean_up",
action="store_false", action="store_false",
@ -351,6 +344,13 @@ def main():
dest="clean_up_flag", dest="clean_up_flag",
help="Does not remove tmpfiles. But it will be enabled while running parallelly", help="Does not remove tmpfiles. But it will be enabled while running parallelly",
) )
parser.add_argument(
"--parl",
action="store_true",
default=False,
dest="parl_flag",
help="To run whole test suite parallelly",
)
parser.add_argument( parser.add_argument(
"--quiet", "--quiet",
action="store_false", action="store_false",
@ -385,7 +385,7 @@ def main():
options.aot_flag, options.aot_flag,
options.sgx_flag, options.sgx_flag,
options.multi_module_flag, options.multi_module_flag,
options.reference_type_flag, options.multi_thread_flag,
options.simd_flag, options.simd_flag,
options.clean_up_flag, options.clean_up_flag,
options.verbose_flag, options.verbose_flag,
@ -401,7 +401,7 @@ def main():
options.aot_flag, options.aot_flag,
options.sgx_flag, options.sgx_flag,
options.multi_module_flag, options.multi_module_flag,
options.reference_type_flag, options.multi_thread_flag,
options.simd_flag, options.simd_flag,
options.clean_up_flag, options.clean_up_flag,
options.verbose_flag, options.verbose_flag,
@ -417,7 +417,7 @@ def main():
options.aot_flag, options.aot_flag,
options.sgx_flag, options.sgx_flag,
options.multi_module_flag, options.multi_module_flag,
options.reference_type_flag, options.multi_thread_flag,
options.simd_flag, options.simd_flag,
options.clean_up_flag, options.clean_up_flag,
options.verbose_flag, options.verbose_flag,

13
tests/wamr-test-suites/spec-test-script/runtest.py
View File

@ -210,8 +210,8 @@ parser.add_argument('--sgx', action='store_true',
parser.add_argument('--simd', default=False, action='store_true', parser.add_argument('--simd', default=False, action='store_true',
help="Enable SIMD") help="Enable SIMD")
parser.add_argument('--ref_types', default=False, action='store_true', parser.add_argument('--multi-thread', default=False, action='store_true',
help="Enable Reference types") help="Enable Multi-thread")
parser.add_argument('--verbose', default=False, action='store_true', parser.add_argument('--verbose', default=False, action='store_true',
help='show more logs') help='show more logs')
@ -939,12 +939,11 @@ def compile_wasm_to_aot(wasm_tempfile, aot_tempfile, runner, opts, r):
if opts.sgx: if opts.sgx:
cmd.append("-sgx") cmd.append("-sgx")
if opts.simd: if not opts.simd:
cmd.append("--enable-simd") cmd.append("--disable-simd")
if opts.ref_types: if opts.multi_thread:
cmd.append("--enable-ref-types") cmd.append("--enable-multi-thread")
cmd.append("--enable-bulk-memory")
# disable llvm link time optimization as it might convert # disable llvm link time optimization as it might convert
# code of tail call into code of dead loop, and stack overflow # code of tail call into code of dead loop, and stack overflow

39
tests/wamr-test-suites/test_wamr.sh
View File

@ -38,9 +38,6 @@ ENABLE_SIMD=0
#unit test case arrary #unit test case arrary
TEST_CASE_ARR=() TEST_CASE_ARR=()
SGX_OPT="" SGX_OPT=""
# enable reference-types and bulk-memory by default
# as they are finished and merged into spec
ENABLE_REF_TYPES=1
PLATFORM=$(uname -s | tr A-Z a-z) PLATFORM=$(uname -s | tr A-Z a-z)
PARALLELISM=0 PARALLELISM=0
@ -104,9 +101,6 @@ do
p) p)
echo "enable multi thread feature" echo "enable multi thread feature"
ENABLE_MULTI_THREAD=1 ENABLE_MULTI_THREAD=1
# Disable reference-types when multi-thread is enabled
echo "disable reference-types for multi thread"
ENABLE_REF_TYPES=0
;; ;;
S) S)
echo "enable SIMD feature" echo "enable SIMD feature"
@ -162,7 +156,6 @@ readonly CLASSIC_INTERP_COMPILE_FLAGS="\
-DWAMR_BUILD_INTERP=1 -DWAMR_BUILD_FAST_INTERP=0 \ -DWAMR_BUILD_INTERP=1 -DWAMR_BUILD_FAST_INTERP=0 \
-DWAMR_BUILD_JIT=0 -DWAMR_BUILD_AOT=0 \ -DWAMR_BUILD_JIT=0 -DWAMR_BUILD_AOT=0 \
-DWAMR_BUILD_SPEC_TEST=1 \ -DWAMR_BUILD_SPEC_TEST=1 \
-DWAMR_BUILD_MULTI_MODULE=${ENABLE_MULTI_MODULE} \
-DCOLLECT_CODE_COVERAGE=${COLLECT_CODE_COVERAGE}" -DCOLLECT_CODE_COVERAGE=${COLLECT_CODE_COVERAGE}"
readonly FAST_INTERP_COMPILE_FLAGS="\ readonly FAST_INTERP_COMPILE_FLAGS="\
@ -170,7 +163,6 @@ readonly FAST_INTERP_COMPILE_FLAGS="\
-DWAMR_BUILD_INTERP=1 -DWAMR_BUILD_FAST_INTERP=1 \ -DWAMR_BUILD_INTERP=1 -DWAMR_BUILD_FAST_INTERP=1 \
-DWAMR_BUILD_JIT=0 -DWAMR_BUILD_AOT=0 \ -DWAMR_BUILD_JIT=0 -DWAMR_BUILD_AOT=0 \
-DWAMR_BUILD_SPEC_TEST=1 \ -DWAMR_BUILD_SPEC_TEST=1 \
-DWAMR_BUILD_MULTI_MODULE=${ENABLE_MULTI_MODULE} \
-DCOLLECT_CODE_COVERAGE=${COLLECT_CODE_COVERAGE}" -DCOLLECT_CODE_COVERAGE=${COLLECT_CODE_COVERAGE}"
# jit: report linking error if set COLLECT_CODE_COVERAGE, # jit: report linking error if set COLLECT_CODE_COVERAGE,
@ -179,15 +171,13 @@ readonly JIT_COMPILE_FLAGS="\
-DWAMR_BUILD_TARGET=${TARGET} \ -DWAMR_BUILD_TARGET=${TARGET} \
-DWAMR_BUILD_INTERP=0 -DWAMR_BUILD_FAST_INTERP=0 \ -DWAMR_BUILD_INTERP=0 -DWAMR_BUILD_FAST_INTERP=0 \
-DWAMR_BUILD_JIT=1 -DWAMR_BUILD_AOT=1 \ -DWAMR_BUILD_JIT=1 -DWAMR_BUILD_AOT=1 \
-DWAMR_BUILD_SPEC_TEST=1 \ -DWAMR_BUILD_SPEC_TEST=1"
-DWAMR_BUILD_MULTI_MODULE=${ENABLE_MULTI_MODULE}"
readonly AOT_COMPILE_FLAGS="\ readonly AOT_COMPILE_FLAGS="\
-DWAMR_BUILD_TARGET=${TARGET} \ -DWAMR_BUILD_TARGET=${TARGET} \
-DWAMR_BUILD_INTERP=0 -DWAMR_BUILD_FAST_INTERP=0 \ -DWAMR_BUILD_INTERP=0 -DWAMR_BUILD_FAST_INTERP=0 \
-DWAMR_BUILD_JIT=0 -DWAMR_BUILD_AOT=1 \ -DWAMR_BUILD_JIT=0 -DWAMR_BUILD_AOT=1 \
-DWAMR_BUILD_SPEC_TEST=1 \ -DWAMR_BUILD_SPEC_TEST=1 \
-DWAMR_BUILD_MULTI_MODULE=${ENABLE_MULTI_MODULE} \
-DCOLLECT_CODE_COVERAGE=${COLLECT_CODE_COVERAGE}" -DCOLLECT_CODE_COVERAGE=${COLLECT_CODE_COVERAGE}"
readonly COMPILE_FLAGS=( readonly COMPILE_FLAGS=(
@ -387,9 +377,8 @@ function spec_test()
fi fi
fi fi
# reference type in all mode if [[ ${ENABLE_MULTI_THREAD} == 1 ]]; then
if [[ ${ENABLE_REF_TYPES} == 1 ]]; then ARGS_FOR_SPEC_TEST+="-p "
ARGS_FOR_SPEC_TEST+="-r "
fi fi
# require warmc only in aot mode # require warmc only in aot mode
@ -536,20 +525,26 @@ function collect_coverage()
function trigger() function trigger()
{ {
local EXTRA_COMPILE_FLAGS="" local EXTRA_COMPILE_FLAGS=""
# default enabled features
EXTRA_COMPILE_FLAGS+=" -DWAMR_BUILD_BULK_MEMORY=1"
if [[ ${ENABLE_MULTI_MODULE} == 1 ]];then
EXTRA_COMPILE_FLAGS+=" -DWAMR_BUILD_MULTI_MODULE=1"
else
EXTRA_COMPILE_FLAGS+=" -DWAMR_BUILD_MULTI_MODULE=0"
fi
if [[ ${ENABLE_MULTI_THREAD} == 1 ]];then if [[ ${ENABLE_MULTI_THREAD} == 1 ]];then
EXTRA_COMPILE_FLAGS+=" -DWAMR_BUILD_LIB_PTHREAD=1" EXTRA_COMPILE_FLAGS+=" -DWAMR_BUILD_LIB_PTHREAD=1"
EXTRA_COMPILE_FLAGS+=" -DWAMR_BUILD_REF_TYPES=0"
else
EXTRA_COMPILE_FLAGS+=" -DWAMR_BUILD_REF_TYPES=1"
fi fi
if [[ ${ENABLE_SIMD} == 1 ]]; then if [[ ${ENABLE_SIMD} == 1 ]]; then
EXTRA_COMPILE_FLAGS+=" -DWAMR_BUILD_SIMD=1" EXTRA_COMPILE_FLAGS+=" -DWAMR_BUILD_SIMD=1"
fi else
EXTRA_COMPILE_FLAGS+=" -DWAMR_BUILD_SIMD=0"
if [[ ${ENABLE_REF_TYPES} == 1 ]]; then
# spec test cases for reference type depends on
# multi-module and bulk memory
EXTRA_COMPILE_FLAGS+=" -DWAMR_BUILD_REF_TYPES=1"
EXTRA_COMPILE_FLAGS+=" -DWAMR_BUILD_MULTI_MODULE=1"
EXTRA_COMPILE_FLAGS+=" -DWAMR_BUILD_BULK_MEMORY=1"
fi fi
for t in "${TYPE[@]}"; do for t in "${TYPE[@]}"; do

24
wamr-compiler/main.c
View File

@ -9,11 +9,6 @@
#include "wasm_export.h" #include "wasm_export.h"
#include "aot_export.h" #include "aot_export.h"
#if WASM_ENABLE_REF_TYPES != 0
extern void
wasm_set_ref_types_flag(bool enable);
#endif
/* clang-format off */ /* clang-format off */
static int static int
print_help() print_help()
@ -48,7 +43,7 @@ print_help()
printf(" object Native object file\n"); printf(" object Native object file\n");
printf(" llvmir-unopt Unoptimized LLVM IR\n"); printf(" llvmir-unopt Unoptimized LLVM IR\n");
printf(" llvmir-opt Optimized LLVM IR\n"); printf(" llvmir-opt Optimized LLVM IR\n");
printf(" --enable-bulk-memory Enable the post-MVP bulk memory feature\n"); printf(" --disable-bulk-memory Disable the MVP bulk memory feature\n");
printf(" --enable-multi-thread Enable multi-thread feature, the dependent features bulk-memory and\n"); printf(" --enable-multi-thread Enable multi-thread feature, the dependent features bulk-memory and\n");
printf(" thread-mgr will be enabled automatically\n"); printf(" thread-mgr will be enabled automatically\n");
printf(" --enable-tail-call Enable the post-MVP tail call feature\n"); printf(" --enable-tail-call Enable the post-MVP tail call feature\n");
@ -56,7 +51,7 @@ print_help()
printf(" currently 128-bit SIMD is only supported for x86-64 target,\n"); printf(" currently 128-bit SIMD is only supported for x86-64 target,\n");
printf(" and by default it is enabled in x86-64 target and disabled\n"); printf(" and by default it is enabled in x86-64 target and disabled\n");
printf(" in other targets\n"); printf(" in other targets\n");
printf(" --enable-ref-types Enable the post-MVP reference types feature\n"); printf(" --disable-ref-types Disable the MVP reference types feature\n");
printf(" --disable-aux-stack-check Disable auxiliary stack overflow/underflow check\n"); printf(" --disable-aux-stack-check Disable auxiliary stack overflow/underflow check\n");
printf(" --enable-dump-call-stack Enable stack trace feature\n"); printf(" --enable-dump-call-stack Enable stack trace feature\n");
printf(" --enable-perf-profiling Enable function performance profiling\n"); printf(" --enable-perf-profiling Enable function performance profiling\n");
@ -94,6 +89,8 @@ main(int argc, char *argv[])
option.bounds_checks = 2; option.bounds_checks = 2;
option.enable_simd = true; option.enable_simd = true;
option.enable_aux_stack_check = true; option.enable_aux_stack_check = true;
option.enable_bulk_memory = true;
option.enable_ref_types = true;
/* Process options */ /* Process options */
for (argc--, argv++; argc > 0 && argv[0][0] == '-'; argc--, argv++) { for (argc--, argv++; argc > 0 && argv[0][0] == '-'; argc--, argv++) {
@ -164,12 +161,13 @@ main(int argc, char *argv[])
if (log_verbose_level < 0 || log_verbose_level > 5) if (log_verbose_level < 0 || log_verbose_level > 5)
return print_help(); return print_help();
} }
else if (!strcmp(argv[0], "--enable-bulk-memory")) { else if (!strcmp(argv[0], "--disable-bulk-memory")) {
option.enable_bulk_memory = true; option.enable_bulk_memory = false;
} }
else if (!strcmp(argv[0], "--enable-multi-thread")) { else if (!strcmp(argv[0], "--enable-multi-thread")) {
option.enable_bulk_memory = true; option.enable_bulk_memory = true;
option.enable_thread_mgr = true; option.enable_thread_mgr = true;
option.enable_ref_types = false;
} }
else if (!strcmp(argv[0], "--enable-tail-call")) { else if (!strcmp(argv[0], "--enable-tail-call")) {
option.enable_tail_call = true; option.enable_tail_call = true;
@ -181,8 +179,8 @@ main(int argc, char *argv[])
else if (!strcmp(argv[0], "--disable-simd")) { else if (!strcmp(argv[0], "--disable-simd")) {
option.enable_simd = false; option.enable_simd = false;
} }
else if (!strcmp(argv[0], "--enable-ref-types")) { else if (!strcmp(argv[0], "--disable-ref-types")) {
option.enable_ref_types = true; option.enable_ref_types = false;
} }
else if (!strcmp(argv[0], "--disable-aux-stack-check")) { else if (!strcmp(argv[0], "--disable-aux-stack-check")) {
option.enable_aux_stack_check = false; option.enable_aux_stack_check = false;
@ -214,10 +212,6 @@ main(int argc, char *argv[])
option.is_sgx_platform = true; option.is_sgx_platform = true;
} }
#if WASM_ENABLE_REF_TYPES != 0
wasm_set_ref_types_flag(option.enable_ref_types);
#endif
wasm_file_name = argv[0]; wasm_file_name = argv[0];
memset(&init_args, 0, sizeof(RuntimeInitArgs)); memset(&init_args, 0, sizeof(RuntimeInitArgs));