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

import v2.mir
import v2.ssa

fn register_x64_matrix_struct_bytes(mut ssa_mod ssa.Module, size int) ssa.TypeID {
    i8_t := ssa_mod.type_store.get_int(8)
    mut fields := []ssa.TypeID{}
    for _ in 0 .. size {
        fields << i8_t
    }
    return register_x64_matrix_struct_fields(mut ssa_mod, fields)
}

fn register_x64_matrix_struct_fields(mut ssa_mod ssa.Module, fields []ssa.TypeID) ssa.TypeID {
    return ssa_mod.type_store.register(ssa.Type{
        kind:   .struct_t
        fields: fields
    })
}

fn assert_abi_value_class(class mir.AbiValueClass, mode mir.AbiPassMode, classes []mir.AbiEightbyteClass) {
    assert class.mode == mode
    assert class.classes == classes
}

fn assert_abi_layout_locs(layout mir.AbiValueLayout, kinds []mir.AbiLocationKind, indexes []int) {
    assert layout.locs.len == kinds.len
    assert indexes.len == kinds.len
    for i, kind in kinds {
        assert layout.locs[i].kind == kind
        assert layout.locs[i].index == indexes[i]
    }
}

fn assert_abi_layout(layout mir.AbiValueLayout, kinds []mir.AbiLocationKind, indexes []int, offsets []int, classes []mir.AbiEightbyteClass) {
    assert layout.locs.len == kinds.len
    assert indexes.len == kinds.len
    assert offsets.len == kinds.len
    assert classes.len == kinds.len
    for i, kind in kinds {
        assert layout.locs[i].kind == kind
        assert layout.locs[i].index == indexes[i]
        assert layout.locs[i].offset == offsets[i]
        assert layout.locs[i].class == classes[i]
    }
}

fn build_x64_matrix_direct_call_module(x64_abi X64Abi) (mir.Module, ssa.ValueID) {
    mut ssa_mod := ssa.Module.new('abi_test_x64_direct_call_matrix')
    i64_t := ssa_mod.type_store.get_int(64)
    sizes := [1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 32]
    mut struct_types := []ssa.TypeID{}
    for size in sizes {
        struct_types << register_x64_matrix_struct_bytes(mut ssa_mod, size)
    }

    callee_id := ssa_mod.new_function('callee', i64_t, [])
    for i, struct_t in struct_types {
        param := ssa_mod.add_value_node(.argument, struct_t, 'p${sizes[i]}', 0)
        ssa_mod.funcs[callee_id].params << param
    }
    caller_id := ssa_mod.new_function('caller', i64_t, [])
    mut args := []ssa.ValueID{}
    for i, struct_t in struct_types {
        arg := ssa_mod.add_value_node(.argument, struct_t, 'a${sizes[i]}', 0)
        ssa_mod.funcs[caller_id].params << arg
        args << arg
    }
    caller_entry := ssa_mod.add_block(caller_id, 'entry')
    fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
    mut operands := [fn_val]
    operands << args
    call_val := ssa_mod.add_instr(.call, caller_entry, i64_t, operands)
    zero := ssa_mod.get_or_add_const(i64_t, '0')
    ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, x64_abi)
    return mir_mod, call_val
}

fn build_x64_matrix_return_call_module(x64_abi X64Abi, size int) (mir.Module, ssa.ValueID) {
    mut ssa_mod := ssa.Module.new('abi_test_x64_return_call_matrix')
    i64_t := ssa_mod.type_store.get_int(64)
    struct_t := register_x64_matrix_struct_bytes(mut ssa_mod, size)

    callee_id := ssa_mod.new_function('callee', struct_t, [])
    callee_entry := ssa_mod.add_block(callee_id, 'entry')
    zero := ssa_mod.get_or_add_const(i64_t, '0')
    ssa_mod.add_instr(.ret, callee_entry, 0, [zero])

    caller_id := ssa_mod.new_function('caller', i64_t, [])
    caller_entry := ssa_mod.add_block(caller_id, 'entry')
    fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
    call_val := ssa_mod.add_instr(.call, caller_entry, struct_t, [fn_val])
    ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, x64_abi)
    return mir_mod, call_val
}

fn build_sysv_layout_call_module(prefix_count int, prefix_float bool, aggregate_kind string) (mir.Module, int, ssa.ValueID, int) {
    mut ssa_mod := ssa.Module.new('abi_test_x64_sysv_location_metadata')
    i64_t := ssa_mod.type_store.get_int(64)
    f64_t := ssa_mod.type_store.get_float(64)
    prefix_t := if prefix_float { f64_t } else { i64_t }
    aggregate_t := match aggregate_kind {
        'i64_i64' { register_x64_matrix_struct_fields(mut ssa_mod, [i64_t, i64_t]) }
        'f64_f64' { register_x64_matrix_struct_fields(mut ssa_mod, [f64_t, f64_t]) }
        'i64_f64' { register_x64_matrix_struct_fields(mut ssa_mod, [i64_t, f64_t]) }
        else { register_x64_matrix_struct_fields(mut ssa_mod, [i64_t]) }
    }

    callee_id := ssa_mod.new_function('callee', i64_t, [])
    mut param_types := []ssa.TypeID{len: prefix_count, init: prefix_t}
    param_types << aggregate_t
    for i, typ in param_types {
        param := ssa_mod.add_value_node(.argument, typ, 'p${i}', 0)
        ssa_mod.funcs[callee_id].params << param
    }
    caller_id := ssa_mod.new_function('caller', i64_t, [])
    mut args := []ssa.ValueID{}
    for i, typ in param_types {
        arg := ssa_mod.add_value_node(.argument, typ, 'a${i}', 0)
        ssa_mod.funcs[caller_id].params << arg
        args << arg
    }
    caller_entry := ssa_mod.add_block(caller_id, 'entry')
    fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
    mut operands := [fn_val]
    operands << args
    call_val := ssa_mod.add_instr(.call, caller_entry, i64_t, operands)
    zero := ssa_mod.get_or_add_const(i64_t, '0')
    ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, .sysv)
    return mir_mod, callee_id, call_val, prefix_count
}

fn build_sysv_scalar_boundary_module(mut ssa_mod ssa.Module, typ ssa.TypeID, count int) (mir.Module, int, ssa.ValueID) {
    i64_t := ssa_mod.type_store.get_int(64)
    callee_id := ssa_mod.new_function('callee', i64_t, [])
    for i := 0; i < count; i++ {
        param := ssa_mod.add_value_node(.argument, typ, 'p${i}', 0)
        ssa_mod.funcs[callee_id].params << param
    }
    caller_id := ssa_mod.new_function('caller', i64_t, [])
    mut args := []ssa.ValueID{}
    for i := 0; i < count; i++ {
        arg := ssa_mod.add_value_node(.argument, typ, 'a${i}', 0)
        ssa_mod.funcs[caller_id].params << arg
        args << arg
    }
    caller_entry := ssa_mod.add_block(caller_id, 'entry')
    fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
    mut operands := [fn_val]
    operands << args
    call_val := ssa_mod.add_instr(.call, caller_entry, i64_t, operands)
    zero := ssa_mod.get_or_add_const(i64_t, '0')
    ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, .sysv)
    return mir_mod, callee_id, call_val
}

fn test_x64_windows_struct_size_matrix_classification() {
    mut ssa_mod := ssa.Module.new('abi_test_x64_windows_size_matrix')
    i64_t := ssa_mod.type_store.get_int(64)
    sizes := [1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 32]
    direct_sizes := [1, 2, 4, 8]
    mut struct_types := []ssa.TypeID{}
    for size in sizes {
        struct_types << register_x64_matrix_struct_bytes(mut ssa_mod, size)
    }

    param_fn_id := ssa_mod.new_function('param_matrix', i64_t, [])
    for i, struct_t in struct_types {
        param := ssa_mod.add_value_node(.argument, struct_t, 's${sizes[i]}', 0)
        ssa_mod.funcs[param_fn_id].params << param
    }
    mut ret_fn_ids := []int{}
    for i, struct_t in struct_types {
        ret_fn_ids << ssa_mod.new_function('ret${sizes[i]}', struct_t, [])
    }

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, .windows)

    for i, size in sizes {
        should_be_indirect := size !in direct_sizes
        assert (mir_mod.funcs[param_fn_id].abi_param_class[i] == .indirect) == should_be_indirect
        assert mir_mod.funcs[ret_fn_ids[i]].abi_ret_indirect == should_be_indirect
    }
}

fn test_x64_windows_callsite_return_size_matrix_classification() {
    sizes := [1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 32]
    direct_sizes := [1, 2, 4, 8]
    for size in sizes {
        mir_mod, call_val := build_x64_matrix_return_call_module(.windows, size)
        call_instr := mir_mod.instrs[mir_mod.values[call_val].index]
        should_be_indirect := size !in direct_sizes
        assert call_instr.abi_ret_indirect == should_be_indirect
        assert (call_instr.op == .call_sret) == should_be_indirect
    }
}

fn test_x64_windows_direct_callsite_struct_size_matrix_classification() {
    sizes := [1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 32]
    direct_sizes := [1, 2, 4, 8]
    mir_mod, call_val := build_x64_matrix_direct_call_module(.windows)
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert call_instr.abi_arg_class.len == sizes.len
    for i, size in sizes {
        should_be_indirect := size !in direct_sizes
        assert (call_instr.abi_arg_class[i] == .indirect) == should_be_indirect
    }
}

fn test_non_sysv_legacy_thresholds_stay_unchanged_with_metadata_fields() {
    mut ssa_mod := ssa.Module.new('abi_test_non_sysv_legacy_metadata_guard')
    i64_t := ssa_mod.type_store.get_int(64)
    struct9_t := register_x64_matrix_struct_bytes(mut ssa_mod, 9)
    struct16_t := register_x64_matrix_struct_bytes(mut ssa_mod, 16)
    struct17_t := register_x64_matrix_struct_bytes(mut ssa_mod, 17)

    param_fn_id := ssa_mod.new_function('param_matrix', i64_t, [])
    for typ in [struct9_t, struct16_t, struct17_t] {
        param := ssa_mod.add_value_node(.argument, typ, 'p', 0)
        ssa_mod.funcs[param_fn_id].params << param
    }
    ret16_id := ssa_mod.new_function('ret16', struct16_t, [])
    ret17_id := ssa_mod.new_function('ret17', struct17_t, [])

    mut win_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut win_mod, .x64, .windows)
    assert win_mod.funcs[param_fn_id].abi_param_class == [.indirect, .indirect, .indirect]
    assert win_mod.funcs[ret16_id].abi_ret_indirect == true
    assert win_mod.funcs[ret17_id].abi_ret_indirect == true
    for layout in win_mod.funcs[param_fn_id].abi_param_layouts {
        assert layout.locs.len == 0
    }

    mut arm_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut arm_mod, .arm64, .sysv)
    assert arm_mod.funcs[param_fn_id].abi_param_class == [.in_reg, .in_reg, .indirect]
    assert arm_mod.funcs[ret16_id].abi_ret_indirect == false
    assert arm_mod.funcs[ret17_id].abi_ret_indirect == true
    for layout in arm_mod.funcs[param_fn_id].abi_param_layouts {
        assert layout.locs.len == 0
    }
}

fn test_x64_sysv_location_metadata_rolls_back_integer_aggregate_when_gprs_are_insufficient() {
    mir_mod, callee_id, call_val, aggregate_idx := build_sysv_layout_call_module(6, false,
        'i64_i64')
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert_abi_layout_locs(mir_mod.funcs[callee_id].abi_param_layouts[aggregate_idx], [
        .stack,
        .stack,
    ], [0, 1])
    assert_abi_layout_locs(call_instr.abi_arg_layouts[aggregate_idx], [.stack, .stack], [
        0,
        1,
    ])
}

fn test_x64_sysv_location_metadata_uses_two_gprs_when_available_for_integer_aggregate() {
    mir_mod, callee_id, call_val, aggregate_idx := build_sysv_layout_call_module(4, false,
        'i64_i64')
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert_abi_layout_locs(mir_mod.funcs[callee_id].abi_param_layouts[aggregate_idx], [
        .int_reg,
        .int_reg,
    ], [4, 5])
    assert_abi_layout_locs(call_instr.abi_arg_layouts[aggregate_idx], [.int_reg, .int_reg], [
        4,
        5,
    ])
}

fn test_x64_sysv_location_metadata_rolls_back_integer_aggregate_after_five_gprs() {
    mir_mod, callee_id, call_val, aggregate_idx := build_sysv_layout_call_module(5, false,
        'i64_i64')
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert_abi_layout_locs(mir_mod.funcs[callee_id].abi_param_layouts[aggregate_idx], [
        .stack,
        .stack,
    ], [0, 1])
    assert_abi_layout_locs(call_instr.abi_arg_layouts[aggregate_idx], [.stack, .stack], [
        0,
        1,
    ])
}

fn test_x64_sysv_location_metadata_rolls_back_sse_aggregate_when_xmms_are_insufficient() {
    mir_mod, callee_id, call_val, aggregate_idx := build_sysv_layout_call_module(7, true, 'f64_f64')
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert_abi_layout_locs(mir_mod.funcs[callee_id].abi_param_layouts[aggregate_idx], [
        .stack,
        .stack,
    ], [0, 1])
    assert_abi_layout_locs(call_instr.abi_arg_layouts[aggregate_idx], [.stack, .stack], [
        0,
        1,
    ])
}

fn test_x64_sysv_location_metadata_assigns_mixed_integer_sse_aggregate() {
    mir_mod, callee_id, call_val, aggregate_idx := build_sysv_layout_call_module(0, false,
        'i64_f64')
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert_abi_layout_locs(mir_mod.funcs[callee_id].abi_param_layouts[aggregate_idx], [
        .int_reg,
        .sse_reg,
    ], [0, 0])
    assert_abi_layout_locs(call_instr.abi_arg_layouts[aggregate_idx], [.int_reg, .sse_reg], [
        0,
        0,
    ])
}

fn test_x64_sysv_location_metadata_reserves_rdi_for_hidden_sret_pointer() {
    mut ssa_mod := ssa.Module.new('abi_test_x64_sysv_sret_location_metadata')
    i64_t := ssa_mod.type_store.get_int(64)
    f64_t := ssa_mod.type_store.get_float(64)
    ret_t := register_x64_matrix_struct_fields(mut ssa_mod, [i64_t, i64_t, i64_t])
    aggregate_t := register_x64_matrix_struct_fields(mut ssa_mod, [i64_t, f64_t])

    callee_id := ssa_mod.new_function('callee', ret_t, [])
    callee_param := ssa_mod.add_value_node(.argument, aggregate_t, 'p', 0)
    ssa_mod.funcs[callee_id].params << callee_param

    caller_id := ssa_mod.new_function('caller', i64_t, [])
    caller_arg := ssa_mod.add_value_node(.argument, aggregate_t, 'a', 0)
    ssa_mod.funcs[caller_id].params << caller_arg
    caller_entry := ssa_mod.add_block(caller_id, 'entry')
    fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
    call_val := ssa_mod.add_instr(.call, caller_entry, ret_t, [fn_val, caller_arg])
    zero := ssa_mod.get_or_add_const(i64_t, '0')
    ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, .sysv)
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert mir_mod.funcs[callee_id].abi_ret_indirect
    assert call_instr.abi_ret_indirect
    assert call_instr.op == .call_sret
    assert_abi_layout(mir_mod.funcs[callee_id].abi_param_layouts[0], [
        .int_reg,
        .sse_reg,
    ], [1, 0], [0, 8], [.integer, .sse])
    assert_abi_layout(call_instr.abi_arg_layouts[0], [.int_reg, .sse_reg], [
        1,
        0,
    ], [0, 8], [.integer, .sse])
}

fn test_x64_sysv_location_metadata_places_seventh_integer_scalar_on_stack() {
    mut ssa_mod := ssa.Module.new('abi_test_x64_sysv_integer_scalar_boundary')
    i64_t := ssa_mod.type_store.get_int(64)
    mir_mod, callee_id, call_val := build_sysv_scalar_boundary_module(mut ssa_mod, i64_t, 7)
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert_abi_layout(mir_mod.funcs[callee_id].abi_param_layouts[6], [.stack], [0], [
        0,
    ], [.integer])
    assert_abi_layout(call_instr.abi_arg_layouts[6], [.stack], [0], [0], [.integer])
}

fn test_x64_sysv_location_metadata_places_ninth_sse_scalar_on_stack() {
    mut ssa_mod := ssa.Module.new('abi_test_x64_sysv_sse_scalar_boundary')
    f64_t := ssa_mod.type_store.get_float(64)
    mir_mod, callee_id, call_val := build_sysv_scalar_boundary_module(mut ssa_mod, f64_t, 9)
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert_abi_layout(mir_mod.funcs[callee_id].abi_param_layouts[8], [.stack], [0], [
        0,
    ], [.sse])
    assert_abi_layout(call_instr.abi_arg_layouts[8], [.stack], [0], [0], [.sse])
}

fn test_x64_sysv_location_metadata_float128_uses_one_sse_register() {
    // x86-64 psABI 3.2.3 classifies __float128 as SSE plus SSEUP; SSEUP is
    // carried in the upper half of the previous SSE register, not a new XMM.
    mut ssa_mod := ssa.Module.new('abi_test_x64_sysv_float128_one_xmm')
    f128_t := ssa_mod.type_store.get_float(128)
    mir_mod, callee_id, call_val := build_sysv_scalar_boundary_module(mut ssa_mod, f128_t, 1)
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert_abi_layout(mir_mod.funcs[callee_id].abi_param_layouts[0], [.sse_reg, .sse_reg], [
        0,
        0,
    ], [0, 8], [.sse, .sseup])
    assert_abi_layout(call_instr.abi_arg_layouts[0], [.sse_reg, .sse_reg], [
        0,
        0,
    ], [0, 8], [.sse, .sseup])
}

fn test_x64_sysv_location_metadata_float128_rolls_back_when_sse_regs_are_exhausted() {
    // x86-64 psABI 3.2.3 says an argument that cannot fit entirely in the
    // available registers is passed on the stack; this guards the SSE/SSEUP
    // rollback path without claiming codegen consumes the metadata yet.
    mut ssa_mod := ssa.Module.new('abi_test_x64_sysv_float128_sse_exhausted')
    f64_t := ssa_mod.type_store.get_float(64)
    f128_t := ssa_mod.type_store.get_float(128)
    i64_t := ssa_mod.type_store.get_int(64)
    mut param_types := []ssa.TypeID{len: 8, init: f64_t}
    param_types << f128_t

    callee_id := ssa_mod.new_function('callee', i64_t, [])
    for i, typ in param_types {
        param := ssa_mod.add_value_node(.argument, typ, 'p${i}', 0)
        ssa_mod.funcs[callee_id].params << param
    }
    caller_id := ssa_mod.new_function('caller', i64_t, [])
    mut args := []ssa.ValueID{}
    for i, typ in param_types {
        arg := ssa_mod.add_value_node(.argument, typ, 'a${i}', 0)
        ssa_mod.funcs[caller_id].params << arg
        args << arg
    }
    caller_entry := ssa_mod.add_block(caller_id, 'entry')
    fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
    mut operands := [fn_val]
    operands << args
    call_val := ssa_mod.add_instr(.call, caller_entry, i64_t, operands)
    zero := ssa_mod.get_or_add_const(i64_t, '0')
    ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, .sysv)
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert_abi_layout(mir_mod.funcs[callee_id].abi_param_layouts[8], [.stack, .stack], [
        0,
        1,
    ], [0, 8], [.sse, .sseup])
    assert_abi_layout(call_instr.abi_arg_layouts[8], [.stack, .stack], [0, 1], [
        0,
        8,
    ], [.sse, .sseup])
    assert call_instr.abi_arg_class[8] == .in_reg
    assert call_instr.op == .call
}

fn test_x64_sysv_location_metadata_assigns_two_xmms_when_available_for_sse_aggregate() {
    mir_mod, callee_id, call_val, aggregate_idx := build_sysv_layout_call_module(0, true, 'f64_f64')
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert_abi_layout(mir_mod.funcs[callee_id].abi_param_layouts[aggregate_idx], [
        .sse_reg,
        .sse_reg,
    ], [0, 1], [0, 8], [.sse, .sse])
    assert_abi_layout(call_instr.abi_arg_layouts[aggregate_idx], [.sse_reg, .sse_reg], [
        0,
        1,
    ], [0, 8], [.sse, .sse])
}

fn test_x64_sysv_location_metadata_passes_memory_class_aggregate_indirectly() {
    mut ssa_mod := ssa.Module.new('abi_test_x64_sysv_memory_class_layout')
    i64_t := ssa_mod.type_store.get_int(64)
    f64_t := ssa_mod.type_store.get_float(64)
    memory_t := register_x64_matrix_struct_fields(mut ssa_mod, [f64_t, f64_t, f64_t])
    callee_id := ssa_mod.new_function('callee', i64_t, [])
    param := ssa_mod.add_value_node(.argument, memory_t, 'p', 0)
    ssa_mod.funcs[callee_id].params << param
    caller_id := ssa_mod.new_function('caller', i64_t, [])
    arg := ssa_mod.add_value_node(.argument, memory_t, 'a', 0)
    ssa_mod.funcs[caller_id].params << arg
    caller_entry := ssa_mod.add_block(caller_id, 'entry')
    fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
    call_val := ssa_mod.add_instr(.call, caller_entry, i64_t, [fn_val, arg])
    zero := ssa_mod.get_or_add_const(i64_t, '0')
    ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, .sysv)
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert mir_mod.funcs[callee_id].abi_param_class == [.indirect]
    assert call_instr.abi_arg_class == [.indirect]
    assert_abi_value_class(mir_mod.funcs[callee_id].abi_param_classes[0], .indirect, [
        .memory,
    ])
    assert_abi_value_class(call_instr.abi_arg_classes[0], .indirect, [.memory])
    assert_abi_layout(mir_mod.funcs[callee_id].abi_param_layouts[0], [.int_reg], [0], [
        0,
    ], [.integer])
    assert_abi_layout(call_instr.abi_arg_layouts[0], [.int_reg], [0], [0], [.integer])
}

fn test_x64_sysv_location_metadata_rolls_back_mixed_aggregate_when_gprs_are_exhausted() {
    mir_mod, callee_id, call_val, aggregate_idx := build_sysv_layout_call_module(6, false,
        'i64_f64')
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert_abi_layout(mir_mod.funcs[callee_id].abi_param_layouts[aggregate_idx], [
        .stack,
        .stack,
    ], [0, 1], [0, 8], [.integer, .sse])
    assert_abi_layout(call_instr.abi_arg_layouts[aggregate_idx], [.stack, .stack], [0, 1], [
        0,
        8,
    ], [.integer, .sse])
    assert call_instr.abi_arg_class[aggregate_idx] == .in_reg
    assert call_instr.op == .call
}

fn test_x64_sysv_location_metadata_rolls_back_mixed_aggregate_when_xmms_are_exhausted() {
    mir_mod, callee_id, call_val, aggregate_idx := build_sysv_layout_call_module(8, true, 'i64_f64')
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert_abi_layout(mir_mod.funcs[callee_id].abi_param_layouts[aggregate_idx], [
        .stack,
        .stack,
    ], [0, 1], [0, 8], [.integer, .sse])
    assert_abi_layout(call_instr.abi_arg_layouts[aggregate_idx], [.stack, .stack], [0, 1], [
        0,
        8,
    ], [.integer, .sse])
    assert call_instr.abi_arg_class[aggregate_idx] == .in_reg
    assert call_instr.op == .call
}

fn test_x64_sysv_location_metadata_stack_indexes_continue_after_scalar_spill() {
    mut ssa_mod := ssa.Module.new('abi_test_x64_sysv_stack_continuation_types')
    i64_t := ssa_mod.type_store.get_int(64)
    struct_i64_i64_t := register_x64_matrix_struct_fields(mut ssa_mod, [i64_t, i64_t])
    mut param_types := []ssa.TypeID{len: 6, init: i64_t}
    param_types << i64_t
    param_types << struct_i64_i64_t

    callee_id := ssa_mod.new_function('callee', i64_t, [])
    for i, typ in param_types {
        param := ssa_mod.add_value_node(.argument, typ, 'p${i}', 0)
        ssa_mod.funcs[callee_id].params << param
    }
    caller_id := ssa_mod.new_function('caller', i64_t, [])
    mut args := []ssa.ValueID{}
    for i, typ in param_types {
        arg := ssa_mod.add_value_node(.argument, typ, 'a${i}', 0)
        ssa_mod.funcs[caller_id].params << arg
        args << arg
    }
    caller_entry := ssa_mod.add_block(caller_id, 'entry')
    fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
    mut operands := [fn_val]
    operands << args
    call_val := ssa_mod.add_instr(.call, caller_entry, i64_t, operands)
    zero := ssa_mod.get_or_add_const(i64_t, '0')
    ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, .sysv)
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert_abi_layout_locs(mir_mod.funcs[callee_id].abi_param_layouts[6], [.stack], [
        0,
    ])
    assert_abi_layout_locs(mir_mod.funcs[callee_id].abi_param_layouts[7], [.stack, .stack], [
        1,
        2,
    ])
    assert_abi_layout_locs(call_instr.abi_arg_layouts[6], [.stack], [0])
    assert_abi_layout_locs(call_instr.abi_arg_layouts[7], [.stack, .stack], [1, 2])
}

fn test_x64_sysv_direct_callsite_struct_size_matrix_current_threshold() {
    sizes := [1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 32]
    mir_mod, call_val := build_x64_matrix_direct_call_module(.sysv)
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert call_instr.abi_arg_class.len == sizes.len
    for i, size in sizes {
        should_be_indirect := size > 16
        assert (call_instr.abi_arg_class[i] == .indirect) == should_be_indirect
    }
}

fn test_x64_sysv_callsite_return_size_matrix_current_threshold() {
    sizes := [1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 32]
    for size in sizes {
        mir_mod, call_val := build_x64_matrix_return_call_module(.sysv, size)
        call_instr := mir_mod.instrs[mir_mod.values[call_val].index]
        should_be_indirect := size > 16
        assert call_instr.abi_ret_indirect == should_be_indirect
        assert (call_instr.op == .call_sret) == should_be_indirect
    }
}

fn test_x64_sysv_struct_size_matrix_current_lowering_threshold() {
    mut ssa_mod := ssa.Module.new('abi_test_x64_sysv_size_matrix')
    i64_t := ssa_mod.type_store.get_int(64)
    sizes := [1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 32]
    mut struct_types := []ssa.TypeID{}
    for size in sizes {
        struct_types << register_x64_matrix_struct_bytes(mut ssa_mod, size)
    }

    param_fn_id := ssa_mod.new_function('param_matrix', i64_t, [])
    for i, struct_t in struct_types {
        param := ssa_mod.add_value_node(.argument, struct_t, 's${sizes[i]}', 0)
        ssa_mod.funcs[param_fn_id].params << param
    }
    mut ret_fn_ids := []int{}
    for i, struct_t in struct_types {
        ret_fn_ids << ssa_mod.new_function('ret${sizes[i]}', struct_t, [])
    }

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, .sysv)

    for i, size in sizes {
        should_be_indirect := size > 16
        assert (mir_mod.funcs[param_fn_id].abi_param_class[i] == .indirect) == should_be_indirect
        assert mir_mod.funcs[ret_fn_ids[i]].abi_ret_indirect == should_be_indirect
    }
}

fn test_x64_sysv_aggregate_memory_class_for_representable_mir_types() {
    mut ssa_mod := ssa.Module.new('abi_test_x64_sysv_memory_class')
    i64_t := ssa_mod.type_store.get_int(64)
    f64_t := ssa_mod.type_store.get_float(64)
    f80_t := ssa_mod.type_store.get_float(80)
    f128_t := ssa_mod.type_store.get_float(128)
    two_eightbytes_t := register_x64_matrix_struct_fields(mut ssa_mod, [f64_t, f64_t])
    three_eightbytes_t := register_x64_matrix_struct_fields(mut ssa_mod, [f64_t, f64_t, f64_t])
    x87_aggregate_t := register_x64_matrix_struct_fields(mut ssa_mod, [f80_t])
    float128_aggregate_t := register_x64_matrix_struct_fields(mut ssa_mod, [f128_t])

    param_fn_id := ssa_mod.new_function('sysv_memory_params', i64_t, [])
    for typ in [two_eightbytes_t, three_eightbytes_t, x87_aggregate_t, float128_aggregate_t] {
        param := ssa_mod.add_value_node(.argument, typ, 'p', 0)
        ssa_mod.funcs[param_fn_id].params << param
    }
    ret_two_id := ssa_mod.new_function('ret_two_eightbytes', two_eightbytes_t, [])
    ret_three_id := ssa_mod.new_function('ret_three_eightbytes', three_eightbytes_t, [])
    ret_x87_id := ssa_mod.new_function('ret_x87_aggregate', x87_aggregate_t, [])
    ret_float128_id := ssa_mod.new_function('ret_float128_aggregate', float128_aggregate_t, [])

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, .sysv)

    assert_abi_value_class(mir_mod.funcs[param_fn_id].abi_param_classes[0], .direct, [
        .sse,
        .sse,
    ])
    assert_abi_value_class(mir_mod.funcs[param_fn_id].abi_param_classes[1], .indirect, [
        .memory,
    ])
    assert_abi_value_class(mir_mod.funcs[param_fn_id].abi_param_classes[2], .indirect, [
        .memory,
    ])
    assert_abi_value_class(mir_mod.funcs[param_fn_id].abi_param_classes[3], .direct, [
        .sse,
        .sseup,
    ])
    assert_abi_value_class(mir_mod.funcs[ret_two_id].abi_ret_class, .direct, [.sse, .sse])
    assert_abi_value_class(mir_mod.funcs[ret_three_id].abi_ret_class, .indirect, [
        .memory,
    ])
    assert_abi_value_class(mir_mod.funcs[ret_x87_id].abi_ret_class, .indirect, [
        .memory,
    ])
    assert_abi_value_class(mir_mod.funcs[ret_float128_id].abi_ret_class, .direct, [
        .sse,
        .sseup,
    ])
}

fn test_x64_sysv_metadata_eightbyte_classification_for_representable_types() {
    mut ssa_mod := ssa.Module.new('abi_test_x64_sysv_eightbyte_metadata')
    i64_t := ssa_mod.type_store.get_int(64)
    f64_t := ssa_mod.type_store.get_float(64)
    f80_t := ssa_mod.type_store.get_float(80)
    f128_t := ssa_mod.type_store.get_float(128)
    struct_i64_t := register_x64_matrix_struct_fields(mut ssa_mod, [i64_t])
    struct_i64_i64_t := register_x64_matrix_struct_fields(mut ssa_mod, [i64_t, i64_t])
    struct_f64_t := register_x64_matrix_struct_fields(mut ssa_mod, [f64_t])
    struct_f64_f64_t := register_x64_matrix_struct_fields(mut ssa_mod, [f64_t, f64_t])
    struct_i64_f64_t := register_x64_matrix_struct_fields(mut ssa_mod, [i64_t, f64_t])
    struct_f64_i64_t := register_x64_matrix_struct_fields(mut ssa_mod, [f64_t, i64_t])
    too_large_t := register_x64_matrix_struct_fields(mut ssa_mod, [f64_t, f64_t, f64_t])
    x87_aggregate_t := register_x64_matrix_struct_fields(mut ssa_mod, [f80_t])
    float128_aggregate_t := register_x64_matrix_struct_fields(mut ssa_mod, [f128_t])
    types := [
        struct_i64_t,
        struct_i64_i64_t,
        struct_f64_t,
        struct_f64_f64_t,
        struct_i64_f64_t,
        struct_f64_i64_t,
        too_large_t,
        x87_aggregate_t,
        float128_aggregate_t,
    ]

    param_fn_id := ssa_mod.new_function('sysv_metadata_params', i64_t, [])
    for typ in types {
        param := ssa_mod.add_value_node(.argument, typ, 'p', 0)
        ssa_mod.funcs[param_fn_id].params << param
    }
    mut ret_fn_ids := []int{}
    for i, typ in types {
        ret_fn_ids << ssa_mod.new_function('sysv_metadata_ret_${i}', typ, [])
    }

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, .sysv)

    expected_classes := [
        [mir.AbiEightbyteClass.integer],
        [mir.AbiEightbyteClass.integer, .integer],
        [mir.AbiEightbyteClass.sse],
        [mir.AbiEightbyteClass.sse, .sse],
        [mir.AbiEightbyteClass.integer, .sse],
        [mir.AbiEightbyteClass.sse, .integer],
        [mir.AbiEightbyteClass.memory],
        [mir.AbiEightbyteClass.memory],
        [mir.AbiEightbyteClass.sse, .sseup],
    ]
    expected_modes := [
        mir.AbiPassMode.direct,
        .direct,
        .direct,
        .direct,
        .direct,
        .direct,
        .indirect,
        .indirect,
        .direct,
    ]
    for i in 0 .. types.len {
        assert_abi_value_class(mir_mod.funcs[param_fn_id].abi_param_classes[i], expected_modes[i],
            expected_classes[i])
        assert_abi_value_class(mir_mod.funcs[ret_fn_ids[i]].abi_ret_class, expected_modes[i],
            expected_classes[i])
    }
}

fn test_x64_sysv_memory_class_projects_to_legacy_indirect_flags() {
    mut ssa_mod := ssa.Module.new('abi_test_x64_sysv_callsite_memory_class')
    i64_t := ssa_mod.type_store.get_int(64)
    f80_t := ssa_mod.type_store.get_float(80)
    x87_aggregate_t := register_x64_matrix_struct_fields(mut ssa_mod, [f80_t])

    callee_id := ssa_mod.new_function('callee', x87_aggregate_t, [])
    callee_param := ssa_mod.add_value_node(.argument, x87_aggregate_t, 'p', 0)
    ssa_mod.funcs[callee_id].params << callee_param
    caller_id := ssa_mod.new_function('caller', i64_t, [])
    arg := ssa_mod.add_value_node(.argument, x87_aggregate_t, 'a', 0)
    ssa_mod.funcs[caller_id].params << arg
    caller_entry := ssa_mod.add_block(caller_id, 'entry')
    fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
    call_val := ssa_mod.add_instr(.call, caller_entry, x87_aggregate_t, [fn_val, arg])
    zero := ssa_mod.get_or_add_const(i64_t, '0')
    ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, .sysv)

    assert_abi_value_class(mir_mod.funcs[callee_id].abi_param_classes[0], .indirect, [
        .memory,
    ])
    assert_abi_value_class(mir_mod.funcs[callee_id].abi_ret_class, .indirect, [
        .memory,
    ])
    assert mir_mod.funcs[callee_id].abi_param_class == [.indirect]
    assert mir_mod.funcs[callee_id].abi_ret_indirect == true
    assert_abi_layout(mir_mod.funcs[callee_id].abi_param_layouts[0], [.int_reg], [1], [
        0,
    ], [.integer])

    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]
    assert_abi_value_class(call_instr.abi_arg_classes[0], .indirect, [.memory])
    assert_abi_value_class(call_instr.abi_ret_class, .indirect, [.memory])
    assert call_instr.abi_arg_class == [.indirect]
    assert call_instr.abi_ret_indirect == true
    assert call_instr.op == .call_sret
    assert_abi_layout(call_instr.abi_arg_layouts[0], [.int_reg], [1], [0], [.integer])
}

fn test_x64_sysv_direct_aggregate_size_guard_boundary() {
    assert !sysv_aggregate_must_be_memory_before_classification(16)
    assert sysv_aggregate_must_be_memory_before_classification(17)
}

fn test_x64_sysv_huge_fixed_array_uses_early_memory_guard_and_bounded_metadata() {
    mut ssa_mod := ssa.Module.new('abi_test_x64_sysv_huge_fixed_array_memory')
    i64_t := ssa_mod.type_store.get_int(64)
    u8_t := ssa_mod.type_store.get_uint(8)
    huge_array_t := ssa_mod.type_store.register(ssa.Type{
        kind:      .array_t
        elem_type: u8_t
        len:       1_000_000
    })

    callee_id := ssa_mod.new_function('callee', huge_array_t, [])
    param := ssa_mod.add_value_node(.argument, huge_array_t, 'p', 0)
    ssa_mod.funcs[callee_id].params << param
    caller_id := ssa_mod.new_function('caller', i64_t, [])
    arg := ssa_mod.add_value_node(.argument, huge_array_t, 'a', 0)
    ssa_mod.funcs[caller_id].params << arg
    caller_entry := ssa_mod.add_block(caller_id, 'entry')
    fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
    call_val := ssa_mod.add_instr(.call, caller_entry, huge_array_t, [fn_val, arg])
    zero := ssa_mod.get_or_add_const(i64_t, '0')
    ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, .sysv)
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    huge_size := mir_mod.type_size(huge_array_t)
    assert huge_size == 1_000_000
    assert sysv_aggregate_must_be_memory_before_classification(huge_size)
    direct_class := sysv_abi_value_class(mir_mod, huge_array_t)
    assert_abi_value_class(direct_class, .indirect, [.memory])
    assert direct_class.classes.len == 1
    assert direct_class.classes.len < (huge_size + 7) / 8

    param_class := mir_mod.funcs[callee_id].abi_param_classes[0]
    ret_class := mir_mod.funcs[callee_id].abi_ret_class
    assert_abi_value_class(param_class, .indirect, [.memory])
    assert_abi_value_class(ret_class, .indirect, [.memory])
    assert param_class.classes.len == 1
    assert ret_class.classes.len == 1
    assert mir_mod.funcs[callee_id].abi_param_class == [.indirect]
    assert mir_mod.funcs[callee_id].abi_ret_indirect
    assert mir_mod.funcs[callee_id].abi_param_layouts[0].locs.len == 1
    assert_abi_layout(mir_mod.funcs[callee_id].abi_param_layouts[0], [.int_reg], [1], [
        0,
    ], [.integer])

    assert_abi_value_class(call_instr.abi_arg_classes[0], .indirect, [.memory])
    assert_abi_value_class(call_instr.abi_ret_class, .indirect, [.memory])
    assert call_instr.abi_arg_classes[0].classes.len == 1
    assert call_instr.abi_ret_class.classes.len == 1
    assert call_instr.abi_arg_class == [.indirect]
    assert call_instr.abi_ret_indirect
    assert call_instr.op == .call_sret
    assert call_instr.abi_arg_layouts[0].locs.len == 1
    assert_abi_layout(call_instr.abi_arg_layouts[0], [.int_reg], [1], [0], [.integer])
}

fn test_x64_sysv_indirect_argument_consumes_gpr_before_direct_aggregate_layout() {
    mut ssa_mod := ssa.Module.new('abi_test_x64_sysv_indirect_arg_gpr_consumption')
    i64_t := ssa_mod.type_store.get_int(64)
    f80_t := ssa_mod.type_store.get_float(80)
    x87_aggregate_t := register_x64_matrix_struct_fields(mut ssa_mod, [f80_t])
    integer_pair_t := register_x64_matrix_struct_fields(mut ssa_mod, [i64_t, i64_t])

    callee_id := ssa_mod.new_function('callee', i64_t, [])
    memory_param := ssa_mod.add_value_node(.argument, x87_aggregate_t, 'memory_arg', 0)
    pair_param := ssa_mod.add_value_node(.argument, integer_pair_t, 'pair_arg', 0)
    ssa_mod.funcs[callee_id].params << [memory_param, pair_param]
    caller_id := ssa_mod.new_function('caller', i64_t, [])
    memory_arg := ssa_mod.add_value_node(.argument, x87_aggregate_t, 'memory_arg', 0)
    pair_arg := ssa_mod.add_value_node(.argument, integer_pair_t, 'pair_arg', 0)
    ssa_mod.funcs[caller_id].params << [memory_arg, pair_arg]
    caller_entry := ssa_mod.add_block(caller_id, 'entry')
    fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
    call_val := ssa_mod.add_instr(.call, caller_entry, i64_t, [fn_val, memory_arg, pair_arg])
    zero := ssa_mod.get_or_add_const(i64_t, '0')
    ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, .sysv)
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert mir_mod.funcs[callee_id].abi_param_class == [.indirect, .in_reg]
    assert call_instr.abi_arg_class == [.indirect, .in_reg]
    assert_abi_layout(mir_mod.funcs[callee_id].abi_param_layouts[0], [.int_reg], [0], [
        0,
    ], [.integer])
    assert_abi_layout(mir_mod.funcs[callee_id].abi_param_layouts[1], [
        .int_reg,
        .int_reg,
    ], [1, 2], [0, 8], [.integer, .integer])
    assert_abi_layout(call_instr.abi_arg_layouts[0], [.int_reg], [0], [0], [.integer])
    assert_abi_layout(call_instr.abi_arg_layouts[1], [.int_reg, .int_reg], [1, 2], [
        0,
        8,
    ], [.integer, .integer])
}

fn test_x64_sysv_indirect_argument_spills_after_gprs_are_exhausted() {
    mut ssa_mod := ssa.Module.new('abi_test_x64_sysv_indirect_arg_stack_spill')
    i64_t := ssa_mod.type_store.get_int(64)
    f80_t := ssa_mod.type_store.get_float(80)
    x87_aggregate_t := register_x64_matrix_struct_fields(mut ssa_mod, [f80_t])
    mut param_types := []ssa.TypeID{len: 6, init: i64_t}
    param_types << x87_aggregate_t
    param_types << i64_t

    callee_id := ssa_mod.new_function('callee', i64_t, [])
    for i, typ in param_types {
        param := ssa_mod.add_value_node(.argument, typ, 'p${i}', 0)
        ssa_mod.funcs[callee_id].params << param
    }
    caller_id := ssa_mod.new_function('caller', i64_t, [])
    mut args := []ssa.ValueID{}
    for i, typ in param_types {
        arg := ssa_mod.add_value_node(.argument, typ, 'a${i}', 0)
        ssa_mod.funcs[caller_id].params << arg
        args << arg
    }
    caller_entry := ssa_mod.add_block(caller_id, 'entry')
    fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
    mut operands := [fn_val]
    operands << args
    call_val := ssa_mod.add_instr(.call, caller_entry, i64_t, operands)
    zero := ssa_mod.get_or_add_const(i64_t, '0')
    ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, .sysv)
    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]

    assert mir_mod.funcs[callee_id].abi_param_class[6] == .indirect
    assert call_instr.abi_arg_class[6] == .indirect
    assert_abi_layout(mir_mod.funcs[callee_id].abi_param_layouts[6], [.stack], [0], [
        0,
    ], [.integer])
    assert_abi_layout(call_instr.abi_arg_layouts[6], [.stack], [0], [0], [.integer])
    assert_abi_layout(mir_mod.funcs[callee_id].abi_param_layouts[7], [.stack], [1], [
        0,
    ], [.integer])
    assert_abi_layout(call_instr.abi_arg_layouts[7], [.stack], [1], [0], [.integer])
}

fn test_x64_windows_indirect_call_uses_function_pointer_signature_for_aggregate_args() {
    mut ssa_mod := ssa.Module.new('abi_test_x64_windows_indirect_call_matrix')
    i64_t := ssa_mod.type_store.get_int(64)
    struct8_t := register_x64_matrix_struct_bytes(mut ssa_mod, 8)
    struct9_t := register_x64_matrix_struct_bytes(mut ssa_mod, 9)
    fn_sig_t := ssa_mod.type_store.register(ssa.Type{
        kind:     .func_t
        params:   [struct8_t, struct9_t]
        ret_type: i64_t
    })
    fn_ptr_t := ssa_mod.type_store.get_ptr(fn_sig_t)

    caller_id := ssa_mod.new_function('caller', i64_t, [])
    fn_ptr := ssa_mod.add_value_node(.argument, fn_ptr_t, 'fn_ptr', 0)
    arg8 := ssa_mod.add_value_node(.argument, struct8_t, 'arg8', 0)
    arg9 := ssa_mod.add_value_node(.argument, struct9_t, 'arg9', 0)
    ssa_mod.funcs[caller_id].params << [fn_ptr, arg8, arg9]
    caller_entry := ssa_mod.add_block(caller_id, 'entry')
    call_val := ssa_mod.add_instr(.call_indirect, caller_entry, i64_t, [fn_ptr, arg8, arg9])
    zero := ssa_mod.get_or_add_const(i64_t, '0')
    ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, .windows)

    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]
    assert call_instr.op == .call_indirect
    assert call_instr.abi_arg_class == [.in_reg, .indirect]
}

fn test_x64_windows_unresolved_callsite_uses_alloca_logical_aggregate_type() {
    mut ssa_mod := ssa.Module.new('abi_test_x64_windows_alloca_logical_arg')
    i64_t := ssa_mod.type_store.get_int(64)
    struct9_t := register_x64_matrix_struct_bytes(mut ssa_mod, 9)
    struct9_ptr_t := ssa_mod.type_store.get_ptr(struct9_t)

    caller_id := ssa_mod.new_function('caller', i64_t, [])
    caller_entry := ssa_mod.add_block(caller_id, 'entry')
    tmp := ssa_mod.add_instr(.alloca, caller_entry, struct9_ptr_t, []ssa.ValueID{})
    external_fn := ssa_mod.add_value_node(.unknown, 0, 'external_accept_struct9', 0)
    call_val := ssa_mod.add_instr(.call, caller_entry, i64_t, [external_fn, tmp])
    zero := ssa_mod.get_or_add_const(i64_t, '0')
    ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

    mut mir_mod := mir.lower_from_ssa(ssa_mod)
    lower_with_x64_abi(mut mir_mod, .x64, .windows)

    call_instr := mir_mod.instrs[mir_mod.values[call_val].index]
    assert call_instr.abi_arg_class == [.indirect]
}