From bf9e289ccd8e70cb59b3f35d71c92e799ecafa63 Mon Sep 17 00:00:00 2001 From: Motiejus Date: Sat, 21 Feb 2026 20:41:37 +0000 Subject: [PATCH] sema: align C function names with Sema.zig for CPU profile cross-referencing MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Rename static functions to use sema prefix + Zig method name pattern, so perf profiles show corresponding names (e.g. semaAddExtra ↔ Sema.addExtra). Co-Authored-By: Claude Opus 4.6 --- stage0/sema.c | 222 +++++++++++++++++++++++++------------------------- 1 file changed, 111 insertions(+), 111 deletions(-) diff --git a/stage0/sema.c b/stage0/sema.c index 1ceb468bac..5cddca6d8c 100644 --- a/stage0/sema.c +++ b/stage0/sema.c @@ -188,11 +188,11 @@ static AirInstRef resolveInst(Sema* sema, ZirInstRef zir_ref) { return AIR_REF_FROM_IP(zir_ref); } -// --- addAirInst --- +// --- semaAddInstAsIndex --- // Appends an AIR instruction to sema's output arrays. // Returns the instruction index (not the ref). -static uint32_t addAirInst(Sema* sema, AirInstTag inst_tag, AirInstData data) { +static uint32_t semaAddInstAsIndex(Sema* sema, AirInstTag inst_tag, AirInstData data) { if (sema->air_inst_len >= sema->air_inst_cap) { uint32_t new_cap = sema->air_inst_cap * 2; uint8_t* new_tags @@ -235,10 +235,10 @@ static void semaBlockDeinit(SemaBlock* block) { } // Add an AIR instruction to the block's instruction list. -static AirInstRef blockAddInst( +static AirInstRef semaAddInst( SemaBlock* block, AirInstTag inst_tag, AirInstData data) { Sema* sema = block->sema; - uint32_t idx = addAirInst(sema, inst_tag, data); + uint32_t idx = semaAddInstAsIndex(sema, inst_tag, data); // Append to block's instruction list. if (block->instructions_len >= block->instructions_cap) { @@ -257,7 +257,7 @@ static AirInstRef blockAddInst( // --- Air extra helpers --- // Append a u32 to the AIR extra array, growing if needed. -static uint32_t addAirExtra(Sema* sema, uint32_t value) { +static uint32_t semaAddExtra(Sema* sema, uint32_t value) { if (sema->air_extra_len >= sema->air_extra_cap) { uint32_t new_cap = sema->air_extra_cap * 2; uint32_t* new_extra @@ -304,11 +304,11 @@ static void zirDbgStmt(Sema* sema, SemaBlock* block, uint32_t inst) { memset(&data, 0, sizeof(data)); data.dbg_stmt.line = line; data.dbg_stmt.column = column; - (void)blockAddInst(block, AIR_INST_DBG_STMT, data); + (void)semaAddInst(block, AIR_INST_DBG_STMT, data); } // semaAppendAirString: store a NullTerminatedString in the AIR extra array. -// Ported from src/Sema.zig appendAirString. +// Ported from src/Sema.zig semaAppendAirString. // The string (including NUL) is packed into u32 words in the extra array. // Returns the extra array index where the string starts. static uint32_t semaAppendAirString(Sema* sema, const char* str) { @@ -370,7 +370,7 @@ static void zirDbgVar( memset(&data, 0, sizeof(data)); data.pl_op.operand = operand; data.pl_op.payload = name_nts; - (void)blockAddInst(block, air_tag, data); + (void)semaAddInst(block, air_tag, data); } // --- Declaration.Flags.Id helpers --- @@ -491,11 +491,11 @@ static void getParamBody(Sema* sema, uint32_t param_block_inst, *body_len_out = 0; } -// coerceIntRef: coerce an integer AIR ref to a target type. +// semaCoerceIntRef: coerce an integer AIR ref to a target type. // If the ref points to a comptime_int IP entry and the target type // is a concrete integer type, creates a new IP entry with that type. // Ported from InternPool.getCoercedInts (src/InternPool.zig:10947). -static AirInstRef coerceIntRef( +static AirInstRef semaCoerceIntRef( Sema* sema, AirInstRef air_ref, TypeIndex target_ty) { // Extract IP index from the AIR ref. uint32_t ip_idx = air_ref; // AIR_REF_FROM_IP is identity @@ -517,7 +517,7 @@ static AirInstRef coerceIntRef( } // semaTypeOf: resolve the type of an AIR ref. -// Ported from src/Air.zig typeOf / typeOfIndex. +// Ported from src/Air.zig semaTypeOf / semaTypeOfIndex. static TypeIndex semaTypeOf(Sema* sema, AirInstRef ref) { if (AIR_REF_IS_IP(ref)) { return ipTypeOf(sema->ip, AIR_REF_TO_IP(ref)); @@ -586,9 +586,9 @@ static TypeIndex semaTypeOf(Sema* sema, AirInstRef ref) { } } -// resolvePeerType: determine the common type of two AIR refs. -// Ported from src/Sema.zig resolvePeerTypes (simplified). -static TypeIndex resolvePeerType(Sema* sema, AirInstRef lhs, AirInstRef rhs) { +// semaResolvePeerTypes: determine the common type of two AIR refs. +// Ported from src/Sema.zig semaResolvePeerTypess (simplified). +static TypeIndex semaResolvePeerTypes(Sema* sema, AirInstRef lhs, AirInstRef rhs) { TypeIndex lhs_ty = semaTypeOf(sema, lhs); TypeIndex rhs_ty = semaTypeOf(sema, rhs); if (lhs_ty == rhs_ty) @@ -600,7 +600,7 @@ static TypeIndex resolvePeerType(Sema* sema, AirInstRef lhs, AirInstRef rhs) { // When both types are concrete int types and one operand is // comptime-known, use the other (runtime) type. The comptime value // can be coerced to the runtime type during semaCoerce. - // Ported from src/Sema.zig resolvePeerTypes peer_resolve_int_int. + // Ported from src/Sema.zig semaResolvePeerTypess peer_resolve_int_int. if (sema->ip->items[lhs_ty].tag == IP_KEY_INT_TYPE && sema->ip->items[rhs_ty].tag == IP_KEY_INT_TYPE) { if (AIR_REF_IS_IP(lhs)) @@ -613,7 +613,7 @@ static TypeIndex resolvePeerType(Sema* sema, AirInstRef lhs, AirInstRef rhs) { return lhs_ty; } -// coerce: coerce an AIR ref to a target type. +// semaCoerce: coerce an AIR ref to a target type. // Ported from src/Sema.zig coerce (simplified). static AirInstRef semaCoerce( Sema* sema, SemaBlock* block, TypeIndex target_ty, AirInstRef ref) { @@ -621,11 +621,11 @@ static AirInstRef semaCoerce( if (src_ty == target_ty) return ref; if (src_ty == IP_INDEX_COMPTIME_INT_TYPE) - return coerceIntRef(sema, ref, target_ty); + return semaCoerceIntRef(sema, ref, target_ty); // Comptime int→int coercion: re-intern with target type. if (AIR_REF_IS_IP(ref) && sema->ip->items[src_ty].tag == IP_KEY_INT_TYPE && sema->ip->items[target_ty].tag == IP_KEY_INT_TYPE) { - return coerceIntRef(sema, ref, target_ty); + return semaCoerceIntRef(sema, ref, target_ty); } // Runtime int→int coercion: emit intcast. if (AIR_REF_IS_INST(ref) && sema->ip->items[src_ty].tag == IP_KEY_INT_TYPE @@ -634,7 +634,7 @@ static AirInstRef semaCoerce( memset(&data, 0, sizeof(data)); data.ty_op.ty_ref = AIR_REF_FROM_IP(target_ty); data.ty_op.operand = ref; - return blockAddInst(block, AIR_INST_INTCAST, data); + return semaAddInst(block, AIR_INST_INTCAST, data); } // For unsupported type combinations (e.g. type→void during comptime // analysis of generic functions), return the operand unchanged. @@ -664,7 +664,7 @@ static void zirStoreNode(Sema* sema, SemaBlock* block, uint32_t inst) { memset(&data, 0, sizeof(data)); data.bin_op.lhs = ptr; data.bin_op.rhs = val; - (void)blockAddInst(block, AIR_INST_STORE, data); + (void)semaAddInst(block, AIR_INST_STORE, data); } // zirLoad: handle load ZIR instruction (pointer dereference). @@ -678,7 +678,7 @@ static AirInstRef zirLoad(Sema* sema, SemaBlock* block, uint32_t inst) { memset(&data, 0, sizeof(data)); data.ty_op.ty_ref = AIR_REF_FROM_IP(elem_ty); data.ty_op.operand = ptr; - return blockAddInst(block, AIR_INST_LOAD, data); + return semaAddInst(block, AIR_INST_LOAD, data); } // zirNegate: handle negate ZIR instruction (unary -). @@ -700,7 +700,7 @@ static AirInstRef zirNegate(Sema* sema, SemaBlock* block, uint32_t inst) { memset(&data, 0, sizeof(data)); data.bin_op.lhs = zero; data.bin_op.rhs = operand; - return blockAddInst(block, AIR_INST_SUB, data); + return semaAddInst(block, AIR_INST_SUB, data); } // zirNegateWrap: handle negate_wrap ZIR instruction (wrapping unary -). @@ -721,7 +721,7 @@ static AirInstRef zirNegateWrap(Sema* sema, SemaBlock* block, uint32_t inst) { memset(&data, 0, sizeof(data)); data.bin_op.lhs = zero; data.bin_op.rhs = operand; - return blockAddInst(block, AIR_INST_SUB_WRAP, data); + return semaAddInst(block, AIR_INST_SUB_WRAP, data); } // zirBitNot: handle bit_not ZIR instruction (bitwise ~). @@ -734,7 +734,7 @@ static AirInstRef zirBitNot(Sema* sema, SemaBlock* block, uint32_t inst) { memset(&data, 0, sizeof(data)); data.ty_op.ty_ref = AIR_REF_FROM_IP(ty); data.ty_op.operand = operand; - return blockAddInst(block, AIR_INST_NOT, data); + return semaAddInst(block, AIR_INST_NOT, data); } // zirBoolNot: handle bool_not ZIR instruction. @@ -747,7 +747,7 @@ static AirInstRef zirBoolNot(Sema* sema, SemaBlock* block, uint32_t inst) { memset(&data, 0, sizeof(data)); data.ty_op.ty_ref = AIR_REF_FROM_IP(IP_INDEX_BOOL_TYPE); data.ty_op.operand = operand; - return blockAddInst(block, AIR_INST_NOT, data); + return semaAddInst(block, AIR_INST_NOT, data); } // zirIntFromBool: handle int_from_bool ZIR instruction (@intFromBool). @@ -760,7 +760,7 @@ static AirInstRef zirIntFromBool(Sema* sema, SemaBlock* block, uint32_t inst) { memset(&data, 0, sizeof(data)); data.ty_op.ty_ref = AIR_REF_FROM_IP(IP_INDEX_U1_TYPE); data.ty_op.operand = operand; - return blockAddInst(block, AIR_INST_BITCAST, data); + return semaAddInst(block, AIR_INST_BITCAST, data); } // isComptimeInt: check if an AIR ref is a comptime integer value. @@ -872,7 +872,7 @@ static AirInstRef zirBitCount( memset(&data, 0, sizeof(data)); data.ty_op.ty_ref = AIR_REF_FROM_IP(result_ty); data.ty_op.operand = operand; - return blockAddInst(block, air_tag, data); + return semaAddInst(block, air_tag, data); } // zirByteSwap: handle byte_swap ZIR instruction (@byteSwap). @@ -885,7 +885,7 @@ static AirInstRef zirByteSwap(Sema* sema, SemaBlock* block, uint32_t inst) { memset(&data, 0, sizeof(data)); data.ty_op.ty_ref = AIR_REF_FROM_IP(operand_ty); data.ty_op.operand = operand; - return blockAddInst(block, AIR_INST_BYTE_SWAP, data); + return semaAddInst(block, AIR_INST_BYTE_SWAP, data); } // zirArithmetic: handle add/sub ZIR instructions. @@ -947,14 +947,14 @@ static AirInstRef zirArithmetic( } emit_runtime:; - TypeIndex peer_ty = resolvePeerType(sema, lhs, rhs); + TypeIndex peer_ty = semaResolvePeerTypes(sema, lhs, rhs); lhs = semaCoerce(sema, block, peer_ty, lhs); rhs = semaCoerce(sema, block, peer_ty, rhs); AirInstData data; memset(&data, 0, sizeof(data)); data.bin_op.lhs = lhs; data.bin_op.rhs = rhs; - return blockAddInst(block, air_tag, data); + return semaAddInst(block, air_tag, data); } // zirBitwise: handle bitwise operation ZIR instructions. @@ -995,14 +995,14 @@ static AirInstRef zirBitwise( } emit_bitwise_runtime:; - TypeIndex peer_ty = resolvePeerType(sema, lhs, rhs); + TypeIndex peer_ty = semaResolvePeerTypes(sema, lhs, rhs); lhs = semaCoerce(sema, block, peer_ty, lhs); rhs = semaCoerce(sema, block, peer_ty, rhs); AirInstData data; memset(&data, 0, sizeof(data)); data.bin_op.lhs = lhs; data.bin_op.rhs = rhs; - return blockAddInst(block, air_tag, data); + return semaAddInst(block, air_tag, data); } // zirBitcast: handle @bitCast ZIR instruction. @@ -1032,7 +1032,7 @@ static AirInstRef zirBitcast(Sema* sema, SemaBlock* block, uint32_t inst) { memset(&data, 0, sizeof(data)); data.ty_op.ty_ref = AIR_REF_FROM_IP(dest_ty); data.ty_op.operand = operand; - return blockAddInst(block, AIR_INST_BITCAST, data); + return semaAddInst(block, AIR_INST_BITCAST, data); } // zirTyOpCast: generic handler for type-changing cast ZIR instructions @@ -1054,7 +1054,7 @@ static AirInstRef zirTyOpCast( memset(&data, 0, sizeof(data)); data.ty_op.ty_ref = AIR_REF_FROM_IP(dest_ty); data.ty_op.operand = operand; - return blockAddInst(block, air_tag, data); + return semaAddInst(block, air_tag, data); } // floatBits: get the bit width of a float type from its IP index. @@ -1101,7 +1101,7 @@ static AirInstRef zirFloatCast(Sema* sema, SemaBlock* block, uint32_t inst) { memset(&data, 0, sizeof(data)); data.ty_op.ty_ref = AIR_REF_FROM_IP(dest_ty); data.ty_op.operand = operand; - return blockAddInst(block, air_tag, data); + return semaAddInst(block, air_tag, data); } // zirTypeofLog2IntType: compute the log2 integer type for shift amounts. @@ -1190,7 +1190,7 @@ static AirInstRef zirShl( memset(&data, 0, sizeof(data)); data.bin_op.lhs = lhs; data.bin_op.rhs = rhs; - return blockAddInst(block, air_tag, data); + return semaAddInst(block, air_tag, data); } // zirAsNode: handle @as ZIR instruction. @@ -2403,7 +2403,7 @@ static AirInstRef zirCall( // need_debug_scope is always false → BLOCK tag. AirInstData rt_dead; memset(&rt_dead, 0, sizeof(rt_dead)); - addAirInst(sema, AIR_INST_BLOCK, rt_dead); + semaAddInstAsIndex(sema, AIR_INST_BLOCK, rt_dead); uint8_t signedness = 0; // 0 = unsigned, 1 = signed uint16_t bits_val = 0; @@ -2521,7 +2521,7 @@ static AirInstRef zirCall( AirInstData dummy; memset(&dummy, 0, sizeof(dummy)); dummy.ty.ty_ref = AIR_REF_FROM_IP(arg_ty); - addAirInst(sema, AIR_INST_ALLOC, dummy); + semaAddInstAsIndex(sema, AIR_INST_ALLOC, dummy); } } } @@ -2557,16 +2557,16 @@ static AirInstRef zirCall( InternPoolIndex func_val_ip = ipIntern(sema->ip, fv_key); // Emit CALL extra: {args_len, arg_refs[0..args_len]}. - uint32_t call_extra = addAirExtra(sema, runtime_args_count); + uint32_t call_extra = semaAddExtra(sema, runtime_args_count); for (uint32_t a = 0; a < runtime_args_count; a++) - addAirExtra(sema, runtime_arg_refs[a]); + semaAddExtra(sema, runtime_arg_refs[a]); // Emit CALL instruction. AirInstData call_data; memset(&call_data, 0, sizeof(call_data)); call_data.pl_op.operand = AIR_REF_FROM_IP(func_val_ip); call_data.pl_op.payload = call_extra; - AirInstRef call_ref = blockAddInst(block, AIR_INST_CALL, call_data); + AirInstRef call_ref = semaAddInst(block, AIR_INST_CALL, call_data); // Register CALL return type for semaTypeOf. if (sema->num_calls < 16) { @@ -2628,7 +2628,7 @@ static AirInstRef zirCall( = need_debug_scope ? AIR_INST_DBG_INLINE_BLOCK : AIR_INST_BLOCK; // Reserve the block instruction (data filled later). - uint32_t block_inst_idx = addAirInst(sema, block_tag, + uint32_t block_inst_idx = semaAddInstAsIndex(sema, block_tag, (AirInstData) { .ty_pl = { .ty_ref = 0, .payload = 0 } }); // Set up child block for inlining. @@ -2699,7 +2699,7 @@ static AirInstRef zirCall( memset(&data, 0, sizeof(data)); data.pl_op.operand = arg_refs[param_idx]; data.pl_op.payload = name_nts; - (void)blockAddInst( + (void)semaAddInst( &child_block, AIR_INST_DBG_ARG_INLINE, data); } param_idx++; @@ -2809,10 +2809,10 @@ static AirInstRef zirCall( child_block.instructions[child_block.instructions_len - 1]); } else { // dbg_inline_block: create block with noreturn type. - uint32_t es = addAirExtra(sema, inlining.func); - addAirExtra(sema, child_block.instructions_len); + uint32_t es = semaAddExtra(sema, inlining.func); + semaAddExtra(sema, child_block.instructions_len); for (uint32_t i = 0; i < child_block.instructions_len; i++) - addAirExtra(sema, child_block.instructions[i]); + semaAddExtra(sema, child_block.instructions[i]); sema->air_inst_datas[block_inst_idx].ty_pl.ty_ref = AIR_REF_FROM_IP(IP_INDEX_NORETURN_TYPE); sema->air_inst_datas[block_inst_idx].ty_pl.payload = es; @@ -2855,13 +2855,13 @@ static AirInstRef zirCall( // Ported from resolveAnalyzedBlock lines 6031-6062. uint32_t es; if (need_debug_scope) { - es = addAirExtra(sema, inlining.func); - addAirExtra(sema, child_block.instructions_len); + es = semaAddExtra(sema, inlining.func); + semaAddExtra(sema, child_block.instructions_len); } else { - es = addAirExtra(sema, child_block.instructions_len); + es = semaAddExtra(sema, child_block.instructions_len); } for (uint32_t i = 0; i < child_block.instructions_len; i++) - addAirExtra(sema, child_block.instructions[i]); + semaAddExtra(sema, child_block.instructions[i]); sema->air_inst_datas[block_inst_idx].ty_pl.ty_ref = AIR_REF_FROM_IP(IP_INDEX_VOID_TYPE); sema->air_inst_datas[block_inst_idx].ty_pl.payload = es; @@ -2884,13 +2884,13 @@ static AirInstRef zirCall( TypeIndex rty = semaTypeOf(sema, result_ref); uint32_t es; if (need_debug_scope) { - es = addAirExtra(sema, inlining.func); - addAirExtra(sema, child_block.instructions_len); + es = semaAddExtra(sema, inlining.func); + semaAddExtra(sema, child_block.instructions_len); } else { - es = addAirExtra(sema, child_block.instructions_len); + es = semaAddExtra(sema, child_block.instructions_len); } for (uint32_t i = 0; i < child_block.instructions_len; i++) - addAirExtra(sema, child_block.instructions[i]); + semaAddExtra(sema, child_block.instructions[i]); sema->air_inst_datas[block_inst_idx].ty_pl.ty_ref = AIR_REF_FROM_IP(rty); sema->air_inst_datas[block_inst_idx].ty_pl.payload = es; @@ -2910,13 +2910,13 @@ static AirInstRef zirCall( TypeIndex rty = semaTypeOf(sema, result_ref); uint32_t es; if (need_debug_scope) { - es = addAirExtra(sema, inlining.func); - addAirExtra(sema, child_block.instructions_len); + es = semaAddExtra(sema, inlining.func); + semaAddExtra(sema, child_block.instructions_len); } else { - es = addAirExtra(sema, child_block.instructions_len); + es = semaAddExtra(sema, child_block.instructions_len); } for (uint32_t i = 0; i < child_block.instructions_len; i++) - addAirExtra(sema, child_block.instructions[i]); + semaAddExtra(sema, child_block.instructions[i]); sema->air_inst_datas[block_inst_idx].ty_pl.ty_ref = AIR_REF_FROM_IP(rty); sema->air_inst_datas[block_inst_idx].ty_pl.payload = es; @@ -3057,7 +3057,7 @@ static void zirFunc(Sema* sema, SemaBlock* block, uint32_t inst) { sema->num_calls = 0; // Reserve extra[0] for main_block index (Air.ExtraIndex.main_block). - addAirExtra(sema, 0); + semaAddExtra(sema, 0); // Resolve the function return type. // Ported from src/Sema.zig zirFunc (lines 8869-8885). @@ -3196,7 +3196,7 @@ static void zirFunc(Sema* sema, SemaBlock* block, uint32_t inst) { memset(&arg_data, 0, sizeof(arg_data)); arg_data.arg.ty_ref = AIR_REF_FROM_IP(param_ty); arg_data.arg.zir_param_index = runtime_param_index; - AirInstRef arg_ref = blockAddInst(&fn_block, AIR_INST_ARG, arg_data); + AirInstRef arg_ref = semaAddInst(&fn_block, AIR_INST_ARG, arg_data); // Map param ZIR inst → arg AIR ref. instMapPut(&sema->inst_map, param_inst, arg_ref); @@ -3209,9 +3209,9 @@ static void zirFunc(Sema* sema, SemaBlock* block, uint32_t inst) { // --- Write main block to extra --- // Layout: AirBlock{body_len}, then body_len instruction indices. - uint32_t main_block_extra = addAirExtra(sema, fn_block.instructions_len); + uint32_t main_block_extra = semaAddExtra(sema, fn_block.instructions_len); for (uint32_t i = 0; i < fn_block.instructions_len; i++) { - addAirExtra(sema, fn_block.instructions[i]); + semaAddExtra(sema, fn_block.instructions[i]); } // Patch extra[0] = main_block index. sema->air_extra[0] = main_block_extra; @@ -3431,12 +3431,12 @@ static AirInstRef zirTypeof(Sema* sema, uint32_t inst) { return AIR_REF_FROM_IP(ty); } -// zirSwitchBlockComptime: handle switch_block on a comptime-known value. -// Ported from src/Sema.zig resolveSwitchComptime (simplified). +// semaResolveSwitchComptime: handle switch_block on a comptime-known value. +// Ported from src/Sema.zig semaResolveSwitchComptime (simplified). // Parses the SwitchBlock extra data, finds the matching scalar case or // falls back to the else prong, then analyzes the matching body. // Returns the result value from the matched break instruction. -static AirInstRef zirSwitchBlockComptime( +static AirInstRef semaResolveSwitchComptime( Sema* sema, SemaBlock* block, uint32_t inst) { uint32_t payload_index = sema->code.inst_datas[inst].pl_node.payload_index; ZirInstRef operand_ref = sema->code.extra[payload_index]; @@ -3540,7 +3540,7 @@ static AirInstRef zirSwitchBlockComptime( // debug undefined pattern. AirInstData block_data; memset(&block_data, 0xaa, sizeof(block_data)); - uint32_t block_inst = addAirInst(sema, AIR_INST_BLOCK, block_data); + uint32_t block_inst = semaAddInstAsIndex(sema, AIR_INST_BLOCK, block_data); // Set up a label so break can find this block. SemaBlockLabel label; @@ -3594,7 +3594,7 @@ static AirInstRef zirSwitchBlockComptime( // Reserve BLOCK instruction (same as scalar case above). AirInstData block_data; memset(&block_data, 0xaa, sizeof(block_data)); - uint32_t block_inst = addAirInst(sema, AIR_INST_BLOCK, block_data); + uint32_t block_inst = semaAddInstAsIndex(sema, AIR_INST_BLOCK, block_data); SemaBlockLabel label; memset(&label, 0, sizeof(label)); @@ -4022,7 +4022,7 @@ static bool analyzeBodyInner( AirInstData ret_data; memset(&ret_data, 0, sizeof(ret_data)); ret_data.un_op.operand = AIR_REF_FROM_IP(IP_INDEX_VOID_VALUE); - (void)blockAddInst(block, AIR_INST_RET, ret_data); + (void)semaAddInst(block, AIR_INST_RET, ret_data); } return false; @@ -4050,7 +4050,7 @@ static bool analyzeBodyInner( memset(&br_data, 0, sizeof(br_data)); br_data.br.block_inst = inl->merges.block_inst; br_data.br.operand = operand; - AirInstRef br_ref = blockAddInst(block, AIR_INST_BR, br_data); + AirInstRef br_ref = semaAddInst(block, AIR_INST_BR, br_data); // Record merge result and br instruction. if (inl->merges.results_len >= inl->merges.results_cap) { uint32_t new_cap = (inl->merges.results_cap == 0) @@ -4075,7 +4075,7 @@ static bool analyzeBodyInner( memset(&ret_data, 0, sizeof(ret_data)); ret_data.un_op.operand = operand; // ReleaseFast: use ret, not ret_safe (no safety checks). - (void)blockAddInst(block, AIR_INST_RET, ret_data); + (void)semaAddInst(block, AIR_INST_RET, ret_data); return false; } @@ -4223,7 +4223,7 @@ static bool analyzeBodyInner( = block->instructions_len - block_index; // Reserve an AIR block instruction. - uint32_t blk_inst = addAirInst(sema, AIR_INST_BLOCK, + uint32_t blk_inst = semaAddInstAsIndex(sema, AIR_INST_BLOCK, (AirInstData) { .ty_pl = { .ty_ref = 0, .payload = 0 } }); // Add a BR to exit the block with void_value. @@ -4231,16 +4231,16 @@ static bool analyzeBodyInner( memset(&br_data, 0, sizeof(br_data)); br_data.br.block_inst = blk_inst; br_data.br.operand = AIR_REF_FROM_IP(IP_INDEX_VOID_VALUE); - uint32_t br_inst = addAirInst(sema, AIR_INST_BR, br_data); + uint32_t br_inst = semaAddInstAsIndex(sema, AIR_INST_BR, br_data); // Write block extra: body_len2, then body insts. uint32_t body_len2 = new_insts_count + 1; // +1 for BR - uint32_t extra_start = addAirExtra(sema, body_len2); + uint32_t extra_start = semaAddExtra(sema, body_len2); for (uint32_t ci = block_index; ci < block->instructions_len; ci++) { - addAirExtra(sema, block->instructions[ci]); + semaAddExtra(sema, block->instructions[ci]); } - addAirExtra(sema, br_inst); + semaAddExtra(sema, br_inst); // Patch the BLOCK instruction data. sema->air_inst_datas[blk_inst].ty_pl.ty_ref @@ -4567,7 +4567,7 @@ static bool analyzeBodyInner( AirInstData d; memset(&d, 0, sizeof(d)); d.ty.ty_ref = AIR_REF_FROM_IP(ptr_ty); - AirInstRef ref = blockAddInst(block, AIR_INST_ALLOC, d); + AirInstRef ref = semaAddInst(block, AIR_INST_ALLOC, d); instMapPut(&sema->inst_map, inst, ref); i++; continue; @@ -4711,7 +4711,7 @@ static bool analyzeBodyInner( // switch_block: comptime switch on a known value. case ZIR_INST_SWITCH_BLOCK: instMapPut(&sema->inst_map, inst, - zirSwitchBlockComptime(sema, block, inst)); + semaResolveSwitchComptime(sema, block, inst)); i++; continue; @@ -4776,7 +4776,7 @@ static bool analyzeBodyInner( memset(&data, 0, sizeof(data)); data.ty.ty_ref = AIR_REF_FROM_IP(ptr_ty); instMapPut(&sema->inst_map, inst, - blockAddInst(block, AIR_INST_ALLOC, data)); + semaAddInst(block, AIR_INST_ALLOC, data)); i++; continue; } @@ -4792,7 +4792,7 @@ static bool analyzeBodyInner( memset(&data, 0, sizeof(data)); // data: alignment=none (0), is_const=false (0) AirInstRef air_ref - = blockAddInst(block, AIR_INST_INFERRED_ALLOC, data); + = semaAddInst(block, AIR_INST_INFERRED_ALLOC, data); instMapPut(&sema->inst_map, inst, air_ref); // Track for resolve_inferred_alloc. assert(sema->num_ia < 16); @@ -4819,7 +4819,7 @@ static bool analyzeBodyInner( memset(&data, 0, sizeof(data)); data.bin_op.lhs = ptr; data.bin_op.rhs = val; - AirInstRef store_ref = blockAddInst(block, AIR_INST_STORE, data); + AirInstRef store_ref = semaAddInst(block, AIR_INST_STORE, data); // Track the store for the inferred alloc. uint32_t ptr_inst = AIR_REF_TO_INST(ptr); for (uint32_t k = 0; k < sema->num_ia; k++) { @@ -4891,7 +4891,7 @@ static bool analyzeBodyInner( store_data.bin_op.lhs = store_lhs; store_data.bin_op.rhs = coerced; uint32_t new_store_idx - = addAirInst(sema, AIR_INST_STORE, store_data); + = semaAddInstAsIndex(sema, AIR_INST_STORE, store_data); // Patch the placeholder store with the replacement. sema->air_inst_tags[store_inst] = sema->air_inst_tags[new_store_idx]; @@ -4976,7 +4976,7 @@ static bool analyzeBodyInner( // Runtime block: reserve an AIR block instruction // (data filled later). - uint32_t block_inst_idx = addAirInst(sema, AIR_INST_BLOCK, + uint32_t block_inst_idx = semaAddInstAsIndex(sema, AIR_INST_BLOCK, (AirInstData) { .ty_pl = { .ty_ref = 0, .payload = 0 } }); // Set up label so break instructions can find this block. @@ -5077,10 +5077,10 @@ static bool analyzeBodyInner( = block_inst_idx; uint32_t extra_start - = addAirExtra(sema, child_block.instructions_len); + = semaAddExtra(sema, child_block.instructions_len); for (uint32_t ci = 0; ci < child_block.instructions_len; ci++) { - addAirExtra(sema, child_block.instructions[ci]); + semaAddExtra(sema, child_block.instructions[ci]); } sema->air_inst_datas[block_inst_idx].ty_pl.ty_ref = AIR_REF_FROM_IP(IP_INDEX_VOID_TYPE); @@ -5107,14 +5107,14 @@ static bool analyzeBodyInner( block->instructions[block->instructions_len++] = block_inst_idx; - TypeIndex resolved_ty = resolvePeerType( + TypeIndex resolved_ty = semaResolvePeerTypes( sema, label.merges.results[0], label.merges.results[1]); uint32_t extra_start - = addAirExtra(sema, child_block.instructions_len); + = semaAddExtra(sema, child_block.instructions_len); for (uint32_t ci = 0; ci < child_block.instructions_len; ci++) { - addAirExtra(sema, child_block.instructions[ci]); + semaAddExtra(sema, child_block.instructions[ci]); } sema->air_inst_datas[block_inst_idx].ty_pl.ty_ref = AIR_REF_FROM_IP(resolved_ty); @@ -5153,16 +5153,16 @@ static bool analyzeBodyInner( - 1] == AIR_REF_TO_INST(coerced)); uint32_t sub_bl = coerce_block.instructions_len + 1; - uint32_t sub_br_idx = addAirInst(sema, AIR_INST_BR, + uint32_t sub_br_idx = semaAddInstAsIndex(sema, AIR_INST_BR, (AirInstData) { .br = { .block_inst = label.merges.block_inst, .operand = coerced } }); - uint32_t sub_extra = addAirExtra(sema, sub_bl); + uint32_t sub_extra = semaAddExtra(sema, sub_bl); for (uint32_t si = 0; si < coerce_block.instructions_len; si++) { - addAirExtra(sema, coerce_block.instructions[si]); + semaAddExtra(sema, coerce_block.instructions[si]); } - addAirExtra(sema, sub_br_idx); + semaAddExtra(sema, sub_br_idx); sema->air_inst_tags[br] = AIR_INST_BLOCK; sema->air_inst_datas[br].ty_pl.ty_ref = AIR_REF_FROM_IP(resolved_ty); @@ -5231,7 +5231,7 @@ static bool analyzeBodyInner( } // Runtime: emit BLOCK(bool) + COND_BR with then/else bodies. - uint32_t block_inst_idx = addAirInst(sema, AIR_INST_BLOCK, + uint32_t block_inst_idx = semaAddInstAsIndex(sema, AIR_INST_BLOCK, (AirInstData) { .ty_pl = { .ty_ref = AIR_REF_FROM_IP(IP_INDEX_BOOL_TYPE), .payload = 0 } }); @@ -5282,7 +5282,7 @@ static bool analyzeBodyInner( br_data.br.block_inst = block_inst_idx; br_data.br.operand = lhs_result; AirInstRef br_ref - = blockAddInst(lhs_block, AIR_INST_BR, br_data); + = semaAddInst(lhs_block, AIR_INST_BR, br_data); mergesAppend( &label.merges, lhs_result, AIR_REF_TO_INST(br_ref)); } @@ -5313,7 +5313,7 @@ static bool analyzeBodyInner( br_data.br.block_inst = block_inst_idx; br_data.br.operand = rhs_result; AirInstRef br_ref - = blockAddInst(rhs_block, AIR_INST_BR, br_data); + = semaAddInst(rhs_block, AIR_INST_BR, br_data); mergesAppend( &label.merges, rhs_result, AIR_REF_TO_INST(br_ref)); } @@ -5324,8 +5324,8 @@ static bool analyzeBodyInner( // Emit COND_BR in child_block. uint32_t extra_start - = addAirExtra(sema, then_block.instructions_len); - addAirExtra(sema, else_block.instructions_len); + = semaAddExtra(sema, then_block.instructions_len); + semaAddExtra(sema, else_block.instructions_len); // Branch hints. uint32_t branch_hints_packed = 0; if (is_bool_or) { @@ -5337,20 +5337,20 @@ static bool analyzeBodyInner( } branch_hints_packed |= (1u << 6); // then_cov = poi branch_hints_packed |= (1u << 7); // else_cov = poi - addAirExtra(sema, branch_hints_packed); + semaAddExtra(sema, branch_hints_packed); for (uint32_t ti = 0; ti < then_block.instructions_len; ti++) { - addAirExtra(sema, then_block.instructions[ti]); + semaAddExtra(sema, then_block.instructions[ti]); } for (uint32_t ei = 0; ei < else_block.instructions_len; ei++) { - addAirExtra(sema, else_block.instructions[ei]); + semaAddExtra(sema, else_block.instructions[ei]); } AirInstData cond_data; memset(&cond_data, 0, sizeof(cond_data)); cond_data.pl_op.operand = lhs; cond_data.pl_op.payload = extra_start; - (void)blockAddInst(&child_block, AIR_INST_COND_BR, cond_data); + (void)semaAddInst(&child_block, AIR_INST_COND_BR, cond_data); // Resolve the block (same as zirBlock resolveAnalyzedBlock). // bool_br always has 2 merges (lhs + rhs BR). @@ -5365,9 +5365,9 @@ static bool analyzeBodyInner( block->instructions[block->instructions_len++] = block_inst_idx; uint32_t blk_extra_start - = addAirExtra(sema, child_block.instructions_len); + = semaAddExtra(sema, child_block.instructions_len); for (uint32_t ci = 0; ci < child_block.instructions_len; ci++) { - addAirExtra(sema, child_block.instructions[ci]); + semaAddExtra(sema, child_block.instructions[ci]); } sema->air_inst_datas[block_inst_idx].ty_pl.payload = blk_extra_start; @@ -5437,8 +5437,8 @@ static bool analyzeBodyInner( // Extra data: {then_body_len, else_body_len, branch_hints, // then_body[...], else_body[...]} uint32_t extra_start - = addAirExtra(sema, then_block.instructions_len); - addAirExtra(sema, else_block.instructions_len); + = semaAddExtra(sema, then_block.instructions_len); + semaAddExtra(sema, else_block.instructions_len); // BranchHints packed struct (u32): // bits [0..2] = true hint (BranchHint, 3 bits) // bits [3..5] = false hint (BranchHint, 3 bits) @@ -5450,20 +5450,20 @@ static bool analyzeBodyInner( branch_hints_packed |= (uint32_t)(false_hint & 0x7) << 3; branch_hints_packed |= (1u << 6); // then_cov = poi branch_hints_packed |= (1u << 7); // else_cov = poi - addAirExtra(sema, branch_hints_packed); + semaAddExtra(sema, branch_hints_packed); for (uint32_t ti = 0; ti < then_block.instructions_len; ti++) { - addAirExtra(sema, then_block.instructions[ti]); + semaAddExtra(sema, then_block.instructions[ti]); } for (uint32_t ei = 0; ei < else_block.instructions_len; ei++) { - addAirExtra(sema, else_block.instructions[ei]); + semaAddExtra(sema, else_block.instructions[ei]); } AirInstData cond_data; memset(&cond_data, 0, sizeof(cond_data)); cond_data.pl_op.operand = cond; cond_data.pl_op.payload = extra_start; - (void)blockAddInst(block, AIR_INST_COND_BR, cond_data); + (void)semaAddInst(block, AIR_INST_COND_BR, cond_data); semaBlockDeinit(&then_block); semaBlockDeinit(&else_block); @@ -5505,7 +5505,7 @@ static bool analyzeBodyInner( memset(&br_data, 0, sizeof(br_data)); br_data.br.block_inst = label->merges.block_inst; br_data.br.operand = operand; - AirInstRef br_ref = blockAddInst(block, AIR_INST_BR, br_data); + AirInstRef br_ref = semaAddInst(block, AIR_INST_BR, br_data); // Record merge result. mergesAppend(&label->merges, operand, AIR_REF_TO_INST(br_ref)); @@ -5535,7 +5535,7 @@ static bool analyzeBodyInner( // (no unreach — trap is already noreturn). AirInstData trap_data; memset(&trap_data, 0, sizeof(trap_data)); - (void)blockAddInst(block, AIR_INST_TRAP, trap_data); + (void)semaAddInst(block, AIR_INST_TRAP, trap_data); return false; // panic is terminal } @@ -5549,7 +5549,7 @@ static bool analyzeBodyInner( } AirInstData data; memset(&data, 0, sizeof(data)); - (void)blockAddInst(block, AIR_INST_UNREACH, data); + (void)semaAddInst(block, AIR_INST_UNREACH, data); return false; // unreachable is terminal }