diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 87c941cdeb23a..158f164bd57b4 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -2043,17 +2043,31 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
             let is_diag = self.tcx.sess.opts.unstable_opts.sanitizer_cfi_diag.unwrap_or(false);
             let is_recover =
                 self.tcx.sess.opts.unstable_opts.sanitizer_cfi_recover.unwrap_or(false);
+            let is_minimal =
+                self.tcx.sess.opts.unstable_opts.sanitizer_cfi_minimal_runtime.unwrap_or(false);
 
             if is_diag || is_recover {
-                let fty = self.cx.type_func(
-                    &[self.cx.type_ptr(), self.cx.type_isize(), self.cx.type_isize()],
-                    self.cx.type_void(),
-                );
+                let fty = if is_minimal {
+                    self.cx.type_func(&[], self.cx.type_void())
+                } else {
+                    self.cx.type_func(
+                        &[self.cx.type_ptr(), self.cx.type_isize(), self.cx.type_isize()],
+                        self.cx.type_void(),
+                    )
+                };
                 let ubsan_handler = self.declare_cfn(
                     if is_recover {
-                        "__ubsan_handle_cfi_check_fail"
+                        if is_minimal {
+                            "__ubsan_handle_cfi_check_fail_minimal"
+                        } else {
+                            "__ubsan_handle_cfi_check_fail"
+                        }
                     } else {
-                        "__ubsan_handle_cfi_check_fail_abort"
+                        if is_minimal {
+                            "__ubsan_handle_cfi_check_fail_minimal_abort"
+                        } else {
+                            "__ubsan_handle_cfi_check_fail_abort"
+                        }
                     },
                     llvm::UnnamedAddr::Global,
                     fty,
@@ -2079,15 +2093,12 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
                     self.generate_ubsan_cfi_diag_data(self.span, expected_ty, check_kind);
 
                 let function_address = self.ptrtoint(llfn, self.cx.type_isize());
-                self.call(
-                    fty,
-                    None,
-                    None,
-                    ubsan_handler,
-                    &[diag_data, function_address, self.const_usize(0)],
-                    None,
-                    None,
-                );
+                let arguments: &[_] = if is_minimal {
+                    &[]
+                } else {
+                    &[diag_data, function_address, self.const_usize(0)]
+                };
+                self.call(fty, None, None, ubsan_handler, arguments, None, None);
                 if is_recover {
                     self.br(bb_pass);
                 } else {
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 25003e071beb7..e7a024dba4ff3 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -1765,7 +1765,11 @@ fn add_sanitizer_libraries(
         && (sess.opts.unstable_opts.sanitizer_cfi_diag.unwrap_or(false)
             || sess.opts.unstable_opts.sanitizer_cfi_recover.unwrap_or(false))
     {
-        link_sanitizer_runtime(sess, flavor, linker, "ubsan");
+        if sess.opts.unstable_opts.sanitizer_cfi_minimal_runtime.unwrap_or(false) {
+            link_sanitizer_runtime(sess, flavor, linker, "ubsan_minimal");
+        } else {
+            link_sanitizer_runtime(sess, flavor, linker, "ubsan");
+        }
     }
 }
 
diff --git a/compiler/rustc_session/src/diagnostics.rs b/compiler/rustc_session/src/diagnostics.rs
index e8f29d8a9ee77..1930a62ca44fc 100644
--- a/compiler/rustc_session/src/diagnostics.rs
+++ b/compiler/rustc_session/src/diagnostics.rs
@@ -337,6 +337,24 @@ pub(crate) struct SanitizerCfiGeneralizePointersRequiresCfi;
 #[diag("`-Zsanitizer-cfi-normalize-integers` requires `-Zsanitizer=cfi` or `-Zsanitizer=kcfi`")]
 pub(crate) struct SanitizerCfiNormalizeIntegersRequiresCfi;
 
+#[derive(Diagnostic)]
+#[diag("`-Zsanitizer-cfi-recover` requires `-Zsanitizer=cfi`")]
+pub(crate) struct SanitizerCfiRecoverRequiresCfi;
+
+#[derive(Diagnostic)]
+#[diag("`-Zsanitizer-cfi-diag` requires `-Zsanitizer=cfi`")]
+pub(crate) struct SanitizerCfiDiagRequiresCfi;
+
+#[derive(Diagnostic)]
+#[diag("`-Zsanitizer-cfi-minimal-runtime` requires `-Zsanitizer=cfi`")]
+pub(crate) struct SanitizerCfiMinimalRuntimeRequiresCfi;
+
+#[derive(Diagnostic)]
+#[diag(
+    "`-Zsanitizer-cfi-minimal-runtime` requires `-Zsanitizer-cfi-recover` or `-Zsanitizer-cfi-diag`"
+)]
+pub(crate) struct SanitizerCfiMinimalRuntimeRequiresCfiRecoverOrDiag;
+
 #[derive(Diagnostic)]
 #[diag("`-Zsanitizer-kcfi-arity` requires `-Zsanitizer=kcfi`")]
 pub(crate) struct SanitizerKcfiArityRequiresKcfi;
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index a075a088d206c..1fc94a841f808 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -134,6 +134,21 @@ mod target_modifier_consistency_check {
         }
         true
     }
+    pub(super) fn sanitizer_cfi_minimal_runtime(
+        sess: &Session,
+        l: &TargetModifier,
+        r: Option<&TargetModifier>,
+    ) -> bool {
+        // For CFI, the helper flag -Zsanitizer-cfi-minimal-runtime should also be a target modifier
+        if sess.sanitizers().contains(SanitizerSet::CFI) {
+            if let Some(r) = r {
+                return l.extend().tech_value == r.extend().tech_value;
+            } else {
+                return false;
+            }
+        }
+        true
+    }
     pub(super) fn target_cpu(
         sess: &Session,
         l: &TargetModifier,
@@ -176,6 +191,11 @@ impl TargetModifier {
                         sess, self, other,
                     );
                 }
+                UnstableOptionsTargetModifiers::SanitizerCfiMinimalRuntime => {
+                    return target_modifier_consistency_check::sanitizer_cfi_minimal_runtime(
+                        sess, self, other,
+                    );
+                }
                 _ => {}
             },
             OptionsTargetModifiers::CodegenOptions(codegen) => match codegen {
@@ -2821,6 +2841,8 @@ written to standard error output)"),
         "enable CFI diagnostics (default: no)"),
     sanitizer_cfi_recover: Option<bool> = (None, parse_opt_bool, [TRACKED],
         "enable CFI recovery (default: no)"),
+    sanitizer_cfi_minimal_runtime: Option<bool> = (None, parse_opt_bool, [TRACKED] { TARGET_MODIFIER: SanitizerCfiMinimalRuntime },
+        "enable minimal UBSan runtime for CFI (default: no)"),
     sanitizer_dataflow_abilist: Vec<String> = (Vec::new(), parse_comma_list, [TRACKED],
         "additional ABI list files that control how shadow parameters are passed (comma separated)"),
     sanitizer_kcfi_arity: Option<bool> = (None, parse_opt_bool, [TRACKED],
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index f04f40dd17168..66d382e66b874 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -605,6 +605,18 @@ impl Session {
         self.opts.unstable_opts.sanitizer_cfi_normalize_integers == Some(true)
     }
 
+    pub fn is_sanitizer_cfi_recover_enabled(&self) -> bool {
+        self.opts.unstable_opts.sanitizer_cfi_recover == Some(true)
+    }
+
+    pub fn is_sanitizer_cfi_diag_enabled(&self) -> bool {
+        self.opts.unstable_opts.sanitizer_cfi_diag == Some(true)
+    }
+
+    pub fn is_sanitizer_cfi_minimal_runtime_enabled(&self) -> bool {
+        self.opts.unstable_opts.sanitizer_cfi_minimal_runtime == Some(true)
+    }
+
     pub fn is_sanitizer_kcfi_arity_enabled(&self) -> bool {
         self.opts.unstable_opts.sanitizer_kcfi_arity == Some(true)
     }
@@ -1579,6 +1591,30 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
         }
     }
 
+    // LLVM CFI recovery requires CFI.
+    if sess.is_sanitizer_cfi_recover_enabled() {
+        if !sess.is_sanitizer_cfi_enabled() {
+            sess.dcx().emit_err(diagnostics::SanitizerCfiRecoverRequiresCfi);
+        }
+    }
+
+    // LLVM CFI diagnostics requires CFI.
+    if sess.is_sanitizer_cfi_diag_enabled() {
+        if !sess.is_sanitizer_cfi_enabled() {
+            sess.dcx().emit_err(diagnostics::SanitizerCfiDiagRequiresCfi);
+        }
+    }
+
+    // LLVM CFI minimal runtime requires CFI Recover or CFI Diag.
+    if sess.is_sanitizer_cfi_minimal_runtime_enabled() {
+        if !sess.is_sanitizer_cfi_enabled() {
+            sess.dcx().emit_err(diagnostics::SanitizerCfiMinimalRuntimeRequiresCfi);
+        }
+        if !(sess.is_sanitizer_cfi_recover_enabled() || sess.is_sanitizer_cfi_diag_enabled()) {
+            sess.dcx().emit_err(diagnostics::SanitizerCfiMinimalRuntimeRequiresCfiRecoverOrDiag);
+        }
+    }
+
     // LLVM CFI integer normalization requires CFI or KCFI.
     if sess.is_sanitizer_cfi_normalize_integers_enabled() {
         if !(sess.is_sanitizer_cfi_enabled() || sess.is_sanitizer_kcfi_enabled()) {
diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs
index 81e0726f414cc..15fb29baf13fd 100644
--- a/src/bootstrap/src/core/build_steps/llvm.rs
+++ b/src/bootstrap/src/core/build_steps/llvm.rs
@@ -1901,7 +1901,7 @@ fn supported_sanitizers(
         "aarch64-unknown-linux-gnu" => common_libs(
             "linux",
             "aarch64",
-            &["asan", "lsan", "msan", "tsan", "hwasan", "rtsan", "ubsan"],
+            &["asan", "lsan", "msan", "tsan", "hwasan", "rtsan", "ubsan", "ubsan_minimal"],
         ),
         "aarch64-unknown-linux-ohos" => {
             common_libs("linux", "aarch64", &["asan", "lsan", "msan", "tsan", "hwasan"])
@@ -1922,7 +1922,17 @@ fn supported_sanitizers(
         "x86_64-unknown-linux-gnu" => common_libs(
             "linux",
             "x86_64",
-            &["asan", "dfsan", "lsan", "msan", "safestack", "tsan", "rtsan", "ubsan"],
+            &[
+                "asan",
+                "dfsan",
+                "lsan",
+                "msan",
+                "safestack",
+                "tsan",
+                "rtsan",
+                "ubsan",
+                "ubsan_minimal",
+            ],
         ),
         "x86_64-unknown-linux-gnuasan" => common_libs("linux", "x86_64", &["asan"]),
         "x86_64-unknown-linux-gnumsan" => common_libs("linux", "x86_64", &["msan"]),
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-checks-diag-mode.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-checks-diag-mode.rs
index 07688a8e5cb0b..4d58872db7c45 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-checks-diag-mode.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-checks-diag-mode.rs
@@ -1,7 +1,9 @@
 // Verifies that pointer type membership tests for indirect calls are emitted.
 //
+//@ revisions: cfi-diag cfi-diag-minimal-runtime
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-diag=true -Copt-level=0 -C unsafe-allow-abi-mismatch=sanitizer
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-diag=true -Copt-level=0 -C unsafe-allow-abi-mismatch=sanitizer,sanitizer-cfi-minimal-runtime
+//@ [cfi-diag-minimal-runtime] compile-flags: -Zsanitizer-cfi-minimal-runtime=true
 
 #![crate_type = "lib"]
 
@@ -14,7 +16,8 @@ pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
     // CHECK-NEXT:  {{%.+}} = call i32 %f(i32{{.*}} %arg)
     // CHECK:       type_test.fail:
     // CHECK-NEXT:  {{%.+}} = ptrtoint ptr {{%f|%0}} to i64
-    // CHECK-NEXT:  call void @__ubsan_handle_cfi_check_fail_abort(
+    // cfi-diag-NEXT:                 call void @__ubsan_handle_cfi_check_fail_abort(
+    // cfi-diag-minimal-runtime-NEXT: call void @__ubsan_handle_cfi_check_fail_minimal_abort()
     // CHECK-NEXT:  unreachable
     f(arg)
 }
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-checks-recover-mode.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-checks-recover-mode.rs
index 0dbcb7a833fb7..3ea97e44c21e7 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-checks-recover-mode.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-checks-recover-mode.rs
@@ -1,7 +1,9 @@
 // Verifies that pointer type membership tests for indirect calls are emitted.
 //
+//@ revisions: cfi-recover cfi-recover-minimal-runtime
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-recover=true -Copt-level=0 -C unsafe-allow-abi-mismatch=sanitizer
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-recover=true -Copt-level=0 -C unsafe-allow-abi-mismatch=sanitizer,sanitizer-cfi-minimal-runtime
+//@ [cfi-recover-minimal-runtime] compile-flags: -Zsanitizer-cfi-minimal-runtime=true
 
 #![crate_type = "lib"]
 
@@ -14,7 +16,8 @@ pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
     // CHECK-NEXT:  {{%.+}} = call i32 %f(i32{{.*}} %arg)
     // CHECK:       type_test.fail:
     // CHECK-NEXT:  {{%.+}} = ptrtoint ptr {{%f|%0}} to i64
-    // CHECK-NEXT:  call void @__ubsan_handle_cfi_check_fail(
+    // cfi-recover-NEXT:                 call void @__ubsan_handle_cfi_check_fail(
+    // cfi-recover-minimal-runtime-NEXT: call void @__ubsan_handle_cfi_check_fail_minimal()
     // CHECK-NEXT:  br label %type_test.pass
     f(arg)
 }
diff --git a/tests/run-make/sanitizer-cfi-runtime/program.rs b/tests/run-make/sanitizer-cfi-runtime/program.rs
new file mode 100644
index 0000000000000..0a46dcedef9de
--- /dev/null
+++ b/tests/run-make/sanitizer-cfi-runtime/program.rs
@@ -0,0 +1,17 @@
+use std::hint::black_box;
+use std::mem;
+
+fn add_one(x: i32) -> i32 {
+    x + 1
+}
+
+#[inline(never)]
+fn call_with_mismatch(f: fn(i32) -> i32) {
+    let g: fn(i32, i32) -> i32 = unsafe { mem::transmute(f) };
+    let res = g(1, 2);
+    assert_eq!(res, 2);
+}
+
+fn main() {
+    call_with_mismatch(black_box(add_one));
+}
diff --git a/tests/run-make/sanitizer-cfi-runtime/rmake.rs b/tests/run-make/sanitizer-cfi-runtime/rmake.rs
new file mode 100644
index 0000000000000..3cad996a14054
--- /dev/null
+++ b/tests/run-make/sanitizer-cfi-runtime/rmake.rs
@@ -0,0 +1,172 @@
+//@ needs-sanitizer-support
+//@ needs-sanitizer-cfi
+//@ ignore-backends: gcc
+
+use run_make_support::{run, run_fail, rustc};
+
+fn main() {
+    // 1. Check link args for default CFI (no diag/recover, no UBSan runtime)
+    let link_args_default = rustc()
+        .arg("-Clto")
+        .arg("-Ccodegen-units=1")
+        .arg("-Ctarget-feature=-crt-static")
+        .arg("-Cunsafe-allow-abi-mismatch=sanitizer")
+        .arg("-Zsanitizer=cfi")
+        .print("link-args")
+        .input("program.rs")
+        .run()
+        .stdout_utf8();
+    assert!(
+        !link_args_default.contains("ubsan"),
+        "did not expect any ubsan runtime in link args, got: {link_args_default}"
+    );
+
+    // 2. Check link args for full UBSan runtime with CFI diag mode
+    let link_args_full_diag = rustc()
+        .arg("-Clto")
+        .arg("-Ccodegen-units=1")
+        .arg("-Ctarget-feature=-crt-static")
+        .arg("-Cunsafe-allow-abi-mismatch=sanitizer")
+        .arg("-Zsanitizer=cfi")
+        .arg("-Zsanitizer-cfi-diag=true")
+        .print("link-args")
+        .input("program.rs")
+        .run()
+        .stdout_utf8();
+    assert!(
+        link_args_full_diag.contains("rt.ubsan.") || link_args_full_diag.contains("rt.ubsan\""),
+        "expected ubsan runtime in link args, got: {link_args_full_diag}"
+    );
+    assert!(
+        !link_args_full_diag.contains("ubsan_minimal"),
+        "did not expect ubsan_minimal in link args, got: {link_args_full_diag}"
+    );
+
+    // 3. Check link args for full UBSan runtime with CFI recover mode
+    let link_args_full_recover = rustc()
+        .arg("-Clto")
+        .arg("-Ccodegen-units=1")
+        .arg("-Ctarget-feature=-crt-static")
+        .arg("-Cunsafe-allow-abi-mismatch=sanitizer")
+        .arg("-Zsanitizer=cfi")
+        .arg("-Zsanitizer-cfi-recover=true")
+        .print("link-args")
+        .input("program.rs")
+        .run()
+        .stdout_utf8();
+    assert!(
+        link_args_full_recover.contains("rt.ubsan.")
+            || link_args_full_recover.contains("rt.ubsan\""),
+        "expected ubsan runtime in link args, got: {link_args_full_recover}"
+    );
+    assert!(
+        !link_args_full_recover.contains("ubsan_minimal"),
+        "did not expect ubsan_minimal in link args, got: {link_args_full_recover}"
+    );
+
+    // 4. Check link args for minimal UBSan runtime with CFI diag mode
+    let link_args_min_diag = rustc()
+        .arg("-Clto")
+        .arg("-Ccodegen-units=1")
+        .arg("-Ctarget-feature=-crt-static")
+        .arg("-Cunsafe-allow-abi-mismatch=sanitizer,sanitizer-cfi-minimal-runtime")
+        .arg("-Zsanitizer=cfi")
+        .arg("-Zsanitizer-cfi-diag=true")
+        .arg("-Zsanitizer-cfi-minimal-runtime=true")
+        .print("link-args")
+        .input("program.rs")
+        .run()
+        .stdout_utf8();
+    assert!(
+        link_args_min_diag.contains("rt.ubsan_minimal.")
+            || link_args_min_diag.contains("rt.ubsan_minimal\""),
+        "expected ubsan_minimal runtime in link args, got: {link_args_min_diag}"
+    );
+
+    // 5. Check link args for minimal UBSan runtime with CFI recover mode
+    let link_args_min_recover = rustc()
+        .arg("-Clto")
+        .arg("-Ccodegen-units=1")
+        .arg("-Ctarget-feature=-crt-static")
+        .arg("-Cunsafe-allow-abi-mismatch=sanitizer,sanitizer-cfi-minimal-runtime")
+        .arg("-Zsanitizer=cfi")
+        .arg("-Zsanitizer-cfi-recover=true")
+        .arg("-Zsanitizer-cfi-minimal-runtime=true")
+        .print("link-args")
+        .input("program.rs")
+        .run()
+        .stdout_utf8();
+    assert!(
+        link_args_min_recover.contains("rt.ubsan_minimal.")
+            || link_args_min_recover.contains("rt.ubsan_minimal\""),
+        "expected ubsan_minimal runtime in link args, got: {link_args_min_recover}"
+    );
+
+    // 6. Build and run binary with default CFI (trap mode, no runtime)
+    rustc()
+        .arg("-Clto")
+        .arg("-Ccodegen-units=1")
+        .arg("-Ctarget-feature=-crt-static")
+        .arg("-Cunsafe-allow-abi-mismatch=sanitizer")
+        .arg("-Zsanitizer=cfi")
+        .output("program_default")
+        .input("program.rs")
+        .run();
+    run_fail("program_default");
+
+    // 7. Build and run binary with full runtime in diag (abort) mode
+    rustc()
+        .arg("-Clto")
+        .arg("-Ccodegen-units=1")
+        .arg("-Ctarget-feature=-crt-static")
+        .arg("-Cunsafe-allow-abi-mismatch=sanitizer")
+        .arg("-Zsanitizer=cfi")
+        .arg("-Zsanitizer-cfi-diag=true")
+        .output("program_full_diag")
+        .input("program.rs")
+        .run();
+    run_fail("program_full_diag")
+        .assert_stderr_contains("runtime error: control flow integrity check for type");
+
+    // 8. Build and run binary with full runtime in recover mode
+    rustc()
+        .arg("-Clto")
+        .arg("-Ccodegen-units=1")
+        .arg("-Ctarget-feature=-crt-static")
+        .arg("-Cunsafe-allow-abi-mismatch=sanitizer")
+        .arg("-Zsanitizer=cfi")
+        .arg("-Zsanitizer-cfi-recover=true")
+        .output("program_full_recover")
+        .input("program.rs")
+        .run();
+    run("program_full_recover")
+        .assert_stderr_contains("runtime error: control flow integrity check for type");
+
+    // 9. Build and run binary with minimal runtime in diag (abort) mode
+    rustc()
+        .arg("-Clto")
+        .arg("-Ccodegen-units=1")
+        .arg("-Ctarget-feature=-crt-static")
+        .arg("-Cunsafe-allow-abi-mismatch=sanitizer,sanitizer-cfi-minimal-runtime")
+        .arg("-Zsanitizer=cfi")
+        .arg("-Zsanitizer-cfi-diag=true")
+        .arg("-Zsanitizer-cfi-minimal-runtime=true")
+        .output("program_min_diag")
+        .input("program.rs")
+        .run();
+    run_fail("program_min_diag").assert_stderr_contains("ubsan: cfi-check-fail");
+
+    // 10. Build and run binary with minimal runtime in recover mode
+    rustc()
+        .arg("-Clto")
+        .arg("-Ccodegen-units=1")
+        .arg("-Ctarget-feature=-crt-static")
+        .arg("-Cunsafe-allow-abi-mismatch=sanitizer,sanitizer-cfi-minimal-runtime")
+        .arg("-Zsanitizer=cfi")
+        .arg("-Zsanitizer-cfi-recover=true")
+        .arg("-Zsanitizer-cfi-minimal-runtime=true")
+        .output("program_min_recover")
+        .input("program.rs")
+        .run();
+    run("program_min_recover").assert_stderr_contains("ubsan: cfi-check-fail");
+}
diff --git a/tests/ui/sanitizer/cfi/diag-requires-cfi.rs b/tests/ui/sanitizer/cfi/diag-requires-cfi.rs
new file mode 100644
index 0000000000000..c7f1cd6f6fd02
--- /dev/null
+++ b/tests/ui/sanitizer/cfi/diag-requires-cfi.rs
@@ -0,0 +1,10 @@
+// Verifies that `-Zsanitizer-cfi-diag` requires `-Zsanitizer=cfi`.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer-cfi-diag
+
+#![feature(no_core)]
+#![no_core]
+#![no_main]
+
+//~? ERROR `-Zsanitizer-cfi-diag` requires `-Zsanitizer=cfi`
diff --git a/tests/ui/sanitizer/cfi/diag-requires-cfi.stderr b/tests/ui/sanitizer/cfi/diag-requires-cfi.stderr
new file mode 100644
index 0000000000000..85a32e3964407
--- /dev/null
+++ b/tests/ui/sanitizer/cfi/diag-requires-cfi.stderr
@@ -0,0 +1,4 @@
+error: `-Zsanitizer-cfi-diag` requires `-Zsanitizer=cfi`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/sanitizer/cfi/fn-ptr-type-mismatch-recover.rs b/tests/ui/sanitizer/cfi/fn-ptr-type-mismatch-recover.rs
new file mode 100644
index 0000000000000..069ac811f481d
--- /dev/null
+++ b/tests/ui/sanitizer/cfi/fn-ptr-type-mismatch-recover.rs
@@ -0,0 +1,38 @@
+// Verifies that calling a function pointer with a mismatched type with CFI
+// recovery enabled reports the failure and continues execution.
+
+//@ revisions: cfi cfi-minimal-runtime
+// FIXME(#122848) Remove only-linux once OSX CFI binaries work
+//@ only-linux
+//@ ignore-backends: gcc
+//@ [cfi] needs-sanitizer-cfi
+//@ [cfi] needs-sanitizer-support
+//@ [cfi-minimal-runtime] needs-sanitizer-cfi
+//@ [cfi-minimal-runtime] needs-sanitizer-support
+//@ compile-flags: -C target-feature=-crt-static
+//@ compile-flags: -C unsafe-allow-abi-mismatch=sanitizer,sanitizer-cfi-minimal-runtime
+//@ compile-flags: -C opt-level=0 -C codegen-units=1 -C lto
+//@ compile-flags: -C prefer-dynamic=off
+//@ compile-flags: -Z sanitizer=cfi
+//@ [cfi] compile-flags: -Z sanitizer-cfi-recover=true
+//@ [cfi-minimal-runtime] compile-flags: -Z sanitizer-cfi-recover=true
+//@ [cfi-minimal-runtime] compile-flags: -Z sanitizer-cfi-minimal-runtime=true
+//@ run-pass
+
+use std::hint::black_box;
+use std::mem;
+
+fn add_one(x: i32) -> i32 {
+    x + 1
+}
+
+#[inline(never)]
+fn call_with_mismatch(f: fn(i32) -> i32) {
+    let g: fn(i32, i32) -> i32 = unsafe { mem::transmute(f) };
+    let res = g(1, 2);
+    assert_eq!(res, 2);
+}
+
+fn main() {
+    call_with_mismatch(black_box(add_one));
+}
diff --git a/tests/ui/sanitizer/cfi/fn-ptr-type-mismatch.rs b/tests/ui/sanitizer/cfi/fn-ptr-type-mismatch.rs
index 6fe7eec7c6920..1e32a1042c848 100644
--- a/tests/ui/sanitizer/cfi/fn-ptr-type-mismatch.rs
+++ b/tests/ui/sanitizer/cfi/fn-ptr-type-mismatch.rs
@@ -1,19 +1,26 @@
 // Verifies that calling a function pointer with a mismatched type triggers a
 // CFI violation and causes the process to trap.
 
-//@ revisions: cfi kcfi
+//@ revisions: cfi cfi-minimal-runtime kcfi
 // FIXME(#122848) Remove only-linux once OSX CFI binaries work
 //@ only-linux
 //@ ignore-backends: gcc
 //@ [cfi] needs-sanitizer-cfi
 //@ [cfi] needs-sanitizer-support
+//@ [cfi-minimal-runtime] needs-sanitizer-cfi
+//@ [cfi-minimal-runtime] needs-sanitizer-support
 //@ [kcfi] needs-sanitizer-kcfi
 //@ compile-flags: -C target-feature=-crt-static
-//@ compile-flags: -C unsafe-allow-abi-mismatch=sanitizer
+//@ compile-flags: -C unsafe-allow-abi-mismatch=sanitizer,sanitizer-cfi-minimal-runtime
 //@ [cfi] compile-flags: -C opt-level=0 -C codegen-units=1 -C lto
 //@ [cfi] compile-flags: -C prefer-dynamic=off
 //@ [cfi] compile-flags: -Z sanitizer=cfi
 //@ [cfi] compile-flags: -Z sanitizer-cfi-diag=true
+//@ [cfi-minimal-runtime] compile-flags: -C opt-level=0 -C codegen-units=1 -C lto
+//@ [cfi-minimal-runtime] compile-flags: -C prefer-dynamic=off
+//@ [cfi-minimal-runtime] compile-flags: -Z sanitizer=cfi
+//@ [cfi-minimal-runtime] compile-flags: -Z sanitizer-cfi-diag=true
+//@ [cfi-minimal-runtime] compile-flags: -Z sanitizer-cfi-minimal-runtime=true
 //@ [kcfi] compile-flags: -Z sanitizer=kcfi
 //@ [kcfi] compile-flags: -C panic=abort -C prefer-dynamic=off
 //@ run-fail-or-crash
diff --git a/tests/ui/sanitizer/cfi/minimal-runtime-requires-cfi-recover-or-diag.rs b/tests/ui/sanitizer/cfi/minimal-runtime-requires-cfi-recover-or-diag.rs
new file mode 100644
index 0000000000000..16f39f09ec7a0
--- /dev/null
+++ b/tests/ui/sanitizer/cfi/minimal-runtime-requires-cfi-recover-or-diag.rs
@@ -0,0 +1,11 @@
+// Verifies that `-Zsanitizer-cfi-minimal-runtime` requires
+// `-Zsanitizer-cfi-recover` or `-Zsanitizer-cfi-diag`.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-minimal-runtime
+
+#![feature(no_core)]
+#![no_core]
+#![no_main]
+
+//~? ERROR `-Zsanitizer-cfi-minimal-runtime` requires `-Zsanitizer-cfi-recover` or `-Zsanitizer-cfi-diag`
diff --git a/tests/ui/sanitizer/cfi/minimal-runtime-requires-cfi-recover-or-diag.stderr b/tests/ui/sanitizer/cfi/minimal-runtime-requires-cfi-recover-or-diag.stderr
new file mode 100644
index 0000000000000..f3d483bef7eb7
--- /dev/null
+++ b/tests/ui/sanitizer/cfi/minimal-runtime-requires-cfi-recover-or-diag.stderr
@@ -0,0 +1,4 @@
+error: `-Zsanitizer-cfi-minimal-runtime` requires `-Zsanitizer-cfi-recover` or `-Zsanitizer-cfi-diag`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/sanitizer/cfi/minimal-runtime-requires-cfi.rs b/tests/ui/sanitizer/cfi/minimal-runtime-requires-cfi.rs
new file mode 100644
index 0000000000000..13b296b4329ee
--- /dev/null
+++ b/tests/ui/sanitizer/cfi/minimal-runtime-requires-cfi.rs
@@ -0,0 +1,11 @@
+// Verifies that `-Zsanitizer-cfi-minimal-runtime` requires `-Zsanitizer=cfi`.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer-cfi-minimal-runtime
+
+#![feature(no_core)]
+#![no_core]
+#![no_main]
+
+//~? ERROR `-Zsanitizer-cfi-minimal-runtime` requires `-Zsanitizer=cfi`
+//~? ERROR `-Zsanitizer-cfi-minimal-runtime` requires `-Zsanitizer-cfi-recover` or `-Zsanitizer-cfi-diag`
diff --git a/tests/ui/sanitizer/cfi/minimal-runtime-requires-cfi.stderr b/tests/ui/sanitizer/cfi/minimal-runtime-requires-cfi.stderr
new file mode 100644
index 0000000000000..251d0d0817631
--- /dev/null
+++ b/tests/ui/sanitizer/cfi/minimal-runtime-requires-cfi.stderr
@@ -0,0 +1,6 @@
+error: `-Zsanitizer-cfi-minimal-runtime` requires `-Zsanitizer=cfi`
+
+error: `-Zsanitizer-cfi-minimal-runtime` requires `-Zsanitizer-cfi-recover` or `-Zsanitizer-cfi-diag`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/sanitizer/cfi/recover-requires-cfi.rs b/tests/ui/sanitizer/cfi/recover-requires-cfi.rs
new file mode 100644
index 0000000000000..17e35a6a740a5
--- /dev/null
+++ b/tests/ui/sanitizer/cfi/recover-requires-cfi.rs
@@ -0,0 +1,10 @@
+// Verifies that `-Zsanitizer-cfi-recover` requires `-Zsanitizer=cfi`.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer-cfi-recover
+
+#![feature(no_core)]
+#![no_core]
+#![no_main]
+
+//~? ERROR `-Zsanitizer-cfi-recover` requires `-Zsanitizer=cfi`
diff --git a/tests/ui/sanitizer/cfi/recover-requires-cfi.stderr b/tests/ui/sanitizer/cfi/recover-requires-cfi.stderr
new file mode 100644
index 0000000000000..81d9908977f0c
--- /dev/null
+++ b/tests/ui/sanitizer/cfi/recover-requires-cfi.stderr
@@ -0,0 +1,4 @@
+error: `-Zsanitizer-cfi-recover` requires `-Zsanitizer=cfi`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/target_modifiers/auxiliary/cfi-minimal-runtime.rs b/tests/ui/target_modifiers/auxiliary/cfi-minimal-runtime.rs
new file mode 100644
index 0000000000000..aacea1ee65dd2
--- /dev/null
+++ b/tests/ui/target_modifiers/auxiliary/cfi-minimal-runtime.rs
@@ -0,0 +1,7 @@
+//@ no-prefer-dynamic
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Zsanitizer=cfi -Zsanitizer-cfi-recover -Zsanitizer-cfi-minimal-runtime
+
+#![feature(no_core)]
+#![crate_type = "rlib"]
+#![no_core]
diff --git a/tests/ui/target_modifiers/sanitizer-cfi-minimal-runtime.rs b/tests/ui/target_modifiers/sanitizer-cfi-minimal-runtime.rs
new file mode 100644
index 0000000000000..45c6ad7b521a3
--- /dev/null
+++ b/tests/ui/target_modifiers/sanitizer-cfi-minimal-runtime.rs
@@ -0,0 +1,18 @@
+// For CFI, the helper flag -Zsanitizer-cfi-minimal-runtime should also be a target modifier.
+
+//@ needs-sanitizer-cfi
+//@ aux-build:cfi-minimal-runtime.rs
+
+//@ revisions: ok wrong_flag wrong_sanitizer
+//@[ok] compile-flags: -Clto -Zsanitizer=cfi -Zsanitizer-cfi-recover -Zsanitizer-cfi-minimal-runtime
+//@[wrong_flag] compile-flags: -Clto -Zsanitizer=cfi -Zsanitizer-cfi-recover
+//@[ok] check-pass
+
+#![feature(no_core)]
+#![crate_type = "rlib"]
+#![no_core]
+
+extern crate cfi_minimal_runtime;
+
+//[wrong_flag]~? ERROR mixing `-Zsanitizer-cfi-minimal-runtime` will cause an ABI mismatch in crate `sanitizer_cfi_minimal_runtime`
+//[wrong_sanitizer]~? ERROR mixing `-Zsanitizer` will cause an ABI mismatch in crate `sanitizer_cfi_minimal_runtime`
diff --git a/tests/ui/target_modifiers/sanitizer-cfi-minimal-runtime.wrong_flag.stderr b/tests/ui/target_modifiers/sanitizer-cfi-minimal-runtime.wrong_flag.stderr
new file mode 100644
index 0000000000000..6dfc1a3bb7d16
--- /dev/null
+++ b/tests/ui/target_modifiers/sanitizer-cfi-minimal-runtime.wrong_flag.stderr
@@ -0,0 +1,9 @@
+error: mixing `-Zsanitizer-cfi-minimal-runtime` will cause an ABI mismatch in crate `sanitizer_cfi_minimal_runtime`
+   |
+   = help: the `-Zsanitizer-cfi-minimal-runtime` flag modifies the ABI so Rust crates compiled with different values of this flag cannot be used together safely
+   = note: `-Zsanitizer-cfi-minimal-runtime` is unset in this crate which is incompatible with `-Zsanitizer-cfi-minimal-runtime` being set in dependency `cfi_minimal_runtime`
+   = help: set `-Zsanitizer-cfi-minimal-runtime` in this crate or unset `-Zsanitizer-cfi-minimal-runtime` in `cfi_minimal_runtime`
+   = help: if you are sure this will not cause problems, you may use `-Cunsafe-allow-abi-mismatch=sanitizer-cfi-minimal-runtime` to silence this error
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/target_modifiers/sanitizer-cfi-minimal-runtime.wrong_sanitizer.stderr b/tests/ui/target_modifiers/sanitizer-cfi-minimal-runtime.wrong_sanitizer.stderr
new file mode 100644
index 0000000000000..32ba848b3b2ad
--- /dev/null
+++ b/tests/ui/target_modifiers/sanitizer-cfi-minimal-runtime.wrong_sanitizer.stderr
@@ -0,0 +1,9 @@
+error: mixing `-Zsanitizer` will cause an ABI mismatch in crate `sanitizer_cfi_minimal_runtime`
+   |
+   = help: the `-Zsanitizer` flag modifies the ABI so Rust crates compiled with different values of this flag cannot be used together safely
+   = note: `-Zsanitizer` is unset in this crate which is incompatible with `-Zsanitizer=cfi` in dependency `cfi_minimal_runtime`
+   = help: set `-Zsanitizer=cfi` in this crate or unset `-Zsanitizer` in `cfi_minimal_runtime`
+   = help: if you are sure this will not cause problems, you may use `-Cunsafe-allow-abi-mismatch=sanitizer` to silence this error
+
+error: aborting due to 1 previous error
+