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

import v2.mir
import v2.ssa
import encoding.binary
import math.bits

const x64_windows_stack_probe_page_size = 4096

pub struct Gen {
	mod &mir.Module
mut:
	elf        &ElfObject
	macho      &MachOObject
	coff       &CoffObject
	obj_format ObjectFormat
	abi        X64Abi

	stack_map      map[int]int
	alloca_offsets map[int]int
	stack_size     int
	curr_offset    int

	block_offsets  map[int]int
	pending_labels map[int][]int

	// Register allocation
	reg_map   map[int]int
	used_regs []int

	cur_func_ret_type         int
	cur_func_abi_ret_indirect bool
	cur_func_abi_ret_class    mir.AbiValueClass
	sret_save_offset          int
}

struct Interval {
mut:
	val_id   int
	start    int
	end      int
	has_call bool
}

struct ReferencedWindowsCoffGlobals {
	complete bool
	indexes  map[int]bool
}

struct X64MainArgGlobals {
mut:
	argc []string
	argv []string
}

pub fn Gen.new(mod &mir.Module) &Gen {
	return &Gen{
		mod:        mod
		elf:        ElfObject.new()
		macho:      MachOObject.new()
		coff:       CoffObject.new()
		obj_format: .elf
		abi:        .sysv
	}
}

pub fn Gen.new_with_format(mod &mir.Module, obj_format ObjectFormat) &Gen {
	return Gen.new_with_format_and_abi(mod, obj_format, .sysv)
}

pub fn Gen.new_with_format_and_abi(mod &mir.Module, obj_format ObjectFormat, abi X64Abi) &Gen {
	return &Gen{
		mod:        mod
		elf:        ElfObject.new()
		macho:      MachOObject.new()
		coff:       CoffObject.new()
		obj_format: obj_format
		abi:        abi
	}
}

pub fn (mut g Gen) gen() {
	for func in g.mod.funcs {
		if func.is_c_extern {
			continue
		}
		if func.blocks.len == 0 {
			continue
		}
		g.gen_func(func)
	}

	// Generate Globals in .data
	referenced_windows_globals := g.referenced_windows_coff_globals()
	for global_index, gvar in g.mod.globals {
		if gvar.linkage == .external {
			continue
		}
		if g.omit_unreferenced_windows_coff_global(global_index, referenced_windows_globals) {
			continue
		}
		for g.data_len() % 8 != 0 {
			g.add_data_byte(0)
		}
		addr := u64(g.data_len())
		g.add_symbol(gvar.name, addr, false, .data)
		if gvar.initial_data.len > 0 {
			g.add_data(gvar.initial_data)
		} else if gvar.is_constant || g.scalar_global_initial_value_supported(gvar.typ) {
			size := g.type_size(gvar.typ)
			mut bytes := []u8{len: if size > 0 { size } else { 8 }}
			if bytes.len >= 8 {
				binary.little_endian_put_u64(mut bytes, u64(gvar.initial_value))
			} else {
				for i := 0; i < bytes.len; i++ {
					bytes[i] = u8(u64(gvar.initial_value) >> (i * 8))
				}
			}
			g.add_data(bytes)
		} else {
			size := g.type_size(gvar.typ)
			data_size := if size > 0 { size } else { 8 }
			for _ in 0 .. data_size {
				g.add_data_byte(0)
			}
		}
	}
}

fn (g Gen) referenced_windows_coff_globals() ReferencedWindowsCoffGlobals {
	mut referenced := map[int]bool{}
	if g.obj_format != .coff || g.abi != .windows {
		return ReferencedWindowsCoffGlobals{}
	}
	for func in g.mod.funcs {
		if func.is_c_extern || func.blocks.len == 0 {
			continue
		}
		for block_id in func.blocks {
			if block_id < 0 || block_id >= g.mod.blocks.len {
				return ReferencedWindowsCoffGlobals{}
			}
			block := g.mod.blocks[block_id]
			for val_id in block.instrs {
				if val_id < 0 || val_id >= g.mod.values.len {
					return ReferencedWindowsCoffGlobals{}
				}
				val := g.mod.values[val_id]
				if val.kind != .instruction || val.index < 0 || val.index >= g.mod.instrs.len {
					return ReferencedWindowsCoffGlobals{}
				}
				instr := g.mod.instrs[val.index]
				for operand_id in instr.operands {
					if operand_id < 0 || operand_id >= g.mod.values.len {
						return ReferencedWindowsCoffGlobals{}
					}
					operand := g.mod.values[operand_id]
					if operand.kind != .global {
						continue
					}
					if operand.index < 0 || operand.index >= g.mod.globals.len {
						return ReferencedWindowsCoffGlobals{}
					}
					if g.mod.globals[operand.index].linkage != .external {
						referenced[operand.index] = true
					}
				}
			}
		}
	}
	return ReferencedWindowsCoffGlobals{
		complete: true
		indexes:  referenced
	}
}

fn (g Gen) omit_unreferenced_windows_coff_global(index int, referenced ReferencedWindowsCoffGlobals) bool {
	if g.obj_format != .coff || g.abi != .windows {
		return false
	}
	if !referenced.complete {
		return false
	}
	return !referenced.indexes[index]
}

fn (g Gen) scalar_global_initial_value_supported(typ_id ssa.TypeID) bool {
	if typ_id <= 0 || typ_id >= g.mod.type_store.types.len {
		return false
	}
	typ := g.mod.type_store.types[typ_id]
	return typ.kind in [.int_t, .ptr_t]
}

fn x64_object_symbol_bare_name(name string) string {
	if name.starts_with('_') {
		return name[1..]
	}
	return name
}

fn x64_main_argc_global_name(name string) bool {
	bare_name := x64_object_symbol_bare_name(name)
	return bare_name == 'g_main_argc' || bare_name == 'builtin__g_main_argc'
}

fn x64_main_argv_global_name(name string) bool {
	bare_name := x64_object_symbol_bare_name(name)
	return bare_name == 'g_main_argv' || bare_name == 'builtin__g_main_argv'
}

fn x64_add_unique_global_name(mut names []string, name string) {
	if name !in names {
		names << name
	}
}

fn x64_enqueue_reachable_func(mut queue []string, reachable map[string]bool, name string) {
	if name != '' && !reachable[name] && name !in queue {
		queue << name
	}
}

fn (g Gen) func_by_name(name string) ?mir.Function {
	for func in g.mod.funcs {
		if func.name == name {
			return func
		}
	}
	return none
}

fn (g Gen) reachable_funcs_from_main() map[string]bool {
	mut reachable := map[string]bool{}
	mut queue := ['main']
	for queue.len > 0 {
		name := queue[0]
		queue.delete(0)
		if reachable[name] {
			continue
		}
		func := g.func_by_name(name) or { continue }
		reachable[name] = true
		for blk_id in func.blocks {
			if blk_id < 0 || blk_id >= g.mod.blocks.len {
				continue
			}
			blk := g.mod.blocks[blk_id]
			for instr_id in blk.instrs {
				if instr_id < 0 || instr_id >= g.mod.values.len {
					continue
				}
				val := g.mod.values[instr_id]
				if val.kind != .instruction || val.index < 0 || val.index >= g.mod.instrs.len {
					continue
				}
				instr := g.mod.instrs[val.index]
				for operand_id in instr.operands {
					if operand_id < 0 || operand_id >= g.mod.values.len {
						continue
					}
					operand := g.mod.values[operand_id]
					if operand.kind == .func_ref {
						x64_enqueue_reachable_func(mut queue, reachable, operand.name)
					}
				}
				if instr.op !in [.call, .call_sret, .go_call, .spawn_call]
					|| instr.operands.len == 0 {
					continue
				}
				callee_id := instr.operands[0]
				if callee_id >= 0 && callee_id < g.mod.values.len {
					callee := g.mod.values[callee_id]
					if callee.kind in [.func_ref, .unknown] {
						x64_enqueue_reachable_func(mut queue, reachable, callee.name)
					}
				}
			}
		}
	}
	return reachable
}

fn (g Gen) referenced_main_arg_globals(reachable map[string]bool) X64MainArgGlobals {
	mut refs := X64MainArgGlobals{}
	for func in g.mod.funcs {
		if !reachable[func.name] {
			continue
		}
		for blk_id in func.blocks {
			if blk_id < 0 || blk_id >= g.mod.blocks.len {
				continue
			}
			blk := g.mod.blocks[blk_id]
			for instr_id in blk.instrs {
				if instr_id < 0 || instr_id >= g.mod.values.len {
					continue
				}
				val := g.mod.values[instr_id]
				if val.kind != .instruction || val.index < 0 || val.index >= g.mod.instrs.len {
					continue
				}
				instr := g.mod.instrs[val.index]
				for operand in instr.operands {
					if operand < 0 || operand >= g.mod.values.len {
						continue
					}
					operand_val := g.mod.values[operand]
					if operand_val.kind != .global {
						continue
					}
					if x64_main_argc_global_name(operand_val.name) {
						x64_add_unique_global_name(mut refs.argc, operand_val.name)
					} else if x64_main_argv_global_name(operand_val.name) {
						x64_add_unique_global_name(mut refs.argv, operand_val.name)
					}
				}
			}
		}
	}
	return refs
}

fn (g Gen) has_defined_global(name string) bool {
	for gvar in g.mod.globals {
		if gvar.name == name && gvar.linkage != .external {
			return true
		}
	}
	return false
}

fn (mut g Gen) store_reg_to_global_symbol(reg Reg, name string, size int) {
	sym_idx := g.add_undefined(name)
	asm_lea_reg_rip(mut g, r10)
	g.add_rip_reloc(sym_idx)
	g.emit_u32(0)
	asm_store_mem_base_disp_reg_size(mut g, r10, 0, reg, size)
}

fn (mut g Gen) maybe_store_sysv_hosted_main_args(func mir.Function) {
	if func.name != 'main' || g.abi != .sysv || g.obj_format !in [.elf, .macho] {
		return
	}
	reachable := g.reachable_funcs_from_main()
	refs := g.referenced_main_arg_globals(reachable)
	for name in refs.argc {
		if g.has_defined_global(name) {
			g.store_reg_to_global_symbol(rdi, name, 4)
		}
	}
	for name in refs.argv {
		if g.has_defined_global(name) {
			g.store_reg_to_global_symbol(rsi, name, 8)
		}
	}
}

fn (mut g Gen) gen_func(func mir.Function) {
	g.curr_offset = g.text_len()
	g.stack_map = map[int]int{}
	g.alloca_offsets = map[int]int{}
	g.block_offsets = map[int]int{}
	g.pending_labels = map[int][]int{}
	g.reg_map = map[int]int{}
	g.used_regs = []int{}
	g.cur_func_ret_type = func.typ
	g.cur_func_abi_ret_indirect = func.abi_ret_indirect
	g.cur_func_abi_ret_class = func.abi_ret_class
	g.sret_save_offset = 0

	g.allocate_registers(func)

	// Start after callee-saved pushes so locals do not overlap their rbp slots.
	mut slot_offset := g.used_regs.len * 8

	// Hidden sret pointer slot (SysV: incoming in RDI, Windows: incoming in RCX)
	if func.abi_ret_indirect {
		off, next_offset := reserve_stack_bytes(slot_offset, 8, 1)
		g.sret_save_offset = off
		slot_offset = next_offset
	}

	for pi, pid in func.params {
		param_typ := g.mod.values[pid].typ
		param_size := g.type_size(param_typ)
		is_indirect_param := pi < func.abi_param_class.len && func.abi_param_class[pi] == .indirect
		if (is_indirect_param || g.value_is_aggregate(pid) || param_size > 8) && param_size > 0 {
			off, next_offset := reserve_stack_bytes(slot_offset, param_size, 16)
			g.stack_map[pid] = off
			slot_offset = next_offset
		} else {
			off, next_offset := reserve_stack_bytes(slot_offset, 8, 1)
			g.stack_map[pid] = off
			slot_offset = next_offset
		}
	}

	for blk_id in func.blocks {
		blk := g.mod.blocks[blk_id]
		for val_id in blk.instrs {
			val := g.mod.values[val_id]
			if val.kind != .instruction {
				continue
			}
			instr := g.mod.instrs[val.index]

			if instr.op == .alloca {
				// Calculate allocation size based on the type
				// The alloca result type is ptr(T), so get the element type
				ptr_type := g.mod.type_store.types[val.typ]
				alloc_size := g.alloc_size_from_uses(val_id, g.type_size(ptr_type.elem_type))

				off, next_offset := reserve_stack_bytes(slot_offset, alloc_size, 16)
				g.alloca_offsets[val_id] = off
				slot_offset = next_offset
			}

			mut val_has_stack_storage := false
			if g.value_needs_stack_storage(val_id) {
				result_size := g.stack_storage_size(val_id)
				off, next_offset := reserve_stack_bytes(slot_offset, result_size, 16)
				g.stack_map[val_id] = off
				slot_offset = next_offset
				val_has_stack_storage = true
			}

			for operand in instr.operands {
				if operand > 0 && operand < g.mod.values.len && g.value_needs_stack_storage(operand)
					&& operand !in g.stack_map {
					lit_size := g.stack_storage_size(operand)
					off, next_offset := reserve_stack_bytes(slot_offset, lit_size, 16)
					g.stack_map[operand] = off
					slot_offset = next_offset
				}
			}

			if val_has_stack_storage {
				continue
			}

			if val_id in g.reg_map {
				continue
			}
			off, next_offset := reserve_stack_bytes(slot_offset, 8, 1)
			g.stack_map[val_id] = off
			slot_offset = next_offset
		}
	}

	g.stack_size = (slot_offset + 16) & ~0xF
	if g.used_regs.len % 2 == 1 {
		g.stack_size += 8
	}

	g.add_symbol(func.name, u64(g.curr_offset), true, .text)

	// Prologue
	asm_endbr64(mut g)
	asm_push_rbp(mut g)
	asm_mov_rbp_rsp(mut g)
	g.maybe_store_sysv_hosted_main_args(func)

	// Push callee-saved regs
	for r in g.used_regs {
		asm_push(mut g, Reg(r))
	}

	g.emit_stack_allocation()

	abi_regs := g.abi.int_arg_regs()
	arg_reg_base := if func.abi_ret_indirect { 1 } else { 0 }
	mut reg_arg_idx := arg_reg_base
	mut sse_arg_idx := 0
	float_arg_regs := g.abi.float_arg_regs()
	if func.abi_ret_indirect && g.sret_save_offset != 0 {
		asm_store_rbp_disp_reg(mut g, g.sret_save_offset, g.abi.sret_reg())
	}
	mut stack_param_offset := 16
	for i, pid in func.params {
		is_indirect_param := i < func.abi_param_class.len && func.abi_param_class[i] == .indirect
		param_size := g.type_size(g.mod.values[pid].typ)
		if g.abi == .windows {
			g.move_windows_param(pid, i + arg_reg_base, is_indirect_param, param_size)
			continue
		}
		if g.value_is_float_type(pid) {
			g.ensure_float_abi_scalar(pid, 'parameter')
			if sse_arg_idx >= float_arg_regs.len {
				g.unsupported_float_abi('stack parameter', pid)
			}
			asm_store_xmm_rbp_disp(mut g, float_arg_regs[sse_arg_idx], g.stack_map[pid], param_size)
			sse_arg_idx++
			continue
		}
		if !is_indirect_param && g.value_is_aggregate(pid) && i < func.abi_param_layouts.len
			&& func.abi_param_layouts[i].locs.len > 0 {
			layout := func.abi_param_layouts[i]
			g.store_sysv_direct_aggregate_param(pid, layout)
			int_limit, sse_limit := sysv_layout_register_limits(layout)
			if int_limit > reg_arg_idx {
				reg_arg_idx = int_limit
			}
			if sse_limit > sse_arg_idx {
				sse_arg_idx = sse_limit
			}
			stack_limit := sysv_layout_stack_slot_limit(layout)
			if stack_limit > 0 {
				stack_param_offset = 16 + stack_limit * 8
			}
			continue
		}
		param_chunks := if !is_indirect_param && g.value_is_aggregate(pid) && param_size > 8
			&& param_size <= 16 {
			(param_size + 7) / 8
		} else {
			1
		}
		if reg_arg_idx + param_chunks <= abi_regs.len {
			src := abi_regs[reg_arg_idx]
			if is_indirect_param {
				g.copy_indirect_param_from_reg(pid, src)
			} else if param_chunks > 1 {
				offset := g.stack_map[pid]
				for chunk := 0; chunk < param_chunks; chunk++ {
					chunk_size := if chunk == param_chunks - 1 {
						param_size - chunk * 8
					} else {
						8
					}
					g.store_reg_to_rbp_exact(Reg(abi_regs[reg_arg_idx + chunk]),
						offset + chunk * 8, chunk_size)
				}
			} else if g.value_needs_raw_abi_reg_bytes(pid, param_size) {
				g.store_reg_to_rbp_exact(Reg(src), g.stack_map[pid], param_size)
			} else if reg := g.reg_map[pid] {
				asm_mov_reg_reg(mut g, Reg(reg), Reg(src))
			} else {
				offset := g.stack_map[pid]
				asm_store_rbp_disp_reg(mut g, offset, Reg(src))
			}
			reg_arg_idx += param_chunks
		} else {
			// Stack parameters start at [rbp+16].
			if is_indirect_param {
				// Load pointer from stack into RAX, then copy through it.
				asm_load_reg_rbp_disp(mut g, rax, stack_param_offset)
				g.copy_indirect_param_from_reg(pid, int(rax))
			} else if param_chunks > 1 {
				g.copy_memory(int(rbp), g.stack_map[pid], int(rbp), stack_param_offset, param_size)
			} else if g.value_needs_raw_abi_reg_bytes(pid, param_size) {
				asm_load_reg_rbp_disp(mut g, rax, stack_param_offset)
				g.store_reg_to_rbp_exact(rax, g.stack_map[pid], param_size)
			} else if reg := g.reg_map[pid] {
				asm_load_reg_rbp_disp(mut g, rax, stack_param_offset)
				asm_mov_reg_reg(mut g, Reg(reg), rax)
			} else {
				asm_load_reg_rbp_disp(mut g, rax, stack_param_offset)
				offset := g.stack_map[pid]
				asm_store_rbp_disp_reg(mut g, offset, rax)
			}
			stack_param_offset += g.param_stack_slots(is_indirect_param, param_chunks, param_size) * 8
		}
	}

	for blk_id in func.blocks {
		blk := g.mod.blocks[blk_id]
		g.block_offsets[blk_id] = g.text_len() - g.curr_offset

		if offsets := g.pending_labels[blk_id] {
			for off in offsets {
				target := g.block_offsets[blk_id]
				rel := target - (off + 4)
				abs_off := g.curr_offset + off
				g.write_u32(abs_off, u32(rel))
			}
		}

		for val_id in blk.instrs {
			g.gen_instr(val_id)
		}
	}
}

// slot_offset is the number of bytes already reserved below rbp.
fn reserve_stack_bytes(slot_offset int, size int, align int) (int, int) {
	mut next_offset := slot_offset
	if align > 1 && slot_offset % align != 0 {
		next_offset = ((slot_offset + align - 1) / align) * align
	}
	alloc_size := if size > 0 { size } else { 8 }
	next_offset += alloc_size
	return -next_offset, next_offset
}

fn (mut g Gen) emit_stack_allocation() {
	if g.stack_size <= 0 {
		return
	}
	if g.abi == .windows && g.stack_size >= x64_windows_stack_probe_page_size {
		g.emit_windows_stack_probe_allocation(g.stack_size)
		return
	}
	g.emit_stack_sub(g.stack_size)
}

fn (mut g Gen) emit_stack_sub(size int) {
	if size <= 0 {
		return
	}
	if size <= 127 {
		asm_sub_rsp_imm8(mut g, u8(size))
	} else {
		asm_sub_rsp_imm32(mut g, u32(size))
	}
}

fn (mut g Gen) emit_windows_stack_probe_allocation(size int) {
	mut remaining := size
	for remaining > x64_windows_stack_probe_page_size {
		g.emit_stack_sub(x64_windows_stack_probe_page_size)
		asm_test_byte_ptr_rsp_zero(mut g)
		remaining -= x64_windows_stack_probe_page_size
	}
	g.emit_stack_sub(remaining)
	asm_test_byte_ptr_rsp_zero(mut g)
}

fn (mut g Gen) move_windows_param(pid int, position int, is_indirect_param bool, param_size int) {
	if g.value_is_float_type(pid) {
		g.ensure_float_abi_scalar(pid, 'parameter')
		if position < 4 {
			asm_store_xmm_rbp_disp(mut g, g.abi.float_arg_reg_for_position(position),
				g.stack_map[pid], param_size)
		} else {
			asm_load_xmm_mem_base_disp_size(mut g, 0, rbp, g.abi.stack_arg_offset(position),
				param_size)
			asm_store_xmm_rbp_disp(mut g, 0, g.stack_map[pid], param_size)
		}
		return
	}
	param_is_indirect := g.windows_value_passed_indirect(pid, is_indirect_param, param_size)
	g.ensure_windows_scalar_or_indirect_arg(pid, param_is_indirect, param_size)
	if position < 4 {
		src := g.abi.int_arg_reg_for_position(position)
		if param_is_indirect {
			g.copy_indirect_param_from_reg(pid, src)
		} else if g.value_needs_raw_abi_reg_bytes(pid, param_size) {
			g.store_reg_to_rbp_exact(Reg(src), g.stack_map[pid], param_size)
		} else if reg := g.reg_map[pid] {
			asm_mov_reg_reg(mut g, Reg(reg), Reg(src))
		} else {
			asm_store_rbp_disp_reg(mut g, g.stack_map[pid], Reg(src))
		}
		return
	}
	stack_param_offset := g.abi.stack_arg_offset(position)
	if param_is_indirect {
		asm_load_reg_rbp_disp(mut g, rax, stack_param_offset)
		g.copy_indirect_param_from_reg(pid, int(rax))
	} else if g.value_needs_raw_abi_reg_bytes(pid, param_size) {
		asm_load_reg_rbp_disp(mut g, rax, stack_param_offset)
		g.store_reg_to_rbp_exact(rax, g.stack_map[pid], param_size)
	} else if reg := g.reg_map[pid] {
		asm_load_reg_rbp_disp(mut g, rax, stack_param_offset)
		asm_mov_reg_reg(mut g, Reg(reg), rax)
	} else {
		asm_load_reg_rbp_disp(mut g, rax, stack_param_offset)
		asm_store_rbp_disp_reg(mut g, g.stack_map[pid], rax)
	}
}

fn (mut g Gen) gen_instr(val_id int) {
	instr := g.mod.instrs[g.mod.values[val_id].index]
	op := g.selected_opcode(instr)

	// Temps: 0=RAX, 1=RCX

	match op {
		.add, .sub, .mul, .sdiv, .udiv, .srem, .urem, .and_, .or_, .xor, .shl, .ashr, .lshr, .eq,
		.ne, .lt, .gt, .le, .ge, .ult, .ugt, .ule, .uge {
			if op in [.eq, .ne, .lt, .gt, .le, .ge] && g.value_is_float_type(instr.operands[0]) {
				g.emit_float_compare(op, instr.operands[0], instr.operands[1], val_id)
				return
			}
			g.load_val_to_reg(0, instr.operands[0]) // RAX
			g.load_val_to_reg(1, instr.operands[1]) // RCX

			match op {
				.add {
					asm_add_rax_rcx(mut g)
				}
				.sub {
					asm_sub_rax_rcx(mut g)
				}
				.mul {
					asm_imul_rax_rcx(mut g)
				}
				.sdiv {
					asm_cqo(mut g)
					asm_idiv_rcx(mut g)
				}
				.udiv {
					asm_xor_edx_edx(mut g)
					asm_div_rcx(mut g)
				}
				.srem {
					asm_cqo(mut g)
					asm_idiv_rcx(mut g)
					asm_mov_rax_rdx(mut g)
				}
				.urem {
					asm_xor_edx_edx(mut g)
					asm_div_rcx(mut g)
					asm_mov_rax_rdx(mut g)
				}
				.and_ {
					asm_and_rax_rcx(mut g)
				}
				.or_ {
					asm_or_rax_rcx(mut g)
				}
				.xor {
					asm_xor_rax_rcx(mut g)
				}
				.shl {
					asm_shl_rax_cl(mut g)
				}
				.ashr {
					asm_sar_rax_cl(mut g)
				}
				.lshr {
					asm_shr_rax_cl(mut g)
				}
				.eq, .ne, .lt, .gt, .le, .ge, .ult, .ugt, .ule, .uge {
					asm_cmp_rax_rcx(mut g)
					cc := match op {
						.eq { cc_e }
						.ne { cc_ne }
						.lt { cc_l }
						.gt { cc_g }
						.le { cc_le }
						.ge { cc_ge }
						.ult { cc_b }
						.ugt { cc_a }
						.ule { cc_be }
						.uge { cc_ae }
						else { cc_e }
					}

					asm_setcc_al_movzx(mut g, cc)
				}
				else {}
			}

			g.store_reg_to_val(0, val_id)
		}
		.store {
			src_id := instr.operands[0]
			dst_id := instr.operands[1]
			src_typ := g.mod.values[src_id].typ
			src_type_info := g.mod.type_store.types[src_typ]
			src_size := g.type_size(src_typ)
			if src_type_info.kind in [.struct_t, .array_t] || src_size > 8 {
				g.load_struct_src_address_to_reg(int(r10), src_id, src_typ)
				g.load_val_to_reg(int(r11), dst_id)
				g.copy_memory(int(r11), 0, int(r10), 0, src_size)
			} else {
				store_size := g.scalar_store_size_for_pointer_destination(dst_id, src_size)
				if g.value_is_float_type(src_id) && src_size in [4, 8] && store_size == src_size {
					g.load_val_to_reg(1, dst_id) // Ptr -> RCX
					g.load_float_val_to_xmm(0, src_id, src_size)
					asm_store_xmm_mem_base_disp_size(mut g, 0, rcx, 0, src_size)
					return
				}
				g.load_val_to_reg(0, src_id) // Val -> RAX
				g.load_val_to_reg(1, dst_id) // Ptr -> RCX
				asm_store_mem_base_disp_reg_size(mut g, rcx, 0, rax, store_size)
			}
		}
		.load {
			g.load_val_to_reg(1, instr.operands[0]) // Ptr -> RCX
			load_size := g.type_size(instr.typ)
			load_type_info := g.mod.type_store.types[instr.typ]
			if load_type_info.kind in [.struct_t, .array_t] || load_size > 8 {
				g.copy_memory(int(rbp), g.stack_map[val_id], int(rcx), 0, load_size)
			} else {
				g.load_typed_mem_to_reg(rax, rcx, 0, instr.typ, load_size)
				g.store_reg_to_val(0, val_id)
			}
		}
		.alloca {
			off := g.alloca_offsets[val_id]
			g.zero_large_fixed_array_alloca(val_id, off)
			asm_lea_reg_rbp_disp(mut g, rax, off)
			g.store_reg_to_val(0, val_id)
		}
		.heap_alloc {
			alloc_size := g.heap_alloc_size(val_id)
			cleanup := g.emit_windows_call_frame(0)
			if g.abi == .windows {
				asm_mov_reg_imm32(mut g, rcx, 1)
				asm_mov_reg_imm64(mut g, rdx, u64(alloc_size))
			} else {
				asm_mov_reg_imm32(mut g, rdi, 1)
				asm_mov_reg_imm64(mut g, rsi, u64(alloc_size))
				asm_xor_eax_eax(mut g)
			}
			asm_call_rel32(mut g)
			sym_idx := g.add_undefined('calloc')
			g.add_call_reloc(sym_idx)
			g.emit_u32(0)
			g.cleanup_windows_call_frame(cleanup)
			g.store_reg_to_val(0, val_id)
		}
		.get_element_ptr {
			g.load_val_to_reg(0, instr.operands[0]) // Base -> RAX
			offset := g.gep_const_offset(instr.operands[0], instr.operands[1], instr.typ)
			if offset >= 0 {
				if offset > 0 {
					asm_mov_reg_imm64(mut g, rcx, u64(offset))
					asm_add_rax_rcx(mut g)
				}
			} else {
				g.load_val_to_reg(1, instr.operands[1]) // Index -> RCX
				elem_size := g.gep_elem_size(instr.operands[0])
				if elem_size == 8 {
					asm_shl_rcx_3(mut g)
				} else if elem_size > 1 {
					asm_mov_reg_reg(mut g, rax, rcx)
					asm_mov_reg_imm64(mut g, rcx, u64(elem_size))
					asm_imul_rax_rcx(mut g)
					asm_mov_reg_reg(mut g, rcx, rax)
					g.load_val_to_reg(0, instr.operands[0])
				}
				asm_add_rax_rcx(mut g)
			}
			g.store_reg_to_val(0, val_id)
		}
		.call {
			abi_regs := g.abi.int_arg_regs()
			num_args := instr.operands.len - 1
			stack_args := g.call_stack_arg_mask(instr, abi_regs.len, 0)
			stack_slots := g.call_stack_slots(instr, stack_args)
			cleanup := g.prepare_call_stack_args(instr, stack_args, stack_slots, 0)
			if g.abi == .sysv && stack_slots > 0 {
				if stack_slots % 2 == 1 {
					asm_push(mut g, rax)
				}
				for arg_idx := num_args - 1; arg_idx >= 0; arg_idx-- {
					if stack_args[arg_idx] {
						g.push_call_stack_arg(instr.operands[arg_idx + 1], arg_idx, instr)
					}
				}
			}

			// Stack arguments were pushed above; this pass only loads register arguments.
			sse_arg_idx := g.load_call_register_args(instr, abi_regs, stack_args, 0)
			fn_val := g.mod.values[instr.operands[0]]
			is_direct_symbol_call := fn_val.name != '' && fn_val.kind in [.unknown, .func_ref]
			if !is_direct_symbol_call {
				g.load_val_to_reg(int(r10), instr.operands[0])
			}

			// AL carries the number of SSE argument registers for variadic calls.
			g.emit_sse_arg_count(sse_arg_idx)

			if is_direct_symbol_call {
				asm_call_rel32(mut g)
				sym_idx := g.add_undefined(fn_val.name)
				// Use R_X86_64_PLT32 (4) for function calls to support shared libraries (libc)
				g.add_call_reloc(sym_idx)
				g.emit_u32(0)
			} else {
				asm_call_r10(mut g)
			}

			// Clean up stack arguments
			if g.abi == .windows {
				g.cleanup_windows_call_frame(cleanup)
			} else if stack_slots > 0 {
				sysv_cleanup := (stack_slots + (stack_slots % 2)) * 8
				if sysv_cleanup <= 127 {
					asm_add_rsp_imm8(mut g, u8(sysv_cleanup))
				} else {
					asm_add_rsp_imm32(mut g, u32(sysv_cleanup))
				}
			}

			if g.mod.type_store.types[g.mod.values[val_id].typ].kind != .void_t {
				g.store_call_result(val_id, instr.abi_ret_class)
			}
		}
		.call_sret {
			abi_regs := if g.abi == .sysv { g.abi.int_arg_regs() } else { g.abi.sret_arg_regs() }
			num_args := instr.operands.len - 1
			arg_position_base := 1
			stack_args := g.call_stack_arg_mask(instr, abi_regs.len, arg_position_base)
			stack_slots := g.call_stack_slots(instr, stack_args)

			if g.abi != .windows {
				g.load_address_of_val_to_reg(int(g.abi.sret_reg()), val_id)
			}

			cleanup := g.prepare_call_stack_args(instr, stack_args, stack_slots, arg_position_base)
			if g.abi == .sysv && stack_slots > 0 {
				if stack_slots % 2 == 1 {
					asm_push(mut g, rax)
				}
				for arg_idx := num_args - 1; arg_idx >= 0; arg_idx-- {
					if stack_args[arg_idx] {
						g.push_call_stack_arg(instr.operands[arg_idx + 1], arg_idx, instr)
					}
				}
			}

			// Stack arguments were pushed above; this pass only loads register arguments.
			sse_arg_idx := g.load_call_register_args(instr, abi_regs, stack_args, arg_position_base)
			if g.abi == .windows {
				g.load_address_of_val_to_reg(int(g.abi.sret_reg()), val_id)
			}

			fn_val := g.mod.values[instr.operands[0]]
			is_direct_symbol_call := fn_val.name != '' && fn_val.kind in [.unknown, .func_ref]
			if !is_direct_symbol_call {
				g.load_val_to_reg(int(r10), instr.operands[0])
			}

			// AL carries the number of SSE argument registers for variadic calls.
			g.emit_sse_arg_count(sse_arg_idx)

			if is_direct_symbol_call {
				asm_call_rel32(mut g)
				sym_idx := g.add_undefined(fn_val.name)
				g.add_call_reloc(sym_idx)
				g.emit_u32(0)
			} else {
				asm_call_r10(mut g)
			}

			// Clean up stack arguments
			if g.abi == .windows {
				g.cleanup_windows_call_frame(cleanup)
			} else if stack_slots > 0 {
				sysv_cleanup := (stack_slots + (stack_slots % 2)) * 8
				if sysv_cleanup <= 127 {
					asm_add_rsp_imm8(mut g, u8(sysv_cleanup))
				} else {
					asm_add_rsp_imm32(mut g, u32(sysv_cleanup))
				}
			}
		}
		.call_indirect {
			// Indirect call through function pointer
			// operands[0] is the function pointer, rest are arguments
			abi_regs := g.abi.int_arg_regs()
			num_args := instr.operands.len - 1
			stack_args := g.call_stack_arg_mask(instr, abi_regs.len, 0)
			stack_slots := g.call_stack_slots(instr, stack_args)
			cleanup := g.prepare_call_stack_args(instr, stack_args, stack_slots, 0)
			if g.abi == .sysv && stack_slots > 0 {
				if stack_slots % 2 == 1 {
					asm_push(mut g, rax)
				}
				for arg_idx := num_args - 1; arg_idx >= 0; arg_idx-- {
					if stack_args[arg_idx] {
						g.push_call_stack_arg(instr.operands[arg_idx + 1], arg_idx, instr)
					}
				}
			}

			// Stack arguments were pushed above; this pass only loads register arguments.
			sse_arg_idx := g.load_call_register_args(instr, abi_regs, stack_args, 0)

			// Load function pointer to r10 (caller-saved, not used for args)
			g.load_val_to_reg(10, instr.operands[0])

			// AL carries the number of SSE argument registers for variadic calls.
			g.emit_sse_arg_count(sse_arg_idx)

			// call *r10
			asm_call_r10(mut g)

			// Clean up stack arguments
			if g.abi == .windows {
				g.cleanup_windows_call_frame(cleanup)
			} else if stack_slots > 0 {
				sysv_cleanup := (stack_slots + (stack_slots % 2)) * 8
				if sysv_cleanup <= 127 {
					asm_add_rsp_imm8(mut g, u8(sysv_cleanup))
				} else {
					asm_add_rsp_imm32(mut g, u32(sysv_cleanup))
				}
			}

			if g.mod.type_store.types[g.mod.values[val_id].typ].kind != .void_t {
				g.store_call_result(val_id, instr.abi_ret_class)
			}
		}
		.ret {
			if g.cur_func_abi_ret_indirect {
				if g.sret_save_offset != 0 {
					asm_load_reg_rbp_disp(mut g, g.abi.sret_reg(), g.sret_save_offset)
				}
				if instr.operands.len > 0 {
					ret_val_id := instr.operands[0]
					ret_size := g.type_size(g.cur_func_ret_type)
					if ret_size > 0 {
						g.load_struct_src_address_to_reg(int(r10), ret_val_id, g.cur_func_ret_type)
						g.copy_memory(int(g.abi.sret_reg()), 0, int(r10), 0, ret_size)
					}
				}
				asm_mov_reg_reg(mut g, rax, g.abi.sret_reg())
			} else if instr.operands.len > 0 {
				ret_val_id := instr.operands[0]
				g.ensure_windows_direct_return_supported(ret_val_id, g.cur_func_abi_ret_class,
					'direct return')
				if g.value_is_float_type(ret_val_id) {
					g.ensure_float_abi_scalar(ret_val_id, 'return')
					g.load_float_val_to_xmm(0, ret_val_id,
						g.type_size(g.mod.values[ret_val_id].typ))
				} else if g.load_sysv_direct_aggregate_return(ret_val_id, g.cur_func_abi_ret_class) {
				} else if g.load_sysv_integer_pair_return(ret_val_id, g.cur_func_abi_ret_class) {
				} else {
					g.load_val_to_reg(0, ret_val_id)
				}
			}
			g.emit_epilogue()
		}
		.jmp {
			target_idx := g.mod.values[instr.operands[0]].index
			g.emit_jmp(target_idx)
		}
		.br {
			cond_id := instr.operands[0]
			true_blk := g.mod.values[instr.operands[1]].index
			false_blk := g.mod.values[instr.operands[2]].index

			// Test condition register directly if register-allocated
			if reg := g.reg_map[cond_id] {
				asm_test_reg_reg(mut g, Reg(reg))
			} else {
				g.load_val_to_reg(0, cond_id)
				asm_test_rax_rax(mut g)
			}

			// Emit je false_blk (jump if zero/false)
			asm_je_rel32(mut g)
			g.emit_rel32_to_block(false_blk)
			// Jump to true block (can't assume it's the next block)
			g.emit_jmp(true_blk)
		}
		.switch_ {
			g.load_val_to_reg(0, instr.operands[0]) // RAX
			for i := 2; i < instr.operands.len; i += 2 {
				g.load_val_to_reg(1, instr.operands[i])
				asm_cmp_rax_rcx(mut g)
				asm_je_rel32(mut g)
				target_idx := g.mod.values[instr.operands[i + 1]].index
				g.emit_rel32_to_block(target_idx)
			}
			def_idx := g.mod.values[instr.operands[1]].index
			g.emit_jmp(def_idx)
		}
		.assign {
			dest_id := instr.operands[0]
			src_id := instr.operands[1]
			dest_size := g.type_size(g.mod.values[dest_id].typ)
			if g.value_is_aggregate(dest_id) || dest_size > 8 {
				g.copy_value_bytes(dest_id, src_id, dest_size)
			} else {
				g.load_val_to_reg(0, src_id)
				g.store_reg_to_val(0, dest_id)
			}
		}
		.bitcast, .trunc, .zext, .sext {
			if instr.operands.len > 0 {
				src_typ := g.mod.values[instr.operands[0]].typ
				dst_typ := instr.typ
				src_info := g.mod.type_store.types[src_typ]
				dst_info := g.mod.type_store.types[dst_typ]
				src_size := g.type_size(src_typ)
				dst_size := g.type_size(dst_typ)
				if op in [.trunc, .zext] && src_info.kind == .float_t && dst_info.kind == .float_t {
					g.load_float_val_to_xmm(0, instr.operands[0], src_size)
					if op == .trunc && src_size == 8 && dst_size == 4 {
						asm_cvtsd2ss_xmm0_xmm0(mut g)
					} else if op == .zext && src_size == 4 && dst_size == 8 {
						asm_cvtss2sd_xmm0_xmm0(mut g)
					} else {
						g.unsupported_numeric_conversion(op, src_size, dst_size, val_id)
					}
					asm_store_xmm0_rbp_disp(mut g, g.stack_map[val_id], dst_size)
				} else if op in [.trunc, .zext, .sext] && src_info.kind == .int_t
					&& dst_info.kind == .int_t {
					g.load_val_to_reg(0, instr.operands[0])
					if op == .trunc {
						g.normalize_integer_rax_for_type(dst_typ, op, val_id)
					} else if op == .zext {
						g.mask_rax_to_size(src_size, op, val_id)
					} else if op == .sext {
						if src_size == 1 {
							asm_movsx_rax_al(mut g)
						} else if src_size == 2 {
							asm_movsx_rax_ax(mut g)
						} else if src_size == 4 {
							asm_movsxd_rax_eax(mut g)
						} else if src_size != 8 {
							g.unsupported_numeric_conversion(op, src_size, dst_size, val_id)
						}
					}
					g.store_reg_to_val(0, val_id)
				} else if op == .bitcast {
					g.load_val_to_reg(0, instr.operands[0])
					g.store_reg_to_val(0, val_id)
				} else {
					g.unsupported_numeric_conversion(op, src_size, dst_size, val_id)
				}
			}
		}
		.sitofp, .uitofp {
			if instr.operands.len > 0 {
				g.load_val_to_reg(0, instr.operands[0])
				src_size := g.type_size(g.mod.values[instr.operands[0]].typ)
				if op == .uitofp {
					g.emit_unsigned_int_to_float(src_size, g.type_size(instr.typ), val_id)
				} else {
					g.emit_signed_int_to_float(g.type_size(instr.typ), op, val_id)
				}
				asm_store_xmm0_rbp_disp(mut g, g.stack_map[val_id], g.type_size(instr.typ))
			}
		}
		.fptosi, .fptoui {
			if instr.operands.len > 0 {
				src_size := g.type_size(g.mod.values[instr.operands[0]].typ)
				dst_size := g.type_size(instr.typ)
				g.load_float_val_to_xmm(0, instr.operands[0], src_size)
				if op == .fptoui {
					g.emit_float_to_unsigned_int(src_size, dst_size, val_id)
				} else {
					g.emit_float_to_signed_int(src_size, op, val_id)
				}
				g.store_reg_to_val(0, val_id)
			}
		}
		.fadd, .fsub, .fmul, .fdiv {
			result_size := g.type_size(instr.typ)
			g.load_float_val_to_xmm(0, instr.operands[0], result_size)
			g.load_float_val_to_xmm(1, instr.operands[1], result_size)
			opcode := match op {
				.fadd { u8(0x58) }
				.fsub { u8(0x5C) }
				.fmul { u8(0x59) }
				.fdiv { u8(0x5E) }
				else { u8(0x58) }
			}

			asm_float_binop_xmm0_xmm1(mut g, opcode, result_size)
			asm_store_xmm0_rbp_disp(mut g, g.stack_map[val_id], result_size)
		}
		.inline_string_init {
			g.zero_value_bytes(val_id, g.stack_storage_size(val_id))
			for fi, field_id in instr.operands {
				field_typ := g.struct_field_type(instr.typ, fi, g.mod.values[field_id].typ)
				g.store_field_value(val_id, instr.typ, fi, field_id, g.type_size(field_typ))
			}
		}
		.struct_init {
			g.zero_value_bytes(val_id, g.type_size(instr.typ))
			for fi, field_id in instr.operands {
				field_typ := g.struct_field_type(instr.typ, fi, g.mod.values[field_id].typ)
				g.store_field_value(val_id, instr.typ, fi, field_id, g.type_size(field_typ))
			}
		}
		.insertvalue {
			tuple_id := instr.operands[0]
			elem_id := instr.operands[1]
			idx := g.const_int_operand(instr.operands[2])
			total_size := g.type_size(instr.typ)
			if !(g.mod.values[tuple_id].kind == .constant && g.mod.values[tuple_id].name == 'undef') {
				g.copy_value_bytes(val_id, tuple_id, total_size)
			} else {
				g.zero_value_bytes(val_id, total_size)
			}
			elem_typ := g.struct_field_type(instr.typ, idx, g.mod.values[elem_id].typ)
			g.store_field_value(val_id, instr.typ, idx, elem_id, g.type_size(elem_typ))
		}
		.extractvalue {
			tuple_id := instr.operands[0]
			idx := g.const_int_operand(instr.operands[1])
			field_off := g.struct_field_offset_bytes(g.mod.values[tuple_id].typ, idx)
			result_size := g.type_size(instr.typ)
			g.load_struct_src_address_to_reg(int(r10), tuple_id, g.mod.values[tuple_id].typ)
			if result_size > 8 || g.value_is_aggregate(val_id) {
				g.copy_memory(int(rbp), g.stack_map[val_id], int(r10), field_off, result_size)
			} else {
				g.load_typed_mem_to_reg(rax, r10, field_off, instr.typ, result_size)
				g.store_reg_to_val(0, val_id)
			}
		}
		.phi {
			// Phi nodes are eliminated by optimization (converted to assignments)
			// but the instructions remain in the block. We ignore them here.
		}
		.unreachable {
			// Emit UD2 instruction (undefined trap)
			asm_ud2(mut g)
		}
		else {
			x64_unsupported('op ${op} in value ${val_id}')
		}
	}
}

fn (mut g Gen) mask_rax_to_size(size int, op ssa.OpCode, val_id int) {
	match size {
		1 {
			asm_mov_reg_imm64(mut g, rcx, 0xff)
			asm_and_rax_rcx(mut g)
		}
		2 {
			asm_mov_reg_imm64(mut g, rcx, 0xffff)
			asm_and_rax_rcx(mut g)
		}
		4 {
			asm_mov_reg_imm64(mut g, rcx, 0xffffffff)
			asm_and_rax_rcx(mut g)
		}
		8 {}
		else {
			g.unsupported_numeric_conversion(op, size, size, val_id)
		}
	}
}

fn (mut g Gen) emit_float_compare(op ssa.OpCode, lhs int, rhs int, val_id int) {
	lhs_size := g.type_size(g.mod.values[lhs].typ)
	rhs_size := g.type_size(g.mod.values[rhs].typ)
	if lhs_size !in [4, 8] || rhs_size !in [4, 8] || !g.value_is_float_type(rhs) {
		g.unsupported_numeric_conversion(op, lhs_size, rhs_size, val_id)
	}
	g.load_float_val_to_xmm(0, lhs, lhs_size)
	g.load_float_val_to_xmm(1, rhs, rhs_size)
	size := if lhs_size == 8 || rhs_size == 8 { 8 } else { 4 }
	if lhs_size == 4 && size == 8 {
		asm_cvtss2sd_xmm0_xmm0(mut g)
	}
	if rhs_size == 4 && size == 8 {
		asm_cvtss2sd_xmm1_xmm1(mut g)
	}
	asm_ucomis_xmm0_xmm1(mut g, size)
	match op {
		.eq {
			asm_setcc_al_movzx(mut g, cc_e)
			asm_setcc_cl_movzx(mut g, cc_np)
			asm_and_rax_rcx(mut g)
		}
		.ne {
			asm_setcc_al_movzx(mut g, cc_ne)
			asm_setcc_cl_movzx(mut g, cc_p)
			asm_or_rax_rcx(mut g)
		}
		.lt {
			asm_setcc_al_movzx(mut g, cc_b)
			asm_setcc_cl_movzx(mut g, cc_np)
			asm_and_rax_rcx(mut g)
		}
		.gt {
			asm_setcc_al_movzx(mut g, cc_a)
		}
		.le {
			asm_setcc_al_movzx(mut g, cc_be)
			asm_setcc_cl_movzx(mut g, cc_np)
			asm_and_rax_rcx(mut g)
		}
		.ge {
			asm_setcc_al_movzx(mut g, cc_ae)
		}
		else {
			g.unsupported_numeric_conversion(op, size, size, val_id)
		}
	}

	g.store_reg_to_val(0, val_id)
}

fn (mut g Gen) emit_signed_int_to_float(result_size int, op ssa.OpCode, val_id int) {
	if result_size == 4 {
		asm_cvtsi2ss_xmm0_rax(mut g)
	} else if result_size == 8 {
		asm_cvtsi2sd_xmm0_rax(mut g)
	} else {
		g.unsupported_numeric_conversion(op, 8, result_size, val_id)
	}
}

fn (mut g Gen) emit_unsigned_int_to_float(src_size int, result_size int, val_id int) {
	if src_size < 8 {
		g.mask_rax_to_size(src_size, .uitofp, val_id)
		g.emit_signed_int_to_float(result_size, .uitofp, val_id)
		return
	}
	if src_size != 8 {
		g.unsupported_numeric_conversion(.uitofp, src_size, result_size, val_id)
	}
	asm_test_rax_rax(mut g)
	asm_jns_rel32(mut g)
	normal_patch := g.text_len()
	g.emit_u32(0)
	asm_mov_reg_reg(mut g, rcx, rax)
	asm_and_rcx_imm8(mut g, 1)
	asm_shr_rax_1(mut g)
	asm_or_rax_rcx(mut g)
	g.emit_signed_int_to_float(result_size, .uitofp, val_id)
	asm_add_float_xmm0_xmm0(mut g, result_size)
	asm_jmp_rel32(mut g)
	end_patch := g.text_len()
	g.emit_u32(0)
	g.patch_rel32(normal_patch)
	g.emit_signed_int_to_float(result_size, .uitofp, val_id)
	g.patch_rel32(end_patch)
}

fn (mut g Gen) emit_float_to_signed_int(src_size int, op ssa.OpCode, val_id int) {
	if src_size == 4 {
		asm_cvttss2si_rax_xmm0(mut g)
	} else if src_size == 8 {
		asm_cvttsd2si_rax_xmm0(mut g)
	} else {
		g.unsupported_numeric_conversion(op, src_size, 8, val_id)
	}
}

fn (mut g Gen) emit_float_to_unsigned_int(src_size int, dst_size int, val_id int) {
	if dst_size != 8 {
		g.emit_float_to_signed_int(src_size, .fptoui, val_id)
		g.mask_rax_to_size(dst_size, .fptoui, val_id)
		return
	}
	g.load_fp_2p63_to_xmm1(src_size, val_id)
	asm_ucomis_xmm0_xmm1(mut g, src_size)
	asm_jae_rel32(mut g)
	big_patch := g.text_len()
	g.emit_u32(0)
	g.emit_float_to_signed_int(src_size, .fptoui, val_id)
	asm_jmp_rel32(mut g)
	end_patch := g.text_len()
	g.emit_u32(0)
	g.patch_rel32(big_patch)
	asm_sub_float_xmm0_xmm1(mut g, src_size)
	g.emit_float_to_signed_int(src_size, .fptoui, val_id)
	asm_mov_reg_imm64(mut g, rcx, 0x8000000000000000)
	asm_or_rax_rcx(mut g)
	g.patch_rel32(end_patch)
}

fn (mut g Gen) load_fp_2p63_to_xmm1(size int, val_id int) {
	mut bytes := []u8{len: size}
	if size == 4 {
		binary.little_endian_put_u32(mut bytes, 0x5f000000)
	} else if size == 8 {
		binary.little_endian_put_u64(mut bytes, 0x43e0000000000000)
	} else {
		g.unsupported_numeric_conversion(.fptoui, size, 8, val_id)
	}
	str_offset := g.rodata_len()
	g.add_rodata(bytes)
	sym_name := 'L_fp_${g.curr_offset}_${str_offset}'
	sym_idx := g.add_symbol(sym_name, u64(str_offset), false, .rodata)
	asm_lea_reg_rip(mut g, r10)
	g.add_rip_reloc(sym_idx)
	g.emit_u32(0)
	asm_load_xmm_mem_base_disp_size(mut g, 1, r10, 0, size)
}

fn (mut g Gen) patch_rel32(patch_pos int) {
	target := g.text_len()
	rel := target - (patch_pos + 4)
	g.write_u32(patch_pos, u32(rel))
}

fn (g Gen) unsupported_numeric_conversion(op ssa.OpCode, src_size int, dst_size int, val_id int) {
	x64_unsupported('numeric conversion ${op} from ${src_size * 8}-bit to ${dst_size * 8}-bit in value ${val_id}')
}

fn (g Gen) const_int_operand(val_id int) int {
	if val_id > 0 && val_id < g.mod.values.len {
		return int(g.mod.values[val_id].name.i64())
	}
	return 0
}

fn (g Gen) heap_alloc_size(val_id int) int {
	val := g.mod.values[val_id]
	mut min_size := 8
	if val.typ > 0 && val.typ < g.mod.type_store.types.len {
		ptr_typ := g.mod.type_store.types[val.typ]
		if ptr_typ.kind == .ptr_t && ptr_typ.elem_type > 0 {
			size := g.type_size(ptr_typ.elem_type)
			min_size = if size > 0 { size } else { 8 }
		}
	}
	return g.alloc_size_from_uses(val_id, min_size)
}

fn valid_x64_scalar_memory_size(size int) bool {
	return size in [1, 2, 4, 8]
}

fn x64_scalar_memory_size_or_default(size int) int {
	return if valid_x64_scalar_memory_size(size) { size } else { 8 }
}

fn (g Gen) scalar_store_size_for_pointer_destination(ptr_id int, fallback_size int) int {
	if ptr_id <= 0 || ptr_id >= g.mod.values.len {
		return x64_scalar_memory_size_or_default(fallback_size)
	}
	ptr_typ_id := g.mod.values[ptr_id].typ
	if ptr_typ_id <= 0 || ptr_typ_id >= g.mod.type_store.types.len {
		return x64_scalar_memory_size_or_default(fallback_size)
	}
	ptr_typ := g.mod.type_store.types[ptr_typ_id]
	if ptr_typ.kind != .ptr_t || ptr_typ.elem_type <= 0 {
		return x64_scalar_memory_size_or_default(fallback_size)
	}
	elem_size := g.type_size(ptr_typ.elem_type)
	if valid_x64_scalar_memory_size(elem_size) {
		return elem_size
	}
	return x64_scalar_memory_size_or_default(fallback_size)
}

fn (g Gen) store_access_size(src_id int, dst_id int) int {
	src_typ := g.mod.values[src_id].typ
	src_type_info := g.mod.type_store.types[src_typ]
	src_size := g.type_size(src_typ)
	if src_type_info.kind in [.struct_t, .array_t] || src_size > 8 {
		return src_size
	}
	return g.scalar_store_size_for_pointer_destination(dst_id, src_size)
}

fn (g Gen) alloc_size_from_uses(ptr_id int, min_size int) int {
	mut size := if min_size > 0 { min_size } else { 8 }
	if ptr_id <= 0 || ptr_id >= g.mod.values.len {
		return size
	}
	for use_id in g.mod.values[ptr_id].uses {
		if use_id <= 0 || use_id >= g.mod.values.len || g.mod.values[use_id].kind != .instruction {
			continue
		}
		use_instr := g.mod.instrs[g.mod.values[use_id].index]
		if use_instr.op == .store && use_instr.operands.len >= 2 && use_instr.operands[1] == ptr_id {
			store_size := g.store_access_size(use_instr.operands[0], use_instr.operands[1])
			if store_size > size {
				size = store_size
			}
		}
		if use_instr.op != .get_element_ptr || use_instr.operands.len < 2
			|| use_instr.operands[0] != ptr_id {
			continue
		}
		offset := g.gep_const_offset(ptr_id, use_instr.operands[1], use_instr.typ)
		if offset < 0 {
			continue
		}
		access_size := g.pointer_access_size(use_id)
		end := offset + if access_size > 0 { access_size } else { g.gep_elem_size(ptr_id) }
		if end > size {
			size = end
		}
	}
	return size
}

fn (g Gen) pointer_access_size(ptr_id int) int {
	if ptr_id <= 0 || ptr_id >= g.mod.values.len {
		return 0
	}
	mut size := 0
	for use_id in g.mod.values[ptr_id].uses {
		if use_id <= 0 || use_id >= g.mod.values.len || g.mod.values[use_id].kind != .instruction {
			continue
		}
		use_instr := g.mod.instrs[g.mod.values[use_id].index]
		if use_instr.op == .store && use_instr.operands.len >= 2 && use_instr.operands[1] == ptr_id {
			store_size := g.store_access_size(use_instr.operands[0], use_instr.operands[1])
			if store_size > size {
				size = store_size
			}
		} else if use_instr.op == .load && use_instr.operands.len >= 1
			&& use_instr.operands[0] == ptr_id {
			load_size := g.type_size(use_instr.typ)
			if load_size > size {
				size = load_size
			}
		}
	}
	return size
}

fn (g Gen) struct_field_type(struct_typ_id int, field_idx int, fallback int) int {
	if struct_typ_id > 0 && struct_typ_id < g.mod.type_store.types.len {
		typ := g.mod.type_store.types[struct_typ_id]
		if typ.kind == .struct_t && field_idx >= 0 && field_idx < typ.fields.len {
			return typ.fields[field_idx]
		}
		if typ.kind == .array_t {
			return typ.elem_type
		}
	}
	return fallback
}

fn (g Gen) struct_field_offset_bytes(struct_typ_id int, field_idx int) int {
	if struct_typ_id <= 0 || struct_typ_id >= g.mod.type_store.types.len {
		return field_idx * 8
	}
	typ := g.mod.type_store.types[struct_typ_id]
	if typ.kind == .array_t {
		return field_idx * g.type_size(typ.elem_type)
	}
	if typ.kind != .struct_t {
		return field_idx * 8
	}
	if typ.is_union {
		return 0
	}
	mut off := 0
	for i, field_typ in typ.fields {
		align := g.type_align(field_typ)
		if align > 1 && off % align != 0 {
			off = (off + align - 1) & ~(align - 1)
		}
		if i == field_idx {
			return off
		}
		off += g.type_size(field_typ)
	}
	return field_idx * 8
}

fn (g Gen) gep_const_offset(base_id int, idx_id int, result_typ_id ssa.TypeID) int {
	if idx_id <= 0 || idx_id >= g.mod.values.len || g.mod.values[idx_id].kind != .constant {
		return -1
	}
	idx := g.const_int_operand(idx_id)
	if base_id <= 0 || base_id >= g.mod.values.len {
		return idx * 8
	}
	base_typ_id := g.mod.values[base_id].typ
	if base_typ_id <= 0 || base_typ_id >= g.mod.type_store.types.len {
		return idx * 8
	}
	base_typ := g.mod.type_store.types[base_typ_id]
	if base_typ.kind != .ptr_t {
		return idx * 8
	}
	elem_typ := g.mod.type_store.types[base_typ.elem_type]
	if elem_typ.kind == .struct_t {
		if result_typ_id > 0 && result_typ_id < g.mod.type_store.types.len {
			result_typ := g.mod.type_store.types[result_typ_id]
			if result_typ.kind == .ptr_t && result_typ.elem_type == base_typ.elem_type {
				return idx * g.type_size(base_typ.elem_type)
			}
		}
		return g.struct_field_offset_bytes(base_typ.elem_type, idx)
	}
	if elem_typ.kind == .array_t {
		return idx * g.type_size(elem_typ.elem_type)
	}
	return idx * g.type_size(base_typ.elem_type)
}

fn (g Gen) gep_elem_size(base_id int) int {
	if base_id > 0 && base_id < g.mod.values.len {
		base_typ_id := g.mod.values[base_id].typ
		if base_typ_id > 0 && base_typ_id < g.mod.type_store.types.len {
			base_typ := g.mod.type_store.types[base_typ_id]
			if base_typ.kind == .ptr_t {
				elem_typ := g.mod.type_store.types[base_typ.elem_type]
				if elem_typ.kind == .array_t {
					size := g.type_size(elem_typ.elem_type)
					return if size > 0 { size } else { 8 }
				}
				size := g.type_size(base_typ.elem_type)
				return if size > 0 { size } else { 8 }
			}
		}
	}
	return 8
}

fn (mut g Gen) zero_value_bytes(val_id int, size int) {
	if size <= 0 {
		return
	}
	dst_off := g.stack_map[val_id]
	asm_xor_reg_reg(mut g, rax)
	g.store_repeated_zero(int(rbp), dst_off, size)
}

fn (mut g Gen) zero_large_fixed_array_alloca(val_id int, off int) {
	if val_id <= 0 || val_id >= g.mod.values.len {
		return
	}
	alloca_val := g.mod.values[val_id]
	if alloca_val.typ <= 0 || alloca_val.typ >= g.mod.type_store.types.len {
		return
	}
	alloca_ptr_type := g.mod.type_store.types[alloca_val.typ]
	if alloca_ptr_type.kind != .ptr_t || alloca_ptr_type.elem_type <= 0
		|| alloca_ptr_type.elem_type >= g.mod.type_store.types.len {
		return
	}
	elem_typ := g.mod.type_store.types[alloca_ptr_type.elem_type]
	if elem_typ.kind != .array_t || elem_typ.len <= 16 {
		return
	}
	arr_size := g.type_size(alloca_ptr_type.elem_type)
	if arr_size <= 0 {
		return
	}
	asm_xor_reg_reg(mut g, rax)
	g.store_repeated_zero(int(rbp), off, arr_size)
}

fn (mut g Gen) store_repeated_zero(base int, off int, size int) {
	mut done := 0
	for done + 8 <= size {
		asm_store_mem_base_disp_reg_size(mut g, Reg(base), off + done, rax, 8)
		done += 8
	}
	for done < size {
		chunk := raw_memory_chunk_size(size - done)
		asm_store_mem_base_disp_reg_size(mut g, Reg(base), off + done, rax, chunk)
		done += chunk
	}
}

fn (mut g Gen) copy_value_bytes(dst_id int, src_id int, size int) {
	if size <= 0 {
		return
	}
	g.load_struct_src_address_to_reg(int(r10), src_id, g.mod.values[src_id].typ)
	g.copy_memory(int(rbp), g.stack_map[dst_id], int(r10), 0, size)
}

fn (mut g Gen) copy_memory(dst_base int, dst_off int, src_base int, src_off int, size int) {
	mut done := 0
	for done + 8 <= size {
		asm_load_reg_mem_base_disp_size(mut g, rax, Reg(src_base), src_off + done, 8)
		asm_store_mem_base_disp_reg_size(mut g, Reg(dst_base), dst_off + done, rax, 8)
		done += 8
	}
	for done < size {
		chunk := raw_memory_chunk_size(size - done)
		asm_load_reg_mem_base_disp_size(mut g, rax, Reg(src_base), src_off + done, chunk)
		asm_store_mem_base_disp_reg_size(mut g, Reg(dst_base), dst_off + done, rax, chunk)
		done += chunk
	}
}

fn raw_memory_chunk_size(size int) int {
	if size >= 4 {
		return 4
	}
	if size >= 2 {
		return 2
	}
	return 1
}

fn is_raw_abi_reg_size(size int) bool {
	return size !in [1, 2, 4, 8]
}

fn (mut g Gen) load_typed_mem_to_reg(reg Reg, base Reg, disp int, typ_id int, size int) {
	typ := g.mod.type_store.types[typ_id]
	if typ.kind == .int_t && !typ.is_unsigned {
		asm_load_reg_mem_base_disp_size_signed(mut g, reg, base, disp, size)
		return
	}
	asm_load_reg_mem_base_disp_size(mut g, reg, base, disp, size)
}

fn (mut g Gen) load_raw_mem_to_reg(reg Reg, base Reg, disp int, size int) {
	if size in [1, 2, 4, 8] {
		asm_load_reg_mem_base_disp_size(mut g, reg, base, disp, size)
		return
	}
	if size <= 0 || size > 8 {
		x64_unsupported('raw memory size ${size}')
	}
	asm_xor_reg_reg(mut g, rax)
	mut done := 0
	for done < size {
		chunk := raw_memory_chunk_size(size - done)
		asm_load_reg_mem_base_disp_size(mut g, r11, base, disp + done, chunk)
		if done > 0 {
			asm_shl_r11_imm8(mut g, u8(done * 8))
		}
		asm_or_rax_r11(mut g)
		done += chunk
	}
	if reg != rax {
		asm_mov_reg_reg(mut g, reg, rax)
	}
}

fn (mut g Gen) store_reg_to_rbp_exact(reg Reg, off int, size int) {
	if size in [1, 2, 4, 8] {
		asm_store_rbp_disp_reg_size(mut g, off, reg, size)
		return
	}
	if size <= 0 || size > 8 {
		x64_unsupported('raw register spill size ${size}')
	}
	if reg != rax {
		asm_mov_reg_reg(mut g, rax, reg)
	}
	mut done := 0
	for done < size {
		chunk := raw_memory_chunk_size(size - done)
		asm_store_rbp_disp_reg_size(mut g, off + done, rax, chunk)
		done += chunk
		if done < size {
			asm_shr_rax_imm8(mut g, u8(chunk * 8))
		}
	}
}

fn (mut g Gen) store_field_value(dst_id int, dst_typ int, field_idx int, src_id int, size int) {
	field_off := g.struct_field_offset_bytes(dst_typ, field_idx)
	dst_off := g.stack_map[dst_id] + field_off
	if size > 8 || g.value_is_aggregate(src_id) {
		if g.value_is_zero_constant(src_id) {
			asm_xor_reg_reg(mut g, rax)
			g.store_repeated_zero(int(rbp), dst_off, size)
			return
		}
		g.load_struct_src_address_to_reg(int(r10), src_id, g.mod.values[src_id].typ)
		g.copy_memory(int(rbp), dst_off, int(r10), 0, size)
		return
	}
	if g.value_is_float_type(src_id) && size in [4, 8] {
		g.load_float_val_to_xmm(0, src_id, size)
		asm_store_xmm_rbp_disp(mut g, 0, dst_off, size)
		return
	}
	g.load_val_to_reg(0, src_id)
	asm_store_rbp_disp_reg_size(mut g, dst_off, rax, size)
}

fn (mut g Gen) emit_epilogue() {
	if g.stack_size > 0 {
		if g.stack_size <= 127 {
			asm_add_rsp_imm8(mut g, u8(g.stack_size))
		} else {
			asm_add_rsp_imm32(mut g, u32(g.stack_size))
		}
	}
	for i := g.used_regs.len - 1; i >= 0; i-- {
		asm_pop(mut g, Reg(g.used_regs[i]))
	}
	asm_pop_rbp(mut g)
	asm_ret(mut g)
}

fn (g Gen) selected_opcode(instr mir.Instruction) ssa.OpCode {
	_ = g
	return instr.op
}

fn (mut g Gen) emit_jmp(target_idx int) {
	asm_jmp_rel32(mut g)
	g.emit_rel32_to_block(target_idx)
}

fn (mut g Gen) emit_rel32_to_block(target_idx int) {
	if target_idx in g.block_offsets {
		off := g.block_offsets[target_idx]
		rel := off - (g.text_len() - g.curr_offset + 4)
		g.emit_u32(u32(rel))
		return
	}
	g.record_pending_label(target_idx)
	g.emit_u32(0)
}

fn (mut g Gen) load_call_arg_to_reg(reg int, val_id int, arg_idx int, instr mir.Instruction) {
	is_indirect := g.call_arg_is_indirect(val_id, arg_idx, instr)
	if is_indirect {
		g.load_address_of_val_to_reg(reg, val_id)
		return
	}
	size := g.type_size(g.mod.values[val_id].typ)
	if g.value_needs_raw_abi_reg_bytes(val_id, size) {
		if g.value_is_zero_constant(val_id) {
			asm_xor_reg_reg(mut g, Reg(reg))
			return
		}
		g.load_struct_src_address_to_reg(int(r10), val_id, g.mod.values[val_id].typ)
		g.load_raw_mem_to_reg(Reg(reg), r10, 0, size)
		return
	}
	g.load_val_to_reg(reg, val_id)
}

fn (mut g Gen) load_sysv_direct_aggregate_arg_to_regs(val_id int, layout mir.AbiValueLayout, abi_regs []int) {
	g.ensure_sysv_direct_aggregate_supported(val_id, layout.value_class, 'argument')
	size := g.type_size(g.mod.values[val_id].typ)
	g.load_struct_src_address_to_reg(int(r10), val_id, g.mod.values[val_id].typ)
	sse_regs := g.abi.float_arg_regs()
	mut loc_idx := 0
	for loc_idx < layout.locs.len {
		loc := layout.locs[loc_idx]
		if loc.kind in [.none, .stack] {
			loc_idx++
			continue
		}
		chunk_size := sysv_abi_chunk_size(size, loc.offset)
		if chunk_size <= 0 {
			loc_idx++
			continue
		}
		match loc.kind {
			.int_reg {
				reg := sysv_checked_int_reg(abi_regs, loc.index, 'argument')
				g.load_raw_mem_to_reg(reg, r10, loc.offset, chunk_size)
				loc_idx++
			}
			.sse_reg {
				if sysv_layout_has_sseup_pair(layout, loc_idx, size) {
					xmm := sysv_checked_sse_reg(sse_regs, loc.index, 'argument')
					asm_load_xmm_mem_base_disp_128(mut g, xmm, r10, loc.offset)
					loc_idx += 2
					continue
				}
				if loc.class == .sseup {
					x64_unsupported('backend feature: SysV direct aggregate argument with unpaired SSEUP ABI location is not implemented yet')
				}
				sysv_checked_sse_chunk_size(chunk_size, 'argument')
				xmm := sysv_checked_sse_reg(sse_regs, loc.index, 'argument')
				asm_load_xmm_mem_base_disp_size(mut g, xmm, r10, loc.offset, chunk_size)
				loc_idx++
			}
			else {
				x64_unsupported('backend feature: SysV direct aggregate argument with unsupported ABI location is not implemented yet')
			}
		}
	}
}

fn (mut g Gen) prepare_call_stack_args(instr mir.Instruction, stack_args []bool, stack_slots int, arg_position_base int) int {
	if g.abi != .windows {
		return 0
	}
	cleanup := g.emit_windows_call_frame(stack_slots)
	for arg_idx, is_stack in stack_args {
		if is_stack {
			g.store_windows_call_stack_arg(instr.operands[arg_idx + 1], arg_idx, arg_idx +
				arg_position_base, instr)
		}
	}
	return cleanup
}

fn (mut g Gen) emit_windows_call_frame(stack_slots int) int {
	if g.abi != .windows {
		return 0
	}
	cleanup := g.abi.call_frame_size(stack_slots)
	if cleanup <= 127 {
		asm_sub_rsp_imm8(mut g, u8(cleanup))
	} else {
		asm_sub_rsp_imm32(mut g, u32(cleanup))
	}
	return cleanup
}

fn (mut g Gen) cleanup_windows_call_frame(cleanup int) {
	if cleanup == 0 {
		return
	}
	if cleanup <= 127 {
		asm_add_rsp_imm8(mut g, u8(cleanup))
	} else {
		asm_add_rsp_imm32(mut g, u32(cleanup))
	}
}

fn (mut g Gen) store_windows_call_stack_arg(val_id int, arg_idx int, position int, instr mir.Instruction) {
	is_indirect := g.call_arg_is_indirect(val_id, arg_idx, instr)
	size := g.type_size(g.mod.values[val_id].typ)
	g.ensure_windows_scalar_or_indirect_arg(val_id, is_indirect, size)
	disp := g.abi.call_stack_arg_offset(position)
	if g.value_is_float_type(val_id) {
		g.ensure_float_abi_scalar(val_id, 'stack argument')
		g.load_float_val_to_xmm(0, val_id, size)
		asm_store_xmm_mem_base_disp_size(mut g, 0, rsp, disp, size)
		return
	}
	g.load_call_arg_to_reg(0, val_id, arg_idx, instr)
	asm_store_mem_base_disp_reg_size(mut g, rsp, disp, rax, 8)
}

fn (mut g Gen) ensure_windows_scalar_or_indirect_arg(val_id int, is_indirect bool, size int) {
	if is_indirect {
		return
	}
	if g.value_is_aggregate(val_id) && size !in [1, 2, 4, 8] {
		g.unsupported_windows_abi_arg(
			'direct aggregate argument larger than 8 bytes reached codegen; ' +
			'expected ABI lowering before codegen to pass it indirectly', val_id)
	}
	if !g.value_is_aggregate(val_id) && size !in [1, 2, 4, 8] {
		g.unsupported_windows_abi_arg(
			'scalar argument with unsupported storage width ${size} bytes reached codegen; ' +
			'expected ABI lowering before codegen', val_id)
	}
}

fn (g Gen) unsupported_windows_abi_arg(reason string, val_id int) {
	x64_unsupported('backend feature: Windows argument lowering for value ${val_id}: ${reason}; check ABI lowering')
}

fn (g Gen) ensure_sysv_direct_aggregate_supported(val_id int, value_class mir.AbiValueClass, context string) {
	if g.abi != .sysv || value_class.mode != .direct || !g.value_is_aggregate(val_id)
		|| value_class.classes.len == 0 {
		return
	}
	for i, class in value_class.classes {
		match class {
			.no_class, .integer, .sse {}
			.sseup {
				if i == 0 || value_class.classes[i - 1] !in [.sse, .sseup] {
					x64_unsupported('backend feature: SysV direct aggregate ${context} with unpaired SSEUP eightbyte class is not implemented yet')
				}
			}
			else {
				x64_unsupported('backend feature: SysV direct aggregate ${context} with MEMORY eightbyte classes is not implemented yet')
			}
		}
	}
}

fn sysv_abi_chunk_size(total_size int, offset int) int {
	if total_size <= offset {
		return 0
	}
	remaining := total_size - offset
	if remaining < 8 {
		return remaining
	}
	return 8
}

fn sysv_layout_register_limits(layout mir.AbiValueLayout) (int, int) {
	mut int_limit := 0
	mut sse_limit := 0
	for loc in layout.locs {
		if loc.kind == .int_reg && loc.index + 1 > int_limit {
			int_limit = loc.index + 1
		}
		if loc.kind == .sse_reg && loc.class == .sse && loc.index + 1 > sse_limit {
			sse_limit = loc.index + 1
		}
	}
	return int_limit, sse_limit
}

fn sysv_layout_stack_slot_limit(layout mir.AbiValueLayout) int {
	mut limit := 0
	for loc in layout.locs {
		if loc.kind == .stack && loc.index + 1 > limit {
			limit = loc.index + 1
		}
	}
	return limit
}

fn sysv_layout_uses_stack(layout mir.AbiValueLayout) bool {
	for loc in layout.locs {
		if loc.kind == .stack {
			return true
		}
	}
	return false
}

fn sysv_checked_int_reg(regs []int, index int, context string) Reg {
	if index < 0 || index >= regs.len {
		x64_unsupported('backend feature: SysV direct aggregate ${context} needs INTEGER register ${index} outside available ABI registers')
	}
	return Reg(regs[index])
}

fn sysv_checked_sse_reg(regs []int, index int, context string) int {
	if index < 0 || index >= regs.len {
		x64_unsupported('backend feature: SysV direct aggregate ${context} needs SSE register ${index} outside available ABI registers')
	}
	return regs[index]
}

fn sysv_checked_sse_chunk_size(size int, context string) {
	if size !in [4, 8] {
		x64_unsupported('backend feature: SysV direct aggregate ${context} with ${size}-byte SSE eightbyte chunk is not implemented yet')
	}
}

fn sysv_layout_has_sseup_pair(layout mir.AbiValueLayout, loc_idx int, total_size int) bool {
	if loc_idx + 1 >= layout.locs.len {
		return false
	}
	loc := layout.locs[loc_idx]
	next := layout.locs[loc_idx + 1]
	return loc.kind == .sse_reg && loc.class == .sse && next.kind == .sse_reg
		&& next.class == .sseup && next.index == loc.index && next.offset == loc.offset + 8
		&& total_size >= loc.offset + 16
}

fn sysv_class_has_sseup_pair(classes []mir.AbiEightbyteClass, class_idx int, total_size int) bool {
	return class_idx + 1 < classes.len && classes[class_idx] == .sse
		&& classes[class_idx + 1] == .sseup && total_size >= class_idx * 8 + 16
}

fn sysv_int_return_reg(index int, context string) Reg {
	return match index {
		0 {
			rax
		}
		1 {
			rdx
		}
		else {
			x64_unsupported('backend feature: SysV direct aggregate ${context} needs INTEGER return register ${index} outside available ABI registers')
			rax
		}
	}
}

fn sysv_sse_return_reg(index int, context string) int {
	if index < 0 || index >= 2 {
		x64_unsupported('backend feature: SysV direct aggregate ${context} needs SSE return register ${index} outside available ABI registers')
	}
	return index
}

fn (mut g Gen) store_sysv_direct_aggregate_param(pid int, layout mir.AbiValueLayout) {
	if g.abi != .sysv {
		return
	}
	g.ensure_sysv_direct_aggregate_supported(pid, layout.value_class, 'parameter')
	param_size := g.type_size(g.mod.values[pid].typ)
	dst_off := g.stack_map[pid]
	int_regs := g.abi.int_arg_regs()
	sse_regs := g.abi.float_arg_regs()
	mut loc_idx := 0
	for loc_idx < layout.locs.len {
		loc := layout.locs[loc_idx]
		if loc.kind == .none {
			loc_idx++
			continue
		}
		chunk_size := sysv_abi_chunk_size(param_size, loc.offset)
		if chunk_size <= 0 {
			loc_idx++
			continue
		}
		match loc.kind {
			.int_reg {
				reg := sysv_checked_int_reg(int_regs, loc.index, 'parameter')
				g.store_reg_to_rbp_exact(reg, dst_off + loc.offset, chunk_size)
				loc_idx++
			}
			.sse_reg {
				if sysv_layout_has_sseup_pair(layout, loc_idx, param_size) {
					xmm := sysv_checked_sse_reg(sse_regs, loc.index, 'parameter')
					asm_store_xmm_mem_base_disp_128(mut g, xmm, rbp, dst_off + loc.offset)
					loc_idx += 2
					continue
				}
				if loc.class == .sseup {
					x64_unsupported('backend feature: SysV direct aggregate parameter with unpaired SSEUP ABI location is not implemented yet')
				}
				sysv_checked_sse_chunk_size(chunk_size, 'parameter')
				xmm := sysv_checked_sse_reg(sse_regs, loc.index, 'parameter')
				asm_store_xmm_rbp_disp(mut g, xmm, dst_off + loc.offset, chunk_size)
				loc_idx++
			}
			.stack {
				g.copy_memory(int(rbp), dst_off + loc.offset, int(rbp), 16 + loc.index * 8,
					chunk_size)
				loc_idx++
			}
			else {
				x64_unsupported('backend feature: SysV direct aggregate parameter with unsupported ABI location is not implemented yet')
			}
		}
	}
}

fn (g Gen) ensure_windows_direct_return_supported(val_id int, ret_class mir.AbiValueClass, context string) {
	if g.abi != .windows {
		return
	}
	if ret_class.mode == .indirect {
		return
	}
	if ret_class.size == 0 && ret_class.classes.len == 0 {
		return
	}
	size := g.type_size(g.mod.values[val_id].typ)
	if g.value_is_aggregate(val_id) && size !in [1, 2, 4, 8] {
		x64_unsupported('backend feature: Windows ${context} lowering for value ${val_id}: ' +
			'aggregate return larger than 8 bytes reached direct return codegen; ' +
			'expected ABI lowering before codegen to use hidden sret pointer; check ABI lowering')
	}
	if !g.value_is_aggregate(val_id) && !g.value_is_float_type(val_id) && size !in [1, 2, 4, 8] {
		x64_unsupported('backend feature: Windows ${context} lowering for value ${val_id}: ' +
			'scalar return with unsupported storage width ${size} bytes reached codegen; ' +
			'expected ABI lowering before codegen; check ABI lowering')
	}
}

fn (g Gen) windows_value_passed_indirect(val_id int, marked_indirect bool, size int) bool {
	if marked_indirect {
		return true
	}
	return g.abi == .windows && g.value_is_aggregate(val_id) && size !in [1, 2, 4, 8]
}

fn (g Gen) call_arg_is_indirect(val_id int, arg_idx int, instr mir.Instruction) bool {
	marked_indirect := arg_idx >= 0 && arg_idx < instr.abi_arg_class.len
		&& instr.abi_arg_class[arg_idx] == .indirect
	return g.windows_value_passed_indirect(val_id, marked_indirect,
		g.type_size(g.mod.values[val_id].typ))
}

fn (mut g Gen) load_call_register_args(instr mir.Instruction, abi_regs []int, stack_args []bool, arg_position_base int) int {
	if g.abi.uses_positional_arg_regs() {
		return g.load_windows_call_register_args(instr, stack_args, arg_position_base)
	}

	mut reg_arg_idx := arg_position_base
	mut sse_arg_idx := 0
	float_arg_regs := g.abi.float_arg_regs()
	for i in 1 .. instr.operands.len {
		arg_idx := i - 1
		arg_id := instr.operands[i]
		if g.value_is_float_type(arg_id) {
			if sse_arg_idx >= float_arg_regs.len {
				g.unsupported_float_abi('stack argument', arg_id)
			}
			g.load_float_call_arg_to_xmm(float_arg_regs[sse_arg_idx], arg_id)
			sse_arg_idx++
			continue
		}
		if arg_idx < instr.abi_arg_classes.len {
			g.ensure_sysv_direct_aggregate_supported(arg_id, instr.abi_arg_classes[arg_idx],
				'argument')
		}
		if stack_args[arg_idx] {
			continue
		}
		if !g.call_arg_is_indirect(arg_id, arg_idx, instr) && g.value_is_aggregate(arg_id)
			&& arg_idx < instr.abi_arg_layouts.len && instr.abi_arg_layouts[arg_idx].locs.len > 0 {
			layout := instr.abi_arg_layouts[arg_idx]
			g.load_sysv_direct_aggregate_arg_to_regs(arg_id, layout, abi_regs)
			int_limit, sse_limit := sysv_layout_register_limits(layout)
			if int_limit > reg_arg_idx {
				reg_arg_idx = int_limit
			}
			if sse_limit > sse_arg_idx {
				sse_arg_idx = sse_limit
			}
			continue
		}
		arg_chunks := g.call_arg_reg_chunks(arg_id, arg_idx, instr)
		if reg_arg_idx + arg_chunks <= abi_regs.len {
			if arg_chunks > 1 {
				g.load_aggregate_arg_to_regs(arg_id,
					abi_regs[reg_arg_idx..reg_arg_idx + arg_chunks],
					g.type_size(g.mod.values[arg_id].typ))
			} else {
				g.load_call_arg_to_reg(abi_regs[reg_arg_idx], arg_id, arg_idx, instr)
			}
			reg_arg_idx += arg_chunks
		}
	}
	return sse_arg_idx
}

fn (mut g Gen) load_windows_call_register_args(instr mir.Instruction, stack_args []bool, arg_position_base int) int {
	mut sse_arg_count := 0
	duplicate_vararg_float := g.call_needs_windows_vararg_float_duplication(instr)
	// Load positional Windows arguments from right to left. Some value loaders use
	// RCX as scratch, so loading arg0 first can corrupt it before the call.
	for i := instr.operands.len - 1; i >= 1; i-- {
		arg_idx := i - 1
		if stack_args[arg_idx] {
			continue
		}
		arg_id := instr.operands[i]
		position := arg_idx + arg_position_base
		if g.value_is_float_type(arg_id) {
			xmm := g.abi.float_arg_reg_for_position(position)
			if xmm == x64_no_arg_reg {
				g.unsupported_float_abi('stack argument', arg_id)
			}
			g.load_float_call_arg_to_xmm(xmm, arg_id)
			if duplicate_vararg_float {
				g.duplicate_windows_vararg_float_arg_to_gp(position, xmm)
			}
			sse_arg_count++
			continue
		}
		reg := g.abi.int_arg_reg_for_position(position)
		if reg == x64_no_arg_reg {
			continue
		}
		is_indirect := g.call_arg_is_indirect(arg_id, arg_idx, instr)
		size := g.type_size(g.mod.values[arg_id].typ)
		g.ensure_windows_scalar_or_indirect_arg(arg_id, is_indirect, size)
		g.load_call_arg_to_reg(reg, arg_id, arg_idx, instr)
	}
	return sse_arg_count
}

fn (g Gen) call_needs_windows_vararg_float_duplication(instr mir.Instruction) bool {
	if g.abi != .windows || instr.operands.len == 0 {
		return false
	}
	fn_val := g.mod.values[instr.operands[0]]
	return fn_val.name in ['snprintf', '_scprintf', '_snprintf']
}

fn (mut g Gen) duplicate_windows_vararg_float_arg_to_gp(position int, xmm int) {
	if position >= 4 {
		return
	}
	reg := g.abi.int_arg_reg_for_position(position)
	if reg == x64_no_arg_reg {
		return
	}
	g.emit_movq_reg_xmm(Reg(reg), xmm)
}

fn (mut g Gen) emit_movq_reg_xmm(dst Reg, src_xmm int) {
	dst_hw := g.map_reg(int(dst))
	mut rex := u8(0x48)
	if src_xmm >= 8 {
		rex |= 4
	}
	if dst_hw >= 8 {
		rex |= 1
	}
	g.emit(0x66)
	g.emit(rex)
	g.emit(0x0f)
	g.emit(0x7e)
	src := u8(src_xmm & 7)
	dst_bits := u8(dst_hw & 7)
	g.emit(0xc0 | (src << 3) | dst_bits)
}

fn (mut g Gen) load_float_call_arg_to_xmm(xmm int, val_id int) {
	g.ensure_float_abi_scalar(val_id, 'argument')
	g.load_float_val_to_xmm(xmm, val_id, g.type_size(g.mod.values[val_id].typ))
}

fn (mut g Gen) store_call_result(val_id int, ret_class mir.AbiValueClass) {
	g.ensure_windows_direct_return_supported(val_id, ret_class, 'call result')
	if g.value_is_float_type(val_id) {
		g.ensure_float_abi_scalar(val_id, 'call result')
		asm_store_xmm0_rbp_disp(mut g, g.stack_map[val_id], g.type_size(g.mod.values[val_id].typ))
		return
	}
	if g.store_sysv_direct_aggregate_call_result(val_id, ret_class) {
		return
	}
	g.ensure_sysv_direct_aggregate_supported(val_id, ret_class, 'call result')
	if g.store_sysv_integer_pair_call_result(val_id, ret_class) {
		return
	}
	g.normalize_integer_call_result(val_id)
	g.store_reg_to_val(0, val_id)
}

fn (mut g Gen) normalize_integer_call_result(val_id int) {
	typ_id := g.mod.values[val_id].typ
	g.normalize_integer_rax_for_type(typ_id, .sext, val_id)
}

fn (mut g Gen) normalize_integer_rax_for_type(typ_id int, op ssa.OpCode, val_id int) {
	if typ_id <= 0 || typ_id >= g.mod.type_store.types.len {
		return
	}
	typ := g.mod.type_store.types[typ_id]
	if typ.kind != .int_t {
		return
	}
	size := g.type_size(typ_id)
	if size == 8 {
		return
	}
	if typ.width == 1 {
		asm_mov_reg_imm32(mut g, rcx, 1)
		asm_and_rax_rcx(mut g)
		return
	}
	if typ.is_unsigned {
		g.mask_rax_to_size(size, .zext, val_id)
		return
	}
	match size {
		1 { asm_movsx_rax_al(mut g) }
		2 { asm_movsx_rax_ax(mut g) }
		4 { asm_movsxd_rax_eax(mut g) }
		else { g.unsupported_numeric_conversion(op, size, 8, val_id) }
	}
}

fn (g Gen) is_sysv_integer_pair_return(ret_class mir.AbiValueClass) bool {
	return g.abi == .sysv && ret_class.mode == .direct && ret_class.size > 8 && ret_class.size <= 16
		&& ret_class.classes.len == 2 && ret_class.classes[0] == .integer
		&& ret_class.classes[1] == .integer
}

fn (g Gen) is_sysv_direct_aggregate_return(val_id int, ret_class mir.AbiValueClass) bool {
	return g.abi == .sysv && ret_class.mode == .direct && g.value_is_aggregate(val_id)
		&& ret_class.classes.len > 0
}

fn (mut g Gen) store_sysv_direct_aggregate_call_result(val_id int, ret_class mir.AbiValueClass) bool {
	if !g.is_sysv_direct_aggregate_return(val_id, ret_class)
		|| g.is_sysv_integer_pair_return(ret_class) {
		return false
	}
	g.ensure_sysv_direct_aggregate_supported(val_id, ret_class, 'call result')
	off := g.stack_map[val_id]
	mut int_idx := 0
	mut sse_idx := 0
	mut i := 0
	for i < ret_class.classes.len {
		class := ret_class.classes[i]
		loc_off := i * 8
		chunk_size := sysv_abi_chunk_size(ret_class.size, loc_off)
		if chunk_size <= 0 {
			i++
			continue
		}
		match class {
			.no_class {
				i++
			}
			.integer {
				reg := sysv_int_return_reg(int_idx, 'call result')
				g.store_reg_to_rbp_exact(reg, off + loc_off, chunk_size)
				int_idx++
				i++
			}
			.sse {
				if sysv_class_has_sseup_pair(ret_class.classes, i, ret_class.size) {
					xmm := sysv_sse_return_reg(sse_idx, 'call result')
					asm_store_xmm_mem_base_disp_128(mut g, xmm, rbp, off + loc_off)
					sse_idx++
					i += 2
					continue
				}
				sysv_checked_sse_chunk_size(chunk_size, 'call result')
				xmm := sysv_sse_return_reg(sse_idx, 'call result')
				asm_store_xmm_rbp_disp(mut g, xmm, off + loc_off, chunk_size)
				sse_idx++
				i++
			}
			.sseup {
				x64_unsupported('backend feature: SysV direct aggregate call result with unpaired SSEUP eightbyte class is not implemented yet')
			}
			else {
				g.ensure_sysv_direct_aggregate_supported(val_id, ret_class, 'call result')
				i++
			}
		}
	}
	return true
}

fn (mut g Gen) load_sysv_direct_aggregate_return(ret_val_id int, ret_class mir.AbiValueClass) bool {
	if !g.is_sysv_direct_aggregate_return(ret_val_id, ret_class)
		|| g.is_sysv_integer_pair_return(ret_class) {
		return false
	}
	g.ensure_sysv_direct_aggregate_supported(ret_val_id, ret_class, 'return')
	g.load_struct_src_address_to_reg(int(r10), ret_val_id, g.cur_func_ret_type)
	mut int_idx := 0
	mut sse_idx := 0
	mut i := 0
	for i < ret_class.classes.len {
		class := ret_class.classes[i]
		loc_off := i * 8
		chunk_size := sysv_abi_chunk_size(ret_class.size, loc_off)
		if chunk_size <= 0 {
			i++
			continue
		}
		match class {
			.no_class {
				i++
			}
			.integer {
				reg := sysv_int_return_reg(int_idx, 'return')
				g.load_raw_mem_to_reg(reg, r10, loc_off, chunk_size)
				int_idx++
				i++
			}
			.sse {
				if sysv_class_has_sseup_pair(ret_class.classes, i, ret_class.size) {
					xmm := sysv_sse_return_reg(sse_idx, 'return')
					asm_load_xmm_mem_base_disp_128(mut g, xmm, r10, loc_off)
					sse_idx++
					i += 2
					continue
				}
				sysv_checked_sse_chunk_size(chunk_size, 'return')
				xmm := sysv_sse_return_reg(sse_idx, 'return')
				asm_load_xmm_mem_base_disp_size(mut g, xmm, r10, loc_off, chunk_size)
				sse_idx++
				i++
			}
			.sseup {
				x64_unsupported('backend feature: SysV direct aggregate return with unpaired SSEUP eightbyte class is not implemented yet')
			}
			else {
				g.ensure_sysv_direct_aggregate_supported(ret_val_id, ret_class, 'return')
				i++
			}
		}
	}
	return true
}

fn (mut g Gen) store_sysv_integer_pair_call_result(val_id int, ret_class mir.AbiValueClass) bool {
	if !g.is_sysv_integer_pair_return(ret_class) {
		return false
	}
	off := g.stack_map[val_id]
	g.store_reg_to_rbp_exact(rax, off, 8)
	second_size := ret_class.size - 8
	if second_size > 0 {
		g.store_reg_to_rbp_exact(rdx, off + 8, second_size)
	}
	return true
}

fn (mut g Gen) load_sysv_integer_pair_return(ret_val_id int, ret_class mir.AbiValueClass) bool {
	if !g.is_sysv_integer_pair_return(ret_class) {
		return false
	}
	g.load_struct_src_address_to_reg(int(r10), ret_val_id, g.cur_func_ret_type)
	second_size := ret_class.size - 8
	if second_size == 8 {
		g.load_raw_mem_to_reg(rax, r10, 0, 8)
		g.load_raw_mem_to_reg(rdx, r10, 8, second_size)
	} else if second_size > 0 {
		g.load_raw_mem_to_reg(rdx, r10, 8, second_size)
		g.load_raw_mem_to_reg(rax, r10, 0, 8)
	} else {
		g.load_raw_mem_to_reg(rax, r10, 0, 8)
	}
	return true
}

fn (mut g Gen) emit_sse_arg_count(count int) {
	if g.abi != .sysv {
		return
	}
	if count == 0 {
		asm_xor_eax_eax(mut g)
	} else {
		asm_mov_reg_imm32(mut g, rax, u32(count))
	}
}

fn (g Gen) param_stack_slots(is_indirect bool, reg_chunks int, size int) int {
	if is_indirect {
		return 1
	}
	if reg_chunks > 1 {
		return reg_chunks
	}
	if size > 8 {
		return (size + 7) / 8
	}
	return 1
}

fn (g Gen) call_arg_reg_chunks(val_id int, arg_idx int, instr mir.Instruction) int {
	is_indirect := g.call_arg_is_indirect(val_id, arg_idx, instr)
	if is_indirect || !g.value_is_aggregate(val_id) {
		return 1
	}
	size := g.type_size(g.mod.values[val_id].typ)
	if size > 8 && size <= 16 {
		return (size + 7) / 8
	}
	return 1
}

fn (g Gen) call_arg_stack_slots(val_id int, arg_idx int, instr mir.Instruction) int {
	is_indirect := g.call_arg_is_indirect(val_id, arg_idx, instr)
	if is_indirect {
		return 1
	}
	size := g.type_size(g.mod.values[val_id].typ)
	if g.value_is_aggregate(val_id) || size > 8 {
		return (size + 7) / 8
	}
	return 1
}

fn (g Gen) call_stack_arg_mask(instr mir.Instruction, abi_reg_count int, arg_position_base int) []bool {
	num_args := instr.operands.len - 1
	mut stack_args := []bool{len: num_args}
	if g.abi.uses_positional_arg_regs() {
		for arg_idx := 0; arg_idx < num_args; arg_idx++ {
			position := arg_idx + arg_position_base
			if position >= g.abi.int_arg_regs().len {
				stack_args[arg_idx] = true
				continue
			}
			arg_id := instr.operands[arg_idx + 1]
			if g.value_is_float_type(arg_id) {
				g.ensure_float_abi_scalar(arg_id, 'argument')
				continue
			}
			if g.call_arg_reg_chunks(arg_id, arg_idx, instr) > 1 {
				g.unsupported_windows_abi_arg('aggregate register splitting reached codegen; ' +
					'expected ABI lowering before codegen to pass it indirectly or as one legal slot',
					arg_id)
			}
		}
		return stack_args
	}

	mut reg_arg_idx := arg_position_base
	mut sse_arg_idx := 0
	float_arg_regs := g.abi.float_arg_regs()
	for arg_idx := 0; arg_idx < num_args; arg_idx++ {
		arg_id := instr.operands[arg_idx + 1]
		if g.value_is_float_type(arg_id) {
			g.ensure_float_abi_scalar(arg_id, 'argument')
			if sse_arg_idx >= float_arg_regs.len {
				g.unsupported_float_abi('stack argument', arg_id)
			}
			sse_arg_idx++
			continue
		}
		if !g.call_arg_is_indirect(arg_id, arg_idx, instr) && g.value_is_aggregate(arg_id)
			&& arg_idx < instr.abi_arg_layouts.len && instr.abi_arg_layouts[arg_idx].locs.len > 0 {
			layout := instr.abi_arg_layouts[arg_idx]
			g.ensure_sysv_direct_aggregate_supported(arg_id, layout.value_class, 'argument')
			stack_args[arg_idx] = sysv_layout_uses_stack(layout)
			int_limit, sse_limit := sysv_layout_register_limits(layout)
			if int_limit > reg_arg_idx {
				reg_arg_idx = int_limit
			}
			if sse_limit > sse_arg_idx {
				sse_arg_idx = sse_limit
			}
			continue
		}
		if arg_idx < instr.abi_arg_classes.len {
			g.ensure_sysv_direct_aggregate_supported(arg_id, instr.abi_arg_classes[arg_idx],
				'argument')
		}
		arg_chunks := g.call_arg_reg_chunks(arg_id, arg_idx, instr)
		if reg_arg_idx + arg_chunks <= abi_reg_count {
			reg_arg_idx += arg_chunks
		} else {
			stack_args[arg_idx] = true
		}
	}
	return stack_args
}

fn (g Gen) call_stack_slots(instr mir.Instruction, stack_args []bool) int {
	mut slots := 0
	for arg_idx, is_stack in stack_args {
		if is_stack {
			slots += g.call_arg_stack_slots(instr.operands[arg_idx + 1], arg_idx, instr)
		}
	}
	return slots
}

fn (mut g Gen) push_call_stack_arg(val_id int, arg_idx int, instr mir.Instruction) {
	is_indirect := g.call_arg_is_indirect(val_id, arg_idx, instr)
	size := g.type_size(g.mod.values[val_id].typ)
	slots := g.call_arg_stack_slots(val_id, arg_idx, instr)
	if !is_indirect && slots > 1 {
		g.load_struct_src_address_to_reg(int(r10), val_id, g.mod.values[val_id].typ)
		for chunk := slots - 1; chunk >= 0; chunk-- {
			chunk_size := if chunk == slots - 1 { size - chunk * 8 } else { 8 }
			g.load_raw_mem_to_reg(rax, r10, chunk * 8, chunk_size)
			asm_push(mut g, rax)
		}
		return
	}
	g.load_call_arg_to_reg(0, val_id, arg_idx, instr)
	asm_push(mut g, rax)
}

fn (mut g Gen) load_aggregate_arg_to_regs(val_id int, regs []int, size int) {
	g.load_struct_src_address_to_reg(int(r10), val_id, g.mod.values[val_id].typ)
	for chunk, reg in regs {
		chunk_size := if chunk == regs.len - 1 { size - chunk * 8 } else { 8 }
		g.load_raw_mem_to_reg(Reg(reg), r10, chunk * 8, chunk_size)
	}
}

fn (mut g Gen) load_struct_src_address_to_reg(reg int, val_id int, expected_struct_typ int) {
	val := g.mod.values[val_id]
	if val.kind == .string_literal {
		g.materialize_string_literal(reg, val_id)
		return
	}
	if val.typ > 0 && val.typ < g.mod.type_store.types.len {
		val_typ := g.mod.type_store.types[val.typ]
		if val_typ.kind == .ptr_t && val_typ.elem_type == expected_struct_typ {
			g.load_val_to_reg(reg, val_id)
			return
		}
	}
	g.load_address_of_val_to_reg(reg, val_id)
}

fn (mut g Gen) copy_indirect_param_from_reg(param_id int, src_reg int) {
	param_typ := g.mod.values[param_id].typ
	param_size := g.type_size(param_typ)
	if param_size <= 0 {
		offset := g.stack_map[param_id]
		asm_store_rbp_disp_reg(mut g, offset, Reg(src_reg))
		return
	}
	if src_reg != int(r10) {
		asm_mov_reg_reg(mut g, r10, Reg(src_reg))
	}
	g.load_address_of_val_to_reg(int(r11), param_id)
	g.copy_memory(int(r11), 0, int(r10), 0, param_size)
}

fn (mut g Gen) load_val_to_reg(reg int, val_id int) {
	val := g.mod.values[val_id]
	if val.kind == .constant {
		if val.name.starts_with('"') {
			str_content := val.name.trim('"')
			// Handle escapes like arm64.v
			mut raw_bytes := []u8{}
			mut i := 0
			for i < str_content.len {
				if str_content[i] == `\\` && i + 1 < str_content.len {
					match str_content[i + 1] {
						`n` { raw_bytes << 10 }
						`t` { raw_bytes << 9 }
						`r` { raw_bytes << 13 }
						`\\` { raw_bytes << 92 }
						`"` { raw_bytes << 34 }
						`'` { raw_bytes << 39 }
						else { raw_bytes << str_content[i + 1] }
					}

					i += 2
				} else {
					raw_bytes << str_content[i]
					i++
				}
			}

			str_offset := g.rodata_len()
			g.add_rodata(raw_bytes)
			g.add_rodata_byte(0)
			sym_name := 'L_str_${g.curr_offset}_${str_offset}'
			sym_idx := g.add_symbol(sym_name, u64(str_offset), false, .rodata)

			// lea reg, [rip + disp]
			asm_lea_reg_rip(mut g, Reg(reg))
			g.add_rip_reloc(sym_idx)
			g.emit_u32(0)
		} else {
			int_val := val.name.i64()
			if int_val == 0 {
				asm_xor_reg_reg(mut g, Reg(reg))
			} else if int_val > 0 && int_val <= 0x7FFFFFFF {
				asm_mov_reg_imm32(mut g, Reg(reg), u32(int_val))
			} else {
				asm_mov_reg_imm64(mut g, Reg(reg), u64(int_val))
			}
		}
	} else if val.kind == .func_ref {
		sym_idx := g.add_undefined(val.name)
		asm_lea_reg_rip(mut g, Reg(reg))
		g.add_rip_reloc(sym_idx)
		g.emit_u32(0)
	} else if val.kind == .c_string_literal {
		g.materialize_c_string_literal(reg, val_id)
	} else if val.kind == .global {
		sym_idx := g.add_undefined(val.name)
		if g.obj_format == .macho && val.index >= 0 && val.index < g.mod.globals.len
			&& g.mod.globals[val.index].linkage == .external {
			asm_mov_reg_got_rip(mut g, Reg(reg))
			g.add_macho_got_load_reloc(sym_idx)
		} else {
			asm_lea_reg_rip(mut g, Reg(reg))
			g.add_rip_reloc(sym_idx)
		}
		g.emit_u32(0)
	} else if val.kind == .string_literal {
		g.materialize_string_literal(reg, val_id)
	} else {
		if val.kind == .instruction {
			instr := g.mod.instrs[val.index]
			if instr.op == .alloca {
				if off := g.alloca_offsets[val_id] {
					asm_lea_reg_rbp_disp(mut g, Reg(reg), off)
					return
				}
			}
		}
		if reg_idx := g.reg_map[val_id] {
			if reg_idx != reg {
				asm_mov_reg_reg(mut g, Reg(reg), Reg(reg_idx))
			}
		} else {
			offset := g.stack_map[val_id]
			asm_load_reg_rbp_disp(mut g, Reg(reg), offset)
		}
	}
}

fn (mut g Gen) materialize_c_string_literal(reg int, val_id int) {
	val := g.mod.values[val_id]
	raw_bytes := decode_c_string_literal_bytes(val.name)
	str_offset := g.rodata_len()
	g.add_rodata(raw_bytes)
	g.add_rodata_byte(0)
	sym_name := 'L_cstr_${g.curr_offset}_${str_offset}'
	sym_idx := g.add_symbol(sym_name, u64(str_offset), false, .rodata)
	asm_lea_reg_rip(mut g, Reg(reg))
	g.add_rip_reloc(sym_idx)
	g.emit_u32(0)
}

fn x64_c_escape_hex_digit(c u8) int {
	if c >= `0` && c <= `9` {
		return int(c - `0`)
	}
	if c >= `a` && c <= `f` {
		return int(c - `a`) + 10
	}
	if c >= `A` && c <= `F` {
		return int(c - `A`) + 10
	}
	return -1
}

fn x64_c_escape_is_octal_digit(c u8) bool {
	return c >= `0` && c <= `7`
}

fn decode_c_string_literal_bytes(raw string) []u8 {
	mut raw_bytes := []u8{cap: raw.len}
	mut i := 0
	for i < raw.len {
		if raw[i] == `\\` && i + 1 < raw.len {
			next := raw[i + 1]
			if x64_c_escape_is_octal_digit(next) {
				mut j := i + 1
				mut value := u32(0)
				mut digits := 0
				for j < raw.len && digits < 3 && x64_c_escape_is_octal_digit(raw[j]) {
					value = (value * 8 + u32(raw[j] - `0`)) & 0xff
					j++
					digits++
				}
				raw_bytes << u8(value)
				i = j
				continue
			}
			match next {
				`a` {
					raw_bytes << 7
				}
				`b` {
					raw_bytes << 8
				}
				`f` {
					raw_bytes << 12
				}
				`n` {
					raw_bytes << 10
				}
				`t` {
					raw_bytes << 9
				}
				`r` {
					raw_bytes << 13
				}
				`v` {
					raw_bytes << 11
				}
				`\\` {
					raw_bytes << 92
				}
				`"` {
					raw_bytes << 34
				}
				`'` {
					raw_bytes << 39
				}
				`?` {
					raw_bytes << 63
				}
				`x` {
					mut j := i + 2
					mut value := u32(0)
					mut saw_digit := false
					for j < raw.len {
						digit := x64_c_escape_hex_digit(raw[j])
						if digit < 0 {
							break
						}
						value = ((value << 4) + u32(digit)) & 0xff
						saw_digit = true
						j++
					}
					if saw_digit {
						raw_bytes << u8(value)
						i = j
						continue
					}
					raw_bytes << next
				}
				else {
					raw_bytes << next
				}
			}

			i += 2
		} else {
			raw_bytes << raw[i]
			i++
		}
	}
	return raw_bytes
}

fn (mut g Gen) store_reg_to_val(reg int, val_id int) {
	if reg_idx := g.reg_map[val_id] {
		if reg_idx != reg {
			asm_mov_reg_reg(mut g, Reg(reg_idx), Reg(reg))
		}
	} else {
		offset := g.stack_map[val_id]
		asm_store_rbp_disp_reg(mut g, offset, Reg(reg))
	}
}

fn (mut g Gen) materialize_string_literal(reg int, val_id int) {
	val := g.mod.values[val_id]
	str_offset := g.rodata_len()
	g.add_rodata(val.name.bytes())
	g.add_rodata_byte(0)
	sym_name := 'L_str_${g.curr_offset}_${str_offset}'
	sym_idx := g.add_symbol(sym_name, u64(str_offset), false, .rodata)

	slot_off := g.stack_map[val_id]
	asm_lea_reg_rip(mut g, rax)
	g.add_rip_reloc(sym_idx)
	g.emit_u32(0)
	mut str_field_size := g.type_size(g.struct_field_type(val.typ, 0, 0))
	if str_field_size <= 0 {
		str_field_size = 8
	}
	mut len_field_size := g.type_size(g.struct_field_type(val.typ, 1, 0))
	if len_field_size <= 0 {
		len_field_size = 8
	}
	mut is_lit_field_size := g.type_size(g.struct_field_type(val.typ, 2, 0))
	if is_lit_field_size <= 0 {
		is_lit_field_size = 8
	}
	asm_store_rbp_disp_reg_size(mut g, slot_off + g.struct_field_offset_bytes(val.typ, 0), rax,
		str_field_size)
	asm_mov_reg_imm32(mut g, rax, u32(val.index))
	asm_store_rbp_disp_reg_size(mut g, slot_off + g.struct_field_offset_bytes(val.typ, 1), rax,
		len_field_size)
	asm_mov_reg_imm32(mut g, rax, 1)
	asm_store_rbp_disp_reg_size(mut g, slot_off + g.struct_field_offset_bytes(val.typ, 2), rax,
		is_lit_field_size)
	if slot_off >= -128 && slot_off <= 127 {
		asm_lea_rax_rbp_disp8(mut g, i8(slot_off))
	} else {
		asm_lea_rax_rbp_disp32(mut g, slot_off)
	}
	if reg != 0 {
		asm_mov_reg_reg(mut g, Reg(reg), rax)
	}
}

fn (mut g Gen) load_float_val_to_xmm(xmm int, val_id int, size int) {
	val := g.mod.values[val_id]
	if val.kind == .constant {
		if size == 4 {
			asm_mov_reg_imm32(mut g, rax, bits.f32_bits(val.name.f32()))
		} else {
			asm_mov_reg_imm64(mut g, rax, bits.f64_bits(val.name.f64()))
		}
		asm_store_rbp_disp_reg_size(mut g, g.stack_map[val_id], rax, size)
	}
	asm_load_xmm_rbp_disp(mut g, xmm, g.stack_map[val_id], size)
}

fn (g Gen) type_size(typ_id ssa.TypeID) int {
	if typ_id == 0 {
		return 0
	}
	if typ_id < 0 || typ_id >= g.mod.type_store.types.len {
		return 8
	}
	typ := g.mod.type_store.types[typ_id]
	match typ.kind {
		.void_t {
			return 0
		}
		.int_t {
			return if typ.width > 0 { (typ.width + 7) / 8 } else { 8 }
		}
		.float_t {
			return if typ.width > 0 { (typ.width + 7) / 8 } else { 8 }
		}
		.ptr_t {
			return 8
		}
		.array_t {
			return typ.len * g.type_size(typ.elem_type)
		}
		.struct_t {
			if typ.is_union {
				mut max_size := 0
				mut max_align := 1
				for field_typ in typ.fields {
					field_size := g.type_size(field_typ)
					if field_size > max_size {
						max_size = field_size
					}
					field_align := g.type_align(field_typ)
					if field_align > max_align {
						max_align = field_align
					}
				}
				if max_align > 1 && max_size % max_align != 0 {
					max_size = (max_size + max_align - 1) & ~(max_align - 1)
				}
				return if max_size > 0 { max_size } else { 8 }
			}
			mut total := 0
			mut max_align := 1
			for field_typ in typ.fields {
				align := g.type_align(field_typ)
				if align > max_align {
					max_align = align
				}
				if align > 1 && total % align != 0 {
					total = (total + align - 1) & ~(align - 1)
				}
				total += g.type_size(field_typ)
			}
			if max_align > 1 && total % max_align != 0 {
				total = (total + max_align - 1) & ~(max_align - 1)
			}
			return if total > 0 { total } else { 8 }
		}
		.func_t {
			return 8
		}
		.label_t, .metadata_t {
			return 0
		}
	}
}

fn (g Gen) type_align(typ_id ssa.TypeID) int {
	if typ_id > 0 && typ_id < g.mod.type_store.types.len {
		typ := g.mod.type_store.types[typ_id]
		if typ.kind == .array_t {
			return g.type_align(typ.elem_type)
		}
		if typ.kind == .struct_t && typ.is_union {
			mut max_align := 1
			for field_typ in typ.fields {
				align := g.type_align(field_typ)
				if align > max_align {
					max_align = align
				}
			}
			return max_align
		}
	}
	size := g.type_size(typ_id)
	if size >= 8 {
		return 8
	}
	if size >= 4 {
		return 4
	}
	if size >= 2 {
		return 2
	}
	return 1
}

fn (mut g Gen) load_address_of_val_to_reg(reg int, val_id int) {
	if val_id > 0 && val_id < g.mod.values.len && g.mod.values[val_id].kind == .string_literal {
		g.materialize_string_literal(reg, val_id)
		return
	}
	offset := g.stack_map[val_id]
	if offset != 0 {
		if offset >= -128 && offset <= 127 {
			asm_lea_rax_rbp_disp8(mut g, i8(offset))
		} else {
			asm_lea_rax_rbp_disp32(mut g, offset)
		}
		if reg != 0 {
			asm_mov_reg_reg(mut g, Reg(reg), rax)
		}
		return
	}
	// Fallback: value already holds a pointer.
	g.load_val_to_reg(reg, val_id)
}

fn (g Gen) map_reg(r int) u8 {
	return u8(r)
}

fn (mut g Gen) record_pending_label(blk int) {
	off := g.text_len() - g.curr_offset
	g.pending_labels[blk] << off
}

// Register Allocation Logic

fn (mut g Gen) allocate_registers(func mir.Function) {
	if g.abi == .windows {
		return
	}
	mut intervals := map[int]&Interval{}
	mut instr_idx := 0
	mut total_instrs := 0

	for blk_id in func.blocks {
		total_instrs += g.mod.blocks[blk_id].instrs.len
	}

	// Phi elimination lowers edge copies as `.assign dest, src` and leaves
	// placeholder `.bitcast` values for former phis. Keep these CFG-carried
	// values on the stack so branch order does not decide register lifetime.
	mut phi_related_vals := map[int]bool{}
	for blk_id in func.blocks {
		blk := g.mod.blocks[blk_id]
		for val_id in blk.instrs {
			val := g.mod.values[val_id]
			if val.kind != .instruction {
				continue
			}
			instr := g.mod.instrs[val.index]
			if instr.op == .assign {
				phi_related_vals[val_id] = true
				if instr.operands.len > 0 {
					phi_related_vals[instr.operands[0]] = true
				}
				if instr.operands.len > 1 {
					phi_related_vals[instr.operands[1]] = true
				}
			} else if instr.op == .bitcast && instr.operands.len == 0 {
				phi_related_vals[val_id] = true
			}
		}
	}

	// Track which values are alloca results - don't register allocate these
	// as they hold addresses that may be needed across the function
	mut alloca_vals := map[int]bool{}

	for i, pid in func.params {
		param_size := g.type_size(g.mod.values[pid].typ)
		if i < func.abi_param_class.len && func.abi_param_class[i] == .indirect {
			alloca_vals[pid] = true
			continue
		}
		if g.value_is_float_type(pid) {
			alloca_vals[pid] = true
			continue
		}
		if g.value_is_aggregate(pid) || param_size > 8
			|| g.value_needs_raw_abi_reg_bytes(pid, param_size) {
			alloca_vals[pid] = true
			continue
		}
		intervals[pid] = &Interval{
			val_id: pid
			start:  0
			// ABI lowering can hide original parameter uses inside selected call sequences.
			// Keep incoming parameters live across the function to avoid reusing their
			// callee-saved register while later calls still need the parameter value.
			end: total_instrs
		}
	}

	for blk_id in func.blocks {
		blk := g.mod.blocks[blk_id]
		for val_id in blk.instrs {
			val := g.mod.values[val_id]
			if val.kind == .instruction || val.kind == .argument {
				if unsafe { intervals[val_id] == nil } && !(val.kind == .instruction
					&& g.value_needs_stack_storage(val_id)) && val_id !in phi_related_vals {
					intervals[val_id] = &Interval{
						val_id: val_id
						start:  instr_idx
						end:    instr_idx
					}
				}
			}
			instr := g.mod.instrs[val.index]
			// Mark alloca results as non-register-allocatable
			if instr.op in [.alloca, .call_sret] || g.value_needs_stack_storage(val_id) {
				alloca_vals[val_id] = true
			}
			for op in instr.operands {
				if op in phi_related_vals {
					continue
				}
				if g.mod.values[op].kind in [.instruction, .argument] {
					if mut interval := intervals[op] {
						if instr_idx > interval.end {
							interval.end = instr_idx
						}
					}
				}
			}
			instr_idx++
		}
	}

	mut block_of_def := map[int]int{}
	for blk_id in func.blocks {
		blk := g.mod.blocks[blk_id]
		for val_id in blk.instrs {
			block_of_def[val_id] = blk_id
		}
	}
	for blk_id in func.blocks {
		blk := g.mod.blocks[blk_id]
		for val_id in blk.instrs {
			val := g.mod.values[val_id]
			if val.kind != .instruction {
				continue
			}
			instr := g.mod.instrs[val.index]
			for op in instr.operands {
				if op in phi_related_vals {
					continue
				}
				if g.mod.values[op].kind in [.instruction, .argument] {
					if def_blk := block_of_def[op] {
						if def_blk != blk_id {
							if mut interval := intervals[op] {
								interval.end = total_instrs
							}
						}
					}
				}
			}
		}
	}

	mut sorted := []&Interval{}
	for _, i in intervals {
		sorted << i
		mut j := sorted.len - 1
		for j > 0 && sorted[j - 1].start > sorted[j].start {
			sorted[j - 1], sorted[j] = sorted[j], sorted[j - 1]
			j--
		}
	}

	mut active := []&Interval{}
	// Use callee-saved registers: RBX(3), R12(12), R13(13), R14(14), R15(15)
	regs := [3, 12, 13, 14, 15]

	for i in sorted {
		// Skip alloca results - they must stay on stack to preserve addresses
		if alloca_vals[i.val_id] {
			continue
		}
		for j := 0; j < active.len; j++ {
			if active[j].end < i.start {
				active.delete(j)
				j--
			}
		}
		if active.len < regs.len {
			mut used := []bool{len: 16, init: false}
			for a in active {
				used[g.reg_map[a.val_id]] = true
			}
			for r in regs {
				if !used[r] {
					g.reg_map[i.val_id] = r
					active << i
					if r !in g.used_regs {
						g.used_regs << r
					}
					break
				}
			}
		}
	}
	g.used_regs.sort()
}

fn (g Gen) value_is_aggregate(val_id int) bool {
	if val_id <= 0 || val_id >= g.mod.values.len {
		return false
	}
	typ_id := g.mod.values[val_id].typ
	if typ_id <= 0 || typ_id >= g.mod.type_store.types.len {
		return false
	}
	typ := g.mod.type_store.types[typ_id]
	return typ.kind in [.struct_t, .array_t]
}

fn (g Gen) value_is_float_type(val_id int) bool {
	if val_id <= 0 || val_id >= g.mod.values.len {
		return false
	}
	typ_id := g.mod.values[val_id].typ
	if typ_id <= 0 || typ_id >= g.mod.type_store.types.len {
		return false
	}
	return g.mod.type_store.types[typ_id].kind == .float_t
}

fn (g Gen) ensure_float_abi_scalar(val_id int, context string) {
	size := g.type_size(g.mod.values[val_id].typ)
	if size == 4 || size == 8 {
		return
	}
	g.unsupported_float_abi(context, val_id)
}

fn (g Gen) unsupported_float_abi(context string, val_id int) {
	size := g.type_size(g.mod.values[val_id].typ)
	subject := if context == 'stack parameter' {
		'stack-passed float parameter'
	} else if context == 'stack argument' {
		'stack-passed float argument'
	} else {
		'float ${context}'
	}
	x64_unsupported('backend feature: ${subject} (${size * 8}-bit type in value ${val_id}) ' +
		'is not implemented for this ABI yet')
}

fn (g Gen) value_is_zero_constant(val_id int) bool {
	if val_id <= 0 || val_id >= g.mod.values.len {
		return false
	}
	val := g.mod.values[val_id]
	return val.kind == .constant && val.name == '0'
}

fn (g Gen) value_needs_raw_abi_reg_bytes(val_id int, size int) bool {
	return size > 0 && size <= 8 && (g.value_is_aggregate(val_id) || is_raw_abi_reg_size(size))
}

fn (g Gen) stack_storage_size(val_id int) int {
	if val_id <= 0 || val_id >= g.mod.values.len {
		return 8
	}
	val := g.mod.values[val_id]
	size := g.type_size(val.typ)
	if val.kind == .string_literal && size < 16 {
		return 16
	}
	if g.value_is_aggregate(val_id) {
		return if size > 0 { size } else { 8 }
	}
	return if size > 8 { size } else { 8 }
}

fn (g Gen) value_needs_stack_storage(val_id int) bool {
	if val_id <= 0 || val_id >= g.mod.values.len {
		return false
	}
	val := g.mod.values[val_id]
	if val.kind == .string_literal {
		return true
	}
	if g.value_is_eliminated_phi_placeholder(val_id) {
		return true
	}
	if val.typ <= 0 || val.typ >= g.mod.type_store.types.len {
		return false
	}
	if val.kind == .instruction {
		instr := g.mod.instrs[val.index]
		if instr.op == .bitcast && instr.operands.len > 0
			&& g.bitcast_touches_pointer(instr.operands[0], val.typ) {
			return false
		}
	}
	typ := g.mod.type_store.types[val.typ]
	if typ.kind == .float_t {
		return true
	}
	if typ.kind in [.struct_t, .array_t] || g.type_size(val.typ) > 8 {
		return true
	}
	if val.kind != .instruction {
		return false
	}
	instr := g.mod.instrs[val.index]
	return instr.op in [.call_sret, .inline_string_init, .struct_init, .insertvalue, .extractvalue]
}

fn (g Gen) value_is_eliminated_phi_placeholder(val_id int) bool {
	if val_id <= 0 || val_id >= g.mod.values.len {
		return false
	}
	val := g.mod.values[val_id]
	if val.kind != .instruction || val.uses.len == 0 {
		return false
	}
	if val.index < 0 || val.index >= g.mod.instrs.len {
		return false
	}
	instr := g.mod.instrs[val.index]
	return instr.op == .bitcast && instr.operands.len == 0
}

fn (g Gen) bitcast_touches_pointer(src_id int, dst_typ int) bool {
	if dst_typ > 0 && dst_typ < g.mod.type_store.types.len
		&& g.mod.type_store.types[dst_typ].kind == .ptr_t {
		return true
	}
	if src_id <= 0 || src_id >= g.mod.values.len {
		return false
	}
	src_typ := g.mod.values[src_id].typ
	return src_typ > 0 && src_typ < g.mod.type_store.types.len
		&& g.mod.type_store.types[src_typ].kind == .ptr_t
}