diff --git a/compiler/rustc_codegen_ssa/messages.ftl b/compiler/rustc_codegen_ssa/messages.ftl
index 42ba01541920b..53a818598a5d5 100644
--- a/compiler/rustc_codegen_ssa/messages.ftl
+++ b/compiler/rustc_codegen_ssa/messages.ftl
@@ -171,9 +171,12 @@ codegen_ssa_invalid_monomorphization_unsupported_symbol = invalid monomorphizati
 
 codegen_ssa_invalid_monomorphization_unsupported_symbol_of_size = invalid monomorphization of `{$name}` intrinsic: unsupported {$symbol} from `{$in_ty}` with element `{$in_elem}` of size `{$size}` to `{$ret_ty}`
 
-codegen_ssa_invalid_sanitize = invalid argument for `sanitize`
+codegen_ssa_invalid_sanitizer = invalid argument for `sanitize`
     .note = expected one of: `address`, `kernel_address`, `cfi`, `hwaddress`, `kcfi`, `memory`, `memtag`, `shadow_call_stack`, or `thread`
 
+codegen_ssa_invalid_sanitizer_setting = invalid setting for `{$sanitizer}`
+    .note = expected one of: `on`, or `off`
+
 codegen_ssa_invalid_windows_subsystem = invalid windows subsystem `{$subsystem}`, only `windows` and `console` are allowed
 
 codegen_ssa_ld64_unimplemented_modifier = `as-needed` modifier not implemented yet for ld64
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index bf14c02a09c55..089746f3d785b 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -569,7 +569,7 @@ fn parse_sanitize_attr(
     if let Some(list) = attr.meta_item_list() {
         for item in list.iter() {
             let MetaItemInner::MetaItem(set) = item else {
-                tcx.dcx().emit_err(errors::InvalidSanitize { span: attr.span() });
+                tcx.dcx().emit_err(errors::InvalidSanitizer { span: attr.span() });
                 break;
             };
             let segments = set.path.segments.iter().map(|x| x.ident.name).collect::<Vec<_>>();
@@ -577,49 +577,93 @@ fn parse_sanitize_attr(
                 // Similar to clang, sanitize(address = ..) and
                 // sanitize(kernel_address = ..) control both ASan and KASan
                 // Source: https://reviews.llvm.org/D44981.
-                [sym::address] | [sym::kernel_address] if set.value_str() == Some(sym::off) => {
-                    result |= SanitizerSet::ADDRESS | SanitizerSet::KERNELADDRESS
-                }
-                [sym::address] | [sym::kernel_address] if set.value_str() == Some(sym::on) => {
-                    result &= !SanitizerSet::ADDRESS;
-                    result &= !SanitizerSet::KERNELADDRESS;
-                }
-                [sym::cfi] if set.value_str() == Some(sym::off) => result |= SanitizerSet::CFI,
-                [sym::cfi] if set.value_str() == Some(sym::on) => result &= !SanitizerSet::CFI,
-                [sym::kcfi] if set.value_str() == Some(sym::off) => result |= SanitizerSet::KCFI,
-                [sym::kcfi] if set.value_str() == Some(sym::on) => result &= !SanitizerSet::KCFI,
-                [sym::memory] if set.value_str() == Some(sym::off) => {
-                    result |= SanitizerSet::MEMORY
-                }
-                [sym::memory] if set.value_str() == Some(sym::on) => {
-                    result &= !SanitizerSet::MEMORY
-                }
-                [sym::memtag] if set.value_str() == Some(sym::off) => {
-                    result |= SanitizerSet::MEMTAG
-                }
-                [sym::memtag] if set.value_str() == Some(sym::on) => {
-                    result &= !SanitizerSet::MEMTAG
-                }
-                [sym::shadow_call_stack] if set.value_str() == Some(sym::off) => {
-                    result |= SanitizerSet::SHADOWCALLSTACK
-                }
-                [sym::shadow_call_stack] if set.value_str() == Some(sym::on) => {
-                    result &= !SanitizerSet::SHADOWCALLSTACK
-                }
-                [sym::thread] if set.value_str() == Some(sym::off) => {
-                    result |= SanitizerSet::THREAD
-                }
-                [sym::thread] if set.value_str() == Some(sym::on) => {
-                    result &= !SanitizerSet::THREAD
-                }
-                [sym::hwaddress] if set.value_str() == Some(sym::off) => {
-                    result |= SanitizerSet::HWADDRESS
-                }
-                [sym::hwaddress] if set.value_str() == Some(sym::on) => {
-                    result &= !SanitizerSet::HWADDRESS
-                }
+                [sym::address] | [sym::kernel_address] => match set.value_str() {
+                    Some(sym::off) => result |= SanitizerSet::ADDRESS | SanitizerSet::KERNELADDRESS,
+                    Some(sym::on) => {
+                        result &= !SanitizerSet::ADDRESS;
+                        result &= !SanitizerSet::KERNELADDRESS;
+                    }
+                    _ => {
+                        let sanitizer = segments.as_slice()[0];
+                        tcx.dcx().emit_err(errors::InvalidSanitizerSetting {
+                            span: set.span,
+                            sanitizer,
+                        });
+                    }
+                },
+                [sym::cfi] => match set.value_str() {
+                    Some(sym::off) => result |= SanitizerSet::CFI,
+                    Some(sym::on) => result &= !SanitizerSet::CFI,
+                    _ => {
+                        tcx.dcx().emit_err(errors::InvalidSanitizerSetting {
+                            span: set.span,
+                            sanitizer: sym::cfi,
+                        });
+                    }
+                },
+                [sym::kcfi] => match set.value_str() {
+                    Some(sym::off) => result |= SanitizerSet::KCFI,
+                    Some(sym::on) => result &= !SanitizerSet::KCFI,
+                    _ => {
+                        tcx.dcx().emit_err(errors::InvalidSanitizerSetting {
+                            span: set.span,
+                            sanitizer: sym::kcfi,
+                        });
+                    }
+                },
+                [sym::memory] => match set.value_str() {
+                    Some(sym::off) => result |= SanitizerSet::MEMORY,
+                    Some(sym::on) => result &= !SanitizerSet::MEMORY,
+                    _ => {
+                        tcx.dcx().emit_err(errors::InvalidSanitizerSetting {
+                            span: set.span,
+                            sanitizer: sym::memory,
+                        });
+                    }
+                },
+                [sym::memtag] => match set.value_str() {
+                    Some(sym::off) => result |= SanitizerSet::MEMTAG,
+                    Some(sym::on) => result &= !SanitizerSet::MEMTAG,
+                    _ => {
+                        tcx.dcx().emit_err(errors::InvalidSanitizerSetting {
+                            span: set.span,
+                            sanitizer: sym::memtag,
+                        });
+                    }
+                },
+                [sym::shadow_call_stack] => match set.value_str() {
+                    Some(sym::off) => result |= SanitizerSet::SHADOWCALLSTACK,
+                    Some(sym::on) => result &= !SanitizerSet::SHADOWCALLSTACK,
+                    _ => {
+                        tcx.dcx().emit_err(errors::InvalidSanitizerSetting {
+                            span: set.span,
+                            sanitizer: sym::shadow_call_stack,
+                        });
+                    }
+                },
+                [sym::thread] => match set.value_str() {
+                    Some(sym::off) => result |= SanitizerSet::THREAD,
+                    Some(sym::on) => result &= !SanitizerSet::THREAD,
+                    _ => {
+                        tcx.dcx().emit_err(errors::InvalidSanitizerSetting {
+                            span: set.span,
+                            sanitizer: sym::thread,
+                        });
+                    }
+                },
+
+                [sym::hwaddress] => match set.value_str() {
+                    Some(sym::off) => result |= SanitizerSet::HWADDRESS,
+                    Some(sym::on) => result &= !SanitizerSet::HWADDRESS,
+                    _ => {
+                        tcx.dcx().emit_err(errors::InvalidSanitizerSetting {
+                            span: set.span,
+                            sanitizer: sym::hwaddress,
+                        });
+                    }
+                },
                 _ => {
-                    tcx.dcx().emit_err(errors::InvalidSanitize { span: attr.span() });
+                    tcx.dcx().emit_err(errors::InvalidSanitizer { span: attr.span() });
                 }
             }
         }
diff --git a/compiler/rustc_codegen_ssa/src/errors.rs b/compiler/rustc_codegen_ssa/src/errors.rs
index 209c78ddeda4c..e7362f3a7035a 100644
--- a/compiler/rustc_codegen_ssa/src/errors.rs
+++ b/compiler/rustc_codegen_ssa/src/errors.rs
@@ -1121,13 +1121,22 @@ impl IntoDiagArg for ExpectedPointerMutability {
 }
 
 #[derive(Diagnostic)]
-#[diag(codegen_ssa_invalid_sanitize)]
+#[diag(codegen_ssa_invalid_sanitizer)]
 #[note]
-pub(crate) struct InvalidSanitize {
+pub(crate) struct InvalidSanitizer {
     #[primary_span]
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(codegen_ssa_invalid_sanitizer_setting)]
+#[note]
+pub(crate) struct InvalidSanitizerSetting {
+    #[primary_span]
+    pub span: Span,
+    pub sanitizer: Symbol,
+}
+
 #[derive(Diagnostic)]
 #[diag(codegen_ssa_target_feature_safe_trait)]
 pub(crate) struct TargetFeatureSafeTrait {
diff --git a/tests/ui/sanitize-attr/invalid-sanitize.rs b/tests/ui/sanitize-attr/invalid-sanitize.rs
index 49dc01c8daaf4..c32e32c3eba49 100644
--- a/tests/ui/sanitize-attr/invalid-sanitize.rs
+++ b/tests/ui/sanitize-attr/invalid-sanitize.rs
@@ -12,7 +12,7 @@ fn multiple_consistent() {}
 #[sanitize(address = "off")]
 fn multiple_inconsistent() {}
 
-#[sanitize(address = "bogus")] //~ ERROR invalid argument for `sanitize`
+#[sanitize(address = "bogus")] //~ ERROR invalid setting for `address`
 fn wrong_value() {}
 
 #[sanitize = "off"] //~ ERROR malformed `sanitize` attribute input
diff --git a/tests/ui/sanitize-attr/invalid-sanitize.stderr b/tests/ui/sanitize-attr/invalid-sanitize.stderr
index 4bf81770b89c0..f5cc5122695e2 100644
--- a/tests/ui/sanitize-attr/invalid-sanitize.stderr
+++ b/tests/ui/sanitize-attr/invalid-sanitize.stderr
@@ -70,13 +70,13 @@ LL | #[sanitize(brontosaurus = "off")]
    |
    = note: expected one of: `address`, `kernel_address`, `cfi`, `hwaddress`, `kcfi`, `memory`, `memtag`, `shadow_call_stack`, or `thread`
 
-error: invalid argument for `sanitize`
-  --> $DIR/invalid-sanitize.rs:15:1
+error: invalid setting for `address`
+  --> $DIR/invalid-sanitize.rs:15:12
    |
 LL | #[sanitize(address = "bogus")]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |            ^^^^^^^^^^^^^^^^^
    |
-   = note: expected one of: `address`, `kernel_address`, `cfi`, `hwaddress`, `kcfi`, `memory`, `memtag`, `shadow_call_stack`, or `thread`
+   = note: expected one of: `on`, or `off`
 
 error: aborting due to 6 previous errors