add fsan_cov_group

Author: ro-i

clang/include/clang/Options/Options.td

@@ -201,6 +201,10 @@ def hlsl_Group : OptionGroup<"<HLSL group>">, Group<f_Group>,
  DocName<"HLSL options">,
  Visibility<[ClangOption]>;
 
+def fsan_cov_Group : OptionGroup<"<-fsanitize-coverage group>">,
+ Group<f_clang_Group>,
+ DocName<"Sanitizer Coverage options">;
+
 // Feature groups - these take command line options that correspond directly to
 // target specific features and can be translated directly from command line
 // options.
@@ -2407,26 +2411,26 @@ def : Flag<["-"], "fno-sanitize-blacklist">,
  Group<f_clang_Group>, Flags<[HelpHidden]>, Alias<fno_sanitize_ignorelist>;
 
 def fsanitize_coverage : CommaJoined<["-"], "fsanitize-coverage=">,
- Group<f_clang_Group>,
+ Group<fsan_cov_Group>,
  HelpText<"Specify the type of coverage instrumentation for Sanitizers">;
 def fno_sanitize_coverage : CommaJoined<["-"], "fno-sanitize-coverage=">,
- Group<f_clang_Group>, Visibility<[ClangOption, CLOption]>,
+ Group<fsan_cov_Group>, Visibility<[ClangOption, CLOption]>,
  HelpText<"Disable features of coverage instrumentation for Sanitizers">,
  Values<"func,bb,edge,indirect-calls,trace-bb,trace-cmp,trace-div,trace-gep,"
  "8bit-counters,trace-pc,trace-pc-guard,no-prune,inline-8bit-counters,"
  "inline-bool-flag">;
 def fsanitize_coverage_allowlist : Joined<["-"], "fsanitize-coverage-allowlist=">,
- Group<f_clang_Group>, Visibility<[ClangOption, CLOption]>,
+ Group<fsan_cov_Group>, Visibility<[ClangOption, CLOption]>,
  HelpText<"Restrict sanitizer coverage instrumentation exclusively to modules and functions that match the provided special case list, except the blocked ones">,
  MarshallingInfoStringVector<CodeGenOpts<"SanitizeCoverageAllowlistFiles">>;
 def fsanitize_coverage_ignorelist : Joined<["-"], "fsanitize-coverage-ignorelist=">,
- Group<f_clang_Group>, Visibility<[ClangOption, CLOption]>,
+ Group<fsan_cov_Group>, Visibility<[ClangOption, CLOption]>,
  HelpText<"Disable sanitizer coverage instrumentation for modules and functions "
  "that match the provided special case list, even the allowed ones">,
  MarshallingInfoStringVector<CodeGenOpts<"SanitizeCoverageIgnorelistFiles">>;
 def fsanitize_coverage_stack_depth_callback_min_EQ
  : Joined<["-"], "fsanitize-coverage-stack-depth-callback-min=">,
- Group<f_clang_Group>,
+ Group<fsan_cov_Group>,
  MetaVarName<"<M>">,
  HelpText<"Use callback for max stack depth tracing with minimum stack "
  "depth M">,
@@ -7901,70 +7905,87 @@ def linker_option : Joined<["--"], "linker-option=">,
  HelpText<"Add linker option">,
  MarshallingInfoStringVector<CodeGenOpts<"LinkerOptions">>;
 def fsanitize_coverage_type : Joined<["-"], "fsanitize-coverage-type=">,
+ Group<fsan_cov_Group>,
  HelpText<"Sanitizer coverage type">,
  MarshallingInfoInt<CodeGenOpts<"SanitizeCoverageType">>;
 def fsanitize_coverage_indirect_calls
  : Flag<["-"], "fsanitize-coverage-indirect-calls">,
+ Group<fsan_cov_Group>,
  HelpText<"Enable sanitizer coverage for indirect calls">,
  MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageIndirectCalls">>;
 def fsanitize_coverage_trace_bb
  : Flag<["-"], "fsanitize-coverage-trace-bb">,
+ Group<fsan_cov_Group>,
  HelpText<"Enable basic block tracing in sanitizer coverage">,
  MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTraceBB">>;
 def fsanitize_coverage_trace_cmp
  : Flag<["-"], "fsanitize-coverage-trace-cmp">,
+ Group<fsan_cov_Group>,
  HelpText<"Enable cmp instruction tracing in sanitizer coverage">,
  MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTraceCmp">>;
 def fsanitize_coverage_trace_div
  : Flag<["-"], "fsanitize-coverage-trace-div">,
+ Group<fsan_cov_Group>,
  HelpText<"Enable div instruction tracing in sanitizer coverage">,
  MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTraceDiv">>;
 def fsanitize_coverage_trace_gep
  : Flag<["-"], "fsanitize-coverage-trace-gep">,
+ Group<fsan_cov_Group>,
  HelpText<"Enable gep instruction tracing in sanitizer coverage">,
  MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTraceGep">>;
 def fsanitize_coverage_8bit_counters
  : Flag<["-"], "fsanitize-coverage-8bit-counters">,
+ Group<fsan_cov_Group>,
  HelpText<"Enable frequency counters in sanitizer coverage">,
  MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverage8bitCounters">>;
 def fsanitize_coverage_inline_8bit_counters
  : Flag<["-"], "fsanitize-coverage-inline-8bit-counters">,
+ Group<fsan_cov_Group>,
  HelpText<"Enable inline 8-bit counters in sanitizer coverage">,
  MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageInline8bitCounters">>;
 def fsanitize_coverage_inline_bool_flag
  : Flag<["-"], "fsanitize-coverage-inline-bool-flag">,
+ Group<fsan_cov_Group>,
  HelpText<"Enable inline bool flag in sanitizer coverage">,
  MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageInlineBoolFlag">>;
 def fsanitize_coverage_pc_table
  : Flag<["-"], "fsanitize-coverage-pc-table">,
+ Group<fsan_cov_Group>,
  HelpText<"Create a table of coverage-instrumented PCs">,
  MarshallingInfoFlag<CodeGenOpts<"SanitizeCoveragePCTable">>;
 def fsanitize_coverage_control_flow
  : Flag<["-"], "fsanitize-coverage-control-flow">,
+ Group<fsan_cov_Group>,
  HelpText<"Collect control flow of function">,
  MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageControlFlow">>;
 def fsanitize_coverage_trace_pc
  : Flag<["-"], "fsanitize-coverage-trace-pc">,
+ Group<fsan_cov_Group>,
  HelpText<"Enable PC tracing in sanitizer coverage">,
  MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTracePC">>;
 def fsanitize_coverage_trace_pc_guard
  : Flag<["-"], "fsanitize-coverage-trace-pc-guard">,
+ Group<fsan_cov_Group>,
  HelpText<"Enable PC tracing with guard in sanitizer coverage">,
  MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTracePCGuard">>;
 def fsanitize_coverage_no_prune
  : Flag<["-"], "fsanitize-coverage-no-prune">,
+ Group<fsan_cov_Group>,
  HelpText<"Disable coverage pruning (i.e. instrument all blocks/edges)">,
  MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageNoPrune">>;
 def fsanitize_coverage_stack_depth
  : Flag<["-"], "fsanitize-coverage-stack-depth">,
+ Group<fsan_cov_Group>,
  HelpText<"Enable max stack depth tracing">,
  MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageStackDepth">>;
 def fsanitize_coverage_trace_loads
  : Flag<["-"], "fsanitize-coverage-trace-loads">,
+ Group<fsan_cov_Group>,
  HelpText<"Enable tracing of loads">,
  MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTraceLoads">>;
 def fsanitize_coverage_trace_stores
  : Flag<["-"], "fsanitize-coverage-trace-stores">,
+ Group<fsan_cov_Group>,
  HelpText<"Enable tracing of stores">,
  MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTraceStores">>;
 def fexperimental_sanitize_metadata_EQ_covered

clang/lib/Driver/ToolChains/AMDGPU.h

@@ -155,22 +155,49 @@ class LLVM_LIBRARY_VISIBILITY ROCMToolChain : public AMDGPUToolChain {
  return SanitizerKind::Address;
  }
 
+ bool diagnoseUnsupportedOption(const llvm::opt::Arg *A,
+ const llvm::opt::DerivedArgList &DAL,
+ const llvm::opt::ArgList &DriverArgs,
+ const char *Value = nullptr) const {
+ auto &Diags = getDriver().getDiags();
+ bool IsExplicitDevice =
+ A->getBaseArg().getOption().matches(options::OPT_Xarch_device);
+
+ if (Value) {
+ unsigned DiagID =
+ IsExplicitDevice
+ ? clang::diag::err_drv_unsupported_option_part_for_target
+ : clang::diag::warn_drv_unsupported_option_part_for_target;
+ Diags.Report(DiagID) << Value << A->getAsString(DriverArgs)
+ << getTriple().str();
+ } else {
+ unsigned DiagID =
+ IsExplicitDevice
+ ? clang::diag::err_drv_unsupported_option_for_target
+ : clang::diag::warn_drv_unsupported_option_for_target;
+ Diags.Report(DiagID) << A->getAsString(DAL) << getTriple().str();
+ }
+ return true;
+ }
+
  bool handleSanitizeOption(const ToolChain &TC, llvm::opt::DerivedArgList &DAL,
  const llvm::opt::ArgList &DriverArgs,
  StringRef TargetID, const llvm::opt::Arg *A) const {
  if (TargetID.empty())
  return false;
- // If this isn't a sanitizer option, don't handle it.
- if (!A->getOption().matches(options::OPT_fsanitize_EQ))
- return false;
  // If we shouldn't do sanitizing, skip it.
  if (!DriverArgs.hasFlag(options::OPT_fgpu_sanitize,
  options::OPT_fno_gpu_sanitize, true))
  return true;
-
- auto &Diags = getDriver().getDiags();
- bool IsExplicitDevice =
- A->getBaseArg().getOption().matches(options::OPT_Xarch_device);
+ const llvm::opt::Option &Opt = A->getOption();
+ // Sanitizer coverage is currently not supported for AMDGPU, so warn/error
+ // on every related option.
+ if (Opt.matches(options::OPT_fsan_cov_Group)) {
+ diagnoseUnsupportedOption(A, DAL, DriverArgs);
+ }
+ // If this isn't a sanitizer option, don't handle it.
+ if (!Opt.matches(options::OPT_fsanitize_EQ))
+ return false;
 
  SmallVector<const char *, 4> SupportedSanitizers;
  SmallVector<const char *, 4> UnSupportedSanitizers;
@@ -185,25 +212,13 @@ class LLVM_LIBRARY_VISIBILITY ROCMToolChain : public AMDGPUToolChain {
 
  // If there are no supported sanitizers, drop the whole argument.
  if (SupportedSanitizers.empty()) {
- if (IsExplicitDevice) {
- Diags.Report(clang::diag::err_drv_unsupported_option_for_target)
- << A->getAsString(DAL) << getTriple().str();
- } else {
- Diags.Report(clang::diag::warn_drv_unsupported_option_for_target)
- << A->getAsString(DAL) << getTriple().str();
- }
+ diagnoseUnsupportedOption(A, DAL, DriverArgs);
  return true;
  }
  // If only some sanitizers are unsupported, report each one individually.
  if (!UnSupportedSanitizers.empty()) {
  for (const char *Value : UnSupportedSanitizers) {
- if (IsExplicitDevice) {
- Diags.Report(clang::diag::err_drv_unsupported_option_part_for_target)
- << Value << A->getAsString(DriverArgs) << getTriple().str();
- } else {
- Diags.Report(clang::diag::warn_drv_unsupported_option_part_for_target)
- << Value << A->getAsString(DriverArgs) << getTriple().str();
- }
+ diagnoseUnsupportedOption(A, DAL, DriverArgs, Value);
  }
  }
  // If we know the target arch, check if the sanitizer is supported for it.

clang/test/Driver/amdgpu-openmp-sanitize-options.c

@@ -72,6 +72,10 @@
 // RUN: %clang -no-canonical-prefixes -### --target=x86_64-unknown-linux-gnu -fopenmp=libomp --offload-arch=gfx908:xnack+,gfx900:xnack- -fsanitize=fuzzer,address -fsanitize=leak --rocm-path=%S/Inputs/rocm %s 2>&1 \
 // RUN: | FileCheck -check-prefixes=HOSTSANCOMBINATION2,NOTSUPPORTED-DAG,INVALIDCOMBINATION2 %s
 
+// Check for -fsanitize-coverage options
+// RUN: %clang -no-canonical-prefixes -### --target=x86_64-unknown-linux-gnu -fopenmp=libomp --offload-arch=gfx908:xnack+ -fsanitize=address -fsanitize-coverage=inline-bool-flag --rocm-path=%S/Inputs/rocm %s 2>&1 \
+// RUN: | FileCheck -check-prefixes=WARNSANCOV %s
+
 // Test -Xarch_device error scenario
 
 // RUN: not %clang -no-canonical-prefixes -### --target=x86_64-unknown-linux-gnu -fopenmp=libomp --offload-arch=gfx908:xnack+ -Xarch_device -fsanitize=leak --rocm-path=%S/Inputs/rocm %s 2>&1 \
@@ -83,6 +87,10 @@
 // RUN: not %clang -no-canonical-prefixes -### --target=x86_64-unknown-linux-gnu -fopenmp=libomp --offload-arch=gfx908:xnack+ -Xarch_device -fsanitize=fuzzer,address --rocm-path=%S/Inputs/rocm %s 2>&1 \
 // RUN: | FileCheck -check-prefixes=INVALIDCOMBINATIONERROR %s
 
+// RUN: not %clang -no-canonical-prefixes -### --target=x86_64-unknown-linux-gnu -fopenmp=libomp --offload-arch=gfx908:xnack+ -fsanitize=address -Xarch_device -fsanitize-coverage-stack-depth-callback-min=42 --rocm-path=%S/Inputs/rocm %s 2>&1 \
+// RUN: | FileCheck -check-prefixes=ERRSANCOV %s
+
+
 // INVALIDCOMBINATION1: warning: ignoring 'fuzzer' in '-fsanitize=address,fuzzer' option as it is not currently supported for target 'amdgcn-amd-amdhsa' [-Woption-ignored]
 // INVALIDCOMBINATION2: warning: ignoring 'fuzzer' in '-fsanitize=fuzzer,address' option as it is not currently supported for target 'amdgcn-amd-amdhsa' [-Woption-ignored]
 
@@ -106,3 +114,6 @@
 // UNSUPPORTEDERROR: error: '-fsanitize=leak' option is not currently supported for target 'amdgcn-amd-amdhsa'
 // XNACKERROR: error: '-fsanitize=address' option for offload arch 'gfx908:xnack-' is not currently supported there. Use it with an offload arch containing 'xnack+' instead
 // INVALIDCOMBINATIONERROR: error: 'fuzzer' in '-fsanitize=fuzzer,address' option is not currently supported for target 'amdgcn-amd-amdhsa'
+
+// WARNSANCOV: warning: ignoring '-fsanitize-coverage=inline-bool-flag' option as it is not currently supported for target 'amdgcn-amd-amdhsa'
+// ERRSANCOV: error: '-fsanitize-coverage-stack-depth-callback-min=42' option is not currently supported for target 'amdgcn-amd-amdhsa'

clang/test/Driver/hip-sanitize-options.hip

@@ -74,6 +74,11 @@
 // RUN: -fsanitize=fuzzer,address -fsanitize=leak --rocm-path=%S/Inputs/rocm %s 2>&1 \
 // RUN: | FileCheck -check-prefixes=MULT2,XNACK2 %s
 
+// Check for -fsanitize-coverage options
+// RUN: %clang -### --target=x86_64-unknown-linux-gnu --offload-arch=gfx900:xnack+ \
+// RUN: -fsanitize=address -fsanitize-coverage=inline-bool-flag --rocm-path=%S/Inputs/rocm %s 2>&1 \
+// RUN: | FileCheck -check-prefixes=WARNSANCOV %s
+
 // Test -Xarch_device error scenario
 
 // RUN: not %clang -### --target=x86_64-unknown-linux-gnu --offload-arch=gfx900:xnack+ \
@@ -88,6 +93,10 @@
 // RUN: -Xarch_device -fsanitize=fuzzer,address --rocm-path=%S/Inputs/rocm %s 2>&1 \
 // RUN: | FileCheck -check-prefixes=INVALIDCOMBINATIONERROR %s
 
+// RUN: not %clang -### --target=x86_64-unknown-linux-gnu --offload-arch=gfx900:xnack+ \
+// RUN: -fsanitize=address -Xarch_device -fsanitize-coverage-stack-depth-callback-min=42 --rocm-path=%S/Inputs/rocm %s 2>&1 \
+// RUN: | FileCheck -check-prefixes=ERRSANCOV %s
+
 // CHECK-NOT: {{"[^"]*clang[^"]*".* "-fcuda-is-device".* "-fsanitize=address"}}
 // CHECK-NOT: {{"[^"]*clang[^"]*".* "-fcuda-is-device".* "-mlink-bitcode-file" ".*asanrtl.bc"}}
 // CHECK-NOT: {{"[^"]*lld(\.exe){0,1}".* ".*hip.bc"}}
@@ -162,3 +171,6 @@
 // UNSUPPORTEDERROR: error: '-fsanitize=leak' option is not currently supported for target 'amdgcn-amd-amdhsa'
 // XNACKERROR: error: '-fsanitize=address' option for offload arch 'gfx900:xnack-' is not currently supported there. Use it with an offload arch containing 'xnack+' instead
 // INVALIDCOMBINATIONERROR: error: 'fuzzer' in '-fsanitize=fuzzer,address' option is not currently supported for target 'amdgcn-amd-amdhsa'
+
+// WARNSANCOV: warning: ignoring '-fsanitize-coverage=inline-bool-flag' option as it is not currently supported for target 'amdgcn-amd-amdhsa'
+// ERRSANCOV: error: '-fsanitize-coverage-stack-depth-callback-min=42' option is not currently supported for target 'amdgcn-amd-amdhsa'