c: c++: Add target_[version/clones] to decl diagnostics formatting.

Adds the target_version and target_clones attributes to diagnostic messages
for target_version semantics.

This is because the target_version/target_clones attributes affect the identity
of the decls, so need to be represented in diagnostics for them.

This also requires making maybe_print_whitespace available to c++ code so
we can control if whitespace is needed cosistantly between c and c++
diagnostics.

After this change diagnostics look like:

c:
```
test.c:6:8: error: redefinition of ‘foo [[target_version("sve")]]’
    6 | float  foo  () {return 1;}
      |        ^~~
test.c:3:8: note: previous definition of ‘foo [[target_version("sve")]]’ with type ‘float(void)’
    3 | float  foo  () {return 2;}
      |        ^~~
test.c:12:8: error: redefinition of ‘bar [[target_clones("sve")]]’
   12 | float  bar () {return 1;}
      |        ^~~
test.c:9:8: note: previous definition of ‘bar [[target_clones("sve")]]’ with type ‘float(void)’
    9 | float  bar () {return 2;}
      |        ^~~
```

c++:
```
test.cpp:6:8: error: redefinition of ‘float foo [[target_version("sve")]] ()’
    6 | float  foo  () {return 1;}
      |        ^~~
test.cpp:3:8: note: ‘float foo [[target_version("sve")]] ()’ previously defined here
    3 | float  foo  () {return 2;}
      |        ^~~
test.cpp:12:8: error: redefinition of ‘float bar [[target_clones("sve")]] ()’
   12 | float  bar () {return 1;}
      |        ^~~
test.cpp:9:8: note: ‘float bar [[target_clones("sve")]] ()’ previously defined here
    9 | float  bar () {return 2;}
      |        ^~~
```

This only affects targets which use target_version (aarch64 and riscv).

gcc/c-family/ChangeLog:

	* c-pretty-print.cc (pp_c_function_target_version): New function.
	(pp_c_function_target_clones): New function.
	(pp_c_maybe_whitespace): Move to c-pretty-print.h.
	* c-pretty-print.h (pp_c_function_target_version): New function.
	(pp_c_function_target_clones): New function.
	(pp_c_maybe_whitespace): Moved here from c-pretty-print.cc.

gcc/c/ChangeLog:

	* c-objc-common.cc (c_tree_printer): Add printing of target_clone and
	target_version in decl diagnostics.

gcc/cp/ChangeLog:

	* cxx-pretty-print.h (pp_cxx_function_target_version): New macro.
	(pp_cxx_function_target_clones): Ditto.
	(pp_cxx_maybe_whitespace): Ditto.
	* error.cc (dump_function_decl): Add printing of target_clone and
	target_version in decl diagnostics.

diff --git a/gcc/c-family/c-pretty-print.cc b/gcc/c-family/c-pretty-print.cc
index fad6b5eb9b0484d34c345a594f15cf39c7d8515b..5adb13b9784dff77399a22cbc92917d2c5d050f1 100644 (file)
--- a/gcc/c-family/c-pretty-print.cc
+++ b/gcc/c-family/c-pretty-print.cc
@@ -36,6 +36,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "function.h"
 #include "basic-block.h"
 #include "gimple.h"
+#include "tm.h"
 
 /* The pretty-printer code is primarily designed to closely follow
    (GNU) C and C++ grammars.  That is to be contrasted with spaghetti
@@ -45,12 +46,6 @@ along with GCC; see the file COPYING3.  If not see
    takes expression or declaration contexts into account.  */
 
 
-#define pp_c_maybe_whitespace(PP)            \
-   do {                                      \
-     if ((PP)->get_padding () == pp_before)  \
-       pp_c_whitespace (PP);                 \
-   } while (0)
-
 /* literal  */
 static void pp_c_char (c_pretty_printer *, int);
 
@@ -3054,6 +3049,76 @@ pp_c_tree_decl_identifier (c_pretty_printer *pp, tree t)
   pp_c_identifier (pp, name);
 }
 
+/* Prints "[version: VERSION]" for a versioned function decl.
+   This will only print for targets with target_version semantics.  */
+void
+pp_c_function_target_version (c_pretty_printer *pp, tree t)
+{
+  if (TARGET_HAS_FMV_TARGET_ATTRIBUTE)
+    return;
+
+  string_slice version = get_target_version (t);
+  if (!version.is_valid ())
+    return;
+
+  pp_c_whitespace (pp);
+
+  pp_c_left_bracket (pp);
+  pp_c_left_bracket (pp);
+  pp_string (pp, "target_version");
+  pp_c_left_paren (pp);
+  pp_doublequote (pp);
+  pp_string_n (pp, version.begin (), version.size ());
+  pp_doublequote (pp);
+  pp_c_right_paren (pp);
+  pp_c_right_bracket (pp);
+  pp_c_right_bracket (pp);
+
+  pp->set_padding (pp_before);
+}
+
+/* Prints "[clones: VERSION, +]" for a versioned function decl.
+   This only works for targets with target_version semantics.  */
+void
+pp_c_function_target_clones (c_pretty_printer *pp, tree t)
+{
+  /* Only print for target_version semantics.
+     This is because for target FMV semantics a target_clone always defines
+     the entire FMV set.  target_version semantics can mix target_clone and
+     target_version decls in the definition of a FMV set and so the
+     target_clone becomes a part of the identity of the declaration.  */
+  if (TARGET_HAS_FMV_TARGET_ATTRIBUTE)
+    return;
+
+  auto_vec<string_slice> versions = get_clone_versions (t, NULL, false);
+  if (versions.is_empty ())
+    return;
+
+  pp_c_whitespace (pp);
+
+  string_slice final_version = versions.pop ();
+  pp_c_left_bracket (pp);
+  pp_c_left_bracket (pp);
+  pp_string (pp, "target_clones");
+  pp_c_left_paren (pp);
+  for (string_slice version : versions)
+    {
+      pp_doublequote (pp);
+      pp_string_n (pp, version.begin (), version.size ());
+      pp_doublequote (pp);
+      pp_string (pp, ",");
+      pp_c_whitespace (pp);
+    }
+  pp_doublequote (pp);
+  pp_string_n (pp, final_version.begin (), final_version.size ());
+  pp_doublequote (pp);
+  pp_c_right_paren (pp);
+  pp_c_right_bracket (pp);
+  pp_c_right_bracket (pp);
+
+  pp->set_padding (pp_before);
+}
+
 #if CHECKING_P
 
 namespace selftest {

diff --git a/gcc/c-family/c-pretty-print.h b/gcc/c-family/c-pretty-print.h
index c8fb6789991555029f6f18ba9f38dd75db03e426..5e00b952c814dd2de508be94958a4d7572b8d0c4 100644 (file)
--- a/gcc/c-family/c-pretty-print.h
+++ b/gcc/c-family/c-pretty-print.h
@@ -102,6 +102,12 @@ public:
 #define pp_ptr_operator(PP, D)          (PP)->ptr_operator (PP, D)
 #define pp_parameter_list(PP, T)        (PP)->parameter_list (PP, T)
 
+#define pp_c_maybe_whitespace(PP)            \
+   do {                                      \
+     if ((PP)->get_padding () == pp_before)  \
+       pp_c_whitespace (PP);                 \
+   } while (0)
+
 void pp_c_whitespace (c_pretty_printer *);
 void pp_c_left_paren (c_pretty_printer *);
 void pp_c_right_paren (c_pretty_printer *);
@@ -138,6 +144,8 @@ void pp_c_ws_string (c_pretty_printer *, const char *);
 void pp_c_identifier (c_pretty_printer *, const char *);
 void pp_c_string_literal (c_pretty_printer *, tree);
 void pp_c_integer_constant (c_pretty_printer *, tree);
+void pp_c_function_target_version (c_pretty_printer *, tree);
+void pp_c_function_target_clones (c_pretty_printer *, tree);
 
 void print_c_tree (FILE *file, tree t, dump_flags_t);
 

diff --git a/gcc/c/c-objc-common.cc b/gcc/c/c-objc-common.cc
index 5c50983544d7f0dd13f74e203b46061a8829e4f2..109a8cb33ee8887064d88c78ba43de5c0024e22b 100644 (file)
--- a/gcc/c/c-objc-common.cc
+++ b/gcc/c/c-objc-common.cc
@@ -23,6 +23,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "c-tree.h"
 #include "intl.h"
 #include "c-family/c-pretty-print.h"
+#include "tree-core.h"
 #include "tree-pretty-print.h"
 #include "tree-pretty-print-markup.h"
 #include "gimple-pretty-print.h"
@@ -359,6 +360,11 @@ c_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
       if (DECL_NAME (t))
        {
          pp_identifier (cpp, lang_hooks.decl_printable_name (t, 2));
+         if (TREE_CODE (t) == FUNCTION_DECL)
+           {
+             pp_c_function_target_version (cpp, t);
+             pp_c_function_target_clones (cpp, t);
+           }
          return true;
        }
       break;

diff --git a/gcc/cp/cxx-pretty-print.h b/gcc/cp/cxx-pretty-print.h
index 86e0ce7d85f265c0978923585d98270c243e286b..356fd6e4d23741cf4be1ff0d57285dca6faecce3 100644 (file)
--- a/gcc/cp/cxx-pretty-print.h
+++ b/gcc/cp/cxx-pretty-print.h
@@ -81,8 +81,13 @@ public:
 
 #define pp_cxx_ws_string(PP, I)                pp_c_ws_string (PP, I)
 #define pp_cxx_identifier(PP, I)       pp_c_identifier (PP, I)
+#define pp_cxx_maybe_whitespace(PP)    pp_c_maybe_whitespace (PP)
 #define pp_cxx_tree_identifier(PP, T) \
   pp_c_tree_identifier (PP, T)
+#define pp_cxx_function_target_version(PP, T) \
+  pp_c_function_target_version (PP, T)
+#define pp_cxx_function_target_clones(PP, T) \
+  pp_c_function_target_clones (PP, T)
 
 void pp_cxx_begin_template_argument_list (cxx_pretty_printer *);
 void pp_cxx_end_template_argument_list (cxx_pretty_printer *);

diff --git a/gcc/cp/error.cc b/gcc/cp/error.cc
index 8ef9f9ee458abedb33edef63d7581202115a2b12..16dfeafc07a0a1688df4eaa96a0187c35e650306 100644 (file)
--- a/gcc/cp/error.cc
+++ b/gcc/cp/error.cc
@@ -2008,6 +2008,14 @@ dump_function_decl (cxx_pretty_printer *pp, tree t, int flags)
 
   dump_function_name (pp, t, dump_function_name_flags);
 
+  /* By default we need no padding here, but if we emit target_version or
+     target_clones then we need some.  */
+  pp->set_padding (pp_none);
+  pp_cxx_function_target_version (pp, t);
+  pp_cxx_maybe_whitespace (pp);
+  pp_cxx_function_target_clones (pp, t);
+  pp_cxx_maybe_whitespace (pp);
+
   if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
     {
       int const parm_flags