mirrors/zig
1
0
Fork 0
mirror of https://codeberg.org/ziglang/zig.git synced 2025-12-06 05:44:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

re-enable macho linker tests

Browse source
This commit is contained in:
Andrew Kelley 2023-03-07 20:23:11 -07:00
parent 9a9b008300
commit 1142e05343
25 changed files with 396 additions and 244 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
build.zig
View file

@ -454,7 +454,7 @@ pub fn build(b: *std.Build) !void {
// enable_symlinks_windows, // enable_symlinks_windows,
//)); //));
test_step.dependOn(tests.addCAbiTests(b, skip_non_native, skip_release)); test_step.dependOn(tests.addCAbiTests(b, skip_non_native, skip_release));
test_step.dependOn(tests.addLinkTests(b, test_filter, optimization_modes, enable_macos_sdk, skip_stage2_tests, enable_symlinks_windows)); test_step.dependOn(tests.addLinkTests(b, enable_macos_sdk, skip_stage2_tests, enable_symlinks_windows));
test_step.dependOn(tests.addStackTraceTests(b, test_filter, optimization_modes)); test_step.dependOn(tests.addStackTraceTests(b, test_filter, optimization_modes));
test_step.dependOn(tests.addCliTests(b, test_filter, optimization_modes)); test_step.dependOn(tests.addCliTests(b, test_filter, optimization_modes));
test_step.dependOn(tests.addAssembleAndLinkTests(b, test_filter, optimization_modes)); test_step.dependOn(tests.addAssembleAndLinkTests(b, test_filter, optimization_modes));

213
test/link.zig
View file

@ -76,122 +76,103 @@ pub const cases = [_]Case{
}, },
// Mach-O Cases // Mach-O Cases
// cases.addBuildFile("test/link/macho/bugs/13056/build.zig", .{ .{
// .build_modes = true, .build_root = "test/link/macho/bugs/13056",
// .requires_macos_sdk = true, .import = @import("link/macho/bugs/13056/build.zig"),
// .requires_symlinks = true, },
// }); .{
// .build_root = "test/link/macho/bugs/13457",
// cases.addBuildFile("test/link/macho/bugs/13457/build.zig", .{ .import = @import("link/macho/bugs/13457/build.zig"),
// .build_modes = true, },
// .requires_symlinks = true, .{
// }); .build_root = "test/link/macho/bugs/13457",
// .import = @import("link/macho/bugs/13457/build.zig"),
// cases.addBuildFile("test/link/macho/dead_strip/build.zig", .{ },
// .build_modes = false, .{
// .requires_symlinks = true, .build_root = "test/link/macho/dead_strip",
// }); .import = @import("link/macho/dead_strip/build.zig"),
// },
// cases.addBuildFile("test/link/macho/dead_strip_dylibs/build.zig", .{ .{
// .build_modes = true, .build_root = "test/link/macho/dead_strip_dylibs",
// .requires_macos_sdk = true, .import = @import("link/macho/dead_strip_dylibs/build.zig"),
// .requires_symlinks = true, },
// }); .{
// .build_root = "test/link/macho/dylib",
// cases.addBuildFile("test/link/macho/dylib/build.zig", .{ .import = @import("link/macho/dylib/build.zig"),
// .build_modes = true, },
// .requires_symlinks = true, .{
// }); .build_root = "test/link/macho/empty",
// .import = @import("link/macho/empty/build.zig"),
// cases.addBuildFile("test/link/macho/empty/build.zig", .{ },
// .build_modes = true, .{
// .requires_symlinks = true, .build_root = "test/link/macho/entry",
// }); .import = @import("link/macho/entry/build.zig"),
// },
// cases.addBuildFile("test/link/macho/entry/build.zig", .{ .{
// .build_modes = true, .build_root = "test/link/macho/headerpad",
// .requires_symlinks = true, .import = @import("link/macho/headerpad/build.zig"),
// }); },
// .{
// cases.addBuildFile("test/link/macho/headerpad/build.zig", .{ .build_root = "test/link/macho/linksection",
// .build_modes = true, .import = @import("link/macho/linksection/build.zig"),
// .requires_macos_sdk = true, },
// .requires_symlinks = true, .{
// }); .build_root = "test/link/macho/needed_framework",
// .import = @import("link/macho/needed_framework/build.zig"),
// cases.addBuildFile("test/link/macho/linksection/build.zig", .{ },
// .build_modes = true, .{
// .requires_symlinks = true, .build_root = "test/link/macho/needed_library",
// }); .import = @import("link/macho/needed_library/build.zig"),
// },
// cases.addBuildFile("test/link/macho/needed_framework/build.zig", .{ .{
// .build_modes = true, .build_root = "test/link/macho/objc",
// .requires_macos_sdk = true, .import = @import("link/macho/objc/build.zig"),
// .requires_symlinks = true, },
// }); .{
// .build_root = "test/link/macho/objcpp",
// cases.addBuildFile("test/link/macho/needed_library/build.zig", .{ .import = @import("link/macho/objcpp/build.zig"),
// .build_modes = true, },
// .requires_symlinks = true, .{
// }); .build_root = "test/link/macho/pagezero",
// .import = @import("link/macho/pagezero/build.zig"),
// cases.addBuildFile("test/link/macho/objc/build.zig", .{ },
// .build_modes = true, .{
// .requires_macos_sdk = true, .build_root = "test/link/macho/search_strategy",
// .requires_symlinks = true, .import = @import("link/macho/search_strategy/build.zig"),
// }); },
// .{
// cases.addBuildFile("test/link/macho/objcpp/build.zig", .{ .build_root = "test/link/macho/stack_size",
// .build_modes = true, .import = @import("link/macho/stack_size/build.zig"),
// .requires_macos_sdk = true, },
// .requires_symlinks = true, .{
// }); .build_root = "test/link/macho/strict_validation",
// .import = @import("link/macho/strict_validation/build.zig"),
// cases.addBuildFile("test/link/macho/pagezero/build.zig", .{ },
// .build_modes = false, .{
// .requires_symlinks = true, .build_root = "test/link/macho/tls",
// }); .import = @import("link/macho/tls/build.zig"),
// },
// cases.addBuildFile("test/link/macho/search_strategy/build.zig", .{ .{
// .build_modes = true, .build_root = "test/link/macho/unwind_info",
// .requires_symlinks = true, .import = @import("link/macho/unwind_info/build.zig"),
// }); },
// // TODO: re-enable this test. It currently has some incompatibilities with
// cases.addBuildFile("test/link/macho/stack_size/build.zig", .{ // the new build system API. In particular, it depends on installing the build
// .build_modes = true, // artifacts, which should be unnecessary, and it has a custom build step that
// .requires_symlinks = true, // prints directly to stderr instead of failing the step with an error message.
// }); //.{
// // .build_root = "test/link/macho/uuid",
// cases.addBuildFile("test/link/macho/strict_validation/build.zig", .{ // .import = @import("link/macho/uuid/build.zig"),
// .build_modes = true, //},
// .requires_symlinks = true,
// }); .{
// .build_root = "test/link/macho/weak_library",
// cases.addBuildFile("test/link/macho/tls/build.zig", .{ .import = @import("link/macho/weak_library/build.zig"),
// .build_modes = true, },
// .requires_symlinks = true, .{
// }); .build_root = "test/link/macho/weak_framework",
// .import = @import("link/macho/weak_framework/build.zig"),
// cases.addBuildFile("test/link/macho/unwind_info/build.zig", .{ },
// .build_modes = true,
// .requires_symlinks = true,
// });
//
// cases.addBuildFile("test/link/macho/uuid/build.zig", .{
// .build_modes = false,
// .requires_symlinks = true,
// });
//
// cases.addBuildFile("test/link/macho/weak_library/build.zig", .{
// .build_modes = true,
// .requires_symlinks = true,
// });
//
// cases.addBuildFile("test/link/macho/weak_framework/build.zig", .{
// .build_modes = true,
// .requires_macos_sdk = true,
// .requires_symlinks = true,
// });
}; };
const std = @import("std"); const std = @import("std");

18
test/link/macho/bugs/13056/build.zig
View file

@ -1,20 +1,28 @@
const std = @import("std"); const std = @import("std");
pub fn build(b: *std.Build) void { pub const requires_macos_sdk = true;
const optimize = b.standardOptimizeOption(.{}); pub const requires_symlinks = true;
pub fn build(b: *std.Build) void {
const test_step = b.step("test", "Test it");
b.default_step = test_step;
add(b, test_step, .Debug);
add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
const target: std.zig.CrossTarget = .{ .os_tag = .macos }; const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const target_info = std.zig.system.NativeTargetInfo.detect(target) catch unreachable; const target_info = std.zig.system.NativeTargetInfo.detect(target) catch unreachable;
const sdk = std.zig.system.darwin.getDarwinSDK(b.allocator, target_info.target) orelse const sdk = std.zig.system.darwin.getDarwinSDK(b.allocator, target_info.target) orelse
@panic("macOS SDK is required to run the test"); @panic("macOS SDK is required to run the test");
const test_step = b.step("test", "Test the program");
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{
.name = "test", .name = "test",
.optimize = optimize, .optimize = optimize,
}); });
b.default_step.dependOn(&exe.step);
exe.addIncludePath(std.fs.path.join(b.allocator, &.{ sdk.path, "/usr/include" }) catch unreachable); exe.addIncludePath(std.fs.path.join(b.allocator, &.{ sdk.path, "/usr/include" }) catch unreachable);
exe.addIncludePath(std.fs.path.join(b.allocator, &.{ sdk.path, "/usr/include/c++/v1" }) catch unreachable); exe.addIncludePath(std.fs.path.join(b.allocator, &.{ sdk.path, "/usr/include/c++/v1" }) catch unreachable);
exe.addCSourceFile("test.cpp", &.{ exe.addCSourceFile("test.cpp", &.{

18
test/link/macho/bugs/13457/build.zig
View file

@ -1,10 +1,19 @@
const std = @import("std"); const std = @import("std");
pub fn build(b: *std.Build) void { pub const requires_symlinks = true;
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const test_step = b.step("test", "Test the program"); pub fn build(b: *std.Build) void {
const test_step = b.step("test", "Test it");
b.default_step = test_step;
add(b, test_step, .Debug);
add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{
.name = "test", .name = "test",
@ -16,5 +25,6 @@ pub fn build(b: *std.Build) void {
const run = b.addRunArtifact(exe); const run = b.addRunArtifact(exe);
run.skip_foreign_checks = true; run.skip_foreign_checks = true;
run.expectStdOutEqual(""); run.expectStdOutEqual("");
test_step.dependOn(&run.step); test_step.dependOn(&run.step);
} }

13
test/link/macho/dead_strip/build.zig
View file

@ -1,15 +1,17 @@
const std = @import("std"); const std = @import("std");
pub const requires_symlinks = true;
pub fn build(b: *std.Build) void { pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{}); const optimize: std.builtin.OptimizeMode = .Debug;
const target: std.zig.CrossTarget = .{ .os_tag = .macos }; const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const test_step = b.step("test", "Test the program"); const test_step = b.step("test", "Test the program");
test_step.dependOn(b.getInstallStep()); b.default_step = test_step;
{ {
// Without -dead_strip, we expect `iAmUnused` symbol present // Without -dead_strip, we expect `iAmUnused` symbol present
const exe = createScenario(b, optimize, target); const exe = createScenario(b, optimize, target, "no-gc");
const check = exe.checkObject(.macho); const check = exe.checkObject(.macho);
check.checkInSymtab(); check.checkInSymtab();
@ -22,7 +24,7 @@ pub fn build(b: *std.Build) void {
{ {
// With -dead_strip, no `iAmUnused` symbol should be present // With -dead_strip, no `iAmUnused` symbol should be present
const exe = createScenario(b, optimize, target); const exe = createScenario(b, optimize, target, "yes-gc");
exe.link_gc_sections = true; exe.link_gc_sections = true;
const check = exe.checkObject(.macho); const check = exe.checkObject(.macho);
@ -39,9 +41,10 @@ fn createScenario(
b: *std.Build, b: *std.Build,
optimize: std.builtin.OptimizeMode, optimize: std.builtin.OptimizeMode,
target: std.zig.CrossTarget, target: std.zig.CrossTarget,
name: []const u8,
) *std.Build.CompileStep { ) *std.Build.CompileStep {
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{
.name = "test", .name = name,
.optimize = optimize, .optimize = optimize,
.target = target, .target = target,
}); });

30
test/link/macho/dead_strip_dylibs/build.zig
View file

@ -1,14 +1,22 @@
const std = @import("std"); const std = @import("std");
pub const requires_macos_sdk = true;
pub const requires_symlinks = true;
pub fn build(b: *std.Build) void { pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{}); const test_step = b.step("test", "Test it");
b.default_step = test_step;
const test_step = b.step("test", "Test the program"); add(b, test_step, .Debug);
test_step.dependOn(b.getInstallStep()); add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
{ {
// Without -dead_strip_dylibs we expect `-la` to include liba.dylib in the final executable // Without -dead_strip_dylibs we expect `-la` to include liba.dylib in the final executable
const exe = createScenario(b, optimize); const exe = createScenario(b, optimize, "no-dead-strip");
const check = exe.checkObject(.macho); const check = exe.checkObject(.macho);
check.checkStart("cmd LOAD_DYLIB"); check.checkStart("cmd LOAD_DYLIB");
@ -25,18 +33,22 @@ pub fn build(b: *std.Build) void {
{ {
// With -dead_strip_dylibs, we should include liba.dylib as it's unreachable // With -dead_strip_dylibs, we should include liba.dylib as it's unreachable
const exe = createScenario(b, optimize); const exe = createScenario(b, optimize, "yes-dead-strip");
exe.dead_strip_dylibs = true; exe.dead_strip_dylibs = true;
const run_cmd = exe.run(); const run_cmd = b.addRunArtifact(exe);
run_cmd.expected_term = .{ .Exited = @bitCast(u8, @as(i8, -2)) }; // should fail run_cmd.expectExitCode(@bitCast(u8, @as(i8, -2))); // should fail
test_step.dependOn(&run_cmd.step); test_step.dependOn(&run_cmd.step);
} }
} }
fn createScenario(b: *std.Build, optimize: std.builtin.OptimizeMode) *std.Build.CompileStep { fn createScenario(
b: *std.Build,
optimize: std.builtin.OptimizeMode,
name: []const u8,
) *std.Build.CompileStep {
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{
.name = "test", .name = name,
.optimize = optimize, .optimize = optimize,
}); });
exe.addCSourceFile("main.c", &[0][]const u8{}); exe.addCSourceFile("main.c", &[0][]const u8{});

29
test/link/macho/dylib/build.zig
View file

@ -1,11 +1,19 @@
const std = @import("std"); const std = @import("std");
pub fn build(b: *std.Build) void { pub const requires_symlinks = true;
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const test_step = b.step("test", "Test"); pub fn build(b: *std.Build) void {
test_step.dependOn(b.getInstallStep()); const test_step = b.step("test", "Test it");
b.default_step = test_step;
add(b, test_step, .Debug);
add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const dylib = b.addSharedLibrary(.{ const dylib = b.addSharedLibrary(.{
.name = "a", .name = "a",
@ -15,7 +23,6 @@ pub fn build(b: *std.Build) void {
}); });
dylib.addCSourceFile("a.c", &.{}); dylib.addCSourceFile("a.c", &.{});
dylib.linkLibC(); dylib.linkLibC();
dylib.install();
const check_dylib = dylib.checkObject(.macho); const check_dylib = dylib.checkObject(.macho);
check_dylib.checkStart("cmd ID_DYLIB"); check_dylib.checkStart("cmd ID_DYLIB");
@ -33,9 +40,9 @@ pub fn build(b: *std.Build) void {
}); });
exe.addCSourceFile("main.c", &.{}); exe.addCSourceFile("main.c", &.{});
exe.linkSystemLibrary("a"); exe.linkSystemLibrary("a");
exe.addLibraryPathDirectorySource(dylib.getOutputDirectorySource());
exe.addRPathDirectorySource(dylib.getOutputDirectorySource());
exe.linkLibC(); exe.linkLibC();
exe.addLibraryPath(b.pathFromRoot("zig-out/lib/"));
exe.addRPath(b.pathFromRoot("zig-out/lib"));
const check_exe = exe.checkObject(.macho); const check_exe = exe.checkObject(.macho);
check_exe.checkStart("cmd LOAD_DYLIB"); check_exe.checkStart("cmd LOAD_DYLIB");
@ -45,10 +52,12 @@ pub fn build(b: *std.Build) void {
check_exe.checkNext("compatibility version 10000"); check_exe.checkNext("compatibility version 10000");
check_exe.checkStart("cmd RPATH"); check_exe.checkStart("cmd RPATH");
check_exe.checkNext(std.fmt.allocPrint(b.allocator, "path {s}", .{b.pathFromRoot("zig-out/lib")}) catch unreachable); // TODO check this (perhaps with `checkNextFileSource(dylib.getOutputDirectorySource())`)
//check_exe.checkNext(std.fmt.allocPrint(b.allocator, "path {s}", .{
// b.pathFromRoot("zig-out/lib"),
//}) catch unreachable);
const run = check_exe.runAndCompare(); const run = check_exe.runAndCompare();
run.cwd = b.pathFromRoot(".");
run.expectStdOutEqual("Hello world"); run.expectStdOutEqual("Hello world");
test_step.dependOn(&run.step); test_step.dependOn(&run.step);
} }

18
test/link/macho/empty/build.zig
View file

@ -1,11 +1,19 @@
const std = @import("std"); const std = @import("std");
pub fn build(b: *std.Build) void { pub const requires_symlinks = true;
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const test_step = b.step("test", "Test the program"); pub fn build(b: *std.Build) void {
test_step.dependOn(b.getInstallStep()); const test_step = b.step("test", "Test it");
b.default_step = test_step;
add(b, test_step, .Debug);
add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{
.name = "test", .name = "test",

13
test/link/macho/entry/build.zig
View file

@ -1,11 +1,18 @@
const std = @import("std"); const std = @import("std");
pub const requires_symlinks = true;
pub fn build(b: *std.Build) void { pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{}); const test_step = b.step("test", "Test it");
b.default_step = test_step;
const test_step = b.step("test", "Test"); add(b, test_step, .Debug);
test_step.dependOn(b.getInstallStep()); add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{
.name = "main", .name = "main",
.optimize = optimize, .optimize = optimize,

14
test/link/macho/headerpad/build.zig
View file

@ -1,12 +1,20 @@
const std = @import("std"); const std = @import("std");
const builtin = @import("builtin"); const builtin = @import("builtin");
pub const requires_symlinks = true;
pub const requires_macos_sdk = true;
pub fn build(b: *std.Build) void { pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{}); const test_step = b.step("test", "Test it");
b.default_step = test_step;
const test_step = b.step("test", "Test"); add(b, test_step, .Debug);
test_step.dependOn(b.getInstallStep()); add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
{ {
// Test -headerpad_max_install_names // Test -headerpad_max_install_names
const exe = simpleExe(b, optimize); const exe = simpleExe(b, optimize);

18
test/link/macho/linksection/build.zig
View file

@ -1,11 +1,19 @@
const std = @import("std"); const std = @import("std");
pub fn build(b: *std.Build) void { pub const requires_symlinks = true;
const optimize = b.standardOptimizeOption(.{});
const target = std.zig.CrossTarget{ .os_tag = .macos };
const test_step = b.step("test", "Test"); pub fn build(b: *std.Build) void {
test_step.dependOn(b.getInstallStep()); const test_step = b.step("test", "Test it");
b.default_step = test_step;
add(b, test_step, .Debug);
add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
const target = std.zig.CrossTarget{ .os_tag = .macos };
const obj = b.addObject(.{ const obj = b.addObject(.{
.name = "test", .name = "test",

14
test/link/macho/needed_framework/build.zig
View file

@ -1,11 +1,19 @@
const std = @import("std"); const std = @import("std");
pub const requires_symlinks = true;
pub const requires_macos_sdk = true;
pub fn build(b: *std.Build) void { pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{}); const test_step = b.step("test", "Test it");
b.default_step = test_step;
const test_step = b.step("test", "Test the program"); add(b, test_step, .Debug);
test_step.dependOn(b.getInstallStep()); add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
// -dead_strip_dylibs // -dead_strip_dylibs
// -needed_framework Cocoa // -needed_framework Cocoa
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{

23
test/link/macho/needed_library/build.zig
View file

@ -1,11 +1,19 @@
const std = @import("std"); const std = @import("std");
pub fn build(b: *std.Build) void { pub const requires_symlinks = true;
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const test_step = b.step("test", "Test the program"); pub fn build(b: *std.Build) void {
test_step.dependOn(b.getInstallStep()); const test_step = b.step("test", "Test it");
b.default_step = test_step;
add(b, test_step, .Debug);
add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const dylib = b.addSharedLibrary(.{ const dylib = b.addSharedLibrary(.{
.name = "a", .name = "a",
@ -15,7 +23,6 @@ pub fn build(b: *std.Build) void {
}); });
dylib.addCSourceFile("a.c", &.{}); dylib.addCSourceFile("a.c", &.{});
dylib.linkLibC(); dylib.linkLibC();
dylib.install();
// -dead_strip_dylibs // -dead_strip_dylibs
// -needed-la // -needed-la
@ -27,8 +34,8 @@ pub fn build(b: *std.Build) void {
exe.addCSourceFile("main.c", &[0][]const u8{}); exe.addCSourceFile("main.c", &[0][]const u8{});
exe.linkLibC(); exe.linkLibC();
exe.linkSystemLibraryNeeded("a"); exe.linkSystemLibraryNeeded("a");
exe.addLibraryPath(b.pathFromRoot("zig-out/lib")); exe.addLibraryPathDirectorySource(dylib.getOutputDirectorySource());
exe.addRPath(b.pathFromRoot("zig-out/lib")); exe.addRPathDirectorySource(dylib.getOutputDirectorySource());
exe.dead_strip_dylibs = true; exe.dead_strip_dylibs = true;
const check = exe.checkObject(.macho); const check = exe.checkObject(.macho);

13
test/link/macho/objc/build.zig
View file

@ -1,10 +1,19 @@
const std = @import("std"); const std = @import("std");
pub const requires_symlinks = true;
pub const requires_macos_sdk = true;
pub fn build(b: *std.Build) void { pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{}); const test_step = b.step("test", "Test it");
b.default_step = test_step;
const test_step = b.step("test", "Test the program"); add(b, test_step, .Debug);
add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{
.name = "test", .name = "test",
.optimize = optimize, .optimize = optimize,

13
test/link/macho/objcpp/build.zig
View file

@ -1,10 +1,19 @@
const std = @import("std"); const std = @import("std");
pub const requires_symlinks = true;
pub const requires_macos_sdk = true;
pub fn build(b: *std.Build) void { pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{}); const test_step = b.step("test", "Test it");
b.default_step = test_step;
const test_step = b.step("test", "Test the program"); add(b, test_step, .Debug);
add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{
.name = "test", .name = "test",
.optimize = optimize, .optimize = optimize,

12
test/link/macho/pagezero/build.zig
View file

@ -1,11 +1,13 @@
const std = @import("std"); const std = @import("std");
pub fn build(b: *std.Build) void { pub const requires_symlinks = true;
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const test_step = b.step("test", "Test"); pub fn build(b: *std.Build) void {
test_step.dependOn(b.getInstallStep()); const test_step = b.step("test", "Test it");
b.default_step = test_step;
const optimize: std.builtin.OptimizeMode = .Debug;
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
{ {
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{

43
test/link/macho/search_strategy/build.zig
View file

@ -1,35 +1,41 @@
const std = @import("std"); const std = @import("std");
pub fn build(b: *std.Build) void { pub const requires_symlinks = true;
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const test_step = b.step("test", "Test"); pub fn build(b: *std.Build) void {
test_step.dependOn(b.getInstallStep()); const test_step = b.step("test", "Test it");
b.default_step = test_step;
add(b, test_step, .Debug);
add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
{ {
// -search_dylibs_first // -search_dylibs_first
const exe = createScenario(b, optimize, target); const exe = createScenario(b, optimize, target, "search_dylibs_first");
exe.search_strategy = .dylibs_first; exe.search_strategy = .dylibs_first;
const check = exe.checkObject(.macho); const check = exe.checkObject(.macho);
check.checkStart("cmd LOAD_DYLIB"); check.checkStart("cmd LOAD_DYLIB");
check.checkNext("name @rpath/liba.dylib"); check.checkNext("name @rpath/libsearch_dylibs_first.dylib");
const run = check.runAndCompare(); const run = check.runAndCompare();
run.cwd = b.pathFromRoot(".");
run.expectStdOutEqual("Hello world"); run.expectStdOutEqual("Hello world");
test_step.dependOn(&run.step); test_step.dependOn(&run.step);
} }
{ {
// -search_paths_first // -search_paths_first
const exe = createScenario(b, optimize, target); const exe = createScenario(b, optimize, target, "search_paths_first");
exe.search_strategy = .paths_first; exe.search_strategy = .paths_first;
const run = b.addRunArtifact(exe); const run = b.addRunArtifact(exe);
run.skip_foreign_checks = true; run.skip_foreign_checks = true;
run.cwd = b.pathFromRoot(".");
run.expectStdOutEqual("Hello world"); run.expectStdOutEqual("Hello world");
test_step.dependOn(&run.step); test_step.dependOn(&run.step);
} }
@ -39,9 +45,10 @@ fn createScenario(
b: *std.Build, b: *std.Build,
optimize: std.builtin.OptimizeMode, optimize: std.builtin.OptimizeMode,
target: std.zig.CrossTarget, target: std.zig.CrossTarget,
name: []const u8,
) *std.Build.CompileStep { ) *std.Build.CompileStep {
const static = b.addStaticLibrary(.{ const static = b.addStaticLibrary(.{
.name = "a", .name = name,
.optimize = optimize, .optimize = optimize,
.target = target, .target = target,
}); });
@ -50,10 +57,9 @@ fn createScenario(
static.override_dest_dir = std.Build.InstallDir{ static.override_dest_dir = std.Build.InstallDir{
.custom = "static", .custom = "static",
}; };
static.install();
const dylib = b.addSharedLibrary(.{ const dylib = b.addSharedLibrary(.{
.name = "a", .name = name,
.version = .{ .major = 1, .minor = 0 }, .version = .{ .major = 1, .minor = 0 },
.optimize = optimize, .optimize = optimize,
.target = target, .target = target,
@ -63,18 +69,17 @@ fn createScenario(
dylib.override_dest_dir = std.Build.InstallDir{ dylib.override_dest_dir = std.Build.InstallDir{
.custom = "dynamic", .custom = "dynamic",
}; };
dylib.install();
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{
.name = "main", .name = name,
.optimize = optimize, .optimize = optimize,
.target = target, .target = target,
}); });
exe.addCSourceFile("main.c", &.{}); exe.addCSourceFile("main.c", &.{});
exe.linkSystemLibraryName("a"); exe.linkSystemLibraryName(name);
exe.linkLibC(); exe.linkLibC();
exe.addLibraryPath(b.pathFromRoot("zig-out/static")); exe.addLibraryPathDirectorySource(static.getOutputDirectorySource());
exe.addLibraryPath(b.pathFromRoot("zig-out/dynamic")); exe.addLibraryPathDirectorySource(dylib.getOutputDirectorySource());
exe.addRPath(b.pathFromRoot("zig-out/dynamic")); exe.addRPathDirectorySource(dylib.getOutputDirectorySource());
return exe; return exe;
} }

18
test/link/macho/stack_size/build.zig
View file

@ -1,11 +1,19 @@
const std = @import("std"); const std = @import("std");
pub fn build(b: *std.Build) void { pub const requires_symlinks = true;
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const test_step = b.step("test", "Test"); pub fn build(b: *std.Build) void {
test_step.dependOn(b.getInstallStep()); const test_step = b.step("test", "Test it");
b.default_step = test_step;
add(b, test_step, .Debug);
add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{
.name = "main", .name = "main",

18
test/link/macho/strict_validation/build.zig
View file

@ -1,12 +1,20 @@
const std = @import("std"); const std = @import("std");
const builtin = @import("builtin"); const builtin = @import("builtin");
pub fn build(b: *std.Build) void { pub const requires_symlinks = true;
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const test_step = b.step("test", "Test"); pub fn build(b: *std.Build) void {
test_step.dependOn(b.getInstallStep()); const test_step = b.step("test", "Test it");
b.default_step = test_step;
add(b, test_step, .Debug);
add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{
.name = "main", .name = "main",

14
test/link/macho/tls/build.zig
View file

@ -1,7 +1,18 @@
const std = @import("std"); const std = @import("std");
pub const requires_symlinks = true;
pub fn build(b: *std.Build) void { pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{}); const test_step = b.step("test", "Test it");
b.default_step = test_step;
add(b, test_step, .Debug);
add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
const target: std.zig.CrossTarget = .{ .os_tag = .macos }; const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const lib = b.addSharedLibrary(.{ const lib = b.addSharedLibrary(.{
@ -21,6 +32,5 @@ pub fn build(b: *std.Build) void {
test_exe.linkLibrary(lib); test_exe.linkLibrary(lib);
test_exe.linkLibC(); test_exe.linkLibC();
const test_step = b.step("test", "Test it");
test_step.dependOn(&test_exe.step); test_step.dependOn(&test_exe.step);
} }

25
test/link/macho/unwind_info/build.zig
View file

@ -1,14 +1,23 @@
const std = @import("std"); const std = @import("std");
const builtin = @import("builtin"); const builtin = @import("builtin");
pub const requires_symlinks = true;
pub fn build(b: *std.Build) void { pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{}); const test_step = b.step("test", "Test it");
b.default_step = test_step;
add(b, test_step, .Debug);
add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
const target: std.zig.CrossTarget = .{ .os_tag = .macos }; const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const test_step = b.step("test", "Test the program"); testUnwindInfo(b, test_step, optimize, target, false, "no-dead-strip");
testUnwindInfo(b, test_step, optimize, target, true, "yes-dead-strip");
testUnwindInfo(b, test_step, optimize, target, false);
testUnwindInfo(b, test_step, optimize, target, true);
} }
fn testUnwindInfo( fn testUnwindInfo(
@ -17,8 +26,9 @@ fn testUnwindInfo(
optimize: std.builtin.OptimizeMode, optimize: std.builtin.OptimizeMode,
target: std.zig.CrossTarget, target: std.zig.CrossTarget,
dead_strip: bool, dead_strip: bool,
name: []const u8,
) void { ) void {
const exe = createScenario(b, optimize, target); const exe = createScenario(b, optimize, target, name);
exe.link_gc_sections = dead_strip; exe.link_gc_sections = dead_strip;
const check = exe.checkObject(.macho); const check = exe.checkObject(.macho);
@ -54,9 +64,10 @@ fn createScenario(
b: *std.Build, b: *std.Build,
optimize: std.builtin.OptimizeMode, optimize: std.builtin.OptimizeMode,
target: std.zig.CrossTarget, target: std.zig.CrossTarget,
name: []const u8,
) *std.Build.CompileStep { ) *std.Build.CompileStep {
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{
.name = "test", .name = name,
.optimize = optimize, .optimize = optimize,
.target = target, .target = target,
}); });

7
test/link/macho/uuid/build.zig
View file

@ -3,11 +3,14 @@ const CompileStep = std.Build.CompileStep;
const FileSource = std.Build.FileSource; const FileSource = std.Build.FileSource;
const Step = std.Build.Step; const Step = std.Build.Step;
pub const requires_symlinks = true;
pub fn build(b: *std.Build) void { pub fn build(b: *std.Build) void {
const test_step = b.step("test", "Test"); const test_step = b.step("test", "Test");
test_step.dependOn(b.getInstallStep()); b.default_step = test_step;
// We force cross-compilation to ensure we always pick a generic CPU with constant set of CPU features. // We force cross-compilation to ensure we always pick a generic CPU with
// constant set of CPU features.
const aarch64_macos = std.zig.CrossTarget{ const aarch64_macos = std.zig.CrossTarget{
.cpu_arch = .aarch64, .cpu_arch = .aarch64,
.os_tag = .macos, .os_tag = .macos,

14
test/link/macho/weak_framework/build.zig
View file

@ -1,11 +1,19 @@
const std = @import("std"); const std = @import("std");
pub const requires_symlinks = true;
pub const requires_macos_sdk = true;
pub fn build(b: *std.Build) void { pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{}); const test_step = b.step("test", "Test it");
b.default_step = test_step;
const test_step = b.step("test", "Test the program"); add(b, test_step, .Debug);
test_step.dependOn(b.getInstallStep()); add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{
.name = "test", .name = "test",
.optimize = optimize, .optimize = optimize,

22
test/link/macho/weak_library/build.zig
View file

@ -1,11 +1,19 @@
const std = @import("std"); const std = @import("std");
pub fn build(b: *std.Build) void { pub const requires_symlinks = true;
const optimize = b.standardOptimizeOption(.{});
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const test_step = b.step("test", "Test the program"); pub fn build(b: *std.Build) void {
test_step.dependOn(b.getInstallStep()); const test_step = b.step("test", "Test it");
b.default_step = test_step;
add(b, test_step, .Debug);
add(b, test_step, .ReleaseFast);
add(b, test_step, .ReleaseSmall);
add(b, test_step, .ReleaseSafe);
}
fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
const target: std.zig.CrossTarget = .{ .os_tag = .macos };
const dylib = b.addSharedLibrary(.{ const dylib = b.addSharedLibrary(.{
.name = "a", .name = "a",
@ -25,8 +33,8 @@ pub fn build(b: *std.Build) void {
exe.addCSourceFile("main.c", &[0][]const u8{}); exe.addCSourceFile("main.c", &[0][]const u8{});
exe.linkLibC(); exe.linkLibC();
exe.linkSystemLibraryWeak("a"); exe.linkSystemLibraryWeak("a");
exe.addLibraryPath(b.pathFromRoot("zig-out/lib")); exe.addLibraryPathDirectorySource(dylib.getOutputDirectorySource());
exe.addRPath(b.pathFromRoot("zig-out/lib")); exe.addRPathDirectorySource(dylib.getOutputDirectorySource());
const check = exe.checkObject(.macho); const check = exe.checkObject(.macho);
check.checkStart("cmd LOAD_WEAK_DYLIB"); check.checkStart("cmd LOAD_WEAK_DYLIB");

18
test/tests.zig
View file

@ -590,23 +590,25 @@ pub fn addStandaloneTests(
pub fn addLinkTests( pub fn addLinkTests(
b: *std.Build, b: *std.Build,
test_filter: ?[]const u8,
optimize_modes: []const OptimizeMode,
enable_macos_sdk: bool, enable_macos_sdk: bool,
omit_stage2: bool, omit_stage2: bool,
enable_symlinks_windows: bool, enable_symlinks_windows: bool,
) *Step { ) *Step {
_ = test_filter;
_ = optimize_modes;
_ = enable_macos_sdk;
_ = enable_symlinks_windows;
const step = b.step("test-link", "Run the linker tests"); const step = b.step("test-link", "Run the linker tests");
const omit_symlinks = builtin.os.tag == .windows and !enable_symlinks_windows;
inline for (link.cases) |link_test| { inline for (link.cases) |link_test| {
const requires_stage2 = @hasDecl(link_test.import, "requires_stage2") and const requires_stage2 = @hasDecl(link_test.import, "requires_stage2") and
link_test.import.requires_stage2; link_test.import.requires_stage2;
if (!requires_stage2 or !omit_stage2) { const requires_symlinks = @hasDecl(link_test.import, "requires_symlinks") and
link_test.import.requires_symlinks;
const requires_macos_sdk = @hasDecl(link_test.import, "requires_macos_sdk") and
link_test.import.requires_macos_sdk;
const bad =
(requires_stage2 and omit_stage2) or
(requires_symlinks and omit_symlinks) or
(requires_macos_sdk and !enable_macos_sdk);
if (!bad) {
const dep = b.anonymousDependency(link_test.build_root, link_test.import, .{}); const dep = b.anonymousDependency(link_test.build_root, link_test.import, .{});
const dep_step = dep.builder.default_step; const dep_step = dep.builder.default_step;
assert(mem.startsWith(u8, dep.builder.dep_prefix, "test.")); assert(mem.startsWith(u8, dep.builder.dep_prefix, "test."));