module x64

import os
import rand
import v2.mir

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

fn pe_test_u32(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 pe_test_u64(data []u8, off int) u64 {
	return u64(pe_test_u32(data, off)) | (u64(pe_test_u32(data, off + 4)) << 32)
}

fn pe_test_i32(data []u8, off int) i32 {
	return i32(pe_test_u32(data, off))
}

fn pe_test_rel8_target(instruction_off int, disp u8) int {
	signed_disp := if int(disp) < 0x80 { int(disp) } else { int(disp) - 0x100 }
	return instruction_off + 2 + signed_disp
}

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

struct PeTestByteRange {
	label string
	start u32
	limit u32
}

fn pe_test_byte_range(label string, start u32, size u32) PeTestByteRange {
	return PeTestByteRange{
		label: label
		start: start
		limit: start + size
	}
}

fn pe_test_assert_range_in_file(image []u8, range PeTestByteRange) {
	assert range.start <= range.limit
	assert range.limit <= u32(image.len)
}

fn pe_test_assert_ranges_do_not_overlap(ranges []PeTestByteRange) {
	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
		}
	}
}

fn pe_test_section_header(image []u8, name string) int {
	pe_off := int(pe_test_u32(image, 0x3c))
	nsections := int(pe_test_u16(image, pe_off + 6))
	section_off := pe_off + 4 + 20 + int(pe_test_u16(image, pe_off + 20))
	for i in 0 .. nsections {
		off := section_off + i * 40
		if image[off..off + 8].bytestr().trim_right('\0') == name {
			return off
		}
	}
	return -1
}

fn pe_test_section_raw_ranges(image []u8) []PeTestByteRange {
	pe_off := int(pe_test_u32(image, 0x3c))
	nsections := int(pe_test_u16(image, pe_off + 6))
	section_off := pe_off + 4 + 20 + int(pe_test_u16(image, pe_off + 20))
	mut ranges := []PeTestByteRange{cap: nsections}
	for i in 0 .. nsections {
		off := section_off + i * 40
		raw_size := pe_test_u32(image, off + 16)
		raw_ptr := pe_test_u32(image, off + 20)
		if raw_size == 0 {
			continue
		}
		name := image[off..off + 8].bytestr().trim_right('\0')
		ranges << pe_test_byte_range(name, raw_ptr, raw_size)
	}
	return ranges
}

fn pe_test_section_virtual_ranges(image []u8) []PeTestByteRange {
	pe_off := int(pe_test_u32(image, 0x3c))
	nsections := int(pe_test_u16(image, pe_off + 6))
	section_off := pe_off + 4 + 20 + int(pe_test_u16(image, pe_off + 20))
	mut ranges := []PeTestByteRange{cap: nsections}
	for i in 0 .. nsections {
		off := section_off + i * 40
		virtual_size := pe_test_u32(image, off + 8)
		virtual_address := pe_test_u32(image, off + 12)
		name := image[off..off + 8].bytestr().trim_right('\0')
		ranges << pe_test_byte_range(name, virtual_address, u32(align_int(int(virtual_size),
			pe_section_alignment)))
	}
	return ranges
}

fn pe_test_assert_ranges_are_adjacent(ranges []PeTestByteRange) {
	if ranges.len < 2 {
		return
	}
	for i in 0 .. ranges.len - 1 {
		assert ranges[i].limit == ranges[i + 1].start
	}
}

fn pe_test_section_virtual_range(image []u8, name string) PeTestByteRange {
	section_off := pe_test_section_header(image, name)
	assert section_off >= 0
	virtual_size := pe_test_u32(image, section_off + 8)
	virtual_address := pe_test_u32(image, section_off + 12)
	return pe_test_byte_range(name, virtual_address, u32(align_int(int(virtual_size),
		pe_section_alignment)))
}

fn pe_test_assert_no_zero_sized_sections(image []u8) {
	pe_off := int(pe_test_u32(image, 0x3c))
	nsections := int(pe_test_u16(image, pe_off + 6))
	section_off := pe_off + 4 + 20 + int(pe_test_u16(image, pe_off + 20))
	for i in 0 .. nsections {
		off := section_off + i * 40
		virtual_size := pe_test_u32(image, off + 8)
		raw_size := pe_test_u32(image, off + 16)
		assert virtual_size != 0 || raw_size != 0
	}
}

fn pe_test_assert_size_of_image_is_exact(image []u8) {
	pe_off := int(pe_test_u32(image, 0x3c))
	opt_off := pe_off + 4 + 20
	ranges := pe_test_section_virtual_ranges(image)
	assert ranges.len > 0
	assert pe_test_u32(image, opt_off + 56) == ranges[ranges.len - 1].limit
}

fn pe_test_assert_entrypoint_in_executable_text(image []u8) {
	pe_off := int(pe_test_u32(image, 0x3c))
	opt_off := pe_off + 4 + 20
	entry_rva := pe_test_u32(image, opt_off + 16)
	text_off := pe_test_section_header(image, '.text')
	text_range := pe_test_section_virtual_range(image, '.text')
	assert entry_rva >= text_range.start
	assert entry_rva < text_range.limit
	assert pe_test_u32(image, text_off + 36) & pe_image_scn_mem_execute != 0
}

fn pe_test_assert_directory_contained_in_section(image []u8, directory_index int, section_name string) {
	pe_off := int(pe_test_u32(image, 0x3c))
	opt_off := pe_off + 4 + 20
	dir_rva := pe_test_u32(image, opt_off + 112 + directory_index * 8)
	dir_size := pe_test_u32(image, opt_off + 116 + directory_index * 8)
	section_range := pe_test_section_virtual_range(image, section_name)
	assert dir_rva >= section_range.start
	assert dir_rva + dir_size <= section_range.limit
}

fn pe_test_rva_to_file_off(image []u8, rva u32) int {
	pe_off := int(pe_test_u32(image, 0x3c))
	nsections := int(pe_test_u16(image, pe_off + 6))
	section_off := pe_off + 4 + 20 + int(pe_test_u16(image, pe_off + 20))
	for i in 0 .. nsections {
		off := section_off + i * 40
		va := pe_test_u32(image, off + 12)
		raw_size := pe_test_u32(image, off + 16)
		raw_ptr := pe_test_u32(image, off + 20)
		virtual_size := pe_test_u32(image, off + 8)
		size := if virtual_size > raw_size { virtual_size } else { raw_size }
		if rva >= va && rva < va + size {
			return int(raw_ptr + (rva - va))
		}
	}
	return -1
}

fn pe_test_import_descriptor_offsets(image []u8) []int {
	pe_off := int(pe_test_u32(image, 0x3c))
	opt_off := pe_off + 4 + 20
	import_rva := pe_test_u32(image, opt_off + 112 + pe_import_directory_index * 8)
	if import_rva == 0 {
		return []
	}
	import_off := pe_test_rva_to_file_off(image, import_rva)
	assert import_off > 0
	mut offsets := []int{}
	for i := 0; i < 32; i++ {
		descriptor_off := import_off + i * 20
		ilt_rva := pe_test_u32(image, descriptor_off)
		dll_name_rva := pe_test_u32(image, descriptor_off + 12)
		first_thunk_rva := pe_test_u32(image, descriptor_off + 16)
		if ilt_rva == 0 && dll_name_rva == 0 && first_thunk_rva == 0 {
			return offsets
		}
		assert ilt_rva != 0
		assert dll_name_rva != 0
		assert first_thunk_rva != 0
		offsets << descriptor_off
	}
	assert false
	return offsets
}

fn pe_test_import_names(image []u8) []string {
	mut names := []string{}
	for descriptor_off in pe_test_import_descriptor_offsets(image) {
		ilt_rva := pe_test_u32(image, descriptor_off)
		ilt_off := pe_test_rva_to_file_off(image, ilt_rva)
		assert ilt_off > 0
		for i := 0; i < 128; i++ {
			hint_name_rva := u32(pe_test_u64(image, ilt_off + i * 8))
			if hint_name_rva == 0 {
				break
			}
			hint_name_off := pe_test_rva_to_file_off(image, hint_name_rva)
			assert hint_name_off > 0
			assert pe_test_u16(image, hint_name_off) == 0
			assert hint_name_off % 2 == 0
			names << pe_test_string(image, hint_name_off + 2)
		}
	}
	return names
}

fn pe_test_import_dll_names(image []u8) []string {
	mut dlls := []string{}
	for descriptor_off in pe_test_import_descriptor_offsets(image) {
		dll_name_rva := pe_test_u32(image, descriptor_off + 12)
		dll_name_off := pe_test_rva_to_file_off(image, dll_name_rva)
		assert dll_name_off > 0
		dlls << pe_test_string(image, dll_name_off)
	}
	return dlls
}

fn pe_test_iat_size(image []u8) u32 {
	pe_off := int(pe_test_u32(image, 0x3c))
	opt_off := pe_off + 4 + 20
	return pe_test_u32(image, opt_off + 116 + pe_iat_directory_index * 8)
}

fn pe_test_text_rel32_target(image []u8, text_rva u32, text_raw int, field_off int) u32 {
	field_rva := text_rva + u32(field_off)
	disp := pe_test_i32(image, text_raw + field_off)
	return u32(i32(field_rva + 4) + disp)
}

fn pe_test_first_import_thunk_rva(image []u8, text_rva u32, text_raw int, text_start int) u32 {
	text_off := pe_test_section_header(image, '.text')
	text_raw_size := int(pe_test_u32(image, text_off + 16))
	for off in text_raw + text_start .. text_raw + text_raw_size - 1 {
		if image[off] == 0xff && image[off + 1] == 0x25 {
			return text_rva + u32(off - text_raw)
		}
	}
	assert false, 'missing PE import thunk in .text'
	return 0
}

fn pe_test_import_thunk_rva(image []u8, text_rva u32, text_raw int, text_start int, name string) u32 {
	names := pe_test_import_names(image)
	idx := names.index(name)
	if idx < 0 {
		assert false, 'missing PE import `${name}` in ${names}'
		return 0
	}
	return pe_test_first_import_thunk_rva(image, text_rva, text_raw, text_start) + u32(idx * 6)
}

fn sample_pe_coff_object() &CoffObject {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xc3), 0xc3]
	obj.rodata << 'Hello World!'.bytes()
	obj.rodata << 0
	obj.data_data << [u8(1), 2, 3, 4]
	obj.add_symbol('_vinit', 0, true, 1)
	obj.add_symbol('main', 1, true, 1)
	return obj
}

fn sample_pe_arguments_coff_object(with_vinit bool) &CoffObject {
	mut obj := CoffObject.new()
	mut main_off := 0
	if with_vinit {
		obj.text_data << u8(0xc3)
		obj.add_symbol('_vinit', 0, true, 1)
		main_off = obj.text_data.len
	}
	obj.text_data << [u8(0x8b), 0x05, 0, 0, 0, 0] // mov eax, [rip + g_main_argc]
	obj.text_data << [u8(0x48), 0x8b, 0x15, 0, 0, 0, 0] // mov rdx, [rip + g_main_argv]
	obj.text_data << u8(0xc3)
	obj.add_symbol('main', u64(main_off), true, 1)
	obj.data_data << [u8(0), 0, 0, 0, 0, 0, 0, 0]
	obj.data_data << [u8(0), 0, 0, 0, 0, 0, 0, 0]
	argc_sym := obj.add_symbol('g_main_argc', 0, false, 3)
	argv_sym := obj.add_symbol('g_main_argv', 8, false, 3)
	obj.add_text_reloc(main_off + 2, argc_sym, coff_image_rel_amd64_rel32)
	obj.add_text_reloc(main_off + 9, argv_sym, coff_image_rel_amd64_rel32)
	return obj
}

fn test_pe_linker_emits_pe32_plus_headers_and_sections() {
	obj := sample_pe_coff_object()
	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }

	assert image[0] == `M`
	assert image[1] == `Z`
	pe_off := int(pe_test_u32(image, 0x3c))
	assert pe_off == pe_dos_stub_size
	assert pe_test_u32(image, pe_off) == pe_signature
	assert pe_test_u16(image, pe_off + 4) == coff_image_file_machine_amd64
	assert pe_test_u16(image, pe_off + 6) == 4
	assert pe_test_u32(image, pe_off + 8) == 0
	assert pe_test_u32(image, pe_off + 12) == 0
	assert pe_test_u32(image, pe_off + 16) == 0
	assert pe_test_u16(image, pe_off + 20) == pe_size_of_optional_header64
	assert pe_test_u16(image, pe_off + 22) & pe_image_file_relocs_stripped != 0
	assert pe_test_u16(image, pe_off + 22) & pe_image_file_executable_image != 0
	assert pe_test_u16(image, pe_off + 22) & pe_image_file_large_address_aware != 0

	opt_off := pe_off + 4 + 20
	assert pe_test_u16(image, opt_off) == pe_optional_header64_magic
	assert image[opt_off + 2] == pe_linker_major_version
	assert image[opt_off + 3] == pe_linker_minor_version
	assert pe_test_u32(image, opt_off + 4) != 0
	assert pe_test_u32(image, opt_off + 8) != 0
	assert pe_test_u32(image, opt_off + 12) == 0
	assert pe_test_u32(image, opt_off + 16) == pe_section_alignment
	assert pe_test_u32(image, opt_off + 20) == pe_section_alignment
	assert pe_test_u64(image, opt_off + 24) == pe_image_base
	assert pe_test_u32(image, opt_off + 32) == pe_section_alignment
	assert pe_test_u32(image, opt_off + 36) == pe_file_alignment
	assert pe_test_u16(image, opt_off + 40) == pe_major_operating_system_version
	assert pe_test_u16(image, opt_off + 42) == pe_minor_operating_system_version
	assert pe_test_u16(image, opt_off + 48) == pe_major_subsystem_version
	assert pe_test_u16(image, opt_off + 50) == pe_minor_subsystem_version
	assert pe_test_u32(image, opt_off + 52) == 0
	assert pe_test_u32(image, opt_off + 60) == pe_headers_size(4)
	assert pe_test_u32(image, opt_off + 64) == 0
	assert pe_test_u16(image, opt_off + 68) == pe_image_subsystem_windows_cui
	assert pe_test_u16(image, opt_off + 70) & pe_dll_characteristics_nx_compat != 0
	assert pe_test_u64(image, opt_off + 72) == pe_size_of_stack_reserve
	assert pe_test_u64(image, opt_off + 80) == pe_size_of_stack_commit
	assert pe_test_u64(image, opt_off + 88) == pe_size_of_heap_reserve
	assert pe_test_u64(image, opt_off + 96) == pe_size_of_heap_commit
	assert pe_test_u32(image, opt_off + 104) == 0
	assert pe_test_u32(image, opt_off + 108) == pe_number_of_rva_and_sizes

	text_off := pe_test_section_header(image, '.text')
	rdata_off := pe_test_section_header(image, '.rdata')
	data_off := pe_test_section_header(image, '.data')
	idata_off := pe_test_section_header(image, '.idata')
	assert text_off > 0
	assert rdata_off > text_off
	assert data_off > rdata_off
	assert idata_off > data_off
	mut file_ranges := [
		pe_test_byte_range('PE headers', 0, pe_test_u32(image, opt_off + 60)),
	]
	file_ranges << pe_test_section_raw_ranges(image)
	for range in file_ranges {
		pe_test_assert_range_in_file(image, range)
	}
	pe_test_assert_ranges_do_not_overlap(file_ranges)
	pe_test_assert_ranges_are_adjacent(pe_test_section_virtual_ranges(image))
	pe_test_assert_no_zero_sized_sections(image)
	pe_test_assert_size_of_image_is_exact(image)
	pe_test_assert_entrypoint_in_executable_text(image)
	pe_test_assert_directory_contained_in_section(image, pe_import_directory_index, '.idata')
	pe_test_assert_directory_contained_in_section(image, pe_iat_directory_index, '.idata')
	assert pe_test_u32(image, text_off + 8) != 0
	assert pe_test_u32(image, text_off + 12) == pe_section_alignment
	assert pe_test_u32(image, text_off + 20) == pe_headers_size(4)
	assert pe_test_u32(image, text_off + 20) % pe_file_alignment == 0
	assert pe_test_u32(image, text_off + 16) % pe_file_alignment == 0
	assert pe_test_u32(image, text_off + 24) == 0
	assert pe_test_u32(image, text_off + 28) == 0
	assert pe_test_u16(image, text_off + 32) == 0
	assert pe_test_u16(image, text_off + 34) == 0
	assert pe_test_u32(image, text_off + 36) & pe_image_scn_cnt_code != 0
	assert pe_test_u32(image, text_off + 36) & pe_image_scn_mem_execute != 0
	assert pe_test_u32(image, text_off + 36) & pe_image_scn_mem_read != 0
	assert pe_test_u32(image, rdata_off + 8) == u32(obj.rodata.len)
	assert pe_test_u32(image, rdata_off + 12) % pe_section_alignment == 0
	assert pe_test_u32(image, rdata_off + 16) % pe_file_alignment == 0
	assert pe_test_u32(image, rdata_off + 20) % pe_file_alignment == 0
	assert pe_test_u32(image, rdata_off + 24) == 0
	assert pe_test_u16(image, rdata_off + 32) == 0
	assert pe_test_u32(image, rdata_off + 36) & pe_image_scn_cnt_initialized_data != 0
	assert pe_test_u32(image, rdata_off + 36) & pe_image_scn_mem_read != 0
	assert pe_test_u32(image, data_off + 8) == u32(obj.data_data.len)
	assert pe_test_u32(image, data_off + 16) % pe_file_alignment == 0
	assert pe_test_u32(image, data_off + 20) % pe_file_alignment == 0
	assert pe_test_u32(image, data_off + 24) == 0
	assert pe_test_u16(image, data_off + 32) == 0
	assert pe_test_u32(image, data_off + 36) & pe_image_scn_cnt_initialized_data != 0
	assert pe_test_u32(image, data_off + 36) & pe_image_scn_mem_read != 0
	assert pe_test_u32(image, data_off + 36) & pe_image_scn_mem_write != 0
	assert pe_test_u32(image, idata_off + 8) != 0
	assert pe_test_u32(image, idata_off + 12) % pe_section_alignment == 0
	assert pe_test_u32(image, idata_off + 16) % pe_file_alignment == 0
	assert pe_test_u32(image, idata_off + 20) % pe_file_alignment == 0
	assert pe_test_u32(image, idata_off + 24) == 0
	assert pe_test_u16(image, idata_off + 32) == 0
	assert pe_test_u32(image, idata_off + 36) & pe_image_scn_cnt_initialized_data != 0
	assert pe_test_u32(image, idata_off + 36) & pe_image_scn_mem_read != 0
	assert pe_test_u32(image, idata_off + 36) & pe_image_scn_mem_write != 0

	idata_end := pe_test_u32(image, idata_off + 12) + pe_section_alignment
	assert pe_test_u32(image, opt_off + 56) == idata_end
}

fn test_pe_linker_emits_demand_driven_kernel32_import_table() {
	obj := sample_pe_coff_object()
	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	expected_imports := ['ExitProcess']

	pe_off := int(pe_test_u32(image, 0x3c))
	opt_off := pe_off + 4 + 20
	import_rva := pe_test_u32(image, opt_off + 112 + pe_import_directory_index * 8)
	import_size := pe_test_u32(image, opt_off + 116 + pe_import_directory_index * 8)
	iat_rva := pe_test_u32(image, opt_off + 112 + pe_iat_directory_index * 8)
	iat_size := pe_test_u32(image, opt_off + 116 + pe_iat_directory_index * 8)
	assert import_rva != 0
	assert import_size == 40
	assert iat_rva != 0
	assert iat_size == u32((expected_imports.len + 1) * 8)

	import_off := pe_test_rva_to_file_off(image, import_rva)
	assert import_off > 0
	ilt_rva := pe_test_u32(image, import_off)
	dll_name_rva := pe_test_u32(image, import_off + 12)
	first_thunk_rva := pe_test_u32(image, import_off + 16)
	assert ilt_rva != 0
	assert first_thunk_rva == iat_rva
	assert pe_test_string(image, pe_test_rva_to_file_off(image, dll_name_rva)) == 'kernel32.dll'
	for i in 0 .. 20 {
		assert image[import_off + 20 + i] == 0
	}

	mut names := []string{}
	ilt_off := pe_test_rva_to_file_off(image, ilt_rva)
	iat_off := pe_test_rva_to_file_off(image, iat_rva)
	for i in 0 .. expected_imports.len {
		hint_name_rva := u32(pe_test_u64(image, ilt_off + i * 8))
		hint_name_off := pe_test_rva_to_file_off(image, hint_name_rva)
		assert pe_test_u16(image, hint_name_off) == 0
		assert hint_name_off % 2 == 0
		names << pe_test_string(image, hint_name_off + 2)
		assert pe_test_u64(image, iat_off + i * 8) == pe_test_u64(image, ilt_off + i * 8)
	}
	assert pe_test_u64(image, ilt_off + expected_imports.len * 8) == 0
	assert pe_test_u64(image, iat_off + expected_imports.len * 8) == 0
	assert names == expected_imports
	assert names == pe_test_import_names(image)
	assert pe_test_import_dll_names(image) == ['kernel32.dll']
	assert pe_test_iat_size(image) == u32((expected_imports.len + 1) * 8)
	assert 'HeapAlloc' !in names
	assert 'WriteFile' !in names
	assert 'GetCommandLineW' !in names
	assert 'CommandLineToArgvW' !in names
}

fn test_pe_linker_adds_direct_kernel32_imports_in_stable_order() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xe8, 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 10, true, 1)
	write_file_sym := obj.add_undefined('WriteFile')
	get_std_handle_sym := obj.add_undefined('GetStdHandle')
	obj.add_text_reloc(1, write_file_sym, coff_image_rel_amd64_rel32)
	obj.add_text_reloc(6, get_std_handle_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	names := pe_test_import_names(image)
	dll_names := pe_test_import_dll_names(image)

	assert names == ['ExitProcess', 'GetStdHandle', 'WriteFile']
	assert dll_names == ['kernel32.dll']
	assert pe_test_iat_size(image) == u32((names.len + 1) * 8)
	assert 'ucrtbase.dll' !in dll_names
}

fn test_pe_linker_imports_kernel32_readconsole_readfile_and_patches_call_to_import_thunks() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xe8, 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 10, true, 1)
	read_console_sym := obj.add_undefined('ReadConsole')
	read_file_sym := obj.add_undefined('ReadFile')
	obj.add_text_reloc(1, read_console_sym, coff_image_rel_amd64_rel32)
	obj.add_text_reloc(6, read_file_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	names := pe_test_import_names(image)
	dll_names := pe_test_import_dll_names(image)

	assert names == ['ExitProcess', 'ReadConsoleW', 'ReadFile']
	assert dll_names == ['kernel32.dll']
	assert pe_test_iat_size(image) == u32((names.len + 1) * 8)

	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	read_console_thunk := pe_test_import_thunk_rva(image, text_rva, text_raw,

		linker.entry_stub_size() + obj.text_data.len, 'ReadConsoleW')
	read_file_thunk := pe_test_import_thunk_rva(image, text_rva, text_raw,

		linker.entry_stub_size() + obj.text_data.len, 'ReadFile')
	read_console_field_off := text_raw + linker.entry_stub_size() + 1
	read_console_field_rva := text_rva + u32(linker.entry_stub_size() + 1)
	read_console_disp := pe_test_i32(image, read_console_field_off)
	read_console_target := u32(i32(read_console_field_rva + 4) + read_console_disp)
	assert read_console_target == read_console_thunk
	read_file_field_off := text_raw + linker.entry_stub_size() + 6
	read_file_field_rva := text_rva + u32(linker.entry_stub_size() + 6)
	read_file_disp := pe_test_i32(image, read_file_field_off)
	read_file_target := u32(i32(read_file_field_rva + 4) + read_file_disp)
	assert read_file_target == read_file_thunk
}

fn test_pe_linker_imports_ucrt_log_and_patches_call_to_import_thunk() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	log_sym := obj.add_undefined('log')
	obj.add_text_reloc(1, log_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	names := pe_test_import_names(image)
	dll_names := pe_test_import_dll_names(image)

	assert names == ['ExitProcess', 'log']
	assert dll_names == ['kernel32.dll', 'ucrtbase.dll']
	assert pe_test_iat_size(image) == u32((names.len + dll_names.len) * 8)

	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	field_off := text_raw + linker.entry_stub_size() + 1
	field_rva := text_rva + u32(linker.entry_stub_size() + 1)
	disp := pe_test_i32(image, field_off)
	target := u32(i32(field_rva + 4) + disp)
	log_thunk := pe_test_import_thunk_rva(image, text_rva, text_raw, linker.entry_stub_size() +
		obj.text_data.len, 'log')
	assert target == log_thunk
}

fn test_pe_linker_imports_ucrt_ldexp_and_patches_call_to_import_thunk() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	ldexp_sym := obj.add_undefined('ldexp')
	obj.add_text_reloc(1, ldexp_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	names := pe_test_import_names(image)
	dll_names := pe_test_import_dll_names(image)

	assert names == ['ExitProcess', 'ldexp']
	assert dll_names == ['kernel32.dll', 'ucrtbase.dll']
	assert pe_test_iat_size(image) == u32((names.len + dll_names.len) * 8)

	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	field_off := text_raw + linker.entry_stub_size() + 1
	field_rva := text_rva + u32(linker.entry_stub_size() + 1)
	disp := pe_test_i32(image, field_off)
	target := u32(i32(field_rva + 4) + disp)
	ldexp_thunk := pe_test_import_thunk_rva(image, text_rva, text_raw, linker.entry_stub_size() +
		obj.text_data.len, 'ldexp')
	assert target == ldexp_thunk
}

fn test_pe_linker_imports_ucrt_sqrt_and_patches_call_to_import_thunk() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	sqrt_sym := obj.add_undefined('sqrt')
	obj.add_text_reloc(1, sqrt_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	names := pe_test_import_names(image)
	dll_names := pe_test_import_dll_names(image)

	assert names == ['ExitProcess', 'sqrt']
	assert dll_names == ['kernel32.dll', 'ucrtbase.dll']
	assert pe_test_iat_size(image) == u32((names.len + dll_names.len) * 8)

	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	field_off := text_raw + linker.entry_stub_size() + 1
	field_rva := text_rva + u32(linker.entry_stub_size() + 1)
	disp := pe_test_i32(image, field_off)
	target := u32(i32(field_rva + 4) + disp)
	sqrt_thunk := pe_test_import_thunk_rva(image, text_rva, text_raw, linker.entry_stub_size() +
		obj.text_data.len, 'sqrt')
	assert target == sqrt_thunk
}

fn test_pe_linker_maps_time_and_localtime_to_ucrt64_imports_and_patches_thunks() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xe8, 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 10, true, 1)
	time_sym := obj.add_undefined('time')
	localtime_sym := obj.add_undefined('localtime')
	obj.add_text_reloc(1, time_sym, coff_image_rel_amd64_rel32)
	obj.add_text_reloc(6, localtime_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	names := pe_test_import_names(image)
	dll_names := pe_test_import_dll_names(image)

	assert names == ['ExitProcess', '_time64', '_localtime64']
	assert dll_names == ['kernel32.dll', 'ucrtbase.dll']
	assert 'time' !in names
	assert 'localtime' !in names
	assert pe_test_iat_size(image) == u32((names.len + dll_names.len) * 8)

	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	time_thunk := pe_test_import_thunk_rva(image, text_rva, text_raw, linker.entry_stub_size() +
		obj.text_data.len, '_time64')
	localtime_thunk := pe_test_import_thunk_rva(image, text_rva, text_raw,

		linker.entry_stub_size() + obj.text_data.len, '_localtime64')
	time_field_off := text_raw + linker.entry_stub_size() + 1
	time_field_rva := text_rva + u32(linker.entry_stub_size() + 1)
	time_disp := pe_test_i32(image, time_field_off)
	time_target := u32(i32(time_field_rva + 4) + time_disp)
	assert time_target == time_thunk
	localtime_field_off := text_raw + linker.entry_stub_size() + 6
	localtime_field_rva := text_rva + u32(linker.entry_stub_size() + 6)
	localtime_disp := pe_test_i32(image, localtime_field_off)
	localtime_target := u32(i32(localtime_field_rva + 4) + localtime_disp)
	assert localtime_target == localtime_thunk
}

fn test_pe_linker_imports_msvcrt_scprintf_snprintf_and_patches_call_to_import_thunks() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xe8, 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 10, true, 1)
	scprintf_sym := obj.add_undefined('_scprintf')
	snprintf_sym := obj.add_undefined('_snprintf')
	obj.add_text_reloc(1, scprintf_sym, coff_image_rel_amd64_rel32)
	obj.add_text_reloc(6, snprintf_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	names := pe_test_import_names(image)
	dll_names := pe_test_import_dll_names(image)

	assert names == ['ExitProcess', '_scprintf', '_snprintf']
	assert dll_names == ['kernel32.dll', 'msvcrt.dll']
	assert pe_test_iat_size(image) == u32((names.len + dll_names.len) * 8)

	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	scprintf_thunk := pe_test_import_thunk_rva(image, text_rva, text_raw,

		linker.entry_stub_size() + obj.text_data.len, '_scprintf')
	snprintf_thunk := pe_test_import_thunk_rva(image, text_rva, text_raw,

		linker.entry_stub_size() + obj.text_data.len, '_snprintf')
	scprintf_field_off := text_raw + linker.entry_stub_size() + 1
	scprintf_field_rva := text_rva + u32(linker.entry_stub_size() + 1)
	scprintf_disp := pe_test_i32(image, scprintf_field_off)
	scprintf_target := u32(i32(scprintf_field_rva + 4) + scprintf_disp)
	assert scprintf_target == scprintf_thunk
	snprintf_field_off := text_raw + linker.entry_stub_size() + 6
	snprintf_field_rva := text_rva + u32(linker.entry_stub_size() + 6)
	snprintf_disp := pe_test_i32(image, snprintf_field_off)
	snprintf_target := u32(i32(snprintf_field_rva + 4) + snprintf_disp)
	assert snprintf_target == snprintf_thunk
}

fn test_pe_linker_resolves_atexit_with_internal_runtime_not_crt_import() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	atexit_sym := obj.add_undefined('atexit')
	obj.add_text_reloc(1, atexit_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	names := pe_test_import_names(image)
	dll_names := pe_test_import_dll_names(image)

	assert names == ['ExitProcess']
	assert dll_names == ['kernel32.dll']
	assert 'atexit' !in names
	assert 'ucrtbase.dll' !in dll_names
	assert 'msvcrt.dll' !in dll_names
	assert pe_test_section_header(image, '.data') >= 0

	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	entry_stub_len := linker.entry_stub_size()
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)
	first_import_thunk_rva := pe_test_first_import_thunk_rva(image, text_rva, text_raw,

		entry_stub_len + obj.text_data.len)
	field_off := entry_stub_len + 1
	target := pe_test_text_rel32_target(image, text_rva, text_raw, field_off)

	assert target >= runtime_start_rva
	assert target < first_import_thunk_rva
}

fn test_pe_linker_adds_runtime_kernel32_import_patches_only_when_needed() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	calloc_sym := obj.add_undefined('calloc')
	obj.add_text_reloc(1, calloc_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	names := pe_test_import_names(image)

	assert names == ['ExitProcess', 'GetProcessHeap', 'HeapAlloc']
	assert pe_test_iat_size(image) == u32((names.len + 1) * 8)
	assert 'HeapFree' !in names
	assert 'WriteFile' !in names
}

fn test_pe_linker_adds_malloc_heap_imports_without_crt() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	malloc_sym := obj.add_undefined('malloc')
	obj.add_text_reloc(1, malloc_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	names := pe_test_import_names(image)
	dll_names := pe_test_import_dll_names(image)

	assert names == ['ExitProcess', 'GetProcessHeap', 'HeapAlloc']
	assert dll_names == ['kernel32.dll']
	assert pe_test_iat_size(image) == u32((names.len + 1) * 8)
	assert 'HeapFree' !in names
	assert 'HeapReAlloc' !in names
	assert 'ucrtbase.dll' !in dll_names
	assert 'msvcrt.dll' !in dll_names
}

fn test_pe_linker_adds_shell32_imports_only_for_windows_arguments_globals() {
	obj := sample_pe_arguments_coff_object(false)
	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	names := pe_test_import_names(image)

	assert names == ['ExitProcess', 'GetCommandLineW', 'CommandLineToArgvW']
	assert pe_test_import_dll_names(image) == ['kernel32.dll', 'shell32.dll']
	assert pe_test_iat_size(image) == u32((names.len + 2) * 8)
}

fn test_pe_linker_uses_qualified_import_keys_for_multi_dll_thunks_and_iat() {
	obj := sample_pe_coff_object()
	mut linker := PeLinker.new(obj)
	linker.imports = [
		PeImport{
			dll:  pe_kernel32_dll
			name: 'SharedExport'
		},
		PeImport{
			dll:  pe_shell32_dll
			name: 'SharedExport'
		},
	]

	kernel_key := pe_import_key(pe_kernel32_dll, 'SharedExport')
	shell_key := pe_import_key(pe_shell32_dll, 'SharedExport')
	import_offsets := linker.import_thunk_offsets(0)
	idata := linker.build_idata(0x3000)

	assert 'SharedExport' !in import_offsets
	assert kernel_key in import_offsets
	assert shell_key in import_offsets
	assert import_offsets[kernel_key] != import_offsets[shell_key]
	assert 'SharedExport' !in idata.iat_rvas
	assert kernel_key in idata.iat_rvas
	assert shell_key in idata.iat_rvas
	assert idata.iat_rvas[kernel_key] != idata.iat_rvas[shell_key]
}

fn test_pe_linker_resolves_windows_string_plus_runtime_with_heap_imports() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	string_plus_sym := obj.add_undefined('builtin__string__+')
	obj.add_text_reloc(1, string_plus_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	names := pe_test_import_names(image)

	assert names == ['ExitProcess', 'GetProcessHeap', 'HeapAlloc']
	assert pe_test_iat_size(image) == u32((names.len + 1) * 8)
	assert 'WriteFile' !in names
}

fn test_pe_linker_resolves_windows_i64_str_runtime_with_heap_imports() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	i64_str_sym := obj.add_undefined('builtin__i64__str')
	obj.add_text_reloc(1, i64_str_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	names := pe_test_import_names(image)

	assert names == ['ExitProcess', 'GetProcessHeap', 'HeapAlloc']
	assert pe_test_iat_size(image) == u32((names.len + 1) * 8)
	assert 'WriteFile' !in names
}

fn test_pe_linker_zeroes_unemitted_data_directories() {
	obj := sample_pe_coff_object()
	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }

	pe_off := int(pe_test_u32(image, 0x3c))
	opt_off := pe_off + 4 + 20
	for i in 0 .. pe_number_of_rva_and_sizes {
		if i in [pe_import_directory_index, pe_iat_directory_index] {
			continue
		}
		assert pe_test_u32(image, opt_off + 112 + i * 8) == 0
		assert pe_test_u32(image, opt_off + 116 + i * 8) == 0
	}
	assert pe_test_u32(image, opt_off + 112 + pe_exception_directory_index * 8) == 0
	assert pe_test_u32(image, opt_off + 116 + pe_exception_directory_index * 8) == 0
	assert pe_test_u32(image, opt_off + 112 + pe_base_reloc_directory_index * 8) == 0
	assert pe_test_u32(image, opt_off + 116 + pe_base_reloc_directory_index * 8) == 0
}

fn test_pe_linker_marks_fixed_base_image_without_unwind_or_reloc_directories() {
	obj := sample_pe_coff_object()
	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }

	pe_off := int(pe_test_u32(image, 0x3c))
	characteristics := pe_test_u16(image, pe_off + 22)
	assert characteristics & pe_image_file_relocs_stripped != 0

	opt_off := pe_off + 4 + 20
	assert pe_test_u32(image, opt_off + 112 + pe_base_reloc_directory_index * 8) == 0
	assert pe_test_u32(image, opt_off + 116 + pe_base_reloc_directory_index * 8) == 0
	assert pe_test_u32(image, opt_off + 112 + pe_exception_directory_index * 8) == 0
	assert pe_test_u32(image, opt_off + 116 + pe_exception_directory_index * 8) == 0
}

fn test_pe_linker_omits_empty_rdata_and_data_sections() {
	mut obj := CoffObject.new()
	obj.text_data << u8(0xc3)
	obj.add_symbol('main', 0, true, 1)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	pe_off := int(pe_test_u32(image, 0x3c))
	opt_off := pe_off + 4 + 20
	text_off := pe_test_section_header(image, '.text')
	idata_off := pe_test_section_header(image, '.idata')

	assert pe_test_u16(image, pe_off + 6) == 2
	assert text_off > 0
	assert pe_test_section_header(image, '.rdata') == -1
	assert pe_test_section_header(image, '.data') == -1
	assert idata_off > text_off

	assert pe_test_u32(image, text_off + 12) == pe_section_alignment
	assert pe_test_u32(image, idata_off + 12) == pe_section_alignment * 2
	assert pe_test_u32(image, idata_off + 20) == pe_headers_size(2) + pe_file_alignment
	assert pe_test_u32(image, opt_off + 56) == pe_section_alignment * 3
	pe_test_assert_ranges_are_adjacent(pe_test_section_virtual_ranges(image))
	pe_test_assert_no_zero_sized_sections(image)
	pe_test_assert_size_of_image_is_exact(image)
	pe_test_assert_entrypoint_in_executable_text(image)
	pe_test_assert_directory_contained_in_section(image, pe_import_directory_index, '.idata')
	pe_test_assert_directory_contained_in_section(image, pe_iat_directory_index, '.idata')
}

fn test_pe_linker_entry_stub_targets_main_and_runtime_exit() {
	obj := sample_pe_coff_object()
	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }

	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	entry_stub_len := linker.entry_stub_size()

	assert image[text_raw..text_raw + 4] == [u8(0x48), 0x83, 0xec, 0x28]
	assert image[text_raw + entry_stub_len - 1] == 0xcc

	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)
	first_import_thunk_rva := pe_test_first_import_thunk_rva(image, text_rva, text_raw,

		entry_stub_len + obj.text_data.len)
	assert image[text_raw + 4] == 0xe8
	assert pe_test_text_rel32_target(image, text_rva, text_raw, 5) == text_rva + u32(entry_stub_len)
	assert image[text_raw + 9] == 0xe8
	assert pe_test_text_rel32_target(image, text_rva, text_raw, 10) == text_rva +
		u32(entry_stub_len + 1)
	assert image[text_raw + 14..text_raw + 16] == [u8(0x31), 0xc9]
	assert image[text_raw + 16] == 0xe8
	exit_target := pe_test_text_rel32_target(image, text_rva, text_raw, 17)
	assert exit_target >= runtime_start_rva
	assert exit_target < first_import_thunk_rva
}

fn test_pe_linker_entry_stub_uses_common_runtime_exit_when_atexit_is_present() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	atexit_sym := obj.add_undefined('atexit')
	obj.add_text_reloc(1, atexit_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	entry_stub_len := linker.entry_stub_size()
	first_import_thunk_rva := pe_test_first_import_thunk_rva(image, text_rva, text_raw,

		entry_stub_len + obj.text_data.len)
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)

	assert image[text_raw..text_raw + 4] == [u8(0x48), 0x83, 0xec, 0x28]
	assert image[text_raw + 4] == 0xe8
	assert pe_test_text_rel32_target(image, text_rva, text_raw, 5) == text_rva +
		u32(entry_stub_len + 5)
	assert image[text_raw + 9..text_raw + 11] == [u8(0x31), 0xc9]
	assert image[text_raw + 11] == 0xe8
	exit_target := pe_test_text_rel32_target(image, text_rva, text_raw, 12)
	assert exit_target >= runtime_start_rva
	assert exit_target < first_import_thunk_rva
	assert image[text_raw + entry_stub_len - 1] == 0xcc
}

fn test_pe_linker_bootstraps_windows_arguments_before_vinit() {
	obj := sample_pe_arguments_coff_object(true)
	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }

	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	data_off := pe_test_section_header(image, '.data')
	data_rva := pe_test_u32(image, data_off + 12)
	entry_stub_len := linker.entry_stub_size()
	bootstrap_len := linker.windows_argv_bootstrap_size()

	assert bootstrap_len > 0
	assert image[text_raw..text_raw + 4] == [u8(0x48), 0x83, 0xec, 0x28]
	assert image[text_raw + 4..text_raw + 12] == [u8(0xc7), 0x44, 0x24, 0x20, 0, 0, 0, 0]
	assert image[text_raw + 12] == 0xe8
	assert image[text_raw + 17..text_raw + 20] == [u8(0x48), 0x89, 0xc1]
	assert image[text_raw + 20..text_raw + 25] == [u8(0x48), 0x8d, 0x54, 0x24, 0x20]
	assert image[text_raw + 25] == 0xe8
	assert image[text_raw + 30..text_raw + 33] == [u8(0x48), 0x85, 0xc0]
	assert image[text_raw + 33..text_raw + 35] == [u8(0x75), 0x0a]
	assert image[text_raw + 35..text_raw + 40] == [u8(0xb9), 1, 0, 0, 0]
	assert image[text_raw + 40] == 0xe8
	assert image[text_raw + 45..text_raw + 48] == [u8(0x4c), 0x8d, 0x15]
	assert image[text_raw + 52..text_raw + 55] == [u8(0x49), 0x89, 0x02]
	assert image[text_raw + 55..text_raw + 58] == [u8(0x4c), 0x8d, 0x15]
	assert image[text_raw + 62..text_raw + 66] == [u8(0x8b), 0x4c, 0x24, 0x20]
	assert image[text_raw + 66..text_raw + 69] == [u8(0x41), 0x89, 0x0a]

	get_command_line_thunk := pe_test_import_thunk_rva(image, text_rva, text_raw, entry_stub_len +
		obj.text_data.len, 'GetCommandLineW')
	command_line_to_argv_thunk := pe_test_import_thunk_rva(image, text_rva, text_raw,

		entry_stub_len + obj.text_data.len, 'CommandLineToArgvW')
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)
	first_import_thunk_rva := pe_test_first_import_thunk_rva(image, text_rva, text_raw,

		entry_stub_len + obj.text_data.len)
	assert pe_test_text_rel32_target(image, text_rva, text_raw, 13) == get_command_line_thunk
	assert pe_test_text_rel32_target(image, text_rva, text_raw, 26) == command_line_to_argv_thunk
	argv_failure_exit_target := pe_test_text_rel32_target(image, text_rva, text_raw, 41)
	assert argv_failure_exit_target >= runtime_start_rva
	assert argv_failure_exit_target < first_import_thunk_rva
	assert pe_test_text_rel32_target(image, text_rva, text_raw, 48) == data_rva + 8
	assert pe_test_text_rel32_target(image, text_rva, text_raw, 58) == data_rva
	vinit_call_field := 4 + bootstrap_len + 1
	main_call_field := vinit_call_field + 5
	assert pe_test_text_rel32_target(image, text_rva, text_raw, vinit_call_field) == text_rva +
		u32(entry_stub_len)
	assert pe_test_text_rel32_target(image, text_rva, text_raw, main_call_field) == text_rva +
		u32(entry_stub_len + 1)
}

fn test_pe_linker_applies_internal_rel32_relocations() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 0, true, 1)
	helper_sym := obj.add_symbol('helper', 5, true, 1)
	obj.add_text_reloc(1, helper_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	text_off := pe_test_section_header(image, '.text')
	text_raw := int(pe_test_u32(image, text_off + 20))
	field_off := text_raw + linker.entry_stub_size() + 1
	assert pe_test_i32(image, field_off) == 0
}

fn test_pe_linker_applies_import_rel32_relocations_to_thunks() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 0, true, 1)
	exit_sym := obj.add_undefined('ExitProcess')
	obj.add_text_reloc(1, exit_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	field_off := text_raw + linker.entry_stub_size() + 1
	field_rva := text_rva + u32(linker.entry_stub_size() + 1)
	disp := pe_test_i32(image, field_off)
	target := u32(i32(field_rva + 4) + disp)
	assert target == pe_test_import_thunk_rva(image, text_rva, text_raw, linker.entry_stub_size() +
		obj.text_data.len, 'ExitProcess')
}

fn test_pe_linker_resolves_get_current_thread_id_as_kernel32_import() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 0, true, 1)
	get_tid_sym := obj.add_undefined('GetCurrentThreadId')
	obj.add_text_reloc(1, get_tid_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	field_off := text_raw + linker.entry_stub_size() + 1
	field_rva := text_rva + u32(linker.entry_stub_size() + 1)
	disp := pe_test_i32(image, field_off)
	target := u32(i32(field_rva + 4) + disp)
	get_tid_thunk := pe_test_import_thunk_rva(image, text_rva, text_raw, linker.entry_stub_size() +
		obj.text_data.len, 'GetCurrentThreadId')

	assert target == get_tid_thunk
}

fn test_pe_linker_resolves_windows_system_time_imports() {
	for name in ['GetSystemTimeAsFileTime', 'FileTimeToSystemTime', 'SystemTimeToTzSpecificLocalTime',
		'QueryPerformanceFrequency', 'QueryPerformanceCounter'] {
		mut obj := CoffObject.new()
		obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
		obj.add_symbol('main', 0, true, 1)
		sym := obj.add_undefined(name)
		obj.add_text_reloc(1, sym, coff_image_rel_amd64_rel32)

		mut linker := PeLinker.new(obj)
		image := linker.image() or { panic(err) }
		text_off := pe_test_section_header(image, '.text')
		text_rva := pe_test_u32(image, text_off + 12)
		text_raw := int(pe_test_u32(image, text_off + 20))
		field_off := text_raw + linker.entry_stub_size() + 1
		field_rva := text_rva + u32(linker.entry_stub_size() + 1)
		disp := pe_test_i32(image, field_off)
		target := u32(i32(field_rva + 4) + disp)
		thunk := pe_test_import_thunk_rva(image, text_rva, text_raw, linker.entry_stub_size() +
			obj.text_data.len, name)

		assert target == thunk
	}
}

fn test_pe_linker_resolves_memcmp_and_exit_with_internal_runtime_thunks() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xe8, 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 10, true, 1)
	memcmp_sym := obj.add_undefined('memcmp')
	exit_sym := obj.add_undefined('exit')
	obj.add_text_reloc(1, memcmp_sym, coff_image_rel_amd64_rel32)
	obj.add_text_reloc(6, exit_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	text_raw_size := int(pe_test_u32(image, text_off + 16))
	entry_stub_len := linker.entry_stub_size()
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)

	mut first_import_thunk_file_off := -1
	for off in text_raw + entry_stub_len + obj.text_data.len .. text_raw + text_raw_size - 1 {
		if image[off] == 0xff && image[off + 1] == 0x25 {
			first_import_thunk_file_off = off
			break
		}
	}
	assert first_import_thunk_file_off > 0
	first_import_thunk_rva := text_rva + u32(first_import_thunk_file_off - text_raw)

	memcmp_field_off := text_raw + entry_stub_len + 1
	memcmp_field_rva := text_rva + u32(entry_stub_len + 1)
	memcmp_target := u32(i32(memcmp_field_rva + 4) + pe_test_i32(image, memcmp_field_off))
	exit_field_off := text_raw + entry_stub_len + 6
	exit_field_rva := text_rva + u32(entry_stub_len + 6)
	exit_target := u32(i32(exit_field_rva + 4) + pe_test_i32(image, exit_field_off))

	assert memcmp_target >= runtime_start_rva
	assert memcmp_target < first_import_thunk_rva
	assert exit_target >= runtime_start_rva
	assert exit_target < first_import_thunk_rva
	assert exit_target != memcmp_target

	memcmp_off := pe_test_rva_to_file_off(image, memcmp_target)
	assert memcmp_off > 0
	assert image[memcmp_off..memcmp_off + 3] == [u8(0x4d), 0x85, 0xc0] // test r8, r8
	assert image[memcmp_off + 22..memcmp_off + 25] == [u8(0x49), 0xff, 0xc8] // dec r8
}

fn test_pe_linker_resolves_errno_with_internal_runtime_data_slot() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	errno_sym := obj.add_undefined('_errno')
	obj.add_text_reloc(1, errno_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	text_raw_size := int(pe_test_u32(image, text_off + 16))
	entry_stub_len := linker.entry_stub_size()
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)

	mut first_import_thunk_file_off := -1
	for off in text_raw + entry_stub_len + obj.text_data.len .. text_raw + text_raw_size - 1 {
		if image[off] == 0xff && image[off + 1] == 0x25 {
			first_import_thunk_file_off = off
			break
		}
	}
	assert first_import_thunk_file_off > 0
	first_import_thunk_rva := text_rva + u32(first_import_thunk_file_off - text_raw)

	errno_field_off := text_raw + entry_stub_len + 1
	errno_field_rva := text_rva + u32(entry_stub_len + 1)
	errno_target := u32(i32(errno_field_rva + 4) + pe_test_i32(image, errno_field_off))
	assert errno_target >= runtime_start_rva
	assert errno_target < first_import_thunk_rva

	errno_off := pe_test_rva_to_file_off(image, errno_target)
	assert errno_off > 0
	assert image[errno_off..errno_off + 3] == [u8(0x48), 0x8d, 0x05] // lea rax, [rip + disp32]
	assert image[errno_off + 7] == u8(0xc3) // ret
	slot_target := u32(i32(errno_target + 7) + pe_test_i32(image, errno_off + 3))
	data_off := pe_test_section_header(image, '.data')
	assert data_off > 0
	data_rva := pe_test_u32(image, data_off + 12)
	data_raw_size := pe_test_u32(image, data_off + 16)
	assert slot_target >= data_rva
	assert slot_target < data_rva + data_raw_size
	slot_off := pe_test_rva_to_file_off(image, slot_target)
	assert pe_test_u32(image, slot_off) == 0
}

fn test_pe_linker_resolves_malloc_with_internal_nonzeroing_heap_thunk() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	malloc_sym := obj.add_undefined('malloc')
	obj.add_text_reloc(1, malloc_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	names := pe_test_import_names(image)
	dll_names := pe_test_import_dll_names(image)
	assert names == ['ExitProcess', 'GetProcessHeap', 'HeapAlloc']
	assert dll_names == ['kernel32.dll']

	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	text_raw_size := int(pe_test_u32(image, text_off + 16))
	entry_stub_len := linker.entry_stub_size()
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)

	mut first_import_thunk_file_off := -1
	for off in text_raw + entry_stub_len + obj.text_data.len .. text_raw + text_raw_size - 1 {
		if image[off] == 0xff && image[off + 1] == 0x25 {
			first_import_thunk_file_off = off
			break
		}
	}
	assert first_import_thunk_file_off > 0
	first_import_thunk_rva := text_rva + u32(first_import_thunk_file_off - text_raw)

	malloc_target := pe_test_text_rel32_target(image, text_rva, text_raw, entry_stub_len + 1)
	assert malloc_target >= runtime_start_rva
	assert malloc_target < first_import_thunk_rva

	malloc_off := pe_test_rva_to_file_off(image, malloc_target)
	assert malloc_off > 0
	mut has_shadow_space_frame := false
	mut has_size_saved_from_rcx := false
	mut has_heap_zero_memory_flag := false
	mut has_plain_heap_flags := false
	mut has_rdx_alignment_dependency := false
	mut has_aligned_allocation_padding := false
	mut has_aligned_cookie_store := false
	mut has_aligned_return_pointer := false
	runtime_scan_end := first_import_thunk_file_off
	for off in malloc_off .. runtime_scan_end - 4 {
		if image[off..off + 4] == [u8(0x48), 0x83, 0xec, 0x28] {
			has_shadow_space_frame = true
		}
		if image[off..off + 5] == [u8(0x48), 0x89, 0x4c, 0x24, 0x20] {
			has_size_saved_from_rcx = true
		}
		if image[off..off + 5] == [u8(0xba), 0x08, 0, 0, 0] {
			has_heap_zero_memory_flag = true
		}
		if image[off..off + 2] == [u8(0x31), 0xd2] {
			has_plain_heap_flags = true
		}
		if image[off..off + 4] == [u8(0x48), 0x83, 0xfa, 0x10] {
			has_rdx_alignment_dependency = true
		}
		if image[off..off + 4] == [u8(0x49), 0x83, 0xc0, 0x18] {
			has_aligned_allocation_padding = true
		}
		if image[off..off + 3] == [u8(0x4c), 0x89, 0xd8] {
			has_aligned_return_pointer = true
		}
	}
	for off in malloc_off .. runtime_scan_end - 14 {
		if image[off..off + 15] == [
			u8(0x49),
			0x89,
			0xc3,
			0x49,
			0x83,
			0xc3,
			0x17,
			0x49,
			0x83,
			0xe3,
			0xf0,
			0x49,
			0x89,
			0x43,
			0xf8,
		] {
			has_aligned_cookie_store = true
		}
	}
	assert has_shadow_space_frame
	assert has_size_saved_from_rcx
	assert !has_heap_zero_memory_flag
	assert has_plain_heap_flags
	assert !has_rdx_alignment_dependency
	assert has_aligned_allocation_padding
	assert has_aligned_cookie_store
	assert has_aligned_return_pointer
}

fn test_pe_linker_resolves_malloc_and_free_with_compatible_heap_cookie() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xe8, 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 10, true, 1)
	malloc_sym := obj.add_undefined('malloc')
	free_sym := obj.add_undefined('free')
	obj.add_text_reloc(1, malloc_sym, coff_image_rel_amd64_rel32)
	obj.add_text_reloc(6, free_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	names := pe_test_import_names(image)
	dll_names := pe_test_import_dll_names(image)
	assert names == ['ExitProcess', 'GetProcessHeap', 'HeapAlloc', 'HeapFree']
	assert dll_names == ['kernel32.dll']
	assert 'HeapReAlloc' !in names
	assert 'ucrtbase.dll' !in dll_names
	assert 'msvcrt.dll' !in dll_names

	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	text_raw_size := int(pe_test_u32(image, text_off + 16))
	entry_stub_len := linker.entry_stub_size()
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)

	mut first_import_thunk_file_off := -1
	for off in text_raw + entry_stub_len + obj.text_data.len .. text_raw + text_raw_size - 1 {
		if image[off] == 0xff && image[off + 1] == 0x25 {
			first_import_thunk_file_off = off
			break
		}
	}
	assert first_import_thunk_file_off > 0
	first_import_thunk_rva := text_rva + u32(first_import_thunk_file_off - text_raw)

	malloc_target := pe_test_text_rel32_target(image, text_rva, text_raw, entry_stub_len + 1)
	free_target := pe_test_text_rel32_target(image, text_rva, text_raw, entry_stub_len + 6)
	assert malloc_target >= runtime_start_rva
	assert malloc_target < first_import_thunk_rva
	assert free_target >= runtime_start_rva
	assert free_target < first_import_thunk_rva

	malloc_off := pe_test_rva_to_file_off(image, malloc_target)
	free_off := pe_test_rva_to_file_off(image, free_target)
	assert malloc_off > 0
	assert free_off > 0
	mut malloc_stores_raw_cookie := false
	for off in malloc_off .. first_import_thunk_file_off - 14 {
		if image[off..off + 15] == [
			u8(0x49),
			0x89,
			0xc3,
			0x49,
			0x83,
			0xc3,
			0x17,
			0x49,
			0x83,
			0xe3,
			0xf0,
			0x49,
			0x89,
			0x43,
			0xf8,
		] {
			malloc_stores_raw_cookie = true
		}
	}
	assert malloc_stores_raw_cookie
	mut free_reads_raw_cookie := false
	for off in free_off .. first_import_thunk_file_off - 3 {
		if image[off..off + 4] == [u8(0x48), 0x8b, 0x41, 0xf8] {
			free_reads_raw_cookie = true
		}
	}
	assert free_reads_raw_cookie
}

fn test_pe_linker_resolves_calloc_with_internal_zeroed_heap_thunk() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	calloc_sym := obj.add_undefined('calloc')
	obj.add_text_reloc(1, calloc_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	text_raw_size := int(pe_test_u32(image, text_off + 16))
	entry_stub_len := linker.entry_stub_size()
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)

	mut first_import_thunk_file_off := -1
	for off in text_raw + entry_stub_len + obj.text_data.len .. text_raw + text_raw_size - 1 {
		if image[off] == 0xff && image[off + 1] == 0x25 {
			first_import_thunk_file_off = off
			break
		}
	}
	assert first_import_thunk_file_off > 0
	first_import_thunk_rva := text_rva + u32(first_import_thunk_file_off - text_raw)

	calloc_field_off := text_raw + entry_stub_len + 1
	calloc_field_rva := text_rva + u32(entry_stub_len + 1)
	calloc_target := u32(i32(calloc_field_rva + 4) + pe_test_i32(image, calloc_field_off))
	assert calloc_target >= runtime_start_rva
	assert calloc_target < first_import_thunk_rva

	calloc_off := pe_test_rva_to_file_off(image, calloc_target)
	assert calloc_off > 0
	assert image[calloc_off..calloc_off + 3] == [u8(0x48), 0x89, 0xc8] // mov rax, rcx
	assert image[calloc_off + 3..calloc_off + 6] == [u8(0x48), 0xf7, 0xe2] // mul rdx
	mut has_heap_zero_memory_flag := false
	mut has_aligned_allocation_padding := false
	mut has_aligned_cookie_store := false
	mut has_aligned_return_pointer := false
	runtime_scan_end := first_import_thunk_file_off - 16
	for off in calloc_off .. runtime_scan_end {
		if image[off..off + 5] == [u8(0xba), 0x08, 0, 0, 0] {
			has_heap_zero_memory_flag = true
		}
		if image[off..off + 4] == [u8(0x49), 0x83, 0xc0, 0x18] {
			has_aligned_allocation_padding = true
		}
		if image[off..off + 15] == [
			u8(0x49),
			0x89,
			0xc3,
			0x49,
			0x83,
			0xc3,
			0x17,
			0x49,
			0x83,
			0xe3,
			0xf0,
			0x49,
			0x89,
			0x43,
			0xf8,
		] {
			has_aligned_cookie_store = true
		}
		if image[off..off + 3] == [u8(0x4c), 0x89, 0xd8] {
			has_aligned_return_pointer = true
		}
	}
	assert has_heap_zero_memory_flag
	assert has_aligned_allocation_padding
	assert has_aligned_cookie_store
	assert has_aligned_return_pointer
}

fn test_pe_linker_resolves_aligned_malloc_checks_size_overflow_before_heap_alloc() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	malloc_sym := obj.add_undefined('_aligned_malloc')
	obj.add_text_reloc(1, malloc_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	text_raw_size := int(pe_test_u32(image, text_off + 16))
	entry_stub_len := linker.entry_stub_size()
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)

	mut first_import_thunk_file_off := -1
	for off in text_raw + entry_stub_len + obj.text_data.len .. text_raw + text_raw_size - 1 {
		if image[off] == 0xff && image[off + 1] == 0x25 {
			first_import_thunk_file_off = off
			break
		}
	}
	assert first_import_thunk_file_off > 0
	first_import_thunk_rva := text_rva + u32(first_import_thunk_file_off - text_raw)

	malloc_field_off := text_raw + entry_stub_len + 1
	malloc_field_rva := text_rva + u32(entry_stub_len + 1)
	malloc_target := u32(i32(malloc_field_rva + 4) + pe_test_i32(image, malloc_field_off))
	assert malloc_target >= runtime_start_rva
	assert malloc_target < first_import_thunk_rva

	malloc_off := pe_test_rva_to_file_off(image, malloc_target)
	assert malloc_off > 0
	mut size_overflow_check_off := -1
	mut padding_overflow_check_off := -1
	mut heap_alloc_call_off := -1
	mut alloc_failed_check_off := -1
	runtime_scan_end := first_import_thunk_file_off - 16
	for off in malloc_off .. runtime_scan_end {
		if image[off..off + 4] == [u8(0x4d), 0x01, 0xc8, 0x72] {
			size_overflow_check_off = off + 3
		}
		if image[off..off + 5] == [u8(0x49), 0x83, 0xc0, 0x08, 0x72] {
			padding_overflow_check_off = off + 4
			heap_alloc_call_off = off + 6
		}
		if image[off..off + 4] == [u8(0x48), 0x85, 0xc0, 0x74] {
			alloc_failed_check_off = off + 3
		}
	}
	assert size_overflow_check_off >= 0
	assert padding_overflow_check_off >= 0
	assert heap_alloc_call_off >= 0
	assert alloc_failed_check_off >= 0
	assert image[heap_alloc_call_off] == 0xe8
	assert size_overflow_check_off < padding_overflow_check_off
	assert padding_overflow_check_off < heap_alloc_call_off
	assert heap_alloc_call_off < alloc_failed_check_off
	size_overflow_target := pe_test_rel8_target(size_overflow_check_off, image[
		size_overflow_check_off + 1])
	padding_overflow_target := pe_test_rel8_target(padding_overflow_check_off, image[
		padding_overflow_check_off + 1])
	alloc_failed_target := pe_test_rel8_target(alloc_failed_check_off, image[
		alloc_failed_check_off + 1])
	assert size_overflow_target == padding_overflow_target
	assert size_overflow_target == alloc_failed_target
	assert alloc_failed_check_off < alloc_failed_target
	assert alloc_failed_target < first_import_thunk_file_off
}

fn test_pe_linker_resolves_strlen_with_internal_runtime_thunk() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	strlen_sym := obj.add_undefined('strlen')
	obj.add_text_reloc(1, strlen_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	text_raw_size := int(pe_test_u32(image, text_off + 16))
	entry_stub_len := linker.entry_stub_size()
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)

	mut first_import_thunk_file_off := -1
	for off in text_raw + entry_stub_len + obj.text_data.len .. text_raw + text_raw_size - 1 {
		if image[off] == 0xff && image[off + 1] == 0x25 {
			first_import_thunk_file_off = off
			break
		}
	}
	assert first_import_thunk_file_off > 0
	first_import_thunk_rva := text_rva + u32(first_import_thunk_file_off - text_raw)

	strlen_field_off := text_raw + entry_stub_len + 1
	strlen_field_rva := text_rva + u32(entry_stub_len + 1)
	strlen_target := u32(i32(strlen_field_rva + 4) + pe_test_i32(image, strlen_field_off))
	assert strlen_target >= runtime_start_rva
	assert strlen_target < first_import_thunk_rva

	strlen_off := pe_test_rva_to_file_off(image, strlen_target)
	assert strlen_off > 0
	assert image[strlen_off..strlen_off + 3] == [u8(0x48), 0x89, 0xc8] // mov rax, rcx
	assert image[strlen_off + 3..strlen_off + 6] == [u8(0x80), 0x38, 0x00] // cmp byte ptr [rax], 0
}

fn test_pe_linker_resolves_wcslen_with_internal_runtime_thunk() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	wcslen_sym := obj.add_undefined('wcslen')
	obj.add_text_reloc(1, wcslen_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	text_raw_size := int(pe_test_u32(image, text_off + 16))
	entry_stub_len := linker.entry_stub_size()
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)

	mut first_import_thunk_file_off := -1
	for off in text_raw + entry_stub_len + obj.text_data.len .. text_raw + text_raw_size - 1 {
		if image[off] == 0xff && image[off + 1] == 0x25 {
			first_import_thunk_file_off = off
			break
		}
	}
	assert first_import_thunk_file_off > 0
	first_import_thunk_rva := text_rva + u32(first_import_thunk_file_off - text_raw)

	wcslen_field_off := text_raw + entry_stub_len + 1
	wcslen_field_rva := text_rva + u32(entry_stub_len + 1)
	wcslen_target := u32(i32(wcslen_field_rva + 4) + pe_test_i32(image, wcslen_field_off))
	assert wcslen_target >= runtime_start_rva
	assert wcslen_target < first_import_thunk_rva

	wcslen_off := pe_test_rva_to_file_off(image, wcslen_target)
	assert wcslen_off > 0
	assert image[wcslen_off..wcslen_off + 3] == [u8(0x48), 0x89, 0xc8] // mov rax, rcx
	assert image[wcslen_off + 3..wcslen_off + 7] == [u8(0x66), 0x83, 0x38, 0x00] // cmp word ptr [rax], 0
	assert image[wcslen_off + 15..wcslen_off + 18] == [u8(0x48), 0x29, 0xc8] // sub rax, rcx
	assert image[wcslen_off + 18..wcslen_off + 21] == [u8(0x48), 0xd1, 0xe8] // shr rax, 1
}

fn test_pe_linker_resolves_wgetcwd_with_kernel32_runtime_thunk() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	wgetcwd_sym := obj.add_undefined('_wgetcwd')
	obj.add_text_reloc(1, wgetcwd_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	text_raw_size := int(pe_test_u32(image, text_off + 16))
	entry_stub_len := linker.entry_stub_size()
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)

	mut first_import_thunk_file_off := -1
	for off in text_raw + entry_stub_len + obj.text_data.len .. text_raw + text_raw_size - 1 {
		if image[off] == 0xff && image[off + 1] == 0x25 {
			first_import_thunk_file_off = off
			break
		}
	}
	assert first_import_thunk_file_off > 0
	first_import_thunk_rva := text_rva + u32(first_import_thunk_file_off - text_raw)

	wgetcwd_field_off := text_raw + entry_stub_len + 1
	wgetcwd_field_rva := text_rva + u32(entry_stub_len + 1)
	wgetcwd_target := u32(i32(wgetcwd_field_rva + 4) + pe_test_i32(image, wgetcwd_field_off))
	assert wgetcwd_target >= runtime_start_rva
	assert wgetcwd_target < first_import_thunk_rva

	wgetcwd_off := pe_test_rva_to_file_off(image, wgetcwd_target)
	assert wgetcwd_off > 0
	assert image[wgetcwd_off..wgetcwd_off + 4] == [u8(0x48), 0x83, 0xec, 0x38] // sub rsp, 56
	assert image[wgetcwd_off + 13..wgetcwd_off + 15] == [u8(0x89), 0xd1] // mov ecx, edx
	assert image[wgetcwd_off + 15..wgetcwd_off + 20] == [
		u8(0x48),
		0x8b,
		0x54,
		0x24,
		0x20,
	] // mov rdx, [rsp+32]
}

fn test_pe_linker_resolves_wgetenv_with_kernel32_runtime_thunk() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	wgetenv_sym := obj.add_undefined('_wgetenv')
	obj.add_text_reloc(1, wgetenv_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	text_raw_size := int(pe_test_u32(image, text_off + 16))
	entry_stub_len := linker.entry_stub_size()
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)

	mut first_import_thunk_file_off := -1
	for off in text_raw + entry_stub_len + obj.text_data.len .. text_raw + text_raw_size - 1 {
		if image[off] == 0xff && image[off + 1] == 0x25 {
			first_import_thunk_file_off = off
			break
		}
	}
	assert first_import_thunk_file_off > 0
	first_import_thunk_rva := text_rva + u32(first_import_thunk_file_off - text_raw)

	wgetenv_field_off := text_raw + entry_stub_len + 1
	wgetenv_field_rva := text_rva + u32(entry_stub_len + 1)
	wgetenv_target := u32(i32(wgetenv_field_rva + 4) + pe_test_i32(image, wgetenv_field_off))
	assert wgetenv_target >= runtime_start_rva
	assert wgetenv_target < first_import_thunk_rva

	wgetenv_off := pe_test_rva_to_file_off(image, wgetenv_target)
	assert wgetenv_off > 0
	assert image[wgetenv_off..wgetenv_off + 4] == [u8(0x48), 0x83, 0xec, 0x28] // sub rsp, 40
	data_off := pe_test_section_header(image, '.data')
	assert data_off > 0
	data_rva := pe_test_u32(image, data_off + 12)
	data_size := pe_test_u32(image, data_off + 8)
	assert data_size >= u32(pe_wgetenv_buffer_bytes)

	runtime_text_size := first_import_thunk_file_off - (text_raw + entry_stub_len +
		obj.text_data.len)
	import_offsets := linker.import_thunk_offsets(runtime_text_size)
	names := pe_test_import_names(image)
	assert names == ['ExitProcess', 'GetEnvironmentVariableW']
	getenv_thunk := import_offsets[pe_kernel32_import_key('GetEnvironmentVariableW')] or {
		panic('missing GetEnvironmentVariableW import thunk')
	}
	getenv_thunk_rva := text_rva + getenv_thunk

	mut has_buffer_arg_lea := false
	mut has_buffer_return_lea := false
	mut has_wgetenv_buffer_size := false
	mut calls_getenv := false
	runtime_scan_end := first_import_thunk_file_off - 8
	for off in wgetenv_off .. runtime_scan_end {
		if image[off..off + 3] == [u8(0x48), 0x8d, 0x15] {
			field_rva := text_rva + u32(off - text_raw + 3)
			target := u32(i32(field_rva + 4) + pe_test_i32(image, off + 3))
			if target >= data_rva && target < data_rva + data_size {
				has_buffer_arg_lea = true
			}
		}
		if image[off..off + 3] == [u8(0x48), 0x8d, 0x05] {
			field_rva := text_rva + u32(off - text_raw + 3)
			target := u32(i32(field_rva + 4) + pe_test_i32(image, off + 3))
			if target >= data_rva && target < data_rva + data_size {
				has_buffer_return_lea = true
			}
		}
		if image[off..off + 6] == [u8(0x41), 0xb8, 0x00, 0x80, 0x00, 0x00] {
			has_wgetenv_buffer_size = true
		}
		if image[off] == u8(0xe8) {
			field_rva := text_rva + u32(off - text_raw + 1)
			target := u32(i32(field_rva + 4) + pe_test_i32(image, off + 1))
			if target == getenv_thunk_rva {
				calls_getenv = true
			}
		}
	}
	assert has_buffer_arg_lea
	assert has_buffer_return_lea
	assert has_wgetenv_buffer_size
	assert calls_getenv
	assert 'GetProcessHeap' !in names
	assert 'HeapAlloc' !in names
	assert 'HeapFree' !in names
}

fn test_pe_linker_resolves_aligned_realloc_with_internal_heap_thunk() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	realloc_sym := obj.add_undefined('_aligned_realloc')
	obj.add_text_reloc(1, realloc_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	text_raw_size := int(pe_test_u32(image, text_off + 16))
	entry_stub_len := linker.entry_stub_size()
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)

	mut first_import_thunk_file_off := -1
	for off in text_raw + entry_stub_len + obj.text_data.len .. text_raw + text_raw_size - 1 {
		if image[off] == 0xff && image[off + 1] == 0x25 {
			first_import_thunk_file_off = off
			break
		}
	}
	assert first_import_thunk_file_off > 0
	first_import_thunk_rva := text_rva + u32(first_import_thunk_file_off - text_raw)

	realloc_field_off := text_raw + entry_stub_len + 1
	realloc_field_rva := text_rva + u32(entry_stub_len + 1)
	realloc_target := u32(i32(realloc_field_rva + 4) + pe_test_i32(image, realloc_field_off))
	assert realloc_target >= runtime_start_rva
	assert realloc_target < first_import_thunk_rva

	realloc_off := pe_test_rva_to_file_off(image, realloc_target)
	assert realloc_off > 0
	assert image[realloc_off..realloc_off + 4] == [u8(0x49), 0x83, 0xf8, 0x10] // cmp r8, 16
	assert image[realloc_off + 9..realloc_off + 12] == [u8(0x48), 0x85, 0xc9] // test rcx, rcx
}

fn test_pe_linker_resolves_free_with_internal_heap_thunk() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	free_sym := obj.add_undefined('free')
	obj.add_text_reloc(1, free_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	text_raw_size := int(pe_test_u32(image, text_off + 16))
	entry_stub_len := linker.entry_stub_size()
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)

	mut first_import_thunk_file_off := -1
	for off in text_raw + entry_stub_len + obj.text_data.len .. text_raw + text_raw_size - 1 {
		if image[off] == 0xff && image[off + 1] == 0x25 {
			first_import_thunk_file_off = off
			break
		}
	}
	assert first_import_thunk_file_off > 0
	first_import_thunk_rva := text_rva + u32(first_import_thunk_file_off - text_raw)

	free_field_off := text_raw + entry_stub_len + 1
	free_field_rva := text_rva + u32(entry_stub_len + 1)
	free_target := u32(i32(free_field_rva + 4) + pe_test_i32(image, free_field_off))
	assert free_target >= runtime_start_rva
	assert free_target < first_import_thunk_rva

	free_off := pe_test_rva_to_file_off(image, free_target)
	assert free_off > 0
	assert image[free_off..free_off + 4] == [u8(0x48), 0x85, 0xc9, 0x74] // test rcx, rcx; je
	assert image[free_off + 5..free_off + 9] == [u8(0x48), 0x83, 0xec, 0x28] // sub rsp, 40
	assert image[free_off + 9..free_off + 14] == [
		u8(0x48),
		0x8b,
		0x41,
		0xf8,
		0x48,
	] // mov rax, [rcx-8]; ...
}

fn test_pe_linker_resolves_array_rune_string_with_internal_runtime_thunk() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	array_rune_string_sym := obj.add_undefined('builtin__Array_rune__string')
	obj.add_text_reloc(1, array_rune_string_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	text_raw_size := int(pe_test_u32(image, text_off + 16))
	entry_stub_len := linker.entry_stub_size()
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)

	mut first_import_thunk_file_off := -1
	for off in text_raw + entry_stub_len + obj.text_data.len .. text_raw + text_raw_size - 1 {
		if image[off] == 0xff && image[off + 1] == 0x25 {
			first_import_thunk_file_off = off
			break
		}
	}
	assert first_import_thunk_file_off > 0
	first_import_thunk_rva := text_rva + u32(first_import_thunk_file_off - text_raw)

	array_rune_string_field_off := text_raw + entry_stub_len + 1
	array_rune_string_field_rva := text_rva + u32(entry_stub_len + 1)
	array_rune_string_target := u32(i32(array_rune_string_field_rva + 4) +
		pe_test_i32(image, array_rune_string_field_off))
	assert array_rune_string_target >= runtime_start_rva
	assert array_rune_string_target < first_import_thunk_rva

	array_rune_string_off := pe_test_rva_to_file_off(image, array_rune_string_target)
	assert array_rune_string_off > 0
	assert image[array_rune_string_off..array_rune_string_off + 4] == [
		u8(0x48),
		0x83,
		0xec,
		0x58,
	] // sub rsp, 88
	assert image[array_rune_string_off + 4..array_rune_string_off + 9] == [
		u8(0x48),
		0x89,
		0x4c,
		0x24,
		0x20,
	] // mov [rsp+32], rcx
	mut has_array_len_load := false
	mut has_array_data_load := false
	mut has_array_offset_load := false
	mut has_array_data_offset_add := false
	mut has_array_cap_load_as_len := false
	mut has_aligned_allocation_padding := false
	mut has_aligned_string_cookie_store := false
	mut has_raw_heap_pointer_saved_as_string := false
	mut has_string_len_store := false
	mut has_string_lit_store := false
	mut has_out_of_bounds_string_store := false
	runtime_scan_end := first_import_thunk_file_off - 24
	for off in array_rune_string_off .. runtime_scan_end {
		if image[off..off + 4] == [u8(0x48), 0x63, 0x42, 0x0c] {
			has_array_len_load = true
		}
		if image[off..off + 4] == [u8(0x48), 0x63, 0x42, 0x10] {
			has_array_cap_load_as_len = true
		}
		if image[off..off + 3] == [u8(0x48), 0x8b, 0x02] {
			has_array_data_load = true
		}
		if image[off..off + 4] == [u8(0x4c), 0x63, 0x52, 0x08] {
			has_array_offset_load = true
		}
		if image[off..off + 3] == [u8(0x4c), 0x01, 0xd0] {
			has_array_data_offset_add = true
		}
		if image[off..off + 4] == [u8(0x49), 0x83, 0xc0, 0x18] {
			has_aligned_allocation_padding = true
		}
		if image[off..off + 20] == [
			u8(0x49),
			0x89,
			0xc3,
			0x49,
			0x83,
			0xc3,
			0x17,
			0x49,
			0x83,
			0xe3,
			0xf0,
			0x49,
			0x89,
			0x43,
			0xf8,
			0x4c,
			0x89,
			0x5c,
			0x24,
			0x40,
		] {
			has_aligned_string_cookie_store = true
		}
		if image[off..off + 8] == [u8(0x48), 0x89, 0x44, 0x24, 0x40, 0x49, 0x89, 0xc3] {
			has_raw_heap_pointer_saved_as_string = true
		}
		if image[off..off + 3] == [u8(0x89), 0x51, 0x08] {
			has_string_len_store = true
		}
		if image[off..off + 7] == [u8(0xc7), 0x41, 0x0c, 0, 0, 0, 0] {
			has_string_lit_store = true
		}
		if image[off..off + 8] == [u8(0x48), 0xc7, 0x41, 0x10, 0, 0, 0, 0] {
			has_out_of_bounds_string_store = true
		}
	}
	assert has_array_len_load
	assert !has_array_cap_load_as_len
	assert has_array_data_load
	assert has_array_offset_load
	assert has_array_data_offset_add
	assert has_aligned_allocation_padding
	assert has_aligned_string_cookie_store
	assert !has_raw_heap_pointer_saved_as_string
	assert has_string_len_store
	assert has_string_lit_store
	assert !has_out_of_bounds_string_store
}

fn test_pe_linker_resolves_new_array_from_c_array_noscan_with_internal_heap_thunk() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	new_array_sym := obj.add_undefined('builtin__new_array_from_c_array_noscan')
	obj.add_text_reloc(1, new_array_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	text_raw_size := int(pe_test_u32(image, text_off + 16))
	entry_stub_len := linker.entry_stub_size()
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)

	mut first_import_thunk_file_off := -1
	for off in text_raw + entry_stub_len + obj.text_data.len .. text_raw + text_raw_size - 1 {
		if image[off] == 0xff && image[off + 1] == 0x25 {
			first_import_thunk_file_off = off
			break
		}
	}
	assert first_import_thunk_file_off > 0
	first_import_thunk_rva := text_rva + u32(first_import_thunk_file_off - text_raw)

	new_array_field_off := text_raw + entry_stub_len + 1
	new_array_field_rva := text_rva + u32(entry_stub_len + 1)
	new_array_target := u32(i32(new_array_field_rva + 4) + pe_test_i32(image, new_array_field_off))
	assert new_array_target >= runtime_start_rva
	assert new_array_target < first_import_thunk_rva

	new_array_off := pe_test_rva_to_file_off(image, new_array_target)
	assert new_array_off > 0
	assert image[new_array_off..new_array_off + 4] == [u8(0x48), 0x83, 0xec, 0x58] // sub rsp, 88
	mut has_stack_c_array_arg_load := false
	mut has_heap_zero_memory_flag := false
	mut has_managed_array_allocation_padding_size := false
	mut has_header_align_rounding := false
	mut has_header_align_mask := false
	mut has_cookie_before_array_header := false
	mut has_array_header_false_store := false
	mut has_data_after_array_header_store := false
	mut has_copy_to_data_after_array_header := false
	mut has_cookie_over_array_header := false
	mut has_extra_header_skip_after_cookie := false
	mut has_naive_heap_plus_header_data := false
	mut has_noscan_flags_store := false
	mut has_element_size_store := false
	mut has_byte_copy_loop := false
	runtime_scan_end := first_import_thunk_file_off - 16
	for off in new_array_off .. runtime_scan_end {
		if image[off..off + 8] == [u8(0x48), 0x8b, 0x84, 0x24, 0x80, 0, 0, 0] {
			has_stack_c_array_arg_load = true
		}
		if image[off..off + 5] == [u8(0xba), 0x08, 0, 0, 0] {
			has_heap_zero_memory_flag = true
		}
		if image[off..off + 4] == [u8(0x49), 0x83, 0xc0, 0x20] {
			has_managed_array_allocation_padding_size = true
		}
		if image[off..off + 4] == [u8(0x49), 0x83, 0xc3, 0x17] {
			has_header_align_rounding = true
		}
		if image[off..off + 4] == [u8(0x49), 0x83, 0xe3, 0xf0] {
			has_header_align_mask = true
		}
		if image[off..off + 20] == [
			u8(0x49),
			0x89,
			0x43,
			0xf8,
			0x41,
			0xc6,
			0x03,
			0x00,
			0x48,
			0x8b,
			0x4c,
			0x24,
			0x20,
			0x49,
			0x8d,
			0x43,
			0x08,
			0x48,
			0x89,
			0x01,
		] {
			has_cookie_before_array_header = true
			has_array_header_false_store = true
			has_data_after_array_header_store = true
		}
		if image[off..off + 3] == [u8(0x49), 0x89, 0x03] {
			has_cookie_over_array_header = true
		}
		if image[off..off + 4] == [u8(0x4d), 0x8d, 0x43, 0x08] {
			has_copy_to_data_after_array_header = true
		}
		if image[off..off + 4] == [u8(0x49), 0x83, 0xc3, 0x08] {
			has_extra_header_skip_after_cookie = true
		}
		if image[off..off + 4] == [u8(0x4c), 0x8d, 0x58, 0x08] {
			has_naive_heap_plus_header_data = true
		}
		if image[off..off + 7] == [u8(0xc7), 0x41, 0x14, 0x30, 0, 0, 0] {
			has_noscan_flags_store = true
		}
		if image[off..off + 3] == [u8(0x89), 0x41, 0x18] {
			has_element_size_store = true
		}
		if image[off..off + 6] == [u8(0x41), 0x8a, 0x12, 0x41, 0x88, 0x10] {
			has_byte_copy_loop = true
		}
	}
	assert has_stack_c_array_arg_load
	assert has_heap_zero_memory_flag
	assert has_managed_array_allocation_padding_size
	assert has_header_align_rounding
	assert has_header_align_mask
	assert has_cookie_before_array_header
	assert has_array_header_false_store
	assert has_data_after_array_header_store
	assert has_copy_to_data_after_array_header
	assert !has_cookie_over_array_header
	assert !has_extra_header_skip_after_cookie
	assert !has_naive_heap_plus_header_data
	assert has_noscan_flags_store
	assert has_element_size_store
	assert has_byte_copy_loop
}

fn test_pe_linker_resolves_new_array_noscan_with_internal_heap_thunk() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 5, true, 1)
	new_array_sym := obj.add_undefined('builtin____new_array_noscan')
	obj.add_text_reloc(1, new_array_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	image := linker.image() or { panic(err) }
	text_off := pe_test_section_header(image, '.text')
	text_rva := pe_test_u32(image, text_off + 12)
	text_raw := int(pe_test_u32(image, text_off + 20))
	text_raw_size := int(pe_test_u32(image, text_off + 16))
	entry_stub_len := linker.entry_stub_size()
	runtime_start_rva := text_rva + u32(entry_stub_len + obj.text_data.len)

	mut first_import_thunk_file_off := -1
	for off in text_raw + entry_stub_len + obj.text_data.len .. text_raw + text_raw_size - 1 {
		if image[off] == 0xff && image[off + 1] == 0x25 {
			first_import_thunk_file_off = off
			break
		}
	}
	assert first_import_thunk_file_off > 0
	first_import_thunk_rva := text_rva + u32(first_import_thunk_file_off - text_raw)

	new_array_field_off := text_raw + entry_stub_len + 1
	new_array_field_rva := text_rva + u32(entry_stub_len + 1)
	new_array_target := u32(i32(new_array_field_rva + 4) + pe_test_i32(image, new_array_field_off))
	assert new_array_target >= runtime_start_rva
	assert new_array_target < first_import_thunk_rva

	new_array_off := pe_test_rva_to_file_off(image, new_array_target)
	assert new_array_off > 0
	assert image[new_array_off..new_array_off + 4] == [u8(0x48), 0x83, 0xec, 0x58] // sub rsp, 88
	names := pe_test_import_names(image)
	assert 'GetProcessHeap' in names
	assert 'HeapAlloc' in names
}

fn test_pe_linker_rejects_unsupported_external_symbols() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 0, true, 1)
	unknown_sym := obj.add_undefined('v_missing_runtime_symbol')
	obj.add_text_reloc(1, unknown_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	if _ := linker.image() {
		assert false
	} else {
		assert err.msg().starts_with('x64: unsupported backend feature: ')
		assert err.msg().contains('cannot resolve external symbol `v_missing_runtime_symbol` yet')
		assert err.msg().contains('.text relocation offset 0x00000001')
		assert err.msg().contains('near `main`+0x00000001')
	}
}

fn test_pe_linker_rejects_crt_stdio_symbols_with_minimal_runtime_message() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 0, true, 1)
	stderr_sym := obj.add_undefined('stderr')
	obj.add_text_reloc(1, stderr_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	if _ := linker.image() {
		assert false
	} else {
		assert err.msg().starts_with('x64: unsupported backend feature: ')
		assert err.msg().contains('cannot resolve C stdio/file-descriptor symbol `stderr`')
		assert err.msg().contains('Windows x64 native backend uses Kernel32 handles')
		assert err.msg().contains('Kernel32 handles')
		assert err.msg().contains('C FILE/stdio calls')
		assert !err.msg().contains('reachable helper')
		assert !err.msg().contains('stdout/stderr path')
		assert !err.msg().contains('C FILE streams')
		assert err.msg().contains('near `main`+0x00000001')
	}
}

fn test_pe_linker_rejects_common_crt_stdio_functions_with_minimal_runtime_message() {
	for symbol_name in ['setvbuf', 'printf', 'snprintf', 'puts', 'fputs', 'fopen'] {
		mut obj := CoffObject.new()
		obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
		obj.add_symbol('main', 0, true, 1)
		stdio_sym := obj.add_undefined(symbol_name)
		obj.add_text_reloc(1, stdio_sym, coff_image_rel_amd64_rel32)

		mut linker := PeLinker.new(obj)
		if _ := linker.image() {
			assert false
		} else {
			assert err.msg().starts_with('x64: unsupported backend feature: ')
			assert err.msg().contains('cannot resolve C stdio/file-descriptor symbol `${symbol_name}`')
			assert err.msg().contains('Windows x64 native backend uses Kernel32 handles')
			assert err.msg().contains('Kernel32 handles')
			assert err.msg().contains('C FILE/stdio calls')
			assert !err.msg().contains('reachable helper')
			assert !err.msg().contains('stdout/stderr path')
			assert !err.msg().contains('C FILE streams')
			assert err.msg().contains('near `main`+0x00000001')
		}
	}
}

fn test_pe_linker_rejects_missing_v_runtime_helper_with_targeted_message() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 0, true, 1)
	helper_sym := obj.add_undefined('builtin__Map_string_int__keys')
	obj.add_text_reloc(1, helper_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	if _ := linker.image() {
		assert false
	} else {
		assert err.msg().starts_with('x64: unsupported backend feature: ')
		assert err.msg().contains('cannot resolve V runtime helper `builtin__Map_string_int__keys`')
		assert err.msg().contains('native x64 backend does not implement this feature for this target yet')
		assert !err.msg().contains('not imported')
		assert !err.msg().contains('must be compiled')
		assert !err.msg().contains('lowered before linking')
		assert err.msg().contains('near `main`+0x00000001')
	}
}

fn test_pe_linker_rejects_relocation_to_omitted_rdata_section() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 0, true, 1)
	rodata_sym := obj.add_symbol('missing_rodata', 0, false, 2)
	obj.add_text_reloc(1, rodata_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	if _ := linker.image() {
		assert false
	} else {
		assert err.msg().contains('relocation references .rdata')
		assert err.msg().contains('no .rdata section was emitted')
	}
}

fn test_pe_linker_rejects_relocation_to_omitted_data_section() {
	mut obj := CoffObject.new()
	obj.text_data << [u8(0xe8), 0, 0, 0, 0, 0xc3]
	obj.add_symbol('main', 0, true, 1)
	data_sym := obj.add_symbol('missing_data', 0, false, 3)
	obj.add_text_reloc(1, data_sym, coff_image_rel_amd64_rel32)

	mut linker := PeLinker.new(obj)
	if _ := linker.image() {
		assert false
	} else {
		assert err.msg().contains('relocation references .data')
		assert err.msg().contains('no .data section was emitted')
	}
}

fn test_x64_gen_link_executable_writes_pe_image() {
	path := os.join_path(os.temp_dir(), 'v_x64_pe_link_api_test_${rand.ulid()}.exe')
	os.rm(path) or {}
	defer {
		os.rm(path) or {}
	}

	mut mod := mir.Module{}
	mut gen := Gen.new_with_format_and_abi(&mod, .coff, .windows)
	gen.coff.text_data << u8(0xc3)
	gen.coff.add_symbol('main', 0, true, 1)

	gen.link_executable(path) or { panic(err) }
	assert os.is_file(path)
	assert os.file_size(path) > 0
	image := os.read_bytes(path) or { panic(err) }

	assert image[0] == `M`
	assert image[1] == `Z`
	pe_off := int(pe_test_u32(image, 0x3c))
	assert pe_test_u32(image, pe_off) == pe_signature
	assert pe_test_u16(image, pe_off + 4) == coff_image_file_machine_amd64
}

fn test_pe_linker_write_postcondition_rejects_missing_or_empty_output() {
	missing_path := os.join_path(os.temp_dir(),
		'v_x64_pe_link_missing_postcondition_test_${rand.ulid()}.exe')
	empty_path := os.join_path(os.temp_dir(),
		'v_x64_pe_link_empty_postcondition_test_${rand.ulid()}.exe')
	os.rm(missing_path) or {}
	os.rm(empty_path) or {}
	defer {
		os.rm(missing_path) or {}
		os.rm(empty_path) or {}
	}

	if _ := pe_check_written_image(missing_path, 512) {
		assert false
	} else {
		assert err.msg().contains('was not created as a file')
	}

	os.write_file(empty_path, '') or { panic(err) }
	if _ := pe_check_written_image(empty_path, 512) {
		assert false
	} else {
		assert err.msg().contains('has size 0 bytes')
	}
}

fn test_x64_gen_link_executable_requires_windows_abi() {
	path := os.join_path(os.temp_dir(), 'v_x64_pe_link_api_sysv_test.exe')
	defer {
		os.rm(path) or {}
	}

	mut mod := mir.Module{}
	mut gen := Gen.new_with_format(&mod, .coff)
	gen.coff.text_data << u8(0xc3)
	gen.coff.add_symbol('main', 0, true, 1)

	if _ := gen.link_executable(path) {
		assert false
	} else {
		assert err.msg().contains('requires Windows ABI')
	}
}

fn test_x64_gen_link_executable_rejects_non_coff_format() {
	path := os.join_path(os.temp_dir(), 'v_x64_pe_link_api_elf_test.exe')
	defer {
		os.rm(path) or {}
	}

	mut mod := mir.Module{}
	mut gen := Gen.new_with_format_and_abi(&mod, .elf, .sysv)

	if _ := gen.link_executable(path) {
		assert false
	} else {
		assert err.msg().contains('only implemented for COFF')
	}
}