Release 0.14.1

It's incorrect to ever set `include_reference_trace` here, because the
compiler has already given or not given reference traces depending on
the `-freference-trace` option propagated to the compiler process by
`std.Build.Step.Compile`.

Perhaps in future we could make the compiler always return the reference
trace when communicating over the compiler protocol; that'd be more
versatile than the current behavior, because the build runner could, for
instance, show a reference trace on-demand without having to even invoke
the compiler. That seems really useful, since the reference trace is
*often* unnecessary noise, but *sometimes* essential. However, we don't
live in that world right now, so passing the option here doesn't make
sense.

Resolves: #23415

.forgejo/ISSUE_TEMPLATE/config.yml

@@ -1,13 +0,0 @@
-contact_links:
-  - name: Language Proposal
-    about: "Please do not submit a proposal to change the language"
-    url: https://ziglang.org/code-of-conduct/#no-language-proposals
-  - name: Question
-    about: "Please use one of the community spaces instead for questions or general discussions."
-    url: https://ziglang.org/community
-  - name: C Translation
-    about: "Issues related to `zig translate-c` and `@cImport` are tracked separately."
-    url: https://codeberg.org/ziglang/translate-c
-  - name: Copilot and Other LLMs
-    about: "Please do not use GitHub Copilot or any other LLM to write an issue."
-    url: https://ziglang.org/code-of-conduct/#strict-no-llm-no-ai-policy

.forgejo/workflows/ci.yaml

@@ -1,303 +0,0 @@
-name: ci
-
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-  workflow_dispatch:
-
-# This cancels older workflow runs on pull requests while ensuring that there
-# are no concurrency limits on pushes and manual workflow dispatches.
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-
-permissions:
-  contents: read
-
-jobs:
-  aarch64-freebsd-debug:
-    runs-on: [self-hosted, aarch64-freebsd]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/aarch64-freebsd-debug.sh
-        timeout-minutes: 300
-  aarch64-freebsd-release:
-    runs-on: [self-hosted, aarch64-freebsd]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/aarch64-freebsd-release.sh
-        timeout-minutes: 240
-
-  aarch64-linux-debug:
-    runs-on: [self-hosted, aarch64-linux]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/aarch64-linux-debug.sh
-        timeout-minutes: 180
-  aarch64-linux-release:
-    runs-on: [self-hosted, aarch64-linux]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/aarch64-linux-release.sh
-        timeout-minutes: 120
-
-  aarch64-netbsd-debug:
-    runs-on: [self-hosted, aarch64-netbsd]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/aarch64-netbsd-debug.sh
-        timeout-minutes: 300
-  aarch64-netbsd-release:
-    runs-on: [self-hosted, aarch64-netbsd]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/aarch64-netbsd-release.sh
-        timeout-minutes: 240
-
-  aarch64-macos-debug:
-    runs-on: [self-hosted, aarch64-macos]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/aarch64-macos-debug.sh
-        timeout-minutes: 180
-  aarch64-macos-release:
-    runs-on: [self-hosted, aarch64-macos]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/aarch64-macos-release.sh
-        timeout-minutes: 120
-
-  loongarch64-linux-debug:
-    runs-on: [self-hosted, loongarch64-linux]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/loongarch64-linux-debug.sh
-        timeout-minutes: 240
-  loongarch64-linux-release:
-    runs-on: [self-hosted, loongarch64-linux]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/loongarch64-linux-release.sh
-        timeout-minutes: 180
-
-  powerpc64le-linux-debug:
-    runs-on: [self-hosted, powerpc64le-linux]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/powerpc64le-linux-debug.sh
-        timeout-minutes: 360
-  powerpc64le-linux-release:
-    runs-on: [self-hosted, powerpc64le-linux]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/powerpc64le-linux-release.sh
-        timeout-minutes: 240
-
-  riscv64-linux-debug:
-    if: github.event_name != 'pull_request'
-    runs-on: [self-hosted, riscv64-linux]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/riscv64-linux-debug.sh
-        timeout-minutes: 660
-  riscv64-linux-release:
-    if: github.event_name != 'pull_request'
-    runs-on: [self-hosted, riscv64-linux]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/riscv64-linux-release.sh
-        timeout-minutes: 540
-
-  s390x-linux-debug:
-    runs-on: [self-hosted, s390x-linux]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/s390x-linux-debug.sh
-        timeout-minutes: 360
-  s390x-linux-release:
-    runs-on: [self-hosted, s390x-linux]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/s390x-linux-release.sh
-        timeout-minutes: 300
-
-  x86_64-freebsd-debug:
-    runs-on: [self-hosted, x86_64-freebsd]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/x86_64-freebsd-debug.sh
-        timeout-minutes: 120
-  x86_64-freebsd-release:
-    runs-on: [self-hosted, x86_64-freebsd]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/x86_64-freebsd-release.sh
-        timeout-minutes: 120
-
-  x86_64-linux-debug:
-    runs-on: [self-hosted, x86_64-linux]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/x86_64-linux-debug.sh
-        timeout-minutes: 180
-  x86_64-linux-debug-llvm:
-    runs-on: [self-hosted, x86_64-linux]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/x86_64-linux-debug-llvm.sh
-        timeout-minutes: 360
-  x86_64-linux-release:
-    runs-on: [self-hosted, x86_64-linux]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/x86_64-linux-release.sh
-        timeout-minutes: 360
-
-  x86_64-netbsd-debug:
-    runs-on: [self-hosted, x86_64-netbsd]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/x86_64-netbsd-debug.sh
-        timeout-minutes: 120
-  x86_64-netbsd-release:
-    runs-on: [self-hosted, x86_64-netbsd]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/x86_64-netbsd-release.sh
-        timeout-minutes: 120
-
-  x86_64-openbsd-debug:
-    runs-on: [self-hosted, x86_64-openbsd]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/x86_64-openbsd-debug.sh
-        timeout-minutes: 120
-  x86_64-openbsd-release:
-    runs-on: [self-hosted, x86_64-openbsd]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: sh ci/x86_64-openbsd-release.sh
-        timeout-minutes: 120
-
-  x86_64-windows-debug:
-    runs-on: [self-hosted, x86_64-windows]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: ci/x86_64-windows-debug.ps1
-        timeout-minutes: 180
-  x86_64-windows-release:
-    runs-on: [self-hosted, x86_64-windows]
-    steps:
-      - name: Checkout
-        uses: https://codeberg.org/ziglang/checkout@19af6bac491e2534a4687a50ee84fa7f13258d28
-        with:
-          fetch-depth: 0
-      - name: Build and Test
-        run: ci/x86_64-windows-release.ps1
-        timeout-minutes: 180

.gitattributes

@@ -2,24 +2,14 @@
 *.zon text eol=lf
 *.txt text eol=lf
 langref.html.in text eol=lf
-
-lib/libc/*/abilists binary
-
 lib/std/compress/testdata/** binary
+lib/std/compress/deflate/testdata/** binary
 lib/std/compress/flate/testdata/** binary
-lib/std/compress/lzma/testdata/** binary
-lib/std/compress/xz/testdata/** binary
-lib/std/crypto/codecs/asn1/der/testdata/** binary
-lib/std/tar/testdata/** binary
-src/Package/Fetch/testdata/** binary
-src/Package/Fetch/git/testdata/** binary
 
-lib/compiler/aro/** linguist-vendored
-lib/compiler/resinator/** linguist-vendored
-lib/compiler/translate-c/** linguist-vendored
 lib/include/** linguist-vendored
 lib/libc/** linguist-vendored
 lib/libcxx/** linguist-vendored
 lib/libcxxabi/** linguist-vendored
-lib/libtsan/** linguist-vendored
 lib/libunwind/** linguist-vendored
+lib/tsan/** linguist-vendored
+lib/compiler/aro/** linguist-vendored

.github/CODE_OF_CONDUCT.md

@@ -0,0 +1,75 @@
+# Code of Conduct
+
+Hello, and welcome! 👋 
+
+The Zig community is decentralized. Anyone is free to start and maintain their
+own space for people to gather, and edit
+[the Community wiki page](https://github.com/ziglang/zig/wiki/Community) to add
+a link. There is no concept of "official" or "unofficial", however, each
+gathering place has its own moderators and rules.
+
+This is Andrew Kelley speaking. At least for now, I'm the moderator of the
+ziglang organization GitHub repositories and the #zig IRC channel on Libera.chat.
+**This document contains the rules that govern these two spaces only**.
+
+The rules here are strict. This space is for focused, on topic, technical work
+on the Zig project only. It is everyone's responsibility to maintain a positive
+environment, especially when disagreements occur.
+
+## Our Standards
+
+Examples of behavior that contribute to creating a positive environment include:
+
+ * Using welcoming and inclusive language.
+ * Being respectful of differing viewpoints and experiences.
+ * Gracefully accepting constructive criticism.
+ * Helping another person accomplish their own goals.
+ * Showing empathy towards others.
+ * Showing appreciation for others' work.
+ * Validating someone else's experience, skills, insight, and use cases.
+
+Examples of unacceptable behavior by participants include:
+
+ * Unwelcome sexual attention or advances, or use of sexualized language or
+   imagery that causes discomfort.
+ * Trolling, insulting/derogatory comments, and personal attacks. Anything
+   antagonistic towards someone else.
+ * Off-topic discussion of any kind - especially offensive or sensitive issues.
+ * Publishing others' private information, such as a physical or electronic
+   address, without explicit permission.
+ * Discussing this Code of Conduct or publicly accusing someone of violating it.
+ * Making someone else feel like an outsider or implying a lack of technical
+   abilities.
+ * Destructive behavior. Anything that harms Zig or another open-source project.
+
+## Enforcement
+
+If you need to report an issue you can contact me or Loris Cro, who are both
+paid by the Zig Software Foundation, and so moderation of this space is part of
+our job. We will swiftly remove anyone who is antagonizing others or being
+generally destructive.
+
+This includes Private Harassment. If person A is directly harassed or
+antagonized by person B, person B will be blocked from participating in this
+space even if the harassment didn't take place on one of the mediums directly
+under rule of this Code of Conduct.
+
+As noted, discussing this Code of Conduct should not take place on GitHub or IRC
+because these spaces are for directly working on code, not for meta-discussion.
+If you have any issues with it, you can contact me directly, or you can join one
+of the community spaces that has different rules.
+
+ * Andrew Kelley <andrew@ziglang.org>
+ * Loris Cro <loris@ziglang.org>
+
+## Conclusion
+
+Thanks for reading the rules. Together, we can make this space welcoming and
+inclusive for everyone, regardless of age, body size, disability, ethnicity,
+sex characteristics, gender identity and expression, level of experience,
+education, socio-economic status, nationality, personal appearance, race,
+religion, or sexual identity and orientation.
+
+Sincerely,
+
+Andrew ✌️ 

.github/CONTRIBUTING.md

@@ -0,0 +1,3 @@
+Please see the
+[Contributing](https://github.com/ziglang/zig/wiki/Contributing)
+page on the wiki.

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: [ziglang]

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,7 @@
+contact_links:
+  - name: Language Proposal
+    about: Propose to improve the Zig language
+    url: https://github.com/ziglang/zig/wiki/Language-Proposals
+  - name: Question
+    about: Please use one of the community spaces for questions or general discussions.
+    url: https://github.com/ziglang/zig/wiki/Community

.github/workflows/ci.yaml

@@ -0,0 +1,93 @@
+name: ci
+on:
+  pull_request:
+  push:
+    branches:
+      - 0.14.x
+concurrency:
+  # Cancels pending runs when a PR gets updated.
+  group: ${{ github.head_ref || github.run_id }}-${{ github.actor }}
+  cancel-in-progress: true
+permissions:
+  # Sets permission policy for `GITHUB_TOKEN`
+  contents: read
+jobs:
+  x86_64-linux-debug:
+    timeout-minutes: 420
+    runs-on: [self-hosted, Linux, x86_64]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Build and Test
+        run: sh ci/x86_64-linux-debug.sh
+  x86_64-linux-release:
+    timeout-minutes: 420
+    runs-on: [self-hosted, Linux, x86_64]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Build and Test
+        run: sh ci/x86_64-linux-release.sh
+  aarch64-linux-debug:
+    timeout-minutes: 480
+    runs-on: [self-hosted, Linux, aarch64]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Build and Test
+        run: sh ci/aarch64-linux-debug.sh
+  aarch64-linux-release:
+    timeout-minutes: 480
+    runs-on: [self-hosted, Linux, aarch64]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Build and Test
+        run: sh ci/aarch64-linux-release.sh
+  x86_64-macos-release:
+    runs-on: "macos-13"
+    env:
+      ARCH: "x86_64"
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Build and Test
+        run: ci/x86_64-macos-release.sh
+  aarch64-macos-debug:
+    runs-on: [self-hosted, macOS, aarch64]
+    env:
+      ARCH: "aarch64"
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Build and Test
+        run: ci/aarch64-macos-debug.sh
+  aarch64-macos-release:
+    runs-on: [self-hosted, macOS, aarch64]
+    env:
+      ARCH: "aarch64"
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Build and Test
+        run: ci/aarch64-macos-release.sh
+  x86_64-windows-debug:
+    timeout-minutes: 420
+    runs-on: [self-hosted, Windows, x86_64]
+    env:
+      ARCH: "x86_64"
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Build and Test
+        run: ci/x86_64-windows-debug.ps1
+  x86_64-windows-release:
+    timeout-minutes: 420
+    runs-on: [self-hosted, Windows, x86_64]
+    env:
+      ARCH: "x86_64"
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Build and Test
+        run: ci/x86_64-windows-release.ps1

.gitignore

@@ -16,3 +16,7 @@ zig-out/
 /build/
 /build-*/
 /docgen_tmp/
+
+# Although this was renamed to .zig-cache, let's leave it here for a few
+# releases to make it less annoying to work with multiple branches.
+zig-cache/

.mailmap

@@ -2,16 +2,10 @@ Adam Goertz <adambgoertz@gmail.com>
 Ali Chraghi <alichraghi@proton.me> <alichraghi@pm.me>
 Andrea Orru <andrea@orru.io> <andreaorru1991@gmail.com>
 Andrew Kelley <andrew@ziglang.org> <superjoe30@gmail.com>
-Andrew Kelley <andrew@ziglang.org> <andrewrk@noreply.codeberg.org>
 Bogdan Romanyuk <wrongnull@gmail.com> <65823030+wrongnull@users.noreply.github.com>
 Casey Banner <kcbanner@gmail.com>
-Dacheng Gao <successgdc@gmail.com>
-Daniel Kongsgaard <dakongsgaard@gmail.com>
 David Carlier <devnexen@gmail.com>
-David Rubin <david@vortan.dev>
-David Rubin <david@vortan.dev> <daviru007@icloud.com>
-David Rubin <david@vortan.dev> <87927264+Rexicon226@users.noreply.github.com>
-David Senoner <seda18@rolmail.net>
+David Rubin <daviru007@icloud.com> <87927264+Rexicon226@users.noreply.github.com>
 Dominic <4678790+dweiller@users.noreply.github.com>
 Dominic <4678790+dweiller@users.noreply.github.com> <4678790+dweiller@users.noreplay.github.com>
 Eric Eastwood <madlittlemods@gmail.com> <contact@ericeastwood.com>
@@ -23,7 +17,6 @@ Felix "xq" Queißner <xq@random-projects.net> <git@masterq32.de>
 Felix "xq" Queißner <xq@random-projects.net> <git@mq32.de>
 Felix "xq" Queißner <xq@random-projects.net> <git@random-projects.net>
 Frank Denis <124872+jedisct1@users.noreply.github.com> <github@pureftpd.org>
-Frank Denis <124872+jedisct1@users.noreply.github.com> <jedisct1@noreply.codeberg.org>
 Garrett Beck <garrettlennoxbeck@gmail.com> <138411610+garrettlennoxbeck@users.noreply.github.com>
 Gaëtan S <blaxoujunior@gmail.com>
 GalaxyShard <dominic.adragna@byteroach.com>
@@ -33,7 +26,6 @@ Igor Anić <igor.anic@gmail.com>
 IntegratedQuantum <jahe788@gmail.com> <43880493+IntegratedQuantum@users.noreply.github.com>
 Isaac Freund <mail@isaacfreund.com> <ifreund@ifreund.xyz>
 Isaac Freund <mail@isaacfreund.com> <isaac.freund@coil.com>
-Ivan Stepanov <ivanstepanovftw@gmail.com>
 Jacob Young <amazingjacob@gmail.com>
 Jacob Young <amazingjacob@gmail.com> <jacobly0@users.noreply.github.com>
 Jacob Young <amazingjacob@gmail.com> <15544577+jacobly0@users.noreply.github.com>
@@ -46,7 +38,6 @@ Jimmi Holst Christensen <jhc@dismail.de> <jimmiholstchristensen@gmail.com>
 Jimmi Holst Christensen <jhc@dismail.de> <rainbowhejsil@gmail.com>
 Joachim Schmidt <joachim.schmidt557@outlook.com>
 Jonathan Marler <johnnymarler@gmail.com> <jonathan.j.marler@hp.com>
-Kendall Condon <goon.pri.low@gmail.com> <149842806+gooncreeper@users.noreply.github.com>
 Krzysztof Wolicki <der.teufel.mail@gmail.com>
 Krzysztof Wolicki <der.teufel.mail@gmail.com> <46651553+der-teufel-programming@users.noreply.github.com>
 LemonBoy <thatlemon@gmail.com> <LemonBoy@users.noreply.github.com>
@@ -57,7 +48,6 @@ Marc Tiehuis <marc@tiehu.is> <marctiehuis@gmail.com>
 Mason Remaley <mason@anthropicstudios.com>
 Mason Remaley <mason@anthropicstudios.com> <MasonRemaley@users.noreply.github.com>
 Matthew Lugg <mlugg@mlugg.co.uk>
-Matthew Lugg <mlugg@mlugg.co.uk> <mlugg@noreply.codeberg.org>
 Meghan Denny <hello@nektro.net>
 Meghan Denny <hello@nektro.net> <meghan@bun.sh>
 Michael Bartnett <michael.bartnett@gmail.com> <michaelbartnett@users.noreply.github.com>
@@ -79,7 +69,6 @@ Travis Staloch <twostepted@gmail.com>
 Travis Staloch <twostepted@gmail.com> <1562827+travisstaloch@users.noreply.github.com>
 Veikka Tuominen <git@vexu.eu>
 Veikka Tuominen <git@vexu.eu> <15308111+Vexu@users.noreply.github.com>
-Veikka Tuominen <git@vexu.eu> <veikka@ziglang.org>
 Will Lillis <will.lillis24@gmail.com>
 Will Lillis <will.lillis24@gmail.com> <wlillis@umass.edu>
 Wooster <r00ster91@proton.me>

CMakeLists.txt

@@ -38,8 +38,8 @@ project(zig
 )
 
 set(ZIG_VERSION_MAJOR 0)
-set(ZIG_VERSION_MINOR 16)
-set(ZIG_VERSION_PATCH 0)
+set(ZIG_VERSION_MINOR 14)
+set(ZIG_VERSION_PATCH 1)
 set(ZIG_VERSION "" CACHE STRING "Override Zig version string. Default is to find out with git.")
 
 if("${ZIG_VERSION}" STREQUAL "")
@@ -133,9 +133,9 @@ else()
     set(ZIG_SYSTEM_LIBCXX "stdc++" CACHE STRING "system libcxx name for build.zig")
 endif()
 
-find_package(llvm 21)
-find_package(clang 21)
-find_package(lld 21)
+find_package(llvm 19)
+find_package(clang 19)
+find_package(lld 19)
 
 if(ZIG_STATIC_ZLIB)
     if (MSVC)
@@ -159,16 +159,6 @@ if(ZIG_STATIC_ZSTD)
     list(APPEND LLVM_LIBRARIES "${ZSTD}")
 endif()
 
-if (MSVC)
-    if(NOT DEFINED CMAKE_MSVC_RUNTIME_LIBRARY)
-        if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
-            # avoid linking to the debug versions of ucrt by default
-            # as they are not redistributable.
-            set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreadedDLL)
-        endif()
-    endif()
-endif ()
-
 if(ZIG_STATIC_CURSES)
     list(REMOVE_ITEM LLVM_LIBRARIES "-lcurses")
     find_library(CURSES NAMES libcurses.a libncurses.a NAMES_PER_DIR
@@ -197,6 +187,7 @@ set(ZIG_CPP_SOURCES
     # These are planned to stay even when we are self-hosted.
     src/zig_llvm.cpp
     src/zig_llvm-ar.cpp
+    src/zig_clang.cpp
     src/zig_clang_driver.cpp
     src/zig_clang_cc1_main.cpp
     src/zig_clang_cc1as_main.cpp
@@ -205,13 +196,183 @@ set(ZIG_CPP_SOURCES
 set(ZIG_STAGE2_SOURCES
     "${ZIG_CONFIG_ZIG_OUT}"
     lib/compiler_rt.zig
+    lib/compiler_rt/absv.zig
+    lib/compiler_rt/absvdi2.zig
+    lib/compiler_rt/absvsi2.zig
+    lib/compiler_rt/absvti2.zig
+    lib/compiler_rt/adddf3.zig
+    lib/compiler_rt/addf3.zig
+    lib/compiler_rt/addo.zig
+    lib/compiler_rt/addsf3.zig
+    lib/compiler_rt/addtf3.zig
+    lib/compiler_rt/addxf3.zig
+    lib/compiler_rt/arm.zig
+    lib/compiler_rt/atomics.zig
+    lib/compiler_rt/aulldiv.zig
+    lib/compiler_rt/aullrem.zig
+    lib/compiler_rt/bswap.zig
+    lib/compiler_rt/ceil.zig
+    lib/compiler_rt/clear_cache.zig
+    lib/compiler_rt/cmp.zig
+    lib/compiler_rt/cmpdf2.zig
+    lib/compiler_rt/cmpsf2.zig
+    lib/compiler_rt/cmptf2.zig
+    lib/compiler_rt/cmpxf2.zig
+    lib/compiler_rt/common.zig
+    lib/compiler_rt/comparef.zig
+    lib/compiler_rt/cos.zig
+    lib/compiler_rt/count0bits.zig
+    lib/compiler_rt/divdf3.zig
+    lib/compiler_rt/divsf3.zig
+    lib/compiler_rt/divtf3.zig
+    lib/compiler_rt/divti3.zig
+    lib/compiler_rt/divxf3.zig
+    lib/compiler_rt/emutls.zig
+    lib/compiler_rt/exp.zig
+    lib/compiler_rt/exp2.zig
+    lib/compiler_rt/extenddftf2.zig
+    lib/compiler_rt/extenddfxf2.zig
+    lib/compiler_rt/extendf.zig
+    lib/compiler_rt/extendhfsf2.zig
+    lib/compiler_rt/extendhftf2.zig
+    lib/compiler_rt/extendhfxf2.zig
+    lib/compiler_rt/extendsfdf2.zig
+    lib/compiler_rt/extendsftf2.zig
+    lib/compiler_rt/extendsfxf2.zig
+    lib/compiler_rt/extendxftf2.zig
+    lib/compiler_rt/fabs.zig
+    lib/compiler_rt/fixdfdi.zig
+    lib/compiler_rt/fixdfsi.zig
+    lib/compiler_rt/fixdfti.zig
+    lib/compiler_rt/fixhfdi.zig
+    lib/compiler_rt/fixhfsi.zig
+    lib/compiler_rt/fixhfti.zig
+    lib/compiler_rt/fixsfdi.zig
+    lib/compiler_rt/fixsfsi.zig
+    lib/compiler_rt/fixsfti.zig
+    lib/compiler_rt/fixtfdi.zig
+    lib/compiler_rt/fixtfsi.zig
+    lib/compiler_rt/fixtfti.zig
+    lib/compiler_rt/fixunsdfdi.zig
+    lib/compiler_rt/fixunsdfsi.zig
+    lib/compiler_rt/fixunsdfti.zig
+    lib/compiler_rt/fixunshfdi.zig
+    lib/compiler_rt/fixunshfsi.zig
+    lib/compiler_rt/fixunshfti.zig
+    lib/compiler_rt/fixunssfdi.zig
+    lib/compiler_rt/fixunssfsi.zig
+    lib/compiler_rt/fixunssfti.zig
+    lib/compiler_rt/fixunstfdi.zig
+    lib/compiler_rt/fixunstfsi.zig
+    lib/compiler_rt/fixunstfti.zig
+    lib/compiler_rt/fixunsxfdi.zig
+    lib/compiler_rt/fixunsxfsi.zig
+    lib/compiler_rt/fixunsxfti.zig
+    lib/compiler_rt/fixxfdi.zig
+    lib/compiler_rt/fixxfsi.zig
+    lib/compiler_rt/fixxfti.zig
+    lib/compiler_rt/float_from_int.zig
+    lib/compiler_rt/floatdidf.zig
+    lib/compiler_rt/floatdihf.zig
+    lib/compiler_rt/floatdisf.zig
+    lib/compiler_rt/floatditf.zig
+    lib/compiler_rt/floatdixf.zig
+    lib/compiler_rt/floatsidf.zig
+    lib/compiler_rt/floatsihf.zig
+    lib/compiler_rt/floatsisf.zig
+    lib/compiler_rt/floatsitf.zig
+    lib/compiler_rt/floatsixf.zig
+    lib/compiler_rt/floattidf.zig
+    lib/compiler_rt/floattihf.zig
+    lib/compiler_rt/floattisf.zig
+    lib/compiler_rt/floattitf.zig
+    lib/compiler_rt/floattixf.zig
+    lib/compiler_rt/floatundidf.zig
+    lib/compiler_rt/floatundihf.zig
+    lib/compiler_rt/floatundisf.zig
+    lib/compiler_rt/floatunditf.zig
+    lib/compiler_rt/floatundixf.zig
+    lib/compiler_rt/floatunsidf.zig
+    lib/compiler_rt/floatunsihf.zig
+    lib/compiler_rt/floatunsisf.zig
+    lib/compiler_rt/floatunsitf.zig
+    lib/compiler_rt/floatunsixf.zig
+    lib/compiler_rt/floatuntidf.zig
+    lib/compiler_rt/floatuntihf.zig
+    lib/compiler_rt/floatuntisf.zig
+    lib/compiler_rt/floatuntitf.zig
+    lib/compiler_rt/floatuntixf.zig
+    lib/compiler_rt/floor.zig
+    lib/compiler_rt/fma.zig
+    lib/compiler_rt/fmax.zig
+    lib/compiler_rt/fmin.zig
+    lib/compiler_rt/fmod.zig
+    lib/compiler_rt/gedf2.zig
+    lib/compiler_rt/gesf2.zig
+    lib/compiler_rt/getf2.zig
+    lib/compiler_rt/gexf2.zig
+    lib/compiler_rt/int.zig
+    lib/compiler_rt/int_from_float.zig
+    lib/compiler_rt/log.zig
+    lib/compiler_rt/log10.zig
+    lib/compiler_rt/log2.zig
+    lib/compiler_rt/modti3.zig
+    lib/compiler_rt/mulXi3.zig
+    lib/compiler_rt/muldf3.zig
+    lib/compiler_rt/mulf3.zig
+    lib/compiler_rt/mulo.zig
+    lib/compiler_rt/mulsf3.zig
+    lib/compiler_rt/multf3.zig
+    lib/compiler_rt/mulxf3.zig
+    lib/compiler_rt/negXi2.zig
+    lib/compiler_rt/negdf2.zig
+    lib/compiler_rt/negsf2.zig
+    lib/compiler_rt/negtf2.zig
+    lib/compiler_rt/negv.zig
+    lib/compiler_rt/negxf2.zig
+    lib/compiler_rt/os_version_check.zig
+    lib/compiler_rt/parity.zig
+    lib/compiler_rt/popcount.zig
+    lib/compiler_rt/rem_pio2.zig
+    lib/compiler_rt/rem_pio2_large.zig
+    lib/compiler_rt/rem_pio2f.zig
+    lib/compiler_rt/round.zig
+    lib/compiler_rt/shift.zig
+    lib/compiler_rt/sin.zig
+    lib/compiler_rt/sincos.zig
+    lib/compiler_rt/sqrt.zig
+    lib/compiler_rt/stack_probe.zig
+    lib/compiler_rt/subdf3.zig
+    lib/compiler_rt/subo.zig
+    lib/compiler_rt/subsf3.zig
+    lib/compiler_rt/subtf3.zig
+    lib/compiler_rt/subxf3.zig
+    lib/compiler_rt/tan.zig
+    lib/compiler_rt/trig.zig
+    lib/compiler_rt/trunc.zig
+    lib/compiler_rt/truncdfhf2.zig
+    lib/compiler_rt/truncdfsf2.zig
+    lib/compiler_rt/truncf.zig
+    lib/compiler_rt/truncsfhf2.zig
+    lib/compiler_rt/trunctfdf2.zig
+    lib/compiler_rt/trunctfhf2.zig
+    lib/compiler_rt/trunctfsf2.zig
+    lib/compiler_rt/trunctfxf2.zig
+    lib/compiler_rt/truncxfdf2.zig
+    lib/compiler_rt/truncxfhf2.zig
+    lib/compiler_rt/truncxfsf2.zig
+    lib/compiler_rt/udivmod.zig
+    lib/compiler_rt/udivmodei4.zig
+    lib/compiler_rt/udivmodti4.zig
+    lib/compiler_rt/udivti3.zig
+    lib/compiler_rt/umodti3.zig
+    lib/compiler_rt/unorddf2.zig
+    lib/compiler_rt/unordsf2.zig
+    lib/compiler_rt/unordtf2.zig
     lib/std/BitStack.zig
     lib/std/Build.zig
     lib/std/Build/Cache.zig
     lib/std/Build/Cache/DepTokenizer.zig
-    lib/std/Io.zig
-    lib/std/Io/Reader.zig
-    lib/std/Io/Writer.zig
     lib/std/Progress.zig
     lib/std/Random.zig
     lib/std/Target.zig
@@ -233,6 +394,11 @@ set(ZIG_STAGE2_SOURCES
     lib/std/Target/wasm.zig
     lib/std/Target/x86.zig
     lib/std/Thread.zig
+    lib/std/Thread/Futex.zig
+    lib/std/Thread/Mutex.zig
+    lib/std/Thread/Pool.zig
+    lib/std/Thread/ResetEvent.zig
+    lib/std/Thread/WaitGroup.zig
     lib/std/array_hash_map.zig
     lib/std/array_list.zig
     lib/std/ascii.zig
@@ -254,18 +420,38 @@ set(ZIG_STAGE2_SOURCES
     lib/std/dwarf/OP.zig
     lib/std/dwarf/TAG.zig
     lib/std/elf.zig
+    lib/std/fifo.zig
     lib/std/fmt.zig
+    lib/std/fmt/format_float.zig
     lib/std/fmt/parse_float.zig
     lib/std/fs.zig
+    lib/std/fs/AtomicFile.zig
+    lib/std/fs/Dir.zig
+    lib/std/fs/File.zig
+    lib/std/fs/get_app_data_dir.zig
     lib/std/fs/path.zig
     lib/std/hash.zig
     lib/std/hash/auto_hash.zig
     lib/std/hash/wyhash.zig
     lib/std/hash_map.zig
     lib/std/heap.zig
-    lib/std/heap/ArenaAllocator.zig
+    lib/std/heap/arena_allocator.zig
+    lib/std/io.zig
+    lib/std/io/Reader.zig
+    lib/std/io/Writer.zig
+    lib/std/io/buffered_atomic_file.zig
+    lib/std/io/buffered_writer.zig
+    lib/std/io/change_detection_stream.zig
+    lib/std/io/counting_reader.zig
+    lib/std/io/counting_writer.zig
+    lib/std/io/find_byte_writer.zig
+    lib/std/io/fixed_buffer_stream.zig
+    lib/std/io/limited_reader.zig
+    lib/std/io/seekable_stream.zig
     lib/std/json.zig
+    lib/std/json/stringify.zig
     lib/std/leb128.zig
+    lib/std/linked_list.zig
     lib/std/log.zig
     lib/std/macho.zig
     lib/std/math.zig
@@ -307,7 +493,6 @@ set(ZIG_STAGE2_SOURCES
     lib/std/unicode.zig
     lib/std/zig.zig
     lib/std/zig/Ast.zig
-    lib/std/zig/Ast/Render.zig
     lib/std/zig/AstGen.zig
     lib/std/zig/AstRlAnnotate.zig
     lib/std/zig/LibCInstallation.zig
@@ -315,6 +500,8 @@ set(ZIG_STAGE2_SOURCES
     lib/std/zig/Server.zig
     lib/std/zig/WindowsSdk.zig
     lib/std/zig/Zir.zig
+    lib/std/zig/c_builtins.zig
+    lib/std/zig/render.zig
     lib/std/zig/string_literal.zig
     lib/std/zig/system.zig
     lib/std/zig/system/NativePaths.zig
@@ -326,15 +513,13 @@ set(ZIG_STAGE2_SOURCES
     lib/std/zig/llvm/bitcode_writer.zig
     lib/std/zig/llvm/ir.zig
     src/Air.zig
-    src/Air/Legalize.zig
-    src/Air/Liveness.zig
-    src/Air/Liveness/Verify.zig
-    src/Air/print.zig
-    src/Air/types_resolved.zig
     src/Builtin.zig
     src/Compilation.zig
     src/Compilation/Config.zig
+    src/DarwinPosixSpawn.zig
     src/InternPool.zig
+    src/Liveness.zig
+    src/Liveness/Verify.zig
     src/Package.zig
     src/Package/Fetch.zig
     src/Package/Fetch/git.zig
@@ -344,35 +529,69 @@ set(ZIG_STAGE2_SOURCES
     src/Sema.zig
     src/Sema/bitcast.zig
     src/Sema/comptime_ptr_access.zig
+    src/ThreadSafeQueue.zig
     src/Type.zig
     src/Value.zig
     src/Zcu.zig
     src/Zcu/PerThread.zig
+    src/arch/aarch64/CodeGen.zig
+    src/arch/aarch64/Emit.zig
+    src/arch/aarch64/Mir.zig
+    src/arch/aarch64/abi.zig
+    src/arch/aarch64/bits.zig
+    src/arch/arm/CodeGen.zig
+    src/arch/arm/Emit.zig
+    src/arch/arm/Mir.zig
+    src/arch/arm/abi.zig
+    src/arch/arm/bits.zig
+    src/arch/riscv64/abi.zig
+    src/arch/riscv64/bits.zig
+    src/arch/riscv64/CodeGen.zig
+    src/arch/riscv64/Emit.zig
+    src/arch/riscv64/encoding.zig
+    src/arch/riscv64/Lower.zig
+    src/arch/riscv64/Mir.zig
+    src/arch/riscv64/mnem.zig
+    src/arch/sparc64/CodeGen.zig
+    src/arch/sparc64/Emit.zig
+    src/arch/sparc64/Mir.zig
+    src/arch/sparc64/abi.zig
+    src/arch/sparc64/bits.zig
+    src/arch/wasm/CodeGen.zig
+    src/arch/wasm/Emit.zig
+    src/arch/wasm/Mir.zig
+    src/arch/wasm/abi.zig
+    src/arch/x86/bits.zig
+    src/arch/x86_64/CodeGen.zig
+    src/arch/x86_64/Disassembler.zig
+    src/arch/x86_64/Emit.zig
+    src/arch/x86_64/Encoding.zig
+    src/arch/x86_64/Lower.zig
+    src/arch/x86_64/Mir.zig
+    src/arch/x86_64/abi.zig
+    src/arch/x86_64/bits.zig
+    src/arch/x86_64/encoder.zig
+    src/arch/x86_64/encodings.zon
+    src/clang.zig
     src/clang_options.zig
     src/clang_options_data.zig
     src/codegen.zig
-    src/codegen/aarch64.zig
-    src/codegen/aarch64/abi.zig
-    src/codegen/aarch64/Assemble.zig
-    src/codegen/aarch64/Disassemble.zig
-    src/codegen/aarch64/encoding.zig
-    src/codegen/aarch64/instructions.zon
-    src/codegen/aarch64/Mir.zig
-    src/codegen/aarch64/Select.zig
     src/codegen/c.zig
     src/codegen/c/Type.zig
     src/codegen/llvm.zig
     src/codegen/llvm/bindings.zig
+    src/codegen/spirv.zig
+    src/codegen/spirv/Assembler.zig
+    src/codegen/spirv/Module.zig
+    src/codegen/spirv/Section.zig
+    src/codegen/spirv/spec.zig
     src/crash_report.zig
     src/dev.zig
-    src/libs/freebsd.zig
-    src/libs/glibc.zig
-    src/libs/netbsd.zig
-    src/libs/openbsd.zig
+    src/glibc.zig
     src/introspect.zig
-    src/libs/libcxx.zig
-    src/libs/libtsan.zig
-    src/libs/libunwind.zig
+    src/libcxx.zig
+    src/libtsan.zig
+    src/libunwind.zig
     src/link.zig
     src/link/C.zig
     src/link/Coff.zig
@@ -394,9 +613,7 @@ set(ZIG_STAGE2_SOURCES
     src/link/Elf/relocatable.zig
     src/link/Elf/relocation.zig
     src/link/Elf/synthetic_sections.zig
-    src/link/Elf2.zig
     src/link/LdScript.zig
-    src/link/Lld.zig
     src/link/MachO.zig
     src/link/MachO/Archive.zig
     src/link/MachO/Atom.zig
@@ -423,8 +640,14 @@ set(ZIG_STAGE2_SOURCES
     src/link/MachO/synthetic.zig
     src/link/MachO/Thunk.zig
     src/link/MachO/uuid.zig
-    src/link/MappedFile.zig
-    src/link/Queue.zig
+    src/link/NvPtx.zig
+    src/link/Plan9.zig
+    src/link/Plan9/aout.zig
+    src/link/SpirV.zig
+    src/link/SpirV/BinaryModule.zig
+    src/link/SpirV/deduplicate.zig
+    src/link/SpirV/lower_invocation_globals.zig
+    src/link/SpirV/prune_unused.zig
     src/link/StringTable.zig
     src/link/Wasm.zig
     src/link/Wasm/Archive.zig
@@ -440,9 +663,10 @@ set(ZIG_STAGE2_SOURCES
     src/link/tapi/yaml.zig
     src/link/tapi/yaml/test.zig
     src/main.zig
-    src/libs/mingw.zig
-    src/libs/musl.zig
+    src/mingw.zig
+    src/musl.zig
     src/mutable_value.zig
+    src/print_air.zig
     src/print_env.zig
     src/print_targets.zig
     src/print_value.zig
@@ -450,7 +674,8 @@ set(ZIG_STAGE2_SOURCES
     src/register_manager.zig
     src/target.zig
     src/tracy.zig
-    src/libs/wasi_libc.zig
+    src/translate_c.zig
+    src/wasi_libc.zig
 )
 
 if(MSVC)
@@ -459,12 +684,6 @@ if(MSVC)
         set(ZIG_DIA_GUIDS_LIB "${MSVC_DIA_SDK_DIR}/lib/amd64/diaguids.lib")
         string(REGEX REPLACE "\\\\" "\\\\\\\\" ZIG_DIA_GUIDS_LIB_ESCAPED "${ZIG_DIA_GUIDS_LIB}")
     endif()
-
-    # The /RTC[c][s][u] flag enables extra runtime checks. ("/RTC1" == "/RTCsu")
-    # The "c" (PossibleDataLoss) and "u" (UninitializeVariable) flags trap on valid C code so we disable
-    # them.  The "s" flag seems like it might be OK.
-    string(REPLACE "/RTC1" "/RTCs" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
-    string(REPLACE "/RTC1" "/RTCs" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
 endif()
 
 configure_file (
@@ -487,13 +706,6 @@ add_library(zigcpp STATIC ${ZIG_CPP_SOURCES})
 target_compile_features(zigcpp PRIVATE cxx_std_17)
 set_target_properties(zigcpp PROPERTIES POSITION_INDEPENDENT_CODE ${ZIG_PIE})
 
-if(LLVM_LINK_MODE STREQUAL "static")
-  target_compile_definitions(zigcpp PRIVATE
-    LLVM_BUILD_STATIC
-    CLANG_BUILD_STATIC
-  )
-endif()
-
 if(NOT MSVC)
   if(MINGW)
     target_compile_options(zigcpp PRIVATE -Wno-format)
@@ -547,22 +759,20 @@ endforeach()
 include(CheckSymbolExists)
 
 string(TOLOWER "${CMAKE_HOST_SYSTEM_NAME}" ZIG_HOST_TARGET_OS)
-if(ZIG_HOST_TARGET_OS STREQUAL "android")
-  set(ZIG_HOST_TARGET_OS "linux")
-  set(ZIG_HOST_TARGET_IS_ANDROID TRUE)
-elseif(ZIG_HOST_TARGET_OS STREQUAL "darwin")
+if(ZIG_HOST_TARGET_OS STREQUAL "darwin")
   set(ZIG_HOST_TARGET_OS "macos")
-elseif(ZIG_HOST_TARGET_OS STREQUAL "gnu")
-  set(ZIG_HOST_TARGET_OS "hurd")
-elseif(ZIG_HOST_TARGET_OS STREQUAL "serenityos")
-  set(ZIG_HOST_TARGET_OS "serenity")
 elseif(ZIG_HOST_TARGET_OS STREQUAL "sunos")
-  set(ZIG_HOST_TARGET_OS "illumos")
+  check_symbol_exists(__illumos__ "" ZIG_HOST_TARGET_HAS_ILLUMOS_MACRO)
+  if (ZIG_HOST_TARGET_HAS_ILLUMOS_MACRO)
+    set(ZIG_HOST_TARGET_OS "illumos")
+  else()
+    set(ZIG_HOST_TARGET_OS "solaris")
+  endif()
 endif()
 
 string(TOLOWER "${CMAKE_HOST_SYSTEM_PROCESSOR}" ZIG_HOST_TARGET_ARCH)
 if(ZIG_HOST_TARGET_ARCH MATCHES "^i[3-9]86$")
-  if (ZIG_HOST_TARGET_OS STREQUAL "illumos")
+  if (ZIG_HOST_TARGET_OS MATCHES "(solaris|illumos)")
     set(ZIG_HOST_TARGET_ARCH "x86_64")
   else()
     set(ZIG_HOST_TARGET_ARCH "x86")
@@ -571,12 +781,13 @@ elseif(ZIG_HOST_TARGET_ARCH STREQUAL "amd64")
   set(ZIG_HOST_TARGET_ARCH "x86_64")
 elseif(ZIG_HOST_TARGET_ARCH STREQUAL "arm64")
   set(ZIG_HOST_TARGET_ARCH "aarch64")
-elseif(ZIG_HOST_TARGET_ARCH MATCHES "^arm(el)?$" OR ZIG_HOST_TARGET_ARCH MATCHES "^armv[7-8]l$")
+elseif(ZIG_HOST_TARGET_ARCH STREQUAL "armv7l")
   set(ZIG_HOST_TARGET_ARCH "arm")
-elseif(ZIG_HOST_TARGET_ARCH STREQUAL "armeb" OR ZIG_HOST_TARGET_ARCH MATCHES "^armv[7-8]b$")
+elseif(ZIG_HOST_TARGET_ARCH STREQUAL "armv7b")
   set(ZIG_HOST_TARGET_ARCH "armeb")
 endif()
-if(ZIG_HOST_TARGET_ARCH MATCHES "^arm(eb)?$")
+string(REGEX REPLACE "^((arm|thumb)(hf?)?)el$" "\\1" ZIG_HOST_TARGET_ARCH "${ZIG_HOST_TARGET_ARCH}")
+if(ZIG_HOST_TARGET_ARCH MATCHES "^arm(hf?)?(eb)?$")
   check_symbol_exists(__thumb__ "" ZIG_HOST_TARGET_DEFAULTS_TO_THUMB)
   if(ZIG_HOST_TARGET_DEFAULTS_TO_THUMB)
     string(REGEX REPLACE "^arm" "thumb" ZIG_HOST_TARGET_ARCH "${ZIG_HOST_TARGET_ARCH}")
@@ -584,17 +795,15 @@ if(ZIG_HOST_TARGET_ARCH MATCHES "^arm(eb)?$")
 endif()
 string(REGEX REPLACE "^ppc((64)?(le)?)$" "powerpc\\1" ZIG_HOST_TARGET_ARCH "${ZIG_HOST_TARGET_ARCH}")
 
-set(ZIG_HOST_TARGET_ABI "")
 if(MSVC)
   set(ZIG_HOST_TARGET_ABI "-msvc")
 elseif(MINGW)
   set(ZIG_HOST_TARGET_ABI "-gnu")
-elseif(ZIG_HOST_TARGET_IS_ANDROID)
-  if(ZIG_HOST_TARGET_ARCH STREQUAL "arm")
-    set(ZIG_HOST_TARGET_ABI "-androideabi")
-  else()
-    set(ZIG_HOST_TARGET_ABI "-android")
-  endif()
+elseif(ZIG_HOST_TARGET_ARCH MATCHES "^(arm|thumb)hf?(eb)?$")
+  string(REGEX REPLACE "^(arm|thumb)hf?((eb)?)$" "\\1\\2" ZIG_HOST_TARGET_ARCH "${ZIG_HOST_TARGET_ARCH}")
+  set(ZIG_HOST_TARGET_ABI "-eabihf")
+else()
+  set(ZIG_HOST_TARGET_ABI "")
 endif()
 
 set(ZIG_HOST_TARGET_TRIPLE "${ZIG_HOST_TARGET_ARCH}-${ZIG_HOST_TARGET_OS}${ZIG_HOST_TARGET_ABI}" CACHE STRING "Host zig target triple.")
@@ -607,12 +816,7 @@ if(MSVC)
 else()
   set(ZIG_WASM2C_COMPILE_FLAGS "-std=c99 -O2")
   set(ZIG1_COMPILE_FLAGS "-std=c99 -Os")
-  set(ZIG2_COMPILE_FLAGS "-std=c99 -O0 -fno-sanitize=undefined -fno-stack-protector")
-  # Must match the condition in build.zig.
-  if(ZIG_HOST_TARGET_ARCH MATCHES "^(arm|thumb)(eb)?$" OR ZIG_HOST_TARGET_ARCH MATCHES "^powerpc(64)?(le)?$")
-    set(ZIG1_COMPILE_FLAGS "${ZIG1_COMPILE_FLAGS} -ffunction-sections -fdata-sections")
-    set(ZIG2_COMPILE_FLAGS "${ZIG2_COMPILE_FLAGS} -ffunction-sections -fdata-sections")
-  endif()
+  set(ZIG2_COMPILE_FLAGS "-std=c99 -O0 -fno-stack-protector")
   if(APPLE)
     set(ZIG2_LINK_FLAGS "-Wl,-stack_size,0x10000000")
   elseif(MINGW)
@@ -741,24 +945,12 @@ if(ZIG_EXTRA_BUILD_ARGS)
   list(APPEND ZIG_BUILD_ARGS ${ZIG_EXTRA_BUILD_ARGS})
 endif()
 
-set(ZIG_RELEASE_SAFE OFF CACHE BOOL "Build Zig as ReleaseSafe (with debug assertions on)")
-
 if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
   list(APPEND ZIG_BUILD_ARGS -Doptimize=Debug)
+elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo")
+  list(APPEND ZIG_BUILD_ARGS -Doptimize=ReleaseFast)
 else()
-  if("${CMAKE_BUILD_TYPE}" STREQUAL "MinSizeRel")
-    list(APPEND ZIG_BUILD_ARGS -Doptimize=ReleaseSmall)
-  else()
-    # Release and RelWithDebInfo
-    if(ZIG_RELEASE_SAFE)
-      list(APPEND ZIG_BUILD_ARGS -Doptimize=ReleaseSafe)
-    else()
-      list(APPEND ZIG_BUILD_ARGS -Doptimize=ReleaseFast)
-    endif()
-    if(NOT "${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo")
-      list(APPEND ZIG_BUILD_ARGS -Dstrip)
-    endif()
-  endif()
+  list(APPEND ZIG_BUILD_ARGS -Doptimize=ReleaseFast -Dstrip)
 endif()
 
 if(ZIG_STATIC AND NOT MSVC)
@@ -781,6 +973,10 @@ if(NOT "${ZIG_TARGET_DYNAMIC_LINKER}" STREQUAL "")
   list(APPEND ZIG_BUILD_ARGS "-Ddynamic-linker=${ZIG_TARGET_DYNAMIC_LINKER}")
 endif()
 
+if(MINGW AND "${ZIG_HOST_TARGET_ARCH}" STREQUAL "x86")
+  list(APPEND ZIG_BUILD_ARGS --maxrss 7000000000)
+endif()
+
 
 add_custom_target(stage3 ALL
   DEPENDS "${PROJECT_BINARY_DIR}/stage3/bin/zig"

README.md

@@ -20,8 +20,8 @@ running `zig std`, which will open a browser tab.
 ## Installation
 
  * [download a pre-built binary](https://ziglang.org/download/)
- * [install from a package manager](https://ziglang.org/learn/getting-started/#managers)
- * [bootstrap zig for any target](https://codeberg.org/ziglang/zig-bootstrap)
+ * [install from a package manager](https://github.com/ziglang/zig/wiki/Install-Zig-from-a-Package-Manager)
+ * [bootstrap zig for any target](https://github.com/ziglang/zig-bootstrap)
 
 A Zig installation is composed of two things:
 
@@ -47,10 +47,7 @@ Ensure you have the required dependencies:
 
  * CMake >= 3.15
  * System C/C++ Toolchain
- * LLVM, Clang, LLD development libraries, version 21.x, compiled with the
-   same system C/C++ toolchain.
-   - If the system package manager lacks these libraries, or has them misconfigured,
-     see below for how to build them from source.
+ * LLVM, Clang, LLD development libraries == 19.x
 
 Then it is the standard CMake build process:
 
@@ -61,9 +58,9 @@ cmake ..
 make install
 ```
 
-Use `CMAKE_PREFIX_PATH` if needed to help CMake find LLVM.
-
-This produces `stage3/bin/zig` which is the Zig compiler built by itself.
+For more options, tips, and troubleshooting, please see the
+[Building Zig From Source](https://github.com/ziglang/zig/wiki/Building-Zig-From-Source)
+page on the wiki.
 
 ## Building from Source without LLVM
 
@@ -79,377 +76,35 @@ This produces a `zig2` executable in the current working directory. This is a
 [without LLVM extensions](https://github.com/ziglang/zig/issues/16270), and is
 therefore lacking these features:
 - Release mode optimizations
-- [Some ELF linking features](https://github.com/ziglang/zig/issues/17749)
-- [Some COFF/PE linking features](https://github.com/ziglang/zig/issues/17751)
-- [Some WebAssembly linking features](https://github.com/ziglang/zig/issues/17750)
-- [Ability to create static archives from object files](https://github.com/ziglang/zig/issues/9828)
+- [aarch64 machine code backend](https://github.com/ziglang/zig/issues/21172)
+- [@cImport](https://github.com/ziglang/zig/issues/20630)
+- [zig translate-c](https://github.com/ziglang/zig/issues/20875)
 - [Ability to compile assembly files](https://github.com/ziglang/zig/issues/21169)
+- [Some ELF linking features](https://github.com/ziglang/zig/issues/17749)
+- [Most COFF/PE linking features](https://github.com/ziglang/zig/issues/17751)
+- [Some WebAssembly linking features](https://github.com/ziglang/zig/issues/17750)
+- [Ability to create import libs from def files](https://github.com/ziglang/zig/issues/17807)
+- [Ability to create static archives from object files](https://github.com/ziglang/zig/issues/9828)
 - Ability to compile C, C++, Objective-C, and Objective-C++ files
 
-Even when built this way, Zig provides an LLVM backend that produces bitcode
-files, which may be optimized and compiled into object files via a system Clang
+However, a compiler built this way does provide a C backend, which may be
+useful for creating system packages of Zig projects using the system C
+toolchain. **In this case, LLVM is not needed!**
+
+Furthermore, a compiler built this way provides an LLVM backend that produces
+bitcode files, which may be compiled into object files via a system Clang
 package. This can be used to produce system packages of Zig applications
 without the Zig package dependency on LLVM.
 
-## Building from Source Using Prebuilt Zig
-
-Dependencies:
-
- * A recent prior build of Zig. The exact version required depends on how
-   recently breaking changes occurred. If the language or std lib changed too
-   much since this version, then this method of building from source will fail.
- * LLVM, Clang, and LLD libraries built using Zig.
-
-The easiest way to obtain both of these artifacts is to use
-[zig-bootstrap](https://codeberg.org/ziglang/zig-bootstrap), which creates the
-directory `out/zig-$target-$cpu` and `out/$target-$cpu`, to be used as
-`$ZIG_PREFIX` and `$LLVM_PREFIX`, respectively, in the following command:
-
-```
-"$ZIG_PREFIX/zig" build \
-  -p stage3 \
-  --search-prefix "$LLVM_PREFIX" \
-  --zig-lib-dir "lib" \
-  -Dstatic-llvm
-```
-
-Where `$LLVM_PREFIX` is the path that contains, for example,
-`include/llvm/Pass.h` and `lib/libLLVMCore.a`.
-
-This produces `stage3/bin/zig`. See `zig build -h` to learn about the options
-that can be passed such as `-Drelease`.
-
-## Building from Source on Windows
-
-### Option 1: Use the Windows Zig Compiler Dev Kit
-
-This one has the benefit that LLVM, LLD, and Clang are built in Release mode,
-while your Zig build has the option to be a Debug build. It also works
-completely independently from MSVC so you don't need it to be installed.
-
-Determine the URL by
-[looking at the CI script](https://codeberg.org/ziglang/zig/src/branch/master/ci/x86_64-windows-debug.ps1#L1-L4).
-It will look something like this (replace `$VERSION` with the one you see by
-following the above link):
-
-```
-https://ziglang.org/deps/zig+llvm+lld+clang-x86_64-windows-gnu-$VERSION.zip
-```
-
-This zip file contains:
-
- * An older Zig installation.
- * LLVM, LLD, and Clang libraries (.lib and .h files), version 16.0.1, built in Release mode.
- * zlib (.lib and .h files), v1.2.13, built in Release mode
- * zstd (.lib and .h files), v1.5.2, built in Release mode
-
-#### Option 1a: CMake + [Ninja](https://ninja-build.org/)
-
-Unzip the dev kit and then in cmd.exe in your Zig source checkout:
-
-```bat
-mkdir build
-cd build
-set DEVKIT=$DEVKIT
-```
-
-Replace `$DEVKIT` with the path to the folder that you unzipped after
-downloading it from the link above. Make sure to use forward slashes (`/`) for
-all path separators (otherwise CMake will try to interpret backslashes as
-escapes and fail).
-
-Then run:
-
-```bat
-cmake .. -GNinja -DCMAKE_PREFIX_PATH="%DEVKIT%" -DCMAKE_C_COMPILER="%DEVKIT%/bin/zig.exe;cc" -DCMAKE_CXX_COMPILER="%DEVKIT%/bin/zig.exe;c++" -DCMAKE_AR="%DEVKIT%/bin/zig.exe" -DZIG_AR_WORKAROUND=ON -DZIG_STATIC=ON -DZIG_USE_LLVM_CONFIG=OFF
-```
-
- * Append `-DCMAKE_BUILD_TYPE=Release` for a Release build.
- * Append `-DZIG_NO_LIB=ON` to avoid having multiple copies of the lib/ folder.
-
-Finally, run:
-
-```bat
-ninja install
-```
-
-You now have the `zig.exe` binary at `stage3\bin\zig.exe`.
-
-#### Option 1b: zig build
-
-Unzip the dev kit and then in cmd.exe in your Zig source checkout:
-
-```bat
-$DEVKIT\bin\zig.exe build -p stage3 --search-prefix $DEVKIT --zig-lib-dir lib -Dstatic-llvm -Duse-zig-libcxx -Dtarget=x86_64-windows-gnu
-```
-
-Replace `$DEVKIT` with the path to the folder that you unzipped after
-downloading it from the link above.
-
-Append `-Doptimize=ReleaseSafe` for a Release build.
-
-**If you get an error building at this step**, it is most likely that the Zig
-installation inside the dev kit is too old, and the dev kit needs to be
-updated. In this case one more step is required:
-
- 1. [Download the latest master branch zip file](https://ziglang.org/download/#release-master).
- 2. Unzip, and try the above command again, replacing the path to zig.exe with
-    the path to the zig.exe you just extracted, and also replace the lib\zig
-    folder with the new contents.
-
-You now have the `zig.exe` binary at `stage3\bin\zig.exe`.
-
-### Option 2: Using CMake and Microsoft Visual Studio
-
-This one has the benefit that changes to the language or build system won't
-break your dev kit. This option can be used to upgrade a dev kit.
-
-First, build LLVM, LLD, and Clang from source using CMake and Microsoft Visual
-Studio (see below for detailed instructions).
-
-Install [Build Tools for Visual Studio
-2019](https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2019).
-Be sure to select "Desktop development with C++" when prompted.
- * You must additionally check the optional component labeled **C++ ATL for
-   v142 build tools**.
-
-Install [CMake](http://cmake.org).
-
-Use [git](https://git-scm.com/) to clone the zig repository to a path with no spaces, e.g. `C:\Users\Andy\zig`.
-
-Using the start menu, run **x64 Native Tools Command Prompt for VS 2019** and execute these commands, replacing `C:\Users\Andy` with the correct value.
-
-```bat
-mkdir C:\Users\Andy\zig\build-release
-cd C:\Users\Andy\zig\build-release
-"c:\Program Files\CMake\bin\cmake.exe" .. -Thost=x64 -G "Visual Studio 16 2019" -A x64 -DCMAKE_PREFIX_PATH=C:\Users\Andy\llvm+clang+lld-20.0.0-x86_64-windows-msvc-release-mt -DCMAKE_BUILD_TYPE=Release
-msbuild -p:Configuration=Release INSTALL.vcxproj
-```
-
-You now have the `zig.exe` binary at `bin\zig.exe` and you can run the tests:
-
-```bat
-bin\zig.exe build test
-```
-
-This can take a long time.
-
-Note: In case you get the error "llvm-config not found" (or similar), make sure
-that you have **no** trailing slash (`/` or `\`) at the end of the
-`-DCMAKE_PREFIX_PATH` value.
-
-## Building LLVM, LLD, and Clang from Source
-
-### Windows
-
-Install [CMake](https://cmake.org/), version 3.20.0 or newer.
-
-[Download LLVM, Clang, and LLD sources](https://releases.llvm.org/download.html#21.0.0)
-The downloads from llvm lead to the github release pages, where the source's
-will be listed as : `llvm-21.X.X.src.tar.xz`, `clang-21.X.X.src.tar.xz`,
-`lld-21.X.X.src.tar.xz`. Unzip each to their own directory. Ensure no
-directories have spaces in them. For example:
-
- * `C:\Users\Andy\llvm-21.0.0.src`
- * `C:\Users\Andy\clang-21.0.0.src`
- * `C:\Users\Andy\lld-21.0.0.src`
-
-Install [Build Tools for Visual Studio
-2019](https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2019).
-Be sure to select "C++ build tools" when prompted.
- * You **must** additionally check the optional component labeled **C++ ATL for
-   v142 build tools**. As this won't be supplied by a default installation of
-   Visual Studio.
- * Full list of supported MSVC versions:
-   - 2017 (version 15.8) (unverified)
-   - 2019 (version 16.7)
-
-Install [Python 3.9.4](https://www.python.org). Tick the box to add python to
-your PATH environment variable.
-
-#### LLVM
-
-Using the start menu, run **x64 Native Tools Command Prompt for VS 2019** and execute these commands, replacing `C:\Users\Andy` with the correct value. Here is listed a brief explanation of each of the CMake parameters we pass when configuring the build
-
-- `-Thost=x64` : Sets the windows toolset to use 64 bit mode.
-- `-A x64` : Make the build target 64 bit .
-- `-G "Visual Studio 16 2019"` : Specifies to generate a 2019 Visual Studio project, the best supported version.
-- `-DCMAKE_INSTALL_PREFIX=""` : Path that llvm components will being installed into by the install project.
-- `-DCMAKE_PREFIX_PATH=""` : Path that CMake will look into first when trying to locate dependencies, should be the same place as the install prefix. This will ensure that clang and lld will use your newly built llvm libraries.
-- `-DLLVM_ENABLE_ZLIB=OFF` : Don't build llvm with ZLib support as it's not required and will disrupt the target dependencies for components linking against llvm. This only has to be passed when building llvm, as this option will be saved into the config headers.
-- `-DCMAKE_BUILD_TYPE=Release` : Build llvm and components in release mode.
-- `-DCMAKE_BUILD_TYPE=Debug` : Build llvm and components in debug mode.
-- `-DLLVM_USE_CRT_RELEASE=MT` : Which C runtime should llvm use during release builds.
-- `-DLLVM_USE_CRT_DEBUG=MTd` : Make llvm use the debug version of the runtime in debug builds.
-
-##### Release Mode
-
-```bat
-mkdir C:\Users\Andy\llvm-21.0.0.src\build-release
-cd C:\Users\Andy\llvm-21.0.0.src\build-release
-"c:\Program Files\CMake\bin\cmake.exe" .. -Thost=x64 -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX=C:\Users\Andy\llvm+clang+lld-21.0.0-x86_64-windows-msvc-release-mt -DCMAKE_PREFIX_PATH=C:\Users\Andy\llvm+clang+lld-21.0.0-x86_64-windows-msvc-release-mt -
-DLLVM_ENABLE_ZLIB=OFF -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_LIBXML2=OFF -DLLVM_USE_CRT_RELEASE=MT
-msbuild /m -p:Configuration=Release INSTALL.vcxproj
-```
-
-##### Debug Mode
-
-```bat
-mkdir C:\Users\Andy\llvm-21.0.0.src\build-debug
-cd C:\Users\Andy\llvm-21.0.0.src\build-debug
-"c:\Program Files\CMake\bin\cmake.exe" .. -Thost=x64 -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX=C:\Users\andy\llvm+clang+lld-21.0.0-x86_64-windows-msvc-debug -
-DLLVM_ENABLE_ZLIB=OFF -DCMAKE_PREFIX_PATH=C:\Users\andy\llvm+clang+lld-21.0.0-x86_64-windows-msvc-debug -DCMAKE_BUILD_TYPE=Debug -DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD="AVR" -DLLVM_ENABLE_LIBXML2=OFF -DLLVM_USE_CRT_DEBUG=MTd
-msbuild /m INSTALL.vcxproj
-```
-
-#### LLD
-
-Using the start menu, run **x64 Native Tools Command Prompt for VS 2019** and execute these commands, replacing `C:\Users\Andy` with the correct value.
-
-##### Release Mode
-
-```bat
-mkdir C:\Users\Andy\lld-21.0.0.src\build-release
-cd C:\Users\Andy\lld-21.0.0.src\build-release
-"c:\Program Files\CMake\bin\cmake.exe" .. -Thost=x64 -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX=C:\Users\Andy\llvm+clang+lld-14.0.6-x86_64-windows-msvc-release-mt -DCMAKE_PREFIX_PATH=C:\Users\Andy\llvm+clang+lld-21.0.0-x86_64-windows-msvc-release-mt -DCMAKE_BUILD_TYPE=Release -DLLVM_USE_CRT_RELEASE=MT
-msbuild /m -p:Configuration=Release INSTALL.vcxproj
-```
-
-##### Debug Mode
-
-```bat
-mkdir C:\Users\Andy\lld-21.0.0.src\build-debug
-cd C:\Users\Andy\lld-21.0.0.src\build-debug
-"c:\Program Files\CMake\bin\cmake.exe" .. -Thost=x64 -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX=C:\Users\andy\llvm+clang+lld-21.0.0-x86_64-windows-msvc-debug -DCMAKE_PREFIX_PATH=C:\Users\andy\llvm+clang+lld-21.0.0-x86_64-windows-msvc-debug -DCMAKE_BUILD_TYPE=Debug -DLLVM_USE_CRT_DEBUG=MTd
-msbuild /m INSTALL.vcxproj
-```
-
-#### Clang
-
-Using the start menu, run **x64 Native Tools Command Prompt for VS 2019** and execute these commands, replacing `C:\Users\Andy` with the correct value.
-
-##### Release Mode
-
-```bat
-mkdir C:\Users\Andy\clang-21.0.0.src\build-release
-cd C:\Users\Andy\clang-21.0.0.src\build-release
-"c:\Program Files\CMake\bin\cmake.exe" .. -Thost=x64 -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX=C:\Users\Andy\llvm+clang+lld-21.0.0-x86_64-windows-msvc-release-mt -DCMAKE_PREFIX_PATH=C:\Users\Andy\llvm+clang+lld-21.0.0-x86_64-windows-msvc-release-mt -DCMAKE_BUILD_TYPE=Release -DLLVM_USE_CRT_RELEASE=MT
-msbuild /m -p:Configuration=Release INSTALL.vcxproj
-```
-
-##### Debug Mode
-
-```bat
-mkdir C:\Users\Andy\clang-21.0.0.src\build-debug
-cd C:\Users\Andy\clang-21.0.0.src\build-debug
-"c:\Program Files\CMake\bin\cmake.exe" .. -Thost=x64 -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX=C:\Users\andy\llvm+clang+lld-21.0.0-x86_64-windows-msvc-debug -DCMAKE_PREFIX_PATH=C:\Users\andy\llvm+clang+lld-21.0.0-x86_64-windows-msvc-debug -DCMAKE_BUILD_TYPE=Debug -DLLVM_USE_CRT_DEBUG=MTd
-msbuild /m INSTALL.vcxproj
-```
-
-### POSIX Systems
-
-This guide will get you both a Debug build of LLVM, and/or a Release build of LLVM.
-It intentionally does not require privileged access, using a prefix inside your home
-directory instead of a global installation.
-
-#### Release
-
-This is the generally recommended approach.
-
-```
-cd ~/Downloads
-git clone --depth 1 --branch release/21.x https://github.com/llvm/llvm-project llvm-project-21
-cd llvm-project-21
-git checkout release/21.x
-
-mkdir build-release
-cd build-release
-cmake ../llvm \
-  -DCMAKE_INSTALL_PREFIX=$HOME/local/llvm21-assert \
-  -DCMAKE_BUILD_TYPE=Release \
-  -DLLVM_ENABLE_PROJECTS="lld;clang" \
-  -DLLVM_ENABLE_LIBXML2=OFF \
-  -DLLVM_ENABLE_TERMINFO=OFF \
-  -DLLVM_ENABLE_LIBEDIT=OFF \
-  -DLLVM_ENABLE_ASSERTIONS=ON \
-  -DLLVM_PARALLEL_LINK_JOBS=1 \
-  -G Ninja
-ninja install
-```
-
-#### Debug
-
-This is occasionally needed when debugging Zig's LLVM backend. Here we build
-the three projects separately so that LLVM can be in Debug mode while the
-others are in Release mode.
-
-```
-cd ~/Downloads
-git clone --depth 1 --branch release/21.x https://github.com/llvm/llvm-project llvm-project-21
-cd llvm-project-21
-git checkout release/21.x
-
-# LLVM
-mkdir llvm/build-debug
-cd llvm/build-debug
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX=$HOME/local/llvm21-debug \
-  -DCMAKE_PREFIX_PATH=$HOME/local/llvm21-debug \
-  -DCMAKE_BUILD_TYPE=Debug \
-  -DLLVM_ENABLE_LIBXML2=OFF \
-  -DLLVM_ENABLE_TERMINFO=OFF \
-  -DLLVM_ENABLE_LIBEDIT=OFF \
-  -DLLVM_PARALLEL_LINK_JOBS=1 \
-  -G Ninja
-ninja install
-cd ../..
-
-# LLD
-mkdir lld/build-debug
-cd lld/build-debug
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX=$HOME/local/llvm21-debug \
-  -DCMAKE_PREFIX_PATH=$HOME/local/llvm21-debug \
-  -DCMAKE_BUILD_TYPE=Release \
-  -DLLVM_PARALLEL_LINK_JOBS=1 \
-  -DCMAKE_CXX_STANDARD=17 \
-  -G Ninja
-ninja install
-cd ../..
-
-# Clang
-mkdir clang/build-debug
-cd clang/build-debug
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX=$HOME/local/llvm21-debug \
-  -DCMAKE_PREFIX_PATH=$HOME/local/llvm21-debug \
-  -DCMAKE_BUILD_TYPE=Release \
-  -DLLVM_PARALLEL_LINK_JOBS=1 \
-  -DLLVM_INCLUDE_TESTS=OFF \
-  -G Ninja
-ninja install
-cd ../..
-```
-
-Then add to your Zig CMake line that you got from the README.md:
-`-DCMAKE_PREFIX_PATH=$HOME/local/llvm21-debug` or
-`-DCMAKE_PREFIX_PATH=$HOME/local/llvm21-assert` depending on whether you want
-Debug or Release LLVM.
-
-
 ## Contributing
 
 [Donate monthly](https://ziglang.org/zsf/).
 
-[Join a community](https://ziglang.org/community/).
-
 Zig is Free and Open Source Software. We welcome bug reports and patches from
 everyone. However, keep in mind that Zig governance is BDFN (Benevolent
 Dictator For Now) which means that Andrew Kelley has final say on the design
 and implementation of everything.
 
-### Make Software With Zig
-
 One of the best ways you can contribute to Zig is to start using it for an
 open-source personal project.
 
@@ -458,343 +113,35 @@ further design iterations of Zig. Importantly, each issue found this way comes
 with real world motivations, making it straightforward to explain the reasoning
 behind proposals and feature requests.
 
-Ideally, such a project will help you to learn new skills and add something
-to your personal portfolio at the same time.
-
-### Talk About Zig
-
-Another way to contribute is to write about Zig, speak about Zig at a
-conference, or do either of those things for your project which uses Zig.
-
-Programming languages live and die based on the pulse of their ecosystems. The
-more people involved, the more we can build great things upon each other's
-abstractions.
-
-### Strict No LLM / No AI Policy
-
-No LLMs for issues.
-
-No LLMs for patches / pull requests.
-
-No LLMs for comments on the bug tracker, including translation.
-
-English is encouraged, but not required. You are welcome to post in your native
-language and rely on others to have their own translation tools of choice to
-interpret your words.
-
-### Find a Contributor Friendly Issue
+You will be taken much more seriously on the issue tracker if you have a
+personal project that uses Zig.
 
 The issue label
-[Contributor Friendly](https://codeberg.org/ziglang/zig/issues?labels=741726&state=open)
-exists to help you find issues that are **limited in scope and/or
-knowledge of Zig internals.**
+[Contributor Friendly](https://github.com/ziglang/zig/issues?q=is%3Aissue+is%3Aopen+label%3A%22contributor+friendly%22)
+exists to help you find issues that are **limited in scope and/or knowledge of
+Zig internals.**
 
 Please note that issues labeled
-[Proposal: Proposed](https://codeberg.org/ziglang/zig/issues?labels=746937&state=open)
-are still under consideration, and efforts to implement such a proposal have
-a high risk of being wasted. If you are interested in a proposal which is
+[Proposal](https://github.com/ziglang/zig/issues?q=is%3Aissue+is%3Aopen+label%3Aproposal)
+but do not also have the
+[Accepted](https://github.com/ziglang/zig/issues?q=is%3Aissue+is%3Aopen+label%3Aaccepted)
+label are still under consideration, and efforts to implement such a proposal
+have a high risk of being wasted. If you are interested in a proposal which is
 still under consideration, please express your interest in the issue tracker,
 providing extra insights and considerations that others have not yet expressed.
 The most highly regarded argument in such a discussion is a real world use case.
 
-Language proposals are not accepted. Please do not open an issue proposing to
-change the Zig language or syntax.
+For more tips, please see the
+[Contributing](https://github.com/ziglang/zig/wiki/Contributing) page on the
+wiki.
 
-### Editing Source Code
+## Community
 
-For a smooth workflow, when building from source, it is recommended to use
-CMake with the following settings:
-
- * `-DCMAKE_BUILD_TYPE=Release` - to recompile zig faster.
- * `-GNinja` - Ninja is faster and simpler to use than Make.
- * `-DZIG_NO_LIB=ON` - Prevents the build system from copying the lib/
-   directory to the installation prefix, causing zig use lib/ directly from the
-   source tree instead. Effectively, this makes it so that changes to lib/ do
-   not require re-running the install command to become active.
-
-After configuration, there are two scenarios:
-
- 1. Pulling upstream changes and rebuilding.
-    - In this case use `git pull` and then `ninja install`. Expected wait:
-      about 10 minutes.
- 2. Building from source after making local changes.
-    - In this case use `stage3/bin/zig build -p stage4 -Denable-llvm -Dno-lib`.
-      Expected wait: about 20 seconds.
-
-This leaves you with two builds of Zig:
-
- * `stage3/bin/zig` - an optimized master branch build. Useful for
-   miscellaneous activities such as `zig fmt`, as well as for building the
-   compiler itself after changing the source code.
- * `stage4/bin/zig` - a debug build that includes your local changes; useful
-   for testing and eliminating bugs before submitting a patch.
-
-To reduce time spent waiting for the compiler to build, try these techniques:
-
- * Omit `-Denable-llvm` if you don't need the LLVM backend.
- * Use `-Ddev=foo` to build with a reduced feature set for development of
-   specific features. See `zig build -h` for a list of options.
- * Use `--watch -fincremental` to enable incremental compilation. This offers
-   **near instant rebuilds**.
-
-### Testing
-
-```
-stage4/bin/zig build test
-```
-
-This command runs the whole test suite, which does a lot of extra testing that
-you likely won't always need, and can take upwards of 1 hour. This is what the
-CI server runs when you make a pull request.
-
-To save time, you can add the `--help` option to the `zig build` command and
-see what options are available. One of the most helpful ones is
-`-Dskip-release`. Adding this option to the command above, along with
-`-Dskip-non-native`, will take the time down from around 2 hours to about 30
-minutes, and this is a good enough amount of testing before making a pull
-request.
-
-Another example is choosing a different set of things to test. For example,
-`test-std` instead of `test` will only run the standard library tests, and
-not the other ones. Combining this suggestion with the previous one, you could
-do this:
-
-```
-stage4/bin/zig build test-std -Dskip-release
-```
-
-This will run only the standard library tests in debug mode for all targets.
-It will cross-compile the tests for non-native targets but not run them.
-
-When making changes to the compiler source code, the most helpful test step to
-run is `test-behavior`. When editing documentation it is `docs`. You can find
-this information and more in the `zig build --help` menu.
-
-#### Directly Testing the Standard Library with `zig test`
-
-This command will run the standard library tests with only the native target
-configuration and is estimated to complete in 3 minutes:
-
-```
-zig build test-std -Dno-matrix
-```
-
-However, one may also use `zig test` directly. From inside the `ziglang/zig` repo root:
-
-```
-zig test lib/std/std.zig --zig-lib-dir lib
-```
-
-You can add `--test-filter "some test name"` to run a specific test or a subset of tests.
-(Running exactly 1 test is not reliably possible, because the test filter does not
-exclude anonymous test blocks, but that shouldn't interfere with whatever
-you're trying to test in practice.)
-
-Note that `--test-filter` filters on fully qualified names, so e.g. it's possible to run only the `std.json` tests with:
-
-```
-zig test lib/std/std.zig --zig-lib-dir lib --test-filter "json."
-```
-
-If you used `-Dno-lib` and you are in a `build/` subdirectory, you can omit the
-`--zig-lib-dir` argument:
-
-```
-stage3/bin/zig test ../lib/std/std.zig
-```
-
-#### Testing Non-Native Architectures with QEMU
-
-The Linux CI server additionally has qemu installed and sets `-fqemu`.
-This provides test coverage for, e.g. aarch64 even on x86_64 machines. It's
-recommended for Linux users to install qemu and enable this testing option
-when editing the standard library or anything related to a non-native
-architecture.
-
-QEMU packages provided by some system package managers (such as Debian) may be
-a few releases old, or may be missing newer targets such as aarch64 and RISC-V.
-[ziglang/qemu-static](https://codeberg.org/ziglang/qemu-static) offers static
-binaries of the latest QEMU version.
-
-##### Testing Non-Native glibc Targets
-
-Testing foreign architectures with dynamically linked glibc is one step trickier.
-This requires enabling `--glibc-runtimes /path/to/glibc/multi/install/glibcs`.
-This path is obtained by building glibc for multiple architectures. This
-process for me took an entire day to complete and takes up 65 GiB on my hard
-drive. The CI server does not provide this test coverage.
-
-[Instructions for producing this path](https://codeberg.org/ziglang/infra/src/branch/master/building-libcs.md#linux-glibc) (just the part with `build-many-glibcs.py`).
-
-It is understood that most contributors will not have these tests enabled.
-
-#### Testing Windows from a Linux Machine with Wine
-
-When developing on Linux, another option is available to you: `-fwine`.
-This will enable running behavior tests and std lib tests with Wine. It's
-recommended for Linux users to install Wine and enable this testing option
-when editing the standard library or anything Windows-related.
-
-#### Testing WebAssembly using wasmtime
-
-If you have [wasmtime](https://wasmtime.dev/) installed, take advantage of the
-`-fwasmtime` flag which will enable running WASI behavior tests and std
-lib tests. It's recommended for all users to install wasmtime and enable this
-testing option when editing the standard library and especially anything
-WebAssembly-related.
-
-### Improving Translate-C
-
-`translate-c` is a feature provided by Zig that converts C source code into
-Zig source code. It powers the `zig translate-c` command as well as
-[@cImport](https://ziglang.org/documentation/master/#cImport), allowing Zig
-code to not only take advantage of function prototypes defined in .h files,
-but also `static inline` functions written in C, and even some macros.
-
-This feature used to work by using libclang API to parse and semantically
-analyze C/C++ files, and then based on the provided AST and type information,
-generating Zig AST, and finally using the mechanisms of `zig fmt` to render the
-Zig AST to a file.
-
-However, C translation is in a transitional period right now. It used to be
-based on Clang, but is now based on Aro:
-
-[Pull Request: update aro and translate-c to latest; delete clang translate-c](https://github.com/ziglang/zig/pull/24497)
-
-Test coverage as well as bug reports have been moved to this repository:
-
-[ziglang/translate-c](https://codeberg.org/ziglang/translate-c/)
-
-In the future, [@cImport will move to the build system](https://github.com/ziglang/zig/issues/20630),
-but for now, the translate-c logic is copy-pasted from that project into
-[ziglang/zig](https://codeberg.org/ziglang/zig/), powering both `zig translate-c`
-and `@cImport`.
-
-Please see the readme of the translate-c project for how to contribute. Once an
-issue is resolved (and test coverage added) there, the changes can be
-immediately backported to the zig compiler.
-
-Once we fix the problems people are facing from this transition from Clang to
-Aro, we can move on to enhancing the translate-c package such that `@cImport`
-becomes redundant and can therefore be eliminated from the language.
-
-### Autodoc
-
-Autodoc is an interactive, searchable, single-page web application for browsing
-Zig codebases.
-
-An autodoc deployment looks like this:
-
-```
-index.html
-main.js
-main.wasm
-sources.tar
-```
-
-* `main.js` and `index.html` are static files which live in a Zig installation
-  at `lib/docs/`.
-* `main.wasm` is compiled from the Zig files inside `lib/docs/wasm/`.
-* `sources.tar` is all the zig source files of the project.
-
-These artifacts are produced by the compiler when `-femit-docs` is passed.
-
-#### Making Changes
-
-The command `zig std` spawns an HTTP server that provides all the assets
-mentioned above specifically for the standard library.
-
-The server creates the requested files on the fly, including rebuilding
-`main.wasm` if any of its source files changed, and constructing `sources.tar`,
-meaning that any source changes to the documented files, or to the autodoc
-system itself are immediately reflected when viewing docs.
-
-This means you can test changes to Zig standard library documentation, as well
-as autodocs functionality, by pressing refresh in the browser.
-
-Prefixing the URL with `/debug` results in a debug build of `main.wasm`.
-
-#### Debugging the Zig Code
-
-While Firefox and Safari support are obviously required, I recommend Chromium
-for development for one reason in particular:
-
-[C/C++ DevTools Support (DWARF)](https://chromewebstore.google.com/detail/cc++-devtools-support-dwa/pdcpmagijalfljmkmjngeonclgbbannb)
-
-This makes debugging Zig WebAssembly code a breeze.
-
-#### The Sources Tarball
-
-The system expects the top level of `sources.tar` to be the set of modules
-documented. So for the Zig standard library you would do this:
-`tar cf std.tar std/`. Don't compress it; the idea is to rely on HTTP
-compression.
-
-Any files that are not `.zig` source files will be ignored by `main.wasm`,
-however, those files will take up wasted space in the tar file. For the
-standard library, use the set of files that zig installs to when running `zig
-build`, which is the same as the set of files that are provided on
-ziglang.org/download.
-
-If the system doesn't find a file named "foo/root.zig" or "foo/foo.zig", it
-will use the first file in the tar as the module root.
-
-You don't typically need to create `sources.tar` yourself, since it is lazily
-provided by the `zig std` HTTP server as well as produced by `-femit-docs`.
-
-
-## Testing Zig Code With LLDB
-
-[@jacobly0](https://github.com/jacobly0) maintains a fork of LLDB with Zig support:
-
-https://github.com/jacobly0/llvm-project/tree/lldb-zig
-
-This fork only contains changes for debugging programs compiled by Zig's
-self-hosted backends, i.e. `zig build-exe -fno-llvm ...`.
-
-### Building
-
-To build the LLDB fork, make sure you have
-[prerequisites](https://lldb.llvm.org/resources/build.html#preliminaries)
-installed, and then do something like:
-
-```
-$ cmake llvm -G Ninja -B build -DLLVM_ENABLE_PROJECTS="clang;lldb" -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLLVM_ENABLE_ASSERTIONS=ON -DLLDB_ENABLE_LIBEDIT=ON -DLLDB_ENABLE_PYTHON=ON
-$ cmake --build build --target lldb --target lldb-server
-```
-
-(You may need to manually [configure
-dependencies](https://lldb.llvm.org/resources/build.html#optional-dependencies)
-if CMake can't find them.)
-
-Once built, you can run `./build/bin/lldb` and so on.
-
-### Pretty Printers
-
-If you will be debugging the Zig compiler itself, or if you will be debugging
-any project compiled with Zig's LLVM backend (not recommended with the LLDB
-fork, prefer vanilla LLDB with a version that matches the version of LLVM that
-Zig is using), you can get a better debugging experience by using
-[`lldb_pretty_printers.py`](https://codeberg.org/ziglang/zig/src/branch/master/tools/lldb_pretty_printers.py).
-
-Put this line in `~/.lldbinit`:
-
-```
-command script import /path/to/zig/tools/lldb_pretty_printers.py
-```
-
-If you will be using Zig's LLVM backend (again, not recommended with the LLDB
-fork), you will also want these lines:
-
-```
-type category enable zig.lang
-type category enable zig.std
-```
-
-If you will be debugging a Zig compiler built using Zig's LLVM backend (again,
-not recommended with the LLDB fork), you will also want this line:
-
-```
-type category enable zig.stage2
-```
+The Zig community is decentralized. Anyone is free to start and maintain their
+own space for Zig users to gather. There is no concept of "official" or
+"unofficial". Each gathering place has its own moderators and rules. Users are
+encouraged to be aware of the social structures of the spaces they inhabit, and
+work purposefully to facilitate spaces that align with their values.
 
+Please see the [Community](https://github.com/ziglang/zig/wiki/Community) wiki
+page for a public listing of social spaces.

bootstrap.c

@@ -64,8 +64,6 @@ static const char *get_host_os(void) {
     return "linux";
 #elif defined(__FreeBSD__)
     return "freebsd";
-#elif defined(__DragonFly__)
-    return "dragonfly";
 #elif defined(__HAIKU__)
     return "haiku";
 #else
@@ -143,7 +141,6 @@ int main(int argc, char **argv) {
             "pub const skip_non_native = false;\n"
             "pub const debug_gpa = false;\n"
             "pub const dev = .core;\n"
-            "pub const io_mode: enum { threaded, evented } = .threaded;\n"
             "pub const value_interpret_mode = .direct;\n"
         , zig_version);
         if (written < 100)

build.zig

@@ -1,21 +1,19 @@
 const std = @import("std");
 const builtin = std.builtin;
+const tests = @import("test/tests.zig");
 const BufMap = std.BufMap;
 const mem = std.mem;
+const ArrayList = std.ArrayList;
+const io = std.io;
 const fs = std.fs;
 const InstallDirectoryOptions = std.Build.InstallDirectoryOptions;
 const assert = std.debug.assert;
-const Io = std.Io;
-
-const tests = @import("test/tests.zig");
 const DevEnv = @import("src/dev.zig").Env;
-
-const zig_version: std.SemanticVersion = .{ .major = 0, .minor = 16, .patch = 0 };
-const stack_size = 46 * 1024 * 1024;
-
-const IoMode = enum { threaded, evented };
 const ValueInterpretMode = enum { direct, by_name };
 
+const zig_version: std.SemanticVersion = .{ .major = 0, .minor = 14, .patch = 1 };
+const stack_size = 46 * 1024 * 1024;
+
 pub fn build(b: *std.Build) !void {
     const only_c = b.option(bool, "only-c", "Translate the Zig compiler to C code, with only the C backend enabled") orelse false;
     const target = b.standardTargetOptions(.{
@@ -30,7 +28,7 @@ pub fn build(b: *std.Build) !void {
     const use_zig_libcxx = b.option(bool, "use-zig-libcxx", "If libc++ is needed, use zig's bundled version, don't try to integrate with the system") orelse false;
 
     const test_step = b.step("test", "Run all the tests");
-    const skip_install_lib_files = b.option(bool, "no-lib", "skip copying of lib/ files and langref to installation prefix. Useful for development") orelse only_c;
+    const skip_install_lib_files = b.option(bool, "no-lib", "skip copying of lib/ files and langref to installation prefix. Useful for development") orelse false;
     const skip_install_langref = b.option(bool, "no-langref", "skip copying of langref to the installation prefix") orelse skip_install_lib_files;
     const std_docs = b.option(bool, "std-docs", "include standard library autodocs") orelse false;
     const no_bin = b.option(bool, "no-bin", "skip emitting compiler binary") orelse false;
@@ -84,27 +82,16 @@ pub fn build(b: *std.Build) !void {
     docs_step.dependOn(langref_step);
     docs_step.dependOn(std_docs_step);
 
-    const no_matrix = b.option(bool, "no-matrix", "Limit test matrix to exactly one target configuration") orelse false;
-    const fuzz_only = b.option(bool, "fuzz-only", "Limit test matrix to one target suitable for fuzzing") orelse false;
     const skip_debug = b.option(bool, "skip-debug", "Main test suite skips debug builds") orelse false;
-    const skip_release = b.option(bool, "skip-release", "Main test suite skips release builds") orelse no_matrix;
+    const skip_release = b.option(bool, "skip-release", "Main test suite skips release builds") orelse false;
     const skip_release_small = b.option(bool, "skip-release-small", "Main test suite skips release-small builds") orelse skip_release;
     const skip_release_fast = b.option(bool, "skip-release-fast", "Main test suite skips release-fast builds") orelse skip_release;
     const skip_release_safe = b.option(bool, "skip-release-safe", "Main test suite skips release-safe builds") orelse skip_release;
-    const skip_non_native = b.option(bool, "skip-non-native", "Main test suite skips non-native builds") orelse no_matrix;
+    const skip_non_native = b.option(bool, "skip-non-native", "Main test suite skips non-native builds") orelse false;
     const skip_libc = b.option(bool, "skip-libc", "Main test suite skips tests that link libc") orelse false;
     const skip_single_threaded = b.option(bool, "skip-single-threaded", "Main test suite skips tests that are single-threaded") orelse false;
-    const skip_compile_errors = b.option(bool, "skip-compile-errors", "Main test suite skips compile error tests") orelse false;
-    const skip_spirv = b.option(bool, "skip-spirv", "Main test suite skips targets with spirv32/spirv64 architecture") orelse false;
-    const skip_wasm = b.option(bool, "skip-wasm", "Main test suite skips targets with wasm32/wasm64 architecture") orelse false;
-    const skip_freebsd = b.option(bool, "skip-freebsd", "Main test suite skips targets with freebsd OS") orelse false;
-    const skip_netbsd = b.option(bool, "skip-netbsd", "Main test suite skips targets with netbsd OS") orelse false;
-    const skip_openbsd = b.option(bool, "skip-openbsd", "Main test suite skips targets with openbsd OS") orelse false;
-    const skip_windows = b.option(bool, "skip-windows", "Main test suite skips targets with windows OS") orelse false;
-    const skip_darwin = b.option(bool, "skip-darwin", "Main test suite skips targets with darwin OSs") orelse false;
-    const skip_linux = b.option(bool, "skip-linux", "Main test suite skips targets with linux OS") orelse false;
-    const skip_llvm = b.option(bool, "skip-llvm", "Main test suite skips targets that use LLVM backend") orelse false;
-    const skip_test_incremental = b.option(bool, "skip-test-incremental", "Main test step omits dependency on test-incremental step") orelse false;
+    const skip_translate_c = b.option(bool, "skip-translate-c", "Main test suite skips translate-c tests") orelse false;
+    const skip_run_translated_c = b.option(bool, "skip-run-translated-c", "Main test suite skips run-translated-c tests") orelse false;
 
     const only_install_lib_files = b.option(bool, "lib-files-only", "Only install library files") orelse false;
 
@@ -190,7 +177,6 @@ pub fn build(b: *std.Build) !void {
     const strip = b.option(bool, "strip", "Omit debug information");
     const valgrind = b.option(bool, "valgrind", "Enable valgrind integration");
     const pie = b.option(bool, "pie", "Produce a Position Independent Executable");
-    const io_mode = b.option(IoMode, "io-mode", "How the compiler performs IO") orelse .threaded;
     const value_interpret_mode = b.option(ValueInterpretMode, "value-interpret-mode", "How the compiler translates between 'std.builtin' types and its internal datastructures") orelse .direct;
     const value_tracing = b.option(bool, "value-tracing", "Enable extra state tracking to help troubleshoot bugs in the compiler (using the std.debug.Trace API)") orelse false;
 
@@ -210,11 +196,12 @@ pub fn build(b: *std.Build) !void {
     });
     exe.pie = pie;
     exe.entitlements = entitlements;
-    exe.use_new_linker = b.option(bool, "new-linker", "Use the new linker");
 
-    const use_llvm = b.option(bool, "use-llvm", "Use the llvm backend");
-    exe.use_llvm = use_llvm;
-    exe.use_lld = use_llvm;
+    exe.build_id = b.option(
+        std.zig.BuildId,
+        "build-id",
+        "Request creation of '.note.gnu.build-id' section",
+    );
 
     if (no_bin) {
         b.getInstallStep().dependOn(&exe.step);
@@ -227,6 +214,10 @@ pub fn build(b: *std.Build) !void {
 
     test_step.dependOn(&exe.step);
 
+    const use_llvm = b.option(bool, "use-llvm", "Use the llvm backend");
+    exe.use_llvm = use_llvm;
+    exe.use_lld = use_llvm;
+
     const exe_options = b.addOptions();
     exe.root_module.addOptions("build_options", exe_options);
 
@@ -239,7 +230,6 @@ pub fn build(b: *std.Build) !void {
     exe_options.addOption(bool, "llvm_has_xtensa", llvm_has_xtensa);
     exe_options.addOption(bool, "debug_gpa", debug_gpa);
     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);
-    exe_options.addOption(IoMode, "io_mode", io_mode);
     exe_options.addOption(ValueInterpretMode, "value_interpret_mode", value_interpret_mode);
 
     if (link_libc) {
@@ -266,12 +256,12 @@ pub fn build(b: *std.Build) !void {
             "--git-dir", ".git", // affected by the -C argument
             "describe", "--match",    "*.*.*", //
             "--tags",   "--abbrev=9",
-        }, &code, .ignore) catch {
+        }, &code, .Ignore) catch {
             break :v version_string;
         };
         const git_describe = mem.trim(u8, git_describe_untrimmed, " \n\r");
 
-        switch (mem.countScalar(u8, git_describe, '-')) {
+        switch (mem.count(u8, git_describe, "-")) {
             0 => {
                 // Tagged release version (e.g. 0.10.0).
                 if (!mem.eql(u8, git_describe, version_string)) {
@@ -289,7 +279,7 @@ pub fn build(b: *std.Build) !void {
 
                 const ancestor_ver = try std.SemanticVersion.parse(tagged_ancestor);
                 if (zig_version.order(ancestor_ver) != .gt) {
-                    std.debug.print("Zig version '{f}' must be greater than tagged ancestor '{f}'\n", .{ zig_version, ancestor_ver });
+                    std.debug.print("Zig version '{}' must be greater than tagged ancestor '{}'\n", .{ zig_version, ancestor_ver });
                     std.process.exit(1);
                 }
 
@@ -313,10 +303,8 @@ pub fn build(b: *std.Build) !void {
 
     if (enable_llvm) {
         const cmake_cfg = if (static_llvm) null else blk: {
-            const io = b.graph.io;
-            const cwd: Io.Dir = .cwd();
             if (findConfigH(b, config_h_path_option)) |config_h_path| {
-                const file_contents = cwd.readFileAlloc(io, config_h_path, b.allocator, .limited(max_config_h_bytes)) catch unreachable;
+                const file_contents = fs.cwd().readFileAlloc(b.allocator, config_h_path, max_config_h_bytes) catch unreachable;
                 break :blk parseConfigH(b, file_contents);
             } else {
                 std.log.warn("config.h could not be located automatically. Consider providing it explicitly via \"-Dconfig_h\"", .{});
@@ -371,22 +359,14 @@ pub fn build(b: *std.Build) !void {
             &[_][]const u8{ tracy_path, "public", "TracyClient.cpp" },
         );
 
-        const tracy_c_flags: []const []const u8 = &.{
-            "-DTRACY_ENABLE=1",
-            "-fno-sanitize=undefined",
-            "-DTRACY_FIBERS",
-        };
+        const tracy_c_flags: []const []const u8 = &.{ "-DTRACY_ENABLE=1", "-fno-sanitize=undefined" };
 
         exe.root_module.addIncludePath(.{ .cwd_relative = tracy_path });
-        exe.root_module.addCSourceFile(.{
-            .file = .{ .cwd_relative = client_cpp },
-            .flags = tracy_c_flags[0..switch (io_mode) {
-                .threaded => 2,
-                .evented => 3,
-            }],
-        });
+        exe.root_module.addCSourceFile(.{ .file = .{ .cwd_relative = client_cpp }, .flags = tracy_c_flags });
+        if (!enable_llvm) {
+            exe.root_module.linkSystemLibrary("c++", .{ .use_pkg_config = .no });
+        }
         exe.root_module.link_libc = true;
-        exe.root_module.link_libcpp = true;
 
         if (target.result.os.tag == .windows) {
             exe.root_module.linkSystemLibrary("dbghelp", .{});
@@ -396,7 +376,7 @@ pub fn build(b: *std.Build) !void {
 
     const test_filters = b.option([]const []const u8, "test-filter", "Skip tests that do not match any filter") orelse &[0][]const u8{};
     const test_target_filters = b.option([]const []const u8, "test-target-filter", "Skip tests whose target triple do not match any filter") orelse &[0][]const u8{};
-    const test_extra_targets = b.option(bool, "test-extra-targets", "Enable running module tests for additional targets") orelse false;
+    const test_slow_targets = b.option(bool, "test-slow-targets", "Enable running module tests for targets that have a slow compiler backend") orelse false;
 
     var chosen_opt_modes_buf: [4]builtin.OptimizeMode = undefined;
     var chosen_mode_index: usize = 0;
@@ -418,13 +398,6 @@ pub fn build(b: *std.Build) !void {
     }
     const optimization_modes = chosen_opt_modes_buf[0..chosen_mode_index];
 
-    const test_only: ?tests.ModuleTestOptions.TestOnly = if (no_matrix)
-        .default
-    else if (fuzz_only)
-        .{ .fuzz = optimize }
-    else
-        null;
-
     const fmt_include_paths = &.{ "lib", "src", "test", "tools", "build.zig", "build.zig.zon" };
     const fmt_exclude_paths = &.{ "test/cases", "test/behavior/zon" };
     const do_fmt = b.addFmt(.{
@@ -442,21 +415,9 @@ pub fn build(b: *std.Build) !void {
     test_step.dependOn(check_fmt);
 
     const test_cases_step = b.step("test-cases", "Run the main compiler test cases");
-    try tests.addCases(b, test_cases_step, .{
-        .test_filters = test_filters,
-        .test_target_filters = test_target_filters,
-        .skip_compile_errors = skip_compile_errors,
-        .skip_non_native = skip_non_native,
-        .skip_spirv = skip_spirv,
-        .skip_wasm = skip_wasm,
-        .skip_freebsd = skip_freebsd,
-        .skip_netbsd = skip_netbsd,
-        .skip_openbsd = skip_openbsd,
-        .skip_windows = skip_windows,
-        .skip_darwin = skip_darwin,
-        .skip_linux = skip_linux,
-        .skip_llvm = skip_llvm,
-        .skip_libc = skip_libc,
+    try tests.addCases(b, test_cases_step, test_filters, test_target_filters, target, .{
+        .skip_translate_c = skip_translate_c,
+        .skip_run_translated_c = skip_run_translated_c,
     }, .{
         .enable_llvm = enable_llvm,
         .llvm_has_m68k = llvm_has_m68k,
@@ -472,7 +433,7 @@ pub fn build(b: *std.Build) !void {
     test_modules_step.dependOn(tests.addModuleTests(b, .{
         .test_filters = test_filters,
         .test_target_filters = test_target_filters,
-        .test_extra_targets = test_extra_targets,
+        .test_slow_targets = test_slow_targets,
         .root_src = "test/behavior.zig",
         .name = "behavior",
         .desc = "Run the behavior tests",
@@ -480,24 +441,30 @@ pub fn build(b: *std.Build) !void {
         .include_paths = &.{},
         .skip_single_threaded = skip_single_threaded,
         .skip_non_native = skip_non_native,
-        .test_only = test_only,
-        .skip_spirv = skip_spirv,
-        .skip_wasm = skip_wasm,
-        .skip_freebsd = skip_freebsd,
-        .skip_netbsd = skip_netbsd,
-        .skip_openbsd = skip_openbsd,
-        .skip_windows = skip_windows,
-        .skip_darwin = skip_darwin,
-        .skip_linux = skip_linux,
-        .skip_llvm = skip_llvm,
         .skip_libc = skip_libc,
-        .max_rss = 4_000_000_000,
+        .use_llvm = use_llvm,
+        .max_rss = 2 * 1024 * 1024 * 1024,
     }));
 
     test_modules_step.dependOn(tests.addModuleTests(b, .{
         .test_filters = test_filters,
         .test_target_filters = test_target_filters,
-        .test_extra_targets = test_extra_targets,
+        .test_slow_targets = test_slow_targets,
+        .root_src = "test/c_import.zig",
+        .name = "c-import",
+        .desc = "Run the @cImport tests",
+        .optimize_modes = optimization_modes,
+        .include_paths = &.{"test/c_import"},
+        .skip_single_threaded = true,
+        .skip_non_native = skip_non_native,
+        .skip_libc = skip_libc,
+        .use_llvm = use_llvm,
+    }));
+
+    test_modules_step.dependOn(tests.addModuleTests(b, .{
+        .test_filters = test_filters,
+        .test_target_filters = test_target_filters,
+        .test_slow_targets = test_slow_targets,
         .root_src = "lib/compiler_rt.zig",
         .name = "compiler-rt",
         .desc = "Run the compiler_rt tests",
@@ -505,51 +472,31 @@ pub fn build(b: *std.Build) !void {
         .include_paths = &.{},
         .skip_single_threaded = true,
         .skip_non_native = skip_non_native,
-        .test_only = test_only,
-        .skip_spirv = skip_spirv,
-        .skip_wasm = skip_wasm,
-        .skip_freebsd = skip_freebsd,
-        .skip_netbsd = skip_netbsd,
-        .skip_openbsd = skip_openbsd,
-        .skip_windows = skip_windows,
-        .skip_darwin = skip_darwin,
-        .skip_linux = skip_linux,
-        .skip_llvm = skip_llvm,
         .skip_libc = true,
+        .use_llvm = use_llvm,
         .no_builtin = true,
-        .max_rss = 4_000_000_000,
     }));
 
     test_modules_step.dependOn(tests.addModuleTests(b, .{
         .test_filters = test_filters,
         .test_target_filters = test_target_filters,
-        .test_extra_targets = test_extra_targets,
+        .test_slow_targets = test_slow_targets,
         .root_src = "lib/c.zig",
-        .name = "zigc",
-        .desc = "Run the zig libc implementation unit tests",
+        .name = "universal-libc",
+        .desc = "Run the universal libc tests",
         .optimize_modes = optimization_modes,
         .include_paths = &.{},
         .skip_single_threaded = true,
         .skip_non_native = skip_non_native,
-        .test_only = test_only,
-        .skip_spirv = skip_spirv,
-        .skip_wasm = skip_wasm,
-        .skip_freebsd = skip_freebsd,
-        .skip_netbsd = skip_netbsd,
-        .skip_openbsd = skip_openbsd,
-        .skip_windows = skip_windows,
-        .skip_darwin = skip_darwin,
-        .skip_linux = skip_linux,
-        .skip_llvm = skip_llvm,
         .skip_libc = true,
+        .use_llvm = use_llvm,
         .no_builtin = true,
-        .max_rss = 4_000_000_000,
     }));
 
     test_modules_step.dependOn(tests.addModuleTests(b, .{
         .test_filters = test_filters,
         .test_target_filters = test_target_filters,
-        .test_extra_targets = test_extra_targets,
+        .test_slow_targets = test_slow_targets,
         .root_src = "lib/std/std.zig",
         .name = "std",
         .desc = "Run the standard library tests",
@@ -557,41 +504,32 @@ pub fn build(b: *std.Build) !void {
         .include_paths = &.{},
         .skip_single_threaded = skip_single_threaded,
         .skip_non_native = skip_non_native,
-        .test_only = test_only,
-        .skip_spirv = skip_spirv,
-        .skip_wasm = skip_wasm,
-        .skip_freebsd = skip_freebsd,
-        .skip_netbsd = skip_netbsd,
-        .skip_openbsd = skip_openbsd,
-        .skip_windows = skip_windows,
-        .skip_darwin = skip_darwin,
-        .skip_linux = skip_linux,
-        .skip_llvm = skip_llvm,
         .skip_libc = skip_libc,
-        .max_rss = 8_500_000_000,
+        .use_llvm = use_llvm,
+        // I observed a value of 5605064704 on the M2 CI.
+        .max_rss = 6165571174,
     }));
 
     const unit_tests_step = b.step("test-unit", "Run the compiler source unit tests");
     test_step.dependOn(unit_tests_step);
 
     const unit_tests = b.addTest(.{
-        .root_module = addCompilerMod(b, .{
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/main.zig"),
             .optimize = optimize,
             .target = target,
+            .link_libc = link_libc,
             .single_threaded = single_threaded,
         }),
         .filters = test_filters,
         .use_llvm = use_llvm,
         .use_lld = use_llvm,
         .zig_lib_dir = b.path("lib"),
-        .max_rss = 2_500_000_000,
     });
-    if (link_libc) {
-        unit_tests.root_module.link_libc = true;
-    }
     unit_tests.root_module.addOptions("build_options", exe_options);
     unit_tests_step.dependOn(&b.addRunArtifact(unit_tests).step);
 
+    test_step.dependOn(tests.addCompareOutputTests(b, test_filters, optimization_modes));
     test_step.dependOn(tests.addStandaloneTests(
         b,
         optimization_modes,
@@ -602,21 +540,12 @@ pub fn build(b: *std.Build) !void {
     test_step.dependOn(tests.addCAbiTests(b, .{
         .test_target_filters = test_target_filters,
         .skip_non_native = skip_non_native,
-        .skip_wasm = skip_wasm,
-        .skip_freebsd = skip_freebsd,
-        .skip_netbsd = skip_netbsd,
-        .skip_openbsd = skip_openbsd,
-        .skip_windows = skip_windows,
-        .skip_darwin = skip_darwin,
-        .skip_linux = skip_linux,
-        .skip_llvm = skip_llvm,
         .skip_release = skip_release,
-        .max_rss = 3_000_000_000,
     }));
     test_step.dependOn(tests.addLinkTests(b, enable_macos_sdk, enable_ios_sdk, enable_symlinks_windows));
-    test_step.dependOn(tests.addStackTraceTests(b, test_filters, skip_non_native));
-    test_step.dependOn(tests.addErrorTraceTests(b, test_filters, optimization_modes, skip_non_native));
+    test_step.dependOn(tests.addStackTraceTests(b, test_filters, optimization_modes));
     test_step.dependOn(tests.addCliTests(b));
+    test_step.dependOn(tests.addAssembleAndLinkTests(b, test_filters, optimization_modes));
     if (tests.addDebuggerTests(b, .{
         .test_filters = test_filters,
         .test_target_filters = test_target_filters,
@@ -624,13 +553,9 @@ pub fn build(b: *std.Build) !void {
         .lldb = b.option([]const u8, "lldb", "path to lldb binary"),
         .optimize_modes = optimization_modes,
         .skip_single_threaded = skip_single_threaded,
+        .skip_non_native = skip_non_native,
         .skip_libc = skip_libc,
     })) |test_debugger_step| test_step.dependOn(test_debugger_step);
-    if (tests.addLlvmIrTests(b, .{
-        .enable_llvm = enable_llvm,
-        .test_filters = test_filters,
-        .test_target_filters = test_target_filters,
-    })) |test_llvm_ir_step| test_step.dependOn(test_llvm_ir_step);
 
     try addWasiUpdateStep(b, version);
 
@@ -654,16 +579,8 @@ pub fn build(b: *std.Build) !void {
     }
 
     const test_incremental_step = b.step("test-incremental", "Run the incremental compilation test cases");
-    try tests.addIncrementalTests(b, test_incremental_step, test_filters);
-    if (!skip_test_incremental) test_step.dependOn(test_incremental_step);
-
-    if (tests.addLibcTests(b, .{
-        .optimize_modes = optimization_modes,
-        .test_filters = test_filters,
-        .test_target_filters = test_target_filters,
-        .skip_wasm = skip_wasm,
-        .max_rss = 3_500_000_000,
-    })) |test_libc_step| test_step.dependOn(test_libc_step);
+    try tests.addIncrementalTests(b, test_incremental_step);
+    test_step.dependOn(test_incremental_step);
 }
 
 fn addWasiUpdateStep(b: *std.Build, version: [:0]const u8) !void {
@@ -696,7 +613,6 @@ fn addWasiUpdateStep(b: *std.Build, version: [:0]const u8) !void {
     exe_options.addOption(u32, "tracy_callstack_depth", 0);
     exe_options.addOption(bool, "value_tracing", false);
     exe_options.addOption(DevEnv, "dev", .bootstrap);
-    exe_options.addOption(IoMode, "io_mode", .threaded);
 
     // zig1 chooses to interpret values by name. The tradeoff is as follows:
     //
@@ -725,17 +641,17 @@ fn addWasiUpdateStep(b: *std.Build, version: [:0]const u8) !void {
     });
     run_opt.addArtifactArg(exe);
     run_opt.addArg("-o");
-    const optimized_wasm = run_opt.addOutputFileArg("zig1.wasm");
+    run_opt.addFileArg(b.path("stage1/zig1.wasm"));
 
-    const update_zig1 = b.addUpdateSourceFiles();
-    update_zig1.addCopyFileToSource(optimized_wasm, "stage1/zig1.wasm");
-    update_zig1.addCopyFileToSource(b.path("lib/zig.h"), "stage1/zig.h");
+    const copy_zig_h = b.addUpdateSourceFiles();
+    copy_zig_h.addCopyFileToSource(b.path("lib/zig.h"), "stage1/zig.h");
 
     const update_zig1_step = b.step("update-zig1", "Update stage1/zig1.wasm");
-    update_zig1_step.dependOn(&update_zig1.step);
+    update_zig1_step.dependOn(&run_opt.step);
+    update_zig1_step.dependOn(&copy_zig_h.step);
 }
 
-const AddCompilerModOptions = struct {
+const AddCompilerStepOptions = struct {
     optimize: std.builtin.OptimizeMode,
     target: std.Build.ResolvedTarget,
     strip: ?bool = null,
@@ -744,7 +660,7 @@ const AddCompilerModOptions = struct {
     single_threaded: ?bool = null,
 };
 
-fn addCompilerMod(b: *std.Build, options: AddCompilerModOptions) *std.Build.Module {
+fn addCompilerStep(b: *std.Build, options: AddCompilerStepOptions) *std.Build.Step.Compile {
     const compiler_mod = b.createModule(.{
         .root_source_file = b.path("src/main.zig"),
         .target = options.target,
@@ -752,6 +668,24 @@ fn addCompilerMod(b: *std.Build, options: AddCompilerModOptions) *std.Build.Modu
         .strip = options.strip,
         .sanitize_thread = options.sanitize_thread,
         .single_threaded = options.single_threaded,
+        .code_model = switch (options.target.result.cpu.arch) {
+            // NB:
+            // For loongarch, LLVM supports only small, medium and large
+            // code model. If we don't explicitly specify the code model,
+            // the default value `small' will be used.
+            //
+            // Since zig binary itself is relatively large, using a `small'
+            // code model will cause
+            //
+            // relocation R_LARCH_B26 out of range
+            //
+            // error when linking a loongarch32/loongarch64 zig binary.
+            //
+            // Here we explicitly set code model to `medium' to avoid this
+            // error.
+            .loongarch32, .loongarch64 => .medium,
+            else => .default,
+        },
         .valgrind = options.valgrind,
     });
 
@@ -759,25 +693,21 @@ fn addCompilerMod(b: *std.Build, options: AddCompilerModOptions) *std.Build.Modu
         .root_source_file = b.path("lib/compiler/aro/aro.zig"),
     });
 
+    const aro_translate_c_mod = b.createModule(.{
+        .root_source_file = b.path("lib/compiler/aro_translate_c.zig"),
+    });
+
+    aro_translate_c_mod.addImport("aro", aro_mod);
     compiler_mod.addImport("aro", aro_mod);
+    compiler_mod.addImport("aro_translate_c", aro_translate_c_mod);
 
-    return compiler_mod;
-}
-
-fn addCompilerStep(b: *std.Build, options: AddCompilerModOptions) *std.Build.Step.Compile {
     const exe = b.addExecutable(.{
         .name = "zig",
-        .max_rss = 7_900_000_000,
-        .root_module = addCompilerMod(b, options),
+        .max_rss = 7_800_000_000,
+        .root_module = compiler_mod,
     });
     exe.stack_size = stack_size;
 
-    // Must match the condition in CMakeLists.txt.
-    const function_data_sections = options.target.result.cpu.arch.isArm() or options.target.result.cpu.arch.isPowerPC();
-
-    exe.link_function_sections = function_data_sections;
-    exe.link_data_sections = function_data_sections;
-
     return exe;
 }
 
@@ -794,9 +724,6 @@ const exe_cflags = [_][]const u8{
     "-Wno-type-limits",
     "-Wno-missing-braces",
     "-Wno-comment",
-    // `exe_cflags` is only used for static linking.
-    "-DLLVM_BUILD_STATIC",
-    "-DCLANG_BUILD_STATIC",
 };
 
 fn addCmakeCfgOptionsToExe(
@@ -806,7 +733,7 @@ fn addCmakeCfgOptionsToExe(
     use_zig_libcxx: bool,
 ) !void {
     const mod = exe.root_module;
-    const target = &mod.resolved_target.?.result;
+    const target = mod.resolved_target.?.result;
 
     if (target.os.tag.isDarwin()) {
         // useful for package maintainers
@@ -850,7 +777,7 @@ fn addCmakeCfgOptionsToExe(
                 };
                 mod.linkSystemLibrary("unwind", .{});
             },
-            .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => {
+            .ios, .macos, .watchos, .tvos, .visionos => {
                 mod.link_libcpp = true;
             },
             .windows => {
@@ -871,7 +798,7 @@ fn addCmakeCfgOptionsToExe(
                 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);
             },
-            .illumos => {
+            .solaris, .illumos => {
                 try addCxxKnownPath(b, cfg, exe, b.fmt("libstdc++.{s}", .{lib_suffix}), null, need_cpp_includes);
                 try addCxxKnownPath(b, cfg, exe, b.fmt("libgcc_eh.{s}", .{lib_suffix}), null, need_cpp_includes);
             },
@@ -904,48 +831,46 @@ fn addStaticLlvmOptionsToModule(mod: *std.Build.Module, options: struct {
         .flags = &zig_cpp_cflags,
     });
 
-    const lsl_options: std.Build.Module.LinkSystemLibraryOptions = .{ .use_pkg_config = .no };
-
     for (clang_libs) |lib_name| {
-        mod.linkSystemLibrary(lib_name, lsl_options);
+        mod.linkSystemLibrary(lib_name, .{});
     }
 
     for (lld_libs) |lib_name| {
-        mod.linkSystemLibrary(lib_name, lsl_options);
+        mod.linkSystemLibrary(lib_name, .{});
     }
 
     for (llvm_libs) |lib_name| {
-        mod.linkSystemLibrary(lib_name, lsl_options);
+        mod.linkSystemLibrary(lib_name, .{});
     }
 
     if (options.llvm_has_m68k) for (llvm_libs_m68k) |lib_name| {
-        mod.linkSystemLibrary(lib_name, lsl_options);
+        mod.linkSystemLibrary(lib_name, .{});
     };
 
     if (options.llvm_has_csky) for (llvm_libs_csky) |lib_name| {
-        mod.linkSystemLibrary(lib_name, lsl_options);
+        mod.linkSystemLibrary(lib_name, .{});
     };
 
     if (options.llvm_has_arc) for (llvm_libs_arc) |lib_name| {
-        mod.linkSystemLibrary(lib_name, lsl_options);
+        mod.linkSystemLibrary(lib_name, .{});
     };
 
     if (options.llvm_has_xtensa) for (llvm_libs_xtensa) |lib_name| {
-        mod.linkSystemLibrary(lib_name, lsl_options);
+        mod.linkSystemLibrary(lib_name, .{});
     };
 
-    mod.linkSystemLibrary("z", lsl_options);
-    mod.linkSystemLibrary("zstd", lsl_options);
+    mod.linkSystemLibrary("z", .{});
+    mod.linkSystemLibrary("zstd", .{});
 
     if (mod.resolved_target.?.result.os.tag != .windows or mod.resolved_target.?.result.abi != .msvc) {
         // This means we rely on clang-or-zig-built LLVM, Clang, LLD libraries.
-        mod.linkSystemLibrary("c++", lsl_options);
+        mod.linkSystemLibrary("c++", .{});
     }
 
     if (mod.resolved_target.?.result.os.tag == .windows) {
-        mod.linkSystemLibrary("version", lsl_options);
-        mod.linkSystemLibrary("uuid", lsl_options);
-        mod.linkSystemLibrary("ole32", lsl_options);
+        mod.linkSystemLibrary("version", .{});
+        mod.linkSystemLibrary("uuid", .{});
+        mod.linkSystemLibrary("ole32", .{});
     }
 }
 
@@ -961,7 +886,7 @@ fn addCxxKnownPath(
         return error.RequiredLibraryNotFound;
 
     const path_padded = run: {
-        var args = std.array_list.Managed([]const u8).init(b.allocator);
+        var args = std.ArrayList([]const u8).init(b.allocator);
         try args.append(ctx.cxx_compiler);
         var it = std.mem.tokenizeAny(u8, ctx.cxx_compiler_arg1, &std.ascii.whitespace);
         while (it.next()) |arg| try args.append(arg);
@@ -1030,13 +955,10 @@ const CMakeConfig = struct {
 const max_config_h_bytes = 1 * 1024 * 1024;
 
 fn findConfigH(b: *std.Build, config_h_path_option: ?[]const u8) ?[]const u8 {
-    const io = b.graph.io;
-    const cwd: Io.Dir = .cwd();
-
     if (config_h_path_option) |path| {
-        var config_h_or_err = cwd.openFile(io, path, .{});
+        var config_h_or_err = fs.cwd().openFile(path, .{});
         if (config_h_or_err) |*file| {
-            file.close(io);
+            file.close();
             return path;
         } else |_| {
             std.log.err("Could not open provided config.h: \"{s}\"", .{path});
@@ -1046,13 +968,13 @@ fn findConfigH(b: *std.Build, config_h_path_option: ?[]const u8) ?[]const u8 {
 
     var check_dir = fs.path.dirname(b.graph.zig_exe).?;
     while (true) {
-        var dir = cwd.openDir(io, check_dir, .{}) catch unreachable;
-        defer dir.close(io);
+        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(io, "config.h", .{});
+        var config_h_or_err = dir.openFile("config.h", .{});
         if (config_h_or_err) |*file| {
-            file.close(io);
+            file.close();
             return fs.path.join(
                 b.allocator,
                 &[_][]const u8{ check_dir, "config.h" },
@@ -1063,9 +985,9 @@ fn findConfigH(b: *std.Build, config_h_path_option: ?[]const u8) ?[]const u8 {
         }
 
         // Check if we reached the source root by looking for .git, and bail if so
-        var git_dir_or_err = dir.openDir(io, ".git", .{});
+        var git_dir_or_err = dir.openDir(".git", .{});
         if (git_dir_or_err) |*git_dir| {
-            git_dir.close(io);
+            git_dir.close();
             return null;
         } else |_| {}
 
@@ -1190,6 +1112,7 @@ fn toNativePathSep(b: *std.Build, s: []const u8) []u8 {
 const zig_cpp_sources = [_][]const u8{
     // These are planned to stay even when we are self-hosted.
     "src/zig_llvm.cpp",
+    "src/zig_clang.cpp",
     "src/zig_llvm-ar.cpp",
     "src/zig_clang_driver.cpp",
     "src/zig_clang_cc1_main.cpp",
@@ -1215,6 +1138,7 @@ const clang_libs = [_][]const u8{
     "clangBasic",
     "clangEdit",
     "clangLex",
+    "clangARCMigrate",
     "clangRewriteFrontend",
     "clangRewrite",
     "clangCrossTU",
@@ -1242,10 +1166,10 @@ const llvm_libs = [_][]const u8{
     "LLVMXRay",
     "LLVMLibDriver",
     "LLVMDlltoolDriver",
-    "LLVMTelemetry",
     "LLVMTextAPIBinaryReader",
     "LLVMCoverage",
     "LLVMLineEditor",
+    "LLVMSandboxIR",
     "LLVMXCoreDisassembler",
     "LLVMXCoreCodeGen",
     "LLVMXCoreDesc",
@@ -1272,10 +1196,6 @@ const llvm_libs = [_][]const u8{
     "LLVMSystemZCodeGen",
     "LLVMSystemZDesc",
     "LLVMSystemZInfo",
-    "LLVMSPIRVCodeGen",
-    "LLVMSPIRVDesc",
-    "LLVMSPIRVInfo",
-    "LLVMSPIRVAnalysis",
     "LLVMSparcDisassembler",
     "LLVMSparcAsmParser",
     "LLVMSparcCodeGen",
@@ -1360,34 +1280,32 @@ const llvm_libs = [_][]const u8{
     "LLVMOrcTargetProcess",
     "LLVMOrcShared",
     "LLVMDWP",
-    "LLVMDWARFCFIChecker",
     "LLVMDebugInfoLogicalView",
+    "LLVMDebugInfoGSYM",
     "LLVMOption",
+    "LLVMObjectYAML",
     "LLVMObjCopy",
     "LLVMMCA",
     "LLVMMCDisassembler",
     "LLVMLTO",
+    "LLVMPasses",
+    "LLVMHipStdPar",
+    "LLVMCFGuard",
+    "LLVMCoroutines",
+    "LLVMipo",
+    "LLVMVectorize",
+    "LLVMLinker",
+    "LLVMInstrumentation",
+    "LLVMFrontendOpenMP",
+    "LLVMFrontendOffloading",
     "LLVMFrontendOpenACC",
     "LLVMFrontendHLSL",
     "LLVMFrontendDriver",
     "LLVMExtensions",
-    "LLVMPasses",
-    "LLVMHipStdPar",
-    "LLVMCoroutines",
-    "LLVMCFGuard",
-    "LLVMipo",
-    "LLVMInstrumentation",
-    "LLVMVectorize",
-    "LLVMSandboxIR",
-    "LLVMLinker",
-    "LLVMFrontendOpenMP",
-    "LLVMFrontendDirective",
-    "LLVMFrontendAtomic",
-    "LLVMFrontendOffloading",
-    "LLVMObjectYAML",
     "LLVMDWARFLinkerParallel",
     "LLVMDWARFLinkerClassic",
     "LLVMDWARFLinker",
+    "LLVMCodeGenData",
     "LLVMGlobalISel",
     "LLVMMIRParser",
     "LLVMAsmPrinter",
@@ -1396,7 +1314,6 @@ const llvm_libs = [_][]const u8{
     "LLVMTarget",
     "LLVMObjCARCOpts",
     "LLVMCodeGenTypes",
-    "LLVMCGData",
     "LLVMIRPrinter",
     "LLVMInterfaceStub",
     "LLVMFileCheck",
@@ -1412,16 +1329,14 @@ const llvm_libs = [_][]const u8{
     "LLVMDebugInfoBTF",
     "LLVMDebugInfoPDB",
     "LLVMDebugInfoMSF",
-    "LLVMDebugInfoCodeView",
-    "LLVMDebugInfoGSYM",
     "LLVMDebugInfoDWARF",
-    "LLVMDebugInfoDWARFLowLevel",
     "LLVMObject",
     "LLVMTextAPI",
     "LLVMMCParser",
     "LLVMIRReader",
     "LLVMAsmParser",
     "LLVMMC",
+    "LLVMDebugInfoCodeView",
     "LLVMBitReader",
     "LLVMFuzzerCLI",
     "LLVMCore",
@@ -1461,8 +1376,6 @@ const llvm_libs_xtensa = [_][]const u8{
 };
 
 fn generateLangRef(b: *std.Build) std.Build.LazyPath {
-    const io = b.graph.io;
-
     const doctest_exe = b.addExecutable(.{
         .name = "doctest",
         .root_module = b.createModule(.{
@@ -1472,18 +1385,17 @@ fn generateLangRef(b: *std.Build) std.Build.LazyPath {
         }),
     });
 
-    var dir = b.build_root.handle.openDir(io, "doc/langref", .{ .iterate = true }) catch |err| {
-        std.debug.panic("unable to open '{f}doc/langref' directory: {s}", .{
+    var dir = b.build_root.handle.openDir("doc/langref", .{ .iterate = true }) catch |err| {
+        std.debug.panic("unable to open '{}doc/langref' directory: {s}", .{
             b.build_root, @errorName(err),
         });
     };
-    defer dir.close(io);
+    defer dir.close();
 
     var wf = b.addWriteFiles();
-    b.step("test-docs", "Test code snippets from the docs").dependOn(&wf.step);
 
     var it = dir.iterateAssumeFirstIteration();
-    while (it.next(io) catch @panic("failed to read dir")) |entry| {
+    while (it.next() catch @panic("failed to read dir")) |entry| {
         if (std.mem.startsWith(u8, entry.name, ".") or entry.kind != .file)
             continue;
 
@@ -1495,7 +1407,7 @@ fn generateLangRef(b: *std.Build) std.Build.LazyPath {
             // in a temporary directory
             "--cache-root", b.cache_root.path orelse ".",
         });
-        cmd.addArgs(&.{ "--zig-lib-dir", b.fmt("{f}", .{b.graph.zig_lib_directory}) });
+        cmd.addArgs(&.{ "--zig-lib-dir", b.fmt("{}", .{b.graph.zig_lib_directory}) });
         cmd.addArgs(&.{"-i"});
         cmd.addFileArg(b.path(b.fmt("doc/langref/{s}", .{entry.name})));
 

ci/aarch64-freebsd-debug.sh

@@ -1,63 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="aarch64-freebsd-none"
-MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.2287+eb3f16db5"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-debug
-cd build-debug
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-debug" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Debug \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-stage3-debug/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-test-incremental \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 2m
-
-stage3-debug/bin/zig build \
-  --prefix stage4-debug \
-  -Denable-llvm \
-  -Dno-lib \
-  -Dtarget=$TARGET \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-debug/bin/zig version)"
-
-stage4-debug/bin/zig test ../test/behavior.zig

ci/aarch64-freebsd-release.sh

@@ -1,69 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="aarch64-freebsd-none"
-MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.2287+eb3f16db5"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-release
-cd build-release
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-release" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Release \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-stage3-release/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-test-incremental \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 2m
-
-# Ensure that stage3 and stage4 are byte-for-byte identical.
-stage3-release/bin/zig build \
-  --prefix stage4-release \
-  -Denable-llvm \
-  -Dno-lib \
-  -Doptimize=ReleaseFast \
-  -Dstrip \
-  -Dtarget=$TARGET \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-release/bin/zig version)"
-
-# diff returns an error code if the files differ.
-echo "If the following command fails, it means nondeterminism has been"
-echo "introduced, making stage3 and stage4 no longer byte-for-byte identical."
-diff stage3-release/bin/zig stage4-release/bin/zig

ci/aarch64-linux-debug.sh

@@ -5,14 +5,20 @@
 set -x
 set -e
 
-TARGET="aarch64-linux-musl"
+ARCH="$(uname -m)"
+TARGET="$ARCH-linux-musl"
 MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
 PREFIX="$HOME/deps/$CACHE_BASENAME"
 ZIG="$PREFIX/bin/zig"
 
 export PATH="$HOME/local/bin:$PATH"
 
+# Make the `zig version` number consistent.
+# This will affect the cmake command below.
+git fetch --unshallow || true
+git fetch --tags
+
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
 # fill up space on the hard drive for no reason.
@@ -44,15 +50,12 @@ ninja install
 
 # No -fqemu and -fwasmtime here as they're covered by the x86_64-linux scripts.
 stage3-debug/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
+  --maxrss 24696061952 \
   -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
-  -Denable-superhtml \
-  --test-timeout 3m
+  -Denable-superhtml
 
 stage3-debug/bin/zig build \
   --prefix stage4-debug \

ci/aarch64-linux-release.sh

@@ -5,14 +5,20 @@
 set -x
 set -e
 
-TARGET="aarch64-linux-musl"
+ARCH="$(uname -m)"
+TARGET="$ARCH-linux-musl"
 MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
 PREFIX="$HOME/deps/$CACHE_BASENAME"
 ZIG="$PREFIX/bin/zig"
 
 export PATH="$HOME/local/bin:$PATH"
 
+# Make the `zig version` number consistent.
+# This will affect the cmake command below.
+git fetch --unshallow || true
+git fetch --tags
+
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
 # fill up space on the hard drive for no reason.
@@ -44,15 +50,12 @@ ninja install
 
 # No -fqemu and -fwasmtime here as they're covered by the x86_64-linux scripts.
 stage3-release/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
+  --maxrss 24696061952 \
   -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
-  -Denable-superhtml \
-  --test-timeout 3m
+  -Denable-superhtml
 
 # Ensure that stage3 and stage4 are byte-for-byte identical.
 stage3-release/bin/zig build \

ci/aarch64-macos-debug.sh

@@ -3,10 +3,13 @@
 set -x
 set -e
 
+# Script assumes the presence of the following:
+# s3cmd
+
 ZIGDIR="$PWD"
-TARGET="aarch64-macos-none"
+TARGET="$ARCH-macos-none"
 MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
 PREFIX="$HOME/$CACHE_BASENAME"
 ZIG="$PREFIX/bin/zig"
 
@@ -18,6 +21,11 @@ fi
 
 cd $ZIGDIR
 
+# Make the `zig version` number consistent.
+# This will affect the cmake command below.
+git fetch --unshallow || true
+git fetch --tags
+
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
 # fill up space on the hard drive for no reason.
@@ -27,7 +35,7 @@ export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
 mkdir build-debug
 cd build-debug
 
-cmake .. \
+PATH="$HOME/local/bin:$PATH" cmake .. \
   -DCMAKE_INSTALL_PREFIX="stage3-debug" \
   -DCMAKE_PREFIX_PATH="$PREFIX" \
   -DCMAKE_BUILD_TYPE=Debug \
@@ -39,24 +47,11 @@ cmake .. \
   -DZIG_NO_LIB=ON \
   -GNinja
 
-ninja install
+$HOME/local/bin/ninja install
 
 stage3-debug/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
   --zig-lib-dir "$PWD/../lib" \
   -Denable-macos-sdk \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
-  --search-prefix "$PREFIX" \
-  --test-timeout 2m
-
-stage3-debug/bin/zig build \
-  --prefix stage4-debug \
-  -Denable-llvm \
-  -Dno-lib \
-  -Dtarget=$TARGET \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-debug/bin/zig version)"
-
-stage4-debug/bin/zig test ../test/behavior.zig
+  --search-prefix "$PREFIX"

ci/aarch64-macos-release.sh

@@ -3,10 +3,13 @@
 set -x
 set -e
 
+# Script assumes the presence of the following:
+# s3cmd
+
 ZIGDIR="$PWD"
-TARGET="aarch64-macos-none"
+TARGET="$ARCH-macos-none"
 MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
 PREFIX="$HOME/$CACHE_BASENAME"
 ZIG="$PREFIX/bin/zig"
 
@@ -18,6 +21,11 @@ fi
 
 cd $ZIGDIR
 
+# Make the `zig version` number consistent.
+# This will affect the cmake command below.
+git fetch --unshallow || true
+git fetch --tags
+
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
 # fill up space on the hard drive for no reason.
@@ -27,7 +35,7 @@ export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
 mkdir build-release
 cd build-release
 
-cmake .. \
+PATH="$HOME/local/bin:$PATH" cmake .. \
   -DCMAKE_INSTALL_PREFIX="stage3-release" \
   -DCMAKE_PREFIX_PATH="$PREFIX" \
   -DCMAKE_BUILD_TYPE=Release \
@@ -39,20 +47,17 @@ cmake .. \
   -DZIG_NO_LIB=ON \
   -GNinja
 
-ninja install
+$HOME/local/bin/ninja install
 
 stage3-release/bin/zig build test docs \
   --zig-lib-dir "$PWD/../lib" \
   -Denable-macos-sdk \
   -Dstatic-llvm \
   -Dskip-non-native \
-  -Dskip-test-incremental \
-  --search-prefix "$PREFIX" \
-  --test-timeout 2m
+  --search-prefix "$PREFIX"
 
 # Ensure that stage3 and stage4 are byte-for-byte identical.
 stage3-release/bin/zig build \
-  --maxrss ${ZSF_MAX_RSS:-0} \
   --prefix stage4-release \
   -Denable-llvm \
   -Dno-lib \
@@ -63,7 +68,6 @@ stage3-release/bin/zig build \
   -Dversion-string="$(stage3-release/bin/zig version)"
 
 # diff returns an error code if the files differ.
-# https://codeberg.org/ziglang/zig/issues/30687
-#echo "If the following command fails, it means nondeterminism has been"
-#echo "introduced, making stage3 and stage4 no longer byte-for-byte identical."
-#diff stage3-release/bin/zig stage4-release/bin/zig
+echo "If the following command fails, it means nondeterminism has been"
+echo "introduced, making stage3 and stage4 no longer byte-for-byte identical."
+diff stage3-release/bin/zig stage4-release/bin/zig

ci/aarch64-netbsd-debug.sh

@@ -1,63 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="aarch64-netbsd-none"
-MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.2287+eb3f16db5"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-debug
-cd build-debug
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-debug" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Debug \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-stage3-debug/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-test-incremental \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 4m
-
-stage3-debug/bin/zig build \
-  --prefix stage4-debug \
-  -Denable-llvm \
-  -Dno-lib \
-  -Dtarget=$TARGET \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-debug/bin/zig version)"
-
-stage4-debug/bin/zig test ../test/behavior.zig

ci/aarch64-netbsd-release.sh

@@ -1,69 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="aarch64-netbsd-none"
-MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.2287+eb3f16db5"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-release
-cd build-release
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-release" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Release \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-stage3-release/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-test-incremental \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 4m
-
-# Ensure that stage3 and stage4 are byte-for-byte identical.
-stage3-release/bin/zig build \
-  --prefix stage4-release \
-  -Denable-llvm \
-  -Dno-lib \
-  -Doptimize=ReleaseFast \
-  -Dstrip \
-  -Dtarget=$TARGET \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-release/bin/zig version)"
-
-# diff returns an error code if the files differ.
-echo "If the following command fails, it means nondeterminism has been"
-echo "introduced, making stage3 and stage4 no longer byte-for-byte identical."
-diff stage3-release/bin/zig stage4-release/bin/zig

ci/aarch64-windows.ps1

@@ -1,11 +1,10 @@
-$TARGET = "aarch64-windows-gnu"
-$ZIG_LLVM_CLANG_LLD_NAME = "zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
+$TARGET = "$($Env:ARCH)-windows-gnu"
+$ZIG_LLVM_CLANG_LLD_NAME = "zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
 $MCPU = "baseline"
 $ZIG_LLVM_CLANG_LLD_URL = "https://ziglang.org/deps/$ZIG_LLVM_CLANG_LLD_NAME.zip"
 $PREFIX_PATH = "$(Get-Location)\..\$ZIG_LLVM_CLANG_LLD_NAME"
 $ZIG = "$PREFIX_PATH\bin\zig.exe"
 $ZIG_LIB_DIR = "$(Get-Location)\lib"
-$ZSF_MAX_RSS = if ($Env:ZSF_MAX_RSS) { $Env:ZSF_MAX_RSS } else { 0 }
 
 if (!(Test-Path "..\$ZIG_LLVM_CLANG_LLD_NAME.zip")) {
     Write-Output "Downloading $ZIG_LLVM_CLANG_LLD_URL"
@@ -23,6 +22,14 @@ function CheckLastExitCode {
     return 0
 }
 
+# Make the `zig version` number consistent.
+# This will affect the `zig build` command below which uses `git describe`.
+git fetch --tags
+
+if ((git rev-parse --is-shallow-repository) -eq "true") {
+    git fetch --unshallow # `git describe` won't work on a shallow repo
+}
+
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
 # fill up space on the hard drive for no reason.
@@ -55,14 +62,11 @@ CheckLastExitCode
 
 Write-Output "Main test suite..."
 & "stage3-release\bin\zig.exe" build test docs `
-  --maxrss $ZSF_MAX_RSS `
   --zig-lib-dir "$ZIG_LIB_DIR" `
   --search-prefix "$PREFIX_PATH" `
   -Dstatic-llvm `
   -Dskip-non-native `
-  -Dskip-test-incremental `
-  -Denable-symlinks-windows `
-  --test-timeout 30m
+  -Denable-symlinks-windows
 CheckLastExitCode
 
 # Ensure that stage3 and stage4 are byte-for-byte identical.

ci/loongarch64-linux-debug.sh

@@ -1,65 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="loongarch64-linux-musl"
-MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.157+7fdd60df1"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-debug
-cd build-debug
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-debug" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Debug \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-# No -fqemu and -fwasmtime here as they're covered by the x86_64-linux scripts.
-stage3-debug/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-test-incremental \
-  -Dtarget=native-native-musl \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 4m
-
-stage3-debug/bin/zig build \
-  --prefix stage4-debug \
-  -Denable-llvm \
-  -Dno-lib \
-  -Dtarget=$TARGET \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-debug/bin/zig version)"
-
-stage4-debug/bin/zig test ../test/behavior.zig

ci/loongarch64-linux-release.sh

@@ -1,71 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="loongarch64-linux-musl"
-MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.157+7fdd60df1"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-release
-cd build-release
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-release" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Release \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-# No -fqemu and -fwasmtime here as they're covered by the x86_64-linux scripts.
-stage3-release/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-test-incremental \
-  -Dtarget=native-native-musl \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 4m
-
-# Ensure that stage3 and stage4 are byte-for-byte identical.
-stage3-release/bin/zig build \
-  --prefix stage4-release \
-  -Denable-llvm \
-  -Dno-lib \
-  -Doptimize=ReleaseFast \
-  -Dstrip \
-  -Dtarget=$TARGET \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-release/bin/zig version)"
-
-# diff returns an error code if the files differ.
-echo "If the following command fails, it means nondeterminism has been"
-echo "introduced, making stage3 and stage4 no longer byte-for-byte identical."
-diff stage3-release/bin/zig stage4-release/bin/zig

ci/powerpc64le-linux-debug.sh

@@ -1,67 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="powerpc64le-linux-musl"
-MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.1594+9fa433d71"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-debug
-cd build-debug
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-debug" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Debug \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-# No -fqemu and -fwasmtime here as they're covered by the x86_64-linux scripts.
-stage3-debug/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-test-incremental \
-  -Dtarget=native-native-musl \
-  -Dcpu=native+longcall \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 4m
-
-stage3-debug/bin/zig build \
-  --prefix stage4-debug \
-  -Denable-llvm \
-  -Dno-lib \
-  -Dtarget=$TARGET \
-  -Dcpu=$MCPU \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-debug/bin/zig version)"
-
-stage4-debug/bin/zig test ../test/behavior.zig

ci/powerpc64le-linux-release.sh

@@ -1,73 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="powerpc64le-linux-musl"
-MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.1594+9fa433d71"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-release
-cd build-release
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-release" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Release \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-# No -fqemu and -fwasmtime here as they're covered by the x86_64-linux scripts.
-stage3-release/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-test-incremental \
-  -Dtarget=native-native-musl \
-  -Dcpu=native+longcall \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 4m
-
-# Ensure that stage3 and stage4 are byte-for-byte identical.
-stage3-release/bin/zig build \
-  --prefix stage4-release \
-  -Denable-llvm \
-  -Dno-lib \
-  -Doptimize=ReleaseFast \
-  -Dstrip \
-  -Dtarget=$TARGET \
-  -Dcpu=$MCPU \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-release/bin/zig version)"
-
-# diff returns an error code if the files differ.
-echo "If the following command fails, it means nondeterminism has been"
-echo "introduced, making stage3 and stage4 no longer byte-for-byte identical."
-diff stage3-release/bin/zig stage4-release/bin/zig

ci/riscv64-linux-debug.sh

@@ -1,54 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="riscv64-linux-musl"
-MCPU="spacemit_x60"
-CACHE_BASENAME="zig+llvm+lld+clang-riscv64-linux-musl-0.16.0-dev.104+689461e31"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-export PATH="$HOME/local/bin:$PATH"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-debug
-cd build-debug
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-debug" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Debug \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-# No -fqemu and -fwasmtime here as they're covered by the x86_64-linux scripts.
-stage3-debug/bin/zig build test-modules test-c-abi \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-single-threaded \
-  -Dtarget=native-native-musl \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 4m

ci/riscv64-linux-release.sh

@@ -1,54 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="riscv64-linux-musl"
-MCPU="spacemit_x60"
-CACHE_BASENAME="zig+llvm+lld+clang-riscv64-linux-musl-0.16.0-dev.104+689461e31"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-export PATH="$HOME/local/bin:$PATH"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-release
-cd build-release
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-release" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Release \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-# No -fqemu and -fwasmtime here as they're covered by the x86_64-linux scripts.
-stage3-release/bin/zig build test-modules test-c-abi \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-single-threaded \
-  -Dtarget=native-native-musl \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 4m

ci/s390x-linux-debug.sh

@@ -1,66 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="s390x-linux-musl"
-MCPU="z15"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.1354+94e98bfe8"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-debug
-cd build-debug
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-debug" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Debug \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-# No -fqemu and -fwasmtime here as they're covered by the x86_64-linux scripts.
-stage3-debug/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-test-incremental \
-  -Dtarget=native-native-musl \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 4m
-
-stage3-debug/bin/zig build \
-  --prefix stage4-debug \
-  -Denable-llvm \
-  -Dno-lib \
-  -Dtarget=$TARGET \
-  -Dcpu=$MCPU \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-debug/bin/zig version)"
-
-stage4-debug/bin/zig test ../test/behavior.zig

ci/s390x-linux-release.sh

@@ -1,72 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="s390x-linux-musl"
-MCPU="z15"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.1354+94e98bfe8"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-release
-cd build-release
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-release" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Release \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-# No -fqemu and -fwasmtime here as they're covered by the x86_64-linux scripts.
-stage3-release/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-test-incremental \
-  -Dtarget=native-native-musl \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 4m
-
-# Ensure that stage3 and stage4 are byte-for-byte identical.
-stage3-release/bin/zig build \
-  --prefix stage4-release \
-  -Denable-llvm \
-  -Dno-lib \
-  -Doptimize=ReleaseFast \
-  -Dstrip \
-  -Dtarget=$TARGET \
-  -Dcpu=$MCPU \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-release/bin/zig version)"
-
-# diff returns an error code if the files differ.
-echo "If the following command fails, it means nondeterminism has been"
-echo "introduced, making stage3 and stage4 no longer byte-for-byte identical."
-diff stage3-release/bin/zig stage4-release/bin/zig

ci/x86_64-freebsd-debug.sh

@@ -1,69 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="x86_64-freebsd-none"
-MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.312+164c598cd"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-debug
-cd build-debug
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-debug" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Debug \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-stage3-debug/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-spirv \
-  -Dskip-wasm \
-  -Dskip-linux \
-  -Dskip-netbsd \
-  -Dskip-openbsd \
-  -Dskip-windows \
-  -Dskip-darwin \
-  -Dskip-test-incremental \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 2m
-
-stage3-debug/bin/zig build \
-  --prefix stage4-debug \
-  -Denable-llvm \
-  -Dno-lib \
-  -Dtarget=$TARGET \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-debug/bin/zig version)"
-
-stage4-debug/bin/zig test ../test/behavior.zig

ci/x86_64-freebsd-release.sh

@@ -1,75 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="x86_64-freebsd-none"
-MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.312+164c598cd"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-release
-cd build-release
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-release" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Release \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-stage3-release/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-spirv \
-  -Dskip-wasm \
-  -Dskip-linux \
-  -Dskip-netbsd \
-  -Dskip-openbsd \
-  -Dskip-windows \
-  -Dskip-darwin \
-  -Dskip-test-incremental \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 2m
-
-# Ensure that stage3 and stage4 are byte-for-byte identical.
-stage3-release/bin/zig build \
-  --prefix stage4-release \
-  -Denable-llvm \
-  -Dno-lib \
-  -Doptimize=ReleaseFast \
-  -Dstrip \
-  -Dtarget=$TARGET \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-release/bin/zig version)"
-
-# diff returns an error code if the files differ.
-echo "If the following command fails, it means nondeterminism has been"
-echo "introduced, making stage3 and stage4 no longer byte-for-byte identical."
-diff stage3-release/bin/zig stage4-release/bin/zig

ci/x86_64-linux-debug-llvm.sh

@@ -1,82 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="x86_64-linux-musl"
-MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-export PATH="$HOME/deps/wasmtime-v42.0.1-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1.1/bin:$HOME/local/bin:$PATH"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-debug-llvm
-cd build-debug-llvm
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-debug" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Debug \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -DZIG_EXTRA_BUILD_ARGS="-Duse-llvm=true" \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-# simultaneously test building self-hosted without LLVM and with 32-bit arm
-stage3-debug/bin/zig build \
-  -Dtarget=arm-linux-musleabihf \
-  -Dno-lib
-
-stage3-debug/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dlldb=$HOME/deps/lldb-zig/Debug-e0a42bb34/bin/lldb \
-  -Dlibc-test-path=$HOME/deps/libc-test-f2bac77 \
-  -fqemu \
-  -fwasmtime \
-  -Dstatic-llvm \
-  -Dskip-freebsd \
-  -Dskip-netbsd \
-  -Dskip-openbsd \
-  -Dskip-windows \
-  -Dskip-darwin \
-  -Dskip-test-incremental \
-  -Dtarget=native-native-musl \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  -Denable-superhtml \
-  --test-timeout 12m
-
-stage3-debug/bin/zig build \
-  --prefix stage4-debug \
-  -Duse-llvm \
-  -Denable-llvm \
-  -Dno-lib \
-  -Dtarget=$TARGET \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-debug/bin/zig version)"
-
-stage4-debug/bin/zig test ../test/behavior.zig

ci/x86_64-linux-debug.sh

@@ -5,13 +5,19 @@
 set -x
 set -e
 
-TARGET="x86_64-linux-musl"
+ARCH="$(uname -m)"
+TARGET="$ARCH-linux-musl"
 MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
 PREFIX="$HOME/deps/$CACHE_BASENAME"
 ZIG="$PREFIX/bin/zig"
 
-export PATH="$HOME/deps/wasmtime-v42.0.1-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1.1/bin:$HOME/local/bin:$PATH"
+export PATH="$HOME/deps/wasmtime-v29.0.0-$ARCH-linux:$HOME/deps/qemu-linux-x86_64-9.2.0-rc1/bin:$HOME/local/bin:$PATH"
+
+# Make the `zig version` number consistent.
+# This will affect the cmake command below.
+git fetch --unshallow || true
+git fetch --tags
 
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
@@ -19,6 +25,12 @@ export PATH="$HOME/deps/wasmtime-v42.0.1-x86_64-linux:$HOME/deps/qemu-linux-x86_
 export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
 export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
 
+# Test building from source without LLVM.
+cc -o bootstrap bootstrap.c
+./bootstrap
+./zig2 build -Dno-lib
+./zig-out/bin/zig test test/behavior.zig
+
 mkdir build-debug
 cd build-debug
 
@@ -33,10 +45,7 @@ cmake .. \
   -DZIG_TARGET_MCPU="$MCPU" \
   -DZIG_STATIC=ON \
   -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
+  -GNinja
 
 # Now cmake will use zig as the C/C++ compiler. We reset the environment variables
 # so that installation and testing do not get affected by them.
@@ -51,30 +60,44 @@ stage3-debug/bin/zig build \
   -Dno-lib
 
 stage3-debug/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
+  --maxrss 21000000000 \
   -Dlldb=$HOME/deps/lldb-zig/Debug-e0a42bb34/bin/lldb \
   -fqemu \
   -fwasmtime \
   -Dstatic-llvm \
-  -Dskip-freebsd \
-  -Dskip-netbsd \
-  -Dskip-openbsd \
-  -Dskip-windows \
-  -Dskip-darwin \
-  -Dskip-llvm \
-  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
-  -Denable-superhtml \
-  --test-timeout 10m
+  -Denable-superhtml
 
-stage3-debug/bin/zig build \
-  --prefix stage4-debug \
-  -Denable-llvm \
+# Ensure that updating the wasm binary from this commit will result in a viable build.
+stage3-debug/bin/zig build update-zig1
+
+mkdir ../build-new
+cd ../build-new
+
+export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
+export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
+
+cmake .. \
+  -DCMAKE_PREFIX_PATH="$PREFIX" \
+  -DCMAKE_BUILD_TYPE=Debug \
+  -DZIG_TARGET_TRIPLE="$TARGET" \
+  -DZIG_TARGET_MCPU="$MCPU" \
+  -DZIG_STATIC=ON \
+  -DZIG_NO_LIB=ON \
+  -GNinja
+
+unset CC
+unset CXX
+
+ninja install
+
+stage3/bin/zig test ../test/behavior.zig
+stage3/bin/zig build -p stage4 \
+  -Dstatic-llvm \
+  -Dtarget=native-native-musl \
   -Dno-lib \
-  -Dtarget=$TARGET \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-debug/bin/zig version)"
-
-stage4-debug/bin/zig test ../test/behavior.zig
+  --search-prefix "$PREFIX" \
+  --zig-lib-dir "$PWD/../lib"
+stage4/bin/zig test ../test/behavior.zig

ci/x86_64-linux-release.sh

@@ -5,13 +5,19 @@
 set -x
 set -e
 
-TARGET="x86_64-linux-musl"
+ARCH="$(uname -m)"
+TARGET="$ARCH-linux-musl"
 MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
 PREFIX="$HOME/deps/$CACHE_BASENAME"
 ZIG="$PREFIX/bin/zig"
 
-export PATH="$HOME/deps/wasmtime-v42.0.1-x86_64-linux:$HOME/deps/qemu-linux-x86_64-10.2.1.1/bin:$HOME/local/bin:$PATH"
+export PATH="$HOME/deps/wasmtime-v29.0.0-$ARCH-linux:$HOME/deps/qemu-linux-x86_64-9.2.0-rc1/bin:$HOME/local/bin:$PATH"
+
+# Make the `zig version` number consistent.
+# This will affect the cmake command below.
+git fetch --unshallow || true
+git fetch --tags
 
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
@@ -39,10 +45,7 @@ cmake .. \
   -DZIG_TARGET_MCPU="$MCPU" \
   -DZIG_STATIC=ON \
   -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
+  -GNinja
 
 # Now cmake will use zig as the C/C++ compiler. We reset the environment variables
 # so that installation and testing do not get affected by them.
@@ -57,18 +60,15 @@ stage3-release/bin/zig build \
   -Dno-lib
 
 stage3-release/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
+  --maxrss 21000000000 \
   -Dlldb=$HOME/deps/lldb-zig/Release-e0a42bb34/bin/lldb \
-  -Dlibc-test-path=$HOME/deps/libc-test-f2bac77 \
   -fqemu \
   -fwasmtime \
   -Dstatic-llvm \
-  -Dskip-test-incremental \
   -Dtarget=native-native-musl \
   --search-prefix "$PREFIX" \
   --zig-lib-dir "$PWD/../lib" \
-  -Denable-superhtml \
-  --test-timeout 12m
+  -Denable-superhtml
 
 # Ensure that stage3 and stage4 are byte-for-byte identical.
 stage3-release/bin/zig build \
@@ -102,10 +102,7 @@ cmake .. \
   -DZIG_TARGET_MCPU="$MCPU" \
   -DZIG_STATIC=ON \
   -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
+  -GNinja
 
 unset CC
 unset CXX

ci/x86_64-macos-release.sh

@@ -0,0 +1,75 @@
+#!/bin/sh
+
+set -x
+set -e
+
+ZIGDIR="$PWD"
+TARGET="$ARCH-macos-none"
+MCPU="baseline"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
+PREFIX="$HOME/$CACHE_BASENAME"
+JOBS="-j3"
+ZIG="$PREFIX/bin/zig"
+
+if [ ! -d "$PREFIX" ]; then
+  cd $HOME
+  curl -L -O "https://ziglang.org/deps/$CACHE_BASENAME.tar.xz"
+  tar xf "$CACHE_BASENAME.tar.xz"
+fi
+
+cd $ZIGDIR
+
+# Make the `zig version` number consistent.
+# This will affect the cmake command below.
+git fetch --unshallow || true
+git fetch --tags
+
+# Override the cache directories because they won't actually help other CI runs
+# which will be testing alternate versions of zig, and ultimately would just
+# fill up space on the hard drive for no reason.
+export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
+export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
+
+# Test building from source without LLVM.
+cc -o bootstrap bootstrap.c
+./bootstrap
+./zig2 build -Dno-lib
+./zig-out/bin/zig test test/behavior.zig
+
+mkdir build
+cd build
+
+cmake .. \
+  -DCMAKE_PREFIX_PATH="$PREFIX" \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_C_COMPILER="$ZIG;cc;-target;$TARGET;-mcpu=$MCPU" \
+  -DCMAKE_CXX_COMPILER="$ZIG;c++;-target;$TARGET;-mcpu=$MCPU" \
+  -DZIG_TARGET_TRIPLE="$TARGET" \
+  -DZIG_TARGET_MCPU="$MCPU" \
+  -DZIG_STATIC=ON \
+  -DZIG_NO_LIB=ON
+
+make $JOBS install
+
+stage3/bin/zig build test docs \
+  --zig-lib-dir "$PWD/../lib" \
+  -Denable-macos-sdk \
+  -Dstatic-llvm \
+  -Dskip-non-native \
+  --search-prefix "$PREFIX"
+
+# Ensure that stage3 and stage4 are byte-for-byte identical.
+stage3/bin/zig build \
+  --prefix stage4 \
+  -Denable-llvm \
+  -Dno-lib \
+  -Doptimize=ReleaseFast \
+  -Dstrip \
+  -Dtarget=$TARGET \
+  -Duse-zig-libcxx \
+  -Dversion-string="$(stage3/bin/zig version)"
+
+# diff returns an error code if the files differ.
+echo "If the following command fails, it means nondeterminism has been"
+echo "introduced, making stage3 and stage4 no longer byte-for-byte identical."
+diff stage3/bin/zig stage4/bin/zig

ci/x86_64-netbsd-debug.sh

@@ -1,63 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="x86_64-netbsd-none"
-MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.2287+eb3f16db5"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-debug
-cd build-debug
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-debug" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Debug \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-stage3-debug/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-test-incremental \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 2m
-
-stage3-debug/bin/zig build \
-  --prefix stage4-debug \
-  -Denable-llvm \
-  -Dno-lib \
-  -Dtarget=$TARGET \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-debug/bin/zig version)"
-
-stage4-debug/bin/zig test ../test/behavior.zig

ci/x86_64-netbsd-release.sh

@@ -1,69 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="x86_64-netbsd-none"
-MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.2287+eb3f16db5"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-release
-cd build-release
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-release" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Release \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-stage3-release/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-test-incremental \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 2m
-
-# Ensure that stage3 and stage4 are byte-for-byte identical.
-stage3-release/bin/zig build \
-  --prefix stage4-release \
-  -Denable-llvm \
-  -Dno-lib \
-  -Doptimize=ReleaseFast \
-  -Dstrip \
-  -Dtarget=$TARGET \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-release/bin/zig version)"
-
-# diff returns an error code if the files differ.
-echo "If the following command fails, it means nondeterminism has been"
-echo "introduced, making stage3 and stage4 no longer byte-for-byte identical."
-diff stage3-release/bin/zig stage4-release/bin/zig

ci/x86_64-openbsd-debug.sh

@@ -1,63 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="x86_64-openbsd-none"
-MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.2051+28b83e3b0"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-debug
-cd build-debug
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-debug" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Debug \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-stage3-debug/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-test-incremental \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 2m
-
-stage3-debug/bin/zig build \
-  --prefix stage4-debug \
-  -Denable-llvm \
-  -Dno-lib \
-  -Dtarget=$TARGET \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-debug/bin/zig version)"
-
-stage4-debug/bin/zig test ../test/behavior.zig

ci/x86_64-openbsd-release.sh

@@ -1,69 +0,0 @@
-#!/bin/sh
-
-# Requires cmake ninja-build
-
-set -x
-set -e
-
-TARGET="x86_64-openbsd-none"
-MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.16.0-dev.2051+28b83e3b0"
-PREFIX="$HOME/deps/$CACHE_BASENAME"
-ZIG="$PREFIX/bin/zig"
-
-# Override the cache directories because they won't actually help other CI runs
-# which will be testing alternate versions of zig, and ultimately would just
-# fill up space on the hard drive for no reason.
-export ZIG_GLOBAL_CACHE_DIR="$PWD/zig-global-cache"
-export ZIG_LOCAL_CACHE_DIR="$PWD/zig-local-cache"
-
-mkdir build-release
-cd build-release
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="stage3-release" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Release \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_NO_LIB=ON \
-  -GNinja \
-  -DCMAKE_C_LINKER_DEPFILE_SUPPORTED=FALSE \
-  -DCMAKE_CXX_LINKER_DEPFILE_SUPPORTED=FALSE
-# https://github.com/ziglang/zig/issues/22213
-
-# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
-# so that installation and testing do not get affected by them.
-unset CC
-unset CXX
-
-ninja install
-
-stage3-release/bin/zig build test docs \
-  --maxrss ${ZSF_MAX_RSS:-0} \
-  -Dstatic-llvm \
-  -Dskip-non-native \
-  -Dskip-test-incremental \
-  --search-prefix "$PREFIX" \
-  --zig-lib-dir "$PWD/../lib" \
-  --test-timeout 2m
-
-# Ensure that stage3 and stage4 are byte-for-byte identical.
-stage3-release/bin/zig build \
-  --prefix stage4-release \
-  -Denable-llvm \
-  -Dno-lib \
-  -Doptimize=ReleaseFast \
-  -Dstrip \
-  -Dtarget=$TARGET \
-  -Duse-zig-libcxx \
-  -Dversion-string="$(stage3-release/bin/zig version)"
-
-# diff returns an error code if the files differ.
-echo "If the following command fails, it means nondeterminism has been"
-echo "introduced, making stage3 and stage4 no longer byte-for-byte identical."
-diff stage3-release/bin/zig stage4-release/bin/zig

ci/x86_64-windows-debug.ps1

@@ -1,9 +1,19 @@
-$TARGET = "x86_64-windows-gnu"
+$TARGET = "$($Env:ARCH)-windows-gnu"
+$ZIG_LLVM_CLANG_LLD_NAME = "zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
 $MCPU = "baseline"
-$PREFIX_PATH = "$($Env:USERPROFILE)\deps\zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
+$ZIG_LLVM_CLANG_LLD_URL = "https://ziglang.org/deps/$ZIG_LLVM_CLANG_LLD_NAME.zip"
+$PREFIX_PATH = "$($Env:USERPROFILE)\$ZIG_LLVM_CLANG_LLD_NAME"
 $ZIG = "$PREFIX_PATH\bin\zig.exe"
 $ZIG_LIB_DIR = "$(Get-Location)\lib"
-$ZSF_MAX_RSS = if ($Env:ZSF_MAX_RSS) { $Env:ZSF_MAX_RSS } else { 0 }
+
+if (!(Test-Path "$PREFIX_PATH.zip")) {
+    Write-Output "Downloading $ZIG_LLVM_CLANG_LLD_URL"
+    Invoke-WebRequest -Uri "$ZIG_LLVM_CLANG_LLD_URL" -OutFile "$PREFIX_PATH.zip"
+
+    Write-Output "Extracting..."
+    Add-Type -AssemblyName System.IO.Compression.FileSystem ;
+    [System.IO.Compression.ZipFile]::ExtractToDirectory("$PREFIX_PATH.zip", "$PREFIX_PATH\..")
+}
 
 function CheckLastExitCode {
     if (!$?) {
@@ -12,6 +22,14 @@ function CheckLastExitCode {
     return 0
 }
 
+# Make the `zig version` number consistent.
+# This will affect the `zig build` command below which uses `git describe`.
+git fetch --tags
+
+if ((git rev-parse --is-shallow-repository) -eq "true") {
+    git fetch --unshallow # `git describe` won't work on a shallow repo
+}
+
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
 # fill up space on the hard drive for no reason.
@@ -24,7 +42,7 @@ Set-Location -Path 'build-debug'
 
 # CMake gives a syntax error when file paths with backward slashes are used.
 # Here, we use forward slashes only to work around this.
-cmake .. `
+& cmake .. `
   -GNinja `
   -DCMAKE_INSTALL_PREFIX="stage3-debug" `
   -DCMAKE_PREFIX_PATH="$($PREFIX_PATH -Replace "\\", "/")" `
@@ -43,50 +61,49 @@ ninja install
 CheckLastExitCode
 
 Write-Output "Main test suite..."
-stage3-debug\bin\zig build test docs `
-  --maxrss $ZSF_MAX_RSS `
+& "stage3-debug\bin\zig.exe" build test docs `
   --zig-lib-dir "$ZIG_LIB_DIR" `
   --search-prefix "$PREFIX_PATH" `
   -Dstatic-llvm `
   -Dskip-non-native `
-  -Dskip-test-incremental `
-  -Denable-symlinks-windows `
-  --test-timeout 30m
+  -Dskip-release `
+  -Denable-symlinks-windows
 CheckLastExitCode
 
 Write-Output "Build x86_64-windows-msvc behavior tests using the C backend..."
-stage3-debug\bin\zig build-obj `
+& "stage3-debug\bin\zig.exe" test `
+  ..\test\behavior.zig `
+  --zig-lib-dir "$ZIG_LIB_DIR" `
+  -ofmt=c `
+  -femit-bin="test-x86_64-windows-msvc.c" `
+  --test-no-exec `
+  -target x86_64-windows-msvc `
+  -lc
+CheckLastExitCode
+
+& "stage3-debug\bin\zig.exe" build-obj `
   --zig-lib-dir "$ZIG_LIB_DIR" `
   -ofmt=c `
   -OReleaseSmall `
   --name compiler_rt `
   -femit-bin="compiler_rt-x86_64-windows-msvc.c" `
+  --dep build_options `
   -target x86_64-windows-msvc `
-  -lc `
-  ..\lib\compiler_rt.zig
+  -Mroot="..\lib\compiler_rt.zig" `
+  -Mbuild_options="config.zig"
 CheckLastExitCode
 
-stage3-debug\bin\zig test `
-  --zig-lib-dir "$ZIG_LIB_DIR" `
-  -ofmt=c `
-  -femit-bin="behavior-x86_64-windows-msvc.c" `
-  --test-no-exec `
-  -target x86_64-windows-msvc `
-  -lc `
-  ..\test\behavior.zig
+Import-Module "C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"
 CheckLastExitCode
 
-Import-Module "C:\Program Files (x86)\Microsoft Visual Studio\18\BuildTools\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"
-CheckLastExitCode
-
-Enter-VsDevShell -VsInstallPath "C:\Program Files (x86)\Microsoft Visual Studio\18\BuildTools" `
+Enter-VsDevShell -VsInstallPath "C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools" `
   -DevCmdArguments '-arch=x64 -no_logo' `
   -StartInPath $(Get-Location)
 CheckLastExitCode
 
 Write-Output "Build and run behavior tests with msvc..."
-cl /I..\lib /W3 /Z7 behavior-x86_64-windows-msvc.c compiler_rt-x86_64-windows-msvc.c /link /nologo /debug /subsystem:console kernel32.lib ntdll.lib libcmt.lib ws2_32.lib
+& cl.exe -I..\lib test-x86_64-windows-msvc.c compiler_rt-x86_64-windows-msvc.c /W3 /Z7 -link -nologo -debug -subsystem:console kernel32.lib ntdll.lib libcmt.lib
 CheckLastExitCode
 
-.\behavior-x86_64-windows-msvc
+& .\test-x86_64-windows-msvc.exe
 CheckLastExitCode

ci/x86_64-windows-release.ps1

@@ -1,9 +1,19 @@
-$TARGET = "x86_64-windows-gnu"
+$TARGET = "$($Env:ARCH)-windows-gnu"
+$ZIG_LLVM_CLANG_LLD_NAME = "zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
 $MCPU = "baseline"
-$PREFIX_PATH = "$($Env:USERPROFILE)\deps\zig+llvm+lld+clang-$TARGET-0.16.0-dev.104+689461e31"
+$ZIG_LLVM_CLANG_LLD_URL = "https://ziglang.org/deps/$ZIG_LLVM_CLANG_LLD_NAME.zip"
+$PREFIX_PATH = "$($Env:USERPROFILE)\$ZIG_LLVM_CLANG_LLD_NAME"
 $ZIG = "$PREFIX_PATH\bin\zig.exe"
 $ZIG_LIB_DIR = "$(Get-Location)\lib"
-$ZSF_MAX_RSS = if ($Env:ZSF_MAX_RSS) { $Env:ZSF_MAX_RSS } else { 0 }
+
+if (!(Test-Path "$PREFIX_PATH.zip")) {
+    Write-Output "Downloading $ZIG_LLVM_CLANG_LLD_URL"
+    Invoke-WebRequest -Uri "$ZIG_LLVM_CLANG_LLD_URL" -OutFile "$PREFIX_PATH.zip"
+
+    Write-Output "Extracting..."
+    Add-Type -AssemblyName System.IO.Compression.FileSystem ;
+    [System.IO.Compression.ZipFile]::ExtractToDirectory("$PREFIX_PATH.zip", "$PREFIX_PATH\..")
+}
 
 function CheckLastExitCode {
     if (!$?) {
@@ -12,6 +22,14 @@ function CheckLastExitCode {
     return 0
 }
 
+# Make the `zig version` number consistent.
+# This will affect the `zig build` command below which uses `git describe`.
+git fetch --tags
+
+if ((git rev-parse --is-shallow-repository) -eq "true") {
+    git fetch --unshallow # `git describe` won't work on a shallow repo
+}
+
 # Override the cache directories because they won't actually help other CI runs
 # which will be testing alternate versions of zig, and ultimately would just
 # fill up space on the hard drive for no reason.
@@ -24,7 +42,7 @@ Set-Location -Path 'build-release'
 
 # CMake gives a syntax error when file paths with backward slashes are used.
 # Here, we use forward slashes only to work around this.
-cmake .. `
+& cmake .. `
   -GNinja `
   -DCMAKE_INSTALL_PREFIX="stage3-release" `
   -DCMAKE_PREFIX_PATH="$($PREFIX_PATH -Replace "\\", "/")" `
@@ -43,20 +61,17 @@ ninja install
 CheckLastExitCode
 
 Write-Output "Main test suite..."
-stage3-release\bin\zig.exe build test docs `
-  --maxrss $ZSF_MAX_RSS `
+& "stage3-release\bin\zig.exe" build test docs `
   --zig-lib-dir "$ZIG_LIB_DIR" `
   --search-prefix "$PREFIX_PATH" `
   -Dstatic-llvm `
   -Dskip-non-native `
-  -Dskip-test-incremental `
-  -Denable-symlinks-windows `
-  --test-timeout 30m
+  -Denable-symlinks-windows
 CheckLastExitCode
 
 # Ensure that stage3 and stage4 are byte-for-byte identical.
 Write-Output "Build and compare stage4..."
-stage3-release\bin\zig.exe build `
+& "stage3-release\bin\zig.exe" build `
   --prefix stage4-release `
   -Denable-llvm `
   -Dno-lib `
@@ -74,38 +89,39 @@ Compare-Object (Get-Content stage3-release\bin\zig.exe) (Get-Content stage4-rele
 CheckLastExitCode
 
 Write-Output "Build x86_64-windows-msvc behavior tests using the C backend..."
-stage3-release\bin\zig.exe build-obj `
+& "stage3-release\bin\zig.exe" test `
+  ..\test\behavior.zig `
+  --zig-lib-dir "$ZIG_LIB_DIR" `
+  -ofmt=c `
+  -femit-bin="test-x86_64-windows-msvc.c" `
+  --test-no-exec `
+  -target x86_64-windows-msvc `
+  -lc
+CheckLastExitCode
+
+& "stage3-release\bin\zig.exe" build-obj `
   --zig-lib-dir "$ZIG_LIB_DIR" `
   -ofmt=c `
   -OReleaseSmall `
   --name compiler_rt `
   -femit-bin="compiler_rt-x86_64-windows-msvc.c" `
+  --dep build_options `
   -target x86_64-windows-msvc `
-  -lc `
-  ..\lib\compiler_rt.zig
+  -Mroot="..\lib\compiler_rt.zig" `
+  -Mbuild_options="config.zig"
 CheckLastExitCode
 
-stage3-release\bin\zig.exe test `
-  --zig-lib-dir "$ZIG_LIB_DIR" `
-  -ofmt=c `
-  -femit-bin="behavior-x86_64-windows-msvc.c" `
-  --test-no-exec `
-  -target x86_64-windows-msvc `
-  -lc `
-  ..\test\behavior.zig
+Import-Module "C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"
 CheckLastExitCode
 
-Import-Module "C:\Program Files (x86)\Microsoft Visual Studio\18\BuildTools\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"
-CheckLastExitCode
-
-Enter-VsDevShell -VsInstallPath "C:\Program Files (x86)\Microsoft Visual Studio\18\BuildTools" `
+Enter-VsDevShell -VsInstallPath "C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools" `
   -DevCmdArguments '-arch=x64 -no_logo' `
   -StartInPath $(Get-Location)
 CheckLastExitCode
 
 Write-Output "Build and run behavior tests with msvc..."
-cl /I..\lib /W3 /Z7 behavior-x86_64-windows-msvc.c compiler_rt-x86_64-windows-msvc.c /link /nologo /debug /subsystem:console kernel32.lib ntdll.lib libcmt.lib ws2_32.lib
+& cl.exe -I..\lib test-x86_64-windows-msvc.c compiler_rt-x86_64-windows-msvc.c /W3 /Z7 -link -nologo -debug -subsystem:console kernel32.lib ntdll.lib libcmt.lib
 CheckLastExitCode
 
-.\behavior-x86_64-windows-msvc
+& .\test-x86_64-windows-msvc.exe
 CheckLastExitCode

cmake/Findclang.cmake

@@ -17,10 +17,10 @@ find_path(CLANG_INCLUDE_DIRS NAMES clang/Frontend/ASTUnit.h
 if(${LLVM_LINK_MODE} STREQUAL "shared")
   find_library(CLANG_LIBRARIES
     NAMES
-      libclang-cpp.so.21
-      libclang-cpp.so.21.1
-      clang-cpp-21.0
-      clang-cpp210
+      libclang-cpp.so.19
+      libclang-cpp.so.19.1
+      clang-cpp-19.0
+      clang-cpp190
       clang-cpp
     NAMES_PER_DIR
     HINTS "${LLVM_LIBDIRS}"
@@ -60,6 +60,7 @@ else()
   FIND_AND_ADD_CLANG_LIB(clangBasic)
   FIND_AND_ADD_CLANG_LIB(clangEdit)
   FIND_AND_ADD_CLANG_LIB(clangLex)
+  FIND_AND_ADD_CLANG_LIB(clangARCMigrate)
   FIND_AND_ADD_CLANG_LIB(clangRewriteFrontend)
   FIND_AND_ADD_CLANG_LIB(clangRewrite)
   FIND_AND_ADD_CLANG_LIB(clangCrossTU)

cmake/Findlld.cmake

@@ -9,23 +9,23 @@
 find_path(LLD_INCLUDE_DIRS NAMES lld/Common/Driver.h
     HINTS ${LLVM_INCLUDE_DIRS}
     PATHS
-        /usr/lib/llvm-21/include
-        /usr/local/llvm210/include
-        /usr/local/llvm21/include
-        /usr/local/opt/lld@21/include
-        /opt/homebrew/opt/lld@21/include
-        /home/linuxbrew/.linuxbrew/opt/lld@21/include
+        /usr/lib/llvm-19/include
+        /usr/local/llvm190/include
+        /usr/local/llvm19/include
+        /usr/local/opt/lld@19/include
+        /opt/homebrew/opt/lld@19/include
+        /home/linuxbrew/.linuxbrew/opt/lld@19/include
         /mingw64/include)
 
-find_library(LLD_LIBRARY NAMES lld-21.0 lld210 lld NAMES_PER_DIR
+find_library(LLD_LIBRARY NAMES lld-19.0 lld190 lld NAMES_PER_DIR
     HINTS ${LLVM_LIBDIRS}
     PATHS
-        /usr/lib/llvm-21/lib
-        /usr/local/llvm210/lib
-        /usr/local/llvm21/lib
-        /usr/local/opt/lld@21/lib
-        /opt/homebrew/opt/lld@21/lib
-        /home/linuxbrew/.linuxbrew/opt/lld@21/lib
+        /usr/lib/llvm-19/lib
+        /usr/local/llvm190/lib
+        /usr/local/llvm19/lib
+        /usr/local/opt/lld@19/lib
+        /opt/homebrew/opt/lld@19/lib
+        /home/linuxbrew/.linuxbrew/opt/lld@19/lib
 )
 if(EXISTS ${LLD_LIBRARY})
     set(LLD_LIBRARIES ${LLD_LIBRARY})
@@ -36,12 +36,12 @@ else()
             HINTS ${LLVM_LIBDIRS}
             PATHS
                 ${LLD_LIBDIRS}
-                /usr/lib/llvm-21/lib
-                /usr/local/llvm210/lib
-                /usr/local/llvm21/lib
-                /usr/local/opt/lld@21/lib
-                /opt/homebrew/opt/lld@21/lib
-                /home/linuxbrew/.linuxbrew/opt/lld@21/lib
+                /usr/lib/llvm-19/lib
+                /usr/local/llvm190/lib
+                /usr/local/llvm19/lib
+                /usr/local/opt/lld@19/lib
+                /opt/homebrew/opt/lld@19/lib
+                /home/linuxbrew/.linuxbrew/opt/lld@19/lib
                 /mingw64/lib
                 /c/msys64/mingw64/lib
                 c:/msys64/mingw64/lib)

cmake/Findllvm.cmake

@@ -17,12 +17,12 @@ if(ZIG_USE_LLVM_CONFIG)
     # terminate when the right LLVM version is not found.
     unset(LLVM_CONFIG_EXE CACHE)
     find_program(LLVM_CONFIG_EXE
-        NAMES llvm-config-21 llvm-config-21.0 llvm-config210 llvm-config21 llvm-config NAMES_PER_DIR
+        NAMES llvm-config-19 llvm-config-19.0 llvm-config190 llvm-config19 llvm-config NAMES_PER_DIR
         PATHS
             "/mingw64/bin"
             "/c/msys64/mingw64/bin"
             "c:/msys64/mingw64/bin"
-            "C:/Libraries/llvm-21.0.0/bin")
+            "C:/Libraries/llvm-19.0.0/bin")
 
     if ("${LLVM_CONFIG_EXE}" STREQUAL "LLVM_CONFIG_EXE-NOTFOUND")
       if (NOT LLVM_CONFIG_ERROR_MESSAGES STREQUAL "")
@@ -40,9 +40,9 @@ if(ZIG_USE_LLVM_CONFIG)
       OUTPUT_STRIP_TRAILING_WHITESPACE)
 
     get_filename_component(LLVM_CONFIG_DIR "${LLVM_CONFIG_EXE}" DIRECTORY)
-    if("${LLVM_CONFIG_VERSION}" VERSION_LESS 21 OR "${LLVM_CONFIG_VERSION}" VERSION_EQUAL 22 OR "${LLVM_CONFIG_VERSION}" VERSION_GREATER 22)
+    if("${LLVM_CONFIG_VERSION}" VERSION_LESS 19 OR "${LLVM_CONFIG_VERSION}" VERSION_EQUAL 20 OR "${LLVM_CONFIG_VERSION}" VERSION_GREATER 20)
       # Save the error message, in case this is the last llvm-config we find
-      list(APPEND LLVM_CONFIG_ERROR_MESSAGES "expected LLVM 21.x but found ${LLVM_CONFIG_VERSION} using ${LLVM_CONFIG_EXE}")
+      list(APPEND LLVM_CONFIG_ERROR_MESSAGES "expected LLVM 19.x but found ${LLVM_CONFIG_VERSION} using ${LLVM_CONFIG_EXE}")
 
       # Ignore this directory and try the search again
       list(APPEND CMAKE_IGNORE_PATH "${LLVM_CONFIG_DIR}")
@@ -66,9 +66,9 @@ if(ZIG_USE_LLVM_CONFIG)
       if (LLVM_CONFIG_ERROR)
         # Save the error message, in case this is the last llvm-config we find
         if (ZIG_SHARED_LLVM)
-          list(APPEND LLVM_CONFIG_ERROR_MESSAGES "LLVM 21.x found at ${LLVM_CONFIG_EXE} does not support linking as a shared library")
+          list(APPEND LLVM_CONFIG_ERROR_MESSAGES "LLVM 19.x found at ${LLVM_CONFIG_EXE} does not support linking as a shared library")
         else()
-          list(APPEND LLVM_CONFIG_ERROR_MESSAGES "LLVM 21.x found at ${LLVM_CONFIG_EXE} does not support linking as a static library")
+          list(APPEND LLVM_CONFIG_ERROR_MESSAGES "LLVM 19.x found at ${LLVM_CONFIG_EXE} does not support linking as a static library")
         endif()
 
         # Ignore this directory and try the search again
@@ -83,7 +83,7 @@ if(ZIG_USE_LLVM_CONFIG)
       OUTPUT_STRIP_TRAILING_WHITESPACE)
     string(REPLACE " " ";" LLVM_TARGETS_BUILT "${LLVM_TARGETS_BUILT_SPACES}")
 
-    set(ZIG_LLVM_REQUIRED_TARGETS "AArch64;AMDGPU;ARM;AVR;BPF;Hexagon;Lanai;LoongArch;Mips;MSP430;NVPTX;PowerPC;RISCV;SPIRV;Sparc;SystemZ;VE;WebAssembly;X86;XCore")
+    set(ZIG_LLVM_REQUIRED_TARGETS "AArch64;AMDGPU;ARM;AVR;BPF;Hexagon;Lanai;Mips;MSP430;NVPTX;PowerPC;RISCV;Sparc;SystemZ;VE;WebAssembly;X86;XCore")
 
     set(ZIG_LLVM_REQUIRED_TARGETS_ENABLED TRUE)
     foreach(TARGET_NAME IN LISTS ZIG_LLVM_REQUIRED_TARGETS)
@@ -197,10 +197,10 @@ else()
   FIND_AND_ADD_LLVM_LIB(LLVMXRay)
   FIND_AND_ADD_LLVM_LIB(LLVMLibDriver)
   FIND_AND_ADD_LLVM_LIB(LLVMDlltoolDriver)
-  FIND_AND_ADD_LLVM_LIB(LLVMTelemetry)
   FIND_AND_ADD_LLVM_LIB(LLVMTextAPIBinaryReader)
   FIND_AND_ADD_LLVM_LIB(LLVMCoverage)
   FIND_AND_ADD_LLVM_LIB(LLVMLineEditor)
+  FIND_AND_ADD_LLVM_LIB(LLVMSandboxIR)
   FIND_AND_ADD_LLVM_LIB(LLVMXCoreDisassembler)
   FIND_AND_ADD_LLVM_LIB(LLVMXCoreCodeGen)
   FIND_AND_ADD_LLVM_LIB(LLVMXCoreDesc)
@@ -227,10 +227,6 @@ else()
   FIND_AND_ADD_LLVM_LIB(LLVMSystemZCodeGen)
   FIND_AND_ADD_LLVM_LIB(LLVMSystemZDesc)
   FIND_AND_ADD_LLVM_LIB(LLVMSystemZInfo)
-  FIND_AND_ADD_LLVM_LIB(LLVMSPIRVCodeGen)
-  FIND_AND_ADD_LLVM_LIB(LLVMSPIRVDesc)
-  FIND_AND_ADD_LLVM_LIB(LLVMSPIRVInfo)
-  FIND_AND_ADD_LLVM_LIB(LLVMSPIRVAnalysis)
   FIND_AND_ADD_LLVM_LIB(LLVMSparcDisassembler)
   FIND_AND_ADD_LLVM_LIB(LLVMSparcAsmParser)
   FIND_AND_ADD_LLVM_LIB(LLVMSparcCodeGen)
@@ -315,34 +311,32 @@ else()
   FIND_AND_ADD_LLVM_LIB(LLVMOrcTargetProcess)
   FIND_AND_ADD_LLVM_LIB(LLVMOrcShared)
   FIND_AND_ADD_LLVM_LIB(LLVMDWP)
-  FIND_AND_ADD_LLVM_LIB(LLVMDWARFCFIChecker)
   FIND_AND_ADD_LLVM_LIB(LLVMDebugInfoLogicalView)
+  FIND_AND_ADD_LLVM_LIB(LLVMDebugInfoGSYM)
   FIND_AND_ADD_LLVM_LIB(LLVMOption)
+  FIND_AND_ADD_LLVM_LIB(LLVMObjectYAML)
   FIND_AND_ADD_LLVM_LIB(LLVMObjCopy)
   FIND_AND_ADD_LLVM_LIB(LLVMMCA)
   FIND_AND_ADD_LLVM_LIB(LLVMMCDisassembler)
   FIND_AND_ADD_LLVM_LIB(LLVMLTO)
+  FIND_AND_ADD_LLVM_LIB(LLVMPasses)
+  FIND_AND_ADD_LLVM_LIB(LLVMHipStdPar)
+  FIND_AND_ADD_LLVM_LIB(LLVMCFGuard)
+  FIND_AND_ADD_LLVM_LIB(LLVMCoroutines)
+  FIND_AND_ADD_LLVM_LIB(LLVMipo)
+  FIND_AND_ADD_LLVM_LIB(LLVMVectorize)
+  FIND_AND_ADD_LLVM_LIB(LLVMLinker)
+  FIND_AND_ADD_LLVM_LIB(LLVMInstrumentation)
+  FIND_AND_ADD_LLVM_LIB(LLVMFrontendOpenMP)
+  FIND_AND_ADD_LLVM_LIB(LLVMFrontendOffloading)
   FIND_AND_ADD_LLVM_LIB(LLVMFrontendOpenACC)
   FIND_AND_ADD_LLVM_LIB(LLVMFrontendHLSL)
   FIND_AND_ADD_LLVM_LIB(LLVMFrontendDriver)
   FIND_AND_ADD_LLVM_LIB(LLVMExtensions)
-  FIND_AND_ADD_LLVM_LIB(LLVMPasses)
-  FIND_AND_ADD_LLVM_LIB(LLVMHipStdPar)
-  FIND_AND_ADD_LLVM_LIB(LLVMCoroutines)
-  FIND_AND_ADD_LLVM_LIB(LLVMCFGuard)
-  FIND_AND_ADD_LLVM_LIB(LLVMipo)
-  FIND_AND_ADD_LLVM_LIB(LLVMInstrumentation)
-  FIND_AND_ADD_LLVM_LIB(LLVMVectorize)
-  FIND_AND_ADD_LLVM_LIB(LLVMSandboxIR)
-  FIND_AND_ADD_LLVM_LIB(LLVMLinker)
-  FIND_AND_ADD_LLVM_LIB(LLVMFrontendOpenMP)
-  FIND_AND_ADD_LLVM_LIB(LLVMFrontendDirective)
-  FIND_AND_ADD_LLVM_LIB(LLVMFrontendAtomic)
-  FIND_AND_ADD_LLVM_LIB(LLVMFrontendOffloading)
-  FIND_AND_ADD_LLVM_LIB(LLVMObjectYAML)
   FIND_AND_ADD_LLVM_LIB(LLVMDWARFLinkerParallel)
   FIND_AND_ADD_LLVM_LIB(LLVMDWARFLinkerClassic)
   FIND_AND_ADD_LLVM_LIB(LLVMDWARFLinker)
+  FIND_AND_ADD_LLVM_LIB(LLVMCodeGenData)
   FIND_AND_ADD_LLVM_LIB(LLVMGlobalISel)
   FIND_AND_ADD_LLVM_LIB(LLVMMIRParser)
   FIND_AND_ADD_LLVM_LIB(LLVMAsmPrinter)
@@ -351,7 +345,6 @@ else()
   FIND_AND_ADD_LLVM_LIB(LLVMTarget)
   FIND_AND_ADD_LLVM_LIB(LLVMObjCARCOpts)
   FIND_AND_ADD_LLVM_LIB(LLVMCodeGenTypes)
-  FIND_AND_ADD_LLVM_LIB(LLVMCGData)
   FIND_AND_ADD_LLVM_LIB(LLVMIRPrinter)
   FIND_AND_ADD_LLVM_LIB(LLVMInterfaceStub)
   FIND_AND_ADD_LLVM_LIB(LLVMFileCheck)
@@ -367,16 +360,14 @@ else()
   FIND_AND_ADD_LLVM_LIB(LLVMDebugInfoBTF)
   FIND_AND_ADD_LLVM_LIB(LLVMDebugInfoPDB)
   FIND_AND_ADD_LLVM_LIB(LLVMDebugInfoMSF)
-  FIND_AND_ADD_LLVM_LIB(LLVMDebugInfoCodeView)
-  FIND_AND_ADD_LLVM_LIB(LLVMDebugInfoGSYM)
   FIND_AND_ADD_LLVM_LIB(LLVMDebugInfoDWARF)
-  FIND_AND_ADD_LLVM_LIB(LLVMDebugInfoDWARFLowLevel)
   FIND_AND_ADD_LLVM_LIB(LLVMObject)
   FIND_AND_ADD_LLVM_LIB(LLVMTextAPI)
   FIND_AND_ADD_LLVM_LIB(LLVMMCParser)
   FIND_AND_ADD_LLVM_LIB(LLVMIRReader)
   FIND_AND_ADD_LLVM_LIB(LLVMAsmParser)
   FIND_AND_ADD_LLVM_LIB(LLVMMC)
+  FIND_AND_ADD_LLVM_LIB(LLVMDebugInfoCodeView)
   FIND_AND_ADD_LLVM_LIB(LLVMBitReader)
   FIND_AND_ADD_LLVM_LIB(LLVMFuzzerCLI)
   FIND_AND_ADD_LLVM_LIB(LLVMCore)

doc/langref/Assembly Syntax Explained.zig

@@ -53,7 +53,8 @@ pub fn syscall1(number: usize, arg1: usize) usize {
           // memory locations - not only the memory pointed to by a declared indirect
           // output. In this example we list $rcx and $r11 because it is known the
           // kernel syscall does not preserve these registers.
-        : .{ .rcx = true, .r11 = true });
+        : "rcx", "r11"
+    );
 }
 
 // syntax

doc/langref/bad_default_value.zig

@@ -17,7 +17,7 @@ pub fn main() !void {
         .maximum = 0.20,
     };
     const category = threshold.categorize(0.90);
-    std.log.info("category: {t}", .{category});
+    try std.io.getStdOut().writeAll(@tagName(category));
 }
 
 const std = @import("std");

doc/langref/build.zig

@@ -4,10 +4,8 @@ pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const exe = b.addExecutable(.{
         .name = "example",
-        .root_module = b.createModule(.{
-            .root_source_file = b.path("example.zig"),
-            .optimize = optimize,
-        }),
+        .root_source_file = b.path("example.zig"),
+        .optimize = optimize,
     });
     b.default_step.dependOn(&exe.step);
 }

doc/langref/build_c.zig

@@ -1,22 +1,17 @@
 const std = @import("std");
 
 pub fn build(b: *std.Build) void {
-    const lib = b.addLibrary(.{
-        .linkage = .dynamic,
+    const lib = b.addSharedLibrary(.{
         .name = "mathtest",
-        .root_module = b.createModule(.{
-            .root_source_file = b.path("mathtest.zig"),
-        }),
+        .root_source_file = b.path("mathtest.zig"),
         .version = .{ .major = 1, .minor = 0, .patch = 0 },
     });
     const exe = b.addExecutable(.{
         .name = "test",
-        .root_module = b.createModule(.{
-            .link_libc = true,
-        }),
     });
-    exe.root_module.addCSourceFile(.{ .file = b.path("test.c"), .flags = &.{"-std=c99"} });
-    exe.root_module.linkLibrary(lib);
+    exe.addCSourceFile(.{ .file = b.path("test.c"), .flags = &.{"-std=c99"} });
+    exe.linkLibrary(lib);
+    exe.linkSystemLibrary("c");
 
     b.default_step.dependOn(&exe.step);
 

doc/langref/build_object.zig

@@ -3,19 +3,15 @@ const std = @import("std");
 pub fn build(b: *std.Build) void {
     const obj = b.addObject(.{
         .name = "base64",
-        .root_module = b.createModule(.{
-            .root_source_file = b.path("base64.zig"),
-        }),
+        .root_source_file = b.path("base64.zig"),
     });
 
     const exe = b.addExecutable(.{
         .name = "test",
-        .root_module = b.createModule(.{
-            .link_libc = true,
-        }),
     });
-    exe.root_module.addCSourceFile(.{ .file = b.path("test.c"), .flags = &.{"-std=c99"} });
-    exe.root_module.addObject(obj);
+    exe.addCSourceFile(.{ .file = b.path("test.c"), .flags = &.{"-std=c99"} });
+    exe.addObject(obj);
+    exe.linkSystemLibrary("c");
     b.installArtifact(exe);
 }
 

doc/langref/builtin.CallModifier struct.zig

@@ -2,6 +2,9 @@ pub const CallModifier = enum {
     /// Equivalent to function call syntax.
     auto,
 
+    /// Equivalent to async keyword used with function call syntax.
+    async_kw,
+
     /// Prevents tail call optimization. This guarantees that the return
     /// address will point to the callsite, as opposed to the callsite's
     /// callsite. If the call is otherwise required to be tail-called
@@ -14,7 +17,7 @@ pub const CallModifier = enum {
 
     /// Asserts that the function call will not suspend. This allows a
     /// non-async function to call an async function.
-    no_suspend,
+    no_async,
 
     /// Guarantees that the call will be generated with tail call optimization.
     /// If this is not possible, a compile error is emitted instead.

doc/langref/cImport_builtin.zig

@@ -4,7 +4,6 @@ const c = @cImport({
     @cInclude("stdio.h");
 });
 pub fn main() void {
-    if (@import("builtin").os.tag == .netbsd) return; // https://github.com/Vexu/arocc/issues/960
     _ = c.printf("hello\n");
 }
 

doc/langref/defer_unwind.zig

@@ -1,7 +1,8 @@
 const std = @import("std");
+const expect = std.testing.expect;
 const print = std.debug.print;
 
-pub fn main() void {
+test "defer unwinding" {
     print("\n", .{});
 
     defer {
@@ -18,4 +19,4 @@ pub fn main() void {
     }
 }
 
-// exe=succeed
+// test

doc/langref/destructuring_block.zig

@@ -15,8 +15,8 @@ pub fn main() void {
         break :blk .{ min, max };
     };
 
-    print("min = {}\n", .{ min });
-    print("max = {}\n", .{ max });
+    print("min = {}", .{ min });
+    print("max = {}", .{ max });
 }
 
 // exe=succeed

doc/langref/error_union_parsing_u64.zig

@@ -35,7 +35,7 @@ fn charToDigit(c: u8) u8 {
 
 test "parse u64" {
     const result = try parseU64("1234", 10);
-    try std.testing.expectEqual(1234, result);
+    try std.testing.expect(result == 1234);
 }
 
 // test

doc/langref/export_builtin.zig

@@ -2,6 +2,6 @@ comptime {
     @export(&internalName, .{ .name = "foo", .linkage = .strong });
 }
 
-fn internalName() callconv(.c) void {}
+fn internalName() callconv(.C) void {}
 
 // obj

doc/langref/hello.zig

@@ -1,7 +1,8 @@
 const std = @import("std");
 
-pub fn main(init: std.process.Init) !void {
-    try std.Io.File.stdout().writeStreamingAll(init.io, "Hello, World!\n");
+pub fn main() !void {
+    const stdout = std.io.getStdOut().writer();
+    try stdout.print("Hello, {s}!\n", .{"world"});
 }
 
 // exe=succeed

doc/langref/hello_again.zig

@@ -1,7 +1,7 @@
 const std = @import("std");
 
 pub fn main() void {
-    std.debug.print("Hello, {s}!\n", .{"World"});
+    std.debug.print("Hello, world!\n", .{});
 }
 
 // exe=succeed

doc/langref/inline_assembly.zig

@@ -15,7 +15,8 @@ pub fn syscall1(number: usize, arg1: usize) usize {
         : [ret] "={rax}" (-> usize),
         : [number] "{rax}" (number),
           [arg1] "{rdi}" (arg1),
-        : .{ .rcx = true, .r11 = true });
+        : "rcx", "r11"
+    );
 }
 
 pub fn syscall3(number: usize, arg1: usize, arg2: usize, arg3: usize) usize {
@@ -25,7 +26,8 @@ pub fn syscall3(number: usize, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{rdi}" (arg1),
           [arg2] "{rsi}" (arg2),
           [arg3] "{rdx}" (arg3),
-        : .{ .rcx = true, .r11 = true });
+        : "rcx", "r11"
+    );
 }
 
 // exe=succeed

doc/langref/inline_call.zig

@@ -1,14 +1,11 @@
-const std = @import("std");
-
-pub fn main() void {
+test "inline function call" {
     if (foo(1200, 34) != 1234) {
         @compileError("bad");
     }
 }
 
 inline fn foo(a: i32, b: i32) i32 {
-    std.debug.print("runtime a = {} b = {}", .{ a, b });
     return a + b;
 }
 
-// exe=succeed
+// test

doc/langref/packed_struct_mmio.zig

@@ -1,19 +0,0 @@
-pub const GpioRegister = packed struct(u8) {
-    GPIO0: bool,
-    GPIO1: bool,
-    GPIO2: bool,
-    GPIO3: bool,
-    reserved: u4 = 0,
-};
-
-const gpio: *volatile GpioRegister = @ptrFromInt(0x0123);
-
-pub fn writeToGpio(new_states: GpioRegister) void {
-    // Example of what not to do:
-    // BAD! gpio.GPIO0 = true; BAD!
-
-    // Instead, do this:
-    gpio.* = new_states;
-}
-
-// syntax

doc/langref/result_location_interfering_with_swap.zig

@@ -1,4 +1,4 @@
-const expectEqual = @import("std").testing.expectEqual;
+const expect = @import("std").testing.expect;
 test "attempt to swap array elements with array initializer" {
     var arr: [2]u32 = .{ 1, 2 };
     arr = .{ arr[1], arr[0] };
@@ -6,8 +6,8 @@ test "attempt to swap array elements with array initializer" {
     //   arr[0] = arr[1];
     //   arr[1] = arr[0];
     // So this fails!
-    try expectEqual(2, arr[0]); // succeeds
-    try expectEqual(1, arr[1]); // fails
+    try expect(arr[0] == 2); // succeeds
+    try expect(arr[1] == 1); // fails
 }
 
 // test_error=

doc/langref/runtime_shrExact_overflow.zig

@@ -1,4 +1,3 @@
-const builtin = @import("builtin");
 const std = @import("std");
 
 pub fn main() void {
@@ -6,8 +5,6 @@ pub fn main() void {
     _ = &x;
     const y = @shrExact(x, 2);
     std.debug.print("value: {}\n", .{y});
-
-    if ((builtin.cpu.arch.isPowerPC() or builtin.cpu.arch.isRISCV() or builtin.cpu.arch.isLoongArch() or builtin.cpu.arch == .s390x) and builtin.zig_backend == .stage2_llvm) @panic("https://github.com/ziglang/zig/issues/24304");
 }
 
 // exe=fail

doc/langref/std_options.zig

@@ -11,7 +11,7 @@ pub const std_options: std.Options = .{
 
 fn myLogFn(
     comptime level: std.log.Level,
-    comptime scope: @EnumLiteral(),
+    comptime scope: @Type(.enum_literal),
     comptime format: []const u8,
     args: anytype,
 ) void {

doc/langref/test_TypeOf_builtin.zig

@@ -1,11 +1,11 @@
 const std = @import("std");
-const expectEqual = std.testing.expectEqual;
+const expect = std.testing.expect;
 
 test "no runtime side effects" {
     var data: i32 = 0;
     const T = @TypeOf(foo(i32, &data));
-    try comptime expectEqual(i32, T);
-    try expectEqual(0, data);
+    try comptime expect(T == i32);
+    try expect(data == 0);
 }
 
 fn foo(comptime T: type, ptr: *T) T {

doc/langref/test_allocator.zig

@@ -1,13 +1,13 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
-const expectEqualStrings = std.testing.expectEqualStrings;
+const expect = std.testing.expect;
 
 test "using an allocator" {
     var buffer: [100]u8 = undefined;
     var fba = std.heap.FixedBufferAllocator.init(&buffer);
     const allocator = fba.allocator();
     const result = try concat(allocator, "foo", "bar");
-    try expectEqualStrings("foobar", result);
+    try expect(std.mem.eql(u8, "foobar", result));
 }
 
 fn concat(allocator: Allocator, a: []const u8, b: []const u8) ![]u8 {

doc/langref/test_allowzero.zig

@@ -1,11 +1,11 @@
 const std = @import("std");
-const expectEqual = std.testing.expectEqual;
+const expect = std.testing.expect;
 
 test "allowzero" {
     var zero: usize = 0; // var to make to runtime-known
     _ = &zero; // suppress 'var is never mutated' error
     const ptr: *allowzero i32 = @ptrFromInt(zero);
-    try expectEqual(0, @intFromPtr(ptr));
+    try expect(@intFromPtr(ptr) == 0);
 }
 
 // test

doc/langref/test_anonymous_struct.zig

@@ -1,6 +1,5 @@
 const std = @import("std");
 const expect = std.testing.expect;
-const expectEqual = std.testing.expectEqual;
 
 test "fully anonymous struct" {
     try check(.{
@@ -12,11 +11,11 @@ test "fully anonymous struct" {
 }
 
 fn check(args: anytype) !void {
-    try expectEqual(1234, args.int);
-    try expectEqual(12.34, args.float);
+    try expect(args.int == 1234);
+    try expect(args.float == 12.34);
     try expect(args.b);
-    try expectEqual('h', args.s[0]);
-    try expectEqual('i', args.s[1]);
+    try expect(args.s[0] == 'h');
+    try expect(args.s[1] == 'i');
 }
 
 // test

doc/langref/test_anonymous_union.zig

@@ -1,5 +1,5 @@
 const std = @import("std");
-const expectEqual = std.testing.expectEqual;
+const expect = std.testing.expect;
 
 const Number = union {
     int: i32,
@@ -9,8 +9,8 @@ const Number = union {
 test "anonymous union literal syntax" {
     const i: Number = .{ .int = 42 };
     const f = makeNumber();
-    try expectEqual(42, i.int);
-    try expectEqual(12.34, f.float);
+    try expect(i.int == 42);
+    try expect(f.float == 12.34);
 }
 
 fn makeNumber() Number {

doc/langref/test_arrays.zig

@@ -1,4 +1,4 @@
-const expectEqual = @import("std").testing.expectEqual;
+const expect = @import("std").testing.expect;
 const assert = @import("std").debug.assert;
 const mem = @import("std").mem;
 
@@ -29,7 +29,7 @@ test "iterate over an array" {
     for (message) |byte| {
         sum += byte;
     }
-    try expectEqual('h' + 'e' + 'l' * 2 + 'o', sum);
+    try expect(sum == 'h' + 'e' + 'l' * 2 + 'o');
 }
 
 // modifiable array
@@ -39,8 +39,8 @@ test "modify an array" {
     for (&some_integers, 0..) |*item, i| {
         item.* = @intCast(i);
     }
-    try expectEqual(10, some_integers[10]);
-    try expectEqual(99, some_integers[99]);
+    try expect(some_integers[10] == 10);
+    try expect(some_integers[99] == 99);
 }
 
 // array concatenation works if the values are known
@@ -91,8 +91,8 @@ const Point = struct {
 };
 
 test "compile-time array initialization" {
-    try expectEqual(4, fancy_array[4].x);
-    try expectEqual(8, fancy_array[4].y);
+    try expect(fancy_array[4].x == 4);
+    try expect(fancy_array[4].y == 8);
 }
 
 // call a function to initialize an array
@@ -104,9 +104,9 @@ fn makePoint(x: i32) Point {
     };
 }
 test "array initialization with function calls" {
-    try expectEqual(3, more_points[4].x);
-    try expectEqual(6, more_points[4].y);
-    try expectEqual(10, more_points.len);
+    try expect(more_points[4].x == 3);
+    try expect(more_points[4].y == 6);
+    try expect(more_points.len == 10);
 }
 
 // test

doc/langref/test_basic_slices.zig

@@ -1,4 +1,4 @@
-const expectEqual = @import("std").testing.expectEqual;
+const expect = @import("std").testing.expect;
 const expectEqualSlices = @import("std").testing.expectEqualSlices;
 
 test "basic slices" {
@@ -12,14 +12,14 @@ test "basic slices" {
 
     try expectEqualSlices(i32, slice, alt_slice);
 
-    try expectEqual([]i32, @TypeOf(slice));
-    try expectEqual(&array[0], &slice[0]);
-    try expectEqual(array.len, slice.len);
+    try expect(@TypeOf(slice) == []i32);
+    try expect(&slice[0] == &array[0]);
+    try expect(slice.len == array.len);
 
     // If you slice with comptime-known start and end positions, the result is
     // a pointer to an array, rather than a slice.
     const array_ptr = array[0..array.len];
-    try expectEqual(*[array.len]i32, @TypeOf(array_ptr));
+    try expect(@TypeOf(array_ptr) == *[array.len]i32);
 
     // You can perform a slice-by-length by slicing twice. This allows the compiler
     // to perform some optimisations like recognising a comptime-known length when
@@ -28,13 +28,13 @@ test "basic slices" {
     _ = &runtime_start;
     const length = 2;
     const array_ptr_len = array[runtime_start..][0..length];
-    try expectEqual(*[length]i32, @TypeOf(array_ptr_len));
+    try expect(@TypeOf(array_ptr_len) == *[length]i32);
 
     // Using the address-of operator on a slice gives a single-item pointer.
-    try expectEqual(*i32, @TypeOf(&slice[0]));
+    try expect(@TypeOf(&slice[0]) == *i32);
     // Using the `ptr` field gives a many-item pointer.
-    try expectEqual([*]i32, @TypeOf(slice.ptr));
-    try expectEqual(@intFromPtr(slice.ptr), @intFromPtr(&slice[0]));
+    try expect(@TypeOf(slice.ptr) == [*]i32);
+    try expect(@intFromPtr(slice.ptr) == @intFromPtr(&slice[0]));
 
     // Slices have array bounds checking. If you try to access something out
     // of bounds, you'll get a safety check failure:
@@ -47,8 +47,8 @@ test "basic slices" {
     const empty1 = &[0]u8{};
     // If the type is known you can use this short hand:
     const empty2: []u8 = &.{};
-    try expectEqual(0, empty1.len);
-    try expectEqual(0, empty2.len);
+    try expect(empty1.len == 0);
+    try expect(empty2.len == 0);
 
     // A zero-length initialization can always be used to create an empty slice, even if the slice is mutable.
     // This is because the pointed-to data is zero bits long, so its immutability is irrelevant.

doc/langref/test_bitOffsetOf_offsetOf.zig

@@ -1,5 +1,5 @@
 const std = @import("std");
-const expectEqual = std.testing.expectEqual;
+const expect = std.testing.expect;
 
 const BitField = packed struct {
     a: u3,
@@ -9,13 +9,13 @@ const BitField = packed struct {
 
 test "offsets of non-byte-aligned fields" {
     comptime {
-        try expectEqual(0, @bitOffsetOf(BitField, "a"));
-        try expectEqual(3, @bitOffsetOf(BitField, "b"));
-        try expectEqual(6, @bitOffsetOf(BitField, "c"));
+        try expect(@bitOffsetOf(BitField, "a") == 0);
+        try expect(@bitOffsetOf(BitField, "b") == 3);
+        try expect(@bitOffsetOf(BitField, "c") == 6);
 
-        try expectEqual(0, @offsetOf(BitField, "a"));
-        try expectEqual(0, @offsetOf(BitField, "b"));
-        try expectEqual(0, @offsetOf(BitField, "c"));
+        try expect(@offsetOf(BitField, "a") == 0);
+        try expect(@offsetOf(BitField, "b") == 0);
+        try expect(@offsetOf(BitField, "c") == 0);
     }
 }
 

doc/langref/test_call_builtin.zig

@@ -1,7 +1,7 @@
-const expectEqual = @import("std").testing.expectEqual;
+const expect = @import("std").testing.expect;
 
 test "noinline function call" {
-    try expectEqual(12, @call(.auto, add, .{ 3, 9 }));
+    try expect(@call(.auto, add, .{ 3, 9 }) == 12);
 }
 
 fn add(a: i32, b: i32) i32 {

doc/langref/test_coerce_error_subset_to_superset.zig

@@ -12,7 +12,7 @@ const AllocationError = error{
 
 test "coerce subset to superset" {
     const err = foo(AllocationError.OutOfMemory);
-    try std.testing.expectEqual(FileOpenError.OutOfMemory, err);
+    try std.testing.expect(err == FileOpenError.OutOfMemory);
 }
 
 fn foo(err: AllocationError) FileOpenError {

doc/langref/test_coerce_large_to_small.zig

@@ -1,10 +1,10 @@
 const std = @import("std");
-const expectEqual = std.testing.expectEqual;
+const expect = std.testing.expect;
 
 test "coercing large integer type to smaller one when value is comptime-known to fit" {
     const x: u64 = 255;
     const y: u8 = x;
-    try expectEqual(255, y);
+    try expect(y == 255);
 }
 
 // test

doc/langref/test_coerce_optional_wrapped_error_union.zig

@@ -1,12 +1,12 @@
 const std = @import("std");
-const expectEqual = std.testing.expectEqual;
+const expect = std.testing.expect;
 
 test "coerce to optionals wrapped in error union" {
     const x: anyerror!?i32 = 1234;
     const y: anyerror!?i32 = null;
 
-    try expectEqual(1234, (try x).?);
-    try expectEqual(null, (try y));
+    try expect((try x).? == 1234);
+    try expect((try y) == null);
 }
 
 // test

doc/langref/test_coerce_optionals.zig

@@ -1,12 +1,12 @@
 const std = @import("std");
-const expectEqual = std.testing.expectEqual;
+const expect = std.testing.expect;
 
 test "coerce to optionals" {
     const x: ?i32 = 1234;
     const y: ?i32 = null;
 
-    try expectEqual(1234, x.?);
-    try expectEqual(null, y);
+    try expect(x.? == 1234);
+    try expect(y == null);
 }
 
 // test

doc/langref/test_coerce_slices_arrays_and_pointers.zig

@@ -1,7 +1,5 @@
 const std = @import("std");
-const expectEqual = std.testing.expectEqual;
-const expectEqualStrings = std.testing.expectEqualStrings;
-const expectEqualSlices = std.testing.expectEqualSlices;
+const expect = std.testing.expect;
 
 // You can assign constant pointers to arrays to a slice with
 // const modifier on the element type. Useful in particular for
@@ -9,48 +7,48 @@ const expectEqualSlices = std.testing.expectEqualSlices;
 test "*const [N]T to []const T" {
     const x1: []const u8 = "hello";
     const x2: []const u8 = &[5]u8{ 'h', 'e', 'l', 'l', 111 };
-    try expectEqualStrings(x1, x2);
+    try expect(std.mem.eql(u8, x1, x2));
 
     const y: []const f32 = &[2]f32{ 1.2, 3.4 };
-    try expectEqual(1.2, y[0]);
+    try expect(y[0] == 1.2);
 }
 
 // Likewise, it works when the destination type is an error union.
 test "*const [N]T to E![]const T" {
     const x1: anyerror![]const u8 = "hello";
     const x2: anyerror![]const u8 = &[5]u8{ 'h', 'e', 'l', 'l', 111 };
-    try expectEqualStrings(try x1, try x2);
+    try expect(std.mem.eql(u8, try x1, try x2));
 
     const y: anyerror![]const f32 = &[2]f32{ 1.2, 3.4 };
-    try expectEqual(1.2, (try y)[0]);
+    try expect((try y)[0] == 1.2);
 }
 
 // Likewise, it works when the destination type is an optional.
 test "*const [N]T to ?[]const T" {
     const x1: ?[]const u8 = "hello";
     const x2: ?[]const u8 = &[5]u8{ 'h', 'e', 'l', 'l', 111 };
-    try expectEqualStrings(x1.?, x2.?);
+    try expect(std.mem.eql(u8, x1.?, x2.?));
 
     const y: ?[]const f32 = &[2]f32{ 1.2, 3.4 };
-    try expectEqual(1.2, y.?[0]);
+    try expect(y.?[0] == 1.2);
 }
 
 // In this cast, the array length becomes the slice length.
 test "*[N]T to []T" {
     var buf: [5]u8 = "hello".*;
     const x: []u8 = &buf;
-    try expectEqualStrings("hello", x);
+    try expect(std.mem.eql(u8, x, "hello"));
 
     const buf2 = [2]f32{ 1.2, 3.4 };
     const x2: []const f32 = &buf2;
-    try expectEqualSlices(f32, &[2]f32{ 1.2, 3.4 }, x2);
+    try expect(std.mem.eql(f32, x2, &[2]f32{ 1.2, 3.4 }));
 }
 
 // Single-item pointers to arrays can be coerced to many-item pointers.
 test "*[N]T to [*]T" {
     var buf: [5]u8 = "hello".*;
     const x: [*]u8 = &buf;
-    try expectEqual('o', x[4]);
+    try expect(x[4] == 'o');
     // x[5] would be an uncaught out of bounds pointer dereference!
 }
 
@@ -58,7 +56,7 @@ test "*[N]T to [*]T" {
 test "*[N]T to ?[*]T" {
     var buf: [5]u8 = "hello".*;
     const x: ?[*]u8 = &buf;
-    try expectEqual('o', x.?[4]);
+    try expect(x.?[4] == 'o');
 }
 
 // Single-item pointers can be cast to len-1 single-item arrays.
@@ -66,14 +64,7 @@ test "*T to *[1]T" {
     var x: i32 = 1234;
     const y: *[1]i32 = &x;
     const z: [*]i32 = y;
-    try expectEqual(1234, z[0]);
-}
-
-// Sentinel-terminated slices can be coerced into sentinel-terminated pointers
-test "[:x]T to [*:x]T" {
-    const buf: [:0]const u8 = "hello";
-    const buf2: [*:0]const u8 = buf;
-    try expectEqual('o', buf2[4]);
+    try expect(z[0] == 1234);
 }
 
 // test

doc/langref/test_coerce_to_error_union.zig

@@ -1,11 +1,11 @@
 const std = @import("std");
-const expectEqual = std.testing.expectEqual;
+const expect = std.testing.expect;
 
 test "coercion to error unions" {
     const x: anyerror!i32 = 1234;
     const y: anyerror!i32 = error.Failure;
 
-    try expectEqual(1234, (try x));
+    try expect((try x) == 1234);
     try std.testing.expectError(error.Failure, y);
 }
 

doc/langref/test_coerce_tuples_arrays.zig

@@ -1,5 +1,5 @@
 const std = @import("std");
-const expectEqual = std.testing.expectEqual;
+const expect = std.testing.expect;
 
 const Tuple = struct { u8, u8 };
 test "coercion from homogeneous tuple to array" {

doc/langref/test_coerce_unions_enums.zig

@@ -1,5 +1,5 @@
 const std = @import("std");
-const expectEqual = std.testing.expectEqual;
+const expect = std.testing.expect;
 
 const E = enum {
     one,
@@ -28,22 +28,22 @@ const U2 = union(enum) {
 test "coercion between unions and enums" {
     const u = U{ .two = 12.34 };
     const e: E = u; // coerce union to enum
-    try expectEqual(E.two, e);
+    try expect(e == E.two);
 
     const three = E.three;
     const u_2: U = three; // coerce enum to union
-    try expectEqual(E.three, u_2);
+    try expect(u_2 == E.three);
 
     const u_3: U = .three; // coerce enum literal to union
-    try expectEqual(E.three, u_3);
+    try expect(u_3 == E.three);
 
     const u_4: U2 = .a; // coerce enum literal to union with inferred enum tag type.
-    try expectEqual(1, u_4.tag());
+    try expect(u_4.tag() == 1);
 
     // The following example is invalid.
-    // error: coercion from enum '@EnumLiteral()' to union 'test_coerce_unions_enum.U2' must initialize 'f32' field 'b'
+    // error: coercion from enum '@TypeOf(.enum_literal)' to union 'test_coerce_unions_enum.U2' must initialize 'f32' field 'b'
     //var u_5: U2 = .b;
-    //try expectEqual(2, u_5.tag());
+    //try expect(u_5.tag() == 2);
 }
 
 // test

doc/langref/test_comptime_evaluation.zig

@@ -1,4 +1,4 @@
-const expectEqual = @import("std").testing.expectEqual;
+const expect = @import("std").testing.expect;
 
 const CmdFn = struct {
     name: []const u8,
@@ -32,9 +32,9 @@ fn performFn(comptime prefix_char: u8, start_value: i32) i32 {
 }
 
 test "perform fn" {
-    try expectEqual(6, performFn('t', 1));
-    try expectEqual(1, performFn('o', 0));
-    try expectEqual(99, performFn('w', 99));
+    try expect(performFn('t', 1) == 6);
+    try expect(performFn('o', 0) == 1);
+    try expect(performFn('w', 99) == 99);
 }
 
 // test

doc/langref/test_comptime_max_with_bool.zig

@@ -8,7 +8,7 @@ fn max(comptime T: type, a: T, b: T) T {
     }
 }
 test "try to compare bools" {
-    try @import("std").testing.expectEqual(true, max(bool, false, true));
+    try @import("std").testing.expect(max(bool, false, true) == true);
 }
 
 // test

doc/langref/test_comptime_pointer_conversion.zig

@@ -1,4 +1,4 @@
-const expectEqual = @import("std").testing.expectEqual;
+const expect = @import("std").testing.expect;
 
 test "comptime @ptrFromInt" {
     comptime {
@@ -6,8 +6,8 @@ test "comptime @ptrFromInt" {
         // ptr is never dereferenced.
         const ptr: *i32 = @ptrFromInt(0xdeadbee0);
         const addr = @intFromPtr(ptr);
-        try expectEqual(usize, @TypeOf(addr));
-        try expectEqual(0xdeadbee0, addr);
+        try expect(@TypeOf(addr) == usize);
+        try expect(addr == 0xdeadbee0);
     }
 }
 

doc/langref/test_comptime_pointers.zig

@@ -1,4 +1,4 @@
-const expectEqual = @import("std").testing.expectEqual;
+const expect = @import("std").testing.expect;
 
 test "comptime pointers" {
     comptime {
@@ -6,7 +6,7 @@ test "comptime pointers" {
         const ptr = &x;
         ptr.* += 1;
         x += 1;
-        try expectEqual(3, ptr.*);
+        try expect(ptr.* == 3);
     }
 }
 

doc/langref/test_comptime_shlExact_overflow.zig

@@ -1,6 +0,0 @@
-comptime {
-    const x = @shlExact(@as(u8, 0b01010101), 2);
-    _ = x;
-}
-
-// test_error=overflow of integer type 'u8' with value '340'

doc/langref/test_comptime_shlExact_overwlow.zig

@@ -0,0 +1,6 @@
+comptime {
+    const x = @shlExact(@as(u8, 0b01010101), 2);
+    _ = x;
+}
+
+// test_error=operation caused overflow

doc/langref/test_comptime_variables.zig

@@ -1,5 +1,5 @@
 const std = @import("std");
-const expectEqual = std.testing.expectEqual;
+const expect = std.testing.expect;
 
 test "comptime vars" {
     var x: i32 = 1;
@@ -8,8 +8,8 @@ test "comptime vars" {
     x += 1;
     y += 1;
 
-    try expectEqual(2, x);
-    try expectEqual(2, y);
+    try expect(x == 2);
+    try expect(y == 2);
 
     if (y != 2) {
         // This compile error never triggers because y is a comptime variable,

doc/langref/test_container-level_comptime_expressions.zig

@@ -31,7 +31,7 @@ fn sum(numbers: []const i32) i32 {
 }
 
 test "variable values" {
-    try @import("std").testing.expectEqual(1060, sum_of_first_25_primes);
+    try @import("std").testing.expect(sum_of_first_25_primes == 1060);
 }
 
 // test

doc/langref/test_container_level_variables.zig

@@ -2,8 +2,8 @@ var y: i32 = add(10, x);
 const x: i32 = add(12, 34);
 
 test "container level variables" {
-    try expectEqual(46, x);
-    try expectEqual(56, y);
+    try expect(x == 46);
+    try expect(y == 56);
 }
 
 fn add(a: i32, b: i32) i32 {
@@ -11,6 +11,6 @@ fn add(a: i32, b: i32) i32 {
 }
 
 const std = @import("std");
-const expectEqual = std.testing.expectEqual;
+const expect = std.testing.expect;
 
 // test

doc/langref/test_defer.zig

@@ -1,5 +1,5 @@
 const std = @import("std");
-const expectEqual = std.testing.expectEqual;
+const expect = std.testing.expect;
 const print = std.debug.print;
 
 fn deferExample() !usize {
@@ -9,14 +9,14 @@ fn deferExample() !usize {
         defer a = 2;
         a = 1;
     }
-    try expectEqual(2, a);
+    try expect(a == 2);
 
     a = 5;
     return a;
 }
 
 test "defer basics" {
-    try expectEqual(5, (try deferExample()));
+    try expect((try deferExample()) == 5);
 }
 
 // test

doc/langref/test_defining_variadic_function.zig

@@ -2,7 +2,7 @@ const std = @import("std");
 const testing = std.testing;
 const builtin = @import("builtin");
 
-fn add(count: c_int, ...) callconv(.c) c_int {
+fn add(count: c_int, ...) callconv(.C) c_int {
     var ap = @cVaStart();
     defer @cVaEnd(&ap);
     var i: usize = 0;
@@ -22,10 +22,6 @@ test "defining a variadic function" {
         // https://github.com/ziglang/zig/issues/16961
         return error.SkipZigTest;
     }
-    if (builtin.cpu.arch == .s390x) {
-        // https://github.com/ziglang/zig/issues/21350#issuecomment-3543006475
-        return error.SkipZigTest;
-    }
 
     try std.testing.expectEqual(@as(c_int, 0), add(0));
     try std.testing.expectEqual(@as(c_int, 1), add(1, @as(c_int, 1)));

doc/langref/test_empty_block.zig

@@ -1,12 +1,12 @@
 const std = @import("std");
-const expectEqual = std.testing.expectEqual;
+const expect = std.testing.expect;
 
 test {
     const a = {};
     const b = void{};
-    try expectEqual(void, @TypeOf(a));
-    try expectEqual(void, @TypeOf(b));
-    try expectEqual(a, b);
+    try expect(@TypeOf(a) == void);
+    try expect(@TypeOf(b) == void);
+    try expect(a == b);
 }
 
 // test

doc/langref/test_enum_literals.zig

@@ -1,6 +1,5 @@
 const std = @import("std");
 const expect = std.testing.expect;
-const expectEqual = std.testing.expectEqual;
 
 const Color = enum {
     auto,
@@ -11,7 +10,7 @@ const Color = enum {
 test "enum literals" {
     const color1: Color = .auto;
     const color2 = Color.auto;
-    try expectEqual(color1, color2);
+    try expect(color1 == color2);
 }
 
 test "switch using enum literals" {

doc/langref/test_enums.zig

@@ -1,6 +1,4 @@
 const expect = @import("std").testing.expect;
-const expectEqual = @import("std").testing.expectEqual;
-const expectEqualStrings = @import("std").testing.expectEqualStrings;
 const mem = @import("std").mem;
 
 // Declare an enum.
@@ -22,9 +20,9 @@ const Value = enum(u2) {
 // Now you can cast between u2 and Value.
 // The ordinal value starts from 0, counting up by 1 from the previous member.
 test "enum ordinal value" {
-    try expectEqual(0, @intFromEnum(Value.zero));
-    try expectEqual(1, @intFromEnum(Value.one));
-    try expectEqual(2, @intFromEnum(Value.two));
+    try expect(@intFromEnum(Value.zero) == 0);
+    try expect(@intFromEnum(Value.one) == 1);
+    try expect(@intFromEnum(Value.two) == 2);
 }
 
 // You can override the ordinal value for an enum.
@@ -34,9 +32,9 @@ const Value2 = enum(u32) {
     million = 1000000,
 };
 test "set enum ordinal value" {
-    try expectEqual(100, @intFromEnum(Value2.hundred));
-    try expectEqual(1000, @intFromEnum(Value2.thousand));
-    try expectEqual(1000000, @intFromEnum(Value2.million));
+    try expect(@intFromEnum(Value2.hundred) == 100);
+    try expect(@intFromEnum(Value2.thousand) == 1000);
+    try expect(@intFromEnum(Value2.million) == 1000000);
 }
 
 // You can also override only some values.
@@ -48,11 +46,11 @@ const Value3 = enum(u4) {
     e,
 };
 test "enum implicit ordinal values and overridden values" {
-    try expectEqual(0, @intFromEnum(Value3.a));
-    try expectEqual(8, @intFromEnum(Value3.b));
-    try expectEqual(9, @intFromEnum(Value3.c));
-    try expectEqual(4, @intFromEnum(Value3.d));
-    try expectEqual(5, @intFromEnum(Value3.e));
+    try expect(@intFromEnum(Value3.a) == 0);
+    try expect(@intFromEnum(Value3.b) == 8);
+    try expect(@intFromEnum(Value3.c) == 9);
+    try expect(@intFromEnum(Value3.d) == 4);
+    try expect(@intFromEnum(Value3.e) == 5);
 }
 
 // Enums can have methods, the same as structs and unions.
@@ -86,7 +84,7 @@ test "enum switch" {
         Foo.number => "this is a number",
         Foo.none => "this is a none",
     };
-    try expectEqualStrings(what_is_it, "this is a number");
+    try expect(mem.eql(u8, what_is_it, "this is a number"));
 }
 
 // @typeInfo can be used to access the integer tag type of an enum.
@@ -97,18 +95,18 @@ const Small = enum {
     four,
 };
 test "std.meta.Tag" {
-    try expectEqual(u2, @typeInfo(Small).@"enum".tag_type);
+    try expect(@typeInfo(Small).@"enum".tag_type == u2);
 }
 
 // @typeInfo tells us the field count and the fields names:
 test "@typeInfo" {
-    try expectEqual(4, @typeInfo(Small).@"enum".fields.len);
-    try expectEqualStrings(@typeInfo(Small).@"enum".fields[1].name, "two");
+    try expect(@typeInfo(Small).@"enum".fields.len == 4);
+    try expect(mem.eql(u8, @typeInfo(Small).@"enum".fields[1].name, "two"));
 }
 
 // @tagName gives a [:0]const u8 representation of an enum value:
 test "@tagName" {
-    try expectEqualStrings(@tagName(Small.three), "three");
+    try expect(mem.eql(u8, @tagName(Small.three), "three"));
 }
 
 // test