// Copyright (c) 2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.

module x64

import os

const pe_dos_stub_size = 0x80
const pe_signature = u32(0x00004550)
const pe_optional_header64_magic = u16(0x20b)
const pe_file_alignment = 0x200
const pe_section_alignment = 0x1000
const pe_image_base = u64(0x140000000)
const pe_size_of_optional_header64 = u16(0xf0)
const pe_number_of_rva_and_sizes = 16

// These optional-header values are local policy defaults for the current
// minimal linker, not requirements imposed by the Microsoft PE/COFF spec.
const pe_linker_major_version = u8(0)
const pe_linker_minor_version = u8(1)
const pe_major_operating_system_version = u16(6)
const pe_minor_operating_system_version = u16(0)
const pe_major_subsystem_version = u16(6)
const pe_minor_subsystem_version = u16(0)
const pe_size_of_stack_reserve = u64(0x100000)
const pe_size_of_stack_commit = u64(0x1000)
const pe_size_of_heap_reserve = u64(0x100000)
const pe_size_of_heap_commit = u64(0x1000)

const pe_image_file_relocs_stripped = u16(0x0001)
const pe_image_file_executable_image = u16(0x0002)
const pe_image_file_large_address_aware = u16(0x0020)
const pe_image_subsystem_windows_cui = u16(3)
const pe_dll_characteristics_nx_compat = u16(0x0100)

const pe_image_scn_cnt_code = u32(0x00000020)
const pe_image_scn_cnt_initialized_data = u32(0x00000040)
const pe_image_scn_mem_execute = u32(0x20000000)
const pe_image_scn_mem_read = u32(0x40000000)
const pe_image_scn_mem_write = u32(0x80000000)

const pe_import_directory_index = 1
const pe_exception_directory_index = 3
const pe_base_reloc_directory_index = 5
const pe_iat_directory_index = 12
const pe_runtime_data_alignment = 16
const pe_wgetenv_buffer_wchars = 32768
const pe_wgetenv_buffer_bytes = pe_wgetenv_buffer_wchars * 2
const pe_atexit_callback_capacity = 64
const pe_run_atexit_symbol = '__v2_pe_run_atexit'

const pe_kernel32_dll = 'kernel32.dll'
const pe_shell32_dll = 'shell32.dll'
const pe_ucrtbase_dll = 'ucrtbase.dll'
const pe_msvcrt_dll = 'msvcrt.dll'
const pe_kernel32_imports = ['ExitProcess', 'GetCommandLineW', 'GetStdHandle', 'GetConsoleMode',
    'MultiByteToWideChar', 'WideCharToMultiByte', 'GetCurrentDirectoryW', 'GetEnvironmentVariableW',
    'ReadConsoleW', 'ReadFile', 'WriteConsoleW', 'WriteFile', 'GetProcessHeap', 'HeapAlloc',
    'HeapReAlloc', 'HeapFree', 'GetCurrentThreadId', 'GetSystemTimeAsFileTime',
    'FileTimeToSystemTime', 'SystemTimeToTzSpecificLocalTime', 'QueryPerformanceFrequency',
    'QueryPerformanceCounter']
const pe_shell32_imports = ['CommandLineToArgvW']
const pe_ucrtbase_imports = ['log', 'ldexp', 'sqrt', '_time64', '_localtime64']
const pe_msvcrt_imports = ['_scprintf', '_snprintf']

struct PeImport {
    dll  string
    name string
}

struct PeRuntimeCallPatch {
    field_off int
    dll       string
    name      string
}

struct PeRuntimeDataPatch {
    field_off int
    data_off  u32
}

struct PeRuntimeText {
mut:
    bytes          []u8
    data           []u8
    symbols        map[string]u32
    import_patches []PeRuntimeCallPatch
    data_patches   []PeRuntimeDataPatch
}

struct PeSection {
mut:
    name            string
    data            []u8
    virtual_address u32
    virtual_size    u32
    raw_pointer     u32
    raw_size        u32
    characteristics u32
}

struct PeIdata {
    data        []u8
    import_rva  u32
    import_size u32
    iat_rva     u32
    iat_size    u32
    iat_rvas    map[string]u32
}

struct PeImportGroup {
    dll   string
    start int
mut:
    len int
}

struct PeTextBuild {
    data                 []u8
    argc_global_disp_off int
    argv_global_disp_off int
}

pub struct PeLinker {
    coff &CoffObject
mut:
    imports []PeImport
}

pub fn PeLinker.new(coff &CoffObject) &PeLinker {
    return unsafe {
        &PeLinker{
            coff: coff
        }
    }
}

pub fn (mut l PeLinker) write(path string) ! {
    image := l.image()!
    os.write_file_array(path, image)!
    pe_check_written_image(path, image.len)!
}

pub fn (mut l PeLinker) image() ![]u8 {
    mut runtime_text := l.build_runtime_text()
    l.imports = l.required_pe_imports(runtime_text)!
    l.patch_runtime_import_calls(mut runtime_text)!
    text_build := l.build_text_section(runtime_text)!
    mut text := text_build.data.clone()
    mut data_data := l.coff.data_data.clone()
    runtime_data_base := if runtime_text.data.len > 0 {
        base := align_int(data_data.len, pe_runtime_data_alignment)
        for data_data.len < base {
            data_data << u8(0)
        }
        data_data << runtime_text.data
        base
    } else {
        data_data.len
    }
    section_count := 2 + if l.coff.rodata.len > 0 { 1 } else { 0 } +
        if data_data.len > 0 { 1 } else { 0 }
    header_size := pe_headers_size(section_count)
    mut raw_pointer := header_size
    mut next_rva := u32(pe_section_alignment)
    mut sections := []PeSection{cap: section_count}

    text_section, next_text_raw := pe_make_section('.text', text, next_rva, raw_pointer,
        pe_image_scn_cnt_code | pe_image_scn_mem_execute | pe_image_scn_mem_read)
    raw_pointer = next_text_raw
    next_rva = pe_next_section_rva(text_section.virtual_address, int(text_section.virtual_size))
    sections << text_section

    mut rdata_rva := u32(0)
    if l.coff.rodata.len > 0 {
        rdata_section, next_rdata_raw := pe_make_section('.rdata', l.coff.rodata, next_rva,
            raw_pointer, pe_image_scn_cnt_initialized_data | pe_image_scn_mem_read)
        raw_pointer = next_rdata_raw
        next_rva = pe_next_section_rva(rdata_section.virtual_address,
            int(rdata_section.virtual_size))
        rdata_rva = rdata_section.virtual_address
        sections << rdata_section
    }

    mut data_rva := u32(0)
    if data_data.len > 0 {
        data_section, next_data_raw := pe_make_section('.data', data_data, next_rva, raw_pointer,
            pe_image_scn_cnt_initialized_data | pe_image_scn_mem_read | pe_image_scn_mem_write)
        raw_pointer = next_data_raw
        next_rva = pe_next_section_rva(data_section.virtual_address, int(data_section.virtual_size))
        data_rva = data_section.virtual_address
        sections << data_section
    }

    idata := l.build_idata(next_rva)
    idata_section, next_idata_raw := pe_make_section('.idata', idata.data, next_rva, raw_pointer,
        pe_image_scn_cnt_initialized_data | pe_image_scn_mem_read | pe_image_scn_mem_write)
    raw_pointer = next_idata_raw
    sections << idata_section

    import_thunks := l.import_thunk_rvas(text_section.virtual_address, runtime_text.bytes.len)
    import_iats := idata.iat_rvas.clone()
    runtime_thunks := runtime_text.symbol_rvas(text_section.virtual_address)
    l.patch_entry_argv_bootstrap_data_refs(mut text, text_section.virtual_address, data_rva,
        text_build)!
    l.apply_text_relocations(mut text, text_section.virtual_address, rdata_rva, data_rva,
        runtime_text.bytes.len, runtime_thunks, import_thunks, import_iats)!
    l.apply_runtime_data_patches(mut text, text_section.virtual_address, data_rva, runtime_text,
        runtime_data_base)!
    sections[0].data = text

    size_of_image := pe_size_of_image(sections)
    size_of_code := text_section.raw_size
    mut size_of_initialized_data := u32(0)
    for section in sections {
        if section.characteristics & pe_image_scn_cnt_initialized_data != 0 {
            size_of_initialized_data += section.raw_size
        }
    }

    mut buf := []u8{cap: int(raw_pointer)}
    write_pe_dos_stub(mut buf)
    for buf.len < pe_dos_stub_size {
        buf << 0
    }

    write_u32_le(mut buf, pe_signature)
    write_u16_le(mut buf, coff_image_file_machine_amd64)
    write_u16_le(mut buf, u16(sections.len))
    write_u32_le(mut buf, 0)
    write_u32_le(mut buf, 0)
    write_u32_le(mut buf, 0)
    write_u16_le(mut buf, pe_size_of_optional_header64)
    // No .reloc section is emitted yet, so mark the image fixed-base.
    write_u16_le(mut buf,
        pe_image_file_relocs_stripped | pe_image_file_executable_image | pe_image_file_large_address_aware)

    l.write_optional_header(mut buf, size_of_code, size_of_initialized_data, size_of_image,
        header_size, idata, text_section.virtual_address)

    for section in sections {
        write_pe_section_header(mut buf, section)
    }

    for buf.len < header_size {
        buf << 0
    }
    for section in sections {
        if section.raw_size == 0 {
            continue
        }
        for buf.len < int(section.raw_pointer) {
            buf << 0
        }
        buf << section.data
        for buf.len < int(section.raw_pointer + section.raw_size) {
            buf << 0
        }
    }

    return buf
}

fn (l PeLinker) build_text_section(runtime_text PeRuntimeText) !PeTextBuild {
    main_rva := l.defined_symbol_offset('main') or {
        return error('PE linker requires a defined main symbol')
    }
    mut text := []u8{}
    vinit_offset := l.defined_symbol_offset('_vinit') or { u32(0xffff_ffff) }
    exit_offset := runtime_text.symbols['exit'] or {
        return error('PE linker internal error: missing runtime exit helper')
    }
    text << [u8(0x48), 0x83, 0xec, 0x28] // sub rsp, 40
    mut get_command_line_field := -1
    mut command_line_to_argv_field := -1
    mut argv_failure_exit_field := -1
    mut argc_global_disp_off := -1
    mut argv_global_disp_off := -1
    if l.needs_windows_argv_bootstrap() {
        text << [u8(0xc7), 0x44, 0x24, 0x20, 0, 0, 0, 0] // mov dword ptr [rsp+32], 0
        get_command_line_field = pe_emit_call_placeholder(mut text)
        text << [u8(0x48), 0x89, 0xc1] // mov rcx, rax
        text << [u8(0x48), 0x8d, 0x54, 0x24, 0x20] // lea rdx, [rsp+32]
        command_line_to_argv_field = pe_emit_call_placeholder(mut text)
        text << [u8(0x48), 0x85, 0xc0] // test rax, rax
        text << [u8(0x75), 0x0a] // jne argv parsed
        text << [u8(0xb9), 1, 0, 0, 0] // mov ecx, 1
        argv_failure_exit_field = pe_emit_call_placeholder(mut text)
        if l.has_main_argv_data_symbol() {
            argv_global_disp_off = pe_emit_lea_r10_rip_placeholder(mut text)
            text << [u8(0x49), 0x89, 0x02] // mov [r10], rax
        }
        if l.has_main_argc_data_symbol() {
            argc_global_disp_off = pe_emit_lea_r10_rip_placeholder(mut text)
            text << [u8(0x8b), 0x4c, 0x24, 0x20] // mov ecx, [rsp+32]
            text << [u8(0x41), 0x89, 0x0a] // mov [r10], ecx
        }
    }
    if vinit_offset != 0xffff_ffff {
        pe_emit_call_placeholder(mut text)
    }
    pe_emit_call_placeholder(mut text)
    text << [u8(0x31), 0xc9] // xor ecx, ecx
    pe_emit_call_placeholder(mut text)
    text << 0xcc

    entry_stub_len := text.len
    if entry_stub_len != l.entry_stub_size() {
        return error('PE linker internal error: entry stub size mismatch (${entry_stub_len} != ${l.entry_stub_size()})')
    }
    text << l.coff.text_data
    text << runtime_text.bytes
    for _ in l.imports {
        text << [u8(0xff), 0x25, 0, 0, 0, 0] // jmp qword ptr [rip + disp32]
    }

    import_offsets := l.import_thunk_offsets(runtime_text.bytes.len)
    if get_command_line_field >= 0 {
        get_command_line_thunk_off := import_offsets[pe_kernel32_import_key('GetCommandLineW')] or {
            return error('PE linker internal error: missing GetCommandLineW import thunk')
        }
        command_line_to_argv_thunk_off := import_offsets[pe_shell32_import_key('CommandLineToArgvW')] or {
            return error('PE linker internal error: missing CommandLineToArgvW import thunk')
        }
        pe_patch_rel32(mut text, get_command_line_field, get_command_line_thunk_off, 0)
        pe_patch_rel32(mut text, command_line_to_argv_field, command_line_to_argv_thunk_off, 0)
        pe_patch_rel32(mut text, argv_failure_exit_field, exit_offset, 0)
    }

    mut cursor := 4 + l.windows_argv_bootstrap_size()
    if vinit_offset != 0xffff_ffff {
        pe_patch_rel32(mut text, cursor + 1, u32(entry_stub_len) + vinit_offset, 0)
        cursor += 5
    }
    pe_patch_rel32(mut text, cursor + 1, u32(entry_stub_len) + main_rva, 0)
    cursor += 5
    cursor += 2
    pe_patch_rel32(mut text, cursor + 1, exit_offset, 0)

    return PeTextBuild{
        data:                 text
        argc_global_disp_off: argc_global_disp_off
        argv_global_disp_off: argv_global_disp_off
    }
}

fn (l PeLinker) build_runtime_text() PeRuntimeText {
    runtime_base := u32(l.entry_stub_size() + l.coff.text_data.len)
    mut rt := PeRuntimeText{
        symbols: map[string]u32{}
    }
    mut run_atexit_offset := -1
    if l.uses_undefined_symbol('atexit') {
        count_off := pe_runtime_data_alloc(mut rt, 8, 8)
        callbacks_off := pe_runtime_data_alloc(mut rt, pe_atexit_callback_capacity * 8, 8)
        run_atexit_offset = rt.bytes.len
        rt.symbols[pe_run_atexit_symbol] = runtime_base + u32(run_atexit_offset)
        pe_emit_runtime_run_atexit(mut rt, count_off, callbacks_off)
        rt.symbols['atexit'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_atexit(mut rt, count_off, callbacks_off)
    }
    if l.uses_undefined_symbol('_aligned_malloc') {
        rt.symbols['_aligned_malloc'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_aligned_malloc(mut rt)
    }
    if l.uses_undefined_symbol('_aligned_free') {
        rt.symbols['_aligned_free'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_aligned_free(mut rt)
    }
    if l.uses_undefined_symbol('_aligned_realloc') {
        rt.symbols['_aligned_realloc'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_aligned_realloc(mut rt)
    }
    needs_memmove := l.uses_undefined_symbol('memmove') || l.uses_undefined_symbol('memcpy')
    if needs_memmove {
        move_off := runtime_base + u32(rt.bytes.len)
        if l.uses_undefined_symbol('memmove') {
            rt.symbols['memmove'] = move_off
        }
        if l.uses_undefined_symbol('memcpy') {
            rt.symbols['memcpy'] = move_off
        }
        pe_emit_runtime_memmove(mut rt)
    }
    if l.uses_undefined_symbol('memset') {
        rt.symbols['memset'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_memset(mut rt)
    }
    if l.uses_undefined_symbol('strlen') {
        rt.symbols['strlen'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_strlen(mut rt)
    }
    if l.uses_undefined_symbol('wcslen') {
        rt.symbols['wcslen'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_wcslen(mut rt)
    }
    if l.uses_undefined_symbol('_wgetcwd') {
        rt.symbols['_wgetcwd'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_wgetcwd(mut rt)
    }
    if l.uses_undefined_symbol('_wgetenv') {
        rt.symbols['_wgetenv'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_wgetenv(mut rt)
    }
    if l.uses_undefined_symbol('_errno') {
        rt.symbols['_errno'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_errno(mut rt)
    }
    if l.uses_undefined_symbol('malloc') {
        rt.symbols['malloc'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_malloc(mut rt)
    }
    if l.uses_undefined_symbol('calloc') {
        rt.symbols['calloc'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_calloc(mut rt)
    }
    if l.uses_undefined_symbol('free') {
        rt.symbols['free'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_free(mut rt)
    }
    if l.uses_undefined_symbol('memcmp') {
        rt.symbols['memcmp'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_memcmp(mut rt)
    }
    rt.symbols['exit'] = runtime_base + u32(rt.bytes.len)
    pe_emit_runtime_exit(mut rt, run_atexit_offset)
    if l.uses_undefined_symbol('builtin__i64__str') {
        rt.symbols['builtin__i64__str'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_i64_str(mut rt)
    }
    if l.uses_undefined_symbol('builtin__string__+') {
        rt.symbols['builtin__string__+'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_string_plus(mut rt)
    }
    if l.uses_undefined_symbol('builtin__Array_rune__string') {
        rt.symbols['builtin__Array_rune__string'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_array_rune_string(mut rt)
    }
    if l.uses_undefined_symbol('builtin__new_array_from_c_array_noscan') {
        rt.symbols['builtin__new_array_from_c_array_noscan'] = runtime_base + u32(rt.bytes.len)
        pe_emit_runtime_new_array_from_c_array_noscan(mut rt)
    }
    if l.uses_undefined_symbol('builtin____new_array_noscan')
        || l.uses_undefined_symbol('__new_array_noscan') {
        start := runtime_base + u32(rt.bytes.len)
        if l.uses_undefined_symbol('builtin____new_array_noscan') {
            rt.symbols['builtin____new_array_noscan'] = start
        }
        if l.uses_undefined_symbol('__new_array_noscan') {
            rt.symbols['__new_array_noscan'] = start
        }
        pe_emit_runtime_new_array_noscan(mut rt)
    }
    return rt
}

fn (l PeLinker) required_pe_imports(runtime_text PeRuntimeText) ![]PeImport {
    mut required_kernel32 := map[string]bool{}
    mut required_shell32 := map[string]bool{}
    mut required_ucrtbase := map[string]bool{}
    mut required_msvcrt := map[string]bool{}
    pe_require_kernel32_import(mut required_kernel32, 'ExitProcess')!
    if l.needs_windows_argv_bootstrap() {
        pe_require_kernel32_import(mut required_kernel32, 'GetCommandLineW')!
        pe_require_shell32_import(mut required_shell32, 'CommandLineToArgvW')!
    }
    for patch in runtime_text.import_patches {
        if patch.dll == pe_kernel32_dll {
            pe_require_kernel32_import(mut required_kernel32, patch.name)!
        } else if patch.dll == pe_shell32_dll {
            pe_require_shell32_import(mut required_shell32, patch.name)!
        } else {
            return error('PE linker internal error: unknown import DLL `${patch.dll}` for `${patch.name}`')
        }
    }
    for reloc in l.coff.text_relocs {
        if reloc.sym_idx < 0 || reloc.sym_idx >= l.coff.symbols.len {
            continue
        }
        sym := l.coff.symbols[reloc.sym_idx]
        if sym.section != 0 {
            continue
        }
        if _ := runtime_text.symbols[sym.name] {
            continue
        }
        if kernel32_name := pe_kernel32_import_name_for_external_symbol(sym.name) {
            required_kernel32[kernel32_name] = true
        } else if pe_shell32_import_is_known(sym.name) {
            required_shell32[sym.name] = true
        } else if ucrt_name := pe_ucrtbase_import_name_for_external_symbol(sym.name) {
            pe_require_ucrtbase_import(mut required_ucrtbase, ucrt_name)!
        } else if pe_msvcrt_import_is_known(sym.name) {
            pe_require_msvcrt_import(mut required_msvcrt, sym.name)!
        }
    }

    mut imports := []PeImport{cap: required_kernel32.len + required_shell32.len +
        required_ucrtbase.len + required_msvcrt.len}
    for name in pe_kernel32_imports {
        if required_kernel32[name] {
            imports << PeImport{
                dll:  pe_kernel32_dll
                name: name
            }
        }
    }
    for name in pe_shell32_imports {
        if required_shell32[name] {
            imports << PeImport{
                dll:  pe_shell32_dll
                name: name
            }
        }
    }
    for name in pe_ucrtbase_imports {
        if required_ucrtbase[name] {
            imports << PeImport{
                dll:  pe_ucrtbase_dll
                name: name
            }
        }
    }
    for name in pe_msvcrt_imports {
        if required_msvcrt[name] {
            imports << PeImport{
                dll:  pe_msvcrt_dll
                name: name
            }
        }
    }
    return imports
}

fn (l PeLinker) patch_runtime_import_calls(mut rt PeRuntimeText) ! {
    runtime_base := u32(l.entry_stub_size() + l.coff.text_data.len)
    import_offsets := l.import_thunk_offsets(rt.bytes.len)
    for patch in rt.import_patches {
        key := pe_import_key(patch.dll, patch.name)
        target := import_offsets[key] or {
            return error('PE linker internal error: missing import thunk for `${key}`')
        }
        pe_patch_rel32(mut rt.bytes, patch.field_off, target, runtime_base)
    }
}

fn pe_import_key(dll string, name string) string {
    return '${dll}:${name}'
}

fn pe_kernel32_import_key(name string) string {
    return pe_import_key(pe_kernel32_dll, name)
}

fn pe_shell32_import_key(name string) string {
    return pe_import_key(pe_shell32_dll, name)
}

fn pe_ucrtbase_import_key(name string) string {
    return pe_import_key(pe_ucrtbase_dll, name)
}

fn pe_msvcrt_import_key(name string) string {
    return pe_import_key(pe_msvcrt_dll, name)
}

fn pe_require_kernel32_import(mut required map[string]bool, name string) ! {
    if !pe_kernel32_import_is_known(name) {
        return error('PE linker internal error: unknown Kernel32 import `${name}`')
    }
    required[name] = true
}

fn pe_kernel32_import_is_known(name string) bool {
    for known in pe_kernel32_imports {
        if known == name {
            return true
        }
    }
    return false
}

fn pe_kernel32_import_name_for_external_symbol(name string) ?string {
    return match name {
        'ReadConsole' {
            'ReadConsoleW'
        }
        else {
            if pe_kernel32_import_is_known(name) {
                name
            } else {
                none
            }
        }
    }
}

fn pe_require_ucrtbase_import(mut required map[string]bool, name string) ! {
    if !pe_ucrtbase_import_is_known(name) {
        return error('PE linker internal error: unknown UCRT import `${name}`')
    }
    required[name] = true
}

fn pe_ucrtbase_import_is_known(name string) bool {
    for known in pe_ucrtbase_imports {
        if known == name {
            return true
        }
    }
    return false
}

fn pe_ucrtbase_import_name_for_external_symbol(name string) ?string {
    return match name {
        'time' {
            '_time64'
        }
        'localtime' {
            '_localtime64'
        }
        else {
            if pe_ucrtbase_import_is_known(name) {
                name
            } else {
                none
            }
        }
    }
}

fn pe_require_msvcrt_import(mut required map[string]bool, name string) ! {
    if !pe_msvcrt_import_is_known(name) {
        return error('PE linker internal error: unknown MSVCRT import `${name}`')
    }
    required[name] = true
}

fn pe_msvcrt_import_is_known(name string) bool {
    for known in pe_msvcrt_imports {
        if known == name {
            return true
        }
    }
    return false
}

fn pe_require_shell32_import(mut required map[string]bool, name string) ! {
    if !pe_shell32_import_is_known(name) {
        return error('PE linker internal error: unknown Shell32 import `${name}`')
    }
    required[name] = true
}

fn pe_shell32_import_is_known(name string) bool {
    for known in pe_shell32_imports {
        if known == name {
            return true
        }
    }
    return false
}

fn (rt PeRuntimeText) symbol_rvas(text_rva u32) map[string]u32 {
    mut out := map[string]u32{}
    for name, off in rt.symbols {
        out[name] = text_rva + off
    }
    return out
}

fn (l PeLinker) build_idata(idata_rva u32) PeIdata {
    descriptor_size := 20
    groups := pe_import_groups(l.imports)
    descriptor_count := groups.len + 1
    mut cursor := descriptor_size * descriptor_count
    mut ilt_offsets := []int{cap: groups.len}
    for group in groups {
        ilt_offsets << cursor
        cursor += (group.len + 1) * 8
    }
    mut iat_offsets := []int{cap: groups.len}
    for group in groups {
        iat_offsets << cursor
        cursor += (group.len + 1) * 8
    }
    hint_name_off := cursor

    mut data := []u8{len: hint_name_off}
    mut hint_name_rvas := []u32{len: l.imports.len}
    for i, imp in l.imports {
        hint_name_rvas[i] = idata_rva + u32(data.len)
        write_u16_le(mut data, 0)
        data << imp.name.bytes()
        data << 0
        if data.len % 2 != 0 {
            data << 0
        }
    }
    mut dll_name_rvas := []u32{len: groups.len}
    for i, group in groups {
        dll_name_rvas[i] = idata_rva + u32(data.len)
        data << group.dll.bytes()
        data << 0
        if data.len % 2 != 0 {
            data << 0
        }
    }

    mut iat_rvas := map[string]u32{}
    for group_idx, group in groups {
        descriptor_off := group_idx * descriptor_size
        ilt_off := ilt_offsets[group_idx]
        iat_off := iat_offsets[group_idx]
        pe_put_u32_le(mut data, descriptor_off, idata_rva + u32(ilt_off))
        pe_put_u32_le(mut data, descriptor_off + 12, dll_name_rvas[group_idx])
        pe_put_u32_le(mut data, descriptor_off + 16, idata_rva + u32(iat_off))
        for local_i in 0 .. group.len {
            import_idx := group.start + local_i
            rva := hint_name_rvas[import_idx]
            pe_put_u64_le(mut data, ilt_off + local_i * 8, u64(rva))
            pe_put_u64_le(mut data, iat_off + local_i * 8, u64(rva))
            imp := l.imports[import_idx]
            iat_rvas[pe_import_key(imp.dll, imp.name)] = idata_rva + u32(iat_off + local_i * 8)
        }
    }
    iat_rva := if groups.len == 0 { idata_rva } else { idata_rva + u32(iat_offsets[0]) }
    iat_size := if groups.len == 0 {
        u32(0)
    } else {
        last_group := groups[groups.len - 1]
        last_iat_off := iat_offsets[iat_offsets.len - 1]
        u32(last_iat_off + (last_group.len + 1) * 8 - iat_offsets[0])
    }

    return PeIdata{
        data:        data
        import_rva:  idata_rva
        import_size: u32(descriptor_size * descriptor_count)
        iat_rva:     iat_rva
        iat_size:    iat_size
        iat_rvas:    iat_rvas
    }
}

fn pe_import_groups(imports []PeImport) []PeImportGroup {
    mut groups := []PeImportGroup{}
    for i, imp in imports {
        if groups.len == 0 || groups[groups.len - 1].dll != imp.dll {
            groups << PeImportGroup{
                dll:   imp.dll
                start: i
                len:   1
            }
        } else {
            groups[groups.len - 1].len++
        }
    }
    return groups
}

fn (l PeLinker) apply_text_relocations(mut text []u8,
    text_rva u32,
    rdata_rva u32,
    data_rva u32,
    runtime_text_size int,
    runtime_thunks map[string]u32,
    import_thunks map[string]u32,
    import_iats map[string]u32) ! {
    entry_stub_len := l.entry_stub_size()
    for reloc in l.coff.text_relocs {
        if reloc.type_ != coff_image_rel_amd64_rel32 {
            return error('PE linker does not support COFF relocation type 0x${reloc.type_:04x}')
        }
        if reloc.sym_idx < 0 || reloc.sym_idx >= l.coff.symbols.len {
            return error('PE linker relocation references invalid symbol index ${reloc.sym_idx}')
        }
        sym := l.coff.symbols[reloc.sym_idx]
        target_rva := match sym.section {
            1 {
                text_rva + u32(entry_stub_len) + sym.value
            }
            2 {
                if rdata_rva == 0 {
                    return error('PE linker relocation references .rdata, but no .rdata section was emitted')
                }
                rdata_rva + sym.value
            }
            3 {
                if data_rva == 0 || l.coff.data_data.len == 0 {
                    return error('PE linker relocation references .data, but no .data section was emitted')
                }
                data_rva + sym.value
            }
            0 {
                if runtime_rva := runtime_thunks[sym.name] {
                    runtime_rva
                } else {
                    import_key := l.import_key_for_external_symbol(sym.name) or {
                        return error(l.unresolved_external_symbol_message(sym.name, reloc))
                    }
                    import_thunks[import_key] or {
                        return error(l.unresolved_external_symbol_message(sym.name, reloc))
                    }
                }
            }
            else {
                return error('PE linker cannot resolve symbol `${sym.name}` in COFF section ${sym.section}')
            }
        }

        field_off := entry_stub_len + int(reloc.offset)
        old_disp := pe_read_i32_le(text, field_off)
        field_rva := text_rva + u32(field_off)
        new_disp := old_disp + i32(int(target_rva) - (int(field_rva) + 4))
        pe_put_u32_le(mut text, field_off, u32(new_disp))
    }

    thunk_base := l.import_thunk_base(runtime_text_size)
    for i, imp in l.imports {
        thunk_off := thunk_base + i * 6
        import_key := pe_import_key(imp.dll, imp.name)
        iat_entry_rva := import_iats[import_key] or {
            return error('PE linker internal error: missing IAT entry for `${import_key}`')
        }
        thunk_rva := text_rva + u32(thunk_off)
        disp := i32(int(iat_entry_rva) - (int(thunk_rva) + 6))
        pe_put_u32_le(mut text, thunk_off + 2, u32(disp))
    }
}

fn (l PeLinker) apply_runtime_data_patches(mut text []u8,
    text_rva u32,
    data_rva u32,
    runtime_text PeRuntimeText,
    runtime_data_base int) ! {
    if runtime_text.data_patches.len == 0 {
        return
    }
    if data_rva == 0 {
        return error('PE linker runtime data patch requires a .data section')
    }
    runtime_base := l.entry_stub_size() + l.coff.text_data.len
    for patch in runtime_text.data_patches {
        field_off := runtime_base + patch.field_off
        target_rva := data_rva + u32(runtime_data_base) + patch.data_off
        pe_patch_rel32(mut text, field_off, target_rva, text_rva)
    }
}

fn (l PeLinker) unresolved_external_symbol_message(name string, reloc CoffRelocation) string {
    context := l.text_relocation_context(reloc)
    return x64_unresolved_external_symbol_message(.coff, name, context)
}

fn (l PeLinker) text_relocation_context(reloc CoffRelocation) string {
    mut has_symbol := false
    mut nearest_name := ''
    mut nearest_offset := u32(0)
    for sym in l.coff.symbols {
        if sym.section != 1 || sym.name.len == 0 || sym.value > reloc.offset {
            continue
        }
        if !has_symbol || sym.value >= nearest_offset {
            has_symbol = true
            nearest_name = sym.name
            nearest_offset = sym.value
        }
    }
    mut context := 'referenced from .text relocation offset 0x${reloc.offset:08x}'
    if has_symbol {
        context += ' near `${nearest_name}`+0x${reloc.offset - nearest_offset:08x}'
    }
    return context
}

fn (l PeLinker) import_thunk_base(runtime_text_size int) int {
    return l.entry_stub_size() + l.coff.text_data.len + runtime_text_size
}

fn (l PeLinker) import_thunk_offsets(runtime_text_size int) map[string]u32 {
    thunk_base := l.import_thunk_base(runtime_text_size)
    mut out := map[string]u32{}
    for i, imp in l.imports {
        out[pe_import_key(imp.dll, imp.name)] = u32(thunk_base + i * 6)
    }
    return out
}

fn (l PeLinker) import_thunk_rvas(text_rva u32, runtime_text_size int) map[string]u32 {
    offsets := l.import_thunk_offsets(runtime_text_size)
    mut out := map[string]u32{}
    for name, off in offsets {
        out[name] = text_rva + off
    }
    return out
}

fn (l PeLinker) import_key_for_external_symbol(name string) ?string {
    if kernel32_name := pe_kernel32_import_name_for_external_symbol(name) {
        return pe_kernel32_import_key(kernel32_name)
    }
    if pe_shell32_import_is_known(name) {
        return pe_shell32_import_key(name)
    }
    if ucrt_name := pe_ucrtbase_import_name_for_external_symbol(name) {
        return pe_ucrtbase_import_key(ucrt_name)
    }
    if pe_msvcrt_import_is_known(name) {
        return pe_msvcrt_import_key(name)
    }
    return none
}

fn (l PeLinker) entry_stub_size() int {
    vinit := l.defined_symbol_offset('_vinit') or { u32(0xffff_ffff) }
    base_size := if vinit == 0xffff_ffff { 17 } else { 22 }
    return base_size + l.windows_argv_bootstrap_size()
}

fn (l PeLinker) windows_argv_bootstrap_size() int {
    if !l.needs_windows_argv_bootstrap() {
        return 0
    }
    mut size := 8 + 5 + 3 + 5 + 5 + 15 // zero argc, argv calls, null check, ExitProcess(1)
    if l.has_main_argv_data_symbol() {
        size += 7 + 3 // lea g_main_argv; mov [g_main_argv], rax
    }
    if l.has_main_argc_data_symbol() {
        size += 7 + 4 + 3 // lea g_main_argc; load local argc; mov [g_main_argc], ecx
    }
    return size
}

fn (l PeLinker) defined_symbol_offset(name string) ?u32 {
    for sym in l.coff.symbols {
        if sym.name == name && sym.section == 1 {
            return sym.value
        }
    }
    return none
}

fn (l PeLinker) uses_undefined_symbol(name string) bool {
    for reloc in l.coff.text_relocs {
        if reloc.sym_idx < 0 || reloc.sym_idx >= l.coff.symbols.len {
            continue
        }
        sym := l.coff.symbols[reloc.sym_idx]
        if sym.section == 0 && sym.name == name {
            return true
        }
    }
    return false
}

fn (l PeLinker) needs_windows_argv_bootstrap() bool {
    for reloc in l.coff.text_relocs {
        if reloc.sym_idx < 0 || reloc.sym_idx >= l.coff.symbols.len {
            continue
        }
        sym := l.coff.symbols[reloc.sym_idx]
        if sym.section == 3
            && (x64_main_argc_global_name(sym.name) || x64_main_argv_global_name(sym.name)) {
            return true
        }
    }
    return false
}

fn (l PeLinker) has_main_argc_data_symbol() bool {
    if _ := l.main_argc_data_offset() {
        return true
    }
    return false
}

fn (l PeLinker) has_main_argv_data_symbol() bool {
    if _ := l.main_argv_data_offset() {
        return true
    }
    return false
}

fn (l PeLinker) main_argc_data_offset() ?u32 {
    for sym in l.coff.symbols {
        if sym.section == 3 && x64_main_argc_global_name(sym.name) {
            return sym.value
        }
    }
    return none
}

fn (l PeLinker) main_argv_data_offset() ?u32 {
    for sym in l.coff.symbols {
        if sym.section == 3 && x64_main_argv_global_name(sym.name) {
            return sym.value
        }
    }
    return none
}

fn (l PeLinker) patch_entry_argv_bootstrap_data_refs(mut text []u8, text_rva u32, data_rva u32, text_build PeTextBuild) ! {
    if text_build.argc_global_disp_off < 0 && text_build.argv_global_disp_off < 0 {
        return
    }
    if data_rva == 0 {
        return error('PE linker Windows argv bootstrap requires a .data section for g_main_argc/g_main_argv')
    }
    if text_build.argc_global_disp_off >= 0 {
        argc_off := l.main_argc_data_offset() or {
            return error('PE linker Windows argv bootstrap requires g_main_argc data symbol')
        }
        pe_patch_rel32(mut text, text_build.argc_global_disp_off, data_rva + argc_off, text_rva)
    }
    if text_build.argv_global_disp_off >= 0 {
        argv_off := l.main_argv_data_offset() or {
            return error('PE linker Windows argv bootstrap requires g_main_argv data symbol')
        }
        pe_patch_rel32(mut text, text_build.argv_global_disp_off, data_rva + argv_off, text_rva)
    }
}

fn (mut l PeLinker) write_optional_header(mut buf []u8, size_of_code u32, size_of_initialized_data u32, size_of_image u32, size_of_headers int, idata PeIdata, entry_rva u32) {
    write_u16_le(mut buf, pe_optional_header64_magic)
    buf << pe_linker_major_version
    buf << pe_linker_minor_version
    write_u32_le(mut buf, size_of_code)
    write_u32_le(mut buf, size_of_initialized_data)
    write_u32_le(mut buf, 0)
    write_u32_le(mut buf, entry_rva)
    write_u32_le(mut buf, entry_rva)
    write_u64_le(mut buf, pe_image_base)
    write_u32_le(mut buf, pe_section_alignment)
    write_u32_le(mut buf, pe_file_alignment)
    write_u16_le(mut buf, pe_major_operating_system_version)
    write_u16_le(mut buf, pe_minor_operating_system_version)
    write_u16_le(mut buf, 0)
    write_u16_le(mut buf, 0)
    write_u16_le(mut buf, pe_major_subsystem_version)
    write_u16_le(mut buf, pe_minor_subsystem_version)
    write_u32_le(mut buf, 0)
    write_u32_le(mut buf, size_of_image)
    write_u32_le(mut buf, u32(size_of_headers))
    write_u32_le(mut buf, 0)
    write_u16_le(mut buf, pe_image_subsystem_windows_cui)
    write_u16_le(mut buf, pe_dll_characteristics_nx_compat)
    write_u64_le(mut buf, pe_size_of_stack_reserve)
    write_u64_le(mut buf, pe_size_of_stack_commit)
    write_u64_le(mut buf, pe_size_of_heap_reserve)
    write_u64_le(mut buf, pe_size_of_heap_commit)
    write_u32_le(mut buf, 0)
    write_u32_le(mut buf, pe_number_of_rva_and_sizes)

    for i in 0 .. pe_number_of_rva_and_sizes {
        if i == pe_import_directory_index {
            write_u32_le(mut buf, idata.import_rva)
            write_u32_le(mut buf, idata.import_size)
        } else if i == pe_exception_directory_index || i == pe_base_reloc_directory_index {
            // Unwind and base relocation directories are not emitted yet.
            write_u32_le(mut buf, 0)
            write_u32_le(mut buf, 0)
        } else if i == pe_iat_directory_index {
            write_u32_le(mut buf, idata.iat_rva)
            write_u32_le(mut buf, idata.iat_size)
        } else {
            write_u32_le(mut buf, 0)
            write_u32_le(mut buf, 0)
        }
    }
}

fn write_pe_dos_stub(mut buf []u8) {
    buf << [u8(`M`), `Z`]
    for buf.len < 0x3c {
        buf << 0
    }
    write_u32_le(mut buf, pe_dos_stub_size)
}

fn write_pe_section_header(mut buf []u8, section PeSection) {
    write_fixed_string(mut buf, section.name, 8)
    write_u32_le(mut buf, section.virtual_size)
    write_u32_le(mut buf, section.virtual_address)
    write_u32_le(mut buf, section.raw_size)
    write_u32_le(mut buf, section.raw_pointer)
    write_u32_le(mut buf, 0)
    write_u32_le(mut buf, 0)
    write_u16_le(mut buf, 0)
    write_u16_le(mut buf, 0)
    write_u32_le(mut buf, section.characteristics)
}

fn pe_make_section(name string, data []u8, virtual_address u32, raw_pointer int, characteristics u32) (PeSection, int) {
    raw_size := if data.len == 0 { 0 } else { align_int(data.len, pe_file_alignment) }
    raw_ptr := if raw_size == 0 { 0 } else { raw_pointer }
    mut next_raw_pointer := raw_pointer
    if raw_size > 0 {
        next_raw_pointer += raw_size
    }
    return PeSection{
        name:            name
        data:            data.clone()
        virtual_address: virtual_address
        virtual_size:    u32(data.len)
        raw_pointer:     u32(raw_ptr)
        raw_size:        u32(raw_size)
        characteristics: characteristics
    }, next_raw_pointer
}

fn pe_headers_size(section_count int) int {
    return align_int(pe_dos_stub_size + 4 + 20 + int(pe_size_of_optional_header64) +
        section_count * 40, pe_file_alignment)
}

fn pe_size_of_image(sections []PeSection) u32 {
    mut end := 0
    for section in sections {
        virtual_size := if section.virtual_size == 0 { 1 } else { int(section.virtual_size) }
        section_end := int(section.virtual_address) + align_int(virtual_size, pe_section_alignment)
        if section_end > end {
            end = section_end
        }
    }
    return u32(align_int(end, pe_section_alignment))
}

fn pe_next_section_rva(rva u32, size int) u32 {
    virtual_size := if size == 0 { 1 } else { size }
    return u32(align_int(int(rva) + virtual_size, pe_section_alignment))
}

fn pe_check_written_image(path string, expected_size int) ! {
    if !os.is_file(path) {
        return error('PE linker write reported success, but `${path}` was not created as a file')
    }
    size := os.file_size(path)
    if size != u64(expected_size) {
        return error('PE linker write reported success, but `${path}` has size ${size} bytes (expected ${expected_size} bytes)')
    }
}

fn pe_emit_call_placeholder(mut text []u8) int {
    text << u8(0xe8)
    field_off := text.len
    text << [u8(0), 0, 0, 0]
    return field_off
}

fn pe_emit_lea_r10_rip_placeholder(mut text []u8) int {
    text << [u8(0x4c), 0x8d, 0x15] // lea r10, [rip + disp32]
    field_off := text.len
    text << [u8(0), 0, 0, 0]
    return field_off
}

fn pe_emit_runtime_call_import(mut rt PeRuntimeText, import_name string) {
    rt.bytes << u8(0xe8)
    rt.import_patches << PeRuntimeCallPatch{
        field_off: rt.bytes.len
        dll:       pe_kernel32_dll
        name:      import_name
    }
    rt.bytes << [u8(0), 0, 0, 0]
}

fn pe_runtime_data_alloc(mut rt PeRuntimeText, size int, align int) u32 {
    aligned := align_int(rt.data.len, align)
    for rt.data.len < aligned {
        rt.data << u8(0)
    }
    off := rt.data.len
    for _ in 0 .. size {
        rt.data << u8(0)
    }
    return u32(off)
}

fn pe_emit_runtime_lea_rax_data(mut rt PeRuntimeText, data_off u32) {
    rt.bytes << [u8(0x48), 0x8d, 0x05] // lea rax, [rip + disp32]
    rt.data_patches << PeRuntimeDataPatch{
        field_off: rt.bytes.len
        data_off:  data_off
    }
    rt.bytes << [u8(0), 0, 0, 0]
}

fn pe_emit_runtime_lea_rdx_data(mut rt PeRuntimeText, data_off u32) {
    rt.bytes << [u8(0x48), 0x8d, 0x15] // lea rdx, [rip + disp32]
    rt.data_patches << PeRuntimeDataPatch{
        field_off: rt.bytes.len
        data_off:  data_off
    }
    rt.bytes << [u8(0), 0, 0, 0]
}

fn pe_emit_runtime_lea_r8_data(mut rt PeRuntimeText, data_off u32) {
    rt.bytes << [u8(0x4c), 0x8d, 0x05] // lea r8, [rip + disp32]
    rt.data_patches << PeRuntimeDataPatch{
        field_off: rt.bytes.len
        data_off:  data_off
    }
    rt.bytes << [u8(0), 0, 0, 0]
}

fn pe_emit_jcc8(mut data []u8, opcode u8) int {
    data << opcode
    field_off := data.len
    data << u8(0)
    return field_off
}

fn pe_emit_jcc32(mut data []u8, opcode u8) int {
    data << [u8(0x0f), opcode]
    field_off := data.len
    data << [u8(0), 0, 0, 0]
    return field_off
}

fn pe_emit_jmp32(mut data []u8) int {
    data << u8(0xe9)
    field_off := data.len
    data << [u8(0), 0, 0, 0]
    return field_off
}

fn pe_patch_rel32(mut text []u8, field_off int, target_off u32, text_rva u32) {
    field_rva := text_rva + u32(field_off)
    disp := i32(int(target_off) - (int(field_rva) + 4))
    pe_put_u32_le(mut text, field_off, u32(disp))
}

fn pe_patch_rel32_local(mut data []u8, field_off int, target_off int) {
    pe_patch_rel32(mut data, field_off, u32(target_off), 0)
}

fn pe_patch_rel8(mut data []u8, field_off int, target_off int) {
    disp := target_off - (field_off + 1)
    data[field_off] = u8(disp & 0xff)
}

fn pe_emit_runtime_aligned_malloc(mut rt PeRuntimeText) {
    rt.bytes << [u8(0x48), 0x83, 0xec, 0x38] // sub rsp, 56
    rt.bytes << [u8(0x48), 0x83, 0xfa, 0x10] // cmp rdx, 16
    align_check := pe_emit_jcc8(mut rt.bytes, 0x77) // ja
    rt.bytes << [u8(0xba), 0x10, 0, 0, 0] // mov edx, 16
    align_ready_jump := pe_emit_jcc8(mut rt.bytes, 0xeb) // jmp
    align_check_target := rt.bytes.len
    rt.bytes << [u8(0x49), 0x89, 0xd2] // mov r10, rdx
    rt.bytes << [u8(0x49), 0xff, 0xca] // dec r10
    rt.bytes << [u8(0x4c), 0x85, 0xd2] // test rdx, r10
    invalid_align := pe_emit_jcc8(mut rt.bytes, 0x75) // jne
    align_ready := rt.bytes.len
    rt.bytes << [u8(0x48), 0x89, 0x4c, 0x24, 0x20] // mov [rsp+32], rcx
    rt.bytes << [u8(0x48), 0x89, 0x54, 0x24, 0x28] // mov [rsp+40], rdx
    pe_emit_runtime_call_import(mut rt, 'GetProcessHeap')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    no_heap := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0x48), 0x89, 0xc1] // mov rcx, rax
    rt.bytes << [u8(0x31), 0xd2] // xor edx, edx
    rt.bytes << [u8(0x4c), 0x8b, 0x44, 0x24, 0x20] // mov r8, [rsp+32]
    rt.bytes << [u8(0x4c), 0x8b, 0x4c, 0x24, 0x28] // mov r9, [rsp+40]
    rt.bytes << [u8(0x4d), 0x01, 0xc8] // add r8, r9
    size_overflow := pe_emit_jcc8(mut rt.bytes, 0x72) // jc
    rt.bytes << [u8(0x49), 0x83, 0xc0, 0x08] // add r8, 8
    padding_overflow := pe_emit_jcc8(mut rt.bytes, 0x72) // jc
    pe_emit_runtime_call_import(mut rt, 'HeapAlloc')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    alloc_failed := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0x4c), 0x8b, 0x54, 0x24, 0x28] // mov r10, [rsp+40]
    rt.bytes << [u8(0x49), 0x89, 0xc3] // mov r11, rax
    rt.bytes << [u8(0x49), 0x83, 0xc3, 0x08] // add r11, 8
    rt.bytes << [u8(0x4d), 0x01, 0xd3] // add r11, r10
    rt.bytes << [u8(0x49), 0xff, 0xcb] // dec r11
    rt.bytes << [u8(0x4c), 0x89, 0xd1] // mov rcx, r10
    rt.bytes << [u8(0x48), 0xf7, 0xd9] // neg rcx
    rt.bytes << [u8(0x49), 0x21, 0xcb] // and r11, rcx
    rt.bytes << [u8(0x49), 0x89, 0x43, 0xf8] // mov [r11-8], rax
    rt.bytes << [u8(0x4c), 0x89, 0xd8] // mov rax, r11
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x38] // add rsp, 56
    rt.bytes << u8(0xc3) // ret
    fail := rt.bytes.len
    rt.bytes << [u8(0x31), 0xc0] // xor eax, eax
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x38] // add rsp, 56
    rt.bytes << u8(0xc3) // ret
    pe_patch_rel8(mut rt.bytes, align_check, align_check_target)
    pe_patch_rel8(mut rt.bytes, align_ready_jump, align_ready)
    pe_patch_rel8(mut rt.bytes, invalid_align, fail)
    pe_patch_rel8(mut rt.bytes, no_heap, fail)
    pe_patch_rel8(mut rt.bytes, size_overflow, fail)
    pe_patch_rel8(mut rt.bytes, padding_overflow, fail)
    pe_patch_rel8(mut rt.bytes, alloc_failed, fail)
}

fn pe_emit_runtime_aligned_free(mut rt PeRuntimeText) {
    rt.bytes << [u8(0x48), 0x85, 0xc9] // test rcx, rcx
    null_ptr := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0x48), 0x83, 0xec, 0x28] // sub rsp, 40
    rt.bytes << [u8(0x48), 0x8b, 0x41, 0xf8] // mov rax, [rcx-8]
    rt.bytes << [u8(0x48), 0x89, 0x44, 0x24, 0x20] // mov [rsp+32], rax
    pe_emit_runtime_call_import(mut rt, 'GetProcessHeap')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    no_heap := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0x48), 0x89, 0xc1] // mov rcx, rax
    rt.bytes << [u8(0x31), 0xd2] // xor edx, edx
    rt.bytes << [u8(0x4c), 0x8b, 0x44, 0x24, 0x20] // mov r8, [rsp+32]
    pe_emit_runtime_call_import(mut rt, 'HeapFree')
    cleanup := rt.bytes.len
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x28] // add rsp, 40
    done := rt.bytes.len
    rt.bytes << u8(0xc3) // ret
    pe_patch_rel8(mut rt.bytes, null_ptr, done)
    pe_patch_rel8(mut rt.bytes, no_heap, cleanup)
}

fn pe_emit_runtime_aligned_realloc(mut rt PeRuntimeText) {
    rt.bytes << [u8(0x49), 0x83, 0xf8, 0x10] // cmp r8, 16
    supported_align := pe_emit_jcc8(mut rt.bytes, 0x76) // jbe
    rt.bytes << [u8(0x31), 0xc0] // xor eax, eax
    rt.bytes << u8(0xc3) // ret
    supported_align_target := rt.bytes.len
    rt.bytes << [u8(0x48), 0x85, 0xc9] // test rcx, rcx
    null_ptr := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0x48), 0x83, 0xec, 0x38] // sub rsp, 56
    rt.bytes << [u8(0x48), 0x89, 0x54, 0x24, 0x20] // mov [rsp+32], rdx
    rt.bytes << [u8(0x4c), 0x8b, 0x51, 0xf8] // mov r10, [rcx-8]
    rt.bytes << [u8(0x4c), 0x89, 0x54, 0x24, 0x28] // mov [rsp+40], r10
    pe_emit_runtime_call_import(mut rt, 'GetProcessHeap')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    no_heap := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0x48), 0x89, 0xc1] // mov rcx, rax
    rt.bytes << [u8(0x31), 0xd2] // xor edx, edx
    rt.bytes << [u8(0x4c), 0x8b, 0x44, 0x24, 0x28] // mov r8, [rsp+40]
    rt.bytes << [u8(0x4c), 0x8b, 0x4c, 0x24, 0x20] // mov r9, [rsp+32]
    rt.bytes << [u8(0x49), 0x83, 0xc1, 0x18] // add r9, 24
    size_overflow := pe_emit_jcc8(mut rt.bytes, 0x72) // jc
    pe_emit_runtime_call_import(mut rt, 'HeapReAlloc')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    realloc_failed := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0x49), 0x89, 0xc2] // mov r10, rax
    rt.bytes << [u8(0x49), 0x83, 0xc2, 0x10] // add r10, 16
    rt.bytes << [u8(0x49), 0x89, 0x42, 0xf8] // mov [r10-8], rax
    rt.bytes << [u8(0x4c), 0x89, 0xd0] // mov rax, r10
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x38] // add rsp, 56
    rt.bytes << u8(0xc3) // ret
    fail_with_frame := rt.bytes.len
    rt.bytes << [u8(0x31), 0xc0] // xor eax, eax
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x38] // add rsp, 56
    rt.bytes << u8(0xc3) // ret
    null_alloc := rt.bytes.len
    rt.bytes << [u8(0x48), 0x83, 0xec, 0x28] // sub rsp, 40
    rt.bytes << [u8(0x48), 0x89, 0x54, 0x24, 0x20] // mov [rsp+32], rdx
    pe_emit_runtime_call_import(mut rt, 'GetProcessHeap')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    no_heap_null := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0x48), 0x89, 0xc1] // mov rcx, rax
    rt.bytes << [u8(0x31), 0xd2] // xor edx, edx
    rt.bytes << [u8(0x4c), 0x8b, 0x44, 0x24, 0x20] // mov r8, [rsp+32]
    rt.bytes << [u8(0x49), 0x83, 0xc0, 0x18] // add r8, 24
    null_size_overflow := pe_emit_jcc8(mut rt.bytes, 0x72) // jc
    pe_emit_runtime_call_import(mut rt, 'HeapAlloc')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    alloc_failed := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0x49), 0x89, 0xc2] // mov r10, rax
    rt.bytes << [u8(0x49), 0x83, 0xc2, 0x10] // add r10, 16
    rt.bytes << [u8(0x49), 0x89, 0x42, 0xf8] // mov [r10-8], rax
    rt.bytes << [u8(0x4c), 0x89, 0xd0] // mov rax, r10
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x28] // add rsp, 40
    rt.bytes << u8(0xc3) // ret
    fail_with_null_frame := rt.bytes.len
    rt.bytes << [u8(0x31), 0xc0] // xor eax, eax
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x28] // add rsp, 40
    rt.bytes << u8(0xc3) // ret
    pe_patch_rel8(mut rt.bytes, supported_align, supported_align_target)
    pe_patch_rel8(mut rt.bytes, null_ptr, null_alloc)
    pe_patch_rel8(mut rt.bytes, no_heap, fail_with_frame)
    pe_patch_rel8(mut rt.bytes, size_overflow, fail_with_frame)
    pe_patch_rel8(mut rt.bytes, realloc_failed, fail_with_frame)
    pe_patch_rel8(mut rt.bytes, no_heap_null, fail_with_null_frame)
    pe_patch_rel8(mut rt.bytes, null_size_overflow, fail_with_null_frame)
    pe_patch_rel8(mut rt.bytes, alloc_failed, fail_with_null_frame)
}

fn pe_emit_runtime_align_heap_allocated_data(mut rt PeRuntimeText) {
    rt.bytes << [u8(0x49), 0x89, 0xc3] // mov r11, rax
    rt.bytes << [u8(0x49), 0x83, 0xc3, 0x17] // add r11, 23
    rt.bytes << [u8(0x49), 0x83, 0xe3, 0xf0] // and r11, -16
    rt.bytes << [u8(0x49), 0x89, 0x43, 0xf8] // mov [r11-8], rax
}

fn pe_emit_runtime_memmove(mut rt PeRuntimeText) {
    rt.bytes << [u8(0x48), 0x89, 0xc8] // mov rax, rcx
    rt.bytes << [u8(0x4d), 0x85, 0xc0] // test r8, r8
    zero_len := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0x48), 0x39, 0xd1] // cmp rcx, rdx
    dest_before_src := pe_emit_jcc8(mut rt.bytes, 0x76) // jbe
    rt.bytes << [u8(0x4e), 0x8d, 0x0c, 0x02] // lea r9, [rdx+r8]
    rt.bytes << [u8(0x4c), 0x39, 0xc9] // cmp rcx, r9
    no_overlap := pe_emit_jcc8(mut rt.bytes, 0x73) // jae
    rt.bytes << [u8(0x4e), 0x8d, 0x54, 0x01, 0xff] // lea r10, [rcx+r8-1]
    rt.bytes << [u8(0x4e), 0x8d, 0x5c, 0x02, 0xff] // lea r11, [rdx+r8-1]
    backward_loop := rt.bytes.len
    rt.bytes << [u8(0x45), 0x8a, 0x0b] // mov r9b, [r11]
    rt.bytes << [u8(0x45), 0x88, 0x0a] // mov [r10], r9b
    rt.bytes << [u8(0x49), 0xff, 0xca] // dec r10
    rt.bytes << [u8(0x49), 0xff, 0xcb] // dec r11
    rt.bytes << [u8(0x49), 0xff, 0xc8] // dec r8
    backward_more := pe_emit_jcc8(mut rt.bytes, 0x75) // jne
    rt.bytes << u8(0xc3) // ret
    forward := rt.bytes.len
    rt.bytes << [u8(0x49), 0x89, 0xca] // mov r10, rcx
    rt.bytes << [u8(0x49), 0x89, 0xd3] // mov r11, rdx
    forward_loop := rt.bytes.len
    rt.bytes << [u8(0x45), 0x8a, 0x0b] // mov r9b, [r11]
    rt.bytes << [u8(0x45), 0x88, 0x0a] // mov [r10], r9b
    rt.bytes << [u8(0x49), 0xff, 0xc2] // inc r10
    rt.bytes << [u8(0x49), 0xff, 0xc3] // inc r11
    rt.bytes << [u8(0x49), 0xff, 0xc8] // dec r8
    forward_more := pe_emit_jcc8(mut rt.bytes, 0x75) // jne
    done := rt.bytes.len
    rt.bytes << u8(0xc3) // ret
    pe_patch_rel8(mut rt.bytes, zero_len, done)
    pe_patch_rel8(mut rt.bytes, dest_before_src, forward)
    pe_patch_rel8(mut rt.bytes, no_overlap, forward)
    pe_patch_rel8(mut rt.bytes, backward_more, backward_loop)
    pe_patch_rel8(mut rt.bytes, forward_more, forward_loop)
}

fn pe_emit_runtime_memset(mut rt PeRuntimeText) {
    rt.bytes << [u8(0x48), 0x89, 0xc8] // mov rax, rcx
    rt.bytes << [u8(0x4d), 0x85, 0xc0] // test r8, r8
    zero_len := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0x49), 0x89, 0xca] // mov r10, rcx
    loop_start := rt.bytes.len
    rt.bytes << [u8(0x41), 0x88, 0x12] // mov [r10], dl
    rt.bytes << [u8(0x49), 0xff, 0xc2] // inc r10
    rt.bytes << [u8(0x49), 0xff, 0xc8] // dec r8
    more := pe_emit_jcc8(mut rt.bytes, 0x75) // jne
    done := rt.bytes.len
    rt.bytes << u8(0xc3) // ret
    pe_patch_rel8(mut rt.bytes, zero_len, done)
    pe_patch_rel8(mut rt.bytes, more, loop_start)
}

fn pe_emit_runtime_strlen(mut rt PeRuntimeText) {
    rt.bytes << [u8(0x48), 0x89, 0xc8] // mov rax, rcx
    loop_start := rt.bytes.len
    rt.bytes << [u8(0x80), 0x38, 0x00] // cmp byte ptr [rax], 0
    done := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0x48), 0xff, 0xc0] // inc rax
    more := pe_emit_jcc8(mut rt.bytes, 0xeb) // jmp
    done_target := rt.bytes.len
    rt.bytes << [u8(0x48), 0x29, 0xc8] // sub rax, rcx
    rt.bytes << u8(0xc3) // ret
    pe_patch_rel8(mut rt.bytes, done, done_target)
    pe_patch_rel8(mut rt.bytes, more, loop_start)
}

fn pe_emit_runtime_wcslen(mut rt PeRuntimeText) {
    rt.bytes << [u8(0x48), 0x89, 0xc8] // mov rax, rcx
    loop_start := rt.bytes.len
    rt.bytes << [u8(0x66), 0x83, 0x38, 0x00] // cmp word ptr [rax], 0
    done := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0x48), 0x83, 0xc0, 0x02] // add rax, 2
    more := pe_emit_jcc8(mut rt.bytes, 0xeb) // jmp
    done_target := rt.bytes.len
    rt.bytes << [u8(0x48), 0x29, 0xc8] // sub rax, rcx
    rt.bytes << [u8(0x48), 0xd1, 0xe8] // shr rax, 1
    rt.bytes << u8(0xc3) // ret
    pe_patch_rel8(mut rt.bytes, done, done_target)
    pe_patch_rel8(mut rt.bytes, more, loop_start)
}

fn pe_emit_runtime_wgetcwd(mut rt PeRuntimeText) {
    rt.bytes << [u8(0x48), 0x83, 0xec, 0x38] // sub rsp, 56
    rt.bytes << [u8(0x48), 0x89, 0x4c, 0x24, 0x20] // mov [rsp+32], rcx
    rt.bytes << [u8(0x89), 0x54, 0x24, 0x28] // mov [rsp+40], edx
    rt.bytes << [u8(0x89), 0xd1] // mov ecx, edx
    rt.bytes << [u8(0x48), 0x8b, 0x54, 0x24, 0x20] // mov rdx, [rsp+32]
    pe_emit_runtime_call_import(mut rt, 'GetCurrentDirectoryW')
    rt.bytes << [u8(0x85), 0xc0] // test eax, eax
    failed := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0x3b), 0x44, 0x24, 0x28] // cmp eax, [rsp+40]
    too_small := pe_emit_jcc8(mut rt.bytes, 0x73) // jae
    rt.bytes << [u8(0x48), 0x8b, 0x44, 0x24, 0x20] // mov rax, [rsp+32]
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x38] // add rsp, 56
    rt.bytes << u8(0xc3) // ret
    fail_target := rt.bytes.len
    rt.bytes << [u8(0x31), 0xc0] // xor eax, eax
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x38] // add rsp, 56
    rt.bytes << u8(0xc3) // ret
    pe_patch_rel8(mut rt.bytes, failed, fail_target)
    pe_patch_rel8(mut rt.bytes, too_small, fail_target)
}

fn pe_emit_runtime_wgetenv(mut rt PeRuntimeText) {
    buffer_off := pe_runtime_data_alloc(mut rt, pe_wgetenv_buffer_bytes, pe_runtime_data_alignment)
    rt.bytes << [u8(0x48), 0x83, 0xec, 0x28] // sub rsp, 40
    rt.bytes << [u8(0x48), 0x85, 0xc9] // test rcx, rcx
    null_name := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    pe_emit_runtime_lea_rdx_data(mut rt, buffer_off)
    rt.bytes << [u8(0x41), 0xb8] // mov r8d, pe_wgetenv_buffer_wchars
    write_u32_le(mut rt.bytes, u32(pe_wgetenv_buffer_wchars))
    pe_emit_runtime_call_import(mut rt, 'GetEnvironmentVariableW')
    rt.bytes << [u8(0x85), 0xc0] // test eax, eax
    missing := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << u8(0x3d) // cmp eax, pe_wgetenv_buffer_wchars
    write_u32_le(mut rt.bytes, u32(pe_wgetenv_buffer_wchars))
    too_small := pe_emit_jcc8(mut rt.bytes, 0x73) // jae
    pe_emit_runtime_lea_rax_data(mut rt, buffer_off)
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x28] // add rsp, 40
    rt.bytes << u8(0xc3) // ret
    fail_target := rt.bytes.len
    rt.bytes << [u8(0x31), 0xc0] // xor eax, eax
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x28] // add rsp, 40
    rt.bytes << u8(0xc3) // ret
    pe_patch_rel8(mut rt.bytes, null_name, fail_target)
    pe_patch_rel8(mut rt.bytes, missing, fail_target)
    pe_patch_rel8(mut rt.bytes, too_small, fail_target)
}

fn pe_emit_runtime_calloc(mut rt PeRuntimeText) {
    rt.bytes << [u8(0x48), 0x89, 0xc8] // mov rax, rcx
    rt.bytes << [u8(0x48), 0xf7, 0xe2] // mul rdx
    rt.bytes << [u8(0x48), 0x85, 0xd2] // test rdx, rdx
    overflow := pe_emit_jcc8(mut rt.bytes, 0x75) // jne
    rt.bytes << [u8(0x48), 0x83, 0xec, 0x28] // sub rsp, 40
    rt.bytes << [u8(0x48), 0x89, 0x44, 0x24, 0x20] // mov [rsp+32], rax
    pe_emit_runtime_call_import(mut rt, 'GetProcessHeap')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    no_heap := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0x48), 0x89, 0xc1] // mov rcx, rax
    rt.bytes << [u8(0xba), 0x08, 0, 0, 0] // mov edx, HEAP_ZERO_MEMORY
    rt.bytes << [u8(0x4c), 0x8b, 0x44, 0x24, 0x20] // mov r8, [rsp+32]
    rt.bytes << [u8(0x49), 0x83, 0xc0, 0x18] // add r8, 24
    size_overflow := pe_emit_jcc8(mut rt.bytes, 0x72) // jc
    pe_emit_runtime_call_import(mut rt, 'HeapAlloc')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    alloc_failed := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    pe_emit_runtime_align_heap_allocated_data(mut rt)
    rt.bytes << [u8(0x4c), 0x89, 0xd8] // mov rax, r11
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x28] // add rsp, 40
    rt.bytes << u8(0xc3) // ret
    fail_with_frame := rt.bytes.len
    rt.bytes << [u8(0x31), 0xc0] // xor eax, eax
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x28] // add rsp, 40
    rt.bytes << u8(0xc3) // ret
    fail_without_frame := rt.bytes.len
    rt.bytes << [u8(0x31), 0xc0] // xor eax, eax
    rt.bytes << u8(0xc3) // ret
    pe_patch_rel8(mut rt.bytes, overflow, fail_without_frame)
    pe_patch_rel8(mut rt.bytes, no_heap, fail_with_frame)
    pe_patch_rel8(mut rt.bytes, size_overflow, fail_with_frame)
    pe_patch_rel8(mut rt.bytes, alloc_failed, fail_with_frame)
}

fn pe_emit_runtime_malloc(mut rt PeRuntimeText) {
    rt.bytes << [u8(0x48), 0x83, 0xec, 0x28] // sub rsp, 40
    rt.bytes << [u8(0x48), 0x89, 0x4c, 0x24, 0x20] // mov [rsp+32], rcx
    pe_emit_runtime_call_import(mut rt, 'GetProcessHeap')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    no_heap := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0x48), 0x89, 0xc1] // mov rcx, rax
    rt.bytes << [u8(0x31), 0xd2] // xor edx, edx
    rt.bytes << [u8(0x4c), 0x8b, 0x44, 0x24, 0x20] // mov r8, [rsp+32]
    rt.bytes << [u8(0x49), 0x83, 0xc0, 0x18] // add r8, 24
    size_overflow := pe_emit_jcc8(mut rt.bytes, 0x72) // jc
    pe_emit_runtime_call_import(mut rt, 'HeapAlloc')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    alloc_failed := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    pe_emit_runtime_align_heap_allocated_data(mut rt)
    rt.bytes << [u8(0x4c), 0x89, 0xd8] // mov rax, r11
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x28] // add rsp, 40
    rt.bytes << u8(0xc3) // ret
    fail := rt.bytes.len
    rt.bytes << [u8(0x31), 0xc0] // xor eax, eax
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x28] // add rsp, 40
    rt.bytes << u8(0xc3) // ret
    pe_patch_rel8(mut rt.bytes, no_heap, fail)
    pe_patch_rel8(mut rt.bytes, size_overflow, fail)
    pe_patch_rel8(mut rt.bytes, alloc_failed, fail)
}

fn pe_emit_runtime_free(mut rt PeRuntimeText) {
    pe_emit_runtime_aligned_free(mut rt)
}

fn pe_emit_runtime_memcmp(mut rt PeRuntimeText) {
    rt.bytes << [u8(0x4d), 0x85, 0xc0] // test r8, r8
    zero_len := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    loop_start := rt.bytes.len
    rt.bytes << [u8(0x44), 0x8a, 0x09] // mov r9b, [rcx]
    rt.bytes << [u8(0x44), 0x8a, 0x12] // mov r10b, [rdx]
    rt.bytes << [u8(0x45), 0x38, 0xd1] // cmp r9b, r10b
    diff := pe_emit_jcc8(mut rt.bytes, 0x75) // jne
    rt.bytes << [u8(0x48), 0xff, 0xc1] // inc rcx
    rt.bytes << [u8(0x48), 0xff, 0xc2] // inc rdx
    rt.bytes << [u8(0x49), 0xff, 0xc8] // dec r8
    more := pe_emit_jcc8(mut rt.bytes, 0x75) // jne
    done_equal := rt.bytes.len
    rt.bytes << [u8(0x31), 0xc0] // xor eax, eax
    rt.bytes << u8(0xc3) // ret
    diff_target := rt.bytes.len
    rt.bytes << [u8(0x41), 0x0f, 0xb6, 0xc1] // movzx eax, r9b
    rt.bytes << [u8(0x45), 0x0f, 0xb6, 0xd2] // movzx r10d, r10b
    rt.bytes << [u8(0x44), 0x29, 0xd0] // sub eax, r10d
    rt.bytes << u8(0xc3) // ret
    pe_patch_rel8(mut rt.bytes, zero_len, done_equal)
    pe_patch_rel8(mut rt.bytes, diff, diff_target)
    pe_patch_rel8(mut rt.bytes, more, loop_start)
}

fn pe_emit_runtime_atexit(mut rt PeRuntimeText, count_off u32, callbacks_off u32) {
    pe_emit_runtime_lea_rdx_data(mut rt, count_off)
    rt.bytes << [u8(0x48), 0x8b, 0x02] // mov rax, [rdx]
    rt.bytes << [u8(0x48), 0x83, 0xf8, pe_atexit_callback_capacity] // cmp rax, capacity
    overflow := pe_emit_jcc8(mut rt.bytes, 0x73) // jae
    pe_emit_runtime_lea_r8_data(mut rt, callbacks_off)
    rt.bytes << [u8(0x49), 0x89, 0x0c, 0xc0] // mov [r8 + rax * 8], rcx
    rt.bytes << [u8(0x48), 0xff, 0xc0] // inc rax
    rt.bytes << [u8(0x48), 0x89, 0x02] // mov [rdx], rax
    rt.bytes << [u8(0x31), 0xc0] // xor eax, eax
    rt.bytes << u8(0xc3) // ret
    overflow_target := rt.bytes.len
    rt.bytes << [u8(0xb8), 1, 0, 0, 0] // mov eax, 1
    rt.bytes << u8(0xc3) // ret
    pe_patch_rel8(mut rt.bytes, overflow, overflow_target)
}

fn pe_emit_runtime_run_atexit(mut rt PeRuntimeText, count_off u32, callbacks_off u32) {
    rt.bytes << [u8(0x48), 0x83, 0xec, 0x28] // sub rsp, 40
    loop_start := rt.bytes.len
    pe_emit_runtime_lea_rdx_data(mut rt, count_off)
    rt.bytes << [u8(0x48), 0x8b, 0x02] // mov rax, [rdx]
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    done := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0x48), 0xff, 0xc8] // dec rax
    rt.bytes << [u8(0x48), 0x89, 0x02] // mov [rdx], rax
    pe_emit_runtime_lea_r8_data(mut rt, callbacks_off)
    rt.bytes << [u8(0x49), 0x8b, 0x0c, 0xc0] // mov rcx, [r8 + rax * 8]
    rt.bytes << [u8(0x48), 0x85, 0xc9] // test rcx, rcx
    skip_null := pe_emit_jcc8(mut rt.bytes, 0x74) // je
    rt.bytes << [u8(0xff), 0xd1] // call rcx
    more := pe_emit_jcc8(mut rt.bytes, 0xeb) // jmp
    done_target := rt.bytes.len
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x28] // add rsp, 40
    rt.bytes << u8(0xc3) // ret
    pe_patch_rel8(mut rt.bytes, done, done_target)
    pe_patch_rel8(mut rt.bytes, skip_null, loop_start)
    pe_patch_rel8(mut rt.bytes, more, loop_start)
}

fn pe_emit_runtime_exit(mut rt PeRuntimeText, run_atexit_offset int) {
    rt.bytes << [u8(0x48), 0x83, 0xec, 0x28] // sub rsp, 40
    if run_atexit_offset >= 0 {
        rt.bytes << [u8(0x89), 0x4c, 0x24, 0x20] // mov [rsp+32], ecx
        call_field := pe_emit_call_placeholder(mut rt.bytes)
        rt.bytes << [u8(0x8b), 0x4c, 0x24, 0x20] // mov ecx, [rsp+32]
        pe_patch_rel32_local(mut rt.bytes, call_field, run_atexit_offset)
    }
    pe_emit_runtime_call_import(mut rt, 'ExitProcess')
    rt.bytes << u8(0xcc) // int3
}

fn pe_emit_runtime_exit_process_1(mut rt PeRuntimeText) {
    rt.bytes << [u8(0xb9), 0x01, 0, 0, 0] // mov ecx, 1
    pe_emit_runtime_call_import(mut rt, 'ExitProcess')
    rt.bytes << u8(0xcc) // int3
}

fn pe_emit_runtime_i64_str(mut rt PeRuntimeText) {
    rt.bytes << [u8(0x48), 0x83, 0xec, 0x58] // sub rsp, 88
    rt.bytes << [u8(0x48), 0x89, 0x4c, 0x24, 0x20] // mov [rsp+32], rcx
    rt.bytes << [u8(0x48), 0x89, 0x54, 0x24, 0x28] // mov [rsp+40], rdx
    pe_emit_runtime_call_import(mut rt, 'GetProcessHeap')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    no_heap := pe_emit_jcc32(mut rt.bytes, 0x84) // je
    rt.bytes << [u8(0x48), 0x89, 0xc1] // mov rcx, rax
    rt.bytes << [u8(0xba), 0x08, 0, 0, 0] // mov edx, HEAP_ZERO_MEMORY
    rt.bytes << [u8(0x41), 0xb8, 0x20, 0, 0, 0] // mov r8d, 32
    pe_emit_runtime_call_import(mut rt, 'HeapAlloc')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    alloc_failed := pe_emit_jcc32(mut rt.bytes, 0x84) // je
    rt.bytes << [u8(0x48), 0x89, 0x44, 0x24, 0x30] // mov [rsp+48], rax
    rt.bytes << [u8(0x4c), 0x8d, 0x40, 0x1f] // lea r8, [rax+31]
    rt.bytes << [u8(0x41), 0xc6, 0x00, 0x00] // mov byte ptr [r8], 0
    rt.bytes << [u8(0x48), 0x8b, 0x44, 0x24, 0x28] // mov rax, [rsp+40]
    rt.bytes << [u8(0x45), 0x31, 0xc9] // xor r9d, r9d
    rt.bytes << [u8(0x45), 0x31, 0xd2] // xor r10d, r10d
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    non_negative := pe_emit_jcc32(mut rt.bytes, 0x89) // jns
    rt.bytes << [u8(0x41), 0xb2, 0x01] // mov r10b, 1
    rt.bytes << [u8(0x48), 0xf7, 0xd8] // neg rax
    non_negative_target := rt.bytes.len
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    non_zero := pe_emit_jcc32(mut rt.bytes, 0x85) // jne
    rt.bytes << [u8(0x49), 0xff, 0xc8] // dec r8
    rt.bytes << [u8(0x41), 0xc6, 0x00, 0x30] // mov byte ptr [r8], '0'
    rt.bytes << [u8(0x41), 0xb9, 0x01, 0, 0, 0] // mov r9d, 1
    maybe_sign_jump := pe_emit_jmp32(mut rt.bytes)
    loop_start := rt.bytes.len
    rt.bytes << [u8(0x31), 0xd2] // xor edx, edx
    rt.bytes << [u8(0xb9), 0x0a, 0, 0, 0] // mov ecx, 10
    rt.bytes << [u8(0x48), 0xf7, 0xf1] // div rcx
    rt.bytes << [u8(0x80), 0xc2, 0x30] // add dl, '0'
    rt.bytes << [u8(0x49), 0xff, 0xc8] // dec r8
    rt.bytes << [u8(0x41), 0x88, 0x10] // mov [r8], dl
    rt.bytes << [u8(0x49), 0xff, 0xc1] // inc r9
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    loop_more := pe_emit_jcc32(mut rt.bytes, 0x85) // jne
    maybe_sign := rt.bytes.len
    rt.bytes << [u8(0x45), 0x84, 0xd2] // test r10b, r10b
    done_digits := pe_emit_jcc32(mut rt.bytes, 0x84) // je
    rt.bytes << [u8(0x49), 0xff, 0xc8] // dec r8
    rt.bytes << [u8(0x41), 0xc6, 0x00, 0x2d] // mov byte ptr [r8], '-'
    rt.bytes << [u8(0x49), 0xff, 0xc1] // inc r9
    done_digits_target := rt.bytes.len
    rt.bytes << [u8(0x48), 0x8b, 0x54, 0x24, 0x20] // mov rdx, [rsp+32]
    rt.bytes << [u8(0x4c), 0x89, 0x02] // mov [rdx], r8
    rt.bytes << [u8(0x44), 0x89, 0x4a, 0x08] // mov [rdx+8], r9d
    rt.bytes << [u8(0xc7), 0x42, 0x0c, 0, 0, 0, 0] // mov dword ptr [rdx+12], 0
    rt.bytes << [u8(0x48), 0x89, 0xd0] // mov rax, rdx
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x58] // add rsp, 88
    rt.bytes << u8(0xc3) // ret
    fail := rt.bytes.len
    pe_emit_runtime_exit_process_1(mut rt)
    pe_patch_rel32_local(mut rt.bytes, no_heap, fail)
    pe_patch_rel32_local(mut rt.bytes, alloc_failed, fail)
    pe_patch_rel32_local(mut rt.bytes, non_negative, non_negative_target)
    pe_patch_rel32_local(mut rt.bytes, non_zero, loop_start)
    pe_patch_rel32_local(mut rt.bytes, maybe_sign_jump, maybe_sign)
    pe_patch_rel32_local(mut rt.bytes, loop_more, loop_start)
    pe_patch_rel32_local(mut rt.bytes, done_digits, done_digits_target)
}

fn pe_emit_runtime_string_plus(mut rt PeRuntimeText) {
    rt.bytes << [u8(0x48), 0x83, 0xec, 0x68] // sub rsp, 104
    rt.bytes << [u8(0x48), 0x89, 0x4c, 0x24, 0x20] // mov [rsp+32], rcx
    rt.bytes << [u8(0x48), 0x89, 0x54, 0x24, 0x28] // mov [rsp+40], rdx
    rt.bytes << [u8(0x4c), 0x89, 0x44, 0x24, 0x30] // mov [rsp+48], r8
    rt.bytes << [u8(0x44), 0x8b, 0x4a, 0x08] // mov r9d, [rdx+8]
    rt.bytes << [u8(0x45), 0x03, 0x48, 0x08] // add r9d, [r8+8]
    len_overflow := pe_emit_jcc32(mut rt.bytes, 0x82) // jc
    rt.bytes << [u8(0x4c), 0x89, 0x4c, 0x24, 0x38] // mov [rsp+56], r9
    rt.bytes << [u8(0x45), 0x89, 0xc8] // mov r8d, r9d
    rt.bytes << [u8(0x49), 0x83, 0xc0, 0x01] // add r8, 1
    alloc_overflow := pe_emit_jcc32(mut rt.bytes, 0x82) // jc
    rt.bytes << [u8(0x4c), 0x89, 0x44, 0x24, 0x40] // mov [rsp+64], r8
    pe_emit_runtime_call_import(mut rt, 'GetProcessHeap')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    no_heap := pe_emit_jcc32(mut rt.bytes, 0x84) // je
    rt.bytes << [u8(0x48), 0x89, 0xc1] // mov rcx, rax
    rt.bytes << [u8(0xba), 0x08, 0, 0, 0] // mov edx, HEAP_ZERO_MEMORY
    rt.bytes << [u8(0x4c), 0x8b, 0x44, 0x24, 0x40] // mov r8, [rsp+64]
    pe_emit_runtime_call_import(mut rt, 'HeapAlloc')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    alloc_failed := pe_emit_jcc32(mut rt.bytes, 0x84) // je
    rt.bytes << [u8(0x48), 0x89, 0x44, 0x24, 0x48] // mov [rsp+72], rax
    rt.bytes << [u8(0x48), 0x8b, 0x54, 0x24, 0x28] // mov rdx, [rsp+40]
    rt.bytes << [u8(0x4c), 0x8b, 0x12] // mov r10, [rdx]
    rt.bytes << [u8(0x44), 0x8b, 0x5a, 0x08] // mov r11d, [rdx+8]
    rt.bytes << [u8(0x48), 0x89, 0xc1] // mov rcx, rax
    rt.bytes << [u8(0x4d), 0x85, 0xdb] // test r11, r11
    copy_a_done := pe_emit_jcc32(mut rt.bytes, 0x84) // je
    copy_a_loop := rt.bytes.len
    rt.bytes << [u8(0x45), 0x8a, 0x0a] // mov r9b, [r10]
    rt.bytes << [u8(0x44), 0x88, 0x09] // mov [rcx], r9b
    rt.bytes << [u8(0x49), 0xff, 0xc2] // inc r10
    rt.bytes << [u8(0x48), 0xff, 0xc1] // inc rcx
    rt.bytes << [u8(0x49), 0xff, 0xcb] // dec r11
    copy_a_more := pe_emit_jcc32(mut rt.bytes, 0x85) // jne
    copy_a_done_target := rt.bytes.len
    rt.bytes << [u8(0x4c), 0x8b, 0x44, 0x24, 0x30] // mov r8, [rsp+48]
    rt.bytes << [u8(0x4d), 0x8b, 0x10] // mov r10, [r8]
    rt.bytes << [u8(0x45), 0x8b, 0x58, 0x08] // mov r11d, [r8+8]
    rt.bytes << [u8(0x4d), 0x85, 0xdb] // test r11, r11
    copy_b_done := pe_emit_jcc32(mut rt.bytes, 0x84) // je
    copy_b_loop := rt.bytes.len
    rt.bytes << [u8(0x45), 0x8a, 0x0a] // mov r9b, [r10]
    rt.bytes << [u8(0x44), 0x88, 0x09] // mov [rcx], r9b
    rt.bytes << [u8(0x49), 0xff, 0xc2] // inc r10
    rt.bytes << [u8(0x48), 0xff, 0xc1] // inc rcx
    rt.bytes << [u8(0x49), 0xff, 0xcb] // dec r11
    copy_b_more := pe_emit_jcc32(mut rt.bytes, 0x85) // jne
    copy_b_done_target := rt.bytes.len
    rt.bytes << [u8(0xc6), 0x01, 0x00] // mov byte ptr [rcx], 0
    rt.bytes << [u8(0x48), 0x8b, 0x54, 0x24, 0x20] // mov rdx, [rsp+32]
    rt.bytes << [u8(0x48), 0x8b, 0x44, 0x24, 0x48] // mov rax, [rsp+72]
    rt.bytes << [u8(0x48), 0x89, 0x02] // mov [rdx], rax
    rt.bytes << [u8(0x8b), 0x44, 0x24, 0x38] // mov eax, [rsp+56]
    rt.bytes << [u8(0x89), 0x42, 0x08] // mov [rdx+8], eax
    rt.bytes << [u8(0xc7), 0x42, 0x0c, 0, 0, 0, 0] // mov dword ptr [rdx+12], 0
    rt.bytes << [u8(0x48), 0x89, 0xd0] // mov rax, rdx
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x68] // add rsp, 104
    rt.bytes << u8(0xc3) // ret
    fail := rt.bytes.len
    pe_emit_runtime_exit_process_1(mut rt)
    pe_patch_rel32_local(mut rt.bytes, len_overflow, fail)
    pe_patch_rel32_local(mut rt.bytes, alloc_overflow, fail)
    pe_patch_rel32_local(mut rt.bytes, no_heap, fail)
    pe_patch_rel32_local(mut rt.bytes, alloc_failed, fail)
    pe_patch_rel32_local(mut rt.bytes, copy_a_done, copy_a_done_target)
    pe_patch_rel32_local(mut rt.bytes, copy_a_more, copy_a_loop)
    pe_patch_rel32_local(mut rt.bytes, copy_b_done, copy_b_done_target)
    pe_patch_rel32_local(mut rt.bytes, copy_b_more, copy_b_loop)
}

fn pe_emit_runtime_errno(mut rt PeRuntimeText) {
    errno_off := pe_runtime_data_alloc(mut rt, 4, 4)
    pe_emit_runtime_lea_rax_data(mut rt, errno_off)
    rt.bytes << u8(0xc3) // ret
}

fn pe_emit_runtime_new_array_from_c_array_noscan(mut rt PeRuntimeText) {
    rt.bytes << [u8(0x48), 0x83, 0xec, 0x58] // sub rsp, 88
    rt.bytes << [u8(0x48), 0x89, 0x4c, 0x24, 0x20] // mov [rsp+32], rcx
    rt.bytes << [u8(0x48), 0x89, 0x54, 0x24, 0x28] // mov [rsp+40], rdx
    rt.bytes << [u8(0x4c), 0x89, 0x44, 0x24, 0x30] // mov [rsp+48], r8
    rt.bytes << [u8(0x4c), 0x89, 0x4c, 0x24, 0x38] // mov [rsp+56], r9
    rt.bytes << [u8(0x48), 0x8b, 0x84, 0x24, 0x80, 0, 0, 0] // mov rax, [rsp+128]
    rt.bytes << [u8(0x48), 0x89, 0x44, 0x24, 0x40] // mov [rsp+64], rax
    rt.bytes << [u8(0x48), 0xc7, 0x01, 0, 0, 0, 0] // mov qword ptr [rcx], 0
    rt.bytes << [u8(0x48), 0xc7, 0x41, 0x08, 0, 0, 0, 0] // mov qword ptr [rcx+8], 0
    rt.bytes << [u8(0x48), 0xc7, 0x41, 0x10, 0, 0, 0, 0] // mov qword ptr [rcx+16], 0
    rt.bytes << [u8(0x48), 0xc7, 0x41, 0x18, 0, 0, 0, 0] // mov qword ptr [rcx+24], 0
    rt.bytes << [u8(0x83), 0xfa, 0x00] // cmp edx, 0
    negative_len := pe_emit_jcc32(mut rt.bytes, 0x8c) // jl
    rt.bytes << [u8(0x41), 0x83, 0xf8, 0x00] // cmp r8d, 0
    negative_cap := pe_emit_jcc32(mut rt.bytes, 0x8c) // jl
    rt.bytes << [u8(0x41), 0x83, 0xf9, 0x00] // cmp r9d, 0
    negative_elem_size := pe_emit_jcc32(mut rt.bytes, 0x8c) // jl
    rt.bytes << [u8(0x45), 0x89, 0xc2] // mov r10d, r8d
    rt.bytes << [u8(0x41), 0x39, 0xd2] // cmp r10d, edx
    cap_ready := pe_emit_jcc8(mut rt.bytes, 0x7d) // jge
    rt.bytes << [u8(0x41), 0x89, 0xd2] // mov r10d, edx
    cap_ready_target := rt.bytes.len
    rt.bytes << [u8(0x4c), 0x89, 0x54, 0x24, 0x48] // mov [rsp+72], r10
    rt.bytes << [u8(0x49), 0x63, 0xc2] // movsxd rax, r10d
    rt.bytes << [u8(0x4d), 0x63, 0xd9] // movsxd r11, r9d
    rt.bytes << [u8(0x49), 0x0f, 0xaf, 0xc3] // imul rax, r11
    rt.bytes << [u8(0x49), 0x89, 0xc0] // mov r8, rax
    rt.bytes << [u8(0x4d), 0x85, 0xc0] // test r8, r8
    payload_nonzero := pe_emit_jcc8(mut rt.bytes, 0x75) // jne
    rt.bytes << [u8(0x41), 0xb8, 0x01, 0, 0, 0] // mov r8d, 1
    payload_nonzero_target := rt.bytes.len
    rt.bytes << [u8(0x49), 0x83, 0xc0, 0x20] // add r8, 32
    allocation_overflow := pe_emit_jcc32(mut rt.bytes, 0x82) // jc
    rt.bytes << [u8(0x4c), 0x89, 0x44, 0x24, 0x50] // mov [rsp+80], r8
    pe_emit_runtime_call_import(mut rt, 'GetProcessHeap')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    no_heap := pe_emit_jcc32(mut rt.bytes, 0x84) // je
    rt.bytes << [u8(0x48), 0x89, 0xc1] // mov rcx, rax
    rt.bytes << [u8(0xba), 0x08, 0, 0, 0] // mov edx, HEAP_ZERO_MEMORY
    rt.bytes << [u8(0x4c), 0x8b, 0x44, 0x24, 0x50] // mov r8, [rsp+80]
    pe_emit_runtime_call_import(mut rt, 'HeapAlloc')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    alloc_failed := pe_emit_jcc32(mut rt.bytes, 0x84) // je
    pe_emit_runtime_align_heap_allocated_data(mut rt)
    rt.bytes << [u8(0x41), 0xc6, 0x03, 0] // mov byte ptr [r11], 0 ; ArrayDataHeader.has_slices = false
    rt.bytes << [u8(0x48), 0x8b, 0x4c, 0x24, 0x20] // mov rcx, [rsp+32]
    rt.bytes << [u8(0x49), 0x8d, 0x43, 0x08] // lea rax, [r11+8]
    rt.bytes << [u8(0x48), 0x89, 0x01] // mov [rcx], rax
    rt.bytes << [u8(0xc7), 0x41, 0x08, 0, 0, 0, 0] // mov dword ptr [rcx+8], 0
    rt.bytes << [u8(0x8b), 0x44, 0x24, 0x28] // mov eax, [rsp+40]
    rt.bytes << [u8(0x89), 0x41, 0x0c] // mov [rcx+12], eax
    rt.bytes << [u8(0x8b), 0x44, 0x24, 0x48] // mov eax, [rsp+72]
    rt.bytes << [u8(0x89), 0x41, 0x10] // mov [rcx+16], eax
    rt.bytes << [u8(0xc7), 0x41, 0x14, 0x30, 0, 0, 0] // mov dword ptr [rcx+20], 48
    rt.bytes << [u8(0x8b), 0x44, 0x24, 0x38] // mov eax, [rsp+56]
    rt.bytes << [u8(0x89), 0x41, 0x18] // mov [rcx+24], eax
    rt.bytes << [u8(0x48), 0x63, 0x44, 0x24, 0x28] // movsxd rax, dword ptr [rsp+40]
    rt.bytes << [u8(0x4c), 0x63, 0x54, 0x24, 0x38] // movsxd r10, dword ptr [rsp+56]
    rt.bytes << [u8(0x49), 0x0f, 0xaf, 0xc2] // imul rax, r10
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    no_copy := pe_emit_jcc32(mut rt.bytes, 0x8e) // jle
    rt.bytes << [u8(0x4c), 0x8b, 0x54, 0x24, 0x40] // mov r10, [rsp+64]
    rt.bytes << [u8(0x4d), 0x85, 0xd2] // test r10, r10
    null_source := pe_emit_jcc32(mut rt.bytes, 0x84) // je
    rt.bytes << [u8(0x4d), 0x8d, 0x43, 0x08] // lea r8, [r11+8]
    copy_loop := rt.bytes.len
    rt.bytes << [u8(0x41), 0x8a, 0x12] // mov dl, [r10]
    rt.bytes << [u8(0x41), 0x88, 0x10] // mov [r8], dl
    rt.bytes << [u8(0x49), 0xff, 0xc2] // inc r10
    rt.bytes << [u8(0x49), 0xff, 0xc0] // inc r8
    rt.bytes << [u8(0x48), 0xff, 0xc8] // dec rax
    copy_more := pe_emit_jcc8(mut rt.bytes, 0x75) // jne
    done := rt.bytes.len
    rt.bytes << [u8(0x48), 0x8b, 0x44, 0x24, 0x20] // mov rax, [rsp+32]
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x58] // add rsp, 88
    rt.bytes << u8(0xc3) // ret
    fail := rt.bytes.len
    rt.bytes << [u8(0x48), 0x8b, 0x44, 0x24, 0x20] // mov rax, [rsp+32]
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x58] // add rsp, 88
    rt.bytes << u8(0xc3) // ret
    pe_patch_rel32_local(mut rt.bytes, negative_len, fail)
    pe_patch_rel32_local(mut rt.bytes, negative_cap, fail)
    pe_patch_rel32_local(mut rt.bytes, negative_elem_size, fail)
    pe_patch_rel8(mut rt.bytes, cap_ready, cap_ready_target)
    pe_patch_rel8(mut rt.bytes, payload_nonzero, payload_nonzero_target)
    pe_patch_rel32_local(mut rt.bytes, allocation_overflow, fail)
    pe_patch_rel32_local(mut rt.bytes, no_heap, fail)
    pe_patch_rel32_local(mut rt.bytes, alloc_failed, fail)
    pe_patch_rel32_local(mut rt.bytes, no_copy, done)
    pe_patch_rel32_local(mut rt.bytes, null_source, done)
    pe_patch_rel8(mut rt.bytes, copy_more, copy_loop)
}

fn pe_emit_runtime_new_array_noscan(mut rt PeRuntimeText) {
    rt.bytes << [u8(0x48), 0x83, 0xec, 0x58] // sub rsp, 88
    rt.bytes << [u8(0x48), 0x89, 0x4c, 0x24, 0x20] // mov [rsp+32], rcx
    rt.bytes << [u8(0x48), 0x89, 0x54, 0x24, 0x28] // mov [rsp+40], rdx
    rt.bytes << [u8(0x4c), 0x89, 0x44, 0x24, 0x30] // mov [rsp+48], r8
    rt.bytes << [u8(0x4c), 0x89, 0x4c, 0x24, 0x38] // mov [rsp+56], r9
    rt.bytes << [u8(0x48), 0xc7, 0x01, 0, 0, 0, 0] // mov qword ptr [rcx], 0
    rt.bytes << [u8(0x48), 0xc7, 0x41, 0x08, 0, 0, 0, 0] // mov qword ptr [rcx+8], 0
    rt.bytes << [u8(0x48), 0xc7, 0x41, 0x10, 0, 0, 0, 0] // mov qword ptr [rcx+16], 0
    rt.bytes << [u8(0x48), 0xc7, 0x41, 0x18, 0, 0, 0, 0] // mov qword ptr [rcx+24], 0
    rt.bytes << [u8(0x83), 0xfa, 0x00] // cmp edx, 0
    negative_len := pe_emit_jcc32(mut rt.bytes, 0x8c) // jl
    rt.bytes << [u8(0x41), 0x83, 0xf8, 0x00] // cmp r8d, 0
    negative_cap := pe_emit_jcc32(mut rt.bytes, 0x8c) // jl
    rt.bytes << [u8(0x41), 0x83, 0xf9, 0x00] // cmp r9d, 0
    negative_elem_size := pe_emit_jcc32(mut rt.bytes, 0x8c) // jl
    rt.bytes << [u8(0x45), 0x89, 0xc2] // mov r10d, r8d
    rt.bytes << [u8(0x41), 0x39, 0xd2] // cmp r10d, edx
    cap_ready := pe_emit_jcc8(mut rt.bytes, 0x7d) // jge
    rt.bytes << [u8(0x41), 0x89, 0xd2] // mov r10d, edx
    cap_ready_target := rt.bytes.len
    rt.bytes << [u8(0x4c), 0x89, 0x54, 0x24, 0x40] // mov [rsp+64], r10
    rt.bytes << [u8(0x49), 0x63, 0xc2] // movsxd rax, r10d
    rt.bytes << [u8(0x4d), 0x63, 0xd9] // movsxd r11, r9d
    rt.bytes << [u8(0x49), 0x0f, 0xaf, 0xc3] // imul rax, r11
    rt.bytes << [u8(0x49), 0x89, 0xc0] // mov r8, rax
    rt.bytes << [u8(0x4d), 0x85, 0xc0] // test r8, r8
    payload_nonzero := pe_emit_jcc8(mut rt.bytes, 0x75) // jne
    rt.bytes << [u8(0x41), 0xb8, 0x01, 0, 0, 0] // mov r8d, 1
    payload_nonzero_target := rt.bytes.len
    rt.bytes << [u8(0x49), 0x83, 0xc0, 0x20] // add r8, 32
    allocation_overflow := pe_emit_jcc32(mut rt.bytes, 0x82) // jc
    rt.bytes << [u8(0x4c), 0x89, 0x44, 0x24, 0x48] // mov [rsp+72], r8
    pe_emit_runtime_call_import(mut rt, 'GetProcessHeap')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    no_heap := pe_emit_jcc32(mut rt.bytes, 0x84) // je
    rt.bytes << [u8(0x48), 0x89, 0xc1] // mov rcx, rax
    rt.bytes << [u8(0xba), 0x08, 0, 0, 0] // mov edx, HEAP_ZERO_MEMORY
    rt.bytes << [u8(0x4c), 0x8b, 0x44, 0x24, 0x48] // mov r8, [rsp+72]
    pe_emit_runtime_call_import(mut rt, 'HeapAlloc')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    alloc_failed := pe_emit_jcc32(mut rt.bytes, 0x84) // je
    pe_emit_runtime_align_heap_allocated_data(mut rt)
    rt.bytes << [u8(0x41), 0xc6, 0x03, 0] // mov byte ptr [r11], 0 ; ArrayDataHeader.has_slices = false
    rt.bytes << [u8(0x48), 0x8b, 0x4c, 0x24, 0x20] // mov rcx, [rsp+32]
    rt.bytes << [u8(0x49), 0x8d, 0x43, 0x08] // lea rax, [r11+8]
    rt.bytes << [u8(0x48), 0x89, 0x01] // mov [rcx], rax
    rt.bytes << [u8(0xc7), 0x41, 0x08, 0, 0, 0, 0] // mov dword ptr [rcx+8], 0
    rt.bytes << [u8(0x8b), 0x44, 0x24, 0x28] // mov eax, [rsp+40]
    rt.bytes << [u8(0x89), 0x41, 0x0c] // mov [rcx+12], eax
    rt.bytes << [u8(0x8b), 0x44, 0x24, 0x40] // mov eax, [rsp+64]
    rt.bytes << [u8(0x89), 0x41, 0x10] // mov [rcx+16], eax
    rt.bytes << [u8(0xc7), 0x41, 0x14, 0x30, 0, 0, 0] // mov dword ptr [rcx+20], 48
    rt.bytes << [u8(0x8b), 0x44, 0x24, 0x38] // mov eax, [rsp+56]
    rt.bytes << [u8(0x89), 0x41, 0x18] // mov [rcx+24], eax
    rt.bytes << [u8(0x48), 0x8b, 0x44, 0x24, 0x20] // mov rax, [rsp+32]
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x58] // add rsp, 88
    rt.bytes << u8(0xc3) // ret
    fail := rt.bytes.len
    rt.bytes << [u8(0x48), 0x8b, 0x44, 0x24, 0x20] // mov rax, [rsp+32]
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x58] // add rsp, 88
    rt.bytes << u8(0xc3) // ret
    pe_patch_rel32_local(mut rt.bytes, negative_len, fail)
    pe_patch_rel32_local(mut rt.bytes, negative_cap, fail)
    pe_patch_rel32_local(mut rt.bytes, negative_elem_size, fail)
    pe_patch_rel8(mut rt.bytes, cap_ready, cap_ready_target)
    pe_patch_rel8(mut rt.bytes, payload_nonzero, payload_nonzero_target)
    pe_patch_rel32_local(mut rt.bytes, allocation_overflow, fail)
    pe_patch_rel32_local(mut rt.bytes, no_heap, fail)
    pe_patch_rel32_local(mut rt.bytes, alloc_failed, fail)
}

fn pe_emit_runtime_array_rune_string(mut rt PeRuntimeText) {
    rt.bytes << [u8(0x48), 0x83, 0xec, 0x58] // sub rsp, 88
    rt.bytes << [u8(0x48), 0x89, 0x4c, 0x24, 0x20] // mov [rsp+32], rcx
    rt.bytes << [u8(0x48), 0x89, 0x54, 0x24, 0x28] // mov [rsp+40], rdx
    rt.bytes << [u8(0x48), 0xc7, 0x01, 0, 0, 0, 0] // mov qword ptr [rcx], 0
    rt.bytes << [u8(0x48), 0xc7, 0x41, 0x08, 0, 0, 0, 0] // mov qword ptr [rcx+8], 0
    rt.bytes << [u8(0x48), 0x85, 0xd2] // test rdx, rdx
    null_array := pe_emit_jcc32(mut rt.bytes, 0x84) // je
    rt.bytes << [u8(0x48), 0x63, 0x42, 0x0c] // movsxd rax, dword ptr [rdx+12]
    rt.bytes << [u8(0x48), 0x89, 0x44, 0x24, 0x30] // mov [rsp+48], rax
    rt.bytes << [u8(0x48), 0x8b, 0x02] // mov rax, [rdx]
    rt.bytes << [u8(0x4c), 0x63, 0x52, 0x08] // movsxd r10, dword ptr [rdx+8]
    rt.bytes << [u8(0x4c), 0x01, 0xd0] // add rax, r10
    rt.bytes << [u8(0x48), 0x89, 0x44, 0x24, 0x38] // mov [rsp+56], rax
    rt.bytes << [u8(0x4c), 0x8b, 0x44, 0x24, 0x30] // mov r8, [rsp+48]
    rt.bytes << [u8(0x4d), 0x85, 0xc0] // test r8, r8
    positive_size := pe_emit_jcc32(mut rt.bytes, 0x8f) // jg
    rt.bytes << [u8(0x41), 0xb8, 0x01, 0, 0, 0] // mov r8d, 1
    size_ready_jump := pe_emit_jmp32(mut rt.bytes)
    positive_size_target := rt.bytes.len
    rt.bytes << [u8(0x49), 0xc1, 0xe0, 0x02] // shl r8, 2
    rt.bytes << [u8(0x49), 0x83, 0xc0, 0x01] // add r8, 1
    size_ready := rt.bytes.len
    rt.bytes << [u8(0x49), 0x83, 0xc0, 0x18] // add r8, 24
    allocation_overflow := pe_emit_jcc32(mut rt.bytes, 0x82) // jc
    rt.bytes << [u8(0x4c), 0x89, 0x44, 0x24, 0x50] // mov [rsp+80], r8
    pe_emit_runtime_call_import(mut rt, 'GetProcessHeap')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    no_heap := pe_emit_jcc32(mut rt.bytes, 0x84) // je
    rt.bytes << [u8(0x48), 0x89, 0xc1] // mov rcx, rax
    rt.bytes << [u8(0x31), 0xd2] // xor edx, edx
    rt.bytes << [u8(0x4c), 0x8b, 0x44, 0x24, 0x50] // mov r8, [rsp+80]
    pe_emit_runtime_call_import(mut rt, 'HeapAlloc')
    rt.bytes << [u8(0x48), 0x85, 0xc0] // test rax, rax
    alloc_failed := pe_emit_jcc32(mut rt.bytes, 0x84) // je
    pe_emit_runtime_align_heap_allocated_data(mut rt)
    rt.bytes << [u8(0x4c), 0x89, 0x5c, 0x24, 0x40] // mov [rsp+64], r11
    rt.bytes << [u8(0x48), 0x8b, 0x4c, 0x24, 0x30] // mov rcx, [rsp+48]
    rt.bytes << [u8(0x48), 0x85, 0xc9] // test rcx, rcx
    no_input := pe_emit_jcc32(mut rt.bytes, 0x8e) // jle
    rt.bytes << [u8(0x48), 0x8b, 0x54, 0x24, 0x38] // mov rdx, [rsp+56]
    rt.bytes << [u8(0x48), 0x85, 0xd2] // test rdx, rdx
    no_data := pe_emit_jcc32(mut rt.bytes, 0x84) // je
    loop_start := rt.bytes.len
    rt.bytes << [u8(0x8b), 0x02] // mov eax, [rdx]
    rt.bytes << [u8(0x48), 0x83, 0xc2, 0x04] // add rdx, 4
    rt.bytes << [u8(0x83), 0xf8, 0x7f] // cmp eax, 0x7f
    two_byte_check := pe_emit_jcc32(mut rt.bytes, 0x87) // ja
    rt.bytes << [u8(0x41), 0x88, 0x03] // mov [r11], al
    rt.bytes << [u8(0x49), 0xff, 0xc3] // inc r11
    after_one := pe_emit_jmp32(mut rt.bytes)
    two_byte_target := rt.bytes.len
    rt.bytes << [u8(0x3d), 0xff, 0x07, 0, 0] // cmp eax, 0x7ff
    three_byte_check := pe_emit_jcc32(mut rt.bytes, 0x87) // ja
    rt.bytes << [u8(0x41), 0x89, 0xc1, 0x41, 0xc1, 0xe9, 0x06, 0x41, 0x80, 0xc9, 0xc0, 0x45, 0x88,
        0x0b, 0x41, 0x89, 0xc1, 0x41, 0x80, 0xe1, 0x3f, 0x41, 0x80, 0xc9, 0x80, 0x45, 0x88, 0x4b,
        0x01, 0x49, 0x83, 0xc3, 0x02]
    after_two := pe_emit_jmp32(mut rt.bytes)
    three_byte_target := rt.bytes.len
    rt.bytes << [u8(0x3d), 0x00, 0xd8, 0, 0] // cmp eax, 0xd800
    valid_three := pe_emit_jcc32(mut rt.bytes, 0x82) // jb
    rt.bytes << [u8(0x3d), 0xff, 0xdf, 0, 0] // cmp eax, 0xdfff
    skip_surrogate := pe_emit_jcc32(mut rt.bytes, 0x86) // jbe
    valid_three_target := rt.bytes.len
    rt.bytes << [u8(0x3d), 0xff, 0xff, 0, 0] // cmp eax, 0xffff
    four_byte_check := pe_emit_jcc32(mut rt.bytes, 0x87) // ja
    rt.bytes << [u8(0x41), 0x89, 0xc1, 0x41, 0xc1, 0xe9, 0x0c, 0x41, 0x80, 0xc9, 0xe0, 0x45, 0x88,
        0x0b, 0x41, 0x89, 0xc1, 0x41, 0xc1, 0xe9, 0x06, 0x41, 0x80, 0xe1, 0x3f, 0x41, 0x80, 0xc9,
        0x80, 0x45, 0x88, 0x4b, 0x01, 0x41, 0x89, 0xc1, 0x41, 0x80, 0xe1, 0x3f, 0x41, 0x80, 0xc9,
        0x80, 0x45, 0x88, 0x4b, 0x02, 0x49, 0x83, 0xc3, 0x03]
    after_three := pe_emit_jmp32(mut rt.bytes)
    four_byte_target := rt.bytes.len
    rt.bytes << [u8(0x3d), 0xff, 0xff, 0x10, 0] // cmp eax, 0x10ffff
    skip_large := pe_emit_jcc32(mut rt.bytes, 0x87) // ja
    rt.bytes << [u8(0x41), 0x89, 0xc1, 0x41, 0xc1, 0xe9, 0x12, 0x41, 0x80, 0xc9, 0xf0, 0x45, 0x88,
        0x0b, 0x41, 0x89, 0xc1, 0x41, 0xc1, 0xe9, 0x0c, 0x41, 0x80, 0xe1, 0x3f, 0x41, 0x80, 0xc9,
        0x80, 0x45, 0x88, 0x4b, 0x01, 0x41, 0x89, 0xc1, 0x41, 0xc1, 0xe9, 0x06, 0x41, 0x80, 0xe1,
        0x3f, 0x41, 0x80, 0xc9, 0x80, 0x45, 0x88, 0x4b, 0x02, 0x41, 0x89, 0xc1, 0x41, 0x80, 0xe1,
        0x3f, 0x41, 0x80, 0xc9, 0x80, 0x45, 0x88, 0x4b, 0x03, 0x49, 0x83, 0xc3, 0x04]
    after_emit := rt.bytes.len
    rt.bytes << [u8(0x48), 0xff, 0xc9] // dec rcx
    more := pe_emit_jcc32(mut rt.bytes, 0x85) // jne
    finish := rt.bytes.len
    rt.bytes << [u8(0x41), 0xc6, 0x03, 0x00] // mov byte ptr [r11], 0
    rt.bytes << [u8(0x48), 0x8b, 0x4c, 0x24, 0x20] // mov rcx, [rsp+32]
    rt.bytes << [u8(0x48), 0x8b, 0x44, 0x24, 0x40] // mov rax, [rsp+64]
    rt.bytes << [u8(0x48), 0x89, 0x01] // mov [rcx], rax
    rt.bytes << [u8(0x4c), 0x89, 0xda] // mov rdx, r11
    rt.bytes << [u8(0x48), 0x29, 0xc2] // sub rdx, rax
    rt.bytes << [u8(0x89), 0x51, 0x08] // mov [rcx+8], edx
    rt.bytes << [u8(0xc7), 0x41, 0x0c, 0, 0, 0, 0] // mov dword ptr [rcx+12], 0
    rt.bytes << [u8(0x48), 0x89, 0xc8] // mov rax, rcx
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x58] // add rsp, 88
    rt.bytes << u8(0xc3) // ret
    fail := rt.bytes.len
    rt.bytes << [u8(0x48), 0x8b, 0x44, 0x24, 0x20] // mov rax, [rsp+32]
    rt.bytes << [u8(0x48), 0x83, 0xc4, 0x58] // add rsp, 88
    rt.bytes << u8(0xc3) // ret
    pe_patch_rel32_local(mut rt.bytes, null_array, fail)
    pe_patch_rel32_local(mut rt.bytes, positive_size, positive_size_target)
    pe_patch_rel32_local(mut rt.bytes, size_ready_jump, size_ready)
    pe_patch_rel32_local(mut rt.bytes, allocation_overflow, fail)
    pe_patch_rel32_local(mut rt.bytes, no_heap, fail)
    pe_patch_rel32_local(mut rt.bytes, alloc_failed, fail)
    pe_patch_rel32_local(mut rt.bytes, no_input, finish)
    pe_patch_rel32_local(mut rt.bytes, no_data, finish)
    pe_patch_rel32_local(mut rt.bytes, two_byte_check, two_byte_target)
    pe_patch_rel32_local(mut rt.bytes, after_one, after_emit)
    pe_patch_rel32_local(mut rt.bytes, three_byte_check, three_byte_target)
    pe_patch_rel32_local(mut rt.bytes, after_two, after_emit)
    pe_patch_rel32_local(mut rt.bytes, valid_three, valid_three_target)
    pe_patch_rel32_local(mut rt.bytes, skip_surrogate, after_emit)
    pe_patch_rel32_local(mut rt.bytes, four_byte_check, four_byte_target)
    pe_patch_rel32_local(mut rt.bytes, after_three, after_emit)
    pe_patch_rel32_local(mut rt.bytes, skip_large, after_emit)
    pe_patch_rel32_local(mut rt.bytes, more, loop_start)
}

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

fn pe_put_u32_le(mut data []u8, off int, v u32) {
    data[off] = u8(v)
    data[off + 1] = u8(v >> 8)
    data[off + 2] = u8(v >> 16)
    data[off + 3] = u8(v >> 24)
}

fn pe_put_u64_le(mut data []u8, off int, v u64) {
    pe_put_u32_le(mut data, off, u32(v))
    pe_put_u32_le(mut data, off + 4, u32(v >> 32))
}