module x64

import os
import v2.mir
import v2.ssa

fn temp_object_path(name string) string {
	return os.join_path(os.vtmp_dir(), 'v2_x64_${name}_${os.getpid()}.o')
}

fn read_u32_le(data []u8, off int) u32 {
	return u32(data[off]) | (u32(data[off + 1]) << 8) | (u32(data[off + 2]) << 16) | (u32(data[
		off + 3]) << 24)
}

fn read_u16_le(data []u8, off int) u16 {
	return u16(data[off]) | (u16(data[off + 1]) << 8)
}

fn read_u64_le(data []u8, off int) u64 {
	return u64(read_u32_le(data, off)) | (u64(read_u32_le(data, off + 4)) << 32)
}

fn read_string(data []u8, off int) string {
	mut end := off
	for end < data.len && data[end] != 0 {
		end++
	}
	return data[off..end].bytestr()
}

fn read_fixed_string(data []u8, off int, len int) string {
	return data[off..off + len].bytestr().trim_right('\0')
}

fn test_decode_c_string_literal_bytes_handles_hex_octal_and_standard_escapes() {
	got := decode_c_string_literal_bytes(r'\x00username\xff\xfe\101\n\t\r\a\b\f\v\\\"')
	assert got == [u8(0), `u`, `s`, `e`, `r`, `n`, `a`, `m`, `e`, 0xff, 0xfe, `A`, 10, 9, 13, 7,
		8, 12, 11, 92, 34]
}

fn new_macho_global_codegen_test_module(name string, linkage ssa.Linkage) mir.Module {
	mut ts := ssa.TypeStore.new()
	i8_t := ts.get_int(8)
	ptr_t := ts.get_ptr(i8_t)
	ptr_ptr_t := ts.get_ptr(ptr_t)
	return mir.Module{
		type_store: unsafe { *ts }
		values:     [
			mir.Value{
				id:    0
				typ:   ptr_ptr_t
				index: 0
				kind:  .global
				name:  name
			},
		]
		globals:    [
			ssa.GlobalVar{
				name:    name
				typ:     ptr_t
				linkage: linkage
			},
		]
	}
}

fn new_func_ref_codegen_test_module(name string) mir.Module {
	mut ts := ssa.TypeStore.new()
	i8_t := ts.get_int(8)
	ptr_t := ts.get_ptr(i8_t)
	return mir.Module{
		type_store: unsafe { *ts }
		values:     [
			mir.Value{
				id:    0
				typ:   ptr_t
				index: 0
				kind:  .func_ref
				name:  name
			},
		]
	}
}

fn new_windows_coff_global_codegen_test_module() mir.Module {
	mut ts := ssa.TypeStore.new()
	i64_t := ts.get_int(64)
	ptr_i64_t := ts.get_ptr(i64_t)
	return mir.Module{
		type_store: unsafe { *ts }
		values:     [
			mir.Value{
				id:    0
				typ:   ptr_i64_t
				index: 0
				kind:  .global
				name:  'keep_global'
			},
			mir.Value{
				id:    1
				typ:   ptr_i64_t
				index: 1
				kind:  .global
				name:  'drop_global'
			},
			mir.Value{
				id:    2
				typ:   ptr_i64_t
				index: 0
				kind:  .instruction
			},
		]
		instrs:     [
			mir.Instruction{
				op:       .ret
				operands: [0]
				typ:      ptr_i64_t
				block:    0
			},
		]
		blocks:     [
			mir.BasicBlock{
				id:     0
				val_id: 2
				name:   'entry'
				parent: 0
				instrs: [2]
			},
		]
		funcs:      [
			mir.Function{
				id:     0
				name:   'main'
				typ:    ptr_i64_t
				blocks: [0]
			},
		]
		globals:    [
			ssa.GlobalVar{
				name:         'keep_global'
				typ:          i64_t
				linkage:      .private
				initial_data: [u8(1), 2, 3, 4, 5, 6, 7, 8]
			},
			ssa.GlobalVar{
				name:         'drop_global'
				typ:          i64_t
				linkage:      .private
				initial_data: [u8(9), 10, 11, 12, 13, 14, 15, 16]
			},
		]
	}
}

fn coff_test_symbol(obj &CoffObject, name string) ?CoffSymbol {
	for sym in obj.symbols {
		if sym.name == name {
			return sym
		}
	}
	return none
}

struct TestByteRange {
	label string
	start u64
	limit u64
}

fn make_byte_range(label string, start u64, size u64) TestByteRange {
	return TestByteRange{
		label: label
		start: start
		limit: start + size
	}
}

fn assert_range_in_file(data []u8, range TestByteRange) {
	assert range.start <= range.limit
	assert range.limit <= u64(data.len)
}

fn assert_ranges_do_not_overlap(ranges []TestByteRange) {
	for i in 0 .. ranges.len {
		for j in i + 1 .. ranges.len {
			if ranges[i].start == ranges[i].limit || ranges[j].start == ranges[j].limit {
				continue
			}
			assert ranges[i].limit <= ranges[j].start || ranges[j].limit <= ranges[i].start
		}
	}
}

struct ElfTestSection {
	name     string
	name_idx u32
	type_    u32
	flags    u64
	offset   u64
	size     u64
	link     u32
	info     u32
	align    u64
	entsize  u64
}

fn elf_test_sections(data []u8) []ElfTestSection {
	shoff := int(read_u64_le(data, 40))
	shentsize := int(read_u16_le(data, 58))
	shnum := int(read_u16_le(data, 60))
	shstrndx := int(read_u16_le(data, 62))
	shstr_off := int(read_u64_le(data, shoff + shstrndx * shentsize + 24))

	mut sections := []ElfTestSection{cap: shnum}
	for i in 0 .. shnum {
		off := shoff + i * shentsize
		name_idx := int(read_u32_le(data, off))
		sections << ElfTestSection{
			name:     read_string(data, shstr_off + name_idx)
			name_idx: u32(name_idx)
			type_:    read_u32_le(data, off + 4)
			flags:    read_u64_le(data, off + 8)
			offset:   read_u64_le(data, off + 24)
			size:     read_u64_le(data, off + 32)
			link:     read_u32_le(data, off + 40)
			info:     read_u32_le(data, off + 44)
			align:    read_u64_le(data, off + 48)
			entsize:  read_u64_le(data, off + 56)
		}
	}
	return sections
}

fn elf_test_payload_ranges(sections []ElfTestSection) []TestByteRange {
	mut ranges := []TestByteRange{}
	for section in sections {
		if section.size == 0 {
			continue
		}
		ranges << make_byte_range(section.name, section.offset, section.size)
	}
	return ranges
}

struct MachOTestSection {
	sectname string
	segname  string
	addr     u64
	size     u64
	offset   u32
	align    u32
	reloff   u32
	nreloc   u32
	flags    u32
}

struct MachOTestSymbol {
	name  string
	type_ u8
	sect  u8
	desc  u16
	value u64
}

struct MachOTestRelocation {
	addr    u32
	sym_idx int
	pcrel   bool
	length  int
	extern  bool
	type_   int
}

fn macho_test_load_commands(data []u8) []int {
	ncmds := int(read_u32_le(data, 16))
	mut off := 32
	mut cmds := []int{cap: ncmds}
	for _ in 0 .. ncmds {
		cmds << off
		off += int(read_u32_le(data, off + 4))
	}
	assert off == 32 + int(read_u32_le(data, 20))
	assert off <= data.len
	return cmds
}

fn macho_test_sections(data []u8, seg_cmd_off int) []MachOTestSection {
	nsects := int(read_u32_le(data, seg_cmd_off + 64))
	mut sections := []MachOTestSection{cap: nsects}
	for i in 0 .. nsects {
		off := seg_cmd_off + 72 + i * 80
		sections << MachOTestSection{
			sectname: read_fixed_string(data, off, 16)
			segname:  read_fixed_string(data, off + 16, 16)
			addr:     read_u64_le(data, off + 32)
			size:     read_u64_le(data, off + 40)
			offset:   read_u32_le(data, off + 48)
			align:    read_u32_le(data, off + 52)
			reloff:   read_u32_le(data, off + 56)
			nreloc:   read_u32_le(data, off + 60)
			flags:    read_u32_le(data, off + 64)
		}
	}
	return sections
}

fn macho_test_section_ranges(sections []MachOTestSection) []TestByteRange {
	mut ranges := []TestByteRange{}
	for section in sections {
		if section.size == 0 {
			continue
		}
		ranges << make_byte_range(section.sectname, u64(section.offset), section.size)
	}
	return ranges
}

fn macho_test_symbols(data []u8) []MachOTestSymbol {
	load_cmds := macho_test_load_commands(data)
	symtab_cmd_off := load_cmds[1]
	sym_off := int(read_u32_le(data, symtab_cmd_off + 8))
	nsyms := int(read_u32_le(data, symtab_cmd_off + 12))
	str_off := int(read_u32_le(data, symtab_cmd_off + 16))
	mut symbols := []MachOTestSymbol{cap: nsyms}
	for i in 0 .. nsyms {
		off := sym_off + i * 16
		name_off := int(read_u32_le(data, off))
		symbols << MachOTestSymbol{
			name:  read_string(data, str_off + name_off)
			type_: data[off + 4]
			sect:  data[off + 5]
			desc:  read_u16_le(data, off + 6)
			value: read_u64_le(data, off + 8)
		}
	}
	return symbols
}

fn macho_test_symbol_names(data []u8) []string {
	symbols := macho_test_symbols(data)
	mut names := []string{cap: symbols.len}
	for symbol in symbols {
		names << symbol.name
	}
	return names
}

fn macho_test_symbol_by_name(symbols []MachOTestSymbol, name string) ?MachOTestSymbol {
	for symbol in symbols {
		if symbol.name == name {
			return symbol
		}
	}
	return none
}

fn macho_test_text_relocations(data []u8) []MachOTestRelocation {
	load_cmds := macho_test_load_commands(data)
	sections := macho_test_sections(data, load_cmds[0])
	text_section := sections[0]
	mut relocs := []MachOTestRelocation{cap: int(text_section.nreloc)}
	for i in 0 .. int(text_section.nreloc) {
		off := int(text_section.reloff) + i * 8
		info := read_u32_le(data, off + 4)
		relocs << MachOTestRelocation{
			addr:    read_u32_le(data, off)
			sym_idx: int(info & 0x00ff_ffff)
			pcrel:   ((info >> 24) & 1) == 1
			length:  int((info >> 25) & 3)
			extern:  ((info >> 27) & 1) == 1
			type_:   int(info >> 28)
		}
	}
	return relocs
}

fn macho_test_text_bytes(data []u8) []u8 {
	load_cmds := macho_test_load_commands(data)
	sections := macho_test_sections(data, load_cmds[0])
	return data[int(sections[0].offset)..int(sections[0].offset + sections[0].size)]
}

fn macho_test_bytes_index(data []u8, needle []u8) int {
	if needle.len == 0 {
		return 0
	}
	if needle.len > data.len {
		return -1
	}
	for i in 0 .. data.len - needle.len + 1 {
		mut matches := true
		for j in 0 .. needle.len {
			if data[i + j] != needle[j] {
				matches = false
				break
			}
		}
		if matches {
			return i
		}
	}
	return -1
}

fn assert_macho_test_bytes_contains(data []u8, needle []u8, label string) {
	assert macho_test_bytes_index(data, needle) >= 0, label
}

struct CoffTestSection {
	name            string
	virtual_size    u32
	virtual_address u32
	raw_size        u32
	raw_pointer     u32
	reloc_pointer   u32
	line_pointer    u32
	nreloc          u16
	nline           u16
	characteristics u32
}

fn coff_test_sections(data []u8) []CoffTestSection {
	nsections := int(read_u16_le(data, 2))
	mut sections := []CoffTestSection{cap: nsections}
	for i in 0 .. nsections {
		off := 20 + i * 40
		sections << CoffTestSection{
			name:            read_fixed_string(data, off, 8)
			virtual_size:    read_u32_le(data, off + 8)
			virtual_address: read_u32_le(data, off + 12)
			raw_size:        read_u32_le(data, off + 16)
			raw_pointer:     read_u32_le(data, off + 20)
			reloc_pointer:   read_u32_le(data, off + 24)
			line_pointer:    read_u32_le(data, off + 28)
			nreloc:          read_u16_le(data, off + 32)
			nline:           read_u16_le(data, off + 34)
			characteristics: read_u32_le(data, off + 36)
		}
	}
	return sections
}

fn coff_test_section_ranges(sections []CoffTestSection) []TestByteRange {
	mut ranges := []TestByteRange{}
	for section in sections {
		if section.raw_size == 0 {
			continue
		}
		ranges << make_byte_range(section.name, u64(section.raw_pointer), u64(section.raw_size))
	}
	return ranges
}

fn assert_command_ok(res os.Result, label string) {
	assert res.exit_code == 0, '${label} failed: ${res.output}'
}

fn output_has_line_with_all(output string, words []string) bool {
	for line in output.split_into_lines() {
		mut matches := true
		for word in words {
			if !line.contains(word) {
				matches = false
				break
			}
		}
		if matches {
			return true
		}
	}
	return false
}

enum ExternalObjectToolKind {
	llvm_readobj
	llvm_objdump
	otool
	dumpbin
}

struct ExternalObjectTool {
	kind ExternalObjectToolKind
	path string
}

fn find_first_available_external_tool(candidates []ExternalObjectTool) ?ExternalObjectTool {
	for candidate in candidates {
		if path := os.find_abs_path_of_executable(candidate.path) {
			return ExternalObjectTool{
				kind: candidate.kind
				path: path
			}
		}
	}
	return none
}

fn macho_external_tool_candidates() []ExternalObjectTool {
	return [
		ExternalObjectTool{
			kind: .llvm_readobj
			path: 'llvm-readobj-20'
		},
		ExternalObjectTool{
			kind: .llvm_readobj
			path: 'llvm-readobj-19'
		},
		ExternalObjectTool{
			kind: .llvm_readobj
			path: 'llvm-readobj'
		},
		ExternalObjectTool{
			kind: .llvm_readobj
			path: 'llvm-readobj-18'
		},
		ExternalObjectTool{
			kind: .llvm_readobj
			path: 'llvm-readobj-17'
		},
		ExternalObjectTool{
			kind: .llvm_readobj
			path: 'llvm-readobj-16'
		},
		ExternalObjectTool{
			kind: .llvm_objdump
			path: 'llvm-objdump-20'
		},
		ExternalObjectTool{
			kind: .llvm_objdump
			path: 'llvm-objdump-19'
		},
		ExternalObjectTool{
			kind: .llvm_objdump
			path: 'llvm-objdump'
		},
		ExternalObjectTool{
			kind: .llvm_objdump
			path: 'llvm-objdump-18'
		},
		ExternalObjectTool{
			kind: .llvm_objdump
			path: 'llvm-objdump-17'
		},
		ExternalObjectTool{
			kind: .llvm_objdump
			path: 'llvm-objdump-16'
		},
		ExternalObjectTool{
			kind: .otool
			path: 'otool'
		},
	]
}

fn coff_external_tool_candidates() []ExternalObjectTool {
	return [
		ExternalObjectTool{
			kind: .llvm_readobj
			path: 'llvm-readobj-20'
		},
		ExternalObjectTool{
			kind: .llvm_readobj
			path: 'llvm-readobj-19'
		},
		ExternalObjectTool{
			kind: .llvm_readobj
			path: 'llvm-readobj'
		},
		ExternalObjectTool{
			kind: .llvm_readobj
			path: 'llvm-readobj-18'
		},
		ExternalObjectTool{
			kind: .llvm_readobj
			path: 'llvm-readobj-17'
		},
		ExternalObjectTool{
			kind: .llvm_readobj
			path: 'llvm-readobj-16'
		},
		ExternalObjectTool{
			kind: .llvm_objdump
			path: 'llvm-objdump-20'
		},
		ExternalObjectTool{
			kind: .llvm_objdump
			path: 'llvm-objdump-19'
		},
		ExternalObjectTool{
			kind: .llvm_objdump
			path: 'llvm-objdump'
		},
		ExternalObjectTool{
			kind: .llvm_objdump
			path: 'llvm-objdump-18'
		},
		ExternalObjectTool{
			kind: .llvm_objdump
			path: 'llvm-objdump-17'
		},
		ExternalObjectTool{
			kind: .llvm_objdump
			path: 'llvm-objdump-16'
		},
		ExternalObjectTool{
			kind: .dumpbin
			path: 'dumpbin'
		},
		ExternalObjectTool{
			kind: .dumpbin
			path: 'dumpbin.exe'
		},
	]
}

fn output_has_nearby_lines_with_all(output string, anchor string, words []string, radius int) bool {
	lines := output.split_into_lines()
	for i, line in lines {
		if !line.contains(anchor) {
			continue
		}
		start := if i > radius { i - radius } else { 0 }
		limit := if i + radius + 1 < lines.len { i + radius + 1 } else { lines.len }
		mut block := ''
		for candidate in lines[start..limit] {
			block += candidate + '\n'
		}
		mut matches := true
		for word in words {
			if !block.contains(word) {
				matches = false
				break
			}
		}
		if matches {
			return true
		}
	}
	return false
}

fn llvm_readobj_relocation_blocks(output string) []string {
	lines := output.split_into_lines()
	mut blocks := []string{}
	mut in_block := false
	mut depth := 0
	mut block := ''
	for line in lines {
		trimmed := line.trim_space()
		if !in_block {
			if trimmed == 'Relocation {' {
				in_block = true
				depth = 1
				block = line + '\n'
			}
			continue
		}
		block += line + '\n'
		if trimmed.ends_with('{') {
			depth++
		}
		if trimmed == '}' {
			depth--
		}
		if depth == 0 {
			blocks << block
			in_block = false
			block = ''
		}
	}
	return blocks
}

fn llvm_readobj_has_relocation_block(output string, words []string) bool {
	for block in llvm_readobj_relocation_blocks(output) {
		mut matches := true
		for word in words {
			if !block.contains(word) {
				matches = false
				break
			}
		}
		if matches {
			return true
		}
	}
	return false
}

fn test_llvm_readobj_relocation_blocks_groups_expanded_multiline_entries() {
	output := [
		'Relocations [',
		'  Section __text {',
		'    Relocation {',
		'      Offset: 0xF',
		'      Type: X86_64_RELOC_GOT_LOAD (3)',
		'      Symbol: ___stderrp',
		'    }',
		'    Relocation {',
		'      Offset: 0x8',
		'      Type: X86_64_RELOC_SIGNED (1)',
		'      Symbol: L_str_0',
		'    }',
		'  }',
		']',
	].join('\n')
	blocks := llvm_readobj_relocation_blocks(output)
	assert blocks.len == 2
	assert blocks[0].contains('___stderrp')
	assert blocks[0].contains('GOT_LOAD')
	assert !blocks[0].contains('L_str_0')
	assert blocks[1].contains('L_str_0')
	assert blocks[1].contains('SIGNED')
	assert !blocks[1].contains('___stderrp')
}

fn find_first_available_tool(names []string) ?string {
	for name in names {
		if path := os.find_abs_path_of_executable(name) {
			return path
		}
	}
	return none
}

fn test_elf_writer_emits_x64_relocatable_object() {
	path := temp_object_path('elf')
	defer {
		os.rm(path) or {}
	}

	mut obj := ElfObject.new()
	obj.text_data << u8(0xc3)
	obj.add_symbol('main', 0, true, 1)
	obj.write(path)

	data := os.read_bytes(path) or { panic(err) }
	assert data.len > 64
	assert data[0] == 0x7f
	assert data[1] == `E`
	assert data[2] == `L`
	assert data[3] == `F`
	assert data[4] == elfclass64
	assert data[5] == elfdata2lsb
	assert data[6] == ev_current
	assert read_u16_le(data, 16) == et_rel
	assert read_u16_le(data, 18) == em_x86_64
	assert read_u32_le(data, 20) == ev_current
	assert read_u64_le(data, 24) == 0
	assert read_u64_le(data, 32) == 0
	shoff := read_u64_le(data, 40)
	assert shoff >= 64
	assert read_u32_le(data, 48) == 0
	assert read_u16_le(data, 52) == 64
	assert read_u16_le(data, 54) == 0
	assert read_u16_le(data, 56) == 0
	assert read_u16_le(data, 58) == 64
	assert read_u16_le(data, 60) == 8
	assert read_u16_le(data, 62) == 7
	assert_range_in_file(data, make_byte_range('ELF section headers', shoff, u64(read_u16_le(data,
		58)) * u64(read_u16_le(data, 60))))
}

fn test_linux_tiny_elf_writer_emits_exec_program_headers_without_sections() {
	$if linux {
		path := os.join_path(os.vtmp_dir(), 'v2_x64_tiny_elf_${os.getpid()}')
		defer {
			os.rm(path) or {}
		}

		mut obj := ElfObject.new()
		obj.text_data << [u8(0x31), 0xc0, 0xc3] // xor eax, eax; ret
		obj.add_symbol('main', 0, true, 1)
		mut linker := ElfTinyLinker{
			elf: obj
		}
		linker.write(path) or { panic(err) }

		data := os.read_bytes(path) or { panic(err) }
		assert data.len > elf_tiny_text_file_offset(1)
		assert data[0] == 0x7f
		assert data[1] == `E`
		assert data[2] == `L`
		assert data[3] == `F`
		assert read_u16_le(data, 16) == et_exec
		assert read_u16_le(data, 18) == em_x86_64
		assert read_u64_le(data, 24) == linux_tiny_base_vaddr + u64(elf_tiny_text_file_offset(1))
		assert read_u64_le(data, 32) == 64
		assert read_u64_le(data, 40) == 0
		assert read_u16_le(data, 54) == 56
		assert read_u16_le(data, 56) == 1
		assert read_u16_le(data, 58) == 0
		assert read_u16_le(data, 60) == 0
		assert read_u32_le(data, 64) == pt_load
		assert read_u32_le(data, 68) == pf_r | pf_x
	}
}

fn test_linux_tiny_elf_writer_keeps_runtime_metadata_wx_clean() {
	$if linux {
		path := os.join_path(os.vtmp_dir(), 'v2_x64_tiny_elf_runtime_${os.getpid()}')
		defer {
			os.rm(path) or {}
		}

		mut obj := ElfObject.new()
		obj.text_data << [u8(0xbf), 23, 0, 0, 0, 0xe8, 0, 0, 0, 0, 0xc3]
		int_str_sym := obj.add_undefined('builtin__int__str')
		obj.add_symbol('main', 0, true, 1)
		obj.add_text_reloc(6, int_str_sym, r_x86_64_plt32, -4)
		mut linker := ElfTinyLinker{
			elf: obj
		}
		linker.write(path) or { panic(err) }

		data := os.read_bytes(path) or { panic(err) }
		assert data.len > elf_tiny_text_file_offset(2)
		assert data.len < linux_tiny_page_align
		assert read_u16_le(data, 16) == et_exec
		assert read_u16_le(data, 56) == 2
		assert read_u16_le(data, 58) == 0
		assert read_u16_le(data, 60) == 0

		text_ph := 64
		assert read_u32_le(data, text_ph) == pt_load
		assert read_u32_le(data, text_ph + 4) == pf_r | pf_x
		assert read_u64_le(data, text_ph + 8) == 0
		assert read_u64_le(data, text_ph + 16) == linux_tiny_base_vaddr
		text_filesz := read_u64_le(data, text_ph + 32)
		assert text_filesz == read_u64_le(data, text_ph + 40)
		assert read_u64_le(data, text_ph + 48) == u64(linux_tiny_page_align)

		rw_ph := text_ph + 56
		assert read_u32_le(data, rw_ph) == pt_load
		assert read_u32_le(data, rw_ph + 4) == pf_r | pf_w
		rw_offset := read_u64_le(data, rw_ph + 8)
		rw_vaddr := read_u64_le(data, rw_ph + 16)
		rw_align := read_u64_le(data, rw_ph + 48)
		assert read_u64_le(data, rw_ph + 32) == 0
		assert read_u64_le(data, rw_ph + 40) == linux_tiny_int_str_arena_metadata_bytes
		assert rw_align == u64(linux_tiny_page_align)
		assert rw_vaddr % rw_align == rw_offset % rw_align
		assert (read_u32_le(data, text_ph + 4) & u32(pf_w | pf_x)) != u32(pf_w | pf_x)
		assert (read_u32_le(data, rw_ph + 4) & u32(pf_w | pf_x)) != u32(pf_w | pf_x)
	}
}

fn test_linux_tiny_write_runtime_exits_on_non_positive_syscall_result() {
	$if linux {
		mut obj := ElfObject.new()
		mut linker := ElfTinyLinker{
			elf: obj
		}
		rt := linker.build_runtime({
			'write': true
		})
		write_off := int(rt.symbols['write'] or { panic('missing write runtime symbol') })
		write_bytes := rt.text[write_off..]
		mut has_exit_group_failure := false
		mut has_old_partial_success_return := false
		for i in 0 .. write_bytes.len {
			if i + 10 <= write_bytes.len && write_bytes[i] == 0xbf && write_bytes[i + 1] == 0x01
				&& write_bytes[i + 2] == 0 && write_bytes[i + 3] == 0 && write_bytes[i + 4] == 0
				&& write_bytes[i + 5] == 0xb8
				&& read_u32_le(write_bytes, i + 6) == linux_sys_exit_group {
				has_exit_group_failure = true
			}
			if i + 4 <= write_bytes.len && write_bytes[i] == 0x49 && write_bytes[i + 1] == 0x0f
				&& write_bytes[i + 2] == 0x45 && write_bytes[i + 3] == 0xc2 {
				has_old_partial_success_return = true
			}
		}
		assert has_exit_group_failure
		assert !has_old_partial_success_return
	}
}

fn test_elf_writer_serializes_sections_symbols_and_relocations() {
	path := temp_object_path('elf_relocs')
	defer {
		os.rm(path) or {}
	}

	mut obj := ElfObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0x48, 0x8d, 0x05, 0, 0, 0, 0]
	obj.rodata << 'hello'.bytes()
	obj.rodata << 0
	obj.data_data << [u8(1), 2, 3, 4]
	call_sym := obj.add_undefined('calloc')
	main_sym := obj.add_symbol('main', 0, true, 1)
	rodata_sym := obj.add_symbol('L_str_0', 0, false, 3)
	data_sym := obj.add_symbol('app_global', 2, false, 2)
	obj.add_text_reloc(1, call_sym, r_x86_64_plt32, -4)
	obj.add_text_reloc(8, rodata_sym, r_x86_64_pc32, -4)
	obj.write(path)

	data := os.read_bytes(path) or { panic(err) }
	assert read_u64_le(data, 32) == 0
	assert read_u16_le(data, 56) == 0
	sections := elf_test_sections(data)
	assert sections.len == 8
	section_header_range := make_byte_range('ELF section headers', read_u64_le(data, 40),
		u64(read_u16_le(data, 58)) * u64(read_u16_le(data, 60)))
	assert_range_in_file(data, section_header_range)
	mut ranges := [make_byte_range('ELF header', 0, u64(read_u16_le(data, 52))), section_header_range]
	ranges << elf_test_payload_ranges(sections)
	for range in ranges {
		assert_range_in_file(data, range)
	}
	assert_ranges_do_not_overlap(ranges)
	assert sections[0].name == ''
	assert sections[0].name_idx == 0
	assert sections[0].offset == 0
	assert sections[0].size == 0
	assert sections[1].name == '.text'
	assert sections[1].type_ == sht_progbits
	assert sections[1].flags == shf_alloc | shf_execinstr
	assert sections[1].offset % 16 == 0
	assert sections[1].size == u64(obj.text_data.len)
	assert data[int(sections[1].offset)..int(sections[1].offset + sections[1].size)] == obj.text_data
	assert sections[2].name == '.data'
	assert sections[2].type_ == sht_progbits
	assert sections[2].flags == shf_alloc | shf_write
	assert sections[2].offset % 8 == 0
	assert sections[2].size == u64(obj.data_data.len)
	assert data[int(sections[2].offset)..int(sections[2].offset + sections[2].size)] == obj.data_data
	assert sections[3].name == '.rodata'
	assert sections[3].type_ == sht_progbits
	assert sections[3].flags == shf_alloc
	assert sections[3].offset % 4 == 0
	assert sections[3].size == u64(obj.rodata.len)
	assert data[int(sections[3].offset)..int(sections[3].offset + sections[3].size)] == obj.rodata
	assert sections[4].name == '.symtab'
	assert sections[4].type_ == sht_symtab
	assert sections[4].link == 5
	assert sections[4].info == 1
	assert sections[4].align == 8
	assert sections[4].entsize == 24
	assert sections[4].size == u64(obj.symbols.len * 24)
	assert sections[5].name == '.strtab'
	assert sections[5].type_ == sht_strtab
	assert sections[5].align == 1
	assert sections[6].name == '.rela.text'
	assert sections[6].type_ == sht_rela
	assert sections[6].link == 4
	assert sections[6].info == 1
	assert sections[6].align == 8
	assert sections[6].entsize == 24
	assert sections[6].size == 48
	assert sections[7].name == '.shstrtab'
	assert sections[7].type_ == sht_strtab
	for section in sections {
		if section.name != '' {
			assert u64(section.name_idx) < sections[7].size
		}
		if section.align > 1 && section.size > 0 {
			assert section.offset % section.align == 0
		}
	}

	sym_off := int(sections[4].offset)
	str_off := int(sections[5].offset)
	assert read_u32_le(data, sym_off) == 0
	assert data[sym_off + 4] == 0
	assert read_u16_le(data, sym_off + 6) == 0

	call_off := sym_off + call_sym * 24
	call_name_off := int(read_u32_le(data, call_off))
	assert read_string(data, str_off + call_name_off) == 'calloc'
	assert data[call_off + 4] == 0x10
	assert read_u16_le(data, call_off + 6) == 0
	assert read_u64_le(data, call_off + 8) == 0

	main_off := sym_off + main_sym * 24
	main_name_off := int(read_u32_le(data, main_off))
	assert read_string(data, str_off + main_name_off) == 'main'
	assert data[main_off + 4] == 0x12
	assert read_u16_le(data, main_off + 6) == 1
	assert read_u64_le(data, main_off + 8) == 0

	rodata_off := sym_off + rodata_sym * 24
	rodata_name_off := int(read_u32_le(data, rodata_off))
	assert read_string(data, str_off + rodata_name_off) == 'L_str_0'
	assert data[rodata_off + 4] == 0x11
	assert read_u16_le(data, rodata_off + 6) == 3
	assert read_u64_le(data, rodata_off + 8) == 0

	data_off := sym_off + data_sym * 24
	data_name_off := int(read_u32_le(data, data_off))
	assert read_string(data, str_off + data_name_off) == 'app_global'
	assert data[data_off + 4] == 0x11
	assert read_u16_le(data, data_off + 6) == 2
	assert read_u64_le(data, data_off + 8) == 2

	rela_off := int(sections[6].offset)
	assert read_u64_le(data, rela_off) == 1
	assert read_u64_le(data, rela_off + 8) == (u64(call_sym) << 32) | u64(r_x86_64_plt32)
	assert read_u64_le(data, rela_off + 16) == 0xffff_ffff_ffff_fffc
	assert read_u64_le(data, rela_off + 24) == 8
	assert read_u64_le(data, rela_off + 32) == (u64(rodata_sym) << 32) | u64(r_x86_64_pc32)
	assert read_u64_le(data, rela_off + 40) == 0xffff_ffff_ffff_fffc
}

fn test_elf_writer_object_is_accepted_by_linux_binutils() {
	$if linux {
		readelf := os.find_abs_path_of_executable('readelf') or {
			println('skipping ${@FN}: readelf is not available')
			return
		}
		objdump := os.find_abs_path_of_executable('objdump') or {
			println('skipping ${@FN}: objdump is not available')
			return
		}
		path := temp_object_path('elf_binutils')
		defer {
			os.rm(path) or {}
		}

		mut obj := ElfObject.new()
		obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0x48, 0x8d, 0x05, 0, 0, 0, 0]
		obj.rodata << 'hello'.bytes()
		obj.rodata << 0
		obj.data_data << [u8(1), 2, 3, 4]
		call_sym := obj.add_undefined('calloc')
		rodata_sym := obj.add_symbol('L_str_0', 0, false, 3)
		obj.add_symbol('main', 0, true, 1)
		obj.add_text_reloc(1, call_sym, r_x86_64_plt32, -4)
		obj.add_text_reloc(8, rodata_sym, r_x86_64_pc32, -4)
		obj.write(path)

		quoted_path := os.quoted_path(path)
		readelf_header := os.execute('${os.quoted_path(readelf)} -h ${quoted_path}')
		assert_command_ok(readelf_header, 'readelf -h')
		assert readelf_header.output.contains('ELF Header:')
		assert readelf_header.output.contains('Class:                             ELF64')
		assert readelf_header.output.contains("Data:                              2's complement, little endian")
		assert readelf_header.output.contains('Type:                              REL (Relocatable file)')
		assert readelf_header.output.contains('Machine:                           Advanced Micro Devices X86-64')
		assert readelf_header.output.contains('Start of program headers:          0 (bytes into file)')
		assert readelf_header.output.contains('Number of program headers:         0')
		assert readelf_header.output.contains('Size of section headers:           64 (bytes)')
		assert readelf_header.output.contains('Section header string table index: 7')

		readelf_sections := os.execute('${os.quoted_path(readelf)} --wide -S ${quoted_path}')
		assert_command_ok(readelf_sections, 'readelf -S')
		assert readelf_sections.output.contains('There are 8 section headers')
		assert readelf_sections.output.contains('.text')
		assert readelf_sections.output.contains('PROGBITS')
		assert readelf_sections.output.contains('AX')
		assert readelf_sections.output.contains('.data')
		assert readelf_sections.output.contains('WA')
		assert readelf_sections.output.contains('.rodata')
		assert readelf_sections.output.contains('.symtab')
		assert readelf_sections.output.contains('SYMTAB')
		assert readelf_sections.output.contains('.strtab')
		assert readelf_sections.output.contains('.rela.text')
		assert readelf_sections.output.contains('RELA')
		assert readelf_sections.output.contains('.shstrtab')

		readelf_symbols := os.execute('${os.quoted_path(readelf)} --wide -s ${quoted_path}')
		assert_command_ok(readelf_symbols, 'readelf -s')
		assert readelf_symbols.output.contains("Symbol table '.symtab' contains 4 entries")
		assert output_has_line_with_all(readelf_symbols.output,
			['NOTYPE', 'GLOBAL', 'UND', 'calloc'])
		assert output_has_line_with_all(readelf_symbols.output, ['FUNC', 'GLOBAL', '1', 'main'])
		assert output_has_line_with_all(readelf_symbols.output,
			['OBJECT', 'GLOBAL', '3', 'L_str_0'])

		readelf_relocs := os.execute('${os.quoted_path(readelf)} --wide -r ${quoted_path}')
		assert_command_ok(readelf_relocs, 'readelf -r')
		assert readelf_relocs.output.contains("Relocation section '.rela.text'")
		assert readelf_relocs.output.contains('R_X86_64_PLT32')
		assert readelf_relocs.output.contains('calloc')
		assert readelf_relocs.output.contains('R_X86_64_PC32')
		assert readelf_relocs.output.contains('L_str_0')
		assert readelf_relocs.output.contains('- 4')

		objdump_header := os.execute('${os.quoted_path(objdump)} -f ${quoted_path}')
		assert_command_ok(objdump_header, 'objdump -f')
		assert objdump_header.output.contains('file format elf64-x86-64')
		assert objdump_header.output.contains('architecture: i386:x86-64')
		assert objdump_header.output.contains('HAS_RELOC')
		assert objdump_header.output.contains('HAS_SYMS')

		objdump_relocs := os.execute('${os.quoted_path(objdump)} -r ${quoted_path}')
		assert_command_ok(objdump_relocs, 'objdump -r')
		assert objdump_relocs.output.contains('RELOCATION RECORDS FOR [.text]')
		assert objdump_relocs.output.contains('R_X86_64_PLT32')
		assert objdump_relocs.output.contains('calloc')
		assert objdump_relocs.output.contains('R_X86_64_PC32')
		assert objdump_relocs.output.contains('L_str_0')
	} $else {
		println('skipping ${@FN}: Linux binutils validation only runs on Linux')
	}
}

fn test_macho_writer_emits_x64_relocatable_object() {
	path := temp_object_path('macho')
	defer {
		os.rm(path) or {}
	}

	mut obj := MachOObject.new()
	obj.text_data << u8(0xc3)
	obj.add_symbol('_main', 0, true, 1)
	obj.write(path)

	data := os.read_bytes(path) or { panic(err) }
	assert data.len > 64
	assert read_u32_le(data, 0) == macho_mh_magic_64
	assert read_u32_le(data, 4) == u32(macho_cpu_type_x86_64)
	assert read_u32_le(data, 8) == u32(macho_cpu_subtype_x86_64_all)
	assert read_u32_le(data, 12) == u32(macho_mh_object)
	assert read_u32_le(data, 16) == 2
	assert read_u32_le(data, 24) == 0
	assert read_u32_le(data, 28) == 0

	load_cmds := macho_test_load_commands(data)
	assert load_cmds.len == 2
	seg_cmd_off := load_cmds[0]
	load_cmds_size := read_u32_le(data, 20)
	assert_range_in_file(data, make_byte_range('Mach-O header', 0, 32))
	assert_range_in_file(data, make_byte_range('Mach-O load commands', 32, u64(load_cmds_size)))
	assert read_u32_le(data, seg_cmd_off) == u32(macho_lc_segment_64)
	assert read_u32_le(data, seg_cmd_off + 4) == u32(72 + (80 * 3))
	assert read_fixed_string(data, seg_cmd_off + 8, 16) == ''
	assert read_u64_le(data, seg_cmd_off + 24) == 0
	assert read_u64_le(data, seg_cmd_off + 32) >= u64(obj.text_data.len)
	assert read_u64_le(data, seg_cmd_off + 40) % 16 == 0
	assert read_u64_le(data, seg_cmd_off + 48) >= u64(obj.text_data.len)
	assert read_u32_le(data, seg_cmd_off + 56) == 7
	assert read_u32_le(data, seg_cmd_off + 60) == 7
	assert read_u32_le(data, seg_cmd_off + 64) == 3
	assert read_u32_le(data, seg_cmd_off + 68) == 0

	sections := macho_test_sections(data, seg_cmd_off)
	assert sections.len == 3
	assert sections[0].sectname == '__text'
	assert sections[0].segname == '__TEXT'
	assert sections[0].addr == 0
	assert sections[0].size == u64(obj.text_data.len)
	assert sections[0].offset % 16 == 0
	assert sections[0].align == 4
	assert sections[0].nreloc == 0
	assert sections[0].flags == 0x80000400
	assert data[int(sections[0].offset)..int(sections[0].offset + sections[0].size)] == obj.text_data
	assert sections[1].sectname == '__const'
	assert sections[1].segname == '__TEXT'
	assert sections[1].addr % 8 == 0
	assert sections[1].size == u64(obj.rodata.len)
	assert sections[1].offset % 8 == 0
	assert sections[1].align == 3
	assert sections[1].reloff == 0
	assert sections[1].nreloc == 0
	assert sections[2].sectname == '__data'
	assert sections[2].segname == '__DATA'
	assert sections[2].addr % 8 == 0
	assert sections[2].size == u64(obj.data_data.len)
	assert sections[2].offset % 8 == 0
	assert sections[2].align == 3
	assert sections[2].reloff == 0
	assert sections[2].nreloc == 0
	mut macho_ranges := [
		make_byte_range('Mach-O header and load commands', 0, 32 + u64(load_cmds_size)),
	]
	macho_ranges << macho_test_section_ranges(sections)

	symtab_cmd_off := load_cmds[1]
	assert read_u32_le(data, symtab_cmd_off) == u32(macho_lc_symtab)
	assert read_u32_le(data, symtab_cmd_off + 4) == 24
	sym_off := int(read_u32_le(data, symtab_cmd_off + 8))
	nsyms := int(read_u32_le(data, symtab_cmd_off + 12))
	str_off := int(read_u32_le(data, symtab_cmd_off + 16))
	str_size := int(read_u32_le(data, symtab_cmd_off + 20))
	assert nsyms == 1
	assert sym_off % 8 == 0
	assert str_off == sym_off + nsyms * 16
	assert str_size == obj.str_table.len
	macho_ranges << make_byte_range('Mach-O symbol table', u64(sym_off), u64(nsyms * 16))
	macho_ranges << make_byte_range('Mach-O string table', u64(str_off), u64(str_size))
	for range in macho_ranges {
		assert_range_in_file(data, range)
	}
	assert_ranges_do_not_overlap(macho_ranges)
	name_off := int(read_u32_le(data, sym_off))
	assert read_string(data, str_off + name_off) == '_main'
	assert data[sym_off + 4] == 0x0f
	assert data[sym_off + 5] == 1
	assert read_u16_le(data, sym_off + 6) == 0
	assert read_u64_le(data, sym_off + 8) == 0
}

fn test_macho_writer_records_x64_text_relocations() {
	mut obj := MachOObject.new()
	call_sym := obj.add_undefined('_calloc')
	data_sym := obj.add_symbol('L_str_0', 0, false, 2)
	got_sym := obj.add_undefined('___stderrp')
	obj.add_reloc(1, call_sym, x86_64_reloc_branch, true, 2)
	obj.add_reloc(8, data_sym, x86_64_reloc_signed, true, 2)
	obj.add_reloc(15, got_sym, x86_64_reloc_got_load, true, 2)

	assert obj.relocs.len == 3
	assert obj.relocs[0].addr == 1
	assert obj.relocs[0].sym_idx == call_sym
	assert obj.relocs[0].type_ == x86_64_reloc_branch
	assert obj.relocs[0].pcrel
	assert obj.relocs[0].length == 2
	assert obj.relocs[1].addr == 8
	assert obj.relocs[1].sym_idx == data_sym
	assert obj.relocs[1].type_ == x86_64_reloc_signed
	assert obj.relocs[1].pcrel
	assert obj.relocs[1].length == 2
	assert obj.relocs[2].addr == 15
	assert obj.relocs[2].sym_idx == got_sym
	assert obj.relocs[2].type_ == x86_64_reloc_got_load
	assert obj.relocs[2].pcrel
	assert obj.relocs[2].length == 2
}

fn test_macho_writer_serializes_got_load_relocation_for_external_data_symbol() {
	path := temp_object_path('macho_got_load')
	defer {
		os.rm(path) or {}
	}

	mut obj := MachOObject.new()
	obj.text_data << [u8(0x48), 0x8b, 0x05, 0, 0, 0, 0]
	stderr_name := ObjectFormat.macho.symbol_name('__stderrp')
	stderr_sym := obj.add_undefined(stderr_name)
	obj.add_reloc(3, stderr_sym, x86_64_reloc_got_load, true, 2)
	obj.write(path)

	data := os.read_bytes(path) or { panic(err) }
	seg_cmd_off := 32
	text_section_off := seg_cmd_off + 72
	reloc_off := int(read_u32_le(data, text_section_off + 56))
	nreloc := int(read_u32_le(data, text_section_off + 60))
	assert nreloc == 1
	assert_range_in_file(data, make_byte_range('Mach-O GOT_LOAD relocation', u64(reloc_off),
		u64(nreloc * 8)))

	reloc_addr := read_u32_le(data, reloc_off)
	reloc_info := read_u32_le(data, reloc_off + 4)
	assert reloc_addr == 3
	assert reloc_info & 0x00ff_ffff == u32(stderr_sym)
	assert ((reloc_info >> 24) & 1) == 1
	assert ((reloc_info >> 25) & 3) == 2
	assert ((reloc_info >> 27) & 1) == 1
	assert (reloc_info >> 28) == u32(x86_64_reloc_got_load)

	symtab_cmd_off := seg_cmd_off + 72 + (80 * 3)
	sym_off := int(read_u32_le(data, symtab_cmd_off + 8))
	str_off := int(read_u32_le(data, symtab_cmd_off + 16))
	name_off := int(read_u32_le(data, sym_off))
	assert read_string(data, str_off + name_off) == '___stderrp'
	assert data[sym_off + 4] == 0x01
	assert data[sym_off + 5] == 0
}

fn test_macho_codegen_loads_external_data_global_through_got_load() {
	mut mod := new_macho_global_codegen_test_module('__stderrp', .external)
	mut gen := Gen.new_with_format(&mod, .macho)
	gen.load_val_to_reg(0, 0)

	assert gen.macho.text_data == [u8(0x48), 0x8b, 0x05, 0, 0, 0, 0]
	assert gen.macho.relocs.len == 1
	assert gen.macho.relocs[0].addr == 3
	assert gen.macho.relocs[0].type_ == x86_64_reloc_got_load
	assert gen.macho.relocs[0].type_ != x86_64_reloc_signed
	assert gen.macho.relocs[0].pcrel
	assert gen.macho.relocs[0].extern
	assert gen.macho.relocs[0].length == 2
	assert gen.macho.symbols[gen.macho.relocs[0].sym_idx].name == '___stderrp'
}

fn test_macho_codegen_got_load_mov_supports_high_registers() {
	mut mod := new_macho_global_codegen_test_module('__stderrp', .external)
	mut gen := Gen.new_with_format(&mod, .macho)
	gen.load_val_to_reg(int(r8), 0)

	assert gen.macho.text_data == [u8(0x4c), 0x8b, 0x05, 0, 0, 0, 0]
	assert gen.macho.relocs.len == 1
	assert gen.macho.relocs[0].type_ == x86_64_reloc_got_load
}

fn test_macho_codegen_keeps_private_global_references_signed() {
	mut mod := new_macho_global_codegen_test_module('app_global', .private)
	mut gen := Gen.new_with_format(&mod, .macho)
	gen.load_val_to_reg(0, 0)

	assert gen.macho.text_data == [u8(0x48), 0x8d, 0x05, 0, 0, 0, 0]
	assert gen.macho.relocs.len == 1
	assert gen.macho.relocs[0].addr == 3
	assert gen.macho.relocs[0].type_ == x86_64_reloc_signed
	assert gen.macho.relocs[0].type_ != x86_64_reloc_got_load
	assert gen.macho.relocs[0].pcrel
	assert gen.macho.relocs[0].extern
	assert gen.macho.relocs[0].length == 2
	assert gen.macho.symbols[gen.macho.relocs[0].sym_idx].name == '_app_global'
}

fn test_elf_codegen_loads_func_ref_as_rip_relative_address() {
	mut mod := new_func_ref_codegen_test_module('_anon_fn_0')
	mut gen := Gen.new_with_format(&mod, .elf)
	gen.load_val_to_reg(0, 0)

	assert gen.elf.text_data == [u8(0x48), 0x8d, 0x05, 0, 0, 0, 0]
	assert gen.elf.text_relocs.len == 1
	assert gen.elf.text_relocs[0].offset == 3
	assert gen.elf.text_relocs[0].info & u64(0xffff_ffff) == u64(r_x86_64_pc32)
	sym_idx := int(gen.elf.text_relocs[0].info >> 32)
	assert gen.elf.symbols[sym_idx].name == '_anon_fn_0'
	assert gen.elf.text_relocs[0].addend == i64(-4)
}

fn test_macho_codegen_loads_func_ref_as_rip_relative_address() {
	mut mod := new_func_ref_codegen_test_module('_anon_fn_0')
	mut gen := Gen.new_with_format(&mod, .macho)
	gen.load_val_to_reg(0, 0)

	assert gen.macho.text_data == [u8(0x48), 0x8d, 0x05, 0, 0, 0, 0]
	assert gen.macho.relocs.len == 1
	assert gen.macho.relocs[0].addr == 3
	assert gen.macho.relocs[0].type_ == x86_64_reloc_signed
	assert gen.macho.relocs[0].pcrel
	assert gen.macho.relocs[0].extern
	assert gen.macho.relocs[0].length == 2
	assert gen.macho.symbols[gen.macho.relocs[0].sym_idx].name == '__anon_fn_0'
}

fn test_coff_codegen_loads_func_ref_as_rip_relative_address() {
	mut mod := new_func_ref_codegen_test_module('_anon_fn_0')
	mut gen := Gen.new_with_format(&mod, .coff)
	gen.load_val_to_reg(0, 0)

	assert gen.coff.text_data == [u8(0x48), 0x8d, 0x05, 0, 0, 0, 0]
	assert gen.coff.text_relocs.len == 1
	assert gen.coff.text_relocs[0].offset == 3
	assert gen.coff.text_relocs[0].type_ == coff_image_rel_amd64_rel32
	assert gen.coff.symbols[gen.coff.text_relocs[0].sym_idx].name == '_anon_fn_0'
}

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

	assert gen.coff.data_data == [u8(1), 2, 3, 4, 5, 6, 7, 8]
	keep_sym := coff_test_symbol(gen.coff, 'keep_global') or {
		panic('missing referenced global symbol')
	}
	assert keep_sym.section == 3
	assert keep_sym.value == 0
	assert coff_test_symbol(gen.coff, 'drop_global') == none
	assert gen.coff.text_relocs.len == 1
	reloc := gen.coff.text_relocs[0]
	assert gen.coff.symbols[reloc.sym_idx].name == 'keep_global'
	assert gen.coff.symbols[reloc.sym_idx].section == 3
}

fn test_windows_coff_codegen_keeps_globals_when_reference_scan_is_ambiguous() {
	mut mod := new_windows_coff_global_codegen_test_module()
	ghost_id := mod.values.len
	mod.values << mir.Value{
		id:    ghost_id
		typ:   mod.values[0].typ
		index: 99
		kind:  .global
		name:  'ghost_global'
	}
	mod.instrs[0].operands = [ghost_id]
	mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
	gen.gen()

	assert gen.coff.data_data == [
		u8(1),
		2,
		3,
		4,
		5,
		6,
		7,
		8,
		9,
		10,
		11,
		12,
		13,
		14,
		15,
		16,
	]
	assert coff_test_symbol(gen.coff, 'keep_global') != none
	assert coff_test_symbol(gen.coff, 'drop_global') != none
}

fn test_non_windows_coff_codegen_preserves_existing_global_emission() {
	mut mod := new_windows_coff_global_codegen_test_module()
	mut gen := Gen.new_with_format(&mod, .coff)
	gen.gen()

	assert gen.coff.data_data == [
		u8(1),
		2,
		3,
		4,
		5,
		6,
		7,
		8,
		9,
		10,
		11,
		12,
		13,
		14,
		15,
		16,
	]
	assert coff_test_symbol(gen.coff, 'keep_global') != none
	assert coff_test_symbol(gen.coff, 'drop_global') != none
}

fn test_macho_codegen_keeps_local_rodata_references_signed() {
	mut ts := ssa.TypeStore.new()
	i64_t := ts.get_int(64)
	mut mod := mir.Module{
		type_store: unsafe { *ts }
		values:     [
			mir.Value{
				id:    0
				typ:   i64_t
				index: 0
				kind:  .constant
				name:  '"hello"'
			},
		]
	}
	mut gen := Gen.new_with_format(&mod, .macho)
	gen.load_val_to_reg(0, 0)

	assert gen.macho.text_data == [u8(0x48), 0x8d, 0x05, 0, 0, 0, 0]
	assert gen.macho.relocs.len == 1
	assert gen.macho.relocs[0].addr == 3
	assert gen.macho.relocs[0].type_ == x86_64_reloc_signed
	assert gen.macho.symbols[gen.macho.relocs[0].sym_idx].name.starts_with('L_str_')
}

fn test_macho_codegen_keeps_external_calls_as_branch_relocations() {
	mut ts := ssa.TypeStore.new()
	mut mod := mir.Module{
		type_store: unsafe { *ts }
	}
	mut gen := Gen.new_with_format(&mod, .macho)
	asm_call_rel32(mut gen)
	sym_idx := gen.add_undefined('calloc')
	gen.add_call_reloc(sym_idx)
	gen.emit_u32(0)

	assert gen.macho.text_data == [u8(0xe8), 0, 0, 0, 0]
	assert gen.macho.relocs.len == 1
	assert gen.macho.relocs[0].addr == 1
	assert gen.macho.relocs[0].type_ == x86_64_reloc_branch
	assert gen.macho.relocs[0].type_ != x86_64_reloc_got_load
	assert gen.macho.symbols[gen.macho.relocs[0].sym_idx].name == '_calloc'
}

fn test_macho_object_format_prefixes_external_symbols() {
	assert ObjectFormat.macho.symbol_name('main') == '_main'
	assert ObjectFormat.macho.symbol_name('calloc') == '_calloc'
	assert ObjectFormat.macho.symbol_name('_main') == '__main'
	assert ObjectFormat.macho.symbol_name('__stdoutp') == '___stdoutp'
	assert ObjectFormat.macho.symbol_name('__stderrp') == '___stderrp'
	assert ObjectFormat.macho.symbol_name('__stdinp') == '___stdinp'
	assert ObjectFormat.macho.symbol_name('__error') == '___error'
	assert ObjectFormat.macho.symbol_name('L_str_0') == 'L_str_0'
	assert ObjectFormat.elf.symbol_name('main') == 'main'
	assert ObjectFormat.elf.symbol_name('calloc') == 'calloc'
	assert ObjectFormat.elf.symbol_name('__stdoutp') == '__stdoutp'
	assert ObjectFormat.coff.symbol_name('main') == 'main'
	assert ObjectFormat.coff.symbol_name('calloc') == 'calloc'
	assert ObjectFormat.coff.symbol_name('__stdoutp') == '__stdoutp'
}

fn test_elf_writer_reuses_undefined_symbol_when_it_is_defined_later() {
	mut obj := ElfObject.new()
	undef_idx := obj.add_undefined('app_global')
	def_idx := obj.add_symbol('app_global', 16, false, 2)

	assert def_idx == undef_idx
	assert obj.symbols[def_idx].name == 'app_global'
	assert obj.symbols[def_idx].shndx == 2
	assert obj.symbols[def_idx].value == 16
}

fn test_elf_writer_reuses_defined_symbol_when_it_is_referenced_later() {
	mut obj := ElfObject.new()
	def_idx := obj.add_symbol('app_global', 16, false, 2)
	undef_idx := obj.add_undefined('app_global')

	assert undef_idx == def_idx
	assert obj.symbols[undef_idx].name == 'app_global'
	assert obj.symbols[undef_idx].shndx == 2
	assert obj.symbols[undef_idx].value == 16
}

fn test_macho_writer_reuses_undefined_symbol_when_it_is_defined_later() {
	mut obj := MachOObject.new()
	undef_idx := obj.add_undefined('_app_global')
	def_idx := obj.add_symbol('_app_global', 24, true, 3)

	assert def_idx == undef_idx
	assert obj.symbols[def_idx].name == '_app_global'
	assert obj.symbols[def_idx].sect == 3
	assert obj.symbols[def_idx].value == 24
}

fn test_macho_writer_serializes_text_relocations_and_symbols() {
	path := temp_object_path('macho_relocs')
	defer {
		os.rm(path) or {}
	}

	mut obj := MachOObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0x48, 0x8d, 0x05, 0, 0, 0, 0]
	call_name := ObjectFormat.macho.symbol_name('__stdoutp')
	local_name := ObjectFormat.macho.symbol_name('L_str_0')
	call_sym := obj.add_undefined(call_name)
	data_sym := obj.add_symbol(local_name, 0, false, 2)
	obj.rodata << 'hello'.bytes()
	obj.rodata << 0
	obj.add_reloc(1, call_sym, x86_64_reloc_branch, true, 2)
	obj.add_reloc(8, data_sym, x86_64_reloc_signed, true, 2)
	obj.write(path)

	data := os.read_bytes(path) or { panic(err) }
	seg_cmd_off := 32
	text_section_off := seg_cmd_off + 72
	load_cmds_size := read_u32_le(data, 20)
	assert_range_in_file(data, make_byte_range('Mach-O header and load commands', 0, 32 +
		u64(load_cmds_size)))
	reloc_off := int(read_u32_le(data, text_section_off + 56))
	nreloc := int(read_u32_le(data, text_section_off + 60))
	assert nreloc == 2
	assert_range_in_file(data, make_byte_range('Mach-O text relocations', u64(reloc_off),
		u64(nreloc * 8)))

	reloc0_addr := read_u32_le(data, reloc_off)
	reloc0_info := read_u32_le(data, reloc_off + 4)
	reloc1_addr := read_u32_le(data, reloc_off + 8)
	reloc1_info := read_u32_le(data, reloc_off + 12)
	assert reloc0_addr == 1
	assert reloc0_info & 0x00ff_ffff == u32(call_sym)
	assert ((reloc0_info >> 24) & 1) == 1
	assert ((reloc0_info >> 25) & 3) == 2
	assert ((reloc0_info >> 27) & 1) == 1
	assert (reloc0_info >> 28) == u32(x86_64_reloc_branch)
	assert reloc1_addr == 8
	assert reloc1_info & 0x00ff_ffff == u32(data_sym)
	assert ((reloc1_info >> 24) & 1) == 1
	assert ((reloc1_info >> 25) & 3) == 2
	assert ((reloc1_info >> 27) & 1) == 1
	assert (reloc1_info >> 28) == u32(x86_64_reloc_signed)

	symtab_cmd_off := seg_cmd_off + 72 + (80 * 3)
	assert read_u32_le(data, symtab_cmd_off) == u32(macho_lc_symtab)
	sym_off := int(read_u32_le(data, symtab_cmd_off + 8))
	nsyms := int(read_u32_le(data, symtab_cmd_off + 12))
	str_off := int(read_u32_le(data, symtab_cmd_off + 16))
	str_size := int(read_u32_le(data, symtab_cmd_off + 20))
	assert nsyms == 2
	assert str_size > 1
	mut macho_reloc_ranges := [
		make_byte_range('Mach-O header and load commands', 0, 32 + u64(load_cmds_size)),
		make_byte_range('Mach-O text section', u64(read_u32_le(data, text_section_off + 48)), read_u64_le(data,

			text_section_off + 40)),
		make_byte_range('Mach-O text relocations', u64(reloc_off), u64(nreloc * 8)),
		make_byte_range('Mach-O symbol table', u64(sym_off), u64(nsyms * 16)),
		make_byte_range('Mach-O string table', u64(str_off), u64(str_size)),
	]
	for range in macho_reloc_ranges {
		assert_range_in_file(data, range)
	}
	assert_ranges_do_not_overlap(macho_reloc_ranges)

	call_name_off := int(read_u32_le(data, sym_off))
	local_name_off := int(read_u32_le(data, sym_off + 16))
	assert read_string(data, str_off + call_name_off) == call_name
	assert read_string(data, str_off + local_name_off) == local_name
	assert data[sym_off + 4] == 0x01
	assert data[sym_off + 5] == 0
	assert data[sym_off + 16 + 4] == 0x0e
	assert data[sym_off + 16 + 5] == 2
}

fn test_macho_tiny_object_writer_prunes_unreachable_text_and_data() {
	path := temp_object_path('macho_tiny_pruned')
	defer {
		os.rm(path) or {}
	}

	mut obj := MachOObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0x48, 0x8d, 0x05, 0, 0, 0, 0, 0xc3]
	main_sym := obj.add_symbol('_main', 0, true, 1)
	helper_start := obj.text_data.len
	obj.text_data << u8(0xc3)
	helper_sym := obj.add_symbol('_helper', u64(helper_start), true, 1)
	unused_start := obj.text_data.len
	obj.text_data << u8(0xc3)
	obj.add_symbol('_unused', u64(unused_start), true, 1)
	keep_sym := obj.add_symbol('L_keep', 0, false, 2)
	obj.rodata << 'ok'.bytes()
	obj.rodata << 0
	drop_start := obj.rodata.len
	obj.add_symbol('L_drop', u64(drop_start), false, 2)
	obj.rodata << 'drop'.bytes()
	obj.rodata << 0
	obj.add_reloc(1, helper_sym, x86_64_reloc_branch, true, 2)
	obj.add_reloc(8, keep_sym, x86_64_reloc_signed, true, 2)

	mut writer := MachOTinyObjectWriter{
		macho: obj
	}
	writer.write(path) or { panic(err) }

	data := os.read_bytes(path) or { panic(err) }
	load_cmds := macho_test_load_commands(data)
	sections := macho_test_sections(data, load_cmds[0])
	assert sections[0].size == u64(helper_start + 1)
	assert sections[1].size == u64(3)
	assert data[int(sections[0].offset)..int(sections[0].offset + sections[0].size)] == obj.text_data[..
		helper_start + 1]
	assert data[int(sections[1].offset)..int(sections[1].offset + sections[1].size)] == 'ok\0'.bytes()
	assert sections[0].nreloc == 2

	symbols := macho_test_symbols(data)
	names := symbols.map(it.name)
	assert '_main' in names
	assert '_helper' in names
	assert 'L_keep' in names
	assert '_unused' !in names
	assert 'L_drop' !in names
	main_out := macho_test_symbol_by_name(symbols, '_main') or {
		assert false, 'missing _main in Mach-O tiny output'
		return
	}
	helper_out := macho_test_symbol_by_name(symbols, '_helper') or {
		assert false, 'missing _helper in Mach-O tiny output'
		return
	}
	keep_out := macho_test_symbol_by_name(symbols, 'L_keep') or {
		assert false, 'missing L_keep in Mach-O tiny output'
		return
	}
	assert main_out.type_ == 0x0f
	assert main_out.sect == 1
	assert helper_out.type_ == 0x0e
	assert helper_out.sect == 1
	assert keep_out.type_ == 0x0e
	assert keep_out.sect == 2
	assert main_sym == 0
}

fn test_macho_tiny_object_writer_preserves_undefined_externals_and_remaps_relocations() {
	path := temp_object_path('macho_tiny_undefined_remap')
	defer {
		os.rm(path) or {}
	}

	mut obj := MachOObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0x48, 0x8b, 0x05, 0, 0, 0, 0, 0x48, 0x8d, 0x05, 0,
		0, 0, 0, 0xc3]
	unused_start := obj.text_data.len
	obj.text_data << u8(0xc3)
	obj.add_symbol('_unused', u64(unused_start), true, 1)
	obj.add_undefined('_unused_external')
	call_sym := obj.add_undefined('_calloc')
	obj.add_symbol('_main', 0, true, 1)
	got_load_sym := obj.add_undefined('___stderrp')
	got_sym := obj.add_undefined('___error')
	obj.add_reloc(1, call_sym, x86_64_reloc_branch, true, 2)
	obj.add_reloc(8, got_load_sym, x86_64_reloc_got_load, true, 2)
	obj.add_reloc(15, got_sym, x86_64_reloc_got, true, 2)

	mut writer := MachOTinyObjectWriter{
		macho: obj
	}
	writer.write(path) or { panic(err) }

	data := os.read_bytes(path) or { panic(err) }
	symbols := macho_test_symbols(data)
	names := symbols.map(it.name)
	assert '_main' in names
	assert '_calloc' in names
	assert '___stderrp' in names
	assert '___error' in names
	assert '_unused' !in names
	assert '_unused_external' !in names
	for name in ['_calloc', '___stderrp', '___error'] {
		symbol := macho_test_symbol_by_name(symbols, name) or {
			assert false, 'missing ${name} in Mach-O tiny output'
			return
		}
		assert symbol.type_ == 0x01
		assert symbol.sect == 0
		assert symbol.value == 0
	}

	relocs := macho_test_text_relocations(data)
	assert relocs.len == 3
	assert relocs[0].addr == 1
	assert relocs[0].type_ == x86_64_reloc_branch
	assert symbols[relocs[0].sym_idx].name == '_calloc'
	assert relocs[0].sym_idx != call_sym
	assert relocs[1].addr == 8
	assert relocs[1].type_ == x86_64_reloc_got_load
	assert symbols[relocs[1].sym_idx].name == '___stderrp'
	assert relocs[1].sym_idx != got_load_sym
	assert relocs[2].addr == 15
	assert relocs[2].type_ == x86_64_reloc_got
	assert symbols[relocs[2].sym_idx].name == '___error'
	assert relocs[2].sym_idx != got_sym
	for reloc in relocs {
		assert reloc.pcrel
		assert reloc.length == 2
		assert reloc.extern
	}
}

fn test_macho_tiny_object_writer_resolves_builtin_string_plus_with_libsystem_runtime() {
	path := temp_object_path('macho_tiny_string_plus_runtime')
	defer {
		os.rm(path) or {}
	}

	mut obj := MachOObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	string_plus_sym := obj.add_undefined('_builtin__string__+')
	obj.add_symbol('_main', 0, true, 1)
	obj.add_reloc(1, string_plus_sym, x86_64_reloc_branch, true, 2)

	mut writer := MachOTinyObjectWriter{
		macho: obj
	}
	writer.write(path) or { panic(err) }

	data := os.read_bytes(path) or { panic(err) }
	symbols := macho_test_symbols(data)
	names := symbols.map(it.name)
	assert '_main' in names
	assert '_builtin__string__+' in names
	assert '_malloc' in names
	assert '_exit' in names

	string_plus_out := macho_test_symbol_by_name(symbols, '_builtin__string__+') or {
		assert false, 'missing _builtin__string__+ in Mach-O tiny output'
		return
	}
	assert string_plus_out.type_ == 0x0e
	assert string_plus_out.sect == 1
	assert string_plus_out.value > 0
	for name in ['_malloc', '_exit'] {
		symbol := macho_test_symbol_by_name(symbols, name) or {
			assert false, 'missing ${name} in Mach-O tiny output'
			return
		}
		assert symbol.type_ == 0x01
		assert symbol.sect == 0
		assert symbol.value == 0
	}

	relocs := macho_test_text_relocations(data)
	assert relocs.len == 2
	assert relocs[0].addr > int(string_plus_out.value)
	assert symbols[relocs[0].sym_idx].name == '_malloc'
	assert relocs[1].addr > int(string_plus_out.value)
	assert relocs[1].addr > relocs[0].addr
	assert symbols[relocs[1].sym_idx].name == '_exit'
	mut reloc_names := []string{}
	for reloc in relocs {
		reloc_names << symbols[reloc.sym_idx].name
		assert reloc.pcrel
		assert reloc.length == 2
		assert reloc.extern
		assert reloc.type_ == x86_64_reloc_branch
	}
	reloc_names.sort()
	assert reloc_names == ['_exit', '_malloc']

	text := macho_test_text_bytes(data)
	expected_disp := i64(string_plus_out.value) - i64(1 + 4)
	assert read_u32_le(text, 1) == u32(i32(expected_disp))
}

fn test_macho_tiny_object_writer_resolves_builtin_i64_str_with_libsystem_runtime() {
	path := temp_object_path('macho_tiny_i64_str_runtime')
	defer {
		os.rm(path) or {}
	}

	mut obj := MachOObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	i64_str_sym := obj.add_undefined('_builtin__i64__str')
	obj.add_symbol('_main', 0, true, 1)
	obj.add_reloc(1, i64_str_sym, x86_64_reloc_branch, true, 2)

	mut writer := MachOTinyObjectWriter{
		macho: obj
	}
	writer.write(path) or { panic(err) }

	data := os.read_bytes(path) or { panic(err) }
	symbols := macho_test_symbols(data)
	i64_str_out := macho_test_symbol_by_name(symbols, '_builtin__i64__str') or {
		assert false, 'missing _builtin__i64__str in Mach-O tiny output'
		return
	}
	assert i64_str_out.type_ == 0x0e
	assert i64_str_out.sect == 1
	assert i64_str_out.value > 0

	relocs := macho_test_text_relocations(data)
	assert relocs.len == 2
	mut reloc_names := []string{}
	for reloc in relocs {
		reloc_names << symbols[reloc.sym_idx].name
		assert reloc.pcrel
		assert reloc.length == 2
		assert reloc.extern
		assert reloc.type_ == x86_64_reloc_branch
		assert reloc.addr > int(i64_str_out.value)
	}
	reloc_names.sort()
	assert reloc_names == ['_exit', '_malloc']

	text := macho_test_text_bytes(data)
	expected_disp := i64(i64_str_out.value) - i64(1 + 4)
	assert read_u32_le(text, 1) == u32(i32(expected_disp))
}

fn test_macho_tiny_i64_str_helper_uses_signed_64_bit_decimal_runtime() {
	path := temp_object_path('macho_tiny_i64_str_runtime_bytes')
	defer {
		os.rm(path) or {}
	}

	mut obj := MachOObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	i64_str_sym := obj.add_undefined('_builtin__i64__str')
	obj.add_symbol('_main', 0, true, 1)
	obj.add_reloc(1, i64_str_sym, x86_64_reloc_branch, true, 2)

	mut writer := MachOTinyObjectWriter{
		macho: obj
	}
	writer.write(path) or { panic(err) }

	data := os.read_bytes(path) or { panic(err) }
	symbols := macho_test_symbols(data)
	i64_str_out := macho_test_symbol_by_name(symbols, '_builtin__i64__str') or {
		assert false, 'missing _builtin__i64__str in Mach-O tiny output'
		return
	}
	text := macho_test_text_bytes(data)
	helper := text[int(i64_str_out.value)..]

	assert helper[0..7] == [u8(0x57), 0xbf, 0x20, 0, 0, 0, 0xe8]
	assert helper[32] == 0x5f
	assert_macho_test_bytes_contains(helper, [u8(0x48), 0x89, 0xf8],
		'i64 str helper must read the full i64 argument from rdi')
	assert_macho_test_bytes_contains(helper, [u8(0x41), 0xb2, 0x01],
		'i64 str helper must remember signed negative inputs')
	assert_macho_test_bytes_contains(helper, [u8(0x48), 0xf7, 0xd8],
		'i64 str helper must negate the full 64-bit value, preserving i64_min as unsigned magnitude')
	assert_macho_test_bytes_contains(helper, [u8(0x48), 0xf7, 0xf1],
		'i64 str helper must divide the full 64-bit magnitude by 10')
	assert_macho_test_bytes_contains(helper, [u8(0x41), 0xc6, 0x00, 0x2d],
		'i64 str helper must emit a minus sign for signed negative inputs')
	assert_macho_test_bytes_contains(helper, [u8(0x4c), 0x89, 0xc0, 0x4c, 0x89, 0xca, 0xc3],
		'i64 str helper must return ptr in rax and len in rdx')

	relocs := macho_test_text_relocations(data)
	mut malloc_relocs := 0
	mut exit_relocs := 0
	for reloc in relocs {
		name := symbols[reloc.sym_idx].name
		if name == '_malloc' {
			malloc_relocs++
			assert reloc.addr == u32(i64_str_out.value + 7)
		} else if name == '_exit' {
			exit_relocs++
			assert reloc.addr == u32(i64_str_out.value + 26)
		} else {
			assert false, 'unexpected Mach-O tiny i64 str helper relocation to ${name}'
		}
		assert reloc.extern
		assert reloc.pcrel
		assert reloc.length == 2
		assert reloc.type_ == x86_64_reloc_branch
	}
	assert malloc_relocs == 1
	assert exit_relocs == 1
}

fn test_macho_tiny_object_writer_resolves_i64_str_and_string_plus_locally() {
	path := temp_object_path('macho_tiny_i64_str_string_plus_runtime')
	defer {
		os.rm(path) or {}
	}

	mut obj := MachOObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xe8, 0, 0, 0, 0, 0xc3]
	i64_str_sym := obj.add_undefined('_builtin__i64__str')
	string_plus_sym := obj.add_undefined('_builtin__string__+')
	obj.add_symbol('_main', 0, true, 1)
	obj.add_reloc(1, i64_str_sym, x86_64_reloc_branch, true, 2)
	obj.add_reloc(6, string_plus_sym, x86_64_reloc_branch, true, 2)

	mut writer := MachOTinyObjectWriter{
		macho: obj
	}
	writer.write(path) or { panic(err) }

	data := os.read_bytes(path) or { panic(err) }
	symbols := macho_test_symbols(data)
	i64_str_out := macho_test_symbol_by_name(symbols, '_builtin__i64__str') or {
		assert false, 'missing _builtin__i64__str in Mach-O tiny output'
		return
	}
	string_plus_out := macho_test_symbol_by_name(symbols, '_builtin__string__+') or {
		assert false, 'missing _builtin__string__+ in Mach-O tiny output'
		return
	}
	assert i64_str_out.type_ == 0x0e
	assert i64_str_out.sect == 1
	assert i64_str_out.value > 0
	assert string_plus_out.type_ == 0x0e
	assert string_plus_out.sect == 1
	assert string_plus_out.value > i64_str_out.value

	relocs := macho_test_text_relocations(data)
	assert relocs.len == 4
	mut reloc_names := []string{}
	for reloc in relocs {
		reloc_names << symbols[reloc.sym_idx].name
		assert reloc.pcrel
		assert reloc.length == 2
		assert reloc.extern
		assert reloc.type_ == x86_64_reloc_branch
	}
	reloc_names.sort()
	assert reloc_names == ['_exit', '_exit', '_malloc', '_malloc']

	text := macho_test_text_bytes(data)
	expected_i64_disp := i64(i64_str_out.value) - i64(1 + 4)
	expected_string_plus_disp := i64(string_plus_out.value) - i64(6 + 4)
	assert read_u32_le(text, 1) == u32(i32(expected_i64_disp))
	assert read_u32_le(text, 6) == u32(i32(expected_string_plus_disp))
}

fn test_macho_tiny_object_writer_keeps_referenced_rodata_and_data() {
	path := temp_object_path('macho_tiny_rodata_data')
	defer {
		os.rm(path) or {}
	}

	mut obj := MachOObject.new()
	obj.text_data << [u8(0x48), 0x8d, 0x05, 0, 0, 0, 0, 0x48, 0x8d, 0x05, 0, 0, 0, 0, 0xc3]
	obj.add_symbol('_main', 0, true, 1)
	ro_keep_sym := obj.add_symbol('L_ro_keep', 0, false, 2)
	obj.rodata << 'ro'.bytes()
	obj.rodata << 0
	ro_drop_start := obj.rodata.len
	obj.add_symbol('L_ro_drop', u64(ro_drop_start), false, 2)
	obj.rodata << 'drop'.bytes()
	obj.rodata << 0
	data_keep_sym := obj.add_symbol('_data_keep', 0, true, 3)
	obj.data_data << [u8(1), 2, 3, 4, 5, 6, 7, 8]
	data_drop_start := obj.data_data.len
	obj.add_symbol('_data_drop', u64(data_drop_start), true, 3)
	obj.data_data << [u8(9), 10, 11, 12]
	obj.add_reloc(3, ro_keep_sym, x86_64_reloc_signed, true, 2)
	obj.add_reloc(10, data_keep_sym, x86_64_reloc_signed, true, 2)

	mut writer := MachOTinyObjectWriter{
		macho: obj
	}
	writer.write(path) or { panic(err) }

	data := os.read_bytes(path) or { panic(err) }
	load_cmds := macho_test_load_commands(data)
	sections := macho_test_sections(data, load_cmds[0])
	assert sections[1].size == u64(3)
	assert sections[2].size == u64(8)
	assert data[int(sections[1].offset)..int(sections[1].offset + sections[1].size)] == 'ro\0'.bytes()
	assert data[int(sections[2].offset)..int(sections[2].offset + sections[2].size)] == [
		u8(1),
		2,
		3,
		4,
		5,
		6,
		7,
		8,
	]

	names := macho_test_symbol_names(data)
	assert 'L_ro_keep' in names
	assert '_data_keep' in names
	assert 'L_ro_drop' !in names
	assert '_data_drop' !in names
	relocs := macho_test_text_relocations(data)
	symbols := macho_test_symbols(data)
	ro_keep_out := macho_test_symbol_by_name(symbols, 'L_ro_keep') or {
		assert false, 'missing L_ro_keep in Mach-O tiny output'
		return
	}
	data_keep_out := macho_test_symbol_by_name(symbols, '_data_keep') or {
		assert false, 'missing _data_keep in Mach-O tiny output'
		return
	}
	assert ro_keep_out.type_ == 0x0e
	assert ro_keep_out.sect == 2
	assert data_keep_out.type_ == 0x0e
	assert data_keep_out.sect == 3
	assert relocs.len == 2
	assert symbols[relocs[0].sym_idx].name == 'L_ro_keep'
	assert symbols[relocs[1].sym_idx].name == '_data_keep'
}

fn test_macho_tiny_object_writer_remaps_multiple_aligned_data_ranges() {
	path := temp_object_path('macho_tiny_aligned_data_ranges')
	defer {
		os.rm(path) or {}
	}

	ro_a := [u8(0x01), 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]
	ro_b := [u8(0x11), 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18]
	data_a := [u8(0x21), 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28]
	data_b := [u8(0x31), 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38]

	mut obj := MachOObject.new()
	obj.text_data << [u8(0x48), 0x8d, 0x05, 0, 0, 0, 0, 0x48, 0x8d, 0x05, 0, 0, 0, 0, 0x48, 0x8d,
		0x05, 0, 0, 0, 0, 0x48, 0x8d, 0x05, 0, 0, 0, 0, 0xc3]
	obj.add_symbol('_main', 0, true, 1)
	ro_a_sym := obj.add_symbol('L_ro64_a', 0, false, 2)
	obj.rodata << ro_a
	ro_b_sym := obj.add_symbol('L_ro64_b', u64(obj.rodata.len), false, 2)
	obj.rodata << ro_b
	obj.add_symbol('L_ro64_unused', u64(obj.rodata.len), false, 2)
	obj.rodata << [u8(0xf1), 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8]
	data_a_sym := obj.add_symbol('_data64_a', 0, true, 3)
	obj.data_data << data_a
	data_b_sym := obj.add_symbol('_data64_b', u64(obj.data_data.len), true, 3)
	obj.data_data << data_b
	obj.add_symbol('_data64_unused', u64(obj.data_data.len), true, 3)
	obj.data_data << [u8(0xe1), 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8]
	obj.add_reloc(3, ro_b_sym, x86_64_reloc_signed, true, 2)
	obj.add_reloc(10, ro_a_sym, x86_64_reloc_signed, true, 2)
	obj.add_reloc(17, data_b_sym, x86_64_reloc_signed, true, 2)
	obj.add_reloc(24, data_a_sym, x86_64_reloc_signed, true, 2)

	mut writer := MachOTinyObjectWriter{
		macho: obj
	}
	writer.write(path) or { panic(err) }

	data := os.read_bytes(path) or { panic(err) }
	load_cmds := macho_test_load_commands(data)
	sections := macho_test_sections(data, load_cmds[0])
	rodata_payload := data[int(sections[1].offset)..int(sections[1].offset + sections[1].size)]
	data_payload := data[int(sections[2].offset)..int(sections[2].offset + sections[2].size)]
	mut expected_rodata := []u8{}
	expected_rodata << ro_b
	expected_rodata << ro_a
	mut expected_data := []u8{}
	expected_data << data_b
	expected_data << data_a
	assert rodata_payload == expected_rodata
	assert data_payload == expected_data

	symbols := macho_test_symbols(data)
	ro_b_out := macho_test_symbol_by_name(symbols, 'L_ro64_b') or {
		assert false, 'missing L_ro64_b'
		return
	}
	ro_a_out := macho_test_symbol_by_name(symbols, 'L_ro64_a') or {
		assert false, 'missing L_ro64_a'
		return
	}
	data_b_out := macho_test_symbol_by_name(symbols, '_data64_b') or {
		assert false, 'missing _data64_b'
		return
	}
	data_a_out := macho_test_symbol_by_name(symbols, '_data64_a') or {
		assert false, 'missing _data64_a'
		return
	}
	assert ro_b_out.value == sections[1].addr
	assert ro_a_out.value == sections[1].addr + 8
	assert data_b_out.value == sections[2].addr
	assert data_a_out.value == sections[2].addr + 8

	names := symbols.map(it.name)
	assert 'L_ro64_unused' !in names
	assert '_data64_unused' !in names
	relocs := macho_test_text_relocations(data)
	assert relocs.len == 4
	assert symbols[relocs[0].sym_idx].name == 'L_ro64_b'
	assert symbols[relocs[1].sym_idx].name == 'L_ro64_a'
	assert symbols[relocs[2].sym_idx].name == '_data64_b'
	assert symbols[relocs[3].sym_idx].name == '_data64_a'
}

fn test_macho_tiny_object_writer_rejects_unknown_relocation_type() {
	path := temp_object_path('macho_tiny_bad_reloc')
	defer {
		os.rm(path) or {}
	}

	mut obj := MachOObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	call_sym := obj.add_undefined('_calloc')
	obj.add_symbol('_main', 0, true, 1)
	obj.add_reloc(1, call_sym, 99, true, 2)
	mut writer := MachOTinyObjectWriter{
		macho: obj
	}
	writer.write(path) or {
		assert err.msg().starts_with(macos_tiny_not_eligible_prefix)
		return
	}
	assert false, 'Mach-O tiny writer accepted an unsupported relocation type'
}

fn test_macho_tiny_object_writer_rejects_non_pcrel_relocation() {
	path := temp_object_path('macho_tiny_non_pcrel_reloc')
	defer {
		os.rm(path) or {}
	}

	mut obj := MachOObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	call_sym := obj.add_undefined('_calloc')
	obj.add_symbol('_main', 0, true, 1)
	obj.add_reloc(1, call_sym, x86_64_reloc_branch, false, 2)
	mut writer := MachOTinyObjectWriter{
		macho: obj
	}
	writer.write(path) or {
		assert err.msg().starts_with(macos_tiny_not_eligible_prefix)
		assert err.msg().contains('non-pcrel')
		return
	}
	assert false, 'Mach-O tiny writer accepted a non-pcrel relocation'
}

fn test_macho_tiny_object_writer_rejects_non_32_bit_relocation() {
	path := temp_object_path('macho_tiny_non_32_bit_reloc')
	defer {
		os.rm(path) or {}
	}

	mut obj := MachOObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	call_sym := obj.add_undefined('_calloc')
	obj.add_symbol('_main', 0, true, 1)
	obj.add_reloc(1, call_sym, x86_64_reloc_branch, true, 3)
	mut writer := MachOTinyObjectWriter{
		macho: obj
	}
	writer.write(path) or {
		assert err.msg().starts_with(macos_tiny_not_eligible_prefix)
		assert err.msg().contains('non-32-bit')
		return
	}
	assert false, 'Mach-O tiny writer accepted a non-32-bit relocation'
}

fn test_macho_tiny_object_writer_rejects_missing_main_symbol() {
	path := temp_object_path('macho_tiny_missing_main')
	defer {
		os.rm(path) or {}
	}

	mut obj := MachOObject.new()
	obj.text_data << u8(0xc3)
	obj.add_symbol('_not_main', 0, true, 1)
	mut writer := MachOTinyObjectWriter{
		macho: obj
	}
	writer.write(path) or {
		assert err.msg().starts_with(macos_tiny_not_eligible_prefix)
		assert err.msg().contains('missing _main symbol')
		return
	}
	assert false, 'Mach-O tiny writer accepted an object without _main'
}

fn test_macho_tiny_object_writer_rejects_module_init_symbol() {
	path := temp_object_path('macho_tiny_module_init')
	defer {
		os.rm(path) or {}
	}

	mut obj := MachOObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	init_start := obj.text_data.len
	obj.text_data << u8(0xc3)
	init_sym := obj.add_symbol('_dep__init', u64(init_start), true, 1)
	obj.add_symbol('_main', 0, true, 1)
	obj.add_reloc(1, init_sym, x86_64_reloc_branch, true, 2)
	mut writer := MachOTinyObjectWriter{
		macho: obj
	}
	writer.write(path) or {
		assert err.msg().starts_with(macos_tiny_not_eligible_prefix)
		assert err.msg().contains('module init symbol')
		return
	}
	assert false, 'Mach-O tiny writer accepted a module init symbol'
}

fn test_macho_object_is_accepted_by_external_tools_when_available() {
	tool := find_first_available_external_tool(macho_external_tool_candidates()) or {
		println('skipping ${@FN}: llvm-readobj, llvm-objdump, and otool variants are not available')
		return
	}
	path := temp_object_path('macho_external_tools')
	defer {
		os.rm(path) or {}
	}

	// Tests-only external validation palier. The same worktree also contains
	// prior accepted production changes for Mach-O GOT_LOAD emission.
	// Apple/XNU mach-o/x86_64/reloc.h defines BRANCH for calls, SIGNED for
	// direct RIP-relative references, and GOT_LOAD for movq foo@GOTPCREL(%rip).
	mut obj := MachOObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0x48, 0x8d, 0x05, 0, 0, 0, 0, 0x48, 0x8b, 0x05, 0,
		0, 0, 0]
	call_sym := obj.add_undefined('_calloc')
	local_sym := obj.add_symbol('L_str_0', 0, false, 2)
	stderr_sym := obj.add_undefined('___stderrp')
	obj.rodata << 'hello'.bytes()
	obj.rodata << 0
	obj.data_data << [u8(1), 2, 3, 4]
	obj.add_reloc(1, call_sym, x86_64_reloc_branch, true, 2)
	obj.add_reloc(8, local_sym, x86_64_reloc_signed, true, 2)
	obj.add_reloc(15, stderr_sym, x86_64_reloc_got_load, true, 2)
	obj.write(path)

	quoted_tool := os.quoted_path(tool.path)
	quoted_path := os.quoted_path(path)
	output := match tool.kind {
		.llvm_readobj {
			res :=
				os.execute('${quoted_tool} --sections --symbols --relocations --expand-relocs ${quoted_path}')
			assert_command_ok(res, 'llvm-readobj Mach-O')
			res.output
		}
		.llvm_objdump {
			res := os.execute('${quoted_tool} -h -t -r ${quoted_path}')
			assert_command_ok(res, 'llvm-objdump Mach-O')
			res.output
		}
		.otool {
			res := os.execute('${quoted_tool} -lrv ${quoted_path}')
			assert_command_ok(res, 'otool Mach-O')
			res.output
		}
		.dumpbin {
			panic('dumpbin is not a Mach-O validator')
		}
	}

	assert output.contains('__text')
	assert output.contains('__const')
	assert output.contains('__data')
	assert output.contains('___stderrp')
	assert output.contains('_calloc')
	assert output.contains('L_str_0')
	if tool.kind == .llvm_readobj {
		assert output.contains('X86_64_RELOC_GOT_LOAD')
			|| output.contains('type=X86_64_RELOC_GOT_LOAD') || output.contains('GOT_LOAD')
		assert output.contains('X86_64_RELOC_BRANCH') || output.contains('BRANCH')
		assert output.contains('X86_64_RELOC_SIGNED') || output.contains('SIGNED')
		assert llvm_readobj_has_relocation_block(output, ['___stderrp', 'GOT_LOAD'])
		assert !llvm_readobj_has_relocation_block(output, ['___stderrp', 'SIGNED'])
		assert llvm_readobj_has_relocation_block(output, ['_calloc', 'BRANCH'])
		assert llvm_readobj_has_relocation_block(output, ['L_str_0', 'SIGNED'])
	} else if tool.kind == .llvm_objdump {
		assert output_has_line_with_all(output, ['GOT_LOAD', '___stderrp'])
		assert !output_has_line_with_all(output, ['SIGNED', '___stderrp'])
		assert output_has_line_with_all(output, ['BRANCH', '_calloc'])
		assert output_has_line_with_all(output, ['SIGNED', 'L_str_0'])
	} else if tool.kind == .otool {
		// Apple otool is kept as an external acceptance smoke. Its relocation
		// type labels are presentation details (for example, cctools prints
		// GOT_LD for X86_64_RELOC_GOT_LOAD), while the binary-level tests above
		// and the LLVM tool paths still validate the exact type/symbol pairing.
		assert output.contains('Relocation information')
	}
}

fn test_coff_writer_emits_x64_relocatable_object() {
	path := temp_object_path('coff')
	defer {
		os.rm(path) or {}
	}

	mut obj := CoffObject.new()
	obj.text_data << u8(0xc3)
	obj.rodata << 'hello'.bytes()
	obj.rodata << 0
	obj.data_data << [u8(1), 2, 3, 4]
	obj.add_symbol('main', 0, true, 1)
	obj.write(path)

	data := os.read_bytes(path) or { panic(err) }
	assert data.len > 20 + (3 * 40)
	assert read_u16_le(data, 0) == coff_image_file_machine_amd64
	assert read_u16_le(data, 2) == 3
	assert read_u32_le(data, 4) == 0
	assert read_u16_le(data, 16) == 0
	assert read_u16_le(data, 18) == 0
	sections := coff_test_sections(data)
	assert sections.len == 3
	mut coff_ranges := [
		make_byte_range('COFF file header and section table', 0, 20 + 3 * 40),
	]
	assert sections[0].name == '.text'
	assert sections[1].name == '.rdata'
	assert sections[2].name == '.data'
	assert read_u32_le(data, 8) == 156
	assert sections[0].virtual_size == 0
	assert sections[0].virtual_address == 0
	assert sections[0].raw_size == 1
	assert sections[0].raw_pointer == 140
	assert sections[0].raw_pointer % 4 == 0
	assert sections[0].reloc_pointer == 0
	assert sections[0].line_pointer == 0
	assert sections[0].nreloc == 0
	assert sections[0].nline == 0
	assert data[int(sections[0].raw_pointer)..int(sections[0].raw_pointer + sections[0].raw_size)] == obj.text_data
	assert sections[1].virtual_size == 0
	assert sections[1].virtual_address == 0
	assert sections[1].raw_size == 6
	assert sections[1].raw_pointer == 144
	assert sections[1].raw_pointer % 4 == 0
	assert sections[1].reloc_pointer == 0
	assert sections[1].line_pointer == 0
	assert sections[1].nreloc == 0
	assert sections[1].nline == 0
	assert data[int(sections[1].raw_pointer)..int(sections[1].raw_pointer + sections[1].raw_size)] == obj.rodata
	assert sections[2].virtual_size == 0
	assert sections[2].virtual_address == 0
	assert sections[2].raw_size == 4
	assert sections[2].raw_pointer == 152
	assert sections[2].raw_pointer % 4 == 0
	assert sections[2].reloc_pointer == 0
	assert sections[2].line_pointer == 0
	assert sections[2].nreloc == 0
	assert sections[2].nline == 0
	assert data[int(sections[2].raw_pointer)..int(sections[2].raw_pointer + sections[2].raw_size)] == obj.data_data
	coff_ranges << coff_test_section_ranges(sections)
	coff_ranges << make_byte_range('COFF symbol table', u64(read_u32_le(data, 8)),
		u64(read_u32_le(data, 12)) * 18)
	for range in coff_ranges {
		assert_range_in_file(data, range)
	}
	assert_ranges_do_not_overlap(coff_ranges)
	assert read_u32_le(data, 8) % 4 == 0
	assert sections[0].characteristics & coff_image_scn_cnt_code != 0
	assert sections[0].characteristics & coff_image_scn_mem_execute != 0
	assert sections[0].characteristics & coff_image_scn_mem_read != 0
	assert sections[0].characteristics & coff_image_scn_align_16bytes != 0
	assert sections[1].characteristics & coff_image_scn_cnt_initialized_data != 0
	assert sections[1].characteristics & coff_image_scn_mem_read != 0
	assert sections[1].characteristics & coff_image_scn_align_8bytes != 0
	assert sections[2].characteristics & coff_image_scn_cnt_initialized_data != 0
	assert sections[2].characteristics & coff_image_scn_mem_read != 0
	assert sections[2].characteristics & coff_image_scn_mem_write != 0
	assert sections[2].characteristics & coff_image_scn_align_8bytes != 0
}

fn test_coff_writer_serializes_symbols_and_string_table() {
	path := temp_object_path('coff_symbols')
	defer {
		os.rm(path) or {}
	}

	mut obj := CoffObject.new()
	undef_idx := obj.add_undefined('external_long_symbol_name')
	pure_undef_idx := obj.add_undefined('calloc')
	main_idx := obj.add_symbol('main', 0, true, 1)
	defined_idx := obj.add_symbol('global_long_symbol_name', 16, false, 3)
	local_idx := obj.add_symbol('L_local_data', 4, false, 2)
	late_def_idx := obj.add_symbol('external_long_symbol_name', 8, false, 2)
	obj.write(path)

	assert late_def_idx == undef_idx

	data := os.read_bytes(path) or { panic(err) }
	sym_off := int(read_u32_le(data, 8))
	nsyms := int(read_u32_le(data, 12))
	assert nsyms == 5

	string_table_off := sym_off + (nsyms * 18)
	string_table_size := int(read_u32_le(data, string_table_off))
	assert string_table_size > 4

	main_off := sym_off + (main_idx * 18)
	assert data[main_off..main_off + 8].bytestr().trim_right('\0') == 'main'
	assert read_u32_le(data, main_off + 8) == 0
	assert read_u16_le(data, main_off + 12) == 1
	assert read_u16_le(data, main_off + 14) == coff_image_sym_dtype_function
	assert data[main_off + 16] == coff_image_sym_class_external

	defined_off := sym_off + (defined_idx * 18)
	assert read_u32_le(data, defined_off) == 0
	defined_name_off := int(read_u32_le(data, defined_off + 4))
	assert read_string(data, string_table_off + defined_name_off) == 'global_long_symbol_name'
	assert read_u32_le(data, defined_off + 8) == 16
	assert read_u16_le(data, defined_off + 12) == 3

	late_def_off := sym_off + (late_def_idx * 18)
	late_def_name_off := int(read_u32_le(data, late_def_off + 4))
	assert read_string(data, string_table_off + late_def_name_off) == 'external_long_symbol_name'
	assert read_u32_le(data, late_def_off + 8) == 8
	assert read_u16_le(data, late_def_off + 12) == 2

	pure_undef_off := sym_off + (pure_undef_idx * 18)
	assert data[pure_undef_off..pure_undef_off + 8].bytestr().trim_right('\0') == 'calloc'
	assert read_u32_le(data, pure_undef_off + 8) == 0
	assert read_u16_le(data, pure_undef_off + 12) == 0
	assert data[pure_undef_off + 16] == coff_image_sym_class_external

	local_off := sym_off + (local_idx * 18)
	assert read_u32_le(data, local_off) == 0
	local_name_off := int(read_u32_le(data, local_off + 4))
	assert read_string(data, string_table_off + local_name_off) == 'L_local_data'
	assert read_u16_le(data, local_off + 12) == 2
	assert data[local_off + 16] == coff_image_sym_class_static
}

fn test_coff_writer_serializes_text_relocations() {
	path := temp_object_path('coff_relocs')
	defer {
		os.rm(path) or {}
	}

	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0x48, 0x8d, 0x05, 0, 0, 0, 0]
	call_sym := obj.add_undefined('calloc')
	data_sym := obj.add_symbol('L_str_0', 0, false, 2)
	obj.add_text_reloc(1, call_sym, coff_image_rel_amd64_rel32)
	obj.add_text_reloc(8, data_sym, coff_image_rel_amd64_rel32)
	obj.write(path)

	data := os.read_bytes(path) or { panic(err) }
	text_section_off := 20
	reloc_off := int(read_u32_le(data, text_section_off + 24))
	nreloc := int(read_u16_le(data, text_section_off + 32))
	assert nreloc == 2
	assert reloc_off == 152
	assert reloc_off % 4 == 0
	assert read_u32_le(data, 8) == 172
	assert read_u32_le(data, 8) % 4 == 0
	mut coff_reloc_ranges := [
		make_byte_range('COFF file header and section table', 0, 20 + 3 * 40),
		make_byte_range('COFF text section', u64(read_u32_le(data, text_section_off + 20)), u64(read_u32_le(data,

			text_section_off + 16))),
		make_byte_range('COFF text relocations', u64(reloc_off), u64(nreloc) * 10),
		make_byte_range('COFF symbol table', u64(read_u32_le(data, 8)),
			u64(read_u32_le(data, 12)) * 18),
	]
	for range in coff_reloc_ranges {
		assert_range_in_file(data, range)
	}
	assert_ranges_do_not_overlap(coff_reloc_ranges)

	assert read_u32_le(data, reloc_off) == 1
	assert read_u32_le(data, reloc_off + 4) == u32(call_sym)
	assert read_u16_le(data, reloc_off + 8) == coff_image_rel_amd64_rel32
	assert read_u32_le(data, reloc_off + 10) == 8
	assert read_u32_le(data, reloc_off + 14) == u32(data_sym)
	assert read_u16_le(data, reloc_off + 18) == coff_image_rel_amd64_rel32
}

fn test_coff_object_is_accepted_by_external_tools_when_available() {
	tool := find_first_available_external_tool(coff_external_tool_candidates()) or {
		println('skipping ${@FN}: llvm-readobj, llvm-objdump, and dumpbin variants are not available')
		return
	}
	path := temp_object_path('coff_external_tools')
	defer {
		os.rm(path) or {}
	}

	// Tests-only external validation palier. The same worktree also contains
	// prior accepted production changes for Mach-O GOT_LOAD emission.
	// Microsoft PE/COFF specifies IMAGE_FILE_MACHINE_AMD64, section tables,
	// COFF symbols, and IMAGE_REL_AMD64_REL32 for x64 rel32 relocations.
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0x48, 0x8d, 0x05, 0, 0, 0, 0]
	obj.rodata << 'hello'.bytes()
	obj.rodata << 0
	obj.data_data << [u8(1), 2, 3, 4]
	call_sym := obj.add_undefined('calloc')
	obj.add_symbol('main', 0, true, 1)
	obj.add_symbol('app_global', 0, false, 3)
	local_sym := obj.add_symbol('L_str_0', 0, false, 2)
	obj.add_text_reloc(1, call_sym, coff_image_rel_amd64_rel32)
	obj.add_text_reloc(8, local_sym, coff_image_rel_amd64_rel32)
	obj.write(path)

	quoted_tool := os.quoted_path(tool.path)
	quoted_path := os.quoted_path(path)
	output := match tool.kind {
		.llvm_readobj {
			res :=
				os.execute('${quoted_tool} --file-headers --sections --symbols --relocations --expand-relocs ${quoted_path}')
			assert_command_ok(res, 'llvm-readobj COFF')
			res.output
		}
		.llvm_objdump {
			res := os.execute('${quoted_tool} -f -h -t -r ${quoted_path}')
			assert_command_ok(res, 'llvm-objdump COFF')
			res.output
		}
		.dumpbin {
			res := os.execute('${quoted_tool} /headers /symbols /relocations ${quoted_path}')
			assert_command_ok(res, 'dumpbin COFF')
			res.output
		}
		.otool {
			panic('otool is not a COFF validator')
		}
	}

	assert output.contains('AMD64') || output.contains('x86-64') || output.contains('X86_64')
	assert output.contains('.text')
	assert output.contains('.rdata')
	assert output.contains('.data')
	assert output.contains('main')
	assert output.contains('calloc')
	assert output.contains('app_global')
	assert output.contains('L_str_0')
	assert output.contains('REL32')
	if tool.kind == .llvm_readobj {
		assert output.contains('IMAGE_REL_AMD64_REL32') || output.contains('REL32')
		assert output_has_nearby_lines_with_all(output, 'calloc', ['REL32'], 8)
	} else {
		assert output_has_line_with_all(output, ['REL32', 'calloc'])
	}
}

fn test_coff_writer_rejects_relocation_count_overflow() {
	section := CoffSection{
		name:   '.text'
		relocs: []CoffRelocation{len: 0x10000}
	}
	if _ := coff_relocation_count_for_header(section) {
		assert false
	} else {
		assert err.msg().contains('COFF section .text has 65536 relocations')
		assert err.msg().contains('extended relocations are not supported')
	}
}