// 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 encoding.binary
import os

const linux_tiny_base_vaddr = u64(0x400000)
const linux_tiny_page_align = 0x1000
const linux_sys_mmap = u32(9)
const linux_sys_write = u32(1)
const linux_sys_exit_group = u32(231)
const linux_mmap_prot_read_write = u32(0x3)
const linux_mmap_private_anonymous = u32(0x22)
const linux_tiny_int_str_arena_bytes = u32(4096)
const linux_tiny_int_str_slot_bytes = 32
const linux_tiny_int_str_arena_metadata_bytes = 16
const linux_tiny_rune_str_arena_bytes = u32(4096)
const linux_tiny_rune_str_slot_bytes = 8
const linux_tiny_rune_str_arena_metadata_bytes = 16
const linux_tiny_string_plus_arena_bytes = u32(4096)
const linux_tiny_string_plus_arena_metadata_bytes = 16

pub const linux_tiny_not_eligible_prefix = 'Linux tiny executable is not eligible: '

struct ElfTextRange {
    name  string
    start u64
    end   u64
}

struct ElfDataRange {
    section ObjectSection
    start   u64
    end     u64
}

struct ElfTinyRuntime {
mut:
    text                      []u8
    symbols                   map[string]u64
    int_str_arena_patches     []int
    rune_str_arena_patches    []int
    string_plus_arena_patches []int
}

struct ElfTinyReachable {
    names           []string
    data            []ElfDataRange
    runtime_symbols map[string]bool
}

struct ElfTinyLinker {
    elf &ElfObject
}

pub fn (mut g Gen) link_linux_tiny_executable(path string) ! {
    if g.obj_format != .elf {
        return error('Linux tiny executable linking requires ELF object output')
    }
    if g.abi != .sysv {
        return error('Linux tiny executable linking requires SysV x64 code generation')
    }
    mut linker := ElfTinyLinker{
        elf: g.elf
    }
    linker.write(path)!
}

fn (mut l ElfTinyLinker) write(path string) ! {
    reachable := l.collect_reachable()!
    if stdout := l.ultra_constant_stdout(reachable) {
        l.write_ultra_executable(path, stdout)!
        return
    }
    selected_names := reachable.names
    selected_data := reachable.data
    mut text := []u8{}
    entry_call_field := elf_tiny_emit_start(mut text)
    mut func_offsets := map[string]u64{}
    for name in selected_names {
        range := l.text_range(name)!
        func_offsets[name] = u64(text.len)
        text << l.elf.text_data[int(range.start)..int(range.end)]
    }
    mut runtime := l.build_runtime(reachable.runtime_symbols)
    runtime_base := u64(text.len)
    text << runtime.text

    mut rodata := []u8{}
    mut data := []u8{}
    mut data_offsets := map[string]u64{}
    l.copy_data_ranges(selected_data, .rodata, mut rodata, mut data_offsets)!
    l.copy_data_ranges(selected_data, .data, mut data, mut data_offsets)!
    int_str_runtime_needed := 'builtin__int__str' in reachable.runtime_symbols
        || 'builtin__i64__str' in reachable.runtime_symbols
    mut bss_bytes := 0
    if int_str_runtime_needed {
        bss_bytes += linux_tiny_int_str_arena_metadata_bytes
    }
    if 'builtin__rune__str' in reachable.runtime_symbols {
        bss_bytes += linux_tiny_rune_str_arena_metadata_bytes
    }
    if 'builtin__string__+' in reachable.runtime_symbols {
        bss_bytes += linux_tiny_string_plus_arena_metadata_bytes
    }
    if rodata.len > 0 {
        for text.len % int(l.data_section_alignment(.rodata)) != 0 {
            text << u8(0)
        }
    }

    phnum := if data.len > 0 || bss_bytes > 0 { 2 } else { 1 }
    text_off := elf_tiny_text_file_offset(phnum)
    data_off := elf_tiny_data_file_offset(text_off, text.len, rodata.len)
    text_vaddr := linux_tiny_base_vaddr + u64(text_off)
    rodata_vaddr := text_vaddr + u64(text.len)
    data_vaddr := linux_tiny_base_vaddr + u64(data_off)
    bss_vaddr := if data.len > 0 { data_vaddr + u64(data.len) } else { data_vaddr }
    if bss_bytes > 0 {
        mut bss_offset := u64(0)
        if int_str_runtime_needed {
            int_str_arena_vaddr := bss_vaddr + bss_offset
            for field_off in runtime.int_str_arena_patches {
                elf_tiny_patch_rel32(mut text, int(runtime_base) + field_off, text_vaddr, 0,
                    int_str_arena_vaddr)
            }
            bss_offset += u64(linux_tiny_int_str_arena_metadata_bytes)
        }
        if 'builtin__rune__str' in reachable.runtime_symbols {
            rune_str_arena_vaddr := bss_vaddr + bss_offset
            for field_off in runtime.rune_str_arena_patches {
                elf_tiny_patch_rel32(mut text, int(runtime_base) + field_off, text_vaddr, 0,
                    rune_str_arena_vaddr)
            }
            bss_offset += u64(linux_tiny_rune_str_arena_metadata_bytes)
        }
        if 'builtin__string__+' in reachable.runtime_symbols {
            string_plus_arena_vaddr := bss_vaddr + bss_offset
            for field_off in runtime.string_plus_arena_patches {
                elf_tiny_patch_rel32(mut text, int(runtime_base) + field_off, text_vaddr, 0,
                    string_plus_arena_vaddr)
            }
        }
    }
    mut symbols := map[string]u64{}
    for name, off in func_offsets {
        symbols[name] = text_vaddr + off
    }
    for name, off in runtime.symbols {
        symbols[name] = text_vaddr + runtime_base + off
    }
    for name, off in data_offsets {
        symbols[name] = if name in l.rodata_symbol_names() {
            rodata_vaddr + off
        } else {
            data_vaddr + off
        }
    }
    main_vaddr := symbols['main'] or {
        return error('Linux tiny executable requires a defined main symbol')
    }
    elf_tiny_patch_rel32(mut text, entry_call_field, text_vaddr, 0, main_vaddr)
    l.apply_relocations(mut text, selected_names, func_offsets, symbols, text_vaddr)!
    l.write_executable(path, text, rodata, data, bss_bytes, phnum, text_off, data_off)!
}

fn (l ElfTinyLinker) ultra_constant_stdout(reachable ElfTinyReachable) ?[]u8 {
    expected_names := ['main', 'builtin__println', 'builtin___writeln_to_fd',
        'builtin___write_buf_to_fd']
    if !elf_tiny_string_arrays_equal(reachable.names, expected_names) {
        return none
    }
    if reachable.data.len != 1 {
        return none
    }
    if reachable.runtime_symbols.len != 2 || 'write' !in reachable.runtime_symbols
        || 'fflush' !in reachable.runtime_symbols {
        return none
    }
    data_range := reachable.data[0]
    if data_range.section != .rodata {
        return none
    }
    literal := 'Hello, World!'.bytes()
    if data_range.end - data_range.start != u64(literal.len + 1) {
        return none
    }
    for i, b in literal {
        if l.elf.rodata[int(data_range.start) + i] != b {
            return none
        }
    }
    if l.elf.rodata[int(data_range.start) + literal.len] != 0 {
        return none
    }
    if !l.ultra_hello_world_main_shape_matches(data_range) {
        return none
    }
    mut stdout := literal.clone()
    stdout << u8(`\n`)
    return stdout
}

fn (l ElfTinyLinker) ultra_hello_world_main_shape_matches(data_range ElfDataRange) bool {
    range := l.text_range('main') or { return false }
    main_text := l.elf.text_data[int(range.start)..int(range.end)]
    expected_main_text := [
        u8(0xf3),
        0x0f,
        0x1e,
        0xfa,
        0x55,
        0x48,
        0x89,
        0xe5,
        0x53,
        0x48,
        0x83,
        0xec,
        0x38,
        0x48,
        0x8d,
        0x05,
        0x00,
        0x00,
        0x00,
        0x00,
        0x48,
        0x89,
        0x45,
        0xe0,
        0xb8,
        0x0d,
        0x00,
        0x00,
        0x00,
        0x89,
        0x45,
        0xe8,
        0xb8,
        0x01,
        0x00,
        0x00,
        0x00,
        0x89,
        0x45,
        0xec,
        0x48,
        0x8d,
        0x45,
        0xe0,
        0x49,
        0x89,
        0xc2,
        0x49,
        0x8b,
        0x3a,
        0x49,
        0x8b,
        0x72,
        0x08,
        0x31,
        0xc0,
        0xe8,
        0x00,
        0x00,
        0x00,
        0x00,
        0x31,
        0xc0,
        0x48,
        0x83,
        0xc4,
        0x38,
        0x5b,
        0x5d,
        0xc3,
    ]
    if main_text.len != expected_main_text.len {
        return false
    }
    for i, b in expected_main_text {
        if main_text[i] != b {
            return false
        }
    }
    mut relocs := []ElfRela{}
    for reloc in l.elf.text_relocs {
        if reloc.offset >= range.start && reloc.offset < range.end {
            relocs << reloc
        }
    }
    for i := 1; i < relocs.len; i++ {
        mut j := i
        for j > 0 && relocs[j - 1].offset > relocs[j].offset {
            relocs[j - 1], relocs[j] = relocs[j], relocs[j - 1]
            j--
        }
    }
    if relocs.len != 2 {
        return false
    }
    rodata_reloc := relocs[0]
    if rodata_reloc.offset - range.start != 16
        || rodata_reloc.info & 0xffff_ffff != u64(r_x86_64_pc32) || rodata_reloc.addend != -4 {
        return false
    }
    rodata_sym := l.reloc_symbol(rodata_reloc) or { return false }
    if rodata_sym.shndx != u16(l.elf_section_index(.rodata)) || rodata_sym.value != data_range.start {
        return false
    }
    println_reloc := relocs[1]
    if println_reloc.offset - range.start != 57
        || println_reloc.info & 0xffff_ffff != u64(r_x86_64_plt32) || println_reloc.addend != -4 {
        return false
    }
    println_sym := l.reloc_symbol(println_reloc) or { return false }
    return println_sym.name == 'builtin__println'
        && println_sym.shndx == u16(l.elf_section_index(.text))
}

fn elf_tiny_string_arrays_equal(left []string, right []string) bool {
    if left.len != right.len {
        return false
    }
    for i, value in left {
        if value != right[i] {
            return false
        }
    }
    return true
}

fn (mut l ElfTinyLinker) collect_reachable() !ElfTinyReachable {
    if _ := l.text_range('main') {
    } else {
        return linux_tiny_not_eligible('missing main symbol')
    }
    mut selected := []string{}
    mut seen := map[string]bool{}
    mut queue := ['main']
    mut selected_data := []ElfDataRange{}
    mut runtime_symbols := map[string]bool{}
    for queue.len > 0 {
        name := queue[0]
        queue.delete(0)
        if seen[name] {
            continue
        }
        if l.tiny_runtime_symbol_name(name) {
            continue
        }
        if l.tiny_unsupported_defined_symbol_name(name) {
            return linux_tiny_not_eligible('`${name}` is not covered by the tiny runtime yet')
        }
        range := l.text_range(name)!
        seen[name] = true
        selected << name
        for reloc in l.elf.text_relocs {
            if reloc.offset < range.start || reloc.offset >= range.end {
                continue
            }
            sym := l.reloc_symbol(reloc)!
            if l.tiny_runtime_symbol_name(sym.name) {
                runtime_symbols[sym.name] = true
                continue
            }
            if sym.shndx == u16(l.elf_section_index(.text)) {
                if l.tiny_unsupported_defined_symbol_name(sym.name) {
                    return linux_tiny_not_eligible('`${sym.name}` is not covered by the tiny runtime yet')
                }
                if !seen[sym.name] {
                    queue << sym.name
                }
            } else if sym.shndx == u16(l.elf_section_index(.rodata)) {
                l.add_data_range(mut selected_data, .rodata, sym.value)!
            } else if sym.shndx == u16(l.elf_section_index(.data)) {
                if x64_main_argc_global_name(sym.name) || x64_main_argv_global_name(sym.name) {
                    return linux_tiny_not_eligible('arguments() requires hosted argc/argv; Linux tiny _start argv is not implemented yet')
                }
                l.add_data_range(mut selected_data, .data, sym.value)!
            } else if sym.shndx == 0 {
                if !l.tiny_runtime_symbol_name(sym.name) {
                    return linux_tiny_not_eligible('external symbol `${sym.name}` referenced from `${name}` requires the hosted linker')
                }
                runtime_symbols[sym.name] = true
            }
        }
    }
    return ElfTinyReachable{
        names:           selected
        data:            selected_data
        runtime_symbols: runtime_symbols
    }
}

fn (l ElfTinyLinker) apply_relocations(mut text []u8, selected_names []string, func_offsets map[string]u64, symbols map[string]u64, text_vaddr u64) ! {
    for name in selected_names {
        range := l.text_range(name)!
        new_base := func_offsets[name]
        for reloc in l.elf.text_relocs {
            if reloc.offset < range.start || reloc.offset >= range.end {
                continue
            }
            reloc_type := reloc.info & 0xffff_ffff
            if reloc_type !in [u64(r_x86_64_pc32), u64(r_x86_64_plt32)] {
                return linux_tiny_not_eligible('ELF relocation type ${reloc_type} is not supported')
            }
            sym := l.reloc_symbol(reloc)!
            target := symbols[sym.name] or {
                return linux_tiny_not_eligible('symbol `${sym.name}` is not resolved by the tiny runtime')
            }
            field_off := int(new_base + reloc.offset - range.start)
            field_vaddr := text_vaddr + u64(field_off)
            disp := i64(target) + reloc.addend - i64(field_vaddr)
            if disp < i64(-2147483648) || disp > i64(2147483647) {
                return error('Linux tiny executable relocation for `${sym.name}` is out of range')
            }
            binary.little_endian_put_u32(mut text[field_off..field_off + 4], u32(i32(disp)))
        }
    }
}

fn (mut l ElfTinyLinker) build_runtime(runtime_symbols map[string]bool) ElfTinyRuntime {
    mut rt := ElfTinyRuntime{
        symbols: map[string]u64{}
    }
    if 'fflush' in runtime_symbols {
        rt.symbols['fflush'] = u64(rt.text.len)
        rt.text << [u8(0x31), 0xc0, 0xc3] // xor eax, eax; ret
    }
    if 'write' in runtime_symbols {
        rt.symbols['write'] = u64(rt.text.len)
        elf_tiny_emit_write(mut rt)
    }
    if 'exit' in runtime_symbols {
        rt.symbols['exit'] = u64(rt.text.len)
        rt.text << [u8(0xb8)]
        write_u32_le(mut rt.text, linux_sys_exit_group)
        rt.text << [u8(0x0f), 0x05, 0x0f, 0x0b] // syscall; ud2
    }
    if 'builtin__int__str' in runtime_symbols {
        rt.symbols['builtin__int__str'] = u64(rt.text.len)
        elf_tiny_emit_int_str(mut rt)
    }
    if 'builtin__i64__str' in runtime_symbols {
        rt.symbols['builtin__i64__str'] = u64(rt.text.len)
        elf_tiny_emit_i64_str(mut rt)
    }
    if 'builtin__rune__str' in runtime_symbols {
        rt.symbols['builtin__rune__str'] = u64(rt.text.len)
        elf_tiny_emit_rune_str(mut rt)
    }
    if 'builtin__string__+' in runtime_symbols {
        rt.symbols['builtin__string__+'] = u64(rt.text.len)
        elf_tiny_emit_string_plus(mut rt)
    }
    return rt
}

fn elf_tiny_emit_start(mut text []u8) int {
    text << [u8(0x31), 0xed] // xor ebp, ebp
    text << u8(0xe8)
    call_field := text.len
    text << [u8(0), 0, 0, 0]
    text << [u8(0x89), 0xc7] // mov edi, eax
    text << u8(0xb8)
    write_u32_le(mut text, linux_sys_exit_group)
    text << [u8(0x0f), 0x05, 0x0f, 0x0b] // syscall; ud2
    return call_field
}

fn elf_tiny_emit_write(mut rt ElfTinyRuntime) {
    rt.text << [u8(0x49), 0x89, 0xd0] // mov r8, rdx
    rt.text << [u8(0x49), 0x89, 0xf1] // mov r9, rsi
    rt.text << [u8(0x45), 0x31, 0xd2] // xor r10d, r10d
    rt.text << [u8(0x48), 0x85, 0xd2] // test rdx, rdx
    rt.text << [u8(0x7f), 0x03] // jg loop
    rt.text << [u8(0x31), 0xc0] // xor eax, eax
    rt.text << u8(0xc3) // ret
    loop_start := rt.text.len
    rt.text << u8(0xb8)
    write_u32_le(mut rt.text, linux_sys_write)
    rt.text << [u8(0x4c), 0x89, 0xce] // mov rsi, r9
    rt.text << [u8(0x4c), 0x89, 0xc2] // mov rdx, r8
    rt.text << [u8(0x0f), 0x05] // syscall
    rt.text << [u8(0x48), 0x85, 0xc0] // test rax, rax
    progress_field := elf_tiny_emit_rel8_placeholder(mut rt.text, 0x7f) // jg progress
    rt.text << [u8(0xbf), 0x01, 0, 0, 0] // mov edi, 1
    rt.text << u8(0xb8)
    write_u32_le(mut rt.text, linux_sys_exit_group)
    rt.text << [u8(0x0f), 0x05, 0x0f, 0x0b] // syscall; ud2
    progress_off := rt.text.len
    rt.text << [u8(0x49), 0x01, 0xc1] // add r9, rax
    rt.text << [u8(0x49), 0x29, 0xc0] // sub r8, rax
    rt.text << [u8(0x49), 0x01, 0xc2] // add r10, rax
    rt.text << [u8(0x4d), 0x85, 0xc0] // test r8, r8
    loop_field := elf_tiny_emit_rel8_placeholder(mut rt.text, 0x75) // jne loop
    rt.text << [u8(0x4c), 0x89, 0xd0] // mov rax, r10
    rt.text << u8(0xc3) // ret
    elf_tiny_patch_rel8(mut rt.text, progress_field, progress_off)
    elf_tiny_patch_rel8(mut rt.text, loop_field, loop_start)
}

fn elf_tiny_emit_ultra_stdout(mut text []u8, stdout_len int) int {
    text << [u8(0x31), 0xed] // xor ebp, ebp
    text << [u8(0x49), 0xc7, 0xc0]
    write_u32_le(mut text, u32(stdout_len)) // mov r8, stdout_len
    text << [u8(0x4c), 0x8d, 0x0d] // lea r9, [rip+stdout]
    stdout_field := text.len
    text << [u8(0), 0, 0, 0]
    text << [u8(0x4d), 0x85, 0xc0] // test r8, r8
    done_field := elf_tiny_emit_rel8_placeholder(mut text, 0x74) // je done
    loop_start := text.len
    text << u8(0xb8)
    write_u32_le(mut text, linux_sys_write)
    text << [u8(0xbf), 0x01, 0, 0, 0] // mov edi, 1
    text << [u8(0x4c), 0x89, 0xce] // mov rsi, r9
    text << [u8(0x4c), 0x89, 0xc2] // mov rdx, r8
    text << [u8(0x0f), 0x05] // syscall
    text << [u8(0x48), 0x85, 0xc0] // test rax, rax
    fail_field := elf_tiny_emit_rel8_placeholder(mut text, 0x7e) // jle fail
    text << [u8(0x49), 0x01, 0xc1] // add r9, rax
    text << [u8(0x49), 0x29, 0xc0] // sub r8, rax
    loop_field := elf_tiny_emit_rel8_placeholder(mut text, 0x75) // jne loop
    done_off := text.len
    text << [u8(0x31), 0xff] // xor edi, edi
    text << u8(0xb8)
    write_u32_le(mut text, linux_sys_exit_group)
    text << [u8(0x0f), 0x05, 0x0f, 0x0b] // syscall; ud2
    fail_off := text.len
    text << [u8(0xbf), 0x01, 0, 0, 0] // mov edi, 1
    text << u8(0xb8)
    write_u32_le(mut text, linux_sys_exit_group)
    text << [u8(0x0f), 0x05, 0x0f, 0x0b] // syscall; ud2
    elf_tiny_patch_rel8(mut text, done_field, done_off)
    elf_tiny_patch_rel8(mut text, fail_field, fail_off)
    elf_tiny_patch_rel8(mut text, loop_field, loop_start)
    return stdout_field
}

fn elf_tiny_emit_int_str(mut rt ElfTinyRuntime) {
    elf_tiny_emit_signed_decimal_str(mut rt, false)
}

fn elf_tiny_emit_i64_str(mut rt ElfTinyRuntime) {
    elf_tiny_emit_signed_decimal_str(mut rt, true)
}

fn elf_tiny_emit_signed_decimal_str(mut rt ElfTinyRuntime, is_i64 bool) {
    rt.text << u8(0x57) // push rdi
    rt.text << [u8(0x4c), 0x8d, 0x1d] // lea r11, [arena]
    rt.int_str_arena_patches << rt.text.len
    rt.text << [u8(0), 0, 0, 0]
    rt.text << [u8(0x4d), 0x8b, 0x03] // mov r8, [r11]
    rt.text << [u8(0x4d), 0x8b, 0x4b, 0x08] // mov r9, [r11+8]
    rt.text << [u8(0x4d), 0x85, 0xc0] // test r8, r8
    need_mmap_field := elf_tiny_emit_rel8_placeholder(mut rt.text, 0x74) // je need_mmap
    rt.text << [u8(0x49), 0x8d, 0x40, u8(linux_tiny_int_str_slot_bytes)] // lea rax, [r8+32]
    rt.text << [u8(0x4c), 0x39, 0xc8] // cmp rax, r9
    have_block_field := elf_tiny_emit_rel8_placeholder(mut rt.text, 0x76) // jbe have_block
    need_mmap_off := rt.text.len
    rt.text << [u8(0x31), 0xff] // xor edi, edi
    rt.text << u8(0xbe)
    write_u32_le(mut rt.text, linux_tiny_int_str_arena_bytes)
    rt.text << u8(0xba)
    write_u32_le(mut rt.text, linux_mmap_prot_read_write)
    rt.text << [u8(0x41), 0xba]
    write_u32_le(mut rt.text, linux_mmap_private_anonymous)
    rt.text << [u8(0x49), 0xc7, 0xc0]
    write_u32_le(mut rt.text, u32(0xffff_ffff))
    rt.text << [u8(0x45), 0x31, 0xc9] // xor r9d, r9d
    rt.text << u8(0xb8)
    write_u32_le(mut rt.text, linux_sys_mmap)
    rt.text << [u8(0x0f), 0x05] // syscall
    rt.text << [u8(0x48), 0x85, 0xc0] // test rax, rax
    mmap_ok_field := elf_tiny_emit_rel8_placeholder(mut rt.text, 0x79) // jns mmap_ok
    rt.text << u8(0xbf)
    write_u32_le(mut rt.text, 1)
    rt.text << u8(0xb8)
    write_u32_le(mut rt.text, linux_sys_exit_group)
    rt.text << [u8(0x0f), 0x05, 0x0f, 0x0b] // syscall; ud2
    mmap_ok_off := rt.text.len
    rt.text << [u8(0x4c), 0x8d, 0x40, u8(linux_tiny_int_str_slot_bytes)] // lea r8, [rax+32]
    rt.text << [u8(0x49), 0x89, 0xc1] // mov r9, rax
    rt.text << [u8(0x49), 0x81, 0xc1]
    write_u32_le(mut rt.text, linux_tiny_int_str_arena_bytes) // add r9, 4096
    rt.text << [u8(0x4c), 0x8d, 0x1d] // lea r11, [arena]
    rt.int_str_arena_patches << rt.text.len
    rt.text << [u8(0), 0, 0, 0]
    rt.text << [u8(0x4d), 0x89, 0x03] // mov [r11], r8
    rt.text << [u8(0x4d), 0x89, 0x4b, 0x08] // mov [r11+8], r9
    allocated_field := elf_tiny_emit_rel8_placeholder(mut rt.text, 0xeb) // jmp allocated
    have_block_off := rt.text.len
    rt.text << [u8(0x49), 0x89, 0x03] // mov [r11], rax
    rt.text << [u8(0x49), 0x89, 0xc0] // mov r8, rax
    allocated_off := rt.text.len
    rt.text << u8(0x5f) // pop rdi
    if is_i64 {
        rt.text << [u8(0x48), 0x89, 0xf8] // mov rax, rdi
    } else {
        rt.text << [u8(0x89), 0xf8] // mov eax, edi
    }
    rt.text << [u8(0x45), 0x31, 0xc9] // xor r9d, r9d
    rt.text << [u8(0x45), 0x31, 0xd2] // xor r10d, r10d
    if is_i64 {
        rt.text << [u8(0x48), 0x85, 0xc0] // test rax, rax
    } else {
        rt.text << [u8(0x85), 0xc0] // test eax, eax
    }
    non_negative_field := elf_tiny_emit_rel8_placeholder(mut rt.text, 0x79) // jns non_negative
    rt.text << [u8(0x41), 0xb2, 0x01] // mov r10b, 1
    if is_i64 {
        rt.text << [u8(0x48), 0xf7, 0xd8] // neg rax
    } else {
        rt.text << [u8(0xf7), 0xd8] // neg eax
    }
    non_negative_off := rt.text.len
    if is_i64 {
        rt.text << [u8(0x48), 0x85, 0xc0] // test rax, rax
    } else {
        rt.text << [u8(0x85), 0xc0] // test eax, eax
    }
    non_zero_field := elf_tiny_emit_rel8_placeholder(mut rt.text, 0x75) // jne loop
    rt.text << [u8(0x49), 0xff, 0xc8] // dec r8
    rt.text << [u8(0x41), 0xc6, 0x00, 0x30] // mov byte ptr [r8], '0'
    rt.text << [u8(0x41), 0xb9, 0x01, 0, 0, 0] // mov r9d, 1
    maybe_sign_field := elf_tiny_emit_rel8_placeholder(mut rt.text, 0xeb) // jmp maybe_sign
    loop_start := rt.text.len
    rt.text << [u8(0x31), 0xd2] // xor edx, edx
    rt.text << [u8(0xb9), 0x0a, 0, 0, 0] // mov ecx, 10
    if is_i64 {
        rt.text << [u8(0x48), 0xf7, 0xf1] // div rcx
    } else {
        rt.text << [u8(0xf7), 0xf1] // div ecx
    }
    rt.text << [u8(0x80), 0xc2, 0x30] // add dl, '0'
    rt.text << [u8(0x49), 0xff, 0xc8] // dec r8
    rt.text << [u8(0x41), 0x88, 0x10] // mov [r8], dl
    rt.text << [u8(0x49), 0xff, 0xc1] // inc r9
    if is_i64 {
        rt.text << [u8(0x48), 0x85, 0xc0] // test rax, rax
    } else {
        rt.text << [u8(0x85), 0xc0] // test eax, eax
    }
    loop_field := elf_tiny_emit_rel8_placeholder(mut rt.text, 0x75) // jne loop
    maybe_sign_off := rt.text.len
    rt.text << [u8(0x45), 0x84, 0xd2] // test r10b, r10b
    done_field := elf_tiny_emit_rel8_placeholder(mut rt.text, 0x74) // je done
    rt.text << [u8(0x49), 0xff, 0xc8] // dec r8
    rt.text << [u8(0x41), 0xc6, 0x00, 0x2d] // mov byte ptr [r8], '-'
    rt.text << [u8(0x49), 0xff, 0xc1] // inc r9
    done_off := rt.text.len
    rt.text << [u8(0x4c), 0x89, 0xc0] // mov rax, r8
    rt.text << [u8(0x4c), 0x89, 0xca] // mov rdx, r9
    rt.text << u8(0xc3)
    elf_tiny_patch_rel8(mut rt.text, non_negative_field, non_negative_off)
    elf_tiny_patch_rel8(mut rt.text, non_zero_field, loop_start)
    elf_tiny_patch_rel8(mut rt.text, maybe_sign_field, maybe_sign_off)
    elf_tiny_patch_rel8(mut rt.text, loop_field, loop_start)
    elf_tiny_patch_rel8(mut rt.text, done_field, done_off)
    elf_tiny_patch_rel8(mut rt.text, mmap_ok_field, mmap_ok_off)
    elf_tiny_patch_rel8(mut rt.text, need_mmap_field, need_mmap_off)
    elf_tiny_patch_rel8(mut rt.text, have_block_field, have_block_off)
    elf_tiny_patch_rel8(mut rt.text, allocated_field, allocated_off)
}

fn elf_tiny_emit_rune_str(mut rt ElfTinyRuntime) {
    rt.text << u8(0x57) // push rdi
    rt.text << [u8(0x4c), 0x8d, 0x1d] // lea r11, [arena]
    rt.rune_str_arena_patches << rt.text.len
    rt.text << [u8(0), 0, 0, 0]
    rt.text << [u8(0x4d), 0x8b, 0x03] // mov r8, [r11]
    rt.text << [u8(0x4d), 0x8b, 0x4b, 0x08] // mov r9, [r11+8]
    rt.text << [u8(0x4d), 0x85, 0xc0] // test r8, r8
    need_mmap_field :=
        elf_tiny_emit_rel32_placeholder(mut rt.text, [u8(0x0f), 0x84]) // je need_mmap
    rt.text << [u8(0x49), 0x8d, 0x40, u8(linux_tiny_rune_str_slot_bytes)] // lea rax, [r8+8]
    rt.text << [u8(0x4c), 0x39, 0xc8] // cmp rax, r9
    have_block_field :=
        elf_tiny_emit_rel32_placeholder(mut rt.text, [u8(0x0f), 0x86]) // jbe have_block
    need_mmap_off := rt.text.len
    rt.text << [u8(0x31), 0xff] // xor edi, edi
    rt.text << u8(0xbe)
    write_u32_le(mut rt.text, linux_tiny_rune_str_arena_bytes)
    rt.text << u8(0xba)
    write_u32_le(mut rt.text, linux_mmap_prot_read_write)
    rt.text << [u8(0x41), 0xba]
    write_u32_le(mut rt.text, linux_mmap_private_anonymous)
    rt.text << [u8(0x49), 0xc7, 0xc0]
    write_u32_le(mut rt.text, u32(0xffff_ffff))
    rt.text << [u8(0x45), 0x31, 0xc9] // xor r9d, r9d
    rt.text << u8(0xb8)
    write_u32_le(mut rt.text, linux_sys_mmap)
    rt.text << [u8(0x0f), 0x05] // syscall
    rt.text << [u8(0x48), 0x85, 0xc0] // test rax, rax
    mmap_ok_field := elf_tiny_emit_rel32_placeholder(mut rt.text, [u8(0x0f), 0x89]) // jns mmap_ok
    rt.text << u8(0xbf)
    write_u32_le(mut rt.text, 1)
    rt.text << u8(0xb8)
    write_u32_le(mut rt.text, linux_sys_exit_group)
    rt.text << [u8(0x0f), 0x05, 0x0f, 0x0b] // syscall; ud2
    mmap_ok_off := rt.text.len
    rt.text << [u8(0x49), 0x89, 0xc0] // mov r8, rax
    rt.text << [u8(0x4c), 0x8d, 0x50, u8(linux_tiny_rune_str_slot_bytes)] // lea r10, [rax+8]
    rt.text << [u8(0x4c), 0x8d, 0x88]
    write_u32_le(mut rt.text, linux_tiny_rune_str_arena_bytes) // lea r9, [rax+4096]
    rt.text << [u8(0x4c), 0x8d, 0x1d] // lea r11, [arena]
    rt.rune_str_arena_patches << rt.text.len
    rt.text << [u8(0), 0, 0, 0]
    rt.text << [u8(0x4d), 0x89, 0x13] // mov [r11], r10
    rt.text << [u8(0x4d), 0x89, 0x4b, 0x08] // mov [r11+8], r9
    allocated_field := elf_tiny_emit_jmp32_placeholder(mut rt.text)
    have_block_off := rt.text.len
    rt.text << [u8(0x49), 0x89, 0x03] // mov [r11], rax
    allocated_off := rt.text.len
    rt.text << u8(0x5f) // pop rdi
    rt.text << [u8(0x89), 0xf8] // mov eax, edi
    rt.text << [u8(0x83), 0xf8, 0x7f] // cmp eax, 0x7f
    two_byte_field := elf_tiny_emit_rel32_placeholder(mut rt.text, [u8(0x0f), 0x87]) // ja two_byte
    rt.text << [u8(0x41), 0x88, 0x00] // mov [r8], al
    rt.text << [u8(0x41), 0xc6, 0x40, 0x01, 0x00] // mov byte ptr [r8+1], 0
    rt.text << [u8(0xba)]
    write_u32_le(mut rt.text, 1)
    one_byte_done_field := elf_tiny_emit_jmp32_placeholder(mut rt.text)
    two_byte_off := rt.text.len
    rt.text << u8(0x3d)
    write_u32_le(mut rt.text, 0x7ff) // cmp eax, 0x7ff
    three_byte_field :=
        elf_tiny_emit_rel32_placeholder(mut rt.text, [u8(0x0f), 0x87]) // ja three_byte
    rt.text << [u8(0x89), 0xc1] // mov ecx, eax
    rt.text << [u8(0xc1), 0xe9, 0x06] // shr ecx, 6
    rt.text << [u8(0x80), 0xc9, 0xc0] // or cl, 0xc0
    rt.text << [u8(0x41), 0x88, 0x08] // mov [r8], cl
    rt.text << [u8(0x89), 0xc1] // mov ecx, eax
    rt.text << [u8(0x80), 0xe1, 0x3f] // and cl, 0x3f
    rt.text << [u8(0x80), 0xc9, 0x80] // or cl, 0x80
    rt.text << [u8(0x41), 0x88, 0x48, 0x01] // mov [r8+1], cl
    rt.text << [u8(0x41), 0xc6, 0x40, 0x02, 0x00] // mov byte ptr [r8+2], 0
    rt.text << [u8(0xba)]
    write_u32_le(mut rt.text, 2)
    two_byte_done_field := elf_tiny_emit_jmp32_placeholder(mut rt.text)
    three_byte_off := rt.text.len
    rt.text << u8(0x3d)
    write_u32_le(mut rt.text, 0xffff) // cmp eax, 0xffff
    four_byte_field :=
        elf_tiny_emit_rel32_placeholder(mut rt.text, [u8(0x0f), 0x87]) // ja four_byte
    rt.text << [u8(0x89), 0xc1] // mov ecx, eax
    rt.text << [u8(0xc1), 0xe9, 0x0c] // shr ecx, 12
    rt.text << [u8(0x80), 0xc9, 0xe0] // or cl, 0xe0
    rt.text << [u8(0x41), 0x88, 0x08] // mov [r8], cl
    rt.text << [u8(0x89), 0xc1] // mov ecx, eax
    rt.text << [u8(0xc1), 0xe9, 0x06] // shr ecx, 6
    rt.text << [u8(0x80), 0xe1, 0x3f] // and cl, 0x3f
    rt.text << [u8(0x80), 0xc9, 0x80] // or cl, 0x80
    rt.text << [u8(0x41), 0x88, 0x48, 0x01] // mov [r8+1], cl
    rt.text << [u8(0x89), 0xc1] // mov ecx, eax
    rt.text << [u8(0x80), 0xe1, 0x3f] // and cl, 0x3f
    rt.text << [u8(0x80), 0xc9, 0x80] // or cl, 0x80
    rt.text << [u8(0x41), 0x88, 0x48, 0x02] // mov [r8+2], cl
    rt.text << [u8(0x41), 0xc6, 0x40, 0x03, 0x00] // mov byte ptr [r8+3], 0
    rt.text << [u8(0xba)]
    write_u32_le(mut rt.text, 3)
    three_byte_done_field := elf_tiny_emit_jmp32_placeholder(mut rt.text)
    four_byte_off := rt.text.len
    rt.text << u8(0x3d)
    write_u32_le(mut rt.text, 0x10ffff) // cmp eax, 0x10ffff
    invalid_large_field :=
        elf_tiny_emit_rel32_placeholder(mut rt.text, [u8(0x0f), 0x87]) // ja invalid
    rt.text << [u8(0x89), 0xc1] // mov ecx, eax
    rt.text << [u8(0xc1), 0xe9, 0x12] // shr ecx, 18
    rt.text << [u8(0x80), 0xc9, 0xf0] // or cl, 0xf0
    rt.text << [u8(0x41), 0x88, 0x08] // mov [r8], cl
    rt.text << [u8(0x89), 0xc1] // mov ecx, eax
    rt.text << [u8(0xc1), 0xe9, 0x0c] // shr ecx, 12
    rt.text << [u8(0x80), 0xe1, 0x3f] // and cl, 0x3f
    rt.text << [u8(0x80), 0xc9, 0x80] // or cl, 0x80
    rt.text << [u8(0x41), 0x88, 0x48, 0x01] // mov [r8+1], cl
    rt.text << [u8(0x89), 0xc1] // mov ecx, eax
    rt.text << [u8(0xc1), 0xe9, 0x06] // shr ecx, 6
    rt.text << [u8(0x80), 0xe1, 0x3f] // and cl, 0x3f
    rt.text << [u8(0x80), 0xc9, 0x80] // or cl, 0x80
    rt.text << [u8(0x41), 0x88, 0x48, 0x02] // mov [r8+2], cl
    rt.text << [u8(0x89), 0xc1] // mov ecx, eax
    rt.text << [u8(0x80), 0xe1, 0x3f] // and cl, 0x3f
    rt.text << [u8(0x80), 0xc9, 0x80] // or cl, 0x80
    rt.text << [u8(0x41), 0x88, 0x48, 0x03] // mov [r8+3], cl
    rt.text << [u8(0x41), 0xc6, 0x40, 0x04, 0x00] // mov byte ptr [r8+4], 0
    rt.text << [u8(0xba)]
    write_u32_le(mut rt.text, 4)
    four_byte_done_field := elf_tiny_emit_jmp32_placeholder(mut rt.text)
    invalid_off := rt.text.len
    rt.text << [u8(0x41), 0xc6, 0x00, 0x00] // mov byte ptr [r8], 0
    rt.text << [u8(0x31), 0xd2] // xor edx, edx
    done_off := rt.text.len
    rt.text << [u8(0x4c), 0x89, 0xc0] // mov rax, r8
    rt.text << u8(0xc3)
    elf_tiny_patch_rel32_local(mut rt.text, need_mmap_field, need_mmap_off)
    elf_tiny_patch_rel32_local(mut rt.text, have_block_field, have_block_off)
    elf_tiny_patch_rel32_local(mut rt.text, mmap_ok_field, mmap_ok_off)
    elf_tiny_patch_rel32_local(mut rt.text, allocated_field, allocated_off)
    elf_tiny_patch_rel32_local(mut rt.text, two_byte_field, two_byte_off)
    elf_tiny_patch_rel32_local(mut rt.text, one_byte_done_field, done_off)
    elf_tiny_patch_rel32_local(mut rt.text, three_byte_field, three_byte_off)
    elf_tiny_patch_rel32_local(mut rt.text, two_byte_done_field, done_off)
    elf_tiny_patch_rel32_local(mut rt.text, four_byte_field, four_byte_off)
    elf_tiny_patch_rel32_local(mut rt.text, three_byte_done_field, done_off)
    elf_tiny_patch_rel32_local(mut rt.text, invalid_large_field, invalid_off)
    elf_tiny_patch_rel32_local(mut rt.text, four_byte_done_field, done_off)
}

fn elf_tiny_emit_string_plus(mut rt ElfTinyRuntime) {
    // SysV ABI: first string in rdi/rsi, second string in rdx/rcx, return in rax/rdx.
    rt.text << [u8(0x57), 0x56, 0x52, 0x51] // push rdi; push rsi; push rdx; push rcx
    rt.text << [u8(0x4c), 0x8d, 0x1d] // lea r11, [arena]
    rt.string_plus_arena_patches << rt.text.len
    rt.text << [u8(0), 0, 0, 0]
    rt.text << [u8(0x4d), 0x8b, 0x13] // mov r10, [r11]
    rt.text << [u8(0x49), 0x8b, 0x43, 0x08] // mov rax, [r11+8]
    rt.text << [u8(0x4d), 0x85, 0xd2] // test r10, r10
    need_mmap_field :=
        elf_tiny_emit_rel32_placeholder(mut rt.text, [u8(0x0f), 0x84]) // je need_mmap
    rt.text << [u8(0x44), 0x8b, 0x44, 0x24, 0x10] // mov r8d, [rsp+16]
    rt.text << [u8(0x44), 0x03, 0x04, 0x24] // add r8d, [rsp]
    rt.text << [u8(0x4d), 0x89, 0xc1] // mov r9, r8
    rt.text << [u8(0x49), 0xff, 0xc1] // inc r9
    rt.text << [u8(0x4c), 0x89, 0xd2] // mov rdx, r10
    rt.text << [u8(0x4c), 0x01, 0xca] // add rdx, r9
    rt.text << [u8(0x48), 0x39, 0xc2] // cmp rdx, rax
    have_block_field :=
        elf_tiny_emit_rel32_placeholder(mut rt.text, [u8(0x0f), 0x86]) // jbe have_block
    need_mmap_off := rt.text.len
    rt.text << [u8(0x44), 0x8b, 0x44, 0x24, 0x10] // mov r8d, [rsp+16]
    rt.text << [u8(0x44), 0x03, 0x04, 0x24] // add r8d, [rsp]
    rt.text << [u8(0x4d), 0x89, 0xc1] // mov r9, r8
    rt.text << [u8(0x49), 0xff, 0xc1] // inc r9
    rt.text << [u8(0x31), 0xff] // xor edi, edi
    rt.text << [u8(0x4c), 0x89, 0xce] // mov rsi, r9
    rt.text << [u8(0x48), 0x81, 0xfe]
    write_u32_le(mut rt.text, linux_tiny_string_plus_arena_bytes) // cmp rsi, 4096
    large_alloc_field :=
        elf_tiny_emit_rel32_placeholder(mut rt.text, [u8(0x0f), 0x83]) // jae large_alloc
    rt.text << u8(0xbe)
    write_u32_le(mut rt.text, linux_tiny_string_plus_arena_bytes) // mov esi, 4096
    large_alloc_off := rt.text.len
    rt.text << u8(0xba)
    write_u32_le(mut rt.text, linux_mmap_prot_read_write)
    rt.text << [u8(0x41), 0xba]
    write_u32_le(mut rt.text, linux_mmap_private_anonymous)
    rt.text << [u8(0x49), 0xc7, 0xc0]
    write_u32_le(mut rt.text, u32(0xffff_ffff))
    rt.text << [u8(0x45), 0x31, 0xc9] // xor r9d, r9d
    rt.text << u8(0xb8)
    write_u32_le(mut rt.text, linux_sys_mmap)
    rt.text << [u8(0x0f), 0x05] // syscall
    rt.text << [u8(0x48), 0x85, 0xc0] // test rax, rax
    mmap_ok_field := elf_tiny_emit_rel32_placeholder(mut rt.text, [u8(0x0f), 0x89]) // jns mmap_ok
    rt.text << u8(0xbf)
    write_u32_le(mut rt.text, 1)
    rt.text << u8(0xb8)
    write_u32_le(mut rt.text, linux_sys_exit_group)
    rt.text << [u8(0x0f), 0x05, 0x0f, 0x0b] // syscall; ud2
    mmap_ok_off := rt.text.len
    rt.text << [u8(0x49), 0x89, 0xc2] // mov r10, rax
    rt.text << [u8(0x44), 0x8b, 0x44, 0x24, 0x10] // mov r8d, [rsp+16]
    rt.text << [u8(0x44), 0x03, 0x04, 0x24] // add r8d, [rsp]
    rt.text << [u8(0x4d), 0x89, 0xc1] // mov r9, r8
    rt.text << [u8(0x49), 0xff, 0xc1] // inc r9
    rt.text << [u8(0x48), 0x89, 0xc2] // mov rdx, rax
    rt.text << [u8(0x4c), 0x01, 0xca] // add rdx, r9
    rt.text << [u8(0x4d), 0x89, 0xcb] // mov r11, r9
    rt.text << [u8(0x49), 0x81, 0xfb]
    write_u32_le(mut rt.text, linux_tiny_string_plus_arena_bytes) // cmp r11, 4096
    large_end_field :=
        elf_tiny_emit_rel32_placeholder(mut rt.text, [u8(0x0f), 0x83]) // jae large_end
    rt.text << [u8(0x41), 0xbb]
    write_u32_le(mut rt.text, linux_tiny_string_plus_arena_bytes) // mov r11d, 4096
    large_end_off := rt.text.len
    rt.text << [u8(0x4c), 0x89, 0xd0] // mov rax, r10
    rt.text << [u8(0x4c), 0x01, 0xd8] // add rax, r11
    rt.text << [u8(0x4c), 0x8d, 0x1d] // lea r11, [arena]
    rt.string_plus_arena_patches << rt.text.len
    rt.text << [u8(0), 0, 0, 0]
    rt.text << [u8(0x49), 0x89, 0x13] // mov [r11], rdx
    rt.text << [u8(0x49), 0x89, 0x43, 0x08] // mov [r11+8], rax
    allocated_field := elf_tiny_emit_jmp32_placeholder(mut rt.text)
    have_block_off := rt.text.len
    rt.text << [u8(0x4c), 0x8d, 0x1d] // lea r11, [arena]
    rt.string_plus_arena_patches << rt.text.len
    rt.text << [u8(0), 0, 0, 0]
    rt.text << [u8(0x49), 0x89, 0x13] // mov [r11], rdx
    allocated_off := rt.text.len
    rt.text << [u8(0x4c), 0x89, 0xd0] // mov rax, r10
    rt.text << [u8(0x4d), 0x89, 0xd0] // mov r8, r10
    rt.text << [u8(0x48), 0x8b, 0x74, 0x24, 0x18] // mov rsi, [rsp+24]
    rt.text << [u8(0x8b), 0x4c, 0x24, 0x10] // mov ecx, [rsp+16]
    rt.text << [u8(0x48), 0x85, 0xc9] // test rcx, rcx
    copy_a_done_field :=
        elf_tiny_emit_rel32_placeholder(mut rt.text, [u8(0x0f), 0x84]) // je copy_a_done
    copy_a_loop := rt.text.len
    rt.text << [u8(0x8a), 0x16] // mov dl, [rsi]
    rt.text << [u8(0x41), 0x88, 0x10] // mov [r8], dl
    rt.text << [u8(0x48), 0xff, 0xc6] // inc rsi
    rt.text << [u8(0x49), 0xff, 0xc0] // inc r8
    rt.text << [u8(0x48), 0xff, 0xc9] // dec rcx
    copy_a_loop_field :=
        elf_tiny_emit_rel32_placeholder(mut rt.text, [u8(0x0f), 0x85]) // jne copy_a_loop
    copy_a_done_off := rt.text.len
    rt.text << [u8(0x48), 0x8b, 0x74, 0x24, 0x08] // mov rsi, [rsp+8]
    rt.text << [u8(0x8b), 0x0c, 0x24] // mov ecx, [rsp]
    rt.text << [u8(0x48), 0x85, 0xc9] // test rcx, rcx
    copy_b_done_field :=
        elf_tiny_emit_rel32_placeholder(mut rt.text, [u8(0x0f), 0x84]) // je copy_b_done
    copy_b_loop := rt.text.len
    rt.text << [u8(0x8a), 0x16] // mov dl, [rsi]
    rt.text << [u8(0x41), 0x88, 0x10] // mov [r8], dl
    rt.text << [u8(0x48), 0xff, 0xc6] // inc rsi
    rt.text << [u8(0x49), 0xff, 0xc0] // inc r8
    rt.text << [u8(0x48), 0xff, 0xc9] // dec rcx
    copy_b_loop_field :=
        elf_tiny_emit_rel32_placeholder(mut rt.text, [u8(0x0f), 0x85]) // jne copy_b_loop
    copy_b_done_off := rt.text.len
    rt.text << [u8(0x41), 0xc6, 0x00, 0x00] // mov byte ptr [r8], 0
    rt.text << [u8(0x8b), 0x54, 0x24, 0x10] // mov edx, [rsp+16]
    rt.text << [u8(0x03), 0x14, 0x24] // add edx, [rsp]
    rt.text << [u8(0x48), 0x83, 0xc4, 0x20] // add rsp, 32
    rt.text << u8(0xc3)
    elf_tiny_patch_rel32_local(mut rt.text, need_mmap_field, need_mmap_off)
    elf_tiny_patch_rel32_local(mut rt.text, have_block_field, have_block_off)
    elf_tiny_patch_rel32_local(mut rt.text, large_alloc_field, large_alloc_off)
    elf_tiny_patch_rel32_local(mut rt.text, mmap_ok_field, mmap_ok_off)
    elf_tiny_patch_rel32_local(mut rt.text, large_end_field, large_end_off)
    elf_tiny_patch_rel32_local(mut rt.text, allocated_field, allocated_off)
    elf_tiny_patch_rel32_local(mut rt.text, copy_a_done_field, copy_a_done_off)
    elf_tiny_patch_rel32_local(mut rt.text, copy_a_loop_field, copy_a_loop)
    elf_tiny_patch_rel32_local(mut rt.text, copy_b_done_field, copy_b_done_off)
    elf_tiny_patch_rel32_local(mut rt.text, copy_b_loop_field, copy_b_loop)
}

fn (mut l ElfTinyLinker) write_executable(path string, text []u8, rodata []u8, data []u8, bss_bytes int, phnum int, text_off int, data_off int) ! {
    rodata_off := text_off + text.len
    text_filesz := rodata_off + rodata.len
    mut buf := []u8{}
    buf << [u8(ei_mag0), ei_mag1, ei_mag2, ei_mag3]
    buf << [u8(elfclass64), elfdata2lsb, ev_current, 0]
    for _ in 0 .. 8 {
        buf << u8(0)
    }
    write_u16_le(mut buf, et_exec)
    write_u16_le(mut buf, em_x86_64)
    write_u32_le(mut buf, ev_current)
    write_u64_le(mut buf, linux_tiny_base_vaddr + u64(text_off))
    write_u64_le(mut buf, 64)
    write_u64_le(mut buf, 0)
    write_u32_le(mut buf, 0)
    write_u16_le(mut buf, 64)
    write_u16_le(mut buf, 56)
    write_u16_le(mut buf, u16(phnum))
    write_u16_le(mut buf, 0)
    write_u16_le(mut buf, 0)
    write_u16_le(mut buf, 0)
    elf_tiny_write_phdr(mut buf, pt_load, pf_r | pf_x, 0, linux_tiny_base_vaddr, u64(text_filesz),
        u64(text_filesz), linux_tiny_page_align)
    if data.len > 0 || bss_bytes > 0 {
        rw_filesz := u64(data.len)
        rw_memsz := u64(data.len + bss_bytes)
        rw_offset := if data.len > 0 { u64(data_off) } else { u64(0) }
        elf_tiny_write_phdr(mut buf, pt_load, pf_r | pf_w, rw_offset, linux_tiny_base_vaddr +
            u64(data_off), rw_filesz, rw_memsz, linux_tiny_page_align)
    }
    for buf.len < text_off {
        buf << u8(0)
    }
    buf << text
    buf << rodata
    if data.len > 0 {
        for buf.len < data_off {
            buf << u8(0)
        }
        buf << data
    }
    os.write_file_array(path, buf)!
    os.chmod(path, 0o755)!
}

fn (mut l ElfTinyLinker) write_ultra_executable(path string, stdout []u8) ! {
    phnum := 1
    text_off := elf_tiny_text_file_offset(phnum)
    text_vaddr := linux_tiny_base_vaddr + u64(text_off)
    mut text := []u8{}
    stdout_field := elf_tiny_emit_ultra_stdout(mut text, stdout.len)
    stdout_vaddr := text_vaddr + u64(text.len)
    elf_tiny_patch_rel32(mut text, stdout_field, text_vaddr, 0, stdout_vaddr)
    l.write_executable(path, text, stdout, []u8{}, 0, phnum, text_off, 0)!
}

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

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

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

fn elf_tiny_patch_rel8(mut text []u8, field_off int, target_off int) {
    disp := target_off - (field_off + 1)
    if disp < -128 || disp > 127 {
        panic('Linux tiny executable short branch is out of range')
    }
    text[field_off] = if disp < 0 { u8(256 + disp) } else { u8(disp) }
}

fn elf_tiny_patch_rel32_local(mut text []u8, field_off int, target_off int) {
    disp := target_off - (field_off + 4)
    if disp < -2147483648 || disp > 2147483647 {
        panic('Linux tiny executable near branch is out of range')
    }
    binary.little_endian_put_u32(mut text[field_off..field_off + 4], u32(i32(disp)))
}

fn elf_tiny_write_phdr(mut b []u8, type_ u32, flags u32, off u64, vaddr u64, filesz u64, memsz u64, align u64) {
    write_u32_le(mut b, type_)
    write_u32_le(mut b, flags)
    write_u64_le(mut b, off)
    write_u64_le(mut b, vaddr)
    write_u64_le(mut b, vaddr)
    write_u64_le(mut b, filesz)
    write_u64_le(mut b, memsz)
    write_u64_le(mut b, align)
}

fn (l ElfTinyLinker) text_range(name string) !ElfTextRange {
    ranges := l.text_symbol_ranges()
    for range in ranges {
        if range.name == name {
            return range
        }
    }
    return error('missing text symbol `${name}`')
}

fn (l ElfTinyLinker) text_symbol_ranges() []ElfTextRange {
    mut syms := []ElfSymbol{}
    for sym in l.elf.symbols {
        if sym.name != '' && sym.shndx == u16(l.elf_section_index(.text)) {
            syms << sym
        }
    }
    for i := 1; i < syms.len; i++ {
        mut j := i
        for j > 0 && syms[j - 1].value > syms[j].value {
            syms[j - 1], syms[j] = syms[j], syms[j - 1]
            j--
        }
    }
    mut ranges := []ElfTextRange{}
    for i, sym in syms {
        mut end := u64(l.elf.text_data.len)
        for j := i + 1; j < syms.len; j++ {
            if syms[j].value > sym.value {
                end = syms[j].value
                break
            }
        }
        if end > sym.value {
            ranges << ElfTextRange{
                name:  sym.name
                start: sym.value
                end:   end
            }
        }
    }
    return ranges
}

fn (l ElfTinyLinker) reloc_symbol(reloc ElfRela) !ElfSymbol {
    sym_idx := int(reloc.info >> 32)
    if sym_idx < 0 || sym_idx >= l.elf.symbols.len {
        return error('Linux tiny executable relocation references invalid symbol index ${sym_idx}')
    }
    return l.elf.symbols[sym_idx]
}

fn (l ElfTinyLinker) elf_section_index(section ObjectSection) int {
    return match section {
        .text { 1 }
        .data { 2 }
        .rodata { 3 }
    }
}

fn (l ElfTinyLinker) tiny_runtime_symbol_name(name string) bool {
    return name in ['write', 'exit', 'fflush', 'builtin__int__str', 'builtin__i64__str',
        'builtin__rune__str', 'builtin__string__+']
}

fn (l ElfTinyLinker) tiny_unsupported_defined_symbol_name(name string) bool {
    return name in ['builtin__print', 'builtin__int__str_l']
}

fn (mut l ElfTinyLinker) add_data_range(mut ranges []ElfDataRange, section ObjectSection, start u64) ! {
    end := l.data_symbol_range_end(section, start)!
    for range in ranges {
        if range.section == section && range.start == start && range.end == end {
            return
        }
    }
    ranges << ElfDataRange{
        section: section
        start:   start
        end:     end
    }
}

fn (l ElfTinyLinker) data_symbol_range_end(section ObjectSection, start u64) !u64 {
    section_idx := u16(l.elf_section_index(section))
    section_len := match section {
        .rodata { u64(l.elf.rodata.len) }
        .data { u64(l.elf.data_data.len) }
        else { u64(0) }
    }

    mut end := section_len
    for sym in l.elf.symbols {
        if sym.shndx == section_idx && sym.value > start && sym.value < end {
            end = sym.value
        }
    }
    if end < start {
        return error('invalid data symbol range')
    }
    return end
}

fn (l ElfTinyLinker) rodata_symbol_names() map[string]bool {
    mut out := map[string]bool{}
    for sym in l.elf.symbols {
        if sym.shndx == u16(l.elf_section_index(.rodata)) {
            out[sym.name] = true
        }
    }
    return out
}

fn (l ElfTinyLinker) copy_data_ranges(ranges []ElfDataRange, section ObjectSection, mut out []u8, mut offsets map[string]u64) ! {
    for dr in ranges {
        if dr.section != section {
            continue
        }
        align := int(l.data_section_alignment(section))
        for align > 1 && out.len % align != int(dr.start % u64(align)) {
            out << u8(0)
        }
        off := u64(out.len)
        for sym in l.elf.symbols {
            if sym.shndx == u16(l.elf_section_index(section)) && sym.value == dr.start {
                offsets[sym.name] = off
            }
        }
        match section {
            .rodata {
                out << l.elf.rodata[int(dr.start)..int(dr.end)]
            }
            .data {
                out << l.elf.data_data[int(dr.start)..int(dr.end)]
            }
            else {
                return error('Linux tiny executable cannot copy ${section} as data')
            }
        }
    }
}

fn (l ElfTinyLinker) data_section_alignment(section ObjectSection) u64 {
    return match section {
        .data { u64(8) }
        .rodata { u64(4) }
        else { u64(1) }
    }
}

fn elf_tiny_text_file_offset(phnum int) int {
    return 64 + phnum * 56
}

fn elf_tiny_data_file_offset(text_off int, text_len int, rodata_len int) int {
    return elf_tiny_align(text_off + text_len + rodata_len, linux_tiny_page_align)
}

fn elf_tiny_align(v int, align int) int {
    if align <= 1 || v % align == 0 {
        return v
    }
    return v + (align - (v % align))
}

fn elf_tiny_patch_rel32(mut text []u8, field_off int, source_base_vaddr u64, source_off u64, target_vaddr u64) {
    field_vaddr := source_base_vaddr + source_off + u64(field_off)
    disp := i64(target_vaddr) - i64(field_vaddr + 4)
    binary.little_endian_put_u32(mut text[field_off..field_off + 4], u32(i32(disp)))
}

fn linux_tiny_not_eligible(message string) IError {
    return error(linux_tiny_not_eligible_prefix + message)
}