MORPH
SIGN IN SIGN UP
ziglang / zig UNCLAIMED

Moved to Codeberg

42806 0 0 Zig
Normal View History Raw
self-hosted: link with LLVM
2017-12-11 23:34:59 -05:00
const std = @import("std");
stage2: improvements aimed at std lib integration * AstGen: emit decl lookup ZIR instructions rather than directly looking up decls in AstGen. This is necessary because we want to reuse the same immutable ZIR code for multiple generic instantiations (and comptime function calls). * AstGen: fix using members_len instead of fields_len for struct decls. * structs: the struct_decl ZIR instruction is now also a block. This is so that the type expressions, default field value expressions, and alignment expressions can be evaluated in a scope that contains the decls from the struct namespace itself. * Add "std" and "builtin" packages to the builtin package. * Don't try to build glibc, musl, or mingw-w64 when using `-ofmt=c`. * builtin.zig is generated without `usingnamespace`. * builtin.zig takes advantage of `std.zig.fmtId` for CPU features. * A first pass at implementing `usingnamespace`. It's problematic and should either be deleted, or polished, before merging this branch. * Sema: allow explicitly specifying the namespace in which to look up Decls. This is used by `struct_decl` in order to put the decls from the struct namespace itself in scope when evaluating the type expressions, default value expressions, and alignment expressions. * Module: fix `analyzeNamespace` assuming that it is the top-level root declaration node. * Sema: implement comptime and runtime cmp operator. * Sema: implement peer type resolution for enums and enum literals. * Pull in the changes from master branch: 262e09c482d98a78531c049a18b7f24146fe157f. * ZIR: complete out simple_ptr_type debug printing
2021-04-12 16:44:51 -07:00
const builtin = std.builtin;
convert compare-output tests to use zig build system
2017-04-19 01:13:15 -04:00
const tests = @import("test/tests.zig");
self-hosted: link with LLVM
2017-12-11 23:34:59 -05:00
const BufMap = std.BufMap;
const mem = std.mem;
const io = std.io;
clean up references to os
2019-05-26 13:17:34 -04:00
const fs = std.fs;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
const InstallDirectoryOptions = std.Build.InstallDirectoryOptions;
start moving `zig cc` to stage2 * build.zig: repair the ability to link against llvm, clang, and lld * move the zig cc arg parsing logic to stage2 - the preprocessor flag is still TODO - the clang arg iterator code is improved to use slices instead of raw pointers because it no longer has to deal with an extern struct. * clean up error printing with a `fatal` function and use log API for messages rather than std.debug.print * add support for more CLI options to stage2 & update usage text - hooking up most of these new options is TODO * clean up the way libc and libc++ are detected via command line options. target information is used to determine if any of the libc candidate names are chosen. * add native library directory detection * implement the ability to invoke clang from stage2 * introduce a build_options.have_llvm so we can comptime branch on whether LLVM is linked in or not.
2020-09-03 20:23:00 -07:00
const assert = std.debug.assert;
dev: introduce dev environments that enable compiler feature sets
2024-07-19 01:04:59 -04:00
const DevEnv = @import("src/dev.zig").Env;
compiler: make it easier to apply breaking changes to `std.builtin` Documentation for this will be on the wiki shortly. Resolves: #21842
2025-01-16 10:09:41 +00:00
const ValueInterpretMode = enum { direct, by_name };
convert compare-output tests to use zig build system
2017-04-19 01:13:15 -04:00
start the 0.16.0 release cycle
2025-08-18 21:33:09 -07:00
const zig_version: std.SemanticVersion = .{ .major = 0, .minor = 16, .patch = 0 };
compiler: bump stack size 32 MiB -> 46 MiB Before the prior commit, the maximum comptime recursion depth on my system was 4062. After the prior commit, it decreased to 2854. This commit increases the compiler's stack size enough so that the recursion depth limit is no less than it was before the `Sema.analyzeCall` rewrite, preventing this from being a breaking change. Specifically, this stack size increases my observed maximum comptime recursion depth to 4105.
2025-01-10 05:35:03 +00:00
const stack_size = 46 * 1024 * 1024;
stage2: implement zig version
2020-08-15 14:17:40 -07:00
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
pub fn build(b: *std.Build) !void {
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
const only_c = b.option(bool, "only-c", "Translate the Zig compiler to C code, with only the C backend enabled") orelse false;
std.Build: Make ofmt part of standardTargetOptions().
2025-01-24 08:11:16 +01:00
const target = b.standardTargetOptions(.{
.default_target = .{
.ofmt = if (only_c) .c else null,
},
});
build.zig: default to Debug for wasm32 too Following @Luukdegram's comment[1]: > The default should remain Debug when unspecified. In ReleaseSmall the > user would lose all DWARF support when testing their WebAssembly code. > Building a release version should be opt-in, not the default. [1]: https://github.com/ziglang/zig/pull/15192#discussion_r1160824726
2023-04-07 22:17:23 +03:00
const optimize = b.standardOptimizeOption(.{});
build: introduce -Dwasi-bootstrap option Also, make -Donly-c prevent Autodoc from being included in the binary. This produces a 2.6 MiB zig.wasm file. 781 KB if piped through zstd.
2022-11-04 18:35:04 -07:00
move installation logic to the build script where it belongs * build.zig: introduce `-Dflat` option which makes the installation match what we want to ship for our download tarballs. This allows deleting a bunch of shell script logic from the CI. - for example it puts the executable directly in prefix/zig rather than prefix/bin/zig and it additionally includes prefix/LICENSE. * build.zig: by default also install std lib documentation to doc/std/ - this can be disabled by `-Dno-autodocs` similar to how there is already `-Dno-langref`. * build.zig: add `std-docs` and `langref` steps which build and install the std lib autodocs and langref to prefix/doc/std and prefix/doc/langref.html, respectively. * std.Build: implement proper handling of `-femit-docs` using the LazyPath system. This is a breaking change. - this is a partial implementation of #16351 * frontend: fixed the handling of Autodocs with regards to caching and putting the artifacts in the proper location to integrate with the build system. - closes #15864 * CI: delete the logic for autodocs since it is now handled by build.zig and is enabled by default. - in the future we should strive to have nearly all the CI shell script logic deleted in favor of `zig build` commands. * CI: pass `-DZIG_NO_LIB=ON`/`-Dno-lib` except for the one command where we want to actually generate the langref and autodocs. Generating the langref takes 14 minutes right now (why?!) so we don't want to do that more times than necessary. * Autodoc: fixed use of a global variable. It works fine as a local variable instead. - note that in the future we will want to make Autodoc run simultaneously using the job system, but for now the principle of YAGNI dictates that we don't have an init()/deinit() API and instead simply call the function that does the things. * Autodoc: only do it when there are no compile errors
2023-07-21 20:29:42 -07:00
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;
build.zig: fix single-threaded option Instead of defaulting to false, just keep the option as optional to communicate default to the build system. Fixes one problem with building the compiler for single-threaded targets.
2022-01-28 17:16:51 -07:00
const single_threaded = b.option(bool, "single-threaded", "Build artifacts that run in single threaded mode");
build.zig: support -Duse-zig-libcxx This supports the case when it is known that LLVM, Clang, LLD were built with Clang (or `zig c++`). This commit updates the Linux CI script to pass this since we build using a zig tarball.
2021-09-16 13:09:32 -07:00
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;
self hosted zig: print usage
2017-10-21 17:31:06 -04:00
build: introduce -Dwasi-bootstrap option Also, make -Donly-c prevent Autodoc from being included in the binary. This produces a 2.6 MiB zig.wasm file. 781 KB if piped through zstd.
2022-11-04 18:35:04 -07:00
const test_step = b.step("test", "Run all the tests");
CMakeLists.txt and build.zig: remove deprecated options Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-05-14 22:59:30 +06:00
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;
build: add option to not build langref on install
2023-04-11 21:05:53 +02:00
const skip_install_langref = b.option(bool, "no-langref", "skip copying of langref to the installation prefix") orelse skip_install_lib_files;
build: don't include std lib docs by default since we have `zig std` now to fill that role.
2024-03-06 22:35:48 -07:00
const std_docs = b.option(bool, "std-docs", "include standard library autodocs") orelse false;
build: add -Dno-bin option This is useful for development, as it speeds up the process of getting semantic analysis errors significantly.
2023-06-12 22:02:59 +01:00
const no_bin = b.option(bool, "no-bin", "skip emitting compiler binary") orelse false;
Replace tidy with superhtml as HTML validator (#21664) Also add `$HOME/local/bin` to `PATH` in linux CI
2024-10-12 06:27:30 +02:00
const enable_superhtml = b.option(bool, "enable-superhtml", "Check langref output HTML validity") orelse false;
build: introduce -Dwasi-bootstrap option Also, make -Donly-c prevent Autodoc from being included in the binary. This produces a 2.6 MiB zig.wasm file. 781 KB if piped through zstd.
2022-11-04 18:35:04 -07:00
migrate langref documentation generation to the build system
2024-04-24 17:41:47 -07:00
const langref_file = generateLangRef(b);
build.zig: install the langref to $prefix/doc/langref.html and update the CI scripts to match.
2023-03-10 14:22:54 -07:00
const install_langref = b.addInstallFileWithDir(langref_file, .prefix, "doc/langref.html");
Replace tidy with superhtml as HTML validator (#21664) Also add `$HOME/local/bin` to `PATH` in linux CI
2024-10-12 06:27:30 +02:00
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) {
add -Denable-tidy flag and use it in the CI Eliminates a TODO from the CI scripts; makes it easier to check validity of html when working on the langref locally.
2024-06-16 20:03:14 -07:00
test_step.dependOn(check_langref);
Replace tidy with superhtml as HTML validator (#21664) Also add `$HOME/local/bin` to `PATH` in linux CI
2024-10-12 06:27:30 +02:00
test_step.dependOn(check_autodocs);
add -Denable-tidy flag and use it in the CI Eliminates a TODO from the CI scripts; makes it easier to check validity of html when working on the langref locally.
2024-06-16 20:03:14 -07:00
}
build: add option to not build langref on install
2023-04-11 21:05:53 +02:00
if (!skip_install_langref) {
make -Dno-lib also skip docgen
2023-03-09 22:12:36 -07:00
b.getInstallStep().dependOn(&install_langref.step);
}
std.io: introduce buffered I/O and change API I started working on #465 and made some corresponding std.io API changes. New structs: * std.io.FileInStream * std.io.FileOutStream * std.io.BufferedOutStream * std.io.BufferedInStream Removed: * std.io.File.in_stream * std.io.File.out_stream Now instead of &file.out_stream or &file.in_stream to get access to the stream API for a file, you get it like this: var file_in_stream = io.FileInStream.init(&file); const in_stream = &file_in_stream.stream; var file_out_stream = io.FileOutStream.init(&file); const out_stream = &file_out_stream.stream; This is evidence that we might not need any OOP features - See #130.
2017-11-07 03:22:27 -05:00
build: spend a lot less time generating std docs
2024-03-06 22:51:38 -07:00
const autodoc_test = b.addObject(.{
.name = "std",
remove deprecated LazyPath.path union tag
2024-04-11 14:02:47 -07:00
.zig_lib_dir = b.path("lib"),
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
.root_module = b.createModule(.{
.root_source_file = b.path("lib/std/std.zig"),
.target = target,
.optimize = .Debug,
}),
move installation logic to the build script where it belongs * build.zig: introduce `-Dflat` option which makes the installation match what we want to ship for our download tarballs. This allows deleting a bunch of shell script logic from the CI. - for example it puts the executable directly in prefix/zig rather than prefix/bin/zig and it additionally includes prefix/LICENSE. * build.zig: by default also install std lib documentation to doc/std/ - this can be disabled by `-Dno-autodocs` similar to how there is already `-Dno-langref`. * build.zig: add `std-docs` and `langref` steps which build and install the std lib autodocs and langref to prefix/doc/std and prefix/doc/langref.html, respectively. * std.Build: implement proper handling of `-femit-docs` using the LazyPath system. This is a breaking change. - this is a partial implementation of #16351 * frontend: fixed the handling of Autodocs with regards to caching and putting the artifacts in the proper location to integrate with the build system. - closes #15864 * CI: delete the logic for autodocs since it is now handled by build.zig and is enabled by default. - in the future we should strive to have nearly all the CI shell script logic deleted in favor of `zig build` commands. * CI: pass `-DZIG_NO_LIB=ON`/`-Dno-lib` except for the one command where we want to actually generate the langref and autodocs. Generating the langref takes 14 minutes right now (why?!) so we don't want to do that more times than necessary. * Autodoc: fixed use of a global variable. It works fine as a local variable instead. - note that in the future we will want to make Autodoc run simultaneously using the job system, but for now the principle of YAGNI dictates that we don't have an init()/deinit() API and instead simply call the function that does the things. * Autodoc: only do it when there are no compile errors
2023-07-21 20:29:42 -07:00
});
const install_std_docs = b.addInstallDirectory(.{
std.Build.Step.Compile: getEmittedDocs API enhancements * Allow calling it multiple times. * Rename it. Sorry, this is to coincide with #16353.
2023-07-23 21:13:58 -07:00
.source_dir = autodoc_test.getEmittedDocs(),
move installation logic to the build script where it belongs * build.zig: introduce `-Dflat` option which makes the installation match what we want to ship for our download tarballs. This allows deleting a bunch of shell script logic from the CI. - for example it puts the executable directly in prefix/zig rather than prefix/bin/zig and it additionally includes prefix/LICENSE. * build.zig: by default also install std lib documentation to doc/std/ - this can be disabled by `-Dno-autodocs` similar to how there is already `-Dno-langref`. * build.zig: add `std-docs` and `langref` steps which build and install the std lib autodocs and langref to prefix/doc/std and prefix/doc/langref.html, respectively. * std.Build: implement proper handling of `-femit-docs` using the LazyPath system. This is a breaking change. - this is a partial implementation of #16351 * frontend: fixed the handling of Autodocs with regards to caching and putting the artifacts in the proper location to integrate with the build system. - closes #15864 * CI: delete the logic for autodocs since it is now handled by build.zig and is enabled by default. - in the future we should strive to have nearly all the CI shell script logic deleted in favor of `zig build` commands. * CI: pass `-DZIG_NO_LIB=ON`/`-Dno-lib` except for the one command where we want to actually generate the langref and autodocs. Generating the langref takes 14 minutes right now (why?!) so we don't want to do that more times than necessary. * Autodoc: fixed use of a global variable. It works fine as a local variable instead. - note that in the future we will want to make Autodoc run simultaneously using the job system, but for now the principle of YAGNI dictates that we don't have an init()/deinit() API and instead simply call the function that does the things. * Autodoc: only do it when there are no compile errors
2023-07-21 20:29:42 -07:00
.install_dir = .prefix,
.install_subdir = "doc/std",
});
disable tidy validation for autodocs tidy gives a false positive: line 304 column 9 - Warning: moved <style> tag to <head>! fix-style-tags: no to avoid. I noticed that `--show-warnings no` still incorrectly causes exit code 1. I was unable to find an alternative to tidy.
2024-06-17 00:09:40 -07:00
//if (enable_tidy) install_std_docs.step.dependOn(check_autodocs);
build: don't include std lib docs by default since we have `zig std` now to fill that role.
2024-03-06 22:35:48 -07:00
if (std_docs) {
move installation logic to the build script where it belongs * build.zig: introduce `-Dflat` option which makes the installation match what we want to ship for our download tarballs. This allows deleting a bunch of shell script logic from the CI. - for example it puts the executable directly in prefix/zig rather than prefix/bin/zig and it additionally includes prefix/LICENSE. * build.zig: by default also install std lib documentation to doc/std/ - this can be disabled by `-Dno-autodocs` similar to how there is already `-Dno-langref`. * build.zig: add `std-docs` and `langref` steps which build and install the std lib autodocs and langref to prefix/doc/std and prefix/doc/langref.html, respectively. * std.Build: implement proper handling of `-femit-docs` using the LazyPath system. This is a breaking change. - this is a partial implementation of #16351 * frontend: fixed the handling of Autodocs with regards to caching and putting the artifacts in the proper location to integrate with the build system. - closes #15864 * CI: delete the logic for autodocs since it is now handled by build.zig and is enabled by default. - in the future we should strive to have nearly all the CI shell script logic deleted in favor of `zig build` commands. * CI: pass `-DZIG_NO_LIB=ON`/`-Dno-lib` except for the one command where we want to actually generate the langref and autodocs. Generating the langref takes 14 minutes right now (why?!) so we don't want to do that more times than necessary. * Autodoc: fixed use of a global variable. It works fine as a local variable instead. - note that in the future we will want to make Autodoc run simultaneously using the job system, but for now the principle of YAGNI dictates that we don't have an init()/deinit() API and instead simply call the function that does the things. * Autodoc: only do it when there are no compile errors
2023-07-21 20:29:42 -07:00
b.getInstallStep().dependOn(&install_std_docs.step);
}
if (flat) {
b.installFile("LICENSE", "LICENSE");
build: include README.md in release tarballs
2023-07-23 15:51:13 -07:00
b.installFile("README.md", "README.md");
move installation logic to the build script where it belongs * build.zig: introduce `-Dflat` option which makes the installation match what we want to ship for our download tarballs. This allows deleting a bunch of shell script logic from the CI. - for example it puts the executable directly in prefix/zig rather than prefix/bin/zig and it additionally includes prefix/LICENSE. * build.zig: by default also install std lib documentation to doc/std/ - this can be disabled by `-Dno-autodocs` similar to how there is already `-Dno-langref`. * build.zig: add `std-docs` and `langref` steps which build and install the std lib autodocs and langref to prefix/doc/std and prefix/doc/langref.html, respectively. * std.Build: implement proper handling of `-femit-docs` using the LazyPath system. This is a breaking change. - this is a partial implementation of #16351 * frontend: fixed the handling of Autodocs with regards to caching and putting the artifacts in the proper location to integrate with the build system. - closes #15864 * CI: delete the logic for autodocs since it is now handled by build.zig and is enabled by default. - in the future we should strive to have nearly all the CI shell script logic deleted in favor of `zig build` commands. * CI: pass `-DZIG_NO_LIB=ON`/`-Dno-lib` except for the one command where we want to actually generate the langref and autodocs. Generating the langref takes 14 minutes right now (why?!) so we don't want to do that more times than necessary. * Autodoc: fixed use of a global variable. It works fine as a local variable instead. - note that in the future we will want to make Autodoc run simultaneously using the job system, but for now the principle of YAGNI dictates that we don't have an init()/deinit() API and instead simply call the function that does the things. * Autodoc: only do it when there are no compile errors
2023-07-21 20:29:42 -07:00
}
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);
std.io: introduce buffered I/O and change API I started working on #465 and made some corresponding std.io API changes. New structs: * std.io.FileInStream * std.io.FileOutStream * std.io.BufferedOutStream * std.io.BufferedInStream Removed: * std.io.File.in_stream * std.io.File.out_stream Now instead of &file.out_stream or &file.in_stream to get access to the stream API for a file, you get it like this: var file_in_stream = io.FileInStream.init(&file); const in_stream = &file_in_stream.stream; var file_out_stream = io.FileOutStream.init(&file); const out_stream = &file_out_stream.stream; This is evidence that we might not need any OOP features - See #130.
2017-11-07 03:22:27 -05:00
build.zig: rename -Dtest-default-only to -Dno-matrix because it's more memorable
2025-10-09 09:59:55 -07:00
const no_matrix = b.option(bool, "no-matrix", "Limit test matrix to exactly one target configuration") orelse false;
ci: drone disable debug test suite for aarch64 Temporary workaround for #8597 until upstream fix lands. - add `zig build -Dskip-debug` option - build a release-fast build.exe - disable test suite build modes { debug, release-small, release-safe } - enable passing test-* components - use parallel pipeline steps for tests
2021-04-24 16:39:26 -04:00
const skip_debug = b.option(bool, "skip-debug", "Main test suite skips debug builds") orelse false;
build.zig: rename -Dtest-default-only to -Dno-matrix because it's more memorable
2025-10-09 09:59:55 -07:00
const skip_release = b.option(bool, "skip-release", "Main test suite skips release builds") orelse no_matrix;
ci: skip release-small tests to save time we keep hitting the limit on how long CI tests take to run.
2018-09-12 14:50:26 -04:00
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;
build.zig: rename -Dtest-default-only to -Dno-matrix because it's more memorable
2025-10-09 09:59:55 -07:00
const skip_non_native = b.option(bool, "skip-non-native", "Main test suite skips non-native builds") orelse no_matrix;
significantly increase test coverage * add zig build option `-Dskip-libc` to skip tests that build libc (e.g. if you don't want to wait for musl to build) * add `-Denable-wine` option which uses wine to run cross compiled windows tests on non-windows hosts * add `-Denable-qemu` option which uses qemu to run cross compiled foreign architecture tests * add `-Denable-foreign-glibc=path` option which combined with `-Denable-qemu` enables running cross compiled tests that link against glibc. See https://github.com/ziglang/zig/wiki/Updating-libc#glibc for how to produce this directory. * the test matrix is done manually. release test builds are only enabled by default for the native target. this should save us some CI time, while still providing decent coverage of release builds. - add test coverage for `x86_64-linux-musl -lc` (building musl libc) - add test coverage for `x86_64-linux-gnu -lc` (building glibc) - add test coverage for `aarch64v8_5a-linux-none` - add test coverage for `aarch64v8_5a-linux-musl -lc` (building musl libc) - add test coverage for `aarch64v8_5a-linux-gnu -lc` (building glibc) - add test coverage for `arm-linux-none` - test coverage for `arm-linux-musleabihf -lc` (building musl libc) is disabled due to #3286 - test coverage for `arm-linux-gnueabihf -lc` (building glibc) is disabled due to #3287 - test coverage for `x86_64-windows-gnu -lc` (building mingw-w64) is disabled due to #3285 * enable qemu testing on the Linux CI job. There's not really a good reason to enable wine, since we have a Windows CI job as well. * remove the no longer needed `--build-file ../build.zig` from CI scripts * fix bug in glibc compilation where it wasn't properly reading the abi list txt files, resulting in "key not found" error. * std.build.Target gains: - isNetBSD - isLinux - osRequiresLibC - getArchPtrBitWidth - getExternalExecutor * zig build system gains support for enabling wine and enabling qemu. `artifact.enable_wine = true;`, `artifact.enable_qemu = true;`. This communicates that the system has these tools installed and the build system will use them to run tests. * zig build system gains support for overriding the dynamic linker of an executable artifact. * fix std.c.lseek prototype. makes behavior tests for arm-linux-musleabihf pass. * disable std lib tests that are failing on ARM. See #3288, #3289 * provide `std.os.off_t`. * disable some of the compiler_rt symbols for arm 32 bit. Fixes compiler_rt tests for arm 32 bit * add __stack_chk_guard when linking against glibc. Fixes std lib tests for aarch64-linux-gnu * workaround for "unable to inline function" using `@inlineCall`. Fixes compiler_rt tests for arm 32 bit.
2019-09-21 23:55:56 -04:00
const skip_libc = b.option(bool, "skip-libc", "Main test suite skips tests that link libc") orelse false;
CI: skip single-threaded tests on Drone sure would be nice if they would just give us another hour of CI run time.
2022-06-01 14:05:58 -07:00
const skip_single_threaded = b.option(bool, "skip-single-threaded", "Main test suite skips tests that are single-threaded") orelse false;
build: add -Dskip-compile-errors option Skips tests in test/cases/compile_errors.
2025-07-23 00:23:31 +02:00
const skip_compile_errors = b.option(bool, "skip-compile-errors", "Main test suite skips compile error tests") orelse false;
restore debug llvm CI coverage and reduce redundant coverage in slow runs to save time
2025-06-06 12:50:14 -07:00
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;
build: change -Dskip-macos to -Dskip-darwin and make it cover all darwin OSs
2025-11-14 22:39:12 +01:00
const skip_darwin = b.option(bool, "skip-darwin", "Main test suite skips targets with darwin OSs") orelse false;
restore debug llvm CI coverage and reduce redundant coverage in slow runs to save time
2025-06-06 12:50:14 -07:00
const skip_linux = b.option(bool, "skip-linux", "Main test suite skips targets with linux OS") orelse false;
CI: skip llvm backend tests in the script for testing x86 backend
2025-06-06 23:34:52 -07:00
const skip_llvm = b.option(bool, "skip-llvm", "Main test suite skips targets that use LLVM backend") orelse false;
CI: skip test-incremental on Windows Tracked by #22510
2025-11-22 08:06:26 -08:00
const skip_test_incremental = b.option(bool, "skip-test-incremental", "Main test step omits dependency on test-incremental step") orelse false;
self hosted zig: print usage
2017-10-21 17:31:06 -04:00
move some of the installation from cmake to zig build This moves the installation of shipped source files from large CMakeLists.txt lists to zig build recursive directory installation. On my computer a cmake `make install` takes 2.4 seconds even when it has to do nothing, and prints a lot of unnecessary lines to stdout that say "up-to-date: [some file it is installing]". After this commit, the default output of `make` is down to 1 second, and it does not print any junk to stdout. Further, a `make install` is no longer required and `make` is sufficient. This closes #2874. It also closes #2585. `make` now always invokes `zig build` for installing files and libuserland.a, and zig's own caching system makes that go fast.
2019-07-14 03:06:20 -04:00
const only_install_lib_files = b.option(bool, "lib-files-only", "Only install library files") orelse false;
build.zig: bootstrap stage1 with zig0 Instead of assuming that the zig version used with `zig build` is appropriate for building the self-hosted compiler component, we follow the same path as the cmake build script and build zig0, using that to produce zig1.o, re-linking to produce stage1. This allows an arbitrarily old Zig version and corresponding build.zig script to build all future versions of Zig from source via the bootstrap compiler. In other words, it allows us to use `zig build` as an alternative to cmake when bootstrapping.
2022-02-16 13:50:47 -07:00
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
const static_llvm = b.option(bool, "static-llvm", "Disable integration with system-installed LLVM, Clang, LLD, and libc++") orelse false;
remove `-fstage1` option After this commit, the self-hosted compiler does not offer the option to use stage1 as a backend anymore.
2022-10-31 20:29:55 -07:00
const enable_llvm = b.option(bool, "enable-llvm", "Build self-hosted compiler with LLVM backend enabled") orelse static_llvm;
stage2: update LLVM backend to for LLVM 13 There was some new code in master branch enumerating all the targets and a new target was added so we needed to add the glue code. This commit also introduces some build options to support experimental LLVM targets.
2021-08-31 22:50:10 -07:00
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;
update CPU features to LLVM 16
2023-01-26 16:33:40 -07:00
const llvm_has_xtensa = b.option(
bool,
"llvm-has-xtensa",
"Whether LLVM has the experimental target xtensa enabled",
) orelse false;
build: add build test check for availability of IOS SDK on the host
2023-08-18 11:57:12 +02:00
const enable_ios_sdk = b.option(bool, "enable-ios-sdk", "Run tests requiring presence of iOS SDK and frameworks") orelse false;
build: -Denable-ios-sdk implies -Denable-macos-sdk
2023-08-18 12:05:13 +02:00
const enable_macos_sdk = b.option(bool, "enable-macos-sdk", "Run tests requiring presence of macOS SDK and frameworks") orelse enable_ios_sdk;
Update build.zig
2022-11-28 22:04:42 +01:00
const enable_symlinks_windows = b.option(bool, "enable-symlinks-windows", "Run tests requiring presence of symlinks on Windows") orelse false;
don't try to find config_h if it's not needed
2020-07-03 18:15:01 -07:00
const config_h_path_option = b.option([]const u8, "config_h", "Path to the generated config.h");
build.zig supports specifying config.h location explicitly also it does not try to run llvm-config executable when -Dlib-files-only This fixes cross-compiling using the bootstrap repository.
2020-04-06 13:07:19 -04:00
build.zig: add a way to skip installing lib/ files
2021-04-16 18:58:27 -07:00
if (!skip_install_lib_files) {
move installation logic to the build script where it belongs * build.zig: introduce `-Dflat` option which makes the installation match what we want to ship for our download tarballs. This allows deleting a bunch of shell script logic from the CI. - for example it puts the executable directly in prefix/zig rather than prefix/bin/zig and it additionally includes prefix/LICENSE. * build.zig: by default also install std lib documentation to doc/std/ - this can be disabled by `-Dno-autodocs` similar to how there is already `-Dno-langref`. * build.zig: add `std-docs` and `langref` steps which build and install the std lib autodocs and langref to prefix/doc/std and prefix/doc/langref.html, respectively. * std.Build: implement proper handling of `-femit-docs` using the LazyPath system. This is a breaking change. - this is a partial implementation of #16351 * frontend: fixed the handling of Autodocs with regards to caching and putting the artifacts in the proper location to integrate with the build system. - closes #15864 * CI: delete the logic for autodocs since it is now handled by build.zig and is enabled by default. - in the future we should strive to have nearly all the CI shell script logic deleted in favor of `zig build` commands. * CI: pass `-DZIG_NO_LIB=ON`/`-Dno-lib` except for the one command where we want to actually generate the langref and autodocs. Generating the langref takes 14 minutes right now (why?!) so we don't want to do that more times than necessary. * Autodoc: fixed use of a global variable. It works fine as a local variable instead. - note that in the future we will want to make Autodoc run simultaneously using the job system, but for now the principle of YAGNI dictates that we don't have an init()/deinit() API and instead simply call the function that does the things. * Autodoc: only do it when there are no compile errors
2023-07-21 20:29:42 -07:00
b.installDirectory(.{
remove deprecated LazyPath.path union tag
2024-04-11 14:02:47 -07:00
.source_dir = b.path("lib"),
move installation logic to the build script where it belongs * build.zig: introduce `-Dflat` option which makes the installation match what we want to ship for our download tarballs. This allows deleting a bunch of shell script logic from the CI. - for example it puts the executable directly in prefix/zig rather than prefix/bin/zig and it additionally includes prefix/LICENSE. * build.zig: by default also install std lib documentation to doc/std/ - this can be disabled by `-Dno-autodocs` similar to how there is already `-Dno-langref`. * build.zig: add `std-docs` and `langref` steps which build and install the std lib autodocs and langref to prefix/doc/std and prefix/doc/langref.html, respectively. * std.Build: implement proper handling of `-femit-docs` using the LazyPath system. This is a breaking change. - this is a partial implementation of #16351 * frontend: fixed the handling of Autodocs with regards to caching and putting the artifacts in the proper location to integrate with the build system. - closes #15864 * CI: delete the logic for autodocs since it is now handled by build.zig and is enabled by default. - in the future we should strive to have nearly all the CI shell script logic deleted in favor of `zig build` commands. * CI: pass `-DZIG_NO_LIB=ON`/`-Dno-lib` except for the one command where we want to actually generate the langref and autodocs. Generating the langref takes 14 minutes right now (why?!) so we don't want to do that more times than necessary. * Autodoc: fixed use of a global variable. It works fine as a local variable instead. - note that in the future we will want to make Autodoc run simultaneously using the job system, but for now the principle of YAGNI dictates that we don't have an init()/deinit() API and instead simply call the function that does the things. * Autodoc: only do it when there are no compile errors
2023-07-21 20:29:42 -07:00
.install_dir = if (flat) .prefix else .lib,
.install_subdir = if (flat) "lib" else "zig",
build.zig: add a way to skip installing lib/ files
2021-04-16 18:58:27 -07:00
.exclude_extensions = &[_][]const u8{
update gitattributes and move test data into subdir
2022-12-18 16:28:30 -07:00
// exclude files from lib/std/compress/testdata
compress: add a deflate compressor Replaces the inflate API from `inflateStream(reader: anytype, window_slice: []u8)` to `decompressor(allocator: mem.Allocator, reader: anytype, dictionary: ?[]const u8)` and `compressor(allocator: mem.Allocator, writer: anytype, options: CompressorOptions)`
2022-01-09 02:12:00 +01:00
".gz",
build.zig: add a way to skip installing lib/ files
2021-04-16 18:58:27 -07:00
".z.0",
".z.9",
build.zig: fix typo in extension exclusion list we've been shipping these test files for a while now. oops.
2024-02-28 22:37:11 -07:00
".zst.3",
".zst.19",
build.zig: add a way to skip installing lib/ files
2021-04-16 18:58:27 -07:00
"rfc1951.txt",
compress: add a deflate compressor Replaces the inflate API from `inflateStream(reader: anytype, window_slice: []u8)` to `decompressor(allocator: mem.Allocator, reader: anytype, dictionary: ?[]const u8)` and `compressor(allocator: mem.Allocator, writer: anytype, options: CompressorOptions)`
2022-01-09 02:12:00 +01:00
"rfc1952.txt",
std.compress: add zstandard decompressor
2023-01-21 19:10:47 +11:00
"rfc8478.txt",
remove v1 deflate implementation
2024-02-14 22:34:13 +01:00
// exclude files from lib/std/compress/flate/testdata
compress: add a deflate compressor Replaces the inflate API from `inflateStream(reader: anytype, window_slice: []u8)` to `decompressor(allocator: mem.Allocator, reader: anytype, dictionary: ?[]const u8)` and `compressor(allocator: mem.Allocator, writer: anytype, options: CompressorOptions)`
2022-01-09 02:12:00 +01:00
".expect",
".expect-noinput",
".golden",
".input",
"compress-e.txt",
"compress-gettysburg.txt",
"compress-pi.txt",
"rfc1951.txt",
Add LZMA decoder
2023-02-02 11:59:56 -08:00
// exclude files from lib/std/compress/lzma/testdata
".lzma",
Add an xz decoder to the standard library
2023-01-23 11:46:40 -08:00
// exclude files from lib/std/compress/xz/testdata
".xz",
compress: add a deflate compressor Replaces the inflate API from `inflateStream(reader: anytype, window_slice: []u8)` to `decompressor(allocator: mem.Allocator, reader: anytype, dictionary: ?[]const u8)` and `compressor(allocator: mem.Allocator, writer: anytype, options: CompressorOptions)`
2022-01-09 02:12:00 +01:00
// exclude files from lib/std/tz/
tz parsing reader interface, test thicc files, and exclude tzif
2021-12-31 17:17:49 +00:00
".tzif",
build.zig: don't install testdata
2024-01-12 17:51:44 -07:00
// exclude files from lib/std/tar/testdata
".tar",
compress: add a deflate compressor Replaces the inflate API from `inflateStream(reader: anytype, window_slice: []u8)` to `decompressor(allocator: mem.Allocator, reader: anytype, dictionary: ?[]const u8)` and `compressor(allocator: mem.Allocator, writer: anytype, options: CompressorOptions)`
2022-01-09 02:12:00 +01:00
// others
"README.md",
build.zig: add a way to skip installing lib/ files
2021-04-16 18:58:27 -07:00
},
build.zig: blank out "*test.zig" files instead of omit Now that `@import` of a non-existent file name is a compile error, the Zig installation needs to include files that end with test.zig. However we still want to avoid bloat in the installation size, so we blank them out instead of omitting them entirely. Now AstGen of the full standard library can complete successfully on a Zig installation rather than erroring out with file not found.
2021-05-18 17:18:42 -07:00
.blank_extensions = &[_][]const u8{
"test.zig",
},
build.zig: add a way to skip installing lib/ files
2021-04-16 18:58:27 -07:00
});
}
self hosted zig: print usage
2017-10-21 17:31:06 -04:00
stage2: eliminate the "compiler id" concept Instead, append a "dirty suffix" to the version string when there are dirty git changes and use the version string as the compiler id. This avoids a dependency on the cache hash system, and saves time on first invocation of the compiler since it does not have to compute its compiler id. It also saves time by not having to check the cache for a saved compiler id.
2020-09-08 11:15:32 -07:00
if (only_install_lib_files)
return;
macho: add hot-code swapping poc
2023-03-16 20:41:46 +01:00
const entitlements = b.option([]const u8, "entitlements", "Path to entitlements file for hot-code swapping without sudo on macOS");
stage2: building libunwind.a and put glibc shared objects on the elf linker line
2020-09-16 17:17:37 -07:00
const tracy = b.option([]const u8, "tracy", "Enable Tracy integration. Supply path to Tracy source");
build: update Tracy integration * Update for v0.9 * Enable the memory and callstack integrations by default
2022-10-26 18:17:49 -07:00
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);
Add build option to set tracy-callstack-depth in `build.zig` (#21990)
2024-11-29 13:13:06 -07:00
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;
compiler: use std.heap.smp_allocator In main, now this allocator is chosen by default when compiling without libc in ReleaseFast or ReleaseSmall, and not targeting WebAssembly.
2025-02-06 17:41:50 -08:00
const debug_gpa = b.option(bool, "debug-allocator", "Force the compiler to use DebugAllocator") orelse false;
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
const link_libc = b.option(bool, "force-link-libc", "Force self-hosted compiler to link libc") orelse (enable_llvm or only_c);
build: add -Dsanitize-thread option
2022-10-05 03:22:10 -07:00
const sanitize_thread = b.option(bool, "sanitize-thread", "Enable thread-sanitization") orelse false;
build: introduce -Dwasi-bootstrap option Also, make -Donly-c prevent Autodoc from being included in the binary. This produces a 2.6 MiB zig.wasm file. 781 KB if piped through zstd.
2022-11-04 18:35:04 -07:00
const strip = b.option(bool, "strip", "Omit debug information");
build.zig: expose valgrind flag Allows to enable Valgrind integrations in release builds, sometimes useful in combination with tooling.
2024-07-16 17:26:41 -07:00
const valgrind = b.option(bool, "valgrind", "Enable valgrind integration");
build: add -Dpie option It is becoming increasingly common for distributions to want to enable PIE for all binaries and zig currently does not provide any way to do so aside from patching the build.zig.
2023-03-08 14:21:33 +01:00
const pie = b.option(bool, "pie", "Produce a Position Independent Executable");
compiler: make it easier to apply breaking changes to `std.builtin` Documentation for this will be on the wiki shortly. Resolves: #21842
2025-01-16 10:09:41 +00:00
const value_interpret_mode = b.option(ValueInterpretMode, "value-interpret-mode", "How the compiler translates between 'std.builtin' types and its internal datastructures") orelse .direct;
stage2: use std.debug.Trace only when explicitly enabled Because it bumps up the stack space requirements, which is making a test case fail on aarch64 drone CI.
2022-06-09 15:33:04 -07:00
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;
stage2: building libunwind.a and put glibc shared objects on the elf linker line
2020-09-16 17:17:37 -07:00
build.zig: add -Dmem-leak-frames option to configure how many stack frames to save with every allocation, in case it leaks and needs to get printed on process termination.
2021-05-03 20:42:36 -07:00
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: {
build: introduce -Dwasi-bootstrap option Also, make -Donly-c prevent Autodoc from being included in the binary. This produces a 2.6 MiB zig.wasm file. 781 KB if piped through zstd.
2022-11-04 18:35:04 -07:00
if (strip == true) break :blk @as(u32, 0);
update build.zig API usage
2023-01-30 21:39:43 -07:00
if (optimize != .Debug) break :blk 0;
build.zig: add -Dmem-leak-frames option to configure how many stack frames to save with every allocation, in case it leaks and needs to get printed on process termination.
2021-05-03 20:42:36 -07:00
break :blk 4;
};
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
const exe = addCompilerStep(b, .{
.optimize = optimize,
.target = target,
.strip = strip,
build.zig: expose valgrind flag Allows to enable Valgrind integrations in release builds, sometimes useful in combination with tooling.
2024-07-16 17:26:41 -07:00
.valgrind = valgrind,
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
.sanitize_thread = sanitize_thread,
.single_threaded = single_threaded,
});
build: add -Dpie option It is becoming increasingly common for distributions to want to enable PIE for all binaries and zig currently does not provide any way to do so aside from patching the build.zig.
2023-03-08 14:21:33 +01:00
exe.pie = pie;
macho: add hot-code swapping poc
2023-03-16 20:41:46 +01:00
exe.entitlements = entitlements;
Elf2: create a new linker from scratch This iteration already has significantly better incremental support. Closes #24110
2025-08-30 12:08:18 -04:00
exe.use_new_linker = b.option(bool, "new-linker", "Use the new linker");
stage2: implement --build-id styles
2023-04-25 16:57:43 +03:00
Build: add install commands to `--verbose` output
2025-06-13 12:01:59 -04:00
const use_llvm = b.option(bool, "use-llvm", "Use the llvm backend");
exe.use_llvm = use_llvm;
exe.use_lld = use_llvm;
build: don't skip compiler build with -Dno-bin This option exists for fast iteration during compiler development, since avoiding codegen (but still performing semantic analysis) causes compile errors to appear around twice as fast. This option was broken when the `emit_bin` property on `std.Build.Step.Compile` was removed. Now, when this option is passed, we add a direct install dependency on the compile step itself, so that it is always run.
2023-09-14 22:49:30 +01:00
if (no_bin) {
b.getInstallStep().dependOn(&exe.step);
} else {
build.zig: use InstallArtifact Options instead of mutation I expect this to have no functional change.
2023-08-02 15:19:26 -07:00
const install_exe = b.addInstallArtifact(exe, .{
.dest_dir = if (flat) .{ .override = .prefix } else .default,
});
move installation logic to the build script where it belongs * build.zig: introduce `-Dflat` option which makes the installation match what we want to ship for our download tarballs. This allows deleting a bunch of shell script logic from the CI. - for example it puts the executable directly in prefix/zig rather than prefix/bin/zig and it additionally includes prefix/LICENSE. * build.zig: by default also install std lib documentation to doc/std/ - this can be disabled by `-Dno-autodocs` similar to how there is already `-Dno-langref`. * build.zig: add `std-docs` and `langref` steps which build and install the std lib autodocs and langref to prefix/doc/std and prefix/doc/langref.html, respectively. * std.Build: implement proper handling of `-femit-docs` using the LazyPath system. This is a breaking change. - this is a partial implementation of #16351 * frontend: fixed the handling of Autodocs with regards to caching and putting the artifacts in the proper location to integrate with the build system. - closes #15864 * CI: delete the logic for autodocs since it is now handled by build.zig and is enabled by default. - in the future we should strive to have nearly all the CI shell script logic deleted in favor of `zig build` commands. * CI: pass `-DZIG_NO_LIB=ON`/`-Dno-lib` except for the one command where we want to actually generate the langref and autodocs. Generating the langref takes 14 minutes right now (why?!) so we don't want to do that more times than necessary. * Autodoc: fixed use of a global variable. It works fine as a local variable instead. - note that in the future we will want to make Autodoc run simultaneously using the job system, but for now the principle of YAGNI dictates that we don't have an init()/deinit() API and instead simply call the function that does the things. * Autodoc: only do it when there are no compile errors
2023-07-21 20:29:42 -07:00
b.getInstallStep().dependOn(&install_exe.step);
}
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
tests: avoid skipping native tests Make the test targets use options that match the actual options of CompileStep. This makes the code more straightforward, and ends up making fewer tests incorrectly skipped. For example, now the CI runner on Windows will no longer skip self-hosted x86_64 backend tests.
2023-04-13 16:44:45 -07:00
test_step.dependOn(&exe.step);
build.zig: bootstrap stage1 with zig0 Instead of assuming that the zig version used with `zig build` is appropriate for building the self-hosted compiler component, we follow the same path as the cmake build script and build zig0, using that to produce zig1.o, re-linking to produce stage1. This allows an arbitrarily old Zig version and corresponding build.zig script to build all future versions of Zig from source via the bootstrap compiler. In other words, it allows us to use `zig build` as an alternative to cmake when bootstrapping.
2022-02-16 13:50:47 -07:00
Rework build system `build_options` API (#9623) * rework `build_options` to integrate with the FileSource abstraction * support mapping as an arbitrarily named package * support mapping to multiple different artifacts * use hash of contents for options filename
2021-08-27 00:53:23 +01:00
const exe_options = b.addOptions();
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
exe.root_module.addOptions("build_options", exe_options);
Rework build system `build_options` API (#9623) * rework `build_options` to integrate with the FileSource abstraction * support mapping as an arbitrarily named package * support mapping to multiple different artifacts * use hash of contents for options filename
2021-08-27 00:53:23 +01:00
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);
stage2: update LLVM backend to for LLVM 13 There was some new code in master branch enumerating all the targets and a new target was added so we needed to add the glue code. This commit also introduces some build options to support experimental LLVM targets.
2021-08-31 22:50:10 -07:00
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);
update CPU features to LLVM 16
2023-01-26 16:33:40 -07:00
exe_options.addOption(bool, "llvm_has_xtensa", llvm_has_xtensa);
compiler: use std.heap.smp_allocator In main, now this allocator is chosen by default when compiling without libc in ReleaseFast or ReleaseSmall, and not targeting WebAssembly.
2025-02-06 17:41:50 -08:00
exe_options.addOption(bool, "debug_gpa", debug_gpa);
dev: introduce dev environments that enable compiler feature sets
2024-07-19 01:04:59 -04:00
exe_options.addOption(DevEnv, "dev", b.option(DevEnv, "dev", "Build a compiler with a reduced feature set for development of specific features") orelse if (only_c) .bootstrap else .full);
compiler: make it easier to apply breaking changes to `std.builtin` Documentation for this will be on the wiki shortly. Resolves: #21842
2025-01-16 10:09:41 +00:00
exe_options.addOption(ValueInterpretMode, "value_interpret_mode", value_interpret_mode);
Rework build system `build_options` API (#9623) * rework `build_options` to integrate with the FileSource abstraction * support mapping as an arbitrarily named package * support mapping to multiple different artifacts * use hash of contents for options filename
2021-08-27 00:53:23 +01:00
stage2: eliminate the "compiler id" concept Instead, append a "dirty suffix" to the version string when there are dirty git changes and use the version string as the compiler id. This avoids a dependency on the cache hash system, and saves time on first invocation of the compiler since it does not have to compute its compiler id. It also saves time by not having to check the cache for a saved compiler id.
2020-09-08 11:15:32 -07:00
if (link_libc) {
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
exe.root_module.link_libc = true;
stage2: eliminate the "compiler id" concept Instead, append a "dirty suffix" to the version string when there are dirty git changes and use the version string as the compiler id. This avoids a dependency on the cache hash system, and saves time on first invocation of the compiler since it does not have to compute its compiler id. It also saves time by not having to check the cache for a saved compiler id.
2020-09-08 11:15:32 -07:00
}
update build.zig API usage
2023-01-30 21:39:43 -07:00
const is_debug = optimize == .Debug;
compiler: audit debug mode checks * Introduce `-Ddebug-extensions` for enabling compiler debug helpers * Replace safety mode checks with `std.debug.runtime_safety` * Replace debugger helper checks with `!builtin.strip_debug_info` Sometimes, you just have to debug optimized compilers...
2024-03-01 16:46:48 +01:00
const enable_debug_extensions = b.option(bool, "debug-extensions", "Enable commands and options useful for debugging the compiler") orelse is_debug;
stage2: make --debug-log work by default for debug builds can be disabled with `-Dlog=false`
2022-01-31 21:11:41 -07:00
const enable_logging = b.option(bool, "log", "Enable debug logging with --debug-log") orelse is_debug;
macho: dump linker's state as JSON Each element of the output JSON has the VM address of the generated binary nondecreasing (some elements might occupy the same VM address for example the atom and the relocation might coincide in the address space). The generated JSON can be inspected manually or via a preview tool `zig-snapshots` that I am currently working on and will allow the user to inspect interactively the state of the linker together with the positioning of sections, symbols, atoms and relocations within each snapshot state, and in the future, between snapshots too. This should allow for quicker debugging of the linker which is nontrivial when run in the incremental mode. Note that the state will only be dumped if the compiler is built with `-Dlink-snapshot` flag on, and then the compiler is passed `--debug-link-snapshot` flag upon compiling a source/project.
2021-10-14 13:50:10 +02:00
const enable_link_snapshots = b.option(bool, "link-snapshot", "Whether to enable linker state snapshots") orelse false;
stage2: eliminate the "compiler id" concept Instead, append a "dirty suffix" to the version string when there are dirty git changes and use the version string as the compiler id. This avoids a dependency on the cache hash system, and saves time on first invocation of the compiler since it does not have to compute its compiler id. It also saves time by not having to check the cache for a saved compiler id.
2020-09-08 11:15:32 -07:00
const opt_version_string = b.option([]const u8, "version-string", "Override Zig version string. Default is to find out with git.");
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
const version_slice = if (opt_version_string) |version| version else v: {
Avoid depending on child process execution when not supported by host OS In accordance with the requesting issue (#10750): - `zig test` skips any tests that it cannot spawn, returning success - `zig run` and `zig build` exit with failure, reporting the command the cannot be run - `zig clang`, `zig ar`, etc. already punt directly to the appropriate clang/lld main(), even before this change - Native `libc` Detection is not supported Additionally, `exec()` and related Builder functions error at run-time, reporting the command that cannot be run
2022-02-03 15:27:01 -07:00
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);
}
build.zig: bootstrap stage1 with zig0 Instead of assuming that the zig version used with `zig build` is appropriate for building the self-hosted compiler component, we follow the same path as the cmake build script and build zig0, using that to produce zig1.o, re-linking to produce stage1. This allows an arbitrarily old Zig version and corresponding build.zig script to build all future versions of Zig from source via the bootstrap compiler. In other words, it allows us to use `zig build` as an alternative to cmake when bootstrapping.
2022-02-16 13:50:47 -07:00
const version_string = b.fmt("{d}.{d}.{d}", .{ zig_version.major, zig_version.minor, zig_version.patch });
stage2: eliminate the "compiler id" concept Instead, append a "dirty suffix" to the version string when there are dirty git changes and use the version string as the compiler id. This avoids a dependency on the cache hash system, and saves time on first invocation of the compiler since it does not have to compute its compiler id. It also saves time by not having to check the cache for a saved compiler id.
2020-09-08 11:15:32 -07:00
var code: u8 = undefined;
child_process + Build: rename exec to run + all related code Justification: exec, execv etc are unix concepts and portable version should be called differently. Do no touch non-Zig code. Adjust error names as well, if associated. Closes #5853.
2023-10-19 22:36:11 +02:00
const git_describe_untrimmed = b.runAllowFail(&[_][]const u8{
build: pass --abbrev to git rather than relying on global config For computing the zig version number, pass --abbrev=9 rather than requiring the user to set their git configuration in order to make zig versions match the standard.
2023-12-18 14:43:07 -07:00
"git",
Reapply "build: Don't check parent directories for git tag" This reverts commit 7e0c25eccd8d9bc5b77953dbc9a39a26e383c550. The `--git-dir` argument is relative to the `-C` argument, making this patch OK after all. I added a comment to go along with this since I found it confusing. Apologies for the revert.
2025-03-08 12:27:43 -08:00
"-C", b.build_root.path orelse ".", // affects the --git-dir argument
"--git-dir", ".git", // affected by the -C argument
"describe", "--match", "*.*.*", //
"--tags", "--abbrev=9",
stage2: eliminate the "compiler id" concept Instead, append a "dirty suffix" to the version string when there are dirty git changes and use the version string as the compiler id. This avoids a dependency on the cache hash system, and saves time on first invocation of the compiler since it does not have to compute its compiler id. It also saves time by not having to check the cache for a saved compiler id.
2020-09-08 11:15:32 -07:00
}, &code, .Ignore) catch {
break :v version_string;
};
Restore the reverted semantic versioning commits restore "Comply with semantic versioning pre-release format" restore "stage2: SemVer compliance for development builds" restore "Remove 'g' prefix from commit hash in Zig semver" This reverts commit d96d8639e592b4bb4b2e330c4bd7412256b297d2. This reverts commit e8810f579406673edad0c9780c9d990f3034717a. This reverts commit 9afe5859a3e428b259a306c36a860e4d82dbb4bb.
2021-01-01 21:01:51 -07:00
const git_describe = mem.trim(u8, git_describe_untrimmed, " \n\r");
std.mem: Add `countScalar`
2025-10-03 14:22:11 -07:00
switch (mem.countScalar(u8, git_describe, '-')) {
Restore the reverted semantic versioning commits restore "Comply with semantic versioning pre-release format" restore "stage2: SemVer compliance for development builds" restore "Remove 'g' prefix from commit hash in Zig semver" This reverts commit d96d8639e592b4bb4b2e330c4bd7412256b297d2. This reverts commit e8810f579406673edad0c9780c9d990f3034717a. This reverts commit 9afe5859a3e428b259a306c36a860e4d82dbb4bb.
2021-01-01 21:01:51 -07:00
0 => {
Release 0.10.0
2022-10-31 10:24:38 -07:00
// Tagged release version (e.g. 0.10.0).
Restore the reverted semantic versioning commits restore "Comply with semantic versioning pre-release format" restore "stage2: SemVer compliance for development builds" restore "Remove 'g' prefix from commit hash in Zig semver" This reverts commit d96d8639e592b4bb4b2e330c4bd7412256b297d2. This reverts commit e8810f579406673edad0c9780c9d990f3034717a. This reverts commit 9afe5859a3e428b259a306c36a860e4d82dbb4bb.
2021-01-01 21:01:51 -07:00
if (!mem.eql(u8, git_describe, version_string)) {
tests: Use {s} instead of {} when formatting strings
2020-11-26 13:28:38 +01:00
std.debug.print("Zig version '{s}' does not match Git tag '{s}'\n", .{ version_string, git_describe });
Restore the reverted semantic versioning commits restore "Comply with semantic versioning pre-release format" restore "stage2: SemVer compliance for development builds" restore "Remove 'g' prefix from commit hash in Zig semver" This reverts commit d96d8639e592b4bb4b2e330c4bd7412256b297d2. This reverts commit e8810f579406673edad0c9780c9d990f3034717a. This reverts commit 9afe5859a3e428b259a306c36a860e4d82dbb4bb.
2021-01-01 21:01:51 -07:00
std.process.exit(1);
}
break :v version_string;
},
2 => {
Release 0.10.0
2022-10-31 10:24:38 -07:00
// Untagged development build (e.g. 0.10.0-dev.2025+ecf0050a9).
Update all std.mem.split calls to their appropriate function Everywhere that can now use `splitScalar` should get a nice little performance boost.
2023-05-04 18:15:50 -07:00
var it = mem.splitScalar(u8, git_describe, '-');
std.mem: add `first` method to `SplitIterator` and `SplitBackwardsIterator`
2022-07-25 21:04:30 +02:00
const tagged_ancestor = it.first();
const commit_height = it.next().?;
const commit_id = it.next().?;
Restore the reverted semantic versioning commits restore "Comply with semantic versioning pre-release format" restore "stage2: SemVer compliance for development builds" restore "Remove 'g' prefix from commit hash in Zig semver" This reverts commit d96d8639e592b4bb4b2e330c4bd7412256b297d2. This reverts commit e8810f579406673edad0c9780c9d990f3034717a. This reverts commit 9afe5859a3e428b259a306c36a860e4d82dbb4bb.
2021-01-01 21:01:51 -07:00
std: replace builtin.Version with SemanticVersion
2023-02-21 18:39:22 +01:00
const ancestor_ver = try std.SemanticVersion.parse(tagged_ancestor);
Restore the reverted semantic versioning commits restore "Comply with semantic versioning pre-release format" restore "stage2: SemVer compliance for development builds" restore "Remove 'g' prefix from commit hash in Zig semver" This reverts commit d96d8639e592b4bb4b2e330c4bd7412256b297d2. This reverts commit e8810f579406673edad0c9780c9d990f3034717a. This reverts commit 9afe5859a3e428b259a306c36a860e4d82dbb4bb.
2021-01-01 21:01:51 -07:00
if (zig_version.order(ancestor_ver) != .gt) {
std.fmt: breaking API changes added adapter to AnyWriter and GenericWriter to help bridge the gap between old and new API make std.testing.expectFmt work at compile-time std.fmt no longer has a dependency on std.unicode. Formatted printing was never properly unicode-aware. Now it no longer pretends to be. Breakage/deprecations: * std.fs.File.reader -> std.fs.File.deprecatedReader * std.fs.File.writer -> std.fs.File.deprecatedWriter * std.io.GenericReader -> std.io.Reader * std.io.GenericWriter -> std.io.Writer * std.io.AnyReader -> std.io.Reader * std.io.AnyWriter -> std.io.Writer * std.fmt.format -> std.fmt.deprecatedFormat * std.fmt.fmtSliceEscapeLower -> std.ascii.hexEscape * std.fmt.fmtSliceEscapeUpper -> std.ascii.hexEscape * std.fmt.fmtSliceHexLower -> {x} * std.fmt.fmtSliceHexUpper -> {X} * std.fmt.fmtIntSizeDec -> {B} * std.fmt.fmtIntSizeBin -> {Bi} * std.fmt.fmtDuration -> {D} * std.fmt.fmtDurationSigned -> {D} * {} -> {f} when there is a format method * format method signature - anytype -> *std.io.Writer - inferred error set -> error{WriteFailed} - options -> (deleted) * std.fmt.Formatted - now takes context type explicitly - no fmt string
2025-06-27 20:05:22 -07:00
std.debug.print("Zig version '{f}' must be greater than tagged ancestor '{f}'\n", .{ zig_version, ancestor_ver });
Restore the reverted semantic versioning commits restore "Comply with semantic versioning pre-release format" restore "stage2: SemVer compliance for development builds" restore "Remove 'g' prefix from commit hash in Zig semver" This reverts commit d96d8639e592b4bb4b2e330c4bd7412256b297d2. This reverts commit e8810f579406673edad0c9780c9d990f3034717a. This reverts commit 9afe5859a3e428b259a306c36a860e4d82dbb4bb.
2021-01-01 21:01:51 -07:00
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') {
tests: Use {s} instead of {} when formatting strings
2020-11-26 13:28:38 +01:00
std.debug.print("Unexpected `git describe` output: {s}\n", .{git_describe});
Restore the reverted semantic versioning commits restore "Comply with semantic versioning pre-release format" restore "stage2: SemVer compliance for development builds" restore "Remove 'g' prefix from commit hash in Zig semver" This reverts commit d96d8639e592b4bb4b2e330c4bd7412256b297d2. This reverts commit e8810f579406673edad0c9780c9d990f3034717a. This reverts commit 9afe5859a3e428b259a306c36a860e4d82dbb4bb.
2021-01-01 21:01:51 -07:00
break :v version_string;
}
// The version is reformatted in accordance with the https://semver.org specification.
tests: Use {s} instead of {} when formatting strings
2020-11-26 13:28:38 +01:00
break :v b.fmt("{s}-dev.{s}+{s}", .{ version_string, commit_height, commit_id[1..] });
Restore the reverted semantic versioning commits restore "Comply with semantic versioning pre-release format" restore "stage2: SemVer compliance for development builds" restore "Remove 'g' prefix from commit hash in Zig semver" This reverts commit d96d8639e592b4bb4b2e330c4bd7412256b297d2. This reverts commit e8810f579406673edad0c9780c9d990f3034717a. This reverts commit 9afe5859a3e428b259a306c36a860e4d82dbb4bb.
2021-01-01 21:01:51 -07:00
},
else => {
tests: Use {s} instead of {} when formatting strings
2020-11-26 13:28:38 +01:00
std.debug.print("Unexpected `git describe` output: {s}\n", .{git_describe});
Restore the reverted semantic versioning commits restore "Comply with semantic versioning pre-release format" restore "stage2: SemVer compliance for development builds" restore "Remove 'g' prefix from commit hash in Zig semver" This reverts commit d96d8639e592b4bb4b2e330c4bd7412256b297d2. This reverts commit e8810f579406673edad0c9780c9d990f3034717a. This reverts commit 9afe5859a3e428b259a306c36a860e4d82dbb4bb.
2021-01-01 21:01:51 -07:00
break :v version_string;
},
stage2: eliminate the "compiler id" concept Instead, append a "dirty suffix" to the version string when there are dirty git changes and use the version string as the compiler id. This avoids a dependency on the cache hash system, and saves time on first invocation of the compiler since it does not have to compute its compiler id. It also saves time by not having to check the cache for a saved compiler id.
2020-09-08 11:15:32 -07:00
}
};
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
const version = try b.allocator.dupeZ(u8, version_slice);
exe_options.addOption([:0]const u8, "version", version);
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
build.zig: bootstrap stage1 with zig0 Instead of assuming that the zig version used with `zig build` is appropriate for building the self-hosted compiler component, we follow the same path as the cmake build script and build zig0, using that to produce zig1.o, re-linking to produce stage1. This allows an arbitrarily old Zig version and corresponding build.zig script to build all future versions of Zig from source via the bootstrap compiler. In other words, it allows us to use `zig build` as an alternative to cmake when bootstrapping.
2022-02-16 13:50:47 -07:00
if (enable_llvm) {
build.zig: Emit warning if "config.h" cannot be found We now warn the user if config.h could not be located. This also updates the search to stop early upon encountering a `.git` directory, so that we avoid recursing outside of the zig source if possible.
2022-07-15 17:25:38 -07:00
const cmake_cfg = if (static_llvm) null else blk: {
if (findConfigH(b, config_h_path_option)) |config_h_path| {
upgrade more old API uses
2025-08-29 20:34:20 -07:00
const file_contents = fs.cwd().readFileAlloc(config_h_path, b.allocator, .limited(max_config_h_bytes)) catch unreachable;
build.zig: Emit warning if "config.h" cannot be found We now warn the user if config.h could not be located. This also updates the search to stop early upon encountering a `.git` directory, so that we avoid recursing outside of the zig source if possible.
2022-07-15 17:25:38 -07:00
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;
}
};
build.zig: bootstrap stage1 with zig0 Instead of assuming that the zig version used with `zig build` is appropriate for building the self-hosted compiler component, we follow the same path as the cmake build script and build zig0, using that to produce zig1.o, re-linking to produce stage1. This allows an arbitrarily old Zig version and corresponding build.zig script to build all future versions of Zig from source via the bootstrap compiler. In other words, it allows us to use `zig build` as an alternative to cmake when bootstrapping.
2022-02-16 13:50:47 -07:00
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) {
Update all std.mem.tokenize calls to their appropriate function Everywhere that can now use `tokenizeScalar` should get a nice little performance boost.
2023-05-04 18:05:40 -07:00
var it = mem.tokenizeScalar(u8, cfg.cmake_prefix_path, ';');
build.zig: Parse CMAKE_PREFIX_PATH with multiple entries CMAKE_PREFIX_PATH is a semicolon separated list.
2022-10-11 08:16:27 -07:00
while (it.next()) |path| {
b.addSearchPrefix(path);
}
build.zig: bootstrap stage1 with zig0 Instead of assuming that the zig version used with `zig build` is appropriate for building the self-hosted compiler component, we follow the same path as the cmake build script and build zig0, using that to produce zig1.o, re-linking to produce stage1. This allows an arbitrarily old Zig version and corresponding build.zig script to build all future versions of Zig from source via the bootstrap compiler. In other words, it allows us to use `zig build` as an alternative to cmake when bootstrapping.
2022-02-16 13:50:47 -07:00
}
try addCmakeCfgOptionsToExe(b, cfg, exe, use_zig_libcxx);
} else {
// Here we are -Denable-llvm but no cmake integration.
build.zig: Statically link LLVM libraries for experimental targets if requested.
2025-03-26 23:19:35 +01:00
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,
});
build.zig: bootstrap stage1 with zig0 Instead of assuming that the zig version used with `zig build` is appropriate for building the self-hosted compiler component, we follow the same path as the cmake build script and build zig0, using that to produce zig1.o, re-linking to produce stage1. This allows an arbitrarily old Zig version and corresponding build.zig script to build all future versions of Zig from source via the bootstrap compiler. In other words, it allows us to use `zig build` as an alternative to cmake when bootstrapping.
2022-02-16 13:50:47 -07:00
}
std.Build.ResolvedTarget: rename target field to result This change is seemingly insignificant but I actually agonized over this for three days. Some other things I considered: * (status quo in master branch) make Compile step creation functions accept a Target.Query and delete the ResolvedTarget struct. - downside: redundantly resolve target queries many times * same as before but additionally add a hash map to cache target query resolutions. - downside: now there is a hash map that doesn't actually need to exist, just to make the API more ergonomic. * add is_native_os and is_native_abi fields to std.Target and use it directly as the result of resolving a target query. - downside: they really don't belong there. They would be available as comptime booleans via `@import("builtin")` but they should not be exposed that way. With this change the downsides are: * the option name of addExecutable and friends is `target` instead of `resolved_target` matching the type name. - upside: this does not break compatibility with existing build scripts * you likely end up seeing `target.result.cpu.arch` rather than `target.cpu.arch`. - upside: this is an improvement over `target.target.cpu.arch` which it was before this commit. - downside: `b.host.target` is now `b.host.result`.
2023-12-05 16:09:07 -07:00
if (target.result.os.tag == .windows) {
compiler: rework type resolution, fully resolve all types I'm so sorry. This commit was just meant to be making all types fully resolve by queueing resolution at the moment of their creation. Unfortunately, a lot of dominoes ended up falling. Here's what happened: * I added a work queue job to fully resolve a type. * I realised that from here we could eliminate `Sema.types_to_resolve` if we made function codegen a separate job. This is desirable for simplicity of both spec and implementation. * This led to a new AIR traversal to detect whether any required type is unresolved. If a type in the AIR failed to resolve, then we can't run codegen. * Because full type resolution now occurs by the work queue job, a bug was exposed whereby error messages for type resolution were associated with the wrong `Decl`, resulting in duplicate error messages when the type was also resolved "by" its owner `Decl` (which really *all* resolution should be done on). * A correct fix for this requires using a different `Sema` when performing type resolution: we need a `Sema` owned by the type. Also note that this fix is necessary for incremental compilation. * This means a whole bunch of functions no longer need to take `Sema`s. * First-order effects: `resolveTypeFields`, `resolveTypeLayout`, etc * Second-order effects: `Type.abiAlignmentAdvanced`, `Value.orderAgainstZeroAdvanced`, etc The end result of this is, in short, a more correct compiler and a simpler language specification. This regressed a few error notes in the test cases, but nothing that seems worth blocking this change. Oh, also, I ripped out the old code in `test/src/Cases.zig` which introduced a dependency on `Compilation`. This dependency was problematic at best, and this code has been unused for a while. When we re-enable incremental test cases, we must rewrite their executor to use the compiler server protocol.
2024-07-04 05:00:32 +01:00
// LLVM depends on networking as of version 18.
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
exe.root_module.linkSystemLibrary("ws2_32", .{});
apparently LLVM depends on ws2_32.dll now
2024-04-29 16:57:40 -07:00
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
exe.root_module.linkSystemLibrary("version", .{});
exe.root_module.linkSystemLibrary("uuid", .{});
exe.root_module.linkSystemLibrary("ole32", .{});
build.zig: on windows always link llvm-required system libs When building with LLVM, always do -lole32 -lversion -luuid even when using the cmake-provided build stuff. Otherwise we get undefined symbols when linking.
2022-12-07 01:50:49 -08:00
}
build.zig: bootstrap stage1 with zig0 Instead of assuming that the zig version used with `zig build` is appropriate for building the self-hosted compiler component, we follow the same path as the cmake build script and build zig0, using that to produce zig1.o, re-linking to produce stage1. This allows an arbitrarily old Zig version and corresponding build.zig script to build all future versions of Zig from source via the bootstrap compiler. In other words, it allows us to use `zig build` as an alternative to cmake when bootstrapping.
2022-02-16 13:50:47 -07:00
}
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
const semver = try std.SemanticVersion.parse(version);
Rework build system `build_options` API (#9623) * rework `build_options` to integrate with the FileSource abstraction * support mapping as an arbitrarily named package * support mapping to multiple different artifacts * use hash of contents for options filename
2021-08-27 00:53:23 +01:00
exe_options.addOption(std.SemanticVersion, "semver", semver);
stage2: eliminate the "compiler id" concept Instead, append a "dirty suffix" to the version string when there are dirty git changes and use the version string as the compiler id. This avoids a dependency on the cache hash system, and saves time on first invocation of the compiler since it does not have to compute its compiler id. It also saves time by not having to check the cache for a saved compiler id.
2020-09-08 11:15:32 -07:00
compiler: audit debug mode checks * Introduce `-Ddebug-extensions` for enabling compiler debug helpers * Replace safety mode checks with `std.debug.runtime_safety` * Replace debugger helper checks with `!builtin.strip_debug_info` Sometimes, you just have to debug optimized compilers...
2024-03-01 16:46:48 +01:00
exe_options.addOption(bool, "enable_debug_extensions", enable_debug_extensions);
Rework build system `build_options` API (#9623) * rework `build_options` to integrate with the FileSource abstraction * support mapping as an arbitrarily named package * support mapping to multiple different artifacts * use hash of contents for options filename
2021-08-27 00:53:23 +01:00
exe_options.addOption(bool, "enable_logging", enable_logging);
macho: dump linker's state as JSON Each element of the output JSON has the VM address of the generated binary nondecreasing (some elements might occupy the same VM address for example the atom and the relocation might coincide in the address space). The generated JSON can be inspected manually or via a preview tool `zig-snapshots` that I am currently working on and will allow the user to inspect interactively the state of the linker together with the positioning of sections, symbols, atoms and relocations within each snapshot state, and in the future, between snapshots too. This should allow for quicker debugging of the linker which is nontrivial when run in the incremental mode. Note that the state will only be dumped if the compiler is built with `-Dlink-snapshot` flag on, and then the compiler is passed `--debug-link-snapshot` flag upon compiling a source/project.
2021-10-14 13:50:10 +02:00
exe_options.addOption(bool, "enable_link_snapshots", enable_link_snapshots);
Rework build system `build_options` API (#9623) * rework `build_options` to integrate with the FileSource abstraction * support mapping as an arbitrarily named package * support mapping to multiple different artifacts * use hash of contents for options filename
2021-08-27 00:53:23 +01:00
exe_options.addOption(bool, "enable_tracy", tracy != null);
make tracy.zig more feature complete
2021-10-31 14:12:36 +00:00
exe_options.addOption(bool, "enable_tracy_callstack", tracy_callstack);
add functionality to trace allocations
2021-10-31 14:16:59 +00:00
exe_options.addOption(bool, "enable_tracy_allocation", tracy_allocation);
Add build option to set tracy-callstack-depth in `build.zig` (#21990)
2024-11-29 13:13:06 -07:00
exe_options.addOption(u32, "tracy_callstack_depth", tracy_callstack_depth);
stage2: use std.debug.Trace only when explicitly enabled Because it bumps up the stack space requirements, which is making a test case fail on aarch64 drone CI.
2022-06-09 15:33:04 -07:00
exe_options.addOption(bool, "value_tracing", value_tracing);
stage2: eliminate the "compiler id" concept Instead, append a "dirty suffix" to the version string when there are dirty git changes and use the version string as the compiler id. This avoids a dependency on the cache hash system, and saves time on first invocation of the compiler since it does not have to compute its compiler id. It also saves time by not having to check the cache for a saved compiler id.
2020-09-08 11:15:32 -07:00
if (tracy) |tracy_path| {
Build.zig rename orgy (aka: #16353). Renames FileSource to LazyPath and removes functions that take literal paths instead of LazyPath.
2023-07-19 10:49:34 +02:00
const client_cpp = b.pathJoin(
build: update Tracy integration * Update for v0.9 * Enable the memory and callstack integrations by default
2022-10-26 18:17:49 -07:00
&[_][]const u8{ tracy_path, "public", "TracyClient.cpp" },
Build.zig rename orgy (aka: #16353). Renames FileSource to LazyPath and removes functions that take literal paths instead of LazyPath.
2023-07-19 10:49:34 +02:00
);
Fix compiler builds with tracy on the mingw target
2021-09-16 16:51:29 -05:00
build.zig: Stop setting _WIN32_WINNT=0x601 (Windows 7) when targeting MinGW. Our default minimum version for Windows has been Windows 10 for a while.
2025-03-26 22:47:59 +01:00
const tracy_c_flags: []const []const u8 = &.{ "-DTRACY_ENABLE=1", "-fno-sanitize=undefined" };
Fix compiler builds with tracy on the mingw target
2021-09-16 16:51:29 -05:00
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
exe.root_module.addIncludePath(.{ .cwd_relative = tracy_path });
exe.root_module.addCSourceFile(.{ .file = .{ .cwd_relative = client_cpp }, .flags = tracy_c_flags });
stage2: building libunwind.a and put glibc shared objects on the elf linker line
2020-09-16 17:17:37 -07:00
if (!enable_llvm) {
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
exe.root_module.linkSystemLibrary("c++", .{ .use_pkg_config = .no });
stage2: building libunwind.a and put glibc shared objects on the elf linker line
2020-09-16 17:17:37 -07:00
}
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
exe.root_module.link_libc = true;
Fix compiler builds with tracy on the mingw target
2021-09-16 16:51:29 -05:00
std.Build.ResolvedTarget: rename target field to result This change is seemingly insignificant but I actually agonized over this for three days. Some other things I considered: * (status quo in master branch) make Compile step creation functions accept a Target.Query and delete the ResolvedTarget struct. - downside: redundantly resolve target queries many times * same as before but additionally add a hash map to cache target query resolutions. - downside: now there is a hash map that doesn't actually need to exist, just to make the API more ergonomic. * add is_native_os and is_native_abi fields to std.Target and use it directly as the result of resolving a target query. - downside: they really don't belong there. They would be available as comptime booleans via `@import("builtin")` but they should not be exposed that way. With this change the downsides are: * the option name of addExecutable and friends is `target` instead of `resolved_target` matching the type name. - upside: this does not break compatibility with existing build scripts * you likely end up seeing `target.result.cpu.arch` rather than `target.cpu.arch`. - upside: this is an improvement over `target.target.cpu.arch` which it was before this commit. - downside: `b.host.target` is now `b.host.result`.
2023-12-05 16:09:07 -07:00
if (target.result.os.tag == .windows) {
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
exe.root_module.linkSystemLibrary("dbghelp", .{});
exe.root_module.linkSystemLibrary("ws2_32", .{});
Fix compiler builds with tracy on the mingw target
2021-09-16 16:51:29 -05:00
}
stage2: eliminate the "compiler id" concept Instead, append a "dirty suffix" to the version string when there are dirty git changes and use the version string as the compiler id. This avoids a dependency on the cache hash system, and saves time on first invocation of the compiler since it does not have to compute its compiler id. It also saves time by not having to check the cache for a saved compiler id.
2020-09-08 11:15:32 -07:00
}
test: rework how filtering works * make test names contain the fully qualified name * make test filters match the fully qualified name * allow multiple test filters, where a test is skipped if it does not match any of the specified filters
2024-02-25 14:04:06 +01:00
const test_filters = b.option([]const []const u8, "test-filter", "Skip tests that do not match any filter") orelse &[0][]const u8{};
build/test: Add -Dtest-target-filter for filtering module tests by target triple. This is useful during porting work where you're not interested in running all targets all the time while iterating on changes.
2024-08-13 23:59:50 +02:00
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{};
build: Rename -Dtest-slow-targets to -Dtest-extra-targets. This can be used more broadly for targets that aren't quite ready to be tested by default yet.
2025-03-21 23:00:14 +01:00
const test_extra_targets = b.option(bool, "test-extra-targets", "Enable running module tests for additional targets") orelse false;
convert compare-output tests to use zig build system
2017-04-19 01:13:15 -04:00
change uses of std.builtin.Mode to OptimizeMode (#16745) std.builtin.Mode is deprecated.
2023-08-09 13:39:34 -05:00
var chosen_opt_modes_buf: [4]builtin.OptimizeMode = undefined;
ci: skip release-small tests to save time we keep hitting the limit on how long CI tests take to run.
2018-09-12 14:50:26 -04:00
var chosen_mode_index: usize = 0;
ci: drone disable debug test suite for aarch64 Temporary workaround for #8597 until upstream fix lands. - add `zig build -Dskip-debug` option - build a release-fast build.exe - disable test suite build modes { debug, release-small, release-safe } - enable passing test-* components - use parallel pipeline steps for tests
2021-04-24 16:39:26 -04:00
if (!skip_debug) {
change uses of std.builtin.Mode to OptimizeMode (#16745) std.builtin.Mode is deprecated.
2023-08-09 13:39:34 -05:00
chosen_opt_modes_buf[chosen_mode_index] = builtin.OptimizeMode.Debug;
ci: drone disable debug test suite for aarch64 Temporary workaround for #8597 until upstream fix lands. - add `zig build -Dskip-debug` option - build a release-fast build.exe - disable test suite build modes { debug, release-small, release-safe } - enable passing test-* components - use parallel pipeline steps for tests
2021-04-24 16:39:26 -04:00
chosen_mode_index += 1;
}
ci: skip release-small tests to save time we keep hitting the limit on how long CI tests take to run.
2018-09-12 14:50:26 -04:00
if (!skip_release_safe) {
change uses of std.builtin.Mode to OptimizeMode (#16745) std.builtin.Mode is deprecated.
2023-08-09 13:39:34 -05:00
chosen_opt_modes_buf[chosen_mode_index] = builtin.OptimizeMode.ReleaseSafe;
ci: skip release-small tests to save time we keep hitting the limit on how long CI tests take to run.
2018-09-12 14:50:26 -04:00
chosen_mode_index += 1;
}
if (!skip_release_fast) {
change uses of std.builtin.Mode to OptimizeMode (#16745) std.builtin.Mode is deprecated.
2023-08-09 13:39:34 -05:00
chosen_opt_modes_buf[chosen_mode_index] = builtin.OptimizeMode.ReleaseFast;
ci: skip release-small tests to save time we keep hitting the limit on how long CI tests take to run.
2018-09-12 14:50:26 -04:00
chosen_mode_index += 1;
}
if (!skip_release_small) {
change uses of std.builtin.Mode to OptimizeMode (#16745) std.builtin.Mode is deprecated.
2023-08-09 13:39:34 -05:00
chosen_opt_modes_buf[chosen_mode_index] = builtin.OptimizeMode.ReleaseSmall;
ci: skip release-small tests to save time we keep hitting the limit on how long CI tests take to run.
2018-09-12 14:50:26 -04:00
chosen_mode_index += 1;
}
update build.zig API usage
2023-01-30 21:39:43 -07:00
const optimization_modes = chosen_opt_modes_buf[0..chosen_mode_index];
std.io: introduce buffered I/O and change API I started working on #465 and made some corresponding std.io API changes. New structs: * std.io.FileInStream * std.io.FileOutStream * std.io.BufferedOutStream * std.io.BufferedInStream Removed: * std.io.File.in_stream * std.io.File.out_stream Now instead of &file.out_stream or &file.in_stream to get access to the stream API for a file, you get it like this: var file_in_stream = io.FileInStream.init(&file); const in_stream = &file_in_stream.stream; var file_out_stream = io.FileOutStream.init(&file); const out_stream = &file_out_stream.stream; This is evidence that we might not need any OOP features - See #130.
2017-11-07 03:22:27 -05:00
make `zig build test` check for conforming formatting There was already `zig build test-fmt` but now `zig build test` depends on that one. The CI scripts no longer need explicit logic since they already do `zig build test`.
2024-06-16 19:31:59 -07:00
const fmt_include_paths = &.{ "lib", "src", "test", "tools", "build.zig", "build.zig.zon" };
compiler,std: implement ZON support This commit allows using ZON (Zig Object Notation) in a few ways. * `@import` can be used to load ZON at comptime and convert it to a normal Zig value. In this case, `@import` must have a result type. * `std.zon.parse` can be used to parse ZON at runtime, akin to the parsing logic in `std.json`. * `std.zon.stringify` can be used to convert arbitrary data structures to ZON at runtime, again akin to `std.json`.
2024-11-04 14:03:36 -08:00
const fmt_exclude_paths = &.{ "test/cases", "test/behavior/zon" };
zig build: many enhancements related to parallel building Rework std.Build.Step to have an `owner: *Build` field. This simplified the implementation of installation steps, as well as provided some much-needed common API for the new parallelized build system. --verbose is now defined very concretely: it prints to stderr just before spawning a child process. Child process execution is updated to conform to the new parallel-friendly make() function semantics. DRY up the failWithCacheError handling code. It now integrates properly with the step graph instead of incorrectly dumping to stderr and calling process exit. In the main CLI, fix `zig fmt` crash when there are no errors and stdin is used. Deleted steps: * EmulatableRunStep - this entire thing can be removed in favor of a flag added to std.Build.RunStep called `skip_foreign_checks`. * LogStep - this doesn't really fit with a multi-threaded build runner and is effectively superseded by the new build summary output. build runner: * add -fsummary and -fno-summary to override the default behavior, which is to print a summary if any of the build steps fail. * print the dep prefix when emitting error messages for steps. std.Build.FmtStep: * This step now supports exclude paths as well as a check flag. * The check flag decides between two modes, modify mode, and check mode. These can be used to update source files in place, or to fail the build, respectively. Zig's own build.zig: * The `test-fmt` step will do all the `zig fmt` checking that we expect to be done. Since the `test` step depends on this one, we can simply remove the explicit call to `zig fmt` in the CI. * The new `fmt` step will actually perform `zig fmt` and update source files in place. std.Build.RunStep: * expose max_stdio_size is a field (previously an unchangeable hard-coded value). * rework the API. Instead of configuring each stream independently, there is a `stdio` field where you can choose between `infer_from_args`, `inherit`, or `check`. These determine whether the RunStep is considered to have side-effects or not. The previous field, `condition` is gone. * when stdio mode is set to `check` there is a slice of any number of checks to make, which include things like exit code, stderr matching, or stdout matching. * remove the ill-defined `print` field. * when adding an output arg, it takes the opportunity to give itself a better name. * The flag `skip_foreign_checks` is added. If this is true, a RunStep which is configured to check the output of the executed binary will not fail the build if the binary cannot be executed due to being for a foreign binary to the host system which is running the build graph. Command-line arguments such as -fqemu and -fwasmtime may affect whether a binary is detected as foreign, as well as system configuration such as Rosetta (macOS) and binfmt_misc (Linux). - This makes EmulatableRunStep no longer needed. * Fix the child process handling to properly integrate with the new bulid API and to avoid deadlocks in stdout/stderr streams by polling if necessary. std.Build.RemoveDirStep now uses the open build_root directory handle instead of an absolute path.
2023-03-01 22:56:37 -07:00
const do_fmt = b.addFmt(.{
.paths = fmt_include_paths,
.exclude_paths = fmt_exclude_paths,
});
make `zig build test` check for conforming formatting There was already `zig build test-fmt` but now `zig build test` depends on that one. The CI scripts no longer need explicit logic since they already do `zig build test`.
2024-06-16 19:31:59 -07:00
b.step("fmt", "Modify source files in place to have conforming formatting").dependOn(&do_fmt.step);
Add experimental Darling support for cross testing macOS * for cross testing stage2 tests, we use `darling shell` command since the path to the tested binary is relative to cwd * for the `zig test` command, we simply use `darling` since the path to the binary is absolute
2021-05-13 11:03:44 +02:00
make `zig build test` check for conforming formatting There was already `zig build test-fmt` but now `zig build test` depends on that one. The CI scripts no longer need explicit logic since they already do `zig build test`.
2024-06-16 19:31:59 -07:00
const check_fmt = b.step("test-fmt", "Check source files having conforming formatting");
check_fmt.dependOn(&b.addFmt(.{
re-enable test-cases and get them all passing Instead of using `zig test` to build a special version of the compiler that runs all the test-cases, the zig build system is now used as much as possible - all with the basic steps found in the standard library. For incremental compilation tests (the ones that look like foo.0.zig, foo.1.zig, foo.2.zig, etc.), a special version of the compiler is compiled into a utility executable called "check-case" which checks exactly one sequence of incremental updates in an independent subprocess. Previously, all incremental and non-incremental test cases were done in the same test runner process. The compile error checking code is now simpler, but also a bit rudimentary, and so it additionally makes sure that the actual compile errors do not include *extra* messages, and it makes sure that the actual compile errors output in the same order as expected. It is also based on the "ends-with" property of each line rather than the previous logic, which frankly I didn't want to touch with a ten-meter pole. The compile error test cases have been updated to pass in light of these differences. Previously, 'error' mode with 0 compile errors was used to shoehorn in a different kind of test-case - one that only checks if a piece of code compiles without errors. Now there is a 'compile' mode of test-cases, and 'error' must be only used when there are greater than 0 errors. link test cases are updated to omit the target object format argument when calling checkObject since that is no longer needed. The test/stage2 directory is removed; the 2 files within are moved to be directly in the test/ directory.
2023-03-09 18:22:51 -07:00
.paths = fmt_include_paths,
.exclude_paths = fmt_exclude_paths,
.check = true,
}).step);
make `zig build test` check for conforming formatting There was already `zig build test-fmt` but now `zig build test` depends on that one. The CI scripts no longer need explicit logic since they already do `zig build test`.
2024-06-16 19:31:59 -07:00
test_step.dependOn(check_fmt);
Add experimental Darling support for cross testing macOS * for cross testing stage2 tests, we use `darling shell` command since the path to the tested binary is relative to cwd * for the `zig test` command, we simply use `darling` since the path to the binary is absolute
2021-05-13 11:03:44 +02:00
re-enable test-cases and get them all passing Instead of using `zig test` to build a special version of the compiler that runs all the test-cases, the zig build system is now used as much as possible - all with the basic steps found in the standard library. For incremental compilation tests (the ones that look like foo.0.zig, foo.1.zig, foo.2.zig, etc.), a special version of the compiler is compiled into a utility executable called "check-case" which checks exactly one sequence of incremental updates in an independent subprocess. Previously, all incremental and non-incremental test cases were done in the same test runner process. The compile error checking code is now simpler, but also a bit rudimentary, and so it additionally makes sure that the actual compile errors do not include *extra* messages, and it makes sure that the actual compile errors output in the same order as expected. It is also based on the "ends-with" property of each line rather than the previous logic, which frankly I didn't want to touch with a ten-meter pole. The compile error test cases have been updated to pass in light of these differences. Previously, 'error' mode with 0 compile errors was used to shoehorn in a different kind of test-case - one that only checks if a piece of code compiles without errors. Now there is a 'compile' mode of test-cases, and 'error' must be only used when there are greater than 0 errors. link test cases are updated to omit the target object format argument when calling checkObject since that is no longer needed. The test/stage2 directory is removed; the 2 files within are moved to be directly in the test/ directory.
2023-03-09 18:22:51 -07:00
const test_cases_step = b.step("test-cases", "Run the main compiler test cases");
delete all the translate-c tests the ziglang/translate-c package has its own test suite, so these are redundant
2025-07-17 23:18:06 -07:00
try tests.addCases(b, test_cases_step, .{
test: Respect various test skip options in test-cases
2025-07-03 17:21:05 +02:00
.test_filters = test_filters,
.test_target_filters = test_target_filters,
build: add -Dskip-compile-errors option Skips tests in test/cases/compile_errors.
2025-07-23 00:23:31 +02:00
.skip_compile_errors = skip_compile_errors,
test: Respect various test skip options in test-cases
2025-07-03 17:21:05 +02:00
.skip_non_native = skip_non_native,
.skip_freebsd = skip_freebsd,
.skip_netbsd = skip_netbsd,
.skip_windows = skip_windows,
build: change -Dskip-macos to -Dskip-darwin and make it cover all darwin OSs
2025-11-14 22:39:12 +01:00
.skip_darwin = skip_darwin,
test: Respect various test skip options in test-cases
2025-07-03 17:21:05 +02:00
.skip_linux = skip_linux,
.skip_llvm = skip_llvm,
.skip_libc = skip_libc,
test manifest key checking and other fixes This commit adds several fixes and improvements for the Zig compiler test harness. 1. -Dskip-translate-c option added for skipping the translate-c tests. 2. translate-c/run-translated-c tests in test/cases/* have been added to the steps test-translate-c and test-run-translated-c. Closes #18224. 3. Custom name added to the CheckFile step for the translate-c step to better communicate which test failed. 4. Test manifest key validation added to return an error if a manifest contains an invalid key.
2024-03-04 17:26:41 -08:00
}, .{
llvm: fix data layout calculation for experimental llvm targets Closes #16616
2023-07-31 09:43:29 -04:00
.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,
});
tests: avoid skipping native tests Make the test targets use options that match the actual options of CompileStep. This makes the code more straightforward, and ends up making fewer tests incorrectly skipped. For example, now the CI runner on Windows will no longer skip self-hosted x86_64 backend tests.
2023-04-13 16:44:45 -07:00
test_step.dependOn(test_cases_step);
zig build: many enhancements related to parallel building Rework std.Build.Step to have an `owner: *Build` field. This simplified the implementation of installation steps, as well as provided some much-needed common API for the new parallelized build system. --verbose is now defined very concretely: it prints to stderr just before spawning a child process. Child process execution is updated to conform to the new parallel-friendly make() function semantics. DRY up the failWithCacheError handling code. It now integrates properly with the step graph instead of incorrectly dumping to stderr and calling process exit. In the main CLI, fix `zig fmt` crash when there are no errors and stdin is used. Deleted steps: * EmulatableRunStep - this entire thing can be removed in favor of a flag added to std.Build.RunStep called `skip_foreign_checks`. * LogStep - this doesn't really fit with a multi-threaded build runner and is effectively superseded by the new build summary output. build runner: * add -fsummary and -fno-summary to override the default behavior, which is to print a summary if any of the build steps fail. * print the dep prefix when emitting error messages for steps. std.Build.FmtStep: * This step now supports exclude paths as well as a check flag. * The check flag decides between two modes, modify mode, and check mode. These can be used to update source files in place, or to fail the build, respectively. Zig's own build.zig: * The `test-fmt` step will do all the `zig fmt` checking that we expect to be done. Since the `test` step depends on this one, we can simply remove the explicit call to `zig fmt` in the CI. * The new `fmt` step will actually perform `zig fmt` and update source files in place. std.Build.RunStep: * expose max_stdio_size is a field (previously an unchangeable hard-coded value). * rework the API. Instead of configuring each stream independently, there is a `stdio` field where you can choose between `infer_from_args`, `inherit`, or `check`. These determine whether the RunStep is considered to have side-effects or not. The previous field, `condition` is gone. * when stdio mode is set to `check` there is a slice of any number of checks to make, which include things like exit code, stderr matching, or stdout matching. * remove the ill-defined `print` field. * when adding an output arg, it takes the opportunity to give itself a better name. * The flag `skip_foreign_checks` is added. If this is true, a RunStep which is configured to check the output of the executed binary will not fail the build if the binary cannot be executed due to being for a foreign binary to the host system which is running the build graph. Command-line arguments such as -fqemu and -fwasmtime may affect whether a binary is detected as foreign, as well as system configuration such as Rosetta (macOS) and binfmt_misc (Linux). - This makes EmulatableRunStep no longer needed. * Fix the child process handling to properly integrate with the new bulid API and to avoid deadlocks in stdout/stderr streams by polling if necessary. std.Build.RemoveDirStep now uses the open build_root directory handle instead of an absolute path.
2023-03-01 22:56:37 -07:00
build/test: Add a test-modules step for running all the per-target tests. This is useful during porting work where you're mainly concerned with tests that e.g. run under QEMU. Combine with the new -Dtest-target-filter for an even more streamlined workflow.
2024-08-14 00:22:58 +02:00
const test_modules_step = b.step("test-modules", "Run the per-target module tests");
build.zig: make unit tests not use the full matrix
2025-01-09 21:49:32 -08:00
test_step.dependOn(test_modules_step);
build/test: Add a test-modules step for running all the per-target tests. This is useful during porting work where you're mainly concerned with tests that e.g. run under QEMU. Combine with the new -Dtest-target-filter for an even more streamlined workflow.
2024-08-14 00:22:58 +02:00
test_modules_step.dependOn(tests.addModuleTests(b, .{
test: rework how filtering works * make test names contain the fully qualified name * make test filters match the fully qualified name * allow multiple test filters, where a test is skipped if it does not match any of the specified filters
2024-02-25 14:04:06 +01:00
.test_filters = test_filters,
build/test: Add -Dtest-target-filter for filtering module tests by target triple. This is useful during porting work where you're not interested in running all targets all the time while iterating on changes.
2024-08-13 23:59:50 +02:00
.test_target_filters = test_target_filters,
build: Rename -Dtest-slow-targets to -Dtest-extra-targets. This can be used more broadly for targets that aren't quite ready to be tested by default yet.
2025-03-21 23:00:14 +01:00
.test_extra_targets = test_extra_targets,
build.zig: annotate std lib tests maxrss
2023-03-06 00:27:46 -07:00
.root_src = "test/behavior.zig",
.name = "behavior",
.desc = "Run the behavior tests",
.optimize_modes = optimization_modes,
c_import: extract behavior tests that use `@cImport` This introduces the new test step `test-c-import`, and removes the ability of the behavior tests to `@cImport` paths relative to `test`. This allows the behavior tests to be run without translate c.
2024-02-20 10:15:10 +01:00
.include_paths = &.{},
build.zig: annotate std lib tests maxrss
2023-03-06 00:27:46 -07:00
.skip_single_threaded = skip_single_threaded,
.skip_non_native = skip_non_native,
build.zig: rename -Dtest-default-only to -Dno-matrix because it's more memorable
2025-10-09 09:59:55 -07:00
.test_default_only = no_matrix,
restore debug llvm CI coverage and reduce redundant coverage in slow runs to save time
2025-06-06 12:50:14 -07:00
.skip_freebsd = skip_freebsd,
.skip_netbsd = skip_netbsd,
.skip_windows = skip_windows,
build: change -Dskip-macos to -Dskip-darwin and make it cover all darwin OSs
2025-11-14 22:39:12 +01:00
.skip_darwin = skip_darwin,
restore debug llvm CI coverage and reduce redundant coverage in slow runs to save time
2025-06-06 12:50:14 -07:00
.skip_linux = skip_linux,
CI: skip llvm backend tests in the script for testing x86 backend
2025-06-06 23:34:52 -07:00
.skip_llvm = skip_llvm,
build.zig: annotate std lib tests maxrss
2023-03-06 00:27:46 -07:00
.skip_libc = skip_libc,
build.zig: bump maxrss for behavior tests
2025-07-07 11:36:03 -07:00
// 3888779264 was observed on an x86_64-linux-gnu host.
.max_rss = 4000000000,
build.zig: annotate std lib tests maxrss
2023-03-06 00:27:46 -07:00
}));
build/test: Add a test-modules step for running all the per-target tests. This is useful during porting work where you're mainly concerned with tests that e.g. run under QEMU. Combine with the new -Dtest-target-filter for an even more streamlined workflow.
2024-08-14 00:22:58 +02:00
test_modules_step.dependOn(tests.addModuleTests(b, .{
test: rework how filtering works * make test names contain the fully qualified name * make test filters match the fully qualified name * allow multiple test filters, where a test is skipped if it does not match any of the specified filters
2024-02-25 14:04:06 +01:00
.test_filters = test_filters,
build/test: Add -Dtest-target-filter for filtering module tests by target triple. This is useful during porting work where you're not interested in running all targets all the time while iterating on changes.
2024-08-13 23:59:50 +02:00
.test_target_filters = test_target_filters,
build: Rename -Dtest-slow-targets to -Dtest-extra-targets. This can be used more broadly for targets that aren't quite ready to be tested by default yet.
2025-03-21 23:00:14 +01:00
.test_extra_targets = test_extra_targets,
build.zig: annotate std lib tests maxrss
2023-03-06 00:27:46 -07:00
.root_src = "lib/compiler_rt.zig",
.name = "compiler-rt",
.desc = "Run the compiler_rt tests",
.optimize_modes = optimization_modes,
c_import: extract behavior tests that use `@cImport` This introduces the new test step `test-c-import`, and removes the ability of the behavior tests to `@cImport` paths relative to `test`. This allows the behavior tests to be run without translate c.
2024-02-20 10:15:10 +01:00
.include_paths = &.{},
build.zig: annotate std lib tests maxrss
2023-03-06 00:27:46 -07:00
.skip_single_threaded = true,
.skip_non_native = skip_non_native,
build.zig: rename -Dtest-default-only to -Dno-matrix because it's more memorable
2025-10-09 09:59:55 -07:00
.test_default_only = no_matrix,
restore debug llvm CI coverage and reduce redundant coverage in slow runs to save time
2025-06-06 12:50:14 -07:00
.skip_freebsd = skip_freebsd,
.skip_netbsd = skip_netbsd,
.skip_windows = skip_windows,
build: change -Dskip-macos to -Dskip-darwin and make it cover all darwin OSs
2025-11-14 22:39:12 +01:00
.skip_darwin = skip_darwin,
restore debug llvm CI coverage and reduce redundant coverage in slow runs to save time
2025-06-06 12:50:14 -07:00
.skip_linux = skip_linux,
CI: skip llvm backend tests in the script for testing x86 backend
2025-06-06 23:34:52 -07:00
.skip_llvm = skip_llvm,
build.zig: annotate std lib tests maxrss
2023-03-06 00:27:46 -07:00
.skip_libc = true,
pass `-fno-builtin` when testing `lib/c.zig`, `lib/compiler_rt.zig`
2024-06-02 10:10:35 +03:00
.no_builtin = true,
build.zig: annotate std lib tests maxrss
2023-03-06 00:27:46 -07:00
}));
build/test: Add a test-modules step for running all the per-target tests. This is useful during porting work where you're mainly concerned with tests that e.g. run under QEMU. Combine with the new -Dtest-target-filter for an even more streamlined workflow.
2024-08-14 00:22:58 +02:00
test_modules_step.dependOn(tests.addModuleTests(b, .{
test: rework how filtering works * make test names contain the fully qualified name * make test filters match the fully qualified name * allow multiple test filters, where a test is skipped if it does not match any of the specified filters
2024-02-25 14:04:06 +01:00
.test_filters = test_filters,
build/test: Add -Dtest-target-filter for filtering module tests by target triple. This is useful during porting work where you're not interested in running all targets all the time while iterating on changes.
2024-08-13 23:59:50 +02:00
.test_target_filters = test_target_filters,
build: Rename -Dtest-slow-targets to -Dtest-extra-targets. This can be used more broadly for targets that aren't quite ready to be tested by default yet.
2025-03-21 23:00:14 +01:00
.test_extra_targets = test_extra_targets,
build.zig: annotate std lib tests maxrss
2023-03-06 00:27:46 -07:00
.root_src = "lib/c.zig",
Introduce libzigc for libc function implementations in Zig. This lays the groundwork for #2879. This library will be built and linked when a static libc is going to be linked into the compilation. Currently, that means musl, wasi-libc, and MinGW-w64. As a demonstration, this commit removes the musl C code for a few string functions and implements them in libzigc. This means that those libzigc functions are now load-bearing for musl and wasi-libc. Note that if a function has an implementation in compiler-rt already, libzigc should not implement it. Instead, as we recently did for memcpy/memmove, we should delete the libc copy and rely on the compiler-rt implementation. I repurposed the existing "universal libc" code to do this. That code hadn't seen development beyond basic string functions in years, and was only usable-ish on freestanding. I think that if we want to seriously pursue the idea of Zig providing a freestanding libc, we should do so only after defining clear goals (and non-goals) for it. See also #22240 for a similar case.
2025-04-10 19:17:29 +02:00
.name = "zigc",
.desc = "Run the zigc tests",
build.zig: annotate std lib tests maxrss
2023-03-06 00:27:46 -07:00
.optimize_modes = optimization_modes,
c_import: extract behavior tests that use `@cImport` This introduces the new test step `test-c-import`, and removes the ability of the behavior tests to `@cImport` paths relative to `test`. This allows the behavior tests to be run without translate c.
2024-02-20 10:15:10 +01:00
.include_paths = &.{},
build.zig: annotate std lib tests maxrss
2023-03-06 00:27:46 -07:00
.skip_single_threaded = true,
.skip_non_native = skip_non_native,
build.zig: rename -Dtest-default-only to -Dno-matrix because it's more memorable
2025-10-09 09:59:55 -07:00
.test_default_only = no_matrix,
restore debug llvm CI coverage and reduce redundant coverage in slow runs to save time
2025-06-06 12:50:14 -07:00
.skip_freebsd = skip_freebsd,
.skip_netbsd = skip_netbsd,
.skip_windows = skip_windows,
build: change -Dskip-macos to -Dskip-darwin and make it cover all darwin OSs
2025-11-14 22:39:12 +01:00
.skip_darwin = skip_darwin,
restore debug llvm CI coverage and reduce redundant coverage in slow runs to save time
2025-06-06 12:50:14 -07:00
.skip_linux = skip_linux,
CI: skip llvm backend tests in the script for testing x86 backend
2025-06-06 23:34:52 -07:00
.skip_llvm = skip_llvm,
build.zig: annotate std lib tests maxrss
2023-03-06 00:27:46 -07:00
.skip_libc = true,
pass `-fno-builtin` when testing `lib/c.zig`, `lib/compiler_rt.zig`
2024-06-02 10:10:35 +03:00
.no_builtin = true,
build.zig: annotate std lib tests maxrss
2023-03-06 00:27:46 -07:00
}));
Azure CI: Test std.* and the rest separately On CI, we have been running into OOM issues when running the test suite on Windows for quite some time. Unfortunately, we are very close to having the same issues on Linux as well. Some additional comptime work immediately makes these builds fail as well. Add a new `test-toolchain` step, that tests everything except `std.*` and documentation. On CI, call `test-toolchain`, `test-std` and `docs` separately instead of the `test` big hammer that emcompasses all of them. Change the special case we made for Windows to the same code as other platforms. This is a stopgap measure that stage2 will eventually make useless. Until then, it gives us some headroom. Change `linux_script` by the way to only output the log of failing steps. This shrinks the Linux CI log from a bazilion lines down to something more humanely manageable.
2021-04-30 23:41:28 +02:00
build/test: Add a test-modules step for running all the per-target tests. This is useful during porting work where you're mainly concerned with tests that e.g. run under QEMU. Combine with the new -Dtest-target-filter for an even more streamlined workflow.
2024-08-14 00:22:58 +02:00
test_modules_step.dependOn(tests.addModuleTests(b, .{
test: rework how filtering works * make test names contain the fully qualified name * make test filters match the fully qualified name * allow multiple test filters, where a test is skipped if it does not match any of the specified filters
2024-02-25 14:04:06 +01:00
.test_filters = test_filters,
build/test: Add -Dtest-target-filter for filtering module tests by target triple. This is useful during porting work where you're not interested in running all targets all the time while iterating on changes.
2024-08-13 23:59:50 +02:00
.test_target_filters = test_target_filters,
build: Rename -Dtest-slow-targets to -Dtest-extra-targets. This can be used more broadly for targets that aren't quite ready to be tested by default yet.
2025-03-21 23:00:14 +01:00
.test_extra_targets = test_extra_targets,
build.zig: annotate std lib tests maxrss
2023-03-06 00:27:46 -07:00
.root_src = "lib/std/std.zig",
.name = "std",
.desc = "Run the standard library tests",
.optimize_modes = optimization_modes,
c_import: extract behavior tests that use `@cImport` This introduces the new test step `test-c-import`, and removes the ability of the behavior tests to `@cImport` paths relative to `test`. This allows the behavior tests to be run without translate c.
2024-02-20 10:15:10 +01:00
.include_paths = &.{},
build.zig: annotate std lib tests maxrss
2023-03-06 00:27:46 -07:00
.skip_single_threaded = skip_single_threaded,
.skip_non_native = skip_non_native,
build.zig: rename -Dtest-default-only to -Dno-matrix because it's more memorable
2025-10-09 09:59:55 -07:00
.test_default_only = no_matrix,
restore debug llvm CI coverage and reduce redundant coverage in slow runs to save time
2025-06-06 12:50:14 -07:00
.skip_freebsd = skip_freebsd,
.skip_netbsd = skip_netbsd,
.skip_windows = skip_windows,
build: change -Dskip-macos to -Dskip-darwin and make it cover all darwin OSs
2025-11-14 22:39:12 +01:00
.skip_darwin = skip_darwin,
restore debug llvm CI coverage and reduce redundant coverage in slow runs to save time
2025-06-06 12:50:14 -07:00
.skip_linux = skip_linux,
CI: skip llvm backend tests in the script for testing x86 backend
2025-06-06 23:34:52 -07:00
.skip_llvm = skip_llvm,
build.zig: annotate std lib tests maxrss
2023-03-06 00:27:46 -07:00
.skip_libc = skip_libc,
build: increase test-std max rss
2025-03-27 05:36:27 +01:00
// I observed a value of 5605064704 on the M2 CI.
.max_rss = 6165571174,
build.zig: annotate std lib tests maxrss
2023-03-06 00:27:46 -07:00
}));
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
build.zig: make unit tests not use the full matrix
2025-01-09 21:49:32 -08:00
const unit_tests_step = b.step("test-unit", "Run the compiler source unit tests");
test_step.dependOn(unit_tests_step);
Add compiler internals tests There are several test decls inside `/src` that are not currently being tested and have bitrotted as a result. This commit revives those tests and adds the `test-compiler-internals` set of tests which tests everything reachable from `/src/main.zig`.
2024-11-06 22:30:46 +01:00
build.zig: make unit tests not use the full matrix
2025-01-09 21:49:32 -08:00
const unit_tests = b.addTest(.{
build.zig: use correct module graph for compiler unit tests
2025-05-10 11:34:19 +01:00
.root_module = addCompilerMod(b, .{
build.zig: make unit tests not use the full matrix
2025-01-09 21:49:32 -08:00
.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"),
});
build.zig: use correct module graph for compiler unit tests
2025-05-10 11:34:19 +01:00
if (link_libc) {
unit_tests.root_module.link_libc = true;
}
build.zig: make unit tests not use the full matrix
2025-01-09 21:49:32 -08:00
unit_tests.root_module.addOptions("build_options", exe_options);
unit_tests_step.dependOn(&b.addRunArtifact(unit_tests).step);
build/test: Add a test-modules step for running all the per-target tests. This is useful during porting work where you're mainly concerned with tests that e.g. run under QEMU. Combine with the new -Dtest-target-filter for an even more streamlined workflow.
2024-08-14 00:22:58 +02:00
test_step.dependOn(tests.addStandaloneTests(
b,
optimization_modes,
enable_macos_sdk,
enable_ios_sdk,
enable_symlinks_windows,
));
test: Enable -Dtest-target-filter=... to work for test-c-abi.
2024-11-23 15:45:15 +01:00
test_step.dependOn(tests.addCAbiTests(b, .{
.test_target_filters = test_target_filters,
.skip_non_native = skip_non_native,
restore debug llvm CI coverage and reduce redundant coverage in slow runs to save time
2025-06-06 12:50:14 -07:00
.skip_freebsd = skip_freebsd,
.skip_netbsd = skip_netbsd,
.skip_windows = skip_windows,
build: change -Dskip-macos to -Dskip-darwin and make it cover all darwin OSs
2025-11-14 22:39:12 +01:00
.skip_darwin = skip_darwin,
restore debug llvm CI coverage and reduce redundant coverage in slow runs to save time
2025-06-06 12:50:14 -07:00
.skip_linux = skip_linux,
CI: skip llvm backend tests in the script for testing x86 backend
2025-06-06 23:34:52 -07:00
.skip_llvm = skip_llvm,
test: Enable -Dtest-target-filter=... to work for test-c-abi.
2024-11-23 15:45:15 +01:00
.skip_release = skip_release,
}));
build/test: Add a test-modules step for running all the per-target tests. This is useful during porting work where you're mainly concerned with tests that e.g. run under QEMU. Combine with the new -Dtest-target-filter for an even more streamlined workflow.
2024-08-14 00:22:58 +02:00
test_step.dependOn(tests.addLinkTests(b, enable_macos_sdk, enable_ios_sdk, enable_symlinks_windows));
tests: split up and enhance stack trace tests Previously, the `test-stack-traces` step was essentially just testing error traces, and even there we didn't have much coverage. This commit solves that by splitting the "stack trace" tests into two separate harnesses: the "stack trace" tests are for actual stack traces (i.e. involving stack unwinding), while the "error trace" tests are specifically for error return traces. The "stack trace" tests will test different configurations of: * `-lc` * `-fPIE` * `-fomit-frame-pointer` * `-fllvm` * unwind tables (currently disabled) * strip debug info (currently disabled) The main goal there is to test *stack unwinding* under different conditions. Meanwhile, the "error trace" tests will test different configurations of `-O` and `-fllvm`; the main goal here, aside from checking that error traces themselves do not miscompile, is to check whether debug info is still working even in optimized builds. Of course, aggressive optimizations *can* thwart debug info no matter what, so as before, there is a way to disable cases for specific targets / optimize modes. The program which converts stack traces into a more validatable format by removing things like addresses (previously `check-stack-trace.zig`, now `convert-stack-trace.zig`) has been rewritten and simplified. Also, thanks to various fixes in this branch, several workarounds have become unnecessary: for instance, we don't need to ignore the function name printed in stack traces in release modes, because `std.debug.Dwarf` now uses the correct DIE for inlined functions! Neither `test-stack-traces` nor `test-error-traces` does general foreign architecture testing, because it seems that (at least for now) external executors often aren't particularly good at handling stack tracing correctly (looking at you, Wine). Generally, they just test the native target (this matches the old behavior of `test-stack-traces`). However, there is one exception: when on an x86_64 or aarch64 host, we will also test the 32-bit version (x86 or arm) if the OS supports it, because such executables can be trivially tested without an external executor. Oh, also, I wrote a bunch of stack trace tests. Previously there was, erm, *one* test in `test-stack-traces` which wasn't for error traces. Now there are a good few!
2025-09-09 22:45:39 +01:00
test_step.dependOn(tests.addStackTraceTests(b, test_filters, skip_non_native));
test_step.dependOn(tests.addErrorTraceTests(b, test_filters, optimization_modes, skip_non_native));
build/test: Add a test-modules step for running all the per-target tests. This is useful during porting work where you're mainly concerned with tests that e.g. run under QEMU. Combine with the new -Dtest-target-filter for an even more streamlined workflow.
2024-08-14 00:22:58 +02:00
test_step.dependOn(tests.addCliTests(b));
Dwarf: rework self-hosted debug info from scratch This is in preparation for incremental and actually being able to debug executables built by the x86_64 backend.
2024-08-06 11:22:37 -04:00
if (tests.addDebuggerTests(b, .{
.test_filters = test_filters,
test: Enable -Dtest-target-filter=... to work for test-debugger.
2024-11-23 18:06:27 +01:00
.test_target_filters = test_target_filters,
Dwarf: rework self-hosted debug info from scratch This is in preparation for incremental and actually being able to debug executables built by the x86_64 backend.
2024-08-06 11:22:37 -04:00
.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);
test: Add test-llvm-ir step and harness for testing generated LLVM IR.
2024-11-28 16:17:02 +01:00
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);
build/test: Add a test-modules step for running all the per-target tests. This is useful during porting work where you're mainly concerned with tests that e.g. run under QEMU. Combine with the new -Dtest-target-filter for an even more streamlined workflow.
2024-08-14 00:22:58 +02:00
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
try addWasiUpdateStep(b, version);
re-enable test-cases and get them all passing Instead of using `zig test` to build a special version of the compiler that runs all the test-cases, the zig build system is now used as much as possible - all with the basic steps found in the standard library. For incremental compilation tests (the ones that look like foo.0.zig, foo.1.zig, foo.2.zig, etc.), a special version of the compiler is compiled into a utility executable called "check-case" which checks exactly one sequence of incremental updates in an independent subprocess. Previously, all incremental and non-incremental test cases were done in the same test runner process. The compile error checking code is now simpler, but also a bit rudimentary, and so it additionally makes sure that the actual compile errors do not include *extra* messages, and it makes sure that the actual compile errors output in the same order as expected. It is also based on the "ends-with" property of each line rather than the previous logic, which frankly I didn't want to touch with a ten-meter pole. The compile error test cases have been updated to pass in light of these differences. Previously, 'error' mode with 0 compile errors was used to shoehorn in a different kind of test-case - one that only checks if a piece of code compiles without errors. Now there is a 'compile' mode of test-cases, and 'error' must be only used when there are greater than 0 errors. link test cases are updated to omit the target object format argument when calling checkObject since that is no longer needed. The test/stage2 directory is removed; the 2 files within are moved to be directly in the test/ directory.
2023-03-09 18:22:51 -07:00
add tool for updating mingw crt files
2024-01-07 18:41:26 -07:00
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| {
build: Use the new b.addFail() for the update-mingw step. This is precisely the kind of use case it was added for.
2024-08-13 23:38:02 +02:00
const update_mingw_exe = b.addExecutable(.{
.name = "update_mingw",
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
.root_module = b.createModule(.{
.target = b.graph.host,
.root_source_file = b.path("tools/update_mingw.zig"),
}),
build: Use the new b.addFail() for the update-mingw step. This is precisely the kind of use case it was added for.
2024-08-13 23:38:02 +02:00
});
const update_mingw_run = b.addRunArtifact(update_mingw_exe);
update_mingw_run.addDirectoryArg(b.path("lib"));
add tool for updating mingw crt files
2024-01-07 18:41:26 -07:00
update_mingw_run.addDirectoryArg(.{ .cwd_relative = mingw_src_path });
build: Use the new b.addFail() for the update-mingw step. This is precisely the kind of use case it was added for.
2024-08-13 23:38:02 +02:00
update_mingw_step.dependOn(&update_mingw_run.step);
add tool for updating mingw crt files
2024-01-07 18:41:26 -07:00
} else {
build: Use the new b.addFail() for the update-mingw step. This is precisely the kind of use case it was added for.
2024-08-13 23:38:02 +02:00
update_mingw_step.dependOn(&b.addFail("The -Dmingw-src=... option is required for this step").step);
add tool for updating mingw crt files
2024-01-07 18:41:26 -07:00
}
tests: add `test-incremental` step This is contained in the `test` step, so is tested by CI. This commit also includes some enhancements to the `incr-check` tool to make this work correctly.
2024-08-20 18:09:23 +01:00
const test_incremental_step = b.step("test-incremental", "Run the incremental compilation test cases");
try tests.addIncrementalTests(b, test_incremental_step);
CI: skip test-incremental on Windows Tracked by #22510
2025-11-22 08:06:26 -08:00
if (!skip_test_incremental) test_step.dependOn(test_incremental_step);
Integrate libc-test cases into the build system zig build test-libc -Dlibc-test-path=/path/to/libc-test
2025-08-26 21:47:59 +02:00
if (tests.addLibcTests(b, .{
.optimize_modes = optimization_modes,
.test_filters = test_filters,
.test_target_filters = test_target_filters,
build: bump libc-test max_rss from 1758181785 to 2253598720
2025-10-30 17:52:05 +01:00
// Highest RSS observed in any test case was exactly 1802878976 on x86_64-linux.
.max_rss = 2253598720,
Integrate libc-test cases into the build system zig build test-libc -Dlibc-test-path=/path/to/libc-test
2025-08-26 21:47:59 +02:00
})) |test_libc_step| test_step.dependOn(test_libc_step);
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
}
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
fn addWasiUpdateStep(b: *std.Build, version: [:0]const u8) !void {
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
const semver = try std.SemanticVersion.parse(version);
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
const exe = addCompilerStep(b, .{
.optimize = .ReleaseSmall,
std.Target: Define and use lime1 as the baseline CPU model for WebAssembly. See: https://github.com/WebAssembly/tool-conventions/pull/235 This is not *quite* using the same features as the spec'd lime1 model because LLVM 19 doesn't have the level of feature granularity that we need for that. This will be fixed once we upgrade to LLVM 20. Part of #21818.
2024-11-29 01:31:49 +01:00
.target = b.resolveTargetQuery(std.Target.Query.parse(.{
.arch_os_abi = "wasm32-wasi",
wasm: Add a nontrapping_bulk_memory_len0 feature. This will mainly be used when targeting our wasm2c implementation which has no problem with zero-length bulk memory operations, as a non-standard extension.
2025-01-22 02:56:53 +01:00
// * `extended_const` is not supported by the `wasm-opt` version in CI.
// * `nontrapping_bulk_memory_len0` is supported by `wasm2c`.
wasm2c: Implement nontrapping_fptoint support.
2025-01-22 03:44:24 +01:00
.cpu_features = "baseline-extended_const+nontrapping_bulk_memory_len0",
std.Target: Define and use lime1 as the baseline CPU model for WebAssembly. See: https://github.com/WebAssembly/tool-conventions/pull/235 This is not *quite* using the same features as the spec'd lime1 model because LLVM 19 doesn't have the level of feature granularity that we need for that. This will be fixed once we upgrade to LLVM 20. Part of #21818.
2024-11-29 01:31:49 +01:00
}) catch unreachable),
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
});
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
const exe_options = b.addOptions();
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
exe.root_module.addOptions("build_options", exe_options);
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
exe_options.addOption(u32, "mem_leak_frames", 0);
exe_options.addOption(bool, "have_llvm", false);
compiler: use std.heap.smp_allocator In main, now this allocator is chosen by default when compiling without libc in ReleaseFast or ReleaseSmall, and not targeting WebAssembly.
2025-02-06 17:41:50 -08:00
exe_options.addOption(bool, "debug_gpa", false);
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
exe_options.addOption([:0]const u8, "version", version);
exe_options.addOption(std.SemanticVersion, "semver", semver);
compiler: audit debug mode checks * Introduce `-Ddebug-extensions` for enabling compiler debug helpers * Replace safety mode checks with `std.debug.runtime_safety` * Replace debugger helper checks with `!builtin.strip_debug_info` Sometimes, you just have to debug optimized compilers...
2024-03-01 16:46:48 +01:00
exe_options.addOption(bool, "enable_debug_extensions", false);
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
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);
Add build option to set tracy-callstack-depth in `build.zig` (#21990)
2024-11-29 13:13:06 -07:00
exe_options.addOption(u32, "tracy_callstack_depth", 0);
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
exe_options.addOption(bool, "value_tracing", false);
dev: introduce dev environments that enable compiler feature sets
2024-07-19 01:04:59 -04:00
exe_options.addOption(DevEnv, "dev", .bootstrap);
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
compiler: make it easier to apply breaking changes to `std.builtin` Documentation for this will be on the wiki shortly. Resolves: #21842
2025-01-16 10:09:41 +00:00
// 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);
update-zig1: add --enable-sign-ext to wasm-opt Otherwise it complains because sign extension is now part of baseline.
2023-03-17 00:52:35 -07:00
const run_opt = b.addSystemCommand(&.{
"wasm-opt",
"-Oz",
"--enable-bulk-memory",
std.Target: Define and use lime1 as the baseline CPU model for WebAssembly. See: https://github.com/WebAssembly/tool-conventions/pull/235 This is not *quite* using the same features as the spec'd lime1 model because LLVM 19 doesn't have the level of feature granularity that we need for that. This will be fixed once we upgrade to LLVM 20. Part of #21818.
2024-11-29 01:31:49 +01:00
"--enable-mutable-globals",
wasm2c: Implement nontrapping_fptoint support.
2025-01-22 03:44:24 +01:00
"--enable-nontrapping-float-to-int",
update-zig1: add --enable-sign-ext to wasm-opt Otherwise it complains because sign extension is now part of baseline.
2023-03-17 00:52:35 -07:00
"--enable-sign-ext",
});
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
run_opt.addArtifactArg(exe);
run_opt.addArg("-o");
build.zig: use `Step.UpdateSourceFiles` for `zig1.wasm` We were already using this for `stage1/zig.h`, but `stage1/zig1.wasm` was being modified directly by the `wasm-opt` command. That's a bad idea because it forces the build system to assume that `wasm-opt` has side effects, so it is re-run every time you run `zig build update-zig1`, i.e. it does not interact with the cache system correctly. It is much better to create non-side-effecting `Run` steps (using `addOutput*Arg`) where possible so that the build system has a more correct understanding of the step graph.
2025-11-15 09:45:22 +00:00
const optimized_wasm = run_opt.addOutputFileArg("zig1.wasm");
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
build.zig: use `Step.UpdateSourceFiles` for `zig1.wasm` We were already using this for `stage1/zig.h`, but `stage1/zig1.wasm` was being modified directly by the `wasm-opt` command. That's a bad idea because it forces the build system to assume that `wasm-opt` has side effects, so it is re-run every time you run `zig build update-zig1`, i.e. it does not interact with the cache system correctly. It is much better to create non-side-effecting `Run` steps (using `addOutput*Arg`) where possible so that the build system has a more correct understanding of the step graph.
2025-11-15 09:45:22 +00:00
const update_zig1 = b.addUpdateSourceFiles();
update_zig1.addCopyFileToSource(optimized_wasm, "stage1/zig1.wasm");
update_zig1.addCopyFileToSource(b.path("lib/zig.h"), "stage1/zig.h");
CBE: use stdint.h types instead of `zig_` prefixes This requires manual defines before C99 which may not have stdint.h. Also have update-zig1 leave a copy of lib/zig.h in stage1/zig.h, which allows lib/zig.h to be updated without needing to update zig1.wasm. Note that since the object already existed with the exact same contents, this completely avoids repo bloat due to zig.h changes.
2023-02-20 20:52:26 -05:00
remove the zstd mechanism from the build process
2022-12-09 16:33:32 -07:00
const update_zig1_step = b.step("update-zig1", "Update stage1/zig1.wasm");
build.zig: use `Step.UpdateSourceFiles` for `zig1.wasm` We were already using this for `stage1/zig.h`, but `stage1/zig1.wasm` was being modified directly by the `wasm-opt` command. That's a bad idea because it forces the build system to assume that `wasm-opt` has side effects, so it is re-run every time you run `zig build update-zig1`, i.e. it does not interact with the cache system correctly. It is much better to create non-side-effecting `Run` steps (using `addOutput*Arg`) where possible so that the build system has a more correct understanding of the step graph.
2025-11-15 09:45:22 +00:00
update_zig1_step.dependOn(&update_zig1.step);
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
}
build.zig: use correct module graph for compiler unit tests
2025-05-10 11:34:19 +01:00
const AddCompilerModOptions = struct {
update build.zig API usage
2023-01-30 21:39:43 -07:00
optimize: std.builtin.OptimizeMode,
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
target: std.Build.ResolvedTarget,
strip: ?bool = null,
build.zig: expose valgrind flag Allows to enable Valgrind integrations in release builds, sometimes useful in combination with tooling.
2024-07-16 17:26:41 -07:00
valgrind: ?bool = null,
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
sanitize_thread: ?bool = null,
single_threaded: ?bool = null,
};
build.zig: use correct module graph for compiler unit tests
2025-05-10 11:34:19 +01:00
fn addCompilerMod(b: *std.Build, options: AddCompilerModOptions) *std.Build.Module {
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
const compiler_mod = b.createModule(.{
remove deprecated LazyPath.path union tag
2024-04-11 14:02:47 -07:00
.root_source_file = b.path("src/main.zig"),
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
.target = options.target,
.optimize = options.optimize,
.strip = options.strip,
.sanitize_thread = options.sanitize_thread,
.single_threaded = options.single_threaded,
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
.valgrind = options.valgrind,
update build.zig API usage
2023-01-30 21:39:43 -07:00
});
aro-translate-c: update to upstream changes
2023-11-15 11:30:26 +02:00
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
const aro_mod = b.createModule(.{
remove deprecated LazyPath.path union tag
2024-04-11 14:02:47 -07:00
.root_source_file = b.path("lib/compiler/aro/aro.zig"),
make aro-based translate-c lazily built from source Part of #19063. Primarily, this moves Aro from deps/ to lib/compiler/ so that it can be lazily compiled from source. src/aro_translate_c.zig is moved to lib/compiler/aro_translate_c.zig and some of Zig CLI logic moved to a main() function there. aro_translate_c.zig becomes the "common" import for clang-based translate-c. Not all of the compiler was able to be detangled from Aro, however, so it still, for now, remains being compiled with the main compiler sources due to the clang-based translate-c depending on it. Once aro-based translate-c achieves feature parity with the clang-based translate-c implementation, the clang-based one can be removed from Zig. Aro made it unnecessarily difficult to depend on with these .def files and all these Zig module requirements. I looked at the .def files and made these observations: - The canonical source is llvm .def files. - Therefore there is an update process to sync with llvm that involves regenerating the .def files in Aro. - Therefore you might as well just regenerate the .zig files directly and check those into Aro. - Also with a small amount of tinkering, the file size on disk of these generated .zig files can be made many times smaller, without compromising type safety in the usage of the data. This would make things much easier on Zig as downstream project, particularly we could remove those pesky stubs when bootstrapping. I have gone ahead with these changes since they unblock me and I will have a chat with Vexu to see what he thinks.
2024-02-27 22:06:11 -07:00
});
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
compiler_mod.addImport("aro", aro_mod);
build.zig: use correct module graph for compiler unit tests
2025-05-10 11:34:19 +01:00
return compiler_mod;
}
fn addCompilerStep(b: *std.Build, options: AddCompilerModOptions) *std.Build.Step.Compile {
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
const exe = b.addExecutable(.{
.name = "zig",
.max_rss = 7_800_000_000,
build.zig: use correct module graph for compiler unit tests
2025-05-10 11:34:19 +01:00
.root_module = addCompilerMod(b, options),
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
});
exe.stack_size = stack_size;
build: remove -Dwasi-bootstrap; add update-zig1 step Now it is a single command tdo update zig1.wasm.zst.
2022-12-01 16:34:15 -07:00
return exe;
convert compare-output tests to use zig build system
2017-04-19 01:13:15 -04:00
}
self-hosted: link with LLVM
2017-12-11 23:34:59 -05:00
stage2: enable building test-stage2 with LLVM backend enabled We can now run `zig build test-stage2 -Denable-llvm`.
2021-01-03 16:48:52 +01:00
const exe_cflags = [_][]const u8{
build.zig: llvm c++ files require -std=c++17
2023-01-29 12:57:24 -07:00
"-std=c++17",
stage2: enable building test-stage2 with LLVM backend enabled We can now run `zig build test-stage2 -Denable-llvm`.
2021-01-03 16:48:52 +01:00
"-D__STDC_CONSTANT_MACROS",
"-D__STDC_FORMAT_MACROS",
"-D__STDC_LIMIT_MACROS",
"-D_GNU_SOURCE",
"-fno-exceptions",
"-fno-rtti",
build.zig: sync "exe_cflags" with CMake Signed-off-by: Eric Joldasov <bratishkaerik@landless-city.net>
2024-05-14 19:48:19 +05:00
"-fno-stack-protector",
"-fvisibility-inlines-hidden",
suppress C++ type-limits warnings Zig has no more C++ code; these warnings are being tripped by the Clang code copy-pasted into Zig. No sense in detecting them.
2024-04-28 21:20:57 -07:00
"-Wno-type-limits",
stage2: enable building test-stage2 with LLVM backend enabled We can now run `zig build test-stage2 -Denable-llvm`.
2021-01-03 16:48:52 +01:00
"-Wno-missing-braces",
"-Wno-comment",
build: Set LLVM_BUILD_STATIC/CLANG_BUILD_STATIC when linking statically. This is needed since LLVM 20, particularly for Windows.
2025-04-08 23:11:32 +02:00
// `exe_cflags` is only used for static linking.
"-DLLVM_BUILD_STATIC",
"-DCLANG_BUILD_STATIC",
stage2: enable building test-stage2 with LLVM backend enabled We can now run `zig build test-stage2 -Denable-llvm`.
2021-01-03 16:48:52 +01:00
};
fn addCmakeCfgOptionsToExe(
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
b: *std.Build,
stage2: enable building test-stage2 with LLVM backend enabled We can now run `zig build test-stage2 -Denable-llvm`.
2021-01-03 16:48:52 +01:00
cfg: CMakeConfig,
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
exe: *std.Build.Step.Compile,
build.zig: support -Duse-zig-libcxx This supports the case when it is known that LLVM, Clang, LLD were built with Clang (or `zig c++`). This commit updates the Linux CI script to pass this since we build using a zig tarball.
2021-09-16 13:09:32 -07:00
use_zig_libcxx: bool,
stage2: enable building test-stage2 with LLVM backend enabled We can now run `zig build test-stage2 -Denable-llvm`.
2021-01-03 16:48:52 +01:00
) !void {
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
const mod = exe.root_module;
Target: pass and use locals by pointer instead of by value This struct is larger than 256 bytes and code that copies it consistently shows up in profiles of the compiler.
2025-06-13 04:46:30 -04:00
const target = &mod.resolved_target.?.result;
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
std.Target: Remove functions that just wrap component functions. Functions like isMinGW() and isGnuLibC() have a good reason to exist: They look at multiple components of the target. But functions like isWasm(), isDarwin(), isGnu(), etc only exist to save 4-8 characters. I don't think this is a good enough reason to keep them, especially given that: * It's not immediately obvious to a reader whether target.isDarwin() means the same thing as target.os.tag.isDarwin() precisely because isMinGW() and similar functions *do* look at multiple components. * It's not clear where we would draw the line. The logical conclusion before this commit would be to also wrap Arch.isX86(), Os.Tag.isSolarish(), Abi.isOpenHarmony(), etc... this obviously quickly gets out of hand. * It's nice to just have a single correct way of doing something.
2025-01-24 03:45:38 +01:00
if (target.os.tag.isDarwin()) {
stage3 macos: enable -headerpad_max_install_names This pads the install names area in final (stage3) zig executable on macos. The executable size grows by 4096 bytes, or roughly 0.002% . closes #13388
2023-01-01 22:43:09 -05:00
// useful for package maintainers
exe.headerpad_max_install_names = true;
}
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
mod.addObjectFile(.{ .cwd_relative = b.pathJoin(&.{
stage2: enable building test-stage2 with LLVM backend enabled We can now run `zig build test-stage2 -Denable-llvm`.
2021-01-03 16:48:52 +01:00
cfg.cmake_binary_dir,
"zigcpp",
build: obtain zigcpp library prefix/suffix from cmake
2022-12-07 01:44:15 -07:00
b.fmt("{s}{s}{s}", .{
cfg.cmake_static_library_prefix,
"zigcpp",
cfg.cmake_static_library_suffix,
}),
Build.zig rename orgy (aka: #16353). Renames FileSource to LazyPath and removes functions that take literal paths instead of LazyPath.
2023-07-19 10:49:34 +02:00
}) });
stage2: enable building test-stage2 with LLVM backend enabled We can now run `zig build test-stage2 -Denable-llvm`.
2021-01-03 16:48:52 +01:00
assert(cfg.lld_include_dir.len != 0);
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
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);
stage2: enable building test-stage2 with LLVM backend enabled We can now run `zig build test-stage2 -Denable-llvm`.
2021-01-03 16:48:52 +01:00
build.zig: support -Duse-zig-libcxx This supports the case when it is known that LLVM, Clang, LLD were built with Clang (or `zig c++`). This commit updates the Linux CI script to pass this since we build using a zig tarball.
2021-09-16 13:09:32 -07:00
if (use_zig_libcxx) {
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
mod.link_libcpp = true;
build.zig: support -Duse-zig-libcxx This supports the case when it is known that LLVM, Clang, LLD were built with Clang (or `zig c++`). This commit updates the Linux CI script to pass this since we build using a zig tarball.
2021-09-16 13:09:32 -07:00
} else {
// System -lc++ must be used because in this code path we are attempting to link
// against system-provided LLVM, Clang, LLD.
stage3 bsd: support dynamic libstdc++/libc++ Currently llvm-linkage mode (static vs dynamic) decides linkage mode for system libstdc++/libc++ . A previous commit only tested static mode for *BSD and netbsd was reported to not work in dynamic mode. We now special-case freebsd, openbsd, netbsd and dragonfly for dynamic linking too.
2023-01-06 00:57:08 -05:00
const need_cpp_includes = true;
const static = cfg.llvm_linkage == .static;
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
const lib_suffix = if (static) target.staticLibSuffix()[1..] else target.dynamicLibSuffix()[1..];
switch (target.os.tag) {
build stage3: add more BSD support - add netbsd - add dragonfly - fixup freebsd
2023-01-02 19:18:33 -05:00
.linux => {
build stage3: detect system libcxx Detect system libcxx name with the CMake build system and convey that information to build.zig via config.h so that the same system libcxx is used for stage3. This undoes the hacky search 901457d173467c71b681a8c69f4b77c94d516da7 . closes #17018
2023-09-01 10:04:26 -04:00
// 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 => {
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
mod.link_libcpp = true;
build stage3: detect system libcxx Detect system libcxx name with the CMake build system and convey that information to build.zig via config.h so that the same system libcxx is used for stage3. This undoes the hacky search 901457d173467c71b681a8c69f4b77c94d516da7 . closes #17018
2023-09-01 10:04:26 -04:00
},
else => |e| return e,
};
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
mod.linkSystemLibrary("unwind", .{});
build stage3: add more BSD support - add netbsd - add dragonfly - fixup freebsd
2023-01-02 19:18:33 -05:00
},
handle visionos target OS tag in the compiler * rename .xros to .visionos as agreed in the tracking issue * add support for VisionOS platform in the MachO linker
2024-05-09 15:04:13 +02:00
.ios, .macos, .watchos, .tvos, .visionos => {
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
mod.link_libcpp = true;
build stage3: add more BSD support - add netbsd - add dragonfly - fixup freebsd
2023-01-02 19:18:33 -05:00
},
build: avoid zig's libc++ on *-windows-msvc
2023-01-15 13:10:19 -05:00
.windows => {
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
if (target.abi != .msvc) mod.link_libcpp = true;
build: avoid zig's libc++ on *-windows-msvc
2023-01-15 13:10:19 -05:00
},
build stage3: add more BSD support - add netbsd - add dragonfly - fixup freebsd
2023-01-02 19:18:33 -05:00
.freebsd => {
openbsd: fix stage3 link - llvm requires libexecinfo which has conflicting symbols with libc++abi - workaround is to link c++abi dynamically
2025-02-01 12:14:37 -05:00
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);
build stage3: add more BSD support - add netbsd - add dragonfly - fixup freebsd
2023-01-02 19:18:33 -05:00
},
.openbsd => {
openbsd: fix stage3 link - llvm requires libexecinfo which has conflicting symbols with libc++abi - workaround is to link c++abi dynamically
2025-02-01 12:14:37 -05:00
// - 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);
build stage3: add more BSD support - add netbsd - add dragonfly - fixup freebsd
2023-01-02 19:18:33 -05:00
},
stage3 bsd: support dynamic libstdc++/libc++ Currently llvm-linkage mode (static vs dynamic) decides linkage mode for system libstdc++/libc++ . A previous commit only tested static mode for *BSD and netbsd was reported to not work in dynamic mode. We now special-case freebsd, openbsd, netbsd and dragonfly for dynamic linking too.
2023-01-06 00:57:08 -05:00
.netbsd, .dragonfly => {
openbsd: fix stage3 link - llvm requires libexecinfo which has conflicting symbols with libc++abi - workaround is to link c++abi dynamically
2025-02-01 12:14:37 -05:00
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);
build stage3: add more BSD support - add netbsd - add dragonfly - fixup freebsd
2023-01-02 19:18:33 -05:00
},
remove all Oracle Solaris support There is no straightforward way for the Zig team to access the Solaris system headers; to do this, one has to create an Oracle account, accept their EULA to download the installer ISO, and finally install it on a machine or VM. We do not have to jump through hoops like this for any other OS that we support, and no one on the team has expressed willingness to do it. As a result, we cannot audit any Solaris contributions to std.c or other similarly sensitive parts of the standard library. The best we would be able to do is assume that Solaris and illumos are 100% compatible with no way to verify that assumption. But at that point, the solaris and illumos OS tags would be functionally identical anyway. For Solaris especially, any contributions that involve APIs introduced after the OS was made closed-source would also be inherently more risky than equivalent contributions for other proprietary OSs due to the case of Google LLC v. Oracle America, Inc., wherein Oracle clearly demonstrated its willingness to pursue legal action against entities that merely copy API declarations. Finally, Oracle laid off most of the Solaris team in 2017; the OS has been in maintenance mode since, presumably to be retired completely sometime in the 2030s. For these reasons, this commit removes all Oracle Solaris support. Anyone who still wishes to use Zig on Solaris can try their luck by simply using illumos instead of solaris in target triples - chances are it'll work. But there will be no effort from the Zig team to support this use case; we recommend that people move to illumos instead.
2025-10-26 05:45:38 +01:00
.illumos => {
Add illumos OS tag - Adds `illumos` to the `Target.Os.Tag` enum. A new function, `isSolarish` has been added that returns true if the tag is either Solaris or Illumos. This matches the naming convention found in Rust's `libc` crate[1]. - Add the tag wherever `.solaris` is being checked against. - Check for the C pre-processor macro `__illumos__` in CMake to set the proper target tuple. Illumos distros patch their compilers to have this in the "built-in" set (verified with `echo | cc -dM -E -`). Alternatively you could check the output of `uname -o`. Right now, both Solaris and Illumos import from `c/solaris.zig`. In the future it may be worth putting the shared ABI bits in a base file, and mixing that in with specific `c/solaris.zig`/`c/illumos.zig` files. [1]: https://github.com/rust-lang/libc/tree/6e02a329a2a27f6887ea86952f389ca11e06448c/src/unix/solarish
2023-10-01 23:09:14 +11:00
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);
solaris: link libstdc++
2023-09-26 15:59:24 -06:00
},
haiku: fix linking issues
2024-04-07 21:19:12 -04:00
.haiku => {
try addCxxKnownPath(b, cfg, exe, b.fmt("libstdc++.{s}", .{lib_suffix}), null, need_cpp_includes);
},
build stage3: add more BSD support - add netbsd - add dragonfly - fixup freebsd
2023-01-02 19:18:33 -05:00
else => {},
build.zig: support -Duse-zig-libcxx This supports the case when it is known that LLVM, Clang, LLD were built with Clang (or `zig c++`). This commit updates the Linux CI script to pass this since we build using a zig tarball.
2021-09-16 13:09:32 -07:00
}
stage2: enable building test-stage2 with LLVM backend enabled We can now run `zig build test-stage2 -Denable-llvm`.
2021-01-03 16:48:52 +01:00
}
if (cfg.dia_guids_lib.len != 0) {
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
mod.addObjectFile(.{ .cwd_relative = cfg.dia_guids_lib });
stage2: enable building test-stage2 with LLVM backend enabled We can now run `zig build test-stage2 -Denable-llvm`.
2021-01-03 16:48:52 +01:00
}
}
build.zig: Statically link LLVM libraries for experimental targets if requested.
2025-03-26 23:19:35 +01:00
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 {
stage2: enable building test-stage2 with LLVM backend enabled We can now run `zig build test-stage2 -Denable-llvm`.
2021-01-03 16:48:52 +01:00
// 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"};
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
mod.addCSourceFiles(.{
Step.Compile: add options struct for `addCSourceFiles` (#17420) Closes #17410
2023-10-10 20:29:26 +02:00
.files = &zig_cpp_sources,
.flags = &zig_cpp_cflags,
});
stage2: enable building test-stage2 with LLVM backend enabled We can now run `zig build test-stage2 -Denable-llvm`.
2021-01-03 16:48:52 +01:00
for (clang_libs) |lib_name| {
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
mod.linkSystemLibrary(lib_name, .{});
stage2: enable building test-stage2 with LLVM backend enabled We can now run `zig build test-stage2 -Denable-llvm`.
2021-01-03 16:48:52 +01:00
}
for (lld_libs) |lib_name| {
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
mod.linkSystemLibrary(lib_name, .{});
stage2: enable building test-stage2 with LLVM backend enabled We can now run `zig build test-stage2 -Denable-llvm`.
2021-01-03 16:48:52 +01:00
}
for (llvm_libs) |lib_name| {
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
mod.linkSystemLibrary(lib_name, .{});
stage2: enable building test-stage2 with LLVM backend enabled We can now run `zig build test-stage2 -Denable-llvm`.
2021-01-03 16:48:52 +01:00
}
build.zig: Statically link LLVM libraries for experimental targets if requested.
2025-03-26 23:19:35 +01:00
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, .{});
};
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
mod.linkSystemLibrary("z", .{});
mod.linkSystemLibrary("zstd", .{});
build: first pass on geting stage3 building under x64_64-windows-msvc
2022-11-08 02:14:39 -05:00
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
if (mod.resolved_target.?.result.os.tag != .windows or mod.resolved_target.?.result.abi != .msvc) {
build: first pass on geting stage3 building under x64_64-windows-msvc
2022-11-08 02:14:39 -05:00
// This means we rely on clang-or-zig-built LLVM, Clang, LLD libraries.
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
mod.linkSystemLibrary("c++", .{});
build: first pass on geting stage3 building under x64_64-windows-msvc
2022-11-08 02:14:39 -05:00
}
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
if (mod.resolved_target.?.result.os.tag == .windows) {
mod.linkSystemLibrary("version", .{});
mod.linkSystemLibrary("uuid", .{});
mod.linkSystemLibrary("ole32", .{});
build: first pass on geting stage3 building under x64_64-windows-msvc
2022-11-08 02:14:39 -05:00
}
stage2: enable building test-stage2 with LLVM backend enabled We can now run `zig build test-stage2 -Denable-llvm`.
2021-01-03 16:48:52 +01:00
}
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
fn addCxxKnownPath(
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
b: *std.Build,
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
ctx: CMakeConfig,
std.Build: use Step.* instead of *Step Follow up to 13eb7251d37759bd47403db304c6120c706fe353
2023-05-03 11:49:55 +03:00
exe: *std.Build.Step.Compile,
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
objname: []const u8,
errtxt: ?[]const u8,
need_cpp_includes: bool,
) !void {
Avoid depending on child process execution when not supported by host OS In accordance with the requesting issue (#10750): - `zig test` skips any tests that it cannot spawn, returning success - `zig run` and `zig build` exit with failure, reporting the command the cannot be run - `zig clang`, `zig ar`, etc. already punt directly to the appropriate clang/lld main(), even before this change - Native `libc` Detection is not supported Additionally, `exec()` and related Builder functions error at run-time, reporting the command that cannot be run
2022-02-03 15:27:01 -07:00
if (!std.process.can_spawn)
return error.RequiredLibraryNotFound;
build.zig: add support for using "zig c++" as the bootstrap c++ compiler The build was previously failing with `error: unknown command: -print-file-name=libstdc++.a` because the command invocation was `zig -print-file-name=libstdc++.a` instead of `zig c++ -print-file-name=libstdc++.a` note: .cxx_compiler_arg1 = "" instead of undefined to avoid breaking existing setups without requiring to run cmake again.
2023-10-16 22:49:27 +02:00
build.zig: support multiple args in `cxx_compiler_arg1` An example of this happening is during CI runs where it has a value such as `c++ -target x86_64-linux-musl -mcpu=baseline`.
2024-02-16 06:01:46 +01:00
const path_padded = run: {
std.ArrayList: make unmanaged the default
2025-07-31 21:54:07 -07:00
var args = std.array_list.Managed([]const u8).init(b.allocator);
build.zig: support multiple args in `cxx_compiler_arg1` An example of this happening is during CI runs where it has a value such as `c++ -target x86_64-linux-musl -mcpu=baseline`.
2024-02-16 06:01:46 +01:00
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);
};
Update all std.mem.tokenize calls to their appropriate function Everywhere that can now use `tokenizeScalar` should get a nice little performance boost.
2023-05-04 18:05:40 -07:00
var tokenizer = mem.tokenizeAny(u8, path_padded, "\r\n");
Value: hash lazy_align
2022-03-27 21:05:42 +03:00
const path_unpadded = tokenizer.next().?;
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
if (mem.eql(u8, path_unpadded, objname)) {
if (errtxt) |msg| {
std lib API deprecations for the upcoming 0.9.0 release See #3811
2021-11-30 00:13:07 -07:00
std.debug.print("{s}", .{msg});
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
} else {
std lib API deprecations for the upcoming 0.9.0 release See #3811
2021-11-30 00:13:07 -07:00
std.debug.print("Unable to determine path to {s}\n", .{objname});
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
}
return error.RequiredLibraryNotFound;
}
build.zig: fix libc++ being a linker script
2024-11-17 00:55:09 -05:00
// 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;
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
exe.root_module.addObjectFile(.{ .cwd_relative = path_unpadded });
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
// TODO a way to integrate with system c++ include files here
build: update Tracy integration * Update for v0.9 * Enable the memory and callstack integrations by default
2022-10-26 18:17:49 -07:00
// c++ -E -Wp,-v -xc++ /dev/null
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
if (need_cpp_includes) {
// I used these temporarily for testing something but we obviously need a
// more general purpose solution here.
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
//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");
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
}
}
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
fn addCMakeLibraryList(mod: *std.Build.Module, list: []const u8) void {
Update all std.mem.tokenize calls to their appropriate function Everywhere that can now use `tokenizeScalar` should get a nice little performance boost.
2023-05-04 18:05:40 -07:00
var it = mem.tokenizeScalar(u8, list, ';');
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
while (it.next()) |lib| {
if (mem.startsWith(u8, lib, "-l")) {
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
mod.linkSystemLibrary(lib["-l".len..], .{});
} else if (mod.resolved_target.?.result.os.tag == .windows and
zig build system: change target, compilation, and module APIs Introduce the concept of "target query" and "resolved target". A target query is what the user specifies, with some things left to default. A resolved target has the default things discovered and populated. In the future, std.zig.CrossTarget will be rename to std.Target.Query. Introduces `std.Build.resolveTargetQuery` to get from one to the other. The concept of `main_mod_path` is gone, no longer supported. You have to put the root source file at the module root now. * remove deprecated API * update build.zig for the breaking API changes in this branch * move std.Build.Step.Compile.BuildId to std.zig.BuildId * add more options to std.Build.ExecutableOptions, std.Build.ObjectOptions, std.Build.SharedLibraryOptions, std.Build.StaticLibraryOptions, and std.Build.TestOptions. * remove `std.Build.constructCMacro`. There is no use for this API. * deprecate `std.Build.Step.Compile.defineCMacro`. Instead, `std.Build.Module.addCMacro` is provided. - remove `std.Build.Step.Compile.defineCMacroRaw`. * deprecate `std.Build.Step.Compile.linkFrameworkNeeded` - use `std.Build.Module.linkFramework` * deprecate `std.Build.Step.Compile.linkFrameworkWeak` - use `std.Build.Module.linkFramework` * move more logic into `std.Build.Module` * allow `target` and `optimize` to be `null` when creating a Module. Along with other fields, those unspecified options will be inherited from parent `Module` when inserted into an import table. * the `target` field of `addExecutable` is now required. pass `b.host` to get the host target.
2023-12-02 21:51:34 -07:00
mem.endsWith(u8, lib, ".lib") and !fs.path.isAbsolute(lib))
{
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
mod.linkSystemLibrary(lib[0 .. lib.len - ".lib".len], .{});
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
} else {
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
mod.addObjectFile(.{ .cwd_relative = lib });
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
}
}
}
const CMakeConfig = struct {
std.builtin: make link mode fields lowercase
2024-02-18 20:34:32 -08:00
llvm_linkage: std.builtin.LinkMode,
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
cmake_binary_dir: []const u8,
cmake_prefix_path: []const u8,
build: obtain zigcpp library prefix/suffix from cmake
2022-12-07 01:44:15 -07:00
cmake_static_library_prefix: []const u8,
cmake_static_library_suffix: []const u8,
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
cxx_compiler: []const u8,
build.zig: add support for using "zig c++" as the bootstrap c++ compiler The build was previously failing with `error: unknown command: -print-file-name=libstdc++.a` because the command invocation was `zig -print-file-name=libstdc++.a` instead of `zig c++ -print-file-name=libstdc++.a` note: .cxx_compiler_arg1 = "" instead of undefined to avoid breaking existing setups without requiring to run cmake again.
2023-10-16 22:49:27 +02:00
cxx_compiler_arg1: []const u8,
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
lld_include_dir: []const u8,
lld_libraries: []const u8,
clang_libraries: []const u8,
build.zig: Forward LLVM lib/include dirs from CMake Previously, you might obtain `-lLLVM-15` from the CMake configuration, but we might not be able to locate the library if it's not in your system library path.
2022-10-12 18:11:46 -04:00
llvm_lib_dir: []const u8,
llvm_include_dir: []const u8,
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
llvm_libraries: []const u8,
dia_guids_lib: []const u8,
build stage3: detect system libcxx Detect system libcxx name with the CMake build system and convey that information to build.zig via config.h so that the same system libcxx is used for stage3. This undoes the hacky search 901457d173467c71b681a8c69f4b77c94d516da7 . closes #17018
2023-09-01 10:04:26 -04:00
system_libcxx: []const u8,
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
};
const max_config_h_bytes = 1 * 1024 * 1024;
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
fn findConfigH(b: *std.Build, config_h_path_option: ?[]const u8) ?[]const u8 {
build.zig: Emit warning if "config.h" cannot be found We now warn the user if config.h could not be located. This also updates the search to stop early upon encountering a `.git` directory, so that we avoid recursing outside of the zig source if possible.
2022-07-15 17:25:38 -07:00
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});
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
std.process.exit(1);
build.zig: Emit warning if "config.h" cannot be found We now warn the user if config.h could not be located. This also updates the search to stop early upon encountering a `.git` directory, so that we avoid recursing outside of the zig source if possible.
2022-07-15 17:25:38 -07:00
}
}
std.Build: implement --host-target, --host-cpu, --host-dynamic-linker This also makes a long-overdue change of extracting common state from Build into a shared Graph object. Getting the semantics right for these flags turned out to be quite tricky. In the end it works like this: * The override only happens when the target is fully native, with no additional query parameters, such as versions or CPU features added. * The override affects the resolved Target but leaves the original Query unmodified. * The "is native?" detection logic operates on the original, unmodified query. This makes it possible to provide invalid host target information, causing confusing errors to occur. Don't do that. There are some minor breaking changes to std.Build API such as the fact that `b.zig_exe` is now moved to `b.graph.zig_exe`, as well as a handful of other similar flags.
2024-02-01 15:44:44 -07:00
var check_dir = fs.path.dirname(b.graph.zig_exe).?;
build.zig: Emit warning if "config.h" cannot be found We now warn the user if config.h could not be located. This also updates the search to stop early upon encountering a `.git` directory, so that we avoid recursing outside of the zig source if possible.
2022-07-15 17:25:38 -07:00
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.?;
build.zig: remove an unneeded 'else unreachable' removed a TODO 🎊
2023-11-26 01:18:13 -08:00
}
build.zig: Emit warning if "config.h" cannot be found We now warn the user if config.h could not be located. This also updates the search to stop early upon encountering a `.git` directory, so that we avoid recursing outside of the zig source if possible.
2022-07-15 17:25:38 -07:00
}
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
fn parseConfigH(b: *std.Build, config_h_text: []const u8) ?CMakeConfig {
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
var ctx: CMakeConfig = .{
CMake: Add ZIG_LLVM_LINK_MODE to config.h This is currently unused, but it will be needed soon so that we can avoid linking static libc++ if LLVM/Clang is configured as a shared library.
2022-07-23 09:02:51 -07:00
.llvm_linkage = undefined,
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
.cmake_binary_dir = undefined,
.cmake_prefix_path = undefined,
build: obtain zigcpp library prefix/suffix from cmake
2022-12-07 01:44:15 -07:00
.cmake_static_library_prefix = undefined,
.cmake_static_library_suffix = undefined,
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
.cxx_compiler = undefined,
build.zig: add support for using "zig c++" as the bootstrap c++ compiler The build was previously failing with `error: unknown command: -print-file-name=libstdc++.a` because the command invocation was `zig -print-file-name=libstdc++.a` instead of `zig c++ -print-file-name=libstdc++.a` note: .cxx_compiler_arg1 = "" instead of undefined to avoid breaking existing setups without requiring to run cmake again.
2023-10-16 22:49:27 +02:00
.cxx_compiler_arg1 = "",
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
.lld_include_dir = undefined,
.lld_libraries = undefined,
.clang_libraries = undefined,
build.zig: Forward LLVM lib/include dirs from CMake Previously, you might obtain `-lLLVM-15` from the CMake configuration, but we might not be able to locate the library if it's not in your system library path.
2022-10-12 18:11:46 -04:00
.llvm_lib_dir = undefined,
.llvm_include_dir = undefined,
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
.llvm_libraries = undefined,
.dia_guids_lib = undefined,
build stage3: detect system libcxx Detect system libcxx name with the CMake build system and convey that information to build.zig via config.h so that the same system libcxx is used for stage3. This undoes the hacky search 901457d173467c71b681a8c69f4b77c94d516da7 . closes #17018
2023-09-01 10:04:26 -04:00
.system_libcxx = undefined,
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
};
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",
},
build: obtain zigcpp library prefix/suffix from cmake
2022-12-07 01:44:15 -07:00
.{
.prefix = "#define ZIG_CMAKE_STATIC_LIBRARY_PREFIX ",
.field = "cmake_static_library_prefix",
},
.{
.prefix = "#define ZIG_CMAKE_STATIC_LIBRARY_SUFFIX ",
.field = "cmake_static_library_suffix",
},
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
.{
.prefix = "#define ZIG_CXX_COMPILER ",
.field = "cxx_compiler",
},
build.zig: add support for using "zig c++" as the bootstrap c++ compiler The build was previously failing with `error: unknown command: -print-file-name=libstdc++.a` because the command invocation was `zig -print-file-name=libstdc++.a` instead of `zig c++ -print-file-name=libstdc++.a` note: .cxx_compiler_arg1 = "" instead of undefined to avoid breaking existing setups without requiring to run cmake again.
2023-10-16 22:49:27 +02:00
.{
.prefix = "#define ZIG_CXX_COMPILER_ARG1 ",
.field = "cxx_compiler_arg1",
},
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
.{
.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",
},
build.zig: Forward LLVM lib/include dirs from CMake Previously, you might obtain `-lLLVM-15` from the CMake configuration, but we might not be able to locate the library if it's not in your system library path.
2022-10-12 18:11:46 -04:00
.{
.prefix = "#define ZIG_LLVM_INCLUDE_PATH ",
.field = "llvm_include_dir",
},
.{
.prefix = "#define ZIG_LLVM_LIB_PATH ",
.field = "llvm_lib_dir",
},
build stage3: detect system libcxx Detect system libcxx name with the CMake build system and convey that information to build.zig via config.h so that the same system libcxx is used for stage3. This undoes the hacky search 901457d173467c71b681a8c69f4b77c94d516da7 . closes #17018
2023-09-01 10:04:26 -04:00
.{
.prefix = "#define ZIG_SYSTEM_LIBCXX",
.field = "system_libcxx",
},
CMake: Add ZIG_LLVM_LINK_MODE to config.h This is currently unused, but it will be needed soon so that we can avoid linking static libc++ if LLVM/Clang is configured as a shared library.
2022-07-23 09:02:51 -07:00
// .prefix = ZIG_LLVM_LINK_MODE parsed manually below
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
};
Update all std.mem.tokenize calls to their appropriate function Everywhere that can now use `tokenizeScalar` should get a nice little performance boost.
2023-05-04 18:05:40 -07:00
var lines_it = mem.tokenizeAny(u8, config_h_text, "\r\n");
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
while (lines_it.next()) |line| {
inline for (mappings) |mapping| {
if (mem.startsWith(u8, line, mapping.prefix)) {
Update all std.mem.split calls to their appropriate function Everywhere that can now use `splitScalar` should get a nice little performance boost.
2023-05-04 18:15:50 -07:00
var it = mem.splitScalar(u8, line, '"');
std.mem: add `first` method to `SplitIterator` and `SplitBackwardsIterator`
2022-07-25 21:04:30 +02:00
_ = it.first(); // skip the stuff before the quote
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
const quoted = it.next().?; // the stuff inside the quote
build.zig: add support for using "zig c++" as the bootstrap c++ compiler The build was previously failing with `error: unknown command: -print-file-name=libstdc++.a` because the command invocation was `zig -print-file-name=libstdc++.a` instead of `zig c++ -print-file-name=libstdc++.a` note: .cxx_compiler_arg1 = "" instead of undefined to avoid breaking existing setups without requiring to run cmake again.
2023-10-16 22:49:27 +02:00
const trimmed = mem.trim(u8, quoted, " ");
@field(ctx, mapping.field) = toNativePathSep(b, trimmed);
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
}
}
CMake: Add ZIG_LLVM_LINK_MODE to config.h This is currently unused, but it will be needed soon so that we can avoid linking static libc++ if LLVM/Clang is configured as a shared library.
2022-07-23 09:02:51 -07:00
if (mem.startsWith(u8, line, "#define ZIG_LLVM_LINK_MODE ")) {
Update all std.mem.split calls to their appropriate function Everywhere that can now use `splitScalar` should get a nice little performance boost.
2023-05-04 18:15:50 -07:00
var it = mem.splitScalar(u8, line, '"');
CMake: Add ZIG_LLVM_LINK_MODE to config.h This is currently unused, but it will be needed soon so that we can avoid linking static libc++ if LLVM/Clang is configured as a shared library.
2022-07-23 09:02:51 -07:00
_ = 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;
}
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
}
return ctx;
}
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.
2023-01-31 00:19:51 -07:00
fn toNativePathSep(b: *std.Build, s: []const u8) []u8 {
std lib API deprecations for the upcoming 0.9.0 release See #3811
2021-11-30 00:13:07 -07:00
const duplicated = b.allocator.dupe(u8, s) catch unreachable;
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-07 17:23:17 -07:00
for (duplicated) |*byte| switch (byte.*) {
'/' => byte.* = fs.path.sep,
else => {},
};
return duplicated;
}
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
const zig_cpp_sources = [_][]const u8{
// These are planned to stay even when we are self-hosted.
"src/zig_llvm.cpp",
Add zig_llvm-ar.cpp in build.zig This was added in 0afb5b2ec6de494efe0605b2270f6a01b95237af 8 days ago, but it seems it was only added in the cmake files and not build.zig
2021-06-05 21:33:16 -03:00
"src/zig_llvm-ar.cpp",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"src/zig_clang_driver.cpp",
"src/zig_clang_cc1_main.cpp",
"src/zig_clang_cc1as_main.cpp",
self-hosted: first passing test * introduce std.atomic.Int * add src-self-hosted/test.zig which is tested by the main test suite - it fully utilizes the multithreaded async/await event loop so the tests should Go Fast * `stage2/bin/zig build-obj test.zig` is able to spit out an error if 2 exported functions collide * ability for `zig test` to accept `--object` and `--assembly` arguments * std.build: TestStep supports addLibPath and addObjectFile
2018-07-10 20:18:43 -04:00
};
remove `zig BUILD_INFO` hack Rather than stuffing configuration information into the Zig binary, the build script reads it from config.h. This solves a problem for package maintainers and improves the use case of deterministic builds. closes #3758
2020-04-04 11:57:28 -04:00
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
const clang_libs = [_][]const u8{
"clangFrontendTool",
"clangCodeGen",
"clangFrontend",
"clangDriver",
"clangSerialization",
"clangSema",
"clangStaticAnalyzerFrontend",
"clangStaticAnalyzerCheckers",
"clangStaticAnalyzerCore",
"clangAnalysis",
"clangASTMatchers",
"clangAST",
"clangParse",
"clangSema",
add missing clang static library to the build
2024-04-25 23:04:36 -07:00
"clangAPINotes",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"clangBasic",
"clangEdit",
"clangLex",
"clangRewriteFrontend",
"clangRewrite",
"clangCrossTU",
"clangIndex",
"clangToolingCore",
build: add new clang libraries for LLVM 15 upgrade
2022-08-02 17:14:19 -07:00
"clangExtractAPI",
"clangSupport",
add missing clang and llvm library listings
2024-09-05 09:07:10 -07:00
"clangInstallAPI",
"clangAST",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
};
const lld_libs = [_][]const u8{
"lldMinGW",
"lldELF",
"lldCOFF",
"lldWasm",
update build scripts to LLD and LLVM 14 libraries
2022-07-03 18:41:43 -07:00
"lldMachO",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"lldCommon",
};
// This list can be re-generated with `llvm-config --libfiles` and then
// reformatting using your favorite text editor. Note we do not execute
build.zig: omit LLVMTableGen from llvm libs
2021-04-15 10:58:53 -07:00
// `llvm-config` here because we are cross compiling. Also omit LLVMTableGen
// from these libs.
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
const llvm_libs = [_][]const u8{
"LLVMWindowsManifest",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMXRay",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMLibDriver",
"LLVMDlltoolDriver",
build: Update to LLVM/Clang 20.
2025-02-05 10:15:15 +01:00
"LLVMTelemetry",
update CMake files to LLVM 18
2024-04-25 14:12:55 -07:00
"LLVMTextAPIBinaryReader",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMCoverage",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMLineEditor",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMXCoreDisassembler",
"LLVMXCoreCodeGen",
"LLVMXCoreDesc",
"LLVMXCoreInfo",
update build scripts to LLD and LLVM 14 libraries
2022-07-03 18:41:43 -07:00
"LLVMX86TargetMCA",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMX86Disassembler",
"LLVMX86AsmParser",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMX86CodeGen",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMX86Desc",
"LLVMX86Info",
"LLVMWebAssemblyDisassembler",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMWebAssemblyAsmParser",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMWebAssemblyCodeGen",
build.zig: update list of LLVM libs companion commit to 0f35a1f37ade9cf25707c41711b352174f1e2789 fixes compiling with a dev kit.
2021-10-02 12:40:07 -07:00
"LLVMWebAssemblyUtils",
update LLVM static library list to 17 release/17.x branch, commit 8f4dd44097c9ae25dd203d5ac87f3b48f854bba8
2023-08-11 22:33:20 -07:00
"LLVMWebAssemblyDesc",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMWebAssemblyInfo",
update build scripts to LLD and LLVM 14 libraries
2022-07-03 18:41:43 -07:00
"LLVMVEDisassembler",
"LLVMVEAsmParser",
"LLVMVECodeGen",
"LLVMVEDesc",
"LLVMVEInfo",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMSystemZDisassembler",
"LLVMSystemZAsmParser",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMSystemZCodeGen",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMSystemZDesc",
"LLVMSystemZInfo",
build: Update to LLVM/Clang 20.
2025-02-05 10:15:15 +01:00
"LLVMSPIRVCodeGen",
"LLVMSPIRVDesc",
"LLVMSPIRVInfo",
"LLVMSPIRVAnalysis",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMSparcDisassembler",
"LLVMSparcAsmParser",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMSparcCodeGen",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMSparcDesc",
"LLVMSparcInfo",
build.zig: update list of llvm libs to llvm 16
2023-01-29 13:12:13 -07:00
"LLVMRISCVTargetMCA",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMRISCVDisassembler",
"LLVMRISCVAsmParser",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMRISCVCodeGen",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMRISCVDesc",
"LLVMRISCVInfo",
"LLVMPowerPCDisassembler",
"LLVMPowerPCAsmParser",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMPowerPCCodeGen",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMPowerPCDesc",
"LLVMPowerPCInfo",
"LLVMNVPTXCodeGen",
"LLVMNVPTXDesc",
"LLVMNVPTXInfo",
"LLVMMSP430Disassembler",
"LLVMMSP430AsmParser",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMMSP430CodeGen",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMMSP430Desc",
"LLVMMSP430Info",
"LLVMMipsDisassembler",
"LLVMMipsAsmParser",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMMipsCodeGen",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMMipsDesc",
"LLVMMipsInfo",
build.zig: update list of llvm libs to llvm 16
2023-01-29 13:12:13 -07:00
"LLVMLoongArchDisassembler",
"LLVMLoongArchAsmParser",
"LLVMLoongArchCodeGen",
"LLVMLoongArchDesc",
"LLVMLoongArchInfo",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMLanaiDisassembler",
"LLVMLanaiCodeGen",
"LLVMLanaiAsmParser",
"LLVMLanaiDesc",
"LLVMLanaiInfo",
"LLVMHexagonDisassembler",
"LLVMHexagonCodeGen",
"LLVMHexagonAsmParser",
"LLVMHexagonDesc",
"LLVMHexagonInfo",
"LLVMBPFDisassembler",
"LLVMBPFAsmParser",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMBPFCodeGen",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMBPFDesc",
"LLVMBPFInfo",
"LLVMAVRDisassembler",
"LLVMAVRAsmParser",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMAVRCodeGen",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMAVRDesc",
"LLVMAVRInfo",
"LLVMARMDisassembler",
"LLVMARMAsmParser",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMARMCodeGen",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMARMDesc",
"LLVMARMUtils",
"LLVMARMInfo",
update build scripts to LLD and LLVM 14 libraries
2022-07-03 18:41:43 -07:00
"LLVMAMDGPUTargetMCA",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMAMDGPUDisassembler",
"LLVMAMDGPUAsmParser",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMAMDGPUCodeGen",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMAMDGPUDesc",
"LLVMAMDGPUUtils",
"LLVMAMDGPUInfo",
"LLVMAArch64Disassembler",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMAArch64AsmParser",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMAArch64CodeGen",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMAArch64Desc",
"LLVMAArch64Utils",
"LLVMAArch64Info",
update CMake files to LLVM 18
2024-04-25 14:12:55 -07:00
"LLVMOrcDebugging",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMOrcJIT",
build.zig: update list of llvm libs to llvm 16
2023-01-29 13:12:13 -07:00
"LLVMWindowsDriver",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMMCJIT",
"LLVMJITLink",
"LLVMInterpreter",
"LLVMExecutionEngine",
"LLVMRuntimeDyld",
build.zig: update list of LLVM libs companion commit to 0f35a1f37ade9cf25707c41711b352174f1e2789 fixes compiling with a dev kit.
2021-10-02 12:40:07 -07:00
"LLVMOrcTargetProcess",
"LLVMOrcShared",
"LLVMDWP",
build: update to LLVM 21 Closes #20966.
2025-07-16 04:41:14 +02:00
"LLVMDWARFCFIChecker",
build.zig: update list of llvm libs to llvm 16
2023-01-29 13:12:13 -07:00
"LLVMDebugInfoLogicalView",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMOption",
update LLVM library list to LLVM 15
2022-08-02 16:57:32 -07:00
"LLVMObjCopy",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMMCA",
"LLVMMCDisassembler",
"LLVMLTO",
build: update to LLVM 21 Closes #20966.
2025-07-16 04:41:14 +02:00
"LLVMFrontendOpenACC",
"LLVMFrontendHLSL",
"LLVMFrontendDriver",
"LLVMExtensions",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMPasses",
update CMake files to LLVM 18
2024-04-25 14:12:55 -07:00
"LLVMHipStdPar",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMCoroutines",
build: update to LLVM 21 Closes #20966.
2025-07-16 04:41:14 +02:00
"LLVMCFGuard",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMipo",
build: update to LLVM 21 Closes #20966.
2025-07-16 04:41:14 +02:00
"LLVMInstrumentation",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMVectorize",
build: Update to LLVM/Clang 20.
2025-02-05 10:15:15 +01:00
"LLVMSandboxIR",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMLinker",
"LLVMFrontendOpenMP",
build: update to LLVM 21 Closes #20966.
2025-07-16 04:41:14 +02:00
"LLVMFrontendDirective",
build: Update to LLVM/Clang 20.
2025-02-05 10:15:15 +01:00
"LLVMFrontendAtomic",
build: update to LLVM 21 Closes #20966.
2025-07-16 04:41:14 +02:00
"LLVMFrontendOffloading",
"LLVMObjectYAML",
build.zig: update list of llvm libs to llvm 16
2023-01-29 13:12:13 -07:00
"LLVMDWARFLinkerParallel",
update CMake files to LLVM 18
2024-04-25 14:12:55 -07:00
"LLVMDWARFLinkerClassic",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMDWARFLinker",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMGlobalISel",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMMIRParser",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMAsmPrinter",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMSelectionDAG",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMCodeGen",
update LLVM static library list to 17 release/17.x branch, commit 8f4dd44097c9ae25dd203d5ac87f3b48f854bba8
2023-08-11 22:33:20 -07:00
"LLVMTarget",
build.zig: update list of llvm libs to llvm 16
2023-01-29 13:12:13 -07:00
"LLVMObjCARCOpts",
update LLVM static library list to 17 release/17.x branch, commit 8f4dd44097c9ae25dd203d5ac87f3b48f854bba8
2023-08-11 22:33:20 -07:00
"LLVMCodeGenTypes",
build: Update to LLVM/Clang 20.
2025-02-05 10:15:15 +01:00
"LLVMCGData",
build.zig: update list of llvm libs to llvm 16
2023-01-29 13:12:13 -07:00
"LLVMIRPrinter",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMInterfaceStub",
"LLVMFileCheck",
"LLVMFuzzMutate",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMScalarOpts",
"LLVMInstCombine",
"LLVMAggressiveInstCombine",
"LLVMTransformUtils",
"LLVMBitWriter",
"LLVMAnalysis",
"LLVMProfileData",
update LLVM library list to LLVM 15
2022-08-02 16:57:32 -07:00
"LLVMSymbolize",
update LLVM static library list to 17 release/17.x branch, commit 8f4dd44097c9ae25dd203d5ac87f3b48f854bba8
2023-08-11 22:33:20 -07:00
"LLVMDebugInfoBTF",
update LLVM library list to LLVM 15
2022-08-02 16:57:32 -07:00
"LLVMDebugInfoPDB",
"LLVMDebugInfoMSF",
build: Update to LLVM/Clang 20.
2025-02-05 10:15:15 +01:00
"LLVMDebugInfoCodeView",
build: update to LLVM 21 Closes #20966.
2025-07-16 04:41:14 +02:00
"LLVMDebugInfoGSYM",
update build scripts to LLD and LLVM 14 libraries
2022-07-03 18:41:43 -07:00
"LLVMDebugInfoDWARF",
build: update to LLVM 21 Closes #20966.
2025-07-16 04:41:14 +02:00
"LLVMDebugInfoDWARFLowLevel",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMObject",
"LLVMTextAPI",
"LLVMMCParser",
build.zig: update list of llvm libs to llvm 16
2023-01-29 13:12:13 -07:00
"LLVMIRReader",
"LLVMAsmParser",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMMC",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMBitReader",
update LLVM library list to LLVM 15
2022-08-02 16:57:32 -07:00
"LLVMFuzzerCLI",
build.zig: update llvm libs
2021-04-15 10:43:39 -07:00
"LLVMCore",
"LLVMRemarks",
"LLVMBitstreamReader",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMBinaryFormat",
build.zig: update list of llvm libs to llvm 16
2023-01-29 13:12:13 -07:00
"LLVMTargetParser",
ability to build stage1 using only a zig tarball The main idea here is that there are now 2 ways to get a stage1 zig binary: * The cmake path. Requirements: cmake, system C++ compiler, system LLVM, LLD, Clang libraries, compiled by the system C++ compiler. * The zig path. Requirements: a zig installation, system LLVM, LLD, Clang libraries, compiled by the zig installation. Note that the former can be used to now take the latter path. Removed config.h.in and config.zig.in. The build.zig script no longer is coupled to the cmake script. cmake no longer tries to determine the zig version. A build with cmake will yield a stage1 zig binary that reports 0.0.0+zig0. This is going to get reverted. `zig build` now accepts `-Dstage1` which will build the stage1 compiler, and put the stage2 backend behind a feature flag. build.zig is simplified to only support the use case of enabling LLVM support when the LLVM, LLD, and Clang libraries were built by zig. This part is probably sadly going to have to get reverted to make package maintainers happy. Zig build system addBuildOption supports a couple new types. The biggest reason to make this change is that the zig path is an attractive option for doing compiler development work on Windows. It allows people to work on the compiler without having MSVC installed, using only a .zip file that contains Zig + LLVM/LLD/Clang libraries.
2020-12-04 21:33:29 -07:00
"LLVMSupport",
"LLVMDemangle",
};
build.zig: Statically link LLVM libraries for experimental targets if requested.
2025-03-26 23:19:35 +01:00
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",
};
migrate langref documentation generation to the build system
2024-04-24 17:41:47 -07:00
fn generateLangRef(b: *std.Build) std.Build.LazyPath {
const doctest_exe = b.addExecutable(.{
.name = "doctest",
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
.root_module = b.createModule(.{
.root_source_file = b.path("tools/doctest.zig"),
.target = b.graph.host,
.optimize = .Debug,
}),
migrate langref documentation generation to the build system
2024-04-24 17:41:47 -07:00
});
var dir = b.build_root.handle.openDir("doc/langref", .{ .iterate = true }) catch |err| {
std.fmt: breaking API changes added adapter to AnyWriter and GenericWriter to help bridge the gap between old and new API make std.testing.expectFmt work at compile-time std.fmt no longer has a dependency on std.unicode. Formatted printing was never properly unicode-aware. Now it no longer pretends to be. Breakage/deprecations: * std.fs.File.reader -> std.fs.File.deprecatedReader * std.fs.File.writer -> std.fs.File.deprecatedWriter * std.io.GenericReader -> std.io.Reader * std.io.GenericWriter -> std.io.Writer * std.io.AnyReader -> std.io.Reader * std.io.AnyWriter -> std.io.Writer * std.fmt.format -> std.fmt.deprecatedFormat * std.fmt.fmtSliceEscapeLower -> std.ascii.hexEscape * std.fmt.fmtSliceEscapeUpper -> std.ascii.hexEscape * std.fmt.fmtSliceHexLower -> {x} * std.fmt.fmtSliceHexUpper -> {X} * std.fmt.fmtIntSizeDec -> {B} * std.fmt.fmtIntSizeBin -> {Bi} * std.fmt.fmtDuration -> {D} * std.fmt.fmtDurationSigned -> {D} * {} -> {f} when there is a format method * format method signature - anytype -> *std.io.Writer - inferred error set -> error{WriteFailed} - options -> (deleted) * std.fmt.Formatted - now takes context type explicitly - no fmt string
2025-06-27 20:05:22 -07:00
std.debug.panic("unable to open '{f}doc/langref' directory: {s}", .{
integrate Compile steps with file watching Updates the build runner to unconditionally require a zig lib directory parameter. This parameter is needed in order to correctly understand file system inputs from zig compiler subprocesses, since they will refer to "the zig lib directory", and the build runner needs to place file system watches on directories in there. The build runner's fanotify file watching implementation now accounts for when two or more Cache.Path instances compare unequal but ultimately refer to the same directory in the file system. Breaking change: std.Build no longer has a zig_lib_dir field. Instead, there is the Graph zig_lib_directory field, and individual Compile steps can still have their zig lib directories overridden. I think this is unlikely to break anyone's build in practice. The compiler now sends a "file_system_inputs" message to the build runner which shares the full set of files that were added to the cache system with the build system, so that the build runner can watch properly and redo the Compile step. This is implemented for whole cache mode but not yet for incremental cache mode.
2024-07-11 16:26:04 -07:00
b.build_root, @errorName(err),
});
migrate langref documentation generation to the build system
2024-04-24 17:41:47 -07:00
};
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 ".",
});
std.fmt: breaking API changes added adapter to AnyWriter and GenericWriter to help bridge the gap between old and new API make std.testing.expectFmt work at compile-time std.fmt no longer has a dependency on std.unicode. Formatted printing was never properly unicode-aware. Now it no longer pretends to be. Breakage/deprecations: * std.fs.File.reader -> std.fs.File.deprecatedReader * std.fs.File.writer -> std.fs.File.deprecatedWriter * std.io.GenericReader -> std.io.Reader * std.io.GenericWriter -> std.io.Writer * std.io.AnyReader -> std.io.Reader * std.io.AnyWriter -> std.io.Writer * std.fmt.format -> std.fmt.deprecatedFormat * std.fmt.fmtSliceEscapeLower -> std.ascii.hexEscape * std.fmt.fmtSliceEscapeUpper -> std.ascii.hexEscape * std.fmt.fmtSliceHexLower -> {x} * std.fmt.fmtSliceHexUpper -> {X} * std.fmt.fmtIntSizeDec -> {B} * std.fmt.fmtIntSizeBin -> {Bi} * std.fmt.fmtDuration -> {D} * std.fmt.fmtDurationSigned -> {D} * {} -> {f} when there is a format method * format method signature - anytype -> *std.io.Writer - inferred error set -> error{WriteFailed} - options -> (deleted) * std.fmt.Formatted - now takes context type explicitly - no fmt string
2025-06-27 20:05:22 -07:00
cmd.addArgs(&.{ "--zig-lib-dir", b.fmt("{f}", .{b.graph.zig_lib_directory}) });
migrate langref documentation generation to the build system
2024-04-24 17:41:47 -07:00
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",
build.zig: migrate from deprecated std.Build APIs
2024-12-15 18:09:38 +00:00
.root_module = b.createModule(.{
.root_source_file = b.path("tools/docgen.zig"),
.target = b.graph.host,
.optimize = .Debug,
}),
migrate langref documentation generation to the build system
2024-04-24 17:41:47 -07:00
});
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");
}
add -Denable-tidy flag and use it in the CI Eliminates a TODO from the CI scripts; makes it easier to check validity of html when working on the langref locally.
2024-06-16 20:03:14 -07:00
Replace tidy with superhtml as HTML validator (#21664) Also add `$HOME/local/bin` to `PATH` in linux CI
2024-10-12 06:27:30 +02:00
fn superHtmlCheck(b: *std.Build, html_file: std.Build.LazyPath) *std.Build.Step {
const run_superhtml = b.addSystemCommand(&.{
"superhtml", "check",
add -Denable-tidy flag and use it in the CI Eliminates a TODO from the CI scripts; makes it easier to check validity of html when working on the langref locally.
2024-06-16 20:03:14 -07:00
});
Replace tidy with superhtml as HTML validator (#21664) Also add `$HOME/local/bin` to `PATH` in linux CI
2024-10-12 06:27:30 +02:00
run_superhtml.addFileArg(html_file);
run_superhtml.expectExitCode(0);
return &run_superhtml.step;
add -Denable-tidy flag and use it in the CI Eliminates a TODO from the CI scripts; makes it easier to check validity of html when working on the langref locally.
2024-06-16 20:03:14 -07:00
}
Reference in New Issue Copy Permalink