From ad120ff12f5514d19465d3ae6acd6ee4a9da0722 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= Date: Mon, 10 Aug 2026 00:47:26 +0200 Subject: [PATCH] test: refine the list of targets that get run in stack/error trace tests Stack trace tests now run for most of the targets that we build module tests for. However, we omit explicit targets that have no meaningful way of executing on a non-native platform - whether through an emulator or 32-bit compatibility layer. (There's no point building them if we cannot run them.) We also omit soft float targets because there's nothing about float ABI that would affect stack tracing. Finally, we currently omit Thumb targets because it turns out the stack trace code does not work well at all on Thumb, and fixing this will likely require us to implement ARM EHABI unwinding (#30931). Error trace tests run on an even further reduced set of targets because we don't care if libc is linked for those. Thumb is enabled here, though, since error tracing seems unaffected by the aforementioned issue. Also make these tests respect the various build options. As far as CI goes, x86_64-linux will run the full set of tests (modulo -Dtest-extra-targets) while all other machines only run native-compatible tests. --- build.zig | 32 +- test/src/ErrorTrace.zig | 348 +++++++++++++- test/src/StackTrace.zig | 982 ++++++++++++++++++++++++++++++++++++++-- test/tests.zig | 17 +- 4 files changed, 1310 insertions(+), 69 deletions(-) diff --git a/build.zig b/build.zig index 3c019d38171015207279d3fd6a535e77ea99f6b0..e6e6a4dcbb5ecf31d5f778e84980a21339db4900 100644 --- a/build.zig +++ b/build.zig @@ -660,8 +660,36 @@ pub fn build(b: *std.Build) !void { .skip_llvm = skip_llvm, .max_rss = 100_000_000, })); - test_step.dependOn(tests.addStackTraceTests(b, test_filters, skip_non_native)); - test_step.dependOn(tests.addErrorTraceTests(b, test_filters, optimize_modes, skip_non_native)); + test_step.dependOn(tests.addStackTraceTests(b, .{ + .test_filters = test_filters, + .test_target_filters = test_target_filters, + .test_extra_targets = test_extra_targets, + .optimize_modes = optimize_modes, + .skip_non_native = skip_non_native, + .skip_freebsd = skip_freebsd, + .skip_netbsd = skip_netbsd, + .skip_openbsd = skip_openbsd, + .skip_windows = skip_windows, + .skip_darwin = skip_darwin, + .skip_linux = skip_linux, + .skip_llvm = skip_llvm, + .skip_libc = skip_libc, + })); + test_step.dependOn(tests.addErrorTraceTests(b, .{ + .test_filters = test_filters, + .test_target_filters = test_target_filters, + .test_extra_targets = test_extra_targets, + .optimize_modes = optimize_modes, + .skip_non_native = skip_non_native, + .skip_freebsd = skip_freebsd, + .skip_netbsd = skip_netbsd, + .skip_openbsd = skip_openbsd, + .skip_windows = skip_windows, + .skip_darwin = skip_darwin, + .skip_linux = skip_linux, + .skip_llvm = skip_llvm, + .skip_libc = skip_libc, + })); test_step.dependOn(tests.addCliTests(b)); if (tests.addDebuggerTests(b, .{ .test_filters = test_filters, diff --git a/test/src/ErrorTrace.zig b/test/src/ErrorTrace.zig index 7fda389dc6c295a6c950f95a6551945eab878643..edaa5bbb0c2043fad31925dd6b58f4fac869403f 100644 --- a/test/src/ErrorTrace.zig +++ b/test/src/ErrorTrace.zig @@ -7,29 +7,292 @@ const Step = std.Build.Step; const OptimizeMode = std.lang.Optimize; const mem = std.mem; +const tests = @import("../tests.zig"); const error_traces_cases = @import("../error_traces.zig"); b: *std.Build, step: *Step, -test_filters: []const []const u8, -skip_non_native: bool, -optimize_modes: []const OptimizeMode, +options: Options, convert_exe: *std.Build.Step.Compile, -pub const CaseParameters = @import("StackTrace.zig").CaseParameters; +pub const Options = struct { + test_filters: []const []const u8, + test_target_filters: []const []const u8, + test_extra_targets: bool, + optimize_modes: []const OptimizeMode, + skip_non_native: bool, + skip_freebsd: bool, + skip_netbsd: bool, + skip_openbsd: bool, + skip_windows: bool, + skip_darwin: bool, + skip_linux: bool, + skip_llvm: bool, + skip_libc: bool, +}; -const param_sets = [_]CaseParameters{ +pub const CaseParameters = struct { + target: std.Target.Query = .{}, + optimize: std.builtin.OptimizeMode = .debug, + use_llvm: ?bool = null, + use_lld: ?bool = null, + + // This is intended for targets that, for any reason, shouldn't be run as part of a normal test + // invocation. This could be because of a slow backend, requiring a newer LLVM version, being + // too niche, etc. + extra_target: bool = false, +}; + +/// See the comment in `StackTrace.zig`. +pub const param_sets = [_]CaseParameters{ .{}, + + // FreeBSD Targets + .{ - .link_libc = true, + .target = .{ + .cpu_arch = .arm, + .os_tag = .freebsd, + .abi = .eabihf, + }, }, + .{ + .target = .{ + .cpu_arch = .x86, + .os_tag = .freebsd, + .abi = .none, + }, + }, + + // Linux Targets + + .{ + .target = .{ + .cpu_arch = .aarch64, + .os_tag = .linux, + .abi = .none, + }, + }, + + .{ + .target = .{ + .cpu_arch = .aarch64_be, + .os_tag = .linux, + .abi = .none, + }, + }, + + .{ + .target = .{ + .cpu_arch = .arm, + .os_tag = .linux, + .abi = .eabihf, + }, + }, + + .{ + .target = .{ + .cpu_arch = .armeb, + .os_tag = .linux, + .abi = .eabihf, + }, + }, + + .{ + .target = .{ + .cpu_arch = .hexagon, + .os_tag = .linux, + .abi = .none, + }, + }, + + .{ + .target = .{ + .cpu_arch = .loongarch32, + .os_tag = .linux, + .abi = .none, + }, + }, + + .{ + .target = .{ + .cpu_arch = .loongarch64, + .os_tag = .linux, + .abi = .none, + }, + }, + + .{ + .target = .{ + .cpu_arch = .mips, + .os_tag = .linux, + .abi = .eabihf, + }, + }, + + .{ + .target = .{ + .cpu_arch = .mipsel, + .os_tag = .linux, + .abi = .eabihf, + }, + }, + + .{ + .target = .{ + .cpu_arch = .mips64, + .os_tag = .linux, + .abi = .none, + }, + }, + .{ + .target = .{ + .cpu_arch = .mips64, + .os_tag = .linux, + .abi = .abin32, + }, + }, + + .{ + .target = .{ + .cpu_arch = .mips64el, + .os_tag = .linux, + .abi = .none, + }, + }, + .{ + .target = .{ + .cpu_arch = .mips64el, + .os_tag = .linux, + .abi = .abin32, + }, + }, + + .{ + .target = .{ + .cpu_arch = .powerpc, + .os_tag = .linux, + .abi = .eabihf, + }, + }, + + .{ + .target = .{ + .cpu_arch = .powerpc64, + .os_tag = .linux, + .abi = .none, + }, + }, + + .{ + .target = .{ + .cpu_arch = .powerpc64le, + .os_tag = .linux, + .abi = .none, + }, + }, + + .{ + .target = .{ + .cpu_arch = .riscv32, + .os_tag = .linux, + .abi = .none, + }, + }, + + .{ + .target = .{ + .cpu_arch = .riscv64, + .os_tag = .linux, + .abi = .none, + }, + }, + + .{ + .target = .{ + .cpu_arch = .s390x, + .os_tag = .linux, + .abi = .none, + }, + }, + + .{ + .target = .{ + .cpu_arch = .sparc64, + .os_tag = .linux, + .abi = .none, + }, + }, + + .{ + .target = .{ + .cpu_arch = .thumb, + .os_tag = .linux, + .abi = .eabihf, + }, + }, + + .{ + .target = .{ + .cpu_arch = .thumbeb, + .os_tag = .linux, + .abi = .eabihf, + }, + }, + + .{ + .target = .{ + .cpu_arch = .x86, + .os_tag = .linux, + .abi = .none, + }, + }, + + .{ + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .linux, + .abi = .none, + }, + }, + .{ + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .linux, + .abi = .none, + }, .use_llvm = true, .use_lld = true, }, .{ - .pie = true, + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .linux, + .abi = .x32, + }, + }, + + // NetBSD Targets + + .{ + .target = .{ + .cpu_arch = .riscv32, + .os_tag = .netbsd, + .abi = .none, + }, + }, + + .{ + .target = .{ + .cpu_arch = .x86, + .os_tag = .netbsd, + .abi = .none, + }, }, + + // Windows Targets + .{ .target = .{ .cpu_arch = .aarch64, @@ -39,11 +302,27 @@ const param_sets = [_]CaseParameters{ }, .{ .target = .{ - .cpu_arch = .x86_64, + .cpu_arch = .aarch64, .os_tag = .windows, .abi = .gnu, }, }, + + .{ + .target = .{ + .cpu_arch = .thumb, + .os_tag = .windows, + .abi = .msvc, + }, + }, + .{ + .target = .{ + .cpu_arch = .thumb, + .os_tag = .windows, + .abi = .gnu, + }, + }, + .{ .target = .{ .cpu_arch = .x86, @@ -53,22 +332,24 @@ const param_sets = [_]CaseParameters{ }, .{ .target = .{ - .cpu_arch = .aarch64, - .os_tag = .macos, + .cpu_arch = .x86, + .os_tag = .windows, + .abi = .gnu, }, }, + .{ .target = .{ - .cpu_arch = .s390x, - .os_tag = .linux, - .abi = .none, + .cpu_arch = .x86_64, + .os_tag = .windows, + .abi = .msvc, }, }, .{ .target = .{ - .cpu_arch = .loongarch32, - .os_tag = .linux, - .abi = .none, + .cpu_arch = .x86_64, + .os_tag = .windows, + .abi = .gnu, }, }, }; @@ -97,17 +378,34 @@ pub fn addCases(self: *ErrorTrace) void { for (¶m_sets) |*params| { const resolved_target = b.resolveTargetQuery(params.target); + const target = &resolved_target.result; - if (self.skip_non_native and !resolved_target.query.isNative()) continue; + if (!self.options.test_extra_targets and params.extra_target) continue; - // To avoid redundant testing, skip cross-compilation targets matching the host. - if (resolved_target.result.os.tag == builtin.target.os.tag and - resolved_target.result.cpu.arch == builtin.target.cpu.arch) - { + if (self.options.skip_non_native and !tests.isNative(&resolved_target, &b.graph.host.result)) continue; + + if (self.options.skip_freebsd and target.os.tag == .freebsd) continue; + if (self.options.skip_netbsd and target.os.tag == .netbsd) continue; + if (self.options.skip_openbsd and target.os.tag == .openbsd) continue; + if (self.options.skip_windows and target.os.tag == .windows) continue; + if (self.options.skip_darwin and target.os.tag.isDarwin()) continue; + if (self.options.skip_linux and target.os.tag == .linux) continue; + + const would_use_llvm = tests.wouldUseLlvm(params.use_llvm, params.target, params.optimize); + if (self.options.skip_llvm and would_use_llvm) continue; + + const triple_txt = resolved_target.query.zigTriple(b.allocator) catch @panic("OOM"); + + if (self.options.test_target_filters.len > 0) { + for (self.options.test_target_filters) |filter| { + if (std.mem.find(u8, triple_txt, filter) != null) break; + } else continue; + } + + if (self.options.skip_libc and std.os.targetRequiresLibC(target)) continue; - } - for (self.optimize_modes) |optimize| { + for (self.options.optimize_modes) |optimize| { if (optimize == params.optimize) break; } else return; @@ -154,8 +452,8 @@ pub fn addCase(self: *ErrorTrace, case: Case) void { params.optimize, backend_string, }); - if (self.test_filters.len > 0) { - for (self.test_filters) |test_filter| { + if (self.options.test_filters.len > 0) { + for (self.options.test_filters) |test_filter| { if (mem.find(u8, annotated_case_name, test_filter)) |_| break; } else return; } diff --git a/test/src/StackTrace.zig b/test/src/StackTrace.zig index c4e4a5fe391a4141fe167681183b761c8fbf806b..523eadab53f0f1e20b5d013203db3ef58a54e84a 100644 --- a/test/src/StackTrace.zig +++ b/test/src/StackTrace.zig @@ -7,15 +7,32 @@ const Step = std.Build.Step; const OptimizeMode = std.lang.Optimize; const mem = std.mem; +const tests = @import("../tests.zig"); const stack_traces_cases = @import("../stack_traces.zig"); b: *std.Build, step: *Step, -test_filters: []const []const u8, -skip_non_native: bool, +options: Options, convert_exe: *std.Build.Step.Compile, +pub const Options = struct { + test_filters: []const []const u8, + test_target_filters: []const []const u8, + test_extra_targets: bool, + optimize_modes: []const OptimizeMode, + skip_non_native: bool, + skip_freebsd: bool, + skip_netbsd: bool, + skip_openbsd: bool, + skip_windows: bool, + skip_darwin: bool, + skip_linux: bool, + skip_llvm: bool, + skip_libc: bool, +}; + pub const CaseParameters = struct { + linkage: ?std.builtin.LinkMode = null, target: std.Target.Query = .{}, optimize: std.builtin.OptimizeMode = .debug, link_libc: ?bool = null, @@ -26,20 +43,814 @@ pub const CaseParameters = struct { /// * The compiler needs to gain the ability to strip only debug info (not symbols) /// * `std.Build.Step.ObjCopy` needs to be un-regressed strip: ?bool = false, + + // This is intended for targets that, for any reason, shouldn't be run as part of a normal test + // invocation. This could be because of a slow backend, requiring a newer LLVM version, being + // too niche, etc. + extra_target: bool = false, }; -const param_sets = [_]CaseParameters{ +/// Only add a non-native target to this set if there's a way to emulate it, or if it can built on a +/// platform with the same arch/OS but has a different ABI. For example, it makes little sense to +/// add `riscv64-netbsd` here because there's no QEMU user-mode emulation for it anyway, and it'll +/// still be covered by the native entries when run on a real `riscv64-netbsd` system. But adding +/// `aarch64-windows-msvc` is valuable because the native entries will default to `gnu` on Windows. +pub const param_sets = [_]CaseParameters{ .{}, .{ .link_libc = true, }, .{ + .pie = true, + }, + .{ + .link_libc = true, + .pie = true, + }, + + // FreeBSD Targets + + .{ + .target = .{ + .cpu_arch = .arm, + .os_tag = .freebsd, + .abi = .eabihf, + }, + }, + + .{ + .target = .{ + .cpu_arch = .x86, + .os_tag = .freebsd, + .abi = .none, + }, + }, + + // Linux Targets + + .{ + .target = .{ + .cpu_arch = .aarch64, + .os_tag = .linux, + .abi = .none, + }, + }, + .{ + .target = .{ + .cpu_arch = .aarch64, + .os_tag = .linux, + .abi = .musl, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .aarch64, + .os_tag = .linux, + .abi = .musl, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + .{ + .target = .{ + .cpu_arch = .aarch64, + .os_tag = .linux, + .abi = .gnu, + }, + .link_libc = true, + }, + + .{ + .target = .{ + .cpu_arch = .aarch64_be, + .os_tag = .linux, + .abi = .none, + }, + }, + .{ + .target = .{ + .cpu_arch = .aarch64_be, + .os_tag = .linux, + .abi = .musl, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .aarch64_be, + .os_tag = .linux, + .abi = .musl, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + .{ + .target = .{ + .cpu_arch = .aarch64_be, + .os_tag = .linux, + .abi = .gnu, + }, + .link_libc = true, + }, + + .{ + .target = .{ + .cpu_arch = .arm, + .os_tag = .linux, + .abi = .eabihf, + }, + }, + .{ + .target = .{ + .cpu_arch = .arm, + .os_tag = .linux, + .abi = .musleabihf, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .arm, + .os_tag = .linux, + .abi = .musleabihf, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + .{ + .target = .{ + .cpu_arch = .arm, + .os_tag = .linux, + .abi = .gnueabihf, + }, + .link_libc = true, + }, + + .{ + .target = .{ + .cpu_arch = .armeb, + .os_tag = .linux, + .abi = .eabihf, + }, + }, + .{ + .target = .{ + .cpu_arch = .armeb, + .os_tag = .linux, + .abi = .musleabihf, + }, + .link_libc = true, + }, + // Crashes in weird ways when applying relocations. + // .{ + // .target = .{ + // .cpu_arch = .armeb, + // .os_tag = .linux, + // .abi = .musleabihf, + // }, + // .linkage = .dynamic, + // .link_libc = true, + // .extra_target = true, + // }, + .{ + .target = .{ + .cpu_arch = .armeb, + .os_tag = .linux, + .abi = .gnueabihf, + }, + .link_libc = true, + }, + + .{ + .target = .{ + .cpu_arch = .hexagon, + .os_tag = .linux, + .abi = .none, + }, + }, + .{ + .target = .{ + .cpu_arch = .hexagon, + .os_tag = .linux, + .abi = .musl, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .hexagon, + .os_tag = .linux, + .abi = .musl, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + + .{ + .target = .{ + .cpu_arch = .loongarch32, + .os_tag = .linux, + .abi = .none, + }, + }, + .{ + .target = .{ + .cpu_arch = .loongarch32, + .os_tag = .linux, + .abi = .gnu, + }, + .link_libc = true, + }, + + .{ + .target = .{ + .cpu_arch = .loongarch64, + .os_tag = .linux, + .abi = .none, + }, + }, + .{ + .target = .{ + .cpu_arch = .loongarch64, + .os_tag = .linux, + .abi = .musl, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .loongarch64, + .os_tag = .linux, + .abi = .musl, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + .{ + .target = .{ + .cpu_arch = .loongarch64, + .os_tag = .linux, + .abi = .gnu, + }, + .link_libc = true, + }, + + .{ + .target = .{ + .cpu_arch = .mips, + .os_tag = .linux, + .abi = .eabihf, + }, + }, + .{ + .target = .{ + .cpu_arch = .mips, + .os_tag = .linux, + .abi = .musleabihf, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .mips, + .os_tag = .linux, + .abi = .musleabihf, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + .{ + .target = .{ + .cpu_arch = .mips, + .os_tag = .linux, + .abi = .gnueabihf, + }, + .link_libc = true, + }, + + .{ + .target = .{ + .cpu_arch = .mipsel, + .os_tag = .linux, + .abi = .eabihf, + }, + }, + .{ + .target = .{ + .cpu_arch = .mipsel, + .os_tag = .linux, + .abi = .musleabihf, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .mipsel, + .os_tag = .linux, + .abi = .musleabihf, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + .{ + .target = .{ + .cpu_arch = .mipsel, + .os_tag = .linux, + .abi = .gnueabihf, + }, + .link_libc = true, + }, + + .{ + .target = .{ + .cpu_arch = .mips64, + .os_tag = .linux, + .abi = .none, + }, + }, + .{ + .target = .{ + .cpu_arch = .mips64, + .os_tag = .linux, + .abi = .abin32, + }, + }, + .{ + .target = .{ + .cpu_arch = .mips64, + .os_tag = .linux, + .abi = .muslabi64, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .mips64, + .os_tag = .linux, + .abi = .muslabi64, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + .{ + .target = .{ + .cpu_arch = .mips64, + .os_tag = .linux, + .abi = .muslabin32, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .mips64, + .os_tag = .linux, + .abi = .muslabin32, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + .{ + .target = .{ + .cpu_arch = .mips64, + .os_tag = .linux, + .abi = .gnuabi64, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .mips64, + .os_tag = .linux, + .abi = .gnuabin32, + }, + .link_libc = true, + }, + + .{ + .target = .{ + .cpu_arch = .mips64el, + .os_tag = .linux, + .abi = .none, + }, + }, + .{ + .target = .{ + .cpu_arch = .mips64el, + .os_tag = .linux, + .abi = .abin32, + }, + }, + .{ + .target = .{ + .cpu_arch = .mips64el, + .os_tag = .linux, + .abi = .muslabi64, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .mips64el, + .os_tag = .linux, + .abi = .muslabi64, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + .{ + .target = .{ + .cpu_arch = .mips64el, + .os_tag = .linux, + .abi = .muslabin32, + }, + .link_libc = true, + .extra_target = true, + }, + .{ + .target = .{ + .cpu_arch = .mips64el, + .os_tag = .linux, + .abi = .muslabin32, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + .{ + .target = .{ + .cpu_arch = .mips64el, + .os_tag = .linux, + .abi = .gnuabi64, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .mips64el, + .os_tag = .linux, + .abi = .gnuabin32, + }, + .link_libc = true, + .extra_target = true, + }, + + .{ + .target = .{ + .cpu_arch = .powerpc, + .os_tag = .linux, + .abi = .eabihf, + }, + }, + .{ + .target = .{ + .cpu_arch = .powerpc, + .os_tag = .linux, + .abi = .musleabihf, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .powerpc, + .os_tag = .linux, + .abi = .musleabihf, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + + .{ + .target = .{ + .cpu_arch = .powerpc64, + .os_tag = .linux, + .abi = .none, + }, + }, + .{ + .target = .{ + .cpu_arch = .powerpc64, + .os_tag = .linux, + .abi = .musl, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .powerpc64, + .os_tag = .linux, + .abi = .musl, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + + .{ + .target = .{ + .cpu_arch = .powerpc64le, + .os_tag = .linux, + .abi = .none, + }, + }, + .{ + .target = .{ + .cpu_arch = .powerpc64le, + .os_tag = .linux, + .abi = .musl, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .powerpc64le, + .os_tag = .linux, + .abi = .musl, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + .{ + .target = .{ + .cpu_arch = .powerpc64le, + .os_tag = .linux, + .abi = .gnu, + }, + .link_libc = true, + }, + + .{ + .target = .{ + .cpu_arch = .riscv32, + .os_tag = .linux, + .abi = .none, + }, + }, + .{ + .target = .{ + .cpu_arch = .riscv32, + .os_tag = .linux, + .abi = .musl, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .riscv32, + .os_tag = .linux, + .abi = .musl, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + .{ + .target = .{ + .cpu_arch = .riscv32, + .os_tag = .linux, + .abi = .gnu, + }, + .link_libc = true, + }, + + .{ + .target = .{ + .cpu_arch = .riscv64, + .os_tag = .linux, + .abi = .none, + }, + }, + .{ + .target = .{ + .cpu_arch = .riscv64, + .os_tag = .linux, + .abi = .musl, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .riscv64, + .os_tag = .linux, + .abi = .musl, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + .{ + .target = .{ + .cpu_arch = .riscv64, + .os_tag = .linux, + .abi = .gnu, + }, + .link_libc = true, + }, + + .{ + .target = .{ + .cpu_arch = .s390x, + .os_tag = .linux, + .abi = .none, + }, + }, + .{ + .target = .{ + .cpu_arch = .s390x, + .os_tag = .linux, + .abi = .musl, + }, + .link_libc = true, + }, + // Currently hangs in qemu-s390x. + // .{ + // .target = .{ + // .cpu_arch = .s390x, + // .os_tag = .linux, + // .abi = .musl, + // }, + // .linkage = .dynamic, + // .link_libc = true, + // .extra_target = true, + // }, + .{ + .target = .{ + .cpu_arch = .s390x, + .os_tag = .linux, + .abi = .gnu, + }, + .link_libc = true, + }, + + .{ + .target = .{ + .cpu_arch = .sparc64, + .os_tag = .linux, + .abi = .none, + }, + }, + // SPARC linking support is currently incomplete. + // .{ + // .target = .{ + // .cpu_arch = .sparc64, + // .os_tag = .linux, + // .abi = .gnu, + // }, + // .link_libc = true, + // }, + + .{ + .target = .{ + .cpu_arch = .x86, + .os_tag = .linux, + .abi = .none, + }, + }, + .{ + .target = .{ + .cpu_arch = .x86, + .os_tag = .linux, + .abi = .musl, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .x86, + .os_tag = .linux, + .abi = .musl, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + .{ + .target = .{ + .cpu_arch = .x86, + .os_tag = .linux, + .abi = .gnu, + }, + .link_libc = true, + }, + + .{ + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .linux, + .abi = .none, + }, + }, + .{ + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .linux, + .abi = .none, + }, .use_llvm = true, .use_lld = true, }, .{ - .pie = true, + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .linux, + .abi = .x32, + }, + }, + .{ + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .linux, + .abi = .musl, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .linux, + .abi = .musl, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + .{ + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .linux, + .abi = .musl, + }, + .link_libc = true, + .use_llvm = true, + .use_lld = false, + }, + .{ + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .linux, + .abi = .muslx32, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .linux, + .abi = .muslx32, + }, + .linkage = .dynamic, + .link_libc = true, + .extra_target = true, + }, + .{ + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .linux, + .abi = .gnu, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .linux, + .abi = .gnux32, + }, + .link_libc = true, }, + + // NetBSD Targets + + .{ + .target = .{ + .cpu_arch = .riscv32, + .os_tag = .netbsd, + .abi = .none, + }, + }, + + .{ + .target = .{ + .cpu_arch = .x86, + .os_tag = .netbsd, + .abi = .none, + }, + }, + + // Windows Targets + .{ .target = .{ .cpu_arch = .aarch64, @@ -49,11 +860,59 @@ const param_sets = [_]CaseParameters{ }, .{ .target = .{ - .cpu_arch = .x86_64, + .cpu_arch = .aarch64, + .os_tag = .windows, + .abi = .msvc, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .aarch64, + .os_tag = .windows, + .abi = .gnu, + }, + }, + .{ + .target = .{ + .cpu_arch = .aarch64, .os_tag = .windows, .abi = .gnu, }, + .link_libc = true, + }, + + .{ + .target = .{ + .cpu_arch = .thumb, + .os_tag = .windows, + .abi = .msvc, + }, }, + .{ + .target = .{ + .cpu_arch = .thumb, + .os_tag = .windows, + .abi = .msvc, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .thumb, + .os_tag = .windows, + .abi = .gnu, + }, + }, + .{ + .target = .{ + .cpu_arch = .thumb, + .os_tag = .windows, + .abi = .gnu, + }, + .link_libc = true, + }, + .{ .target = .{ .cpu_arch = .x86, @@ -63,23 +922,57 @@ const param_sets = [_]CaseParameters{ }, .{ .target = .{ - .cpu_arch = .aarch64, - .os_tag = .macos, + .cpu_arch = .x86, + .os_tag = .windows, + .abi = .msvc, }, + .link_libc = true, }, .{ .target = .{ - .cpu_arch = .s390x, - .os_tag = .linux, - .abi = .none, + .cpu_arch = .x86, + .os_tag = .windows, + .abi = .gnu, }, }, .{ .target = .{ - .cpu_arch = .loongarch32, - .os_tag = .linux, - .abi = .none, + .cpu_arch = .x86, + .os_tag = .windows, + .abi = .gnu, + }, + .link_libc = true, + }, + + .{ + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .windows, + .abi = .msvc, + }, + }, + .{ + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .windows, + .abi = .msvc, + }, + .link_libc = true, + }, + .{ + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .windows, + .abi = .gnu, + }, + }, + .{ + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .windows, + .abi = .gnu, }, + .link_libc = true, }, }; @@ -112,16 +1005,41 @@ pub fn addCases(self: *StackTrace) void { for (¶m_sets) |*params| { const resolved_target = b.resolveTargetQuery(params.target); + const target = &resolved_target.result; - if (self.skip_non_native and !resolved_target.query.isNative()) continue; + if (!self.options.test_extra_targets and params.extra_target) continue; - // To avoid redundant testing, skip cross-compilation targets matching the host. - if (resolved_target.result.os.tag == builtin.target.os.tag and - resolved_target.result.cpu.arch == builtin.target.cpu.arch) - { - continue; + if (self.options.skip_non_native and !tests.isNative(&resolved_target, &b.graph.host.result)) continue; + + if (self.options.skip_freebsd and target.os.tag == .freebsd) continue; + if (self.options.skip_netbsd and target.os.tag == .netbsd) continue; + if (self.options.skip_openbsd and target.os.tag == .openbsd) continue; + if (self.options.skip_windows and target.os.tag == .windows) continue; + if (self.options.skip_darwin and target.os.tag.isDarwin()) continue; + if (self.options.skip_linux and target.os.tag == .linux) continue; + + const would_use_llvm = tests.wouldUseLlvm(params.use_llvm, params.target, params.optimize); + if (self.options.skip_llvm and would_use_llvm) continue; + + const triple_txt = resolved_target.query.zigTriple(b.allocator) catch @panic("OOM"); + + if (self.options.test_target_filters.len > 0) { + for (self.options.test_target_filters) |filter| { + if (std.mem.find(u8, triple_txt, filter) != null) break; + } else continue; } + if (self.options.skip_libc and (params.link_libc == true or std.os.targetRequiresLibC(target))) + continue; + + // We can't provide MSVC libc when cross-compiling. + if (target.abi == .msvc and params.link_libc == true and builtin.os.tag != .windows) + continue; + + for (self.options.optimize_modes) |optimize| { + if (optimize == params.optimize) break; + } else return; + stack_traces_cases.addCases(self, params, &resolved_target.result); } } @@ -163,7 +1081,7 @@ pub fn addCase(self: *StackTrace, config: Config) void { else => .unsafe, }; const supports_unwind_tables = switch (target.os.tag) { - // x86-windows just has no way to do stack unwinding other then using frame pointers. + // x86-windows just has no way to do stack unwinding other than using frame pointers. .windows => target.cpu.arch != .x86, else => true, }; @@ -255,19 +1173,22 @@ fn addCaseInstance( else ""; - const annotated_case_name = b.fmt("check {s} ({s}{s}{s}{s}{s}{s}{s}{s})", .{ + const annotated_case_name = b.fmt("check {s} ({s}{s}{s}{s}{s}{s}{s}{s}{s})", .{ name, triple orelse "", if (triple != null) " " else "", backend_string, if (params.pie == true) " pie" else "", if (params.link_libc == true) " libc" else "", + if (params.linkage) |linkage| switch (linkage) { + inline else => |t| " " ++ @tagName(t), + } else "", strip_string, if (strip_unwind) " no_unwind" else "", if (omit_frame_pointer) " no_fp" else "", }); - if (self.test_filters.len > 0) { - for (self.test_filters) |test_filter| { + if (self.options.test_filters.len > 0) { + for (self.options.test_filters) |test_filter| { if (mem.find(u8, annotated_case_name, test_filter)) |_| break; } else return; } @@ -278,7 +1199,7 @@ fn addCaseInstance( .name = "test", .root_module = b.createModule(.{ .root_source_file = source_zig, - .optimize = .Debug, + .optimize = params.optimize, .target = resolved_target, .omit_frame_pointer = omit_frame_pointer, .link_libc = params.link_libc, @@ -289,6 +1210,7 @@ fn addCaseInstance( .use_llvm = params.use_llvm, .use_lld = params.use_lld, }); + exe.linkage = params.linkage; exe.pie = params.pie; exe.bundle_ubsan_rt = false; @@ -296,11 +1218,13 @@ fn addCaseInstance( run.skip_foreign_checks = true; run.removeEnvironmentVariable("CLICOLOR_FORCE"); run.setEnvironmentVariable("NO_COLOR", "1"); - run.addCheck(.{ .expect_term = term: { - if (!expect_panic) break :term .{ .exited = 0 }; - if (resolved_target.result.os.tag == .windows) break :term .{ .exited = 3 }; - break :term .{ .signal = @fromBackingInt(@intCast(6)) }; - } }); + run.addCheck(.{ + .expect_term = term: { + if (!expect_panic) break :term .{ .exited = 0 }; + if (resolved_target.result.os.tag == .windows) break :term .{ .exited = 3 }; + break :term .{ .signal = @fromBackingInt(@intCast(6)) }; // SIGABRT + }, + }); run.expectStdOutEqual(""); const check_run = b.addRunArtifact(self.convert_exe); diff --git a/test/tests.zig b/test/tests.zig index fbb16c5a2fe759dd4840d4670670983898985276..302570d313b69de36c2893104f9ccf3cf925d88e 100644 --- a/test/tests.zig +++ b/test/tests.zig @@ -747,7 +747,6 @@ const module_test_targets = blk: { .os_tag = .linux, .abi = .abin32, }, - .extra_target = true, }, .{ .target = .{ @@ -2379,7 +2378,7 @@ pub fn isNative(actual_target: *const std.Build.ResolvedTarget, host: *const std return true; } -pub fn addStackTraceTests(b: *std.Build, test_filters: []const []const u8, skip_non_native: bool) *Step { +pub fn addStackTraceTests(b: *std.Build, options: StackTracesContext.Options) *Step { const step = b.step("test-stack-traces", "Run the stack trace tests"); const convert_exe = b.addExecutable(.{ @@ -2395,8 +2394,7 @@ pub fn addStackTraceTests(b: *std.Build, test_filters: []const []const u8, skip_ stack_traces_context.* = .{ .b = b, .step = step, - .test_filters = test_filters, - .skip_non_native = skip_non_native, + .options = options, .convert_exe = convert_exe, }; stack_traces_context.addCases(); @@ -2404,12 +2402,7 @@ pub fn addStackTraceTests(b: *std.Build, test_filters: []const []const u8, skip_ return step; } -pub fn addErrorTraceTests( - b: *std.Build, - test_filters: []const []const u8, - optimize_modes: []const OptimizeMode, - skip_non_native: bool, -) *Step { +pub fn addErrorTraceTests(b: *std.Build, options: ErrorTracesContext.Options) *Step { const step = b.step("test-error-traces", "Run the error trace tests"); const convert_exe = b.addExecutable(.{ @@ -2425,9 +2418,7 @@ pub fn addErrorTraceTests( error_traces_context.* = .{ .b = b, .step = step, - .test_filters = test_filters, - .skip_non_native = skip_non_native, - .optimize_modes = optimize_modes, + .options = options, .convert_exe = convert_exe, }; error_traces_context.addCases(); -- 2.54.0