From 94e3faa8c08be3ff4ac95c9650a8e1a3477f540d Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Sun, 7 Aug 2022 23:10:57 -0700 Subject: [PATCH] make self-hosted the default compiler stage1 is available behind the -fstage1 flag. closes #89 --- CMakeLists.txt | 2 +- build.zig | 16 +- ci/azure/build.zig | 10 +- ci/azure/macos_script | 17 +- ci/azure/pipelines.yml | 4 +- ci/srht/freebsd_script | 9 +- ci/zinc/linux_test.sh | 48 +++-- doc/docgen.zig | 31 +++ doc/langref.html.in | 178 +++++++----------- lib/std/builtin.zig | 2 +- src/Compilation.zig | 29 +-- src/config.zig.in | 2 +- src/link.zig | 4 +- src/link/Coff.zig | 4 +- src/link/Elf.zig | 2 +- src/link/MachO.zig | 4 +- src/link/Wasm.zig | 6 +- src/main.zig | 2 +- src/stage1.zig | 2 +- src/test.zig | 2 +- ...mpty slice with sentinel out of bounds.zig | 2 +- .../safety/out of bounds slice access.zig | 6 +- ...h sentinel out of bounds - runtime len.zig | 2 +- .../slice with sentinel out of bounds.zig | 2 +- test/tests.zig | 3 +- 25 files changed, 176 insertions(+), 213 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 96d10f1e8354..d9784090cd08 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -12,7 +12,7 @@ if(NOT CMAKE_BUILD_TYPE) endif() if(NOT CMAKE_INSTALL_PREFIX) - set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/stage1" CACHE STRING + set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/stage2" CACHE STRING "Directory to install zig to" FORCE) endif() diff --git a/build.zig b/build.zig index 1c2212c1a4c7..6823248431da 100644 --- a/build.zig +++ b/build.zig @@ -64,9 +64,9 @@ pub fn build(b: *Builder) !void { const only_install_lib_files = b.option(bool, "lib-files-only", "Only install library files") orelse false; - const is_stage1 = b.option(bool, "stage1", "Build the stage1 compiler, put stage2 behind a feature flag") orelse false; + const have_stage1 = b.option(bool, "enable-stage1", "Include the stage1 compiler behind a feature flag") orelse false; const static_llvm = b.option(bool, "static-llvm", "Disable integration with system-installed LLVM, Clang, LLD, and libc++") orelse false; - const enable_llvm = b.option(bool, "enable-llvm", "Build self-hosted compiler with LLVM backend enabled") orelse (is_stage1 or static_llvm); + const enable_llvm = b.option(bool, "enable-llvm", "Build self-hosted compiler with LLVM backend enabled") orelse (have_stage1 or static_llvm); const llvm_has_m68k = b.option( bool, "llvm-has-m68k", @@ -136,7 +136,7 @@ pub fn build(b: *Builder) !void { }; const main_file: ?[]const u8 = mf: { - if (!is_stage1) break :mf "src/main.zig"; + if (!have_stage1) break :mf "src/main.zig"; if (use_zig0) break :mf null; break :mf "src/stage1.zig"; }; @@ -247,7 +247,7 @@ pub fn build(b: *Builder) !void { } }; - if (is_stage1) { + if (have_stage1) { const softfloat = b.addStaticLibrary("softfloat", null); softfloat.setBuildMode(.ReleaseFast); softfloat.setTarget(target); @@ -359,7 +359,7 @@ pub fn build(b: *Builder) !void { exe_options.addOption(bool, "enable_tracy_callstack", tracy_callstack); exe_options.addOption(bool, "enable_tracy_allocation", tracy_allocation); exe_options.addOption(bool, "value_tracing", value_tracing); - exe_options.addOption(bool, "is_stage1", is_stage1); + exe_options.addOption(bool, "have_stage1", have_stage1); if (tracy) |tracy_path| { const client_cpp = fs.path.join( b.allocator, @@ -394,7 +394,7 @@ pub fn build(b: *Builder) !void { test_cases_options.addOption(bool, "enable_link_snapshots", enable_link_snapshots); test_cases_options.addOption(bool, "skip_non_native", skip_non_native); test_cases_options.addOption(bool, "skip_stage1", skip_stage1); - test_cases_options.addOption(bool, "is_stage1", is_stage1); + test_cases_options.addOption(bool, "have_stage1", have_stage1); test_cases_options.addOption(bool, "have_llvm", enable_llvm); test_cases_options.addOption(bool, "llvm_has_m68k", llvm_has_m68k); test_cases_options.addOption(bool, "llvm_has_csky", llvm_has_csky); @@ -455,7 +455,6 @@ pub fn build(b: *Builder) !void { skip_libc, skip_stage1, false, - is_stage1, )); toolchain_step.dependOn(tests.addPkgTests( @@ -470,7 +469,6 @@ pub fn build(b: *Builder) !void { true, // skip_libc skip_stage1, true, // TODO get these all passing - is_stage1, )); toolchain_step.dependOn(tests.addPkgTests( @@ -485,7 +483,6 @@ pub fn build(b: *Builder) !void { true, // skip_libc skip_stage1, true, // TODO get these all passing - is_stage1, )); toolchain_step.dependOn(tests.addCompareOutputTests(b, test_filter, modes)); @@ -525,7 +522,6 @@ pub fn build(b: *Builder) !void { skip_libc, skip_stage1, true, // TODO get these all passing - is_stage1, ); const test_step = b.step("test", "Run all the tests"); diff --git a/ci/azure/build.zig b/ci/azure/build.zig index 053065b6997b..00f1cce2bd95 100644 --- a/ci/azure/build.zig +++ b/ci/azure/build.zig @@ -37,9 +37,9 @@ pub fn build(b: *Builder) !void { const docs_step = b.step("docs", "Build documentation"); docs_step.dependOn(&docgen_cmd.step); - const is_stage1 = b.option(bool, "stage1", "Build the stage1 compiler, put stage2 behind a feature flag") orelse false; + const have_stage1 = b.option(bool, "enable-stage1", "Include the stage1 compiler behind a feature flag") orelse false; const static_llvm = b.option(bool, "static-llvm", "Disable integration with system-installed LLVM, Clang, LLD, and libc++") orelse false; - const enable_llvm = b.option(bool, "enable-llvm", "Build self-hosted compiler with LLVM backend enabled") orelse (is_stage1 or static_llvm); + const enable_llvm = b.option(bool, "enable-llvm", "Build self-hosted compiler with LLVM backend enabled") orelse (have_stage1 or static_llvm); const llvm_has_m68k = b.option( bool, "llvm-has-m68k", @@ -101,7 +101,7 @@ pub fn build(b: *Builder) !void { break :blk 4; }; - const main_file: ?[]const u8 = if (is_stage1) null else "src/main.zig"; + const main_file: ?[]const u8 = if (have_stage1) null else "src/main.zig"; const exe = b.addExecutable("zig", main_file); exe.strip = strip; @@ -190,7 +190,7 @@ pub fn build(b: *Builder) !void { if (enable_llvm) { const cmake_cfg = if (static_llvm) null else findAndParseConfigH(b, config_h_path_option); - if (is_stage1) { + if (have_stage1) { const softfloat = b.addStaticLibrary("softfloat", null); softfloat.setBuildMode(.ReleaseFast); softfloat.setTarget(target); @@ -298,7 +298,7 @@ pub fn build(b: *Builder) !void { exe_options.addOption(bool, "enable_tracy_callstack", tracy_callstack); exe_options.addOption(bool, "enable_tracy_allocation", tracy_allocation); exe_options.addOption(bool, "value_tracing", value_tracing); - exe_options.addOption(bool, "is_stage1", is_stage1); + exe_options.addOption(bool, "have_stage1", have_stage1); if (tracy) |tracy_path| { const client_cpp = fs.path.join( b.allocator, diff --git a/ci/azure/macos_script b/ci/azure/macos_script index b244a7386947..d0ad9171ee8e 100755 --- a/ci/azure/macos_script +++ b/ci/azure/macos_script @@ -34,7 +34,7 @@ git fetch --tags mkdir build cd build cmake .. \ - -DCMAKE_INSTALL_PREFIX="$(pwd)/release" \ + -DCMAKE_INSTALL_PREFIX="$(pwd)/stage2" \ -DCMAKE_PREFIX_PATH="$PREFIX" \ -DCMAKE_BUILD_TYPE=Release \ -DZIG_TARGET_TRIPLE="$TARGET" \ @@ -52,23 +52,18 @@ make $JOBS install # Here we rebuild zig but this time using the Zig binary we just now produced to # build zig1.o rather than relying on the one built with stage0. See # https://github.com/ziglang/zig/issues/6830 for more details. -cmake .. -DZIG_EXECUTABLE="$(pwd)/release/bin/zig" +cmake .. -DZIG_EXECUTABLE="$(pwd)/stage2/bin/zig" make $JOBS install -# Build stage2 standalone so that we can test stage2 against stage2 compiler-rt. -release/bin/zig build -p stage2 -Denable-llvm +stage2/bin/zig build -p release -Denable-llvm -Denable-stage1 -stage2/bin/zig build test-behavior - -# TODO: upgrade these to test stage2 instead of stage1 -# TODO: upgrade these to test stage3 instead of stage2 -release/bin/zig build test-behavior -Denable-macos-sdk -Domit-stage2 release/bin/zig build test-compiler-rt -Denable-macos-sdk +release/bin/zig build test-behavior -Denable-macos-sdk release/bin/zig build test-std -Denable-macos-sdk release/bin/zig build test-universal-libc -Denable-macos-sdk release/bin/zig build test-compare-output -Denable-macos-sdk release/bin/zig build test-standalone -Denable-macos-sdk -release/bin/zig build test-stack-traces -Denable-macos-sdk +release/bin/zig build test-stack-traces -Denable-macos-sdk -fstage1 release/bin/zig build test-cli -Denable-macos-sdk release/bin/zig build test-asm-link -Denable-macos-sdk release/bin/zig build test-translate-c -Denable-macos-sdk @@ -76,7 +71,7 @@ release/bin/zig build test-run-translated-c -Denable-macos-sdk release/bin/zig build docs -Denable-macos-sdk release/bin/zig build test-fmt -Denable-macos-sdk release/bin/zig build test-cases -Denable-macos-sdk -Dsingle-threaded -release/bin/zig build test-link -Denable-macos-sdk -Domit-stage2 +release/bin/zig build test-link -Denable-macos-sdk if [ "${BUILD_REASON}" != "PullRequest" ]; then mv ../LICENSE release/ diff --git a/ci/azure/pipelines.yml b/ci/azure/pipelines.yml index 5d208b31a2f7..16804a0a2b6e 100644 --- a/ci/azure/pipelines.yml +++ b/ci/azure/pipelines.yml @@ -68,9 +68,7 @@ jobs: & "${ZIGPREFIXPATH}/bin/zig.exe" build ` --prefix "$ZIGINSTALLDIR" ` --search-prefix "$ZIGPREFIXPATH" ` - -Dstage1 ` - <# stage2 is omitted until we resolve https://github.com/ziglang/zig/issues/6485 #> ` - -Domit-stage2 ` + -Denable-stage1 ` -Dstatic-llvm ` -Drelease ` -Dstrip ` diff --git a/ci/srht/freebsd_script b/ci/srht/freebsd_script index 9fd7c0be6505..9c77c7d120c4 100755 --- a/ci/srht/freebsd_script +++ b/ci/srht/freebsd_script @@ -38,10 +38,11 @@ cmake .. \ -GNinja samu install -# TODO ld.lld: error: undefined symbol: main -# >>> referenced by crt1_c.c:75 (/usr/src/lib/csu/amd64/crt1_c.c:75) -# >>> /usr/lib/crt1.o:(_start) -#release/bin/zig test ../test/behavior.zig -fno-stage1 -fLLVM -I ../test +# Here we rebuild zig but this time using the Zig binary we just now produced to +# build zig1.o rather than relying on the one built with stage0. This makes it +# a stage3 build rather than a stage2 build. +cmake .. -DZIG_EXECUTABLE="$PREFIX/bin/zig" +samu install # Here we skip some tests to save time. release/bin/zig build test -Dskip-stage1 -Dskip-non-native diff --git a/ci/zinc/linux_test.sh b/ci/zinc/linux_test.sh index 3a54e82c38a5..1b280fbae5fd 100755 --- a/ci/zinc/linux_test.sh +++ b/ci/zinc/linux_test.sh @@ -33,41 +33,39 @@ unset CXX ninja install -STAGE1_ZIG="$DEBUG_STAGING/bin/zig" - # Here we rebuild zig but this time using the Zig binary we just now produced to # build zig1.o rather than relying on the one built with stage0. See # https://github.com/ziglang/zig/issues/6830 for more details. -cmake .. -DZIG_EXECUTABLE="$STAGE1_ZIG" +cmake .. -DZIG_EXECUTABLE="$DEBUG_STAGING/bin/zig" ninja install cd $WORKSPACE +"$DEBUG_STAGING/bin/zig" build -p stage3 -Denable-stage1 -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL" + +# simultaneously test building self-hosted without LLVM and with 32-bit arm +stage3/bin/zig build -Dtarget=arm-linux-musleabihf + echo "Looking for non-conforming code formatting..." echo "Formatting errors can be fixed by running 'zig fmt' on the files printed here." -$STAGE1_ZIG fmt --check . --exclude test/cases/ - -$STAGE1_ZIG build -p stage2 -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL" -stage2/bin/zig build -p stage3 -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL" -stage3/bin/zig build # test building self-hosted without LLVM -stage3/bin/zig build -Dtarget=arm-linux-musleabihf # test building self-hosted for 32-bit arm - -stage3/bin/zig build test-compiler-rt -fqemu -fwasmtime -Denable-llvm -stage3/bin/zig build test-behavior -fqemu -fwasmtime -Denable-llvm -stage3/bin/zig build test-std -fqemu -fwasmtime -Denable-llvm -stage3/bin/zig build test-universal-libc -fqemu -fwasmtime -Denable-llvm -stage3/bin/zig build test-compare-output -fqemu -fwasmtime -Denable-llvm -stage3/bin/zig build test-asm-link -fqemu -fwasmtime -Denable-llvm -stage3/bin/zig build test-fmt -fqemu -fwasmtime -Denable-llvm -stage3/bin/zig build test-translate-c -fqemu -fwasmtime -Denable-llvm -stage3/bin/zig build test-run-translated-c -fqemu -fwasmtime -Denable-llvm -stage3/bin/zig build test-standalone -fqemu -fwasmtime -Denable-llvm -stage3/bin/zig build test-cli -fqemu -fwasmtime -Denable-llvm +stage3/bin/zig fmt --check . --exclude test/cases/ + +stage3/bin/zig build test-compiler-rt -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL" +stage3/bin/zig build test-behavior -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL" +stage3/bin/zig build test-std -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL" +stage3/bin/zig build test-universal-libc -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL" +stage3/bin/zig build test-compare-output -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL" +stage3/bin/zig build test-asm-link -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL" +stage3/bin/zig build test-fmt -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL" +stage3/bin/zig build test-translate-c -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL" +stage3/bin/zig build test-run-translated-c -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL" +stage3/bin/zig build test-standalone -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL" +stage3/bin/zig build test-cli -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL" stage3/bin/zig build test-cases -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL" -stage3/bin/zig build test-link -fqemu -fwasmtime -Denable-llvm +stage3/bin/zig build test-link -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL" +stage3/bin/zig build docs -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL" -$STAGE1_ZIG build test-stack-traces -fqemu -fwasmtime -$STAGE1_ZIG build docs -fqemu -fwasmtime +stage3/bin/zig build test-stack-traces -fqemu -fwasmtime -fstage1 # Produce the experimental std lib documentation. mkdir -p "$RELEASE_STAGING/docs/std" @@ -87,7 +85,7 @@ stage3/bin/zig build \ -Drelease \ -Dstrip \ -Dtarget="$TARGET" \ - -Dstage1 + -Denable-stage1 # Explicit exit helps show last command duration. exit diff --git a/doc/docgen.zig b/doc/docgen.zig index a101b96be72d..0f0e212e3c24 100644 --- a/doc/docgen.zig +++ b/doc/docgen.zig @@ -285,6 +285,7 @@ const Code = struct { link_objects: []const []const u8, target_str: ?[]const u8, link_libc: bool, + backend_stage1: bool, link_mode: ?std.builtin.LinkMode, disable_cache: bool, verbose_cimport: bool, @@ -554,6 +555,7 @@ fn genToc(allocator: Allocator, tokenizer: *Tokenizer) !Toc { var link_mode: ?std.builtin.LinkMode = null; var disable_cache = false; var verbose_cimport = false; + var backend_stage1 = false; const source_token = while (true) { const content_tok = try eatToken(tokenizer, Token.Id.Content); @@ -586,6 +588,8 @@ fn genToc(allocator: Allocator, tokenizer: *Tokenizer) !Toc { link_libc = true; } else if (mem.eql(u8, end_tag_name, "link_mode_dynamic")) { link_mode = .Dynamic; + } else if (mem.eql(u8, end_tag_name, "backend_stage1")) { + backend_stage1 = true; } else if (mem.eql(u8, end_tag_name, "code_end")) { _ = try eatToken(tokenizer, Token.Id.BracketClose); break content_tok; @@ -609,6 +613,7 @@ fn genToc(allocator: Allocator, tokenizer: *Tokenizer) !Toc { .link_objects = link_objects.toOwnedSlice(), .target_str = target_str, .link_libc = link_libc, + .backend_stage1 = backend_stage1, .link_mode = link_mode, .disable_cache = disable_cache, .verbose_cimport = verbose_cimport, @@ -1187,6 +1192,9 @@ fn printShell(out: anytype, shell_content: []const u8) !void { try out.writeAll(""); } +// Override this to skip to later tests +const debug_start_line = 0; + fn genHtml( allocator: Allocator, tokenizer: *Tokenizer, @@ -1266,6 +1274,13 @@ fn genHtml( continue; } + if (debug_start_line > 0) { + const loc = tokenizer.getTokenLocation(code.source_token); + if (debug_start_line > loc.line) { + continue; + } + } + const raw_source = tokenizer.buffer[code.source_token.start..code.source_token.end]; const trimmed_raw_source = mem.trim(u8, raw_source, " \n"); const tmp_source_file_name = try fs.path.join( @@ -1311,6 +1326,10 @@ fn genHtml( try build_args.append("-lc"); try shell_out.print("-lc ", .{}); } + if (code.backend_stage1) { + try build_args.append("-fstage1"); + try shell_out.print("-fstage1", .{}); + } const target = try std.zig.CrossTarget.parse(.{ .arch_os_abi = code.target_str orelse "native", }); @@ -1443,6 +1462,10 @@ fn genHtml( try test_args.append("-lc"); try shell_out.print("-lc ", .{}); } + if (code.backend_stage1) { + try test_args.append("-fstage1"); + try shell_out.print("-fstage1", .{}); + } if (code.target_str) |triple| { try test_args.appendSlice(&[_][]const u8{ "-target", triple }); try shell_out.print("-target {s} ", .{triple}); @@ -1490,6 +1513,14 @@ fn genHtml( try shell_out.print("-O {s} ", .{@tagName(code.mode)}); }, } + if (code.link_libc) { + try test_args.append("-lc"); + try shell_out.print("-lc ", .{}); + } + if (code.backend_stage1) { + try test_args.append("-fstage1"); + try shell_out.print("-fstage1", .{}); + } const result = try ChildProcess.exec(.{ .allocator = allocator, .argv = test_args.items, diff --git a/doc/langref.html.in b/doc/langref.html.in index c61f2d0790fe..ba817f0a4d10 100644 --- a/doc/langref.html.in +++ b/doc/langref.html.in @@ -1188,6 +1188,7 @@ test "this will be skipped" { (The evented IO mode is enabled using the --test-evented-io command line parameter.)

{#code_begin|test|async_skip#} + {#backend_stage1#} const std = @import("std"); test "async skip test" { @@ -2768,7 +2769,7 @@ test "comptime @intToPtr" { } } {#code_end#} - {#see_also|Optional Pointers|@intToPtr|@ptrToInt|C Pointers|Pointers to Zero Bit Types#} + {#see_also|Optional Pointers|@intToPtr|@ptrToInt|C Pointers#} {#header_open|volatile#}

Loads and stores are assumed to not have side effects. If a given load or store should have side effects, such as Memory Mapped Input/Output (MMIO), use {#syntax#}volatile{#endsyntax#}. @@ -2862,19 +2863,22 @@ var foo: u8 align(4) = 100; test "global variable alignment" { try expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4); try expect(@TypeOf(&foo) == *align(4) u8); - const as_pointer_to_array: *[1]u8 = &foo; - const as_slice: []u8 = as_pointer_to_array; - try expect(@TypeOf(as_slice) == []align(4) u8); + const as_pointer_to_array: *align(4) [1]u8 = &foo; + const as_slice: []align(4) u8 = as_pointer_to_array; + const as_unaligned_slice: []u8 = as_slice; + try expect(as_unaligned_slice[0] == 100); } -fn derp() align(@sizeOf(usize) * 2) i32 { return 1234; } +fn derp() align(@sizeOf(usize) * 2) i32 { + return 1234; +} fn noop1() align(1) void {} fn noop4() align(4) void {} test "function alignment" { try expect(derp() == 1234); - try expect(@TypeOf(noop1) == fn() align(1) void); - try expect(@TypeOf(noop4) == fn() align(4) void); + try expect(@TypeOf(noop1) == fn () align(1) void); + try expect(@TypeOf(noop4) == fn () align(4) void); noop1(); noop4(); } @@ -3336,6 +3340,7 @@ fn doTheTest() !void { Zig allows the address to be taken of a non-byte-aligned field:

{#code_begin|test|pointer_to_non-byte_aligned_field#} + {#backend_stage1#} const std = @import("std"); const expect = std.testing.expect; @@ -3391,7 +3396,8 @@ fn bar(x: *const u3) u3 {

Pointers to non-ABI-aligned fields share the same address as the other fields within their host integer:

- {#code_begin|test|pointer_to_non-bit_aligned_field#} + {#code_begin|test|packed_struct_field_addrs#} + {#backend_stage1#} const std = @import("std"); const expect = std.testing.expect; @@ -3407,7 +3413,7 @@ var bit_field = BitField{ .c = 3, }; -test "pointer to non-bit-aligned field" { +test "pointers of sub-byte-aligned fields share addresses" { try expect(@ptrToInt(&bit_field.a) == @ptrToInt(&bit_field.b)); try expect(@ptrToInt(&bit_field.a) == @ptrToInt(&bit_field.c)); } @@ -3438,20 +3444,22 @@ test "pointer to non-bit-aligned field" { } {#code_end#}

- Packed structs have 1-byte alignment. However if you have an overaligned pointer to a packed struct, - Zig should correctly understand the alignment of fields. However there is - a bug: + Packed structs have the same alignment as their backing integer, however, overaligned + pointers to packed structs can override this:

- {#code_begin|test_err|expected type '*u32', found '*align(1) u32'#} + {#code_begin|test|overaligned_packed_struct#} +const std = @import("std"); +const expect = std.testing.expect; + const S = packed struct { a: u32, b: u32, }; test "overaligned pointer to packed struct" { - var foo: S align(4) = undefined; + var foo: S align(4) = .{ .a = 1, .b = 2 }; const ptr: *align(4) S = &foo; const ptr_to_b: *u32 = &ptr.b; - _ = ptr_to_b; + try expect(ptr_to_b.* == 2); } {#code_end#}

When this bug is fixed, the above test in the documentation will unexpectedly pass, which will @@ -3698,7 +3706,7 @@ test "@tagName" {

By default, enums are not guaranteed to be compatible with the C ABI:

- {#code_begin|obj_err|parameter of type 'Foo' not allowed in function with calling convention 'C'#} + {#code_begin|obj_err|parameter of type 'test.Foo' not allowed in function with calling convention 'C'#} const Foo = enum { a, b, c }; export fn entry(foo: Foo) void { _ = foo; } {#code_end#} @@ -4004,7 +4012,7 @@ fn makeNumber() Number { This is typically used for type safety when interacting with C code that does not expose struct details. Example:

- {#code_begin|test_err|expected type '*Derp', found '*Wat'#} + {#code_begin|test_err|expected type '*test.Derp', found '*test.Wat'#} const Derp = opaque {}; const Wat = opaque {}; @@ -4203,7 +4211,7 @@ test "switch on tagged union" { When a {#syntax#}switch{#endsyntax#} expression does not have an {#syntax#}else{#endsyntax#} clause, it must exhaustively list all the possible values. Failure to do so is a compile error:

- {#code_begin|test_err|not handled in switch#} + {#code_begin|test_err|unhandled enumeration value#} const Color = enum { auto, off, @@ -5026,17 +5034,9 @@ test "function" { try expect(do_op(sub2, 5, 6) == -1); } {#code_end#} -

Function values are like pointers:

- {#code_begin|obj#} -const assert = @import("std").debug.assert; - -comptime { - assert(@TypeOf(foo) == fn()void); - assert(@sizeOf(fn()void) == @sizeOf(?fn()void)); -} - -fn foo() void { } - {#code_end#} +

There is a difference between a function body and a function pointer. + Function bodies are {#link|comptime#}-only types while function {#link|Pointers#} may be + runtime-known.

{#header_open|Pass-by-value Parameters#}

Primitive types such as {#link|Integers#} and {#link|Floats#} passed as parameters @@ -6123,10 +6123,11 @@ test "float widening" { two choices about the coercion.

{#code_begin|test_err#} + {#backend_stage1#} // Compile time coercion of float to int test "implicit cast to comptime_int" { var f: f32 = 54.0 / 5; @@ -6302,19 +6303,6 @@ test "coercion between unions and enums" { {#code_end#} {#see_also|union|enum#} {#header_close#} - {#header_open|Type Coercion: Zero Bit Types#} -

{#link|Zero Bit Types#} may be coerced to single-item {#link|Pointers#}, - regardless of const.

-

TODO document the reasoning for this

-

TODO document whether vice versa should work and why

- {#code_begin|test|coerce_zero_bit_types#} -test "coercion of zero bit types" { - var x: void = {}; - var y: *void = x; - _ = y; -} - {#code_end#} - {#header_close#} {#header_open|Type Coercion: undefined#}

{#link|undefined#} can be cast to any type.

{#header_close#} @@ -6467,7 +6455,6 @@ test "peer type resolution: *const T and ?*T" {
  • An {#link|enum#} with only 1 tag.
  • A {#link|struct#} with all fields being zero bit types.
  • A {#link|union#} with only 1 field which is a zero bit type.
    • -
  • {#link|Pointers to Zero Bit Types#} are themselves zero bit types.

    • These types can only ever have one possible value, and thus @@ -6527,7 +6514,7 @@ test "turn HashMap into a set with void" {

    Expressions of type {#syntax#}void{#endsyntax#} are the only ones whose value can be ignored. For example:

    - {#code_begin|test_err|expression value is ignored#} + {#code_begin|test_err|ignored#} test "ignoring expression value" { foo(); } @@ -6553,37 +6540,6 @@ fn foo() i32 { } {#code_end#} {#header_close#} - - {#header_open|Pointers to Zero Bit Types#} -

    Pointers to zero bit types also have zero bits. They always compare equal to each other:

    - {#code_begin|test|pointers_to_zero_bits#} -const std = @import("std"); -const expect = std.testing.expect; - -test "pointer to empty struct" { - const Empty = struct {}; - var a = Empty{}; - var b = Empty{}; - var ptr_a = &a; - var ptr_b = &b; - comptime try expect(ptr_a == ptr_b); -} - {#code_end#} -

    The type being pointed to can only ever be one value; therefore loads and stores are - never generated. {#link|ptrToInt#} and {#link|intToPtr#} are not allowed:

    - {#code_begin|test_err#} -const Empty = struct {}; - -test "@ptrToInt for pointer to zero bit type" { - var a = Empty{}; - _ = @ptrToInt(&a); -} - -test "@intToPtr for pointer to zero bit type" { - _ = @intToPtr(*Empty, 0x1); -} - {#code_end#} - {#header_close#} {#header_close#} {#header_open|Result Location Semantics#} @@ -6666,7 +6622,7 @@ fn gimmeTheBiggerInteger(a: u64, b: u64) u64 {

    For example, if we were to introduce another function to the above snippet:

    - {#code_begin|test_err|values of type 'type' must be comptime known#} + {#code_begin|test_err|value with comptime only type 'type' depends on runtime control flow#} fn max(comptime T: type, a: T, b: T) T { return if (a > b) a else b; } @@ -6692,7 +6648,7 @@ fn foo(condition: bool) void {

    For example:

    - {#code_begin|test_err|operator not allowed for type 'bool'#} + {#code_begin|test_err|operator > not allowed for type 'bool'#} fn max(comptime T: type, a: T, b: T) T { return if (a > b) a else b; } @@ -6837,7 +6793,7 @@ fn performFn(start_value: i32) i32 { use a {#syntax#}comptime{#endsyntax#} expression to guarantee that the expression will be evaluated at compile-time. If this cannot be accomplished, the compiler will emit an error. For example:

    - {#code_begin|test_err|unable to evaluate constant expression#} + {#code_begin|test_err|comptime call of extern function#} extern fn exit() noreturn; test "foo" { @@ -6889,7 +6845,7 @@ test "fibonacci" {

    Imagine if we had forgotten the base case of the recursive function and tried to run the tests:

    - {#code_begin|test_err|operation caused overflow#} + {#code_begin|test_err|overflow of integer type#} const expect = @import("std").testing.expect; fn fibonacci(index: u32) u32 { @@ -6913,7 +6869,8 @@ test "fibonacci" { But what would have happened if we used a signed integer?

    {#code_begin|test_err|evaluation exceeded 1000 backwards branches#} -const expect = @import("std").testing.expect; + {#backend_stage1#} +const assert = @import("std").debug.assert; fn fibonacci(index: i32) i32 { //if (index < 2) return index; @@ -6922,7 +6879,7 @@ fn fibonacci(index: i32) i32 { test "fibonacci" { comptime { - try expect(fibonacci(7) == 13); + try assert(fibonacci(7) == 13); } } {#code_end#} @@ -6935,8 +6892,8 @@ test "fibonacci" {

    What if we fix the base case, but put the wrong value in the {#syntax#}expect{#endsyntax#} line?

    - {#code_begin|test_err|test "fibonacci"... FAIL (TestUnexpectedResult)#} -const expect = @import("std").testing.expect; + {#code_begin|test_err|reached unreachable#} +const assert = @import("std").debug.assert; fn fibonacci(index: i32) i32 { if (index < 2) return index; @@ -6945,16 +6902,10 @@ fn fibonacci(index: i32) i32 { test "fibonacci" { comptime { - try expect(fibonacci(7) == 99999); + try assert(fibonacci(7) == 99999); } } {#code_end#} -

    - What happened is Zig started interpreting the {#syntax#}expect{#endsyntax#} function with the - parameter {#syntax#}ok{#endsyntax#} set to {#syntax#}false{#endsyntax#}. When the interpreter hit - {#syntax#}@panic{#endsyntax#} it emitted a compile error because a panic during compile - causes a compile error if it is detected at compile-time. -

    At container level (outside of any function), all expressions are implicitly @@ -7280,6 +7231,7 @@ pub fn main() void {

    {#code_begin|exe#} {#target_linux_x86_64#} + {#backend_stage1#} pub fn main() noreturn { const msg = "hello world\n"; _ = syscall3(SYS_write, STDOUT_FILENO, @ptrToInt(msg), msg.len); @@ -7497,6 +7449,7 @@ test "global assembly" { or resumer (in the case of subsequent suspensions).

    {#code_begin|test|suspend_no_resume#} + {#backend_stage1#} const std = @import("std"); const expect = std.testing.expect; @@ -7524,6 +7477,7 @@ fn func() void { {#link|@frame#} provides access to the async function frame pointer.

    {#code_begin|test|async_suspend_block#} + {#backend_stage1#} const std = @import("std"); const expect = std.testing.expect; @@ -7562,6 +7516,7 @@ fn testSuspendBlock() void { never returns to its resumer and continues executing.

    {#code_begin|test|resume_from_suspend#} + {#backend_stage1#} const std = @import("std"); const expect = std.testing.expect; @@ -7598,6 +7553,7 @@ fn testResumeFromSuspend(my_result: *i32) void { and the return value of the async function would be lost.

    {#code_begin|test|async_await#} + {#backend_stage1#} const std = @import("std"); const expect = std.testing.expect; @@ -7642,6 +7598,7 @@ fn func() void { return value directly from the target function's frame.

    {#code_begin|test|async_await_sequence#} + {#backend_stage1#} const std = @import("std"); const expect = std.testing.expect; @@ -7695,6 +7652,7 @@ fn seq(c: u8) void { {#syntax#}async{#endsyntax#}/{#syntax#}await{#endsyntax#} usage:

    {#code_begin|exe|async#} + {#backend_stage1#} const std = @import("std"); const Allocator = std.mem.Allocator; @@ -7773,6 +7731,7 @@ fn readFile(allocator: Allocator, filename: []const u8) ![]u8 { observe the same behavior, with one tiny difference:

    {#code_begin|exe|blocking#} + {#backend_stage1#} const std = @import("std"); const Allocator = std.mem.Allocator; @@ -7910,6 +7869,7 @@ comptime { {#syntax#}await{#endsyntax#} will copy the result from {#syntax#}result_ptr{#endsyntax#}.

    {#code_begin|test|async_struct_field_fn_pointer#} + {#backend_stage1#} const std = @import("std"); const expect = std.testing.expect; @@ -8677,6 +8637,7 @@ test "decl access by string" { allows one to, for example, heap-allocate an async function frame:

    {#code_begin|test|heap_allocated_frame#} + {#backend_stage1#} const std = @import("std"); test "heap allocated frame" { @@ -9423,12 +9384,6 @@ const std = @import("std"); const expect = std.testing.expect; test "vector @reduce" { - // This test regressed with LLVM 14: - // https://github.com/llvm/llvm-project/issues/55522 - // We'll skip this test unless the self-hosted compiler is being used. - // After LLVM 15 is released we can delete this line. - if (@import("builtin").zig_backend == .stage1) return; - const value = @Vector(4, i32){ 1, -1, 1, -1 }; const result = value > @splat(4, @as(i32, 0)); // result is { true, false, true, false }; @@ -9938,7 +9893,7 @@ pub fn main() void { {#header_close#} {#header_open|Index out of Bounds#}

    At compile-time:

    - {#code_begin|test_err|index 5 outside array of size 5#} + {#code_begin|test_err|index 5 outside array of length 5#} comptime { const array: [5]u8 = "hello".*; const garbage = array[5]; @@ -9959,9 +9914,9 @@ fn foo(x: []const u8) u8 { {#header_close#} {#header_open|Cast Negative Number to Unsigned Integer#}

    At compile-time:

    - {#code_begin|test_err|attempt to cast negative value to unsigned integer#} + {#code_begin|test_err|type 'u32' cannot represent integer value '-1'#} comptime { - const value: i32 = -1; + var value: i32 = -1; const unsigned = @intCast(u32, value); _ = unsigned; } @@ -9982,7 +9937,7 @@ pub fn main() void { {#header_close#} {#header_open|Cast Truncates Data#}

    At compile-time:

    - {#code_begin|test_err|cast from 'u16' to 'u8' truncates bits#} + {#code_begin|test_err|type 'u8' cannot represent integer value '300'#} comptime { const spartan_count: u16 = 300; const byte = @intCast(u8, spartan_count); @@ -10017,7 +9972,7 @@ pub fn main() void {
  • {#link|@divExact#} (division)

    • Example with addition at compile-time:

    - {#code_begin|test_err|operation caused overflow#} + {#code_begin|test_err|overflow of integer type 'u8' with value '256'#} comptime { var byte: u8 = 255; byte += 1; @@ -10118,6 +10073,7 @@ test "wraparound addition and subtraction" { {#header_open|Exact Left Shift Overflow#}

    At compile-time:

    {#code_begin|test_err|operation caused overflow#} + {#backend_stage1#} comptime { const x = @shlExact(@as(u8, 0b01010101), 2); _ = x; @@ -10137,6 +10093,7 @@ pub fn main() void { {#header_open|Exact Right Shift Overflow#}

    At compile-time:

    {#code_begin|test_err|exact shift shifted out 1 bits#} + {#backend_stage1#} comptime { const x = @shrExact(@as(u8, 0b10101010), 2); _ = x; @@ -10200,6 +10157,7 @@ pub fn main() void { {#header_open|Exact Division Remainder#}

    At compile-time:

    {#code_begin|test_err|exact division had a remainder#} + {#backend_stage1#} comptime { const a: u32 = 10; const b: u32 = 3; @@ -10302,7 +10260,7 @@ fn getNumberOrFail() !i32 { {#header_close#} {#header_open|Invalid Error Code#}

    At compile-time:

    - {#code_begin|test_err|integer value 11 represents no error#} + {#code_begin|test_err|integer value '11' represents no error#} comptime { const err = error.AnError; const number = @errorToInt(err) + 10; @@ -10324,7 +10282,7 @@ pub fn main() void { {#header_close#} {#header_open|Invalid Enum Cast#}

    At compile-time:

    - {#code_begin|test_err|has no tag matching integer value 3#} + {#code_begin|test_err|enum 'test.Foo' has no tag with value '3'#} const Foo = enum { a, b, @@ -10356,7 +10314,7 @@ pub fn main() void { {#header_open|Invalid Error Set Cast#}

    At compile-time:

    - {#code_begin|test_err|error.B not a member of error set 'Set2'#} + {#code_begin|test_err|'error.B' not a member of error set 'error{A,C}'#} const Set1 = error{ A, B, @@ -10417,7 +10375,7 @@ fn foo(bytes: []u8) u32 { {#header_close#} {#header_open|Wrong Union Field Access#}

    At compile-time:

    - {#code_begin|test_err|accessing union field 'float' while field 'int' is set#} + {#code_begin|test_err|access of union field 'float' while field 'int' is active#} comptime { var f = Foo{ .int = 42 }; f.float = 12.34; @@ -10509,6 +10467,7 @@ fn bar(f: *Foo) void {

    At compile-time:

    {#code_begin|test_err|null pointer casted to type#} + {#backend_stage1#} comptime { const opt_ptr: ?*i32 = null; const ptr = @ptrCast(*i32, opt_ptr); @@ -10551,7 +10510,8 @@ const expect = std.testing.expect; test "using an allocator" { var buffer: [100]u8 = undefined; - const allocator = std.heap.FixedBufferAllocator.init(&buffer).allocator(); + var fba = std.heap.FixedBufferAllocator.init(&buffer); + const allocator = fba.allocator(); const result = try concat(allocator, "foo", "bar"); try expect(std.mem.eql(u8, "foobar", result)); } @@ -10647,7 +10607,7 @@ pub fn main() !void {

    String literals such as {#syntax#}"foo"{#endsyntax#} are in the global constant data section. This is why it is an error to pass a string literal to a mutable slice, like this:

    - {#code_begin|test_err|cannot cast pointer to array literal to slice type '[]u8'#} + {#code_begin|test_err|expected type '[]u8', found '*const [5:0]u8'#} fn foo(s: []u8) void { _ = s; } diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index 2c2bc92c9602..69312df83853 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -866,7 +866,7 @@ pub fn panicUnwrapError(st: ?*StackTrace, err: anyerror) noreturn { pub fn panicOutOfBounds(index: usize, len: usize) noreturn { @setCold(true); - std.debug.panic("attempt to index out of bound: index {d}, len {d}", .{ index, len }); + std.debug.panic("index out of bounds: index {d}, len {d}", .{ index, len }); } pub noinline fn returnError(st: *StackTrace) void { diff --git a/src/Compilation.zig b/src/Compilation.zig index 6d778b955a01..84dd2739470a 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -1040,22 +1040,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation { const comp = try arena.create(Compilation); const root_name = try arena.dupeZ(u8, options.root_name); - const use_stage1 = options.use_stage1 orelse blk: { - // Even though we may have no Zig code to compile (depending on `options.main_pkg`), - // we may need to use stage1 for building compiler-rt and other dependencies. - - if (options.use_llvm) |use_llvm| { - if (!use_llvm) { - break :blk false; - } - } - - // If LLVM does not support the target, then we can't use it. - if (!target_util.hasLlvmSupport(options.target, options.target.ofmt)) - break :blk false; - - break :blk build_options.is_stage1; - }; + const use_stage1 = options.use_stage1 orelse false; const cache_mode = if (use_stage1 and !options.disable_lld_caching) CacheMode.whole @@ -2211,7 +2196,7 @@ pub fn update(comp: *Compilation) !void { comp.c_object_work_queue.writeItemAssumeCapacity(key); } - const use_stage1 = build_options.is_stage1 and comp.bin_file.options.use_stage1; + const use_stage1 = build_options.have_stage1 and comp.bin_file.options.use_stage1; if (comp.bin_file.options.module) |module| { module.compile_log_text.shrinkAndFree(module.gpa, 0); module.generation += 1; @@ -2387,7 +2372,7 @@ fn flush(comp: *Compilation, prog_node: *std.Progress.Node) !void { }; comp.link_error_flags = comp.bin_file.errorFlags(); - const use_stage1 = build_options.is_stage1 and comp.bin_file.options.use_stage1; + const use_stage1 = build_options.have_stage1 and comp.bin_file.options.use_stage1; if (!use_stage1) { if (comp.bin_file.options.module) |module| { try link.File.C.flushEmitH(module); @@ -2845,7 +2830,7 @@ pub fn performAllTheWork( comp.work_queue_wait_group.reset(); defer comp.work_queue_wait_group.wait(); - const use_stage1 = build_options.is_stage1 and comp.bin_file.options.use_stage1; + const use_stage1 = build_options.have_stage1 and comp.bin_file.options.use_stage1; { const astgen_frame = tracy.namedFrame("astgen"); @@ -3430,7 +3415,7 @@ pub fn cImport(comp: *Compilation, c_src: []const u8) !CImportResult { var man = comp.obtainCObjectCacheManifest(); defer man.deinit(); - const use_stage1 = build_options.is_stage1 and comp.bin_file.options.use_stage1; + const use_stage1 = build_options.have_stage1 and comp.bin_file.options.use_stage1; man.hash.add(@as(u16, 0xb945)); // Random number to distinguish translate-c from compiling C objects man.hash.add(use_stage1); @@ -4745,7 +4730,7 @@ pub fn generateBuiltinZigSource(comp: *Compilation, allocator: Allocator) Alloca const target = comp.getTarget(); const generic_arch_name = target.cpu.arch.genericName(); - const use_stage1 = build_options.is_stage1 and comp.bin_file.options.use_stage1; + const use_stage1 = build_options.have_stage1 and comp.bin_file.options.use_stage1; const zig_backend: std.builtin.CompilerBackend = blk: { if (use_stage1) break :blk .stage1; @@ -5032,7 +5017,7 @@ fn buildOutputFromZig( .link_mode = .Static, .function_sections = true, .no_builtin = true, - .use_stage1 = build_options.is_stage1 and comp.bin_file.options.use_stage1, + .use_stage1 = build_options.have_stage1 and comp.bin_file.options.use_stage1, .want_sanitize_c = false, .want_stack_check = false, .want_stack_protector = 0, diff --git a/src/config.zig.in b/src/config.zig.in index 336a6c45edae..12e13815f84c 100644 --- a/src/config.zig.in +++ b/src/config.zig.in @@ -8,5 +8,5 @@ pub const enable_logging: bool = @ZIG_ENABLE_LOGGING_BOOL@; pub const enable_link_snapshots: bool = false; pub const enable_tracy = false; pub const value_tracing = false; -pub const is_stage1 = true; +pub const have_stage1 = true; pub const skip_non_native = false; diff --git a/src/link.zig b/src/link.zig index a0c0c5c369ee..a85969d61eb7 100644 --- a/src/link.zig +++ b/src/link.zig @@ -279,7 +279,7 @@ pub const File = struct { return &(try MachO.openPath(allocator, options)).base; } - const use_stage1 = build_options.is_stage1 and options.use_stage1; + const use_stage1 = build_options.have_stage1 and options.use_stage1; if (use_stage1 or options.emit == null) { return switch (options.target.ofmt) { .coff => &(try Coff.createEmpty(allocator, options)).base, @@ -817,7 +817,7 @@ pub const File = struct { // If there is no Zig code to compile, then we should skip flushing the output file // because it will not be part of the linker line anyway. const module_obj_path: ?[]const u8 = if (base.options.module) |module| blk: { - const use_stage1 = build_options.is_stage1 and base.options.use_stage1; + const use_stage1 = build_options.have_stage1 and base.options.use_stage1; if (use_stage1) { const obj_basename = try std.zig.binNameAlloc(arena, .{ .root_name = base.options.root_name, diff --git a/src/link/Coff.zig b/src/link/Coff.zig index 92e9dce3ad28..a01b9cf7c3ac 100644 --- a/src/link/Coff.zig +++ b/src/link/Coff.zig @@ -411,7 +411,7 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !*Coff { }; const use_llvm = build_options.have_llvm and options.use_llvm; - const use_stage1 = build_options.is_stage1 and options.use_stage1; + const use_stage1 = build_options.have_stage1 and options.use_stage1; if (use_llvm and !use_stage1) { self.llvm_object = try LlvmObject.create(gpa, options); } @@ -949,7 +949,7 @@ fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Node) ! // If there is no Zig code to compile, then we should skip flushing the output file because it // will not be part of the linker line anyway. const module_obj_path: ?[]const u8 = if (self.base.options.module) |module| blk: { - const use_stage1 = build_options.is_stage1 and self.base.options.use_stage1; + const use_stage1 = build_options.have_stage1 and self.base.options.use_stage1; if (use_stage1) { const obj_basename = try std.zig.binNameAlloc(arena, .{ .root_name = self.base.options.root_name, diff --git a/src/link/Elf.zig b/src/link/Elf.zig index 9902886baca5..ade4f62f91e2 100644 --- a/src/link/Elf.zig +++ b/src/link/Elf.zig @@ -328,7 +328,7 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !*Elf { .page_size = page_size, }; const use_llvm = build_options.have_llvm and options.use_llvm; - const use_stage1 = build_options.is_stage1 and options.use_stage1; + const use_stage1 = build_options.have_stage1 and options.use_stage1; if (use_llvm and !use_stage1) { self.llvm_object = try LlvmObject.create(gpa, options); } diff --git a/src/link/MachO.zig b/src/link/MachO.zig index 7a5084302363..020388cee871 100644 --- a/src/link/MachO.zig +++ b/src/link/MachO.zig @@ -272,7 +272,7 @@ pub const Export = struct { pub fn openPath(allocator: Allocator, options: link.Options) !*MachO { assert(options.target.ofmt == .macho); - const use_stage1 = build_options.is_stage1 and options.use_stage1; + const use_stage1 = build_options.have_stage1 and options.use_stage1; if (use_stage1 or options.emit == null) { return createEmpty(allocator, options); } @@ -363,7 +363,7 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !*MachO { const cpu_arch = options.target.cpu.arch; const page_size: u16 = if (cpu_arch == .aarch64) 0x4000 else 0x1000; const use_llvm = build_options.have_llvm and options.use_llvm; - const use_stage1 = build_options.is_stage1 and options.use_stage1; + const use_stage1 = build_options.have_stage1 and options.use_stage1; const self = try gpa.create(MachO); errdefer gpa.destroy(self); diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig index 626786588873..626f17665215 100644 --- a/src/link/Wasm.zig +++ b/src/link/Wasm.zig @@ -356,7 +356,7 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !*Wasm { } const use_llvm = build_options.have_llvm and options.use_llvm; - const use_stage1 = build_options.is_stage1 and options.use_stage1; + const use_stage1 = build_options.have_stage1 and options.use_stage1; if (use_llvm and !use_stage1) { self.llvm_object = try LlvmObject.create(gpa, options); } @@ -2593,7 +2593,7 @@ fn linkWithLLD(self: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) ! // If there is no Zig code to compile, then we should skip flushing the output file because it // will not be part of the linker line anyway. const module_obj_path: ?[]const u8 = if (self.base.options.module) |mod| blk: { - const use_stage1 = build_options.is_stage1 and self.base.options.use_stage1; + const use_stage1 = build_options.have_stage1 and self.base.options.use_stage1; if (use_stage1) { const obj_basename = try std.zig.binNameAlloc(arena, .{ .root_name = self.base.options.root_name, @@ -2803,7 +2803,7 @@ fn linkWithLLD(self: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) ! if (self.base.options.module) |mod| { // when we use stage1, we use the exports that stage1 provided us. // For stage2, we can directly retrieve them from the module. - const use_stage1 = build_options.is_stage1 and self.base.options.use_stage1; + const use_stage1 = build_options.have_stage1 and self.base.options.use_stage1; if (use_stage1) { for (comp.export_symbol_names.items) |symbol_name| { try argv.append(try std.fmt.allocPrint(arena, "--export={s}", .{symbol_name})); diff --git a/src/main.zig b/src/main.zig index 91d171d23764..dd3a7e797bdb 100644 --- a/src/main.zig +++ b/src/main.zig @@ -2989,7 +2989,7 @@ fn buildOutputType( return std.io.getStdOut().writeAll(try comp.generateBuiltinZigSource(arena)); } if (arg_mode == .translate_c) { - const stage1_mode = use_stage1 orelse build_options.is_stage1; + const stage1_mode = use_stage1 orelse false; return cmdTranslateC(comp, arena, have_enable_cache, stage1_mode); } diff --git a/src/stage1.zig b/src/stage1.zig index 826fdd0f6bb9..e3f0daaa4450 100644 --- a/src/stage1.zig +++ b/src/stage1.zig @@ -18,7 +18,7 @@ const target_util = @import("target.zig"); comptime { assert(builtin.link_libc); - assert(build_options.is_stage1); + assert(build_options.have_stage1); assert(build_options.have_llvm); if (!builtin.is_test) { @export(main, .{ .name = "main" }); diff --git a/src/test.zig b/src/test.zig index a8567f24928b..babded13f9d7 100644 --- a/src/test.zig +++ b/src/test.zig @@ -25,7 +25,7 @@ const skip_stage1 = builtin.zig_backend != .stage1 or build_options.skip_stage1; const hr = "=" ** 80; test { - if (build_options.is_stage1) { + if (build_options.have_stage1) { @import("stage1.zig").os_init(); } diff --git a/test/cases/safety/empty slice with sentinel out of bounds.zig b/test/cases/safety/empty slice with sentinel out of bounds.zig index 835b084740c5..d989a33541c1 100644 --- a/test/cases/safety/empty slice with sentinel out of bounds.zig +++ b/test/cases/safety/empty slice with sentinel out of bounds.zig @@ -2,7 +2,7 @@ const std = @import("std"); pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to index out of bound: index 1, len 0")) { + if (std.mem.eql(u8, message, "index out of bounds: index 1, len 0")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/out of bounds slice access.zig b/test/cases/safety/out of bounds slice access.zig index a30532aee78c..ddd9e74cf285 100644 --- a/test/cases/safety/out of bounds slice access.zig +++ b/test/cases/safety/out of bounds slice access.zig @@ -2,20 +2,20 @@ const std = @import("std"); pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to index out of bound: index 4, len 4")) { + if (std.mem.eql(u8, message, "index out of bounds: index 4, len 4")) { std.process.exit(0); } std.process.exit(1); } pub fn main() !void { - const a = [_]i32{1, 2, 3, 4}; + const a = [_]i32{ 1, 2, 3, 4 }; baz(bar(&a)); return error.TestFailed; } fn bar(a: []const i32) i32 { return a[4]; } -fn baz(_: i32) void { } +fn baz(_: i32) void {} // run // backend=llvm // target=native diff --git a/test/cases/safety/slice with sentinel out of bounds - runtime len.zig b/test/cases/safety/slice with sentinel out of bounds - runtime len.zig index fa2e127107c8..524c69d7b7dd 100644 --- a/test/cases/safety/slice with sentinel out of bounds - runtime len.zig +++ b/test/cases/safety/slice with sentinel out of bounds - runtime len.zig @@ -2,7 +2,7 @@ const std = @import("std"); pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to index out of bound: index 5, len 4")) { + if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/slice with sentinel out of bounds.zig b/test/cases/safety/slice with sentinel out of bounds.zig index 3cc8bfb355a4..636235a5b34c 100644 --- a/test/cases/safety/slice with sentinel out of bounds.zig +++ b/test/cases/safety/slice with sentinel out of bounds.zig @@ -2,7 +2,7 @@ const std = @import("std"); pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to index out of bound: index 5, len 4")) { + if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/tests.zig b/test/tests.zig index e1836dc1e010..bd3c1c5dec39 100644 --- a/test/tests.zig +++ b/test/tests.zig @@ -601,7 +601,6 @@ pub fn addPkgTests( skip_libc: bool, skip_stage1: bool, skip_stage2: bool, - is_stage1: bool, ) *build.Step { const step = b.step(b.fmt("test-{s}", .{name}), desc); @@ -630,7 +629,7 @@ pub fn addPkgTests( if (test_target.backend) |backend| switch (backend) { .stage1 => if (skip_stage1) continue, else => if (skip_stage2) continue, - } else if (is_stage1 and skip_stage1) continue; + } else if (skip_stage2) continue; const want_this_mode = for (modes) |m| { if (m == test_target.mode) break true;