CbC/CbC_gcc: gcc/c/c-decl.c comparison

comparison gcc/c/c-decl.c @ 132:d34655255c78

update gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 10:21:07 +0900
parents	bdf41c9fa0b7 84e7813d76e9
children	351920fa3827

comparison

equal deleted inserted replaced

-:e108057fa461
+:d34655255c78
 /* Process declarations and variables for C compiler.
-Copyright (C) 1988-2017 Free Software Foundation, Inc.
+Copyright (C) 1988-2018 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
 /* ??? not all decl nodes are given the most useful possible
 line numbers.  For example, the CONST_DECLs for enum values.  */
 #include "config.h"
+#define INCLUDE_UNIQUE_PTR
 #include "system.h"
 #include "coretypes.h"
 #include "target.h"
 #include "function.h"
 #include "c-tree.h"
 #include "langhooks.h"
 #include "tree-iterator.h"
 #include "dumpfile.h"
 #include "plugin.h"
 #include "c-family/c-ada-spec.h"
-#include "cilk.h"
 #include "builtins.h"
 #include "spellcheck-tree.h"
 #include "gcc-rich-location.h"
 #include "asan.h"
+#include "c-family/name-hint.h"
+#include "c-family/known-headers.h"
+#include "c-family/c-spellcheck.h"
 #ifndef noCbC
 #include "cbc-tree.h"
 tree cbc_env;
 tree cbc_return_f;
 location_t cbc_return;
 bool
 global_bindings_p (void)
 {
 return current_scope == file_scope;
+}
+/* Return true if we're declaring parameters in an old-style function
+declaration.  */
+bool
+old_style_parameter_scope (void)
+{
+/* If processing parameters and there is no function statement list, we
+* have an old-style function declaration.  */
+return (current_scope->parm_flag && !DECL_SAVED_TREE (current_function_decl));
 }
 void
 keep_next_level (void)
 {
 	  && (B_IN_CURRENT_SCOPE (b)
 	      || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
 	  && (TYPE_MAIN_VARIANT (TREE_TYPE (b->decl))
 	      != TYPE_MAIN_VARIANT (type)))
 	{
+	  auto_diagnostic_group d;
 	  if (warning_at (loc, OPT_Wc___compat,
 			  ("using %qD as both a typedef and a tag is "
 			   "invalid in C++"), b->decl)
 	      && b->locus != UNKNOWN_LOCATION)
 	    inform (b->locus, "originally defined here");
 first in a pair of mismatched declarations, using the diagnostic
 function DIAG.  */
 static void
 locate_old_decl (tree decl)
 {
-if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl)
+if (TREE_CODE (decl) == FUNCTION_DECL && fndecl_built_in_p (decl)
 && !C_DECL_DECLARED_BUILTIN (decl))
 ;
 else if (DECL_INITIAL (decl))
 inform (input_location, "previous definition of %q+D was here", decl);
 else if (C_DECL_IMPLICIT (decl))
 static bool
 diagnose_mismatched_decls (tree newdecl, tree olddecl,
 			   tree *newtypep, tree *oldtypep)
 {
 tree newtype, oldtype;
-bool pedwarned = false;
-bool warned = false;
 bool retval = true;
 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL)  \
 				  && DECL_EXTERNAL (DECL))
 /* Two different categories of symbol altogether.  This is an error
 unless OLDDECL is a builtin.  OLDDECL will be discarded in any case.  */
 if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
 {
 if (!(TREE_CODE (olddecl) == FUNCTION_DECL
-	    && DECL_BUILT_IN (olddecl)
+	    && fndecl_built_in_p (olddecl)
 	    && !C_DECL_DECLARED_BUILTIN (olddecl)))
 	{
+	  auto_diagnostic_group d;
 	  error ("%q+D redeclared as different kind of symbol", newdecl);
 	  locate_old_decl (olddecl);
 	}
 else if (TREE_PUBLIC (newdecl))
 	warning (OPT_Wbuiltin_declaration_mismatch,
 /* Enumerators have no linkage, so may only be declared once in a
 given scope.  */
 if (TREE_CODE (olddecl) == CONST_DECL)
 {
+auto_diagnostic_group d;
 error ("redeclaration of enumerator %q+D", newdecl);
 locate_old_decl (olddecl);
 return false;
 }
+bool pedwarned = false;
+bool warned = false;
+auto_diagnostic_group d;
 if (!comptypes (oldtype, newtype))
 {
 if (TREE_CODE (olddecl) == FUNCTION_DECL
-	  && DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
+	  && fndecl_built_in_p (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
 	{
 	  /* Accept harmless mismatch in function types.
 	     This is for the ffs and fprintf builtins.  */
 	  tree trytype = match_builtin_function_types (newtype, oldtype);
 {
 /* If you declare a built-in function name as static, or
 	 define the built-in with an old-style definition (so we
 	 can't validate the argument list) the built-in definition is
 	 overridden, but optionally warn this was a bad choice of name.  */
-if (DECL_BUILT_IN (olddecl)
+if (fndecl_built_in_p (olddecl)
 	  && !C_DECL_DECLARED_BUILTIN (olddecl)
 	  && (!TREE_PUBLIC (newdecl)
 	      || (DECL_INITIAL (newdecl)
 		  && !prototype_p (TREE_TYPE (newdecl)))))
 	{
 			   || !lookup_attribute ("gnu_inline",
 						 DECL_ATTRIBUTES (newdecl))))
 		  )
 		  && same_translation_unit_p (newdecl, olddecl))
 		{
+		  auto_diagnostic_group d;
 		  error ("redefinition of %q+D", newdecl);
 		  locate_old_decl (olddecl);
 		  return false;
 		}
 	    }
 	}
 /* If we have a prototype after an old-style function definition,
 	 the argument types must be checked specially.  */
 else if (DECL_INITIAL (olddecl)
 	       && !prototype_p (oldtype) && prototype_p (newtype)
-	       && TYPE_ACTUAL_ARG_TYPES (oldtype)
+	       && TYPE_ACTUAL_ARG_TYPES (oldtype))
-	       && !validate_proto_after_old_defn (newdecl, newtype, oldtype))
+	{
-	{
+	  auto_diagnostic_group d;
-	  locate_old_decl (olddecl);
+	  if (!validate_proto_after_old_defn (newdecl, newtype, oldtype))
-	  return false;
+	    {
+	      locate_old_decl (olddecl);
+	      return false;
+	    }
 	}
 /* A non-static declaration (even an "extern") followed by a
 	 static declaration is undefined behavior per C99 6.2.2p3-5,7.
 	 The same is true for a static forward declaration at block
 	 scope followed by a non-static declaration/definition at file
 	     occur only in Objective C; see also above.  (FIXME: Make
 	     Objective C use normal builtins.)  */
 	  if (!DECL_IS_BUILTIN (olddecl)
 	      && !DECL_EXTERN_INLINE (olddecl))
 	    {
+	      auto_diagnostic_group d;
 	      error ("static declaration of %q+D follows "
 		     "non-static declaration", newdecl);
 	      locate_old_decl (olddecl);
 	    }
 	  return false;
 	}
 else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl))
 	{
 	  if (DECL_CONTEXT (olddecl))
 	    {
+	      auto_diagnostic_group d;
 	      error ("non-static declaration of %q+D follows "
 		     "static declaration", newdecl);
 	      locate_old_decl (olddecl);
 	      return false;
 	    }
 					DECL_ATTRIBUTES (newdecl)) != NULL;
 	  bool olda = lookup_attribute ("gnu_inline",
 					DECL_ATTRIBUTES (olddecl)) != NULL;
 	  if (newa != olda)
 	    {
+	      auto_diagnostic_group d;
 	      error_at (input_location, "%<gnu_inline%> attribute present on %q+D",
 			newa ? newdecl : olddecl);
 	      error_at (DECL_SOURCE_LOCATION (newa ? olddecl : newdecl),
 			"but not here");
 	    }
 	     will merge the threadprivate attribute into NEWDECL.  */
 	  ;
 	}
 else if (DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl))
 	{
+	  auto_diagnostic_group d;
 	  if (DECL_THREAD_LOCAL_P (newdecl))
 	    error ("thread-local declaration of %q+D follows "
 		   "non-thread-local declaration", newdecl);
 	  else
 	    error ("non-thread-local declaration of %q+D follows "
 	}
 /* Multiple initialized definitions are not allowed (6.9p3,5).  */
 if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
 	{
+	  auto_diagnostic_group d;
 	  error ("redefinition of %q+D", newdecl);
 	  locate_old_decl (olddecl);
 	  return false;
 	}
 	{
 	  if (DECL_EXTERNAL (newdecl))
 	    {
 	      if (!DECL_FILE_SCOPE_P (olddecl))
 		{
+		  auto_diagnostic_group d;
 		  error ("extern declaration of %q+D follows "
 			 "declaration with no linkage", newdecl);
 		  locate_old_decl (olddecl);
 		  return false;
 		}
 				     "follows static declaration", newdecl);
 		}
 	    }
 	  else
 	    {
+	      auto_diagnostic_group d;
 	      if (TREE_PUBLIC (newdecl))
 		error ("non-static declaration of %q+D follows "
 		       "static declaration", newdecl);
 	      else
 		error ("static declaration of %q+D follows "
 	      /* Extern with initializer at block scope, which will
 		 already have received an error.  */
 	    }
 	  else if (DECL_EXTERNAL (olddecl))
 	    {
+	      auto_diagnostic_group d;
 	      error ("declaration of %q+D with no linkage follows "
 		     "extern declaration", newdecl);
 	      locate_old_decl (olddecl);
 	    }
 	  else
 	    {
+	      auto_diagnostic_group d;
 	      error ("redeclaration of %q+D with no linkage", newdecl);
 	      locate_old_decl (olddecl);
 	    }
 	  return false;
 	 mark_forward_parm_decls.  */
 if (TREE_CODE (newdecl) == PARM_DECL
 	  && (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
 	{
+	  auto_diagnostic_group d;
 	  error ("redefinition of parameter %q+D", newdecl);
 	  locate_old_decl (olddecl);
 	  return false;
 	}
 }
 	 definition.  */
 && !(TREE_CODE (newdecl) == FUNCTION_DECL
 	   && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
 /* Don't warn about redundant redeclarations of builtins.  */
 && !(TREE_CODE (newdecl) == FUNCTION_DECL
-	   && !DECL_BUILT_IN (newdecl)
+	   && !fndecl_built_in_p (newdecl)
-	   && DECL_BUILT_IN (olddecl)
+	   && fndecl_built_in_p (olddecl)
 	   && !C_DECL_DECLARED_BUILTIN (olddecl))
 /* Don't warn about an extern followed by a definition.  */
 && !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
 /* Don't warn about forward parameter decls.  */
 && !(TREE_CODE (newdecl) == PARM_DECL
 	    = DECL_DISREGARD_INLINE_LIMITS (olddecl)
 	    = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
 	       || DECL_DISREGARD_INLINE_LIMITS (olddecl));
 	}
-if (DECL_BUILT_IN (olddecl))
+if (fndecl_built_in_p (olddecl))
 	{
 	  /* If redeclaring a builtin function, it stays built in.
 	     But it gets tagged as having been declared.  */
 	  DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
 	  DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
 /* Shadow warnings wanted?  */
 if (!(warn_shadow
 || warn_shadow_local
 || warn_shadow_compatible_local)
 /* No shadow warnings for internally generated vars.  */
-|| DECL_IS_BUILTIN (new_decl)
+|| DECL_IS_BUILTIN (new_decl))
-/* No shadow warnings for vars made for inlining.  */
-|| DECL_FROM_INLINE (new_decl))
 return;
 /* Is anything being shadowed?  Invisible decls do not count.  */
 for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
 if (b->decl && b->decl != new_decl && !b->invisible
 	&& (b->decl == error_mark_node
 	    || diagnostic_report_warnings_p (global_dc,
 					     DECL_SOURCE_LOCATION (b->decl))))
 {
 	tree old_decl = b->decl;
-	bool warned = false;
 	if (old_decl == error_mark_node)
 	  {
 	    warning (OPT_Wshadow, "declaration of %q+D shadows previous "
 		     "non-variable", new_decl);
 	    break;
 	  }
-	else if (TREE_CODE (old_decl) == PARM_DECL)
+	bool warned = false;
+	auto_diagnostic_group d;
+	if (TREE_CODE (old_decl) == PARM_DECL)
 	  {
 	    enum opt_code warning_code;
 	    /* If '-Wshadow=compatible-local' is specified without other
 	       -Wshadow= flags, we will warn only when the types of the
 				 "declaration of %qD shadows a global "
 				 "declaration",
 				 new_decl);
 	  }
 	else if (TREE_CODE (old_decl) == FUNCTION_DECL
-		 && DECL_BUILT_IN (old_decl))
+		 && fndecl_built_in_p (old_decl))
 	  {
 	    warning (OPT_Wshadow, "declaration of %q+D shadows "
 		     "a built-in function", new_decl);
 	    break;
 	  }
 		thistype = composite_type (vistype, type);
 	      else
 		thistype = TREE_TYPE (b_use->decl);
 	      b_use->u.type = TREE_TYPE (b_use->decl);
 	      if (TREE_CODE (b_use->decl) == FUNCTION_DECL
-		  && DECL_BUILT_IN (b_use->decl))
+		  && fndecl_built_in_p (b_use->decl))
 		thistype
 		  = build_type_attribute_variant (thistype,
 						  TYPE_ATTRIBUTES
 						  (b_use->u.type));
 	      TREE_TYPE (b_use->decl) = thistype;
 		thistype = TREE_TYPE (b->decl);
 	    }
 	  else
 	    thistype = type;
 	  b->u.type = TREE_TYPE (b->decl);
-	  if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
+	  if (TREE_CODE (b->decl) == FUNCTION_DECL
+	      && fndecl_built_in_p (b->decl))
 	    thistype
 	      = build_type_attribute_variant (thistype,
 					      TYPE_ATTRIBUTES (b->u.type));
 	  TREE_TYPE (b->decl) = thistype;
 	  bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true,
 {
 if (!warn_implicit_function_declaration)
 return;
 bool warned;
-const char *hint = NULL;
+auto_diagnostic_group d;
+name_hint hint;
 if (!olddecl)
-hint = lookup_name_fuzzy (id, FUZZY_LOOKUP_FUNCTION_NAME);
+hint = lookup_name_fuzzy (id, FUZZY_LOOKUP_FUNCTION_NAME, loc);
 if (flag_isoc99)
 {
 if (hint)
 	{
 	  gcc_rich_location richloc (loc);
-	  richloc.add_fixit_replace (hint);
+	  richloc.add_fixit_replace (hint.suggestion ());
-	  warned = pedwarn_at_rich_loc
+	  warned = pedwarn (&richloc, OPT_Wimplicit_function_declaration,
-	    (&richloc, OPT_Wimplicit_function_declaration,
+			    "implicit declaration of function %qE;"
-	     "implicit declaration of function %qE; did you mean %qs?",
+			    " did you mean %qs?",
-	     id, hint);
+			    id, hint.suggestion ());
 	}
 else
 	warned = pedwarn (loc, OPT_Wimplicit_function_declaration,
 			  "implicit declaration of function %qE", id);
 }
 else if (hint)
 {
 gcc_rich_location richloc (loc);
-richloc.add_fixit_replace (hint);
+richloc.add_fixit_replace (hint.suggestion ());
-warned = warning_at_rich_loc
+warned = warning_at
 	(&richloc, OPT_Wimplicit_function_declaration,
 	 G_("implicit declaration of function %qE; did you mean %qs?"),
-	 id, hint);
+	 id, hint.suggestion ());
 }
 else
 warned = warning_at (loc, OPT_Wimplicit_function_declaration,
 			 G_("implicit declaration of function %qE"), id);
 if (olddecl && warned)
 locate_old_decl (olddecl);
+if (!warned)
+hint.suppress ();
 }
 /* This function represents mapping of a function code FCODE
 to its respective header.  */
 CASE_FLT_FN (BUILT_IN_ATAN):
 CASE_FLT_FN (BUILT_IN_ATANH):
 CASE_FLT_FN (BUILT_IN_ATAN2):
 CASE_FLT_FN (BUILT_IN_CBRT):
 CASE_FLT_FN (BUILT_IN_CEIL):
+CASE_FLT_FN_FLOATN_NX (BUILT_IN_CEIL):
 CASE_FLT_FN (BUILT_IN_COPYSIGN):
+CASE_FLT_FN_FLOATN_NX (BUILT_IN_COPYSIGN):
 CASE_FLT_FN (BUILT_IN_COS):
 CASE_FLT_FN (BUILT_IN_COSH):
 CASE_FLT_FN (BUILT_IN_ERF):
 CASE_FLT_FN (BUILT_IN_ERFC):
 CASE_FLT_FN (BUILT_IN_EXP):
 CASE_FLT_FN (BUILT_IN_EXP2):
 CASE_FLT_FN (BUILT_IN_EXPM1):
 CASE_FLT_FN (BUILT_IN_FABS):
+CASE_FLT_FN_FLOATN_NX (BUILT_IN_FABS):
 CASE_FLT_FN (BUILT_IN_FDIM):
 CASE_FLT_FN (BUILT_IN_FLOOR):
+CASE_FLT_FN_FLOATN_NX (BUILT_IN_FLOOR):
 CASE_FLT_FN (BUILT_IN_FMA):
+CASE_FLT_FN_FLOATN_NX (BUILT_IN_FMA):
 CASE_FLT_FN (BUILT_IN_FMAX):
+CASE_FLT_FN_FLOATN_NX (BUILT_IN_FMAX):
 CASE_FLT_FN (BUILT_IN_FMIN):
+CASE_FLT_FN_FLOATN_NX (BUILT_IN_FMIN):
 CASE_FLT_FN (BUILT_IN_FMOD):
 CASE_FLT_FN (BUILT_IN_FREXP):
 CASE_FLT_FN (BUILT_IN_HYPOT):
 CASE_FLT_FN (BUILT_IN_ILOGB):
 CASE_FLT_FN (BUILT_IN_LDEXP):
 CASE_FLT_FN (BUILT_IN_LRINT):
 CASE_FLT_FN (BUILT_IN_LROUND):
 CASE_FLT_FN (BUILT_IN_MODF):
 CASE_FLT_FN (BUILT_IN_NAN):
 CASE_FLT_FN (BUILT_IN_NEARBYINT):
+CASE_FLT_FN_FLOATN_NX (BUILT_IN_NEARBYINT):
 CASE_FLT_FN (BUILT_IN_NEXTAFTER):
 CASE_FLT_FN (BUILT_IN_NEXTTOWARD):
 CASE_FLT_FN (BUILT_IN_POW):
 CASE_FLT_FN (BUILT_IN_REMAINDER):
 CASE_FLT_FN (BUILT_IN_REMQUO):
 CASE_FLT_FN (BUILT_IN_RINT):
+CASE_FLT_FN_FLOATN_NX (BUILT_IN_RINT):
 CASE_FLT_FN (BUILT_IN_ROUND):
+CASE_FLT_FN_FLOATN_NX (BUILT_IN_ROUND):
 CASE_FLT_FN (BUILT_IN_SCALBLN):
 CASE_FLT_FN (BUILT_IN_SCALBN):
 CASE_FLT_FN (BUILT_IN_SIN):
 CASE_FLT_FN (BUILT_IN_SINH):
 CASE_FLT_FN (BUILT_IN_SINCOS):
 CASE_FLT_FN (BUILT_IN_SQRT):
+CASE_FLT_FN_FLOATN_NX (BUILT_IN_SQRT):
 CASE_FLT_FN (BUILT_IN_TAN):
 CASE_FLT_FN (BUILT_IN_TANH):
 CASE_FLT_FN (BUILT_IN_TGAMMA):
 CASE_FLT_FN (BUILT_IN_TRUNC):
+CASE_FLT_FN_FLOATN_NX (BUILT_IN_TRUNC):
 case BUILT_IN_ISINF:
 case BUILT_IN_ISNAN:
 return "<math.h>";
 CASE_FLT_FN (BUILT_IN_CABS):
 CASE_FLT_FN (BUILT_IN_CACOS):
 /* FIXME: Objective-C has weird not-really-builtin functions
 	 which are supposed to be visible automatically.  They wind up
 	 in the external scope because they're pushed before the file
 	 scope gets created.  Catch this here and rebind them into the
 	 file scope.  */
-if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
+if (!fndecl_built_in_p (decl) && DECL_IS_BUILTIN (decl))
 	{
 	  bind (functionid, decl, file_scope,
 		/*invisible=*/false, /*nested=*/true,
 		DECL_SOURCE_LOCATION (decl));
 	  return decl;
 	  if (!C_DECL_IMPLICIT (decl))
 	    {
 	      implicit_decl_warning (loc, functionid, decl);
 	      C_DECL_IMPLICIT (decl) = 1;
 	    }
-	  if (DECL_BUILT_IN (decl))
+	  if (fndecl_built_in_p (decl))
 	    {
 	      newtype = build_type_attribute_variant (newtype,
 						      TYPE_ATTRIBUTES
 						      (TREE_TYPE (decl)));
 	      if (!comptypes (newtype, TREE_TYPE (decl)))
 		  const char *header
 		    = header_for_builtin_fn (DECL_FUNCTION_CODE (decl));
 		  if (header != NULL && warned)
 		    {
 		      rich_location richloc (line_table, loc);
-		      maybe_add_include_fixit (&richloc, header);
+		      maybe_add_include_fixit (&richloc, header, true);
-		      inform_at_rich_loc
+		      inform (&richloc,
-			(&richloc,
+			      "include %qs or provide a declaration of %qD",
-			 "include %qs or provide a declaration of %qD",
+			      header, decl);
-			 header, decl);
 		    }
 		  newtype = TREE_TYPE (decl);
 		}
 	    }
 	  else
 	    {
 	      if (!comptypes (newtype, TREE_TYPE (decl)))
 		{
+		  auto_diagnostic_group d;
 		  error_at (loc, "incompatible implicit declaration of "
 			    "function %qD", decl);
 		  locate_old_decl (decl);
 		}
 	    }
 undeclared_variable (location_t loc, tree id)
 {
 static bool already = false;
 struct c_scope *scope;
+auto_diagnostic_group d;
 if (current_function_decl == NULL_TREE)
 {
-const char *guessed_id = lookup_name_fuzzy (id, FUZZY_LOOKUP_NAME);
+name_hint guessed_id = lookup_name_fuzzy (id, FUZZY_LOOKUP_NAME, loc);
 if (guessed_id)
 	{
 	  gcc_rich_location richloc (loc);
-	  richloc.add_fixit_replace (guessed_id);
+	  richloc.add_fixit_replace (guessed_id.suggestion ());
-	  error_at_rich_loc (&richloc,
+	  error_at (&richloc,
-			     "%qE undeclared here (not in a function);"
+		    "%qE undeclared here (not in a function);"
-			     " did you mean %qs?",
+		    " did you mean %qs?",
-			     id, guessed_id);
+		    id, guessed_id.suggestion ());
 	}
 else
 	error_at (loc, "%qE undeclared here (not in a function)", id);
 scope = current_scope;
 }
 else
 {
 if (!objc_diagnose_private_ivar (id))
 	{
-	  const char *guessed_id = lookup_name_fuzzy (id, FUZZY_LOOKUP_NAME);
+	  name_hint guessed_id = lookup_name_fuzzy (id, FUZZY_LOOKUP_NAME, loc);
 	  if (guessed_id)
 	    {
 	      gcc_rich_location richloc (loc);
-	      richloc.add_fixit_replace (guessed_id);
+	      richloc.add_fixit_replace (guessed_id.suggestion ());
-	      error_at_rich_loc
+	      error_at (&richloc,
-		(&richloc,
+			"%qE undeclared (first use in this function);"
-		 "%qE undeclared (first use in this function);"
+			" did you mean %qs?",
-		 " did you mean %qs?",
+			id, guessed_id.suggestion ());
-		 id, guessed_id);
 	    }
 	  else
 	    error_at (loc, "%qE undeclared (first use in this function)", id);
 	}
 if (!already)
 /* Check to make sure that the label hasn't already been declared
 at this scope */
 if (b && B_IN_CURRENT_SCOPE (b))
 {
+auto_diagnostic_group d;
 error ("duplicate label declaration %qE", name);
 locate_old_decl (b->decl);
 /* Just use the previous declaration.  */
 return b->decl;
 && ((DECL_CONTEXT (label) == current_function_decl
 	   && DECL_INITIAL (label) != NULL_TREE)
 	  || (DECL_CONTEXT (label) != current_function_decl
 	      && C_DECLARED_LABEL_FLAG (label))))
 {
+auto_diagnostic_group d;
 error_at (location, "duplicate label %qD", label);
 locate_old_decl (label);
 return NULL_TREE;
 }
 else if (label && DECL_CONTEXT (label) == current_function_decl)
 The function also looks for similar macro names to NAME, since a
 misspelled macro name will not be expanded, and hence looks like an
 identifier to the C frontend.
 It also looks for start_typename keywords, to detect "singed" vs "signed"
-typos.  */
+typos.
-const char *
+Use LOC for any deferred diagnostics.  */
-lookup_name_fuzzy (tree name, enum lookup_name_fuzzy_kind kind)
+name_hint
+lookup_name_fuzzy (tree name, enum lookup_name_fuzzy_kind kind, location_t loc)
 {
 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
+/* First, try some well-known names in the C standard library, in case
+the user forgot a #include.  */
+const char *header_hint
+= get_c_stdlib_header_for_name (IDENTIFIER_POINTER (name));
+if (header_hint)
+return name_hint (NULL,
+		      new suggest_missing_header (loc,
+						  IDENTIFIER_POINTER (name),
+						  header_hint));
+/* Only suggest names reserved for the implementation if NAME begins
+with an underscore.  */
+bool consider_implementation_names = (IDENTIFIER_POINTER (name)[0] == '_');
 best_match<tree, tree> bm (name);
 /* Look within currently valid scopes.  */
 for (c_scope *scope = current_scope; scope; scope = scope->outer)
 for (c_binding *binding = scope->bindings; binding; binding = binding->prev)
 {
 	if (!binding->id || binding->invisible)
 	  continue;
+	if (binding->decl == error_mark_node)
+	  continue;
 	/* Don't use bindings from implicitly declared functions,
 	   as they were likely misspellings themselves.  */
 	if (TREE_CODE (binding->decl) == FUNCTION_DECL)
 	  if (C_DECL_IMPLICIT (binding->decl))
 	    continue;
+	/* Don't suggest names that are reserved for use by the
+	   implementation, unless NAME began with an underscore.  */
+	if (!consider_implementation_names)
+	  {
+	    const char *suggestion_str = IDENTIFIER_POINTER (binding->id);
+	    if (name_reserved_for_implementation_p (suggestion_str))
+	      continue;
+	  }
 	switch (kind)
 	  {
 	  case FUZZY_LOOKUP_TYPENAME:
 	    if (TREE_CODE (binding->decl) != TYPE_DECL)
 	      continue;
 	}
 }
 tree best = bm.get_best_meaningful_candidate ();
 if (best)
-return IDENTIFIER_POINTER (best);
+return name_hint (IDENTIFIER_POINTER (best), NULL);
 else
-return NULL;
+return name_hint (NULL, NULL);
 }
 /* Create the predefined scalar types of C,
 and some nodes representing standard constants (0, 1, (void *) 0).
 && ((VAR_P (*node) && is_global_var (*node))
 	  || TREE_CODE (*node) == FUNCTION_DECL))
 {
 if (VAR_P (*node)
 	  && !lang_hooks.types.omp_mappable_type (TREE_TYPE (*node)))
-	error ("%q+D in declare target directive does not have mappable type",
+	attributes = tree_cons (get_identifier ("omp declare target implicit"),
-	       *node);
+				NULL_TREE, attributes);
 else
 	attributes = tree_cons (get_identifier ("omp declare target"),
 				NULL_TREE, attributes);
 }
-return decl_attributes (node, attributes, flags);
+/* Look up the current declaration with all the attributes merged
+so far so that attributes on the current declaration that's
+about to be pushed that conflict with the former can be detected,
+diagnosed, and rejected as appropriate.  */
+tree last_decl = lookup_name (DECL_NAME (*node));
+if (!last_decl)
+last_decl = lookup_name_in_scope (DECL_NAME (*node), external_scope);
+return decl_attributes (node, attributes, flags, last_decl);
 }
 /* Decode a declarator in an ordinary declaration or data definition.
 This is called as soon as the type information and variable name
 return NULL_TREE;
 if (expr)
 add_stmt (fold_convert (void_type_node, expr));
-if (TREE_CODE (decl) != FUNCTION_DECL && MAIN_NAME_P (DECL_NAME (decl)))
+if (TREE_CODE (decl) != FUNCTION_DECL && MAIN_NAME_P (DECL_NAME (decl))
+&& TREE_PUBLIC (decl))
 warning (OPT_Wmain, "%q+D is usually a function", decl);
 if (initialized)
 /* Is it valid for this decl to have an initializer at all?
 If not, set INITIALIZED to zero, which will indirectly
 	  break;
 	case 2:
 	  if (do_default)
 	    error ("array size missing in %q+D", decl);
-	  /* If a `static' var's size isn't known,
-	     make it extern as well as static, so it does not get
-	     allocated.
-	     If it is not `static', then do not mark extern;
-	     finish_incomplete_decl will give it a default size
-	     and it will get allocated.  */
-	  else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
-	    DECL_EXTERNAL (decl) = 1;
 	  break;
 	case 3:
 	  error ("zero or negative size array %q+D", decl);
 	  break;
 	TREE_TYPE (DECL_INITIAL (decl)) = type;
 relayout_decl (decl);
 }
+if (TREE_CODE (type) == ARRAY_TYPE
+&& TYPE_STRING_FLAG (TREE_TYPE (type))
+&& DECL_INITIAL (decl)
+&& TREE_CODE (DECL_INITIAL (decl)) == CONSTRUCTOR)
+DECL_INITIAL (decl) = braced_list_to_string (type, DECL_INITIAL (decl));
 if (VAR_P (decl))
 {
 if (init && TREE_CODE (init) == CONSTRUCTOR)
 	add_flexible_array_elts_to_size (decl, init);
+complete_flexible_array_elts (DECL_INITIAL (decl));
 if (DECL_SIZE (decl) == NULL_TREE && TREE_TYPE (decl) != error_mark_node
 	  && COMPLETE_TYPE_P (TREE_TYPE (decl)))
 	layout_decl (decl, 0);
 else if (RECORD_OR_UNION_TYPE_P (type)
 	       && C_TYPE_FIELDS_READONLY (type))
 	diagnose_uninitialized_cst_member (decl, type);
 }
-	invoke_plugin_callbacks (PLUGIN_FINISH_DECL, decl);
+if (flag_openmp
+&& VAR_P (decl)
+&& lookup_attribute ("omp declare target implicit",
+			   DECL_ATTRIBUTES (decl)))
+{
+DECL_ATTRIBUTES (decl)
+	= remove_attribute ("omp declare target implicit",
+			    DECL_ATTRIBUTES (decl));
+if (!lang_hooks.types.omp_mappable_type (TREE_TYPE (decl)))
+	error ("%q+D in declare target directive does not have mappable type",
+	       decl);
+else if (!lookup_attribute ("omp declare target",
+				  DECL_ATTRIBUTES (decl))
+	       && !lookup_attribute ("omp declare target link",
+				     DECL_ATTRIBUTES (decl)))
+	DECL_ATTRIBUTES (decl)
+	  = tree_cons (get_identifier ("omp declare target"),
+		       NULL_TREE, DECL_ATTRIBUTES (decl));
+}
+invoke_plugin_callbacks (PLUGIN_FINISH_DECL, decl);
 }
 /* Given a parsed parameter declaration, decode it into a PARM_DECL.
 EXPR is NULL or a pointer to an expression that needs to be
 evaluated for the side effects of array size expressions in the
 /* Build a COMPOUND_LITERAL_EXPR.  TYPE is the type given in the compound
 literal, which may be an incomplete array type completed by the
 initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound
 literal.  NON_CONST is true if the initializers contain something
-that cannot occur in a constant expression.  */
+that cannot occur in a constant expression.  If ALIGNAS_ALIGN is nonzero,
+it is the (valid) alignment for this compound literal, as specified
+with _Alignas.  */
 tree
-build_compound_literal (location_t loc, tree type, tree init, bool non_const)
+build_compound_literal (location_t loc, tree type, tree init, bool non_const,
+			unsigned int alignas_align)
 {
 /* We do not use start_decl here because we have a type, not a declarator;
 and do not use finish_decl because the decl should be stored inside
 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR.  */
 tree decl;
 DECL_READ_P (decl) = 1;
 DECL_ARTIFICIAL (decl) = 1;
 DECL_IGNORED_P (decl) = 1;
 TREE_TYPE (decl) = type;
 c_apply_type_quals_to_decl (TYPE_QUALS (strip_array_types (type)), decl);
+if (alignas_align)
+{
+SET_DECL_ALIGN (decl, alignas_align * BITS_PER_UNIT);
+DECL_USER_ALIGN (decl) = 1;
+}
 store_init_value (loc, decl, init, NULL_TREE);
 if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
 {
 int failure = complete_array_type (&TREE_TYPE (decl),
 DECL_DEFER_OUTPUT (decl) = 1;
 DECL_COMDAT (decl) = 1;
 pushdecl (decl);
 rest_of_decl_compilation (decl, 1, 0);
 }
+else
+pushdecl (decl);
 if (non_const)
 {
 complit = build2 (C_MAYBE_CONST_EXPR, type, NULL, complit);
 C_MAYBE_CONST_EXPR_NON_CONST (complit) = 1;
 pedwarn_c90 (loc, OPT_Wpedantic,
 		 "type of bit-field %qs is a GCC extension", name);
 max_width = TYPE_PRECISION (*type);
-if (0 < compare_tree_int (*width, max_width))
+if (compare_tree_int (*width, max_width) > 0)
 {
 error_at (loc, "width of %qs exceeds its type", name);
 w = max_width;
 *width = build_int_cst (integer_type_node, w);
 }
 if (declspecs->default_int_p && !in_system_header_at (input_location))
 {
 /* Issue a warning if this is an ISO C 99 program or if
 	 -Wreturn-type and this is a function, or if -Wimplicit;
 	 prefer the former warning since it is more explicit.  */
-if ((warn_implicit_int || warn_return_type || flag_isoc99)
+if ((warn_implicit_int || warn_return_type > 0 || flag_isoc99)
 	  && funcdef_flag)
 	warn_about_return_type = 1;
 else
 	{
 	  if (name)
 /* Applying the _Atomic qualifier to an array type (through the use
 of typedefs or typeof) must be detected here.  If the qualifier
 is introduced later, any appearance of applying it to an array is
 actually applying it to an element of that array.  */
-if (atomicp && TREE_CODE (type) == ARRAY_TYPE)
+if (declspecs->atomic_p && TREE_CODE (type) == ARRAY_TYPE)
 error_at (loc, "%<_Atomic%>-qualified array type");
 /* Warn about storage classes that are invalid for certain
 kinds of declarations (parameters, typenames, etc.).  */
 	       This is expected to happen automatically when the pointed-to
 	       type has a name/declaration of it's own, but special attention
 	       is required if the type is anonymous.
-	       We handle the NORMAL and FIELD contexts here by attaching an
+	       We attach an artificial TYPE_DECL to such pointed-to type
-	       artificial TYPE_DECL to such pointed-to type.  This forces the
+	       and arrange for it to be included in a DECL_EXPR.  This
-	       sizes evaluation at a safe point and ensures it is not deferred
+	       forces the sizes evaluation at a safe point and ensures it
-	       until e.g. within a deeper conditional context.
+	       is not deferred until e.g. within a deeper conditional context.
-	       We expect nothing to be needed here for PARM or TYPENAME.
+	       PARM contexts have no enclosing statement list that
-	       Pushing a TYPE_DECL at this point for TYPENAME would actually
+	       can hold the DECL_EXPR, so we need to use a BIND_EXPR
-	       be incorrect, as we might be in the middle of an expression
+	       instead, and add it to the list of expressions that
-	       with side effects on the pointed-to type size "arguments" prior
+	       need to be evaluated.
-	       to the pointer declaration point and the fake TYPE_DECL in the
-	       enclosing context would force the size evaluation prior to the
+	       TYPENAME contexts do have an enclosing statement list,
-	       side effects.  */
+	       but it would be incorrect to use it, as the size should
+	       only be evaluated if the containing expression is
+	       evaluated.  We might also be in the middle of an
+	       expression with side effects on the pointed-to type size
+	       "arguments" prior to the pointer declaration point and
+	       the fake TYPE_DECL in the enclosing context would force
+	       the size evaluation prior to the side effects.  We therefore
+	       use BIND_EXPRs in TYPENAME contexts too.  */
 	    if (!TYPE_NAME (type)
-		&& (decl_context == NORMAL || decl_context == FIELD)
 		&& variably_modified_type_p (type, NULL_TREE))
 	      {
+		tree bind = NULL_TREE;
+		if (decl_context == TYPENAME || decl_context == PARM)
+		  {
+		    bind = build3 (BIND_EXPR, void_type_node, NULL_TREE,
+				   NULL_TREE, NULL_TREE);
+		    TREE_SIDE_EFFECTS (bind) = 1;
+		    BIND_EXPR_BODY (bind) = push_stmt_list ();
+		    push_scope ();
+		  }
 		tree decl = build_decl (loc, TYPE_DECL, NULL_TREE, type);
 		DECL_ARTIFICIAL (decl) = 1;
 		pushdecl (decl);
 		finish_decl (decl, loc, NULL_TREE, NULL_TREE, NULL_TREE);
 		TYPE_NAME (type) = decl;
+		if (bind)
+		  {
+		    pop_scope ();
+		    BIND_EXPR_BODY (bind)
+		      = pop_stmt_list (BIND_EXPR_BODY (bind));
+		    if (*expr)
+		      *expr = build2 (COMPOUND_EXPR, void_type_node, *expr,
+				      bind);
+		    else
+		      *expr = bind;
+		  }
 	      }
 	    type = c_build_pointer_type (type);
 	    /* Process type qualifiers (such as const or volatile)
 	      && b->decl != NULL_TREE
 	      && (B_IN_CURRENT_SCOPE (b)
 		  || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
 	      && TYPE_MAIN_VARIANT (b->decl) != TYPE_MAIN_VARIANT (type))
 	    {
+	      auto_diagnostic_group d;
 	      if (warning_at (declarator->id_loc, OPT_Wc___compat,
 			      ("using %qD as both a typedef and a tag is "
 			       "invalid in C++"), decl)
 		  && b->locus != UNKNOWN_LOCATION)
 		inform (b->locus, "originally defined here");
 				       orig_qual_indirect);
 	decl = build_decl (declarator->id_loc,
 			   FIELD_DECL, declarator->u.id, type);
 	DECL_NONADDRESSABLE_P (decl) = bitfield;
 	if (bitfield && !declarator->u.id)
-	  TREE_NO_WARNING (decl) = 1;
+	  {
+	    TREE_NO_WARNING (decl) = 1;
+	    DECL_PADDING_P (decl) = 1;
+	  }
 	if (size_varies)
 	  C_DECL_VARIABLE_SIZE (decl) = 1;
 }
 else if (TREE_CODE (type) == FUNCTION_TYPE)
 {
 TYPE_TRANSPARENT_AGGR (t) = 0;
 warning_at (loc, 0, "union cannot be made transparent");
 }
+/* Update type location to the one of the definition, instead of e.g.
+a forward declaration.  */
+if (TYPE_STUB_DECL (t))
+DECL_SOURCE_LOCATION (TYPE_STUB_DECL (t)) = loc;
+/* Finish debugging output for this type.  */
+rest_of_type_compilation (t, toplevel);
 /* If this structure or union completes the type of any previous
 variable declaration, lay it out and output its rtl.  */
 for (x = incomplete_vars; x; x = TREE_CHAIN (x))
 {
 tree decl = TREE_VALUE (x);
 	  if (c_dialect_objc ())
 	    objc_check_decl (decl);
 	  rest_of_decl_compilation (decl, toplevel, 0);
 	}
 }
-/* Update type location to the one of the definition, instead of e.g.
-a forward declaration.  */
-if (TYPE_STUB_DECL (t))
-DECL_SOURCE_LOCATION (TYPE_STUB_DECL (t)) = loc;
-/* Finish debugging output for this type.  */
-rest_of_type_compilation (t, toplevel);
 /* If we're inside a function proper, i.e. not file-scope and not still
 parsing parameters, then arrange for the size of a variable sized type
 to be bound now.  */
 if (building_stmt_list_p () && variably_modified_type_p (t, NULL_TREE))
 			       TYPE_ARG_TYPES (TREE_TYPE (decl1)));
 }
 if (warn_about_return_type)
 warn_defaults_to (loc, flag_isoc99 ? OPT_Wimplicit_int
-			   : (warn_return_type ? OPT_Wreturn_type
+			   : (warn_return_type > 0 ? OPT_Wreturn_type
 			      : OPT_Wimplicit_int),
 		      "return type defaults to %<int%>");
 /* Make the init_value nonzero so pushdecl knows this is not tentative.
 error_mark_node is replaced below (in pop_scope) with the BLOCK.  */
 	  && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
 			TREE_TYPE (TREE_TYPE (old_decl))))
 	{
 	  if (stdarg_p (TREE_TYPE (old_decl)))
 	    {
+	      auto_diagnostic_group d;
 	      warning_at (loc, 0, "%q+D defined as variadic function "
 			  "without prototype", decl1);
 	      locate_old_decl (old_decl);
 	    }
 	  TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl),
 }
 /* Tie off the statement tree for this function.  */
 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
-/* If the function has _Cilk_spawn in front of a function call inside it
-i.e. it is a spawning function, then add the appropriate Cilk plus
-functions inside.  */
-if (fn_contains_cilk_spawn_p (cfun))
-cfun->cilk_frame_decl = insert_cilk_frame (fndecl);
 finish_fname_decls ();
-/* Complain if there's just no return statement.  */
+/* Complain if there's no return statement only if option specified on
-if (warn_return_type
+command line.  */
+if (warn_return_type > 0
 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
 && !current_function_returns_value && !current_function_returns_null
 /* Don't complain if we are no-return.  */
 && !current_function_returns_abnormally
 /* Don't complain if we are declared noreturn.  */
 		  "to compile your code");
 	  hint = false;
 	}
 return NULL_TREE;
 }
+else
+pedwarn_c90 (loc, OPT_Wpedantic, "ISO C90 does not support %<for%> loop "
+		 "initial declarations");
 /* C99 subclause 6.8.5 paragraph 3:
 [#3]  The  declaration  part  of  a for statement shall only
 declare identifiers for objects having storage class auto or
 register.

Mercurial > hg > CbC > CbC_gcc

comparison gcc/c/c-decl.c @ 132:d34655255c78