CbC/CbC_gcc: gcc/c-family/c-pragma.c comparison

comparison gcc/c-family/c-pragma.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Handle #pragma, system V.4 style.  Supports #pragma weak and #pragma pack.
-Copyright (C) 1992-2018 Free Software Foundation, Inc.
+Copyright (C) 1992-2020 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
 #include "attribs.h"
 #include "varasm.h"
 #include "c-pragma.h"
 #include "opts.h"
 #include "plugin.h"
+#include "opt-suggestions.h"
 #define GCC_BAD(gmsgid) \
 do { warning (OPT_Wpragmas, gmsgid); return; } while (0)
 #define GCC_BAD2(gmsgid, arg) \
 do { warning (OPT_Wpragmas, gmsgid, arg); return; } while (0)
 pop_alignment (tree id)
 {
 align_stack * entry;
 if (alignment_stack == NULL)
-GCC_BAD ("#pragma pack (pop) encountered without matching #pragma pack (push)");
+GCC_BAD ("%<#pragma pack (pop)%> encountered without matching "
+	     "%<#pragma pack (push)%>");
 /* If we got an identifier, strip away everything above the target
 entry so that the next step will restore the state just below it.  */
 if (id)
 {
 	  {
 	    alignment_stack = entry;
 	    break;
 	  }
 if (entry == NULL)
-	warning (OPT_Wpragmas, "\
+	warning (OPT_Wpragmas,
-#pragma pack(pop, %E) encountered without matching #pragma pack(push, %E)"
+		 "%<#pragma pack(pop, %E)%> encountered without matching "
+		 "%<#pragma pack(push, %E)%>"
 		 , id, id);
 }
 entry = alignment_stack->prev;
 if (pragma_lex (&x) != CPP_EOF)
 warning (OPT_Wpragmas, "junk at end of %<#pragma pack%>");
 if (flag_pack_struct)
-GCC_BAD ("#pragma pack has no effect with -fpack-struct - ignored");
+GCC_BAD ("%<#pragma pack%> has no effect with %<-fpack-struct%> - ignored");
 if (action != pop)
 switch (align)
 {
 case 0:
 if (SUPPORTS_WEAK && DECL_EXTERNAL (decl) && TREE_USED (decl)
 && !DECL_WEAK (decl) /* Don't complain about a redundant #pragma.  */
 && DECL_ASSEMBLER_NAME_SET_P (decl)
 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
-warning (OPT_Wpragmas, "applying #pragma weak %q+D after first use "
+warning (OPT_Wpragmas, "applying %<#pragma weak %+D%> after first use "
 	     "results in unspecified behavior", decl);
 declare_weak (decl);
 }
 enum cpp_ttype t;
 value = 0;
 if (pragma_lex (&name) != CPP_NAME)
-GCC_BAD ("malformed #pragma weak, ignored");
+GCC_BAD ("malformed %<#pragma weak%>, ignored");
 t = pragma_lex (&x);
 if (t == CPP_EQ)
 {
 if (pragma_lex (&value) != CPP_NAME)
-	GCC_BAD ("malformed #pragma weak, ignored");
+	GCC_BAD ("malformed %<#pragma weak%>, ignored");
 t = pragma_lex (&x);
 }
 if (t != CPP_EOF)
 warning (OPT_Wpragmas, "junk at end of %<#pragma weak%>");
 enum cpp_ttype token;
 tree x;
 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN)
 {
-error ("scalar_storage_order is not supported because endianness "
+error ("%<scalar_storage_order%> is not supported because endianness "
 	     "is not uniform");
 return;
 }
 if (c_dialect_cxx ())
 tree oldname, newname, decls, x;
 enum cpp_ttype t;
 bool found;
 if (pragma_lex (&oldname) != CPP_NAME)
-GCC_BAD ("malformed #pragma redefine_extname, ignored");
+GCC_BAD ("malformed %<#pragma redefine_extname%>, ignored");
 if (pragma_lex (&newname) != CPP_NAME)
-GCC_BAD ("malformed #pragma redefine_extname, ignored");
+GCC_BAD ("malformed %<#pragma redefine_extname%>, ignored");
 t = pragma_lex (&x);
 if (t != CPP_EOF)
 warning (OPT_Wpragmas, "junk at end of %<#pragma redefine_extname%>");
 found = false;
 	    {
 	      const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 	      name = targetm.strip_name_encoding (name);
 	      if (!id_equal (newname, name))
-		warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to "
+		warning (OPT_Wpragmas, "%<#pragma redefine_extname%> "
-			 "conflict with previous rename");
+			 "ignored due to conflict with previous rename");
 	    }
 	  else
 	    symtab->change_decl_assembler_name (decl, newname);
 	}
 }
 FOR_EACH_VEC_SAFE_ELT (pending_redefine_extname, ix, p)
 if (oldname == p->oldname)
 {
 	if (p->newname != newname)
-	  warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to "
+	  warning (OPT_Wpragmas, "%<#pragma redefine_extname%> ignored due to "
-		   "conflict with previous #pragma redefine_extname");
+		   "conflict with previous %<#pragma redefine_extname%>");
 	return;
 }
 pending_redefinition e = {oldname, newname};
 vec_safe_push (pending_redefine_extname, e);
 {
 const char *oldname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 oldname = targetm.strip_name_encoding (oldname);
 if (asmname && strcmp (TREE_STRING_POINTER (asmname), oldname))
-	  warning (OPT_Wpragmas, "asm declaration ignored due to "
+	  warning (OPT_Wpragmas, "%<asm%> declaration ignored due to "
 		   "conflict with previous rename");
 /* Take any pending redefine_extname off the list.  */
 FOR_EACH_VEC_SAFE_ELT (pending_redefine_extname, ix, p)
 	if (DECL_NAME (decl) == p->oldname)
 	  {
 	    /* Only warn if there is a conflict.  */
 	    if (!id_equal (p->newname, oldname))
-	      warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to "
+	      warning (OPT_Wpragmas, "%<#pragma redefine_extname%> ignored "
-		       "conflict with previous rename");
+		       "due to conflict with previous rename");
 	    pending_redefine_extname->unordered_remove (ix);
 	    break;
 	  }
 return NULL_TREE;
 	   ignored (with a warning if it conflicts).  */
 	if (asmname)
 	  {
 	    if (strcmp (TREE_STRING_POINTER (asmname),
 			IDENTIFIER_POINTER (newname)) != 0)
-	      warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to "
+	      warning (OPT_Wpragmas, "%<#pragma redefine_extname%> ignored "
-		       "conflict with __asm__ declaration");
+		       "due to conflict with %<asm%> declaration");
 	    return asmname;
 	  }
 	/* Otherwise we use what we've got; #pragma extern_prefix is
 	   silently ignored.  */
 else if (!strcmp (str, "hidden"))
 default_visibility = VISIBILITY_HIDDEN;
 else if (!strcmp (str, "protected"))
 default_visibility = VISIBILITY_PROTECTED;
 else
-GCC_BAD ("#pragma GCC visibility push() must specify default, internal, hidden or protected");
+GCC_BAD ("%<#pragma GCC visibility push()%> must specify %<default%>, "
+	     "%<internal%>, %<hidden%> or %<protected%>");
 visibility_options.inpragma = 1;
 }
 /* Pop a level of the #pragma visibility stack.  Return true if
 successful.  */
 	action = push;
 else if (!strcmp (op, "pop"))
 	action = pop;
 }
 if (bad == action)
-GCC_BAD ("#pragma GCC visibility must be followed by push or pop");
+GCC_BAD ("%<#pragma GCC visibility%> must be followed by %<push%> "
+	     "or %<pop%>");
 else
 {
 if (pop == action)
 	{
 	  if (! pop_visibility (0))
 	{
 	  if (pragma_lex (&x) != CPP_OPEN_PAREN)
 	    GCC_BAD ("missing %<(%> after %<#pragma GCC visibility push%> - ignored");
 	  token = pragma_lex (&x);
 	  if (token != CPP_NAME)
-	    GCC_BAD ("malformed #pragma GCC visibility push");
+	    GCC_BAD ("malformed %<#pragma GCC visibility push%>");
 	  else
 	    push_visibility (IDENTIFIER_POINTER (x), 0);
 	  if (pragma_lex (&x) != CPP_CLOSE_PAREN)
 	    GCC_BAD ("missing %<(%> after %<#pragma GCC visibility push%> - ignored");
 	}
 unsigned int lang_mask = c_common_option_lang_mask () | CL_COMMON;
 /* option_string + 1 to skip the initial '-' */
 unsigned int option_index = find_opt (option_string + 1, lang_mask);
 if (option_index == OPT_SPECIAL_unknown)
 {
-warning_at (loc, OPT_Wpragmas,
+option_proposer op;
-		  "unknown option after %<#pragma GCC diagnostic%> kind");
+const char *hint = op.suggest_option (option_string + 1);
+if (hint)
+	warning_at (loc, OPT_Wpragmas,
+		    "unknown option after %<#pragma GCC diagnostic%> kind;"
+		    " did you mean %<-%s%>", hint);
+else
+	warning_at (loc, OPT_Wpragmas,
+		    "unknown option after %<#pragma GCC diagnostic%> kind");
 return;
 }
 else if (!(cl_options[option_index].flags & CL_WARNING))
 {
 warning_at (loc, OPT_Wpragmas,
 tree x;
 bool close_paren_needed_p = false;
 if (cfun)
 {
-error ("#pragma GCC option is not allowed inside functions");
+error ("%<#pragma GCC option%> is not allowed inside functions");
 return;
 }
 token = pragma_lex (&x);
 if (token == CPP_OPEN_PAREN)
 		     "not have a final %<)%>");
 	}
 if (token != CPP_EOF)
 	{
-	  error ("#pragma GCC target string... is badly formed");
+	  error ("%<#pragma GCC target%> string is badly formed");
 	  return;
 	}
 /* put arguments in the order the user typed them.  */
 args = nreverse (args);
 bool close_paren_needed_p = false;
 tree optimization_previous_node = optimization_current_node;
 if (cfun)
 {
-error ("#pragma GCC optimize is not allowed inside functions");
+error ("%<#pragma GCC optimize%> is not allowed inside functions");
 return;
 }
 token = pragma_lex (&x);
 if (token == CPP_OPEN_PAREN)
 		     "not have a final %<)%>");
 	}
 if (token != CPP_EOF)
 	{
-	  error ("#pragma GCC optimize string... is badly formed");
+	  error ("%<#pragma GCC optimize%> string is badly formed");
 	  return;
 	}
 /* put arguments in the order the user typed them.  */
 args = nreverse (args);
 if (pragma_lex (&x) != CPP_EOF)
 warning (OPT_Wpragmas, "junk at end of %<#pragma message%>");
 if (TREE_STRING_LENGTH (message) > 1)
-inform (input_location, "#pragma message: %s", TREE_STRING_POINTER (message));
+inform (input_location, "%<#pragma message: %s%>",
+	    TREE_STRING_POINTER (message));
 }
 /* Mark whether the current location is valid for a STDC pragma.  */
 static bool valid_location_for_stdc_pragma;
 { "host_data", PRAGMA_OACC_HOST_DATA },
 { "kernels", PRAGMA_OACC_KERNELS },
 { "loop", PRAGMA_OACC_LOOP },
 { "parallel", PRAGMA_OACC_PARALLEL },
 { "routine", PRAGMA_OACC_ROUTINE },
+{ "serial", PRAGMA_OACC_SERIAL },
 { "update", PRAGMA_OACC_UPDATE },
 { "wait", PRAGMA_OACC_WAIT }
 };
 static const struct omp_pragma_def omp_pragmas[] = {
 { "atomic", PRAGMA_OMP_ATOMIC },
 { "barrier", PRAGMA_OMP_BARRIER },
 { "cancel", PRAGMA_OMP_CANCEL },
 { "cancellation", PRAGMA_OMP_CANCELLATION_POINT },
 { "critical", PRAGMA_OMP_CRITICAL },
+{ "depobj", PRAGMA_OMP_DEPOBJ },
 { "end", PRAGMA_OMP_END_DECLARE_TARGET },
 { "flush", PRAGMA_OMP_FLUSH },
 { "master", PRAGMA_OMP_MASTER },
+{ "requires", PRAGMA_OMP_REQUIRES },
 { "section", PRAGMA_OMP_SECTION },
 { "sections", PRAGMA_OMP_SECTIONS },
 { "single", PRAGMA_OMP_SINGLE },
 { "task", PRAGMA_OMP_TASK },
 { "taskgroup", PRAGMA_OMP_TASKGROUP },
 };
 static const struct omp_pragma_def omp_pragmas_simd[] = {
 { "declare", PRAGMA_OMP_DECLARE },
 { "distribute", PRAGMA_OMP_DISTRIBUTE },
 { "for", PRAGMA_OMP_FOR },
+{ "loop", PRAGMA_OMP_LOOP },
 { "ordered", PRAGMA_OMP_ORDERED },
 { "parallel", PRAGMA_OMP_PARALLEL },
+{ "scan", PRAGMA_OMP_SCAN },
 { "simd", PRAGMA_OMP_SIMD },
 { "target", PRAGMA_OMP_TARGET },
 { "taskloop", PRAGMA_OMP_TASKLOOP },
 { "teams", PRAGMA_OMP_TEAMS },
 };

Mercurial > hg > CbC > CbC_gcc

comparison gcc/c-family/c-pragma.c @ 145:1830386684a0