8033767082
* test/link: initial wasm support This adds basic parsing and dumping of wasm section so they can be tested using the new linker-test infrastructure. * test/link: all wasm sections parsing and dumping We now parse and dump all sections for the wasm binary format. Currently, this only dumps the name of a custom section. Later this should also dump symbol table, name, linking metadata and relocations. All of those live within the custom sections. * Add wasm linker test This also fixes a parser mistake in reading the flags. * test/link: implement linker tests wasm & fixes Adds several test cases to test the wasm self-hosted linker. This also introduces fixes that were caught during the implementation of those tests. * test-runner: obey omit_stage2 for standalone When a standalone test requires stage2, but stage2 is omit from the compiler, such test case will not be included as part of the test suite that is being ran. This is to support CI's where we omit stage2 to lower the memory usage.
1166 lines
45 KiB
Zig
1166 lines
45 KiB
Zig
const std = @import("std");
|
|
const builtin = std.builtin;
|
|
const Builder = std.build.Builder;
|
|
const tests = @import("test/tests.zig");
|
|
const BufMap = std.BufMap;
|
|
const mem = std.mem;
|
|
const ArrayList = std.ArrayList;
|
|
const io = std.io;
|
|
const fs = std.fs;
|
|
const InstallDirectoryOptions = std.build.InstallDirectoryOptions;
|
|
const assert = std.debug.assert;
|
|
|
|
const zig_version = std.builtin.Version{ .major = 0, .minor = 10, .patch = 0 };
|
|
|
|
pub fn build(b: *Builder) !void {
|
|
b.setPreferredReleaseMode(.ReleaseFast);
|
|
const mode = b.standardReleaseOptions();
|
|
const target = b.standardTargetOptions(.{});
|
|
const single_threaded = b.option(bool, "single-threaded", "Build artifacts that run in single threaded mode");
|
|
const use_zig_libcxx = b.option(bool, "use-zig-libcxx", "If libc++ is needed, use zig's bundled version, don't try to integrate with the system") orelse false;
|
|
|
|
const docgen_exe = b.addExecutable("docgen", "doc/docgen.zig");
|
|
docgen_exe.single_threaded = single_threaded;
|
|
|
|
const rel_zig_exe = try fs.path.relative(b.allocator, b.build_root, b.zig_exe);
|
|
const langref_out_path = fs.path.join(
|
|
b.allocator,
|
|
&[_][]const u8{ b.cache_root, "langref.html" },
|
|
) catch unreachable;
|
|
const docgen_cmd = docgen_exe.run();
|
|
docgen_cmd.addArgs(&[_][]const u8{
|
|
rel_zig_exe,
|
|
"doc" ++ fs.path.sep_str ++ "langref.html.in",
|
|
langref_out_path,
|
|
});
|
|
docgen_cmd.step.dependOn(&docgen_exe.step);
|
|
|
|
const docs_step = b.step("docs", "Build documentation");
|
|
docs_step.dependOn(&docgen_cmd.step);
|
|
|
|
const toolchain_step = b.step("test-toolchain", "Run the tests for the toolchain");
|
|
|
|
var test_cases = b.addTest("src/test.zig");
|
|
test_cases.setBuildMode(mode);
|
|
test_cases.addPackagePath("test_cases", "test/cases.zig");
|
|
test_cases.single_threaded = single_threaded;
|
|
|
|
const fmt_build_zig = b.addFmt(&[_][]const u8{"build.zig"});
|
|
|
|
const skip_debug = b.option(bool, "skip-debug", "Main test suite skips debug builds") orelse false;
|
|
const skip_release = b.option(bool, "skip-release", "Main test suite skips release builds") orelse false;
|
|
const skip_release_small = b.option(bool, "skip-release-small", "Main test suite skips release-small builds") orelse skip_release;
|
|
const skip_release_fast = b.option(bool, "skip-release-fast", "Main test suite skips release-fast builds") orelse skip_release;
|
|
const skip_release_safe = b.option(bool, "skip-release-safe", "Main test suite skips release-safe builds") orelse skip_release;
|
|
const skip_non_native = b.option(bool, "skip-non-native", "Main test suite skips non-native builds") orelse false;
|
|
const skip_libc = b.option(bool, "skip-libc", "Main test suite skips tests that link libc") orelse false;
|
|
const skip_single_threaded = b.option(bool, "skip-single-threaded", "Main test suite skips tests that are single-threaded") orelse false;
|
|
const skip_stage1 = b.option(bool, "skip-stage1", "Main test suite skips stage1 compile error tests") orelse false;
|
|
const skip_run_translated_c = b.option(bool, "skip-run-translated-c", "Main test suite skips run-translated-c tests") orelse false;
|
|
const skip_stage2_tests = b.option(bool, "skip-stage2-tests", "Main test suite skips self-hosted compiler tests") orelse false;
|
|
const skip_install_lib_files = b.option(bool, "skip-install-lib-files", "Do not copy lib/ files to installation prefix") orelse false;
|
|
|
|
const only_install_lib_files = b.option(bool, "lib-files-only", "Only install library files") orelse false;
|
|
|
|
const is_stage1 = b.option(bool, "stage1", "Build the stage1 compiler, put stage2 behind a feature flag") orelse false;
|
|
const omit_stage2 = b.option(bool, "omit-stage2", "Do not include stage2 behind a feature flag inside stage1") orelse false;
|
|
const static_llvm = b.option(bool, "static-llvm", "Disable integration with system-installed LLVM, Clang, LLD, and libc++") orelse false;
|
|
const enable_llvm = b.option(bool, "enable-llvm", "Build self-hosted compiler with LLVM backend enabled") orelse (is_stage1 or static_llvm);
|
|
const llvm_has_m68k = b.option(
|
|
bool,
|
|
"llvm-has-m68k",
|
|
"Whether LLVM has the experimental target m68k enabled",
|
|
) orelse false;
|
|
const llvm_has_csky = b.option(
|
|
bool,
|
|
"llvm-has-csky",
|
|
"Whether LLVM has the experimental target csky enabled",
|
|
) orelse false;
|
|
const llvm_has_arc = b.option(
|
|
bool,
|
|
"llvm-has-arc",
|
|
"Whether LLVM has the experimental target arc enabled",
|
|
) orelse false;
|
|
const enable_macos_sdk = b.option(bool, "enable-macos-sdk", "Run tests requiring presence of macOS SDK and frameworks") orelse false;
|
|
const config_h_path_option = b.option([]const u8, "config_h", "Path to the generated config.h");
|
|
|
|
if (!skip_install_lib_files) {
|
|
b.installDirectory(InstallDirectoryOptions{
|
|
.source_dir = "lib",
|
|
.install_dir = .lib,
|
|
.install_subdir = "zig",
|
|
.exclude_extensions = &[_][]const u8{
|
|
// exclude files from lib/std/compress/
|
|
".gz",
|
|
".z.0",
|
|
".z.9",
|
|
"rfc1951.txt",
|
|
"rfc1952.txt",
|
|
// exclude files from lib/std/compress/deflate/testdata
|
|
".expect",
|
|
".expect-noinput",
|
|
".golden",
|
|
".input",
|
|
"compress-e.txt",
|
|
"compress-gettysburg.txt",
|
|
"compress-pi.txt",
|
|
"rfc1951.txt",
|
|
// exclude files from lib/std/tz/
|
|
".tzif",
|
|
// others
|
|
"README.md",
|
|
},
|
|
.blank_extensions = &[_][]const u8{
|
|
"test.zig",
|
|
},
|
|
});
|
|
}
|
|
|
|
if (only_install_lib_files)
|
|
return;
|
|
|
|
const tracy = b.option([]const u8, "tracy", "Enable Tracy integration. Supply path to Tracy source");
|
|
const tracy_callstack = b.option(bool, "tracy-callstack", "Include callstack information with Tracy data. Does nothing if -Dtracy is not provided") orelse false;
|
|
const tracy_allocation = b.option(bool, "tracy-allocation", "Include allocation information with Tracy data. Does nothing if -Dtracy is not provided") orelse false;
|
|
const force_gpa = b.option(bool, "force-gpa", "Force the compiler to use GeneralPurposeAllocator") orelse false;
|
|
const link_libc = b.option(bool, "force-link-libc", "Force self-hosted compiler to link libc") orelse enable_llvm;
|
|
const strip = b.option(bool, "strip", "Omit debug information") orelse false;
|
|
const use_zig0 = b.option(bool, "zig0", "Bootstrap using zig0") orelse false;
|
|
const value_tracing = b.option(bool, "value-tracing", "Enable extra state tracking to help troubleshoot bugs in the compiler (using the std.debug.Trace API)") orelse false;
|
|
|
|
const mem_leak_frames: u32 = b.option(u32, "mem-leak-frames", "How many stack frames to print when a memory leak occurs. Tests get 2x this amount.") orelse blk: {
|
|
if (strip) break :blk @as(u32, 0);
|
|
if (mode != .Debug) break :blk 0;
|
|
break :blk 4;
|
|
};
|
|
|
|
const main_file: ?[]const u8 = mf: {
|
|
if (!is_stage1) break :mf "src/main.zig";
|
|
if (use_zig0) break :mf null;
|
|
break :mf "src/stage1.zig";
|
|
};
|
|
|
|
const exe = b.addExecutable("zig", main_file);
|
|
exe.strip = strip;
|
|
exe.build_id = b.option(bool, "build-id", "Include a build id note") orelse false;
|
|
exe.install();
|
|
exe.setBuildMode(mode);
|
|
exe.setTarget(target);
|
|
if (!skip_stage2_tests) {
|
|
toolchain_step.dependOn(&exe.step);
|
|
}
|
|
|
|
b.default_step.dependOn(&exe.step);
|
|
exe.single_threaded = single_threaded;
|
|
|
|
if (target.isWindows() and target.getAbi() == .gnu) {
|
|
// LTO is currently broken on mingw, this can be removed when it's fixed.
|
|
exe.want_lto = false;
|
|
test_cases.want_lto = false;
|
|
}
|
|
|
|
const exe_options = b.addOptions();
|
|
exe.addOptions("build_options", exe_options);
|
|
|
|
exe_options.addOption(u32, "mem_leak_frames", mem_leak_frames);
|
|
exe_options.addOption(bool, "skip_non_native", skip_non_native);
|
|
exe_options.addOption(bool, "have_llvm", enable_llvm);
|
|
exe_options.addOption(bool, "llvm_has_m68k", llvm_has_m68k);
|
|
exe_options.addOption(bool, "llvm_has_csky", llvm_has_csky);
|
|
exe_options.addOption(bool, "llvm_has_arc", llvm_has_arc);
|
|
exe_options.addOption(bool, "force_gpa", force_gpa);
|
|
|
|
if (link_libc) {
|
|
exe.linkLibC();
|
|
test_cases.linkLibC();
|
|
}
|
|
|
|
const is_debug = mode == .Debug;
|
|
const enable_logging = b.option(bool, "log", "Enable debug logging with --debug-log") orelse is_debug;
|
|
const enable_link_snapshots = b.option(bool, "link-snapshot", "Whether to enable linker state snapshots") orelse false;
|
|
|
|
const opt_version_string = b.option([]const u8, "version-string", "Override Zig version string. Default is to find out with git.");
|
|
const version = if (opt_version_string) |version| version else v: {
|
|
if (!std.process.can_spawn) {
|
|
std.debug.print("error: version info cannot be retrieved from git. Zig version must be provided using -Dversion-string\n", .{});
|
|
std.process.exit(1);
|
|
}
|
|
const version_string = b.fmt("{d}.{d}.{d}", .{ zig_version.major, zig_version.minor, zig_version.patch });
|
|
|
|
var code: u8 = undefined;
|
|
const git_describe_untrimmed = b.execAllowFail(&[_][]const u8{
|
|
"git", "-C", b.build_root, "describe", "--match", "*.*.*", "--tags",
|
|
}, &code, .Ignore) catch {
|
|
break :v version_string;
|
|
};
|
|
const git_describe = mem.trim(u8, git_describe_untrimmed, " \n\r");
|
|
|
|
switch (mem.count(u8, git_describe, "-")) {
|
|
0 => {
|
|
// Tagged release version (e.g. 0.9.0).
|
|
if (!mem.eql(u8, git_describe, version_string)) {
|
|
std.debug.print("Zig version '{s}' does not match Git tag '{s}'\n", .{ version_string, git_describe });
|
|
std.process.exit(1);
|
|
}
|
|
break :v version_string;
|
|
},
|
|
2 => {
|
|
// Untagged development build (e.g. 0.9.0-dev.2025+ecf0050a9).
|
|
var it = mem.split(u8, git_describe, "-");
|
|
const tagged_ancestor = it.next() orelse unreachable;
|
|
const commit_height = it.next() orelse unreachable;
|
|
const commit_id = it.next() orelse unreachable;
|
|
|
|
const ancestor_ver = try std.builtin.Version.parse(tagged_ancestor);
|
|
if (zig_version.order(ancestor_ver) != .gt) {
|
|
std.debug.print("Zig version '{}' must be greater than tagged ancestor '{}'\n", .{ zig_version, ancestor_ver });
|
|
std.process.exit(1);
|
|
}
|
|
|
|
// Check that the commit hash is prefixed with a 'g' (a Git convention).
|
|
if (commit_id.len < 1 or commit_id[0] != 'g') {
|
|
std.debug.print("Unexpected `git describe` output: {s}\n", .{git_describe});
|
|
break :v version_string;
|
|
}
|
|
|
|
// The version is reformatted in accordance with the https://semver.org specification.
|
|
break :v b.fmt("{s}-dev.{s}+{s}", .{ version_string, commit_height, commit_id[1..] });
|
|
},
|
|
else => {
|
|
std.debug.print("Unexpected `git describe` output: {s}\n", .{git_describe});
|
|
break :v version_string;
|
|
},
|
|
}
|
|
};
|
|
exe_options.addOption([:0]const u8, "version", try b.allocator.dupeZ(u8, version));
|
|
|
|
if (enable_llvm) {
|
|
const cmake_cfg = if (static_llvm) null else findAndParseConfigH(b, config_h_path_option);
|
|
|
|
if (is_stage1) {
|
|
const softfloat = b.addStaticLibrary("softfloat", null);
|
|
softfloat.setBuildMode(.ReleaseFast);
|
|
softfloat.setTarget(target);
|
|
softfloat.addIncludePath("deps/SoftFloat-3e-prebuilt");
|
|
softfloat.addIncludePath("deps/SoftFloat-3e/source/8086");
|
|
softfloat.addIncludePath("deps/SoftFloat-3e/source/include");
|
|
softfloat.addCSourceFiles(&softfloat_sources, &[_][]const u8{ "-std=c99", "-O3" });
|
|
softfloat.single_threaded = single_threaded;
|
|
|
|
const zig0 = b.addExecutable("zig0", null);
|
|
zig0.addCSourceFiles(&.{"src/stage1/zig0.cpp"}, &exe_cflags);
|
|
zig0.addIncludePath("zig-cache/tmp"); // for config.h
|
|
zig0.defineCMacro("ZIG_VERSION_MAJOR", b.fmt("{d}", .{zig_version.major}));
|
|
zig0.defineCMacro("ZIG_VERSION_MINOR", b.fmt("{d}", .{zig_version.minor}));
|
|
zig0.defineCMacro("ZIG_VERSION_PATCH", b.fmt("{d}", .{zig_version.patch}));
|
|
zig0.defineCMacro("ZIG_VERSION_STRING", b.fmt("\"{s}\"", .{version}));
|
|
|
|
for ([_]*std.build.LibExeObjStep{ zig0, exe, test_cases }) |artifact| {
|
|
artifact.addIncludePath("src");
|
|
artifact.addIncludePath("deps/SoftFloat-3e/source/include");
|
|
artifact.addIncludePath("deps/SoftFloat-3e-prebuilt");
|
|
|
|
artifact.defineCMacro("ZIG_LINK_MODE", "Static");
|
|
|
|
artifact.addCSourceFiles(&stage1_sources, &exe_cflags);
|
|
artifact.addCSourceFiles(&optimized_c_sources, &[_][]const u8{ "-std=c99", "-O3" });
|
|
|
|
artifact.linkLibrary(softfloat);
|
|
artifact.linkLibCpp();
|
|
}
|
|
|
|
try addStaticLlvmOptionsToExe(zig0);
|
|
|
|
const zig1_obj_ext = target.getObjectFormat().fileExt(target.getCpuArch());
|
|
const zig1_obj_path = b.pathJoin(&.{ "zig-cache", "tmp", b.fmt("zig1{s}", .{zig1_obj_ext}) });
|
|
const zig1_compiler_rt_path = b.pathJoin(&.{ b.pathFromRoot("lib"), "std", "special", "compiler_rt.zig" });
|
|
|
|
const zig1_obj = zig0.run();
|
|
zig1_obj.addArgs(&.{
|
|
"src/stage1.zig",
|
|
"-target",
|
|
try target.zigTriple(b.allocator),
|
|
"-mcpu=baseline",
|
|
"--name",
|
|
"zig1",
|
|
"--zig-lib-dir",
|
|
b.pathFromRoot("lib"),
|
|
b.fmt("-femit-bin={s}", .{b.pathFromRoot(zig1_obj_path)}),
|
|
"-fcompiler-rt",
|
|
"-lc",
|
|
});
|
|
{
|
|
zig1_obj.addArgs(&.{ "--pkg-begin", "build_options" });
|
|
zig1_obj.addFileSourceArg(exe_options.getSource());
|
|
zig1_obj.addArgs(&.{ "--pkg-end", "--pkg-begin", "compiler_rt", zig1_compiler_rt_path, "--pkg-end" });
|
|
}
|
|
switch (mode) {
|
|
.Debug => {},
|
|
.ReleaseFast => {
|
|
zig1_obj.addArg("-OReleaseFast");
|
|
zig1_obj.addArg("--strip");
|
|
},
|
|
.ReleaseSafe => {
|
|
zig1_obj.addArg("-OReleaseSafe");
|
|
zig1_obj.addArg("--strip");
|
|
},
|
|
.ReleaseSmall => {
|
|
zig1_obj.addArg("-OReleaseSmall");
|
|
zig1_obj.addArg("--strip");
|
|
},
|
|
}
|
|
if (single_threaded orelse false) {
|
|
zig1_obj.addArg("-fsingle-threaded");
|
|
}
|
|
|
|
if (use_zig0) {
|
|
exe.step.dependOn(&zig1_obj.step);
|
|
exe.addObjectFile(zig1_obj_path);
|
|
}
|
|
|
|
// This is intentionally a dummy path. stage1.zig tries to @import("compiler_rt") in case
|
|
// of being built by cmake. But when built by zig it's gonna get a compiler_rt so that
|
|
// is pointless.
|
|
exe.addPackagePath("compiler_rt", "src/empty.zig");
|
|
}
|
|
if (cmake_cfg) |cfg| {
|
|
// Inside this code path, we have to coordinate with system packaged LLVM, Clang, and LLD.
|
|
// That means we also have to rely on stage1 compiled c++ files. We parse config.h to find
|
|
// the information passed on to us from cmake.
|
|
if (cfg.cmake_prefix_path.len > 0) {
|
|
b.addSearchPrefix(cfg.cmake_prefix_path);
|
|
}
|
|
|
|
try addCmakeCfgOptionsToExe(b, cfg, exe, use_zig_libcxx);
|
|
try addCmakeCfgOptionsToExe(b, cfg, test_cases, use_zig_libcxx);
|
|
} else {
|
|
// Here we are -Denable-llvm but no cmake integration.
|
|
try addStaticLlvmOptionsToExe(exe);
|
|
try addStaticLlvmOptionsToExe(test_cases);
|
|
}
|
|
}
|
|
|
|
const semver = try std.SemanticVersion.parse(version);
|
|
exe_options.addOption(std.SemanticVersion, "semver", semver);
|
|
|
|
exe_options.addOption(bool, "enable_logging", enable_logging);
|
|
exe_options.addOption(bool, "enable_link_snapshots", enable_link_snapshots);
|
|
exe_options.addOption(bool, "enable_tracy", tracy != null);
|
|
exe_options.addOption(bool, "enable_tracy_callstack", tracy_callstack);
|
|
exe_options.addOption(bool, "enable_tracy_allocation", tracy_allocation);
|
|
exe_options.addOption(bool, "value_tracing", value_tracing);
|
|
exe_options.addOption(bool, "is_stage1", is_stage1);
|
|
exe_options.addOption(bool, "omit_stage2", omit_stage2);
|
|
if (tracy) |tracy_path| {
|
|
const client_cpp = fs.path.join(
|
|
b.allocator,
|
|
&[_][]const u8{ tracy_path, "TracyClient.cpp" },
|
|
) catch unreachable;
|
|
|
|
// On mingw, we need to opt into windows 7+ to get some features required by tracy.
|
|
const tracy_c_flags: []const []const u8 = if (target.isWindows() and target.getAbi() == .gnu)
|
|
&[_][]const u8{ "-DTRACY_ENABLE=1", "-fno-sanitize=undefined", "-D_WIN32_WINNT=0x601" }
|
|
else
|
|
&[_][]const u8{ "-DTRACY_ENABLE=1", "-fno-sanitize=undefined" };
|
|
|
|
exe.addIncludePath(tracy_path);
|
|
exe.addCSourceFile(client_cpp, tracy_c_flags);
|
|
if (!enable_llvm) {
|
|
exe.linkSystemLibraryName("c++");
|
|
}
|
|
exe.linkLibC();
|
|
|
|
if (target.isWindows()) {
|
|
exe.linkSystemLibrary("dbghelp");
|
|
exe.linkSystemLibrary("ws2_32");
|
|
}
|
|
}
|
|
|
|
const test_filter = b.option([]const u8, "test-filter", "Skip tests that do not match filter");
|
|
|
|
const test_cases_options = b.addOptions();
|
|
test_cases.addOptions("build_options", test_cases_options);
|
|
|
|
test_cases_options.addOption(bool, "enable_logging", enable_logging);
|
|
test_cases_options.addOption(bool, "enable_link_snapshots", enable_link_snapshots);
|
|
test_cases_options.addOption(bool, "skip_non_native", skip_non_native);
|
|
test_cases_options.addOption(bool, "skip_stage1", skip_stage1);
|
|
test_cases_options.addOption(bool, "is_stage1", is_stage1);
|
|
test_cases_options.addOption(bool, "omit_stage2", omit_stage2);
|
|
test_cases_options.addOption(bool, "have_llvm", enable_llvm);
|
|
test_cases_options.addOption(bool, "llvm_has_m68k", llvm_has_m68k);
|
|
test_cases_options.addOption(bool, "llvm_has_csky", llvm_has_csky);
|
|
test_cases_options.addOption(bool, "llvm_has_arc", llvm_has_arc);
|
|
test_cases_options.addOption(bool, "force_gpa", force_gpa);
|
|
test_cases_options.addOption(bool, "enable_qemu", b.enable_qemu);
|
|
test_cases_options.addOption(bool, "enable_wine", b.enable_wine);
|
|
test_cases_options.addOption(bool, "enable_wasmtime", b.enable_wasmtime);
|
|
test_cases_options.addOption(bool, "enable_rosetta", b.enable_rosetta);
|
|
test_cases_options.addOption(bool, "enable_darling", b.enable_darling);
|
|
test_cases_options.addOption(u32, "mem_leak_frames", mem_leak_frames * 2);
|
|
test_cases_options.addOption(bool, "value_tracing", value_tracing);
|
|
test_cases_options.addOption(?[]const u8, "glibc_runtimes_dir", b.glibc_runtimes_dir);
|
|
test_cases_options.addOption([:0]const u8, "version", try b.allocator.dupeZ(u8, version));
|
|
test_cases_options.addOption(std.SemanticVersion, "semver", semver);
|
|
test_cases_options.addOption(?[]const u8, "test_filter", test_filter);
|
|
|
|
const test_cases_step = b.step("test-cases", "Run the main compiler test cases");
|
|
test_cases_step.dependOn(&test_cases.step);
|
|
if (!skip_stage2_tests) {
|
|
toolchain_step.dependOn(test_cases_step);
|
|
}
|
|
|
|
var chosen_modes: [4]builtin.Mode = undefined;
|
|
var chosen_mode_index: usize = 0;
|
|
if (!skip_debug) {
|
|
chosen_modes[chosen_mode_index] = builtin.Mode.Debug;
|
|
chosen_mode_index += 1;
|
|
}
|
|
if (!skip_release_safe) {
|
|
chosen_modes[chosen_mode_index] = builtin.Mode.ReleaseSafe;
|
|
chosen_mode_index += 1;
|
|
}
|
|
if (!skip_release_fast) {
|
|
chosen_modes[chosen_mode_index] = builtin.Mode.ReleaseFast;
|
|
chosen_mode_index += 1;
|
|
}
|
|
if (!skip_release_small) {
|
|
chosen_modes[chosen_mode_index] = builtin.Mode.ReleaseSmall;
|
|
chosen_mode_index += 1;
|
|
}
|
|
const modes = chosen_modes[0..chosen_mode_index];
|
|
|
|
// run stage1 `zig fmt` on this build.zig file just to make sure it works
|
|
toolchain_step.dependOn(&fmt_build_zig.step);
|
|
const fmt_step = b.step("test-fmt", "Run zig fmt against build.zig to make sure it works");
|
|
fmt_step.dependOn(&fmt_build_zig.step);
|
|
|
|
toolchain_step.dependOn(tests.addPkgTests(
|
|
b,
|
|
test_filter,
|
|
"test/behavior.zig",
|
|
"behavior",
|
|
"Run the behavior tests",
|
|
modes,
|
|
skip_single_threaded,
|
|
skip_non_native,
|
|
skip_libc,
|
|
skip_stage1,
|
|
omit_stage2,
|
|
is_stage1,
|
|
));
|
|
|
|
toolchain_step.dependOn(tests.addPkgTests(
|
|
b,
|
|
test_filter,
|
|
"lib/compiler_rt.zig",
|
|
"compiler-rt",
|
|
"Run the compiler_rt tests",
|
|
modes,
|
|
true, // skip_single_threaded
|
|
skip_non_native,
|
|
true, // skip_libc
|
|
skip_stage1,
|
|
omit_stage2 or true, // TODO get these all passing
|
|
is_stage1,
|
|
));
|
|
|
|
toolchain_step.dependOn(tests.addPkgTests(
|
|
b,
|
|
test_filter,
|
|
"lib/c.zig",
|
|
"universal-libc",
|
|
"Run the universal libc tests",
|
|
modes,
|
|
true, // skip_single_threaded
|
|
skip_non_native,
|
|
true, // skip_libc
|
|
skip_stage1,
|
|
omit_stage2 or true, // TODO get these all passing
|
|
is_stage1,
|
|
));
|
|
|
|
toolchain_step.dependOn(tests.addCompareOutputTests(b, test_filter, modes));
|
|
toolchain_step.dependOn(tests.addStandaloneTests(b, test_filter, modes, skip_non_native, enable_macos_sdk, target, omit_stage2));
|
|
toolchain_step.dependOn(tests.addLinkTests(b, test_filter, modes, enable_macos_sdk, omit_stage2));
|
|
toolchain_step.dependOn(tests.addStackTraceTests(b, test_filter, modes));
|
|
toolchain_step.dependOn(tests.addCliTests(b, test_filter, modes));
|
|
toolchain_step.dependOn(tests.addAssembleAndLinkTests(b, test_filter, modes));
|
|
toolchain_step.dependOn(tests.addTranslateCTests(b, test_filter));
|
|
if (!skip_run_translated_c) {
|
|
toolchain_step.dependOn(tests.addRunTranslatedCTests(b, test_filter, target));
|
|
}
|
|
// tests for this feature are disabled until we have the self-hosted compiler available
|
|
// toolchain_step.dependOn(tests.addGenHTests(b, test_filter));
|
|
|
|
const std_step = tests.addPkgTests(
|
|
b,
|
|
test_filter,
|
|
"lib/std/std.zig",
|
|
"std",
|
|
"Run the standard library tests",
|
|
modes,
|
|
skip_single_threaded,
|
|
skip_non_native,
|
|
skip_libc,
|
|
skip_stage1,
|
|
omit_stage2 or true, // TODO get these all passing
|
|
is_stage1,
|
|
);
|
|
|
|
const test_step = b.step("test", "Run all the tests");
|
|
test_step.dependOn(toolchain_step);
|
|
test_step.dependOn(std_step);
|
|
test_step.dependOn(docs_step);
|
|
}
|
|
|
|
const exe_cflags = [_][]const u8{
|
|
"-std=c++14",
|
|
"-D__STDC_CONSTANT_MACROS",
|
|
"-D__STDC_FORMAT_MACROS",
|
|
"-D__STDC_LIMIT_MACROS",
|
|
"-D_GNU_SOURCE",
|
|
"-fvisibility-inlines-hidden",
|
|
"-fno-exceptions",
|
|
"-fno-rtti",
|
|
"-Werror=type-limits",
|
|
"-Wno-missing-braces",
|
|
"-Wno-comment",
|
|
};
|
|
|
|
fn addCmakeCfgOptionsToExe(
|
|
b: *Builder,
|
|
cfg: CMakeConfig,
|
|
exe: *std.build.LibExeObjStep,
|
|
use_zig_libcxx: bool,
|
|
) !void {
|
|
exe.addObjectFile(fs.path.join(b.allocator, &[_][]const u8{
|
|
cfg.cmake_binary_dir,
|
|
"zigcpp",
|
|
b.fmt("{s}{s}{s}", .{ exe.target.libPrefix(), "zigcpp", exe.target.staticLibSuffix() }),
|
|
}) catch unreachable);
|
|
assert(cfg.lld_include_dir.len != 0);
|
|
exe.addIncludePath(cfg.lld_include_dir);
|
|
addCMakeLibraryList(exe, cfg.clang_libraries);
|
|
addCMakeLibraryList(exe, cfg.lld_libraries);
|
|
addCMakeLibraryList(exe, cfg.llvm_libraries);
|
|
|
|
if (use_zig_libcxx) {
|
|
exe.linkLibCpp();
|
|
} else {
|
|
const need_cpp_includes = true;
|
|
|
|
// System -lc++ must be used because in this code path we are attempting to link
|
|
// against system-provided LLVM, Clang, LLD.
|
|
if (exe.target.getOsTag() == .linux) {
|
|
// First we try to static link against gcc libstdc++. If that doesn't work,
|
|
// we fall back to -lc++ and cross our fingers.
|
|
addCxxKnownPath(b, cfg, exe, "libstdc++.a", "", need_cpp_includes) catch |err| switch (err) {
|
|
error.RequiredLibraryNotFound => {
|
|
exe.linkSystemLibrary("c++");
|
|
},
|
|
else => |e| return e,
|
|
};
|
|
exe.linkSystemLibrary("unwind");
|
|
} else if (exe.target.isFreeBSD()) {
|
|
try addCxxKnownPath(b, cfg, exe, "libc++.a", null, need_cpp_includes);
|
|
exe.linkSystemLibrary("pthread");
|
|
} else if (exe.target.getOsTag() == .openbsd) {
|
|
try addCxxKnownPath(b, cfg, exe, "libc++.a", null, need_cpp_includes);
|
|
try addCxxKnownPath(b, cfg, exe, "libc++abi.a", null, need_cpp_includes);
|
|
} else if (exe.target.isDarwin()) {
|
|
exe.linkSystemLibrary("c++");
|
|
}
|
|
}
|
|
|
|
if (cfg.dia_guids_lib.len != 0) {
|
|
exe.addObjectFile(cfg.dia_guids_lib);
|
|
}
|
|
}
|
|
|
|
fn addStaticLlvmOptionsToExe(exe: *std.build.LibExeObjStep) !void {
|
|
// Adds the Zig C++ sources which both stage1 and stage2 need.
|
|
//
|
|
// We need this because otherwise zig_clang_cc1_main.cpp ends up pulling
|
|
// in a dependency on llvm::cfg::Update<llvm::BasicBlock*>::dump() which is
|
|
// unavailable when LLVM is compiled in Release mode.
|
|
const zig_cpp_cflags = exe_cflags ++ [_][]const u8{"-DNDEBUG=1"};
|
|
exe.addCSourceFiles(&zig_cpp_sources, &zig_cpp_cflags);
|
|
|
|
for (clang_libs) |lib_name| {
|
|
exe.linkSystemLibrary(lib_name);
|
|
}
|
|
|
|
for (lld_libs) |lib_name| {
|
|
exe.linkSystemLibrary(lib_name);
|
|
}
|
|
|
|
for (llvm_libs) |lib_name| {
|
|
exe.linkSystemLibrary(lib_name);
|
|
}
|
|
|
|
exe.linkSystemLibrary("z");
|
|
|
|
// This means we rely on clang-or-zig-built LLVM, Clang, LLD libraries.
|
|
exe.linkSystemLibrary("c++");
|
|
|
|
if (exe.target.getOs().tag == .windows) {
|
|
exe.linkSystemLibrary("version");
|
|
exe.linkSystemLibrary("uuid");
|
|
exe.linkSystemLibrary("ole32");
|
|
}
|
|
}
|
|
|
|
fn addCxxKnownPath(
|
|
b: *Builder,
|
|
ctx: CMakeConfig,
|
|
exe: *std.build.LibExeObjStep,
|
|
objname: []const u8,
|
|
errtxt: ?[]const u8,
|
|
need_cpp_includes: bool,
|
|
) !void {
|
|
if (!std.process.can_spawn)
|
|
return error.RequiredLibraryNotFound;
|
|
const path_padded = try b.exec(&[_][]const u8{
|
|
ctx.cxx_compiler,
|
|
b.fmt("-print-file-name={s}", .{objname}),
|
|
});
|
|
var tokenizer = mem.tokenize(u8, path_padded, "\r\n");
|
|
const path_unpadded = tokenizer.next().?;
|
|
if (mem.eql(u8, path_unpadded, objname)) {
|
|
if (errtxt) |msg| {
|
|
std.debug.print("{s}", .{msg});
|
|
} else {
|
|
std.debug.print("Unable to determine path to {s}\n", .{objname});
|
|
}
|
|
return error.RequiredLibraryNotFound;
|
|
}
|
|
exe.addObjectFile(path_unpadded);
|
|
|
|
// TODO a way to integrate with system c++ include files here
|
|
// cc -E -Wp,-v -xc++ /dev/null
|
|
if (need_cpp_includes) {
|
|
// I used these temporarily for testing something but we obviously need a
|
|
// more general purpose solution here.
|
|
//exe.addIncludePath("/nix/store/fvf3qjqa5qpcjjkq37pb6ypnk1mzhf5h-gcc-9.3.0/lib/gcc/x86_64-unknown-linux-gnu/9.3.0/../../../../include/c++/9.3.0");
|
|
//exe.addIncludePath("/nix/store/fvf3qjqa5qpcjjkq37pb6ypnk1mzhf5h-gcc-9.3.0/lib/gcc/x86_64-unknown-linux-gnu/9.3.0/../../../../include/c++/9.3.0/x86_64-unknown-linux-gnu");
|
|
//exe.addIncludePath("/nix/store/fvf3qjqa5qpcjjkq37pb6ypnk1mzhf5h-gcc-9.3.0/lib/gcc/x86_64-unknown-linux-gnu/9.3.0/../../../../include/c++/9.3.0/backward");
|
|
}
|
|
}
|
|
|
|
fn addCMakeLibraryList(exe: *std.build.LibExeObjStep, list: []const u8) void {
|
|
var it = mem.tokenize(u8, list, ";");
|
|
while (it.next()) |lib| {
|
|
if (mem.startsWith(u8, lib, "-l")) {
|
|
exe.linkSystemLibrary(lib["-l".len..]);
|
|
} else {
|
|
exe.addObjectFile(lib);
|
|
}
|
|
}
|
|
}
|
|
|
|
const CMakeConfig = struct {
|
|
cmake_binary_dir: []const u8,
|
|
cmake_prefix_path: []const u8,
|
|
cxx_compiler: []const u8,
|
|
lld_include_dir: []const u8,
|
|
lld_libraries: []const u8,
|
|
clang_libraries: []const u8,
|
|
llvm_libraries: []const u8,
|
|
dia_guids_lib: []const u8,
|
|
};
|
|
|
|
const max_config_h_bytes = 1 * 1024 * 1024;
|
|
|
|
fn findAndParseConfigH(b: *Builder, config_h_path_option: ?[]const u8) ?CMakeConfig {
|
|
const config_h_text: []const u8 = if (config_h_path_option) |config_h_path| blk: {
|
|
break :blk fs.cwd().readFileAlloc(b.allocator, config_h_path, max_config_h_bytes) catch unreachable;
|
|
} else blk: {
|
|
// TODO this should stop looking for config.h once it detects we hit the
|
|
// zig source root directory.
|
|
var check_dir = fs.path.dirname(b.zig_exe).?;
|
|
while (true) {
|
|
var dir = fs.cwd().openDir(check_dir, .{}) catch unreachable;
|
|
defer dir.close();
|
|
|
|
break :blk dir.readFileAlloc(b.allocator, "config.h", max_config_h_bytes) catch |err| switch (err) {
|
|
error.FileNotFound => {
|
|
const new_check_dir = fs.path.dirname(check_dir);
|
|
if (new_check_dir == null or mem.eql(u8, new_check_dir.?, check_dir)) {
|
|
return null;
|
|
}
|
|
check_dir = new_check_dir.?;
|
|
continue;
|
|
},
|
|
else => unreachable,
|
|
};
|
|
} else unreachable; // TODO should not need `else unreachable`.
|
|
};
|
|
|
|
var ctx: CMakeConfig = .{
|
|
.cmake_binary_dir = undefined,
|
|
.cmake_prefix_path = undefined,
|
|
.cxx_compiler = undefined,
|
|
.lld_include_dir = undefined,
|
|
.lld_libraries = undefined,
|
|
.clang_libraries = undefined,
|
|
.llvm_libraries = undefined,
|
|
.dia_guids_lib = undefined,
|
|
};
|
|
|
|
const mappings = [_]struct { prefix: []const u8, field: []const u8 }{
|
|
.{
|
|
.prefix = "#define ZIG_CMAKE_BINARY_DIR ",
|
|
.field = "cmake_binary_dir",
|
|
},
|
|
.{
|
|
.prefix = "#define ZIG_CMAKE_PREFIX_PATH ",
|
|
.field = "cmake_prefix_path",
|
|
},
|
|
.{
|
|
.prefix = "#define ZIG_CXX_COMPILER ",
|
|
.field = "cxx_compiler",
|
|
},
|
|
.{
|
|
.prefix = "#define ZIG_LLD_INCLUDE_PATH ",
|
|
.field = "lld_include_dir",
|
|
},
|
|
.{
|
|
.prefix = "#define ZIG_LLD_LIBRARIES ",
|
|
.field = "lld_libraries",
|
|
},
|
|
.{
|
|
.prefix = "#define ZIG_CLANG_LIBRARIES ",
|
|
.field = "clang_libraries",
|
|
},
|
|
.{
|
|
.prefix = "#define ZIG_LLVM_LIBRARIES ",
|
|
.field = "llvm_libraries",
|
|
},
|
|
.{
|
|
.prefix = "#define ZIG_DIA_GUIDS_LIB ",
|
|
.field = "dia_guids_lib",
|
|
},
|
|
};
|
|
|
|
var lines_it = mem.tokenize(u8, config_h_text, "\r\n");
|
|
while (lines_it.next()) |line| {
|
|
inline for (mappings) |mapping| {
|
|
if (mem.startsWith(u8, line, mapping.prefix)) {
|
|
var it = mem.split(u8, line, "\"");
|
|
_ = it.next().?; // skip the stuff before the quote
|
|
const quoted = it.next().?; // the stuff inside the quote
|
|
@field(ctx, mapping.field) = toNativePathSep(b, quoted);
|
|
}
|
|
}
|
|
}
|
|
return ctx;
|
|
}
|
|
|
|
fn toNativePathSep(b: *Builder, s: []const u8) []u8 {
|
|
const duplicated = b.allocator.dupe(u8, s) catch unreachable;
|
|
for (duplicated) |*byte| switch (byte.*) {
|
|
'/' => byte.* = fs.path.sep,
|
|
else => {},
|
|
};
|
|
return duplicated;
|
|
}
|
|
|
|
const softfloat_sources = [_][]const u8{
|
|
"deps/SoftFloat-3e/source/8086/f128M_isSignalingNaN.c",
|
|
"deps/SoftFloat-3e/source/8086/extF80M_isSignalingNaN.c",
|
|
"deps/SoftFloat-3e/source/8086/s_commonNaNToF128M.c",
|
|
"deps/SoftFloat-3e/source/8086/s_commonNaNToExtF80M.c",
|
|
"deps/SoftFloat-3e/source/8086/s_commonNaNToF16UI.c",
|
|
"deps/SoftFloat-3e/source/8086/s_commonNaNToF32UI.c",
|
|
"deps/SoftFloat-3e/source/8086/s_commonNaNToF64UI.c",
|
|
"deps/SoftFloat-3e/source/8086/s_f128MToCommonNaN.c",
|
|
"deps/SoftFloat-3e/source/8086/s_extF80MToCommonNaN.c",
|
|
"deps/SoftFloat-3e/source/8086/s_f16UIToCommonNaN.c",
|
|
"deps/SoftFloat-3e/source/8086/s_f32UIToCommonNaN.c",
|
|
"deps/SoftFloat-3e/source/8086/s_f64UIToCommonNaN.c",
|
|
"deps/SoftFloat-3e/source/8086/s_propagateNaNF128M.c",
|
|
"deps/SoftFloat-3e/source/8086/s_propagateNaNExtF80M.c",
|
|
"deps/SoftFloat-3e/source/8086/s_propagateNaNF16UI.c",
|
|
"deps/SoftFloat-3e/source/8086/softfloat_raiseFlags.c",
|
|
"deps/SoftFloat-3e/source/f128M_add.c",
|
|
"deps/SoftFloat-3e/source/f128M_div.c",
|
|
"deps/SoftFloat-3e/source/f128M_eq.c",
|
|
"deps/SoftFloat-3e/source/f128M_eq_signaling.c",
|
|
"deps/SoftFloat-3e/source/f128M_le.c",
|
|
"deps/SoftFloat-3e/source/f128M_le_quiet.c",
|
|
"deps/SoftFloat-3e/source/f128M_lt.c",
|
|
"deps/SoftFloat-3e/source/f128M_lt_quiet.c",
|
|
"deps/SoftFloat-3e/source/f128M_mul.c",
|
|
"deps/SoftFloat-3e/source/f128M_mulAdd.c",
|
|
"deps/SoftFloat-3e/source/f128M_rem.c",
|
|
"deps/SoftFloat-3e/source/f128M_roundToInt.c",
|
|
"deps/SoftFloat-3e/source/f128M_sqrt.c",
|
|
"deps/SoftFloat-3e/source/f128M_sub.c",
|
|
"deps/SoftFloat-3e/source/f128M_to_f16.c",
|
|
"deps/SoftFloat-3e/source/f128M_to_f32.c",
|
|
"deps/SoftFloat-3e/source/f128M_to_f64.c",
|
|
"deps/SoftFloat-3e/source/f128M_to_extF80M.c",
|
|
"deps/SoftFloat-3e/source/f128M_to_i32.c",
|
|
"deps/SoftFloat-3e/source/f128M_to_i32_r_minMag.c",
|
|
"deps/SoftFloat-3e/source/f128M_to_i64.c",
|
|
"deps/SoftFloat-3e/source/f128M_to_i64_r_minMag.c",
|
|
"deps/SoftFloat-3e/source/f128M_to_ui32.c",
|
|
"deps/SoftFloat-3e/source/f128M_to_ui32_r_minMag.c",
|
|
"deps/SoftFloat-3e/source/f128M_to_ui64.c",
|
|
"deps/SoftFloat-3e/source/f128M_to_ui64_r_minMag.c",
|
|
"deps/SoftFloat-3e/source/extF80M_add.c",
|
|
"deps/SoftFloat-3e/source/extF80M_div.c",
|
|
"deps/SoftFloat-3e/source/extF80M_eq.c",
|
|
"deps/SoftFloat-3e/source/extF80M_le.c",
|
|
"deps/SoftFloat-3e/source/extF80M_lt.c",
|
|
"deps/SoftFloat-3e/source/extF80M_mul.c",
|
|
"deps/SoftFloat-3e/source/extF80M_rem.c",
|
|
"deps/SoftFloat-3e/source/extF80M_roundToInt.c",
|
|
"deps/SoftFloat-3e/source/extF80M_sqrt.c",
|
|
"deps/SoftFloat-3e/source/extF80M_sub.c",
|
|
"deps/SoftFloat-3e/source/extF80M_to_f16.c",
|
|
"deps/SoftFloat-3e/source/extF80M_to_f32.c",
|
|
"deps/SoftFloat-3e/source/extF80M_to_f64.c",
|
|
"deps/SoftFloat-3e/source/extF80M_to_f128M.c",
|
|
"deps/SoftFloat-3e/source/f16_add.c",
|
|
"deps/SoftFloat-3e/source/f16_div.c",
|
|
"deps/SoftFloat-3e/source/f16_eq.c",
|
|
"deps/SoftFloat-3e/source/f16_isSignalingNaN.c",
|
|
"deps/SoftFloat-3e/source/f16_lt.c",
|
|
"deps/SoftFloat-3e/source/f16_mul.c",
|
|
"deps/SoftFloat-3e/source/f16_mulAdd.c",
|
|
"deps/SoftFloat-3e/source/f16_rem.c",
|
|
"deps/SoftFloat-3e/source/f16_roundToInt.c",
|
|
"deps/SoftFloat-3e/source/f16_sqrt.c",
|
|
"deps/SoftFloat-3e/source/f16_sub.c",
|
|
"deps/SoftFloat-3e/source/f16_to_extF80M.c",
|
|
"deps/SoftFloat-3e/source/f16_to_f128M.c",
|
|
"deps/SoftFloat-3e/source/f16_to_f64.c",
|
|
"deps/SoftFloat-3e/source/f32_to_extF80M.c",
|
|
"deps/SoftFloat-3e/source/f32_to_f128M.c",
|
|
"deps/SoftFloat-3e/source/f64_to_extF80M.c",
|
|
"deps/SoftFloat-3e/source/f64_to_f128M.c",
|
|
"deps/SoftFloat-3e/source/f64_to_f16.c",
|
|
"deps/SoftFloat-3e/source/i32_to_f128M.c",
|
|
"deps/SoftFloat-3e/source/s_add256M.c",
|
|
"deps/SoftFloat-3e/source/s_addCarryM.c",
|
|
"deps/SoftFloat-3e/source/s_addComplCarryM.c",
|
|
"deps/SoftFloat-3e/source/s_addF128M.c",
|
|
"deps/SoftFloat-3e/source/s_addExtF80M.c",
|
|
"deps/SoftFloat-3e/source/s_addM.c",
|
|
"deps/SoftFloat-3e/source/s_addMagsF16.c",
|
|
"deps/SoftFloat-3e/source/s_addMagsF32.c",
|
|
"deps/SoftFloat-3e/source/s_addMagsF64.c",
|
|
"deps/SoftFloat-3e/source/s_approxRecip32_1.c",
|
|
"deps/SoftFloat-3e/source/s_approxRecipSqrt32_1.c",
|
|
"deps/SoftFloat-3e/source/s_approxRecipSqrt_1Ks.c",
|
|
"deps/SoftFloat-3e/source/s_approxRecip_1Ks.c",
|
|
"deps/SoftFloat-3e/source/s_compare128M.c",
|
|
"deps/SoftFloat-3e/source/s_compare96M.c",
|
|
"deps/SoftFloat-3e/source/s_compareNonnormExtF80M.c",
|
|
"deps/SoftFloat-3e/source/s_countLeadingZeros16.c",
|
|
"deps/SoftFloat-3e/source/s_countLeadingZeros32.c",
|
|
"deps/SoftFloat-3e/source/s_countLeadingZeros64.c",
|
|
"deps/SoftFloat-3e/source/s_countLeadingZeros8.c",
|
|
"deps/SoftFloat-3e/source/s_eq128.c",
|
|
"deps/SoftFloat-3e/source/s_invalidF128M.c",
|
|
"deps/SoftFloat-3e/source/s_invalidExtF80M.c",
|
|
"deps/SoftFloat-3e/source/s_isNaNF128M.c",
|
|
"deps/SoftFloat-3e/source/s_le128.c",
|
|
"deps/SoftFloat-3e/source/s_lt128.c",
|
|
"deps/SoftFloat-3e/source/s_mul128MTo256M.c",
|
|
"deps/SoftFloat-3e/source/s_mul64To128M.c",
|
|
"deps/SoftFloat-3e/source/s_mulAddF128M.c",
|
|
"deps/SoftFloat-3e/source/s_mulAddF16.c",
|
|
"deps/SoftFloat-3e/source/s_mulAddF32.c",
|
|
"deps/SoftFloat-3e/source/s_mulAddF64.c",
|
|
"deps/SoftFloat-3e/source/s_negXM.c",
|
|
"deps/SoftFloat-3e/source/s_normExtF80SigM.c",
|
|
"deps/SoftFloat-3e/source/s_normRoundPackMToF128M.c",
|
|
"deps/SoftFloat-3e/source/s_normRoundPackMToExtF80M.c",
|
|
"deps/SoftFloat-3e/source/s_normRoundPackToF16.c",
|
|
"deps/SoftFloat-3e/source/s_normRoundPackToF32.c",
|
|
"deps/SoftFloat-3e/source/s_normRoundPackToF64.c",
|
|
"deps/SoftFloat-3e/source/s_normSubnormalF128SigM.c",
|
|
"deps/SoftFloat-3e/source/s_normSubnormalF16Sig.c",
|
|
"deps/SoftFloat-3e/source/s_normSubnormalF32Sig.c",
|
|
"deps/SoftFloat-3e/source/s_normSubnormalF64Sig.c",
|
|
"deps/SoftFloat-3e/source/s_remStepMBy32.c",
|
|
"deps/SoftFloat-3e/source/s_roundMToI64.c",
|
|
"deps/SoftFloat-3e/source/s_roundMToUI64.c",
|
|
"deps/SoftFloat-3e/source/s_roundPackMToExtF80M.c",
|
|
"deps/SoftFloat-3e/source/s_roundPackMToF128M.c",
|
|
"deps/SoftFloat-3e/source/s_roundPackToF16.c",
|
|
"deps/SoftFloat-3e/source/s_roundPackToF32.c",
|
|
"deps/SoftFloat-3e/source/s_roundPackToF64.c",
|
|
"deps/SoftFloat-3e/source/s_roundToI32.c",
|
|
"deps/SoftFloat-3e/source/s_roundToI64.c",
|
|
"deps/SoftFloat-3e/source/s_roundToUI32.c",
|
|
"deps/SoftFloat-3e/source/s_roundToUI64.c",
|
|
"deps/SoftFloat-3e/source/s_shiftLeftM.c",
|
|
"deps/SoftFloat-3e/source/s_shiftNormSigF128M.c",
|
|
"deps/SoftFloat-3e/source/s_shiftRightJam256M.c",
|
|
"deps/SoftFloat-3e/source/s_shiftRightJam32.c",
|
|
"deps/SoftFloat-3e/source/s_shiftRightJam64.c",
|
|
"deps/SoftFloat-3e/source/s_shiftRightJamM.c",
|
|
"deps/SoftFloat-3e/source/s_shiftRightM.c",
|
|
"deps/SoftFloat-3e/source/s_shortShiftLeft64To96M.c",
|
|
"deps/SoftFloat-3e/source/s_shortShiftLeftM.c",
|
|
"deps/SoftFloat-3e/source/s_shortShiftRightExtendM.c",
|
|
"deps/SoftFloat-3e/source/s_shortShiftRightJam64.c",
|
|
"deps/SoftFloat-3e/source/s_shortShiftRightJamM.c",
|
|
"deps/SoftFloat-3e/source/s_shortShiftRightM.c",
|
|
"deps/SoftFloat-3e/source/s_sub1XM.c",
|
|
"deps/SoftFloat-3e/source/s_sub256M.c",
|
|
"deps/SoftFloat-3e/source/s_subM.c",
|
|
"deps/SoftFloat-3e/source/s_subMagsF16.c",
|
|
"deps/SoftFloat-3e/source/s_subMagsF32.c",
|
|
"deps/SoftFloat-3e/source/s_subMagsF64.c",
|
|
"deps/SoftFloat-3e/source/s_tryPropagateNaNF128M.c",
|
|
"deps/SoftFloat-3e/source/s_tryPropagateNaNExtF80M.c",
|
|
"deps/SoftFloat-3e/source/softfloat_state.c",
|
|
"deps/SoftFloat-3e/source/ui32_to_f128M.c",
|
|
"deps/SoftFloat-3e/source/ui64_to_f128M.c",
|
|
"deps/SoftFloat-3e/source/ui32_to_extF80M.c",
|
|
"deps/SoftFloat-3e/source/ui64_to_extF80M.c",
|
|
};
|
|
|
|
const stage1_sources = [_][]const u8{
|
|
"src/stage1/analyze.cpp",
|
|
"src/stage1/astgen.cpp",
|
|
"src/stage1/bigfloat.cpp",
|
|
"src/stage1/bigint.cpp",
|
|
"src/stage1/buffer.cpp",
|
|
"src/stage1/codegen.cpp",
|
|
"src/stage1/dump_analysis.cpp",
|
|
"src/stage1/errmsg.cpp",
|
|
"src/stage1/error.cpp",
|
|
"src/stage1/heap.cpp",
|
|
"src/stage1/ir.cpp",
|
|
"src/stage1/ir_print.cpp",
|
|
"src/stage1/mem.cpp",
|
|
"src/stage1/os.cpp",
|
|
"src/stage1/parser.cpp",
|
|
"src/stage1/range_set.cpp",
|
|
"src/stage1/stage1.cpp",
|
|
"src/stage1/target.cpp",
|
|
"src/stage1/tokenizer.cpp",
|
|
"src/stage1/util.cpp",
|
|
"src/stage1/softfloat_ext.cpp",
|
|
};
|
|
const optimized_c_sources = [_][]const u8{
|
|
"src/stage1/parse_f128.c",
|
|
};
|
|
const zig_cpp_sources = [_][]const u8{
|
|
// These are planned to stay even when we are self-hosted.
|
|
"src/zig_llvm.cpp",
|
|
"src/zig_clang.cpp",
|
|
"src/zig_llvm-ar.cpp",
|
|
"src/zig_clang_driver.cpp",
|
|
"src/zig_clang_cc1_main.cpp",
|
|
"src/zig_clang_cc1as_main.cpp",
|
|
// https://github.com/ziglang/zig/issues/6363
|
|
"src/windows_sdk.cpp",
|
|
};
|
|
|
|
const clang_libs = [_][]const u8{
|
|
"clangFrontendTool",
|
|
"clangCodeGen",
|
|
"clangFrontend",
|
|
"clangDriver",
|
|
"clangSerialization",
|
|
"clangSema",
|
|
"clangStaticAnalyzerFrontend",
|
|
"clangStaticAnalyzerCheckers",
|
|
"clangStaticAnalyzerCore",
|
|
"clangAnalysis",
|
|
"clangASTMatchers",
|
|
"clangAST",
|
|
"clangParse",
|
|
"clangSema",
|
|
"clangBasic",
|
|
"clangEdit",
|
|
"clangLex",
|
|
"clangARCMigrate",
|
|
"clangRewriteFrontend",
|
|
"clangRewrite",
|
|
"clangCrossTU",
|
|
"clangIndex",
|
|
"clangToolingCore",
|
|
};
|
|
const lld_libs = [_][]const u8{
|
|
"lldMinGW",
|
|
"lldELF",
|
|
"lldCOFF",
|
|
"lldWasm",
|
|
"lldMachO",
|
|
"lldCommon",
|
|
};
|
|
// This list can be re-generated with `llvm-config --libfiles` and then
|
|
// reformatting using your favorite text editor. Note we do not execute
|
|
// `llvm-config` here because we are cross compiling. Also omit LLVMTableGen
|
|
// from these libs.
|
|
const llvm_libs = [_][]const u8{
|
|
"LLVMWindowsManifest",
|
|
"LLVMXRay",
|
|
"LLVMLibDriver",
|
|
"LLVMDlltoolDriver",
|
|
"LLVMCoverage",
|
|
"LLVMLineEditor",
|
|
"LLVMXCoreDisassembler",
|
|
"LLVMXCoreCodeGen",
|
|
"LLVMXCoreDesc",
|
|
"LLVMXCoreInfo",
|
|
"LLVMX86TargetMCA",
|
|
"LLVMX86Disassembler",
|
|
"LLVMX86AsmParser",
|
|
"LLVMX86CodeGen",
|
|
"LLVMX86Desc",
|
|
"LLVMX86Info",
|
|
"LLVMWebAssemblyDisassembler",
|
|
"LLVMWebAssemblyAsmParser",
|
|
"LLVMWebAssemblyCodeGen",
|
|
"LLVMWebAssemblyDesc",
|
|
"LLVMWebAssemblyUtils",
|
|
"LLVMWebAssemblyInfo",
|
|
"LLVMVEDisassembler",
|
|
"LLVMVEAsmParser",
|
|
"LLVMVECodeGen",
|
|
"LLVMVEDesc",
|
|
"LLVMVEInfo",
|
|
"LLVMSystemZDisassembler",
|
|
"LLVMSystemZAsmParser",
|
|
"LLVMSystemZCodeGen",
|
|
"LLVMSystemZDesc",
|
|
"LLVMSystemZInfo",
|
|
"LLVMSparcDisassembler",
|
|
"LLVMSparcAsmParser",
|
|
"LLVMSparcCodeGen",
|
|
"LLVMSparcDesc",
|
|
"LLVMSparcInfo",
|
|
"LLVMRISCVDisassembler",
|
|
"LLVMRISCVAsmParser",
|
|
"LLVMRISCVCodeGen",
|
|
"LLVMRISCVDesc",
|
|
"LLVMRISCVInfo",
|
|
"LLVMPowerPCDisassembler",
|
|
"LLVMPowerPCAsmParser",
|
|
"LLVMPowerPCCodeGen",
|
|
"LLVMPowerPCDesc",
|
|
"LLVMPowerPCInfo",
|
|
"LLVMNVPTXCodeGen",
|
|
"LLVMNVPTXDesc",
|
|
"LLVMNVPTXInfo",
|
|
"LLVMMSP430Disassembler",
|
|
"LLVMMSP430AsmParser",
|
|
"LLVMMSP430CodeGen",
|
|
"LLVMMSP430Desc",
|
|
"LLVMMSP430Info",
|
|
"LLVMMipsDisassembler",
|
|
"LLVMMipsAsmParser",
|
|
"LLVMMipsCodeGen",
|
|
"LLVMMipsDesc",
|
|
"LLVMMipsInfo",
|
|
"LLVMLanaiDisassembler",
|
|
"LLVMLanaiCodeGen",
|
|
"LLVMLanaiAsmParser",
|
|
"LLVMLanaiDesc",
|
|
"LLVMLanaiInfo",
|
|
"LLVMHexagonDisassembler",
|
|
"LLVMHexagonCodeGen",
|
|
"LLVMHexagonAsmParser",
|
|
"LLVMHexagonDesc",
|
|
"LLVMHexagonInfo",
|
|
"LLVMBPFDisassembler",
|
|
"LLVMBPFAsmParser",
|
|
"LLVMBPFCodeGen",
|
|
"LLVMBPFDesc",
|
|
"LLVMBPFInfo",
|
|
"LLVMAVRDisassembler",
|
|
"LLVMAVRAsmParser",
|
|
"LLVMAVRCodeGen",
|
|
"LLVMAVRDesc",
|
|
"LLVMAVRInfo",
|
|
"LLVMARMDisassembler",
|
|
"LLVMARMAsmParser",
|
|
"LLVMARMCodeGen",
|
|
"LLVMARMDesc",
|
|
"LLVMARMUtils",
|
|
"LLVMARMInfo",
|
|
"LLVMAMDGPUTargetMCA",
|
|
"LLVMAMDGPUDisassembler",
|
|
"LLVMAMDGPUAsmParser",
|
|
"LLVMAMDGPUCodeGen",
|
|
"LLVMAMDGPUDesc",
|
|
"LLVMAMDGPUUtils",
|
|
"LLVMAMDGPUInfo",
|
|
"LLVMAArch64Disassembler",
|
|
"LLVMAArch64AsmParser",
|
|
"LLVMAArch64CodeGen",
|
|
"LLVMAArch64Desc",
|
|
"LLVMAArch64Utils",
|
|
"LLVMAArch64Info",
|
|
"LLVMOrcJIT",
|
|
"LLVMMCJIT",
|
|
"LLVMJITLink",
|
|
"LLVMInterpreter",
|
|
"LLVMExecutionEngine",
|
|
"LLVMRuntimeDyld",
|
|
"LLVMOrcTargetProcess",
|
|
"LLVMOrcShared",
|
|
"LLVMDWP",
|
|
"LLVMSymbolize",
|
|
"LLVMDebugInfoPDB",
|
|
"LLVMDebugInfoGSYM",
|
|
"LLVMOption",
|
|
"LLVMObjectYAML",
|
|
"LLVMMCA",
|
|
"LLVMMCDisassembler",
|
|
"LLVMLTO",
|
|
"LLVMPasses",
|
|
"LLVMCFGuard",
|
|
"LLVMCoroutines",
|
|
"LLVMObjCARCOpts",
|
|
"LLVMipo",
|
|
"LLVMVectorize",
|
|
"LLVMLinker",
|
|
"LLVMInstrumentation",
|
|
"LLVMFrontendOpenMP",
|
|
"LLVMFrontendOpenACC",
|
|
"LLVMExtensions",
|
|
"LLVMDWARFLinker",
|
|
"LLVMGlobalISel",
|
|
"LLVMMIRParser",
|
|
"LLVMAsmPrinter",
|
|
"LLVMDebugInfoMSF",
|
|
"LLVMSelectionDAG",
|
|
"LLVMCodeGen",
|
|
"LLVMIRReader",
|
|
"LLVMAsmParser",
|
|
"LLVMInterfaceStub",
|
|
"LLVMFileCheck",
|
|
"LLVMFuzzMutate",
|
|
"LLVMTarget",
|
|
"LLVMScalarOpts",
|
|
"LLVMInstCombine",
|
|
"LLVMAggressiveInstCombine",
|
|
"LLVMTransformUtils",
|
|
"LLVMBitWriter",
|
|
"LLVMAnalysis",
|
|
"LLVMProfileData",
|
|
"LLVMDebugInfoDWARF",
|
|
"LLVMObject",
|
|
"LLVMTextAPI",
|
|
"LLVMMCParser",
|
|
"LLVMMC",
|
|
"LLVMDebugInfoCodeView",
|
|
"LLVMBitReader",
|
|
"LLVMCore",
|
|
"LLVMRemarks",
|
|
"LLVMBitstreamReader",
|
|
"LLVMBinaryFormat",
|
|
"LLVMSupport",
|
|
"LLVMDemangle",
|
|
};
|