[WIP][DO NOT MERGE][Clang][Driver] Emit warning when -fsanitize-trap=<...> is passed without associated -fsanitize=<...>

clang/include/clang/Basic/DiagnosticDriverKinds.td

@@ -874,4 +874,9 @@ def warn_drv_openacc_without_cir
     : Warning<"OpenACC directives will result in no runtime behavior; use "
               "-fclangir to enable runtime effect">,
       InGroup<SourceUsesOpenACC>;
+
+def warn_drv_sanitize_trap_mismatch : Warning<
+  "-fsanitize-trap=%0 has no effect because the \"%0\" sanitizer is disabled; "
+  "consider passing \"fsanitize=%0\" to enable the sanitizer">,
+  InGroup<SanitizeTrapMismatch>;
 }

clang/include/clang/Basic/DiagnosticGroups.td

@@ -1752,3 +1752,6 @@ def ExplicitSpecializationStorageClass : DiagGroup<"explicit-specialization-stor
 
 // A warning for options that enable a feature that is not yet complete
 def ExperimentalOption : DiagGroup<"experimental-option">;
+
+// Warnings for sanitizer arguments
+def SanitizeTrapMismatch : DiagGroup<"sanitize-trap-mismatch">;

clang/lib/Driver/SanitizerArgs.cpp

@@ -348,6 +348,30 @@ parseSanitizeSkipHotCutoffArgs(const Driver &D, const llvm::opt::ArgList &Args,
   return Cutoffs;
 }
 
+// Given a set of mismatched bits, TrapOnly (bits the user asked to trap but
+// that aren’t actually enabled), emit a warning based on -fsanitize-trap=NAME
+static void diagnoseTrapOnly(const Driver &D, SanitizerMask &TrapOnly) {
+// One pass for sanitizer groupings
+#define SANITIZER(NAME, ID)
+#define SANITIZER_GROUP(NAME, ID, ALIAS)                                       \
+  if (TrapOnly & SanitizerKind::ID##Group) {                                   \
+    D.Diag(diag::warn_drv_sanitize_trap_mismatch) << NAME;                     \
+    TrapOnly &= ~SanitizerKind::ID##Group;                                     \
+    TrapOnly &= ~SanitizerKind::ID;                                            \
+  }
+#include "clang/Basic/Sanitizers.def"
+
+#undef SANITIZER_GROUP
+// One pass for individual sanitizer names/leaves
+#define SANITIZER_GROUP(NAME, ID, ALIAS)
+#define SANITIZER(NAME, ID)                                                    \
+  if (TrapOnly & SanitizerKind::ID) {                                          \
+    D.Diag(diag::warn_drv_sanitize_trap_mismatch) << NAME;                     \
+    TrapOnly &= ~SanitizerKind::ID;                                            \
+  }
+#include "clang/Basic/Sanitizers.def"
+}
+
 bool SanitizerArgs::needsFuzzerInterceptors() const {
   return needsFuzzer() && !needsAsanRt() && !needsTsanRt() && !needsMsanRt();
 }
@@ -730,6 +754,23 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC,
       options::OPT_fno_sanitize_recover_EQ);
   RecoverableKinds &= Kinds;
 
+  // FIXME: `DiagnoseErrors` name seems a little wrong as we emit warnings here, 
+  // not errors but that seems to be done elsewhere in this method.
+
+  // Parse any -fsanitize-trap=<...> flags the user provided, then
+  // diagnose any which do not have a matching -fsanitize=<...>
+  if (DiagnoseErrors) {
+    // parseSanitizeTrapArgs was not used because it sets a TrappingDefault 
+    // which causes the emission of warnings beyond what the user entered
+    SanitizerMask ExplicitTrap = parseSanitizeArgs(
+        D, Args, false, {}, {}, {}, options::OPT_fsanitize_trap_EQ,
+        options::OPT_fno_sanitize_trap_EQ);
+    SanitizerMask TrapOnly = ExplicitTrap & ~Kinds;
+
+    if (TrapOnly)
+      diagnoseTrapOnly(D, TrapOnly);
+  }
+
   TrappingKinds &= Kinds;
   RecoverableKinds &= ~TrappingKinds;
 

clang/test/Driver/fsanitize-trap-mismatch.c

@@ -0,0 +1,9 @@
+// RUN: %clang -S -emit-llvm -g -O0 %s -fsanitize-trap=undefined -o - 2>&1 | FileCheck %s --check-prefix=WARN
+// RUN: %clang -S -emit-llvm -g -O0 %s -fsanitize=undefined  -fsanitize-trap=undefined -o - 2>&1 | FileCheck %s --check-prefix=NOWARN
+// RUN: %clang -S -emit-llvm -g -O0 %s -fsanitize-trap=undefined -Wno-sanitize-trap-mismatch -o - 2>&1 | FileCheck %s --check-prefix=SUPPRESS
+//
+// WARN: warning: -fsanitize-trap=undefined has no effect because the "undefined" sanitizer is disabled; consider passing "fsanitize=undefined" to enable the sanitizer
+// NOWARN-NOT: warning: -fsanitize-trap=undefined has no effect because the "undefined" sanitizer is disabled; consider passing "fsanitize=undefined" to enable the sanitizer
+// SUPPRESS-NOT: warning: -fsanitize-trap=undefined has no effect because the "undefined" sanitizer is disabled; consider passing "fsanitize=undefined" to enable the sanitizer
+
+int main(void) { return 0; }