From 88fdda6bb879f5c0bdc5f2217dff24dd11dc84e6 Mon Sep 17 00:00:00 2001 From: Brendan Hansen Date: Thu, 21 Jul 2022 22:38:39 -0500 Subject: [PATCH] preparing for generating line to instruction translations --- build.sh | 7 + include/wasm_emit.h | 36 + lib/linux_x86_64/libovmwasm.so | Bin 0 -> 198656 bytes src/onyx.c | 4 +- src/wasm_emit.c | 1161 +++++++++++++++++--------------- src/wasm_intrinsics.h | 188 +++--- 6 files changed, 742 insertions(+), 654 deletions(-) create mode 100755 lib/linux_x86_64/libovmwasm.so diff --git a/build.sh b/build.sh index 18021006..5f529668 100755 --- a/build.sh +++ b/build.sh @@ -31,6 +31,9 @@ WASMER_LIBRARY_DIR="$(pwd)/lib/linux_$ARCH/lib" # Where the intermediate build files go. BUILD_DIR='./build' +# Temporary flag +ENABLE_DEBUG_INFO=0 + @@ -60,6 +63,10 @@ if [ "$RUNTIME_LIBRARY" = "ovmwasm" ]; then FLAGS="$FLAGS -DUSE_OVM_DEBUGGER" fi +if [ "$ENABLE_DEBUG_INFO" = "1" ]; then + FLAGS="$FLAGS -DENABLE_DEBUG_INFO" +fi + if [ ! -z "$ENABLE_BUNDLING_WASM_RUNTIME" ]; then C_FILES="$C_FILES wasm_runtime" diff --git a/include/wasm_emit.h b/include/wasm_emit.h index 5475473b..d02bdea4 100644 --- a/include/wasm_emit.h +++ b/include/wasm_emit.h @@ -749,6 +749,11 @@ typedef struct OnyxWasmModule { i32 null_proc_func_idx; b32 has_stack_locals : 1; + +#ifdef ENABLE_DEBUG_INFO + struct DebugContext *debug_context; +#endif + } OnyxWasmModule; typedef struct OnyxWasmLinkOptions { @@ -784,4 +789,35 @@ void onyx_wasm_module_write_to_file(OnyxWasmModule* module, bh_file file); b32 onyx_run_wasm(bh_buffer code_buffer, int argc, char *argv[]); #endif +#ifdef ENABLE_DEBUG_INFO + +typedef struct DebugLocation { + u32 file_id; + u32 line; + u32 repeat; +} DebugLocation; + +typedef struct DebugFuncContext { + u32 func_index; + bh_arr_each(DebugLocation) locations; +} DebugFuncContext; + +typedef struct DebugContext { + bh_allocator allocator; + + // file_names[file_ids["file"]] == "file" + // file_ids[file_name[123]] == 123 + Table(u32) file_ids; + bh_arr_each(char *) file_names; + + bh_arr_each(DebugFuncContext *) + + // Used during building the debug info + OnyxToken *last_token; + DebugFucnContext *current_func; + +} DebugContext; + +#endif + #endif diff --git a/lib/linux_x86_64/libovmwasm.so b/lib/linux_x86_64/libovmwasm.so new file mode 100755 index 0000000000000000000000000000000000000000..d8250e7969584d9f58b42f475d3b7b133acef9ce GIT binary patch literal 198656 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 oOVYE8T~3on(?45O$5vTKTKf_#Q*>R literal 0 HcmV?d00001 diff --git a/src/onyx.c b/src/onyx.c index ae47fab0..40ce3097 100644 --- a/src/onyx.c +++ b/src/onyx.c @@ -659,7 +659,9 @@ static void link_wasm_module() { assert(unify_node_and_type(&link_options_node, link_options_type) == TYPE_MATCH_SUCCESS); OnyxWasmLinkOptions link_opts; - onyx_wasm_build_link_options_from_node(&link_opts, link_options_node); + // CLEANUP: Properly handle this case. + assert(onyx_wasm_build_link_options_from_node(&link_opts, link_options_node)); + onyx_wasm_module_link(context.wasm_module, &link_opts); } diff --git a/src/wasm_emit.c b/src/wasm_emit.c index bc05fc95..36a872fe 100644 --- a/src/wasm_emit.c +++ b/src/wasm_emit.c @@ -213,6 +213,35 @@ static inline b32 should_emit_function(AstFunction* fd) { } +// +// Debug Info Generation +// + +#ifdef ENABLE_DEBUG_INFO + +static void debug_set_position(OnyxWasmModule *mod, OnyxToken *token) { + mod->debug_context->last_token = token; +} + +// Called for every instruction being emitted +static void debug_emit_instruction(OnyxWasmModule *mod, OnyxToken *token) { + DebugContext *ctx = mod->debug_context; + assert(ctx); + + DebugFuncContext *func_ctx = ctx->current_func; + assert(func_ctx); + + if () + + if (shgeti(ctx->file_ids, ctx->last_token->pos.filename) == -1) { + // File name has not been seen before, allocate a slot for it. + + } +} + +#endif + + typedef enum StructuredBlockType StructuredBlockType; enum StructuredBlockType { SBT_Basic_Block, // Cannot be targeted using jump @@ -230,21 +259,28 @@ enum StructuredBlockType { SBT_Count, }; +#ifdef ENABLE_DEBUG_INFO + #define WI(token, instr) (debug_emit_instruction(mod, token), bh_arr_push(code, ((WasmInstruction){ instr, 0x00 }))) + #define WID(token, instr, data) (debug_emit_instruction(mod, token), bh_arr_push(code, ((WasmInstruction){ instr, data }))) + #define WIL(token, instr, data) (debug_emit_instruction(mod, token), bh_arr_push(code, ((WasmInstruction){ instr, { .l = data } }))) + #define WIP(token, instr, data) (debug_emit_instruction(mod, token), bh_arr_push(code, ((WasmInstruction){ instr, { .p = data } }))) +#else + #define WI(token, instr) (bh_arr_push(code, ((WasmInstruction){ instr, 0x00 }))) + #define WID(token, instr, data) (bh_arr_push(code, ((WasmInstruction){ instr, data }))) + #define WIL(token, instr, data) (bh_arr_push(code, ((WasmInstruction){ instr, { .l = data } }))) + #define WIP(token, instr, data) (bh_arr_push(code, ((WasmInstruction){ instr, { .p = data } }))) +#endif -#define WI(instr) bh_arr_push(code, ((WasmInstruction){ instr, 0x00 })) -#define WID(instr, data) bh_arr_push(code, ((WasmInstruction){ instr, data })) -#define WIL(instr, data) bh_arr_push(code, ((WasmInstruction){ instr, { .l = data } })) -#define WIP(instr, data) bh_arr_push(code, ((WasmInstruction){ instr, { .p = data } })) #define EMIT_FUNC(kind, ...) static void emit_ ## kind (OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, __VA_ARGS__) #define EMIT_FUNC_NO_ARGS(kind) static void emit_ ## kind (OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode) -#define STACK_SWAP(type1, type2) { \ +#define STACK_SWAP(token, type1, type2) { \ u64 t0 = local_raw_allocate(mod->local_alloc, type1); \ u64 t1 = local_raw_allocate(mod->local_alloc, type2); \ \ - WIL(WI_LOCAL_SET, t0); \ - WIL(WI_LOCAL_SET, t1); \ - WIL(WI_LOCAL_GET, t0); \ - WIL(WI_LOCAL_GET, t1); \ + WIL(token, WI_LOCAL_SET, t0); \ + WIL(token, WI_LOCAL_SET, t1); \ + WIL(token, WI_LOCAL_GET, t0); \ + WIL(token, WI_LOCAL_GET, t1); \ \ local_raw_free(mod->local_alloc, type1); \ local_raw_free(mod->local_alloc, type2); \ @@ -298,7 +334,7 @@ EMIT_FUNC(stack_enter, u64 stacksize); EMIT_FUNC(zero_value, WasmType wt); EMIT_FUNC(zero_value_for_type, Type* type, OnyxToken* where); -EMIT_FUNC(enter_structured_block, StructuredBlockType sbt); +EMIT_FUNC(enter_structured_block, StructuredBlockType sbt, OnyxToken* block_token); EMIT_FUNC_NO_ARGS(leave_structured_block); static u32 emit_data_entry(OnyxWasmModule *mod, WasmDatum *datum); @@ -323,7 +359,8 @@ EMIT_FUNC(block, AstBlock* block, b32 generate_block_headers) { if (generate_block_headers) { emit_enter_structured_block(mod, &code, (block->rules & Block_Rule_Override_Return) ? SBT_Return_Block - : SBT_Breakable_Block); + : SBT_Breakable_Block, + block->token); } forll (AstNode, stmt, block->body, next) { @@ -349,7 +386,7 @@ EMIT_FUNC(block, AstBlock* block, b32 generate_block_headers) { *pcode = code; } -EMIT_FUNC(enter_structured_block, StructuredBlockType sbt) { +EMIT_FUNC(enter_structured_block, StructuredBlockType sbt, OnyxToken* token) { bh_arr(WasmInstruction) code = *pcode; static const StructuredBlockType jump_numbers[SBT_Count] = { @@ -381,7 +418,7 @@ EMIT_FUNC(enter_structured_block, StructuredBlockType sbt) { }; - WID(block_instrs[sbt], 0x40); + WID(token, block_instrs[sbt], 0x40); bh_arr_push(mod->structured_jump_target, jump_numbers[sbt]); *pcode = code; @@ -390,7 +427,7 @@ EMIT_FUNC(enter_structured_block, StructuredBlockType sbt) { EMIT_FUNC_NO_ARGS(leave_structured_block) { bh_arr(WasmInstruction) code = *pcode; - WI(WI_BLOCK_END); + WI(NULL, WI_BLOCK_END); bh_arr_pop(mod->structured_jump_target); *pcode = code; @@ -438,7 +475,7 @@ EMIT_FUNC(structured_jump, AstJump* jump) { // NOTE: If the previous instruction was a non conditional jump, // don't emit another jump since it will never be reached. if (bh_arr_last(code).type != WI_JUMP) - WID(WI_JUMP, labelidx); + WID(jump->token, WI_JUMP, labelidx); } else { onyx_report_error(jump->token->pos, Error_Critical, "Invalid structured jump."); } @@ -449,6 +486,10 @@ EMIT_FUNC(structured_jump, AstJump* jump) { EMIT_FUNC(statement, AstNode* stmt) { bh_arr(WasmInstruction) code = *pcode; +#ifdef ENABLE_DEBUG_INFO + debug_set_position(stmt->token); +#endif + switch (stmt->kind) { case Ast_Kind_Return: emit_return(mod, &code, (AstReturn *) stmt); break; case Ast_Kind_If: emit_if(mod, &code, (AstIfWhile *) stmt); break; @@ -478,14 +519,14 @@ EMIT_FUNC(local_allocation, AstTyped* stmt) { bh_arr(WasmInstruction) code = *pcode; if (local_is_wasm_local(stmt)) { emit_zero_value(mod, &code, onyx_type_to_wasm_type(stmt->type)); - WIL(WI_LOCAL_SET, local_idx); + WIL(stmt->token, WI_LOCAL_SET, local_idx); } else { emit_location(mod, &code, stmt); - WID(WI_I32_CONST, 0); - WID(WI_I32_CONST, type_size_of(stmt->type)); + WID(stmt->token, WI_I32_CONST, 0); + WID(stmt->token, WI_I32_CONST, type_size_of(stmt->type)); if (context.options->use_post_mvp_features) { - WID(WI_MEMORY_FILL, 0x00); + WID(stmt->token, WI_MEMORY_FILL, 0x00); } else { emit_intrinsic_memory_fill(mod, &code); } @@ -517,7 +558,7 @@ EMIT_FUNC(data_relocation, u32 data_id) { bh_arr(WasmInstruction) code = *pcode; u32 instr_idx = bh_arr_length(code); - WID(WI_PTR_CONST, 0); + WID(NULL, WI_PTR_CONST, 0); assert(mod->current_func_idx >= 0); DatumPatchInfo patch; @@ -556,10 +597,10 @@ EMIT_FUNC(assignment, AstBinaryOp* assign) { if (lval->kind == Ast_Kind_Param && type_is_structlike_strict(lval->type)) { u32 mem_count = type_structlike_mem_count(lval->type); - fori (i, 0, mem_count) WIL(WI_LOCAL_SET, localidx + i); + fori (i, 0, mem_count) WIL(assign->token, WI_LOCAL_SET, localidx + i); } else { - WIL(WI_LOCAL_SET, localidx); + WIL(assign->token, WI_LOCAL_SET, localidx); } *pcode = code; @@ -573,7 +614,7 @@ EMIT_FUNC(assignment, AstBinaryOp* assign) { emit_expression(mod, &code, assign->right); u64 localidx = bh_imap_get(&mod->local_map, (u64) fa->expr); - WIL(WI_LOCAL_SET, localidx + fa->idx); + WIL(assign->token, WI_LOCAL_SET, localidx + fa->idx); *pcode = code; return; @@ -584,7 +625,7 @@ EMIT_FUNC(assignment, AstBinaryOp* assign) { emit_expression(mod, &code, assign->right); i32 globalidx = (i32) bh_imap_get(&mod->index_map, (u64) lval); - WID(WI_GLOBAL_SET, globalidx); + WID(assign->token, WI_GLOBAL_SET, globalidx); *pcode = code; return; @@ -616,11 +657,11 @@ EMIT_FUNC(assignment_of_array, AstTyped* left, AstTyped* right) { u64 lptr_local = local_raw_allocate(mod->local_alloc, WASM_TYPE_PTR); emit_location(mod, &code, left); - WIL(WI_LOCAL_SET, lptr_local); + WIL(left->token, WI_LOCAL_SET, lptr_local); AstArrayLiteral* al = (AstArrayLiteral *) right; fori (i, 0, elem_count) { - WIL(WI_LOCAL_GET, lptr_local); + WIL(left->token, WI_LOCAL_GET, lptr_local); emit_expression(mod, &code, al->values[i]); emit_store_instruction(mod, &code, elem_type, i * elem_size); } @@ -655,17 +696,17 @@ EMIT_FUNC(compound_assignment, AstBinaryOp* assign) { if (lval->kind == Ast_Kind_Local || lval->kind == Ast_Kind_Param) { if (bh_imap_get(&mod->local_map, (u64) lval) & LOCAL_IS_WASM) { u64 localidx = bh_imap_get(&mod->local_map, (u64) lval); - WIL(WI_LOCAL_SET, localidx); + WIL(assign->token, WI_LOCAL_SET, localidx); continue; } } WasmType wt = onyx_type_to_wasm_type(lval->type); u64 expr_tmp = local_raw_allocate(mod->local_alloc, wt); - WIL(WI_LOCAL_SET, expr_tmp); + WIL(assign->token, WI_LOCAL_SET, expr_tmp); u64 offset = 0; emit_location_return_offset(mod, &code, lval, &offset); - WIL(WI_LOCAL_GET, expr_tmp); + WIL(assign->token, WI_LOCAL_GET, expr_tmp); local_raw_free(mod->local_alloc, wt); emit_store_instruction(mod, &code, lval->type, offset); @@ -703,19 +744,19 @@ EMIT_FUNC(store_instruction, Type* type, u32 offset) { i32 is_basic = type->kind == Type_Kind_Basic || type->kind == Type_Kind_Pointer; if (is_basic && (type->Basic.flags & Basic_Flag_Pointer)) { - WID(WI_I32_STORE, ((WasmInstructionData) { 2, offset })); + WID(NULL, WI_I32_STORE, ((WasmInstructionData) { 2, offset })); } else if (is_basic && ((type->Basic.flags & Basic_Flag_Integer) || (type->Basic.flags & Basic_Flag_Boolean) || (type->Basic.flags & Basic_Flag_Type_Index))) { - if (store_size == 1) WID(WI_I32_STORE_8, ((WasmInstructionData) { alignment, offset })); - else if (store_size == 2) WID(WI_I32_STORE_16, ((WasmInstructionData) { alignment, offset })); - else if (store_size == 4) WID(WI_I32_STORE, ((WasmInstructionData) { alignment, offset })); - else if (store_size == 8) WID(WI_I64_STORE, ((WasmInstructionData) { alignment, offset })); + if (store_size == 1) WID(NULL, WI_I32_STORE_8, ((WasmInstructionData) { alignment, offset })); + else if (store_size == 2) WID(NULL, WI_I32_STORE_16, ((WasmInstructionData) { alignment, offset })); + else if (store_size == 4) WID(NULL, WI_I32_STORE, ((WasmInstructionData) { alignment, offset })); + else if (store_size == 8) WID(NULL, WI_I64_STORE, ((WasmInstructionData) { alignment, offset })); } else if (is_basic && (type->Basic.flags & Basic_Flag_Float)) { - if (store_size == 4) WID(WI_F32_STORE, ((WasmInstructionData) { alignment, offset })); - else if (store_size == 8) WID(WI_F64_STORE, ((WasmInstructionData) { alignment, offset })); + if (store_size == 4) WID(NULL, WI_F32_STORE, ((WasmInstructionData) { alignment, offset })); + else if (store_size == 8) WID(NULL, WI_F64_STORE, ((WasmInstructionData) { alignment, offset })); } else if (is_basic && (type->Basic.flags & Basic_Flag_SIMD)) { - WID(WI_V128_STORE, ((WasmInstructionData) { alignment, offset })); + WID(NULL, WI_V128_STORE, ((WasmInstructionData) { alignment, offset })); } else { onyx_report_error((OnyxFilePos) { 0 }, Error_Critical, "Failed to generate store instruction for type '%s'.", @@ -740,8 +781,8 @@ EMIT_FUNC(load_instruction, Type* type, u32 offset) { if (type->kind == Type_Kind_Array) { if (offset != 0) { - WID(WI_PTR_CONST, offset); - WI(WI_PTR_ADD); + WID(NULL, WI_PTR_CONST, offset); + WI(NULL, WI_PTR_ADD); } *pcode = code; @@ -780,7 +821,7 @@ EMIT_FUNC(load_instruction, Type* type, u32 offset) { instr = WI_V128_LOAD; } - WID(instr, ((WasmInstructionData) { alignment, offset })); + WID(NULL, instr, ((WasmInstructionData) { alignment, offset })); if (instr == WI_NOP) { onyx_report_error((OnyxFilePos) { 0 }, Error_Critical, @@ -815,11 +856,11 @@ EMIT_FUNC(if, AstIfWhile* if_node) { emit_expression(mod, &code, if_node->cond); - emit_enter_structured_block(mod, &code, SBT_Basic_If); + emit_enter_structured_block(mod, &code, SBT_Basic_If, if_node->token); if (if_node->true_stmt) emit_block(mod, &code, if_node->true_stmt, 0); if (if_node->false_stmt) { - WI(WI_ELSE); + WI(if_node->false_stmt->token, WI_ELSE); if (if_node->false_stmt->kind == Ast_Kind_If) { emit_if(mod, &code, (AstIfWhile *) if_node->false_stmt); @@ -843,24 +884,24 @@ EMIT_FUNC(while, AstIfWhile* while_node) { } if (while_node->false_stmt == NULL) { - emit_enter_structured_block(mod, &code, SBT_Breakable_Block); - emit_enter_structured_block(mod, &code, SBT_Continue_Loop); + emit_enter_structured_block(mod, &code, SBT_Breakable_Block, while_node->token); + emit_enter_structured_block(mod, &code, SBT_Continue_Loop, while_node->token); if (!while_node->bottom_test) { emit_expression(mod, &code, while_node->cond); - WI(WI_I32_EQZ); - WID(WI_COND_JUMP, 0x01); + WI(while_cond->token, WI_I32_EQZ); + WID(while_cond->token, WI_COND_JUMP, 0x01); } emit_block(mod, &code, while_node->true_stmt, 0); if (while_node->bottom_test) { emit_expression(mod, &code, while_node->cond); - WID(WI_COND_JUMP, 0x00); + WID(while_node->cond, WI_COND_JUMP, 0x00); } else { if (bh_arr_last(code).type != WI_JUMP) - WID(WI_JUMP, 0x00); + WID(while_node->cond, WI_JUMP, 0x00); } emit_leave_structured_block(mod, &code); @@ -869,16 +910,16 @@ EMIT_FUNC(while, AstIfWhile* while_node) { } else { emit_expression(mod, &code, while_node->cond); - emit_enter_structured_block(mod, &code, SBT_Breakable_If); - emit_enter_structured_block(mod, &code, SBT_Continue_Loop); + emit_enter_structured_block(mod, &code, SBT_Breakable_If, while_node->token); + emit_enter_structured_block(mod, &code, SBT_Continue_Loop, while_node->token); emit_block(mod, &code, while_node->true_stmt, 0); emit_expression(mod, &code, while_node->cond); - WID(WI_COND_JUMP, 0x00); + WID(while_node->cond->token, WI_COND_JUMP, 0x00); emit_leave_structured_block(mod, &code); - WI(WI_ELSE); + WI(while_node->false_stmt->token, WI_ELSE); emit_block(mod, &code, while_node->false_stmt, 0); @@ -908,46 +949,46 @@ EMIT_FUNC(for_range, AstFor* for_node, u64 iter_local) { u64 high_local = local_raw_allocate(mod->local_alloc, onyx_type_to_wasm_type(high_mem.type)); u64 step_local = local_raw_allocate(mod->local_alloc, onyx_type_to_wasm_type(step_mem.type)); - WIL(WI_LOCAL_SET, step_local); - WIL(WI_LOCAL_SET, high_local); - WIL(WI_LOCAL_TEE, low_local); - WIL(WI_LOCAL_SET, iter_local); + WIL(for_node->token, WI_LOCAL_SET, step_local); + WIL(for_node->token, WI_LOCAL_SET, high_local); + WIL(for_node->token, WI_LOCAL_TEE, low_local); + WIL(for_node->token, WI_LOCAL_SET, iter_local); - emit_enter_structured_block(mod, &code, SBT_Breakable_Block); - emit_enter_structured_block(mod, &code, SBT_Basic_Loop); - emit_enter_structured_block(mod, &code, SBT_Continue_Block); + emit_enter_structured_block(mod, &code, SBT_Breakable_Block, for_node->token); + emit_enter_structured_block(mod, &code, SBT_Basic_Loop, for_node->token); + emit_enter_structured_block(mod, &code, SBT_Continue_Block, for_node->token); if (range->kind == Ast_Kind_Struct_Literal && (range->args.values[2]->flags & Ast_Flag_Comptime) != 0) { AstNumLit *step_value = (AstNumLit *) range->args.values[2]; assert(step_value->kind == Ast_Kind_NumLit); if (step_value->value.l >= 0) { - WIL(WI_LOCAL_GET, iter_local); - WIL(WI_LOCAL_GET, high_local); - WI(WI_I32_GE_S); - WID(WI_COND_JUMP, 0x02); + WIL(for_node->token, WI_LOCAL_GET, iter_local); + WIL(for_node->token, WI_LOCAL_GET, high_local); + WI(for_node->token, WI_I32_GE_S); + WID(for_node->token, WI_COND_JUMP, 0x02); } else { - WIL(WI_LOCAL_GET, iter_local); - WIL(WI_LOCAL_GET, high_local); - WI(WI_I32_LT_S); - WID(WI_COND_JUMP, 0x02); + WIL(for_node->token, WI_LOCAL_GET, iter_local); + WIL(for_node->token, WI_LOCAL_GET, high_local); + WI(for_node->token, WI_I32_LT_S); + WID(for_node->token, WI_COND_JUMP, 0x02); } } else { - WIL(WI_LOCAL_GET, step_local); - WID(WI_I32_CONST, 0); - WI(WI_I32_GE_S); - WID(WI_IF_START, 0x40); - WIL(WI_LOCAL_GET, iter_local); - WIL(WI_LOCAL_GET, high_local); - WI(WI_I32_GE_S); - WID(WI_COND_JUMP, 0x03); - WI(WI_ELSE); - WIL(WI_LOCAL_GET, iter_local); - WIL(WI_LOCAL_GET, high_local); - WI(WI_I32_LT_S); - WID(WI_COND_JUMP, 0x03); - WI(WI_IF_END); + WIL(for_node->token, WI_LOCAL_GET, step_local); + WID(for_node->token, WI_I32_CONST, 0); + WI(for_node->token, WI_I32_GE_S); + WID(for_node->token, WI_IF_START, 0x40); + WIL(for_node->token, WI_LOCAL_GET, iter_local); + WIL(for_node->token, WI_LOCAL_GET, high_local); + WI(for_node->token, WI_I32_GE_S); + WID(for_node->token, WI_COND_JUMP, 0x03); + WI(for_node->token, WI_ELSE); + WIL(for_node->token, WI_LOCAL_GET, iter_local); + WIL(for_node->token, WI_LOCAL_GET, high_local); + WI(for_node->token, WI_I32_LT_S); + WID(for_node->token, WI_COND_JUMP, 0x03); + WI(for_node->token, WI_IF_END); } @@ -955,13 +996,13 @@ EMIT_FUNC(for_range, AstFor* for_node, u64 iter_local) { emit_leave_structured_block(mod, &code); - WIL(WI_LOCAL_GET, iter_local); - WIL(WI_LOCAL_GET, step_local); - WI(WI_I32_ADD); - WIL(WI_LOCAL_SET, iter_local); + WIL(for_node->token, WI_LOCAL_GET, iter_local); + WIL(for_node->token, WI_LOCAL_GET, step_local); + WI(for_node->token, WI_I32_ADD); + WIL(for_node->token, WI_LOCAL_SET, iter_local); if (bh_arr_last(code).type != WI_JUMP) - WID(WI_JUMP, 0x00); + WID(for_node->token, WI_JUMP, 0x00); emit_leave_structured_block(mod, &code); emit_leave_structured_block(mod, &code); @@ -993,41 +1034,41 @@ EMIT_FUNC(for_array, AstFor* for_node, u64 iter_local) { if (for_node->by_pointer) elem_size = type_size_of(var->type->Pointer.elem); else elem_size = type_size_of(var->type); - WIL(WI_LOCAL_TEE, ptr_local); - WIL(WI_PTR_CONST, for_node->iter->type->Array.count * elem_size); - WI(WI_PTR_ADD); - WIL(WI_LOCAL_SET, end_ptr_local); + WIL(for_node->token, WI_LOCAL_TEE, ptr_local); + WIL(for_node->token, WI_PTR_CONST, for_node->iter->type->Array.count * elem_size); + WI(for_node->token, WI_PTR_ADD); + WIL(for_node->token, WI_LOCAL_SET, end_ptr_local); - emit_enter_structured_block(mod, &code, SBT_Breakable_Block); - emit_enter_structured_block(mod, &code, SBT_Basic_Loop); - emit_enter_structured_block(mod, &code, SBT_Continue_Block); + emit_enter_structured_block(mod, &code, SBT_Breakable_Block, for_node->token); + emit_enter_structured_block(mod, &code, SBT_Basic_Loop, for_node->token); + emit_enter_structured_block(mod, &code, SBT_Continue_Block, for_node->token); - WIL(WI_LOCAL_GET, ptr_local); - WIL(WI_LOCAL_GET, end_ptr_local); - WI(WI_PTR_GE); - WID(WI_COND_JUMP, 0x02); + WIL(for_node->token, WI_LOCAL_GET, ptr_local); + WIL(for_node->token, WI_LOCAL_GET, end_ptr_local); + WI(for_node->token, WI_PTR_GE); + WID(for_node->token, WI_COND_JUMP, 0x02); if (!for_node->by_pointer) { if (!it_is_local) emit_local_location(mod, &code, var, &offset); - WIL(WI_LOCAL_GET, ptr_local); + WIL(for_node->token, WI_LOCAL_GET, ptr_local); emit_load_instruction(mod, &code, var->type, 0); if (!it_is_local) emit_store_instruction(mod, &code, var->type, offset); - else WIL(WI_LOCAL_SET, iter_local); + else WIL(for_node->token, WI_LOCAL_SET, iter_local); } emit_block(mod, &code, for_node->stmt, 0); emit_leave_structured_block(mod, &code); - WIL(WI_LOCAL_GET, ptr_local); - WIL(WI_PTR_CONST, elem_size); - WI(WI_PTR_ADD); - WIL(WI_LOCAL_SET, ptr_local); + WIL(for_node->token, WI_LOCAL_GET, ptr_local); + WIL(for_node->token, WI_PTR_CONST, elem_size); + WI(for_node->token, WI_PTR_ADD); + WIL(for_node->token, WI_LOCAL_SET, ptr_local); if (bh_arr_last(code).type != WI_JUMP) - WID(WI_JUMP, 0x00); + WID(for_node->token, WI_JUMP, 0x00); emit_leave_structured_block(mod, &code); emit_leave_structured_block(mod, &code); @@ -1058,46 +1099,46 @@ EMIT_FUNC(for_slice, AstFor* for_node, u64 iter_local) { if (for_node->by_pointer) elem_size = type_size_of(var->type->Pointer.elem); else elem_size = type_size_of(var->type); - WIL(WI_LOCAL_SET, end_ptr_local); - WIL(WI_LOCAL_TEE, ptr_local); - WIL(WI_LOCAL_GET, end_ptr_local); + WIL(for_node->token, WI_LOCAL_SET, end_ptr_local); + WIL(for_node->token, WI_LOCAL_TEE, ptr_local); + WIL(for_node->token, WI_LOCAL_GET, end_ptr_local); if (elem_size != 1) { - WID(WI_PTR_CONST, elem_size); - WI(WI_PTR_MUL); + WID(for_node->token, WI_PTR_CONST, elem_size); + WI(for_node->token, WI_PTR_MUL); } - WI(WI_PTR_ADD); - WIL(WI_LOCAL_SET, end_ptr_local); + WI(for_node->token, WI_PTR_ADD); + WIL(for_node->token, WI_LOCAL_SET, end_ptr_local); - emit_enter_structured_block(mod, &code, SBT_Breakable_Block); - emit_enter_structured_block(mod, &code, SBT_Basic_Loop); - emit_enter_structured_block(mod, &code, SBT_Continue_Block); + emit_enter_structured_block(mod, &code, SBT_Breakable_Block, for_node->token); + emit_enter_structured_block(mod, &code, SBT_Basic_Loop, for_node->token); + emit_enter_structured_block(mod, &code, SBT_Continue_Block, for_node->token); - WIL(WI_LOCAL_GET, ptr_local); - WIL(WI_LOCAL_GET, end_ptr_local); - WI(WI_PTR_GE); - WID(WI_COND_JUMP, 0x02); + WIL(for_node->token, WI_LOCAL_GET, ptr_local); + WIL(for_node->token, WI_LOCAL_GET, end_ptr_local); + WI(for_node->token, WI_PTR_GE); + WID(for_node->token, WI_COND_JUMP, 0x02); if (!for_node->by_pointer) { if (!it_is_local) emit_local_location(mod, &code, var, &offset); - WIL(WI_LOCAL_GET, ptr_local); + WIL(for_node->token, WI_LOCAL_GET, ptr_local); emit_load_instruction(mod, &code, var->type, 0); if (!it_is_local) emit_store_instruction(mod, &code, var->type, offset); - else WIL(WI_LOCAL_SET, iter_local); + else WIL(for_node->token, WI_LOCAL_SET, iter_local); } emit_block(mod, &code, for_node->stmt, 0); emit_leave_structured_block(mod, &code); - WIL(WI_LOCAL_GET, ptr_local); - WIL(WI_PTR_CONST, elem_size); - WI(WI_PTR_ADD); - WIL(WI_LOCAL_SET, ptr_local); + WIL(for_node->token, WI_LOCAL_GET, ptr_local); + WIL(for_node->token, WI_PTR_CONST, elem_size); + WI(for_node->token, WI_PTR_ADD); + WIL(for_node->token, WI_LOCAL_SET, ptr_local); if (bh_arr_last(code).type != WI_JUMP) - WID(WI_JUMP, 0x00); + WID(for_node->token, WI_JUMP, 0x00); emit_leave_structured_block(mod, &code); emit_leave_structured_block(mod, &code); @@ -1117,10 +1158,10 @@ EMIT_FUNC(for_iterator, AstFor* for_node, u64 iter_local) { u64 iterator_close_func = local_raw_allocate(mod->local_alloc, WASM_TYPE_FUNC); u64 iterator_remove_func = local_raw_allocate(mod->local_alloc, WASM_TYPE_FUNC); u64 iterator_done_bool = local_raw_allocate(mod->local_alloc, WASM_TYPE_INT32); - WIL(WI_LOCAL_SET, iterator_remove_func); - WIL(WI_LOCAL_SET, iterator_close_func); - WIL(WI_LOCAL_SET, iterator_next_func); - WIL(WI_LOCAL_SET, iterator_data_ptr); + WIL(for_node->token, WI_LOCAL_SET, iterator_remove_func); + WIL(for_node->token, WI_LOCAL_SET, iterator_close_func); + WIL(for_node->token, WI_LOCAL_SET, iterator_next_func); + WIL(for_node->token, WI_LOCAL_SET, iterator_data_ptr); { @@ -1143,7 +1184,7 @@ EMIT_FUNC(for_iterator, AstFor* for_node, u64 iter_local) { u64 offset = 0; // Enter a deferred statement for the auto-close - emit_enter_structured_block(mod, &code, SBT_Basic_Block); + emit_enter_structured_block(mod, &code, SBT_Basic_Block, for_node->token); if (!for_node->no_close) { TypeWithOffset close_func_type; @@ -1163,14 +1204,14 @@ EMIT_FUNC(for_iterator, AstFor* for_node, u64 iter_local) { emit_defer_code(mod, &code, close_instructions, 8); } - emit_enter_structured_block(mod, &code, SBT_Breakable_Block); - emit_enter_structured_block(mod, &code, SBT_Continue_Loop); + emit_enter_structured_block(mod, &code, SBT_Breakable_Block, for_node->token); + emit_enter_structured_block(mod, &code, SBT_Continue_Loop, for_node->token); if (!it_is_local) emit_local_location(mod, &code, var, &offset); { - WIL(WI_LOCAL_GET, iterator_data_ptr); - WIL(WI_LOCAL_GET, iterator_next_func); + WIL(for_node->token, WI_LOCAL_GET, iterator_data_ptr); + WIL(for_node->token, WI_LOCAL_GET, iterator_next_func); // CLEANUP: Calling a function is way too f-ing complicated. FACTOR IT!! u64 stack_top_idx = bh_imap_get(&mod->index_map, (u64) &builtin_stack_top); @@ -1186,34 +1227,34 @@ EMIT_FUNC(for_iterator, AstFor* for_node, u64 iter_local) { u64 reserve_size = return_size; bh_align(reserve_size, 16); - WID(WI_GLOBAL_GET, stack_top_idx); - WID(WI_PTR_CONST, reserve_size); - WI(WI_PTR_ADD); - WID(WI_GLOBAL_SET, stack_top_idx); + WID(for_node->token, WI_GLOBAL_GET, stack_top_idx); + WID(for_node->token, WI_PTR_CONST, reserve_size); + WI(for_node->token, WI_PTR_ADD); + WID(for_node->token, WI_GLOBAL_SET, stack_top_idx); i32 type_idx = generate_type_idx(mod, next_func_type.type); - WID(WI_CALL_INDIRECT, ((WasmInstructionData) { type_idx, 0x00 })); + WID(for_node->token, WI_CALL_INDIRECT, ((WasmInstructionData) { type_idx, 0x00 })); - WID(WI_GLOBAL_GET, stack_top_idx); - WID(WI_PTR_CONST, reserve_size); - WI(WI_PTR_SUB); - WID(WI_GLOBAL_SET, stack_top_idx); + WID(for_node->token, WI_GLOBAL_GET, stack_top_idx); + WID(for_node->token, WI_PTR_CONST, reserve_size); + WI(for_node->token, WI_PTR_SUB); + WID(for_node->token, WI_GLOBAL_SET, stack_top_idx); - WID(WI_GLOBAL_GET, stack_top_idx); + WID(for_node->token, WI_GLOBAL_GET, stack_top_idx); emit_load_instruction(mod, &code, return_type, reserve_size - return_size); } - WIL(WI_LOCAL_SET, iterator_done_bool); + WIL(for_node->token, WI_LOCAL_SET, iterator_done_bool); if (!it_is_local) emit_store_instruction(mod, &code, var->type, offset); - else WIL(WI_LOCAL_SET, iter_local); + else WIL(for_node->token, WI_LOCAL_SET, iter_local); - WIL(WI_LOCAL_GET, iterator_done_bool); - WI(WI_I32_EQZ); - WID(WI_COND_JUMP, 0x01); + WIL(for_node->token, WI_LOCAL_GET, iterator_done_bool); + WI(for_node->token, WI_I32_EQZ); + WID(for_node->token, WI_COND_JUMP, 0x01); emit_block(mod, &code, for_node->stmt, 0); - WID(WI_JUMP, 0x00); + WID(for_node->token, WI_JUMP, 0x00); emit_leave_structured_block(mod, &code); emit_leave_structured_block(mod, &code); @@ -1246,7 +1287,7 @@ EMIT_FUNC(for, AstFor* for_node) { // Just dropping the extra fields will mean we can just use the slice implementation. // - brendanfh 2020/09/04 // - brendanfh 2021/04/13 - case For_Loop_DynArr: WI(WI_DROP); WI(WI_DROP); WI(WI_DROP); + case For_Loop_DynArr: WI(for_node->token, WI_DROP); WI(for_node->token, WI_DROP); WI(for_node->token, WI_DROP); case For_Loop_Slice: emit_for_slice(mod, &code, for_node, iter_local); break; case For_Loop_Iterator: emit_for_iterator(mod, &code, for_node, iter_local); break; default: onyx_report_error(for_node->token->pos, Error_Critical, "Invalid for loop type. You should probably not be seeing this..."); @@ -1269,13 +1310,13 @@ EMIT_FUNC(switch, AstSwitch* switch_node) { } } - emit_enter_structured_block(mod, &code, SBT_Breakable_Block); + emit_enter_structured_block(mod, &code, SBT_Breakable_Block, switch_node->token); u64 block_num = 0; bh_arr_each(AstSwitchCase *, sc, switch_node->cases) { if (bh_imap_has(&block_map, (u64) (*sc)->block)) continue; - emit_enter_structured_block(mod, &code, SBT_Fallthrough_Block); + emit_enter_structured_block(mod, &code, SBT_Fallthrough_Block, (*sc)->block->token); bh_imap_put(&block_map, (u64) (*sc)->block, block_num); block_num++; @@ -1305,31 +1346,31 @@ EMIT_FUNC(switch, AstSwitch* switch_node) { // // If we didn't enter a new block, then jumping to label 0, would jump // to the second block, and so on. - WID(WI_BLOCK_START, 0x40); + WID(switch_node->expr->token, WI_BLOCK_START, 0x40); emit_expression(mod, &code, switch_node->expr); if (switch_node->min_case != 0) { - WID(WI_I32_CONST, switch_node->min_case); - WI(WI_I32_SUB); + WID(switch_node->expr->token, WI_I32_CONST, switch_node->min_case); + WI(switch_node->expr->token, WI_I32_SUB); } - WIP(WI_JUMP_TABLE, bt); - WI(WI_BLOCK_END); + WIP(switch_node->expr->token, WI_JUMP_TABLE, bt); + WI(switch_node->expr->token, WI_BLOCK_END); break; } case Switch_Kind_Use_Equals: { - WID(WI_BLOCK_START, 0x40); + WID(switch_node->expr->token, WI_BLOCK_START, 0x40); bh_arr_each(CaseToBlock, ctb, switch_node->case_exprs) { emit_expression(mod, &code, (AstTyped *) ctb->comparison); u64 bn = bh_imap_get(&block_map, (u64) ctb->block); - WID(WI_IF_START, 0x40); - WID(WI_JUMP, bn + 1); - WI(WI_IF_END); + WID(switch_node->expr->token, WI_IF_START, 0x40); + WID(switch_node->expr->token, WI_JUMP, bn + 1); + WI(switch_node->expr->token, WI_IF_END); } - WID(WI_JUMP, block_num); - WI(WI_BLOCK_END); + WID(switch_node->expr->token, WI_JUMP, block_num); + WI(switch_node->expr->token, WI_BLOCK_END); break; } } @@ -1343,7 +1384,7 @@ EMIT_FUNC(switch, AstSwitch* switch_node) { emit_block(mod, &code, sc->block, 0); if (bh_arr_last(code).type != WI_JUMP) - WID(WI_JUMP, block_num - bn); + WID(NULL, WI_JUMP, block_num - bn); emit_leave_structured_block(mod, &code); @@ -1411,14 +1452,14 @@ EMIT_FUNC(remove_directive, AstDirectiveRemove* remove) { ForRemoveInfo remove_info = bh_arr_last(mod->for_remove_info); - WIL(WI_LOCAL_GET, remove_info.iterator_remove_func); - WIL(WI_I32_CONST, mod->null_proc_func_idx); - WI(WI_I32_NE); - WID(WI_IF_START, 0x40); - WIL(WI_LOCAL_GET, remove_info.iterator_data_ptr); - WIL(WI_LOCAL_GET, remove_info.iterator_remove_func); - WIL(WI_CALL_INDIRECT, remove_info.remove_func_type_idx); - WI(WI_IF_END); + WIL(remote->token, WI_LOCAL_GET, remove_info.iterator_remove_func); + WIL(remote->token, WI_I32_CONST, mod->null_proc_func_idx); + WI(remote->token, WI_I32_NE); + WID(remote->token, WI_IF_START, 0x40); + WIL(remote->token, WI_LOCAL_GET, remove_info.iterator_data_ptr); + WIL(remote->token, WI_LOCAL_GET, remove_info.iterator_remove_func); + WIL(remote->token, WI_CALL_INDIRECT, remove_info.remove_func_type_idx); + WI(remote->token, WI_IF_END); *pcode = code; } @@ -1491,7 +1532,7 @@ EMIT_FUNC(binop, AstBinaryOp* binop) { emit_expression(mod, &code, binop->left); emit_expression(mod, &code, binop->right); - WI(binop_instr); + WI(binop->token, binop_instr); *pcode = code; } @@ -1506,22 +1547,22 @@ EMIT_FUNC(unaryop, AstUnaryOp* unop) { if (type->kind == Basic_Kind_I32 || type->kind == Basic_Kind_I16 || type->kind == Basic_Kind_I8) { - WID(WI_I32_CONST, 0x00); + WID(unop->token, WI_I32_CONST, 0x00); emit_expression(mod, &code, unop->expr); - WI(WI_I32_SUB); + WI(unop->token, WI_I32_SUB); } else if (type->kind == Basic_Kind_I64) { - WID(WI_I64_CONST, 0x00); + WID(unop->token, WI_I64_CONST, 0x00); emit_expression(mod, &code, unop->expr); - WI(WI_I64_SUB); + WI(unop->token, WI_I64_SUB); } else { emit_expression(mod, &code, unop->expr); - if (type->kind == Basic_Kind_F32) WI(WI_F32_NEG); - if (type->kind == Basic_Kind_F64) WI(WI_F64_NEG); + if (type->kind == Basic_Kind_F32) WI(unop->token, WI_F32_NEG); + if (type->kind == Basic_Kind_F64) WI(unop->token, WI_F64_NEG); } break; @@ -1530,7 +1571,7 @@ EMIT_FUNC(unaryop, AstUnaryOp* unop) { case Unary_Op_Not: emit_expression(mod, &code, unop->expr); - WI(WI_I32_EQZ); + WI(unop->token, WI_I32_EQZ); break; case Unary_Op_Bitwise_Not: { @@ -1539,20 +1580,20 @@ EMIT_FUNC(unaryop, AstUnaryOp* unop) { TypeBasic* type = &unop->type->Basic; if (type->kind == Basic_Kind_I8 || type->kind == Basic_Kind_U8) { - WID(WI_I32_CONST, 0xff); - WI(WI_I32_XOR); + WID(unop->token, WI_I32_CONST, 0xff); + WI(unop->token, WI_I32_XOR); } else if (type->kind == Basic_Kind_I16 || type->kind == Basic_Kind_U16) { - WID(WI_I32_CONST, 0xffff); - WI(WI_I32_XOR); + WID(unop->token, WI_I32_CONST, 0xffff); + WI(unop->token, WI_I32_XOR); } else if (type->kind == Basic_Kind_I32 || type->kind == Basic_Kind_U32) { - WID(WI_I32_CONST, 0xffffffff); - WI(WI_I32_XOR); + WID(unop->token, WI_I32_CONST, 0xffffffff); + WI(unop->token, WI_I32_XOR); } else if (type->kind == Basic_Kind_I64 || type->kind == Basic_Kind_U64) { - WIL(WI_I64_CONST, 0xffffffffffffffff); - WI(WI_I64_XOR); + WIL(unop->token, WI_I64_CONST, 0xffffffffffffffff); + WI(unop->token, WI_I64_XOR); } break; @@ -1600,16 +1641,18 @@ EMIT_FUNC(call, AstCall* call) { u64 stack_top_idx = bh_imap_get(&mod->index_map, (u64) &builtin_stack_top); u64 stack_top_store_local = local_raw_allocate(mod->local_alloc, WASM_TYPE_PTR); + OnyxToken* call_token = call->token; + // Because it would be inefficient to increment and decrement the global stack pointer for every argument, // a simple set of instructions increments it once to the size it will need to be. However, because it is // impossible to know what size the reserved memory will be, a location patch is taken in order to fill it // in later. u32 reserve_space_patch = bh_arr_length(code); - WID(WI_GLOBAL_GET, stack_top_idx); - WIL(WI_LOCAL_TEE, stack_top_store_local); - WID(WI_PTR_CONST, 0); // This will be filled in later. - WI(WI_PTR_ADD); - WID(WI_GLOBAL_SET, stack_top_idx); + WID(call_token, WI_GLOBAL_GET, stack_top_idx); + WIL(call_token, WI_LOCAL_TEE, stack_top_store_local); + WID(call_token, WI_PTR_CONST, 0); // This will be filled in later. + WI(call_token, WI_PTR_ADD); + WID(call_token, WI_GLOBAL_SET, stack_top_idx); u32 reserve_size = 0; u32 vararg_count = 0; @@ -1646,7 +1689,7 @@ EMIT_FUNC(call, AstCall* call) { place_on_stack = 1; } - if (place_on_stack) WIL(WI_LOCAL_GET, stack_top_store_local); + if (place_on_stack) WIL(call_token, WI_LOCAL_GET, stack_top_store_local); emit_expression(mod, &code, arg->value); @@ -1655,9 +1698,9 @@ EMIT_FUNC(call, AstCall* call) { if (arg->va_kind == VA_Kind_Not_VA) { // Non-variadic arguments on the stack need a pointer to them placed on the WASM stack. - WIL(WI_LOCAL_GET, stack_top_store_local); - WID(WI_PTR_CONST, reserve_size); - WI(WI_PTR_ADD); + WIL(call_token, WI_LOCAL_GET, stack_top_store_local); + WID(call_token, WI_PTR_CONST, reserve_size); + WI(call_token, WI_PTR_ADD); } if (arg->va_kind == VA_Kind_Any) { @@ -1666,7 +1709,7 @@ EMIT_FUNC(call, AstCall* call) { } if (arg->pass_as_any) { - WIL(WI_I32_CONST, arg->value->type->id); + WIL(call_token, WI_I32_CONST, arg->value->type->id); } reserve_size += type_size_of(arg->value->type); @@ -1680,14 +1723,14 @@ EMIT_FUNC(call, AstCall* call) { i32 any_size = type_size_of(type_build_from_ast(context.ast_alloc, builtin_any_type)); fori (i, 0, vararg_count) { - WIL(WI_LOCAL_GET, stack_top_store_local); - WIL(WI_LOCAL_GET, stack_top_store_local); - WID(WI_PTR_CONST, vararg_any_offsets[i]); - WI(WI_PTR_ADD); + WIL(call_token, WI_LOCAL_GET, stack_top_store_local); + WIL(call_token, WI_LOCAL_GET, stack_top_store_local); + WID(call_token, WI_PTR_CONST, vararg_any_offsets[i]); + WI(call_token, WI_PTR_ADD); emit_store_instruction(mod, &code, &basic_types[Basic_Kind_Rawptr], vararg_offset + i * any_size); - WIL(WI_LOCAL_GET, stack_top_store_local); - WID(WI_I32_CONST, vararg_any_types[i]); + WIL(call_token, WI_LOCAL_GET, stack_top_store_local); + WID(call_token, WI_I32_CONST, vararg_any_types[i]); emit_store_instruction(mod, &code, &basic_types[Basic_Kind_Type_Index], vararg_offset + i * any_size + POINTER_SIZE); reserve_size += any_size; @@ -1697,34 +1740,34 @@ EMIT_FUNC(call, AstCall* call) { } case VA_Kind_Typed: { - WIL(WI_LOCAL_GET, stack_top_store_local); + WIL(call_token, WI_LOCAL_GET, stack_top_store_local); if (vararg_offset > 0) { - WID(WI_PTR_CONST, vararg_offset); - WI(WI_PTR_ADD); + WID(call_token, WI_PTR_CONST, vararg_offset); + WI(call_token, WI_PTR_ADD); } - WID(WI_I32_CONST, vararg_count); + WID(call_token, WI_I32_CONST, vararg_count); break; } case VA_Kind_Untyped: { - WIL(WI_LOCAL_GET, stack_top_store_local); - WIL(WI_LOCAL_GET, stack_top_store_local); + WIL(call_token, WI_LOCAL_GET, stack_top_store_local); + WIL(call_token, WI_LOCAL_GET, stack_top_store_local); if (vararg_offset > 0) { - WID(WI_PTR_CONST, vararg_offset); - WI(WI_PTR_ADD); + WID(call_token, WI_PTR_CONST, vararg_offset); + WI(call_token, WI_PTR_ADD); } emit_store_instruction(mod, &code, &basic_types[Basic_Kind_Rawptr], reserve_size); // NOTE: There may be 4 uninitialized bytes here, because pointers are only 4 bytes in WASM. - WIL(WI_LOCAL_GET, stack_top_store_local); - WID(WI_I32_CONST, vararg_count); + WIL(call_token, WI_LOCAL_GET, stack_top_store_local); + WID(call_token, WI_I32_CONST, vararg_count); emit_store_instruction(mod, &code, &basic_types[Basic_Kind_I32], reserve_size + POINTER_SIZE); - WIL(WI_LOCAL_GET, stack_top_store_local); + WIL(call_token, WI_LOCAL_GET, stack_top_store_local); if (reserve_size > 0) { - WID(WI_PTR_CONST, reserve_size); - WI(WI_PTR_ADD); + WID(call_token, WI_PTR_CONST, reserve_size); + WI(call_token, WI_PTR_ADD); } reserve_size += 4 + POINTER_SIZE; @@ -1749,12 +1792,12 @@ EMIT_FUNC(call, AstCall* call) { emit_expression(mod, &code, call->callee); i32 type_idx = generate_type_idx(mod, call->callee->type); - WID(WI_CALL_INDIRECT, ((WasmInstructionData) { type_idx, 0x00 })); + WID(call_token, WI_CALL_INDIRECT, ((WasmInstructionData) { type_idx, 0x00 })); } if (reserve_size > 0) { - WIL(WI_LOCAL_GET, stack_top_store_local); - WID(WI_GLOBAL_SET, stack_top_idx); + WIL(call_token, WI_LOCAL_GET, stack_top_store_local); + WID(call_token, WI_GLOBAL_SET, stack_top_idx); bh_align(reserve_size, 16); code[reserve_space_patch + 2].data.l = reserve_size; @@ -1764,7 +1807,7 @@ EMIT_FUNC(call, AstCall* call) { } if (cc == CC_Return_Stack) { - WID(WI_GLOBAL_GET, stack_top_idx); + WID(call_token, WI_GLOBAL_GET, stack_top_idx); emit_load_instruction(mod, &code, return_type, reserve_size - return_size); } @@ -1787,7 +1830,7 @@ EMIT_FUNC(call, AstCall* call) { } \ byte_buffer[i] = (type) ((AstNumLit *) arg_arr[i]->value)->value.l; \ } \ - WIP(WI_V128_CONST, byte_buffer); \ + WIP(call->token, WI_V128_CONST, byte_buffer); \ } #define SIMD_EXTRACT_LANE_INSTR(instr, arg_arr) \ @@ -1797,7 +1840,7 @@ EMIT_FUNC(call, AstCall* call) { *pcode = code; \ return; \ } \ - WID(instr, (u8) ((AstNumLit *) arg_arr[1]->value)->value.i); + WID(call->token, instr, (u8) ((AstNumLit *) arg_arr[1]->value)->value.i); #define SIMD_REPLACE_LANE_INSTR(instr, arg_arr) { \ emit_expression(mod, &code, arg_arr[0]->value);\ @@ -1808,7 +1851,7 @@ EMIT_FUNC(call, AstCall* call) { } \ u8 lane = (u8) ((AstNumLit *) arg_arr[1]->value)->value.i; \ emit_expression(mod, &code, arg_arr[2]->value); \ - WID(instr, lane); \ + WID(call->token, instr, lane); \ } @@ -1842,18 +1885,18 @@ EMIT_FUNC(intrinsic_call, AstCall* call) { } switch (call->intrinsic) { - case ONYX_INTRINSIC_MEMORY_SIZE: WID(WI_MEMORY_SIZE, 0x00); break; - case ONYX_INTRINSIC_MEMORY_GROW: WID(WI_MEMORY_GROW, 0x00); break; + case ONYX_INTRINSIC_MEMORY_SIZE: WID(call->token, WI_MEMORY_SIZE, 0x00); break; + case ONYX_INTRINSIC_MEMORY_GROW: WID(call->token, WI_MEMORY_GROW, 0x00); break; case ONYX_INTRINSIC_MEMORY_COPY: if (context.options->use_post_mvp_features) { - WIL(WI_MEMORY_COPY, 0x00); + WIL(call->token, WI_MEMORY_COPY, 0x00); } else { emit_intrinsic_memory_copy(mod, &code); } break; case ONYX_INTRINSIC_MEMORY_FILL: if (context.options->use_post_mvp_features) { - WIL(WI_MEMORY_FILL, 0x00); + WIL(call->token, WI_MEMORY_FILL, 0x00); } else { emit_intrinsic_memory_fill(mod, &code); } @@ -1865,49 +1908,49 @@ EMIT_FUNC(intrinsic_call, AstCall* call) { break; } - case ONYX_INTRINSIC_I32_CLZ: WI(WI_I32_CLZ); break; - case ONYX_INTRINSIC_I32_CTZ: WI(WI_I32_CTZ); break; - case ONYX_INTRINSIC_I32_POPCNT: WI(WI_I32_POPCNT); break; - case ONYX_INTRINSIC_I32_AND: WI(WI_I32_AND); break; - case ONYX_INTRINSIC_I32_OR: WI(WI_I32_OR); break; - case ONYX_INTRINSIC_I32_XOR: WI(WI_I32_XOR); break; - case ONYX_INTRINSIC_I32_SHL: WI(WI_I32_SHL); break; - case ONYX_INTRINSIC_I32_SLR: WI(WI_I32_SHR_U); break; - case ONYX_INTRINSIC_I32_SAR: WI(WI_I32_SHR_S); break; - case ONYX_INTRINSIC_I32_ROTL: WI(WI_I32_ROTL); break; - case ONYX_INTRINSIC_I32_ROTR: WI(WI_I32_ROTR); break; - - case ONYX_INTRINSIC_I64_CLZ: WI(WI_I64_CLZ); break; - case ONYX_INTRINSIC_I64_CTZ: WI(WI_I64_CTZ); break; - case ONYX_INTRINSIC_I64_POPCNT: WI(WI_I64_POPCNT); break; - case ONYX_INTRINSIC_I64_AND: WI(WI_I64_AND); break; - case ONYX_INTRINSIC_I64_OR: WI(WI_I64_OR); break; - case ONYX_INTRINSIC_I64_XOR: WI(WI_I64_XOR); break; - case ONYX_INTRINSIC_I64_SHL: WI(WI_I64_SHL); break; - case ONYX_INTRINSIC_I64_SLR: WI(WI_I64_SHR_U); break; - case ONYX_INTRINSIC_I64_SAR: WI(WI_I64_SHR_S); break; - case ONYX_INTRINSIC_I64_ROTL: WI(WI_I64_ROTL); break; - case ONYX_INTRINSIC_I64_ROTR: WI(WI_I64_ROTR); break; - - case ONYX_INTRINSIC_F32_ABS: WI(WI_F32_ABS); break; - case ONYX_INTRINSIC_F32_CEIL: WI(WI_F32_CEIL); break; - case ONYX_INTRINSIC_F32_FLOOR: WI(WI_F32_FLOOR); break; - case ONYX_INTRINSIC_F32_TRUNC: WI(WI_F32_TRUNC); break; - case ONYX_INTRINSIC_F32_NEAREST: WI(WI_F32_NEAREST); break; - case ONYX_INTRINSIC_F32_SQRT: WI(WI_F32_SQRT); break; - case ONYX_INTRINSIC_F32_MIN: WI(WI_F32_MIN); break; - case ONYX_INTRINSIC_F32_MAX: WI(WI_F32_MAX); break; - case ONYX_INTRINSIC_F32_COPYSIGN: WI(WI_F32_COPYSIGN); break; - - case ONYX_INTRINSIC_F64_ABS: WI(WI_F64_ABS); break; - case ONYX_INTRINSIC_F64_CEIL: WI(WI_F64_CEIL); break; - case ONYX_INTRINSIC_F64_FLOOR: WI(WI_F64_FLOOR); break; - case ONYX_INTRINSIC_F64_TRUNC: WI(WI_F64_TRUNC); break; - case ONYX_INTRINSIC_F64_NEAREST: WI(WI_F64_NEAREST); break; - case ONYX_INTRINSIC_F64_SQRT: WI(WI_F64_SQRT); break; - case ONYX_INTRINSIC_F64_MIN: WI(WI_F64_MIN); break; - case ONYX_INTRINSIC_F64_MAX: WI(WI_F64_MAX); break; - case ONYX_INTRINSIC_F64_COPYSIGN: WI(WI_F64_COPYSIGN); break; + case ONYX_INTRINSIC_I32_CLZ: WI(call->token, WI_I32_CLZ); break; + case ONYX_INTRINSIC_I32_CTZ: WI(call->token, WI_I32_CTZ); break; + case ONYX_INTRINSIC_I32_POPCNT: WI(call->token, WI_I32_POPCNT); break; + case ONYX_INTRINSIC_I32_AND: WI(call->token, WI_I32_AND); break; + case ONYX_INTRINSIC_I32_OR: WI(call->token, WI_I32_OR); break; + case ONYX_INTRINSIC_I32_XOR: WI(call->token, WI_I32_XOR); break; + case ONYX_INTRINSIC_I32_SHL: WI(call->token, WI_I32_SHL); break; + case ONYX_INTRINSIC_I32_SLR: WI(call->token, WI_I32_SHR_U); break; + case ONYX_INTRINSIC_I32_SAR: WI(call->token, WI_I32_SHR_S); break; + case ONYX_INTRINSIC_I32_ROTL: WI(call->token, WI_I32_ROTL); break; + case ONYX_INTRINSIC_I32_ROTR: WI(call->token, WI_I32_ROTR); break; + + case ONYX_INTRINSIC_I64_CLZ: WI(call->token, WI_I64_CLZ); break; + case ONYX_INTRINSIC_I64_CTZ: WI(call->token, WI_I64_CTZ); break; + case ONYX_INTRINSIC_I64_POPCNT: WI(call->token, WI_I64_POPCNT); break; + case ONYX_INTRINSIC_I64_AND: WI(call->token, WI_I64_AND); break; + case ONYX_INTRINSIC_I64_OR: WI(call->token, WI_I64_OR); break; + case ONYX_INTRINSIC_I64_XOR: WI(call->token, WI_I64_XOR); break; + case ONYX_INTRINSIC_I64_SHL: WI(call->token, WI_I64_SHL); break; + case ONYX_INTRINSIC_I64_SLR: WI(call->token, WI_I64_SHR_U); break; + case ONYX_INTRINSIC_I64_SAR: WI(call->token, WI_I64_SHR_S); break; + case ONYX_INTRINSIC_I64_ROTL: WI(call->token, WI_I64_ROTL); break; + case ONYX_INTRINSIC_I64_ROTR: WI(call->token, WI_I64_ROTR); break; + + case ONYX_INTRINSIC_F32_ABS: WI(call->token, WI_F32_ABS); break; + case ONYX_INTRINSIC_F32_CEIL: WI(call->token, WI_F32_CEIL); break; + case ONYX_INTRINSIC_F32_FLOOR: WI(call->token, WI_F32_FLOOR); break; + case ONYX_INTRINSIC_F32_TRUNC: WI(call->token, WI_F32_TRUNC); break; + case ONYX_INTRINSIC_F32_NEAREST: WI(call->token, WI_F32_NEAREST); break; + case ONYX_INTRINSIC_F32_SQRT: WI(call->token, WI_F32_SQRT); break; + case ONYX_INTRINSIC_F32_MIN: WI(call->token, WI_F32_MIN); break; + case ONYX_INTRINSIC_F32_MAX: WI(call->token, WI_F32_MAX); break; + case ONYX_INTRINSIC_F32_COPYSIGN: WI(call->token, WI_F32_COPYSIGN); break; + + case ONYX_INTRINSIC_F64_ABS: WI(call->token, WI_F64_ABS); break; + case ONYX_INTRINSIC_F64_CEIL: WI(call->token, WI_F64_CEIL); break; + case ONYX_INTRINSIC_F64_FLOOR: WI(call->token, WI_F64_FLOOR); break; + case ONYX_INTRINSIC_F64_TRUNC: WI(call->token, WI_F64_TRUNC); break; + case ONYX_INTRINSIC_F64_NEAREST: WI(call->token, WI_F64_NEAREST); break; + case ONYX_INTRINSIC_F64_SQRT: WI(call->token, WI_F64_SQRT); break; + case ONYX_INTRINSIC_F64_MIN: WI(call->token, WI_F64_MIN); break; + case ONYX_INTRINSIC_F64_MAX: WI(call->token, WI_F64_MAX); break; + case ONYX_INTRINSIC_F64_COPYSIGN: WI(call->token, WI_F64_COPYSIGN); break; case ONYX_INTRINSIC_I8X16_CONST: case ONYX_INTRINSIC_V128_CONST: SIMD_INT_CONST_INTRINSIC(u8, 16); break; @@ -1927,7 +1970,7 @@ EMIT_FUNC(intrinsic_call, AstCall* call) { } byte_buffer[i] = (f32) ((AstNumLit *) arg_arr[i]->value)->value.f; } - WIP(WI_V128_CONST, byte_buffer); + WIP(call->token, WI_V128_CONST, byte_buffer); break; } @@ -1944,7 +1987,7 @@ EMIT_FUNC(intrinsic_call, AstCall* call) { } byte_buffer[i] = (f64) ((AstNumLit *) arg_arr[i]->value)->value.d; } - WIP(WI_V128_CONST, byte_buffer); + WIP(call->token, WI_V128_CONST, byte_buffer); break; } @@ -1967,7 +2010,7 @@ EMIT_FUNC(intrinsic_call, AstCall* call) { } byte_buffer[i] = (u8) ((AstNumLit *) arg_arr[i + 2]->value)->value.i; } - WIP(WI_I8X16_SHUFFLE, byte_buffer); + WIP(call->token, WI_I8X16_SHUFFLE, byte_buffer); break; } @@ -1987,169 +2030,169 @@ EMIT_FUNC(intrinsic_call, AstCall* call) { case ONYX_INTRINSIC_F64X2_EXTRACT_LANE: SIMD_EXTRACT_LANE_INSTR(WI_F64X2_EXTRACT_LANE, ((bh_arr(AstArgument *)) call->args.values)); break; case ONYX_INTRINSIC_F64X2_REPLACE_LANE: SIMD_REPLACE_LANE_INSTR(WI_F64X2_REPLACE_LANE, ((bh_arr(AstArgument *)) call->args.values)); break; - case ONYX_INTRINSIC_I8X16_SWIZZLE: WI(WI_I8X16_SWIZZLE); break; - case ONYX_INTRINSIC_I8X16_SPLAT: WI(WI_I8X16_SPLAT); break; - case ONYX_INTRINSIC_I16X8_SPLAT: WI(WI_I16X8_SPLAT); break; - case ONYX_INTRINSIC_I32X4_SPLAT: WI(WI_I32X4_SPLAT); break; - case ONYX_INTRINSIC_I64X2_SPLAT: WI(WI_I64X2_SPLAT); break; - case ONYX_INTRINSIC_F32X4_SPLAT: WI(WI_F32X4_SPLAT); break; - case ONYX_INTRINSIC_F64X2_SPLAT: WI(WI_F64X2_SPLAT); break; - - case ONYX_INTRINSIC_I8X16_EQ: WI(WI_I8X16_EQ); break; - case ONYX_INTRINSIC_I8X16_NEQ: WI(WI_I8X16_NEQ); break; - case ONYX_INTRINSIC_I8X16_LT_S: WI(WI_I8X16_LT_S); break; - case ONYX_INTRINSIC_I8X16_LT_U: WI(WI_I8X16_LT_U); break; - case ONYX_INTRINSIC_I8X16_GT_S: WI(WI_I8X16_GT_S); break; - case ONYX_INTRINSIC_I8X16_GT_U: WI(WI_I8X16_GT_U); break; - case ONYX_INTRINSIC_I8X16_LE_S: WI(WI_I8X16_LE_S); break; - case ONYX_INTRINSIC_I8X16_LE_U: WI(WI_I8X16_LE_U); break; - case ONYX_INTRINSIC_I8X16_GE_S: WI(WI_I8X16_GE_S); break; - case ONYX_INTRINSIC_I8X16_GE_U: WI(WI_I8X16_GE_U); break; - - case ONYX_INTRINSIC_I16X8_EQ: WI(WI_I16X8_EQ); break; - case ONYX_INTRINSIC_I16X8_NEQ: WI(WI_I16X8_NEQ); break; - case ONYX_INTRINSIC_I16X8_LT_S: WI(WI_I16X8_LT_S); break; - case ONYX_INTRINSIC_I16X8_LT_U: WI(WI_I16X8_LT_U); break; - case ONYX_INTRINSIC_I16X8_GT_S: WI(WI_I16X8_GT_S); break; - case ONYX_INTRINSIC_I16X8_GT_U: WI(WI_I16X8_GT_U); break; - case ONYX_INTRINSIC_I16X8_LE_S: WI(WI_I16X8_LE_S); break; - case ONYX_INTRINSIC_I16X8_LE_U: WI(WI_I16X8_LE_U); break; - case ONYX_INTRINSIC_I16X8_GE_S: WI(WI_I16X8_GE_S); break; - case ONYX_INTRINSIC_I16X8_GE_U: WI(WI_I16X8_GE_U); break; - - case ONYX_INTRINSIC_I32X4_EQ: WI(WI_I32X4_EQ); break; - case ONYX_INTRINSIC_I32X4_NEQ: WI(WI_I32X4_NEQ); break; - case ONYX_INTRINSIC_I32X4_LT_S: WI(WI_I32X4_LT_S); break; - case ONYX_INTRINSIC_I32X4_LT_U: WI(WI_I32X4_LT_U); break; - case ONYX_INTRINSIC_I32X4_GT_S: WI(WI_I32X4_GT_S); break; - case ONYX_INTRINSIC_I32X4_GT_U: WI(WI_I32X4_GT_U); break; - case ONYX_INTRINSIC_I32X4_LE_S: WI(WI_I32X4_LE_S); break; - case ONYX_INTRINSIC_I32X4_LE_U: WI(WI_I32X4_LE_U); break; - case ONYX_INTRINSIC_I32X4_GE_S: WI(WI_I32X4_GE_S); break; - case ONYX_INTRINSIC_I32X4_GE_U: WI(WI_I32X4_GE_U); break; - - case ONYX_INTRINSIC_F32X4_EQ: WI(WI_F32X4_EQ); break; - case ONYX_INTRINSIC_F32X4_NEQ: WI(WI_F32X4_NEQ); break; - case ONYX_INTRINSIC_F32X4_LT: WI(WI_F32X4_LT); break; - case ONYX_INTRINSIC_F32X4_GT: WI(WI_F32X4_GT); break; - case ONYX_INTRINSIC_F32X4_LE: WI(WI_F32X4_LE); break; - case ONYX_INTRINSIC_F32X4_GE: WI(WI_F32X4_GE); break; - - case ONYX_INTRINSIC_F64X2_EQ: WI(WI_F64X2_EQ); break; - case ONYX_INTRINSIC_F64X2_NEQ: WI(WI_F64X2_NEQ); break; - case ONYX_INTRINSIC_F64X2_LT: WI(WI_F64X2_LT); break; - case ONYX_INTRINSIC_F64X2_GT: WI(WI_F64X2_GT); break; - case ONYX_INTRINSIC_F64X2_LE: WI(WI_F64X2_LE); break; - case ONYX_INTRINSIC_F64X2_GE: WI(WI_F64X2_GE); break; - - case ONYX_INTRINSIC_V128_NOT: WI(WI_V128_NOT); break; - case ONYX_INTRINSIC_V128_AND: WI(WI_V128_AND); break; - case ONYX_INTRINSIC_V128_ANDNOT: WI(WI_V128_ANDNOT); break; - case ONYX_INTRINSIC_V128_OR: WI(WI_V128_OR); break; - case ONYX_INTRINSIC_V128_XOR: WI(WI_V128_XOR); break; - case ONYX_INTRINSIC_V128_BITSELECT: WI(WI_V128_BITSELECT); break; - - case ONYX_INTRINSIC_I8X16_ABS: WI(WI_I8X16_ABS); break; - case ONYX_INTRINSIC_I8X16_NEG: WI(WI_I8X16_NEG); break; - case ONYX_INTRINSIC_I8X16_ANY_TRUE: WI(WI_I8X16_ANY_TRUE); break; - case ONYX_INTRINSIC_I8X16_ALL_TRUE: WI(WI_I8X16_ALL_TRUE); break; - case ONYX_INTRINSIC_I8X16_BITMASK: WI(WI_I8X16_BITMASK); break; - case ONYX_INTRINSIC_I8X16_NARROW_I16X8_S: WI(WI_I8X16_NARROW_I16X8_S); break; - case ONYX_INTRINSIC_I8X16_NARROW_I16X8_U: WI(WI_I8X16_NARROW_I16X8_U); break; - case ONYX_INTRINSIC_I8X16_SHL: WI(WI_I8X16_SHL); break; - case ONYX_INTRINSIC_I8X16_SHR_S: WI(WI_I8X16_SHR_S); break; - case ONYX_INTRINSIC_I8X16_SHR_U: WI(WI_I8X16_SHR_U); break; - case ONYX_INTRINSIC_I8X16_ADD: WI(WI_I8X16_ADD); break; - case ONYX_INTRINSIC_I8X16_ADD_SAT_S: WI(WI_I8X16_ADD_SAT_S); break; - case ONYX_INTRINSIC_I8X16_ADD_SAT_U: WI(WI_I8X16_ADD_SAT_U); break; - case ONYX_INTRINSIC_I8X16_SUB: WI(WI_I8X16_SUB); break; - case ONYX_INTRINSIC_I8X16_SUB_SAT_S: WI(WI_I8X16_SUB_SAT_S); break; - case ONYX_INTRINSIC_I8X16_SUB_SAT_U: WI(WI_I8X16_SUB_SAT_U); break; - case ONYX_INTRINSIC_I8X16_MIN_S: WI(WI_I8X16_MIN_S); break; - case ONYX_INTRINSIC_I8X16_MIN_U: WI(WI_I8X16_MIN_U); break; - case ONYX_INTRINSIC_I8X16_MAX_S: WI(WI_I8X16_MAX_S); break; - case ONYX_INTRINSIC_I8X16_MAX_U: WI(WI_I8X16_MAX_U); break; - case ONYX_INTRINSIC_I8X16_AVGR_U: WI(WI_I8X16_AVGR_U); break; - - case ONYX_INTRINSIC_I16X8_ABS: WI(WI_I16X8_ABS); break; - case ONYX_INTRINSIC_I16X8_NEG: WI(WI_I16X8_NEG); break; - case ONYX_INTRINSIC_I16X8_ANY_TRUE: WI(WI_I16X8_ANY_TRUE); break; - case ONYX_INTRINSIC_I16X8_ALL_TRUE: WI(WI_I16X8_ALL_TRUE); break; - case ONYX_INTRINSIC_I16X8_BITMASK: WI(WI_I16X8_BITMASK); break; - case ONYX_INTRINSIC_I16X8_NARROW_I32X4_S: WI(WI_I16X8_NARROW_I32X4_S); break; - case ONYX_INTRINSIC_I16X8_NARROW_I32X4_U: WI(WI_I16X8_NARROW_I32X4_U); break; - case ONYX_INTRINSIC_I16X8_WIDEN_LOW_I8X16_S: WI(WI_I16X8_WIDEN_LOW_I8X16_S); break; - case ONYX_INTRINSIC_I16X8_WIDEN_HIGH_I8X16_S: WI(WI_I16X8_WIDEN_HIGH_I8X16_S); break; - case ONYX_INTRINSIC_I16X8_WIDEN_LOW_I8X16_U: WI(WI_I16X8_WIDEN_LOW_I8X16_U); break; - case ONYX_INTRINSIC_I16X8_WIDEN_HIGH_I8X16_U: WI(WI_I16X8_WIDEN_HIGH_I8X16_U); break; - case ONYX_INTRINSIC_I16X8_SHL: WI(WI_I16X8_SHL); break; - case ONYX_INTRINSIC_I16X8_SHR_S: WI(WI_I16X8_SHR_S); break; - case ONYX_INTRINSIC_I16X8_SHR_U: WI(WI_I16X8_SHR_U); break; - case ONYX_INTRINSIC_I16X8_ADD: WI(WI_I16X8_ADD); break; - case ONYX_INTRINSIC_I16X8_ADD_SAT_S: WI(WI_I16X8_ADD_SAT_S); break; - case ONYX_INTRINSIC_I16X8_ADD_SAT_U: WI(WI_I16X8_ADD_SAT_U); break; - case ONYX_INTRINSIC_I16X8_SUB: WI(WI_I16X8_SUB); break; - case ONYX_INTRINSIC_I16X8_SUB_SAT_S: WI(WI_I16X8_SUB_SAT_S); break; - case ONYX_INTRINSIC_I16X8_SUB_SAT_U: WI(WI_I16X8_SUB_SAT_U); break; - case ONYX_INTRINSIC_I16X8_MUL: WI(WI_I16X8_MUL); break; - case ONYX_INTRINSIC_I16X8_MIN_S: WI(WI_I16X8_MIN_S); break; - case ONYX_INTRINSIC_I16X8_MIN_U: WI(WI_I16X8_MIN_U); break; - case ONYX_INTRINSIC_I16X8_MAX_S: WI(WI_I16X8_MAX_S); break; - case ONYX_INTRINSIC_I16X8_MAX_U: WI(WI_I16X8_MAX_U); break; - case ONYX_INTRINSIC_I16X8_AVGR_U: WI(WI_I16X8_AVGR_U); break; - - case ONYX_INTRINSIC_I32X4_ABS: WI(WI_I32X4_ABS); break; - case ONYX_INTRINSIC_I32X4_NEG: WI(WI_I32X4_NEG); break; - case ONYX_INTRINSIC_I32X4_ANY_TRUE: WI(WI_I32X4_ANY_TRUE); break; - case ONYX_INTRINSIC_I32X4_ALL_TRUE: WI(WI_I32X4_ALL_TRUE); break; - case ONYX_INTRINSIC_I32X4_BITMASK: WI(WI_I32X4_BITMASK); break; - case ONYX_INTRINSIC_I32X4_WIDEN_LOW_I16X8_S: WI(WI_I32X4_WIDEN_LOW_I16X8_S); break; - case ONYX_INTRINSIC_I32X4_WIDEN_HIGH_I16X8_S: WI(WI_I32X4_WIDEN_HIGH_I16X8_S); break; - case ONYX_INTRINSIC_I32X4_WIDEN_LOW_I16X8_U: WI(WI_I32X4_WIDEN_LOW_I16X8_U); break; - case ONYX_INTRINSIC_I32X4_WIDEN_HIGH_I16X8_U: WI(WI_I32X4_WIDEN_HIGH_I16X8_U); break; - case ONYX_INTRINSIC_I32X4_SHL: WI(WI_I32X4_SHL); break; - case ONYX_INTRINSIC_I32X4_SHR_S: WI(WI_I32X4_SHR_S); break; - case ONYX_INTRINSIC_I32X4_SHR_U: WI(WI_I32X4_SHR_U); break; - case ONYX_INTRINSIC_I32X4_ADD: WI(WI_I32X4_ADD); break; - case ONYX_INTRINSIC_I32X4_SUB: WI(WI_I32X4_SUB); break; - case ONYX_INTRINSIC_I32X4_MUL: WI(WI_I32X4_MUL); break; - case ONYX_INTRINSIC_I32X4_MIN_S: WI(WI_I32X4_MIN_S); break; - case ONYX_INTRINSIC_I32X4_MIN_U: WI(WI_I32X4_MIN_U); break; - case ONYX_INTRINSIC_I32X4_MAX_S: WI(WI_I32X4_MAX_S); break; - case ONYX_INTRINSIC_I32X4_MAX_U: WI(WI_I32X4_MAX_U); break; - - case ONYX_INTRINSIC_I64X2_NEG: WI(WI_I64X2_NEG); break; - case ONYX_INTRINSIC_I64X2_SHL: WI(WI_I64X2_SHL); break; - case ONYX_INTRINSIC_I64X2_SHR_S: WI(WI_I64X2_SHR_S); break; - case ONYX_INTRINSIC_I64X2_SHR_U: WI(WI_I64X2_SHR_U); break; - case ONYX_INTRINSIC_I64X2_ADD: WI(WI_I64X2_ADD); break; - case ONYX_INTRINSIC_I64X2_SUB: WI(WI_I64X2_SUB); break; - case ONYX_INTRINSIC_I64X2_MUL: WI(WI_I64X2_MUL); break; - - case ONYX_INTRINSIC_F32X4_ABS: WI(WI_F32X4_ABS); break; - case ONYX_INTRINSIC_F32X4_NEG: WI(WI_F32X4_NEG); break; - case ONYX_INTRINSIC_F32X4_SQRT: WI(WI_F32X4_SQRT); break; - case ONYX_INTRINSIC_F32X4_ADD: WI(WI_F32X4_ADD); break; - case ONYX_INTRINSIC_F32X4_SUB: WI(WI_F32X4_SUB); break; - case ONYX_INTRINSIC_F32X4_MUL: WI(WI_F32X4_MUL); break; - case ONYX_INTRINSIC_F32X4_DIV: WI(WI_F32X4_DIV); break; - case ONYX_INTRINSIC_F32X4_MIN: WI(WI_F32X4_MIN); break; - case ONYX_INTRINSIC_F32X4_MAX: WI(WI_F32X4_MAX); break; - - case ONYX_INTRINSIC_F64X2_ABS: WI(WI_F64X2_ABS); break; - case ONYX_INTRINSIC_F64X2_NEG: WI(WI_F64X2_NEG); break; - case ONYX_INTRINSIC_F64X2_SQRT: WI(WI_F64X2_SQRT); break; - case ONYX_INTRINSIC_F64X2_ADD: WI(WI_F64X2_ADD); break; - case ONYX_INTRINSIC_F64X2_SUB: WI(WI_F64X2_SUB); break; - case ONYX_INTRINSIC_F64X2_MUL: WI(WI_F64X2_MUL); break; - case ONYX_INTRINSIC_F64X2_DIV: WI(WI_F64X2_DIV); break; - case ONYX_INTRINSIC_F64X2_MIN: WI(WI_F64X2_MIN); break; - case ONYX_INTRINSIC_F64X2_MAX: WI(WI_F64X2_MAX); break; - - case ONYX_INTRINSIC_I32X4_TRUNC_SAT_F32X4_S: WI(WI_I32X4_TRUNC_SAT_F32X4_S); break; - case ONYX_INTRINSIC_I32X4_TRUNC_SAT_F32X4_U: WI(WI_I32X4_TRUNC_SAT_F32X4_U); break; - case ONYX_INTRINSIC_F32X4_CONVERT_I32X4_S: WI(WI_F32X4_CONVERT_I32X4_S); break; - case ONYX_INTRINSIC_F32X4_CONVERT_I32X4_U: WI(WI_F32X4_CONVERT_I32X4_U); break; + case ONYX_INTRINSIC_I8X16_SWIZZLE: WI(call->token, WI_I8X16_SWIZZLE); break; + case ONYX_INTRINSIC_I8X16_SPLAT: WI(call->token, WI_I8X16_SPLAT); break; + case ONYX_INTRINSIC_I16X8_SPLAT: WI(call->token, WI_I16X8_SPLAT); break; + case ONYX_INTRINSIC_I32X4_SPLAT: WI(call->token, WI_I32X4_SPLAT); break; + case ONYX_INTRINSIC_I64X2_SPLAT: WI(call->token, WI_I64X2_SPLAT); break; + case ONYX_INTRINSIC_F32X4_SPLAT: WI(call->token, WI_F32X4_SPLAT); break; + case ONYX_INTRINSIC_F64X2_SPLAT: WI(call->token, WI_F64X2_SPLAT); break; + + case ONYX_INTRINSIC_I8X16_EQ: WI(call->token, WI_I8X16_EQ); break; + case ONYX_INTRINSIC_I8X16_NEQ: WI(call->token, WI_I8X16_NEQ); break; + case ONYX_INTRINSIC_I8X16_LT_S: WI(call->token, WI_I8X16_LT_S); break; + case ONYX_INTRINSIC_I8X16_LT_U: WI(call->token, WI_I8X16_LT_U); break; + case ONYX_INTRINSIC_I8X16_GT_S: WI(call->token, WI_I8X16_GT_S); break; + case ONYX_INTRINSIC_I8X16_GT_U: WI(call->token, WI_I8X16_GT_U); break; + case ONYX_INTRINSIC_I8X16_LE_S: WI(call->token, WI_I8X16_LE_S); break; + case ONYX_INTRINSIC_I8X16_LE_U: WI(call->token, WI_I8X16_LE_U); break; + case ONYX_INTRINSIC_I8X16_GE_S: WI(call->token, WI_I8X16_GE_S); break; + case ONYX_INTRINSIC_I8X16_GE_U: WI(call->token, WI_I8X16_GE_U); break; + + case ONYX_INTRINSIC_I16X8_EQ: WI(call->token, WI_I16X8_EQ); break; + case ONYX_INTRINSIC_I16X8_NEQ: WI(call->token, WI_I16X8_NEQ); break; + case ONYX_INTRINSIC_I16X8_LT_S: WI(call->token, WI_I16X8_LT_S); break; + case ONYX_INTRINSIC_I16X8_LT_U: WI(call->token, WI_I16X8_LT_U); break; + case ONYX_INTRINSIC_I16X8_GT_S: WI(call->token, WI_I16X8_GT_S); break; + case ONYX_INTRINSIC_I16X8_GT_U: WI(call->token, WI_I16X8_GT_U); break; + case ONYX_INTRINSIC_I16X8_LE_S: WI(call->token, WI_I16X8_LE_S); break; + case ONYX_INTRINSIC_I16X8_LE_U: WI(call->token, WI_I16X8_LE_U); break; + case ONYX_INTRINSIC_I16X8_GE_S: WI(call->token, WI_I16X8_GE_S); break; + case ONYX_INTRINSIC_I16X8_GE_U: WI(call->token, WI_I16X8_GE_U); break; + + case ONYX_INTRINSIC_I32X4_EQ: WI(call->token, WI_I32X4_EQ); break; + case ONYX_INTRINSIC_I32X4_NEQ: WI(call->token, WI_I32X4_NEQ); break; + case ONYX_INTRINSIC_I32X4_LT_S: WI(call->token, WI_I32X4_LT_S); break; + case ONYX_INTRINSIC_I32X4_LT_U: WI(call->token, WI_I32X4_LT_U); break; + case ONYX_INTRINSIC_I32X4_GT_S: WI(call->token, WI_I32X4_GT_S); break; + case ONYX_INTRINSIC_I32X4_GT_U: WI(call->token, WI_I32X4_GT_U); break; + case ONYX_INTRINSIC_I32X4_LE_S: WI(call->token, WI_I32X4_LE_S); break; + case ONYX_INTRINSIC_I32X4_LE_U: WI(call->token, WI_I32X4_LE_U); break; + case ONYX_INTRINSIC_I32X4_GE_S: WI(call->token, WI_I32X4_GE_S); break; + case ONYX_INTRINSIC_I32X4_GE_U: WI(call->token, WI_I32X4_GE_U); break; + + case ONYX_INTRINSIC_F32X4_EQ: WI(call->token, WI_F32X4_EQ); break; + case ONYX_INTRINSIC_F32X4_NEQ: WI(call->token, WI_F32X4_NEQ); break; + case ONYX_INTRINSIC_F32X4_LT: WI(call->token, WI_F32X4_LT); break; + case ONYX_INTRINSIC_F32X4_GT: WI(call->token, WI_F32X4_GT); break; + case ONYX_INTRINSIC_F32X4_LE: WI(call->token, WI_F32X4_LE); break; + case ONYX_INTRINSIC_F32X4_GE: WI(call->token, WI_F32X4_GE); break; + + case ONYX_INTRINSIC_F64X2_EQ: WI(call->token, WI_F64X2_EQ); break; + case ONYX_INTRINSIC_F64X2_NEQ: WI(call->token, WI_F64X2_NEQ); break; + case ONYX_INTRINSIC_F64X2_LT: WI(call->token, WI_F64X2_LT); break; + case ONYX_INTRINSIC_F64X2_GT: WI(call->token, WI_F64X2_GT); break; + case ONYX_INTRINSIC_F64X2_LE: WI(call->token, WI_F64X2_LE); break; + case ONYX_INTRINSIC_F64X2_GE: WI(call->token, WI_F64X2_GE); break; + + case ONYX_INTRINSIC_V128_NOT: WI(call->token, WI_V128_NOT); break; + case ONYX_INTRINSIC_V128_AND: WI(call->token, WI_V128_AND); break; + case ONYX_INTRINSIC_V128_ANDNOT: WI(call->token, WI_V128_ANDNOT); break; + case ONYX_INTRINSIC_V128_OR: WI(call->token, WI_V128_OR); break; + case ONYX_INTRINSIC_V128_XOR: WI(call->token, WI_V128_XOR); break; + case ONYX_INTRINSIC_V128_BITSELECT: WI(call->token, WI_V128_BITSELECT); break; + + case ONYX_INTRINSIC_I8X16_ABS: WI(call->token, WI_I8X16_ABS); break; + case ONYX_INTRINSIC_I8X16_NEG: WI(call->token, WI_I8X16_NEG); break; + case ONYX_INTRINSIC_I8X16_ANY_TRUE: WI(call->token, WI_I8X16_ANY_TRUE); break; + case ONYX_INTRINSIC_I8X16_ALL_TRUE: WI(call->token, WI_I8X16_ALL_TRUE); break; + case ONYX_INTRINSIC_I8X16_BITMASK: WI(call->token, WI_I8X16_BITMASK); break; + case ONYX_INTRINSIC_I8X16_NARROW_I16X8_S: WI(call->token, WI_I8X16_NARROW_I16X8_S); break; + case ONYX_INTRINSIC_I8X16_NARROW_I16X8_U: WI(call->token, WI_I8X16_NARROW_I16X8_U); break; + case ONYX_INTRINSIC_I8X16_SHL: WI(call->token, WI_I8X16_SHL); break; + case ONYX_INTRINSIC_I8X16_SHR_S: WI(call->token, WI_I8X16_SHR_S); break; + case ONYX_INTRINSIC_I8X16_SHR_U: WI(call->token, WI_I8X16_SHR_U); break; + case ONYX_INTRINSIC_I8X16_ADD: WI(call->token, WI_I8X16_ADD); break; + case ONYX_INTRINSIC_I8X16_ADD_SAT_S: WI(call->token, WI_I8X16_ADD_SAT_S); break; + case ONYX_INTRINSIC_I8X16_ADD_SAT_U: WI(call->token, WI_I8X16_ADD_SAT_U); break; + case ONYX_INTRINSIC_I8X16_SUB: WI(call->token, WI_I8X16_SUB); break; + case ONYX_INTRINSIC_I8X16_SUB_SAT_S: WI(call->token, WI_I8X16_SUB_SAT_S); break; + case ONYX_INTRINSIC_I8X16_SUB_SAT_U: WI(call->token, WI_I8X16_SUB_SAT_U); break; + case ONYX_INTRINSIC_I8X16_MIN_S: WI(call->token, WI_I8X16_MIN_S); break; + case ONYX_INTRINSIC_I8X16_MIN_U: WI(call->token, WI_I8X16_MIN_U); break; + case ONYX_INTRINSIC_I8X16_MAX_S: WI(call->token, WI_I8X16_MAX_S); break; + case ONYX_INTRINSIC_I8X16_MAX_U: WI(call->token, WI_I8X16_MAX_U); break; + case ONYX_INTRINSIC_I8X16_AVGR_U: WI(call->token, WI_I8X16_AVGR_U); break; + + case ONYX_INTRINSIC_I16X8_ABS: WI(call->token, WI_I16X8_ABS); break; + case ONYX_INTRINSIC_I16X8_NEG: WI(call->token, WI_I16X8_NEG); break; + case ONYX_INTRINSIC_I16X8_ANY_TRUE: WI(call->token, WI_I16X8_ANY_TRUE); break; + case ONYX_INTRINSIC_I16X8_ALL_TRUE: WI(call->token, WI_I16X8_ALL_TRUE); break; + case ONYX_INTRINSIC_I16X8_BITMASK: WI(call->token, WI_I16X8_BITMASK); break; + case ONYX_INTRINSIC_I16X8_NARROW_I32X4_S: WI(call->token, WI_I16X8_NARROW_I32X4_S); break; + case ONYX_INTRINSIC_I16X8_NARROW_I32X4_U: WI(call->token, WI_I16X8_NARROW_I32X4_U); break; + case ONYX_INTRINSIC_I16X8_WIDEN_LOW_I8X16_S: WI(call->token, WI_I16X8_WIDEN_LOW_I8X16_S); break; + case ONYX_INTRINSIC_I16X8_WIDEN_HIGH_I8X16_S: WI(call->token, WI_I16X8_WIDEN_HIGH_I8X16_S); break; + case ONYX_INTRINSIC_I16X8_WIDEN_LOW_I8X16_U: WI(call->token, WI_I16X8_WIDEN_LOW_I8X16_U); break; + case ONYX_INTRINSIC_I16X8_WIDEN_HIGH_I8X16_U: WI(call->token, WI_I16X8_WIDEN_HIGH_I8X16_U); break; + case ONYX_INTRINSIC_I16X8_SHL: WI(call->token, WI_I16X8_SHL); break; + case ONYX_INTRINSIC_I16X8_SHR_S: WI(call->token, WI_I16X8_SHR_S); break; + case ONYX_INTRINSIC_I16X8_SHR_U: WI(call->token, WI_I16X8_SHR_U); break; + case ONYX_INTRINSIC_I16X8_ADD: WI(call->token, WI_I16X8_ADD); break; + case ONYX_INTRINSIC_I16X8_ADD_SAT_S: WI(call->token, WI_I16X8_ADD_SAT_S); break; + case ONYX_INTRINSIC_I16X8_ADD_SAT_U: WI(call->token, WI_I16X8_ADD_SAT_U); break; + case ONYX_INTRINSIC_I16X8_SUB: WI(call->token, WI_I16X8_SUB); break; + case ONYX_INTRINSIC_I16X8_SUB_SAT_S: WI(call->token, WI_I16X8_SUB_SAT_S); break; + case ONYX_INTRINSIC_I16X8_SUB_SAT_U: WI(call->token, WI_I16X8_SUB_SAT_U); break; + case ONYX_INTRINSIC_I16X8_MUL: WI(call->token, WI_I16X8_MUL); break; + case ONYX_INTRINSIC_I16X8_MIN_S: WI(call->token, WI_I16X8_MIN_S); break; + case ONYX_INTRINSIC_I16X8_MIN_U: WI(call->token, WI_I16X8_MIN_U); break; + case ONYX_INTRINSIC_I16X8_MAX_S: WI(call->token, WI_I16X8_MAX_S); break; + case ONYX_INTRINSIC_I16X8_MAX_U: WI(call->token, WI_I16X8_MAX_U); break; + case ONYX_INTRINSIC_I16X8_AVGR_U: WI(call->token, WI_I16X8_AVGR_U); break; + + case ONYX_INTRINSIC_I32X4_ABS: WI(call->token, WI_I32X4_ABS); break; + case ONYX_INTRINSIC_I32X4_NEG: WI(call->token, WI_I32X4_NEG); break; + case ONYX_INTRINSIC_I32X4_ANY_TRUE: WI(call->token, WI_I32X4_ANY_TRUE); break; + case ONYX_INTRINSIC_I32X4_ALL_TRUE: WI(call->token, WI_I32X4_ALL_TRUE); break; + case ONYX_INTRINSIC_I32X4_BITMASK: WI(call->token, WI_I32X4_BITMASK); break; + case ONYX_INTRINSIC_I32X4_WIDEN_LOW_I16X8_S: WI(call->token, WI_I32X4_WIDEN_LOW_I16X8_S); break; + case ONYX_INTRINSIC_I32X4_WIDEN_HIGH_I16X8_S: WI(call->token, WI_I32X4_WIDEN_HIGH_I16X8_S); break; + case ONYX_INTRINSIC_I32X4_WIDEN_LOW_I16X8_U: WI(call->token, WI_I32X4_WIDEN_LOW_I16X8_U); break; + case ONYX_INTRINSIC_I32X4_WIDEN_HIGH_I16X8_U: WI(call->token, WI_I32X4_WIDEN_HIGH_I16X8_U); break; + case ONYX_INTRINSIC_I32X4_SHL: WI(call->token, WI_I32X4_SHL); break; + case ONYX_INTRINSIC_I32X4_SHR_S: WI(call->token, WI_I32X4_SHR_S); break; + case ONYX_INTRINSIC_I32X4_SHR_U: WI(call->token, WI_I32X4_SHR_U); break; + case ONYX_INTRINSIC_I32X4_ADD: WI(call->token, WI_I32X4_ADD); break; + case ONYX_INTRINSIC_I32X4_SUB: WI(call->token, WI_I32X4_SUB); break; + case ONYX_INTRINSIC_I32X4_MUL: WI(call->token, WI_I32X4_MUL); break; + case ONYX_INTRINSIC_I32X4_MIN_S: WI(call->token, WI_I32X4_MIN_S); break; + case ONYX_INTRINSIC_I32X4_MIN_U: WI(call->token, WI_I32X4_MIN_U); break; + case ONYX_INTRINSIC_I32X4_MAX_S: WI(call->token, WI_I32X4_MAX_S); break; + case ONYX_INTRINSIC_I32X4_MAX_U: WI(call->token, WI_I32X4_MAX_U); break; + + case ONYX_INTRINSIC_I64X2_NEG: WI(call->token, WI_I64X2_NEG); break; + case ONYX_INTRINSIC_I64X2_SHL: WI(call->token, WI_I64X2_SHL); break; + case ONYX_INTRINSIC_I64X2_SHR_S: WI(call->token, WI_I64X2_SHR_S); break; + case ONYX_INTRINSIC_I64X2_SHR_U: WI(call->token, WI_I64X2_SHR_U); break; + case ONYX_INTRINSIC_I64X2_ADD: WI(call->token, WI_I64X2_ADD); break; + case ONYX_INTRINSIC_I64X2_SUB: WI(call->token, WI_I64X2_SUB); break; + case ONYX_INTRINSIC_I64X2_MUL: WI(call->token, WI_I64X2_MUL); break; + + case ONYX_INTRINSIC_F32X4_ABS: WI(call->token, WI_F32X4_ABS); break; + case ONYX_INTRINSIC_F32X4_NEG: WI(call->token, WI_F32X4_NEG); break; + case ONYX_INTRINSIC_F32X4_SQRT: WI(call->token, WI_F32X4_SQRT); break; + case ONYX_INTRINSIC_F32X4_ADD: WI(call->token, WI_F32X4_ADD); break; + case ONYX_INTRINSIC_F32X4_SUB: WI(call->token, WI_F32X4_SUB); break; + case ONYX_INTRINSIC_F32X4_MUL: WI(call->token, WI_F32X4_MUL); break; + case ONYX_INTRINSIC_F32X4_DIV: WI(call->token, WI_F32X4_DIV); break; + case ONYX_INTRINSIC_F32X4_MIN: WI(call->token, WI_F32X4_MIN); break; + case ONYX_INTRINSIC_F32X4_MAX: WI(call->token, WI_F32X4_MAX); break; + + case ONYX_INTRINSIC_F64X2_ABS: WI(call->token, WI_F64X2_ABS); break; + case ONYX_INTRINSIC_F64X2_NEG: WI(call->token, WI_F64X2_NEG); break; + case ONYX_INTRINSIC_F64X2_SQRT: WI(call->token, WI_F64X2_SQRT); break; + case ONYX_INTRINSIC_F64X2_ADD: WI(call->token, WI_F64X2_ADD); break; + case ONYX_INTRINSIC_F64X2_SUB: WI(call->token, WI_F64X2_SUB); break; + case ONYX_INTRINSIC_F64X2_MUL: WI(call->token, WI_F64X2_MUL); break; + case ONYX_INTRINSIC_F64X2_DIV: WI(call->token, WI_F64X2_DIV); break; + case ONYX_INTRINSIC_F64X2_MIN: WI(call->token, WI_F64X2_MIN); break; + case ONYX_INTRINSIC_F64X2_MAX: WI(call->token, WI_F64X2_MAX); break; + + case ONYX_INTRINSIC_I32X4_TRUNC_SAT_F32X4_S: WI(call->token, WI_I32X4_TRUNC_SAT_F32X4_S); break; + case ONYX_INTRINSIC_I32X4_TRUNC_SAT_F32X4_U: WI(call->token, WI_I32X4_TRUNC_SAT_F32X4_U); break; + case ONYX_INTRINSIC_F32X4_CONVERT_I32X4_S: WI(call->token, WI_F32X4_CONVERT_I32X4_S); break; + case ONYX_INTRINSIC_F32X4_CONVERT_I32X4_U: WI(call->token, WI_F32X4_CONVERT_I32X4_U); break; case ONYX_INTRINSIC_ATOMIC_WAIT: { Type* atomic_type = ((AstArgument *) call->args.values[0])->value->type->Pointer.elem; @@ -2232,8 +2275,8 @@ EMIT_FUNC(subscript_location, AstSubscript* sub, u64* offset_return) { emit_expression(mod, &code, sub->expr); if (sub->elem_size != 1) { - WID(WI_PTR_CONST, sub->elem_size); - WI(WI_PTR_MUL); + WID(sub->token, WI_PTR_CONST, sub->elem_size); + WI(sub->token, WI_PTR_MUL); } // CLEANUP: This is one dense clusterf**k of code... @@ -2254,7 +2297,7 @@ EMIT_FUNC(subscript_location, AstSubscript* sub, u64* offset_return) { emit_expression(mod, &code, sub->addr); } - WI(WI_PTR_ADD); + WI(sub->token, WI_PTR_ADD); *offset_return += offset; @@ -2302,9 +2345,9 @@ EMIT_FUNC(memory_reservation_location, AstMemRes* memres) { if (memres->threadlocal) { u64 tls_base_idx = bh_imap_get(&mod->index_map, (u64) &builtin_tls_base); - WID(WI_PTR_CONST, memres->tls_offset); - WIL(WI_GLOBAL_GET, tls_base_idx); - WI(WI_PTR_ADD); + WID(memres->token, WI_PTR_CONST, memres->tls_offset); + WIL(memres->token, WI_GLOBAL_GET, tls_base_idx); + WI(memres->token, WI_PTR_ADD); } else { // :ProperLinking @@ -2323,10 +2366,10 @@ EMIT_FUNC(local_location, AstLocal* local, u64* offset_return) { if (local_offset & LOCAL_IS_WASM) { // This is a weird condition but it is relied on in a couple places including // passing non-simple structs by value. -brendanfh 2020/09/18 - WIL(WI_LOCAL_GET, local_offset); + WIL(NULL, WI_LOCAL_GET, local_offset); } else { - WIL(WI_LOCAL_GET, mod->stack_base_idx); + WIL(NULL, WI_LOCAL_GET, mod->stack_base_idx); *offset_return += local_offset; } @@ -2356,11 +2399,11 @@ EMIT_FUNC(compound_load, Type* type, u64 offset) { emit_load_instruction(mod, &code, two.type, offset + two.offset); // two.offset should be 0 } else { u64 tmp_idx = local_raw_allocate(mod->local_alloc, WASM_TYPE_PTR); - WIL(WI_LOCAL_TEE, tmp_idx); + WIL(NULL, WI_LOCAL_TEE, tmp_idx); fori (i, 0, mem_count) { type_linear_member_lookup(type, i, &two); - if (i != 0) WIL(WI_LOCAL_GET, tmp_idx); + if (i != 0) WIL(NULL, WI_LOCAL_GET, tmp_idx); emit_load_instruction(mod, &code, two.type, offset + two.offset); } @@ -2377,7 +2420,7 @@ EMIT_FUNC(compound_store, Type* type, u64 offset, b32 location_first) { TypeWithOffset two; u64 loc_idx = local_raw_allocate(mod->local_alloc, WASM_TYPE_PTR); - if (location_first) WIL(WI_LOCAL_SET, loc_idx); + if (location_first) WIL(NULL, WI_LOCAL_SET, loc_idx); i32 elem_count = type_linear_member_count(type); u64 *temp_locals = bh_alloc_array(global_scratch_allocator, u64, elem_count); @@ -2387,17 +2430,17 @@ EMIT_FUNC(compound_store, Type* type, u64 offset, b32 location_first) { WasmType wt = onyx_type_to_wasm_type(two.type); temp_locals[i] = local_raw_allocate(mod->local_alloc, wt); - WIL(WI_LOCAL_SET, temp_locals[i]); + WIL(NULL, WI_LOCAL_SET, temp_locals[i]); } - if (!location_first) WIL(WI_LOCAL_SET, loc_idx); + if (!location_first) WIL(NULL, WI_LOCAL_SET, loc_idx); fori (i, 0, elem_count) { type_linear_member_lookup(type, i, &two); u64 tmp_idx = temp_locals[i]; - WIL(WI_LOCAL_GET, loc_idx); - WIL(WI_LOCAL_GET, tmp_idx); + WIL(NULL, WI_LOCAL_GET, loc_idx); + WIL(NULL, WI_LOCAL_GET, tmp_idx); emit_store_instruction(mod, &code, two.type, offset + two.offset); WasmType wt = onyx_type_to_wasm_type(two.type); @@ -2436,13 +2479,13 @@ EMIT_FUNC(array_store, Type* type, u32 offset) { u64 lptr_local = local_raw_allocate(mod->local_alloc, WASM_TYPE_PTR); u64 rptr_local = local_raw_allocate(mod->local_alloc, WASM_TYPE_PTR); - WIL(WI_LOCAL_SET, rptr_local); - WIL(WI_LOCAL_SET, lptr_local); + WIL(NULL, WI_LOCAL_SET, rptr_local); + WIL(NULL, WI_LOCAL_SET, lptr_local); - WIL(WI_LOCAL_GET, rptr_local); - WID(WI_I32_CONST, 0); - WI(WI_I32_NE); - emit_enter_structured_block(mod, &code, SBT_Basic_If); + WIL(NULL, WI_LOCAL_GET, rptr_local); + WID(NULL, WI_I32_CONST, 0); + WI(NULL, WI_I32_NE); + emit_enter_structured_block(mod, &code, SBT_Basic_If, NULL); // // CLEANUP: Most of these cases could be much shorter if they used existing intrinsics. @@ -2454,9 +2497,9 @@ EMIT_FUNC(array_store, Type* type, u32 offset) { if (bh_arr_last(code).type == WI_LOCAL_SET && (u64) bh_arr_last(code).data.l == lptr_local) bh_arr_last(code).type = WI_LOCAL_TEE; else - WIL(WI_LOCAL_GET, lptr_local); + WIL(NULL, WI_LOCAL_GET, lptr_local); - WIL(WI_LOCAL_GET, rptr_local); + WIL(NULL, WI_LOCAL_GET, rptr_local); emit_load_instruction(mod, &code, elem_type, i * elem_size); emit_store_instruction(mod, &code, elem_type, i * elem_size + offset); @@ -2468,69 +2511,69 @@ EMIT_FUNC(array_store, Type* type, u32 offset) { if (bh_arr_last(code).type == WI_LOCAL_SET && (u64) bh_arr_last(code).data.l == lptr_local) bh_arr_last(code).type = WI_LOCAL_TEE; else - WIL(WI_LOCAL_GET, lptr_local); + WIL(NULL, WI_LOCAL_GET, lptr_local); if (offset != 0) { - WIL(WI_PTR_CONST, offset); - WI(WI_PTR_ADD); + WIL(NULL, WI_PTR_CONST, offset); + WI(NULL, WI_PTR_ADD); } - WIL(WI_LOCAL_GET, rptr_local); - WIL(WI_I32_CONST, elem_count * elem_size); - WI(WI_MEMORY_COPY); + WIL(NULL, WI_LOCAL_GET, rptr_local); + WIL(NULL, WI_I32_CONST, elem_count * elem_size); + WI(NULL, WI_MEMORY_COPY); } else { // Emit a loop that copies the memory. This could be switched to a tight loop that just copies word per word. u64 offset_local = local_raw_allocate(mod->local_alloc, WASM_TYPE_PTR); - WIL(WI_PTR_CONST, 0); - WIL(WI_LOCAL_SET, offset_local); + WIL(NULL, WI_PTR_CONST, 0); + WIL(NULL, WI_LOCAL_SET, offset_local); - WID(WI_BLOCK_START, 0x40); - WID(WI_LOOP_START, 0x40); - WIL(WI_LOCAL_GET, offset_local); - WIL(WI_LOCAL_GET, lptr_local); - WI(WI_PTR_ADD); + WID(NULL, WI_BLOCK_START, 0x40); + WID(NULL, WI_LOOP_START, 0x40); + WIL(NULL, WI_LOCAL_GET, offset_local); + WIL(NULL, WI_LOCAL_GET, lptr_local); + WI(NULL, WI_PTR_ADD); - WIL(WI_LOCAL_GET, offset_local); - WIL(WI_LOCAL_GET, rptr_local); - WI(WI_PTR_ADD); + WIL(NULL, WI_LOCAL_GET, offset_local); + WIL(NULL, WI_LOCAL_GET, rptr_local); + WI(NULL, WI_PTR_ADD); emit_load_instruction(mod, &code, elem_type, 0); emit_store_instruction(mod, &code, elem_type, offset); - WIL(WI_LOCAL_GET, offset_local); - WIL(WI_PTR_CONST, elem_size); - WI(WI_PTR_ADD); - WIL(WI_LOCAL_TEE, offset_local); + WIL(NULL, WI_LOCAL_GET, offset_local); + WIL(NULL, WI_PTR_CONST, elem_size); + WI(NULL, WI_PTR_ADD); + WIL(NULL, WI_LOCAL_TEE, offset_local); - WIL(WI_PTR_CONST, elem_count * elem_size); - WI(WI_PTR_GE); - WID(WI_COND_JUMP, 0x01); + WIL(NULL, WI_PTR_CONST, elem_count * elem_size); + WI(NULL, WI_PTR_GE); + WID(NULL, WI_COND_JUMP, 0x01); - WID(WI_JUMP, 0x00); + WID(NULL, WI_JUMP, 0x00); - WI(WI_LOOP_END); - WI(WI_BLOCK_END); + WI(NULL, WI_LOOP_END); + WI(NULL, WI_BLOCK_END); local_raw_free(mod->local_alloc, WASM_TYPE_PTR); } - WI(WI_ELSE); + WI(NULL, WI_ELSE); { // If the source ptr is null (0), then just copy in 0 bytes. - WIL(WI_LOCAL_GET, lptr_local); + WIL(NULL, WI_LOCAL_GET, lptr_local); if (offset != 0) { - WIL(WI_PTR_CONST, offset); - WI(WI_PTR_ADD); + WIL(NULL, WI_PTR_CONST, offset); + WI(NULL, WI_PTR_ADD); } - WIL(WI_I32_CONST, 0); + WIL(NULL, WI_I32_CONST, 0); - WIL(WI_I32_CONST, elem_count * elem_size); + WIL(NULL, WI_I32_CONST, elem_count * elem_size); if (context.options->use_post_mvp_features) { - WI(WI_MEMORY_FILL); + WI(NULL, WI_MEMORY_FILL); } else { emit_intrinsic_memory_fill(mod, &code); } @@ -2555,14 +2598,14 @@ EMIT_FUNC(array_literal, AstArrayLiteral* al) { u32 elem_size = type_size_of(al->type->Array.elem); fori (i, 0, al->type->Array.count) { - WIL(WI_LOCAL_GET, mod->stack_base_idx); + WIL(al->token, WI_LOCAL_GET, mod->stack_base_idx); emit_expression(mod, &code, al->values[i]); emit_store_instruction(mod, &code, al->type->Array.elem, local_offset + i * elem_size); } - WIL(WI_LOCAL_GET, mod->stack_base_idx); - WIL(WI_PTR_CONST, local_offset); - WI(WI_PTR_ADD); + WIL(al->token, WI_LOCAL_GET, mod->stack_base_idx); + WIL(al->token, WI_PTR_CONST, local_offset); + WI(al->token, WI_PTR_ADD); *pcode = code; } @@ -2587,22 +2630,22 @@ EMIT_FUNC(if_expression, AstIfExpression* if_expr) { emit_expression(mod, &code, if_expr->cond); - emit_enter_structured_block(mod, &code, SBT_Basic_If); + emit_enter_structured_block(mod, &code, SBT_Basic_If, if_expr->token); if (!result_is_local) emit_local_location(mod, &code, (AstLocal *) if_expr, &offset); emit_expression(mod, &code, if_expr->true_expr); if (!result_is_local) emit_store_instruction(mod, &code, if_expr->type, offset); - else WIL(WI_LOCAL_SET, result_local); + else WIL(if_expr->token, WI_LOCAL_SET, result_local); offset = 0; - WI(WI_ELSE); + WI(if_expr->token, WI_ELSE); if (!result_is_local) emit_local_location(mod, &code, (AstLocal *) if_expr, &offset); emit_expression(mod, &code, if_expr->false_expr); if (!result_is_local) emit_store_instruction(mod, &code, if_expr->type, offset); - else WIL(WI_LOCAL_SET, result_local); + else WIL(if_expr->token, WI_LOCAL_SET, result_local); emit_leave_structured_block(mod, &code); @@ -2612,7 +2655,7 @@ EMIT_FUNC(if_expression, AstIfExpression* if_expr) { emit_load_instruction(mod, &code, if_expr->type, offset); } else { - WIL(WI_LOCAL_GET, result_local); + WIL(if_expr->token, WI_LOCAL_GET, result_local); } local_free(mod->local_alloc, (AstTyped *) if_expr); @@ -2637,7 +2680,7 @@ EMIT_FUNC(do_block, AstDoBlock* doblock) { emit_load_instruction(mod, &code, doblock->type, offset); } else { - WIL(WI_LOCAL_GET, result_local); + WIL(doblock->block->token, WI_LOCAL_GET, result_local); } bh_arr_pop(mod->return_location_stack); @@ -2700,8 +2743,8 @@ EMIT_FUNC(location, AstTyped* expr) { u64 offset = 0; emit_location_return_offset(mod, &code, expr, &offset); if (offset != 0) { - WID(WI_PTR_CONST, offset); - WI(WI_PTR_ADD); + WID(NULL, WI_PTR_CONST, offset); + WI(NULL, WI_PTR_ADD); } *pcode = code; @@ -2715,10 +2758,10 @@ EMIT_FUNC(expression, AstTyped* expr) { if (type->flags & Ast_Flag_Expr_Ignored) return; if (type->type_id != 0) { - WID(WI_I32_CONST, ((AstType *) expr)->type_id); + WID(NULL, WI_I32_CONST, ((AstType *) expr)->type_id); } else { Type* t = type_build_from_ast(context.ast_alloc, type); - WID(WI_I32_CONST, t->id); + WID(NULL, WI_I32_CONST, t->id); } @@ -2735,18 +2778,18 @@ EMIT_FUNC(expression, AstTyped* expr) { case Param_Pass_By_Value: { if (type_is_structlike_strict(expr->type)) { u32 mem_count = type_structlike_mem_count(expr->type); - fori (idx, 0, mem_count) WIL(WI_LOCAL_GET, localidx + idx); + fori (idx, 0, mem_count) WIL(NULL, WI_LOCAL_GET, localidx + idx); } else { assert(localidx & LOCAL_IS_WASM); - WIL(WI_LOCAL_GET, localidx); + WIL(NULL, WI_LOCAL_GET, localidx); } break; } case Param_Pass_By_Implicit_Pointer: { assert(localidx & LOCAL_IS_WASM); - WIL(WI_LOCAL_GET, localidx); + WIL(NULL, WI_LOCAL_GET, localidx); emit_load_instruction(mod, &code, expr->type, 0); break; } @@ -2764,7 +2807,7 @@ EMIT_FUNC(expression, AstTyped* expr) { if (bh_arr_last(code).type == WI_LOCAL_SET && (u64) bh_arr_last(code).data.l == tmp) { bh_arr_last(code).type = WI_LOCAL_TEE; } else { - WIL(WI_LOCAL_GET, tmp); + WIL(NULL, WI_LOCAL_GET, tmp); } } else { @@ -2774,8 +2817,8 @@ EMIT_FUNC(expression, AstTyped* expr) { if (expr->type->kind != Type_Kind_Array) { emit_load_instruction(mod, &code, expr->type, offset); } else if (offset != 0) { - WID(WI_PTR_CONST, offset); - WI(WI_PTR_ADD); + WID(NULL, WI_PTR_CONST, offset); + WI(NULL, WI_PTR_ADD); } } @@ -2785,7 +2828,7 @@ EMIT_FUNC(expression, AstTyped* expr) { case Ast_Kind_Global: { i32 globalidx = (i32) bh_imap_get(&mod->index_map, (u64) expr); - WID(WI_GLOBAL_GET, globalidx); + WID(NULL, WI_GLOBAL_GET, globalidx); break; } @@ -2819,7 +2862,7 @@ EMIT_FUNC(expression, AstTyped* expr) { emit_data_relocation(mod, &code, strlit->data_id); if (strlit->is_cstr == 0) - WID(WI_I32_CONST, strlit->length); + WID(NULL, WI_I32_CONST, strlit->length); break; } @@ -2842,7 +2885,7 @@ EMIT_FUNC(expression, AstTyped* expr) { case Ast_Kind_Function: { i32 elemidx = get_element_idx(mod, (AstFunction *) expr); - WID(WI_I32_CONST, elemidx); + WID(NULL, WI_I32_CONST, elemidx); break; } @@ -2893,7 +2936,7 @@ EMIT_FUNC(expression, AstTyped* expr) { if (type_get_param_pass(field->expr->type) == Param_Pass_By_Value && !type_is_pointer(field->expr->type)) { u64 localidx = bh_imap_get(&mod->local_map, (u64) field->expr) + field->idx; assert(localidx & LOCAL_IS_WASM); - WIL(WI_LOCAL_GET, localidx); + WIL(NULL, WI_LOCAL_GET, localidx); break; } } @@ -2912,13 +2955,13 @@ EMIT_FUNC(expression, AstTyped* expr) { if (idx == 0) { // Easy case: the member is the first one and all other members just have to be dropped. - fori (i, 0, total_linear_members - field_linear_members) WI(WI_DROP); + fori (i, 0, total_linear_members - field_linear_members) WI(NULL, WI_DROP); } else { // Tough case: Stack shuffling to make the member the only thing on the stack. // This is very similar to the compound_load/compound_store procedures but it is different enough // that I cannot find a good way to factor them all without just introducing a ton of complexity. - fori (i, 0, total_linear_members - idx - field_linear_members) WI(WI_DROP); + fori (i, 0, total_linear_members - idx - field_linear_members) WI(NULL, WI_DROP); u64 *temporaries = bh_alloc_array(global_scratch_allocator, u64, field_linear_members); fori (i, 0, field_linear_members) temporaries[i] = 0; @@ -2929,15 +2972,15 @@ EMIT_FUNC(expression, AstTyped* expr) { WasmType wt = onyx_type_to_wasm_type(two.type); temporaries[i] = local_raw_allocate(mod->local_alloc, wt); - WIL(WI_LOCAL_SET, temporaries[i]); + WIL(NULL, WI_LOCAL_SET, temporaries[i]); } - fori (i, 0, idx) WI(WI_DROP); + fori (i, 0, idx) WI(NULL, WI_DROP); fori (i, 0, field_linear_members) { type_linear_member_lookup(field->type, i, &two); - WIL(WI_LOCAL_GET, temporaries[i]); + WIL(NULL, WI_LOCAL_GET, temporaries[i]); WasmType wt = onyx_type_to_wasm_type(two.type); local_raw_free(mod->local_alloc, wt); @@ -2958,18 +3001,18 @@ EMIT_FUNC(expression, AstTyped* expr) { u64 lo_local = local_raw_allocate(mod->local_alloc, WASM_TYPE_INT32); u64 hi_local = local_raw_allocate(mod->local_alloc, WASM_TYPE_INT32); - WI(WI_DROP); - WIL(WI_LOCAL_SET, hi_local); - WIL(WI_LOCAL_TEE, lo_local); + WI(NULL, WI_DROP); + WIL(NULL, WI_LOCAL_SET, hi_local); + WIL(NULL, WI_LOCAL_TEE, lo_local); if (sl->elem_size != 1) { - WID(WI_I32_CONST, sl->elem_size); - WI(WI_I32_MUL); + WID(NULL, WI_I32_CONST, sl->elem_size); + WI(NULL, WI_I32_MUL); } emit_expression(mod, &code, sl->addr); - WI(WI_I32_ADD); - WIL(WI_LOCAL_GET, hi_local); - WIL(WI_LOCAL_GET, lo_local); - WI(WI_I32_SUB); + WI(NULL, WI_I32_ADD); + WIL(NULL, WI_LOCAL_GET, hi_local); + WIL(NULL, WI_LOCAL_GET, lo_local); + WI(NULL, WI_I32_SUB); local_raw_free(mod->local_alloc, lo_local); local_raw_free(mod->local_alloc, hi_local); @@ -2978,13 +3021,13 @@ EMIT_FUNC(expression, AstTyped* expr) { case Ast_Kind_Size_Of: { AstSizeOf* so = (AstSizeOf *) expr; - WID(WI_I32_CONST, so->size); + WID(NULL, WI_I32_CONST, so->size); break; } case Ast_Kind_Align_Of: { AstAlignOf* ao = (AstAlignOf *) expr; - WID(WI_I32_CONST, ao->alignment); + WID(NULL, WI_I32_CONST, ao->alignment); break; } @@ -2994,8 +3037,8 @@ EMIT_FUNC(expression, AstTyped* expr) { assert(num->kind == Ast_Kind_NumLit); WasmType backing_type = onyx_type_to_wasm_type(ev->type); - if (backing_type == WASM_TYPE_INT32) WID(WI_I32_CONST, num->value.i); - else if (backing_type == WASM_TYPE_INT64) WID(WI_I64_CONST, num->value.l); + if (backing_type == WASM_TYPE_INT32) WID(NULL, WI_I32_CONST, num->value.i); + else if (backing_type == WASM_TYPE_INT64) WID(NULL, WI_I64_CONST, num->value.l); else onyx_report_error(ev->token->pos, Error_Critical, "Invalid backing type for enum."); break; } @@ -3015,7 +3058,7 @@ EMIT_FUNC(expression, AstTyped* expr) { // :ProperLinking emit_data_relocation(mod, &code, fc->data_id); - WID(WI_I32_CONST, fc->size); + WID(NULL, WI_I32_CONST, fc->size); break; } @@ -3059,7 +3102,7 @@ EMIT_FUNC(expression, AstTyped* expr) { case Ast_Kind_Foreign_Block: { AstForeignBlock *fb = (AstForeignBlock *) expr; - WID(WI_I32_CONST, fb->foreign_block_number); + WID(NULL, WI_I32_CONST, fb->foreign_block_number); break; } @@ -3079,7 +3122,7 @@ EMIT_FUNC(expression, AstTyped* expr) { if ((expr->flags & Ast_Flag_Expr_Ignored) != 0 && !type_results_in_void(expr->type)) { i32 mem_count = 1; if (type_is_compound(expr->type)) mem_count = type_linear_member_count(expr->type); - fori (i, 0, mem_count) WI(WI_DROP); + fori (i, 0, mem_count) WI(NULL, WI_DROP); } *pcode = code; @@ -3117,21 +3160,21 @@ EMIT_FUNC(cast, AstUnaryOp* cast) { } if (to->kind == Type_Kind_Basic && to->Basic.kind == Basic_Kind_Void) { - WI(WI_DROP); + WI(NULL, WI_DROP); *pcode = code; return; } if (to->kind == Type_Kind_Slice && from->kind == Type_Kind_Array) { - WID(WI_I32_CONST, from->Array.count); + WID(NULL, WI_I32_CONST, from->Array.count); *pcode = code; return; } if (to->kind == Type_Kind_Slice && from->kind == Type_Kind_DynArray) { - WI(WI_DROP); - WI(WI_DROP); - WI(WI_DROP); + WI(NULL, WI_DROP); + WI(NULL, WI_DROP); + WI(NULL, WI_DROP); *pcode = code; return; } @@ -3198,7 +3241,7 @@ EMIT_FUNC(cast, AstUnaryOp* cast) { assert(cast_op != WI_UNREACHABLE); if (cast_op != WI_NOP) { - WI(cast_op); + WI(NULL, cast_op); } } @@ -3221,12 +3264,12 @@ EMIT_FUNC(return, AstReturn* ret) { emit_expression(mod, &code, ret->expr); if (!dest_is_local) emit_store_instruction(mod, &code, dest->type, offset); - else WIL(WI_LOCAL_SET, dest_loc); + else WIL(NULL, WI_LOCAL_SET, dest_loc); } else if (mod->curr_cc == CC_Return_Stack) { - WIL(WI_LOCAL_GET, mod->stack_base_idx); - WID(WI_I32_CONST, type_size_of(ret->expr->type)); - WI(WI_I32_SUB); + WIL(NULL, WI_LOCAL_GET, mod->stack_base_idx); + WID(NULL, WI_I32_CONST, type_size_of(ret->expr->type)); + WI(NULL, WI_I32_SUB); emit_expression(mod, &code, ret->expr); emit_store_instruction(mod, &code, ret->expr->type, 0); @@ -3241,7 +3284,7 @@ EMIT_FUNC(return, AstReturn* ret) { i64 jump_label = get_structured_jump_label(mod, Jump_Type_Return, 1); if (jump_label >= 0) { - WIL(WI_JUMP, jump_label); + WIL(NULL, WI_JUMP, jump_label); } else { // Clear the rest of the deferred statements @@ -3255,10 +3298,10 @@ EMIT_FUNC(return, AstReturn* ret) { // Make a patch for the two instructions needed to restore the stack pointer SUBMIT_PATCH(mod->stack_leave_patches, 0); - WI(WI_NOP); - WI(WI_NOP); + WI(NULL, WI_NOP); + WI(NULL, WI_NOP); - WI(WI_RETURN); + WI(NULL, WI_RETURN); } *pcode = code; @@ -3293,13 +3336,13 @@ EMIT_FUNC(zero_value, WasmType wt) { bh_arr(WasmInstruction) code = *pcode; switch (wt) { - case WASM_TYPE_INT32: WIL(WI_I32_CONST, 0); break; - case WASM_TYPE_INT64: WIL(WI_I64_CONST, 0); break; - case WASM_TYPE_FLOAT32: WIL(WI_F32_CONST, 0); break; - case WASM_TYPE_FLOAT64: WIL(WI_F64_CONST, 0); break; + case WASM_TYPE_INT32: WIL(NULL, WI_I32_CONST, 0); break; + case WASM_TYPE_INT64: WIL(NULL, WI_I64_CONST, 0); break; + case WASM_TYPE_FLOAT32: WIL(NULL, WI_F32_CONST, 0); break; + case WASM_TYPE_FLOAT64: WIL(NULL, WI_F64_CONST, 0); break; case WASM_TYPE_VAR128: { static u8 zero_v128[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; - WIP(WI_V128_CONST, &zero_v128); + WIP(NULL, WI_V128_CONST, &zero_v128); break; } } @@ -3320,7 +3363,7 @@ EMIT_FUNC(zero_value_for_type, Type* type, OnyxToken* where) { } } else if (type->kind == Type_Kind_Function) { - WID(WI_I32_CONST, mod->null_proc_func_idx); + WID(NULL, WI_I32_CONST, mod->null_proc_func_idx); } else { WasmType wt = onyx_type_to_wasm_type(type); diff --git a/src/wasm_intrinsics.h b/src/wasm_intrinsics.h index 72b6bf83..59633ffc 100644 --- a/src/wasm_intrinsics.h +++ b/src/wasm_intrinsics.h @@ -19,41 +19,41 @@ EMIT_FUNC_NO_ARGS(intrinsic_memory_copy) { u64 source_local = local_raw_allocate(mod->local_alloc, WASM_TYPE_PTR); u64 dest_local = local_raw_allocate(mod->local_alloc, WASM_TYPE_PTR); - WIL(WI_LOCAL_SET, count_local); - WIL(WI_LOCAL_SET, source_local); - WIL(WI_LOCAL_SET, dest_local); + WIL(NULL, WI_LOCAL_SET, count_local); + WIL(NULL, WI_LOCAL_SET, source_local); + WIL(NULL, WI_LOCAL_SET, dest_local); // count is greater than 0 - WIL(WI_LOCAL_GET, count_local); - WID(WI_I32_CONST, 0); - WI(WI_I32_GT_S); + WIL(NULL, WI_LOCAL_GET, count_local); + WID(NULL, WI_I32_CONST, 0); + WI(NULL, WI_I32_GT_S); - WID(WI_IF_START, 0x40); - WID(WI_LOOP_START, 0x40); + WID(NULL, WI_IF_START, 0x40); + WID(NULL, WI_LOOP_START, 0x40); - WIL(WI_LOCAL_GET, count_local); - WID(WI_I32_CONST, 1); - WI(WI_I32_SUB); - WIL(WI_LOCAL_SET, count_local); + WIL(NULL, WI_LOCAL_GET, count_local); + WID(NULL, WI_I32_CONST, 1); + WI(NULL, WI_I32_SUB); + WIL(NULL, WI_LOCAL_SET, count_local); - WIL(WI_LOCAL_GET, dest_local); - WIL(WI_LOCAL_GET, count_local); - WI(WI_PTR_ADD); + WIL(NULL, WI_LOCAL_GET, dest_local); + WIL(NULL, WI_LOCAL_GET, count_local); + WI(NULL, WI_PTR_ADD); - WIL(WI_LOCAL_GET, source_local); - WIL(WI_LOCAL_GET, count_local); - WI(WI_PTR_ADD); + WIL(NULL, WI_LOCAL_GET, source_local); + WIL(NULL, WI_LOCAL_GET, count_local); + WI(NULL, WI_PTR_ADD); - WID(WI_I32_LOAD_8_U, ((WasmInstructionData) { 0, 0 })); - WID(WI_I32_STORE_8, ((WasmInstructionData) { 0, 0 })); + WID(NULL, WI_I32_LOAD_8_U, ((WasmInstructionData) { 0, 0 })); + WID(NULL, WI_I32_STORE_8, ((WasmInstructionData) { 0, 0 })); - WIL(WI_LOCAL_GET, count_local); - WID(WI_I32_CONST, 0); - WI(WI_I32_GT_S); - WID(WI_COND_JUMP, 0x00); + WIL(NULL, WI_LOCAL_GET, count_local); + WID(NULL, WI_I32_CONST, 0); + WI(NULL, WI_I32_GT_S); + WID(NULL, WI_COND_JUMP, 0x00); - WI(WI_LOOP_END); - WI(WI_IF_END); + WI(NULL, WI_LOOP_END); + WI(NULL, WI_IF_END); local_raw_free(mod->local_alloc, WASM_TYPE_INT32); local_raw_free(mod->local_alloc, WASM_TYPE_PTR); @@ -74,37 +74,37 @@ EMIT_FUNC_NO_ARGS(intrinsic_memory_fill) { u64 byte_local = local_raw_allocate(mod->local_alloc, WASM_TYPE_INT32); u64 dest_local = local_raw_allocate(mod->local_alloc, WASM_TYPE_PTR); - WIL(WI_LOCAL_SET, count_local); - WIL(WI_LOCAL_SET, byte_local); - WIL(WI_LOCAL_SET, dest_local); + WIL(NULL, WI_LOCAL_SET, count_local); + WIL(NULL, WI_LOCAL_SET, byte_local); + WIL(NULL, WI_LOCAL_SET, dest_local); // count is greater than 0 - WIL(WI_LOCAL_GET, count_local); - WID(WI_I32_CONST, 0); - WI(WI_I32_GT_S); + WIL(NULL, WI_LOCAL_GET, count_local); + WID(NULL, WI_I32_CONST, 0); + WI(NULL, WI_I32_GT_S); - WID(WI_IF_START, 0x40); - WID(WI_LOOP_START, 0x40); + WID(NULL, WI_IF_START, 0x40); + WID(NULL, WI_LOOP_START, 0x40); - WIL(WI_LOCAL_GET, count_local); - WID(WI_I32_CONST, 1); - WI(WI_I32_SUB); - WIL(WI_LOCAL_SET, count_local); + WIL(NULL, WI_LOCAL_GET, count_local); + WID(NULL, WI_I32_CONST, 1); + WI(NULL, WI_I32_SUB); + WIL(NULL, WI_LOCAL_SET, count_local); - WIL(WI_LOCAL_GET, dest_local); - WIL(WI_LOCAL_GET, count_local); - WI(WI_PTR_ADD); + WIL(NULL, WI_LOCAL_GET, dest_local); + WIL(NULL, WI_LOCAL_GET, count_local); + WI(NULL, WI_PTR_ADD); - WIL(WI_LOCAL_GET, byte_local); - WID(WI_I32_STORE_8, ((WasmInstructionData) { 0, 0 })); + WIL(NULL, WI_LOCAL_GET, byte_local); + WID(NULL, WI_I32_STORE_8, ((WasmInstructionData) { 0, 0 })); - WIL(WI_LOCAL_GET, count_local); - WID(WI_I32_CONST, 0); - WI(WI_I32_GT_S); - WID(WI_COND_JUMP, 0x00); + WIL(NULL, WI_LOCAL_GET, count_local); + WID(NULL, WI_I32_CONST, 0); + WI(NULL, WI_I32_GT_S); + WID(NULL, WI_COND_JUMP, 0x00); - WI(WI_LOOP_END); - WI(WI_IF_END); + WI(NULL, WI_LOOP_END); + WI(NULL, WI_IF_END); local_raw_free(mod->local_alloc, WASM_TYPE_INT32); local_raw_free(mod->local_alloc, WASM_TYPE_INT32); @@ -127,13 +127,13 @@ EMIT_FUNC(initialize_type, Type* type, OnyxToken* where) { case Type_Kind_Struct: { u64 value_ptr = local_raw_allocate(mod->local_alloc, WASM_TYPE_PTR); - WIL(WI_LOCAL_SET, value_ptr); + WIL(NULL, WI_LOCAL_SET, value_ptr); bh_arr_each(StructMember *, psmem, type->Struct.memarr) { StructMember* smem = *psmem; if (smem->initial_value == NULL || *smem->initial_value == NULL) continue; - WIL(WI_LOCAL_GET, value_ptr); + WIL(NULL, WI_LOCAL_GET, value_ptr); emit_expression(mod, &code, *smem->initial_value); emit_store_instruction(mod, &code, smem->type, smem->offset); } @@ -159,10 +159,10 @@ EMIT_FUNC(intrinsic_atomic_wait, Type* type, OnyxToken* where) { switch (type->Basic.kind) { case Basic_Kind_I32: - case Basic_Kind_U32: WID(WI_ATOMIC_WAIT32, ((WasmInstructionData) { 2, 0 })); break; + case Basic_Kind_U32: WID(NULL, WI_ATOMIC_WAIT32, ((WasmInstructionData) { 2, 0 })); break; case Basic_Kind_I64: - case Basic_Kind_U64: WID(WI_ATOMIC_WAIT64, ((WasmInstructionData) { 3, 0 })); break; + case Basic_Kind_U64: WID(NULL, WI_ATOMIC_WAIT64, ((WasmInstructionData) { 3, 0 })); break; default: goto bad_type; } @@ -176,13 +176,13 @@ bad_type: EMIT_FUNC_NO_ARGS(intrinsic_atomic_notify) { bh_arr(WasmInstruction) code = *pcode; - WID(WI_ATOMIC_NOTIFY, ((WasmInstructionData) { 2, 0 })); + WID(NULL, WI_ATOMIC_NOTIFY, ((WasmInstructionData) { 2, 0 })); *pcode = code; } EMIT_FUNC_NO_ARGS(intrinsic_atomic_fence) { bh_arr(WasmInstruction) code = *pcode; - WI(WI_ATOMIC_FENCE); + WI(NULL, WI_ATOMIC_FENCE); *pcode = code; } @@ -192,14 +192,14 @@ EMIT_FUNC(intrinsic_atomic_load, Type* type, OnyxToken* where) { bh_arr(WasmInstruction) code = *pcode; switch (type->Basic.kind) { - case Basic_Kind_U8: WID(WI_ATOMIC_I32_LOAD8_U, ((WasmInstructionData) { 0, 0 })); break; - case Basic_Kind_U16: WID(WI_ATOMIC_I32_LOAD16_U, ((WasmInstructionData) { 1, 0 })); break; + case Basic_Kind_U8: WID(NULL, WI_ATOMIC_I32_LOAD8_U, ((WasmInstructionData) { 0, 0 })); break; + case Basic_Kind_U16: WID(NULL, WI_ATOMIC_I32_LOAD16_U, ((WasmInstructionData) { 1, 0 })); break; case Basic_Kind_I32: - case Basic_Kind_U32: WID(WI_ATOMIC_I32_LOAD, ((WasmInstructionData) { 2, 0 })); break; + case Basic_Kind_U32: WID(NULL, WI_ATOMIC_I32_LOAD, ((WasmInstructionData) { 2, 0 })); break; case Basic_Kind_I64: - case Basic_Kind_U64: WID(WI_ATOMIC_I64_LOAD, ((WasmInstructionData) { 3, 0 })); break; + case Basic_Kind_U64: WID(NULL, WI_ATOMIC_I64_LOAD, ((WasmInstructionData) { 3, 0 })); break; default: goto bad_type; } @@ -217,14 +217,14 @@ EMIT_FUNC(intrinsic_atomic_store, Type* type, OnyxToken* where) { bh_arr(WasmInstruction) code = *pcode; switch (type->Basic.kind) { - case Basic_Kind_U8: WID(WI_ATOMIC_I32_STORE8, ((WasmInstructionData) { 0, 0 })); break; - case Basic_Kind_U16: WID(WI_ATOMIC_I32_STORE16, ((WasmInstructionData) { 1, 0 })); break; + case Basic_Kind_U8: WID(NULL, WI_ATOMIC_I32_STORE8, ((WasmInstructionData) { 0, 0 })); break; + case Basic_Kind_U16: WID(NULL, WI_ATOMIC_I32_STORE16, ((WasmInstructionData) { 1, 0 })); break; case Basic_Kind_I32: - case Basic_Kind_U32: WID(WI_ATOMIC_I32_STORE, ((WasmInstructionData) { 2, 0 })); break; + case Basic_Kind_U32: WID(NULL, WI_ATOMIC_I32_STORE, ((WasmInstructionData) { 2, 0 })); break; case Basic_Kind_I64: - case Basic_Kind_U64: WID(WI_ATOMIC_I64_STORE, ((WasmInstructionData) { 3, 0 })); break; + case Basic_Kind_U64: WID(NULL, WI_ATOMIC_I64_STORE, ((WasmInstructionData) { 3, 0 })); break; default: goto bad_type; } @@ -242,14 +242,14 @@ EMIT_FUNC(intrinsic_atomic_add, Type* type, OnyxToken* where) { bh_arr(WasmInstruction) code = *pcode; switch (type->Basic.kind) { - case Basic_Kind_U8: WID(WI_ATOMIC_I32_ADD8_U, ((WasmInstructionData) { 0, 0 })); break; - case Basic_Kind_U16: WID(WI_ATOMIC_I32_ADD16_U, ((WasmInstructionData) { 1, 0 })); break; + case Basic_Kind_U8: WID(NULL, WI_ATOMIC_I32_ADD8_U, ((WasmInstructionData) { 0, 0 })); break; + case Basic_Kind_U16: WID(NULL, WI_ATOMIC_I32_ADD16_U, ((WasmInstructionData) { 1, 0 })); break; case Basic_Kind_I32: - case Basic_Kind_U32: WID(WI_ATOMIC_I32_ADD, ((WasmInstructionData) { 2, 0 })); break; + case Basic_Kind_U32: WID(NULL, WI_ATOMIC_I32_ADD, ((WasmInstructionData) { 2, 0 })); break; case Basic_Kind_I64: - case Basic_Kind_U64: WID(WI_ATOMIC_I64_ADD, ((WasmInstructionData) { 3, 0 })); break; + case Basic_Kind_U64: WID(NULL, WI_ATOMIC_I64_ADD, ((WasmInstructionData) { 3, 0 })); break; default: goto bad_type; } @@ -267,14 +267,14 @@ EMIT_FUNC(intrinsic_atomic_sub, Type* type, OnyxToken* where) { bh_arr(WasmInstruction) code = *pcode; switch (type->Basic.kind) { - case Basic_Kind_U8: WID(WI_ATOMIC_I32_SUB8_U, ((WasmInstructionData) { 0, 0 })); break; - case Basic_Kind_U16: WID(WI_ATOMIC_I32_SUB16_U, ((WasmInstructionData) { 1, 0 })); break; + case Basic_Kind_U8: WID(NULL, WI_ATOMIC_I32_SUB8_U, ((WasmInstructionData) { 0, 0 })); break; + case Basic_Kind_U16: WID(NULL, WI_ATOMIC_I32_SUB16_U, ((WasmInstructionData) { 1, 0 })); break; case Basic_Kind_I32: - case Basic_Kind_U32: WID(WI_ATOMIC_I32_SUB, ((WasmInstructionData) { 2, 0 })); break; + case Basic_Kind_U32: WID(NULL, WI_ATOMIC_I32_SUB, ((WasmInstructionData) { 2, 0 })); break; case Basic_Kind_I64: - case Basic_Kind_U64: WID(WI_ATOMIC_I64_SUB, ((WasmInstructionData) { 3, 0 })); break; + case Basic_Kind_U64: WID(NULL, WI_ATOMIC_I64_SUB, ((WasmInstructionData) { 3, 0 })); break; default: goto bad_type; } @@ -292,14 +292,14 @@ EMIT_FUNC(intrinsic_atomic_and, Type* type, OnyxToken* where) { bh_arr(WasmInstruction) code = *pcode; switch (type->Basic.kind) { - case Basic_Kind_U8: WID(WI_ATOMIC_I32_AND8_U, ((WasmInstructionData) { 0, 0 })); break; - case Basic_Kind_U16: WID(WI_ATOMIC_I32_AND16_U, ((WasmInstructionData) { 1, 0 })); break; + case Basic_Kind_U8: WID(NULL, WI_ATOMIC_I32_AND8_U, ((WasmInstructionData) { 0, 0 })); break; + case Basic_Kind_U16: WID(NULL, WI_ATOMIC_I32_AND16_U, ((WasmInstructionData) { 1, 0 })); break; case Basic_Kind_I32: - case Basic_Kind_U32: WID(WI_ATOMIC_I32_AND, ((WasmInstructionData) { 2, 0 })); break; + case Basic_Kind_U32: WID(NULL, WI_ATOMIC_I32_AND, ((WasmInstructionData) { 2, 0 })); break; case Basic_Kind_I64: - case Basic_Kind_U64: WID(WI_ATOMIC_I64_AND, ((WasmInstructionData) { 3, 0 })); break; + case Basic_Kind_U64: WID(NULL, WI_ATOMIC_I64_AND, ((WasmInstructionData) { 3, 0 })); break; default: goto bad_type; } @@ -317,14 +317,14 @@ EMIT_FUNC(intrinsic_atomic_or, Type* type, OnyxToken* where) { bh_arr(WasmInstruction) code = *pcode; switch (type->Basic.kind) { - case Basic_Kind_U8: WID(WI_ATOMIC_I32_OR8_U, ((WasmInstructionData) { 0, 0 })); break; - case Basic_Kind_U16: WID(WI_ATOMIC_I32_OR16_U, ((WasmInstructionData) { 1, 0 })); break; + case Basic_Kind_U8: WID(NULL, WI_ATOMIC_I32_OR8_U, ((WasmInstructionData) { 0, 0 })); break; + case Basic_Kind_U16: WID(NULL, WI_ATOMIC_I32_OR16_U, ((WasmInstructionData) { 1, 0 })); break; case Basic_Kind_I32: - case Basic_Kind_U32: WID(WI_ATOMIC_I32_OR, ((WasmInstructionData) { 2, 0 })); break; + case Basic_Kind_U32: WID(NULL, WI_ATOMIC_I32_OR, ((WasmInstructionData) { 2, 0 })); break; case Basic_Kind_I64: - case Basic_Kind_U64: WID(WI_ATOMIC_I64_OR, ((WasmInstructionData) { 3, 0 })); break; + case Basic_Kind_U64: WID(NULL, WI_ATOMIC_I64_OR, ((WasmInstructionData) { 3, 0 })); break; default: goto bad_type; } @@ -342,14 +342,14 @@ EMIT_FUNC(intrinsic_atomic_xor, Type* type, OnyxToken* where) { bh_arr(WasmInstruction) code = *pcode; switch (type->Basic.kind) { - case Basic_Kind_U8: WID(WI_ATOMIC_I32_XOR8_U, ((WasmInstructionData) { 0, 0 })); break; - case Basic_Kind_U16: WID(WI_ATOMIC_I32_XOR16_U, ((WasmInstructionData) { 1, 0 })); break; + case Basic_Kind_U8: WID(NULL, WI_ATOMIC_I32_XOR8_U, ((WasmInstructionData) { 0, 0 })); break; + case Basic_Kind_U16: WID(NULL, WI_ATOMIC_I32_XOR16_U, ((WasmInstructionData) { 1, 0 })); break; case Basic_Kind_I32: - case Basic_Kind_U32: WID(WI_ATOMIC_I32_XOR, ((WasmInstructionData) { 2, 0 })); break; + case Basic_Kind_U32: WID(NULL, WI_ATOMIC_I32_XOR, ((WasmInstructionData) { 2, 0 })); break; case Basic_Kind_I64: - case Basic_Kind_U64: WID(WI_ATOMIC_I64_XOR, ((WasmInstructionData) { 3, 0 })); break; + case Basic_Kind_U64: WID(NULL, WI_ATOMIC_I64_XOR, ((WasmInstructionData) { 3, 0 })); break; default: goto bad_type; } @@ -367,14 +367,14 @@ EMIT_FUNC(intrinsic_atomic_xchg, Type* type, OnyxToken* where) { bh_arr(WasmInstruction) code = *pcode; switch (type->Basic.kind) { - case Basic_Kind_U8: WID(WI_ATOMIC_I32_XCHG8_U, ((WasmInstructionData) { 0, 0 })); break; - case Basic_Kind_U16: WID(WI_ATOMIC_I32_XCHG16_U, ((WasmInstructionData) { 1, 0 })); break; + case Basic_Kind_U8: WID(NULL, WI_ATOMIC_I32_XCHG8_U, ((WasmInstructionData) { 0, 0 })); break; + case Basic_Kind_U16: WID(NULL, WI_ATOMIC_I32_XCHG16_U, ((WasmInstructionData) { 1, 0 })); break; case Basic_Kind_I32: - case Basic_Kind_U32: WID(WI_ATOMIC_I32_XCHG, ((WasmInstructionData) { 2, 0 })); break; + case Basic_Kind_U32: WID(NULL, WI_ATOMIC_I32_XCHG, ((WasmInstructionData) { 2, 0 })); break; case Basic_Kind_I64: - case Basic_Kind_U64: WID(WI_ATOMIC_I64_XCHG, ((WasmInstructionData) { 3, 0 })); break; + case Basic_Kind_U64: WID(NULL, WI_ATOMIC_I64_XCHG, ((WasmInstructionData) { 3, 0 })); break; default: goto bad_type; } @@ -392,14 +392,14 @@ EMIT_FUNC(intrinsic_atomic_cmpxchg, Type* type, OnyxToken* where) { bh_arr(WasmInstruction) code = *pcode; switch (type->Basic.kind) { - case Basic_Kind_U8: WID(WI_ATOMIC_I32_CMPXCHG8_U, ((WasmInstructionData) { 0, 0 })); break; - case Basic_Kind_U16: WID(WI_ATOMIC_I32_CMPXCHG16_U, ((WasmInstructionData) { 1, 0 })); break; + case Basic_Kind_U8: WID(NULL, WI_ATOMIC_I32_CMPXCHG8_U, ((WasmInstructionData) { 0, 0 })); break; + case Basic_Kind_U16: WID(NULL, WI_ATOMIC_I32_CMPXCHG16_U, ((WasmInstructionData) { 1, 0 })); break; case Basic_Kind_I32: - case Basic_Kind_U32: WID(WI_ATOMIC_I32_CMPXCHG, ((WasmInstructionData) { 2, 0 })); break; + case Basic_Kind_U32: WID(NULL, WI_ATOMIC_I32_CMPXCHG, ((WasmInstructionData) { 2, 0 })); break; case Basic_Kind_I64: - case Basic_Kind_U64: WID(WI_ATOMIC_I64_CMPXCHG, ((WasmInstructionData) { 3, 0 })); break; + case Basic_Kind_U64: WID(NULL, WI_ATOMIC_I64_CMPXCHG, ((WasmInstructionData) { 3, 0 })); break; default: goto bad_type; } @@ -429,9 +429,9 @@ EMIT_FUNC_NO_ARGS(initialize_data_segments_body) { if (datum->data == NULL) { index++; continue; } emit_data_relocation(mod, &code, datum->id); - WID(WI_PTR_CONST, 0); - WID(WI_I32_CONST, datum->length); - WID(WI_MEMORY_INIT, ((WasmInstructionData) { index, 0 })); + WID(NULL, WI_PTR_CONST, 0); + WID(NULL, WI_I32_CONST, datum->length); + WID(NULL, WI_MEMORY_INIT, ((WasmInstructionData) { index, 0 })); index += 1; } -- 2.25.1