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

import hash.fnv1a
import os
import v.ast
import v.cflag
import v.pref
import v.util
import v.vcache
import term

const c_std = 'c99'
const cpp_std = 'c++17'

const c_verror_message_marker = 'VERROR_MESSAGE '

const current_os = os.user_os()

const c_compilation_error_title = 'C compilation error'
const missing_libatomic_markers = [
    "library 'atomic' not found",
    'cannot find -latomic',
    'unable to find library -latomic',
    'library not found for -latomic',
    'cannot find libatomic',
]!
const max_cross_sysroot_git_symlink_depth = 32
const max_cross_sysroot_git_symlink_placeholder_size = 256

fn live_windows_import_lib_path(source_path string) string {
    cache_dir := os.join_path(os.cache_dir(), 'v', 'live')
    os.mkdir_all(cache_dir) or {}
    key := fnv1a.sum64_string(os.real_path(source_path)).str()
    return os.join_path(cache_dir, 'host_symbols_${key}.a')
}

fn extract_c_struct_name(line string) string {
    start := line.index('struct ') or { return '' } + 'struct '.len
    mut end := start
    for end < line.len {
        ch := line[end]
        if !ch.is_letter() && !ch.is_digit() && ch != `_` {
            break
        }
        end++
    }
    return if end > start { line[start..end] } else { '' }
}

fn extract_quoted_identifier(line string) string {
    for quote in [u8(`"`), u8(`'`), u8(96)] {
        start := line.index_u8(quote)
        if start == -1 {
            continue
        }
        end := line[start + 1..].index_u8(quote)
        if end == -1 {
            continue
        }
        return line[start + 1..start + 1 + end]
    }
    return ''
}

fn c_output_suggests_missing_header_for_typedef_c_struct(c_output string, known_typedef_c_structs map[string]bool, known_typedef_c_struct_aliases map[string]string) string {
    if known_typedef_c_structs.len == 0 && known_typedef_c_struct_aliases.len == 0 {
        return ''
    }
    for line in c_output.split_into_lines() {
        lower_line := line.to_lower()
        name := extract_quoted_identifier(line)
        if name != '' {
            if lower_line.contains('unknown type name') && name in known_typedef_c_structs {
                return name
            }
            if name in known_typedef_c_struct_aliases
                && (lower_line.contains('expected (got') || lower_line.contains('unknown type name')
                || lower_line.contains('undeclared identifier')
                || lower_line.contains('does not name a type')) {
                return known_typedef_c_struct_aliases[name]
            }
            if name.contains('__')
                && (lower_line.contains('expected (got') || lower_line.contains('unknown type name')
                || lower_line.contains('undeclared identifier')
                || lower_line.contains('does not name a type')) {
                suffix := name.all_after_last('__')
                if suffix in known_typedef_c_structs {
                    return suffix
                }
            }
        }
    }
    return ''
}

fn c_output_suggests_missing_typedef_for_c_struct(c_output string, known_non_typedef_c_structs map[string]bool) string {
    if known_non_typedef_c_structs.len == 0 {
        return ''
    }
    mut forward_declared := map[string]bool{}
    mut incomplete := map[string]bool{}
    for line in c_output.split_into_lines() {
        name := extract_c_struct_name(line)
        if name == '' || name !in known_non_typedef_c_structs {
            continue
        }
        lower_line := line.to_lower()
        if lower_line.contains('has no member named') && (lower_line.contains("aka 'struct ")
            || lower_line.contains('aka `struct ')
            || lower_line.contains('aka "struct ')) {
            return name
        }
        if lower_line.contains('forward declaration of') {
            if name in incomplete {
                return name
            }
            forward_declared[name] = true
            continue
        }
        if lower_line.contains('incomplete result type')
            || lower_line.contains('has incomplete type') || lower_line.contains('incomplete type')
            || lower_line.contains('return type is an incomplete type') {
            if name in forward_declared {
                return name
            }
            incomplete[name] = true
        }
    }
    return ''
}

fn c_output_suggests_missing_sokol_shader_symbol(c_output string) string {
    for line in c_output.split_into_lines() {
        lower_line := line.to_lower()
        if !lower_line.contains('undeclared identifier')
            && !lower_line.contains('undeclared (first use in this function)') {
            continue
        }
        name := extract_quoted_identifier(line)
        if name.starts_with('ATTR_') || name.starts_with('SLOT_') {
            return name
        }
    }
    return ''
}

fn (v &Builder) known_non_typedef_c_structs() map[string]bool {
    mut names := map[string]bool{}
    for sym in v.table.type_symbols {
        if sym.language != .c || sym.kind != .struct || !sym.cname.starts_with('C__') {
            continue
        }
        info := sym.info as ast.Struct
        if info.is_typedef {
            continue
        }
        names[sym.cname[3..]] = true
    }
    return names
}

fn (v &Builder) known_typedef_c_structs() map[string]bool {
    mut names := map[string]bool{}
    for sym in v.table.type_symbols {
        if sym.language != .c || sym.kind != .struct || !sym.cname.starts_with('C__') {
            continue
        }
        info := sym.info as ast.Struct
        if !info.is_typedef {
            continue
        }
        names[sym.cname[3..]] = true
    }
    return names
}

fn (v &Builder) known_typedef_c_struct_aliases() map[string]string {
    mut aliases := map[string]string{}
    for sym in v.table.type_symbols {
        if sym.kind != .alias {
            continue
        }
        alias_info := sym.info as ast.Alias
        parent_sym := v.table.final_sym(alias_info.parent_type)
        if parent_sym.language != .c || parent_sym.kind != .struct
            || !parent_sym.cname.starts_with('C__') {
            continue
        }
        parent_info := parent_sym.info as ast.Struct
        if !parent_info.is_typedef {
            continue
        }
        aliases[sym.cname] = parent_sym.cname[3..]
    }
    return aliases
}

fn c_error_looks_like_cpp_header(c_output string) bool {
    lower_output := c_output.to_lower()
    for marker in [
        "unknown type name 'namespace'",
        "unknown type name 'class'",
        "unknown type name 'template'",
        'unknown type name `namespace`',
        'unknown type name `class`',
        'unknown type name `template`',
        'error: namespace',
        'namespace does not name a type',
        "'operator' declared as",
        '`operator` declared as',
        "before 'operator'",
        'before `operator`',
        'before "operator"',
    ] {
        if lower_output.contains(marker) {
            return true
        }
    }
    for line in lower_output.split_into_lines() {
        trimmed_line := line.trim_space()
        if trimmed_line.starts_with('namespace ') || trimmed_line.contains('| namespace ')
            || trimmed_line.starts_with('class ') || trimmed_line.contains('| class ')
            || trimmed_line.starts_with('public:') || trimmed_line.contains('| public:')
            || trimmed_line.starts_with('private:') || trimmed_line.contains('| private:')
            || trimmed_line.starts_with('protected:') || trimmed_line.contains('| protected:')
            || trimmed_line.contains('template<') || trimmed_line.contains('template <')
            || trimmed_line.contains('operator[]') || trimmed_line.contains('operator []')
            || trimmed_line.contains('::') {
            return true
        }
    }
    return false
}

fn (v &Builder) ensure_imported_coroutines_runtime() ! {
    if 'coroutines' !in v.table.imports {
        return
    }
    pref.ensure_coroutines_runtime()!
}

fn c_error_missing_libatomic_marker(c_output string) string {
    for line in c_output.split_into_lines() {
        lower_line := line.to_lower()
        for marker in missing_libatomic_markers {
            if start := lower_line.index(marker) {
                return line[start..start + marker.len]
            }
        }
    }
    return ''
}

fn c_error_looks_like_missing_libatomic(c_output string) bool {
    return c_error_missing_libatomic_marker(c_output) != ''
}

fn c_error_missing_library_name(c_output string) string {
    for line in c_output.split_into_lines() {
        if line.contains("library '") && line.contains("' not found") {
            return line.all_after("library '").all_before("' not found")
        }
        for marker in [
            'cannot find -l',
            'unable to find library -l',
            'library not found for -l',
        ] {
            if line.contains(marker) {
                lib_name := line.all_after(marker).trim_space()
                return lib_name.all_before('`').all_before("'").all_before('"').all_before(' ').all_before(':')
            }
        }
    }
    return ''
}

fn (mut v Builder) show_c_compiler_output(ccompiler string, res os.Result) {
    header := '======== Output of the C Compiler (${ccompiler}) ========'
    println(header)
    if res.output.len > 0 {
        println(res.output.trim_space())
    }
    println('='.repeat(header.len))
}

fn (mut v Builder) post_process_c_compiler_output(ccompiler string, res os.Result) {
    if res.exit_code == 0 {
        if v.pref.reuse_tmpc {
            return
        }
        if os.getenv('V_NO_RM_CLEANUP_FILES') != '' {
            return
        }
        for tmpfile in v.pref.cleanup_files {
            if os.is_file(tmpfile) {
                if v.pref.is_verbose {
                    eprintln('>> remove tmp file: ${tmpfile}')
                }
                os.rm(tmpfile) or {}
            }
        }
        return
    }
    libatomic_marker := c_error_missing_libatomic_marker(res.output)
    missing_library_name := if libatomic_marker == '' {
        c_error_missing_library_name(res.output)
    } else {
        ''
    }
    for emsg_marker in [c_verror_message_marker, 'error: include file '] {
        if res.output.contains(emsg_marker) {
            emessage :=
                res.output.all_after(emsg_marker).all_before('\n').all_before('\r').trim_right('\r\n')
            verror(emessage)
        }
    }
    if v.pref.is_debug {
        eword := 'error:'
        khighlight := highlight_word(eword)
        println(res.output.trim_right('\r\n').replace(eword, khighlight))
    } else {
        if res.output.len < 30 {
            println(res.output)
        } else {
            trimmed_output := res.output.trim_space()
            original_elines := trimmed_output.split_into_lines()
            mlines := 12
            cut_off_limit := if original_elines.len > mlines + 3 { mlines } else { mlines + 3 }
            mut error_keyword := 'error:'
            mut error_context_before := 1
            if libatomic_marker != '' && trimmed_output.contains(libatomic_marker) {
                error_keyword = libatomic_marker
                error_context_before = 0
            }
            elines := error_context_lines(trimmed_output, error_keyword, error_context_before,
                cut_off_limit)
            header := '================== ${c_compilation_error_title} (from ${ccompiler}): =============='
            println(header)
            for eline in elines {
                println('cc: ${eline}')
            }
            if original_elines.len != elines.len {
                println('...')
                println('cc: ${original_elines#[-1..][0]}')
                println('(note: the original output was ${original_elines.len} lines long; it was truncated to its first ${elines.len} lines + the last line)')
            }
            println('='.repeat(header.len))
            // Check for TCC cross-compilation errors
            if ccompiler == 'tcc' && res.output.starts_with('tcc: error: could not run') {
                println('${highlight_word('Suggestion')}: try using a different C compiler with `-cc gcc` or `-cc clang`.')
                println('${highlight_word('Suggestion')}: or build TCC for the target architecture yourself.')
                println('${highlight_word('Note')}: you should build an 32bit version of `${@VEXEROOT}/thirdparty/tcc/lib/libgc.a` first or use `-gc none`.')
                exit(1)
            } else {
                println('Try passing `-g` when compiling, to see a .v file:line information, that correlates more with the C error.')
                println('(Alternatively, pass `-show-c-output`, to print the full C error message).')
            }
        }
    }
    if v.pref.is_quiet {
        exit(1)
    }
    mut more_suggestions := ''
    if res.output.contains('o: unrecognized file type')
        || res.output.contains('.o: file not recognized') {
        more_suggestions += '\n${highlight_word('Suggestion')}: try `v wipe-cache`, then repeat your compilation.'
    }
    missing_typedef_header_name := c_output_suggests_missing_header_for_typedef_c_struct(res.output,
        v.known_typedef_c_structs(), v.known_typedef_c_struct_aliases())
    if missing_typedef_header_name != '' {
        more_suggestions += '\n${highlight_word('Suggestion')}: the C typedef `${missing_typedef_header_name}` backing `@[typedef] struct C.${missing_typedef_header_name} {}` was not found by the C compiler. Make sure the header that defines it is included on this platform and that its `#flag -I` path is correct. If the C API actually declares `struct ${missing_typedef_header_name}` without a typedef, remove `@[typedef]` from the V redeclaration.'
    }
    missing_typedef_name := c_output_suggests_missing_typedef_for_c_struct(res.output,
        v.known_non_typedef_c_structs())
    if missing_typedef_name != '' {
        more_suggestions += '\n${highlight_word('Suggestion')}: if `${missing_typedef_name}` is declared in the C header with `typedef struct ... ${missing_typedef_name};`, add `@[typedef]` to the V redeclaration: `@[typedef] struct C.${missing_typedef_name} { ... }`.'
    }
    missing_shader_symbol := c_output_suggests_missing_sokol_shader_symbol(res.output)
    if missing_shader_symbol != '' {
        more_suggestions += '\n${highlight_word('Suggestion')}: `${missing_shader_symbol}` looks like a sokol shader symbol generated by `v shader`/`sokol-shdc`. If you renamed `C.${missing_shader_symbol}` in V, make the same change in the matching `.glsl` file and regenerate the header with `v shader .`.'
    }
    if c_error_looks_like_cpp_header(res.output) {
        verror('
==================
C error found while compiling generated C code.
It looks like a C++ header was included with `#include` (for example one that contains `namespace`).
Use a C-compatible header (for HDF5 use `hdf5.h` instead of `H5File.h`), or compile/link the C++ code separately.${more_suggestions}')
    }
    if libatomic_marker != '' {
        verror('
==================
C error found while compiling generated C code.
The C toolchain could not find `libatomic`, which V needs for `sync.stdatomic` with this compiler on this platform.
Install the system package that provides `libatomic` and retry.
On CentOS/RHEL, that is usually `libatomic` or `libatomic-devel`.${more_suggestions}')
    }
    if missing_library_name != '' {
        verror('
==================
C library `${missing_library_name}` was not found while linking the generated program.
Please install the corresponding development package/libraries and make sure the linker can find it.${more_suggestions}')
    }
    verror('
==================
C error found while compiling generated C code.
This can be caused by invalid C interop code, C compiler flags, or a V compiler bug.
If your code is pure V and this still happens, please report it using `v bug file.v`,
or goto https://github.com/vlang/v/issues/new/choose .
You can also use #help on Discord: https://discord.gg/vlang .${more_suggestions}')
}

fn (mut v Builder) show_cc(cmd string, response_file string, response_file_content string) {
    if v.pref.is_verbose || v.pref.show_cc {
        println('> C compiler cmd: ${cmd}')
        if v.pref.show_cc && !v.pref.no_rsp && response_file != '' {
            println('> C compiler response file "${response_file}":')
            println(response_file_content)
        }
    }
}

pub enum CC {
    tcc
    gcc
    icc
    msvc
    clang
    emcc
    unknown
}

pub struct CcompilerOptions {
pub mut:
    guessed_compiler string
    shared_postfix   string // .so, .dll

    debug_mode bool
    cc         CC

    env_cflags  string // prepended *before* everything else
    env_ldflags string // appended *after* everything else

    args         []string // ordinary C options like `-O2`
    wargs        []string // for `-Wxyz` *exclusively*
    pre_args     []string // options that should go before .o_args
    o_args       []string // for `-o target`
    source_args  []string // for `x.tmp.c`
    post_args    []string // options that should go after .o_args
    linker_flags []string // `-lm`
    ldflags      []string // `-labcd' from `v -ldflags "-labcd"`
}

type WindowsPathResolver = fn (string) string

fn ccompiler_type_from_name_with_ok(ccompiler string) (pref.CompilerType, bool) {
    cc_file_name := os.file_name(ccompiler).to_lower_ascii()
    if is_tinyc_compiler_label(cc_file_name) {
        return pref.CompilerType.tinyc, true
    }
    if cc_file_name.contains('gcc') {
        return pref.CompilerType.gcc, true
    }
    if cc_file_name.contains('clang') {
        return pref.CompilerType.clang, true
    }
    if cc_file_name.contains('emcc') {
        return pref.CompilerType.emcc, true
    }
    if cc_file_name == 'cl' || cc_file_name == 'cl.exe' || cc_file_name.contains('msvc') {
        return pref.CompilerType.msvc, true
    }
    if cc_file_name.contains('mingw') {
        return pref.CompilerType.mingw, true
    }
    if cc_file_name.contains('++') {
        return pref.CompilerType.cplusplus, true
    }
    return pref.CompilerType.tinyc, false
}

fn ccompiler_type_from_name(ccompiler string) ?pref.CompilerType {
    resolved, ok := ccompiler_type_from_name_with_ok(ccompiler)
    return if ok { resolved } else { none }
}

fn ccompiler_type_from_resolved_path(ccompiler string) ?pref.CompilerType {
    ccompiler_path := if os.exists(ccompiler) {
        ccompiler
    } else {
        os.find_abs_path_of_executable(ccompiler) or { return none }
    }
    $if macos {
        if ccompiler_path == '/usr/bin/cc' {
            return pref.CompilerType.clang
        }
    }
    resolved, ok := ccompiler_type_from_name_with_ok(os.real_path(ccompiler_path))
    return if ok { resolved } else { none }
}

fn ccompiler_type_from_version_output_with_ok(output string) (pref.CompilerType, bool) {
    if output == '' {
        return pref.CompilerType.tinyc, false
    }
    lower_output := output.to_lower_ascii()
    if is_tinyc_version_output(lower_output) {
        return pref.CompilerType.tinyc, true
    }
    if lower_output.contains('clang') {
        return pref.CompilerType.clang, true
    }
    if lower_output.contains('gcc version') || lower_output.contains('(gcc)')
        || lower_output.contains('free software foundation') || lower_output.contains('gcc ') {
        return pref.CompilerType.gcc, true
    }
    if lower_output.contains('emscripten') || lower_output.contains('emcc') {
        return pref.CompilerType.emcc, true
    }
    if (lower_output.contains('microsoft') && lower_output.contains('c/c++'))
        || lower_output.contains('msvc') {
        return pref.CompilerType.msvc, true
    }
    return pref.CompilerType.tinyc, false
}

fn ccompiler_type_from_version_output(output string) ?pref.CompilerType {
    resolved, ok := ccompiler_type_from_version_output_with_ok(output)
    return if ok { resolved } else { none }
}

fn resolve_ccompiler_type(ccompiler string, fallback pref.CompilerType) pref.CompilerType {
    resolved_by_name, name_ok := ccompiler_type_from_name_with_ok(ccompiler)
    if name_ok {
        return resolved_by_name
    }
    if resolved_by_path := ccompiler_type_from_resolved_path(ccompiler) {
        return resolved_by_path
    }
    quoted_ccompiler := os.quoted_path(ccompiler)
    for version_flag in ['--version', '-v'] {
        res := os.execute('${quoted_ccompiler} ${version_flag} 2>&1')
        resolved_by_version, version_ok := ccompiler_type_from_version_output_with_ok(res.output)
        if version_ok {
            return resolved_by_version
        }
    }
    return fallback
}

fn darwin_target_arch_name(arch pref.Arch) string {
    return match arch {
        .amd64 { 'x86_64' }
        .arm64 { 'arm64' }
        .i386 { 'i386' }
        .ppc { 'ppc' }
        .ppc64 { 'ppc64' }
        else { '' }
    }
}

fn cc_from_pref_ccompiler_type(cc_type pref.CompilerType) CC {
    return match cc_type {
        .tinyc { .tcc }
        .gcc, .mingw { .gcc }
        .clang { .clang }
        .emcc { .emcc }
        .msvc { .msvc }
        .cplusplus { .unknown }
    }
}

fn (mut v Builder) setup_ccompiler_options(ccompiler string) {
    mut ccoptions := CcompilerOptions{}

    mut debug_options := ['-g']
    mut optimization_options := ['-O2']
    // arguments for the C compiler
    ccoptions.args = [v.pref.cflags]
    ccoptions.ldflags = [v.pref.ldflags]
    ccoptions.wargs = [
        '-Wall',
        '-Wextra',
        '-Werror',
        // if anything, these should be a `v vet` warning instead:
        '-Wno-unused-parameter',
        '-Wno-unused',
        '-Wno-type-limits',
        '-Wno-tautological-compare',
        // these cause various issues:
        '-Wno-shadow', // the V compiler already catches this for user code, and enabling this causes issues with e.g. the `it` variable
        '-Wno-int-to-pointer-cast', // gcc version of the above
        '-Wno-trigraphs', // see stackoverflow.com/a/8435413
        '-Wno-missing-braces', // see stackoverflow.com/q/13746033
        '-Wno-enum-conversion', // silences `.dst_factor_rgb = sokol__gfx__BlendFactor__one_minus_src_alpha`
        '-Wno-enum-compare', // silences `if (ev->mouse_button == sokol__sapp__MouseButton__left) {`
        // enable additional warnings:
        '-Wdate-time',
        '-Winit-self',
        '-Winvalid-pch',
        '-Wmultichar',
        '-Wnested-externs',
        '-Wnull-dereference',
        '-Wpacked',
        '-Wpointer-arith',
    ]
    if v.pref.os == .ios {
        ccoptions.args << '-fobjc-arc'
    }
    if v.pref.os == .macos && os.exists('/opt/procursus') {
        ccoptions.linker_flags << '-Wl,-rpath,/opt/procursus/lib'
    }
    mut user_darwin_version := 999_999
    mut user_darwin_ppc := false
    $if macos {
        user_darwin_version = os.uname().release.split('.')[0].int()
        if os.uname().machine == 'Power Macintosh' {
            user_darwin_ppc = true
        }
    }
    ccoptions.debug_mode = v.pref.is_debug
    ccoptions.guessed_compiler = v.pref.ccompiler
    v.pref.ccompiler_type = resolve_ccompiler_type(ccompiler, v.pref.ccompiler_type)
    cc_file_name := os.file_name(ccompiler).to_lower_ascii()
    ccoptions.cc = if cc_file_name.contains('icc') || ccoptions.guessed_compiler == 'icc' {
        .icc
    } else {
        cc_from_pref_ccompiler_type(v.pref.ccompiler_type)
    }
    if ccoptions.cc == .unknown {
        eprintln('Compilation with unknown C compiler `${cc_file_name}`')
    }
    if v.pref.os == .macos && ccoptions.cc != .tcc {
        // tcc does not understand -arch; it only targets the host arch.
        darwin_target_arch := darwin_target_arch_name(v.pref.arch)
        if darwin_target_arch != '' {
            ccoptions.args << ['-arch', darwin_target_arch]
        }
    }

    // Add -fwrapv to handle UB overflows
    if ccoptions.cc in [.gcc, .clang, .tcc]
        && v.pref.os in [.macos, .linux, .openbsd, .freebsd, .windows] {
        ccoptions.args << '-fwrapv'
    }

    // For C++ we must be very tolerant
    if ccoptions.guessed_compiler.contains('++') {
        ccoptions.args << '-fpermissive'
        ccoptions.args << '-w'
    }
    if ccoptions.cc == .clang {
        if ccoptions.debug_mode {
            debug_options = ['-g', '-O0']
        }
        optimization_options = ['-O3']
        mut have_flto := true
        $if windows {
            have_flto = false
        }
        if v.pref.parallel_cc {
            have_flto = false
        }
        if v.pref.is_shared || v.disable_flto {
            // Keep shared libraries away from LTO to avoid runtime loader regressions.
            have_flto = false
        }
        if have_flto {
            optimization_options << '-flto'
        }
        ccoptions.wargs << [
            '-Wno-tautological-bitwise-compare',
            '-Wno-enum-conversion', // used in vlib/sokol, where C enums in C structs are typed as V structs instead
            '-Wno-sometimes-uninitialized', // produced after exhaustive matches
            '-Wno-int-to-void-pointer-cast',
            '-Wno-excess-initializers', // vlib/v/tests/struct_init_with_complex_fields_test.v fails without that on macos clang 13
            '-Wno-unknown-warning', // if a C compiler does not understand a certain flag, it should just ignore it
            '-Wno-unknown-warning-option', // clang equivalent of the above
        ]
        // Apple clang >= 17 treats -Wincompatible-function-pointer-types as an error by default.
        // V generates code with enum types (e.g. os.Signal) in callbacks where C expects int,
        // and specific struct* returns where C expects void* (e.g. sync.pool.ThreadCB).
        ccoptions.args << '-Wno-incompatible-function-pointer-types'
        ccoptions.args << '-Wno-typedef-redefinition' // V re-typedefs bool after includes to undo stdbool.h
    }
    if ccoptions.cc == .gcc {
        if ccoptions.debug_mode {
            debug_options = ['-g']
            if user_darwin_version > 9 {
                debug_options << '-no-pie'
            }
        }
        optimization_options = ['-O3']
        mut have_flto := true
        if v.pref.parallel_cc {
            have_flto = false
        }
        if v.pref.is_shared || v.disable_flto {
            // Keep shared libraries away from LTO to avoid runtime loader regressions.
            have_flto = false
        }
        if have_flto {
            optimization_options << '-flto'
        }
        // gcc versions newer than 10.2, produce buggy programs, usually triggered by optimising inlined small functions, when both -flto and -O3 are used.
        // Using -fno-strict-aliasing prevents that. See https://github.com/vlang/v/issues/26512 .
        optimization_options << '-fno-strict-aliasing'
        ccoptions.wargs << [
            '-Wduplicated-branches',
            '-Wduplicated-cond',
            '-Wjump-misses-init',
            '-Wlogical-op',
            '-Wno-incompatible-pointer-types', // V uses enum types (e.g. os.Signal) in callbacks where C expects int
            '-Wno-missing-field-initializers', // @[typedef] C structs may have fields not present in V binding
        ]
        // On macOS, `gcc` is actually Apple clang, which splits -Wincompatible-pointer-types
        // and -Wincompatible-function-pointer-types into separate warnings.
        ccoptions.args << '-Wno-incompatible-function-pointer-types'
    }
    if ccoptions.cc == .icc {
        if ccoptions.debug_mode {
            debug_options = ['-g']
            if user_darwin_version > 9 {
                debug_options << '-no-pie'
            }
        }
        optimization_options = ['-Ofast']
    }

    if ccoptions.debug_mode {
        ccoptions.args << debug_options
    }
    if v.pref.is_prod {
        // don't warn for vlib tests
        if ccoptions.cc == .tcc && !(v.parsed_files.len > 0
            && v.parsed_files.last().path.contains('vlib')) {
            if !v.pref.is_quiet {
                eprintln('Note: tcc is not recommended for -prod builds')
            }
        }
        if !v.pref.no_prod_options {
            ccoptions.args << optimization_options
        }
    }
    if v.pref.is_prod && !ccoptions.debug_mode {
        // sokol and other C libraries that use asserts
        // have much better performance when NDEBUG is defined
        // See also http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf
        ccoptions.args << '-DNDEBUG'
        ccoptions.args << '-DNO_DEBUGGING' // for BDWGC
    }
    if v.pref.sanitize {
        ccoptions.args << '-fsanitize=leak'
    }
    if v.pref.is_o {
        ccoptions.args << '-c'
    }

    ccoptions.shared_postfix = '.so'
    if v.pref.os == .macos {
        ccoptions.shared_postfix = '.dylib'
    }
    if v.pref.os == .windows {
        ccoptions.shared_postfix = '.dll'
    }
    if v.pref.is_shared {
        ccoptions.linker_flags << '-shared'
        $if !windows {
            ccoptions.args << '-fPIC' // -Wl,-z,defs'
        }
        if v.pref.os == .linux && 'gcboehm' in v.pref.compile_defines_all {
            // Keep shared-library GC symbols bound to the shared object itself.
            // This avoids cross-DSO symbol interposition between multiple V binaries
            // in one process (for example, host executable + loaded V plugin).
            ccoptions.linker_flags << '-Wl,-Bsymbolic'
        }
    }
    if v.pref.is_bare && v.pref.os != .wasm32 {
        ccoptions.args << '-fno-stack-protector'
        ccoptions.args << '-ffreestanding'
        ccoptions.linker_flags << '-static'
        ccoptions.linker_flags << '-nostdlib'
    } else if v.pref.os == .wasm32 {
        ccoptions.args << '--no-standard-libraries'
        ccoptions.args << '-target wasm32-unknown-unknown'
        ccoptions.args << '-static'
        ccoptions.args << '-nostdlib'
        ccoptions.args << '-ffreestanding'
        ccoptions.args << '-Wl,--export-all'
        ccoptions.args << '-Wl,--no-entry'
    }
    if ccoptions.debug_mode && current_os != 'windows' && v.pref.build_mode != .build_module {
        if ccoptions.cc != .tcc && current_os == 'macos' {
            ccoptions.linker_flags << '-Wl,-export_dynamic' // clang for mac needs export_dynamic instead of -rdynamic
        } else {
            if v.pref.ccompiler != 'x86_64-w64-mingw32-gcc' {
                // the mingw-w64-gcc cross compiler does not support -rdynamic, and windows/wine already does have nicer backtraces
                ccoptions.linker_flags << '-rdynamic' // needed for nicer symbolic backtraces
            }
        }
    }
    if v.pref.os == .freebsd {
        // Needed for -usecache on FreeBSD 13, otherwise we get `ld: error: duplicate symbol: _const_math__bits__de_bruijn32` errors there
        if ccoptions.cc != .tcc {
            ccoptions.linker_flags << '-Wl,--allow-multiple-definition'
        } else {
            // tcc needs this, otherwise it fails to compile the runetype.h system header with:
            // /usr/include/runetype.h:94: error: ';' expected (got "const")
            ccoptions.args << '-D__RUNETYPE_INTERNAL'
        }
    }

    // Fix 'braces around scalar initializer' errors
    // on OpenBSD with clang for cstrict mode
    if v.pref.os == .openbsd && ccoptions.cc == .clang {
        ccoptions.wargs << '-Wno-braced-scalar-init'
    }

    if ccompiler != 'msvc' && v.pref.os != .freebsd {
        ccoptions.wargs << '-Werror=implicit-function-declaration'
    }
    if ccoptions.cc == .tcc {
        // tcc 806b3f98 needs this flag too:
        ccoptions.wargs << '-Wno-write-strings'
    }
    if v.pref.is_liveshared || v.pref.is_livemain {
        if v.pref.os in [.linux, .android, .termux] && v.pref.build_mode != .build_module {
            // The live reload shared library resolves symbols from the host executable.
            // Termux/Android need the same export behavior as Linux, otherwise plain
            // `-live` can crash while `-cg -live` happens to work via debug linker flags.
            ccoptions.linker_flags << '-rdynamic'
        }
        if v.pref.os == .macos {
            ccoptions.args << '-flat_namespace'
            if v.pref.is_liveshared {
                // Resolve sapp_* and similar host symbols when the live-reload dylib is loaded.
                ccoptions.args << '-undefined'
                ccoptions.args << 'dynamic_lookup'
            }
        }
        if v.pref.os == .windows && ccoptions.cc != .msvc {
            host_import_lib := v.tcc_quoted_path(live_windows_import_lib_path(v.pref.path))
            if v.pref.is_livemain {
                // Re-export host graphics/backend symbols so the live-reload DLL can reuse them.
                ccoptions.linker_flags << '-Wl,--export-all-symbols'
                ccoptions.linker_flags << '-Wl,--out-implib,${host_import_lib}'
            }
            if v.pref.is_liveshared {
                // Link the live-reload DLL against the host executable's import library.
                ccoptions.linker_flags << host_import_lib
            }
        }
    }

    // macOS code can include objective C  TODO remove once objective C is replaced with C
    if v.pref.os in [.macos, .ios] {
        if ccoptions.cc != .tcc && !user_darwin_ppc && !v.pref.is_bare && ccompiler != 'musl-gcc' {
            ccoptions.source_args << '-x objective-c'
        }
    }
    // Newer Windows runner images can surface short paths with an uppercase `.C` suffix,
    // which makes GCC/Clang compile the generated V C file as C++ unless we force C mode.
    force_generated_c_language := v.pref.os == .windows && !v.pref.parallel_cc
        && ccoptions.cc in [.gcc, .clang, .emcc]
    if force_generated_c_language {
        ccoptions.source_args << '-x c'
    }
    // The C file we are compiling
    if !v.pref.parallel_cc { // parallel_cc uses its own split up c files
        ccoptions.source_args << v.tcc_quoted_path(v.out_name_c)
    }
    // Min macos version is mandatory I think?
    if v.pref.os == .macos {
        if v.pref.macosx_version_min != '0' {
            ccoptions.post_args << '-mmacosx-version-min=${v.pref.macosx_version_min}'
        }
    }
    if v.pref.os == .ios {
        if v.pref.is_ios_simulator {
            ccoptions.post_args << '-miphonesimulator-version-min=10.0'
        } else {
            ccoptions.post_args << '-miphoneos-version-min=10.0'
        }
    }
    if v.pref.os == .windows {
        subsystem_flag := v.get_subsystem_flag()
        if subsystem_flag != '' {
            ccoptions.post_args << subsystem_flag
        }
    }
    ccoptions.env_cflags = os.getenv('CFLAGS').replace('\n', ' ')
    ccoptions.env_ldflags = os.getenv('LDFLAGS').replace('\n', ' ')
    // Set the cache salt before resolving cached thirdparty object paths,
    // so object building and final compilation agree on the same cache entry.
    v.pref.cache_manager.set_temporary_options(v.thirdparty_object_args(ccoptions, [
        ccoptions.guessed_compiler,
    ], false))
    cflags := v.get_os_cflags()

    if v.pref.build_mode != .build_module && !v.pref.is_o {
        only_o_files := cflags.c_options_only_object_files()
        ccoptions.o_args << only_o_files
    }

    defines, others, libs := cflags.defines_others_libs()
    ccoptions.pre_args << defines
    ccoptions.pre_args << others
    ccoptions.linker_flags << libs
    v.fixup_tcc_macos_comma_path_flags(mut ccoptions)
    if v.pref.use_cache && v.pref.build_mode != .build_module {
        if ccoptions.cc != .tcc {
            $if linux {
                ccoptions.linker_flags << '-Xlinker -z'
                ccoptions.linker_flags << '-Xlinker muldefs'
            }
        }
    }
    if ccoptions.cc == .tcc && 'no_backtrace' !in v.pref.compile_defines {
        ccoptions.post_args << '-bt25'
    }
    // Without these libs compilation will fail on Linux
    if !v.pref.is_bare && v.pref.build_mode != .build_module
        && v.pref.os in [.linux, .freebsd, .openbsd, .netbsd, .dragonfly, .solaris, .haiku] {
        if v.pref.os in [.freebsd, .netbsd] {
            // Free/NetBSD: backtrace needs execinfo library while linking, also execinfo depends on elf.
            ccoptions.linker_flags << '-lexecinfo'
            ccoptions.linker_flags << '-lelf'
        }
    }
    if v.pref.os == .macos {
        if v.pref.use_cache {
            ccoptions.source_args << '-x none'
        } else {
            for flag in ccoptions.linker_flags {
                if flag.starts_with('-') {
                    continue
                }
                if os.is_file(flag) {
                    ccoptions.source_args << '-x none'
                    break
                }
                path := if flag.starts_with('"') && flag.ends_with('"') {
                    flag[1..flag.len - 1]
                } else {
                    flag
                }
                if os.is_dir(os.dir(path)) {
                    ccoptions.source_args << '-x none'
                    break
                }
            }
        }
    }
    if !v.pref.no_std {
        ccoptions.source_args << ['-std=${c_std}', '-D_DEFAULT_SOURCE']
    }
    $if trace_ccoptions ? {
        println('>>> setup_ccompiler_options ccompiler: ${ccompiler}')
        println('>>> setup_ccompiler_options ccoptions: ${ccoptions}')
    }
    v.ccoptions = ccoptions
}

fn (v &Builder) all_args(ccoptions CcompilerOptions) []string {
    mut all := []string{}
    all << v.only_compile_args(ccoptions)
    all << v.only_linker_args(ccoptions)
    return all
}

pub fn (v &Builder) get_compile_args() []string {
    return v.only_compile_args(v.ccoptions)
}

fn (v &Builder) only_compile_args(ccoptions CcompilerOptions) []string {
    mut all := []string{}
    all << ccoptions.env_cflags
    if v.pref.is_cstrict {
        all << ccoptions.wargs
    }
    all << ccoptions.args
    all << ccoptions.o_args
    $if windows {
        // Adding default options for tcc, gcc and clang as done in msvc.v.
        // This is done before pre_args is added so that it can be overwritten if needed.
        // -Wl,-stack=33554432 == /F33554432
        // -Werror=implicit-function-declaration == /we4013
        // /volatile:ms - there seems to be no equivalent,
        // normally msvc should use /volatile:iso
        // but it could have an impact on vinix if it is created with msvc.
        if ccoptions.cc != .msvc {
            if v.pref.os != .wasm32_emscripten {
                all << '-Wl,-stack=33554432'
            }
            if !v.pref.is_cstrict {
                all << '-Werror=implicit-function-declaration'
            }
        }
    }
    all << ccoptions.pre_args
    all << ccoptions.source_args
    all << ccoptions.post_args
    return all
}

pub fn (v &Builder) get_linker_args() []string {
    return v.only_linker_args(v.ccoptions)
}

fn (v &Builder) only_linker_args(ccoptions CcompilerOptions) []string {
    mut all := []string{}
    // in `build-mode` or when producing a .o file, we do not need -lxyz flags,
    // since we are building an (.o) object file, that will be linked later.
    if v.pref.build_mode != .build_module && !v.pref.is_o {
        all << ccoptions.linker_flags
        all << ccoptions.env_ldflags
        all << ccoptions.ldflags
    }
    return all
}

struct ThirdpartyCrossCompileConfig {
    target_args           []string
    trailing_include_args []string
    sysroot               string
}

fn (v &Builder) thirdparty_cross_compile_config() ThirdpartyCrossCompileConfig {
    if v.pref.os == .linux && current_os != 'linux' {
        sysroot := os.join_path(os.vmodules_dir(), 'linuxroot')
        return ThirdpartyCrossCompileConfig{
            target_args:           ['-target x86_64-linux-gnu']
            trailing_include_args: [
                '-I',
                os.quoted_path('${sysroot}/include'),
            ]
            sysroot:               sysroot
        }
    }
    if v.pref.os == .freebsd && current_os != 'freebsd' {
        sysroot := os.join_path(os.vmodules_dir(), 'freebsdroot')
        return ThirdpartyCrossCompileConfig{
            target_args:           ['-target x86_64-unknown-freebsd14.0']
            trailing_include_args: [
                '-I',
                os.quoted_path('${sysroot}/include'),
                '-I',
                os.quoted_path('${sysroot}/usr/include'),
            ]
            sysroot:               sysroot
        }
    }
    return ThirdpartyCrossCompileConfig{}
}

fn (mut v Builder) ensure_thirdparty_cross_compile_sysroot(cfg ThirdpartyCrossCompileConfig) {
    if cfg.sysroot == '' {
        return
    }
    if v.pref.os == .linux {
        v.ensure_linuxroot_exists(cfg.sysroot)
        return
    }
    if v.pref.os == .freebsd {
        v.ensure_freebsdroot_exists(cfg.sysroot)
    }
}

fn (mut v Builder) thirdparty_object_args(ccoptions CcompilerOptions, middle []string, cpp_file bool) []string {
    mut all := []string{}

    if !v.pref.no_std {
        if cpp_file {
            all << '-std=${cpp_std}'
        } else {
            all << '-std=${c_std}'
        }
        all << '-D_DEFAULT_SOURCE'
    }

    cross_cfg := v.thirdparty_cross_compile_config()
    if cross_cfg.sysroot != '' {
        v.ensure_thirdparty_cross_compile_sysroot(cross_cfg)
        all << cross_cfg.target_args
    }

    all << ccoptions.env_cflags
    all << ccoptions.args
    all << middle
    // NOTE do not append linker flags in .o build process,
    // compilers are inconsistent about how they handle:
    // all << ccoptions.env_ldflags
    // all << ccoptions.ldflags
    if cross_cfg.sysroot != '' {
        // add the system include/ folder after everything else,
        // so that local folders like thirdparty/mbedtls have a
        // chance to supply their own headers
        all << cross_cfg.trailing_include_args
    }
    return all
}

fn (mut v Builder) setup_output_name() {
    if !v.pref.is_shared && v.pref.build_mode != .build_module && v.pref.os == .windows
        && !v.pref.is_o && !v.pref.out_name.ends_with('.exe') {
        v.pref.out_name += '.exe'
    }
    // Output executable name
    v.log('cc() isprod=${v.pref.is_prod} outname=${v.pref.out_name}')
    if v.pref.is_shared {
        if !v.pref.out_name.ends_with(v.ccoptions.shared_postfix) {
            v.pref.out_name += v.ccoptions.shared_postfix
        }
    }
    if v.pref.build_mode == .build_module {
        v.pref.out_name = v.pref.cache_manager.mod_postfix_with_key2cpath(v.pref.path, '.o',
            v.pref.path) // v.out_name
        if v.pref.is_verbose {
            println('Building ${v.pref.path} to ${v.pref.out_name} ...')
        }
        v.pref.cache_manager.mod_save(v.pref.path, '.output.description.txt', v.pref.path,
            get_dsc_content('PREF.PATH: ${v.pref.path}\nVOPTS: ${v.pref.cache_manager.vopts}\n')) or {
            panic(err)
        }
    }
    if os.is_dir(v.pref.out_name) {
        verror('${os.quoted_path(v.pref.out_name)} is a directory')
    }
    if !v.pref.parallel_cc {
        // parallel_cc sets its own `-o out_n.o`
        v.ccoptions.o_args << '-o ${v.tcc_quoted_path(v.pref.out_name)}'
    }
}

pub fn (mut v Builder) tcc_quoted_path(p string) string {
    wp := v.tcc_windows_path(p)
    if v.ccoptions.cc == .tcc && !v.pref.no_rsp {
        // tcc has a bug that prevents it from parsing names quoted with `'` in .rsp files,
        // so force double-quoted, backslash-escaped paths for tcc rsp mode.
        mut escaped := wp.replace('\\', '\\\\')
        escaped = escaped.replace('"', '\\"')
        return '"${escaped}"'
    }
    return os.quoted_path(wp)
}

fn looks_like_windows_path(value string) bool {
    return value.contains('\\') || value.contains('/') || (value.len > 1 && value[1] == `:`)
}

fn rewrite_windows_path_arg(arg string, resolver WindowsPathResolver) string {
    if arg == '' {
        return ''
    }
    if start := arg.index('"') {
        end := arg.last_index('"') or { -1 }
        if end > start {
            path := arg[start + 1..end]
            if looks_like_windows_path(path) {
                return arg[..start] + '"${resolver(path)}"' + arg[end + 1..]
            }
        }
    }
    for prefix in ['-I', '-L', '-B', '-o ', '-c '] {
        if arg.starts_with(prefix) {
            path := arg[prefix.len..].trim_space().trim('"')
            if looks_like_windows_path(path) {
                return prefix + '"${resolver(path)}"'
            }
        }
    }
    trimmed := arg.trim_space().trim('"')
    if !arg.starts_with('-') && looks_like_windows_path(trimmed) {
        return '"${resolver(trimmed)}"'
    }
    return arg
}

fn short_windows_path(path string) string {
    $if windows {
        return os.short_path(path)
    }
    return path
}

fn (v &Builder) tcc_windows_path(p string) string {
    $if windows {
        if v.ccoptions.cc == .tcc {
            return short_windows_path(p)
        }
    }
    return p
}

fn (v &Builder) tcc_windows_path_arg(arg string) string {
    $if windows {
        if v.ccoptions.cc == .tcc {
            return rewrite_windows_path_arg(arg, short_windows_path)
        }
    }
    return arg
}

fn (v &Builder) rsp_safe_arg(arg string) string {
    if arg.starts_with('-B') && arg.len > 2 {
        path := arg[2..]
        if path.contains(' ') && !path.starts_with('"') {
            return '-B"${path}"'
        }
    }
    return arg
}

fn (v &Builder) should_use_rsp(rsp_args []string) bool {
    if v.pref.no_rsp || v.pref.os == .termux {
        return false
    }
    for arg in rsp_args {
        if arg.contains("'\\''") || arg.contains('\n') || arg.contains('\r') {
            return false
        }
    }
    return true
}

fn (v &Builder) msvc_should_use_rsp(args []string) bool {
    if !v.should_use_rsp(args) {
        return false
    }
    // Keep Unicode paths on the direct CreateProcessW command line. MSVC response
    // files still mis-handle non-ASCII file names on some Windows setups.
    for arg in args {
        if !arg.is_ascii() {
            return false
        }
    }
    return true
}

fn (v &Builder) c_project_source_name() string {
    mut output_name := os.file_name(v.pref.out_name)
    if output_name == '' {
        output_name = 'main'
    }
    base_name := output_name.all_before_last('.')
    return if base_name == '' { '${output_name}.c' } else { '${base_name}.c' }
}

fn (mut v Builder) c_project_output_name() string {
    mut output_name := os.file_name(v.pref.out_name)
    if output_name == '' {
        output_name = 'main'
    }
    if output_name.ends_with('.c') {
        output_name = output_name.trim_string_right('.c')
    }
    if output_name == '' {
        output_name = 'main'
    }
    if !v.pref.is_shared && v.pref.build_mode != .build_module && v.pref.os == .windows
        && !v.pref.is_o && !output_name.ends_with('.exe') {
        output_name += '.exe'
    }
    if v.pref.is_shared && !output_name.ends_with(v.ccoptions.shared_postfix) {
        output_name += v.ccoptions.shared_postfix
    }
    return output_name
}

fn (mut v Builder) c_project_dependency_replacements() map[string]string {
    mut replacements := map[string]string{}
    for flag in v.get_os_cflags() {
        if !flag.value.ends_with('.o') && !flag.value.ends_with('.obj') {
            continue
        }
        cached_value := if flag.cached == '' { os.real_path(flag.value) } else { flag.cached }
        obj_path := os.real_path(flag.value)
        replacement_value := if source_path := c_project_source_from_object_path(obj_path) {
            os.quoted_path(source_path)
        } else if os.exists(obj_path) {
            os.quoted_path(obj_path)
        } else {
            os.quoted_path(cached_value)
        }
        for key in [
            cached_value,
            os.quoted_path(cached_value),
            '"${cached_value}"',
            flag.format() or { '' },
        ] {
            if key == '' {
                continue
            }
            replacements[key] = replacement_value
        }
    }
    return replacements
}

fn (mut v Builder) generate_c_project() {
    if v.pref.backend != .c {
        verror('`-generate-c-project` is currently supported only for the C backend.')
    }
    mut project_dir := v.pref.generate_c_project
    if !os.is_abs_path(project_dir) {
        project_dir = os.real_path(project_dir)
    }
    if os.exists(project_dir) && !os.is_dir(project_dir) {
        verror('`-generate-c-project` expects a directory path, got file: ${os.quoted_path(project_dir)}')
    }
    os.mkdir_all(project_dir) or {
        verror('Cannot create `-generate-c-project` directory ${os.quoted_path(project_dir)}: ${err}')
    }
    c_source_path := os.join_path(project_dir, v.c_project_source_name())
    os.mv_by_cp(v.out_name_c, c_source_path) or {
        verror('Cannot write generated C source to ${os.quoted_path(c_source_path)}: ${err}')
    }

    mut ccompiler := v.pref.ccompiler
    if v.pref.os == .wasm32 {
        ccompiler = 'clang'
    }
    v.setup_ccompiler_options(ccompiler)
    if v.pref.build_mode == .build_module {
        v.ccoptions.pre_args << '-c'
    }
    mut project_o_args := v.ccoptions.o_args.filter(!it.starts_with('-o '))
    project_o_args << [
        '-o ${v.tcc_quoted_path(os.join_path(project_dir, v.c_project_output_name()))}',
    ]
    v.ccoptions.o_args = project_o_args
    for idx, source_arg in v.ccoptions.source_args {
        if source_arg.contains(v.out_name_c) || source_arg.ends_with('.tmp.c')
            || source_arg.contains(".tmp.c'") || source_arg.contains('.tmp.c"') {
            v.ccoptions.source_args[idx] = v.tcc_quoted_path(c_source_path)
        }
    }

    mut all_args := v.all_args(v.ccoptions)
    replacements := v.c_project_dependency_replacements()
    for idx, arg in all_args {
        if replacement := replacements[arg] {
            all_args[idx] = replacement
        }
    }
    v.dump_c_options(all_args)
    cc_cmd := '${v.quote_compiler_name(ccompiler)} ${all_args.join(' ')}'
    os.write_file(os.join_path(project_dir, 'build_command.txt'), cc_cmd + '\n') or {
        verror('Cannot write ${os.quoted_path(os.join_path(project_dir, 'build_command.txt'))}: ${err}')
    }
    os.write_file(os.join_path(project_dir, 'Makefile'), 'all:\n\t${cc_cmd}\n') or {
        verror('Cannot write ${os.quoted_path(os.join_path(project_dir, 'Makefile'))}: ${err}')
    }
    os.write_file(os.join_path(project_dir, 'build.sh'), '#!/bin/sh\nset -eu\n${cc_cmd}\n') or {
        verror('Cannot write ${os.quoted_path(os.join_path(project_dir, 'build.sh'))}: ${err}')
    }
    os.write_file(os.join_path(project_dir, 'build.bat'), '@echo off\r\n${cc_cmd}\r\n') or {
        verror('Cannot write ${os.quoted_path(os.join_path(project_dir, 'build.bat'))}: ${err}')
    }
    $if !windows {
        os.chmod(os.join_path(project_dir, 'build.sh'), 0o755) or {}
    }
    println('Generated C project in ${os.quoted_path(project_dir)}')
}

pub fn (mut v Builder) cc() {
    if os.executable().contains('vfmt') {
        return
    }
    if v.pref.is_verbose {
        println('builder.cc() pref.out_name=${os.quoted_path(v.pref.out_name)}')
    }
    if v.pref.only_check_syntax {
        if v.pref.is_verbose {
            println('builder.cc returning early, since pref.only_check_syntax is true')
        }
        return
    }
    if v.pref.check_only {
        if v.pref.is_verbose {
            println('builder.cc returning early, since pref.check_only is true')
        }
        return
    }
    v.ensure_windows_icon_flag_is_valid()
    if v.pref.should_output_to_stdout() {
        // output to stdout
        content := os.read_file(v.out_name_c) or { panic(err) }
        println(content)
        os.rm(v.out_name_c) or {}
        return
    }
    if v.pref.generate_c_project != '' {
        v.pref.skip_running = true
        v.generate_c_project()
        return
    }
    // whether to just create a .c or .js file and exit, for example: `v -o v.c cmd.v`
    ends_with_c := v.pref.out_name.ends_with('.c')
    ends_with_js := v.pref.out_name.ends_with('.js')
    if ends_with_c || (ends_with_js && v.pref.os != .wasm32_emscripten) {
        v.pref.skip_running = true
        msg_mv := 'os.mv_by_cp ${os.quoted_path(v.out_name_c)} => ${os.quoted_path(v.pref.out_name)}'
        util.timing_start(msg_mv)
        // v.out_name_c may be on a different partition than v.out_name
        os.mv_by_cp(v.out_name_c, v.pref.out_name) or { panic(err) }
        util.timing_measure(msg_mv)
        return
    }
    v.ensure_imported_coroutines_runtime() or { verror(err.msg()) }
    // Cross compiling for Windows
    if v.pref.os == .windows && v.pref.ccompiler != 'msvc' {
        $if !windows {
            v.cc_windows_cross()
            return
        }
    }
    // Cross compiling for Linux
    if v.pref.os == .linux {
        $if !linux {
            v.cc_linux_cross()
            return
        }
    }
    // Cross compiling for FreeBSD
    if v.pref.os == .freebsd {
        $if !freebsd {
            v.cc_freebsd_cross()
            return
        }
    }

    vexe := pref.vexe_path()
    vdir := os.dir(vexe)
    mut tried_compilation_commands := []string{}
    mut tcc_output := os.Result{}
    original_pwd := os.getwd()
    for {
        // try to compile with the chosen compiler
        // if compilation fails, retry again with another
        mut ccompiler := v.pref.ccompiler
        if v.pref.os == .wasm32 {
            ccompiler = 'clang'
        }
        v.setup_ccompiler_options(ccompiler)
        v.build_thirdparty_obj_files()
        v.setup_output_name()

        if v.pref.os != .windows && ccompiler.contains('++') {
            cpp_atomic_h_path := '${@VEXEROOT}/thirdparty/stdatomic/nix/cpp/atomic.h'
            if !os.exists(cpp_atomic_h_path) {
                for file in v.parsed_files {
                    if file.imports.any(it.mod.contains('sync')) {
                        $if trace_stdatomic_gen ? {
                            eprintln('> creating ${cpp_atomic_h_path} ...')
                        }
                        cppgenv := '${@VEXEROOT}/thirdparty/stdatomic/nix/cpp/gen.v'
                        os.execute('${os.quoted_path(vexe)} run ${os.quoted_path(cppgenv)} ${os.quoted_path(ccompiler)}')
                        break
                    }
                }
            }
        }
        if v.pref.build_mode == .build_module {
            v.ccoptions.pre_args << '-c'
        }
        v.handle_usecache(vexe)
        $if windows {
            if v.ccoptions.cc == .msvc || v.pref.ccompiler_type == .msvc {
                v.cc_msvc()
                return
            }
        }
        //
        all_args := v.all_args(v.ccoptions)
        v.dump_c_options(all_args)
        mut rsp_args := all_args.map(v.rsp_safe_arg(it))
        rsp_args = rsp_args.map(v.tcc_windows_path_arg(it))
        shell_args := rsp_args.join(' ')
        mut should_use_rsp := v.should_use_rsp(rsp_args)
        mut str_args := if !should_use_rsp {
            shell_args.replace('\n', ' ')
        } else {
            shell_args
        }
        mut cmd := '${v.quote_compiler_name(ccompiler)} ${str_args}'
        if v.pref.parallel_cc {
            // In parallel cc mode, all we want in cc() is build the str_args.
            // Actual cc logic then happens in `parallel_cc()`
            v.str_args = str_args
            return
        }
        mut response_file := ''
        mut response_file_content := str_args
        if should_use_rsp {
            response_file = '${v.out_name_c}.rsp'
            response_file_content = str_args.replace('\\', '\\\\')
            write_response_file(response_file, response_file_content)
            rspexpr := '@${v.tcc_windows_path(response_file)}'
            cmd = '${v.quote_compiler_name(ccompiler)} ${os.quoted_path(rspexpr)}'
            if !v.ccoptions.debug_mode {
                v.pref.cleanup_files << response_file
            }
        }
        if !v.ccoptions.debug_mode {
            v.pref.cleanup_files << v.out_name_c
        }
        $if windows {
            if v.ccoptions.cc == .tcc {
                def_name := v.pref.out_name[0..v.pref.out_name.len - 4]
                v.pref.cleanup_files << '${def_name}.def'
            }
        }
        //
        os.chdir(vdir) or {}
        tried_compilation_commands << cmd
        v.show_cc(cmd, response_file, response_file_content)
        // Run
        ccompiler_label := 'C ${os.file_name(ccompiler):3}'
        util.timing_start(ccompiler_label)
        res := os.execute(cmd)
        util.timing_measure(ccompiler_label)
        if v.pref.show_c_output {
            v.show_c_compiler_output(ccompiler, res)
        }
        os.chdir(original_pwd) or {}
        vcache.dlog('| Builder.' + @FN,
            '>       v.pref.use_cache: ${v.pref.use_cache} | v.pref.retry_compilation: ${v.pref.retry_compilation}')
        vcache.dlog('| Builder.' + @FN, '>      cmd res.exit_code: ${res.exit_code} | cmd: ${cmd}')
        vcache.dlog('| Builder.' + @FN, '>  response_file_content:\n${response_file_content}')
        if res.exit_code != 0 {
            // Some GCC+linker setups fail bootstrapping with `-flto` and then report a missing `main` symbol.
            // Retry once without `-flto`, while still keeping the remaining -prod options.
            if v.pref.building_v && v.pref.is_prod && !v.pref.no_prod_options && !v.disable_flto
                && v.ccoptions.cc == .gcc && response_file_content.contains('-flto')
                && (res.output.contains('undefined symbol: main')
                || res.output.contains('undefined reference to `main')) {
                v.disable_flto = true
                if !v.pref.is_quiet {
                    eprintln('Retrying compiler build without `-flto` after a linker failure with missing `main`.')
                }
                continue
            }
            if is_tcc_compilation_failure(ccompiler, v.ccoptions.cc, res.output) {
                // A TCC problem? Retry with a non-tcc system compiler:
                if tried_compilation_commands.len > 1 {
                    eprintln('Recompilation loop detected (ccompiler: ${ccompiler}):')
                    for recompile_command in tried_compilation_commands {
                        eprintln('   ${recompile_command}')
                    }
                    exit(101)
                }
                if v.pref.retry_compilation {
                    tcc_output = res
                    old_ccompiler := v.pref.ccompiler
                    v.pref.default_c_compiler()
                    if v.pref.ccompiler == ccompiler || is_tcc_compiler_name(v.pref.ccompiler)
                        || is_tcc_alias_compiler(v.pref.ccompiler) {
                        v.pref.ccompiler = first_available_ccompiler([old_ccompiler, ccompiler,
                            v.pref.ccompiler])
                    }
                    if v.pref.ccompiler != '' && v.pref.ccompiler != ccompiler {
                        if v.pref.is_verbose {
                            eprintln('Compilation with tcc failed. Retrying with ${v.pref.ccompiler} ...')
                        } else {
                            $if macos {
                                eprintln(term.red('warning: tcc compilation failed, falling back to ${v.pref.ccompiler} (this is much slower)'))
                            }
                        }
                        continue
                    }
                }
            }
            if res.exit_code == 127 {
                verror('C compiler error, while attempting to run: \n' +
                    '-----------------------------------------------------------\n' + '${cmd}\n' +
                    '-----------------------------------------------------------\n' +
                    'Probably your C compiler is missing. \n' +
                    'Please reinstall it, or make it available in your PATH.\n\n' +
                    missing_compiler_info())
            }
        }
        if !v.pref.show_c_output {
            // if tcc failed once, and the system C compiler has failed as well,
            // print the tcc error instead since it may contain more useful information
            // see https://discord.com/channels/592103645835821068/592115457029308427/811956304314761228
            if res.exit_code != 0 && tcc_output.output != '' {
                v.post_process_c_compiler_output('tcc', tcc_output)
            } else {
                v.post_process_c_compiler_output(ccompiler, res)
            }
        }
        // Print the C command
        if v.pref.is_verbose {
            println('${ccompiler}')
            println('=========\n')
        }
        break
    }
    v.apply_windows_icon_to_executable() or { verror(err.msg()) }
    if v.pref.compress {
        ret := os.system('strip ${os.quoted_path(v.pref.out_name)}')
        if ret != 0 {
            println('strip failed')
            return
        }
        // Note: upx --lzma can sometimes fail with NotCompressibleException
        // See https://github.com/vlang/v/pull/3528
        mut ret2 := os.system('upx --lzma -qqq ${os.quoted_path(v.pref.out_name)}')
        if ret2 != 0 {
            ret2 = os.system('upx -qqq ${os.quoted_path(v.pref.out_name)}')
        }
        if ret2 != 0 {
            println('upx failed')
            $if macos {
                println('install upx with `brew install upx`')
            }
            $if linux {
                println('install upx\n' + 'for example, on Debian/Ubuntu run `sudo apt install upx`')
            }
            $if windows {
                println('install upx')
            }
        }
    }
    // if v.pref.os == .ios {
    // ret := os.system('ldid2 -S ${v.pref.out_name}')
    // if ret != 0 {
    // eprintln('failed to run ldid2, try: brew install ldid')
    // }
    // }
}

fn (mut b Builder) ensure_linuxroot_exists(sysroot string) {
    crossrepo_url := 'https://github.com/vlang/linuxroot'
    sysroot_git_config_path := os.join_path(sysroot, '.git', 'config')
    if os.is_dir(sysroot) && !os.exists(sysroot_git_config_path) {
        // remove existing obsolete unarchived .zip file content
        os.rmdir_all(sysroot) or {}
    }
    if !os.is_dir(sysroot) {
        println('Downloading files for Linux cross compilation (~77MB) ...')
        os.system('git clone "${crossrepo_url}" ${os.quoted_path(sysroot)}')
        if !os.exists(sysroot_git_config_path) {
            verror('Failed to clone `${crossrepo_url}` to `${sysroot}`')
        }
        os.chmod(os.join_path(sysroot, 'ld.lld'), 0o755) or { panic(err) }
    }
    repaired := repair_cross_sysroot_git_symlink_placeholders(sysroot) or {
        verror('Failed to repair `${sysroot}` symlink placeholders: ${err}')
        return
    }
    if repaired > 0 {
        println('Materialized ${repaired} Git symlink placeholder files in ${os.quoted_path(sysroot)}.')
    }
}

fn (mut b Builder) ensure_freebsdroot_exists(sysroot string) {
    crossrepo_url := 'https://github.com/spytheman/freebsd_base13.2'
    sysroot_git_config_path := os.join_path(sysroot, '.git', 'config')
    if os.is_dir(sysroot) && !os.exists(sysroot_git_config_path) {
        // remove existing obsolete unarchived .zip file content
        os.rmdir_all(sysroot) or {}
    }
    if !os.is_dir(sysroot) {
        println('Downloading files for FreeBSD cross compilation (~458MB) ...')
        os.system('git clone "${crossrepo_url}" ${os.quoted_path(sysroot)}')
        if !os.exists(sysroot_git_config_path) {
            verror('Failed to clone `${crossrepo_url}` to `${sysroot}`')
        }
    }
    repaired := repair_cross_sysroot_git_symlink_placeholders(sysroot) or {
        verror('Failed to repair `${sysroot}` symlink placeholders: ${err}')
        return
    }
    if repaired > 0 {
        println('Materialized ${repaired} Git symlink placeholder files in ${os.quoted_path(sysroot)}.')
    }
}

fn git_repo_tracked_symlink_paths(repo string) ![]string {
    git_cmd := 'git -C ${os.quoted_path(repo)} ls-files -s'
    res := os.execute(git_cmd)
    if res.exit_code != 0 {
        return error('`${git_cmd}` failed: ${res.output.trim_space()}')
    }
    mut paths := []string{}
    for line in res.output.split_into_lines() {
        if !line.starts_with('120000 ') || line.index_u8(`\t`) == -1 {
            continue
        }
        paths << line.all_after('\t')
    }
    return paths
}

fn normalize_git_symlink_target_path(path string, raw_target string) ?string {
    target := raw_target.trim_space()
    if target == '' || target.index_u8(`\n`) != -1 || target.index_u8(`\r`) != -1
        || target.index_u8(`\t`) != -1 {
        return none
    }
    resolved := if os.is_abs_path(target) {
        os.norm_path(target)
    } else {
        os.norm_path(os.join_path(os.dir(path), target))
    }
    if !os.exists(resolved) || os.is_dir(resolved) {
        return none
    }
    return resolved
}

fn git_symlink_target_path(path string) ?string {
    if os.is_link(path) {
        raw_target := os.readlink(path) or { return none }
        return normalize_git_symlink_target_path(path, raw_target)
    }
    if !os.is_file(path) || os.file_size(path) > max_cross_sysroot_git_symlink_placeholder_size {
        return none
    }
    raw_target := os.read_file(path) or { return none }
    if raw_target.index_u8(0) != -1 {
        return none
    }
    return normalize_git_symlink_target_path(path, raw_target)
}

fn git_symlink_materialization_source(path string) ?string {
    mut current := path
    mut seen := map[string]bool{}
    for _ in 0 .. max_cross_sysroot_git_symlink_depth {
        if current in seen {
            return none
        }
        seen[current] = true
        next := git_symlink_target_path(current) or {
            if current != path && os.is_file(current) {
                return current
            }
            return none
        }
        current = next
    }
    return none
}

fn materialize_git_symlink_placeholder(path string, source string) ! {
    tmp_path := '${path}.v_symlink_fix_tmp'
    os.rm(tmp_path) or {}
    os.cp(source, tmp_path)!
    os.rm(path)!
    os.mv(tmp_path, path)!
}

fn repair_cross_sysroot_git_symlink_placeholders_in_paths(paths []string, strict bool) !int {
    mut repaired := 0
    for path in paths {
        if os.is_link(path) || !os.is_file(path) {
            continue
        }
        source := git_symlink_materialization_source(path) or {
            if strict {
                return error('`${path}` is tracked as a symlink in the cross-compilation sysroot, but its target could not be resolved')
            }
            continue
        }
        if source == path {
            continue
        }
        materialize_git_symlink_placeholder(path, source)!
        repaired++
    }
    return repaired
}

// Git on Windows can check symlinks out as tiny text files instead of real links.
fn repair_cross_sysroot_git_symlink_placeholders(sysroot string) !int {
    if !os.is_dir(sysroot) {
        return 0
    }
    if tracked_paths := git_repo_tracked_symlink_paths(sysroot) {
        mut candidates := []string{cap: tracked_paths.len}
        for rel_path in tracked_paths {
            candidates << os.join_path(sysroot, rel_path)
        }
        return repair_cross_sysroot_git_symlink_placeholders_in_paths(candidates, true)
    } else {
        mut fallback_candidates := []string{}
        for path in os.walk_ext(sysroot, '', hidden: false) {
            if !os.is_file(path) || os.is_link(path) {
                continue
            }
            if os.file_size(path) > max_cross_sysroot_git_symlink_placeholder_size {
                continue
            }
            fallback_candidates << path
        }
        return repair_cross_sysroot_git_symlink_placeholders_in_paths(fallback_candidates, false)
    }
}

fn (mut b Builder) get_subsystem_flag() string {
    if b.pref.is_shared || b.pref.build_mode == .build_module || b.pref.is_o {
        return ''
    }
    return match b.pref.subsystem {
        .auto { '-municode' }
        .console { '-municode -mconsole' }
        .windows { '-municode -mwindows' }
    }
}

struct LinuxCrossTarget {
    triple           string
    lib_dir          string
    dynamic_linker   string
    linker_emulation string
}

fn linux_cross_target_for_arch(arch pref.Arch) !LinuxCrossTarget {
    if arch != .amd64 {
        return error('Linux cross compilation currently supports only `-arch amd64`; the bundled linuxroot sysroot does not provide `${arch}` runtime files.')
    }
    return LinuxCrossTarget{
        triple:           'x86_64-linux-gnu'
        lib_dir:          'x86_64-linux-gnu'
        dynamic_linker:   '/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2'
        linker_emulation: 'elf_x86_64'
    }
}

fn (mut b Builder) cc_linux_cross() {
    linux_cross_target := linux_cross_target_for_arch(b.pref.arch) or {
        verror(err.msg())
        return
    }
    b.setup_ccompiler_options(b.pref.ccompiler)
    b.build_thirdparty_obj_files()
    b.setup_output_name()
    parent_dir := os.vmodules_dir()
    if !os.exists(parent_dir) {
        os.mkdir(parent_dir) or { panic(err) }
    }
    sysroot := os.join_path(os.vmodules_dir(), 'linuxroot')
    b.ensure_linuxroot_exists(sysroot)
    obj_file := if b.pref.build_mode == .build_module {
        b.pref.out_name
    } else {
        b.out_name_c + '.o'
    }
    cflags := b.get_os_cflags()
    defines, others, libs := cflags.defines_others_libs()
    // Some modules pass a raw `#flag /path/to/file.c` to add an additional
    // source file to the compile step (e.g. gitly's markdown module uses this
    // for md4c-lib.c). The native build line just appends them to the main
    // `clang ... main.c` invocation, but the cross-compile path uses
    // `clang -c <main.c> -o <main.o>`, and clang refuses to combine `-c` with
    // multiple inputs ("cannot specify -o when generating multiple output
    // files"). Pull those out, compile each separately into its own .o, and
    // hand the resulting objects to the linker step.
    mut other_flags := []string{cap: others.len}
    mut extra_sources := []string{}
    for opt in others {
        unq := opt.trim('"').trim("'")
        ext := os.file_ext(unq).to_lower()
        if ext in ['.c', '.cpp', '.cc', '.cxx', '.s'] && os.is_file(unq) {
            extra_sources << unq
        } else {
            other_flags << opt
        }
    }
    mut cc_name := b.pref.ccompiler
    mut out_name := b.pref.out_name
    $if windows {
        out_name = out_name.trim_string_right('.exe')
    }
    mut extra_objs := []string{cap: extra_sources.len}
    for src in extra_sources {
        src_obj := os.join_path(os.vtmp_dir(), os.file_name(src) + '.' +
            linux_cross_target.lib_dir + '.o')
        mut src_args := []string{cap: 16}
        src_args << '-w'
        src_args << '-fPIC'
        src_args << '-target ${linux_cross_target.triple}'
        src_args << defines
        src_args << '-I ${os.quoted_path('${sysroot}/include')}'
        src_args << other_flags
        src_args << '-o ${os.quoted_path(src_obj)}'
        src_args << '-c ${os.quoted_path(src)}'
        src_cmd := '${b.quote_compiler_name(cc_name)} ' + src_args.join(' ')
        if b.pref.show_cc {
            println(src_cmd)
        }
        src_res := os.execute(src_cmd)
        if src_res.exit_code != 0 {
            println('Cross compilation for Linux failed (extra source ${src}).')
            verror(src_res.output)
            return
        }
        extra_objs << src_obj
    }
    mut cc_args := []string{cap: 20}
    cc_args << '-w'
    cc_args << '-fPIC'
    cc_args << '-target ${linux_cross_target.triple}'
    cc_args << defines
    cc_args << '-I ${os.quoted_path('${sysroot}/include')} '
    cc_args << other_flags
    cc_args << '-o ${os.quoted_path(obj_file)}'
    cc_args << '-c ${os.quoted_path(b.out_name_c)}'
    cc_args << libs
    b.dump_c_options(cc_args)
    cc_cmd := '${b.quote_compiler_name(cc_name)} ' + cc_args.join(' ')
    if b.pref.show_cc {
        println(cc_cmd)
    }
    cc_res := os.execute(cc_cmd)
    if cc_res.exit_code != 0 {
        println('Cross compilation for Linux failed (first step, cc). Make sure you have clang installed.')
        verror(cc_res.output)
        return
    }
    if b.pref.build_mode == .build_module {
        return
    }
    // Compile compiler runtime builtins (provides __udivti3 etc. for 128-bit integer
    // operations used by thirdparty code like mbedtls bignum.c, since the linuxroot
    // sysroot doesn't include libgcc or compiler-rt).
    builtins_src := os.join_path(@VEXEROOT, 'thirdparty', 'builtins', 'compiler_builtins.c')
    builtins_obj := os.join_path(os.vtmp_dir(), 'compiler_builtins_${linux_cross_target.lib_dir}.o')
    if os.exists(builtins_src) {
        builtins_cmd := '${b.quote_compiler_name(cc_name)} -w -fPIC -target ${linux_cross_target.triple} -o ${os.quoted_path(builtins_obj)} -c ${os.quoted_path(builtins_src)}'
        builtins_res := os.execute(builtins_cmd)
        if builtins_res.exit_code != 0 {
            println('Warning: failed to compile compiler builtins for cross compilation.')
        }
    }
    mut linker_args := [
        '-L',
        os.quoted_path(os.join_path(sysroot, 'usr', 'lib', linux_cross_target.lib_dir)),
        '-L',
        os.quoted_path(os.join_path(sysroot, 'lib', linux_cross_target.lib_dir)),
        '--sysroot=' + os.quoted_path(sysroot),
        '-v',
        '-o',
        os.quoted_path(out_name),
        '-m ${linux_cross_target.linker_emulation}',
        '-dynamic-linker',
        os.quoted_path(linux_cross_target.dynamic_linker),
        os.quoted_path('${sysroot}/crt1.o'),
        os.quoted_path('${sysroot}/crti.o'),
        os.quoted_path(obj_file),
    ]
    for eobj in extra_objs {
        linker_args << os.quoted_path(eobj)
    }
    // User-defined libraries (e.g. `-lpq` from db.pg) and extra object files
    // must come before the system libraries they depend on. ld.lld resolves
    // references left-to-right, so libpq.a needs to be encountered before
    // -lssl/-lcrypto, otherwise its references to SSL_*/EVP_* stay unresolved.
    linker_args << cflags.c_options_only_object_files()
    linker_args << [
        '-lc',
        '-lcrypto',
        '-lssl',
        '-lpthread',
        os.quoted_path('${sysroot}/crtn.o'),
        '-lm',
        '-ldl',
    ]
    if os.exists(builtins_obj) {
        linker_args << os.quoted_path(builtins_obj)
    }
    // -ldl
    b.dump_c_options(linker_args)
    mut ldlld := '${sysroot}/ld.lld'
    $if windows {
        ldlld = 'ld.lld.exe'
    }
    linker_cmd := '${b.quote_compiler_name(ldlld)} ' + linker_args.join(' ')
    if b.pref.show_cc {
        println(linker_cmd)
    }
    res := os.execute(linker_cmd)
    if res.exit_code != 0 {
        println('Cross compilation for Linux failed (second step, lld).')
        verror(res.output)
        return
    }
    println(out_name + ' has been successfully cross compiled for linux.')
}

fn (mut b Builder) cc_freebsd_cross() {
    b.setup_ccompiler_options(b.pref.ccompiler)
    b.build_thirdparty_obj_files()
    b.setup_output_name()
    parent_dir := os.vmodules_dir()
    if !os.exists(parent_dir) {
        os.mkdir(parent_dir) or { panic(err) }
    }
    sysroot := os.join_path(os.vmodules_dir(), 'freebsdroot')
    b.ensure_freebsdroot_exists(sysroot)
    obj_file := b.out_name_c + '.o'
    cflags := b.get_os_cflags()
    defines, others, libs := cflags.defines_others_libs()
    mut cc_args := []string{cap: 20}
    cc_args << '-w'
    cc_args << '-fPIC'
    cc_args << '-target x86_64-unknown-freebsd14.0' // TODO custom freebsd versions
    cc_args << defines
    cc_args << '-I'
    cc_args << os.quoted_path('${sysroot}/include')
    cc_args << '-I'
    cc_args << os.quoted_path('${sysroot}/usr/include')
    cc_args << others
    cc_args << '-o'
    cc_args << os.quoted_path(obj_file)
    cc_args << '-c'
    cc_args << os.quoted_path(b.out_name_c)
    cc_args << libs
    b.dump_c_options(cc_args)
    mut cc_name := b.pref.ccompiler
    mut out_name := b.pref.out_name
    $if windows {
        out_name = out_name.trim_string_right('.exe')
    }
    cc_cmd := '${b.quote_compiler_name(cc_name)} ' + cc_args.join(' ')
    if b.pref.show_cc {
        println(cc_cmd)
    }
    cc_res := os.execute(cc_cmd)
    if cc_res.exit_code != 0 {
        println('Cross compilation for FreeBSD failed (first step, cc). Make sure you have clang installed.')
        verror(cc_res.output)
        return
    }
    mut linker_args := [
        '-L',
        os.quoted_path('${sysroot}/lib/'),
        '-L',
        os.quoted_path('${sysroot}/usr/lib/'),
        '--sysroot=' + os.quoted_path(sysroot),
        '-v',
        '-o',
        os.quoted_path(out_name),
        '-m elf_x86_64',
        '-dynamic-linker /libexec/ld-elf.so.1',
        os.quoted_path('${sysroot}/usr/lib/crt1.o'),
        os.quoted_path('${sysroot}/usr/lib/crti.o'),
        os.quoted_path(obj_file),
        os.quoted_path('${sysroot}/usr/lib/crtn.o'),
    ]
    linker_args << '-lc' // needed for fwrite, strlen etc
    linker_args << '-lexecinfo' // needed for backtrace
    linker_args << cflags.c_options_only_object_files() // support custom module defined linker flags
    linker_args << libs
    // -ldl
    b.dump_c_options(linker_args)
    // mut ldlld := '${sysroot}/ld.lld'
    mut ldlld := b.pref.vcross_linker_name()
    linker_cmd := '${b.quote_compiler_name(ldlld)} ' + linker_args.join(' ')
    if b.pref.show_cc {
        println(linker_cmd)
    }
    res := os.execute(linker_cmd)
    if res.exit_code != 0 {
        println('Cross compilation for FreeBSD failed (second step, lld).')
        verror(res.output)
        return
    }
    println(out_name + ' has been successfully cross compiled for FreeBSD.')
}

fn (mut c Builder) cc_windows_cross() {
    println('Cross compiling for Windows...')
    cross_compiler_name := c.pref.ccompiler
    cross_compiler_name_path := if cross_compiler_name.contains('/')
        || cross_compiler_name.contains('\\') {
        cross_compiler_name
    } else {
        os.find_abs_path_of_executable(cross_compiler_name) or {
            eprintln('Could not find `${cross_compiler_name}` in your PATH.')
            eprintln('Set `-cc` or `VCROSS_COMPILER_NAME` to a working cross compiler.')
            eprintln('See https://github.com/vlang/v/blob/master/doc/docs.md#cross-compilation for instructions on how to fix that.')
            exit(1)
        }
    }

    c.setup_ccompiler_options(c.pref.ccompiler)
    c.build_thirdparty_obj_files()
    c.setup_output_name()
    icon_object := c.prepare_cross_windows_icon_resource() or { verror(err.msg()) }

    if current_os !in ['macos', 'linux', 'termux'] {
        println(current_os)
        panic('your platform is not supported yet')
    }

    all_args := c.windows_cross_compile_args(icon_object)
    c.dump_c_options(all_args)
    mut cmd := '${c.quote_compiler_name(cross_compiler_name_path)} ${all_args.join(' ')}'
    // cmd := 'clang -o ${obj_name} -w ${include} -m32 -c -target x86_64-win32 ${pref.default_module_path}/${c.out_name_c}'
    if c.pref.is_verbose || c.pref.show_cc {
        println(cmd)
    }
    if os.system(cmd) != 0 {
        println('Cross compilation for Windows failed. Make sure you have mingw-w64 installed.')
        $if macos {
            println('brew install mingw-w64')
        }
        $if linux {
            println('Try `sudo apt install -y mingw-w64` on Debian based distros, or `sudo pacman -S mingw-w64-gcc` on Arch, etc...')
        }
        exit(1)
    }
    println(c.pref.out_name + ' has been successfully cross compiled for windows.')
}

fn (c &Builder) windows_cross_compile_args(icon_object string) []string {
    mut ccoptions := c.ccoptions
    if icon_object != '' {
        mut o_args := ccoptions.o_args.clone()
        o_args << os.quoted_path(icon_object)
        ccoptions.o_args = o_args
    }
    return c.all_args(ccoptions)
}

fn (mut b Builder) build_thirdparty_obj_files() {
    b.log('build_thirdparty_obj_files: v.ast.cflags: ${b.table.cflags}')
    for flag in b.get_os_cflags() {
        if flag.value.ends_with('.o') || flag.value.ends_with('.obj') {
            rest_of_module_flags := b.get_rest_of_module_cflags(flag)
            $if windows {
                if b.pref.ccompiler == 'msvc' {
                    b.build_thirdparty_obj_file_with_msvc(flag.mod, flag.value,
                        rest_of_module_flags)
                    continue
                }
            }
            b.build_thirdparty_obj_file(flag.mod, flag.value, rest_of_module_flags)
        }
    }
}

enum SourceKind {
    c
    cpp
    asm
    unknown
}

fn c_project_source_from_object_path(obj_path string) ?string {
    if !obj_path.ends_with('.o') && !obj_path.ends_with('.obj') {
        return none
    }
    base := obj_path.all_before_last('.')
    for ext in ['.c', '.cpp', '.S'] {
        source_file := base + ext
        if os.exists(source_file) {
            return source_file
        }
    }
    return none
}

fn sqlite_thirdparty_validation_error(mod string, obj_path string, source_file string, source_kind SourceKind) string {
    if mod != 'db.sqlite' || os.file_name(obj_path) != 'sqlite3.o'
        || os.base(os.dir(obj_path)) != 'sqlite'
        || os.base(os.dir(os.dir(obj_path))) != 'thirdparty' {
        return ''
    }
    sqlite_dir := os.dir(obj_path)
    if source_kind == .cpp && os.file_name(source_file) == 'sqlite3.cpp' {
        return 'The `db.sqlite` module expects the SQLite amalgamation files `sqlite3.c` and `sqlite3.h` in `${sqlite_dir}`. Do not rename `sqlite3.c` to `sqlite3.cpp`; run `v vlib/db/sqlite/install_thirdparty_sqlite.vsh`, or download the SQLite amalgamation package and place those files there.'
    }
    if source_kind == .unknown {
        return 'The `db.sqlite` module expects the SQLite amalgamation files `sqlite3.c` and `sqlite3.h` in `${sqlite_dir}`. Run `v vlib/db/sqlite/install_thirdparty_sqlite.vsh`, or download the SQLite amalgamation package and place those files there.'
    }
    return ''
}

// fixup_tcc_macos_comma_path_flags works around the fact that both tcc and
// clang split `-Wl,foo,bar` on every comma without an escape mechanism. When
// V's install path contains a literal comma (used in CI to stress
// space-paths), the `-Wl,-rpath,"@VEXEROOT/thirdparty/tcc/lib"` flag emitted
// by builtin_d_gcboehm.c.v under `$if tinyc` expands into a path with a comma
// and the linker rejects it. The bundled libgc.dylib also gets passed by
// absolute path; that itself is fine, but the dylib's `LC_ID_DYLIB` is
// `@rpath/libgc.dylib`, so the linked binary cannot find the library at
// runtime once we strip the rpath flag.
//
// This helper copies the bundled dylib into a non-comma cache directory,
// updates the copy's install_name to its own absolute path (so the linked
// binary records that path in `LC_LOAD_DYLIB`), then rewrites the dylib flag
// in the linker arguments to point at the copy and drops the now-broken rpath
// flag. The bundled libgc.dylib itself is left untouched, so binaries built
// before/elsewhere that rely on `@rpath/libgc.dylib` still work. The fixup is
// applied for any cc, since V may fall back from tcc to clang and reuse the
// already-emitted flags.
fn (v &Builder) fixup_tcc_macos_comma_path_flags(mut ccoptions CcompilerOptions) {
    $if !macos {
        return
    }
    if v.pref.os != .macos {
        return
    }
    tcc_lib_dir := os.real_path(os.join_path(v.pref.vroot, 'thirdparty', 'tcc', 'lib'))
    if !tcc_lib_dir.contains(',') {
        return
    }
    src_dylib := os.join_path(tcc_lib_dir, 'libgc.dylib')
    if !os.exists(src_dylib) {
        return
    }
    cache_dir := os.join_path(os.temp_dir(), 'v_tcc_libgc')
    if cache_dir.contains(',') {
        return
    }
    if !os.exists(cache_dir) {
        os.mkdir_all(cache_dir) or { return }
    }
    cache_dylib := os.join_path(cache_dir, 'libgc.dylib')
    src_mtime := os.file_last_mod_unix(src_dylib)
    if !os.exists(cache_dylib) || os.file_last_mod_unix(cache_dylib) < src_mtime {
        os.cp(src_dylib, cache_dylib) or { return }
        idres :=
            os.execute('install_name_tool -id ${os.quoted_path(cache_dylib)} ${os.quoted_path(cache_dylib)}')
        if idres.exit_code != 0 {
            if v.pref.is_verbose {
                eprintln('install_name_tool -id for ${cache_dylib} failed: ${idres.output.trim_space()}')
            }
            return
        }
    }
    cache_dylib_quoted := '"${cache_dylib}"'
    suffix := os.path_separator + 'tcc' + os.path_separator + 'lib' + os.path_separator +
        'libgc.dylib'
    ccoptions.linker_flags = ccoptions.linker_flags.map(if it.ends_with(suffix + '"')
        && it.starts_with('"') {
        cache_dylib_quoted
    } else {
        it
    })
    ccoptions.pre_args = ccoptions.pre_args.filter(!it.starts_with('-Wl,-rpath,'))
}

fn (v &Builder) should_compile_bundled_thirdparty_object_from_source(obj_path string, source_file string, source_kind SourceKind) bool {
    if source_kind == .unknown {
        return false
    }
    if os.exists(obj_path) && os.file_last_mod_unix(obj_path) < os.file_last_mod_unix(source_file) {
        return true
    }
    return v.ccoptions.cc == .tcc && v.pref.os == .macos
}

fn (mut v Builder) build_thirdparty_obj_file(mod string, path string, moduleflags []cflag.CFlag) {
    trace_thirdparty_obj_files := 'trace_thirdparty_obj_files' in v.pref.compile_defines
    obj_path := os.real_path(path)
    opath := v.pref.cache_manager.mod_postfix_with_key2cpath(mod, '.o', obj_path)
    thirdparty_desc_path := v.pref.cache_manager.mod_postfix_with_key2cpath(mod,
        '.thirdparty.description.txt', obj_path)
    mut source_file := c_project_source_from_object_path(obj_path) or { '' }
    source_kind := if source_file.ends_with('.c') {
        SourceKind.c
    } else if source_file.ends_with('.cpp') {
        SourceKind.cpp
    } else if source_file.ends_with('.S') {
        SourceKind.asm
    } else {
        SourceKind.unknown
    }
    sqlite_validation_message := sqlite_thirdparty_validation_error(mod, obj_path, source_file,
        source_kind)
    if sqlite_validation_message != '' {
        verror(sqlite_validation_message)
    }
    compile_bundled_source := v.should_compile_bundled_thirdparty_object_from_source(obj_path,
        source_file, source_kind)
    if os.exists(obj_path) && !compile_bundled_source {
        // Some .o files are distributed with no source
        // for example thirdparty\tcc\lib\openlibm.o
        // the best we can do for them is just copy them,
        // and hope that they work with any compiler...
        os.cp(obj_path, opath) or { panic(err) }
        return
    }
    if source_kind == .unknown {
        base := obj_path.all_before_last('.')
        eprintln('> File not found: ${base}{.c,.cpp,.S}')
        verror('build_thirdparty_obj_file only support .c, .cpp, and .S source file.')
    }
    bundled_object_is_stale := os.exists(obj_path)
        && os.file_last_mod_unix(obj_path) < os.file_last_mod_unix(source_file)
    cached_object_was_built_from_source := os.exists(thirdparty_desc_path)
    mut rebuild_reason_message := if bundled_object_is_stale {
        '${os.quoted_path(obj_path)} is older than ${os.quoted_path(source_file)}, rebuilding it in ${os.quoted_path(opath)} ...'
    } else if compile_bundled_source {
        '${os.quoted_path(obj_path)} is bundled for a different object format; rebuilding it in ${os.quoted_path(opath)} from ${os.quoted_path(source_file)} ...'
    } else {
        '${os.quoted_path(obj_path)} not found, building it in ${os.quoted_path(opath)} ...'
    }
    if os.exists(opath) {
        if compile_bundled_source && !cached_object_was_built_from_source {
            rebuild_reason_message = '${os.quoted_path(opath)} was copied from a bundled object, rebuilding it from ${os.quoted_path(source_file)} ...'
        } else if os.file_last_mod_unix(opath) < os.file_last_mod_unix(source_file) {
            rebuild_reason_message = '${os.quoted_path(opath)} is older than ${os.quoted_path(source_file)}, rebuilding ...'
        } else {
            return
        }
    }
    if v.pref.is_verbose {
        println(rebuild_reason_message)
    }
    // prepare for tcc, it needs relative paths to thirdparty/tcc to work:
    current_folder := os.getwd()
    os.chdir(v.pref.vroot) or {}

    cc_options := if source_kind == .asm {
        '-o ${v.tcc_quoted_path(opath)} -c ${v.tcc_quoted_path(source_file)}'
    } else {
        mut all_options := []string{cap: 4}
        all_options << v.pref.third_party_option
        all_options << moduleflags.c_options_before_target()
        all_options << '-o ${v.tcc_quoted_path(opath)}'
        all_options << '-c ${v.tcc_quoted_path(source_file)}'
        cpp_file := source_kind == .cpp
        v.thirdparty_object_args(v.ccoptions, all_options, cpp_file).map(v.tcc_windows_path_arg(it)).join(' ')
    }

    // If the third party object file requires a CPP file compilation, switch to a CPP compiler
    mut ccompiler := v.pref.ccompiler
    if source_kind == .cpp {
        if trace_thirdparty_obj_files {
            println('>>> build_thirdparty_obj_files switched from compiler "${ccompiler}" to "${v.pref.cppcompiler}"')
        }
        ccompiler = v.pref.cppcompiler
    }
    cmd := '${v.quote_compiler_name(ccompiler)} ${cc_options}'
    if trace_thirdparty_obj_files {
        println('>>> build_thirdparty_obj_files cmd: ${cmd}')
    }
    res := os.execute(cmd)
    os.chdir(current_folder) or {}
    if res.exit_code != 0 {
        eprintln('> Failed build_thirdparty_obj_file cmd')
        eprintln('>           mod: ${mod}')
        eprintln('>          path: ${path}')
        eprintln('>   source_file: ${source_file}')
        eprintln('> wd before cmd: ${current_folder}')
        eprintln('> getwd for cmd: ${v.pref.vroot}')
        eprintln('>           cmd: ${cmd}')
        verror(res.output)
        return
    }
    v.pref.cache_manager.mod_save(mod, '.thirdparty.description.txt', obj_path,
        get_dsc_content('OBJ_PATH: ${obj_path}\nCMD: ${cmd}\n')) or { panic(err) }
    if v.pref.show_cc {
        println('>> OBJECT FILE compilation cmd: ${cmd}')
    }
    if trace_thirdparty_obj_files {
        if res.output != '' {
            println(res.output)
        }
        println('>>> build_thirdparty_obj_files done')
    }
}

fn missing_compiler_info() string {
    $if windows {
        return 'https://github.com/vlang/v/wiki/Installing-a-C-compiler-on-Windows'
    }
    $if linux {
        return 'On Debian/Ubuntu, run `sudo apt install build-essential`'
    }
    $if macos {
        return 'Install command line XCode tools with `xcode-select --install`'
    }
    return 'Install a C compiler, like gcc or clang'
}

fn is_tcc_compilation_failure(ccompiler string, cc_kind CC, output string) bool {
    return cc_kind == .tcc || is_tcc_compiler_name(ccompiler) || is_tcc_alias_compiler(ccompiler)
        || is_tcc_error_output(output)
}

fn is_tinyc_compiler_label(label string) bool {
    return label.contains('tcc') || label.contains('tinyc') || label.contains('tinygcc')
        || label.contains('tiny_gcc') || label.contains('tiny-gcc')
}

fn is_tinyc_version_output(output string) bool {
    return output.contains('tiny c compiler') || output.contains('tinycc')
        || output.contains('tinygcc') || output.contains('tiny_gcc') || output.contains('tiny-gcc')
        || output.contains('\ntcc') || output.starts_with('tcc')
}

fn is_tcc_compiler_name(ccompiler string) bool {
    name := os.file_name(ccompiler).to_lower()
    return is_tinyc_compiler_label(name)
}

fn is_tcc_error_output(output string) bool {
    trimmed_output := output.trim_space()
    return trimmed_output.starts_with('tcc: error:') || trimmed_output.contains('\ntcc: error:')
}

fn is_tcc_alias_compiler(ccompiler string) bool {
    if ccompiler != 'cc' {
        return false
    }
    cc_version := os.execute('cc --version')
    if cc_version.exit_code != 0 {
        return false
    }
    lcc_version := cc_version.output.to_lower()
    return is_tinyc_version_output(lcc_version)
}

fn ccompiler_is_available(ccompiler string) bool {
    if ccompiler.contains('/') || ccompiler.contains('\\') {
        return os.is_file(ccompiler) && os.is_executable(ccompiler)
    }
    os.find_abs_path_of_executable(ccompiler) or { return false }
    return true
}

fn first_available_ccompiler(excluded []string) string {
    for candidate in ['cc', 'clang', 'gcc'] {
        if candidate in excluded {
            continue
        }
        if os.find_abs_path_of_executable(candidate) or { '' } != '' {
            return candidate
        }
    }
    return ''
}

fn highlight_word(keyword string) string {
    return if term.can_show_color_on_stdout() { term.red(keyword) } else { keyword }
}

fn error_context_lines(text string, keyword string, before int, after int) []string {
    khighlight := highlight_word(keyword)
    mut eline_idx := -1
    mut lines := text.split_into_lines()
    for idx, eline in lines {
        if eline.contains(keyword) {
            lines[idx] = lines[idx].replace(keyword, khighlight)
            if eline_idx == -1 {
                eline_idx = idx
            }
        }
    }
    idx_s := if eline_idx - before >= 0 { eline_idx - before } else { 0 }
    idx_e := if idx_s + after < lines.len { idx_s + after } else { lines.len }
    return lines[idx_s..idx_e]
}

pub fn (mut v Builder) quote_compiler_name(name string) string {
    $if windows {
        // some compiler frontends on windows, like emcc, are a .bat file on windows.
        // Quoting the .bat file name here leads to problems with them, when they internally call python scripts for some reason.
        // Just emcc without quotes here does work, but:
        // |"emcc" -v| produces: python.exe: can't open file 'D:\programs\v\emcc.py': [Errno 2] No such file or directory
        if name.contains('/') || name.contains('\\') {
            return os.quoted_path(name)
        }
        return name
    }
    return os.quoted_path(name)
}

fn write_response_file(response_file string, response_file_content string) {
    $if windows {
        os.write_file_array(response_file,
            string_to_ansi_not_null_terminated(response_file_content)) or {
            write_response_file_error(response_file_content, err)
        }
    } $else {
        os.write_file(response_file, response_file_content) or {
            write_response_file_error(response_file_content, err)
        }
    }
}

fn write_response_file_error(response_file string, err IError) {
    verror('Unable to write to C response file "${response_file}", error: ${err}')
}

fn get_dsc_content(suffix string) string {
    vargs := os.args.join(' ')
    vjobs := os.getenv('VJOBS')
    vflags := os.getenv('VFLAGS')
    return 'CLI: ${vargs}\nVFLAGS="${vflags}"\nVJOBS=${vjobs}\n${suffix}'
}