module x64

import v2.mir
import v2.ssa

fn contains_bytes(haystack []u8, needle []u8) bool {
    if needle.len == 0 {
        return true
    }
    if needle.len > haystack.len {
        return false
    }
    for i in 0 .. haystack.len - needle.len + 1 {
        if haystack[i..i + needle.len] == needle {
            return true
        }
    }
    return false
}

fn index_bytes(haystack []u8, needle []u8) int {
    if needle.len == 0 {
        return 0
    }
    if needle.len > haystack.len {
        return -1
    }
    for i in 0 .. haystack.len - needle.len + 1 {
        if haystack[i..i + needle.len] == needle {
            return i
        }
    }
    return -1
}

fn last_index_bytes(haystack []u8, needle []u8) int {
    if needle.len == 0 {
        return haystack.len
    }
    if needle.len > haystack.len {
        return -1
    }
    for i := haystack.len - needle.len; i >= 0; i-- {
        if haystack[i..i + needle.len] == needle {
            return i
        }
    }
    return -1
}

fn test_x64_abi_int_argument_registers() {
    assert X64Abi.sysv.int_arg_regs() == [int(rdi), int(rsi), int(rdx), int(rcx), int(r8), int(r9)]
    assert X64Abi.windows.int_arg_regs() == [int(rcx), int(rdx), int(r8), int(r9)]
    assert X64Abi.sysv.int_arg_reg_at(0) == int(rdi)
    assert X64Abi.sysv.int_arg_reg_at(5) == int(r9)
    assert X64Abi.sysv.int_arg_reg_at(6) == x64_no_arg_reg
}

fn test_x64_abi_float_argument_registers() {
    assert X64Abi.sysv.float_arg_regs() == [0, 1, 2, 3, 4, 5, 6, 7]
    assert X64Abi.windows.float_arg_regs() == [0, 1, 2, 3]
    assert X64Abi.sysv.float_arg_reg_at(0) == 0
    assert X64Abi.sysv.float_arg_reg_at(7) == 7
    assert X64Abi.sysv.float_arg_reg_at(8) == x64_no_arg_reg
}

fn test_x64_union_type_layout_uses_overlapping_fields() {
    mut ts := ssa.TypeStore.new()
    f64_t := ts.get_float(64)
    u64_t := ts.get_uint(64)
    union_t := ts.register(ssa.Type{
        kind:        .struct_t
        fields:      [f64_t, u64_t]
        field_names: ['f', 'u']
        is_union:    true
    })
    mut mod := mir.Module{
        type_store: unsafe { *ts }
    }
    gen := Gen.new(&mod)

    assert gen.struct_field_offset_bytes(union_t, 0) == 0
    assert gen.struct_field_offset_bytes(union_t, 1) == 0
    assert gen.type_align(union_t) == 8
    assert gen.type_size(union_t) == 8
}

fn test_x64_abi_basic_argument_position_matrix() {
    sysv_int := [int(rdi), int(rsi), int(rdx), int(rcx), int(r8), int(r9), x64_no_arg_reg,
        x64_no_arg_reg, x64_no_arg_reg]
    sysv_float := [0, 1, 2, 3, 4, 5, 6, 7, x64_no_arg_reg]
    windows_int := [int(rcx), int(rdx), int(r8), int(r9), x64_no_arg_reg, x64_no_arg_reg,
        x64_no_arg_reg, x64_no_arg_reg, x64_no_arg_reg]
    windows_float := [0, 1, 2, 3, x64_no_arg_reg, x64_no_arg_reg, x64_no_arg_reg, x64_no_arg_reg,
        x64_no_arg_reg]

    for position in 0 .. 9 {
        assert X64Abi.sysv.int_arg_reg_at(position) == sysv_int[position]
        assert X64Abi.sysv.float_arg_reg_at(position) == sysv_float[position]
        assert X64Abi.windows.int_arg_reg_for_position(position) == windows_int[position]
        assert X64Abi.windows.float_arg_reg_for_position(position) == windows_float[position]
    }
}

fn test_x64_windows_argument_registers_are_position_based() {
    assert X64Abi.windows.uses_positional_arg_regs()
    assert X64Abi.windows.int_arg_reg_for_position(0) == int(rcx)
    assert X64Abi.windows.float_arg_reg_for_position(1) == 1
    assert X64Abi.windows.int_arg_reg_for_position(2) == int(r8)
    assert X64Abi.windows.float_arg_reg_for_position(3) == 3
    assert X64Abi.windows.int_arg_reg_for_position(4) == x64_no_arg_reg
    assert X64Abi.windows.float_arg_reg_for_position(4) == x64_no_arg_reg
}

fn test_x64_sysv_argument_helpers_keep_compact_register_order() {
    assert !X64Abi.sysv.uses_positional_arg_regs()
    assert X64Abi.sysv.int_arg_reg_at(0) == int(rdi)
    assert X64Abi.sysv.int_arg_reg_at(1) == int(rsi)
    assert X64Abi.sysv.float_arg_reg_at(0) == 0
    assert X64Abi.sysv.float_arg_reg_at(1) == 1
}

fn test_x64_abi_shadow_space_size() {
    assert X64Abi.sysv.shadow_space_size() == 0
    assert X64Abi.windows.shadow_space_size() == 32
    assert X64Abi.windows.call_stack_arg_offset(4) == 32
    assert X64Abi.windows.call_stack_arg_offset(5) == 40
    assert X64Abi.windows.stack_arg_offset(4) == 48
    assert X64Abi.windows.stack_arg_offset(5) == 56
    assert X64Abi.windows.call_frame_size(0) == 32
    assert X64Abi.windows.call_frame_size(1) == 48
}

fn test_x64_windows_stack_argument_offset_matrix() {
    expected_call_offsets := [32, 40, 48, 56, 64]
    expected_callee_offsets := [48, 56, 64, 72, 80]
    positions := [4, 5, 6, 7, 8]
    for i, position in positions {
        assert X64Abi.windows.call_stack_arg_offset(position) == expected_call_offsets[i]
        assert X64Abi.windows.stack_arg_offset(position) == expected_callee_offsets[i]
    }
    assert X64Abi.windows.call_frame_size(0) == 32
    assert X64Abi.windows.call_frame_size(1) == 48
    assert X64Abi.windows.call_frame_size(2) == 48
    assert X64Abi.windows.call_frame_size(3) == 64
    assert X64Abi.windows.call_frame_size(4) == 64
    assert X64Abi.windows.call_frame_size(5) == 80
}

fn test_x64_abi_sret_registers_are_explicit() {
    assert X64Abi.sysv.sret_reg() == rdi
    assert X64Abi.sysv.sret_arg_regs() == [int(rsi), int(rdx), int(rcx), int(r8), int(r9)]
    assert X64Abi.windows.sret_reg() == rcx
    assert X64Abi.windows.sret_arg_regs() == [int(rdx), int(r8), int(r9)]
}

fn test_x64_gen_defaults_to_sysv_abi() {
    mut mod := mir.Module{}
    gen := Gen.new(&mod)
    assert gen.abi == .sysv

    coff_gen := Gen.new_with_format(&mod, .coff)
    assert coff_gen.abi == .sysv

    windows_gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    assert windows_gen.abi == .windows
}

fn test_x64_windows_stack_arg_mask_is_position_based() {
    mut mod := new_x64_abi_test_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    instr := mir.Instruction{
        operands: [ssa.ValueID(0), 1, 2, 3, 4, 5]
    }

    assert gen.call_stack_arg_mask(instr, gen.abi.int_arg_regs().len, 0) == [false, false, false,
        false, true]
    assert gen.call_stack_arg_mask(instr, gen.abi.sret_arg_regs().len, 1) == [false, false, false,
        true, true]
}

fn test_x64_sysv_stack_arg_mask_keeps_separate_int_and_float_counters() {
    mut mod := new_x64_abi_test_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    instr := mir.Instruction{
        operands: [ssa.ValueID(0), 1, 2, 3, 4, 5]
    }

    assert gen.call_stack_arg_mask(instr, gen.abi.int_arg_regs().len, 0) == [false, false, false,
        false, false]
}

fn test_x64_sysv_stack_arg_mask_counts_two_eightbyte_aggregate_registers() {
    mut mod := new_x64_abi_pair_arg_test_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    // x86-64 psABI 3.2.3 classifies small integer aggregates by eightbyte:
    // this Pair consumes r8/r9 after four scalar INTEGER arguments, so the
    // following scalar argument must be passed on the stack.
    pair_then_scalar := mir.Instruction{
        operands: [ssa.ValueID(0), 1, 2, 3, 4, 5, 6]
    }
    stack_after_pair := gen.call_stack_arg_mask(pair_then_scalar, gen.abi.int_arg_regs().len, 0)

    assert stack_after_pair == [false, false, false, false, false, true]
    assert gen.call_stack_slots(pair_then_scalar, stack_after_pair) == 1
}

fn test_x64_sysv_stack_arg_mask_spilled_aggregate_does_not_consume_remaining_register() {
    mut mod := new_x64_abi_pair_arg_test_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    // If an aggregate cannot fit entirely in the remaining INTEGER registers,
    // psABI 3.2.3 requires it to roll back to the stack; the next scalar can
    // still use the remaining register.
    spilled_pair_then_scalar := mir.Instruction{
        operands: [ssa.ValueID(0), 1, 2, 3, 4, 6, 5, 7]
    }
    stack_after_spill := gen.call_stack_arg_mask(spilled_pair_then_scalar,
        gen.abi.int_arg_regs().len, 0)

    assert stack_after_spill == [false, false, false, false, false, true, false]
    assert gen.call_stack_slots(spilled_pair_then_scalar, stack_after_spill) == 2
}

fn test_x64_windows_call_frame_reserves_shadow_space() {
    mut mod := new_x64_abi_test_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)

    cleanup := gen.emit_windows_call_frame(1)
    assert cleanup == 48
    gen.cleanup_windows_call_frame(cleanup)
    assert gen.coff.text_data == [u8(0x48), 0x83, 0xec, 0x30, 0x48, 0x83, 0xc4, 0x30]
}

fn test_x64_windows_large_stack_allocation_probes_each_page() {
    mut mod := new_x64_abi_test_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    gen.stack_size = x64_windows_stack_probe_page_size * 2 + 8

    gen.emit_stack_allocation()

    page_probe := [u8(0x48), 0x81, 0xec, 0x00, 0x10, 0x00, 0x00, 0xf6, 0x04, 0x24, 0x00]
    mut expected := []u8{}
    expected << page_probe
    expected << page_probe
    expected << [u8(0x48), 0x83, 0xec, 0x08, 0xf6, 0x04, 0x24, 0x00]
    assert gen.coff.text_data == expected
}

fn test_x64_sysv_large_stack_allocation_uses_single_sub() {
    mut mod := new_x64_abi_test_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    gen.stack_size = x64_windows_stack_probe_page_size * 2 + 8

    gen.emit_stack_allocation()

    assert gen.elf.text_data == [u8(0x48), 0x81, 0xec, 0x08, 0x20, 0x00, 0x00]
}

fn test_x64_windows_stack_arg_store_starts_after_shadow_space() {
    mut mod := new_x64_abi_test_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    instr := mir.Instruction{
        operands: [ssa.ValueID(0), 1, 2, 3, 4, 5]
    }

    gen.store_windows_call_stack_arg(5, 4, 4, instr)
    assert gen.coff.text_data == [u8(0xb8), 0x05, 0, 0, 0, 0x48, 0x89, 0x44, 0x24, 0x20]
}

fn test_x64_windows_integer_stack_arg_store_writes_full_slot() {
    mut mod := new_x64_abi_u32_stack_arg_test_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    instr := mir.Instruction{
        operands: [ssa.ValueID(0), 1, 2, 3, 4, 5]
    }

    gen.store_windows_call_stack_arg(5, 4, 4, instr)
    assert gen.coff.text_data == [u8(0x31), 0xc0, 0x48, 0x89, 0x44, 0x24, 0x20]
}

fn test_x64_windows_does_not_emit_sysv_sse_arg_count() {
    mut mod := new_x64_abi_test_module()
    mut win_gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    win_gen.emit_sse_arg_count(2)
    assert win_gen.coff.text_data.len == 0

    mut sysv_gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    sysv_gen.emit_sse_arg_count(2)
    assert sysv_gen.elf.text_data == [u8(0xb8), 0x02, 0, 0, 0]
}

fn test_x64_windows_codegen_mixed_call_uses_positional_registers() {
    mut mod := new_x64_abi_call_module(false)
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    gen.gen()
    code := gen.coff.text_data

    assert contains_bytes(code, [u8(0x48), 0x83, 0xec, 0x30])
    assert contains_bytes(code, [u8(0xb9), 0x01, 0, 0, 0]) // arg0 int -> RCX
    assert contains_bytes(code, [u8(0xf2), 0x0f, 0x10, 0x4d]) // arg1 float -> XMM1
    assert contains_bytes(code, [u8(0x41), 0xb8, 0x03, 0, 0, 0]) // arg2 int -> R8
    assert contains_bytes(code, [u8(0xf2), 0x0f, 0x10, 0x5d]) // arg3 float -> XMM3
    assert contains_bytes(code, [u8(0xb8), 0x05, 0, 0, 0, 0x48, 0x89, 0x44, 0x24, 0x20])
    assert !contains_bytes(code, [u8(0xb8), 0x02, 0, 0, 0]) // no SysV AL SSE count
}

fn test_x64_windows_codegen_call_sret_shifts_user_arg_registers() {
    mut mod := new_x64_abi_call_module(true)
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    gen.gen()
    code := gen.coff.text_data

    assert contains_bytes(code, [u8(0x48), 0x89, 0xc1]) // hidden sret pointer -> RCX
    assert contains_bytes(code, [u8(0xba), 0x01, 0, 0, 0]) // first user int -> RDX
    assert contains_bytes(code, [u8(0xf2), 0x0f, 0x10, 0x55]) // second user float -> XMM2
}

fn test_x64_windows_codegen_call_sret_with_indirect_receiver_shifts_user_args() {
    mut mod := new_x64_abi_sret_indirect_receiver_call_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    gen.gen()
    code := gen.coff.text_data

    end_arg := index_bytes(code, [u8(0x41), 0xb9, 0x03, 0, 0, 0]) // end -> R9
    start_arg := index_bytes(code, [u8(0x41), 0xb8, 0x01, 0, 0, 0]) // start -> R8
    receiver_arg := index_bytes(code, [u8(0x48), 0x89, 0xc2]) // receiver pointer -> RDX
    hidden_sret := index_bytes(code, [u8(0x48), 0x89, 0xc1]) // hidden sret pointer -> RCX

    assert end_arg >= 0
    assert start_arg > end_arg
    assert receiver_arg > start_arg
    assert hidden_sret > receiver_arg
}

fn test_x64_windows_codegen_sret_callee_prologue_shifts_indirect_receiver_and_scalars() {
    mut mod := new_x64_abi_sret_indirect_receiver_callee_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    gen.gen()
    code := gen.coff.text_data

    receiver_from_rdx := index_bytes(code, [u8(0x49), 0x89, 0xd2]) // mov r10, rdx
    receiver_from_rcx := index_bytes(code, [u8(0x49), 0x89, 0xca]) // mov r10, rcx
    start_from_r8 := index_bytes(code, [u8(0x4c), 0x89, 0x45]) // mov [rbp+disp8], r8
    end_from_r9 := index_bytes(code, [u8(0x4c), 0x89, 0x4d]) // mov [rbp+disp8], r9

    assert receiver_from_rdx >= 0
    assert receiver_from_rcx < 0
    assert start_from_r8 > receiver_from_rdx
    assert end_from_r9 > start_from_r8
}

fn test_x64_sysv_codegen_direct_integer_pair_call_result_stores_rax_and_rdx() {
    mut mod := new_x64_abi_pair_return_call_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    gen.gen()
    code := gen.elf.text_data

    rax_store := index_bytes(code, [u8(0x48), 0x89, 0x45]) // mov [rbp+disp8], rax
    rdx_store := index_bytes(code, [u8(0x48), 0x89, 0x55]) // mov [rbp+disp8], rdx

    assert rax_store >= 0
    assert rdx_store > rax_store
}

fn test_x64_sysv_codegen_direct_integer_pair_return_loads_rax_and_rdx() {
    mut mod := new_x64_abi_pair_return_callee_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    gen.gen()
    code := gen.elf.text_data

    rax_load := index_bytes(code, [u8(0x49), 0x8b, 0x02]) // mov rax, [r10]
    rdx_load := index_bytes(code, [u8(0x49), 0x8b, 0x52, 0x08]) // mov rdx, [r10+8]

    assert rax_load >= 0
    assert rdx_load > rax_load
}

fn test_x64_sysv_codegen_mixed_aggregate_param_stores_gpr_and_xmm() {
    mut mod := new_x64_abi_mixed_aggregate_call_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    gen.gen()
    code := gen.elf.text_data

    assert contains_bytes(code, [u8(0x48), 0x89, 0x7d]) // RDI -> integer eightbyte
    assert contains_bytes(code, [u8(0xf2), 0x0f, 0x11, 0x45]) // XMM0 -> SSE eightbyte
}

fn test_x64_sysv_codegen_mixed_aggregate_call_arg_loads_gpr_and_xmm() {
    mut mod := new_x64_abi_mixed_aggregate_call_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    gen.gen()
    code := gen.elf.text_data

    rdi_load := index_bytes(code, [u8(0x49), 0x8b, 0x3a]) // mov rdi, [r10]
    xmm0_load := index_bytes(code, [u8(0xf2), 0x41, 0x0f, 0x10, 0x42, 0x08]) // movsd xmm0, [r10+8]

    assert rdi_load >= 0
    assert xmm0_load > rdi_load
}

fn test_x64_sysv_codegen_mixed_aggregate_call_sets_sse_arg_count_to_one() {
    mut mod := new_x64_abi_mixed_aggregate_call_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    gen.gen()
    code := gen.elf.text_data

    xmm0_load := index_bytes(code, [u8(0xf2), 0x41, 0x0f, 0x10, 0x42, 0x08]) // movsd xmm0, [r10+8]
    al_count := index_bytes(code, [u8(0xb8), 0x01, 0, 0, 0]) // mov eax, 1
    call := last_index_bytes(code, [u8(0xe8)])

    assert xmm0_load >= 0
    assert al_count > xmm0_load
    assert call > al_count
}

fn test_x64_sysv_codegen_indirect_f64_call_loads_callee_before_sse_arg_count() {
    code := emit_x64_abi_indirect_f64_call_with_callee_in_rax(false)

    callee_load := index_bytes(code, [u8(0x49), 0x89, 0xc2]) // mov r10, rax
    al_count := index_bytes(code, [u8(0xb8), 0x01, 0, 0, 0]) // mov eax, 1
    call := index_bytes(code, [u8(0x41), 0xff, 0xd2]) // call r10

    assert callee_load >= 0
    assert al_count > callee_load
    assert call > al_count
}

fn test_x64_sysv_codegen_indirect_f64_call_sret_loads_callee_before_sse_arg_count() {
    code := emit_x64_abi_indirect_f64_call_with_callee_in_rax(true)

    callee_load := index_bytes(code, [u8(0x49), 0x89, 0xc2]) // mov r10, rax
    al_count := index_bytes(code, [u8(0xb8), 0x01, 0, 0, 0]) // mov eax, 1
    call := index_bytes(code, [u8(0x41), 0xff, 0xd2]) // call r10

    assert callee_load >= 0
    assert al_count > callee_load
    assert call > al_count
}

fn test_x64_sysv_codegen_call_sret_shifts_mixed_user_arg_to_rsi_and_xmm0() {
    mut mod := new_x64_abi_sret_mixed_aggregate_call_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    gen.gen()
    code := gen.elf.text_data

    sret := index_bytes(code, [u8(0x48), 0x89, 0xc7]) // hidden sret pointer -> RDI
    rsi_load := index_bytes(code, [u8(0x49), 0x8b, 0x32]) // mov rsi, [r10]
    xmm0_load := index_bytes(code, [u8(0xf2), 0x41, 0x0f, 0x10, 0x42, 0x08]) // movsd xmm0, [r10+8]
    al_count := index_bytes(code, [u8(0xb8), 0x01, 0, 0, 0]) // mov eax, 1
    call := last_index_bytes(code, [u8(0xe8)])

    assert sret >= 0
    assert rsi_load > sret
    assert xmm0_load > rsi_load
    assert al_count > xmm0_load
    assert call > al_count
}

fn test_x64_sysv_codegen_sse_pair_aggregate_param_stores_xmm0_and_xmm1() {
    mut mod := new_x64_abi_sse_pair_aggregate_call_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    gen.gen()
    code := gen.elf.text_data

    xmm0_store := index_bytes(code, [u8(0xf2), 0x0f, 0x11, 0x45]) // XMM0 -> first f64
    xmm1_store := index_bytes(code, [u8(0xf2), 0x0f, 0x11, 0x4d]) // XMM1 -> second f64

    assert xmm0_store >= 0
    assert xmm1_store > xmm0_store
}

fn test_x64_sysv_codegen_sse_pair_aggregate_call_arg_loads_xmm0_and_xmm1() {
    mut mod := new_x64_abi_sse_pair_aggregate_call_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    gen.gen()
    code := gen.elf.text_data

    xmm0_load := index_bytes(code, [u8(0xf2), 0x41, 0x0f, 0x10, 0x02]) // movsd xmm0, [r10]
    xmm1_load := index_bytes(code, [u8(0xf2), 0x41, 0x0f, 0x10, 0x4a, 0x08]) // movsd xmm1, [r10+8]
    al_count := index_bytes(code, [u8(0xb8), 0x02, 0, 0, 0]) // mov eax, 2
    call := last_index_bytes(code, [u8(0xe8)])

    assert xmm0_load >= 0
    assert xmm1_load > xmm0_load
    assert al_count > xmm1_load
    assert call > al_count
}

fn test_x64_sysv_codegen_sse_aggregate_call_result_stores_xmms() {
    mut mod := new_x64_abi_sse_pair_return_call_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    gen.gen()
    code := gen.elf.text_data

    xmm0_store := index_bytes(code, [u8(0xf2), 0x0f, 0x11, 0x45]) // movsd [rbp+disp], xmm0
    xmm1_store := index_bytes(code, [u8(0xf2), 0x0f, 0x11, 0x4d]) // movsd [rbp+disp], xmm1

    assert xmm0_store >= 0
    assert xmm1_store > xmm0_store
}

fn test_x64_sysv_codegen_mixed_aggregate_direct_return_loads_gpr_and_xmm() {
    mut mod := new_x64_abi_mixed_return_callee_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    gen.gen()
    code := gen.elf.text_data

    rax_load := index_bytes(code, [u8(0x49), 0x8b, 0x02]) // mov rax, [r10]
    xmm0_load := index_bytes(code, [u8(0xf2), 0x41, 0x0f, 0x10, 0x42, 0x08]) // movsd xmm0, [r10+8]

    assert rax_load >= 0
    assert xmm0_load > rax_load
}

fn test_x64_sysv_codegen_sseup_aggregate_param_and_call_arg_use_one_xmm_register() {
    mut mod := new_x64_abi_sseup_aggregate_call_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    gen.gen()
    code := gen.elf.text_data

    xmm0_store := index_bytes(code, [u8(0xf3), 0x0f, 0x7f, 0x45]) // movdqu [rbp+disp], xmm0
    xmm0_load := index_bytes(code, [u8(0xf3), 0x41, 0x0f, 0x6f, 0x02]) // movdqu xmm0, [r10]

    assert xmm0_store >= 0
    assert xmm0_load > xmm0_store
}

fn test_x64_sysv_codegen_sseup_aggregate_call_result_stores_one_xmm_register() {
    mut mod := new_x64_abi_sseup_return_call_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    gen.gen()
    code := gen.elf.text_data

    assert contains_bytes(code, [u8(0xf3), 0x0f, 0x7f, 0x45]) // movdqu [rbp+disp], xmm0
}

fn test_x64_sysv_codegen_sseup_aggregate_direct_return_loads_one_xmm_register() {
    mut mod := new_x64_abi_sseup_return_callee_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    gen.gen()
    code := gen.elf.text_data

    assert contains_bytes(code, [u8(0xf3), 0x41, 0x0f, 0x6f, 0x02]) // movdqu xmm0, [r10]
}

fn test_x64_windows_does_not_take_sysv_integer_pair_return_path() {
    mut mod := new_x64_abi_pair_return_call_module()
    gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)

    assert !gen.is_sysv_integer_pair_return(x64_abi_integer_pair_return_class())
}

fn test_x64_windows_codegen_callee_stack_arg_loads_from_rbp_48() {
    mut mod := new_x64_abi_callee_stack_arg_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    gen.gen()
    code := gen.coff.text_data

    assert contains_bytes(code, [u8(0x48), 0x8b, 0x45, 0x30]) // mov rax, [rbp+48]
}

fn test_x64_windows_codegen_large_aggregate_arg_uses_indirect_pointer() {
    mut mod := new_x64_abi_indirect_aggregate_call_module(true)
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    gen.gen()
    code := gen.coff.text_data

    assert contains_bytes(code, [u8(0x48), 0x83, 0xec, 0x20]) // shadow space
    assert contains_bytes(code, [u8(0x48), 0x8d, 0x45]) // lea rax, [rbp+disp8]
    assert contains_bytes(code, [u8(0x48), 0x89, 0xc1]) // indirect arg pointer -> RCX
}

fn test_x64_windows_codegen_unmarked_large_aggregate_arg_uses_indirect_pointer() {
    mut mod := new_x64_abi_indirect_aggregate_call_module(false)
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    gen.gen()
    code := gen.coff.text_data

    assert contains_bytes(code, [u8(0x48), 0x83, 0xec, 0x20]) // shadow space
    assert contains_bytes(code, [u8(0x48), 0x8d, 0x45]) // lea rax, [rbp+disp8]
    assert contains_bytes(code, [u8(0x48), 0x89, 0xc1]) // indirect arg pointer -> RCX
}

fn test_x64_windows_codegen_struct8_arg_remains_by_value() {
    mut mod := new_x64_abi_struct8_call_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    gen.gen()
    code := gen.coff.text_data

    assert contains_bytes(code, [u8(0x49), 0x8b, 0x0a]) // mov rcx, [r10]
    assert !contains_bytes(code, [u8(0x48), 0x89, 0xc1]) // no pointer move into RCX
}

fn test_x64_windows_codegen_stack_large_aggregate_arg_uses_indirect_pointer() {
    mut mod := new_x64_abi_stack_indirect_aggregate_call_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    gen.gen()
    code := gen.coff.text_data

    assert contains_bytes(code, [u8(0x48), 0x83, 0xec, 0x30]) // shadow space + one stack slot
    assert contains_bytes(code, [u8(0x48), 0x8d, 0x45]) // lea rax, [rbp+disp8]
    assert contains_bytes(code, [u8(0x48), 0x89, 0x44, 0x24, 0x20]) // pointer -> [rsp+32]
}

fn test_x64_windows_codegen_fifth_nil_pointer_arg_uses_8_byte_shadow_stack_slot() {
    mut mod := new_x64_abi_fifth_nil_pointer_call_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    gen.gen()
    code := gen.coff.text_data

    assert contains_bytes(code, [u8(0x48), 0x83, 0xec, 0x30]) // 32 shadow bytes + 8 stack arg + align
    assert contains_bytes(code, [u8(0x31), 0xc0, 0x48, 0x89, 0x44, 0x24, 0x20]) // nil -> [rsp+32]
}

fn test_x64_windows_codegen_local_u32_pointer_arg_uses_r9_before_fifth_nil() {
    mut mod := new_x64_abi_writefile_like_pointer_call_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    gen.gen()
    code := gen.coff.text_data

    assert contains_bytes(code, [u8(0x48), 0x83, 0xec, 0x30]) // 32 shadow bytes + 8 stack arg + align
    assert contains_bytes(code, [u8(0x48), 0x8d, 0x45]) // materialize local u32 address
    assert contains_bytes(code, [u8(0x4c), 0x8d, 0x4d]) // fourth arg pointer -> R9
    assert contains_bytes(code, [u8(0x31), 0xc0, 0x48, 0x89, 0x44, 0x24, 0x20]) // fifth nil -> [rsp+32]
}

fn test_x64_windows_codegen_writefile_buffer_pointer_uses_rdx() {
    mut mod := new_x64_abi_writefile_buffer_pointer_call_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    gen.gen()
    code := gen.coff.text_data
    rdx_buffer := index_bytes(code, [u8(0x48), 0x8d, 0x55])
    r8_len := index_bytes(code, [u8(0x41), 0xb8, 0x01, 0, 0, 0])
    r9_written := index_bytes(code, [u8(0x4c), 0x8d, 0x4d])
    rcx_handle := last_index_bytes(code, [u8(0xb9), 0x01, 0, 0, 0])

    assert contains_bytes(code, [u8(0x48), 0x83, 0xec, 0x30]) // 32 shadow bytes + 8 stack arg + align
    assert rdx_buffer >= 0 // second arg &u8 buffer pointer -> RDX
    assert r8_len >= 0 // third arg length -> R8
    assert r9_written >= 0 // fourth arg &u32 written pointer -> R9
    assert rcx_handle > rdx_buffer // first arg is loaded last to protect RCX from scratch use
    assert rcx_handle > r8_len
    assert rcx_handle > r9_written
    assert contains_bytes(code, [u8(0x31), 0xc0, 0x48, 0x89, 0x44, 0x24, 0x20]) // fifth nil -> [rsp+32]
}

fn test_x64_windows_codegen_indirect_string_literal_materializes_before_call() {
    mut mod := new_x64_abi_indirect_string_literal_call_module()
    mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
    gen.gen()
    code := gen.coff.text_data

    assert gen.coff.rodata == [u8(`h`), `e`, `l`, `l`, `o`, 0]
    assert contains_bytes(code, [u8(0x48), 0x89, 0x45]) // store string.str in the stack slot
    assert contains_bytes(code, [u8(0xb8), 0x05, 0, 0, 0]) // materialized len = 5
    assert contains_bytes(code, [u8(0xb8), 0x01, 0, 0, 0]) // materialized is_lit = 1
    assert contains_bytes(code, [u8(0x48), 0x89, 0xc1]) // string slot pointer -> RCX
}

fn new_x64_abi_test_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    int_t := ts.get_int(64)
    float_t := ts.get_float(64)
    return mir.Module{
        type_store: unsafe { *ts }
        values:     [
            mir.Value{
                id:    0
                typ:   int_t
                kind:  .func_ref
                name:  'callee'
                index: 0
            },
            mir.Value{
                id:    1
                typ:   int_t
                kind:  .constant
                name:  '1'
                index: 1
            },
            mir.Value{
                id:    2
                typ:   float_t
                kind:  .constant
                name:  '2'
                index: 2
            },
            mir.Value{
                id:    3
                typ:   int_t
                kind:  .constant
                name:  '3'
                index: 3
            },
            mir.Value{
                id:    4
                typ:   float_t
                kind:  .constant
                name:  '4'
                index: 4
            },
            mir.Value{
                id:    5
                typ:   int_t
                kind:  .constant
                name:  '5'
                index: 5
            },
        ]
    }
}

fn new_x64_abi_u32_stack_arg_test_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    ptr_t := ts.get_ptr(ts.get_int(8))
    u32_t := ts.get_uint(32)
    return mir.Module{
        type_store: unsafe { *ts }
        values:     [
            mir.Value{
                id:    0
                typ:   ptr_t
                kind:  .func_ref
                name:  'callee'
                index: 0
            },
            mir.Value{
                id:    1
                typ:   ptr_t
                kind:  .constant
                name:  '0'
                index: 1
            },
            mir.Value{
                id:    2
                typ:   ptr_t
                kind:  .constant
                name:  '0'
                index: 2
            },
            mir.Value{
                id:    3
                typ:   ptr_t
                kind:  .constant
                name:  '0'
                index: 3
            },
            mir.Value{
                id:    4
                typ:   ptr_t
                kind:  .constant
                name:  '0'
                index: 4
            },
            mir.Value{
                id:    5
                typ:   u32_t
                kind:  .constant
                name:  '0'
                index: 5
            },
        ]
    }
}

fn new_x64_abi_pair_arg_test_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    int_t := ts.get_int(64)
    pair_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [int_t, int_t]
    })
    return mir.Module{
        type_store: unsafe { *ts }
        values:     [
            mir.Value{
                id:    0
                typ:   int_t
                kind:  .func_ref
                name:  'callee'
                index: 0
            },
            mir.Value{
                id:    1
                typ:   int_t
                kind:  .constant
                name:  '1'
                index: 1
            },
            mir.Value{
                id:    2
                typ:   int_t
                kind:  .constant
                name:  '2'
                index: 2
            },
            mir.Value{
                id:    3
                typ:   int_t
                kind:  .constant
                name:  '3'
                index: 3
            },
            mir.Value{
                id:    4
                typ:   int_t
                kind:  .constant
                name:  '4'
                index: 4
            },
            mir.Value{
                id:    5
                typ:   pair_t
                kind:  .argument
                name:  'pair'
                index: 5
            },
            mir.Value{
                id:    6
                typ:   int_t
                kind:  .constant
                name:  '6'
                index: 6
            },
            mir.Value{
                id:    7
                typ:   int_t
                kind:  .constant
                name:  '7'
                index: 7
            },
        ]
    }
}

fn new_x64_abi_call_module(sret bool) mir.Module {
    mut ts := ssa.TypeStore.new()
    int_t := ts.get_int(64)
    float_t := ts.get_float(64)
    struct9_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [int_t, ts.get_int(8)]
    })
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 8}
        instrs:     []mir.Instruction{len: 2}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   int_t
        kind:  .func_ref
        name:  'callee'
        index: 0
    }
    for i in 1 .. 6 {
        m.values[i] = mir.Value{
            id:    i
            typ:   if i in [2, 4] { float_t } else { int_t }
            kind:  .constant
            name:  i.str()
            index: i
        }
    }
    m.values[6] = mir.Value{
        id:    6
        typ:   struct9_t
        kind:  .instruction
        name:  'v6'
        index: 0
    }
    m.values[7] = mir.Value{
        id:    7
        typ:   int_t
        kind:  .instruction
        name:  'v7'
        index: 1
    }
    m.instrs[0] = mir.Instruction{
        op:       if sret { .call_sret } else { .call }
        operands: if sret { [ssa.ValueID(0), 1, 2] } else { [ssa.ValueID(0), 1, 2, 3, 4, 5] }
        typ:      if sret { struct9_t } else { int_t }
        block:    0
    }
    m.instrs[1] = mir.Instruction{
        op:       .ret
        operands: []ssa.ValueID{}
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 0
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(6), 7]
    }
    m.funcs[0] = mir.Function{
        id:     0
        name:   'caller'
        typ:    0
        blocks: [ssa.BlockID(0)]
    }
    return m
}

fn emit_x64_abi_indirect_f64_call_with_callee_in_rax(sret bool) []u8 {
    mut mod := new_x64_abi_indirect_f64_call_module(sret)
    mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)
    gen.stack_map = {
        1: -8
        2: -24
    }
    gen.reg_map = {
        0: int(rax)
    }
    gen.gen_instr(2)
    return gen.elf.text_data
}

fn new_x64_abi_indirect_f64_call_module(sret bool) mir.Module {
    mut ts := ssa.TypeStore.new()
    i64_t := ts.get_int(64)
    f64_t := ts.get_float(64)
    ret_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [i64_t, i64_t, i64_t]
    })
    fn_t := ts.register(ssa.Type{
        kind:     .func_t
        params:   [f64_t]
        ret_type: if sret { ret_t } else { i64_t }
    })
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 5}
        instrs:     []mir.Instruction{len: 2}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   fn_t
        kind:  .argument
        name:  'callee'
        index: 0
    }
    m.values[1] = mir.Value{
        id:    1
        typ:   f64_t
        kind:  .argument
        name:  'arg'
        index: 1
    }
    m.values[2] = mir.Value{
        id:    2
        typ:   if sret { ret_t } else { i64_t }
        kind:  .instruction
        name:  'call'
        index: 0
    }
    m.values[3] = mir.Value{
        id:    3
        typ:   0
        kind:  .instruction
        name:  'ret'
        index: 1
    }
    m.values[4] = mir.Value{
        id:    4
        typ:   0
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:               if sret { .call_sret } else { .call }
        operands:         [ssa.ValueID(0), 1]
        typ:              if sret { ret_t } else { i64_t }
        block:            0
        abi_ret_indirect: sret
        abi_arg_class:    [.in_reg]
    }
    m.instrs[1] = mir.Instruction{
        op:       .ret
        operands: []ssa.ValueID{}
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 4
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(2), 3]
    }
    m.funcs[0] = mir.Function{
        id:     0
        name:   'caller'
        typ:    0
        blocks: [ssa.BlockID(0)]
        params: [ssa.ValueID(0), 1]
    }
    return m
}

fn new_x64_abi_sret_indirect_receiver_call_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    int_t := ts.get_int(64)
    array_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [int_t, int_t, int_t, int_t]
    })
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 8}
        instrs:     []mir.Instruction{len: 2}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   array_t
        kind:  .func_ref
        name:  'array__slice'
        index: 0
    }
    m.values[1] = mir.Value{
        id:    1
        typ:   array_t
        kind:  .argument
        name:  'receiver'
        index: 1
    }
    m.values[2] = mir.Value{
        id:    2
        typ:   int_t
        kind:  .constant
        name:  '1'
        index: 2
    }
    m.values[3] = mir.Value{
        id:    3
        typ:   int_t
        kind:  .constant
        name:  '3'
        index: 3
    }
    m.values[4] = mir.Value{
        id:    4
        typ:   array_t
        kind:  .instruction
        name:  'slice'
        index: 0
    }
    m.values[5] = mir.Value{
        id:    5
        typ:   int_t
        kind:  .instruction
        name:  'ret'
        index: 1
    }
    m.values[6] = mir.Value{
        id:    6
        typ:   int_t
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.values[7] = mir.Value{
        id:    7
        typ:   int_t
        kind:  .constant
        name:  '0'
        index: 7
    }
    m.instrs[0] = mir.Instruction{
        op:               .call_sret
        operands:         [ssa.ValueID(0), 1, 2, 3]
        typ:              array_t
        block:            0
        abi_ret_indirect: true
        abi_arg_class:    [.indirect, .in_reg, .in_reg]
    }
    m.instrs[1] = mir.Instruction{
        op:       .ret
        operands: [ssa.ValueID(7)]
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 6
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(4), 5]
    }
    m.funcs[0] = mir.Function{
        id:              0
        name:            'caller'
        typ:             int_t
        blocks:          [ssa.BlockID(0)]
        params:          [ssa.ValueID(1)]
        abi_param_class: [.indirect]
    }
    return m
}

fn new_x64_abi_sret_indirect_receiver_callee_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    int_t := ts.get_int(64)
    array_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [int_t, int_t, int_t, int_t]
    })
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 6}
        instrs:     []mir.Instruction{len: 1}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   array_t
        kind:  .argument
        name:  'receiver'
        index: 0
    }
    m.values[1] = mir.Value{
        id:    1
        typ:   int_t
        kind:  .argument
        name:  'start'
        index: 1
    }
    m.values[2] = mir.Value{
        id:    2
        typ:   int_t
        kind:  .argument
        name:  'end'
        index: 2
    }
    m.values[3] = mir.Value{
        id:    3
        typ:   array_t
        kind:  .instruction
        name:  'ret'
        index: 0
    }
    m.values[4] = mir.Value{
        id:    4
        typ:   int_t
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.values[5] = mir.Value{
        id:    5
        typ:   int_t
        kind:  .constant
        name:  '0'
        index: 5
    }
    m.instrs[0] = mir.Instruction{
        op:       .ret
        operands: [ssa.ValueID(0)]
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 4
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(3)]
    }
    m.funcs[0] = mir.Function{
        id:               0
        name:             'array__slice'
        typ:              array_t
        blocks:           [ssa.BlockID(0)]
        params:           [ssa.ValueID(0), 1, 2]
        abi_ret_indirect: true
        abi_param_class:  [.indirect, .in_reg, .in_reg]
    }
    return m
}

fn new_x64_abi_struct8_call_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    int_t := ts.get_int(64)
    struct8_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [int_t]
    })
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 5}
        instrs:     []mir.Instruction{len: 2}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   int_t
        kind:  .func_ref
        name:  'callee'
        index: 0
    }
    m.values[1] = mir.Value{
        id:    1
        typ:   struct8_t
        kind:  .argument
        name:  's'
        index: 1
    }
    m.values[2] = mir.Value{
        id:    2
        typ:   int_t
        kind:  .instruction
        name:  'v2'
        index: 0
    }
    m.values[3] = mir.Value{
        id:    3
        typ:   int_t
        kind:  .instruction
        name:  'v3'
        index: 1
    }
    m.values[4] = mir.Value{
        id:    4
        typ:   int_t
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:       .call
        operands: [ssa.ValueID(0), 1]
        typ:      int_t
        block:    0
    }
    m.instrs[1] = mir.Instruction{
        op:       .ret
        operands: []ssa.ValueID{}
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 4
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(2), 3]
    }
    m.funcs[0] = mir.Function{
        id:     0
        name:   'caller'
        typ:    0
        blocks: [ssa.BlockID(0)]
        params: [ssa.ValueID(1)]
    }
    return m
}

fn new_x64_abi_stack_indirect_aggregate_call_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    int_t := ts.get_int(64)
    struct16_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [int_t, int_t]
    })
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 10}
        instrs:     []mir.Instruction{len: 2}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   int_t
        kind:  .func_ref
        name:  'callee'
        index: 0
    }
    for i in 1 .. 5 {
        m.values[i] = mir.Value{
            id:    i
            typ:   int_t
            kind:  .constant
            name:  i.str()
            index: i
        }
    }
    m.values[5] = mir.Value{
        id:    5
        typ:   struct16_t
        kind:  .argument
        name:  's'
        index: 5
    }
    m.values[6] = mir.Value{
        id:    6
        typ:   int_t
        kind:  .instruction
        name:  'v6'
        index: 0
    }
    m.values[7] = mir.Value{
        id:    7
        typ:   int_t
        kind:  .instruction
        name:  'v7'
        index: 1
    }
    m.values[8] = mir.Value{
        id:    8
        typ:   int_t
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.values[9] = mir.Value{
        id:    9
        typ:   int_t
        kind:  .constant
        name:  '0'
        index: 9
    }
    m.instrs[0] = mir.Instruction{
        op:            .call
        operands:      [ssa.ValueID(0), 1, 2, 3, 4, 5]
        typ:           int_t
        block:         0
        abi_arg_class: [.in_reg, .in_reg, .in_reg, .in_reg, .indirect]
    }
    m.instrs[1] = mir.Instruction{
        op:       .ret
        operands: []ssa.ValueID{}
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 8
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(6), 7]
    }
    m.funcs[0] = mir.Function{
        id:              0
        name:            'caller'
        typ:             0
        blocks:          [ssa.BlockID(0)]
        params:          [ssa.ValueID(5)]
        abi_param_class: [.indirect]
    }
    return m
}

fn new_x64_abi_fifth_nil_pointer_call_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    int_t := ts.get_int(64)
    u8_t := ts.get_int(8)
    ptr_u8_t := ts.get_ptr(u8_t)
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 9}
        instrs:     []mir.Instruction{len: 2}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   int_t
        kind:  .func_ref
        name:  'callee'
        index: 0
    }
    for i in 1 .. 5 {
        m.values[i] = mir.Value{
            id:    i
            typ:   int_t
            kind:  .constant
            name:  i.str()
            index: i
        }
    }
    m.values[5] = mir.Value{
        id:    5
        typ:   ptr_u8_t
        kind:  .constant
        name:  '0'
        index: 5
    }
    m.values[6] = mir.Value{
        id:    6
        typ:   int_t
        kind:  .instruction
        name:  'call'
        index: 0
    }
    m.values[7] = mir.Value{
        id:    7
        typ:   0
        kind:  .instruction
        name:  'ret'
        index: 1
    }
    m.values[8] = mir.Value{
        id:    8
        typ:   0
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:       .call
        operands: [ssa.ValueID(0), 1, 2, 3, 4, 5]
        typ:      int_t
        block:    0
    }
    m.instrs[1] = mir.Instruction{
        op:       .ret
        operands: []ssa.ValueID{}
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 8
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(6), 7]
    }
    m.funcs[0] = mir.Function{
        id:     0
        name:   'caller'
        typ:    0
        blocks: [ssa.BlockID(0)]
    }
    return m
}

fn new_x64_abi_writefile_like_pointer_call_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    int_t := ts.get_int(64)
    u32_t := ts.get_int(32)
    u8_t := ts.get_int(8)
    ptr_u32_t := ts.get_ptr(u32_t)
    ptr_u8_t := ts.get_ptr(u8_t)
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 9}
        instrs:     []mir.Instruction{len: 3}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   int_t
        kind:  .func_ref
        name:  'callee'
        index: 0
    }
    for i in 1 .. 4 {
        m.values[i] = mir.Value{
            id:    i
            typ:   int_t
            kind:  .constant
            name:  i.str()
            index: i
        }
    }
    m.values[4] = mir.Value{
        id:    4
        typ:   ptr_u32_t
        kind:  .instruction
        name:  'written'
        index: 0
    }
    m.values[5] = mir.Value{
        id:    5
        typ:   ptr_u8_t
        kind:  .constant
        name:  '0'
        index: 5
    }
    m.values[6] = mir.Value{
        id:    6
        typ:   int_t
        kind:  .instruction
        name:  'call'
        index: 1
    }
    m.values[7] = mir.Value{
        id:    7
        typ:   0
        kind:  .instruction
        name:  'ret'
        index: 2
    }
    m.values[8] = mir.Value{
        id:    8
        typ:   0
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:       .alloca
        operands: []ssa.ValueID{}
        typ:      ptr_u32_t
        block:    0
    }
    m.instrs[1] = mir.Instruction{
        op:       .call
        operands: [ssa.ValueID(0), 1, 2, 3, 4, 5]
        typ:      int_t
        block:    0
    }
    m.instrs[2] = mir.Instruction{
        op:       .ret
        operands: []ssa.ValueID{}
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 8
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(4), 6, 7]
    }
    m.funcs[0] = mir.Function{
        id:     0
        name:   'caller'
        typ:    0
        blocks: [ssa.BlockID(0)]
    }
    return m
}

fn new_x64_abi_writefile_buffer_pointer_call_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    int_t := ts.get_int(64)
    u32_t := ts.get_int(32)
    u8_t := ts.get_int(8)
    ptr_u32_t := ts.get_ptr(u32_t)
    ptr_u8_t := ts.get_ptr(u8_t)
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 9}
        instrs:     []mir.Instruction{len: 4}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   int_t
        kind:  .func_ref
        name:  'callee'
        index: 0
    }
    m.values[1] = mir.Value{
        id:    1
        typ:   int_t
        kind:  .constant
        name:  '1'
        index: 1
    }
    m.values[2] = mir.Value{
        id:    2
        typ:   ptr_u8_t
        kind:  .instruction
        name:  'buf'
        index: 0
    }
    m.values[3] = mir.Value{
        id:    3
        typ:   int_t
        kind:  .constant
        name:  '1'
        index: 3
    }
    m.values[4] = mir.Value{
        id:    4
        typ:   ptr_u32_t
        kind:  .instruction
        name:  'written'
        index: 1
    }
    m.values[5] = mir.Value{
        id:    5
        typ:   ptr_u8_t
        kind:  .constant
        name:  '0'
        index: 5
    }
    m.values[6] = mir.Value{
        id:    6
        typ:   int_t
        kind:  .instruction
        name:  'call'
        index: 2
    }
    m.values[7] = mir.Value{
        id:    7
        typ:   0
        kind:  .instruction
        name:  'ret'
        index: 3
    }
    m.values[8] = mir.Value{
        id:    8
        typ:   0
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:       .alloca
        operands: []ssa.ValueID{}
        typ:      ptr_u8_t
        block:    0
    }
    m.instrs[1] = mir.Instruction{
        op:       .alloca
        operands: []ssa.ValueID{}
        typ:      ptr_u32_t
        block:    0
    }
    m.instrs[2] = mir.Instruction{
        op:       .call
        operands: [ssa.ValueID(0), 1, 2, 3, 4, 5]
        typ:      int_t
        block:    0
    }
    m.instrs[3] = mir.Instruction{
        op:       .ret
        operands: []ssa.ValueID{}
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 8
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(2), 4, 6, 7]
    }
    m.funcs[0] = mir.Function{
        id:     0
        name:   'caller'
        typ:    0
        blocks: [ssa.BlockID(0)]
    }
    return m
}

fn new_x64_abi_indirect_string_literal_call_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    i64_t := ts.get_int(64)
    i32_t := ts.get_int(32)
    i8_t := ts.get_int(8)
    ptr_u8_t := ts.get_ptr(i8_t)
    string_t := ts.register(ssa.Type{
        kind:        .struct_t
        fields:      [ptr_u8_t, i32_t, i32_t]
        field_names: ['str', 'len', 'is_lit']
    })
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 5}
        instrs:     []mir.Instruction{len: 2}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   i64_t
        kind:  .func_ref
        name:  'callee'
        index: 0
    }
    m.values[1] = mir.Value{
        id:    1
        typ:   string_t
        kind:  .string_literal
        name:  'hello'
        index: 5
    }
    m.values[2] = mir.Value{
        id:    2
        typ:   i64_t
        kind:  .instruction
        name:  'call'
        index: 0
    }
    m.values[3] = mir.Value{
        id:    3
        typ:   0
        kind:  .instruction
        name:  'ret'
        index: 1
    }
    m.values[4] = mir.Value{
        id:    4
        typ:   0
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:            .call
        operands:      [ssa.ValueID(0), 1]
        typ:           i64_t
        block:         0
        abi_arg_class: [.indirect]
    }
    m.instrs[1] = mir.Instruction{
        op:       .ret
        operands: []ssa.ValueID{}
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 4
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(2), 3]
    }
    m.funcs[0] = mir.Function{
        id:     0
        name:   'caller'
        typ:    0
        blocks: [ssa.BlockID(0)]
    }
    return m
}

fn x64_abi_integer_pair_return_class() mir.AbiValueClass {
    return mir.AbiValueClass{
        mode:    .direct
        size:    16
        classes: [.integer, .integer]
    }
}

fn x64_abi_mixed_aggregate_class() mir.AbiValueClass {
    return mir.AbiValueClass{
        mode:    .direct
        size:    16
        classes: [.integer, .sse]
    }
}

fn x64_abi_sse_pair_class() mir.AbiValueClass {
    return mir.AbiValueClass{
        mode:    .direct
        size:    16
        classes: [.sse, .sse]
    }
}

fn x64_abi_sseup_aggregate_class() mir.AbiValueClass {
    return mir.AbiValueClass{
        mode:    .direct
        size:    16
        classes: [.sse, .sseup]
    }
}

fn x64_abi_mixed_aggregate_layout() mir.AbiValueLayout {
    value_class := x64_abi_mixed_aggregate_class()
    return mir.AbiValueLayout{
        value_class: value_class
        locs:        [
            mir.AbiLocation{
                kind:   .int_reg
                index:  0
                offset: 0
                class:  .integer
            },
            mir.AbiLocation{
                kind:   .sse_reg
                index:  0
                offset: 8
                class:  .sse
            },
        ]
    }
}

fn x64_abi_sret_mixed_aggregate_arg_layout() mir.AbiValueLayout {
    value_class := x64_abi_mixed_aggregate_class()
    return mir.AbiValueLayout{
        value_class: value_class
        locs:        [
            mir.AbiLocation{
                kind:   .int_reg
                index:  1
                offset: 0
                class:  .integer
            },
            mir.AbiLocation{
                kind:   .sse_reg
                index:  0
                offset: 8
                class:  .sse
            },
        ]
    }
}

fn x64_abi_sse_pair_layout() mir.AbiValueLayout {
    value_class := x64_abi_sse_pair_class()
    return mir.AbiValueLayout{
        value_class: value_class
        locs:        [
            mir.AbiLocation{
                kind:   .sse_reg
                index:  0
                offset: 0
                class:  .sse
            },
            mir.AbiLocation{
                kind:   .sse_reg
                index:  1
                offset: 8
                class:  .sse
            },
        ]
    }
}

fn x64_abi_sseup_aggregate_layout() mir.AbiValueLayout {
    value_class := x64_abi_sseup_aggregate_class()
    return mir.AbiValueLayout{
        value_class: value_class
        locs:        [
            mir.AbiLocation{
                kind:   .sse_reg
                index:  0
                offset: 0
                class:  .sse
            },
            mir.AbiLocation{
                kind:   .sse_reg
                index:  0
                offset: 8
                class:  .sseup
            },
        ]
    }
}

fn new_x64_abi_pair_return_call_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    int_t := ts.get_int(64)
    pair_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [int_t, int_t]
    })
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 4}
        instrs:     []mir.Instruction{len: 2}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   pair_t
        kind:  .func_ref
        name:  'callee'
        index: 0
    }
    m.values[1] = mir.Value{
        id:    1
        typ:   pair_t
        kind:  .instruction
        name:  'pair'
        index: 0
    }
    m.values[2] = mir.Value{
        id:    2
        typ:   0
        kind:  .instruction
        name:  'ret'
        index: 1
    }
    m.values[3] = mir.Value{
        id:    3
        typ:   0
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:            .call
        operands:      [ssa.ValueID(0)]
        typ:           pair_t
        block:         0
        abi_ret_class: x64_abi_integer_pair_return_class()
    }
    m.instrs[1] = mir.Instruction{
        op:       .ret
        operands: []ssa.ValueID{}
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 3
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(1), 2]
    }
    m.funcs[0] = mir.Function{
        id:     0
        name:   'caller'
        typ:    0
        blocks: [ssa.BlockID(0)]
    }
    return m
}

fn new_x64_abi_pair_return_callee_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    int_t := ts.get_int(64)
    pair_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [int_t, int_t]
    })
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 3}
        instrs:     []mir.Instruction{len: 1}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   pair_t
        kind:  .argument
        name:  'pair'
        index: 0
    }
    m.values[1] = mir.Value{
        id:    1
        typ:   0
        kind:  .instruction
        name:  'ret'
        index: 0
    }
    m.values[2] = mir.Value{
        id:    2
        typ:   0
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:       .ret
        operands: [ssa.ValueID(0)]
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 2
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(1)]
    }
    m.funcs[0] = mir.Function{
        id:            0
        name:          'callee'
        typ:           pair_t
        blocks:        [ssa.BlockID(0)]
        params:        [ssa.ValueID(0)]
        abi_ret_class: x64_abi_integer_pair_return_class()
    }
    return m
}

fn new_x64_abi_mixed_aggregate_call_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    i64_t := ts.get_int(64)
    f64_t := ts.get_float(64)
    mixed_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [i64_t, f64_t]
    })
    layout := x64_abi_mixed_aggregate_layout()
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 5}
        instrs:     []mir.Instruction{len: 2}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   i64_t
        kind:  .func_ref
        name:  'callee'
        index: 0
    }
    m.values[1] = mir.Value{
        id:    1
        typ:   mixed_t
        kind:  .argument
        name:  'mixed'
        index: 0
    }
    m.values[2] = mir.Value{
        id:    2
        typ:   i64_t
        kind:  .instruction
        name:  'call'
        index: 0
    }
    m.values[3] = mir.Value{
        id:    3
        typ:   0
        kind:  .instruction
        name:  'ret'
        index: 1
    }
    m.values[4] = mir.Value{
        id:    4
        typ:   0
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:              .call
        operands:        [ssa.ValueID(0), 1]
        typ:             i64_t
        block:           0
        abi_arg_class:   [.in_reg]
        abi_arg_classes: [layout.value_class]
        abi_arg_layouts: [layout]
    }
    m.instrs[1] = mir.Instruction{
        op:       .ret
        operands: []ssa.ValueID{}
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 4
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(2), 3]
    }
    m.funcs[0] = mir.Function{
        id:                0
        name:              'caller'
        typ:               0
        blocks:            [ssa.BlockID(0)]
        params:            [ssa.ValueID(1)]
        abi_param_classes: [layout.value_class]
        abi_param_layouts: [layout]
    }
    return m
}

fn new_x64_abi_sret_mixed_aggregate_call_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    i64_t := ts.get_int(64)
    f64_t := ts.get_float(64)
    ret_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [i64_t, i64_t, i64_t]
    })
    mixed_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [i64_t, f64_t]
    })
    layout := x64_abi_sret_mixed_aggregate_arg_layout()
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 5}
        instrs:     []mir.Instruction{len: 2}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   ret_t
        kind:  .func_ref
        name:  'callee'
        index: 0
    }
    m.values[1] = mir.Value{
        id:    1
        typ:   mixed_t
        kind:  .argument
        name:  'mixed'
        index: 0
    }
    m.values[2] = mir.Value{
        id:    2
        typ:   ret_t
        kind:  .instruction
        name:  'call'
        index: 0
    }
    m.values[3] = mir.Value{
        id:    3
        typ:   0
        kind:  .instruction
        name:  'ret'
        index: 1
    }
    m.values[4] = mir.Value{
        id:    4
        typ:   0
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:               .call_sret
        operands:         [ssa.ValueID(0), 1]
        typ:              ret_t
        block:            0
        abi_ret_indirect: true
        abi_arg_class:    [.in_reg]
        abi_arg_classes:  [layout.value_class]
        abi_arg_layouts:  [layout]
    }
    m.instrs[1] = mir.Instruction{
        op:       .ret
        operands: []ssa.ValueID{}
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 4
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(2), 3]
    }
    m.funcs[0] = mir.Function{
        id:     0
        name:   'caller'
        typ:    0
        blocks: [ssa.BlockID(0)]
    }
    return m
}

fn new_x64_abi_sse_pair_aggregate_call_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    i64_t := ts.get_int(64)
    f64_t := ts.get_float(64)
    pair_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [f64_t, f64_t]
    })
    layout := x64_abi_sse_pair_layout()
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 5}
        instrs:     []mir.Instruction{len: 2}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   i64_t
        kind:  .func_ref
        name:  'callee'
        index: 0
    }
    m.values[1] = mir.Value{
        id:    1
        typ:   pair_t
        kind:  .argument
        name:  'pair'
        index: 0
    }
    m.values[2] = mir.Value{
        id:    2
        typ:   i64_t
        kind:  .instruction
        name:  'call'
        index: 0
    }
    m.values[3] = mir.Value{
        id:    3
        typ:   0
        kind:  .instruction
        name:  'ret'
        index: 1
    }
    m.values[4] = mir.Value{
        id:    4
        typ:   0
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:              .call
        operands:        [ssa.ValueID(0), 1]
        typ:             i64_t
        block:           0
        abi_arg_class:   [.in_reg]
        abi_arg_classes: [layout.value_class]
        abi_arg_layouts: [layout]
    }
    m.instrs[1] = mir.Instruction{
        op:       .ret
        operands: []ssa.ValueID{}
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 4
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(2), 3]
    }
    m.funcs[0] = mir.Function{
        id:                0
        name:              'caller'
        typ:               0
        blocks:            [ssa.BlockID(0)]
        params:            [ssa.ValueID(1)]
        abi_param_classes: [layout.value_class]
        abi_param_layouts: [layout]
    }
    return m
}

fn new_x64_abi_sseup_aggregate_call_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    i64_t := ts.get_int(64)
    f128_t := ts.get_float(128)
    sseup_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [f128_t]
    })
    layout := x64_abi_sseup_aggregate_layout()
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 5}
        instrs:     []mir.Instruction{len: 2}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   i64_t
        kind:  .func_ref
        name:  'callee'
        index: 0
    }
    m.values[1] = mir.Value{
        id:    1
        typ:   sseup_t
        kind:  .argument
        name:  'vector'
        index: 0
    }
    m.values[2] = mir.Value{
        id:    2
        typ:   i64_t
        kind:  .instruction
        name:  'call'
        index: 0
    }
    m.values[3] = mir.Value{
        id:    3
        typ:   0
        kind:  .instruction
        name:  'ret'
        index: 1
    }
    m.values[4] = mir.Value{
        id:    4
        typ:   0
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:              .call
        operands:        [ssa.ValueID(0), 1]
        typ:             i64_t
        block:           0
        abi_arg_class:   [.in_reg]
        abi_arg_classes: [layout.value_class]
        abi_arg_layouts: [layout]
    }
    m.instrs[1] = mir.Instruction{
        op:       .ret
        operands: []ssa.ValueID{}
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 4
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(2), 3]
    }
    m.funcs[0] = mir.Function{
        id:                0
        name:              'caller'
        typ:               0
        blocks:            [ssa.BlockID(0)]
        params:            [ssa.ValueID(1)]
        abi_param_classes: [layout.value_class]
        abi_param_layouts: [layout]
    }
    return m
}

fn new_x64_abi_sse_pair_return_call_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    f64_t := ts.get_float(64)
    pair_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [f64_t, f64_t]
    })
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 4}
        instrs:     []mir.Instruction{len: 2}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   pair_t
        kind:  .func_ref
        name:  'callee'
        index: 0
    }
    m.values[1] = mir.Value{
        id:    1
        typ:   pair_t
        kind:  .instruction
        name:  'pair'
        index: 0
    }
    m.values[2] = mir.Value{
        id:    2
        typ:   0
        kind:  .instruction
        name:  'ret'
        index: 1
    }
    m.values[3] = mir.Value{
        id:    3
        typ:   0
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:            .call
        operands:      [ssa.ValueID(0)]
        typ:           pair_t
        block:         0
        abi_ret_class: x64_abi_sse_pair_class()
    }
    m.instrs[1] = mir.Instruction{
        op:       .ret
        operands: []ssa.ValueID{}
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 3
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(1), 2]
    }
    m.funcs[0] = mir.Function{
        id:     0
        name:   'caller'
        typ:    0
        blocks: [ssa.BlockID(0)]
    }
    return m
}

fn new_x64_abi_sseup_return_call_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    f128_t := ts.get_float(128)
    sseup_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [f128_t]
    })
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 4}
        instrs:     []mir.Instruction{len: 2}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   sseup_t
        kind:  .func_ref
        name:  'callee'
        index: 0
    }
    m.values[1] = mir.Value{
        id:    1
        typ:   sseup_t
        kind:  .instruction
        name:  'vector'
        index: 0
    }
    m.values[2] = mir.Value{
        id:    2
        typ:   0
        kind:  .instruction
        name:  'ret'
        index: 1
    }
    m.values[3] = mir.Value{
        id:    3
        typ:   0
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:            .call
        operands:      [ssa.ValueID(0)]
        typ:           sseup_t
        block:         0
        abi_ret_class: x64_abi_sseup_aggregate_class()
    }
    m.instrs[1] = mir.Instruction{
        op:       .ret
        operands: []ssa.ValueID{}
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 3
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(1), 2]
    }
    m.funcs[0] = mir.Function{
        id:     0
        name:   'caller'
        typ:    0
        blocks: [ssa.BlockID(0)]
    }
    return m
}

fn new_x64_abi_mixed_return_callee_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    i64_t := ts.get_int(64)
    f64_t := ts.get_float(64)
    mixed_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [i64_t, f64_t]
    })
    layout := x64_abi_mixed_aggregate_layout()
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 4}
        instrs:     []mir.Instruction{len: 1}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   i64_t
        kind:  .constant
        name:  '0'
        index: 0
    }
    m.values[1] = mir.Value{
        id:    1
        typ:   mixed_t
        kind:  .argument
        name:  'mixed'
        index: 0
    }
    m.values[2] = mir.Value{
        id:    2
        typ:   0
        kind:  .instruction
        name:  'ret'
        index: 0
    }
    m.values[3] = mir.Value{
        id:    3
        typ:   0
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:       .ret
        operands: [ssa.ValueID(1)]
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 3
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(2)]
    }
    m.funcs[0] = mir.Function{
        id:                0
        name:              'callee'
        typ:               mixed_t
        blocks:            [ssa.BlockID(0)]
        params:            [ssa.ValueID(1)]
        abi_ret_class:     layout.value_class
        abi_param_classes: [layout.value_class]
        abi_param_layouts: [layout]
    }
    return m
}

fn new_x64_abi_sseup_return_callee_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    i64_t := ts.get_int(64)
    f128_t := ts.get_float(128)
    sseup_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [f128_t]
    })
    layout := x64_abi_sseup_aggregate_layout()
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 4}
        instrs:     []mir.Instruction{len: 1}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   i64_t
        kind:  .constant
        name:  '0'
        index: 0
    }
    m.values[1] = mir.Value{
        id:    1
        typ:   sseup_t
        kind:  .argument
        name:  'vector'
        index: 0
    }
    m.values[2] = mir.Value{
        id:    2
        typ:   0
        kind:  .instruction
        name:  'ret'
        index: 0
    }
    m.values[3] = mir.Value{
        id:    3
        typ:   0
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:       .ret
        operands: [ssa.ValueID(1)]
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 3
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(2)]
    }
    m.funcs[0] = mir.Function{
        id:                0
        name:              'callee'
        typ:               sseup_t
        blocks:            [ssa.BlockID(0)]
        params:            [ssa.ValueID(1)]
        abi_ret_class:     layout.value_class
        abi_param_classes: [layout.value_class]
        abi_param_layouts: [layout]
    }
    return m
}

fn new_x64_abi_callee_stack_arg_module() mir.Module {
    mut ts := ssa.TypeStore.new()
    int_t := ts.get_int(64)
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 7}
        instrs:     []mir.Instruction{len: 1}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    for i in 0 .. 5 {
        m.values[i] = mir.Value{
            id:    i
            typ:   int_t
            kind:  .argument
            name:  'a${i}'
            index: i
        }
    }
    m.values[5] = mir.Value{
        id:    5
        typ:   int_t
        kind:  .instruction
        name:  'v5'
        index: 0
    }
    m.values[6] = mir.Value{
        id:    6
        typ:   int_t
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:       .ret
        operands: []ssa.ValueID{}
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 6
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(5)]
    }
    m.funcs[0] = mir.Function{
        id:     0
        name:   'callee'
        typ:    0
        blocks: [ssa.BlockID(0)]
        params: [ssa.ValueID(0), 1, 2, 3, 4]
    }
    return m
}

fn new_x64_abi_indirect_aggregate_call_module(mark_indirect bool) mir.Module {
    mut ts := ssa.TypeStore.new()
    int_t := ts.get_int(64)
    struct16_t := ts.register(ssa.Type{
        kind:   .struct_t
        fields: [int_t, int_t]
    })
    mut m := mir.Module{
        type_store: unsafe { *ts }
        values:     []mir.Value{len: 5}
        instrs:     []mir.Instruction{len: 2}
        blocks:     []mir.BasicBlock{len: 1}
        funcs:      []mir.Function{len: 1}
    }
    m.values[0] = mir.Value{
        id:    0
        typ:   int_t
        kind:  .func_ref
        name:  'callee'
        index: 0
    }
    m.values[1] = mir.Value{
        id:    1
        typ:   struct16_t
        kind:  .argument
        name:  's'
        index: 1
    }
    m.values[2] = mir.Value{
        id:    2
        typ:   int_t
        kind:  .instruction
        name:  'v2'
        index: 0
    }
    m.values[3] = mir.Value{
        id:    3
        typ:   int_t
        kind:  .instruction
        name:  'v3'
        index: 1
    }
    m.values[4] = mir.Value{
        id:    4
        typ:   int_t
        kind:  .basic_block
        name:  'entry'
        index: 0
    }
    m.instrs[0] = mir.Instruction{
        op:            .call
        operands:      [ssa.ValueID(0), 1]
        typ:           int_t
        block:         0
        abi_arg_class: if mark_indirect { [.indirect] } else { []mir.AbiArgClass{} }
    }
    m.instrs[1] = mir.Instruction{
        op:       .ret
        operands: []ssa.ValueID{}
        typ:      0
        block:    0
    }
    m.blocks[0] = mir.BasicBlock{
        id:     0
        val_id: 4
        name:   'entry'
        parent: 0
        instrs: [ssa.ValueID(2), 3]
    }
    m.funcs[0] = mir.Function{
        id:              0
        name:            'caller'
        typ:             0
        blocks:          [ssa.BlockID(0)]
        params:          [ssa.ValueID(1)]
        abi_param_class: if mark_indirect { [.indirect] } else { []mir.AbiArgClass{} }
    }
    return m
}