diff options
Diffstat (limited to 'src')
44 files changed, 3450 insertions, 3439 deletions
diff --git a/src/apply-names.cc b/src/apply-names.cc index 43867e0a..e564ab94 100644 --- a/src/apply-names.cc +++ b/src/apply-names.cc @@ -24,7 +24,7 @@ #define CHECK_RESULT(expr) \ do { \ if (WABT_FAILED(expr)) \ - return WABT_ERROR; \ + return WabtResult::Error; \ } while (0) typedef WabtLabel* LabelPtr; @@ -50,7 +50,7 @@ static void pop_label(Context* ctx) { } static WabtLabel* find_label_by_var(Context* ctx, WabtVar* var) { - if (var->type == WABT_VAR_TYPE_NAME) { + if (var->type == WabtVarType::Name) { int i; for (i = ctx->labels.size - 1; i >= 0; --i) { WabtLabel* label = ctx->labels.data[i]; @@ -66,12 +66,12 @@ static WabtLabel* find_label_by_var(Context* ctx, WabtVar* var) { } static void use_name_for_var(WabtStringSlice* name, WabtVar* var) { - if (var->type == WABT_VAR_TYPE_NAME) { + if (var->type == WabtVarType::Name) { assert(wabt_string_slices_are_equal(name, &var->name)); } if (name && name->start) { - var->type = WABT_VAR_TYPE_NAME; + var->type = WabtVarType::Name; var->name = wabt_dup_string_slice(*name); } } @@ -79,41 +79,41 @@ static void use_name_for_var(WabtStringSlice* name, WabtVar* var) { static WabtResult use_name_for_func_type_var(WabtModule* module, WabtVar* var) { WabtFuncType* func_type = wabt_get_func_type_by_var(module, var); if (!func_type) - return WABT_ERROR; + return WabtResult::Error; use_name_for_var(&func_type->name, var); - return WABT_OK; + return WabtResult::Ok; } static WabtResult use_name_for_func_var(WabtModule* module, WabtVar* var) { WabtFunc* func = wabt_get_func_by_var(module, var); if (!func) - return WABT_ERROR; + return WabtResult::Error; use_name_for_var(&func->name, var); - return WABT_OK; + return WabtResult::Ok; } static WabtResult use_name_for_global_var(WabtModule* module, WabtVar* var) { WabtGlobal* global = wabt_get_global_by_var(module, var); if (!global) - return WABT_ERROR; + return WabtResult::Error; use_name_for_var(&global->name, var); - return WABT_OK; + return WabtResult::Ok; } static WabtResult use_name_for_table_var(WabtModule* module, WabtVar* var) { WabtTable* table = wabt_get_table_by_var(module, var); if (!table) - return WABT_ERROR; + return WabtResult::Error; use_name_for_var(&table->name, var); - return WABT_OK; + return WabtResult::Ok; } static WabtResult use_name_for_memory_var(WabtModule* module, WabtVar* var) { WabtMemory* memory = wabt_get_memory_by_var(module, var); if (!memory) - return WABT_ERROR; + return WabtResult::Error; use_name_for_var(&memory->name, var); - return WABT_OK; + return WabtResult::Ok; } static WabtResult use_name_for_param_and_local_var(Context* ctx, @@ -122,7 +122,7 @@ static WabtResult use_name_for_param_and_local_var(Context* ctx, int local_index = wabt_get_local_index_by_var(func, var); if (local_index < 0 || static_cast<size_t>(local_index) >= wabt_get_num_params_and_locals(func)) - return WABT_ERROR; + return WabtResult::Error; uint32_t num_params = wabt_get_num_params(func); WabtStringSlice* name; @@ -137,55 +137,55 @@ static WabtResult use_name_for_param_and_local_var(Context* ctx, name = &ctx->local_index_to_name.data[local_index]; } - if (var->type == WABT_VAR_TYPE_NAME) { + if (var->type == WabtVarType::Name) { assert(wabt_string_slices_are_equal(name, &var->name)); - return WABT_OK; + return WabtResult::Ok; } if (name->start) { - var->type = WABT_VAR_TYPE_NAME; + var->type = WabtVarType::Name; var->name = wabt_dup_string_slice(*name); - return var->name.start ? WABT_OK : WABT_ERROR; + return var->name.start ? WabtResult::Ok : WabtResult::Error; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_block_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); push_label(ctx, &expr->block.label); - return WABT_OK; + return WabtResult::Ok; } static WabtResult end_block_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); pop_label(ctx); - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_loop_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); push_label(ctx, &expr->loop.label); - return WABT_OK; + return WabtResult::Ok; } static WabtResult end_loop_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); pop_label(ctx); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_br_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtLabel* label = find_label_by_var(ctx, &expr->br.var); use_name_for_var(label, &expr->br.var); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_br_if_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtLabel* label = find_label_by_var(ctx, &expr->br_if.var); use_name_for_var(label, &expr->br_if.var); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_br_table_expr(WabtExpr* expr, void* user_data) { @@ -200,65 +200,65 @@ static WabtResult on_br_table_expr(WabtExpr* expr, void* user_data) { WabtLabel* label = find_label_by_var(ctx, &expr->br_table.default_target); use_name_for_var(label, &expr->br_table.default_target); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_call_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); CHECK_RESULT(use_name_for_func_var(ctx->module, &expr->call.var)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_call_indirect_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); CHECK_RESULT( use_name_for_func_type_var(ctx->module, &expr->call_indirect.var)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_get_global_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); CHECK_RESULT(use_name_for_global_var(ctx->module, &expr->get_global.var)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_get_local_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); CHECK_RESULT(use_name_for_param_and_local_var(ctx, ctx->current_func, &expr->get_local.var)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_if_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); push_label(ctx, &expr->if_.true_.label); - return WABT_OK; + return WabtResult::Ok; } static WabtResult end_if_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); pop_label(ctx); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_set_global_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); CHECK_RESULT(use_name_for_global_var(ctx->module, &expr->set_global.var)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_set_local_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); CHECK_RESULT(use_name_for_param_and_local_var(ctx, ctx->current_func, &expr->set_local.var)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_tee_local_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); CHECK_RESULT(use_name_for_param_and_local_var(ctx, ctx->current_func, &expr->tee_local.var)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult visit_func(Context* ctx, @@ -278,16 +278,16 @@ static WabtResult visit_func(Context* ctx, CHECK_RESULT(wabt_visit_func(func, &ctx->visitor)); ctx->current_func = nullptr; - return WABT_OK; + return WabtResult::Ok; } static WabtResult visit_export(Context* ctx, uint32_t export_index, WabtExport* export_) { - if (export_->kind == WABT_EXTERNAL_KIND_FUNC) { + if (export_->kind == WabtExternalKind::Func) { use_name_for_func_var(ctx->module, &export_->var); } - return WABT_OK; + return WabtResult::Ok; } static WabtResult visit_elem_segment(Context* ctx, @@ -298,14 +298,14 @@ static WabtResult visit_elem_segment(Context* ctx, for (i = 0; i < segment->vars.size; ++i) { CHECK_RESULT(use_name_for_func_var(ctx->module, &segment->vars.data[i])); } - return WABT_OK; + return WabtResult::Ok; } static WabtResult visit_data_segment(Context* ctx, uint32_t data_segment_index, WabtDataSegment* segment) { CHECK_RESULT(use_name_for_memory_var(ctx->module, &segment->memory_var)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult visit_module(Context* ctx, WabtModule* module) { @@ -318,7 +318,7 @@ static WabtResult visit_module(Context* ctx, WabtModule* module) { CHECK_RESULT(visit_elem_segment(ctx, i, module->elem_segments.data[i])); for (i = 0; i < module->data_segments.size; ++i) CHECK_RESULT(visit_data_segment(ctx, i, module->data_segments.data[i])); - return WABT_OK; + return WabtResult::Ok; } WabtResult wabt_apply_names(WabtModule* module) { diff --git a/src/ast-lexer.cc b/src/ast-lexer.cc index 933e1b2c..adb276bc 100644 --- a/src/ast-lexer.cc +++ b/src/ast-lexer.cc @@ -82,13 +82,13 @@ lval->text.start = yytext + offset; \ lval->text.length = yyleng - offset -#define TYPE(type_) lval->type = WABT_TYPE_##type_ +#define TYPE(type_) lval->type = WabtType::type_ -#define OPCODE(name) lval->opcode = WABT_OPCODE_##name +#define OPCODE(name) lval->opcode = WabtOpcode::name -#define LITERAL(type_) \ - lval->literal.type = WABT_LITERAL_TYPE_##type_; \ - lval->literal.text.start = yytext; \ +#define LITERAL(type_) \ + lval->literal.type = WabtLiteralType::type_; \ + lval->literal.text.start = yytext; \ lval->literal.text.length = yyleng static WabtResult fill(WabtLocation* loc, @@ -96,7 +96,7 @@ static WabtResult fill(WabtLocation* loc, WabtAstParser* parser, size_t need) { if (lexer->eof) - return WABT_ERROR; + return WabtResult::Error; size_t free = lexer->token - lexer->buffer; assert(static_cast<size_t>(lexer->cursor - lexer->buffer) >= free); /* our buffer is too small, need to realloc */ @@ -118,7 +118,7 @@ static WabtResult fill(WabtLocation* loc, if (!new_buffer) { wabt_ast_parser_error(loc, lexer, parser, "unable to reallocate lexer buffer."); - return WABT_ERROR; + return WabtResult::Error; } memmove(new_buffer, lexer->token, lexer->limit - lexer->token); lexer->buffer = new_buffer; @@ -139,11 +139,11 @@ static WabtResult fill(WabtLocation* loc, lexer->buffer_file_offset += free; } /* read the new data into the buffer */ - if (lexer->source.type == WABT_LEXER_SOURCE_TYPE_FILE) { + if (lexer->source.type == WabtAstLexerSourceType::File) { lexer->limit += fread(lexer->limit, 1, free, lexer->source.file); } else { /* TODO(binji): could lex directly from buffer */ - assert(lexer->source.type == WABT_LEXER_SOURCE_TYPE_BUFFER); + assert(lexer->source.type == WabtAstLexerSourceType::Buffer); size_t read_size = free; size_t offset = lexer->source.buffer.read_offset; size_t bytes_left = lexer->source.buffer.size - offset; @@ -163,7 +163,7 @@ static WabtResult fill(WabtLocation* loc, memset(lexer->limit, 0, YYMAXFILL); lexer->limit += YYMAXFILL; } - return WABT_OK; + return WabtResult::Ok; } int wabt_ast_lexer_lex(WABT_AST_PARSER_STYPE* lval, @@ -219,12 +219,12 @@ int wabt_ast_lexer_lex(WABT_AST_PARSER_STYPE* lval, <i> "(" { RETURN(LPAR); } <i> ")" { RETURN(RPAR); } - <i> nat { LITERAL(INT); RETURN(NAT); } - <i> int { LITERAL(INT); RETURN(INT); } - <i> float { LITERAL(FLOAT); RETURN(FLOAT); } - <i> hexfloat { LITERAL(HEXFLOAT); RETURN(FLOAT); } - <i> infinity { LITERAL(INFINITY); RETURN(FLOAT); } - <i> nan { LITERAL(NAN); RETURN(FLOAT); } + <i> nat { LITERAL(Int); RETURN(NAT); } + <i> int { LITERAL(Int); RETURN(INT); } + <i> float { LITERAL(Float); RETURN(FLOAT); } + <i> hexfloat { LITERAL(Hexfloat); RETURN(FLOAT); } + <i> infinity { LITERAL(Infinity); RETURN(FLOAT); } + <i> nan { LITERAL(Nan); RETURN(FLOAT); } <i> text { TEXT; RETURN(TEXT); } <i> '"' => BAD_TEXT { continue; } <BAD_TEXT> character { continue; } @@ -264,161 +264,161 @@ int wabt_ast_lexer_lex(WABT_AST_PARSER_STYPE* lval, <i> "tee_local" { RETURN(TEE_LOCAL); } <i> "get_global" { RETURN(GET_GLOBAL); } <i> "set_global" { RETURN(SET_GLOBAL); } - <i> "i32.load" { OPCODE(I32_LOAD); RETURN(LOAD); } - <i> "i64.load" { OPCODE(I64_LOAD); RETURN(LOAD); } - <i> "f32.load" { OPCODE(F32_LOAD); RETURN(LOAD); } - <i> "f64.load" { OPCODE(F64_LOAD); RETURN(LOAD); } - <i> "i32.store" { OPCODE(I32_STORE); RETURN(STORE); } - <i> "i64.store" { OPCODE(I64_STORE); RETURN(STORE); } - <i> "f32.store" { OPCODE(F32_STORE); RETURN(STORE); } - <i> "f64.store" { OPCODE(F64_STORE); RETURN(STORE); } - <i> "i32.load8_s" { OPCODE(I32_LOAD8_S); RETURN(LOAD); } - <i> "i64.load8_s" { OPCODE(I64_LOAD8_S); RETURN(LOAD); } - <i> "i32.load8_u" { OPCODE(I32_LOAD8_U); RETURN(LOAD); } - <i> "i64.load8_u" { OPCODE(I64_LOAD8_U); RETURN(LOAD); } - <i> "i32.load16_s" { OPCODE(I32_LOAD16_S); RETURN(LOAD); } - <i> "i64.load16_s" { OPCODE(I64_LOAD16_S); RETURN(LOAD); } - <i> "i32.load16_u" { OPCODE(I32_LOAD16_U); RETURN(LOAD); } - <i> "i64.load16_u" { OPCODE(I64_LOAD16_U); RETURN(LOAD); } - <i> "i64.load32_s" { OPCODE(I64_LOAD32_S); RETURN(LOAD); } - <i> "i64.load32_u" { OPCODE(I64_LOAD32_U); RETURN(LOAD); } - <i> "i32.store8" { OPCODE(I32_STORE8); RETURN(STORE); } - <i> "i64.store8" { OPCODE(I64_STORE8); RETURN(STORE); } - <i> "i32.store16" { OPCODE(I32_STORE16); RETURN(STORE); } - <i> "i64.store16" { OPCODE(I64_STORE16); RETURN(STORE); } - <i> "i64.store32" { OPCODE(I64_STORE32); RETURN(STORE); } + <i> "i32.load" { OPCODE(I32Load); RETURN(LOAD); } + <i> "i64.load" { OPCODE(I64Load); RETURN(LOAD); } + <i> "f32.load" { OPCODE(F32Load); RETURN(LOAD); } + <i> "f64.load" { OPCODE(F64Load); RETURN(LOAD); } + <i> "i32.store" { OPCODE(I32Store); RETURN(STORE); } + <i> "i64.store" { OPCODE(I64Store); RETURN(STORE); } + <i> "f32.store" { OPCODE(F32Store); RETURN(STORE); } + <i> "f64.store" { OPCODE(F64Store); RETURN(STORE); } + <i> "i32.load8_s" { OPCODE(I32Load8S); RETURN(LOAD); } + <i> "i64.load8_s" { OPCODE(I64Load8S); RETURN(LOAD); } + <i> "i32.load8_u" { OPCODE(I32Load8U); RETURN(LOAD); } + <i> "i64.load8_u" { OPCODE(I64Load8U); RETURN(LOAD); } + <i> "i32.load16_s" { OPCODE(I32Load16S); RETURN(LOAD); } + <i> "i64.load16_s" { OPCODE(I64Load16S); RETURN(LOAD); } + <i> "i32.load16_u" { OPCODE(I32Load16U); RETURN(LOAD); } + <i> "i64.load16_u" { OPCODE(I64Load16U); RETURN(LOAD); } + <i> "i64.load32_s" { OPCODE(I64Load32S); RETURN(LOAD); } + <i> "i64.load32_u" { OPCODE(I64Load32U); RETURN(LOAD); } + <i> "i32.store8" { OPCODE(I32Store8); RETURN(STORE); } + <i> "i64.store8" { OPCODE(I64Store8); RETURN(STORE); } + <i> "i32.store16" { OPCODE(I32Store16); RETURN(STORE); } + <i> "i64.store16" { OPCODE(I64Store16); RETURN(STORE); } + <i> "i64.store32" { OPCODE(I64Store32); RETURN(STORE); } <i> "offset=" nat { TEXT_AT(7); RETURN(OFFSET_EQ_NAT); } <i> "align=" nat { TEXT_AT(6); RETURN(ALIGN_EQ_NAT); } <i> "i32.const" { TYPE(I32); RETURN(CONST); } <i> "i64.const" { TYPE(I64); RETURN(CONST); } <i> "f32.const" { TYPE(F32); RETURN(CONST); } <i> "f64.const" { TYPE(F64); RETURN(CONST); } - <i> "i32.eqz" { OPCODE(I32_EQZ); RETURN(CONVERT); } - <i> "i64.eqz" { OPCODE(I64_EQZ); RETURN(CONVERT); } - <i> "i32.clz" { OPCODE(I32_CLZ); RETURN(UNARY); } - <i> "i64.clz" { OPCODE(I64_CLZ); RETURN(UNARY); } - <i> "i32.ctz" { OPCODE(I32_CTZ); RETURN(UNARY); } - <i> "i64.ctz" { OPCODE(I64_CTZ); RETURN(UNARY); } - <i> "i32.popcnt" { OPCODE(I32_POPCNT); RETURN(UNARY); } - <i> "i64.popcnt" { OPCODE(I64_POPCNT); RETURN(UNARY); } - <i> "f32.neg" { OPCODE(F32_NEG); RETURN(UNARY); } - <i> "f64.neg" { OPCODE(F64_NEG); RETURN(UNARY); } - <i> "f32.abs" { OPCODE(F32_ABS); RETURN(UNARY); } - <i> "f64.abs" { OPCODE(F64_ABS); RETURN(UNARY); } - <i> "f32.sqrt" { OPCODE(F32_SQRT); RETURN(UNARY); } - <i> "f64.sqrt" { OPCODE(F64_SQRT); RETURN(UNARY); } - <i> "f32.ceil" { OPCODE(F32_CEIL); RETURN(UNARY); } - <i> "f64.ceil" { OPCODE(F64_CEIL); RETURN(UNARY); } - <i> "f32.floor" { OPCODE(F32_FLOOR); RETURN(UNARY); } - <i> "f64.floor" { OPCODE(F64_FLOOR); RETURN(UNARY); } - <i> "f32.trunc" { OPCODE(F32_TRUNC); RETURN(UNARY); } - <i> "f64.trunc" { OPCODE(F64_TRUNC); RETURN(UNARY); } - <i> "f32.nearest" { OPCODE(F32_NEAREST); RETURN(UNARY); } - <i> "f64.nearest" { OPCODE(F64_NEAREST); RETURN(UNARY); } - <i> "i32.add" { OPCODE(I32_ADD); RETURN(BINARY); } - <i> "i64.add" { OPCODE(I64_ADD); RETURN(BINARY); } - <i> "i32.sub" { OPCODE(I32_SUB); RETURN(BINARY); } - <i> "i64.sub" { OPCODE(I64_SUB); RETURN(BINARY); } - <i> "i32.mul" { OPCODE(I32_MUL); RETURN(BINARY); } - <i> "i64.mul" { OPCODE(I64_MUL); RETURN(BINARY); } - <i> "i32.div_s" { OPCODE(I32_DIV_S); RETURN(BINARY); } - <i> "i64.div_s" { OPCODE(I64_DIV_S); RETURN(BINARY); } - <i> "i32.div_u" { OPCODE(I32_DIV_U); RETURN(BINARY); } - <i> "i64.div_u" { OPCODE(I64_DIV_U); RETURN(BINARY); } - <i> "i32.rem_s" { OPCODE(I32_REM_S); RETURN(BINARY); } - <i> "i64.rem_s" { OPCODE(I64_REM_S); RETURN(BINARY); } - <i> "i32.rem_u" { OPCODE(I32_REM_U); RETURN(BINARY); } - <i> "i64.rem_u" { OPCODE(I64_REM_U); RETURN(BINARY); } - <i> "i32.and" { OPCODE(I32_AND); RETURN(BINARY); } - <i> "i64.and" { OPCODE(I64_AND); RETURN(BINARY); } - <i> "i32.or" { OPCODE(I32_OR); RETURN(BINARY); } - <i> "i64.or" { OPCODE(I64_OR); RETURN(BINARY); } - <i> "i32.xor" { OPCODE(I32_XOR); RETURN(BINARY); } - <i> "i64.xor" { OPCODE(I64_XOR); RETURN(BINARY); } - <i> "i32.shl" { OPCODE(I32_SHL); RETURN(BINARY); } - <i> "i64.shl" { OPCODE(I64_SHL); RETURN(BINARY); } - <i> "i32.shr_s" { OPCODE(I32_SHR_S); RETURN(BINARY); } - <i> "i64.shr_s" { OPCODE(I64_SHR_S); RETURN(BINARY); } - <i> "i32.shr_u" { OPCODE(I32_SHR_U); RETURN(BINARY); } - <i> "i64.shr_u" { OPCODE(I64_SHR_U); RETURN(BINARY); } - <i> "i32.rotl" { OPCODE(I32_ROTL); RETURN(BINARY); } - <i> "i64.rotl" { OPCODE(I64_ROTL); RETURN(BINARY); } - <i> "i32.rotr" { OPCODE(I32_ROTR); RETURN(BINARY); } - <i> "i64.rotr" { OPCODE(I64_ROTR); RETURN(BINARY); } - <i> "f32.add" { OPCODE(F32_ADD); RETURN(BINARY); } - <i> "f64.add" { OPCODE(F64_ADD); RETURN(BINARY); } - <i> "f32.sub" { OPCODE(F32_SUB); RETURN(BINARY); } - <i> "f64.sub" { OPCODE(F64_SUB); RETURN(BINARY); } - <i> "f32.mul" { OPCODE(F32_MUL); RETURN(BINARY); } - <i> "f64.mul" { OPCODE(F64_MUL); RETURN(BINARY); } - <i> "f32.div" { OPCODE(F32_DIV); RETURN(BINARY); } - <i> "f64.div" { OPCODE(F64_DIV); RETURN(BINARY); } - <i> "f32.min" { OPCODE(F32_MIN); RETURN(BINARY); } - <i> "f64.min" { OPCODE(F64_MIN); RETURN(BINARY); } - <i> "f32.max" { OPCODE(F32_MAX); RETURN(BINARY); } - <i> "f64.max" { OPCODE(F64_MAX); RETURN(BINARY); } - <i> "f32.copysign" { OPCODE(F32_COPYSIGN); RETURN(BINARY); } - <i> "f64.copysign" { OPCODE(F64_COPYSIGN); RETURN(BINARY); } - <i> "i32.eq" { OPCODE(I32_EQ); RETURN(COMPARE); } - <i> "i64.eq" { OPCODE(I64_EQ); RETURN(COMPARE); } - <i> "i32.ne" { OPCODE(I32_NE); RETURN(COMPARE); } - <i> "i64.ne" { OPCODE(I64_NE); RETURN(COMPARE); } - <i> "i32.lt_s" { OPCODE(I32_LT_S); RETURN(COMPARE); } - <i> "i64.lt_s" { OPCODE(I64_LT_S); RETURN(COMPARE); } - <i> "i32.lt_u" { OPCODE(I32_LT_U); RETURN(COMPARE); } - <i> "i64.lt_u" { OPCODE(I64_LT_U); RETURN(COMPARE); } - <i> "i32.le_s" { OPCODE(I32_LE_S); RETURN(COMPARE); } - <i> "i64.le_s" { OPCODE(I64_LE_S); RETURN(COMPARE); } - <i> "i32.le_u" { OPCODE(I32_LE_U); RETURN(COMPARE); } - <i> "i64.le_u" { OPCODE(I64_LE_U); RETURN(COMPARE); } - <i> "i32.gt_s" { OPCODE(I32_GT_S); RETURN(COMPARE); } - <i> "i64.gt_s" { OPCODE(I64_GT_S); RETURN(COMPARE); } - <i> "i32.gt_u" { OPCODE(I32_GT_U); RETURN(COMPARE); } - <i> "i64.gt_u" { OPCODE(I64_GT_U); RETURN(COMPARE); } - <i> "i32.ge_s" { OPCODE(I32_GE_S); RETURN(COMPARE); } - <i> "i64.ge_s" { OPCODE(I64_GE_S); RETURN(COMPARE); } - <i> "i32.ge_u" { OPCODE(I32_GE_U); RETURN(COMPARE); } - <i> "i64.ge_u" { OPCODE(I64_GE_U); RETURN(COMPARE); } - <i> "f32.eq" { OPCODE(F32_EQ); RETURN(COMPARE); } - <i> "f64.eq" { OPCODE(F64_EQ); RETURN(COMPARE); } - <i> "f32.ne" { OPCODE(F32_NE); RETURN(COMPARE); } - <i> "f64.ne" { OPCODE(F64_NE); RETURN(COMPARE); } - <i> "f32.lt" { OPCODE(F32_LT); RETURN(COMPARE); } - <i> "f64.lt" { OPCODE(F64_LT); RETURN(COMPARE); } - <i> "f32.le" { OPCODE(F32_LE); RETURN(COMPARE); } - <i> "f64.le" { OPCODE(F64_LE); RETURN(COMPARE); } - <i> "f32.gt" { OPCODE(F32_GT); RETURN(COMPARE); } - <i> "f64.gt" { OPCODE(F64_GT); RETURN(COMPARE); } - <i> "f32.ge" { OPCODE(F32_GE); RETURN(COMPARE); } - <i> "f64.ge" { OPCODE(F64_GE); RETURN(COMPARE); } - <i> "i64.extend_s/i32" { OPCODE(I64_EXTEND_S_I32); RETURN(CONVERT); } - <i> "i64.extend_u/i32" { OPCODE(I64_EXTEND_U_I32); RETURN(CONVERT); } - <i> "i32.wrap/i64" { OPCODE(I32_WRAP_I64); RETURN(CONVERT); } - <i> "i32.trunc_s/f32" { OPCODE(I32_TRUNC_S_F32); RETURN(CONVERT); } - <i> "i64.trunc_s/f32" { OPCODE(I64_TRUNC_S_F32); RETURN(CONVERT); } - <i> "i32.trunc_s/f64" { OPCODE(I32_TRUNC_S_F64); RETURN(CONVERT); } - <i> "i64.trunc_s/f64" { OPCODE(I64_TRUNC_S_F64); RETURN(CONVERT); } - <i> "i32.trunc_u/f32" { OPCODE(I32_TRUNC_U_F32); RETURN(CONVERT); } - <i> "i64.trunc_u/f32" { OPCODE(I64_TRUNC_U_F32); RETURN(CONVERT); } - <i> "i32.trunc_u/f64" { OPCODE(I32_TRUNC_U_F64); RETURN(CONVERT); } - <i> "i64.trunc_u/f64" { OPCODE(I64_TRUNC_U_F64); RETURN(CONVERT); } - <i> "f32.convert_s/i32" { OPCODE(F32_CONVERT_S_I32); RETURN(CONVERT); } - <i> "f64.convert_s/i32" { OPCODE(F64_CONVERT_S_I32); RETURN(CONVERT); } - <i> "f32.convert_s/i64" { OPCODE(F32_CONVERT_S_I64); RETURN(CONVERT); } - <i> "f64.convert_s/i64" { OPCODE(F64_CONVERT_S_I64); RETURN(CONVERT); } - <i> "f32.convert_u/i32" { OPCODE(F32_CONVERT_U_I32); RETURN(CONVERT); } - <i> "f64.convert_u/i32" { OPCODE(F64_CONVERT_U_I32); RETURN(CONVERT); } - <i> "f32.convert_u/i64" { OPCODE(F32_CONVERT_U_I64); RETURN(CONVERT); } - <i> "f64.convert_u/i64" { OPCODE(F64_CONVERT_U_I64); RETURN(CONVERT); } - <i> "f64.promote/f32" { OPCODE(F64_PROMOTE_F32); RETURN(CONVERT); } - <i> "f32.demote/f64" { OPCODE(F32_DEMOTE_F64); RETURN(CONVERT); } - <i> "f32.reinterpret/i32" { OPCODE(F32_REINTERPRET_I32); RETURN(CONVERT); + <i> "i32.eqz" { OPCODE(I32Eqz); RETURN(CONVERT); } + <i> "i64.eqz" { OPCODE(I64Eqz); RETURN(CONVERT); } + <i> "i32.clz" { OPCODE(I32Clz); RETURN(UNARY); } + <i> "i64.clz" { OPCODE(I64Clz); RETURN(UNARY); } + <i> "i32.ctz" { OPCODE(I32Ctz); RETURN(UNARY); } + <i> "i64.ctz" { OPCODE(I64Ctz); RETURN(UNARY); } + <i> "i32.popcnt" { OPCODE(I32Popcnt); RETURN(UNARY); } + <i> "i64.popcnt" { OPCODE(I64Popcnt); RETURN(UNARY); } + <i> "f32.neg" { OPCODE(F32Neg); RETURN(UNARY); } + <i> "f64.neg" { OPCODE(F64Neg); RETURN(UNARY); } + <i> "f32.abs" { OPCODE(F32Abs); RETURN(UNARY); } + <i> "f64.abs" { OPCODE(F64Abs); RETURN(UNARY); } + <i> "f32.sqrt" { OPCODE(F32Sqrt); RETURN(UNARY); } + <i> "f64.sqrt" { OPCODE(F64Sqrt); RETURN(UNARY); } + <i> "f32.ceil" { OPCODE(F32Ceil); RETURN(UNARY); } + <i> "f64.ceil" { OPCODE(F64Ceil); RETURN(UNARY); } + <i> "f32.floor" { OPCODE(F32Floor); RETURN(UNARY); } + <i> "f64.floor" { OPCODE(F64Floor); RETURN(UNARY); } + <i> "f32.trunc" { OPCODE(F32Trunc); RETURN(UNARY); } + <i> "f64.trunc" { OPCODE(F64Trunc); RETURN(UNARY); } + <i> "f32.nearest" { OPCODE(F32Nearest); RETURN(UNARY); } + <i> "f64.nearest" { OPCODE(F64Nearest); RETURN(UNARY); } + <i> "i32.add" { OPCODE(I32Add); RETURN(BINARY); } + <i> "i64.add" { OPCODE(I64Add); RETURN(BINARY); } + <i> "i32.sub" { OPCODE(I32Sub); RETURN(BINARY); } + <i> "i64.sub" { OPCODE(I64Sub); RETURN(BINARY); } + <i> "i32.mul" { OPCODE(I32Mul); RETURN(BINARY); } + <i> "i64.mul" { OPCODE(I64Mul); RETURN(BINARY); } + <i> "i32.div_s" { OPCODE(I32DivS); RETURN(BINARY); } + <i> "i64.div_s" { OPCODE(I64DivS); RETURN(BINARY); } + <i> "i32.div_u" { OPCODE(I32DivU); RETURN(BINARY); } + <i> "i64.div_u" { OPCODE(I64DivU); RETURN(BINARY); } + <i> "i32.rem_s" { OPCODE(I32RemS); RETURN(BINARY); } + <i> "i64.rem_s" { OPCODE(I64RemS); RETURN(BINARY); } + <i> "i32.rem_u" { OPCODE(I32RemU); RETURN(BINARY); } + <i> "i64.rem_u" { OPCODE(I64RemU); RETURN(BINARY); } + <i> "i32.and" { OPCODE(I32And); RETURN(BINARY); } + <i> "i64.and" { OPCODE(I64And); RETURN(BINARY); } + <i> "i32.or" { OPCODE(I32Or); RETURN(BINARY); } + <i> "i64.or" { OPCODE(I64Or); RETURN(BINARY); } + <i> "i32.xor" { OPCODE(I32Xor); RETURN(BINARY); } + <i> "i64.xor" { OPCODE(I64Xor); RETURN(BINARY); } + <i> "i32.shl" { OPCODE(I32Shl); RETURN(BINARY); } + <i> "i64.shl" { OPCODE(I64Shl); RETURN(BINARY); } + <i> "i32.shr_s" { OPCODE(I32ShrS); RETURN(BINARY); } + <i> "i64.shr_s" { OPCODE(I64ShrS); RETURN(BINARY); } + <i> "i32.shr_u" { OPCODE(I32ShrU); RETURN(BINARY); } + <i> "i64.shr_u" { OPCODE(I64ShrU); RETURN(BINARY); } + <i> "i32.rotl" { OPCODE(I32Rotl); RETURN(BINARY); } + <i> "i64.rotl" { OPCODE(I64Rotl); RETURN(BINARY); } + <i> "i32.rotr" { OPCODE(I32Rotr); RETURN(BINARY); } + <i> "i64.rotr" { OPCODE(I64Rotr); RETURN(BINARY); } + <i> "f32.add" { OPCODE(F32Add); RETURN(BINARY); } + <i> "f64.add" { OPCODE(F64Add); RETURN(BINARY); } + <i> "f32.sub" { OPCODE(F32Sub); RETURN(BINARY); } + <i> "f64.sub" { OPCODE(F64Sub); RETURN(BINARY); } + <i> "f32.mul" { OPCODE(F32Mul); RETURN(BINARY); } + <i> "f64.mul" { OPCODE(F64Mul); RETURN(BINARY); } + <i> "f32.div" { OPCODE(F32Div); RETURN(BINARY); } + <i> "f64.div" { OPCODE(F64Div); RETURN(BINARY); } + <i> "f32.min" { OPCODE(F32Min); RETURN(BINARY); } + <i> "f64.min" { OPCODE(F64Min); RETURN(BINARY); } + <i> "f32.max" { OPCODE(F32Max); RETURN(BINARY); } + <i> "f64.max" { OPCODE(F64Max); RETURN(BINARY); } + <i> "f32.copysign" { OPCODE(F32Copysign); RETURN(BINARY); } + <i> "f64.copysign" { OPCODE(F64Copysign); RETURN(BINARY); } + <i> "i32.eq" { OPCODE(I32Eq); RETURN(COMPARE); } + <i> "i64.eq" { OPCODE(I64Eq); RETURN(COMPARE); } + <i> "i32.ne" { OPCODE(I32Ne); RETURN(COMPARE); } + <i> "i64.ne" { OPCODE(I64Ne); RETURN(COMPARE); } + <i> "i32.lt_s" { OPCODE(I32LtS); RETURN(COMPARE); } + <i> "i64.lt_s" { OPCODE(I64LtS); RETURN(COMPARE); } + <i> "i32.lt_u" { OPCODE(I32LtU); RETURN(COMPARE); } + <i> "i64.lt_u" { OPCODE(I64LtU); RETURN(COMPARE); } + <i> "i32.le_s" { OPCODE(I32LeS); RETURN(COMPARE); } + <i> "i64.le_s" { OPCODE(I64LeS); RETURN(COMPARE); } + <i> "i32.le_u" { OPCODE(I32LeU); RETURN(COMPARE); } + <i> "i64.le_u" { OPCODE(I64LeU); RETURN(COMPARE); } + <i> "i32.gt_s" { OPCODE(I32GtS); RETURN(COMPARE); } + <i> "i64.gt_s" { OPCODE(I64GtS); RETURN(COMPARE); } + <i> "i32.gt_u" { OPCODE(I32GtU); RETURN(COMPARE); } + <i> "i64.gt_u" { OPCODE(I64GtU); RETURN(COMPARE); } + <i> "i32.ge_s" { OPCODE(I32GeS); RETURN(COMPARE); } + <i> "i64.ge_s" { OPCODE(I64GeS); RETURN(COMPARE); } + <i> "i32.ge_u" { OPCODE(I32GeU); RETURN(COMPARE); } + <i> "i64.ge_u" { OPCODE(I64GeU); RETURN(COMPARE); } + <i> "f32.eq" { OPCODE(F32Eq); RETURN(COMPARE); } + <i> "f64.eq" { OPCODE(F64Eq); RETURN(COMPARE); } + <i> "f32.ne" { OPCODE(F32Ne); RETURN(COMPARE); } + <i> "f64.ne" { OPCODE(F64Ne); RETURN(COMPARE); } + <i> "f32.lt" { OPCODE(F32Lt); RETURN(COMPARE); } + <i> "f64.lt" { OPCODE(F64Lt); RETURN(COMPARE); } + <i> "f32.le" { OPCODE(F32Le); RETURN(COMPARE); } + <i> "f64.le" { OPCODE(F64Le); RETURN(COMPARE); } + <i> "f32.gt" { OPCODE(F32Gt); RETURN(COMPARE); } + <i> "f64.gt" { OPCODE(F64Gt); RETURN(COMPARE); } + <i> "f32.ge" { OPCODE(F32Ge); RETURN(COMPARE); } + <i> "f64.ge" { OPCODE(F64Ge); RETURN(COMPARE); } + <i> "i64.extend_s/i32" { OPCODE(I64ExtendSI32); RETURN(CONVERT); } + <i> "i64.extend_u/i32" { OPCODE(I64ExtendUI32); RETURN(CONVERT); } + <i> "i32.wrap/i64" { OPCODE(I32WrapI64); RETURN(CONVERT); } + <i> "i32.trunc_s/f32" { OPCODE(I32TruncSF32); RETURN(CONVERT); } + <i> "i64.trunc_s/f32" { OPCODE(I64TruncSF32); RETURN(CONVERT); } + <i> "i32.trunc_s/f64" { OPCODE(I32TruncSF64); RETURN(CONVERT); } + <i> "i64.trunc_s/f64" { OPCODE(I64TruncSF64); RETURN(CONVERT); } + <i> "i32.trunc_u/f32" { OPCODE(I32TruncUF32); RETURN(CONVERT); } + <i> "i64.trunc_u/f32" { OPCODE(I64TruncUF32); RETURN(CONVERT); } + <i> "i32.trunc_u/f64" { OPCODE(I32TruncUF64); RETURN(CONVERT); } + <i> "i64.trunc_u/f64" { OPCODE(I64TruncUF64); RETURN(CONVERT); } + <i> "f32.convert_s/i32" { OPCODE(F32ConvertSI32); RETURN(CONVERT); } + <i> "f64.convert_s/i32" { OPCODE(F64ConvertSI32); RETURN(CONVERT); } + <i> "f32.convert_s/i64" { OPCODE(F32ConvertSI64); RETURN(CONVERT); } + <i> "f64.convert_s/i64" { OPCODE(F64ConvertSI64); RETURN(CONVERT); } + <i> "f32.convert_u/i32" { OPCODE(F32ConvertUI32); RETURN(CONVERT); } + <i> "f64.convert_u/i32" { OPCODE(F64ConvertUI32); RETURN(CONVERT); } + <i> "f32.convert_u/i64" { OPCODE(F32ConvertUI64); RETURN(CONVERT); } + <i> "f64.convert_u/i64" { OPCODE(F64ConvertUI64); RETURN(CONVERT); } + <i> "f64.promote/f32" { OPCODE(F64PromoteF32); RETURN(CONVERT); } + <i> "f32.demote/f64" { OPCODE(F32DemoteF64); RETURN(CONVERT); } + <i> "f32.reinterpret/i32" { OPCODE(F32ReinterpretI32); RETURN(CONVERT); } - <i> "i32.reinterpret/f32" { OPCODE(I32_REINTERPRET_F32); RETURN(CONVERT); + <i> "i32.reinterpret/f32" { OPCODE(I32ReinterpretF32); RETURN(CONVERT); } - <i> "f64.reinterpret/i64" { OPCODE(F64_REINTERPRET_I64); RETURN(CONVERT); + <i> "f64.reinterpret/i64" { OPCODE(F64ReinterpretI64); RETURN(CONVERT); } - <i> "i64.reinterpret/f64" { OPCODE(I64_REINTERPRET_F64); RETURN(CONVERT); + <i> "i64.reinterpret/f64" { OPCODE(I64ReinterpretF64); RETURN(CONVERT); } <i> "select" { RETURN(SELECT); } <i> "unreachable" { RETURN(UNREACHABLE); } @@ -486,7 +486,7 @@ static WabtAstLexer* wabt_new_lexer(WabtAstLexerSourceType type, } WabtAstLexer* wabt_new_ast_file_lexer(const char* filename) { - WabtAstLexer* lexer = wabt_new_lexer(WABT_LEXER_SOURCE_TYPE_FILE, filename); + WabtAstLexer* lexer = wabt_new_lexer(WabtAstLexerSourceType::File, filename); lexer->source.file = fopen(filename, "rb"); if (!lexer->source.file) { wabt_destroy_ast_lexer(lexer); @@ -498,7 +498,8 @@ WabtAstLexer* wabt_new_ast_file_lexer(const char* filename) { WabtAstLexer* wabt_new_ast_buffer_lexer(const char* filename, const void* data, size_t size) { - WabtAstLexer* lexer = wabt_new_lexer(WABT_LEXER_SOURCE_TYPE_BUFFER, filename); + WabtAstLexer* lexer = + wabt_new_lexer(WabtAstLexerSourceType::Buffer, filename); lexer->source.buffer.data = data; lexer->source.buffer.size = size; lexer->source.buffer.read_offset = 0; @@ -506,15 +507,15 @@ WabtAstLexer* wabt_new_ast_buffer_lexer(const char* filename, } void wabt_destroy_ast_lexer(WabtAstLexer* lexer) { - if (lexer->source.type == WABT_LEXER_SOURCE_TYPE_FILE && lexer->source.file) + if (lexer->source.type == WabtAstLexerSourceType::File && lexer->source.file) fclose(lexer->source.file); wabt_free(lexer->buffer); wabt_free(lexer); } -enum WabtLineOffsetPosition { - WABT_LINE_OFFSET_POSITION_START, - WABT_LINE_OFFSET_POSITION_END, +enum class WabtLineOffsetPosition { + Start, + End, }; static WabtResult scan_forward_for_line_offset_in_buffer( @@ -532,14 +533,15 @@ static WabtResult scan_forward_for_line_offset_in_buffer( bool is_previous_carriage = 0; for (p = buffer_start; p < buffer_end; ++p) { if (*p == '\n') { - if (find_position == WABT_LINE_OFFSET_POSITION_START) { + if (find_position == WabtLineOffsetPosition::Start) { if (++line == find_line) { line_offset = buffer_file_offset + (p - buffer_start) + 1; break; } } else { if (line++ == find_line) { - line_offset = buffer_file_offset + (p - buffer_start) - is_previous_carriage; + line_offset = + buffer_file_offset + (p - buffer_start) - is_previous_carriage; break; } } @@ -547,11 +549,11 @@ static WabtResult scan_forward_for_line_offset_in_buffer( is_previous_carriage = *p == '\r'; } - WabtResult result = WABT_OK; + WabtResult result = WabtResult::Ok; if (p == buffer_end) { /* end of buffer */ - if (find_position == WABT_LINE_OFFSET_POSITION_START) { - result = WABT_ERROR; + if (find_position == WabtLineOffsetPosition::Start) { + result = WabtResult::Error; } else { line_offset = buffer_file_offset + (buffer_end - buffer_start); } @@ -570,10 +572,10 @@ static WabtResult scan_forward_for_line_offset_in_file( int find_line, size_t* out_line_offset) { FILE* lexer_file = lexer->source.file; - WabtResult result = WABT_ERROR; + WabtResult result = WabtResult::Error; long old_offset = ftell(lexer_file); if (old_offset == -1) - return WABT_ERROR; + return WabtResult::Error; size_t buffer_file_offset = line_start_offset; if (fseek(lexer_file, buffer_file_offset, SEEK_SET) == -1) goto cleanup; @@ -584,11 +586,11 @@ static WabtResult scan_forward_for_line_offset_in_file( size_t read_bytes = fread(buffer, 1, buffer_size, lexer_file); if (read_bytes == 0) { /* end of buffer */ - if (find_position == WABT_LINE_OFFSET_POSITION_START) { - result = WABT_ERROR; + if (find_position == WabtLineOffsetPosition::Start) { + result = WabtResult::Error; } else { *out_line_offset = buffer_file_offset + read_bytes; - result = WABT_OK; + result = WabtResult::Ok; } goto cleanup; } @@ -597,7 +599,7 @@ static WabtResult scan_forward_for_line_offset_in_file( result = scan_forward_for_line_offset_in_buffer( buffer, buffer_end, line, buffer_file_offset, find_position, find_line, &line, out_line_offset); - if (result == WABT_OK) + if (result == WabtResult::Ok) goto cleanup; buffer_file_offset += read_bytes; @@ -606,7 +608,7 @@ static WabtResult scan_forward_for_line_offset_in_file( cleanup: /* if this fails, we're screwed */ if (fseek(lexer_file, old_offset, SEEK_SET) == -1) - return WABT_ERROR; + return WabtResult::Error; return result; } @@ -618,7 +620,7 @@ static WabtResult scan_forward_for_line_offset( int find_line, size_t* out_line_offset) { assert(line <= find_line); - if (lexer->source.type == WABT_LEXER_SOURCE_TYPE_BUFFER) { + if (lexer->source.type == WabtAstLexerSourceType::Buffer) { const char* source_buffer = static_cast<const char*>(lexer->source.buffer.data); const char* buffer_start = source_buffer + line_start_offset; @@ -627,7 +629,7 @@ static WabtResult scan_forward_for_line_offset( buffer_start, buffer_end, line, line_start_offset, find_position, find_line, &line, out_line_offset); } else { - assert(lexer->source.type == WABT_LEXER_SOURCE_TYPE_FILE); + assert(lexer->source.type == WabtAstLexerSourceType::File); return scan_forward_for_line_offset_in_file(lexer, line, line_start_offset, find_position, find_line, out_line_offset); @@ -644,18 +646,18 @@ static WabtResult get_line_start_offset(WabtAstLexer* lexer, if (line == current_line) { *out_offset = current_offset; - return WABT_OK; + return WabtResult::Ok; } else if (line == first_line) { *out_offset = first_offset; - return WABT_OK; + return WabtResult::Ok; } else if (line > current_line) { return scan_forward_for_line_offset(lexer, current_line, current_offset, - WABT_LINE_OFFSET_POSITION_START, line, + WabtLineOffsetPosition::Start, line, out_offset); } else { /* TODO(binji): optimize by storing more known line/offset pairs */ return scan_forward_for_line_offset(lexer, first_line, first_offset, - WABT_LINE_OFFSET_POSITION_START, line, + WabtLineOffsetPosition::Start, line, out_offset); } } @@ -666,16 +668,16 @@ static WabtResult get_offsets_from_line(WabtAstLexer* lexer, size_t* out_line_end) { size_t line_start; if (WABT_FAILED(get_line_start_offset(lexer, line, &line_start))) - return WABT_ERROR; + return WabtResult::Error; size_t line_end; if (WABT_FAILED(scan_forward_for_line_offset(lexer, line, line_start, - WABT_LINE_OFFSET_POSITION_END, + WabtLineOffsetPosition::End, line, &line_end))) - return WABT_ERROR; + return WabtResult::Error; *out_line_start = line_start; *out_line_end = line_end; - return WABT_OK; + return WabtResult::Ok; } static void clamp_source_line_offsets_to_location(size_t line_start, @@ -743,27 +745,27 @@ WabtResult wabt_ast_lexer_get_source_line(WabtAstLexer* lexer, read_length -= 3; } - if (lexer->source.type == WABT_LEXER_SOURCE_TYPE_BUFFER) { + if (lexer->source.type == WabtAstLexerSourceType::Buffer) { const char* buffer_read_start = static_cast<const char*>(lexer->source.buffer.data) + read_start; memcpy(write_start, buffer_read_start, read_length); } else { - assert(lexer->source.type == WABT_LEXER_SOURCE_TYPE_FILE); + assert(lexer->source.type == WabtAstLexerSourceType::File); FILE* lexer_file = lexer->source.file; long old_offset = ftell(lexer_file); if (old_offset == -1) - return WABT_ERROR; + return WabtResult::Error; if (fseek(lexer_file, read_start, SEEK_SET) == -1) - return WABT_ERROR; + return WabtResult::Error; if (fread(write_start, 1, read_length, lexer_file) < read_length) - return WABT_ERROR; + return WabtResult::Error; if (fseek(lexer_file, old_offset, SEEK_SET) == -1) - return WABT_ERROR; + return WabtResult::Error; } line[line_length] = '\0'; *out_line_length = line_length; *out_column_offset = new_line_start - line_start; - return WABT_OK; + return WabtResult::Ok; } diff --git a/src/ast-lexer.h b/src/ast-lexer.h index 10c0f4c9..818c843d 100644 --- a/src/ast-lexer.h +++ b/src/ast-lexer.h @@ -23,9 +23,9 @@ #include "common.h" #include "vector.h" -enum WabtAstLexerSourceType { - WABT_LEXER_SOURCE_TYPE_FILE, - WABT_LEXER_SOURCE_TYPE_BUFFER, +enum class WabtAstLexerSourceType { + File, + Buffer, }; struct WabtAstLexerSource { diff --git a/src/ast-parser-lexer-shared.cc b/src/ast-parser-lexer-shared.cc index 24936e93..5808b2ab 100644 --- a/src/ast-parser-lexer-shared.cc +++ b/src/ast-parser-lexer-shared.cc @@ -98,18 +98,18 @@ void wabt_destroy_func_fields(WabtFuncField* func_field) { WabtFuncField* next_func_field = func_field->next; switch (func_field->type) { - case WABT_FUNC_FIELD_TYPE_EXPRS: + case WabtFuncFieldType::Exprs: wabt_destroy_expr_list(func_field->first_expr); break; - case WABT_FUNC_FIELD_TYPE_PARAM_TYPES: - case WABT_FUNC_FIELD_TYPE_LOCAL_TYPES: - case WABT_FUNC_FIELD_TYPE_RESULT_TYPES: + case WabtFuncFieldType::ParamTypes: + case WabtFuncFieldType::LocalTypes: + case WabtFuncFieldType::ResultTypes: wabt_destroy_type_vector(&func_field->types); break; - case WABT_FUNC_FIELD_TYPE_BOUND_PARAM: - case WABT_FUNC_FIELD_TYPE_BOUND_LOCAL: + case WabtFuncFieldType::BoundParam: + case WabtFuncFieldType::BoundLocal: wabt_destroy_string_slice(&func_field->bound_type.name); break; } diff --git a/src/ast-parser-lexer-shared.h b/src/ast-parser-lexer-shared.h index 8ad3a82c..c957248a 100644 --- a/src/ast-parser-lexer-shared.h +++ b/src/ast-parser-lexer-shared.h @@ -75,13 +75,13 @@ struct WabtExportedMemory { bool has_data_segment; }; -enum WabtFuncFieldType { - WABT_FUNC_FIELD_TYPE_EXPRS, - WABT_FUNC_FIELD_TYPE_PARAM_TYPES, - WABT_FUNC_FIELD_TYPE_BOUND_PARAM, - WABT_FUNC_FIELD_TYPE_RESULT_TYPES, - WABT_FUNC_FIELD_TYPE_LOCAL_TYPES, - WABT_FUNC_FIELD_TYPE_BOUND_LOCAL, +enum class WabtFuncFieldType { + Exprs, + ParamTypes, + BoundParam, + ResultTypes, + LocalTypes, + BoundLocal, }; struct WabtBoundType { diff --git a/src/ast-parser.y b/src/ast-parser.y index 521bb2fa..1263edeb 100644 --- a/src/ast-parser.y +++ b/src/ast-parser.y @@ -69,11 +69,11 @@ } \ while (0) -#define APPEND_FIELD_TO_LIST(module, field, KIND, kind, loc_, item) \ +#define APPEND_FIELD_TO_LIST(module, field, Kind, kind, loc_, item) \ do { \ field = wabt_append_module_field(module); \ field->loc = loc_; \ - field->type = WABT_MODULE_FIELD_TYPE_##KIND; \ + field->type = WabtModuleFieldType::Kind; \ field->kind = item; \ } while (0) @@ -93,13 +93,13 @@ } \ while (0) -#define APPEND_INLINE_EXPORT(module, KIND, loc_, value, index_) \ +#define APPEND_INLINE_EXPORT(module, Kind, loc_, value, index_) \ do \ if ((value).export_.has_export) { \ WabtModuleField* export_field; \ - APPEND_FIELD_TO_LIST(module, export_field, EXPORT, export_, loc_, \ + APPEND_FIELD_TO_LIST(module, export_field, Export, export_, loc_, \ (value).export_.export_); \ - export_field->export_.kind = WABT_EXTERNAL_KIND_##KIND; \ + export_field->export_.kind = WabtExternalKind::Kind; \ export_field->export_.var.loc = loc_; \ export_field->export_.var.index = index_; \ APPEND_ITEM_TO_VECTOR(module, Export, export, exports, \ @@ -437,12 +437,12 @@ literal : var : nat { $$.loc = @1; - $$.type = WABT_VAR_TYPE_INDEX; + $$.type = WabtVarType::Index; $$.index = $1; } | VAR { $$.loc = @1; - $$.type = WABT_VAR_TYPE_NAME; + $$.type = WabtVarType::Name; DUPTEXT($$.name, $1); } ; @@ -470,7 +470,7 @@ offset_opt : /* empty */ { $$ = 0; } | OFFSET_EQ_NAT { if (WABT_FAILED(wabt_parse_int64($1.start, $1.start + $1.length, &$$, - WABT_PARSE_SIGNED_AND_UNSIGNED))) { + WabtParseIntType::SignedAndUnsigned))) { wabt_ast_parser_error(&@1, lexer, parser, "invalid offset \"" PRIstringslice "\"", WABT_PRINTF_STRING_SLICE_ARG($1)); @@ -480,11 +480,11 @@ offset_opt : align_opt : /* empty */ { $$ = USE_NATURAL_ALIGNMENT; } | ALIGN_EQ_NAT { - if (WABT_FAILED(wabt_parse_int32($1.start, $1.start + $1.length, &$$, - WABT_PARSE_UNSIGNED_ONLY))) { - wabt_ast_parser_error(&@1, lexer, parser, - "invalid alignment \"" PRIstringslice "\"", - WABT_PRINTF_STRING_SLICE_ARG($1)); + if (WABT_FAILED(wabt_parse_int32($1.start, $1.start + $1.length, &$$, + WabtParseIntType::UnsignedOnly))) { + wabt_ast_parser_error(&@1, lexer, parser, + "invalid alignment \"" PRIstringslice "\"", + WABT_PRINTF_STRING_SLICE_ARG($1)); } } ; @@ -657,7 +657,7 @@ expr1 : | IF labeling_opt value_type_list if_ { $$ = $4; WabtExpr* if_ = $4.last; - assert(if_->type == WABT_EXPR_TYPE_IF); + assert(if_->type == WabtExprType::If); if_->if_.true_.label = $2; if_->if_.true_.sig = $3; } @@ -725,19 +725,19 @@ func_fields : func_body | LPAR RESULT value_type_list RPAR func_body { $$ = new_func_field(); - $$->type = WABT_FUNC_FIELD_TYPE_RESULT_TYPES; + $$->type = WabtFuncFieldType::ResultTypes; $$->types = $3; $$->next = $5; } | LPAR PARAM value_type_list RPAR func_fields { $$ = new_func_field(); - $$->type = WABT_FUNC_FIELD_TYPE_PARAM_TYPES; + $$->type = WabtFuncFieldType::ParamTypes; $$->types = $3; $$->next = $5; } | LPAR PARAM bind_var VALUE_TYPE RPAR func_fields { $$ = new_func_field(); - $$->type = WABT_FUNC_FIELD_TYPE_BOUND_PARAM; + $$->type = WabtFuncFieldType::BoundParam; $$->bound_type.loc = @2; $$->bound_type.name = $3; $$->bound_type.type = $4; @@ -747,19 +747,19 @@ func_fields : func_body : instr_list { $$ = new_func_field(); - $$->type = WABT_FUNC_FIELD_TYPE_EXPRS; + $$->type = WabtFuncFieldType::Exprs; $$->first_expr = $1.first; $$->next = nullptr; } | LPAR LOCAL value_type_list RPAR func_body { $$ = new_func_field(); - $$->type = WABT_FUNC_FIELD_TYPE_LOCAL_TYPES; + $$->type = WabtFuncFieldType::LocalTypes; $$->types = $3; $$->next = $5; } | LPAR LOCAL bind_var VALUE_TYPE RPAR func_body { $$ = new_func_field(); - $$->type = WABT_FUNC_FIELD_TYPE_BOUND_LOCAL; + $$->type = WabtFuncFieldType::BoundLocal; $$->bound_type.loc = @2; $$->bound_type.name = $3; $$->bound_type.type = $4; @@ -774,26 +774,25 @@ func_info : while (field) { WabtFuncField* next = field->next; switch (field->type) { - case WABT_FUNC_FIELD_TYPE_EXPRS: + case WabtFuncFieldType::Exprs: $$->first_expr = field->first_expr; break; - case WABT_FUNC_FIELD_TYPE_PARAM_TYPES: - case WABT_FUNC_FIELD_TYPE_LOCAL_TYPES: { - WabtTypeVector* types = - field->type == WABT_FUNC_FIELD_TYPE_PARAM_TYPES - ? &$$->decl.sig.param_types - : &$$->local_types; + case WabtFuncFieldType::ParamTypes: + case WabtFuncFieldType::LocalTypes: { + WabtTypeVector* types = field->type == WabtFuncFieldType::ParamTypes + ? &$$->decl.sig.param_types + : &$$->local_types; wabt_extend_types(types, &field->types); wabt_destroy_type_vector(&field->types); break; } - case WABT_FUNC_FIELD_TYPE_BOUND_PARAM: - case WABT_FUNC_FIELD_TYPE_BOUND_LOCAL: { + case WabtFuncFieldType::BoundParam: + case WabtFuncFieldType::BoundLocal: { WabtTypeVector* types; WabtBindingHash* bindings; - if (field->type == WABT_FUNC_FIELD_TYPE_BOUND_PARAM) { + if (field->type == WabtFuncFieldType::BoundParam) { types = &$$->decl.sig.param_types; bindings = &$$->param_bindings; } else { @@ -809,7 +808,7 @@ func_info : break; } - case WABT_FUNC_FIELD_TYPE_RESULT_TYPES: + case WabtFuncFieldType::ResultTypes: $$->decl.sig.result_types = field->types; break; } @@ -870,7 +869,7 @@ elem : | LPAR ELEM offset var_list RPAR { WABT_ZERO_MEMORY($$); $$.table_var.loc = @2; - $$.table_var.type = WABT_VAR_TYPE_INDEX; + $$.table_var.type = WabtVarType::Index; $$.table_var.index = 0; $$.offset = $3.first; $$.vars = $4; @@ -888,7 +887,7 @@ table : LPAR ELEM var_list RPAR RPAR { WabtExpr* expr = wabt_new_const_expr(); expr->loc = @2; - expr->const_.type = WABT_TYPE_I32; + expr->const_.type = WabtType::I32; expr->const_.u32 = 0; WABT_ZERO_MEMORY($$); @@ -914,7 +913,7 @@ data : | LPAR DATA offset text_list RPAR { WABT_ZERO_MEMORY($$); $$.memory_var.loc = @2; - $$.memory_var.type = WABT_VAR_TYPE_INDEX; + $$.memory_var.type = WabtVarType::Index; $$.memory_var.index = 0; $$.offset = $3.first; dup_text_list(&$4, &$$.data, &$$.size); @@ -933,7 +932,7 @@ memory : | LPAR MEMORY bind_var_opt inline_export LPAR DATA text_list RPAR RPAR { WabtExpr* expr = wabt_new_const_expr(); expr->loc = @2; - expr->const_.type = WABT_TYPE_I32; + expr->const_.type = WabtType::I32; expr->const_.u32 = 0; WABT_ZERO_MEMORY($$); @@ -953,7 +952,7 @@ memory : | LPAR MEMORY bind_var_opt LPAR DATA text_list RPAR RPAR { WabtExpr* expr = wabt_new_const_expr(); expr->loc = @2; - expr->const_.type = WABT_TYPE_I32; + expr->const_.type = WabtType::I32; expr->const_.u32 = 0; WABT_ZERO_MEMORY($$); @@ -994,32 +993,32 @@ global : import_kind : LPAR FUNC bind_var_opt type_use RPAR { $$ = new_import(); - $$->kind = WABT_EXTERNAL_KIND_FUNC; + $$->kind = WabtExternalKind::Func; $$->func.name = $3; $$->func.decl.flags = WABT_FUNC_DECLARATION_FLAG_HAS_FUNC_TYPE; $$->func.decl.type_var = $4; } | LPAR FUNC bind_var_opt func_sig RPAR { $$ = new_import(); - $$->kind = WABT_EXTERNAL_KIND_FUNC; + $$->kind = WabtExternalKind::Func; $$->func.name = $3; $$->func.decl.sig = $4; } | LPAR TABLE bind_var_opt table_sig RPAR { $$ = new_import(); - $$->kind = WABT_EXTERNAL_KIND_TABLE; + $$->kind = WabtExternalKind::Table; $$->table = $4; $$->table.name = $3; } | LPAR MEMORY bind_var_opt memory_sig RPAR { $$ = new_import(); - $$->kind = WABT_EXTERNAL_KIND_MEMORY; + $$->kind = WabtExternalKind::Memory; $$->memory = $4; $$->memory.name = $3; } | LPAR GLOBAL bind_var_opt global_type RPAR { $$ = new_import(); - $$->kind = WABT_EXTERNAL_KIND_GLOBAL; + $$->kind = WabtExternalKind::Global; $$->global = $4; $$->global.name = $3; } @@ -1032,32 +1031,32 @@ import : } | LPAR FUNC bind_var_opt inline_import type_use RPAR { $$ = $4; - $$->kind = WABT_EXTERNAL_KIND_FUNC; + $$->kind = WabtExternalKind::Func; $$->func.name = $3; $$->func.decl.flags = WABT_FUNC_DECLARATION_FLAG_HAS_FUNC_TYPE; $$->func.decl.type_var = $5; } | LPAR FUNC bind_var_opt inline_import func_sig RPAR { $$ = $4; - $$->kind = WABT_EXTERNAL_KIND_FUNC; + $$->kind = WabtExternalKind::Func; $$->func.name = $3; $$->func.decl.sig = $5; } | LPAR TABLE bind_var_opt inline_import table_sig RPAR { $$ = $4; - $$->kind = WABT_EXTERNAL_KIND_TABLE; + $$->kind = WabtExternalKind::Table; $$->table = $5; $$->table.name = $3; } | LPAR MEMORY bind_var_opt inline_import memory_sig RPAR { $$ = $4; - $$->kind = WABT_EXTERNAL_KIND_MEMORY; + $$->kind = WabtExternalKind::Memory; $$->memory = $5; $$->memory.name = $3; } | LPAR GLOBAL bind_var_opt inline_import global_type RPAR { $$ = $4; - $$->kind = WABT_EXTERNAL_KIND_GLOBAL; + $$->kind = WabtExternalKind::Global; $$->global = $5; $$->global.name = $3; } @@ -1074,22 +1073,22 @@ inline_import : export_kind : LPAR FUNC var RPAR { WABT_ZERO_MEMORY($$); - $$.kind = WABT_EXTERNAL_KIND_FUNC; + $$.kind = WabtExternalKind::Func; $$.var = $3; } | LPAR TABLE var RPAR { WABT_ZERO_MEMORY($$); - $$.kind = WABT_EXTERNAL_KIND_TABLE; + $$.kind = WabtExternalKind::Table; $$.var = $3; } | LPAR MEMORY var RPAR { WABT_ZERO_MEMORY($$); - $$.kind = WABT_EXTERNAL_KIND_MEMORY; + $$.kind = WabtExternalKind::Memory; $$.var = $3; } | LPAR GLOBAL var RPAR { WABT_ZERO_MEMORY($$); - $$.kind = WABT_EXTERNAL_KIND_GLOBAL; + $$.kind = WabtExternalKind::Global; $$.var = $3; } ; @@ -1140,7 +1139,7 @@ module_fields : | module_fields type_def { $$ = $1; WabtModuleField* field; - APPEND_FIELD_TO_LIST($$, field, FUNC_TYPE, func_type, @2, $2); + APPEND_FIELD_TO_LIST($$, field, FuncType, func_type, @2, $2); APPEND_ITEM_TO_VECTOR($$, FuncType, func_type, func_types, &field->func_type); INSERT_BINDING($$, func_type, func_types, @2, $2.name); @@ -1148,22 +1147,22 @@ module_fields : | module_fields global { $$ = $1; WabtModuleField* field; - APPEND_FIELD_TO_LIST($$, field, GLOBAL, global, @2, $2.global); + APPEND_FIELD_TO_LIST($$, field, Global, global, @2, $2.global); APPEND_ITEM_TO_VECTOR($$, Global, global, globals, &field->global); INSERT_BINDING($$, global, globals, @2, $2.global.name); - APPEND_INLINE_EXPORT($$, GLOBAL, @2, $2, $$->globals.size - 1); + APPEND_INLINE_EXPORT($$, Global, @2, $2, $$->globals.size - 1); } | module_fields table { $$ = $1; WabtModuleField* field; - APPEND_FIELD_TO_LIST($$, field, TABLE, table, @2, $2.table); + APPEND_FIELD_TO_LIST($$, field, Table, table, @2, $2.table); APPEND_ITEM_TO_VECTOR($$, Table, table, tables, &field->table); INSERT_BINDING($$, table, tables, @2, $2.table.name); - APPEND_INLINE_EXPORT($$, TABLE, @2, $2, $$->tables.size - 1); + APPEND_INLINE_EXPORT($$, Table, @2, $2, $$->tables.size - 1); if ($2.has_elem_segment) { WabtModuleField* elem_segment_field; - APPEND_FIELD_TO_LIST($$, elem_segment_field, ELEM_SEGMENT, elem_segment, + APPEND_FIELD_TO_LIST($$, elem_segment_field, ElemSegment, elem_segment, @2, $2.elem_segment); APPEND_ITEM_TO_VECTOR($$, ElemSegment, elem_segment, elem_segments, &elem_segment_field->elem_segment); @@ -1173,14 +1172,14 @@ module_fields : | module_fields memory { $$ = $1; WabtModuleField* field; - APPEND_FIELD_TO_LIST($$, field, MEMORY, memory, @2, $2.memory); + APPEND_FIELD_TO_LIST($$, field, Memory, memory, @2, $2.memory); APPEND_ITEM_TO_VECTOR($$, Memory, memory, memories, &field->memory); INSERT_BINDING($$, memory, memories, @2, $2.memory.name); - APPEND_INLINE_EXPORT($$, MEMORY, @2, $2, $$->memories.size - 1); + APPEND_INLINE_EXPORT($$, Memory, @2, $2, $$->memories.size - 1); if ($2.has_data_segment) { WabtModuleField* data_segment_field; - APPEND_FIELD_TO_LIST($$, data_segment_field, DATA_SEGMENT, data_segment, + APPEND_FIELD_TO_LIST($$, data_segment_field, DataSegment, data_segment, @2, $2.data_segment); APPEND_ITEM_TO_VECTOR($$, DataSegment, data_segment, data_segments, &data_segment_field->data_segment); @@ -1189,68 +1188,65 @@ module_fields : | module_fields func { $$ = $1; WabtModuleField* field; - APPEND_FIELD_TO_LIST($$, field, FUNC, func, @2, *$2.func); + APPEND_FIELD_TO_LIST($$, field, Func, func, @2, *$2.func); append_implicit_func_declaration(&@2, $$, &field->func.decl); APPEND_ITEM_TO_VECTOR($$, Func, func, funcs, &field->func); INSERT_BINDING($$, func, funcs, @2, $2.func->name); - APPEND_INLINE_EXPORT($$, FUNC, @2, $2, $$->funcs.size - 1); + APPEND_INLINE_EXPORT($$, Func, @2, $2, $$->funcs.size - 1); wabt_free($2.func); } | module_fields elem { $$ = $1; WabtModuleField* field; - APPEND_FIELD_TO_LIST($$, field, ELEM_SEGMENT, elem_segment, @2, $2); + APPEND_FIELD_TO_LIST($$, field, ElemSegment, elem_segment, @2, $2); APPEND_ITEM_TO_VECTOR($$, ElemSegment, elem_segment, elem_segments, &field->elem_segment); } | module_fields data { $$ = $1; WabtModuleField* field; - APPEND_FIELD_TO_LIST($$, field, DATA_SEGMENT, data_segment, @2, $2); + APPEND_FIELD_TO_LIST($$, field, DataSegment, data_segment, @2, $2); APPEND_ITEM_TO_VECTOR($$, DataSegment, data_segment, data_segments, &field->data_segment); } | module_fields start { $$ = $1; WabtModuleField* field; - APPEND_FIELD_TO_LIST($$, field, START, start, @2, $2); + APPEND_FIELD_TO_LIST($$, field, Start, start, @2, $2); $$->start = &field->start; } | module_fields import { $$ = $1; WabtModuleField* field; - APPEND_FIELD_TO_LIST($$, field, IMPORT, import, @2, *$2); + APPEND_FIELD_TO_LIST($$, field, Import, import, @2, *$2); CHECK_IMPORT_ORDERING($$, func, funcs, @2); CHECK_IMPORT_ORDERING($$, table, tables, @2); CHECK_IMPORT_ORDERING($$, memory, memories, @2); CHECK_IMPORT_ORDERING($$, global, globals, @2); switch ($2->kind) { - case WABT_EXTERNAL_KIND_FUNC: + case WabtExternalKind::Func: append_implicit_func_declaration(&@2, $$, &field->import.func.decl); APPEND_ITEM_TO_VECTOR($$, Func, func, funcs, &field->import.func); INSERT_BINDING($$, func, funcs, @2, field->import.func.name); $$->num_func_imports++; break; - case WABT_EXTERNAL_KIND_TABLE: + case WabtExternalKind::Table: APPEND_ITEM_TO_VECTOR($$, Table, table, tables, &field->import.table); INSERT_BINDING($$, table, tables, @2, field->import.table.name); $$->num_table_imports++; break; - case WABT_EXTERNAL_KIND_MEMORY: + case WabtExternalKind::Memory: APPEND_ITEM_TO_VECTOR($$, Memory, memory, memories, &field->import.memory); INSERT_BINDING($$, memory, memories, @2, field->import.memory.name); $$->num_memory_imports++; break; - case WABT_EXTERNAL_KIND_GLOBAL: + case WabtExternalKind::Global: APPEND_ITEM_TO_VECTOR($$, Global, global, globals, &field->import.global); INSERT_BINDING($$, global, globals, @2, field->import.global.name); $$->num_global_imports++; break; - case WABT_NUM_EXTERNAL_KINDS: - assert(0); - break; } wabt_free($2); APPEND_ITEM_TO_VECTOR($$, Import, import, imports, &field->import); @@ -1258,7 +1254,7 @@ module_fields : | module_fields export { $$ = $1; WabtModuleField* field = wabt_append_module_field($$); - APPEND_FIELD_TO_LIST($$, field, EXPORT, export_, @2, $2); + APPEND_FIELD_TO_LIST($$, field, Export, export_, @2, $2); APPEND_ITEM_TO_VECTOR($$, Export, export, exports, &field->export_); INSERT_BINDING($$, export, exports, @2, $2.name); } @@ -1266,7 +1262,7 @@ module_fields : raw_module : LPAR MODULE bind_var_opt module_fields RPAR { - $$.type = WABT_RAW_MODULE_TYPE_TEXT; + $$.type = WabtRawModuleType::Text; $$.text = $4; $$.text->name = $3; $$.text->loc = @2; @@ -1288,7 +1284,7 @@ raw_module : } } | LPAR MODULE bind_var_opt non_empty_text_list RPAR { - $$.type = WABT_RAW_MODULE_TYPE_BINARY; + $$.type = WabtRawModuleType::Binary; $$.binary.name = $3; $$.binary.loc = @2; dup_text_list(&$4, &$$.binary.data, &$$.binary.size); @@ -1298,10 +1294,10 @@ raw_module : module : raw_module { - if ($1.type == WABT_RAW_MODULE_TYPE_TEXT) { + if ($1.type == WabtRawModuleType::Text) { $$ = $1.text; } else { - assert($1.type == WABT_RAW_MODULE_TYPE_BINARY); + assert($1.type == WabtRawModuleType::Binary); $$ = new_module(); WabtReadBinaryOptions options = WABT_READ_BINARY_OPTIONS_DEFAULT; BinaryErrorCallbackData user_data; @@ -1325,12 +1321,12 @@ module : script_var_opt : /* empty */ { WABT_ZERO_MEMORY($$); - $$.type = WABT_VAR_TYPE_INDEX; + $$.type = WabtVarType::Index; $$.index = INVALID_VAR_INDEX; } | VAR { WABT_ZERO_MEMORY($$); - $$.type = WABT_VAR_TYPE_NAME; + $$.type = WabtVarType::Name; DUPTEXT($$.name, $1); } ; @@ -1340,7 +1336,7 @@ action : WABT_ZERO_MEMORY($$); $$.loc = @2; $$.module_var = $3; - $$.type = WABT_ACTION_TYPE_INVOKE; + $$.type = WabtActionType::Invoke; $$.invoke.name = $4; $$.invoke.args = $5; } @@ -1348,7 +1344,7 @@ action : WABT_ZERO_MEMORY($$); $$.loc = @2; $$.module_var = $3; - $$.type = WABT_ACTION_TYPE_GET; + $$.type = WabtActionType::Get; $$.invoke.name = $4; } ; @@ -1356,48 +1352,48 @@ action : assertion : LPAR ASSERT_MALFORMED raw_module quoted_text RPAR { $$ = new_command(); - $$->type = WABT_COMMAND_TYPE_ASSERT_MALFORMED; + $$->type = WabtCommandType::AssertMalformed; $$->assert_malformed.module = $3; $$->assert_malformed.text = $4; } | LPAR ASSERT_INVALID raw_module quoted_text RPAR { $$ = new_command(); - $$->type = WABT_COMMAND_TYPE_ASSERT_INVALID; + $$->type = WabtCommandType::AssertInvalid; $$->assert_invalid.module = $3; $$->assert_invalid.text = $4; } | LPAR ASSERT_UNLINKABLE raw_module quoted_text RPAR { $$ = new_command(); - $$->type = WABT_COMMAND_TYPE_ASSERT_UNLINKABLE; + $$->type = WabtCommandType::AssertUnlinkable; $$->assert_unlinkable.module = $3; $$->assert_unlinkable.text = $4; } | LPAR ASSERT_TRAP raw_module quoted_text RPAR { $$ = new_command(); - $$->type = WABT_COMMAND_TYPE_ASSERT_UNINSTANTIABLE; + $$->type = WabtCommandType::AssertUninstantiable; $$->assert_uninstantiable.module = $3; $$->assert_uninstantiable.text = $4; } | LPAR ASSERT_RETURN action const_list RPAR { $$ = new_command(); - $$->type = WABT_COMMAND_TYPE_ASSERT_RETURN; + $$->type = WabtCommandType::AssertReturn; $$->assert_return.action = $3; $$->assert_return.expected = $4; } | LPAR ASSERT_RETURN_NAN action RPAR { $$ = new_command(); - $$->type = WABT_COMMAND_TYPE_ASSERT_RETURN_NAN; + $$->type = WabtCommandType::AssertReturnNan; $$->assert_return_nan.action = $3; } | LPAR ASSERT_TRAP action quoted_text RPAR { $$ = new_command(); - $$->type = WABT_COMMAND_TYPE_ASSERT_TRAP; + $$->type = WabtCommandType::AssertTrap; $$->assert_trap.action = $3; $$->assert_trap.text = $4; } | LPAR ASSERT_EXHAUSTION action quoted_text RPAR { $$ = new_command(); - $$->type = WABT_COMMAND_TYPE_ASSERT_EXHAUSTION; + $$->type = WabtCommandType::AssertExhaustion; $$->assert_trap.action = $3; $$->assert_trap.text = $4; } @@ -1406,19 +1402,19 @@ assertion : cmd : action { $$ = new_command(); - $$->type = WABT_COMMAND_TYPE_ACTION; + $$->type = WabtCommandType::Action; $$->action = $1; } | assertion | module { $$ = new_command(); - $$->type = WABT_COMMAND_TYPE_MODULE; + $$->type = WabtCommandType::Module; $$->module = *$1; wabt_free($1); } | LPAR REGISTER quoted_text script_var_opt RPAR { $$ = new_command(); - $$->type = WABT_COMMAND_TYPE_REGISTER; + $$->type = WabtCommandType::Register; $$->register_.module_name = $3; $$->register_.var = $4; $$->register_.var.loc = @4; @@ -1464,7 +1460,7 @@ script : WabtCommand* command = &$$.commands.data[i]; WabtVar* module_var = nullptr; switch (command->type) { - case WABT_COMMAND_TYPE_MODULE: { + case WabtCommandType::Module: { last_module_index = i; /* Wire up module name bindings. */ @@ -1480,27 +1476,27 @@ script : break; } - case WABT_COMMAND_TYPE_ASSERT_RETURN: + case WabtCommandType::AssertReturn: module_var = &command->assert_return.action.module_var; goto has_module_var; - case WABT_COMMAND_TYPE_ASSERT_RETURN_NAN: + case WabtCommandType::AssertReturnNan: module_var = &command->assert_return_nan.action.module_var; goto has_module_var; - case WABT_COMMAND_TYPE_ASSERT_TRAP: - case WABT_COMMAND_TYPE_ASSERT_EXHAUSTION: + case WabtCommandType::AssertTrap: + case WabtCommandType::AssertExhaustion: module_var = &command->assert_trap.action.module_var; goto has_module_var; - case WABT_COMMAND_TYPE_ACTION: + case WabtCommandType::Action: module_var = &command->action.module_var; goto has_module_var; - case WABT_COMMAND_TYPE_REGISTER: + case WabtCommandType::Register: module_var = &command->register_.var; goto has_module_var; has_module_var: { /* Resolve actions with an invalid index to use the preceding * module. */ - if (module_var->type == WABT_VAR_TYPE_INDEX && + if (module_var->type == WabtVarType::Index && module_var->index == INVALID_VAR_INDEX) { module_var->index = last_module_index; } @@ -1568,21 +1564,21 @@ static WabtResult parse_const(WabtType type, WabtConst* out) { out->type = type; switch (type) { - case WABT_TYPE_I32: + case WabtType::I32: return wabt_parse_int32(s, end, &out->u32, - WABT_PARSE_SIGNED_AND_UNSIGNED); - case WABT_TYPE_I64: + WabtParseIntType::SignedAndUnsigned); + case WabtType::I64: return wabt_parse_int64(s, end, &out->u64, - WABT_PARSE_SIGNED_AND_UNSIGNED); - case WABT_TYPE_F32: + WabtParseIntType::SignedAndUnsigned); + case WabtType::F32: return wabt_parse_float(literal_type, s, end, &out->f32_bits); - case WABT_TYPE_F64: + case WabtType::F64: return wabt_parse_double(literal_type, s, end, &out->f64_bits); default: assert(0); break; } - return WABT_ERROR; + return WabtResult::Error; } static size_t copy_string_contents(WabtStringSlice* text, char* dest) { @@ -1693,7 +1689,7 @@ WabtResult wabt_parse_ast(WabtAstLexer* lexer, wabt_free(parser.yyvsa); wabt_free(parser.yylsa); *out_script = parser.script; - return result == 0 && parser.errors == 0 ? WABT_OK : WABT_ERROR; + return result == 0 && parser.errors == 0 ? WabtResult::Ok : WabtResult::Error; } static void on_read_binary_error(uint32_t offset, const char* error, diff --git a/src/ast-writer.cc b/src/ast-writer.cc index 3d92d7ef..33871b22 100644 --- a/src/ast-writer.cc +++ b/src/ast-writer.cc @@ -44,11 +44,11 @@ static const uint8_t s_is_char_escaped[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; -enum NextChar { - NEXT_CHAR_NONE, - NEXT_CHAR_SPACE, - NEXT_CHAR_NEWLINE, - NEXT_CHAR_FORCE_NEWLINE, +enum class NextChar { + None, + Space, + Newline, + ForceNewline, }; struct Context { @@ -93,20 +93,20 @@ static void write_indent(Context* ctx) { static void write_next_char(Context* ctx) { switch (ctx->next_char) { - case NEXT_CHAR_SPACE: + case NextChar::Space: wabt_write_data(&ctx->stream, " ", 1, nullptr); break; - case NEXT_CHAR_NEWLINE: - case NEXT_CHAR_FORCE_NEWLINE: + case NextChar::Newline: + case NextChar::ForceNewline: wabt_write_data(&ctx->stream, "\n", 1, nullptr); write_indent(ctx); break; default: - case NEXT_CHAR_NONE: + case NextChar::None: break; } - ctx->next_char = NEXT_CHAR_NONE; + ctx->next_char = NextChar::None; } static void write_data_with_next_char(Context* ctx, @@ -121,7 +121,7 @@ static void WABT_PRINTF_FORMAT(2, 3) WABT_SNPRINTF_ALLOCA(buffer, length, format); /* default to following space */ write_data_with_next_char(ctx, buffer, length); - ctx->next_char = NEXT_CHAR_SPACE; + ctx->next_char = NextChar::Space; } static void write_putc(Context* ctx, char c) { @@ -135,46 +135,46 @@ static void write_puts(Context* ctx, const char* s, NextChar next_char) { } static void write_puts_space(Context* ctx, const char* s) { - write_puts(ctx, s, NEXT_CHAR_SPACE); + write_puts(ctx, s, NextChar::Space); } static void write_puts_newline(Context* ctx, const char* s) { - write_puts(ctx, s, NEXT_CHAR_NEWLINE); + write_puts(ctx, s, NextChar::Newline); } static void write_newline(Context* ctx, bool force) { - if (ctx->next_char == NEXT_CHAR_FORCE_NEWLINE) + if (ctx->next_char == NextChar::ForceNewline) write_next_char(ctx); - ctx->next_char = force ? NEXT_CHAR_FORCE_NEWLINE : NEXT_CHAR_NEWLINE; + ctx->next_char = force ? NextChar::ForceNewline : NextChar::Newline; } static void write_open(Context* ctx, const char* name, NextChar next_char) { - write_puts(ctx, "(", NEXT_CHAR_NONE); + write_puts(ctx, "(", NextChar::None); write_puts(ctx, name, next_char); indent(ctx); } static void write_open_newline(Context* ctx, const char* name) { - write_open(ctx, name, NEXT_CHAR_NEWLINE); + write_open(ctx, name, NextChar::Newline); } static void write_open_space(Context* ctx, const char* name) { - write_open(ctx, name, NEXT_CHAR_SPACE); + write_open(ctx, name, NextChar::Space); } static void write_close(Context* ctx, NextChar next_char) { - if (ctx->next_char != NEXT_CHAR_FORCE_NEWLINE) - ctx->next_char = NEXT_CHAR_NONE; + if (ctx->next_char != NextChar::ForceNewline) + ctx->next_char = NextChar::None; dedent(ctx); write_puts(ctx, ")", next_char); } static void write_close_newline(Context* ctx) { - write_close(ctx, NEXT_CHAR_NEWLINE); + write_close(ctx, NextChar::Newline); } static void write_close_space(Context* ctx) { - write_close(ctx, NEXT_CHAR_SPACE); + write_close(ctx, NextChar::Space); } static void write_string_slice(Context* ctx, @@ -219,7 +219,7 @@ static void write_quoted_data(Context* ctx, const void* data, size_t length) { } } write_putc(ctx, '\"'); - ctx->next_char = NEXT_CHAR_SPACE; + ctx->next_char = NextChar::Space; } static void write_quoted_string_slice(Context* ctx, @@ -230,7 +230,7 @@ static void write_quoted_string_slice(Context* ctx, } static void write_var(Context* ctx, const WabtVar* var, NextChar next_char) { - if (var->type == WABT_VAR_TYPE_INDEX) { + if (var->type == WabtVarType::Index) { writef(ctx, "%" PRId64, var->index); ctx->next_char = next_char; } else { @@ -239,7 +239,7 @@ static void write_var(Context* ctx, const WabtVar* var, NextChar next_char) { } static void write_br_var(Context* ctx, const WabtVar* var, NextChar next_char) { - if (var->type == WABT_VAR_TYPE_INDEX) { + if (var->type == WabtVarType::Index) { writef(ctx, "%" PRId64 " (;@%" PRId64 ";)", var->index, ctx->depth - var->index - 1); ctx->next_char = next_char; @@ -262,7 +262,7 @@ static void write_types(Context* ctx, if (name) write_open_space(ctx, name); for (i = 0; i < types->size; ++i) - write_type(ctx, types->data[i], NEXT_CHAR_SPACE); + write_type(ctx, types->data[i], NextChar::Space); if (name) write_close_space(ctx); } @@ -283,7 +283,7 @@ static void write_begin_block(Context* ctx, const char* text) { write_puts_space(ctx, text); bool has_label = - write_string_slice_opt(ctx, &block->label, NEXT_CHAR_SPACE); + write_string_slice_opt(ctx, &block->label, NextChar::Space); write_types(ctx, &block->sig, nullptr); if (!has_label) writef(ctx, " ;; label = @%d", ctx->depth); @@ -295,7 +295,7 @@ static void write_begin_block(Context* ctx, static void write_end_block(Context* ctx) { dedent(ctx); ctx->depth--; - write_puts_newline(ctx, wabt_get_opcode_name(WABT_OPCODE_END)); + write_puts_newline(ctx, wabt_get_opcode_name(WabtOpcode::End)); } static void write_block(Context* ctx, @@ -308,20 +308,20 @@ static void write_block(Context* ctx, static void write_const(Context* ctx, const WabtConst* const_) { switch (const_->type) { - case WABT_TYPE_I32: - write_puts_space(ctx, wabt_get_opcode_name(WABT_OPCODE_I32_CONST)); + case WabtType::I32: + write_puts_space(ctx, wabt_get_opcode_name(WabtOpcode::I32Const)); writef(ctx, "%d", static_cast<int32_t>(const_->u32)); write_newline(ctx, NO_FORCE_NEWLINE); break; - case WABT_TYPE_I64: - write_puts_space(ctx, wabt_get_opcode_name(WABT_OPCODE_I64_CONST)); + case WabtType::I64: + write_puts_space(ctx, wabt_get_opcode_name(WabtOpcode::I64Const)); writef(ctx, "%" PRId64, static_cast<int64_t>(const_->u64)); write_newline(ctx, NO_FORCE_NEWLINE); break; - case WABT_TYPE_F32: { - write_puts_space(ctx, wabt_get_opcode_name(WABT_OPCODE_F32_CONST)); + case WabtType::F32: { + write_puts_space(ctx, wabt_get_opcode_name(WabtOpcode::F32Const)); char buffer[128]; wabt_write_float_hex(buffer, 128, const_->f32_bits); write_puts_space(ctx, buffer); @@ -332,8 +332,8 @@ static void write_const(Context* ctx, const WabtConst* const_) { break; } - case WABT_TYPE_F64: { - write_puts_space(ctx, wabt_get_opcode_name(WABT_OPCODE_F64_CONST)); + case WabtType::F64: { + write_puts_space(ctx, wabt_get_opcode_name(WabtOpcode::F64Const)); char buffer[128]; wabt_write_double_hex(buffer, 128, const_->f64_bits); write_puts_space(ctx, buffer); @@ -352,80 +352,80 @@ static void write_const(Context* ctx, const WabtConst* const_) { static void write_expr(Context* ctx, const WabtExpr* expr) { switch (expr->type) { - case WABT_EXPR_TYPE_BINARY: + case WabtExprType::Binary: write_puts_newline(ctx, wabt_get_opcode_name(expr->binary.opcode)); break; - case WABT_EXPR_TYPE_BLOCK: - write_block(ctx, &expr->block, wabt_get_opcode_name(WABT_OPCODE_BLOCK)); + case WabtExprType::Block: + write_block(ctx, &expr->block, wabt_get_opcode_name(WabtOpcode::Block)); break; - case WABT_EXPR_TYPE_BR: - write_puts_space(ctx, wabt_get_opcode_name(WABT_OPCODE_BR)); - write_br_var(ctx, &expr->br.var, NEXT_CHAR_NEWLINE); + case WabtExprType::Br: + write_puts_space(ctx, wabt_get_opcode_name(WabtOpcode::Br)); + write_br_var(ctx, &expr->br.var, NextChar::Newline); break; - case WABT_EXPR_TYPE_BR_IF: - write_puts_space(ctx, wabt_get_opcode_name(WABT_OPCODE_BR_IF)); - write_br_var(ctx, &expr->br_if.var, NEXT_CHAR_NEWLINE); + case WabtExprType::BrIf: + write_puts_space(ctx, wabt_get_opcode_name(WabtOpcode::BrIf)); + write_br_var(ctx, &expr->br_if.var, NextChar::Newline); break; - case WABT_EXPR_TYPE_BR_TABLE: { - write_puts_space(ctx, wabt_get_opcode_name(WABT_OPCODE_BR_TABLE)); + case WabtExprType::BrTable: { + write_puts_space(ctx, wabt_get_opcode_name(WabtOpcode::BrTable)); size_t i; for (i = 0; i < expr->br_table.targets.size; ++i) - write_br_var(ctx, &expr->br_table.targets.data[i], NEXT_CHAR_SPACE); - write_br_var(ctx, &expr->br_table.default_target, NEXT_CHAR_NEWLINE); + write_br_var(ctx, &expr->br_table.targets.data[i], NextChar::Space); + write_br_var(ctx, &expr->br_table.default_target, NextChar::Newline); break; } - case WABT_EXPR_TYPE_CALL: - write_puts_space(ctx, wabt_get_opcode_name(WABT_OPCODE_CALL)); - write_var(ctx, &expr->call.var, NEXT_CHAR_NEWLINE); + case WabtExprType::Call: + write_puts_space(ctx, wabt_get_opcode_name(WabtOpcode::Call)); + write_var(ctx, &expr->call.var, NextChar::Newline); break; - case WABT_EXPR_TYPE_CALL_INDIRECT: - write_puts_space(ctx, wabt_get_opcode_name(WABT_OPCODE_CALL_INDIRECT)); - write_var(ctx, &expr->call_indirect.var, NEXT_CHAR_NEWLINE); + case WabtExprType::CallIndirect: + write_puts_space(ctx, wabt_get_opcode_name(WabtOpcode::CallIndirect)); + write_var(ctx, &expr->call_indirect.var, NextChar::Newline); break; - case WABT_EXPR_TYPE_COMPARE: + case WabtExprType::Compare: write_puts_newline(ctx, wabt_get_opcode_name(expr->compare.opcode)); break; - case WABT_EXPR_TYPE_CONST: + case WabtExprType::Const: write_const(ctx, &expr->const_); break; - case WABT_EXPR_TYPE_CONVERT: + case WabtExprType::Convert: write_puts_newline(ctx, wabt_get_opcode_name(expr->convert.opcode)); break; - case WABT_EXPR_TYPE_DROP: - write_puts_newline(ctx, wabt_get_opcode_name(WABT_OPCODE_DROP)); + case WabtExprType::Drop: + write_puts_newline(ctx, wabt_get_opcode_name(WabtOpcode::Drop)); break; - case WABT_EXPR_TYPE_GET_GLOBAL: - write_puts_space(ctx, wabt_get_opcode_name(WABT_OPCODE_GET_GLOBAL)); - write_var(ctx, &expr->get_global.var, NEXT_CHAR_NEWLINE); + case WabtExprType::GetGlobal: + write_puts_space(ctx, wabt_get_opcode_name(WabtOpcode::GetGlobal)); + write_var(ctx, &expr->get_global.var, NextChar::Newline); break; - case WABT_EXPR_TYPE_GET_LOCAL: - write_puts_space(ctx, wabt_get_opcode_name(WABT_OPCODE_GET_LOCAL)); - write_var(ctx, &expr->get_local.var, NEXT_CHAR_NEWLINE); + case WabtExprType::GetLocal: + write_puts_space(ctx, wabt_get_opcode_name(WabtOpcode::GetLocal)); + write_var(ctx, &expr->get_local.var, NextChar::Newline); break; - case WABT_EXPR_TYPE_GROW_MEMORY: - write_puts_newline(ctx, wabt_get_opcode_name(WABT_OPCODE_GROW_MEMORY)); + case WabtExprType::GrowMemory: + write_puts_newline(ctx, wabt_get_opcode_name(WabtOpcode::GrowMemory)); break; - case WABT_EXPR_TYPE_IF: + case WabtExprType::If: write_begin_block(ctx, &expr->if_.true_, - wabt_get_opcode_name(WABT_OPCODE_IF)); + wabt_get_opcode_name(WabtOpcode::If)); write_expr_list(ctx, expr->if_.true_.first); if (expr->if_.false_) { dedent(ctx); - write_puts_space(ctx, wabt_get_opcode_name(WABT_OPCODE_ELSE)); + write_puts_space(ctx, wabt_get_opcode_name(WabtOpcode::Else)); indent(ctx); write_newline(ctx, FORCE_NEWLINE); write_expr_list(ctx, expr->if_.false_); @@ -433,7 +433,7 @@ static void write_expr(Context* ctx, const WabtExpr* expr) { write_end_block(ctx); break; - case WABT_EXPR_TYPE_LOAD: + case WabtExprType::Load: write_puts_space(ctx, wabt_get_opcode_name(expr->load.opcode)); if (expr->load.offset) writef(ctx, "offset=%" PRIu64, expr->load.offset); @@ -442,37 +442,37 @@ static void write_expr(Context* ctx, const WabtExpr* expr) { write_newline(ctx, NO_FORCE_NEWLINE); break; - case WABT_EXPR_TYPE_LOOP: - write_block(ctx, &expr->loop, wabt_get_opcode_name(WABT_OPCODE_LOOP)); + case WabtExprType::Loop: + write_block(ctx, &expr->loop, wabt_get_opcode_name(WabtOpcode::Loop)); break; - case WABT_EXPR_TYPE_CURRENT_MEMORY: - write_puts_newline(ctx, wabt_get_opcode_name(WABT_OPCODE_CURRENT_MEMORY)); + case WabtExprType::CurrentMemory: + write_puts_newline(ctx, wabt_get_opcode_name(WabtOpcode::CurrentMemory)); break; - case WABT_EXPR_TYPE_NOP: - write_puts_newline(ctx, wabt_get_opcode_name(WABT_OPCODE_NOP)); + case WabtExprType::Nop: + write_puts_newline(ctx, wabt_get_opcode_name(WabtOpcode::Nop)); break; - case WABT_EXPR_TYPE_RETURN: - write_puts_newline(ctx, wabt_get_opcode_name(WABT_OPCODE_RETURN)); + case WabtExprType::Return: + write_puts_newline(ctx, wabt_get_opcode_name(WabtOpcode::Return)); break; - case WABT_EXPR_TYPE_SELECT: - write_puts_newline(ctx, wabt_get_opcode_name(WABT_OPCODE_SELECT)); + case WabtExprType::Select: + write_puts_newline(ctx, wabt_get_opcode_name(WabtOpcode::Select)); break; - case WABT_EXPR_TYPE_SET_GLOBAL: - write_puts_space(ctx, wabt_get_opcode_name(WABT_OPCODE_SET_GLOBAL)); - write_var(ctx, &expr->set_global.var, NEXT_CHAR_NEWLINE); + case WabtExprType::SetGlobal: + write_puts_space(ctx, wabt_get_opcode_name(WabtOpcode::SetGlobal)); + write_var(ctx, &expr->set_global.var, NextChar::Newline); break; - case WABT_EXPR_TYPE_SET_LOCAL: - write_puts_space(ctx, wabt_get_opcode_name(WABT_OPCODE_SET_LOCAL)); - write_var(ctx, &expr->set_local.var, NEXT_CHAR_NEWLINE); + case WabtExprType::SetLocal: + write_puts_space(ctx, wabt_get_opcode_name(WabtOpcode::SetLocal)); + write_var(ctx, &expr->set_local.var, NextChar::Newline); break; - case WABT_EXPR_TYPE_STORE: + case WabtExprType::Store: write_puts_space(ctx, wabt_get_opcode_name(expr->store.opcode)); if (expr->store.offset) writef(ctx, "offset=%" PRIu64, expr->store.offset); @@ -481,21 +481,21 @@ static void write_expr(Context* ctx, const WabtExpr* expr) { write_newline(ctx, NO_FORCE_NEWLINE); break; - case WABT_EXPR_TYPE_TEE_LOCAL: - write_puts_space(ctx, wabt_get_opcode_name(WABT_OPCODE_TEE_LOCAL)); - write_var(ctx, &expr->tee_local.var, NEXT_CHAR_NEWLINE); + case WabtExprType::TeeLocal: + write_puts_space(ctx, wabt_get_opcode_name(WabtOpcode::TeeLocal)); + write_var(ctx, &expr->tee_local.var, NextChar::Newline); break; - case WABT_EXPR_TYPE_UNARY: + case WabtExprType::Unary: write_puts_newline(ctx, wabt_get_opcode_name(expr->unary.opcode)); break; - case WABT_EXPR_TYPE_UNREACHABLE: - write_puts_newline(ctx, wabt_get_opcode_name(WABT_OPCODE_UNREACHABLE)); + case WabtExprType::Unreachable: + write_puts_newline(ctx, wabt_get_opcode_name(WabtOpcode::Unreachable)); break; default: - fprintf(stderr, "bad expr type: %d\n", expr->type); + fprintf(stderr, "bad expr type: %d\n", static_cast<int>(expr->type)); assert(0); break; } @@ -509,11 +509,11 @@ static void write_expr_list(Context* ctx, const WabtExpr* first) { static void write_init_expr(Context* ctx, const WabtExpr* expr) { if (expr) { - write_puts(ctx, "(", NEXT_CHAR_NONE); + write_puts(ctx, "(", NextChar::None); write_expr(ctx, expr); /* clear the next char, so we don't write a newline after the expr */ - ctx->next_char = NEXT_CHAR_NONE; - write_puts(ctx, ")", NEXT_CHAR_SPACE); + ctx->next_char = NextChar::None; + write_puts(ctx, ")", NextChar::Space); } } @@ -540,8 +540,8 @@ static void write_type_bindings(Context* ctx, const WabtStringSlice* name = &ctx->index_to_name.data[i]; bool has_name = !!name->start; if (has_name) - write_string_slice(ctx, name, NEXT_CHAR_SPACE); - write_type(ctx, types->data[i], NEXT_CHAR_SPACE); + write_string_slice(ctx, name, NextChar::Space); + write_type(ctx, types->data[i], NextChar::Space); if (has_name) { write_close_space(ctx); is_open = false; @@ -556,10 +556,10 @@ static void write_func(Context* ctx, const WabtFunc* func) { write_open_space(ctx, "func"); write_string_slice_or_index(ctx, &func->name, ctx->func_index++, - NEXT_CHAR_SPACE); + NextChar::Space); if (wabt_decl_has_func_type(&func->decl)) { write_open_space(ctx, "type"); - write_var(ctx, &func->decl.type_var, NEXT_CHAR_NONE); + write_var(ctx, &func->decl.type_var, NextChar::None); write_close_space(ctx); } write_type_bindings(ctx, "param", func, &func->decl.sig.param_types, @@ -579,13 +579,13 @@ static void write_func(Context* ctx, static void write_begin_global(Context* ctx, const WabtGlobal* global) { write_open_space(ctx, "global"); write_string_slice_or_index(ctx, &global->name, ctx->global_index++, - NEXT_CHAR_SPACE); + NextChar::Space); if (global->mutable_) { write_open_space(ctx, "mut"); - write_type(ctx, global->type, NEXT_CHAR_SPACE); + write_type(ctx, global->type, NextChar::Space); write_close_space(ctx); } else { - write_type(ctx, global->type, NEXT_CHAR_SPACE); + write_type(ctx, global->type, NextChar::Space); } } @@ -604,7 +604,7 @@ static void write_limits(Context* ctx, const WabtLimits* limits) { static void write_table(Context* ctx, const WabtTable* table) { write_open_space(ctx, "table"); write_string_slice_or_index(ctx, &table->name, ctx->table_index++, - NEXT_CHAR_SPACE); + NextChar::Space); write_limits(ctx, &table->elem_limits); write_puts_space(ctx, "anyfunc"); write_close_newline(ctx); @@ -615,14 +615,14 @@ static void write_elem_segment(Context* ctx, const WabtElemSegment* segment) { write_init_expr(ctx, segment->offset); size_t i; for (i = 0; i < segment->vars.size; ++i) - write_var(ctx, &segment->vars.data[i], NEXT_CHAR_SPACE); + write_var(ctx, &segment->vars.data[i], NextChar::Space); write_close_newline(ctx); } static void write_memory(Context* ctx, const WabtMemory* memory) { write_open_space(ctx, "memory"); write_string_slice_or_index(ctx, &memory->name, ctx->memory_index++, - NEXT_CHAR_SPACE); + NextChar::Space); write_limits(ctx, &memory->page_limits); write_close_newline(ctx); } @@ -636,16 +636,16 @@ static void write_data_segment(Context* ctx, const WabtDataSegment* segment) { static void write_import(Context* ctx, const WabtImport* import) { write_open_space(ctx, "import"); - write_quoted_string_slice(ctx, &import->module_name, NEXT_CHAR_SPACE); - write_quoted_string_slice(ctx, &import->field_name, NEXT_CHAR_SPACE); + write_quoted_string_slice(ctx, &import->module_name, NextChar::Space); + write_quoted_string_slice(ctx, &import->field_name, NextChar::Space); switch (import->kind) { - case WABT_EXTERNAL_KIND_FUNC: + case WabtExternalKind::Func: write_open_space(ctx, "func"); write_string_slice_or_index(ctx, &import->func.name, ctx->func_index++, - NEXT_CHAR_SPACE); + NextChar::Space); if (wabt_decl_has_func_type(&import->func.decl)) { write_open_space(ctx, "type"); - write_var(ctx, &import->func.decl.type_var, NEXT_CHAR_NONE); + write_var(ctx, &import->func.decl.type_var, NextChar::None); write_close_space(ctx); } else { write_func_sig_space(ctx, &import->func.decl.sig); @@ -653,34 +653,30 @@ static void write_import(Context* ctx, const WabtImport* import) { write_close_space(ctx); break; - case WABT_EXTERNAL_KIND_TABLE: + case WabtExternalKind::Table: write_table(ctx, &import->table); break; - case WABT_EXTERNAL_KIND_MEMORY: + case WabtExternalKind::Memory: write_memory(ctx, &import->memory); break; - case WABT_EXTERNAL_KIND_GLOBAL: + case WabtExternalKind::Global: write_begin_global(ctx, &import->global); write_close_space(ctx); break; - - case WABT_NUM_EXTERNAL_KINDS: - assert(0); - break; } write_close_newline(ctx); } static void write_export(Context* ctx, const WabtExport* export_) { static const char* s_kind_names[] = {"func", "table", "memory", "global"}; - WABT_STATIC_ASSERT(WABT_ARRAY_SIZE(s_kind_names) == WABT_NUM_EXTERNAL_KINDS); + WABT_STATIC_ASSERT(WABT_ARRAY_SIZE(s_kind_names) == kWabtExternalKindCount); write_open_space(ctx, "export"); - write_quoted_string_slice(ctx, &export_->name, NEXT_CHAR_SPACE); - assert(export_->kind < WABT_ARRAY_SIZE(s_kind_names)); - write_open_space(ctx, s_kind_names[export_->kind]); - write_var(ctx, &export_->var, NEXT_CHAR_SPACE); + write_quoted_string_slice(ctx, &export_->name, NextChar::Space); + assert(static_cast<size_t>(export_->kind) < WABT_ARRAY_SIZE(s_kind_names)); + write_open_space(ctx, s_kind_names[static_cast<size_t>(export_->kind)]); + write_var(ctx, &export_->var, NextChar::Space); write_close_space(ctx); write_close_newline(ctx); } @@ -688,7 +684,7 @@ static void write_export(Context* ctx, const WabtExport* export_) { static void write_func_type(Context* ctx, const WabtFuncType* func_type) { write_open_space(ctx, "type"); write_string_slice_or_index(ctx, &func_type->name, ctx->func_type_index++, - NEXT_CHAR_SPACE); + NextChar::Space); write_open_space(ctx, "func"); write_func_sig_space(ctx, &func_type->sig); write_close_space(ctx); @@ -697,7 +693,7 @@ static void write_func_type(Context* ctx, const WabtFuncType* func_type) { static void write_start_function(Context* ctx, const WabtVar* start) { write_open_space(ctx, "start"); - write_var(ctx, start, NEXT_CHAR_NONE); + write_var(ctx, start, NextChar::None); write_close_newline(ctx); } @@ -706,34 +702,34 @@ static void write_module(Context* ctx, const WabtModule* module) { const WabtModuleField* field; for (field = module->first_field; field; field = field->next) { switch (field->type) { - case WABT_MODULE_FIELD_TYPE_FUNC: + case WabtModuleFieldType::Func: write_func(ctx, module, &field->func); break; - case WABT_MODULE_FIELD_TYPE_GLOBAL: + case WabtModuleFieldType::Global: write_global(ctx, &field->global); break; - case WABT_MODULE_FIELD_TYPE_IMPORT: + case WabtModuleFieldType::Import: write_import(ctx, &field->import); break; - case WABT_MODULE_FIELD_TYPE_EXPORT: + case WabtModuleFieldType::Export: write_export(ctx, &field->export_); break; - case WABT_MODULE_FIELD_TYPE_TABLE: + case WabtModuleFieldType::Table: write_table(ctx, &field->table); break; - case WABT_MODULE_FIELD_TYPE_ELEM_SEGMENT: + case WabtModuleFieldType::ElemSegment: write_elem_segment(ctx, &field->elem_segment); break; - case WABT_MODULE_FIELD_TYPE_MEMORY: + case WabtModuleFieldType::Memory: write_memory(ctx, &field->memory); break; - case WABT_MODULE_FIELD_TYPE_DATA_SEGMENT: + case WabtModuleFieldType::DataSegment: write_data_segment(ctx, &field->data_segment); break; - case WABT_MODULE_FIELD_TYPE_FUNC_TYPE: + case WabtModuleFieldType::FuncType: write_func_type(ctx, &field->func_type); break; - case WABT_MODULE_FIELD_TYPE_START: + case WabtModuleFieldType::Start: write_start_function(ctx, &field->start); break; } @@ -746,7 +742,7 @@ static void write_module(Context* ctx, const WabtModule* module) { WabtResult wabt_write_ast(WabtWriter* writer, const WabtModule* module) { Context ctx; WABT_ZERO_MEMORY(ctx); - ctx.result = WABT_OK; + ctx.result = WabtResult::Ok; wabt_init_stream(&ctx.stream, writer, nullptr); write_module(&ctx, module); /* the memory for the actual string slice is shared with the module, so we @@ -20,7 +20,7 @@ #include <stddef.h> int wabt_get_index_from_var(const WabtBindingHash* hash, const WabtVar* var) { - if (var->type == WABT_VAR_TYPE_NAME) + if (var->type == WabtVarType::Name) return wabt_find_binding_index_by_name(hash, &var->name); return static_cast<int>(var->index); } @@ -55,7 +55,7 @@ int wabt_get_func_type_index_by_var(const WabtModule* module, } int wabt_get_local_index_by_var(const WabtFunc* func, const WabtVar* var) { - if (var->type == WABT_VAR_TYPE_INDEX) + if (var->type == WabtVarType::Index) return static_cast<int>(var->index); int result = @@ -136,7 +136,7 @@ WabtModule* wabt_get_first_module(const WabtScript* script) { size_t i; for (i = 0; i < script->commands.size; ++i) { WabtCommand* command = &script->commands.data[i]; - if (command->type == WABT_COMMAND_TYPE_MODULE) + if (command->type == WabtCommandType::Module) return &command->module; } return nullptr; @@ -148,7 +148,7 @@ WabtModule* wabt_get_module_by_var(const WabtScript* script, if (index < 0 || static_cast<size_t>(index) >= script->commands.size) return nullptr; WabtCommand* command = &script->commands.data[index]; - assert(command->type == WABT_COMMAND_TYPE_MODULE); + assert(command->type == WabtCommandType::Module); return &command->module; } @@ -214,7 +214,7 @@ WabtFuncType* wabt_append_implicit_func_type(WabtLocation* loc, WabtFuncSignature* sig) { WabtModuleField* field = wabt_append_module_field(module); field->loc = *loc; - field->type = WABT_MODULE_FIELD_TYPE_FUNC_TYPE; + field->type = WabtModuleFieldType::FuncType; field->func_type.sig = *sig; WabtFuncType* func_type_ptr = &field->func_type; @@ -222,34 +222,34 @@ WabtFuncType* wabt_append_implicit_func_type(WabtLocation* loc, return func_type_ptr; } -#define FOREACH_EXPR_TYPE(V) \ - V(WABT_EXPR_TYPE_BINARY, binary) \ - V(WABT_EXPR_TYPE_BLOCK, block) \ - V(WABT_EXPR_TYPE_BR, br) \ - V(WABT_EXPR_TYPE_BR_IF, br_if) \ - V(WABT_EXPR_TYPE_BR_TABLE, br_table) \ - V(WABT_EXPR_TYPE_CALL, call) \ - V(WABT_EXPR_TYPE_CALL_INDIRECT, call_indirect) \ - V(WABT_EXPR_TYPE_COMPARE, compare) \ - V(WABT_EXPR_TYPE_CONST, const) \ - V(WABT_EXPR_TYPE_CONVERT, convert) \ - V(WABT_EXPR_TYPE_GET_GLOBAL, get_global) \ - V(WABT_EXPR_TYPE_GET_LOCAL, get_local) \ - V(WABT_EXPR_TYPE_IF, if) \ - V(WABT_EXPR_TYPE_LOAD, load) \ - V(WABT_EXPR_TYPE_LOOP, loop) \ - V(WABT_EXPR_TYPE_SET_GLOBAL, set_global) \ - V(WABT_EXPR_TYPE_SET_LOCAL, set_local) \ - V(WABT_EXPR_TYPE_STORE, store) \ - V(WABT_EXPR_TYPE_TEE_LOCAL, tee_local) \ - V(WABT_EXPR_TYPE_UNARY, unary) \ - V(WABT_EXPR_TYPE_CURRENT_MEMORY, current_memory) \ - V(WABT_EXPR_TYPE_DROP, drop) \ - V(WABT_EXPR_TYPE_GROW_MEMORY, grow_memory) \ - V(WABT_EXPR_TYPE_NOP, nop) \ - V(WABT_EXPR_TYPE_RETURN, return ) \ - V(WABT_EXPR_TYPE_SELECT, select) \ - V(WABT_EXPR_TYPE_UNREACHABLE, unreachable) +#define FOREACH_EXPR_TYPE(V) \ + V(WabtExprType::Binary, binary) \ + V(WabtExprType::Block, block) \ + V(WabtExprType::Br, br) \ + V(WabtExprType::BrIf, br_if) \ + V(WabtExprType::BrTable, br_table) \ + V(WabtExprType::Call, call) \ + V(WabtExprType::CallIndirect, call_indirect) \ + V(WabtExprType::Compare, compare) \ + V(WabtExprType::Const, const) \ + V(WabtExprType::Convert, convert) \ + V(WabtExprType::GetGlobal, get_global) \ + V(WabtExprType::GetLocal, get_local) \ + V(WabtExprType::If, if) \ + V(WabtExprType::Load, load) \ + V(WabtExprType::Loop, loop) \ + V(WabtExprType::SetGlobal, set_global) \ + V(WabtExprType::SetLocal, set_local) \ + V(WabtExprType::Store, store) \ + V(WabtExprType::TeeLocal, tee_local) \ + V(WabtExprType::Unary, unary) \ + V(WabtExprType::CurrentMemory, current_memory) \ + V(WabtExprType::Drop, drop) \ + V(WabtExprType::GrowMemory, grow_memory) \ + V(WabtExprType::Nop, nop) \ + V(WabtExprType::Return, return ) \ + V(WabtExprType::Select, select) \ + V(WabtExprType::Unreachable, unreachable) #define DEFINE_NEW_EXPR(type_, name) \ WabtExpr* wabt_new_##name##_expr(void) { \ @@ -262,7 +262,7 @@ FOREACH_EXPR_TYPE(DEFINE_NEW_EXPR) #undef DEFINE_NEW_EXPR void wabt_destroy_var(WabtVar* var) { - if (var->type == WABT_VAR_TYPE_NAME) + if (var->type == WabtVarType::Name) wabt_destroy_string_slice(&var->name); } @@ -292,62 +292,62 @@ void wabt_destroy_block(WabtBlock* block) { void wabt_destroy_expr(WabtExpr* expr) { switch (expr->type) { - case WABT_EXPR_TYPE_BLOCK: + case WabtExprType::Block: wabt_destroy_block(&expr->block); break; - case WABT_EXPR_TYPE_BR: + case WabtExprType::Br: wabt_destroy_var(&expr->br.var); break; - case WABT_EXPR_TYPE_BR_IF: + case WabtExprType::BrIf: wabt_destroy_var(&expr->br_if.var); break; - case WABT_EXPR_TYPE_BR_TABLE: + case WabtExprType::BrTable: WABT_DESTROY_VECTOR_AND_ELEMENTS(expr->br_table.targets, var); wabt_destroy_var(&expr->br_table.default_target); break; - case WABT_EXPR_TYPE_CALL: + case WabtExprType::Call: wabt_destroy_var(&expr->call.var); break; - case WABT_EXPR_TYPE_CALL_INDIRECT: + case WabtExprType::CallIndirect: wabt_destroy_var(&expr->call_indirect.var); break; - case WABT_EXPR_TYPE_GET_GLOBAL: + case WabtExprType::GetGlobal: wabt_destroy_var(&expr->get_global.var); break; - case WABT_EXPR_TYPE_GET_LOCAL: + case WabtExprType::GetLocal: wabt_destroy_var(&expr->get_local.var); break; - case WABT_EXPR_TYPE_IF: + case WabtExprType::If: wabt_destroy_block(&expr->if_.true_); wabt_destroy_expr_list(expr->if_.false_); break; - case WABT_EXPR_TYPE_LOOP: + case WabtExprType::Loop: wabt_destroy_block(&expr->loop); break; - case WABT_EXPR_TYPE_SET_GLOBAL: + case WabtExprType::SetGlobal: wabt_destroy_var(&expr->set_global.var); break; - case WABT_EXPR_TYPE_SET_LOCAL: + case WabtExprType::SetLocal: wabt_destroy_var(&expr->set_local.var); break; - case WABT_EXPR_TYPE_TEE_LOCAL: + case WabtExprType::TeeLocal: wabt_destroy_var(&expr->tee_local.var); break; - case WABT_EXPR_TYPE_BINARY: - case WABT_EXPR_TYPE_COMPARE: - case WABT_EXPR_TYPE_CONST: - case WABT_EXPR_TYPE_CONVERT: - case WABT_EXPR_TYPE_DROP: - case WABT_EXPR_TYPE_CURRENT_MEMORY: - case WABT_EXPR_TYPE_GROW_MEMORY: - case WABT_EXPR_TYPE_LOAD: - case WABT_EXPR_TYPE_NOP: - case WABT_EXPR_TYPE_RETURN: - case WABT_EXPR_TYPE_SELECT: - case WABT_EXPR_TYPE_STORE: - case WABT_EXPR_TYPE_UNARY: - case WABT_EXPR_TYPE_UNREACHABLE: + case WabtExprType::Binary: + case WabtExprType::Compare: + case WabtExprType::Const: + case WabtExprType::Convert: + case WabtExprType::Drop: + case WabtExprType::CurrentMemory: + case WabtExprType::GrowMemory: + case WabtExprType::Load: + case WabtExprType::Nop: + case WabtExprType::Return: + case WabtExprType::Select: + case WabtExprType::Store: + case WabtExprType::Unary: + case WabtExprType::Unreachable: break; } wabt_free(expr); @@ -377,21 +377,18 @@ void wabt_destroy_import(WabtImport* import) { wabt_destroy_string_slice(&import->module_name); wabt_destroy_string_slice(&import->field_name); switch (import->kind) { - case WABT_EXTERNAL_KIND_FUNC: + case WabtExternalKind::Func: wabt_destroy_func(&import->func); break; - case WABT_EXTERNAL_KIND_TABLE: + case WabtExternalKind::Table: wabt_destroy_table(&import->table); break; - case WABT_EXTERNAL_KIND_MEMORY: + case WabtExternalKind::Memory: wabt_destroy_memory(&import->memory); break; - case WABT_EXTERNAL_KIND_GLOBAL: + case WabtExternalKind::Global: wabt_destroy_global(&import->global); break; - case WABT_NUM_EXTERNAL_KINDS: - assert(0); - break; } } @@ -421,34 +418,34 @@ void wabt_destroy_table(WabtTable* table) { static void destroy_module_field(WabtModuleField* field) { switch (field->type) { - case WABT_MODULE_FIELD_TYPE_FUNC: + case WabtModuleFieldType::Func: wabt_destroy_func(&field->func); break; - case WABT_MODULE_FIELD_TYPE_GLOBAL: + case WabtModuleFieldType::Global: wabt_destroy_global(&field->global); break; - case WABT_MODULE_FIELD_TYPE_IMPORT: + case WabtModuleFieldType::Import: wabt_destroy_import(&field->import); break; - case WABT_MODULE_FIELD_TYPE_EXPORT: + case WabtModuleFieldType::Export: wabt_destroy_export(&field->export_); break; - case WABT_MODULE_FIELD_TYPE_FUNC_TYPE: + case WabtModuleFieldType::FuncType: wabt_destroy_func_type(&field->func_type); break; - case WABT_MODULE_FIELD_TYPE_TABLE: + case WabtModuleFieldType::Table: wabt_destroy_table(&field->table); break; - case WABT_MODULE_FIELD_TYPE_ELEM_SEGMENT: + case WabtModuleFieldType::ElemSegment: wabt_destroy_elem_segment(&field->elem_segment); break; - case WABT_MODULE_FIELD_TYPE_MEMORY: + case WabtModuleFieldType::Memory: wabt_destroy_memory(&field->memory); break; - case WABT_MODULE_FIELD_TYPE_DATA_SEGMENT: + case WabtModuleFieldType::DataSegment: wabt_destroy_data_segment(&field->data_segment); break; - case WABT_MODULE_FIELD_TYPE_START: + case WabtModuleFieldType::Start: wabt_destroy_var(&field->start); break; } @@ -485,7 +482,7 @@ void wabt_destroy_module(WabtModule* module) { } void wabt_destroy_raw_module(WabtRawModule* raw) { - if (raw->type == WABT_RAW_MODULE_TYPE_TEXT) { + if (raw->type == WabtRawModuleType::Text) { wabt_destroy_module(raw->text); wabt_free(raw->text); } else { @@ -497,11 +494,11 @@ void wabt_destroy_raw_module(WabtRawModule* raw) { void wabt_destroy_action(WabtAction* action) { wabt_destroy_var(&action->module_var); switch (action->type) { - case WABT_ACTION_TYPE_INVOKE: + case WabtActionType::Invoke: wabt_destroy_string_slice(&action->invoke.name); wabt_destroy_const_vector(&action->invoke.args); break; - case WABT_ACTION_TYPE_GET: + case WabtActionType::Get: wabt_destroy_string_slice(&action->get.name); break; } @@ -509,48 +506,45 @@ void wabt_destroy_action(WabtAction* action) { void wabt_destroy_command(WabtCommand* command) { switch (command->type) { - case WABT_COMMAND_TYPE_MODULE: + case WabtCommandType::Module: wabt_destroy_module(&command->module); break; - case WABT_COMMAND_TYPE_ACTION: + case WabtCommandType::Action: wabt_destroy_action(&command->action); break; - case WABT_COMMAND_TYPE_REGISTER: + case WabtCommandType::Register: wabt_destroy_string_slice(&command->register_.module_name); wabt_destroy_var(&command->register_.var); break; - case WABT_COMMAND_TYPE_ASSERT_MALFORMED: + case WabtCommandType::AssertMalformed: wabt_destroy_raw_module(&command->assert_malformed.module); wabt_destroy_string_slice(&command->assert_malformed.text); break; - case WABT_COMMAND_TYPE_ASSERT_INVALID: - case WABT_COMMAND_TYPE_ASSERT_INVALID_NON_BINARY: + case WabtCommandType::AssertInvalid: + case WabtCommandType::AssertInvalidNonBinary: wabt_destroy_raw_module(&command->assert_invalid.module); wabt_destroy_string_slice(&command->assert_invalid.text); break; - case WABT_COMMAND_TYPE_ASSERT_UNLINKABLE: + case WabtCommandType::AssertUnlinkable: wabt_destroy_raw_module(&command->assert_unlinkable.module); wabt_destroy_string_slice(&command->assert_unlinkable.text); break; - case WABT_COMMAND_TYPE_ASSERT_UNINSTANTIABLE: + case WabtCommandType::AssertUninstantiable: wabt_destroy_raw_module(&command->assert_uninstantiable.module); wabt_destroy_string_slice(&command->assert_uninstantiable.text); break; - case WABT_COMMAND_TYPE_ASSERT_RETURN: + case WabtCommandType::AssertReturn: wabt_destroy_action(&command->assert_return.action); wabt_destroy_const_vector(&command->assert_return.expected); break; - case WABT_COMMAND_TYPE_ASSERT_RETURN_NAN: + case WabtCommandType::AssertReturnNan: wabt_destroy_action(&command->assert_return_nan.action); break; - case WABT_COMMAND_TYPE_ASSERT_TRAP: - case WABT_COMMAND_TYPE_ASSERT_EXHAUSTION: + case WabtCommandType::AssertTrap: + case WabtCommandType::AssertExhaustion: wabt_destroy_action(&command->assert_trap.action); wabt_destroy_string_slice(&command->assert_trap.text); break; - case WABT_NUM_COMMAND_TYPES: - assert(0); - break; } } @@ -569,16 +563,16 @@ void wabt_destroy_script(WabtScript* script) { wabt_destroy_binding_hash(&script->module_bindings); } -#define CHECK_RESULT(expr) \ - do { \ - if (WABT_FAILED((expr))) \ - return WABT_ERROR; \ +#define CHECK_RESULT(expr) \ + do { \ + if (WABT_FAILED((expr))) \ + return WabtResult::Error; \ } while (0) #define CALLBACK(member) \ CHECK_RESULT((visitor)->member \ ? (visitor)->member(expr, (visitor)->user_data) \ - : WABT_OK) + : WabtResult::Ok) static WabtResult visit_expr(WabtExpr* expr, WabtExprVisitor* visitor); @@ -586,74 +580,74 @@ WabtResult wabt_visit_expr_list(WabtExpr* first, WabtExprVisitor* visitor) { WabtExpr* expr; for (expr = first; expr; expr = expr->next) CHECK_RESULT(visit_expr(expr, visitor)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult visit_expr(WabtExpr* expr, WabtExprVisitor* visitor) { switch (expr->type) { - case WABT_EXPR_TYPE_BINARY: + case WabtExprType::Binary: CALLBACK(on_binary_expr); break; - case WABT_EXPR_TYPE_BLOCK: + case WabtExprType::Block: CALLBACK(begin_block_expr); CHECK_RESULT(wabt_visit_expr_list(expr->block.first, visitor)); CALLBACK(end_block_expr); break; - case WABT_EXPR_TYPE_BR: + case WabtExprType::Br: CALLBACK(on_br_expr); break; - case WABT_EXPR_TYPE_BR_IF: + case WabtExprType::BrIf: CALLBACK(on_br_if_expr); break; - case WABT_EXPR_TYPE_BR_TABLE: + case WabtExprType::BrTable: CALLBACK(on_br_table_expr); break; - case WABT_EXPR_TYPE_CALL: + case WabtExprType::Call: CALLBACK(on_call_expr); break; - case WABT_EXPR_TYPE_CALL_INDIRECT: + case WabtExprType::CallIndirect: CALLBACK(on_call_indirect_expr); break; - case WABT_EXPR_TYPE_COMPARE: + case WabtExprType::Compare: CALLBACK(on_compare_expr); break; - case WABT_EXPR_TYPE_CONST: + case WabtExprType::Const: CALLBACK(on_const_expr); break; - case WABT_EXPR_TYPE_CONVERT: + case WabtExprType::Convert: CALLBACK(on_convert_expr); break; - case WABT_EXPR_TYPE_CURRENT_MEMORY: + case WabtExprType::CurrentMemory: CALLBACK(on_current_memory_expr); break; - case WABT_EXPR_TYPE_DROP: + case WabtExprType::Drop: CALLBACK(on_drop_expr); break; - case WABT_EXPR_TYPE_GET_GLOBAL: + case WabtExprType::GetGlobal: CALLBACK(on_get_global_expr); break; - case WABT_EXPR_TYPE_GET_LOCAL: + case WabtExprType::GetLocal: CALLBACK(on_get_local_expr); break; - case WABT_EXPR_TYPE_GROW_MEMORY: + case WabtExprType::GrowMemory: CALLBACK(on_grow_memory_expr); break; - case WABT_EXPR_TYPE_IF: + case WabtExprType::If: CALLBACK(begin_if_expr); CHECK_RESULT(wabt_visit_expr_list(expr->if_.true_.first, visitor)); CALLBACK(after_if_true_expr); @@ -661,54 +655,54 @@ static WabtResult visit_expr(WabtExpr* expr, WabtExprVisitor* visitor) { CALLBACK(end_if_expr); break; - case WABT_EXPR_TYPE_LOAD: + case WabtExprType::Load: CALLBACK(on_load_expr); break; - case WABT_EXPR_TYPE_LOOP: + case WabtExprType::Loop: CALLBACK(begin_loop_expr); CHECK_RESULT(wabt_visit_expr_list(expr->loop.first, visitor)); CALLBACK(end_loop_expr); break; - case WABT_EXPR_TYPE_NOP: + case WabtExprType::Nop: CALLBACK(on_nop_expr); break; - case WABT_EXPR_TYPE_RETURN: + case WabtExprType::Return: CALLBACK(on_return_expr); break; - case WABT_EXPR_TYPE_SELECT: + case WabtExprType::Select: CALLBACK(on_select_expr); break; - case WABT_EXPR_TYPE_SET_GLOBAL: + case WabtExprType::SetGlobal: CALLBACK(on_set_global_expr); break; - case WABT_EXPR_TYPE_SET_LOCAL: + case WabtExprType::SetLocal: CALLBACK(on_set_local_expr); break; - case WABT_EXPR_TYPE_STORE: + case WabtExprType::Store: CALLBACK(on_store_expr); break; - case WABT_EXPR_TYPE_TEE_LOCAL: + case WabtExprType::TeeLocal: CALLBACK(on_tee_local_expr); break; - case WABT_EXPR_TYPE_UNARY: + case WabtExprType::Unary: CALLBACK(on_unary_expr); break; - case WABT_EXPR_TYPE_UNREACHABLE: + case WabtExprType::Unreachable: CALLBACK(on_unreachable_expr); break; } - return WABT_OK; + return WabtResult::Ok; } /* TODO(binji): make the visitor non-recursive */ @@ -26,9 +26,9 @@ #include "type-vector.h" #include "vector.h" -enum WabtVarType { - WABT_VAR_TYPE_INDEX, - WABT_VAR_TYPE_NAME, +enum class WabtVarType { + Index, + Name, }; struct WabtVar { @@ -56,34 +56,34 @@ struct WabtConst { }; WABT_DEFINE_VECTOR(const, WabtConst); -enum WabtExprType { - WABT_EXPR_TYPE_BINARY, - WABT_EXPR_TYPE_BLOCK, - WABT_EXPR_TYPE_BR, - WABT_EXPR_TYPE_BR_IF, - WABT_EXPR_TYPE_BR_TABLE, - WABT_EXPR_TYPE_CALL, - WABT_EXPR_TYPE_CALL_INDIRECT, - WABT_EXPR_TYPE_COMPARE, - WABT_EXPR_TYPE_CONST, - WABT_EXPR_TYPE_CONVERT, - WABT_EXPR_TYPE_CURRENT_MEMORY, - WABT_EXPR_TYPE_DROP, - WABT_EXPR_TYPE_GET_GLOBAL, - WABT_EXPR_TYPE_GET_LOCAL, - WABT_EXPR_TYPE_GROW_MEMORY, - WABT_EXPR_TYPE_IF, - WABT_EXPR_TYPE_LOAD, - WABT_EXPR_TYPE_LOOP, - WABT_EXPR_TYPE_NOP, - WABT_EXPR_TYPE_RETURN, - WABT_EXPR_TYPE_SELECT, - WABT_EXPR_TYPE_SET_GLOBAL, - WABT_EXPR_TYPE_SET_LOCAL, - WABT_EXPR_TYPE_STORE, - WABT_EXPR_TYPE_TEE_LOCAL, - WABT_EXPR_TYPE_UNARY, - WABT_EXPR_TYPE_UNREACHABLE, +enum class WabtExprType { + Binary, + Block, + Br, + BrIf, + BrTable, + Call, + CallIndirect, + Compare, + Const, + Convert, + CurrentMemory, + Drop, + GetGlobal, + GetLocal, + GrowMemory, + If, + Load, + Loop, + Nop, + Return, + Select, + SetGlobal, + SetLocal, + Store, + TeeLocal, + Unary, + Unreachable, }; typedef WabtTypeVector WabtBlockSignature; @@ -213,17 +213,17 @@ struct WabtExport { typedef WabtExport* WabtExportPtr; WABT_DEFINE_VECTOR(export_ptr, WabtExportPtr); -enum WabtModuleFieldType { - WABT_MODULE_FIELD_TYPE_FUNC, - WABT_MODULE_FIELD_TYPE_GLOBAL, - WABT_MODULE_FIELD_TYPE_IMPORT, - WABT_MODULE_FIELD_TYPE_EXPORT, - WABT_MODULE_FIELD_TYPE_FUNC_TYPE, - WABT_MODULE_FIELD_TYPE_TABLE, - WABT_MODULE_FIELD_TYPE_ELEM_SEGMENT, - WABT_MODULE_FIELD_TYPE_MEMORY, - WABT_MODULE_FIELD_TYPE_DATA_SEGMENT, - WABT_MODULE_FIELD_TYPE_START, +enum class WabtModuleFieldType { + Func, + Global, + Import, + Export, + FuncType, + Table, + ElemSegment, + Memory, + DataSegment, + Start, }; struct WabtModuleField { @@ -276,9 +276,9 @@ struct WabtModule { WabtBindingHash memory_bindings; }; -enum WabtRawModuleType { - WABT_RAW_MODULE_TYPE_TEXT, - WABT_RAW_MODULE_TYPE_BINARY, +enum class WabtRawModuleType { + Text, + Binary, }; /* "raw" means that the binary module has not yet been decoded. This is only @@ -299,9 +299,9 @@ struct WabtRawModule { }; }; -enum WabtActionType { - WABT_ACTION_TYPE_INVOKE, - WABT_ACTION_TYPE_GET, +enum class WabtActionType { + Invoke, + Get, }; struct WabtActionInvoke { @@ -323,23 +323,26 @@ struct WabtAction { }; }; -enum WabtCommandType { - WABT_COMMAND_TYPE_MODULE, - WABT_COMMAND_TYPE_ACTION, - WABT_COMMAND_TYPE_REGISTER, - WABT_COMMAND_TYPE_ASSERT_MALFORMED, - WABT_COMMAND_TYPE_ASSERT_INVALID, +enum class WabtCommandType { + Module, + Action, + Register, + AssertMalformed, + AssertInvalid, /* This is a module that is invalid, but cannot be written as a binary module * (e.g. it has unresolvable names.) */ - WABT_COMMAND_TYPE_ASSERT_INVALID_NON_BINARY, - WABT_COMMAND_TYPE_ASSERT_UNLINKABLE, - WABT_COMMAND_TYPE_ASSERT_UNINSTANTIABLE, - WABT_COMMAND_TYPE_ASSERT_RETURN, - WABT_COMMAND_TYPE_ASSERT_RETURN_NAN, - WABT_COMMAND_TYPE_ASSERT_TRAP, - WABT_COMMAND_TYPE_ASSERT_EXHAUSTION, - WABT_NUM_COMMAND_TYPES, + AssertInvalidNonBinary, + AssertUnlinkable, + AssertUninstantiable, + AssertReturn, + AssertReturnNan, + AssertTrap, + AssertExhaustion, + + First = Module, + Last = AssertExhaustion, }; +static const int kWabtCommandTypeCount = WABT_ENUM_COUNT(WabtCommandType); struct WabtCommand { WabtCommandType type; @@ -580,8 +583,8 @@ wabt_get_func_type_num_results(const WabtFuncType* func_type) { static WABT_INLINE const WabtLocation* wabt_get_raw_module_location( const WabtRawModule* raw) { switch (raw->type) { - case WABT_RAW_MODULE_TYPE_BINARY: return &raw->binary.loc; - case WABT_RAW_MODULE_TYPE_TEXT: return &raw->text->loc; + case WabtRawModuleType::Binary: return &raw->binary.loc; + case WabtRawModuleType::Text: return &raw->text->loc; default: assert(0); return nullptr; diff --git a/src/binary-reader-ast.cc b/src/binary-reader-ast.cc index c159bfc5..eb219510 100644 --- a/src/binary-reader-ast.cc +++ b/src/binary-reader-ast.cc @@ -29,7 +29,7 @@ #define CHECK_RESULT(expr) \ do { \ if (WABT_FAILED(expr)) \ - return WABT_ERROR; \ + return WabtResult::Error; \ } while (0) struct LabelNode { @@ -71,12 +71,12 @@ static void push_label(Context* ctx, static WabtResult pop_label(Context* ctx) { if (ctx->label_stack.size == 0) { print_error(ctx, "popping empty label stack"); - return WABT_ERROR; + return WabtResult::Error; } ctx->max_depth--; ctx->label_stack.size--; - return WABT_OK; + return WabtResult::Ok; } static WabtResult get_label_at(Context* ctx, @@ -85,11 +85,11 @@ static WabtResult get_label_at(Context* ctx, if (depth >= ctx->label_stack.size) { print_error(ctx, "accessing stack depth: %u >= max: %" PRIzd, depth, ctx->label_stack.size); - return WABT_ERROR; + return WabtResult::Error; } *label = &ctx->label_stack.data[ctx->label_stack.size - depth - 1]; - return WABT_OK; + return WabtResult::Ok; } static WabtResult top_label(Context* ctx, LabelNode** label) { @@ -110,7 +110,7 @@ static WabtResult append_expr(Context* ctx, WabtExpr* expr) { LabelNode* label; if (WABT_FAILED(top_label(ctx, &label))) { wabt_free(expr); - return WABT_ERROR; + return WabtResult::Error; } if (*label->first) { label->last->next = expr; @@ -118,7 +118,7 @@ static WabtResult append_expr(Context* ctx, WabtExpr* expr) { } else { *label->first = label->last = expr; } - return WABT_OK; + return WabtResult::Ok; } static void handle_error(Context* ctx, uint32_t offset, const char* message) { @@ -137,7 +137,7 @@ static void on_error(WabtBinaryReaderContext* reader_context, static WabtResult on_signature_count(uint32_t count, void* user_data) { Context* ctx = static_cast<Context*>(user_data); wabt_reserve_func_type_ptrs(&ctx->module->func_types, count); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_signature(uint32_t index, @@ -148,7 +148,7 @@ static WabtResult on_signature(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtModuleField* field = wabt_append_module_field(ctx->module); - field->type = WABT_MODULE_FIELD_TYPE_FUNC_TYPE; + field->type = WabtModuleFieldType::FuncType; WabtFuncType* func_type = &field->func_type; WABT_ZERO_MEMORY(*func_type); @@ -167,13 +167,13 @@ static WabtResult on_signature(uint32_t index, WabtFuncTypePtr* func_type_ptr = wabt_append_func_type_ptr(&ctx->module->func_types); *func_type_ptr = func_type; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import_count(uint32_t count, void* user_data) { Context* ctx = static_cast<Context*>(user_data); wabt_reserve_import_ptrs(&ctx->module->imports, count); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import(uint32_t index, @@ -184,7 +184,7 @@ static WabtResult on_import(uint32_t index, assert(index < ctx->module->imports.capacity); WabtModuleField* field = wabt_append_module_field(ctx->module); - field->type = WABT_MODULE_FIELD_TYPE_IMPORT; + field->type = WabtModuleFieldType::Import; WabtImport* import = &field->import; WABT_ZERO_MEMORY(*import); @@ -193,7 +193,7 @@ static WabtResult on_import(uint32_t index, WabtImportPtr* import_ptr = wabt_append_import_ptr(&ctx->module->imports); *import_ptr = import; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import_func(uint32_t import_index, @@ -205,17 +205,17 @@ static WabtResult on_import_func(uint32_t import_index, assert(sig_index < ctx->module->func_types.size); WabtImport* import = ctx->module->imports.data[import_index]; - import->kind = WABT_EXTERNAL_KIND_FUNC; + import->kind = WabtExternalKind::Func; import->func.decl.flags = WABT_FUNC_DECLARATION_FLAG_HAS_FUNC_TYPE | WABT_FUNC_DECLARATION_FLAG_SHARED_SIGNATURE; - import->func.decl.type_var.type = WABT_VAR_TYPE_INDEX; + import->func.decl.type_var.type = WabtVarType::Index; import->func.decl.type_var.index = sig_index; import->func.decl.sig = ctx->module->func_types.data[sig_index]->sig; WabtFuncPtr func_ptr = &import->func; wabt_append_func_ptr_value(&ctx->module->funcs, &func_ptr); ctx->module->num_func_imports++; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import_table(uint32_t import_index, @@ -226,13 +226,13 @@ static WabtResult on_import_table(uint32_t import_index, Context* ctx = static_cast<Context*>(user_data); assert(import_index == ctx->module->imports.size - 1); WabtImport* import = ctx->module->imports.data[import_index]; - import->kind = WABT_EXTERNAL_KIND_TABLE; + import->kind = WabtExternalKind::Table; import->table.elem_limits = *elem_limits; WabtTablePtr table_ptr = &import->table; wabt_append_table_ptr_value(&ctx->module->tables, &table_ptr); ctx->module->num_table_imports++; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import_memory(uint32_t import_index, @@ -242,13 +242,13 @@ static WabtResult on_import_memory(uint32_t import_index, Context* ctx = static_cast<Context*>(user_data); assert(import_index == ctx->module->imports.size - 1); WabtImport* import = ctx->module->imports.data[import_index]; - import->kind = WABT_EXTERNAL_KIND_MEMORY; + import->kind = WabtExternalKind::Memory; import->memory.page_limits = *page_limits; WabtMemoryPtr memory_ptr = &import->memory; wabt_append_memory_ptr_value(&ctx->module->memories, &memory_ptr); ctx->module->num_memory_imports++; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import_global(uint32_t import_index, @@ -259,14 +259,14 @@ static WabtResult on_import_global(uint32_t import_index, Context* ctx = static_cast<Context*>(user_data); assert(import_index == ctx->module->imports.size - 1); WabtImport* import = ctx->module->imports.data[import_index]; - import->kind = WABT_EXTERNAL_KIND_GLOBAL; + import->kind = WabtExternalKind::Global; import->global.type = type; import->global.mutable_ = mutable_; WabtGlobalPtr global_ptr = &import->global; wabt_append_global_ptr_value(&ctx->module->globals, &global_ptr); ctx->module->num_global_imports++; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_function_signatures_count(uint32_t count, @@ -274,7 +274,7 @@ static WabtResult on_function_signatures_count(uint32_t count, Context* ctx = static_cast<Context*>(user_data); wabt_reserve_func_ptrs(&ctx->module->funcs, ctx->module->num_func_imports + count); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_function_signature(uint32_t index, @@ -285,26 +285,26 @@ static WabtResult on_function_signature(uint32_t index, assert(sig_index < ctx->module->func_types.size); WabtModuleField* field = wabt_append_module_field(ctx->module); - field->type = WABT_MODULE_FIELD_TYPE_FUNC; + field->type = WabtModuleFieldType::Func; WabtFunc* func = &field->func; WABT_ZERO_MEMORY(*func); func->decl.flags = WABT_FUNC_DECLARATION_FLAG_HAS_FUNC_TYPE | WABT_FUNC_DECLARATION_FLAG_SHARED_SIGNATURE; - func->decl.type_var.type = WABT_VAR_TYPE_INDEX; + func->decl.type_var.type = WabtVarType::Index; func->decl.type_var.index = sig_index; func->decl.sig = ctx->module->func_types.data[sig_index]->sig; WabtFuncPtr* func_ptr = wabt_append_func_ptr(&ctx->module->funcs); *func_ptr = func; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_table_count(uint32_t count, void* user_data) { Context* ctx = static_cast<Context*>(user_data); wabt_reserve_table_ptrs(&ctx->module->tables, ctx->module->num_table_imports + count); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_table(uint32_t index, @@ -315,7 +315,7 @@ static WabtResult on_table(uint32_t index, assert(index < ctx->module->tables.capacity); WabtModuleField* field = wabt_append_module_field(ctx->module); - field->type = WABT_MODULE_FIELD_TYPE_TABLE; + field->type = WabtModuleFieldType::Table; WabtTable* table = &field->table; WABT_ZERO_MEMORY(*table); @@ -323,14 +323,14 @@ static WabtResult on_table(uint32_t index, WabtTablePtr* table_ptr = wabt_append_table_ptr(&ctx->module->tables); *table_ptr = table; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_memory_count(uint32_t count, void* user_data) { Context* ctx = static_cast<Context*>(user_data); wabt_reserve_memory_ptrs(&ctx->module->memories, ctx->module->num_memory_imports + count); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_memory(uint32_t index, @@ -340,7 +340,7 @@ static WabtResult on_memory(uint32_t index, assert(index < ctx->module->memories.capacity); WabtModuleField* field = wabt_append_module_field(ctx->module); - field->type = WABT_MODULE_FIELD_TYPE_MEMORY; + field->type = WabtModuleFieldType::Memory; WabtMemory* memory = &field->memory; WABT_ZERO_MEMORY(*memory); @@ -348,14 +348,14 @@ static WabtResult on_memory(uint32_t index, WabtMemoryPtr* memory_ptr = wabt_append_memory_ptr(&ctx->module->memories); *memory_ptr = memory; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_global_count(uint32_t count, void* user_data) { Context* ctx = static_cast<Context*>(user_data); wabt_reserve_global_ptrs(&ctx->module->globals, ctx->module->num_global_imports + count); - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_global(uint32_t index, @@ -366,7 +366,7 @@ static WabtResult begin_global(uint32_t index, assert(index < ctx->module->globals.capacity); WabtModuleField* field = wabt_append_module_field(ctx->module); - field->type = WABT_MODULE_FIELD_TYPE_GLOBAL; + field->type = WabtModuleFieldType::Global; WabtGlobal* global = &field->global; WABT_ZERO_MEMORY(*global); @@ -375,7 +375,7 @@ static WabtResult begin_global(uint32_t index, WabtGlobalPtr* global_ptr = wabt_append_global_ptr(&ctx->module->globals); *global_ptr = global; - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_global_init_expr(uint32_t index, void* user_data) { @@ -383,19 +383,19 @@ static WabtResult begin_global_init_expr(uint32_t index, void* user_data) { assert(index == ctx->module->globals.size - 1); WabtGlobal* global = ctx->module->globals.data[index]; ctx->current_init_expr = &global->init_expr; - return WABT_OK; + return WabtResult::Ok; } static WabtResult end_global_init_expr(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); ctx->current_init_expr = nullptr; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_export_count(uint32_t count, void* user_data) { Context* ctx = static_cast<Context*>(user_data); wabt_reserve_export_ptrs(&ctx->module->exports, count); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_export(uint32_t index, @@ -405,56 +405,53 @@ static WabtResult on_export(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtModuleField* field = wabt_append_module_field(ctx->module); - field->type = WABT_MODULE_FIELD_TYPE_EXPORT; + field->type = WabtModuleFieldType::Export; WabtExport* export_ = &field->export_; WABT_ZERO_MEMORY(*export_); export_->name = wabt_dup_string_slice(name); switch (kind) { - case WABT_EXTERNAL_KIND_FUNC: + case WabtExternalKind::Func: assert(item_index < ctx->module->funcs.size); break; - case WABT_EXTERNAL_KIND_TABLE: + case WabtExternalKind::Table: assert(item_index < ctx->module->tables.size); break; - case WABT_EXTERNAL_KIND_MEMORY: + case WabtExternalKind::Memory: assert(item_index < ctx->module->memories.size); break; - case WABT_EXTERNAL_KIND_GLOBAL: + case WabtExternalKind::Global: assert(item_index < ctx->module->globals.size); break; - case WABT_NUM_EXTERNAL_KINDS: - assert(0); - break; } - export_->var.type = WABT_VAR_TYPE_INDEX; + export_->var.type = WabtVarType::Index; export_->var.index = item_index; export_->kind = kind; assert(index < ctx->module->exports.capacity); WabtExportPtr* export_ptr = wabt_append_export_ptr(&ctx->module->exports); *export_ptr = export_; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_start_function(uint32_t func_index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtModuleField* field = wabt_append_module_field(ctx->module); - field->type = WABT_MODULE_FIELD_TYPE_START; + field->type = WabtModuleFieldType::Start; - field->start.type = WABT_VAR_TYPE_INDEX; + field->start.type = WabtVarType::Index; assert(func_index < ctx->module->funcs.size); field->start.index = func_index; ctx->module->start = &field->start; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_function_bodies_count(uint32_t count, void* user_data) { Context* ctx = static_cast<Context*>(user_data); assert(ctx->module->num_func_imports + count == ctx->module->funcs.size); WABT_USE(ctx); - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_function_body(WabtBinaryReaderContext* context, @@ -462,8 +459,8 @@ static WabtResult begin_function_body(WabtBinaryReaderContext* context, Context* ctx = static_cast<Context*>(context->user_data); assert(index < ctx->module->funcs.size); ctx->current_func = ctx->module->funcs.data[index]; - push_label(ctx, WABT_LABEL_TYPE_FUNC, &ctx->current_func->first_expr); - return WABT_OK; + push_label(ctx, WabtLabelType::Func, &ctx->current_func->first_expr); + return WabtResult::Ok; } static WabtResult on_local_decl(uint32_t decl_index, @@ -479,7 +476,7 @@ static WabtResult on_local_decl(uint32_t decl_index, for (i = 0; i < count; ++i) types->data[old_local_count + i] = type; types->size = new_local_count; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_binary_expr(WabtOpcode opcode, void* user_data) { @@ -500,14 +497,14 @@ static WabtResult on_block_expr(uint32_t num_types, src.data = sig_types; wabt_extend_types(&expr->block.sig, &src); append_expr(ctx, expr); - push_label(ctx, WABT_LABEL_TYPE_BLOCK, &expr->block.first); - return WABT_OK; + push_label(ctx, WabtLabelType::Block, &expr->block.first); + return WabtResult::Ok; } static WabtResult on_br_expr(uint32_t depth, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtExpr* expr = wabt_new_br_expr(); - expr->br.var.type = WABT_VAR_TYPE_INDEX; + expr->br.var.type = WabtVarType::Index; expr->br.var.index = depth; return append_expr(ctx, expr); } @@ -515,7 +512,7 @@ static WabtResult on_br_expr(uint32_t depth, void* user_data) { static WabtResult on_br_if_expr(uint32_t depth, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtExpr* expr = wabt_new_br_if_expr(); - expr->br_if.var.type = WABT_VAR_TYPE_INDEX; + expr->br_if.var.type = WabtVarType::Index; expr->br_if.var.index = depth; return append_expr(ctx, expr); } @@ -531,10 +528,10 @@ static WabtResult on_br_table_expr(WabtBinaryReaderContext* context, uint32_t i; for (i = 0; i < num_targets; ++i) { WabtVar* var = &expr->br_table.targets.data[i]; - var->type = WABT_VAR_TYPE_INDEX; + var->type = WabtVarType::Index; var->index = target_depths[i]; } - expr->br_table.default_target.type = WABT_VAR_TYPE_INDEX; + expr->br_table.default_target.type = WabtVarType::Index; expr->br_table.default_target.index = default_target_depth; return append_expr(ctx, expr); } @@ -543,7 +540,7 @@ static WabtResult on_call_expr(uint32_t func_index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); assert(func_index < ctx->module->funcs.size); WabtExpr* expr = wabt_new_call_expr(); - expr->call.var.type = WABT_VAR_TYPE_INDEX; + expr->call.var.type = WabtVarType::Index; expr->call.var.index = func_index; return append_expr(ctx, expr); } @@ -552,7 +549,7 @@ static WabtResult on_call_indirect_expr(uint32_t sig_index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); assert(sig_index < ctx->module->func_types.size); WabtExpr* expr = wabt_new_call_indirect_expr(); - expr->call_indirect.var.type = WABT_VAR_TYPE_INDEX; + expr->call_indirect.var.type = WabtVarType::Index; expr->call_indirect.var.index = sig_index; return append_expr(ctx, expr); } @@ -587,19 +584,19 @@ static WabtResult on_else_expr(void* user_data) { Context* ctx = static_cast<Context*>(user_data); LabelNode* label; CHECK_RESULT(top_label(ctx, &label)); - if (label->label_type != WABT_LABEL_TYPE_IF) { + if (label->label_type != WabtLabelType::If) { print_error(ctx, "else expression without matching if"); - return WABT_ERROR; + return WabtResult::Error; } LabelNode* parent_label; CHECK_RESULT(get_label_at(ctx, &parent_label, 1)); - assert(parent_label->last->type == WABT_EXPR_TYPE_IF); + assert(parent_label->last->type == WabtExprType::If); - label->label_type = WABT_LABEL_TYPE_ELSE; + label->label_type = WabtLabelType::Else; label->first = &parent_label->last->if_.false_; label->last = nullptr; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_end_expr(void* user_data) { @@ -610,7 +607,7 @@ static WabtResult on_end_expr(void* user_data) { static WabtResult on_f32_const_expr(uint32_t value_bits, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtExpr* expr = wabt_new_const_expr(); - expr->const_.type = WABT_TYPE_F32; + expr->const_.type = WabtType::F32; expr->const_.f32_bits = value_bits; return append_expr(ctx, expr); } @@ -618,7 +615,7 @@ static WabtResult on_f32_const_expr(uint32_t value_bits, void* user_data) { static WabtResult on_f64_const_expr(uint64_t value_bits, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtExpr* expr = wabt_new_const_expr(); - expr->const_.type = WABT_TYPE_F64; + expr->const_.type = WabtType::F64; expr->const_.f64_bits = value_bits; return append_expr(ctx, expr); } @@ -626,7 +623,7 @@ static WabtResult on_f64_const_expr(uint64_t value_bits, void* user_data) { static WabtResult on_get_global_expr(uint32_t global_index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtExpr* expr = wabt_new_get_global_expr(); - expr->get_global.var.type = WABT_VAR_TYPE_INDEX; + expr->get_global.var.type = WabtVarType::Index; expr->get_global.var.index = global_index; return append_expr(ctx, expr); } @@ -634,7 +631,7 @@ static WabtResult on_get_global_expr(uint32_t global_index, void* user_data) { static WabtResult on_get_local_expr(uint32_t local_index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtExpr* expr = wabt_new_get_local_expr(); - expr->get_local.var.type = WABT_VAR_TYPE_INDEX; + expr->get_local.var.type = WabtVarType::Index; expr->get_local.var.index = local_index; return append_expr(ctx, expr); } @@ -648,7 +645,7 @@ static WabtResult on_grow_memory_expr(void* user_data) { static WabtResult on_i32_const_expr(uint32_t value, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtExpr* expr = wabt_new_const_expr(); - expr->const_.type = WABT_TYPE_I32; + expr->const_.type = WabtType::I32; expr->const_.u32 = value; return append_expr(ctx, expr); } @@ -656,7 +653,7 @@ static WabtResult on_i32_const_expr(uint32_t value, void* user_data) { static WabtResult on_i64_const_expr(uint64_t value, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtExpr* expr = wabt_new_const_expr(); - expr->const_.type = WABT_TYPE_I64; + expr->const_.type = WabtType::I64; expr->const_.u64 = value; return append_expr(ctx, expr); } @@ -672,8 +669,8 @@ static WabtResult on_if_expr(uint32_t num_types, src.data = sig_types; wabt_extend_types(&expr->if_.true_.sig, &src); append_expr(ctx, expr); - push_label(ctx, WABT_LABEL_TYPE_IF, &expr->if_.true_.first); - return WABT_OK; + push_label(ctx, WabtLabelType::If, &expr->if_.true_.first); + return WabtResult::Ok; } static WabtResult on_load_expr(WabtOpcode opcode, @@ -699,8 +696,8 @@ static WabtResult on_loop_expr(uint32_t num_types, src.data = sig_types; wabt_extend_types(&expr->loop.sig, &src); append_expr(ctx, expr); - push_label(ctx, WABT_LABEL_TYPE_LOOP, &expr->loop.first); - return WABT_OK; + push_label(ctx, WabtLabelType::Loop, &expr->loop.first); + return WabtResult::Ok; } static WabtResult on_nop_expr(void* user_data) { @@ -724,7 +721,7 @@ static WabtResult on_select_expr(void* user_data) { static WabtResult on_set_global_expr(uint32_t global_index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtExpr* expr = wabt_new_set_global_expr(); - expr->set_global.var.type = WABT_VAR_TYPE_INDEX; + expr->set_global.var.type = WabtVarType::Index; expr->set_global.var.index = global_index; return append_expr(ctx, expr); } @@ -732,7 +729,7 @@ static WabtResult on_set_global_expr(uint32_t global_index, void* user_data) { static WabtResult on_set_local_expr(uint32_t local_index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtExpr* expr = wabt_new_set_local_expr(); - expr->set_local.var.type = WABT_VAR_TYPE_INDEX; + expr->set_local.var.type = WabtVarType::Index; expr->set_local.var.index = local_index; return append_expr(ctx, expr); } @@ -752,7 +749,7 @@ static WabtResult on_store_expr(WabtOpcode opcode, static WabtResult on_tee_local_expr(uint32_t local_index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtExpr* expr = wabt_new_tee_local_expr(); - expr->tee_local.var.type = WABT_VAR_TYPE_INDEX; + expr->tee_local.var.type = WabtVarType::Index; expr->tee_local.var.index = local_index; return append_expr(ctx, expr); } @@ -774,14 +771,14 @@ static WabtResult end_function_body(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); CHECK_RESULT(pop_label(ctx)); ctx->current_func = nullptr; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_elem_segment_count(uint32_t count, void* user_data) { Context* ctx = static_cast<Context*>(user_data); wabt_reserve_elem_segment_ptrs(&ctx->module->elem_segments, count); - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_elem_segment(uint32_t index, @@ -789,11 +786,11 @@ static WabtResult begin_elem_segment(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtModuleField* field = wabt_append_module_field(ctx->module); - field->type = WABT_MODULE_FIELD_TYPE_ELEM_SEGMENT; + field->type = WabtModuleFieldType::ElemSegment; WabtElemSegment* segment = &field->elem_segment; WABT_ZERO_MEMORY(*segment); - segment->table_var.type = WABT_VAR_TYPE_INDEX; + segment->table_var.type = WabtVarType::Index; segment->table_var.index = table_index; assert(index == ctx->module->elem_segments.size); @@ -801,7 +798,7 @@ static WabtResult begin_elem_segment(uint32_t index, WabtElemSegmentPtr* segment_ptr = wabt_append_elem_segment_ptr(&ctx->module->elem_segments); *segment_ptr = segment; - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_elem_segment_init_expr(uint32_t index, @@ -810,13 +807,13 @@ static WabtResult begin_elem_segment_init_expr(uint32_t index, assert(index == ctx->module->elem_segments.size - 1); WabtElemSegment* segment = ctx->module->elem_segments.data[index]; ctx->current_init_expr = &segment->offset; - return WABT_OK; + return WabtResult::Ok; } static WabtResult end_elem_segment_init_expr(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); ctx->current_init_expr = nullptr; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_elem_segment_function_index_count( @@ -827,7 +824,7 @@ static WabtResult on_elem_segment_function_index_count( assert(index == ctx->module->elem_segments.size - 1); WabtElemSegment* segment = ctx->module->elem_segments.data[index]; wabt_reserve_vars(&segment->vars, count); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_elem_segment_function_index(uint32_t index, @@ -837,15 +834,15 @@ static WabtResult on_elem_segment_function_index(uint32_t index, assert(index == ctx->module->elem_segments.size - 1); WabtElemSegment* segment = ctx->module->elem_segments.data[index]; WabtVar* var = wabt_append_var(&segment->vars); - var->type = WABT_VAR_TYPE_INDEX; + var->type = WabtVarType::Index; var->index = func_index; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_data_segment_count(uint32_t count, void* user_data) { Context* ctx = static_cast<Context*>(user_data); wabt_reserve_data_segment_ptrs(&ctx->module->data_segments, count); - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_data_segment(uint32_t index, @@ -853,11 +850,11 @@ static WabtResult begin_data_segment(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtModuleField* field = wabt_append_module_field(ctx->module); - field->type = WABT_MODULE_FIELD_TYPE_DATA_SEGMENT; + field->type = WabtModuleFieldType::DataSegment; WabtDataSegment* segment = &field->data_segment; WABT_ZERO_MEMORY(*segment); - segment->memory_var.type = WABT_VAR_TYPE_INDEX; + segment->memory_var.type = WabtVarType::Index; segment->memory_var.index = memory_index; assert(index == ctx->module->data_segments.size); @@ -865,7 +862,7 @@ static WabtResult begin_data_segment(uint32_t index, WabtDataSegmentPtr* segment_ptr = wabt_append_data_segment_ptr(&ctx->module->data_segments); *segment_ptr = segment; - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_data_segment_init_expr(uint32_t index, @@ -874,13 +871,13 @@ static WabtResult begin_data_segment_init_expr(uint32_t index, assert(index == ctx->module->data_segments.size - 1); WabtDataSegment* segment = ctx->module->data_segments.data[index]; ctx->current_init_expr = &segment->offset; - return WABT_OK; + return WabtResult::Ok; } static WabtResult end_data_segment_init_expr(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); ctx->current_init_expr = nullptr; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_data_segment_data(uint32_t index, @@ -893,7 +890,7 @@ static WabtResult on_data_segment_data(uint32_t index, segment->data = wabt_alloc(size); segment->size = size; memcpy(segment->data, data, size); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_function_names_count(uint32_t count, void* user_data) { @@ -902,9 +899,9 @@ static WabtResult on_function_names_count(uint32_t count, void* user_data) { print_error( ctx, "expected function name count (%u) <= function count (%" PRIzd ")", count, ctx->module->funcs.size); - return WABT_ERROR; + return WabtResult::Error; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_function_name(uint32_t index, @@ -921,7 +918,7 @@ static WabtResult on_function_name(uint32_t index, WabtFunc* func = ctx->module->funcs.data[index]; func->name = new_name; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_local_names_count(uint32_t index, @@ -935,9 +932,9 @@ static WabtResult on_local_names_count(uint32_t index, if (count > num_params_and_locals) { print_error(ctx, "expected local name count (%d) <= local count (%d)", count, num_params_and_locals); - return WABT_ERROR; + return WabtResult::Error; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_init_expr_f32_const_expr(uint32_t index, @@ -945,10 +942,10 @@ static WabtResult on_init_expr_f32_const_expr(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtExpr* expr = wabt_new_const_expr(); - expr->const_.type = WABT_TYPE_F32; + expr->const_.type = WabtType::F32; expr->const_.f32_bits = value; *ctx->current_init_expr = expr; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_init_expr_f64_const_expr(uint32_t index, @@ -956,10 +953,10 @@ static WabtResult on_init_expr_f64_const_expr(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtExpr* expr = wabt_new_const_expr(); - expr->const_.type = WABT_TYPE_F64; + expr->const_.type = WabtType::F64; expr->const_.f64_bits = value; *ctx->current_init_expr = expr; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_init_expr_get_global_expr(uint32_t index, @@ -967,10 +964,10 @@ static WabtResult on_init_expr_get_global_expr(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtExpr* expr = wabt_new_get_global_expr(); - expr->get_global.var.type = WABT_VAR_TYPE_INDEX; + expr->get_global.var.type = WabtVarType::Index; expr->get_global.var.index = global_index; *ctx->current_init_expr = expr; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_init_expr_i32_const_expr(uint32_t index, @@ -978,10 +975,10 @@ static WabtResult on_init_expr_i32_const_expr(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtExpr* expr = wabt_new_const_expr(); - expr->const_.type = WABT_TYPE_I32; + expr->const_.type = WabtType::I32; expr->const_.u32 = value; *ctx->current_init_expr = expr; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_init_expr_i64_const_expr(uint32_t index, @@ -989,10 +986,10 @@ static WabtResult on_init_expr_i64_const_expr(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtExpr* expr = wabt_new_const_expr(); - expr->const_.type = WABT_TYPE_I64; + expr->const_.type = WabtType::I64; expr->const_.u64 = value; *ctx->current_init_expr = expr; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_local_name(uint32_t func_index, @@ -1019,7 +1016,7 @@ static WabtResult on_local_name(uint32_t func_index, } binding = wabt_insert_binding(bindings, &new_name); binding->index = index; - return WABT_OK; + return WabtResult::Ok; } static void wabt_destroy_label_node(LabelNode* node) { diff --git a/src/binary-reader-interpreter.cc b/src/binary-reader-interpreter.cc index 9c5c40d1..ca28d412 100644 --- a/src/binary-reader-interpreter.cc +++ b/src/binary-reader-interpreter.cc @@ -26,10 +26,10 @@ #include "type-checker.h" #include "writer.h" -#define CHECK_RESULT(expr) \ - do { \ - if (WABT_FAILED(expr)) \ - return WABT_ERROR; \ +#define CHECK_RESULT(expr) \ + do { \ + if (WABT_FAILED(expr)) \ + return WabtResult::Error; \ } while (0) #define CHECK_LOCAL(ctx, local_index) \ @@ -39,7 +39,7 @@ if ((local_index) >= max_local_index) { \ print_error((ctx), "invalid local_index: %d (max %d)", (local_index), \ max_local_index); \ - return WABT_ERROR; \ + return WabtResult::Error; \ } \ } while (0) @@ -49,7 +49,7 @@ if ((global_index) >= max_global_index) { \ print_error((ctx), "invalid global_index: %d (max %d)", (global_index), \ max_global_index); \ - return WABT_ERROR; \ + return WabtResult::Error; \ } \ } while (0) @@ -207,13 +207,17 @@ static WabtResult emit_data_at(Context* ctx, static WabtResult emit_data(Context* ctx, const void* data, size_t size) { CHECK_RESULT(emit_data_at(ctx, ctx->istream_offset, data, size)); ctx->istream_offset += size; - return WABT_OK; + return WabtResult::Ok; } static WabtResult emit_opcode(Context* ctx, WabtOpcode opcode) { return emit_data(ctx, &opcode, sizeof(uint8_t)); } +static WabtResult emit_opcode(Context* ctx, WabtInterpreterOpcode opcode) { + return emit_data(ctx, &opcode, sizeof(uint8_t)); +} + static WabtResult emit_i8(Context* ctx, uint8_t value) { return emit_data(ctx, &value, sizeof(value)); } @@ -235,15 +239,14 @@ static WabtResult emit_drop_keep(Context* ctx, uint32_t drop, uint8_t keep) { assert(keep <= 1); if (drop > 0) { if (drop == 1 && keep == 0) { - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_DROP)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::Drop)); } else { - CHECK_RESULT( - emit_opcode(ctx, static_cast<WabtOpcode>(WABT_OPCODE_DROP_KEEP))); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::DropKeep)); CHECK_RESULT(emit_i32(ctx, drop)); CHECK_RESULT(emit_i8(ctx, keep)); } } - return WABT_OK; + return WabtResult::Ok; } static WabtResult append_fixup(Context* ctx, @@ -254,7 +257,7 @@ static WabtResult append_fixup(Context* ctx, Uint32Vector* fixups = &fixups_vector->data[index]; uint32_t offset = get_istream_offset(ctx); wabt_append_uint32_value(fixups, &offset); - return WABT_OK; + return WabtResult::Ok; } static WabtResult emit_br_offset(Context* ctx, @@ -268,7 +271,7 @@ static WabtResult emit_br_offset(Context* ctx, append_fixup(ctx, &ctx->depth_fixups, depth)); } CHECK_RESULT(emit_i32(ctx, offset)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult get_br_drop_keep_count(Context* ctx, @@ -278,7 +281,7 @@ static WabtResult get_br_drop_keep_count(Context* ctx, WabtTypeCheckerLabel* label; CHECK_RESULT(wabt_typechecker_get_label(&ctx->typechecker, depth, &label)); *out_keep_count = - label->label_type != WABT_LABEL_TYPE_LOOP ? label->sig.size : 0; + label->label_type != WabtLabelType::Loop ? label->sig.size : 0; if (wabt_typechecker_is_unreachable(&ctx->typechecker)) { *out_drop_count = 0; } else { @@ -286,7 +289,7 @@ static WabtResult get_br_drop_keep_count(Context* ctx, (ctx->typechecker.type_stack.size - label->type_stack_limit) - *out_keep_count; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult get_return_drop_keep_count(Context* ctx, @@ -294,11 +297,11 @@ static WabtResult get_return_drop_keep_count(Context* ctx, uint32_t* out_keep_count) { if (WABT_FAILED(get_br_drop_keep_count(ctx, ctx->label_stack.size - 1, out_drop_count, out_keep_count))) { - return WABT_ERROR; + return WabtResult::Error; } *out_drop_count += ctx->current_func->defined.param_and_local_types.size; - return WABT_OK; + return WabtResult::Ok; } static WabtResult emit_br(Context* ctx, @@ -306,9 +309,9 @@ static WabtResult emit_br(Context* ctx, uint32_t drop_count, uint32_t keep_count) { CHECK_RESULT(emit_drop_keep(ctx, drop_count, keep_count)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_BR)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::Br)); CHECK_RESULT(emit_br_offset(ctx, depth, get_label(ctx, depth)->offset)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult emit_br_table_offset(Context* ctx, uint32_t depth) { @@ -317,7 +320,7 @@ static WabtResult emit_br_table_offset(Context* ctx, uint32_t depth) { CHECK_RESULT(emit_br_offset(ctx, depth, get_label(ctx, depth)->offset)); CHECK_RESULT(emit_i32(ctx, drop_count)); CHECK_RESULT(emit_i8(ctx, keep_count)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult fixup_top_label(Context* ctx) { @@ -325,7 +328,7 @@ static WabtResult fixup_top_label(Context* ctx) { uint32_t top = ctx->label_stack.size - 1; if (top >= ctx->depth_fixups.size) { /* nothing to fixup */ - return WABT_OK; + return WabtResult::Ok; } Uint32Vector* fixups = &ctx->depth_fixups.data[top]; @@ -335,7 +338,7 @@ static WabtResult fixup_top_label(Context* ctx) { /* reduce the size to 0 in case this gets reused. Keep the allocations for * later use */ fixups->size = 0; - return WABT_OK; + return WabtResult::Ok; } static WabtResult emit_func_offset(Context* ctx, @@ -347,7 +350,7 @@ static WabtResult emit_func_offset(Context* ctx, CHECK_RESULT(append_fixup(ctx, &ctx->func_fixups, defined_index)); } CHECK_RESULT(emit_i32(ctx, func->defined.offset)); - return WABT_OK; + return WabtResult::Ok; } static void on_error(WabtBinaryReaderContext* ctx, const char* message) { @@ -362,7 +365,7 @@ static WabtResult on_signature_count(uint32_t count, void* user_data) { ctx->sig_index_mapping.data[i] = ctx->env->sigs.size + i; wabt_resize_interpreter_func_signature_vector(&ctx->env->sigs, ctx->env->sigs.size + count); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_signature(uint32_t index, @@ -381,13 +384,13 @@ static WabtResult on_signature(uint32_t index, wabt_reserve_types(&sig->result_types, result_count); sig->result_types.size = result_count; memcpy(sig->result_types.data, result_types, result_count * sizeof(WabtType)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import_count(uint32_t count, void* user_data) { Context* ctx = static_cast<Context*>(user_data); wabt_new_interpreter_import_array(&ctx->module->defined.imports, count); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import(uint32_t index, @@ -404,7 +407,7 @@ static WabtResult on_import(uint32_t index, if (module_index < 0) { print_error(ctx, "unknown import module \"" PRIstringslice "\"", WABT_PRINTF_STRING_SLICE_ARG(import->module_name)); - return WABT_ERROR; + return WabtResult::Error; } assert(static_cast<size_t>(module_index) < ctx->env->modules.size); @@ -421,14 +424,14 @@ static WabtResult on_import(uint32_t index, if (!export_) { print_error(ctx, "unknown module field \"" PRIstringslice "\"", WABT_PRINTF_STRING_SLICE_ARG(import->field_name)); - return WABT_ERROR; + return WabtResult::Error; } import->kind = export_->kind; ctx->is_host_import = false; ctx->import_env_index = export_->index; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult check_import_kind(Context* ctx, @@ -441,9 +444,9 @@ static WabtResult check_import_kind(Context* ctx, WABT_PRINTF_STRING_SLICE_ARG(import->field_name), wabt_get_kind_name(expected_kind), wabt_get_kind_name(import->kind)); - return WABT_ERROR; + return WabtResult::Error; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult check_import_limits(Context* ctx, @@ -453,7 +456,7 @@ static WabtResult check_import_limits(Context* ctx, print_error(ctx, "actual size (%" PRIu64 ") smaller than declared (%" PRIu64 ")", actual_limits->initial, declared_limits->initial); - return WABT_ERROR; + return WabtResult::Error; } if (declared_limits->has_max) { @@ -461,16 +464,16 @@ static WabtResult check_import_limits(Context* ctx, print_error(ctx, "max size (unspecified) larger than declared (%" PRIu64 ")", declared_limits->max); - return WABT_ERROR; + return WabtResult::Error; } else if (actual_limits->max > declared_limits->max) { print_error(ctx, "max size (%" PRIu64 ") larger than declared (%" PRIu64 ")", actual_limits->max, declared_limits->max); - return WABT_ERROR; + return WabtResult::Error; } } - return WABT_OK; + return WabtResult::Ok; } static WabtResult append_export(Context* ctx, @@ -481,7 +484,7 @@ static WabtResult append_export(Context* ctx, if (wabt_find_binding_index_by_name(&module->export_bindings, &name) != -1) { print_error(ctx, "duplicate export \"" PRIstringslice "\"", WABT_PRINTF_STRING_SLICE_ARG(name)); - return WABT_ERROR; + return WabtResult::Error; } WabtInterpreterExport* export_ = @@ -493,7 +496,7 @@ static WabtResult append_export(Context* ctx, WabtBinding* binding = wabt_insert_binding(&module->export_bindings, &export_->name); binding->index = module->exports.size - 1; - return WABT_OK; + return WabtResult::Ok; } static void on_host_import_print_error(const char* msg, void* user_data) { @@ -536,23 +539,23 @@ static WabtResult on_import_func(uint32_t import_index, assert(func->host.callback); func_env_index = ctx->env->funcs.size - 1; - append_export(ctx, ctx->host_import_module, WABT_EXTERNAL_KIND_FUNC, + append_export(ctx, ctx->host_import_module, WabtExternalKind::Func, func_env_index, import->field_name); } else { - CHECK_RESULT(check_import_kind(ctx, import, WABT_EXTERNAL_KIND_FUNC)); + CHECK_RESULT(check_import_kind(ctx, import, WabtExternalKind::Func)); assert(ctx->import_env_index < ctx->env->funcs.size); WabtInterpreterFunc* func = &ctx->env->funcs.data[ctx->import_env_index]; if (!wabt_func_signatures_are_equal(ctx->env, import->func.sig_index, func->sig_index)) { print_error(ctx, "import signature mismatch"); - return WABT_ERROR; + return WabtResult::Error; } func_env_index = ctx->import_env_index; } wabt_append_uint32_value(&ctx->func_index_mapping, &func_env_index); ctx->num_func_imports++; - return WABT_OK; + return WabtResult::Ok; } static void init_table_func_indexes(Context* ctx, WabtInterpreterTable* table) { @@ -570,7 +573,7 @@ static WabtResult on_import_table(uint32_t import_index, Context* ctx = static_cast<Context*>(user_data); if (ctx->module->table_index != WABT_INVALID_INDEX) { print_error(ctx, "only one table allowed"); - return WABT_ERROR; + return WabtResult::Error; } assert(import_index < ctx->module->defined.imports.size); @@ -592,10 +595,10 @@ static WabtResult on_import_table(uint32_t import_index, CHECK_RESULT(check_import_limits(ctx, elem_limits, &table->limits)); ctx->module->table_index = ctx->env->tables.size - 1; - append_export(ctx, ctx->host_import_module, WABT_EXTERNAL_KIND_TABLE, + append_export(ctx, ctx->host_import_module, WabtExternalKind::Table, ctx->module->table_index, import->field_name); } else { - CHECK_RESULT(check_import_kind(ctx, import, WABT_EXTERNAL_KIND_TABLE)); + CHECK_RESULT(check_import_kind(ctx, import, WabtExternalKind::Table)); assert(ctx->import_env_index < ctx->env->tables.size); WabtInterpreterTable* table = &ctx->env->tables.data[ctx->import_env_index]; CHECK_RESULT(check_import_limits(ctx, elem_limits, &table->limits)); @@ -603,7 +606,7 @@ static WabtResult on_import_table(uint32_t import_index, import->table.limits = *elem_limits; ctx->module->table_index = ctx->import_env_index; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import_memory(uint32_t import_index, @@ -613,7 +616,7 @@ static WabtResult on_import_memory(uint32_t import_index, Context* ctx = static_cast<Context*>(user_data); if (ctx->module->memory_index != WABT_INVALID_INDEX) { print_error(ctx, "only one memory allowed"); - return WABT_ERROR; + return WabtResult::Error; } assert(import_index < ctx->module->defined.imports.size); @@ -634,10 +637,10 @@ static WabtResult on_import_memory(uint32_t import_index, CHECK_RESULT(check_import_limits(ctx, page_limits, &memory->page_limits)); ctx->module->memory_index = ctx->env->memories.size - 1; - append_export(ctx, ctx->host_import_module, WABT_EXTERNAL_KIND_MEMORY, + append_export(ctx, ctx->host_import_module, WabtExternalKind::Memory, ctx->module->memory_index, import->field_name); } else { - CHECK_RESULT(check_import_kind(ctx, import, WABT_EXTERNAL_KIND_MEMORY)); + CHECK_RESULT(check_import_kind(ctx, import, WabtExternalKind::Memory)); assert(ctx->import_env_index < ctx->env->memories.size); WabtInterpreterMemory* memory = &ctx->env->memories.data[ctx->import_env_index]; @@ -646,7 +649,7 @@ static WabtResult on_import_memory(uint32_t import_index, import->memory.limits = *page_limits; ctx->module->memory_index = ctx->import_env_index; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import_global(uint32_t import_index, @@ -673,10 +676,10 @@ static WabtResult on_import_global(uint32_t import_index, host_delegate->user_data)); global_env_index = ctx->env->globals.size - 1; - append_export(ctx, ctx->host_import_module, WABT_EXTERNAL_KIND_GLOBAL, + append_export(ctx, ctx->host_import_module, WabtExternalKind::Global, global_env_index, import->field_name); } else { - CHECK_RESULT(check_import_kind(ctx, import, WABT_EXTERNAL_KIND_GLOBAL)); + CHECK_RESULT(check_import_kind(ctx, import, WabtExternalKind::Global)); // TODO: check type and mutability import->global.type = type; import->global.mutable_ = mutable_; @@ -684,7 +687,7 @@ static WabtResult on_import_global(uint32_t import_index, } wabt_append_uint32_value(&ctx->global_index_mapping, &global_env_index); ctx->num_global_imports++; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_function_signatures_count(uint32_t count, @@ -698,7 +701,7 @@ static WabtResult on_function_signatures_count(uint32_t count, wabt_resize_interpreter_func_vector(&ctx->env->funcs, ctx->env->funcs.size + count); wabt_resize_uint32_vector_vector(&ctx->func_fixups, count); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_function_signature(uint32_t index, @@ -708,7 +711,7 @@ static WabtResult on_function_signature(uint32_t index, WabtInterpreterFunc* func = get_func_by_module_index(ctx, index); func->defined.offset = WABT_INVALID_OFFSET; func->sig_index = translate_sig_index_to_env(ctx, sig_index); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_table(uint32_t index, @@ -718,14 +721,14 @@ static WabtResult on_table(uint32_t index, Context* ctx = static_cast<Context*>(user_data); if (ctx->module->table_index != WABT_INVALID_INDEX) { print_error(ctx, "only one table allowed"); - return WABT_ERROR; + return WabtResult::Error; } WabtInterpreterTable* table = wabt_append_interpreter_table(&ctx->env->tables); table->limits = *elem_limits; init_table_func_indexes(ctx, table); ctx->module->table_index = ctx->env->tables.size - 1; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_memory(uint32_t index, @@ -734,7 +737,7 @@ static WabtResult on_memory(uint32_t index, Context* ctx = static_cast<Context*>(user_data); if (ctx->module->memory_index != WABT_INVALID_INDEX) { print_error(ctx, "only one memory allowed"); - return WABT_ERROR; + return WabtResult::Error; } WabtInterpreterMemory* memory = wabt_append_interpreter_memory(&ctx->env->memories); @@ -742,7 +745,7 @@ static WabtResult on_memory(uint32_t index, memory->byte_size = page_limits->initial * WABT_PAGE_SIZE; memory->data = wabt_alloc_zero(memory->byte_size); ctx->module->memory_index = ctx->env->memories.size - 1; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_global_count(uint32_t count, void* user_data) { @@ -754,7 +757,7 @@ static WabtResult on_global_count(uint32_t count, void* user_data) { ctx->global_index_mapping.data[old_size + i] = ctx->env->globals.size + i; wabt_resize_interpreter_global_vector(&ctx->env->globals, ctx->env->globals.size + count); - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_global(uint32_t index, @@ -765,7 +768,7 @@ static WabtResult begin_global(uint32_t index, WabtInterpreterGlobal* global = get_global_by_module_index(ctx, index); global->typed_value.type = type; global->mutable_ = mutable_; - return WABT_OK; + return WabtResult::Ok; } static WabtResult end_global_init_expr(uint32_t index, void* user_data) { @@ -775,28 +778,28 @@ static WabtResult end_global_init_expr(uint32_t index, void* user_data) { print_error(ctx, "type mismatch in global, expected %s but got %s.", wabt_get_type_name(global->typed_value.type), wabt_get_type_name(ctx->init_expr_value.type)); - return WABT_ERROR; + return WabtResult::Error; } global->typed_value = ctx->init_expr_value; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_init_expr_f32_const_expr(uint32_t index, uint32_t value_bits, void* user_data) { Context* ctx = static_cast<Context*>(user_data); - ctx->init_expr_value.type = WABT_TYPE_F32; + ctx->init_expr_value.type = WabtType::F32; ctx->init_expr_value.value.f32_bits = value_bits; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_init_expr_f64_const_expr(uint32_t index, uint64_t value_bits, void* user_data) { Context* ctx = static_cast<Context*>(user_data); - ctx->init_expr_value.type = WABT_TYPE_F64; + ctx->init_expr_value.type = WabtType::F64; ctx->init_expr_value.value.f64_bits = value_bits; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_init_expr_get_global_expr(uint32_t index, @@ -806,35 +809,35 @@ static WabtResult on_init_expr_get_global_expr(uint32_t index, if (global_index >= ctx->num_global_imports) { print_error(ctx, "initializer expression can only reference an imported global"); - return WABT_ERROR; + return WabtResult::Error; } WabtInterpreterGlobal* ref_global = get_global_by_module_index(ctx, global_index); if (ref_global->mutable_) { print_error(ctx, "initializer expression cannot reference a mutable global"); - return WABT_ERROR; + return WabtResult::Error; } ctx->init_expr_value = ref_global->typed_value; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_init_expr_i32_const_expr(uint32_t index, uint32_t value, void* user_data) { Context* ctx = static_cast<Context*>(user_data); - ctx->init_expr_value.type = WABT_TYPE_I32; + ctx->init_expr_value.type = WabtType::I32; ctx->init_expr_value.value.i32 = value; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_init_expr_i64_const_expr(uint32_t index, uint64_t value, void* user_data) { Context* ctx = static_cast<Context*>(user_data); - ctx->init_expr_value.type = WABT_TYPE_I64; + ctx->init_expr_value.type = WabtType::I64; ctx->init_expr_value.value.i64 = value; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_export(uint32_t index, @@ -844,31 +847,27 @@ static WabtResult on_export(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); switch (kind) { - case WABT_EXTERNAL_KIND_FUNC: + case WabtExternalKind::Func: item_index = translate_func_index_to_env(ctx, item_index); break; - case WABT_EXTERNAL_KIND_TABLE: + case WabtExternalKind::Table: item_index = ctx->module->table_index; break; - case WABT_EXTERNAL_KIND_MEMORY: + case WabtExternalKind::Memory: item_index = ctx->module->memory_index; break; - case WABT_EXTERNAL_KIND_GLOBAL: { + case WabtExternalKind::Global: { item_index = translate_global_index_to_env(ctx, item_index); WabtInterpreterGlobal* global = &ctx->env->globals.data[item_index]; if (global->mutable_) { print_error(ctx, "mutable globals cannot be exported"); - return WABT_ERROR; + return WabtResult::Error; } break; } - - case WABT_NUM_EXTERNAL_KINDS: - assert(0); - break; } return append_export(ctx, ctx->module, kind, item_index, name); } @@ -882,25 +881,25 @@ static WabtResult on_start_function(uint32_t func_index, void* user_data) { get_signature_by_env_index(ctx, start_func->sig_index); if (sig->param_types.size != 0) { print_error(ctx, "start function must be nullary"); - return WABT_ERROR; + return WabtResult::Error; } if (sig->result_types.size != 0) { print_error(ctx, "start function must not return anything"); - return WABT_ERROR; + return WabtResult::Error; } ctx->module->defined.start_func_index = start_func_index; - return WABT_OK; + return WabtResult::Ok; } static WabtResult end_elem_segment_init_expr(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); - if (ctx->init_expr_value.type != WABT_TYPE_I32) { + if (ctx->init_expr_value.type != WabtType::I32) { print_error(ctx, "type mismatch in elem segment, expected i32 but got %s", wabt_get_type_name(ctx->init_expr_value.type)); - return WABT_ERROR; + return WabtResult::Error; } ctx->table_offset = ctx->init_expr_value.value.i32; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_elem_segment_function_index_check(uint32_t index, @@ -914,19 +913,19 @@ static WabtResult on_elem_segment_function_index_check(uint32_t index, print_error(ctx, "elem segment offset is out of bounds: %u >= max value %" PRIzd, ctx->table_offset, table->func_indexes.size); - return WABT_ERROR; + return WabtResult::Error; } uint32_t max_func_index = ctx->func_index_mapping.size; if (func_index >= max_func_index) { print_error(ctx, "invalid func_index: %d (max %d)", func_index, max_func_index); - return WABT_ERROR; + return WabtResult::Error; } table->func_indexes.data[ctx->table_offset++] = translate_func_index_to_env(ctx, func_index); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_elem_segment_function_index(uint32_t index, @@ -938,7 +937,7 @@ static WabtResult on_elem_segment_function_index(uint32_t index, &ctx->env->tables.data[ctx->module->table_index]; table->func_indexes.data[ctx->table_offset++] = translate_func_index_to_env(ctx, func_index); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_data_segment_data_check(uint32_t index, @@ -949,10 +948,10 @@ static WabtResult on_data_segment_data_check(uint32_t index, assert(ctx->module->memory_index != WABT_INVALID_INDEX); WabtInterpreterMemory* memory = &ctx->env->memories.data[ctx->module->memory_index]; - if (ctx->init_expr_value.type != WABT_TYPE_I32) { + if (ctx->init_expr_value.type != WabtType::I32) { print_error(ctx, "type mismatch in data segment, expected i32 but got %s", wabt_get_type_name(ctx->init_expr_value.type)); - return WABT_ERROR; + return WabtResult::Error; } uint32_t address = ctx->init_expr_value.value.i32; uint64_t end_address = @@ -961,9 +960,9 @@ static WabtResult on_data_segment_data_check(uint32_t index, print_error(ctx, "data segment is out of bounds: [%u, %" PRIu64 ") >= max value %u", address, end_address, memory->byte_size); - return WABT_ERROR; + return WabtResult::Error; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_data_segment_data(uint32_t index, @@ -977,7 +976,7 @@ static WabtResult on_data_segment_data(uint32_t index, uint32_t address = ctx->init_expr_value.value.i32; uint8_t* dst_data = static_cast<uint8_t*>(memory->data); memcpy(&dst_data[address], src_data, size); - return WABT_OK; + return WabtResult::Ok; } static void push_label(Context* ctx, uint32_t offset, uint32_t fixup_offset) { @@ -1034,7 +1033,7 @@ static WabtResult begin_function_body(WabtBinaryReaderContext* context, /* push implicit func label (equivalent to return) */ push_label(ctx, WABT_INVALID_OFFSET, WABT_INVALID_OFFSET); - return WABT_OK; + return WabtResult::Ok; } static WabtResult end_function_body(uint32_t index, void* user_data) { @@ -1044,17 +1043,17 @@ static WabtResult end_function_body(uint32_t index, void* user_data) { CHECK_RESULT(get_return_drop_keep_count(ctx, &drop_count, &keep_count)); CHECK_RESULT(wabt_typechecker_end_function(&ctx->typechecker)); CHECK_RESULT(emit_drop_keep(ctx, drop_count, keep_count)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_RETURN)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::Return)); pop_label(ctx); ctx->current_func = nullptr; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_local_decl_count(uint32_t count, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtInterpreterFunc* func = ctx->current_func; func->defined.local_decl_count = count; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_local_decl(uint32_t decl_index, @@ -1072,19 +1071,19 @@ static WabtResult on_local_decl(uint32_t decl_index, if (decl_index == func->defined.local_decl_count - 1) { /* last local declaration, allocate space for all locals. */ - CHECK_RESULT(emit_opcode(ctx, static_cast<WabtOpcode>(WABT_OPCODE_ALLOCA))); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::Alloca)); CHECK_RESULT(emit_i32(ctx, func->defined.local_count)); } - return WABT_OK; + return WabtResult::Ok; } static WabtResult check_has_memory(Context* ctx, WabtOpcode opcode) { if (ctx->module->memory_index == WABT_INVALID_INDEX) { print_error(ctx, "%s requires an imported or defined memory.", wabt_get_opcode_name(opcode)); - return WABT_ERROR; + return WabtResult::Error; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult check_align(Context* ctx, @@ -1093,23 +1092,23 @@ static WabtResult check_align(Context* ctx, if (alignment_log2 >= 32 || (1U << alignment_log2) > natural_alignment) { print_error(ctx, "alignment must not be larger than natural alignment (%u)", natural_alignment); - return WABT_ERROR; + return WabtResult::Error; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_unary_expr(WabtOpcode opcode, void* user_data) { Context* ctx = static_cast<Context*>(user_data); CHECK_RESULT(wabt_typechecker_on_unary(&ctx->typechecker, opcode)); CHECK_RESULT(emit_opcode(ctx, opcode)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_binary_expr(WabtOpcode opcode, void* user_data) { Context* ctx = static_cast<Context*>(user_data); CHECK_RESULT(wabt_typechecker_on_binary(&ctx->typechecker, opcode)); CHECK_RESULT(emit_opcode(ctx, opcode)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_block_expr(uint32_t num_types, @@ -1121,7 +1120,7 @@ static WabtResult on_block_expr(uint32_t num_types, sig.data = sig_types; CHECK_RESULT(wabt_typechecker_on_block(&ctx->typechecker, &sig)); push_label(ctx, WABT_INVALID_OFFSET, WABT_INVALID_OFFSET); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_loop_expr(uint32_t num_types, @@ -1133,7 +1132,7 @@ static WabtResult on_loop_expr(uint32_t num_types, sig.data = sig_types; CHECK_RESULT(wabt_typechecker_on_loop(&ctx->typechecker, &sig)); push_label(ctx, get_istream_offset(ctx), WABT_INVALID_OFFSET); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_if_expr(uint32_t num_types, @@ -1144,12 +1143,11 @@ static WabtResult on_if_expr(uint32_t num_types, sig.size = num_types; sig.data = sig_types; CHECK_RESULT(wabt_typechecker_on_if(&ctx->typechecker, &sig)); - CHECK_RESULT( - emit_opcode(ctx, static_cast<WabtOpcode>(WABT_OPCODE_BR_UNLESS))); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::BrUnless)); uint32_t fixup_offset = get_istream_offset(ctx); CHECK_RESULT(emit_i32(ctx, WABT_INVALID_OFFSET)); push_label(ctx, WABT_INVALID_OFFSET, fixup_offset); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_else_expr(void* user_data) { @@ -1157,11 +1155,11 @@ static WabtResult on_else_expr(void* user_data) { CHECK_RESULT(wabt_typechecker_on_else(&ctx->typechecker)); Label* label = top_label(ctx); uint32_t fixup_cond_offset = label->fixup_offset; - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_BR)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::Br)); label->fixup_offset = get_istream_offset(ctx); CHECK_RESULT(emit_i32(ctx, WABT_INVALID_OFFSET)); CHECK_RESULT(emit_i32_at(ctx, fixup_cond_offset, get_istream_offset(ctx))); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_end_expr(void* user_data) { @@ -1170,13 +1168,13 @@ static WabtResult on_end_expr(void* user_data) { CHECK_RESULT(wabt_typechecker_get_label(&ctx->typechecker, 0, &label)); WabtLabelType label_type = label->label_type; CHECK_RESULT(wabt_typechecker_on_end(&ctx->typechecker)); - if (label_type == WABT_LABEL_TYPE_IF || label_type == WABT_LABEL_TYPE_ELSE) { + if (label_type == WabtLabelType::If || label_type == WabtLabelType::Else) { CHECK_RESULT(emit_i32_at(ctx, top_label(ctx)->fixup_offset, get_istream_offset(ctx))); } fixup_top_label(ctx); pop_label(ctx); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_br_expr(uint32_t depth, void* user_data) { @@ -1185,7 +1183,7 @@ static WabtResult on_br_expr(uint32_t depth, void* user_data) { CHECK_RESULT(get_br_drop_keep_count(ctx, depth, &drop_count, &keep_count)); CHECK_RESULT(wabt_typechecker_on_br(&ctx->typechecker, depth)); CHECK_RESULT(emit_br(ctx, depth, drop_count, keep_count)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_br_if_expr(uint32_t depth, void* user_data) { @@ -1194,13 +1192,12 @@ static WabtResult on_br_if_expr(uint32_t depth, void* user_data) { CHECK_RESULT(wabt_typechecker_on_br_if(&ctx->typechecker, depth)); CHECK_RESULT(get_br_drop_keep_count(ctx, depth, &drop_count, &keep_count)); /* flip the br_if so if <cond> is true it can drop values from the stack */ - CHECK_RESULT( - emit_opcode(ctx, static_cast<WabtOpcode>(WABT_OPCODE_BR_UNLESS))); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::BrUnless)); uint32_t fixup_br_offset = get_istream_offset(ctx); CHECK_RESULT(emit_i32(ctx, WABT_INVALID_OFFSET)); CHECK_RESULT(emit_br(ctx, depth, drop_count, keep_count)); CHECK_RESULT(emit_i32_at(ctx, fixup_br_offset, get_istream_offset(ctx))); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_br_table_expr(WabtBinaryReaderContext* context, @@ -1209,13 +1206,13 @@ static WabtResult on_br_table_expr(WabtBinaryReaderContext* context, uint32_t default_target_depth) { Context* ctx = static_cast<Context*>(context->user_data); CHECK_RESULT(wabt_typechecker_begin_br_table(&ctx->typechecker)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_BR_TABLE)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::BrTable)); CHECK_RESULT(emit_i32(ctx, num_targets)); uint32_t fixup_table_offset = get_istream_offset(ctx); CHECK_RESULT(emit_i32(ctx, WABT_INVALID_OFFSET)); /* not necessary for the interpreter, but it makes it easier to disassemble. * This opcode specifies how many bytes of data follow. */ - CHECK_RESULT(emit_opcode(ctx, static_cast<WabtOpcode>(WABT_OPCODE_DATA))); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::Data)); CHECK_RESULT(emit_i32(ctx, (num_targets + 1) * WABT_TABLE_ENTRY_SIZE)); CHECK_RESULT(emit_i32_at(ctx, fixup_table_offset, get_istream_offset(ctx))); @@ -1227,7 +1224,7 @@ static WabtResult on_br_table_expr(WabtBinaryReaderContext* context, } CHECK_RESULT(wabt_typechecker_end_br_table(&ctx->typechecker)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_call_expr(uint32_t func_index, void* user_data) { @@ -1239,71 +1236,70 @@ static WabtResult on_call_expr(uint32_t func_index, void* user_data) { &sig->result_types)); if (func->is_host) { - CHECK_RESULT( - emit_opcode(ctx, static_cast<WabtOpcode>(WABT_OPCODE_CALL_HOST))); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::CallHost)); CHECK_RESULT(emit_i32(ctx, translate_func_index_to_env(ctx, func_index))); } else { - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_CALL)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::Call)); CHECK_RESULT(emit_func_offset(ctx, func, func_index)); } - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_call_indirect_expr(uint32_t sig_index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); if (ctx->module->table_index == WABT_INVALID_INDEX) { print_error(ctx, "found call_indirect operator, but no table"); - return WABT_ERROR; + return WabtResult::Error; } WabtInterpreterFuncSignature* sig = get_signature_by_module_index(ctx, sig_index); CHECK_RESULT(wabt_typechecker_on_call_indirect( &ctx->typechecker, &sig->param_types, &sig->result_types)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_CALL_INDIRECT)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::CallIndirect)); CHECK_RESULT(emit_i32(ctx, ctx->module->table_index)); CHECK_RESULT(emit_i32(ctx, translate_sig_index_to_env(ctx, sig_index))); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_drop_expr(void* user_data) { Context* ctx = static_cast<Context*>(user_data); CHECK_RESULT(wabt_typechecker_on_drop(&ctx->typechecker)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_DROP)); - return WABT_OK; + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::Drop)); + return WabtResult::Ok; } static WabtResult on_i32_const_expr(uint32_t value, void* user_data) { Context* ctx = static_cast<Context*>(user_data); - CHECK_RESULT(wabt_typechecker_on_const(&ctx->typechecker, WABT_TYPE_I32)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_I32_CONST)); + CHECK_RESULT(wabt_typechecker_on_const(&ctx->typechecker, WabtType::I32)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::I32Const)); CHECK_RESULT(emit_i32(ctx, value)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_i64_const_expr(uint64_t value, void* user_data) { Context* ctx = static_cast<Context*>(user_data); - CHECK_RESULT(wabt_typechecker_on_const(&ctx->typechecker, WABT_TYPE_I64)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_I64_CONST)); + CHECK_RESULT(wabt_typechecker_on_const(&ctx->typechecker, WabtType::I64)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::I64Const)); CHECK_RESULT(emit_i64(ctx, value)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_f32_const_expr(uint32_t value_bits, void* user_data) { Context* ctx = static_cast<Context*>(user_data); - CHECK_RESULT(wabt_typechecker_on_const(&ctx->typechecker, WABT_TYPE_F32)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_F32_CONST)); + CHECK_RESULT(wabt_typechecker_on_const(&ctx->typechecker, WabtType::F32)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::F32Const)); CHECK_RESULT(emit_i32(ctx, value_bits)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_f64_const_expr(uint64_t value_bits, void* user_data) { Context* ctx = static_cast<Context*>(user_data); - CHECK_RESULT(wabt_typechecker_on_const(&ctx->typechecker, WABT_TYPE_F64)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_F64_CONST)); + CHECK_RESULT(wabt_typechecker_on_const(&ctx->typechecker, WabtType::F64)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::F64Const)); CHECK_RESULT(emit_i64(ctx, value_bits)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_get_global_expr(uint32_t global_index, void* user_data) { @@ -1311,9 +1307,9 @@ static WabtResult on_get_global_expr(uint32_t global_index, void* user_data) { CHECK_GLOBAL(ctx, global_index); WabtType type = get_global_type_by_module_index(ctx, global_index); CHECK_RESULT(wabt_typechecker_on_get_global(&ctx->typechecker, type)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_GET_GLOBAL)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::GetGlobal)); CHECK_RESULT(emit_i32(ctx, translate_global_index_to_env(ctx, global_index))); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_set_global_expr(uint32_t global_index, void* user_data) { @@ -1323,13 +1319,13 @@ static WabtResult on_set_global_expr(uint32_t global_index, void* user_data) { if (!global->mutable_) { print_error(ctx, "can't set_global on immutable global at index %u.", global_index); - return WABT_ERROR; + return WabtResult::Error; } CHECK_RESULT(wabt_typechecker_on_set_global(&ctx->typechecker, global->typed_value.type)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_SET_GLOBAL)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::SetGlobal)); CHECK_RESULT(emit_i32(ctx, translate_global_index_to_env(ctx, global_index))); - return WABT_OK; + return WabtResult::Ok; } static uint32_t translate_local_index(Context* ctx, uint32_t local_index) { @@ -1346,9 +1342,9 @@ static WabtResult on_get_local_expr(uint32_t local_index, void* user_data) { * relative to the old stack size. */ uint32_t translated_local_index = translate_local_index(ctx, local_index); CHECK_RESULT(wabt_typechecker_on_get_local(&ctx->typechecker, type)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_GET_LOCAL)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::GetLocal)); CHECK_RESULT(emit_i32(ctx, translated_local_index)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_set_local_expr(uint32_t local_index, void* user_data) { @@ -1356,9 +1352,9 @@ static WabtResult on_set_local_expr(uint32_t local_index, void* user_data) { CHECK_LOCAL(ctx, local_index); WabtType type = get_local_type_by_index(ctx->current_func, local_index); CHECK_RESULT(wabt_typechecker_on_set_local(&ctx->typechecker, type)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_SET_LOCAL)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::SetLocal)); CHECK_RESULT(emit_i32(ctx, translate_local_index(ctx, local_index))); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_tee_local_expr(uint32_t local_index, void* user_data) { @@ -1366,18 +1362,18 @@ static WabtResult on_tee_local_expr(uint32_t local_index, void* user_data) { CHECK_LOCAL(ctx, local_index); WabtType type = get_local_type_by_index(ctx->current_func, local_index); CHECK_RESULT(wabt_typechecker_on_tee_local(&ctx->typechecker, type)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_TEE_LOCAL)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::TeeLocal)); CHECK_RESULT(emit_i32(ctx, translate_local_index(ctx, local_index))); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_grow_memory_expr(void* user_data) { Context* ctx = static_cast<Context*>(user_data); - CHECK_RESULT(check_has_memory(ctx, WABT_OPCODE_GROW_MEMORY)); + CHECK_RESULT(check_has_memory(ctx, WabtOpcode::GrowMemory)); CHECK_RESULT(wabt_typechecker_on_grow_memory(&ctx->typechecker)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_GROW_MEMORY)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::GrowMemory)); CHECK_RESULT(emit_i32(ctx, ctx->module->memory_index)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_load_expr(WabtOpcode opcode, @@ -1392,7 +1388,7 @@ static WabtResult on_load_expr(WabtOpcode opcode, CHECK_RESULT(emit_opcode(ctx, opcode)); CHECK_RESULT(emit_i32(ctx, ctx->module->memory_index)); CHECK_RESULT(emit_i32(ctx, offset)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_store_expr(WabtOpcode opcode, @@ -1407,20 +1403,20 @@ static WabtResult on_store_expr(WabtOpcode opcode, CHECK_RESULT(emit_opcode(ctx, opcode)); CHECK_RESULT(emit_i32(ctx, ctx->module->memory_index)); CHECK_RESULT(emit_i32(ctx, offset)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_current_memory_expr(void* user_data) { Context* ctx = static_cast<Context*>(user_data); - CHECK_RESULT(check_has_memory(ctx, WABT_OPCODE_CURRENT_MEMORY)); + CHECK_RESULT(check_has_memory(ctx, WabtOpcode::CurrentMemory)); CHECK_RESULT(wabt_typechecker_on_current_memory(&ctx->typechecker)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_CURRENT_MEMORY)); + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::CurrentMemory)); CHECK_RESULT(emit_i32(ctx, ctx->module->memory_index)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_nop_expr(void* user_data) { - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_return_expr(void* user_data) { @@ -1429,22 +1425,22 @@ static WabtResult on_return_expr(void* user_data) { CHECK_RESULT(get_return_drop_keep_count(ctx, &drop_count, &keep_count)); CHECK_RESULT(wabt_typechecker_on_return(&ctx->typechecker)); CHECK_RESULT(emit_drop_keep(ctx, drop_count, keep_count)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_RETURN)); - return WABT_OK; + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::Return)); + return WabtResult::Ok; } static WabtResult on_select_expr(void* user_data) { Context* ctx = static_cast<Context*>(user_data); CHECK_RESULT(wabt_typechecker_on_select(&ctx->typechecker)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_SELECT)); - return WABT_OK; + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::Select)); + return WabtResult::Ok; } static WabtResult on_unreachable_expr(void* user_data) { Context* ctx = static_cast<Context*>(user_data); CHECK_RESULT(wabt_typechecker_on_unreachable(&ctx->typechecker)); - CHECK_RESULT(emit_opcode(ctx, WABT_OPCODE_UNREACHABLE)); - return WABT_OK; + CHECK_RESULT(emit_opcode(ctx, WabtInterpreterOpcode::Unreachable)); + return WabtResult::Ok; } static void destroy_context(Context* ctx) { diff --git a/src/binary-reader-linker.cc b/src/binary-reader-linker.cc index 4f3e4811..b99bd44f 100644 --- a/src/binary-reader-linker.cc +++ b/src/binary-reader-linker.cc @@ -36,7 +36,7 @@ static WabtResult on_reloc_count(uint32_t count, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtLinkerInputBinary* binary = ctx->binary; - if (section_code == WABT_BINARY_SECTION_CUSTOM) { + if (section_code == WabtBinarySection::Custom) { WABT_FATAL("relocation for custom sections not yet supported\n"); } @@ -46,11 +46,11 @@ static WabtResult on_reloc_count(uint32_t count, if (sec->section_code != section_code) continue; ctx->reloc_section = sec; - return WABT_OK; + return WabtResult::Ok; } - WABT_FATAL("section not found: %d\n", section_code); - return WABT_ERROR; + WABT_FATAL("section not found: %d\n", static_cast<int>(section_code)); + return WabtResult::Error; } static WabtResult on_reloc(WabtRelocType type, @@ -66,7 +66,7 @@ static WabtResult on_reloc(WabtRelocType type, reloc->type = type; reloc->offset = offset; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import(uint32_t index, @@ -79,7 +79,7 @@ static WabtResult on_import(uint32_t index, WABT_PRINTF_STRING_SLICE_ARG(module_name)); } ctx->import_name = field_name; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import_func(uint32_t import_index, @@ -93,7 +93,7 @@ static WabtResult on_import_func(uint32_t import_index, import->sig_index = sig_index; import->active = true; ctx->binary->active_function_imports++; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import_global(uint32_t import_index, @@ -108,7 +108,7 @@ static WabtResult on_import_global(uint32_t import_index, import->type = type; import->mutable_ = mutable_; ctx->binary->active_global_imports++; - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_section(WabtBinaryReaderContext* ctx, @@ -123,8 +123,8 @@ static WabtResult begin_section(WabtBinaryReaderContext* ctx, sec->offset = ctx->offset; sec->binary = binary; - if (sec->section_code != WABT_BINARY_SECTION_CUSTOM && - sec->section_code != WABT_BINARY_SECTION_START) { + if (sec->section_code != WabtBinarySection::Custom && + sec->section_code != WabtBinarySection::Start) { size_t bytes_read = wabt_read_u32_leb128( &binary->data[sec->offset], &binary->data[binary->size], &sec->count); if (bytes_read == 0) @@ -132,7 +132,7 @@ static WabtResult begin_section(WabtBinaryReaderContext* ctx, sec->payload_offset = sec->offset + bytes_read; sec->payload_size = sec->size - bytes_read; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_custom_section(WabtBinaryReaderContext* ctx, @@ -163,7 +163,7 @@ static WabtResult begin_custom_section(WabtBinaryReaderContext* ctx, uint32_t total_funcs = binary->function_imports.size; for (i = 0; i < binary->sections.size; i++) { if (binary->sections.data[i].section_code == - WABT_BINARY_SECTION_FUNCTION) { + WabtBinarySection::Function) { total_funcs += binary->sections.data[i].count; break; } @@ -174,7 +174,7 @@ static WabtResult begin_custom_section(WabtBinaryReaderContext* ctx, } } - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_table(uint32_t index, @@ -186,7 +186,7 @@ static WabtResult on_table(uint32_t index, Context* ctx = static_cast<Context*>(user_data); ctx->binary->table_elem_count = elem_limits->initial; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_elem_segment_function_index_count( @@ -200,7 +200,7 @@ static WabtResult on_elem_segment_function_index_count( size_t delta = ctx->offset - sec->payload_offset; sec->payload_offset += delta; sec->payload_size -= delta; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_memory(uint32_t index, @@ -210,7 +210,7 @@ static WabtResult on_memory(uint32_t index, WabtSection* sec = ctx->current_section; sec->memory_limits = *page_limits; ctx->binary->memory_page_count = page_limits->initial; - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_data_segment(uint32_t index, @@ -220,7 +220,7 @@ static WabtResult begin_data_segment(uint32_t index, WabtSection* sec = ctx->current_section; WabtDataSegment* segment = wabt_append_data_segment(&sec->data_segments); segment->memory_index = memory_index; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_init_expr_i32_const_expr(uint32_t index, @@ -228,12 +228,12 @@ static WabtResult on_init_expr_i32_const_expr(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); WabtSection* sec = ctx->current_section; - if (sec->section_code != WABT_BINARY_SECTION_DATA) - return WABT_OK; + if (sec->section_code != WabtBinarySection::Data) + return WabtResult::Ok; WabtDataSegment* segment = &sec->data_segments.data[sec->data_segments.size - 1]; segment->offset = value; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_data_segment_data(uint32_t index, @@ -246,7 +246,7 @@ static WabtResult on_data_segment_data(uint32_t index, &sec->data_segments.data[sec->data_segments.size - 1]; segment->data = static_cast<const uint8_t*>(src_data); segment->size = size; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_export(uint32_t index, @@ -259,7 +259,7 @@ static WabtResult on_export(uint32_t index, export_->name = name; export_->kind = kind; export_->index = item_index; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_function_name(uint32_t index, @@ -267,7 +267,7 @@ static WabtResult on_function_name(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); wabt_append_string_slice_value(&ctx->binary->debug_names, &name); - return WABT_OK; + return WabtResult::Ok; } WabtResult wabt_read_binary_linker(WabtLinkerInputBinary* input_info) { diff --git a/src/binary-reader-objdump.cc b/src/binary-reader-objdump.cc index 11964494..67e53528 100644 --- a/src/binary-reader-objdump.cc +++ b/src/binary-reader-objdump.cc @@ -41,7 +41,7 @@ struct Context { bool header_printed; int section_found; - uint32_t section_starts[WABT_NUM_BINARY_SECTIONS]; + uint32_t section_starts[kWabtBinarySectionCount]; WabtBinarySection reloc_section; WabtStringSlice import_module_name; @@ -51,7 +51,7 @@ struct Context { }; static bool should_print_details(Context* ctx) { - if (ctx->options->mode != WABT_DUMP_DETAILS) + if (ctx->options->mode != WabtObjdumpMode::Details) return false; return ctx->print_details; } @@ -70,7 +70,7 @@ static WabtResult begin_section(WabtBinaryReaderContext* ctx, WabtBinarySection section_code, uint32_t size) { Context* context = static_cast<Context*>(ctx->user_data); - context->section_starts[section_code] = ctx->offset; + context->section_starts[static_cast<size_t>(section_code)] = ctx->offset; const char* name = wabt_get_section_name(section_code); @@ -80,33 +80,33 @@ static WabtResult begin_section(WabtBinaryReaderContext* ctx, context->section_found = true; switch (context->options->mode) { - case WABT_DUMP_PREPASS: + case WabtObjdumpMode::Prepass: break; - case WABT_DUMP_HEADERS: + case WabtObjdumpMode::Headers: printf("%9s start=%#010" PRIzx " end=%#010" PRIzx " (size=%#010x) ", name, ctx->offset, ctx->offset + size, size); break; - case WABT_DUMP_DETAILS: + case WabtObjdumpMode::Details: if (section_match) { - if (section_code != WABT_BINARY_SECTION_CODE) + if (section_code != WabtBinarySection::Code) printf("%s:\n", name); context->print_details = true; } else { context->print_details = false; } break; - case WABT_DUMP_RAW_DATA: + case WabtObjdumpMode::RawData: if (section_match) { printf("\nContents of section %s:\n", name); wabt_write_memory_dump(context->out_stream, context->data + ctx->offset, - size, ctx->offset, WABT_PRINT_CHARS, nullptr, + size, ctx->offset, WabtPrintChars::Yes, nullptr, nullptr); } break; - case WABT_DUMP_DISASSEMBLE: + case WabtObjdumpMode::Disassemble: break; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_custom_section(WabtBinaryReaderContext* ctx, @@ -115,19 +115,19 @@ static WabtResult begin_custom_section(WabtBinaryReaderContext* ctx, Context* context = static_cast<Context*>(ctx->user_data); print_details(context, " - name: \"" PRIstringslice "\"\n", WABT_PRINTF_STRING_SLICE_ARG(section_name)); - if (context->options->mode == WABT_DUMP_HEADERS) { + if (context->options->mode == WabtObjdumpMode::Headers) { printf("\"" PRIstringslice "\"\n", WABT_PRINTF_STRING_SLICE_ARG(section_name)); } - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_count(uint32_t count, void* user_data) { Context* ctx = static_cast<Context*>(user_data); - if (ctx->options->mode == WABT_DUMP_HEADERS) { + if (ctx->options->mode == WabtObjdumpMode::Headers) { printf("count: %d\n", count); } - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_module(uint32_t version, void* user_data) { @@ -143,24 +143,24 @@ static WabtResult begin_module(uint32_t version, void* user_data) { } switch (ctx->options->mode) { - case WABT_DUMP_HEADERS: + case WabtObjdumpMode::Headers: printf("\n"); printf("Sections:\n\n"); break; - case WABT_DUMP_DETAILS: + case WabtObjdumpMode::Details: printf("\n"); printf("Section Details:\n\n"); break; - case WABT_DUMP_DISASSEMBLE: + case WabtObjdumpMode::Disassemble: printf("\n"); printf("Code Disassembly:\n\n"); break; - case WABT_DUMP_RAW_DATA: - case WABT_DUMP_PREPASS: + case WabtObjdumpMode::RawData: + case WabtObjdumpMode::Prepass: break; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult end_module(void *user_data) { @@ -168,11 +168,11 @@ static WabtResult end_module(void *user_data) { if (ctx->options->section_name) { if (!ctx->section_found) { printf("Section not found: %s\n", ctx->options->section_name); - return WABT_ERROR; + return WabtResult::Error; } } - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_opcode(WabtBinaryReaderContext* ctx, WabtOpcode opcode) { @@ -192,13 +192,13 @@ static WabtResult on_opcode(WabtBinaryReaderContext* ctx, WabtOpcode opcode) { " (%#02x=%s)\n", ctx->offset, context->last_opcode_end + 1, ctx->data[context->last_opcode_end], opcode_name); - return WABT_ERROR; + return WabtResult::Error; } } context->current_opcode_offset = ctx->offset; context->current_opcode = opcode; - return WABT_OK; + return WabtResult::Ok; } #define IMMEDIATE_OCTET_COUNT 9 @@ -211,7 +211,8 @@ static void log_opcode(Context* ctx, size_t offset = ctx->current_opcode_offset; // Print binary data - printf(" %06" PRIzx ": %02x", offset - 1, ctx->current_opcode); + printf(" %06" PRIzx ": %02x", offset - 1, + static_cast<unsigned>(ctx->current_opcode)); size_t i; for (i = 0; i < data_size && i < IMMEDIATE_OCTET_COUNT; i++, offset++) { printf(" %02x", data[offset]); @@ -224,7 +225,7 @@ static void log_opcode(Context* ctx, // Print disassemble int j; int indent_level = ctx->indent_level; - if (ctx->current_opcode == WABT_OPCODE_ELSE) + if (ctx->current_opcode == WabtOpcode::Else) indent_level--; for (j = 0; j < indent_level; j++) { printf(" "); @@ -247,7 +248,8 @@ static void log_opcode(Context* ctx, if (ctx->options->relocs) { if (ctx->next_reloc < ctx->options->code_relocations.size) { WabtReloc* reloc = &ctx->options->code_relocations.data[ctx->next_reloc]; - size_t code_start = ctx->section_starts[WABT_BINARY_SECTION_CODE]; + size_t code_start = + ctx->section_starts[static_cast<size_t>(WabtBinarySection::Code)]; size_t abs_offset = code_start + reloc->offset; if (ctx->last_opcode_end > abs_offset) { printf(" %06" PRIzx ": %s\n", abs_offset, @@ -261,7 +263,7 @@ static void log_opcode(Context* ctx, static WabtResult on_opcode_bare(WabtBinaryReaderContext* ctx) { Context* context = static_cast<Context*>(ctx->user_data); log_opcode(context, ctx->data, 0, nullptr); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_opcode_uint32(WabtBinaryReaderContext* ctx, @@ -269,7 +271,7 @@ static WabtResult on_opcode_uint32(WabtBinaryReaderContext* ctx, Context* context = static_cast<Context*>(ctx->user_data); size_t immediate_len = ctx->offset - context->current_opcode_offset; log_opcode(context, ctx->data, immediate_len, "%#x", value); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_opcode_uint32_uint32(WabtBinaryReaderContext* ctx, @@ -278,7 +280,7 @@ static WabtResult on_opcode_uint32_uint32(WabtBinaryReaderContext* ctx, Context* context = static_cast<Context*>(ctx->user_data); size_t immediate_len = ctx->offset - context->current_opcode_offset; log_opcode(context, ctx->data, immediate_len, "%lu %lu", value, value2); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_opcode_uint64(WabtBinaryReaderContext* ctx, @@ -286,7 +288,7 @@ static WabtResult on_opcode_uint64(WabtBinaryReaderContext* ctx, Context* context = static_cast<Context*>(ctx->user_data); size_t immediate_len = ctx->offset - context->current_opcode_offset; log_opcode(context, ctx->data, immediate_len, "%d", value); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_opcode_f32(WabtBinaryReaderContext* ctx, @@ -296,7 +298,7 @@ static WabtResult on_opcode_f32(WabtBinaryReaderContext* ctx, char buffer[WABT_MAX_FLOAT_HEX]; wabt_write_float_hex(buffer, sizeof(buffer), value); log_opcode(context, ctx->data, immediate_len, buffer); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_opcode_f64(WabtBinaryReaderContext* ctx, @@ -306,7 +308,7 @@ static WabtResult on_opcode_f64(WabtBinaryReaderContext* ctx, char buffer[WABT_MAX_DOUBLE_HEX]; wabt_write_double_hex(buffer, sizeof(buffer), value); log_opcode(context, ctx->data, immediate_len, buffer); - return WABT_OK; + return WabtResult::Ok; } WabtResult on_br_table_expr(WabtBinaryReaderContext* ctx, @@ -317,7 +319,7 @@ WabtResult on_br_table_expr(WabtBinaryReaderContext* ctx, size_t immediate_len = ctx->offset - context->current_opcode_offset; /* TODO(sbc): Print targets */ log_opcode(context, ctx->data, immediate_len, nullptr); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_end_expr(void* user_data) { @@ -325,21 +327,21 @@ static WabtResult on_end_expr(void* user_data) { context->indent_level--; assert(context->indent_level >= 0); log_opcode(context, nullptr, 0, nullptr); - return WABT_OK; + return WabtResult::Ok; } static const char* wabt_type_name(WabtType type) { switch (type) { - case WABT_TYPE_I32: + case WabtType::I32: return "i32"; - case WABT_TYPE_I64: + case WabtType::I64: return "i64"; - case WABT_TYPE_F32: + case WabtType::F32: return "f32"; - case WABT_TYPE_F64: + case WabtType::F64: return "f64"; default: @@ -357,7 +359,7 @@ static WabtResult on_opcode_block_sig(WabtBinaryReaderContext* ctx, else log_opcode(context, ctx->data, 1, nullptr); context->indent_level++; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_signature(uint32_t index, @@ -369,7 +371,7 @@ static WabtResult on_signature(uint32_t index, Context* ctx = static_cast<Context*>(user_data); if (!should_print_details(ctx)) - return WABT_OK; + return WabtResult::Ok; printf(" - [%d] (", index); uint32_t i; for (i = 0; i < param_count; i++) { @@ -384,7 +386,7 @@ static WabtResult on_signature(uint32_t index, else printf("nil"); printf("\n"); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_function_signature(uint32_t index, @@ -392,14 +394,14 @@ static WabtResult on_function_signature(uint32_t index, void* user_data) { print_details(static_cast<Context*>(user_data), " - func[%d] sig=%d\n", index, sig_index); - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_function_body(WabtBinaryReaderContext* context, uint32_t index) { Context* ctx = static_cast<Context*>(context->user_data); - if (ctx->options->mode == WABT_DUMP_DISASSEMBLE) { + if (ctx->options->mode == WabtObjdumpMode::Disassemble) { if (index < ctx->options->function_names.size) printf("%06" PRIzx " <" PRIstringslice ">:\n", context->offset, WABT_PRINTF_STRING_SLICE_ARG( @@ -409,7 +411,7 @@ static WabtResult begin_function_body(WabtBinaryReaderContext* context, } ctx->last_opcode_end = 0; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import(uint32_t index, @@ -419,7 +421,7 @@ static WabtResult on_import(uint32_t index, Context* ctx = static_cast<Context*>(user_data); ctx->import_module_name = module_name; ctx->import_field_name = field_name; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import_func(uint32_t import_index, @@ -432,7 +434,7 @@ static WabtResult on_import_func(uint32_t import_index, func_index, sig_index, WABT_PRINTF_STRING_SLICE_ARG(ctx->import_module_name), WABT_PRINTF_STRING_SLICE_ARG(ctx->import_field_name)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import_table(uint32_t import_index, @@ -447,7 +449,7 @@ static WabtResult on_import_table(uint32_t import_index, WABT_PRINTF_STRING_SLICE_ARG(ctx->import_module_name), WABT_PRINTF_STRING_SLICE_ARG(ctx->import_field_name), wabt_get_type_name(elem_type), elem_limits->initial, elem_limits->max); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import_memory(uint32_t import_index, @@ -458,7 +460,7 @@ static WabtResult on_import_memory(uint32_t import_index, print_details(ctx, " - " PRIstringslice "." PRIstringslice " -> memory\n", WABT_PRINTF_STRING_SLICE_ARG(ctx->import_module_name), WABT_PRINTF_STRING_SLICE_ARG(ctx->import_field_name)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_import_global(uint32_t import_index, @@ -472,7 +474,7 @@ static WabtResult on_import_global(uint32_t import_index, global_index, wabt_get_type_name(type), mutable_, WABT_PRINTF_STRING_SLICE_ARG(ctx->import_module_name), WABT_PRINTF_STRING_SLICE_ARG(ctx->import_field_name)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_memory(uint32_t index, @@ -484,7 +486,7 @@ static WabtResult on_memory(uint32_t index, if (page_limits->has_max) print_details(ctx, " max=%" PRId64, page_limits->max); print_details(ctx, "\n"); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_table(uint32_t index, @@ -497,7 +499,7 @@ static WabtResult on_table(uint32_t index, if (elem_limits->has_max) print_details(ctx, " max=%" PRId64, elem_limits->max); print_details(ctx, "\n"); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_export(uint32_t index, @@ -509,7 +511,7 @@ static WabtResult on_export(uint32_t index, print_details(ctx, " - %s[%d] ", wabt_get_kind_name(kind), item_index); print_details(ctx, PRIstringslice, WABT_PRINTF_STRING_SLICE_ARG(name)); print_details(ctx, "\n"); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_elem_segment_function_index(uint32_t index, @@ -517,7 +519,7 @@ static WabtResult on_elem_segment_function_index(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); print_details(ctx, " - func[%d]\n", func_index); - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_elem_segment(uint32_t index, @@ -525,7 +527,7 @@ static WabtResult begin_elem_segment(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); print_details(ctx, " - segment[%d] table=%d\n", index, table_index); - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_global(uint32_t index, @@ -535,7 +537,7 @@ static WabtResult begin_global(uint32_t index, Context* ctx = static_cast<Context*>(user_data); print_details(ctx, " - global[%d] %s mutable=%d", index, wabt_get_type_name(type), mutable_); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_init_expr_f32_const_expr(uint32_t index, @@ -545,7 +547,7 @@ static WabtResult on_init_expr_f32_const_expr(uint32_t index, char buffer[WABT_MAX_FLOAT_HEX]; wabt_write_float_hex(buffer, sizeof(buffer), value); print_details(ctx, " - init f32=%s\n", buffer); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_init_expr_f64_const_expr(uint32_t index, @@ -555,7 +557,7 @@ static WabtResult on_init_expr_f64_const_expr(uint32_t index, char buffer[WABT_MAX_DOUBLE_HEX]; wabt_write_float_hex(buffer, sizeof(buffer), value); print_details(ctx, " - init f64=%s\n", buffer); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_init_expr_get_global_expr(uint32_t index, @@ -563,7 +565,7 @@ static WabtResult on_init_expr_get_global_expr(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); print_details(ctx, " - init global=%d\n", global_index); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_init_expr_i32_const_expr(uint32_t index, @@ -571,7 +573,7 @@ static WabtResult on_init_expr_i32_const_expr(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); print_details(ctx, " - init i32=%d\n", value); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_init_expr_i64_const_expr(uint32_t index, @@ -579,7 +581,7 @@ static WabtResult on_init_expr_i64_const_expr(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); print_details(ctx, " - init i64=%" PRId64 "\n", value); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_function_name(uint32_t index, @@ -588,9 +590,9 @@ static WabtResult on_function_name(uint32_t index, Context* ctx = static_cast<Context*>(user_data); print_details(ctx, " - func[%d] " PRIstringslice "\n", index, WABT_PRINTF_STRING_SLICE_ARG(name)); - if (ctx->options->mode == WABT_DUMP_PREPASS) + if (ctx->options->mode == WabtObjdumpMode::Prepass) wabt_append_string_slice_value(&ctx->options->function_names, &name); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_local_name(uint32_t func_index, @@ -602,7 +604,7 @@ static WabtResult on_local_name(uint32_t func_index, print_details(ctx, " - local[%d] " PRIstringslice "\n", local_index, WABT_PRINTF_STRING_SLICE_ARG(name)); } - return WABT_OK; + return WabtResult::Ok; } WabtResult on_reloc_count(uint32_t count, @@ -612,31 +614,32 @@ WabtResult on_reloc_count(uint32_t count, Context* ctx = static_cast<Context*>(user_data); ctx->reloc_section = section_code; print_details(ctx, " - section: %s\n", wabt_get_section_name(section_code)); - return WABT_OK; + return WabtResult::Ok; } WabtResult on_reloc(WabtRelocType type, uint32_t offset, void* user_data) { Context* ctx = static_cast<Context*>(user_data); - uint32_t total_offset = ctx->section_starts[ctx->reloc_section] + offset; + uint32_t total_offset = + ctx->section_starts[static_cast<size_t>(ctx->reloc_section)] + offset; print_details(ctx, " - %-18s offset=%#x (%#x)\n", wabt_get_reloc_type_name(type), total_offset, offset); - if (ctx->options->mode == WABT_DUMP_PREPASS && - ctx->reloc_section == WABT_BINARY_SECTION_CODE) { + if (ctx->options->mode == WabtObjdumpMode::Prepass && + ctx->reloc_section == WabtBinarySection::Code) { WabtReloc reloc; reloc.offset = offset; reloc.type = type; wabt_append_reloc_value(&ctx->options->code_relocations, &reloc); } - return WABT_OK; + return WabtResult::Ok; } static void on_error(WabtBinaryReaderContext* ctx, const char* message) { WabtDefaultErrorHandlerInfo info; info.header = "error reading binary"; info.out_file = stdout; - info.print_header = WABT_PRINT_ERROR_HEADER_ONCE; + info.print_header = WabtPrintErrorHeader::Once; wabt_default_binary_error_callback(ctx->offset, message, &info); } @@ -645,7 +648,7 @@ static WabtResult begin_data_segment(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); print_details(ctx, " - memory[%d]", memory_index); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_data_segment_data(uint32_t index, @@ -654,10 +657,10 @@ static WabtResult on_data_segment_data(uint32_t index, void* user_data) { Context* ctx = static_cast<Context*>(user_data); if (should_print_details(ctx)) { - wabt_write_memory_dump(ctx->out_stream, src_data, size, 0, WABT_PRINT_CHARS, - " - ", nullptr); + wabt_write_memory_dump(ctx->out_stream, src_data, size, 0, + WabtPrintChars::Yes, " - ", nullptr); } - return WABT_OK; + return WabtResult::Ok; } WabtResult wabt_read_binary_objdump(const uint8_t* data, @@ -675,7 +678,7 @@ WabtResult wabt_read_binary_objdump(const uint8_t* data, WabtBinaryReader reader; WABT_ZERO_MEMORY(reader); - if (options->mode == WABT_DUMP_PREPASS) { + if (options->mode == WabtObjdumpMode::Prepass) { reader.on_function_name = on_function_name; reader.on_reloc_count = on_reloc_count; reader.on_reloc = on_reloc; @@ -750,7 +753,7 @@ WabtResult wabt_read_binary_objdump(const uint8_t* data, reader.on_init_expr_get_global_expr = on_init_expr_get_global_expr; } - if (options->mode == WABT_DUMP_DISASSEMBLE) { + if (options->mode == WabtObjdumpMode::Disassemble) { reader.on_opcode = on_opcode; reader.on_opcode_bare = on_opcode_bare; reader.on_opcode_uint32 = on_opcode_uint32; diff --git a/src/binary-reader-objdump.h b/src/binary-reader-objdump.h index 12e02e97..70899a20 100644 --- a/src/binary-reader-objdump.h +++ b/src/binary-reader-objdump.h @@ -32,12 +32,12 @@ WABT_DEFINE_VECTOR(reloc, WabtReloc); WABT_DEFINE_VECTOR(string_slice, WabtStringSlice); -enum WabtObjdumpMode { - WABT_DUMP_PREPASS, - WABT_DUMP_HEADERS, - WABT_DUMP_DETAILS, - WABT_DUMP_DISASSEMBLE, - WABT_DUMP_RAW_DATA, +enum class WabtObjdumpMode { + Prepass, + Headers, + Details, + Disassemble, + RawData, }; struct WabtObjdumpOptions { diff --git a/src/binary-reader-opcnt.cc b/src/binary-reader-opcnt.cc index 4c0cd5c2..f9ef60b4 100644 --- a/src/binary-reader-opcnt.cc +++ b/src/binary-reader-opcnt.cc @@ -35,14 +35,14 @@ static WabtResult add_int_counter_value(WabtIntCounterVector* vec, for (i = 0; i < vec->size; ++i) { if (vec->data[i].value == value) { ++vec->data[i].count; - return WABT_OK; + return WabtResult::Ok; } } WabtIntCounter counter; counter.value = value; counter.count = 1; wabt_append_int_counter_value(vec, &counter); - return WABT_OK; + return WabtResult::Ok; } static WabtResult add_int_pair_counter_value(WabtIntPairCounterVector* vec, @@ -52,7 +52,7 @@ static WabtResult add_int_pair_counter_value(WabtIntPairCounterVector* vec, for (i = 0; i < vec->size; ++i) { if (vec->data[i].first == first && vec->data[i].second == second) { ++vec->data[i].count; - return WABT_OK; + return WabtResult::Ok; } } WabtIntPairCounter counter; @@ -60,21 +60,21 @@ static WabtResult add_int_pair_counter_value(WabtIntPairCounterVector* vec, counter.second = second; counter.count = 1; wabt_append_int_pair_counter_value(vec, &counter); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_opcode(WabtBinaryReaderContext* context, WabtOpcode opcode) { Context* ctx = static_cast<Context*>(context->user_data); WabtIntCounterVector* opcnt_vec = &ctx->opcnt_data->opcode_vec; - while (opcode >= opcnt_vec->size) { + while (static_cast<size_t>(opcode) >= opcnt_vec->size) { WabtIntCounter Counter; Counter.value = opcnt_vec->size; Counter.count = 0; wabt_append_int_counter_value(opcnt_vec, &Counter); } - ++opcnt_vec->data[opcode].count; - return WABT_OK; + ++opcnt_vec->data[static_cast<size_t>(opcode)].count; + return WabtResult::Ok; } static WabtResult on_i32_const_expr(uint32_t value, void* user_data) { @@ -103,10 +103,10 @@ static WabtResult on_load_expr(WabtOpcode opcode, uint32_t offset, void* user_data) { Context* ctx = static_cast<Context*>(user_data); - if (opcode == WABT_OPCODE_I32_LOAD) + if (opcode == WabtOpcode::I32Load) return add_int_pair_counter_value(&ctx->opcnt_data->i32_load_vec, alignment_log2, offset); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_store_expr(WabtOpcode opcode, @@ -114,17 +114,17 @@ static WabtResult on_store_expr(WabtOpcode opcode, uint32_t offset, void* user_data) { Context* ctx = static_cast<Context*>(user_data); - if (opcode == WABT_OPCODE_I32_STORE) + if (opcode == WabtOpcode::I32Store) return add_int_pair_counter_value(&ctx->opcnt_data->i32_store_vec, alignment_log2, offset); - return WABT_OK; + return WabtResult::Ok; } static void on_error(WabtBinaryReaderContext* ctx, const char* message) { WabtDefaultErrorHandlerInfo info; info.header = "error reading binary"; info.out_file = stdout; - info.print_header = WABT_PRINT_ERROR_HEADER_ONCE; + info.print_header = WabtPrintErrorHeader::Once; wabt_default_binary_error_callback(ctx->offset, message, &info); } diff --git a/src/binary-reader.cc b/src/binary-reader.cc index d937a6c4..53737c03 100644 --- a/src/binary-reader.cc +++ b/src/binary-reader.cc @@ -47,14 +47,14 @@ WABT_DEFINE_VECTOR(uint32, Uint32); WABT_SUCCEEDED( \ ctx->reader->member \ ? ctx->reader->member(get_user_context(ctx), __VA_ARGS__) \ - : WABT_OK), \ + : WabtResult::Ok), \ #member " callback failed") #define CALLBACK_CTX0(member) \ RAISE_ERROR_UNLESS( \ WABT_SUCCEEDED(ctx->reader->member \ ? ctx->reader->member(get_user_context(ctx)) \ - : WABT_OK), \ + : WabtResult::Ok), \ #member " callback failed") #define CALLBACK_SECTION(member, section_size) \ @@ -64,7 +64,7 @@ WABT_DEFINE_VECTOR(uint32, Uint32); RAISE_ERROR_UNLESS( \ WABT_SUCCEEDED(ctx->reader->member \ ? ctx->reader->member(ctx->reader->user_data) \ - : WABT_OK), \ + : WabtResult::Ok), \ #member " callback failed") #define CALLBACK(member, ...) \ @@ -72,23 +72,23 @@ WABT_DEFINE_VECTOR(uint32, Uint32); WABT_SUCCEEDED( \ ctx->reader->member \ ? ctx->reader->member(__VA_ARGS__, ctx->reader->user_data) \ - : WABT_OK), \ + : WabtResult::Ok), \ #member " callback failed") #define FORWARD0(member) \ return ctx->reader->member ? ctx->reader->member(ctx->reader->user_data) \ - : WABT_OK + : WabtResult::Ok #define FORWARD_CTX0(member) \ if (!ctx->reader->member) \ - return WABT_OK; \ + return WabtResult::Ok; \ WabtBinaryReaderContext 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 WABT_OK; \ + return WabtResult::Ok; \ WabtBinaryReaderContext new_ctx = *context; \ new_ctx.user_data = ctx->reader->user_data; \ return ctx->reader->member(&new_ctx, __VA_ARGS__); @@ -96,7 +96,7 @@ WABT_DEFINE_VECTOR(uint32, Uint32); #define FORWARD(member, ...) \ return ctx->reader->member \ ? ctx->reader->member(__VA_ARGS__, ctx->reader->user_data) \ - : WABT_OK + : WabtResult::Ok #define RAISE_ERROR(...) raise_error(ctx, __VA_ARGS__) @@ -389,15 +389,15 @@ static void in_bytes(Context* ctx, } static bool is_valid_external_kind(uint8_t kind) { - return kind < WABT_NUM_EXTERNAL_KINDS; + return kind < kWabtExternalKindCount; } static bool is_concrete_type(WabtType type) { switch (type) { - case WABT_TYPE_I32: - case WABT_TYPE_I64: - case WABT_TYPE_F32: - case WABT_TYPE_F64: + case WabtType::I32: + case WabtType::I64: + case WabtType::F32: + case WabtType::F64: return true; default: @@ -406,7 +406,7 @@ static bool is_concrete_type(WabtType type) { } static bool is_inline_sig_type(WabtType type) { - return is_concrete_type(type) || type == WABT_TYPE_VOID; + return is_concrete_type(type) || type == WabtType::Void; } static uint32_t num_total_funcs(Context* ctx) { @@ -542,7 +542,8 @@ static WabtResult logging_begin_custom_section(WabtBinaryReaderContext* context, #define LOGGING_OPCODE(name) \ static WabtResult logging_##name(WabtOpcode opcode, void* user_data) { \ LoggingContext* ctx = static_cast<LoggingContext*>(user_data); \ - LOGF(#name "(\"%s\" (%u))\n", wabt_get_opcode_name(opcode), opcode); \ + LOGF(#name "(\"%s\" (%u))\n", wabt_get_opcode_name(opcode), \ + static_cast<unsigned>(opcode)); \ FORWARD(name, opcode); \ } @@ -890,7 +891,8 @@ static WabtResult logging_on_load_expr(WabtOpcode opcode, void* user_data) { LoggingContext* ctx = static_cast<LoggingContext*>(user_data); LOGF("on_load_expr(opcode: \"%s\" (%u), align log2: %u, offset: %u)\n", - wabt_get_opcode_name(opcode), opcode, alignment_log2, offset); + wabt_get_opcode_name(opcode), static_cast<unsigned>(opcode), + alignment_log2, offset); FORWARD(on_load_expr, opcode, alignment_log2, offset); } @@ -910,7 +912,8 @@ static WabtResult logging_on_store_expr(WabtOpcode opcode, void* user_data) { LoggingContext* ctx = static_cast<LoggingContext*>(user_data); LOGF("on_store_expr(opcode: \"%s\" (%u), align log2: %u, offset: %u)\n", - wabt_get_opcode_name(opcode), opcode, alignment_log2, offset); + wabt_get_opcode_name(opcode), static_cast<unsigned>(opcode), + alignment_log2, offset); FORWARD(on_store_expr, opcode, alignment_log2, offset); } @@ -1006,43 +1009,43 @@ static WabtResult logging_on_reloc_count(uint32_t count, static void read_init_expr(Context* ctx, uint32_t index) { uint8_t opcode; in_u8(ctx, &opcode, "opcode"); - switch (opcode) { - case WABT_OPCODE_I32_CONST: { + switch (static_cast<WabtOpcode>(opcode)) { + case WabtOpcode::I32Const: { 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 WABT_OPCODE_I64_CONST: { + case WabtOpcode::I64Const: { 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 WABT_OPCODE_F32_CONST: { + case WabtOpcode::F32Const: { 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 WABT_OPCODE_F64_CONST: { + case WabtOpcode::F64Const: { 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 WABT_OPCODE_GET_GLOBAL: { + case WabtOpcode::GetGlobal: { 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 WABT_OPCODE_END: + case WabtOpcode::End: return; default: @@ -1052,7 +1055,7 @@ static void read_init_expr(Context* ctx, uint32_t index) { } in_u8(ctx, &opcode, "opcode"); - RAISE_ERROR_UNLESS(opcode == WABT_OPCODE_END, + RAISE_ERROR_UNLESS(static_cast<WabtOpcode>(opcode) == WabtOpcode::End, "expected END opcode after initializer expression"); } @@ -1060,7 +1063,7 @@ static void read_table(Context* ctx, WabtType* out_elem_type, WabtLimits* out_elem_limits) { in_type(ctx, out_elem_type, "table elem type"); - RAISE_ERROR_UNLESS(*out_elem_type == WABT_TYPE_ANYFUNC, + RAISE_ERROR_UNLESS(*out_elem_type == WabtType::Anyfunc, "table elem type must by anyfunc"); uint32_t flags; @@ -1124,55 +1127,55 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { WabtOpcode opcode = static_cast<WabtOpcode>(opcode_u8); CALLBACK_CTX(on_opcode, opcode); switch (opcode) { - case WABT_OPCODE_UNREACHABLE: + case WabtOpcode::Unreachable: CALLBACK0(on_unreachable_expr); CALLBACK_CTX0(on_opcode_bare); break; - case WABT_OPCODE_BLOCK: { + case WabtOpcode::Block: { WabtType 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 == WABT_TYPE_VOID ? 0 : 1; + uint32_t num_types = sig_type == WabtType::Void ? 0 : 1; CALLBACK(on_block_expr, num_types, &sig_type); CALLBACK_CTX(on_opcode_block_sig, num_types, &sig_type); break; } - case WABT_OPCODE_LOOP: { + case WabtOpcode::Loop: { WabtType 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 == WABT_TYPE_VOID ? 0 : 1; + uint32_t num_types = sig_type == WabtType::Void ? 0 : 1; CALLBACK(on_loop_expr, num_types, &sig_type); CALLBACK_CTX(on_opcode_block_sig, num_types, &sig_type); break; } - case WABT_OPCODE_IF: { + case WabtOpcode::If: { WabtType 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 == WABT_TYPE_VOID ? 0 : 1; + uint32_t num_types = sig_type == WabtType::Void ? 0 : 1; CALLBACK(on_if_expr, num_types, &sig_type); CALLBACK_CTX(on_opcode_block_sig, num_types, &sig_type); break; } - case WABT_OPCODE_ELSE: + case WabtOpcode::Else: CALLBACK0(on_else_expr); CALLBACK_CTX0(on_opcode_bare); break; - case WABT_OPCODE_SELECT: + case WabtOpcode::Select: CALLBACK0(on_select_expr); CALLBACK_CTX0(on_opcode_bare); break; - case WABT_OPCODE_BR: { + case WabtOpcode::Br: { uint32_t depth; in_u32_leb128(ctx, &depth, "br depth"); CALLBACK(on_br_expr, depth); @@ -1180,7 +1183,7 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_BR_IF: { + case WabtOpcode::BrIf: { uint32_t depth; in_u32_leb128(ctx, &depth, "br_if depth"); CALLBACK(on_br_if_expr, depth); @@ -1188,7 +1191,7 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_BR_TABLE: { + case WabtOpcode::BrTable: { uint32_t num_targets; in_u32_leb128(ctx, &num_targets, "br_table target count"); if (num_targets > ctx->target_depths.capacity) { @@ -1212,29 +1215,29 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_RETURN: + case WabtOpcode::Return: CALLBACK0(on_return_expr); CALLBACK_CTX0(on_opcode_bare); break; - case WABT_OPCODE_NOP: + case WabtOpcode::Nop: CALLBACK0(on_nop_expr); CALLBACK_CTX0(on_opcode_bare); break; - case WABT_OPCODE_DROP: + case WabtOpcode::Drop: CALLBACK0(on_drop_expr); CALLBACK_CTX0(on_opcode_bare); break; - case WABT_OPCODE_END: + case WabtOpcode::End: if (ctx->offset == end_offset) seen_end_opcode = true; else CALLBACK0(on_end_expr); break; - case WABT_OPCODE_I32_CONST: { + case WabtOpcode::I32Const: { uint32_t value = 0; in_i32_leb128(ctx, &value, "i32.const value"); CALLBACK(on_i32_const_expr, value); @@ -1242,7 +1245,7 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_I64_CONST: { + case WabtOpcode::I64Const: { uint64_t value = 0; in_i64_leb128(ctx, &value, "i64.const value"); CALLBACK(on_i64_const_expr, value); @@ -1250,7 +1253,7 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_F32_CONST: { + case WabtOpcode::F32Const: { uint32_t value_bits = 0; in_f32(ctx, &value_bits, "f32.const value"); CALLBACK(on_f32_const_expr, value_bits); @@ -1258,7 +1261,7 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_F64_CONST: { + case WabtOpcode::F64Const: { uint64_t value_bits = 0; in_f64(ctx, &value_bits, "f64.const value"); CALLBACK(on_f64_const_expr, value_bits); @@ -1266,7 +1269,7 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_GET_GLOBAL: { + case WabtOpcode::GetGlobal: { uint32_t global_index; in_u32_leb128(ctx, &global_index, "get_global global index"); CALLBACK(on_get_global_expr, global_index); @@ -1274,7 +1277,7 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_GET_LOCAL: { + case WabtOpcode::GetLocal: { uint32_t local_index; in_u32_leb128(ctx, &local_index, "get_local local index"); CALLBACK(on_get_local_expr, local_index); @@ -1282,7 +1285,7 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_SET_GLOBAL: { + case WabtOpcode::SetGlobal: { uint32_t global_index; in_u32_leb128(ctx, &global_index, "set_global global index"); CALLBACK(on_set_global_expr, global_index); @@ -1290,7 +1293,7 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_SET_LOCAL: { + case WabtOpcode::SetLocal: { uint32_t local_index; in_u32_leb128(ctx, &local_index, "set_local local index"); CALLBACK(on_set_local_expr, local_index); @@ -1298,7 +1301,7 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_CALL: { + case WabtOpcode::Call: { uint32_t func_index; in_u32_leb128(ctx, &func_index, "call function index"); RAISE_ERROR_UNLESS(func_index < num_total_funcs(ctx), @@ -1308,7 +1311,7 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_CALL_INDIRECT: { + case WabtOpcode::CallIndirect: { uint32_t sig_index; in_u32_leb128(ctx, &sig_index, "call_indirect signature index"); RAISE_ERROR_UNLESS(sig_index < ctx->num_signatures, @@ -1322,7 +1325,7 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_TEE_LOCAL: { + case WabtOpcode::TeeLocal: { uint32_t local_index; in_u32_leb128(ctx, &local_index, "tee_local local index"); CALLBACK(on_tee_local_expr, local_index); @@ -1330,20 +1333,20 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_I32_LOAD8_S: - case WABT_OPCODE_I32_LOAD8_U: - case WABT_OPCODE_I32_LOAD16_S: - case WABT_OPCODE_I32_LOAD16_U: - case WABT_OPCODE_I64_LOAD8_S: - case WABT_OPCODE_I64_LOAD8_U: - case WABT_OPCODE_I64_LOAD16_S: - case WABT_OPCODE_I64_LOAD16_U: - case WABT_OPCODE_I64_LOAD32_S: - case WABT_OPCODE_I64_LOAD32_U: - case WABT_OPCODE_I32_LOAD: - case WABT_OPCODE_I64_LOAD: - case WABT_OPCODE_F32_LOAD: - case WABT_OPCODE_F64_LOAD: { + case WabtOpcode::I32Load8S: + case WabtOpcode::I32Load8U: + case WabtOpcode::I32Load16S: + case WabtOpcode::I32Load16U: + case WabtOpcode::I64Load8S: + case WabtOpcode::I64Load8U: + case WabtOpcode::I64Load16S: + case WabtOpcode::I64Load16U: + case WabtOpcode::I64Load32S: + case WabtOpcode::I64Load32U: + case WabtOpcode::I32Load: + case WabtOpcode::I64Load: + case WabtOpcode::F32Load: + case WabtOpcode::F64Load: { uint32_t alignment_log2; in_u32_leb128(ctx, &alignment_log2, "load alignment"); uint32_t offset; @@ -1354,15 +1357,15 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_I32_STORE8: - case WABT_OPCODE_I32_STORE16: - case WABT_OPCODE_I64_STORE8: - case WABT_OPCODE_I64_STORE16: - case WABT_OPCODE_I64_STORE32: - case WABT_OPCODE_I32_STORE: - case WABT_OPCODE_I64_STORE: - case WABT_OPCODE_F32_STORE: - case WABT_OPCODE_F64_STORE: { + case WabtOpcode::I32Store8: + case WabtOpcode::I32Store16: + case WabtOpcode::I64Store8: + case WabtOpcode::I64Store16: + case WabtOpcode::I64Store32: + case WabtOpcode::I32Store: + case WabtOpcode::I64Store: + case WabtOpcode::F32Store: + case WabtOpcode::F64Store: { uint32_t alignment_log2; in_u32_leb128(ctx, &alignment_log2, "store alignment"); uint32_t offset; @@ -1373,7 +1376,7 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_CURRENT_MEMORY: { + case WabtOpcode::CurrentMemory: { uint32_t reserved; in_u32_leb128(ctx, &reserved, "current_memory reserved"); RAISE_ERROR_UNLESS(reserved == 0, @@ -1383,7 +1386,7 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_GROW_MEMORY: { + case WabtOpcode::GrowMemory: { uint32_t reserved; in_u32_leb128(ctx, &reserved, "grow_memory reserved"); RAISE_ERROR_UNLESS(reserved == 0, @@ -1393,147 +1396,148 @@ static void read_function_body(Context* ctx, uint32_t end_offset) { break; } - case WABT_OPCODE_I32_ADD: - case WABT_OPCODE_I32_SUB: - case WABT_OPCODE_I32_MUL: - case WABT_OPCODE_I32_DIV_S: - case WABT_OPCODE_I32_DIV_U: - case WABT_OPCODE_I32_REM_S: - case WABT_OPCODE_I32_REM_U: - case WABT_OPCODE_I32_AND: - case WABT_OPCODE_I32_OR: - case WABT_OPCODE_I32_XOR: - case WABT_OPCODE_I32_SHL: - case WABT_OPCODE_I32_SHR_U: - case WABT_OPCODE_I32_SHR_S: - case WABT_OPCODE_I32_ROTR: - case WABT_OPCODE_I32_ROTL: - case WABT_OPCODE_I64_ADD: - case WABT_OPCODE_I64_SUB: - case WABT_OPCODE_I64_MUL: - case WABT_OPCODE_I64_DIV_S: - case WABT_OPCODE_I64_DIV_U: - case WABT_OPCODE_I64_REM_S: - case WABT_OPCODE_I64_REM_U: - case WABT_OPCODE_I64_AND: - case WABT_OPCODE_I64_OR: - case WABT_OPCODE_I64_XOR: - case WABT_OPCODE_I64_SHL: - case WABT_OPCODE_I64_SHR_U: - case WABT_OPCODE_I64_SHR_S: - case WABT_OPCODE_I64_ROTR: - case WABT_OPCODE_I64_ROTL: - case WABT_OPCODE_F32_ADD: - case WABT_OPCODE_F32_SUB: - case WABT_OPCODE_F32_MUL: - case WABT_OPCODE_F32_DIV: - case WABT_OPCODE_F32_MIN: - case WABT_OPCODE_F32_MAX: - case WABT_OPCODE_F32_COPYSIGN: - case WABT_OPCODE_F64_ADD: - case WABT_OPCODE_F64_SUB: - case WABT_OPCODE_F64_MUL: - case WABT_OPCODE_F64_DIV: - case WABT_OPCODE_F64_MIN: - case WABT_OPCODE_F64_MAX: - case WABT_OPCODE_F64_COPYSIGN: + case WabtOpcode::I32Add: + case WabtOpcode::I32Sub: + case WabtOpcode::I32Mul: + case WabtOpcode::I32DivS: + case WabtOpcode::I32DivU: + case WabtOpcode::I32RemS: + case WabtOpcode::I32RemU: + case WabtOpcode::I32And: + case WabtOpcode::I32Or: + case WabtOpcode::I32Xor: + case WabtOpcode::I32Shl: + case WabtOpcode::I32ShrU: + case WabtOpcode::I32ShrS: + case WabtOpcode::I32Rotr: + case WabtOpcode::I32Rotl: + case WabtOpcode::I64Add: + case WabtOpcode::I64Sub: + case WabtOpcode::I64Mul: + case WabtOpcode::I64DivS: + case WabtOpcode::I64DivU: + case WabtOpcode::I64RemS: + case WabtOpcode::I64RemU: + case WabtOpcode::I64And: + case WabtOpcode::I64Or: + case WabtOpcode::I64Xor: + case WabtOpcode::I64Shl: + case WabtOpcode::I64ShrU: + case WabtOpcode::I64ShrS: + case WabtOpcode::I64Rotr: + case WabtOpcode::I64Rotl: + case WabtOpcode::F32Add: + case WabtOpcode::F32Sub: + case WabtOpcode::F32Mul: + case WabtOpcode::F32Div: + case WabtOpcode::F32Min: + case WabtOpcode::F32Max: + case WabtOpcode::F32Copysign: + case WabtOpcode::F64Add: + case WabtOpcode::F64Sub: + case WabtOpcode::F64Mul: + case WabtOpcode::F64Div: + case WabtOpcode::F64Min: + case WabtOpcode::F64Max: + case WabtOpcode::F64Copysign: CALLBACK(on_binary_expr, opcode); CALLBACK_CTX0(on_opcode_bare); break; - case WABT_OPCODE_I32_EQ: - case WABT_OPCODE_I32_NE: - case WABT_OPCODE_I32_LT_S: - case WABT_OPCODE_I32_LE_S: - case WABT_OPCODE_I32_LT_U: - case WABT_OPCODE_I32_LE_U: - case WABT_OPCODE_I32_GT_S: - case WABT_OPCODE_I32_GE_S: - case WABT_OPCODE_I32_GT_U: - case WABT_OPCODE_I32_GE_U: - case WABT_OPCODE_I64_EQ: - case WABT_OPCODE_I64_NE: - case WABT_OPCODE_I64_LT_S: - case WABT_OPCODE_I64_LE_S: - case WABT_OPCODE_I64_LT_U: - case WABT_OPCODE_I64_LE_U: - case WABT_OPCODE_I64_GT_S: - case WABT_OPCODE_I64_GE_S: - case WABT_OPCODE_I64_GT_U: - case WABT_OPCODE_I64_GE_U: - case WABT_OPCODE_F32_EQ: - case WABT_OPCODE_F32_NE: - case WABT_OPCODE_F32_LT: - case WABT_OPCODE_F32_LE: - case WABT_OPCODE_F32_GT: - case WABT_OPCODE_F32_GE: - case WABT_OPCODE_F64_EQ: - case WABT_OPCODE_F64_NE: - case WABT_OPCODE_F64_LT: - case WABT_OPCODE_F64_LE: - case WABT_OPCODE_F64_GT: - case WABT_OPCODE_F64_GE: + case WabtOpcode::I32Eq: + case WabtOpcode::I32Ne: + case WabtOpcode::I32LtS: + case WabtOpcode::I32LeS: + case WabtOpcode::I32LtU: + case WabtOpcode::I32LeU: + case WabtOpcode::I32GtS: + case WabtOpcode::I32GeS: + case WabtOpcode::I32GtU: + case WabtOpcode::I32GeU: + case WabtOpcode::I64Eq: + case WabtOpcode::I64Ne: + case WabtOpcode::I64LtS: + case WabtOpcode::I64LeS: + case WabtOpcode::I64LtU: + case WabtOpcode::I64LeU: + case WabtOpcode::I64GtS: + case WabtOpcode::I64GeS: + case WabtOpcode::I64GtU: + case WabtOpcode::I64GeU: + case WabtOpcode::F32Eq: + case WabtOpcode::F32Ne: + case WabtOpcode::F32Lt: + case WabtOpcode::F32Le: + case WabtOpcode::F32Gt: + case WabtOpcode::F32Ge: + case WabtOpcode::F64Eq: + case WabtOpcode::F64Ne: + case WabtOpcode::F64Lt: + case WabtOpcode::F64Le: + case WabtOpcode::F64Gt: + case WabtOpcode::F64Ge: CALLBACK(on_compare_expr, opcode); CALLBACK_CTX0(on_opcode_bare); break; - case WABT_OPCODE_I32_CLZ: - case WABT_OPCODE_I32_CTZ: - case WABT_OPCODE_I32_POPCNT: - case WABT_OPCODE_I64_CLZ: - case WABT_OPCODE_I64_CTZ: - case WABT_OPCODE_I64_POPCNT: - case WABT_OPCODE_F32_ABS: - case WABT_OPCODE_F32_NEG: - case WABT_OPCODE_F32_CEIL: - case WABT_OPCODE_F32_FLOOR: - case WABT_OPCODE_F32_TRUNC: - case WABT_OPCODE_F32_NEAREST: - case WABT_OPCODE_F32_SQRT: - case WABT_OPCODE_F64_ABS: - case WABT_OPCODE_F64_NEG: - case WABT_OPCODE_F64_CEIL: - case WABT_OPCODE_F64_FLOOR: - case WABT_OPCODE_F64_TRUNC: - case WABT_OPCODE_F64_NEAREST: - case WABT_OPCODE_F64_SQRT: + case WabtOpcode::I32Clz: + case WabtOpcode::I32Ctz: + case WabtOpcode::I32Popcnt: + case WabtOpcode::I64Clz: + case WabtOpcode::I64Ctz: + case WabtOpcode::I64Popcnt: + case WabtOpcode::F32Abs: + case WabtOpcode::F32Neg: + case WabtOpcode::F32Ceil: + case WabtOpcode::F32Floor: + case WabtOpcode::F32Trunc: + case WabtOpcode::F32Nearest: + case WabtOpcode::F32Sqrt: + case WabtOpcode::F64Abs: + case WabtOpcode::F64Neg: + case WabtOpcode::F64Ceil: + case WabtOpcode::F64Floor: + case WabtOpcode::F64Trunc: + case WabtOpcode::F64Nearest: + case WabtOpcode::F64Sqrt: CALLBACK(on_unary_expr, opcode); CALLBACK_CTX0(on_opcode_bare); break; - case WABT_OPCODE_I32_TRUNC_S_F32: - case WABT_OPCODE_I32_TRUNC_S_F64: - case WABT_OPCODE_I32_TRUNC_U_F32: - case WABT_OPCODE_I32_TRUNC_U_F64: - case WABT_OPCODE_I32_WRAP_I64: - case WABT_OPCODE_I64_TRUNC_S_F32: - case WABT_OPCODE_I64_TRUNC_S_F64: - case WABT_OPCODE_I64_TRUNC_U_F32: - case WABT_OPCODE_I64_TRUNC_U_F64: - case WABT_OPCODE_I64_EXTEND_S_I32: - case WABT_OPCODE_I64_EXTEND_U_I32: - case WABT_OPCODE_F32_CONVERT_S_I32: - case WABT_OPCODE_F32_CONVERT_U_I32: - case WABT_OPCODE_F32_CONVERT_S_I64: - case WABT_OPCODE_F32_CONVERT_U_I64: - case WABT_OPCODE_F32_DEMOTE_F64: - case WABT_OPCODE_F32_REINTERPRET_I32: - case WABT_OPCODE_F64_CONVERT_S_I32: - case WABT_OPCODE_F64_CONVERT_U_I32: - case WABT_OPCODE_F64_CONVERT_S_I64: - case WABT_OPCODE_F64_CONVERT_U_I64: - case WABT_OPCODE_F64_PROMOTE_F32: - case WABT_OPCODE_F64_REINTERPRET_I64: - case WABT_OPCODE_I32_REINTERPRET_F32: - case WABT_OPCODE_I64_REINTERPRET_F64: - case WABT_OPCODE_I32_EQZ: - case WABT_OPCODE_I64_EQZ: + case WabtOpcode::I32TruncSF32: + case WabtOpcode::I32TruncSF64: + case WabtOpcode::I32TruncUF32: + case WabtOpcode::I32TruncUF64: + case WabtOpcode::I32WrapI64: + case WabtOpcode::I64TruncSF32: + case WabtOpcode::I64TruncSF64: + case WabtOpcode::I64TruncUF32: + case WabtOpcode::I64TruncUF64: + case WabtOpcode::I64ExtendSI32: + case WabtOpcode::I64ExtendUI32: + case WabtOpcode::F32ConvertSI32: + case WabtOpcode::F32ConvertUI32: + case WabtOpcode::F32ConvertSI64: + case WabtOpcode::F32ConvertUI64: + case WabtOpcode::F32DemoteF64: + case WabtOpcode::F32ReinterpretI32: + case WabtOpcode::F64ConvertSI32: + case WabtOpcode::F64ConvertUI32: + case WabtOpcode::F64ConvertSI64: + case WabtOpcode::F64ConvertUI64: + case WabtOpcode::F64PromoteF32: + case WabtOpcode::F64ReinterpretI64: + case WabtOpcode::I32ReinterpretF32: + case WabtOpcode::I64ReinterpretF64: + case WabtOpcode::I32Eqz: + case WabtOpcode::I64Eqz: CALLBACK(on_convert_expr, opcode); CALLBACK_CTX0(on_opcode_bare); break; default: - RAISE_ERROR("unexpected opcode: %d (0x%x)", opcode, opcode); + RAISE_ERROR("unexpected opcode: %d (0x%x)", static_cast<int>(opcode), + static_cast<unsigned>(opcode)); } } RAISE_ERROR_UNLESS(ctx->offset == end_offset, @@ -1546,7 +1550,7 @@ static void read_custom_section(Context* ctx, uint32_t section_size) { in_str(ctx, §ion_name, "section name"); CALLBACK_CTX(begin_custom_section, section_size, section_name); - bool name_section_ok = ctx->last_known_section >= WABT_BINARY_SECTION_IMPORT; + bool name_section_ok = ctx->last_known_section >= WabtBinarySection::Import; if (ctx->options->read_debug_names && name_section_ok && strncmp(section_name.start, WABT_BINARY_SECTION_NAME, section_name.length) == 0) { @@ -1576,7 +1580,7 @@ static void read_custom_section(Context* ctx, uint32_t section_size) { uint32_t i, num_relocs, section; in_u32_leb128(ctx, §ion, "section"); WABT_ZERO_MEMORY(section_name); - if (section == WABT_BINARY_SECTION_CUSTOM) + if (static_cast<WabtBinarySection>(section) == WabtBinarySection::Custom) in_str(ctx, §ion_name, "section name"); in_u32_leb128(ctx, &num_relocs, "relocation count"); CALLBACK(on_reloc_count, num_relocs, @@ -1604,7 +1608,7 @@ static void read_type_section(Context* ctx, uint32_t section_size) { for (i = 0; i < ctx->num_signatures; ++i) { WabtType form; in_type(ctx, &form, "type form"); - RAISE_ERROR_UNLESS(form == WABT_TYPE_FUNC, "unexpected type form"); + RAISE_ERROR_UNLESS(form == WabtType::Func, "unexpected type form"); uint32_t num_params; in_u32_leb128(ctx, &num_params, "function param count"); @@ -1625,7 +1629,7 @@ static void read_type_section(Context* ctx, uint32_t section_size) { in_u32_leb128(ctx, &num_results, "function result count"); RAISE_ERROR_UNLESS(num_results <= 1, "result count must be 0 or 1"); - WabtType result_type = WABT_TYPE_VOID; + WabtType result_type = WabtType::Void; if (num_results) { in_type(ctx, &result_type, "function result type"); RAISE_ERROR_UNLESS(is_concrete_type(result_type), @@ -1652,8 +1656,8 @@ static void read_import_section(Context* ctx, uint32_t section_size) { uint32_t kind; in_u32_leb128(ctx, &kind, "import kind"); - switch (kind) { - case WABT_EXTERNAL_KIND_FUNC: { + switch (static_cast<WabtExternalKind>(kind)) { + case WabtExternalKind::Func: { uint32_t sig_index; in_u32_leb128(ctx, &sig_index, "import signature index"); RAISE_ERROR_UNLESS(sig_index < ctx->num_signatures, @@ -1663,7 +1667,7 @@ static void read_import_section(Context* ctx, uint32_t section_size) { break; } - case WABT_EXTERNAL_KIND_TABLE: { + case WabtExternalKind::Table: { WabtType elem_type; WabtLimits elem_limits; read_table(ctx, &elem_type, &elem_limits); @@ -1673,7 +1677,7 @@ static void read_import_section(Context* ctx, uint32_t section_size) { break; } - case WABT_EXTERNAL_KIND_MEMORY: { + case WabtExternalKind::Memory: { WabtLimits page_limits; read_memory(ctx, &page_limits); CALLBACK(on_import_memory, i, ctx->num_memory_imports, &page_limits); @@ -1681,7 +1685,7 @@ static void read_import_section(Context* ctx, uint32_t section_size) { break; } - case WABT_EXTERNAL_KIND_GLOBAL: { + case WabtExternalKind::Global: { WabtType type; bool mutable_; read_global_header(ctx, &type, &mutable_); @@ -1780,26 +1784,23 @@ static void read_export_section(Context* ctx, uint32_t section_size) { uint32_t item_index; in_u32_leb128(ctx, &item_index, "export item index"); - switch (external_kind) { - case WABT_EXTERNAL_KIND_FUNC: + switch (static_cast<WabtExternalKind>(external_kind)) { + case WabtExternalKind::Func: RAISE_ERROR_UNLESS(item_index < num_total_funcs(ctx), "invalid export func index: %d", item_index); break; - case WABT_EXTERNAL_KIND_TABLE: + case WabtExternalKind::Table: RAISE_ERROR_UNLESS(item_index < num_total_tables(ctx), "invalid export table index"); break; - case WABT_EXTERNAL_KIND_MEMORY: + case WabtExternalKind::Memory: RAISE_ERROR_UNLESS(item_index < num_total_memories(ctx), "invalid export memory index"); break; - case WABT_EXTERNAL_KIND_GLOBAL: + case WabtExternalKind::Global: RAISE_ERROR_UNLESS(item_index < num_total_globals(ctx), "invalid export global index"); break; - case WABT_NUM_EXTERNAL_KINDS: - assert(0); - break; } CALLBACK(on_export, i, static_cast<WabtExternalKind>(external_kind), @@ -1919,9 +1920,9 @@ static void read_sections(Context* ctx) { in_u32_leb128(ctx, §ion_code, "section code"); in_u32_leb128(ctx, §ion_size, "section size"); ctx->read_end = ctx->offset + section_size; - if (section_code >= WABT_NUM_BINARY_SECTIONS) { + if (section_code >= kWabtBinarySectionCount) { RAISE_ERROR("invalid section code: %u; max is %u", section_code, - WABT_NUM_BINARY_SECTIONS - 1); + kWabtBinarySectionCount - 1); } WabtBinarySection section = static_cast<WabtBinarySection>(section_code); @@ -1929,16 +1930,16 @@ static void read_sections(Context* ctx) { if (ctx->read_end > ctx->data_size) RAISE_ERROR("invalid section size: extends past end"); - if (ctx->last_known_section != WABT_NUM_BINARY_SECTIONS && - section != WABT_BINARY_SECTION_CUSTOM && - section_code <= ctx->last_known_section) { + if (ctx->last_known_section != WabtBinarySection::Invalid && + section != WabtBinarySection::Custom && + section <= ctx->last_known_section) { RAISE_ERROR("section %s out of order", wabt_get_section_name(section)); } CALLBACK_CTX(begin_section, section, section_size); -#define V(NAME, name, code) \ - case WABT_BINARY_SECTION_##NAME: \ +#define V(Name, name, code) \ + case WabtBinarySection::Name: \ read_##name##_section(ctx, section_size); \ break; @@ -1957,7 +1958,7 @@ static void read_sections(Context* ctx) { ctx->read_end); } - if (section != WABT_BINARY_SECTION_CUSTOM) + if (section != WabtBinarySection::Custom) ctx->last_known_section = section; } } @@ -2132,11 +2133,11 @@ WabtResult wabt_read_binary(const void* data, ctx->data_size = ctx->read_end = size; ctx->reader = options->log_stream ? &logging_reader : reader; ctx->options = options; - ctx->last_known_section = WABT_NUM_BINARY_SECTIONS; + ctx->last_known_section = WabtBinarySection::Invalid; if (setjmp(ctx->error_jmp_buf) == 1) { destroy_context(ctx); - return WABT_ERROR; + return WabtResult::Error; } wabt_reserve_types(&ctx->param_types, INITIAL_PARAM_TYPES_CAPACITY); @@ -2155,5 +2156,5 @@ WabtResult wabt_read_binary(const void* data, read_sections(ctx); CALLBACK0(end_module); destroy_context(ctx); - return WABT_OK; + return WabtResult::Ok; } diff --git a/src/binary-writer-spec.cc b/src/binary-writer-spec.cc index d3696d97..4d2799cb 100644 --- a/src/binary-writer-spec.cc +++ b/src/binary-writer-spec.cc @@ -148,12 +148,11 @@ static void write_command_type(Context* ctx, const WabtCommand* command) { "assert_trap", "assert_exhaustion", }; - WABT_STATIC_ASSERT(WABT_ARRAY_SIZE(s_command_names) == - WABT_NUM_COMMAND_TYPES); + WABT_STATIC_ASSERT(WABT_ARRAY_SIZE(s_command_names) == kWabtCommandTypeCount); write_key(ctx, "type"); - assert(s_command_names[command->type]); - write_string(ctx, s_command_names[command->type]); + assert(s_command_names[static_cast<size_t>(command->type)]); + write_string(ctx, s_command_names[static_cast<size_t>(command->type)]); } static void write_location(Context* ctx, const WabtLocation* loc) { @@ -162,7 +161,7 @@ static void write_location(Context* ctx, const WabtLocation* loc) { } static void write_var(Context* ctx, const WabtVar* var) { - if (var->type == WABT_VAR_TYPE_INDEX) + if (var->type == WabtVarType::Index) wabt_writef(&ctx->json_stream, "\"%" PRIu64 "\"", var->index); else write_escaped_string_slice(ctx, var->name); @@ -182,21 +181,21 @@ static void write_const(Context* ctx, const WabtConst* const_) { /* Always write the values as strings, even though they may be representable * as JSON numbers. This way the formatting is consistent. */ switch (const_->type) { - case WABT_TYPE_I32: + case WabtType::I32: write_string(ctx, "i32"); write_separator(ctx); write_key(ctx, "value"); wabt_writef(&ctx->json_stream, "\"%u\"", const_->u32); break; - case WABT_TYPE_I64: + case WabtType::I64: write_string(ctx, "i64"); write_separator(ctx); write_key(ctx, "value"); wabt_writef(&ctx->json_stream, "\"%" PRIu64 "\"", const_->u64); break; - case WABT_TYPE_F32: { + case WabtType::F32: { /* TODO(binji): write as hex float */ write_string(ctx, "f32"); write_separator(ctx); @@ -205,7 +204,7 @@ static void write_const(Context* ctx, const WabtConst* const_) { break; } - case WABT_TYPE_F64: { + case WabtType::F64: { /* TODO(binji): write as hex float */ write_string(ctx, "f64"); write_separator(ctx); @@ -237,19 +236,19 @@ static void write_action(Context* ctx, const WabtAction* action) { write_key(ctx, "action"); wabt_writef(&ctx->json_stream, "{"); write_key(ctx, "type"); - if (action->type == WABT_ACTION_TYPE_INVOKE) { + if (action->type == WabtActionType::Invoke) { write_string(ctx, "invoke"); } else { - assert(action->type == WABT_ACTION_TYPE_GET); + assert(action->type == WabtActionType::Get); write_string(ctx, "get"); } write_separator(ctx); - if (action->module_var.type != WABT_VAR_TYPE_INDEX) { + if (action->module_var.type != WabtVarType::Index) { write_key(ctx, "module"); write_var(ctx, &action->module_var); write_separator(ctx); } - if (action->type == WABT_ACTION_TYPE_INVOKE) { + if (action->type == WabtActionType::Invoke) { write_key(ctx, "field"); write_escaped_string_slice(ctx, action->invoke.name); write_separator(ctx); @@ -270,9 +269,9 @@ static void write_action_result_type(Context* ctx, const WabtExport* export_; wabt_writef(&ctx->json_stream, "["); switch (action->type) { - case WABT_ACTION_TYPE_INVOKE: { + case WabtActionType::Invoke: { export_ = wabt_get_export_by_name(module, &action->invoke.name); - assert(export_->kind == WABT_EXTERNAL_KIND_FUNC); + assert(export_->kind == WabtExternalKind::Func); WabtFunc* func = wabt_get_func_by_var(module, &export_->var); size_t num_results = wabt_get_num_results(func); size_t i; @@ -281,9 +280,9 @@ static void write_action_result_type(Context* ctx, break; } - case WABT_ACTION_TYPE_GET: { + case WabtActionType::Get: { export_ = wabt_get_export_by_name(module, &action->get.name); - assert(export_->kind == WABT_EXTERNAL_KIND_GLOBAL); + assert(export_->kind == WabtExternalKind::Global); WabtGlobal* global = wabt_get_global_by_var(module, &export_->var); write_type_object(ctx, global->type); break; @@ -311,7 +310,7 @@ static void write_module(Context* ctx, static void write_raw_module(Context* ctx, char* filename, const WabtRawModule* raw_module) { - if (raw_module->type == WABT_RAW_MODULE_TYPE_TEXT) { + if (raw_module->type == WabtRawModuleType::Text) { write_module(ctx, filename, raw_module->text); } else if (ctx->write_modules) { WabtFileStream stream; @@ -350,7 +349,7 @@ static void write_commands(Context* ctx, WabtScript* script) { for (i = 0; i < script->commands.size; ++i) { WabtCommand* command = &script->commands.data[i]; - if (command->type == WABT_COMMAND_TYPE_ASSERT_INVALID_NON_BINARY) + if (command->type == WabtCommandType::AssertInvalidNonBinary) continue; if (i != 0) @@ -362,7 +361,7 @@ static void write_commands(Context* ctx, WabtScript* script) { write_separator(ctx); switch (command->type) { - case WABT_COMMAND_TYPE_MODULE: { + case WabtCommandType::Module: { WabtModule* module = &command->module; char* filename = get_module_filename(ctx); write_location(ctx, &module->loc); @@ -381,16 +380,16 @@ static void write_commands(Context* ctx, WabtScript* script) { break; } - case WABT_COMMAND_TYPE_ACTION: + case WabtCommandType::Action: write_location(ctx, &command->action.loc); write_separator(ctx); write_action(ctx, &command->action); break; - case WABT_COMMAND_TYPE_REGISTER: + case WabtCommandType::Register: write_location(ctx, &command->register_.var.loc); write_separator(ctx); - if (command->register_.var.type == WABT_VAR_TYPE_NAME) { + if (command->register_.var.type == WabtVarType::Name) { write_key(ctx, "name"); write_var(ctx, &command->register_.var); write_separator(ctx); @@ -404,31 +403,31 @@ static void write_commands(Context* ctx, WabtScript* script) { write_escaped_string_slice(ctx, command->register_.module_name); break; - case WABT_COMMAND_TYPE_ASSERT_MALFORMED: + case WabtCommandType::AssertMalformed: write_invalid_module(ctx, &command->assert_malformed.module, command->assert_malformed.text); ctx->num_modules++; break; - case WABT_COMMAND_TYPE_ASSERT_INVALID: + case WabtCommandType::AssertInvalid: write_invalid_module(ctx, &command->assert_invalid.module, command->assert_invalid.text); ctx->num_modules++; break; - case WABT_COMMAND_TYPE_ASSERT_UNLINKABLE: + case WabtCommandType::AssertUnlinkable: write_invalid_module(ctx, &command->assert_unlinkable.module, command->assert_unlinkable.text); ctx->num_modules++; break; - case WABT_COMMAND_TYPE_ASSERT_UNINSTANTIABLE: + case WabtCommandType::AssertUninstantiable: write_invalid_module(ctx, &command->assert_uninstantiable.module, command->assert_uninstantiable.text); ctx->num_modules++; break; - case WABT_COMMAND_TYPE_ASSERT_RETURN: + case WabtCommandType::AssertReturn: write_location(ctx, &command->assert_return.action.loc); write_separator(ctx); write_action(ctx, &command->assert_return.action); @@ -437,7 +436,7 @@ static void write_commands(Context* ctx, WabtScript* script) { write_const_vector(ctx, &command->assert_return.expected); break; - case WABT_COMMAND_TYPE_ASSERT_RETURN_NAN: + case WabtCommandType::AssertReturnNan: write_location(ctx, &command->assert_return_nan.action.loc); write_separator(ctx); write_action(ctx, &command->assert_return_nan.action); @@ -447,7 +446,7 @@ static void write_commands(Context* ctx, WabtScript* script) { &command->assert_return_nan.action); break; - case WABT_COMMAND_TYPE_ASSERT_TRAP: + case WabtCommandType::AssertTrap: write_location(ctx, &command->assert_trap.action.loc); write_separator(ctx); write_action(ctx, &command->assert_trap.action); @@ -456,14 +455,13 @@ static void write_commands(Context* ctx, WabtScript* script) { write_escaped_string_slice(ctx, command->assert_trap.text); break; - case WABT_COMMAND_TYPE_ASSERT_EXHAUSTION: + case WabtCommandType::AssertExhaustion: write_location(ctx, &command->assert_trap.action.loc); write_separator(ctx); write_action(ctx, &command->assert_trap.action); break; - case WABT_COMMAND_TYPE_ASSERT_INVALID_NON_BINARY: - case WABT_NUM_COMMAND_TYPES: + case WabtCommandType::AssertInvalidNonBinary: assert(0); break; } @@ -481,7 +479,7 @@ WabtResult wabt_write_binary_spec_script( Context ctx; WABT_ZERO_MEMORY(ctx); ctx.spec_options = spec_options; - ctx.result = WABT_OK; + ctx.result = WabtResult::Ok; ctx.source_filename.start = source_filename; ctx.source_filename.length = strlen(source_filename); ctx.module_filename_noext = strip_extension( diff --git a/src/binary-writer.cc b/src/binary-writer.cc index 172fc9fc..b1bf49f9 100644 --- a/src/binary-writer.cc +++ b/src/binary-writer.cc @@ -118,7 +118,7 @@ uint32_t wabt_write_u32_leb128_at(WabtStream* stream, uint32_t i = 0; LEB128_LOOP_UNTIL(value == 0); uint32_t length = i; - wabt_write_data_at(stream, offset, data, length, WABT_DONT_PRINT_CHARS, desc); + wabt_write_data_at(stream, offset, data, length, WabtPrintChars::No, desc); return length; } @@ -142,7 +142,7 @@ uint32_t wabt_write_fixed_u32_leb128_at(WabtStream* stream, uint8_t data[MAX_U32_LEB128_BYTES]; uint32_t length = wabt_write_fixed_u32_leb128_raw(data, data + MAX_U32_LEB128_BYTES, value); - wabt_write_data_at(stream, offset, data, length, WABT_DONT_PRINT_CHARS, desc); + wabt_write_data_at(stream, offset, data, length, WabtPrintChars::No, desc); return length; } @@ -174,7 +174,7 @@ void wabt_write_i32_leb128(WabtStream* stream, uint32_t length = i; wabt_write_data_at(stream, stream->offset, data, length, - WABT_DONT_PRINT_CHARS, desc); + WabtPrintChars::No, desc); stream->offset += length; } @@ -190,7 +190,7 @@ static void write_i64_leb128(WabtStream* stream, int length = i; wabt_write_data_at(stream, stream->offset, data, length, - WABT_DONT_PRINT_CHARS, desc); + WabtPrintChars::No, desc); stream->offset += length; } @@ -249,17 +249,17 @@ void wabt_write_str(WabtStream* stream, } void wabt_write_opcode(WabtStream* stream, WabtOpcode opcode) { - wabt_write_u8(stream, opcode, wabt_get_opcode_name(opcode)); + wabt_write_u8_enum(stream, opcode, wabt_get_opcode_name(opcode)); } void wabt_write_type(WabtStream* stream, WabtType type) { - wabt_write_i32_leb128(stream, type, wabt_get_type_name(type)); + wabt_write_i32_leb128_enum(stream, type, wabt_get_type_name(type)); } static void write_inline_signature_type(WabtStream* stream, const WabtBlockSignature* sig) { if (sig->size == 0) { - wabt_write_type(stream, WABT_TYPE_VOID); + wabt_write_type(stream, WabtType::Void); } else if (sig->size == 1) { wabt_write_type(stream, sig->data[0]); } else { @@ -274,9 +274,10 @@ static void begin_known_section(Context* ctx, assert(ctx->last_section_leb_size_guess == 0); char desc[100]; wabt_snprintf(desc, sizeof(desc), "section \"%s\" (%u)", - wabt_get_section_name(section_code), section_code); + wabt_get_section_name(section_code), + static_cast<unsigned>(section_code)); write_header(ctx, desc, PRINT_HEADER_NO_INDEX); - wabt_write_u8(&ctx->stream, section_code, "section code"); + wabt_write_u8_enum(&ctx->stream, section_code, "section code"); ctx->last_section_type = section_code; ctx->last_section_leb_size_guess = leb_size_guess; ctx->last_section_offset = @@ -291,14 +292,14 @@ static void begin_custom_section(Context* ctx, char desc[100]; wabt_snprintf(desc, sizeof(desc), "section \"%s\"", name); write_header(ctx, desc, PRINT_HEADER_NO_INDEX); - wabt_write_u8(&ctx->stream, WABT_BINARY_SECTION_CUSTOM, - "custom section code"); - ctx->last_section_type = WABT_BINARY_SECTION_CUSTOM; + wabt_write_u8_enum(&ctx->stream, WabtBinarySection::Custom, + "custom section code"); + ctx->last_section_type = WabtBinarySection::Custom; ctx->last_section_leb_size_guess = leb_size_guess; ctx->last_section_offset = write_u32_leb128_space(ctx, leb_size_guess, "section size (guess)"); ctx->last_section_payload_offset = ctx->stream.offset; - wabt_write_str(&ctx->stream, name, strlen(name), WABT_PRINT_CHARS, + wabt_write_str(&ctx->stream, name, strlen(name), WabtPrintChars::Yes, "custom section name"); } @@ -311,7 +312,7 @@ static void end_section(Context* ctx) { } static uint32_t get_label_var_depth(Context* ctx, const WabtVar* var) { - assert(var->type == WABT_VAR_TYPE_INDEX); + assert(var->type == WabtVarType::Index); return var->index; } @@ -354,28 +355,28 @@ static void write_expr(Context* ctx, const WabtFunc* func, const WabtExpr* expr) { switch (expr->type) { - case WABT_EXPR_TYPE_BINARY: + case WabtExprType::Binary: wabt_write_opcode(&ctx->stream, expr->binary.opcode); break; - case WABT_EXPR_TYPE_BLOCK: - wabt_write_opcode(&ctx->stream, WABT_OPCODE_BLOCK); + case WabtExprType::Block: + wabt_write_opcode(&ctx->stream, WabtOpcode::Block); write_inline_signature_type(&ctx->stream, &expr->block.sig); write_expr_list(ctx, module, func, expr->block.first); - wabt_write_opcode(&ctx->stream, WABT_OPCODE_END); + wabt_write_opcode(&ctx->stream, WabtOpcode::End); break; - case WABT_EXPR_TYPE_BR: - wabt_write_opcode(&ctx->stream, WABT_OPCODE_BR); + case WabtExprType::Br: + wabt_write_opcode(&ctx->stream, WabtOpcode::Br); wabt_write_u32_leb128( &ctx->stream, get_label_var_depth(ctx, &expr->br.var), "break depth"); break; - case WABT_EXPR_TYPE_BR_IF: - wabt_write_opcode(&ctx->stream, WABT_OPCODE_BR_IF); + case WabtExprType::BrIf: + wabt_write_opcode(&ctx->stream, WabtOpcode::BrIf); wabt_write_u32_leb128(&ctx->stream, get_label_var_depth(ctx, &expr->br_if.var), "break depth"); break; - case WABT_EXPR_TYPE_BR_TABLE: { - wabt_write_opcode(&ctx->stream, WABT_OPCODE_BR_TABLE); + case WabtExprType::BrTable: { + wabt_write_opcode(&ctx->stream, WabtOpcode::BrTable); wabt_write_u32_leb128(&ctx->stream, expr->br_table.targets.size, "num targets"); size_t i; @@ -388,146 +389,139 @@ static void write_expr(Context* ctx, wabt_write_u32_leb128(&ctx->stream, depth, "break depth for default"); break; } - case WABT_EXPR_TYPE_CALL: { + case WabtExprType::Call: { int index = wabt_get_func_index_by_var(module, &expr->call.var); - wabt_write_opcode(&ctx->stream, WABT_OPCODE_CALL); + wabt_write_opcode(&ctx->stream, WabtOpcode::Call); write_u32_leb128_with_reloc(ctx, index, "function index", - WABT_RELOC_FUNC_INDEX_LEB); + WabtRelocType::FuncIndexLeb); break; } - case WABT_EXPR_TYPE_CALL_INDIRECT: { + case WabtExprType::CallIndirect: { int index = wabt_get_func_type_index_by_var(module, &expr->call_indirect.var); - wabt_write_opcode(&ctx->stream, WABT_OPCODE_CALL_INDIRECT); + wabt_write_opcode(&ctx->stream, WabtOpcode::CallIndirect); wabt_write_u32_leb128(&ctx->stream, index, "signature index"); wabt_write_u32_leb128(&ctx->stream, 0, "call_indirect reserved"); break; } - case WABT_EXPR_TYPE_COMPARE: + case WabtExprType::Compare: wabt_write_opcode(&ctx->stream, expr->compare.opcode); break; - case WABT_EXPR_TYPE_CONST: + case WabtExprType::Const: switch (expr->const_.type) { - case WABT_TYPE_I32: { - wabt_write_opcode(&ctx->stream, WABT_OPCODE_I32_CONST); - wabt_write_i32_leb128(&ctx->stream, - static_cast<int32_t>(expr->const_.u32), - "i32 literal"); + case WabtType::I32: { + wabt_write_opcode(&ctx->stream, WabtOpcode::I32Const); + wabt_write_i32_leb128(&ctx->stream, expr->const_.u32, "i32 literal"); break; } - case WABT_TYPE_I64: - wabt_write_opcode(&ctx->stream, WABT_OPCODE_I64_CONST); - write_i64_leb128(&ctx->stream, static_cast<int64_t>(expr->const_.u64), - "i64 literal"); + case WabtType::I64: + wabt_write_opcode(&ctx->stream, WabtOpcode::I64Const); + write_i64_leb128(&ctx->stream, expr->const_.u64, "i64 literal"); break; - case WABT_TYPE_F32: - wabt_write_opcode(&ctx->stream, WABT_OPCODE_F32_CONST); + case WabtType::F32: + wabt_write_opcode(&ctx->stream, WabtOpcode::F32Const); wabt_write_u32(&ctx->stream, expr->const_.f32_bits, "f32 literal"); break; - case WABT_TYPE_F64: - wabt_write_opcode(&ctx->stream, WABT_OPCODE_F64_CONST); + case WabtType::F64: + wabt_write_opcode(&ctx->stream, WabtOpcode::F64Const); wabt_write_u64(&ctx->stream, expr->const_.f64_bits, "f64 literal"); break; default: assert(0); } break; - case WABT_EXPR_TYPE_CONVERT: + case WabtExprType::Convert: wabt_write_opcode(&ctx->stream, expr->convert.opcode); break; - case WABT_EXPR_TYPE_CURRENT_MEMORY: - wabt_write_opcode(&ctx->stream, WABT_OPCODE_CURRENT_MEMORY); + case WabtExprType::CurrentMemory: + wabt_write_opcode(&ctx->stream, WabtOpcode::CurrentMemory); wabt_write_u32_leb128(&ctx->stream, 0, "current_memory reserved"); break; - case WABT_EXPR_TYPE_DROP: - wabt_write_opcode(&ctx->stream, WABT_OPCODE_DROP); + case WabtExprType::Drop: + wabt_write_opcode(&ctx->stream, WabtOpcode::Drop); break; - case WABT_EXPR_TYPE_GET_GLOBAL: { + case WabtExprType::GetGlobal: { int index = wabt_get_global_index_by_var(module, &expr->get_global.var); - wabt_write_opcode(&ctx->stream, WABT_OPCODE_GET_GLOBAL); + wabt_write_opcode(&ctx->stream, WabtOpcode::GetGlobal); write_u32_leb128_with_reloc(ctx, index, "global index", - WABT_RELOC_GLOBAL_INDEX_LEB); + WabtRelocType::GlobalIndexLeb); break; } - case WABT_EXPR_TYPE_GET_LOCAL: { + case WabtExprType::GetLocal: { int index = wabt_get_local_index_by_var(func, &expr->get_local.var); - wabt_write_opcode(&ctx->stream, WABT_OPCODE_GET_LOCAL); + wabt_write_opcode(&ctx->stream, WabtOpcode::GetLocal); wabt_write_u32_leb128(&ctx->stream, index, "local index"); break; } - case WABT_EXPR_TYPE_GROW_MEMORY: - wabt_write_opcode(&ctx->stream, WABT_OPCODE_GROW_MEMORY); + case WabtExprType::GrowMemory: + wabt_write_opcode(&ctx->stream, WabtOpcode::GrowMemory); wabt_write_u32_leb128(&ctx->stream, 0, "grow_memory reserved"); break; - case WABT_EXPR_TYPE_IF: - wabt_write_opcode(&ctx->stream, WABT_OPCODE_IF); + case WabtExprType::If: + wabt_write_opcode(&ctx->stream, WabtOpcode::If); write_inline_signature_type(&ctx->stream, &expr->if_.true_.sig); write_expr_list(ctx, module, func, expr->if_.true_.first); if (expr->if_.false_) { - wabt_write_opcode(&ctx->stream, WABT_OPCODE_ELSE); + wabt_write_opcode(&ctx->stream, WabtOpcode::Else); write_expr_list(ctx, module, func, expr->if_.false_); } - wabt_write_opcode(&ctx->stream, WABT_OPCODE_END); + wabt_write_opcode(&ctx->stream, WabtOpcode::End); break; - case WABT_EXPR_TYPE_LOAD: { + case WabtExprType::Load: { wabt_write_opcode(&ctx->stream, expr->load.opcode); uint32_t align = wabt_get_opcode_alignment(expr->load.opcode, expr->load.align); wabt_write_u8(&ctx->stream, log2_u32(align), "alignment"); - wabt_write_u32_leb128(&ctx->stream, - static_cast<uint32_t>(expr->load.offset), - "load offset"); + wabt_write_u32_leb128(&ctx->stream, expr->load.offset, "load offset"); break; } - case WABT_EXPR_TYPE_LOOP: - wabt_write_opcode(&ctx->stream, WABT_OPCODE_LOOP); + case WabtExprType::Loop: + wabt_write_opcode(&ctx->stream, WabtOpcode::Loop); write_inline_signature_type(&ctx->stream, &expr->loop.sig); write_expr_list(ctx, module, func, expr->loop.first); - wabt_write_opcode(&ctx->stream, WABT_OPCODE_END); + wabt_write_opcode(&ctx->stream, WabtOpcode::End); break; - case WABT_EXPR_TYPE_NOP: - wabt_write_opcode(&ctx->stream, WABT_OPCODE_NOP); + case WabtExprType::Nop: + wabt_write_opcode(&ctx->stream, WabtOpcode::Nop); break; - case WABT_EXPR_TYPE_RETURN: - wabt_write_opcode(&ctx->stream, WABT_OPCODE_RETURN); + case WabtExprType::Return: + wabt_write_opcode(&ctx->stream, WabtOpcode::Return); break; - case WABT_EXPR_TYPE_SELECT: - wabt_write_opcode(&ctx->stream, WABT_OPCODE_SELECT); + case WabtExprType::Select: + wabt_write_opcode(&ctx->stream, WabtOpcode::Select); break; - case WABT_EXPR_TYPE_SET_GLOBAL: { + case WabtExprType::SetGlobal: { int index = wabt_get_global_index_by_var(module, &expr->get_global.var); - wabt_write_opcode(&ctx->stream, WABT_OPCODE_SET_GLOBAL); + wabt_write_opcode(&ctx->stream, WabtOpcode::SetGlobal); write_u32_leb128_with_reloc(ctx, index, "global index", - WABT_RELOC_GLOBAL_INDEX_LEB); + WabtRelocType::GlobalIndexLeb); break; } - case WABT_EXPR_TYPE_SET_LOCAL: { + case WabtExprType::SetLocal: { int index = wabt_get_local_index_by_var(func, &expr->get_local.var); - wabt_write_opcode(&ctx->stream, WABT_OPCODE_SET_LOCAL); + wabt_write_opcode(&ctx->stream, WabtOpcode::SetLocal); wabt_write_u32_leb128(&ctx->stream, index, "local index"); break; } - case WABT_EXPR_TYPE_STORE: { + case WabtExprType::Store: { wabt_write_opcode(&ctx->stream, expr->store.opcode); uint32_t align = wabt_get_opcode_alignment(expr->store.opcode, expr->store.align); wabt_write_u8(&ctx->stream, log2_u32(align), "alignment"); - wabt_write_u32_leb128(&ctx->stream, - static_cast<uint32_t>(expr->store.offset), - "store offset"); + wabt_write_u32_leb128(&ctx->stream, expr->store.offset, "store offset"); break; } - case WABT_EXPR_TYPE_TEE_LOCAL: { + case WabtExprType::TeeLocal: { int index = wabt_get_local_index_by_var(func, &expr->get_local.var); - wabt_write_opcode(&ctx->stream, WABT_OPCODE_TEE_LOCAL); + wabt_write_opcode(&ctx->stream, WabtOpcode::TeeLocal); wabt_write_u32_leb128(&ctx->stream, index, "local index"); break; } - case WABT_EXPR_TYPE_UNARY: + case WabtExprType::Unary: wabt_write_opcode(&ctx->stream, expr->unary.opcode); break; - case WABT_EXPR_TYPE_UNREACHABLE: - wabt_write_opcode(&ctx->stream, WABT_OPCODE_UNREACHABLE); + case WabtExprType::Unreachable: + wabt_write_opcode(&ctx->stream, WabtOpcode::Unreachable); break; } } @@ -546,7 +540,7 @@ static void write_init_expr(Context* ctx, const WabtExpr* expr) { if (expr) write_expr_list(ctx, module, nullptr, expr); - wabt_write_opcode(&ctx->stream, WABT_OPCODE_END); + wabt_write_opcode(&ctx->stream, WabtOpcode::End); } static void write_func_locals(Context* ctx, @@ -582,7 +576,7 @@ static void write_func_locals(Context* ctx, uint32_t local_type_count = 1; for (i = FIRST_LOCAL_INDEX + 1; i <= LAST_LOCAL_INDEX; ++i) { /* loop through an extra time to catch the final type transition */ - WabtType type = i == LAST_LOCAL_INDEX ? WABT_TYPE_VOID : GET_LOCAL_TYPE(i); + WabtType type = i == LAST_LOCAL_INDEX ? WabtType::Void : GET_LOCAL_TYPE(i); if (current_type == type) { local_type_count++; } else { @@ -599,7 +593,7 @@ static void write_func(Context* ctx, const WabtFunc* func) { write_func_locals(ctx, module, func, &func->local_types); write_expr_list(ctx, module, func, func->first_expr); - wabt_write_opcode(&ctx->stream, WABT_OPCODE_END); + wabt_write_opcode(&ctx->stream, WabtOpcode::End); } void wabt_write_limits(WabtStream* stream, const WabtLimits* limits) { @@ -611,7 +605,7 @@ void wabt_write_limits(WabtStream* stream, const WabtLimits* limits) { } static void write_table(Context* ctx, const WabtTable* table) { - wabt_write_type(&ctx->stream, WABT_TYPE_ANYFUNC); + wabt_write_type(&ctx->stream, WabtType::Anyfunc); wabt_write_limits(&ctx->stream, &table->elem_limits); } @@ -629,14 +623,15 @@ static void write_reloc_section(Context* ctx, RelocSection* reloc_section) { wabt_snprintf(section_name, sizeof(section_name), "%s.%s", WABT_BINARY_SECTION_RELOC, reloc_section->name); begin_custom_section(ctx, section_name, LEB_SECTION_SIZE_GUESS); - wabt_write_u32_leb128(&ctx->stream, reloc_section->section_code, - "reloc section type"); + wabt_write_u32_leb128_enum(&ctx->stream, reloc_section->section_code, + "reloc section type"); RelocVector* relocs = &reloc_section->relocations; wabt_write_u32_leb128(&ctx->stream, relocs->size, "num relocs"); size_t i; for (i = 0; i < relocs->size; i++) { - wabt_write_u32_leb128(&ctx->stream, relocs->data[i].type, "reloc type"); + wabt_write_u32_leb128_enum(&ctx->stream, relocs->data[i].type, + "reloc type"); wabt_write_u32_leb128(&ctx->stream, relocs->data[i].offset, "reloc offset"); } @@ -649,13 +644,13 @@ static WabtResult write_module(Context* ctx, const WabtModule* module) { wabt_write_u32(&ctx->stream, WABT_BINARY_VERSION, "WASM_BINARY_VERSION"); if (module->func_types.size) { - begin_known_section(ctx, WABT_BINARY_SECTION_TYPE, LEB_SECTION_SIZE_GUESS); + begin_known_section(ctx, WabtBinarySection::Type, LEB_SECTION_SIZE_GUESS); wabt_write_u32_leb128(&ctx->stream, module->func_types.size, "num types"); for (i = 0; i < module->func_types.size; ++i) { const WabtFuncType* func_type = module->func_types.data[i]; const WabtFuncSignature* sig = &func_type->sig; write_header(ctx, "type", i); - wabt_write_type(&ctx->stream, WABT_TYPE_FUNC); + wabt_write_type(&ctx->stream, WabtType::Func); size_t j; uint32_t num_params = sig->param_types.size; @@ -672,38 +667,34 @@ static WabtResult write_module(Context* ctx, const WabtModule* module) { } if (module->imports.size) { - begin_known_section(ctx, WABT_BINARY_SECTION_IMPORT, - LEB_SECTION_SIZE_GUESS); + begin_known_section(ctx, WabtBinarySection::Import, LEB_SECTION_SIZE_GUESS); wabt_write_u32_leb128(&ctx->stream, module->imports.size, "num imports"); for (i = 0; i < module->imports.size; ++i) { const WabtImport* import = module->imports.data[i]; write_header(ctx, "import header", i); wabt_write_str(&ctx->stream, import->module_name.start, - import->module_name.length, WABT_PRINT_CHARS, + import->module_name.length, WabtPrintChars::Yes, "import module name"); wabt_write_str(&ctx->stream, import->field_name.start, - import->field_name.length, WABT_PRINT_CHARS, + import->field_name.length, WabtPrintChars::Yes, "import field name"); - wabt_write_u8(&ctx->stream, import->kind, "import kind"); + wabt_write_u8_enum(&ctx->stream, import->kind, "import kind"); switch (import->kind) { - case WABT_EXTERNAL_KIND_FUNC: + case WabtExternalKind::Func: wabt_write_u32_leb128(&ctx->stream, wabt_get_func_type_index_by_decl( module, &import->func.decl), "import signature index"); break; - case WABT_EXTERNAL_KIND_TABLE: + case WabtExternalKind::Table: write_table(ctx, &import->table); break; - case WABT_EXTERNAL_KIND_MEMORY: + case WabtExternalKind::Memory: write_memory(ctx, &import->memory); break; - case WABT_EXTERNAL_KIND_GLOBAL: + case WabtExternalKind::Global: write_global_header(ctx, &import->global); break; - case WABT_NUM_EXTERNAL_KINDS: - assert(0); - break; } } end_section(ctx); @@ -712,7 +703,7 @@ static WabtResult write_module(Context* ctx, const WabtModule* module) { assert(module->funcs.size >= module->num_func_imports); uint32_t num_funcs = module->funcs.size - module->num_func_imports; if (num_funcs) { - begin_known_section(ctx, WABT_BINARY_SECTION_FUNCTION, + begin_known_section(ctx, WabtBinarySection::Function, LEB_SECTION_SIZE_GUESS); wabt_write_u32_leb128(&ctx->stream, num_funcs, "num functions"); @@ -731,7 +722,7 @@ static WabtResult write_module(Context* ctx, const WabtModule* module) { assert(module->tables.size >= module->num_table_imports); uint32_t num_tables = module->tables.size - module->num_table_imports; if (num_tables) { - begin_known_section(ctx, WABT_BINARY_SECTION_TABLE, LEB_SECTION_SIZE_GUESS); + begin_known_section(ctx, WabtBinarySection::Table, LEB_SECTION_SIZE_GUESS); wabt_write_u32_leb128(&ctx->stream, num_tables, "num tables"); for (i = 0; i < num_tables; ++i) { const WabtTable* table = @@ -745,8 +736,7 @@ static WabtResult write_module(Context* ctx, const WabtModule* module) { assert(module->memories.size >= module->num_memory_imports); uint32_t num_memories = module->memories.size - module->num_memory_imports; if (num_memories) { - begin_known_section(ctx, WABT_BINARY_SECTION_MEMORY, - LEB_SECTION_SIZE_GUESS); + begin_known_section(ctx, WabtBinarySection::Memory, LEB_SECTION_SIZE_GUESS); wabt_write_u32_leb128(&ctx->stream, num_memories, "num memories"); for (i = 0; i < num_memories; ++i) { const WabtMemory* memory = @@ -760,8 +750,7 @@ static WabtResult write_module(Context* ctx, const WabtModule* module) { assert(module->globals.size >= module->num_global_imports); uint32_t num_globals = module->globals.size - module->num_global_imports; if (num_globals) { - begin_known_section(ctx, WABT_BINARY_SECTION_GLOBAL, - LEB_SECTION_SIZE_GUESS); + begin_known_section(ctx, WabtBinarySection::Global, LEB_SECTION_SIZE_GUESS); wabt_write_u32_leb128(&ctx->stream, num_globals, "num globals"); for (i = 0; i < num_globals; ++i) { @@ -774,39 +763,35 @@ static WabtResult write_module(Context* ctx, const WabtModule* module) { } if (module->exports.size) { - begin_known_section(ctx, WABT_BINARY_SECTION_EXPORT, - LEB_SECTION_SIZE_GUESS); + begin_known_section(ctx, WabtBinarySection::Export, LEB_SECTION_SIZE_GUESS); wabt_write_u32_leb128(&ctx->stream, module->exports.size, "num exports"); for (i = 0; i < module->exports.size; ++i) { const WabtExport* export_ = module->exports.data[i]; wabt_write_str(&ctx->stream, export_->name.start, export_->name.length, - WABT_PRINT_CHARS, "export name"); - wabt_write_u8(&ctx->stream, export_->kind, "export kind"); + WabtPrintChars::Yes, "export name"); + wabt_write_u8_enum(&ctx->stream, export_->kind, "export kind"); switch (export_->kind) { - case WABT_EXTERNAL_KIND_FUNC: { + case WabtExternalKind::Func: { int index = wabt_get_func_index_by_var(module, &export_->var); wabt_write_u32_leb128(&ctx->stream, index, "export func index"); break; } - case WABT_EXTERNAL_KIND_TABLE: { + case WabtExternalKind::Table: { int index = wabt_get_table_index_by_var(module, &export_->var); wabt_write_u32_leb128(&ctx->stream, index, "export table index"); break; } - case WABT_EXTERNAL_KIND_MEMORY: { + case WabtExternalKind::Memory: { int index = wabt_get_memory_index_by_var(module, &export_->var); wabt_write_u32_leb128(&ctx->stream, index, "export memory index"); break; } - case WABT_EXTERNAL_KIND_GLOBAL: { + case WabtExternalKind::Global: { int index = wabt_get_global_index_by_var(module, &export_->var); wabt_write_u32_leb128(&ctx->stream, index, "export global index"); break; } - case WABT_NUM_EXTERNAL_KINDS: - assert(0); - break; } } end_section(ctx); @@ -815,7 +800,7 @@ static WabtResult write_module(Context* ctx, const WabtModule* module) { if (module->start) { int start_func_index = wabt_get_func_index_by_var(module, module->start); if (start_func_index != -1) { - begin_known_section(ctx, WABT_BINARY_SECTION_START, + begin_known_section(ctx, WabtBinarySection::Start, LEB_SECTION_SIZE_GUESS); wabt_write_u32_leb128(&ctx->stream, start_func_index, "start func index"); end_section(ctx); @@ -823,7 +808,7 @@ static WabtResult write_module(Context* ctx, const WabtModule* module) { } if (module->elem_segments.size) { - begin_known_section(ctx, WABT_BINARY_SECTION_ELEM, LEB_SECTION_SIZE_GUESS); + begin_known_section(ctx, WabtBinarySection::Elem, LEB_SECTION_SIZE_GUESS); wabt_write_u32_leb128(&ctx->stream, module->elem_segments.size, "num elem segments"); for (i = 0; i < module->elem_segments.size; ++i) { @@ -839,14 +824,14 @@ static WabtResult write_module(Context* ctx, const WabtModule* module) { for (j = 0; j < segment->vars.size; ++j) { int index = wabt_get_func_index_by_var(module, &segment->vars.data[j]); write_u32_leb128_with_reloc(ctx, index, "function index", - WABT_RELOC_FUNC_INDEX_LEB); + WabtRelocType::FuncIndexLeb); } } end_section(ctx); } if (num_funcs) { - begin_known_section(ctx, WABT_BINARY_SECTION_CODE, LEB_SECTION_SIZE_GUESS); + begin_known_section(ctx, WabtBinarySection::Code, LEB_SECTION_SIZE_GUESS); wabt_write_u32_leb128(&ctx->stream, num_funcs, "num functions"); for (i = 0; i < num_funcs; ++i) { @@ -865,7 +850,7 @@ static WabtResult write_module(Context* ctx, const WabtModule* module) { } if (module->data_segments.size) { - begin_known_section(ctx, WABT_BINARY_SECTION_DATA, LEB_SECTION_SIZE_GUESS); + begin_known_section(ctx, WabtBinarySection::Data, LEB_SECTION_SIZE_GUESS); wabt_write_u32_leb128(&ctx->stream, module->data_segments.size, "num data segments"); for (i = 0; i < module->data_segments.size; ++i) { @@ -898,7 +883,7 @@ static WabtResult write_module(Context* ctx, const WabtModule* module) { wabt_snprintf(desc, sizeof(desc), "func name %" PRIzd, i); wabt_write_str(&ctx->stream, func->name.start, func->name.length, - WABT_PRINT_CHARS, desc); + WabtPrintChars::Yes, desc); wabt_write_u32_leb128(&ctx->stream, num_params_and_locals, "num locals"); if (num_params_and_locals) { @@ -909,7 +894,7 @@ static WabtResult write_module(Context* ctx, const WabtModule* module) { WabtStringSlice name = index_to_name.data[j]; wabt_snprintf(desc, sizeof(desc), "local name %" PRIzd, j); wabt_write_str(&ctx->stream, name.start, name.length, - WABT_PRINT_CHARS, desc); + WabtPrintChars::Yes, desc); } wabt_make_type_binding_reverse_mapping( @@ -919,7 +904,7 @@ static WabtResult write_module(Context* ctx, const WabtModule* module) { wabt_snprintf(desc, sizeof(desc), "local name %" PRIzd, num_params + j); wabt_write_str(&ctx->stream, name.start, name.length, - WABT_PRINT_CHARS, desc); + WabtPrintChars::Yes, desc); } } } diff --git a/src/binary-writer.h b/src/binary-writer.h index f34bb5c6..e8f18477 100644 --- a/src/binary-writer.h +++ b/src/binary-writer.h @@ -77,4 +77,19 @@ void wabt_write_opcode(struct WabtStream* stream, WabtOpcode opcode); void wabt_write_limits(struct WabtStream* stream, const WabtLimits* limits); WABT_EXTERN_C_END +/* Convenience functions for writing enums as LEB128s. */ +template <typename T> +void wabt_write_u32_leb128_enum(struct WabtStream* stream, + T value, + const char* desc) { + wabt_write_u32_leb128(stream, static_cast<uint32_t>(value), desc); +} + +template <typename T> +void wabt_write_i32_leb128_enum(struct WabtStream* stream, + T value, + const char* desc) { + wabt_write_i32_leb128(stream, static_cast<int32_t>(value), desc); +} + #endif /* WABT_BINARY_WRITER_H_ */ diff --git a/src/binary.h b/src/binary.h index 04059c54..31c1dd54 100644 --- a/src/binary.h +++ b/src/binary.h @@ -27,34 +27,38 @@ #define WABT_BINARY_SECTION_RELOC "reloc" #define WABT_FOREACH_BINARY_SECTION(V) \ - V(CUSTOM, custom, 0) \ - V(TYPE, type, 1) \ - V(IMPORT, import, 2) \ - V(FUNCTION, function, 3) \ - V(TABLE, table, 4) \ - V(MEMORY, memory, 5) \ - V(GLOBAL, global, 6) \ - V(EXPORT, export, 7) \ - V(START, start, 8) \ - V(ELEM, elem, 9) \ - V(CODE, code, 10) \ - V(DATA, data, 11) + V(Custom, custom, 0) \ + V(Type, type, 1) \ + V(Import, import, 2) \ + V(Function, function, 3) \ + V(Table, table, 4) \ + V(Memory, memory, 5) \ + V(Global, global, 6) \ + V(Export, export, 7) \ + V(Start, start, 8) \ + V(Elem, elem, 9) \ + V(Code, code, 10) \ + V(Data, data, 11) /* clang-format off */ -enum WabtBinarySection { -#define V(NAME, name, code) WABT_BINARY_SECTION_##NAME = code, +enum class WabtBinarySection { +#define V(Name, name, code) Name = code, WABT_FOREACH_BINARY_SECTION(V) #undef V - WABT_NUM_BINARY_SECTIONS + Invalid, + + First = Custom, + Last = Data, }; /* clang-format on */ +static const int kWabtBinarySectionCount = WABT_ENUM_COUNT(WabtBinarySection); WABT_EXTERN_C_BEGIN extern const char* g_wabt_section_name[]; static WABT_INLINE const char* wabt_get_section_name(WabtBinarySection sec) { - assert(sec < WABT_NUM_BINARY_SECTIONS); - return g_wabt_section_name[sec]; + assert(static_cast<int>(sec) < kWabtBinarySectionCount); + return g_wabt_section_name[static_cast<size_t>(sec)]; } WABT_EXTERN_C_END diff --git a/src/common.cc b/src/common.cc index 830a17ac..5f317de6 100644 --- a/src/common.cc +++ b/src/common.cc @@ -29,7 +29,7 @@ #define PATH_MAX _MAX_PATH #endif -WabtOpcodeInfo g_wabt_opcode_info[WABT_NUM_OPCODES]; +WabtOpcodeInfo g_wabt_opcode_info[kWabtOpcodeCount]; /* TODO(binji): It's annoying to have to have an initializer function, but it * seems to be necessary as g++ doesn't allow non-trival designated @@ -37,11 +37,11 @@ WabtOpcodeInfo g_wabt_opcode_info[WABT_NUM_OPCODES]; void wabt_init_opcode_info(void) { static bool s_initialized = false; if (!s_initialized) { -#define V(rtype, type1, type2, mem_size, code, NAME, text) \ - g_wabt_opcode_info[code].name = text; \ - g_wabt_opcode_info[code].result_type = WABT_TYPE_##rtype; \ - g_wabt_opcode_info[code].param1_type = WABT_TYPE_##type1; \ - g_wabt_opcode_info[code].param2_type = WABT_TYPE_##type2; \ +#define V(rtype, type1, type2, mem_size, code, NAME, text) \ + g_wabt_opcode_info[code].name = text; \ + g_wabt_opcode_info[code].result_type = WabtType::rtype; \ + g_wabt_opcode_info[code].param1_type = WabtType::type1; \ + g_wabt_opcode_info[code].param2_type = WabtType::type2; \ g_wabt_opcode_info[code].memory_size = mem_size; WABT_FOREACH_OPCODE(V) @@ -51,14 +51,13 @@ void wabt_init_opcode_info(void) { } const char* g_wabt_kind_name[] = {"func", "table", "memory", "global"}; -WABT_STATIC_ASSERT(WABT_ARRAY_SIZE(g_wabt_kind_name) == - WABT_NUM_EXTERNAL_KINDS); +WABT_STATIC_ASSERT(WABT_ARRAY_SIZE(g_wabt_kind_name) == kWabtExternalKindCount); const char* g_wabt_reloc_type_name[] = { "R_FUNC_INDEX_LEB", "R_TABLE_INDEX_SLEB", "R_TABLE_INDEX_I32", "R_GLOBAL_INDEX_LEB", "R_DATA"}; WABT_STATIC_ASSERT(WABT_ARRAY_SIZE(g_wabt_reloc_type_name) == - WABT_NUM_RELOC_TYPES); + kWabtRelocTypeCount); bool wabt_is_naturally_aligned(WabtOpcode opcode, uint32_t alignment) { uint32_t opcode_align = wabt_get_opcode_memory_size(opcode); @@ -127,35 +126,35 @@ WabtResult wabt_read_file(const char* filename, char msg[PATH_MAX + sizeof(format)]; wabt_snprintf(msg, sizeof(msg), format, filename); perror(msg); - return WABT_ERROR; + return WabtResult::Error; } if (fseek(infile, 0, SEEK_END) < 0) { perror("fseek to end failed"); - return WABT_ERROR; + return WabtResult::Error; } long size = ftell(infile); if (size < 0) { perror("ftell failed"); - return WABT_ERROR; + return WabtResult::Error; } if (fseek(infile, 0, SEEK_SET) < 0) { perror("fseek to beginning failed"); - return WABT_ERROR; + return WabtResult::Error; } void* data = wabt_alloc(size); if (size != 0 && fread(data, size, 1, infile) != 1) { perror("fread failed"); - return WABT_ERROR; + return WabtResult::Error; } *out_data = data; *out_size = size; fclose(infile); - return WABT_OK; + return WabtResult::Ok; } static void print_carets(FILE* out, @@ -193,14 +192,14 @@ static void print_source_error(FILE* out, static void print_error_header(FILE* out, WabtDefaultErrorHandlerInfo* info) { if (info && info->header) { switch (info->print_header) { - case WABT_PRINT_ERROR_HEADER_NEVER: + case WabtPrintErrorHeader::Never: break; - case WABT_PRINT_ERROR_HEADER_ONCE: - info->print_header = WABT_PRINT_ERROR_HEADER_NEVER; + case WabtPrintErrorHeader::Once: + info->print_header = WabtPrintErrorHeader::Never; /* Fallthrough. */ - case WABT_PRINT_ERROR_HEADER_ALWAYS: + case WabtPrintErrorHeader::Always: fprintf(out, "%s:\n", info->header); break; } diff --git a/src/common.h b/src/common.h index a0eee458..173377c2 100644 --- a/src/common.h +++ b/src/common.h @@ -68,22 +68,28 @@ } \ va_end(args_copy) -enum WabtResult { - WABT_OK, - WABT_ERROR, +#define WABT_ENUM_COUNT(name) \ + (static_cast<int>(name::Last) - static_cast<int>(name::First) + 1) + +enum class WabtResult { + Ok, + Error, }; -#define WABT_SUCCEEDED(x) ((x) == WABT_OK) -#define WABT_FAILED(x) ((x) == WABT_ERROR) +#define WABT_SUCCEEDED(x) ((x) == WabtResult::Ok) +#define WABT_FAILED(x) ((x) == WabtResult::Error) + +enum class WabtLabelType { + Func, + Block, + Loop, + If, + Else, -enum WabtLabelType { - WABT_LABEL_TYPE_FUNC, - WABT_LABEL_TYPE_BLOCK, - WABT_LABEL_TYPE_LOOP, - WABT_LABEL_TYPE_IF, - WABT_LABEL_TYPE_ELSE, - WABT_NUM_LABEL_TYPES, + First = Func, + Last = Else, }; +static const int kWabtLabelTypeCount = WABT_ENUM_COUNT(WabtLabelType); struct WabtStringSlice { const char* start; @@ -132,10 +138,10 @@ struct WabtBinaryErrorHandler { /* This data structure is not required; it is just used by the default error * handler callbacks. */ -enum WabtPrintErrorHeader { - WABT_PRINT_ERROR_HEADER_NEVER, - WABT_PRINT_ERROR_HEADER_ONCE, - WABT_PRINT_ERROR_HEADER_ALWAYS, +enum class WabtPrintErrorHeader { + Never, + Once, + Always, }; struct WabtDefaultErrorHandlerInfo { @@ -145,35 +151,41 @@ struct WabtDefaultErrorHandlerInfo { }; /* matches binary format, do not change */ -enum WabtType { - WABT_TYPE_I32 = -0x01, - WABT_TYPE_I64 = -0x02, - WABT_TYPE_F32 = -0x03, - WABT_TYPE_F64 = -0x04, - WABT_TYPE_ANYFUNC = -0x10, - WABT_TYPE_FUNC = -0x20, - WABT_TYPE_VOID = -0x40, - WABT_TYPE____ = WABT_TYPE_VOID, /* convenient for the opcode table below */ - WABT_TYPE_ANY = 0, /* Not actually specified, but useful for type-checking */ +enum class WabtType { + I32 = -0x01, + I64 = -0x02, + F32 = -0x03, + F64 = -0x04, + Anyfunc = -0x10, + Func = -0x20, + Void = -0x40, + ___ = Void, /* convenient for the opcode table below */ + Any = 0, /* Not actually specified, but useful for type-checking */ }; -enum WabtRelocType { - WABT_RELOC_FUNC_INDEX_LEB = 0, /* e.g. immediate of call instruction */ - WABT_RELOC_TABLE_INDEX_SLEB = 1, /* e.g. loading address of function */ - WABT_RELOC_TABLE_INDEX_I32 = 2, /* e.g. function address in DATA */ - WABT_RELOC_GLOBAL_INDEX_LEB = 3, /* e.g immediate of get_global inst */ - WABT_RELOC_DATA = 4, - WABT_NUM_RELOC_TYPES, +enum class WabtRelocType { + FuncIndexLeb = 0, /* e.g. immediate of call instruction */ + TableIndexSleb = 1, /* e.g. loading address of function */ + TableIndexI32 = 2, /* e.g. function address in DATA */ + GlobalIndexLeb = 3, /* e.g immediate of get_global inst */ + Data = 4, + + First = FuncIndexLeb, + Last = Data, }; +static const int kWabtRelocTypeCount = WABT_ENUM_COUNT(WabtRelocType); /* matches binary format, do not change */ -enum WabtExternalKind { - WABT_EXTERNAL_KIND_FUNC = 0, - WABT_EXTERNAL_KIND_TABLE = 1, - WABT_EXTERNAL_KIND_MEMORY = 2, - WABT_EXTERNAL_KIND_GLOBAL = 3, - WABT_NUM_EXTERNAL_KINDS, +enum class WabtExternalKind { + Func = 0, + Table = 1, + Memory = 2, + Global = 3, + + First = Func, + Last = Global, }; +static const int kWabtExternalKindCount = WABT_ENUM_COUNT(WabtExternalKind); struct WabtLimits { uint64_t initial; @@ -194,187 +206,190 @@ enum { WABT_USE_NATURAL_ALIGNMENT = 0xFFFFFFFF }; * * tr t1 t2 m code NAME text * ============================ */ -#define WABT_FOREACH_OPCODE(V) \ - V(___, ___, ___, 0, 0x00, UNREACHABLE, "unreachable") \ - V(___, ___, ___, 0, 0x01, NOP, "nop") \ - V(___, ___, ___, 0, 0x02, BLOCK, "block") \ - V(___, ___, ___, 0, 0x03, LOOP, "loop") \ - V(___, ___, ___, 0, 0x04, IF, "if") \ - V(___, ___, ___, 0, 0x05, ELSE, "else") \ - V(___, ___, ___, 0, 0x0b, END, "end") \ - V(___, ___, ___, 0, 0x0c, BR, "br") \ - V(___, ___, ___, 0, 0x0d, BR_IF, "br_if") \ - V(___, ___, ___, 0, 0x0e, BR_TABLE, "br_table") \ - V(___, ___, ___, 0, 0x0f, RETURN, "return") \ - V(___, ___, ___, 0, 0x10, CALL, "call") \ - V(___, ___, ___, 0, 0x11, CALL_INDIRECT, "call_indirect") \ - V(___, ___, ___, 0, 0x1a, DROP, "drop") \ - V(___, ___, ___, 0, 0x1b, SELECT, "select") \ - V(___, ___, ___, 0, 0x20, GET_LOCAL, "get_local") \ - V(___, ___, ___, 0, 0x21, SET_LOCAL, "set_local") \ - V(___, ___, ___, 0, 0x22, TEE_LOCAL, "tee_local") \ - V(___, ___, ___, 0, 0x23, GET_GLOBAL, "get_global") \ - V(___, ___, ___, 0, 0x24, SET_GLOBAL, "set_global") \ - V(I32, I32, ___, 4, 0x28, I32_LOAD, "i32.load") \ - V(I64, I32, ___, 8, 0x29, I64_LOAD, "i64.load") \ - V(F32, I32, ___, 4, 0x2a, F32_LOAD, "f32.load") \ - V(F64, I32, ___, 8, 0x2b, F64_LOAD, "f64.load") \ - V(I32, I32, ___, 1, 0x2c, I32_LOAD8_S, "i32.load8_s") \ - V(I32, I32, ___, 1, 0x2d, I32_LOAD8_U, "i32.load8_u") \ - V(I32, I32, ___, 2, 0x2e, I32_LOAD16_S, "i32.load16_s") \ - V(I32, I32, ___, 2, 0x2f, I32_LOAD16_U, "i32.load16_u") \ - V(I64, I32, ___, 1, 0x30, I64_LOAD8_S, "i64.load8_s") \ - V(I64, I32, ___, 1, 0x31, I64_LOAD8_U, "i64.load8_u") \ - V(I64, I32, ___, 2, 0x32, I64_LOAD16_S, "i64.load16_s") \ - V(I64, I32, ___, 2, 0x33, I64_LOAD16_U, "i64.load16_u") \ - V(I64, I32, ___, 4, 0x34, I64_LOAD32_S, "i64.load32_s") \ - V(I64, I32, ___, 4, 0x35, I64_LOAD32_U, "i64.load32_u") \ - V(___, I32, I32, 4, 0x36, I32_STORE, "i32.store") \ - V(___, I32, I64, 8, 0x37, I64_STORE, "i64.store") \ - V(___, I32, F32, 4, 0x38, F32_STORE, "f32.store") \ - V(___, I32, F64, 8, 0x39, F64_STORE, "f64.store") \ - V(___, I32, I32, 1, 0x3a, I32_STORE8, "i32.store8") \ - V(___, I32, I32, 2, 0x3b, I32_STORE16, "i32.store16") \ - V(___, I32, I64, 1, 0x3c, I64_STORE8, "i64.store8") \ - V(___, I32, I64, 2, 0x3d, I64_STORE16, "i64.store16") \ - V(___, I32, I64, 4, 0x3e, I64_STORE32, "i64.store32") \ - V(I32, ___, ___, 0, 0x3f, CURRENT_MEMORY, "current_memory") \ - V(I32, I32, ___, 0, 0x40, GROW_MEMORY, "grow_memory") \ - V(I32, ___, ___, 0, 0x41, I32_CONST, "i32.const") \ - V(I64, ___, ___, 0, 0x42, I64_CONST, "i64.const") \ - V(F32, ___, ___, 0, 0x43, F32_CONST, "f32.const") \ - V(F64, ___, ___, 0, 0x44, F64_CONST, "f64.const") \ - V(I32, I32, ___, 0, 0x45, I32_EQZ, "i32.eqz") \ - V(I32, I32, I32, 0, 0x46, I32_EQ, "i32.eq") \ - V(I32, I32, I32, 0, 0x47, I32_NE, "i32.ne") \ - V(I32, I32, I32, 0, 0x48, I32_LT_S, "i32.lt_s") \ - V(I32, I32, I32, 0, 0x49, I32_LT_U, "i32.lt_u") \ - V(I32, I32, I32, 0, 0x4a, I32_GT_S, "i32.gt_s") \ - V(I32, I32, I32, 0, 0x4b, I32_GT_U, "i32.gt_u") \ - V(I32, I32, I32, 0, 0x4c, I32_LE_S, "i32.le_s") \ - V(I32, I32, I32, 0, 0x4d, I32_LE_U, "i32.le_u") \ - V(I32, I32, I32, 0, 0x4e, I32_GE_S, "i32.ge_s") \ - V(I32, I32, I32, 0, 0x4f, I32_GE_U, "i32.ge_u") \ - V(I32, I64, ___, 0, 0x50, I64_EQZ, "i64.eqz") \ - V(I32, I64, I64, 0, 0x51, I64_EQ, "i64.eq") \ - V(I32, I64, I64, 0, 0x52, I64_NE, "i64.ne") \ - V(I32, I64, I64, 0, 0x53, I64_LT_S, "i64.lt_s") \ - V(I32, I64, I64, 0, 0x54, I64_LT_U, "i64.lt_u") \ - V(I32, I64, I64, 0, 0x55, I64_GT_S, "i64.gt_s") \ - V(I32, I64, I64, 0, 0x56, I64_GT_U, "i64.gt_u") \ - V(I32, I64, I64, 0, 0x57, I64_LE_S, "i64.le_s") \ - V(I32, I64, I64, 0, 0x58, I64_LE_U, "i64.le_u") \ - V(I32, I64, I64, 0, 0x59, I64_GE_S, "i64.ge_s") \ - V(I32, I64, I64, 0, 0x5a, I64_GE_U, "i64.ge_u") \ - V(I32, F32, F32, 0, 0x5b, F32_EQ, "f32.eq") \ - V(I32, F32, F32, 0, 0x5c, F32_NE, "f32.ne") \ - V(I32, F32, F32, 0, 0x5d, F32_LT, "f32.lt") \ - V(I32, F32, F32, 0, 0x5e, F32_GT, "f32.gt") \ - V(I32, F32, F32, 0, 0x5f, F32_LE, "f32.le") \ - V(I32, F32, F32, 0, 0x60, F32_GE, "f32.ge") \ - V(I32, F64, F64, 0, 0x61, F64_EQ, "f64.eq") \ - V(I32, F64, F64, 0, 0x62, F64_NE, "f64.ne") \ - V(I32, F64, F64, 0, 0x63, F64_LT, "f64.lt") \ - V(I32, F64, F64, 0, 0x64, F64_GT, "f64.gt") \ - V(I32, F64, F64, 0, 0x65, F64_LE, "f64.le") \ - V(I32, F64, F64, 0, 0x66, F64_GE, "f64.ge") \ - V(I32, I32, ___, 0, 0x67, I32_CLZ, "i32.clz") \ - V(I32, I32, ___, 0, 0x68, I32_CTZ, "i32.ctz") \ - V(I32, I32, ___, 0, 0x69, I32_POPCNT, "i32.popcnt") \ - V(I32, I32, I32, 0, 0x6a, I32_ADD, "i32.add") \ - V(I32, I32, I32, 0, 0x6b, I32_SUB, "i32.sub") \ - V(I32, I32, I32, 0, 0x6c, I32_MUL, "i32.mul") \ - V(I32, I32, I32, 0, 0x6d, I32_DIV_S, "i32.div_s") \ - V(I32, I32, I32, 0, 0x6e, I32_DIV_U, "i32.div_u") \ - V(I32, I32, I32, 0, 0x6f, I32_REM_S, "i32.rem_s") \ - V(I32, I32, I32, 0, 0x70, I32_REM_U, "i32.rem_u") \ - V(I32, I32, I32, 0, 0x71, I32_AND, "i32.and") \ - V(I32, I32, I32, 0, 0x72, I32_OR, "i32.or") \ - V(I32, I32, I32, 0, 0x73, I32_XOR, "i32.xor") \ - V(I32, I32, I32, 0, 0x74, I32_SHL, "i32.shl") \ - V(I32, I32, I32, 0, 0x75, I32_SHR_S, "i32.shr_s") \ - V(I32, I32, I32, 0, 0x76, I32_SHR_U, "i32.shr_u") \ - V(I32, I32, I32, 0, 0x77, I32_ROTL, "i32.rotl") \ - V(I32, I32, I32, 0, 0x78, I32_ROTR, "i32.rotr") \ - V(I64, I64, I64, 0, 0x79, I64_CLZ, "i64.clz") \ - V(I64, I64, I64, 0, 0x7a, I64_CTZ, "i64.ctz") \ - V(I64, I64, I64, 0, 0x7b, I64_POPCNT, "i64.popcnt") \ - V(I64, I64, I64, 0, 0x7c, I64_ADD, "i64.add") \ - V(I64, I64, I64, 0, 0x7d, I64_SUB, "i64.sub") \ - V(I64, I64, I64, 0, 0x7e, I64_MUL, "i64.mul") \ - V(I64, I64, I64, 0, 0x7f, I64_DIV_S, "i64.div_s") \ - V(I64, I64, I64, 0, 0x80, I64_DIV_U, "i64.div_u") \ - V(I64, I64, I64, 0, 0x81, I64_REM_S, "i64.rem_s") \ - V(I64, I64, I64, 0, 0x82, I64_REM_U, "i64.rem_u") \ - V(I64, I64, I64, 0, 0x83, I64_AND, "i64.and") \ - V(I64, I64, I64, 0, 0x84, I64_OR, "i64.or") \ - V(I64, I64, I64, 0, 0x85, I64_XOR, "i64.xor") \ - V(I64, I64, I64, 0, 0x86, I64_SHL, "i64.shl") \ - V(I64, I64, I64, 0, 0x87, I64_SHR_S, "i64.shr_s") \ - V(I64, I64, I64, 0, 0x88, I64_SHR_U, "i64.shr_u") \ - V(I64, I64, I64, 0, 0x89, I64_ROTL, "i64.rotl") \ - V(I64, I64, I64, 0, 0x8a, I64_ROTR, "i64.rotr") \ - V(F32, F32, F32, 0, 0x8b, F32_ABS, "f32.abs") \ - V(F32, F32, F32, 0, 0x8c, F32_NEG, "f32.neg") \ - V(F32, F32, F32, 0, 0x8d, F32_CEIL, "f32.ceil") \ - V(F32, F32, F32, 0, 0x8e, F32_FLOOR, "f32.floor") \ - V(F32, F32, F32, 0, 0x8f, F32_TRUNC, "f32.trunc") \ - V(F32, F32, F32, 0, 0x90, F32_NEAREST, "f32.nearest") \ - V(F32, F32, F32, 0, 0x91, F32_SQRT, "f32.sqrt") \ - V(F32, F32, F32, 0, 0x92, F32_ADD, "f32.add") \ - V(F32, F32, F32, 0, 0x93, F32_SUB, "f32.sub") \ - V(F32, F32, F32, 0, 0x94, F32_MUL, "f32.mul") \ - V(F32, F32, F32, 0, 0x95, F32_DIV, "f32.div") \ - V(F32, F32, F32, 0, 0x96, F32_MIN, "f32.min") \ - V(F32, F32, F32, 0, 0x97, F32_MAX, "f32.max") \ - V(F32, F32, F32, 0, 0x98, F32_COPYSIGN, "f32.copysign") \ - V(F64, F64, F64, 0, 0x99, F64_ABS, "f64.abs") \ - V(F64, F64, F64, 0, 0x9a, F64_NEG, "f64.neg") \ - V(F64, F64, F64, 0, 0x9b, F64_CEIL, "f64.ceil") \ - V(F64, F64, F64, 0, 0x9c, F64_FLOOR, "f64.floor") \ - V(F64, F64, F64, 0, 0x9d, F64_TRUNC, "f64.trunc") \ - V(F64, F64, F64, 0, 0x9e, F64_NEAREST, "f64.nearest") \ - V(F64, F64, F64, 0, 0x9f, F64_SQRT, "f64.sqrt") \ - V(F64, F64, F64, 0, 0xa0, F64_ADD, "f64.add") \ - V(F64, F64, F64, 0, 0xa1, F64_SUB, "f64.sub") \ - V(F64, F64, F64, 0, 0xa2, F64_MUL, "f64.mul") \ - V(F64, F64, F64, 0, 0xa3, F64_DIV, "f64.div") \ - V(F64, F64, F64, 0, 0xa4, F64_MIN, "f64.min") \ - V(F64, F64, F64, 0, 0xa5, F64_MAX, "f64.max") \ - V(F64, F64, F64, 0, 0xa6, F64_COPYSIGN, "f64.copysign") \ - V(I32, I64, ___, 0, 0xa7, I32_WRAP_I64, "i32.wrap/i64") \ - V(I32, F32, ___, 0, 0xa8, I32_TRUNC_S_F32, "i32.trunc_s/f32") \ - V(I32, F32, ___, 0, 0xa9, I32_TRUNC_U_F32, "i32.trunc_u/f32") \ - V(I32, F64, ___, 0, 0xaa, I32_TRUNC_S_F64, "i32.trunc_s/f64") \ - V(I32, F64, ___, 0, 0xab, I32_TRUNC_U_F64, "i32.trunc_u/f64") \ - V(I64, I32, ___, 0, 0xac, I64_EXTEND_S_I32, "i64.extend_s/i32") \ - V(I64, I32, ___, 0, 0xad, I64_EXTEND_U_I32, "i64.extend_u/i32") \ - V(I64, F32, ___, 0, 0xae, I64_TRUNC_S_F32, "i64.trunc_s/f32") \ - V(I64, F32, ___, 0, 0xaf, I64_TRUNC_U_F32, "i64.trunc_u/f32") \ - V(I64, F64, ___, 0, 0xb0, I64_TRUNC_S_F64, "i64.trunc_s/f64") \ - V(I64, F64, ___, 0, 0xb1, I64_TRUNC_U_F64, "i64.trunc_u/f64") \ - V(F32, I32, ___, 0, 0xb2, F32_CONVERT_S_I32, "f32.convert_s/i32") \ - V(F32, I32, ___, 0, 0xb3, F32_CONVERT_U_I32, "f32.convert_u/i32") \ - V(F32, I64, ___, 0, 0xb4, F32_CONVERT_S_I64, "f32.convert_s/i64") \ - V(F32, I64, ___, 0, 0xb5, F32_CONVERT_U_I64, "f32.convert_u/i64") \ - V(F32, F64, ___, 0, 0xb6, F32_DEMOTE_F64, "f32.demote/f64") \ - V(F64, I32, ___, 0, 0xb7, F64_CONVERT_S_I32, "f64.convert_s/i32") \ - V(F64, I32, ___, 0, 0xb8, F64_CONVERT_U_I32, "f64.convert_u/i32") \ - V(F64, I64, ___, 0, 0xb9, F64_CONVERT_S_I64, "f64.convert_s/i64") \ - V(F64, I64, ___, 0, 0xba, F64_CONVERT_U_I64, "f64.convert_u/i64") \ - V(F64, F32, ___, 0, 0xbb, F64_PROMOTE_F32, "f64.promote/f32") \ - V(I32, F32, ___, 0, 0xbc, I32_REINTERPRET_F32, "i32.reinterpret/f32") \ - V(I64, F64, ___, 0, 0xbd, I64_REINTERPRET_F64, "i64.reinterpret/f64") \ - V(F32, I32, ___, 0, 0xbe, F32_REINTERPRET_I32, "f32.reinterpret/i32") \ - V(F64, I64, ___, 0, 0xbf, F64_REINTERPRET_I64, "f64.reinterpret/i64") - -enum WabtOpcode { -#define V(rtype, type1, type2, mem_size, code, NAME, text) \ - WABT_OPCODE_##NAME = code, +#define WABT_FOREACH_OPCODE(V) \ + V(___, ___, ___, 0, 0x00, Unreachable, "unreachable") \ + V(___, ___, ___, 0, 0x01, Nop, "nop") \ + V(___, ___, ___, 0, 0x02, Block, "block") \ + V(___, ___, ___, 0, 0x03, Loop, "loop") \ + V(___, ___, ___, 0, 0x04, If, "if") \ + V(___, ___, ___, 0, 0x05, Else, "else") \ + V(___, ___, ___, 0, 0x0b, End, "end") \ + V(___, ___, ___, 0, 0x0c, Br, "br") \ + V(___, ___, ___, 0, 0x0d, BrIf, "br_if") \ + V(___, ___, ___, 0, 0x0e, BrTable, "br_table") \ + V(___, ___, ___, 0, 0x0f, Return, "return") \ + V(___, ___, ___, 0, 0x10, Call, "call") \ + V(___, ___, ___, 0, 0x11, CallIndirect, "call_indirect") \ + V(___, ___, ___, 0, 0x1a, Drop, "drop") \ + V(___, ___, ___, 0, 0x1b, Select, "select") \ + V(___, ___, ___, 0, 0x20, GetLocal, "get_local") \ + V(___, ___, ___, 0, 0x21, SetLocal, "set_local") \ + V(___, ___, ___, 0, 0x22, TeeLocal, "tee_local") \ + V(___, ___, ___, 0, 0x23, GetGlobal, "get_global") \ + V(___, ___, ___, 0, 0x24, SetGlobal, "set_global") \ + V(I32, I32, ___, 4, 0x28, I32Load, "i32.load") \ + V(I64, I32, ___, 8, 0x29, I64Load, "i64.load") \ + V(F32, I32, ___, 4, 0x2a, F32Load, "f32.load") \ + V(F64, I32, ___, 8, 0x2b, F64Load, "f64.load") \ + V(I32, I32, ___, 1, 0x2c, I32Load8S, "i32.load8_s") \ + V(I32, I32, ___, 1, 0x2d, I32Load8U, "i32.load8_u") \ + V(I32, I32, ___, 2, 0x2e, I32Load16S, "i32.load16_s") \ + V(I32, I32, ___, 2, 0x2f, I32Load16U, "i32.load16_u") \ + V(I64, I32, ___, 1, 0x30, I64Load8S, "i64.load8_s") \ + V(I64, I32, ___, 1, 0x31, I64Load8U, "i64.load8_u") \ + V(I64, I32, ___, 2, 0x32, I64Load16S, "i64.load16_s") \ + V(I64, I32, ___, 2, 0x33, I64Load16U, "i64.load16_u") \ + V(I64, I32, ___, 4, 0x34, I64Load32S, "i64.load32_s") \ + V(I64, I32, ___, 4, 0x35, I64Load32U, "i64.load32_u") \ + V(___, I32, I32, 4, 0x36, I32Store, "i32.store") \ + V(___, I32, I64, 8, 0x37, I64Store, "i64.store") \ + V(___, I32, F32, 4, 0x38, F32Store, "f32.store") \ + V(___, I32, F64, 8, 0x39, F64Store, "f64.store") \ + V(___, I32, I32, 1, 0x3a, I32Store8, "i32.store8") \ + V(___, I32, I32, 2, 0x3b, I32Store16, "i32.store16") \ + V(___, I32, I64, 1, 0x3c, I64Store8, "i64.store8") \ + V(___, I32, I64, 2, 0x3d, I64Store16, "i64.store16") \ + V(___, I32, I64, 4, 0x3e, I64Store32, "i64.store32") \ + V(I32, ___, ___, 0, 0x3f, CurrentMemory, "current_memory") \ + V(I32, I32, ___, 0, 0x40, GrowMemory, "grow_memory") \ + V(I32, ___, ___, 0, 0x41, I32Const, "i32.const") \ + V(I64, ___, ___, 0, 0x42, I64Const, "i64.const") \ + V(F32, ___, ___, 0, 0x43, F32Const, "f32.const") \ + V(F64, ___, ___, 0, 0x44, F64Const, "f64.const") \ + V(I32, I32, ___, 0, 0x45, I32Eqz, "i32.eqz") \ + V(I32, I32, I32, 0, 0x46, I32Eq, "i32.eq") \ + V(I32, I32, I32, 0, 0x47, I32Ne, "i32.ne") \ + V(I32, I32, I32, 0, 0x48, I32LtS, "i32.lt_s") \ + V(I32, I32, I32, 0, 0x49, I32LtU, "i32.lt_u") \ + V(I32, I32, I32, 0, 0x4a, I32GtS, "i32.gt_s") \ + V(I32, I32, I32, 0, 0x4b, I32GtU, "i32.gt_u") \ + V(I32, I32, I32, 0, 0x4c, I32LeS, "i32.le_s") \ + V(I32, I32, I32, 0, 0x4d, I32LeU, "i32.le_u") \ + V(I32, I32, I32, 0, 0x4e, I32GeS, "i32.ge_s") \ + V(I32, I32, I32, 0, 0x4f, I32GeU, "i32.ge_u") \ + V(I32, I64, ___, 0, 0x50, I64Eqz, "i64.eqz") \ + V(I32, I64, I64, 0, 0x51, I64Eq, "i64.eq") \ + V(I32, I64, I64, 0, 0x52, I64Ne, "i64.ne") \ + V(I32, I64, I64, 0, 0x53, I64LtS, "i64.lt_s") \ + V(I32, I64, I64, 0, 0x54, I64LtU, "i64.lt_u") \ + V(I32, I64, I64, 0, 0x55, I64GtS, "i64.gt_s") \ + V(I32, I64, I64, 0, 0x56, I64GtU, "i64.gt_u") \ + V(I32, I64, I64, 0, 0x57, I64LeS, "i64.le_s") \ + V(I32, I64, I64, 0, 0x58, I64LeU, "i64.le_u") \ + V(I32, I64, I64, 0, 0x59, I64GeS, "i64.ge_s") \ + V(I32, I64, I64, 0, 0x5a, I64GeU, "i64.ge_u") \ + V(I32, F32, F32, 0, 0x5b, F32Eq, "f32.eq") \ + V(I32, F32, F32, 0, 0x5c, F32Ne, "f32.ne") \ + V(I32, F32, F32, 0, 0x5d, F32Lt, "f32.lt") \ + V(I32, F32, F32, 0, 0x5e, F32Gt, "f32.gt") \ + V(I32, F32, F32, 0, 0x5f, F32Le, "f32.le") \ + V(I32, F32, F32, 0, 0x60, F32Ge, "f32.ge") \ + V(I32, F64, F64, 0, 0x61, F64Eq, "f64.eq") \ + V(I32, F64, F64, 0, 0x62, F64Ne, "f64.ne") \ + V(I32, F64, F64, 0, 0x63, F64Lt, "f64.lt") \ + V(I32, F64, F64, 0, 0x64, F64Gt, "f64.gt") \ + V(I32, F64, F64, 0, 0x65, F64Le, "f64.le") \ + V(I32, F64, F64, 0, 0x66, F64Ge, "f64.ge") \ + V(I32, I32, ___, 0, 0x67, I32Clz, "i32.clz") \ + V(I32, I32, ___, 0, 0x68, I32Ctz, "i32.ctz") \ + V(I32, I32, ___, 0, 0x69, I32Popcnt, "i32.popcnt") \ + V(I32, I32, I32, 0, 0x6a, I32Add, "i32.add") \ + V(I32, I32, I32, 0, 0x6b, I32Sub, "i32.sub") \ + V(I32, I32, I32, 0, 0x6c, I32Mul, "i32.mul") \ + V(I32, I32, I32, 0, 0x6d, I32DivS, "i32.div_s") \ + V(I32, I32, I32, 0, 0x6e, I32DivU, "i32.div_u") \ + V(I32, I32, I32, 0, 0x6f, I32RemS, "i32.rem_s") \ + V(I32, I32, I32, 0, 0x70, I32RemU, "i32.rem_u") \ + V(I32, I32, I32, 0, 0x71, I32And, "i32.and") \ + V(I32, I32, I32, 0, 0x72, I32Or, "i32.or") \ + V(I32, I32, I32, 0, 0x73, I32Xor, "i32.xor") \ + V(I32, I32, I32, 0, 0x74, I32Shl, "i32.shl") \ + V(I32, I32, I32, 0, 0x75, I32ShrS, "i32.shr_s") \ + V(I32, I32, I32, 0, 0x76, I32ShrU, "i32.shr_u") \ + V(I32, I32, I32, 0, 0x77, I32Rotl, "i32.rotl") \ + V(I32, I32, I32, 0, 0x78, I32Rotr, "i32.rotr") \ + V(I64, I64, I64, 0, 0x79, I64Clz, "i64.clz") \ + V(I64, I64, I64, 0, 0x7a, I64Ctz, "i64.ctz") \ + V(I64, I64, I64, 0, 0x7b, I64Popcnt, "i64.popcnt") \ + V(I64, I64, I64, 0, 0x7c, I64Add, "i64.add") \ + V(I64, I64, I64, 0, 0x7d, I64Sub, "i64.sub") \ + V(I64, I64, I64, 0, 0x7e, I64Mul, "i64.mul") \ + V(I64, I64, I64, 0, 0x7f, I64DivS, "i64.div_s") \ + V(I64, I64, I64, 0, 0x80, I64DivU, "i64.div_u") \ + V(I64, I64, I64, 0, 0x81, I64RemS, "i64.rem_s") \ + V(I64, I64, I64, 0, 0x82, I64RemU, "i64.rem_u") \ + V(I64, I64, I64, 0, 0x83, I64And, "i64.and") \ + V(I64, I64, I64, 0, 0x84, I64Or, "i64.or") \ + V(I64, I64, I64, 0, 0x85, I64Xor, "i64.xor") \ + V(I64, I64, I64, 0, 0x86, I64Shl, "i64.shl") \ + V(I64, I64, I64, 0, 0x87, I64ShrS, "i64.shr_s") \ + V(I64, I64, I64, 0, 0x88, I64ShrU, "i64.shr_u") \ + V(I64, I64, I64, 0, 0x89, I64Rotl, "i64.rotl") \ + V(I64, I64, I64, 0, 0x8a, I64Rotr, "i64.rotr") \ + V(F32, F32, F32, 0, 0x8b, F32Abs, "f32.abs") \ + V(F32, F32, F32, 0, 0x8c, F32Neg, "f32.neg") \ + V(F32, F32, F32, 0, 0x8d, F32Ceil, "f32.ceil") \ + V(F32, F32, F32, 0, 0x8e, F32Floor, "f32.floor") \ + V(F32, F32, F32, 0, 0x8f, F32Trunc, "f32.trunc") \ + V(F32, F32, F32, 0, 0x90, F32Nearest, "f32.nearest") \ + V(F32, F32, F32, 0, 0x91, F32Sqrt, "f32.sqrt") \ + V(F32, F32, F32, 0, 0x92, F32Add, "f32.add") \ + V(F32, F32, F32, 0, 0x93, F32Sub, "f32.sub") \ + V(F32, F32, F32, 0, 0x94, F32Mul, "f32.mul") \ + V(F32, F32, F32, 0, 0x95, F32Div, "f32.div") \ + V(F32, F32, F32, 0, 0x96, F32Min, "f32.min") \ + V(F32, F32, F32, 0, 0x97, F32Max, "f32.max") \ + V(F32, F32, F32, 0, 0x98, F32Copysign, "f32.copysign") \ + V(F64, F64, F64, 0, 0x99, F64Abs, "f64.abs") \ + V(F64, F64, F64, 0, 0x9a, F64Neg, "f64.neg") \ + V(F64, F64, F64, 0, 0x9b, F64Ceil, "f64.ceil") \ + V(F64, F64, F64, 0, 0x9c, F64Floor, "f64.floor") \ + V(F64, F64, F64, 0, 0x9d, F64Trunc, "f64.trunc") \ + V(F64, F64, F64, 0, 0x9e, F64Nearest, "f64.nearest") \ + V(F64, F64, F64, 0, 0x9f, F64Sqrt, "f64.sqrt") \ + V(F64, F64, F64, 0, 0xa0, F64Add, "f64.add") \ + V(F64, F64, F64, 0, 0xa1, F64Sub, "f64.sub") \ + V(F64, F64, F64, 0, 0xa2, F64Mul, "f64.mul") \ + V(F64, F64, F64, 0, 0xa3, F64Div, "f64.div") \ + V(F64, F64, F64, 0, 0xa4, F64Min, "f64.min") \ + V(F64, F64, F64, 0, 0xa5, F64Max, "f64.max") \ + V(F64, F64, F64, 0, 0xa6, F64Copysign, "f64.copysign") \ + V(I32, I64, ___, 0, 0xa7, I32WrapI64, "i32.wrap/i64") \ + V(I32, F32, ___, 0, 0xa8, I32TruncSF32, "i32.trunc_s/f32") \ + V(I32, F32, ___, 0, 0xa9, I32TruncUF32, "i32.trunc_u/f32") \ + V(I32, F64, ___, 0, 0xaa, I32TruncSF64, "i32.trunc_s/f64") \ + V(I32, F64, ___, 0, 0xab, I32TruncUF64, "i32.trunc_u/f64") \ + V(I64, I32, ___, 0, 0xac, I64ExtendSI32, "i64.extend_s/i32") \ + V(I64, I32, ___, 0, 0xad, I64ExtendUI32, "i64.extend_u/i32") \ + V(I64, F32, ___, 0, 0xae, I64TruncSF32, "i64.trunc_s/f32") \ + V(I64, F32, ___, 0, 0xaf, I64TruncUF32, "i64.trunc_u/f32") \ + V(I64, F64, ___, 0, 0xb0, I64TruncSF64, "i64.trunc_s/f64") \ + V(I64, F64, ___, 0, 0xb1, I64TruncUF64, "i64.trunc_u/f64") \ + V(F32, I32, ___, 0, 0xb2, F32ConvertSI32, "f32.convert_s/i32") \ + V(F32, I32, ___, 0, 0xb3, F32ConvertUI32, "f32.convert_u/i32") \ + V(F32, I64, ___, 0, 0xb4, F32ConvertSI64, "f32.convert_s/i64") \ + V(F32, I64, ___, 0, 0xb5, F32ConvertUI64, "f32.convert_u/i64") \ + V(F32, F64, ___, 0, 0xb6, F32DemoteF64, "f32.demote/f64") \ + V(F64, I32, ___, 0, 0xb7, F64ConvertSI32, "f64.convert_s/i32") \ + V(F64, I32, ___, 0, 0xb8, F64ConvertUI32, "f64.convert_u/i32") \ + V(F64, I64, ___, 0, 0xb9, F64ConvertSI64, "f64.convert_s/i64") \ + V(F64, I64, ___, 0, 0xba, F64ConvertUI64, "f64.convert_u/i64") \ + V(F64, F32, ___, 0, 0xbb, F64PromoteF32, "f64.promote/f32") \ + V(I32, F32, ___, 0, 0xbc, I32ReinterpretF32, "i32.reinterpret/f32") \ + V(I64, F64, ___, 0, 0xbd, I64ReinterpretF64, "i64.reinterpret/f64") \ + V(F32, I32, ___, 0, 0xbe, F32ReinterpretI32, "f32.reinterpret/i32") \ + V(F64, I64, ___, 0, 0xbf, F64ReinterpretI64, "f64.reinterpret/i64") + +enum class WabtOpcode { +#define V(rtype, type1, type2, mem_size, code, Name, text) \ + Name = code, WABT_FOREACH_OPCODE(V) #undef V - WABT_NUM_OPCODES + + First = Unreachable, + Last = F64ReinterpretI64, }; +static const int kWabtOpcodeCount = WABT_ENUM_COUNT(WabtOpcode); struct WabtOpcodeInfo { const char* name; @@ -384,12 +399,12 @@ struct WabtOpcodeInfo { int memory_size; }; -enum WabtLiteralType { - WABT_LITERAL_TYPE_INT, - WABT_LITERAL_TYPE_FLOAT, - WABT_LITERAL_TYPE_HEXFLOAT, - WABT_LITERAL_TYPE_INFINITY, - WABT_LITERAL_TYPE_NAN, +enum class WabtLiteralType { + Int, + Float, + Hexfloat, + Infinity, + Nan, }; struct WabtLiteral { @@ -477,33 +492,33 @@ extern WabtOpcodeInfo g_wabt_opcode_info[]; void wabt_init_opcode_info(void); static WABT_INLINE const char* wabt_get_opcode_name(WabtOpcode opcode) { - assert(opcode < WABT_NUM_OPCODES); + assert(static_cast<int>(opcode) < kWabtOpcodeCount); wabt_init_opcode_info(); - return g_wabt_opcode_info[opcode].name; + return g_wabt_opcode_info[static_cast<size_t>(opcode)].name; } static WABT_INLINE WabtType wabt_get_opcode_result_type(WabtOpcode opcode) { - assert(opcode < WABT_NUM_OPCODES); + assert(static_cast<int>(opcode) < kWabtOpcodeCount); wabt_init_opcode_info(); - return g_wabt_opcode_info[opcode].result_type; + return g_wabt_opcode_info[static_cast<size_t>(opcode)].result_type; } static WABT_INLINE WabtType wabt_get_opcode_param_type_1(WabtOpcode opcode) { - assert(opcode < WABT_NUM_OPCODES); + assert(static_cast<int>(opcode) < kWabtOpcodeCount); wabt_init_opcode_info(); - return g_wabt_opcode_info[opcode].param1_type; + return g_wabt_opcode_info[static_cast<size_t>(opcode)].param1_type; } static WABT_INLINE WabtType wabt_get_opcode_param_type_2(WabtOpcode opcode) { - assert(opcode < WABT_NUM_OPCODES); + assert(static_cast<int>(opcode) < kWabtOpcodeCount); wabt_init_opcode_info(); - return g_wabt_opcode_info[opcode].param2_type; + return g_wabt_opcode_info[static_cast<size_t>(opcode)].param2_type; } static WABT_INLINE int wabt_get_opcode_memory_size(WabtOpcode opcode) { - assert(opcode < WABT_NUM_OPCODES); + assert(static_cast<int>(opcode) < kWabtOpcodeCount); wabt_init_opcode_info(); - return g_wabt_opcode_info[opcode].memory_size; + return g_wabt_opcode_info[static_cast<size_t>(opcode)].memory_size; } /* external kind */ @@ -511,8 +526,8 @@ static WABT_INLINE int wabt_get_opcode_memory_size(WabtOpcode opcode) { extern const char* g_wabt_kind_name[]; static WABT_INLINE const char* wabt_get_kind_name(WabtExternalKind kind) { - assert(kind < WABT_NUM_EXTERNAL_KINDS); - return g_wabt_kind_name[kind]; + assert(static_cast<int>(kind) < kWabtExternalKindCount); + return g_wabt_kind_name[static_cast<size_t>(kind)]; } /* reloc */ @@ -520,22 +535,22 @@ static WABT_INLINE const char* wabt_get_kind_name(WabtExternalKind kind) { extern const char* g_wabt_reloc_type_name[]; static WABT_INLINE const char* wabt_get_reloc_type_name(WabtRelocType reloc) { - assert(reloc < WABT_NUM_RELOC_TYPES); - return g_wabt_reloc_type_name[reloc]; + assert(static_cast<int>(reloc) < kWabtRelocTypeCount); + return g_wabt_reloc_type_name[static_cast<size_t>(reloc)]; } /* type */ static WABT_INLINE const char* wabt_get_type_name(WabtType type) { switch (type) { - case WABT_TYPE_I32: return "i32"; - case WABT_TYPE_I64: return "i64"; - case WABT_TYPE_F32: return "f32"; - case WABT_TYPE_F64: return "f64"; - case WABT_TYPE_ANYFUNC: return "anyfunc"; - case WABT_TYPE_FUNC: return "func"; - case WABT_TYPE_VOID: return "void"; - case WABT_TYPE_ANY: return "any"; + case WabtType::I32: return "i32"; + case WabtType::I64: return "i64"; + case WabtType::F32: return "f32"; + case WabtType::F64: return "f64"; + case WabtType::Anyfunc: return "anyfunc"; + case WabtType::Func: return "func"; + case WabtType::Void: return "void"; + case WabtType::Any: return "any"; default: return nullptr; } } diff --git a/src/generate-names.cc b/src/generate-names.cc index e19bcfd4..71a2d38a 100644 --- a/src/generate-names.cc +++ b/src/generate-names.cc @@ -24,7 +24,7 @@ #define CHECK_RESULT(expr) \ do { \ if (WABT_FAILED(expr)) \ - return WABT_ERROR; \ + return WabtResult::Error; \ } while (0) struct Context { @@ -95,19 +95,19 @@ static void generate_and_bind_local_names(WabtStringSliceVector* index_to_name, static WabtResult begin_block_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); maybe_generate_name("$B", ctx->label_count++, &expr->block.label); - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_loop_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); maybe_generate_name("$L", ctx->label_count++, &expr->loop.label); - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_if_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); maybe_generate_name("$L", ctx->label_count++, &expr->if_.true_.label); - return WABT_OK; + return WabtResult::Ok; } @@ -129,7 +129,7 @@ static WabtResult visit_func(Context* ctx, ctx->label_count = 0; CHECK_RESULT(wabt_visit_func(func, &ctx->visitor)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult visit_global(Context* ctx, @@ -137,7 +137,7 @@ static WabtResult visit_global(Context* ctx, WabtGlobal* global) { maybe_generate_and_bind_name(&ctx->module->global_bindings, "$g", global_index, &global->name); - return WABT_OK; + return WabtResult::Ok; } static WabtResult visit_func_type(Context* ctx, @@ -145,7 +145,7 @@ static WabtResult visit_func_type(Context* ctx, WabtFuncType* func_type) { maybe_generate_and_bind_name(&ctx->module->func_type_bindings, "$t", func_type_index, &func_type->name); - return WABT_OK; + return WabtResult::Ok; } static WabtResult visit_table(Context* ctx, @@ -153,7 +153,7 @@ static WabtResult visit_table(Context* ctx, WabtTable* table) { maybe_generate_and_bind_name(&ctx->module->table_bindings, "$T", table_index, &table->name); - return WABT_OK; + return WabtResult::Ok; } static WabtResult visit_memory(Context* ctx, @@ -161,7 +161,7 @@ static WabtResult visit_memory(Context* ctx, WabtMemory* memory) { maybe_generate_and_bind_name(&ctx->module->memory_bindings, "$M", memory_index, &memory->name); - return WABT_OK; + return WabtResult::Ok; } static WabtResult visit_module(Context* ctx, WabtModule* module) { @@ -176,7 +176,7 @@ static WabtResult visit_module(Context* ctx, WabtModule* module) { CHECK_RESULT(visit_table(ctx, i, module->tables.data[i])); for (i = 0; i < module->memories.size; ++i) CHECK_RESULT(visit_memory(ctx, i, module->memories.data[i])); - return WABT_OK; + return WabtResult::Ok; } WabtResult wabt_generate_names(WabtModule* module) { diff --git a/src/interpreter.cc b/src/interpreter.cc index ac246a5d..e9eeee08 100644 --- a/src/interpreter.cc +++ b/src/interpreter.cc @@ -29,7 +29,7 @@ static const char* s_interpreter_opcode_name[256]; #define CHECK_RESULT(expr) \ do { \ if (WABT_FAILED(expr)) \ - return WABT_ERROR; \ + return WabtResult::Error; \ } while (0) /* TODO(binji): It's annoying to have to have an initializer function, but it @@ -41,20 +41,16 @@ static void init_interpreter_opcode_table(void) { #define V(rtype, type1, type2, mem_size, code, NAME, text) \ s_interpreter_opcode_name[code] = text; - WABT_FOREACH_OPCODE(V) - s_interpreter_opcode_name[WABT_OPCODE_ALLOCA] = "alloca"; - s_interpreter_opcode_name[WABT_OPCODE_BR_UNLESS] = "br_unless"; - s_interpreter_opcode_name[WABT_OPCODE_CALL_HOST] = "call_host"; - s_interpreter_opcode_name[WABT_OPCODE_DATA] = "data"; - s_interpreter_opcode_name[WABT_OPCODE_DROP_KEEP] = "drop_keep"; + WABT_FOREACH_INTERPRETER_OPCODE(V) #undef V } } -static const char* wabt_get_interpreter_opcode_name(uint8_t opcode) { +static const char* wabt_get_interpreter_opcode_name( + WabtInterpreterOpcode opcode) { init_interpreter_opcode_table(); - return s_interpreter_opcode_name[opcode]; + return s_interpreter_opcode_name[static_cast<int>(opcode)]; } void wabt_init_interpreter_environment(WabtInterpreterEnvironment* env) { @@ -199,9 +195,9 @@ void wabt_init_interpreter_thread(WabtInterpreterEnvironment* env, WabtInterpreterResult wabt_push_thread_value(WabtInterpreterThread* thread, WabtInterpreterValue value) { if (thread->value_stack_top >= thread->value_stack_end) - return WABT_INTERPRETER_TRAP_VALUE_STACK_EXHAUSTED; + return WabtInterpreterResult::TrapValueStackExhausted; *thread->value_stack_top++ = value; - return WABT_INTERPRETER_OK; + return WabtInterpreterResult::Ok; } WabtInterpreterExport* wabt_get_interpreter_export_by_name( @@ -450,17 +446,17 @@ DEFINE_BITCAST(bitcast_u64_to_f64, uint64_t, double) #define TYPE_FIELD_NAME_F32 f32_bits #define TYPE_FIELD_NAME_F64 f64_bits -#define TRAP(type) return WABT_INTERPRETER_TRAP_##type +#define TRAP(type) return WabtInterpreterResult::Trap##type #define TRAP_UNLESS(cond, type) TRAP_IF(!(cond), type) -#define TRAP_IF(cond, type) \ - do { \ - if (WABT_UNLIKELY(cond)) \ - return WABT_INTERPRETER_TRAP_##type; \ +#define TRAP_IF(cond, type) \ + do { \ + if (WABT_UNLIKELY(cond)) \ + TRAP(type); \ } while (0) #define CHECK_STACK() \ TRAP_IF(thread->value_stack_top >= thread->value_stack_end, \ - VALUE_STACK_EXHAUSTED) + ValueStackExhausted) #define PUSH_NEG_1_AND_BREAK_IF(cond) \ if (WABT_UNLIKELY(cond)) { \ @@ -506,7 +502,7 @@ DEFINE_BITCAST(bitcast_u64_to_f64, uint64_t, double) #define PUSH_CALL() \ do { \ TRAP_IF(thread->call_stack_top >= thread->call_stack_end, \ - CALL_STACK_EXHAUSTED); \ + CallStackExhausted); \ (*thread->call_stack_top++) = (pc - istream); \ } while (0) @@ -523,7 +519,7 @@ DEFINE_BITCAST(bitcast_u64_to_f64, uint64_t, double) uint64_t offset = static_cast<uint64_t>(POP_I32()) + read_u32(&pc); \ MEM_TYPE_##mem_type value; \ TRAP_IF(offset + sizeof(value) > memory->byte_size, \ - MEMORY_ACCESS_OUT_OF_BOUNDS); \ + MemoryAccessOutOfBounds); \ void* src = \ reinterpret_cast<void*>(reinterpret_cast<intptr_t>(memory->data) + \ static_cast<uint32_t>(offset)); \ @@ -538,7 +534,7 @@ DEFINE_BITCAST(bitcast_u64_to_f64, uint64_t, double) uint64_t offset = static_cast<uint64_t>(POP_I32()) + read_u32(&pc); \ MEM_TYPE_##mem_type src = static_cast<MEM_TYPE_##mem_type>(value); \ TRAP_IF(offset + sizeof(src) > memory->byte_size, \ - MEMORY_ACCESS_OUT_OF_BOUNDS); \ + MemoryAccessOutOfBounds); \ void* dst = \ reinterpret_cast<void*>(reinterpret_cast<intptr_t>(memory->data) + \ static_cast<uint32_t>(offset)); \ @@ -593,7 +589,7 @@ DEFINE_BITCAST(bitcast_u64_to_f64, uint64_t, double) do { \ VALUE_TYPE_##type rhs = POP_##type(); \ VALUE_TYPE_##type lhs = POP_##type(); \ - TRAP_IF(rhs == 0, INTEGER_DIVIDE_BY_ZERO); \ + TRAP_IF(rhs == 0, IntegerDivideByZero); \ PUSH_##type(BITCAST_##type##_TO_UNSIGNED(lhs) \ op BITCAST_##type##_TO_UNSIGNED(rhs)); \ } while (0) @@ -605,10 +601,10 @@ DEFINE_BITCAST(bitcast_u64_to_f64, uint64_t, double) do { \ VALUE_TYPE_##type rhs = POP_##type(); \ VALUE_TYPE_##type lhs = POP_##type(); \ - TRAP_IF(rhs == 0, INTEGER_DIVIDE_BY_ZERO); \ + TRAP_IF(rhs == 0, IntegerDivideByZero); \ TRAP_IF(lhs == VALUE_TYPE_SIGNED_MAX_##type && \ rhs == VALUE_TYPE_UNSIGNED_MAX_##type, \ - INTEGER_OVERFLOW); \ + IntegerOverflow); \ PUSH_##type(BITCAST_##type##_TO_SIGNED(lhs) / \ BITCAST_##type##_TO_SIGNED(rhs)); \ } while (0) @@ -617,7 +613,7 @@ DEFINE_BITCAST(bitcast_u64_to_f64, uint64_t, double) do { \ VALUE_TYPE_##type rhs = POP_##type(); \ VALUE_TYPE_##type lhs = POP_##type(); \ - TRAP_IF(rhs == 0, INTEGER_DIVIDE_BY_ZERO); \ + TRAP_IF(rhs == 0, IntegerDivideByZero); \ if (WABT_UNLIKELY(lhs == VALUE_TYPE_SIGNED_MAX_##type && \ rhs == VALUE_TYPE_UNSIGNED_MAX_##type)) { \ PUSH_##type(0); \ @@ -767,21 +763,21 @@ WabtInterpreterResult wabt_call_host(WabtInterpreterThread* thread, WabtResult call_result = func->host.callback( func, sig, num_args, thread->host_args.data, num_results, call_result_values, func->host.user_data); - TRAP_IF(call_result != WABT_OK, HOST_TRAPPED); + TRAP_IF(call_result != WabtResult::Ok, HostTrapped); for (i = 0; i < num_results; ++i) { TRAP_IF(call_result_values[i].type != sig->result_types.data[i], - HOST_RESULT_TYPE_MISMATCH); + HostResultTypeMismatch); PUSH(call_result_values[i].value); } - return WABT_INTERPRETER_OK; + return WabtInterpreterResult::Ok; } WabtInterpreterResult wabt_run_interpreter(WabtInterpreterThread* thread, uint32_t num_instructions, uint32_t* call_stack_return_top) { - WabtInterpreterResult result = WABT_INTERPRETER_OK; + WabtInterpreterResult result = WabtInterpreterResult::Ok; assert(call_stack_return_top < thread->call_stack_end); WabtInterpreterEnvironment* env = thread->env; @@ -790,9 +786,9 @@ WabtInterpreterResult wabt_run_interpreter(WabtInterpreterThread* thread, const uint8_t* pc = &istream[thread->pc]; uint32_t i; for (i = 0; i < num_instructions; ++i) { - uint8_t opcode = *pc++; + WabtInterpreterOpcode opcode = static_cast<WabtInterpreterOpcode>(*pc++); switch (opcode) { - case WABT_OPCODE_SELECT: { + case WabtInterpreterOpcode::Select: { VALUE_TYPE_I32 cond = POP_I32(); WabtInterpreterValue false_ = POP(); WabtInterpreterValue true_ = POP(); @@ -800,18 +796,18 @@ WabtInterpreterResult wabt_run_interpreter(WabtInterpreterThread* thread, break; } - case WABT_OPCODE_BR: + case WabtInterpreterOpcode::Br: GOTO(read_u32(&pc)); break; - case WABT_OPCODE_BR_IF: { + case WabtInterpreterOpcode::BrIf: { uint32_t new_pc = read_u32(&pc); if (POP_I32()) GOTO(new_pc); break; } - case WABT_OPCODE_BR_TABLE: { + case WabtInterpreterOpcode::BrTable: { uint32_t num_targets = read_u32(&pc); uint32_t table_offset = read_u32(&pc); VALUE_TYPE_I32 key = POP_I32(); @@ -827,85 +823,85 @@ WabtInterpreterResult wabt_run_interpreter(WabtInterpreterThread* thread, break; } - case WABT_OPCODE_RETURN: + case WabtInterpreterOpcode::Return: if (thread->call_stack_top == call_stack_return_top) { - result = WABT_INTERPRETER_RETURNED; + result = WabtInterpreterResult::Returned; goto exit_loop; } GOTO(POP_CALL()); break; - case WABT_OPCODE_UNREACHABLE: - TRAP(UNREACHABLE); + case WabtInterpreterOpcode::Unreachable: + TRAP(Unreachable); break; - case WABT_OPCODE_I32_CONST: + case WabtInterpreterOpcode::I32Const: PUSH_I32(read_u32(&pc)); break; - case WABT_OPCODE_I64_CONST: + case WabtInterpreterOpcode::I64Const: PUSH_I64(read_u64(&pc)); break; - case WABT_OPCODE_F32_CONST: + case WabtInterpreterOpcode::F32Const: PUSH_F32(read_u32(&pc)); break; - case WABT_OPCODE_F64_CONST: + case WabtInterpreterOpcode::F64Const: PUSH_F64(read_u64(&pc)); break; - case WABT_OPCODE_GET_GLOBAL: { + case WabtInterpreterOpcode::GetGlobal: { uint32_t index = read_u32(&pc); assert(index < env->globals.size); PUSH(env->globals.data[index].typed_value.value); break; } - case WABT_OPCODE_SET_GLOBAL: { + case WabtInterpreterOpcode::SetGlobal: { uint32_t index = read_u32(&pc); assert(index < env->globals.size); env->globals.data[index].typed_value.value = POP(); break; } - case WABT_OPCODE_GET_LOCAL: { + case WabtInterpreterOpcode::GetLocal: { WabtInterpreterValue value = PICK(read_u32(&pc)); PUSH(value); break; } - case WABT_OPCODE_SET_LOCAL: { + case WabtInterpreterOpcode::SetLocal: { WabtInterpreterValue value = POP(); PICK(read_u32(&pc)) = value; break; } - case WABT_OPCODE_TEE_LOCAL: + case WabtInterpreterOpcode::TeeLocal: PICK(read_u32(&pc)) = TOP(); break; - case WABT_OPCODE_CALL: { + case WabtInterpreterOpcode::Call: { uint32_t offset = read_u32(&pc); PUSH_CALL(); GOTO(offset); break; } - case WABT_OPCODE_CALL_INDIRECT: { + case WabtInterpreterOpcode::CallIndirect: { uint32_t table_index = read_u32(&pc); assert(table_index < env->tables.size); WabtInterpreterTable* table = &env->tables.data[table_index]; uint32_t sig_index = read_u32(&pc); assert(sig_index < env->sigs.size); VALUE_TYPE_I32 entry_index = POP_I32(); - TRAP_IF(entry_index >= table->func_indexes.size, UNDEFINED_TABLE_INDEX); + TRAP_IF(entry_index >= table->func_indexes.size, UndefinedTableIndex); uint32_t func_index = table->func_indexes.data[entry_index]; - TRAP_IF(func_index == WABT_INVALID_INDEX, UNINITIALIZED_TABLE_ELEMENT); + TRAP_IF(func_index == WABT_INVALID_INDEX, UninitializedTableElement); WabtInterpreterFunc* func = &env->funcs.data[func_index]; TRAP_UNLESS( wabt_func_signatures_are_equal(env, func->sig_index, sig_index), - INDIRECT_CALL_SIGNATURE_MISMATCH); + IndirectCallSignatureMismatch); if (func->is_host) { wabt_call_host(thread, func); } else { @@ -915,7 +911,7 @@ WabtInterpreterResult wabt_run_interpreter(WabtInterpreterThread* thread, break; } - case WABT_OPCODE_CALL_HOST: { + case WabtInterpreterOpcode::CallHost: { uint32_t func_index = read_u32(&pc); assert(func_index < env->funcs.size); WabtInterpreterFunc* func = &env->funcs.data[func_index]; @@ -923,105 +919,105 @@ WabtInterpreterResult wabt_run_interpreter(WabtInterpreterThread* thread, break; } - case WABT_OPCODE_I32_LOAD8_S: + case WabtInterpreterOpcode::I32Load8S: LOAD(I32, I8); break; - case WABT_OPCODE_I32_LOAD8_U: + case WabtInterpreterOpcode::I32Load8U: LOAD(I32, U8); break; - case WABT_OPCODE_I32_LOAD16_S: + case WabtInterpreterOpcode::I32Load16S: LOAD(I32, I16); break; - case WABT_OPCODE_I32_LOAD16_U: + case WabtInterpreterOpcode::I32Load16U: LOAD(I32, U16); break; - case WABT_OPCODE_I64_LOAD8_S: + case WabtInterpreterOpcode::I64Load8S: LOAD(I64, I8); break; - case WABT_OPCODE_I64_LOAD8_U: + case WabtInterpreterOpcode::I64Load8U: LOAD(I64, U8); break; - case WABT_OPCODE_I64_LOAD16_S: + case WabtInterpreterOpcode::I64Load16S: LOAD(I64, I16); break; - case WABT_OPCODE_I64_LOAD16_U: + case WabtInterpreterOpcode::I64Load16U: LOAD(I64, U16); break; - case WABT_OPCODE_I64_LOAD32_S: + case WabtInterpreterOpcode::I64Load32S: LOAD(I64, I32); break; - case WABT_OPCODE_I64_LOAD32_U: + case WabtInterpreterOpcode::I64Load32U: LOAD(I64, U32); break; - case WABT_OPCODE_I32_LOAD: + case WabtInterpreterOpcode::I32Load: LOAD(I32, U32); break; - case WABT_OPCODE_I64_LOAD: + case WabtInterpreterOpcode::I64Load: LOAD(I64, U64); break; - case WABT_OPCODE_F32_LOAD: + case WabtInterpreterOpcode::F32Load: LOAD(F32, F32); break; - case WABT_OPCODE_F64_LOAD: + case WabtInterpreterOpcode::F64Load: LOAD(F64, F64); break; - case WABT_OPCODE_I32_STORE8: + case WabtInterpreterOpcode::I32Store8: STORE(I32, U8); break; - case WABT_OPCODE_I32_STORE16: + case WabtInterpreterOpcode::I32Store16: STORE(I32, U16); break; - case WABT_OPCODE_I64_STORE8: + case WabtInterpreterOpcode::I64Store8: STORE(I64, U8); break; - case WABT_OPCODE_I64_STORE16: + case WabtInterpreterOpcode::I64Store16: STORE(I64, U16); break; - case WABT_OPCODE_I64_STORE32: + case WabtInterpreterOpcode::I64Store32: STORE(I64, U32); break; - case WABT_OPCODE_I32_STORE: + case WabtInterpreterOpcode::I32Store: STORE(I32, U32); break; - case WABT_OPCODE_I64_STORE: + case WabtInterpreterOpcode::I64Store: STORE(I64, U64); break; - case WABT_OPCODE_F32_STORE: + case WabtInterpreterOpcode::F32Store: STORE(F32, F32); break; - case WABT_OPCODE_F64_STORE: + case WabtInterpreterOpcode::F64Store: STORE(F64, F64); break; - case WABT_OPCODE_CURRENT_MEMORY: { + case WabtInterpreterOpcode::CurrentMemory: { GET_MEMORY(memory); PUSH_I32(memory->page_limits.initial); break; } - case WABT_OPCODE_GROW_MEMORY: { + case WabtInterpreterOpcode::GrowMemory: { GET_MEMORY(memory); uint32_t old_page_size = memory->page_limits.initial; uint32_t old_byte_size = memory->byte_size; @@ -1046,507 +1042,507 @@ WabtInterpreterResult wabt_run_interpreter(WabtInterpreterThread* thread, break; } - case WABT_OPCODE_I32_ADD: + case WabtInterpreterOpcode::I32Add: BINOP(I32, I32, +); break; - case WABT_OPCODE_I32_SUB: + case WabtInterpreterOpcode::I32Sub: BINOP(I32, I32, -); break; - case WABT_OPCODE_I32_MUL: + case WabtInterpreterOpcode::I32Mul: BINOP(I32, I32, *); break; - case WABT_OPCODE_I32_DIV_S: + case WabtInterpreterOpcode::I32DivS: BINOP_DIV_S(I32); break; - case WABT_OPCODE_I32_DIV_U: + case WabtInterpreterOpcode::I32DivU: BINOP_DIV_REM_U(I32, / ); break; - case WABT_OPCODE_I32_REM_S: + case WabtInterpreterOpcode::I32RemS: BINOP_REM_S(I32); break; - case WABT_OPCODE_I32_REM_U: + case WabtInterpreterOpcode::I32RemU: BINOP_DIV_REM_U(I32, % ); break; - case WABT_OPCODE_I32_AND: + case WabtInterpreterOpcode::I32And: BINOP(I32, I32, &); break; - case WABT_OPCODE_I32_OR: + case WabtInterpreterOpcode::I32Or: BINOP(I32, I32, | ); break; - case WABT_OPCODE_I32_XOR: + case WabtInterpreterOpcode::I32Xor: BINOP(I32, I32, ^); break; - case WABT_OPCODE_I32_SHL: + case WabtInterpreterOpcode::I32Shl: BINOP_SHIFT(I32, <<, UNSIGNED); break; - case WABT_OPCODE_I32_SHR_U: + case WabtInterpreterOpcode::I32ShrU: BINOP_SHIFT(I32, >>, UNSIGNED); break; - case WABT_OPCODE_I32_SHR_S: + case WabtInterpreterOpcode::I32ShrS: BINOP_SHIFT(I32, >>, SIGNED); break; - case WABT_OPCODE_I32_EQ: + case WabtInterpreterOpcode::I32Eq: BINOP(I32, I32, == ); break; - case WABT_OPCODE_I32_NE: + case WabtInterpreterOpcode::I32Ne: BINOP(I32, I32, != ); break; - case WABT_OPCODE_I32_LT_S: + case WabtInterpreterOpcode::I32LtS: BINOP_SIGNED(I32, I32, < ); break; - case WABT_OPCODE_I32_LE_S: + case WabtInterpreterOpcode::I32LeS: BINOP_SIGNED(I32, I32, <= ); break; - case WABT_OPCODE_I32_LT_U: + case WabtInterpreterOpcode::I32LtU: BINOP(I32, I32, < ); break; - case WABT_OPCODE_I32_LE_U: + case WabtInterpreterOpcode::I32LeU: BINOP(I32, I32, <= ); break; - case WABT_OPCODE_I32_GT_S: + case WabtInterpreterOpcode::I32GtS: BINOP_SIGNED(I32, I32, > ); break; - case WABT_OPCODE_I32_GE_S: + case WabtInterpreterOpcode::I32GeS: BINOP_SIGNED(I32, I32, >= ); break; - case WABT_OPCODE_I32_GT_U: + case WabtInterpreterOpcode::I32GtU: BINOP(I32, I32, > ); break; - case WABT_OPCODE_I32_GE_U: + case WabtInterpreterOpcode::I32GeU: BINOP(I32, I32, >= ); break; - case WABT_OPCODE_I32_CLZ: { + case WabtInterpreterOpcode::I32Clz: { VALUE_TYPE_I32 value = POP_I32(); PUSH_I32(value != 0 ? wabt_clz_u32(value) : 32); break; } - case WABT_OPCODE_I32_CTZ: { + case WabtInterpreterOpcode::I32Ctz: { VALUE_TYPE_I32 value = POP_I32(); PUSH_I32(value != 0 ? wabt_ctz_u32(value) : 32); break; } - case WABT_OPCODE_I32_POPCNT: { + case WabtInterpreterOpcode::I32Popcnt: { VALUE_TYPE_I32 value = POP_I32(); PUSH_I32(wabt_popcount_u32(value)); break; } - case WABT_OPCODE_I32_EQZ: { + case WabtInterpreterOpcode::I32Eqz: { VALUE_TYPE_I32 value = POP_I32(); PUSH_I32(value == 0); break; } - case WABT_OPCODE_I64_ADD: + case WabtInterpreterOpcode::I64Add: BINOP(I64, I64, +); break; - case WABT_OPCODE_I64_SUB: + case WabtInterpreterOpcode::I64Sub: BINOP(I64, I64, -); break; - case WABT_OPCODE_I64_MUL: + case WabtInterpreterOpcode::I64Mul: BINOP(I64, I64, *); break; - case WABT_OPCODE_I64_DIV_S: + case WabtInterpreterOpcode::I64DivS: BINOP_DIV_S(I64); break; - case WABT_OPCODE_I64_DIV_U: + case WabtInterpreterOpcode::I64DivU: BINOP_DIV_REM_U(I64, / ); break; - case WABT_OPCODE_I64_REM_S: + case WabtInterpreterOpcode::I64RemS: BINOP_REM_S(I64); break; - case WABT_OPCODE_I64_REM_U: + case WabtInterpreterOpcode::I64RemU: BINOP_DIV_REM_U(I64, % ); break; - case WABT_OPCODE_I64_AND: + case WabtInterpreterOpcode::I64And: BINOP(I64, I64, &); break; - case WABT_OPCODE_I64_OR: + case WabtInterpreterOpcode::I64Or: BINOP(I64, I64, | ); break; - case WABT_OPCODE_I64_XOR: + case WabtInterpreterOpcode::I64Xor: BINOP(I64, I64, ^); break; - case WABT_OPCODE_I64_SHL: + case WabtInterpreterOpcode::I64Shl: BINOP_SHIFT(I64, <<, UNSIGNED); break; - case WABT_OPCODE_I64_SHR_U: + case WabtInterpreterOpcode::I64ShrU: BINOP_SHIFT(I64, >>, UNSIGNED); break; - case WABT_OPCODE_I64_SHR_S: + case WabtInterpreterOpcode::I64ShrS: BINOP_SHIFT(I64, >>, SIGNED); break; - case WABT_OPCODE_I64_EQ: + case WabtInterpreterOpcode::I64Eq: BINOP(I32, I64, == ); break; - case WABT_OPCODE_I64_NE: + case WabtInterpreterOpcode::I64Ne: BINOP(I32, I64, != ); break; - case WABT_OPCODE_I64_LT_S: + case WabtInterpreterOpcode::I64LtS: BINOP_SIGNED(I32, I64, < ); break; - case WABT_OPCODE_I64_LE_S: + case WabtInterpreterOpcode::I64LeS: BINOP_SIGNED(I32, I64, <= ); break; - case WABT_OPCODE_I64_LT_U: + case WabtInterpreterOpcode::I64LtU: BINOP(I32, I64, < ); break; - case WABT_OPCODE_I64_LE_U: + case WabtInterpreterOpcode::I64LeU: BINOP(I32, I64, <= ); break; - case WABT_OPCODE_I64_GT_S: + case WabtInterpreterOpcode::I64GtS: BINOP_SIGNED(I32, I64, > ); break; - case WABT_OPCODE_I64_GE_S: + case WabtInterpreterOpcode::I64GeS: BINOP_SIGNED(I32, I64, >= ); break; - case WABT_OPCODE_I64_GT_U: + case WabtInterpreterOpcode::I64GtU: BINOP(I32, I64, > ); break; - case WABT_OPCODE_I64_GE_U: + case WabtInterpreterOpcode::I64GeU: BINOP(I32, I64, >= ); break; - case WABT_OPCODE_I64_CLZ: { + case WabtInterpreterOpcode::I64Clz: { VALUE_TYPE_I64 value = POP_I64(); PUSH_I64(value != 0 ? wabt_clz_u64(value) : 64); break; } - case WABT_OPCODE_I64_CTZ: { + case WabtInterpreterOpcode::I64Ctz: { VALUE_TYPE_I64 value = POP_I64(); PUSH_I64(value != 0 ? wabt_ctz_u64(value) : 64); break; } - case WABT_OPCODE_I64_POPCNT: { + case WabtInterpreterOpcode::I64Popcnt: { VALUE_TYPE_I64 value = POP_I64(); PUSH_I64(wabt_popcount_u64(value)); break; } - case WABT_OPCODE_F32_ADD: + case WabtInterpreterOpcode::F32Add: BINOP_FLOAT(F32, +); break; - case WABT_OPCODE_F32_SUB: + case WabtInterpreterOpcode::F32Sub: BINOP_FLOAT(F32, -); break; - case WABT_OPCODE_F32_MUL: + case WabtInterpreterOpcode::F32Mul: BINOP_FLOAT(F32, *); break; - case WABT_OPCODE_F32_DIV: + case WabtInterpreterOpcode::F32Div: BINOP_FLOAT_DIV(F32); break; - case WABT_OPCODE_F32_MIN: + case WabtInterpreterOpcode::F32Min: MINMAX_FLOAT(F32, MIN); break; - case WABT_OPCODE_F32_MAX: + case WabtInterpreterOpcode::F32Max: MINMAX_FLOAT(F32, MAX); break; - case WABT_OPCODE_F32_ABS: + case WabtInterpreterOpcode::F32Abs: TOP().f32_bits &= ~F32_SIGN_MASK; break; - case WABT_OPCODE_F32_NEG: + case WabtInterpreterOpcode::F32Neg: TOP().f32_bits ^= F32_SIGN_MASK; break; - case WABT_OPCODE_F32_COPYSIGN: { + case WabtInterpreterOpcode::F32Copysign: { VALUE_TYPE_F32 rhs = POP_F32(); VALUE_TYPE_F32 lhs = POP_F32(); PUSH_F32((lhs & ~F32_SIGN_MASK) | (rhs & F32_SIGN_MASK)); break; } - case WABT_OPCODE_F32_CEIL: + case WabtInterpreterOpcode::F32Ceil: UNOP_FLOAT(F32, ceilf); break; - case WABT_OPCODE_F32_FLOOR: + case WabtInterpreterOpcode::F32Floor: UNOP_FLOAT(F32, floorf); break; - case WABT_OPCODE_F32_TRUNC: + case WabtInterpreterOpcode::F32Trunc: UNOP_FLOAT(F32, truncf); break; - case WABT_OPCODE_F32_NEAREST: + case WabtInterpreterOpcode::F32Nearest: UNOP_FLOAT(F32, nearbyintf); break; - case WABT_OPCODE_F32_SQRT: + case WabtInterpreterOpcode::F32Sqrt: UNOP_FLOAT(F32, sqrtf); break; - case WABT_OPCODE_F32_EQ: + case WabtInterpreterOpcode::F32Eq: BINOP_FLOAT_COMPARE(F32, == ); break; - case WABT_OPCODE_F32_NE: + case WabtInterpreterOpcode::F32Ne: BINOP_FLOAT_COMPARE(F32, != ); break; - case WABT_OPCODE_F32_LT: + case WabtInterpreterOpcode::F32Lt: BINOP_FLOAT_COMPARE(F32, < ); break; - case WABT_OPCODE_F32_LE: + case WabtInterpreterOpcode::F32Le: BINOP_FLOAT_COMPARE(F32, <= ); break; - case WABT_OPCODE_F32_GT: + case WabtInterpreterOpcode::F32Gt: BINOP_FLOAT_COMPARE(F32, > ); break; - case WABT_OPCODE_F32_GE: + case WabtInterpreterOpcode::F32Ge: BINOP_FLOAT_COMPARE(F32, >= ); break; - case WABT_OPCODE_F64_ADD: + case WabtInterpreterOpcode::F64Add: BINOP_FLOAT(F64, +); break; - case WABT_OPCODE_F64_SUB: + case WabtInterpreterOpcode::F64Sub: BINOP_FLOAT(F64, -); break; - case WABT_OPCODE_F64_MUL: + case WabtInterpreterOpcode::F64Mul: BINOP_FLOAT(F64, *); break; - case WABT_OPCODE_F64_DIV: + case WabtInterpreterOpcode::F64Div: BINOP_FLOAT_DIV(F64); break; - case WABT_OPCODE_F64_MIN: + case WabtInterpreterOpcode::F64Min: MINMAX_FLOAT(F64, MIN); break; - case WABT_OPCODE_F64_MAX: + case WabtInterpreterOpcode::F64Max: MINMAX_FLOAT(F64, MAX); break; - case WABT_OPCODE_F64_ABS: + case WabtInterpreterOpcode::F64Abs: TOP().f64_bits &= ~F64_SIGN_MASK; break; - case WABT_OPCODE_F64_NEG: + case WabtInterpreterOpcode::F64Neg: TOP().f64_bits ^= F64_SIGN_MASK; break; - case WABT_OPCODE_F64_COPYSIGN: { + case WabtInterpreterOpcode::F64Copysign: { VALUE_TYPE_F64 rhs = POP_F64(); VALUE_TYPE_F64 lhs = POP_F64(); PUSH_F64((lhs & ~F64_SIGN_MASK) | (rhs & F64_SIGN_MASK)); break; } - case WABT_OPCODE_F64_CEIL: + case WabtInterpreterOpcode::F64Ceil: UNOP_FLOAT(F64, ceil); break; - case WABT_OPCODE_F64_FLOOR: + case WabtInterpreterOpcode::F64Floor: UNOP_FLOAT(F64, floor); break; - case WABT_OPCODE_F64_TRUNC: + case WabtInterpreterOpcode::F64Trunc: UNOP_FLOAT(F64, trunc); break; - case WABT_OPCODE_F64_NEAREST: + case WabtInterpreterOpcode::F64Nearest: UNOP_FLOAT(F64, nearbyint); break; - case WABT_OPCODE_F64_SQRT: + case WabtInterpreterOpcode::F64Sqrt: UNOP_FLOAT(F64, sqrt); break; - case WABT_OPCODE_F64_EQ: + case WabtInterpreterOpcode::F64Eq: BINOP_FLOAT_COMPARE(F64, == ); break; - case WABT_OPCODE_F64_NE: + case WabtInterpreterOpcode::F64Ne: BINOP_FLOAT_COMPARE(F64, != ); break; - case WABT_OPCODE_F64_LT: + case WabtInterpreterOpcode::F64Lt: BINOP_FLOAT_COMPARE(F64, < ); break; - case WABT_OPCODE_F64_LE: + case WabtInterpreterOpcode::F64Le: BINOP_FLOAT_COMPARE(F64, <= ); break; - case WABT_OPCODE_F64_GT: + case WabtInterpreterOpcode::F64Gt: BINOP_FLOAT_COMPARE(F64, > ); break; - case WABT_OPCODE_F64_GE: + case WabtInterpreterOpcode::F64Ge: BINOP_FLOAT_COMPARE(F64, >= ); break; - case WABT_OPCODE_I32_TRUNC_S_F32: { + case WabtInterpreterOpcode::I32TruncSF32: { VALUE_TYPE_F32 value = POP_F32(); - TRAP_IF(wabt_is_nan_f32(value), INVALID_CONVERSION_TO_INTEGER); - TRAP_UNLESS(is_in_range_i32_trunc_s_f32(value), INTEGER_OVERFLOW); + TRAP_IF(wabt_is_nan_f32(value), InvalidConversionToInteger); + TRAP_UNLESS(is_in_range_i32_trunc_s_f32(value), IntegerOverflow); PUSH_I32(static_cast<int32_t>(BITCAST_TO_F32(value))); break; } - case WABT_OPCODE_I32_TRUNC_S_F64: { + case WabtInterpreterOpcode::I32TruncSF64: { VALUE_TYPE_F64 value = POP_F64(); - TRAP_IF(wabt_is_nan_f64(value), INVALID_CONVERSION_TO_INTEGER); - TRAP_UNLESS(is_in_range_i32_trunc_s_f64(value), INTEGER_OVERFLOW); + TRAP_IF(wabt_is_nan_f64(value), InvalidConversionToInteger); + TRAP_UNLESS(is_in_range_i32_trunc_s_f64(value), IntegerOverflow); PUSH_I32(static_cast<int32_t>(BITCAST_TO_F64(value))); break; } - case WABT_OPCODE_I32_TRUNC_U_F32: { + case WabtInterpreterOpcode::I32TruncUF32: { VALUE_TYPE_F32 value = POP_F32(); - TRAP_IF(wabt_is_nan_f32(value), INVALID_CONVERSION_TO_INTEGER); - TRAP_UNLESS(is_in_range_i32_trunc_u_f32(value), INTEGER_OVERFLOW); + TRAP_IF(wabt_is_nan_f32(value), InvalidConversionToInteger); + TRAP_UNLESS(is_in_range_i32_trunc_u_f32(value), IntegerOverflow); PUSH_I32(static_cast<uint32_t>(BITCAST_TO_F32(value))); break; } - case WABT_OPCODE_I32_TRUNC_U_F64: { + case WabtInterpreterOpcode::I32TruncUF64: { VALUE_TYPE_F64 value = POP_F64(); - TRAP_IF(wabt_is_nan_f64(value), INVALID_CONVERSION_TO_INTEGER); - TRAP_UNLESS(is_in_range_i32_trunc_u_f64(value), INTEGER_OVERFLOW); + TRAP_IF(wabt_is_nan_f64(value), InvalidConversionToInteger); + TRAP_UNLESS(is_in_range_i32_trunc_u_f64(value), IntegerOverflow); PUSH_I32(static_cast<uint32_t>(BITCAST_TO_F64(value))); break; } - case WABT_OPCODE_I32_WRAP_I64: { + case WabtInterpreterOpcode::I32WrapI64: { VALUE_TYPE_I64 value = POP_I64(); PUSH_I32(static_cast<uint32_t>(value)); break; } - case WABT_OPCODE_I64_TRUNC_S_F32: { + case WabtInterpreterOpcode::I64TruncSF32: { VALUE_TYPE_F32 value = POP_F32(); - TRAP_IF(wabt_is_nan_f32(value), INVALID_CONVERSION_TO_INTEGER); - TRAP_UNLESS(is_in_range_i64_trunc_s_f32(value), INTEGER_OVERFLOW); + TRAP_IF(wabt_is_nan_f32(value), InvalidConversionToInteger); + TRAP_UNLESS(is_in_range_i64_trunc_s_f32(value), IntegerOverflow); PUSH_I64(static_cast<int64_t>(BITCAST_TO_F32(value))); break; } - case WABT_OPCODE_I64_TRUNC_S_F64: { + case WabtInterpreterOpcode::I64TruncSF64: { VALUE_TYPE_F64 value = POP_F64(); - TRAP_IF(wabt_is_nan_f64(value), INVALID_CONVERSION_TO_INTEGER); - TRAP_UNLESS(is_in_range_i64_trunc_s_f64(value), INTEGER_OVERFLOW); + TRAP_IF(wabt_is_nan_f64(value), InvalidConversionToInteger); + TRAP_UNLESS(is_in_range_i64_trunc_s_f64(value), IntegerOverflow); PUSH_I64(static_cast<int64_t>(BITCAST_TO_F64(value))); break; } - case WABT_OPCODE_I64_TRUNC_U_F32: { + case WabtInterpreterOpcode::I64TruncUF32: { VALUE_TYPE_F32 value = POP_F32(); - TRAP_IF(wabt_is_nan_f32(value), INVALID_CONVERSION_TO_INTEGER); - TRAP_UNLESS(is_in_range_i64_trunc_u_f32(value), INTEGER_OVERFLOW); + TRAP_IF(wabt_is_nan_f32(value), InvalidConversionToInteger); + TRAP_UNLESS(is_in_range_i64_trunc_u_f32(value), IntegerOverflow); PUSH_I64(static_cast<uint64_t>(BITCAST_TO_F32(value))); break; } - case WABT_OPCODE_I64_TRUNC_U_F64: { + case WabtInterpreterOpcode::I64TruncUF64: { VALUE_TYPE_F64 value = POP_F64(); - TRAP_IF(wabt_is_nan_f64(value), INVALID_CONVERSION_TO_INTEGER); - TRAP_UNLESS(is_in_range_i64_trunc_u_f64(value), INTEGER_OVERFLOW); + TRAP_IF(wabt_is_nan_f64(value), InvalidConversionToInteger); + TRAP_UNLESS(is_in_range_i64_trunc_u_f64(value), IntegerOverflow); PUSH_I64(static_cast<uint64_t>(BITCAST_TO_F64(value))); break; } - case WABT_OPCODE_I64_EXTEND_S_I32: { + case WabtInterpreterOpcode::I64ExtendSI32: { VALUE_TYPE_I32 value = POP_I32(); PUSH_I64(static_cast<int64_t>(BITCAST_I32_TO_SIGNED(value))); break; } - case WABT_OPCODE_I64_EXTEND_U_I32: { + case WabtInterpreterOpcode::I64ExtendUI32: { VALUE_TYPE_I32 value = POP_I32(); PUSH_I64(static_cast<uint64_t>(value)); break; } - case WABT_OPCODE_F32_CONVERT_S_I32: { + case WabtInterpreterOpcode::F32ConvertSI32: { VALUE_TYPE_I32 value = POP_I32(); PUSH_F32( BITCAST_FROM_F32(static_cast<float>(BITCAST_I32_TO_SIGNED(value)))); break; } - case WABT_OPCODE_F32_CONVERT_U_I32: { + case WabtInterpreterOpcode::F32ConvertUI32: { VALUE_TYPE_I32 value = POP_I32(); PUSH_F32(BITCAST_FROM_F32(static_cast<float>(value))); break; } - case WABT_OPCODE_F32_CONVERT_S_I64: { + case WabtInterpreterOpcode::F32ConvertSI64: { VALUE_TYPE_I64 value = POP_I64(); PUSH_F32( BITCAST_FROM_F32(static_cast<float>(BITCAST_I64_TO_SIGNED(value)))); break; } - case WABT_OPCODE_F32_CONVERT_U_I64: { + case WabtInterpreterOpcode::F32ConvertUI64: { VALUE_TYPE_I64 value = POP_I64(); PUSH_F32(BITCAST_FROM_F32(static_cast<float>(value))); break; } - case WABT_OPCODE_F32_DEMOTE_F64: { + case WabtInterpreterOpcode::F32DemoteF64: { VALUE_TYPE_F64 value = POP_F64(); if (WABT_LIKELY(is_in_range_f64_demote_f32(value))) { PUSH_F32(BITCAST_FROM_F32(static_cast<float>(BITCAST_TO_F64(value)))); @@ -1566,85 +1562,85 @@ WabtInterpreterResult wabt_run_interpreter(WabtInterpreterThread* thread, break; } - case WABT_OPCODE_F32_REINTERPRET_I32: { + case WabtInterpreterOpcode::F32ReinterpretI32: { VALUE_TYPE_I32 value = POP_I32(); PUSH_F32(value); break; } - case WABT_OPCODE_F64_CONVERT_S_I32: { + case WabtInterpreterOpcode::F64ConvertSI32: { VALUE_TYPE_I32 value = POP_I32(); PUSH_F64(BITCAST_FROM_F64( static_cast<double>(BITCAST_I32_TO_SIGNED(value)))); break; } - case WABT_OPCODE_F64_CONVERT_U_I32: { + case WabtInterpreterOpcode::F64ConvertUI32: { VALUE_TYPE_I32 value = POP_I32(); PUSH_F64(BITCAST_FROM_F64(static_cast<double>(value))); break; } - case WABT_OPCODE_F64_CONVERT_S_I64: { + case WabtInterpreterOpcode::F64ConvertSI64: { VALUE_TYPE_I64 value = POP_I64(); PUSH_F64(BITCAST_FROM_F64( static_cast<double>(BITCAST_I64_TO_SIGNED(value)))); break; } - case WABT_OPCODE_F64_CONVERT_U_I64: { + case WabtInterpreterOpcode::F64ConvertUI64: { VALUE_TYPE_I64 value = POP_I64(); PUSH_F64(BITCAST_FROM_F64(static_cast<double>(value))); break; } - case WABT_OPCODE_F64_PROMOTE_F32: { + case WabtInterpreterOpcode::F64PromoteF32: { VALUE_TYPE_F32 value = POP_F32(); PUSH_F64(BITCAST_FROM_F64(static_cast<double>(BITCAST_TO_F32(value)))); break; } - case WABT_OPCODE_F64_REINTERPRET_I64: { + case WabtInterpreterOpcode::F64ReinterpretI64: { VALUE_TYPE_I64 value = POP_I64(); PUSH_F64(value); break; } - case WABT_OPCODE_I32_REINTERPRET_F32: { + case WabtInterpreterOpcode::I32ReinterpretF32: { VALUE_TYPE_F32 value = POP_F32(); PUSH_I32(value); break; } - case WABT_OPCODE_I64_REINTERPRET_F64: { + case WabtInterpreterOpcode::I64ReinterpretF64: { VALUE_TYPE_F64 value = POP_F64(); PUSH_I64(value); break; } - case WABT_OPCODE_I32_ROTR: + case WabtInterpreterOpcode::I32Rotr: BINOP_ROT(I32, RIGHT); break; - case WABT_OPCODE_I32_ROTL: + case WabtInterpreterOpcode::I32Rotl: BINOP_ROT(I32, LEFT); break; - case WABT_OPCODE_I64_ROTR: + case WabtInterpreterOpcode::I64Rotr: BINOP_ROT(I64, RIGHT); break; - case WABT_OPCODE_I64_ROTL: + case WabtInterpreterOpcode::I64Rotl: BINOP_ROT(I64, LEFT); break; - case WABT_OPCODE_I64_EQZ: { + case WabtInterpreterOpcode::I64Eqz: { VALUE_TYPE_I64 value = POP_I64(); PUSH_I64(value == 0); break; } - case WABT_OPCODE_ALLOCA: { + case WabtInterpreterOpcode::Alloca: { WabtInterpreterValue* old_value_stack_top = thread->value_stack_top; thread->value_stack_top += read_u32(&pc); CHECK_STACK(); @@ -1654,30 +1650,30 @@ WabtInterpreterResult wabt_run_interpreter(WabtInterpreterThread* thread, break; } - case WABT_OPCODE_BR_UNLESS: { + case WabtInterpreterOpcode::BrUnless: { uint32_t new_pc = read_u32(&pc); if (!POP_I32()) GOTO(new_pc); break; } - case WABT_OPCODE_DROP: + case WabtInterpreterOpcode::Drop: (void)POP(); break; - case WABT_OPCODE_DROP_KEEP: { + case WabtInterpreterOpcode::DropKeep: { uint32_t drop_count = read_u32(&pc); uint8_t keep_count = *pc++; DROP_KEEP(drop_count, keep_count); break; } - case WABT_OPCODE_DATA: + case WabtInterpreterOpcode::Data: /* shouldn't ever execute this */ assert(0); break; - case WABT_OPCODE_NOP: + case WabtInterpreterOpcode::Nop: break; default: @@ -1703,26 +1699,26 @@ void wabt_trace_pc(WabtInterpreterThread* thread, WabtStream* stream) { pc - static_cast<uint8_t*>(thread->env->istream.start), value_stack_depth); - uint8_t opcode = *pc++; + WabtInterpreterOpcode opcode = static_cast<WabtInterpreterOpcode>(*pc++); switch (opcode) { - case WABT_OPCODE_SELECT: + case WabtInterpreterOpcode::Select: wabt_writef(stream, "%s %u, %" PRIu64 ", %" PRIu64 "\n", wabt_get_interpreter_opcode_name(opcode), PICK(3).i32, PICK(2).i64, PICK(1).i64); break; - case WABT_OPCODE_BR: + case WabtInterpreterOpcode::Br: wabt_writef(stream, "%s @%u\n", wabt_get_interpreter_opcode_name(opcode), read_u32_at(pc)); break; - case WABT_OPCODE_BR_IF: + case WabtInterpreterOpcode::BrIf: wabt_writef(stream, "%s @%u, %u\n", wabt_get_interpreter_opcode_name(opcode), read_u32_at(pc), TOP().i32); break; - case WABT_OPCODE_BR_TABLE: { + case WabtInterpreterOpcode::BrTable: { uint32_t num_targets = read_u32_at(pc); uint32_t table_offset = read_u32_at(pc + 4); VALUE_TYPE_I32 key = TOP().i32; @@ -1732,84 +1728,84 @@ void wabt_trace_pc(WabtInterpreterThread* thread, WabtStream* stream) { break; } - case WABT_OPCODE_NOP: - case WABT_OPCODE_RETURN: - case WABT_OPCODE_UNREACHABLE: - case WABT_OPCODE_DROP: + case WabtInterpreterOpcode::Nop: + case WabtInterpreterOpcode::Return: + case WabtInterpreterOpcode::Unreachable: + case WabtInterpreterOpcode::Drop: wabt_writef(stream, "%s\n", wabt_get_interpreter_opcode_name(opcode)); break; - case WABT_OPCODE_CURRENT_MEMORY: { + case WabtInterpreterOpcode::CurrentMemory: { uint32_t memory_index = read_u32(&pc); wabt_writef(stream, "%s $%u\n", wabt_get_interpreter_opcode_name(opcode), memory_index); break; } - case WABT_OPCODE_I32_CONST: + case WabtInterpreterOpcode::I32Const: wabt_writef(stream, "%s $%u\n", wabt_get_interpreter_opcode_name(opcode), read_u32_at(pc)); break; - case WABT_OPCODE_I64_CONST: + case WabtInterpreterOpcode::I64Const: wabt_writef(stream, "%s $%" PRIu64 "\n", wabt_get_interpreter_opcode_name(opcode), read_u64_at(pc)); break; - case WABT_OPCODE_F32_CONST: + case WabtInterpreterOpcode::F32Const: wabt_writef(stream, "%s $%g\n", wabt_get_interpreter_opcode_name(opcode), bitcast_u32_to_f32(read_u32_at(pc))); break; - case WABT_OPCODE_F64_CONST: + case WabtInterpreterOpcode::F64Const: wabt_writef(stream, "%s $%g\n", wabt_get_interpreter_opcode_name(opcode), bitcast_u64_to_f64(read_u64_at(pc))); break; - case WABT_OPCODE_GET_LOCAL: - case WABT_OPCODE_GET_GLOBAL: + case WabtInterpreterOpcode::GetLocal: + case WabtInterpreterOpcode::GetGlobal: wabt_writef(stream, "%s $%u\n", wabt_get_interpreter_opcode_name(opcode), read_u32_at(pc)); break; - case WABT_OPCODE_SET_LOCAL: - case WABT_OPCODE_SET_GLOBAL: - case WABT_OPCODE_TEE_LOCAL: + case WabtInterpreterOpcode::SetLocal: + case WabtInterpreterOpcode::SetGlobal: + case WabtInterpreterOpcode::TeeLocal: wabt_writef(stream, "%s $%u, %u\n", wabt_get_interpreter_opcode_name(opcode), read_u32_at(pc), TOP().i32); break; - case WABT_OPCODE_CALL: + case WabtInterpreterOpcode::Call: wabt_writef(stream, "%s @%u\n", wabt_get_interpreter_opcode_name(opcode), read_u32_at(pc)); break; - case WABT_OPCODE_CALL_INDIRECT: + case WabtInterpreterOpcode::CallIndirect: wabt_writef(stream, "%s $%u, %u\n", wabt_get_interpreter_opcode_name(opcode), read_u32_at(pc), TOP().i32); break; - case WABT_OPCODE_CALL_HOST: + case WabtInterpreterOpcode::CallHost: wabt_writef(stream, "%s $%u\n", wabt_get_interpreter_opcode_name(opcode), read_u32_at(pc)); break; - case WABT_OPCODE_I32_LOAD8_S: - case WABT_OPCODE_I32_LOAD8_U: - case WABT_OPCODE_I32_LOAD16_S: - case WABT_OPCODE_I32_LOAD16_U: - case WABT_OPCODE_I64_LOAD8_S: - case WABT_OPCODE_I64_LOAD8_U: - case WABT_OPCODE_I64_LOAD16_S: - case WABT_OPCODE_I64_LOAD16_U: - case WABT_OPCODE_I64_LOAD32_S: - case WABT_OPCODE_I64_LOAD32_U: - case WABT_OPCODE_I32_LOAD: - case WABT_OPCODE_I64_LOAD: - case WABT_OPCODE_F32_LOAD: - case WABT_OPCODE_F64_LOAD: { + case WabtInterpreterOpcode::I32Load8S: + case WabtInterpreterOpcode::I32Load8U: + case WabtInterpreterOpcode::I32Load16S: + case WabtInterpreterOpcode::I32Load16U: + case WabtInterpreterOpcode::I64Load8S: + case WabtInterpreterOpcode::I64Load8U: + case WabtInterpreterOpcode::I64Load16S: + case WabtInterpreterOpcode::I64Load16U: + case WabtInterpreterOpcode::I64Load32S: + case WabtInterpreterOpcode::I64Load32U: + case WabtInterpreterOpcode::I32Load: + case WabtInterpreterOpcode::I64Load: + case WabtInterpreterOpcode::F32Load: + case WabtInterpreterOpcode::F64Load: { uint32_t memory_index = read_u32(&pc); wabt_writef(stream, "%s $%u:%u+$%u\n", wabt_get_interpreter_opcode_name(opcode), memory_index, @@ -1817,9 +1813,9 @@ void wabt_trace_pc(WabtInterpreterThread* thread, WabtStream* stream) { break; } - case WABT_OPCODE_I32_STORE8: - case WABT_OPCODE_I32_STORE16: - case WABT_OPCODE_I32_STORE: { + case WabtInterpreterOpcode::I32Store8: + case WabtInterpreterOpcode::I32Store16: + case WabtInterpreterOpcode::I32Store: { uint32_t memory_index = read_u32(&pc); wabt_writef(stream, "%s $%u:%u+$%u, %u\n", wabt_get_interpreter_opcode_name(opcode), memory_index, @@ -1827,10 +1823,10 @@ void wabt_trace_pc(WabtInterpreterThread* thread, WabtStream* stream) { break; } - case WABT_OPCODE_I64_STORE8: - case WABT_OPCODE_I64_STORE16: - case WABT_OPCODE_I64_STORE32: - case WABT_OPCODE_I64_STORE: { + case WabtInterpreterOpcode::I64Store8: + case WabtInterpreterOpcode::I64Store16: + case WabtInterpreterOpcode::I64Store32: + case WabtInterpreterOpcode::I64Store: { uint32_t memory_index = read_u32(&pc); wabt_writef(stream, "%s $%u:%u+$%u, %" PRIu64 "\n", wabt_get_interpreter_opcode_name(opcode), memory_index, @@ -1838,7 +1834,7 @@ void wabt_trace_pc(WabtInterpreterThread* thread, WabtStream* stream) { break; } - case WABT_OPCODE_F32_STORE: { + case WabtInterpreterOpcode::F32Store: { uint32_t memory_index = read_u32(&pc); wabt_writef(stream, "%s $%u:%u+$%u, %g\n", wabt_get_interpreter_opcode_name(opcode), memory_index, @@ -1847,7 +1843,7 @@ void wabt_trace_pc(WabtInterpreterThread* thread, WabtStream* stream) { break; } - case WABT_OPCODE_F64_STORE: { + case WabtInterpreterOpcode::F64Store: { uint32_t memory_index = read_u32(&pc); wabt_writef(stream, "%s $%u:%u+$%u, %g\n", wabt_get_interpreter_opcode_name(opcode), memory_index, @@ -1856,7 +1852,7 @@ void wabt_trace_pc(WabtInterpreterThread* thread, WabtStream* stream) { break; } - case WABT_OPCODE_GROW_MEMORY: { + case WabtInterpreterOpcode::GrowMemory: { uint32_t memory_index = read_u32(&pc); wabt_writef(stream, "%s $%u:%u\n", wabt_get_interpreter_opcode_name(opcode), memory_index, @@ -1864,199 +1860,199 @@ void wabt_trace_pc(WabtInterpreterThread* thread, WabtStream* stream) { break; } - case WABT_OPCODE_I32_ADD: - case WABT_OPCODE_I32_SUB: - case WABT_OPCODE_I32_MUL: - case WABT_OPCODE_I32_DIV_S: - case WABT_OPCODE_I32_DIV_U: - case WABT_OPCODE_I32_REM_S: - case WABT_OPCODE_I32_REM_U: - case WABT_OPCODE_I32_AND: - case WABT_OPCODE_I32_OR: - case WABT_OPCODE_I32_XOR: - case WABT_OPCODE_I32_SHL: - case WABT_OPCODE_I32_SHR_U: - case WABT_OPCODE_I32_SHR_S: - case WABT_OPCODE_I32_EQ: - case WABT_OPCODE_I32_NE: - case WABT_OPCODE_I32_LT_S: - case WABT_OPCODE_I32_LE_S: - case WABT_OPCODE_I32_LT_U: - case WABT_OPCODE_I32_LE_U: - case WABT_OPCODE_I32_GT_S: - case WABT_OPCODE_I32_GE_S: - case WABT_OPCODE_I32_GT_U: - case WABT_OPCODE_I32_GE_U: - case WABT_OPCODE_I32_ROTR: - case WABT_OPCODE_I32_ROTL: + case WabtInterpreterOpcode::I32Add: + case WabtInterpreterOpcode::I32Sub: + case WabtInterpreterOpcode::I32Mul: + case WabtInterpreterOpcode::I32DivS: + case WabtInterpreterOpcode::I32DivU: + case WabtInterpreterOpcode::I32RemS: + case WabtInterpreterOpcode::I32RemU: + case WabtInterpreterOpcode::I32And: + case WabtInterpreterOpcode::I32Or: + case WabtInterpreterOpcode::I32Xor: + case WabtInterpreterOpcode::I32Shl: + case WabtInterpreterOpcode::I32ShrU: + case WabtInterpreterOpcode::I32ShrS: + case WabtInterpreterOpcode::I32Eq: + case WabtInterpreterOpcode::I32Ne: + case WabtInterpreterOpcode::I32LtS: + case WabtInterpreterOpcode::I32LeS: + case WabtInterpreterOpcode::I32LtU: + case WabtInterpreterOpcode::I32LeU: + case WabtInterpreterOpcode::I32GtS: + case WabtInterpreterOpcode::I32GeS: + case WabtInterpreterOpcode::I32GtU: + case WabtInterpreterOpcode::I32GeU: + case WabtInterpreterOpcode::I32Rotr: + case WabtInterpreterOpcode::I32Rotl: wabt_writef(stream, "%s %u, %u\n", wabt_get_interpreter_opcode_name(opcode), PICK(2).i32, PICK(1).i32); break; - case WABT_OPCODE_I32_CLZ: - case WABT_OPCODE_I32_CTZ: - case WABT_OPCODE_I32_POPCNT: - case WABT_OPCODE_I32_EQZ: + case WabtInterpreterOpcode::I32Clz: + case WabtInterpreterOpcode::I32Ctz: + case WabtInterpreterOpcode::I32Popcnt: + case WabtInterpreterOpcode::I32Eqz: wabt_writef(stream, "%s %u\n", wabt_get_interpreter_opcode_name(opcode), TOP().i32); break; - case WABT_OPCODE_I64_ADD: - case WABT_OPCODE_I64_SUB: - case WABT_OPCODE_I64_MUL: - case WABT_OPCODE_I64_DIV_S: - case WABT_OPCODE_I64_DIV_U: - case WABT_OPCODE_I64_REM_S: - case WABT_OPCODE_I64_REM_U: - case WABT_OPCODE_I64_AND: - case WABT_OPCODE_I64_OR: - case WABT_OPCODE_I64_XOR: - case WABT_OPCODE_I64_SHL: - case WABT_OPCODE_I64_SHR_U: - case WABT_OPCODE_I64_SHR_S: - case WABT_OPCODE_I64_EQ: - case WABT_OPCODE_I64_NE: - case WABT_OPCODE_I64_LT_S: - case WABT_OPCODE_I64_LE_S: - case WABT_OPCODE_I64_LT_U: - case WABT_OPCODE_I64_LE_U: - case WABT_OPCODE_I64_GT_S: - case WABT_OPCODE_I64_GE_S: - case WABT_OPCODE_I64_GT_U: - case WABT_OPCODE_I64_GE_U: - case WABT_OPCODE_I64_ROTR: - case WABT_OPCODE_I64_ROTL: + case WabtInterpreterOpcode::I64Add: + case WabtInterpreterOpcode::I64Sub: + case WabtInterpreterOpcode::I64Mul: + case WabtInterpreterOpcode::I64DivS: + case WabtInterpreterOpcode::I64DivU: + case WabtInterpreterOpcode::I64RemS: + case WabtInterpreterOpcode::I64RemU: + case WabtInterpreterOpcode::I64And: + case WabtInterpreterOpcode::I64Or: + case WabtInterpreterOpcode::I64Xor: + case WabtInterpreterOpcode::I64Shl: + case WabtInterpreterOpcode::I64ShrU: + case WabtInterpreterOpcode::I64ShrS: + case WabtInterpreterOpcode::I64Eq: + case WabtInterpreterOpcode::I64Ne: + case WabtInterpreterOpcode::I64LtS: + case WabtInterpreterOpcode::I64LeS: + case WabtInterpreterOpcode::I64LtU: + case WabtInterpreterOpcode::I64LeU: + case WabtInterpreterOpcode::I64GtS: + case WabtInterpreterOpcode::I64GeS: + case WabtInterpreterOpcode::I64GtU: + case WabtInterpreterOpcode::I64GeU: + case WabtInterpreterOpcode::I64Rotr: + case WabtInterpreterOpcode::I64Rotl: wabt_writef(stream, "%s %" PRIu64 ", %" PRIu64 "\n", wabt_get_interpreter_opcode_name(opcode), PICK(2).i64, PICK(1).i64); break; - case WABT_OPCODE_I64_CLZ: - case WABT_OPCODE_I64_CTZ: - case WABT_OPCODE_I64_POPCNT: - case WABT_OPCODE_I64_EQZ: + case WabtInterpreterOpcode::I64Clz: + case WabtInterpreterOpcode::I64Ctz: + case WabtInterpreterOpcode::I64Popcnt: + case WabtInterpreterOpcode::I64Eqz: wabt_writef(stream, "%s %" PRIu64 "\n", wabt_get_interpreter_opcode_name(opcode), TOP().i64); break; - case WABT_OPCODE_F32_ADD: - case WABT_OPCODE_F32_SUB: - case WABT_OPCODE_F32_MUL: - case WABT_OPCODE_F32_DIV: - case WABT_OPCODE_F32_MIN: - case WABT_OPCODE_F32_MAX: - case WABT_OPCODE_F32_COPYSIGN: - case WABT_OPCODE_F32_EQ: - case WABT_OPCODE_F32_NE: - case WABT_OPCODE_F32_LT: - case WABT_OPCODE_F32_LE: - case WABT_OPCODE_F32_GT: - case WABT_OPCODE_F32_GE: + case WabtInterpreterOpcode::F32Add: + case WabtInterpreterOpcode::F32Sub: + case WabtInterpreterOpcode::F32Mul: + case WabtInterpreterOpcode::F32Div: + case WabtInterpreterOpcode::F32Min: + case WabtInterpreterOpcode::F32Max: + case WabtInterpreterOpcode::F32Copysign: + case WabtInterpreterOpcode::F32Eq: + case WabtInterpreterOpcode::F32Ne: + case WabtInterpreterOpcode::F32Lt: + case WabtInterpreterOpcode::F32Le: + case WabtInterpreterOpcode::F32Gt: + case WabtInterpreterOpcode::F32Ge: wabt_writef( stream, "%s %g, %g\n", wabt_get_interpreter_opcode_name(opcode), bitcast_u32_to_f32(PICK(2).i32), bitcast_u32_to_f32(PICK(1).i32)); break; - case WABT_OPCODE_F32_ABS: - case WABT_OPCODE_F32_NEG: - case WABT_OPCODE_F32_CEIL: - case WABT_OPCODE_F32_FLOOR: - case WABT_OPCODE_F32_TRUNC: - case WABT_OPCODE_F32_NEAREST: - case WABT_OPCODE_F32_SQRT: + case WabtInterpreterOpcode::F32Abs: + case WabtInterpreterOpcode::F32Neg: + case WabtInterpreterOpcode::F32Ceil: + case WabtInterpreterOpcode::F32Floor: + case WabtInterpreterOpcode::F32Trunc: + case WabtInterpreterOpcode::F32Nearest: + case WabtInterpreterOpcode::F32Sqrt: wabt_writef(stream, "%s %g\n", wabt_get_interpreter_opcode_name(opcode), bitcast_u32_to_f32(TOP().i32)); break; - case WABT_OPCODE_F64_ADD: - case WABT_OPCODE_F64_SUB: - case WABT_OPCODE_F64_MUL: - case WABT_OPCODE_F64_DIV: - case WABT_OPCODE_F64_MIN: - case WABT_OPCODE_F64_MAX: - case WABT_OPCODE_F64_COPYSIGN: - case WABT_OPCODE_F64_EQ: - case WABT_OPCODE_F64_NE: - case WABT_OPCODE_F64_LT: - case WABT_OPCODE_F64_LE: - case WABT_OPCODE_F64_GT: - case WABT_OPCODE_F64_GE: + case WabtInterpreterOpcode::F64Add: + case WabtInterpreterOpcode::F64Sub: + case WabtInterpreterOpcode::F64Mul: + case WabtInterpreterOpcode::F64Div: + case WabtInterpreterOpcode::F64Min: + case WabtInterpreterOpcode::F64Max: + case WabtInterpreterOpcode::F64Copysign: + case WabtInterpreterOpcode::F64Eq: + case WabtInterpreterOpcode::F64Ne: + case WabtInterpreterOpcode::F64Lt: + case WabtInterpreterOpcode::F64Le: + case WabtInterpreterOpcode::F64Gt: + case WabtInterpreterOpcode::F64Ge: wabt_writef( stream, "%s %g, %g\n", wabt_get_interpreter_opcode_name(opcode), bitcast_u64_to_f64(PICK(2).i64), bitcast_u64_to_f64(PICK(1).i64)); break; - case WABT_OPCODE_F64_ABS: - case WABT_OPCODE_F64_NEG: - case WABT_OPCODE_F64_CEIL: - case WABT_OPCODE_F64_FLOOR: - case WABT_OPCODE_F64_TRUNC: - case WABT_OPCODE_F64_NEAREST: - case WABT_OPCODE_F64_SQRT: + case WabtInterpreterOpcode::F64Abs: + case WabtInterpreterOpcode::F64Neg: + case WabtInterpreterOpcode::F64Ceil: + case WabtInterpreterOpcode::F64Floor: + case WabtInterpreterOpcode::F64Trunc: + case WabtInterpreterOpcode::F64Nearest: + case WabtInterpreterOpcode::F64Sqrt: wabt_writef(stream, "%s %g\n", wabt_get_interpreter_opcode_name(opcode), bitcast_u64_to_f64(TOP().i64)); break; - case WABT_OPCODE_I32_TRUNC_S_F32: - case WABT_OPCODE_I32_TRUNC_U_F32: - case WABT_OPCODE_I64_TRUNC_S_F32: - case WABT_OPCODE_I64_TRUNC_U_F32: - case WABT_OPCODE_F64_PROMOTE_F32: - case WABT_OPCODE_I32_REINTERPRET_F32: + case WabtInterpreterOpcode::I32TruncSF32: + case WabtInterpreterOpcode::I32TruncUF32: + case WabtInterpreterOpcode::I64TruncSF32: + case WabtInterpreterOpcode::I64TruncUF32: + case WabtInterpreterOpcode::F64PromoteF32: + case WabtInterpreterOpcode::I32ReinterpretF32: wabt_writef(stream, "%s %g\n", wabt_get_interpreter_opcode_name(opcode), bitcast_u32_to_f32(TOP().i32)); break; - case WABT_OPCODE_I32_TRUNC_S_F64: - case WABT_OPCODE_I32_TRUNC_U_F64: - case WABT_OPCODE_I64_TRUNC_S_F64: - case WABT_OPCODE_I64_TRUNC_U_F64: - case WABT_OPCODE_F32_DEMOTE_F64: - case WABT_OPCODE_I64_REINTERPRET_F64: + case WabtInterpreterOpcode::I32TruncSF64: + case WabtInterpreterOpcode::I32TruncUF64: + case WabtInterpreterOpcode::I64TruncSF64: + case WabtInterpreterOpcode::I64TruncUF64: + case WabtInterpreterOpcode::F32DemoteF64: + case WabtInterpreterOpcode::I64ReinterpretF64: wabt_writef(stream, "%s %g\n", wabt_get_interpreter_opcode_name(opcode), bitcast_u64_to_f64(TOP().i64)); break; - case WABT_OPCODE_I32_WRAP_I64: - case WABT_OPCODE_F32_CONVERT_S_I64: - case WABT_OPCODE_F32_CONVERT_U_I64: - case WABT_OPCODE_F64_CONVERT_S_I64: - case WABT_OPCODE_F64_CONVERT_U_I64: - case WABT_OPCODE_F64_REINTERPRET_I64: + case WabtInterpreterOpcode::I32WrapI64: + case WabtInterpreterOpcode::F32ConvertSI64: + case WabtInterpreterOpcode::F32ConvertUI64: + case WabtInterpreterOpcode::F64ConvertSI64: + case WabtInterpreterOpcode::F64ConvertUI64: + case WabtInterpreterOpcode::F64ReinterpretI64: wabt_writef(stream, "%s %" PRIu64 "\n", wabt_get_interpreter_opcode_name(opcode), TOP().i64); break; - case WABT_OPCODE_I64_EXTEND_S_I32: - case WABT_OPCODE_I64_EXTEND_U_I32: - case WABT_OPCODE_F32_CONVERT_S_I32: - case WABT_OPCODE_F32_CONVERT_U_I32: - case WABT_OPCODE_F32_REINTERPRET_I32: - case WABT_OPCODE_F64_CONVERT_S_I32: - case WABT_OPCODE_F64_CONVERT_U_I32: + case WabtInterpreterOpcode::I64ExtendSI32: + case WabtInterpreterOpcode::I64ExtendUI32: + case WabtInterpreterOpcode::F32ConvertSI32: + case WabtInterpreterOpcode::F32ConvertUI32: + case WabtInterpreterOpcode::F32ReinterpretI32: + case WabtInterpreterOpcode::F64ConvertSI32: + case WabtInterpreterOpcode::F64ConvertUI32: wabt_writef(stream, "%s %u\n", wabt_get_interpreter_opcode_name(opcode), TOP().i32); break; - case WABT_OPCODE_ALLOCA: + case WabtInterpreterOpcode::Alloca: wabt_writef(stream, "%s $%u\n", wabt_get_interpreter_opcode_name(opcode), read_u32_at(pc)); break; - case WABT_OPCODE_BR_UNLESS: + case WabtInterpreterOpcode::BrUnless: wabt_writef(stream, "%s @%u, %u\n", wabt_get_interpreter_opcode_name(opcode), read_u32_at(pc), TOP().i32); break; - case WABT_OPCODE_DROP_KEEP: + case WabtInterpreterOpcode::DropKeep: wabt_writef(stream, "%s $%u $%u\n", wabt_get_interpreter_opcode_name(opcode), read_u32_at(pc), *(pc + 4)); break; - case WABT_OPCODE_DATA: + case WabtInterpreterOpcode::Data: /* shouldn't ever execute this */ assert(0); break; @@ -2083,24 +2079,24 @@ void wabt_disassemble(WabtInterpreterEnvironment* env, while (static_cast<uint32_t>(pc - istream) < to) { wabt_writef(stream, "%4" PRIzd "| ", pc - istream); - uint8_t opcode = *pc++; + WabtInterpreterOpcode opcode = static_cast<WabtInterpreterOpcode>(*pc++); switch (opcode) { - case WABT_OPCODE_SELECT: + case WabtInterpreterOpcode::Select: wabt_writef(stream, "%s %%[-3], %%[-2], %%[-1]\n", wabt_get_interpreter_opcode_name(opcode)); break; - case WABT_OPCODE_BR: + case WabtInterpreterOpcode::Br: wabt_writef(stream, "%s @%u\n", wabt_get_interpreter_opcode_name(opcode), read_u32(&pc)); break; - case WABT_OPCODE_BR_IF: + case WabtInterpreterOpcode::BrIf: wabt_writef(stream, "%s @%u, %%[-1]\n", wabt_get_interpreter_opcode_name(opcode), read_u32(&pc)); break; - case WABT_OPCODE_BR_TABLE: { + case WabtInterpreterOpcode::BrTable: { uint32_t num_targets = read_u32(&pc); uint32_t table_offset = read_u32(&pc); wabt_writef(stream, "%s %%[-1], $#%u, table:$%u\n", @@ -2109,61 +2105,61 @@ void wabt_disassemble(WabtInterpreterEnvironment* env, break; } - case WABT_OPCODE_NOP: - case WABT_OPCODE_RETURN: - case WABT_OPCODE_UNREACHABLE: - case WABT_OPCODE_DROP: + case WabtInterpreterOpcode::Nop: + case WabtInterpreterOpcode::Return: + case WabtInterpreterOpcode::Unreachable: + case WabtInterpreterOpcode::Drop: wabt_writef(stream, "%s\n", wabt_get_interpreter_opcode_name(opcode)); break; - case WABT_OPCODE_CURRENT_MEMORY: { + case WabtInterpreterOpcode::CurrentMemory: { uint32_t memory_index = read_u32(&pc); wabt_writef(stream, "%s $%u\n", wabt_get_interpreter_opcode_name(opcode), memory_index); break; } - case WABT_OPCODE_I32_CONST: + case WabtInterpreterOpcode::I32Const: wabt_writef(stream, "%s $%u\n", wabt_get_interpreter_opcode_name(opcode), read_u32(&pc)); break; - case WABT_OPCODE_I64_CONST: + case WabtInterpreterOpcode::I64Const: wabt_writef(stream, "%s $%" PRIu64 "\n", wabt_get_interpreter_opcode_name(opcode), read_u64(&pc)); break; - case WABT_OPCODE_F32_CONST: + case WabtInterpreterOpcode::F32Const: wabt_writef(stream, "%s $%g\n", wabt_get_interpreter_opcode_name(opcode), bitcast_u32_to_f32(read_u32(&pc))); break; - case WABT_OPCODE_F64_CONST: + case WabtInterpreterOpcode::F64Const: wabt_writef(stream, "%s $%g\n", wabt_get_interpreter_opcode_name(opcode), bitcast_u64_to_f64(read_u64(&pc))); break; - case WABT_OPCODE_GET_LOCAL: - case WABT_OPCODE_GET_GLOBAL: + case WabtInterpreterOpcode::GetLocal: + case WabtInterpreterOpcode::GetGlobal: wabt_writef(stream, "%s $%u\n", wabt_get_interpreter_opcode_name(opcode), read_u32(&pc)); break; - case WABT_OPCODE_SET_LOCAL: - case WABT_OPCODE_SET_GLOBAL: - case WABT_OPCODE_TEE_LOCAL: + case WabtInterpreterOpcode::SetLocal: + case WabtInterpreterOpcode::SetGlobal: + case WabtInterpreterOpcode::TeeLocal: wabt_writef(stream, "%s $%u, %%[-1]\n", wabt_get_interpreter_opcode_name(opcode), read_u32(&pc)); break; - case WABT_OPCODE_CALL: + case WabtInterpreterOpcode::Call: wabt_writef(stream, "%s @%u\n", wabt_get_interpreter_opcode_name(opcode), read_u32(&pc)); break; - case WABT_OPCODE_CALL_INDIRECT: { + case WabtInterpreterOpcode::CallIndirect: { uint32_t table_index = read_u32(&pc); wabt_writef(stream, "%s $%u:%u, %%[-1]\n", wabt_get_interpreter_opcode_name(opcode), table_index, @@ -2171,25 +2167,25 @@ void wabt_disassemble(WabtInterpreterEnvironment* env, break; } - case WABT_OPCODE_CALL_HOST: + case WabtInterpreterOpcode::CallHost: wabt_writef(stream, "%s $%u\n", wabt_get_interpreter_opcode_name(opcode), read_u32(&pc)); break; - case WABT_OPCODE_I32_LOAD8_S: - case WABT_OPCODE_I32_LOAD8_U: - case WABT_OPCODE_I32_LOAD16_S: - case WABT_OPCODE_I32_LOAD16_U: - case WABT_OPCODE_I64_LOAD8_S: - case WABT_OPCODE_I64_LOAD8_U: - case WABT_OPCODE_I64_LOAD16_S: - case WABT_OPCODE_I64_LOAD16_U: - case WABT_OPCODE_I64_LOAD32_S: - case WABT_OPCODE_I64_LOAD32_U: - case WABT_OPCODE_I32_LOAD: - case WABT_OPCODE_I64_LOAD: - case WABT_OPCODE_F32_LOAD: - case WABT_OPCODE_F64_LOAD: { + case WabtInterpreterOpcode::I32Load8S: + case WabtInterpreterOpcode::I32Load8U: + case WabtInterpreterOpcode::I32Load16S: + case WabtInterpreterOpcode::I32Load16U: + case WabtInterpreterOpcode::I64Load8S: + case WabtInterpreterOpcode::I64Load8U: + case WabtInterpreterOpcode::I64Load16S: + case WabtInterpreterOpcode::I64Load16U: + case WabtInterpreterOpcode::I64Load32S: + case WabtInterpreterOpcode::I64Load32U: + case WabtInterpreterOpcode::I32Load: + case WabtInterpreterOpcode::I64Load: + case WabtInterpreterOpcode::F32Load: + case WabtInterpreterOpcode::F64Load: { uint32_t memory_index = read_u32(&pc); wabt_writef(stream, "%s $%u:%%[-1]+$%u\n", wabt_get_interpreter_opcode_name(opcode), memory_index, @@ -2197,15 +2193,15 @@ void wabt_disassemble(WabtInterpreterEnvironment* env, break; } - case WABT_OPCODE_I32_STORE8: - case WABT_OPCODE_I32_STORE16: - case WABT_OPCODE_I32_STORE: - case WABT_OPCODE_I64_STORE8: - case WABT_OPCODE_I64_STORE16: - case WABT_OPCODE_I64_STORE32: - case WABT_OPCODE_I64_STORE: - case WABT_OPCODE_F32_STORE: - case WABT_OPCODE_F64_STORE: { + case WabtInterpreterOpcode::I32Store8: + case WabtInterpreterOpcode::I32Store16: + case WabtInterpreterOpcode::I32Store: + case WabtInterpreterOpcode::I64Store8: + case WabtInterpreterOpcode::I64Store16: + case WabtInterpreterOpcode::I64Store32: + case WabtInterpreterOpcode::I64Store: + case WabtInterpreterOpcode::F32Store: + case WabtInterpreterOpcode::F64Store: { uint32_t memory_index = read_u32(&pc); wabt_writef(stream, "%s %%[-2]+$%u, $%u:%%[-1]\n", wabt_get_interpreter_opcode_name(opcode), memory_index, @@ -2213,155 +2209,155 @@ void wabt_disassemble(WabtInterpreterEnvironment* env, break; } - case WABT_OPCODE_I32_ADD: - case WABT_OPCODE_I32_SUB: - case WABT_OPCODE_I32_MUL: - case WABT_OPCODE_I32_DIV_S: - case WABT_OPCODE_I32_DIV_U: - case WABT_OPCODE_I32_REM_S: - case WABT_OPCODE_I32_REM_U: - case WABT_OPCODE_I32_AND: - case WABT_OPCODE_I32_OR: - case WABT_OPCODE_I32_XOR: - case WABT_OPCODE_I32_SHL: - case WABT_OPCODE_I32_SHR_U: - case WABT_OPCODE_I32_SHR_S: - case WABT_OPCODE_I32_EQ: - case WABT_OPCODE_I32_NE: - case WABT_OPCODE_I32_LT_S: - case WABT_OPCODE_I32_LE_S: - case WABT_OPCODE_I32_LT_U: - case WABT_OPCODE_I32_LE_U: - case WABT_OPCODE_I32_GT_S: - case WABT_OPCODE_I32_GE_S: - case WABT_OPCODE_I32_GT_U: - case WABT_OPCODE_I32_GE_U: - case WABT_OPCODE_I32_ROTR: - case WABT_OPCODE_I32_ROTL: - case WABT_OPCODE_F32_ADD: - case WABT_OPCODE_F32_SUB: - case WABT_OPCODE_F32_MUL: - case WABT_OPCODE_F32_DIV: - case WABT_OPCODE_F32_MIN: - case WABT_OPCODE_F32_MAX: - case WABT_OPCODE_F32_COPYSIGN: - case WABT_OPCODE_F32_EQ: - case WABT_OPCODE_F32_NE: - case WABT_OPCODE_F32_LT: - case WABT_OPCODE_F32_LE: - case WABT_OPCODE_F32_GT: - case WABT_OPCODE_F32_GE: - case WABT_OPCODE_I64_ADD: - case WABT_OPCODE_I64_SUB: - case WABT_OPCODE_I64_MUL: - case WABT_OPCODE_I64_DIV_S: - case WABT_OPCODE_I64_DIV_U: - case WABT_OPCODE_I64_REM_S: - case WABT_OPCODE_I64_REM_U: - case WABT_OPCODE_I64_AND: - case WABT_OPCODE_I64_OR: - case WABT_OPCODE_I64_XOR: - case WABT_OPCODE_I64_SHL: - case WABT_OPCODE_I64_SHR_U: - case WABT_OPCODE_I64_SHR_S: - case WABT_OPCODE_I64_EQ: - case WABT_OPCODE_I64_NE: - case WABT_OPCODE_I64_LT_S: - case WABT_OPCODE_I64_LE_S: - case WABT_OPCODE_I64_LT_U: - case WABT_OPCODE_I64_LE_U: - case WABT_OPCODE_I64_GT_S: - case WABT_OPCODE_I64_GE_S: - case WABT_OPCODE_I64_GT_U: - case WABT_OPCODE_I64_GE_U: - case WABT_OPCODE_I64_ROTR: - case WABT_OPCODE_I64_ROTL: - case WABT_OPCODE_F64_ADD: - case WABT_OPCODE_F64_SUB: - case WABT_OPCODE_F64_MUL: - case WABT_OPCODE_F64_DIV: - case WABT_OPCODE_F64_MIN: - case WABT_OPCODE_F64_MAX: - case WABT_OPCODE_F64_COPYSIGN: - case WABT_OPCODE_F64_EQ: - case WABT_OPCODE_F64_NE: - case WABT_OPCODE_F64_LT: - case WABT_OPCODE_F64_LE: - case WABT_OPCODE_F64_GT: - case WABT_OPCODE_F64_GE: + case WabtInterpreterOpcode::I32Add: + case WabtInterpreterOpcode::I32Sub: + case WabtInterpreterOpcode::I32Mul: + case WabtInterpreterOpcode::I32DivS: + case WabtInterpreterOpcode::I32DivU: + case WabtInterpreterOpcode::I32RemS: + case WabtInterpreterOpcode::I32RemU: + case WabtInterpreterOpcode::I32And: + case WabtInterpreterOpcode::I32Or: + case WabtInterpreterOpcode::I32Xor: + case WabtInterpreterOpcode::I32Shl: + case WabtInterpreterOpcode::I32ShrU: + case WabtInterpreterOpcode::I32ShrS: + case WabtInterpreterOpcode::I32Eq: + case WabtInterpreterOpcode::I32Ne: + case WabtInterpreterOpcode::I32LtS: + case WabtInterpreterOpcode::I32LeS: + case WabtInterpreterOpcode::I32LtU: + case WabtInterpreterOpcode::I32LeU: + case WabtInterpreterOpcode::I32GtS: + case WabtInterpreterOpcode::I32GeS: + case WabtInterpreterOpcode::I32GtU: + case WabtInterpreterOpcode::I32GeU: + case WabtInterpreterOpcode::I32Rotr: + case WabtInterpreterOpcode::I32Rotl: + case WabtInterpreterOpcode::F32Add: + case WabtInterpreterOpcode::F32Sub: + case WabtInterpreterOpcode::F32Mul: + case WabtInterpreterOpcode::F32Div: + case WabtInterpreterOpcode::F32Min: + case WabtInterpreterOpcode::F32Max: + case WabtInterpreterOpcode::F32Copysign: + case WabtInterpreterOpcode::F32Eq: + case WabtInterpreterOpcode::F32Ne: + case WabtInterpreterOpcode::F32Lt: + case WabtInterpreterOpcode::F32Le: + case WabtInterpreterOpcode::F32Gt: + case WabtInterpreterOpcode::F32Ge: + case WabtInterpreterOpcode::I64Add: + case WabtInterpreterOpcode::I64Sub: + case WabtInterpreterOpcode::I64Mul: + case WabtInterpreterOpcode::I64DivS: + case WabtInterpreterOpcode::I64DivU: + case WabtInterpreterOpcode::I64RemS: + case WabtInterpreterOpcode::I64RemU: + case WabtInterpreterOpcode::I64And: + case WabtInterpreterOpcode::I64Or: + case WabtInterpreterOpcode::I64Xor: + case WabtInterpreterOpcode::I64Shl: + case WabtInterpreterOpcode::I64ShrU: + case WabtInterpreterOpcode::I64ShrS: + case WabtInterpreterOpcode::I64Eq: + case WabtInterpreterOpcode::I64Ne: + case WabtInterpreterOpcode::I64LtS: + case WabtInterpreterOpcode::I64LeS: + case WabtInterpreterOpcode::I64LtU: + case WabtInterpreterOpcode::I64LeU: + case WabtInterpreterOpcode::I64GtS: + case WabtInterpreterOpcode::I64GeS: + case WabtInterpreterOpcode::I64GtU: + case WabtInterpreterOpcode::I64GeU: + case WabtInterpreterOpcode::I64Rotr: + case WabtInterpreterOpcode::I64Rotl: + case WabtInterpreterOpcode::F64Add: + case WabtInterpreterOpcode::F64Sub: + case WabtInterpreterOpcode::F64Mul: + case WabtInterpreterOpcode::F64Div: + case WabtInterpreterOpcode::F64Min: + case WabtInterpreterOpcode::F64Max: + case WabtInterpreterOpcode::F64Copysign: + case WabtInterpreterOpcode::F64Eq: + case WabtInterpreterOpcode::F64Ne: + case WabtInterpreterOpcode::F64Lt: + case WabtInterpreterOpcode::F64Le: + case WabtInterpreterOpcode::F64Gt: + case WabtInterpreterOpcode::F64Ge: wabt_writef(stream, "%s %%[-2], %%[-1]\n", wabt_get_interpreter_opcode_name(opcode)); break; - case WABT_OPCODE_I32_CLZ: - case WABT_OPCODE_I32_CTZ: - case WABT_OPCODE_I32_POPCNT: - case WABT_OPCODE_I32_EQZ: - case WABT_OPCODE_I64_CLZ: - case WABT_OPCODE_I64_CTZ: - case WABT_OPCODE_I64_POPCNT: - case WABT_OPCODE_I64_EQZ: - case WABT_OPCODE_F32_ABS: - case WABT_OPCODE_F32_NEG: - case WABT_OPCODE_F32_CEIL: - case WABT_OPCODE_F32_FLOOR: - case WABT_OPCODE_F32_TRUNC: - case WABT_OPCODE_F32_NEAREST: - case WABT_OPCODE_F32_SQRT: - case WABT_OPCODE_F64_ABS: - case WABT_OPCODE_F64_NEG: - case WABT_OPCODE_F64_CEIL: - case WABT_OPCODE_F64_FLOOR: - case WABT_OPCODE_F64_TRUNC: - case WABT_OPCODE_F64_NEAREST: - case WABT_OPCODE_F64_SQRT: - case WABT_OPCODE_I32_TRUNC_S_F32: - case WABT_OPCODE_I32_TRUNC_U_F32: - case WABT_OPCODE_I64_TRUNC_S_F32: - case WABT_OPCODE_I64_TRUNC_U_F32: - case WABT_OPCODE_F64_PROMOTE_F32: - case WABT_OPCODE_I32_REINTERPRET_F32: - case WABT_OPCODE_I32_TRUNC_S_F64: - case WABT_OPCODE_I32_TRUNC_U_F64: - case WABT_OPCODE_I64_TRUNC_S_F64: - case WABT_OPCODE_I64_TRUNC_U_F64: - case WABT_OPCODE_F32_DEMOTE_F64: - case WABT_OPCODE_I64_REINTERPRET_F64: - case WABT_OPCODE_I32_WRAP_I64: - case WABT_OPCODE_F32_CONVERT_S_I64: - case WABT_OPCODE_F32_CONVERT_U_I64: - case WABT_OPCODE_F64_CONVERT_S_I64: - case WABT_OPCODE_F64_CONVERT_U_I64: - case WABT_OPCODE_F64_REINTERPRET_I64: - case WABT_OPCODE_I64_EXTEND_S_I32: - case WABT_OPCODE_I64_EXTEND_U_I32: - case WABT_OPCODE_F32_CONVERT_S_I32: - case WABT_OPCODE_F32_CONVERT_U_I32: - case WABT_OPCODE_F32_REINTERPRET_I32: - case WABT_OPCODE_F64_CONVERT_S_I32: - case WABT_OPCODE_F64_CONVERT_U_I32: + case WabtInterpreterOpcode::I32Clz: + case WabtInterpreterOpcode::I32Ctz: + case WabtInterpreterOpcode::I32Popcnt: + case WabtInterpreterOpcode::I32Eqz: + case WabtInterpreterOpcode::I64Clz: + case WabtInterpreterOpcode::I64Ctz: + case WabtInterpreterOpcode::I64Popcnt: + case WabtInterpreterOpcode::I64Eqz: + case WabtInterpreterOpcode::F32Abs: + case WabtInterpreterOpcode::F32Neg: + case WabtInterpreterOpcode::F32Ceil: + case WabtInterpreterOpcode::F32Floor: + case WabtInterpreterOpcode::F32Trunc: + case WabtInterpreterOpcode::F32Nearest: + case WabtInterpreterOpcode::F32Sqrt: + case WabtInterpreterOpcode::F64Abs: + case WabtInterpreterOpcode::F64Neg: + case WabtInterpreterOpcode::F64Ceil: + case WabtInterpreterOpcode::F64Floor: + case WabtInterpreterOpcode::F64Trunc: + case WabtInterpreterOpcode::F64Nearest: + case WabtInterpreterOpcode::F64Sqrt: + case WabtInterpreterOpcode::I32TruncSF32: + case WabtInterpreterOpcode::I32TruncUF32: + case WabtInterpreterOpcode::I64TruncSF32: + case WabtInterpreterOpcode::I64TruncUF32: + case WabtInterpreterOpcode::F64PromoteF32: + case WabtInterpreterOpcode::I32ReinterpretF32: + case WabtInterpreterOpcode::I32TruncSF64: + case WabtInterpreterOpcode::I32TruncUF64: + case WabtInterpreterOpcode::I64TruncSF64: + case WabtInterpreterOpcode::I64TruncUF64: + case WabtInterpreterOpcode::F32DemoteF64: + case WabtInterpreterOpcode::I64ReinterpretF64: + case WabtInterpreterOpcode::I32WrapI64: + case WabtInterpreterOpcode::F32ConvertSI64: + case WabtInterpreterOpcode::F32ConvertUI64: + case WabtInterpreterOpcode::F64ConvertSI64: + case WabtInterpreterOpcode::F64ConvertUI64: + case WabtInterpreterOpcode::F64ReinterpretI64: + case WabtInterpreterOpcode::I64ExtendSI32: + case WabtInterpreterOpcode::I64ExtendUI32: + case WabtInterpreterOpcode::F32ConvertSI32: + case WabtInterpreterOpcode::F32ConvertUI32: + case WabtInterpreterOpcode::F32ReinterpretI32: + case WabtInterpreterOpcode::F64ConvertSI32: + case WabtInterpreterOpcode::F64ConvertUI32: wabt_writef(stream, "%s %%[-1]\n", wabt_get_interpreter_opcode_name(opcode)); break; - case WABT_OPCODE_GROW_MEMORY: { + case WabtInterpreterOpcode::GrowMemory: { uint32_t memory_index = read_u32(&pc); wabt_writef(stream, "%s $%u:%%[-1]\n", wabt_get_interpreter_opcode_name(opcode), memory_index); break; } - case WABT_OPCODE_ALLOCA: + case WabtInterpreterOpcode::Alloca: wabt_writef(stream, "%s $%u\n", wabt_get_interpreter_opcode_name(opcode), read_u32(&pc)); break; - case WABT_OPCODE_BR_UNLESS: + case WabtInterpreterOpcode::BrUnless: wabt_writef(stream, "%s @%u, %%[-1]\n", wabt_get_interpreter_opcode_name(opcode), read_u32(&pc)); break; - case WABT_OPCODE_DROP_KEEP: { + case WabtInterpreterOpcode::DropKeep: { uint32_t drop = read_u32(&pc); uint32_t keep = *pc++; wabt_writef(stream, "%s $%u $%u\n", @@ -2369,7 +2365,7 @@ void wabt_disassemble(WabtInterpreterEnvironment* env, break; } - case WABT_OPCODE_DATA: { + case WabtInterpreterOpcode::Data: { uint32_t num_bytes = read_u32(&pc); wabt_writef(stream, "%s $%u\n", wabt_get_interpreter_opcode_name(opcode), num_bytes); diff --git a/src/interpreter.h b/src/interpreter.h index 78a28312..97b9d64f 100644 --- a/src/interpreter.h +++ b/src/interpreter.h @@ -20,6 +20,7 @@ #include <stdint.h> #include "array.h" +#include "common.h" #include "binding-hash.h" #include "type-vector.h" #include "vector.h" @@ -27,45 +28,45 @@ struct WabtStream; -#define FOREACH_INTERPRETER_RESULT(V) \ - V(OK, "ok") \ - /* returned from the top-most function */ \ - V(RETURNED, "returned") \ - /* memory access is out of bounds */ \ - V(TRAP_MEMORY_ACCESS_OUT_OF_BOUNDS, "out of bounds memory access") \ - /* converting from float -> int would overflow int */ \ - V(TRAP_INTEGER_OVERFLOW, "integer overflow") \ - /* dividend is zero in integer divide */ \ - V(TRAP_INTEGER_DIVIDE_BY_ZERO, "integer divide by zero") \ - /* converting from float -> int where float is nan */ \ - V(TRAP_INVALID_CONVERSION_TO_INTEGER, "invalid conversion to integer") \ - /* function table index is out of bounds */ \ - V(TRAP_UNDEFINED_TABLE_INDEX, "undefined table index") \ - /* function table element is uninitialized */ \ - V(TRAP_UNINITIALIZED_TABLE_ELEMENT, "uninitialized table element") \ - /* unreachable instruction executed */ \ - V(TRAP_UNREACHABLE, "unreachable executed") \ - /* call indirect signature doesn't match function table signature */ \ - V(TRAP_INDIRECT_CALL_SIGNATURE_MISMATCH, "indirect call signature mismatch") \ - /* ran out of call stack frames (probably infinite recursion) */ \ - V(TRAP_CALL_STACK_EXHAUSTED, "call stack exhausted") \ - /* ran out of value stack space */ \ - V(TRAP_VALUE_STACK_EXHAUSTED, "value stack exhausted") \ - /* we called a host function, but the return value didn't match the */ \ - /* expected type */ \ - V(TRAP_HOST_RESULT_TYPE_MISMATCH, "host result type mismatch") \ - /* we called an import function, but it didn't complete succesfully */ \ - V(TRAP_HOST_TRAPPED, "host function trapped") \ - /* we attempted to call a function with the an argument list that doesn't \ - * match the function signature */ \ - V(ARGUMENT_TYPE_MISMATCH, "argument type mismatch") \ - /* we tried to get an export by name that doesn't exist */ \ - V(UNKNOWN_EXPORT, "unknown export") \ - /* the expected export kind doesn't match. */ \ - V(EXPORT_KIND_MISMATCH, "export kind mismatch") - -enum WabtInterpreterResult { -#define V(name, str) WABT_INTERPRETER_##name, +#define FOREACH_INTERPRETER_RESULT(V) \ + V(Ok, "ok") \ + /* returned from the top-most function */ \ + V(Returned, "returned") \ + /* memory access is out of bounds */ \ + V(TrapMemoryAccessOutOfBounds, "out of bounds memory access") \ + /* converting from float -> int would overflow int */ \ + V(TrapIntegerOverflow, "integer overflow") \ + /* dividend is zero in integer divide */ \ + V(TrapIntegerDivideByZero, "integer divide by zero") \ + /* converting from float -> int where float is nan */ \ + V(TrapInvalidConversionToInteger, "invalid conversion to integer") \ + /* function table index is out of bounds */ \ + V(TrapUndefinedTableIndex, "undefined table index") \ + /* function table element is uninitialized */ \ + V(TrapUninitializedTableElement, "uninitialized table element") \ + /* unreachable instruction executed */ \ + V(TrapUnreachable, "unreachable executed") \ + /* call indirect signature doesn't match function table signature */ \ + V(TrapIndirectCallSignatureMismatch, "indirect call signature mismatch") \ + /* ran out of call stack frames (probably infinite recursion) */ \ + V(TrapCallStackExhausted, "call stack exhausted") \ + /* ran out of value stack space */ \ + V(TrapValueStackExhausted, "value stack exhausted") \ + /* we called a host function, but the return value didn't match the */ \ + /* expected type */ \ + V(TrapHostResultTypeMismatch, "host result type mismatch") \ + /* we called an import function, but it didn't complete succesfully */ \ + V(TrapHostTrapped, "host function trapped") \ + /* we attempted to call a function with the an argument list that doesn't \ + * match the function signature */ \ + V(ArgumentTypeMismatch, "argument type mismatch") \ + /* we tried to get an export by name that doesn't exist */ \ + V(UnknownExport, "unknown export") \ + /* the expected export kind doesn't match. */ \ + V(ExportKindMismatch, "export kind mismatch") + +enum class WabtInterpreterResult { +#define V(Name, str) Name, FOREACH_INTERPRETER_RESULT(V) #undef V }; @@ -77,16 +78,26 @@ enum WabtInterpreterResult { #define WABT_TABLE_ENTRY_DROP_OFFSET sizeof(uint32_t) #define WABT_TABLE_ENTRY_KEEP_OFFSET (sizeof(uint32_t) * 2) -enum { - /* push space on the value stack for N entries */ - WABT_OPCODE_ALLOCA = WABT_NUM_OPCODES, - WABT_OPCODE_BR_UNLESS, - WABT_OPCODE_CALL_HOST, - WABT_OPCODE_DATA, - WABT_OPCODE_DROP_KEEP, - WABT_NUM_INTERPRETER_OPCODES, +#define WABT_FOREACH_INTERPRETER_OPCODE(V) \ + WABT_FOREACH_OPCODE(V) \ + V(___, ___, ___, 0, 0xfb, Alloca, "alloca") \ + V(___, ___, ___, 0, 0xfc, BrUnless, "br_unless") \ + V(___, ___, ___, 0, 0xfd, CallHost, "call_host") \ + V(___, ___, ___, 0, 0xfe, Data, "data") \ + V(___, ___, ___, 0, 0xff, DropKeep, "drop_keep") + +enum class WabtInterpreterOpcode { +/* push space on the value stack for N entries */ +#define V(rtype, type1, type2, mem_size, code, Name, text) \ + Name = code, + WABT_FOREACH_INTERPRETER_OPCODE(V) +#undef V + + First = static_cast<int>(WabtOpcode::First), + Last = DropKeep, }; -WABT_STATIC_ASSERT(WABT_NUM_INTERPRETER_OPCODES <= 256); +static const int kWabtInterpreterOpcodeCount = + WABT_ENUM_COUNT(WabtInterpreterOpcode); typedef uint32_t WabtUint32; WABT_DEFINE_ARRAY(uint32, WabtUint32); diff --git a/src/literal.cc b/src/literal.cc index bfd02de6..9fc6f4e8 100644 --- a/src/literal.cc +++ b/src/literal.cc @@ -54,15 +54,15 @@ static const char s_hex_digits[] = "0123456789abcdef"; WabtResult wabt_parse_hexdigit(char c, uint32_t* out) { if (static_cast<unsigned int>(c - '0') <= 9) { *out = c - '0'; - return WABT_OK; + return WabtResult::Ok; } else if (static_cast<unsigned int>(c - 'a') <= 6) { *out = 10 + (c - 'a'); - return WABT_OK; + return WabtResult::Ok; } else if (static_cast<unsigned int>(c - 'A') <= 6) { *out = 10 + (c - 'A'); - return WABT_OK; + return WabtResult::Ok; } - return WABT_ERROR; + return WabtResult::Error; } /* return 1 if the non-NULL-terminated string starting with |start| and ending @@ -81,38 +81,38 @@ static bool string_starts_with(const char* start, WabtResult wabt_parse_uint64(const char* s, const char* end, uint64_t* out) { if (s == end) - return WABT_ERROR; + return WabtResult::Error; uint64_t value = 0; if (*s == '0' && s + 1 < end && s[1] == 'x') { s += 2; if (s == end) - return WABT_ERROR; + return WabtResult::Error; for (; s < end; ++s) { uint32_t digit; if (WABT_FAILED(wabt_parse_hexdigit(*s, &digit))) - return WABT_ERROR; + return WabtResult::Error; uint64_t old_value = value; value = value * 16 + digit; /* check for overflow */ if (old_value > value) - return WABT_ERROR; + return WabtResult::Error; } } else { for (; s < end; ++s) { uint32_t digit = (*s - '0'); if (digit > 9) - return WABT_ERROR; + return WabtResult::Error; uint64_t old_value = value; value = value * 10 + digit; /* check for overflow */ if (old_value > value) - return WABT_ERROR; + return WabtResult::Error; } } if (s != end) - return WABT_ERROR; + return WabtResult::Error; *out = value; - return WABT_OK; + return WabtResult::Ok; } WabtResult wabt_parse_int64(const char* s, @@ -121,8 +121,8 @@ WabtResult wabt_parse_int64(const char* s, WabtParseIntType parse_type) { bool has_sign = false; if (*s == '-' || *s == '+') { - if (parse_type == WABT_PARSE_UNSIGNED_ONLY) - return WABT_ERROR; + if (parse_type == WabtParseIntType::UnsignedOnly) + return WabtResult::Error; if (*s == '-') has_sign = true; s++; @@ -132,7 +132,7 @@ WabtResult wabt_parse_int64(const char* s, if (has_sign) { /* abs(INT64_MIN) == INT64_MAX + 1 */ if (value > static_cast<uint64_t>(INT64_MAX) + 1) - return WABT_ERROR; + return WabtResult::Error; value = UINT64_MAX - value + 1; } *out = value; @@ -146,26 +146,26 @@ WabtResult wabt_parse_int32(const char* s, uint64_t value; bool has_sign = false; if (*s == '-' || *s == '+') { - if (parse_type == WABT_PARSE_UNSIGNED_ONLY) - return WABT_ERROR; + if (parse_type == WabtParseIntType::UnsignedOnly) + return WabtResult::Error; if (*s == '-') has_sign = true; s++; } if (WABT_FAILED(wabt_parse_uint64(s, end, &value))) - return WABT_ERROR; + return WabtResult::Error; if (has_sign) { /* abs(INT32_MIN) == INT32_MAX + 1 */ if (value > static_cast<uint64_t>(INT32_MAX) + 1) - return WABT_ERROR; + return WabtResult::Error; value = UINT32_MAX - value + 1; } else { if (value > static_cast<uint64_t>(UINT32_MAX)) - return WABT_ERROR; + return WabtResult::Error; } *out = static_cast<uint32_t>(value); - return WABT_OK; + return WabtResult::Ok; } /* floats */ @@ -208,22 +208,22 @@ static WabtResult parse_float_nan(const char* s, for (; s < end; ++s) { uint32_t digit; if (WABT_FAILED(wabt_parse_hexdigit(*s, &digit))) - return WABT_ERROR; + return WabtResult::Error; tag = tag * 16 + digit; /* check for overflow */ if (tag > F32_SIG_MASK) - return WABT_ERROR; + return WabtResult::Error; } /* NaN cannot have a zero tag, that is reserved for infinity */ if (tag == 0) - return WABT_ERROR; + return WabtResult::Error; } else { tag = F32_QUIET_NAN_TAG; } *out_bits = make_float(is_neg, F32_MAX_EXP, tag); - return WABT_OK; + return WabtResult::Ok; } static void parse_float_hex(const char* s, @@ -383,8 +383,8 @@ WabtResult wabt_parse_float(WabtLiteralType literal_type, const char* end, uint32_t* out_bits) { switch (literal_type) { - case WABT_LITERAL_TYPE_INT: - case WABT_LITERAL_TYPE_FLOAT: { + case WabtLiteralType::Int: + case WabtLiteralType::Float: { errno = 0; char* endptr; float value; @@ -392,26 +392,26 @@ WabtResult wabt_parse_float(WabtLiteralType literal_type, if (endptr != end || ((value == 0 || value == HUGE_VALF || value == -HUGE_VALF) && errno != 0)) - return WABT_ERROR; + return WabtResult::Error; memcpy(out_bits, &value, sizeof(value)); - return WABT_OK; + return WabtResult::Ok; } - case WABT_LITERAL_TYPE_HEXFLOAT: + case WabtLiteralType::Hexfloat: parse_float_hex(s, end, out_bits); - return WABT_OK; + return WabtResult::Ok; - case WABT_LITERAL_TYPE_INFINITY: + case WabtLiteralType::Infinity: parse_float_infinity(s, end, out_bits); - return WABT_OK; + return WabtResult::Ok; - case WABT_LITERAL_TYPE_NAN: + case WabtLiteralType::Nan: return parse_float_nan(s, end, out_bits); default: assert(0); - return WABT_ERROR; + return WabtResult::Error; } } @@ -539,28 +539,28 @@ static WabtResult parse_double_nan(const char* s, if (s != end) { tag = 0; if (!string_starts_with(s, end, ":0x")) - return WABT_ERROR; + return WabtResult::Error; s += 3; for (; s < end; ++s) { uint32_t digit; if (WABT_FAILED(wabt_parse_hexdigit(*s, &digit))) - return WABT_ERROR; + return WabtResult::Error; tag = tag * 16 + digit; /* check for overflow */ if (tag > F64_SIG_MASK) - return WABT_ERROR; + return WabtResult::Error; } /* NaN cannot have a zero tag, that is reserved for infinity */ if (tag == 0) - return WABT_ERROR; + return WabtResult::Error; } else { tag = F64_QUIET_NAN_TAG; } *out_bits = make_double(is_neg, F64_MAX_EXP, tag); - return WABT_OK; + return WabtResult::Ok; } static void parse_double_hex(const char* s, @@ -713,8 +713,8 @@ WabtResult wabt_parse_double(WabtLiteralType literal_type, const char* end, uint64_t* out_bits) { switch (literal_type) { - case WABT_LITERAL_TYPE_INT: - case WABT_LITERAL_TYPE_FLOAT: { + case WabtLiteralType::Int: + case WabtLiteralType::Float: { errno = 0; char* endptr; double value; @@ -722,26 +722,26 @@ WabtResult wabt_parse_double(WabtLiteralType literal_type, if (endptr != end || ((value == 0 || value == HUGE_VAL || value == -HUGE_VAL) && errno != 0)) - return WABT_ERROR; + return WabtResult::Error; memcpy(out_bits, &value, sizeof(value)); - return WABT_OK; + return WabtResult::Ok; } - case WABT_LITERAL_TYPE_HEXFLOAT: + case WabtLiteralType::Hexfloat: parse_double_hex(s, end, out_bits); - return WABT_OK; + return WabtResult::Ok; - case WABT_LITERAL_TYPE_INFINITY: + case WabtLiteralType::Infinity: parse_double_infinity(s, end, out_bits); - return WABT_OK; + return WabtResult::Ok; - case WABT_LITERAL_TYPE_NAN: + case WabtLiteralType::Nan: return parse_double_nan(s, end, out_bits); default: assert(0); - return WABT_ERROR; + return WabtResult::Error; } } diff --git a/src/literal.h b/src/literal.h index 5f237c0c..5c87fc5b 100644 --- a/src/literal.h +++ b/src/literal.h @@ -21,16 +21,16 @@ #include "common.h" -/* These functions all return WABT_OK on success and WABT_ERROR on failure. +/* These functions all return WabtResult::Ok on success and WabtResult::Error on failure. * * NOTE: the functions are written for use with the re2c lexer, assuming that * the literal has already matched the regular expressions defined there. As a * result, the only validation that is done is for overflow, not for otherwise * bogus input. */ -enum WabtParseIntType { - WABT_PARSE_UNSIGNED_ONLY = 0, - WABT_PARSE_SIGNED_AND_UNSIGNED = 1, +enum class WabtParseIntType { + UnsignedOnly = 0, + SignedAndUnsigned = 1, }; /* Size of char buffer required to hold hex representation of a float/double */ diff --git a/src/option-parser.cc b/src/option-parser.cc index db897860..0ead2d50 100644 --- a/src/option-parser.cc +++ b/src/option-parser.cc @@ -39,7 +39,7 @@ static int option_match(const char* s, /* we want to fail if s is longer than full, e.g. --foobar vs. --foo. * However, if s ends with an '=', it's OK. */ - if (!(has_argument && s[i] == '=')) + if (!(has_argument == WabtHasArgument::Yes && s[i] == '=')) return -1; break; } @@ -98,7 +98,7 @@ void wabt_parse_options(WabtOptionParser* parser, WabtOption* best_option = &parser->options[best_index]; const char* option_argument = nullptr; - if (best_option->has_argument) { + if (best_option->has_argument == WabtHasArgument::Yes) { if (arg[best_length] == '=') { option_argument = &arg[best_length + 1]; } else { @@ -127,7 +127,7 @@ void wabt_parse_options(WabtOptionParser* parser, WabtOption* option = &parser->options[j]; if (option->short_name && arg[k] == option->short_name) { const char* option_argument = nullptr; - if (option->has_argument) { + if (option->has_argument == WabtHasArgument::Yes) { /* a short option with a required argument cannot be followed * by other short options */ if (arg[k + 1] != '\0') { diff --git a/src/option-parser.h b/src/option-parser.h index 910464ac..01dae4ea 100644 --- a/src/option-parser.h +++ b/src/option-parser.h @@ -19,9 +19,9 @@ #include "common.h" -enum WabtHasArgument { - WABT_OPTION_NO_ARGUMENT, - WABT_OPTION_HAS_ARGUMENT, +enum class WabtHasArgument { + No = 0, + Yes = 1, }; struct WabtOption; diff --git a/src/prebuilt/ast-lexer-gen.cc b/src/prebuilt/ast-lexer-gen.cc index 47c8c59a..4953a1f9 100644 --- a/src/prebuilt/ast-lexer-gen.cc +++ b/src/prebuilt/ast-lexer-gen.cc @@ -84,13 +84,13 @@ lval->text.start = yytext + offset; \ lval->text.length = yyleng - offset -#define TYPE(type_) lval->type = WABT_TYPE_##type_ +#define TYPE(type_) lval->type = WabtType::type_ -#define OPCODE(name) lval->opcode = WABT_OPCODE_##name +#define OPCODE(name) lval->opcode = WabtOpcode::name -#define LITERAL(type_) \ - lval->literal.type = WABT_LITERAL_TYPE_##type_; \ - lval->literal.text.start = yytext; \ +#define LITERAL(type_) \ + lval->literal.type = WabtLiteralType::type_; \ + lval->literal.text.start = yytext; \ lval->literal.text.length = yyleng static WabtResult fill(WabtLocation* loc, @@ -98,7 +98,7 @@ static WabtResult fill(WabtLocation* loc, WabtAstParser* parser, size_t need) { if (lexer->eof) - return WABT_ERROR; + return WabtResult::Error; size_t free = lexer->token - lexer->buffer; assert(static_cast<size_t>(lexer->cursor - lexer->buffer) >= free); /* our buffer is too small, need to realloc */ @@ -120,7 +120,7 @@ static WabtResult fill(WabtLocation* loc, if (!new_buffer) { wabt_ast_parser_error(loc, lexer, parser, "unable to reallocate lexer buffer."); - return WABT_ERROR; + return WabtResult::Error; } memmove(new_buffer, lexer->token, lexer->limit - lexer->token); lexer->buffer = new_buffer; @@ -141,11 +141,11 @@ static WabtResult fill(WabtLocation* loc, lexer->buffer_file_offset += free; } /* read the new data into the buffer */ - if (lexer->source.type == WABT_LEXER_SOURCE_TYPE_FILE) { + if (lexer->source.type == WabtAstLexerSourceType::File) { lexer->limit += fread(lexer->limit, 1, free, lexer->source.file); } else { /* TODO(binji): could lex directly from buffer */ - assert(lexer->source.type == WABT_LEXER_SOURCE_TYPE_BUFFER); + assert(lexer->source.type == WabtAstLexerSourceType::Buffer); size_t read_size = free; size_t offset = lexer->source.buffer.read_offset; size_t bytes_left = lexer->source.buffer.size - offset; @@ -165,7 +165,7 @@ static WabtResult fill(WabtLocation* loc, memset(lexer->limit, 0, YYMAXFILL); lexer->limit += YYMAXFILL; } - return WABT_OK; + return WabtResult::Ok; } int wabt_ast_lexer_lex(WABT_AST_PARSER_STYPE* lval, @@ -702,7 +702,7 @@ yy60: } yy61: #line 222 "src/ast-lexer.cc" - { LITERAL(INT); RETURN(NAT); } + { LITERAL(Int); RETURN(NAT); } #line 707 "src/prebuilt/ast-lexer-gen.cc" yy62: ++lexer->cursor; @@ -1020,7 +1020,7 @@ yy93: } yy94: #line 223 "src/ast-lexer.cc" - { LITERAL(INT); RETURN(INT); } + { LITERAL(Int); RETURN(INT); } #line 1025 "src/prebuilt/ast-lexer-gen.cc" yy95: ++lexer->cursor; @@ -1119,7 +1119,7 @@ yy99: } yy101: #line 224 "src/ast-lexer.cc" - { LITERAL(FLOAT); RETURN(FLOAT); } + { LITERAL(Float); RETURN(FLOAT); } #line 1124 "src/prebuilt/ast-lexer-gen.cc" yy102: yych = *++lexer->cursor; @@ -1810,7 +1810,7 @@ yy185: } yy186: #line 226 "src/ast-lexer.cc" - { LITERAL(INFINITY); RETURN(FLOAT); } + { LITERAL(Infinity); RETURN(FLOAT); } #line 1815 "src/prebuilt/ast-lexer-gen.cc" yy187: yych = *++lexer->cursor; @@ -1879,7 +1879,7 @@ yy195: } yy196: #line 227 "src/ast-lexer.cc" - { LITERAL(NAN); RETURN(FLOAT); } + { LITERAL(Nan); RETURN(FLOAT); } #line 1884 "src/prebuilt/ast-lexer-gen.cc" yy197: ++lexer->cursor; @@ -2399,7 +2399,7 @@ yy273: } yy275: #line 225 "src/ast-lexer.cc" - { LITERAL(HEXFLOAT); RETURN(FLOAT); } + { LITERAL(Hexfloat); RETURN(FLOAT); } #line 2404 "src/prebuilt/ast-lexer-gen.cc" yy276: yych = *++lexer->cursor; @@ -2938,7 +2938,7 @@ yy386: goto yy49; } #line 382 "src/ast-lexer.cc" - { OPCODE(F32_EQ); RETURN(COMPARE); } + { OPCODE(F32Eq); RETURN(COMPARE); } #line 2943 "src/prebuilt/ast-lexer-gen.cc" yy388: yych = *++lexer->cursor; @@ -2950,7 +2950,7 @@ yy389: goto yy49; } #line 392 "src/ast-lexer.cc" - { OPCODE(F32_GE); RETURN(COMPARE); } + { OPCODE(F32Ge); RETURN(COMPARE); } #line 2955 "src/prebuilt/ast-lexer-gen.cc" yy391: ++lexer->cursor; @@ -2958,7 +2958,7 @@ yy391: goto yy49; } #line 390 "src/ast-lexer.cc" - { OPCODE(F32_GT); RETURN(COMPARE); } + { OPCODE(F32Gt); RETURN(COMPARE); } #line 2963 "src/prebuilt/ast-lexer-gen.cc" yy393: ++lexer->cursor; @@ -2966,7 +2966,7 @@ yy393: goto yy49; } #line 388 "src/ast-lexer.cc" - { OPCODE(F32_LE); RETURN(COMPARE); } + { OPCODE(F32Le); RETURN(COMPARE); } #line 2971 "src/prebuilt/ast-lexer-gen.cc" yy395: yych = *++lexer->cursor; @@ -2978,7 +2978,7 @@ yy396: goto yy49; } #line 386 "src/ast-lexer.cc" - { OPCODE(F32_LT); RETURN(COMPARE); } + { OPCODE(F32Lt); RETURN(COMPARE); } #line 2983 "src/prebuilt/ast-lexer-gen.cc" yy398: yych = *++lexer->cursor; @@ -3029,7 +3029,7 @@ yy401: } yy402: #line 384 "src/ast-lexer.cc" - { OPCODE(F32_NE); RETURN(COMPARE); } + { OPCODE(F32Ne); RETURN(COMPARE); } #line 3034 "src/prebuilt/ast-lexer-gen.cc" yy403: yych = *++lexer->cursor; @@ -3078,7 +3078,7 @@ yy413: goto yy49; } #line 383 "src/ast-lexer.cc" - { OPCODE(F64_EQ); RETURN(COMPARE); } + { OPCODE(F64Eq); RETURN(COMPARE); } #line 3083 "src/prebuilt/ast-lexer-gen.cc" yy415: yych = *++lexer->cursor; @@ -3090,7 +3090,7 @@ yy416: goto yy49; } #line 393 "src/ast-lexer.cc" - { OPCODE(F64_GE); RETURN(COMPARE); } + { OPCODE(F64Ge); RETURN(COMPARE); } #line 3095 "src/prebuilt/ast-lexer-gen.cc" yy418: ++lexer->cursor; @@ -3098,7 +3098,7 @@ yy418: goto yy49; } #line 391 "src/ast-lexer.cc" - { OPCODE(F64_GT); RETURN(COMPARE); } + { OPCODE(F64Gt); RETURN(COMPARE); } #line 3103 "src/prebuilt/ast-lexer-gen.cc" yy420: ++lexer->cursor; @@ -3106,7 +3106,7 @@ yy420: goto yy49; } #line 389 "src/ast-lexer.cc" - { OPCODE(F64_LE); RETURN(COMPARE); } + { OPCODE(F64Le); RETURN(COMPARE); } #line 3111 "src/prebuilt/ast-lexer-gen.cc" yy422: yych = *++lexer->cursor; @@ -3118,7 +3118,7 @@ yy423: goto yy49; } #line 387 "src/ast-lexer.cc" - { OPCODE(F64_LT); RETURN(COMPARE); } + { OPCODE(F64Lt); RETURN(COMPARE); } #line 3123 "src/prebuilt/ast-lexer-gen.cc" yy425: yych = *++lexer->cursor; @@ -3169,7 +3169,7 @@ yy428: } yy429: #line 385 "src/ast-lexer.cc" - { OPCODE(F64_NE); RETURN(COMPARE); } + { OPCODE(F64Ne); RETURN(COMPARE); } #line 3174 "src/prebuilt/ast-lexer-gen.cc" yy430: yych = *++lexer->cursor; @@ -3275,7 +3275,7 @@ yy447: } yy448: #line 362 "src/ast-lexer.cc" - { OPCODE(I32_EQ); RETURN(COMPARE); } + { OPCODE(I32Eq); RETURN(COMPARE); } #line 3280 "src/prebuilt/ast-lexer-gen.cc" yy449: yych = *++lexer->cursor; @@ -3307,7 +3307,7 @@ yy455: goto yy49; } #line 364 "src/ast-lexer.cc" - { OPCODE(I32_NE); RETURN(COMPARE); } + { OPCODE(I32Ne); RETURN(COMPARE); } #line 3312 "src/prebuilt/ast-lexer-gen.cc" yy457: ++lexer->cursor; @@ -3315,7 +3315,7 @@ yy457: goto yy49; } #line 334 "src/ast-lexer.cc" - { OPCODE(I32_OR); RETURN(BINARY); } + { OPCODE(I32Or); RETURN(BINARY); } #line 3320 "src/prebuilt/ast-lexer-gen.cc" yy459: yych = *++lexer->cursor; @@ -3415,7 +3415,7 @@ yy474: } yy475: #line 363 "src/ast-lexer.cc" - { OPCODE(I64_EQ); RETURN(COMPARE); } + { OPCODE(I64Eq); RETURN(COMPARE); } #line 3420 "src/prebuilt/ast-lexer-gen.cc" yy476: yych = *++lexer->cursor; @@ -3451,7 +3451,7 @@ yy483: goto yy49; } #line 365 "src/ast-lexer.cc" - { OPCODE(I64_NE); RETURN(COMPARE); } + { OPCODE(I64Ne); RETURN(COMPARE); } #line 3456 "src/prebuilt/ast-lexer-gen.cc" yy485: ++lexer->cursor; @@ -3459,7 +3459,7 @@ yy485: goto yy49; } #line 335 "src/ast-lexer.cc" - { OPCODE(I64_OR); RETURN(BINARY); } + { OPCODE(I64Or); RETURN(BINARY); } #line 3464 "src/prebuilt/ast-lexer-gen.cc" yy487: yych = *++lexer->cursor; @@ -3759,7 +3759,7 @@ yy532: goto yy49; } #line 306 "src/ast-lexer.cc" - { OPCODE(F32_ABS); RETURN(UNARY); } + { OPCODE(F32Abs); RETURN(UNARY); } #line 3764 "src/prebuilt/ast-lexer-gen.cc" yy534: ++lexer->cursor; @@ -3767,7 +3767,7 @@ yy534: goto yy49; } #line 348 "src/ast-lexer.cc" - { OPCODE(F32_ADD); RETURN(BINARY); } + { OPCODE(F32Add); RETURN(BINARY); } #line 3772 "src/prebuilt/ast-lexer-gen.cc" yy536: yych = *++lexer->cursor; @@ -3792,7 +3792,7 @@ yy540: goto yy49; } #line 354 "src/ast-lexer.cc" - { OPCODE(F32_DIV); RETURN(BINARY); } + { OPCODE(F32Div); RETURN(BINARY); } #line 3797 "src/prebuilt/ast-lexer-gen.cc" yy542: yych = *++lexer->cursor; @@ -3808,7 +3808,7 @@ yy544: goto yy49; } #line 358 "src/ast-lexer.cc" - { OPCODE(F32_MAX); RETURN(BINARY); } + { OPCODE(F32Max); RETURN(BINARY); } #line 3813 "src/prebuilt/ast-lexer-gen.cc" yy546: ++lexer->cursor; @@ -3816,7 +3816,7 @@ yy546: goto yy49; } #line 356 "src/ast-lexer.cc" - { OPCODE(F32_MIN); RETURN(BINARY); } + { OPCODE(F32Min); RETURN(BINARY); } #line 3821 "src/prebuilt/ast-lexer-gen.cc" yy548: ++lexer->cursor; @@ -3824,7 +3824,7 @@ yy548: goto yy49; } #line 352 "src/ast-lexer.cc" - { OPCODE(F32_MUL); RETURN(BINARY); } + { OPCODE(F32Mul); RETURN(BINARY); } #line 3829 "src/prebuilt/ast-lexer-gen.cc" yy550: yych = *++lexer->cursor; @@ -3836,7 +3836,7 @@ yy551: goto yy49; } #line 304 "src/ast-lexer.cc" - { OPCODE(F32_NEG); RETURN(UNARY); } + { OPCODE(F32Neg); RETURN(UNARY); } #line 3841 "src/prebuilt/ast-lexer-gen.cc" yy553: yych = *++lexer->cursor; @@ -3856,7 +3856,7 @@ yy556: goto yy49; } #line 350 "src/ast-lexer.cc" - { OPCODE(F32_SUB); RETURN(BINARY); } + { OPCODE(F32Sub); RETURN(BINARY); } #line 3861 "src/prebuilt/ast-lexer-gen.cc" yy558: yych = *++lexer->cursor; @@ -3868,7 +3868,7 @@ yy559: goto yy49; } #line 307 "src/ast-lexer.cc" - { OPCODE(F64_ABS); RETURN(UNARY); } + { OPCODE(F64Abs); RETURN(UNARY); } #line 3873 "src/prebuilt/ast-lexer-gen.cc" yy561: ++lexer->cursor; @@ -3876,7 +3876,7 @@ yy561: goto yy49; } #line 349 "src/ast-lexer.cc" - { OPCODE(F64_ADD); RETURN(BINARY); } + { OPCODE(F64Add); RETURN(BINARY); } #line 3881 "src/prebuilt/ast-lexer-gen.cc" yy563: yych = *++lexer->cursor; @@ -3897,7 +3897,7 @@ yy566: goto yy49; } #line 355 "src/ast-lexer.cc" - { OPCODE(F64_DIV); RETURN(BINARY); } + { OPCODE(F64Div); RETURN(BINARY); } #line 3902 "src/prebuilt/ast-lexer-gen.cc" yy568: yych = *++lexer->cursor; @@ -3913,7 +3913,7 @@ yy570: goto yy49; } #line 359 "src/ast-lexer.cc" - { OPCODE(F64_MAX); RETURN(BINARY); } + { OPCODE(F64Max); RETURN(BINARY); } #line 3918 "src/prebuilt/ast-lexer-gen.cc" yy572: ++lexer->cursor; @@ -3921,7 +3921,7 @@ yy572: goto yy49; } #line 357 "src/ast-lexer.cc" - { OPCODE(F64_MIN); RETURN(BINARY); } + { OPCODE(F64Min); RETURN(BINARY); } #line 3926 "src/prebuilt/ast-lexer-gen.cc" yy574: ++lexer->cursor; @@ -3929,7 +3929,7 @@ yy574: goto yy49; } #line 353 "src/ast-lexer.cc" - { OPCODE(F64_MUL); RETURN(BINARY); } + { OPCODE(F64Mul); RETURN(BINARY); } #line 3934 "src/prebuilt/ast-lexer-gen.cc" yy576: yych = *++lexer->cursor; @@ -3941,7 +3941,7 @@ yy577: goto yy49; } #line 305 "src/ast-lexer.cc" - { OPCODE(F64_NEG); RETURN(UNARY); } + { OPCODE(F64Neg); RETURN(UNARY); } #line 3946 "src/prebuilt/ast-lexer-gen.cc" yy579: yych = *++lexer->cursor; @@ -3965,7 +3965,7 @@ yy583: goto yy49; } #line 351 "src/ast-lexer.cc" - { OPCODE(F64_SUB); RETURN(BINARY); } + { OPCODE(F64Sub); RETURN(BINARY); } #line 3970 "src/prebuilt/ast-lexer-gen.cc" yy585: yych = *++lexer->cursor; @@ -3989,7 +3989,7 @@ yy589: goto yy49; } #line 318 "src/ast-lexer.cc" - { OPCODE(I32_ADD); RETURN(BINARY); } + { OPCODE(I32Add); RETURN(BINARY); } #line 3994 "src/prebuilt/ast-lexer-gen.cc" yy591: ++lexer->cursor; @@ -3997,7 +3997,7 @@ yy591: goto yy49; } #line 332 "src/ast-lexer.cc" - { OPCODE(I32_AND); RETURN(BINARY); } + { OPCODE(I32And); RETURN(BINARY); } #line 4002 "src/prebuilt/ast-lexer-gen.cc" yy593: ++lexer->cursor; @@ -4005,7 +4005,7 @@ yy593: goto yy49; } #line 298 "src/ast-lexer.cc" - { OPCODE(I32_CLZ); RETURN(UNARY); } + { OPCODE(I32Clz); RETURN(UNARY); } #line 4010 "src/prebuilt/ast-lexer-gen.cc" yy595: yych = *++lexer->cursor; @@ -4017,7 +4017,7 @@ yy596: goto yy49; } #line 300 "src/ast-lexer.cc" - { OPCODE(I32_CTZ); RETURN(UNARY); } + { OPCODE(I32Ctz); RETURN(UNARY); } #line 4022 "src/prebuilt/ast-lexer-gen.cc" yy598: yych = *++lexer->cursor; @@ -4029,7 +4029,7 @@ yy599: goto yy49; } #line 296 "src/ast-lexer.cc" - { OPCODE(I32_EQZ); RETURN(CONVERT); } + { OPCODE(I32Eqz); RETURN(CONVERT); } #line 4034 "src/prebuilt/ast-lexer-gen.cc" yy601: yych = *++lexer->cursor; @@ -4061,7 +4061,7 @@ yy606: goto yy49; } #line 322 "src/ast-lexer.cc" - { OPCODE(I32_MUL); RETURN(BINARY); } + { OPCODE(I32Mul); RETURN(BINARY); } #line 4066 "src/prebuilt/ast-lexer-gen.cc" yy608: yych = *++lexer->cursor; @@ -4086,7 +4086,7 @@ yy612: goto yy49; } #line 338 "src/ast-lexer.cc" - { OPCODE(I32_SHL); RETURN(BINARY); } + { OPCODE(I32Shl); RETURN(BINARY); } #line 4091 "src/prebuilt/ast-lexer-gen.cc" yy614: yych = *++lexer->cursor; @@ -4102,7 +4102,7 @@ yy616: goto yy49; } #line 320 "src/ast-lexer.cc" - { OPCODE(I32_SUB); RETURN(BINARY); } + { OPCODE(I32Sub); RETURN(BINARY); } #line 4107 "src/prebuilt/ast-lexer-gen.cc" yy618: yych = *++lexer->cursor; @@ -4118,7 +4118,7 @@ yy620: goto yy49; } #line 336 "src/ast-lexer.cc" - { OPCODE(I32_XOR); RETURN(BINARY); } + { OPCODE(I32Xor); RETURN(BINARY); } #line 4123 "src/prebuilt/ast-lexer-gen.cc" yy622: ++lexer->cursor; @@ -4126,7 +4126,7 @@ yy622: goto yy49; } #line 319 "src/ast-lexer.cc" - { OPCODE(I64_ADD); RETURN(BINARY); } + { OPCODE(I64Add); RETURN(BINARY); } #line 4131 "src/prebuilt/ast-lexer-gen.cc" yy624: ++lexer->cursor; @@ -4134,7 +4134,7 @@ yy624: goto yy49; } #line 333 "src/ast-lexer.cc" - { OPCODE(I64_AND); RETURN(BINARY); } + { OPCODE(I64And); RETURN(BINARY); } #line 4139 "src/prebuilt/ast-lexer-gen.cc" yy626: ++lexer->cursor; @@ -4142,7 +4142,7 @@ yy626: goto yy49; } #line 299 "src/ast-lexer.cc" - { OPCODE(I64_CLZ); RETURN(UNARY); } + { OPCODE(I64Clz); RETURN(UNARY); } #line 4147 "src/prebuilt/ast-lexer-gen.cc" yy628: yych = *++lexer->cursor; @@ -4154,7 +4154,7 @@ yy629: goto yy49; } #line 301 "src/ast-lexer.cc" - { OPCODE(I64_CTZ); RETURN(UNARY); } + { OPCODE(I64Ctz); RETURN(UNARY); } #line 4159 "src/prebuilt/ast-lexer-gen.cc" yy631: yych = *++lexer->cursor; @@ -4166,7 +4166,7 @@ yy632: goto yy49; } #line 297 "src/ast-lexer.cc" - { OPCODE(I64_EQZ); RETURN(CONVERT); } + { OPCODE(I64Eqz); RETURN(CONVERT); } #line 4171 "src/prebuilt/ast-lexer-gen.cc" yy634: yych = *++lexer->cursor; @@ -4202,7 +4202,7 @@ yy640: goto yy49; } #line 323 "src/ast-lexer.cc" - { OPCODE(I64_MUL); RETURN(BINARY); } + { OPCODE(I64Mul); RETURN(BINARY); } #line 4207 "src/prebuilt/ast-lexer-gen.cc" yy642: yych = *++lexer->cursor; @@ -4227,7 +4227,7 @@ yy646: goto yy49; } #line 339 "src/ast-lexer.cc" - { OPCODE(I64_SHL); RETURN(BINARY); } + { OPCODE(I64Shl); RETURN(BINARY); } #line 4232 "src/prebuilt/ast-lexer-gen.cc" yy648: yych = *++lexer->cursor; @@ -4243,7 +4243,7 @@ yy650: goto yy49; } #line 321 "src/ast-lexer.cc" - { OPCODE(I64_SUB); RETURN(BINARY); } + { OPCODE(I64Sub); RETURN(BINARY); } #line 4248 "src/prebuilt/ast-lexer-gen.cc" yy652: yych = *++lexer->cursor; @@ -4255,7 +4255,7 @@ yy653: goto yy49; } #line 337 "src/ast-lexer.cc" - { OPCODE(I64_XOR); RETURN(BINARY); } + { OPCODE(I64Xor); RETURN(BINARY); } #line 4260 "src/prebuilt/ast-lexer-gen.cc" yy655: ++lexer->cursor; @@ -4403,7 +4403,7 @@ yy678: goto yy49; } #line 310 "src/ast-lexer.cc" - { OPCODE(F32_CEIL); RETURN(UNARY); } + { OPCODE(F32Ceil); RETURN(UNARY); } #line 4408 "src/prebuilt/ast-lexer-gen.cc" yy680: yych = *++lexer->cursor; @@ -4431,7 +4431,7 @@ yy685: goto yy49; } #line 269 "src/ast-lexer.cc" - { OPCODE(F32_LOAD); RETURN(LOAD); } + { OPCODE(F32Load); RETURN(LOAD); } #line 4436 "src/prebuilt/ast-lexer-gen.cc" yy687: yych = *++lexer->cursor; @@ -4447,7 +4447,7 @@ yy689: goto yy49; } #line 308 "src/ast-lexer.cc" - { OPCODE(F32_SQRT); RETURN(UNARY); } + { OPCODE(F32Sqrt); RETURN(UNARY); } #line 4452 "src/prebuilt/ast-lexer-gen.cc" yy691: yych = *++lexer->cursor; @@ -4463,7 +4463,7 @@ yy693: goto yy49; } #line 311 "src/ast-lexer.cc" - { OPCODE(F64_CEIL); RETURN(UNARY); } + { OPCODE(F64Ceil); RETURN(UNARY); } #line 4468 "src/prebuilt/ast-lexer-gen.cc" yy695: yych = *++lexer->cursor; @@ -4487,7 +4487,7 @@ yy699: goto yy49; } #line 270 "src/ast-lexer.cc" - { OPCODE(F64_LOAD); RETURN(LOAD); } + { OPCODE(F64Load); RETURN(LOAD); } #line 4492 "src/prebuilt/ast-lexer-gen.cc" yy701: yych = *++lexer->cursor; @@ -4507,7 +4507,7 @@ yy704: goto yy49; } #line 309 "src/ast-lexer.cc" - { OPCODE(F64_SQRT); RETURN(UNARY); } + { OPCODE(F64Sqrt); RETURN(UNARY); } #line 4512 "src/prebuilt/ast-lexer-gen.cc" yy706: yych = *++lexer->cursor; @@ -4544,7 +4544,7 @@ yy713: goto yy49; } #line 378 "src/ast-lexer.cc" - { OPCODE(I32_GE_S); RETURN(COMPARE); } + { OPCODE(I32GeS); RETURN(COMPARE); } #line 4549 "src/prebuilt/ast-lexer-gen.cc" yy715: ++lexer->cursor; @@ -4552,7 +4552,7 @@ yy715: goto yy49; } #line 380 "src/ast-lexer.cc" - { OPCODE(I32_GE_U); RETURN(COMPARE); } + { OPCODE(I32GeU); RETURN(COMPARE); } #line 4557 "src/prebuilt/ast-lexer-gen.cc" yy717: ++lexer->cursor; @@ -4560,7 +4560,7 @@ yy717: goto yy49; } #line 374 "src/ast-lexer.cc" - { OPCODE(I32_GT_S); RETURN(COMPARE); } + { OPCODE(I32GtS); RETURN(COMPARE); } #line 4565 "src/prebuilt/ast-lexer-gen.cc" yy719: ++lexer->cursor; @@ -4568,7 +4568,7 @@ yy719: goto yy49; } #line 376 "src/ast-lexer.cc" - { OPCODE(I32_GT_U); RETURN(COMPARE); } + { OPCODE(I32GtU); RETURN(COMPARE); } #line 4573 "src/prebuilt/ast-lexer-gen.cc" yy721: ++lexer->cursor; @@ -4576,7 +4576,7 @@ yy721: goto yy49; } #line 370 "src/ast-lexer.cc" - { OPCODE(I32_LE_S); RETURN(COMPARE); } + { OPCODE(I32LeS); RETURN(COMPARE); } #line 4581 "src/prebuilt/ast-lexer-gen.cc" yy723: ++lexer->cursor; @@ -4584,7 +4584,7 @@ yy723: goto yy49; } #line 372 "src/ast-lexer.cc" - { OPCODE(I32_LE_U); RETURN(COMPARE); } + { OPCODE(I32LeU); RETURN(COMPARE); } #line 4589 "src/prebuilt/ast-lexer-gen.cc" yy725: ++lexer->cursor; @@ -4622,7 +4622,7 @@ yy725: } yy726: #line 267 "src/ast-lexer.cc" - { OPCODE(I32_LOAD); RETURN(LOAD); } + { OPCODE(I32Load); RETURN(LOAD); } #line 4627 "src/prebuilt/ast-lexer-gen.cc" yy727: ++lexer->cursor; @@ -4630,7 +4630,7 @@ yy727: goto yy49; } #line 366 "src/ast-lexer.cc" - { OPCODE(I32_LT_S); RETURN(COMPARE); } + { OPCODE(I32LtS); RETURN(COMPARE); } #line 4635 "src/prebuilt/ast-lexer-gen.cc" yy729: ++lexer->cursor; @@ -4638,7 +4638,7 @@ yy729: goto yy49; } #line 368 "src/ast-lexer.cc" - { OPCODE(I32_LT_U); RETURN(COMPARE); } + { OPCODE(I32LtU); RETURN(COMPARE); } #line 4643 "src/prebuilt/ast-lexer-gen.cc" yy731: yych = *++lexer->cursor; @@ -4659,7 +4659,7 @@ yy734: goto yy49; } #line 344 "src/ast-lexer.cc" - { OPCODE(I32_ROTL); RETURN(BINARY); } + { OPCODE(I32Rotl); RETURN(BINARY); } #line 4664 "src/prebuilt/ast-lexer-gen.cc" yy736: ++lexer->cursor; @@ -4667,7 +4667,7 @@ yy736: goto yy49; } #line 346 "src/ast-lexer.cc" - { OPCODE(I32_ROTR); RETURN(BINARY); } + { OPCODE(I32Rotr); RETURN(BINARY); } #line 4672 "src/prebuilt/ast-lexer-gen.cc" yy738: yych = *++lexer->cursor; @@ -4705,7 +4705,7 @@ yy745: goto yy49; } #line 379 "src/ast-lexer.cc" - { OPCODE(I64_GE_S); RETURN(COMPARE); } + { OPCODE(I64GeS); RETURN(COMPARE); } #line 4710 "src/prebuilt/ast-lexer-gen.cc" yy747: ++lexer->cursor; @@ -4713,7 +4713,7 @@ yy747: goto yy49; } #line 381 "src/ast-lexer.cc" - { OPCODE(I64_GE_U); RETURN(COMPARE); } + { OPCODE(I64GeU); RETURN(COMPARE); } #line 4718 "src/prebuilt/ast-lexer-gen.cc" yy749: ++lexer->cursor; @@ -4721,7 +4721,7 @@ yy749: goto yy49; } #line 375 "src/ast-lexer.cc" - { OPCODE(I64_GT_S); RETURN(COMPARE); } + { OPCODE(I64GtS); RETURN(COMPARE); } #line 4726 "src/prebuilt/ast-lexer-gen.cc" yy751: ++lexer->cursor; @@ -4729,7 +4729,7 @@ yy751: goto yy49; } #line 377 "src/ast-lexer.cc" - { OPCODE(I64_GT_U); RETURN(COMPARE); } + { OPCODE(I64GtU); RETURN(COMPARE); } #line 4734 "src/prebuilt/ast-lexer-gen.cc" yy753: ++lexer->cursor; @@ -4737,7 +4737,7 @@ yy753: goto yy49; } #line 371 "src/ast-lexer.cc" - { OPCODE(I64_LE_S); RETURN(COMPARE); } + { OPCODE(I64LeS); RETURN(COMPARE); } #line 4742 "src/prebuilt/ast-lexer-gen.cc" yy755: ++lexer->cursor; @@ -4745,7 +4745,7 @@ yy755: goto yy49; } #line 373 "src/ast-lexer.cc" - { OPCODE(I64_LE_U); RETURN(COMPARE); } + { OPCODE(I64LeU); RETURN(COMPARE); } #line 4750 "src/prebuilt/ast-lexer-gen.cc" yy757: ++lexer->cursor; @@ -4787,7 +4787,7 @@ yy757: } yy758: #line 268 "src/ast-lexer.cc" - { OPCODE(I64_LOAD); RETURN(LOAD); } + { OPCODE(I64Load); RETURN(LOAD); } #line 4792 "src/prebuilt/ast-lexer-gen.cc" yy759: ++lexer->cursor; @@ -4795,7 +4795,7 @@ yy759: goto yy49; } #line 367 "src/ast-lexer.cc" - { OPCODE(I64_LT_S); RETURN(COMPARE); } + { OPCODE(I64LtS); RETURN(COMPARE); } #line 4800 "src/prebuilt/ast-lexer-gen.cc" yy761: ++lexer->cursor; @@ -4803,7 +4803,7 @@ yy761: goto yy49; } #line 369 "src/ast-lexer.cc" - { OPCODE(I64_LT_U); RETURN(COMPARE); } + { OPCODE(I64LtU); RETURN(COMPARE); } #line 4808 "src/prebuilt/ast-lexer-gen.cc" yy763: yych = *++lexer->cursor; @@ -4824,7 +4824,7 @@ yy766: goto yy49; } #line 345 "src/ast-lexer.cc" - { OPCODE(I64_ROTL); RETURN(BINARY); } + { OPCODE(I64Rotl); RETURN(BINARY); } #line 4829 "src/prebuilt/ast-lexer-gen.cc" yy768: ++lexer->cursor; @@ -4832,7 +4832,7 @@ yy768: goto yy49; } #line 347 "src/ast-lexer.cc" - { OPCODE(I64_ROTR); RETURN(BINARY); } + { OPCODE(I64Rotr); RETURN(BINARY); } #line 4837 "src/prebuilt/ast-lexer-gen.cc" yy770: yych = *++lexer->cursor; @@ -5067,7 +5067,7 @@ yy800: goto yy49; } #line 312 "src/ast-lexer.cc" - { OPCODE(F32_FLOOR); RETURN(UNARY); } + { OPCODE(F32Floor); RETURN(UNARY); } #line 5072 "src/prebuilt/ast-lexer-gen.cc" yy802: yych = *++lexer->cursor; @@ -5083,7 +5083,7 @@ yy804: goto yy49; } #line 273 "src/ast-lexer.cc" - { OPCODE(F32_STORE); RETURN(STORE); } + { OPCODE(F32Store); RETURN(STORE); } #line 5088 "src/prebuilt/ast-lexer-gen.cc" yy806: ++lexer->cursor; @@ -5091,7 +5091,7 @@ yy806: goto yy49; } #line 314 "src/ast-lexer.cc" - { OPCODE(F32_TRUNC); RETURN(UNARY); } + { OPCODE(F32Trunc); RETURN(UNARY); } #line 5096 "src/prebuilt/ast-lexer-gen.cc" yy808: ++lexer->cursor; @@ -5115,7 +5115,7 @@ yy812: goto yy49; } #line 313 "src/ast-lexer.cc" - { OPCODE(F64_FLOOR); RETURN(UNARY); } + { OPCODE(F64Floor); RETURN(UNARY); } #line 5120 "src/prebuilt/ast-lexer-gen.cc" yy814: yych = *++lexer->cursor; @@ -5135,7 +5135,7 @@ yy817: goto yy49; } #line 274 "src/ast-lexer.cc" - { OPCODE(F64_STORE); RETURN(STORE); } + { OPCODE(F64Store); RETURN(STORE); } #line 5140 "src/prebuilt/ast-lexer-gen.cc" yy819: ++lexer->cursor; @@ -5143,7 +5143,7 @@ yy819: goto yy49; } #line 315 "src/ast-lexer.cc" - { OPCODE(F64_TRUNC); RETURN(UNARY); } + { OPCODE(F64Trunc); RETURN(UNARY); } #line 5148 "src/prebuilt/ast-lexer-gen.cc" yy821: yych = *++lexer->cursor; @@ -5175,7 +5175,7 @@ yy827: goto yy49; } #line 324 "src/ast-lexer.cc" - { OPCODE(I32_DIV_S); RETURN(BINARY); } + { OPCODE(I32DivS); RETURN(BINARY); } #line 5180 "src/prebuilt/ast-lexer-gen.cc" yy829: ++lexer->cursor; @@ -5183,7 +5183,7 @@ yy829: goto yy49; } #line 326 "src/ast-lexer.cc" - { OPCODE(I32_DIV_U); RETURN(BINARY); } + { OPCODE(I32DivU); RETURN(BINARY); } #line 5188 "src/prebuilt/ast-lexer-gen.cc" yy831: yych = *++lexer->cursor; @@ -5207,7 +5207,7 @@ yy835: goto yy49; } #line 328 "src/ast-lexer.cc" - { OPCODE(I32_REM_S); RETURN(BINARY); } + { OPCODE(I32RemS); RETURN(BINARY); } #line 5212 "src/prebuilt/ast-lexer-gen.cc" yy837: ++lexer->cursor; @@ -5215,7 +5215,7 @@ yy837: goto yy49; } #line 330 "src/ast-lexer.cc" - { OPCODE(I32_REM_U); RETURN(BINARY); } + { OPCODE(I32RemU); RETURN(BINARY); } #line 5220 "src/prebuilt/ast-lexer-gen.cc" yy839: ++lexer->cursor; @@ -5223,7 +5223,7 @@ yy839: goto yy49; } #line 340 "src/ast-lexer.cc" - { OPCODE(I32_SHR_S); RETURN(BINARY); } + { OPCODE(I32ShrS); RETURN(BINARY); } #line 5228 "src/prebuilt/ast-lexer-gen.cc" yy841: ++lexer->cursor; @@ -5231,7 +5231,7 @@ yy841: goto yy49; } #line 342 "src/ast-lexer.cc" - { OPCODE(I32_SHR_U); RETURN(BINARY); } + { OPCODE(I32ShrU); RETURN(BINARY); } #line 5236 "src/prebuilt/ast-lexer-gen.cc" yy843: ++lexer->cursor; @@ -5269,7 +5269,7 @@ yy843: } yy844: #line 271 "src/ast-lexer.cc" - { OPCODE(I32_STORE); RETURN(STORE); } + { OPCODE(I32Store); RETURN(STORE); } #line 5274 "src/prebuilt/ast-lexer-gen.cc" yy845: yych = *++lexer->cursor; @@ -5293,7 +5293,7 @@ yy849: goto yy49; } #line 325 "src/ast-lexer.cc" - { OPCODE(I64_DIV_S); RETURN(BINARY); } + { OPCODE(I64DivS); RETURN(BINARY); } #line 5298 "src/prebuilt/ast-lexer-gen.cc" yy851: ++lexer->cursor; @@ -5301,7 +5301,7 @@ yy851: goto yy49; } #line 327 "src/ast-lexer.cc" - { OPCODE(I64_DIV_U); RETURN(BINARY); } + { OPCODE(I64DivU); RETURN(BINARY); } #line 5306 "src/prebuilt/ast-lexer-gen.cc" yy853: yych = *++lexer->cursor; @@ -5333,7 +5333,7 @@ yy859: goto yy49; } #line 329 "src/ast-lexer.cc" - { OPCODE(I64_REM_S); RETURN(BINARY); } + { OPCODE(I64RemS); RETURN(BINARY); } #line 5338 "src/prebuilt/ast-lexer-gen.cc" yy861: ++lexer->cursor; @@ -5341,7 +5341,7 @@ yy861: goto yy49; } #line 331 "src/ast-lexer.cc" - { OPCODE(I64_REM_U); RETURN(BINARY); } + { OPCODE(I64RemU); RETURN(BINARY); } #line 5346 "src/prebuilt/ast-lexer-gen.cc" yy863: ++lexer->cursor; @@ -5349,7 +5349,7 @@ yy863: goto yy49; } #line 341 "src/ast-lexer.cc" - { OPCODE(I64_SHR_S); RETURN(BINARY); } + { OPCODE(I64ShrS); RETURN(BINARY); } #line 5354 "src/prebuilt/ast-lexer-gen.cc" yy865: ++lexer->cursor; @@ -5357,7 +5357,7 @@ yy865: goto yy49; } #line 343 "src/ast-lexer.cc" - { OPCODE(I64_SHR_U); RETURN(BINARY); } + { OPCODE(I64ShrU); RETURN(BINARY); } #line 5362 "src/prebuilt/ast-lexer-gen.cc" yy867: ++lexer->cursor; @@ -5399,7 +5399,7 @@ yy867: } yy868: #line 272 "src/ast-lexer.cc" - { OPCODE(I64_STORE); RETURN(STORE); } + { OPCODE(I64Store); RETURN(STORE); } #line 5404 "src/prebuilt/ast-lexer-gen.cc" yy869: yych = *++lexer->cursor; @@ -5544,7 +5544,7 @@ yy901: goto yy49; } #line 302 "src/ast-lexer.cc" - { OPCODE(I32_POPCNT); RETURN(UNARY); } + { OPCODE(I32Popcnt); RETURN(UNARY); } #line 5549 "src/prebuilt/ast-lexer-gen.cc" yy903: yych = *++lexer->cursor; @@ -5560,7 +5560,7 @@ yy905: goto yy49; } #line 285 "src/ast-lexer.cc" - { OPCODE(I32_STORE8); RETURN(STORE); } + { OPCODE(I32Store8); RETURN(STORE); } #line 5565 "src/prebuilt/ast-lexer-gen.cc" yy907: yych = *++lexer->cursor; @@ -5594,7 +5594,7 @@ yy913: goto yy49; } #line 303 "src/ast-lexer.cc" - { OPCODE(I64_POPCNT); RETURN(UNARY); } + { OPCODE(I64Popcnt); RETURN(UNARY); } #line 5599 "src/prebuilt/ast-lexer-gen.cc" yy915: yych = *++lexer->cursor; @@ -5614,7 +5614,7 @@ yy918: goto yy49; } #line 286 "src/ast-lexer.cc" - { OPCODE(I64_STORE8); RETURN(STORE); } + { OPCODE(I64Store8); RETURN(STORE); } #line 5619 "src/prebuilt/ast-lexer-gen.cc" yy920: yych = *++lexer->cursor; @@ -5741,7 +5741,7 @@ yy940: goto yy49; } #line 316 "src/ast-lexer.cc" - { OPCODE(F32_NEAREST); RETURN(UNARY); } + { OPCODE(F32Nearest); RETURN(UNARY); } #line 5746 "src/prebuilt/ast-lexer-gen.cc" yy942: yych = *++lexer->cursor; @@ -5761,7 +5761,7 @@ yy945: goto yy49; } #line 317 "src/ast-lexer.cc" - { OPCODE(F64_NEAREST); RETURN(UNARY); } + { OPCODE(F64Nearest); RETURN(UNARY); } #line 5766 "src/prebuilt/ast-lexer-gen.cc" yy947: yych = *++lexer->cursor; @@ -5790,7 +5790,7 @@ yy952: goto yy49; } #line 275 "src/ast-lexer.cc" - { OPCODE(I32_LOAD8_S); RETURN(LOAD); } + { OPCODE(I32Load8S); RETURN(LOAD); } #line 5795 "src/prebuilt/ast-lexer-gen.cc" yy954: ++lexer->cursor; @@ -5798,7 +5798,7 @@ yy954: goto yy49; } #line 277 "src/ast-lexer.cc" - { OPCODE(I32_LOAD8_U); RETURN(LOAD); } + { OPCODE(I32Load8U); RETURN(LOAD); } #line 5803 "src/prebuilt/ast-lexer-gen.cc" yy956: yych = *++lexer->cursor; @@ -5810,7 +5810,7 @@ yy957: goto yy49; } #line 287 "src/ast-lexer.cc" - { OPCODE(I32_STORE16); RETURN(STORE); } + { OPCODE(I32Store16); RETURN(STORE); } #line 5815 "src/prebuilt/ast-lexer-gen.cc" yy959: yych = *++lexer->cursor; @@ -5845,7 +5845,7 @@ yy965: goto yy49; } #line 276 "src/ast-lexer.cc" - { OPCODE(I64_LOAD8_S); RETURN(LOAD); } + { OPCODE(I64Load8S); RETURN(LOAD); } #line 5850 "src/prebuilt/ast-lexer-gen.cc" yy967: ++lexer->cursor; @@ -5853,7 +5853,7 @@ yy967: goto yy49; } #line 278 "src/ast-lexer.cc" - { OPCODE(I64_LOAD8_U); RETURN(LOAD); } + { OPCODE(I64Load8U); RETURN(LOAD); } #line 5858 "src/prebuilt/ast-lexer-gen.cc" yy969: yych = *++lexer->cursor; @@ -5865,7 +5865,7 @@ yy970: goto yy49; } #line 288 "src/ast-lexer.cc" - { OPCODE(I64_STORE16); RETURN(STORE); } + { OPCODE(I64Store16); RETURN(STORE); } #line 5870 "src/prebuilt/ast-lexer-gen.cc" yy972: ++lexer->cursor; @@ -5873,7 +5873,7 @@ yy972: goto yy49; } #line 289 "src/ast-lexer.cc" - { OPCODE(I64_STORE32); RETURN(STORE); } + { OPCODE(I64Store32); RETURN(STORE); } #line 5878 "src/prebuilt/ast-lexer-gen.cc" yy974: yych = *++lexer->cursor; @@ -5930,7 +5930,7 @@ yy986: goto yy49; } #line 360 "src/ast-lexer.cc" - { OPCODE(F32_COPYSIGN); RETURN(BINARY); } + { OPCODE(F32Copysign); RETURN(BINARY); } #line 5935 "src/prebuilt/ast-lexer-gen.cc" yy988: yych = *++lexer->cursor; @@ -5951,7 +5951,7 @@ yy991: goto yy49; } #line 361 "src/ast-lexer.cc" - { OPCODE(F64_COPYSIGN); RETURN(BINARY); } + { OPCODE(F64Copysign); RETURN(BINARY); } #line 5956 "src/prebuilt/ast-lexer-gen.cc" yy993: yych = *++lexer->cursor; @@ -5967,7 +5967,7 @@ yy995: goto yy49; } #line 279 "src/ast-lexer.cc" - { OPCODE(I32_LOAD16_S); RETURN(LOAD); } + { OPCODE(I32Load16S); RETURN(LOAD); } #line 5972 "src/prebuilt/ast-lexer-gen.cc" yy997: ++lexer->cursor; @@ -5975,7 +5975,7 @@ yy997: goto yy49; } #line 281 "src/ast-lexer.cc" - { OPCODE(I32_LOAD16_U); RETURN(LOAD); } + { OPCODE(I32Load16U); RETURN(LOAD); } #line 5980 "src/prebuilt/ast-lexer-gen.cc" yy999: yych = *++lexer->cursor; @@ -5995,7 +5995,7 @@ yy1002: goto yy49; } #line 396 "src/ast-lexer.cc" - { OPCODE(I32_WRAP_I64); RETURN(CONVERT); } + { OPCODE(I32WrapI64); RETURN(CONVERT); } #line 6000 "src/prebuilt/ast-lexer-gen.cc" yy1004: yych = *++lexer->cursor; @@ -6011,7 +6011,7 @@ yy1006: goto yy49; } #line 280 "src/ast-lexer.cc" - { OPCODE(I64_LOAD16_S); RETURN(LOAD); } + { OPCODE(I64Load16S); RETURN(LOAD); } #line 6016 "src/prebuilt/ast-lexer-gen.cc" yy1008: ++lexer->cursor; @@ -6019,7 +6019,7 @@ yy1008: goto yy49; } #line 282 "src/ast-lexer.cc" - { OPCODE(I64_LOAD16_U); RETURN(LOAD); } + { OPCODE(I64Load16U); RETURN(LOAD); } #line 6024 "src/prebuilt/ast-lexer-gen.cc" yy1010: ++lexer->cursor; @@ -6027,7 +6027,7 @@ yy1010: goto yy49; } #line 283 "src/ast-lexer.cc" - { OPCODE(I64_LOAD32_S); RETURN(LOAD); } + { OPCODE(I64Load32S); RETURN(LOAD); } #line 6032 "src/prebuilt/ast-lexer-gen.cc" yy1012: ++lexer->cursor; @@ -6035,7 +6035,7 @@ yy1012: goto yy49; } #line 284 "src/ast-lexer.cc" - { OPCODE(I64_LOAD32_U); RETURN(LOAD); } + { OPCODE(I64Load32U); RETURN(LOAD); } #line 6040 "src/prebuilt/ast-lexer-gen.cc" yy1014: yych = *++lexer->cursor; @@ -6229,7 +6229,7 @@ yy1052: goto yy49; } #line 414 "src/ast-lexer.cc" - { OPCODE(F32_DEMOTE_F64); RETURN(CONVERT); } + { OPCODE(F32DemoteF64); RETURN(CONVERT); } #line 6234 "src/prebuilt/ast-lexer-gen.cc" yy1054: yych = *++lexer->cursor; @@ -6345,7 +6345,7 @@ yy1080: goto yy49; } #line 413 "src/ast-lexer.cc" - { OPCODE(F64_PROMOTE_F32); RETURN(CONVERT); } + { OPCODE(F64PromoteF32); RETURN(CONVERT); } #line 6350 "src/prebuilt/ast-lexer-gen.cc" yy1082: yych = *++lexer->cursor; @@ -6361,7 +6361,7 @@ yy1084: goto yy49; } #line 397 "src/ast-lexer.cc" - { OPCODE(I32_TRUNC_S_F32); RETURN(CONVERT); } + { OPCODE(I32TruncSF32); RETURN(CONVERT); } #line 6366 "src/prebuilt/ast-lexer-gen.cc" yy1086: ++lexer->cursor; @@ -6369,7 +6369,7 @@ yy1086: goto yy49; } #line 399 "src/ast-lexer.cc" - { OPCODE(I32_TRUNC_S_F64); RETURN(CONVERT); } + { OPCODE(I32TruncSF64); RETURN(CONVERT); } #line 6374 "src/prebuilt/ast-lexer-gen.cc" yy1088: ++lexer->cursor; @@ -6377,7 +6377,7 @@ yy1088: goto yy49; } #line 401 "src/ast-lexer.cc" - { OPCODE(I32_TRUNC_U_F32); RETURN(CONVERT); } + { OPCODE(I32TruncUF32); RETURN(CONVERT); } #line 6382 "src/prebuilt/ast-lexer-gen.cc" yy1090: ++lexer->cursor; @@ -6385,7 +6385,7 @@ yy1090: goto yy49; } #line 403 "src/ast-lexer.cc" - { OPCODE(I32_TRUNC_U_F64); RETURN(CONVERT); } + { OPCODE(I32TruncUF64); RETURN(CONVERT); } #line 6390 "src/prebuilt/ast-lexer-gen.cc" yy1092: yych = *++lexer->cursor; @@ -6405,7 +6405,7 @@ yy1095: goto yy49; } #line 398 "src/ast-lexer.cc" - { OPCODE(I64_TRUNC_S_F32); RETURN(CONVERT); } + { OPCODE(I64TruncSF32); RETURN(CONVERT); } #line 6410 "src/prebuilt/ast-lexer-gen.cc" yy1097: ++lexer->cursor; @@ -6413,7 +6413,7 @@ yy1097: goto yy49; } #line 400 "src/ast-lexer.cc" - { OPCODE(I64_TRUNC_S_F64); RETURN(CONVERT); } + { OPCODE(I64TruncSF64); RETURN(CONVERT); } #line 6418 "src/prebuilt/ast-lexer-gen.cc" yy1099: ++lexer->cursor; @@ -6421,7 +6421,7 @@ yy1099: goto yy49; } #line 402 "src/ast-lexer.cc" - { OPCODE(I64_TRUNC_U_F32); RETURN(CONVERT); } + { OPCODE(I64TruncUF32); RETURN(CONVERT); } #line 6426 "src/prebuilt/ast-lexer-gen.cc" yy1101: ++lexer->cursor; @@ -6429,7 +6429,7 @@ yy1101: goto yy49; } #line 404 "src/ast-lexer.cc" - { OPCODE(I64_TRUNC_U_F64); RETURN(CONVERT); } + { OPCODE(I64TruncUF64); RETURN(CONVERT); } #line 6434 "src/prebuilt/ast-lexer-gen.cc" yy1103: yych = *++lexer->cursor; @@ -6501,7 +6501,7 @@ yy1119: goto yy49; } #line 394 "src/ast-lexer.cc" - { OPCODE(I64_EXTEND_S_I32); RETURN(CONVERT); } + { OPCODE(I64ExtendSI32); RETURN(CONVERT); } #line 6506 "src/prebuilt/ast-lexer-gen.cc" yy1121: ++lexer->cursor; @@ -6509,7 +6509,7 @@ yy1121: goto yy49; } #line 395 "src/ast-lexer.cc" - { OPCODE(I64_EXTEND_U_I32); RETURN(CONVERT); } + { OPCODE(I64ExtendUI32); RETURN(CONVERT); } #line 6514 "src/prebuilt/ast-lexer-gen.cc" yy1123: yych = *++lexer->cursor; @@ -6545,7 +6545,7 @@ yy1130: goto yy49; } #line 405 "src/ast-lexer.cc" - { OPCODE(F32_CONVERT_S_I32); RETURN(CONVERT); } + { OPCODE(F32ConvertSI32); RETURN(CONVERT); } #line 6550 "src/prebuilt/ast-lexer-gen.cc" yy1132: ++lexer->cursor; @@ -6553,7 +6553,7 @@ yy1132: goto yy49; } #line 407 "src/ast-lexer.cc" - { OPCODE(F32_CONVERT_S_I64); RETURN(CONVERT); } + { OPCODE(F32ConvertSI64); RETURN(CONVERT); } #line 6558 "src/prebuilt/ast-lexer-gen.cc" yy1134: ++lexer->cursor; @@ -6561,7 +6561,7 @@ yy1134: goto yy49; } #line 409 "src/ast-lexer.cc" - { OPCODE(F32_CONVERT_U_I32); RETURN(CONVERT); } + { OPCODE(F32ConvertUI32); RETURN(CONVERT); } #line 6566 "src/prebuilt/ast-lexer-gen.cc" yy1136: ++lexer->cursor; @@ -6569,7 +6569,7 @@ yy1136: goto yy49; } #line 411 "src/ast-lexer.cc" - { OPCODE(F32_CONVERT_U_I64); RETURN(CONVERT); } + { OPCODE(F32ConvertUI64); RETURN(CONVERT); } #line 6574 "src/prebuilt/ast-lexer-gen.cc" yy1138: yych = *++lexer->cursor; @@ -6581,7 +6581,7 @@ yy1139: goto yy49; } #line 406 "src/ast-lexer.cc" - { OPCODE(F64_CONVERT_S_I32); RETURN(CONVERT); } + { OPCODE(F64ConvertSI32); RETURN(CONVERT); } #line 6586 "src/prebuilt/ast-lexer-gen.cc" yy1141: ++lexer->cursor; @@ -6589,7 +6589,7 @@ yy1141: goto yy49; } #line 408 "src/ast-lexer.cc" - { OPCODE(F64_CONVERT_S_I64); RETURN(CONVERT); } + { OPCODE(F64ConvertSI64); RETURN(CONVERT); } #line 6594 "src/prebuilt/ast-lexer-gen.cc" yy1143: ++lexer->cursor; @@ -6597,7 +6597,7 @@ yy1143: goto yy49; } #line 410 "src/ast-lexer.cc" - { OPCODE(F64_CONVERT_U_I32); RETURN(CONVERT); } + { OPCODE(F64ConvertUI32); RETURN(CONVERT); } #line 6602 "src/prebuilt/ast-lexer-gen.cc" yy1145: ++lexer->cursor; @@ -6605,7 +6605,7 @@ yy1145: goto yy49; } #line 412 "src/ast-lexer.cc" - { OPCODE(F64_CONVERT_U_I64); RETURN(CONVERT); } + { OPCODE(F64ConvertUI64); RETURN(CONVERT); } #line 6610 "src/prebuilt/ast-lexer-gen.cc" yy1147: yych = *++lexer->cursor; @@ -6641,7 +6641,7 @@ yy1154: goto yy49; } #line 415 "src/ast-lexer.cc" - { OPCODE(F32_REINTERPRET_I32); RETURN(CONVERT); + { OPCODE(F32ReinterpretI32); RETURN(CONVERT); } #line 6647 "src/prebuilt/ast-lexer-gen.cc" yy1156: @@ -6650,7 +6650,7 @@ yy1156: goto yy49; } #line 419 "src/ast-lexer.cc" - { OPCODE(F64_REINTERPRET_I64); RETURN(CONVERT); + { OPCODE(F64ReinterpretI64); RETURN(CONVERT); } #line 6656 "src/prebuilt/ast-lexer-gen.cc" yy1158: @@ -6659,7 +6659,7 @@ yy1158: goto yy49; } #line 417 "src/ast-lexer.cc" - { OPCODE(I32_REINTERPRET_F32); RETURN(CONVERT); + { OPCODE(I32ReinterpretF32); RETURN(CONVERT); } #line 6665 "src/prebuilt/ast-lexer-gen.cc" yy1160: @@ -6668,7 +6668,7 @@ yy1160: goto yy49; } #line 421 "src/ast-lexer.cc" - { OPCODE(I64_REINTERPRET_F64); RETURN(CONVERT); + { OPCODE(I64ReinterpretF64); RETURN(CONVERT); } #line 6674 "src/prebuilt/ast-lexer-gen.cc" } @@ -6689,7 +6689,7 @@ static WabtAstLexer* wabt_new_lexer(WabtAstLexerSourceType type, } WabtAstLexer* wabt_new_ast_file_lexer(const char* filename) { - WabtAstLexer* lexer = wabt_new_lexer(WABT_LEXER_SOURCE_TYPE_FILE, filename); + WabtAstLexer* lexer = wabt_new_lexer(WabtAstLexerSourceType::File, filename); lexer->source.file = fopen(filename, "rb"); if (!lexer->source.file) { wabt_destroy_ast_lexer(lexer); @@ -6701,7 +6701,8 @@ WabtAstLexer* wabt_new_ast_file_lexer(const char* filename) { WabtAstLexer* wabt_new_ast_buffer_lexer(const char* filename, const void* data, size_t size) { - WabtAstLexer* lexer = wabt_new_lexer(WABT_LEXER_SOURCE_TYPE_BUFFER, filename); + WabtAstLexer* lexer = + wabt_new_lexer(WabtAstLexerSourceType::Buffer, filename); lexer->source.buffer.data = data; lexer->source.buffer.size = size; lexer->source.buffer.read_offset = 0; @@ -6709,15 +6710,15 @@ WabtAstLexer* wabt_new_ast_buffer_lexer(const char* filename, } void wabt_destroy_ast_lexer(WabtAstLexer* lexer) { - if (lexer->source.type == WABT_LEXER_SOURCE_TYPE_FILE && lexer->source.file) + if (lexer->source.type == WabtAstLexerSourceType::File && lexer->source.file) fclose(lexer->source.file); wabt_free(lexer->buffer); wabt_free(lexer); } -enum WabtLineOffsetPosition { - WABT_LINE_OFFSET_POSITION_START, - WABT_LINE_OFFSET_POSITION_END, +enum class WabtLineOffsetPosition { + Start, + End, }; static WabtResult scan_forward_for_line_offset_in_buffer( @@ -6735,14 +6736,15 @@ static WabtResult scan_forward_for_line_offset_in_buffer( bool is_previous_carriage = 0; for (p = buffer_start; p < buffer_end; ++p) { if (*p == '\n') { - if (find_position == WABT_LINE_OFFSET_POSITION_START) { + if (find_position == WabtLineOffsetPosition::Start) { if (++line == find_line) { line_offset = buffer_file_offset + (p - buffer_start) + 1; break; } } else { if (line++ == find_line) { - line_offset = buffer_file_offset + (p - buffer_start) - is_previous_carriage; + line_offset = + buffer_file_offset + (p - buffer_start) - is_previous_carriage; break; } } @@ -6750,11 +6752,11 @@ static WabtResult scan_forward_for_line_offset_in_buffer( is_previous_carriage = *p == '\r'; } - WabtResult result = WABT_OK; + WabtResult result = WabtResult::Ok; if (p == buffer_end) { /* end of buffer */ - if (find_position == WABT_LINE_OFFSET_POSITION_START) { - result = WABT_ERROR; + if (find_position == WabtLineOffsetPosition::Start) { + result = WabtResult::Error; } else { line_offset = buffer_file_offset + (buffer_end - buffer_start); } @@ -6773,10 +6775,10 @@ static WabtResult scan_forward_for_line_offset_in_file( int find_line, size_t* out_line_offset) { FILE* lexer_file = lexer->source.file; - WabtResult result = WABT_ERROR; + WabtResult result = WabtResult::Error; long old_offset = ftell(lexer_file); if (old_offset == -1) - return WABT_ERROR; + return WabtResult::Error; size_t buffer_file_offset = line_start_offset; if (fseek(lexer_file, buffer_file_offset, SEEK_SET) == -1) goto cleanup; @@ -6787,11 +6789,11 @@ static WabtResult scan_forward_for_line_offset_in_file( size_t read_bytes = fread(buffer, 1, buffer_size, lexer_file); if (read_bytes == 0) { /* end of buffer */ - if (find_position == WABT_LINE_OFFSET_POSITION_START) { - result = WABT_ERROR; + if (find_position == WabtLineOffsetPosition::Start) { + result = WabtResult::Error; } else { *out_line_offset = buffer_file_offset + read_bytes; - result = WABT_OK; + result = WabtResult::Ok; } goto cleanup; } @@ -6800,7 +6802,7 @@ static WabtResult scan_forward_for_line_offset_in_file( result = scan_forward_for_line_offset_in_buffer( buffer, buffer_end, line, buffer_file_offset, find_position, find_line, &line, out_line_offset); - if (result == WABT_OK) + if (result == WabtResult::Ok) goto cleanup; buffer_file_offset += read_bytes; @@ -6809,7 +6811,7 @@ static WabtResult scan_forward_for_line_offset_in_file( cleanup: /* if this fails, we're screwed */ if (fseek(lexer_file, old_offset, SEEK_SET) == -1) - return WABT_ERROR; + return WabtResult::Error; return result; } @@ -6821,7 +6823,7 @@ static WabtResult scan_forward_for_line_offset( int find_line, size_t* out_line_offset) { assert(line <= find_line); - if (lexer->source.type == WABT_LEXER_SOURCE_TYPE_BUFFER) { + if (lexer->source.type == WabtAstLexerSourceType::Buffer) { const char* source_buffer = static_cast<const char*>(lexer->source.buffer.data); const char* buffer_start = source_buffer + line_start_offset; @@ -6830,7 +6832,7 @@ static WabtResult scan_forward_for_line_offset( buffer_start, buffer_end, line, line_start_offset, find_position, find_line, &line, out_line_offset); } else { - assert(lexer->source.type == WABT_LEXER_SOURCE_TYPE_FILE); + assert(lexer->source.type == WabtAstLexerSourceType::File); return scan_forward_for_line_offset_in_file(lexer, line, line_start_offset, find_position, find_line, out_line_offset); @@ -6847,18 +6849,18 @@ static WabtResult get_line_start_offset(WabtAstLexer* lexer, if (line == current_line) { *out_offset = current_offset; - return WABT_OK; + return WabtResult::Ok; } else if (line == first_line) { *out_offset = first_offset; - return WABT_OK; + return WabtResult::Ok; } else if (line > current_line) { return scan_forward_for_line_offset(lexer, current_line, current_offset, - WABT_LINE_OFFSET_POSITION_START, line, + WabtLineOffsetPosition::Start, line, out_offset); } else { /* TODO(binji): optimize by storing more known line/offset pairs */ return scan_forward_for_line_offset(lexer, first_line, first_offset, - WABT_LINE_OFFSET_POSITION_START, line, + WabtLineOffsetPosition::Start, line, out_offset); } } @@ -6869,16 +6871,16 @@ static WabtResult get_offsets_from_line(WabtAstLexer* lexer, size_t* out_line_end) { size_t line_start; if (WABT_FAILED(get_line_start_offset(lexer, line, &line_start))) - return WABT_ERROR; + return WabtResult::Error; size_t line_end; if (WABT_FAILED(scan_forward_for_line_offset(lexer, line, line_start, - WABT_LINE_OFFSET_POSITION_END, + WabtLineOffsetPosition::End, line, &line_end))) - return WABT_ERROR; + return WabtResult::Error; *out_line_start = line_start; *out_line_end = line_end; - return WABT_OK; + return WabtResult::Ok; } static void clamp_source_line_offsets_to_location(size_t line_start, @@ -6946,27 +6948,27 @@ WabtResult wabt_ast_lexer_get_source_line(WabtAstLexer* lexer, read_length -= 3; } - if (lexer->source.type == WABT_LEXER_SOURCE_TYPE_BUFFER) { + if (lexer->source.type == WabtAstLexerSourceType::Buffer) { const char* buffer_read_start = static_cast<const char*>(lexer->source.buffer.data) + read_start; memcpy(write_start, buffer_read_start, read_length); } else { - assert(lexer->source.type == WABT_LEXER_SOURCE_TYPE_FILE); + assert(lexer->source.type == WabtAstLexerSourceType::File); FILE* lexer_file = lexer->source.file; long old_offset = ftell(lexer_file); if (old_offset == -1) - return WABT_ERROR; + return WabtResult::Error; if (fseek(lexer_file, read_start, SEEK_SET) == -1) - return WABT_ERROR; + return WabtResult::Error; if (fread(write_start, 1, read_length, lexer_file) < read_length) - return WABT_ERROR; + return WabtResult::Error; if (fseek(lexer_file, old_offset, SEEK_SET) == -1) - return WABT_ERROR; + return WabtResult::Error; } line[line_length] = '\0'; *out_line_length = line_length; *out_column_offset = new_line_start - line_start; - return WABT_OK; + return WabtResult::Ok; } diff --git a/src/prebuilt/ast-parser-gen.cc b/src/prebuilt/ast-parser-gen.cc index 7f627dda..d9467a36 100644 --- a/src/prebuilt/ast-parser-gen.cc +++ b/src/prebuilt/ast-parser-gen.cc @@ -126,11 +126,11 @@ } \ while (0) -#define APPEND_FIELD_TO_LIST(module, field, KIND, kind, loc_, item) \ +#define APPEND_FIELD_TO_LIST(module, field, Kind, kind, loc_, item) \ do { \ field = wabt_append_module_field(module); \ field->loc = loc_; \ - field->type = WABT_MODULE_FIELD_TYPE_##KIND; \ + field->type = WabtModuleFieldType::Kind; \ field->kind = item; \ } while (0) @@ -150,13 +150,13 @@ } \ while (0) -#define APPEND_INLINE_EXPORT(module, KIND, loc_, value, index_) \ +#define APPEND_INLINE_EXPORT(module, Kind, loc_, value, index_) \ do \ if ((value).export_.has_export) { \ WabtModuleField* export_field; \ - APPEND_FIELD_TO_LIST(module, export_field, EXPORT, export_, loc_, \ + APPEND_FIELD_TO_LIST(module, export_field, Export, export_, loc_, \ (value).export_.export_); \ - export_field->export_.kind = WABT_EXTERNAL_KIND_##KIND; \ + export_field->export_.kind = WabtExternalKind::Kind; \ export_field->export_.var.loc = loc_; \ export_field->export_.var.index = index_; \ APPEND_ITEM_TO_VECTOR(module, Export, export, exports, \ @@ -712,15 +712,15 @@ static const yytype_uint16 yyrline[] = 578, 582, 586, 590, 594, 597, 602, 608, 614, 620, 630, 638, 642, 645, 651, 657, 666, 672, 677, 683, 688, 694, 702, 703, 711, 712, 720, 725, 726, 732, - 738, 748, 754, 760, 770, 824, 833, 840, 847, 857, - 860, 864, 870, 881, 887, 907, 914, 926, 933, 953, - 975, 982, 995, 1002, 1008, 1014, 1020, 1028, 1033, 1040, - 1046, 1052, 1058, 1067, 1075, 1080, 1085, 1090, 1097, 1104, - 1108, 1111, 1122, 1126, 1133, 1137, 1140, 1148, 1156, 1173, - 1189, 1199, 1206, 1213, 1219, 1258, 1268, 1290, 1300, 1326, - 1331, 1339, 1347, 1357, 1363, 1369, 1375, 1381, 1387, 1392, - 1398, 1407, 1412, 1413, 1419, 1428, 1429, 1437, 1449, 1450, - 1457, 1521 + 738, 748, 754, 760, 770, 823, 832, 839, 846, 856, + 859, 863, 869, 880, 886, 906, 913, 925, 932, 952, + 974, 981, 994, 1001, 1007, 1013, 1019, 1027, 1032, 1039, + 1045, 1051, 1057, 1066, 1074, 1079, 1084, 1089, 1096, 1103, + 1107, 1110, 1121, 1125, 1132, 1136, 1139, 1147, 1155, 1172, + 1188, 1198, 1205, 1212, 1218, 1254, 1264, 1286, 1296, 1322, + 1327, 1335, 1343, 1353, 1359, 1365, 1371, 1377, 1383, 1388, + 1394, 1403, 1408, 1409, 1415, 1424, 1425, 1433, 1445, 1446, + 1453, 1517 }; #endif @@ -2487,7 +2487,7 @@ yyreduce: #line 438 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.var).loc = (yylsp[0]); - (yyval.var).type = WABT_VAR_TYPE_INDEX; + (yyval.var).type = WabtVarType::Index; (yyval.var).index = (yyvsp[0].u64); } #line 2494 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ @@ -2497,7 +2497,7 @@ yyreduce: #line 443 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.var).loc = (yylsp[0]); - (yyval.var).type = WABT_VAR_TYPE_NAME; + (yyval.var).type = WabtVarType::Name; DUPTEXT((yyval.var).name, (yyvsp[0].text)); } #line 2504 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ @@ -2546,7 +2546,7 @@ yyreduce: #line 471 "src/ast-parser.y" /* yacc.c:1646 */ { if (WABT_FAILED(wabt_parse_int64((yyvsp[0].text).start, (yyvsp[0].text).start + (yyvsp[0].text).length, &(yyval.u64), - WABT_PARSE_SIGNED_AND_UNSIGNED))) { + WabtParseIntType::SignedAndUnsigned))) { wabt_ast_parser_error(&(yylsp[0]), lexer, parser, "invalid offset \"" PRIstringslice "\"", WABT_PRINTF_STRING_SLICE_ARG((yyvsp[0].text))); @@ -2564,11 +2564,11 @@ yyreduce: case 38: #line 482 "src/ast-parser.y" /* yacc.c:1646 */ { - if (WABT_FAILED(wabt_parse_int32((yyvsp[0].text).start, (yyvsp[0].text).start + (yyvsp[0].text).length, &(yyval.u32), - WABT_PARSE_UNSIGNED_ONLY))) { - wabt_ast_parser_error(&(yylsp[0]), lexer, parser, - "invalid alignment \"" PRIstringslice "\"", - WABT_PRINTF_STRING_SLICE_ARG((yyvsp[0].text))); + if (WABT_FAILED(wabt_parse_int32((yyvsp[0].text).start, (yyvsp[0].text).start + (yyvsp[0].text).length, &(yyval.u32), + WabtParseIntType::UnsignedOnly))) { + wabt_ast_parser_error(&(yylsp[0]), lexer, parser, + "invalid alignment \"" PRIstringslice "\"", + WABT_PRINTF_STRING_SLICE_ARG((yyvsp[0].text))); } } #line 2575 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ @@ -2911,7 +2911,7 @@ yyreduce: { (yyval.expr_list) = (yyvsp[0].expr_list); WabtExpr* if_ = (yyvsp[0].expr_list).last; - assert(if_->type == WABT_EXPR_TYPE_IF); + assert(if_->type == WabtExprType::If); if_->if_.true_.label = (yyvsp[-2].text); if_->if_.true_.sig = (yyvsp[-1].types); } @@ -3019,7 +3019,7 @@ yyreduce: #line 726 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.func_fields) = new_func_field(); - (yyval.func_fields)->type = WABT_FUNC_FIELD_TYPE_RESULT_TYPES; + (yyval.func_fields)->type = WabtFuncFieldType::ResultTypes; (yyval.func_fields)->types = (yyvsp[-2].types); (yyval.func_fields)->next = (yyvsp[0].func_fields); } @@ -3030,7 +3030,7 @@ yyreduce: #line 732 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.func_fields) = new_func_field(); - (yyval.func_fields)->type = WABT_FUNC_FIELD_TYPE_PARAM_TYPES; + (yyval.func_fields)->type = WabtFuncFieldType::ParamTypes; (yyval.func_fields)->types = (yyvsp[-2].types); (yyval.func_fields)->next = (yyvsp[0].func_fields); } @@ -3041,7 +3041,7 @@ yyreduce: #line 738 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.func_fields) = new_func_field(); - (yyval.func_fields)->type = WABT_FUNC_FIELD_TYPE_BOUND_PARAM; + (yyval.func_fields)->type = WabtFuncFieldType::BoundParam; (yyval.func_fields)->bound_type.loc = (yylsp[-4]); (yyval.func_fields)->bound_type.name = (yyvsp[-3].text); (yyval.func_fields)->bound_type.type = (yyvsp[-2].type); @@ -3054,7 +3054,7 @@ yyreduce: #line 748 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.func_fields) = new_func_field(); - (yyval.func_fields)->type = WABT_FUNC_FIELD_TYPE_EXPRS; + (yyval.func_fields)->type = WabtFuncFieldType::Exprs; (yyval.func_fields)->first_expr = (yyvsp[0].expr_list).first; (yyval.func_fields)->next = nullptr; } @@ -3065,7 +3065,7 @@ yyreduce: #line 754 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.func_fields) = new_func_field(); - (yyval.func_fields)->type = WABT_FUNC_FIELD_TYPE_LOCAL_TYPES; + (yyval.func_fields)->type = WabtFuncFieldType::LocalTypes; (yyval.func_fields)->types = (yyvsp[-2].types); (yyval.func_fields)->next = (yyvsp[0].func_fields); } @@ -3076,7 +3076,7 @@ yyreduce: #line 760 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.func_fields) = new_func_field(); - (yyval.func_fields)->type = WABT_FUNC_FIELD_TYPE_BOUND_LOCAL; + (yyval.func_fields)->type = WabtFuncFieldType::BoundLocal; (yyval.func_fields)->bound_type.loc = (yylsp[-4]); (yyval.func_fields)->bound_type.name = (yyvsp[-3].text); (yyval.func_fields)->bound_type.type = (yyvsp[-2].type); @@ -3094,26 +3094,25 @@ yyreduce: while (field) { WabtFuncField* next = field->next; switch (field->type) { - case WABT_FUNC_FIELD_TYPE_EXPRS: + case WabtFuncFieldType::Exprs: (yyval.func)->first_expr = field->first_expr; break; - case WABT_FUNC_FIELD_TYPE_PARAM_TYPES: - case WABT_FUNC_FIELD_TYPE_LOCAL_TYPES: { - WabtTypeVector* types = - field->type == WABT_FUNC_FIELD_TYPE_PARAM_TYPES - ? &(yyval.func)->decl.sig.param_types - : &(yyval.func)->local_types; + case WabtFuncFieldType::ParamTypes: + case WabtFuncFieldType::LocalTypes: { + WabtTypeVector* types = field->type == WabtFuncFieldType::ParamTypes + ? &(yyval.func)->decl.sig.param_types + : &(yyval.func)->local_types; wabt_extend_types(types, &field->types); wabt_destroy_type_vector(&field->types); break; } - case WABT_FUNC_FIELD_TYPE_BOUND_PARAM: - case WABT_FUNC_FIELD_TYPE_BOUND_LOCAL: { + case WabtFuncFieldType::BoundParam: + case WabtFuncFieldType::BoundLocal: { WabtTypeVector* types; WabtBindingHash* bindings; - if (field->type == WABT_FUNC_FIELD_TYPE_BOUND_PARAM) { + if (field->type == WabtFuncFieldType::BoundParam) { types = &(yyval.func)->decl.sig.param_types; bindings = &(yyval.func)->param_bindings; } else { @@ -3129,7 +3128,7 @@ yyreduce: break; } - case WABT_FUNC_FIELD_TYPE_RESULT_TYPES: + case WabtFuncFieldType::ResultTypes: (yyval.func)->decl.sig.result_types = field->types; break; } @@ -3139,11 +3138,11 @@ yyreduce: field = next; } } -#line 3143 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3142 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 95: -#line 824 "src/ast-parser.y" /* yacc.c:1646 */ +#line 823 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.exported_func)); (yyval.exported_func).func = (yyvsp[-1].func); @@ -3152,11 +3151,11 @@ yyreduce: (yyval.exported_func).func->name = (yyvsp[-4].text); (yyval.exported_func).export_ = (yyvsp[-3].optional_export); } -#line 3156 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3155 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 96: -#line 833 "src/ast-parser.y" /* yacc.c:1646 */ +#line 832 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.exported_func)); (yyval.exported_func).func = (yyvsp[-1].func); @@ -3164,79 +3163,79 @@ yyreduce: (yyval.exported_func).func->decl.type_var = (yyvsp[-2].var); (yyval.exported_func).func->name = (yyvsp[-3].text); } -#line 3168 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3167 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 97: -#line 840 "src/ast-parser.y" /* yacc.c:1646 */ +#line 839 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.exported_func)); (yyval.exported_func).func = (yyvsp[-1].func); (yyval.exported_func).func->name = (yyvsp[-3].text); (yyval.exported_func).export_ = (yyvsp[-2].optional_export); } -#line 3179 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3178 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 98: -#line 847 "src/ast-parser.y" /* yacc.c:1646 */ +#line 846 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.exported_func)); (yyval.exported_func).func = (yyvsp[-1].func); (yyval.exported_func).func->name = (yyvsp[-2].text); } -#line 3189 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3188 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 99: -#line 857 "src/ast-parser.y" /* yacc.c:1646 */ +#line 856 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.expr_list) = (yyvsp[-1].expr_list); } -#line 3197 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3196 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 101: -#line 864 "src/ast-parser.y" /* yacc.c:1646 */ +#line 863 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.elem_segment)); (yyval.elem_segment).table_var = (yyvsp[-3].var); (yyval.elem_segment).offset = (yyvsp[-2].expr_list).first; (yyval.elem_segment).vars = (yyvsp[-1].vars); } -#line 3208 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3207 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 102: -#line 870 "src/ast-parser.y" /* yacc.c:1646 */ +#line 869 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.elem_segment)); (yyval.elem_segment).table_var.loc = (yylsp[-3]); - (yyval.elem_segment).table_var.type = WABT_VAR_TYPE_INDEX; + (yyval.elem_segment).table_var.type = WabtVarType::Index; (yyval.elem_segment).table_var.index = 0; (yyval.elem_segment).offset = (yyvsp[-2].expr_list).first; (yyval.elem_segment).vars = (yyvsp[-1].vars); } -#line 3221 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3220 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 103: -#line 881 "src/ast-parser.y" /* yacc.c:1646 */ +#line 880 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.exported_table).table = (yyvsp[-1].table); (yyval.exported_table).table.name = (yyvsp[-3].text); (yyval.exported_table).has_elem_segment = false; (yyval.exported_table).export_ = (yyvsp[-2].optional_export); } -#line 3232 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3231 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 104: -#line 888 "src/ast-parser.y" /* yacc.c:1646 */ +#line 887 "src/ast-parser.y" /* yacc.c:1646 */ { WabtExpr* expr = wabt_new_const_expr(); expr->loc = (yylsp[-8]); - expr->const_.type = WABT_TYPE_I32; + expr->const_.type = WabtType::I32; expr->const_.u32 = 0; WABT_ZERO_MEMORY((yyval.exported_table)); @@ -3249,11 +3248,11 @@ yyreduce: (yyval.exported_table).elem_segment.vars = (yyvsp[-2].vars); (yyval.exported_table).export_ = (yyvsp[-6].optional_export); } -#line 3253 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3252 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 105: -#line 907 "src/ast-parser.y" /* yacc.c:1646 */ +#line 906 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.data_segment)); (yyval.data_segment).memory_var = (yyvsp[-3].var); @@ -3261,25 +3260,25 @@ yyreduce: dup_text_list(&(yyvsp[-1].text_list), &(yyval.data_segment).data, &(yyval.data_segment).size); wabt_destroy_text_list(&(yyvsp[-1].text_list)); } -#line 3265 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3264 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 106: -#line 914 "src/ast-parser.y" /* yacc.c:1646 */ +#line 913 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.data_segment)); (yyval.data_segment).memory_var.loc = (yylsp[-3]); - (yyval.data_segment).memory_var.type = WABT_VAR_TYPE_INDEX; + (yyval.data_segment).memory_var.type = WabtVarType::Index; (yyval.data_segment).memory_var.index = 0; (yyval.data_segment).offset = (yyvsp[-2].expr_list).first; dup_text_list(&(yyvsp[-1].text_list), &(yyval.data_segment).data, &(yyval.data_segment).size); wabt_destroy_text_list(&(yyvsp[-1].text_list)); } -#line 3279 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3278 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 107: -#line 926 "src/ast-parser.y" /* yacc.c:1646 */ +#line 925 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.exported_memory)); (yyval.exported_memory).memory = (yyvsp[-1].memory); @@ -3287,15 +3286,15 @@ yyreduce: (yyval.exported_memory).has_data_segment = false; (yyval.exported_memory).export_ = (yyvsp[-2].optional_export); } -#line 3291 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3290 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 108: -#line 933 "src/ast-parser.y" /* yacc.c:1646 */ +#line 932 "src/ast-parser.y" /* yacc.c:1646 */ { WabtExpr* expr = wabt_new_const_expr(); expr->loc = (yylsp[-7]); - expr->const_.type = WABT_TYPE_I32; + expr->const_.type = WabtType::I32; expr->const_.u32 = 0; WABT_ZERO_MEMORY((yyval.exported_memory)); @@ -3311,15 +3310,15 @@ yyreduce: (yyval.exported_memory).memory.page_limits.has_max = true; (yyval.exported_memory).export_ = (yyvsp[-5].optional_export); } -#line 3315 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3314 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 109: -#line 953 "src/ast-parser.y" /* yacc.c:1646 */ +#line 952 "src/ast-parser.y" /* yacc.c:1646 */ { WabtExpr* expr = wabt_new_const_expr(); expr->loc = (yylsp[-6]); - expr->const_.type = WABT_TYPE_I32; + expr->const_.type = WabtType::I32; expr->const_.u32 = 0; WABT_ZERO_MEMORY((yyval.exported_memory)); @@ -3335,11 +3334,11 @@ yyreduce: (yyval.exported_memory).memory.page_limits.has_max = true; (yyval.exported_memory).export_.has_export = false; } -#line 3339 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3338 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 110: -#line 975 "src/ast-parser.y" /* yacc.c:1646 */ +#line 974 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.exported_global)); (yyval.exported_global).global = (yyvsp[-2].global); @@ -3347,11 +3346,11 @@ yyreduce: (yyval.exported_global).global.init_expr = (yyvsp[-1].expr_list).first; (yyval.exported_global).export_ = (yyvsp[-3].optional_export); } -#line 3351 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3350 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 111: -#line 982 "src/ast-parser.y" /* yacc.c:1646 */ +#line 981 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.exported_global)); (yyval.exported_global).global = (yyvsp[-2].global); @@ -3359,420 +3358,417 @@ yyreduce: (yyval.exported_global).global.init_expr = (yyvsp[-1].expr_list).first; (yyval.exported_global).export_.has_export = false; } -#line 3363 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3362 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 112: -#line 995 "src/ast-parser.y" /* yacc.c:1646 */ +#line 994 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.import) = new_import(); - (yyval.import)->kind = WABT_EXTERNAL_KIND_FUNC; + (yyval.import)->kind = WabtExternalKind::Func; (yyval.import)->func.name = (yyvsp[-2].text); (yyval.import)->func.decl.flags = WABT_FUNC_DECLARATION_FLAG_HAS_FUNC_TYPE; (yyval.import)->func.decl.type_var = (yyvsp[-1].var); } -#line 3375 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3374 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 113: -#line 1002 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1001 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.import) = new_import(); - (yyval.import)->kind = WABT_EXTERNAL_KIND_FUNC; + (yyval.import)->kind = WabtExternalKind::Func; (yyval.import)->func.name = (yyvsp[-2].text); (yyval.import)->func.decl.sig = (yyvsp[-1].func_sig); } -#line 3386 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3385 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 114: -#line 1008 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1007 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.import) = new_import(); - (yyval.import)->kind = WABT_EXTERNAL_KIND_TABLE; + (yyval.import)->kind = WabtExternalKind::Table; (yyval.import)->table = (yyvsp[-1].table); (yyval.import)->table.name = (yyvsp[-2].text); } -#line 3397 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3396 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 115: -#line 1014 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1013 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.import) = new_import(); - (yyval.import)->kind = WABT_EXTERNAL_KIND_MEMORY; + (yyval.import)->kind = WabtExternalKind::Memory; (yyval.import)->memory = (yyvsp[-1].memory); (yyval.import)->memory.name = (yyvsp[-2].text); } -#line 3408 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3407 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 116: -#line 1020 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1019 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.import) = new_import(); - (yyval.import)->kind = WABT_EXTERNAL_KIND_GLOBAL; + (yyval.import)->kind = WabtExternalKind::Global; (yyval.import)->global = (yyvsp[-1].global); (yyval.import)->global.name = (yyvsp[-2].text); } -#line 3419 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3418 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 117: -#line 1028 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1027 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.import) = (yyvsp[-1].import); (yyval.import)->module_name = (yyvsp[-3].text); (yyval.import)->field_name = (yyvsp[-2].text); } -#line 3429 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3428 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 118: -#line 1033 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1032 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.import) = (yyvsp[-2].import); - (yyval.import)->kind = WABT_EXTERNAL_KIND_FUNC; + (yyval.import)->kind = WabtExternalKind::Func; (yyval.import)->func.name = (yyvsp[-3].text); (yyval.import)->func.decl.flags = WABT_FUNC_DECLARATION_FLAG_HAS_FUNC_TYPE; (yyval.import)->func.decl.type_var = (yyvsp[-1].var); } -#line 3441 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3440 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 119: -#line 1040 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1039 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.import) = (yyvsp[-2].import); - (yyval.import)->kind = WABT_EXTERNAL_KIND_FUNC; + (yyval.import)->kind = WabtExternalKind::Func; (yyval.import)->func.name = (yyvsp[-3].text); (yyval.import)->func.decl.sig = (yyvsp[-1].func_sig); } -#line 3452 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3451 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 120: -#line 1046 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1045 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.import) = (yyvsp[-2].import); - (yyval.import)->kind = WABT_EXTERNAL_KIND_TABLE; + (yyval.import)->kind = WabtExternalKind::Table; (yyval.import)->table = (yyvsp[-1].table); (yyval.import)->table.name = (yyvsp[-3].text); } -#line 3463 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3462 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 121: -#line 1052 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1051 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.import) = (yyvsp[-2].import); - (yyval.import)->kind = WABT_EXTERNAL_KIND_MEMORY; + (yyval.import)->kind = WabtExternalKind::Memory; (yyval.import)->memory = (yyvsp[-1].memory); (yyval.import)->memory.name = (yyvsp[-3].text); } -#line 3474 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3473 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 122: -#line 1058 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1057 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.import) = (yyvsp[-2].import); - (yyval.import)->kind = WABT_EXTERNAL_KIND_GLOBAL; + (yyval.import)->kind = WabtExternalKind::Global; (yyval.import)->global = (yyvsp[-1].global); (yyval.import)->global.name = (yyvsp[-3].text); } -#line 3485 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3484 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 123: -#line 1067 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1066 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.import) = new_import(); (yyval.import)->module_name = (yyvsp[-2].text); (yyval.import)->field_name = (yyvsp[-1].text); } -#line 3495 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3494 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 124: -#line 1075 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1074 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.export_)); - (yyval.export_).kind = WABT_EXTERNAL_KIND_FUNC; + (yyval.export_).kind = WabtExternalKind::Func; (yyval.export_).var = (yyvsp[-1].var); } -#line 3505 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3504 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 125: -#line 1080 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1079 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.export_)); - (yyval.export_).kind = WABT_EXTERNAL_KIND_TABLE; + (yyval.export_).kind = WabtExternalKind::Table; (yyval.export_).var = (yyvsp[-1].var); } -#line 3515 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3514 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 126: -#line 1085 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1084 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.export_)); - (yyval.export_).kind = WABT_EXTERNAL_KIND_MEMORY; + (yyval.export_).kind = WabtExternalKind::Memory; (yyval.export_).var = (yyvsp[-1].var); } -#line 3525 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3524 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 127: -#line 1090 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1089 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.export_)); - (yyval.export_).kind = WABT_EXTERNAL_KIND_GLOBAL; + (yyval.export_).kind = WabtExternalKind::Global; (yyval.export_).var = (yyvsp[-1].var); } -#line 3535 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3534 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 128: -#line 1097 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1096 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.export_) = (yyvsp[-1].export_); (yyval.export_).name = (yyvsp[-2].text); } -#line 3544 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3543 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 129: -#line 1104 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1103 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.optional_export)); (yyval.optional_export).has_export = false; } -#line 3553 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3552 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 131: -#line 1111 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1110 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.optional_export)); (yyval.optional_export).has_export = true; (yyval.optional_export).export_.name = (yyvsp[-1].text); } -#line 3563 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3562 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 132: -#line 1122 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1121 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.func_type)); (yyval.func_type).sig = (yyvsp[-1].func_sig); } -#line 3572 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3571 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 133: -#line 1126 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1125 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.func_type).name = (yyvsp[-2].text); (yyval.func_type).sig = (yyvsp[-1].func_sig); } -#line 3581 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3580 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 134: -#line 1133 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1132 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.var) = (yyvsp[-1].var); } -#line 3587 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3586 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 135: -#line 1137 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1136 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.module) = new_module(); } -#line 3595 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3594 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 136: -#line 1140 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1139 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.module) = (yyvsp[-1].module); WabtModuleField* field; - APPEND_FIELD_TO_LIST((yyval.module), field, FUNC_TYPE, func_type, (yylsp[0]), (yyvsp[0].func_type)); + APPEND_FIELD_TO_LIST((yyval.module), field, FuncType, func_type, (yylsp[0]), (yyvsp[0].func_type)); APPEND_ITEM_TO_VECTOR((yyval.module), FuncType, func_type, func_types, &field->func_type); INSERT_BINDING((yyval.module), func_type, func_types, (yylsp[0]), (yyvsp[0].func_type).name); } -#line 3608 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3607 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 137: -#line 1148 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1147 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.module) = (yyvsp[-1].module); WabtModuleField* field; - APPEND_FIELD_TO_LIST((yyval.module), field, GLOBAL, global, (yylsp[0]), (yyvsp[0].exported_global).global); + APPEND_FIELD_TO_LIST((yyval.module), field, Global, global, (yylsp[0]), (yyvsp[0].exported_global).global); APPEND_ITEM_TO_VECTOR((yyval.module), Global, global, globals, &field->global); INSERT_BINDING((yyval.module), global, globals, (yylsp[0]), (yyvsp[0].exported_global).global.name); - APPEND_INLINE_EXPORT((yyval.module), GLOBAL, (yylsp[0]), (yyvsp[0].exported_global), (yyval.module)->globals.size - 1); + APPEND_INLINE_EXPORT((yyval.module), Global, (yylsp[0]), (yyvsp[0].exported_global), (yyval.module)->globals.size - 1); } -#line 3621 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3620 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 138: -#line 1156 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1155 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.module) = (yyvsp[-1].module); WabtModuleField* field; - APPEND_FIELD_TO_LIST((yyval.module), field, TABLE, table, (yylsp[0]), (yyvsp[0].exported_table).table); + APPEND_FIELD_TO_LIST((yyval.module), field, Table, table, (yylsp[0]), (yyvsp[0].exported_table).table); APPEND_ITEM_TO_VECTOR((yyval.module), Table, table, tables, &field->table); INSERT_BINDING((yyval.module), table, tables, (yylsp[0]), (yyvsp[0].exported_table).table.name); - APPEND_INLINE_EXPORT((yyval.module), TABLE, (yylsp[0]), (yyvsp[0].exported_table), (yyval.module)->tables.size - 1); + APPEND_INLINE_EXPORT((yyval.module), Table, (yylsp[0]), (yyvsp[0].exported_table), (yyval.module)->tables.size - 1); if ((yyvsp[0].exported_table).has_elem_segment) { WabtModuleField* elem_segment_field; - APPEND_FIELD_TO_LIST((yyval.module), elem_segment_field, ELEM_SEGMENT, elem_segment, + APPEND_FIELD_TO_LIST((yyval.module), elem_segment_field, ElemSegment, elem_segment, (yylsp[0]), (yyvsp[0].exported_table).elem_segment); APPEND_ITEM_TO_VECTOR((yyval.module), ElemSegment, elem_segment, elem_segments, &elem_segment_field->elem_segment); } } -#line 3643 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3642 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 139: -#line 1173 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1172 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.module) = (yyvsp[-1].module); WabtModuleField* field; - APPEND_FIELD_TO_LIST((yyval.module), field, MEMORY, memory, (yylsp[0]), (yyvsp[0].exported_memory).memory); + APPEND_FIELD_TO_LIST((yyval.module), field, Memory, memory, (yylsp[0]), (yyvsp[0].exported_memory).memory); APPEND_ITEM_TO_VECTOR((yyval.module), Memory, memory, memories, &field->memory); INSERT_BINDING((yyval.module), memory, memories, (yylsp[0]), (yyvsp[0].exported_memory).memory.name); - APPEND_INLINE_EXPORT((yyval.module), MEMORY, (yylsp[0]), (yyvsp[0].exported_memory), (yyval.module)->memories.size - 1); + APPEND_INLINE_EXPORT((yyval.module), Memory, (yylsp[0]), (yyvsp[0].exported_memory), (yyval.module)->memories.size - 1); if ((yyvsp[0].exported_memory).has_data_segment) { WabtModuleField* data_segment_field; - APPEND_FIELD_TO_LIST((yyval.module), data_segment_field, DATA_SEGMENT, data_segment, + APPEND_FIELD_TO_LIST((yyval.module), data_segment_field, DataSegment, data_segment, (yylsp[0]), (yyvsp[0].exported_memory).data_segment); APPEND_ITEM_TO_VECTOR((yyval.module), DataSegment, data_segment, data_segments, &data_segment_field->data_segment); } } -#line 3664 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3663 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 140: -#line 1189 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1188 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.module) = (yyvsp[-1].module); WabtModuleField* field; - APPEND_FIELD_TO_LIST((yyval.module), field, FUNC, func, (yylsp[0]), *(yyvsp[0].exported_func).func); + APPEND_FIELD_TO_LIST((yyval.module), field, Func, func, (yylsp[0]), *(yyvsp[0].exported_func).func); append_implicit_func_declaration(&(yylsp[0]), (yyval.module), &field->func.decl); APPEND_ITEM_TO_VECTOR((yyval.module), Func, func, funcs, &field->func); INSERT_BINDING((yyval.module), func, funcs, (yylsp[0]), (yyvsp[0].exported_func).func->name); - APPEND_INLINE_EXPORT((yyval.module), FUNC, (yylsp[0]), (yyvsp[0].exported_func), (yyval.module)->funcs.size - 1); + APPEND_INLINE_EXPORT((yyval.module), Func, (yylsp[0]), (yyvsp[0].exported_func), (yyval.module)->funcs.size - 1); wabt_free((yyvsp[0].exported_func).func); } -#line 3679 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3678 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 141: -#line 1199 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1198 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.module) = (yyvsp[-1].module); WabtModuleField* field; - APPEND_FIELD_TO_LIST((yyval.module), field, ELEM_SEGMENT, elem_segment, (yylsp[0]), (yyvsp[0].elem_segment)); + APPEND_FIELD_TO_LIST((yyval.module), field, ElemSegment, elem_segment, (yylsp[0]), (yyvsp[0].elem_segment)); APPEND_ITEM_TO_VECTOR((yyval.module), ElemSegment, elem_segment, elem_segments, &field->elem_segment); } -#line 3691 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3690 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 142: -#line 1206 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1205 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.module) = (yyvsp[-1].module); WabtModuleField* field; - APPEND_FIELD_TO_LIST((yyval.module), field, DATA_SEGMENT, data_segment, (yylsp[0]), (yyvsp[0].data_segment)); + APPEND_FIELD_TO_LIST((yyval.module), field, DataSegment, data_segment, (yylsp[0]), (yyvsp[0].data_segment)); APPEND_ITEM_TO_VECTOR((yyval.module), DataSegment, data_segment, data_segments, &field->data_segment); } -#line 3703 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3702 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 143: -#line 1213 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1212 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.module) = (yyvsp[-1].module); WabtModuleField* field; - APPEND_FIELD_TO_LIST((yyval.module), field, START, start, (yylsp[0]), (yyvsp[0].var)); + APPEND_FIELD_TO_LIST((yyval.module), field, Start, start, (yylsp[0]), (yyvsp[0].var)); (yyval.module)->start = &field->start; } -#line 3714 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3713 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 144: -#line 1219 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1218 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.module) = (yyvsp[-1].module); WabtModuleField* field; - APPEND_FIELD_TO_LIST((yyval.module), field, IMPORT, import, (yylsp[0]), *(yyvsp[0].import)); + APPEND_FIELD_TO_LIST((yyval.module), field, Import, import, (yylsp[0]), *(yyvsp[0].import)); CHECK_IMPORT_ORDERING((yyval.module), func, funcs, (yylsp[0])); CHECK_IMPORT_ORDERING((yyval.module), table, tables, (yylsp[0])); CHECK_IMPORT_ORDERING((yyval.module), memory, memories, (yylsp[0])); CHECK_IMPORT_ORDERING((yyval.module), global, globals, (yylsp[0])); switch ((yyvsp[0].import)->kind) { - case WABT_EXTERNAL_KIND_FUNC: + case WabtExternalKind::Func: append_implicit_func_declaration(&(yylsp[0]), (yyval.module), &field->import.func.decl); APPEND_ITEM_TO_VECTOR((yyval.module), Func, func, funcs, &field->import.func); INSERT_BINDING((yyval.module), func, funcs, (yylsp[0]), field->import.func.name); (yyval.module)->num_func_imports++; break; - case WABT_EXTERNAL_KIND_TABLE: + case WabtExternalKind::Table: APPEND_ITEM_TO_VECTOR((yyval.module), Table, table, tables, &field->import.table); INSERT_BINDING((yyval.module), table, tables, (yylsp[0]), field->import.table.name); (yyval.module)->num_table_imports++; break; - case WABT_EXTERNAL_KIND_MEMORY: + case WabtExternalKind::Memory: APPEND_ITEM_TO_VECTOR((yyval.module), Memory, memory, memories, &field->import.memory); INSERT_BINDING((yyval.module), memory, memories, (yylsp[0]), field->import.memory.name); (yyval.module)->num_memory_imports++; break; - case WABT_EXTERNAL_KIND_GLOBAL: + case WabtExternalKind::Global: APPEND_ITEM_TO_VECTOR((yyval.module), Global, global, globals, &field->import.global); INSERT_BINDING((yyval.module), global, globals, (yylsp[0]), field->import.global.name); (yyval.module)->num_global_imports++; break; - case WABT_NUM_EXTERNAL_KINDS: - assert(0); - break; } wabt_free((yyvsp[0].import)); APPEND_ITEM_TO_VECTOR((yyval.module), Import, import, imports, &field->import); } -#line 3758 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3754 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 145: -#line 1258 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1254 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.module) = (yyvsp[-1].module); WabtModuleField* field = wabt_append_module_field((yyval.module)); - APPEND_FIELD_TO_LIST((yyval.module), field, EXPORT, export_, (yylsp[0]), (yyvsp[0].export_)); + APPEND_FIELD_TO_LIST((yyval.module), field, Export, export_, (yylsp[0]), (yyvsp[0].export_)); APPEND_ITEM_TO_VECTOR((yyval.module), Export, export, exports, &field->export_); INSERT_BINDING((yyval.module), export, exports, (yylsp[0]), (yyvsp[0].export_).name); } -#line 3770 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3766 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 146: -#line 1268 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1264 "src/ast-parser.y" /* yacc.c:1646 */ { - (yyval.raw_module).type = WABT_RAW_MODULE_TYPE_TEXT; + (yyval.raw_module).type = WabtRawModuleType::Text; (yyval.raw_module).text = (yyvsp[-1].module); (yyval.raw_module).text->name = (yyvsp[-2].text); (yyval.raw_module).text->loc = (yylsp[-3]); @@ -3793,28 +3789,28 @@ yyreduce: } } } -#line 3797 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3793 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 147: -#line 1290 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1286 "src/ast-parser.y" /* yacc.c:1646 */ { - (yyval.raw_module).type = WABT_RAW_MODULE_TYPE_BINARY; + (yyval.raw_module).type = WabtRawModuleType::Binary; (yyval.raw_module).binary.name = (yyvsp[-2].text); (yyval.raw_module).binary.loc = (yylsp[-3]); dup_text_list(&(yyvsp[-1].text_list), &(yyval.raw_module).binary.data, &(yyval.raw_module).binary.size); wabt_destroy_text_list(&(yyvsp[-1].text_list)); } -#line 3809 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3805 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 148: -#line 1300 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1296 "src/ast-parser.y" /* yacc.c:1646 */ { - if ((yyvsp[0].raw_module).type == WABT_RAW_MODULE_TYPE_TEXT) { + if ((yyvsp[0].raw_module).type == WabtRawModuleType::Text) { (yyval.module) = (yyvsp[0].raw_module).text; } else { - assert((yyvsp[0].raw_module).type == WABT_RAW_MODULE_TYPE_BINARY); + assert((yyvsp[0].raw_module).type == WabtRawModuleType::Binary); (yyval.module) = new_module(); WabtReadBinaryOptions options = WABT_READ_BINARY_OPTIONS_DEFAULT; BinaryErrorCallbackData user_data; @@ -3831,192 +3827,192 @@ yyreduce: (yyval.module)->loc = (yyvsp[0].raw_module).binary.loc; } } -#line 3835 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3831 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 149: -#line 1326 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1322 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.var)); - (yyval.var).type = WABT_VAR_TYPE_INDEX; + (yyval.var).type = WabtVarType::Index; (yyval.var).index = INVALID_VAR_INDEX; } -#line 3845 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3841 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 150: -#line 1331 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1327 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.var)); - (yyval.var).type = WABT_VAR_TYPE_NAME; + (yyval.var).type = WabtVarType::Name; DUPTEXT((yyval.var).name, (yyvsp[0].text)); } -#line 3855 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3851 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 151: -#line 1339 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1335 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.action)); (yyval.action).loc = (yylsp[-4]); (yyval.action).module_var = (yyvsp[-3].var); - (yyval.action).type = WABT_ACTION_TYPE_INVOKE; + (yyval.action).type = WabtActionType::Invoke; (yyval.action).invoke.name = (yyvsp[-2].text); (yyval.action).invoke.args = (yyvsp[-1].consts); } -#line 3868 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3864 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 152: -#line 1347 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1343 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.action)); (yyval.action).loc = (yylsp[-3]); (yyval.action).module_var = (yyvsp[-2].var); - (yyval.action).type = WABT_ACTION_TYPE_GET; + (yyval.action).type = WabtActionType::Get; (yyval.action).invoke.name = (yyvsp[-1].text); } -#line 3880 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3876 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 153: -#line 1357 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1353 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.command) = new_command(); - (yyval.command)->type = WABT_COMMAND_TYPE_ASSERT_MALFORMED; + (yyval.command)->type = WabtCommandType::AssertMalformed; (yyval.command)->assert_malformed.module = (yyvsp[-2].raw_module); (yyval.command)->assert_malformed.text = (yyvsp[-1].text); } -#line 3891 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3887 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 154: -#line 1363 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1359 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.command) = new_command(); - (yyval.command)->type = WABT_COMMAND_TYPE_ASSERT_INVALID; + (yyval.command)->type = WabtCommandType::AssertInvalid; (yyval.command)->assert_invalid.module = (yyvsp[-2].raw_module); (yyval.command)->assert_invalid.text = (yyvsp[-1].text); } -#line 3902 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3898 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 155: -#line 1369 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1365 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.command) = new_command(); - (yyval.command)->type = WABT_COMMAND_TYPE_ASSERT_UNLINKABLE; + (yyval.command)->type = WabtCommandType::AssertUnlinkable; (yyval.command)->assert_unlinkable.module = (yyvsp[-2].raw_module); (yyval.command)->assert_unlinkable.text = (yyvsp[-1].text); } -#line 3913 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3909 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 156: -#line 1375 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1371 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.command) = new_command(); - (yyval.command)->type = WABT_COMMAND_TYPE_ASSERT_UNINSTANTIABLE; + (yyval.command)->type = WabtCommandType::AssertUninstantiable; (yyval.command)->assert_uninstantiable.module = (yyvsp[-2].raw_module); (yyval.command)->assert_uninstantiable.text = (yyvsp[-1].text); } -#line 3924 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3920 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 157: -#line 1381 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1377 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.command) = new_command(); - (yyval.command)->type = WABT_COMMAND_TYPE_ASSERT_RETURN; + (yyval.command)->type = WabtCommandType::AssertReturn; (yyval.command)->assert_return.action = (yyvsp[-2].action); (yyval.command)->assert_return.expected = (yyvsp[-1].consts); } -#line 3935 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3931 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 158: -#line 1387 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1383 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.command) = new_command(); - (yyval.command)->type = WABT_COMMAND_TYPE_ASSERT_RETURN_NAN; + (yyval.command)->type = WabtCommandType::AssertReturnNan; (yyval.command)->assert_return_nan.action = (yyvsp[-1].action); } -#line 3945 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3941 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 159: -#line 1392 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1388 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.command) = new_command(); - (yyval.command)->type = WABT_COMMAND_TYPE_ASSERT_TRAP; + (yyval.command)->type = WabtCommandType::AssertTrap; (yyval.command)->assert_trap.action = (yyvsp[-2].action); (yyval.command)->assert_trap.text = (yyvsp[-1].text); } -#line 3956 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3952 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 160: -#line 1398 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1394 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.command) = new_command(); - (yyval.command)->type = WABT_COMMAND_TYPE_ASSERT_EXHAUSTION; + (yyval.command)->type = WabtCommandType::AssertExhaustion; (yyval.command)->assert_trap.action = (yyvsp[-2].action); (yyval.command)->assert_trap.text = (yyvsp[-1].text); } -#line 3967 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3963 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 161: -#line 1407 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1403 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.command) = new_command(); - (yyval.command)->type = WABT_COMMAND_TYPE_ACTION; + (yyval.command)->type = WabtCommandType::Action; (yyval.command)->action = (yyvsp[0].action); } -#line 3977 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3973 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 163: -#line 1413 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1409 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.command) = new_command(); - (yyval.command)->type = WABT_COMMAND_TYPE_MODULE; + (yyval.command)->type = WabtCommandType::Module; (yyval.command)->module = *(yyvsp[0].module); wabt_free((yyvsp[0].module)); } -#line 3988 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3984 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 164: -#line 1419 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1415 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.command) = new_command(); - (yyval.command)->type = WABT_COMMAND_TYPE_REGISTER; + (yyval.command)->type = WabtCommandType::Register; (yyval.command)->register_.module_name = (yyvsp[-2].text); (yyval.command)->register_.var = (yyvsp[-1].var); (yyval.command)->register_.var.loc = (yylsp[-1]); } -#line 4000 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 3996 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 165: -#line 1428 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1424 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.commands)); } -#line 4006 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 4002 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 166: -#line 1429 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1425 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.commands) = (yyvsp[-1].commands); wabt_append_command_value(&(yyval.commands), (yyvsp[0].command)); wabt_free((yyvsp[0].command)); } -#line 4016 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 4012 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 167: -#line 1437 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1433 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.const_).loc = (yylsp[-2]); if (WABT_FAILED(parse_const((yyvsp[-2].type), (yyvsp[-1].literal).type, (yyvsp[-1].literal).text.start, @@ -4027,26 +4023,26 @@ yyreduce: } wabt_free(const_cast<char*>((yyvsp[-1].literal).text.start)); } -#line 4031 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 4027 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 168: -#line 1449 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1445 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.consts)); } -#line 4037 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 4033 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 169: -#line 1450 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1446 "src/ast-parser.y" /* yacc.c:1646 */ { (yyval.consts) = (yyvsp[-1].consts); wabt_append_const_value(&(yyval.consts), &(yyvsp[0].const_)); } -#line 4046 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 4042 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; case 170: -#line 1457 "src/ast-parser.y" /* yacc.c:1646 */ +#line 1453 "src/ast-parser.y" /* yacc.c:1646 */ { WABT_ZERO_MEMORY((yyval.script)); (yyval.script).commands = (yyvsp[0].commands); @@ -4057,7 +4053,7 @@ yyreduce: WabtCommand* command = &(yyval.script).commands.data[i]; WabtVar* module_var = nullptr; switch (command->type) { - case WABT_COMMAND_TYPE_MODULE: { + case WabtCommandType::Module: { last_module_index = i; /* Wire up module name bindings. */ @@ -4073,27 +4069,27 @@ yyreduce: break; } - case WABT_COMMAND_TYPE_ASSERT_RETURN: + case WabtCommandType::AssertReturn: module_var = &command->assert_return.action.module_var; goto has_module_var; - case WABT_COMMAND_TYPE_ASSERT_RETURN_NAN: + case WabtCommandType::AssertReturnNan: module_var = &command->assert_return_nan.action.module_var; goto has_module_var; - case WABT_COMMAND_TYPE_ASSERT_TRAP: - case WABT_COMMAND_TYPE_ASSERT_EXHAUSTION: + case WabtCommandType::AssertTrap: + case WabtCommandType::AssertExhaustion: module_var = &command->assert_trap.action.module_var; goto has_module_var; - case WABT_COMMAND_TYPE_ACTION: + case WabtCommandType::Action: module_var = &command->action.module_var; goto has_module_var; - case WABT_COMMAND_TYPE_REGISTER: + case WabtCommandType::Register: module_var = &command->register_.var; goto has_module_var; has_module_var: { /* Resolve actions with an invalid index to use the preceding * module. */ - if (module_var->type == WABT_VAR_TYPE_INDEX && + if (module_var->type == WabtVarType::Index && module_var->index == INVALID_VAR_INDEX) { module_var->index = last_module_index; } @@ -4106,11 +4102,11 @@ yyreduce: } parser->script = (yyval.script); } -#line 4110 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 4106 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ break; -#line 4114 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ +#line 4110 "src/prebuilt/ast-parser-gen.cc" /* yacc.c:1646 */ default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -4345,7 +4341,7 @@ yyreturn: #endif return yyresult; } -#line 1524 "src/ast-parser.y" /* yacc.c:1906 */ +#line 1520 "src/ast-parser.y" /* yacc.c:1906 */ static void append_expr_list(WabtExprList* expr_list, WabtExprList* expr) { @@ -4393,21 +4389,21 @@ static WabtResult parse_const(WabtType type, WabtConst* out) { out->type = type; switch (type) { - case WABT_TYPE_I32: + case WabtType::I32: return wabt_parse_int32(s, end, &out->u32, - WABT_PARSE_SIGNED_AND_UNSIGNED); - case WABT_TYPE_I64: + WabtParseIntType::SignedAndUnsigned); + case WabtType::I64: return wabt_parse_int64(s, end, &out->u64, - WABT_PARSE_SIGNED_AND_UNSIGNED); - case WABT_TYPE_F32: + WabtParseIntType::SignedAndUnsigned); + case WabtType::F32: return wabt_parse_float(literal_type, s, end, &out->f32_bits); - case WABT_TYPE_F64: + case WabtType::F64: return wabt_parse_double(literal_type, s, end, &out->f64_bits); default: assert(0); break; } - return WABT_ERROR; + return WabtResult::Error; } static size_t copy_string_contents(WabtStringSlice* text, char* dest) { @@ -4518,7 +4514,7 @@ WabtResult wabt_parse_ast(WabtAstLexer* lexer, wabt_free(parser.yyvsa); wabt_free(parser.yylsa); *out_script = parser.script; - return result == 0 && parser.errors == 0 ? WABT_OK : WABT_ERROR; + return result == 0 && parser.errors == 0 ? WabtResult::Ok : WabtResult::Error; } static void on_read_binary_error(uint32_t offset, const char* error, diff --git a/src/resolve-names.cc b/src/resolve-names.cc index 9e89ed7f..330de03f 100644 --- a/src/resolve-names.cc +++ b/src/resolve-names.cc @@ -38,7 +38,7 @@ struct Context { static void WABT_PRINTF_FORMAT(3, 4) print_error(Context* ctx, const WabtLocation* loc, const char* fmt, ...) { - ctx->result = WABT_ERROR; + ctx->result = WabtResult::Error; va_list args; va_start(args, fmt); wabt_ast_format_error(ctx->error_handler, loc, ctx->lexer, fmt, args); @@ -82,13 +82,13 @@ static void check_duplicate_bindings(Context* ctx, } static void resolve_label_var(Context* ctx, WabtVar* var) { - if (var->type == WABT_VAR_TYPE_NAME) { + if (var->type == WabtVarType::Name) { int i; for (i = ctx->labels.size - 1; i >= 0; --i) { WabtLabel* label = ctx->labels.data[i]; if (wabt_string_slices_are_equal(label, &var->name)) { wabt_destroy_string_slice(&var->name); - var->type = WABT_VAR_TYPE_INDEX; + var->type = WabtVarType::Index; var->index = ctx->labels.size - i - 1; return; } @@ -103,7 +103,7 @@ static void resolve_var(Context* ctx, const WabtBindingHash* bindings, WabtVar* var, const char* desc) { - if (var->type == WABT_VAR_TYPE_NAME) { + if (var->type == WabtVarType::Name) { int index = wabt_get_index_from_var(bindings, var); if (index == -1) { print_error(ctx, &var->loc, @@ -114,7 +114,7 @@ static void resolve_var(Context* ctx, wabt_destroy_string_slice(&var->name); var->index = index; - var->type = WABT_VAR_TYPE_INDEX; + var->type = WabtVarType::Index; } } @@ -140,7 +140,7 @@ static void resolve_memory_var(Context* ctx, WabtVar* var) { } static void resolve_local_var(Context* ctx, WabtVar* var) { - if (var->type == WABT_VAR_TYPE_NAME) { + if (var->type == WabtVarType::Name) { int index = wabt_get_local_index_by_var(ctx->current_func, var); if (index == -1) { print_error(ctx, &var->loc, @@ -151,44 +151,44 @@ static void resolve_local_var(Context* ctx, WabtVar* var) { wabt_destroy_string_slice(&var->name); var->index = index; - var->type = WABT_VAR_TYPE_INDEX; + var->type = WabtVarType::Index; } } static WabtResult begin_block_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); push_label(ctx, &expr->block.label); - return WABT_OK; + return WabtResult::Ok; } static WabtResult end_block_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); pop_label(ctx); - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_loop_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); push_label(ctx, &expr->loop.label); - return WABT_OK; + return WabtResult::Ok; } static WabtResult end_loop_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); pop_label(ctx); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_br_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); resolve_label_var(ctx, &expr->br.var); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_br_if_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); resolve_label_var(ctx, &expr->br_if.var); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_br_table_expr(WabtExpr* expr, void* user_data) { @@ -201,61 +201,61 @@ static WabtResult on_br_table_expr(WabtExpr* expr, void* user_data) { } resolve_label_var(ctx, &expr->br_table.default_target); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_call_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); resolve_func_var(ctx, &expr->call.var); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_call_indirect_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); resolve_func_type_var(ctx, &expr->call_indirect.var); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_get_global_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); resolve_global_var(ctx, &expr->get_global.var); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_get_local_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); resolve_local_var(ctx, &expr->get_local.var); - return WABT_OK; + return WabtResult::Ok; } static WabtResult begin_if_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); push_label(ctx, &expr->if_.true_.label); - return WABT_OK; + return WabtResult::Ok; } static WabtResult end_if_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); pop_label(ctx); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_set_global_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); resolve_global_var(ctx, &expr->set_global.var); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_set_local_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); resolve_local_var(ctx, &expr->set_local.var); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_tee_local_expr(WabtExpr* expr, void* user_data) { Context* ctx = static_cast<Context*>(user_data); resolve_local_var(ctx, &expr->tee_local.var); - return WABT_OK; + return WabtResult::Ok; } static void visit_func(Context* ctx, WabtFunc* func) { @@ -272,25 +272,21 @@ static void visit_func(Context* ctx, WabtFunc* func) { static void visit_export(Context* ctx, WabtExport* export_) { switch (export_->kind) { - case WABT_EXTERNAL_KIND_FUNC: + case WabtExternalKind::Func: resolve_func_var(ctx, &export_->var); break; - case WABT_EXTERNAL_KIND_TABLE: + case WabtExternalKind::Table: resolve_table_var(ctx, &export_->var); break; - case WABT_EXTERNAL_KIND_MEMORY: + case WabtExternalKind::Memory: resolve_memory_var(ctx, &export_->var); break; - case WABT_EXTERNAL_KIND_GLOBAL: + case WabtExternalKind::Global: resolve_global_var(ctx, &export_->var); break; - - case WABT_NUM_EXTERNAL_KINDS: - assert(0); - break; } } @@ -336,7 +332,7 @@ static void visit_module(Context* ctx, WabtModule* module) { } static void visit_raw_module(Context* ctx, WabtRawModule* raw_module) { - if (raw_module->type == WABT_RAW_MODULE_TYPE_TEXT) + if (raw_module->type == WabtRawModuleType::Text) visit_module(ctx, raw_module->text); } @@ -349,26 +345,26 @@ static void dummy_source_error_callback(const WabtLocation* loc, static void visit_command(Context* ctx, WabtCommand* command) { switch (command->type) { - case WABT_COMMAND_TYPE_MODULE: + case WabtCommandType::Module: visit_module(ctx, &command->module); break; - case WABT_COMMAND_TYPE_ACTION: - case WABT_COMMAND_TYPE_ASSERT_RETURN: - case WABT_COMMAND_TYPE_ASSERT_RETURN_NAN: - case WABT_COMMAND_TYPE_ASSERT_TRAP: - case WABT_COMMAND_TYPE_ASSERT_EXHAUSTION: - case WABT_COMMAND_TYPE_REGISTER: + case WabtCommandType::Action: + case WabtCommandType::AssertReturn: + case WabtCommandType::AssertReturnNan: + case WabtCommandType::AssertTrap: + case WabtCommandType::AssertExhaustion: + case WabtCommandType::Register: /* Don't resolve a module_var, since it doesn't really behave like other * vars. You can't reference a module by index. */ break; - case WABT_COMMAND_TYPE_ASSERT_MALFORMED: + case WabtCommandType::AssertMalformed: /* Malformed modules should not be text; the whole point of this * assertion is to test for malformed binary modules. */ break; - case WABT_COMMAND_TYPE_ASSERT_INVALID: { + case WabtCommandType::AssertInvalid: { /* The module may be invalid because the names cannot be resolved; we * don't want to print errors or fail if that's the case, but we still * should try to resolve names when possible. */ @@ -383,33 +379,29 @@ static void visit_command(Context* ctx, WabtCommand* command) { new_ctx.lexer = ctx->lexer; new_ctx.visitor = ctx->visitor; new_ctx.visitor.user_data = &new_ctx; - new_ctx.result = WABT_OK; + new_ctx.result = WabtResult::Ok; visit_raw_module(&new_ctx, &command->assert_invalid.module); wabt_destroy_label_ptr_vector(&new_ctx.labels); if (WABT_FAILED(new_ctx.result)) { - command->type = WABT_COMMAND_TYPE_ASSERT_INVALID_NON_BINARY; + command->type = WabtCommandType::AssertInvalidNonBinary; } break; } - case WABT_COMMAND_TYPE_ASSERT_INVALID_NON_BINARY: + case WabtCommandType::AssertInvalidNonBinary: /* The only reason a module would be "non-binary" is if the names cannot * be resolved. So we assume name resolution has already been tried and * failed, so skip it. */ break; - case WABT_COMMAND_TYPE_ASSERT_UNLINKABLE: + case WabtCommandType::AssertUnlinkable: visit_raw_module(ctx, &command->assert_unlinkable.module); break; - case WABT_COMMAND_TYPE_ASSERT_UNINSTANTIABLE: + case WabtCommandType::AssertUninstantiable: visit_raw_module(ctx, &command->assert_uninstantiable.module); break; - - case WABT_NUM_COMMAND_TYPES: - assert(0); - break; } } @@ -426,7 +418,7 @@ static void init_context(Context* ctx, WABT_ZERO_MEMORY(*ctx); ctx->lexer = lexer; ctx->error_handler = error_handler; - ctx->result = WABT_OK; + ctx->result = WabtResult::Ok; ctx->script = script; ctx->visitor.user_data = ctx; ctx->visitor.begin_block_expr = begin_block_expr; diff --git a/src/stream.cc b/src/stream.cc index 64073d0f..1299fee8 100644 --- a/src/stream.cc +++ b/src/stream.cc @@ -30,7 +30,7 @@ void wabt_init_stream(WabtStream* stream, WabtStream* log_stream) { stream->writer = writer; stream->offset = 0; - stream->result = WABT_OK; + stream->result = WabtResult::Ok; stream->log_stream = log_stream; } @@ -71,7 +71,7 @@ void wabt_write_data(WabtStream* stream, const void* src, size_t size, const char* desc) { - wabt_write_data_at(stream, stream->offset, src, size, WABT_DONT_PRINT_CHARS, + wabt_write_data_at(stream, stream->offset, src, size, WabtPrintChars::No, desc); stream->offset += size; } @@ -102,19 +102,19 @@ void wabt_write_u8(WabtStream* stream, uint32_t value, const char* desc) { assert(value <= UINT8_MAX); uint8_t value8 = value; wabt_write_data_at(stream, stream->offset, &value8, sizeof(value8), - WABT_DONT_PRINT_CHARS, desc); + WabtPrintChars::No, desc); stream->offset += sizeof(value8); } void wabt_write_u32(WabtStream* stream, uint32_t value, const char* desc) { wabt_write_data_at(stream, stream->offset, &value, sizeof(value), - WABT_DONT_PRINT_CHARS, desc); + WabtPrintChars::No, desc); stream->offset += sizeof(value); } void wabt_write_u64(WabtStream* stream, uint64_t value, const char* desc) { wabt_write_data_at(stream, stream->offset, &value, sizeof(value), - WABT_DONT_PRINT_CHARS, desc); + WabtPrintChars::No, desc); stream->offset += sizeof(value); } @@ -148,7 +148,7 @@ void wabt_write_memory_dump(WabtStream* stream, wabt_write_char(stream, ' '); } - if (print_chars == WABT_PRINT_CHARS) { + if (print_chars == WabtPrintChars::Yes) { wabt_write_char(stream, ' '); p = line; int i; diff --git a/src/stream.h b/src/stream.h index c7daba11..50ca3fbf 100644 --- a/src/stream.h +++ b/src/stream.h @@ -37,9 +37,9 @@ struct WabtFileStream { /* whether to display the ASCII characters in the debug output for * wabt_write_memory */ -enum WabtPrintChars { - WABT_DONT_PRINT_CHARS, - WABT_PRINT_CHARS, +enum class WabtPrintChars { + No = 0, + Yes = 1, }; WABT_EXTERN_C_BEGIN @@ -93,9 +93,15 @@ static WABT_INLINE void wabt_write_output_buffer_memory_dump( WabtStream* stream, struct WabtOutputBuffer* buf) { wabt_write_memory_dump(stream, buf->start, buf->size, 0, - WABT_DONT_PRINT_CHARS, nullptr, nullptr); + WabtPrintChars::No, nullptr, nullptr); } WABT_EXTERN_C_END +/* Helper function for writing enums as u8. */ +template <typename T> +void wabt_write_u8_enum(WabtStream* stream, T value, const char* desc) { + wabt_write_u8(stream, static_cast<uint32_t>(value), desc); +} + #endif /* WABT_STREAM_H_ */ diff --git a/src/tools/wasm-interp.cc b/src/tools/wasm-interp.cc index 691c4353..5130afdc 100644 --- a/src/tools/wasm-interp.cc +++ b/src/tools/wasm-interp.cc @@ -50,12 +50,12 @@ static WabtBinaryErrorHandler s_error_handler = static WabtFileWriter s_log_stream_writer; static WabtStream s_log_stream; -#define NOPE WABT_OPTION_NO_ARGUMENT -#define YEP WABT_OPTION_HAS_ARGUMENT +#define NOPE WabtHasArgument::No +#define YEP WabtHasArgument::Yes -enum RunVerbosity { - RUN_QUIET = 0, - RUN_VERBOSE = 1, +enum class RunVerbosity { + Quiet = 0, + Verbose = 1, }; enum { @@ -69,6 +69,7 @@ enum { NUM_FLAGS }; + static const char s_description[] = " read a file in the wasm binary format, and run in it a stack-based\n" " interpreter.\n" @@ -199,22 +200,22 @@ static void sprint_typed_value(char* buffer, size_t size, const WabtInterpreterTypedValue* tv) { switch (tv->type) { - case WABT_TYPE_I32: + case WabtType::I32: wabt_snprintf(buffer, size, "i32:%u", tv->value.i32); break; - case WABT_TYPE_I64: + case WabtType::I64: wabt_snprintf(buffer, size, "i64:%" PRIu64, tv->value.i64); break; - case WABT_TYPE_F32: { + case WabtType::F32: { float value; memcpy(&value, &tv->value.f32_bits, sizeof(float)); wabt_snprintf(buffer, size, "f32:%g", value); break; } - case WABT_TYPE_F64: { + case WabtType::F64: { double value; memcpy(&value, &tv->value.f64_bits, sizeof(double)); wabt_snprintf(buffer, size, "f64:%g", value); @@ -250,7 +251,7 @@ static void print_typed_value_vector( static void print_interpreter_result(const char* desc, WabtInterpreterResult iresult) { - printf("%s: %s\n", desc, s_trap_strings[iresult]); + printf("%s: %s\n", desc, s_trap_strings[static_cast<size_t>(iresult)]); } static void print_call(WabtStringSlice module_name, @@ -263,7 +264,7 @@ static void print_call(WabtStringSlice module_name, printf(PRIstringslice "(", WABT_PRINTF_STRING_SLICE_ARG(func_name)); print_typed_value_vector(args); printf(") =>"); - if (iresult == WABT_INTERPRETER_OK) { + if (iresult == WabtInterpreterResult::Ok) { if (results->size > 0) { printf(" "); print_typed_value_vector(results); @@ -277,18 +278,18 @@ static void print_call(WabtStringSlice module_name, static WabtInterpreterResult run_defined_function(WabtInterpreterThread* thread, uint32_t offset) { thread->pc = offset; - WabtInterpreterResult iresult = WABT_INTERPRETER_OK; + WabtInterpreterResult iresult = WabtInterpreterResult::Ok; uint32_t quantum = s_trace ? 1 : INSTRUCTION_QUANTUM; uint32_t* call_stack_return_top = thread->call_stack_top; - while (iresult == WABT_INTERPRETER_OK) { + while (iresult == WabtInterpreterResult::Ok) { if (s_trace) wabt_trace_pc(thread, s_stdout_stream); iresult = wabt_run_interpreter(thread, quantum, call_stack_return_top); } - if (iresult != WABT_INTERPRETER_RETURNED) + if (iresult != WabtInterpreterResult::Returned) return iresult; /* use OK instead of RETURNED for consistency */ - return WABT_INTERPRETER_OK; + return WabtInterpreterResult::Ok; } static WabtInterpreterResult push_args( @@ -296,21 +297,21 @@ static WabtInterpreterResult push_args( const WabtInterpreterFuncSignature* sig, const WabtInterpreterTypedValueVector* args) { if (sig->param_types.size != args->size) - return WABT_INTERPRETER_ARGUMENT_TYPE_MISMATCH; + return WabtInterpreterResult::ArgumentTypeMismatch; size_t i; for (i = 0; i < sig->param_types.size; ++i) { if (sig->param_types.data[i] != args->data[i].type) - return WABT_INTERPRETER_ARGUMENT_TYPE_MISMATCH; + return WabtInterpreterResult::ArgumentTypeMismatch; WabtInterpreterResult iresult = wabt_push_thread_value(thread, args->data[i].value); - if (iresult != WABT_INTERPRETER_OK) { + if (iresult != WabtInterpreterResult::Ok) { thread->value_stack_top = thread->value_stack.data; return iresult; } } - return WABT_INTERPRETER_OK; + return WabtInterpreterResult::Ok; } static void copy_results(WabtInterpreterThread* thread, @@ -344,11 +345,11 @@ static WabtInterpreterResult run_function( WabtInterpreterFuncSignature* sig = &thread->env->sigs.data[sig_index]; WabtInterpreterResult iresult = push_args(thread, sig, args); - if (iresult == WABT_INTERPRETER_OK) { + if (iresult == WabtInterpreterResult::Ok) { iresult = func->is_host ? wabt_call_host(thread, func) : run_defined_function(thread, func->defined.offset); - if (iresult == WABT_INTERPRETER_OK) + if (iresult == WabtInterpreterResult::Ok) copy_results(thread, sig, out_results); } @@ -361,7 +362,7 @@ static WabtInterpreterResult run_function( static WabtInterpreterResult run_start_function(WabtInterpreterThread* thread, WabtInterpreterModule* module) { if (module->defined.start_func_index == WABT_INVALID_INDEX) - return WABT_INTERPRETER_OK; + return WabtInterpreterResult::Ok; if (s_trace) printf(">>> running start function:\n"); @@ -386,7 +387,7 @@ static WabtInterpreterResult run_export( WABT_PRINTF_STRING_SLICE_ARG(export_->name)); } - assert(export_->kind == WABT_EXTERNAL_KIND_FUNC); + assert(export_->kind == WabtExternalKind::Func); return run_function(thread, export_->index, args, out_results); } @@ -400,9 +401,9 @@ static WabtInterpreterResult run_export_by_name( WabtInterpreterExport* export_ = wabt_get_interpreter_export_by_name(module, name); if (!export_) - return WABT_INTERPRETER_UNKNOWN_EXPORT; - if (export_->kind != WABT_EXTERNAL_KIND_FUNC) - return WABT_INTERPRETER_EXPORT_KIND_MISMATCH; + return WabtInterpreterResult::UnknownExport; + if (export_->kind != WabtExternalKind::Func) + return WabtInterpreterResult::ExportKindMismatch; return run_export(thread, export_, args, out_results); } @@ -414,9 +415,9 @@ static WabtInterpreterResult get_global_export_by_name( WabtInterpreterExport* export_ = wabt_get_interpreter_export_by_name(module, name); if (!export_) - return WABT_INTERPRETER_UNKNOWN_EXPORT; - if (export_->kind != WABT_EXTERNAL_KIND_GLOBAL) - return WABT_INTERPRETER_EXPORT_KIND_MISMATCH; + return WabtInterpreterResult::UnknownExport; + if (export_->kind != WabtExternalKind::Global) + return WabtInterpreterResult::ExportKindMismatch; assert(export_->index < thread->env->globals.size); WabtInterpreterGlobal* global = &thread->env->globals.data[export_->index]; @@ -425,7 +426,7 @@ static WabtInterpreterResult get_global_export_by_name( * size to zero. */ out_results->size = 0; wabt_append_interpreter_typed_value_value(out_results, &global->typed_value); - return WABT_INTERPRETER_OK; + return WabtInterpreterResult::Ok; } static void run_all_exports(WabtInterpreterModule* module, @@ -440,7 +441,7 @@ static void run_all_exports(WabtInterpreterModule* module, WabtInterpreterExport* export_ = &module->exports.data[i]; WabtInterpreterResult iresult = run_export(thread, export_, &args, &results); - if (verbose) { + if (verbose == RunVerbosity::Verbose) { print_call(wabt_empty_string_slice(), export_->name, &args, &results, iresult); } @@ -495,8 +496,8 @@ static WabtResult default_host_callback(const WabtInterpreterFunc* func, printf("called host "); print_call(func->host.module_name, func->host.field_name, &vec_args, - &vec_results, WABT_INTERPRETER_OK); - return WABT_OK; + &vec_results, WabtInterpreterResult::Ok); + return WabtResult::Ok; } #define PRIimport "\"" PRIstringslice "." PRIstringslice "\"" @@ -517,11 +518,11 @@ static WabtResult spectest_import_func(WabtInterpreterImport* import, void* user_data) { if (wabt_string_slice_eq_cstr(&import->field_name, "print")) { func->host.callback = default_host_callback; - return WABT_OK; + return WabtResult::Ok; } else { print_error(callback, "unknown host function import " PRIimport, PRINTF_IMPORT_ARG(*import)); - return WABT_ERROR; + return WabtResult::Error; } } @@ -533,11 +534,11 @@ static WabtResult spectest_import_table(WabtInterpreterImport* import, table->limits.has_max = true; table->limits.initial = 10; table->limits.max = 20; - return WABT_OK; + return WabtResult::Ok; } else { print_error(callback, "unknown host table import " PRIimport, PRINTF_IMPORT_ARG(*import)); - return WABT_ERROR; + return WabtResult::Error; } } @@ -551,11 +552,11 @@ static WabtResult spectest_import_memory(WabtInterpreterImport* import, memory->page_limits.max = 2; memory->byte_size = memory->page_limits.initial * WABT_MAX_PAGES; memory->data = wabt_alloc_zero(memory->byte_size); - return WABT_OK; + return WabtResult::Ok; } else { print_error(callback, "unknown host memory import " PRIimport, PRINTF_IMPORT_ARG(*import)); - return WABT_ERROR; + return WabtResult::Error; } } @@ -565,21 +566,21 @@ static WabtResult spectest_import_global(WabtInterpreterImport* import, void* user_data) { if (wabt_string_slice_eq_cstr(&import->field_name, "global")) { switch (global->typed_value.type) { - case WABT_TYPE_I32: + case WabtType::I32: global->typed_value.value.i32 = 666; break; - case WABT_TYPE_F32: { + case WabtType::F32: { float value = 666.6f; memcpy(&global->typed_value.value.f32_bits, &value, sizeof(value)); break; } - case WABT_TYPE_I64: + case WabtType::I64: global->typed_value.value.i64 = 666; break; - case WABT_TYPE_F64: { + case WabtType::F64: { double value = 666.6; memcpy(&global->typed_value.value.f64_bits, &value, sizeof(value)); break; @@ -588,14 +589,14 @@ static WabtResult spectest_import_global(WabtInterpreterImport* import, default: print_error(callback, "bad type for host global import " PRIimport, PRINTF_IMPORT_ARG(*import)); - return WABT_ERROR; + return WabtResult::Error; } - return WABT_OK; + return WabtResult::Ok; } else { print_error(callback, "unknown host global import " PRIimport, PRINTF_IMPORT_ARG(*import)); - return WABT_ERROR; + return WabtResult::Error; } } @@ -620,9 +621,9 @@ static WabtResult read_and_run_module(const char* module_filename) { result = read_module(module_filename, &env, &s_error_handler, &module); if (WABT_SUCCEEDED(result)) { WabtInterpreterResult iresult = run_start_function(&thread, module); - if (iresult == WABT_INTERPRETER_OK) { + if (iresult == WabtInterpreterResult::Ok) { if (s_run_all_exports) - run_all_exports(module, &thread, RUN_VERBOSE); + run_all_exports(module, &thread, RunVerbosity::Verbose); } else { print_interpreter_result("error running start function", iresult); } @@ -656,9 +657,9 @@ struct Context { int total; }; -enum ActionType { - ACTION_TYPE_INVOKE, - ACTION_TYPE_GET, +enum class ActionType { + Invoke, + Get, }; struct Action { @@ -671,7 +672,7 @@ struct Action { #define CHECK_RESULT(x) \ do { \ if (WABT_FAILED(x)) \ - return WABT_ERROR; \ + return WabtResult::Error; \ } while (0) #define EXPECT(x) CHECK_RESULT(expect(ctx, x)) @@ -753,10 +754,10 @@ static bool match(Context* ctx, const char* s) { static WabtResult expect(Context* ctx, const char* s) { if (match(ctx, s)) { - return WABT_OK; + return WabtResult::Ok; } else { print_parse_error(ctx, "expected %s", s); - return WABT_ERROR; + return WabtResult::Error; } } @@ -767,7 +768,7 @@ static WabtResult expect_key(Context* ctx, const char* key) { wabt_snprintf(quoted, quoted_len, "\"%s\"", key); EXPECT(quoted); EXPECT(":"); - return WABT_OK; + return WabtResult::Ok; } static WabtResult parse_uint32(Context* ctx, uint32_t* out_int) { @@ -780,7 +781,7 @@ static WabtResult parse_uint32(Context* ctx, uint32_t* out_int) { result = result * 10 + static_cast<uint32_t>(c - '0'); if (result < last_result) { print_parse_error(ctx, "uint32 overflow"); - return WABT_ERROR; + return WabtResult::Error; } } else { putback_char(ctx); @@ -788,7 +789,7 @@ static WabtResult parse_uint32(Context* ctx, uint32_t* out_int) { } } *out_int = result; - return WABT_OK; + return WabtResult::Ok; } static WabtResult parse_string(Context* ctx, WabtStringSlice* out_string) { @@ -797,7 +798,7 @@ static WabtResult parse_string(Context* ctx, WabtStringSlice* out_string) { skip_whitespace(ctx); if (read_char(ctx) != '"') { print_parse_error(ctx, "expected string"); - return WABT_ERROR; + return WabtResult::Error; } /* Modify json_data in-place so we can use the WabtStringSlice directly * without having to allocate additional memory; this is only necessary when @@ -815,7 +816,7 @@ static WabtResult parse_string(Context* ctx, WabtStringSlice* out_string) { c = read_char(ctx); if (c != 'u') { print_parse_error(ctx, "expected escape: \\uxxxx"); - return WABT_ERROR; + return WabtResult::Error; } int i; uint16_t code = 0; @@ -830,7 +831,7 @@ static WabtResult parse_string(Context* ctx, WabtStringSlice* out_string) { cval = c - 'A' + 10; } else { print_parse_error(ctx, "expected hex char"); - return WABT_ERROR; + return WabtResult::Error; } code = (code << 4) + cval; } @@ -846,7 +847,7 @@ static WabtResult parse_string(Context* ctx, WabtStringSlice* out_string) { } } out_string->length = p - start; - return WABT_OK; + return WabtResult::Ok; } static WabtResult parse_key_string_value(Context* ctx, @@ -865,13 +866,13 @@ static WabtResult parse_opt_name_string_value(Context* ctx, CHECK_RESULT(parse_string(ctx, out_string)); EXPECT(","); } - return WABT_OK; + return WabtResult::Ok; } static WabtResult parse_line(Context* ctx) { EXPECT_KEY("line"); CHECK_RESULT(parse_uint32(ctx, &ctx->command_line_number)); - return WABT_OK; + return WabtResult::Ok; } static WabtResult parse_type_object(Context* ctx, WabtType* out_type) { @@ -881,21 +882,21 @@ static WabtResult parse_type_object(Context* ctx, WabtType* out_type) { EXPECT("}"); if (wabt_string_slice_eq_cstr(&type_str, "i32")) { - *out_type = WABT_TYPE_I32; - return WABT_OK; + *out_type = WabtType::I32; + return WabtResult::Ok; } else if (wabt_string_slice_eq_cstr(&type_str, "f32")) { - *out_type = WABT_TYPE_F32; - return WABT_OK; + *out_type = WabtType::F32; + return WabtResult::Ok; } else if (wabt_string_slice_eq_cstr(&type_str, "i64")) { - *out_type = WABT_TYPE_I64; - return WABT_OK; + *out_type = WabtType::I64; + return WabtResult::Ok; } else if (wabt_string_slice_eq_cstr(&type_str, "f64")) { - *out_type = WABT_TYPE_F64; - return WABT_OK; + *out_type = WabtType::F64; + return WabtResult::Ok; } else { print_parse_error(ctx, "unknown type: \"" PRIstringslice "\"", WABT_PRINTF_STRING_SLICE_ARG(type_str)); - return WABT_ERROR; + return WabtResult::Error; } } @@ -911,7 +912,7 @@ static WabtResult parse_type_vector(Context* ctx, WabtTypeVector* out_types) { first = false; wabt_append_type_value(out_types, &type); } - return WABT_OK; + return WabtResult::Ok; } static WabtResult parse_const(Context* ctx, @@ -930,35 +931,35 @@ static WabtResult parse_const(Context* ctx, if (wabt_string_slice_eq_cstr(&type_str, "i32")) { uint32_t value; CHECK_RESULT(wabt_parse_int32(value_start, value_end, &value, - WABT_PARSE_UNSIGNED_ONLY)); - out_value->type = WABT_TYPE_I32; + WabtParseIntType::UnsignedOnly)); + out_value->type = WabtType::I32; out_value->value.i32 = value; - return WABT_OK; + return WabtResult::Ok; } else if (wabt_string_slice_eq_cstr(&type_str, "f32")) { uint32_t value_bits; CHECK_RESULT(wabt_parse_int32(value_start, value_end, &value_bits, - WABT_PARSE_UNSIGNED_ONLY)); - out_value->type = WABT_TYPE_F32; + WabtParseIntType::UnsignedOnly)); + out_value->type = WabtType::F32; out_value->value.f32_bits = value_bits; - return WABT_OK; + return WabtResult::Ok; } else if (wabt_string_slice_eq_cstr(&type_str, "i64")) { uint64_t value; CHECK_RESULT(wabt_parse_int64(value_start, value_end, &value, - WABT_PARSE_UNSIGNED_ONLY)); - out_value->type = WABT_TYPE_I64; + WabtParseIntType::UnsignedOnly)); + out_value->type = WabtType::I64; out_value->value.i64 = value; - return WABT_OK; + return WabtResult::Ok; } else if (wabt_string_slice_eq_cstr(&type_str, "f64")) { uint64_t value_bits; CHECK_RESULT(wabt_parse_int64(value_start, value_end, &value_bits, - WABT_PARSE_UNSIGNED_ONLY)); - out_value->type = WABT_TYPE_F64; + WabtParseIntType::UnsignedOnly)); + out_value->type = WabtType::F64; out_value->value.f64_bits = value_bits; - return WABT_OK; + return WabtResult::Ok; } else { print_parse_error(ctx, "unknown type: \"" PRIstringslice "\"", WABT_PRINTF_STRING_SLICE_ARG(type_str)); - return WABT_ERROR; + return WabtResult::Error; } } @@ -976,7 +977,7 @@ static WabtResult parse_const_vector( wabt_append_interpreter_typed_value_value(out_values, &value); first = false; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult parse_action(Context* ctx, Action* out_action) { @@ -985,10 +986,10 @@ static WabtResult parse_action(Context* ctx, Action* out_action) { EXPECT("{"); EXPECT_KEY("type"); if (match(ctx, "\"invoke\"")) { - out_action->type = ACTION_TYPE_INVOKE; + out_action->type = ActionType::Invoke; } else { EXPECT("\"get\""); - out_action->type = ACTION_TYPE_GET; + out_action->type = ActionType::Get; } EXPECT(","); if (match(ctx, "\"module\"")) { @@ -997,13 +998,13 @@ static WabtResult parse_action(Context* ctx, Action* out_action) { EXPECT(","); } PARSE_KEY_STRING_VALUE("field", &out_action->field_name); - if (out_action->type == ACTION_TYPE_INVOKE) { + if (out_action->type == ActionType::Invoke) { EXPECT(","); EXPECT_KEY("args"); CHECK_RESULT(parse_const_vector(ctx, &out_action->args)); } EXPECT("}"); - return WABT_OK; + return WabtResult::Ok; } static char* create_module_path(Context* ctx, WabtStringSlice filename) { @@ -1037,17 +1038,17 @@ static WabtResult on_module_command(Context* ctx, wabt_reset_interpreter_environment_to_mark(&ctx->env, mark); print_command_error(ctx, "error reading module: \"%s\"", path); wabt_free(path); - return WABT_ERROR; + return WabtResult::Error; } wabt_free(path); WabtInterpreterResult iresult = run_start_function(&ctx->thread, ctx->last_module); - if (iresult != WABT_INTERPRETER_OK) { + if (iresult != WabtInterpreterResult::Ok) { wabt_reset_interpreter_environment_to_mark(&ctx->env, mark); print_interpreter_result("error running start function", iresult); - return WABT_ERROR; + return WabtResult::Error; } if (!wabt_string_slice_is_empty(&name)) { @@ -1059,7 +1060,7 @@ static WabtResult on_module_command(Context* ctx, wabt_insert_binding(&ctx->env.module_bindings, &binding_name); binding->index = ctx->env.modules.size - 1; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult run_action(Context* ctx, @@ -1081,25 +1082,26 @@ static WabtResult run_action(Context* ctx, WabtInterpreterModule* module = &ctx->env.modules.data[module_index]; switch (action->type) { - case ACTION_TYPE_INVOKE: + case ActionType::Invoke: *out_iresult = run_export_by_name(&ctx->thread, module, &action->field_name, &action->args, out_results, verbose); - if (verbose) { + if (verbose == RunVerbosity::Verbose) { print_call(wabt_empty_string_slice(), action->field_name, &action->args, out_results, *out_iresult); } - return WABT_OK; + return WabtResult::Ok; - case ACTION_TYPE_GET: { + case ActionType::Get: { *out_iresult = get_global_export_by_name( &ctx->thread, module, &action->field_name, out_results); - return WABT_OK; + return WabtResult::Ok; } default: - print_command_error(ctx, "invalid action type %d", action->type); - return WABT_ERROR; + print_command_error(ctx, "invalid action type %d", + static_cast<int>(action->type)); + return WabtResult::Error; } } @@ -1108,13 +1110,15 @@ static WabtResult on_action_command(Context* ctx, Action* action) { WabtInterpreterResult iresult; ctx->total++; - WabtResult result = run_action(ctx, action, &iresult, &results, RUN_VERBOSE); + WabtResult result = + run_action(ctx, action, &iresult, &results, RunVerbosity::Verbose); if (WABT_SUCCEEDED(result)) { - if (iresult == WABT_INTERPRETER_OK) { + if (iresult == WabtInterpreterResult::Ok) { ctx->passed++; } else { - print_command_error(ctx, "unexpected trap: %s", s_trap_strings[iresult]); - result = WABT_ERROR; + print_command_error(ctx, "unexpected trap: %s", + s_trap_strings[static_cast<size_t>(iresult)]); + result = WabtResult::Error; } } @@ -1134,7 +1138,7 @@ static WabtBinaryErrorHandler* new_custom_error_handler(Context* ctx, wabt_alloc_zero(sizeof(WabtDefaultErrorHandlerInfo))); info->header = header; info->out_file = stdout; - info->print_header = WABT_PRINT_ERROR_HEADER_ONCE; + info->print_header = WabtPrintErrorHeader::Once; WabtBinaryErrorHandler* error_handler = static_cast<WabtBinaryErrorHandler*>( wabt_alloc_zero(sizeof(WabtBinaryErrorHandler))); @@ -1167,10 +1171,10 @@ static WabtResult on_assert_malformed_command(Context* ctx, WabtResult result = read_module(path, &env, error_handler, &module); if (WABT_FAILED(result)) { ctx->passed++; - result = WABT_OK; + result = WabtResult::Ok; } else { print_command_error(ctx, "expected module to be malformed: \"%s\"", path); - result = WABT_ERROR; + result = WabtResult::Error; } wabt_free(path); @@ -1204,14 +1208,14 @@ static WabtResult on_register_command(Context* ctx, if (module_index < 0 || module_index >= static_cast<int>(ctx->env.modules.size)) { print_command_error(ctx, "unknown module in register"); - return WABT_ERROR; + return WabtResult::Error; } WabtStringSlice dup_as = wabt_dup_string_slice(as); WabtBinding* binding = wabt_insert_binding(&ctx->env.registered_module_bindings, &dup_as); binding->index = module_index; - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_assert_unlinkable_command(Context* ctx, @@ -1230,10 +1234,10 @@ static WabtResult on_assert_unlinkable_command(Context* ctx, if (WABT_FAILED(result)) { ctx->passed++; - result = WABT_OK; + result = WabtResult::Ok; } else { print_command_error(ctx, "expected module to be unlinkable: \"%s\"", path); - result = WABT_ERROR; + result = WabtResult::Error; } wabt_free(path); @@ -1256,10 +1260,10 @@ static WabtResult on_assert_invalid_command(Context* ctx, WabtResult result = read_module(path, &env, error_handler, &module); if (WABT_FAILED(result)) { ctx->passed++; - result = WABT_OK; + result = WabtResult::Ok; } else { print_command_error(ctx, "expected module to be invalid: \"%s\"", path); - result = WABT_ERROR; + result = WabtResult::Error; } wabt_free(path); @@ -1280,17 +1284,17 @@ static WabtResult on_assert_uninstantiable_command(Context* ctx, if (WABT_SUCCEEDED(result)) { WabtInterpreterResult iresult = run_start_function(&ctx->thread, module); - if (iresult == WABT_INTERPRETER_OK) { + if (iresult == WabtInterpreterResult::Ok) { print_command_error(ctx, "expected error running start function: \"%s\"", path); - result = WABT_ERROR; + result = WabtResult::Error; } else { ctx->passed++; - result = WABT_OK; + result = WabtResult::Ok; } } else { print_command_error(ctx, "error reading module: \"%s\"", path); - result = WABT_ERROR; + result = WabtResult::Error; } wabt_reset_interpreter_environment_to_mark(&ctx->env, mark); @@ -1304,10 +1308,10 @@ static bool typed_values_are_equal(const WabtInterpreterTypedValue* tv1, return false; switch (tv1->type) { - case WABT_TYPE_I32: return tv1->value.i32 == tv2->value.i32; - case WABT_TYPE_F32: return tv1->value.f32_bits == tv2->value.f32_bits; - case WABT_TYPE_I64: return tv1->value.i64 == tv2->value.i64; - case WABT_TYPE_F64: return tv1->value.f64_bits == tv2->value.f64_bits; + case WabtType::I32: return tv1->value.i32 == tv2->value.i32; + case WabtType::F32: return tv1->value.f32_bits == tv2->value.f32_bits; + case WabtType::I64: return tv1->value.i64 == tv2->value.i64; + case WabtType::F64: return tv1->value.f64_bits == tv2->value.f64_bits; default: assert(0); return false; } } @@ -1320,10 +1324,11 @@ static WabtResult on_assert_return_command( WabtInterpreterResult iresult; ctx->total++; - WabtResult result = run_action(ctx, action, &iresult, &results, RUN_QUIET); + WabtResult result = + run_action(ctx, action, &iresult, &results, RunVerbosity::Quiet); if (WABT_SUCCEEDED(result)) { - if (iresult == WABT_INTERPRETER_OK) { + if (iresult == WabtInterpreterResult::Ok) { if (results.size == expected->size) { size_t i; for (i = 0; i < results.size; ++i) { @@ -1337,7 +1342,7 @@ static WabtResult on_assert_return_command( print_command_error(ctx, "mismatch in result %" PRIzd " of assert_return: expected %s, got %s", i, expected_str, actual_str); - result = WABT_ERROR; + result = WabtResult::Error; } } } else { @@ -1345,11 +1350,12 @@ static WabtResult on_assert_return_command( ctx, "result length mismatch in assert_return: expected %" PRIzd ", got %" PRIzd, expected->size, results.size); - result = WABT_ERROR; + result = WabtResult::Error; } } else { - print_command_error(ctx, "unexpected trap: %s", s_trap_strings[iresult]); - result = WABT_ERROR; + print_command_error(ctx, "unexpected trap: %s", + s_trap_strings[static_cast<size_t>(iresult)]); + result = WabtResult::Error; } } @@ -1365,34 +1371,35 @@ static WabtResult on_assert_return_nan_command(Context* ctx, Action* action) { WabtInterpreterResult iresult; ctx->total++; - WabtResult result = run_action(ctx, action, &iresult, &results, RUN_QUIET); + WabtResult result = + run_action(ctx, action, &iresult, &results, RunVerbosity::Quiet); if (WABT_SUCCEEDED(result)) { - if (iresult == WABT_INTERPRETER_OK) { + if (iresult == WabtInterpreterResult::Ok) { if (results.size != 1) { print_command_error(ctx, "expected one result, got %" PRIzd, results.size); - result = WABT_ERROR; + result = WabtResult::Error; } const WabtInterpreterTypedValue* actual = &results.data[0]; switch (actual->type) { - case WABT_TYPE_F32: + case WabtType::F32: if (!wabt_is_nan_f32(actual->value.f32_bits)) { char actual_str[MAX_TYPED_VALUE_CHARS]; sprint_typed_value(actual_str, sizeof(actual_str), actual); print_command_error(ctx, "expected result to be nan, got %s", actual_str); - result = WABT_ERROR; + result = WabtResult::Error; } break; - case WABT_TYPE_F64: + case WabtType::F64: if (!wabt_is_nan_f64(actual->value.f64_bits)) { char actual_str[MAX_TYPED_VALUE_CHARS]; sprint_typed_value(actual_str, sizeof(actual_str), actual); print_command_error(ctx, "expected result to be nan, got %s", actual_str); - result = WABT_ERROR; + result = WabtResult::Error; } break; @@ -1400,12 +1407,13 @@ static WabtResult on_assert_return_nan_command(Context* ctx, Action* action) { print_command_error(ctx, "expected result type to be f32 or f64, got %s", wabt_get_type_name(actual->type)); - result = WABT_ERROR; + result = WabtResult::Error; break; } } else { - print_command_error(ctx, "unexpected trap: %s", s_trap_strings[iresult]); - result = WABT_ERROR; + print_command_error(ctx, "unexpected trap: %s", + s_trap_strings[static_cast<int>(iresult)]); + result = WabtResult::Error; } } @@ -1413,7 +1421,7 @@ static WabtResult on_assert_return_nan_command(Context* ctx, Action* action) { ctx->passed++; wabt_destroy_interpreter_typed_value_vector(&results); - return WABT_OK; + return WabtResult::Ok; } static WabtResult on_assert_trap_command(Context* ctx, @@ -1423,14 +1431,15 @@ static WabtResult on_assert_trap_command(Context* ctx, WabtInterpreterResult iresult; ctx->total++; - WabtResult result = run_action(ctx, action, &iresult, &results, RUN_QUIET); + WabtResult result = + run_action(ctx, action, &iresult, &results, RunVerbosity::Quiet); if (WABT_SUCCEEDED(result)) { - if (iresult != WABT_INTERPRETER_OK) { + if (iresult != WabtInterpreterResult::Ok) { ctx->passed++; } else { print_command_error(ctx, "expected trap: \"" PRIstringslice "\"", WABT_PRINTF_STRING_SLICE_ARG(text)); - result = WABT_ERROR; + result = WabtResult::Error; } } @@ -1444,14 +1453,15 @@ static WabtResult on_assert_exhaustion_command(Context* ctx, WabtInterpreterResult iresult; ctx->total++; - WabtResult result = run_action(ctx, action, &iresult, &results, RUN_QUIET); + WabtResult result = + run_action(ctx, action, &iresult, &results, RunVerbosity::Quiet); if (WABT_SUCCEEDED(result)) { - if (iresult == WABT_INTERPRETER_TRAP_CALL_STACK_EXHAUSTED || - iresult == WABT_INTERPRETER_TRAP_VALUE_STACK_EXHAUSTED) { + if (iresult == WabtInterpreterResult::TrapCallStackExhausted || + iresult == WabtInterpreterResult::TrapValueStackExhausted) { ctx->passed++; } else { print_command_error(ctx, "expected call stack exhaustion"); - result = WABT_ERROR; + result = WabtResult::Error; } } @@ -1609,10 +1619,10 @@ static WabtResult parse_command(Context* ctx) { destroy_action(&action); } else { print_command_error(ctx, "unknown command type"); - return WABT_ERROR; + return WabtResult::Error; } EXPECT("}"); - return WABT_OK; + return WabtResult::Ok; } static WabtResult parse_commands(Context* ctx) { @@ -1629,7 +1639,7 @@ static WabtResult parse_commands(Context* ctx) { first = false; } EXPECT("}"); - return WABT_OK; + return WabtResult::Ok; } static void destroy_context(Context* ctx) { @@ -1651,7 +1661,7 @@ static WabtResult read_and_run_spec_json(const char* spec_json_filename) { size_t size; WabtResult result = wabt_read_file(spec_json_filename, &data, &size); if (WABT_FAILED(result)) - return WABT_ERROR; + return WabtResult::Error; ctx.json_data = static_cast<char*>(data); ctx.json_data_size = size; @@ -1668,9 +1678,11 @@ int main(int argc, char** argv) { s_stdout_stream = wabt_init_stdout_stream(); + WabtResult result; if (s_spec) { - return read_and_run_spec_json(s_infile); + result = read_and_run_spec_json(s_infile); } else { - return read_and_run_module(s_infile); + result = read_and_run_module(s_infile); } + return result != WabtResult::Ok; } diff --git a/src/tools/wasm-link.cc b/src/tools/wasm-link.cc index a9e3274b..2f3e93dd 100644 --- a/src/tools/wasm-link.cc +++ b/src/tools/wasm-link.cc @@ -26,9 +26,9 @@ #include "binary-reader-linker.h" #define PROGRAM_NAME "wasm-link" -#define NOPE WABT_OPTION_NO_ARGUMENT -#define YEP WABT_OPTION_HAS_ARGUMENT -#define FIRST_KNOWN_SECTION WABT_BINARY_SECTION_TYPE +#define NOPE WabtHasArgument::No +#define YEP WabtHasArgument::Yes +#define FIRST_KNOWN_SECTION static_cast<size_t>(WabtBinarySection::Type) enum { FLAG_VERBOSE, FLAG_OUTPUT, FLAG_RELOCATABLE, FLAG_HELP, NUM_FLAGS }; @@ -117,7 +117,7 @@ static void parse_options(int argc, char** argv) { void wabt_destroy_section(WabtSection* section) { wabt_destroy_reloc_vector(§ion->relocations); switch (section->section_code) { - case WABT_BINARY_SECTION_DATA: + case WabtBinarySection::Data: wabt_destroy_data_segment_vector(§ion->data_segments); break; default: @@ -170,16 +170,16 @@ static void apply_relocation(WabtSection* section, WabtReloc* r) { uint32_t offset = 0; switch (r->type) { - case WABT_RELOC_FUNC_INDEX_LEB: + case WabtRelocType::FuncIndexLeb: new_value = relocate_func_index(binary, cur_value); break; - case WABT_RELOC_TABLE_INDEX_SLEB: + case WabtRelocType::TableIndexSleb: printf("%s: table index reloc: %d offset=%d\n", binary->filename, cur_value, binary->table_index_offset); offset = binary->table_index_offset; new_value = cur_value + offset; break; - case WABT_RELOC_GLOBAL_INDEX_LEB: + case WabtRelocType::GlobalIndexLeb: if (cur_value >= binary->global_imports.size) { offset = binary->global_index_offset; } else { @@ -224,13 +224,13 @@ static void write_section_payload(Context* ctx, WabtSection* sec) { } static void write_c_str(WabtStream* stream, const char* str, const char* desc) { - wabt_write_str(stream, str, strlen(str), WABT_PRINT_CHARS, desc); + wabt_write_str(stream, str, strlen(str), WabtPrintChars::Yes, desc); } static void write_slice(WabtStream* stream, WabtStringSlice str, const char* desc) { - wabt_write_str(stream, str.start, str.length, WABT_PRINT_CHARS, desc); + wabt_write_str(stream, str.start, str.length, WabtPrintChars::Yes, desc); } #define WRITE_UNKNOWN_SIZE(STREAM) \ @@ -260,7 +260,7 @@ static void write_table_section(Context* ctx, WabtStream* stream = &ctx->stream; WRITE_UNKNOWN_SIZE(stream); wabt_write_u32_leb128(stream, table_count, "table count"); - wabt_write_type(stream, WABT_TYPE_ANYFUNC); + wabt_write_type(stream, WabtType::Anyfunc); wabt_write_u32_leb128(stream, flags, "table elem flags"); wabt_write_u32_leb128(stream, elem_count, "table initial length"); wabt_write_u32_leb128(stream, elem_count, "table max length"); @@ -284,14 +284,15 @@ static void write_export_section(Context* ctx) { for (j = 0; j < binary->exports.size; j++) { WabtExport* export_ = &binary->exports.data[j]; write_slice(stream, export_->name, "export name"); - wabt_write_u8(stream, export_->kind, "export kind"); + wabt_write_u8_enum(stream, export_->kind, "export kind"); uint32_t index = export_->index; switch (export_->kind) { - case WABT_EXTERNAL_KIND_FUNC: + case WabtExternalKind::Func: index = relocate_func_index(binary, index); break; default: - WABT_FATAL("unsupport export type: %d\n", export_->kind); + WABT_FATAL("unsupport export type: %d\n", + static_cast<int>(export_->kind)); break; } wabt_write_u32_leb128(stream, index, "export index"); @@ -314,9 +315,9 @@ static void write_elem_section(Context* ctx, wabt_write_u32_leb128(stream, 1, "segment count"); wabt_write_u32_leb128(stream, 0, "table index"); - wabt_write_opcode(&ctx->stream, WABT_OPCODE_I32_CONST); + wabt_write_opcode(&ctx->stream, WabtOpcode::I32Const); wabt_write_i32_leb128(&ctx->stream, 0, "elem init literal"); - wabt_write_opcode(&ctx->stream, WABT_OPCODE_END); + wabt_write_opcode(&ctx->stream, WabtOpcode::End); wabt_write_u32_leb128(stream, total_elem_count, "num elements"); ctx->current_section_payload_offset = stream->offset; @@ -356,7 +357,7 @@ static void write_function_import(Context* ctx, uint32_t offset) { write_c_str(&ctx->stream, WABT_LINK_MODULE_NAME, "import module name"); write_slice(&ctx->stream, import->name, "import field name"); - wabt_write_u8(&ctx->stream, WABT_EXTERNAL_KIND_FUNC, "import kind"); + wabt_write_u8_enum(&ctx->stream, WabtExternalKind::Func, "import kind"); wabt_write_u32_leb128(&ctx->stream, import->sig_index + offset, "import signature index"); } @@ -364,7 +365,7 @@ static void write_function_import(Context* ctx, static void write_global_import(Context* ctx, WabtGlobalImport* import) { write_c_str(&ctx->stream, WABT_LINK_MODULE_NAME, "import module name"); write_slice(&ctx->stream, import->name, "import field name"); - wabt_write_u8(&ctx->stream, WABT_EXTERNAL_KIND_GLOBAL, "import kind"); + wabt_write_u8_enum(&ctx->stream, WabtExternalKind::Global, "import kind"); wabt_write_type(&ctx->stream, import->type); wabt_write_u8(&ctx->stream, import->mutable_, "global mutability"); } @@ -437,9 +438,9 @@ static void write_data_segment(WabtStream* stream, uint32_t offset) { assert(segment->memory_index == 0); wabt_write_u32_leb128(stream, segment->memory_index, "memory index"); - wabt_write_opcode(stream, WABT_OPCODE_I32_CONST); + wabt_write_opcode(stream, WabtOpcode::I32Const); wabt_write_u32_leb128(stream, segment->offset + offset, "offset"); - wabt_write_opcode(stream, WABT_OPCODE_END); + wabt_write_opcode(stream, WabtOpcode::End); wabt_write_u32_leb128(stream, segment->size, "segment size"); wabt_write_data(stream, segment->data, segment->size, "segment data"); } @@ -482,7 +483,7 @@ static void write_names_section(Context* ctx) { return; WabtStream* stream = &ctx->stream; - wabt_write_u8(stream, WABT_BINARY_SECTION_CUSTOM, "section code"); + wabt_write_u8_enum(stream, WabtBinarySection::Custom, "section code"); WRITE_UNKNOWN_SIZE(stream); write_c_str(stream, "name", "custom section name"); wabt_write_u32_leb128(stream, total_count, "element count"); @@ -522,17 +523,18 @@ static void write_reloc_section(Context* ctx, WABT_BINARY_SECTION_RELOC, wabt_get_section_name(section_code)); WabtStream* stream = &ctx->stream; - wabt_write_u8(stream, WABT_BINARY_SECTION_CUSTOM, "section code"); + wabt_write_u8_enum(stream, WabtBinarySection::Custom, "section code"); WRITE_UNKNOWN_SIZE(stream); write_c_str(stream, section_name, "reloc section name"); - wabt_write_u32_leb128(&ctx->stream, section_code, "reloc section"); + wabt_write_u32_leb128_enum(&ctx->stream, section_code, "reloc section"); wabt_write_u32_leb128(&ctx->stream, total_relocs, "num relocs"); for (i = 0; i < sections->size; i++) { WabtSection* sec = sections->data[i]; WabtRelocVector* relocs = &sec->relocations; for (j = 0; j < relocs->size; j++) { - wabt_write_u32_leb128(&ctx->stream, relocs->data[j].type, "reloc type"); + wabt_write_u32_leb128_enum(&ctx->stream, relocs->data[j].type, + "reloc type"); uint32_t new_offset = relocs->data[j].offset + sec->output_payload_offset; wabt_write_u32_leb128(&ctx->stream, new_offset, "reloc offset"); } @@ -547,7 +549,7 @@ static bool write_combined_section(Context* ctx, if (!sections->size) return false; - if (section_code == WABT_BINARY_SECTION_START && sections->size > 1) { + if (section_code == WabtBinarySection::Start && sections->size > 1) { WABT_FATAL("Don't know how to combine sections of type: %s\n", wabt_get_section_name(section_code)); } @@ -563,29 +565,29 @@ static bool write_combined_section(Context* ctx, total_count += sec->count; } - wabt_write_u8(&ctx->stream, section_code, "section code"); + wabt_write_u8_enum(&ctx->stream, section_code, "section code"); ctx->current_section_payload_offset = -1; switch (section_code) { - case WABT_BINARY_SECTION_IMPORT: + case WabtBinarySection::Import: write_import_section(ctx); break; - case WABT_BINARY_SECTION_FUNCTION: + case WabtBinarySection::Function: write_function_section(ctx, sections, total_count); break; - case WABT_BINARY_SECTION_TABLE: + case WabtBinarySection::Table: write_table_section(ctx, sections); break; - case WABT_BINARY_SECTION_EXPORT: + case WabtBinarySection::Export: write_export_section(ctx); break; - case WABT_BINARY_SECTION_ELEM: + case WabtBinarySection::Elem: write_elem_section(ctx, sections); break; - case WABT_BINARY_SECTION_MEMORY: + case WabtBinarySection::Memory: write_memory_section(ctx, sections); break; - case WABT_BINARY_SECTION_DATA: + case WabtBinarySection::Data: write_data_section(ctx, sections, total_count); break; default: { @@ -698,17 +700,17 @@ static void calculate_reloc_offsets(Context* ctx) { for (j = 0; j < binary->sections.size; j++) { WabtSection* sec = &binary->sections.data[j]; switch (sec->section_code) { - case WABT_BINARY_SECTION_TYPE: + case WabtBinarySection::Type: binary->type_index_offset = type_count; type_count += sec->count; break; - case WABT_BINARY_SECTION_GLOBAL: + case WabtBinarySection::Global: binary->global_index_offset = total_global_imports - sec->binary->global_imports.size + global_count; global_count += sec->count; break; - case WABT_BINARY_SECTION_FUNCTION: + case WabtBinarySection::Function: binary->function_index_offset = total_function_imports - sec->binary->function_imports.size + function_count; @@ -723,7 +725,7 @@ static void calculate_reloc_offsets(Context* ctx) { static void write_binary(Context* ctx) { /* Find all the sections of each type */ - WabtSectionPtrVector sections[WABT_NUM_BINARY_SECTIONS]; + WabtSectionPtrVector sections[kWabtBinarySectionCount]; WABT_ZERO_MEMORY(sections); size_t i, j; @@ -731,7 +733,8 @@ static void write_binary(Context* ctx) { WabtLinkerInputBinary* binary = &ctx->inputs.data[j]; for (i = 0; i < binary->sections.size; i++) { WabtSection* s = &binary->sections.data[i]; - WabtSectionPtrVector* sec_list = §ions[s->section_code]; + WabtSectionPtrVector* sec_list = + §ions[static_cast<int>(s->section_code)]; wabt_append_section_ptr_value(sec_list, &s); } } @@ -741,7 +744,7 @@ static void write_binary(Context* ctx) { wabt_write_u32(&ctx->stream, WABT_BINARY_VERSION, "WABT_BINARY_VERSION"); /* Write known sections first */ - for (i = FIRST_KNOWN_SECTION; i < WABT_NUM_BINARY_SECTIONS; i++) { + for (i = FIRST_KNOWN_SECTION; i < kWabtBinarySectionCount; i++) { write_combined_section(ctx, static_cast<WabtBinarySection>(i), §ions[i]); } @@ -749,11 +752,11 @@ static void write_binary(Context* ctx) { write_names_section(ctx); /* Generate a new set of reloction sections */ - for (i = FIRST_KNOWN_SECTION; i < WABT_NUM_BINARY_SECTIONS; i++) { + for (i = FIRST_KNOWN_SECTION; i < kWabtBinarySectionCount; i++) { write_reloc_section(ctx, static_cast<WabtBinarySection>(i), §ions[i]); } - for (i = 0; i < WABT_NUM_BINARY_SECTIONS; i++) { + for (i = 0; i < kWabtBinarySectionCount; i++) { wabt_destroy_section_ptr_vector(§ions[i]); } } @@ -804,7 +807,7 @@ static WabtResult perform_link(Context* ctx) { WABT_FATAL("error writing linked output to file\n"); wabt_close_mem_writer(&writer); - return WABT_OK; + return WabtResult::Ok; } int main(int argc, char** argv) { @@ -815,7 +818,7 @@ int main(int argc, char** argv) { parse_options(argc, argv); - WabtResult result = WABT_OK; + WabtResult result = WabtResult::Ok; size_t i; for (i = 0; i < s_infiles.size; i++) { const char* input_filename = s_infiles.data[i]; @@ -825,7 +828,7 @@ int main(int argc, char** argv) { size_t size; result = wabt_read_file(input_filename, &data, &size); if (WABT_FAILED(result)) - return result; + return result != WabtResult::Ok; WabtLinkerInputBinary* b = wabt_append_binary(&context.inputs); b->data = static_cast<uint8_t*>(data); b->size = size; @@ -837,10 +840,10 @@ int main(int argc, char** argv) { result = perform_link(&context); if (WABT_FAILED(result)) - return result; + return result != WabtResult::Ok; /* Cleanup */ WABT_DESTROY_VECTOR_AND_ELEMENTS(context.inputs, binary); wabt_destroy_string_vector(&s_infiles); - return result; + return result != WabtResult::Ok; } diff --git a/src/tools/wasm2wast.cc b/src/tools/wasm2wast.cc index e55a923b..c2e0271a 100644 --- a/src/tools/wasm2wast.cc +++ b/src/tools/wasm2wast.cc @@ -43,8 +43,8 @@ static WabtBinaryErrorHandler s_error_handler = static WabtFileWriter s_log_stream_writer; static WabtStream s_log_stream; -#define NOPE WABT_OPTION_NO_ARGUMENT -#define YEP WABT_OPTION_HAS_ARGUMENT +#define NOPE WabtHasArgument::No +#define YEP WabtHasArgument::Yes enum { FLAG_VERBOSE, @@ -177,5 +177,5 @@ int main(int argc, char** argv) { } wabt_free(data); } - return result; + return result != WabtResult::Ok; } diff --git a/src/tools/wasmdump.cc b/src/tools/wasmdump.cc index fb8fecf0..be9bd9fd 100644 --- a/src/tools/wasmdump.cc +++ b/src/tools/wasmdump.cc @@ -27,8 +27,8 @@ #define PROGRAM_NAME "wasmdump" -#define NOPE WABT_OPTION_NO_ARGUMENT -#define YEP WABT_OPTION_HAS_ARGUMENT +#define NOPE WabtHasArgument::No +#define YEP WabtHasArgument::Yes enum { FLAG_HEADERS, @@ -148,7 +148,7 @@ int main(int argc, char** argv) { WabtResult result = wabt_read_file(s_objdump_options.infile, &void_data, &size); if (WABT_FAILED(result)) - return result; + return result != WabtResult::Ok; uint8_t* data = static_cast<uint8_t*>(void_data); @@ -165,14 +165,14 @@ int main(int argc, char** argv) { return 1; } - s_objdump_options.mode = WABT_DUMP_PREPASS; + s_objdump_options.mode = WabtObjdumpMode::Prepass; result = wabt_read_binary_objdump(data, size, &s_objdump_options); if (WABT_FAILED(result)) goto done; // Pass 1: Print the section headers if (s_objdump_options.headers) { - s_objdump_options.mode = WABT_DUMP_HEADERS; + s_objdump_options.mode = WabtObjdumpMode::Headers; result = wabt_read_binary_objdump(data, size, &s_objdump_options); if (WABT_FAILED(result)) goto done; @@ -180,14 +180,14 @@ int main(int argc, char** argv) { } // Pass 2: Print extra information based on section type if (s_objdump_options.details) { - s_objdump_options.mode = WABT_DUMP_DETAILS; + s_objdump_options.mode = WabtObjdumpMode::Details; result = wabt_read_binary_objdump(data, size, &s_objdump_options); if (WABT_FAILED(result)) goto done; s_objdump_options.print_header = 0; } if (s_objdump_options.disassemble) { - s_objdump_options.mode = WABT_DUMP_DISASSEMBLE; + s_objdump_options.mode = WabtObjdumpMode::Disassemble; result = wabt_read_binary_objdump(data, size, &s_objdump_options); if (WABT_FAILED(result)) goto done; @@ -195,11 +195,11 @@ int main(int argc, char** argv) { } // Pass 3: Dump to raw contents of the sections if (s_objdump_options.raw) { - s_objdump_options.mode = WABT_DUMP_RAW_DATA; + s_objdump_options.mode = WabtObjdumpMode::RawData; result = wabt_read_binary_objdump(data, size, &s_objdump_options); } done: wabt_free(data); - return result; + return result != WabtResult::Ok; } diff --git a/src/tools/wasmopcodecnt.cc b/src/tools/wasmopcodecnt.cc index 52ec99c3..5fa30c10 100644 --- a/src/tools/wasmopcodecnt.cc +++ b/src/tools/wasmopcodecnt.cc @@ -43,8 +43,8 @@ static WabtReadBinaryOptions s_read_binary_options = static WabtFileWriter s_log_stream_writer; static WabtStream s_log_stream; -#define NOPE WABT_OPTION_NO_ARGUMENT -#define YEP WABT_OPTION_HAS_ARGUMENT +#define NOPE WabtHasArgument::No +#define YEP WabtHasArgument::Yes enum { FLAG_VERBOSE, @@ -143,7 +143,7 @@ typedef int (int_pair_counter_lt_fcn)(WabtIntPairCounter*, WabtIntPairCounter*); typedef void (*display_name_fcn)(FILE* out, intmax_t value); static void display_opcode_name(FILE* out, intmax_t opcode) { - if (opcode >= 0 && opcode < WABT_NUM_OPCODES) + if (opcode >= 0 && opcode < kWabtOpcodeCount) fprintf(out, "%s", wabt_get_opcode_name(static_cast<WabtOpcode>(opcode))); else fprintf(out, "?(%" PRIdMAX ")", opcode); @@ -208,13 +208,13 @@ static int opcode_counter_gt(WabtIntCounter* counter_1, return 0; const char* name_1 = "?1"; const char* name_2 = "?2"; - if (counter_1->value < WABT_NUM_OPCODES) { + if (counter_1->value < kWabtOpcodeCount) { const char* opcode_name = wabt_get_opcode_name(static_cast<WabtOpcode>(counter_1->value)); if (opcode_name) name_1 = opcode_name; } - if (counter_2->value < WABT_NUM_OPCODES) { + if (counter_2->value < kWabtOpcodeCount) { const char* opcode_name = wabt_get_opcode_name(static_cast<WabtOpcode>(counter_2->value)); if (opcode_name) @@ -348,7 +348,7 @@ int main(int argc, char** argv) { out = fopen(s_outfile, "w"); if (!out) ERROR("fopen \"%s\" failed, errno=%d\n", s_outfile, errno); - result = WABT_ERROR; + result = WabtResult::Error; } if (WABT_SUCCEEDED(result)) { WabtOpcntData opcnt_data; @@ -361,27 +361,27 @@ int main(int argc, char** argv) { display_opcode_name, nullptr); display_sorted_int_counter_vector( out, "\ni32.const:", &opcnt_data.i32_const_vec, int_counter_gt, - display_intmax, wabt_get_opcode_name(WABT_OPCODE_I32_CONST)); + display_intmax, wabt_get_opcode_name(WabtOpcode::I32Const)); display_sorted_int_counter_vector( out, "\nget_local:", &opcnt_data.get_local_vec, int_counter_gt, - display_intmax, wabt_get_opcode_name(WABT_OPCODE_GET_LOCAL)); + display_intmax, wabt_get_opcode_name(WabtOpcode::GetLocal)); display_sorted_int_counter_vector( out, "\nset_local:", &opcnt_data.set_local_vec, int_counter_gt, - display_intmax, wabt_get_opcode_name(WABT_OPCODE_SET_LOCAL)); + display_intmax, wabt_get_opcode_name(WabtOpcode::SetLocal)); display_sorted_int_counter_vector( out, "\ntee_local:", &opcnt_data.tee_local_vec, int_counter_gt, - display_intmax, wabt_get_opcode_name(WABT_OPCODE_TEE_LOCAL)); + display_intmax, wabt_get_opcode_name(WabtOpcode::TeeLocal)); display_sorted_int_pair_counter_vector( out, "\ni32.load:", &opcnt_data.i32_load_vec, int_pair_counter_gt, display_intmax, display_intmax, - wabt_get_opcode_name(WABT_OPCODE_I32_LOAD)); + wabt_get_opcode_name(WabtOpcode::I32Load)); display_sorted_int_pair_counter_vector( out, "\ni32.store:", &opcnt_data.i32_store_vec, int_pair_counter_gt, display_intmax, display_intmax, - wabt_get_opcode_name(WABT_OPCODE_I32_STORE)); + wabt_get_opcode_name(WabtOpcode::I32Store)); } wabt_destroy_opcnt_data(&opcnt_data); } wabt_free(data); - return result; + return result != WabtResult::Ok; } diff --git a/src/tools/wast-desugar.cc b/src/tools/wast-desugar.cc index 84813c0e..454ab14a 100644 --- a/src/tools/wast-desugar.cc +++ b/src/tools/wast-desugar.cc @@ -61,11 +61,11 @@ static const char s_description[] = " $ wast-desugar --generate-names test.wast\n"; static WabtOption s_options[] = { - {FLAG_HELP, 'h', "help", nullptr, WABT_OPTION_NO_ARGUMENT, + {FLAG_HELP, 'h', "help", nullptr, WabtHasArgument::No, "print this help message"}, - {FLAG_OUTPUT, 'o', "output", "FILE", WABT_OPTION_HAS_ARGUMENT, + {FLAG_OUTPUT, 'o', "output", "FILE", WabtHasArgument::Yes, "output file for the formatted file"}, - {FLAG_GENERATE_NAMES, 0, "generate-names", nullptr, WABT_OPTION_NO_ARGUMENT, + {FLAG_GENERATE_NAMES, 0, "generate-names", nullptr, WabtHasArgument::No, "Give auto-generated names to non-named functions, types, etc."}, }; WABT_STATIC_ASSERT(NUM_FLAGS == WABT_ARRAY_SIZE(s_options)); @@ -163,6 +163,6 @@ int main(int argc, char** argv) { wabt_destroy_ast_lexer(lexer); wabt_destroy_script(&script); - return result; + return result != WabtResult::Ok; } diff --git a/src/tools/wast2wasm.cc b/src/tools/wast2wasm.cc index e1655d42..5f89f125 100644 --- a/src/tools/wast2wasm.cc +++ b/src/tools/wast2wasm.cc @@ -50,8 +50,8 @@ static WabtSourceErrorHandler s_error_handler = static WabtFileStream s_log_stream; -#define NOPE WABT_OPTION_NO_ARGUMENT -#define YEP WABT_OPTION_HAS_ARGUMENT +#define NOPE WabtHasArgument::No +#define YEP WabtHasArgument::Yes enum { FLAG_VERBOSE, @@ -238,5 +238,5 @@ int main(int argc, char** argv) { wabt_destroy_ast_lexer(lexer); wabt_destroy_script(&script); - return result; + return result != WabtResult::Ok; } diff --git a/src/type-checker.cc b/src/type-checker.cc index 53dcd13c..f0283227 100644 --- a/src/type-checker.cc +++ b/src/type-checker.cc @@ -19,12 +19,13 @@ #define CHECK_RESULT(expr) \ do { \ if (WABT_FAILED(expr)) \ - return WABT_ERROR; \ + return WabtResult::Error; \ } while (0) -#define COMBINE_RESULT(result_var, result) \ - do { \ - (result_var) = static_cast<WabtResult>((result_var) | (result)); \ +#define COMBINE_RESULT(result_var, result) \ + do { \ + (result_var) = static_cast<WabtResult>(static_cast<int>(result_var) | \ + static_cast<int>(result)); \ } while (0) static void WABT_PRINTF_FORMAT(2, 3) @@ -43,10 +44,10 @@ WabtResult wabt_typechecker_get_label(WabtTypeChecker* tc, print_error(tc, "invalid depth: %" PRIzd " (max %" PRIzd ")", depth, tc->label_stack.size - 1); *out_label = nullptr; - return WABT_ERROR; + return WabtResult::Error; } *out_label = &tc->label_stack.data[tc->label_stack.size - depth - 1]; - return WABT_OK; + return WabtResult::Ok; } static WabtResult top_label(WabtTypeChecker* tc, @@ -71,7 +72,7 @@ static WabtResult set_unreachable(WabtTypeChecker* tc) { CHECK_RESULT(top_label(tc, &label)); label->unreachable = true; reset_type_stack_to_label(tc, label); - return WABT_OK; + return WabtResult::Ok; } static void push_label(WabtTypeChecker* tc, @@ -94,12 +95,12 @@ static WabtResult pop_label(WabtTypeChecker* tc) { CHECK_RESULT(top_label(tc, &label)); wabt_destroy_type_checker_label(label); tc->label_stack.size--; - return WABT_OK; + return WabtResult::Ok; } static WabtResult check_label_type(WabtTypeCheckerLabel* label, WabtLabelType label_type) { - return label->label_type == label_type ? WABT_OK : WABT_ERROR; + return label->label_type == label_type ? WabtResult::Ok : WabtResult::Error; } static WabtResult peek_type(WabtTypeChecker* tc, @@ -109,11 +110,11 @@ static WabtResult peek_type(WabtTypeChecker* tc, CHECK_RESULT(top_label(tc, &label)); if (label->type_stack_limit + depth >= tc->type_stack.size) { - *out_type = WABT_TYPE_ANY; - return label->unreachable ? WABT_OK : WABT_ERROR; + *out_type = WabtType::Any; + return label->unreachable ? WabtResult::Ok : WabtResult::Error; } *out_type = tc->type_stack.data[tc->type_stack.size - depth - 1]; - return WABT_OK; + return WabtResult::Ok; } static WabtResult top_type(WabtTypeChecker* tc, WabtType* out_type) { @@ -135,16 +136,16 @@ static WabtResult drop_types(WabtTypeChecker* tc, size_t drop_count) { if (label->type_stack_limit + drop_count > tc->type_stack.size) { if (label->unreachable) { reset_type_stack_to_label(tc, label); - return WABT_OK; + return WabtResult::Ok; } - return WABT_ERROR; + return WabtResult::Error; } tc->type_stack.size -= drop_count; - return WABT_OK; + return WabtResult::Ok; } static void push_type(WabtTypeChecker* tc, WabtType type) { - if (type != WABT_TYPE_VOID) + if (type != WabtType::Void) wabt_append_type_value(&tc->type_stack, &type); } @@ -164,9 +165,9 @@ static WabtResult check_type_stack_limit(WabtTypeChecker* tc, print_error(tc, "type stack size too small at %s. got %" PRIzd ", expected at least %" PRIzd, desc, avail, expected); - return WABT_ERROR; + return WabtResult::Error; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult check_type_stack_end(WabtTypeChecker* tc, const char* desc) { @@ -175,32 +176,32 @@ static WabtResult check_type_stack_end(WabtTypeChecker* tc, const char* desc) { if (tc->type_stack.size != label->type_stack_limit) { print_error(tc, "type stack at end of %s is %" PRIzd ", expected %" PRIzd, desc, tc->type_stack.size, label->type_stack_limit); - return WABT_ERROR; + return WabtResult::Error; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult check_type(WabtTypeChecker* tc, WabtType actual, WabtType expected, const char* desc) { - if (expected != actual && expected != WABT_TYPE_ANY && - actual != WABT_TYPE_ANY) { + if (expected != actual && expected != WabtType::Any && + actual != WabtType::Any) { print_error(tc, "type mismatch in %s, expected %s but got %s.", desc, wabt_get_type_name(expected), wabt_get_type_name(actual)); - return WABT_ERROR; + return WabtResult::Error; } - return WABT_OK; + return WabtResult::Ok; } static WabtResult check_signature(WabtTypeChecker* tc, const WabtTypeVector* sig, const char* desc) { - WabtResult result = WABT_OK; + WabtResult result = WabtResult::Ok; size_t i; COMBINE_RESULT(result, check_type_stack_limit(tc, sig->size, desc)); for (i = 0; i < sig->size; ++i) { - WabtType actual = WABT_TYPE_ANY; + WabtType actual = WabtType::Any; COMBINE_RESULT(result, peek_type(tc, sig->size - i - 1, &actual)); COMBINE_RESULT(result, check_type(tc, actual, sig->data[i], desc)); } @@ -210,7 +211,7 @@ static WabtResult check_signature(WabtTypeChecker* tc, static WabtResult pop_and_check_signature(WabtTypeChecker* tc, const WabtTypeVector* sig, const char* desc) { - WabtResult result = WABT_OK; + WabtResult result = WabtResult::Ok; COMBINE_RESULT(result, check_signature(tc, sig, desc)); COMBINE_RESULT(result, drop_types(tc, sig->size)); return result; @@ -220,11 +221,11 @@ static WabtResult pop_and_check_call(WabtTypeChecker* tc, const WabtTypeVector* param_types, const WabtTypeVector* result_types, const char* desc) { - WabtResult result = WABT_OK; + WabtResult result = WabtResult::Ok; size_t i; COMBINE_RESULT(result, check_type_stack_limit(tc, param_types->size, desc)); for (i = 0; i < param_types->size; ++i) { - WabtType actual = WABT_TYPE_ANY; + WabtType actual = WabtType::Any; COMBINE_RESULT(result, peek_type(tc, param_types->size - i - 1, &actual)); COMBINE_RESULT(result, check_type(tc, actual, param_types->data[i], desc)); } @@ -236,8 +237,8 @@ static WabtResult pop_and_check_call(WabtTypeChecker* tc, static WabtResult pop_and_check_1_type(WabtTypeChecker* tc, WabtType expected, const char* desc) { - WabtResult result = WABT_OK; - WabtType actual = WABT_TYPE_ANY; + WabtResult result = WabtResult::Ok; + WabtType actual = WabtType::Any; COMBINE_RESULT(result, check_type_stack_limit(tc, 1, desc)); COMBINE_RESULT(result, pop_type(tc, &actual)); COMBINE_RESULT(result, check_type(tc, actual, expected, desc)); @@ -248,9 +249,9 @@ static WabtResult pop_and_check_2_types(WabtTypeChecker* tc, WabtType expected1, WabtType expected2, const char* desc) { - WabtResult result = WABT_OK; - WabtType actual1 = WABT_TYPE_ANY; - WabtType actual2 = WABT_TYPE_ANY; + WabtResult result = WabtResult::Ok; + WabtType actual1 = WabtType::Any; + WabtType actual2 = WabtType::Any; COMBINE_RESULT(result, check_type_stack_limit(tc, 2, desc)); COMBINE_RESULT(result, pop_type(tc, &actual2)); COMBINE_RESULT(result, pop_type(tc, &actual1)); @@ -262,9 +263,9 @@ static WabtResult pop_and_check_2_types(WabtTypeChecker* tc, static WabtResult pop_and_check_2_types_are_equal(WabtTypeChecker* tc, WabtType* out_type, const char* desc) { - WabtResult result = WABT_OK; - WabtType right = WABT_TYPE_ANY; - WabtType left = WABT_TYPE_ANY; + WabtResult result = WabtResult::Ok; + WabtType right = WabtType::Any; + WabtType left = WabtType::Any; COMBINE_RESULT(result, check_type_stack_limit(tc, 2, desc)); COMBINE_RESULT(result, pop_type(tc, &right)); COMBINE_RESULT(result, pop_type(tc, &left)); @@ -297,8 +298,8 @@ WabtResult wabt_typechecker_begin_function(WabtTypeChecker* tc, const WabtTypeVector* sig) { tc->type_stack.size = 0; tc->label_stack.size = 0; - push_label(tc, WABT_LABEL_TYPE_FUNC, sig); - return WABT_OK; + push_label(tc, WabtLabelType::Func, sig); + return WabtResult::Ok; } WabtResult wabt_typechecker_on_binary(WabtTypeChecker* tc, WabtOpcode opcode) { @@ -307,48 +308,48 @@ WabtResult wabt_typechecker_on_binary(WabtTypeChecker* tc, WabtOpcode opcode) { WabtResult wabt_typechecker_on_block(WabtTypeChecker* tc, const WabtTypeVector* sig) { - push_label(tc, WABT_LABEL_TYPE_BLOCK, sig); - return WABT_OK; + push_label(tc, WabtLabelType::Block, sig); + return WabtResult::Ok; } WabtResult wabt_typechecker_on_br(WabtTypeChecker* tc, size_t depth) { - WabtResult result = WABT_OK; + WabtResult result = WabtResult::Ok; WabtTypeCheckerLabel* label; CHECK_RESULT(wabt_typechecker_get_label(tc, depth, &label)); - if (label->label_type != WABT_LABEL_TYPE_LOOP) + if (label->label_type != WabtLabelType::Loop) COMBINE_RESULT(result, check_signature(tc, &label->sig, "br")); CHECK_RESULT(set_unreachable(tc)); return result; } WabtResult wabt_typechecker_on_br_if(WabtTypeChecker* tc, size_t depth) { - WabtResult result = WABT_OK; - COMBINE_RESULT(result, pop_and_check_1_type(tc, WABT_TYPE_I32, "br_if")); + WabtResult result = WabtResult::Ok; + COMBINE_RESULT(result, pop_and_check_1_type(tc, WabtType::I32, "br_if")); WabtTypeCheckerLabel* label; CHECK_RESULT(wabt_typechecker_get_label(tc, depth, &label)); - if (label->label_type != WABT_LABEL_TYPE_LOOP) + if (label->label_type != WabtLabelType::Loop) COMBINE_RESULT(result, check_signature(tc, &label->sig, "br_if")); return result; } WabtResult wabt_typechecker_begin_br_table(WabtTypeChecker* tc) { - tc->br_table_sig = WABT_TYPE_ANY; - return pop_and_check_1_type(tc, WABT_TYPE_I32, "br_table"); + tc->br_table_sig = WabtType::Any; + return pop_and_check_1_type(tc, WabtType::I32, "br_table"); } WabtResult wabt_typechecker_on_br_table_target(WabtTypeChecker* tc, size_t depth) { - WabtResult result = WABT_OK; + WabtResult result = WabtResult::Ok; WabtTypeCheckerLabel* label; CHECK_RESULT(wabt_typechecker_get_label(tc, depth, &label)); assert(label->sig.size <= 1); WabtType label_sig = - label->sig.size == 0 ? WABT_TYPE_VOID : label->sig.data[0]; + label->sig.size == 0 ? WabtType::Void : label->sig.data[0]; COMBINE_RESULT(result, check_type(tc, tc->br_table_sig, label_sig, "br_table")); tc->br_table_sig = label_sig; - if (label->label_type != WABT_LABEL_TYPE_LOOP) + if (label->label_type != WabtLabelType::Loop) COMBINE_RESULT(result, check_signature(tc, &label->sig, "br_table")); return result; } @@ -367,9 +368,9 @@ WabtResult wabt_typechecker_on_call_indirect( WabtTypeChecker* tc, const WabtTypeVector* param_types, const WabtTypeVector* result_types) { - WabtResult result = WABT_OK; + WabtResult result = WabtResult::Ok; COMBINE_RESULT(result, - pop_and_check_1_type(tc, WABT_TYPE_I32, "call_indirect")); + pop_and_check_1_type(tc, WabtType::I32, "call_indirect")); COMBINE_RESULT(result, pop_and_check_call(tc, param_types, result_types, "call_indirect")); return result; @@ -381,7 +382,7 @@ WabtResult wabt_typechecker_on_compare(WabtTypeChecker* tc, WabtOpcode opcode) { WabtResult wabt_typechecker_on_const(WabtTypeChecker* tc, WabtType type) { push_type(tc, type); - return WABT_OK; + return WabtResult::Ok; } WabtResult wabt_typechecker_on_convert(WabtTypeChecker* tc, WabtOpcode opcode) { @@ -389,28 +390,28 @@ WabtResult wabt_typechecker_on_convert(WabtTypeChecker* tc, WabtOpcode opcode) { } WabtResult wabt_typechecker_on_current_memory(WabtTypeChecker* tc) { - push_type(tc, WABT_TYPE_I32); - return WABT_OK; + push_type(tc, WabtType::I32); + return WabtResult::Ok; } WabtResult wabt_typechecker_on_drop(WabtTypeChecker* tc) { - WabtResult result = WABT_OK; - WabtType type = WABT_TYPE_ANY; + WabtResult result = WabtResult::Ok; + WabtType type = WabtType::Any; COMBINE_RESULT(result, check_type_stack_limit(tc, 1, "drop")); COMBINE_RESULT(result, pop_type(tc, &type)); return result; } WabtResult wabt_typechecker_on_else(WabtTypeChecker* tc) { - WabtResult result = WABT_OK; + WabtResult result = WabtResult::Ok; WabtTypeCheckerLabel* label; CHECK_RESULT(top_label(tc, &label)); - COMBINE_RESULT(result, check_label_type(label, WABT_LABEL_TYPE_IF)); + COMBINE_RESULT(result, check_label_type(label, WabtLabelType::If)); COMBINE_RESULT(result, pop_and_check_signature(tc, &label->sig, "if true branch")); COMBINE_RESULT(result, check_type_stack_end(tc, "if true branch")); reset_type_stack_to_label(tc, label); - label->label_type = WABT_LABEL_TYPE_ELSE; + label->label_type = WabtLabelType::Else; label->unreachable = false; return result; } @@ -419,7 +420,7 @@ static WabtResult on_end(WabtTypeChecker* tc, WabtTypeCheckerLabel* label, const char* sig_desc, const char* end_desc) { - WabtResult result = WABT_OK; + WabtResult result = WabtResult::Ok; COMBINE_RESULT(result, pop_and_check_signature(tc, &label->sig, sig_desc)); COMBINE_RESULT(result, check_type_stack_end(tc, end_desc)); reset_type_stack_to_label(tc, label); @@ -429,44 +430,43 @@ static WabtResult on_end(WabtTypeChecker* tc, } WabtResult wabt_typechecker_on_end(WabtTypeChecker* tc) { - WabtResult result = WABT_OK; + WabtResult result = WabtResult::Ok; static const char* s_label_type_name[] = {"function", "block", "loop", "if", "if false branch"}; - WABT_STATIC_ASSERT(WABT_ARRAY_SIZE(s_label_type_name) == - WABT_NUM_LABEL_TYPES); + WABT_STATIC_ASSERT(WABT_ARRAY_SIZE(s_label_type_name) == kWabtLabelTypeCount); WabtTypeCheckerLabel* label; CHECK_RESULT(top_label(tc, &label)); - assert(label->label_type < WABT_NUM_LABEL_TYPES); - if (label->label_type == WABT_LABEL_TYPE_IF) { + assert(static_cast<int>(label->label_type) < kWabtLabelTypeCount); + if (label->label_type == WabtLabelType::If) { if (label->sig.size != 0) { print_error(tc, "if without else cannot have type signature."); - result = WABT_ERROR; + result = WabtResult::Error; } } - const char* desc = s_label_type_name[label->label_type]; + const char* desc = s_label_type_name[static_cast<int>(label->label_type)]; COMBINE_RESULT(result, on_end(tc, label, desc, desc)); return result; } WabtResult wabt_typechecker_on_grow_memory(WabtTypeChecker* tc) { - return check_opcode1(tc, WABT_OPCODE_GROW_MEMORY); + return check_opcode1(tc, WabtOpcode::GrowMemory); } WabtResult wabt_typechecker_on_if(WabtTypeChecker* tc, const WabtTypeVector* sig) { - WabtResult result = pop_and_check_1_type(tc, WABT_TYPE_I32, "if"); - push_label(tc, WABT_LABEL_TYPE_IF, sig); + WabtResult result = pop_and_check_1_type(tc, WabtType::I32, "if"); + push_label(tc, WabtLabelType::If, sig); return result; } WabtResult wabt_typechecker_on_get_global(WabtTypeChecker* tc, WabtType type) { push_type(tc, type); - return WABT_OK; + return WabtResult::Ok; } WabtResult wabt_typechecker_on_get_local(WabtTypeChecker* tc, WabtType type) { push_type(tc, type); - return WABT_OK; + return WabtResult::Ok; } WabtResult wabt_typechecker_on_load(WabtTypeChecker* tc, WabtOpcode opcode) { @@ -475,12 +475,12 @@ WabtResult wabt_typechecker_on_load(WabtTypeChecker* tc, WabtOpcode opcode) { WabtResult wabt_typechecker_on_loop(WabtTypeChecker* tc, const WabtTypeVector* sig) { - push_label(tc, WABT_LABEL_TYPE_LOOP, sig); - return WABT_OK; + push_label(tc, WabtLabelType::Loop, sig); + return WabtResult::Ok; } WabtResult wabt_typechecker_on_return(WabtTypeChecker* tc) { - WabtResult result = WABT_OK; + WabtResult result = WabtResult::Ok; WabtTypeCheckerLabel* func_label; CHECK_RESULT( wabt_typechecker_get_label(tc, tc->label_stack.size - 1, &func_label)); @@ -491,9 +491,9 @@ WabtResult wabt_typechecker_on_return(WabtTypeChecker* tc) { } WabtResult wabt_typechecker_on_select(WabtTypeChecker* tc) { - WabtResult result = WABT_OK; - COMBINE_RESULT(result, pop_and_check_1_type(tc, WABT_TYPE_I32, "select")); - WabtType type = WABT_TYPE_ANY; + WabtResult result = WabtResult::Ok; + COMBINE_RESULT(result, pop_and_check_1_type(tc, WabtType::I32, "select")); + WabtType type = WabtType::Any; COMBINE_RESULT(result, pop_and_check_2_types_are_equal(tc, &type, "select")); push_type(tc, type); return result; @@ -512,8 +512,8 @@ WabtResult wabt_typechecker_on_store(WabtTypeChecker* tc, WabtOpcode opcode) { } WabtResult wabt_typechecker_on_tee_local(WabtTypeChecker* tc, WabtType type) { - WabtResult result = WABT_OK; - WabtType value = WABT_TYPE_ANY; + WabtResult result = WabtResult::Ok; + WabtType value = WabtType::Any; COMBINE_RESULT(result, check_type_stack_limit(tc, 1, "tee_local")); COMBINE_RESULT(result, top_type(tc, &value)); COMBINE_RESULT(result, check_type(tc, value, type, "tee_local")); @@ -529,10 +529,10 @@ WabtResult wabt_typechecker_on_unreachable(WabtTypeChecker* tc) { } WabtResult wabt_typechecker_end_function(WabtTypeChecker* tc) { - WabtResult result = WABT_OK; + WabtResult result = WabtResult::Ok; WabtTypeCheckerLabel* label; CHECK_RESULT(top_label(tc, &label)); - COMBINE_RESULT(result, check_label_type(label, WABT_LABEL_TYPE_FUNC)); + COMBINE_RESULT(result, check_label_type(label, WabtLabelType::Func)); COMBINE_RESULT(result, on_end(tc, label, "implicit return", "function")); return result; } diff --git a/src/validator.cc b/src/validator.cc index 587e19a9..4238daa9 100644 --- a/src/validator.cc +++ b/src/validator.cc @@ -28,10 +28,10 @@ #include "binary-reader.h" #include "type-checker.h" -enum ActionResultKind { - ACTION_RESULT_KIND_ERROR, - ACTION_RESULT_KIND_TYPES, - ACTION_RESULT_KIND_TYPE, +enum class ActionResultKind { + Error, + Types, + Type, }; struct ActionResult { @@ -59,7 +59,7 @@ struct Context { static void WABT_PRINTF_FORMAT(3, 4) print_error(Context* ctx, const WabtLocation* loc, const char* fmt, ...) { - ctx->result = WABT_ERROR; + ctx->result = WabtResult::Error; va_list args; va_start(args, fmt); wabt_ast_format_error(ctx->error_handler, loc, ctx->lexer, fmt, args); @@ -86,15 +86,15 @@ static WabtResult check_var(Context* ctx, const WabtVar* var, const char* desc, int* out_index) { - assert(var->type == WABT_VAR_TYPE_INDEX); + assert(var->type == WabtVarType::Index); if (var->index >= 0 && var->index < max_index) { if (out_index) *out_index = var->index; - return WABT_OK; + return WabtResult::Ok; } print_error(ctx, &var->loc, "%s variable out of range (max %d)", desc, max_index); - return WABT_ERROR; + return WabtResult::Error; } static WabtResult check_func_var(Context* ctx, @@ -103,12 +103,12 @@ static WabtResult check_func_var(Context* ctx, int index; if (WABT_FAILED(check_var(ctx, ctx->current_module->funcs.size, var, "function", &index))) { - return WABT_ERROR; + return WabtResult::Error; } if (out_func) *out_func = ctx->current_module->funcs.data[index]; - return WABT_OK; + return WabtResult::Ok; } static WabtResult check_global_var(Context* ctx, @@ -118,21 +118,21 @@ static WabtResult check_global_var(Context* ctx, int index; if (WABT_FAILED(check_var(ctx, ctx->current_module->globals.size, var, "global", &index))) { - return WABT_ERROR; + return WabtResult::Error; } if (out_global) *out_global = ctx->current_module->globals.data[index]; if (out_global_index) *out_global_index = index; - return WABT_OK; + return WabtResult::Ok; } static WabtType get_global_var_type_or_any(Context* ctx, const WabtVar* var) { const WabtGlobal* global; if (WABT_SUCCEEDED(check_global_var(ctx, var, &global, nullptr))) return global->type; - return WABT_TYPE_ANY; + return WabtType::Any; } static WabtResult check_func_type_var(Context* ctx, @@ -141,12 +141,12 @@ static WabtResult check_func_type_var(Context* ctx, int index; if (WABT_FAILED(check_var(ctx, ctx->current_module->func_types.size, var, "function type", &index))) { - return WABT_ERROR; + return WabtResult::Error; } if (out_func_type) *out_func_type = ctx->current_module->func_types.data[index]; - return WABT_OK; + return WabtResult::Ok; } static WabtResult check_table_var(Context* ctx, @@ -155,12 +155,12 @@ static WabtResult check_table_var(Context* ctx, int index; if (WABT_FAILED(check_var(ctx, ctx->current_module->tables.size, var, "table", &index))) { - return WABT_ERROR; + return WabtResult::Error; } if (out_table) *out_table = ctx->current_module->tables.data[index]; - return WABT_OK; + return WabtResult::Ok; } static WabtResult check_memory_var(Context* ctx, @@ -169,12 +169,12 @@ static WabtResult check_memory_var(Context* ctx, int index; if (WABT_FAILED(check_var(ctx, ctx->current_module->memories.size, var, "memory", &index))) { - return WABT_ERROR; + return WabtResult::Error; } if (out_memory) *out_memory = ctx->current_module->memories.data[index]; - return WABT_OK; + return WabtResult::Ok; } static WabtResult check_local_var(Context* ctx, @@ -192,10 +192,10 @@ static WabtResult check_local_var(Context* ctx, *out_type = ctx->current_func->local_types.data[index - num_params]; } } - return WABT_OK; + return WabtResult::Ok; } - if (var->type == WABT_VAR_TYPE_NAME) { + if (var->type == WabtVarType::Name) { print_error(ctx, &var->loc, "undefined local variable \"" PRIstringslice "\"", WABT_PRINTF_STRING_SLICE_ARG(var->name)); @@ -203,11 +203,11 @@ static WabtResult check_local_var(Context* ctx, print_error(ctx, &var->loc, "local variable out of range (max %d)", max_index); } - return WABT_ERROR; + return WabtResult::Error; } static WabtType get_local_var_type_or_any(Context* ctx, const WabtVar* var) { - WabtType type = WABT_TYPE_ANY; + WabtType type = WabtType::Any; check_local_var(ctx, var, &type); return type; } @@ -253,8 +253,8 @@ static void check_type_index(Context* ctx, const char* desc, int index, const char* index_kind) { - if (expected != actual && expected != WABT_TYPE_ANY && - actual != WABT_TYPE_ANY) { + if (expected != actual && expected != WabtType::Any && + actual != WabtType::Any) { print_error(ctx, loc, "type mismatch for %s %d of %s. got %s, expected %s", index_kind, index, desc, wabt_get_type_name(actual), wabt_get_type_name(expected)); @@ -303,7 +303,7 @@ static void check_const_type(Context* ctx, const char* desc) { WabtTypeVector actual_types; WABT_ZERO_MEMORY(actual_types); - actual_types.size = actual == WABT_TYPE_VOID ? 0 : 1; + actual_types.size = actual == WabtType::Void ? 0 : 1; actual_types.data = &actual; check_const_types(ctx, loc, &actual_types, expected, desc); } @@ -314,7 +314,7 @@ static void check_assert_return_nan_type(Context* ctx, const char* desc) { /* when using assert_return_nan, the result can be either a f32 or f64 type * so we special case it here. */ - if (actual != WABT_TYPE_F32 && actual != WABT_TYPE_F64) { + if (actual != WabtType::F32 && actual != WabtType::F64) { print_error(ctx, loc, "type mismatch at %s. got %s, expected f32 or f64", desc, wabt_get_type_name(actual)); } @@ -345,25 +345,25 @@ static void check_expr(Context* ctx, const WabtExpr* expr) { ctx->expr_loc = &expr->loc; switch (expr->type) { - case WABT_EXPR_TYPE_BINARY: + case WabtExprType::Binary: wabt_typechecker_on_binary(&ctx->typechecker, expr->binary.opcode); break; - case WABT_EXPR_TYPE_BLOCK: + case WabtExprType::Block: wabt_typechecker_on_block(&ctx->typechecker, &expr->block.sig); check_expr_list(ctx, &expr->loc, expr->block.first); wabt_typechecker_on_end(&ctx->typechecker); break; - case WABT_EXPR_TYPE_BR: + case WabtExprType::Br: wabt_typechecker_on_br(&ctx->typechecker, expr->br.var.index); break; - case WABT_EXPR_TYPE_BR_IF: + case WabtExprType::BrIf: wabt_typechecker_on_br_if(&ctx->typechecker, expr->br_if.var.index); break; - case WABT_EXPR_TYPE_BR_TABLE: { + case WabtExprType::BrTable: { wabt_typechecker_begin_br_table(&ctx->typechecker); size_t i; for (i = 0; i < expr->br_table.targets.size; ++i) { @@ -376,7 +376,7 @@ static void check_expr(Context* ctx, const WabtExpr* expr) { break; } - case WABT_EXPR_TYPE_CALL: { + case WabtExprType::Call: { const WabtFunc* callee; if (WABT_SUCCEEDED(check_func_var(ctx, &expr->call.var, &callee))) { wabt_typechecker_on_call(&ctx->typechecker, @@ -386,7 +386,7 @@ static void check_expr(Context* ctx, const WabtExpr* expr) { break; } - case WABT_EXPR_TYPE_CALL_INDIRECT: { + case WabtExprType::CallIndirect: { const WabtFuncType* func_type; if (ctx->current_module->tables.size == 0) { print_error(ctx, &expr->loc, @@ -401,40 +401,40 @@ static void check_expr(Context* ctx, const WabtExpr* expr) { break; } - case WABT_EXPR_TYPE_COMPARE: + case WabtExprType::Compare: wabt_typechecker_on_compare(&ctx->typechecker, expr->compare.opcode); break; - case WABT_EXPR_TYPE_CONST: + case WabtExprType::Const: wabt_typechecker_on_const(&ctx->typechecker, expr->const_.type); break; - case WABT_EXPR_TYPE_CONVERT: + case WabtExprType::Convert: wabt_typechecker_on_convert(&ctx->typechecker, expr->convert.opcode); break; - case WABT_EXPR_TYPE_DROP: + case WabtExprType::Drop: wabt_typechecker_on_drop(&ctx->typechecker); break; - case WABT_EXPR_TYPE_GET_GLOBAL: + case WabtExprType::GetGlobal: wabt_typechecker_on_get_global( &ctx->typechecker, get_global_var_type_or_any(ctx, &expr->get_global.var)); break; - case WABT_EXPR_TYPE_GET_LOCAL: + case WabtExprType::GetLocal: wabt_typechecker_on_get_local( &ctx->typechecker, get_local_var_type_or_any(ctx, &expr->get_local.var)); break; - case WABT_EXPR_TYPE_GROW_MEMORY: - check_has_memory(ctx, &expr->loc, WABT_OPCODE_GROW_MEMORY); + case WabtExprType::GrowMemory: + check_has_memory(ctx, &expr->loc, WabtOpcode::GrowMemory); wabt_typechecker_on_grow_memory(&ctx->typechecker); break; - case WABT_EXPR_TYPE_IF: + case WabtExprType::If: wabt_typechecker_on_if(&ctx->typechecker, &expr->if_.true_.sig); check_expr_list(ctx, &expr->loc, expr->if_.true_.first); if (expr->if_.false_) { @@ -444,7 +444,7 @@ static void check_expr(Context* ctx, const WabtExpr* expr) { wabt_typechecker_on_end(&ctx->typechecker); break; - case WABT_EXPR_TYPE_LOAD: + case WabtExprType::Load: check_has_memory(ctx, &expr->loc, expr->load.opcode); check_align(ctx, &expr->loc, expr->load.align, get_opcode_natural_alignment(expr->load.opcode)); @@ -452,41 +452,41 @@ static void check_expr(Context* ctx, const WabtExpr* expr) { wabt_typechecker_on_load(&ctx->typechecker, expr->load.opcode); break; - case WABT_EXPR_TYPE_LOOP: + case WabtExprType::Loop: wabt_typechecker_on_loop(&ctx->typechecker, &expr->loop.sig); check_expr_list(ctx, &expr->loc, expr->loop.first); wabt_typechecker_on_end(&ctx->typechecker); break; - case WABT_EXPR_TYPE_CURRENT_MEMORY: - check_has_memory(ctx, &expr->loc, WABT_OPCODE_CURRENT_MEMORY); + case WabtExprType::CurrentMemory: + check_has_memory(ctx, &expr->loc, WabtOpcode::CurrentMemory); wabt_typechecker_on_current_memory(&ctx->typechecker); break; - case WABT_EXPR_TYPE_NOP: + case WabtExprType::Nop: break; - case WABT_EXPR_TYPE_RETURN: + case WabtExprType::Return: wabt_typechecker_on_return(&ctx->typechecker); break; - case WABT_EXPR_TYPE_SELECT: + case WabtExprType::Select: wabt_typechecker_on_select(&ctx->typechecker); break; - case WABT_EXPR_TYPE_SET_GLOBAL: + case WabtExprType::SetGlobal: wabt_typechecker_on_set_global( &ctx->typechecker, get_global_var_type_or_any(ctx, &expr->set_global.var)); break; - case WABT_EXPR_TYPE_SET_LOCAL: + case WabtExprType::SetLocal: wabt_typechecker_on_set_local( &ctx->typechecker, get_local_var_type_or_any(ctx, &expr->set_local.var)); break; - case WABT_EXPR_TYPE_STORE: + case WabtExprType::Store: check_has_memory(ctx, &expr->loc, expr->store.opcode); check_align(ctx, &expr->loc, expr->store.align, get_opcode_natural_alignment(expr->store.opcode)); @@ -494,17 +494,17 @@ static void check_expr(Context* ctx, const WabtExpr* expr) { wabt_typechecker_on_store(&ctx->typechecker, expr->store.opcode); break; - case WABT_EXPR_TYPE_TEE_LOCAL: + case WabtExprType::TeeLocal: wabt_typechecker_on_tee_local( &ctx->typechecker, get_local_var_type_or_any(ctx, &expr->tee_local.var)); break; - case WABT_EXPR_TYPE_UNARY: + case WabtExprType::Unary: wabt_typechecker_on_unary(&ctx->typechecker, expr->unary.opcode); break; - case WABT_EXPR_TYPE_UNREACHABLE: + case WabtExprType::Unreachable: wabt_typechecker_on_unreachable(&ctx->typechecker); break; } @@ -561,7 +561,7 @@ static void check_const_init_expr(Context* ctx, const WabtExpr* expr, WabtType expected_type, const char* desc) { - WabtType type = WABT_TYPE_VOID; + WabtType type = WabtType::Void; if (expr) { if (expr->next) { print_const_expr_error(ctx, loc, desc); @@ -569,11 +569,11 @@ static void check_const_init_expr(Context* ctx, } switch (expr->type) { - case WABT_EXPR_TYPE_CONST: + case WabtExprType::Const: type = expr->const_.type; break; - case WABT_EXPR_TYPE_GET_GLOBAL: { + case WabtExprType::GetGlobal: { const WabtGlobal* ref_global = nullptr; int ref_global_index; if (WABT_FAILED(check_global_var(ctx, &expr->get_global.var, @@ -652,7 +652,7 @@ static void check_table(Context* ctx, static void check_elem_segments(Context* ctx, const WabtModule* module) { WabtModuleField* field; for (field = module->first_field; field; field = field->next) { - if (field->type != WABT_MODULE_FIELD_TYPE_ELEM_SEGMENT) + if (field->type != WabtModuleFieldType::ElemSegment) continue; WabtElemSegment* elem_segment = &field->elem_segment; @@ -668,7 +668,7 @@ static void check_elem_segments(Context* ctx, const WabtModule* module) { continue; } - check_const_init_expr(ctx, &field->loc, elem_segment->offset, WABT_TYPE_I32, + check_const_init_expr(ctx, &field->loc, elem_segment->offset, WabtType::I32, "elem segment offset"); } } @@ -684,7 +684,7 @@ static void check_memory(Context* ctx, static void check_data_segments(Context* ctx, const WabtModule* module) { WabtModuleField* field; for (field = module->first_field; field; field = field->next) { - if (field->type != WABT_MODULE_FIELD_TYPE_DATA_SEGMENT) + if (field->type != WabtModuleFieldType::DataSegment) continue; WabtDataSegment* data_segment = &field->data_segment; @@ -693,7 +693,7 @@ static void check_data_segments(Context* ctx, const WabtModule* module) { check_memory_var(ctx, &data_segment->memory_var, &memory))) continue; - check_const_init_expr(ctx, &field->loc, data_segment->offset, WABT_TYPE_I32, + check_const_init_expr(ctx, &field->loc, data_segment->offset, WabtType::I32, "data segment offset"); } } @@ -702,43 +702,40 @@ static void check_import(Context* ctx, const WabtLocation* loc, const WabtImport* import) { switch (import->kind) { - case WABT_EXTERNAL_KIND_FUNC: + case WabtExternalKind::Func: if (wabt_decl_has_func_type(&import->func.decl)) check_func_type_var(ctx, &import->func.decl.type_var, nullptr); break; - case WABT_EXTERNAL_KIND_TABLE: + case WabtExternalKind::Table: check_table(ctx, loc, &import->table); ctx->current_table_index++; break; - case WABT_EXTERNAL_KIND_MEMORY: + case WabtExternalKind::Memory: check_memory(ctx, loc, &import->memory); ctx->current_memory_index++; break; - case WABT_EXTERNAL_KIND_GLOBAL: + case WabtExternalKind::Global: if (import->global.mutable_) { print_error(ctx, loc, "mutable globals cannot be imported"); } ctx->num_imported_globals++; ctx->current_global_index++; break; - case WABT_NUM_EXTERNAL_KINDS: - assert(0); - break; } } static void check_export(Context* ctx, const WabtExport* export_) { switch (export_->kind) { - case WABT_EXTERNAL_KIND_FUNC: + case WabtExternalKind::Func: check_func_var(ctx, &export_->var, nullptr); break; - case WABT_EXTERNAL_KIND_TABLE: + case WabtExternalKind::Table: check_table_var(ctx, &export_->var, nullptr); break; - case WABT_EXTERNAL_KIND_MEMORY: + case WabtExternalKind::Memory: check_memory_var(ctx, &export_->var, nullptr); break; - case WABT_EXTERNAL_KIND_GLOBAL: { + case WabtExternalKind::Global: { const WabtGlobal* global; if (WABT_SUCCEEDED( check_global_var(ctx, &export_->var, &global, nullptr))) { @@ -749,9 +746,6 @@ static void check_export(Context* ctx, const WabtExport* export_) { } break; } - case WABT_NUM_EXTERNAL_KINDS: - assert(0); - break; } } @@ -785,45 +779,45 @@ static void check_module(Context* ctx, const WabtModule* module) { WabtModuleField* field; for (field = module->first_field; field; field = field->next) { switch (field->type) { - case WABT_MODULE_FIELD_TYPE_FUNC: + case WabtModuleFieldType::Func: check_func(ctx, &field->loc, &field->func); break; - case WABT_MODULE_FIELD_TYPE_GLOBAL: + case WabtModuleFieldType::Global: check_global(ctx, &field->loc, &field->global); ctx->current_global_index++; break; - case WABT_MODULE_FIELD_TYPE_IMPORT: + case WabtModuleFieldType::Import: check_import(ctx, &field->loc, &field->import); break; - case WABT_MODULE_FIELD_TYPE_EXPORT: + case WabtModuleFieldType::Export: check_export(ctx, &field->export_); break; - case WABT_MODULE_FIELD_TYPE_TABLE: + case WabtModuleFieldType::Table: check_table(ctx, &field->loc, &field->table); ctx->current_table_index++; break; - case WABT_MODULE_FIELD_TYPE_ELEM_SEGMENT: + case WabtModuleFieldType::ElemSegment: /* checked below */ break; - case WABT_MODULE_FIELD_TYPE_MEMORY: + case WabtModuleFieldType::Memory: check_memory(ctx, &field->loc, &field->memory); ctx->current_memory_index++; break; - case WABT_MODULE_FIELD_TYPE_DATA_SEGMENT: + case WabtModuleFieldType::DataSegment: /* checked below */ break; - case WABT_MODULE_FIELD_TYPE_FUNC_TYPE: + case WabtModuleFieldType::FuncType: break; - case WABT_MODULE_FIELD_TYPE_START: { + case WabtModuleFieldType::Start: { if (seen_start) { print_error(ctx, &field->loc, "only one start function allowed"); } @@ -905,7 +899,7 @@ static WabtResult check_get(Context* ctx, wabt_get_module_by_var(ctx->script, &action->module_var); if (!module) { print_error(ctx, &action->loc, "unknown module"); - return WABT_ERROR; + return WabtResult::Error; } WabtExport* export_ = wabt_get_export_by_name(module, &get->name); @@ -913,17 +907,17 @@ static WabtResult check_get(Context* ctx, print_error(ctx, &action->loc, "unknown global export \"" PRIstringslice "\"", WABT_PRINTF_STRING_SLICE_ARG(get->name)); - return WABT_ERROR; + return WabtResult::Error; } WabtGlobal* global = wabt_get_global_by_var(module, &export_->var); if (!global) { /* this error will have already been reported, just skip it */ - return WABT_ERROR; + return WabtResult::Error; } *out_type = global->type; - return WABT_OK; + return WabtResult::Ok; } static ActionResult check_action(Context* ctx, const WabtAction* action) { @@ -931,17 +925,17 @@ static ActionResult check_action(Context* ctx, const WabtAction* action) { WABT_ZERO_MEMORY(result); switch (action->type) { - case WABT_ACTION_TYPE_INVOKE: + case WabtActionType::Invoke: result.types = check_invoke(ctx, action); result.kind = - result.types ? ACTION_RESULT_KIND_TYPES : ACTION_RESULT_KIND_ERROR; + result.types ? ActionResultKind::Types : ActionResultKind::Error; break; - case WABT_ACTION_TYPE_GET: + case WabtActionType::Get: if (WABT_SUCCEEDED(check_get(ctx, action, &result.type))) - result.kind = ACTION_RESULT_KIND_TYPE; + result.kind = ActionResultKind::Type; else - result.kind = ACTION_RESULT_KIND_ERROR; + result.kind = ActionResultKind::Error; break; } @@ -950,79 +944,74 @@ static ActionResult check_action(Context* ctx, const WabtAction* action) { static void check_command(Context* ctx, const WabtCommand* command) { switch (command->type) { - case WABT_COMMAND_TYPE_MODULE: + case WabtCommandType::Module: check_module(ctx, &command->module); break; - case WABT_COMMAND_TYPE_ACTION: + case WabtCommandType::Action: /* ignore result type */ check_action(ctx, &command->action); break; - case WABT_COMMAND_TYPE_REGISTER: - case WABT_COMMAND_TYPE_ASSERT_MALFORMED: - case WABT_COMMAND_TYPE_ASSERT_INVALID: - case WABT_COMMAND_TYPE_ASSERT_INVALID_NON_BINARY: - case WABT_COMMAND_TYPE_ASSERT_UNLINKABLE: - case WABT_COMMAND_TYPE_ASSERT_UNINSTANTIABLE: + case WabtCommandType::Register: + case WabtCommandType::AssertMalformed: + case WabtCommandType::AssertInvalid: + case WabtCommandType::AssertInvalidNonBinary: + case WabtCommandType::AssertUnlinkable: + case WabtCommandType::AssertUninstantiable: /* ignore */ break; - case WABT_COMMAND_TYPE_ASSERT_RETURN: { + case WabtCommandType::AssertReturn: { const WabtAction* action = &command->assert_return.action; ActionResult result = check_action(ctx, action); switch (result.kind) { - case ACTION_RESULT_KIND_TYPES: + case ActionResultKind::Types: check_const_types(ctx, &action->loc, result.types, &command->assert_return.expected, "action"); break; - case ACTION_RESULT_KIND_TYPE: + case ActionResultKind::Type: check_const_type(ctx, &action->loc, result.type, &command->assert_return.expected, "action"); break; - case ACTION_RESULT_KIND_ERROR: + case ActionResultKind::Error: /* error occurred, don't do any further checks */ break; } break; } - case WABT_COMMAND_TYPE_ASSERT_RETURN_NAN: { + case WabtCommandType::AssertReturnNan: { const WabtAction* action = &command->assert_return_nan.action; ActionResult result = check_action(ctx, action); /* a valid result type will either be f32 or f64; convert a TYPES result - * into a TYPE result, so it is easier to check below. WABT_TYPE_ANY is + * into a TYPE result, so it is easier to check below. WabtType::Any is * used to specify a type that should not be checked (because an earlier * error occurred). */ - if (result.kind == ACTION_RESULT_KIND_TYPES) { + if (result.kind == ActionResultKind::Types) { if (result.types->size == 1) { - result.kind = ACTION_RESULT_KIND_TYPE; + result.kind = ActionResultKind::Type; result.type = result.types->data[0]; } else { print_error(ctx, &action->loc, "expected 1 result, got %" PRIzd, result.types->size); - result.type = WABT_TYPE_ANY; + result.type = WabtType::Any; } } - if (result.kind == ACTION_RESULT_KIND_TYPE && - result.type != WABT_TYPE_ANY) + if (result.kind == ActionResultKind::Type && result.type != WabtType::Any) check_assert_return_nan_type(ctx, &action->loc, result.type, "action"); break; } - case WABT_COMMAND_TYPE_ASSERT_TRAP: - case WABT_COMMAND_TYPE_ASSERT_EXHAUSTION: + case WabtCommandType::AssertTrap: + case WabtCommandType::AssertExhaustion: /* ignore result type */ check_action(ctx, &command->assert_trap.action); break; - - case WABT_NUM_COMMAND_TYPES: - assert(0); - break; } } @@ -1037,7 +1026,7 @@ WabtResult wabt_validate_script(WabtAstLexer* lexer, WABT_ZERO_MEMORY(ctx); ctx.lexer = lexer; ctx.error_handler = error_handler; - ctx.result = WABT_OK; + ctx.result = WabtResult::Ok; ctx.script = script; WabtTypeCheckerErrorHandler tc_error_handler; diff --git a/src/writer.cc b/src/writer.cc index 2a715747..45b257d5 100644 --- a/src/writer.cc +++ b/src/writer.cc @@ -33,21 +33,21 @@ static WabtResult write_data_to_file(size_t offset, size_t size, void* user_data) { if (size == 0) - return WABT_OK; + return WabtResult::Ok; WabtFileWriter* writer = static_cast<WabtFileWriter*>(user_data); if (offset != writer->offset) { if (fseek(writer->file, offset, SEEK_SET) != 0) { ERROR("fseek offset=%" PRIzd " failed, errno=%d\n", size, errno); - return WABT_ERROR; + return WabtResult::Error; } writer->offset = offset; } if (fwrite(data, size, 1, writer->file) != 1) { ERROR("fwrite size=%" PRIzd " failed, errno=%d\n", size, errno); - return WABT_ERROR; + return WabtResult::Error; } writer->offset += size; - return WABT_OK; + return WabtResult::Ok; } static WabtResult move_data_in_file(size_t dst_offset, @@ -55,10 +55,10 @@ static WabtResult move_data_in_file(size_t dst_offset, size_t size, void* user_data) { if (size == 0) - return WABT_OK; + return WabtResult::Ok; /* TODO(binji): implement if needed. */ ERROR0("move_data_in_file not implemented!\n"); - return WABT_ERROR; + return WabtResult::Error; } void wabt_init_file_writer_existing(WabtFileWriter* writer, FILE* file) { @@ -74,11 +74,11 @@ WabtResult wabt_init_file_writer(WabtFileWriter* writer, const char* filename) { FILE* file = fopen(filename, "wb"); if (!file) { ERROR("fopen name=\"%s\" failed, errno=%d\n", filename, errno); - return WABT_ERROR; + return WabtResult::Error; } wabt_init_file_writer_existing(writer, file); - return WABT_OK; + return WabtResult::Ok; } void wabt_close_file_writer(WabtFileWriter* writer) { @@ -116,7 +116,7 @@ static WabtResult write_data_to_output_buffer(size_t offset, data, size); if (end > writer->buf.size) writer->buf.size = end; - return WABT_OK; + return WabtResult::Ok; } static WabtResult move_data_in_output_buffer(size_t dst_offset, @@ -135,7 +135,7 @@ static WabtResult move_data_in_output_buffer(size_t dst_offset, memmove(dst, src, size); if (end > writer->buf.size) writer->buf.size = end; - return WABT_OK; + return WabtResult::Ok; } WabtResult wabt_init_mem_writer(WabtMemoryWriter* writer) { @@ -144,7 +144,7 @@ WabtResult wabt_init_mem_writer(WabtMemoryWriter* writer) { writer->base.write_data = write_data_to_output_buffer; writer->base.move_data = move_data_in_output_buffer; wabt_init_output_buffer(&writer->buf, INITIAL_OUTPUT_BUFFER_CAPACITY); - return WABT_OK; + return WabtResult::Ok; } WabtResult wabt_init_mem_writer_existing(WabtMemoryWriter* writer, @@ -156,7 +156,7 @@ WabtResult wabt_init_mem_writer_existing(WabtMemoryWriter* writer, writer->buf = *buf; /* Clear buffer, since ownership has passed to the writer. */ WABT_ZERO_MEMORY(*buf); - return WABT_OK; + return WabtResult::Ok; } void wabt_steal_mem_writer_output_buffer(WabtMemoryWriter* writer, @@ -176,17 +176,17 @@ WabtResult wabt_write_output_buffer_to_file(WabtOutputBuffer* buf, FILE* file = fopen(filename, "wb"); if (!file) { ERROR("unable to open %s for writing\n", filename); - return WABT_ERROR; + return WabtResult::Error; } ssize_t bytes = fwrite(buf->start, 1, buf->size, file); if (bytes < 0 || static_cast<size_t>(bytes) != buf->size) { ERROR("failed to write %" PRIzd " bytes to %s\n", buf->size, filename); - return WABT_ERROR; + return WabtResult::Error; } fclose(file); - return WABT_OK; + return WabtResult::Ok; } void wabt_destroy_output_buffer(WabtOutputBuffer* buf) { |