diff --git a/compiler/rustc_codegen_gcc/.cspell.json b/compiler/rustc_codegen_gcc/.cspell.json
index 556432d69a41b..a2856029c2c1a 100644
--- a/compiler/rustc_codegen_gcc/.cspell.json
+++ b/compiler/rustc_codegen_gcc/.cspell.json
@@ -22,7 +22,7 @@
         "src/intrinsic/llvm.rs"
     ],
     "ignoreRegExpList": [
-        "/(FIXME|NOTE|TODO)\\([^)]+\\)/",
+        "/(FIXME|NOTE)\\([^)]+\\)/",
         "__builtin_\\w*"
     ]
 }
diff --git a/compiler/rustc_codegen_gcc/.github/workflows/ci.yml b/compiler/rustc_codegen_gcc/.github/workflows/ci.yml
index fa9535a3729c3..b76c79fd10870 100644
--- a/compiler/rustc_codegen_gcc/.github/workflows/ci.yml
+++ b/compiler/rustc_codegen_gcc/.github/workflows/ci.yml
@@ -26,7 +26,7 @@ jobs:
           - { gcc: "gcc-15.deb" }
           - { gcc: "gcc-15-without-int128.deb" }
         commands: [
-          "--std-tests",
+          "--std-tests --alloc-tests",
           # FIXME: re-enable asm tests when GCC can emit in the right syntax.
           # "--asm-tests",
           "--test-libcore",
@@ -36,6 +36,7 @@ jobs:
           "--test-successful-rustc --nb-parts 2 --current-part 0",
           "--test-successful-rustc --nb-parts 2 --current-part 1",
           "--projects",
+          "--gcc-asm-tests",
         ]
 
     steps:
@@ -52,9 +53,6 @@ jobs:
       # `llvm-14-tools` is needed to install the `FileCheck` binary which is used for asm tests.
       run: sudo apt-get install ninja-build ripgrep llvm-14-tools llvm
 
-    - name: Install rustfmt & clippy
-      run: rustup component add rustfmt clippy
-
     - name: Download artifact
       run: curl -LO https://github.com/rust-lang/gcc/releases/latest/download/${{ matrix.libgccjit_version.gcc }}
 
@@ -88,16 +86,17 @@ jobs:
     - name: Check formatting
       run: ./y.sh fmt --check
 
-    - name: clippy
-      run: |
-        cargo clippy --all-targets -- -D warnings
-        cargo clippy --all-targets --no-default-features -- -D warnings
-        cargo clippy --manifest-path build_system/Cargo.toml --all-targets -- -D warnings
+    - name: Check todo
+      run: ./y.sh check-todo
+
+    - name: Check lints
+      run: ./y.sh clippy
 
     - name: Build
       run: |
         ./y.sh build --sysroot
         ./y.sh test --cargo-tests
+        CARGO_TEST_FLAGS="-Zmir-preserve-ub" ./y.sh test --cargo-tests -- mir_preserve_ub_empty_switch
 
     - name: Run y.sh cargo build
       run: |
diff --git a/compiler/rustc_codegen_gcc/.github/workflows/stdarch.yml b/compiler/rustc_codegen_gcc/.github/workflows/stdarch.yml
index 66f30b147b4c0..17d6449c85e08 100644
--- a/compiler/rustc_codegen_gcc/.github/workflows/stdarch.yml
+++ b/compiler/rustc_codegen_gcc/.github/workflows/stdarch.yml
@@ -21,7 +21,7 @@ jobs:
       fail-fast: false
       matrix:
         cargo_runner: [
-          "sde -future -rtm_mode full --",
+          "sde -cpuid-in /home/runner/work/rustc_codegen_gcc/rustc_codegen_gcc/tests/cpuid.def -rtm_mode full --",
           "",
         ]
 
@@ -42,8 +42,14 @@ jobs:
     - name: Install more recent binutils
       run: |
         echo "deb http://archive.ubuntu.com/ubuntu plucky main universe" | sudo tee /etc/apt/sources.list.d/plucky-copies.list
-        sudo apt-get update
+        sudo apt-get update -o Acquire::Retries=3
         sudo apt-get install binutils
+        installed="$(dpkg-query --showformat='${Version}' --show binutils)"
+        echo "Installed binutils: $installed"
+        if dpkg --compare-versions "$installed" lt "2.44"; then
+            echo "::error::binutils upgrade failed (got $installed, need >= 2.44); the apt fetch probably failed"
+            exit 1
+        fi
 
     - name: Install Intel Software Development Emulator
       if: ${{ matrix.cargo_runner }}
@@ -51,10 +57,9 @@ jobs:
           mkdir intel-sde
           cd intel-sde
           version=10.8.0-2026-03-15
-          url_path=915934
           dir=sde-external-$version-lin
           file=$dir.tar.xz
-          wget https://downloadmirror.intel.com/$url_path/$file
+          wget http://ci-mirrors.rust-lang.org/$file
           tar xvf $file
           sudo mkdir /usr/share/intel-sde
           sudo cp -r $dir/* /usr/share/intel-sde
@@ -90,14 +95,15 @@ jobs:
     - name: Run stdarch tests
       if: ${{ !matrix.cargo_runner }}
       run: |
-        CHANNEL=release TARGET=x86_64-unknown-linux-gnu CG_RUSTFLAGS="-Ainternal_features" ./y.sh cargo test --manifest-path build/build_sysroot/sysroot_src/library/stdarch/Cargo.toml
+        # FIXME: remove --skip test_tile_ and --skip --skip test__tile when it's implemented.
+        ./y.sh test --release --stdarch-tests -- --skip test_tile_ --skip test__tile
 
     - name: Run stdarch tests
       if: ${{ matrix.cargo_runner }}
       run: |
         # FIXME: these tests fail when the sysroot is compiled with LTO because of a missing symbol in proc-macro.
-        # FIXME: remove --skip test_tile_ when it's implemented.
-        STDARCH_TEST_SKIP_FUNCTION="xsave,xsaveopt,xsave64,xsaveopt64" STDARCH_TEST_EVERYTHING=1 CHANNEL=release CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER="${{ matrix.cargo_runner }}" TARGET=x86_64-unknown-linux-gnu CG_RUSTFLAGS="-Ainternal_features" ./y.sh cargo test --manifest-path build/build_sysroot/sysroot_src/library/stdarch/Cargo.toml -- --skip rtm --skip tbm --skip sse4a --skip test_tile_
+        # FIXME: remove --skip test_tile_ and --skip --skip test__tile when it's implemented.
+        STDARCH_TEST_SKIP_FUNCTION="xsave,xsaveopt,xsave64,xsaveopt64" STDARCH_TEST_EVERYTHING=1 CHANNEL=release CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER="${{ matrix.cargo_runner }}" TARGET=x86_64-unknown-linux-gnu CG_RUSTFLAGS="-Ainternal_features" ./y.sh cargo test --manifest-path build/build_sysroot/sysroot_src/library/stdarch/Cargo.toml -- --skip rtm --skip tbm --skip sse4a --skip test_tile_ --skip test__tile
 
   # Summary job for the merge queue.
   # ALL THE PREVIOUS JOBS NEED TO BE ADDED TO THE `needs` SECTION OF THIS JOB!
diff --git a/compiler/rustc_codegen_gcc/.gitignore b/compiler/rustc_codegen_gcc/.gitignore
index 8f73d3eb972a0..1bbd3a9958073 100644
--- a/compiler/rustc_codegen_gcc/.gitignore
+++ b/compiler/rustc_codegen_gcc/.gitignore
@@ -7,7 +7,7 @@ perf.data.old
 *.events
 *.string*
 gimple*
-*asm
+*_asm
 res
 test-backend
 projects
diff --git a/compiler/rustc_codegen_gcc/CONTRIBUTING.md b/compiler/rustc_codegen_gcc/CONTRIBUTING.md
index 8f81ecca445a8..c5c2a783b1ee7 100644
--- a/compiler/rustc_codegen_gcc/CONTRIBUTING.md
+++ b/compiler/rustc_codegen_gcc/CONTRIBUTING.md
@@ -112,7 +112,7 @@ Full list of debugging options can be found in the [README](Readme.md#env-vars).
 ### Code Style Guidelines
 
 - Follow Rust standard coding conventions
-- Ensure your code passes `rustfmt` and `clippy`
+- Ensure your code passes `rustfmt` and `clippy` (you can run them with `y.sh fmt` and `y.sh clippy`)
 - Add comments explaining complex logic, especially in GCC interface code
 
 ## Additional Resources
diff --git a/compiler/rustc_codegen_gcc/Cargo.lock b/compiler/rustc_codegen_gcc/Cargo.lock
index a283ea4cb0b05..060509e51a6f9 100644
--- a/compiler/rustc_codegen_gcc/Cargo.lock
+++ b/compiler/rustc_codegen_gcc/Cargo.lock
@@ -31,9 +31,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "errno"
-version = "0.3.10"
+version = "0.3.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
  "windows-sys",
@@ -56,18 +56,18 @@ dependencies = [
 
 [[package]]
 name = "gccjit"
-version = "3.3.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26b73d18b642ce16378af78f89664841d7eeafa113682ff5d14573424eb0232a"
+checksum = "be5dafc4e649cb4a363e95a5960ef50b0c6f1b8e136ff8eb2e928b40353b5d8b"
 dependencies = [
  "gccjit_sys",
 ]
 
 [[package]]
 name = "gccjit_sys"
-version = "1.3.0"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee689456c013616942d5aef9a84d613cefcc3b335340d036f3650fc1a7459e15"
+checksum = "ab6a00a243aba2a45442bfd72b28d871137d4dac094f13de7f48cf9705112ffe"
 dependencies = [
  "libc",
 ]
@@ -117,15 +117,15 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.168"
+version = "0.2.186"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5aaeb2981e0606ca11d79718f8bb01164f1d6ed75080182d3abf017e6d244b6d"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.9.4"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
 
 [[package]]
 name = "memchr"
@@ -194,9 +194,9 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "1.0.7"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c71e83d6afe7ff64890ec6b71d6a69bb8a610ab78ce364b3352876bb4c801266"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
 dependencies = [
  "bitflags",
  "errno",
@@ -216,9 +216,9 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.20.0"
+version = "3.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8a64e3985349f2441a1a9ef0b853f869006c3855f2cda6862a94d26ebb9d6a1"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
  "fastrand",
  "getrandom",
@@ -311,78 +311,20 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
-name = "windows-sys"
-version = "0.59.0"
+name = "windows-link"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
-dependencies = [
- "windows-targets",
-]
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
 [[package]]
-name = "windows-targets"
-version = "0.52.6"
+name = "windows-sys"
+version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_gnullvm",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows-link",
 ]
 
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
-
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
-
 [[package]]
 name = "wit-bindgen-rt"
 version = "0.39.0"
diff --git a/compiler/rustc_codegen_gcc/Cargo.toml b/compiler/rustc_codegen_gcc/Cargo.toml
index 8956bd6948979..63a20d46b9d2f 100644
--- a/compiler/rustc_codegen_gcc/Cargo.toml
+++ b/compiler/rustc_codegen_gcc/Cargo.toml
@@ -20,7 +20,7 @@ default = ["master"]
 [dependencies]
 object = { version = "0.37.0", default-features = false, features = ["std", "read"] }
 tempfile = "3.20"
-gccjit = { version = "3.3.0", features = ["dlopen"] }
+gccjit = { version = "4.0.0", features = ["dlopen"] }
 #gccjit = { git = "https://github.com/rust-lang/gccjit.rs", branch = "error-dlopen", features = ["dlopen"] }
 
 # Local copy.
diff --git a/compiler/rustc_codegen_gcc/Readme.md b/compiler/rustc_codegen_gcc/Readme.md
index ce5ee1e4adee6..26783aa39cea8 100644
--- a/compiler/rustc_codegen_gcc/Readme.md
+++ b/compiler/rustc_codegen_gcc/Readme.md
@@ -136,19 +136,21 @@ $ ./y.sh cargo build --manifest-path tests/hello-world/Cargo.toml
 ### Cargo
 
 ```bash
-$ CHANNEL="release" $CG_GCCJIT_DIR/y.sh cargo run
+$ CHANNEL=release $CG_GCCJIT_DIR/y.sh cargo run
 ```
 
-If you compiled cg_gccjit in debug mode (aka you didn't pass `--release` to `./y.sh test`) you should use `CHANNEL="debug"` instead or omit `CHANNEL="release"` completely.
+If you compiled `cg_gcc` in debug mode (aka you didn't pass `--release` to `./y.sh build`) you should use `CHANNEL=debug` instead or omit `CHANNEL=release` completely.
 
 ### Rustc
 
 If you want to run `rustc` directly, you can do so with:
 
 ```bash
-$ ./y.sh rustc my_crate.rs
+$ CHANNEL=release ./y.sh rustc my_crate.rs
 ```
 
+If you compiled `cg_gcc` in debug mode (aka you didn't pass `--release` to `./y.sh build`) you should use `CHANNEL=debug` instead or omit `CHANNEL=release` completely.
+
 You can do the same manually (although we don't recommend it):
 
 ```bash
diff --git a/compiler/rustc_codegen_gcc/build_system/Cargo.lock b/compiler/rustc_codegen_gcc/build_system/Cargo.lock
index e727561a2bfba..5e761149eb3bc 100644
--- a/compiler/rustc_codegen_gcc/build_system/Cargo.lock
+++ b/compiler/rustc_codegen_gcc/build_system/Cargo.lock
@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "boml"
diff --git a/compiler/rustc_codegen_gcc/build_system/asm-tester/Cargo.lock b/compiler/rustc_codegen_gcc/build_system/asm-tester/Cargo.lock
new file mode 100644
index 0000000000000..9ad96acfda407
--- /dev/null
+++ b/compiler/rustc_codegen_gcc/build_system/asm-tester/Cargo.lock
@@ -0,0 +1,507 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "asm-tester"
+version = "0.1.0"
+dependencies = [
+ "compiletest_rs",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "compiletest_rs"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f150fe9105fcd2a57cad53f0c079a24de65195903ef670990f5909f695eac04c"
+dependencies = [
+ "diff",
+ "filetime",
+ "getopts",
+ "lazy_static",
+ "libc",
+ "log",
+ "miow",
+ "regex",
+ "rustfix",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "tester",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "diff"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
+
+[[package]]
+name = "dirs-next"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"
+dependencies = [
+ "cfg-if",
+ "dirs-sys-next",
+]
+
+[[package]]
+name = "dirs-sys-next"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
+dependencies = [
+ "libc",
+ "redox_users",
+ "winapi",
+]
+
+[[package]]
+name = "filetime"
+version = "0.2.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759"
+dependencies = [
+ "cfg-if",
+ "libc",
+]
+
+[[package]]
+name = "getopts"
+version = "0.2.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfe4fbac503b8d1f88e6676011885f34b7174f46e59956bba534ba83abded4df"
+dependencies = [
+ "unicode-width",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "libredox"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c943259e342f1e06ff2da7a83eabdfe7f92ce10262688dbf1895ff0b3e6e4652"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "log"
+version = "0.4.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
+
+[[package]]
+name = "memchr"
+version = "2.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
+
+[[package]]
+name = "miow"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "536bfad37a309d62069485248eeaba1e8d9853aaf951caaeaed0585a95346f08"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
+dependencies = [
+ "getrandom",
+ "libredox",
+ "thiserror",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1292b7759ae1cb9ec195452d1390a074f0cd8541ab7a5a8c31cd6db45d4a6ba"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
+
+[[package]]
+name = "rustfix"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82fa69b198d894d84e23afde8e9ab2af4400b2cba20d6bf2b428a8b01c222c5a"
+dependencies = [
+ "serde",
+ "serde_json",
+ "thiserror",
+ "tracing",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.150"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.118"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "term"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f"
+dependencies = [
+ "dirs-next",
+ "rustversion",
+ "winapi",
+]
+
+[[package]]
+name = "tester"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89e8bf7e0eb2dd7b4228cc1b6821fc5114cd6841ae59f652a85488c016091e5f"
+dependencies = [
+ "cfg-if",
+ "getopts",
+ "libc",
+ "num_cpus",
+ "term",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "pin-project-lite",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-width"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
diff --git a/compiler/rustc_codegen_gcc/build_system/asm-tester/Cargo.toml b/compiler/rustc_codegen_gcc/build_system/asm-tester/Cargo.toml
new file mode 100644
index 0000000000000..eeefe61bdc75b
--- /dev/null
+++ b/compiler/rustc_codegen_gcc/build_system/asm-tester/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "asm-tester"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+compiletest_rs = "0.11.2"
+
+[[bin]]
+name = "asm-tester"
+path = "src/main.rs"
+
+[workspace]
diff --git a/compiler/rustc_codegen_gcc/build_system/asm-tester/src/main.rs b/compiler/rustc_codegen_gcc/build_system/asm-tester/src/main.rs
new file mode 100644
index 0000000000000..00ee4ac936520
--- /dev/null
+++ b/compiler/rustc_codegen_gcc/build_system/asm-tester/src/main.rs
@@ -0,0 +1,66 @@
+use std::path::PathBuf;
+
+#[derive(Default)]
+struct Config {
+    llvm_filecheck: Option<PathBuf>,
+    filters: Vec<String>,
+    rustc_flags: Vec<String>,
+}
+
+impl Config {
+    fn new() -> Result<Self, String> {
+        // We skip the program's name.
+        let mut args = std::env::args().skip(1);
+        let mut config = Self::default();
+
+        while let Some(arg) = args.next() {
+            match arg.as_str() {
+                "--llvm-filecheck" => {
+                    config.llvm_filecheck = args.next().map(PathBuf::from);
+                }
+                "--filter" => {
+                    if let Some(arg) = args.next() {
+                        config.filters.push(arg);
+                    }
+                }
+                "--" => {
+                    config.rustc_flags.extend(&mut args);
+                    // Nothing else to be read but the `break` makes it more clear.
+                    break;
+                }
+                arg => return Err(format!("Unknown argument {arg:?}")),
+            }
+        }
+        if config.llvm_filecheck.is_none() {
+            Err("Missing `--llvm-filecheck` option".to_owned())
+        } else if config.rustc_flags.is_empty() {
+            Err("Missing rustc flags (passed after `--`)".to_owned())
+        } else {
+            Ok(config)
+        }
+    }
+}
+
+fn main() {
+    let Config { llvm_filecheck, filters, rustc_flags } = match Config::new() {
+        Ok(c) => c,
+        Err(error) => {
+            eprintln!("{error}");
+            std::process::exit(1);
+        }
+    };
+
+    let mut test_config = compiletest_rs::Config::default();
+
+    test_config.mode = compiletest_rs::common::Mode::Assembly;
+    test_config.src_base = PathBuf::from("tests/asm");
+    test_config.llvm_filecheck = llvm_filecheck;
+    test_config.filters = filters;
+    test_config.strict_headers = true;
+    test_config.build_base = PathBuf::from("build/tests/asm");
+    test_config.target_rustcflags = Some(rustc_flags.join(" "));
+    test_config.link_deps();
+    test_config.clean_rmeta();
+
+    compiletest_rs::run_tests(&test_config)
+}
diff --git a/compiler/rustc_codegen_gcc/build_system/src/build.rs b/compiler/rustc_codegen_gcc/build_system/src/build.rs
index 839c762fed742..e570a3f16c39e 100644
--- a/compiler/rustc_codegen_gcc/build_system/src/build.rs
+++ b/compiler/rustc_codegen_gcc/build_system/src/build.rs
@@ -227,7 +227,7 @@ fn build_codegen(args: &mut BuildArg) -> Result<(), String> {
     }
     run_command_with_output_and_env(&command, None, Some(&env))?;
 
-    args.config_info.setup(&mut env, false)?;
+    args.config_info.setup(&mut env, false, true)?;
 
     // We voluntarily ignore the error.
     let _ = fs::remove_dir_all("target/out");
diff --git a/compiler/rustc_codegen_gcc/build_system/src/clean.rs b/compiler/rustc_codegen_gcc/build_system/src/clean.rs
index 43f01fdf35ecb..ec2092ee92ef5 100644
--- a/compiler/rustc_codegen_gcc/build_system/src/clean.rs
+++ b/compiler/rustc_codegen_gcc/build_system/src/clean.rs
@@ -74,7 +74,8 @@ fn clean_ui_tests() -> Result<(), String> {
         let path = Path::new(crate::BUILD_DIR)
             .join("rust/build/x86_64-unknown-linux-gnu/test/")
             .join(directory);
-        run_command(&[&"find", &path, &"-name", &"stamp", &"-delete"], None)?;
+        // The directory might not exist, so ignore the error.
+        let _ = run_command(&[&"find", &path, &"-name", &"stamp", &"-delete"], None);
     }
     Ok(())
 }
diff --git a/compiler/rustc_codegen_gcc/build_system/src/clippy.rs b/compiler/rustc_codegen_gcc/build_system/src/clippy.rs
new file mode 100644
index 0000000000000..813d4b9141e1c
--- /dev/null
+++ b/compiler/rustc_codegen_gcc/build_system/src/clippy.rs
@@ -0,0 +1,62 @@
+use std::path::Path;
+
+use crate::utils::{run_command_with_output, run_tool_and_install_it_if_not_present};
+
+fn show_usage() {
+    println!(
+        r#"
+`clippy` command help:
+
+    --help  : Show this help"#
+    );
+}
+
+pub fn run() -> Result<(), String> {
+    // We skip binary name and the `info` command.
+    let args = std::env::args().skip(2);
+    #[allow(clippy::never_loop)]
+    for arg in args {
+        match arg.as_str() {
+            "--help" => {
+                show_usage();
+                return Ok(());
+            }
+            _ => return Err(format!("Unknown option {arg}")),
+        }
+    }
+
+    run_tool_and_install_it_if_not_present(&[
+        &"cargo",
+        &"clippy",
+        &"--all-targets",
+        &"--",
+        &"-D",
+        &"warnings",
+    ])?;
+    run_command_with_output(
+        &[
+            &"cargo",
+            &"clippy",
+            &"--all-targets",
+            &"--no-default-features",
+            &"--",
+            &"-D",
+            &"warnings",
+        ],
+        Some(Path::new(".")),
+    )?;
+    run_command_with_output(
+        &[
+            &"cargo",
+            &"clippy",
+            &"--all-targets",
+            &"--manifest-path",
+            &"build_system/Cargo.toml",
+            &"--",
+            &"-D",
+            &"warnings",
+        ],
+        Some(Path::new(".")),
+    )?;
+    Ok(())
+}
diff --git a/compiler/rustc_codegen_gcc/build_system/src/config.rs b/compiler/rustc_codegen_gcc/build_system/src/config.rs
index 8eb6d8f019e1c..fd78f691d1657 100644
--- a/compiler/rustc_codegen_gcc/build_system/src/config.rs
+++ b/compiler/rustc_codegen_gcc/build_system/src/config.rs
@@ -314,6 +314,7 @@ impl ConfigInfo {
         &mut self,
         env: &mut HashMap<String, String>,
         use_system_gcc: bool,
+        generate_out_dir: bool,
     ) -> Result<(), String> {
         env.insert("CARGO_INCREMENTAL".to_string(), "0".to_string());
 
@@ -444,12 +445,12 @@ impl ConfigInfo {
 
         self.rustc_command = vec![rustc];
         self.rustc_command.extend_from_slice(&rustflags);
-        self.rustc_command.extend_from_slice(&[
-            "-L".to_string(),
-            format!("crate={}", self.cargo_target_dir),
-            "--out-dir".to_string(),
-            self.cargo_target_dir.clone(),
-        ]);
+        self.rustc_command
+            .extend_from_slice(&["-L".to_string(), format!("crate={}", self.cargo_target_dir)]);
+        if generate_out_dir {
+            self.rustc_command
+                .extend_from_slice(&["--out-dir".to_string(), self.cargo_target_dir.clone()]);
+        }
 
         if !env.contains_key("RUSTC_LOG") {
             env.insert("RUSTC_LOG".to_string(), "warn".to_string());
diff --git a/compiler/rustc_codegen_gcc/build_system/src/fmt.rs b/compiler/rustc_codegen_gcc/build_system/src/fmt.rs
index 91535f217e351..dc1ca1d3e82ae 100644
--- a/compiler/rustc_codegen_gcc/build_system/src/fmt.rs
+++ b/compiler/rustc_codegen_gcc/build_system/src/fmt.rs
@@ -1,7 +1,7 @@
 use std::ffi::OsStr;
 use std::path::Path;
 
-use crate::utils::{run_command_with_output, walk_dir};
+use crate::utils::{run_command_with_output, run_tool_and_install_it_if_not_present, walk_dir};
 
 fn show_usage() {
     println!(
@@ -31,8 +31,9 @@ pub fn run() -> Result<(), String> {
     let cmd: &[&dyn AsRef<OsStr>] =
         if check { &[&"cargo", &"fmt", &"--check"] } else { &[&"cargo", &"fmt"] };
 
-    run_command_with_output(cmd, Some(Path::new(".")))?;
+    run_tool_and_install_it_if_not_present(cmd)?;
     run_command_with_output(cmd, Some(Path::new("build_system")))?;
+    run_command_with_output(cmd, Some(Path::new("build_system/asm-tester")))?;
 
     run_rustfmt_recursively("tests/run", check)
 }
diff --git a/compiler/rustc_codegen_gcc/build_system/src/main.rs b/compiler/rustc_codegen_gcc/build_system/src/main.rs
index ae975c94fff25..83f07a758d659 100644
--- a/compiler/rustc_codegen_gcc/build_system/src/main.rs
+++ b/compiler/rustc_codegen_gcc/build_system/src/main.rs
@@ -3,6 +3,7 @@ use std::{env, process};
 mod abi_test;
 mod build;
 mod clean;
+mod clippy;
 mod clone_gcc;
 mod config;
 mod fmt;
@@ -12,6 +13,7 @@ mod prepare;
 mod rust_tools;
 mod rustc_info;
 mod test;
+mod todo;
 mod utils;
 const BUILD_DIR: &str = "build";
 
@@ -24,43 +26,67 @@ macro_rules! arg_error {
     }};
 }
 
-fn usage() {
-    println!(
-        "\
+macro_rules! commands_decl {
+    ($($variant:ident: $doc_name:literal => $doc:literal ,)+) => {
+        enum Command {
+            $($variant),+
+        }
+
+        impl<'a> From<Option<&'a str>> for Command {
+            fn from(arg: Option<&'a str>) -> Self {
+                match arg {
+                    $(Some($doc_name) => Self::$variant,)+
+                    Some("--help") => {
+                        usage();
+                        process::exit(0);
+                    }
+                    Some(flag) if flag.starts_with('-') => arg_error!("Expected command found flag {}", flag),
+                    Some(command) => arg_error!("Unknown command {}", command),
+                    None => {
+                        usage();
+                        process::exit(0);
+                    }
+                }
+            }
+        }
+
+        fn usage() {
+            println!("\
 rustc_codegen_gcc build system
 
 Usage: build_system [command] [options]
 
 Options:
-        --help    : Displays this help message.
+    --help     : Displays this help message.
+
+Commands:",
+            );
+            let mut commands = vec![$(($doc_name, $doc),)+];
+            let longest = commands.iter().map(|(name, _)| name.len()).max().unwrap();
 
-Commands:
-        cargo     : Executes a cargo command.
-        rustc     : Compiles the program using the GCC compiler.
-        clean     : Cleans the build directory, removing all compiled files and artifacts.
-        prepare   : Prepares the environment for building, including fetching dependencies and setting up configurations.
-        build     : Compiles the project.
-        test      : Runs tests for the project.
-        info      : Displays information about the build environment and project configuration.
-        clone-gcc : Clones the GCC compiler from a specified source.
-        fmt       : Runs rustfmt
-        fuzz      : Fuzzes `cg_gcc` using rustlantis
-        abi-test   : Runs the abi-cafe test suite on the codegen, checking for ABI compatibility with LLVM"
-    );
+            commands.sort_unstable_by(|a, b| a.0.cmp(b.0));
+            for (name, doc) in commands {
+                let spacing = std::iter::repeat(' ').take(longest - name.len() + 1).collect::<String>();
+                eprintln!("    {name}{spacing}: {doc}.");
+            }
+        }
+    }
 }
 
-pub enum Command {
-    Cargo,
-    Clean,
-    CloneGcc,
-    Prepare,
-    Build,
-    Rustc,
-    Test,
-    Info,
-    Fmt,
-    Fuzz,
-    AbiTest,
+commands_decl! {
+    Cargo: "cargo" => "Executes a cargo command",
+    Clean: "clean" => "Cleans the build directory, removing all compiled files and artifacts",
+    Clippy: "clippy" => "Runs clippy",
+    CloneGcc: "clone-gcc" => "Clones the GCC compiler from a specified source",
+    Prepare: "prepare" => "Prepares the environment for building, including fetching dependencies and setting up configurations",
+    Build: "build" => "Compiles the project",
+    Rustc: "rustc" => "Compiles the program using the GCC compiler",
+    Test: "test" => "Runs tests for the project",
+    Info: "info" => "Displays information about the build environment and project configuration",
+    Fmt: "fmt" => "Runs rustfmt",
+    Fuzz: "fuzz" => "Fuzzes `cg_gcc` using `rustlantis`",
+    AbiTest: "abi-test" => "Runs the abi-cafe test suite on the codegen, checking for ABI compatibility with LLVM",
+    CheckTodo: "check-todo" => "Checks todo in the project",
 }
 
 fn main() {
@@ -70,31 +96,7 @@ fn main() {
         }
     }
 
-    let command = match env::args().nth(1).as_deref() {
-        Some("cargo") => Command::Cargo,
-        Some("rustc") => Command::Rustc,
-        Some("clean") => Command::Clean,
-        Some("prepare") => Command::Prepare,
-        Some("build") => Command::Build,
-        Some("test") => Command::Test,
-        Some("info") => Command::Info,
-        Some("clone-gcc") => Command::CloneGcc,
-        Some("abi-test") => Command::AbiTest,
-        Some("fmt") => Command::Fmt,
-        Some("fuzz") => Command::Fuzz,
-        Some("--help") => {
-            usage();
-            process::exit(0);
-        }
-        Some(flag) if flag.starts_with('-') => arg_error!("Expected command found flag {}", flag),
-        Some(command) => arg_error!("Unknown command {}", command),
-        None => {
-            usage();
-            process::exit(0);
-        }
-    };
-
-    if let Err(e) = match command {
+    if let Err(e) = match Command::from(env::args().nth(1).as_deref()) {
         Command::Cargo => rust_tools::run_cargo(),
         Command::Rustc => rust_tools::run_rustc(),
         Command::Clean => clean::run(),
@@ -106,6 +108,8 @@ fn main() {
         Command::Fmt => fmt::run(),
         Command::Fuzz => fuzz::run(),
         Command::AbiTest => abi_test::run(),
+        Command::Clippy => clippy::run(),
+        Command::CheckTodo => todo::run(),
     } {
         eprintln!("Command failed to run: {e}");
         process::exit(1);
diff --git a/compiler/rustc_codegen_gcc/build_system/src/rust_tools.rs b/compiler/rustc_codegen_gcc/build_system/src/rust_tools.rs
index b1faa27acc4a2..1b50f11c3d324 100644
--- a/compiler/rustc_codegen_gcc/build_system/src/rust_tools.rs
+++ b/compiler/rustc_codegen_gcc/build_system/src/rust_tools.rs
@@ -72,7 +72,7 @@ impl RustcTools {
 
         let mut env: HashMap<String, String> = std::env::vars().collect();
         let mut config = ConfigInfo::default();
-        config.setup(&mut env, false)?;
+        config.setup(&mut env, false, false)?;
         let toolchain = get_toolchain()?;
 
         let toolchain_version = rustc_toolchain_version_info(&toolchain)?;
diff --git a/compiler/rustc_codegen_gcc/build_system/src/test.rs b/compiler/rustc_codegen_gcc/build_system/src/test.rs
index 2475a3a6a7155..6cc2282c8022f 100644
--- a/compiler/rustc_codegen_gcc/build_system/src/test.rs
+++ b/compiler/rustc_codegen_gcc/build_system/src/test.rs
@@ -9,8 +9,8 @@ use crate::build;
 use crate::config::{Channel, ConfigInfo};
 use crate::utils::{
     create_dir, get_sysroot_dir, get_toolchain, git_clone, git_clone_root_dir, remove_file,
-    run_command, run_command_with_env, run_command_with_output_and_env, rustc_version_info,
-    split_args, walk_dir,
+    run_command, run_command_with_env, run_command_with_output_and_env,
+    run_command_with_output_and_env_no_err, rustc_version_info, split_args, walk_dir,
 };
 
 type Env = HashMap<String, String>;
@@ -28,8 +28,10 @@ fn get_runners() -> Runners {
         ("Run failing ui pattern tests", test_failing_ui_pattern_tests),
     );
     runners.insert("--test-failing-rustc", ("Run failing rustc tests", test_failing_rustc));
+    runners.insert("--run-ui-tests", ("Run specified rustc UI tests", run_ui_tests));
     runners.insert("--projects", ("Run the tests of popular crates", test_projects));
     runners.insert("--test-libcore", ("Run libcore tests", test_libcore));
+    runners.insert("--alloc-tests", ("Run alloc tests", test_alloc));
     runners.insert("--clean", ("Empty cargo target directory", clean));
     runners.insert("--build-sysroot", ("Build sysroot", build_sysroot));
     runners.insert("--std-tests", ("Run std tests", std_tests));
@@ -42,8 +44,10 @@ fn get_runners() -> Runners {
     );
     runners.insert("--extended-regex-tests", ("Run extended regex tests", extended_regex_tests));
     runners.insert("--mini-tests", ("Run mini tests", mini_tests));
+    runners.insert("--gcc-asm-tests", ("Run cg_gcc asm tests", test_asm));
     runners.insert("--cargo-tests", ("Run cargo tests", cargo_tests));
     runners.insert("--no-builtins-tests", ("Test #![no_builtins] attribute", no_builtins_tests));
+    runners.insert("--stdarch-tests", ("Run stdarch tests", test_stdarch as Runner));
     runners
 }
 
@@ -505,6 +509,26 @@ fn std_tests(env: &Env, args: &TestArg) -> Result<(), String> {
     Ok(())
 }
 
+fn get_llvm_filecheck(env: &Env) -> Result<String, String> {
+    match run_command_with_env(
+        &[
+            &"bash",
+            &"-c",
+            &"which FileCheck-10 || \
+          which FileCheck-11 || \
+          which FileCheck-12 || \
+          which FileCheck-13 || \
+          which FileCheck-14 || \
+          which FileCheck",
+        ],
+        None,
+        Some(env),
+    ) {
+        Ok(cmd) => Ok(String::from_utf8_lossy(&cmd.stdout).trim().to_string()),
+        Err(_) => Err("Failed to retrieve LLVM FileCheck, ignoring...".to_owned()),
+    }
+}
+
 fn setup_rustc(env: &mut Env, args: &TestArg) -> Result<PathBuf, String> {
     let toolchain = format!(
         "+{channel}-{host}",
@@ -548,23 +572,10 @@ fn setup_rustc(env: &mut Env, args: &TestArg) -> Result<PathBuf, String> {
         let rustc = rustc.trim().to_owned();
         if rustc.is_empty() { Err("`rustc` path is empty".to_string()) } else { Ok(rustc) }
     })?;
-    let llvm_filecheck = match run_command_with_env(
-        &[
-            &"bash",
-            &"-c",
-            &"which FileCheck-10 || \
-          which FileCheck-11 || \
-          which FileCheck-12 || \
-          which FileCheck-13 || \
-          which FileCheck-14 || \
-          which FileCheck",
-        ],
-        rust_dir,
-        Some(env),
-    ) {
-        Ok(cmd) => String::from_utf8_lossy(&cmd.stdout).to_string(),
-        Err(_) => {
-            eprintln!("Failed to retrieve LLVM FileCheck, ignoring...");
+    let llvm_filecheck = match get_llvm_filecheck(env) {
+        Ok(l) => l,
+        Err(error) => {
+            eprintln!("{error}");
             // FIXME: the test tests/run-make/no-builtins-attribute will fail if we cannot find
             // FileCheck.
             String::new()
@@ -634,7 +645,7 @@ fn asm_tests(env: &Env, args: &TestArg) -> Result<(), String> {
             &"0",
             &"--set",
             &"build.compiletest-allow-stage0=true",
-            &"tests/assembly-llvm/asm",
+            &"tests/assembly-gcc/asm",
             &"--compiletest-rustc-args",
             &rustc_args,
         ],
@@ -764,6 +775,39 @@ fn test_libcore(env: &Env, args: &TestArg) -> Result<(), String> {
     Ok(())
 }
 
+fn test_stdarch(env: &Env, args: &TestArg) -> Result<(), String> {
+    println!("[TEST] stdarch");
+    let manifest_path = get_sysroot_dir().join("sysroot_src/library/stdarch/Cargo.toml");
+    let mut env = env.clone();
+
+    // `config.setup` already baked `CG_RUSTFLAGS` into `RUSTFLAGS`, so append the lint-allow to
+    // `RUSTFLAGS` directly (which `run_cargo_command` also propagates to `RUSTDOCFLAGS`).
+    let rustflags = env.get("RUSTFLAGS").cloned().unwrap_or_default();
+    env.insert(
+        "RUSTFLAGS".to_string(),
+        format!("{rustflags} -Ainternal_features").trim().to_owned(),
+    );
+    env.insert("TARGET".to_string(), args.config_info.target_triple.clone());
+
+    let mut command: Vec<&dyn AsRef<OsStr>> =
+        vec![&"test", &"--manifest-path", &manifest_path, &"--"];
+    for test_name in &args.test_args {
+        command.push(test_name);
+    }
+    run_cargo_command(&command, None, &env, args)?;
+    Ok(())
+}
+
+fn test_alloc(env: &Env, args: &TestArg) -> Result<(), String> {
+    // FIXME: create a function "display_if_not_quiet" or something along the line.
+    println!("[TEST] alloc");
+    let path = get_sysroot_dir().join("sysroot_src/library/alloctests");
+    let _ = remove_dir_all(path.join("target"));
+    // FIXME(antoyo): run in release mode when we fix the failures.
+    run_cargo_command(&[&"test"], Some(&path), env, args)?;
+    Ok(())
+}
+
 fn extended_rand_tests(env: &Env, args: &TestArg) -> Result<(), String> {
     if !args.is_using_gcc_master_branch() {
         println!("Not using GCC master branch. Skipping `extended_rand_tests`.");
@@ -908,7 +952,6 @@ fn contains_ui_error_patterns(file_path: &Path, keep_lto_tests: bool) -> Result<
             "//@ known-bug",
             "-Cllvm-args",
             "//~",
-            "thread",
         ]
         .iter()
         .any(|check| line.contains(check))
@@ -985,21 +1028,6 @@ where
                 true,
             )?;
         } else {
-            walk_dir(
-                rust_path.join("tests/ui"),
-                &mut |dir| {
-                    let dir_name = dir.file_name().and_then(|name| name.to_str()).unwrap_or("");
-                    if ["abi", "extern", "proc-macro", "threads-sendsync"].contains(&dir_name) {
-                        remove_dir_all(dir).map_err(|error| {
-                            format!("Failed to remove folder `{}`: {:?}", dir.display(), error)
-                        })?;
-                    }
-                    Ok(())
-                },
-                &mut |_| Ok(()),
-                false,
-            )?;
-
             // These two functions are used to remove files that are known to not be working currently
             // with the GCC backend to reduce noise.
             fn dir_handling(keep_lto_tests: bool) -> impl Fn(&Path) -> Result<(), String> {
@@ -1196,6 +1224,46 @@ fn test_failing_ui_pattern_tests(env: &Env, args: &TestArg) -> Result<(), String
     )
 }
 
+fn run_ui_tests(env: &Env, args: &TestArg) -> Result<(), String> {
+    let mut env = env.clone();
+    let rust_path = setup_rustc(&mut env, args)?;
+
+    let extra =
+        if args.is_using_gcc_master_branch() { "" } else { " -Csymbol-mangling-version=v0" };
+
+    let rustc_args = format!(
+        "{test_flags} -Zcodegen-backend={backend} --sysroot {sysroot}{extra}",
+        test_flags = env.get("TEST_FLAGS").unwrap_or(&String::new()),
+        backend = args.config_info.cg_backend_path,
+        sysroot = args.config_info.sysroot_path,
+        extra = extra,
+    );
+
+    env.get_mut("RUSTFLAGS").unwrap().clear();
+
+    let mut command: Vec<&dyn AsRef<OsStr>> = vec![
+        &"./x.py",
+        &"test",
+        &"--run",
+        &"always",
+        &"--stage",
+        &"0",
+        &"--set",
+        &"build.compiletest-allow-stage0=true",
+        &"--compiletest-rustc-args",
+        &rustc_args,
+        &"--bypass-ignore-backends",
+        &"--force-rerun",
+    ];
+
+    for test_name in &args.test_args {
+        command.push(test_name);
+    }
+
+    run_command_with_output_and_env(&command, Some(&rust_path), Some(&env))?;
+    Ok(())
+}
+
 fn retain_files_callback<'a>(
     file_path: &'a str,
     test_type: &'a str,
@@ -1297,6 +1365,60 @@ fn remove_files_callback<'a>(
     }
 }
 
+fn test_asm(env: &Env, args: &TestArg) -> Result<(), String> {
+    fn is_path_time_more_recent(ref_time: std::time::SystemTime, path: &str) -> bool {
+        std::fs::metadata(path)
+            .and_then(|metadata| metadata.modified())
+            .is_ok_and(|time| ref_time < time)
+    }
+
+    // FIXME: create a function "display_if_not_quiet" or something along the line.
+    println!("[TEST] cg_gcc assembly");
+    let llvm_filecheck = get_llvm_filecheck(env)?;
+
+    let target_dir = std::env::current_dir().unwrap().join("build_system/asm-tester/target");
+
+    // All this code is because `cargo` keeps recompiling this file, and we can't figure out why.
+    let binary_file_path = "build_system/asm-tester/target/debug/asm-tester";
+    let mut need_recompilation = true;
+    if let Ok(metadata) = std::fs::metadata(binary_file_path)
+        && let Ok(ref_time) = metadata.modified()
+        && !is_path_time_more_recent(ref_time, "build_system/asm-tester/Cargo.toml")
+        && !is_path_time_more_recent(ref_time, "build_system/asm-tester/Cargo.lock")
+        && !is_path_time_more_recent(ref_time, "build_system/asm-tester/src/main.rs")
+    {
+        need_recompilation = false;
+    }
+
+    if need_recompilation {
+        let build_asm_args: Vec<&dyn AsRef<OsStr>> = vec![
+            &"cargo",
+            &"build",
+            &"--manifest-path",
+            &"build_system/asm-tester/Cargo.toml",
+            &"--target-dir",
+            &target_dir,
+            &"--",
+        ];
+        run_command_with_output_and_env_no_err(&build_asm_args, Some(Path::new(".")), Some(env))?;
+    }
+
+    let mut test_asm_args: Vec<&dyn AsRef<OsStr>> = vec![
+        &"build_system/asm-tester/target/debug/asm-tester",
+        &"--llvm-filecheck",
+        &llvm_filecheck,
+    ];
+    for test_arg in &args.test_args {
+        test_asm_args.push(&"--filter");
+        test_asm_args.push(test_arg);
+    }
+    test_asm_args.push(&"--");
+    for arg in args.config_info.rustc_command_vec().into_iter().skip(1) {
+        test_asm_args.push(arg);
+    }
+    run_command_with_output_and_env_no_err(&test_asm_args, Some(Path::new(".")), Some(env))
+}
+
 fn run_all(env: &Env, args: &TestArg) -> Result<(), String> {
     clean(env, args)?;
     mini_tests(env, args)?;
@@ -1308,6 +1430,7 @@ fn run_all(env: &Env, args: &TestArg) -> Result<(), String> {
     cargo_tests(env, args)?;
     no_builtins_tests(env, args)?;
     test_rustc(env, args)?;
+    test_asm(env, args)?;
 
     Ok(())
 }
@@ -1329,7 +1452,7 @@ pub fn run() -> Result<(), String> {
         return Ok(());
     }
 
-    args.config_info.setup(&mut env, args.use_system_gcc)?;
+    args.config_info.setup(&mut env, args.use_system_gcc, true)?;
 
     if args.runners.is_empty() {
         run_all(&env, &args)?;
diff --git a/compiler/rustc_codegen_gcc/build_system/src/todo.rs b/compiler/rustc_codegen_gcc/build_system/src/todo.rs
new file mode 100644
index 0000000000000..5b89410844788
--- /dev/null
+++ b/compiler/rustc_codegen_gcc/build_system/src/todo.rs
@@ -0,0 +1,72 @@
+use std::ffi::OsStr;
+use std::fs::File;
+use std::io::{BufRead, BufReader};
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+const EXTENSIONS: &[&str] =
+    &["rs", "py", "js", "sh", "c", "cpp", "h", "md", "css", "ftl", "toml", "yml", "yaml"];
+
+fn has_supported_extension(path: &Path) -> bool {
+    path.extension().is_some_and(|ext| EXTENSIONS.iter().any(|e| ext == OsStr::new(e)))
+}
+
+fn list_tracked_files() -> Result<Vec<PathBuf>, String> {
+    let output = Command::new("git")
+        .args(["ls-files", "-z"])
+        .output()
+        .map_err(|e| format!("Failed to run `git ls-files`: {e}"))?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(format!("`git ls-files` failed: {stderr}"));
+    }
+
+    let mut files = Vec::new();
+    for entry in output.stdout.split(|b| *b == 0) {
+        if entry.is_empty() {
+            continue;
+        }
+        let path = std::str::from_utf8(entry).unwrap();
+        files.push(PathBuf::from(path));
+    }
+
+    Ok(files)
+}
+
+pub(crate) fn run() -> Result<(), String> {
+    let files = list_tracked_files()?;
+    let mut error_count = 0;
+    // Avoid embedding the task marker in source so greps only find real occurrences.
+    let todo_marker = "todo".to_ascii_uppercase();
+
+    for file in files {
+        if !has_supported_extension(&file) {
+            continue;
+        }
+
+        let file_handle =
+            File::open(&file).map_err(|e| format!("Failed to open {}: {e}", file.display()))?;
+        let reader = BufReader::new(file_handle);
+
+        for (i, line) in reader.lines().enumerate() {
+            let line = line.map_err(|e| format!("Failed to read {}: {e}", file.display()))?;
+            let trimmed = line.trim();
+            if trimmed.contains(&todo_marker) {
+                eprintln!(
+                    "{}:{}: {} is used for tasks that should be done before merging a PR; if you want to leave a message in the codebase use FIXME",
+                    file.display(),
+                    i + 1,
+                    todo_marker
+                );
+                error_count += 1;
+            }
+        }
+    }
+
+    if error_count == 0 {
+        return Ok(());
+    }
+
+    Err(format!("found {} {}(s)", error_count, todo_marker))
+}
diff --git a/compiler/rustc_codegen_gcc/build_system/src/utils.rs b/compiler/rustc_codegen_gcc/build_system/src/utils.rs
index 112322f8688c1..4c67156a85fb2 100644
--- a/compiler/rustc_codegen_gcc/build_system/src/utils.rs
+++ b/compiler/rustc_codegen_gcc/build_system/src/utils.rs
@@ -2,10 +2,11 @@ use std::collections::HashMap;
 use std::ffi::OsStr;
 use std::fmt::Debug;
 use std::fs;
+use std::io::{BufReader, Read};
 #[cfg(unix)]
 use std::os::unix::process::ExitStatusExt;
 use std::path::{Path, PathBuf};
-use std::process::{Command, ExitStatus, Output};
+use std::process::{Command, ExitStatus, Output, Stdio};
 
 fn exec_command(
     input: &[&dyn AsRef<OsStr>],
@@ -47,7 +48,7 @@ pub(crate) fn get_command_inner(
     command
 }
 
-fn check_exit_status(
+pub(crate) fn check_exit_status(
     input: &[&dyn AsRef<OsStr>],
     cwd: Option<&Path>,
     exit_status: ExitStatus,
@@ -115,6 +116,30 @@ pub fn run_command_with_output(
     check_exit_status(input, cwd, exit_status, None, true)
 }
 
+pub fn run_command_with_output_and_get_it(
+    input: &[&dyn AsRef<OsStr>],
+    cwd: Option<&Path>,
+) -> Result<(ExitStatus, String), String> {
+    let mut child = get_command_inner(input, cwd, None)
+        .stderr(Stdio::piped())
+        .spawn()
+        .map_err(|e| command_error(input, &cwd, e))?;
+
+    let stderr = child.stderr.take().expect("Failed to capture stderr");
+    let mut captured = String::new();
+    BufReader::new(stderr).read_to_string(&mut captured).expect("failed to read stderr");
+
+    let status = child.wait().map_err(|e| command_error(input, &cwd, e))?;
+    #[cfg(unix)]
+    {
+        if let Some(signal) = status.signal() {
+            // In case the signal didn't kill the current process.
+            return Err(command_error(input, &cwd, format!("Process received signal {signal}")));
+        }
+    }
+    Ok((status, captured))
+}
+
 pub fn run_command_with_output_and_env(
     input: &[&dyn AsRef<OsStr>],
     cwd: Option<&Path>,
@@ -124,7 +149,6 @@ pub fn run_command_with_output_and_env(
     check_exit_status(input, cwd, exit_status, None, true)
 }
 
-#[cfg(not(unix))]
 pub fn run_command_with_output_and_env_no_err(
     input: &[&dyn AsRef<OsStr>],
     cwd: Option<&Path>,
@@ -419,6 +443,34 @@ pub fn get_sysroot_dir() -> PathBuf {
     Path::new(crate::BUILD_DIR).join("build_sysroot")
 }
 
+pub fn run_tool_and_install_it_if_not_present(cmd: &[&dyn AsRef<OsStr>]) -> Result<(), String> {
+    let (exit_status, stderr) = run_command_with_output_and_get_it(cmd, Some(Path::new(".")))?;
+    if exit_status.success() {
+        return Ok(());
+    }
+    let mut iter = stderr.split('\n');
+    if let Some(line) = iter.next()
+        && line.contains("is not installed for the toolchain")
+        && let Some(line) = iter.next()
+        && line.contains("run `rustup component add")
+        && let Some(cmd) = line.split('`').nth(1)
+        && let Some(tool_name) = cmd.rsplit(' ').next()
+    {
+        println!("`{tool_name}` is not installed for this toolchain, installing it...");
+        // A weird round-about way to get a `&&str` so I can get a `&dyn AsRef<OsStr>` but
+        // as long as it works...
+        let cmd = cmd.split(' ').collect::<Vec<_>>();
+        let cmd = cmd.iter().map(|s: &&str| s as &dyn AsRef<OsStr>).collect::<Vec<_>>();
+        run_command_with_output(cmd.as_slice(), Some(Path::new(".")))?;
+    } else {
+        // If the component is installed, then it's something else. In this case we fail like we
+        // should have and let the user handles the error.
+        return check_exit_status(cmd, Some(Path::new(".")), exit_status, None, true);
+    }
+    // We retry the command...
+    run_command_with_output(cmd, Some(Path::new(".")))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/compiler/rustc_codegen_gcc/doc/subtree.md b/compiler/rustc_codegen_gcc/doc/subtree.md
index a81b6c9c74bdd..fcac399e46542 100644
--- a/compiler/rustc_codegen_gcc/doc/subtree.md
+++ b/compiler/rustc_codegen_gcc/doc/subtree.md
@@ -1,7 +1,7 @@
 # git subtree sync
 
 `rustc_codegen_gcc` is a subtree of the rust compiler. As such, it needs to be
-sync from time to time to ensure changes that happened on their side are also
+synced from time to time to ensure changes that happened on their side are also
 included on our side.
 
 ### How to install a forked git-subtree
@@ -41,6 +41,8 @@ cd ../rust
 git pull origin master
 git checkout -b subtree-update_cg_gcc_YYYY-MM-DD
 PATH="$HOME/bin:$PATH" ~/bin/git-subtree pull --prefix=compiler/rustc_codegen_gcc/ https://github.com/rust-lang/rustc_codegen_gcc.git master
+# Don't forget to update the `gcc` submodule to the same version as the
+# one in `rustc_codegen_gcc/libgccjit.version`.
 git push
 
 # Immediately merge the merge commit into cg_gcc to prevent merge conflicts when syncing from rust-lang/rust later.
diff --git a/compiler/rustc_codegen_gcc/libgccjit.version b/compiler/rustc_codegen_gcc/libgccjit.version
index 5eef70260466f..7c141c20c4d3d 100644
--- a/compiler/rustc_codegen_gcc/libgccjit.version
+++ b/compiler/rustc_codegen_gcc/libgccjit.version
@@ -1 +1 @@
-6f155cc3f5a2dff33afe6cc3ed6c2e0e605ae6a3
+dfbee712e611693596ffec1de22177089c537491
diff --git a/compiler/rustc_codegen_gcc/patches/0001-Add-stdarch-Cargo.toml-for-testing.patch b/compiler/rustc_codegen_gcc/patches/0001-Add-stdarch-Cargo.toml-for-testing.patch
deleted file mode 100644
index 3a8c37a8b8d9a..0000000000000
--- a/compiler/rustc_codegen_gcc/patches/0001-Add-stdarch-Cargo.toml-for-testing.patch
+++ /dev/null
@@ -1,39 +0,0 @@
-From 190e26c9274b3c93a9ee3516b395590e6bd9213b Mon Sep 17 00:00:00 2001
-From: None <none@example.com>
-Date: Sun, 3 Aug 2025 19:54:56 -0400
-Subject: [PATCH] Patch 0001-Add-stdarch-Cargo.toml-for-testing.patch
-
----
- library/stdarch/Cargo.toml | 20 ++++++++++++++++++++
- 1 file changed, 20 insertions(+)
- create mode 100644 library/stdarch/Cargo.toml
-
-diff --git a/library/stdarch/Cargo.toml b/library/stdarch/Cargo.toml
-new file mode 100644
-index 0000000..bd6725c
---- /dev/null
-+++ b/library/stdarch/Cargo.toml
-@@ -0,0 +1,20 @@
-+[workspace]
-+resolver = "1"
-+members = [
-+  "crates/*",
-+  #"examples/"
-+]
-+exclude = [
-+  "crates/wasm-assert-instr-tests",
-+  "rust_programs",
-+]
-+
-+[profile.release]
-+debug = true
-+opt-level = 3
-+incremental = true
-+
-+[profile.bench]
-+debug = 1
-+opt-level = 3
-+incremental = true
--- 
-2.50.1
-
diff --git a/compiler/rustc_codegen_gcc/rust-toolchain b/compiler/rustc_codegen_gcc/rust-toolchain
index 56fcfdff1c719..104992b5da46b 100644
--- a/compiler/rustc_codegen_gcc/rust-toolchain
+++ b/compiler/rustc_codegen_gcc/rust-toolchain
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2026-04-29"
+channel = "nightly-2026-07-24"
 components = ["rust-src", "rustc-dev", "llvm-tools-preview"]
diff --git a/compiler/rustc_codegen_gcc/src/abi.rs b/compiler/rustc_codegen_gcc/src/abi.rs
index 1b7bb8c907735..45fc5e3c4f619 100644
--- a/compiler/rustc_codegen_gcc/src/abi.rs
+++ b/compiler/rustc_codegen_gcc/src/abi.rs
@@ -146,12 +146,23 @@ impl<'gcc, 'tcx> FnAbiGccExt<'gcc, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
             if attrs.regular.contains(rustc_target::callconv::ArgAttribute::NonNull) {
                 non_null_args.push(arg_index as i32 + 1);
             }
+            // There are a few others `ArgAttribute` variants"
+            //
+            // * ArgAttribute::ReadOnly: `access(read_only())`, but it's only used for emitting
+            //   warning, not for optimization.
+            // * ArgAttribute::NoUndef: No equivalent in GCC
+            // * ArgAttribute::Writable: `access(read_write())` or `access(write_only())`, but it's
+            //   only used for emitting warning, not for optimization.
+            // * ArgAttribute::NoFree: No equivalent in GCC
             ty
         };
         #[cfg(not(feature = "master"))]
         let apply_attrs = |ty: Type<'gcc>, _attrs: &ArgAttributes, _arg_index: usize| ty;
 
-        for arg in self.args.iter() {
+        for (source_arg_index, arg) in self.args.iter().enumerate() {
+            #[cfg(not(feature = "master"))]
+            let _ = source_arg_index;
+
             let arg_ty = match arg.mode {
                 PassMode::Ignore => continue,
                 PassMode::Pair(a, b) => {
@@ -177,9 +188,31 @@ impl<'gcc, 'tcx> FnAbiGccExt<'gcc, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
                     apply_attrs(ty, &cast.attrs, argument_tys.len())
                 }
                 PassMode::Indirect { attrs: _, meta_attrs: None, on_stack: true } => {
-                    // This is a "byval" argument, so we don't apply the `restrict` attribute on it.
-                    on_stack_param_indices.insert(argument_tys.len());
-                    arg.layout.gcc_type(cx)
+                    let x86_interrupt_first_arg = {
+                        #[cfg(feature = "master")]
+                        {
+                            source_arg_index == 0
+                                && matches!(self.conv, CanonAbi::Interrupt(InterruptKind::X86))
+                        }
+                        #[cfg(not(feature = "master"))]
+                        {
+                            false
+                        }
+                    };
+
+                    if x86_interrupt_first_arg {
+                        // Rust lowers the first `x86-interrupt` argument as a byval stack slot.
+                        // LLVM represents that as a pointer parameter with `byval`; GCC's
+                        // interrupt attribute likewise requires a pointer-shaped first parameter.
+                        // Do not add this parameter to `on_stack_param_indices`: that set is only
+                        // needed when GCC represents a byval argument as a value parameter, while
+                        // this parameter is already pointer-shaped.
+                        cx.type_ptr_to(arg.layout.gcc_type(cx))
+                    } else {
+                        // This is a "byval" argument, so we don't apply the `restrict` attribute on it.
+                        on_stack_param_indices.insert(argument_tys.len());
+                        arg.layout.gcc_type(cx)
+                    }
                 }
                 PassMode::Direct(attrs) => {
                     apply_attrs(arg.layout.immediate_gcc_type(cx), &attrs, argument_tys.len())
diff --git a/compiler/rustc_codegen_gcc/src/asm.rs b/compiler/rustc_codegen_gcc/src/asm.rs
index ee0cef350b42f..a1d227157314b 100644
--- a/compiler/rustc_codegen_gcc/src/asm.rs
+++ b/compiler/rustc_codegen_gcc/src/asm.rs
@@ -298,7 +298,9 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                         out_place,
                     });
 
-                    if !readwrite {
+                    if readwrite {
+                        self.llbb().add_assignment(None, tmp_var, in_value.immediate());
+                    } else {
                         let out_gcc_idx = outputs.len() - 1;
                         let constraint = Cow::Owned(out_gcc_idx.to_string());
 
@@ -364,7 +366,14 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                         let ty = value.layout.gcc_type(self.cx);
                         let reg_var = self.current_func().new_local(None, ty, "input_register");
                         reg_var.set_register_name(reg_name);
-                        self.llbb().add_assignment(None, reg_var, value.immediate());
+                        // FIXME: We should remove this when switching to "untyped" pointers
+                        let value = value.immediate();
+                        let value = if value.get_type() != ty {
+                            self.context.new_cast(None, value, ty)
+                        } else {
+                            value
+                        };
+                        self.llbb().add_assignment(None, reg_var, value);
 
                         inputs.push(AsmInOperand {
                             constraint: "r".into(),
@@ -603,6 +612,12 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
             self.llbb().add_eval(None, self.context.new_call(None, builtin_unreachable, &[]));
         }
 
+        if !options.contains(InlineAsmOptions::NORETURN)
+            && let Some(dest) = dest
+        {
+            self.switch_to_block(dest);
+        }
+
         // Write results to outputs.
         //
         // We need to do this because:
diff --git a/compiler/rustc_codegen_gcc/src/attributes.rs b/compiler/rustc_codegen_gcc/src/attributes.rs
index ce1877b308e94..95d12480efa69 100644
--- a/compiler/rustc_codegen_gcc/src/attributes.rs
+++ b/compiler/rustc_codegen_gcc/src/attributes.rs
@@ -2,6 +2,8 @@
 use gccjit::FnAttribute;
 use gccjit::Function;
 #[cfg(feature = "master")]
+use rustc_abi::{CanonAbi, InterruptKind};
+#[cfg(feature = "master")]
 use rustc_hir::attrs::InlineAttr;
 use rustc_hir::attrs::InstructionSetAttr;
 #[cfg(feature = "master")]
@@ -9,6 +11,7 @@ use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 #[cfg(feature = "master")]
 use rustc_middle::mir::TerminatorKind;
 use rustc_middle::ty;
+use rustc_target::callconv::FnAbi;
 #[cfg(feature = "master")]
 use rustc_target::spec::Arch;
 
@@ -82,12 +85,23 @@ fn inline_attr<'gcc, 'tcx>(
     }
 }
 
+#[cfg(feature = "master")]
+fn is_x86_interrupt<'tcx>(fn_abi: Option<&FnAbi<'tcx, ty::Ty<'tcx>>>) -> bool {
+    matches!(
+        fn_abi,
+        Some(fn_abi) if matches!(fn_abi.conv, CanonAbi::Interrupt(InterruptKind::X86))
+    )
+}
+
 /// Composite function which sets GCC attributes for function depending on its AST (`#[attribute]`)
 /// attributes.
 pub fn from_fn_attrs<'gcc, 'tcx>(
     cx: &CodegenCx<'gcc, 'tcx>,
     #[cfg_attr(not(feature = "master"), expect(unused_variables))] func: Function<'gcc>,
     instance: ty::Instance<'tcx>,
+    #[cfg_attr(not(feature = "master"), expect(unused_variables))] fn_abi: Option<
+        &FnAbi<'tcx, ty::Ty<'tcx>>,
+    >,
 ) {
     let codegen_fn_attrs = cx.tcx.codegen_instance_attrs(instance.def);
 
@@ -120,6 +134,11 @@ pub fn from_fn_attrs<'gcc, 'tcx>(
         }
     }
 
+    #[cfg(feature = "master")]
+    let x86_interrupt = is_x86_interrupt(fn_abi);
+    #[cfg(not(feature = "master"))]
+    let x86_interrupt = false;
+
     let mut function_features = codegen_fn_attrs
         .target_features
         .iter()
@@ -135,6 +154,13 @@ pub fn from_fn_attrs<'gcc, 'tcx>(
     // Check if GCC requires the same.
     let mut global_features = cx.tcx.global_backend_features(()).iter().map(|s| s.as_str());
     function_features.extend(&mut global_features);
+    if x86_interrupt {
+        // GCC does not preserve SSE, MMX, or x87 state in interrupt handlers and rejects
+        // them whenever those instruction sets are enabled, even if the handler does not
+        // emit such instructions. Restrict the function to general registers so the
+        // interrupt attribute works with the default x86_64 target features.
+        function_features.push("general-regs-only");
+    }
     let target_features = function_features
         .iter()
         .filter_map(|feature| {
diff --git a/compiler/rustc_codegen_gcc/src/back/lto.rs b/compiler/rustc_codegen_gcc/src/back/lto.rs
index 98f9abdb05c4c..baf1fda02e258 100644
--- a/compiler/rustc_codegen_gcc/src/back/lto.rs
+++ b/compiler/rustc_codegen_gcc/src/back/lto.rs
@@ -20,6 +20,7 @@
 use std::ffi::CString;
 use std::fs::{self, File};
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 use gccjit::OutputKind;
 use object::read::archive::ArchiveFile;
@@ -29,14 +30,15 @@ use rustc_codegen_ssa::back::write::{CodegenContext, FatLtoInput, SharedEmitter}
 use rustc_codegen_ssa::traits::*;
 use rustc_codegen_ssa::{CompiledModule, ModuleCodegen, ModuleKind};
 use rustc_data_structures::memmap::Mmap;
-use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_errors::{DiagCtxt, DiagCtxtHandle};
 use rustc_log::tracing::info;
+use rustc_session::Session;
 use tempfile::{TempDir, tempdir};
 
 use crate::back::write::{codegen, save_temp_bitcode};
 use crate::diagnostics::LtoBitcodeFromRlib;
-use crate::{GccCodegenBackend, GccContext, LtoMode, to_gcc_opt_level};
+use crate::gcc_util::new_context;
+use crate::{GccCodegenBackend, GccContext, LtoMode, SyncContext, to_gcc_opt_level};
 
 struct LtoData {
     // FIXME(antoyo): use symbols_below_threshold.
@@ -102,8 +104,8 @@ fn save_as_file(obj: &[u8], path: &Path) -> Result<(), LtoBitcodeFromRlib> {
 /// Performs fat LTO by merging all modules into a single one and returning it
 /// for further optimization.
 pub(crate) fn run_fat(
+    sess: &Session,
     cgcx: &CodegenContext,
-    prof: &SelfProfilerRef,
     shared_emitter: &SharedEmitter,
     each_linked_rlib_for_lto: &[PathBuf],
     modules: Vec<FatLtoInput<GccCodegenBackend>>,
@@ -114,8 +116,8 @@ pub(crate) fn run_fat(
     /*let symbols_below_threshold =
     lto_data.symbols_below_threshold.iter().map(|c| c.as_ptr()).collect::<Vec<_>>();*/
     fat_lto(
+        sess,
         cgcx,
-        prof,
         dcx,
         modules,
         lto_data.upstream_modules,
@@ -125,15 +127,15 @@ pub(crate) fn run_fat(
 }
 
 fn fat_lto(
+    sess: &Session,
     cgcx: &CodegenContext,
-    prof: &SelfProfilerRef,
     dcx: DiagCtxtHandle<'_>,
     modules: Vec<FatLtoInput<GccCodegenBackend>>,
     mut serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>,
     tmp_path: TempDir,
     //symbols_below_threshold: &[String],
 ) -> CompiledModule {
-    let _timer = prof.generic_activity("GCC_fat_lto_build_monolithic_module");
+    let _timer = sess.prof.generic_activity("GCC_fat_lto_build_monolithic_module");
     info!("going for a fat lto");
 
     // Sort out all our lists of incoming modules into two lists.
@@ -183,17 +185,16 @@ fn fat_lto(
     // module and create a linker with it.
     let mut module: ModuleCodegen<GccContext> = match costliest_module {
         Some((_cost, i)) => in_memory.remove(i),
-        None => {
-            unimplemented!("Incremental");
-            /*assert!(!serialized_modules.is_empty(), "must have at least one serialized module");
-            let (buffer, name) = serialized_modules.remove(0);
-            info!("no in-memory regular modules to choose from, parsing {:?}", name);
-            ModuleCodegen {
-                module_llvm: GccContext::parse(cgcx, &name, buffer.data(), dcx)?,
-                name: name.into_string().unwrap(),
-                kind: ModuleKind::Regular,
-            }*/
-        }
+        None => ModuleCodegen::new_regular(
+            "lto_module".to_string(),
+            GccContext {
+                context: Arc::new(SyncContext::new(new_context(sess))),
+                relocation_model: sess.relocation_model(),
+                lto_supported: true,
+                lto_mode: LtoMode::None,
+                temp_dir: None,
+            },
+        ),
     };
     {
         info!("using {:?} as a base module", module.name);
@@ -220,7 +221,8 @@ fn fat_lto(
         // We add the object files and save in should_combine_object_files that we should combine
         // them into a single object file when compiling later.
         for (bc_decoded, name) in serialized_modules {
-            let _timer = prof
+            let _timer = sess
+                .prof
                 .generic_activity_with_arg_recorder("GCC_fat_lto_link_module", |recorder| {
                     recorder.record_arg(format!("{:?}", name))
                 });
@@ -258,7 +260,7 @@ fn fat_lto(
     // of now.
     module.module_llvm.temp_dir = Some(tmp_path);
 
-    codegen(cgcx, prof, dcx, module, &cgcx.module_config)
+    codegen(cgcx, &sess.prof, dcx, module, &cgcx.module_config)
 }
 
 pub struct ModuleBuffer(PathBuf);
diff --git a/compiler/rustc_codegen_gcc/src/back/write.rs b/compiler/rustc_codegen_gcc/src/back/write.rs
index cf5514412f745..1f4fd8a314ad2 100644
--- a/compiler/rustc_codegen_gcc/src/back/write.rs
+++ b/compiler/rustc_codegen_gcc/src/back/write.rs
@@ -11,8 +11,8 @@ use rustc_log::tracing::debug;
 use rustc_session::config::OutputType;
 use rustc_target::spec::SplitDebuginfo;
 
-use crate::base::add_pic_option;
 use crate::diagnostics::CopyBitcode;
+use crate::gcc_util::add_pic_option;
 use crate::{GccContext, LtoMode};
 
 pub(crate) fn codegen(
@@ -60,9 +60,6 @@ pub(crate) fn codegen(
                 let _timer = prof
                     .generic_activity_with_arg("GCC_module_codegen_embed_bitcode", &*module.name);
                 if lto_supported {
-                    // FIXME(antoyo): maybe we should call embed_bitcode to have the proper iOS fixes?
-                    //embed_bitcode(cgcx, llcx, llmod, &config.bc_cmdline, data);
-
                     context.add_command_line_option("-flto=auto");
                     context.add_command_line_option("-flto-partition=one");
                     context.add_command_line_option("-ffat-lto-objects");
diff --git a/compiler/rustc_codegen_gcc/src/base.rs b/compiler/rustc_codegen_gcc/src/base.rs
index 7a25fc46fd3fc..041420e35d2b5 100644
--- a/compiler/rustc_codegen_gcc/src/base.rs
+++ b/compiler/rustc_codegen_gcc/src/base.rs
@@ -1,9 +1,7 @@
-use std::collections::HashSet;
-use std::env;
 use std::sync::Arc;
 use std::time::Instant;
 
-use gccjit::{CType, Context, FunctionType, GlobalKind};
+use gccjit::{CType, FunctionType, GlobalKind};
 use rustc_codegen_ssa::ModuleCodegen;
 use rustc_codegen_ssa::base::maybe_create_entry_wrapper;
 use rustc_codegen_ssa::mono_item::MonoItemExt;
@@ -17,11 +15,11 @@ use rustc_session::config::DebugInfo;
 use rustc_span::Symbol;
 #[cfg(feature = "master")]
 use rustc_target::spec::SymbolVisibility;
-use rustc_target::spec::{Arch, RelocModel};
 
 use crate::builder::Builder;
 use crate::context::CodegenCx;
-use crate::{GccContext, LockedTargetInfo, LtoMode, SyncContext, gcc_util, new_context};
+use crate::gcc_util::new_context;
+use crate::{GccContext, LockedTargetInfo, LtoMode, SyncContext};
 
 #[cfg(feature = "master")]
 pub fn visibility_to_gcc(visibility: Visibility) -> gccjit::Visibility {
@@ -101,41 +99,7 @@ pub fn compile_codegen_unit(
     ) -> ModuleCodegen<GccContext> {
         let cgu = tcx.codegen_unit(cgu_name);
         // Instantiate monomorphizations without filling out definitions yet...
-        let context = new_context(tcx);
-
-        if tcx.sess.panic_strategy().unwinds() {
-            context.add_command_line_option("-fexceptions");
-            context.add_driver_option("-fexceptions");
-        }
-
-        let disabled_features: HashSet<_> = tcx
-            .sess
-            .opts
-            .cg
-            .target_feature
-            .split(',')
-            .filter(|feature| feature.starts_with('-'))
-            .map(|string| &string[1..])
-            .collect();
-
-        if !disabled_features.contains("avx") && tcx.sess.target.arch == Arch::X86_64 {
-            // NOTE: we always enable AVX because the equivalent of llvm.x86.sse2.cmp.pd in GCC for
-            // SSE2 is multiple builtins, so we use the AVX __builtin_ia32_cmppd instead.
-            // FIXME(antoyo): use the proper builtins for llvm.x86.sse2.cmp.pd and similar.
-            context.add_command_line_option("-mavx");
-        }
-
-        for arg in &tcx.sess.opts.cg.llvm_args {
-            context.add_command_line_option(arg);
-        }
-        // NOTE: This is needed to compile the file src/intrinsic/archs.rs during a bootstrap of rustc.
-        context.add_command_line_option("-fno-var-tracking-assignments");
-        // NOTE: an optimization (https://github.com/rust-lang/rustc_codegen_gcc/issues/53).
-        context.add_command_line_option("-fno-semantic-interposition");
-        // NOTE: Rust relies on LLVM not doing TBAA (https://github.com/rust-lang/unsafe-code-guidelines/issues/292).
-        context.add_command_line_option("-fno-strict-aliasing");
-        // NOTE: Rust relies on LLVM doing wrapping on overflow.
-        context.add_command_line_option("-fwrapv");
+        let context = new_context(tcx.sess);
 
         // NOTE: We need to honor the `#![no_builtins]` attribute to prevent GCC from
         // replacing code patterns (like loops) with calls to builtins (like memset).
@@ -148,64 +112,6 @@ pub fn compile_codegen_unit(
             context.add_command_line_option("-fno-tree-loop-distribute-patterns");
         }
 
-        if let Some(model) = tcx.sess.code_model() {
-            use rustc_target::spec::CodeModel;
-
-            context.add_command_line_option(match model {
-                CodeModel::Tiny => "-mcmodel=tiny",
-                CodeModel::Small => "-mcmodel=small",
-                CodeModel::Kernel => "-mcmodel=kernel",
-                CodeModel::Medium => "-mcmodel=medium",
-                CodeModel::Large => "-mcmodel=large",
-            });
-        }
-
-        add_pic_option(&context, tcx.sess.relocation_model());
-
-        let target_cpu = gcc_util::target_cpu(tcx.sess);
-        if target_cpu != "generic" {
-            context.add_command_line_option(format!("-march={}", target_cpu));
-        }
-
-        if tcx
-            .sess
-            .opts
-            .unstable_opts
-            .function_sections
-            .unwrap_or(tcx.sess.target.function_sections)
-        {
-            context.add_command_line_option("-ffunction-sections");
-            context.add_command_line_option("-fdata-sections");
-        }
-
-        if env::var("CG_GCCJIT_DUMP_RTL").as_deref() == Ok("1") {
-            context.add_command_line_option("-fdump-rtl-vregs");
-        }
-        if env::var("CG_GCCJIT_DUMP_RTL_ALL").as_deref() == Ok("1") {
-            context.add_command_line_option("-fdump-rtl-all");
-        }
-        if env::var("CG_GCCJIT_DUMP_TREE_ALL").as_deref() == Ok("1") {
-            context.add_command_line_option("-fdump-tree-all-eh");
-        }
-        if env::var("CG_GCCJIT_DUMP_IPA_ALL").as_deref() == Ok("1") {
-            context.add_command_line_option("-fdump-ipa-all-eh");
-        }
-        if env::var("CG_GCCJIT_DUMP_CODE").as_deref() == Ok("1") {
-            context.set_dump_code_on_compile(true);
-        }
-        if env::var("CG_GCCJIT_DUMP_GIMPLE").as_deref() == Ok("1") {
-            context.set_dump_initial_gimple(true);
-        }
-        if env::var("CG_GCCJIT_DUMP_EVERYTHING").as_deref() == Ok("1") {
-            context.set_dump_everything(true);
-        }
-        if env::var("CG_GCCJIT_KEEP_INTERMEDIATES").as_deref() == Ok("1") {
-            context.set_keep_intermediates(true);
-        }
-        if env::var("CG_GCCJIT_VERBOSE").as_deref() == Ok("1") {
-            context.add_driver_option("-v");
-        }
-
         // NOTE: The codegen generates unreachable blocks.
         context.set_allow_unreachable_blocks(true);
 
@@ -269,24 +175,3 @@ pub fn compile_codegen_unit(
 
     (module, cost)
 }
-
-pub fn add_pic_option<'gcc>(context: &Context<'gcc>, relocation_model: RelocModel) {
-    match relocation_model {
-        rustc_target::spec::RelocModel::Static => {
-            context.add_command_line_option("-fno-pie");
-            context.add_driver_option("-fno-pie");
-        }
-        rustc_target::spec::RelocModel::Pic => {
-            context.add_command_line_option("-fPIC");
-            // NOTE: we use both add_command_line_option and add_driver_option because the usage in
-            // this module (compile_codegen_unit) requires add_command_line_option while the usage
-            // in the back::write module (codegen) requires add_driver_option.
-            context.add_driver_option("-fPIC");
-        }
-        rustc_target::spec::RelocModel::Pie => {
-            context.add_command_line_option("-fPIE");
-            context.add_driver_option("-fPIE");
-        }
-        model => eprintln!("Unsupported relocation model: {:?}", model),
-    }
-}
diff --git a/compiler/rustc_codegen_gcc/src/builder.rs b/compiler/rustc_codegen_gcc/src/builder.rs
index a407362638f10..4096679ba0959 100644
--- a/compiler/rustc_codegen_gcc/src/builder.rs
+++ b/compiler/rustc_codegen_gcc/src/builder.rs
@@ -4,8 +4,8 @@ use std::convert::TryFrom;
 use std::ops::Deref;
 
 use gccjit::{
-    BinaryOp, Block, ComparisonOp, Context, Function, LValue, Location, RValue, ToRValue, Type,
-    UnaryOp,
+    BinaryOp, Block, CType, ComparisonOp, Context, Function, LValue, Location, RValue, ToRValue,
+    Type, UnaryOp,
 };
 use rustc_abi as abi;
 use rustc_abi::{Align, HasDataLayout, Size, TargetDataLayout, WrappingRange};
@@ -36,7 +36,6 @@ use rustc_target::spec::{HasTargetSpec, HasX86AbiOpt, Target, X86Abi};
 use crate::abi::FnAbiGccExt;
 use crate::common::{SignType, TypeReflection, type_is_pointer};
 use crate::context::CodegenCx;
-use crate::diagnostics;
 use crate::intrinsic::llvm;
 use crate::type_of::LayoutGccExt;
 
@@ -85,7 +84,7 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
             self.atomic_load(dst.get_type(), dst, load_ordering, Size::from_bytes(size));
         let previous_var =
             func.new_local(self.location, previous_value.get_type(), "previous_value");
-        let return_value = func.new_local(self.location, previous_value.get_type(), "return_value");
+        let return_value = self.new_temp(func, self.location, previous_value.get_type());
         self.llbb().add_assignment(self.location, previous_var, previous_value);
         self.llbb().add_assignment(self.location, return_value, previous_var.to_rvalue());
 
@@ -312,34 +311,59 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
         self.block.get_function()
     }
 
+    /// Shared implementation of `call` and `tail_call`. For tail call it is important that this
+    /// returns a bare call, and not the result assigned to a local, or the result of `add_eval`.
+    fn build_call(
+        &mut self,
+        typ: Type<'gcc>,
+        fn_abi: Option<&FnAbi<'tcx, Ty<'tcx>>>,
+        func: RValue<'gcc>,
+        args: &[RValue<'gcc>],
+        funclet: Option<&Funclet>,
+        must_tail: bool,
+    ) -> RValue<'gcc> {
+        // FIXME(antoyo): remove when having a proper API.
+        let gcc_func = unsafe { std::mem::transmute::<RValue<'gcc>, Function<'gcc>>(func) };
+        let call = if self.functions.borrow().values().any(|value| *value == gcc_func) {
+            // FIXME(antoyo): remove when the API supports a different type for functions.
+            let func: Function<'gcc> = self.cx.rvalue_as_function(func);
+            self.function_call(func, args, funclet, must_tail)
+        } else {
+            // If it's a not function that was defined, it's a function pointer.
+            self.function_ptr_call(typ, fn_abi, func, args, funclet, must_tail)
+        };
+        if let Some(_fn_abi) = fn_abi {
+            // FIXME(bjorn3): Apply function attributes
+        }
+        call
+    }
+
     pub fn function_call(
         &mut self,
         func: Function<'gcc>,
         args: &[RValue<'gcc>],
         _funclet: Option<&Funclet>,
+        must_tail: bool,
     ) -> RValue<'gcc> {
         let args = self.check_call("call", func, args);
 
+        let call = self.cx.context.new_call(self.location, func, &args);
+        if must_tail {
+            // Return the bare tail call, don't assign or `add_eval` it yet.
+            return call;
+        }
+
         // gccjit requires to use the result of functions, even when it's not used.
         // That's why we assign the result to a local or call add_eval().
         let return_type = func.get_return_type();
         let void_type = self.context.new_type::<()>();
         let current_func = self.block.get_function();
         if return_type != void_type {
-            let result = current_func.new_local(
-                self.location,
-                return_type,
-                format!("returnValue{}", self.next_value_counter()),
-            );
-            self.block.add_assignment(
-                self.location,
-                result,
-                self.cx.context.new_call(self.location, func, &args),
-            );
+            let result = self.new_temp(current_func, self.location, return_type);
+            self.block.add_assignment(self.location, result, call);
             result.to_rvalue()
         } else {
-            self.block
-                .add_eval(self.location, self.cx.context.new_call(self.location, func, &args));
+            self.block.add_eval(self.location, call);
             // Return dummy value when not having return value.
             self.context.new_rvalue_zero(self.isize_type)
         }
@@ -352,6 +376,7 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
         mut func_ptr: RValue<'gcc>,
         args: &[RValue<'gcc>],
         _funclet: Option<&Funclet>,
+        must_tail: bool,
     ) -> RValue<'gcc> {
         let func_ptr_type = {
             let func_ptr_type = func_ptr.get_type();
@@ -376,6 +401,12 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
         let args_adjusted = args.len() != previous_arg_count;
         let args = self.check_ptr_call("call", func_ptr, &args, &on_stack_param_indices);
 
+        if must_tail {
+            // Return the bare tail call, don't assign or `add_eval` it yet.
+            let call = self.cx.context.new_call_through_ptr(self.location, func_ptr, &args);
+            return call;
+        }
+
         // gccjit requires to use the result of functions, even when it's not used.
         // That's why we assign the result to a local or call add_eval().
         let return_type = gcc_func.get_return_type();
@@ -392,11 +423,7 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
                 args_adjusted,
                 orig_args,
             );
-            let result = current_func.new_local(
-                self.location,
-                return_value.get_type(),
-                format!("ptrReturnValue{}", self.next_value_counter()),
-            );
+            let result = self.new_temp(current_func, self.location, return_value.get_type());
             self.block.add_assignment(self.location, result, return_value);
             result.to_rvalue()
         } else {
@@ -418,8 +445,16 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
                 self.location,
                 self.cx.context.new_call_through_ptr(self.location, func_ptr, &args),
             );
-            // Return dummy value when not having return value.
-            self.context.new_rvalue_zero(self.isize_type)
+            // Return dummy value when not having return value, unless the intrinsic adapter
+            // needs to synthesize a non-void LLVM-level result from out-parameters.
+            llvm::adjust_intrinsic_return_value(
+                self,
+                self.context.new_rvalue_zero(self.isize_type),
+                &func_name,
+                &args,
+                args_adjusted,
+                orig_args,
+            )
         }
     }
 
@@ -434,11 +469,7 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
         let return_type = self.context.new_type::<bool>();
         let current_func = self.block.get_function();
         // FIXME(antoyo): return the new_call() directly? Since the overflow function has no side-effects.
-        let result = current_func.new_local(
-            self.location,
-            return_type,
-            format!("overflowReturnValue{}", self.next_value_counter()),
-        );
+        let result = self.new_temp(current_func, self.location, return_type);
         self.block.add_assignment(
             self.location,
             result,
@@ -570,6 +601,18 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         default_block: Block<'gcc>,
         cases: impl ExactSizeIterator<Item = (u128, Block<'gcc>)>,
     ) {
+        // A switch with no cases is equivalent to an unconditional jump to the
+        // default block. Such a `SwitchInt` (one with only an `otherwise` target)
+        // is normally simplified into a `goto`, but `-Z mir-preserve-ub` keeps it,
+        // so it can reach here with e.g. the `bool` discriminant produced by a
+        // range-pattern comparison. `gcc_jit_block_end_with_switch` rejects a
+        // discriminant that is not of integer type, so emit a plain jump instead
+        // of a (pointless) switch.
+        if cases.len() == 0 {
+            self.block.end_with_jump(self.location, default_block);
+            return;
+        }
+
         let mut gcc_cases = vec![];
         let typ = self.val_ty(value);
         // FIXME(FractalFir): This is a workaround for a libgccjit limitation.
@@ -616,8 +659,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         let call = self.call(typ, fn_attrs, fn_abi, func, args, None, instance); // FIXME(antoyo): use funclet here?
         self.block = current_block;
 
-        let return_value =
-            self.current_func().new_local(self.location, call.get_type(), "invokeResult");
+        let return_value = self.new_temp(self.current_func(), self.location, call.get_type());
 
         try_block.add_assignment(self.location, return_value, call);
 
@@ -664,8 +706,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         if return_type == void_type {
             self.block.end_with_void_return(self.location)
         } else {
-            let return_value =
-                self.current_func().new_local(self.location, return_type, "unreachableReturn");
+            let return_value = self.new_temp(self.current_func(), self.location, return_type);
             self.block.end_with_return(self.location, return_value)
         }
     }
@@ -984,11 +1025,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         // the current basic block. Otherwise, it could be used in another basic block, causing a
         // dereference after a drop, for instance.
         let deref = ptr.dereference(self.location).to_rvalue();
-        let loaded_value = function.new_local(
-            self.location,
-            aligned_type,
-            format!("loadedValue{}", self.next_value_counter()),
-        );
+        let loaded_value = self.new_temp(function, self.location, aligned_type);
         block.add_assignment(self.location, loaded_value, deref);
         loaded_value.to_rvalue()
     }
@@ -1106,7 +1143,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         let next_bb = self.append_sibling_block("repeat_loop_next");
 
         let ptr_type = start.get_type();
-        let current = self.llbb().get_function().new_local(self.location, ptr_type, "loop_var");
+        let current = self.new_temp(self.llbb().get_function(), self.location, ptr_type);
         let current_val = current.to_rvalue();
         self.assign(current, start);
 
@@ -1471,7 +1508,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         mut else_val: RValue<'gcc>,
     ) -> RValue<'gcc> {
         let func = self.current_func();
-        let variable = func.new_local(self.location, then_val.get_type(), "selectVar");
+        let variable = self.new_temp(func, self.location, then_val.get_type());
         let then_block = func.new_block("then");
         let else_block = func.new_block("else");
         let after_block = func.new_block("after");
@@ -1493,8 +1530,10 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         variable.to_rvalue()
     }
 
-    fn va_arg(&mut self, _list: RValue<'gcc>, _ty: Type<'gcc>) -> RValue<'gcc> {
-        unimplemented!();
+    fn va_arg(&mut self, list: RValue<'gcc>, ty: Type<'gcc>) -> RValue<'gcc> {
+        let va_list_type = self.context.new_c_type(CType::VaList);
+        let list = self.context.new_cast(self.location, list, va_list_type.make_pointer());
+        self.context.new_va_arg(self.location, list, ty)
     }
 
     #[cfg(feature = "master")]
@@ -1615,11 +1654,9 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
     #[cfg(not(feature = "master"))]
     fn cleanup_landing_pad(&mut self, _pers_fn: Function<'gcc>) -> (RValue<'gcc>, RValue<'gcc>) {
         let value1 = self
-            .current_func()
-            .new_local(self.location, self.u8_type.make_pointer(), "landing_pad0")
+            .new_temp(self.current_func(), self.location, self.u8_type.make_pointer())
             .to_rvalue();
-        let value2 =
-            self.current_func().new_local(self.location, self.i32_type, "landing_pad1").to_rvalue();
+        let value2 = self.new_temp(self.current_func(), self.location, self.i32_type).to_rvalue();
         (value1, value2)
     }
 
@@ -1687,7 +1724,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
 
         // NOTE: since success contains the call to the intrinsic, it must be added to the basic block before
         // expected so that we store expected after the call.
-        let success_var = self.current_func().new_local(self.location, self.bool_type, "success");
+        let success_var = self.new_temp(self.current_func(), self.location, self.bool_type);
         self.llbb().add_assignment(self.location, success_var, success);
 
         (expected.to_rvalue(), success_var.to_rvalue())
@@ -1776,34 +1813,34 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         funclet: Option<&Funclet>,
         _instance: Option<Instance<'tcx>>,
     ) -> RValue<'gcc> {
-        // FIXME(antoyo): remove when having a proper API.
-        let gcc_func = unsafe { std::mem::transmute::<RValue<'gcc>, Function<'gcc>>(func) };
-        let call = if self.functions.borrow().values().any(|value| *value == gcc_func) {
-            // FIXME(antoyo): remove when the API supports a different type for functions.
-            let func: Function<'gcc> = self.cx.rvalue_as_function(func);
-            self.function_call(func, args, funclet)
-        } else {
-            // If it's a not function that was defined, it's a function pointer.
-            self.function_ptr_call(typ, fn_abi, func, args, funclet)
-        };
-        if let Some(_fn_abi) = fn_abi {
-            // FIXME(bjorn3): Apply function attributes
-        }
-        call
+        self.build_call(typ, fn_abi, func, args, funclet, false)
     }
 
     fn tail_call(
         &mut self,
-        _llty: Self::Type,
+        llty: Self::Type,
         _fn_attrs: Option<&CodegenFnAttrs>,
-        _fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
-        _llfn: Self::Value,
-        _args: &[Self::Value],
-        _funclet: Option<&Self::Funclet>,
+        fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
+        llfn: Self::Value,
+        args: &[Self::Value],
+        funclet: Option<&Self::Funclet>,
         _instance: Option<Instance<'tcx>>,
     ) {
-        // FIXME: implement support for explicit tail calls like rustc_codegen_llvm.
-        self.tcx.dcx().emit_fatal(diagnostics::ExplicitTailCallsUnsupported);
+        // `emit_call` returns a bare call for here, it has not been assigned or passed to add_eval.
+        let call = self.build_call(llty, Some(fn_abi), llfn, args, funclet, true);
+        call.set_require_tail_call(true);
+
+        let return_type = self.current_func().get_return_type();
+        let void_type = self.context.new_type::<()>();
+
+        if return_type == void_type {
+            // For a void return the call is emitted as its own statement, immediately
+            // followed by a void return, so the tail call sits in tail position.
+            self.llbb().add_eval(self.location, call);
+            self.ret_void();
+        } else {
+            self.ret(call)
+        }
     }
 
     fn zext(&mut self, value: RValue<'gcc>, dest_typ: Type<'gcc>) -> RValue<'gcc> {
@@ -2388,11 +2425,31 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
         self.bitcast_if_needed(res, result_type)
     }
 
+    /// Create a temporary variable.
+    ///
+    /// GCC will use more stack space with a local variable than with a temporary variable in debug mode,
+    /// so in order to avoid having the stack probe test fail in CI, we avoid creating local variables for temporaries.
+    pub fn new_temp(
+        &self,
+        function: Function<'gcc>,
+        location: Option<Location<'gcc>>,
+        typ: Type<'gcc>,
+    ) -> LValue<'gcc> {
+        #[cfg(feature = "master")]
+        {
+            function.new_temp(location, typ)
+        }
+        #[cfg(not(feature = "master"))]
+        {
+            function.new_local(location, typ, format!("temp{}", self.next_value_counter()))
+        }
+    }
+
     // GCC doesn't like deeply nested expressions.
     // By assigning intermediate expressions to a variable, this allow us to avoid deeply nested
     // expressions and GCC will use much less RAM.
     fn assign_to_var(&self, value: RValue<'gcc>) -> RValue<'gcc> {
-        let var = self.current_func().new_local(self.location, value.get_type(), "opResult");
+        let var = self.new_temp(self.current_func(), self.location, value.get_type());
         self.llbb().add_assignment(self.location, var, value);
         var.to_rvalue()
     }
diff --git a/compiler/rustc_codegen_gcc/src/callee.rs b/compiler/rustc_codegen_gcc/src/callee.rs
index 00f095ed54371..d3f412180da55 100644
--- a/compiler/rustc_codegen_gcc/src/callee.rs
+++ b/compiler/rustc_codegen_gcc/src/callee.rs
@@ -70,7 +70,7 @@ pub fn get_fn<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, instance: Instance<'tcx>)
         cx.linkage.set(FunctionType::Extern);
         let func = cx.declare_fn(sym, fn_abi);
 
-        attributes::from_fn_attrs(cx, func, instance);
+        attributes::from_fn_attrs(cx, func, instance, Some(fn_abi));
 
         #[cfg(feature = "master")]
         {
diff --git a/compiler/rustc_codegen_gcc/src/common.rs b/compiler/rustc_codegen_gcc/src/common.rs
index 6bd186f1121fc..d979c8b7ed094 100644
--- a/compiler/rustc_codegen_gcc/src/common.rs
+++ b/compiler/rustc_codegen_gcc/src/common.rs
@@ -143,9 +143,9 @@ pub fn bytes_in_context<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, bytes: &[u8]) ->
             let context = &cx.context;
             let byte_type = context.new_type::<u64>();
             let typ = new_array_type(context, None, byte_type, bytes.len() as u64 / 8);
-            let elements: Vec<_> = bytes
-                .as_chunks::<8>()
-                .0
+            let (arrays, remainder) = bytes.as_chunks::<8>();
+            debug_assert!(remainder.is_empty());
+            let elements: Vec<_> = arrays
                 .iter()
                 .map(|&arr| {
                     context.new_rvalue_from_long(
@@ -170,9 +170,9 @@ pub fn bytes_in_context<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, bytes: &[u8]) ->
             let context = &cx.context;
             let byte_type = context.new_type::<u32>();
             let typ = new_array_type(context, None, byte_type, bytes.len() as u64 / 4);
-            let elements: Vec<_> = bytes
-                .as_chunks::<4>()
-                .0
+            let (arrays, remainder) = bytes.as_chunks::<4>();
+            debug_assert!(remainder.is_empty());
+            let elements: Vec<_> = arrays
                 .iter()
                 .map(|&arr| {
                     context.new_rvalue_from_int(
diff --git a/compiler/rustc_codegen_gcc/src/consts.rs b/compiler/rustc_codegen_gcc/src/consts.rs
index 42ff930968501..5ebdf91fe20b6 100644
--- a/compiler/rustc_codegen_gcc/src/consts.rs
+++ b/compiler/rustc_codegen_gcc/src/consts.rs
@@ -1,6 +1,6 @@
 #[cfg(feature = "master")]
-use gccjit::{FnAttribute, VarAttribute, Visibility};
-use gccjit::{Function, GlobalKind, LValue, RValue, ToRValue, Type};
+use gccjit::{FnAttribute, ToRValue, VarAttribute, Visibility};
+use gccjit::{Function, GlobalKind, LValue, RValue, Type};
 use rustc_abi::{self as abi, Align, HasDataLayout, Primitive, Size, WrappingRange};
 use rustc_codegen_ssa::traits::{
     BaseTypeCodegenMethods, ConstCodegenMethods, StaticCodegenMethods,
@@ -160,29 +160,52 @@ impl<'gcc, 'tcx> StaticCodegenMethods for CodegenCx<'gcc, 'tcx> {
         }
 
         // Wasm statics with custom link sections get special treatment as they
-        // go into custom sections of the wasm executable.
-        if self.tcx.sess.target.is_like_wasm {
+        // go into custom sections of the wasm executable. The exception to this
+        // is the `.init_array` section which are treated specially by the wasm linker.
+        if self.tcx.sess.target.is_like_wasm
+            && attrs
+                .link_section
+                .map(|link_section| !link_section.as_str().starts_with(".init_array"))
+                .unwrap_or(true)
+        {
             if let Some(_section) = attrs.link_section {
                 unimplemented!();
             }
-        } else {
-            // FIXME(antoyo): set link section.
+        } else if let Some(_section) = attrs.link_section {
+            #[cfg(feature = "master")]
+            global.add_attribute(VarAttribute::Section(_section.as_str()));
         }
 
-        if attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER)
-            || attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER)
-        {
-            self.add_used_global(global.to_rvalue());
+        if attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER) {
+            // To copy the conditions from the LLVM backend...
+            assert!(!attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER));
+            self.add_used_global(global);
+        }
+        if attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER) {
+            // To copy the conditions from the LLVM backend...
+            assert!(!attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER));
+            self.add_retained_global(global);
         }
     }
 }
 
 impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
-    /// Add a global value to a list to be stored in the `llvm.used` variable, an array of i8*.
-    pub fn add_used_global(&mut self, _global: RValue<'gcc>) {
-        // FIXME(antoyo)
+    /// Need to have the `SHF_GNU_RETAIN` flag, so needs to use the `retain` attribute instead of
+    /// `used`. This is used by `#[used(linker)]`.
+    pub fn add_retained_global(&mut self, global: LValue<'gcc>) {
+        // We need to add the `used` C attribute in any case.
+        self.add_used_global(global);
+        #[cfg(feature = "master")]
+        global.add_attribute(VarAttribute::Retain);
+    }
+
+    /// This is used by `#[used(compiler)]` and `#[used]`.
+    pub fn add_used_global(&mut self, _global: LValue<'gcc>) {
+        #[cfg(feature = "master")]
+        _global.add_attribute(VarAttribute::Used);
     }
 
+    // No need to have the `SHF_GNU_RETAIN` flag, so `used` attribute is ok.
     #[cfg_attr(not(feature = "master"), expect(unused_variables))]
     pub fn add_used_function(&self, function: Function<'gcc>) {
         #[cfg(feature = "master")]
diff --git a/compiler/rustc_codegen_gcc/src/declare.rs b/compiler/rustc_codegen_gcc/src/declare.rs
index 4174eebcf7b02..9bf57fbf75bc0 100644
--- a/compiler/rustc_codegen_gcc/src/declare.rs
+++ b/compiler/rustc_codegen_gcc/src/declare.rs
@@ -1,12 +1,12 @@
 #[cfg(feature = "master")]
-use gccjit::{FnAttribute, ToRValue};
+use gccjit::{FnAttribute, ToRValue, VarAttribute};
 use gccjit::{Function, FunctionType, GlobalKind, LValue, RValue, Type};
 use rustc_codegen_ssa::traits::BaseTypeCodegenMethods;
 use rustc_middle::ty::Ty;
 use rustc_span::Symbol;
 use rustc_target::callconv::FnAbi;
 
-use crate::abi::{FnAbiGcc, FnAbiGccExt};
+use crate::abi::FnAbiGccExt;
 use crate::context::CodegenCx;
 
 impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
@@ -24,6 +24,9 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
                 global.set_tls_model(self.tls_model);
             }
             if let Some(link_section) = link_section {
+                #[cfg(feature = "master")]
+                global.add_attribute(VarAttribute::Section(link_section.as_str()));
+                #[cfg(not(feature = "master"))]
                 global.set_link_section(link_section.as_str());
             }
             global
@@ -73,6 +76,9 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
             global.set_tls_model(self.tls_model);
         }
         if let Some(link_section) = link_section {
+            #[cfg(feature = "master")]
+            global.add_attribute(VarAttribute::Section(link_section.as_str()));
+            #[cfg(not(feature = "master"))]
             global.set_link_section(link_section.as_str());
         }
         let global_address = global.get_address(None);
@@ -110,22 +116,22 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
     }
 
     pub fn declare_fn(&self, name: &str, fn_abi: &FnAbi<'tcx, Ty<'tcx>>) -> Function<'gcc> {
-        let FnAbiGcc {
-            return_type,
-            arguments_type,
-            is_c_variadic,
-            on_stack_param_indices,
-            #[cfg(feature = "master")]
-            fn_attributes,
-        } = fn_abi.gcc_type(self);
+        let fn_abi_gcc = fn_abi.gcc_type(self);
         #[cfg(feature = "master")]
         let conv = fn_abi.gcc_cconv(self);
         #[cfg(not(feature = "master"))]
         let conv = None;
-        let func = declare_raw_fn(self, name, conv, return_type, &arguments_type, is_c_variadic);
-        self.on_stack_function_params.borrow_mut().insert(func, on_stack_param_indices);
+        let func = declare_raw_fn(
+            self,
+            name,
+            conv,
+            fn_abi_gcc.return_type,
+            &fn_abi_gcc.arguments_type,
+            fn_abi_gcc.is_c_variadic,
+        );
+        self.on_stack_function_params.borrow_mut().insert(func, fn_abi_gcc.on_stack_param_indices);
         #[cfg(feature = "master")]
-        for fn_attr in fn_attributes {
+        for fn_attr in fn_abi_gcc.fn_attributes {
             func.add_attribute(fn_attr);
         }
         func
diff --git a/compiler/rustc_codegen_gcc/src/diagnostics.rs b/compiler/rustc_codegen_gcc/src/diagnostics.rs
index de633d3bdde79..67723ebd2f30b 100644
--- a/compiler/rustc_codegen_gcc/src/diagnostics.rs
+++ b/compiler/rustc_codegen_gcc/src/diagnostics.rs
@@ -20,10 +20,6 @@ pub(crate) struct LtoBitcodeFromRlib {
     pub gcc_err: String,
 }
 
-#[derive(Diagnostic)]
-#[diag("explicit tail calls with the 'become' keyword are not implemented in the GCC backend")]
-pub(crate) struct ExplicitTailCallsUnsupported;
-
 #[derive(Diagnostic)]
 #[diag("asm contains a NUL byte")]
 pub(crate) struct NulBytesInAsm {
diff --git a/compiler/rustc_codegen_gcc/src/gcc_util.rs b/compiler/rustc_codegen_gcc/src/gcc_util.rs
index a95b4da28eb63..4d7f2cdbb92ed 100644
--- a/compiler/rustc_codegen_gcc/src/gcc_util.rs
+++ b/compiler/rustc_codegen_gcc/src/gcc_util.rs
@@ -1,10 +1,14 @@
-#[cfg(feature = "master")]
+use std::collections::HashSet;
+use std::env;
+
 use gccjit::Context;
+#[cfg(feature = "master")]
+use gccjit::Version;
 use rustc_codegen_ssa::target_features;
 use rustc_data_structures::smallvec::{SmallVec, smallvec};
 use rustc_session::Session;
 use rustc_session::config::NATIVE_CPU;
-use rustc_target::spec::Arch;
+use rustc_target::spec::{Arch, RelocModel, StackProbeType, StackProtector};
 
 fn gcc_features_by_flags(sess: &Session, features: &mut Vec<String>) {
     target_features::retpoline_features_by_flags(sess, features);
@@ -136,3 +140,147 @@ pub fn target_cpu(sess: &Session) -> &str {
         None => handle_native(sess.target.cpu.as_ref()),
     }
 }
+
+pub fn new_context<'gcc>(sess: &Session) -> Context<'gcc> {
+    let context = Context::default();
+    if matches!(sess.target.arch, Arch::X86 | Arch::X86_64) {
+        context.add_command_line_option("-masm=intel");
+    }
+    #[cfg(feature = "master")]
+    {
+        context.set_special_chars_allowed_in_func_names("$.*");
+        let version = Version::get();
+        let version = format!("{}.{}.{}", version.major, version.minor, version.patch);
+        context.set_output_ident(&format!(
+            "rustc version {} with libgccjit {}",
+            rustc_interface::util::rustc_version_str().unwrap_or("unknown version"),
+            version,
+        ));
+    }
+    // FIXME(antoyo): check if this should only be added when using -Cforce-unwind-tables=n.
+    context.add_command_line_option("-fno-asynchronous-unwind-tables");
+
+    if sess.panic_strategy().unwinds() {
+        context.add_command_line_option("-fexceptions");
+        context.add_driver_option("-fexceptions");
+    }
+
+    let disabled_features: HashSet<_> = sess
+        .opts
+        .cg
+        .target_feature
+        .split(',')
+        .filter(|feature| feature.starts_with('-'))
+        .map(|string| &string[1..])
+        .collect();
+
+    if !disabled_features.contains("avx") && sess.target.arch == Arch::X86_64 {
+        // NOTE: we always enable AVX because the equivalent of llvm.x86.sse2.cmp.pd in GCC for
+        // SSE2 is multiple builtins, so we use the AVX __builtin_ia32_cmppd instead.
+        // FIXME(antoyo): use the proper builtins for llvm.x86.sse2.cmp.pd and similar.
+        context.add_command_line_option("-mavx");
+    }
+
+    for arg in &sess.opts.cg.llvm_args {
+        context.add_command_line_option(arg);
+    }
+    // NOTE: This is needed to compile the file src/intrinsic/archs.rs during a bootstrap of rustc.
+    context.add_command_line_option("-fno-var-tracking-assignments");
+    // NOTE: an optimization (https://github.com/rust-lang/rustc_codegen_gcc/issues/53).
+    context.add_command_line_option("-fno-semantic-interposition");
+    // NOTE: Rust relies on LLVM not doing TBAA (https://github.com/rust-lang/unsafe-code-guidelines/issues/292).
+    context.add_command_line_option("-fno-strict-aliasing");
+    // NOTE: Rust relies on LLVM doing wrapping on overflow.
+    context.add_command_line_option("-fwrapv");
+
+    if let Some(model) = sess.code_model() {
+        use rustc_target::spec::CodeModel;
+
+        context.add_command_line_option(match model {
+            CodeModel::Tiny => "-mcmodel=tiny",
+            CodeModel::Small => "-mcmodel=small",
+            CodeModel::Kernel => "-mcmodel=kernel",
+            CodeModel::Medium => "-mcmodel=medium",
+            CodeModel::Large => "-mcmodel=large",
+        });
+    }
+
+    match sess.stack_protector() {
+        StackProtector::All => context.add_command_line_option("-fstack-protector-all"),
+        StackProtector::Strong => context.add_command_line_option("-fstack-protector-strong"),
+        StackProtector::Basic => context.add_command_line_option("-fstack-protector"),
+        StackProtector::None => (),
+    }
+
+    match sess.target.stack_probes {
+        StackProbeType::None => (),
+        StackProbeType::Inline | StackProbeType::InlineOrCall { .. } => {
+            context.add_command_line_option("-fstack-clash-protection")
+        }
+        // FIXME(antoyo): We should define the stack probe symbol to be __rust_probestack, but it seems GCC cannot do that.
+        StackProbeType::Call => (),
+    };
+
+    add_pic_option(&context, sess.relocation_model());
+
+    let target_cpu = target_cpu(sess);
+    if target_cpu != "generic" {
+        context.add_command_line_option(format!("-march={}", target_cpu));
+    }
+
+    if sess.opts.unstable_opts.function_sections.unwrap_or(sess.target.function_sections) {
+        context.add_command_line_option("-ffunction-sections");
+        context.add_command_line_option("-fdata-sections");
+    }
+
+    if env::var("CG_GCCJIT_DUMP_RTL").as_deref() == Ok("1") {
+        context.add_command_line_option("-fdump-rtl-vregs");
+    }
+    if env::var("CG_GCCJIT_DUMP_RTL_ALL").as_deref() == Ok("1") {
+        context.add_command_line_option("-fdump-rtl-all");
+    }
+    if env::var("CG_GCCJIT_DUMP_TREE_ALL").as_deref() == Ok("1") {
+        context.add_command_line_option("-fdump-tree-all-eh");
+    }
+    if env::var("CG_GCCJIT_DUMP_IPA_ALL").as_deref() == Ok("1") {
+        context.add_command_line_option("-fdump-ipa-all-eh");
+    }
+    if env::var("CG_GCCJIT_DUMP_CODE").as_deref() == Ok("1") {
+        context.set_dump_code_on_compile(true);
+    }
+    if env::var("CG_GCCJIT_DUMP_GIMPLE").as_deref() == Ok("1") {
+        context.set_dump_initial_gimple(true);
+    }
+    if env::var("CG_GCCJIT_DUMP_EVERYTHING").as_deref() == Ok("1") {
+        context.set_dump_everything(true);
+    }
+    if env::var("CG_GCCJIT_KEEP_INTERMEDIATES").as_deref() == Ok("1") {
+        context.set_keep_intermediates(true);
+    }
+    if env::var("CG_GCCJIT_VERBOSE").as_deref() == Ok("1") {
+        context.add_driver_option("-v");
+    }
+
+    context
+}
+
+pub fn add_pic_option<'gcc>(context: &Context<'gcc>, relocation_model: RelocModel) {
+    match relocation_model {
+        rustc_target::spec::RelocModel::Static => {
+            context.add_command_line_option("-fno-pie");
+            context.add_driver_option("-fno-pie");
+        }
+        rustc_target::spec::RelocModel::Pic => {
+            context.add_command_line_option("-fPIC");
+            // NOTE: we use both add_command_line_option and add_driver_option because the usage in
+            // base (compile_codegen_unit) requires add_command_line_option while the usage
+            // in the back::write module (codegen) requires add_driver_option.
+            context.add_driver_option("-fPIC");
+        }
+        rustc_target::spec::RelocModel::Pie => {
+            context.add_command_line_option("-fPIE");
+            context.add_driver_option("-fPIE");
+        }
+        model => eprintln!("Unsupported relocation model: {:?}", model),
+    }
+}
diff --git a/compiler/rustc_codegen_gcc/src/int.rs b/compiler/rustc_codegen_gcc/src/int.rs
index dfae4eceebe44..0c9a755694577 100644
--- a/compiler/rustc_codegen_gcc/src/int.rs
+++ b/compiler/rustc_codegen_gcc/src/int.rs
@@ -432,7 +432,7 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
         if self.is_non_native_int_type(a_type) || self.is_non_native_int_type(b_type) {
             // This algorithm is based on compiler-rt's __cmpti2:
             // https://github.com/llvm-mirror/compiler-rt/blob/f0745e8476f069296a7c71accedd061dce4cdf79/lib/builtins/cmpti2.c#L21
-            let result = self.current_func().new_local(self.location, self.int_type, "icmp_result");
+            let result = self.new_temp(self.current_func(), self.location, self.int_type);
             let block1 = self.current_func().new_block("block1");
             let block2 = self.current_func().new_block("block2");
             let block3 = self.current_func().new_block("block3");
@@ -462,9 +462,15 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
                     lhs_high = self.context.new_cast(self.location, lhs_high, unsigned_type);
                     rhs_high = self.context.new_cast(self.location, rhs_high, unsigned_type);
                 }
-                // FIXME(antoyo): we probably need to handle signed comparison for unsigned
-                // integers.
-                _ => (),
+                IntPredicate::IntSGT
+                | IntPredicate::IntSGE
+                | IntPredicate::IntSLT
+                | IntPredicate::IntSLE => {
+                    let signed_type = native_int_type.to_signed(self.cx);
+                    lhs_high = self.context.new_cast(self.location, lhs_high, signed_type);
+                    rhs_high = self.context.new_cast(self.location, rhs_high, signed_type);
+                }
+                IntPredicate::IntEQ | IntPredicate::IntNE => (),
             }
 
             let condition = self.context.new_comparison(
@@ -602,9 +608,17 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
                         rhs = self.context.new_cast(self.location, rhs, unsigned_type);
                     }
                 }
-                // FIXME(antoyo): we probably need to handle signed comparison for unsigned
-                // integers.
-                _ => (),
+                IntPredicate::IntSGT
+                | IntPredicate::IntSGE
+                | IntPredicate::IntSLT
+                | IntPredicate::IntSLE => {
+                    if !a_type.is_vector() {
+                        let signed_type = a_type.to_signed(self.cx);
+                        lhs = self.context.new_cast(self.location, lhs, signed_type);
+                        rhs = self.context.new_cast(self.location, rhs, signed_type);
+                    }
+                }
+                IntPredicate::IntEQ | IntPredicate::IntNE => (),
             }
             self.context.new_comparison(self.location, op.to_gcc_comparison(), lhs, rhs)
         }
@@ -862,7 +876,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         self.bitwise_operation(BinaryOp::BitwiseOr, a, b, loc)
     }
 
-    // FIXME(antoyo): can we use https://github.com/rust-lang/compiler-builtins/blob/master/src/int/mod.rs#L379 instead?
+    // FIXME(antoyo): can we use https://github.com/rust-lang/compiler-builtins/blob/1a99c2aa295bb2d507fa0e67a3b5eef64fba92a0/libm/src/math/support/int_traits.rs#L485 instead?
     pub fn gcc_int_cast(&self, value: RValue<'gcc>, dest_typ: Type<'gcc>) -> RValue<'gcc> {
         let value_type = value.get_type();
         if self.is_native_int_type_or_bool(dest_typ) && self.is_native_int_type_or_bool(value_type)
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/archs.rs b/compiler/rustc_codegen_gcc/src/intrinsic/archs.rs
index 3c1698df6dec2..1856c2468616d 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/archs.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/archs.rs
@@ -24,6 +24,7 @@ fn map_arch_intrinsic(full_name: &str) -> &'static str {
                     "gcsss" => "__builtin_arm_gcsss",
                     "isb" => "__builtin_arm_isb",
                     "prefetch" => "__builtin_arm_prefetch",
+                    "prefetch.ir" => "__builtin_arm_prefetch_ir",
                     "range.prefetch" => "__builtin_arm_range_prefetch",
                     "sme.in.streaming.mode" => "__builtin_arm_in_streaming_mode",
                     "sve.aesd" => "__builtin_sve_svaesd_u8",
@@ -53,6 +54,7 @@ fn map_arch_intrinsic(full_name: &str) -> &'static str {
                     "alignbyte" => "__builtin_amdgcn_alignbyte",
                     "ashr.pk.i8.i32" => "__builtin_amdgcn_ashr_pk_i8_i32",
                     "ashr.pk.u8.i32" => "__builtin_amdgcn_ashr_pk_u8_i32",
+                    "asyncmark" => "__builtin_amdgcn_asyncmark",
                     "buffer.wbinvl1" => "__builtin_amdgcn_buffer_wbinvl1",
                     "buffer.wbinvl1.sc" => "__builtin_amdgcn_buffer_wbinvl1_sc",
                     "buffer.wbinvl1.vol" => "__builtin_amdgcn_buffer_wbinvl1_vol",
@@ -270,6 +272,7 @@ fn map_arch_intrinsic(full_name: &str) -> &'static str {
                     "fdot2c.f32.bf16" => "__builtin_amdgcn_fdot2c_f32_bf16",
                     "flat.prefetch" => "__builtin_amdgcn_flat_prefetch",
                     "fmul.legacy" => "__builtin_amdgcn_fmul_legacy",
+                    "global.load.async.lds" => "__builtin_amdgcn_global_load_async_lds",
                     "global.load.async.to.lds.b128" => {
                         "__builtin_amdgcn_global_load_async_to_lds_b128"
                     }
@@ -361,11 +364,7 @@ fn map_arch_intrinsic(full_name: &str) -> &'static str {
                     "perm.pk16.b4.u4" => "__builtin_amdgcn_perm_pk16_b4_u4",
                     "perm.pk16.b6.u4" => "__builtin_amdgcn_perm_pk16_b6_u4",
                     "perm.pk16.b8.u4" => "__builtin_amdgcn_perm_pk16_b8_u4",
-                    "permlane.bcast" => "__builtin_amdgcn_permlane_bcast",
-                    "permlane.down" => "__builtin_amdgcn_permlane_down",
                     "permlane.idx.gen" => "__builtin_amdgcn_permlane_idx_gen",
-                    "permlane.up" => "__builtin_amdgcn_permlane_up",
-                    "permlane.xor" => "__builtin_amdgcn_permlane_xor",
                     "permlane16.var" => "__builtin_amdgcn_permlane16_var",
                     "permlanex16.var" => "__builtin_amdgcn_permlanex16_var",
                     "pk.add.max.i16" => "__builtin_amdgcn_pk_add_max_i16",
@@ -375,6 +374,9 @@ fn map_arch_intrinsic(full_name: &str) -> &'static str {
                     "prng.b32" => "__builtin_amdgcn_prng_b32",
                     "qsad.pk.u16.u8" => "__builtin_amdgcn_qsad_pk_u16_u8",
                     "queue.ptr" => "__builtin_amdgcn_queue_ptr",
+                    "raw.ptr.buffer.load.async.lds" => {
+                        "__builtin_amdgcn_raw_ptr_buffer_load_async_lds"
+                    }
                     "raw.ptr.buffer.load.lds" => "__builtin_amdgcn_raw_ptr_buffer_load_lds",
                     "rcp.legacy" => "__builtin_amdgcn_rcp_legacy",
                     "rsq.legacy" => "__builtin_amdgcn_rsq_legacy",
@@ -386,6 +388,7 @@ fn map_arch_intrinsic(full_name: &str) -> &'static str {
                     "s.barrier.signal.isfirst" => "__builtin_amdgcn_s_barrier_signal_isfirst",
                     "s.barrier.signal.var" => "__builtin_amdgcn_s_barrier_signal_var",
                     "s.barrier.wait" => "__builtin_amdgcn_s_barrier_wait",
+                    "s.bitreplicate" => "__builtin_amdgcn_s_bitreplicate",
                     "s.buffer.prefetch.data" => "__builtin_amdgcn_s_buffer_prefetch_data",
                     "s.cluster.barrier" => "__builtin_amdgcn_s_cluster_barrier",
                     "s.dcache.inv" => "__builtin_amdgcn_s_dcache_inv",
@@ -412,6 +415,7 @@ fn map_arch_intrinsic(full_name: &str) -> &'static str {
                     "s.ttracedata" => "__builtin_amdgcn_s_ttracedata",
                     "s.ttracedata.imm" => "__builtin_amdgcn_s_ttracedata_imm",
                     "s.wait.asynccnt" => "__builtin_amdgcn_s_wait_asynccnt",
+                    "s.wait.event" => "__builtin_amdgcn_s_wait_event",
                     "s.wait.event.export.ready" => "__builtin_amdgcn_s_wait_event_export_ready",
                     "s.wait.tensorcnt" => "__builtin_amdgcn_s_wait_tensorcnt",
                     "s.waitcnt" => "__builtin_amdgcn_s_waitcnt",
@@ -462,16 +466,18 @@ fn map_arch_intrinsic(full_name: &str) -> &'static str {
                     "smfmac.i32.16x16x64.i8" => "__builtin_amdgcn_smfmac_i32_16x16x64_i8",
                     "smfmac.i32.32x32x32.i8" => "__builtin_amdgcn_smfmac_i32_32x32x32_i8",
                     "smfmac.i32.32x32x64.i8" => "__builtin_amdgcn_smfmac_i32_32x32x64_i8",
+                    "struct.ptr.buffer.load.async.lds" => {
+                        "__builtin_amdgcn_struct_ptr_buffer_load_async_lds"
+                    }
                     "struct.ptr.buffer.load.lds" => "__builtin_amdgcn_struct_ptr_buffer_load_lds",
                     "sudot4" => "__builtin_amdgcn_sudot4",
                     "sudot8" => "__builtin_amdgcn_sudot8",
                     "tensor.load.to.lds" => "__builtin_amdgcn_tensor_load_to_lds",
-                    "tensor.load.to.lds.d2" => "__builtin_amdgcn_tensor_load_to_lds_d2",
                     "tensor.store.from.lds" => "__builtin_amdgcn_tensor_store_from_lds",
-                    "tensor.store.from.lds.d2" => "__builtin_amdgcn_tensor_store_from_lds_d2",
                     "udot2" => "__builtin_amdgcn_udot2",
                     "udot4" => "__builtin_amdgcn_udot4",
                     "udot8" => "__builtin_amdgcn_udot8",
+                    "wait.asyncmark" => "__builtin_amdgcn_wait_asyncmark",
                     "wave.barrier" => "__builtin_amdgcn_wave_barrier",
                     "wavefrontsize" => "__builtin_amdgcn_wavefrontsize",
                     "workgroup.id.x" => "__builtin_amdgcn_workgroup_id_x",
@@ -4844,7 +4850,11 @@ fn map_arch_intrinsic(full_name: &str) -> &'static str {
                     "add.rn.f" => "__nvvm_add_rn_f",
                     "add.rn.ftz.f" => "__nvvm_add_rn_ftz_f",
                     "add.rn.ftz.sat.f" => "__nvvm_add_rn_ftz_sat_f",
+                    "add.rn.ftz.sat.f16" => "__nvvm_add_rn_ftz_sat_f16",
+                    "add.rn.ftz.sat.v2f16" => "__nvvm_add_rn_ftz_sat_v2f16",
                     "add.rn.sat.f" => "__nvvm_add_rn_sat_f",
+                    "add.rn.sat.f16" => "__nvvm_add_rn_sat_f16",
+                    "add.rn.sat.v2f16" => "__nvvm_add_rn_sat_v2f16",
                     "add.rp.d" => "__nvvm_add_rp_d",
                     "add.rp.f" => "__nvvm_add_rp_f",
                     "add.rp.ftz.f" => "__nvvm_add_rp_ftz_f",
@@ -5063,18 +5073,10 @@ fn map_arch_intrinsic(full_name: &str) -> &'static str {
                     "fma.rn.bf16x2" => "__nvvm_fma_rn_bf16x2",
                     "fma.rn.d" => "__nvvm_fma_rn_d",
                     "fma.rn.f" => "__nvvm_fma_rn_f",
-                    "fma.rn.ftz.bf16" => "__nvvm_fma_rn_ftz_bf16",
-                    "fma.rn.ftz.bf16x2" => "__nvvm_fma_rn_ftz_bf16x2",
                     "fma.rn.ftz.f" => "__nvvm_fma_rn_ftz_f",
-                    "fma.rn.ftz.relu.bf16" => "__nvvm_fma_rn_ftz_relu_bf16",
-                    "fma.rn.ftz.relu.bf16x2" => "__nvvm_fma_rn_ftz_relu_bf16x2",
-                    "fma.rn.ftz.sat.bf16" => "__nvvm_fma_rn_ftz_sat_bf16",
-                    "fma.rn.ftz.sat.bf16x2" => "__nvvm_fma_rn_ftz_sat_bf16x2",
                     "fma.rn.ftz.sat.f" => "__nvvm_fma_rn_ftz_sat_f",
                     "fma.rn.relu.bf16" => "__nvvm_fma_rn_relu_bf16",
                     "fma.rn.relu.bf16x2" => "__nvvm_fma_rn_relu_bf16x2",
-                    "fma.rn.sat.bf16" => "__nvvm_fma_rn_sat_bf16",
-                    "fma.rn.sat.bf16x2" => "__nvvm_fma_rn_sat_bf16x2",
                     "fma.rn.sat.f" => "__nvvm_fma_rn_sat_f",
                     "fma.rp.d" => "__nvvm_fma_rp_d",
                     "fma.rp.f" => "__nvvm_fma_rp_f",
@@ -5195,6 +5197,10 @@ fn map_arch_intrinsic(full_name: &str) -> &'static str {
                     "mul.rn.d" => "__nvvm_mul_rn_d",
                     "mul.rn.f" => "__nvvm_mul_rn_f",
                     "mul.rn.ftz.f" => "__nvvm_mul_rn_ftz_f",
+                    "mul.rn.ftz.sat.f16" => "__nvvm_mul_rn_ftz_sat_f16",
+                    "mul.rn.ftz.sat.v2f16" => "__nvvm_mul_rn_ftz_sat_v2f16",
+                    "mul.rn.sat.f16" => "__nvvm_mul_rn_sat_f16",
+                    "mul.rn.sat.v2f16" => "__nvvm_mul_rn_sat_v2f16",
                     "mul.rp.d" => "__nvvm_mul_rp_d",
                     "mul.rp.f" => "__nvvm_mul_rp_f",
                     "mul.rp.ftz.f" => "__nvvm_mul_rp_ftz_f",
@@ -5827,8 +5833,10 @@ fn map_arch_intrinsic(full_name: &str) -> &'static str {
                     "altivec.vmuleuh" => "__builtin_altivec_vmuleuh",
                     "altivec.vmuleuw" => "__builtin_altivec_vmuleuw",
                     "altivec.vmulhsd" => "__builtin_altivec_vmulhsd",
+                    "altivec.vmulhsh" => "__builtin_altivec_vmulhsh",
                     "altivec.vmulhsw" => "__builtin_altivec_vmulhsw",
                     "altivec.vmulhud" => "__builtin_altivec_vmulhud",
+                    "altivec.vmulhuh" => "__builtin_altivec_vmulhuh",
                     "altivec.vmulhuw" => "__builtin_altivec_vmulhuw",
                     "altivec.vmulosb" => "__builtin_altivec_vmulosb",
                     "altivec.vmulosd" => "__builtin_altivec_vmulosd",
@@ -5912,22 +5920,45 @@ fn map_arch_intrinsic(full_name: &str) -> &'static str {
                     "altivec.vsum4shs" => "__builtin_altivec_vsum4shs",
                     "altivec.vsum4ubs" => "__builtin_altivec_vsum4ubs",
                     "altivec.vsumsws" => "__builtin_altivec_vsumsws",
+                    "altivec.vucmprhb" => "__builtin_altivec_vucmprhb",
+                    "altivec.vucmprhh" => "__builtin_altivec_vucmprhh",
+                    "altivec.vucmprhn" => "__builtin_altivec_vucmprhn",
+                    "altivec.vucmprlb" => "__builtin_altivec_vucmprlb",
+                    "altivec.vucmprlh" => "__builtin_altivec_vucmprlh",
+                    "altivec.vucmprln" => "__builtin_altivec_vucmprln",
                     "altivec.vupkhpx" => "__builtin_altivec_vupkhpx",
                     "altivec.vupkhsb" => "__builtin_altivec_vupkhsb",
                     "altivec.vupkhsh" => "__builtin_altivec_vupkhsh",
+                    "altivec.vupkhsntob" => "__builtin_altivec_vupkhsntob",
                     "altivec.vupkhsw" => "__builtin_altivec_vupkhsw",
+                    "altivec.vupkint4tobf16" => "__builtin_altivec_vupkint4tobf16",
+                    "altivec.vupkint4tofp32" => "__builtin_altivec_vupkint4tofp32",
+                    "altivec.vupkint8tobf16" => "__builtin_altivec_vupkint8tobf16",
+                    "altivec.vupkint8tofp32" => "__builtin_altivec_vupkint8tofp32",
                     "altivec.vupklpx" => "__builtin_altivec_vupklpx",
                     "altivec.vupklsb" => "__builtin_altivec_vupklsb",
                     "altivec.vupklsh" => "__builtin_altivec_vupklsh",
+                    "altivec.vupklsntob" => "__builtin_altivec_vupklsntob",
                     "altivec.vupklsw" => "__builtin_altivec_vupklsw",
                     "amo.ldat" => "__builtin_amo_ldat",
+                    "amo.ldat.cond" => "__builtin_amo_ldat_cond",
+                    "amo.ldat.csne" => "__builtin_amo_ldat_csne",
                     "amo.lwat" => "__builtin_amo_lwat",
+                    "amo.lwat.cond" => "__builtin_amo_lwat_cond",
+                    "amo.lwat.csne" => "__builtin_amo_lwat_csne",
+                    "amo.stdat" => "__builtin_amo_stdat",
+                    "amo.stwat" => "__builtin_amo_stwat",
                     "bcdadd" => "__builtin_ppc_bcdadd",
                     "bcdadd.p" => "__builtin_ppc_bcdadd_p",
                     "bcdcopysign" => "__builtin_ppc_bcdcopysign",
                     "bcdsetsign" => "__builtin_ppc_bcdsetsign",
+                    "bcdshift" => "__builtin_ppc_bcdshift",
+                    "bcdshiftround" => "__builtin_ppc_bcdshiftround",
                     "bcdsub" => "__builtin_ppc_bcdsub",
                     "bcdsub.p" => "__builtin_ppc_bcdsub_p",
+                    "bcdtruncate" => "__builtin_ppc_bcdtruncate",
+                    "bcdunsignedshift" => "__builtin_ppc_bcdunsignedshift",
+                    "bcdunsignedtruncate" => "__builtin_ppc_bcdunsignedtruncate",
                     "bpermd" => "__builtin_bpermd",
                     "cbcdtd" => "__builtin_cbcdtd",
                     "cbcdtdd" => "__builtin_ppc_cbcdtd",
@@ -6126,6 +6157,27 @@ fn map_arch_intrinsic(full_name: &str) -> &'static str {
                     "vsx.xxinsertw" => "__builtin_vsx_xxinsertw",
                     "vsx.xxleqv" => "__builtin_vsx_xxleqv",
                     "vsx.xxpermx" => "__builtin_vsx_xxpermx",
+                    "xsaddaddsuqm" => "__builtin_xsaddaddsuqm",
+                    "xsaddadduqm" => "__builtin_xsaddadduqm",
+                    "xsaddsubsuqm" => "__builtin_xsaddsubsuqm",
+                    "xsaddsubuqm" => "__builtin_xsaddsubuqm",
+                    "xsmerge2t1uqm" => "__builtin_xsmerge2t1uqm",
+                    "xsmerge2t2uqm" => "__builtin_xsmerge2t2uqm",
+                    "xsmerge2t3uqm" => "__builtin_xsmerge2t3uqm",
+                    "xsmerge3t1uqm" => "__builtin_xsmerge3t1uqm",
+                    "xsrebase2t1uqm" => "__builtin_xsrebase2t1uqm",
+                    "xsrebase2t2uqm" => "__builtin_xsrebase2t2uqm",
+                    "xsrebase2t3uqm" => "__builtin_xsrebase2t3uqm",
+                    "xsrebase2t4uqm" => "__builtin_xsrebase2t4uqm",
+                    "xsrebase3t1uqm" => "__builtin_xsrebase3t1uqm",
+                    "xsrebase3t2uqm" => "__builtin_xsrebase3t2uqm",
+                    "xsrebase3t3uqm" => "__builtin_xsrebase3t3uqm",
+                    "xxmulmul" => "__builtin_xxmulmul",
+                    "xxmulmulhiadd" => "__builtin_xxmulmulhiadd",
+                    "xxmulmulloadd" => "__builtin_xxmulmulloadd",
+                    "xxssumudm" => "__builtin_xxssumudm",
+                    "xxssumudmc" => "__builtin_xxssumudmc",
+                    "xxssumudmcext" => "__builtin_xxssumudmcext",
                     "zoned2packed" => "__builtin_ppc_zoned2packed",
                     _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
@@ -6388,13 +6440,13 @@ fn map_arch_intrinsic(full_name: &str) -> &'static str {
                     // spv
                     "group.memory.barrier.with.group.sync" => "__builtin_spirv_group_barrier",
                     "num.subgroups" => "__builtin_spirv_num_subgroups",
+                    "subgroup.ballot" => "__builtin_spirv_subgroup_ballot",
                     "subgroup.id" => "__builtin_spirv_subgroup_id",
                     "subgroup.local.invocation.id" => {
                         "__builtin_spirv_subgroup_local_invocation_id"
                     }
                     "subgroup.max.size" => "__builtin_spirv_subgroup_max_size",
                     "subgroup.size" => "__builtin_spirv_subgroup_size",
-                    "wave.ballot" => "__builtin_spirv_subgroup_ballot",
                     _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
@@ -8661,10 +8713,6 @@ fn map_arch_intrinsic(full_name: &str) -> &'static str {
                     "bmi.bextr.64" => "__builtin_ia32_bextr_u64",
                     "bmi.bzhi.32" => "__builtin_ia32_bzhi_si",
                     "bmi.bzhi.64" => "__builtin_ia32_bzhi_di",
-                    "bmi.pdep.32" => "__builtin_ia32_pdep_si",
-                    "bmi.pdep.64" => "__builtin_ia32_pdep_di",
-                    "bmi.pext.32" => "__builtin_ia32_pext_si",
-                    "bmi.pext.64" => "__builtin_ia32_pext_di",
                     "cldemote" => "__builtin_ia32_cldemote",
                     "clflushopt" => "__builtin_ia32_clflushopt",
                     "clrssbsy" => "__builtin_ia32_clrssbsy",
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/llvm.rs b/compiler/rustc_codegen_gcc/src/intrinsic/llvm.rs
index 41efe3e8209bf..6ad19d5af095e 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/llvm.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/llvm.rs
@@ -1,5 +1,7 @@
 use std::borrow::Cow;
 
+#[cfg(feature = "master")]
+use gccjit::TypeAttribute;
 use gccjit::{CType, Context, Field, Function, FunctionPtrType, RValue, ToRValue, Type};
 use rustc_codegen_ssa::traits::BuilderMethods;
 
@@ -23,7 +25,7 @@ fn encode_key_128_type<'a, 'gcc, 'tcx>(
         &[field1, field2, field3, field4, field5, field6, field7],
     );
     #[cfg(feature = "master")]
-    encode_type.as_type().set_packed();
+    encode_type.as_type().add_attribute(TypeAttribute::Packed);
     (encode_type.as_type(), field1, field2)
 }
 
@@ -45,7 +47,7 @@ fn encode_key_256_type<'a, 'gcc, 'tcx>(
         &[field1, field2, field3, field4, field5, field6, field7, field8],
     );
     #[cfg(feature = "master")]
-    encode_type.as_type().set_packed();
+    encode_type.as_type().add_attribute(TypeAttribute::Packed);
     (encode_type.as_type(), field1, field2)
 }
 
@@ -58,7 +60,7 @@ fn aes_output_type<'a, 'gcc, 'tcx>(
     let aes_output_type = builder.context.new_struct_type(None, "AesOutput", &[field1, field2]);
     let typ = aes_output_type.as_type();
     #[cfg(feature = "master")]
-    typ.set_packed();
+    typ.add_attribute(TypeAttribute::Packed);
     (typ, field1, field2)
 }
 
@@ -81,7 +83,7 @@ fn wide_aes_output_type<'a, 'gcc, 'tcx>(
         &[field1, field2, field3, field4, field5, field6, field7, field8, field9],
     );
     #[cfg(feature = "master")]
-    aes_output_type.as_type().set_packed();
+    aes_output_type.as_type().add_attribute(TypeAttribute::Packed);
     (aes_output_type.as_type(), field1, field2)
 }
 
@@ -478,6 +480,26 @@ pub fn adjust_intrinsic_arguments<'a, 'b, 'gcc, 'tcx>(
                 new_args.push(variable.get_address(None));
                 args = new_args.into();
             }
+            "__builtin_ia32_2intersectd128"
+            | "__builtin_ia32_2intersectq128"
+            | "__builtin_ia32_2intersectd256"
+            | "__builtin_ia32_2intersectq256"
+            | "__builtin_ia32_2intersectd512"
+            | "__builtin_ia32_2intersectq512" => {
+                let old_args = args.to_vec();
+                let mut new_args = vec![];
+                let arg1_type = gcc_func.get_param_type(0);
+                let first_mask =
+                    builder.current_func().new_local(None, arg1_type, "return_2intersect_arg1");
+                let arg2_type = gcc_func.get_param_type(1);
+                let second_mask =
+                    builder.current_func().new_local(None, arg2_type, "return_2intersect_arg2");
+                new_args.push(first_mask.get_address(None));
+                new_args.push(second_mask.get_address(None));
+                new_args.push(old_args[0]);
+                new_args.push(old_args[1]);
+                args = new_args.into();
+            }
             "__builtin_ia32_vpermt2varqi512_mask"
             | "__builtin_ia32_vpermt2varqi256_mask"
             | "__builtin_ia32_vpermt2varqi128_mask"
@@ -489,6 +511,23 @@ pub fn adjust_intrinsic_arguments<'a, 'b, 'gcc, 'tcx>(
                 let minus_one = builder.context.new_rvalue_from_int(arg4_type, -1);
                 args = vec![new_args[1], new_args[0], new_args[2], minus_one].into();
             }
+            "__builtin_ia32_fpclassph128_mask"
+            | "__builtin_ia32_fpclassph256_mask"
+            | "__builtin_ia32_fpclassph512_mask"
+            | "__builtin_ia32_fpclasspd128_mask"
+            | "__builtin_ia32_fpclassps128_mask"
+            | "__builtin_ia32_fpclasspd256_mask"
+            | "__builtin_ia32_fpclassps256_mask"
+            | "__builtin_ia32_fpclasspd512_mask"
+            | "__builtin_ia32_fpclassps512_mask"
+            | "__builtin_ia32_vpshufbitqmb128_mask"
+            | "__builtin_ia32_vpshufbitqmb256_mask"
+            | "__builtin_ia32_vpshufbitqmb512_mask" => {
+                let new_args = args.to_vec();
+                let arg3_type = gcc_func.get_param_type(2);
+                let minus_one = builder.context.new_rvalue_from_int(arg3_type, -1);
+                args = vec![new_args[0], new_args[1], minus_one].into();
+            }
             "__builtin_ia32_xrstor"
             | "__builtin_ia32_xrstor64"
             | "__builtin_ia32_xsavec"
@@ -840,7 +879,7 @@ pub fn adjust_intrinsic_return_value<'a, 'gcc, 'tcx>(
         "__builtin_ia32_rdrand64_step" => {
             let random_number = args[0].dereference(None).to_rvalue();
             let success_variable =
-                builder.current_func().new_local(None, return_value.get_type(), "success");
+                builder.new_temp(builder.current_func(), None, return_value.get_type());
             builder.llbb().add_assignment(None, success_variable, return_value);
 
             let field1 = builder.context.new_field(None, random_number.get_type(), "random_number");
@@ -854,6 +893,25 @@ pub fn adjust_intrinsic_return_value<'a, 'gcc, 'tcx>(
                 &[random_number, success_variable.to_rvalue()],
             );
         }
+        "__builtin_ia32_2intersectd128"
+        | "__builtin_ia32_2intersectq128"
+        | "__builtin_ia32_2intersectd256"
+        | "__builtin_ia32_2intersectq256"
+        | "__builtin_ia32_2intersectd512"
+        | "__builtin_ia32_2intersectq512" => {
+            let first_mask = args[0].dereference(None).to_rvalue();
+            let second_mask = args[1].dereference(None).to_rvalue();
+            let field1 = builder.context.new_field(None, first_mask.get_type(), "first_mask");
+            let field2 = builder.context.new_field(None, second_mask.get_type(), "second_mask");
+            let struct_type =
+                builder.context.new_struct_type(None, "vp2intersect_result", &[field1, field2]);
+            return_value = builder.context.new_struct_constructor(
+                None,
+                struct_type.as_type(),
+                None,
+                &[first_mask, second_mask],
+            );
+        }
         "fma" => {
             let f16_type = builder.context.new_c_type(CType::Float16);
             return_value = builder.context.new_cast(None, return_value, f16_type);
@@ -1182,6 +1240,9 @@ pub fn intrinsic<'gcc, 'tcx>(name: &str, cx: &CodegenCx<'gcc, 'tcx>) -> Function
         "llvm.x86.avx512.mask.vpshufbitqmb.512" => "__builtin_ia32_vpshufbitqmb512_mask",
         "llvm.x86.avx512.mask.vpshufbitqmb.256" => "__builtin_ia32_vpshufbitqmb256_mask",
         "llvm.x86.avx512.mask.vpshufbitqmb.128" => "__builtin_ia32_vpshufbitqmb128_mask",
+        "llvm.x86.avx512.vpshufbitqmb.512" => "__builtin_ia32_vpshufbitqmb512_mask",
+        "llvm.x86.avx512.vpshufbitqmb.256" => "__builtin_ia32_vpshufbitqmb256_mask",
+        "llvm.x86.avx512.vpshufbitqmb.128" => "__builtin_ia32_vpshufbitqmb128_mask",
         "llvm.x86.avx512.mask.ucmp.w.512" => "__builtin_ia32_ucmpw512_mask",
         "llvm.x86.avx512.mask.ucmp.w.256" => "__builtin_ia32_ucmpw256_mask",
         "llvm.x86.avx512.mask.ucmp.w.128" => "__builtin_ia32_ucmpw128_mask",
@@ -1339,11 +1400,20 @@ pub fn intrinsic<'gcc, 'tcx>(name: &str, cx: &CodegenCx<'gcc, 'tcx>) -> Function
         "llvm.x86.avx512bf16.cvtne2ps2bf16.128" => "__builtin_ia32_cvtne2ps2bf16_v8bf",
         "llvm.x86.avx512bf16.cvtne2ps2bf16.256" => "__builtin_ia32_cvtne2ps2bf16_v16bf",
         "llvm.x86.avx512bf16.cvtne2ps2bf16.512" => "__builtin_ia32_cvtne2ps2bf16_v32bf",
+        "llvm.x86.vcvtneps2bf16128" => "__builtin_ia32_cvtneps2bf16_v4sf",
+        "llvm.x86.vcvtneps2bf16256" => "__builtin_ia32_cvtneps2bf16_v8sf",
+        "llvm.x86.avx512bf16.mask.cvtneps2bf16.128" => "__builtin_ia32_cvtneps2bf16_v4sf_mask",
         "llvm.x86.avx512bf16.cvtneps2bf16.256" => "__builtin_ia32_cvtneps2bf16_v8sf",
         "llvm.x86.avx512bf16.cvtneps2bf16.512" => "__builtin_ia32_cvtneps2bf16_v16sf",
         "llvm.x86.avx512bf16.dpbf16ps.128" => "__builtin_ia32_dpbf16ps_v4sf",
         "llvm.x86.avx512bf16.dpbf16ps.256" => "__builtin_ia32_dpbf16ps_v8sf",
         "llvm.x86.avx512bf16.dpbf16ps.512" => "__builtin_ia32_dpbf16ps_v16sf",
+        "llvm.x86.avx512.vp2intersect.d.128" => "__builtin_ia32_2intersectd128",
+        "llvm.x86.avx512.vp2intersect.q.128" => "__builtin_ia32_2intersectq128",
+        "llvm.x86.avx512.vp2intersect.d.256" => "__builtin_ia32_2intersectd256",
+        "llvm.x86.avx512.vp2intersect.q.256" => "__builtin_ia32_2intersectq256",
+        "llvm.x86.avx512.vp2intersect.d.512" => "__builtin_ia32_2intersectd512",
+        "llvm.x86.avx512.vp2intersect.q.512" => "__builtin_ia32_2intersectq512",
         "llvm.x86.pclmulqdq.512" => "__builtin_ia32_vpclmulqdq_v8di",
         "llvm.x86.pclmulqdq.256" => "__builtin_ia32_vpclmulqdq_v4di",
         "llvm.x86.avx512.pmulhu.w.512" => "__builtin_ia32_pmulhuw512_mask",
@@ -1577,38 +1647,79 @@ pub fn intrinsic<'gcc, 'tcx>(name: &str, cx: &CodegenCx<'gcc, 'tcx>) -> Function
         "llvm.x86.avx512.uitofp.round.v4f64.v4i64" => "__builtin_ia32_cvtuqq2pd256_mask",
         "llvm.x86.avx512.uitofp.round.v8f32.v8i64" => "__builtin_ia32_cvtuqq2ps512_mask",
         "llvm.x86.avx512.uitofp.round.v4f32.v4i64" => "__builtin_ia32_cvtuqq2ps256_mask",
+        "llvm.x86.avx512fp16.fpclass.ph.128" => "__builtin_ia32_fpclassph128_mask",
+        "llvm.x86.avx512fp16.mask.cmp.ph.128" => "__builtin_ia32_cmpph128_mask",
+        "llvm.x86.avx512fp16.fpclass.ph.256" => "__builtin_ia32_fpclassph256_mask",
+        "llvm.x86.avx512fp16.fpclass.ph.512" => "__builtin_ia32_fpclassph512_mask",
+        "llvm.x86.avx512fp16.mask.cmp.ph.256" => "__builtin_ia32_cmpph256_mask",
+        "llvm.x86.avx512fp16.mask.cmp.ph.512" => "__builtin_ia32_cmpph512_mask_round",
+        "llvm.x86.avx512.fpclass.pd.128" => "__builtin_ia32_fpclasspd128_mask",
+        "llvm.x86.avx512.fpclass.ps.128" => "__builtin_ia32_fpclassps128_mask",
+        "llvm.x86.avx512.fpclass.pd.256" => "__builtin_ia32_fpclasspd256_mask",
+        "llvm.x86.avx512.fpclass.ps.256" => "__builtin_ia32_fpclassps256_mask",
+        "llvm.x86.avx512.fpclass.pd.512" => "__builtin_ia32_fpclasspd512_mask",
+        "llvm.x86.avx512.fpclass.ps.512" => "__builtin_ia32_fpclassps512_mask",
 
         // FIXME: support the tile builtins:
         "llvm.x86.ldtilecfg" => "__builtin_trap",
         "llvm.x86.sttilecfg" => "__builtin_trap",
         "llvm.x86.tileloadd64" => "__builtin_trap",
+        "llvm.x86.tileloadd64.internal" => "__builtin_trap",
         "llvm.x86.tilerelease" => "__builtin_trap",
         "llvm.x86.tilestored64" => "__builtin_trap",
+        "llvm.x86.tilestored64.internal" => "__builtin_trap",
         "llvm.x86.tileloaddrs64" => "__builtin_trap",
+        "llvm.x86.tileloaddrs64.internal" => "__builtin_trap",
         "llvm.x86.tileloaddt164" => "__builtin_trap",
+        "llvm.x86.tileloaddt164.internal" => "__builtin_trap",
         "llvm.x86.tileloaddrst164" => "__builtin_trap",
+        "llvm.x86.tileloaddrst164.internal" => "__builtin_trap",
         "llvm.x86.tilezero" => "__builtin_trap",
+        "llvm.x86.tilezero.internal" => "__builtin_trap",
         "llvm.x86.tilemovrow" => "__builtin_trap",
+        "llvm.x86.tilemovrow.internal" => "__builtin_trap",
         "llvm.x86.tilemovrowi" => "__builtin_trap",
         "llvm.x86.tdpbhf8ps" => "__builtin_trap",
+        "llvm.x86.tdpbhf8ps.internal" => "__builtin_trap",
         "llvm.x86.tdphbf8ps" => "__builtin_trap",
+        "llvm.x86.tdphbf8ps.internal" => "__builtin_trap",
         "llvm.x86.tdpbf8ps" => "__builtin_trap",
+        "llvm.x86.tdpbf8ps.internal" => "__builtin_trap",
         "llvm.x86.tdphf8ps" => "__builtin_trap",
+        "llvm.x86.tdphf8ps.internal" => "__builtin_trap",
         "llvm.x86.tdpbf16ps" => "__builtin_trap",
+        "llvm.x86.tdpbf16ps.internal" => "__builtin_trap",
         "llvm.x86.tdpbssd" => "__builtin_trap",
+        "llvm.x86.tdpbssd.internal" => "__builtin_trap",
         "llvm.x86.tdpbsud" => "__builtin_trap",
+        "llvm.x86.tdpbsud.internal" => "__builtin_trap",
         "llvm.x86.tdpbusd" => "__builtin_trap",
+        "llvm.x86.tdpbusd.internal" => "__builtin_trap",
         "llvm.x86.tdpbuud" => "__builtin_trap",
+        "llvm.x86.tdpbuud.internal" => "__builtin_trap",
         "llvm.x86.tdpfp16ps" => "__builtin_trap",
+        "llvm.x86.tdpfp16ps.internal" => "__builtin_trap",
         "llvm.x86.tmmultf32ps" => "__builtin_trap",
+        "llvm.x86.tmmultf32ps.internal" => "__builtin_trap",
         "llvm.x86.tcvtrowps2phh" => "__builtin_trap",
+        "llvm.x86.tcvtrowps2phh.internal" => "__builtin_trap",
         "llvm.x86.tcvtrowps2phl" => "__builtin_trap",
+        "llvm.x86.tcvtrowps2phl.internal" => "__builtin_trap",
         "llvm.x86.tcvtrowd2ps" => "__builtin_trap",
+        "llvm.x86.tcvtrowd2ps.internal" => "__builtin_trap",
         "llvm.x86.tcvtrowd2psi" => "__builtin_trap",
         "llvm.x86.tcvtrowps2phhi" => "__builtin_trap",
         "llvm.x86.tcvtrowps2phli" => "__builtin_trap",
+        "llvm.x86.tcvtrowps2bf16h" => "__builtin_trap",
+        "llvm.x86.tcvtrowps2bf16h.internal" => "__builtin_trap",
+        "llvm.x86.tcvtrowps2bf16hi" => "__builtin_trap",
+        "llvm.x86.tcvtrowps2bf16l" => "__builtin_trap",
+        "llvm.x86.tcvtrowps2bf16l.internal" => "__builtin_trap",
+        "llvm.x86.tcvtrowps2bf16li" => "__builtin_trap",
         "llvm.x86.tcmmimfp16ps" => "__builtin_trap",
+        "llvm.x86.tcmmimfp16ps.internal" => "__builtin_trap",
         "llvm.x86.tcmmrlfp16ps" => "__builtin_trap",
+        "llvm.x86.tcmmrlfp16ps.internal" => "__builtin_trap",
 
         // NOTE: this file is generated by https://github.com/GuillaumeGomez/llvmint/blob/master/generate_list.py
         _ => map_arch_intrinsic(name),
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
index 09ad3254e5714..bbf5acf702e21 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
@@ -4,7 +4,7 @@ mod simd;
 #[cfg(feature = "master")]
 use std::iter;
 
-use gccjit::{ComparisonOp, Function, FunctionType, RValue, ToRValue, Type, UnaryOp};
+use gccjit::{CType, ComparisonOp, Function, FunctionType, RValue, ToRValue, Type, UnaryOp};
 use rustc_abi::{Align, BackendRepr, HasDataLayout, WrappingRange};
 use rustc_codegen_ssa::base::wants_msvc_seh;
 use rustc_codegen_ssa::common::IntPredicate;
@@ -95,7 +95,6 @@ fn get_simple_intrinsic<'gcc, 'tcx>(
         sym::floorf64 => "floor",
         sym::ceilf32 => "ceilf",
         sym::ceilf64 => "ceil",
-        sym::powf128 => return float_intrinsic(cx, cx.type_f128(), "powf128"),
         sym::truncf32 => "truncf",
         sym::truncf64 => "trunc",
         // We match the LLVM backend and lower this to `rint`.
@@ -118,12 +117,7 @@ fn get_simple_function_f128<'gcc, 'tcx>(
     let func_name = match name {
         sym::ceilf128 => "ceilf128",
         sym::fabs => "fabsf128",
-        sym::expf128 => "expf128",
-        sym::exp2f128 => "exp2f128",
         sym::floorf128 => "floorf128",
-        sym::logf128 => "logf128",
-        sym::log2f128 => "log2f128",
-        sym::log10f128 => "log10f128",
         sym::truncf128 => "truncf128",
         sym::roundf128 => "roundf128",
         sym::round_ties_even_f128 => "roundevenf128",
@@ -167,15 +161,8 @@ fn f16_builtin<'gcc, 'tcx>(
     let builtin_name = match name {
         sym::ceilf16 => "__builtin_ceilf",
         sym::copysignf16 => "__builtin_copysignf",
-        sym::expf16 => "expf",
-        sym::exp2f16 => "exp2f",
-        sym::fabs => "fabsf",
         sym::floorf16 => "__builtin_floorf",
         sym::fmaf16 => "fmaf",
-        sym::logf16 => "logf",
-        sym::log2f16 => "log2f",
-        sym::log10f16 => "log10f",
-        sym::powf16 => "__builtin_powf",
         sym::roundf16 => "__builtin_roundf",
         sym::round_ties_even_f16 => "__builtin_rintf",
         sym::sqrtf16 => "__builtin_sqrtf",
@@ -210,14 +197,11 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
         let simple = get_simple_intrinsic(self, name);
 
         let value = match name {
-            _ if simple.is_some() => {
-                let func = simple.expect("simple intrinsic function");
-                self.cx.context.new_call(
-                    self.location,
-                    func,
-                    &args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(),
-                )
-            }
+            _ if let Some(func) = simple => self.cx.context.new_call(
+                self.location,
+                func,
+                &args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(),
+            ),
             // FIXME(antoyo): We can probably remove these and use the fallback intrinsic implementation.
             sym::minimumf32 | sym::minimumf64 | sym::maximumf32 | sym::maximumf64 => {
                 let (ty, func_name) = match name {
@@ -246,14 +230,8 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
             }
             sym::ceilf16
             | sym::copysignf16
-            | sym::expf16
-            | sym::exp2f16
             | sym::floorf16
             | sym::fmaf16
-            | sym::logf16
-            | sym::log2f16
-            | sym::log10f16
-            | sym::powf16
             | sym::roundf16
             | sym::round_ties_even_f16
             | sym::sqrtf16
@@ -264,11 +242,6 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
             | sym::roundf128
             | sym::round_ties_even_f128
             | sym::sqrtf128
-            | sym::expf128
-            | sym::exp2f128
-            | sym::logf128
-            | sym::log2f128
-            | sym::log10f128
                 if self.cx.supports_f128_type =>
             {
                 let func = get_simple_function_f128(span, self, name);
@@ -363,7 +336,9 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
                 unimplemented!();
             }
             sym::va_arg => {
-                unimplemented!();
+                let va_list = args[0].immediate();
+                let gcc_type = self.immediate_backend_type(result.layout);
+                self.va_arg(va_list, gcc_type)
             }
 
             sym::volatile_load | sym::unaligned_volatile_load => {
@@ -613,7 +588,7 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
 
                 self.on_stack_function_params.borrow_mut().insert(func, FxHashSet::default());
 
-                crate::attributes::from_fn_attrs(self, func, instance);
+                crate::attributes::from_fn_attrs(self, func, instance, None);
 
                 func
             };
@@ -692,8 +667,18 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
         self.context.new_rvalue_from_int(self.int_type, 0)
     }
 
-    fn va_start(&mut self, _va_list: RValue<'gcc>) {
-        unimplemented!();
+    fn va_start(&mut self, va_list: RValue<'gcc>) {
+        let func = self.context.get_builtin_function("__builtin_va_start");
+
+        let va_list_type = self.context.new_c_type(CType::VaList);
+        let va_list = self.context.new_cast(self.location, va_list, va_list_type.make_pointer());
+
+        // Pre-C23 requires that the last "normal" argument was passed to va_start.
+        // Just pass 0, this appears to be handled correctly.
+        let last_normal_arg = self.context.new_rvalue_from_int(self.int_type, 0);
+
+        let call = self.context.new_call(self.location, func, &[va_list, last_normal_arg]);
+        self.block.add_eval(self.location, call);
     }
 
     fn retag_reg(&mut self, _ptr: Self::Value, _info: &RetagInfo<Self::Value>) -> Self::Value {
@@ -951,7 +936,7 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
         let else_block = func.new_block("else");
         let after_block = func.new_block("after");
 
-        let result = func.new_local(None, self.u32_type, "zeros");
+        let result = self.new_temp(func, None, self.u32_type);
         let zero = self.cx.gcc_zero(arg.get_type());
         let cond = self.gcc_icmp(IntPredicate::IntEQ, arg, zero);
         self.llbb().end_with_conditional(None, cond, then_block, else_block);
@@ -1032,7 +1017,7 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
             // else call it on the 64 high bits and add 64. In the else case, 64 high bits can't be 0
             // because arg is not 0.
 
-            let result = self.current_func().new_local(None, result_type, "count_zeroes_results");
+            let result = self.new_temp(self.current_func(), None, result_type);
 
             let cz_then_block = self.current_func().new_block("cz_then");
             let cz_else_block = self.current_func().new_block("cz_else");
@@ -1147,8 +1132,8 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
         let loop_tail = func.new_block("tail");
 
         let counter_type = self.int_type;
-        let counter = self.current_func().new_local(None, counter_type, "popcount_counter");
-        let val = self.current_func().new_local(None, value_type, "popcount_value");
+        let counter = self.new_temp(self.current_func(), None, counter_type);
+        let val = self.new_temp(self.current_func(), None, value_type);
         let zero = self.gcc_zero(counter_type);
         self.llbb().add_assignment(self.location, counter, zero);
         self.llbb().add_assignment(self.location, val, value);
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/old_archs.rs b/compiler/rustc_codegen_gcc/src/intrinsic/old_archs.rs
index 8d3e3487b5cb4..1aac52c28d220 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/old_archs.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/old_archs.rs
@@ -1240,6 +1240,10 @@ pub(crate) fn old_archs(arch: &str, name: &str) -> ArchCheckResult {
             "avx512.vbroadcast.sd.pd.512" => "__builtin_ia32_vbroadcastsd_pd512",
             "avx512.vbroadcast.ss.512" => "__builtin_ia32_vbroadcastss512",
             "avx512.vbroadcast.ss.ps.512" => "__builtin_ia32_vbroadcastss_ps512",
+            "bmi.pdep.32" => "__builtin_ia32_pdep_si",
+            "bmi.pdep.64" => "__builtin_ia32_pdep_di",
+            "bmi.pext.32" => "__builtin_ia32_pext_si",
+            "bmi.pext.64" => "__builtin_ia32_pext_di",
             "fma.mask.vfmadd.pd.512" => "__builtin_ia32_vfmaddpd512_mask",
             "fma.mask.vfmadd.ps.512" => "__builtin_ia32_vfmaddps512_mask",
             "fma.mask.vfmaddsub.pd.512" => "__builtin_ia32_vfmaddsubpd512_mask",
diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
index 55c721a9706a6..436f8a1176300 100644
--- a/compiler/rustc_codegen_gcc/src/lib.rs
+++ b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -76,9 +76,9 @@ use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 
-use gccjit::{CType, Context, OptimizationLevel};
 #[cfg(feature = "master")]
-use gccjit::{TargetInfo, Version};
+use gccjit::TargetInfo;
+use gccjit::{CType, Context, OptimizationLevel};
 use rustc_ast::expand::allocator::AllocatorMethod;
 use rustc_codegen_ssa::back::lto::ThinModule;
 use rustc_codegen_ssa::back::write::{
@@ -97,7 +97,7 @@ use rustc_middle::util::Providers;
 use rustc_session::Session;
 use rustc_session::config::{OptLevel, OutputFilenames};
 use rustc_span::{Symbol, sym};
-use rustc_target::spec::{Arch, RelocModel};
+use rustc_target::spec::RelocModel;
 use tempfile::TempDir;
 
 use crate::back::lto::ModuleBuffer;
@@ -197,8 +197,10 @@ impl CodegenBackend for GccCodegenBackend {
 
     fn init(&self, sess: &Session) {
         fn file_path(sysroot_path: &Path, sess: &Session) -> PathBuf {
-            let rustlib_path =
-                rustc_target::relative_target_rustlib_path(sysroot_path, &sess.host.llvm_target);
+            let rustlib_path = rustc_target::relative_target_rustlib_path(
+                sysroot_path,
+                rustc_session::config::host_tuple(),
+            );
             sysroot_path
                 .join(rustlib_path)
                 .join("codegen-backends")
@@ -315,27 +317,6 @@ impl CodegenBackend for GccCodegenBackend {
     }
 }
 
-fn new_context<'gcc, 'tcx>(tcx: TyCtxt<'tcx>) -> Context<'gcc> {
-    let context = Context::default();
-    if matches!(tcx.sess.target.arch, Arch::X86 | Arch::X86_64) {
-        context.add_command_line_option("-masm=intel");
-    }
-    #[cfg(feature = "master")]
-    {
-        context.set_special_chars_allowed_in_func_names("$.*");
-        let version = Version::get();
-        let version = format!("{}.{}.{}", version.major, version.minor, version.patch);
-        context.set_output_ident(&format!(
-            "rustc version {} with libgccjit {}",
-            rustc_interface::util::rustc_version_str().unwrap_or("unknown version"),
-            version,
-        ));
-    }
-    // FIXME(antoyo): check if this should only be added when using -Cforce-unwind-tables=n.
-    context.add_command_line_option("-fno-asynchronous-unwind-tables");
-    context
-}
-
 impl ExtraBackendMethods for GccCodegenBackend {
     type Module = GccContext;
 
@@ -347,7 +328,7 @@ impl ExtraBackendMethods for GccCodegenBackend {
     ) -> Self::Module {
         let lto_supported = self.lto_supported.load(Ordering::SeqCst);
         let mut mods = GccContext {
-            context: Arc::new(SyncContext::new(new_context(tcx))),
+            context: Arc::new(SyncContext::new(gcc_util::new_context(tcx.sess))),
             relocation_model: tcx.sess.relocation_model(),
             lto_mode: LtoMode::None,
             lto_supported,
@@ -444,7 +425,7 @@ impl WriteBackendMethods for GccCodegenBackend {
         each_linked_rlib_for_lto: &[PathBuf],
         modules: Vec<FatLtoInput<Self>>,
     ) -> CompiledModule {
-        back::lto::run_fat(cgcx, &sess.prof, shared_emitter, each_linked_rlib_for_lto, modules)
+        back::lto::run_fat(sess, cgcx, shared_emitter, each_linked_rlib_for_lto, modules)
     }
 
     fn run_thin_lto(
diff --git a/compiler/rustc_codegen_gcc/src/mono_item.rs b/compiler/rustc_codegen_gcc/src/mono_item.rs
index d5874779021d2..7513978b12272 100644
--- a/compiler/rustc_codegen_gcc/src/mono_item.rs
+++ b/compiler/rustc_codegen_gcc/src/mono_item.rs
@@ -1,11 +1,12 @@
+use gccjit::Function;
 #[cfg(feature = "master")]
-use gccjit::{FnAttribute, VarAttribute};
+use gccjit::{FnAttribute, LValue, ToRValue, VarAttribute};
 use rustc_codegen_ssa::traits::PreDefineCodegenMethods;
 use rustc_hir::attrs::Linkage;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_middle::bug;
-use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
+use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, CodegenFnAttrs};
 use rustc_middle::mono::Visibility;
 use rustc_middle::ty::layout::{FnAbiOf, HasTypingEnv, LayoutOf};
 use rustc_middle::ty::{self, Instance, TypeVisitableExt};
@@ -21,7 +22,7 @@ impl<'gcc, 'tcx> PreDefineCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         def_id: DefId,
         _linkage: Linkage,
         visibility: Visibility,
-        symbol_name: &str,
+        global_name: &str,
     ) {
         let attrs = self.tcx.codegen_fn_attrs(def_id);
         let instance = Instance::mono(self.tcx, def_id);
@@ -33,11 +34,20 @@ impl<'gcc, 'tcx> PreDefineCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         let gcc_type = self.layout_of(ty).gcc_type(self);
 
         let is_tls = attrs.flags.contains(CodegenFnAttrFlags::THREAD_LOCAL);
-        let global = self.define_global(symbol_name, gcc_type, is_tls, attrs.link_section);
+
+        let create_global = |this: &CodegenCx<'gcc, 'tcx>, name: &str, visibility: Visibility| {
+            let global = this.define_global(name, gcc_type, is_tls, attrs.link_section);
+            #[cfg(feature = "master")]
+            global.add_attribute(VarAttribute::Visibility(base::visibility_to_gcc(visibility)));
+            // FIXME(antoyo): set linkage.
+            global
+        };
+        let global = create_global(self, global_name, visibility);
+
+        let attrs = self.tcx.codegen_instance_attrs(instance.def);
         #[cfg(feature = "master")]
-        global.add_attribute(VarAttribute::Visibility(base::visibility_to_gcc(visibility)));
+        self.add_static_aliases(&attrs.foreign_item_symbol_aliases, global_name, &create_global);
 
-        // FIXME(antoyo): set linkage.
         self.instances.borrow_mut().insert(instance, global);
     }
 
@@ -50,12 +60,98 @@ impl<'gcc, 'tcx> PreDefineCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
     ) {
         assert!(!instance.args.has_infer());
 
+        let attrs = self.tcx.codegen_instance_attrs(instance.def);
+
+        let decl =
+            self.predefine_without_aliases(instance, &attrs, linkage, visibility, symbol_name);
+
+        #[cfg(feature = "master")]
+        self.add_function_aliases(instance, decl, &attrs, &attrs.foreign_item_symbol_aliases);
+
+        self.functions.borrow_mut().insert(symbol_name.to_string(), decl);
+        self.function_instances.borrow_mut().insert(instance, decl);
+    }
+}
+
+impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
+    #[cfg(feature = "master")]
+    fn add_static_aliases<F>(
+        &self,
+        aliases: &[(DefId, Linkage, Visibility)],
+        aliased: &str,
+        create_global: &F,
+    ) where
+        F: Fn(&CodegenCx<'gcc, 'tcx>, &str, Visibility) -> LValue<'gcc>,
+    {
+        for &(alias, _linkage, visibility) in aliases {
+            let instance = Instance::mono(self.tcx, alias);
+            let symbol_name = self.tcx.symbol_name(instance);
+
+            let alias = create_global(self, symbol_name.name, visibility);
+            alias.add_attribute(VarAttribute::Alias(aliased));
+
+            // Add the alias name to the set of cached items, so there is no duplicate
+            // instance added to it during the normal `external static` codegen
+            let prev_entry = self.instances.borrow_mut().insert(instance, alias);
+
+            // If there already was a previous entry, then `add_static_aliases` was called multiple times for the same `alias`
+            // which would result in incorrect codegen
+            assert!(prev_entry.is_none(), "An instance was already present for {instance:?}");
+        }
+    }
+
+    #[cfg(feature = "master")]
+    fn add_function_aliases(
+        &self,
+        aliased_instance: Instance<'tcx>,
+        aliased: Function<'gcc>,
+        attrs: &CodegenFnAttrs,
+        aliases: &[(DefId, Linkage, Visibility)],
+    ) {
+        for &(alias, linkage, visibility) in aliases {
+            let symbol_name = self.tcx.symbol_name(Instance::mono(self.tcx, alias));
+
+            // predefine another copy of the original instance
+            // with a new symbol name
+            let alias_fn_decl = self.predefine_without_aliases(
+                aliased_instance,
+                attrs,
+                linkage,
+                visibility,
+                symbol_name.name,
+            );
+
+            let block = alias_fn_decl.new_block("start");
+            let nb_params = alias_fn_decl.get_param_count();
+            let mut args = Vec::with_capacity(nb_params);
+            for idx in 0..nb_params {
+                args.push(alias_fn_decl.get_param(idx as _).to_rvalue());
+            }
+
+            let void_type = self.context.new_type::<()>();
+            let call = self.context.new_call(None, aliased, &args);
+            if alias_fn_decl.get_return_type() == void_type {
+                block.add_eval(None, call);
+                block.end_with_void_return(None);
+            } else {
+                block.end_with_return(None, call);
+            }
+        }
+    }
+
+    fn predefine_without_aliases(
+        &self,
+        instance: Instance<'tcx>,
+        _attrs: &CodegenFnAttrs,
+        linkage: Linkage,
+        visibility: Visibility,
+        symbol_name: &str,
+    ) -> Function<'gcc> {
         let fn_abi = self.fn_abi_of_instance(instance, ty::List::empty());
         self.linkage.set(base::linkage_to_gcc(linkage));
-        let decl = self.declare_fn(symbol_name, fn_abi);
-        //let attrs = self.tcx.codegen_instance_attrs(instance.def);
+        let fn_decl = self.declare_fn(symbol_name, fn_abi);
 
-        attributes::from_fn_attrs(self, decl, instance);
+        attributes::from_fn_attrs(self, fn_decl, instance, Some(fn_abi));
 
         // If we're compiling the compiler-builtins crate, e.g., the equivalent of
         // compiler-rt, then we want to implicitly compile everything with hidden
@@ -63,17 +159,21 @@ impl<'gcc, 'tcx> PreDefineCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         // don't want the symbols to get exported.
         if linkage != Linkage::Internal && self.tcx.is_compiler_builtins(LOCAL_CRATE) {
             #[cfg(feature = "master")]
-            decl.add_attribute(FnAttribute::Visibility(gccjit::Visibility::Hidden));
+            fn_decl.add_attribute(FnAttribute::Visibility(gccjit::Visibility::Hidden));
         } else if visibility != Visibility::Default {
             #[cfg(feature = "master")]
-            decl.add_attribute(FnAttribute::Visibility(base::visibility_to_gcc(visibility)));
+            fn_decl.add_attribute(FnAttribute::Visibility(base::visibility_to_gcc(visibility)));
+        }
+
+        #[cfg(feature = "master")]
+        if let Some(section) = _attrs.link_section {
+            fn_decl.add_attribute(FnAttribute::Section(section.as_str()));
         }
 
-        // FIXME(antoyo): call set_link_section() to allow initializing argc/argv.
         // FIXME(antoyo): set unique comdat.
         // FIXME(antoyo): use inline attribute from there in linkage.set() above.
+        // FIXME: Should we handle dso?
 
-        self.functions.borrow_mut().insert(symbol_name.to_string(), decl);
-        self.function_instances.borrow_mut().insert(instance, decl);
+        fn_decl
     }
 }
diff --git a/compiler/rustc_codegen_gcc/src/type_.rs b/compiler/rustc_codegen_gcc/src/type_.rs
index 5252f93a92ebe..f008be67e39cb 100644
--- a/compiler/rustc_codegen_gcc/src/type_.rs
+++ b/compiler/rustc_codegen_gcc/src/type_.rs
@@ -2,7 +2,7 @@
 use std::convert::TryInto;
 
 #[cfg(feature = "master")]
-use gccjit::CType;
+use gccjit::{CType, TypeAttribute};
 use gccjit::{RValue, Struct, Type};
 use rustc_abi::{AddressSpace, Align, Integer, Size};
 use rustc_codegen_ssa::common::TypeKind;
@@ -116,7 +116,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         let typ = self.context.new_struct_type(None, "struct", &fields).as_type();
         if packed {
             #[cfg(feature = "master")]
-            typ.set_packed();
+            typ.add_attribute(TypeAttribute::Packed);
         }
         self.struct_types.borrow_mut().insert(types, typ);
         typ
@@ -153,7 +153,7 @@ impl<'gcc, 'tcx> BaseTypeCodegenMethods for CodegenCx<'gcc, 'tcx> {
         if self.supports_f16_type {
             return self.context.new_c_type(CType::Float16);
         }
-        bug!("unsupported float width 16")
+        self.u16_type
     }
 
     fn type_f32(&self) -> Type<'gcc> {
@@ -333,7 +333,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         typ.set_fields(None, &fields);
         if packed {
             #[cfg(feature = "master")]
-            typ.as_type().set_packed();
+            typ.as_type().add_attribute(TypeAttribute::Packed);
         }
     }
 
diff --git a/compiler/rustc_codegen_gcc/tests/asm/asm/comments.rs b/compiler/rustc_codegen_gcc/tests/asm/asm/comments.rs
new file mode 100644
index 0000000000000..603bb014930c4
--- /dev/null
+++ b/compiler/rustc_codegen_gcc/tests/asm/asm/comments.rs
@@ -0,0 +1,12 @@
+//@ assembly-output: emit-asm
+//@ only-x86_64
+// Check that comments in assembly get passed
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: "test_comments":
+#[no_mangle]
+pub fn test_comments() {
+    // CHECK: example comment
+    unsafe { core::arch::asm!("nop // example comment") };
+}
diff --git a/compiler/rustc_codegen_gcc/tests/asm/naked-functions/x86_64-naked-fn-no-cet-prolog.rs b/compiler/rustc_codegen_gcc/tests/asm/naked-functions/x86_64-naked-fn-no-cet-prolog.rs
new file mode 100644
index 0000000000000..81ee9b13b4eca
--- /dev/null
+++ b/compiler/rustc_codegen_gcc/tests/asm/naked-functions/x86_64-naked-fn-no-cet-prolog.rs
@@ -0,0 +1,24 @@
+//@ compile-flags: -C no-prepopulate-passes -Zcf-protection=full
+//@ assembly-output: emit-asm
+//@ needs-asm-support
+//@ only-x86_64
+
+#![crate_type = "lib"]
+
+use std::arch::naked_asm;
+
+// The problem at hand: Rust has adopted a fairly strict meaning for "naked functions",
+// meaning "no prologue whatsoever, no, really, not one instruction."
+// Unfortunately, x86's control-flow enforcement, specifically indirect branch protection,
+// works by using an instruction for each possible landing site,
+// and LLVM implements this via making sure of that.
+#[no_mangle]
+#[unsafe(naked)]
+pub extern "sysv64" fn will_halt() -> ! {
+    // CHECK-NOT: endbr{{32|64}}
+    // CHECK: hlt
+    naked_asm!("hlt")
+}
+
+// what about aarch64?
+// "branch-protection"=false
diff --git a/compiler/rustc_codegen_gcc/tests/asm/panic-no-unwind-no-uwtable.rs b/compiler/rustc_codegen_gcc/tests/asm/panic-no-unwind-no-uwtable.rs
new file mode 100644
index 0000000000000..b51b173e9616e
--- /dev/null
+++ b/compiler/rustc_codegen_gcc/tests/asm/panic-no-unwind-no-uwtable.rs
@@ -0,0 +1,8 @@
+//@ assembly-output: emit-asm
+//@ only-x86_64-unknown-linux-gnu
+//@ compile-flags: -C panic=unwind -C force-unwind-tables=n -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-NOT: .cfi_startproc
+pub fn foo() {}
diff --git a/compiler/rustc_codegen_gcc/tests/asm/used.rs b/compiler/rustc_codegen_gcc/tests/asm/used.rs
new file mode 100644
index 0000000000000..deb0c69dc48fa
--- /dev/null
+++ b/compiler/rustc_codegen_gcc/tests/asm/used.rs
@@ -0,0 +1,14 @@
+//@ assembly-output: emit-asm
+//@ only-x86_64-unknown-linux-gnu
+
+#![feature(used_with_arg)]
+#![crate_type = "lib"]
+
+// CHECK: .section	.rodata.X,"a"
+#[used(compiler)]
+#[no_mangle]
+pub static X: u32 = 12;
+// CHECK: .section	.rodata.Y,"aR"
+#[used(linker)]
+#[no_mangle]
+pub static Y: u32 = 12;
diff --git a/compiler/rustc_codegen_gcc/tests/asm/x86_64-sse_crc.rs b/compiler/rustc_codegen_gcc/tests/asm/x86_64-sse_crc.rs
new file mode 100644
index 0000000000000..bde58955a2146
--- /dev/null
+++ b/compiler/rustc_codegen_gcc/tests/asm/x86_64-sse_crc.rs
@@ -0,0 +1,12 @@
+//@ only-x86_64
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type staticlib -Ctarget-feature=+sse4.2
+
+// CHECK-LABEL: banana
+// CHECK: crc32
+#[no_mangle]
+pub unsafe fn banana(v: u8) -> u32 {
+    use std::arch::x86_64::*;
+    let out = !0u32;
+    _mm_crc32_u8(out, v)
+}
diff --git a/compiler/rustc_codegen_gcc/tests/compile/x86_interrupt_first_arg_byval.rs b/compiler/rustc_codegen_gcc/tests/compile/x86_interrupt_first_arg_byval.rs
new file mode 100644
index 0000000000000..4b6bbd48f7ad5
--- /dev/null
+++ b/compiler/rustc_codegen_gcc/tests/compile/x86_interrupt_first_arg_byval.rs
@@ -0,0 +1,16 @@
+// Compiler:
+
+// Test that `x86-interrupt` functions whose first argument is passed by value
+// emit pointer-shaped GCC parameters and compile with interrupt-safe target features.
+
+#![feature(abi_x86_interrupt)]
+#![crate_type = "lib"]
+
+#[repr(C)]
+pub struct Frame {
+    ip: u64,
+}
+
+pub extern "x86-interrupt" fn scalar(_a: i64) {}
+
+pub extern "x86-interrupt" fn aggregate(_frame: Frame) {}
diff --git a/compiler/rustc_codegen_gcc/tests/cpuid.def b/compiler/rustc_codegen_gcc/tests/cpuid.def
new file mode 100644
index 0000000000000..05fe8e94a8282
--- /dev/null
+++ b/compiler/rustc_codegen_gcc/tests/cpuid.def
@@ -0,0 +1,27 @@
+#      Input      =>               Output
+# EAX      ECX    =>   EAX      EBX      ECX      EDX
+00000000 ******** => 00000024 756e6547 6c65746e 49656e69 #Processor ID and Manufacturer
+00000001 ******** => 00400f10 00100800 7ffaf3ff bfebfbff
+00000007 00000000 => 00000002 f3bfbfbf bac05ffe 03d54130 #Extended Features
+00000007 00000001 => 98ee00bf 00000002 00000020 1d29cd3e
+0000000d 00000000 => 000e02e7 00002b00 00002b00 00000000 #xcr0
+0000000d 00000001 => 0000001f 00000240 00000100 00000000 #Supervisor State
+0000000d 00000002 => 00000100 00000240 00000000 00000000
+0000000d 00000005 => 00000040 00000440 00000000 00000000 #zmasks
+0000000d 00000006 => 00000200 00000480 00000000 00000000 #zmmh
+0000000d 00000007 => 00000400 00000680 00000000 00000000 #zmm
+0000000d 00000011 => 00000040 00000ac0 00000002 00000000 #tileconfig
+0000000d 00000012 => 00002000 00000b00 00000006 00000000 #tiles
+0000000d 00000013 => 00000080 000003c0 00000000 00000000 #APX
+00000019 ******** => 00000000 00000005 00000000 00000000 #Key Locker
+0000001d 00000000 => 00000001 00000000 00000000 00000000 #AMX Tile
+0000001d 00000001 => 04002000 00080040 00000010 00000000 #AMX Palette1
+0000001e 00000000 => 00000001 00004010 00000000 00000000 #AMX Tmul
+0000001e 00000001 => 000001ff 00000000 00000000 00000000
+00000024 00000000 => 00000001 00070002 00000000 00000000 #AVX10
+00000024 00000001 => 00000000 00000000 00000004 00000000
+80000000 ******** => 80000004 00000000 00000000 00000000
+80000001 ******** => 00000000 00000000 00000121 2c100000
+80000002 ******** => 00000000 00000000 00000000 00000000
+80000003 ******** => 00000000 00000000 00000000 00000000
+80000004 ******** => 00000000 00000000 00000000 00000000
diff --git a/compiler/rustc_codegen_gcc/tests/failing-lto-tests.txt b/compiler/rustc_codegen_gcc/tests/failing-lto-tests.txt
index 4c62c35a512c1..e98d2aab9361b 100644
--- a/compiler/rustc_codegen_gcc/tests/failing-lto-tests.txt
+++ b/compiler/rustc_codegen_gcc/tests/failing-lto-tests.txt
@@ -4,3 +4,7 @@ tests/ui/uninhabited/uninhabited-transparent-return-abi.rs
 tests/ui/coroutine/panic-drops-resume.rs
 tests/ui/coroutine/panic-drops.rs
 tests/ui/coroutine/panic-safe.rs
+tests/ui/panic-handler/catch-unwind-during-unwind-68696.rs
+tests/ui/threads-sendsync/task-stderr.rs
+tests/ui/extern/issue-64655-allow-unwind-when-calling-panic-directly.rs
+tests/ui/extern/issue-64655-extern-rust-must-allow-unwind.rs
diff --git a/compiler/rustc_codegen_gcc/tests/failing-run-make-tests.txt b/compiler/rustc_codegen_gcc/tests/failing-run-make-tests.txt
index 528ee1df9f583..1feb2c7cc6edc 100644
--- a/compiler/rustc_codegen_gcc/tests/failing-run-make-tests.txt
+++ b/compiler/rustc_codegen_gcc/tests/failing-run-make-tests.txt
@@ -12,3 +12,4 @@ tests/run-make/glibc-staticlib-args/
 tests/run-make/lto-smoke-c/
 tests/run-make/return-non-c-like-enum/
 tests/run-make/short-ice
+tests/run-make/embed-source-dwarf
diff --git a/compiler/rustc_codegen_gcc/tests/failing-ui-tests.txt b/compiler/rustc_codegen_gcc/tests/failing-ui-tests.txt
index e8a26a90890c1..2b2f21904abb5 100644
--- a/compiler/rustc_codegen_gcc/tests/failing-ui-tests.txt
+++ b/compiler/rustc_codegen_gcc/tests/failing-ui-tests.txt
@@ -11,27 +11,22 @@ tests/ui/mir/mir_match_guard_let_chains_drop_order.rs
 tests/ui/panic-runtime/abort-link-to-unwinding-crates.rs
 tests/ui/panic-runtime/abort.rs
 tests/ui/panic-runtime/link-to-abort.rs
-tests/ui/parser/unclosed-delimiter-in-dep.rs
 tests/ui/consts/missing_span_in_backtrace.rs
 tests/ui/drop/dynamic-drop.rs
 tests/ui/simd/issue-17170.rs
 tests/ui/simd/issue-39720.rs
 tests/ui/drop/panic-during-drop-14875.rs
-tests/ui/issues/issue-29948.rs
+tests/ui/drop/move-closure-drop-on-unwind.rs
 tests/ui/process/println-with-broken-pipe.rs
 tests/ui/lto/thin-lto-inlines2.rs
 tests/ui/panic-runtime/lto-abort.rs
 tests/ui/lto/lto-thin-rustc-loads-linker-plugin.rs
 tests/ui/async-await/deep-futures-are-freeze.rs
 tests/ui/coroutine/resume-after-return.rs
-tests/ui/simd/masked-load-store.rs
 tests/ui/simd/repr_packed.rs
 tests/ui/async-await/in-trait/dont-project-to-specializable-projection.rs
 tests/ui/coroutine/unwind-abort-mix.rs
-tests/ui/consts/issue-miri-1910.rs
 tests/ui/consts/const_cmp_type_id.rs
-tests/ui/consts/issue-94675.rs
-tests/ui/traits/const-traits/const-drop-fail.rs
 tests/ui/runtime/on-broken-pipe/child-processes.rs
 tests/ui/sanitizer/cfi/assoc-ty-lifetime-issue-123053.rs
 tests/ui/sanitizer/cfi/async-closures.rs
@@ -47,7 +42,6 @@ tests/ui/sanitizer/cfi/virtual-auto.rs
 tests/ui/sanitizer/cfi/sized-associated-ty.rs
 tests/ui/sanitizer/cfi/can-reveal-opaques.rs
 tests/ui/sanitizer/kcfi-mangling.rs
-tests/ui/delegation/fn-header.rs
 tests/ui/consts/const-eval/parse_ints.rs
 tests/ui/simd/intrinsic/generic-as.rs
 tests/ui/runtime/rt-explody-panic-payloads.rs
@@ -67,47 +61,53 @@ tests/ui/simd/simd-bitmask-notpow2.rs
 tests/ui/codegen/StackColoring-not-blowup-stack-issue-40883.rs
 tests/ui/numbers-arithmetic/u128-as-f32.rs
 tests/ui/process/nofile-limit.rs
-tests/ui/linking/no-gc-encapsulation-symbols.rs
 tests/ui/panics/unwind-force-no-unwind-tables.rs
 tests/ui/attributes/fn-align-dyn.rs
 tests/ui/linkage-attr/raw-dylib/elf/glibc-x86_64.rs
-tests/ui/explicit-tail-calls/recursion-etc.rs
-tests/ui/explicit-tail-calls/indexer.rs
-tests/ui/explicit-tail-calls/drop-order.rs
-tests/ui/c-variadic/valid.rs
-tests/ui/c-variadic/inherent-method.rs
-tests/ui/c-variadic/trait-method.rs
-tests/ui/explicit-tail-calls/become-cast-return.rs
-tests/ui/explicit-tail-calls/become-indirect-return.rs
 tests/ui/panics/panic-abort-backtrace-without-debuginfo.rs
 tests/ui/sanitizer/kcfi-c-variadic.rs
 tests/ui/sanitizer/kcfi/fn-trait-objects.rs
 tests/ui/statics/const_generics.rs
 tests/ui/test-attrs/test-panic-while-printing.rs
 tests/ui/thir-print/offset_of.rs
-tests/ui/iterators/rangefrom-overflow-debug.rs
-tests/ui/iterators/rangefrom-overflow-overflow-checks.rs
 tests/ui/iterators/iter-filter-count-debug-check.rs
-tests/ui/eii/linking/codegen_single_crate.rs
-tests/ui/eii/linking/codegen_cross_crate.rs
-tests/ui/eii/default/local_crate.rs
-tests/ui/eii/duplicate/multiple_impls.rs
-tests/ui/eii/default/call_default.rs
-tests/ui/eii/linking/same-symbol.rs
-tests/ui/eii/privacy1.rs
 tests/ui/eii/default/call_impl.rs
-tests/ui/c-variadic/copy.rs
 tests/ui/asm/x86_64/global_asm_escape.rs
 tests/ui/lto/all-crates.rs
-tests/ui/consts/const-eval/c-variadic.rs
-tests/ui/eii/default/call_default_panics.rs
-tests/ui/explicit-tail-calls/indirect.rs
-tests/ui/traits/inheritance/self-in-supertype.rs
-tests/ui/fmt/fmt_debug/shallow.rs
-tests/ui/c-variadic/roundtrip.rs
-tests/ui/eii/eii_impl_with_contract.rs
 tests/ui/eii/static/cross_crate_decl.rs
 tests/ui/eii/static/cross_crate_def.rs
 tests/ui/eii/static/same_address.rs
 tests/ui/eii/static/simple.rs
-tests/ui/explicit-tail-calls/default-trait-method.rs
+tests/ui/eii/static/default.rs
+tests/ui/eii/static/default_cross_crate.rs
+tests/ui/eii/static/default_explicit.rs
+tests/ui/eii/static/default_cross_crate_explicit.rs
+tests/ui/explicit-tail-calls/tailcc-no-signature-restriction.rs
+tests/ui/abi/rust-tail-cc.rs
+tests/ui/abi/rust-preserve-none-cc.rs
+tests/ui/extern/extern-types-field-offset.rs
+tests/ui/numbers-arithmetic/int-abs-overflow.rs
+tests/ui/numbers-arithmetic/issue-8460.rs
+tests/ui/panics/panic-handler-chain-update-hook.rs
+tests/ui/panics/panic-handler-chain.rs
+tests/ui/panics/panic-handler-set-twice.rs
+tests/ui/panics/panic-recover-propagate.rs
+tests/ui/panics/panic-in-dtor-drops-fields.rs
+tests/ui/panics/panic-handler-flail-wildly.rs
+tests/ui/panics/rvalue-cleanup-during-box-panic.rs
+tests/ui/process/multi-panic.rs
+tests/ui/sepcomp/sepcomp-unwind.rs
+tests/ui/structs/unit-like-struct-drop-run.rs
+tests/ui/threads-sendsync/unwind-resource.rs
+tests/ui/array-slice-vec/box-of-array-of-drop-2.rs
+tests/ui/array-slice-vec/box-of-array-of-drop-1.rs
+tests/ui/array-slice-vec/nested-vec-3.rs
+tests/ui/array-slice-vec/slice-panic-1.rs
+tests/ui/array-slice-vec/slice-panic-2.rs
+tests/ui/backtrace/synchronized-panic-handler.rs
+tests/ui/cross-crate/mut-ref-write-visible-after-unwind.rs
+tests/ui/drop/drop-once-on-panic.rs
+tests/ui/drop/enum-destructor-on-unwind.rs
+tests/ui/drop/drop-trait-enum.rs
+tests/ui/drop/panic-during-slice-init.rs
+tests/ui/drop/terminate-in-initializer.rs
diff --git a/compiler/rustc_codegen_gcc/tests/lang_tests.rs b/compiler/rustc_codegen_gcc/tests/lang_tests.rs
index 6afd54e1c3fe0..f3b4ad34bc9c4 100644
--- a/compiler/rustc_codegen_gcc/tests/lang_tests.rs
+++ b/compiler/rustc_codegen_gcc/tests/lang_tests.rs
@@ -172,6 +172,16 @@ fn build_test_runner(
                 }
             }
 
+            // Extra flags passed at run time (as opposed to the compile-time
+            // `TEST_FLAGS`). This lets a single test opt into flags like
+            // `-Zmir-preserve-ub` via an `ignore-if` directive that checks
+            // whether `CARGO_TEST_FLAGS` is set.
+            if let Ok(flags) = std::env::var("CARGO_TEST_FLAGS") {
+                for flag in flags.split_whitespace() {
+                    compiler_args.push(flag.into());
+                }
+            }
+
             if build_mode.is_debug() {
                 compiler_args
                     .extend_from_slice(&["-C".to_string(), "llvm-args=sanitize-undefined".into()]);
@@ -201,7 +211,13 @@ fn compile_tests(tempdir: PathBuf, current_dir: String) {
         "lang compile",
         "tests/compile",
         TestMode::Compile,
-        &["simd-ffi.rs", "asm_nul_byte.rs", "global_asm_nul_byte.rs", "naked_asm_nul_byte.rs"],
+        &[
+            "simd-ffi.rs",
+            "asm_nul_byte.rs",
+            "global_asm_nul_byte.rs",
+            "naked_asm_nul_byte.rs",
+            "x86_interrupt_first_arg_byval.rs",
+        ],
     );
 }
 
diff --git a/compiler/rustc_codegen_gcc/tests/run/asm.rs b/compiler/rustc_codegen_gcc/tests/run/asm.rs
index 01775c92ffc8a..42141c671b596 100644
--- a/compiler/rustc_codegen_gcc/tests/run/asm.rs
+++ b/compiler/rustc_codegen_gcc/tests/run/asm.rs
@@ -3,6 +3,8 @@
 // Run-time:
 //   status: 0
 
+#![feature(asm_goto_with_outputs)]
+
 #[cfg(target_arch = "x86_64")]
 use std::arch::{asm, global_asm};
 
@@ -32,6 +34,20 @@ pub unsafe fn mem_cpy(dst: *mut u8, src: *const u8, len: usize) {
     );
 }
 
+#[cfg(target_arch = "x86_64")]
+#[unsafe(no_mangle)]
+pub fn asm_goto_test(mut a: i16) -> i16 {
+    unsafe {
+        std::arch::asm!(
+            "jmp {op}",
+            inout("eax") a,
+            op = label { a = 7; },
+            options(nostack,nomem)
+        );
+        a
+    }
+}
+
 #[cfg(target_arch = "x86_64")]
 fn asm() {
     unsafe {
@@ -190,6 +206,14 @@ fn asm() {
     }
     assert_eq!((x, y), (8, 8));
 
+    // Regression test for <https://github.com/rust-lang/rustc_codegen_gcc/issues/792>
+    // typed pointer inputs to explicit registers need a cast.
+    let mut x = 123_i32;
+    unsafe {
+        asm!("", in("rdi") &mut x, options(nostack, preserves_flags));
+    }
+    assert_eq!(x, 123);
+
     // sysv64 is the default calling convention on unix systems. The rdi register is
     // used to pass arguments in the sysv64 calling convention, so this register will be clobbered
     #[cfg(unix)]
@@ -227,6 +251,24 @@ fn asm() {
             out("r15b") _,
         );
     }
+
+    // Make sure the input value from inout is assigned to the input value
+    unsafe {
+        // Use a very distinctive value unlikely to live in any register.
+        let input: u64 = 0x1234567890ABCDEF;
+        let mut output: u64;
+
+        asm!(
+            "push {1}",
+            "pop   {0}",
+            out(reg) output,
+            inout(reg) input => _,
+        );
+
+        assert_eq!(output, 0x1234567890ABCDEF);
+    }
+
+    asm_goto_test(0);
 }
 
 #[cfg(not(target_arch = "x86_64"))]
diff --git a/compiler/rustc_codegen_gcc/tests/run/int.rs b/compiler/rustc_codegen_gcc/tests/run/int.rs
index 78675acb5447b..ef825b4d80185 100644
--- a/compiler/rustc_codegen_gcc/tests/run/int.rs
+++ b/compiler/rustc_codegen_gcc/tests/run/int.rs
@@ -319,4 +319,29 @@ fn main() {
         const VAL5: T = 73236519889708027473620326106273939584_i128;
         check_ops128!();
     }
+
+    {
+        #[allow(dead_code)]
+        #[repr(u8)]
+        enum Inner {
+            L0 = 0,
+            H255 = 255,
+        }
+        #[allow(dead_code)]
+        enum O {
+            A(Inner),
+            B,
+            C,
+        }
+
+        #[inline(never)]
+        fn which(o: &O) -> &'static str {
+            match o {
+                O::A(_) => "a",
+                O::B => "b",
+                O::C => "c",
+            }
+        }
+        assert_eq!(which(black_box(&O::A(Inner::H255))), "a");
+    }
 }
diff --git a/compiler/rustc_codegen_gcc/tests/run/mir_preserve_ub_empty_switch.rs b/compiler/rustc_codegen_gcc/tests/run/mir_preserve_ub_empty_switch.rs
new file mode 100644
index 0000000000000..26056360b9212
--- /dev/null
+++ b/compiler/rustc_codegen_gcc/tests/run/mir_preserve_ub_empty_switch.rs
@@ -0,0 +1,35 @@
+// ignore-if: test -z "$CARGO_TEST_FLAGS"
+// Compiler:
+//
+// Run-time:
+//   status: 0
+
+// Regression test for https://github.com/rust-lang/rustc_codegen_gcc/issues/881
+//
+// This needs `-Zmir-preserve-ub`, so it is skipped unless that flag is passed
+// through `CARGO_TEST_FLAGS` (see the `ignore-if` directive above). Run it with:
+//   CARGO_TEST_FLAGS="-Zmir-preserve-ub" ./y.sh test --cargo-tests -- mir_preserve_ub_empty_switch
+
+#![feature(no_core)]
+#![no_std]
+#![no_core]
+#![no_main]
+
+extern crate mini_core;
+use intrinsics::black_box;
+use mini_core::*;
+
+#[no_mangle]
+extern "C" fn main(argc: i32, _argv: *const *const u8) -> i32 {
+    // With `-Zmir-preserve-ub`, the range pattern below is lowered to a pair of
+    // comparisons and the second one becomes a `SwitchInt` with no cases (only
+    // an `otherwise` target) whose discriminant is the `bool` comparison
+    // result. `gcc_jit_block_end_with_switch` rejects a non-integer
+    // discriminant, so the backend must emit a plain jump for it instead.
+    let value = black_box(argc);
+    match value {
+        0..=9 => (),
+        _ => (),
+    }
+    0
+}
diff --git a/compiler/rustc_codegen_gcc/tools/cspell_dicts/rust.txt b/compiler/rustc_codegen_gcc/tools/cspell_dicts/rust.txt
index 379cbd77eef01..15faacd53d5a0 100644
--- a/compiler/rustc_codegen_gcc/tools/cspell_dicts/rust.txt
+++ b/compiler/rustc_codegen_gcc/tools/cspell_dicts/rust.txt
@@ -1,2 +1,3 @@
 lateout
 repr
+rmeta
diff --git a/compiler/rustc_codegen_gcc/tools/cspell_dicts/rustc_codegen_gcc.txt b/compiler/rustc_codegen_gcc/tools/cspell_dicts/rustc_codegen_gcc.txt
index 4fb018b3ecd87..bae8edc9ffdf9 100644
--- a/compiler/rustc_codegen_gcc/tools/cspell_dicts/rustc_codegen_gcc.txt
+++ b/compiler/rustc_codegen_gcc/tools/cspell_dicts/rustc_codegen_gcc.txt
@@ -60,10 +60,12 @@ nvptx
 pointee
 powitf
 reassoc
+retag
 riscv
 rlib
 roundevenf
 rustc
+sgpr
 sitofp
 sizet
 spir
@@ -74,5 +76,8 @@ uitofp
 unord
 uninlined
 utrunc
+vgpr
 xabort
+xreg
+xtensa
 zext
diff --git a/compiler/rustc_codegen_gcc/tools/generate_intrinsics.py b/compiler/rustc_codegen_gcc/tools/generate_intrinsics.py
index 5390323407779..06425f682a88b 100644
--- a/compiler/rustc_codegen_gcc/tools/generate_intrinsics.py
+++ b/compiler/rustc_codegen_gcc/tools/generate_intrinsics.py
@@ -84,6 +84,10 @@ def update_intrinsics(llvm_path):
     # This speeds up the comparison, and makes our code considerably smaller.
     # Since all intrinsic names start with "llvm.", we skip that prefix.
     print("Updating content of `{}`...".format(output_file))
+    indent4 = "    "
+    indent8 = indent4 + indent4
+    indent12 = indent8 + indent4
+    indent16 = indent12 + indent4
     with open(output_file, "w", encoding="utf8") as out:
         out.write("""// File generated by `rustc_codegen_gcc/tools/generate_intrinsics.py`
 // DO NOT EDIT IT!
@@ -95,33 +99,35 @@ def update_intrinsics(llvm_path):
     if let ArchCheckResult::Ok(res) = old_arch_res {
         return res;
     }
-match arch {""")
+    match arch {
+""")
         for arch in archs:
             if len(intrinsics[arch]) == 0:
                 continue
             attribute = "#[expect(non_snake_case)]" if arch[0].isupper() else ""
-            out.write("\"{}\" => {{ {} fn {}(name: &str,full_name:&str) -> &'static str {{ match name {{".format(arch, attribute, arch))
+            out.write(f"""{indent4}"{arch}" => {{
+{indent8}{attribute} fn {arch}(name: &str,full_name:&str) -> &'static str {{
+{indent12}match name {{""")
             intrinsics[arch].sort(key=lambda x: (x[0], x[1]))
-            out.write('    // {}\n'.format(arch))
+            out.write(f'{indent16}// {arch}\n')
             for entry in intrinsics[arch]:
                 llvm_name = entry[0].removeprefix("llvm.");
                 llvm_name = llvm_name.removeprefix(arch);
                 llvm_name = llvm_name.removeprefix(".");
                 if "_round_mask" in entry[1]:
-                    out.write('    // [INVALID CONVERSION]: "{}" => "{}",\n'.format(llvm_name, entry[1]))
+                    out.write(f'{indent16}// [INVALID CONVERSION]: "{llvm_name}" => "{entry[1]}",\n')
                 else:
-                    out.write('    "{}" => "{}",\n'.format(llvm_name, entry[1]))
-            out.write('    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),\n')
-            out.write("}} }} {}(name,full_name) }}\n,".format(arch))
-        out.write("""    _ => {
-        match old_arch_res {
-            ArchCheckResult::UnknownIntrinsic => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
-            ArchCheckResult::UnknownArch => unimplemented!("***** unsupported LLVM architecture {arch}, intrinsic: {full_name}"),
-            ArchCheckResult::Ok(_) => unreachable!(),
-        }
-    }""")
+                    out.write(f'{indent16}"{llvm_name}" => "{entry[1]}",\n')
+            out.write(f'{indent16}_ => unimplemented!("***** unsupported LLVM intrinsic {{full_name}}"),\n')
+            out.write(f"{indent16}}}\n{indent12}}}\n{indent8}{arch}(name,full_name)\n{indent8}}}\n,")
+        out.write(f"""{indent4}_ => {{
+{indent8}match old_arch_res {{
+{indent8}ArchCheckResult::UnknownIntrinsic => unimplemented!("***** unsupported LLVM intrinsic {{full_name}}"),
+{indent8}ArchCheckResult::UnknownArch => unimplemented!("***** unsupported LLVM architecture {{arch}}, intrinsic: {{full_name}}"),
+{indent8}ArchCheckResult::Ok(_) => unreachable!(),
+{indent4}}}
+}}""")
         out.write("}\n}")
-    subprocess.call(["rustfmt", output_file])
     print("Done!")
 
 
diff --git a/compiler/rustc_target/src/asm/x86.rs b/compiler/rustc_target/src/asm/x86.rs
index 6f0faffa32984..c582c06d8f4bb 100644
--- a/compiler/rustc_target/src/asm/x86.rs
+++ b/compiler/rustc_target/src/asm/x86.rs
@@ -105,7 +105,7 @@ impl X86InlineAsmRegClass {
     pub fn supported_types(
         self,
         arch: InlineAsmArch,
-        allow_experimental_reg: bool,
+        _allow_experimental_reg: bool,
     ) -> &'static [(InlineAsmType, Option<Symbol>)] {
         match self {
             Self::reg | Self::reg_abcd => {
@@ -117,48 +117,24 @@ impl X86InlineAsmRegClass {
             }
             Self::reg_byte => types! { _: I8; },
             Self::xmm_reg => {
-                if allow_experimental_reg {
-                    types! {
-                        sse: I32, I64, I128, F16, F32, F64, F128,
-                          VecI8(16), VecI16(8), VecI32(4), VecI64(2), VecF16(8), VecF32(4), VecF64(2);
-                    }
-                } else {
-                    types! {
-                        sse: I32, I64, F16, F32, F64, F128,
-                          VecI8(16), VecI16(8), VecI32(4), VecI64(2), VecF16(8), VecF32(4), VecF64(2);
-                    }
+                types! {
+                    sse: I32, I64, I128, F16, F32, F64, F128,
+                      VecI8(16), VecI16(8), VecI32(4), VecI64(2), VecF16(8), VecF32(4), VecF64(2);
                 }
             }
             Self::ymm_reg => {
-                if allow_experimental_reg {
-                    types! {
-                        avx: I32, I64, I128, F16, F32, F64, F128,
-                            VecI8(16), VecI16(8), VecI32(4), VecI64(2), VecF16(8), VecF32(4), VecF64(2),
-                            VecI8(32), VecI16(16), VecI32(8), VecI64(4), VecF16(16), VecF32(8), VecF64(4);
-                    }
-                } else {
-                    types! {
-                        avx: I32, I64, F16, F32, F64, F128,
-                            VecI8(16), VecI16(8), VecI32(4), VecI64(2), VecF16(8), VecF32(4), VecF64(2),
-                            VecI8(32), VecI16(16), VecI32(8), VecI64(4), VecF16(16), VecF32(8), VecF64(4);
-                    }
+                types! {
+                    avx: I32, I64, I128, F16, F32, F64, F128,
+                        VecI8(16), VecI16(8), VecI32(4), VecI64(2), VecF16(8), VecF32(4), VecF64(2),
+                        VecI8(32), VecI16(16), VecI32(8), VecI64(4), VecF16(16), VecF32(8), VecF64(4);
                 }
             }
             Self::zmm_reg => {
-                if allow_experimental_reg {
-                    types! {
-                        avx512f: I32, I64, I128, F16, F32, F64, F128,
-                            VecI8(16), VecI16(8), VecI32(4), VecI64(2), VecF16(8), VecF32(4), VecF64(2),
-                            VecI8(32), VecI16(16), VecI32(8), VecI64(4), VecF16(16), VecF32(8), VecF64(4),
-                            VecI8(64), VecI16(32), VecI32(16), VecI64(8), VecF16(32), VecF32(16), VecF64(8);
-                    }
-                } else {
-                    types! {
-                    avx512f: I32, I64, F16, F32, F64, F128,
+                types! {
+                    avx512f: I32, I64, I128, F16, F32, F64, F128,
                         VecI8(16), VecI16(8), VecI32(4), VecI64(2), VecF16(8), VecF32(4), VecF64(2),
                         VecI8(32), VecI16(16), VecI32(8), VecI64(4), VecF16(16), VecF32(8), VecF64(4),
                         VecI8(64), VecI16(32), VecI32(16), VecI64(8), VecF16(32), VecF32(16), VecF64(8);
-                    }
                 }
             }
 
diff --git a/library/alloc/src/io/mod.rs b/library/alloc/src/io/mod.rs
index 5c043240daba8..44d780292317f 100644
--- a/library/alloc/src/io/mod.rs
+++ b/library/alloc/src/io/mod.rs
@@ -1,4 +1,179 @@
 //! Traits, helpers, and type definitions for core I/O functionality.
+//!
+//! The `io` module contains a number of common things you'll need
+//! when doing input and output. The most core part of this module is
+//! the [`Read`] and [`Write`] traits, which provide the
+//! most general interface for reading and writing input and output.
+//!
+//! ## Read and Write
+//!
+//! Because they are traits, [`Read`] and [`Write`] are implemented by a number
+//! of other types, and you can implement them for your types too. As such,
+//! you'll see a few different types of I/O throughout the documentation in
+//! this module: [`File`]s, [`TcpStream`]s, and sometimes even [`Vec<T>`]s. For
+//! example, [`Read`] adds a [`read`][`Read::read`] method, which we can use on
+//! [`File`]s:
+//!
+//! ```no_run
+//! use std::io;
+//! use std::io::prelude::*;
+//! use std::fs::File;
+//!
+//! fn main() -> io::Result<()> {
+//!     let mut f = File::open("foo.txt")?;
+//!     let mut buffer = [0; 10];
+//!
+//!     // read up to 10 bytes
+//!     let n = f.read(&mut buffer)?;
+//!
+//!     println!("The bytes: {:?}", &buffer[..n]);
+//!     Ok(())
+//! }
+//! ```
+//!
+//! [`Read`] and [`Write`] are so important, implementors of the two traits have a
+//! nickname: readers and writers. So you'll sometimes see 'a reader' instead
+//! of 'a type that implements the [`Read`] trait'. Much easier!
+//!
+//! ## Seek and BufRead
+//!
+//! Beyond that, there are two important traits that are provided: [`Seek`]
+//! and [`BufRead`]. Both of these build on top of a reader to control
+//! how the reading happens. [`Seek`] lets you control where the next byte is
+//! coming from:
+//!
+//! ```no_run
+//! use std::io;
+//! use std::io::prelude::*;
+//! use std::io::SeekFrom;
+//! use std::fs::File;
+//!
+//! fn main() -> io::Result<()> {
+//!     let mut f = File::open("foo.txt")?;
+//!     let mut buffer = [0; 10];
+//!
+//!     // skip to the last 10 bytes of the file
+//!     f.seek(SeekFrom::End(-10))?;
+//!
+//!     // read up to 10 bytes
+//!     let n = f.read(&mut buffer)?;
+//!
+//!     println!("The bytes: {:?}", &buffer[..n]);
+//!     Ok(())
+//! }
+//! ```
+//!
+//! [`BufRead`] uses an internal buffer to provide a number of other ways to read, but
+//! to show it off, we'll need to talk about buffers in general. Keep reading!
+//!
+//! ## BufReader and BufWriter
+//!
+//! Byte-based interfaces are unwieldy and can be inefficient, as we'd need to be
+//! making near-constant calls to the operating system. To help with this,
+//! `std::io` comes with two structs, [`BufReader`] and [`BufWriter`], which wrap
+//! readers and writers. The wrapper uses a buffer, reducing the number of
+//! calls and providing nicer methods for accessing exactly what you want.
+//!
+//! For example, [`BufReader`] works with the [`BufRead`] trait to add extra
+//! methods to any reader:
+//!
+//! ```no_run
+//! use std::io;
+//! use std::io::prelude::*;
+//! use std::io::BufReader;
+//! use std::fs::File;
+//!
+//! fn main() -> io::Result<()> {
+//!     let f = File::open("foo.txt")?;
+//!     let mut reader = BufReader::new(f);
+//!     let mut buffer = String::new();
+//!
+//!     // read a line into buffer
+//!     reader.read_line(&mut buffer)?;
+//!
+//!     println!("{buffer}");
+//!     Ok(())
+//! }
+//! ```
+//!
+//! [`BufWriter`] doesn't add any new ways of writing; it just buffers every call
+//! to [`write`][`Write::write`]:
+//!
+//! ```no_run
+//! use std::io;
+//! use std::io::prelude::*;
+//! use std::io::BufWriter;
+//! use std::fs::File;
+//!
+//! fn main() -> io::Result<()> {
+//!     let f = File::create("foo.txt")?;
+//!     {
+//!         let mut writer = BufWriter::new(f);
+//!
+//!         // write a byte to the buffer
+//!         writer.write(&[42])?;
+//!
+//!     } // the buffer is flushed once writer goes out of scope
+//!
+//!     Ok(())
+//! }
+//! ```
+//!
+//! ## Iterator types
+//!
+//! A large number of the structures provided by `std::io` are for various
+//! ways of iterating over I/O. For example, [`Lines`] is used to split over
+//! lines:
+//!
+//! ```no_run
+//! use std::io;
+//! use std::io::prelude::*;
+//! use std::io::BufReader;
+//! use std::fs::File;
+//!
+//! fn main() -> io::Result<()> {
+//!     let f = File::open("foo.txt")?;
+//!     let reader = BufReader::new(f);
+//!
+//!     for line in reader.lines() {
+//!         println!("{}", line?);
+//!     }
+//!     Ok(())
+//! }
+//! ```
+//!
+//! ## io::Result
+//!
+//! Last, but certainly not least, is [`io::Result`]. This type is used
+//! as the return type of many `std::io` functions that can cause an error, and
+//! can be returned from your own functions as well. Many of the examples in this
+//! module use the [`?` operator]:
+//!
+//! ```no_run
+//! use std::io;
+//!
+//! # #[allow(dead_code)]
+//! fn read_input() -> io::Result<()> {
+//!     let mut input = String::new();
+//!
+//!     io::stdin().read_line(&mut input)?;
+//!
+//!     println!("You typed: {}", input.trim());
+//!
+//!     Ok(())
+//! }
+//! ```
+//!
+//! The return type of `read_input()`, [`io::Result<()>`][`io::Result`], is a very
+//! common type for functions which don't have a 'real' return value, but do want to
+//! return errors if they happen. In this case, the only purpose of this function is
+//! to read the line and print it, so we use `()`.
+//!
+//! [`File`]: ../../std/fs/struct.File.html
+//! [`TcpStream`]: ../../std/net/struct.TcpStream.html
+//! [`Vec<T>`]: crate::vec::Vec
+//! [`io::Result`]: self::Result
+//! [`?` operator]: ../../book/appendix-02-operators.html
 
 mod buf_read;
 mod buffered;
@@ -6,6 +181,8 @@ mod copy;
 mod cursor;
 mod error;
 mod impls;
+#[unstable(feature = "alloc_io", issue = "154046")]
+pub mod prelude;
 mod read;
 mod util;
 
diff --git a/library/alloc/src/io/prelude.rs b/library/alloc/src/io/prelude.rs
new file mode 100644
index 0000000000000..86ae040d1d6f6
--- /dev/null
+++ b/library/alloc/src/io/prelude.rs
@@ -0,0 +1,12 @@
+//! The I/O Prelude.
+//!
+//! The purpose of this module is to alleviate imports of many common I/O traits
+//! by adding a glob import to the top of I/O heavy modules:
+//!
+//! ```
+//! # #![allow(unused_imports)]
+//! use std::io::prelude::*;
+//! ```
+
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use crate::io::{BufRead, Read, Seek, Write};
diff --git a/library/alloc/src/io/read.rs b/library/alloc/src/io/read.rs
index 490a55f9d10dc..fe1a8d11ccefe 100644
--- a/library/alloc/src/io/read.rs
+++ b/library/alloc/src/io/read.rs
@@ -84,6 +84,7 @@ use crate::vec::Vec;
 #[stable(feature = "rust1", since = "1.0.0")]
 #[doc(notable_trait)]
 #[cfg_attr(not(test), rustc_diagnostic_item = "IoRead")]
+#[rustc_must_implement_one_of(read, read_buf)]
 pub trait Read {
     /// Pull some bytes from this source into the specified buffer, returning
     /// how many bytes were read.
@@ -164,7 +165,10 @@ pub trait Read {
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+        let mut buf = BorrowedBuf::from(buf);
+        self.read_buf(buf.unfilled()).map(|()| buf.len())
+    }
 
     /// Like `read`, except that it reads into a slice of buffers.
     ///
diff --git a/library/std/src/io/impls/tests.rs b/library/alloctests/benches/io.rs
similarity index 59%
rename from library/std/src/io/impls/tests.rs
rename to library/alloctests/benches/io.rs
index d1cd84a67ada5..f2e3f2cd3c998 100644
--- a/library/std/src/io/impls/tests.rs
+++ b/library/alloctests/benches/io.rs
@@ -1,4 +1,4 @@
-use crate::io::prelude::*;
+use std::io::prelude::*;
 
 #[bench]
 fn bench_read_slice(b: &mut test::Bencher) {
@@ -55,3 +55,26 @@ fn bench_write_vec(b: &mut test::Bencher) {
         }
     })
 }
+
+#[bench]
+#[cfg(unix)]
+#[cfg_attr(target_os = "emscripten", ignore)] // no /dev
+fn bench_copy_buf_reader(b: &mut test::Bencher) {
+    use std::fs::{File, OpenOptions};
+
+    let mut file_in = File::open("/dev/zero").expect("opening /dev/zero failed");
+    // use dyn to avoid specializations unrelated to readbuf
+    let dyn_in = &mut file_in as &mut dyn Read;
+    let mut reader = std::io::BufReader::with_capacity(256 * 1024, dyn_in.take(0));
+    let mut writer =
+        OpenOptions::new().write(true).open("/dev/null").expect("opening /dev/null failed");
+
+    const BYTES: u64 = 1024 * 1024;
+
+    b.bytes = BYTES;
+
+    b.iter(|| {
+        reader.get_mut().set_limit(BYTES);
+        std::io::copy(&mut reader, &mut writer).unwrap()
+    });
+}
diff --git a/library/alloctests/benches/lib.rs b/library/alloctests/benches/lib.rs
index 4b7139d943593..974b389a765d5 100644
--- a/library/alloctests/benches/lib.rs
+++ b/library/alloctests/benches/lib.rs
@@ -12,6 +12,7 @@ extern crate test;
 
 mod binary_heap;
 mod btree;
+mod io;
 mod linked_list;
 mod slice;
 mod str;
diff --git a/library/std/src/io/buffered/tests.rs b/library/alloctests/tests/io/buffered.rs
similarity index 98%
rename from library/std/src/io/buffered/tests.rs
rename to library/alloctests/tests/io/buffered.rs
index ff4585a60cae9..0abaa63870e15 100644
--- a/library/std/src/io/buffered/tests.rs
+++ b/library/alloctests/tests/io/buffered.rs
@@ -1,10 +1,14 @@
-use crate::io::prelude::*;
-use crate::io::{
-    self, BorrowedBuf, BufReader, BufWriter, ErrorKind, IoSlice, LineWriter, SeekFrom,
+//! Tests for buffering wrappers for I/O traits
+
+use alloc::io::{
+    self, BorrowedBuf, BufRead, BufReader, BufWriter, ErrorKind, IoSlice, LineWriter, Read, Seek,
+    SeekFrom, Write,
 };
-use crate::mem::MaybeUninit;
-use crate::sync::atomic::{AtomicUsize, Ordering};
-use crate::{panic, thread};
+use core::mem::MaybeUninit;
+use core::sync::atomic::{AtomicUsize, Ordering};
+use std::{panic, thread};
+
+extern crate test;
 
 /// A dummy reader intended at testing short-reads propagation.
 pub struct ShortReader {
@@ -488,7 +492,7 @@ fn dont_panic_in_drop_on_panicked_flush() {
 }
 
 #[test]
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
+#[cfg_attr(not(panic = "unwind"), ignore = "test requires unwinding support")]
 fn panic_in_write_doesnt_flush_in_drop() {
     static WRITES: AtomicUsize = AtomicUsize::new(0);
 
@@ -504,12 +508,11 @@ fn panic_in_write_doesnt_flush_in_drop() {
         }
     }
 
-    thread::spawn(|| {
+    panic::catch_unwind(panic::AssertUnwindSafe(|| {
         let mut writer = BufWriter::new(PanicWriter);
         let _ = writer.write(b"hello world");
         let _ = writer.flush();
-    })
-    .join()
+    }))
     .unwrap_err();
 
     assert_eq!(WRITES.load(Ordering::SeqCst), 1);
@@ -681,7 +684,7 @@ fn line_vectored() {
 
 #[test]
 fn line_vectored_partial_and_errors() {
-    use crate::collections::VecDeque;
+    use alloc::collections::VecDeque;
 
     enum Call {
         Write { inputs: Vec<&'static [u8]>, output: io::Result<usize> },
@@ -1150,7 +1153,7 @@ struct WriteRecorder {
 
 impl Write for WriteRecorder {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        use crate::str::from_utf8;
+        use core::str::from_utf8;
 
         self.events.push(RecordedEvent::Write(from_utf8(buf).unwrap().to_string()));
         Ok(buf.len())
@@ -1183,7 +1186,7 @@ fn single_formatted_write() {
 fn bufreader_full_initialize() {
     struct OneByteReader;
     impl Read for OneByteReader {
-        fn read(&mut self, buf: &mut [u8]) -> crate::io::Result<usize> {
+        fn read(&mut self, buf: &mut [u8]) -> alloc::io::Result<usize> {
             if buf.len() > 0 {
                 buf[0] = 0;
                 Ok(1)
@@ -1206,7 +1209,7 @@ fn bufreader_full_initialize() {
 /// This is a regression test for https://github.com/rust-lang/rust/issues/127584.
 #[test]
 fn bufwriter_aliasing() {
-    use crate::io::{BufWriter, Cursor};
+    use alloc::io::{BufWriter, Cursor};
     let mut v = vec![0; 1024];
     let c = Cursor::new(&mut v);
     let w = BufWriter::new(Box::new(c));
diff --git a/library/std/src/io/copy/tests.rs b/library/alloctests/tests/io/copy.rs
similarity index 74%
rename from library/std/src/io/copy/tests.rs
rename to library/alloctests/tests/io/copy.rs
index 7bdba3a04416e..485deeaea80e7 100644
--- a/library/std/src/io/copy/tests.rs
+++ b/library/alloctests/tests/io/copy.rs
@@ -1,7 +1,6 @@
-use crate::cmp::{max, min};
-use crate::collections::VecDeque;
-use crate::io;
-use crate::io::*;
+use alloc::collections::VecDeque;
+use alloc::io::{self, *};
+use core::cmp::{max, min};
 
 #[test]
 fn copy_copies() {
@@ -65,7 +64,7 @@ fn copy_specializes_bufreader() {
     let mut buffered = BufReader::with_capacity(256 * 1024, Cursor::new(&mut source));
 
     let mut sink = Vec::new();
-    assert_eq!(crate::io::copy(&mut buffered, &mut sink).unwrap(), source.len() as u64);
+    assert_eq!(io::copy(&mut buffered, &mut sink).unwrap(), source.len() as u64);
     assert_eq!(source.as_slice(), sink.as_slice());
 
     let buf_sz = 71 * 1024;
@@ -73,7 +72,7 @@ fn copy_specializes_bufreader() {
 
     let mut buffered = BufReader::with_capacity(buf_sz, Cursor::new(&mut source));
     let mut sink = WriteObserver { observed_buffer: 0 };
-    assert_eq!(crate::io::copy(&mut buffered, &mut sink).unwrap(), source.len() as u64);
+    assert_eq!(io::copy(&mut buffered, &mut sink).unwrap(), source.len() as u64);
     assert_eq!(
         sink.observed_buffer, buf_sz,
         "expected a large buffer to be provided to the writer"
@@ -117,32 +116,3 @@ fn copy_specializes_from_slice() {
     assert_eq!(60 * 1024u64, io::copy(&mut source, &mut sink).unwrap());
     assert_eq!(60 * 1024, sink.observed_buffer);
 }
-
-#[cfg(unix)]
-mod io_benches {
-    use test::Bencher;
-
-    use crate::fs::{File, OpenOptions};
-    use crate::io::BufReader;
-    use crate::io::prelude::*;
-
-    #[bench]
-    #[cfg_attr(target_os = "emscripten", ignore)] // no /dev
-    fn bench_copy_buf_reader(b: &mut Bencher) {
-        let mut file_in = File::open("/dev/zero").expect("opening /dev/zero failed");
-        // use dyn to avoid specializations unrelated to readbuf
-        let dyn_in = &mut file_in as &mut dyn Read;
-        let mut reader = BufReader::with_capacity(256 * 1024, dyn_in.take(0));
-        let mut writer =
-            OpenOptions::new().write(true).open("/dev/null").expect("opening /dev/null failed");
-
-        const BYTES: u64 = 1024 * 1024;
-
-        b.bytes = BYTES;
-
-        b.iter(|| {
-            reader.get_mut().set_limit(BYTES);
-            crate::io::copy(&mut reader, &mut writer).unwrap()
-        });
-    }
-}
diff --git a/library/std/src/io/cursor/tests.rs b/library/alloctests/tests/io/cursor.rs
similarity index 99%
rename from library/std/src/io/cursor/tests.rs
rename to library/alloctests/tests/io/cursor.rs
index d7c203c297fe6..5e863f29af53c 100644
--- a/library/std/src/io/cursor/tests.rs
+++ b/library/alloctests/tests/io/cursor.rs
@@ -1,5 +1,6 @@
-use crate::io::prelude::*;
-use crate::io::{Cursor, IoSlice, IoSliceMut, SeekFrom};
+use alloc::io::{Cursor, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write};
+
+extern crate test;
 
 #[test]
 fn test_vec_writer() {
diff --git a/library/std/src/io/tests.rs b/library/alloctests/tests/io/mod.rs
similarity index 98%
rename from library/std/src/io/tests.rs
rename to library/alloctests/tests/io/mod.rs
index 3b4f871268cd1..712e322d79f1c 100644
--- a/library/std/src/io/tests.rs
+++ b/library/alloctests/tests/io/mod.rs
@@ -1,7 +1,16 @@
-use super::{BorrowedBuf, Cursor, SeekFrom, repeat};
-use crate::cmp::{self, min};
-use crate::io::{self, BufRead, BufReader, DEFAULT_BUF_SIZE, IoSlice, Read, Seek, Write};
-use crate::mem::MaybeUninit;
+mod buffered;
+mod copy;
+mod cursor;
+mod util;
+
+use alloc::io::{
+    self, BorrowedBuf, BufRead, BufReader, Cursor, DEFAULT_BUF_SIZE, IoSlice, Read, Seek, SeekFrom,
+    Write, repeat,
+};
+use core::cmp::{self, min};
+use core::mem::MaybeUninit;
+
+extern crate test;
 
 #[test]
 fn read_until() {
@@ -270,7 +279,7 @@ fn chain_bufread() {
 #[test]
 fn chain_splitted_char() {
     let chain = b"\xc3".chain(b"\xa9".as_slice());
-    assert_eq!(crate::io::read_to_string(chain).unwrap(), "é");
+    assert_eq!(alloc::io::read_to_string(chain).unwrap(), "é");
 
     let mut chain = b"\xc3".chain(b"\xa9\n".as_slice());
     let mut buf = String::new();
@@ -360,7 +369,7 @@ fn bench_read_to_end(b: &mut test::Bencher) {
     b.iter(|| {
         let mut lr = repeat(1).take(10000000);
         let mut vec = Vec::with_capacity(1024);
-        super::default_read_to_end(&mut lr, &mut vec, None)
+        alloc::io::default_read_to_end(&mut lr, &mut vec, None)
     });
 }
 
diff --git a/library/std/src/io/util/tests.rs b/library/alloctests/tests/io/util.rs
similarity index 96%
rename from library/std/src/io/util/tests.rs
rename to library/alloctests/tests/io/util.rs
index ed1d6891577da..52e0c3013dde7 100644
--- a/library/std/src/io/util/tests.rs
+++ b/library/alloctests/tests/io/util.rs
@@ -1,9 +1,9 @@
-use crate::fmt;
-use crate::io::prelude::*;
-use crate::io::{
-    BorrowedBuf, Empty, ErrorKind, IoSlice, IoSliceMut, Repeat, SeekFrom, Sink, empty, repeat, sink,
+use alloc::io::{
+    BorrowedBuf, Empty, ErrorKind, IoSlice, IoSliceMut, Read, Repeat, Seek, SeekFrom, Sink, Write,
+    empty, repeat, sink,
 };
-use crate::mem::MaybeUninit;
+use core::fmt;
+use core::mem::MaybeUninit;
 
 struct ErrorDisplay;
 
diff --git a/library/alloctests/tests/lib.rs b/library/alloctests/tests/lib.rs
index 7ccc8d9c6a115..eb9ea287d950f 100644
--- a/library/alloctests/tests/lib.rs
+++ b/library/alloctests/tests/lib.rs
@@ -2,23 +2,31 @@
 #![allow(internal_features)]
 #![deny(implicit_provenance_casts)]
 #![deny(unsafe_op_in_unsafe_fn)]
+#![feature(alloc_io)]
 #![feature(allocator_api)]
 #![feature(binary_heap_drain_sorted)]
 #![feature(binary_heap_into_iter_sorted)]
 #![feature(binary_heap_pop_if)]
+#![feature(borrowed_buf_init)]
+#![feature(buf_read_has_data_left)]
+#![feature(can_vector)]
 #![feature(casefold)]
 #![feature(const_btree_len)]
 #![feature(const_cmp)]
 #![feature(const_heap)]
 #![feature(const_trait_impl)]
 #![feature(core_intrinsics)]
+#![feature(core_io_borrowed_buf)]
+#![feature(core_io_internals)]
 #![feature(cow_is_borrowed)]
+#![feature(cursor_split)]
 #![feature(deque_extend_front)]
 #![feature(downcast_unchecked)]
 #![feature(drain_keep_rest)]
 #![feature(exact_size_is_empty)]
 #![feature(hashmap_internals)]
 #![feature(inplace_iteration)]
+#![feature(io_const_error)]
 #![feature(iter_advance_by)]
 #![feature(iter_array_chunks)]
 #![feature(iter_next_chunk)]
@@ -28,6 +36,9 @@
 #![feature(map_try_insert)]
 #![feature(pattern)]
 #![feature(ptr_cast_slice)]
+#![feature(read_buf)]
+#![feature(seek_io_take_position)]
+#![feature(seek_stream_len)]
 #![feature(slice_partial_sort_unstable)]
 #![feature(slice_partition_dedup)]
 #![feature(slice_ptr_get)]
@@ -48,6 +59,7 @@
 #![feature(vec_deque_retain_range)]
 #![feature(vec_peek_mut)]
 #![feature(vec_try_remove)]
+#![feature(write_all_vectored)]
 // tidy-alphabetical-end
 
 extern crate alloc;
@@ -67,6 +79,7 @@ mod const_fns;
 mod cow_str;
 mod fmt;
 mod heap;
+mod io;
 mod linked_list;
 mod misc_tests;
 mod num;
diff --git a/library/core/src/io/mod.rs b/library/core/src/io/mod.rs
index 0134540ae86c8..a44d271535a9e 100644
--- a/library/core/src/io/mod.rs
+++ b/library/core/src/io/mod.rs
@@ -5,6 +5,8 @@ mod cursor;
 mod error;
 mod impls;
 mod io_slice;
+#[unstable(feature = "core_io", issue = "154046")]
+pub mod prelude;
 mod seek;
 mod size_hint;
 mod util;
diff --git a/library/core/src/io/prelude.rs b/library/core/src/io/prelude.rs
new file mode 100644
index 0000000000000..15dacaa3a4fa0
--- /dev/null
+++ b/library/core/src/io/prelude.rs
@@ -0,0 +1,12 @@
+//! The I/O Prelude.
+//!
+//! The purpose of this module is to alleviate imports of many common I/O traits
+//! by adding a glob import to the top of I/O heavy modules:
+//!
+//! ```
+//! # #![allow(unused_imports)]
+//! use std::io::prelude::*;
+//! ```
+
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use crate::io::{Seek, Write};
diff --git a/library/core/src/io/util.rs b/library/core/src/io/util.rs
index b022d876eb8f5..07173f13eb08b 100644
--- a/library/core/src/io/util.rs
+++ b/library/core/src/io/util.rs
@@ -130,7 +130,7 @@ impl Seek for Empty {
 /// [`Ok(0)`]: Ok
 ///
 /// [`write`]: crate::io::Write::write
-/// [`read`]: ../../std/io/trait.Read.html#tymethod.read
+/// [`read`]: ../../std/io/trait.Read.html#method.read
 ///
 /// # Examples
 ///
diff --git a/library/core/src/iter/adapters/fuse.rs b/library/core/src/iter/adapters/fuse.rs
index ef956e8bdef5d..f614c31430745 100644
--- a/library/core/src/iter/adapters/fuse.rs
+++ b/library/core/src/iter/adapters/fuse.rs
@@ -4,6 +4,7 @@ use crate::iter::adapters::zip::try_get_unchecked;
 use crate::iter::{
     FusedIterator, TrustedFused, TrustedLen, TrustedRandomAccess, TrustedRandomAccessNoCoerce,
 };
+use crate::num::NonZero;
 use crate::ops::Try;
 
 /// An iterator that yields `None` forever after the underlying iterator
@@ -50,6 +51,10 @@ where
         FuseImpl::next(self)
     }
 
+    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        FuseImpl::advance_by(self, n)
+    }
+
     #[inline]
     fn nth(&mut self, n: usize) -> Option<I::Item> {
         FuseImpl::nth(self, n)
@@ -259,6 +264,7 @@ trait FuseImpl<I> {
 
     // Functions specific to any normal Iterators
     fn next(&mut self) -> Option<Self::Item>;
+    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>;
     fn nth(&mut self, n: usize) -> Option<Self::Item>;
     fn try_fold<Acc, Fold, R>(&mut self, acc: Acc, fold: Fold) -> R
     where
@@ -301,6 +307,22 @@ where
         and_then_or_clear(&mut self.iter, Iterator::next)
     }
 
+    #[inline]
+    default fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        let Some(iter) = &mut self.iter else {
+            return match NonZero::new(n) {
+                Some(n) => Err(n),
+                None => Ok(()),
+            };
+        };
+
+        let res = iter.advance_by(n);
+        if res.is_err() {
+            self.iter = None;
+        }
+        res
+    }
+
     #[inline]
     default fn nth(&mut self, n: usize) -> Option<I::Item> {
         and_then_or_clear(&mut self.iter, |iter| iter.nth(n))
@@ -381,6 +403,17 @@ where
         self.iter.as_mut()?.next()
     }
 
+    #[inline]
+    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        match &mut self.iter {
+            Some(iter) => iter.advance_by(n),
+            None => match NonZero::new(n) {
+                Some(n) => Err(n),
+                None => Ok(()),
+            },
+        }
+    }
+
     #[inline]
     fn nth(&mut self, n: usize) -> Option<I::Item> {
         self.iter.as_mut()?.nth(n)
diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index 1b393e6c928e8..41f4b837efaea 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -157,6 +157,13 @@
 //!   the allocation), `base + o` will not wrap around the address space (in
 //!   other words, will not overflow `usize`)
 //!
+//! Allocations typically have a fixed size that cannot change. However, allocations created by
+//! directly invoking page table operations of the operating system, e.g. via `mmap`, are allowed to
+//! grow by adding more pages to them at the end. Unmapping parts of an allocation (i.e., shrinking
+//! it or punching holes into it) is currently not supported. Allocations created via
+//! "compiler-recognized" operations, such as `std::alloc` methods or `libc::malloc`, can never
+//! change their size, even if they use `mmap` under the hood.
+//!
 //! [`null()`]: null
 //!
 //! # Provenance
diff --git a/library/std/src/io/buffered/mod.rs b/library/std/src/io/buffered/mod.rs
deleted file mode 100644
index 1d09ff7d8dc1c..0000000000000
--- a/library/std/src/io/buffered/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-//! Buffering wrappers for I/O traits
-
-#[cfg(test)]
-mod tests;
diff --git a/library/std/src/io/copy.rs b/library/std/src/io/copy.rs
deleted file mode 100644
index 87c2771955a9d..0000000000000
--- a/library/std/src/io/copy.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-#[cfg(test)]
-mod tests;
diff --git a/library/std/src/io/cursor.rs b/library/std/src/io/cursor.rs
deleted file mode 100644
index 87c2771955a9d..0000000000000
--- a/library/std/src/io/cursor.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-#[cfg(test)]
-mod tests;
diff --git a/library/std/src/io/impls.rs b/library/std/src/io/impls.rs
deleted file mode 100644
index 87c2771955a9d..0000000000000
--- a/library/std/src/io/impls.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-#[cfg(test)]
-mod tests;
diff --git a/library/std/src/io/mod.rs b/library/std/src/io/mod.rs
index 203572c9067b6..c0ed06d5311bc 100644
--- a/library/std/src/io/mod.rs
+++ b/library/std/src/io/mod.rs
@@ -294,9 +294,6 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-#[cfg(test)]
-mod tests;
-
 use alloc_crate::io::OsFunctions;
 #[unstable(feature = "raw_os_error_ty", issue = "107792")]
 pub use alloc_crate::io::RawOsError;
@@ -344,12 +341,7 @@ pub(crate) use self::stdio::{attempt_print_to_stderr, cleanup};
 #[doc(no_inline, hidden)]
 pub use self::stdio::{set_output_capture, try_set_output_capture};
 
-mod buffered;
-mod copy;
-mod cursor;
 mod error;
-mod impls;
 mod pipe;
 pub mod prelude;
 mod stdio;
-mod util;
diff --git a/library/std/src/io/util.rs b/library/std/src/io/util.rs
deleted file mode 100644
index 87c2771955a9d..0000000000000
--- a/library/std/src/io/util.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-#[cfg(test)]
-mod tests;
diff --git a/src/doc/unstable-book/src/language-features/asm-experimental-reg.md b/src/doc/unstable-book/src/language-features/asm-experimental-reg.md
index 095b541da6e46..db72c44a2dc92 100644
--- a/src/doc/unstable-book/src/language-features/asm-experimental-reg.md
+++ b/src/doc/unstable-book/src/language-features/asm-experimental-reg.md
@@ -19,9 +19,6 @@ This tracks support for additional registers in architectures where inline assem
 
 | Architecture | Register class | Target feature | Allowed types |
 | ------------ | -------------- | -------------- | ------------- |
-| x86 | `xmm_reg` | `sse` | `i128` |
-| x86 | `ymm_reg` | `avx` | `i128` |
-| x86 | `zmm_reg` | `avx512f` | `i128` |
 | LoongArch | `vreg` | `lsx` | `f32`, `f64`, <br> `i8x16`, `i16x8`, `i32x4`, `i64x2`, `f32x4`, `f64x2` |
 | LoongArch | `xreg` | `lasx` | `f32`, `f64`, <br> `i8x16`, `i16x8`, `i32x4`, `i64x2`, `f32x4`, `f64x2`, <br> `i8x32`, `i16x16`, `i32x8`, `i64x4`, `f32x8`, `f64x4` |
 
diff --git a/src/gcc b/src/gcc
index 6f155cc3f5a2d..dfbee712e6116 160000
--- a/src/gcc
+++ b/src/gcc
@@ -1 +1 @@
-Subproject commit 6f155cc3f5a2dff33afe6cc3ed6c2e0e605ae6a3
+Subproject commit dfbee712e611693596ffec1de22177089c537491
diff --git a/tests/rustdoc-html/jump-to-def/non-local-method.rs b/tests/rustdoc-html/jump-to-def/non-local-method.rs
index e785ab8d204f9..db85d31bf656c 100644
--- a/tests/rustdoc-html/jump-to-def/non-local-method.rs
+++ b/tests/rustdoc-html/jump-to-def/non-local-method.rs
@@ -16,7 +16,7 @@ use std::cmp::Ordering;
 use std::marker::PhantomData;
 
 pub fn bar2<T: Read>(readable: T) {
-    //@ has - '//a[@href="{{channel}}/alloc/io/read/trait.Read.html#tymethod.read"]' 'read'
+    //@ has - '//a[@href="{{channel}}/alloc/io/read/trait.Read.html#method.read"]' 'read'
     let _ = readable.read(&mut []);
 }
 
diff --git a/tests/ui/asm/x86_64/bad-reg.experimental_reg.stderr b/tests/ui/asm/x86_64/bad-reg.experimental_reg.stderr
index fe2a53aec5d48..a03791b9222cc 100644
--- a/tests/ui/asm/x86_64/bad-reg.experimental_reg.stderr
+++ b/tests/ui/asm/x86_64/bad-reg.experimental_reg.stderr
@@ -1,5 +1,5 @@
 error: invalid register class `foo`: unknown register class
-  --> $DIR/bad-reg.rs:20:20
+  --> $DIR/bad-reg.rs:19:20
    |
 LL |         asm!("{}", in(foo) foo);
    |                    ^^^^^^^^^^^
@@ -7,13 +7,13 @@ LL |         asm!("{}", in(foo) foo);
    = note: the following register classes are supported on this target: `reg`, `reg_abcd`, `reg_byte`, `xmm_reg`, `ymm_reg`, `zmm_reg`, `kreg`, `kreg0`, `mmx_reg`, `x87_reg`, and `tmm_reg`
 
 error: invalid register `foo`: unknown register
-  --> $DIR/bad-reg.rs:22:18
+  --> $DIR/bad-reg.rs:21:18
    |
 LL |         asm!("", in("foo") foo);
    |                  ^^^^^^^^^^^^^
 
 error: invalid asm template modifier `z` for this register class
-  --> $DIR/bad-reg.rs:24:15
+  --> $DIR/bad-reg.rs:23:15
    |
 LL |         asm!("{:z}", in(reg) foo);
    |               ^^^^   ----------- argument
@@ -23,7 +23,7 @@ LL |         asm!("{:z}", in(reg) foo);
    = note: the `reg` register class supports the following template modifiers: `l`, `x`, `e`, and `r`
 
 error: invalid asm template modifier `r` for this register class
-  --> $DIR/bad-reg.rs:26:15
+  --> $DIR/bad-reg.rs:25:15
    |
 LL |         asm!("{:r}", in(xmm_reg) foo);
    |               ^^^^   --------------- argument
@@ -33,7 +33,7 @@ LL |         asm!("{:r}", in(xmm_reg) foo);
    = note: the `xmm_reg` register class supports the following template modifiers: `x`, `y`, and `z`
 
 error: asm template modifiers are not allowed for `const` arguments
-  --> $DIR/bad-reg.rs:28:15
+  --> $DIR/bad-reg.rs:27:15
    |
 LL |         asm!("{:a}", const 0);
    |               ^^^^   ------- argument
@@ -41,7 +41,7 @@ LL |         asm!("{:a}", const 0);
    |               template modifier
 
 error: asm template modifiers are not allowed for `sym` arguments
-  --> $DIR/bad-reg.rs:30:15
+  --> $DIR/bad-reg.rs:29:15
    |
 LL |         asm!("{:a}", sym main);
    |               ^^^^   -------- argument
@@ -49,67 +49,67 @@ LL |         asm!("{:a}", sym main);
    |               template modifier
 
 error: invalid register `ebp`: the frame pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:32:18
+  --> $DIR/bad-reg.rs:31:18
    |
 LL |         asm!("", in("ebp") foo);
    |                  ^^^^^^^^^^^^^
 
 error: invalid register `rsp`: the stack pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:34:18
+  --> $DIR/bad-reg.rs:33:18
    |
 LL |         asm!("", in("rsp") foo);
    |                  ^^^^^^^^^^^^^
 
 error: invalid register `ip`: the instruction pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:36:18
+  --> $DIR/bad-reg.rs:35:18
    |
 LL |         asm!("", in("ip") foo);
    |                  ^^^^^^^^^^^^
 
 error: register class `x87_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:43:18
+  --> $DIR/bad-reg.rs:42:18
    |
 LL |         asm!("", in("st(2)") foo);
    |                  ^^^^^^^^^^^^^^^
 
 error: register class `mmx_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:46:18
+  --> $DIR/bad-reg.rs:45:18
    |
 LL |         asm!("", in("mm0") foo);
    |                  ^^^^^^^^^^^^^
 
 error: register class `kreg0` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:49:18
+  --> $DIR/bad-reg.rs:48:18
    |
 LL |         asm!("", in("k0") foo);
    |                  ^^^^^^^^^^^^
 
 error: register class `x87_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:54:20
+  --> $DIR/bad-reg.rs:53:20
    |
 LL |         asm!("{}", in(x87_reg) foo);
    |                    ^^^^^^^^^^^^^^^
 
 error: register class `mmx_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:57:20
+  --> $DIR/bad-reg.rs:56:20
    |
 LL |         asm!("{}", in(mmx_reg) foo);
    |                    ^^^^^^^^^^^^^^^
 
 error: register class `x87_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:60:20
+  --> $DIR/bad-reg.rs:59:20
    |
 LL |         asm!("{}", out(x87_reg) _);
    |                    ^^^^^^^^^^^^^^
 
 error: register class `mmx_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:62:20
+  --> $DIR/bad-reg.rs:61:20
    |
 LL |         asm!("{}", out(mmx_reg) _);
    |                    ^^^^^^^^^^^^^^
 
 error: register `al` conflicts with register `eax`
-  --> $DIR/bad-reg.rs:68:33
+  --> $DIR/bad-reg.rs:67:33
    |
 LL |         asm!("", in("eax") foo, in("al") bar);
    |                  -------------  ^^^^^^^^^^^^ register `al`
@@ -117,7 +117,7 @@ LL |         asm!("", in("eax") foo, in("al") bar);
    |                  register `eax`
 
 error: register `rax` conflicts with register `rax`
-  --> $DIR/bad-reg.rs:71:33
+  --> $DIR/bad-reg.rs:70:33
    |
 LL |         asm!("", in("rax") foo, out("rax") bar);
    |                  -------------  ^^^^^^^^^^^^^^ register `rax`
@@ -125,13 +125,13 @@ LL |         asm!("", in("rax") foo, out("rax") bar);
    |                  register `rax`
    |
 help: use `lateout` instead of `out` to avoid conflict
-  --> $DIR/bad-reg.rs:71:18
+  --> $DIR/bad-reg.rs:70:18
    |
 LL |         asm!("", in("rax") foo, out("rax") bar);
    |                  ^^^^^^^^^^^^^
 
 error: register `ymm0` conflicts with register `xmm0`
-  --> $DIR/bad-reg.rs:76:34
+  --> $DIR/bad-reg.rs:75:34
    |
 LL |         asm!("", in("xmm0") foo, in("ymm0") bar);
    |                  --------------  ^^^^^^^^^^^^^^ register `ymm0`
@@ -139,7 +139,7 @@ LL |         asm!("", in("xmm0") foo, in("ymm0") bar);
    |                  register `xmm0`
 
 error: register `ymm0` conflicts with register `xmm0`
-  --> $DIR/bad-reg.rs:78:34
+  --> $DIR/bad-reg.rs:77:34
    |
 LL |         asm!("", in("xmm0") foo, out("ymm0") bar);
    |                  --------------  ^^^^^^^^^^^^^^^ register `ymm0`
@@ -147,25 +147,25 @@ LL |         asm!("", in("xmm0") foo, out("ymm0") bar);
    |                  register `xmm0`
    |
 help: use `lateout` instead of `out` to avoid conflict
-  --> $DIR/bad-reg.rs:78:18
+  --> $DIR/bad-reg.rs:77:18
    |
 LL |         asm!("", in("xmm0") foo, out("ymm0") bar);
    |                  ^^^^^^^^^^^^^^
 
 error: cannot use register `bl`: rbx is used internally by LLVM and cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:38:18
+  --> $DIR/bad-reg.rs:37:18
    |
 LL |         asm!("", in("bl") foo);
    |                  ^^^^^^^^^^^^
 
 error: cannot use register `bh`: rbx is used internally by LLVM and cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:40:18
+  --> $DIR/bad-reg.rs:39:18
    |
 LL |         asm!("", in("bh") foo);
    |                  ^^^^^^^^^^^^
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:43:30
+  --> $DIR/bad-reg.rs:42:30
    |
 LL |         asm!("", in("st(2)") foo);
    |                              ^^^
@@ -173,7 +173,7 @@ LL |         asm!("", in("st(2)") foo);
    = note: register class `x87_reg` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:46:28
+  --> $DIR/bad-reg.rs:45:28
    |
 LL |         asm!("", in("mm0") foo);
    |                            ^^^
@@ -181,7 +181,7 @@ LL |         asm!("", in("mm0") foo);
    = note: register class `mmx_reg` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:49:27
+  --> $DIR/bad-reg.rs:48:27
    |
 LL |         asm!("", in("k0") foo);
    |                           ^^^
@@ -189,7 +189,7 @@ LL |         asm!("", in("k0") foo);
    = note: register class `kreg0` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:54:32
+  --> $DIR/bad-reg.rs:53:32
    |
 LL |         asm!("{}", in(x87_reg) foo);
    |                                ^^^
@@ -197,7 +197,7 @@ LL |         asm!("{}", in(x87_reg) foo);
    = note: register class `x87_reg` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:57:32
+  --> $DIR/bad-reg.rs:56:32
    |
 LL |         asm!("{}", in(mmx_reg) foo);
    |                                ^^^
@@ -205,7 +205,7 @@ LL |         asm!("{}", in(mmx_reg) foo);
    = note: register class `mmx_reg` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:68:42
+  --> $DIR/bad-reg.rs:67:42
    |
 LL |         asm!("", in("eax") foo, in("al") bar);
    |                                          ^^^
@@ -213,7 +213,7 @@ LL |         asm!("", in("eax") foo, in("al") bar);
    = note: register class `reg_byte` supports these types: i8
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:73:27
+  --> $DIR/bad-reg.rs:72:27
    |
 LL |         asm!("", in("al") foo, lateout("al") bar);
    |                           ^^^
@@ -221,7 +221,7 @@ LL |         asm!("", in("al") foo, lateout("al") bar);
    = note: register class `reg_byte` supports these types: i8
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:73:46
+  --> $DIR/bad-reg.rs:72:46
    |
 LL |         asm!("", in("al") foo, lateout("al") bar);
    |                                              ^^^
diff --git a/tests/ui/asm/x86_64/bad-reg.rs b/tests/ui/asm/x86_64/bad-reg.rs
index cc3def95508ff..3e9858f4d9664 100644
--- a/tests/ui/asm/x86_64/bad-reg.rs
+++ b/tests/ui/asm/x86_64/bad-reg.rs
@@ -3,7 +3,6 @@
 //@ compile-flags: --target x86_64-unknown-linux-gnu -C target-feature=+avx2,+avx512f
 //@ needs-llvm-components: x86
 #![cfg_attr(experimental_reg, feature(asm_experimental_reg))]
-
 #![crate_type = "lib"]
 #![feature(no_core)]
 #![no_core]
@@ -79,22 +78,16 @@ fn main() {
         //~^ ERROR register `ymm0` conflicts with register `xmm0`
         asm!("", in("xmm0") foo, lateout("ymm0") bar);
 
-        // Passing u128/i128 is currently experimental.
+        // Use 128-bit integers with vector registers.
         let mut xmmword = 0u128;
 
-        asm!("/* {:x} */", in(xmm_reg) xmmword); // requires asm_experimental_reg
-        //[stable]~^ ERROR type `u128` cannot be used with this register class in stable
-        asm!("/* {:x} */", out(xmm_reg) xmmword); // requires asm_experimental_reg
-        //[stable]~^ ERROR type `u128` cannot be used with this register class in stable
+        asm!("/* {:x} */", in(xmm_reg) xmmword);
+        asm!("/* {:x} */", out(xmm_reg) xmmword);
 
-        asm!("/* {:y} */", in(ymm_reg) xmmword); // requires asm_experimental_reg
-        //[stable]~^ ERROR type `u128` cannot be used with this register class in stable
-        asm!("/* {:y} */", out(ymm_reg) xmmword); // requires asm_experimental_reg
-        //[stable]~^ ERROR type `u128` cannot be used with this register class in stable
+        asm!("/* {:y} */", in(ymm_reg) xmmword);
+        asm!("/* {:y} */", out(ymm_reg) xmmword);
 
-        asm!("/* {:z} */", in(zmm_reg) xmmword); // requires asm_experimental_reg
-        //[stable]~^ ERROR type `u128` cannot be used with this register class in stable
-        asm!("/* {:z} */", out(zmm_reg) xmmword); // requires asm_experimental_reg
-        //[stable]~^ ERROR type `u128` cannot be used with this register class in stable
+        asm!("/* {:z} */", in(zmm_reg) xmmword);
+        asm!("/* {:z} */", out(zmm_reg) xmmword);
     }
 }
diff --git a/tests/ui/asm/x86_64/bad-reg.stable.stderr b/tests/ui/asm/x86_64/bad-reg.stable.stderr
index d8a37933065e1..a03791b9222cc 100644
--- a/tests/ui/asm/x86_64/bad-reg.stable.stderr
+++ b/tests/ui/asm/x86_64/bad-reg.stable.stderr
@@ -1,5 +1,5 @@
 error: invalid register class `foo`: unknown register class
-  --> $DIR/bad-reg.rs:20:20
+  --> $DIR/bad-reg.rs:19:20
    |
 LL |         asm!("{}", in(foo) foo);
    |                    ^^^^^^^^^^^
@@ -7,13 +7,13 @@ LL |         asm!("{}", in(foo) foo);
    = note: the following register classes are supported on this target: `reg`, `reg_abcd`, `reg_byte`, `xmm_reg`, `ymm_reg`, `zmm_reg`, `kreg`, `kreg0`, `mmx_reg`, `x87_reg`, and `tmm_reg`
 
 error: invalid register `foo`: unknown register
-  --> $DIR/bad-reg.rs:22:18
+  --> $DIR/bad-reg.rs:21:18
    |
 LL |         asm!("", in("foo") foo);
    |                  ^^^^^^^^^^^^^
 
 error: invalid asm template modifier `z` for this register class
-  --> $DIR/bad-reg.rs:24:15
+  --> $DIR/bad-reg.rs:23:15
    |
 LL |         asm!("{:z}", in(reg) foo);
    |               ^^^^   ----------- argument
@@ -23,7 +23,7 @@ LL |         asm!("{:z}", in(reg) foo);
    = note: the `reg` register class supports the following template modifiers: `l`, `x`, `e`, and `r`
 
 error: invalid asm template modifier `r` for this register class
-  --> $DIR/bad-reg.rs:26:15
+  --> $DIR/bad-reg.rs:25:15
    |
 LL |         asm!("{:r}", in(xmm_reg) foo);
    |               ^^^^   --------------- argument
@@ -33,7 +33,7 @@ LL |         asm!("{:r}", in(xmm_reg) foo);
    = note: the `xmm_reg` register class supports the following template modifiers: `x`, `y`, and `z`
 
 error: asm template modifiers are not allowed for `const` arguments
-  --> $DIR/bad-reg.rs:28:15
+  --> $DIR/bad-reg.rs:27:15
    |
 LL |         asm!("{:a}", const 0);
    |               ^^^^   ------- argument
@@ -41,7 +41,7 @@ LL |         asm!("{:a}", const 0);
    |               template modifier
 
 error: asm template modifiers are not allowed for `sym` arguments
-  --> $DIR/bad-reg.rs:30:15
+  --> $DIR/bad-reg.rs:29:15
    |
 LL |         asm!("{:a}", sym main);
    |               ^^^^   -------- argument
@@ -49,67 +49,67 @@ LL |         asm!("{:a}", sym main);
    |               template modifier
 
 error: invalid register `ebp`: the frame pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:32:18
+  --> $DIR/bad-reg.rs:31:18
    |
 LL |         asm!("", in("ebp") foo);
    |                  ^^^^^^^^^^^^^
 
 error: invalid register `rsp`: the stack pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:34:18
+  --> $DIR/bad-reg.rs:33:18
    |
 LL |         asm!("", in("rsp") foo);
    |                  ^^^^^^^^^^^^^
 
 error: invalid register `ip`: the instruction pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:36:18
+  --> $DIR/bad-reg.rs:35:18
    |
 LL |         asm!("", in("ip") foo);
    |                  ^^^^^^^^^^^^
 
 error: register class `x87_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:43:18
+  --> $DIR/bad-reg.rs:42:18
    |
 LL |         asm!("", in("st(2)") foo);
    |                  ^^^^^^^^^^^^^^^
 
 error: register class `mmx_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:46:18
+  --> $DIR/bad-reg.rs:45:18
    |
 LL |         asm!("", in("mm0") foo);
    |                  ^^^^^^^^^^^^^
 
 error: register class `kreg0` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:49:18
+  --> $DIR/bad-reg.rs:48:18
    |
 LL |         asm!("", in("k0") foo);
    |                  ^^^^^^^^^^^^
 
 error: register class `x87_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:54:20
+  --> $DIR/bad-reg.rs:53:20
    |
 LL |         asm!("{}", in(x87_reg) foo);
    |                    ^^^^^^^^^^^^^^^
 
 error: register class `mmx_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:57:20
+  --> $DIR/bad-reg.rs:56:20
    |
 LL |         asm!("{}", in(mmx_reg) foo);
    |                    ^^^^^^^^^^^^^^^
 
 error: register class `x87_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:60:20
+  --> $DIR/bad-reg.rs:59:20
    |
 LL |         asm!("{}", out(x87_reg) _);
    |                    ^^^^^^^^^^^^^^
 
 error: register class `mmx_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:62:20
+  --> $DIR/bad-reg.rs:61:20
    |
 LL |         asm!("{}", out(mmx_reg) _);
    |                    ^^^^^^^^^^^^^^
 
 error: register `al` conflicts with register `eax`
-  --> $DIR/bad-reg.rs:68:33
+  --> $DIR/bad-reg.rs:67:33
    |
 LL |         asm!("", in("eax") foo, in("al") bar);
    |                  -------------  ^^^^^^^^^^^^ register `al`
@@ -117,7 +117,7 @@ LL |         asm!("", in("eax") foo, in("al") bar);
    |                  register `eax`
 
 error: register `rax` conflicts with register `rax`
-  --> $DIR/bad-reg.rs:71:33
+  --> $DIR/bad-reg.rs:70:33
    |
 LL |         asm!("", in("rax") foo, out("rax") bar);
    |                  -------------  ^^^^^^^^^^^^^^ register `rax`
@@ -125,13 +125,13 @@ LL |         asm!("", in("rax") foo, out("rax") bar);
    |                  register `rax`
    |
 help: use `lateout` instead of `out` to avoid conflict
-  --> $DIR/bad-reg.rs:71:18
+  --> $DIR/bad-reg.rs:70:18
    |
 LL |         asm!("", in("rax") foo, out("rax") bar);
    |                  ^^^^^^^^^^^^^
 
 error: register `ymm0` conflicts with register `xmm0`
-  --> $DIR/bad-reg.rs:76:34
+  --> $DIR/bad-reg.rs:75:34
    |
 LL |         asm!("", in("xmm0") foo, in("ymm0") bar);
    |                  --------------  ^^^^^^^^^^^^^^ register `ymm0`
@@ -139,7 +139,7 @@ LL |         asm!("", in("xmm0") foo, in("ymm0") bar);
    |                  register `xmm0`
 
 error: register `ymm0` conflicts with register `xmm0`
-  --> $DIR/bad-reg.rs:78:34
+  --> $DIR/bad-reg.rs:77:34
    |
 LL |         asm!("", in("xmm0") foo, out("ymm0") bar);
    |                  --------------  ^^^^^^^^^^^^^^^ register `ymm0`
@@ -147,25 +147,25 @@ LL |         asm!("", in("xmm0") foo, out("ymm0") bar);
    |                  register `xmm0`
    |
 help: use `lateout` instead of `out` to avoid conflict
-  --> $DIR/bad-reg.rs:78:18
+  --> $DIR/bad-reg.rs:77:18
    |
 LL |         asm!("", in("xmm0") foo, out("ymm0") bar);
    |                  ^^^^^^^^^^^^^^
 
 error: cannot use register `bl`: rbx is used internally by LLVM and cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:38:18
+  --> $DIR/bad-reg.rs:37:18
    |
 LL |         asm!("", in("bl") foo);
    |                  ^^^^^^^^^^^^
 
 error: cannot use register `bh`: rbx is used internally by LLVM and cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:40:18
+  --> $DIR/bad-reg.rs:39:18
    |
 LL |         asm!("", in("bh") foo);
    |                  ^^^^^^^^^^^^
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:43:30
+  --> $DIR/bad-reg.rs:42:30
    |
 LL |         asm!("", in("st(2)") foo);
    |                              ^^^
@@ -173,7 +173,7 @@ LL |         asm!("", in("st(2)") foo);
    = note: register class `x87_reg` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:46:28
+  --> $DIR/bad-reg.rs:45:28
    |
 LL |         asm!("", in("mm0") foo);
    |                            ^^^
@@ -181,7 +181,7 @@ LL |         asm!("", in("mm0") foo);
    = note: register class `mmx_reg` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:49:27
+  --> $DIR/bad-reg.rs:48:27
    |
 LL |         asm!("", in("k0") foo);
    |                           ^^^
@@ -189,7 +189,7 @@ LL |         asm!("", in("k0") foo);
    = note: register class `kreg0` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:54:32
+  --> $DIR/bad-reg.rs:53:32
    |
 LL |         asm!("{}", in(x87_reg) foo);
    |                                ^^^
@@ -197,7 +197,7 @@ LL |         asm!("{}", in(x87_reg) foo);
    = note: register class `x87_reg` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:57:32
+  --> $DIR/bad-reg.rs:56:32
    |
 LL |         asm!("{}", in(mmx_reg) foo);
    |                                ^^^
@@ -205,7 +205,7 @@ LL |         asm!("{}", in(mmx_reg) foo);
    = note: register class `mmx_reg` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:68:42
+  --> $DIR/bad-reg.rs:67:42
    |
 LL |         asm!("", in("eax") foo, in("al") bar);
    |                                          ^^^
@@ -213,7 +213,7 @@ LL |         asm!("", in("eax") foo, in("al") bar);
    = note: register class `reg_byte` supports these types: i8
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:73:27
+  --> $DIR/bad-reg.rs:72:27
    |
 LL |         asm!("", in("al") foo, lateout("al") bar);
    |                           ^^^
@@ -221,73 +221,12 @@ LL |         asm!("", in("al") foo, lateout("al") bar);
    = note: register class `reg_byte` supports these types: i8
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:73:46
+  --> $DIR/bad-reg.rs:72:46
    |
 LL |         asm!("", in("al") foo, lateout("al") bar);
    |                                              ^^^
    |
    = note: register class `reg_byte` supports these types: i8
 
-error[E0658]: type `u128` cannot be used with this register class in stable
-  --> $DIR/bad-reg.rs:85:40
-   |
-LL |         asm!("/* {:x} */", in(xmm_reg) xmmword); // requires asm_experimental_reg
-   |                                        ^^^^^^^
-   |
-   = note: see issue #133416 <https://github.com/rust-lang/rust/issues/133416> for more information
-   = help: add `#![feature(asm_experimental_reg)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: type `u128` cannot be used with this register class in stable
-  --> $DIR/bad-reg.rs:87:41
-   |
-LL |         asm!("/* {:x} */", out(xmm_reg) xmmword); // requires asm_experimental_reg
-   |                                         ^^^^^^^
-   |
-   = note: see issue #133416 <https://github.com/rust-lang/rust/issues/133416> for more information
-   = help: add `#![feature(asm_experimental_reg)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: type `u128` cannot be used with this register class in stable
-  --> $DIR/bad-reg.rs:90:40
-   |
-LL |         asm!("/* {:y} */", in(ymm_reg) xmmword); // requires asm_experimental_reg
-   |                                        ^^^^^^^
-   |
-   = note: see issue #133416 <https://github.com/rust-lang/rust/issues/133416> for more information
-   = help: add `#![feature(asm_experimental_reg)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: type `u128` cannot be used with this register class in stable
-  --> $DIR/bad-reg.rs:92:41
-   |
-LL |         asm!("/* {:y} */", out(ymm_reg) xmmword); // requires asm_experimental_reg
-   |                                         ^^^^^^^
-   |
-   = note: see issue #133416 <https://github.com/rust-lang/rust/issues/133416> for more information
-   = help: add `#![feature(asm_experimental_reg)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: type `u128` cannot be used with this register class in stable
-  --> $DIR/bad-reg.rs:95:40
-   |
-LL |         asm!("/* {:z} */", in(zmm_reg) xmmword); // requires asm_experimental_reg
-   |                                        ^^^^^^^
-   |
-   = note: see issue #133416 <https://github.com/rust-lang/rust/issues/133416> for more information
-   = help: add `#![feature(asm_experimental_reg)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: type `u128` cannot be used with this register class in stable
-  --> $DIR/bad-reg.rs:97:41
-   |
-LL |         asm!("/* {:z} */", out(zmm_reg) xmmword); // requires asm_experimental_reg
-   |                                         ^^^^^^^
-   |
-   = note: see issue #133416 <https://github.com/rust-lang/rust/issues/133416> for more information
-   = help: add `#![feature(asm_experimental_reg)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error: aborting due to 36 previous errors
+error: aborting due to 30 previous errors
 
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/asm/x86_64/type-check-3.stderr b/tests/ui/asm/x86_64/type-check-3.stderr
index 5a7b349413e45..ea9a3955e7078 100644
--- a/tests/ui/asm/x86_64/type-check-3.stderr
+++ b/tests/ui/asm/x86_64/type-check-3.stderr
@@ -28,7 +28,7 @@ error: type `u8` cannot be used with this register class
 LL |         asm!("{}", in(xmm_reg) 0u8);
    |                                ^^^
    |
-   = note: register class `xmm_reg` supports these types: i32, i64, f16, f32, f64, f128, i8x16, i16x8, i32x4, i64x2, f16x8, f32x4, f64x2
+   = note: register class `xmm_reg` supports these types: i32, i64, i128, f16, f32, f64, f128, i8x16, i16x8, i32x4, i64x2, f16x8, f32x4, f64x2
 
 error: `avx512bw` target feature is not enabled
   --> $DIR/type-check-3.rs:27:29
diff --git a/tests/ui/feature-gates/feature-gate-asm_experimental_reg.rs b/tests/ui/feature-gates/feature-gate-asm_experimental_reg.rs
index bfc79ae8db663..0d2c4fe2b67c3 100644
--- a/tests/ui/feature-gates/feature-gate-asm_experimental_reg.rs
+++ b/tests/ui/feature-gates/feature-gate-asm_experimental_reg.rs
@@ -1,16 +1,27 @@
 //@ add-minicore
-//@ compile-flags: --target x86_64-unknown-linux-gnu
-//@ needs-llvm-components: x86
+//@ compile-flags: --target loongarch64-unknown-none
+//@ needs-llvm-components: loongarch
 //@ ignore-backends: gcc
 
-#![feature(no_core, lang_items, rustc_attrs)]
+#![feature(no_core, lang_items, rustc_attrs, repr_simd)]
 #![crate_type = "rlib"]
 #![no_core]
+#![allow(non_camel_case_types)]
 
 extern crate minicore;
 use minicore::*;
 
-unsafe fn main() {
-    asm!("{:x}", in(xmm_reg) 0u128);
-    //~^ ERROR type `u128` cannot be used with this register class in stable
+#[repr(simd)]
+pub struct i8x16([i8; 16]);
+
+impl Copy for i8x16 {}
+
+unsafe fn main(x: i8x16) -> i8x16 {
+    let y;
+    asm!("xvadd.h {1:u}, {0:u}, {0:u}", out(vreg) y, in(vreg) x);
+    //~^ ERROR register class `vreg` can only be used as a clobber in stable
+    //~| ERROR register class `vreg` can only be used as a clobber in stable
+    //~| ERROR type `i8x16` cannot be used with this register class in stable
+    //~| ERROR type `i8x16` cannot be used with this register class in stable
+    y
 }
diff --git a/tests/ui/feature-gates/feature-gate-asm_experimental_reg.stderr b/tests/ui/feature-gates/feature-gate-asm_experimental_reg.stderr
index 4042ee7029b53..fb54438ef589e 100644
--- a/tests/ui/feature-gates/feature-gate-asm_experimental_reg.stderr
+++ b/tests/ui/feature-gates/feature-gate-asm_experimental_reg.stderr
@@ -1,13 +1,43 @@
-error[E0658]: type `u128` cannot be used with this register class in stable
-  --> $DIR/feature-gate-asm_experimental_reg.rs:14:30
+error[E0658]: register class `vreg` can only be used as a clobber in stable
+  --> $DIR/feature-gate-asm_experimental_reg.rs:21:41
    |
-LL |     asm!("{:x}", in(xmm_reg) 0u128);
-   |                              ^^^^^
+LL |     asm!("xvadd.h {1:u}, {0:u}, {0:u}", out(vreg) y, in(vreg) x);
+   |                                         ^^^^^^^^^^^
    |
    = note: see issue #133416 <https://github.com/rust-lang/rust/issues/133416> for more information
    = help: add `#![feature(asm_experimental_reg)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error: aborting due to 1 previous error
+error[E0658]: register class `vreg` can only be used as a clobber in stable
+  --> $DIR/feature-gate-asm_experimental_reg.rs:21:54
+   |
+LL |     asm!("xvadd.h {1:u}, {0:u}, {0:u}", out(vreg) y, in(vreg) x);
+   |                                                      ^^^^^^^^^^
+   |
+   = note: see issue #133416 <https://github.com/rust-lang/rust/issues/133416> for more information
+   = help: add `#![feature(asm_experimental_reg)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: type `i8x16` cannot be used with this register class in stable
+  --> $DIR/feature-gate-asm_experimental_reg.rs:21:51
+   |
+LL |     asm!("xvadd.h {1:u}, {0:u}, {0:u}", out(vreg) y, in(vreg) x);
+   |                                                   ^
+   |
+   = note: see issue #133416 <https://github.com/rust-lang/rust/issues/133416> for more information
+   = help: add `#![feature(asm_experimental_reg)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: type `i8x16` cannot be used with this register class in stable
+  --> $DIR/feature-gate-asm_experimental_reg.rs:21:63
+   |
+LL |     asm!("xvadd.h {1:u}, {0:u}, {0:u}", out(vreg) y, in(vreg) x);
+   |                                                               ^
+   |
+   = note: see issue #133416 <https://github.com/rust-lang/rust/issues/133416> for more information
+   = help: add `#![feature(asm_experimental_reg)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0658`.