mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2025-12-06 06:13:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

std.Target: add DynamicLinker

Browse Source
This commit is contained in:
Andrew Kelley 2023-12-04 15:26:57 -07:00
parent 3179f58c41
commit dbdb87502d
16 changed files with 1280 additions and 1295 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -516,7 +516,6 @@ set(ZIG_STAGE2_SOURCES
"${CMAKE_SOURCE_DIR}/lib/std/zig/string_literal.zig" "${CMAKE_SOURCE_DIR}/lib/std/zig/string_literal.zig"
"${CMAKE_SOURCE_DIR}/lib/std/zig/system.zig" "${CMAKE_SOURCE_DIR}/lib/std/zig/system.zig"
"${CMAKE_SOURCE_DIR}/lib/std/zig/system/NativePaths.zig" "${CMAKE_SOURCE_DIR}/lib/std/zig/system/NativePaths.zig"
"${CMAKE_SOURCE_DIR}/lib/std/zig/system/NativeTargetInfo.zig"
"${CMAKE_SOURCE_DIR}/lib/std/zig/system/x86.zig" "${CMAKE_SOURCE_DIR}/lib/std/zig/system/x86.zig"
"${CMAKE_SOURCE_DIR}/lib/std/zig/tokenizer.zig" "${CMAKE_SOURCE_DIR}/lib/std/zig/tokenizer.zig"
"${CMAKE_SOURCE_DIR}/src/Air.zig" "${CMAKE_SOURCE_DIR}/src/Air.zig"

4
lib/build_runner.zig
View File

@ -46,11 +46,9 @@ pub fn main() !void {
return error.InvalidArgs; return error.InvalidArgs;
}; };
const detected = try std.zig.system.NativeTargetInfo.detect(.{});
const host: std.Build.ResolvedTarget = .{ const host: std.Build.ResolvedTarget = .{
.query = .{}, .query = .{},
.target = detected.target, .target = try std.zig.system.resolveTargetQuery(.{}),
.dynamic_linker = detected.dynamic_linker,
}; };
const build_root_directory: std.Build.Cache.Directory = .{ const build_root_directory: std.Build.Cache.Directory = .{

15
lib/std/Build.zig
View File

@ -2129,14 +2129,6 @@ pub fn hex64(x: u64) [16]u8 {
pub const ResolvedTarget = struct { pub const ResolvedTarget = struct {
query: Target.Query, query: Target.Query,
target: Target, target: Target,
dynamic_linker: Target.DynamicLinker,
pub fn toNativeTargetInfo(self: ResolvedTarget) std.zig.system.NativeTargetInfo {
return .{
.target = self.target,
.dynamic_linker = self.dynamic_linker,
};
}
}; };
/// Converts a target query into a fully resolved target that can be passed to /// Converts a target query into a fully resolved target that can be passed to
@ -2146,13 +2138,10 @@ pub fn resolveTargetQuery(b: *Build, query: Target.Query) ResolvedTarget {
// resolved via a WASI API or via the build protocol. // resolved via a WASI API or via the build protocol.
_ = b; _ = b;
const result = std.zig.system.NativeTargetInfo.detect(query) catch
@panic("unable to resolve target query");
return .{ return .{
.query = query, .query = query,
.target = result.target, .target = std.zig.system.resolveTargetQuery(query) catch
.dynamic_linker = result.dynamic_linker, @panic("unable to resolve target query"),
}; };
} }

1
lib/std/Build/Module.zig
View File

@ -746,5 +746,4 @@ const Module = @This();
const std = @import("std"); const std = @import("std");
const assert = std.debug.assert; const assert = std.debug.assert;
const LazyPath = std.Build.LazyPath; const LazyPath = std.Build.LazyPath;
const NativeTargetInfo = std.zig.system.NativeTargetInfo;
const Step = std.Build.Step; const Step = std.Build.Step;

1
lib/std/Build/Step/Compile.zig
View File

@ -9,7 +9,6 @@ const StringHashMap = std.StringHashMap;
const Sha256 = std.crypto.hash.sha2.Sha256; const Sha256 = std.crypto.hash.sha2.Sha256;
const Allocator = mem.Allocator; const Allocator = mem.Allocator;
const Step = std.Build.Step; const Step = std.Build.Step;
const NativeTargetInfo = std.zig.system.NativeTargetInfo;
const LazyPath = std.Build.LazyPath; const LazyPath = std.Build.LazyPath;
const PkgConfigPkg = std.Build.PkgConfigPkg; const PkgConfigPkg = std.Build.PkgConfigPkg;
const PkgConfigError = std.Build.PkgConfigError; const PkgConfigError = std.Build.PkgConfigError;

4
lib/std/Build/Step/Options.zig
View File

@ -294,11 +294,9 @@ test Options {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator); var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit(); defer arena.deinit();
const detected = try std.zig.system.NativeTargetInfo.detect(.{});
const host: std.Build.ResolvedTarget = .{ const host: std.Build.ResolvedTarget = .{
.query = .{}, .query = .{},
.target = detected.target, .target = try std.zig.system.resolveTargetQuery(.{}),
.dynamic_linker = detected.dynamic_linker,
}; };
var cache: std.Build.Cache = .{ var cache: std.Build.Cache = .{

6
lib/std/Build/Step/Run.zig
View File

@ -678,8 +678,8 @@ fn runCommand(
const need_cross_glibc = exe.rootModuleTarget().isGnuLibC() and const need_cross_glibc = exe.rootModuleTarget().isGnuLibC() and
exe.is_linking_libc; exe.is_linking_libc;
const other_target_info = exe.root_module.target.?.toNativeTargetInfo(); const other_target = exe.root_module.target.?.target;
switch (b.host.toNativeTargetInfo().getExternalExecutor(&other_target_info, .{ switch (std.zig.system.getExternalExecutor(b.host.target, &other_target, .{
.qemu_fixes_dl = need_cross_glibc and b.glibc_runtimes_dir != null, .qemu_fixes_dl = need_cross_glibc and b.glibc_runtimes_dir != null,
.link_libc = exe.is_linking_libc, .link_libc = exe.is_linking_libc,
})) { })) {
@ -752,7 +752,7 @@ fn runCommand(
.bad_dl => |foreign_dl| { .bad_dl => |foreign_dl| {
if (allow_skip) return error.MakeSkipped; if (allow_skip) return error.MakeSkipped;
const host_dl = b.host.dynamic_linker.get() orelse "(none)"; const host_dl = b.host.target.dynamic_linker.get() orelse "(none)";
return step.fail( return step.fail(
\\the host system is unable to execute binaries from the target \\the host system is unable to execute binaries from the target

72
lib/std/Target.zig
View File

@ -1,7 +1,13 @@
//! All the details about the machine that will be executing code.
//! Unlike `Query` which might leave some things as "default" or "host", this
//! data is fully resolved into a concrete set of OS versions, CPU features,
//! etc.
cpu: Cpu, cpu: Cpu,
os: Os, os: Os,
abi: Abi, abi: Abi,
ofmt: ObjectFormat, ofmt: ObjectFormat,
dynamic_linker: DynamicLinker = DynamicLinker.none,
pub const Query = @import("Target/Query.zig"); pub const Query = @import("Target/Query.zig");
@ -1529,13 +1535,19 @@ pub inline fn hasDynamicLinker(self: Target) bool {
} }
pub const DynamicLinker = struct { pub const DynamicLinker = struct {
/// Contains the memory used to store the dynamic linker path. This field should /// Contains the memory used to store the dynamic linker path. This field
/// not be used directly. See `get` and `set`. This field exists so that this API requires no allocator. /// should not be used directly. See `get` and `set`. This field exists so
buffer: [255]u8 = undefined, /// that this API requires no allocator.
buffer: [255]u8,
/// Used to construct the dynamic linker path. This field should not be used /// Used to construct the dynamic linker path. This field should not be used
/// directly. See `get` and `set`. /// directly. See `get` and `set`.
max_byte: ?u8 = null, max_byte: ?u8,
pub const none: DynamicLinker = .{
.buffer = undefined,
.max_byte = null,
};
/// Asserts that the length is less than or equal to 255 bytes. /// Asserts that the length is less than or equal to 255 bytes.
pub fn init(dl_or_null: ?[]const u8) DynamicLinker { pub fn init(dl_or_null: ?[]const u8) DynamicLinker {
@ -1561,8 +1573,12 @@ pub const DynamicLinker = struct {
} }
}; };
pub fn standardDynamicLinkerPath(self: Target) DynamicLinker { pub fn standardDynamicLinkerPath(target: Target) DynamicLinker {
var result: DynamicLinker = .{}; return standardDynamicLinkerPath_cpu_os_abi(target.cpu, target.os.tag, target.abi);
}
pub fn standardDynamicLinkerPath_cpu_os_abi(cpu: Cpu, os_tag: Os.Tag, abi: Abi) DynamicLinker {
var result = DynamicLinker.none;
const S = struct { const S = struct {
fn print(r: *DynamicLinker, comptime fmt: []const u8, args: anytype) DynamicLinker { fn print(r: *DynamicLinker, comptime fmt: []const u8, args: anytype) DynamicLinker {
r.max_byte = @as(u8, @intCast((std.fmt.bufPrint(&r.buffer, fmt, args) catch unreachable).len - 1)); r.max_byte = @as(u8, @intCast((std.fmt.bufPrint(&r.buffer, fmt, args) catch unreachable).len - 1));
@ -1577,32 +1593,32 @@ pub fn standardDynamicLinkerPath(self: Target) DynamicLinker {
const print = S.print; const print = S.print;
const copy = S.copy; const copy = S.copy;
if (self.abi == .android) { if (abi == .android) {
const suffix = if (self.ptrBitWidth() == 64) "64" else ""; const suffix = if (ptrBitWidth_cpu_abi(cpu, abi) == 64) "64" else "";
return print(&result, "/system/bin/linker{s}", .{suffix}); return print(&result, "/system/bin/linker{s}", .{suffix});
} }
if (self.abi.isMusl()) { if (abi.isMusl()) {
const is_arm = switch (self.cpu.arch) { const is_arm = switch (cpu.arch) {
.arm, .armeb, .thumb, .thumbeb => true, .arm, .armeb, .thumb, .thumbeb => true,
else => false, else => false,
}; };
const arch_part = switch (self.cpu.arch) { const arch_part = switch (cpu.arch) {
.arm, .thumb => "arm", .arm, .thumb => "arm",
.armeb, .thumbeb => "armeb", .armeb, .thumbeb => "armeb",
else => |arch| @tagName(arch), else => |arch| @tagName(arch),
}; };
const arch_suffix = if (is_arm and self.abi.floatAbi() == .hard) "hf" else ""; const arch_suffix = if (is_arm and abi.floatAbi() == .hard) "hf" else "";
return print(&result, "/lib/ld-musl-{s}{s}.so.1", .{ arch_part, arch_suffix }); return print(&result, "/lib/ld-musl-{s}{s}.so.1", .{ arch_part, arch_suffix });
} }
switch (self.os.tag) { switch (os_tag) {
.freebsd => return copy(&result, "/libexec/ld-elf.so.1"), .freebsd => return copy(&result, "/libexec/ld-elf.so.1"),
.netbsd => return copy(&result, "/libexec/ld.elf_so"), .netbsd => return copy(&result, "/libexec/ld.elf_so"),
.openbsd => return copy(&result, "/usr/libexec/ld.so"), .openbsd => return copy(&result, "/usr/libexec/ld.so"),
.dragonfly => return copy(&result, "/libexec/ld-elf.so.2"), .dragonfly => return copy(&result, "/libexec/ld-elf.so.2"),
.solaris, .illumos => return copy(&result, "/lib/64/ld.so.1"), .solaris, .illumos => return copy(&result, "/lib/64/ld.so.1"),
.linux => switch (self.cpu.arch) { .linux => switch (cpu.arch) {
.x86, .x86,
.sparc, .sparc,
.sparcel, .sparcel,
@ -1616,7 +1632,7 @@ pub fn standardDynamicLinkerPath(self: Target) DynamicLinker {
.armeb, .armeb,
.thumb, .thumb,
.thumbeb, .thumbeb,
=> return copy(&result, switch (self.abi.floatAbi()) { => return copy(&result, switch (abi.floatAbi()) {
.hard => "/lib/ld-linux-armhf.so.3", .hard => "/lib/ld-linux-armhf.so.3",
else => "/lib/ld-linux.so.3", else => "/lib/ld-linux.so.3",
}), }),
@ -1626,12 +1642,12 @@ pub fn standardDynamicLinkerPath(self: Target) DynamicLinker {
.mips64, .mips64,
.mips64el, .mips64el,
=> { => {
const lib_suffix = switch (self.abi) { const lib_suffix = switch (abi) {
.gnuabin32, .gnux32 => "32", .gnuabin32, .gnux32 => "32",
.gnuabi64 => "64", .gnuabi64 => "64",
else => "", else => "",
}; };
const is_nan_2008 = mips.featureSetHas(self.cpu.features, .nan2008); const is_nan_2008 = mips.featureSetHas(cpu.features, .nan2008);
const loader = if (is_nan_2008) "ld-linux-mipsn8.so.1" else "ld.so.1"; const loader = if (is_nan_2008) "ld-linux-mipsn8.so.1" else "ld.so.1";
return print(&result, "/lib{s}/{s}", .{ lib_suffix, loader }); return print(&result, "/lib{s}/{s}", .{ lib_suffix, loader });
}, },
@ -1640,7 +1656,7 @@ pub fn standardDynamicLinkerPath(self: Target) DynamicLinker {
.powerpc64, .powerpc64le => return copy(&result, "/lib64/ld64.so.2"), .powerpc64, .powerpc64le => return copy(&result, "/lib64/ld64.so.2"),
.s390x => return copy(&result, "/lib64/ld64.so.1"), .s390x => return copy(&result, "/lib64/ld64.so.1"),
.sparc64 => return copy(&result, "/lib64/ld-linux.so.2"), .sparc64 => return copy(&result, "/lib64/ld-linux.so.2"),
.x86_64 => return copy(&result, switch (self.abi) { .x86_64 => return copy(&result, switch (abi) {
.gnux32 => "/libx32/ld-linux-x32.so.2", .gnux32 => "/libx32/ld-linux-x32.so.2",
else => "/lib64/ld-linux-x86-64.so.2", else => "/lib64/ld-linux-x86-64.so.2",
}), }),
@ -1862,17 +1878,17 @@ pub fn maxIntAlignment(target: Target) u16 {
}; };
} }
pub fn ptrBitWidth(target: Target) u16 { pub fn ptrBitWidth_cpu_abi(cpu: Cpu, abi: Abi) u16 {
switch (target.abi) { switch (abi) {
.gnux32, .muslx32, .gnuabin32, .gnuilp32 => return 32, .gnux32, .muslx32, .gnuabin32, .gnuilp32 => return 32,
.gnuabi64 => return 64, .gnuabi64 => return 64,
else => {}, else => {},
} }
switch (target.cpu.arch) { return switch (cpu.arch) {
.avr, .avr,
.msp430, .msp430,
.spu_2, .spu_2,
=> return 16, => 16,
.arc, .arc,
.arm, .arm,
@ -1908,7 +1924,7 @@ pub fn ptrBitWidth(target: Target) u16 {
.loongarch32, .loongarch32,
.dxil, .dxil,
.xtensa, .xtensa,
=> return 32, => 32,
.aarch64, .aarch64,
.aarch64_be, .aarch64_be,
@ -1933,10 +1949,14 @@ pub fn ptrBitWidth(target: Target) u16 {
.ve, .ve,
.spirv64, .spirv64,
.loongarch64, .loongarch64,
=> return 64, => 64,
.sparc => return if (std.Target.sparc.featureSetHas(target.cpu.features, .v9)) 64 else 32, .sparc => if (std.Target.sparc.featureSetHas(cpu.features, .v9)) 64 else 32,
} };
}
pub fn ptrBitWidth(target: Target) u16 {
return ptrBitWidth_cpu_abi(target.cpu, target.abi);
} }
pub fn stackAlignment(target: Target) u16 { pub fn stackAlignment(target: Target) u16 {

26
lib/std/Target/Query.zig
View File

@ -34,7 +34,7 @@ abi: ?Target.Abi = null,
/// When `os_tag` is `null`, then `null` means native. Otherwise it means the standard path /// When `os_tag` is `null`, then `null` means native. Otherwise it means the standard path
/// based on the `os_tag`. /// based on the `os_tag`.
dynamic_linker: DynamicLinker = DynamicLinker{}, dynamic_linker: Target.DynamicLinker = Target.DynamicLinker.none,
/// `null` means default for the cpu/arch/os combo. /// `null` means default for the cpu/arch/os combo.
ofmt: ?Target.ObjectFormat = null, ofmt: ?Target.ObjectFormat = null,
@ -61,8 +61,6 @@ pub const OsVersion = union(enum) {
pub const SemanticVersion = std.SemanticVersion; pub const SemanticVersion = std.SemanticVersion;
pub const DynamicLinker = Target.DynamicLinker;
pub fn fromTarget(target: Target) Query { pub fn fromTarget(target: Target) Query {
var result: Query = .{ var result: Query = .{
.cpu_arch = target.cpu.arch, .cpu_arch = target.cpu.arch,
@ -164,7 +162,7 @@ fn updateOsVersionRange(self: *Query, os: Target.Os) void {
} }
} }
/// TODO deprecated, use `std.zig.system.NativeTargetInfo.detect`. /// TODO deprecated, use `std.zig.system.resolveTargetQuery`.
pub fn toTarget(self: Query) Target { pub fn toTarget(self: Query) Target {
return .{ return .{
.cpu = self.getCpu(), .cpu = self.getCpu(),
@ -232,7 +230,7 @@ pub fn parse(args: ParseOptions) !Query {
const diags = args.diagnostics orelse &dummy_diags; const diags = args.diagnostics orelse &dummy_diags;
var result: Query = .{ var result: Query = .{
.dynamic_linker = DynamicLinker.init(args.dynamic_linker), .dynamic_linker = Target.DynamicLinker.init(args.dynamic_linker),
}; };
var it = mem.splitScalar(u8, args.arch_os_abi, '-'); var it = mem.splitScalar(u8, args.arch_os_abi, '-');
@ -379,13 +377,13 @@ test parseVersion {
try std.testing.expectError(error.InvalidVersion, parseVersion("1.2.3.4")); try std.testing.expectError(error.InvalidVersion, parseVersion("1.2.3.4"));
} }
/// TODO deprecated, use `std.zig.system.NativeTargetInfo.detect`. /// TODO deprecated, use `std.zig.system.resolveTargetQuery`.
pub fn getCpu(self: Query) Target.Cpu { pub fn getCpu(self: Query) Target.Cpu {
switch (self.cpu_model) { switch (self.cpu_model) {
.native => { .native => {
// This works when doing `zig build` because Zig generates a build executable using // This works when doing `zig build` because Zig generates a build executable using
// native CPU model & features. However this will not be accurate otherwise, and // native CPU model & features. However this will not be accurate otherwise, and
// will need to be integrated with `std.zig.system.NativeTargetInfo.detect`. // will need to be integrated with `std.zig.system.resolveTargetQuery`.
return builtin.cpu; return builtin.cpu;
}, },
.baseline => { .baseline => {
@ -396,7 +394,7 @@ pub fn getCpu(self: Query) Target.Cpu {
.determined_by_cpu_arch => if (self.cpu_arch == null) { .determined_by_cpu_arch => if (self.cpu_arch == null) {
// This works when doing `zig build` because Zig generates a build executable using // This works when doing `zig build` because Zig generates a build executable using
// native CPU model & features. However this will not be accurate otherwise, and // native CPU model & features. However this will not be accurate otherwise, and
// will need to be integrated with `std.zig.system.NativeTargetInfo.detect`. // will need to be integrated with `std.zig.system.resolveTargetQuery`.
return builtin.cpu; return builtin.cpu;
} else { } else {
var adjusted_baseline = Target.Cpu.baseline(self.getCpuArch()); var adjusted_baseline = Target.Cpu.baseline(self.getCpuArch());
@ -426,11 +424,11 @@ pub fn getCpuFeatures(self: Query) Target.Cpu.Feature.Set {
return self.getCpu().features; return self.getCpu().features;
} }
/// TODO deprecated, use `std.zig.system.NativeTargetInfo.detect`. /// TODO deprecated, use `std.zig.system.resolveTargetQuery`.
pub fn getOs(self: Query) Target.Os { pub fn getOs(self: Query) Target.Os {
// `builtin.os` works when doing `zig build` because Zig generates a build executable using // `builtin.os` works when doing `zig build` because Zig generates a build executable using
// native OS version range. However this will not be accurate otherwise, and // native OS version range. However this will not be accurate otherwise, and
// will need to be integrated with `std.zig.system.NativeTargetInfo.detect`. // will need to be integrated with `std.zig.system.resolveTargetQuery`.
var adjusted_os = if (self.os_tag) |os_tag| os_tag.defaultVersionRange(self.getCpuArch()) else builtin.os; var adjusted_os = if (self.os_tag) |os_tag| os_tag.defaultVersionRange(self.getCpuArch()) else builtin.os;
if (self.os_version_min) |min| switch (min) { if (self.os_version_min) |min| switch (min) {
@ -463,7 +461,7 @@ pub fn getOsTag(self: Query) Target.Os.Tag {
return self.os_tag orelse builtin.os.tag; return self.os_tag orelse builtin.os.tag;
} }
/// TODO deprecated, use `std.zig.system.NativeTargetInfo.detect`. /// TODO deprecated, use `std.zig.system.resolveTargetQuery`.
pub fn getOsVersionMin(self: Query) OsVersion { pub fn getOsVersionMin(self: Query) OsVersion {
if (self.os_version_min) |version_min| return version_min; if (self.os_version_min) |version_min| return version_min;
var tmp: Query = undefined; var tmp: Query = undefined;
@ -471,7 +469,7 @@ pub fn getOsVersionMin(self: Query) OsVersion {
return tmp.os_version_min.?; return tmp.os_version_min.?;
} }
/// TODO deprecated, use `std.zig.system.NativeTargetInfo.detect`. /// TODO deprecated, use `std.zig.system.resolveTargetQuery`.
pub fn getOsVersionMax(self: Query) OsVersion { pub fn getOsVersionMax(self: Query) OsVersion {
if (self.os_version_max) |version_max| return version_max; if (self.os_version_max) |version_max| return version_max;
var tmp: Query = undefined; var tmp: Query = undefined;
@ -479,14 +477,14 @@ pub fn getOsVersionMax(self: Query) OsVersion {
return tmp.os_version_max.?; return tmp.os_version_max.?;
} }
/// TODO deprecated, use `std.zig.system.NativeTargetInfo.detect`. /// TODO deprecated, use `std.zig.system.resolveTargetQuery`.
pub fn getAbi(self: Query) Target.Abi { pub fn getAbi(self: Query) Target.Abi {
if (self.abi) |abi| return abi; if (self.abi) |abi| return abi;
if (self.os_tag == null) { if (self.os_tag == null) {
// This works when doing `zig build` because Zig generates a build executable using // This works when doing `zig build` because Zig generates a build executable using
// native CPU model & features. However this will not be accurate otherwise, and // native CPU model & features. However this will not be accurate otherwise, and
// will need to be integrated with `std.zig.system.NativeTargetInfo.detect`. // will need to be integrated with `std.zig.system.resolveTargetQuery`.
return builtin.abi; return builtin.abi;
} }

1118
lib/std/zig/system.zig
View File

File diff suppressed because it is too large Load Diff

4
lib/std/zig/system/NativePaths.zig
View File

@ -5,7 +5,6 @@ const process = std.process;
const mem = std.mem; const mem = std.mem;
const NativePaths = @This(); const NativePaths = @This();
const NativeTargetInfo = std.zig.system.NativeTargetInfo;
arena: Allocator, arena: Allocator,
include_dirs: std.ArrayListUnmanaged([]const u8) = .{}, include_dirs: std.ArrayListUnmanaged([]const u8) = .{},
@ -14,8 +13,7 @@ framework_dirs: std.ArrayListUnmanaged([]const u8) = .{},
rpaths: std.ArrayListUnmanaged([]const u8) = .{}, rpaths: std.ArrayListUnmanaged([]const u8) = .{},
warnings: std.ArrayListUnmanaged([]const u8) = .{}, warnings: std.ArrayListUnmanaged([]const u8) = .{},
pub fn detect(arena: Allocator, native_info: NativeTargetInfo) !NativePaths { pub fn detect(arena: Allocator, native_target: std.Target) !NativePaths {
const native_target = native_info.target;
var self: NativePaths = .{ .arena = arena }; var self: NativePaths = .{ .arena = arena };
var is_nix = false; var is_nix = false;
if (process.getEnvVarOwned(arena, "NIX_CFLAGS_COMPILE")) |nix_cflags_compile| { if (process.getEnvVarOwned(arena, "NIX_CFLAGS_COMPILE")) |nix_cflags_compile| {

1130
lib/std/zig/system/NativeTargetInfo.zig
View File

File diff suppressed because it is too large Load Diff

27
src/Compilation.zig
View File

@ -6527,7 +6527,6 @@ pub fn generateBuiltinZigSource(comp: *Compilation, allocator: Allocator) Alloca
try buffer.writer().print(" .{},\n", .{std.zig.fmtId(feature.name)}); try buffer.writer().print(" .{},\n", .{std.zig.fmtId(feature.name)});
} }
} }
try buffer.writer().print( try buffer.writer().print(
\\ }}), \\ }}),
\\}}; \\}};
@ -6607,15 +6606,31 @@ pub fn generateBuiltinZigSource(comp: *Compilation, allocator: Allocator) Alloca
.{ windows.min, windows.max }, .{ windows.min, windows.max },
), ),
} }
try buffer.appendSlice("};\n"); try buffer.appendSlice(
\\};
try buffer.writer().print( \\pub const target: std.Target = .{
\\pub const target = std.Target{{
\\ .cpu = cpu, \\ .cpu = cpu,
\\ .os = os, \\ .os = os,
\\ .abi = abi, \\ .abi = abi,
\\ .ofmt = object_format, \\ .ofmt = object_format,
\\}}; \\
);
if (target.dynamic_linker.get()) |dl| {
try buffer.writer().print(
\\ .dynamic_linker = std.Target.DynamicLinker.init("{s}"),
\\}};
\\
, .{dl});
} else {
try buffer.appendSlice(
\\ .dynamic_linker = std.Target.DynamicLinker.none,
\\};
\\
);
}
try buffer.writer().print(
\\pub const object_format = std.Target.ObjectFormat.{}; \\pub const object_format = std.Target.ObjectFormat.{};
\\pub const mode = std.builtin.OptimizeMode.{}; \\pub const mode = std.builtin.OptimizeMode.{};
\\pub const link_libc = {}; \\pub const link_libc = {};

132
src/main.zig
View File

@ -321,13 +321,14 @@ pub fn mainArgs(gpa: Allocator, arena: Allocator, args: []const []const u8) !voi
} else if (mem.eql(u8, cmd, "init")) { } else if (mem.eql(u8, cmd, "init")) {
return cmdInit(gpa, arena, cmd_args); return cmdInit(gpa, arena, cmd_args);
} else if (mem.eql(u8, cmd, "targets")) { } else if (mem.eql(u8, cmd, "targets")) {
const info = try detectNativeTargetInfo(.{}); const host = try std.zig.system.resolveTargetQuery(.{});
const stdout = io.getStdOut().writer(); const stdout = io.getStdOut().writer();
return @import("print_targets.zig").cmdTargets(arena, cmd_args, stdout, info.target); return @import("print_targets.zig").cmdTargets(arena, cmd_args, stdout, host);
} else if (mem.eql(u8, cmd, "version")) { } else if (mem.eql(u8, cmd, "version")) {
try std.io.getStdOut().writeAll(build_options.version ++ "\n"); try std.io.getStdOut().writeAll(build_options.version ++ "\n");
// Check libc++ linkage to make sure Zig was built correctly, but only for "env" and "version" // Check libc++ linkage to make sure Zig was built correctly, but only
// to avoid affecting the startup time for build-critical commands (check takes about ~10 μs) // for "env" and "version" to avoid affecting the startup time for
// build-critical commands (check takes about ~10 μs)
return verifyLibcxxCorrectlyLinked(); return verifyLibcxxCorrectlyLinked();
} else if (mem.eql(u8, cmd, "env")) { } else if (mem.eql(u8, cmd, "env")) {
verifyLibcxxCorrectlyLinked(); verifyLibcxxCorrectlyLinked();
@ -2608,9 +2609,9 @@ fn buildOutputType(
} }
const target_query = try parseTargetQueryOrReportFatalError(arena, target_parse_options); const target_query = try parseTargetQueryOrReportFatalError(arena, target_parse_options);
const target_info = try detectNativeTargetInfo(target_query); const target = try std.zig.system.resolveTargetQuery(target_query);
if (target_info.target.os.tag != .freestanding) { if (target.os.tag != .freestanding) {
if (ensure_libc_on_non_freestanding) if (ensure_libc_on_non_freestanding)
link_libc = true; link_libc = true;
if (ensure_libcpp_on_non_freestanding) if (ensure_libcpp_on_non_freestanding)
@ -2621,7 +2622,7 @@ fn buildOutputType(
if (!force) { if (!force) {
entry = null; entry = null;
} else if (entry == null and output_mode == .Exe) { } else if (entry == null and output_mode == .Exe) {
entry = switch (target_info.target.ofmt) { entry = switch (target.ofmt) {
.coff => "wWinMainCRTStartup", .coff => "wWinMainCRTStartup",
.macho => "_main", .macho => "_main",
.elf, .plan9 => "_start", .elf, .plan9 => "_start",
@ -2629,12 +2630,12 @@ fn buildOutputType(
else => |tag| fatal("No default entry point available for output format {s}", .{@tagName(tag)}), else => |tag| fatal("No default entry point available for output format {s}", .{@tagName(tag)}),
}; };
} }
} else if (entry == null and target_info.target.isWasm() and output_mode == .Exe) { } else if (entry == null and target.isWasm() and output_mode == .Exe) {
// For WebAssembly the compiler defaults to setting the entry name when no flags are set. // For WebAssembly the compiler defaults to setting the entry name when no flags are set.
entry = defaultWasmEntryName(wasi_exec_model); entry = defaultWasmEntryName(wasi_exec_model);
} }
if (target_info.target.ofmt == .coff) { if (target.ofmt == .coff) {
// Now that we know the target supports resources, // Now that we know the target supports resources,
// we can add the res files as link objects. // we can add the res files as link objects.
for (res_files.items) |res_file| { for (res_files.items) |res_file| {
@ -2652,7 +2653,7 @@ fn buildOutputType(
} }
} }
if (target_info.target.cpu.arch.isWasm()) blk: { if (target.cpu.arch.isWasm()) blk: {
if (single_threaded == null) { if (single_threaded == null) {
single_threaded = true; single_threaded = true;
} }
@ -2678,8 +2679,8 @@ fn buildOutputType(
fatal("shared memory is not allowed in object files", .{}); fatal("shared memory is not allowed in object files", .{});
} }
if (!target_info.target.cpu.features.isEnabled(@intFromEnum(std.Target.wasm.Feature.atomics)) or if (!target.cpu.features.isEnabled(@intFromEnum(std.Target.wasm.Feature.atomics)) or
!target_info.target.cpu.features.isEnabled(@intFromEnum(std.Target.wasm.Feature.bulk_memory))) !target.cpu.features.isEnabled(@intFromEnum(std.Target.wasm.Feature.bulk_memory)))
{ {
fatal("'atomics' and 'bulk-memory' features must be enabled to use shared memory", .{}); fatal("'atomics' and 'bulk-memory' features must be enabled to use shared memory", .{});
} }
@ -2777,15 +2778,15 @@ fn buildOutputType(
} }
for (system_libs.keys(), system_libs.values()) |lib_name, info| { for (system_libs.keys(), system_libs.values()) |lib_name, info| {
if (target_info.target.is_libc_lib_name(lib_name)) { if (target.is_libc_lib_name(lib_name)) {
link_libc = true; link_libc = true;
continue; continue;
} }
if (target_info.target.is_libcpp_lib_name(lib_name)) { if (target.is_libcpp_lib_name(lib_name)) {
link_libcpp = true; link_libcpp = true;
continue; continue;
} }
switch (target_util.classifyCompilerRtLibName(target_info.target, lib_name)) { switch (target_util.classifyCompilerRtLibName(target, lib_name)) {
.none => {}, .none => {},
.only_libunwind, .both => { .only_libunwind, .both => {
link_libunwind = true; link_libunwind = true;
@ -2797,8 +2798,8 @@ fn buildOutputType(
}, },
} }
if (target_info.target.isMinGW()) { if (target.isMinGW()) {
const exists = mingw.libExists(arena, target_info.target, zig_lib_directory, lib_name) catch |err| { const exists = mingw.libExists(arena, target, zig_lib_directory, lib_name) catch |err| {
fatal("failed to check zig installation for DLL import libs: {s}", .{ fatal("failed to check zig installation for DLL import libs: {s}", .{
@errorName(err), @errorName(err),
}); });
@ -2820,7 +2821,7 @@ fn buildOutputType(
fatal("cannot use absolute path as a system library: {s}", .{lib_name}); fatal("cannot use absolute path as a system library: {s}", .{lib_name});
} }
if (target_info.target.os.tag == .wasi) { if (target.os.tag == .wasi) {
if (wasi_libc.getEmulatedLibCRTFile(lib_name)) |crt_file| { if (wasi_libc.getEmulatedLibCRTFile(lib_name)) |crt_file| {
try wasi_emulated_libs.append(crt_file); try wasi_emulated_libs.append(crt_file);
continue; continue;
@ -2838,7 +2839,7 @@ fn buildOutputType(
if (sysroot == null and target_query.isNativeOs() and target_query.isNativeAbi() and if (sysroot == null and target_query.isNativeOs() and target_query.isNativeAbi() and
(external_system_libs.len != 0 or want_native_include_dirs)) (external_system_libs.len != 0 or want_native_include_dirs))
{ {
const paths = std.zig.system.NativePaths.detect(arena, target_info) catch |err| { const paths = std.zig.system.NativePaths.detect(arena, target) catch |err| {
fatal("unable to detect native system paths: {s}", .{@errorName(err)}); fatal("unable to detect native system paths: {s}", .{@errorName(err)});
}; };
for (paths.warnings.items) |warning| { for (paths.warnings.items) |warning| {
@ -2857,7 +2858,7 @@ fn buildOutputType(
} }
if (builtin.target.os.tag == .windows and if (builtin.target.os.tag == .windows and
target_info.target.abi == .msvc and target.abi == .msvc and
external_system_libs.len != 0) external_system_libs.len != 0)
{ {
if (libc_installation == null) { if (libc_installation == null) {
@ -2902,7 +2903,7 @@ fn buildOutputType(
&checked_paths, &checked_paths,
lib_dir_path, lib_dir_path,
lib_name, lib_name,
target_info.target, target,
info.preferred_mode, info.preferred_mode,
)) { )) {
const path = try arena.dupe(u8, test_path.items); const path = try arena.dupe(u8, test_path.items);
@ -2936,7 +2937,7 @@ fn buildOutputType(
&checked_paths, &checked_paths,
lib_dir_path, lib_dir_path,
lib_name, lib_name,
target_info.target, target,
info.fallbackMode(), info.fallbackMode(),
)) { )) {
const path = try arena.dupe(u8, test_path.items); const path = try arena.dupe(u8, test_path.items);
@ -2970,7 +2971,7 @@ fn buildOutputType(
&checked_paths, &checked_paths,
lib_dir_path, lib_dir_path,
lib_name, lib_name,
target_info.target, target,
info.preferred_mode, info.preferred_mode,
)) { )) {
const path = try arena.dupe(u8, test_path.items); const path = try arena.dupe(u8, test_path.items);
@ -2994,7 +2995,7 @@ fn buildOutputType(
&checked_paths, &checked_paths,
lib_dir_path, lib_dir_path,
lib_name, lib_name,
target_info.target, target,
info.fallbackMode(), info.fallbackMode(),
)) { )) {
const path = try arena.dupe(u8, test_path.items); const path = try arena.dupe(u8, test_path.items);
@ -3089,15 +3090,13 @@ fn buildOutputType(
} }
// After this point, resolved_frameworks is used instead of frameworks. // After this point, resolved_frameworks is used instead of frameworks.
const object_format = target_info.target.ofmt; if (output_mode == .Obj and (target.ofmt == .coff or target.ofmt == .macho)) {
if (output_mode == .Obj and (object_format == .coff or object_format == .macho)) {
const total_obj_count = c_source_files.items.len + const total_obj_count = c_source_files.items.len +
@intFromBool(root_src_file != null) + @intFromBool(root_src_file != null) +
rc_source_files.items.len + rc_source_files.items.len +
link_objects.items.len; link_objects.items.len;
if (total_obj_count > 1) { if (total_obj_count > 1) {
fatal("{s} does not support linking multiple objects into one", .{@tagName(object_format)}); fatal("{s} does not support linking multiple objects into one", .{@tagName(target.ofmt)});
} }
} }
@ -3110,7 +3109,7 @@ fn buildOutputType(
const resolved_soname: ?[]const u8 = switch (soname) { const resolved_soname: ?[]const u8 = switch (soname) {
.yes => |explicit| explicit, .yes => |explicit| explicit,
.no => null, .no => null,
.yes_default_value => switch (object_format) { .yes_default_value => switch (target.ofmt) {
.elf => if (have_version) .elf => if (have_version)
try std.fmt.allocPrint(arena, "lib{s}.so.{d}", .{ root_name, version.major }) try std.fmt.allocPrint(arena, "lib{s}.so.{d}", .{ root_name, version.major })
else else
@ -3119,7 +3118,7 @@ fn buildOutputType(
}, },
}; };
const a_out_basename = switch (object_format) { const a_out_basename = switch (target.ofmt) {
.coff => "a.exe", .coff => "a.exe",
else => "a.out", else => "a.out",
}; };
@ -3141,7 +3140,7 @@ fn buildOutputType(
}, },
.basename = try std.zig.binNameAlloc(arena, .{ .basename = try std.zig.binNameAlloc(arena, .{
.root_name = root_name, .root_name = root_name,
.target = target_info.target, .target = target,
.output_mode = output_mode, .output_mode = output_mode,
.link_mode = link_mode, .link_mode = link_mode,
.version = optional_version, .version = optional_version,
@ -3269,7 +3268,7 @@ fn buildOutputType(
// Note that cmake when targeting Windows will try to execute // Note that cmake when targeting Windows will try to execute
// zig cc to make an executable and output an implib too. // zig cc to make an executable and output an implib too.
const implib_eligible = is_exe_or_dyn_lib and const implib_eligible = is_exe_or_dyn_lib and
emit_bin_loc != null and target_info.target.os.tag == .windows; emit_bin_loc != null and target.os.tag == .windows;
if (!implib_eligible) { if (!implib_eligible) {
if (!emit_implib_arg_provided) { if (!emit_implib_arg_provided) {
emit_implib = .no; emit_implib = .no;
@ -3419,7 +3418,7 @@ fn buildOutputType(
// "-" is stdin. Dump it to a real file. // "-" is stdin. Dump it to a real file.
const sep = fs.path.sep_str; const sep = fs.path.sep_str;
const sub_path = try std.fmt.allocPrint(arena, "tmp" ++ sep ++ "{x}-stdin{s}", .{ const sub_path = try std.fmt.allocPrint(arena, "tmp" ++ sep ++ "{x}-stdin{s}", .{
std.crypto.random.int(u64), ext.canonicalName(target_info.target), std.crypto.random.int(u64), ext.canonicalName(target),
}); });
try local_cache_directory.handle.makePath("tmp"); try local_cache_directory.handle.makePath("tmp");
// Note that in one of the happy paths, execve() is used to switch // Note that in one of the happy paths, execve() is used to switch
@ -3454,10 +3453,10 @@ fn buildOutputType(
.local_cache_directory = local_cache_directory, .local_cache_directory = local_cache_directory,
.global_cache_directory = global_cache_directory, .global_cache_directory = global_cache_directory,
.root_name = root_name, .root_name = root_name,
.target = target_info.target, .target = target,
.is_native_os = target_query.isNativeOs(), .is_native_os = target_query.isNativeOs(),
.is_native_abi = target_query.isNativeAbi(), .is_native_abi = target_query.isNativeAbi(),
.dynamic_linker = target_info.dynamic_linker.get(), .dynamic_linker = target.dynamic_linker.get(),
.sysroot = sysroot, .sysroot = sysroot,
.output_mode = output_mode, .output_mode = output_mode,
.main_mod = main_mod, .main_mod = main_mod,
@ -3603,7 +3602,6 @@ fn buildOutputType(
.want_structured_cfg = want_structured_cfg, .want_structured_cfg = want_structured_cfg,
}) catch |err| switch (err) { }) catch |err| switch (err) {
error.LibCUnavailable => { error.LibCUnavailable => {
const target = target_info.target;
const triple_name = try target.zigTriple(arena); const triple_name = try target.zigTriple(arena);
std.log.err("unable to find or provide libc for target '{s}'", .{triple_name}); std.log.err("unable to find or provide libc for target '{s}'", .{triple_name});
@ -3692,7 +3690,7 @@ fn buildOutputType(
try comp.makeBinFileExecutable(); try comp.makeBinFileExecutable();
saveState(comp, debug_incremental); saveState(comp, debug_incremental);
if (test_exec_args.items.len == 0 and object_format == .c) default_exec_args: { if (test_exec_args.items.len == 0 and target.ofmt == .c) default_exec_args: {
// Default to using `zig run` to execute the produced .c code from `zig test`. // Default to using `zig run` to execute the produced .c code from `zig test`.
const c_code_loc = emit_bin_loc orelse break :default_exec_args; const c_code_loc = emit_bin_loc orelse break :default_exec_args;
const c_code_directory = c_code_loc.directory orelse comp.bin_file.options.emit.?.directory; const c_code_directory = c_code_loc.directory orelse comp.bin_file.options.emit.?.directory;
@ -3707,7 +3705,7 @@ fn buildOutputType(
if (link_libc) { if (link_libc) {
try test_exec_args.append("-lc"); try test_exec_args.append("-lc");
} else if (target_info.target.os.tag == .windows) { } else if (target.os.tag == .windows) {
try test_exec_args.appendSlice(&.{ try test_exec_args.appendSlice(&.{
"--subsystem", "console", "--subsystem", "console",
"-lkernel32", "-lntdll", "-lkernel32", "-lntdll",
@ -3741,7 +3739,7 @@ fn buildOutputType(
test_exec_args.items, test_exec_args.items,
self_exe_path.?, self_exe_path.?,
arg_mode, arg_mode,
&target_info, &target,
&comp_destroyed, &comp_destroyed,
all_args, all_args,
runtime_args_start, runtime_args_start,
@ -3861,7 +3859,7 @@ fn serve(
// test_exec_args, // test_exec_args,
// self_exe_path.?, // self_exe_path.?,
// arg_mode, // arg_mode,
// target_info, // target,
// true, // true,
// &comp_destroyed, // &comp_destroyed,
// all_args, // all_args,
@ -4071,7 +4069,7 @@ fn runOrTest(
test_exec_args: []const ?[]const u8, test_exec_args: []const ?[]const u8,
self_exe_path: []const u8, self_exe_path: []const u8,
arg_mode: ArgMode, arg_mode: ArgMode,
target_info: *const std.zig.system.NativeTargetInfo, target: *const std.Target,
comp_destroyed: *bool, comp_destroyed: *bool,
all_args: []const []const u8, all_args: []const []const u8,
runtime_args_start: ?usize, runtime_args_start: ?usize,
@ -4105,7 +4103,7 @@ fn runOrTest(
if (process.can_execv and arg_mode == .run) { if (process.can_execv and arg_mode == .run) {
// execv releases the locks; no need to destroy the Compilation here. // execv releases the locks; no need to destroy the Compilation here.
const err = process.execve(gpa, argv.items, &env_map); const err = process.execve(gpa, argv.items, &env_map);
try warnAboutForeignBinaries(arena, arg_mode, target_info, link_libc); try warnAboutForeignBinaries(arena, arg_mode, target, link_libc);
const cmd = try std.mem.join(arena, " ", argv.items); const cmd = try std.mem.join(arena, " ", argv.items);
fatal("the following command failed to execve with '{s}':\n{s}", .{ @errorName(err), cmd }); fatal("the following command failed to execve with '{s}':\n{s}", .{ @errorName(err), cmd });
} else if (process.can_spawn) { } else if (process.can_spawn) {
@ -4121,7 +4119,7 @@ fn runOrTest(
comp_destroyed.* = true; comp_destroyed.* = true;
const term = child.spawnAndWait() catch |err| { const term = child.spawnAndWait() catch |err| {
try warnAboutForeignBinaries(arena, arg_mode, target_info, link_libc); try warnAboutForeignBinaries(arena, arg_mode, target, link_libc);
const cmd = try std.mem.join(arena, " ", argv.items); const cmd = try std.mem.join(arena, " ", argv.items);
fatal("the following command failed with '{s}':\n{s}", .{ @errorName(err), cmd }); fatal("the following command failed with '{s}':\n{s}", .{ @errorName(err), cmd });
}; };
@ -4820,12 +4818,10 @@ pub fn cmdLibC(gpa: Allocator, args: []const []const u8) !void {
if (!target_query.isNative()) { if (!target_query.isNative()) {
fatal("unable to detect libc for non-native target", .{}); fatal("unable to detect libc for non-native target", .{});
} }
const target_info = try detectNativeTargetInfo(target_query);
var libc = LibCInstallation.findNative(.{ var libc = LibCInstallation.findNative(.{
.allocator = gpa, .allocator = gpa,
.verbose = true, .verbose = true,
.target = target_info.target, .target = try std.zig.system.resolveTargetQuery(target_query),
}) catch |err| { }) catch |err| {
fatal("unable to detect native libc: {s}", .{@errorName(err)}); fatal("unable to detect native libc: {s}", .{@errorName(err)});
}; };
@ -5114,11 +5110,11 @@ pub fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !voi
gimmeMoreOfThoseSweetSweetFileDescriptors(); gimmeMoreOfThoseSweetSweetFileDescriptors();
const target_query: std.Target.Query = .{}; const target_query: std.Target.Query = .{};
const target_info = try detectNativeTargetInfo(target_query); const target = try std.zig.system.resolveTargetQuery(target_query);
const exe_basename = try std.zig.binNameAlloc(arena, .{ const exe_basename = try std.zig.binNameAlloc(arena, .{
.root_name = "build", .root_name = "build",
.target = target_info.target, .target = target,
.output_mode = .Exe, .output_mode = .Exe,
}); });
const emit_bin: Compilation.EmitLoc = .{ const emit_bin: Compilation.EmitLoc = .{
@ -5282,10 +5278,10 @@ pub fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !voi
.local_cache_directory = local_cache_directory, .local_cache_directory = local_cache_directory,
.global_cache_directory = global_cache_directory, .global_cache_directory = global_cache_directory,
.root_name = "build", .root_name = "build",
.target = target_info.target, .target = target,
.is_native_os = target_query.isNativeOs(), .is_native_os = target_query.isNativeOs(),
.is_native_abi = target_query.isNativeAbi(), .is_native_abi = target_query.isNativeAbi(),
.dynamic_linker = target_info.dynamic_linker.get(), .dynamic_linker = target.dynamic_linker.get(),
.output_mode = .Exe, .output_mode = .Exe,
.main_mod = &main_mod, .main_mod = &main_mod,
.emit_bin = emit_bin, .emit_bin = emit_bin,
@ -6269,10 +6265,6 @@ test "fds" {
gimmeMoreOfThoseSweetSweetFileDescriptors(); gimmeMoreOfThoseSweetSweetFileDescriptors();
} }
fn detectNativeTargetInfo(target_query: std.Target.Query) !std.zig.system.NativeTargetInfo {
return std.zig.system.NativeTargetInfo.detect(target_query);
}
const usage_ast_check = const usage_ast_check =
\\Usage: zig ast-check [file] \\Usage: zig ast-check [file]
\\ \\
@ -6669,24 +6661,24 @@ fn parseIntSuffix(arg: []const u8, prefix_len: usize) u64 {
fn warnAboutForeignBinaries( fn warnAboutForeignBinaries(
arena: Allocator, arena: Allocator,
arg_mode: ArgMode, arg_mode: ArgMode,
target_info: *const std.zig.system.NativeTargetInfo, target: *const std.Target,
link_libc: bool, link_libc: bool,
) !void { ) !void {
const host_query: std.Target.Query = .{}; const host_query: std.Target.Query = .{};
const host_target_info = try detectNativeTargetInfo(host_query); const host_target = try std.zig.system.resolveTargetQuery(host_query);
switch (host_target_info.getExternalExecutor(target_info, .{ .link_libc = link_libc })) { switch (std.zig.system.getExternalExecutor(host_target, target, .{ .link_libc = link_libc })) {
.native => return, .native => return,
.rosetta => { .rosetta => {
const host_name = try host_target_info.target.zigTriple(arena); const host_name = try host_target.zigTriple(arena);
const foreign_name = try target_info.target.zigTriple(arena); const foreign_name = try target.zigTriple(arena);
warn("the host system ({s}) does not appear to be capable of executing binaries from the target ({s}). Consider installing Rosetta.", .{ warn("the host system ({s}) does not appear to be capable of executing binaries from the target ({s}). Consider installing Rosetta.", .{
host_name, foreign_name, host_name, foreign_name,
}); });
}, },
.qemu => |qemu| { .qemu => |qemu| {
const host_name = try host_target_info.target.zigTriple(arena); const host_name = try host_target.zigTriple(arena);
const foreign_name = try target_info.target.zigTriple(arena); const foreign_name = try target.zigTriple(arena);
switch (arg_mode) { switch (arg_mode) {
.zig_test => warn( .zig_test => warn(
"the host system ({s}) does not appear to be capable of executing binaries " ++ "the host system ({s}) does not appear to be capable of executing binaries " ++
@ -6702,8 +6694,8 @@ fn warnAboutForeignBinaries(
} }
}, },
.wine => |wine| { .wine => |wine| {
const host_name = try host_target_info.target.zigTriple(arena); const host_name = try host_target.zigTriple(arena);
const foreign_name = try target_info.target.zigTriple(arena); const foreign_name = try target.zigTriple(arena);
switch (arg_mode) { switch (arg_mode) {
.zig_test => warn( .zig_test => warn(
"the host system ({s}) does not appear to be capable of executing binaries " ++ "the host system ({s}) does not appear to be capable of executing binaries " ++
@ -6719,8 +6711,8 @@ fn warnAboutForeignBinaries(
} }
}, },
.wasmtime => |wasmtime| { .wasmtime => |wasmtime| {
const host_name = try host_target_info.target.zigTriple(arena); const host_name = try host_target.zigTriple(arena);
const foreign_name = try target_info.target.zigTriple(arena); const foreign_name = try target.zigTriple(arena);
switch (arg_mode) { switch (arg_mode) {
.zig_test => warn( .zig_test => warn(
"the host system ({s}) does not appear to be capable of executing binaries " ++ "the host system ({s}) does not appear to be capable of executing binaries " ++
@ -6736,8 +6728,8 @@ fn warnAboutForeignBinaries(
} }
}, },
.darling => |darling| { .darling => |darling| {
const host_name = try host_target_info.target.zigTriple(arena); const host_name = try host_target.zigTriple(arena);
const foreign_name = try target_info.target.zigTriple(arena); const foreign_name = try target.zigTriple(arena);
switch (arg_mode) { switch (arg_mode) {
.zig_test => warn( .zig_test => warn(
"the host system ({s}) does not appear to be capable of executing binaries " ++ "the host system ({s}) does not appear to be capable of executing binaries " ++
@ -6753,7 +6745,7 @@ fn warnAboutForeignBinaries(
} }
}, },
.bad_dl => |foreign_dl| { .bad_dl => |foreign_dl| {
const host_dl = host_target_info.dynamic_linker.get() orelse "(none)"; const host_dl = host_target.dynamic_linker.get() orelse "(none)";
const tip_suffix = switch (arg_mode) { const tip_suffix = switch (arg_mode) {
.zig_test => ", '--test-no-exec', or '--test-cmd'", .zig_test => ", '--test-no-exec', or '--test-cmd'",
else => "", else => "",
@ -6763,8 +6755,8 @@ fn warnAboutForeignBinaries(
}); });
}, },
.bad_os_or_cpu => { .bad_os_or_cpu => {
const host_name = try host_target_info.target.zigTriple(arena); const host_name = try host_target.zigTriple(arena);
const foreign_name = try target_info.target.zigTriple(arena); const foreign_name = try target.zigTriple(arena);
const tip_suffix = switch (arg_mode) { const tip_suffix = switch (arg_mode) {
.zig_test => ". Consider using '--test-no-exec' or '--test-cmd'", .zig_test => ". Consider using '--test-no-exec' or '--test-cmd'",
else => "", else => "",

4
src/print_env.zig
View File

@ -17,8 +17,8 @@ pub fn cmdEnv(arena: Allocator, args: []const []const u8, stdout: std.fs.File.Wr
const global_cache_dir = try introspect.resolveGlobalCacheDir(arena); const global_cache_dir = try introspect.resolveGlobalCacheDir(arena);
const info = try std.zig.system.NativeTargetInfo.detect(.{}); const host = try std.zig.system.resolveTargetQuery(.{});
const triple = try info.target.zigTriple(arena); const triple = try host.zigTriple(arena);
var bw = std.io.bufferedWriter(stdout); var bw = std.io.bufferedWriter(stdout);
const w = bw.writer(); const w = bw.writer();

30
test/src/Cases.zig
View File

@ -541,7 +541,7 @@ pub fn lowerToBuildSteps(
cases_dir_path: []const u8, cases_dir_path: []const u8,
incremental_exe: *std.Build.Step.Compile, incremental_exe: *std.Build.Step.Compile,
) void { ) void {
const host = std.zig.system.NativeTargetInfo.detect(.{}) catch |err| const host = std.zig.system.resolveTargetQuery(.{}) catch |err|
std.debug.panic("unable to detect native host: {s}\n", .{@errorName(err)}); std.debug.panic("unable to detect native host: {s}\n", .{@errorName(err)});
for (self.incremental_cases.items) |incr_case| { for (self.incremental_cases.items) |incr_case| {
@ -648,8 +648,7 @@ pub fn lowerToBuildSteps(
}, },
.Execution => |expected_stdout| no_exec: { .Execution => |expected_stdout| no_exec: {
const run = if (case.target.target.ofmt == .c) run_step: { const run = if (case.target.target.ofmt == .c) run_step: {
const target_info = case.target.toNativeTargetInfo(); if (getExternalExecutor(host, &case.target.target, .{ .link_libc = true }) != .native) {
if (host.getExternalExecutor(&target_info, .{ .link_libc = true }) != .native) {
// We wouldn't be able to run the compiled C code. // We wouldn't be able to run the compiled C code.
break :no_exec; break :no_exec;
} }
@ -694,8 +693,7 @@ pub fn lowerToBuildSteps(
continue; // Pass test. continue; // Pass test.
} }
const target_info = case.target.toNativeTargetInfo(); if (getExternalExecutor(host, &case.target.target, .{ .link_libc = true }) != .native) {
if (host.getExternalExecutor(&target_info, .{ .link_libc = true }) != .native) {
// We wouldn't be able to run the compiled C code. // We wouldn't be able to run the compiled C code.
continue; // Pass test. continue; // Pass test.
} }
@ -1199,6 +1197,8 @@ const builtin = @import("builtin");
const std = @import("std"); const std = @import("std");
const assert = std.debug.assert; const assert = std.debug.assert;
const Allocator = std.mem.Allocator; const Allocator = std.mem.Allocator;
const getExternalExecutor = std.zig.system.getExternalExecutor;
const Compilation = @import("../../src/Compilation.zig"); const Compilation = @import("../../src/Compilation.zig");
const zig_h = @import("../../src/link.zig").File.C.zig_h; const zig_h = @import("../../src/link.zig").File.C.zig_h;
const introspect = @import("../../src/introspect.zig"); const introspect = @import("../../src/introspect.zig");
@ -1386,18 +1386,15 @@ pub fn main() !void {
} }
fn resolveTargetQuery(query: std.Target.Query) std.Build.ResolvedTarget { fn resolveTargetQuery(query: std.Target.Query) std.Build.ResolvedTarget {
const result = std.zig.system.NativeTargetInfo.detect(query) catch
@panic("unable to resolve target query");
return .{ return .{
.query = query, .query = query,
.target = result.target, .target = std.zig.system.resolveTargetQuery(query) catch
.dynamic_linker = result.dynamic_linker, @panic("unable to resolve target query"),
}; };
} }
fn runCases(self: *Cases, zig_exe_path: []const u8) !void { fn runCases(self: *Cases, zig_exe_path: []const u8) !void {
const host = try std.zig.system.NativeTargetInfo.detect(.{}); const host = try std.zig.system.resolveTargetQuery(.{});
var progress = std.Progress{}; var progress = std.Progress{};
const root_node = progress.start("compiler", self.cases.items.len); const root_node = progress.start("compiler", self.cases.items.len);
@ -1478,7 +1475,7 @@ fn runOneCase(
zig_exe_path: []const u8, zig_exe_path: []const u8,
thread_pool: *ThreadPool, thread_pool: *ThreadPool,
global_cache_directory: Compilation.Directory, global_cache_directory: Compilation.Directory,
host: std.zig.system.NativeTargetInfo, host: std.Target,
) !void { ) !void {
const tmp_src_path = "tmp.zig"; const tmp_src_path = "tmp.zig";
const enable_rosetta = build_options.enable_rosetta; const enable_rosetta = build_options.enable_rosetta;
@ -1488,8 +1485,7 @@ fn runOneCase(
const enable_darling = build_options.enable_darling; const enable_darling = build_options.enable_darling;
const glibc_runtimes_dir: ?[]const u8 = build_options.glibc_runtimes_dir; const glibc_runtimes_dir: ?[]const u8 = build_options.glibc_runtimes_dir;
const target_info = try std.zig.system.NativeTargetInfo.detect(case.target); const target = try std.zig.system.resolveTargetQuery(case.target);
const target = target_info.target;
var arena_allocator = std.heap.ArenaAllocator.init(allocator); var arena_allocator = std.heap.ArenaAllocator.init(allocator);
defer arena_allocator.deinit(); defer arena_allocator.deinit();
@ -1579,7 +1575,7 @@ fn runOneCase(
.keep_source_files_loaded = true, .keep_source_files_loaded = true,
.is_native_os = case.target.isNativeOs(), .is_native_os = case.target.isNativeOs(),
.is_native_abi = case.target.isNativeAbi(), .is_native_abi = case.target.isNativeAbi(),
.dynamic_linker = target_info.dynamic_linker.get(), .dynamic_linker = target.dynamic_linker.get(),
.link_libc = case.link_libc, .link_libc = case.link_libc,
.use_llvm = use_llvm, .use_llvm = use_llvm,
.self_exe_path = zig_exe_path, .self_exe_path = zig_exe_path,
@ -1715,7 +1711,7 @@ fn runOneCase(
.{ &tmp.sub_path, bin_name }, .{ &tmp.sub_path, bin_name },
); );
if (case.target.ofmt != null and case.target.ofmt.? == .c) { if (case.target.ofmt != null and case.target.ofmt.? == .c) {
if (host.getExternalExecutor(target_info, .{ .link_libc = true }) != .native) { if (getExternalExecutor(host, &target, .{ .link_libc = true }) != .native) {
// We wouldn't be able to run the compiled C code. // We wouldn't be able to run the compiled C code.
continue :update; // Pass test. continue :update; // Pass test.
} }
@ -1734,7 +1730,7 @@ fn runOneCase(
if (zig_lib_directory.path) |p| { if (zig_lib_directory.path) |p| {
try argv.appendSlice(&.{ "-I", p }); try argv.appendSlice(&.{ "-I", p });
} }
} else switch (host.getExternalExecutor(target_info, .{ .link_libc = case.link_libc })) { } else switch (getExternalExecutor(host, &target, .{ .link_libc = case.link_libc })) {
.native => { .native => {
if (case.backend == .stage2 and case.target.getCpuArch().isArmOrThumb()) { if (case.backend == .stage2 and case.target.getCpuArch().isArmOrThumb()) {
// https://github.com/ziglang/zig/issues/13623 // https://github.com/ziglang/zig/issues/13623