module ssa

import v3.flat
import v3.types

const arm64_force_external_syms = ['_malloc', '_free', '_calloc', '_realloc', '_exit', '_abort',
    '_memcpy', '_memmove', '_memset', '_memcmp', '___stdoutp', '___stderrp', '_puts', '_printf',
    '_write', '_read', '_open', '_close', '_fwrite', '_fflush', '_fopen', '_fclose', '_putchar',
    '_sprintf', '_snprintf', '_fprintf', '_sscanf', '_mmap', '_munmap', '_getcwd', '_access',
    '_readlink', '_getenv', '_strlen', '_opendir', '_readdir', '_closedir', '_mkdir', '_rmdir',
    '_unlink', '_rename', '_remove', '_stat', '_lstat', '_fstat', '_chmod', '_chdir', '_realpath',
    '_symlink', '_link', '_getpid', '_getuid', '_geteuid', '_fork', '_execve', '_execvp', '_waitpid',
    '_kill', '_system', '_posix_spawn', '_signal', '_atexit', '_fgets', '_fputs', '_fread', '_fseek',
    '_ftell', '_rewind', '_fileno', '_popen', '_pclose', '_dup', '_dup2', '_pipe', '_isatty',
    '_freopen', '_dprintf', '_getc', '_strdup', '_strcmp', '_strncmp', '_strchr', '_strrchr',
    '_strerror', '_strncasecmp', '_strcasecmp', '_atoi', '_atof', '_qsort', '_time', '_localtime_r',
    '_gmtime_r', '_mktime', '_gettimeofday', '_clock', '_clock_gettime_nsec_np',
    '_mach_absolute_time', '_mach_timebase_info', '_nanosleep', '_sleep', '_usleep', '_strftime',
    '_task_info', '_mach_task_self_', '_rand', '_srand', '_isdigit', '_isspace', '_tolower',
    '_toupper', '_setenv', '_unsetenv', '_sysconf', '_uname', '_gethostname', '_pthread_mutex_init',
    '_pthread_mutex_lock', '_pthread_mutex_unlock', '_pthread_mutex_destroy', '_pthread_self',
    '_pthread_create', '_pthread_join', '_pthread_attr_init', '_pthread_attr_setstacksize',
    '_pthread_attr_destroy', '_arc4random_buf', '_proc_pidpath', '_backtrace', '_backtrace_symbols',
    '_backtrace_symbols_fd', '_dispatch_semaphore_create', '_dispatch_semaphore_signal',
    '_dispatch_semaphore_wait', '_dispatch_time', '_dispatch_release', '_setvbuf', '_setbuf',
    '_memchr', '_getlogin_r', '_getppid', '_getgid', '_getegid', '_ftruncate', '_mkstemp', '_statvfs',
    '_chown', '_sigaction', '_sigemptyset', '_sigaddset', '_sigprocmask', '_select', '_kqueue',
    '_abs', '_tcgetattr', '_tcsetattr', '_ioctl', '_getchar', '_getline', '_fdopen', '_feof',
    '_ferror', '_setpgid', '_ptrace', '_wait', '_timegm', '_clock_gettime', '_aligned_alloc',
    '_utime', '_getlogin', '_environ', '___error', '___stdinp', '__dyld_get_image_name',
    '__dyld_get_image_header', '_cos', '_sin', '_tan', '_acos', '_asin', '_atan', '_atan2', '_cosh',
    '_sinh', '_tanh', '_acosh', '_asinh', '_atanh', '_exp', '_exp2', '_log', '_log2', '_log10',
    '_pow', '_sqrt', '_cbrt', '_ceil', '_floor', '_round', '_trunc', '_fmod', '_remainder', '_fabs',
    '_copysign', '_fmax', '_fmin', '_hypot', '_ldexp', '_frexp', '_modf', '_scalbn', '_ilogb',
    '_logb', '_erf', '_erfc', '_lgamma', '_tgamma', '_j0', '_j1', '_jn', '_y0', '_y1', '_yn',
    '_mprotect', '_sys_icache_invalidate', '_objc_msgSend', '_objc_getClass', '_sel_registerName',
    '_objc_alloc_init', '_objc_autoreleasePoolPush', '_objc_autoreleasePoolPop',
    '_MTLCreateSystemDefaultDevice', '_dlopen', '_dlsym']

const bench_runtime_stub_names = ['current_rss_kb', 'macos_peak_rss_kb', 'linux_rss_kb',
    'bench.current_rss_kb', 'bench.macos_peak_rss_kb', 'bench.linux_rss_kb',
    'v3.bench.current_rss_kb', 'v3.bench.macos_peak_rss_kb', 'v3.bench.linux_rss_kb']

// Builder stores state for SSA construction.
pub struct Builder {
mut:
    m                  &Module            = unsafe { nil }
    a                  &flat.FlatAst      = unsafe { nil }
    tc                 &types.TypeChecker = unsafe { nil }
    used_fns           map[string]bool
    cur_module         string
    cur_func           int
    cur_func_ret_type  string
    cur_block          BlockID
    vars               map[string]ValueID
    var_type_names     map[string]string
    i64_type           TypeID
    i32_type           TypeID
    i8_type            TypeID
    i1_type            TypeID
    u64_type           TypeID
    u32_type           TypeID
    u16_type           TypeID
    u8_type            TypeID
    f32_type           TypeID
    f64_type           TypeID
    void_type          TypeID
    str_type           TypeID
    array_type         TypeID
    map_type           TypeID
    map_state_type     TypeID
    fn_types           map[string]TypeID
    fn_ids             map[string]int
    const_exprs        map[string]flat.NodeId
    struct_types       map[string]TypeID
    struct_field_types map[string]string
    option_types       map[string]TypeID
    sum_type_variants  map[string][]string
    sum_type_canonical map[string]string
    enum_types         map[string]bool
    flag_enum_types    map[string]bool
    enum_values        map[string]int
    enum_member_values map[string]int
    enum_member_dupes  map[string]bool
    c_fn_ids           map[string]int
    c_fn_types         map[string]TypeID
    label_blocks       map[string]BlockID
    defer_body_ids     []flat.NodeId
    break_targets      []BlockID
    continue_targets   []BlockID
    top_level_main     bool
    // --- Build-control machinery (ported from v2 build_all) ---
    // When set, build_functions only materializes this one function body (hot reload).
    hot_fn string
    // When set, build_functions registers signatures only and marks them prototypes.
    skip_fn_bodies bool
    // When non-empty, all functions declared in these modules are skipped (dead
    // code elimination for unused backends/modules).
    skip_modules map[string]bool
    // SSA-level type alias name -> resolved base TypeID. Supplements the checker's
    // alias map (used when building without a checker).
    type_aliases map[string]TypeID
}

// VarBinding represents var binding data used by ssa.
struct VarBinding {
    exists bool
    addr   ValueID
    typ    string
}

// IfGuardState stores if guard state state used by ssa.
struct IfGuardState {
    active    bool
    name      string
    old       VarBinding
    slot      ValueID
    value_ptr ValueID
    typ       TypeID
    typ_name  string
}

// BuildOptions controls which functions a build materializes. The zero value
// reproduces the default whole-program build.
pub struct BuildOptions {
pub:
    hot_fn         string   // build only this function's body (hot reload)
    skip_fn_bodies bool     // register signatures only, mark them prototypes
    skip_modules   []string // skip all functions declared in these modules
}

// build supports build handling for ssa.
pub fn build(a_ &flat.FlatAst) &Module {
    return build_with_used(a_, map[string]bool{}, unsafe { nil })
}

// build_with_used builds with used data for ssa.
pub fn build_with_used(a_ &flat.FlatAst, used_fns map[string]bool, tc &types.TypeChecker) &Module {
    return build_with_options(a_, used_fns, tc, BuildOptions{})
}

// build_with_options builds with options data for ssa.
pub fn build_with_options(a_ &flat.FlatAst, used_fns map[string]bool, tc &types.TypeChecker, opts BuildOptions) &Module {
    mut b := Builder{
        m:                  Module.new()
        a:                  unsafe { a_ }
        tc:                 unsafe { tc }
        used_fns:           used_fns
        vars:               map[string]ValueID{}
        var_type_names:     map[string]string{}
        fn_types:           map[string]TypeID{}
        fn_ids:             map[string]int{}
        const_exprs:        map[string]flat.NodeId{}
        struct_types:       map[string]TypeID{}
        struct_field_types: map[string]string{}
        option_types:       map[string]TypeID{}
        sum_type_variants:  map[string][]string{}
        sum_type_canonical: map[string]string{}
        enum_types:         map[string]bool{}
        flag_enum_types:    map[string]bool{}
        enum_values:        map[string]int{}
        enum_member_values: map[string]int{}
        enum_member_dupes:  map[string]bool{}
        c_fn_ids:           map[string]int{}
        c_fn_types:         map[string]TypeID{}
        label_blocks:       map[string]BlockID{}
        defer_body_ids:     []flat.NodeId{}
        break_targets:      []BlockID{}
        continue_targets:   []BlockID{}
        skip_modules:       map[string]bool{}
        type_aliases:       map[string]TypeID{}
    }
    b.void_type = TypeID(0)
    b.i64_type = b.m.type_store.get_int(64)
    b.i32_type = b.m.type_store.get_int(32)
    b.i8_type = b.m.type_store.get_int(8)
    b.i1_type = b.m.type_store.get_int(1)
    b.u64_type = b.m.type_store.get_uint(64)
    b.u32_type = b.m.type_store.get_uint(32)
    b.u16_type = b.m.type_store.get_uint(16)
    b.u8_type = b.m.type_store.get_uint(8)
    b.f32_type = b.m.type_store.get_float(32)
    b.f64_type = b.m.type_store.get_float(64)
    mut str_fields := []TypeID{}
    str_fields << b.m.type_store.get_ptr(b.i8_type)
    str_fields << b.i32_type
    // `is_lit` occupies the trailing 4-byte slot (offset 12) that the struct is padded
    // to anyway. It must be a named field so `s.is_lit` (e.g. in `string.free`) resolves
    // to offset 12 instead of defaulting to offset 0 (which would read `str`).
    str_fields << b.i32_type
    mut str_field_names := []string{}
    str_field_names << 'str'
    str_field_names << 'len'
    str_field_names << 'is_lit'
    b.str_type = b.m.type_store.register(Type{
        kind:        .struct_t
        fields:      str_fields
        field_names: str_field_names
    })
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    mut array_fields := []TypeID{}
    array_fields << ptr_i8
    array_fields << b.i32_type
    array_fields << b.i32_type
    array_fields << b.i32_type
    array_fields << b.i32_type
    array_fields << b.i32_type
    mut array_field_names := []string{}
    array_field_names << 'data'
    array_field_names << 'offset'
    array_field_names << 'len'
    array_field_names << 'cap'
    array_field_names << 'flags'
    array_field_names << 'element_size'
    b.array_type = b.m.type_store.register(Type{
        kind:        .struct_t
        fields:      array_fields
        field_names: array_field_names
    })
    mut map_state_fields := []TypeID{}
    map_state_fields << ptr_i8
    map_state_fields << ptr_i8
    map_state_fields << b.i64_type
    map_state_fields << b.i64_type
    map_state_fields << b.i64_type
    map_state_fields << b.i64_type
    mut map_state_field_names := []string{}
    map_state_field_names << 'keys'
    map_state_field_names << 'vals'
    map_state_field_names << 'cap'
    map_state_field_names << 'len'
    map_state_field_names << 'key_size'
    map_state_field_names << 'val_size'
    b.map_state_type = b.m.type_store.register(Type{
        kind:        .struct_t
        fields:      map_state_fields
        field_names: map_state_field_names
    })
    mut map_fields := []TypeID{}
    map_fields << b.m.type_store.get_ptr(b.map_state_type)
    mut map_field_names := []string{}
    map_field_names << 'state'
    b.map_type = b.m.type_store.register(Type{
        kind:        .struct_t
        fields:      map_fields
        field_names: map_field_names
    })
    b.hot_fn = opts.hot_fn
    b.skip_fn_bodies = opts.skip_fn_bodies
    for mname in opts.skip_modules {
        b.skip_modules[mname] = true
    }
    b.m.name = b.main_module_name()
    b.register_type_aliases()
    b.register_types()
    b.register_consts()
    b.register_globals()
    b.register_functions()
    b.build_functions()
    return b.m
}

// register_types updates register types state for ssa.
fn (mut b Builder) register_types() {
    mut cur_module := ''
    for node in b.a.nodes {
        if node.kind == .module_decl {
            cur_module = node.value
            continue
        }
        if node.kind == .struct_decl {
            typ_id := b.m.type_store.register(Type{
                kind: .struct_t
            })
            b.register_struct_type_name(node.value, cur_module, typ_id)
        } else if node.kind == .type_decl && node.children_count > 0 {
            typ_id := b.m.type_store.register(Type{
                kind: .struct_t
            })
            b.register_sum_type_name(node.value, cur_module, typ_id)
        } else if node.kind == .enum_decl {
            b.register_enum_values(node, cur_module)
        }
    }

    cur_module = ''
    for node in b.a.nodes {
        if node.kind == .module_decl {
            cur_module = node.value
            continue
        }
        if node.kind == .struct_decl {
            mut field_types := []TypeID{}
            mut field_names := []string{}
            for i in 0 .. node.children_count {
                f := b.a.child_node(&node, i)
                field_type := b.resolve_type_in_module(f.typ, cur_module)
                field_type_name := qualify_type_ref_name(f.typ, cur_module)
                field_types << field_type
                field_names << f.value
                b.struct_field_types[node.value + '.' + f.value] = field_type_name
                short_name := node.value.all_after('.')
                b.struct_field_types[short_name + '.' + f.value] = field_type_name
                if cur_module.len > 0 && cur_module != 'main' && cur_module != 'builtin' {
                    b.struct_field_types[cur_module + '.' + short_name + '.' + f.value] = field_type_name
                }
            }
            typ_id := b.struct_type_id_for_decl(node.value, cur_module)
            b.m.type_store.types[typ_id] = Type{
                kind:        .struct_t
                fields:      field_types
                field_names: field_names
            }
        } else if node.kind == .type_decl && node.children_count > 0 {
            sum_name := qualify_type_name(node.value, cur_module)
            variants := b.sum_type_variants[sum_name] or { []string{} }
            mut field_types := []TypeID{}
            mut field_names := []string{}
            field_types << b.i32_type
            field_names << 'typ'
            for variant in variants {
                mut variant_type := b.resolve_type_in_module(variant, cur_module)
                if variant_type > 0 && variant_type < b.m.type_store.types.len
                    && b.m.type_store.types[variant_type].kind == .struct_t {
                    variant_type = b.m.type_store.get_ptr(variant_type)
                }
                field_types << variant_type
                field_names << sum_variant_field_name(variant)
            }
            typ_id := b.struct_type_id_for_decl(node.value, cur_module)
            b.m.type_store.types[typ_id] = Type{
                kind:        .struct_t
                fields:      field_types
                field_names: field_names
            }
        }
    }

    cur_module = ''
    for node in b.a.nodes {
        if node.kind == .module_decl {
            cur_module = node.value
            continue
        }
        if node.kind != .type_decl || node.children_count == 0 {
            continue
        }
        sum_typ_id := b.struct_type_id_for_decl(node.value, cur_module)
        mut field_types := []TypeID{}
        mut field_names := []string{}
        field_types << b.i64_type
        field_names << 'typ'
        b.register_sum_field_type(node.value, cur_module, 'typ', 'int')
        variants := b.sum_type_variants_for_decl(node, cur_module)
        for variant in variants {
            field_name := sum_variant_field_name(variant)
            mut field_type := b.resolve_type_in_module(variant, cur_module)
            if field_type > 0 && field_type < b.m.type_store.types.len
                && b.m.type_store.types[field_type].kind == .struct_t {
                field_type = b.m.type_store.get_ptr(field_type)
            }
            field_types << field_type
            field_names << field_name
            b.register_sum_field_type(node.value, cur_module, field_name, variant)
        }
        b.m.type_store.types[sum_typ_id] = Type{
            kind:        .struct_t
            fields:      field_types
            field_names: field_names
        }
    }
    b.register_multi_return_types()
}

// register_multi_return_types updates register multi return types state for ssa.
fn (mut b Builder) register_multi_return_types() {
    if b.tc == unsafe { nil } {
        return
    }
    for _, ret in b.tc.fn_ret_types {
        if ret is types.MultiReturn {
            b.register_multi_return_type(ret)
        }
    }
}

// register_multi_return_type updates register multi return type state for ssa.
fn (mut b Builder) register_multi_return_type(ret types.MultiReturn) TypeID {
    name := b.multi_return_c_type(ret)
    if typ := b.struct_types[name] {
        return typ
    }
    typ_id := b.m.type_store.register(Type{
        kind: .struct_t
    })
    b.struct_types[name] = typ_id
    mut field_types := []TypeID{}
    mut field_names := []string{}
    for i, field_type in ret.types {
        field_types << b.ssa_type_from_checker_type(field_type)
        field_name := 'arg${i}'
        field_names << field_name
        b.struct_field_types[name + '.' + field_name] = field_type.name()
    }
    b.m.type_store.types[typ_id] = Type{
        kind:        .struct_t
        fields:      field_types
        field_names: field_names
    }
    return typ_id
}

// multi_return_c_type supports multi return c type handling for Builder.
fn (b &Builder) multi_return_c_type(ret types.MultiReturn) string {
    mut parts := []string{}
    for field_type in ret.types {
        parts << b.tc.c_type(field_type)
    }
    return 'multi_return_${parts.join('_')}'
}

// primitive_type_name supports primitive type name handling for ssa.
fn primitive_type_name(typ types.Primitive) string {
    if typ.props.has(.boolean) {
        return 'bool'
    }
    if typ.props.has(.integer) {
        if typ.props.has(.unsigned) {
            return match typ.size {
                8 { 'u8' }
                16 { 'u16' }
                32 { 'u32' }
                64 { 'u64' }
                else { 'u${typ.size}' }
            }
        }
        return match typ.size {
            0 { 'int' }
            8 { 'i8' }
            16 { 'i16' }
            32 { 'i32' }
            64 { 'i64' }
            else { 'i${typ.size}' }
        }
    }
    if typ.props.has(.float) {
        return match typ.size {
            32 { 'f32' }
            else { 'f64' }
        }
    }
    return 'int'
}

// ssa_type_from_checker_type converts ssa type from checker type data for ssa.
fn (mut b Builder) ssa_type_from_checker_type(typ types.Type) TypeID {
    if typ is types.Void {
        return b.void_type
    }
    if typ is types.String {
        return b.str_type
    }
    if typ is types.Char {
        return b.i8_type
    }
    if typ is types.Rune {
        return b.i32_type
    }
    if typ is types.ISize || typ is types.USize {
        return b.i64_type
    }
    if typ is types.Primitive {
        return b.resolve_type(primitive_type_name(typ))
    }
    if typ is types.Array {
        return b.array_type
    }
    if typ is types.ArrayFixed {
        return b.m.type_store.get_ptr(b.ssa_type_from_checker_type(typ.elem_type))
    }
    if typ is types.Map {
        return b.map_type
    }
    if typ is types.Pointer {
        return b.m.type_store.get_ptr(b.ssa_type_from_checker_type(typ.base_type))
    }
    if typ is types.OptionType {
        return b.option_type_id(typ.base_type.name())
    }
    if typ is types.ResultType {
        return b.option_type_id(typ.base_type.name())
    }
    if typ is types.Enum {
        return b.i32_type
    }
    if typ is types.MultiReturn {
        return b.register_multi_return_type(typ)
    }
    if typ is types.Alias {
        return b.ssa_type_from_checker_type(typ.base_type)
    }
    return b.resolve_type(typ.name())
}

// register_enum_values updates register enum values state for ssa.
fn (mut b Builder) register_enum_values(node flat.Node, module_name string) {
    short_name := node.value.all_after('.')
    mut enum_names := []string{}
    enum_names << node.value
    if short_name != node.value {
        enum_names << short_name
    }
    if module_name.len > 0 && module_name != 'main' && module_name != 'builtin' {
        enum_names << module_name + '.' + short_name
    }
    mut is_flag_enum := false
    for enum_name in enum_names {
        if b.checker_has_flag_enum(enum_name) {
            is_flag_enum = true
            break
        }
    }
    for enum_name in enum_names {
        b.enum_types[enum_name] = true
        if is_flag_enum {
            b.flag_enum_types[enum_name] = true
        }
    }
    mut value := 0
    for i in 0 .. node.children_count {
        field := b.a.child_node(&node, i)
        if field.kind != .enum_field {
            continue
        }
        if field.children_count > 0 {
            if explicit := b.enum_field_expr_value(b.a.child(field, 0)) {
                value = explicit
            }
        }
        for enum_name in enum_names {
            enum_key := enum_name + '.' + field.value
            b.enum_values[enum_key] = value
        }
        if existing := b.enum_member_values[field.value] {
            if existing != value {
                b.enum_member_dupes[field.value] = true
            }
        } else {
            b.enum_member_values[field.value] = value
        }
        value++
    }
}

// register_struct_type_name updates register struct type name state for ssa.
fn (mut b Builder) register_struct_type_name(name string, module_name string, typ_id TypeID) {
    b.struct_types[name] = typ_id
    short_name := name.all_after('.')
    if short_name !in b.struct_types {
        b.struct_types[short_name] = typ_id
    }
    if module_name.len > 0 && module_name != 'main' && module_name != 'builtin' {
        qualified_name := module_name + '.' + short_name
        b.struct_types[qualified_name] = typ_id
    }
}

// register_sum_type_name updates register sum type name state for ssa.
fn (mut b Builder) register_sum_type_name(name string, module_name string, typ_id TypeID) {
    qualified_name := qualify_type_name(name, module_name)
    b.register_struct_type_name(name, module_name, typ_id)
    mut variants := []string{}
    if b.tc != unsafe { nil } {
        if tc_variants := b.tc.sum_types[qualified_name] {
            variants = tc_variants.clone()
        }
    }
    if variants.len == 0 {
        for node in b.a.nodes {
            if node.kind != .type_decl || node.value != name || node.children_count == 0 {
                continue
            }
            for i in 0 .. node.children_count {
                variant := b.a.child_node(&node, i)
                variants << qualify_type_name(variant.value, module_name)
            }
            break
        }
    }
    b.sum_type_variants[qualified_name] = variants
    b.sum_type_canonical[qualified_name] = qualified_name
    if name != qualified_name {
        b.sum_type_variants[name] = variants
        b.sum_type_canonical[name] = qualified_name
    }
    short_name := qualified_name.all_after('.')
    b.sum_type_variants[short_name] = variants
    b.sum_type_canonical[short_name] = qualified_name
}

// qualify_type_name supports qualify type name handling for ssa.
fn qualify_type_name(name string, module_name string) string {
    if name.contains('.') || module_name.len == 0 || module_name == 'main'
        || module_name == 'builtin' {
        return name
    }
    return '${module_name}.${name}'
}

// qualify_type_ref_name supports qualify type ref name handling for ssa.
fn qualify_type_ref_name(name string, module_name string) string {
    if name.len == 0 {
        return name
    }
    if name.starts_with('&') {
        return '&' + qualify_type_ref_name(name[1..], module_name)
    }
    if name.len > 1 && (name[0] == `?` || name[0] == `!`) {
        return name[..1] + qualify_type_ref_name(name[1..], module_name)
    }
    if name.starts_with('[]') {
        return '[]' + qualify_type_ref_name(name[2..], module_name)
    }
    if name.starts_with('[') {
        idx := name.index_u8(`]`)
        if idx > 0 && idx + 1 < name.len {
            return name[..idx + 1] + qualify_type_ref_name(name[idx + 1..], module_name)
        }
    }
    if name.contains('[') && name.ends_with(']') {
        idx := name.index_u8(`[`)
        if idx > 0 && idx < name.len - 1 {
            return qualify_type_ref_name(name[..idx], module_name) + name[idx..]
        }
    }
    if name.starts_with('map[') {
        key_type, val_type := map_type_parts(name)
        if key_type.len > 0 && val_type.len > 0 {
            return 'map[' + qualify_type_ref_name(key_type, module_name) + ']' +
                qualify_type_ref_name(val_type, module_name)
        }
    }
    if type_ref_is_builtin(name) || name.contains('.') || module_name.len == 0
        || module_name == 'main' || module_name == 'builtin' {
        return name
    }
    return module_name + '.' + name
}

// type_ref_is_builtin returns type ref is builtin data for ssa.
fn type_ref_is_builtin(name string) bool {
    return name in ['int', 'i8', 'i16', 'i32', 'i64', 'u8', 'byte', 'u16', 'u32', 'u64', 'f32',
        'f64', 'bool', 'string', 'void', 'voidptr', 'rune', 'char', 'array', 'map']
}

// sum_type_variants_for_decl supports sum type variants for decl handling for Builder.
fn (b &Builder) sum_type_variants_for_decl(node flat.Node, module_name string) []string {
    mut variants := []string{}
    for i in 0 .. node.children_count {
        variant := b.a.child_node(&node, i).value
        variants << qualify_type_name(variant, module_name)
    }
    return variants
}

// register_sum_field_type updates register sum field type state for ssa.
fn (mut b Builder) register_sum_field_type(name string, module_name string, field_name string, field_type string) {
    short_name := name.all_after('.')
    b.struct_field_types[name + '.' + field_name] = field_type
    b.struct_field_types[short_name + '.' + field_name] = field_type
    if module_name.len > 0 && module_name != 'main' && module_name != 'builtin' {
        b.struct_field_types[module_name + '.' + short_name + '.' + field_name] = field_type
    }
}

// struct_type_id_for_decl supports struct type id for decl handling for Builder.
fn (b &Builder) struct_type_id_for_decl(name string, module_name string) TypeID {
    short_name := name.all_after('.')
    if module_name.len > 0 && module_name != 'main' && module_name != 'builtin' {
        qualified_name := module_name + '.' + short_name
        if typ := b.struct_types[qualified_name] {
            return typ
        }
    }
    if typ := b.struct_types[name] {
        return typ
    }
    if typ := b.struct_types[short_name] {
        return typ
    }
    return TypeID(0)
}

// register_consts updates register consts state for ssa.
fn (mut b Builder) register_consts() {
    mut cur_module := ''
    for node in b.a.nodes {
        if node.kind == .module_decl {
            cur_module = node.value
            continue
        }
        if node.kind == .const_decl {
            for i in 0 .. node.children_count {
                field_id := b.a.child(&node, i)
                if int(field_id) < 0 {
                    continue
                }
                field := b.a.nodes[int(field_id)]
                if field.kind != .const_field || field.children_count == 0 {
                    continue
                }
                expr_id := b.a.child(&field, 0)
                if cur_module.len > 0 && cur_module != 'main' {
                    b.const_exprs['${cur_module}.${field.value}'] = expr_id
                } else {
                    b.const_exprs[field.value] = expr_id
                }
            }
        }
    }
}

// register_globals updates register globals state for ssa.
fn (mut b Builder) register_globals() {
    for node in b.a.nodes {
        if node.kind == .global_decl {
            for i in 0 .. node.children_count {
                f := b.a.child_node(&node, i)
                typ := b.resolve_type(f.typ)
                b.vars[f.value] = b.m.add_global(f.value, typ)
            }
        }
    }
    b.ensure_runtime_global('g_main_argc', b.i64_type)
    b.ensure_runtime_global('g_main_argv',
        b.m.type_store.get_ptr(b.m.type_store.get_ptr(b.i8_type)))
}

// ensure_runtime_global supports ensure runtime global handling for Builder.
fn (mut b Builder) ensure_runtime_global(name string, typ TypeID) {
    if name in b.vars {
        return
    }
    for v in b.m.values {
        if v.kind == .global && v.name == name {
            b.vars[name] = v.id
            return
        }
    }
    b.vars[name] = b.m.add_global(name, typ)
}

// register_functions updates register functions state for ssa.
fn (mut b Builder) register_functions() {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    mut p1 := []TypeID{}
    mut p2 := []TypeID{}
    mut p3 := []TypeID{}
    // C library externs
    p3 = []TypeID{}
    p3 << b.i64_type
    p3 << ptr_i8
    p3 << b.i64_type
    b.register_extern('write', b.i64_type, p3)
    b.register_extern('read', b.i64_type, p3)
    p3 = []TypeID{}
    p3 << ptr_i8
    p3 << b.i64_type
    p3 << b.i64_type
    b.register_extern('open', b.i64_type, p3)
    p1 = []TypeID{}
    p1 << b.i64_type
    b.register_extern('putchar', b.i64_type, p1)
    b.register_extern('getchar', b.i64_type, []TypeID{})
    p1 = []TypeID{}
    p1 << b.i64_type
    b.register_extern('close', b.i64_type, p1)
    p1 = []TypeID{}
    p1 << ptr_i8
    b.register_extern('puts', b.i64_type, p1)
    p1 = []TypeID{}
    p1 << ptr_i8
    b.register_extern('strlen', b.i64_type, p1)
    p1 = []TypeID{}
    p1 << b.i64_type
    b.register_extern('strerror', ptr_i8, p1)
    p1 = []TypeID{}
    p1 << ptr_i8
    b.register_extern('feof', b.i64_type, p1)
    p1 = []TypeID{}
    p1 << ptr_i8
    b.register_extern('ferror', b.i64_type, p1)
    p1 = []TypeID{}
    p1 << ptr_i8
    b.register_extern('fclose', b.i64_type, p1)
    p1 = []TypeID{}
    p1 << ptr_i8
    b.register_extern('pclose', b.i64_type, p1)
    p1 = []TypeID{}
    p1 << ptr_i8
    b.register_extern('ftell', b.i64_type, p1)
    p1 = []TypeID{}
    p1 << ptr_i8
    b.register_extern('rewind', b.void_type, p1)
    p2 = []TypeID{}
    p2 << ptr_i8
    p2 << ptr_i8
    b.register_extern('fputs', b.i64_type, p2)
    b.register_extern('stat', b.i64_type, p2)
    b.register_extern('lstat', b.i64_type, p2)
    b.register_extern('statvfs', b.i64_type, p2)
    b.register_extern('rename', b.i64_type, p2)
    b.register_extern('strcmp', b.i64_type, p2)
    p2 = []TypeID{}
    p2 << ptr_i8
    p2 << b.i64_type
    b.register_extern('strchr', ptr_i8, p2)
    b.register_extern('strrchr', ptr_i8, p2)
    p2 = []TypeID{}
    p2 << ptr_i8
    p2 << ptr_i8
    b.register_extern('fopen', ptr_i8, p2)
    p2 = []TypeID{}
    p2 << ptr_i8
    p2 << ptr_i8
    b.register_extern('popen', ptr_i8, p2)
    mut p4 := []TypeID{}
    p4 << ptr_i8
    p4 << b.i64_type
    p4 << b.i64_type
    p4 << ptr_i8
    b.register_extern('fread', b.i64_type, p4)
    p4 = []TypeID{}
    p4 << ptr_i8
    p4 << b.i64_type
    p4 << b.i64_type
    p4 << ptr_i8
    b.register_extern('fwrite', b.i64_type, p4)
    p3 = []TypeID{}
    p3 << ptr_i8
    p3 << b.i64_type
    p3 << b.i64_type
    b.register_extern('fseek', b.i64_type, p3)
    p1 = []TypeID{}
    p1 << b.i64_type
    b.register_extern('malloc', ptr_i8, p1)
    p2 = []TypeID{}
    p2 << b.i64_type
    p2 << b.i64_type
    b.register_extern('calloc', ptr_i8, p2)
    p2 = []TypeID{}
    p2 << ptr_i8
    p2 << b.i64_type
    b.register_extern('realloc', ptr_i8, p2)
    p3 = []TypeID{}
    p3 << ptr_i8
    p3 << ptr_i8
    p3 << b.i64_type
    b.register_extern('memcpy', ptr_i8, p3)
    p3 = []TypeID{}
    p3 << ptr_i8
    p3 << ptr_i8
    p3 << b.i64_type
    b.register_extern('memmove', ptr_i8, p3)
    p3 = []TypeID{}
    p3 << ptr_i8
    p3 << b.i64_type
    p3 << b.i64_type
    b.register_extern('memset', ptr_i8, p3)
    p3 = []TypeID{}
    p3 << ptr_i8
    p3 << ptr_i8
    p3 << b.i64_type
    b.register_extern('memcmp', b.i64_type, p3)
    p1 = []TypeID{}
    p1 << b.i64_type
    b.register_extern('exit', b.void_type, p1)
    p1 = []TypeID{}
    p1 << ptr_i8
    b.register_extern('fflush', b.void_type, p1)
    p2 = []TypeID{}
    p2 << ptr_i8
    p2 << b.i64_type
    b.register_extern('access', b.i64_type, p2)
    b.register_extern('mkdir', b.i64_type, p2)
    b.register_extern('chmod', b.i64_type, p2)
    b.register_extern('getcwd', ptr_i8, p2)
    p1 = []TypeID{}
    p1 << ptr_i8
    b.register_extern('remove', b.i64_type, p1)
    b.register_extern('unlink', b.i64_type, p1)
    b.register_extern('rmdir', b.i64_type, p1)
    b.register_extern('chdir', b.i64_type, p1)
    b.register_extern('getenv', ptr_i8, p1)
    b.register_extern('system', b.i64_type, p1)
    b.register_extern('opendir', ptr_i8, p1)
    b.register_extern('closedir', b.i64_type, p1)
    b.register_extern('fileno', b.i64_type, p1)
    b.register_extern('getc', b.i64_type, p1)
    b.register_extern('strdup', ptr_i8, p1)
    b.register_extern('atoi', b.i64_type, p1)
    p3 = []TypeID{}
    p3 << ptr_i8
    p3 << ptr_i8
    p3 << b.i64_type
    b.register_extern('readlink', b.i64_type, p3)
    b.register_extern('strncmp', b.i64_type, p3)
    p1 = []TypeID{}
    p1 << ptr_i8
    b.register_extern('readdir', ptr_i8, p1)
    b.register_extern('pipe', b.i64_type, p1)
    p3 = []TypeID{}
    p3 << ptr_i8
    p3 << ptr_i8
    p3 << b.i64_type
    b.register_extern('setenv', b.i64_type, p3)
    p3 = []TypeID{}
    p3 << b.i64_type
    p3 << ptr_i8
    p3 << b.i64_type
    b.register_extern('waitpid', b.i64_type, p3)
    p2 = []TypeID{}
    p2 << ptr_i8
    p2 << ptr_i8
    b.register_extern('realpath', ptr_i8, p2)
    b.register_extern('pthread_mutex_init', b.i64_type, p2)
    p1 = []TypeID{}
    p1 << ptr_i8
    b.register_extern('pthread_mutex_lock', b.i64_type, p1)
    b.register_extern('pthread_mutex_trylock', b.i64_type, p1)
    b.register_extern('pthread_mutex_unlock', b.i64_type, p1)
    b.register_extern('pthread_mutex_destroy', b.i64_type, p1)
    b.register_extern('pthread_self', b.i64_type, []TypeID{})
    b.register_extern('getpid', b.i64_type, []TypeID{})
    b.register_extern('clock', b.i64_type, []TypeID{})
    b.register_extern('mach_absolute_time', b.i64_type, []TypeID{})
    p1 = []TypeID{}
    p1 << ptr_i8
    b.register_extern('mach_timebase_info', b.void_type, p1)
    p1 = []TypeID{}
    p1 << b.i64_type
    b.register_extern('clock_gettime_nsec_np', b.i64_type, p1)
    p1 = []TypeID{}
    p1 << ptr_i8
    b.register_extern('time', b.i64_type, p1)
    b.register_extern('mktime', b.i64_type, p1)
    p2 = []TypeID{}
    p2 << ptr_i8
    p2 << ptr_i8
    b.register_extern('localtime_r', ptr_i8, p2)
    b.register_extern('gmtime_r', ptr_i8, p2)
    p4 = []TypeID{}
    p4 << ptr_i8
    p4 << b.i64_type
    p4 << ptr_i8
    p4 << ptr_i8
    b.register_extern('strftime', b.i64_type, p4)
    p2 = []TypeID{}
    p2 << ptr_i8
    p2 << ptr_i8
    b.register_extern('gettimeofday', b.i64_type, p2)
    p1 = []TypeID{}
    p1 << b.i64_type
    b.register_extern('sleep', b.i64_type, p1)
    b.register_extern('usleep', b.i64_type, p1)
    b.register_extern('dup', b.i64_type, p1)
    b.register_extern('isatty', b.i64_type, p1)
    p2 = []TypeID{}
    p2 << b.i64_type
    p2 << b.i64_type
    b.register_extern('dup2', b.i64_type, p2)
    p2 = []TypeID{}
    p2 << ptr_i8
    p2 << ptr_i8
    b.register_extern('nanosleep', b.i64_type, p2)
    p2 = []TypeID{}
    p2 << b.i64_type
    p2 << ptr_i8
    b.register_extern('clock_gettime', b.i64_type, p2)
    b.register_basic_format_stubs()
    b.register_string_plus_stubs()
    b.register_bench_runtime_stubs()
    p1 = []TypeID{}
    p1 << ptr_i8
    b.register_extern('free', b.void_type, p1)
    p2 = []TypeID{}
    p2 << ptr_i8
    p2 << ptr_i8
    b.register_extern('fprintf', b.void_type, p2)

    for node in b.a.nodes {
        if node.kind != .c_fn_decl {
            continue
        }
        ret_type := b.resolve_c_decl_type(node.typ)
        mut param_types := []TypeID{}
        for i in 0 .. node.children_count {
            child := b.a.child_node(&node, i)
            if child.kind == .param {
                param_types << b.resolve_c_decl_type(child.typ)
            }
        }
        b.register_extern(node.value, ret_type, param_types)
        if node.value.starts_with('C.') {
            b.register_extern(node.value[2..], ret_type, param_types)
        }
    }

    mut cur_module := ''
    for node in b.a.nodes {
        if node.kind == .module_decl {
            cur_module = node.value
            continue
        }
        if node.kind == .fn_decl {
            if b.skip_source_fn_in_module(node.value, cur_module) {
                continue
            }
            fn_name := ssa_fn_name_in_module(cur_module, node.value)
            if b.used_fns.len > 0 && !b.fn_is_used(node.value) && !b.fn_is_used(fn_name) {
                continue
            }
            ret_type := b.checker_return_type(node.value, cur_module) or {
                b.resolve_type_in_module(node.typ, cur_module)
            }
            mut param_types := []TypeID{}
            mut param_idx := 0
            for i in 0 .. node.children_count {
                child := b.a.child_node(&node, i)
                if child.kind == .param {
                    typ_name := if child.typ.starts_with('&') {
                        child.typ
                    } else {
                        b.checker_param_type_name(node.value, cur_module, param_idx) or {
                            child.typ
                        }
                    }
                    param_types << b.resolve_type_in_module(typ_name, cur_module)
                    param_idx++
                }
            }
            fn_type := b.m.type_store.register(Type{
                kind:     .func_t
                ret_type: ret_type
                params:   param_types
            })
            b.fn_types[fn_name] = fn_type
            func_id := b.m.new_function(fn_name, ret_type)
            b.fn_ids[fn_name] = func_id
        }
    }
    b.register_top_level_main()
    b.register_wyhash_stubs()
    b.register_string_eq_stub()
    b.register_fast_string_eq_stub()
    b.register_string_lt_stub()
    b.register_string_trim_stubs()
    b.register_string_last_part_stubs()
    b.register_ierror_stubs()
    b.register_array_runtime_stubs()
    b.register_arguments_stub()
    b.register_panic_stub()
    b.register_string_builder_stubs()
    b.register_path_runtime_stubs()
    b.register_map_runtime_stubs()
    b.register_u8_runtime_stubs()
    b.register_heap_tracking_stubs()
    b.register_printing_stubs()
    b.register_prealloc_atomic_stubs()
    b.register_process_capture_stubs()
    b.register_file_check_stubs()
    b.register_fd_macro_stubs()
    b.register_signal_macro_stubs()
    b.register_os_stat_stubs()
    b.register_array_string_stubs()
    b.register_fixed_array_contains_stubs()
    b.register_array_contains_stubs()
    b.register_enum_autostr_fns()
}

// register_enum_autostr_fns synthesizes a `<Enum>__autostr` helper per enum decl,
// mirroring cgen's enum_str_defs (gen/c/types.v). The transformer rewrites `${enum}`
// interpolation (when no custom `.str()` exists) into a call to this helper, so the
// ARM64/SSA path must provide it just like the C backend does. The body switches on the
// value and returns the matching field NAME, falling back to the integer rendering.
fn (mut b Builder) register_enum_autostr_fns() {
    mut cur_module := ''
    for node in b.a.nodes {
        match node.kind {
            .file {
                cur_module = ''
            }
            .module_decl {
                cur_module = node.value
            }
            .enum_decl {
                qualified := if cur_module.len > 0 && cur_module != 'main'
                    && cur_module != 'builtin' {
                    '${cur_module}.${node.value}'
                } else {
                    node.value
                }
                fn_name := '${qualified.replace('.', '__')}__autostr'
                if fn_name in b.fn_ids {
                    continue
                }
                is_flag := b.is_flag_enum_type_name(qualified)
                mut names := []string{}
                mut values := []int{}
                mut val := 0
                for i in 0 .. node.children_count {
                    field := b.a.child_node(&node, i)
                    if field.kind != .enum_field {
                        continue
                    }
                    if field.children_count > 0 {
                        if explicit := b.enum_field_expr_value(b.a.child(field, 0)) {
                            val = explicit
                        }
                    }
                    names << field.value
                    // Flag enums store one bit per field, matching `enum_value_for_type`.
                    values << if is_flag { 1 << val } else { val }
                    val++
                }
                mut p1 := []TypeID{}
                p1 << b.i64_type
                fid := b.register_synthetic_function(fn_name, b.str_type, p1)
                if is_flag {
                    // `@[flag]` enums stringify as `Name{.a | .b}` (and `Name{}` for 0),
                    // matching the C backend, rather than a single field name.
                    b.generate_flag_enum_autostr_body(fid, node.value.all_after_last('.'), names,
                        values)
                } else {
                    b.generate_enum_autostr_body(fid, names, values)
                }
            }
            else {}
        }
    }
}

// enum_field_expr_value evaluates the constant integer value of an enum-field initializer
// expression, mirroring cgen's enum_field_expr_value (gen/c/types.v). Without this the
// autostr helpers above would only honour bare `.int_literal` initializers and leave a
// field like `a = 1 << 3` / `a = -1` at the previous sequential value, so the generated
// `<Enum>__autostr` would compare against the wrong number.
fn (b &Builder) enum_field_expr_value(id flat.NodeId) ?int {
    if int(id) < 0 {
        return none
    }
    node := b.a.nodes[int(id)]
    match node.kind {
        .int_literal {
            return parse_int_literal(node.value)
        }
        .paren {
            if node.children_count == 0 {
                return none
            }
            return b.enum_field_expr_value(b.a.child(&node, 0))
        }
        .prefix {
            if node.children_count == 0 {
                return none
            }
            value := b.enum_field_expr_value(b.a.child(&node, 0))?
            return match node.op {
                .plus { value }
                .minus { -value }
                .bit_not { ~value }
                else { none }
            }
        }
        .infix {
            if node.children_count < 2 {
                return none
            }
            left := b.enum_field_expr_value(b.a.child(&node, 0))?
            right := b.enum_field_expr_value(b.a.child(&node, 1))?
            return match node.op {
                .plus {
                    left + right
                }
                .minus {
                    left - right
                }
                .mul {
                    left * right
                }
                .div {
                    if right == 0 {
                        none
                    } else {
                        left / right
                    }
                }
                .mod {
                    if right == 0 {
                        none
                    } else {
                        left % right
                    }
                }
                .amp {
                    left & right
                }
                .pipe {
                    left | right
                }
                .xor {
                    left ^ right
                }
                .left_shift {
                    int(u64(left) << right)
                }
                .right_shift, .right_shift_unsigned {
                    left >> right
                }
                else {
                    none
                }
            }
        }
        else {
            return none
        }
    }
}

// generate_enum_autostr_body emits the body of a `<Enum>__autostr` helper: a chain of
// equality tests returning each field's name as a string literal, with an `int_str`
// fallback for out-of-range (or combined-flag) values.
fn (mut b Builder) generate_enum_autostr_body(func_id int, field_names []string, field_values []int) {
    entry := b.m.add_block(func_id, 'entry')
    it := b.func_add_argument(func_id, b.i64_type, 'it')
    mut cur_block := entry
    mut seen := map[int]bool{}
    for i, fname in field_names {
        val := field_values[i]
        // Duplicate values would create unreachable cases; keep the first name.
        if val in seen {
            continue
        }
        seen[val] = true
        const_val := b.m.get_or_add_const(b.i64_type, val.str())
        cmp := b.block_instr2(.eq, cur_block, b.i1_type, it, const_val)
        match_block := b.m.add_block(func_id, 'autostr_match')
        next_block := b.m.add_block(func_id, 'autostr_next')
        b.block_instr3(.br, cur_block, b.void_type, cmp, ValueID(match_block), ValueID(next_block))
        name_val := b.m.add_value(.string_literal, b.str_type, fname, 0)
        b.block_instr1(.ret, match_block, b.void_type, name_val)
        cur_block = next_block
    }
    int_str_ref := b.m.add_value(.func_ref, b.str_type, 'int_str', b.fn_ids['int_str'])
    default_val := b.block_instr2(.call, cur_block, b.str_type, int_str_ref, it)
    b.block_instr1(.ret, cur_block, b.void_type, default_val)
}

// generate_flag_enum_autostr_body emits the body of a `<FlagEnum>__autostr` helper that
// renders a `@[flag]` value as `Name{.a | .b}` (and `Name{}` for 0), mirroring cgen's
// emit_flag_enum_autostr: start with `Name{`, append `.field` for every set bit (joined
// by ` | `), then append `}`. `field_values` holds each field's bit (1 << index).
fn (mut b Builder) generate_flag_enum_autostr_body(func_id int, short_name string, field_names []string, field_values []int) {
    ptr_string := b.m.type_store.get_ptr(b.str_type)
    ptr_i1 := b.m.type_store.get_ptr(b.i1_type)
    entry := b.m.add_block(func_id, 'entry')
    it := b.func_add_argument(func_id, b.i64_type, 'it')

    // res = "Name{"; first = true. Both live in stack slots so they can be updated
    // across the per-field branches (this body uses plain control flow, not phis).
    res_slot := b.block_instr0(.alloca, entry, ptr_string)
    first_slot := b.block_instr0(.alloca, entry, ptr_i1)
    open_lit := b.m.add_value(.string_literal, b.str_type, '${short_name}{', 0)
    b.block_instr2(.store, entry, b.void_type, open_lit, res_slot)
    true_const := b.m.get_or_add_const(b.i1_type, '1')
    b.block_instr2(.store, entry, b.void_type, true_const, first_slot)
    false_const := b.m.get_or_add_const(b.i1_type, '0')
    plus_ref := b.m.add_value(.func_ref, b.str_type, 'string__plus', b.fn_ids['string__plus'])

    mut cur_block := entry
    mut seen := map[int]bool{}
    for i, fname in field_names {
        bit := field_values[i]
        // A zero bit can never be "set" (matches the cgen `bit != 0` guard); skip it.
        if bit == 0 || bit in seen {
            continue
        }
        seen[bit] = true
        bit_const := b.m.get_or_add_const(b.i64_type, bit.str())
        masked := b.block_instr2(.and_, cur_block, b.i64_type, it, bit_const)
        is_set := b.block_instr2(.eq, cur_block, b.i1_type, masked, bit_const)
        append_block := b.m.add_block(func_id, 'fe_append')
        after_block := b.m.add_block(func_id, 'fe_after')
        b.block_instr3(.br, cur_block, b.void_type, is_set, ValueID(append_block),
            ValueID(after_block))

        // append_block: if not first, prepend the ` | ` separator first.
        first := b.block_instr1(.load, append_block, b.i1_type, first_slot)
        sep_block := b.m.add_block(func_id, 'fe_sep')
        name_block := b.m.add_block(func_id, 'fe_name')
        b.block_instr3(.br, append_block, b.void_type, first, ValueID(name_block),
            ValueID(sep_block))

        sep_res := b.block_instr1(.load, sep_block, b.str_type, res_slot)
        sep_lit := b.m.add_value(.string_literal, b.str_type, ' | ', 0)
        sep_joined := b.block_instr3(.call, sep_block, b.str_type, plus_ref, sep_res, sep_lit)
        b.block_instr2(.store, sep_block, b.void_type, sep_joined, res_slot)
        b.block_instr1(.jmp, sep_block, b.void_type, ValueID(name_block))

        name_res := b.block_instr1(.load, name_block, b.str_type, res_slot)
        name_lit := b.m.add_value(.string_literal, b.str_type, '.${fname}', 0)
        name_joined := b.block_instr3(.call, name_block, b.str_type, plus_ref, name_res, name_lit)
        b.block_instr2(.store, name_block, b.void_type, name_joined, res_slot)
        b.block_instr2(.store, name_block, b.void_type, false_const, first_slot)
        b.block_instr1(.jmp, name_block, b.void_type, ValueID(after_block))

        cur_block = after_block
    }

    close_res := b.block_instr1(.load, cur_block, b.str_type, res_slot)
    close_lit := b.m.add_value(.string_literal, b.str_type, '}', 0)
    final_res := b.block_instr3(.call, cur_block, b.str_type, plus_ref, close_res, close_lit)
    b.block_instr1(.ret, cur_block, b.void_type, final_res)
}

// ssa_fn_name_in_module supports ssa fn name in module handling for ssa.
fn ssa_fn_name_in_module(module_name string, name string) string {
    if module_name.len > 0 && module_name != 'main' && module_name != 'builtin' {
        return module_name + '.' + name
    }
    return name
}

// register_extern updates register extern state for ssa.
fn (mut b Builder) register_extern(name string, ret TypeID, params []TypeID) {
    fn_type := b.m.type_store.register(Type{
        kind:     .func_t
        ret_type: ret
        params:   params
    })
    extern_name := 'C.${name}'
    func_id := b.m.new_function(extern_name, ret)
    b.fn_types[name] = fn_type
    b.fn_ids[name] = func_id
    b.fn_types[extern_name] = fn_type
    b.c_fn_types[name] = fn_type
    b.c_fn_ids[name] = func_id
    mut f := b.m.funcs[func_id]
    f.is_c_extern = true
    f.is_prototype = true
    f.linkage = .external
    b.m.funcs[func_id] = f
}

// register_runtime_extern updates register runtime extern state for ssa.
fn (mut b Builder) register_runtime_extern(name string, ret TypeID, params []TypeID) {
    if b.has_fn_decl(name) {
        return
    }
    b.register_extern(name, ret, params)
}

// has_fn_decl reports whether has fn decl applies in ssa.
fn (b &Builder) has_fn_decl(name string) bool {
    for node in b.a.nodes {
        if node.kind == .fn_decl && node.value == name {
            return true
        }
    }
    return false
}

// skip_source_fn supports skip source fn handling for Builder.
fn (b &Builder) skip_source_fn(name string) bool {
    if name in bench_runtime_stub_names {
        return true
    }
    if name in ['_wymix', 'wyhash', 'wyhash64', 'string__eq', 'string__lt', 'array_new', 'array_get',
        'string__plus', 'string_plus_many', 'string.trim_right', 'array_push', 'array_push_many',
        'array.push_many', 'array_clone', 'panic', 'fast_string_eq', 'strings.new_builder',
        'strings.Builder.write_string', 'strings.Builder.writeln', 'strings.Builder.str',
        'strings.Builder.write_ptr', 'strings.Builder.write_u8', 'strings.Builder.write_runes',
        'strings.Builder.free', 'strings.Builder.last_n', 'Builder.write_string', 'Builder.writeln',
        'Builder.str', 'Builder.write_ptr', 'Builder.write_u8', 'Builder.write_runes', 'Builder.free',
        'Builder.last_n', 'new_map', 'map__set', 'map__get', 'map__exists', 'map__get_check',
        'map__get_or_set', 'map__delete', 'map__clear', 'map__clone', 'v3_map_find',
        'v3_map_set_sized', 'u8.is_digit', 'u8.is_letter', 'u8.is_alnum', 'u8.is_capital', 'bytestr',
        '[]u8.bytestr', 'Array_u8__bytestr', 'Array_u8__hex', 'Array_rune__string',
        'array.repeat_to_depth', 'string.all_before_last', 'string__all_before_last',
        'all_before_last', 'string.all_after_last', 'string__all_after_last', 'all_after_last',
        '_ht_alloc', '_ht_free', 'f32_to_str_l', 'f32_to_str_l_with_dot', 'f64_to_str_l',
        'f64_to_str_l_with_dot', 'print', 'println', 'eprint', 'eprintln', 'arguments', 'tos2',
        'tos3', 'tos_clone', 'v_prealloc_atomic_add_i32', 'v_prealloc_atomic_load_i32',
        'v_prealloc_atomic_store_i32', 'v_prealloc_atomic_cas_i32', 'FD_ZERO', 'FD_SET', 'FD_ISSET',
        'v_signal_with_handler_cast', 'normalize_path_in_builder', 'check_fwrite', 'check_fread',
        'os.check_fwrite', 'os.check_fread', 'fxx_to_str_l_parse', 'fxx_to_str_l_parse_with_dot',
        'u8.vstring', 'u8.vstring_with_len', 'char.vstring', 'char.vstring_with_len',
        'byteptr.vstring', 'byteptr.vstring_with_len', 'charptr.vstring', 'charptr.vstring_with_len',
        'u8.vstring_literal', 'u8.vstring_literal_with_len', 'char.vstring_literal',
        'char.vstring_literal_with_len', 'byteptr.vstring_literal',
        'byteptr.vstring_literal_with_len', 'charptr.vstring_literal',
        'charptr.vstring_literal_with_len'] {
        return true
    }
    return name.starts_with('print_backtrace') || name.starts_with('backtrace_')
        || name.starts_with('map.')
        || name in ['print_libbacktrace', 'eprint_libbacktrace', 'bsd_backtrace_resolve_atos']
}

// skip_source_fn_in_module supports skip source fn in module handling for Builder.
fn (b &Builder) skip_source_fn_in_module(name string, module_name string) bool {
    if module_name == 'builtin' && name in b.c_fn_ids {
        return true
    }
    if module_name == 'ast' && name in ['Expr.name', 'SelectorExpr.name', '[]Expr.name_list'] {
        return true
    }
    if module_name == 'c' && name.starts_with('Gen.') {
        return true
    }
    if module_name == 'os' && name in ['is_dir', 'is_link', 'ls'] {
        return true
    }
    return b.skip_source_fn(name)
}

// register_top_level_main updates register top level main state for ssa.
fn (mut b Builder) register_top_level_main() {
    if 'main' in b.fn_ids || !b.has_top_level_stmts() {
        return
    }
    fn_type := b.m.type_store.register(Type{
        kind:     .func_t
        ret_type: b.void_type
    })
    b.fn_types['main'] = fn_type
    b.fn_ids['main'] = b.m.new_function('main', b.void_type)
    b.top_level_main = true
}

// has_top_level_stmts reports whether has top level stmts applies in ssa.
fn (b &Builder) has_top_level_stmts() bool {
    return b.top_level_stmt_ids().len > 0
}

// top_level_stmt_ids supports top level stmt ids handling for Builder.
fn (b &Builder) top_level_stmt_ids() []flat.NodeId {
    mut ids := []flat.NodeId{}
    for file_idx, file_node in b.a.nodes {
        if file_idx < b.a.user_code_start || file_node.kind != .file
            || file_node.children_count == 0 {
            continue
        }
        for i in 0 .. file_node.children_count {
            child_id := b.a.child(&file_node, i)
            if int(child_id) < b.a.user_code_start {
                continue
            }
            child := b.a.nodes[int(child_id)]
            if b.is_top_level_stmt(child) {
                ids << child_id
            }
        }
    }
    return ids
}

// is_top_level_stmt reports whether is top level stmt applies in ssa.
fn (b &Builder) is_top_level_stmt(node flat.Node) bool {
    return match node.kind {
        .expr_stmt, .assign, .decl_assign, .selector_assign, .index_assign, .for_stmt,
        .for_in_stmt, .if_expr, .assert_stmt, .defer_stmt, .block {
            true
        }
        else {
            false
        }
    }
}

// register_wyhash_stubs updates register wyhash stubs state for ssa.
fn (mut b Builder) register_wyhash_stubs() {
    mut p2 := []TypeID{}
    p2 << b.i64_type
    p2 << b.i64_type
    wymix_id := b.register_synthetic_function('_wymix', b.i64_type, p2)
    b.generate_wymix_body(wymix_id)
    wyhash64_id := b.register_synthetic_function('wyhash64', b.i64_type, p2)
    b.generate_wyhash64_body(wyhash64_id)

    ptr_u8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_u64 := b.m.type_store.get_ptr(b.u64_type)
    mut p4 := []TypeID{}
    p4 << ptr_u8
    p4 << b.i64_type
    p4 << b.i64_type
    p4 << ptr_u64
    wyhash_id := b.register_synthetic_function('wyhash', b.i64_type, p4)
    b.generate_wyhash_body(wyhash_id)
}

// register_synthetic_function updates register synthetic function state for ssa.
fn (mut b Builder) register_synthetic_function(name string, ret TypeID, params []TypeID) int {
    fn_type := b.m.type_store.register(Type{
        kind:     .func_t
        ret_type: ret
        params:   params
    })
    b.fn_types[name] = fn_type
    func_id := b.m.new_function(name, ret)
    b.fn_ids[name] = func_id
    mut f := b.m.funcs[func_id]
    f.typ = ret
    f.blocks = []BlockID{}
    f.params = []ValueID{}
    f.is_c_extern = false
    b.m.funcs[func_id] = f
    return func_id
}

// func_add_argument supports func add argument handling for Builder.
fn (mut b Builder) func_add_argument(func_id int, typ TypeID, name string) ValueID {
    mut f := b.m.funcs[func_id]
    param := b.m.add_value(.argument, typ, name, f.params.len)
    f.params << param
    b.m.funcs[func_id] = f
    return param
}

// block_instr0 supports block instr0 handling for Builder.
fn (mut b Builder) block_instr0(op OpCode, block_id BlockID, typ TypeID) ValueID {
    ops := []ValueID{}
    return b.m.add_instr(op, block_id, typ, ops)
}

// block_instr1 supports block instr1 handling for Builder.
fn (mut b Builder) block_instr1(op OpCode, block_id BlockID, typ TypeID, a ValueID) ValueID {
    mut ops := []ValueID{}
    ops << a
    return b.m.add_instr(op, block_id, typ, ops)
}

// block_instr2 supports block instr2 handling for Builder.
fn (mut b Builder) block_instr2(op OpCode, block_id BlockID, typ TypeID, a ValueID, c ValueID) ValueID {
    mut ops := []ValueID{}
    ops << a
    ops << c
    return b.m.add_instr(op, block_id, typ, ops)
}

// block_instr3 supports block instr3 handling for Builder.
fn (mut b Builder) block_instr3(op OpCode, block_id BlockID, typ TypeID, a ValueID, c ValueID, d ValueID) ValueID {
    mut ops := []ValueID{}
    ops << a
    ops << c
    ops << d
    return b.m.add_instr(op, block_id, typ, ops)
}

// block_instr4 supports block instr4 handling for Builder.
fn (mut b Builder) block_instr4(op OpCode, block_id BlockID, typ TypeID, a ValueID, c ValueID, d ValueID, e ValueID) ValueID {
    mut ops := []ValueID{}
    ops << a
    ops << c
    ops << d
    ops << e
    return b.m.add_instr(op, block_id, typ, ops)
}

// block_struct_field_ptr supports block struct field ptr handling for Builder.
fn (mut b Builder) block_struct_field_ptr(block_id BlockID, base_addr ValueID, typ_id TypeID, field_idx int) ValueID {
    mut builtin_field_type := TypeID(0)
    mut builtin_offset := 0
    mut has_builtin_layout := false
    if typ_id == b.str_type {
        has_builtin_layout = true
        if field_idx == 0 {
            builtin_field_type = b.m.type_store.get_ptr(b.i8_type)
            builtin_offset = 0
        } else if field_idx == 1 {
            builtin_field_type = b.i32_type
            builtin_offset = 8
        } else if field_idx == 2 {
            // is_lit (i32) shares the trailing word with len; it sits at offset 12,
            // matching `struct_field_offset` used by the field readers.
            builtin_field_type = b.i32_type
            builtin_offset = 12
        } else {
            builtin_field_type = b.i64_type
            builtin_offset = field_idx * 8
        }
    } else if typ_id == b.array_type {
        has_builtin_layout = true
        if field_idx == 0 {
            builtin_field_type = b.m.type_store.get_ptr(b.i8_type)
            builtin_offset = 0
        } else {
            builtin_field_type = b.i32_type
            builtin_offset = 8 + (field_idx - 1) * 4
        }
    } else if typ_id == b.map_state_type {
        has_builtin_layout = true
        if field_idx == 0 || field_idx == 1 {
            builtin_field_type = b.m.type_store.get_ptr(b.i8_type)
        } else {
            builtin_field_type = b.i64_type
        }
        builtin_offset = field_idx * 8
    } else if typ_id == b.map_type {
        has_builtin_layout = true
        builtin_field_type = b.m.type_store.get_ptr(b.map_state_type)
        builtin_offset = 0
    }
    if has_builtin_layout {
        off_const := b.m.get_or_add_const(b.i64_type, '${builtin_offset}')
        return b.block_instr2(.get_element_ptr, block_id,
            b.m.type_store.get_ptr(builtin_field_type), base_addr, off_const)
    }
    typ := b.m.type_store.types[typ_id]
    field_type := if field_idx < typ.fields.len { typ.fields[field_idx] } else { b.i64_type }
    offset := b.m.struct_field_offset(typ_id, field_idx)
    off_const := b.m.get_or_add_const(b.i64_type, '${offset}')
    return b.block_instr2(.get_element_ptr, block_id, b.m.type_store.get_ptr(field_type),
        base_addr, off_const)
}

// block_load_array_int_field supports block load array int field handling for Builder.
fn (mut b Builder) block_load_array_int_field(block_id BlockID, arr_ptr ValueID, field_idx int) ValueID {
    field_ptr := b.block_struct_field_ptr(block_id, arr_ptr, b.array_type, field_idx)
    field32 := b.block_instr1(.load, block_id, b.i32_type, field_ptr)
    return b.block_instr1(.zext, block_id, b.i64_type, field32)
}

// register_basic_format_stubs converts register basic format stubs data for ssa.
fn (mut b Builder) register_basic_format_stubs() {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    mut p1_ptr := []TypeID{}
    p1_ptr << ptr_i8
    tos2_id := b.register_synthetic_function('tos2', b.str_type, p1_ptr)
    b.generate_tos2_body(tos2_id, 0)
    tos3_id := b.register_synthetic_function('tos3', b.str_type, p1_ptr)
    b.generate_tos2_body(tos3_id, 0)
    tos_clone_id := b.register_synthetic_function('tos_clone', b.str_type, p1_ptr)
    b.generate_tos_clone_body(tos_clone_id)
    b.register_pointer_string_stubs()

    mut p1_i64 := []TypeID{}
    p1_i64 << b.i64_type
    int_str_id := b.register_synthetic_function('int_str', b.str_type, p1_i64)
    b.generate_int_format_body(int_str_id, true, false)

    mut p1_i1 := []TypeID{}
    p1_i1 << b.i1_type
    bool_str_id := b.register_synthetic_function('bool_str', b.str_type, p1_i1)
    b.generate_bool_str_body(bool_str_id)

    mut p1_string := []TypeID{}
    p1_string << b.str_type
    string_int_id := b.register_synthetic_function('string.int', b.i64_type, p1_string)
    b.generate_string_int_body(string_int_id)
    string_int_c_id := b.register_synthetic_function('string__int', b.i64_type, p1_string)
    b.generate_string_int_body(string_int_c_id)

    mut p2_i64 := []TypeID{}
    p2_i64 << b.i64_type
    p2_i64 << b.i64_type
    format_int_id := b.register_synthetic_function('strconv__format_int', b.str_type, p2_i64)
    b.generate_int_format_body(format_int_id, true, true)
    format_uint_id := b.register_synthetic_function('strconv__format_uint', b.str_type, p2_i64)
    b.generate_int_format_body(format_uint_id, false, true)

    for name in ['strconv__f32_to_str_l', 'strconv__f32_to_str_l_with_dot', 'f32_to_str_l',
        'f32_to_str_l_with_dot', 'strconv__f64_to_str_l', 'strconv__f64_to_str_l_with_dot',
        'f64_to_str_l', 'f64_to_str_l_with_dot'] {
        float_str_id := b.register_synthetic_function(name, b.str_type, p1_i64)
        b.generate_const_string_body(float_str_id, '0.0')
    }
}

// register_pointer_string_stubs updates register pointer string stubs state for ssa.
fn (mut b Builder) register_pointer_string_stubs() {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    mut p1_ptr := []TypeID{}
    p1_ptr << ptr_i8
    for name in ['u8.vstring', 'char.vstring', 'byteptr.vstring', 'charptr.vstring',
        'u8.vstring_literal', 'char.vstring_literal', 'byteptr.vstring_literal',
        'charptr.vstring_literal'] {
        func_id := b.register_synthetic_function(name, b.str_type, p1_ptr)
        // The `_literal` wrappers borrow static C data (is_lit=1, never freed); the plain
        // ones return a non-copying view of a runtime buffer (is_lit=0), matching V.
        b.generate_tos2_body(func_id, if name.contains('_literal') { 1 } else { 0 })
    }

    mut p2_ptr_len := []TypeID{}
    p2_ptr_len << ptr_i8
    p2_ptr_len << b.i64_type
    for name in ['u8.vstring_with_len', 'char.vstring_with_len', 'byteptr.vstring_with_len',
        'charptr.vstring_with_len', 'u8.vstring_literal_with_len', 'char.vstring_literal_with_len',
        'byteptr.vstring_literal_with_len', 'charptr.vstring_literal_with_len'] {
        func_id := b.register_synthetic_function(name, b.str_type, p2_ptr_len)
        b.generate_vstring_with_len_body(func_id, if name.contains('_literal') { 1 } else { 0 })
    }
}

// generate_const_string_body supports generate const string body handling for Builder.
fn (mut b Builder) generate_const_string_body(func_id int, value string) {
    entry := b.m.add_block(func_id, 'entry')
    result := b.m.add_value(.string_literal, b.str_type, value, 0)
    b.block_instr1(.ret, entry, b.void_type, result)
}

// generate_bool_str_body supports generate bool str body handling for Builder.
fn (mut b Builder) generate_bool_str_body(func_id int) {
    entry := b.m.add_block(func_id, 'entry')
    value := b.func_add_argument(func_id, b.i1_type, 'value')
    true_block := b.m.add_block(func_id, 'bool_str_true')
    false_block := b.m.add_block(func_id, 'bool_str_false')
    b.block_instr3(.br, entry, b.void_type, value, ValueID(true_block), ValueID(false_block))
    true_val := b.m.add_value(.string_literal, b.str_type, 'true', 0)
    false_val := b.m.add_value(.string_literal, b.str_type, 'false', 0)
    b.block_instr1(.ret, true_block, b.void_type, true_val)
    b.block_instr1(.ret, false_block, b.void_type, false_val)
}

// generate_int_format_body converts generate int format body data for ssa.
fn (mut b Builder) generate_int_format_body(func_id int, is_signed bool, has_radix bool) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_i64 := b.m.type_store.get_ptr(b.i64_type)
    ptr_ptr_i8 := b.m.type_store.get_ptr(ptr_i8)

    entry := b.m.add_block(func_id, 'entry')
    value := b.func_add_argument(func_id, b.i64_type, 'value')
    if has_radix {
        _ := b.func_add_argument(func_id, b.i64_type, 'radix')
    }

    alloca_n := b.block_instr0(.alloca, entry, ptr_i64)
    alloca_len := b.block_instr0(.alloca, entry, ptr_i64)
    alloca_pos := b.block_instr0(.alloca, entry, ptr_ptr_i8)
    alloca_neg := b.block_instr0(.alloca, entry, b.m.type_store.get_ptr(b.i1_type))

    zero := b.m.get_or_add_const(b.i64_type, '0')
    one := b.m.get_or_add_const(b.i64_type, '1')
    ten := b.m.get_or_add_const(b.i64_type, '10')
    buf_size := b.m.get_or_add_const(b.i64_type, '32')
    last_off := b.m.get_or_add_const(b.i64_type, '31')
    minus_one := b.m.get_or_add_const(b.i64_type, '-1')
    ascii_zero := b.m.get_or_add_const(b.i64_type, '48')
    ascii_minus := b.m.get_or_add_const(b.i64_type, '45')
    false_val := b.m.get_or_add_const(b.i1_type, '0')
    true_val := b.m.get_or_add_const(b.i1_type, '1')

    malloc_ref := b.m.add_value(.func_ref, b.void_type, 'malloc', b.fn_ids['malloc'])
    buf := b.block_instr2(.call, entry, ptr_i8, malloc_ref, buf_size)
    end := b.block_instr2(.add, entry, ptr_i8, buf, last_off)
    nul := b.m.get_or_add_const(b.i8_type, '0')
    b.block_instr2(.store, entry, b.void_type, nul, end)
    b.block_instr2(.store, entry, b.void_type, end, alloca_pos)
    b.block_instr2(.store, entry, b.void_type, zero, alloca_len)
    b.block_instr2(.store, entry, b.void_type, false_val, alloca_neg)

    init_block := b.m.add_block(func_id, 'int_str_init')
    neg_block := b.m.add_block(func_id, 'int_str_neg')
    pos_block := b.m.add_block(func_id, 'int_str_pos')
    if is_signed {
        is_neg := b.block_instr2(.lt, entry, b.i1_type, value, zero)
        b.block_instr3(.br, entry, b.void_type, is_neg, ValueID(neg_block), ValueID(pos_block))
        abs_value := b.block_instr2(.sub, neg_block, b.i64_type, zero, value)
        b.block_instr2(.store, neg_block, b.void_type, abs_value, alloca_n)
        b.block_instr2(.store, neg_block, b.void_type, true_val, alloca_neg)
        b.block_instr1(.jmp, neg_block, b.void_type, ValueID(init_block))
        b.block_instr2(.store, pos_block, b.void_type, value, alloca_n)
        b.block_instr1(.jmp, pos_block, b.void_type, ValueID(init_block))
    } else {
        b.block_instr2(.store, entry, b.void_type, value, alloca_n)
        b.block_instr1(.jmp, entry, b.void_type, ValueID(init_block))
    }

    zero_digit_block := b.m.add_block(func_id, 'int_str_zero')
    loop_block := b.m.add_block(func_id, 'int_str_loop')
    sign_block := b.m.add_block(func_id, 'int_str_sign')
    sign_write_block := b.m.add_block(func_id, 'int_str_sign_write')
    done_block := b.m.add_block(func_id, 'int_str_done')

    n_init := b.block_instr1(.load, init_block, b.i64_type, alloca_n)
    is_zero := b.block_instr2(.eq, init_block, b.i1_type, n_init, zero)
    b.block_instr3(.br, init_block, b.void_type, is_zero, ValueID(zero_digit_block),
        ValueID(loop_block))

    pos_zero := b.block_instr1(.load, zero_digit_block, ptr_i8, alloca_pos)
    pos_zero_next := b.block_instr2(.add, zero_digit_block, ptr_i8, pos_zero, minus_one)
    b.block_instr2(.store, zero_digit_block, b.void_type, ascii_zero, pos_zero_next)
    b.block_instr2(.store, zero_digit_block, b.void_type, pos_zero_next, alloca_pos)
    b.block_instr2(.store, zero_digit_block, b.void_type, one, alloca_len)
    b.block_instr1(.jmp, zero_digit_block, b.void_type, ValueID(sign_block))

    n_cur := b.block_instr1(.load, loop_block, b.i64_type, alloca_n)
    rem := b.block_instr2(.srem, loop_block, b.i64_type, n_cur, ten)
    digit := b.block_instr2(.add, loop_block, b.i64_type, rem, ascii_zero)
    pos := b.block_instr1(.load, loop_block, ptr_i8, alloca_pos)
    pos_next := b.block_instr2(.add, loop_block, ptr_i8, pos, minus_one)
    b.block_instr2(.store, loop_block, b.void_type, digit, pos_next)
    b.block_instr2(.store, loop_block, b.void_type, pos_next, alloca_pos)
    old_len := b.block_instr1(.load, loop_block, b.i64_type, alloca_len)
    new_len := b.block_instr2(.add, loop_block, b.i64_type, old_len, one)
    b.block_instr2(.store, loop_block, b.void_type, new_len, alloca_len)
    quot := b.block_instr2(.sdiv, loop_block, b.i64_type, n_cur, ten)
    b.block_instr2(.store, loop_block, b.void_type, quot, alloca_n)
    has_more := b.block_instr2(.gt, loop_block, b.i1_type, quot, zero)
    b.block_instr3(.br, loop_block, b.void_type, has_more, ValueID(loop_block), ValueID(sign_block))

    neg_flag := b.block_instr1(.load, sign_block, b.i1_type, alloca_neg)
    b.block_instr3(.br, sign_block, b.void_type, neg_flag, ValueID(sign_write_block),
        ValueID(done_block))

    pos_sign := b.block_instr1(.load, sign_write_block, ptr_i8, alloca_pos)
    pos_sign_next := b.block_instr2(.add, sign_write_block, ptr_i8, pos_sign, minus_one)
    b.block_instr2(.store, sign_write_block, b.void_type, ascii_minus, pos_sign_next)
    b.block_instr2(.store, sign_write_block, b.void_type, pos_sign_next, alloca_pos)
    len_sign := b.block_instr1(.load, sign_write_block, b.i64_type, alloca_len)
    len_sign_next := b.block_instr2(.add, sign_write_block, b.i64_type, len_sign, one)
    b.block_instr2(.store, sign_write_block, b.void_type, len_sign_next, alloca_len)
    b.block_instr1(.jmp, sign_write_block, b.void_type, ValueID(done_block))

    data := b.block_instr1(.load, done_block, ptr_i8, alloca_pos)
    len := b.block_instr1(.load, done_block, b.i64_type, alloca_len)
    // The digits were written backwards, so `data` points into the middle of `buf`.
    // Shift them to the allocation start (memmove handles the overlap) and NUL-terminate,
    // so the returned owned string's `str` is `buf` itself and free() gets a valid pointer.
    memmove_ref := b.m.add_value(.func_ref, b.void_type, 'memmove', b.fn_ids['memmove'])
    b.block_instr4(.call, done_block, ptr_i8, memmove_ref, buf, data, len)
    buf_term := b.block_instr2(.add, done_block, ptr_i8, buf, len)
    b.block_instr2(.store, done_block, b.void_type, nul, buf_term)
    result := b.emit_make_string(done_block, buf, len, 0)
    b.block_instr1(.ret, done_block, b.void_type, result)
}

// generate_string_int_body supports generate string int body handling for Builder.
fn (mut b Builder) generate_string_int_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_i64 := b.m.type_store.get_ptr(b.i64_type)
    ptr_string := b.m.type_store.get_ptr(b.str_type)
    entry := b.m.add_block(func_id, 'entry')
    s := b.func_add_argument(func_id, b.str_type, 's')
    s_slot := b.block_instr0(.alloca, entry, ptr_string)
    result_slot := b.block_instr0(.alloca, entry, ptr_i64)
    i_slot := b.block_instr0(.alloca, entry, ptr_i64)
    sign_slot := b.block_instr0(.alloca, entry, ptr_i64)
    b.block_instr2(.store, entry, b.void_type, s, s_slot)

    data_ptr := b.block_struct_field_ptr(entry, s_slot, b.str_type, 0)
    len_ptr := b.block_struct_field_ptr(entry, s_slot, b.str_type, 1)
    data := b.block_instr1(.load, entry, ptr_i8, data_ptr)
    len32 := b.block_instr1(.load, entry, b.i32_type, len_ptr)
    len := b.block_instr1(.zext, entry, b.i64_type, len32)

    zero64 := b.m.get_or_add_const(b.i64_type, '0')
    one64 := b.m.get_or_add_const(b.i64_type, '1')
    minus_one := b.m.get_or_add_const(b.i64_type, '-1')
    ten64 := b.m.get_or_add_const(b.i64_type, '10')
    ascii_zero := b.m.get_or_add_const(b.i64_type, '48')
    ascii_minus := b.m.get_or_add_const(b.i8_type, '45')
    b.block_instr2(.store, entry, b.void_type, zero64, result_slot)
    b.block_instr2(.store, entry, b.void_type, zero64, i_slot)
    b.block_instr2(.store, entry, b.void_type, one64, sign_slot)

    check_sign := b.m.add_block(func_id, 'string_int_check_sign')
    sign_body := b.m.add_block(func_id, 'string_int_sign_body')
    loop := b.m.add_block(func_id, 'string_int_loop')
    body := b.m.add_block(func_id, 'string_int_body')
    done := b.m.add_block(func_id, 'string_int_done')
    has_chars := b.block_instr2(.gt, entry, b.i1_type, len, zero64)
    b.block_instr3(.br, entry, b.void_type, has_chars, ValueID(check_sign), ValueID(done))

    first_ch := b.block_instr1(.load, check_sign, b.i8_type, data)
    is_minus := b.block_instr2(.eq, check_sign, b.i1_type, first_ch, ascii_minus)
    b.block_instr3(.br, check_sign, b.void_type, is_minus, ValueID(sign_body), ValueID(loop))

    b.block_instr2(.store, sign_body, b.void_type, minus_one, sign_slot)
    b.block_instr2(.store, sign_body, b.void_type, one64, i_slot)
    b.block_instr1(.jmp, sign_body, b.void_type, ValueID(loop))

    i := b.block_instr1(.load, loop, b.i64_type, i_slot)
    more := b.block_instr2(.lt, loop, b.i1_type, i, len)
    b.block_instr3(.br, loop, b.void_type, more, ValueID(body), ValueID(done))

    body_i := b.block_instr1(.load, body, b.i64_type, i_slot)
    ch_ptr := b.block_instr2(.add, body, ptr_i8, data, body_i)
    ch := b.block_instr1(.load, body, b.i8_type, ch_ptr)
    ch64 := b.block_instr1(.zext, body, b.i64_type, ch)
    digit := b.block_instr2(.sub, body, b.i64_type, ch64, ascii_zero)
    cur := b.block_instr1(.load, body, b.i64_type, result_slot)
    scaled := b.block_instr2(.mul, body, b.i64_type, cur, ten64)
    next := b.block_instr2(.add, body, b.i64_type, scaled, digit)
    b.block_instr2(.store, body, b.void_type, next, result_slot)
    next_i := b.block_instr2(.add, body, b.i64_type, body_i, one64)
    b.block_instr2(.store, body, b.void_type, next_i, i_slot)
    b.block_instr1(.jmp, body, b.void_type, ValueID(loop))

    parsed := b.block_instr1(.load, done, b.i64_type, result_slot)
    sign := b.block_instr1(.load, done, b.i64_type, sign_slot)
    signed := b.block_instr2(.mul, done, b.i64_type, parsed, sign)
    b.block_instr1(.ret, done, b.void_type, signed)
}

// register_bench_runtime_stubs updates register bench runtime stubs state for ssa.
fn (mut b Builder) register_bench_runtime_stubs() {
    for name in bench_runtime_stub_names {
        id := b.register_synthetic_function(name, b.i64_type, []TypeID{})
        b.generate_const_i64_body(id, '0')
    }
}

// generate_tos2_body supports generate tos2 body handling for Builder. It backs both the
// non-copying `tos2`/`vstring` wrappers (is_lit=0) and the `vstring_literal` wrappers
// (is_lit=1, the borrowed pointer is static C data that must never be freed).
fn (mut b Builder) generate_tos2_body(func_id int, is_lit int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    entry := b.m.add_block(func_id, 'entry')
    s := b.func_add_argument(func_id, ptr_i8, 's')
    strlen_ref := b.m.add_value(.func_ref, b.i64_type, 'strlen', b.fn_ids['strlen'])
    len := b.block_instr2(.call, entry, b.i64_type, strlen_ref, s)
    result := b.emit_make_string(entry, s, len, is_lit)
    b.block_instr1(.ret, entry, b.void_type, result)
}

// generate_tos_clone_body supports generate tos clone body handling for Builder.
fn (mut b Builder) generate_tos_clone_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    entry := b.m.add_block(func_id, 'entry')
    s := b.func_add_argument(func_id, ptr_i8, 's')
    strlen_ref := b.m.add_value(.func_ref, b.i64_type, 'strlen', b.fn_ids['strlen'])
    len := b.block_instr2(.call, entry, b.i64_type, strlen_ref, s)
    result := b.emit_make_owned_string(entry, s, len)
    b.block_instr1(.ret, entry, b.void_type, result)
}

// generate_vstring_with_len_body backs `vstring_with_len` (is_lit=0) and
// `vstring_literal_with_len` (is_lit=1; borrowed static C data that must never be freed).
fn (mut b Builder) generate_vstring_with_len_body(func_id int, is_lit int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    entry := b.m.add_block(func_id, 'entry')
    s := b.func_add_argument(func_id, ptr_i8, 's')
    len := b.func_add_argument(func_id, b.i64_type, 'len')
    result := b.emit_make_string(entry, s, len, is_lit)
    b.block_instr1(.ret, entry, b.void_type, result)
}

// register_string_plus_stubs updates register string plus stubs state for ssa.
fn (mut b Builder) register_string_plus_stubs() {
    mut p2 := []TypeID{}
    p2 << b.str_type
    p2 << b.str_type
    plus_id := b.register_synthetic_function('string__plus', b.str_type, p2)
    b.generate_string_plus_body(plus_id)

    mut p_many := []TypeID{}
    p_many << b.i64_type
    p_many << b.m.type_store.get_ptr(b.str_type)
    many_id := b.register_synthetic_function('string_plus_many', b.str_type, p_many)
    b.generate_string_plus_many_body(many_id)
}

// emit_make_string emits emit make string output for ssa.
// emit_make_string builds a `string{ str: data, len: len64, is_lit: is_lit }` value.
// `is_lit` must be set explicitly because the field shares the trailing struct word and
// is otherwise stack garbage that string.free could misread: pass 1 for a literal /
// borrowed view of static data that must never be freed, and 0 for an owned heap string
// whose `data` is an allocation start (so free() gets the right pointer). For an owned
// copy of a borrowed/interior buffer use emit_make_owned_string.
fn (mut b Builder) emit_make_string(block_id BlockID, data ValueID, len64 ValueID, is_lit int) ValueID {
    ptr_string := b.m.type_store.get_ptr(b.str_type)
    alloca_out := b.block_instr0(.alloca, block_id, ptr_string)
    data_ptr := b.block_struct_field_ptr(block_id, alloca_out, b.str_type, 0)
    len_ptr := b.block_struct_field_ptr(block_id, alloca_out, b.str_type, 1)
    is_lit_ptr := b.block_struct_field_ptr(block_id, alloca_out, b.str_type, 2)
    b.block_instr2(.store, block_id, b.void_type, data, data_ptr)
    b.block_instr2(.store, block_id, b.void_type, len64, len_ptr)
    is_lit_const := b.m.get_or_add_const(b.i32_type, is_lit.str())
    b.block_instr2(.store, block_id, b.void_type, is_lit_const, is_lit_ptr)
    return b.block_instr1(.load, block_id, b.str_type, alloca_out)
}

// emit_make_owned_string allocates `len + 1` bytes, copies `len` bytes from `src`,
// NUL-terminates, and returns an owned (non-literal, freeable) string. Use this where a
// helper must return its own buffer rather than a view into a caller-owned one — e.g. a
// substring of a strings.Builder. The returned string is marked non-literal by
// emit_make_string, so returning an interior/aliased pointer here would later hand a
// non-allocation-start pointer to free().
fn (mut b Builder) emit_make_owned_string(block_id BlockID, src ValueID, len ValueID) ValueID {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    one := b.m.get_or_add_const(b.i64_type, '1')
    alloc_len := b.block_instr2(.add, block_id, b.i64_type, len, one)
    malloc_ref := b.m.add_value(.func_ref, b.void_type, 'malloc', b.fn_ids['malloc'])
    out_data := b.block_instr2(.call, block_id, ptr_i8, malloc_ref, alloc_len)
    memcpy_ref := b.m.add_value(.func_ref, b.void_type, 'memcpy', b.fn_ids['memcpy'])
    b.block_instr4(.call, block_id, ptr_i8, memcpy_ref, out_data, src, len)
    zero8 := b.m.get_or_add_const(b.i8_type, '0')
    term_ptr := b.block_instr2(.add, block_id, ptr_i8, out_data, len)
    b.block_instr2(.store, block_id, b.void_type, zero8, term_ptr)
    return b.emit_make_string(block_id, out_data, len, 0)
}

// generate_string_plus_body supports generate string plus body handling for Builder.
fn (mut b Builder) generate_string_plus_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_string := b.m.type_store.get_ptr(b.str_type)
    entry := b.m.add_block(func_id, 'entry')
    left := b.func_add_argument(func_id, b.str_type, 'left')
    right := b.func_add_argument(func_id, b.str_type, 'right')

    alloca_left := b.block_instr0(.alloca, entry, ptr_string)
    alloca_right := b.block_instr0(.alloca, entry, ptr_string)
    b.block_instr2(.store, entry, b.void_type, left, alloca_left)
    b.block_instr2(.store, entry, b.void_type, right, alloca_right)

    left_data_ptr := b.block_struct_field_ptr(entry, alloca_left, b.str_type, 0)
    left_len_ptr := b.block_struct_field_ptr(entry, alloca_left, b.str_type, 1)
    right_data_ptr := b.block_struct_field_ptr(entry, alloca_right, b.str_type, 0)
    right_len_ptr := b.block_struct_field_ptr(entry, alloca_right, b.str_type, 1)
    left_data := b.block_instr1(.load, entry, ptr_i8, left_data_ptr)
    right_data := b.block_instr1(.load, entry, ptr_i8, right_data_ptr)
    left_len32 := b.block_instr1(.load, entry, b.i32_type, left_len_ptr)
    right_len32 := b.block_instr1(.load, entry, b.i32_type, right_len_ptr)
    left_len := b.block_instr1(.zext, entry, b.i64_type, left_len32)
    right_len := b.block_instr1(.zext, entry, b.i64_type, right_len32)
    total_len := b.block_instr2(.add, entry, b.i64_type, left_len, right_len)
    one := b.m.get_or_add_const(b.i64_type, '1')
    alloc_len := b.block_instr2(.add, entry, b.i64_type, total_len, one)

    malloc_ref := b.m.add_value(.func_ref, b.void_type, 'malloc', b.fn_ids['malloc'])
    out_data := b.block_instr2(.call, entry, ptr_i8, malloc_ref, alloc_len)
    memcpy_ref_left := b.m.add_value(.func_ref, b.void_type, 'memcpy', b.fn_ids['memcpy'])
    b.block_instr4(.call, entry, ptr_i8, memcpy_ref_left, out_data, left_data, left_len)
    right_dest := b.block_instr2(.add, entry, ptr_i8, out_data, left_len)
    memcpy_ref_right := b.m.add_value(.func_ref, b.void_type, 'memcpy', b.fn_ids['memcpy'])
    b.block_instr4(.call, entry, ptr_i8, memcpy_ref_right, right_dest, right_data, right_len)
    zero8 := b.m.get_or_add_const(b.i8_type, '0')
    term_ptr := b.block_instr2(.add, entry, ptr_i8, out_data, total_len)
    b.block_instr2(.store, entry, b.void_type, zero8, term_ptr)

    result := b.emit_make_string(entry, out_data, total_len, 0)
    b.block_instr1(.ret, entry, b.void_type, result)
}

// generate_string_plus_many_body supports generate string plus many body handling for Builder.
fn (mut b Builder) generate_string_plus_many_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_i64 := b.m.type_store.get_ptr(b.i64_type)
    ptr_string := b.m.type_store.get_ptr(b.str_type)
    entry := b.m.add_block(func_id, 'entry')
    count := b.func_add_argument(func_id, b.i64_type, 'count')
    input_base := b.func_add_argument(func_id, ptr_string, 'input_base')

    alloca_i := b.block_instr0(.alloca, entry, ptr_i64)
    alloca_total := b.block_instr0(.alloca, entry, ptr_i64)
    alloca_written := b.block_instr0(.alloca, entry, ptr_i64)
    zero64 := b.m.get_or_add_const(b.i64_type, '0')
    one64 := b.m.get_or_add_const(b.i64_type, '1')
    stride := b.m.get_or_add_const(b.i64_type, '16')
    b.block_instr2(.store, entry, b.void_type, zero64, alloca_i)
    b.block_instr2(.store, entry, b.void_type, zero64, alloca_total)

    sum_check := b.m.add_block(func_id, 'string_plus_many_sum_check')
    sum_body := b.m.add_block(func_id, 'string_plus_many_sum_body')
    alloc_block := b.m.add_block(func_id, 'string_plus_many_alloc')
    b.block_instr1(.jmp, entry, b.void_type, ValueID(sum_check))

    i_sum := b.block_instr1(.load, sum_check, b.i64_type, alloca_i)
    more_sum := b.block_instr2(.lt, sum_check, b.i1_type, i_sum, count)
    b.block_instr3(.br, sum_check, b.void_type, more_sum, ValueID(sum_body), ValueID(alloc_block))

    sum_item_off := b.block_instr2(.mul, sum_body, b.i64_type, i_sum, stride)
    sum_item_ptr := b.block_instr2(.get_element_ptr, sum_body, ptr_string, input_base, sum_item_off)
    sum_len_ptr := b.block_struct_field_ptr(sum_body, sum_item_ptr, b.str_type, 1)
    sum_len32 := b.block_instr1(.load, sum_body, b.i32_type, sum_len_ptr)
    sum_len := b.block_instr1(.zext, sum_body, b.i64_type, sum_len32)
    old_total := b.block_instr1(.load, sum_body, b.i64_type, alloca_total)
    new_total := b.block_instr2(.add, sum_body, b.i64_type, old_total, sum_len)
    next_i_sum := b.block_instr2(.add, sum_body, b.i64_type, i_sum, one64)
    b.block_instr2(.store, sum_body, b.void_type, new_total, alloca_total)
    b.block_instr2(.store, sum_body, b.void_type, next_i_sum, alloca_i)
    b.block_instr1(.jmp, sum_body, b.void_type, ValueID(sum_check))

    total_len := b.block_instr1(.load, alloc_block, b.i64_type, alloca_total)
    alloc_len := b.block_instr2(.add, alloc_block, b.i64_type, total_len, one64)
    malloc_ref := b.m.add_value(.func_ref, b.void_type, 'malloc', b.fn_ids['malloc'])
    out_data := b.block_instr2(.call, alloc_block, ptr_i8, malloc_ref, alloc_len)
    b.block_instr2(.store, alloc_block, b.void_type, zero64, alloca_i)
    b.block_instr2(.store, alloc_block, b.void_type, zero64, alloca_written)

    copy_check := b.m.add_block(func_id, 'string_plus_many_copy_check')
    copy_body := b.m.add_block(func_id, 'string_plus_many_copy_body')
    done := b.m.add_block(func_id, 'string_plus_many_done')
    b.block_instr1(.jmp, alloc_block, b.void_type, ValueID(copy_check))

    i_copy := b.block_instr1(.load, copy_check, b.i64_type, alloca_i)
    more_copy := b.block_instr2(.lt, copy_check, b.i1_type, i_copy, count)
    b.block_instr3(.br, copy_check, b.void_type, more_copy, ValueID(copy_body), ValueID(done))

    copy_item_off := b.block_instr2(.mul, copy_body, b.i64_type, i_copy, stride)
    copy_item_ptr := b.block_instr2(.get_element_ptr, copy_body, ptr_string, input_base,
        copy_item_off)
    copy_data_ptr := b.block_struct_field_ptr(copy_body, copy_item_ptr, b.str_type, 0)
    copy_len_ptr := b.block_struct_field_ptr(copy_body, copy_item_ptr, b.str_type, 1)
    copy_data := b.block_instr1(.load, copy_body, ptr_i8, copy_data_ptr)
    copy_len32 := b.block_instr1(.load, copy_body, b.i32_type, copy_len_ptr)
    copy_len := b.block_instr1(.zext, copy_body, b.i64_type, copy_len32)
    written := b.block_instr1(.load, copy_body, b.i64_type, alloca_written)
    dest := b.block_instr2(.add, copy_body, ptr_i8, out_data, written)
    memcpy_ref := b.m.add_value(.func_ref, b.void_type, 'memcpy', b.fn_ids['memcpy'])
    b.block_instr4(.call, copy_body, ptr_i8, memcpy_ref, dest, copy_data, copy_len)
    new_written := b.block_instr2(.add, copy_body, b.i64_type, written, copy_len)
    next_i_copy := b.block_instr2(.add, copy_body, b.i64_type, i_copy, one64)
    b.block_instr2(.store, copy_body, b.void_type, new_written, alloca_written)
    b.block_instr2(.store, copy_body, b.void_type, next_i_copy, alloca_i)
    b.block_instr1(.jmp, copy_body, b.void_type, ValueID(copy_check))

    zero8 := b.m.get_or_add_const(b.i8_type, '0')
    term_ptr := b.block_instr2(.add, done, ptr_i8, out_data, total_len)
    b.block_instr2(.store, done, b.void_type, zero8, term_ptr)
    result := b.emit_make_string(done, out_data, total_len, 0)
    b.block_instr1(.ret, done, b.void_type, result)
}

// register_array_runtime_stubs updates register array runtime stubs state for ssa.
fn (mut b Builder) register_array_runtime_stubs() {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_array := b.m.type_store.get_ptr(b.array_type)

    mut p3 := []TypeID{}
    p3 << b.i64_type
    p3 << b.i64_type
    p3 << b.i64_type
    array_new_id := b.register_synthetic_function('array_new', b.array_type, p3)
    b.generate_array_new_body(array_new_id)

    mut p2 := []TypeID{}
    p2 << b.array_type
    p2 << b.i64_type
    array_get_id := b.register_synthetic_function('array_get', ptr_i8, p2)
    b.generate_array_get_body(array_get_id)

    p3 = []TypeID{}
    p3 << b.array_type
    p3 << b.i64_type
    p3 << b.i64_type
    array_slice_id := b.register_synthetic_function('array_slice', b.array_type, p3)
    b.generate_array_slice_body(array_slice_id)

    p2 = []TypeID{}
    p2 << ptr_array
    p2 << ptr_i8
    array_push_id := b.register_synthetic_function('array_push', b.void_type, p2)
    b.generate_array_push_body(array_push_id)

    mut p3_push_many := []TypeID{}
    p3_push_many << ptr_array
    p3_push_many << ptr_i8
    p3_push_many << b.i64_type
    array_push_many_id := b.register_synthetic_function('array.push_many', b.void_type,
        p3_push_many)
    b.generate_array_push_many_body(array_push_many_id)
    // `array_push_many_ptr` is the C-macro name the transformer emits for
    // `arr << ptr_value` / fixed-array appends; it has the same
    // (ptr_array, ptr_value, count) signature as `array.push_many`. It needs its
    // own definition so the native linker resolves the `_array_push_many_ptr` symbol.
    array_push_many_ptr_id := b.register_synthetic_function('array_push_many_ptr', b.void_type,
        p3_push_many)
    b.generate_array_push_many_body(array_push_many_ptr_id)

    mut p2_push_many := []TypeID{}
    p2_push_many << ptr_array
    p2_push_many << b.array_type
    array_push_many_wrapper_id := b.register_synthetic_function('array_push_many', b.void_type,
        p2_push_many)
    b.generate_array_push_many_array_body(array_push_many_wrapper_id)

    mut p1 := []TypeID{}
    p1 << b.array_type
    array_clone_id := b.register_synthetic_function('array_clone', b.array_type, p1)
    b.generate_array_clone_body(array_clone_id)

    // The transformer lowers `arr.clone()` to `array__clone(&arr)` (a pointer arg, matching
    // cgen's `array array__clone(array* a)`). Without a synthetic under this exact name, the
    // `__`->`.` fallback resolves it to the builtin `array.clone`, which allocates data past
    // an 8-byte header (alloc_array_data) — incompatible with the synthetic runtime that
    // grows/frees buffers via `realloc(data)`/`free(data)` assuming no header. Provide a
    // header-less (calloc-based) clone taking the array by pointer.
    mut p1_ptr_arr := []TypeID{}
    p1_ptr_arr << b.m.type_store.get_ptr(b.array_type)
    array_clone_ptr_id := b.register_synthetic_function('array__clone', b.array_type, p1_ptr_arr)
    b.generate_array_clone_ptr_body(array_clone_ptr_id)

    mut p3_repeat := []TypeID{}
    p3_repeat << b.array_type
    p3_repeat << b.i64_type
    p3_repeat << b.i64_type
    array_repeat_id := b.register_synthetic_function('array.repeat_to_depth', b.array_type,
        p3_repeat)
    b.generate_array_repeat_to_depth_body(array_repeat_id)
}

// register_panic_stub updates register panic stub state for ssa.
fn (mut b Builder) register_panic_stub() {
    mut p1 := []TypeID{}
    p1 << b.str_type
    panic_id := b.register_synthetic_function('panic', b.void_type, p1)
    b.generate_panic_body(panic_id)
}

// register_printing_stubs updates register printing stubs state for ssa.
fn (mut b Builder) register_printing_stubs() {
    mut p1 := []TypeID{}
    p1 << b.str_type
    print_id := b.register_synthetic_function('print', b.void_type, p1)
    b.generate_print_body(print_id, '1', false)
    println_id := b.register_synthetic_function('println', b.void_type, p1)
    b.generate_print_body(println_id, '1', true)
    eprint_id := b.register_synthetic_function('eprint', b.void_type, p1)
    b.generate_print_body(eprint_id, '2', false)
    eprintln_id := b.register_synthetic_function('eprintln', b.void_type, p1)
    b.generate_print_body(eprintln_id, '2', true)
}

// generate_print_body supports generate print body handling for Builder.
fn (mut b Builder) generate_print_body(func_id int, fd_value string, newline bool) {
    ptr_string := b.m.type_store.get_ptr(b.str_type)
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    entry := b.m.add_block(func_id, 'entry')
    message := b.func_add_argument(func_id, b.str_type, 'message')
    message_slot := b.block_instr0(.alloca, entry, ptr_string)
    b.block_instr2(.store, entry, b.void_type, message, message_slot)
    data_ptr := b.block_struct_field_ptr(entry, message_slot, b.str_type, 0)
    len_ptr := b.block_struct_field_ptr(entry, message_slot, b.str_type, 1)
    data := b.block_instr1(.load, entry, ptr_i8, data_ptr)
    len32 := b.block_instr1(.load, entry, b.i32_type, len_ptr)
    len := b.block_instr1(.zext, entry, b.i64_type, len32)
    fd := b.m.get_or_add_const(b.i64_type, fd_value)
    write_ref := b.m.add_value(.func_ref, b.void_type, 'write', b.fn_ids['write'])
    b.block_instr4(.call, entry, b.i64_type, write_ref, fd, data, len)
    if newline {
        newline_str := b.m.add_value(.string_literal, b.str_type, '\n', 0)
        newline_slot := b.block_instr0(.alloca, entry, ptr_string)
        b.block_instr2(.store, entry, b.void_type, newline_str, newline_slot)
        newline_data_ptr := b.block_struct_field_ptr(entry, newline_slot, b.str_type, 0)
        newline_data := b.block_instr1(.load, entry, ptr_i8, newline_data_ptr)
        one := b.m.get_or_add_const(b.i64_type, '1')
        b.block_instr4(.call, entry, b.i64_type, write_ref, fd, newline_data, one)
    }
    b.block_instr0(.ret, entry, b.void_type)
}

// generate_panic_body supports generate panic body handling for Builder.
fn (mut b Builder) generate_panic_body(func_id int) {
    entry := b.m.add_block(func_id, 'entry')
    message := b.func_add_argument(func_id, b.str_type, 'message')
    if eprintln_id := b.fn_ids['eprintln'] {
        fn_ref := b.m.add_value(.func_ref, b.void_type, 'eprintln', eprintln_id)
        b.block_instr2(.call, entry, b.void_type, fn_ref, message)
    }
    if exit_id := b.fn_ids['exit'] {
        one := b.m.get_or_add_const(b.i64_type, '1')
        fn_ref := b.m.add_value(.func_ref, b.void_type, 'exit', exit_id)
        b.block_instr2(.call, entry, b.void_type, fn_ref, one)
    }
    b.block_instr0(.ret, entry, b.void_type)
}

// register_string_builder_stubs updates register string builder stubs state for ssa.
fn (mut b Builder) register_string_builder_stubs() {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_builder := b.m.type_store.get_ptr(b.array_type)

    mut p1 := []TypeID{}
    p1 << b.i64_type
    new_id := b.register_synthetic_function('strings.new_builder', b.array_type, p1)
    b.generate_builder_new_body(new_id)

    mut p2 := []TypeID{}
    p2 << ptr_builder
    p2 << b.str_type
    write_string_id :=
        b.register_synthetic_function('strings.Builder.write_string', b.void_type, p2)
    b.generate_builder_write_string_body(write_string_id, false)
    writeln_id := b.register_synthetic_function('strings.Builder.writeln', b.void_type, p2)
    b.generate_builder_write_string_body(writeln_id, true)

    p1 = []TypeID{}
    p1 << ptr_builder
    str_id := b.register_synthetic_function('strings.Builder.str', b.str_type, p1)
    b.generate_builder_str_body(str_id)
    free_id := b.register_synthetic_function('strings.Builder.free', b.void_type, p1)
    b.generate_builder_free_body(free_id)

    p2 = []TypeID{}
    p2 << ptr_builder
    p2 << b.i8_type
    write_u8_id := b.register_synthetic_function('strings.Builder.write_u8', b.void_type, p2)
    b.generate_builder_write_u8_body(write_u8_id)

    mut p3 := []TypeID{}
    p3 << ptr_builder
    p3 << ptr_i8
    p3 << b.i64_type
    write_ptr_id := b.register_synthetic_function('strings.Builder.write_ptr', b.void_type, p3)
    b.generate_builder_write_ptr_body(write_ptr_id)
    push_many_id := b.register_synthetic_function('strings.Builder.push_many', b.void_type, p3)
    b.generate_builder_write_ptr_body(push_many_id)

    p2 = []TypeID{}
    p2 << ptr_builder
    p2 << b.array_type
    write_runes_id := b.register_synthetic_function('strings.Builder.write_runes', b.void_type, p2)
    b.generate_builder_free_body(write_runes_id)

    p2 = []TypeID{}
    p2 << ptr_builder
    p2 << b.i64_type
    last_n_id := b.register_synthetic_function('strings.Builder.last_n', b.str_type, p2)
    b.generate_builder_last_n_body(last_n_id)
}

// generate_builder_new_body supports generate builder new body handling for Builder.
fn (mut b Builder) generate_builder_new_body(func_id int) {
    entry := b.m.add_block(func_id, 'entry')
    initial_size := b.func_add_argument(func_id, b.i64_type, 'initial_size')
    one := b.m.get_or_add_const(b.i64_type, '1')
    zero := b.m.get_or_add_const(b.i64_type, '0')
    fn_ref := b.m.add_value(.func_ref, b.void_type, 'array_new', b.fn_ids['array_new'])
    builder := b.block_instr4(.call, entry, b.array_type, fn_ref, one, zero, initial_size)
    b.block_instr1(.ret, entry, b.void_type, builder)
}

// emit_builder_append emits emit builder append output for ssa.
fn (mut b Builder) emit_builder_append(func_id int, entry BlockID, builder_ptr ValueID, src_ptr ValueID, add_len ValueID) BlockID {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    data_ptr := b.block_struct_field_ptr(entry, builder_ptr, b.array_type, 0)
    len_ptr := b.block_struct_field_ptr(entry, builder_ptr, b.array_type, 2)
    cap_ptr := b.block_struct_field_ptr(entry, builder_ptr, b.array_type, 3)
    old_len32 := b.block_instr1(.load, entry, b.i32_type, len_ptr)
    old_len := b.block_instr1(.zext, entry, b.i64_type, old_len32)
    cap32 := b.block_instr1(.load, entry, b.i32_type, cap_ptr)
    cap := b.block_instr1(.zext, entry, b.i64_type, cap32)
    needed := b.block_instr2(.add, entry, b.i64_type, old_len, add_len)
    needs_grow := b.block_instr2(.gt, entry, b.i1_type, needed, cap)

    blk_grow := b.m.add_block(func_id, 'builder_append_grow')
    blk_copy := b.m.add_block(func_id, 'builder_append_copy')
    b.block_instr3(.br, entry, b.void_type, needs_grow, ValueID(blk_grow), ValueID(blk_copy))

    two := b.m.get_or_add_const(b.i64_type, '2')
    old_data := b.block_instr1(.load, blk_grow, ptr_i8, data_ptr)
    double_needed := b.block_instr2(.mul, blk_grow, b.i64_type, needed, two)
    new_cap := b.block_instr2(.add, blk_grow, b.i64_type, double_needed, two)
    realloc_ref := b.m.add_value(.func_ref, b.void_type, 'realloc', b.fn_ids['realloc'])
    new_data := b.block_instr3(.call, blk_grow, ptr_i8, realloc_ref, old_data, new_cap)
    b.block_instr2(.store, blk_grow, b.void_type, new_data, data_ptr)
    b.block_instr2(.store, blk_grow, b.void_type, new_cap, cap_ptr)
    b.block_instr1(.jmp, blk_grow, b.void_type, ValueID(blk_copy))

    data := b.block_instr1(.load, blk_copy, ptr_i8, data_ptr)
    dest := b.block_instr2(.add, blk_copy, ptr_i8, data, old_len)
    memcpy_ref := b.m.add_value(.func_ref, b.void_type, 'memcpy', b.fn_ids['memcpy'])
    b.block_instr4(.call, blk_copy, ptr_i8, memcpy_ref, dest, src_ptr, add_len)
    b.block_instr2(.store, blk_copy, b.void_type, needed, len_ptr)
    return blk_copy
}

// generate_builder_write_string_body
// supports helper handling in ssa.
fn (mut b Builder) generate_builder_write_string_body(func_id int, add_newline bool) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_builder := b.m.type_store.get_ptr(b.array_type)
    ptr_string := b.m.type_store.get_ptr(b.str_type)
    ptr_i32 := b.m.type_store.get_ptr(b.i32_type)
    entry := b.m.add_block(func_id, 'entry')
    builder_ptr := b.func_add_argument(func_id, ptr_builder, 'builder')
    s := b.func_add_argument(func_id, b.str_type, 's')

    alloca_s := b.block_instr0(.alloca, entry, ptr_string)
    b.block_instr2(.store, entry, b.void_type, s, alloca_s)
    zero := b.m.get_or_add_const(b.i64_type, '0')
    len_off := b.m.get_or_add_const(b.i64_type, '8')
    str_ptr_ptr := b.block_instr2(.get_element_ptr, entry, ptr_i8, alloca_s, zero)
    len_ptr := b.block_instr2(.get_element_ptr, entry, ptr_i32, alloca_s, len_off)
    str_ptr := b.block_instr1(.load, entry, ptr_i8, str_ptr_ptr)
    len32 := b.block_instr1(.load, entry, b.i32_type, len_ptr)
    len64 := b.block_instr1(.zext, entry, b.i64_type, len32)
    end_block := b.emit_builder_append(func_id, entry, builder_ptr, str_ptr, len64)
    if add_newline {
        nl := b.m.get_or_add_const(b.i8_type, '10')
        alloca_nl := b.block_instr0(.alloca, end_block, ptr_i8)
        b.block_instr2(.store, end_block, b.void_type, nl, alloca_nl)
        one := b.m.get_or_add_const(b.i64_type, '1')
        final_block := b.emit_builder_append(func_id, end_block, builder_ptr, alloca_nl, one)
        b.block_instr0(.ret, final_block, b.void_type)
    } else {
        b.block_instr0(.ret, end_block, b.void_type)
    }
}

// generate_builder_write_ptr_body supports generate builder write ptr body handling for Builder.
fn (mut b Builder) generate_builder_write_ptr_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_builder := b.m.type_store.get_ptr(b.array_type)
    entry := b.m.add_block(func_id, 'entry')
    builder_ptr := b.func_add_argument(func_id, ptr_builder, 'builder')
    src_ptr := b.func_add_argument(func_id, ptr_i8, 'ptr')
    len := b.func_add_argument(func_id, b.i64_type, 'len')
    end_block := b.emit_builder_append(func_id, entry, builder_ptr, src_ptr, len)
    b.block_instr0(.ret, end_block, b.void_type)
}

// generate_builder_write_u8_body supports generate builder write u8 body handling for Builder.
fn (mut b Builder) generate_builder_write_u8_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_builder := b.m.type_store.get_ptr(b.array_type)
    entry := b.m.add_block(func_id, 'entry')
    builder_ptr := b.func_add_argument(func_id, ptr_builder, 'builder')
    ch := b.func_add_argument(func_id, b.i8_type, 'ch')
    alloca_ch := b.block_instr0(.alloca, entry, ptr_i8)
    b.block_instr2(.store, entry, b.void_type, ch, alloca_ch)
    one := b.m.get_or_add_const(b.i64_type, '1')
    end_block := b.emit_builder_append(func_id, entry, builder_ptr, alloca_ch, one)
    b.block_instr0(.ret, end_block, b.void_type)
}

// generate_builder_str_body supports generate builder str body handling for Builder.
fn (mut b Builder) generate_builder_str_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_builder := b.m.type_store.get_ptr(b.array_type)
    entry := b.m.add_block(func_id, 'entry')
    builder_ptr := b.func_add_argument(func_id, ptr_builder, 'builder')
    data_ptr := b.block_struct_field_ptr(entry, builder_ptr, b.array_type, 0)
    len_ptr := b.block_struct_field_ptr(entry, builder_ptr, b.array_type, 2)
    data := b.block_instr1(.load, entry, ptr_i8, data_ptr)
    len32 := b.block_instr1(.load, entry, b.i32_type, len_ptr)
    len := b.block_instr1(.zext, entry, b.i64_type, len32)
    // Return an owned copy, not the builder's live buffer (matches strings.Builder.str,
    // which memdups): the result is marked non-literal and may be freed independently.
    result := b.emit_make_owned_string(entry, data, len)
    b.block_instr1(.ret, entry, b.void_type, result)
}

// generate_builder_last_n_body supports generate builder last n body handling for Builder.
fn (mut b Builder) generate_builder_last_n_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_builder := b.m.type_store.get_ptr(b.array_type)
    entry := b.m.add_block(func_id, 'entry')
    builder_ptr := b.func_add_argument(func_id, ptr_builder, 'builder')
    n := b.func_add_argument(func_id, b.i64_type, 'n')
    data_ptr := b.block_struct_field_ptr(entry, builder_ptr, b.array_type, 0)
    len_ptr := b.block_struct_field_ptr(entry, builder_ptr, b.array_type, 2)
    data := b.block_instr1(.load, entry, ptr_i8, data_ptr)
    len32 := b.block_instr1(.load, entry, b.i32_type, len_ptr)
    len := b.block_instr1(.zext, entry, b.i64_type, len32)
    start := b.block_instr2(.sub, entry, b.i64_type, len, n)
    src := b.block_instr2(.add, entry, ptr_i8, data, start)
    // Copy out an owned substring (matches strings.Builder.last_n -> spart): the result
    // must not alias the interior of the builder buffer, since string.free would later
    // pass that non-allocation-start pointer to free().
    result := b.emit_make_owned_string(entry, src, n)
    b.block_instr1(.ret, entry, b.void_type, result)
}

// generate_builder_free_body supports generate builder free body handling for Builder.
fn (mut b Builder) generate_builder_free_body(func_id int) {
    ptr_builder := b.m.type_store.get_ptr(b.array_type)
    entry := b.m.add_block(func_id, 'entry')
    _ := b.func_add_argument(func_id, ptr_builder, 'builder')
    b.block_instr0(.ret, entry, b.void_type)
}

// register_path_runtime_stubs updates register path runtime stubs state for ssa.
fn (mut b Builder) register_path_runtime_stubs() {
    ptr_builder := b.m.type_store.get_ptr(b.array_type)
    mut p1 := []TypeID{}
    p1 << ptr_builder
    for name in ['normalize_path_in_builder', 'os.normalize_path_in_builder'] {
        normalize_id := b.register_synthetic_function(name, b.void_type, p1)
        b.generate_builder_free_body(normalize_id)
    }

    mut p2 := []TypeID{}
    p2 << b.str_type
    p2 << b.str_type
    for name in ['join_path_single', 'os.join_path_single'] {
        join_id := b.register_synthetic_function(name, b.str_type, p2)
        b.generate_join_path_single_body(join_id)
    }
}

// generate_join_path_single_body supports generate join path single body handling for Builder.
fn (mut b Builder) generate_join_path_single_body(func_id int) {
    entry := b.m.add_block(func_id, 'entry')
    base := b.func_add_argument(func_id, b.str_type, 'base')
    elem := b.func_add_argument(func_id, b.str_type, 'elem')
    slash := b.m.add_value(.string_literal, b.str_type, '/', 0)
    plus_ref := b.m.add_value(.func_ref, b.str_type, 'string__plus', b.fn_ids['string__plus'])
    with_sep := b.block_instr3(.call, entry, b.str_type, plus_ref, base, slash)
    result := b.block_instr3(.call, entry, b.str_type, plus_ref, with_sep, elem)
    b.block_instr1(.ret, entry, b.void_type, result)
}

// register_map_runtime_stubs updates register map runtime stubs state for ssa.
fn (mut b Builder) register_map_runtime_stubs() {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_map := b.m.type_store.get_ptr(b.map_type)

    mut p2 := []TypeID{}
    p2 << ptr_map
    p2 << ptr_i8
    find_id := b.register_synthetic_function('v3_map_find', b.i64_type, p2)
    b.generate_map_find_body(find_id)

    mut p6 := []TypeID{}
    for _ in 0 .. 6 {
        p6 << b.i64_type
    }
    new_id := b.register_synthetic_function('new_map', b.map_type, p6)
    b.generate_new_map_body(new_id)

    mut p3 := []TypeID{}
    p3 << ptr_map
    p3 << ptr_i8
    p3 << ptr_i8

    mut p5 := []TypeID{}
    p5 << ptr_map
    p5 << ptr_i8
    p5 << ptr_i8
    p5 << b.i64_type
    p5 << b.i64_type
    sized_set_id := b.register_synthetic_function('v3_map_set_sized', b.void_type, p5)
    b.generate_map_set_sized_body(sized_set_id)
    set_id := b.register_synthetic_function('map__set', b.void_type, p3)
    b.generate_map_set_default_body(set_id)

    p3 = []TypeID{}
    p3 << ptr_map
    p3 << ptr_i8
    p3 << ptr_i8
    get_id := b.register_synthetic_function('map__get', ptr_i8, p3)
    b.generate_map_get_body(get_id)
    mut p2_map_key := []TypeID{}
    p2_map_key << ptr_map
    p2_map_key << ptr_i8
    get_check_id := b.register_synthetic_function('map__get_check', ptr_i8, p2_map_key)
    b.generate_map_get_check_body(get_check_id)
    get_or_set_id := b.register_synthetic_function('map__get_or_set', ptr_i8, p3)
    b.generate_map_get_body(get_or_set_id)

    p2 = []TypeID{}
    p2 << ptr_map
    p2 << ptr_i8
    exists_id := b.register_synthetic_function('map__exists', b.i1_type, p2)
    b.generate_map_exists_body(exists_id)

    mut p1_ptr := []TypeID{}
    p1_ptr << ptr_map
    clear_id := b.register_synthetic_function('map__clear', b.void_type, p1_ptr)
    b.generate_map_ptr_noop_body(clear_id)

    p2 = []TypeID{}
    p2 << ptr_map
    p2 << ptr_i8
    delete_id := b.register_synthetic_function('map__delete', b.void_type, p2)
    b.generate_map_delete_body(delete_id)

    mut p1_map := []TypeID{}
    p1_map << b.map_type
    clone_id := b.register_synthetic_function('map__clone', b.map_type, p1_map)
    b.generate_map_clone_body(clone_id)
}

// generate_map_ptr_noop_body supports generate map ptr noop body handling for Builder.
fn (mut b Builder) generate_map_ptr_noop_body(func_id int) {
    ptr_map := b.m.type_store.get_ptr(b.map_type)
    entry := b.m.add_block(func_id, 'entry')
    _ := b.func_add_argument(func_id, ptr_map, 'm')
    b.block_instr0(.ret, entry, b.void_type)
}

// generate_map_delete_body supports generate map delete body handling for Builder.
fn (mut b Builder) generate_map_delete_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_map := b.m.type_store.get_ptr(b.map_type)
    entry := b.m.add_block(func_id, 'entry')
    map_ptr := b.func_add_argument(func_id, ptr_map, 'm')
    key_ptr := b.func_add_argument(func_id, ptr_i8, 'key')
    find_ref := b.m.add_value(.func_ref, b.void_type, 'v3_map_find', b.fn_ids['v3_map_find'])
    idx := b.block_instr3(.call, entry, b.i64_type, find_ref, map_ptr, key_ptr)
    zero := b.m.get_or_add_const(b.i64_type, '0')
    found := b.block_instr2(.ge, entry, b.i1_type, idx, zero)
    blk_found := b.m.add_block(func_id, 'map_delete_found')
    blk_done := b.m.add_block(func_id, 'map_delete_done')
    b.block_instr3(.br, entry, b.void_type, found, ValueID(blk_found), ValueID(blk_done))

    state := b.map_state_ptr(blk_found, map_ptr)
    len_ptr := b.map_state_field_ptr(blk_found, state, 3)
    len := b.block_instr1(.load, blk_found, b.i64_type, len_ptr)
    one := b.m.get_or_add_const(b.i64_type, '1')
    new_len := b.block_instr2(.sub, blk_found, b.i64_type, len, one)
    b.block_instr2(.store, blk_found, b.void_type, new_len, len_ptr)
    b.block_instr1(.jmp, blk_found, b.void_type, ValueID(blk_done))

    b.block_instr0(.ret, blk_done, b.void_type)
}

// generate_map_clone_body supports generate map clone body handling for Builder.
fn (mut b Builder) generate_map_clone_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_map := b.m.type_store.get_ptr(b.map_type)
    ptr_state := b.m.type_store.get_ptr(b.map_state_type)
    entry := b.m.add_block(func_id, 'entry')
    m := b.func_add_argument(func_id, b.map_type, 'm')
    map_slot := b.block_instr0(.alloca, entry, ptr_map)
    b.block_instr2(.store, entry, b.void_type, m, map_slot)
    state_field := b.block_struct_field_ptr(entry, map_slot, b.map_type, 0)
    old_state := b.block_instr1(.load, entry, ptr_state, state_field)
    zero_state := b.m.get_or_add_const(ptr_state, '0')
    has_state := b.block_instr2(.ne, entry, b.i1_type, old_state, zero_state)
    blk_clone := b.m.add_block(func_id, 'map_clone_copy')
    blk_empty := b.m.add_block(func_id, 'map_clone_empty')
    b.block_instr3(.br, entry, b.void_type, has_state, ValueID(blk_clone), ValueID(blk_empty))

    one := b.m.get_or_add_const(b.i64_type, '1')
    state_size := b.m.get_or_add_const(b.i64_type, '48')
    calloc_ref := b.m.add_value(.func_ref, b.void_type, 'calloc', b.fn_ids['calloc'])
    new_state_raw := b.block_instr3(.call, blk_clone, ptr_i8, calloc_ref, one, state_size)
    new_state := b.block_instr1(.bitcast, blk_clone, ptr_state, new_state_raw)

    old_keys_ptr := b.map_state_field_ptr(blk_clone, old_state, 0)
    old_vals_ptr := b.map_state_field_ptr(blk_clone, old_state, 1)
    old_cap_ptr := b.map_state_field_ptr(blk_clone, old_state, 2)
    old_len_ptr := b.map_state_field_ptr(blk_clone, old_state, 3)
    old_key_size_ptr := b.map_state_field_ptr(blk_clone, old_state, 4)
    old_val_size_ptr := b.map_state_field_ptr(blk_clone, old_state, 5)
    old_keys := b.block_instr1(.load, blk_clone, ptr_i8, old_keys_ptr)
    old_vals := b.block_instr1(.load, blk_clone, ptr_i8, old_vals_ptr)
    cap := b.block_instr1(.load, blk_clone, b.i64_type, old_cap_ptr)
    len := b.block_instr1(.load, blk_clone, b.i64_type, old_len_ptr)
    key_size := b.block_instr1(.load, blk_clone, b.i64_type, old_key_size_ptr)
    val_size := b.block_instr1(.load, blk_clone, b.i64_type, old_val_size_ptr)
    new_keys := b.block_instr3(.call, blk_clone, ptr_i8, calloc_ref, cap, key_size)
    new_vals := b.block_instr3(.call, blk_clone, ptr_i8, calloc_ref, cap, val_size)
    key_bytes := b.block_instr2(.mul, blk_clone, b.i64_type, len, key_size)
    val_bytes := b.block_instr2(.mul, blk_clone, b.i64_type, len, val_size)
    memcpy_ref_keys := b.m.add_value(.func_ref, b.void_type, 'memcpy', b.fn_ids['memcpy'])
    memcpy_ref_vals := b.m.add_value(.func_ref, b.void_type, 'memcpy', b.fn_ids['memcpy'])
    b.block_instr4(.call, blk_clone, ptr_i8, memcpy_ref_keys, new_keys, old_keys, key_bytes)
    b.block_instr4(.call, blk_clone, ptr_i8, memcpy_ref_vals, new_vals, old_vals, val_bytes)

    new_keys_ptr := b.map_state_field_ptr(blk_clone, new_state, 0)
    new_vals_ptr := b.map_state_field_ptr(blk_clone, new_state, 1)
    new_cap_ptr := b.map_state_field_ptr(blk_clone, new_state, 2)
    new_len_ptr := b.map_state_field_ptr(blk_clone, new_state, 3)
    new_key_size_ptr := b.map_state_field_ptr(blk_clone, new_state, 4)
    new_val_size_ptr := b.map_state_field_ptr(blk_clone, new_state, 5)
    b.block_instr2(.store, blk_clone, b.void_type, new_keys, new_keys_ptr)
    b.block_instr2(.store, blk_clone, b.void_type, new_vals, new_vals_ptr)
    b.block_instr2(.store, blk_clone, b.void_type, cap, new_cap_ptr)
    b.block_instr2(.store, blk_clone, b.void_type, len, new_len_ptr)
    b.block_instr2(.store, blk_clone, b.void_type, key_size, new_key_size_ptr)
    b.block_instr2(.store, blk_clone, b.void_type, val_size, new_val_size_ptr)

    result_slot := b.block_instr0(.alloca, blk_clone, ptr_map)
    result_state_field := b.block_struct_field_ptr(blk_clone, result_slot, b.map_type, 0)
    b.block_instr2(.store, blk_clone, b.void_type, new_state, result_state_field)
    result := b.block_instr1(.load, blk_clone, b.map_type, result_slot)
    b.block_instr1(.ret, blk_clone, b.void_type, result)

    b.block_instr1(.ret, blk_empty, b.void_type, m)
}

// register_u8_runtime_stubs updates register u8 runtime stubs state for ssa.
fn (mut b Builder) register_u8_runtime_stubs() {
    mut p1 := []TypeID{}
    p1 << b.i8_type
    for name in ['u8.is_digit', 'u8.is_letter', 'u8.is_alnum', 'u8.is_capital'] {
        func_id := b.register_synthetic_function(name, b.i1_type, p1)
        b.generate_u8_predicate_body(func_id, name)
    }
}

// generate_u8_predicate_body supports generate u8 predicate body handling for Builder.
fn (mut b Builder) generate_u8_predicate_body(func_id int, name string) {
    entry := b.m.add_block(func_id, 'entry')
    c := b.func_add_argument(func_id, b.i8_type, 'c')
    digit := b.u8_in_range(entry, c, `0`, `9`)
    lower := b.u8_in_range(entry, c, `a`, `z`)
    upper := b.u8_in_range(entry, c, `A`, `Z`)
    letter := b.block_instr2(.or_, entry, b.i1_type, lower, upper)
    result := match name {
        'u8.is_digit' {
            digit
        }
        'u8.is_letter' {
            letter
        }
        'u8.is_alnum' {
            b.block_instr2(.or_, entry, b.i1_type, digit, letter)
        }
        else {
            upper
        }
    }

    b.block_instr1(.ret, entry, b.void_type, result)
}

// u8_in_range supports u8 in range handling for Builder.
fn (mut b Builder) u8_in_range(block_id BlockID, c ValueID, low u8, high u8) ValueID {
    low_v := b.m.get_or_add_const(b.i8_type, '${int(low)}')
    high_v := b.m.get_or_add_const(b.i8_type, '${int(high)}')
    ge_low := b.block_instr2(.ge, block_id, b.i1_type, c, low_v)
    le_high := b.block_instr2(.le, block_id, b.i1_type, c, high_v)
    return b.block_instr2(.and_, block_id, b.i1_type, ge_low, le_high)
}

// register_heap_tracking_stubs updates register heap tracking stubs state for ssa.
fn (mut b Builder) register_heap_tracking_stubs() {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    mut p2 := []TypeID{}
    p2 << ptr_i8
    p2 << b.i64_type
    alloc_id := b.register_synthetic_function('_ht_alloc', b.void_type, p2)
    b.generate_void_noop_body(alloc_id)
    mut p1 := []TypeID{}
    p1 << ptr_i8
    free_id := b.register_synthetic_function('_ht_free', b.void_type, p1)
    b.generate_void_noop_body(free_id)
}

// generate_void_noop_body supports generate void noop body handling for Builder.
fn (mut b Builder) generate_void_noop_body(func_id int) {
    entry := b.m.add_block(func_id, 'entry')
    b.block_instr0(.ret, entry, b.void_type)
}

// register_process_capture_stubs updates register process capture stubs state for ssa.
fn (mut b Builder) register_process_capture_stubs() {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    mut p3 := []TypeID{}
    p3 << ptr_i8
    p3 << ptr_i8
    p3 << ptr_i8
    for name in ['v_os_execute_capture_start', 'v_os_exec_capture_start'] {
        func_id := b.register_synthetic_function(name, b.i64_type, p3)
        b.generate_const_i64_body(func_id, '1')
    }
}

// register_file_check_stubs updates register file check stubs state for ssa.
fn (mut b Builder) register_file_check_stubs() {
    mut p1 := []TypeID{}
    p1 << b.i64_type
    for name in ['check_fwrite', 'os.check_fwrite', 'check_fread', 'os.check_fread'] {
        func_id := b.register_synthetic_function(name, b.i64_type, p1)
        b.generate_identity_i64_body(func_id)
    }
}

// generate_identity_i64_body supports generate identity i64 body handling for Builder.
fn (mut b Builder) generate_identity_i64_body(func_id int) {
    entry := b.m.add_block(func_id, 'entry')
    n := b.func_add_argument(func_id, b.i64_type, 'n')
    b.block_instr1(.ret, entry, b.void_type, n)
}

// register_fd_macro_stubs updates register fd macro stubs state for ssa.
fn (mut b Builder) register_fd_macro_stubs() {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    mut fd_set_params := []TypeID{}
    fd_set_params << ptr_i8
    zero_id := b.register_synthetic_function('FD_ZERO', b.void_type, fd_set_params)
    b.generate_void_noop_with_params_body(zero_id, fd_set_params)

    mut fd_check_params := []TypeID{}
    fd_check_params << b.i64_type
    fd_check_params << ptr_i8
    set_id := b.register_synthetic_function('FD_SET', b.void_type, fd_check_params)
    b.generate_void_noop_with_params_body(set_id, fd_check_params)
    isset_id := b.register_synthetic_function('FD_ISSET', b.i64_type, fd_check_params)
    b.generate_const_i64_with_params_body(isset_id, fd_check_params, '0')
}

// register_signal_macro_stubs updates register signal macro stubs state for ssa.
fn (mut b Builder) register_signal_macro_stubs() {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    mut params := []TypeID{}
    params << b.i64_type
    params << ptr_i8
    name := 'v_signal_with_handler_cast'
    func_id := b.register_synthetic_function(name, ptr_i8, params)
    if fn_type := b.fn_types[name] {
        b.c_fn_types[name] = fn_type
    }
    b.c_fn_ids[name] = func_id
    b.generate_const_ptr_with_params_body(func_id, params, ptr_i8, '0')
}

// generate_void_noop_with_params_body supports generate_void_noop_with_params_body handling in ssa.
fn (mut b Builder) generate_void_noop_with_params_body(func_id int, params []TypeID) {
    entry := b.m.add_block(func_id, 'entry')
    for i, param in params {
        _ := b.func_add_argument(func_id, param, 'p${i}')
    }
    b.block_instr0(.ret, entry, b.void_type)
}

// generate_const_i64_with_params_body supports generate_const_i64_with_params_body handling in ssa.
fn (mut b Builder) generate_const_i64_with_params_body(func_id int, params []TypeID, value string) {
    entry := b.m.add_block(func_id, 'entry')
    for i, param in params {
        _ := b.func_add_argument(func_id, param, 'p${i}')
    }
    result := b.m.get_or_add_const(b.i64_type, value)
    b.block_instr1(.ret, entry, b.void_type, result)
}

// generate_const_ptr_with_params_body supports generate_const_ptr_with_params_body handling in ssa.
fn (mut b Builder) generate_const_ptr_with_params_body(func_id int, params []TypeID, ret_type TypeID, value string) {
    entry := b.m.add_block(func_id, 'entry')
    for i, param in params {
        _ := b.func_add_argument(func_id, param, 'p${i}')
    }
    result := b.m.get_or_add_const(ret_type, value)
    b.block_instr1(.ret, entry, b.void_type, result)
}

// register_os_stat_stubs updates register os stat stubs state for ssa.
fn (mut b Builder) register_os_stat_stubs() {
    mut p1 := []TypeID{}
    p1 << b.str_type
    for name in ['is_dir', 'os.is_dir'] {
        is_dir_id := b.register_synthetic_function(name, b.i1_type, p1)
        b.generate_os_stat_kind_body(is_dir_id, 'stat', '16384')
    }
    for name in ['is_link', 'os.is_link'] {
        is_link_id := b.register_synthetic_function(name, b.i1_type, p1)
        b.generate_os_stat_kind_body(is_link_id, 'lstat', '40960')
    }
    ls_result_type := b.option_type_id('[]string')
    for name in ['ls', 'os.ls'] {
        ls_id := b.register_synthetic_function(name, ls_result_type, p1)
        b.generate_os_ls_body(ls_id, ls_result_type)
    }
}

// generate_os_stat_kind_body supports generate os stat kind body handling for Builder.
fn (mut b Builder) generate_os_stat_kind_body(func_id int, stat_fn string, expected_mode string) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_i32 := b.m.type_store.get_ptr(b.i32_type)
    entry := b.m.add_block(func_id, 'entry')
    path := b.func_add_argument(func_id, b.str_type, 'path')
    path_data := b.emit_cstring_from_string(entry, path)

    stat_size := b.m.get_or_add_const(b.i64_type, '256')
    malloc_ref := b.m.add_value(.func_ref, b.void_type, 'malloc', b.fn_ids['malloc'])
    stat_buf := b.block_instr2(.call, entry, ptr_i8, malloc_ref, stat_size)
    stat_idx := b.c_fn_ids[stat_fn] or {
        false_val := b.m.get_or_add_const(b.i1_type, '0')
        b.block_instr1(.ret, entry, b.void_type, false_val)
        return
    }
    stat_ref := b.m.add_value(.func_ref, b.void_type, stat_fn, stat_idx)
    res := b.block_instr3(.call, entry, b.i64_type, stat_ref, path_data, stat_buf)
    zero64 := b.m.get_or_add_const(b.i64_type, '0')
    ok := b.block_instr2(.eq, entry, b.i1_type, res, zero64)
    ok_block := b.m.add_block(func_id, 'stat_ok')
    fail_block := b.m.add_block(func_id, 'stat_fail')
    b.block_instr3(.br, entry, b.void_type, ok, ValueID(ok_block), ValueID(fail_block))

    false_val := b.m.get_or_add_const(b.i1_type, '0')
    b.block_instr1(.ret, fail_block, b.void_type, false_val)

    mode_off := b.m.get_or_add_const(b.i64_type, '4')
    mode_raw_ptr := b.block_instr2(.get_element_ptr, ok_block, ptr_i8, stat_buf, mode_off)
    mode_ptr := b.block_instr1(.bitcast, ok_block, ptr_i32, mode_raw_ptr)
    mode := b.block_instr1(.load, ok_block, b.i32_type, mode_ptr)
    mask := b.m.get_or_add_const(b.i32_type, '61440')
    masked := b.block_instr2(.and_, ok_block, b.i32_type, mode, mask)
    expected := b.m.get_or_add_const(b.i32_type, expected_mode)
    is_kind := b.block_instr2(.eq, ok_block, b.i1_type, masked, expected)
    b.block_instr1(.ret, ok_block, b.void_type, is_kind)
}

// generate_os_ls_body supports generate os ls body handling for Builder.
fn (mut b Builder) generate_os_ls_body(func_id int, result_type TypeID) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_array := b.m.type_store.get_ptr(b.array_type)
    ptr_string := b.m.type_store.get_ptr(b.str_type)
    entry := b.m.add_block(func_id, 'entry')
    path := b.func_add_argument(func_id, b.str_type, 'path')
    path_data := b.emit_cstring_from_string(entry, path)

    str_size := b.m.get_or_add_const(b.i64_type, '16')
    zero64 := b.m.get_or_add_const(b.i64_type, '0')
    cap := b.m.get_or_add_const(b.i64_type, '50')
    array_new_ref := b.m.add_value(.func_ref, b.void_type, 'array_new', b.fn_ids['array_new'])
    arr := b.block_instr4(.call, entry, b.array_type, array_new_ref, str_size, zero64, cap)
    arr_alloca := b.block_instr0(.alloca, entry, ptr_array)
    b.block_instr2(.store, entry, b.void_type, arr, arr_alloca)

    opendir_ref := b.m.add_value(.func_ref, b.void_type, 'opendir', b.c_fn_ids['opendir'])
    dir_ptr := b.block_instr2(.call, entry, ptr_i8, opendir_ref, path_data)
    null_ptr := b.m.get_or_add_const(ptr_i8, '0')
    dir_is_null := b.block_instr2(.eq, entry, b.i1_type, dir_ptr, null_ptr)
    blk_loop := b.m.add_block(func_id, 'ls_loop')
    blk_empty := b.m.add_block(func_id, 'ls_empty')
    b.block_instr3(.br, entry, b.void_type, dir_is_null, ValueID(blk_empty), ValueID(blk_loop))

    empty_result := b.block_instr1(.load, blk_empty, b.array_type, arr_alloca)
    empty_wrapped := b.block_option_value(blk_empty, result_type, false, empty_result)
    b.block_instr1(.ret, blk_empty, b.void_type, empty_wrapped)

    readdir_ref := b.m.add_value(.func_ref, b.void_type, 'readdir', b.c_fn_ids['readdir'])
    ent := b.block_instr2(.call, blk_loop, ptr_i8, readdir_ref, dir_ptr)
    ent_is_null := b.block_instr2(.eq, blk_loop, b.i1_type, ent, null_ptr)
    blk_done := b.m.add_block(func_id, 'ls_done')
    blk_check := b.m.add_block(func_id, 'ls_check')
    b.block_instr3(.br, blk_loop, b.void_type, ent_is_null, ValueID(blk_done), ValueID(blk_check))

    name_off := b.m.get_or_add_const(b.i64_type, '21')
    name_ptr := b.block_instr2(.get_element_ptr, blk_check, ptr_i8, ent, name_off)
    first := b.block_instr1(.load, blk_check, b.i8_type, name_ptr)
    zero8 := b.m.get_or_add_const(b.i8_type, '0')
    has_name := b.block_instr2(.ne, blk_check, b.i1_type, first, zero8)
    blk_push := b.m.add_block(func_id, 'ls_push')
    blk_next := b.m.add_block(func_id, 'ls_next')
    b.block_instr3(.br, blk_check, b.void_type, has_name, ValueID(blk_push), ValueID(blk_next))

    tos_clone_ref := b.m.add_value(.func_ref, b.str_type, 'tos_clone', b.fn_ids['tos_clone'])
    name_str := b.block_instr2(.call, blk_push, b.str_type, tos_clone_ref, name_ptr)
    name_alloca := b.block_instr0(.alloca, blk_push, ptr_string)
    b.block_instr2(.store, blk_push, b.void_type, name_str, name_alloca)
    name_elem := b.block_instr1(.bitcast, blk_push, ptr_i8, name_alloca)
    array_push_ref := b.m.add_value(.func_ref, b.void_type, 'array_push', b.fn_ids['array_push'])
    b.block_instr3(.call, blk_push, b.void_type, array_push_ref, arr_alloca, name_elem)
    b.block_instr1(.jmp, blk_push, b.void_type, ValueID(blk_loop))

    b.block_instr1(.jmp, blk_next, b.void_type, ValueID(blk_loop))

    closedir_ref := b.m.add_value(.func_ref, b.void_type, 'closedir', b.c_fn_ids['closedir'])
    b.block_instr2(.call, blk_done, b.i64_type, closedir_ref, dir_ptr)
    result := b.block_instr1(.load, blk_done, b.array_type, arr_alloca)
    wrapped := b.block_option_value(blk_done, result_type, true, result)
    b.block_instr1(.ret, blk_done, b.void_type, wrapped)
}

// block_option_value supports block option value handling for Builder.
fn (mut b Builder) block_option_value(block_id BlockID, opt_typ TypeID, ok bool, raw_value ValueID) ValueID {
    ptr_opt := b.m.type_store.get_ptr(opt_typ)
    alloca := b.block_instr0(.alloca, block_id, ptr_opt)
    ok_ptr := b.block_struct_field_ptr(block_id, alloca, opt_typ, 0)
    ok_val := b.m.get_or_add_const(b.i1_type, if ok { '1' } else { '0' })
    b.block_instr2(.store, block_id, b.void_type, ok_val, ok_ptr)
    value_typ := b.option_value_type(opt_typ)
    if value_typ != b.void_type {
        value_ptr := b.block_struct_field_ptr(block_id, alloca, opt_typ, 1)
        mut value := raw_value
        if value <= 0 {
            value = b.m.get_or_add_const(value_typ, '0')
        }
        b.block_instr2(.store, block_id, b.void_type, value, value_ptr)
    }
    return b.block_instr1(.load, block_id, opt_typ, alloca)
}

// emit_cstring_from_string converts emit cstring from string data for ssa.
fn (mut b Builder) emit_cstring_from_string(block_id BlockID, value ValueID) ValueID {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_string := b.m.type_store.get_ptr(b.str_type)
    value_alloca := b.block_instr0(.alloca, block_id, ptr_string)
    b.block_instr2(.store, block_id, b.void_type, value, value_alloca)
    data_ptr := b.block_struct_field_ptr(block_id, value_alloca, b.str_type, 0)
    len_ptr := b.block_struct_field_ptr(block_id, value_alloca, b.str_type, 1)
    data := b.block_instr1(.load, block_id, ptr_i8, data_ptr)
    len32 := b.block_instr1(.load, block_id, b.i32_type, len_ptr)
    len := b.block_instr1(.zext, block_id, b.i64_type, len32)
    one := b.m.get_or_add_const(b.i64_type, '1')
    alloc_len := b.block_instr2(.add, block_id, b.i64_type, len, one)
    malloc_ref := b.m.add_value(.func_ref, b.void_type, 'malloc', b.fn_ids['malloc'])
    out_data := b.block_instr2(.call, block_id, ptr_i8, malloc_ref, alloc_len)
    memcpy_ref := b.m.add_value(.func_ref, b.void_type, 'memcpy', b.fn_ids['memcpy'])
    b.block_instr4(.call, block_id, ptr_i8, memcpy_ref, out_data, data, len)
    zero8 := b.m.get_or_add_const(b.i8_type, '0')
    term_ptr := b.block_instr2(.add, block_id, ptr_i8, out_data, len)
    b.block_instr2(.store, block_id, b.void_type, zero8, term_ptr)
    return out_data
}

// generate_const_i64_body supports generate const i64 body handling for Builder.
fn (mut b Builder) generate_const_i64_body(func_id int, value string) {
    entry := b.m.add_block(func_id, 'entry')
    result := b.m.get_or_add_const(b.i64_type, value)
    b.block_instr1(.ret, entry, b.void_type, result)
}

// register_prealloc_atomic_stubs updates register prealloc atomic stubs state for ssa.
fn (mut b Builder) register_prealloc_atomic_stubs() {
    ptr_i64 := b.m.type_store.get_ptr(b.i64_type)
    mut p1_ptr := []TypeID{}
    p1_ptr << ptr_i64
    load_id := b.register_synthetic_function('v_prealloc_atomic_load_i32', b.i64_type, p1_ptr)
    b.generate_atomic_load_i64_body(load_id)

    mut p2 := []TypeID{}
    p2 << ptr_i64
    p2 << b.i64_type
    add_id := b.register_synthetic_function('v_prealloc_atomic_add_i32', b.i64_type, p2)
    b.generate_atomic_add_i64_body(add_id)
    store_id := b.register_synthetic_function('v_prealloc_atomic_store_i32', b.i64_type, p2)
    b.generate_atomic_store_i64_body(store_id)

    mut p3 := []TypeID{}
    p3 << ptr_i64
    p3 << b.i64_type
    p3 << b.i64_type
    cas_id := b.register_synthetic_function('v_prealloc_atomic_cas_i32', b.i64_type, p3)
    b.generate_atomic_cas_i64_body(cas_id)
}

// generate_atomic_load_i64_body supports generate atomic load i64 body handling for Builder.
fn (mut b Builder) generate_atomic_load_i64_body(func_id int) {
    ptr_i64 := b.m.type_store.get_ptr(b.i64_type)
    entry := b.m.add_block(func_id, 'entry')
    ptr := b.func_add_argument(func_id, ptr_i64, 'ptr')
    value := b.block_instr1(.load, entry, b.i64_type, ptr)
    b.block_instr1(.ret, entry, b.void_type, value)
}

// generate_atomic_store_i64_body supports generate atomic store i64 body handling for Builder.
fn (mut b Builder) generate_atomic_store_i64_body(func_id int) {
    ptr_i64 := b.m.type_store.get_ptr(b.i64_type)
    entry := b.m.add_block(func_id, 'entry')
    ptr := b.func_add_argument(func_id, ptr_i64, 'ptr')
    value := b.func_add_argument(func_id, b.i64_type, 'value')
    b.block_instr2(.store, entry, b.void_type, value, ptr)
    b.block_instr1(.ret, entry, b.void_type, value)
}

// generate_atomic_add_i64_body supports generate atomic add i64 body handling for Builder.
fn (mut b Builder) generate_atomic_add_i64_body(func_id int) {
    ptr_i64 := b.m.type_store.get_ptr(b.i64_type)
    entry := b.m.add_block(func_id, 'entry')
    ptr := b.func_add_argument(func_id, ptr_i64, 'ptr')
    delta := b.func_add_argument(func_id, b.i64_type, 'delta')
    old := b.block_instr1(.load, entry, b.i64_type, ptr)
    new_value := b.block_instr2(.add, entry, b.i64_type, old, delta)
    b.block_instr2(.store, entry, b.void_type, new_value, ptr)
    b.block_instr1(.ret, entry, b.void_type, new_value)
}

// generate_atomic_cas_i64_body converts generate atomic cas i64 body data for ssa.
fn (mut b Builder) generate_atomic_cas_i64_body(func_id int) {
    ptr_i64 := b.m.type_store.get_ptr(b.i64_type)
    entry := b.m.add_block(func_id, 'entry')
    ptr := b.func_add_argument(func_id, ptr_i64, 'ptr')
    expected := b.func_add_argument(func_id, b.i64_type, 'expected')
    desired := b.func_add_argument(func_id, b.i64_type, 'desired')
    old := b.block_instr1(.load, entry, b.i64_type, ptr)
    ok := b.block_instr2(.eq, entry, b.i1_type, old, expected)
    then_block := b.m.add_block(func_id, 'cas_store')
    else_block := b.m.add_block(func_id, 'cas_done')
    b.block_instr3(.br, entry, b.void_type, ok, ValueID(then_block), ValueID(else_block))
    b.block_instr2(.store, then_block, b.void_type, desired, ptr)
    one := b.m.get_or_add_const(b.i64_type, '1')
    zero := b.m.get_or_add_const(b.i64_type, '0')
    b.block_instr1(.ret, then_block, b.void_type, one)
    b.block_instr1(.ret, else_block, b.void_type, zero)
}

// register_array_string_stubs updates register array string stubs state for ssa.
fn (mut b Builder) register_array_string_stubs() {
    mut p1 := []TypeID{}
    p1 << b.array_type
    array_str_id := b.register_synthetic_function('Array_str', b.str_type, p1)
    b.generate_const_string_body(array_str_id, '[]')
    bytestr_id := b.register_synthetic_function('bytestr', b.str_type, p1)
    b.generate_array_bytestr_body(bytestr_id)
    array_bytestr_id := b.register_synthetic_function('Array_u8__bytestr', b.str_type, p1)
    b.generate_array_bytestr_body(array_bytestr_id)
    array_hex_id := b.register_synthetic_function('Array_u8__hex', b.str_type, p1)
    b.generate_const_string_body(array_hex_id, '')
    rune_string_id := b.register_synthetic_function('Array_rune__string', b.str_type, p1)
    b.generate_const_string_body(rune_string_id, '')

    mut p2 := []TypeID{}
    p2 << b.array_type
    p2 << b.str_type
    for name in ['array_string_join', 'Array_string__join'] {
        func_id := b.register_synthetic_function(name, b.str_type, p2)
        b.generate_array_string_join_body(func_id)
    }
}

// generate_array_string_join_body supports generate array string join body handling for Builder.
fn (mut b Builder) generate_array_string_join_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_i64 := b.m.type_store.get_ptr(b.i64_type)
    ptr_array := b.m.type_store.get_ptr(b.array_type)
    entry := b.m.add_block(func_id, 'entry')
    arr := b.func_add_argument(func_id, b.array_type, 'arr')
    sep := b.func_add_argument(func_id, b.str_type, 'sep')
    arr_alloca := b.block_instr0(.alloca, entry, ptr_array)
    builder_alloca := b.block_instr0(.alloca, entry, ptr_array)
    i_alloca := b.block_instr0(.alloca, entry, ptr_i64)
    b.block_instr2(.store, entry, b.void_type, arr, arr_alloca)
    zero := b.m.get_or_add_const(b.i64_type, '0')
    one := b.m.get_or_add_const(b.i64_type, '1')
    b.block_instr2(.store, entry, b.void_type, zero, i_alloca)

    new_ref := b.m.add_value(.func_ref, b.array_type, 'strings.new_builder',
        b.fn_ids['strings.new_builder'])
    initial_cap := b.m.get_or_add_const(b.i64_type, '16')
    builder := b.block_instr2(.call, entry, b.array_type, new_ref, initial_cap)
    b.block_instr2(.store, entry, b.void_type, builder, builder_alloca)

    data_ptr := b.block_struct_field_ptr(entry, arr_alloca, b.array_type, 0)
    len_ptr := b.block_struct_field_ptr(entry, arr_alloca, b.array_type, 2)
    data := b.block_instr1(.load, entry, ptr_i8, data_ptr)
    len32 := b.block_instr1(.load, entry, b.i32_type, len_ptr)
    len := b.block_instr1(.zext, entry, b.i64_type, len32)

    loop := b.m.add_block(func_id, 'array_join_loop')
    body := b.m.add_block(func_id, 'array_join_body')
    write_sep := b.m.add_block(func_id, 'array_join_write_sep')
    write_elem := b.m.add_block(func_id, 'array_join_write_elem')
    done := b.m.add_block(func_id, 'array_join_done')
    b.block_instr1(.jmp, entry, b.void_type, ValueID(loop))

    i_val := b.block_instr1(.load, loop, b.i64_type, i_alloca)
    more := b.block_instr2(.lt, loop, b.i1_type, i_val, len)
    b.block_instr3(.br, loop, b.void_type, more, ValueID(body), ValueID(done))

    needs_sep := b.block_instr2(.gt, body, b.i1_type, i_val, zero)
    b.block_instr3(.br, body, b.void_type, needs_sep, ValueID(write_sep), ValueID(write_elem))

    write_ref := b.m.add_value(.func_ref, b.void_type, 'strings.Builder.write_string',
        b.fn_ids['strings.Builder.write_string'])
    b.block_instr3(.call, write_sep, b.void_type, write_ref, builder_alloca, sep)
    b.block_instr1(.jmp, write_sep, b.void_type, ValueID(write_elem))

    elem_size := b.m.get_or_add_const(b.i64_type, '${b.m.type_size(b.str_type)}')
    offset := b.block_instr2(.mul, write_elem, b.i64_type, i_val, elem_size)
    elem_ptr_raw := b.block_instr2(.add, write_elem, ptr_i8, data, offset)
    elem_ptr := b.block_instr1(.bitcast, write_elem, b.m.type_store.get_ptr(b.str_type),
        elem_ptr_raw)
    elem := b.block_instr1(.load, write_elem, b.str_type, elem_ptr)
    write_ref2 := b.m.add_value(.func_ref, b.void_type, 'strings.Builder.write_string',
        b.fn_ids['strings.Builder.write_string'])
    b.block_instr3(.call, write_elem, b.void_type, write_ref2, builder_alloca, elem)
    next_i := b.block_instr2(.add, write_elem, b.i64_type, i_val, one)
    b.block_instr2(.store, write_elem, b.void_type, next_i, i_alloca)
    b.block_instr1(.jmp, write_elem, b.void_type, ValueID(loop))

    str_ref := b.m.add_value(.func_ref, b.str_type, 'strings.Builder.str',
        b.fn_ids['strings.Builder.str'])
    result := b.block_instr2(.call, done, b.str_type, str_ref, builder_alloca)
    b.block_instr1(.ret, done, b.void_type, result)
}

// generate_array_bytestr_body supports generate array bytestr body handling for Builder.
fn (mut b Builder) generate_array_bytestr_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_array := b.m.type_store.get_ptr(b.array_type)
    entry := b.m.add_block(func_id, 'entry')
    arr := b.func_add_argument(func_id, b.array_type, 'arr')

    alloca_arr := b.block_instr0(.alloca, entry, ptr_array)
    b.block_instr2(.store, entry, b.void_type, arr, alloca_arr)
    data_ptr := b.block_struct_field_ptr(entry, alloca_arr, b.array_type, 0)
    len_ptr := b.block_struct_field_ptr(entry, alloca_arr, b.array_type, 2)
    data := b.block_instr1(.load, entry, ptr_i8, data_ptr)
    len32 := b.block_instr1(.load, entry, b.i32_type, len_ptr)
    len := b.block_instr1(.zext, entry, b.i64_type, len32)

    one := b.m.get_or_add_const(b.i64_type, '1')
    alloc_len := b.block_instr2(.add, entry, b.i64_type, len, one)
    malloc_ref := b.m.add_value(.func_ref, b.void_type, 'malloc', b.fn_ids['malloc'])
    out_data := b.block_instr2(.call, entry, ptr_i8, malloc_ref, alloc_len)
    memcpy_ref := b.m.add_value(.func_ref, b.void_type, 'memcpy', b.fn_ids['memcpy'])
    b.block_instr4(.call, entry, ptr_i8, memcpy_ref, out_data, data, len)
    zero8 := b.m.get_or_add_const(b.i8_type, '0')
    term_ptr := b.block_instr2(.add, entry, ptr_i8, out_data, len)
    b.block_instr2(.store, entry, b.void_type, zero8, term_ptr)

    result := b.emit_make_string(entry, out_data, len, 0)
    b.block_instr1(.ret, entry, b.void_type, result)
}

// register_ierror_stubs updates register ierror stubs state for ssa.
fn (mut b Builder) register_ierror_stubs() {
    ptr_ierror := b.m.type_store.get_ptr(b.i64_type)
    mut p1 := []TypeID{}
    p1 << ptr_ierror
    msg_id := b.register_synthetic_function('IError.msg', b.str_type, p1)
    b.generate_ierror_msg_body(msg_id, ptr_ierror)
    code_id := b.register_synthetic_function('IError.code', b.i64_type, p1)
    b.generate_ierror_code_body(code_id, ptr_ierror)
}

// generate_ierror_msg_body supports generate ierror msg body handling for Builder.
fn (mut b Builder) generate_ierror_msg_body(func_id int, ptr_ierror TypeID) {
    entry := b.m.add_block(func_id, 'entry')
    _ := b.func_add_argument(func_id, ptr_ierror, 'err')
    result := b.m.add_value(.string_literal, b.str_type, '', 0)
    b.block_instr1(.ret, entry, b.void_type, result)
}

// generate_ierror_code_body supports generate ierror code body handling for Builder.
fn (mut b Builder) generate_ierror_code_body(func_id int, ptr_ierror TypeID) {
    entry := b.m.add_block(func_id, 'entry')
    _ := b.func_add_argument(func_id, ptr_ierror, 'err')
    result := b.m.get_or_add_const(b.i64_type, '0')
    b.block_instr1(.ret, entry, b.void_type, result)
}

// register_fixed_array_contains_stubs reports register_fixed_array_contains_stubs logic in ssa.
fn (mut b Builder) register_fixed_array_contains_stubs() {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    mut p3_string := []TypeID{}
    p3_string << ptr_i8
    p3_string << b.i64_type
    p3_string << b.str_type
    contains_string_id := b.register_synthetic_function('fixed_array_contains_string', b.i1_type,
        p3_string)
    b.generate_fixed_array_contains_string_body(contains_string_id)

    mut p3_int := []TypeID{}
    p3_int << ptr_i8
    p3_int << b.i64_type
    p3_int << b.i64_type
    contains_int_id := b.register_synthetic_function('fixed_array_contains_int', b.i1_type, p3_int)
    b.generate_const_bool_body(contains_int_id, false)
}

// generate_fixed_array_contains_string_body
// builds helper data for ssa.
fn (mut b Builder) generate_fixed_array_contains_string_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_i64 := b.m.type_store.get_ptr(b.i64_type)
    ptr_string := b.m.type_store.get_ptr(b.str_type)
    entry := b.m.add_block(func_id, 'entry')
    arr := b.func_add_argument(func_id, ptr_i8, 'arr')
    len := b.func_add_argument(func_id, b.i64_type, 'len')
    needle := b.func_add_argument(func_id, b.str_type, 'needle')
    alloca_i := b.block_instr0(.alloca, entry, ptr_i64)
    zero := b.m.get_or_add_const(b.i64_type, '0')
    one := b.m.get_or_add_const(b.i64_type, '1')
    b.block_instr2(.store, entry, b.void_type, zero, alloca_i)

    blk_loop := b.m.add_block(func_id, 'fixed_array_contains_string_loop')
    blk_body := b.m.add_block(func_id, 'fixed_array_contains_string_body')
    blk_next := b.m.add_block(func_id, 'fixed_array_contains_string_next')
    blk_found := b.m.add_block(func_id, 'fixed_array_contains_string_found')
    blk_not_found := b.m.add_block(func_id, 'fixed_array_contains_string_not_found')
    b.block_instr1(.jmp, entry, b.void_type, ValueID(blk_loop))

    i := b.block_instr1(.load, blk_loop, b.i64_type, alloca_i)
    in_range := b.block_instr2(.lt, blk_loop, b.i1_type, i, len)
    b.block_instr3(.br, blk_loop, b.void_type, in_range, ValueID(blk_body), ValueID(blk_not_found))

    stride := b.m.get_or_add_const(b.i64_type, '16')
    offset := b.block_instr2(.mul, blk_body, b.i64_type, i, stride)
    slot := b.block_instr2(.add, blk_body, ptr_i8, arr, offset)
    slot_string_ptr := b.block_instr1(.bitcast, blk_body, ptr_string, slot)
    slot_string := b.block_instr1(.load, blk_body, b.str_type, slot_string_ptr)
    eq_ref := b.m.add_value(.func_ref, b.void_type, 'string__eq', b.fn_ids['string__eq'])
    is_eq := b.block_instr3(.call, blk_body, b.i1_type, eq_ref, slot_string, needle)
    b.block_instr3(.br, blk_body, b.void_type, is_eq, ValueID(blk_found), ValueID(blk_next))

    next_i := b.block_instr2(.add, blk_next, b.i64_type, i, one)
    b.block_instr2(.store, blk_next, b.void_type, next_i, alloca_i)
    b.block_instr1(.jmp, blk_next, b.void_type, ValueID(blk_loop))

    true_value := b.m.get_or_add_const(b.i1_type, '1')
    false_value := b.m.get_or_add_const(b.i1_type, '0')
    b.block_instr1(.ret, blk_found, b.void_type, true_value)
    b.block_instr1(.ret, blk_not_found, b.void_type, false_value)
}

// generate_const_bool_body supports generate const bool body handling for Builder.
fn (mut b Builder) generate_const_bool_body(func_id int, value bool) {
    entry := b.m.add_block(func_id, 'entry')
    result := b.m.get_or_add_const(b.i1_type, if value { '1' } else { '0' })
    b.block_instr1(.ret, entry, b.void_type, result)
}

// register_array_contains_stubs reports whether register array contains stubs applies in ssa.
fn (mut b Builder) register_array_contains_stubs() {
    mut p2_string := []TypeID{}
    p2_string << b.array_type
    p2_string << b.str_type
    index_string_id := b.register_synthetic_function('array_index_string', b.i64_type, p2_string)
    b.generate_array_index_string_body(index_string_id)
    contains_string_id := b.register_synthetic_function('array_contains_string', b.i1_type,
        p2_string)
    b.generate_array_contains_from_index_body(contains_string_id, 'array_index_string', b.str_type)

    mut p2_int := []TypeID{}
    p2_int << b.array_type
    p2_int << b.i64_type
    index_int_id := b.register_synthetic_function('array_index_int', b.i64_type, p2_int)
    b.generate_array_index_int_body(index_int_id)
    contains_int_id := b.register_synthetic_function('array_contains_int', b.i1_type, p2_int)
    b.generate_array_contains_from_index_body(contains_int_id, 'array_index_int', b.i64_type)
}

// generate_array_contains_from_index_body
// supports helper handling in ssa.
fn (mut b Builder) generate_array_contains_from_index_body(func_id int, index_name string, needle_type TypeID) {
    entry := b.m.add_block(func_id, 'entry')
    arr := b.func_add_argument(func_id, b.array_type, 'arr')
    needle := b.func_add_argument(func_id, needle_type, 'needle')
    index_ref := b.m.add_value(.func_ref, b.void_type, index_name, b.fn_ids[index_name])
    idx := b.block_instr3(.call, entry, b.i64_type, index_ref, arr, needle)
    zero := b.m.get_or_add_const(b.i64_type, '0')
    found := b.block_instr2(.ge, entry, b.i1_type, idx, zero)
    b.block_instr1(.ret, entry, b.void_type, found)
}

// generate_array_index_string_body supports generate array index string body handling for Builder.
fn (mut b Builder) generate_array_index_string_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_i64 := b.m.type_store.get_ptr(b.i64_type)
    ptr_array := b.m.type_store.get_ptr(b.array_type)
    ptr_string := b.m.type_store.get_ptr(b.str_type)
    entry := b.m.add_block(func_id, 'entry')
    arr := b.func_add_argument(func_id, b.array_type, 'arr')
    needle := b.func_add_argument(func_id, b.str_type, 'needle')
    alloca_arr := b.block_instr0(.alloca, entry, ptr_array)
    alloca_i := b.block_instr0(.alloca, entry, ptr_i64)
    b.block_instr2(.store, entry, b.void_type, arr, alloca_arr)
    zero := b.m.get_or_add_const(b.i64_type, '0')
    one := b.m.get_or_add_const(b.i64_type, '1')
    b.block_instr2(.store, entry, b.void_type, zero, alloca_i)

    data_ptr := b.block_struct_field_ptr(entry, alloca_arr, b.array_type, 0)
    len_ptr := b.block_struct_field_ptr(entry, alloca_arr, b.array_type, 2)
    elem_size_ptr := b.block_struct_field_ptr(entry, alloca_arr, b.array_type, 5)
    blk_loop := b.m.add_block(func_id, 'array_index_string_loop')
    blk_body := b.m.add_block(func_id, 'array_index_string_body')
    blk_next := b.m.add_block(func_id, 'array_index_string_next')
    blk_found := b.m.add_block(func_id, 'array_index_string_found')
    blk_not_found := b.m.add_block(func_id, 'array_index_string_not_found')
    b.block_instr1(.jmp, entry, b.void_type, ValueID(blk_loop))

    i := b.block_instr1(.load, blk_loop, b.i64_type, alloca_i)
    len32 := b.block_instr1(.load, blk_loop, b.i32_type, len_ptr)
    len := b.block_instr1(.zext, blk_loop, b.i64_type, len32)
    in_range := b.block_instr2(.lt, blk_loop, b.i1_type, i, len)
    b.block_instr3(.br, blk_loop, b.void_type, in_range, ValueID(blk_body), ValueID(blk_not_found))

    data := b.block_instr1(.load, blk_body, ptr_i8, data_ptr)
    elem_size32 := b.block_instr1(.load, blk_body, b.i32_type, elem_size_ptr)
    elem_size := b.block_instr1(.zext, blk_body, b.i64_type, elem_size32)
    offset := b.block_instr2(.mul, blk_body, b.i64_type, i, elem_size)
    slot := b.block_instr2(.add, blk_body, ptr_i8, data, offset)
    slot_string_ptr := b.block_instr1(.bitcast, blk_body, ptr_string, slot)
    slot_string := b.block_instr1(.load, blk_body, b.str_type, slot_string_ptr)
    eq_ref := b.m.add_value(.func_ref, b.void_type, 'string__eq', b.fn_ids['string__eq'])
    is_eq := b.block_instr3(.call, blk_body, b.i1_type, eq_ref, slot_string, needle)
    b.block_instr3(.br, blk_body, b.void_type, is_eq, ValueID(blk_found), ValueID(blk_next))

    next_i := b.block_instr2(.add, blk_next, b.i64_type, i, one)
    b.block_instr2(.store, blk_next, b.void_type, next_i, alloca_i)
    b.block_instr1(.jmp, blk_next, b.void_type, ValueID(blk_loop))

    b.block_instr1(.ret, blk_found, b.void_type, i)
    not_found := b.m.get_or_add_const(b.i64_type, '-1')
    b.block_instr1(.ret, blk_not_found, b.void_type, not_found)
}

// generate_array_index_int_body supports generate array index int body handling for Builder.
fn (mut b Builder) generate_array_index_int_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_i64 := b.m.type_store.get_ptr(b.i64_type)
    ptr_i32 := b.m.type_store.get_ptr(b.i32_type)
    ptr_array := b.m.type_store.get_ptr(b.array_type)
    entry := b.m.add_block(func_id, 'entry')
    arr := b.func_add_argument(func_id, b.array_type, 'arr')
    needle := b.func_add_argument(func_id, b.i64_type, 'needle')
    alloca_arr := b.block_instr0(.alloca, entry, ptr_array)
    alloca_i := b.block_instr0(.alloca, entry, ptr_i64)
    b.block_instr2(.store, entry, b.void_type, arr, alloca_arr)
    zero := b.m.get_or_add_const(b.i64_type, '0')
    one := b.m.get_or_add_const(b.i64_type, '1')
    b.block_instr2(.store, entry, b.void_type, zero, alloca_i)

    data_ptr := b.block_struct_field_ptr(entry, alloca_arr, b.array_type, 0)
    len_ptr := b.block_struct_field_ptr(entry, alloca_arr, b.array_type, 2)
    elem_size_ptr := b.block_struct_field_ptr(entry, alloca_arr, b.array_type, 5)
    blk_loop := b.m.add_block(func_id, 'array_index_int_loop')
    blk_body := b.m.add_block(func_id, 'array_index_int_body')
    blk_next := b.m.add_block(func_id, 'array_index_int_next')
    blk_found := b.m.add_block(func_id, 'array_index_int_found')
    blk_not_found := b.m.add_block(func_id, 'array_index_int_not_found')
    b.block_instr1(.jmp, entry, b.void_type, ValueID(blk_loop))

    i := b.block_instr1(.load, blk_loop, b.i64_type, alloca_i)
    len32 := b.block_instr1(.load, blk_loop, b.i32_type, len_ptr)
    len := b.block_instr1(.zext, blk_loop, b.i64_type, len32)
    in_range := b.block_instr2(.lt, blk_loop, b.i1_type, i, len)
    b.block_instr3(.br, blk_loop, b.void_type, in_range, ValueID(blk_body), ValueID(blk_not_found))

    data := b.block_instr1(.load, blk_body, ptr_i8, data_ptr)
    elem_size32 := b.block_instr1(.load, blk_body, b.i32_type, elem_size_ptr)
    elem_size := b.block_instr1(.zext, blk_body, b.i64_type, elem_size32)
    offset := b.block_instr2(.mul, blk_body, b.i64_type, i, elem_size)
    slot := b.block_instr2(.add, blk_body, ptr_i8, data, offset)
    slot_i32_ptr := b.block_instr1(.bitcast, blk_body, ptr_i32, slot)
    slot_i32 := b.block_instr1(.load, blk_body, b.i32_type, slot_i32_ptr)
    slot_i64 := b.block_instr1(.sext, blk_body, b.i64_type, slot_i32)
    is_eq := b.block_instr2(.eq, blk_body, b.i1_type, slot_i64, needle)
    b.block_instr3(.br, blk_body, b.void_type, is_eq, ValueID(blk_found), ValueID(blk_next))

    next_i := b.block_instr2(.add, blk_next, b.i64_type, i, one)
    b.block_instr2(.store, blk_next, b.void_type, next_i, alloca_i)
    b.block_instr1(.jmp, blk_next, b.void_type, ValueID(blk_loop))

    b.block_instr1(.ret, blk_found, b.void_type, i)
    not_found := b.m.get_or_add_const(b.i64_type, '-1')
    b.block_instr1(.ret, blk_not_found, b.void_type, not_found)
}

// emit_map_state_alloc emits emit map state alloc output for ssa.
fn (mut b Builder) emit_map_state_alloc(block_id BlockID, key_size ValueID, val_size ValueID) ValueID {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_state := b.m.type_store.get_ptr(b.map_state_type)
    cap := b.m.get_or_add_const(b.i64_type, '8')
    one := b.m.get_or_add_const(b.i64_type, '1')
    zero := b.m.get_or_add_const(b.i64_type, '0')
    state_size := b.m.get_or_add_const(b.i64_type, '48')
    calloc_ref := b.m.add_value(.func_ref, b.void_type, 'calloc', b.fn_ids['calloc'])
    state_raw := b.block_instr3(.call, block_id, ptr_i8, calloc_ref, one, state_size)
    state := b.block_instr1(.bitcast, block_id, ptr_state, state_raw)
    keys := b.block_instr3(.call, block_id, ptr_i8, calloc_ref, cap, key_size)
    vals := b.block_instr3(.call, block_id, ptr_i8, calloc_ref, cap, val_size)

    keys_ptr := b.map_state_field_ptr(block_id, state, 0)
    vals_ptr := b.map_state_field_ptr(block_id, state, 1)
    cap_ptr := b.map_state_field_ptr(block_id, state, 2)
    len_ptr := b.map_state_field_ptr(block_id, state, 3)
    key_size_ptr := b.map_state_field_ptr(block_id, state, 4)
    val_size_ptr := b.map_state_field_ptr(block_id, state, 5)
    b.block_instr2(.store, block_id, b.void_type, keys, keys_ptr)
    b.block_instr2(.store, block_id, b.void_type, vals, vals_ptr)
    b.block_instr2(.store, block_id, b.void_type, cap, cap_ptr)
    b.block_instr2(.store, block_id, b.void_type, zero, len_ptr)
    b.block_instr2(.store, block_id, b.void_type, key_size, key_size_ptr)
    b.block_instr2(.store, block_id, b.void_type, val_size, val_size_ptr)
    return state
}

// map_state_ptr supports map state ptr handling for Builder.
fn (mut b Builder) map_state_ptr(block_id BlockID, map_ptr ValueID) ValueID {
    ptr_state := b.m.type_store.get_ptr(b.map_state_type)
    state_field_ptr := b.block_struct_field_ptr(block_id, map_ptr, b.map_type, 0)
    return b.block_instr1(.load, block_id, ptr_state, state_field_ptr)
}

// map_state_field_ptr supports map state field ptr handling for Builder.
fn (mut b Builder) map_state_field_ptr(block_id BlockID, state_ptr ValueID, field_idx int) ValueID {
    return b.block_struct_field_ptr(block_id, state_ptr, b.map_state_type, field_idx)
}

// generate_new_map_body supports generate new map body handling for Builder.
fn (mut b Builder) generate_new_map_body(func_id int) {
    ptr_map := b.m.type_store.get_ptr(b.map_type)
    entry := b.m.add_block(func_id, 'entry')
    key_size := b.func_add_argument(func_id, b.i64_type, 'key_size')
    val_size := b.func_add_argument(func_id, b.i64_type, 'val_size')
    hash_fn := b.func_add_argument(func_id, b.i64_type, 'hash_fn')
    eq_fn := b.func_add_argument(func_id, b.i64_type, 'eq_fn')
    clone_fn := b.func_add_argument(func_id, b.i64_type, 'clone_fn')
    free_fn := b.func_add_argument(func_id, b.i64_type, 'free_fn')
    _ = hash_fn
    _ = eq_fn
    _ = clone_fn
    _ = free_fn

    alloca_m := b.block_instr0(.alloca, entry, ptr_map)
    state := b.emit_map_state_alloc(entry, key_size, val_size)
    state_ptr := b.block_struct_field_ptr(entry, alloca_m, b.map_type, 0)
    b.block_instr2(.store, entry, b.void_type, state, state_ptr)
    result := b.block_instr1(.load, entry, b.map_type, alloca_m)
    b.block_instr1(.ret, entry, b.void_type, result)
}

// generate_map_find_body supports generate map find body handling for Builder.
fn (mut b Builder) generate_map_find_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_map := b.m.type_store.get_ptr(b.map_type)
    ptr_i64 := b.m.type_store.get_ptr(b.i64_type)
    ptr_string := b.m.type_store.get_ptr(b.str_type)
    ptr_state := b.m.type_store.get_ptr(b.map_state_type)
    entry := b.m.add_block(func_id, 'entry')
    map_ptr := b.func_add_argument(func_id, ptr_map, 'map')
    key_ptr := b.func_add_argument(func_id, ptr_i8, 'key')

    alloca_i := b.block_instr0(.alloca, entry, ptr_i64)
    zero := b.m.get_or_add_const(b.i64_type, '0')
    b.block_instr2(.store, entry, b.void_type, zero, alloca_i)

    blk_has_map := b.m.add_block(func_id, 'map_find_has_map')
    blk_loop := b.m.add_block(func_id, 'map_find_loop')
    blk_body := b.m.add_block(func_id, 'map_find_body')
    blk_string_cmp := b.m.add_block(func_id, 'map_find_string_cmp')
    blk_mem_cmp := b.m.add_block(func_id, 'map_find_mem_cmp')
    blk_found := b.m.add_block(func_id, 'map_find_found')
    blk_next := b.m.add_block(func_id, 'map_find_next')
    blk_not_found := b.m.add_block(func_id, 'map_find_not_found')
    zero_map := b.m.get_or_add_const(ptr_map, '0')
    has_map := b.block_instr2(.ne, entry, b.i1_type, map_ptr, zero_map)
    b.block_instr3(.br, entry, b.void_type, has_map, ValueID(blk_has_map), ValueID(blk_not_found))

    state := b.map_state_ptr(blk_has_map, map_ptr)
    zero_state := b.m.get_or_add_const(ptr_state, '0')
    has_state := b.block_instr2(.ne, blk_has_map, b.i1_type, state, zero_state)
    keys_ptr := b.map_state_field_ptr(blk_has_map, state, 0)
    len_ptr := b.map_state_field_ptr(blk_has_map, state, 3)
    key_size_ptr := b.map_state_field_ptr(blk_has_map, state, 4)
    b.block_instr3(.br, blk_has_map, b.void_type, has_state, ValueID(blk_loop),
        ValueID(blk_not_found))

    i := b.block_instr1(.load, blk_loop, b.i64_type, alloca_i)
    len := b.block_instr1(.load, blk_loop, b.i64_type, len_ptr)
    in_range := b.block_instr2(.lt, blk_loop, b.i1_type, i, len)
    b.block_instr3(.br, blk_loop, b.void_type, in_range, ValueID(blk_body), ValueID(blk_not_found))

    keys := b.block_instr1(.load, blk_body, ptr_i8, keys_ptr)
    key_size := b.block_instr1(.load, blk_body, b.i64_type, key_size_ptr)
    offset := b.block_instr2(.mul, blk_body, b.i64_type, i, key_size)
    slot_key := b.block_instr2(.add, blk_body, ptr_i8, keys, offset)
    string_key_size := b.m.get_or_add_const(b.i64_type, '16')
    is_string_key := b.block_instr2(.eq, blk_body, b.i1_type, key_size, string_key_size)
    b.block_instr3(.br, blk_body, b.void_type, is_string_key, ValueID(blk_string_cmp),
        ValueID(blk_mem_cmp))

    slot_string_ptr := b.block_instr1(.bitcast, blk_string_cmp, ptr_string, slot_key)
    key_string_ptr := b.block_instr1(.bitcast, blk_string_cmp, ptr_string, key_ptr)
    slot_string := b.block_instr1(.load, blk_string_cmp, b.str_type, slot_string_ptr)
    key_string := b.block_instr1(.load, blk_string_cmp, b.str_type, key_string_ptr)
    eq_ref := b.m.add_value(.func_ref, b.void_type, 'fast_string_eq', b.fn_ids['fast_string_eq'])
    string_eq := b.block_instr3(.call, blk_string_cmp, b.i1_type, eq_ref, slot_string, key_string)
    b.block_instr3(.br, blk_string_cmp, b.void_type, string_eq, ValueID(blk_found),
        ValueID(blk_next))

    memcmp_ref := b.m.add_value(.func_ref, b.void_type, 'memcmp', b.fn_ids['memcmp'])
    cmp := b.block_instr4(.call, blk_mem_cmp, b.i64_type, memcmp_ref, slot_key, key_ptr, key_size)
    mem_eq := b.block_instr2(.eq, blk_mem_cmp, b.i1_type, cmp, zero)
    b.block_instr3(.br, blk_mem_cmp, b.void_type, mem_eq, ValueID(blk_found), ValueID(blk_next))

    b.block_instr1(.ret, blk_found, b.void_type, i)

    one := b.m.get_or_add_const(b.i64_type, '1')
    next_i := b.block_instr2(.add, blk_next, b.i64_type, i, one)
    b.block_instr2(.store, blk_next, b.void_type, next_i, alloca_i)
    b.block_instr1(.jmp, blk_next, b.void_type, ValueID(blk_loop))

    not_found := b.m.get_or_add_const(b.i64_type, '-1')
    b.block_instr1(.ret, blk_not_found, b.void_type, not_found)
}

// generate_map_exists_body supports generate map exists body handling for Builder.
fn (mut b Builder) generate_map_exists_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_map := b.m.type_store.get_ptr(b.map_type)
    entry := b.m.add_block(func_id, 'entry')
    map_ptr := b.func_add_argument(func_id, ptr_map, 'map')
    key_ptr := b.func_add_argument(func_id, ptr_i8, 'key')
    find_ref := b.m.add_value(.func_ref, b.void_type, 'v3_map_find', b.fn_ids['v3_map_find'])
    idx := b.block_instr3(.call, entry, b.i64_type, find_ref, map_ptr, key_ptr)
    zero := b.m.get_or_add_const(b.i64_type, '0')
    found := b.block_instr2(.ge, entry, b.i1_type, idx, zero)
    b.block_instr1(.ret, entry, b.void_type, found)
}

// generate_map_get_body supports generate map get body handling for Builder.
fn (mut b Builder) generate_map_get_body(func_id int) {
    ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
    ptr_map := b.m.type_store.get_ptr(b.map_type)
    entry := b.m.add_block(func_id, 'entry')
    map_ptr := b.func_add_argument(func_id, ptr_map, 'map')
    key_ptr := b.func_add_argument(func_id, ptr_i8, 'key')
    zero_ptr := b.func_add_argument(func_id, ptr_i8, 'zero')
    find_ref := b.m.add_value(.func_ref, b.void_type, 'v3_map_find', b.fn_ids['v3_map_find'])
    idx := b.block_instr3(.call, entry, b.i64_type, find_r