// Copyright (c) 2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.

module arm64

import v2.mir
import v2.ssa
import v2.types
import encoding.binary
import os
import time

pub struct Gen {
pub:
    mod &mir.Module
mut:
    macho &MachOObject
pub mut:
    stack_map      map[int]int
    alloca_offsets map[int]int
    stack_size     int
    curr_offset    int

    block_offsets      []int // indexed by block_id, -1 = not yet visited
    pending_label_blks []int
    pending_label_offs []int
    // Per-block pending label index (linked list head per block id).
    // pending_head[blk_id] = first index into pending_label_offs (-1 = none).
    // pending_next[i] = next pending entry for same block (-1 = last).
    pending_head   []int // indexed by block_id, -1 = no pending labels for this block
    pending_next   []int
    func_count     int
    total_pending  int
    total_resolved int

    // Register allocation
    reg_map    map[int]int
    used_regs  []int
    next_blk   int
    cur_blk_id int // current block being generated (for phi copy emission)

    // Track which string literals have been materialized (value_id -> str_data offset)
    string_literal_offsets map[int]int

    // Cache for parsed constant integer values (value_id -> parsed i64)
    const_cache map[int]i64

    // Current function's return type (for handling struct returns)
    cur_func_ret_type int
    cur_func_name     string

    // Stack offset where x8 (indirect return pointer) is saved for large struct returns
    x8_save_offset int
    // Cache for deduplicating string data in cstring section (content -> offset)
    string_data_cache map[string]int
    // alloca values whose addresses are stored in sumtype `_data` fields and
    // therefore must outlive the current stack frame.
    sumtype_data_heap_allocas map[int]bool
    // Type layout caches/guards to avoid recursive size/alignment loops.
    type_size_cache  []int  // indexed by type_id, 0 = not cached (valid sizes are > 0 or == 0 only for void)
    type_align_cache []int  // indexed by type_id, 0 = not cached
    type_size_stack  []bool // indexed by type_id (recursion guard)
    type_align_stack []bool // indexed by type_id (recursion guard)
    // Cache for struct field offset calculations (key: typ_id << 16 | field_idx)
    struct_field_offset_cache map[int]int
    // Lookup caches for O(1) name resolution
    func_by_name   map[string]int // function name → index in g.mod.funcs
    global_by_name map[string]int // global name → index in g.mod.globals
    // Per-function cache for alloca pointer analysis (cleared per function)
    alloca_ptr_cache map[int]u8 // alloca_id → 1=has_ptrs, 2=no_ptrs
    // Cached environment variables for debug tracing (read once at init)
    env_dump_funcrefs     string
    env_trace_skip_dead   string
    env_dump_stackmap     string
    env_dump_blocks       string
    env_trace_paramspill  string
    env_trace_val         string
    env_trace_instr       string
    env_trace_cmp         string
    env_trace_store       string
    env_trace_load        string
    env_trace_call        string
    env_trace_ret         string
    env_trace_bitcast     string
    env_trace_assign      string
    env_trace_extract     string
    env_trace_struct_init string
    env_trace_agg_copy    string
    env_trace_insert      string
    env_trace_callcount   string
    env_trace_callarg     string
    env_trace_struct_addr string
    env_trace_strlit      string
    env_trace_storeval    string
    env_trace_regalloc    string
    env_no_regalloc       bool
    // SP-relative addressing: sp_base_offset = callee_saved_size + stack_size
    // so that fp - N = sp + (sp_base_offset - N) for positive sp-relative offsets.
    sp_base_offset int
    sp_adjusted    bool // true when sp is temporarily modified (call arg push)
    sp_adjust_amt  int  // how much SP was decremented (valid when sp_adjusted)
    // Last-store cache for eliminating redundant store-then-load sequences.
    // After store_reg_to_val records (reg, val_id), the next load_val_to_reg
    // for the same val_id can reuse the register instead of loading from stack.
    // Cleared at block boundaries, function calls, and any register write.
    last_store_reg            int = -1
    last_store_val            int
    last_store_blk            int = -1
    last_store_next_instr_idx int = -1
    // Current block instruction list and index, for lookahead optimizations.
    cur_blk_instrs    []int
    cur_blk_instr_idx int
    // BasicBlock is large and contains array fields. Cache the per-block
    // instruction slices so self-hosted ARM codegen does not repeatedly copy it.
    block_instrs [][]int
    // Function is large and contains array/string fields. Cache the metadata used by
    // codegen so self-hosted ARM codegen can avoid copying Function values.
    func_names            []string
    func_blocks           [][]int
    func_params           [][]int
    func_typs             []ssa.TypeID
    func_is_c_extern      []bool
    func_abi_ret_indirect []bool
    func_abi_param_class  [][]mir.AbiArgClass
    func_ref_to_func_idx  []int
    type_kinds            []ssa.TypeKind
    type_elem_types       []ssa.TypeID
    type_lens             []int
    type_is_unsigned      []bool
    // Function boundaries for dead-stripping.
    fn_starts  []int    // text offset where each function begins
    fn_ends    []int    // text offset where each function ends
    fn_names   []string // symbol name of each function
    fn_sym_ids []int    // symbol index in macho.symbols
    // Stats counters for optimization analysis.
    stats_total_stores   int
    stats_skipped_stores int
    stats_cache_hits     int
    // Profiling timers for gen_func sub-stages.
    t_setup_ms    f64
    t_prepass_ms  f64
    t_prologue_ms f64
    t_main_ms     f64
    t_regalloc_ms f64
}

pub fn Gen.new(mod &mir.Module) &Gen {
    n_types := mod.type_store.types.len
    return &Gen{
        mod:                   mod
        macho:                 MachOObject.new()
        type_size_cache:       []int{len: n_types}
        type_align_cache:      []int{len: n_types}
        type_size_stack:       []bool{len: n_types}
        type_align_stack:      []bool{len: n_types}
        env_dump_funcrefs:     os.getenv('V2_ARM64_DUMP_FUNCREFS')
        env_trace_skip_dead:   os.getenv('V2_ARM64_TRACE_SKIP_DEAD')
        env_dump_stackmap:     os.getenv('V2_ARM64_DUMP_STACKMAP')
        env_dump_blocks:       os.getenv('V2_ARM64_DUMP_BLOCKS')
        env_trace_paramspill:  os.getenv('V2_ARM64_TRACE_PARAMSPILL')
        env_trace_val:         os.getenv('V2_ARM64_TRACE_VAL')
        env_trace_instr:       os.getenv('V2_ARM64_TRACE_INSTR')
        env_trace_cmp:         os.getenv('V2_ARM64_TRACE_CMP')
        env_trace_store:       os.getenv('V2_ARM64_TRACE_STORE')
        env_trace_load:        os.getenv('V2_ARM64_TRACE_LOAD')
        env_trace_call:        os.getenv('V2_ARM64_TRACE_CALL')
        env_trace_ret:         os.getenv('V2_ARM64_TRACE_RET')
        env_trace_bitcast:     os.getenv('V2_ARM64_TRACE_BITCAST')
        env_trace_assign:      os.getenv('V2_ARM64_TRACE_ASSIGN')
        env_trace_extract:     os.getenv('V2_ARM64_TRACE_EXTRACT')
        env_trace_struct_init: os.getenv('V2_ARM64_TRACE_STRUCT_INIT')
        env_trace_agg_copy:    os.getenv('V2_ARM64_TRACE_AGG_COPY')
        env_trace_insert:      os.getenv('V2_ARM64_TRACE_INSERT')
        env_trace_callcount:   os.getenv('V2_ARM64_TRACE_CALLCOUNT')
        env_trace_callarg:     os.getenv('V2_ARM64_TRACE_CALLARG')
        env_trace_struct_addr: os.getenv('V2_ARM64_TRACE_STRUCT_ADDR')
        env_trace_strlit:      os.getenv('V2_ARM64_TRACE_STRLIT')
        env_trace_storeval:    os.getenv('V2_ARM64_TRACE_STOREVAL')
        env_trace_regalloc:    os.getenv('V2_ARM64_TRACE_REGALLOC')
        env_no_regalloc:       os.getenv('V2_ARM64_NO_REGALLOC').len > 0
    }
}

// Clear the last-store cache (block boundary, call, etc.).
fn (mut g Gen) invalidate_last_store() {
    g.last_store_reg = -1
    g.last_store_val = 0
    g.last_store_blk = -1
    g.last_store_next_instr_idx = -1
}

fn (g &Gen) last_store_cache_enabled() bool {
    return true
}

fn (g &Gen) is_cacheable_last_store_reg(reg int) bool {
    return reg >= 0 && reg != 8 && reg != 9
}

// Check if a store to stack can be skipped for val_id because the value
// will be consumed from the last-store cache by the very next instruction.
// Returns: 0 = must store, 1 = skip (consumed as operand[0]).
fn (mut g Gen) should_skip_store(val_id int) int {
    if !g.last_store_cache_enabled() {
        return 0
    }
    if val_id <= 0 || val_id >= g.mod.values.len {
        return 0
    }
    v := g.mod.values[val_id]
    if v.uses.len != 1 {
        return 0
    }
    // Check that the next instruction in the block is the single consumer.
    next_idx := g.cur_blk_instr_idx + 1
    if next_idx >= g.cur_blk_instrs.len {
        return 0
    }
    next_vid := g.cur_blk_instrs[next_idx]
    if v.uses[0] != next_vid {
        return 0
    }
    if next_vid <= 0 || next_vid >= g.mod.values.len {
        return 0
    }
    nv := g.mod.values[next_vid]
    if nv.kind != .instruction {
        return 0
    }
    ni := g.mod.instrs[nv.index]
    // Only allow pure ops that load operands via get_operand_reg first
    // and DON'T re-load operands afterwards.
    is_arith := ni.op in [.add, .sub, .mul, .sdiv, .udiv, .srem, .urem, .and_, .or_, .xor, .shl,
        .ashr, .lshr]
    is_int_cmp := ni.op in [.eq, .ne, .lt, .gt, .le, .ge, .ult, .ugt, .ule, .uge] && v.typ > 0
        && v.typ < g.mod.type_store.types.len && g.mod.type_store.types[v.typ].kind != .float_t
    is_mem_or_ptr := ni.op in [.store, .load, .get_element_ptr]
    is_int_conv := ni.op in [.trunc, .zext] && v.typ > 0 && v.typ < g.mod.type_store.types.len
        && g.mod.type_store.types[v.typ].kind != .float_t
    if !is_arith && !is_int_cmp && !is_mem_or_ptr && !is_int_conv {
        return 0
    }
    if ni.operands.len == 0 {
        return 0
    }
    // Operand[0] match: skip store entirely, value stays in cache register.
    if ni.operands[0] == val_id {
        return 1
    }
    return 0
}

pub fn (mut g Gen) gen() {
    t0 := time.now()
    g.gen_pre_pass()
    pre_ms := f64(time.since(t0)) / f64(time.millisecond)
    t1 := time.now()
    for fi := 0; fi < g.mod.funcs.len; fi++ {
        g.gen_func(fi)
    }
    funcs_ms := f64(time.since(t1)) / f64(time.millisecond)
    t2 := time.now()
    g.gen_post_pass()
    post_ms := f64(time.since(t2)) / f64(time.millisecond)
    eprintln('ARM64 gen sub: pre=${pre_ms:.1}ms funcs=${funcs_ms:.1}ms post=${post_ms:.1}ms')
    if os.getenv('V2_ARM64_TIME_DETAIL') != '' {
        eprintln('ARM64 gen_func subs: setup=${g.t_setup_ms:.0}ms prepass=${g.t_prepass_ms:.0}ms prologue=${g.t_prologue_ms:.0}ms main=${g.t_main_ms:.0}ms regalloc=${g.t_regalloc_ms:.0}ms')
    }
}

// release_scratch_after_gen drops codegen lookup/cache tables after all machine
// code and relocations have been emitted into g.macho.
pub fn (mut g Gen) release_scratch_after_gen() {
    unsafe {
        g.stack_map.free()
        g.alloca_offsets.free()
        g.block_offsets.free()
        g.pending_label_blks.free()
        g.pending_label_offs.free()
        g.pending_head.free()
        g.pending_next.free()
        g.reg_map.free()
        g.used_regs.free()
        g.string_literal_offsets.free()
        g.const_cache.free()
        g.string_data_cache.free()
        g.sumtype_data_heap_allocas.free()
        g.type_size_cache.free()
        g.type_align_cache.free()
        g.type_size_stack.free()
        g.type_align_stack.free()
        g.struct_field_offset_cache.free()
        g.func_by_name.free()
        g.global_by_name.free()
        g.alloca_ptr_cache.free()
        g.block_instrs.free()
        g.func_blocks.free()
        g.func_params.free()
        g.func_typs.free()
        g.func_is_c_extern.free()
        g.func_abi_ret_indirect.free()
        g.func_abi_param_class.free()
        g.func_ref_to_func_idx.free()
        g.type_kinds.free()
        g.type_elem_types.free()
        g.type_lens.free()
        g.type_is_unsigned.free()
        g.fn_starts.free()
        g.fn_ends.free()
        g.fn_sym_ids.free()
    }
    g.stack_map = map[int]int{}
    g.alloca_offsets = map[int]int{}
    g.block_offsets = []int{}
    g.pending_label_blks = []int{}
    g.pending_label_offs = []int{}
    g.pending_head = []int{}
    g.pending_next = []int{}
    g.reg_map = map[int]int{}
    g.used_regs = []int{}
    g.string_literal_offsets = map[int]int{}
    g.const_cache = map[int]i64{}
    g.string_data_cache = map[string]int{}
    g.sumtype_data_heap_allocas = map[int]bool{}
    g.type_size_cache = []int{}
    g.type_align_cache = []int{}
    g.type_size_stack = []bool{}
    g.type_align_stack = []bool{}
    g.struct_field_offset_cache = map[int]int{}
    g.func_by_name = map[string]int{}
    g.global_by_name = map[string]int{}
    g.alloca_ptr_cache = map[int]u8{}
    g.cur_blk_instrs = []int{}
    g.block_instrs = [][]int{}
    g.func_blocks = [][]int{}
    g.func_params = [][]int{}
    g.func_typs = []ssa.TypeID{}
    g.func_is_c_extern = []bool{}
    g.func_abi_ret_indirect = []bool{}
    g.func_abi_param_class = [][]mir.AbiArgClass{}
    g.func_ref_to_func_idx = []int{}
    g.type_kinds = []ssa.TypeKind{}
    g.type_elem_types = []ssa.TypeID{}
    g.type_lens = []int{}
    g.type_is_unsigned = []bool{}
    g.fn_starts = []int{}
    g.fn_ends = []int{}
    g.fn_sym_ids = []int{}
}

// gen_pre_pass registers global symbols and builds lookup caches.
// Must be called before any gen_func calls.
pub fn (mut g Gen) gen_pre_pass() {
    // Pre-register global symbols BEFORE generating functions
    // This ensures add_undefined() finds existing symbols instead of creating undefined ones
    mut data_offset := u64(0)
    for gi := 0; gi < g.mod.globals.len; gi++ {
        // Skip external globals (defined elsewhere, e.g. __stdoutp)
        if g.mod.globals[gi].linkage == .external {
            continue
        }
        // Align to 8 bytes
        data_offset = (data_offset + 7) & ~7
        g.macho.add_symbol('_' + g.mod.globals[gi].name, data_offset, true, 3)
        size := if g.mod.globals[gi].initial_data.len > 0 {
            g.mod.globals[gi].initial_data.len
        } else {
            g.type_size(g.mod.globals[gi].typ)
        }
        data_offset += u64(size)
    }

    // Build lookup caches for O(1) name resolution and cache function metadata.
    n_funcs := g.mod.funcs.len
    g.func_names = []string{len: n_funcs}
    g.func_blocks = [][]int{len: n_funcs}
    g.func_params = [][]int{len: n_funcs}
    g.func_typs = []ssa.TypeID{len: n_funcs}
    g.func_is_c_extern = []bool{len: n_funcs}
    g.func_abi_ret_indirect = []bool{len: n_funcs}
    g.func_abi_param_class = [][]mir.AbiArgClass{len: n_funcs}
    for fi := 0; fi < n_funcs; fi++ {
        func_name := g.mod.funcs[fi].name
        g.func_names[fi] = func_name
        g.func_blocks[fi] = g.mod.funcs[fi].blocks
        g.func_params[fi] = g.mod.funcs[fi].params
        g.func_typs[fi] = g.mod.funcs[fi].typ
        g.func_is_c_extern[fi] = g.mod.funcs[fi].is_c_extern
        g.func_abi_ret_indirect[fi] = g.mod.funcs[fi].abi_ret_indirect
        g.func_abi_param_class[fi] = g.mod.funcs[fi].abi_param_class
    }
    g.func_ref_to_func_idx = []int{len: g.mod.values.len, init: -1}
    for vi := 0; vi < g.mod.values.len; vi++ {
        if g.mod.values[vi].kind == .func_ref {
            fn_name := g.mod.values[vi].name
            fi := g.find_func_idx_by_name(fn_name)
            if fi >= 0 {
                g.func_ref_to_func_idx[vi] = fi
            }
        }
    }

    n_types := g.mod.type_store.types.len
    g.type_kinds = []ssa.TypeKind{len: n_types}
    g.type_elem_types = []ssa.TypeID{len: n_types}
    g.type_lens = []int{len: n_types}
    g.type_is_unsigned = []bool{len: n_types}
    for ti := 0; ti < n_types; ti++ {
        g.type_kinds[ti] = g.mod.type_store.types[ti].kind
        g.type_elem_types[ti] = g.mod.type_store.types[ti].elem_type
        g.type_lens[ti] = g.mod.type_store.types[ti].len
        g.type_is_unsigned[ti] = g.mod.type_store.types[ti].is_unsigned
    }

    // Pre-populate type size/align caches so parallel workers can share them read-only
    g.pre_populate_type_caches()
    g.block_instrs = [][]int{len: g.mod.blocks.len}
    for bid := 0; bid < g.mod.blocks.len; bid++ {
        g.block_instrs[bid] = g.mod.blocks[bid].instrs
    }
}

// dead_strip_functions removes unreachable functions from the text section.
// Builds a call graph from relocations, marks reachable functions starting
// from _main and __v_init_consts_* roots, then compacts the text section.
fn (mut g Gen) dead_strip_functions() {
    if g.fn_starts.len == 0 {
        return
    }
    ds_t0 := time.now()
    n_fns := g.fn_starts.len
    // Build sym_idx → fn_idx for resolving relocation targets.
    mut sym_to_fn := map[int]int{}
    for fi := 0; fi < n_fns; fi++ {
        sym_to_fn[g.fn_sym_ids[fi]] = fi
    }
    // Build call graph from relocations using binary search on sorted fn_starts.
    mut callees := [][]int{len: n_fns}
    for reloc in g.macho.relocs {
        mut lo := 0
        mut hi := n_fns - 1
        mut src_fn := -1
        for lo <= hi {
            mid := (lo + hi) / 2
            if reloc.addr < g.fn_starts[mid] {
                hi = mid - 1
            } else if reloc.addr >= g.fn_ends[mid] {
                lo = mid + 1
            } else {
                src_fn = mid
                break
            }
        }
        if src_fn < 0 {
            continue
        }
        if tgt_fn := sym_to_fn[reloc.sym_idx] {
            callees[src_fn] << tgt_fn
        }
    }
    // Mark reachable functions starting from roots via BFS.
    mut reachable := []bool{len: n_fns}
    mut worklist := []int{}
    for fi := 0; fi < n_fns; fi++ {
        name := g.fn_names[fi]
        if name == '__main' || name == '_main' || name == '_main__main'
            || name.starts_with('___v_init_consts_')
            || name.starts_with('_builtin____v_init_consts_') || name == '___unresolved_stub' {
            if !reachable[fi] {
                reachable[fi] = true
                worklist << fi
            }
        }
    }
    for worklist.len > 0 {
        fi := worklist.pop()
        for callee in callees[fi] {
            if !reachable[callee] {
                reachable[callee] = true
                worklist << callee
            }
        }
    }
    // Force-strip unused backend modules by name prefix.
    // When compiling for arm64, cleanc/c/eval/x64 functions are never called
    // at runtime. Their symbols redirect to ___unresolved_stub (returns 0).
    for fi2 := 0; fi2 < n_fns; fi2++ {
        if !reachable[fi2] {
            continue
        }
        n2 := g.fn_names[fi2]
        if n2.len > 1 {
            sn := n2[1..] // strip leading underscore
            if sn.starts_with('cleanc__') || sn.starts_with('c__Gen') || sn.starts_with('eval__')
                || sn.starts_with('x64__') {
                reachable[fi2] = false
            }
        }
    }
    // Compute cumulative shift: how many bytes of dead code precede each function.
    mut fn_shift := []int{len: n_fns}
    mut cum_shift := 0
    mut dead_count := 0
    mut dead_bytes := 0
    for fi := 0; fi < n_fns; fi++ {
        fn_shift[fi] = cum_shift
        if !reachable[fi] {
            dead_count++
            fn_size := g.fn_ends[fi] - g.fn_starts[fi]
            dead_bytes += fn_size
            cum_shift += fn_size
        }
    }
    if dead_count == 0 {
        return
    }
    eprintln('ARM64 DEADSTRIP: ${dead_count} dead functions, ${dead_bytes} bytes (${dead_bytes / 1024}KB)')
    // Build compacted text section: copy prefix, kept functions, suffix.
    old_text := g.macho.text_data
    mut new_text := []u8{cap: old_text.len - dead_bytes}
    // Copy prefix bytes before first function (if any).
    if g.fn_starts[0] > 0 {
        new_text << old_text[..g.fn_starts[0]]
    }
    // Copy kept functions in order.
    for fi := 0; fi < n_fns; fi++ {
        if !reachable[fi] {
            continue
        }
        new_text << old_text[g.fn_starts[fi]..g.fn_ends[fi]]
    }
    // Copy suffix bytes after last function (e.g. unresolved stub added by gen_post_pass).
    last_end := g.fn_ends[n_fns - 1]
    if last_end < old_text.len {
        new_text << old_text[last_end..]
    }
    // Fix up relocation addresses and drop relocations inside dead functions.
    mut new_relocs := []RelocationInfo{cap: g.macho.relocs.len}
    for reloc in g.macho.relocs {
        // Binary search for source function (using original boundaries).
        mut lo := 0
        mut hi := n_fns - 1
        mut src_fn := -1
        for lo <= hi {
            mid := (lo + hi) / 2
            if reloc.addr < g.fn_starts[mid] {
                hi = mid - 1
            } else if reloc.addr >= g.fn_ends[mid] {
                lo = mid + 1
            } else {
                src_fn = mid
                break
            }
        }
        if src_fn >= 0 && !reachable[src_fn] {
            continue // drop relocations in dead functions
        }
        mut new_addr := reloc.addr
        if src_fn >= 0 {
            new_addr = reloc.addr - fn_shift[src_fn]
        } else if reloc.addr >= last_end {
            new_addr = reloc.addr - cum_shift
        }
        new_relocs << RelocationInfo{
            addr:    new_addr
            sym_idx: reloc.sym_idx
            pcrel:   reloc.pcrel
            length:  reloc.length
            extern:  reloc.extern
            type_:   reloc.type_
        }
    }
    g.macho.relocs = new_relocs
    // Fix up symbol addresses.
    // Dead function symbols redirect to ___unresolved_stub (returns 0).
    mut stub_new_addr := u64(0)
    if stub_si := g.macho.sym_by_name['___unresolved_stub'] {
        // Stub is in suffix region, shift by total dead bytes.
        stub_new_addr = g.macho.symbols[stub_si].value - u64(cum_shift)
    }
    for si := 0; si < g.macho.symbols.len; si++ {
        old_val := int(g.macho.symbols[si].value)
        if fi := sym_to_fn[si] {
            if reachable[fi] {
                g.macho.symbols[si].value = u64(old_val - fn_shift[fi])
            } else {
                g.macho.symbols[si].value = stub_new_addr
            }
        } else if old_val >= last_end {
            // Symbol in suffix region.
            g.macho.symbols[si].value = u64(old_val - cum_shift)
        }
    }
    // Update function boundaries (for any downstream use).
    for fi := 0; fi < n_fns; fi++ {
        if reachable[fi] {
            g.fn_starts[fi] -= fn_shift[fi]
            g.fn_ends[fi] -= fn_shift[fi]
        }
    }
    g.macho.text_data = new_text
    ds_ms := f64(time.since(ds_t0)) / f64(time.millisecond)
    eprintln('ARM64 deadstrip ms=${ds_ms:.1}')
}

// gen_post_pass emits the unresolved stub, global data, and patches symbol addresses.
// Must be called after all gen_func calls.
pub fn (mut g Gen) gen_post_pass() {
    eprintln('ARM64 STATS: stores=${g.stats_total_stores} skipped=${g.stats_skipped_stores} cache_hits=${g.stats_cache_hits}')
    // Add return-zero stub for unresolved symbols.
    // When the linker can't resolve a symbol, it redirects calls here instead of
    // letting them jump to the Mach-O header which corrupts memory.
    unresolved_stub_offset := u64(g.macho.text_data.len)
    g.macho.add_symbol('___unresolved_stub', unresolved_stub_offset, false, 1)
    g.macho.add_symbol('_tcc_backtrace', unresolved_stub_offset, false, 1)
    g.emit(0xD2800000) // mov x0, #0
    g.emit(0xD2800001) // mov x1, #0
    g.emit(0xD65F03C0) // ret
    g.macho.add_symbol('_v_os_execute_capture_start', u64(g.macho.text_data.len), false, 1)
    g.emit(0x12800000) // mov w0, #-1
    g.emit(0xD65F03C0) // ret

    // Dead-strip unreachable functions.
    g.dead_strip_functions()

    // Globals in __data (Section 3) - emit actual data
    for gi := 0; gi < g.mod.globals.len; gi++ {
        // Skip external globals (defined elsewhere)
        if g.mod.globals[gi].linkage == .external {
            continue
        }
        // Skip globals that collide with function names (same as pre-registration loop)
        if g.has_function_named(g.mod.globals[gi].name) {
            continue
        }
        for g.macho.data_data.len % 8 != 0 {
            g.macho.data_data << 0
        }
        // Constant arrays: emit raw element data directly
        if g.mod.globals[gi].initial_data.len > 0 {
            g.macho.data_data << g.mod.globals[gi].initial_data
            continue
        }
        // Calculate actual size of the global variable based on its type.
        size := g.type_size(g.mod.globals[gi].typ)
        is_constant := g.mod.globals[gi].is_constant
        initial_value := g.mod.globals[gi].initial_value
        if is_constant {
            match size {
                1 {
                    g.macho.data_data << u8(initial_value)
                }
                2 {
                    mut bytes := []u8{len: 2}
                    binary.little_endian_put_u16(mut bytes, u16(initial_value))
                    g.macho.data_data << bytes
                }
                4 {
                    mut bytes := []u8{len: 4}
                    binary.little_endian_put_u32(mut bytes, u32(initial_value))
                    g.macho.data_data << bytes
                }
                8 {
                    mut bytes := []u8{len: 8}
                    binary.little_endian_put_u64(mut bytes, u64(initial_value))
                    g.macho.data_data << bytes
                }
                else {
                    // For struct constants (e.g., sum types), emit initial_value as first 8 bytes
                    // (the tag for sum types), then zeros for the rest.
                    if initial_value != 0 && size >= 8 {
                        mut bytes := []u8{len: 8}
                        binary.little_endian_put_u64(mut bytes, u64(initial_value))
                        g.macho.data_data << bytes
                        for _ in 0 .. size - 8 {
                            g.macho.data_data << 0
                        }
                    } else {
                        for _ in 0 .. size {
                            g.macho.data_data << 0
                        }
                    }
                }
            }
        } else {
            // For regular (mutable) globals, emit initial value if set, else zeros.
            if initial_value != 0 {
                match size {
                    1 {
                        g.macho.data_data << u8(initial_value)
                    }
                    2 {
                        mut bytes := []u8{len: 2}
                        binary.little_endian_put_u16(mut bytes, u16(initial_value))
                        g.macho.data_data << bytes
                    }
                    4 {
                        mut bytes := []u8{len: 4}
                        binary.little_endian_put_u32(mut bytes, u32(initial_value))
                        g.macho.data_data << bytes
                    }
                    else {
                        mut bytes := []u8{len: 8}
                        binary.little_endian_put_u64(mut bytes, u64(initial_value))
                        g.macho.data_data << bytes
                        for _ in 0 .. size - 8 {
                            g.macho.data_data << 0
                        }
                    }
                }
            } else {
                for _ in 0 .. size {
                    g.macho.data_data << 0
                }
            }
        }
    }

    // Patch symbol addresses
    cstring_base := u64(g.macho.text_data.len)
    // Align data section to 8 bytes
    data_base := (cstring_base + u64(g.macho.str_data.len) + 7) & ~7

    for mut sym in g.macho.symbols {
        if sym.sect == 2 {
            sym.value += cstring_base
        } else if sym.sect == 3 {
            sym.value += data_base
        }
    }
}

// new_worker_clone creates a new Gen instance for parallel code generation.
// The worker shares the read-only MIR module and lookup caches, but has its
// own MachOObject buffers for independent code emission.
// pre_populate_type_caches computes type_size and type_align for ALL types
// in the type store, so that workers can share the caches read-only.
pub fn (mut g Gen) pre_populate_type_caches() {
    for tid := 0; tid < g.mod.type_store.types.len; tid++ {
        g.type_size(tid)
        g.type_align(tid)
    }
}

fn (g &Gen) block_id_from_value(val_id int) int {
    if val_id < 0 || val_id >= g.mod.values.len {
        return -1
    }
    if g.mod.values[val_id].kind != .basic_block {
        return -1
    }
    block_id := g.mod.values[val_id].index
    if block_id < 0 || block_id >= g.mod.blocks.len {
        return -1
    }
    return block_id
}

pub fn (g &Gen) new_worker_clone() &Gen {
    // Clone all maps and arrays to avoid COW data races between threads.
    // V's map/array assignment shares internal data; concurrent reads can
    // trigger internal rehashing/COW writes that race with other threads.
    return &Gen{
        mod:                   g.mod
        macho:                 MachOObject.new()
        func_by_name:          g.func_by_name.clone()
        global_by_name:        g.global_by_name.clone()
        type_size_cache:       g.type_size_cache.clone()
        type_align_cache:      g.type_align_cache.clone()
        type_size_stack:       g.type_size_stack.clone()
        type_align_stack:      g.type_align_stack.clone()
        block_instrs:          g.block_instrs.clone()
        func_names:            g.func_names.clone()
        func_blocks:           g.func_blocks.clone()
        func_params:           g.func_params.clone()
        func_typs:             g.func_typs.clone()
        func_is_c_extern:      g.func_is_c_extern.clone()
        func_abi_ret_indirect: g.func_abi_ret_indirect.clone()
        func_abi_param_class:  g.func_abi_param_class.clone()
        func_ref_to_func_idx:  g.func_ref_to_func_idx.clone()
        type_kinds:            g.type_kinds.clone()
        type_elem_types:       g.type_elem_types.clone()
        type_lens:             g.type_lens.clone()
        type_is_unsigned:      g.type_is_unsigned.clone()
        env_dump_funcrefs:     g.env_dump_funcrefs
        env_trace_skip_dead:   g.env_trace_skip_dead
        env_dump_stackmap:     g.env_dump_stackmap
        env_dump_blocks:       g.env_dump_blocks
        env_trace_paramspill:  g.env_trace_paramspill
        env_trace_val:         g.env_trace_val
        env_trace_instr:       g.env_trace_instr
        env_trace_cmp:         g.env_trace_cmp
        env_trace_store:       g.env_trace_store
        env_trace_load:        g.env_trace_load
        env_trace_call:        g.env_trace_call
        env_trace_ret:         g.env_trace_ret
        env_trace_bitcast:     g.env_trace_bitcast
        env_trace_assign:      g.env_trace_assign
        env_trace_extract:     g.env_trace_extract
        env_trace_struct_init: g.env_trace_struct_init
        env_trace_agg_copy:    g.env_trace_agg_copy
        env_trace_insert:      g.env_trace_insert
        env_trace_callcount:   g.env_trace_callcount
        env_trace_callarg:     g.env_trace_callarg
        env_trace_struct_addr: g.env_trace_struct_addr
        env_trace_strlit:      g.env_trace_strlit
        env_trace_storeval:    g.env_trace_storeval
        env_trace_regalloc:    g.env_trace_regalloc
        env_no_regalloc:       g.env_no_regalloc
    }
}

// merge_worker merges a parallel worker's output buffers into the main Gen.
// text_data, str_data, symbols, and relocations are concatenated with offset adjustment.
pub fn (mut g Gen) merge_worker(w &Gen) {
    text_base := g.macho.text_data.len
    str_base := g.macho.str_data.len

    // Append machine code
    g.macho.text_data << w.macho.text_data

    // Append string literal data
    g.macho.str_data << w.macho.str_data

    // Merge symbols: remap worker symbol indices to main symbol table
    mut sym_remap := []int{len: w.macho.symbols.len}
    for wi, sym in w.macho.symbols {
        mut new_value := sym.value
        if sym.sect == 1 {
            new_value += u64(text_base)
        } else if sym.sect == 2 {
            new_value += u64(str_base)
        }
        // Local symbols (L_str_*, L_cstr_*) are per-worker and must never be
        // deduplicated — each worker's L_str_0 refers to a different string literal.
        is_local := sym.name.len > 2 && sym.name[0] == `L` && sym.name[1] == `_`
        // Check if symbol already exists in main (e.g., pre-registered global or extern)
        if !is_local {
            if existing := g.macho.sym_by_name[sym.name] {
                // Update existing symbol with definition if this one defines it
                if sym.type_ != 0x01 { // not N_UNDF
                    mut main_sym := &g.macho.symbols[existing]
                    main_sym.type_ = sym.type_
                    main_sym.sect = sym.sect
                    main_sym.value = new_value
                }
                sym_remap[wi] = existing
                continue
            }
        }
        sym_remap[wi] = g.macho.symbols.len
        name_off := g.macho.str_table.len
        g.macho.str_table << sym.name.bytes()
        g.macho.str_table << 0
        g.macho.symbols << Symbol{
            name:     sym.name
            type_:    sym.type_
            sect:     sym.sect
            desc:     sym.desc
            value:    new_value
            name_off: name_off
        }
        if !is_local {
            g.macho.sym_by_name[sym.name] = sym_remap[wi]
        }
    }

    // Merge relocations with adjusted addresses and remapped symbol indices
    for rel in w.macho.relocs {
        g.macho.relocs << RelocationInfo{
            addr:    rel.addr + text_base
            sym_idx: sym_remap[rel.sym_idx]
            pcrel:   rel.pcrel
            length:  rel.length
            extern:  rel.extern
            type_:   rel.type_
        }
    }
    // Merge function boundary tracking for dead-stripping.
    for fi := 0; fi < w.fn_starts.len; fi++ {
        g.fn_starts << w.fn_starts[fi] + text_base
        g.fn_ends << w.fn_ends[fi] + text_base
        g.fn_names << w.fn_names[fi]
        g.fn_sym_ids << sym_remap[w.fn_sym_ids[fi]]
    }
    // Merge stats.
    g.stats_total_stores += w.stats_total_stores
    g.stats_skipped_stores += w.stats_skipped_stores
    g.stats_cache_hits += w.stats_cache_hits
}

pub fn (mut g Gen) gen_func(func_idx int) {
    if func_idx < 0 || func_idx >= g.func_names.len {
        return
    }
    func_name := g.func_names[func_idx]
    func_blocks := g.func_blocks[func_idx]
    func_params := g.func_params[func_idx]
    func_typ := g.func_typs[func_idx]
    func_abi_param_class := g.func_abi_param_class[func_idx]
    func_abi_ret_indirect := g.func_abi_ret_indirect[func_idx]
    if g.func_is_c_extern[func_idx] {
        // C extern functions are provided by external libraries (libc, etc.).
        // Don't emit any local symbol — let the linker resolve them as undefined externals.
        return
    }
    if func_blocks.len == 0 {
        // Emit a minimal stub: just a ret instruction.
        fn_start := g.macho.text_data.len
        g.curr_offset = fn_start
        sym_name := '_' + func_name
        sym_idx := g.macho.add_symbol(sym_name, u64(fn_start), false, 1)
        g.emit(0xd65f03c0) // ret
        g.fn_starts << fn_start
        g.fn_ends << g.macho.text_data.len
        g.fn_names << sym_name
        g.fn_sym_ids << sym_idx
        return
    }
    tf_setup := time.now()
    g.curr_offset = g.macho.text_data.len
    g.stack_map.clear()
    g.alloca_offsets.clear()
    g.alloca_ptr_cache.clear()
    // Reuse block_offsets and pending_head arrays, grow if needed, only reset
    // entries that can still contain state from the previous function.
    n_blks := g.mod.blocks.len
    if g.block_offsets.len < n_blks {
        g.block_offsets = []int{len: n_blks}
        g.pending_head = []int{len: n_blks}
        // Fresh allocation needs full -1 init.
        for bo_idx := 0; bo_idx < n_blks; bo_idx++ {
            g.block_offsets[bo_idx] = -1
            g.pending_head[bo_idx] = -1
        }
    } else {
        // Only reset blocks belonging to this function.
        for fbi := 0; fbi < func_blocks.len; fbi++ {
            bid := func_blocks[fbi]
            if bid >= 0 && bid < g.block_offsets.len {
                g.block_offsets[bid] = -1
            }
        }
        for pi := 0; pi < g.pending_label_blks.len; pi++ {
            prev_blk := g.pending_label_blks[pi]
            if prev_blk >= 0 && prev_blk < g.pending_head.len {
                g.pending_head[prev_blk] = -1
            }
        }
    }
    g.pending_label_blks.clear()
    g.pending_label_offs.clear()
    g.pending_next.clear()
    g.func_count++
    g.total_pending = 0
    g.total_resolved = 0
    g.reg_map.clear()
    g.used_regs.clear()
    g.string_literal_offsets.clear()
    g.const_cache.clear()
    g.sumtype_data_heap_allocas.clear()
    g.cur_func_ret_type = func_typ
    g.cur_func_name = func_name
    g.x8_save_offset = 0
    g.mark_sumtype_data_heap_allocas(func_idx)
    tf_regalloc := time.now()
    g.t_setup_ms += f64(time.since(tf_setup)) / f64(time.millisecond)
    g.allocate_registers(func_idx)
    tf_prepass := time.now()
    g.t_regalloc_ms += f64(time.since(tf_regalloc)) / f64(time.millisecond)
    if g.env_dump_funcrefs.len > 0
        && (g.env_dump_funcrefs == '*' || func_name == g.env_dump_funcrefs) {
        eprintln('ARM64 FUNCREFS fn=${func_name} begin')
        for i, vv in g.mod.values {
            if vv.kind != .func_ref {
                continue
            }
            if vv.name.contains('cleanc__Gen__expr') {
                vv_typ := vv.typ.str()
                eprintln('ARM64 FUNCREF val=${i} name=${vv.name} typ=${vv_typ}')
            }
        }
        for f in g.mod.funcs {
            if f.name.contains('cleanc__Gen__expr') {
                f_typ := f.typ.str()
                eprintln('ARM64 FUNCDECL id=${f.id} name=${f.name} typ=${f_typ} params_len=${f.params.len}')
            }
        }
        eprintln('ARM64 FUNCREFS fn=${func_name} end')
    }

    // Check if function requires indirect return pointer preservation in x8.
    fn_ret_typ := g.mod.type_store.types[func_typ]
    fn_ret_size := g.type_size(func_typ)
    needs_x8_save := func_abi_ret_indirect || (fn_ret_typ.kind == .struct_t && fn_ret_size > 16)

    // Callee-saved registers are pushed at [fp - 8], [fp - 16], etc.
    // We need to account for this when computing stack offsets
    callee_saved_size := ((g.used_regs.len + 1) / 2) * 16

    // Stack Frame - start after callee-saved register area
    mut slot_offset := 8 + callee_saved_size

    // If function returns large struct, reserve slot for saving x8
    if needs_x8_save {
        g.x8_save_offset = -slot_offset
        slot_offset += 8
    }

    for pi, pid in func_params {
        // For struct parameters, allocate full struct size on the stack.
        // On ARM64, structs > 16 bytes are passed by pointer (indirect),
        // and structs 9-16 bytes are passed in 2 consecutive registers.
        param_typ := g.mod.values[pid].typ
        param_type_info := g.mod.type_store.types[param_typ]
        param_size := g.type_size(param_typ)
        is_indirect_param := pi < func_abi_param_class.len && func_abi_param_class[pi] == .indirect
        if is_indirect_param || (param_type_info.kind == .struct_t && param_size > 16) {
            // Align to 16 bytes and allocate full struct size
            slot_offset = (slot_offset + 15) & ~0xF
            slot_offset += param_size
            g.stack_map[pid] = -slot_offset
            // Reserve one more scalar slot so following values do not overlap
            // with the first field at the base offset.
            slot_offset += 8
        } else if param_type_info.kind == .struct_t && param_size > 8 {
            // Small struct (9-16 bytes) passed in 2 registers - allocate full size
            slot_offset = (slot_offset + 7) & ~0x7
            slot_offset += param_size
            g.stack_map[pid] = -slot_offset
            slot_offset += 8
        } else {
            g.stack_map[pid] = -slot_offset
            slot_offset += 8
        }
    }

    // Pre-pass: find string_literal values used in this function and allocate stack for them
    mut used_string_literals := map[int]bool{}
    for blk_id in func_blocks {
        blk := g.mod.blocks[blk_id]
        for val_id in blk.instrs {
            val := g.mod.values[val_id]
            if val.kind != .instruction {
                continue
            }
            instr := g.mod.instrs[val.index]
            // Check all operands for string_literal references
            for op in instr.operands {
                op_val := g.mod.values[op]
                if op_val.kind == .string_literal {
                    used_string_literals[op] = true
                }
            }
            // Also check return values - if function returns a string_literal directly
            if instr.op == .ret && instr.operands.len > 0 {
                ret_val := g.mod.values[instr.operands[0]]
                if ret_val.kind == .string_literal {
                    used_string_literals[instr.operands[0]] = true
                }
            }
        }
    }

    // Allocate stack slots for used string_literal values
    for str_lit_id, _ in used_string_literals {
        mut str_size := g.type_size(g.mod.values[str_lit_id].typ)
        if str_size <= 0 {
            str_size = 24
        }
        slot_offset = (slot_offset + 15) & ~0xF
        slot_offset += str_size
        g.stack_map[str_lit_id] = -slot_offset
        // Keep subsequent scalar slots below the aggregate base.
        slot_offset += 8
    }

    trace_skip_dead := g.env_trace_skip_dead.len > 0
        && (g.env_trace_skip_dead == '*' || func_name == g.env_trace_skip_dead)

    for i, blk_id in func_blocks {
        g.next_blk = if i + 1 < func_blocks.len { func_blocks[i + 1] } else { -1 }
        blk := g.mod.blocks[blk_id]
        for pp_idx, val_id in blk.instrs {
            val := g.mod.values[val_id]
            if val.kind != .instruction {
                continue
            }
            instr := g.mod.instrs[val.index]
            opcode := g.selected_opcode(instr)
            _ = pp_idx
            // Phi lowering can leave placeholder bitcasts/copies that are fully dead.
            // Do not reserve stack slots for these values; in large recursive
            // functions this can cause pathological frame growth and stack overflow.
            if val.uses.len == 0 {
                if opcode == .bitcast && instr.operands.len == 0 {
                    if trace_skip_dead {
                        eprintln('ARM64 SKIP_DEAD fn=${func_name} val=${val_id} op=bitcast ops_len=${instr.operands.len} uses_len=${val.uses.len}')
                    }
                    continue
                }
                if opcode == .assign {
                    if trace_skip_dead {
                        eprintln('ARM64 SKIP_DEAD fn=${func_name} val=${val_id} op=assign ops_len=${instr.operands.len} uses_len=${val.uses.len}')
                    }
                    continue
                }
            }

            if instr.op == .alloca {
                if val_id !in g.sumtype_data_heap_allocas {
                    // Calculate allocation size based on the type
                    // The alloca result type is ptr(T), so get the element type
                    ptr_type := g.mod.type_store.types[val.typ]
                    elem_size := g.type_size(ptr_type.elem_type)
                    mut alloc_size := if elem_size > 0 { elem_size } else { 8 }
                    // Check for array alloca: operand[0] is element count
                    if instr.operands.len > 0 {
                        count_val := g.mod.values[instr.operands[0]]
                        count := int(parse_const_int_literal(count_val.name))
                        if count > 1 {
                            alloc_size = elem_size * count
                        }
                    }

                    // Align to 16 bytes.
                    slot_offset = (slot_offset + 15) & ~0xF
                    slot_offset += alloc_size
                    g.alloca_offsets[val_id] = -slot_offset

                    // Ensure the next instruction does not use the slot
                    // overlapping with the base of the alloca data.
                    slot_offset += 8
                }
            }

            if instr.op == .inline_string_init {
                // Reserve payload bytes plus a separate pointer slot.
                // The payload size follows the lowered string type layout.
                mut string_size := g.type_size(instr.typ)
                if string_size <= 0 {
                    string_size = 24
                }
                slot_offset = (slot_offset + 15) & ~0xF
                slot_offset += string_size // struct data
                slot_offset += 8 // pointer slot (separate from struct)
                g.stack_map[val_id] = -slot_offset
                continue
            }

            if instr.op == .insertvalue || instr.op == .struct_init {
                // Tuple/struct needs full ABI size, not just fields.len * 8.
                tuple_typ := g.mod.type_store.types[instr.typ]
                mut tuple_size := g.type_size(instr.typ)
                if tuple_size <= 0 {
                    tuple_size = tuple_typ.fields.len * 8
                }
                slot_offset = (slot_offset + 15) & ~0xF
                slot_offset += tuple_size
                g.stack_map[val_id] = -slot_offset
                // Keep following scalar slots from overlapping field 0.
                slot_offset += 8
                continue
            }

            // Keep full stack storage for struct/array values so aggregate copies have
            // stable backing bytes even when values are register-allocated.
            val_typ := g.mod.type_store.types[val.typ]
            if val_typ.kind == .struct_t || val_typ.kind == .array_t {
                mut struct_size := g.type_size(val.typ)
                if struct_size <= 0 {
                    struct_size = if val_typ.fields.len > 0 { val_typ.fields.len * 8 } else { 8 }
                }
                // Some large aggregate producers are represented as data pointers in stack
                // slots (one word), not inline bytes. Reserve pointer-sized storage for
                // those values to avoid pathological frame growth in recursive functions.
                if val_typ.kind == .struct_t && struct_size > 16
                    && g.large_struct_stack_value_is_pointer(val_id) {
                    g.stack_map[val_id] = -slot_offset
                    slot_offset += 8
                    continue
                }
                slot_offset = (slot_offset + 15) & ~0xF
                slot_offset += struct_size
                g.stack_map[val_id] = -slot_offset
                // Keep following scalar slots below the aggregate base.
                slot_offset += 8
                continue
            }

            if instr.op == .call {
                // Check if call returns a tuple
                result_typ := g.mod.type_store.types[val.typ]
                mut is_multi_reg_call := result_typ.kind == .struct_t && result_typ.fields.len > 1
                mut call_tuple_size := g.type_size(val.typ)
                // Also check callee's registered return type
                if !is_multi_reg_call && instr.operands.len > 0 {
                    callee_idx := g.func_idx_from_ref_value(instr.operands[0])
                    if callee_idx >= 0 && callee_idx < g.func_typs.len {
                        callee_typ := g.func_typs[callee_idx]
                        callee_ret_typ := g.mod.type_store.types[callee_typ]
                        callee_ret_size := g.type_size(callee_typ)
                        if callee_ret_typ.kind == .struct_t && callee_ret_size > 8
                            && callee_ret_size <= 16 {
                            is_multi_reg_call = true
                            call_tuple_size = callee_ret_size
                        }
                    }
                }
                if is_multi_reg_call {
                    if call_tuple_size <= 0 {
                        call_tuple_size = 16
                    }
                    slot_offset = (slot_offset + 15) & ~0xF
                    slot_offset += call_tuple_size
                    g.stack_map[val_id] = -slot_offset
                    // Keep following scalar slots below the aggregate base.
                    slot_offset += 8
                    continue
                }
            } else if instr.op == .call_sret {
                // call_sret returns an aggregate indirectly into the destination slot.
                result_typ := g.mod.type_store.types[val.typ]
                if result_typ.kind == .struct_t {
                    result_size := g.type_size(val.typ)
                    slot_offset = (slot_offset + 15) & ~0xF
                    slot_offset += result_size
                    g.stack_map[val_id] = -slot_offset
                    // Keep following scalar slots below the aggregate base.
                    slot_offset += 8
                    continue
                }
            }

            // Skip stack slot for callee-saved register values (always in reg_map).
            if val_id in g.reg_map && g.reg_map[val_id] != 0xFF {
                continue
            }
            // Align to 8 bytes before assigning scalar slot so that
            // SP-relative scaled-immediate addressing always works.
            slot_offset = (slot_offset + 7) & ~0x7
            g.stack_map[val_id] = -slot_offset
            slot_offset += 8
        }
    }

    g.stack_size = (slot_offset + 16) & ~0xF

    if g.env_dump_stackmap.len > 0
        && (g.env_dump_stackmap == '*' || func_name == g.env_dump_stackmap) {
        eprintln('ARM64 FRAME ${func_name} stack_size=${g.stack_size} x8_save_offset=${g.x8_save_offset}')
        eprintln('ARM64 STACKMAP ${func_name} begin')
        for vid, off in g.stack_map {
            mut typ_kind := 'na'
            mut typ_size := 0
            mut typ_id := ssa.TypeID(0)
            mut typ_desc := ''
            mut kind := 'na'
            mut name := ''
            mut op := 'na'
            mut blk := ssa.BlockID(-1)
            mut operands := ''
            mut uses := ''
            if vid > 0 && vid < g.mod.values.len {
                vv := g.mod.values[vid]
                kind = '${vv.kind}'
                name = vv.name
                if vv.typ > 0 && vv.typ < g.mod.type_store.types.len {
                    typ_id = vv.typ
                    typ := g.mod.type_store.types[vv.typ]
                    typ_kind = '${typ.kind}'
                    typ_size = g.type_size(vv.typ)
                    if typ.kind == .struct_t {
                        typ_desc = 'fields_len=${typ.field_names.len} ftypes_len=${typ.fields.len}'
                    } else if typ.kind == .ptr_t {
                        typ_desc = 'elem=${typ.elem_type}'
                    }
                }
                if vv.kind == .instruction {
                    instr := g.mod.instrs[vv.index]
                    op = '${g.selected_opcode(instr)}'
                    blk = instr.block
                    operands = 'len=${instr.operands.len}'
                }
                uses = 'len=${vv.uses.len}'
            }
            eprintln('ARM64 STACKMAP ${func_name} val=${vid} off=${off} kind=${kind} blk=${blk} op=${op} ops=${operands} uses=${uses} typ=${typ_id}/${typ_kind} size=${typ_size} tdesc=`${typ_desc}` name=`${name}`')
        }
        for vid, off in g.alloca_offsets {
            mut elem_typ_id := ssa.TypeID(0)
            mut elem_typ_kind := 'na'
            mut elem_typ_size := 0
            mut alloca_ops := ''
            if vid > 0 && vid < g.mod.values.len {
                vv := g.mod.values[vid]
                if vv.kind == .instruction {
                    instr := g.mod.instrs[vv.index]
                    alloca_ops = 'len=${instr.operands.len}'
                    if vv.typ > 0 && vv.typ < g.mod.type_store.types.len {
                        typ := g.mod.type_store.types[vv.typ]
                        if typ.kind == .ptr_t && typ.elem_type > 0
                            && typ.elem_type < g.mod.type_store.types.len {
                            elem_typ_id = typ.elem_type
                            elem_typ := g.mod.type_store.types[elem_typ_id]
                            elem_typ_kind = '${elem_typ.kind}'
                            elem_typ_size = g.type_size(elem_typ_id)
                        }
                    }
                }
            }
            eprintln('ARM64 ALLOCA ${func_name} val=${vid} off=${off} ops=${alloca_ops} elem=${elem_typ_id}/${elem_typ_kind} size=${elem_typ_size}')
        }
        eprintln('ARM64 STACKMAP ${func_name} end')
    }
    if g.env_dump_blocks.len > 0 && (g.env_dump_blocks == '*' || func_name == g.env_dump_blocks) {
        eprintln('ARM64 BLOCKS ${func_name} begin')
        for bi, blk_id in func_blocks {
            blk := g.mod.blocks[blk_id]
            eprintln('ARM64 BLOCK ${func_name} order=${bi} id=${blk_id} val=${blk.val_id} preds_len=${blk.preds.len} succs_len=${blk.succs.len} instrs_len=${blk.instrs.len}')
            for val_id in blk.instrs {
                if val_id <= 0 || val_id >= g.mod.values.len {
                    continue
                }
                val := g.mod.values[val_id]
                mut op := 'na'
                mut operands := '[]'
                if val.kind == .instruction {
                    instr := g.mod.instrs[val.index]
                    op = '${g.selected_opcode(instr)}'
                    operands = 'len=${instr.operands.len}'
                }
                mut callee_info := ''
                if val.kind == .instruction {
                    instr := g.mod.instrs[val.index]
                    opcode := g.selected_opcode(instr)
                    if opcode in [.call, .call_indirect, .call_sret] && instr.operands.len > 0 {
                        callee_id := instr.operands[0]
                        if callee_id > 0 && callee_id < g.mod.values.len {
                            callee_val := g.mod.values[callee_id]
                            callee_info = ' callee=${callee_id}:${callee_val.kind}:${callee_val.name}:${callee_val.typ}'
                        } else {
                            callee_info = ' callee=${callee_id}:invalid'
                        }
                    }
                }
                eprintln('ARM64 BLOCK INSTR ${func_name} blk=${blk_id} val=${val_id} kind=${val.kind} op=${op} ops=${operands} uses_len=${val.uses.len}${callee_info}')
            }
        }
        eprintln('ARM64 BLOCKS ${func_name} end')
    }
    fn_sym_name := '_' + func_name
    fn_sym_idx := g.macho.add_symbol(fn_sym_name, u64(g.curr_offset), true, 1)
    fn_start_off := g.macho.text_data.len

    tf_prologue := time.now()
    g.t_prepass_ms += f64(time.since(tf_prepass)) / f64(time.millisecond)
    // Prologue
    g.emit(asm_stp_fp_lr_pre())
    g.emit(asm_mov_fp_sp())

    // Save callee-saved regs (pushed below fp using pre-decrement)
    for i := 0; i < g.used_regs.len; i += 2 {
        r1 := g.used_regs[i]
        mut r2 := 31 // xzr
        if i + 1 < g.used_regs.len {
            r2 = g.used_regs[i + 1]
        }
        g.emit(asm_stp_pair_pre(Reg(r1), Reg(r2)))
    }

    g.emit_sub_sp(g.stack_size)

    // Compute sp_base_offset for sp-relative addressing.
    // sp = fp - callee_saved_size - stack_size, so fp - N = sp + (sp_base_offset + N).
    g.sp_base_offset = callee_saved_size + g.stack_size
    g.sp_adjusted = false
    g.sp_adjust_amt = 0

    // Save x8 if this function returns a large struct
    // x8 contains the indirect return pointer from the caller
    // Save it at a fixed offset from fp (below callee-saved registers)
    if g.x8_save_offset != 0 {
        g.emit_str_reg_offset(8, 29, g.x8_save_offset)
    }

    // The Mach-O LC_MAIN entrypoint invokes `main` with C-style argc/argv in
    // x0/x1. Persist them to builtin globals so `os.args` / `arguments()` work.
    if func_name == 'main' {
        g.store_entry_arg_to_global(0, 'builtin__g_main_argc', 4)
        g.store_entry_arg_to_global(1, 'builtin__g_main_argv', 8)
        g.store_entry_arg_to_global(0, 'g_main_argc', 4)
        g.store_entry_arg_to_global(1, 'g_main_argv', 8)
        // Call _vinit to initialize dynamic array constants
        g.emit_call_to_named_fn('_vinit')
    }

    // Spill params
    // ARM64 ABI: args in x0..x7, args 8+ on caller stack.
    // Struct params ≤ 16 bytes occupy ceil(size/8) consecutive registers.
    // Struct params > 16 bytes are passed by pointer (one register).
    // ARM64 ABI: integer params in x0-x7, float params in d0-d7 (independent allocation)
    mut reg_idx := 0
    mut float_reg_idx := 0
    trace_paramspill := g.env_trace_paramspill.len > 0
        && (g.env_trace_paramspill == '*' || func_name == g.env_trace_paramspill)
    for i, pid in func_params {
        param_typ := g.mod.values[pid].typ
        param_type_info := g.mod.type_store.types[param_typ]
        param_size := g.type_size(param_typ)
        is_indirect_param := i < func_abi_param_class.len && func_abi_param_class[i] == .indirect
        if trace_paramspill {
            eprintln('ARM64 PARAMSPILL fn=${func_name} idx=${i} pid=${pid} typ=${param_typ} kind=${int(param_type_info.kind)} size=${param_size} reg_idx=${reg_idx} indirect=${is_indirect_param}')
        }

        // Float parameters arrive in d-registers; move to x-register for storage
        if param_type_info.kind == .float_t && !is_indirect_param {
            if float_reg_idx < 8 {
                // fmov xN, dN to get float bits into integer register
                g.emit(asm_fmov_x_d(Reg(9), float_reg_idx))
                offset := g.stack_map[pid]
                g.emit_str_reg_offset(9, 29, offset)
                if pid in g.reg_map {
                    g.emit_mov_reg(g.reg_map[pid], 9)
                }
            }
            float_reg_idx++
            continue
        }

        mut src_reg := reg_idx
        if reg_idx >= 8 {
            stack_arg_off := 16 + ((reg_idx - 8) * 8)
            g.emit_ldr_reg_offset(9, 29, stack_arg_off)
            src_reg = 9
        }

        // For large struct parameters (> 16 bytes), the argument value is a pointer.
        // Copy pointed struct bytes into the function-local spill slot.
        if is_indirect_param || (param_type_info.kind == .struct_t && param_size > 16) {
            if src_reg != 9 {
                g.emit_mov_reg(9, src_reg)
            }
            offset := g.stack_map[pid]
            num_fields := (param_size + 7) / 8
            for field_idx in 0 .. num_fields {
                g.emit(asm_ldr_imm(Reg(10), Reg(9), u32(field_idx)))
                g.emit_str_reg_offset(10, 29, offset + field_idx * 8)
            }
            // Large/indirect params are represented as addresses in registers.
            // Materialize the local spill address for any register-allocated uses.
            if pid in g.reg_map {
                g.emit_add_fp_imm(g.reg_map[pid], offset)
            }
            reg_idx += 1
        } else if param_type_info.kind == .struct_t && param_size > 8 {
            // Small struct (9-16 bytes) passed in 2 consecutive registers.
            offset := g.stack_map[pid]
            num_regs := (param_size + 7) / 8
            if trace_paramspill {
                eprintln('ARM64 PARAMSPILL fn=${func_name} idx=${i} mode=small_struct offset=${offset} num_regs=${num_regs}')
            }
            for ri in 0 .. num_regs {
                mut cur_reg := reg_idx + ri
                if cur_reg >= 8 {
                    stack_arg_off := 16 + ((cur_reg - 8) * 8)
                    g.emit_ldr_reg_offset(9, 29, stack_arg_off)
                    g.emit_str_reg_offset(9, 29, offset + ri * 8)
                } else {
                    g.emit_str_reg_offset(cur_reg, 29, offset + ri * 8)
                }
            }
            if pid in g.reg_map {
                g.emit_add_fp_imm(g.reg_map[pid], offset)
            }
            reg_idx += num_regs
        } else if pid in g.reg_map {
            reg := g.reg_map[pid]
            offset := g.stack_map[pid]
            g.emit_str_reg_offset(src_reg, 29, offset)
            if reg != src_reg {
                g.emit_mov_reg(reg, src_reg)
            }
            reg_idx += 1
        } else {
            offset := g.stack_map[pid]
            g.emit_str_reg_offset(src_reg, 29, offset)
            reg_idx += 1
        }
    }

    // Run SSA lowered global initializers before entering user main.
    // This mirrors the C backend behavior where __v2_global_init() is invoked from main.
    if func_name == 'main' && g.has_function_named('__v2_global_init') {
        sym_idx := g.macho.add_undefined('_' + '__v2_global_init')
        g.macho.add_reloc(g.macho.text_data.len, sym_idx, arm64_reloc_branch26, true)
        g.emit(asm_bl_reloc())
    }

    // Materialize all string literals unconditionally in the function prologue.
    // Relying on first-use codegen order can leave literal slots uninitialized when
    // control flow reaches a "reuse" site before the first emitted init site.
    mut lit_ids := []int{}
    for lit_id, _ in used_string_literals {
        lit_ids << lit_id
    }
    lit_ids.sort(a < b)
    for lit_id in lit_ids {
        g.load_val_to_reg(8, lit_id)
    }

    tf_main := time.now()
    g.t_prologue_ms += f64(time.since(tf_prologue)) / f64(time.millisecond)
    for i := 0; i < func_blocks.len; i++ {
        g.invalidate_last_store()
        blk_id := int(func_blocks[i])
        g.next_blk = if i + 1 < func_blocks.len { int(func_blocks[i + 1]) } else { -1 }
        g.cur_blk_id = blk_id
        g.block_offsets[blk_id] = g.macho.text_data.len - g.curr_offset

        // Resolve pending forward branches that target this block via the
        // per-block linked list (head in pending_head, next-pointers in pending_next).
        mut pi := if blk_id >= 0 && blk_id < g.pending_head.len {
            g.pending_head[blk_id]
        } else {
            -1
        }
        mut pending_guard := 0
        for pi != -1 {
            if pi < 0 || pi >= g.pending_label_offs.len || pi >= g.pending_next.len
                || pending_guard > g.pending_label_offs.len {
                break
            }
            off := g.pending_label_offs[pi]
            target := g.block_offsets[blk_id]
            rel := (target - off) / 4
            abs_off := g.curr_offset + off
            instr := g.read_u32(abs_off)

            mut new_instr := u32(0)
            // Check for CBZ (0xB4...) / CBNZ (0xB5...) vs B (0x14...) vs B.cond (0x54...)
            if (instr & 0xFE000000) == 0xB4000000 {
                // CBZ / CBNZ (both use imm19 at bits [23:5])
                new_instr = (instr & 0xFF00001F) | ((u32(rel) & 0x7FFFF) << 5)
            } else if (instr & 0xFC000000) == 0x14000000 {
                // B imm26
                new_instr = (instr & 0xFC000000) | (u32(rel) & 0x3FFFFFF)
            } else {
                // B.cond
                new_instr = (instr & 0xFF00001F) | ((u32(rel) & 0x7FFFF) << 5)
            }
            g.write_u32(abs_off, new_instr)
            g.total_resolved++
            pi = g.pending_next[pi]
            pending_guard++
        }

        g.cur_blk_instrs = if blk_id >= 0 && blk_id < g.block_instrs.len {
            g.block_instrs[blk_id]
        } else {
            []int{}
        }
        for instr_idx, val_id in g.cur_blk_instrs {
            g.cur_blk_instr_idx = instr_idx
            g.gen_instr(val_id)
        }
    }
    g.t_main_ms += f64(time.since(tf_main)) / f64(time.millisecond)
    g.fn_starts << fn_start_off
    g.fn_ends << g.macho.text_data.len
    g.fn_names << fn_sym_name
    g.fn_sym_ids << fn_sym_idx
}

fn (mut g Gen) gen_instr(val_id int) {
    instr_idx := g.mod.values[val_id].index
    if instr_idx < 0 || instr_idx >= g.mod.instrs.len {
        return
    }
    instr := g.mod.instrs[instr_idx]
    instr_operands := instr.operands
    op := g.selected_opcode(instr)
    trace_val := g.env_trace_val.len > 0
        && (g.env_trace_val == '*' || g.cur_func_name == g.env_trace_val)
    if trace_val {
        eprintln('ARM64 VAL fn=${g.cur_func_name} val=${val_id} opi=${int(op)} off=${g.macho.text_data.len - g.curr_offset} ops_len=${instr_operands.len}')
    }
    trace_instr := g.env_trace_instr.len > 0
        && (g.env_trace_instr == '*' || g.cur_func_name == g.env_trace_instr)
    if trace_instr {
        typ_id := g.mod.values[val_id].typ
        mut kind := ssa.TypeKind.void_t
        mut width := 0
        mut is_unsigned := false
        if typ_id > 0 && typ_id < g.mod.type_store.types.len {
            typ := g.mod.type_store.types[typ_id]
            kind = typ.kind
            width = typ.width
            is_unsigned = typ.is_unsigned
        }
        eprintln('ARM64 INSTR fn=${g.cur_func_name} val=${val_id} op=${op} orig=${instr.op} typ=${typ_id} kind=${kind} width=${width} unsigned=${is_unsigned} ops_len=${instr_operands.len}')
    }
    if op == .store && g.try_emit_simple_scalar_store(instr_idx) {
        return
    }
    match op {
        .fadd, .fsub, .fmul, .fdiv, .frem {
            // Float operations using scalar SIMD instructions (d0-d7)
            dest_reg := g.get_dest_reg(val_id)

            // For now, load operands as float constants or from memory
            // Load LHS to d0
            g.load_float_operand(instr.operands[0], 0) // d0
            // Load RHS to d1
            g.load_float_operand(instr.operands[1], 1) // d1

            // Perform float operation: result in d0
            match op {
                .fadd {
                    g.emit(asm_fadd_d0_d0_d1())
                }
                .fsub {
                    g.emit(asm_fsub_d0_d0_d1())
                }
                .fmul {
                    g.emit(asm_fmul_d0_d0_d1())
                }
                .fdiv {
                    g.emit(asm_fdiv_d0_d0_d1())
                }
                .frem {
                    // No single instruction for frem on ARM64
                    // Use: d0 = d0 - trunc(d0/d1) * d1
                    g.emit(asm_fdiv_d2_d0_d1())
                    g.emit(asm_frintz_d2())
                    g.emit(asm_fnmsub_d0_d2_d1_d0())
                }
                else {}
            }

            // Convert d0 result back to integer register for storage
            // Store the float bits in the result (for later int() conversion)
            g.emit(asm_fmov_x_d(Reg(dest_reg), 0))

            g.store_reg_to_val(dest_reg, val_id)
        }
        .fptosi {
            // Float to signed integer conversion
            dest_reg := g.get_dest_reg(val_id)

            // Load float operand to d0
            g.load_float_operand(instr.operands[0], 0)

            // FCVTZS Xd, Dn (convert to signed int, truncate toward zero)
            g.emit(asm_fcvtzs_x_d(Reg(dest_reg), 0))

            g.store_reg_to_val(dest_reg, val_id)
        }
        .sitofp {
            // Signed integer to float conversion
            dest_reg := g.get_dest_reg(val_id)

            // Load integer operand to x8
            src_reg := g.get_operand_reg(instr.operands[0], 8)

            // Check if target is f32
            result_is_f32 := g.mod.values[val_id].typ > 0
                && g.mod.values[val_id].typ < g.mod.type_store.types.len
                && g.mod.type_store.types[g.mod.values[val_id].typ].kind == .float_t
                && g.mod.type_store.types[g.mod.values[val_id].typ].width == 32

            // SCVTF Dd, Xn (convert signed int to double)
            g.emit(asm_scvtf_d_x(0, Reg(src_reg)))

            if result_is_f32 {
                // Convert f64→f32 and move to integer register as 32-bit pattern
                g.emit(asm_fcvt_s_d(0, 0))
                g.emit(asm_fmov_w_s(Reg(dest_reg), 0))
            } else {
                // FMOV Xd, D0 (copy f64 bit pattern to integer reg for storage)
                g.emit(asm_fmov_x_d(Reg(dest_reg), 0))
            }

            g.store_reg_to_val(dest_reg, val_id)
        }
        .uitofp {
            // Unsigned integer to float conversion
            dest_reg := g.get_dest_reg(val_id)

            // Load integer operand to x8
            src_reg := g.get_operand_reg(instr.operands[0], 8)

            // Check if target is f32
            result_is_f32 := g.mod.values[val_id].typ > 0
                && g.mod.values[val_id].typ < g.mod.type_store.types.len
                && g.mod.type_store.types[g.mod.values[val_id].typ].kind == .float_t
                && g.mod.type_store.types[g.mod.values[val_id].typ].width == 32

            // UCVTF Dd, Xn (convert unsigned int to double)
            g.emit(asm_ucvtf_d_x(0, Reg(src_reg)))

            if result_is_f32 {
                // Convert f64→f32 and move to integer register as 32-bit pattern
                g.emit(asm_fcvt_s_d(0, 0))
                g.emit(asm_fmov_w_s(Reg(dest_reg), 0))
            } else {
                // FMOV Xd, D0 (copy float bit pattern to integer reg for storage)
                g.emit(asm_fmov_x_d(Reg(dest_reg), 0))
            }

            g.store_reg_to_val(dest_reg, val_id)
        }
        .fptoui {
            // Float to unsigned integer conversion
            dest_reg := g.get_dest_reg(val_id)

            // Load float operand to d0
            g.load_float_operand(instr.operands[0], 0)

            // FCVTZU Xd, Dn (convert to unsigned int, truncate toward zero)
            g.emit(asm_fcvtzu_x_d(Reg(dest_reg), 0))

            g.store_reg_to_val(dest_reg, val_id)
        }
        .add, .sub, .mul, .sdiv, .udiv, .srem, .urem, .and_, .or_, .xor, .shl, .ashr, .lshr, .eq,
        .ne, .lt, .gt, .le, .ge, .ult, .ugt, .ule, .uge {
            // Optimization: Use actual registers if allocated, avoid shuffling to x8/x9
            // Dest register
            dest_reg := g.get_dest_reg(val_id)

            // Op0 (LHS)
            lhs_reg := g.get_operand_reg(instr.operands[0], 8)

            // Op1 (RHS) - Check immediate optimization
            mut is_imm := false
            mut imm_val := i64(0)
            mut rhs_reg := 9 // Default scratch for RHS

            op1 := g.mod.values[instr.operands[1]]
            if op1.kind == .constant
                && op in [.add, .sub, .eq, .ne, .lt, .gt, .le, .ge, .ult, .ugt, .ule, .uge] {
                v := g.get_const_int(instr.operands[1])
                if v >= 0 && v < 4096 {
                    is_imm = true
                    imm_val = v
                }
            }

            if !is_imm {
                // Don't use x8 as scratch if LHS is in x8
                scratch := if lhs_reg == 8 { 9 } else { 8 }
                rhs_reg = g.get_operand_reg(instr.operands[1], scratch)
            }
            mut emitted_types_sum_is_check := false

            match op {
                .add {
                    // Some frontend paths can leave `is` checks over `types.Type` as malformed
                    // `add` i1 over sumtype wrappers. Lower these to direct `_tag == variant_tag`
                    // checks in arm64 so branch conditions remain semantically correct.
                    if g.try_emit_types_type_ischeck_add(dest_reg, lhs_reg, val_id, instr) {
                        emitted_types_sum_is_check = true
                    } else if is_imm {
                        g.emit(asm_add_imm(Reg(dest_reg), Reg(lhs_reg), u32(imm_val)))
                    } else {
                        g.emit(asm_add_reg(Reg(dest_reg), Reg(lhs_reg), Reg(rhs_reg)))
                    }
                }
                .sub {
                    if is_imm {
                        g.emit(asm_sub_imm(Reg(dest_reg), Reg(lhs_reg), u32(imm_val)))
                    } else {
                        g.emit(asm_sub_reg(Reg(dest_reg), Reg(lhs_reg), Reg(rhs_reg)))
                    }
                }
                .mul {
                    g.emit(asm_mul(Reg(dest_reg), Reg(lhs_reg), Reg(rhs_reg)))
                }
                .sdiv {
                    g.emit(asm_sdiv(Reg(dest_reg), Reg(lhs_reg), Reg(rhs_reg)))
                }
                .udiv {
                    g.emit(asm_udiv(Reg(dest_reg), Reg(lhs_reg), Reg(rhs_reg)))
                }
                .srem {
                    // Signed modulo: a % b = a - (a / b) * b
                    // Choose temp register for quotient that doesn't conflict with inputs
                    mut temp_reg := 10
                    if lhs_reg == 10 || rhs_reg == 10 {
                        temp_reg = 11
                        if lhs_reg == 11 || rhs_reg == 11 {
                            temp_reg = 12
                        }
                    }
                    g.emit(asm_sdiv(Reg(temp_reg), Reg(lhs_reg), Reg(rhs_reg)))
                    g.emit(asm_msub(Reg(dest_reg), Reg(temp_reg), Reg(rhs_reg), Reg(lhs_reg)))
                }
                .urem {
                    // Unsigned modulo: a % b = a - (a / b) * b
                    mut temp_reg := 10
                    if lhs_reg == 10 || rhs_reg == 10 {
                        temp_reg = 11
                        if lhs_reg == 11 || rhs_reg == 11 {
                            temp_reg = 12
                        }
                    }
                    g.emit(asm_udiv(Reg(temp_reg), Reg(lhs_reg), Reg(rhs_reg)))
                    g.emit(asm_msub(Reg(dest_reg), Reg(temp_reg), Reg(rhs_reg), Reg(lhs_reg)))
                }
                .and_ {
                    g.emit(asm_and(Reg(dest_reg), Reg(lhs_reg), Reg(rhs_reg)))
                }
                .or_ {
                    g.emit(asm_orr(Reg(dest_reg), Reg(lhs_reg), Reg(rhs_reg)))
                }
                .xor {
                    g.emit(asm_eor(Reg(dest_reg), Reg(lhs_reg), Reg(rhs_reg)))
                }
                .shl {
                    g.emit(asm_lslv(Reg(dest_reg), Reg(lhs_reg), Reg(rhs_reg)))
                }
                .ashr {
                    g.emit(asm_asrv(Reg(dest_reg), Reg(lhs_reg), Reg(rhs_reg)))
                }
                .lshr {
                    g.emit(asm_lsrv(Reg(dest_reg), Reg(lhs_reg), Reg(rhs_reg)))
                }
                .eq, .ne, .lt, .gt, .le, .ge, .ult, .ugt, .ule, .uge {
                    trace_cmp := g.env_trace_cmp.len > 0
                        && (g.env_trace_cmp == '*' || g.cur_func_name == g.env_trace_cmp)
                    lhs_typ := g.mod.values[instr.operands[0]].typ
                    is_float := lhs_typ > 0 && lhs_typ < g.mod.type_store.types.len
                        && g.mod.type_store.types[lhs_typ].kind == .float_t
                    mut handled_large_struct_zero_cmp := false
                    mut large_struct_cmp_operand := 0
                    if is_float {
                        // Float comparison: load to FP regs, use FCMP
                        g.load_float_operand(instr.operands[0], 0) // d0
                        g.load_float_operand(instr.operands[1], 1) // d1
                        g.emit(asm_fcmp_d(Reg(0), Reg(1)))
                    } else {
                        // For `eq/ne` against zero on large struct values, compare the
                        // struct truth word (`[addr + 0]`) instead of the slot address.
                        // This keeps comparison semantics consistent with `.br` lowering.
                        if op in [.eq, .ne] {
                            lhs_id := instr.operands[0]
                            rhs_id := instr.operands[1]
                            if g.value_is_large_struct(lhs_id) && g.is_known_zero_value(rhs_id, 0) {
                                large_struct_cmp_operand = lhs_id
                            } else if g.value_is_large_struct(rhs_id)
                                && g.is_known_zero_value(lhs_id, 0) {
                                large_struct_cmp_operand = rhs_id
                            }
                            if large_struct_cmp_operand > 0 {
                                g.load_large_struct_truth_word_to_reg(9, large_struct_cmp_operand)
                                g.emit(asm_cmp_reg(Reg(9), Reg(31)))
                                handled_large_struct_zero_cmp = true
                            }
                        }
                        if !handled_large_struct_zero_cmp {
                            // Integer comparison
                            // Use 32-bit CMP for i32 operands to preserve sign semantics.
                            use_32bit := lhs_typ > 0 && lhs_typ < g.mod.type_store.types.len
                                && g.mod.type_store.types[lhs_typ].kind == .int_t
                                && g.mod.type_store.types[lhs_typ].width == 32
                            if is_imm {
                                if use_32bit {
                                    g.emit(asm_cmp_imm_w(Reg(lhs_reg), u32(imm_val)))
                                } else {
                                    g.emit(asm_cmp_imm(Reg(lhs_reg), u32(imm_val)))
                                }
                            } else if use_32bit {
                                g.emit(asm_cmp_reg_w(Reg(lhs_reg), Reg(rhs_reg)))
                            } else {
                                g.emit(asm_cmp_reg(Reg(lhs_reg), Reg(rhs_reg)))
                            }
                        }
                    }
                    if trace_cmp {
                        eprintln('ARM64 CMP fn=${g.cur_func_name} val=${val_id} op=${op} lhs_id=${instr.operands[0]} rhs_id=${instr.operands[1]} lhs_reg=${lhs_reg} rhs_reg=${rhs_reg} lhs_typ=${lhs_typ} float=${is_float} large_struct_zero_cmp=${handled_large_struct_zero_cmp} large_struct_id=${large_struct_cmp_operand}')
                    }

                    // CSET Rd, cond (works for both integer and float NZCV flags)
                    match op {
                        .eq { g.emit(asm_cset_eq(Reg(dest_reg))) }
                        .ne { g.emit(asm_cset_ne(Reg(dest_reg))) }
                        .lt { g.emit(asm_cset_lt(Reg(dest_reg))) }
                        .gt { g.emit(asm_cset_gt(Reg(dest_reg))) }
                        .le { g.emit(asm_cset_le(Reg(dest_reg))) }
                        .ge { g.emit(asm_cset_ge(Reg(dest_reg))) }
                        .ugt { g.emit(asm_cset_hi(Reg(dest_reg))) }
                        .uge { g.emit(asm_cset_hs(Reg(dest_reg))) }
                        .ult { g.emit(asm_cset_lo(Reg(dest_reg))) }
                        .ule { g.emit(asm_cset_ls(Reg(dest_reg))) }
                        else {}
                    }
                }
                else {}
            }

            // Keep narrow integer results (i1/i8/i16/i32) canonical after 64-bit
            // ALU ops so upper garbage bits do not leak through later uses.
            // Skip for comparison ops (cset always produces 0 or 1, already canonical).
            is_cmp := op in [.eq, .ne, .lt, .gt, .le, .ge, .ult, .ugt, .ule, .uge]
            if !is_cmp {
                result_typ_id := g.mod.values[val_id].typ
                if result_typ_id > 0 && result_typ_id < g.mod.type_store.types.len {
                    result_typ := g.mod.type_store.types[result_typ_id]
                    if result_typ.kind == .int_t && !emitted_types_sum_is_check {
                        g.canonicalize_narrow_int_result(dest_reg, result_typ_id)
                    }
                }
            }
            // If dest_reg was not the allocated one (e.g. was 8), move it.
            g.store_reg_to_val(dest_reg, val_id)
        }
        .store {
            if instr_operands.len < 2 {
                return
            }
            src_id := instr_operands[0]
            ptr_id := instr_operands[1]
            trace_store := g.env_trace_store.len > 0
                && (g.env_trace_store == '*' || g.cur_func_name == g.env_trace_store)
            // ValueID 0 is the SSA null/invalid sentinel.
            if src_id <= 0 || src_id >= g.mod.values.len {
                return
            }
            if ptr_id <= 0 || ptr_id >= g.mod.values.len {
                return
            }
            mut src_addr_override_id := 0
            if src_id > 0 && src_id < g.mod.values.len {
                src_val2 := g.mod.values[src_id]
                if src_val2.kind == .instruction {
                    src_instr2 := g.mod.instrs[src_val2.index]
                    if src_instr2.op == .bitcast && src_instr2.operands.len > 0 {
                        bitcast_src := src_instr2.operands[0]
                        if bitcast_src > 0 && bitcast_src < g.mod.values.len {
                            bitcast_src_val := g.mod.values[bitcast_src]
                            if bitcast_src_val.kind == .instruction {
                                extract_instr := g.mod.instrs[bitcast_src_val.index]
                                if extract_instr.op == .extractvalue
                                    && extract_instr.operands.len >= 2 {
                                    idx_val_id := extract_instr.operands[1]
                                    if idx_val_id > 0 && idx_val_id < g.mod.values.len {
                                        idx_val := g.mod.values[idx_val_id]
                                        if idx_val.kind == .constant && idx_val.name == '0' {
                                            base_id := extract_instr.operands[0]
                                            if base_id > 0 && base_id < g.mod.values.len {
                                                base_val := g.mod.values[base_id]
                                                if base_val.kind == .instruction {
                                                    load_instr := g.mod.instrs[base_val.index]
                                                    if load_instr.op == .load
                                                        && load_instr.operands.len > 0 {
                                                        load_src := load_instr.operands[0]
                                                        if load_src > 0
                                                            && load_src < g.mod.values.len
                                                            && g.mod.values[load_src].kind == .string_literal {
                                                            // Sumtype string payload lowering can arrive as:
                                                            // bitcast(extractvalue(load(string_literal), 0)).
                                                            // Preserve pointer-to-string-struct, not string.str.
                                                            src_addr_override_id = load_src
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            // Check if we're storing a large struct value (> 16 bytes)
            // In this case, the value is a pointer to the struct and we need to copy
            val_val := g.mod.values[src_id]
            val_typ := g.mod.type_store.types[val_val.typ]
            val_size := g.type_size(val_val.typ)
            is_undef_aggregate := val_val.kind == .constant && val_val.name == 'undef'
            src_has_storage := src_id in g.reg_map || src_id in g.stack_map
                || val_val.kind in [.global, .string_literal]
            mut dst_struct_size := 0
            mut dst_is_large_struct := false
            mut dst_is_small_struct := false
            mut dst_struct_typ_id := ssa.TypeID(0)
            mut dst_elem_is_ptrlike := false
            ptr_val := g.mod.values[ptr_id]
            if ptr_val.typ > 0 && ptr_val.typ < g.mod.type_store.types.len {
                ptr_typ := g.mod.type_store.types[ptr_val.typ]
                if ptr_typ.kind == .ptr_t && ptr_typ.elem_type > 0
                    && ptr_typ.elem_type < g.mod.type_store.types.len {
                    elem_typ := g.mod.type_store.types[ptr_typ.elem_type]
                    elem_size := g.type_size(ptr_typ.elem_type)
                    if elem_typ.kind in [.ptr_t, .func_t] {
                        dst_elem_is_ptrlike = true
                    }
                    if elem_typ.kind == .struct_t || elem_typ.kind == .array_t {
                        dst_struct_typ_id = ptr_typ.elem_type
                        if elem_size > 16 {
                            dst_is_large_struct = true
                            dst_struct_size = elem_size
                        } else if elem_size > 0 {
                            dst_is_small_struct = true
                            dst_struct_size = elem_size
                        }
                    }
                }
            }
            // If the source is a large struct/array (>16 bytes) but the destination
            // pointer's elem_type was not classified as a struct (e.g., GEP through
            // a ptr(ptr(...)) type from array-of-array construction), override.
            if !dst_is_large_struct && val_typ.kind in [.struct_t, .array_t] && val_size > 16 {
                dst_is_large_struct = true
                dst_struct_size = val_size
            }
            if trace_store {
                mut dst_kind := ssa.TypeKind.void_t
                mut dst_size := 0
                mut src_off_dbg := 0
                mut src_has_off_dbg := false
                if src_off := g.stack_map[src_id] {
                    src_off_dbg = src_off
                    src_has_off_dbg = true
                }
                mut src_op_dbg := 'na'
                if val_val.kind == .instruction {
                    src_op_dbg = '${g.selected_opcode(g.mod.instrs[val_val.index])}'
                }
                if ptr_val.typ > 0 && ptr_val.typ < g.mod.type_store.types.len {
                    ptr_typ := g.mod.type_store.types[ptr_val.typ]
                    if ptr_typ.kind == .ptr_t && ptr_typ.elem_type > 0
                        && ptr_typ.elem_type < g.mod.type_store.types.len {
                        dst_kind = g.mod.type_store.types[ptr_typ.elem_type].kind
                        dst_size = g.type_size(ptr_typ.elem_type)
                    }
                }
                eprintln('ARM64 STORE fn=${g.cur_func_name} src=${src_id} sop=${src_op_dbg} ptr=${ptr_id} styp=${val_val.typ}/${val_typ.kind} ssz=${val_size} src_has_storage=${src_has_storage} src_has_off=${src_has_off_dbg} src_off=${src_off_dbg} dst_kind=${dst_kind} dst_size=${dst_size} dst_small=${dst_is_small_struct} dst_ptrlike=${dst_elem_is_ptrlike}')
            }
            mut should_zero_large_store := is_undef_aggregate
            if !should_zero_large_store && (dst_is_large_struct
                || (val_typ.kind in [.struct_t, .array_t] && val_size > 16 && !dst_elem_is_ptrlike))
                && !src_has_storage {
                should_zero_large_store = true
            }

            // Load source first, then preserve it in a register that will not be clobbered
            // when loading the destination pointer (which may use x9 plus x11/x12 scratch).
            mut val_reg := if src_addr_override_id > 0 {
                g.get_operand_reg(src_addr_override_id, 8)
            } else {
                g.get_operand_reg(src_id, 8)
            }
            if val_reg == 9 || val_reg == 11 || val_reg == 12 {
                if val_reg != 8 {
                    g.emit_mov_reg(8, val_reg)
                }
                val_reg = 8
            }
            ptr_reg := g.get_operand_reg(ptr_id, 9)

            if dst_is_large_struct {
                // Destination expects a large struct by value.
                // Large structs are represented as pointers in registers, so copy pointee bytes.
                if should_zero_large_store {
                    g.zero_ptr_bytes(ptr_reg, dst_struct_size)
                } else {
                    mut can_copy_from_src_ptr := false
                    mut src_ptr_reg := if ptr_reg == 11 { 12 } else { 11 }
                    mut src_is_unwrapped_wrapper := false
                    if val_typ.kind == .struct_t && g.is_sumtype_wrapper_struct_type(val_val.typ)
                        && g.load_sumtype_data_ptr_to_reg(src_ptr_reg, src_id) {
                        can_copy_from_src_ptr = true
                        src_is_unwrapped_wrapper = true
                    }
                    if !can_copy_from_src_ptr {
                        if src_off := g.stack_map[src_id] {
                            if g.large_struct_stack_value_is_pointer(src_id)
                                || g.large_aggregate_stack_value_is_pointer(src_id) {
                                g.emit_ldr_reg_offset(src_ptr_reg, 29, src_off)
                            } else if src_id in g.reg_map {
                                if val_reg != src_ptr_reg {
                                    g.emit_mov_reg(src_ptr_reg, val_reg)
                                }
                            } else {
                                g.emit_add_fp_imm(src_ptr_reg, src_off)
                            }
                            can_copy_from_src_ptr = true
                        } else {
                            src_ptr_reg = val_reg
                            can_copy_from_src_ptr = true
                        }
                    }
                    if can_copy_from_src_ptr {
                        mut large_copy_size := dst_struct_size
                        if !src_is_unwrapped_wrapper && val_typ.kind in [.struct_t, .array_t] {
                            src_inline_size := g.type_size(val_val.typ)
                            // Some MIR paths store a small aggregate into a pointer typed as a
                            // larger aggregate (e.g. wrapper field updates through opaque GEPs).
                            // Copy only initialized source bytes and clear the destination tail.
                            if src_inline_size > 0 && src_inline_size < large_copy_size {
                                large_copy_size = src_inline_size
                            }
                        }
                        if large_copy_size <= 0 {
                            large_copy_size = dst_struct_size
                        }
                        g.copy_ptr_to_ptr_bytes(src_ptr_reg, ptr_reg, large_copy_size)
                        if large_copy_size < dst_struct_size {
                            g.zero_ptr_range_bytes(ptr_reg, large_copy_size, dst_struct_size)
                        }
                    } else {
                        g.zero_ptr_bytes(ptr_reg, dst_struct_size)
                    }
                }
            } else if dst_is_small_struct {
                // Destination expects a small multi-field struct by value.
                num_fields := (dst_struct_size + 7) / 8
                mut src_points_to_struct := false
                if dst_struct_typ_id > 0 && val_typ.kind == .ptr_t && val_typ.elem_type > 0
                    && val_typ.elem_type < g.mod.type_store.types.len {
                    // Only treat pointer sources as by-value struct bytes when the
                    // pointee type exactly matches the destination struct type.
                    // Size-only matches can copy unrelated payload structs into wrapper
                    // structs (e.g. ast.Expr), corrupting tag/data words.
                    if val_typ.elem_type == dst_struct_typ_id {
                        if g.is_sumtype_wrapper_struct_type(dst_struct_typ_id)
                            && g.scalar_value_is_pointer_payload(src_id, 0) {
                            src_points_to_struct = false
                        } else {
                            src_points_to_struct = true
                        }
                    }
                }
                mut src_copy_chunks := num_fields
                if !src_points_to_struct {
                    src_size_for_copy := g.aggregate_source_size_bytes(src_id)
                    if src_size_for_copy > 0 {
                        src_chunks := (src_size_for_copy + 7) / 8
                        if src_chunks > 0 && src_chunks < src_copy_chunks {
                            src_copy_chunks = src_chunks
                        }
                    }
                }
                if src_copy_chunks < 1 {
                    src_copy_chunks = 1
                }
                if trace_store {
                    eprintln('ARM64 STORE_SMALL_COPY fn=${g.cur_func_name} src=${src_id} ptr=${ptr_id} src_chunks=${src_copy_chunks}/${num_fields} src_points_to_struct=${src_points_to_struct}')
                }
                if !src_has_storage && !src_points_to_struct {
                    g.emit_mov_reg(10, 31)
                    for i in 0 .. num_fields {
                        g.emit(asm_str_imm(Reg(10), Reg(ptr_reg), u32(i)))
                    }
                } else {
                    mut can_copy_from_src_ptr := false
                    mut src_ptr_reg := if ptr_reg == 11 { 12 } else { 11 }
                    if src_points_to_struct {
                        if val_reg != src_ptr_reg {
                            g.emit_mov_reg(src_ptr_reg, val_reg)
                        }
                        can_copy_from_src_ptr = true
                    } else if src_off := g.stack_map[src_id] {
                        g.emit_add_fp_imm(src_ptr_reg, src_off)
                        can_copy_from_src_ptr = true
                    }
                    if can_copy_from_src_ptr {
                        for i in 0 .. src_copy_chunks {
                            g.emit(asm_ldr_imm(Reg(10), Reg(src_ptr_reg), u32(i)))
                            g.emit(asm_str_imm(Reg(10), Reg(ptr_reg), u32(i)))
                        }
                        if src_copy_chunks < num_fields {
                            g.emit_mov_reg(10, 31)
                            for i in src_copy_chunks .. num_fields {
                                g.emit(asm_str_imm(Reg(10), Reg(ptr_reg), u32(i)))
                            }
                        }
                    } else if num_fields == 1 {
                        // Single-slot struct values in registers can be stored directly.
                        g.emit(asm_str(Reg(val_reg), Reg(ptr_reg)))
                    } else if val_typ.kind in [.struct_t, .array_t] && src_id > 0
                        && src_id < g.mod.values.len {
                        // Source is a struct/array value whose register holds a pointer
                        // (e.g., from a .load of a struct without a stack slot).
                        // Use the register as a source pointer for field-by-field copy.
                        src_val_info := g.mod.values[src_id]
                        if src_val_info.kind == .instruction
                            && g.mod.instrs[src_val_info.index].op == .load {
                            if val_reg != src_ptr_reg {
                                g.emit_mov_reg(src_ptr_reg, val_reg)
                            }
                            for i in 0 .. src_copy_chunks {
                                g.emit(asm_ldr_imm(Reg(10), Reg(src_ptr_reg), u32(i)))
                                g.emit(asm_str_imm(Reg(10), Reg(ptr_reg), u32(i)))
                            }
                            if src_copy_chunks < num_fields {
                                g.emit_mov_reg(10, 31)
                                for i in src_copy_chunks .. num_fields {
                                    g.emit(asm_str_imm(Reg(10), Reg(ptr_reg), u32(i)))
                                }
                            }
                        } else {
                            g.emit_mov_reg(10, 31)
                            for i in 0 .. num_fields {
                                g.emit(asm_str_imm(Reg(10), Reg(ptr_reg), u32(i)))
                            }
                        }
                    } else {
                        // Keep behavior deterministic when aggregate source bytes are unavailable.
                        g.emit_mov_reg(10, 31)
                        for i in 0 .. num_fields {
                            g.emit(asm_str_imm(Reg(10), Reg(ptr_reg), u32(i)))
                        }
                    }
                }
            } else if dst_struct_typ_id > 0 && val_typ.kind in [.struct_t, .array_t]
                && val_size > 16 && !dst_elem_is_ptrlike {
                // Large struct source with non-pointer destination slot:
                // copy pointee bytes into destination memory.
                if should_zero_large_store {
                    g.zero_ptr_bytes(ptr_reg, val_size)
                } else {
                    mut can_copy_from_src_ptr := false
                    mut src_ptr_reg := if ptr_reg == 11 { 12 } else { 11 }
                    if src_off := g.stack_map[src_id] {
                        if g.large_struct_stack_value_is_pointer(src_id)
                            || g.large_aggregate_stack_value_is_pointer(src_id) {
                            g.emit_ldr_reg_offset(src_ptr_reg, 29, src_off)
                        } else if src_id in g.reg_map {
                            if val_reg != src_ptr_reg {
                                g.emit_mov_reg(src_ptr_reg, val_reg)
                            }
                        } else {
                            g.emit_add_fp_imm(src_ptr_reg, src_off)
                        }
                        can_copy_from_src_ptr = true
                    } else {
                        src_ptr_reg = val_reg
                        can_copy_from_src_ptr = true
                    }
                    if can_copy_from_src_ptr {
                        g.copy_ptr_to_ptr_bytes(src_ptr_reg, ptr_reg, val_size)
                    } else {
                        g.zero_ptr_bytes(ptr_reg, val_size)
                    }
                }
            } else if val_typ.kind in [.struct_t, .array_t] && val_size > 0 && val_size <= 16
                && !dst_elem_is_ptrlike {
                // Small aggregate source stored through an opaque destination pointer.
                // Copy value-sized 8-byte chunks (not field count), otherwise packed
                // structs like `{u32,u8}` can over-copy and corrupt adjacent memory.
                num_chunks := (val_size + 7) / 8
                if !src_has_storage {
                    g.emit_mov_reg(10, 31)
                    for i in 0 .. num_chunks {
                        g.emit(asm_str_imm(Reg(10), Reg(ptr_reg), u32(i)))
                    }
                } else if src_off := g.stack_map[src_id] {
                    for i in 0 .. num_chunks {
                        g.emit_ldr_reg_offset(10, 29, src_off + i * 8)
                        g.emit(asm_str_imm(Reg(10), Reg(ptr_reg), u32(i)))
                    }
                } else if num_chunks == 1 {
                    g.emit(asm_str(Reg(val_reg), Reg(ptr_reg)))
                } else if val_typ.kind in [.struct_t, .array_t] && src_id > 0
                    && src_id < g.mod.values.len {
                    src_val_info := g.mod.values[src_id]
                    if src_val_info.kind == .instruction
                        && g.mod.instrs[src_val_info.index].op == .load {
                        if val_reg != 11 {
                            g.emit_mov_reg(11, val_reg)
                        }
                        for i in 0 .. num_chunks {
                            g.emit(asm_ldr_imm(Reg(10), Reg(11), u32(i)))
                            g.emit(asm_str_imm(Reg(10), Reg(ptr_reg), u32(i)))
                        }
                    } else {
                        g.emit_mov_reg(10, 31)
                        for i in 0 .. num_chunks {
                            g.emit(asm_str_imm(Reg(10), Reg(ptr_reg), u32(i)))
                        }
                    }
                } else {
                    g.emit_mov_reg(10, 31)
                    for i in 0 .. num_chunks {
                        g.emit(asm_str_imm(Reg(10), Reg(ptr_reg), u32(i)))
                    }
                }
            } else {
                mut store_size := g.mem_access_size_bytes(val_val.typ, ptr_id)
                // The destination slot controls memory width for pointer fields. A nil
                // constant can be typed as a narrow integer, but storing it into a pointer
                // field must clear all 64 bits, otherwise stale upper address bits remain.
                if store_size < 8 && dst_elem_is_ptrlike {
                    store_size = 8
                }
                // Sumtype payload pointers can flow through i64-typed SSA values.
                // Do not narrow these stores based on imprecise pointer element widths.
                if store_size < 8 && g.scalar_value_is_pointer_payload(src_id, 0) {
                    store_size = 8
                }
                match store_size {
                    1 { g.emit(asm_str_b(Reg(val_reg), Reg(ptr_reg))) }
                    2 { g.emit(asm_str_h(Reg(val_reg), Reg(ptr_reg))) }
                    4 { g.emit(asm_str_w(Reg(val_reg), Reg(ptr_reg))) }
                    else { g.emit(asm_str(Reg(val_reg), Reg(ptr_reg))) }
                }
            }
        }
        .load {
            dest_reg := g.get_dest_reg(val_id)
            ptr_id := instr.operands[0]
            trace_load := g.env_trace_load.len > 0
                && (g.env_trace_load == '*' || g.cur_func_name == g.env_trace_load)
            mut loaded_into_aggregate_slot := false
            mut ptr_is_null_const := false
            // ValueID 0 is the SSA null/invalid sentinel.
            if ptr_id <= 0 || ptr_id >= g.mod.values.len {
                g.emit_mov_imm64(dest_reg, 0)
            } else if data_word_id := g.sumtype_data_word_load_source(ptr_id,
                g.mod.values[val_id].typ)
            {
                if trace_load {
                    eprintln('ARM64 LOAD fn=${g.cur_func_name} val=${val_id} ptr=${ptr_id} sumtype_data_word=${data_word_id}')
                }
                g.load_val_to_reg(dest_reg, data_word_id)
            } else {
                ptr_is_null_const = g.is_effective_null_pointer_value(ptr_id)
                mut ptr_reg := g.get_operand_reg(ptr_id, 9)
                if ptr_id > 0 && ptr_id < g.mod.values.len {
                    ptr_val := g.mod.values[ptr_id]
                    if ptr_val.kind == .instruction {
                        ptr_instr := g.mod.instrs[ptr_val.index]
                        if g.selected_opcode(ptr_instr) == .alloca {
                            ptr_reg = if dest_reg == 9 { 10 } else { 9 }
                            g.load_address_of_val_to_reg(ptr_reg, ptr_id)
                        }
                    }
                }
                if trace_load {
                    mut rkind := ssa.TypeKind.void_t
                    mut rsize := 0
                    mut rtyp := ssa.TypeID(0)
                    mut pkind := mir.ValueKind.constant
                    mut ptyp := ssa.TypeID(0)
                    mut pop := 'na'
                    mut pname := ''
                    mut gtyp := ssa.TypeID(0)
                    mut gkind := ssa.TypeKind.void_t
                    mut gsize := 0
                    mut gconst := false
                    mut ginit_len := 0
                    if val_id > 0 && val_id < g.mod.values.len {
                        rtyp = g.mod.values[val_id].typ
                        if rtyp > 0 && rtyp < g.mod.type_store.types.len {
                            rkind = g.mod.type_store.types[rtyp].kind
                            rsize = g.type_size(rtyp)
                        }
                    }
                    if ptr_id > 0 && ptr_id < g.mod.values.len {
                        ptr_val_dbg := g.mod.values[ptr_id]
                        pkind = ptr_val_dbg.kind
                        ptyp = ptr_val_dbg.typ
                        pname = ptr_val_dbg.name
                        if ptr_val_dbg.kind == .instruction {
                            pop = '${g.selected_opcode(g.mod.instrs[ptr_val_dbg.index])}'
                        } else if ptr_val_dbg.kind == .global {
                            for gvar in g.mod.globals {
                                if gvar.name == ptr_val_dbg.name {
                                    gtyp = gvar.typ
                                    gconst = gvar.is_constant
                                    ginit_len = gvar.initial_data.len
                                    if gtyp > 0 && gtyp < g.mod.type_store.types.len {
                                        gkind = g.mod.type_store.types[gtyp].kind
                                        gsize = g.type_size(gtyp)
                                    }
                                    break
                                }
                            }
                        }
                    }
                    eprintln('ARM64 LOAD fn=${g.cur_func_name} val=${val_id} rtyp=${rtyp} ptr=${ptr_id} ptr_name=`${pname}` ptr_kind=${pkind} ptr_typ=${ptyp} ptr_op=${pop} ptr_reg=${ptr_reg} ptr_null=${ptr_is_null_const} rkind=${rkind} rsize=${rsize} gtyp=${gtyp}/${gkind} gsize=${gsize} gconst=${gconst} ginit=${ginit_len}')
                }
                mut load_src_ptr_reg := ptr_reg
                if ptr_id > 0 && ptr_id < g.mod.values.len {
                    ptr_val := g.mod.values[ptr_id]
                    if ptr_val.kind == .instruction {
                        ptr_instr := g.mod.instrs[ptr_val.index]
                        if g.selected_opcode(ptr_instr) == .alloca {
                            slot_has_ptr := g.alloca_slot_stores_pointer_like_values(ptr_id,
                                g.mod.values[val_id].typ)
                            if trace_load {
                                mut rkind := ssa.TypeKind.void_t
                                mut rsize := 0
                                if g.mod.values[val_id].typ > 0
                                    && g.mod.values[val_id].typ < g.mod.type_store.types.len {
                                    rkind = g.mod.type_store.types[g.mod.values[val_id].typ].kind
                                    rsize = g.type_size(g.mod.values[val_id].typ)
                                }
                                eprintln('ARM64 LOAD fn=${g.cur_func_name} val=${val_id} ptr=${ptr_id} alloca_slot_ptr=${slot_has_ptr} rkind=${rkind} rsize=${rsize}')
                            }
                            if slot_has_ptr {
                                load_src_ptr_reg = if ptr_reg == 11 { 12 } else { 11 }
                                g.emit(asm_ldr(Reg(load_src_ptr_reg), Reg(ptr_reg)))
                            }
                        }
                    }
                }
                result_typ_id := g.mod.values[val_id].typ
                if result_typ_id > 0 && result_typ_id < g.mod.type_store.types.len {
                    result_typ := g.mod.type_store.types[result_typ_id]
                    result_size := g.type_size(result_typ_id)
                    if (result_typ.kind == .struct_t || result_typ.kind == .array_t)
                        && result_size > 8 && result_size <= 16 {
                        if result_offset := g.stack_map[val_id] {
                            if trace_load {
                                eprintln('ARM64 LOAD_SMALL_AGG fn=${g.cur_func_name} val=${val_id} ptr=${ptr_id} result_off=${result_offset} size=${result_size} mode=copy')
                            }
                            if ptr_is_null_const {
                                g.zero_fp_bytes(result_offset, result_size)
                            } else {
                                g.copy_ptr_to_fp_bytes(load_src_ptr_reg, result_offset, result_size)
                            }
                            loaded_into_aggregate_slot = true
                        } else if dest_reg != load_src_ptr_reg {
                            if trace_load {
                                eprintln('ARM64 LOAD_SMALL_AGG fn=${g.cur_func_name} val=${val_id} ptr=${ptr_id} size=${result_size} mode=address')
                            }
                            // Fallback when no aggregate slot is available.
                            if ptr_is_null_const {
                                g.emit_mov_reg(dest_reg, 31)
                            } else {
                                g.emit_mov_reg(dest_reg, load_src_ptr_reg)
                            }
                        }
                    } else if (result_typ.kind == .struct_t || result_typ.kind == .array_t)
                        && result_size > 16 {
                        if result_offset := g.stack_map[val_id] {
                            if g.large_struct_stack_value_is_pointer(val_id) {
                                // Pointer-backed large struct value: keep source address in the
                                // value slot instead of copying full bytes into the frame.
                                if ptr_is_null_const {
                                    g.emit_mov_reg(dest_reg, 31)
                                } else if dest_reg != load_src_ptr_reg {
                                    g.emit_mov_reg(dest_reg, load_src_ptr_reg)
                                }
                                g.store_reg_to_val(dest_reg, val_id)
                            } else {
                                // Materialize large load results by value in their stack slot.
                                if ptr_is_null_const {
                                    g.zero_fp_bytes(result_offset, result_size)
                                } else {
                                    g.copy_ptr_to_fp_bytes(load_src_ptr_reg, result_offset,
                                        result_size)
                                }
                                if val_id in g.reg_map {
                                    g.emit_add_fp_imm(dest_reg, result_offset)
                                }
                            }
                            loaded_into_aggregate_slot = true
                        } else if dest_reg != load_src_ptr_reg {
                            // Fallback when no spill slot is available: keep address form.
                            if ptr_is_null_const {
                                g.emit_mov_reg(dest_reg, 31)
                            } else {
                                g.emit_mov_reg(dest_reg, load_src_ptr_reg)
                            }
                        }
                    } else {
                        if ptr_is_null_const {
                            g.emit_mov_reg(dest_reg, 31)
                        } else {
                            mut load_size := g.mem_access_size_bytes(result_typ_id, ptr_id)
                            // Sumtype payload pointers can be represented as i64 scalar words.
                            // Preserve pointer-width loads for these values even when the
                            // intermediate pointer type appears byte-sized.
                            if load_size < 8 && g.scalar_value_is_pointer_payload(val_id, 0) {
                                load_size = 8
                            }
                            match load_size {
                                1 { g.emit(asm_ldr_b(Reg(dest_reg), Reg(ptr_reg))) }
                                2 { g.emit(asm_ldr_h(Reg(dest_reg), Reg(ptr_reg))) }
                                4 { g.emit(asm_ldr_w(Reg(dest_reg), Reg(ptr_reg))) }
                                else { g.emit(asm_ldr(Reg(dest_reg), Reg(ptr_reg))) }
                            }
                        }
                    }
                } else {
                    if ptr_is_null_const {
                        g.emit_mov_reg(dest_reg, 31)
                    } else {
                        g.emit(asm_ldr(Reg(dest_reg), Reg(ptr_reg)))
                    }
                }
            }

            if !loaded_into_aggregate_slot {
                g.store_reg_to_val(dest_reg, val_id)
            }
        }
        .alloca {
            if val_id in g.sumtype_data_heap_allocas {
                ptr_type := g.mod.type_store.types[g.mod.values[val_id].typ]
                mut alloc_size := g.type_size(ptr_type.elem_type)
                if alloc_size <= 0 {
                    alloc_size = 8
                }
                // alloca can request multiple elements via operand[0].
                if instr.operands.len > 0 {
                    count_id := instr.operands[0]
                    if count_id > 0 && count_id < g.mod.values.len {
                        count_val := g.mod.values[count_id]
                        count := int(parse_const_int_literal(count_val.name))
                        if count > 1 {
                            alloc_size *= count
                        }
                    }
                }
                g.emit_mov_imm(0, 1)
                g.emit_mov_imm(1, u64(alloc_size))
                sym_idx := g.macho.add_undefined('_calloc')
                g.macho.add_reloc(g.macho.text_data.len, sym_idx, arm64_reloc_branch26, true)
                g.emit(asm_bl_reloc())
                g.store_reg_to_val(0, val_id)
            } else {
                data_off := g.alloca_offsets[val_id]
                g.emit_add_fp_imm(8, data_off)
                // Zero-initialize large fixed array allocas.
                // The SSA builder skips element-by-element zero-init for arrays > 16 elements,
                // so the codegen must bulk-zero them here.
                alloca_val := g.mod.values[val_id]
                if alloca_val.typ > 0 && alloca_val.typ < g.mod.type_store.types.len {
                    alloca_ptr_type := g.mod.type_store.types[alloca_val.typ]
                    if alloca_ptr_type.kind == .ptr_t && alloca_ptr_type.elem_type > 0
                        && alloca_ptr_type.elem_type < g.mod.type_store.types.len {
                        elem_typ := g.mod.type_store.types[alloca_ptr_type.elem_type]
                        if elem_typ.kind == .array_t && elem_typ.len > 16 {
                            arr_size := g.type_size(alloca_ptr_type.elem_type)
                            if arr_size > 0 {
                                g.zero_ptr_bytes(8, arr_size)
                            }
                        }
                    }
                }
                g.store_reg_to_val(8, val_id)
            }
        }
        .heap_alloc {
            // Heap-allocate memory for a struct type.
            // Result type is ptr(T), compute sizeof(T) and call calloc(1, size).
            mut alloc_size := 8
            ha_val := g.mod.values[val_id]
            if ha_val.typ > 0 && ha_val.typ < g.mod.type_store.types.len {
                ptr_typ := g.mod.type_store.types[ha_val.typ]
                if ptr_typ.kind == .ptr_t && ptr_typ.elem_type > 0 {
                    alloc_size = g.type_size(ptr_typ.elem_type)
                    if alloc_size <= 0 {
                        alloc_size = 8
                    }
                }
            }
            // calloc(1, size) → x0 = 1, x1 = size
            g.emit_mov_imm(0, 1)
            g.emit_mov_imm(1, u64(alloc_size))
            sym_idx := g.macho.add_undefined('_calloc')
            g.macho.add_reloc(g.macho.text_data.len, sym_idx, arm64_reloc_branch26, true)
            g.emit(asm_bl_reloc())
            // calloc returns heap pointer in x0
            g.store_reg_to_val(0, val_id)
        }
        .get_element_ptr {
            // GEP: Base + scaled index (or struct field offset for aggregate pointers)
            idx_id := instr.operands[1]
            base_typ_id := g.mod.values[instr.operands[0]].typ
            mut pointee_typ_id := ssa.TypeID(0)
            mut base_elem_typ_id := ssa.TypeID(0)
            mut gep_done := false
            if base_typ_id > 0 && base_typ_id < g.mod.type_store.types.len {
                base_typ := g.mod.type_store.types[base_typ_id]
                if base_typ.kind == .ptr_t {
                    pointee_typ_id = base_typ.elem_type
                    base_elem_typ_id = base_typ.elem_type
                }
            }
            mut base_reg := g.get_operand_reg(instr.operands[0], 8)

            // Struct field GEP with constant index: use real field byte offsets.
            // Distinguish from array-style GEP: if the GEP result type equals the
            // base pointer type, this is array indexing (ptr(struct)[i] -> ptr(struct)),
            // not struct field access (ptr(struct), field_idx -> ptr(field_type)).
            mut is_array_gep := false
            base_val_typ := g.mod.values[instr.operands[0]].typ
            if instr.typ == base_val_typ {
                is_array_gep = true
            }
            // Some lowered flows keep pointer payloads in alloca-backed scalar slots.
            // For GEP over such values, first load the payload pointer from the slot.
            mut idx_is_zero_const := false
            if idx_id > 0 && idx_id < g.mod.values.len {
                idx_val_dbg := g.mod.values[idx_id]
                if idx_val_dbg.kind == .constant && idx_val_dbg.name == '0' {
                    idx_is_zero_const = true
                }
            }
            base_val := g.mod.values[instr.operands[0]]
            mut gep_base_slot_has_ptr := false
            if base_val.kind == .instruction {
                base_instr := g.mod.instrs[base_val.index]
                if g.selected_opcode(base_instr) == .alloca {
                    mut target_elem_typ_id := base_elem_typ_id
                    if instr.typ > 0 && instr.typ < g.mod.type_store.types.len {
                        res_typ := g.mod.type_store.types[instr.typ]
                        if res_typ.kind == .ptr_t && res_typ.elem_type > 0
                            && res_typ.elem_type < g.mod.type_store.types.len {
                            target_elem_typ_id = res_typ.elem_type
                        }
                    }
                    gep_base_slot_has_ptr = target_elem_typ_id > 0
                        && g.alloca_slot_stores_pointer_like_values(instr.operands[0], target_elem_typ_id)
                    if gep_base_slot_has_ptr && !(instr.typ == base_val_typ && idx_is_zero_const) {
                        g.emit(asm_ldr(Reg(base_reg), Reg(base_reg)))
                    }
                }
            }
            if !is_array_gep && idx_id > 0 && idx_id < g.mod.values.len && pointee_typ_id > 0
                && pointee_typ_id < g.mod.type_store.types.len {
                idx_val := g.mod.values[idx_id]
                pointee_typ := g.mod.type_store.types[pointee_typ_id]
                if idx_val.kind == .constant && pointee_typ.kind == .struct_t {
                    field_idx := int(parse_const_int_literal(idx_val.name))
                    field_off := g.struct_field_offset_bytes(pointee_typ_id, field_idx)
                    if field_off <= 0xFFF {
                        g.emit(asm_add_imm(Reg(8), Reg(base_reg), u32(field_off)))
                    } else {
                        g.emit_mov_imm64(9, i64(field_off))
                        g.emit(asm_add_reg(Reg(8), Reg(base_reg), Reg(9)))
                    }
                    g.store_gep_result_from_addr(8, val_id)
                    gep_done = true
                }
            }
            if !gep_done {
                // Array/pointer-style GEP: scale by element size.
                mut scale := 8
                mut base_ptr_reg := base_reg
                if pointee_typ_id > 0 && pointee_typ_id < g.mod.type_store.types.len {
                    pointee_typ := g.mod.type_store.types[pointee_typ_id]
                    elem_size := if pointee_typ.kind == .array_t && !is_array_gep {
                        g.type_size(pointee_typ.elem_type)
                    } else {
                        g.type_size(pointee_typ_id)
                    }
                    if elem_size > 0 {
                        scale = elem_size
                    }
                }
                // Ensure index load doesn't clobber base if base is 8
                idx_scratch := if base_ptr_reg == 8 { 9 } else { 8 }
                idx_reg := g.get_operand_reg(idx_id, idx_scratch)
                // Sign-extend index from 32-bit to 64-bit. GEP indices may have
                // been stored as 32-bit values (e.g. from map lookups or
                // extractvalue of int fields) with undefined upper 32 bits.
                // The ARM64 ABI does not guarantee upper bits are zeroed for
                // sub-64-bit values, so always extend before scaling.
                g.emit(asm_sxtw(Reg(idx_reg), Reg(idx_reg)))
                if scale == 8 {
                    g.emit(asm_add_reg_lsl3(Reg(8), Reg(base_ptr_reg), Reg(idx_reg)))
                } else if scale == 1 {
                    g.emit(asm_add_reg(Reg(8), Reg(base_ptr_reg), Reg(idx_reg)))
                } else {
                    mut scale_reg := 10
                    if scale_reg == base_ptr_reg || scale_reg == idx_reg {
                        scale_reg = 11
                        if scale_reg == base_ptr_reg || scale_reg == idx_reg {
                            scale_reg = 12
                        }
                    }
                    g.emit_mov_imm64(scale_reg, scale)
                    g.emit(asm_mul(Reg(scale_reg), Reg(idx_reg), Reg(scale_reg)))
                    g.emit(asm_add_reg(Reg(8), Reg(base_ptr_reg), Reg(scale_reg)))
                }
                g.store_gep_result_from_addr(8, val_id)
            }
        }
        .call {
            g.invalidate_last_store()
            fn_val := g.mod.values[instr.operands[0]]
            fn_name := fn_val.name
            trace_call := g.env_trace_call.len > 0
                && (g.env_trace_call == '*' || g.cur_func_name == g.env_trace_call)
            if trace_call {
                eprintln('ARM64 CALL fn=${g.cur_func_name} val=${val_id} callee_id=${instr.operands[0]} callee=`${fn_name}` args=${instr.operands.len - 1}')
            }
            // Skip calls with empty function names (shouldn't happen, but safety check)
            if fn_name != '' {
                // On ARM64 macOS (Apple Silicon), variadic arguments must be
                // passed on the stack, not in registers.
                is_variadic := fn_name in ['sprintf', 'printf', 'snprintf', 'fprintf', 'sscanf']
                num_fixed_args := if fn_name == 'sprintf' {
                    2 // buffer, format
                } else if fn_name == 'printf' {
                    1 // format
                } else if fn_name in ['snprintf', 'fprintf'] {
                    3 // buffer/file, size, format
                } else if fn_name == 'sscanf' {
                    2 // string, format
                } else {
                    8 // default: all in registers
                }

                num_args := instr.operands.len - 1

                // Check if return type is a large struct (> 16 bytes) requiring indirect return
                result_typ := g.mod.type_store.types[g.mod.values[val_id].typ]
                result_size := g.type_size(g.mod.values[val_id].typ)
                is_indirect_return := result_typ.kind == .struct_t && result_size > 16
                // For indirect struct returns, set x8 to point to result storage BEFORE the call
                if is_indirect_return {
                    result_offset := g.stack_map[val_id]
                    g.emit_add_fp_imm(8, result_offset)
                }

                if is_variadic && num_args > num_fixed_args {
                    // Variadic call: push variadic args to stack, fixed args to registers
                    num_variadic := num_args - num_fixed_args

                    // Allocate stack space for variadic args (8 bytes each, 16-byte aligned)
                    stack_space := ((num_variadic * 8) + 15) & ~0xF
                    if stack_space > 0 {
                        g.sp_adjusted = true
                        g.sp_adjust_amt = stack_space
                        g.emit_sub_sp(stack_space)
                    }

                    // Store variadic arguments to stack (in order)
                    for i := 0; i < num_variadic; i++ {
                        arg_idx := num_fixed_args + 1 + i // +1 because operands[0] is the function
                        // Anonymous variadic args do not have a declared parameter slot.
                        // Pass their promoted value representation directly instead of
                        // reusing fixed-arg lowering, which can incorrectly turn a loaded
                        // scalar into the address of its spill slot.
                        g.load_val_to_reg(9, instr.operands[arg_idx]) // Use x9 to avoid clobbering x8
                        // STR x9, [sp, #offset]
                        offset := i * 8
                        imm12 := u32(offset / 8)
                        g.emit(asm_str_imm(Reg(9), sp, imm12))
                    }

                    // Load fixed arguments to registers (in reverse order to avoid clobbering)
                    for i := num_fixed_args; i >= 1; i-- {
                        g.load_call_arg_to_reg(i - 1, instr.operands[i], i - 1, instr)
                    }

                    // Call function
                    sym_idx := g.macho.add_undefined('_' + fn_name)
                    g.macho.add_reloc(g.macho.text_data.len, sym_idx, arm64_reloc_branch26, true)
                    g.emit(asm_bl_reloc())

                    // Restore stack
                    if stack_space > 0 {
                        if stack_space <= 0xFFF {
                            g.emit(asm_add_imm(sp, sp, u32(stack_space)))
                        } else {
                            g.emit_mov_imm(10, u64(stack_space))
                            g.emit(asm_add_sp_reg(Reg(10)))
                        }
                        g.sp_adjusted = false
                        g.sp_adjust_amt = 0
                    }
                } else {
                    // Non-variadic call:
                    // ARM64 ABI: integer args in x0-x7, float args in d0-d7
                    // Integer and float registers are allocated independently.

                    // Classify each argument as float or integer
                    mut is_float_arg := []bool{len: num_args}
                    mut arg_int_reg := []int{len: num_args, init: -1}
                    mut arg_float_reg := []int{len: num_args, init: -1}
                    mut arg_int_cnt := []int{len: num_args}
                    mut int_reg_idx := 0
                    mut float_reg_idx := 0

                    for a in 0 .. num_args {
                        arg_val := g.mod.values[instr.operands[a + 1]]
                        mut is_float := false
                        if arg_val.typ > 0 && int(arg_val.typ) < g.mod.type_store.types.len {
                            arg_typ := g.mod.type_store.types[arg_val.typ]
                            if arg_typ.kind == .float_t {
                                is_float = true
                            }
                        }
                        if is_float {
                            is_float_arg[a] = true
                            arg_float_reg[a] = float_reg_idx
                            float_reg_idx++
                        } else {
                            cnt := g.call_arg_reg_count(instr.operands[a + 1], a, instr)
                            arg_int_reg[a] = int_reg_idx
                            arg_int_cnt[a] = cnt
                            int_reg_idx += cnt
                        }
                    }

                    // Handle stack-spilled integer args (>8 int regs)
                    num_int_stack := if int_reg_idx > 8 { int_reg_idx - 8 } else { 0 }
                    num_float_stack := if float_reg_idx > 8 { float_reg_idx - 8 } else { 0 }
                    total_stack_slots := num_int_stack + num_float_stack
                    stack_space := ((total_stack_slots * 8) + 15) & ~0xF
                    if stack_space > 0 {
                        g.sp_adjusted = true
                        g.sp_adjust_amt = stack_space
                        g.emit_sub_sp(stack_space)
                        mut stack_idx := 0
                        for a in 0 .. num_args {
                            if is_float_arg[a] {
                                if arg_float_reg[a] >= 8 {
                                    g.load_val_to_reg(9, instr.operands[a + 1])
                                    g.emit(asm_str_imm(Reg(9), sp, u32(stack_idx)))
                                    stack_idx++
                                }
                            } else {
                                cnt := arg_int_cnt[a]
                                start_reg := arg_int_reg[a]
                                expected_struct_typ := g.call_param_type(instr, a) or {
                                    ssa.TypeID(0)
                                }
                                for ri in 0 .. cnt {
                                    if start_reg + ri < 8 {
                                        continue
                                    }
                                    if cnt > 1 {
                                        g.load_struct_arg_word_to_reg(9, instr.operands[a + 1], ri,
                                            expected_struct_typ, instr.operands[0])
                                    } else {
                                        g.load_call_arg_to_reg(9, instr.operands[a + 1], a, instr)
                                    }
                                    g.emit(asm_str_imm(Reg(9), sp, u32(stack_idx)))
                                    stack_idx++
                                }
                            }
                        }
                    }

                    // Load integer args to x-registers (reverse order)
                    for a := num_args - 1; a >= 0; a-- {
                        if is_float_arg[a] {
                            continue
                        }
                        reg := arg_int_reg[a]
                        if reg >= 8 && arg_int_cnt[a] == 1 {
                            continue // stack arg
                        }
                        if arg_int_cnt[a] > 1 {
                            expected_struct_typ := g.call_param_type(instr, a) or { ssa.TypeID(0) }
                            for ri := arg_int_cnt[a] - 1; ri >= 0; ri-- {
                                target_reg := reg + ri
                                if target_reg >= 8 {
                                    continue
                                }
                                g.load_struct_arg_word_to_reg(target_reg, instr.operands[a + 1],
                                    ri, expected_struct_typ, instr.operands[0])
                            }
                        } else {
                            g.load_call_arg_to_reg(reg, instr.operands[a + 1], a, instr)
                        }
                    }

                    // Load float args to d-registers
                    for a in 0 .. num_args {
                        if !is_float_arg[a] {
                            continue
                        }
                        freg := arg_float_reg[a]
                        if freg >= 8 {
                            continue // stack float arg
                        }
                        // Load value bits to x9, then fmov to dN
                        g.load_val_to_reg(9, instr.operands[a + 1])
                        g.emit(asm_fmov_d_x(freg, Reg(9)))
                    }

                    sym_idx := g.macho.add_undefined('_' + fn_name)
                    g.macho.add_reloc(g.macho.text_data.len, sym_idx, arm64_reloc_branch26, true)
                    g.emit(asm_bl_reloc())

                    if stack_space > 0 {
                        if stack_space <= 0xFFF {
                            g.emit(asm_add_imm(sp, sp, u32(stack_space)))
                        } else {
                            g.emit_mov_imm(10, u64(stack_space))
                            g.emit(asm_add_sp_reg(Reg(10)))
                        }
                        g.sp_adjusted = false
                        g.sp_adjust_amt = 0
                    }
                }

                if result_typ.kind != .void_t {
                    // Check if this is a float return: result comes in d0 instead of x0
                    mut is_float_return := result_typ.kind == .float_t
                    if !is_float_return {
                        // Also check the callee's registered return type
                        callee_idx := g.func_idx_from_ref_value(instr.operands[0])
                        if callee_idx >= 0 && callee_idx < g.func_typs.len {
                            callee_ret := g.mod.type_store.types[g.func_typs[callee_idx]]
                            if callee_ret.kind == .float_t {
                                is_float_return = true
                            }
                        }
                    }
                    if is_float_return {
                        // Float return: move d0 to x0 for integer storage
                        g.emit(asm_fmov_x_d(Reg(0), 0))
                        g.store_reg_to_val(0, val_id)
                    } else {
                        // Also check callee's registered return type: when the SSA value type
                        // isn't struct_t (e.g. i64 fallback), use the callee's return type.
                        mut call_ret_is_multi_reg := result_typ.kind == .struct_t && result_size > 8
                        mut actual_call_ret_size := result_size
                        if !call_ret_is_multi_reg && !is_indirect_return
                            && result_typ.kind == .int_t {
                            callee_idx := g.func_idx_from_ref_value(instr.operands[0])
                            if callee_idx >= 0 && callee_idx < g.func_typs.len {
                                callee_typ := g.func_typs[callee_idx]
                                callee_ret_typ := g.mod.type_store.types[callee_typ]
                                callee_ret_size := g.type_size(callee_typ)
                                if callee_ret_typ.kind == .struct_t && callee_ret_size > 8
                                    && callee_ret_size <= 16 {
                                    call_ret_is_multi_reg = true
                                    actual_call_ret_size = callee_ret_size
                                }
                            }
                        }
                        if call_ret_is_multi_reg {
                            if !is_indirect_return {
                                if val_id in g.stack_map {
                                    result_offset := g.stack_map[val_id]
                                    num_chunks := (actual_call_ret_size + 7) / 8
                                    // Use ABI return size, not SSA value type size. Some MIR
                                    // paths merge small-struct call results to `int`, but the
                                    // call still returns x0/x1 that must both be materialized.
                                    for i in 0 .. num_chunks {
                                        if i < 8 {
                                            g.emit_str_reg_offset(i, 29, result_offset + i * 8)
                                        }
                                    }
                                } else {
                                    g.store_reg_to_val(0, val_id)
                                }
                            }
                        } else {
                            g.canonicalize_narrow_int_result(0, g.mod.values[val_id].typ)
                            g.store_reg_to_val(0, val_id)
                        }
                    }
                }
            }
        }
        .call_indirect {
            g.invalidate_last_store()
            // Indirect call through function pointer
            // operands[0] is the function pointer, rest are arguments
            num_args := instr.operands.len - 1

            // Compute register mapping for multi-register struct args.
            mut ci_arg_reg_start := []int{len: num_args}
            mut ci_arg_reg_cnt := []int{len: num_args}
            mut ci_total_reg_slots := 0
            for a in 0 .. num_args {
                ci_arg_reg_start[a] = ci_total_reg_slots
                cnt := g.call_arg_reg_count(instr.operands[a + 1], a, instr)
                ci_arg_reg_cnt[a] = cnt
                ci_total_reg_slots += cnt
            }
            num_stack_slots := if ci_total_reg_slots > 8 {
                ci_total_reg_slots - 8
            } else {
                0
            }
            stack_space := ((num_stack_slots * 8) + 15) & ~0xF
            if stack_space > 0 {
                g.sp_adjusted = true
                g.sp_adjust_amt = stack_space
                g.emit_sub_sp(stack_space)
                mut stack_idx := 0
                for a in 0 .. num_args {
                    cnt := ci_arg_reg_cnt[a]
                    start_reg := ci_arg_reg_start[a]
                    expected_struct_typ := g.call_param_type(instr, a) or { ssa.TypeID(0) }
                    for ri in 0 .. cnt {
                        if start_reg + ri < 8 {
                            continue
                        }
                        if cnt > 1 {
                            g.load_struct_arg_word_to_reg(9, instr.operands[a + 1], ri,
                                expected_struct_typ, instr.operands[0])
                        } else {
                            g.load_call_arg_to_reg(9, instr.operands[a + 1], a, instr)
                        }
                        imm12 := u32(stack_idx)
                        g.emit(asm_str_imm(Reg(9), sp, imm12))
                        stack_idx++
                    }
                }
            }

            for a := num_args - 1; a >= 0; a-- {
                reg := ci_arg_reg_start[a]
                if reg >= 8 && ci_arg_reg_cnt[a] == 1 {
                    continue
                }
                if ci_arg_reg_cnt[a] > 1 {
                    expected_struct_typ := g.call_param_type(instr, a) or { ssa.TypeID(0) }
                    for ri := ci_arg_reg_cnt[a] - 1; ri >= 0; ri-- {
                        target_reg := reg + ri
                        if target_reg >= 8 {
                            continue
                        }
                        g.load_struct_arg_word_to_reg(target_reg, instr.operands[a + 1], ri,
                            expected_struct_typ, instr.operands[0])
                    }
                } else {
                    g.load_call_arg_to_reg(reg, instr.operands[a + 1], a, instr)
                }
            }

            // Load function pointer to x9 (scratch register).
            // Do not use generic value loading here: it can materialize an address
            // for large struct-like values instead of the actual callable pointer.
            g.load_fnptr_to_reg(9, instr.operands[0])

            // BLR x9 - branch and link to register
            g.emit(asm_blr(Reg(9)))

            if stack_space > 0 {
                if stack_space <= 0xFFF {
                    g.emit(asm_add_imm(sp, sp, u32(stack_space)))
                } else {
                    g.emit_mov_imm(10, u64(stack_space))
                    g.emit(asm_add_sp_reg(Reg(10)))
                }
                g.sp_adjusted = false
                g.sp_adjust_amt = 0
            }

            ci_result_typ_id := g.mod.values[val_id].typ
            ci_result_typ := g.mod.type_store.types[ci_result_typ_id]
            if ci_result_typ.kind != .void_t {
                ci_result_size := g.type_size(ci_result_typ_id)
                if ci_result_typ.kind == .struct_t && ci_result_size > 8 {
                    // Small struct return: store x0, x1 into stack slot
                    ci_result_offset := g.stack_map[val_id]
                    num_chunks := (ci_result_size + 7) / 8
                    for i in 0 .. num_chunks {
                        if i < 8 {
                            g.emit_str_reg_offset(i, 29, ci_result_offset + i * 8)
                        }
                    }
                } else {
                    g.canonicalize_narrow_int_result(0, ci_result_typ_id)
                    g.store_reg_to_val(0, val_id)
                }
            }
        }
        .call_sret {
            g.invalidate_last_store()
            // Call with struct return lowered by ABI pass.
            // operands: [fn, arg1, arg2, ...], destination is val_id's stack slot.
            num_args := instr.operands.len - 1
            trace_call := g.env_trace_call.len > 0
                && (g.env_trace_call == '*' || g.cur_func_name == g.env_trace_call)
            if trace_call {
                callee_id := instr.operands[0]
                mut callee_name := ''
                if callee_id > 0 && callee_id < g.mod.values.len {
                    callee_name = g.mod.values[callee_id].name
                }
                eprintln('ARM64 CALL_SRET fn=${g.cur_func_name} val=${val_id} callee_id=${callee_id} callee=`${callee_name}` args=${num_args}')
            }

            // Keep the destination offset for the hidden indirect-return pointer.
            // x8 is scratch for argument materialization, so set it only after
            // all arguments have been loaded.
            result_offset := g.stack_map[val_id]

            // Compute register mapping for multi-register struct args.
            mut sr_arg_reg_start := []int{len: num_args}
            mut sr_arg_reg_cnt := []int{len: num_args}
            mut sr_total_reg_slots := 0
            for a in 0 .. num_args {
                sr_arg_reg_start[a] = sr_total_reg_slots
                cnt := g.call_arg_reg_count(instr.operands[a + 1], a, instr)
                sr_arg_reg_cnt[a] = cnt
                sr_total_reg_slots += cnt
            }
            sr_num_stack_slots := if sr_total_reg_slots > 8 {
                sr_total_reg_slots - 8
            } else {
                0
            }
            stack_space := ((sr_num_stack_slots * 8) + 15) & ~0xF
            if stack_space > 0 {
                g.sp_adjusted = true
                g.sp_adjust_amt = stack_space
                g.emit_sub_sp(stack_space)
                mut stack_idx := 0
                for a in 0 .. num_args {
                    cnt := sr_arg_reg_cnt[a]
                    start_reg := sr_arg_reg_start[a]
                    expected_struct_typ := g.call_param_type(instr, a) or { ssa.TypeID(0) }
                    for ri in 0 .. cnt {
                        if start_reg + ri < 8 {
                            continue
                        }
                        if cnt > 1 {
                            g.load_struct_arg_word_to_reg(9, instr.operands[a + 1], ri,
                                expected_struct_typ, instr.operands[0])
                        } else {
                            g.load_call_arg_to_reg(9, instr.operands[a + 1], a, instr)
                        }
                        imm12 := u32(stack_idx)
                        g.emit(asm_str_imm(Reg(9), sp, imm12))
                        stack_idx++
                    }
                }
            }

            for a := num_args - 1; a >= 0; a-- {
                reg := sr_arg_reg_start[a]
                if reg >= 8 && sr_arg_reg_cnt[a] == 1 {
                    continue
                }
                if sr_arg_reg_cnt[a] > 1 {
                    expected_struct_typ := g.call_param_type(instr, a) or { ssa.TypeID(0) }
                    for ri := sr_arg_reg_cnt[a] - 1; ri >= 0; ri-- {
                        target_reg := reg + ri
                        if target_reg >= 8 {
                            continue
                        }
                        g.load_struct_arg_word_to_reg(target_reg, instr.operands[a + 1], ri,
                            expected_struct_typ, instr.operands[0])
                    }
                } else {
                    g.load_call_arg_to_reg(reg, instr.operands[a + 1], a, instr)
                }
            }

            // Set x8 to destination address for indirect return.
            g.emit_add_fp_imm(8, result_offset)

            fn_val := g.mod.values[instr.operands[0]]
            if fn_val.name != '' && fn_val.kind in [.unknown, .func_ref] {
                // Direct call by symbol.
                sym_idx := g.macho.add_undefined('_' + fn_val.name)
                g.macho.add_reloc(g.macho.text_data.len, sym_idx, arm64_reloc_branch26, true)
                g.emit(asm_bl_reloc())
            } else {
                // Indirect call through function pointer value.
                g.load_fnptr_to_reg(9, instr.operands[0])
                g.emit(asm_blr(Reg(9)))
            }

            if stack_space > 0 {
                if stack_space <= 0xFFF {
                    g.emit(asm_add_imm(sp, sp, u32(stack_space)))
                } else {
                    g.emit_mov_imm(10, u64(stack_space))
                    g.emit(asm_add_sp_reg(Reg(10)))
                }
                g.sp_adjusted = false
                g.sp_adjust_amt = 0
            }
        }
        .ret {
            if instr.operands.len > 0 {
                mut ret_val_id := instr.operands[0]
                mut ret_val_typ := g.mod.values[ret_val_id].typ
                mut ret_typ := g.mod.type_store.types[ret_val_typ]
                trace_ret := g.env_trace_ret.len > 0
                    && (g.env_trace_ret == '*' || g.cur_func_name == g.env_trace_ret)

                // Get the function's declared return type
                fn_ret_type := g.cur_func_ret_type
                fn_ret_typ := g.mod.type_store.types[fn_ret_type]
                fn_ret_size := g.type_size(fn_ret_type)
                mut ret_val_size := g.type_size(ret_val_typ)
                if trace_ret {
                    eprintln('ARM64 RET fn=${g.cur_func_name} ret_val=${ret_val_id} rtyp=${ret_val_typ}/${ret_typ.kind} rsz=${ret_val_size} fn_typ=${fn_ret_type}/${fn_ret_typ.kind} fn_sz=${fn_ret_size} roff=${g.stack_map[ret_val_id]}')
                }
                // Sumtype wrapper returns must produce `{_tag, _data}`.
                // When the lowered return value is a payload/pointer/etc., recover
                // the originating wrapper from the unwrapped value chain.
                if fn_ret_typ.kind == .struct_t && g.is_sumtype_wrapper_struct_type(fn_ret_type)
                    && fn_ret_size > 0 && fn_ret_size <= 16 && ret_val_typ != fn_ret_type {
                    if wrapper_id := g.sumtype_wrapper_source_from_unwrapped_value(ret_val_id,
                        fn_ret_type, 0)
                    {
                        ret_val_id = wrapper_id
                        ret_val_typ = g.mod.values[ret_val_id].typ
                        ret_typ = g.mod.type_store.types[ret_val_typ]
                        ret_val_size = g.type_size(ret_val_typ)
                    }
                }
                // Some lowered return paths re-wrap an already-optional `types.Type`
                // value as `Type(OptionType{ base_type: <Type> })`. For `return inner()`
                // this turns `none` into a fake `some`. Recover the original wrapper.
                if fn_ret_typ.kind == .struct_t && g.is_sumtype_wrapper_struct_type(fn_ret_type) {
                    if forwarded_wrapper_id := g.forwarded_optiontype_wrapper_return_source(ret_val_id,
                        fn_ret_type)
                    {
                        if trace_ret {
                            eprintln('ARM64 RET fn=${g.cur_func_name} rewrite=forward_option_wrapper from=${ret_val_id} to=${forwarded_wrapper_id}')
                        }
                        ret_val_id = forwarded_wrapper_id
                        ret_val_typ = g.mod.values[ret_val_id].typ
                        ret_typ = g.mod.type_store.types[ret_val_typ]
                        ret_val_size = g.type_size(ret_val_typ)
                    }
                }

                // Check if we're returning a pointer but the function expects a struct
                // This happens when returning local struct variables (expr_init returns pointers)
                mut is_indirect_struct_return := false
                if ret_typ.kind == .ptr_t && fn_ret_typ.kind == .struct_t {
                    elem_type := ret_typ.elem_type
                    if elem_type == fn_ret_type {
                        is_indirect_struct_return = true
                    }
                }

                // For large struct returns (> 16 bytes), use indirect return via x8
                // The caller provides the destination address in x8
                if fn_ret_typ.kind == .struct_t && fn_ret_size > 16 {
                    // Restore x8 from the saved location (fp-relative)
                    if g.x8_save_offset != 0 {
                        g.emit_ldr_reg_offset(8, 29, g.x8_save_offset)
                    }

                    // Check if returning a zero/none value (e.g., `return 0` from `return none`).
                    // In this case, zero-fill the return area instead of trying to copy
                    // from address 0 (which would be a null pointer dereference).
                    is_zero_const := g.mod.values[ret_val_id].kind == .constant
                        && g.mod.values[ret_val_id].name == '0'
                    if is_zero_const {
                        num_fields := (fn_ret_size + 7) / 8
                        for i in 0 .. num_fields {
                            // STR xzr, [x8, #i*8]
                            g.emit(asm_str_imm(Reg(31), Reg(8), u32(i)))
                        }
                    } else {
                        // string_literal values need to be materialized on the stack
                        // before we can copy them to the return pointer.
                        if g.mod.values[ret_val_id].kind == .string_literal {
                            g.load_val_to_reg(9, ret_val_id)
                        }

                        // Get the source address of the struct
                        if is_indirect_struct_return {
                            // Return value is a pointer to struct - use it as source
                            g.load_val_to_reg(9, ret_val_id)
                        } else if ret_offset := g.stack_map[ret_val_id] {
                            if g.large_struct_stack_value_is_pointer(ret_val_id) {
                                // Some large-struct temporaries are represented as pointers in stack slots.
                                g.emit_ldr_reg_offset(9, 29, ret_offset)
                            } else {
                                // Struct is materialized by value on stack.
                                g.emit_add_fp_imm(9, ret_offset)
                            }
                        } else {
                            // Fallback
                            g.load_val_to_reg(9, ret_val_id)
                        }
                        // Copy struct from [x9] to [x8] (x8 was restored from saved location)
                        num_fields := (fn_ret_size + 7) / 8
                        for i in 0 .. num_fields {
                            // LDR x10, [x9, #i*8]
                            g.emit(asm_ldr_imm(Reg(10), Reg(9), u32(i)))
                            // STR x10, [x8, #i*8]
                            g.emit(asm_str_imm(Reg(10), Reg(8), u32(i)))
                        }
                    }
                } else if (ret_typ.kind == .struct_t && g.type_size(ret_val_typ) > 8)
                    || is_indirect_struct_return
                    || (fn_ret_typ.kind == .struct_t && fn_ret_size > 8 && fn_ret_size <= 16) {
                    // Small struct (≤ 16 bytes) - return in registers x0, x1
                    // Use type size (not field count) to determine multi-register returns,
                    // since a struct with 1 nested struct field can still span 2 registers.
                    // Also handle the case where the SSA value's type doesn't match the
                    // function's return type (e.g., after PHI node type merging).
                    use_declared_ret_layout := fn_ret_typ.kind == .struct_t
                        && ret_typ.kind == .struct_t && ret_val_size != fn_ret_size
                    actual_struct_typ_id := if is_indirect_struct_return
                        || ret_typ.kind != .struct_t || use_declared_ret_layout {
                        fn_ret_type
                    } else {
                        ret_val_typ
                    }
                    actual_struct_size := g.type_size(actual_struct_typ_id)
                    num_chunks := (actual_struct_size + 7) / 8
                    mut source_chunks := num_chunks
                    if !is_indirect_struct_return {
                        mut source_size := 0
                        if ret_typ.kind in [.struct_t, .array_t] {
                            source_size = g.type_size(ret_val_typ)
                        } else {
                            // Some return values are scalar-typed in SSA while still carrying
                            // multi-word struct bytes in their stack slot (e.g. phi-merged
                            // small structs). Preserve all carried chunks in x0/x1 returns.
                            source_size = g.aggregate_source_size_bytes(ret_val_id)
                            if source_size <= 0 {
                                source_size = g.type_size(ret_val_typ)
                            }
                        }
                        if source_size > 0 {
                            source_chunks = (source_size + 7) / 8
                            if source_chunks < 1 {
                                source_chunks = 1
                            } else if source_chunks > num_chunks {
                                source_chunks = num_chunks
                            }
                        }
                    }
                    if trace_ret {
                        eprintln('ARM64 RET_SMALL_STRUCT fn=${g.cur_func_name} ret_val=${ret_val_id} actual_typ=${actual_struct_typ_id} chunks=${source_chunks}/${num_chunks} indirect=${is_indirect_struct_return}')
                    }
                    is_zero_struct_const := g.mod.values[ret_val_id].kind == .constant
                        && g.mod.values[ret_val_id].name == '0'
                    mut unwrapped_small_sumtype_ret := false
                    if !is_indirect_struct_return && use_declared_ret_layout
                        && actual_struct_size > 0 && actual_struct_size <= 8
                        && g.is_sumtype_wrapper_struct_type(ret_val_typ) {
                        if g.load_sumtype_payload_word_to_reg(0, ret_val_id) {
                            unwrapped_small_sumtype_ret = true
                        }
                    }

                    // Ensure string literals are materialized on the stack
                    // before we try to load their fields into return registers.
                    if g.mod.values[ret_val_id].kind == .string_literal {
                        g.load_val_to_reg(9, ret_val_id)
                    }

                    if is_zero_struct_const {
                        // `return 0`/`return none` for multi-register struct returns must
                        // clear all return registers, not just x0.
                        for i in 0 .. num_chunks {
                            if i < 8 {
                                g.emit_mov_reg(i, 31)
                            }
                        }
                    } else if unwrapped_small_sumtype_ret {
                        // x0 already materialized from sumtype._data payload
                    } else if is_indirect_struct_return {
                        // Return value is a pointer to struct - load each field via the pointer
                        g.load_val_to_reg(8, ret_val_id)
                        for i in 0 .. num_chunks {
                            if i < 8 {
                                g.emit(asm_ldr_imm(Reg(i), Reg(8), u32(i)))
                            }
                        }
                    } else if ret_offset := g.stack_map[ret_val_id] {
                        for i in 0 .. num_chunks {
                            if i < 8 {
                                if i < source_chunks {
                                    g.emit_ldr_reg_offset(i, 29, ret_offset + i * 8)
                                } else {
                                    g.emit_mov_reg(i, 31)
                                }
                            }
                        }
                    } else {
                        if source_chunks > 1 || ret_typ.kind == .struct_t {
                            g.load_struct_src_address_to_reg(8, ret_val_id, actual_struct_typ_id, 0)
                            for i in 0 .. num_chunks {
                                if i < 8 {
                                    if i < source_chunks {
                                        g.emit(asm_ldr_imm(Reg(i), Reg(8), u32(i)))
                                    } else {
                                        g.emit_mov_reg(i, 31)
                                    }
                                }
                            }
                        } else {
                            g.load_val_to_reg(0, ret_val_id)
                            for i in 1 .. num_chunks {
                                if i < 8 {
                                    g.emit_mov_reg(i, 31)
                                }
                            }
                        }
                    }
                } else if fn_ret_typ.kind == .struct_t && g.mod.values[ret_val_id].kind == .constant
                    && g.mod.values[ret_val_id].name == '0' {
                    // Returning zero/none from a function that returns a small struct.
                    // Zero all return registers for the struct to avoid garbage in x1+.
                    num_ret_chunks := (fn_ret_size + 7) / 8
                    for i in 0 .. num_ret_chunks {
                        if i < 8 {
                            g.emit_mov_reg(i, 31) // xN = xzr (zero)
                        }
                    }
                } else {
                    g.load_val_to_reg(0, ret_val_id)
                }
                // For float return types, move result from x0 to d0
                if fn_ret_typ.kind == .float_t {
                    g.emit(asm_fmov_d_x(0, Reg(0))) // fmov d0, x0
                }
            }
            if g.mod.type_store.types[g.cur_func_ret_type].kind == .void_t {
                // Keep void returns deterministic; process entry uses x0 as exit status.
                g.emit_mov_reg(0, 31)
            }
            // Reset SP to the bottom of the callee-saved registers area
            // SP = FP - callee_saved_size
            callee_size := ((g.used_regs.len + 1) / 2) * 16
            g.emit(asm_sub_imm(sp, fp, u32(callee_size)))
            // Restore callee-saved regs
            mut j := g.used_regs.len
            if j % 2 != 0 {
                j += 1
            }
            for j > 0 {
                base := j - 2
                r1 := g.used_regs[base]
                mut r2 := 31 // xzr
                if base + 1 < g.used_regs.len {
                    r2 = g.used_regs[base + 1]
                }
                g.emit(asm_ldp_pair_post(Reg(r1), Reg(r2)))
                j -= 2
            }
            g.emit(asm_ldp_fp_lr_post())
            g.emit(asm_ret())
        }
        .jmp {
            target_blk := instr.operands[0]
            target_idx := g.block_id_from_value(target_blk)

            // Emit phi copies for the target block before branching
            g.emit_phi_copies(target_idx)

            // Fallthrough optimization: Don't jump if target is next block
            if target_idx != g.next_blk {
                if target_idx >= 0 && target_idx < g.block_offsets.len
                    && g.block_offsets[target_idx] != -1 {
                    off := g.block_offsets[target_idx]
                    rel := (off - (g.macho.text_data.len - g.curr_offset)) / 4
                    g.emit(asm_b(rel))
                } else {
                    g.record_pending_label(target_idx)
                    g.emit(asm_b(0))
                }
            }
        }
        .br {
            // Load condition value into x8 for branch.
            // Large struct conditions are lowered through their truth word (`[addr + 0]`)
            // to keep branch semantics aligned with `eq/ne` comparisons against zero.
            cond_id := instr.operands[0]
            if g.value_is_large_struct(cond_id) {
                g.load_large_struct_truth_word_to_reg(8, cond_id)
            } else {
                g.load_val_to_reg(8, cond_id)
            }
            // IR i1 conditions are 1-bit values. Force truncation so non-canonical
            // upper bits from previous producers do not flip branch direction.
            cond_typ := if cond_id >= 0 && cond_id < g.mod.values.len {
                g.mod.values[cond_id].typ
            } else {
                ssa.TypeID(0)
            }
            cond_is_i1 := cond_typ > 0 && cond_typ < g.mod.type_store.types.len
                && g.mod.type_store.types[cond_typ].kind == .int_t
                && g.mod.type_store.types[cond_typ].width == 1
            if cond_is_i1 {
                // Skip AND if condition is from a comparison (cset produces 0/1).
                mut need_and := true
                if cond_id >= 0 && cond_id < g.mod.values.len
                    && g.mod.values[cond_id].kind == .instruction {
                    cond_index := g.mod.values[cond_id].index
                    cond_instr := g.mod.instrs[cond_index]
                    cond_op := g.selected_opcode(cond_instr)
                    if cond_op in [.eq, .ne, .lt, .gt, .le, .ge, .ult, .ugt, .ule, .uge] {
                        need_and = false
                    }
                }
                if need_and {
                    g.emit(asm_and_imm_1(Reg(8), Reg(8)))
                }
            }

            true_blk := g.block_id_from_value(instr.operands[1])
            false_blk := g.block_id_from_value(instr.operands[2])

            has_phis := g.block_has_phis(true_blk) || g.block_has_phis(false_blk)
            if has_phis {
                // When target blocks have phi nodes (e.g. -O0 mode), we must emit
                // phi copies on each branch path separately.
                if true_blk == g.next_blk {
                    // Optimize: true_blk is next block (fall-through).
                    // Structure:
                    //   CBNZ x8, true_path
                    //   <false phi copies>
                    //   B false_blk (or fall-through if false_blk == next)
                    //   true_path:
                    //   <true phi copies>
                    //   (fall through to true_blk)
                    cbnz_off := g.macho.text_data.len - g.curr_offset
                    g.emit(asm_cbnz(Reg(8), 0)) // placeholder, will patch

                    // False path: emit phi copies then branch to false block
                    g.emit_phi_copies(false_blk)
                    if false_blk >= 0 && false_blk < g.block_offsets.len
                        && g.block_offsets[false_blk] != -1 {
                        off := g.block_offsets[false_blk]
                        rel := (off - (g.macho.text_data.len - g.curr_offset)) / 4
                        g.emit(asm_b(rel))
                    } else {
                        g.record_pending_label(false_blk)
                        g.emit(asm_b(0))
                    }

                    // Patch CBNZ to jump here (true path)
                    true_path_off := g.macho.text_data.len - g.curr_offset
                    cbnz_rel := (true_path_off - cbnz_off) / 4
                    cbnz_abs := g.curr_offset + cbnz_off
                    g.write_u32(cbnz_abs, asm_cbnz(Reg(8), cbnz_rel))

                    // True path: emit phi copies, then fall through to true_blk (next block)
                    g.emit_phi_copies(true_blk)
                } else {
                    // Standard structure:
                    //   CBZ x8, false_path
                    //   <true phi copies>
                    //   B true_blk
                    //   false_path:
                    //   <false phi copies>
                    //   B false_blk (or fall-through)
                    cbz_off := g.macho.text_data.len - g.curr_offset
                    g.emit(asm_cbz(Reg(8), 0)) // placeholder, will patch

                    // True path: emit phi copies then branch to true block
                    g.emit_phi_copies(true_blk)
                    if true_blk >= 0 && true_blk < g.block_offsets.len
                        && g.block_offsets[true_blk] != -1 {
                        off := g.block_offsets[true_blk]
                        rel := (off - (g.macho.text_data.len - g.curr_offset)) / 4
                        g.emit(asm_b(rel))
                    } else {
                        g.record_pending_label(true_blk)
                        g.emit(asm_b(0))
                    }

                    // Patch CBZ to jump here (false path)
                    false_path_off := g.macho.text_data.len - g.curr_offset
                    cbz_rel := (false_path_off - cbz_off) / 4
                    cbz_abs := g.curr_offset + cbz_off
                    g.write_u32(cbz_abs, asm_cbz(Reg(8), cbz_rel))

                    // False path: emit phi copies then branch to false block
                    g.emit_phi_copies(false_blk)
                    if false_blk != g.next_blk {
                        if false_blk >= 0 && false_blk < g.block_offsets.len
                            && g.block_offsets[false_blk] != -1 {
                            off := g.block_offsets[false_blk]
                            rel := (off - (g.macho.text_data.len - g.curr_offset)) / 4
                            g.emit(asm_b(rel))
                        } else {
                            g.record_pending_label(false_blk)
                            g.emit(asm_b(0))
                        }
                    }
                }
            } else {
                // No phi nodes — use efficient branch pattern.
                // Optimize: if true_blk is next (fall-through), just CBZ to false_blk.
                if true_blk == g.next_blk {
                    // Condition true → fall through to next block.
                    // Condition false → branch to false_blk.
                    if false_blk != g.next_blk {
                        if false_blk >= 0 && false_blk < g.block_offsets.len
                            && g.block_offsets[false_blk] != -1 {
                            off := g.block_offsets[false_blk]
                            rel := (off - (g.macho.text_data.len - g.curr_offset)) / 4
                            if rel >= -262144 && rel < 262144 {
                                g.emit(asm_cbz(Reg(8), rel))
                            } else {
                                g.emit(asm_cbnz(Reg(8), 2))
                                g.emit(asm_b(rel - 1))
                            }
                        } else {
                            g.record_pending_label(false_blk)
                            g.emit(asm_cbz(Reg(8), 0))
                        }
                    }
                    // else: both true and false are next block — no branch needed
                } else {
                    if true_blk >= 0 && true_blk < g.block_offsets.len
                        && g.block_offsets[true_blk] != -1 {
                        off := g.block_offsets[true_blk]
                        rel := (off - (g.macho.text_data.len - g.curr_offset)) / 4
                        if rel >= -262144 && rel < 262144 {
                            g.emit(asm_cbnz(Reg(8), rel))
                        } else {
                            // Branch target too far for CBNZ (19-bit range).
                            // Use trampoline: CBZ skip; B target; skip:
                            g.emit(asm_cbz(Reg(8), 2)) // skip over next B instruction
                            g.emit(asm_b(rel - 1)) // adjust for the extra CBZ instruction
                        }
                    } else {
                        // Forward reference — check if false_blk is next (common pattern).
                        // If so, use CBNZ directly to true_blk (1 instruction).
                        if false_blk == g.next_blk {
                            g.record_pending_label(true_blk)
                            g.emit(asm_cbnz(Reg(8), 0))
                        } else {
                            // Neither block is next: use trampoline pattern.
                            // CBZ x8, skip; B true_target; skip:
                            g.emit(asm_cbz(Reg(8), 2)) // skip over next B instruction
                            g.record_pending_label(true_blk)
                            g.emit(asm_b(0))
                        }
                    }

                    if false_blk != g.next_blk {
                        if false_blk >= 0 && false_blk < g.block_offsets.len
                            && g.block_offsets[false_blk] != -1 {
                            off := g.block_offsets[false_blk]
                            rel := (off - (g.macho.text_data.len - g.curr_offset)) / 4
                            g.emit(asm_b(rel))
                        } else {
                            g.record_pending_label(false_blk)
                            g.emit(asm_b(0))
                        }
                    }
                }
            }
        }
        .switch_ {
            g.load_val_to_reg(8, instr.operands[0]) // Cond -> x8

            // Iterate cases: pairs of (val, blk) starting at index 2
            for i := 2; i < instr.operands.len; i += 2 {
                // We need val in a register. x9.
                g.load_val_to_reg(9, instr.operands[i])
                g.emit(asm_cmp_reg(Reg(8), Reg(9)))

                // b.eq target
                target_blk_val := instr.operands[i + 1]
                target_blk_idx := g.block_id_from_value(target_blk_val)

                if target_blk_idx >= 0 && target_blk_idx < g.block_offsets.len
                    && g.block_offsets[target_blk_idx] != -1 {
                    off := g.block_offsets[target_blk_idx]
                    rel := (off - (g.macho.text_data.len - g.curr_offset)) / 4
                    if rel >= -262144 && rel < 262144 {
                        g.emit(asm_b_cond(cond_eq, rel))
                    } else {
                        // Trampoline: b.ne skip; B target; skip:
                        g.emit(asm_b_cond(cond_ne, 2)) // skip over next B
                        g.emit(asm_b(rel - 1))
                    }
                } else {
                    // Forward reference: use trampoline for safety
                    g.emit(asm_b_cond(cond_ne, 2)) // skip over next B
                    g.record_pending_label(target_blk_idx)
                    g.emit(asm_b(0))
                }
            }

            // Default (Unconditional Branch)
            def_blk_val := instr.operands[1]
            def_idx := g.block_id_from_value(def_blk_val)
            g.emit_phi_copies(def_idx)
            if def_idx >= 0 && def_idx < g.block_offsets.len && g.block_offsets[def_idx] != -1 {
                off := g.block_offsets[def_idx]
                rel := (off - (g.macho.text_data.len - g.curr_offset)) / 4
                g.emit(asm_b(rel))
            } else {
                g.record_pending_label(def_idx)
                g.emit(asm_b(0))
            }
        }
        .trunc, .zext {
            if instr.operands.len > 0 {
                // Check if this is a float-to-float conversion
                src_val := g.mod.values[instr.operands[0]]
                src_is_float := src_val.typ > 0 && src_val.typ < g.mod.type_store.types.len
                    && g.mod.type_store.types[src_val.typ].kind == .float_t
                dst_is_float := g.mod.values[val_id].typ > 0
                    && g.mod.values[val_id].typ < g.mod.type_store.types.len
                    && g.mod.type_store.types[g.mod.values[val_id].typ].kind == .float_t
                if src_is_float && dst_is_float {
                    dest_reg := g.get_dest_reg(val_id)
                    if instr.op == .trunc {
                        // f64 → f32: load f64 into d0, convert to s0, move bits to int reg
                        g.load_float_operand(instr.operands[0], 0)
                        g.emit(asm_fcvt_s_d(0, 0))
                        g.emit(asm_fmov_w_s(Reg(dest_reg), 0))
                    } else {
                        // f32 → f64: load_float_operand already widens f32→f64
                        g.load_float_operand(instr.operands[0], 0)
                        g.emit(asm_fmov_x_d(Reg(dest_reg), 0))
                    }
                    g.store_reg_to_val(dest_reg, val_id)
                } else {
                    // Integer conversions: just copy (registers are 64-bit)
                    g.load_val_to_reg(8, instr.operands[0])
                    g.store_reg_to_val(8, val_id)
                }
            }
        }
        .bitcast, .sext {
            // For arm64: all registers are 64-bit, so integer type conversions
            // are mostly just copies. Sign extension would matter for 8/16 bit
            // values but we operate on full 64-bit registers throughout.
            if instr.operands.len > 0 {
                mut src_id := instr.operands[0]
                // Keep sumtype wrapper semantics: if the source is an unwrapped payload
                // derived from an existing wrapper, copy the wrapper value instead of
                // reinterpreting payload struct bytes as `{_tag,_data}`.
                if val_id > 0 && val_id < g.mod.values.len {
                    dest_typ_id := g.mod.values[val_id].typ
                    if g.is_sumtype_wrapper_struct_type(dest_typ_id) {
                        if wrapper_id := g.sumtype_wrapper_source_from_unwrapped_value(src_id,
                            dest_typ_id, 0)
                        {
                            src_id = wrapper_id
                        }
                    }
                }
                trace_bitcast := g.env_trace_bitcast.len > 0
                    && (g.env_trace_bitcast == '*' || g.cur_func_name == g.env_trace_bitcast)
                if trace_bitcast {
                    mut src_kind := ssa.TypeKind.void_t
                    mut src_size := 0
                    mut dest_kind := ssa.TypeKind.void_t
                    mut dest_size := 0
                    mut src_name := ''
                    if src_id > 0 && src_id < g.mod.values.len {
                        src_val_dbg := g.mod.values[src_id]
                        src_name = src_val_dbg.name
                        if src_val_dbg.typ > 0 && src_val_dbg.typ < g.mod.type_store.types.len {
                            src_kind = g.mod.type_store.types[src_val_dbg.typ].kind
                            src_size = g.type_size(src_val_dbg.typ)
                        }
                    }
                    if val_id > 0 && val_id < g.mod.values.len {
                        dst_typ_id := g.mod.values[val_id].typ
                        if dst_typ_id > 0 && dst_typ_id < g.mod.type_store.types.len {
                            dest_kind = g.mod.type_store.types[dst_typ_id].kind
                            dest_size = g.type_size(dst_typ_id)
                        }
                    }
                    eprintln('ARM64 BITCAST fn=${g.cur_func_name} val=${val_id} src=${src_id} sname=`${src_name}` skind=${src_kind} ssz=${src_size} dkind=${dest_kind} dsz=${dest_size} src_off=${g.stack_map[src_id]} dst_off=${g.stack_map[val_id]}')
                }
                mut copied_aggregate := false
                if val_id > 0 && val_id < g.mod.values.len {
                    dest_typ_id := g.mod.values[val_id].typ
                    if dest_typ_id > 0 && dest_typ_id < g.mod.type_store.types.len {
                        dest_typ := g.mod.type_store.types[dest_typ_id]
                        dest_size := g.type_size(dest_typ_id)
                        if dest_typ.kind in [.struct_t, .array_t] && dest_size > 8 {
                            if dest_off := g.stack_map[val_id] {
                                mut src_ptr_reg := 11
                                mut can_copy := false
                                mut src_is_null_ptr := false
                                mut src_copy_uses_pointee := false
                                src_is_ptr_carried :=
                                    g.large_aggregate_stack_value_is_pointer(src_id)
                                if src_id > 0 && src_id < g.mod.values.len {
                                    src_typ_id := g.mod.values[src_id].typ
                                    if src_typ_id > 0 && src_typ_id < g.mod.type_store.types.len {
                                        src_typ := g.mod.type_store.types[src_typ_id]
                                        if src_typ.kind == .ptr_t && src_typ.elem_type > 0
                                            && src_typ.elem_type < g.mod.type_store.types.len {
                                            src_elem_size := g.type_size(src_typ.elem_type)
                                            mut can_reinterpret_ptr :=
                                                src_typ.elem_type == dest_typ_id
                                                || src_elem_size == dest_size
                                            // Sumtype wrappers must never reinterpret same-size,
                                            // different pointee structs as wrapper bytes.
                                            if can_reinterpret_ptr
                                                && g.is_sumtype_wrapper_struct_type(dest_typ_id)
                                                && src_typ.elem_type != dest_typ_id {
                                                can_reinterpret_ptr = false
                                            }
                                            if can_reinterpret_ptr
                                                && g.is_sumtype_wrapper_struct_type(dest_typ_id)
                                                && g.scalar_value_is_pointer_payload(src_id, 0) {
                                                can_reinterpret_ptr = false
                                            }
                                            if can_reinterpret_ptr {
                                                src_is_null_ptr =
                                                    g.is_effective_null_pointer_value(src_id)
                                                if src_id in g.reg_map {
                                                    src_ptr_reg = g.reg_map[src_id]
                                                } else if src_off := g.stack_map[src_id] {
                                                    g.emit_ldr_reg_offset(src_ptr_reg, 29, src_off)
                                                } else {
                                                    g.load_val_to_reg(src_ptr_reg, src_id)
                                                }
                                                can_copy = true
                                                src_copy_uses_pointee = true
                                            }
                                        }
                                    }
                                }
                                if !can_copy {
                                    if src_off := g.stack_map[src_id] {
                                        if src_is_ptr_carried {
                                            // Source slot carries an address to aggregate payload.
                                            g.emit_ldr_reg_offset(src_ptr_reg, 29, src_off)
                                        } else {
                                            // For bitcasted aggregate values, reinterpret bytes from
                                            // the source value storage. Pointer-typed sources are
                                            // handled above; non-pointer sources must copy inline
                                            // bytes from their stack slot, not dereference slot data.
                                            g.emit_add_fp_imm(src_ptr_reg, src_off)
                                        }
                                        can_copy = true
                                    } else if src_id in g.reg_map {
                                        if src_is_ptr_carried {
                                            src_ptr_reg = g.reg_map[src_id]
                                            can_copy = true
                                        }
                                    } else if src_id > 0 && src_id < g.mod.values.len {
                                        src_is_null_ptr = g.is_effective_null_pointer_value(src_id)
                                        g.load_address_of_val_to_reg(src_ptr_reg, src_id)
                                        can_copy = true
                                    }
                                }
                                if can_copy {
                                    mut src_size := if src_copy_uses_pointee {
                                        // Pointer source was accepted as by-value aggregate address.
                                        // Size must follow the pointee layout.
                                        if src_id > 0 && src_id < g.mod.values.len {
                                            src_typ_id := g.mod.values[src_id].typ
                                            if src_typ_id > 0
                                                && src_typ_id < g.mod.type_store.types.len {
                                                src_typ := g.mod.type_store.types[src_typ_id]
                                                if src_typ.kind == .ptr_t && src_typ.elem_type > 0
                                                    && src_typ.elem_type < g.mod.type_store.types.len {
                                                    g.type_size(src_typ.elem_type)
                                                } else {
                                                    g.type_size(g.mod.values[src_id].typ)
                                                }
                                            } else {
                                                0
                                            }
                                        } else {
                                            0
                                        }
                                    } else {
                                        // Copying from source value storage: use source storage size,
                                        // not pointer pointee size, to avoid over-reading adjacent slots.
                                        g.aggregate_source_size_bytes(src_id)
                                    }
                                    copy_size := if src_size > 0 && src_size < dest_size {
                                        src_size
                                    } else {
                                        dest_size
                                    }
                                    if src_is_null_ptr {
                                        g.zero_fp_bytes(dest_off, dest_size)
                                    } else {
                                        g.copy_ptr_to_fp_bytes(src_ptr_reg, dest_off, copy_size)
                                        if copy_size < dest_size {
                                            g.zero_fp_bytes(dest_off + copy_size,
                                                dest_size - copy_size)
                                        }
                                    }
                                    copied_aggregate = true
                                }
                            }
                        }
                    }
                }
                if !copied_aggregate {
                    g.load_val_to_reg(8, src_id)
                    g.store_reg_to_val(8, val_id)
                }
            }
        }
        .phi {
            // Phi nodes are handled by elim_phi_nodes inserting assignments in predecessors.
            // We just need to ensure the slot exists (handled in gen_func loop).
        }
        .assign {
            // assign dest_id, src_id
            // Used for Phi elimination: store src into dest's slot
            dest_id := instr.operands[0]
            mut src_id := instr.operands[1]
            trace_assign := g.env_trace_assign.len > 0
                && (g.env_trace_assign == '*' || g.cur_func_name == g.env_trace_assign)
            mut handled_aggregate_copy := false
            if dest_id > 0 && dest_id < g.mod.values.len {
                dest_typ_id := g.mod.values[dest_id].typ
                if dest_typ_id > 0 && dest_typ_id < g.mod.type_store.types.len {
                    dest_typ := g.mod.type_store.types[dest_typ_id]
                    dest_size := g.type_size(dest_typ_id)
                    if g.is_sumtype_wrapper_struct_type(dest_typ_id) {
                        if wrapper_id := g.sumtype_wrapper_source_from_unwrapped_value(src_id,
                            dest_typ_id, 0)
                        {
                            src_id = wrapper_id
                        }
                    }
                    if trace_assign {
                        mut src_kind := ssa.TypeKind.void_t
                        mut src_size := 0
                        mut src_op_dbg := 'na'
                        mut src_name_dbg := ''
                        mut src_has_off_dbg := false
                        mut src_off_dbg := 0
                        mut dest_has_off_dbg := false
                        mut dest_off_dbg := 0
                        if src_id > 0 && src_id < g.mod.values.len {
                            src_typ_id := g.mod.values[src_id].typ
                            if src_typ_id > 0 && src_typ_id < g.mod.type_store.types.len {
                                src_kind = g.mod.type_store.types[src_typ_id].kind
                                src_size = g.type_size(src_typ_id)
                            }
                            src_val := g.mod.values[src_id]
                            src_name_dbg = src_val.name
                            if src_val.kind == .instruction {
                                src_op_dbg = '${g.selected_opcode(g.mod.instrs[src_val.index])}'
                            } else {
                                src_op_dbg = '${src_val.kind}'
                            }
                        }
                        if src_off := g.stack_map[src_id] {
                            src_has_off_dbg = true
                            src_off_dbg = src_off
                        }
                        if dest_off := g.stack_map[dest_id] {
                            dest_has_off_dbg = true
                            dest_off_dbg = dest_off
                        }
                        eprintln('ARM64 ASSIGN fn=${g.cur_func_name} dest=${dest_id} dtyp=${dest_typ_id} dkind=${dest_typ.kind} dsz=${dest_size} dest_has_off=${dest_has_off_dbg} dest_off=${dest_off_dbg} src=${src_id} sop=${src_op_dbg} sname=`${src_name_dbg}` skind=${src_kind} ssz=${src_size} src_has_off=${src_has_off_dbg} src_off=${src_off_dbg}')
                    }
                    if dest_typ.kind in [.struct_t, .array_t] && dest_size > 8 {
                        if dest_off := g.stack_map[dest_id] {
                            // Use x12 as source pointer: emit_str_reg_offset can clobber x11.
                            mut src_ptr_reg := 12
                            mut can_copy := false
                            mut src_is_null_ptr := false
                            mut src_copy_uses_pointee := false
                            src_is_ptr_carried := g.large_aggregate_stack_value_is_pointer(src_id)
                            if src_id > 0 && src_id < g.mod.values.len {
                                src_typ_id := g.mod.values[src_id].typ
                                if src_typ_id > 0 && src_typ_id < g.mod.type_store.types.len {
                                    src_typ := g.mod.type_store.types[src_typ_id]
                                    // Aggregate sources in registers/slots are often address-typed
                                    // (including bitcasted pointers). Treat pointer sources as
                                    // source addresses for by-value struct copies.
                                    if src_typ.kind == .ptr_t {
                                        mut can_use_ptr_source := true
                                        // For sumtype wrappers, only copy from pointer sources
                                        // when the pointee type exactly matches the wrapper type.
                                        if g.is_sumtype_wrapper_struct_type(dest_typ_id)
                                            && src_typ.elem_type != dest_typ_id {
                                            can_use_ptr_source = false
                                        }
                                        if can_use_ptr_source {
                                            if g.is_sumtype_wrapper_struct_type(dest_typ_id)
                                                && g.scalar_value_is_pointer_payload(src_id, 0) {
                                                can_use_ptr_source = false
                                            }
                                        }
                                        if can_use_ptr_source {
                                            src_is_null_ptr =
                                                g.is_effective_null_pointer_value(src_id)
                                            if src_id in g.reg_map {
                                                src_ptr_reg = g.reg_map[src_id]
                                            } else if src_off := g.stack_map[src_id] {
                                                g.emit_ldr_reg_offset(src_ptr_reg, 29, src_off)
                                            } else {
                                                g.load_val_to_reg(src_ptr_reg, src_id)
                                            }
                                            can_copy = true
                                            src_copy_uses_pointee = true
                                        }
                                    }
                                }
                            }
                            if !can_copy {
                                if src_off := g.stack_map[src_id] {
                                    // Materialize string_literal values before reading from their stack slot.
                                    if src_id > 0 && src_id < g.mod.values.len
                                        && g.mod.values[src_id].kind == .string_literal
                                        && src_id !in g.string_literal_offsets {
                                        g.load_val_to_reg(src_ptr_reg, src_id)
                                    }
                                    if src_is_ptr_carried {
                                        // Source slot carries an address to aggregate payload.
                                        g.emit_ldr_reg_offset(src_ptr_reg, 29, src_off)
                                    } else {
                                        // Pointer-typed sources are handled above.
                                        // Non-pointer aggregate assigns should copy bytes from
                                        // the source value stack slot directly.
                                        g.emit_add_fp_imm(src_ptr_reg, src_off)
                                    }
                                    can_copy = true
                                } else if src_id in g.reg_map {
                                    if src_is_ptr_carried {
                                        src_ptr_reg = g.reg_map[src_id]
                                        can_copy = true
                                    }
                                } else if src_id > 0 && src_id < g.mod.values.len {
                                    // Keep aggregate-by-value semantics for non-stack sources
                                    // (e.g. globals, arguments, and address-carried values).
                                    src_is_null_ptr = g.is_effective_null_pointer_value(src_id)
                                    g.load_address_of_val_to_reg(src_ptr_reg, src_id)
                                    can_copy = true
                                }
                            }
                            if can_copy {
                                mut src_sz := if src_copy_uses_pointee {
                                    // Pointer source was accepted as by-value aggregate address.
                                    if src_id > 0 && src_id < g.mod.values.len {
                                        src_typ_id := g.mod.values[src_id].typ
                                        if src_typ_id > 0 && src_typ_id < g.mod.type_store.types.len {
                                            src_typ := g.mod.type_store.types[src_typ_id]
                                            if src_typ.kind == .ptr_t && src_typ.elem_type > 0
                                                && src_typ.elem_type < g.mod.type_store.types.len {
                                                g.type_size(src_typ.elem_type)
                                            } else {
                                                g.type_size(g.mod.values[src_id].typ)
                                            }
                                        } else {
                                            0
                                        }
                                    } else {
                                        0
                                    }
                                } else {
                                    // Copying from source value storage: do not use pointer pointee
                                    // size here, otherwise we over-read stale neighbouring slots.
                                    g.aggregate_source_size_bytes(src_id)
                                }
                                copy_size := if src_sz > 0 && src_sz < dest_size {
                                    src_sz
                                } else {
                                    dest_size
                                }
                                if src_is_null_ptr {
                                    g.zero_fp_bytes(dest_off, dest_size)
                                } else {
                                    g.copy_ptr_to_fp_bytes(src_ptr_reg, dest_off, copy_size)
                                    if copy_size < dest_size {
                                        g.zero_fp_bytes(dest_off + copy_size, dest_size - copy_size)
                                    }
                                }
                                handled_aggregate_copy = true
                            }
                        }
                    }
                }
            }
            if !handled_aggregate_copy {
                // For multi-word struct destinations with constant sources (undef/0),
                // zero-fill all chunks instead of storing a single register.
                if dest_id > 0 && dest_id < g.mod.values.len {
                    d_typ_id := g.mod.values[dest_id].typ
                    if d_typ_id > 0 && d_typ_id < g.mod.type_store.types.len {
                        d_sz := g.type_size(d_typ_id)
                        if d_sz > 8 {
                            is_const_src := src_id > 0 && src_id < g.mod.values.len
                                && g.mod.values[src_id].kind == .constant
                            if is_const_src {
                                if d_off := g.stack_map[dest_id] {
                                    g.zero_fp_bytes(d_off, d_sz)
                                    handled_aggregate_copy = true
                                }
                            }
                        }
                    }
                }
            }
            if !handled_aggregate_copy {
                g.load_val_to_reg(8, src_id)
                g.store_reg_to_val(8, dest_id)
            }
        }
        .unreachable {
            // Emit UDF #0 instruction (undefined trap)
            g.emit(asm_udf())
        }
        .inline_string_init {
            // Create string struct by value: { str, len, is_lit }
            // operands: [str_ptr, len, is_lit]
            // This instruction creates a string struct on the stack
            // The result is a pointer to the struct
            str_ptr_id := instr.operands[0]
            len_id := instr.operands[1]
            is_lit_id := instr.operands[2]

            // stack_map[val_id] points to the 8-byte pointer slot.
            // The string payload data lives right above it (at +8).
            base_offset := g.stack_map[val_id]
            struct_offset := base_offset + 8
            str_off, _ := g.struct_field_offset_and_size(instr.typ, 0, 0, 8)
            len_off, len_size := g.struct_field_offset_and_size(instr.typ, 1, 8, 8)
            is_lit_off, is_lit_size := g.struct_field_offset_and_size(instr.typ, 2, 16, 8)

            // Store str field
            g.load_val_to_reg(8, str_ptr_id)
            g.emit_str_reg_offset_sized(8, 29, struct_offset + str_off, 8)

            // Store len field
            g.load_val_to_reg(9, len_id)
            g.emit_str_reg_offset_sized(9, 29, struct_offset + len_off, len_size)

            // Store is_lit field
            g.load_val_to_reg(10, is_lit_id)
            g.emit_str_reg_offset_sized(10, 29, struct_offset + is_lit_off, is_lit_size)

            // Return pointer to struct (stored at base_offset, separate from struct data)
            g.emit_add_fp_imm(8, struct_offset) // x8 = fp + struct_offset
            g.store_reg_to_val(8, val_id)
        }
        .extractvalue {
            // Extract element from tuple/struct
            // operands: [tuple_val, index]
            tuple_id := instr.operands[0]
            idx_val := g.mod.values[instr.operands[1]]
            idx := int(parse_const_int_literal(idx_val.name))
            trace_extract := g.env_trace_extract.len > 0
                && (g.env_trace_extract == '*' || g.cur_func_name == g.env_trace_extract)
            tuple_val := g.mod.values[tuple_id]
            mut tuple_is_agg_typ := false
            mut tuple_is_large_agg := false
            mut field_byte_off := idx * 8
            mut field_elem_size := 8
            mut scalar_load_agg_src_ptr_id := 0
            mut scalar_load_agg_ptr_elem_typ_id := ssa.TypeID(0)
            mut scalar_load_agg_needs_slot_deref := false
            if tuple_val.typ > 0 && tuple_val.typ < g.mod.type_store.types.len {
                tuple_typ := g.mod.type_store.types[tuple_val.typ]
                tuple_is_agg_typ = tuple_typ.kind in [.struct_t, .array_t]
                tuple_is_large_agg = g.type_size(tuple_val.typ) > 16
                    && tuple_typ.kind in [.struct_t, .array_t]
                if tuple_typ.kind == .struct_t && idx >= 0 {
                    field_byte_off = g.struct_field_offset_bytes(tuple_val.typ, idx)
                    if idx < tuple_typ.fields.len {
                        field_elem_size = g.type_size(tuple_typ.fields[idx])
                        if field_elem_size <= 0 {
                            field_elem_size = 8
                        }
                    }
                }
            } else {
                // typ out of range — use default field_byte_off and field_elem_size
            }
            // Some lowered aggregate loads are scalar-typed in SSA (e.g. pointer-width
            // temporaries). Recover the aggregate element type from the load pointer so
            // field offsets/sizes stay correct for mixed-size structs like `map`.
            if !tuple_is_agg_typ && tuple_val.kind == .instruction {
                tuple_ins0 := g.mod.instrs[tuple_val.index]
                if g.selected_opcode(tuple_ins0) == .load && tuple_ins0.operands.len > 0 {
                    load_ptr_id := tuple_ins0.operands[0]
                    if load_ptr_id > 0 && load_ptr_id < g.mod.values.len {
                        load_ptr_val := g.mod.values[load_ptr_id]
                        if load_ptr_val.typ > 0 && load_ptr_val.typ < g.mod.type_store.types.len {
                            load_ptr_typ := g.mod.type_store.types[load_ptr_val.typ]
                            if load_ptr_typ.kind == .ptr_t && load_ptr_typ.elem_type > 0
                                && load_ptr_typ.elem_type < g.mod.type_store.types.len {
                                load_elem_typ := g.mod.type_store.types[load_ptr_typ.elem_type]
                                if load_elem_typ.kind in [.struct_t, .array_t] {
                                    scalar_load_agg_src_ptr_id = load_ptr_id
                                    scalar_load_agg_ptr_elem_typ_id = load_ptr_typ.elem_type
                                    tuple_is_agg_typ = true
                                    tuple_is_large_agg = g.type_size(load_ptr_typ.elem_type) > 16
                                    if load_elem_typ.kind == .struct_t && idx >= 0 {
                                        field_byte_off =
                                            g.struct_field_offset_bytes(load_ptr_typ.elem_type, idx)
                                        if idx < load_elem_typ.fields.len {
                                            field_elem_size = g.type_size(load_elem_typ.fields[idx])
                                            if field_elem_size <= 0 {
                                                field_elem_size = 8
                                            }
                                        }
                                    }
                                    if load_ptr_val.kind == .instruction {
                                        load_ptr_instr := g.mod.instrs[load_ptr_val.index]
                                        if g.selected_opcode(load_ptr_instr) == .alloca
                                            && g.alloca_slot_stores_pointer_like_values(load_ptr_id, load_ptr_typ.elem_type) {
                                            scalar_load_agg_needs_slot_deref = true
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            mut result_is_agg := false
            mut result_size := 0
            if instr.typ > 0 && instr.typ < g.mod.type_store.types.len {
                result_typ := g.mod.type_store.types[instr.typ]
                result_size = g.type_size(instr.typ)
                result_is_agg = result_typ.kind in [.struct_t, .array_t]
            }
            mut direct_load_agg_src_ptr_id := 0
            mut direct_load_agg_needs_slot_deref := false
            if tuple_is_agg_typ && tuple_val.kind == .instruction {
                tuple_ins := g.mod.instrs[tuple_val.index]
                if g.selected_opcode(tuple_ins) == .load && tuple_ins.operands.len > 0 {
                    load_ptr_id := tuple_ins.operands[0]
                    if load_ptr_id > 0 && load_ptr_id < g.mod.values.len {
                        direct_load_agg_src_ptr_id = load_ptr_id
                        load_ptr_val := g.mod.values[load_ptr_id]
                        if load_ptr_val.kind == .instruction {
                            load_ptr_instr := g.mod.instrs[load_ptr_val.index]
                            if g.selected_opcode(load_ptr_instr) == .alloca
                                && g.alloca_slot_stores_pointer_like_values(load_ptr_id, tuple_val.typ) {
                                direct_load_agg_needs_slot_deref = true
                            }
                        }
                    }
                }
            }
            if trace_extract {
                eprintln('ARM64 EXTRACT fn=${g.cur_func_name} val=${val_id} tuple=${tuple_id} tuple_kind=${tuple_val.kind} tuple_name=`${tuple_val.name}` tuple_typ=${tuple_val.typ} idx=${idx} field_off=${field_byte_off} field_size=${field_elem_size} result_typ=${instr.typ} result_size=${result_size} tuple_agg=${tuple_is_agg_typ} tuple_large=${tuple_is_large_agg} scalar_ptr=${scalar_load_agg_src_ptr_id} scalar_elem_typ=${scalar_load_agg_ptr_elem_typ_id} needs_slot_deref=${scalar_load_agg_needs_slot_deref} tuple_off=${g.stack_map[tuple_id]}')
            }
            mut handled_direct_load_agg_extract := false
            if direct_load_agg_src_ptr_id > 0 {
                base_ptr_reg := g.get_operand_reg(direct_load_agg_src_ptr_id, 9)
                mut agg_ptr_reg := base_ptr_reg
                if direct_load_agg_needs_slot_deref {
                    agg_ptr_reg = if base_ptr_reg == 11 { 12 } else { 11 }
                    g.emit(asm_ldr(Reg(agg_ptr_reg), Reg(base_ptr_reg)))
                }
                if result_is_agg && result_size > 8 {
                    if dst_offset := g.stack_map[val_id] {
                        if g.is_effective_null_pointer_value(direct_load_agg_src_ptr_id) {
                            g.zero_fp_bytes(dst_offset, result_size)
                        } else {
                            g.copy_ptr_offset_to_fp_bytes(agg_ptr_reg, field_byte_off, dst_offset,
                                result_size)
                        }
                        handled_direct_load_agg_extract = true
                    }
                } else {
                    if g.is_effective_null_pointer_value(direct_load_agg_src_ptr_id) {
                        g.emit_mov_reg(8, 31)
                    } else if field_elem_size in [1, 2, 4] {
                        mut field_addr_reg := 9
                        if field_addr_reg == agg_ptr_reg {
                            field_addr_reg = 10
                        }
                        if field_byte_off >= 0 && field_byte_off <= 0xFFF {
                            g.emit(asm_add_imm(Reg(field_addr_reg), Reg(agg_ptr_reg),
                                u32(field_byte_off)))
                        } else {
                            g.emit_mov_imm64(field_addr_reg, field_byte_off)
                            g.emit(asm_add_reg(Reg(field_addr_reg), Reg(agg_ptr_reg),
                                Reg(field_addr_reg)))
                        }
                        field_is_unsigned := if instr.typ > 0
                            && instr.typ < g.mod.type_store.types.len {
                            g.mod.type_store.types[instr.typ].is_unsigned
                        } else {
                            false
                        }
                        match field_elem_size {
                            1 {
                                g.emit(asm_ldr_b(Reg(8), Reg(field_addr_reg)))
                            }
                            2 {
                                g.emit(asm_ldr_h(Reg(8), Reg(field_addr_reg)))
                            }
                            4 {
                                if field_is_unsigned {
                                    g.emit(asm_ldr_w(Reg(8), Reg(field_addr_reg)))
                                } else {
                                    g.emit(asm_ldrsw(Reg(8), Reg(field_addr_reg)))
                                }
                            }
                            else {}
                        }
                    } else {
                        g.emit_ldr_reg_offset(8, agg_ptr_reg, field_byte_off)
                    }
                    g.store_reg_to_val(8, val_id)
                    handled_direct_load_agg_extract = true
                }
            }
            mut handled_scalar_load_struct_extract := false
            if !handled_direct_load_agg_extract && scalar_load_agg_src_ptr_id > 0
                && scalar_load_agg_ptr_elem_typ_id > 0 {
                base_ptr_reg := g.get_operand_reg(scalar_load_agg_src_ptr_id, 9)
                mut agg_ptr_reg := base_ptr_reg
                if scalar_load_agg_needs_slot_deref {
                    agg_ptr_reg = if base_ptr_reg == 11 { 12 } else { 11 }
                    g.emit(asm_ldr(Reg(agg_ptr_reg), Reg(base_ptr_reg)))
                }
                if result_is_agg && result_size > 8 {
                    if dst_offset := g.stack_map[val_id] {
                        if g.is_effective_null_pointer_value(scalar_load_agg_src_ptr_id) {
                            g.zero_fp_bytes(dst_offset, result_size)
                        } else {
                            g.copy_ptr_offset_to_fp_bytes(agg_ptr_reg, field_byte_off, dst_offset,
                                result_size)
                        }
                        handled_scalar_load_struct_extract = true
                    }
                } else {
                    if g.is_effective_null_pointer_value(scalar_load_agg_src_ptr_id) {
                        g.emit_mov_reg(8, 31)
                    } else if field_elem_size in [1, 2, 4] {
                        mut field_addr_reg := 9
                        if field_addr_reg == agg_ptr_reg {
                            field_addr_reg = 10
                        }
                        if field_byte_off >= 0 && field_byte_off <= 0xFFF {
                            g.emit(asm_add_imm(Reg(field_addr_reg), Reg(agg_ptr_reg),
                                u32(field_byte_off)))
                        } else {
                            g.emit_mov_imm64(field_addr_reg, field_byte_off)
                            g.emit(asm_add_reg(Reg(field_addr_reg), Reg(agg_ptr_reg),
                                Reg(field_addr_reg)))
                        }
                        field_is_unsigned := if instr.typ > 0
                            && instr.typ < g.mod.type_store.types.len {
                            g.mod.type_store.types[instr.typ].is_unsigned
                        } else {
                            false
                        }
                        match field_elem_size {
                            1 {
                                g.emit(asm_ldr_b(Reg(8), Reg(field_addr_reg)))
                            }
                            2 {
                                g.emit(asm_ldr_h(Reg(8), Reg(field_addr_reg)))
                            }
                            4 {
                                if field_is_unsigned {
                                    g.emit(asm_ldr_w(Reg(8), Reg(field_addr_reg)))
                                } else {
                                    g.emit(asm_ldrsw(Reg(8), Reg(field_addr_reg)))
                                }
                            }
                            else {}
                        }
                    } else {
                        g.emit_ldr_reg_offset(8, agg_ptr_reg, field_byte_off)
                    }
                    g.store_reg_to_val(8, val_id)
                    handled_scalar_load_struct_extract = true
                }
            }
            mut handled_scalar_load_agg_extract := false
            // Some lowered paths represent aggregate loads through scalar-typed
            // temporaries (typically pointer-sized). If extractvalue asks for a
            // multi-word aggregate from such a temporary, read directly from the
            // original load pointer instead of interpreting scalar spill bytes.
            if !handled_direct_load_agg_extract && result_is_agg && result_size > 8
                && !tuple_is_agg_typ && tuple_val.kind == .instruction {
                tuple_ins := g.mod.instrs[tuple_val.index]
                if tuple_ins.op == .load && tuple_ins.operands.len > 0 {
                    load_src_id := tuple_ins.operands[0]
                    mut scalar_load_is_ptr_payload := false
                    if load_src_id > 0 && load_src_id < g.mod.values.len {
                        load_src_val := g.mod.values[load_src_id]
                        if load_src_val.kind == .instruction {
                            load_src_instr := g.mod.instrs[load_src_val.index]
                            if g.selected_opcode(load_src_instr) == .alloca
                                && g.alloca_slot_stores_pointer_like_values(load_src_id, instr.typ) {
                                scalar_load_is_ptr_payload = true
                            }
                        }
                    }
                    if scalar_load_is_ptr_payload {
                        // The scalar load result carries a pointer payload stored in an
                        // alloca-backed slot. Extract aggregate bytes from that pointer.
                        src_ptr_id := tuple_id
                        if dst_offset := g.stack_map[val_id] {
                            if g.is_effective_null_pointer_value(src_ptr_id) {
                                g.zero_fp_bytes(dst_offset, result_size)
                            } else {
                                src_ptr_reg := g.get_operand_reg(src_ptr_id, 9)
                                g.copy_ptr_offset_to_fp_bytes(src_ptr_reg, field_byte_off,
                                    dst_offset, result_size)
                            }
                            handled_scalar_load_agg_extract = true
                        }
                    }
                }
            }
            mut handled_sumtype_tag_payload_extract := false
            // Some malformed MIR paths unwrap sumtype wrappers through `_tag` first, then
            // request a pointer/aggregate extract from that scalar word. Recover by reading
            // from the wrapper `_data` pointer directly.
            if !handled_direct_load_agg_extract && !handled_scalar_load_struct_extract
                && !handled_scalar_load_agg_extract && !tuple_is_agg_typ
                && tuple_val.kind == .instruction && instr.typ > 0
                && instr.typ < g.mod.type_store.types.len {
                dst_typ := g.mod.type_store.types[instr.typ]
                if (result_is_agg && result_size > 8) || dst_typ.kind == .ptr_t {
                    if wrapper_id := g.sumtype_wrapper_source_from_tag_word(tuple_id) {
                        if g.load_sumtype_data_ptr_to_reg(9, wrapper_id) {
                            if result_is_agg && result_size > 8 {
                                if dst_offset := g.stack_map[val_id] {
                                    g.copy_ptr_offset_to_fp_bytes(9, field_byte_off, dst_offset,
                                        result_size)
                                    handled_sumtype_tag_payload_extract = true
                                }
                            } else if dst_typ.kind == .ptr_t {
                                if field_byte_off == 0 {
                                    g.emit_mov_reg(8, 9)
                                } else if field_byte_off >= 0 && field_byte_off <= 0xFFF {
                                    g.emit(asm_add_imm(Reg(8), Reg(9), u32(field_byte_off)))
                                } else {
                                    g.emit_mov_imm64(8, field_byte_off)
                                    g.emit(asm_add_reg(Reg(8), Reg(9), Reg(8)))
                                }
                                g.store_reg_to_val(8, val_id)
                                handled_sumtype_tag_payload_extract = true
                            }
                        }
                    }
                }
            }
            if !handled_direct_load_agg_extract && !handled_scalar_load_struct_extract
                && !handled_scalar_load_agg_extract && !handled_sumtype_tag_payload_extract {
                // If the tuple source is a string_literal (e.g. after mem2reg
                // promotion of alloca → store → load), ensure the string struct
                // has been materialized on the stack before we read from it.
                if tuple_val.kind == .string_literal {
                    if _ := g.string_literal_offsets[tuple_id] {
                        // already materialized
                    } else {
                        // Force materialization by loading into a scratch register.
                        g.load_val_to_reg(10, tuple_id)
                    }
                }
                mut handled_scalar_payload_extract := false
                if !tuple_is_agg_typ && g.scalar_value_is_pointer_payload(tuple_id, 0) {
                    base_ptr_reg := g.get_operand_reg(tuple_id, 9)
                    if result_is_agg && result_size > 8 {
                        if dst_offset := g.stack_map[val_id] {
                            if g.is_effective_null_pointer_value(tuple_id) {
                                g.zero_fp_bytes(dst_offset, result_size)
                            } else {
                                g.copy_ptr_offset_to_fp_bytes(base_ptr_reg, field_byte_off,
                                    dst_offset, result_size)
                            }
                            handled_scalar_payload_extract = true
                        }
                    } else if instr.typ > 0 && instr.typ < g.mod.type_store.types.len
                        && g.mod.type_store.types[instr.typ].kind == .ptr_t {
                        if g.is_effective_null_pointer_value(tuple_id) {
                            g.emit_mov_reg(8, 31)
                        } else if field_byte_off == 0 {
                            if base_ptr_reg != 8 {
                                g.emit_mov_reg(8, base_ptr_reg)
                            }
                        } else if field_byte_off >= 0 && field_byte_off <= 0xFFF {
                            g.emit(asm_add_imm(Reg(8), Reg(base_ptr_reg), u32(field_byte_off)))
                        } else {
                            g.emit_mov_imm64(8, field_byte_off)
                            g.emit(asm_add_reg(Reg(8), Reg(base_ptr_reg), Reg(8)))
                        }
                        g.store_reg_to_val(8, val_id)
                        handled_scalar_payload_extract = true
                    } else {
                        if g.is_effective_null_pointer_value(tuple_id) {
                            g.emit_mov_reg(8, 31)
                        } else {
                            load_size := if result_size in [1, 2, 4, 8] {
                                result_size
                            } else {
                                8
                            }
                            mut field_addr_reg := 9
                            if field_addr_reg == base_ptr_reg {
                                field_addr_reg = 10
                            }
                            if field_byte_off == 0 {
                                if field_addr_reg != base_ptr_reg {
                                    g.emit_mov_reg(field_addr_reg, base_ptr_reg)
                                }
                            } else if field_byte_off >= 0 && field_byte_off <= 0xFFF {
                                g.emit(asm_add_imm(Reg(field_addr_reg), Reg(base_ptr_reg),
                                    u32(field_byte_off)))
                            } else {
                                g.emit_mov_imm64(field_addr_reg, field_byte_off)
                                g.emit(asm_add_reg(Reg(field_addr_reg), Reg(base_ptr_reg),
                                    Reg(field_addr_reg)))
                            }
                            match load_size {
                                1 {
                                    g.emit(asm_ldr_b(Reg(8), Reg(field_addr_reg)))
                                }
                                2 {
                                    g.emit(asm_ldr_h(Reg(8), Reg(field_addr_reg)))
                                }
                                4 {
                                    field_is_unsigned := if instr.typ > 0
                                        && instr.typ < g.mod.type_store.types.len {
                                        g.mod.type_store.types[instr.typ].is_unsigned
                                    } else {
                                        false
                                    }
                                    if field_is_unsigned {
                                        g.emit(asm_ldr_w(Reg(8), Reg(field_addr_reg)))
                                    } else {
                                        g.emit(asm_ldrsw(Reg(8), Reg(field_addr_reg)))
                                    }
                                }
                                else {
                                    g.emit(asm_ldr(Reg(8), Reg(field_addr_reg)))
                                }
                            }
                        }
                        g.store_reg_to_val(8, val_id)
                        handled_scalar_payload_extract = true
                    }
                }
                mut direct_global_load_ptr_id := -1
                if !handled_scalar_payload_extract && idx == 0 && tuple_val.kind == .instruction {
                    tuple_ins := g.mod.instrs[tuple_val.index]
                    if tuple_ins.op == .load && tuple_ins.operands.len > 0 && instr.typ > 0
                        && instr.typ < g.mod.type_store.types.len {
                        src_ptr_id := tuple_ins.operands[0]
                        if src_ptr_id > 0 && src_ptr_id < g.mod.values.len
                            && g.mod.values[src_ptr_id].kind == .global {
                            src_is_aggregate := tuple_val.typ > 0
                                && tuple_val.typ < g.mod.type_store.types.len
                                && g.mod.type_store.types[tuple_val.typ].kind in [.struct_t, .array_t]
                            dst_typ := g.mod.type_store.types[instr.typ]
                            if !src_is_aggregate && dst_typ.kind in [.struct_t, .array_t] {
                                direct_global_load_ptr_id = src_ptr_id
                            }
                        }
                    }
                }

                // Get tuple's stack location and load from offset
                if handled_scalar_payload_extract {
                    // handled above
                } else if direct_global_load_ptr_id > 0 {
                    src_reg := g.get_operand_reg(direct_global_load_ptr_id, 9)
                    dst_size := g.type_size(instr.typ)
                    if dst_size > 8 {
                        if dst_offset := g.stack_map[val_id] {
                            num_words := (dst_size + 7) / 8
                            for w in 0 .. num_words {
                                g.emit_ldr_reg_offset(8, src_reg, w * 8)
                                g.emit_str_reg_offset(8, 29, dst_offset + w * 8)
                            }
                        } else {
                            if src_reg != 8 {
                                g.emit_mov_reg(8, src_reg)
                            }
                            g.store_reg_to_val(8, val_id)
                        }
                    } else {
                        load_size := if dst_size in [1, 2, 4, 8] { dst_size } else { 8 }
                        match load_size {
                            1 { g.emit(asm_ldr_b(Reg(8), Reg(src_reg))) }
                            2 { g.emit(asm_ldr_h(Reg(8), Reg(src_reg))) }
                            4 { g.emit(asm_ldr_w(Reg(8), Reg(src_reg))) }
                            else { g.emit_ldr_reg_offset(8, src_reg, 0) }
                        }

                        g.store_reg_to_val(8, val_id)
                    }
                } else if tuple_offset := g.stack_map[tuple_id] {
                    mut handled_wrapper_payload_extract := false
                    if tuple_val.typ > 0 && tuple_val.typ < g.mod.type_store.types.len {
                        tuple_typ2 := g.mod.type_store.types[tuple_val.typ]
                        // Sumtype wrappers encode payload pointers in `_data`.
                        // `extractvalue` with indices beyond wrapper fields means
                        // "read from payload pointer", not "read past wrapper bytes".
                        if tuple_typ2.kind == .struct_t && tuple_typ2.field_names.len == 2
                            && tuple_typ2.field_names[0] == '_tag'
                            && tuple_typ2.field_names[1] == '_data' && idx >= tuple_typ2.fields.len {
                            data_off := g.struct_field_offset_bytes(tuple_val.typ, 1)
                            g.emit_ldr_reg_offset(9, 29, tuple_offset + data_off)
                            payload_field_idx := idx - tuple_typ2.fields.len
                            payload_off := payload_field_idx * 8
                            if result_is_agg && result_size > 8 {
                                if dst_offset := g.stack_map[val_id] {
                                    g.copy_ptr_offset_to_fp_bytes(9, payload_off, dst_offset,
                                        result_size)
                                    handled_wrapper_payload_extract = true
                                }
                            } else if instr.typ > 0 && instr.typ < g.mod.type_store.types.len
                                && g.mod.type_store.types[instr.typ].kind == .ptr_t {
                                if payload_off == 0 {
                                    g.emit_mov_reg(8, 9)
                                } else if payload_off >= 0 && payload_off <= 0xFFF {
                                    g.emit(asm_add_imm(Reg(8), Reg(9), u32(payload_off)))
                                } else {
                                    g.emit_mov_imm64(8, payload_off)
                                    g.emit(asm_add_reg(Reg(8), Reg(9), Reg(8)))
                                }
                                g.store_reg_to_val(8, val_id)
                                handled_wrapper_payload_extract = true
                            } else {
                                load_size := if result_size in [1, 2, 4, 8] {
                                    result_size
                                } else {
                                    8
                                }
                                if payload_off == 0 {
                                    g.emit_mov_reg(10, 9)
                                } else if payload_off >= 0 && payload_off <= 0xFFF {
                                    g.emit(asm_add_imm(Reg(10), Reg(9), u32(payload_off)))
                                } else {
                                    g.emit_mov_imm64(10, payload_off)
                                    g.emit(asm_add_reg(Reg(10), Reg(9), Reg(10)))
                                }
                                match load_size {
                                    1 {
                                        g.emit(asm_ldr_b(Reg(8), Reg(10)))
                                    }
                                    2 {
                                        g.emit(asm_ldr_h(Reg(8), Reg(10)))
                                    }
                                    4 {
                                        field_is_unsigned := if instr.typ > 0
                                            && instr.typ < g.mod.type_store.types.len {
                                            g.mod.type_store.types[instr.typ].is_unsigned
                                        } else {
                                            false
                                        }
                                        if field_is_unsigned {
                                            g.emit(asm_ldr_w(Reg(8), Reg(10)))
                                        } else {
                                            g.emit(asm_ldrsw(Reg(8), Reg(10)))
                                        }
                                    }
                                    else {
                                        g.emit(asm_ldr(Reg(8), Reg(10)))
                                    }
                                }

                                g.store_reg_to_val(8, val_id)
                                handled_wrapper_payload_extract = true
                            }
                        }
                    }
                    if handled_wrapper_payload_extract {
                        // handled above
                    } else if tuple_is_large_agg && idx >= 0
                        && g.large_aggregate_stack_value_is_pointer(tuple_id) {
                        g.emit_ldr_reg_offset(9, 29, tuple_offset)
                        if field_elem_size > 8 {
                            // Multi-word struct field: copy all words from pointer
                            if dst_offset := g.stack_map[val_id] {
                                num_words := (field_elem_size + 7) / 8
                                for w in 0 .. num_words {
                                    g.emit_ldr_reg_offset(8, 9, field_byte_off + w * 8)
                                    g.emit_str_reg_offset(8, 29, dst_offset + w * 8)
                                }
                            } else {
                                g.emit_ldr_reg_offset(8, 9, field_byte_off)
                                g.store_reg_to_val(8, val_id)
                            }
                        } else {
                            g.emit_ldr_reg_offset(8, 9, field_byte_off)
                            g.store_reg_to_val(8, val_id)
                        }
                    } else if field_elem_size > 8 {
                        // Multi-word struct field stored inline: copy all words
                        if trace_extract && ((tuple_val.typ == 140 && instr.typ == 10)
                            || (tuple_val.typ == 143 && instr.typ == 123)) {
                            eprintln('ARM64 EXTRACT PATH inline tuple=${tuple_id} val=${val_id} src=${
                                tuple_offset + field_byte_off} dst=${g.stack_map[val_id]} field_off=${field_byte_off}')
                        }
                        if dst_offset := g.stack_map[val_id] {
                            src_offset := tuple_offset + field_byte_off
                            num_words := (field_elem_size + 7) / 8
                            for w in 0 .. num_words {
                                g.emit_ldr_reg_offset(8, 29, src_offset + w * 8)
                                g.emit_str_reg_offset(8, 29, dst_offset + w * 8)
                            }
                        } else {
                            field_offset := tuple_offset + field_byte_off
                            g.emit_ldr_reg_offset(8, 29, field_offset)
                            g.store_reg_to_val(8, val_id)
                        }
                    } else if field_elem_size in [1, 2, 4] {
                        // Use sized load to avoid reading adjacent packed fields.
                        // For signed integer fields, use sign-extending loads.
                        field_offset := tuple_offset + field_byte_off
                        g.emit_add_fp_imm(9, field_offset)
                        field_is_unsigned := if instr.typ > 0
                            && instr.typ < g.mod.type_store.types.len {
                            g.mod.type_store.types[instr.typ].is_unsigned
                        } else {
                            false
                        }
                        match field_elem_size {
                            1 {
                                g.emit(asm_ldr_b(Reg(8), Reg(9)))
                            }
                            2 {
                                g.emit(asm_ldr_h(Reg(8), Reg(9)))
                            }
                            4 {
                                if field_is_unsigned {
                                    g.emit(asm_ldr_w(Reg(8), Reg(9)))
                                } else {
                                    g.emit(asm_ldrsw(Reg(8), Reg(9)))
                                }
                            }
                            else {}
                        }

                        g.store_reg_to_val(8, val_id)
                    } else {
                        field_offset := tuple_offset + field_byte_off
                        g.emit_ldr_reg_offset(8, 29, field_offset)
                        g.store_reg_to_val(8, val_id)
                    }
                } else if tuple_id in g.reg_map {
                    reg := g.reg_map[tuple_id]
                    // Large aggregates in registers are represented by their address.
                    if tuple_is_large_agg && idx >= 0 {
                        if field_elem_size > 8 {
                            // Multi-word struct field: copy all words from address
                            if dst_offset := g.stack_map[val_id] {
                                num_words := (field_elem_size + 7) / 8
                                for w in 0 .. num_words {
                                    g.emit_ldr_reg_offset(8, reg, field_byte_off + w * 8)
                                    g.emit_str_reg_offset(8, 29, dst_offset + w * 8)
                                }
                            } else {
                                g.emit_ldr_reg_offset(8, reg, field_byte_off)
                                g.store_reg_to_val(8, val_id)
                            }
                        } else {
                            g.emit_ldr_reg_offset(8, reg, field_byte_off)
                            g.store_reg_to_val(8, val_id)
                        }
                    } else if idx == 0 {
                        // Tuple is in a register (e.g., scalarized first field).
                        if reg != 8 {
                            g.emit_mov_reg(8, reg)
                        }
                        // Mask to field width for sub-8-byte fields packed in register.
                        if field_elem_size in [1, 2, 4] {
                            g.emit(asm_ubfx_lower(Reg(8), Reg(8), u32(field_elem_size * 8)))
                        }
                        g.store_reg_to_val(8, val_id)
                    } else {
                        // Higher indices packed in same register — shift then mask.
                        g.load_val_to_reg(8, tuple_id)
                        if field_byte_off > 0 && field_byte_off < 8 {
                            g.emit(asm_lsr_imm(Reg(8), Reg(8), u32(field_byte_off * 8)))
                        }
                        if field_elem_size in [1, 2, 4] {
                            g.emit(asm_ubfx_lower(Reg(8), Reg(8), u32(field_elem_size * 8)))
                        }
                        g.store_reg_to_val(8, val_id)
                    }
                } else {
                    // Tuple not in stack_map or reg_map - fallback
                    g.load_val_to_reg(8, tuple_id)
                    g.store_reg_to_val(8, val_id)
                }
            }
        }
        .struct_init {
            // Create struct from field values: operands are field values in order
            result_offset := g.stack_map[val_id]
            struct_typ := g.mod.type_store.types[instr.typ]
            struct_size := g.type_size(instr.typ)
            trace_struct_init := g.env_trace_struct_init.len > 0
                && (g.env_trace_struct_init == '*' || g.cur_func_name == g.env_trace_struct_init)
            if trace_struct_init {
                mut op_dbg := []string{}
                for field_id in instr.operands {
                    if field_id > 0 && field_id < g.mod.values.len {
                        fv := g.mod.values[field_id]
                        op_dbg << '${field_id}:${fv.kind}:${fv.typ}:`${fv.name}`'
                    } else {
                        op_dbg << '${field_id}:invalid:0:` `'
                    }
                }
                eprintln('ARM64 STRUCT_INIT fn=${g.cur_func_name} val=${val_id} typ=${instr.typ} size=${struct_size} ops=${op_dbg}')
            }
            zero_size := if struct_size > 0 { struct_size } else { 8 }

            // Zero-initialize the entire struct first
            g.emit_add_fp_imm(9, result_offset)
            g.emit_mov_reg(10, 31) // xzr
            mut off := 0
            for off + 8 <= zero_size {
                g.emit_str_reg_offset_sized(10, 9, off, 8)
                off += 8
            }
            if off + 4 <= zero_size {
                g.emit_str_reg_offset_sized(10, 9, off, 4)
                off += 4
            }
            if off + 2 <= zero_size {
                g.emit_str_reg_offset_sized(10, 9, off, 2)
                off += 2
            }
            if off < zero_size {
                g.emit_str_reg_offset_sized(10, 9, off, 1)
            }

            // Store each field value at its proper offset
            for fi, field_id in instr.operands {
                mut field_off := fi * 8
                if struct_typ.kind == .struct_t && fi >= 0 && fi < struct_typ.fields.len {
                    field_off = g.struct_field_offset_bytes(instr.typ, fi)
                }

                mut field_typ_id := ssa.TypeID(0)
                if struct_typ.kind == .struct_t && fi >= 0 && fi < struct_typ.fields.len {
                    field_typ_id = struct_typ.fields[fi]
                } else if field_id > 0 && field_id < g.mod.values.len {
                    field_typ_id = g.mod.values[field_id].typ
                }
                mut field_size := if field_typ_id > 0 { g.type_size(field_typ_id) } else { 8 }
                if field_size <= 0 {
                    field_size = 8
                }
                if trace_struct_init {
                    eprintln('ARM64 STRUCT_INIT FIELD fn=${g.cur_func_name} val=${val_id} fi=${fi} foff=${field_off} fsz=${field_size} ftyp=${field_typ_id} src=${field_id}')
                }

                // Skip zero constants (already zeroed above)
                field_val := g.mod.values[field_id]
                if field_val.kind == .constant && field_val.name == '0' {
                    continue
                }

                if field_size <= 8 {
                    g.load_val_to_reg(8, field_id)
                    store_off := result_offset + field_off
                    if field_size in [1, 2, 4] {
                        g.emit_add_fp_imm(9, store_off)
                        match field_size {
                            1 { g.emit(asm_str_b(Reg(8), Reg(9))) }
                            2 { g.emit(asm_str_h(Reg(8), Reg(9))) }
                            4 { g.emit(asm_str_w(Reg(8), Reg(9))) }
                            else {}
                        }
                    } else {
                        g.emit_str_reg_offset(8, 29, store_off)
                    }
                } else {
                    // Multi-word field (nested struct)
                    // Ensure string_literal values are materialized before reading from stack
                    if field_val.kind == .string_literal {
                        if _ := g.string_literal_offsets[field_id] {
                            // already materialized
                        } else {
                            // Force materialization by loading into a scratch register
                            g.load_val_to_reg(10, field_id)
                        }
                    }
                    field_chunks := (field_size + 7) / 8
                    src_typ_id := if field_id > 0 && field_id < g.mod.values.len {
                        g.mod.values[field_id].typ
                    } else {
                        ssa.TypeID(0)
                    }
                    mut src_ptr_matches_field := false
                    mut src_size := if src_typ_id > 0 { g.type_size(src_typ_id) } else { 0 }
                    if src_typ_id > 0 && src_typ_id < g.mod.type_store.types.len {
                        src_typ := g.mod.type_store.types[src_typ_id]
                        if src_typ.kind == .ptr_t && src_typ.elem_type > 0
                            && src_typ.elem_type < g.mod.type_store.types.len {
                            // Pointer-typed field sources are valid by-value aggregates only when
                            // pointee type matches the destination field type exactly.
                            if src_typ.elem_type == field_typ_id {
                                if g.is_sumtype_wrapper_struct_type(field_typ_id)
                                    && g.scalar_value_is_pointer_payload(field_id, 0) {
                                    src_ptr_matches_field = false
                                } else {
                                    src_ptr_matches_field = true
                                }
                                src_size = g.type_size(src_typ.elem_type)
                            }
                        }
                    }
                    src_chunks := if src_size > 0 { (src_size + 7) / 8 } else { 0 }
                    src_is_ptr_carried := g.large_aggregate_stack_value_is_pointer(field_id)
                    trace_agg_copy := g.env_trace_agg_copy.len > 0
                        && (g.env_trace_agg_copy == '*' || g.cur_func_name == g.env_trace_agg_copy)
                    if trace_agg_copy && src_typ_id > 0 && src_typ_id < g.mod.type_store.types.len {
                        src_typ := g.mod.type_store.types[src_typ_id]
                        if src_typ.kind == .ptr_t {
                            eprintln('ARM64 AGG struct_init fn=${g.cur_func_name} field=${fi} fsz=${field_size} src=${field_id} src_typ=${src_typ_id} src_sz=${src_size} chunks=${src_chunks}')
                        }
                    }
                    copy_chunks := if src_chunks > 0 && src_chunks < field_chunks {
                        src_chunks
                    } else {
                        field_chunks
                    }
                    mut copied_field := false

                    // Size-mismatched scalar sources (e.g. from unresolved wraps) must not
                    // be treated as aggregate addresses.
                    if src_size > 0 && src_size <= 8 {
                        g.load_val_to_reg(8, field_id)
                        g.emit_str_reg_offset(8, 29, result_offset + field_off)
                        copied_field = true
                    } else if field_offset := g.stack_map[field_id] {
                        mut src_ptr_reg := 12
                        if src_ptr_matches_field || src_is_ptr_carried {
                            g.emit_ldr_reg_offset(src_ptr_reg, 29, field_offset)
                        } else {
                            g.emit_add_fp_imm(src_ptr_reg, field_offset)
                        }
                        for w in 0 .. copy_chunks {
                            g.emit(asm_ldr_imm(Reg(10), Reg(src_ptr_reg), u32(w)))
                            g.emit_str_reg_offset(10, 29, result_offset + field_off + w * 8)
                        }
                        copied_field = true
                    } else if field_id in g.reg_map {
                        field_reg := g.reg_map[field_id]
                        if src_ptr_matches_field || src_is_ptr_carried {
                            for w in 0 .. copy_chunks {
                                g.emit(asm_ldr_imm(Reg(10), Reg(field_reg), u32(w)))
                                g.emit_str_reg_offset(10, 29, result_offset + field_off + w * 8)
                            }
                            copied_field = true
                        }
                    }
                    if !copied_field && g.is_sumtype_wrapper_struct_type(field_typ_id) {
                        // Some MIR paths carry small wrapper structs (like `types.Type`)
                        // through scalar-typed values. Recover the wrapper address and
                        // copy the full bytes instead of falling back to a single-word store.
                        mut src_ptr_reg := 12
                        g.load_struct_src_address_to_reg(src_ptr_reg, field_id, field_typ_id, 0)
                        for w in 0 .. field_chunks {
                            g.emit(asm_ldr_imm(Reg(10), Reg(src_ptr_reg), u32(w)))
                            g.emit_str_reg_offset(10, 29, result_offset + field_off + w * 8)
                        }
                        copied_field = true
                    }

                    if !copied_field {
                        // Deterministic fallback when aggregate backing storage is unavailable.
                        g.load_val_to_reg(8, field_id)
                        g.emit_str_reg_offset(8, 29, result_offset + field_off)
                        copied_field = true
                        // Ensure upper words are initialized; otherwise stale stack bytes
                        // can leak into small struct fields (e.g. sumtype wrappers).
                        if field_chunks > 1 {
                            g.emit_mov_reg(10, 31)
                            for w in 1 .. field_chunks {
                                g.emit_str_reg_offset(10, 29, result_offset + field_off + w * 8)
                            }
                        }
                    }
                    if copied_field && copy_chunks < field_chunks {
                        g.emit_mov_reg(10, 31)
                        for w in copy_chunks .. field_chunks {
                            g.emit_str_reg_offset(10, 29, result_offset + field_off + w * 8)
                        }
                    }
                }
            }
        }
        .insertvalue {
            // Insert element into tuple/struct
            // operands: [tuple_val, elem_val, index]
            tuple_id := instr.operands[0]
            elem_id := instr.operands[1]
            idx_val := g.mod.values[instr.operands[2]]
            idx := int(parse_const_int_literal(idx_val.name))
            trace_insert := g.env_trace_insert.len > 0
                && (g.env_trace_insert == '*' || g.cur_func_name == g.env_trace_insert)

            // Get result's stack location
            result_offset := g.stack_map[val_id]
            tuple_typ := g.mod.type_store.types[instr.typ]
            tuple_size := g.type_size(instr.typ)
            num_chunks := if tuple_size > 0 { (tuple_size + 7) / 8 } else { 1 }
            mut elem_off := idx * 8
            if tuple_typ.kind == .struct_t && idx >= 0 && idx < tuple_typ.fields.len {
                elem_off = g.struct_field_offset_bytes(instr.typ, idx)
            }
            if trace_insert {
                tuple_val_dbg := g.mod.values[tuple_id]
                elem_val_dbg := g.mod.values[elem_id]
                eprintln('ARM64 INSERT fn=${g.cur_func_name} val=${val_id} typ=${instr.typ} size=${tuple_size} idx=${idx} elem_off=${elem_off} tuple=${tuple_id}:${tuple_val_dbg.kind}:${tuple_val_dbg.typ} elem=${elem_id}:${elem_val_dbg.kind}:${elem_val_dbg.typ} roff=${result_offset} toff=${g.stack_map[tuple_id]} eoff=${g.stack_map[elem_id]}')
            }

            // Copy existing tuple data if not undef.
            tuple_val := g.mod.values[tuple_id]
            if !(tuple_val.kind == .constant && tuple_val.name == 'undef') {
                mut copied_tuple := false
                if tuple_offset := g.stack_map[tuple_id] {
                    if tuple_size > 16 && g.large_aggregate_stack_value_is_pointer(tuple_id) {
                        // Keep source pointer in x12 so stores can use x11 scratch safely.
                        g.emit_ldr_reg_offset(12, 29, tuple_offset)
                        for i in 0 .. num_chunks {
                            g.emit_ldr_reg_offset(9, 12, i * 8)
                            g.emit_str_reg_offset(9, 29, result_offset + i * 8)
                        }
                    } else {
                        for i in 0 .. num_chunks {
                            g.emit_ldr_reg_offset(9, 29, tuple_offset + i * 8)
                            g.emit_str_reg_offset(9, 29, result_offset + i * 8)
                        }
                    }
                    copied_tuple = true
                } else if tuple_id in g.reg_map {
                    tuple_reg := g.reg_map[tuple_id]
                    for i in 0 .. num_chunks {
                        g.emit(asm_ldr_imm(Reg(9), Reg(tuple_reg), u32(i)))
                        g.emit_str_reg_offset(9, 29, result_offset + i * 8)
                    }
                    copied_tuple = true
                }
                if !copied_tuple {
                    // Deterministic fallback for missing aggregate backing bytes.
                    g.emit_mov_reg(9, 31)
                    for i in 0 .. num_chunks {
                        g.emit_str_reg_offset(9, 29, result_offset + i * 8)
                    }
                }
            } else {
                // Start from zeroed storage for `insertvalue(undef, ...)`.
                g.emit_mov_reg(9, 31)
                for i in 0 .. num_chunks {
                    g.emit_str_reg_offset(9, 29, result_offset + i * 8)
                }
            }

            // Store the new element at the specified index. Aggregate fields need
            // full-width copies, not a single 8-byte store.
            mut elem_typ_id := ssa.TypeID(0)
            if tuple_typ.kind == .struct_t && idx >= 0 && idx < tuple_typ.fields.len {
                elem_typ_id = tuple_typ.fields[idx]
            } else if elem_id > 0 && elem_id < g.mod.values.len {
                elem_typ_id = g.mod.values[elem_id].typ
            }
            mut elem_size := if elem_typ_id > 0 { g.type_size(elem_typ_id) } else { 8 }
            if elem_size <= 0 {
                elem_size = 8
            }
            if elem_size <= 8 {
                g.load_val_to_reg(8, elem_id)
                store_off := result_offset + elem_off
                if elem_size in [1, 2, 4] {
                    g.emit_add_fp_imm(9, store_off)
                    match elem_size {
                        1 { g.emit(asm_str_b(Reg(8), Reg(9))) }
                        2 { g.emit(asm_str_h(Reg(8), Reg(9))) }
                        4 { g.emit(asm_str_w(Reg(8), Reg(9))) }
                        else {}
                    }
                } else {
                    g.emit_str_reg_offset(8, 29, store_off)
                }
            } else {
                elem_chunks := (elem_size + 7) / 8
                src_typ_id := if elem_id > 0 && elem_id < g.mod.values.len {
                    g.mod.values[elem_id].typ
                } else {
                    ssa.TypeID(0)
                }
                mut src_ptr_matches_elem := false
                mut src_size := if src_typ_id > 0 { g.type_size(src_typ_id) } else { 0 }
                if src_typ_id > 0 && src_typ_id < g.mod.type_store.types.len {
                    src_typ := g.mod.type_store.types[src_typ_id]
                    if src_typ.kind == .ptr_t && src_typ.elem_type > 0
                        && src_typ.elem_type < g.mod.type_store.types.len {
                        // Pointer-typed element sources can be copied by-value only for
                        // exact pointee-type matches with the destination element type.
                        if src_typ.elem_type == elem_typ_id {
                            if g.is_sumtype_wrapper_struct_type(elem_typ_id)
                                && g.scalar_value_is_pointer_payload(elem_id, 0) {
                                src_ptr_matches_elem = false
                            } else {
                                src_ptr_matches_elem = true
                            }
                            src_size = g.type_size(src_typ.elem_type)
                        }
                    }
                }
                src_chunks := if src_size > 0 { (src_size + 7) / 8 } else { 0 }
                src_is_ptr_carried := g.large_aggregate_stack_value_is_pointer(elem_id)
                trace_agg_copy := g.env_trace_agg_copy.len > 0
                    && (g.env_trace_agg_copy == '*' || g.cur_func_name == g.env_trace_agg_copy)
                if trace_agg_copy && src_typ_id > 0 && src_typ_id < g.mod.type_store.types.len {
                    src_typ := g.mod.type_store.types[src_typ_id]
                    if src_typ.kind == .ptr_t {
                        eprintln('ARM64 AGG insertvalue fn=${g.cur_func_name} idx=${idx} esz=${elem_size} src=${elem_id} src_typ=${src_typ_id} src_sz=${src_size} chunks=${src_chunks}')
                    }
                }
                copy_chunks := if src_chunks > 0 && src_chunks < elem_chunks {
                    src_chunks
                } else {
                    elem_chunks
                }
                mut copied_elem := false

                // Avoid treating scalar mismatch values as aggregate addresses.
                if src_size > 0 && src_size <= 8 {
                    g.load_val_to_reg(8, elem_id)
                    g.emit_str_reg_offset(8, 29, result_offset + elem_off)
                    copied_elem = true
                } else if elem_offset := g.stack_map[elem_id] {
                    mut src_ptr_reg := 12
                    if src_ptr_matches_elem || src_is_ptr_carried {
                        g.emit_ldr_reg_offset(src_ptr_reg, 29, elem_offset)
                    } else {
                        g.emit_add_fp_imm(src_ptr_reg, elem_offset)
                    }
                    for i in 0 .. copy_chunks {
                        g.emit(asm_ldr_imm(Reg(10), Reg(src_ptr_reg), u32(i)))
                        g.emit_str_reg_offset(10, 29, result_offset + elem_off + i * 8)
                    }
                    copied_elem = true
                } else if elem_id in g.reg_map {
                    elem_reg := g.reg_map[elem_id]
                    if src_ptr_matches_elem || src_is_ptr_carried {
                        for i in 0 .. copy_chunks {
                            g.emit(asm_ldr_imm(Reg(10), Reg(elem_reg), u32(i)))
                            g.emit_str_reg_offset(10, 29, result_offset + elem_off + i * 8)
                        }
                        copied_elem = true
                    }
                }
                if !copied_elem && g.is_sumtype_wrapper_struct_type(elem_typ_id) {
                    // Keep full wrapper bytes for small sumtype fields carried through
                    // scalar temporaries instead of truncating to the first word.
                    mut src_ptr_reg := 12
                    g.load_struct_src_address_to_reg(src_ptr_reg, elem_id, elem_typ_id, 0)
                    for i in 0 .. elem_chunks {
                        g.emit(asm_ldr_imm(Reg(10), Reg(src_ptr_reg), u32(i)))
                        g.emit_str_reg_offset(10, 29, result_offset + elem_off + i * 8)
                    }
                    copied_elem = true
                }
                if !copied_elem {
                    // Best-effort fallback: store first word when source aggregate
                    // backing storage is unavailable.
                    g.load_val_to_reg(8, elem_id)
                    g.emit_str_reg_offset(8, 29, result_offset + elem_off)
                    copied_elem = true
                    // Initialize remaining words to avoid leaking stale bytes when
                    // multi-word values are only partially materialized.
                    if elem_chunks > 1 {
                        g.emit_mov_reg(10, 31)
                        for i in 1 .. elem_chunks {
                            g.emit_str_reg_offset(10, 29, result_offset + elem_off + i * 8)
                        }
                    }
                }
                if copied_elem && copy_chunks < elem_chunks {
                    g.emit_mov_reg(10, 31)
                    for i in copy_chunks .. elem_chunks {
                        g.emit_str_reg_offset(10, 29, result_offset + elem_off + i * 8)
                    }
                }
            }
        }
        .spawn_call, .go_call {
            // ARM64 native backend does not implement OS thread spawn or goroutine
            // launch. Emit a no-op so functions that contain `spawn`/`go` (e.g.
            // sync.WaitGroup.go pulled in transitively) can still be lowered for
            // reachability without crashing the backend. These functions are never
            // invoked from v2-self-host paths.
            if val_id > 0 && val_id < g.mod.values.len {
                g.emit_mov_imm64(8, 0)
                g.store_reg_to_val(8, val_id)
            }
        }
        else {
            eprintln('arm64: unknown instruction ${int(op)} in fn ${g.cur_func_name}')
            exit(1)
        }
    }
}

fn (mut g Gen) try_emit_simple_scalar_store(instr_idx int) bool {
    if instr_idx < 0 || instr_idx >= g.mod.instrs.len {
        return false
    }
    instr := g.mod.instrs[instr_idx]
    if instr.operands.len < 2 {
        return false
    }
    src_id := instr.operands[0]
    ptr_id := instr.operands[1]
    if src_id <= 0 || src_id >= g.mod.values.len || ptr_id <= 0 || ptr_id >= g.mod.values.len {
        return false
    }
    src_typ_id := g.mod.values[src_id].typ
    if src_typ_id <= 0 || src_typ_id >= g.mod.type_store.types.len {
        return false
    }
    src_kind := g.cached_type_kind(src_typ_id)
    if src_kind in [.struct_t, .array_t] {
        return false
    }
    ptr_typ_id := g.mod.values[ptr_id].typ
    mut dst_elem_is_ptrlike := false
    if ptr_typ_id > 0 && ptr_typ_id < g.mod.type_store.types.len {
        ptr_kind := g.cached_type_kind(ptr_typ_id)
        ptr_elem := g.cached_type_elem_type(ptr_typ_id)
        if ptr_kind == .ptr_t && ptr_elem > 0 && ptr_elem < g.mod.type_store.types.len {
            elem_kind := g.cached_type_kind(ptr_elem)
            if elem_kind in [.struct_t, .array_t] {
                return false
            }
            dst_elem_is_ptrlike = elem_kind in [.ptr_t, .func_t]
        }
    }
    mut val_reg := g.get_operand_reg(src_id, 8)
    if val_reg == 9 || val_reg == 11 || val_reg == 12 {
        if val_reg != 8 {
            g.emit_mov_reg(8, val_reg)
        }
        val_reg = 8
    }
    ptr_reg := g.get_operand_reg(ptr_id, 9)
    mut store_size := g.mem_access_size_bytes(src_typ_id, ptr_id)
    if store_size < 8 && dst_elem_is_ptrlike {
        store_size = 8
    }
    if store_size < 8 && g.scalar_value_is_pointer_payload(src_id, 0) {
        store_size = 8
    }
    match store_size {
        1 { g.emit(asm_str_b(Reg(val_reg), Reg(ptr_reg))) }
        2 { g.emit(asm_str_h(Reg(val_reg), Reg(ptr_reg))) }
        4 { g.emit(asm_str_w(Reg(val_reg), Reg(ptr_reg))) }
        else { g.emit(asm_str(Reg(val_reg), Reg(ptr_reg))) }
    }

    return true
}

fn (g &Gen) cached_type_kind(typ_id ssa.TypeID) ssa.TypeKind {
    if typ_id > 0 && typ_id < g.type_kinds.len {
        return g.type_kinds[typ_id]
    }
    return .void_t
}

fn (g &Gen) cached_type_elem_type(typ_id ssa.TypeID) ssa.TypeID {
    if typ_id > 0 && typ_id < g.type_elem_types.len {
        return g.type_elem_types[typ_id]
    }
    return ssa.TypeID(0)
}

@[inline]
fn (g &Gen) selected_opcode(instr &mir.Instruction) ssa.OpCode {
    return instr.op
}

fn (g &Gen) has_function_named(name string) bool {
    return g.find_func_idx_by_name(name) >= 0
}

fn (g &Gen) get_function_by_name(name string) ?&mir.Function {
    fi := g.find_func_idx_by_name(name)
    if fi >= 0 {
        return &g.mod.funcs[fi]
    }
    return none
}

fn (g &Gen) find_func_idx_by_name(name string) int {
    if name == '' {
        return -1
    }
    for fi := 0; fi < g.func_names.len; fi++ {
        if g.func_names[fi] == name {
            return fi
        }
    }
    return -1
}

fn (g &Gen) find_global_idx_by_name(name string) int {
    if name == '' {
        return -1
    }
    for gi := 0; gi < g.mod.globals.len; gi++ {
        if g.mod.globals[gi].name == name {
            return gi
        }
    }
    return -1
}

fn (g &Gen) func_idx_from_ref_value(val_id int) int {
    if val_id >= 0 && val_id < g.func_ref_to_func_idx.len {
        return g.func_ref_to_func_idx[val_id]
    }
    return -1
}

fn (g &Gen) call_param_type(instr &mir.Instruction, arg_idx int) ?ssa.TypeID {
    if arg_idx < 0 || instr.operands.len == 0 {
        return none
    }
    fn_id := instr.operands[0]
    if fn_id <= 0 || fn_id >= g.mod.values.len {
        return none
    }
    op := g.selected_opcode(instr)
    // Direct calls should follow the declared callee signature.
    // MIR transformations can leave a drifted `fn_val.typ` on direct call targets,
    // which would otherwise misclassify aggregate arguments.
    if op in [.call, .call_sret] {
        fi := g.func_idx_from_ref_value(fn_id)
        if fi >= 0 && fi < g.func_params.len {
            params := g.func_params[fi]
            if arg_idx < params.len {
                param_id := params[arg_idx]
                if param_id > 0 && param_id < g.mod.values.len {
                    return g.mod.values[param_id].typ
                }
            }
            return none
        }
    }
    // For indirect calls (and as a fallback), use the function type attached to
    // the call target value.
    fn_val_typ := g.mod.values[fn_id].typ
    if fn_val_typ > 0 && fn_val_typ < g.mod.type_store.types.len {
        fn_typ := g.mod.type_store.types[fn_val_typ]
        if fn_typ.kind == .func_t && arg_idx < fn_typ.params.len {
            return fn_typ.params[arg_idx]
        }
    }
    return none
}

fn (g &Gen) call_result_type(instr &mir.Instruction) ?ssa.TypeID {
    op := g.selected_opcode(instr)
    if op in [.call, .call_indirect] && instr.operands.len > 0 {
        fn_id := instr.operands[0]
        if fn_id > 0 && fn_id < g.mod.values.len {
            // Keep direct calls aligned with declared function signatures first.
            fi := g.func_idx_from_ref_value(fn_id)
            if fi >= 0 && fi < g.func_typs.len {
                return g.func_typs[fi]
            }
            fn_val_typ := g.mod.values[fn_id].typ
            if fn_val_typ > 0 && fn_val_typ < g.mod.type_store.types.len {
                fn_typ := g.mod.type_store.types[fn_val_typ]
                if fn_typ.kind == .func_t && fn_typ.ret_type > 0 {
                    return fn_typ.ret_type
                }
            }
        }
    }
    if instr.typ > 0 {
        return instr.typ
    }
    return none
}

fn (g &Gen) alloca_store_value_is_pointer_like(val_id int, for_alloca_id int, depth int) bool {
    mut seen_allocas := map[int]bool{}
    return g.alloca_store_value_is_pointer_like_inner(val_id, for_alloca_id, depth, mut
        seen_allocas)
}

fn (g &Gen) value_is_pointer_compatible_zero(val_id int) bool {
    if val_id <= 0 || val_id >= g.mod.values.len {
        return false
    }
    val := g.mod.values[val_id]
    if val.kind != .constant || val.name != '0' {
        return false
    }
    if val.typ <= 0 || val.typ >= g.mod.type_store.types.len {
        return false
    }
    typ := g.mod.type_store.types[val.typ]
    return typ.kind == .ptr_t || (typ.kind == .int_t && typ.width >= 64)
}

fn (g &Gen) alloca_store_value_is_pointer_like_inner(val_id int, for_alloca_id int, depth int, mut seen_allocas map[int]bool) bool {
    if depth > 64 || val_id <= 0 || val_id >= g.mod.values.len {
        return false
    }
    val := g.mod.values[val_id]
    if val.typ > 0 && val.typ < g.mod.type_store.types.len {
        typ := g.mod.type_store.types[val.typ]
        if typ.kind in [.ptr_t, .func_t] {
            return true
        }
    }
    if val.kind == .constant {
        // A pointer-typed zero is a null pointer. A pointer-width integer zero is
        // only neutral when combined with real pointer values; by itself it is also
        // used for scalar default values passed by address.
        if val.name == '0' {
            if val.typ > 0 && val.typ < g.mod.type_store.types.len {
                ct := g.mod.type_store.types[val.typ]
                if ct.kind == .ptr_t {
                    return true
                }
            }
        }
        return false
    }
    if val.kind != .instruction {
        return false
    }
    instr := g.mod.instrs[val.index]
    op := g.selected_opcode(instr)
    match op {
        .bitcast, .zext, .sext, .trunc {
            if instr.operands.len > 0 {
                return g.alloca_store_value_is_pointer_like_inner(instr.operands[0], for_alloca_id,

                    depth + 1, mut seen_allocas)
            }
        }
        .assign {
            if instr.operands.len >= 2 {
                return g.alloca_store_value_is_pointer_like_inner(instr.operands[1], for_alloca_id,

                    depth + 1, mut seen_allocas)
            }
        }
        .phi {
            if instr.operands.len == 0 {
                return false
            }
            mut saw_pointer_like := false
            for op_id in instr.operands {
                if g.value_is_pointer_compatible_zero(op_id) {
                    continue
                }
                if !g.alloca_store_value_is_pointer_like_inner(op_id, for_alloca_id, depth + 1, mut
                    seen_allocas) {
                    return false
                }
                saw_pointer_like = true
            }
            return saw_pointer_like
        }
        .load {
            if instr.operands.len > 0 {
                ptr_id := instr.operands[0]
                if ptr_id > 0 && ptr_id < g.mod.values.len {
                    ptr_val := g.mod.values[ptr_id]
                    if ptr_val.kind == .instruction {
                        ptr_instr := g.mod.instrs[ptr_val.index]
                        if g.selected_opcode(ptr_instr) == .alloca && ptr_id != for_alloca_id {
                            if g.alloca_slot_stores_pointer_like_values_inner(ptr_id,
                                ssa.TypeID(0), depth + 1, mut seen_allocas)
                            {
                                return true
                            }
                        }
                    }
                }
            }
        }
        else {}
    }

    // Some SSA pseudo-values are mutable placeholders whose current value is
    // carried by `assign dest, src` instructions. Follow such assignments so
    // pointer payloads stored through these placeholders are detected.
    mut saw_assign_to_val := false
    for use_id in val.uses {
        if use_id <= 0 || use_id >= g.mod.values.len {
            continue
        }
        use_val := g.mod.values[use_id]
        if use_val.kind != .instruction {
            continue
        }
        use_instr := g.mod.instrs[use_val.index]
        if g.selected_opcode(use_instr) != .assign || use_instr.operands.len < 2
            || use_instr.operands[0] != val_id {
            continue
        }
        saw_assign_to_val = true
        src_id := use_instr.operands[1]
        if src_id <= 0 || src_id >= g.mod.values.len {
            return false
        }
        if !g.alloca_store_value_is_pointer_like_inner(src_id, for_alloca_id, depth + 1, mut
            seen_allocas) {
            return false
        }
    }
    if saw_assign_to_val {
        return true
    }
    return false
}

fn (mut g Gen) alloca_slot_stores_pointer_like_values(alloca_id int, param_elem_typ_id ssa.TypeID) bool {
    if cached := g.alloca_ptr_cache[alloca_id] {
        return cached == 1
    }
    mut seen_allocas := map[int]bool{}
    result := g.alloca_slot_stores_pointer_like_values_inner(alloca_id, param_elem_typ_id, 0, mut
        seen_allocas)
    g.alloca_ptr_cache[alloca_id] = if result { u8(1) } else { u8(2) }
    return result
}

fn (g &Gen) alloca_slot_stores_pointer_like_values_inner(alloca_id int, param_elem_typ_id ssa.TypeID, depth int, mut seen_allocas map[int]bool) bool {
    _ = param_elem_typ_id
    if depth > 64 {
        return false
    }
    if alloca_id in seen_allocas {
        return false
    }
    seen_allocas[alloca_id] = true
    defer {
        seen_allocas.delete(alloca_id)
    }
    if alloca_id <= 0 || alloca_id >= g.mod.values.len {
        return false
    }
    alloca_val := g.mod.values[alloca_id]
    if alloca_val.kind != .instruction {
        return false
    }
    alloca_instr := g.mod.instrs[alloca_val.index]
    if g.selected_opcode(alloca_instr) != .alloca {
        return false
    }
    mut saw_ptr_like_store := false
    mut saw_non_ptr_like_store := false
    for use_id in alloca_val.uses {
        if use_id <= 0 || use_id >= g.mod.values.len {
            continue
        }
        use_val := g.mod.values[use_id]
        if use_val.kind != .instruction {
            continue
        }
        use_instr := g.mod.instrs[use_val.index]
        if g.selected_opcode(use_instr) != .store || use_instr.operands.len < 2
            || use_instr.operands[1] != alloca_id {
            continue
        }
        src_id := use_instr.operands[0]
        if src_id <= 0 || src_id >= g.mod.values.len {
            continue
        }
        if g.value_is_pointer_compatible_zero(src_id) {
            continue
        }
        if g.alloca_store_value_is_pointer_like_inner(src_id, alloca_id, depth + 1, mut
            seen_allocas)
        {
            saw_ptr_like_store = true
        } else {
            saw_non_ptr_like_store = true
        }
    }
    return saw_ptr_like_store && !saw_non_ptr_like_store
}

fn (g &Gen) scalar_value_is_pointer_payload(val_id int, depth int) bool {
    if depth > 8 || val_id <= 0 || val_id >= g.mod.values.len {
        return false
    }
    val := g.mod.values[val_id]
    if val.typ > 0 && val.typ < g.mod.type_store.types.len {
        typ := g.mod.type_store.types[val.typ]
        if typ.kind !in [.int_t, .ptr_t] {
            return false
        }
    } else {
        return false
    }
    if val.kind != .instruction {
        return false
    }
    instr := g.mod.instrs[val.index]
    op := g.selected_opcode(instr)
    match op {
        .extractvalue {
            if instr.operands.len < 2 {
                return false
            }
            src_id := instr.operands[0]
            idx_id := instr.operands[1]
            if src_id <= 0 || src_id >= g.mod.values.len || idx_id <= 0
                || idx_id >= g.mod.values.len {
                return false
            }
            src_typ_id := g.mod.values[src_id].typ
            if src_typ_id <= 0 || src_typ_id >= g.mod.type_store.types.len {
                return false
            }
            src_typ := g.mod.type_store.types[src_typ_id]
            if src_typ.kind != .struct_t {
                return false
            }
            idx_val := g.mod.values[idx_id]
            idx := int(parse_const_int_literal(idx_val.name))
            if idx < 0 || idx >= src_typ.field_names.len {
                return false
            }
            // Sumtype payloads are extracted from `_data` scalar fields and are
            // represented as pointer-width integers in SSA.
            return src_typ.field_names[idx] == '_data'
        }
        .get_element_ptr {
            if instr.operands.len < 2 {
                return false
            }
            base_id := instr.operands[0]
            idx_id := instr.operands[1]
            if idx_id <= 0 || idx_id >= g.mod.values.len {
                return false
            }
            idx_val := g.mod.values[idx_id]
            if idx_val.kind != .constant {
                return false
            }
            idx := int(parse_const_int_literal(idx_val.name))
            if idx == 0 {
                // Preserve classification through no-op GEP hops.
                return g.scalar_value_is_pointer_payload(base_id, depth + 1)
            }
            if base_id <= 0 || base_id >= g.mod.values.len {
                return false
            }
            base_typ_id := g.mod.values[base_id].typ
            if base_typ_id <= 0 || base_typ_id >= g.mod.type_store.types.len {
                return false
            }
            base_typ := g.mod.type_store.types[base_typ_id]
            if base_typ.kind != .ptr_t || base_typ.elem_type <= 0
                || base_typ.elem_type >= g.mod.type_store.types.len {
                return false
            }
            elem_typ := g.mod.type_store.types[base_typ.elem_type]
            if elem_typ.kind != .struct_t || idx < 0 || idx >= elem_typ.field_names.len {
                return false
            }
            // GEP to sumtype wrapper `_data` field keeps pointer payload semantics.
            return elem_typ.field_names[idx] == '_data'
        }
        .load {
            // Payload pointers often flow through `load(bitcast(extractvalue(...,_data)))`.
            // Follow the source pointer to classify only those flows as payload words.
            if instr.operands.len < 1 {
                return false
            }
            return g.scalar_value_is_pointer_payload(instr.operands[0], depth + 1)
        }
        .bitcast, .assign {
            if instr.operands.len == 0 {
                return false
            }
            src_idx := if op == .assign && instr.operands.len > 1 { 1 } else { 0 }
            return g.scalar_value_is_pointer_payload(instr.operands[src_idx], depth + 1)
        }
        .phi {
            if instr.operands.len == 0 {
                return false
            }
            for op_id in instr.operands {
                if !g.scalar_value_is_pointer_payload(op_id, depth + 1) {
                    return false
                }
            }
            return true
        }
        else {}
    }

    return false
}

fn (mut g Gen) get_dest_reg(val_id int) int {
    if r := g.reg_map[val_id] {
        if r != 0xFF {
            return r
        }
    }
    return 8
}

fn (mut g Gen) get_operand_reg(val_id int, fallback int) int {
    // If value is in a callee-saved register, return it
    if r := g.reg_map[val_id] {
        if r != 0xFF {
            return r
        }
    }
    // Otherwise load it into fallback
    g.load_val_to_reg(fallback, val_id)
    return fallback
}

// Returns the number of registers a call argument occupies on ARM64.
// Struct args 9-16 bytes use 2 consecutive registers; all others use 1.
fn (mut g Gen) call_arg_reg_count(val_id int, arg_idx int, instr &mir.Instruction) int {
    is_indirect := arg_idx >= 0 && arg_idx < instr.abi_arg_class.len
        && instr.abi_arg_class[arg_idx] == .indirect
    trace_callcount := g.env_trace_callcount.len > 0
        && (g.env_trace_callcount == '*' || g.cur_func_name == g.env_trace_callcount)
    if is_indirect {
        if trace_callcount {
            eprintln('ARM64 CALLCOUNT fn=${g.cur_func_name} arg_idx=${arg_idx} val=${val_id} indirect=1 count=1')
        }
        return 1 // pointer
    }
    // Prefer the callee signature over the SSA value type when deciding
    // how many argument registers are needed. Some transformed calls carry
    // a widened/narrowed SSA value type that does not match the declared param.
    if param_typ_id := g.call_param_type(instr, arg_idx) {
        if param_typ_id > 0 && param_typ_id < g.mod.type_store.types.len {
            param_typ := g.mod.type_store.types[param_typ_id]
            if param_typ.kind == .struct_t {
                size := g.type_size(param_typ_id)
                if size > 8 && size <= 16 {
                    if trace_callcount {
                        eprintln('ARM64 CALLCOUNT fn=${g.cur_func_name} arg_idx=${arg_idx} val=${val_id} source=param typ=${param_typ_id} kind=${int(param_typ.kind)} size=${size} count=2')
                    }
                    return 2
                }
            }
        }
    }
    if val_id <= 0 || val_id >= g.mod.values.len {
        return 1
    }
    val := g.mod.values[val_id]
    if val.typ > 0 && val.typ < g.mod.type_store.types.len {
        val_typ := g.mod.type_store.types[val.typ]
        if val_typ.kind == .struct_t {
            size := g.type_size(val.typ)
            if size > 8 && size <= 16 {
                if trace_callcount {
                    eprintln('ARM64 CALLCOUNT fn=${g.cur_func_name} arg_idx=${arg_idx} val=${val_id} source=val typ=${val.typ} kind=${int(val_typ.kind)} size=${size} count=2')
                }
                return 2
            }
        }
    }
    if trace_callcount {
        mut typ_id := ssa.TypeID(0)
        mut kind := -1
        mut size := 0
        if val_id > 0 && val_id < g.mod.values.len {
            typ_id = g.mod.values[val_id].typ
            if typ_id > 0 && typ_id < g.mod.type_store.types.len {
                kind = int(g.mod.type_store.types[typ_id].kind)
                size = g.type_size(typ_id)
            }
        }
        eprintln('ARM64 CALLCOUNT fn=${g.cur_func_name} arg_idx=${arg_idx} val=${val_id} typ=${typ_id} kind=${kind} size=${size} count=1')
    }
    return 1
}

// Loads one 8-byte word of a small struct argument (9-16 bytes) into `dest_reg`.
fn (mut g Gen) load_struct_arg_word_to_reg(dest_reg int, val_id int, word_idx int, expected_struct_typ ssa.TypeID, call_callee_id int) {
    if g.is_known_zero_value(val_id, 0) {
        g.emit_mov_reg(dest_reg, 31)
        return
    }
    g.materialize_string_literal_value(val_id)
    if expected_struct_typ > 0 && val_id > 0 && val_id < g.mod.values.len
        && expected_struct_typ < g.mod.type_store.types.len {
        val := g.mod.values[val_id]
        if val.typ == expected_struct_typ {
            expected_typ := g.mod.type_store.types[expected_struct_typ]
            expected_size := g.type_size(expected_struct_typ)
            if expected_typ.kind == .struct_t && expected_size > 8 && expected_size <= 16 {
                if offset := g.stack_map[val_id] {
                    g.emit_ldr_reg_offset(dest_reg, 29, offset + word_idx * 8)
                    return
                }
            }
        }
    }
    // Get the source address of the struct value.
    // expected_struct_typ lets us correctly handle pointer-backed struct values.
    mut addr_reg := 9
    if addr_reg == dest_reg {
        addr_reg = 10
        if addr_reg == dest_reg {
            addr_reg = 11
        }
    }
    if expected_struct_typ > 0 {
        g.load_struct_src_address_to_reg(addr_reg, val_id, expected_struct_typ, call_callee_id)
    } else {
        g.load_address_of_val_to_reg(addr_reg, val_id)
    }
    g.emit(asm_ldr_imm(Reg(dest_reg), Reg(addr_reg), u32(word_idx)))
}

fn (mut g Gen) materialize_string_literal_value(val_id int) {
    if val_id <= 0 || val_id >= g.mod.values.len {
        return
    }
    if g.mod.values[val_id].kind != .string_literal {
        return
    }
    if _ := g.string_literal_offsets[val_id] {
        return
    }
    g.load_val_to_reg(12, val_id)
}

// Loads a multi-register struct argument (9-16 bytes) into consecutive regs.
fn (mut g Gen) load_struct_arg_to_regs(start_reg int, val_id int, expected_struct_typ ssa.TypeID, call_callee_id int) {
    g.load_struct_arg_word_to_reg(start_reg, val_id, 0, expected_struct_typ, call_callee_id)
    g.load_struct_arg_word_to_reg(start_reg + 1, val_id, 1, expected_struct_typ, call_callee_id)
}

fn (mut g Gen) load_call_arg_to_reg(reg int, val_id int, arg_idx int, instr &mir.Instruction) {
    is_indirect := arg_idx >= 0 && arg_idx < instr.abi_arg_class.len
        && instr.abi_arg_class[arg_idx] == .indirect
    trace_callarg := g.env_trace_callarg.len > 0
        && (g.env_trace_callarg == '*' || g.cur_func_name == g.env_trace_callarg)
    if !is_indirect {
        if param_typ_id := g.call_param_type(instr, arg_idx) {
            if param_typ_id > 0 && param_typ_id < g.mod.type_store.types.len && val_id > 0
                && val_id < g.mod.values.len {
                param_typ := g.mod.type_store.types[param_typ_id]
                arg_val := g.mod.values[val_id]
                if trace_callarg {
                    mut arg_op := 'na'
                    if arg_val.kind == .instruction {
                        arg_op = '${g.selected_opcode(g.mod.instrs[arg_val.index])}'
                    }
                    eprintln('ARM64 CALLARG fn=${g.cur_func_name} arg_idx=${arg_idx} val=${val_id} param_typ=${param_typ_id} val_typ=${arg_val.typ} val_kind=${int(arg_val.kind)} arg_op=${arg_op} indirect=${is_indirect}')
                }
                if arg_val.typ > 0 && arg_val.typ < g.mod.type_store.types.len {
                    arg_typ := g.mod.type_store.types[arg_val.typ]
                    if param_typ.kind == .ptr_t && arg_val.kind == .instruction {
                        arg_instr := g.mod.instrs[arg_val.index]
                        if g.selected_opcode(arg_instr) == .alloca && arg_typ.kind == .ptr_t {
                            slot_has_ptr := g.alloca_slot_stores_pointer_like_values(val_id,
                                param_typ.elem_type)
                            if trace_callarg {
                                eprintln('ARM64 CALLARG alloca-ptr fn=${g.cur_func_name} arg_idx=${arg_idx} val=${val_id} slot_has_ptr=${slot_has_ptr}')
                            }
                            if slot_has_ptr {
                                g.load_val_to_reg(reg, val_id)
                                g.emit(asm_ldr(Reg(reg), Reg(reg)))
                            } else {
                                g.load_address_of_val_to_reg(reg, val_id)
                            }
                            return
                        }
                    }
                    // Some pointer arguments come from alloca-backed pointer-variable slots
                    // (slot element is often i64 in MIR). For `&T` params, pass the slot
                    // contents (`*slot`) rather than the slot address.
                    if param_typ.kind == .ptr_t && param_typ.elem_type > 0
                        && param_typ.elem_type < g.mod.type_store.types.len
                        && arg_val.kind == .instruction {
                        param_elem_typ := g.mod.type_store.types[param_typ.elem_type]
                        arg_instr := g.mod.instrs[arg_val.index]
                        if param_elem_typ.kind != .ptr_t && g.selected_opcode(arg_instr) == .alloca {
                            slot_has_ptr := g.alloca_slot_stores_pointer_like_values(val_id,
                                param_typ.elem_type)
                            if trace_callarg {
                                eprintln('ARM64 CALLARG slot-check fn=${g.cur_func_name} arg_idx=${arg_idx} val=${val_id} param_typ=${param_typ_id} param_elem_typ=${param_typ.elem_type} alloca_slot_ptr=${slot_has_ptr}')
                            }
                            if slot_has_ptr {
                                g.load_val_to_reg(reg, val_id)
                                g.emit(asm_ldr(Reg(reg), Reg(reg)))
                                return
                            }
                        }
                    }
                    // Mutable locals are often represented as `alloca` pointers. When the
                    // slot stores a pointer and the callee expects that pointer type, pass
                    // the loaded pointer value (not the alloca slot address).
                    if param_typ.kind == .ptr_t && arg_val.kind == .instruction {
                        arg_instr := g.mod.instrs[arg_val.index]
                        if arg_instr.op == .alloca && arg_typ.kind == .ptr_t
                            && arg_typ.elem_type > 0
                            && arg_typ.elem_type < g.mod.type_store.types.len {
                            slot_typ := g.mod.type_store.types[arg_typ.elem_type]
                            if slot_typ.kind == .ptr_t && arg_typ.elem_type == param_typ_id {
                                g.load_val_to_reg(reg, val_id)
                                g.emit(asm_ldr(Reg(reg), Reg(reg)))
                                return
                            }
                        }
                    }
                    // Some transformed pointer locals are materialized in generic i64-sized
                    // alloca slots (slot type appears as int_t) even though stores carry
                    // `&Struct`/`&Array` values. Treat these slots as pointer containers and
                    // pass the loaded pointer value.
                    if param_typ.kind == .ptr_t && arg_val.kind == .instruction {
                        arg_instr := g.mod.instrs[arg_val.index]
                        if arg_instr.op == .alloca && arg_typ.kind == .ptr_t
                            && arg_typ.elem_type > 0
                            && arg_typ.elem_type < g.mod.type_store.types.len
                            && param_typ.elem_type > 0
                            && param_typ.elem_type < g.mod.type_store.types.len {
                            slot_elem_typ := g.mod.type_store.types[arg_typ.elem_type]
                            param_elem_typ := g.mod.type_store.types[param_typ.elem_type]
                            if slot_elem_typ.kind == .int_t && g.type_size(arg_typ.elem_type) == 8
                                && param_elem_typ.kind in [.struct_t, .array_t] {
                                g.load_val_to_reg(reg, val_id)
                                g.emit(asm_ldr(Reg(reg), Reg(reg)))
                                return
                            }
                        }
                    }
                    // Loop-carried pointer variables can be represented as pointers
                    // to pointer slots (typically from alloca-backed mutable vars).
                    // When the callee expects `&T` and we have `&&T`, pass `*arg`.
                    if param_typ.kind == .ptr_t && arg_typ.kind == .ptr_t && arg_typ.elem_type > 0
                        && arg_typ.elem_type < g.mod.type_store.types.len {
                        arg_elem_typ := g.mod.type_store.types[arg_typ.elem_type]
                        if arg_elem_typ.kind == .ptr_t
                            && arg_elem_typ.elem_type == param_typ.elem_type {
                            g.load_val_to_reg(reg, val_id)
                            g.emit(asm_ldr(Reg(reg), Reg(reg)))
                            return
                        }
                    }
                    // If call lowering asks for a pointer parameter but the argument is
                    // a struct value, pass the address of the struct instead of
                    // loading its first field. This handles call results, load results,
                    // and other struct-producing instructions.
                    // Applies to ALL struct sizes (e.g., sumtype=16 bytes, string=24 bytes).
                    if param_typ.kind == .ptr_t && arg_typ.kind == .struct_t {
                        arg_size := g.type_size(arg_val.typ)
                        if arg_size > 16 {
                            // Large aggregates are address-carried in ARM64 codegen.
                            // `load_val_to_reg` preserves whether the producer already
                            // materialized a pointer, avoiding accidental pointer-to-pointer
                            // arguments when the SSA value is stack-spilled.
                            g.load_val_to_reg(reg, val_id)
                        } else {
                            g.load_address_of_val_to_reg(reg, val_id)
                        }
                        return
                    }
                }
            }
        }
    }
    if is_indirect {
        if param_typ_id := g.call_param_type(instr, arg_idx) {
            g.load_struct_src_address_to_reg(reg, val_id, param_typ_id, instr.operands[0])
        } else {
            g.load_address_of_val_to_reg(reg, val_id)
        }
        return
    }
    g.load_val_to_reg(reg, val_id)
}

// val_is_cmp_result returns true if the value is a comparison instruction result (cset).
// Comparison results are always 0 or 1 and don't need narrow int canonicalization.
fn (g Gen) val_is_cmp_result(val_id int) bool {
    if val_id <= 0 || val_id >= g.mod.values.len {
        return false
    }
    val := g.mod.values[val_id]
    if val.kind != .instruction {
        return false
    }
    instr := g.mod.instrs[val.index]
    op := g.selected_opcode(instr)
    return op in [.eq, .ne, .lt, .gt, .le, .ge, .ult, .ugt, .ule, .uge]
}

fn (mut g Gen) canonicalize_narrow_int_result(reg int, typ_id ssa.TypeID) {
    if typ_id <= 0 || typ_id >= g.mod.type_store.types.len {
        return
    }
    typ := g.mod.type_store.types[typ_id]
    if typ.kind != .int_t || typ.width <= 0 || typ.width >= 64 {
        return
    }
    if typ.width == 1 {
        // i1 arithmetic is modulo 2; force truncation to the low bit.
        g.emit(asm_and_imm_1(Reg(reg), Reg(reg)))
    } else if typ.is_unsigned {
        // Unsigned narrow integers: zero-extend using bitmask immediate AND.
        if typ.width == 8 {
            g.emit(asm_and_imm_0xff(Reg(reg), Reg(reg)))
        } else if typ.width == 16 {
            g.emit(asm_and_imm_0xffff(Reg(reg), Reg(reg)))
        } else if typ.width == 32 {
            g.emit(asm_and_imm_0xffffffff(Reg(reg), Reg(reg)))
        } else if typ.width < 32 {
            mask := (u64(1) << typ.width) - 1
            g.emit_mov_imm64(11, i64(mask))
            g.emit(asm_and(Reg(reg), Reg(reg), Reg(11)))
        }
        // Unsigned 33-63 bit: no action needed (upper bits already zero)
    } else {
        // For signed types, sign-extend using dedicated instructions.
        if typ.width == 8 {
            g.emit(asm_sxtb(Reg(reg), Reg(reg)))
        } else if typ.width == 16 {
            g.emit(asm_sxth(Reg(reg), Reg(reg)))
        } else if typ.width == 32 {
            g.emit(asm_sxtw(Reg(reg), Reg(reg)))
        } else {
            shift := 64 - typ.width
            mut shreg := 11
            if reg == shreg {
                shreg = 12
            }
            g.emit_mov_imm64(shreg, shift)
            g.emit(asm_lslv(Reg(reg), Reg(reg), Reg(shreg)))
            g.emit(asm_asrv(Reg(reg), Reg(reg), Reg(shreg)))
        }
    }
}

fn (g &Gen) is_i1_type(typ_id ssa.TypeID) bool {
    if typ_id <= 0 || typ_id >= g.mod.type_store.types.len {
        return false
    }
    typ := g.mod.type_store.types[typ_id]
    return typ.kind == .int_t && typ.width == 1
}

fn (g &Gen) types_type_variant_name_from_ssa_typ(typ_id ssa.TypeID) ?string {
    if typ_id <= 0 || typ_id >= g.mod.type_store.types.len {
        return none
    }
    typ := g.mod.type_store.types[typ_id]
    if typ.kind == .struct_t {
        if typ.field_names.len == 2 && typ.field_names[0] == 'name'
            && typ.field_names[1] == 'base_type' {
            return 'Alias'
        }
        if typ.field_names.len == 2 && typ.field_names[0] == 'len'
            && typ.field_names[1] == 'elem_type' {
            return 'ArrayFixed'
        }
        if typ.field_names.len == 1 && typ.field_names[0] == 'elem_type' {
            return 'Array'
        }
        if typ.field_names.len == 1 && typ.field_names[0] == 'base_type' {
            return 'Pointer'
        }
        return none
    }
    if typ.kind == .int_t && typ.width == 8 {
        return 'String'
    }
    return none
}

fn (g &Gen) sumtype_variant_tag_index(sumtype_name string, module_name string, variant_name string) ?int {
    if sum_obj := g.lookup_type_from_env(sumtype_name, module_name) {
        if sum_obj is types.SumType {
            for i, variant in sum_obj.get_variants() {
                full_name := types.type_name(variant)
                short_name := if full_name.contains('__') {
                    full_name.all_after_last('__')
                } else {
                    full_name
                }
                if full_name == variant_name || short_name == variant_name {
                    return i
                }
            }
        }
    }
    return none
}

fn (g &Gen) try_match_types_type_ischeck_rhs(rhs_id int) ?string {
    if rhs_id <= 0 || rhs_id >= g.mod.values.len {
        return none
    }
    rhs_val := g.mod.values[rhs_id]
    if rhs_val.kind != .instruction {
        return none
    }
    rhs_instr := g.mod.instrs[rhs_val.index]
    if g.selected_opcode(rhs_instr) != .extractvalue || rhs_instr.operands.len < 2 {
        return none
    }
    idx_id := rhs_instr.operands[1]
    if idx_id <= 0 || idx_id >= g.mod.values.len {
        return none
    }
    idx_val := g.mod.values[idx_id]
    if idx_val.kind != .constant || idx_val.name != '0' {
        return none
    }
    tuple_id := rhs_instr.operands[0]
    if tuple_id <= 0 || tuple_id >= g.mod.values.len {
        return none
    }
    tuple_val := g.mod.values[tuple_id]
    if tuple_val.kind != .constant || tuple_val.name != '0' {
        return none
    }
    if variant_name := g.types_type_variant_name_from_ssa_typ(rhs_val.typ) {
        return variant_name
    }
    return none
}

fn (mut g Gen) try_emit_types_type_ischeck_add(dest_reg int, lhs_reg int, val_id int, instr &mir.Instruction) bool {
    if instr.operands.len < 2 || !g.is_i1_type(g.mod.values[val_id].typ) {
        return false
    }
    lhs_id := instr.operands[0]
    if lhs_id <= 0 || lhs_id >= g.mod.values.len {
        return false
    }
    lhs_typ_id := g.mod.values[lhs_id].typ
    if !g.is_sumtype_wrapper_struct_type(lhs_typ_id) {
        return false
    }
    variant_name := g.try_match_types_type_ischeck_rhs(instr.operands[1]) or { return false }
    tag_idx := g.sumtype_variant_tag_index('Type', 'types', variant_name) or { return false }
    mut tag_reg := 10
    if tag_reg == lhs_reg || tag_reg == dest_reg {
        tag_reg = 11
        if tag_reg == lhs_reg || tag_reg == dest_reg {
            tag_reg = 12
        }
    }
    g.emit_mov_imm64(tag_reg, i64(tag_idx))
    g.emit(asm_cmp_reg(Reg(lhs_reg), Reg(tag_reg)))
    g.emit(asm_cset_eq(Reg(dest_reg)))
    return true
}

fn (g &Gen) call_targets_current_function(callee_id int) bool {
    if callee_id <= 0 || callee_id >= g.mod.values.len {
        return false
    }
    callee := g.mod.values[callee_id]
    return callee.name != '' && callee.name == g.cur_func_name
}

fn (mut g Gen) load_struct_src_address_to_reg(reg int, val_id int, expected_struct_typ ssa.TypeID, _call_callee_id int) {
    if val_id <= 0 || val_id >= g.mod.values.len {
        g.emit_mov_imm64(reg, 0)
        return
    }
    if expected_struct_typ > 0 && expected_struct_typ < g.mod.type_store.types.len {
        expected_typ := g.mod.type_store.types[expected_struct_typ]
        // Some call sites pass unwrapped sumtype words (`_tag`/`_data`) while the
        // callee expects the full wrapper struct. Re-associate such values back to
        // their wrapper so argument passing uses stable `{_tag, _data}` storage.
        if expected_typ.kind == .struct_t && g.is_sumtype_wrapper_struct_type(expected_struct_typ) {
            trace_struct_addr := g.env_trace_struct_addr.len > 0
                && (g.env_trace_struct_addr == '*' || g.cur_func_name == g.env_trace_struct_addr)
            // A raw `_data` word extracted from a wrapper can represent an address to
            // bytes whose prefix is the desired wrapper argument (for example, when
            // selecting a nested `ast.Expr` field). In that case pass the payload
            // pointer directly as the struct source address.
            if tuple_id := g.sumtype_extractvalue_data_tuple_id(val_id, expected_struct_typ) {
                if trace_struct_addr {
                    eprintln('ARM64 STRUCT_ADDR fn=${g.cur_func_name} mode=data_word_payload val=${val_id} wrapper=${tuple_id} expected=${expected_struct_typ}')
                }
                if g.load_sumtype_data_ptr_to_reg(reg, tuple_id) {
                    return
                }
            }
            if wrapper_id := g.sumtype_wrapper_source_from_unwrapped_value(val_id,
                expected_struct_typ, 0)
            {
                if trace_struct_addr {
                    eprintln('ARM64 STRUCT_ADDR fn=${g.cur_func_name} mode=unwrap_match val=${val_id} wrapper=${wrapper_id} expected=${expected_struct_typ}')
                }
                g.load_address_of_val_to_reg(reg, wrapper_id)
                return
            }
            if wrapper_id := g.sumtype_wrapper_source_from_tag_word(val_id) {
                if wrapper_id > 0 && wrapper_id < g.mod.values.len
                    && g.mod.values[wrapper_id].typ == expected_struct_typ {
                    // `_tag` extracted from the same wrapper type: recover that wrapper.
                    // Passing payload bytes here corrupts `{_tag, _data}` arguments.
                    if trace_struct_addr {
                        eprintln('ARM64 STRUCT_ADDR fn=${g.cur_func_name} mode=tag_match val=${val_id} wrapper=${wrapper_id} expected=${expected_struct_typ}')
                    }
                    g.load_address_of_val_to_reg(reg, wrapper_id)
                    return
                }
                // If wrapper types differ and there is a dominating variant guard,
                // the payload can carry the expected nested wrapper bytes.
                if wrapper_id > 0 && wrapper_id < g.mod.values.len
                    && g.sumtype_tag_word_has_variant_guard(val_id) {
                    if trace_struct_addr {
                        eprintln('ARM64 STRUCT_ADDR fn=${g.cur_func_name} mode=tag_payload_guarded val=${val_id} wrapper=${wrapper_id} wrapper_typ=${g.mod.values[wrapper_id].typ} expected=${expected_struct_typ}')
                    }
                    if g.load_sumtype_data_ptr_to_reg(reg, wrapper_id) {
                        return
                    }
                }
            }
        }
        if expected_typ.kind == .struct_t && g.type_size(expected_struct_typ) > 16
            && g.large_struct_stack_value_is_pointer(val_id) {
            // Some large struct values are explicitly pointer-carried in their stack
            // slot. Preserve that representation for indirect ABI arguments, but keep
            // ordinary large structs/arrays by address so array headers are copied intact.
            g.load_val_to_reg(reg, val_id)
            return
        }
    }
    val := g.mod.values[val_id]
    if val.typ > 0 && val.typ < g.mod.type_store.types.len {
        val_typ := g.mod.type_store.types[val.typ]
        if val_typ.kind == .ptr_t && val_typ.elem_type == expected_struct_typ {
            if val.kind == .instruction {
                instr := g.mod.instrs[val.index]
                if g.selected_opcode(instr) == .alloca {
                    if g.alloca_slot_stores_pointer_like_values(val_id, expected_struct_typ) {
                        g.load_val_to_reg(reg, val_id)
                    } else {
                        g.load_address_of_val_to_reg(reg, val_id)
                    }
                    return
                }
            }
            g.load_val_to_reg(reg, val_id)
            return
        }
    }
    g.load_address_of_val_to_reg(reg, val_id)
}

fn (mut g Gen) load_address_of_val_to_reg(reg int, val_id int) {
    if val_id <= 0 || val_id >= g.mod.values.len {
        g.emit_mov_imm64(reg, 0)
        return
    }
    val := g.mod.values[val_id]
    // string_literal values need full materialization (create cstring data,
    // store str/len/is_lit to stack) before their address can be taken.
    // load_val_to_reg handles this and returns the struct address.
    if val.kind == .string_literal {
        g.load_val_to_reg(reg, val_id)
        return
    }
    if val.kind == .instruction {
        instr := g.mod.instrs[val.index]
        if instr.op == .alloca {
            if data_off := g.alloca_offsets[val_id] {