zig/test/link/link.zig

221 lines
7.6 KiB
Zig

pub fn build(b: *Build) void {
const test_step = b.step("test-link", "Run link tests");
b.default_step = test_step;
const has_macos_sdk = b.option(bool, "has_macos_sdk", "whether the host provides a macOS SDK in system path");
const has_ios_sdk = b.option(bool, "has_ios_sdk", "whether the host provides a iOS SDK in system path");
const has_symlinks_windows = b.option(bool, "has_symlinks_windows", "whether the host is windows and has symlinks enabled");
const build_opts: BuildOptions = .{
.has_macos_sdk = has_macos_sdk orelse false,
.has_ios_sdk = has_ios_sdk orelse false,
.has_symlinks_windows = has_symlinks_windows orelse false,
};
test_step.dependOn(@import("elf.zig").testAll(b, build_opts));
test_step.dependOn(@import("macho.zig").testAll(b, build_opts));
}
pub const BuildOptions = struct {
has_macos_sdk: bool,
has_ios_sdk: bool,
has_symlinks_windows: bool,
};
pub const Options = struct {
target: std.Build.ResolvedTarget,
optimize: std.builtin.OptimizeMode = .Debug,
use_llvm: bool = true,
use_lld: bool = false,
};
pub fn addTestStep(b: *Build, prefix: []const u8, opts: Options) *Step {
const target = opts.target.result.zigTriple(b.allocator) catch @panic("OOM");
const optimize = @tagName(opts.optimize);
const use_llvm = if (opts.use_llvm) "llvm" else "no-llvm";
const name = std.fmt.allocPrint(b.allocator, "test-{s}-{s}-{s}-{s}", .{
prefix, target, optimize, use_llvm,
}) catch @panic("OOM");
return b.step(name, "");
}
const OverlayOptions = struct {
name: []const u8,
asm_source_bytes: ?[]const u8 = null,
c_source_bytes: ?[]const u8 = null,
c_source_flags: []const []const u8 = &.{},
cpp_source_bytes: ?[]const u8 = null,
cpp_source_flags: []const []const u8 = &.{},
zig_source_bytes: ?[]const u8 = null,
pic: ?bool = null,
strip: ?bool = null,
};
pub fn addExecutable(b: *std.Build, base: Options, overlay: OverlayOptions) *Step.Compile {
const compile_step = b.addExecutable(.{
.name = overlay.name,
.root_source_file = rsf: {
const bytes = overlay.zig_source_bytes orelse break :rsf null;
break :rsf b.addWriteFiles().add("a.zig", bytes);
},
.target = base.target,
.optimize = base.optimize,
.use_llvm = base.use_llvm,
.use_lld = base.use_lld,
.pic = overlay.pic,
.strip = overlay.strip,
});
if (overlay.cpp_source_bytes) |bytes| {
compile_step.addCSourceFile(.{
.file = b.addWriteFiles().add("a.cpp", bytes),
.flags = overlay.cpp_source_flags,
});
}
if (overlay.c_source_bytes) |bytes| {
compile_step.addCSourceFile(.{
.file = b.addWriteFiles().add("a.c", bytes),
.flags = overlay.c_source_flags,
});
}
if (overlay.asm_source_bytes) |bytes| {
compile_step.addAssemblyFile(b.addWriteFiles().add("a.s", bytes));
}
return compile_step;
}
pub fn addObject(b: *Build, base: Options, overlay: OverlayOptions) *Step.Compile {
const compile_step = b.addObject(.{
.name = overlay.name,
.root_source_file = rsf: {
const bytes = overlay.zig_source_bytes orelse break :rsf null;
break :rsf b.addWriteFiles().add("a.zig", bytes);
},
.target = base.target,
.optimize = base.optimize,
.use_llvm = base.use_llvm,
.use_lld = base.use_lld,
.pic = overlay.pic,
.strip = overlay.strip,
});
if (overlay.cpp_source_bytes) |bytes| {
compile_step.addCSourceFile(.{
.file = b.addWriteFiles().add("a.cpp", bytes),
.flags = overlay.cpp_source_flags,
});
}
if (overlay.c_source_bytes) |bytes| {
compile_step.addCSourceFile(.{
.file = b.addWriteFiles().add("a.c", bytes),
.flags = overlay.c_source_flags,
});
}
if (overlay.asm_source_bytes) |bytes| {
compile_step.addAssemblyFile(b.addWriteFiles().add("a.s", bytes));
}
return compile_step;
}
pub fn addStaticLibrary(b: *Build, base: Options, overlay: OverlayOptions) *Compile {
const compile_step = b.addStaticLibrary(.{
.name = overlay.name,
.root_source_file = rsf: {
const bytes = overlay.zig_source_bytes orelse break :rsf null;
break :rsf b.addWriteFiles().add("a.zig", bytes);
},
.target = base.target,
.optimize = base.optimize,
.use_llvm = base.use_llvm,
.use_lld = base.use_lld,
.pic = overlay.pic,
.strip = overlay.strip,
});
if (overlay.cpp_source_bytes) |bytes| {
compile_step.addCSourceFile(.{
.file = b.addWriteFiles().add("a.cpp", bytes),
.flags = overlay.cpp_source_flags,
});
}
if (overlay.c_source_bytes) |bytes| {
compile_step.addCSourceFile(.{
.file = b.addWriteFiles().add("a.c", bytes),
.flags = overlay.c_source_flags,
});
}
if (overlay.asm_source_bytes) |bytes| {
compile_step.addAssemblyFile(b.addWriteFiles().add("a.s", bytes));
}
return compile_step;
}
pub fn addSharedLibrary(b: *Build, base: Options, overlay: OverlayOptions) *Compile {
const compile_step = b.addSharedLibrary(.{
.name = overlay.name,
.root_source_file = rsf: {
const bytes = overlay.zig_source_bytes orelse break :rsf null;
break :rsf b.addWriteFiles().add("a.zig", bytes);
},
.target = base.target,
.optimize = base.optimize,
.use_llvm = base.use_llvm,
.use_lld = base.use_lld,
.pic = overlay.pic,
.strip = overlay.strip,
});
if (overlay.cpp_source_bytes) |bytes| {
compile_step.addCSourceFile(.{
.file = b.addWriteFiles().add("a.cpp", bytes),
.flags = overlay.cpp_source_flags,
});
}
if (overlay.c_source_bytes) |bytes| {
compile_step.addCSourceFile(.{
.file = b.addWriteFiles().add("a.c", bytes),
.flags = overlay.c_source_flags,
});
}
if (overlay.asm_source_bytes) |bytes| {
compile_step.addAssemblyFile(b.addWriteFiles().add("a.s", bytes));
}
return compile_step;
}
pub fn addRunArtifact(comp: *Compile) *Run {
const b = comp.step.owner;
const run = b.addRunArtifact(comp);
run.skip_foreign_checks = true;
return run;
}
pub fn addCSourceBytes(comp: *Compile, bytes: []const u8, flags: []const []const u8) void {
const b = comp.step.owner;
const file = WriteFile.create(b).add("a.c", bytes);
comp.addCSourceFile(.{ .file = file, .flags = flags });
}
pub fn addCppSourceBytes(comp: *Compile, bytes: []const u8, flags: []const []const u8) void {
const b = comp.step.owner;
const file = WriteFile.create(b).add("a.cpp", bytes);
comp.addCSourceFile(.{ .file = file, .flags = flags });
}
pub fn addAsmSourceBytes(comp: *Compile, bytes: []const u8) void {
const b = comp.step.owner;
const actual_bytes = std.fmt.allocPrint(b.allocator, "{s}\n", .{bytes}) catch @panic("OOM");
const file = WriteFile.create(b).add("a.s", actual_bytes);
comp.addAssemblyFile(file);
}
pub fn expectLinkErrors(comp: *Compile, test_step: *Step, expected_errors: Compile.ExpectedCompileErrors) void {
comp.expect_errors = expected_errors;
const bin_file = comp.getEmittedBin();
bin_file.addStepDependencies(test_step);
}
const std = @import("std");
const Build = std.Build;
const Compile = Step.Compile;
const Run = Step.Run;
const Step = Build.Step;
const WriteFile = Step.WriteFile;