mirror of
https://codeberg.org/ziglang/zig.git
synced 2026-04-28 19:47:08 +03:00
Andrew Kelley
788dee8821
When an artifact arg is added to a Run step, if the artifact is installed, then the installation path is added rather than the cache artifact path. This is probably something that should change in the future, but the goal of this branch is to generally avoid breakage other than that caused by phase separation.
1552 lines
69 KiB
Zig
1552 lines
69 KiB
Zig
const Compile = @This();
|
|
|
|
const std = @import("std");
|
|
const Allocator = std.mem.Allocator;
|
|
const Configuration = std.Build.Configuration;
|
|
const Dir = std.Io.Dir;
|
|
const Path = std.Build.Cache.Path;
|
|
const Module = std.Build.Configuration.Module;
|
|
const Io = std.Io;
|
|
const Sha256 = std.crypto.hash.sha2.Sha256;
|
|
const assert = std.debug.assert;
|
|
const mem = std.mem;
|
|
const allocPrint = std.fmt.allocPrint;
|
|
|
|
const Step = @import("../Step.zig");
|
|
const Maker = @import("../../Maker.zig");
|
|
|
|
/// Populated when there is compiler process that lives across multiple calls
|
|
/// to `make`.
|
|
zig_process: ?*Step.ZigProcess = null,
|
|
/// Persisted to reuse memory on subsequent calls to `make`.
|
|
zig_args: std.ArrayList([]const u8) = .empty,
|
|
/// Populated by InstallArtifact.
|
|
installed_path: ?Path = null,
|
|
|
|
pub fn make(
|
|
compile: *Compile,
|
|
compile_index: Configuration.Step.Index,
|
|
maker: *Maker,
|
|
progress_node: std.Progress.Node,
|
|
) Step.ExtendedMakeError!void {
|
|
const graph = maker.graph;
|
|
const arena = graph.arena; // TODO don't leak into process arena
|
|
const conf = &maker.scanned_config.configuration;
|
|
const conf_step = compile_index.ptr(conf);
|
|
const conf_comp = conf_step.extended.get(conf.extra).compile;
|
|
|
|
// Reset / repopulate persistent state.
|
|
compile.zig_args.clearRetainingCapacity();
|
|
|
|
try lowerZigArgs(compile, compile_index, maker, &compile.zig_args, false);
|
|
|
|
const maybe_output_dir = Step.evalZigProcess(
|
|
compile_index,
|
|
maker,
|
|
compile.zig_args.items,
|
|
progress_node,
|
|
(graph.incremental == true) and (maker.watch or maker.web_server != null),
|
|
) catch |err| switch (err) {
|
|
error.NeedCompileErrorCheck => {
|
|
try checkCompileErrors(compile, maker);
|
|
return;
|
|
},
|
|
else => |e| return e,
|
|
};
|
|
|
|
const root_module = conf_comp.root_module.get(conf);
|
|
const target = root_module.resolved_target.get(conf).?.result.get(conf);
|
|
|
|
// Update generated files
|
|
if (maybe_output_dir) |output_dir| {
|
|
if (conf_comp.emit_directory.value) |gf| maker.generatedPath(gf).* = output_dir;
|
|
try updateGeneratedFile(&conf_comp, maker, output_dir, &target, conf_comp.generated_bin.value, .bin);
|
|
try updateGeneratedFile(&conf_comp, maker, output_dir, &target, conf_comp.generated_pdb.value, .pdb);
|
|
try updateGeneratedFile(&conf_comp, maker, output_dir, &target, conf_comp.generated_implib.value, .implib);
|
|
try updateGeneratedFile(&conf_comp, maker, output_dir, &target, conf_comp.generated_h.value, .h);
|
|
try updateGeneratedFile(&conf_comp, maker, output_dir, &target, conf_comp.generated_docs.value, .docs);
|
|
try updateGeneratedFile(&conf_comp, maker, output_dir, &target, conf_comp.generated_asm.value, .@"asm");
|
|
try updateGeneratedFile(&conf_comp, maker, output_dir, &target, conf_comp.generated_llvm_ir.value, .llvm_ir);
|
|
try updateGeneratedFile(&conf_comp, maker, output_dir, &target, conf_comp.generated_llvm_bc.value, .llvm_bc);
|
|
}
|
|
|
|
if (conf_comp.flags3.kind == .lib and conf_comp.flags2.linkage == .dynamic and
|
|
conf_comp.version.value != null and target.flags.os_tag != .windows)
|
|
{
|
|
if (conf_comp.generated_bin.value) |generated_bin| {
|
|
const full_dest_path = maker.generatedPath(generated_bin).*;
|
|
try maker.installSymLinks(arena, full_dest_path, compile_index, compile_index);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn updateGeneratedFile(
|
|
conf_comp: *const Configuration.Step.Compile,
|
|
maker: *Maker,
|
|
out_path: std.Build.Cache.Path,
|
|
target: *const Configuration.TargetQuery,
|
|
opt_gf: ?Configuration.GeneratedFileIndex,
|
|
ea: std.zig.EmitArtifact,
|
|
) Allocator.Error!void {
|
|
const gf = opt_gf orelse return;
|
|
const graph = maker.graph;
|
|
const conf = &maker.scanned_config.configuration;
|
|
const arena = graph.arena; // TODO don't leak into process arena
|
|
const name = try ea.cacheName(arena, .{
|
|
.root_name = conf_comp.root_name.slice(conf),
|
|
.cpu_arch = target.flags.cpu_arch.unwrap().?,
|
|
.os_tag = target.flags.os_tag.unwrap().?,
|
|
.ofmt = target.flags.object_format.unwrap().?,
|
|
.abi = target.flags.abi.unwrap().?,
|
|
.output_mode = switch (conf_comp.flags3.kind) {
|
|
.lib => .Lib,
|
|
.obj, .test_obj => .Obj,
|
|
.exe, .@"test" => .Exe,
|
|
},
|
|
.link_mode = conf_comp.flags2.linkage.unwrap(),
|
|
.version = if (conf_comp.version.value) |v|
|
|
std.SemanticVersion.parse(v.slice(conf)) catch unreachable
|
|
else
|
|
null,
|
|
});
|
|
maker.generatedPath(gf).* = try out_path.join(arena, name);
|
|
}
|
|
|
|
/// List of importable modules in a compilation's module graph, including
|
|
/// the root module. The root module is guaranteed to be first.
|
|
const ModuleList = std.AutoArrayHashMapUnmanaged(Configuration.Module.Index, Configuration.String);
|
|
/// Keyed on the first key in the module list.
|
|
const ModuleGraph = std.ArrayHashMapUnmanaged(ModuleList, void, ModuleListContext, false);
|
|
|
|
const ModuleListContext = struct {
|
|
pub fn eql(ctx: @This(), a: ModuleList, b: ModuleList) bool {
|
|
_ = ctx;
|
|
return a.keys()[0] == b.keys()[0];
|
|
}
|
|
|
|
pub fn hash(ctx: @This(), key: ModuleList) u32 {
|
|
_ = ctx;
|
|
return std.hash.int(@intFromEnum(key.keys()[0]));
|
|
}
|
|
|
|
const Adapter = struct {
|
|
pub fn eql(ctx: @This(), a: Configuration.Module.Index, b: ModuleList, b_index: usize) bool {
|
|
_ = ctx;
|
|
_ = b_index;
|
|
return a == b.keys()[0];
|
|
}
|
|
|
|
pub fn hash(ctx: @This(), key: Configuration.Module.Index) u32 {
|
|
_ = ctx;
|
|
return std.hash.int(@intFromEnum(key));
|
|
}
|
|
};
|
|
};
|
|
|
|
fn lowerZigArgs(
|
|
compile: *const Compile,
|
|
compile_index: Configuration.Step.Index,
|
|
maker: *const Maker,
|
|
zig_args: *std.ArrayList([]const u8),
|
|
fuzz: bool,
|
|
) error{ OutOfMemory, MakeFailed }!void {
|
|
const step = maker.stepByIndex(compile_index);
|
|
const graph = maker.graph;
|
|
const arena = graph.arena; // TODO don't leak into the process arena
|
|
const gpa = maker.gpa;
|
|
const conf = &maker.scanned_config.configuration;
|
|
const conf_step = compile_index.ptr(conf);
|
|
const conf_comp = conf_step.extended.get(conf.extra).compile;
|
|
const root_module_target = conf_comp.rootModuleTarget(conf);
|
|
|
|
try zig_args.append(gpa, graph.zig_exe);
|
|
|
|
const cmd = switch (conf_comp.flags3.kind) {
|
|
.lib => "build-lib",
|
|
.exe => "build-exe",
|
|
.obj => "build-obj",
|
|
.@"test" => "test",
|
|
.test_obj => "test-obj",
|
|
};
|
|
try zig_args.append(gpa, cmd);
|
|
|
|
if (graph.reference_trace) |some| {
|
|
try zig_args.append(gpa, try allocPrint(arena, "-freference-trace={d}", .{some}));
|
|
}
|
|
try addFlag(gpa, zig_args, "allow-so-scripts", conf_comp.flags2.allow_so_scripts.toBool() orelse graph.allow_so_scripts);
|
|
|
|
try addFlag(gpa, zig_args, "llvm", conf_comp.flags2.use_llvm.toBool());
|
|
try addFlag(gpa, zig_args, "lld", conf_comp.flags2.use_lld.toBool());
|
|
try addFlag(gpa, zig_args, "new-linker", conf_comp.flags2.use_new_linker.toBool());
|
|
|
|
const root_module = conf_comp.root_module.get(conf);
|
|
|
|
if (root_module.resolved_target.get(conf).?.query.unwrap()) |query| {
|
|
if (query.get(conf).flags.object_format.unwrap()) |ofmt| {
|
|
try zig_args.append(gpa, try allocPrint(arena, "-ofmt={t}", .{ofmt}));
|
|
}
|
|
}
|
|
|
|
switch (conf_comp.flags3.entry) {
|
|
.default => {},
|
|
.disabled => try zig_args.append(gpa, "-fno-entry"),
|
|
.enabled => try zig_args.append(gpa, "-fentry"),
|
|
.symbol_name => {
|
|
const symbol_name = conf_comp.entry.value.?.slice(conf);
|
|
try zig_args.append(gpa, try allocPrint(arena, "-fentry={s}", .{symbol_name}));
|
|
},
|
|
}
|
|
|
|
for (conf_comp.force_undefined_symbols.slice) |symbol_name| {
|
|
try zig_args.appendSlice(gpa, &.{ "--force_undefined", symbol_name.slice(conf) });
|
|
}
|
|
|
|
if (conf_comp.stack_size.value) |stack_size| {
|
|
try zig_args.appendSlice(gpa, &.{ "--stack", try allocPrint(arena, "{d}", .{stack_size}) });
|
|
}
|
|
|
|
try addBool(gpa, zig_args, "-ffuzz", fuzz);
|
|
|
|
{
|
|
var is_linking_libc = conf_comp.flags3.is_linking_libc;
|
|
var is_linking_libcpp = conf_comp.flags3.is_linking_libcpp;
|
|
|
|
// Stores system libraries that have already been seen for at least one
|
|
// module, along with any C compiler arguments that need to be passed
|
|
// to the compiler for each module individually as reported by
|
|
// pkg-config.
|
|
var seen_system_libs: std.AutoArrayHashMapUnmanaged(Configuration.String, []const []const u8) = .empty;
|
|
var frameworks: std.AutoArrayHashMapUnmanaged(Configuration.String, Configuration.Module.Framework.Flags) = .empty;
|
|
var module_graph: ModuleGraph = .empty;
|
|
|
|
var prev_has_cflags = false;
|
|
var prev_has_rcflags = false;
|
|
var prev_search_strategy: Configuration.SystemLib.SearchStrategy = .paths_first;
|
|
var prev_preferred_link_mode: std.builtin.LinkMode = .dynamic;
|
|
// Track the number of positional arguments so that a nice error can be
|
|
// emitted if there is nothing to link.
|
|
var total_linker_objects: usize = @intFromBool(root_module.root_source_file != .none);
|
|
|
|
// Fully recursive iteration including dynamic libraries to detect
|
|
// libc and libc++ linkage.
|
|
for (try getCompileDependencies(arena, &module_graph, conf, compile_index, true)) |some_compile_index| {
|
|
const some_compile = some_compile_index.ptr(conf).extended.get(conf.extra).compile;
|
|
const modules = try getModuleList(arena, &module_graph, some_compile.root_module, conf);
|
|
for (modules.keys()) |mod_index| {
|
|
const mod = mod_index.get(conf);
|
|
is_linking_libc = is_linking_libc or mod.flags2.link_libc == .true;
|
|
is_linking_libcpp = is_linking_libcpp or mod.flags2.link_libcpp == .true;
|
|
}
|
|
}
|
|
|
|
var cli_named_modules = try CliNamedModules.init(arena, &module_graph, compile_index, maker);
|
|
|
|
// For this loop, don't chase dynamic libraries because their link
|
|
// objects are already linked.
|
|
for (try getCompileDependencies(arena, &module_graph, conf, compile_index, false)) |dep_compile_index| {
|
|
const dep_compile = dep_compile_index.ptr(conf).extended.get(conf.extra).compile;
|
|
const modules = try getModuleList(arena, &module_graph, dep_compile.root_module, conf);
|
|
for (modules.keys()) |mod_index| {
|
|
const mod = mod_index.get(conf);
|
|
// While walking transitive dependencies, if a given link object is
|
|
// already included in a library, it should not redundantly be
|
|
// placed on the linker line of the dependee.
|
|
const my_responsibility = dep_compile_index == compile_index;
|
|
const already_linked = !my_responsibility and dep_compile.isDynamicLibrary();
|
|
|
|
// Inherit dependencies on darwin frameworks.
|
|
if (!already_linked) {
|
|
for (mod.frameworks.slice) |framework| {
|
|
try frameworks.put(arena, framework.name, framework.flags);
|
|
}
|
|
}
|
|
|
|
// Inherit dependencies on system libraries and static libraries.
|
|
for (0..mod.link_objects.len) |lo_i| switch (mod.link_objects.get(conf.extra, lo_i)) {
|
|
.static_path => |static_path| {
|
|
if (my_responsibility) {
|
|
try zig_args.append(gpa, try maker.resolveLazyPathIndexAbs(arena, static_path, compile_index));
|
|
total_linker_objects += 1;
|
|
}
|
|
},
|
|
.system_lib => |system_lib_index| {
|
|
const system_lib = system_lib_index.get(conf);
|
|
const system_lib_name = system_lib.name.slice(conf);
|
|
const system_lib_gop = try seen_system_libs.getOrPut(arena, system_lib.name);
|
|
if (system_lib_gop.found_existing) {
|
|
try zig_args.appendSlice(gpa, system_lib_gop.value_ptr.*);
|
|
continue;
|
|
} else {
|
|
system_lib_gop.value_ptr.* = &.{};
|
|
}
|
|
|
|
if (already_linked)
|
|
continue;
|
|
|
|
if ((system_lib.flags.search_strategy != prev_search_strategy or
|
|
system_lib.flags.preferred_link_mode != prev_preferred_link_mode) and
|
|
conf_comp.flags2.linkage != .static)
|
|
{
|
|
switch (system_lib.flags.search_strategy) {
|
|
.no_fallback => switch (system_lib.flags.preferred_link_mode) {
|
|
.dynamic => try zig_args.append(gpa, "-search_dylibs_only"),
|
|
.static => try zig_args.append(gpa, "-search_static_only"),
|
|
},
|
|
.paths_first => switch (system_lib.flags.preferred_link_mode) {
|
|
.dynamic => try zig_args.append(gpa, "-search_paths_first"),
|
|
.static => try zig_args.append(gpa, "-search_paths_first_static"),
|
|
},
|
|
.mode_first => switch (system_lib.flags.preferred_link_mode) {
|
|
.dynamic => try zig_args.append(gpa, "-search_dylibs_first"),
|
|
.static => try zig_args.append(gpa, "-search_static_first"),
|
|
},
|
|
}
|
|
prev_search_strategy = system_lib.flags.search_strategy;
|
|
prev_preferred_link_mode = system_lib.flags.preferred_link_mode;
|
|
}
|
|
|
|
const prefix: []const u8 = prefix: {
|
|
if (system_lib.flags.needed) break :prefix "-needed-l";
|
|
if (system_lib.flags.weak) break :prefix "-weak-l";
|
|
break :prefix "-l";
|
|
};
|
|
switch (system_lib.flags.use_pkg_config) {
|
|
.no => try zig_args.append(gpa, try allocPrint(arena, "{s}{s}", .{
|
|
prefix, system_lib_name,
|
|
})),
|
|
.yes, .force => {
|
|
if (compile.runPkgConfig(maker, system_lib_name)) |result| {
|
|
try zig_args.appendSlice(gpa, result.cflags);
|
|
try zig_args.appendSlice(gpa, result.libs);
|
|
try seen_system_libs.put(arena, system_lib.name, result.cflags);
|
|
} else |err| switch (err) {
|
|
error.PkgConfigInvalidOutput,
|
|
error.PkgConfigCrashed,
|
|
error.PkgConfigFailed,
|
|
error.PkgConfigNotInstalled,
|
|
error.PackageNotFound,
|
|
=> switch (system_lib.flags.use_pkg_config) {
|
|
.yes => {
|
|
// pkg-config failed, so fall back to linking the library
|
|
// by name directly.
|
|
try zig_args.append(gpa, try allocPrint(arena, "{s}{s}", .{
|
|
prefix, system_lib_name,
|
|
}));
|
|
},
|
|
.force => {
|
|
return step.fail(maker, "pkg-config failed for library {s}", .{
|
|
system_lib_name,
|
|
});
|
|
},
|
|
.no => unreachable,
|
|
},
|
|
|
|
else => |e| return e,
|
|
}
|
|
},
|
|
}
|
|
},
|
|
.other_step => |other_step_index| {
|
|
const other = other_step_index.ptr(conf);
|
|
const other_compile = other.extended.get(conf.extra).compile;
|
|
switch (other_compile.flags3.kind) {
|
|
.exe => return step.fail(maker, "cannot link with an executable build artifact", .{}),
|
|
.@"test" => return step.fail(maker, "cannot link with a test", .{}),
|
|
.obj, .test_obj => {
|
|
const included_in_lib_or_obj = switch (dep_compile.flags3.kind) {
|
|
.lib, .obj, .test_obj => !my_responsibility,
|
|
else => false,
|
|
};
|
|
if (!already_linked and !included_in_lib_or_obj) {
|
|
try zig_args.append(gpa, try maker.resolveLazyPathAbs(
|
|
arena,
|
|
.{ .generated = .{ .index = other_compile.generated_bin.value.? } },
|
|
compile_index,
|
|
));
|
|
total_linker_objects += 1;
|
|
}
|
|
},
|
|
.lib => l: {
|
|
const other_produces_implib = other_compile.producesImplib(conf);
|
|
const other_is_static = other_produces_implib or other_compile.isStaticLibrary();
|
|
|
|
if (conf_comp.isStaticLibrary() and other_is_static) {
|
|
// Avoid putting a static library inside a static library.
|
|
break :l;
|
|
}
|
|
|
|
// For DLLs, we must link against the implib.
|
|
// For everything else, we directly link
|
|
// against the library file.
|
|
const full_path_lib = try maker.resolveLazyPathAbs(
|
|
arena,
|
|
.{ .generated = .{
|
|
.index = if (other_produces_implib)
|
|
other_compile.generated_implib.value.?
|
|
else
|
|
other_compile.generated_bin.value.?,
|
|
} },
|
|
compile_index,
|
|
);
|
|
|
|
try zig_args.append(gpa, full_path_lib);
|
|
total_linker_objects += 1;
|
|
|
|
if (other_compile.flags2.linkage == .dynamic and
|
|
root_module_target.flags.os_tag != .windows)
|
|
{
|
|
if (Dir.path.dirname(full_path_lib)) |dirname| {
|
|
try zig_args.appendSlice(gpa, &.{ "-rpath", dirname });
|
|
}
|
|
}
|
|
},
|
|
}
|
|
},
|
|
.assembly_file => |asm_file| l: {
|
|
if (!my_responsibility) break :l;
|
|
|
|
if (prev_has_cflags) {
|
|
try zig_args.appendSlice(gpa, &.{ "-cflags", "--" });
|
|
prev_has_cflags = false;
|
|
}
|
|
try zig_args.append(gpa, try maker.resolveLazyPathIndexAbs(arena, asm_file, compile_index));
|
|
total_linker_objects += 1;
|
|
},
|
|
|
|
.c_source_file => |c_source_file_index| l: {
|
|
if (!my_responsibility) break :l;
|
|
|
|
const c_source_file = c_source_file_index.get(conf);
|
|
|
|
if (prev_has_cflags or c_source_file.args.slice.len != 0) {
|
|
try zig_args.ensureUnusedCapacity(gpa, 2 + c_source_file.args.slice.len);
|
|
zig_args.appendAssumeCapacity("-cflags");
|
|
for (c_source_file.args.slice) |arg| {
|
|
zig_args.appendAssumeCapacity(arg.slice(conf));
|
|
}
|
|
zig_args.appendAssumeCapacity("--");
|
|
}
|
|
prev_has_cflags = (c_source_file.args.slice.len != 0);
|
|
|
|
if (c_source_file.flags.lang.get()) |lang|
|
|
(try zig_args.addManyAsArray(gpa, 2)).* = .{ "-x", lang.clangIdentifier() };
|
|
|
|
try zig_args.append(gpa, try maker.resolveLazyPathIndexAbs(arena, c_source_file.file, compile_index));
|
|
|
|
if (c_source_file.flags.lang != .default)
|
|
(try zig_args.addManyAsArray(gpa, 2)).* = .{ "-x", "none" };
|
|
|
|
total_linker_objects += 1;
|
|
},
|
|
|
|
.c_source_files => |c_source_files_index| l: {
|
|
if (!my_responsibility) break :l;
|
|
|
|
const c_source_files = c_source_files_index.get(conf);
|
|
|
|
if (prev_has_cflags or c_source_files.args.slice.len != 0) {
|
|
try zig_args.ensureUnusedCapacity(gpa, 2 + c_source_files.args.slice.len);
|
|
zig_args.appendAssumeCapacity("-cflags");
|
|
for (c_source_files.args.slice) |arg| {
|
|
zig_args.appendAssumeCapacity(arg.slice(conf));
|
|
}
|
|
zig_args.appendAssumeCapacity("--");
|
|
}
|
|
prev_has_cflags = (c_source_files.args.slice.len != 0);
|
|
|
|
if (c_source_files.flags.lang.get()) |lang|
|
|
(try zig_args.addManyAsArray(gpa, 2)).* = .{ "-x", lang.clangIdentifier() };
|
|
|
|
const root_path = try maker.resolveLazyPathIndexAbs(arena, c_source_files.root, compile_index);
|
|
try zig_args.ensureUnusedCapacity(gpa, c_source_files.sub_paths.slice.len);
|
|
for (c_source_files.sub_paths.slice) |sub_path| {
|
|
zig_args.appendAssumeCapacity(try Dir.path.join(arena, &.{
|
|
root_path, sub_path.slice(conf),
|
|
}));
|
|
}
|
|
|
|
if (c_source_files.flags.lang != .default)
|
|
(try zig_args.addManyAsArray(gpa, 2)).* = .{ "-x", "none" };
|
|
|
|
total_linker_objects += c_source_files.sub_paths.slice.len;
|
|
},
|
|
|
|
.win32_resource_file => |rc_source_file_index| l: {
|
|
if (!my_responsibility) break :l;
|
|
|
|
const rc_source_file = rc_source_file_index.get(conf);
|
|
|
|
if (rc_source_file.args.slice.len == 0 and rc_source_file.include_paths.slice.len == 0) {
|
|
if (prev_has_rcflags) {
|
|
(try zig_args.addManyAsArray(gpa, 2)).* = .{ "-rcflags", "--" };
|
|
prev_has_rcflags = false;
|
|
}
|
|
} else {
|
|
try zig_args.ensureUnusedCapacity(gpa, 1 + rc_source_file.args.slice.len);
|
|
zig_args.appendAssumeCapacity("-rcflags");
|
|
for (rc_source_file.args.slice) |arg| {
|
|
zig_args.appendAssumeCapacity(arg.slice(conf));
|
|
}
|
|
try zig_args.ensureUnusedCapacity(gpa, 1 + 2 * rc_source_file.include_paths.slice.len);
|
|
for (rc_source_file.include_paths.slice) |include_path| {
|
|
zig_args.appendAssumeCapacity("/I");
|
|
zig_args.appendAssumeCapacity(try maker.resolveLazyPathIndexAbs(arena, include_path, compile_index));
|
|
}
|
|
zig_args.appendAssumeCapacity("--");
|
|
prev_has_rcflags = true;
|
|
}
|
|
try zig_args.append(gpa, try maker.resolveLazyPathIndexAbs(arena, rc_source_file.file, compile_index));
|
|
total_linker_objects += 1;
|
|
},
|
|
};
|
|
|
|
// We need to emit the --mod argument here so that the above link objects
|
|
// have the correct parent module, but only if the module is part of
|
|
// this compilation.
|
|
if (!my_responsibility) continue;
|
|
if (cli_named_modules.modules.getIndex(mod_index)) |module_cli_index| {
|
|
const module_cli_name = cli_named_modules.names.keys()[module_cli_index];
|
|
const module_index = cli_named_modules.modules.keys()[module_cli_index];
|
|
try appendModuleFlags(module_index, zig_args, compile_index, maker);
|
|
|
|
const imports = mod.import_table.get(conf).imports.mal;
|
|
|
|
// --dep arguments
|
|
try zig_args.ensureUnusedCapacity(gpa, imports.len * 2);
|
|
for (imports.items(.name), imports.items(.module)) |name, import| {
|
|
const import_index = cli_named_modules.modules.getIndex(import).?;
|
|
const import_cli_name = cli_named_modules.names.keys()[import_index];
|
|
zig_args.appendAssumeCapacity("--dep");
|
|
const name_slice = name.slice(conf);
|
|
if (std.mem.eql(u8, import_cli_name, name_slice)) {
|
|
zig_args.appendAssumeCapacity(import_cli_name);
|
|
} else {
|
|
zig_args.appendAssumeCapacity(try allocPrint(arena, "{s}={s}", .{
|
|
name_slice, import_cli_name,
|
|
}));
|
|
}
|
|
}
|
|
|
|
// When the CLI sees a -M argument, it determines whether it
|
|
// implies the existence of a Zig compilation unit based on
|
|
// whether there is a root source file. If there is no root
|
|
// source file, then this is not a zig compilation unit - it is
|
|
// perhaps a set of linker objects, or C source files instead.
|
|
// Linker objects are added to the CLI globally, while C source
|
|
// files must have a module parent.
|
|
try zig_args.ensureUnusedCapacity(gpa, 1);
|
|
if (mod.root_source_file.unwrap()) |lp| {
|
|
const src = try maker.resolveLazyPathIndexAbs(arena, lp, compile_index);
|
|
zig_args.appendAssumeCapacity(try allocPrint(arena, "-M{s}={s}", .{ module_cli_name, src }));
|
|
} else if (moduleNeedsCliArg(&mod, conf)) {
|
|
zig_args.appendAssumeCapacity(try allocPrint(arena, "-M{s}", .{module_cli_name}));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (total_linker_objects == 0) {
|
|
return step.fail(maker, "the linker needs one or more objects to link", .{});
|
|
}
|
|
|
|
for (frameworks.keys(), frameworks.values()) |name, info| {
|
|
try zig_args.ensureUnusedCapacity(gpa, 2);
|
|
if (info.needed) {
|
|
zig_args.appendAssumeCapacity("-needed_framework");
|
|
} else if (info.weak) {
|
|
zig_args.appendAssumeCapacity("-weak_framework");
|
|
} else {
|
|
zig_args.appendAssumeCapacity("-framework");
|
|
}
|
|
zig_args.appendAssumeCapacity(name.slice(conf));
|
|
}
|
|
|
|
try zig_args.ensureUnusedCapacity(gpa, 2);
|
|
if (is_linking_libcpp) zig_args.appendAssumeCapacity("-lc++");
|
|
if (is_linking_libc) zig_args.appendAssumeCapacity("-lc");
|
|
}
|
|
|
|
if (conf_comp.win32_manifest.value) |manifest_file| {
|
|
try zig_args.append(gpa, try maker.resolveLazyPathIndexAbs(arena, manifest_file, compile_index));
|
|
}
|
|
|
|
if (conf_comp.win32_module_definition.value) |module_file| {
|
|
try zig_args.append(gpa, try maker.resolveLazyPathIndexAbs(arena, module_file, compile_index));
|
|
}
|
|
|
|
if (conf_comp.image_base.value) |image_base| {
|
|
(try zig_args.addManyAsArray(gpa, 2)).* = .{
|
|
"--image-base", try allocPrint(arena, "0x{x}", .{image_base}),
|
|
};
|
|
}
|
|
|
|
for (conf_comp.filters.slice) |filter| {
|
|
(try zig_args.addManyAsArray(gpa, 2)).* = .{ "--test-filter", filter.slice(conf) };
|
|
}
|
|
|
|
switch (conf_comp.test_runner.u) {
|
|
.default => {},
|
|
.simple, .server => |lp| (try zig_args.addManyAsArray(gpa, 2)).* = .{
|
|
"--test-runner", try maker.resolveLazyPathIndexAbs(arena, lp, compile_index),
|
|
},
|
|
}
|
|
|
|
for (graph.debug_log_scopes.items) |log_scope| {
|
|
(try zig_args.addManyAsArray(gpa, 2)).* = .{ "--debug-log", log_scope };
|
|
}
|
|
|
|
try addBool(gpa, zig_args, "--debug-compile-errors", graph.debug_compile_errors);
|
|
try addBool(gpa, zig_args, "--debug-incremental", graph.debug_incremental);
|
|
try addBool(gpa, zig_args, "--verbose-air", graph.verbose_air);
|
|
try addBool(gpa, zig_args, "--verbose-llvm-ir", graph.verbose_llvm_ir);
|
|
try addBool(gpa, zig_args, "--verbose-link", graph.verbose_link or conf_comp.flags.verbose_link);
|
|
try addBool(gpa, zig_args, "--verbose-cc", graph.verbose_cc or conf_comp.flags.verbose_cc);
|
|
try addBool(gpa, zig_args, "--verbose-llvm-cpu-features", graph.verbose_llvm_cpu_features);
|
|
try addBool(gpa, zig_args, "--time-report", graph.time_report);
|
|
|
|
if (conf_comp.generated_bin.value == null) try zig_args.append(gpa, "-fno-emit-bin");
|
|
if (conf_comp.generated_asm.value != null) try zig_args.append(gpa, "-femit-asm");
|
|
if (conf_comp.generated_docs.value != null) try zig_args.append(gpa, "-femit-docs");
|
|
if (conf_comp.generated_implib.value != null) try zig_args.append(gpa, "-femit-implib");
|
|
if (conf_comp.generated_llvm_bc.value != null) try zig_args.append(gpa, "-femit-llvm-bc");
|
|
if (conf_comp.generated_llvm_ir.value != null) try zig_args.append(gpa, "-femit-llvm-ir");
|
|
if (conf_comp.generated_h.value != null) try zig_args.append(gpa, "-femit-h");
|
|
|
|
try addFlag(gpa, zig_args, "formatted-panics", conf_comp.flags2.formatted_panics.toBool());
|
|
|
|
switch (conf_comp.flags3.compress_debug_sections) {
|
|
.none => {},
|
|
.zlib => try zig_args.append(gpa, "--compress-debug-sections=zlib"),
|
|
.zstd => try zig_args.append(gpa, "--compress-debug-sections=zstd"),
|
|
}
|
|
|
|
try addBool(gpa, zig_args, "--eh-frame-hdr", conf_comp.flags.link_eh_frame_hdr);
|
|
try addBool(gpa, zig_args, "--emit-relocs", conf_comp.flags.link_emit_relocs);
|
|
try addBool(gpa, zig_args, "-ffunction-sections", conf_comp.flags.link_function_sections);
|
|
try addBool(gpa, zig_args, "-fdata-sections", conf_comp.flags.link_data_sections);
|
|
|
|
if (conf_comp.flags2.link_gc_sections.toBool()) |x|
|
|
try zig_args.append(gpa, if (x) "--gc-sections" else "--no-gc-sections");
|
|
|
|
if (!conf_comp.flags.linker_dynamicbase)
|
|
try zig_args.append(gpa, "--no-dynamicbase");
|
|
|
|
try addFlag(gpa, zig_args, "allow-shlib-undefined", conf_comp.flags2.linker_allow_shlib_undefined.toBool());
|
|
if (conf_comp.flags.link_z_notext) (try zig_args.addManyAsArray(gpa, 2)).* = .{ "-z", "notext" };
|
|
if (!conf_comp.flags.link_z_relro) (try zig_args.addManyAsArray(gpa, 2)).* = .{ "-z", "norelro" };
|
|
if (conf_comp.flags.link_z_lazy) (try zig_args.addManyAsArray(gpa, 2)).* = .{ "-z", "lazy" };
|
|
if (conf_comp.link_z_common_page_size.value) |size| (try zig_args.addManyAsArray(gpa, 2)).* = .{
|
|
"-z", try allocPrint(arena, "common-page-size={d}", .{size}),
|
|
};
|
|
if (conf_comp.link_z_max_page_size.value) |size| (try zig_args.addManyAsArray(gpa, 2)).* = .{
|
|
"-z", try allocPrint(arena, "max-page-size={d}", .{size}),
|
|
};
|
|
if (conf_comp.flags.link_z_defs) (try zig_args.addManyAsArray(gpa, 2)).* = .{ "-z", "defs" };
|
|
|
|
try zig_args.ensureUnusedCapacity(gpa, 2);
|
|
if (conf_comp.libc_file.value) |libc_file| {
|
|
zig_args.appendAssumeCapacity("--libc");
|
|
zig_args.appendAssumeCapacity(try maker.resolveLazyPathIndexAbs(arena, libc_file, compile_index));
|
|
} else if (graph.libc_file) |libc_file| {
|
|
zig_args.appendAssumeCapacity("--libc");
|
|
zig_args.appendAssumeCapacity(libc_file);
|
|
}
|
|
|
|
(try zig_args.addManyAsArray(gpa, 4)).* = .{
|
|
"--cache-dir", graph.local_cache_root.path orelse ".",
|
|
"--global-cache-dir", graph.global_cache_root.path orelse ".",
|
|
};
|
|
|
|
try zig_args.ensureUnusedCapacity(gpa, 1);
|
|
if (graph.debug_compiler_runtime_libs) |mode| switch (mode) {
|
|
.Debug => zig_args.appendAssumeCapacity("--debug-rt"),
|
|
else => zig_args.appendAssumeCapacity(try allocPrint(arena, "--debug-rt={t}", .{mode})),
|
|
};
|
|
|
|
{
|
|
try zig_args.ensureUnusedCapacity(gpa, 7);
|
|
|
|
zig_args.addManyAsArrayAssumeCapacity(2).* = .{ "--name", conf_comp.root_name.slice(conf) };
|
|
|
|
switch (conf_comp.flags2.linkage) {
|
|
.dynamic => zig_args.appendAssumeCapacity("-dynamic"),
|
|
.static => zig_args.appendAssumeCapacity("-static"),
|
|
.default => {},
|
|
}
|
|
|
|
if (conf_comp.flags3.kind == .lib and conf_comp.flags2.linkage == .dynamic) {
|
|
if (conf_comp.version.value) |version| zig_args.addManyAsArrayAssumeCapacity(2).* = .{
|
|
"--version", version.slice(conf),
|
|
};
|
|
|
|
const os_tag = root_module_target.flags.os_tag.unwrap().?;
|
|
if (os_tag.isDarwin()) {
|
|
const abi = root_module_target.flags.abi.unwrap().?;
|
|
zig_args.addManyAsArrayAssumeCapacity(2).* = .{
|
|
"-install_name",
|
|
if (conf_comp.install_name.value) |s| s.slice(conf) else try allocPrint(
|
|
arena,
|
|
"@rpath/{s}{s}{s}",
|
|
.{
|
|
os_tag.libPrefix(abi),
|
|
conf_comp.root_name.slice(conf),
|
|
os_tag.dynamicLibSuffix(),
|
|
},
|
|
),
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
if (conf_comp.entitlements.value) |entitlements| {
|
|
(try zig_args.addManyAsArray(gpa, 2)).* = .{
|
|
"--entitlements", try maker.resolveLazyPathIndexAbs(arena, entitlements, compile_index),
|
|
};
|
|
}
|
|
if (conf_comp.pagezero_size.value) |pagezero_size| {
|
|
(try zig_args.addManyAsArray(gpa, 2)).* = .{
|
|
"-pagezero_size", try allocPrint(arena, "{x}", .{pagezero_size}),
|
|
};
|
|
}
|
|
if (conf_comp.headerpad_size.value) |headerpad_size| {
|
|
(try zig_args.addManyAsArray(gpa, 2)).* = .{
|
|
"-headerpad", try allocPrint(arena, "{x}", .{headerpad_size}),
|
|
};
|
|
}
|
|
try addBool(gpa, zig_args, "-headerpad_max_install_names", conf_comp.flags.headerpad_max_install_names);
|
|
try addBool(gpa, zig_args, "-dead_strip_dylibs", conf_comp.flags.dead_strip_dylibs);
|
|
try addBool(gpa, zig_args, "-ObjC", conf_comp.flags.force_load_objc);
|
|
try addBool(gpa, zig_args, "--discard-all", conf_comp.flags.discard_local_symbols);
|
|
|
|
try addFlag(gpa, zig_args, "compiler-rt", conf_comp.flags2.bundle_compiler_rt.toBool());
|
|
try addFlag(gpa, zig_args, "ubsan-rt", conf_comp.flags2.bundle_ubsan_rt.toBool());
|
|
try addFlag(gpa, zig_args, "dll-export-fns", conf_comp.flags2.dll_export_fns.toBool());
|
|
|
|
try addBool(gpa, zig_args, "-rdynamic", conf_comp.flags.rdynamic);
|
|
try addBool(gpa, zig_args, "--import-memory", conf_comp.flags.import_memory);
|
|
try addBool(gpa, zig_args, "--export-memory", conf_comp.flags.export_memory);
|
|
try addBool(gpa, zig_args, "--import-symbols", conf_comp.flags.import_symbols);
|
|
try addBool(gpa, zig_args, "--import-table", conf_comp.flags.import_table);
|
|
try addBool(gpa, zig_args, "--export-table", conf_comp.flags.export_table);
|
|
try addBool(gpa, zig_args, "--shared-memory", conf_comp.flags.shared_memory);
|
|
|
|
{
|
|
try zig_args.ensureUnusedCapacity(gpa, 4);
|
|
if (conf_comp.initial_memory.value) |initial_memory| {
|
|
zig_args.appendAssumeCapacity(try allocPrint(arena, "--initial-memory={d}", .{initial_memory}));
|
|
}
|
|
if (conf_comp.max_memory.value) |max_memory| {
|
|
zig_args.appendAssumeCapacity(try allocPrint(arena, "--max-memory={d}", .{max_memory}));
|
|
}
|
|
if (conf_comp.global_base.value) |global_base| {
|
|
zig_args.appendAssumeCapacity(try allocPrint(arena, "--global-base={d}", .{global_base}));
|
|
}
|
|
switch (conf_comp.flags3.wasi_exec_model) {
|
|
.default => {},
|
|
.command => zig_args.appendAssumeCapacity("-mexec-model=command"),
|
|
.reactor => zig_args.appendAssumeCapacity("-mexec-model=reactor"),
|
|
}
|
|
}
|
|
|
|
if (conf_comp.linker_script.value) |linker_script| (try zig_args.addManyAsArray(gpa, 2)).* = .{
|
|
"--script", try maker.resolveLazyPathIndexAbs(arena, linker_script, compile_index),
|
|
};
|
|
if (conf_comp.version_script.value) |version_script| (try zig_args.addManyAsArray(gpa, 2)).* = .{
|
|
"--version-script", try maker.resolveLazyPathIndexAbs(arena, version_script, compile_index),
|
|
};
|
|
if (conf_comp.flags2.linker_allow_undefined_version.toBool()) |x| {
|
|
try zig_args.append(gpa, if (x) "--undefined-version" else "--no-undefined-version");
|
|
}
|
|
|
|
if (conf_comp.flags2.linker_enable_new_dtags.toBool()) |enabled| {
|
|
try zig_args.append(gpa, if (enabled) "--enable-new-dtags" else "--disable-new-dtags");
|
|
}
|
|
|
|
if (conf_comp.flags3.kind == .@"test" and conf_comp.exec_cmd_args.slice.len != 0) {
|
|
for (conf_comp.exec_cmd_args.slice) |cmd_arg| {
|
|
try zig_args.ensureUnusedCapacity(gpa, 2);
|
|
if (cmd_arg.slice(conf)) |arg| {
|
|
zig_args.appendAssumeCapacity("--test-cmd");
|
|
zig_args.appendAssumeCapacity(arg);
|
|
} else {
|
|
zig_args.appendAssumeCapacity("--test-cmd-bin");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (graph.sysroot) |sysroot| try zig_args.appendSlice(gpa, &.{ "--sysroot", sysroot });
|
|
|
|
// -I and -L arguments that appear after the last --mod argument apply to all modules.
|
|
const cwd: Io.Dir = .cwd();
|
|
const io = graph.io;
|
|
|
|
for (graph.search_prefixes.items) |search_prefix| {
|
|
var prefix_dir = cwd.openDir(io, search_prefix, .{}) catch |err| {
|
|
return step.fail(maker, "unable to open prefix directory '{s}': {t}", .{ search_prefix, err });
|
|
};
|
|
defer prefix_dir.close(io);
|
|
|
|
// Avoid passing -L and -I flags for nonexistent directories.
|
|
// This prevents a warning, that should probably be upgraded to an error in Zig's
|
|
// CLI parsing code, when the linker sees an -L directory that does not exist.
|
|
|
|
if (prefix_dir.access(io, "lib", .{})) |_| {
|
|
try zig_args.appendSlice(gpa, &.{
|
|
"-L", try Dir.path.join(arena, &.{ search_prefix, "lib" }),
|
|
});
|
|
} else |err| switch (err) {
|
|
error.FileNotFound => {},
|
|
else => |e| return step.fail(maker, "unable to access '{s}/lib' directory: {t}", .{ search_prefix, e }),
|
|
}
|
|
|
|
if (prefix_dir.access(io, "include", .{})) |_| {
|
|
try zig_args.appendSlice(gpa, &.{
|
|
"-I", try Dir.path.join(arena, &.{ search_prefix, "include" }),
|
|
});
|
|
} else |err| switch (err) {
|
|
error.FileNotFound => {},
|
|
else => |e| return step.fail(maker, "unable to access '{s}/include' directory: {t}", .{ search_prefix, e }),
|
|
}
|
|
}
|
|
|
|
if (conf_comp.flags3.rc_includes != .any) (try zig_args.addManyAsArray(gpa, 2)).* = .{
|
|
"-rcincludes", @tagName(conf_comp.flags3.rc_includes),
|
|
};
|
|
|
|
try addFlag(gpa, zig_args, "each-lib-rpath", conf_comp.flags2.each_lib_rpath.toBool());
|
|
|
|
if (conf_comp.flags3.build_id.unwrap(conf_comp.build_id.value, conf) orelse graph.build_id) |build_id| {
|
|
try zig_args.append(gpa, switch (build_id) {
|
|
.hexstring => |hs| try allocPrint(arena, "--build-id=0x{x}", .{hs.toSlice()}),
|
|
.none, .fast, .uuid, .sha1, .md5 => try allocPrint(arena, "--build-id={t}", .{build_id}),
|
|
});
|
|
}
|
|
|
|
const opt_zig_lib_dir: ?[]const u8 = if (conf_comp.zig_lib_dir.value) |dir|
|
|
try maker.resolveLazyPathIndexAbs(arena, dir, compile_index)
|
|
else if (graph.zig_lib_directory.path) |_|
|
|
try allocPrint(arena, "{f}", .{graph.zig_lib_directory})
|
|
else
|
|
null;
|
|
|
|
if (opt_zig_lib_dir) |zig_lib_dir| (try zig_args.addManyAsArray(gpa, 2)).* = .{
|
|
"--zig-lib-dir", zig_lib_dir,
|
|
};
|
|
|
|
try addFlag(gpa, zig_args, "PIE", conf_comp.flags2.pie.toBool());
|
|
|
|
try zig_args.ensureUnusedCapacity(gpa, 1);
|
|
switch (conf_comp.flags3.lto) {
|
|
.full => zig_args.appendAssumeCapacity("-flto=full"),
|
|
.thin => zig_args.appendAssumeCapacity("-flto=thin"),
|
|
.none => zig_args.appendAssumeCapacity("-fno-lto"),
|
|
.default => {},
|
|
}
|
|
|
|
try addFlag(gpa, zig_args, "sanitize-coverage-trace-pc-guard", conf_comp.flags2.sanitize_coverage_trace_pc_guard.toBool());
|
|
|
|
switch (conf_comp.flags3.subsystem) {
|
|
.default => {},
|
|
else => |t| (try zig_args.addManyAsArray(gpa, 2)).* = .{ "--subsystem", @tagName(t) },
|
|
}
|
|
|
|
try addBool(gpa, zig_args, "-municode", conf_comp.flags.mingw_unicode_entry_point);
|
|
|
|
if (conf_comp.error_limit.value orelse graph.error_limit) |err_limit| (try zig_args.addManyAsArray(gpa, 2)).* = .{
|
|
"--error-limit", try allocPrint(arena, "{d}", .{err_limit}),
|
|
};
|
|
|
|
try addFlag(gpa, zig_args, "incremental", graph.incremental);
|
|
|
|
try zig_args.append(gpa, "--listen=-");
|
|
|
|
// Windows has an argument length limit of 32,766 characters, macOS 262,144 and Linux
|
|
// 2,097,152. If our args exceed 30 KiB, we instead write them to a "response file" and
|
|
// pass that to zig, e.g. via 'zig build-lib @args.rsp'
|
|
// See @file syntax here: https://gcc.gnu.org/onlinedocs/gcc/Overall-Options.html
|
|
var args_length: usize = 0;
|
|
for (zig_args.items) |arg| {
|
|
args_length += arg.len + 1; // +1 to account for null terminator
|
|
}
|
|
if (args_length >= 30 * 1024) {
|
|
const local_cache_root = graph.local_cache_root;
|
|
const args_path: Path = .{ .root_dir = local_cache_root, .sub_path = "args" };
|
|
args_path.root_dir.handle.createDirPath(io, args_path.sub_path) catch |err|
|
|
return step.fail(maker, "failed creating directory {f}: {t}", .{ args_path, err });
|
|
|
|
const args_to_escape = zig_args.items[2..];
|
|
var escaped_args = try std.array_list.Managed([]const u8).initCapacity(arena, args_to_escape.len);
|
|
arg_blk: for (args_to_escape) |arg| {
|
|
for (arg, 0..) |c, arg_idx| {
|
|
if (c == '\\' or c == '"') {
|
|
// Slow path for arguments that need to be escaped. We'll need to allocate and copy
|
|
var escaped: std.ArrayList(u8) = .empty;
|
|
try escaped.ensureTotalCapacityPrecise(arena, arg.len + 1);
|
|
try escaped.appendSlice(arena, arg[0..arg_idx]);
|
|
for (arg[arg_idx..]) |to_escape| {
|
|
if (to_escape == '\\' or to_escape == '"') try escaped.append(arena, '\\');
|
|
try escaped.append(arena, to_escape);
|
|
}
|
|
escaped_args.appendAssumeCapacity(escaped.items);
|
|
continue :arg_blk;
|
|
}
|
|
}
|
|
escaped_args.appendAssumeCapacity(arg); // no escaping needed so just use original argument
|
|
}
|
|
|
|
// Write the args to zig-cache/args/<SHA256 hash of args> to avoid conflicts with
|
|
// other zig build commands running in parallel.
|
|
const partially_quoted = try std.mem.join(arena, "\" \"", escaped_args.items);
|
|
const args = try std.mem.concat(arena, u8, &[_][]const u8{ "\"", partially_quoted, "\"" });
|
|
|
|
var args_hash: [Sha256.digest_length]u8 = undefined;
|
|
Sha256.hash(args, &args_hash, .{});
|
|
var args_hex_hash: [Sha256.digest_length * 2]u8 = undefined;
|
|
_ = std.fmt.bufPrint(&args_hex_hash, "{x}", .{&args_hash}) catch unreachable;
|
|
|
|
const args_file = "args" ++ Dir.path.sep_str ++ args_hex_hash;
|
|
local_cache_root.handle.access(io, args_file, .{}) catch {
|
|
var af = local_cache_root.handle.createFileAtomic(io, args_file, .{
|
|
.replace = false,
|
|
.make_path = true,
|
|
}) catch |e| return step.fail(maker, "failed creating tmp args file {f}{s}: {t}", .{
|
|
local_cache_root, args_file, e,
|
|
});
|
|
defer af.deinit(io);
|
|
|
|
af.file.writeStreamingAll(io, args) catch |e| {
|
|
return step.fail(maker, "failed writing args data to tmp file {f}{s}: {t}", .{
|
|
local_cache_root, args_file, e,
|
|
});
|
|
};
|
|
// Note we can't clean up this file, not even after build
|
|
// success, because that might interfere with another build
|
|
// process that needs the same file.
|
|
af.link(io) catch |e| switch (e) {
|
|
error.PathAlreadyExists => {
|
|
// The args file was created by another concurrent build process.
|
|
},
|
|
else => |other_err| return step.fail(maker, "failed linking tmp file {f}{s}: {t}", .{
|
|
local_cache_root, args_file, other_err,
|
|
}),
|
|
};
|
|
};
|
|
|
|
const resolved_args_file = try mem.concat(arena, u8, &.{
|
|
"@", try local_cache_root.join(arena, &.{args_file}),
|
|
});
|
|
|
|
zig_args.shrinkRetainingCapacity(2);
|
|
try zig_args.append(gpa, resolved_args_file);
|
|
}
|
|
}
|
|
|
|
pub fn rebuildInFuzzMode(compile: *Compile, maker: *Maker, progress_node: std.Progress.Node) !Path {
|
|
const gpa = maker.graph.gpa;
|
|
|
|
compile.step.result_error_msgs.clearRetainingCapacity();
|
|
compile.step.result_stderr = "";
|
|
|
|
compile.step.result_error_bundle.deinit(gpa);
|
|
compile.step.result_error_bundle = std.zig.ErrorBundle.empty;
|
|
|
|
if (compile.step.result_failed_command) |cmd| {
|
|
gpa.free(cmd);
|
|
compile.step.result_failed_command = null;
|
|
}
|
|
|
|
const zig_args = &compile.zig_args;
|
|
zig_args.clearRetainingCapacity();
|
|
try lowerZigArgs(compile, maker, zig_args, true);
|
|
const maybe_output_bin_path = try compile.step.evalZigProcess(zig_args.items, progress_node, false, maker);
|
|
return maybe_output_bin_path.?;
|
|
}
|
|
|
|
pub const PkgConfigError = error{
|
|
PkgConfigCrashed,
|
|
PkgConfigFailed,
|
|
PkgConfigNotInstalled,
|
|
PkgConfigInvalidOutput,
|
|
};
|
|
|
|
pub const PkgConfigPkg = struct {
|
|
name: []const u8,
|
|
desc: []const u8,
|
|
};
|
|
|
|
fn execPkgConfigList(maker: *Maker, out_code: *u8) (PkgConfigError || Maker.RunError)![]const PkgConfigPkg {
|
|
const graph = maker.graph;
|
|
const process_arena = graph.arena; // TODO don't leak into process arena
|
|
const pkg_config_exe = graph.environ_map.get("PKG_CONFIG") orelse "pkg-config";
|
|
const stdout = try maker.runAllowFail(&[_][]const u8{ pkg_config_exe, "--list-all" }, out_code, .ignore);
|
|
var list = std.array_list.Managed(PkgConfigPkg).init(process_arena);
|
|
errdefer list.deinit();
|
|
var line_it = mem.tokenizeAny(u8, stdout, "\r\n");
|
|
while (line_it.next()) |line| {
|
|
if (mem.trim(u8, line, " \t").len == 0) continue;
|
|
var tok_it = mem.tokenizeAny(u8, line, " \t");
|
|
try list.append(PkgConfigPkg{
|
|
.name = tok_it.next() orelse return error.PkgConfigInvalidOutput,
|
|
.desc = tok_it.rest(),
|
|
});
|
|
}
|
|
return list.toOwnedSlice();
|
|
}
|
|
|
|
fn getPkgConfigList(b: *std.Build) ![]const PkgConfigPkg {
|
|
if (b.pkg_config_pkg_list) |res| {
|
|
return res;
|
|
}
|
|
var code: u8 = undefined;
|
|
if (execPkgConfigList(b, &code)) |list| {
|
|
b.pkg_config_pkg_list = list;
|
|
return list;
|
|
} else |err| {
|
|
const result = switch (err) {
|
|
error.ProcessTerminated => error.PkgConfigCrashed,
|
|
error.ExecNotSupported => error.PkgConfigFailed,
|
|
error.ExitCodeFailure => error.PkgConfigFailed,
|
|
error.FileNotFound => error.PkgConfigNotInstalled,
|
|
error.InvalidName => error.PkgConfigNotInstalled,
|
|
error.PkgConfigInvalidOutput => error.PkgConfigInvalidOutput,
|
|
else => return err,
|
|
};
|
|
b.pkg_config_pkg_list = result;
|
|
return result;
|
|
}
|
|
}
|
|
|
|
fn addBool(gpa: Allocator, args: *std.ArrayList([]const u8), arg: []const u8, opt: bool) !void {
|
|
if (opt) try args.append(gpa, arg);
|
|
}
|
|
|
|
fn addFlag(gpa: Allocator, args: *std.ArrayList([]const u8), comptime name: []const u8, opt: ?bool) !void {
|
|
const cond = opt orelse return;
|
|
try args.append(gpa, if (cond) "-f" ++ name else "-fno-" ++ name);
|
|
}
|
|
|
|
const PkgConfigResult = struct {
|
|
cflags: []const []const u8,
|
|
libs: []const []const u8,
|
|
};
|
|
|
|
/// Run pkg-config for the given library name and parse the output, returning the arguments
|
|
/// that should be passed to zig to link the given library.
|
|
fn runPkgConfig(compile: *const Compile, maker: *const Maker, lib_name: []const u8) !PkgConfigResult {
|
|
if (true) @panic("TODO");
|
|
const graph = maker.graph;
|
|
const wl_rpath_prefix = "-Wl,-rpath,";
|
|
|
|
const b = compile.step.owner;
|
|
const arena = b.allocator;
|
|
const pkg_name = match: {
|
|
// First we have to map the library name to pkg config name. Unfortunately,
|
|
// there are several examples where this is not straightforward:
|
|
// -lSDL2 -> pkg-config sdl2
|
|
// -lgdk-3 -> pkg-config gdk-3.0
|
|
// -latk-1.0 -> pkg-config atk
|
|
// -lpulse -> pkg-config libpulse
|
|
const pkgs = try getPkgConfigList(b);
|
|
|
|
// Exact match means instant winner.
|
|
for (pkgs) |pkg| {
|
|
if (mem.eql(u8, pkg.name, lib_name)) {
|
|
break :match pkg.name;
|
|
}
|
|
}
|
|
|
|
// Next we'll try ignoring case.
|
|
for (pkgs) |pkg| {
|
|
if (std.ascii.eqlIgnoreCase(pkg.name, lib_name)) {
|
|
break :match pkg.name;
|
|
}
|
|
}
|
|
|
|
// Prefixed "lib" or suffixed ".0".
|
|
for (pkgs) |pkg| {
|
|
if (std.ascii.findIgnoreCase(pkg.name, lib_name)) |pos| {
|
|
const prefix = pkg.name[0..pos];
|
|
const suffix = pkg.name[pos + lib_name.len ..];
|
|
if (prefix.len > 0 and !mem.eql(u8, prefix, "lib")) continue;
|
|
if (suffix.len > 0 and !mem.eql(u8, suffix, ".0")) continue;
|
|
break :match pkg.name;
|
|
}
|
|
}
|
|
|
|
// Trimming "-1.0".
|
|
if (mem.endsWith(u8, lib_name, "-1.0")) {
|
|
const trimmed_lib_name = lib_name[0 .. lib_name.len - "-1.0".len];
|
|
for (pkgs) |pkg| {
|
|
if (std.ascii.eqlIgnoreCase(pkg.name, trimmed_lib_name)) {
|
|
break :match pkg.name;
|
|
}
|
|
}
|
|
}
|
|
|
|
return error.PackageNotFound;
|
|
};
|
|
|
|
var code: u8 = undefined;
|
|
const pkg_config_exe = graph.environ_map.get("PKG_CONFIG") orelse "pkg-config";
|
|
const stdout = if (b.runAllowFail(&[_][]const u8{
|
|
pkg_config_exe,
|
|
pkg_name,
|
|
"--cflags",
|
|
"--libs",
|
|
}, &code, .ignore)) |stdout| stdout else |err| switch (err) {
|
|
error.ProcessTerminated => return error.PkgConfigCrashed,
|
|
error.ExecNotSupported => return error.PkgConfigFailed,
|
|
error.ExitCodeFailure => return error.PkgConfigFailed,
|
|
error.FileNotFound => return error.PkgConfigNotInstalled,
|
|
else => return err,
|
|
};
|
|
|
|
var zig_cflags: std.ArrayList([]const u8) = .empty;
|
|
defer zig_cflags.deinit(arena);
|
|
var zig_libs: std.ArrayList([]const u8) = .empty;
|
|
defer zig_libs.deinit(arena);
|
|
|
|
var arg_it = mem.tokenizeAny(u8, stdout, " \r\n\t");
|
|
while (arg_it.next()) |arg| {
|
|
if (mem.eql(u8, arg, "-I")) {
|
|
const dir = arg_it.next() orelse return error.PkgConfigInvalidOutput;
|
|
try zig_cflags.appendSlice(arena, &.{ "-I", dir });
|
|
} else if (mem.startsWith(u8, arg, "-I")) {
|
|
try zig_cflags.append(arena, arg);
|
|
} else if (mem.eql(u8, arg, "-L")) {
|
|
const dir = arg_it.next() orelse return error.PkgConfigInvalidOutput;
|
|
try zig_libs.appendSlice(arena, &.{ "-L", dir });
|
|
} else if (mem.startsWith(u8, arg, "-L")) {
|
|
try zig_libs.append(arena, arg);
|
|
} else if (mem.eql(u8, arg, "-l")) {
|
|
const lib = arg_it.next() orelse return error.PkgConfigInvalidOutput;
|
|
try zig_libs.appendSlice(arena, &.{ "-l", lib });
|
|
} else if (mem.startsWith(u8, arg, "-l")) {
|
|
try zig_libs.append(arena, arg);
|
|
} else if (mem.eql(u8, arg, "-D")) {
|
|
const macro = arg_it.next() orelse return error.PkgConfigInvalidOutput;
|
|
try zig_cflags.appendSlice(arena, &.{ "-D", macro });
|
|
} else if (mem.startsWith(u8, arg, "-D")) {
|
|
try zig_cflags.append(arena, arg);
|
|
} else if (mem.startsWith(u8, arg, wl_rpath_prefix)) {
|
|
try zig_cflags.appendSlice(arena, &.{ "-rpath", arg[wl_rpath_prefix.len..] });
|
|
} else if (b.debug_pkg_config) {
|
|
return compile.step.fail(maker, "unknown pkg-config flag '{s}'", .{arg});
|
|
}
|
|
}
|
|
|
|
try zig_cflags.shrinkToLen(arena);
|
|
try zig_libs.shrinkToLen(arena);
|
|
|
|
return .{
|
|
.cflags = zig_cflags.toOwnedSliceAssert(),
|
|
.libs = zig_libs.toOwnedSliceAssert(),
|
|
};
|
|
}
|
|
|
|
fn checkCompileErrors(compile: *Compile, maker: *Maker) !void {
|
|
if (true) @panic("TODO");
|
|
// Clear this field so that it does not get printed by the build runner.
|
|
const actual_eb = compile.step.result_error_bundle;
|
|
compile.step.result_error_bundle = .empty;
|
|
|
|
const arena = compile.step.owner.allocator;
|
|
|
|
const actual_errors = ae: {
|
|
var aw: std.Io.Writer.Allocating = .init(arena);
|
|
defer aw.deinit();
|
|
try actual_eb.renderToWriter(.{
|
|
.include_reference_trace = false,
|
|
.include_source_line = false,
|
|
}, &aw.writer);
|
|
break :ae try aw.toOwnedSlice();
|
|
};
|
|
|
|
// Render the expected lines into a string that we can compare verbatim.
|
|
var expected_generated: std.ArrayList(u8) = .empty;
|
|
const expect_errors = compile.expect_errors.?;
|
|
|
|
var actual_line_it = mem.splitScalar(u8, actual_errors, '\n');
|
|
|
|
// TODO merge this with the testing.expectEqualStrings logic, and also CheckFile
|
|
switch (expect_errors) {
|
|
.starts_with => |expect_starts_with| {
|
|
if (std.mem.startsWith(u8, actual_errors, expect_starts_with)) return;
|
|
return compile.step.fail(maker,
|
|
\\
|
|
\\========= should start with: ============
|
|
\\{s}
|
|
\\========= but not found: ================
|
|
\\{s}
|
|
\\=========================================
|
|
, .{ expect_starts_with, actual_errors });
|
|
},
|
|
.contains => |expect_line| {
|
|
while (actual_line_it.next()) |actual_line| {
|
|
if (!matchCompileError(actual_line, expect_line)) continue;
|
|
return;
|
|
}
|
|
|
|
return compile.step.fail(maker,
|
|
\\
|
|
\\========= should contain: ===============
|
|
\\{s}
|
|
\\========= but not found: ================
|
|
\\{s}
|
|
\\=========================================
|
|
, .{ expect_line, actual_errors });
|
|
},
|
|
.stderr_contains => |expect_line| {
|
|
const actual_stderr: []const u8 = if (compile.step.result_error_msgs.items.len > 0)
|
|
compile.step.result_error_msgs.items[0]
|
|
else
|
|
&.{};
|
|
compile.step.result_error_msgs.clearRetainingCapacity();
|
|
|
|
var stderr_line_it = mem.splitScalar(u8, actual_stderr, '\n');
|
|
|
|
while (stderr_line_it.next()) |actual_line| {
|
|
if (!matchCompileError(actual_line, expect_line)) continue;
|
|
return;
|
|
}
|
|
|
|
return compile.step.fail(maker,
|
|
\\
|
|
\\========= should contain: ===============
|
|
\\{s}
|
|
\\========= but not found: ================
|
|
\\{s}
|
|
\\=========================================
|
|
, .{ expect_line, actual_stderr });
|
|
},
|
|
.exact => |expect_lines| {
|
|
for (expect_lines) |expect_line| {
|
|
const actual_line = actual_line_it.next() orelse {
|
|
try expected_generated.appendSlice(arena, expect_line);
|
|
try expected_generated.append(arena, '\n');
|
|
continue;
|
|
};
|
|
if (matchCompileError(actual_line, expect_line)) {
|
|
try expected_generated.appendSlice(arena, actual_line);
|
|
try expected_generated.append(arena, '\n');
|
|
continue;
|
|
}
|
|
try expected_generated.appendSlice(arena, expect_line);
|
|
try expected_generated.append(arena, '\n');
|
|
}
|
|
|
|
if (mem.eql(u8, expected_generated.items, actual_errors)) return;
|
|
|
|
return compile.step.fail(maker,
|
|
\\
|
|
\\========= expected: =====================
|
|
\\{s}
|
|
\\========= but found: ====================
|
|
\\{s}
|
|
\\=========================================
|
|
, .{ expected_generated.items, actual_errors });
|
|
},
|
|
}
|
|
}
|
|
|
|
fn matchCompileError(actual: []const u8, expected: []const u8) bool {
|
|
if (mem.endsWith(u8, actual, expected)) return true;
|
|
if (mem.startsWith(u8, expected, ":?:?: ")) {
|
|
if (mem.endsWith(u8, actual, expected[":?:?: ".len..])) return true;
|
|
}
|
|
// We scan for /?/ in expected line and if there is a match, we match everything
|
|
// up to and after /?/.
|
|
const expected_trim = mem.trim(u8, expected, " ");
|
|
if (mem.find(u8, expected_trim, "/?/")) |index| {
|
|
const actual_trim = mem.trim(u8, actual, " ");
|
|
const lhs = expected_trim[0..index];
|
|
const rhs = expected_trim[index + "/?/".len ..];
|
|
if (mem.startsWith(u8, actual_trim, lhs) and mem.endsWith(u8, actual_trim, rhs)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
fn moduleNeedsCliArg(mod: *const Configuration.Module, conf: *const Configuration) bool {
|
|
return for (0..mod.link_objects.len) |i| switch (mod.link_objects.tag(conf.extra, i)) {
|
|
.c_source_file, .c_source_files, .assembly_file, .win32_resource_file => break true,
|
|
else => continue,
|
|
} else false;
|
|
}
|
|
|
|
const CliNamedModules = struct {
|
|
modules: std.AutoArrayHashMapUnmanaged(Configuration.Module.Index, void),
|
|
names: std.StringArrayHashMapUnmanaged(void),
|
|
|
|
/// Traverse the whole dependency graph and give every module a unique
|
|
/// name, ideally one named after what it's called somewhere in the graph.
|
|
/// It will help here to have both a mapping from module to name and a set
|
|
/// of all the currently-used names.
|
|
fn init(
|
|
arena: Allocator,
|
|
module_graph: *ModuleGraph,
|
|
compile_index: Configuration.Step.Index,
|
|
maker: *const Maker,
|
|
) Allocator.Error!CliNamedModules {
|
|
const conf = &maker.scanned_config.configuration;
|
|
const conf_compile = compile_index.ptr(conf).extended.get(conf.extra).compile;
|
|
|
|
var result: CliNamedModules = .{
|
|
.modules = .{},
|
|
.names = .{},
|
|
};
|
|
const modules = try getModuleList(arena, module_graph, conf_compile.root_module, conf);
|
|
{
|
|
assert(conf_compile.root_module == modules.keys()[0]);
|
|
try result.modules.put(arena, conf_compile.root_module, {});
|
|
try result.names.put(arena, "root", {});
|
|
}
|
|
for (modules.keys()[1..], modules.values()[1..]) |mod, orig_name| {
|
|
const orig_name_slice = orig_name.slice(conf);
|
|
var name: []const u8 = orig_name_slice;
|
|
var n: usize = 0;
|
|
while (true) {
|
|
const gop = try result.names.getOrPut(arena, name);
|
|
if (!gop.found_existing) {
|
|
try result.modules.putNoClobber(arena, mod, {});
|
|
break;
|
|
}
|
|
name = try allocPrint(arena, "{s}{d}", .{ orig_name_slice, n });
|
|
n += 1;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
|
|
fn getCompileDependencies(
|
|
arena: Allocator,
|
|
module_graph: *ModuleGraph,
|
|
conf: *const Configuration,
|
|
start: Configuration.Step.Index,
|
|
chase_dynamic: bool,
|
|
) ![]const Configuration.Step.Index {
|
|
var compiles: std.AutoArrayHashMapUnmanaged(Configuration.Step.Index, void) = .empty;
|
|
var compiles_i: usize = 0;
|
|
|
|
try compiles.putNoClobber(arena, start, {});
|
|
|
|
while (compiles_i < compiles.count()) : (compiles_i += 1) {
|
|
const step = compiles.keys()[compiles_i].ptr(conf);
|
|
const compile = step.extended.get(conf.extra).compile;
|
|
const modules = try getModuleList(arena, module_graph, compile.root_module, conf);
|
|
|
|
for (modules.keys()) |mod_index| {
|
|
const mod = mod_index.get(conf);
|
|
for (0..mod.link_objects.len) |i| {
|
|
switch (mod.link_objects.get(conf.extra, i)) {
|
|
.other_step => |other_compile_index| {
|
|
const other_compile = other_compile_index.ptr(conf).extended.get(conf.extra).compile;
|
|
if (!chase_dynamic and other_compile.isDynamicLibrary()) continue;
|
|
try compiles.put(arena, other_compile_index, {});
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return compiles.keys();
|
|
}
|
|
|
|
/// Returned pointer expires upon next call to `getModuleList`.
|
|
fn getModuleList(
|
|
arena: Allocator,
|
|
module_graph: *ModuleGraph,
|
|
root_module: Configuration.Module.Index,
|
|
conf: *const Configuration,
|
|
) !*ModuleList {
|
|
const gop = try module_graph.getOrPutAdapted(arena, root_module, @as(ModuleListContext.Adapter, .{}));
|
|
const modules = gop.key_ptr;
|
|
|
|
if (gop.found_existing) return modules;
|
|
modules.* = .empty;
|
|
try modules.putNoClobber(arena, root_module, .root);
|
|
|
|
var i: usize = 0;
|
|
|
|
while (i < modules.entries.len) : (i += 1) {
|
|
const dep_index = modules.keys()[i];
|
|
const dep = dep_index.get(conf);
|
|
const imports = dep.import_table.get(conf).imports;
|
|
try modules.ensureUnusedCapacity(arena, imports.mal.len);
|
|
for (imports.mal.items(.name), imports.mal.items(.module)) |import_name, other_mod|
|
|
modules.putAssumeCapacity(other_mod, import_name);
|
|
}
|
|
|
|
return modules;
|
|
}
|
|
|
|
fn appendModuleFlags(
|
|
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 graph = maker.graph;
|
|
const arena = graph.arena; // TODO don't leak into the process arena
|
|
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, "red-zone", m.flags2.red_zone.toBool());
|
|
try addFlag(gpa, zig_args, "no-builtin", m.flags2.no_builtin.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)) |target| {
|
|
// Communicate the query via CLI since it's more compact.
|
|
if (target.query.get(conf)) |query| {
|
|
try zig_args.ensureUnusedCapacity(gpa, 6);
|
|
|
|
if (true) @panic("TODO");
|
|
|
|
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| {
|
|
const dynamic_linker_slice = dynamic_linker.slice(conf);
|
|
if (dynamic_linker_slice.len != 0) {
|
|
zig_args.appendAssumeCapacity("--dynamic-linker");
|
|
zig_args.appendAssumeCapacity(dynamic_linker_slice);
|
|
} else {
|
|
zig_args.appendAssumeCapacity("--no-dynamic-linker");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (m.export_symbol_names.slice) |symbol_name| {
|
|
try zig_args.append(gpa, try allocPrint(arena, "--export={s}", .{symbol_name.slice(conf)}));
|
|
}
|
|
|
|
for (0..m.include_dirs.len) |i|
|
|
try appendIncludeDirFlags(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));
|
|
},
|
|
};
|
|
}
|
|
|
|
fn appendIncludeDirFlags(
|
|
include_dir: Configuration.Module.IncludeDir,
|
|
zig_args: *std.ArrayList([]const u8),
|
|
asking_step: Configuration.Step.Index,
|
|
maker: *const Maker,
|
|
) !void {
|
|
const gpa = maker.gpa;
|
|
const graph = maker.graph;
|
|
const arena = graph.arena; // TODO don't leak into the process arena
|
|
|
|
try zig_args.ensureUnusedCapacity(gpa, 2);
|
|
switch (include_dir) {
|
|
.path => |lp| {
|
|
zig_args.appendAssumeCapacity("-I");
|
|
zig_args.appendAssumeCapacity(try maker.resolveLazyPathIndexAbs(arena, lp, asking_step));
|
|
},
|
|
.path_system => |lp| {
|
|
zig_args.appendAssumeCapacity("-isystem");
|
|
zig_args.appendAssumeCapacity(try maker.resolveLazyPathIndexAbs(arena, lp, asking_step));
|
|
},
|
|
.path_after => |lp| {
|
|
zig_args.appendAssumeCapacity("-idirafter");
|
|
zig_args.appendAssumeCapacity(try maker.resolveLazyPathIndexAbs(arena, lp, asking_step));
|
|
},
|
|
.framework_path => |lp| {
|
|
zig_args.appendAssumeCapacity("-F");
|
|
zig_args.appendAssumeCapacity(try maker.resolveLazyPathIndexAbs(arena, lp, asking_step));
|
|
},
|
|
.framework_path_system => |lp| {
|
|
zig_args.appendAssumeCapacity("-iframework");
|
|
zig_args.appendAssumeCapacity(try maker.resolveLazyPathIndexAbs(arena, lp, asking_step));
|
|
},
|
|
.config_header_step => |ch| {
|
|
zig_args.appendAssumeCapacity("-I");
|
|
if (true) @panic("TODO");
|
|
ch.getOutputDir();
|
|
},
|
|
.other_step => |comp| {
|
|
zig_args.appendAssumeCapacity("-I");
|
|
if (true) @panic("TODO");
|
|
comp.installed_headers_include_tree.?.getDirectory();
|
|
},
|
|
.embed_path => |lazy_path| {
|
|
try zig_args.append(
|
|
gpa,
|
|
try allocPrint(arena, "--embed-dir={f}", .{
|
|
try maker.resolveLazyPathIndex(arena, lazy_path, asking_step),
|
|
}),
|
|
);
|
|
},
|
|
}
|
|
}
|