const std = @import("std"); const builtin = std.builtin; const tests = @import("test/tests.zig"); const BufMap = std.BufMap; const mem = std.mem; const io = std.io; const fs = std.fs; const InstallDirectoryOptions = std.Build.InstallDirectoryOptions; const assert = std.debug.assert; const DevEnv = @import("src/dev.zig").Env; const ValueInterpretMode = enum { direct, by_name }; const corpus = @import("stage0/corpus.zig"); const zig0_headers = &[_][]const u8{ "air.h", "ast.h", "astgen.h", "common.h", "compilation.h", "intern_pool.h", "parser.h", "sema.h", "type.h", "value.h", "verbose_air.h", "verbose_intern_pool.h", "wyhash.h", "zcu.h", "zcu_per_thread.h", "zir.h", }; const zig0_c_lib_files = &[_][]const u8{ "air.c", "ast.c", "astgen.c", "intern_pool.c", "parser.c", "sema.c", "tokenizer.c", "type.c", "value.c", "verbose_air.c", "verbose_intern_pool.c", "wyhash.c", "zig0.c", "zcu.c", "zcu_per_thread.c", "zir.c", }; const zig0_all_c_files = zig0_c_lib_files ++ &[_][]const u8{"main.c"}; const zig0_cflags = &[_][]const u8{ "-std=c99", "-pedantic", "-Wall", "-Wvla", "-Wextra", "-Werror", "-Wshadow", "-Wswitch", "-Walloca", "-Wformat=2", "-fno-common", "-Wconversion", "-Wuninitialized", "-Wdouble-promotion", "-fstack-protector-all", "-Wimplicit-fallthrough", "-Wno-unused-function", }; const zig0_compilers = &[_][]const u8{ "zig", "clang", "gcc", "tcc" }; const zig_version: std.SemanticVersion = .{ .major = 0, .minor = 15, .patch = 3 }; const stack_size = 46 * 1024 * 1024; pub fn build(b: *std.Build) !void { const only_c = b.option(bool, "only-c", "Translate the Zig compiler to C code, with only the C backend enabled") orelse false; const target = b.standardTargetOptions(.{ .default_target = .{ .ofmt = if (only_c) .c else null, }, }); const optimize = b.standardOptimizeOption(.{}); const flat = b.option(bool, "flat", "Put files into the installation prefix in a manner suited for upstream distribution rather than a posix file system hierarchy standard") orelse false; 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 test_step = b.step("test", "Run all the tests"); const skip_install_lib_files = b.option(bool, "no-lib", "skip copying of lib/ files and langref to installation prefix. Useful for development") orelse false; const skip_install_langref = b.option(bool, "no-langref", "skip copying of langref to the installation prefix") orelse skip_install_lib_files; const std_docs = b.option(bool, "std-docs", "include standard library autodocs") orelse false; const no_bin = b.option(bool, "no-bin", "skip emitting compiler binary") orelse false; const enable_superhtml = b.option(bool, "enable-superhtml", "Check langref output HTML validity") orelse false; const langref_file = generateLangRef(b); const install_langref = b.addInstallFileWithDir(langref_file, .prefix, "doc/langref.html"); const check_langref = superHtmlCheck(b, langref_file); if (enable_superhtml) install_langref.step.dependOn(check_langref); const check_autodocs = superHtmlCheck(b, b.path("lib/docs/index.html")); if (enable_superhtml) { test_step.dependOn(check_langref); test_step.dependOn(check_autodocs); } if (!skip_install_langref) { b.getInstallStep().dependOn(&install_langref.step); } const autodoc_test = b.addObject(.{ .name = "std", .zig_lib_dir = b.path("lib"), .root_module = b.createModule(.{ .root_source_file = b.path("lib/std/std.zig"), .target = target, .optimize = .Debug, }), }); const install_std_docs = b.addInstallDirectory(.{ .source_dir = autodoc_test.getEmittedDocs(), .install_dir = .prefix, .install_subdir = "doc/std", }); //if (enable_tidy) install_std_docs.step.dependOn(check_autodocs); if (std_docs) { b.getInstallStep().dependOn(&install_std_docs.step); } if (flat) { b.installFile("LICENSE", "LICENSE"); b.installFile("README.md", "README.md"); } const langref_step = b.step("langref", "Build and install the language reference"); langref_step.dependOn(&install_langref.step); const std_docs_step = b.step("std-docs", "Build and install the standard library documentation"); std_docs_step.dependOn(&install_std_docs.step); const docs_step = b.step("docs", "Build and install documentation"); docs_step.dependOn(langref_step); docs_step.dependOn(std_docs_step); 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_compile_errors = b.option(bool, "skip-compile-errors", "Main test suite skips compile error tests") orelse false; const skip_translate_c = b.option(bool, "skip-translate-c", "Main test suite skips translate-c 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_freebsd = b.option(bool, "skip-freebsd", "Main test suite skips targets with freebsd OS") orelse false; const skip_netbsd = b.option(bool, "skip-netbsd", "Main test suite skips targets with netbsd OS") orelse false; const skip_windows = b.option(bool, "skip-windows", "Main test suite skips targets with windows OS") orelse false; const skip_macos = b.option(bool, "skip-macos", "Main test suite skips targets with macos OS") orelse false; const skip_linux = b.option(bool, "skip-linux", "Main test suite skips targets with linux OS") orelse false; const skip_llvm = b.option(bool, "skip-llvm", "Main test suite skips targets that use LLVM backend") orelse false; const only_install_lib_files = b.option(bool, "lib-files-only", "Only install library files") 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 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 llvm_has_xtensa = b.option( bool, "llvm-has-xtensa", "Whether LLVM has the experimental target xtensa enabled", ) orelse false; const enable_ios_sdk = b.option(bool, "enable-ios-sdk", "Run tests requiring presence of iOS SDK and frameworks") orelse false; const enable_macos_sdk = b.option(bool, "enable-macos-sdk", "Run tests requiring presence of macOS SDK and frameworks") orelse enable_ios_sdk; const enable_symlinks_windows = b.option(bool, "enable-symlinks-windows", "Run tests requiring presence of symlinks on Windows") 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(.{ .source_dir = b.path("lib"), .install_dir = if (flat) .prefix else .lib, .install_subdir = if (flat) "lib" else "zig", .exclude_extensions = &[_][]const u8{ // exclude files from lib/std/compress/testdata ".gz", ".z.0", ".z.9", ".zst.3", ".zst.19", "rfc1951.txt", "rfc1952.txt", "rfc8478.txt", // exclude files from lib/std/compress/flate/testdata ".expect", ".expect-noinput", ".golden", ".input", "compress-e.txt", "compress-gettysburg.txt", "compress-pi.txt", "rfc1951.txt", // exclude files from lib/std/compress/lzma/testdata ".lzma", // exclude files from lib/std/compress/xz/testdata ".xz", // exclude files from lib/std/tz/ ".tzif", // exclude files from lib/std/tar/testdata ".tar", // others "README.md", }, .blank_extensions = &[_][]const u8{ "test.zig", }, }); } if (only_install_lib_files) return; const entitlements = b.option([]const u8, "entitlements", "Path to entitlements file for hot-code swapping without sudo on macOS"); 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 (tracy != null); const tracy_allocation = b.option(bool, "tracy-allocation", "Include allocation information with Tracy data. Does nothing if -Dtracy is not provided") orelse (tracy != null); const tracy_callstack_depth: u32 = b.option(u32, "tracy-callstack-depth", "Declare callstack depth for Tracy data. Does nothing if -Dtracy_callstack is not provided") orelse 10; const debug_gpa = b.option(bool, "debug-allocator", "Force the compiler to use DebugAllocator") orelse false; const link_libc = b.option(bool, "force-link-libc", "Force self-hosted compiler to link libc") orelse (enable_llvm or only_c); const sanitize_thread = b.option(bool, "sanitize-thread", "Enable thread-sanitization") orelse false; const strip = b.option(bool, "strip", "Omit debug information"); const valgrind = b.option(bool, "valgrind", "Enable valgrind integration"); const pie = b.option(bool, "pie", "Produce a Position Independent Executable"); const value_interpret_mode = b.option(ValueInterpretMode, "value-interpret-mode", "How the compiler translates between 'std.builtin' types and its internal datastructures") orelse .direct; 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 == true) break :blk @as(u32, 0); if (optimize != .Debug) break :blk 0; break :blk 4; }; const exe = addCompilerStep(b, .{ .optimize = optimize, .target = target, .strip = strip, .valgrind = valgrind, .sanitize_thread = sanitize_thread, .single_threaded = single_threaded, }); exe.pie = pie; exe.entitlements = entitlements; const use_llvm = b.option(bool, "use-llvm", "Use the llvm backend"); exe.use_llvm = use_llvm; exe.use_lld = use_llvm; if (no_bin) { b.getInstallStep().dependOn(&exe.step); } else { const install_exe = b.addInstallArtifact(exe, .{ .dest_dir = if (flat) .{ .override = .prefix } else .default, }); b.getInstallStep().dependOn(&install_exe.step); } test_step.dependOn(&exe.step); const exe_options = b.addOptions(); exe.root_module.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, "llvm_has_xtensa", llvm_has_xtensa); exe_options.addOption(bool, "debug_gpa", debug_gpa); const dev_mode: DevEnv = b.option(DevEnv, "dev", "Build a compiler with a reduced feature set for development of specific features") orelse if (only_c) .bootstrap else .full; exe_options.addOption(DevEnv, "dev", dev_mode); exe_options.addOption(ValueInterpretMode, "value_interpret_mode", value_interpret_mode); if (link_libc) { exe.root_module.link_libc = true; } const is_debug = optimize == .Debug; const enable_debug_extensions = b.option(bool, "debug-extensions", "Enable commands and options useful for debugging the compiler") orelse is_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_slice = 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.runAllowFail(&[_][]const u8{ "git", "-C", b.build_root.path orelse ".", // affects the --git-dir argument "--git-dir", ".git", // affected by the -C argument "describe", "--match", "*.*.*", // "--tags", "--abbrev=9", }, &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.10.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.10.0-dev.2025+ecf0050a9). var it = mem.splitScalar(u8, git_describe, '-'); const tagged_ancestor = it.first(); const commit_height = it.next().?; const commit_id = it.next().?; const ancestor_ver = try std.SemanticVersion.parse(tagged_ancestor); if (zig_version.order(ancestor_ver) != .gt) { std.debug.print("Zig version '{f}' must be greater than tagged ancestor '{f}'\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; }, } }; const version = try b.allocator.dupeZ(u8, version_slice); exe_options.addOption([:0]const u8, "version", version); if (enable_llvm) { const cmake_cfg = if (static_llvm) null else blk: { if (findConfigH(b, config_h_path_option)) |config_h_path| { const file_contents = fs.cwd().readFileAlloc(b.allocator, config_h_path, max_config_h_bytes) catch unreachable; break :blk parseConfigH(b, file_contents); } else { std.log.warn("config.h could not be located automatically. Consider providing it explicitly via \"-Dconfig_h\"", .{}); break :blk null; } }; 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) { var it = mem.tokenizeScalar(u8, cfg.cmake_prefix_path, ';'); while (it.next()) |path| { b.addSearchPrefix(path); } } try addCmakeCfgOptionsToExe(b, cfg, exe, use_zig_libcxx); } else { // Here we are -Denable-llvm but no cmake integration. try addStaticLlvmOptionsToModule(exe.root_module, .{ .llvm_has_m68k = llvm_has_m68k, .llvm_has_csky = llvm_has_csky, .llvm_has_arc = llvm_has_arc, .llvm_has_xtensa = llvm_has_xtensa, }); } if (target.result.os.tag == .windows) { // LLVM depends on networking as of version 18. exe.root_module.linkSystemLibrary("ws2_32", .{}); exe.root_module.linkSystemLibrary("version", .{}); exe.root_module.linkSystemLibrary("uuid", .{}); exe.root_module.linkSystemLibrary("ole32", .{}); } } const semver = try std.SemanticVersion.parse(version); exe_options.addOption(std.SemanticVersion, "semver", semver); exe_options.addOption(bool, "enable_debug_extensions", enable_debug_extensions); 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(u32, "tracy_callstack_depth", tracy_callstack_depth); exe_options.addOption(bool, "value_tracing", value_tracing); if (tracy) |tracy_path| { const client_cpp = b.pathJoin( &[_][]const u8{ tracy_path, "public", "TracyClient.cpp" }, ); const tracy_c_flags: []const []const u8 = &.{ "-DTRACY_ENABLE=1", "-fno-sanitize=undefined" }; exe.root_module.addIncludePath(.{ .cwd_relative = tracy_path }); exe.root_module.addCSourceFile(.{ .file = .{ .cwd_relative = client_cpp }, .flags = tracy_c_flags }); if (!enable_llvm) { exe.root_module.linkSystemLibrary("c++", .{ .use_pkg_config = .no }); } exe.root_module.link_libc = true; if (target.result.os.tag == .windows) { exe.root_module.linkSystemLibrary("dbghelp", .{}); exe.root_module.linkSystemLibrary("ws2_32", .{}); } } const test_filters = b.option([]const []const u8, "test-filter", "Skip tests that do not match any filter") orelse &[0][]const u8{}; const test_target_filters = b.option([]const []const u8, "test-target-filter", "Skip tests whose target triple do not match any filter") orelse &[0][]const u8{}; const test_extra_targets = b.option(bool, "test-extra-targets", "Enable running module tests for additional targets") orelse false; var chosen_opt_modes_buf: [4]builtin.OptimizeMode = undefined; var chosen_mode_index: usize = 0; if (!skip_debug) { chosen_opt_modes_buf[chosen_mode_index] = builtin.OptimizeMode.Debug; chosen_mode_index += 1; } if (!skip_release_safe) { chosen_opt_modes_buf[chosen_mode_index] = builtin.OptimizeMode.ReleaseSafe; chosen_mode_index += 1; } if (!skip_release_fast) { chosen_opt_modes_buf[chosen_mode_index] = builtin.OptimizeMode.ReleaseFast; chosen_mode_index += 1; } if (!skip_release_small) { chosen_opt_modes_buf[chosen_mode_index] = builtin.OptimizeMode.ReleaseSmall; chosen_mode_index += 1; } const optimization_modes = chosen_opt_modes_buf[0..chosen_mode_index]; const fmt_include_paths = &.{ "lib", "src", "test", "tools", "build.zig", "build.zig.zon" }; const fmt_exclude_paths = &.{ "test/cases", "test/behavior/zon" }; const do_fmt = b.addFmt(.{ .paths = fmt_include_paths, .exclude_paths = fmt_exclude_paths, }); b.step("fmt", "Modify source files in place to have conforming formatting").dependOn(&do_fmt.step); const check_fmt = b.step("test-fmt", "Check source files having conforming formatting"); check_fmt.dependOn(&b.addFmt(.{ .paths = fmt_include_paths, .exclude_paths = fmt_exclude_paths, .check = true, }).step); test_step.dependOn(check_fmt); const test_cases_step = b.step("test-cases", "Run the main compiler test cases"); try tests.addCases(b, test_cases_step, target, .{ .test_filters = test_filters, .test_target_filters = test_target_filters, .skip_compile_errors = skip_compile_errors, .skip_non_native = skip_non_native, .skip_freebsd = skip_freebsd, .skip_netbsd = skip_netbsd, .skip_windows = skip_windows, .skip_macos = skip_macos, .skip_linux = skip_linux, .skip_llvm = skip_llvm, .skip_libc = skip_libc, }, .{ .skip_translate_c = skip_translate_c, .skip_run_translated_c = skip_run_translated_c, }, .{ .enable_llvm = enable_llvm, .llvm_has_m68k = llvm_has_m68k, .llvm_has_csky = llvm_has_csky, .llvm_has_arc = llvm_has_arc, .llvm_has_xtensa = llvm_has_xtensa, }); test_step.dependOn(test_cases_step); const test_modules_step = b.step("test-modules", "Run the per-target module tests"); test_step.dependOn(test_modules_step); test_modules_step.dependOn(tests.addModuleTests(b, .{ .test_filters = test_filters, .test_target_filters = test_target_filters, .test_extra_targets = test_extra_targets, .root_src = "test/behavior.zig", .name = "behavior", .desc = "Run the behavior tests", .optimize_modes = optimization_modes, .include_paths = &.{}, .skip_single_threaded = skip_single_threaded, .skip_non_native = skip_non_native, .skip_freebsd = skip_freebsd, .skip_netbsd = skip_netbsd, .skip_windows = skip_windows, .skip_macos = skip_macos, .skip_linux = skip_linux, .skip_llvm = skip_llvm, .skip_libc = skip_libc, // 3888779264 was observed on an x86_64-linux-gnu host. .max_rss = 4000000000, })); test_modules_step.dependOn(tests.addModuleTests(b, .{ .test_filters = test_filters, .test_target_filters = test_target_filters, .test_extra_targets = test_extra_targets, .root_src = "test/c_import.zig", .name = "c-import", .desc = "Run the @cImport tests", .optimize_modes = optimization_modes, .include_paths = &.{"test/c_import"}, .skip_single_threaded = true, .skip_non_native = skip_non_native, .skip_freebsd = skip_freebsd, .skip_netbsd = skip_netbsd, .skip_windows = skip_windows, .skip_macos = skip_macos, .skip_linux = skip_linux, .skip_llvm = skip_llvm, .skip_libc = skip_libc, })); test_modules_step.dependOn(tests.addModuleTests(b, .{ .test_filters = test_filters, .test_target_filters = test_target_filters, .test_extra_targets = test_extra_targets, .root_src = "lib/compiler_rt.zig", .name = "compiler-rt", .desc = "Run the compiler_rt tests", .optimize_modes = optimization_modes, .include_paths = &.{}, .skip_single_threaded = true, .skip_non_native = skip_non_native, .skip_freebsd = skip_freebsd, .skip_netbsd = skip_netbsd, .skip_windows = skip_windows, .skip_macos = skip_macos, .skip_linux = skip_linux, .skip_llvm = skip_llvm, .skip_libc = true, .no_builtin = true, })); test_modules_step.dependOn(tests.addModuleTests(b, .{ .test_filters = test_filters, .test_target_filters = test_target_filters, .test_extra_targets = test_extra_targets, .root_src = "lib/c.zig", .name = "zigc", .desc = "Run the zigc tests", .optimize_modes = optimization_modes, .include_paths = &.{}, .skip_single_threaded = true, .skip_non_native = skip_non_native, .skip_freebsd = skip_freebsd, .skip_netbsd = skip_netbsd, .skip_windows = skip_windows, .skip_macos = skip_macos, .skip_linux = skip_linux, .skip_llvm = skip_llvm, .skip_libc = true, .no_builtin = true, })); test_modules_step.dependOn(tests.addModuleTests(b, .{ .test_filters = test_filters, .test_target_filters = test_target_filters, .test_extra_targets = test_extra_targets, .root_src = "lib/std/std.zig", .name = "std", .desc = "Run the standard library tests", .optimize_modes = optimization_modes, .include_paths = &.{}, .skip_single_threaded = skip_single_threaded, .skip_non_native = skip_non_native, .skip_freebsd = skip_freebsd, .skip_netbsd = skip_netbsd, .skip_windows = skip_windows, .skip_macos = skip_macos, .skip_linux = skip_linux, .skip_llvm = skip_llvm, .skip_libc = skip_libc, // I observed a value of 5605064704 on the M2 CI. .max_rss = 6165571174, })); const unit_tests_step = b.step("test-unit", "Run the compiler source unit tests"); test_step.dependOn(unit_tests_step); const unit_tests = b.addTest(.{ .root_module = addCompilerMod(b, .{ .optimize = optimize, .target = target, .single_threaded = single_threaded, }), .filters = test_filters, .use_llvm = use_llvm, .use_lld = use_llvm, .zig_lib_dir = b.path("lib"), }); if (link_libc) { unit_tests.root_module.link_libc = true; } unit_tests.root_module.addOptions("build_options", exe_options); unit_tests_step.dependOn(&b.addRunArtifact(unit_tests).step); test_step.dependOn(tests.addCompareOutputTests(b, test_filters, optimization_modes)); test_step.dependOn(tests.addStandaloneTests( b, optimization_modes, enable_macos_sdk, enable_ios_sdk, enable_symlinks_windows, )); test_step.dependOn(tests.addCAbiTests(b, .{ .test_target_filters = test_target_filters, .skip_non_native = skip_non_native, .skip_freebsd = skip_freebsd, .skip_netbsd = skip_netbsd, .skip_windows = skip_windows, .skip_macos = skip_macos, .skip_linux = skip_linux, .skip_llvm = skip_llvm, .skip_release = skip_release, })); test_step.dependOn(tests.addLinkTests(b, enable_macos_sdk, enable_ios_sdk, enable_symlinks_windows)); test_step.dependOn(tests.addStackTraceTests(b, test_filters, optimization_modes)); test_step.dependOn(tests.addCliTests(b)); test_step.dependOn(tests.addAssembleAndLinkTests(b, test_filters, optimization_modes)); if (tests.addDebuggerTests(b, .{ .test_filters = test_filters, .test_target_filters = test_target_filters, .gdb = b.option([]const u8, "gdb", "path to gdb binary"), .lldb = b.option([]const u8, "lldb", "path to lldb binary"), .optimize_modes = optimization_modes, .skip_single_threaded = skip_single_threaded, .skip_libc = skip_libc, })) |test_debugger_step| test_step.dependOn(test_debugger_step); if (tests.addLlvmIrTests(b, .{ .enable_llvm = enable_llvm, .test_filters = test_filters, .test_target_filters = test_target_filters, })) |test_llvm_ir_step| test_step.dependOn(test_llvm_ir_step); try addWasiUpdateStep(b, version); const update_mingw_step = b.step("update-mingw", "Update zig's bundled mingw"); const opt_mingw_src_path = b.option([]const u8, "mingw-src", "path to mingw-w64 source directory"); if (opt_mingw_src_path) |mingw_src_path| { const update_mingw_exe = b.addExecutable(.{ .name = "update_mingw", .root_module = b.createModule(.{ .target = b.graph.host, .root_source_file = b.path("tools/update_mingw.zig"), }), }); const update_mingw_run = b.addRunArtifact(update_mingw_exe); update_mingw_run.addDirectoryArg(b.path("lib")); update_mingw_run.addDirectoryArg(.{ .cwd_relative = mingw_src_path }); update_mingw_step.dependOn(&update_mingw_run.step); } else { update_mingw_step.dependOn(&b.addFail("The -Dmingw-src=... option is required for this step").step); } const test_incremental_step = b.step("test-incremental", "Run the incremental compilation test cases"); try tests.addIncrementalTests(b, test_incremental_step); test_step.dependOn(test_incremental_step); // zig0 (C implementation) build steps const zig0_cc = b.option([]const u8, "zig0-cc", "C compiler for zig0 tests") orelse "zig"; const zig0_no_exec = b.option(bool, "zig0-no-exec", "Compile zig0 test binary without running it") orelse false; const zig0_test_timeout = b.option([]const u8, "zig0-test-timeout", "Test execution timeout for zig0"); const zig0_valgrind = valgrind orelse false; const zig0_target = blk: { var query = target.query; const arch = query.cpu_arch orelse @import("builtin").cpu.arch; if (arch == .x86_64) { // Valgrind doesn't support AVX-512 instructions (EVEX prefix). // Subtract all AVX-512 features so the zig CC won't emit them. const F = std.Target.x86.Feature; const avx512_features = [_]F{ .avx512f, .avx512bw, .avx512cd, .avx512dq, .avx512vl, .avx512bf16, .avx512bitalg, .avx512er, .avx512fp16, .avx512ifma, .avx512pf, .avx512vbmi, .avx512vbmi2, .avx512vnni, .avx512vp2intersect, .avx512vpopcntdq, .evex512, }; for (avx512_features) |f| query.cpu_features_sub.addFeature(@intFromEnum(f)); } break :blk b.resolveTargetQuery(query); }; // Separate build_options for zig0 tests with a fixed version string, so // that the verbose_dumper cache is not invalidated on every git commit. const zig0_airgen_options = b.addOptions(); zig0_airgen_options.addOption(u32, "mem_leak_frames", mem_leak_frames); zig0_airgen_options.addOption(bool, "skip_non_native", skip_non_native); // air_gen only needs source->AIR (no codegen), so disable LLVM. zig0_airgen_options.addOption(bool, "have_llvm", false); zig0_airgen_options.addOption(bool, "llvm_has_m68k", false); zig0_airgen_options.addOption(bool, "llvm_has_csky", false); zig0_airgen_options.addOption(bool, "llvm_has_arc", false); zig0_airgen_options.addOption(bool, "llvm_has_xtensa", false); zig0_airgen_options.addOption(bool, "debug_gpa", debug_gpa); zig0_airgen_options.addOption(DevEnv, "dev", .full); zig0_airgen_options.addOption(ValueInterpretMode, "value_interpret_mode", value_interpret_mode); zig0_airgen_options.addOption([:0]const u8, "version", try b.allocator.dupeZ(u8, "0.15.2-zig0-dev")); zig0_airgen_options.addOption(std.SemanticVersion, "semver", try std.SemanticVersion.parse("0.15.2-zig0-dev")); zig0_airgen_options.addOption(bool, "enable_debug_extensions", enable_debug_extensions); zig0_airgen_options.addOption(bool, "enable_logging", enable_logging); zig0_airgen_options.addOption(bool, "enable_link_snapshots", enable_link_snapshots); zig0_airgen_options.addOption(bool, "enable_tracy", tracy != null); zig0_airgen_options.addOption(bool, "enable_tracy_callstack", tracy_callstack); zig0_airgen_options.addOption(bool, "enable_tracy_allocation", tracy_allocation); zig0_airgen_options.addOption(u32, "tracy_callstack_depth", tracy_callstack_depth); zig0_airgen_options.addOption(bool, "value_tracing", value_tracing); // ReleaseFast, because we trust compiler will emit the correct AIR // under all modes. const air_gen_result = addAirGen(b, zig0_airgen_options, .ReleaseFast); const prepare_zig0 = b.step("prepare-zig0", "Generate pre-computed AIR files for zig0 tests"); prepare_zig0.dependOn(air_gen_result.step); const test_zig0_step = b.step("test-zig0", "Run zig0 C implementation tests"); addZig0TestStep(b, test_zig0_step, zig0_target, optimize, zig0_cc, zig0_no_exec, zig0_valgrind, zig0_test_timeout, air_gen_result); // zig0 standalone executable const zig0_step = b.step("zig0", "Build zig0 standalone executable"); const zig0_mod = b.createModule(.{ .target = zig0_target, .optimize = optimize, }); zig0_mod.addCSourceFiles(.{ .root = b.path("stage0"), .files = zig0_all_c_files, .flags = zig0_cflags, }); zig0_mod.linkSystemLibrary("c", .{}); const zig0_exe = b.addExecutable(.{ .name = "zig0", .root_module = zig0_mod, }); const zig0_install = b.addInstallArtifact(zig0_exe, .{}); zig0_step.dependOn(&zig0_install.step); const fmt_zig0 = b.step("fmt-zig0", "Format zig0 C code"); const clang_format = b.addSystemCommand(&.{ "clang-format", "-i" }); for (zig0_all_c_files ++ zig0_headers) |f| clang_format.addFileArg(b.path(b.fmt("stage0/{s}", .{f}))); fmt_zig0.dependOn(&clang_format.step); const lint_zig0 = b.step("lint-zig0", "Run zig0 linters"); for (zig0_all_c_files) |cfile| { const clang_analyze = b.addSystemCommand(&.{ "clang", "--analyze", "--analyzer-output", "text", "-Wno-unused-command-line-argument", "-Werror", "-Xclang", "-analyzer-disable-checker", "-Xclang", "unix.Malloc", }); clang_analyze.addFileArg(b.path(b.fmt("stage0/{s}", .{cfile}))); clang_analyze.step.name = b.fmt("clang --analyze ({s})", .{cfile}); clang_analyze.expectExitCode(0); lint_zig0.dependOn(&clang_analyze.step); // Uses >20GiB of memory, disabled for now. // const gcc_analyze = b.addSystemCommand(&.{ // "gcc", // "-c", // "--analyzer", // "-Werror", // "-o", // "/dev/null", // }); // gcc_analyze.addFileArg(b.path(b.fmt("stage0/{s}", .{cfile}))); // gcc_analyze.expectExitCode(0); // lint_zig0.dependOn(&gcc_analyze.step); const cppcheck = b.addSystemCommand(&.{ "cppcheck", "--quiet", "--error-exitcode=1", "--check-level=exhaustive", "--enable=warning,style,performance,portability", "--inline-suppr", }); cppcheck.addFileArg(b.path(b.fmt("stage0/{s}", .{cfile}))); cppcheck.step.name = b.fmt("cppcheck ({s})", .{cfile}); cppcheck.expectExitCode(0); lint_zig0.dependOn(&cppcheck.step); } // TODO enable unusedFunction when it's settled. //const cppcheck_unused = b.addSystemCommand(&.{ // "cppcheck", // "--quiet", // "--error-exitcode=1", // "--check-level=exhaustive", // "--enable=unusedFunction", // "--inline-suppr", //}); //for (zig0_all_c_files) |cfile| { // cppcheck_unused.addFileArg(b.path(b.fmt("stage0/{s}", .{cfile}))); //} //cppcheck_unused.step.name = "cppcheck (unusedFunction)"; //cppcheck_unused.expectExitCode(0); //lint_zig0.dependOn(&cppcheck_unused.step); const all_zig0 = b.step("all-zig0", "Run zig0 fmt check, lint, and tests with all compilers"); // fmt check (dry-run) const zig0_fmt_check = b.addSystemCommand(&.{ "clang-format", "--dry-run", "-Werror" }); for (zig0_all_c_files ++ zig0_headers) |f| zig0_fmt_check.addFileArg(b.path(b.fmt("stage0/{s}", .{f}))); zig0_fmt_check.expectExitCode(0); all_zig0.dependOn(&zig0_fmt_check.step); all_zig0.dependOn(lint_zig0); for (zig0_compilers) |compiler| { addZig0TestStep(b, all_zig0, zig0_target, optimize, compiler, false, zig0_valgrind, zig0_test_timeout, air_gen_result); } } fn addWasiUpdateStep(b: *std.Build, version: [:0]const u8) !void { const semver = try std.SemanticVersion.parse(version); const exe = addCompilerStep(b, .{ .optimize = .ReleaseSmall, .target = b.resolveTargetQuery(std.Target.Query.parse(.{ .arch_os_abi = "wasm32-wasi", // * `extended_const` is not supported by the `wasm-opt` version in CI. // * `nontrapping_bulk_memory_len0` is supported by `wasm2c`. .cpu_features = "baseline-extended_const+nontrapping_bulk_memory_len0", }) catch unreachable), }); const exe_options = b.addOptions(); exe.root_module.addOptions("build_options", exe_options); exe_options.addOption(u32, "mem_leak_frames", 0); exe_options.addOption(bool, "have_llvm", false); exe_options.addOption(bool, "debug_gpa", false); exe_options.addOption([:0]const u8, "version", version); exe_options.addOption(std.SemanticVersion, "semver", semver); exe_options.addOption(bool, "enable_debug_extensions", false); exe_options.addOption(bool, "enable_logging", false); exe_options.addOption(bool, "enable_link_snapshots", false); exe_options.addOption(bool, "enable_tracy", false); exe_options.addOption(bool, "enable_tracy_callstack", false); exe_options.addOption(bool, "enable_tracy_allocation", false); exe_options.addOption(u32, "tracy_callstack_depth", 0); exe_options.addOption(bool, "value_tracing", false); exe_options.addOption(DevEnv, "dev", .bootstrap); // zig1 chooses to interpret values by name. The tradeoff is as follows: // // * We lose a small amount of performance. This is essentially irrelevant for zig1. // // * We lose the ability to perform trivial renames on certain `std.builtin` types without // zig1.wasm updates. For instance, we cannot rename an enum from PascalCase fields to // snake_case fields without an update. // // * We gain the ability to add and remove fields to and from `std.builtin` types without // zig1.wasm updates. For instance, we can add a new tag to `CallingConvention` without // an update. // // Because field renames only happen when we apply a breaking change to the language (which // is becoming progressively rarer), but tags may be added to or removed from target-dependent // types over time in response to new targets coming into use, we gain more than we lose here. exe_options.addOption(ValueInterpretMode, "value_interpret_mode", .by_name); const run_opt = b.addSystemCommand(&.{ "wasm-opt", "-Oz", "--enable-bulk-memory", "--enable-mutable-globals", "--enable-nontrapping-float-to-int", "--enable-sign-ext", }); run_opt.addArtifactArg(exe); run_opt.addArg("-o"); run_opt.addFileArg(b.path("stage1/zig1.wasm")); const copy_zig_h = b.addUpdateSourceFiles(); copy_zig_h.addCopyFileToSource(b.path("lib/zig.h"), "stage1/zig.h"); const update_zig1_step = b.step("update-zig1", "Update stage1/zig1.wasm"); update_zig1_step.dependOn(&run_opt.step); update_zig1_step.dependOn(©_zig_h.step); } const AddCompilerModOptions = struct { optimize: std.builtin.OptimizeMode, target: std.Build.ResolvedTarget, strip: ?bool = null, valgrind: ?bool = null, sanitize_thread: ?bool = null, single_threaded: ?bool = null, }; fn addCompilerMod(b: *std.Build, options: AddCompilerModOptions) *std.Build.Module { const compiler_mod = b.createModule(.{ .root_source_file = b.path("src/main.zig"), .target = options.target, .optimize = options.optimize, .strip = options.strip, .sanitize_thread = options.sanitize_thread, .single_threaded = options.single_threaded, .valgrind = options.valgrind, }); const aro_mod = b.createModule(.{ .root_source_file = b.path("lib/compiler/aro/aro.zig"), }); const aro_translate_c_mod = b.createModule(.{ .root_source_file = b.path("lib/compiler/aro_translate_c.zig"), }); aro_translate_c_mod.addImport("aro", aro_mod); compiler_mod.addImport("aro", aro_mod); compiler_mod.addImport("aro_translate_c", aro_translate_c_mod); return compiler_mod; } fn addCompilerStep(b: *std.Build, options: AddCompilerModOptions) *std.Build.Step.Compile { const exe = b.addExecutable(.{ .name = "zig", .max_rss = 7_800_000_000, .root_module = addCompilerMod(b, options), }); exe.stack_size = stack_size; return exe; } const exe_cflags = [_][]const u8{ "-std=c++17", "-D__STDC_CONSTANT_MACROS", "-D__STDC_FORMAT_MACROS", "-D__STDC_LIMIT_MACROS", "-D_GNU_SOURCE", "-fno-exceptions", "-fno-rtti", "-fno-stack-protector", "-fvisibility-inlines-hidden", "-Wno-type-limits", "-Wno-missing-braces", "-Wno-comment", // `exe_cflags` is only used for static linking. "-DLLVM_BUILD_STATIC", "-DCLANG_BUILD_STATIC", }; fn addCmakeCfgOptionsToExe( b: *std.Build, cfg: CMakeConfig, exe: *std.Build.Step.Compile, use_zig_libcxx: bool, ) !void { const mod = exe.root_module; const target = &mod.resolved_target.?.result; if (target.os.tag.isDarwin()) { // useful for package maintainers exe.headerpad_max_install_names = true; } mod.addObjectFile(.{ .cwd_relative = b.pathJoin(&.{ cfg.cmake_binary_dir, "zigcpp", b.fmt("{s}{s}{s}", .{ cfg.cmake_static_library_prefix, "zigcpp", cfg.cmake_static_library_suffix, }), }) }); assert(cfg.lld_include_dir.len != 0); mod.addIncludePath(.{ .cwd_relative = cfg.lld_include_dir }); mod.addIncludePath(.{ .cwd_relative = cfg.llvm_include_dir }); mod.addLibraryPath(.{ .cwd_relative = cfg.llvm_lib_dir }); addCMakeLibraryList(mod, cfg.clang_libraries); addCMakeLibraryList(mod, cfg.lld_libraries); addCMakeLibraryList(mod, cfg.llvm_libraries); if (use_zig_libcxx) { mod.link_libcpp = true; } else { // System -lc++ must be used because in this code path we are attempting to link // against system-provided LLVM, Clang, LLD. const need_cpp_includes = true; const static = cfg.llvm_linkage == .static; const lib_suffix = if (static) target.staticLibSuffix()[1..] else target.dynamicLibSuffix()[1..]; switch (target.os.tag) { .linux => { // First we try to link against the detected libcxx name. If that doesn't work, we fall // back to -lc++ and cross our fingers. addCxxKnownPath(b, cfg, exe, b.fmt("lib{s}.{s}", .{ cfg.system_libcxx, lib_suffix }), "", need_cpp_includes) catch |err| switch (err) { error.RequiredLibraryNotFound => { mod.link_libcpp = true; }, else => |e| return e, }; mod.linkSystemLibrary("unwind", .{}); }, .ios, .macos, .watchos, .tvos, .visionos => { mod.link_libcpp = true; }, .windows => { if (target.abi != .msvc) mod.link_libcpp = true; }, .freebsd => { try addCxxKnownPath(b, cfg, exe, b.fmt("libc++.{s}", .{lib_suffix}), null, need_cpp_includes); if (static) try addCxxKnownPath(b, cfg, exe, b.fmt("libgcc_eh.{s}", .{lib_suffix}), null, need_cpp_includes); }, .openbsd => { // - llvm requires libexecinfo which has conflicting symbols with libc++abi // - only an issue with .a linking // - workaround is to link c++abi dynamically try addCxxKnownPath(b, cfg, exe, b.fmt("libc++.{s}", .{target.dynamicLibSuffix()[1..]}), null, need_cpp_includes); try addCxxKnownPath(b, cfg, exe, b.fmt("libc++abi.{s}", .{target.dynamicLibSuffix()[1..]}), null, need_cpp_includes); }, .netbsd, .dragonfly => { try addCxxKnownPath(b, cfg, exe, b.fmt("libstdc++.{s}", .{lib_suffix}), null, need_cpp_includes); if (static) try addCxxKnownPath(b, cfg, exe, b.fmt("libgcc_eh.{s}", .{lib_suffix}), null, need_cpp_includes); }, .solaris, .illumos => { try addCxxKnownPath(b, cfg, exe, b.fmt("libstdc++.{s}", .{lib_suffix}), null, need_cpp_includes); try addCxxKnownPath(b, cfg, exe, b.fmt("libgcc_eh.{s}", .{lib_suffix}), null, need_cpp_includes); }, .haiku => { try addCxxKnownPath(b, cfg, exe, b.fmt("libstdc++.{s}", .{lib_suffix}), null, need_cpp_includes); }, else => {}, } } if (cfg.dia_guids_lib.len != 0) { mod.addObjectFile(.{ .cwd_relative = cfg.dia_guids_lib }); } } fn addStaticLlvmOptionsToModule(mod: *std.Build.Module, options: struct { llvm_has_m68k: bool, llvm_has_csky: bool, llvm_has_arc: bool, llvm_has_xtensa: bool, }) !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::dump() which is // unavailable when LLVM is compiled in Release mode. const zig_cpp_cflags = exe_cflags ++ [_][]const u8{"-DNDEBUG=1"}; mod.addCSourceFiles(.{ .files = &zig_cpp_sources, .flags = &zig_cpp_cflags, }); for (clang_libs) |lib_name| { mod.linkSystemLibrary(lib_name, .{}); } for (lld_libs) |lib_name| { mod.linkSystemLibrary(lib_name, .{}); } for (llvm_libs) |lib_name| { mod.linkSystemLibrary(lib_name, .{}); } if (options.llvm_has_m68k) for (llvm_libs_m68k) |lib_name| { mod.linkSystemLibrary(lib_name, .{}); }; if (options.llvm_has_csky) for (llvm_libs_csky) |lib_name| { mod.linkSystemLibrary(lib_name, .{}); }; if (options.llvm_has_arc) for (llvm_libs_arc) |lib_name| { mod.linkSystemLibrary(lib_name, .{}); }; if (options.llvm_has_xtensa) for (llvm_libs_xtensa) |lib_name| { mod.linkSystemLibrary(lib_name, .{}); }; mod.linkSystemLibrary("z", .{}); mod.linkSystemLibrary("zstd", .{}); if (mod.resolved_target.?.result.os.tag != .windows or mod.resolved_target.?.result.abi != .msvc) { // This means we rely on clang-or-zig-built LLVM, Clang, LLD libraries. mod.linkSystemLibrary("c++", .{}); } if (mod.resolved_target.?.result.os.tag == .windows) { mod.linkSystemLibrary("version", .{}); mod.linkSystemLibrary("uuid", .{}); mod.linkSystemLibrary("ole32", .{}); } } fn addCxxKnownPath( b: *std.Build, ctx: CMakeConfig, exe: *std.Build.Step.Compile, objname: []const u8, errtxt: ?[]const u8, need_cpp_includes: bool, ) !void { if (!std.process.can_spawn) return error.RequiredLibraryNotFound; const path_padded = run: { var args = std.array_list.Managed([]const u8).init(b.allocator); try args.append(ctx.cxx_compiler); var it = std.mem.tokenizeAny(u8, ctx.cxx_compiler_arg1, &std.ascii.whitespace); while (it.next()) |arg| try args.append(arg); try args.append(b.fmt("-print-file-name={s}", .{objname})); break :run b.run(args.items); }; var tokenizer = mem.tokenizeAny(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; } // By default, explicit library paths are not checked for being linker scripts, // but libc++ may very well be one, so force all inputs to be checked when passing // an explicit path to libc++. exe.allow_so_scripts = true; exe.root_module.addObjectFile(.{ .cwd_relative = path_unpadded }); // TODO a way to integrate with system c++ include files here // c++ -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.root_module.addIncludePath("/nix/store/2lr0fc0ak8rwj0k8n3shcyz1hz63wzma-gcc-11.3.0/include/c++/11.3.0"); //exe.root_module.addIncludePath("/nix/store/2lr0fc0ak8rwj0k8n3shcyz1hz63wzma-gcc-11.3.0/include/c++/11.3.0/x86_64-unknown-linux-gnu"); } } fn addCMakeLibraryList(mod: *std.Build.Module, list: []const u8) void { var it = mem.tokenizeScalar(u8, list, ';'); while (it.next()) |lib| { if (mem.startsWith(u8, lib, "-l")) { mod.linkSystemLibrary(lib["-l".len..], .{}); } else if (mod.resolved_target.?.result.os.tag == .windows and mem.endsWith(u8, lib, ".lib") and !fs.path.isAbsolute(lib)) { mod.linkSystemLibrary(lib[0 .. lib.len - ".lib".len], .{}); } else { mod.addObjectFile(.{ .cwd_relative = lib }); } } } const CMakeConfig = struct { llvm_linkage: std.builtin.LinkMode, cmake_binary_dir: []const u8, cmake_prefix_path: []const u8, cmake_static_library_prefix: []const u8, cmake_static_library_suffix: []const u8, cxx_compiler: []const u8, cxx_compiler_arg1: []const u8, lld_include_dir: []const u8, lld_libraries: []const u8, clang_libraries: []const u8, llvm_lib_dir: []const u8, llvm_include_dir: []const u8, llvm_libraries: []const u8, dia_guids_lib: []const u8, system_libcxx: []const u8, }; const max_config_h_bytes = 1 * 1024 * 1024; fn findConfigH(b: *std.Build, config_h_path_option: ?[]const u8) ?[]const u8 { if (config_h_path_option) |path| { var config_h_or_err = fs.cwd().openFile(path, .{}); if (config_h_or_err) |*file| { file.close(); return path; } else |_| { std.log.err("Could not open provided config.h: \"{s}\"", .{path}); std.process.exit(1); } } var check_dir = fs.path.dirname(b.graph.zig_exe).?; while (true) { var dir = fs.cwd().openDir(check_dir, .{}) catch unreachable; defer dir.close(); // Check if config.h is present in dir var config_h_or_err = dir.openFile("config.h", .{}); if (config_h_or_err) |*file| { file.close(); return fs.path.join( b.allocator, &[_][]const u8{ check_dir, "config.h" }, ) catch unreachable; } else |e| switch (e) { error.FileNotFound => {}, else => unreachable, } // Check if we reached the source root by looking for .git, and bail if so var git_dir_or_err = dir.openDir(".git", .{}); if (git_dir_or_err) |*git_dir| { git_dir.close(); return null; } else |_| {} // Otherwise, continue search in the parent directory 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.?; } } fn parseConfigH(b: *std.Build, config_h_text: []const u8) ?CMakeConfig { var ctx: CMakeConfig = .{ .llvm_linkage = undefined, .cmake_binary_dir = undefined, .cmake_prefix_path = undefined, .cmake_static_library_prefix = undefined, .cmake_static_library_suffix = undefined, .cxx_compiler = undefined, .cxx_compiler_arg1 = "", .lld_include_dir = undefined, .lld_libraries = undefined, .clang_libraries = undefined, .llvm_lib_dir = undefined, .llvm_include_dir = undefined, .llvm_libraries = undefined, .dia_guids_lib = undefined, .system_libcxx = 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_CMAKE_STATIC_LIBRARY_PREFIX ", .field = "cmake_static_library_prefix", }, .{ .prefix = "#define ZIG_CMAKE_STATIC_LIBRARY_SUFFIX ", .field = "cmake_static_library_suffix", }, .{ .prefix = "#define ZIG_CXX_COMPILER ", .field = "cxx_compiler", }, .{ .prefix = "#define ZIG_CXX_COMPILER_ARG1 ", .field = "cxx_compiler_arg1", }, .{ .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", }, .{ .prefix = "#define ZIG_LLVM_INCLUDE_PATH ", .field = "llvm_include_dir", }, .{ .prefix = "#define ZIG_LLVM_LIB_PATH ", .field = "llvm_lib_dir", }, .{ .prefix = "#define ZIG_SYSTEM_LIBCXX", .field = "system_libcxx", }, // .prefix = ZIG_LLVM_LINK_MODE parsed manually below }; var lines_it = mem.tokenizeAny(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.splitScalar(u8, line, '"'); _ = it.first(); // skip the stuff before the quote const quoted = it.next().?; // the stuff inside the quote const trimmed = mem.trim(u8, quoted, " "); @field(ctx, mapping.field) = toNativePathSep(b, trimmed); } } if (mem.startsWith(u8, line, "#define ZIG_LLVM_LINK_MODE ")) { var it = mem.splitScalar(u8, line, '"'); _ = it.next().?; // skip the stuff before the quote const quoted = it.next().?; // the stuff inside the quote ctx.llvm_linkage = if (mem.eql(u8, quoted, "shared")) .dynamic else .static; } } return ctx; } fn toNativePathSep(b: *std.Build, 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 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", }; const clang_libs = [_][]const u8{ "clangFrontendTool", "clangCodeGen", "clangFrontend", "clangDriver", "clangSerialization", "clangSema", "clangStaticAnalyzerFrontend", "clangStaticAnalyzerCheckers", "clangStaticAnalyzerCore", "clangAnalysis", "clangASTMatchers", "clangAST", "clangParse", "clangSema", "clangAPINotes", "clangBasic", "clangEdit", "clangLex", "clangARCMigrate", "clangRewriteFrontend", "clangRewrite", "clangCrossTU", "clangIndex", "clangToolingCore", "clangExtractAPI", "clangSupport", "clangInstallAPI", "clangAST", }; 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", "LLVMTelemetry", "LLVMTextAPIBinaryReader", "LLVMCoverage", "LLVMLineEditor", "LLVMXCoreDisassembler", "LLVMXCoreCodeGen", "LLVMXCoreDesc", "LLVMXCoreInfo", "LLVMX86TargetMCA", "LLVMX86Disassembler", "LLVMX86AsmParser", "LLVMX86CodeGen", "LLVMX86Desc", "LLVMX86Info", "LLVMWebAssemblyDisassembler", "LLVMWebAssemblyAsmParser", "LLVMWebAssemblyCodeGen", "LLVMWebAssemblyUtils", "LLVMWebAssemblyDesc", "LLVMWebAssemblyInfo", "LLVMVEDisassembler", "LLVMVEAsmParser", "LLVMVECodeGen", "LLVMVEDesc", "LLVMVEInfo", "LLVMSystemZDisassembler", "LLVMSystemZAsmParser", "LLVMSystemZCodeGen", "LLVMSystemZDesc", "LLVMSystemZInfo", "LLVMSPIRVCodeGen", "LLVMSPIRVDesc", "LLVMSPIRVInfo", "LLVMSPIRVAnalysis", "LLVMSparcDisassembler", "LLVMSparcAsmParser", "LLVMSparcCodeGen", "LLVMSparcDesc", "LLVMSparcInfo", "LLVMRISCVTargetMCA", "LLVMRISCVDisassembler", "LLVMRISCVAsmParser", "LLVMRISCVCodeGen", "LLVMRISCVDesc", "LLVMRISCVInfo", "LLVMPowerPCDisassembler", "LLVMPowerPCAsmParser", "LLVMPowerPCCodeGen", "LLVMPowerPCDesc", "LLVMPowerPCInfo", "LLVMNVPTXCodeGen", "LLVMNVPTXDesc", "LLVMNVPTXInfo", "LLVMMSP430Disassembler", "LLVMMSP430AsmParser", "LLVMMSP430CodeGen", "LLVMMSP430Desc", "LLVMMSP430Info", "LLVMMipsDisassembler", "LLVMMipsAsmParser", "LLVMMipsCodeGen", "LLVMMipsDesc", "LLVMMipsInfo", "LLVMLoongArchDisassembler", "LLVMLoongArchAsmParser", "LLVMLoongArchCodeGen", "LLVMLoongArchDesc", "LLVMLoongArchInfo", "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", "LLVMOrcDebugging", "LLVMOrcJIT", "LLVMWindowsDriver", "LLVMMCJIT", "LLVMJITLink", "LLVMInterpreter", "LLVMExecutionEngine", "LLVMRuntimeDyld", "LLVMOrcTargetProcess", "LLVMOrcShared", "LLVMDWP", "LLVMDebugInfoLogicalView", "LLVMDebugInfoGSYM", "LLVMOption", "LLVMObjectYAML", "LLVMObjCopy", "LLVMMCA", "LLVMMCDisassembler", "LLVMLTO", "LLVMPasses", "LLVMHipStdPar", "LLVMCFGuard", "LLVMCoroutines", "LLVMipo", "LLVMVectorize", "LLVMSandboxIR", "LLVMLinker", "LLVMInstrumentation", "LLVMFrontendOpenMP", "LLVMFrontendOffloading", "LLVMFrontendOpenACC", "LLVMFrontendHLSL", "LLVMFrontendDriver", "LLVMFrontendAtomic", "LLVMExtensions", "LLVMDWARFLinkerParallel", "LLVMDWARFLinkerClassic", "LLVMDWARFLinker", "LLVMGlobalISel", "LLVMMIRParser", "LLVMAsmPrinter", "LLVMSelectionDAG", "LLVMCodeGen", "LLVMTarget", "LLVMObjCARCOpts", "LLVMCodeGenTypes", "LLVMCGData", "LLVMIRPrinter", "LLVMInterfaceStub", "LLVMFileCheck", "LLVMFuzzMutate", "LLVMScalarOpts", "LLVMInstCombine", "LLVMAggressiveInstCombine", "LLVMTransformUtils", "LLVMBitWriter", "LLVMAnalysis", "LLVMProfileData", "LLVMSymbolize", "LLVMDebugInfoBTF", "LLVMDebugInfoPDB", "LLVMDebugInfoMSF", "LLVMDebugInfoCodeView", "LLVMDebugInfoDWARF", "LLVMObject", "LLVMTextAPI", "LLVMMCParser", "LLVMIRReader", "LLVMAsmParser", "LLVMMC", "LLVMBitReader", "LLVMFuzzerCLI", "LLVMCore", "LLVMRemarks", "LLVMBitstreamReader", "LLVMBinaryFormat", "LLVMTargetParser", "LLVMSupport", "LLVMDemangle", }; const llvm_libs_m68k = [_][]const u8{ "LLVMM68kDisassembler", "LLVMM68kAsmParser", "LLVMM68kCodeGen", "LLVMM68kDesc", "LLVMM68kInfo", }; const llvm_libs_csky = [_][]const u8{ "LLVMCSKYDisassembler", "LLVMCSKYAsmParser", "LLVMCSKYCodeGen", "LLVMCSKYDesc", "LLVMCSKYInfo", }; const llvm_libs_arc = [_][]const u8{ "LLVMARCDisassembler", "LLVMARCCodeGen", "LLVMARCDesc", "LLVMARCInfo", }; const llvm_libs_xtensa = [_][]const u8{ "LLVMXtensaDisassembler", "LLVMXtensaAsmParser", "LLVMXtensaCodeGen", "LLVMXtensaDesc", "LLVMXtensaInfo", }; fn generateLangRef(b: *std.Build) std.Build.LazyPath { const doctest_exe = b.addExecutable(.{ .name = "doctest", .root_module = b.createModule(.{ .root_source_file = b.path("tools/doctest.zig"), .target = b.graph.host, .optimize = .Debug, }), }); var dir = b.build_root.handle.openDir("doc/langref", .{ .iterate = true }) catch |err| { std.debug.panic("unable to open '{f}doc/langref' directory: {s}", .{ b.build_root, @errorName(err), }); }; defer dir.close(); var wf = b.addWriteFiles(); var it = dir.iterateAssumeFirstIteration(); while (it.next() catch @panic("failed to read dir")) |entry| { if (std.mem.startsWith(u8, entry.name, ".") or entry.kind != .file) continue; const out_basename = b.fmt("{s}.out", .{std.fs.path.stem(entry.name)}); const cmd = b.addRunArtifact(doctest_exe); cmd.addArgs(&.{ "--zig", b.graph.zig_exe, // TODO: enhance doctest to use "--listen=-" rather than operating // in a temporary directory "--cache-root", b.cache_root.path orelse ".", }); cmd.addArgs(&.{ "--zig-lib-dir", b.fmt("{f}", .{b.graph.zig_lib_directory}) }); cmd.addArgs(&.{"-i"}); cmd.addFileArg(b.path(b.fmt("doc/langref/{s}", .{entry.name}))); cmd.addArgs(&.{"-o"}); _ = wf.addCopyFile(cmd.addOutputFileArg(out_basename), out_basename); } const docgen_exe = b.addExecutable(.{ .name = "docgen", .root_module = b.createModule(.{ .root_source_file = b.path("tools/docgen.zig"), .target = b.graph.host, .optimize = .Debug, }), }); const docgen_cmd = b.addRunArtifact(docgen_exe); docgen_cmd.addArgs(&.{"--code-dir"}); docgen_cmd.addDirectoryArg(wf.getDirectory()); docgen_cmd.addFileArg(b.path("doc/langref.html.in")); return docgen_cmd.addOutputFileArg("langref.html"); } fn superHtmlCheck(b: *std.Build, html_file: std.Build.LazyPath) *std.Build.Step { const run_superhtml = b.addSystemCommand(&.{ "superhtml", "check", }); run_superhtml.addFileArg(html_file); run_superhtml.expectExitCode(0); return &run_superhtml.step; } const AirGenResult = struct { step: *std.Build.Step, air_dir: std.Build.LazyPath, }; fn addAirGen( b: *std.Build, exe_options: *std.Build.Step.Options, optimize: std.builtin.OptimizeMode, ) AirGenResult { const zig_internals_mod = b.createModule(.{ .root_source_file = b.path("src/test_exports.zig"), }); const aro_mod = b.createModule(.{ .root_source_file = b.path("lib/compiler/aro/aro.zig"), }); const aro_translate_c_mod = b.createModule(.{ .root_source_file = b.path("lib/compiler/aro_translate_c.zig"), }); aro_translate_c_mod.addImport("aro", aro_mod); zig_internals_mod.addImport("aro", aro_mod); zig_internals_mod.addImport("aro_translate_c", aro_translate_c_mod); zig_internals_mod.addOptions("build_options", exe_options); const dumper_mod = b.createModule(.{ .root_source_file = b.path("src/verbose_air.zig"), .target = b.graph.host, .optimize = optimize, }); dumper_mod.addImport("zig_internals", zig_internals_mod); dumper_mod.linkSystemLibrary("c", .{}); const gen_mod = b.createModule(.{ .root_source_file = b.path("src/verbose_air_gen.zig"), .target = b.graph.host, .optimize = optimize, }); gen_mod.addImport("verbose_air", dumper_mod); gen_mod.addImport("zig_internals", zig_internals_mod); gen_mod.linkSystemLibrary("c", .{}); const gen_exe = b.addExecutable(.{ .name = "air_gen", .root_module = gen_mod, .use_llvm = false, .use_lld = false, }); // Run generator: air_gen [ ]... const gen_run = b.addRunArtifact(gen_exe); const air_dir = gen_run.addOutputDirectoryArg("air"); // Add non-lib/std/ corpus files as name/path pairs. // lib/std/ files are compiled via std.zig root inside air_gen. // stage0/sema_tests/ files are also included (standalone compilation). for (corpus.files) |path| { if (std.mem.startsWith(u8, path, "lib/std/")) continue; gen_run.addArg(path); gen_run.addFileArg(b.path(path)); } return .{ .step = &gen_run.step, .air_dir = air_dir }; } fn addZig0TestStep( b: *std.Build, step: *std.Build.Step, target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode, cc: []const u8, no_exec: bool, valgrind: bool, test_timeout: ?[]const u8, air_gen: AirGenResult, ) void { // Step 1: Compile Zig test code to .o (cached independently of C objects). // NOTE: test_mod does NOT import zig_internals — stage0 tests are fast. const test_mod = b.createModule(.{ .root_source_file = b.path("stage0_test_root.zig"), .optimize = optimize, .target = target, .valgrind = true, }); test_mod.addIncludePath(b.path("stage0")); test_mod.linkSystemLibrary("c", .{}); // Make pre-computed AIR data available to tests. test_mod.addAnonymousImport("air_tag_names", .{ .root_source_file = air_gen.air_dir.path(b, "tag_names.zig"), }); test_mod.addAnonymousImport("air_data", .{ .root_source_file = air_gen.air_dir.path(b, "air_data.zig"), }); const test_obj = b.addTest(.{ .root_module = test_mod, .emit_object = true, .use_llvm = false, .use_lld = false, }); test_obj.step.dependOn(air_gen.step); // Step 2: Link test_obj + C objects into final executable. // No more dumper_obj — AIR is pre-computed at build time. const link_mod = b.createModule(.{ .target = target, .optimize = optimize, }); link_mod.addObject(test_obj); addZig0CSources(b, link_mod, cc, optimize); link_mod.linkSystemLibrary("c", .{}); const test_exe = b.addExecutable(.{ .name = "test", .root_module = link_mod, }); const timeout: ?[]const u8 = test_timeout orelse if (valgrind) null else "300"; if (no_exec) { const install = b.addInstallArtifact(test_exe, .{}); step.dependOn(&install.step); } else { // Step 3: Run with test IPC protocol. const run = std.Build.Step.Run.create(b, b.fmt("test ({s})", .{cc})); if (valgrind) { run.addArgs(&.{ "valgrind", "--error-exitcode=2", "--leak-check=full", "--show-leak-kinds=all", "--errors-for-leak-kinds=all", "--track-fds=yes", "--quiet", }); } else if (timeout) |t| { run.addArgs(&.{ "timeout", t }); } run.addArtifactArg(test_exe); run.enableTestRunnerMode(); step.dependOn(&run.step); } } fn addZig0CSources( b: *std.Build, mod: *std.Build.Module, cc: []const u8, optimize: std.builtin.OptimizeMode, ) void { if (std.mem.eql(u8, cc, "zig")) { mod.addCSourceFiles(.{ .root = b.path("stage0"), .files = zig0_c_lib_files, .flags = zig0_cflags, }); } else for (zig0_c_lib_files) |cfile| { const cc1 = b.addSystemCommand(&.{cc}); cc1.addArgs(zig0_cflags ++ .{"-g"}); cc1.addArg(switch (optimize) { .Debug => "-O0", .ReleaseFast, .ReleaseSafe => "-O3", .ReleaseSmall => "-Os", }); cc1.addArg("-c"); cc1.addFileArg(b.path(b.fmt("stage0/{s}", .{cfile}))); // Track headers as extra inputs so changes invalidate the cache. for (zig0_headers) |h| cc1.addFileInput(b.path(b.fmt("stage0/{s}", .{h}))); cc1.addArg("-o"); mod.addObjectFile(cc1.addOutputFileArg(b.fmt("{s}.o", .{cfile[0 .. cfile.len - 2]}))); } }