[gcc r12-1177] Simplify option handling for -fsanitize-coverage

[gcc r12-1177] Simplify option handling for -fsanitize-coverage

[Martin Liska]

https://gcc.gnu.org/g:c1681f22b4b44096f7bd8a2cf42f54762305c3ae

commit r12-1177-gc1681f22b4b44096f7bd8a2cf42f54762305c3ae
Author: Martin Liska <mliska@suse.cz>
Date:   Thu May 20 10:57:49 2021 +0200

    Simplify option handling for -fsanitize-coverage
    
    gcc/ChangeLog:
    
            * common.opt: Use proper Enum values.
            * opts.c (COVERAGE_SANITIZER_OPT): Remove.
            (parse_sanitizer_options): Handle only sanitizer_opts.
            (common_handle_option): Just assign value.
    
    gcc/testsuite/ChangeLog:
    
            * gcc.dg/spellcheck-options-23.c: New test.

Diff:
---
 gcc/common.opt                               | 11 +++++++-
 gcc/opts.c                                   | 41 +++++++---------------------
 gcc/testsuite/gcc.dg/spellcheck-options-23.c |  5 ++++
 3 files changed, 25 insertions(+), 32 deletions(-)

diff --git a/gcc/common.opt b/gcc/common.opt
index ffb968d90f8..7f5fc39911e 100644
--- a/gcc/common.opt
+++ b/gcc/common.opt
@@ -1037,9 +1037,18 @@ Common Driver Joined
 Select what to sanitize.
 
 fsanitize-coverage=
-Common Joined
+Common Joined RejectNegative Enum(sanitize_coverage)
 Select type of coverage sanitization.
 
+Enum
+Name(sanitize_coverage) Type(int)
+
+EnumValue
+Enum(sanitize_coverage) String(trace-pc) Value(SANITIZE_COV_TRACE_PC)
+
+EnumValue
+Enum(sanitize_coverage) String(trace-cmp) Value(SANITIZE_COV_TRACE_CMP)
+
 fasan-shadow-offset=
 Common Joined RejectNegative Var(common_deferred_options) Defer
 -fasan-shadow-offset=<number>	Use custom shadow memory offset.
diff --git a/gcc/opts.c b/gcc/opts.c
index a751d95d32b..52e9e3a9df9 100644
--- a/gcc/opts.c
+++ b/gcc/opts.c
@@ -1908,17 +1908,6 @@ const struct sanitizer_opts_s sanitizer_opts[] =
   { NULL, 0U, 0UL, false }
 };
 
-/* -f{,no-}sanitize-coverage= suboptions.  */
-const struct sanitizer_opts_s coverage_sanitizer_opts[] =
-{
-#define COVERAGE_SANITIZER_OPT(name, flags) \
-    { #name, flags, sizeof #name - 1, true }
-  COVERAGE_SANITIZER_OPT (trace-pc, SANITIZE_COV_TRACE_PC),
-  COVERAGE_SANITIZER_OPT (trace-cmp, SANITIZE_COV_TRACE_CMP),
-#undef COVERAGE_SANITIZER_OPT
-  { NULL, 0U, 0UL, false }
-};
-
 /* -fzero-call-used-regs= suboptions.  */
 const struct zero_call_used_regs_opts_s zero_call_used_regs_opts[] =
 {
@@ -1969,8 +1958,7 @@ struct edit_distance_traits<const string_fragment &>
 /* Given ARG, an unrecognized sanitizer option, return the best
    matching sanitizer option, or NULL if there isn't one.
    OPTS is array of candidate sanitizer options.
-   CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or
-   OPT_fsanitize_coverage_.
+   CODE is OPT_fsanitize_ or OPT_fsanitize_recover_.
    VALUE is non-zero for the regular form of the option, zero
    for the "no-" form (e.g. "-fno-sanitize-recover=").  */
 
@@ -2010,12 +1998,6 @@ parse_sanitizer_options (const char *p, location_t loc, int scode,
 {
   enum opt_code code = (enum opt_code) scode;
 
-  const struct sanitizer_opts_s *opts;
-  if (code == OPT_fsanitize_coverage_)
-    opts = coverage_sanitizer_opts;
-  else
-    opts = sanitizer_opts;
-
   while (*p != 0)
     {
       size_t len, i;
@@ -2033,11 +2015,12 @@ parse_sanitizer_options (const char *p, location_t loc, int scode,
 	}
 
       /* Check to see if the string matches an option class name.  */
-      for (i = 0; opts[i].name != NULL; ++i)
-	if (len == opts[i].len && memcmp (p, opts[i].name, len) == 0)
+      for (i = 0; sanitizer_opts[i].name != NULL; ++i)
+	if (len == sanitizer_opts[i].len
+	    && memcmp (p, sanitizer_opts[i].name, len) == 0)
 	  {
 	    /* Handle both -fsanitize and -fno-sanitize cases.  */
-	    if (value && opts[i].flag == ~0U)
+	    if (value && sanitizer_opts[i].flag == ~0U)
 	      {
 		if (code == OPT_fsanitize_)
 		  {
@@ -2054,14 +2037,14 @@ parse_sanitizer_options (const char *p, location_t loc, int scode,
 		   -fsanitize-recover=return if -fsanitize-recover=undefined
 		   is selected.  */
 		if (code == OPT_fsanitize_recover_
-		    && opts[i].flag == SANITIZE_UNDEFINED)
+		    && sanitizer_opts[i].flag == SANITIZE_UNDEFINED)
 		  flags |= (SANITIZE_UNDEFINED
 			    & ~(SANITIZE_UNREACHABLE | SANITIZE_RETURN));
 		else
-		  flags |= opts[i].flag;
+		  flags |= sanitizer_opts[i].flag;
 	      }
 	    else
-	      flags &= ~opts[i].flag;
+	      flags &= ~sanitizer_opts[i].flag;
 	    found = true;
 	    break;
 	  }
@@ -2070,13 +2053,11 @@ parse_sanitizer_options (const char *p, location_t loc, int scode,
 	{
 	  const char *hint
 	    = get_closest_sanitizer_option (string_fragment (p, len),
-					    opts, code, value);
+					    sanitizer_opts, code, value);
 
 	  const char *suffix;
 	  if (code == OPT_fsanitize_recover_)
 	    suffix = "-recover";
-	  else if (code == OPT_fsanitize_coverage_)
-	    suffix = "-coverage";
 	  else
 	    suffix = "";
 
@@ -2527,9 +2508,7 @@ common_handle_option (struct gcc_options *opts,
       break;
 
     case OPT_fsanitize_coverage_:
-      opts->x_flag_sanitize_coverage
-	= parse_sanitizer_options (arg, loc, code,
-				   opts->x_flag_sanitize_coverage, value, true);
+      opts->x_flag_sanitize_coverage = value;
       break;
 
     case OPT_O:
diff --git a/gcc/testsuite/gcc.dg/spellcheck-options-23.c b/gcc/testsuite/gcc.dg/spellcheck-options-23.c
new file mode 100644
index 00000000000..575a28da504
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/spellcheck-options-23.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+/* { dg-options "-fsanitize-coverage=tracecmp" } */
+
+/* { dg-error "unrecognized argument in option '-fsanitize-coverage=tracecmp'" "" { target *-*-* } 0 } */
+/* { dg-message "valid arguments to '-fsanitize-coverage=' are: trace-cmp trace-pc; did you mean 'trace-cmp'?" "" { target *-*-* } 0 } */