// 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