diff --git a/.github/workflows/failures.yml b/.github/workflows/failures.yml
index 2c9e4950706..52e96726129 100644
--- a/.github/workflows/failures.yml
+++ b/.github/workflows/failures.yml
@@ -98,7 +98,14 @@ jobs:
       if: matrix.libgccjit_version.gcc != 'libgccjit12.so'
       id: tests
       run: |
-        ${{ matrix.libgccjit_version.env_extra }} ./y.sh test --release --clean --build-sysroot --test-failing-rustc ${{ matrix.libgccjit_version.extra }} 2>&1 | tee output_log
+        # Without this, `tee` masks the exit status of `y.sh test`.
+        set -o pipefail
+        status=0
+        ${{ matrix.libgccjit_version.env_extra }} ./y.sh test --release --clean --build-sysroot --test-failing-rustc ${{ matrix.libgccjit_version.extra }} 2>&1 | tee output_log || status=$?
+        # This suite runs the tests known to fail, so only a build system error must fail the job.
+        if [ "$status" -ne 0 ] && [ "$status" -ne 2 ]; then
+          exit "$status"
+        fi
         rg --text "test result" output_log >> $GITHUB_STEP_SUMMARY
 
     - name: Run failing ui pattern tests for ICE
@@ -106,7 +113,14 @@ jobs:
       if: matrix.libgccjit_version.gcc != 'libgccjit12.so'
       id: ui-tests
       run: |
-        ${{ matrix.libgccjit_version.env_extra }} ./y.sh test --release --test-failing-ui-pattern-tests ${{ matrix.libgccjit_version.extra }} 2>&1 | tee output_log_ui
+        # Without this, `tee` masks the exit status of `y.sh test`.
+        set -o pipefail
+        status=0
+        ${{ matrix.libgccjit_version.env_extra }} ./y.sh test --release --test-failing-ui-pattern-tests ${{ matrix.libgccjit_version.extra }} 2>&1 | tee output_log_ui || status=$?
+        # This suite runs tests that fail, so only a build system error must fail the job here.
+        if [ "$status" -ne 0 ] && [ "$status" -ne 2 ]; then
+          exit "$status"
+        fi
         if grep -q "the compiler unexpectedly panicked" output_log_ui; then
           echo "Error: 'the compiler unexpectedly panicked' found in output logs. CI Error!!"
           exit 1
diff --git a/build_system/src/build.rs b/build_system/src/build.rs
index 2fc4d970545..bcd386bfebd 100644
--- a/build_system/src/build.rs
+++ b/build_system/src/build.rs
@@ -132,6 +132,24 @@ pub fn build_sysroot(env: &HashMap<String, String>, config: &ConfigInfo) -> Resu
 
     // Builds libs
     let mut rustflags = env.get("RUSTFLAGS").cloned().unwrap_or_default();
+
+    // Record the sysroot sources under the path the `rust-src` component uses, which is where
+    // rustc looks for them to turn a sysroot span into `/rustc/$hash`. Without this, ui tests
+    // print the build path where they expect `$SRC_DIR`.
+    let sysroot_source_dir = lib_path.join("rustlib/src/rust/library");
+    rustflags.push_str(&format!(
+        " --remap-path-prefix={library_dir}={sysroot_source_dir}",
+        library_dir = std::path::absolute(&library_dir)
+            .map_err(|error| format!(
+                "Failed to get the absolute path of the sysroot sources: {error:?}"
+            ))?
+            .display(),
+        sysroot_source_dir = std::path::absolute(&sysroot_source_dir)
+            .map_err(|error| format!(
+                "Failed to get the absolute path of the sysroot sources: {error:?}"
+            ))?
+            .display(),
+    ));
     if config.sysroot_panic_abort {
         rustflags.push_str(" -Cpanic=abort -Zpanic-abort-tests");
     }
diff --git a/build_system/src/main.rs b/build_system/src/main.rs
index 83f07a758d6..37b1f306817 100644
--- a/build_system/src/main.rs
+++ b/build_system/src/main.rs
@@ -112,6 +112,9 @@ fn main() {
         Command::CheckTodo => todo::run(),
     } {
         eprintln!("Command failed to run: {e}");
-        process::exit(1);
+        // CI needs to tell a build system error apart from the test failures some suites expect.
+        let exit_code =
+            if e == test::TESTS_FAILED_ERROR { test::TESTS_FAILED_EXIT_CODE } else { 1 };
+        process::exit(exit_code);
     }
 }
diff --git a/build_system/src/test.rs b/build_system/src/test.rs
index 2e9a67f9a8c..a5e79d6f3c1 100644
--- a/build_system/src/test.rs
+++ b/build_system/src/test.rs
@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::ffi::OsStr;
 use std::fs::{File, read_to_string, remove_dir_all};
 use std::io::{BufRead, BufReader};
@@ -15,6 +15,15 @@ use crate::utils::{
     run_command_with_output_and_env_no_err, rustc_version_info, split_args, walk_dir,
 };
 
+/// Exit code of `y.sh test` when the tests ran and reported failures, as opposed to the build
+/// system failing to run them at all. CI relies on the distinction: the suites of known-failing
+/// tests are expected to report failures, but a broken build system must never pass silently.
+pub const TESTS_FAILED_EXIT_CODE: i32 = 2;
+
+/// The error returned for that case. `main` compares against it to pick the exit code, so no other
+/// error may use this message.
+pub const TESTS_FAILED_ERROR: &str = "the test suite reported failures";
+
 type Env = HashMap<String, String>;
 type Runner = fn(&Env, &TestArg) -> Result<(), String>;
 type Runners = HashMap<&'static str, (&'static str, Runner)>;
@@ -1091,60 +1100,55 @@ where
     }
 
     if test_type == "ui" {
-        if run_error_pattern_test {
-            // After we removed the error tests that are known to panic with rustc_codegen_gcc, we now remove the passing tests since this runs the error tests.
-            walk_dir(
-                rust_path.join("tests/ui"),
-                &mut |_dir| Ok(()),
-                &mut |file_path| {
-                    if contains_ui_error_patterns(file_path, args.keep_lto_tests)? {
-                        Ok(())
-                    } else {
-                        remove_file(file_path).map_err(|e| e.to_string())
-                    }
-                },
-                true,
-            )?;
-        } else {
-            // 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> {
-                move |dir| {
-                    if dir.file_name().map(|name| name == "auxiliary").unwrap_or(true) {
-                        return Ok(());
-                    }
-
-                    walk_dir(
-                        dir,
-                        &mut dir_handling(keep_lto_tests),
-                        &mut file_handling(keep_lto_tests),
-                        false,
-                    )
+        // Each mode runs one half of the ui tests and removes the other: `run_error_pattern_test`
+        // runs the tests expected to error, the other mode runs the rest. Only `.rs` files outside
+        // `auxiliary` are tests, so the expected output and the auxiliary crates are left alone.
+        fn dir_handling(
+            keep_lto_tests: bool,
+            remove_error_pattern_tests: bool,
+        ) -> impl Fn(&Path) -> Result<(), String> {
+            move |dir| {
+                if dir.file_name().map(|name| name == "auxiliary").unwrap_or(true) {
+                    return Ok(());
                 }
+
+                walk_dir(
+                    dir,
+                    &mut dir_handling(keep_lto_tests, remove_error_pattern_tests),
+                    &mut file_handling(keep_lto_tests, remove_error_pattern_tests),
+                    false,
+                )
             }
+        }
 
-            fn file_handling(keep_lto_tests: bool) -> impl Fn(&Path) -> Result<(), String> {
-                move |file_path| {
-                    if !file_path.extension().map(|extension| extension == "rs").unwrap_or(false) {
-                        return Ok(());
-                    }
-                    let path_str = file_path.display().to_string().replace("\\", "/");
-                    if valid_ui_error_pattern_test(&path_str) {
-                        return Ok(());
-                    } else if contains_ui_error_patterns(file_path, keep_lto_tests)? {
-                        return remove_file(&file_path);
-                    }
-                    Ok(())
+        fn file_handling(
+            keep_lto_tests: bool,
+            remove_error_pattern_tests: bool,
+        ) -> impl Fn(&Path) -> Result<(), String> {
+            move |file_path| {
+                if !file_path.extension().map(|extension| extension == "rs").unwrap_or(false) {
+                    return Ok(());
                 }
+                let path_str = file_path.display().to_string().replace("\\", "/");
+                if valid_ui_error_pattern_test(&path_str) {
+                    return Ok(());
+                }
+                if contains_ui_error_patterns(file_path, keep_lto_tests)?
+                    == remove_error_pattern_tests
+                {
+                    return remove_file(file_path);
+                }
+                Ok(())
             }
-
-            walk_dir(
-                rust_path.join("tests/ui"),
-                &mut dir_handling(args.keep_lto_tests),
-                &mut file_handling(args.keep_lto_tests),
-                false,
-            )?;
         }
+
+        let remove_error_pattern_tests = !run_error_pattern_test;
+        walk_dir(
+            rust_path.join("tests/ui"),
+            &mut dir_handling(args.keep_lto_tests, remove_error_pattern_tests),
+            &mut file_handling(args.keep_lto_tests, remove_error_pattern_tests),
+            false,
+        )?;
         if let Some(retained_tests_list_path) = retained_tests_list_path {
             check_for_dead_listed_tests(&rust_path, retained_tests_list_path)?;
         }
@@ -1221,8 +1225,57 @@ where
         &"--bypass-ignore-backends",
     ];
 
-    run_command_with_output_and_env(&command, Some(&rust_path), Some(&env))?;
-    Ok(())
+    run_test_command(&command, &rust_path, &env)
+}
+
+/// Reads the list of tests at `list_path`, checking that each of them still exists in the rust
+/// checkout at `rust_path` and that none is listed twice.
+///
+/// Both problems make a line a no-op: the test it names is neither kept nor removed, so the test
+/// suite silently drifts away from what the list claims to describe.
+fn read_test_list(rust_path: &Path, list_path: &str) -> Result<Vec<String>, String> {
+    let content = std::fs::read_to_string(list_path)
+        .map_err(|error| format!("Failed to read `{list_path}`: {error:?}"))?;
+
+    let mut tests = Vec::new();
+    let mut seen = HashSet::new();
+    let mut missing = Vec::new();
+    let mut duplicated = Vec::new();
+
+    for line in content.lines().map(|line| line.trim()).filter(|line| !line.is_empty()) {
+        if !seen.insert(line) {
+            duplicated.push(line);
+            continue;
+        }
+        if !rust_path.join(line.trim_end_matches('/')).exists() {
+            missing.push(line);
+        }
+        tests.push(line.to_string());
+    }
+
+    if missing.is_empty() && duplicated.is_empty() {
+        return Ok(tests);
+    }
+
+    let mut error = format!("`{list_path}` is out of date:\n");
+    if !missing.is_empty() {
+        error.push_str(&format!(
+            "\nThese tests no longer exist in `{rust_path}`:\n{missing}\n",
+            rust_path = rust_path.display(),
+            missing = missing.join("\n"),
+        ));
+    }
+    if !duplicated.is_empty() {
+        error.push_str(&format!(
+            "\nThese tests are listed more than once:\n{}\n",
+            duplicated.join("\n")
+        ));
+    }
+    error.push_str(
+        "\nEvery line must name a test that exists, exactly once, otherwise the line filters \
+         nothing. Delete the stale lines, or update them to the test's current path.",
+    );
+    Err(error)
 }
 
 /// Checks that every test listed in `list_path` survived the filtering done by
@@ -1281,14 +1334,29 @@ fn test_failing_rustc(env: &Env, args: &TestArg) -> Result<(), String> {
         Some("tests/failing-ui-tests.txt"),
     );
 
-    run_make_result.and(run_make_cargo_result).and(ui_result)
+    combine_test_results([run_make_result, run_make_cargo_result, ui_result])
+}
+
+/// Combines the results of several test suites, letting a build system error win over a test
+/// failure so that a broken build system is never reported to CI as the failures those suites
+/// expect.
+fn combine_test_results<const N: usize>(results: [Result<(), String>; N]) -> Result<(), String> {
+    let mut tests_failed = false;
+    for result in results {
+        match result {
+            Ok(()) => {}
+            Err(error) if error == TESTS_FAILED_ERROR => tests_failed = true,
+            Err(error) => return Err(error),
+        }
+    }
+    if tests_failed { Err(TESTS_FAILED_ERROR.to_string()) } else { Ok(()) }
 }
 
 fn test_successful_rustc(env: &Env, args: &TestArg) -> Result<(), String> {
     test_rustc_inner(
         env,
         args,
-        remove_files_callback("tests/failing-ui-tests.txt", "ui"),
+        remove_files_callback("tests/failing-ui-tests.txt"),
         false,
         "ui",
         None,
@@ -1296,7 +1364,7 @@ fn test_successful_rustc(env: &Env, args: &TestArg) -> Result<(), String> {
     test_rustc_inner(
         env,
         args,
-        remove_files_callback("tests/failing-run-make-tests.txt", "run-make"),
+        remove_files_callback("tests/failing-run-make-tests.txt"),
         false,
         "run-make",
         None,
@@ -1304,7 +1372,7 @@ fn test_successful_rustc(env: &Env, args: &TestArg) -> Result<(), String> {
     test_rustc_inner(
         env,
         args,
-        remove_files_callback("tests/failing-run-make-tests.txt", "run-make-cargo"),
+        remove_files_callback("tests/failing-run-make-tests.txt"),
         false,
         "run-make-cargo",
         None,
@@ -1315,7 +1383,7 @@ fn test_failing_ui_pattern_tests(env: &Env, args: &TestArg) -> Result<(), String
     test_rustc_inner(
         env,
         args,
-        remove_files_callback("tests/failing-ice-tests.txt", "ui"),
+        remove_files_callback("tests/failing-ice-tests.txt"),
         true,
         "ui",
         None,
@@ -1358,7 +1426,20 @@ fn run_ui_tests(env: &Env, args: &TestArg) -> Result<(), String> {
         command.push(test_name);
     }
 
-    run_command_with_output_and_env(&command, Some(&rust_path), Some(&env))?;
+    run_test_command(&command, &rust_path, &env)
+}
+
+/// Runs the command that actually runs a test suite, mapping its failure to `TESTS_FAILED_ERROR`.
+fn run_test_command(
+    command: &[&dyn AsRef<OsStr>],
+    rust_path: &Path,
+    env: &Env,
+) -> Result<(), String> {
+    if let Err(error) = run_command_with_output_and_env(command, Some(rust_path), Some(env)) {
+        // The failures themselves were already streamed to the console.
+        eprintln!("{error}");
+        return Err(TESTS_FAILED_ERROR.to_string());
+    }
     Ok(())
 }
 
@@ -1367,8 +1448,8 @@ fn retain_files_callback<'a>(
     test_type: &'a str,
 ) -> impl Fn(&Path) -> Result<bool, String> + 'a {
     move |rust_path| {
-        let files = std::fs::read_to_string(file_path).unwrap_or_default();
-        let first_file_name = files.lines().next().unwrap_or("");
+        let tests = read_test_list(rust_path, file_path)?;
+        let first_file_name = tests.first().map(String::as_str).unwrap_or("");
         // If the first line ends with a `/`, we treat all lines in the file as a directory.
         if first_file_name.ends_with('/') {
             // Treat as directory
@@ -1410,53 +1491,31 @@ fn retain_files_callback<'a>(
         }
 
         // Putting back only the failing ones.
-        if let Ok(files) = std::fs::read_to_string(file_path) {
-            for file in files.split('\n').map(|line| line.trim()).filter(|line| !line.is_empty()) {
-                run_command(&[&"git", &"checkout", &"--", &file], Some(rust_path))?;
-            }
-        } else {
-            println!("Failed to read `{file_path}`, not putting back failing {test_type} tests");
+        for test in &tests {
+            run_command(&[&"git", &"checkout", &"--", test], Some(rust_path))?;
         }
 
         Ok(true)
     }
 }
 
-fn remove_files_callback<'a>(
-    file_path: &'a str,
-    test_type: &'a str,
-) -> impl Fn(&Path) -> Result<bool, String> + 'a {
+fn remove_files_callback(file_path: &str) -> impl Fn(&Path) -> Result<bool, String> + '_ {
     move |rust_path| {
-        let files = std::fs::read_to_string(file_path).unwrap_or_default();
-        let first_file_name = files.lines().next().unwrap_or("");
+        let tests = read_test_list(rust_path, file_path)?;
+        let first_file_name = tests.first().map(String::as_str).unwrap_or("");
         // If the first line ends with a `/`, we treat all lines in the file as a directory.
         if first_file_name.ends_with('/') {
             // Removing the failing tests.
-            if let Ok(files) = std::fs::read_to_string(file_path) {
-                for file in
-                    files.split('\n').map(|line| line.trim()).filter(|line| !line.is_empty())
-                {
-                    let path = rust_path.join(file);
-                    if let Err(e) = remove_dir_all(&path) {
-                        println!("Failed to remove directory `{}`: {}", path.display(), e);
-                    }
-                }
-            } else {
-                println!(
-                    "Failed to read `{file_path}`, not putting back failing {test_type} tests"
-                );
+            for test in &tests {
+                let path = rust_path.join(test);
+                remove_dir_all(&path).map_err(|error| {
+                    format!("Failed to remove directory `{}`: {error}", path.display())
+                })?;
             }
         } else {
             // Removing the failing tests.
-            if let Ok(files) = std::fs::read_to_string(file_path) {
-                for file in
-                    files.split('\n').map(|line| line.trim()).filter(|line| !line.is_empty())
-                {
-                    let path = rust_path.join(file);
-                    remove_file(&path)?;
-                }
-            } else {
-                println!("Failed to read `{file_path}`, not putting back failing ui tests");
+            for test in &tests {
+                remove_file(&rust_path.join(test))?;
             }
         }
         Ok(true)
@@ -1563,3 +1622,58 @@ pub fn run() -> Result<(), String> {
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn write_test_list(directory: &Path, content: &str) -> PathBuf {
+        let list_path = directory.join("failing-tests.txt");
+        std::fs::write(&list_path, content).unwrap();
+        list_path
+    }
+
+    #[test]
+    fn test_combine_test_results() {
+        let tests_failed = || Err(TESTS_FAILED_ERROR.to_string());
+        let build_error = || Err("could not clone rust".to_string());
+
+        assert_eq!(combine_test_results([Ok(()), Ok(())]), Ok(()));
+        assert_eq!(combine_test_results([Ok(()), tests_failed()]), tests_failed());
+        assert_eq!(combine_test_results([Ok(()), build_error()]), build_error());
+        // A build system error wins, whichever suite reported it.
+        assert_eq!(combine_test_results([tests_failed(), build_error()]), build_error());
+        assert_eq!(combine_test_results([build_error(), tests_failed()]), build_error());
+    }
+
+    #[test]
+    fn test_read_test_list() {
+        let rust_path = std::env::temp_dir().join("cg_gcc_read_test_list");
+        let _ = remove_dir_all(&rust_path);
+        create_dir(rust_path.join("tests/ui")).unwrap();
+        std::fs::write(rust_path.join("tests/ui/alive.rs"), "").unwrap();
+
+        let list_path = write_test_list(&rust_path, "\ntests/ui/alive.rs\n  \n");
+        let list_path = list_path.display().to_string();
+        assert_eq!(
+            read_test_list(&rust_path, &list_path),
+            Ok(vec!["tests/ui/alive.rs".to_string()])
+        );
+
+        write_test_list(&rust_path, "tests/ui/alive.rs\ntests/ui/gone.rs\n");
+        let error = read_test_list(&rust_path, &list_path).unwrap_err();
+        assert!(error.contains("no longer exist"), "{error}");
+        assert!(error.contains("tests/ui/gone.rs"), "{error}");
+
+        write_test_list(&rust_path, "tests/ui/alive.rs\ntests/ui/alive.rs\n");
+        let error = read_test_list(&rust_path, &list_path).unwrap_err();
+        assert!(error.contains("listed more than once"), "{error}");
+        assert!(error.contains("tests/ui/alive.rs"), "{error}");
+
+        // Directories are listed with a trailing `/`.
+        write_test_list(&rust_path, "tests/ui/\n");
+        assert_eq!(read_test_list(&rust_path, &list_path), Ok(vec!["tests/ui/".to_string()]));
+
+        remove_dir_all(&rust_path).unwrap();
+    }
+}
diff --git a/tests/failing-ice-tests.txt b/tests/failing-ice-tests.txt
index ff1b6f14894..ca685eb2af7 100644
--- a/tests/failing-ice-tests.txt
+++ b/tests/failing-ice-tests.txt
@@ -10,7 +10,6 @@ tests/ui/simd/intrinsic/generic-arithmetic-saturating-2.rs
 tests/ui/simd/intrinsic/generic-arithmetic-2.rs
 tests/ui/panics/default-backtrace-ice.rs
 tests/ui/mir/lint/storage-live.rs
-tests/ui/layout/valid_range_oob.rs
 tests/ui/higher-ranked/trait-bounds/future.rs
 tests/ui/consts/const-eval/const-eval-query-stack.rs
 tests/ui/simd/masked-load-store.rs
@@ -28,13 +27,17 @@ tests/ui/lto/thin-lto-global-allocator.rs
 tests/ui/lto/msvc-imp-present.rs
 tests/ui/lto/dylib-works.rs
 tests/ui/lto/all-crates.rs
-tests/ui/issues/issue-47364.rs
+tests/ui/codegen/no-segfault-with-multiple-codegen-units.rs
 tests/ui/functions-closures/parallel-codegen-closures.rs
 tests/ui/sepcomp/sepcomp-unwind.rs
 tests/ui/extern/issue-64655-extern-rust-must-allow-unwind.rs
 tests/ui/extern/issue-64655-allow-unwind-when-calling-panic-directly.rs
-tests/ui/unwind-no-uwtable.rs
+tests/ui/panics/unwind-force-no-unwind-tables.rs
 tests/ui/delegation/fn-header.rs
 tests/ui/simd/intrinsic/generic-arithmetic-pass.rs
-tests/ui/simd/masked-load-store.rs
-tests/ui/rfcs/rfc-2632-const-trait-impl/effects/minicore.rs
+tests/ui/codegen/unknown-llvm-intrinsic.rs
+tests/ui/codegen/incorrect-llvm-intrinsic-signature.rs
+tests/ui/codegen/incorrect-arch-intrinsic.rs
+tests/ui/codegen/custom-target-invalid-llvm-target.rs
+tests/ui/asm/x86_64/naked_asm_escape.rs
+tests/ui/lto/debuginfo-lto-alloc.rs
diff --git a/tests/failing-run-make-tests.txt b/tests/failing-run-make-tests.txt
index 1feb2c7cc6e..d5297e069f7 100644
--- a/tests/failing-run-make-tests.txt
+++ b/tests/failing-run-make-tests.txt
@@ -11,5 +11,5 @@ tests/run-make/foreign-exceptions/
 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
+tests/run-make/short-ice/
+tests/run-make/embed-source-dwarf/