appendModuleFlags

fn appendModuleFlags(
    arena: Allocator,
    module_index: Configuration.Module.Index,
    zig_args: *std.ArrayList([]const u8),
    asking_step: Configuration.Step.Index,
    maker: *const Maker,
) !void

File

Code

fn appendModuleFlags(
    arena: Allocator,
    module_index: Configuration.Module.Index,
    zig_args: *std.ArrayList([]const u8),
    asking_step: Configuration.Step.Index,
    maker: *const Maker,
) !void {
    const gpa = maker.gpa;
    const conf = &maker.scanned_config.configuration;
    const m = module_index.get(conf);

    try addFlag(gpa, zig_args, "strip", m.flags.strip.toBool());
    try addFlag(gpa, zig_args, "single-threaded", m.flags.single_threaded.toBool());
    try addFlag(gpa, zig_args, "stack-check", m.flags.stack_check.toBool());
    try addFlag(gpa, zig_args, "stack-protector", m.flags.stack_protector.toBool());
    try addFlag(gpa, zig_args, "omit-frame-pointer", m.flags2.omit_frame_pointer.toBool());
    try addFlag(gpa, zig_args, "error-tracing", m.flags2.error_tracing.toBool());
    try addFlag(gpa, zig_args, "sanitize-thread", m.flags.sanitize_thread.toBool());
    try addFlag(gpa, zig_args, "fuzz", m.flags.fuzz.toBool());
    try addFlag(gpa, zig_args, "valgrind", m.flags2.valgrind.toBool());
    try addFlag(gpa, zig_args, "PIC", m.flags2.pic.toBool());
    try addFlag(gpa, zig_args, "no-builtin", m.flags2.no_builtin.toBool());

    try addArchFlag(gpa, zig_args, "red-zone", m.flags2.red_zone.toBool());
    {
        try zig_args.ensureUnusedCapacity(gpa, 6);

        switch (m.flags.sanitize_c) {
            .off => zig_args.appendAssumeCapacity("-fno-sanitize-c"),
            .trap => zig_args.appendAssumeCapacity("-fsanitize-c=trap"),
            .full => zig_args.appendAssumeCapacity("-fsanitize-c=full"),
            .default => {},
        }

        switch (m.flags.dwarf_format) {
            .@"32" => zig_args.appendAssumeCapacity("-gdwarf32"),
            .@"64" => zig_args.appendAssumeCapacity("-gdwarf64"),
            .default => {},
        }

        switch (m.flags.unwind_tables) {
            .none => zig_args.appendAssumeCapacity("-fno-unwind-tables"),
            .sync => zig_args.appendAssumeCapacity("-funwind-tables"),
            .async => zig_args.appendAssumeCapacity("-fasync-unwind-tables"),
            .default => {},
        }

        switch (m.flags.optimize) {
            .debug => zig_args.appendAssumeCapacity("-ODebug"),
            .safe => zig_args.appendAssumeCapacity("-OReleaseSafe"),
            .fast => zig_args.appendAssumeCapacity("-OReleaseFast"),
            .small => zig_args.appendAssumeCapacity("-OReleaseSmall"),
            .default => {},
        }

        if (m.flags.code_model != .default) {
            zig_args.appendAssumeCapacity("-mcmodel");
            zig_args.appendAssumeCapacity(@tagName(m.flags.code_model));
        }
    }

    if (m.resolved_target.get(conf)) |resolved_target| {
        // Communicate the query via CLI since it's more compact.
        if (resolved_target.unwrapQuery(conf)) |query| {
            try zig_args.ensureUnusedCapacity(gpa, 6);

            zig_args.appendAssumeCapacity("-target");
            zig_args.appendAssumeCapacity(try query.zigTriple(arena));

            zig_args.appendAssumeCapacity("-mcpu");
            zig_args.appendAssumeCapacity(try query.serializeCpuAlloc(arena));

            if (query.dynamic_linker) |*dynamic_linker| {
                if (dynamic_linker.get()) |dynamic_linker_path| {
                    zig_args.appendAssumeCapacity("--dynamic-linker");
                    zig_args.appendAssumeCapacity(dynamic_linker_path);
                } else {
                    zig_args.appendAssumeCapacity("--no-dynamic-linker");
                }
            }
        }
    }

    for (m.export_symbol_names.slice) |symbol_name| {
        try zig_args.append(gpa, try arena.print("--export={s}", .{symbol_name.slice(conf)}));
    }

    try zig_args.ensureUnusedCapacity(gpa, 2 * m.include_dirs.len);
    for (0..m.include_dirs.len) |i|
        try appendIncludeDirFlags(arena, m.include_dirs.get(conf.extra, i), zig_args, asking_step, maker);

    try zig_args.ensureUnusedCapacity(gpa, m.c_macros.slice.len);
    for (m.c_macros.slice) |c_macro|
        zig_args.appendAssumeCapacity(c_macro.slice(conf));

    try zig_args.ensureUnusedCapacity(gpa, 2 * m.lib_paths.slice.len);
    for (m.lib_paths.slice) |lib_path| {
        zig_args.appendAssumeCapacity("-L");
        zig_args.appendAssumeCapacity(try maker.resolveLazyPathIndexAbs(arena, lib_path, asking_step));
    }

    try zig_args.ensureUnusedCapacity(gpa, 2 * m.rpaths.len);
    for (0..m.rpaths.len) |i| switch (m.rpaths.get(conf.extra, i)) {
        .lazy_path => |lp| {
            zig_args.appendAssumeCapacity("-rpath");
            zig_args.appendAssumeCapacity(try maker.resolveLazyPathIndexAbs(arena, lp, asking_step));
        },
        .special => |string| {
            zig_args.appendAssumeCapacity("-rpath");
            zig_args.appendAssumeCapacity(string.slice(conf));
        },
    };
}