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

comparison gcc/cp/decl.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
-/* Process declarations and variables for C++ compiler.
+/* Process declarations and variables for -*- C++ -*- compiler.
-Copyright (C) 1988-2018 Free Software Foundation, Inc.
+Copyright (C) 1988-2020 Free Software Foundation, Inc.
 Contributed by Michael Tiemann (tiemann@cygnus.com)
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify
 #include "builtins.h"
 #include "gimplify.h"
 #include "asan.h"
 #include "gcc-rich-location.h"
 #include "langhooks.h"
+#include "omp-general.h"
 /* Possible cases of bad specifiers type used by bad_specifiers. */
 enum bad_spec_place {
 BSP_VAR,    /* variable */
 BSP_PARM,   /* parameter */
 static const char *redeclaration_error_message (tree, tree);
 static int decl_jump_unsafe (tree);
 static void require_complete_types_for_parms (tree);
-static void push_local_name (tree);
 static tree grok_reference_init (tree, tree, tree, int);
 static tree grokvardecl (tree, tree, tree, const cp_decl_specifier_seq *,
-			 int, int, int, bool, int, tree);
+			 int, int, int, bool, int, tree, location_t);
 static void check_static_variable_definition (tree, tree);
 static void record_unknown_type (tree, const char *);
-static tree builtin_function_1 (tree, tree, bool);
 static int member_function_or_else (tree, tree, enum overload_flags);
 static tree local_variable_p_walkfn (tree *, int *, void *);
 static const char *tag_name (enum tag_types);
 static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
 static void maybe_deduce_size_from_array_init (tree, tree);
 static void layout_var_decl (tree);
 static tree check_initializer (tree, tree, int, vec<tree, va_gc> **);
 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
-static void save_function_data (tree);
 static void copy_type_enum (tree , tree);
 static void check_function_type (tree, tree);
 static void finish_constructor_body (void);
 static void begin_destructor_body (void);
 static void finish_destructor_body (void);
 static void record_key_method_defined (tree);
-static tree create_array_type_for_decl (tree, tree, tree);
+static tree create_array_type_for_decl (tree, tree, tree, location_t);
 static tree get_atexit_node (void);
 static tree get_dso_handle_node (void);
 static tree start_cleanup_fn (void);
 static void end_cleanup_fn (void);
 static tree cp_make_fname_decl (location_t, tree, int);
 static tree push_cp_library_fn (enum tree_code, tree, int);
 static tree build_cp_library_fn (tree, enum tree_code, tree, int);
 static void store_parm_decls (tree);
 static void initialize_local_var (tree, tree);
 static void expand_static_init (tree, tree);
+static location_t smallest_type_location (const cp_decl_specifier_seq*);
 /* The following symbols are subsumed in the cp_global_trees array, and
 listed here individually for documentation purposes.
 C++ extensions
 Used by RTTI
 	tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 	tree tinfo_var_id;  */
 tree cp_global_trees[CPTI_MAX];
-#define local_names cp_function_chain->x_local_names
 /* A list of objects which have constructors or destructors
 which reside in the global scope.  The decl is stored in
 the TREE_VALUE slot and the initializer is stored
 in the TREE_PURPOSE slot.  */
 TYPE_STUB_DECL (type) = decl;
 return decl;
 }
-/* Remember a local name for name-mangling purposes.  */
+/* Function-scope local entities that need discriminators.  Each entry
+is a {decl,name} pair.  VAR_DECLs for anon unions get their name
-static void
+smashed, so we cannot rely on DECL_NAME.  */
-push_local_name (tree decl)
-{
+static GTY((deletable)) vec<tree, va_gc> *local_entities;
-size_t i, nelts;
-tree t, name;
+/* Determine the mangling discriminator of local DECL.  There are
+generally very few of these in any particular function.  */
-timevar_start (TV_NAME_LOOKUP);
+void
-name = DECL_NAME (decl);
+determine_local_discriminator (tree decl)
+{
-nelts = vec_safe_length (local_names);
+bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
-for (i = 0; i < nelts; i++)
+retrofit_lang_decl (decl);
-{
+tree ctx = DECL_CONTEXT (decl);
-t = (*local_names)[i];
+tree name = (TREE_CODE (decl) == TYPE_DECL
-if (DECL_NAME (t) == name)
+	       && TYPE_UNNAMED_P (TREE_TYPE (decl))
-	{
+	       ? NULL_TREE : DECL_NAME (decl));
-	  retrofit_lang_decl (decl);
+size_t nelts = vec_safe_length (local_entities);
-	  DECL_LANG_SPECIFIC (decl)->u.base.u2sel = 1;
+for (size_t i = 0; i < nelts; i += 2)
-	  if (DECL_DISCRIMINATOR_SET_P (t))
+{
-	    DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
+tree *pair = &(*local_entities)[i];
-	  else
+tree d = pair[0];
-	    DECL_DISCRIMINATOR (decl) = 1;
+tree n = pair[1];
+gcc_checking_assert (d != decl);
-	  (*local_names)[i] = decl;
+if (name == n
-	  timevar_stop (TV_NAME_LOOKUP);
+	  && TREE_CODE (decl) == TREE_CODE (d)
-	  return;
+	  && ctx == DECL_CONTEXT (d))
-	}
+	{
-}
+	  tree disc = integer_one_node;
+	  if (DECL_DISCRIMINATOR (d))
-vec_safe_push (local_names, decl);
+	    disc = build_int_cst (TREE_TYPE (disc),
-timevar_stop (TV_NAME_LOOKUP);
+				  TREE_INT_CST_LOW (DECL_DISCRIMINATOR (d)) + 1);
-}
+	  DECL_DISCRIMINATOR (decl) = disc;
+	  /* Replace the saved decl.  */
+	  pair[0] = decl;
+	  decl = NULL_TREE;
+	  break;
+	}
+}
+if (decl)
+{
+vec_safe_reserve (local_entities, 2);
+local_entities->quick_push (decl);
+local_entities->quick_push (name);
+}
+timevar_cond_stop (TV_NAME_LOOKUP, subtime);
+}
+/* Returns true if functions FN1 and FN2 have equivalent trailing
+requires clauses.  */
+static bool
+function_requirements_equivalent_p (tree newfn, tree oldfn)
+{
+/* In the concepts TS, the combined constraints are compared.  */
+if (cxx_dialect < cxx2a)
+{
+tree ci1 = get_constraints (oldfn);
+tree ci2 = get_constraints (newfn);
+tree req1 = ci1 ? CI_ASSOCIATED_CONSTRAINTS (ci1) : NULL_TREE;
+tree req2 = ci2 ? CI_ASSOCIATED_CONSTRAINTS (ci2) : NULL_TREE;
+return cp_tree_equal (req1, req2);
+}
+/* Compare only trailing requirements.  */
+tree reqs1 = get_trailing_function_requirements (newfn);
+tree reqs2 = get_trailing_function_requirements (oldfn);
+if ((reqs1 != NULL_TREE) != (reqs2 != NULL_TREE))
+return false;
+reqs1 = maybe_substitute_reqs_for (reqs1, newfn);
+reqs2 = maybe_substitute_reqs_for (reqs2, oldfn);
+return cp_tree_equal (reqs1, reqs2);
+}
 /* Subroutine of duplicate_decls: return truthvalue of whether
 or not types of these decls match.
 For C++, we must compare the parameter list so that `int' can match
 `int&' in a parameter position, but `int&' is not confused with
 					   TREE_TYPE (olddecl)) != 0);
 	}
 else
 	types_match = 0;
+/* Two function declarations match if either has a requires-clause
+then both have a requires-clause and their constraints-expressions
+are equivalent.  */
+if (types_match && flag_concepts)
+	types_match = function_requirements_equivalent_p (newdecl, olddecl);
 /* The decls dont match if they correspond to two different versions
 	 of the same function.   Disallow extern "C" functions to be
 	 versions for now.  */
 if (types_match
 	  && !DECL_EXTERN_C_P (newdecl)
 				       || !DECL_FUNCTION_VERSIONED (olddecl))))
 	return 0;
 }
 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
 {
+if (!template_heads_equivalent_p (newdecl, olddecl))
+	return 0;
 tree oldres = DECL_TEMPLATE_RESULT (olddecl);
 tree newres = DECL_TEMPLATE_RESULT (newdecl);
 if (TREE_CODE (newres) != TREE_CODE (oldres))
 	return 0;
-if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
+/* Two template types match if they are the same. Otherwise, compare
-				DECL_TEMPLATE_PARMS (olddecl)))
+the underlying declarations.  */
-	return 0;
+if (TREE_CODE (newres) == TYPE_DECL)
+types_match = same_type_p (TREE_TYPE (newres), TREE_TYPE (oldres));
-if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
-	types_match = (same_type_p (TREE_TYPE (oldres), TREE_TYPE (newres))
-		       && equivalently_constrained (olddecl, newdecl));
 else
-	// We don't need to check equivalently_constrained for variable and
+	types_match = decls_match (newres, oldres);
-	// function templates because we check it on the results.
-	types_match = decls_match (oldres, newres);
 }
 else
 {
 /* Need to check scope for variable declaration (VAR_DECL).
 	 For typedef (TYPE_DECL), scope is ignored.  */
 else
 	types_match = comptypes (TREE_TYPE (newdecl),
 				 TREE_TYPE (olddecl),
 				 COMPARE_REDECLARATION);
 }
-// Normal functions can be constrained, as can variable partial
-// specializations.
-if (types_match && VAR_OR_FUNCTION_DECL_P (newdecl))
-types_match = equivalently_constrained (newdecl, olddecl);
 return types_match;
 }
 /* NEWDECL and OLDDECL have identical signatures.  If they are
 if (!VAR_OR_FUNCTION_DECL_P (old_decl)
 || !VAR_OR_FUNCTION_DECL_P (new_decl))
 return true;
 if (DECL_DECLARED_CONSTEXPR_P (old_decl)
 == DECL_DECLARED_CONSTEXPR_P (new_decl))
-return true;
+{
+if (TREE_CODE (old_decl) != FUNCTION_DECL)
+	return true;
+if (DECL_IMMEDIATE_FUNCTION_P (old_decl)
+	  == DECL_IMMEDIATE_FUNCTION_P (new_decl))
+	return true;
+}
 if (TREE_CODE (old_decl) == FUNCTION_DECL)
 {
 if (fndecl_built_in_p (old_decl))
 	{
 	  /* Hide a built-in declaration.  */
 	  DECL_DECLARED_CONSTEXPR_P (old_decl)
 	    = DECL_DECLARED_CONSTEXPR_P (new_decl);
+	  if (DECL_IMMEDIATE_FUNCTION_P (new_decl))
+	    SET_DECL_IMMEDIATE_FUNCTION_P (old_decl);
 	  return true;
 	}
 /* 7.1.5 [dcl.constexpr]
 	 Note: An explicit specialization can differ from the template
 	 declaration with respect to the constexpr specifier.  */
 if (! DECL_TEMPLATE_SPECIALIZATION (old_decl)
 	  && DECL_TEMPLATE_SPECIALIZATION (new_decl))
 	return true;
+const char *kind = "constexpr";
+if (DECL_IMMEDIATE_FUNCTION_P (old_decl)
+	  || DECL_IMMEDIATE_FUNCTION_P (new_decl))
+	kind = "consteval";
 error_at (DECL_SOURCE_LOCATION (new_decl),
-		"redeclaration %qD differs in %<constexpr%> "
+		"redeclaration %qD differs in %qs "
-		"from previous declaration", new_decl);
+		"from previous declaration", new_decl,
+		kind);
 inform (DECL_SOURCE_LOCATION (old_decl),
 	      "previous declaration %qD", old_decl);
 return false;
 }
 return true;
 	|| (DECL_FRIEND_P (newdecl) && TREE_PURPOSE (t2)))
 {
 	auto_diagnostic_group d;
 	if (permerror (DECL_SOURCE_LOCATION (newdecl),
 		       "friend declaration of %q#D specifies default "
-		       "arguments and isn't the only declaration", newdecl))
+		       "arguments and isn%'t the only declaration", newdecl))
 	  inform (DECL_SOURCE_LOCATION (olddecl),
 		  "previous declaration of %q#D", olddecl);
 	return;
 }
 }
 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn)			\
 			  && lookup_attribute ("gnu_inline",		\
 					       DECL_ATTRIBUTES (fn)))
+/* A subroutine of duplicate_decls. Emits a diagnostic when newdecl
+ambiguates olddecl.  Returns true if an error occurs.  */
+static bool
+duplicate_function_template_decls (tree newdecl, tree olddecl)
+{
+tree newres = DECL_TEMPLATE_RESULT (newdecl);
+tree oldres = DECL_TEMPLATE_RESULT (olddecl);
+/* Function template declarations can be differentiated by parameter
+and return type.  */
+if (compparms (TYPE_ARG_TYPES (TREE_TYPE (oldres)),
+		 TYPE_ARG_TYPES (TREE_TYPE (newres)))
+&& same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
+		       TREE_TYPE (TREE_TYPE (olddecl))))
+{
+/* ... and also by their template-heads and requires-clauses.  */
+if (template_heads_equivalent_p (newdecl, olddecl)
+	  && function_requirements_equivalent_p (newres, oldres))
+	{
+	  error ("ambiguating new declaration %q+#D", newdecl);
+	  inform (DECL_SOURCE_LOCATION (olddecl),
+		  "old declaration %q#D", olddecl);
+	  return true;
+	}
+/* FIXME: The types are the same but the are differences
+	 in either the template heads or function requirements.
+	 We should be able to diagnose a set of common errors
+	 stemming from these declarations. For example:
+	   template<typename T> requires C void f(...);
+	   template<typename T> void f(...) requires C;
+	 These are functionally equivalent but not equivalent.  */
+}
+return false;
+}
 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
 If the redeclaration is invalid, a diagnostic is issued, and the
 error_mark_node is returned.  Otherwise, OLDDECL is returned.
 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
 it is rather pointless to harass the user with yet more error message
 about the same declaration, so just pretend the types match here.  */
 if (TREE_TYPE (newdecl) == error_mark_node
 || TREE_TYPE (olddecl) == error_mark_node)
 return error_mark_node;
-if (DECL_NAME (newdecl)
-&& DECL_NAME (olddecl)
-&& UDLIT_OPER_P (DECL_NAME (newdecl))
-&& UDLIT_OPER_P (DECL_NAME (olddecl)))
-{
-if (TREE_CODE (newdecl) == TEMPLATE_DECL
-	  && TREE_CODE (olddecl) != TEMPLATE_DECL
-	  && check_raw_literal_operator (olddecl))
-	error_at (newdecl_loc,
-		  "literal operator template %qD conflicts with"
-		  " raw literal operator %qD", newdecl, olddecl);
-else if (TREE_CODE (newdecl) != TEMPLATE_DECL
-	       && TREE_CODE (olddecl) == TEMPLATE_DECL
-	       && check_raw_literal_operator (newdecl))
-	error_at (newdecl_loc,
-		  "raw literal operator %qD conflicts with"
-		  " literal operator template %qD", newdecl, olddecl);
-}
-/* True to merge attributes between the declarations, false to
-set OLDDECL's attributes to those of NEWDECL (for template
-explicit specializations that specify their own attributes
-independent of those specified for the primary template).  */
-const bool merge_attr = (TREE_CODE (newdecl) != FUNCTION_DECL
-			   || !DECL_TEMPLATE_SPECIALIZATION (newdecl)
-			   || DECL_TEMPLATE_SPECIALIZATION (olddecl));
-if (DECL_P (olddecl)
-&& TREE_CODE (newdecl) == FUNCTION_DECL
-&& TREE_CODE (olddecl) == FUNCTION_DECL
-&& merge_attr
-&& diagnose_mismatched_attributes (olddecl, newdecl))
-{
-if (DECL_INITIAL (olddecl))
-	inform (olddecl_loc,
-		"previous definition of %qD was here", olddecl);
-else
-	inform (olddecl_loc,
-		"previous declaration of %qD was here", olddecl);
-}
 /* Check for redeclaration and other discrepancies.  */
 if (TREE_CODE (olddecl) == FUNCTION_DECL
 && DECL_ARTIFICIAL (olddecl))
 {
 			goto next_arg;
 		      }
 		  if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
 		    break;
-next_arg:;
+		next_arg:;
 		}
 	      warning_at (newdecl_loc,
 			  OPT_Wbuiltin_declaration_mismatch,
 			  "declaration of %q#D conflicts with built-in "
 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
 {
 /* C++ Standard, 3.3, clause 4:
 	 "[Note: a namespace name or a class template name must be unique
 	 in its declarative region (7.3.2, clause 14). ]"  */
-if (TREE_CODE (olddecl) != NAMESPACE_DECL
+if (TREE_CODE (olddecl) == NAMESPACE_DECL
-	  && TREE_CODE (newdecl) != NAMESPACE_DECL
+	  || TREE_CODE (newdecl) == NAMESPACE_DECL)
-	  && (TREE_CODE (olddecl) != TEMPLATE_DECL
+	/* Namespace conflicts with not namespace.  */;
-	      || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) != TYPE_DECL)
+else if (DECL_TYPE_TEMPLATE_P (olddecl)
-	  && (TREE_CODE (newdecl) != TEMPLATE_DECL
+	       || DECL_TYPE_TEMPLATE_P (newdecl))
-	      || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != TYPE_DECL))
+	/* Class template conflicts.  */;
-	{
+else if ((TREE_CODE (newdecl) == FUNCTION_DECL
-	  if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
+		&& DECL_FUNCTION_TEMPLATE_P (olddecl))
-	       && TREE_CODE (newdecl) != TYPE_DECL)
+	       || (TREE_CODE (olddecl) == FUNCTION_DECL
-	      || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
+		   && DECL_FUNCTION_TEMPLATE_P (newdecl)))
-		  && TREE_CODE (olddecl) != TYPE_DECL))
+	{
-	    {
+	  /* One is a function and the other is a template
-	      /* We do nothing special here, because C++ does such nasty
+	     function.  */
-		 things with TYPE_DECLs.  Instead, just let the TYPE_DECL
+	  if (!UDLIT_OPER_P (DECL_NAME (newdecl)))
-		 get shadowed, and know that if we need to find a TYPE_DECL
+	    return NULL_TREE;
-		 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
-		 slot of the identifier.  */
+	  /* There can only be one!  */
-	      return NULL_TREE;
+	  if (TREE_CODE (newdecl) == TEMPLATE_DECL
-	    }
+	      && check_raw_literal_operator (olddecl))
+	    error_at (newdecl_loc,
-	    if ((TREE_CODE (newdecl) == FUNCTION_DECL
+		      "literal operator %q#D conflicts with"
-		 && DECL_FUNCTION_TEMPLATE_P (olddecl))
+		      " raw literal operator", newdecl);
-		|| (TREE_CODE (olddecl) == FUNCTION_DECL
+	  else if (check_raw_literal_operator (newdecl))
-		    && DECL_FUNCTION_TEMPLATE_P (newdecl)))
+	    error_at (newdecl_loc,
-	      return NULL_TREE;
+		      "raw literal operator %q#D conflicts with"
-	}
+		      " literal operator template", newdecl);
+	  else
-error ("%q#D redeclared as different kind of symbol", newdecl);
+	    return NULL_TREE;
-if (TREE_CODE (olddecl) == TREE_LIST)
-	olddecl = TREE_VALUE (olddecl);
+	  inform (olddecl_loc, "previous declaration %q#D", olddecl);
-inform (olddecl_loc,
+	  return error_mark_node;
-	      "previous declaration %q#D", olddecl);
+	}
+else if (DECL_IMPLICIT_TYPEDEF_P (olddecl)
+	       || DECL_IMPLICIT_TYPEDEF_P (newdecl))
+	/* One is an implicit typedef, that's ok.  */
+	return NULL_TREE;
+error ("%q#D redeclared as different kind of entity", newdecl);
+inform (olddecl_loc, "previous declaration %q#D", olddecl);
 return error_mark_node;
 }
 else if (!types_match)
 {
 	   from different scopes.  */
 	return NULL_TREE;
 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
 	{
+	  tree oldres = DECL_TEMPLATE_RESULT (olddecl);
+	  tree newres = DECL_TEMPLATE_RESULT (newdecl);
 	  /* The name of a class template may not be declared to refer to
 	     any other template, class, function, object, namespace, value,
 	     or type in the same scope.  */
-	  if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
+	  if (TREE_CODE (oldres) == TYPE_DECL
-	      || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
+	      || TREE_CODE (newres) == TYPE_DECL)
 	    {
 	      error_at (newdecl_loc,
 			"conflicting declaration of template %q#D", newdecl);
 	      inform (olddecl_loc,
 		      "previous declaration %q#D", olddecl);
 	      return error_mark_node;
 	    }
-	  else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
-		   && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
+	  else if (TREE_CODE (oldres) == FUNCTION_DECL
-		   && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
+		   && TREE_CODE (newres) == FUNCTION_DECL)
-				 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
-		   && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
-					   DECL_TEMPLATE_PARMS (olddecl))
-		   /* Template functions can be disambiguated by
-		      return type.  */
-		   && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
-				   TREE_TYPE (TREE_TYPE (olddecl)))
-// Template functions can also be disambiguated by
-// constraints.
-&& equivalently_constrained (olddecl, newdecl))
 	    {
-	      error_at (newdecl_loc, "ambiguating new declaration %q#D",
+	      if (duplicate_function_template_decls (newdecl, olddecl))
-			newdecl);
+		return error_mark_node;
-	      inform (olddecl_loc,
+	      return NULL_TREE;
-		      "old declaration %q#D", olddecl);
 	    }
 else if (check_concept_refinement (olddecl, newdecl))
 	    return error_mark_node;
 	  return NULL_TREE;
 	}
 if (TREE_CODE (olddecl) == TYPE_DECL
 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
 	  || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
 return NULL_TREE;
+if (!validate_constexpr_redeclaration (olddecl, newdecl))
+return error_mark_node;
+/* We have committed to returning OLDDECL at this point.  */
 /* If new decl is `static' and an `extern' was seen previously,
 warn about it.  */
 warn_extern_redeclared_static (newdecl, olddecl);
-if (!validate_constexpr_redeclaration (olddecl, newdecl))
+/* True to merge attributes between the declarations, false to
-return error_mark_node;
+set OLDDECL's attributes to those of NEWDECL (for template
+explicit specializations that specify their own attributes
-/* We have committed to returning 1 at this point.  */
+independent of those specified for the primary template).  */
+const bool merge_attr = (TREE_CODE (newdecl) != FUNCTION_DECL
+			   || !DECL_TEMPLATE_SPECIALIZATION (newdecl)
+			   || DECL_TEMPLATE_SPECIALIZATION (olddecl));
 if (TREE_CODE (newdecl) == FUNCTION_DECL)
 {
+if (merge_attr)
+	{
+	  if (diagnose_mismatched_attributes (olddecl, newdecl))
+	    inform (olddecl_loc, DECL_INITIAL (olddecl)
+		    ? G_("previous definition of %qD here")
+		    : G_("previous declaration of %qD here"), olddecl);
+	  /* [dcl.attr.noreturn]: The first declaration of a function shall
+	     specify the noreturn attribute if any declaration of that function
+	     specifies the noreturn attribute.  */
+	  tree a;
+	  if (TREE_THIS_VOLATILE (newdecl)
+	      && !TREE_THIS_VOLATILE (olddecl)
+	      /* This applies to [[noreturn]] only, not its GNU variants.  */
+	      && (a = lookup_attribute ("noreturn", DECL_ATTRIBUTES (newdecl)))
+	      && cxx11_attribute_p (a)
+	      && get_attribute_namespace (a) == NULL_TREE)
+	    {
+	      error_at (newdecl_loc, "function %qD declared %<[[noreturn]]%> "
+			"but its first declaration was not", newdecl);
+	      inform (olddecl_loc, "previous declaration of %qD", olddecl);
+	    }
+	}
 /* Now that functions must hold information normally held
 	 by field decls, there is extra work to do so that
 	 declaration information does not get destroyed during
 	 definition.  */
 if (DECL_VINDEX (olddecl))
 DECL_ATTRIBUTES (newdecl)
 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
 else
 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
-if (DECL_DECLARES_FUNCTION_P (olddecl) && DECL_DECLARES_FUNCTION_P (newdecl))
+if (DECL_DECLARES_FUNCTION_P (olddecl))
 {
 olddecl_friend = DECL_FRIEND_P (olddecl);
 olddecl_hidden_friend = DECL_HIDDEN_FRIEND_P (olddecl);
 hidden_friend = (DECL_ANTICIPATED (olddecl)
 		       && DECL_HIDDEN_FRIEND_P (olddecl)
 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
 {
 tree old_result = DECL_TEMPLATE_RESULT (olddecl);
 tree new_result = DECL_TEMPLATE_RESULT (newdecl);
 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
-DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
-	= chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
+/* The new decl should not already have gathered any
-		   DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
+	 specializations.  */
+gcc_assert (!DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
 DECL_ATTRIBUTES (old_result)
 	= (*targetm.merge_decl_attributes) (old_result, new_result);
 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
 	  /* And remove the new type from the variants list.  */
 	  if (TYPE_NAME (TREE_TYPE (newdecl)) == newdecl)
 	    {
 	      tree remove = TREE_TYPE (newdecl);
-	      for (tree t = TYPE_MAIN_VARIANT (remove); ;
+	      if (TYPE_MAIN_VARIANT (remove) == remove)
-		   t = TYPE_NEXT_VARIANT (t))
+		{
-		if (TYPE_NEXT_VARIANT (t) == remove)
+		  gcc_assert (TYPE_NEXT_VARIANT (remove) == NULL_TREE);
-		  {
+		  /* If remove is the main variant, no need to remove that
-		    TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (remove);
+		     from the list.  One of the DECL_ORIGINAL_TYPE
-		    break;
+		     variants, e.g. created for aligned attribute, might still
-		  }
+		     refer to the newdecl TYPE_DECL though, so remove that one
+		     in that case.  */
+		  if (tree orig = DECL_ORIGINAL_TYPE (newdecl))
+		    if (orig != remove)
+		      for (tree t = TYPE_MAIN_VARIANT (orig); t;
+			   t = TYPE_MAIN_VARIANT (t))
+			if (TYPE_NAME (TYPE_NEXT_VARIANT (t)) == newdecl)
+			  {
+			    TYPE_NEXT_VARIANT (t)
+			      = TYPE_NEXT_VARIANT (TYPE_NEXT_VARIANT (t));
+			    break;
+			  }
+		}
+	      else
+		for (tree t = TYPE_MAIN_VARIANT (remove); ;
+		     t = TYPE_NEXT_VARIANT (t))
+		  if (TYPE_NEXT_VARIANT (t) == remove)
+		    {
+		      TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (remove);
+		      break;
+		    }
 	    }
 	}
 else if (merge_attr)
 	newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
 else
 	    |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
 	  if (DECL_DEPENDENT_INIT_P (olddecl))
 	    SET_DECL_DEPENDENT_INIT_P (newdecl, true);
 	  DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
 	    |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
-if (DECL_CLASS_SCOPE_P (olddecl))
+	  DECL_DECLARED_CONSTEXPR_P (newdecl)
-DECL_DECLARED_CONSTEXPR_P (newdecl)
+	    |= DECL_DECLARED_CONSTEXPR_P (olddecl);
-	      |= DECL_DECLARED_CONSTEXPR_P (olddecl);
 	  /* Merge the threadprivate attribute from OLDDECL into NEWDECL.  */
 	  if (DECL_LANG_SPECIFIC (olddecl)
 	      && CP_DECL_THREADPRIVATE_P (olddecl))
 	    {
 if (TREE_CODE (newdecl) == FUNCTION_DECL)
 	{
 	  DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
 	    |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
 	  DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
-	  DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
+	  if (DECL_IS_OPERATOR_NEW_P (olddecl))
+	    DECL_SET_IS_OPERATOR_NEW (newdecl, true);
 	  DECL_LOOPING_CONST_OR_PURE_P (newdecl)
 	    |= DECL_LOOPING_CONST_OR_PURE_P (olddecl);
 	  if (merge_attr)
 	    merge_attribute_bits (newdecl, olddecl);
 	DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
 /* Don't really know how much of the language-specific
 	 values we should copy from old to new.  */
 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
-DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
 DECL_INITIALIZED_IN_CLASS_P (newdecl)
 	|= DECL_INITIALIZED_IN_CLASS_P (olddecl);
 if (LANG_DECL_HAS_MIN (newdecl))
 	{
-	  DECL_LANG_SPECIFIC (newdecl)->u.min.u2 =
+	  DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
-	    DECL_LANG_SPECIFIC (olddecl)->u.min.u2;
 	  if (DECL_TEMPLATE_INFO (newdecl))
 	    {
 	      new_template_info = DECL_TEMPLATE_INFO (newdecl);
 	      if (DECL_TEMPLATE_INSTANTIATION (olddecl)
 		  && DECL_TEMPLATE_SPECIALIZATION (newdecl))
 		TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (olddecl))
 		  = TINFO_USED_TEMPLATE_ID (new_template_info);
 	    }
 	  DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
 	}
-/* Only functions have these fields.  */
 if (DECL_DECLARES_FUNCTION_P (newdecl))
 	{
+	  /* Only functions have these fields.  */
 	  DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
 	  DECL_BEFRIENDING_CLASSES (newdecl)
 	    = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
 		       DECL_BEFRIENDING_CLASSES (olddecl));
 	  /* DECL_THUNKS is only valid for virtual functions,
 	     otherwise it is a DECL_FRIEND_CONTEXT.  */
 	  if (DECL_VIRTUAL_P (newdecl))
 	    SET_DECL_THUNKS (newdecl, DECL_THUNKS (olddecl));
 	}
-/* Only variables have this field.  */
+else if (VAR_P (newdecl))
-else if (VAR_P (newdecl)
+	{
-	       && VAR_HAD_UNKNOWN_BOUND (olddecl))
+	  /* Only variables have this field.  */
-	SET_VAR_HAD_UNKNOWN_BOUND (newdecl);
+	  if (VAR_HAD_UNKNOWN_BOUND (olddecl))
+	    SET_VAR_HAD_UNKNOWN_BOUND (newdecl);
+	}
 }
 if (TREE_CODE (newdecl) == FUNCTION_DECL)
 {
 tree parm;
 /* Merge parameter attributes. */
 tree oldarg, newarg;
-for (oldarg = DECL_ARGUMENTS(olddecl),
+for (oldarg = DECL_ARGUMENTS(olddecl),  newarg = DECL_ARGUMENTS(newdecl);
-newarg = DECL_ARGUMENTS(newdecl);
 oldarg && newarg;
-oldarg = DECL_CHAIN(oldarg), newarg = DECL_CHAIN(newarg)) {
+oldarg = DECL_CHAIN(oldarg), newarg = DECL_CHAIN(newarg))
+	{
 DECL_ATTRIBUTES (newarg)
-= (*targetm.merge_decl_attributes) (oldarg, newarg);
+	    = (*targetm.merge_decl_attributes) (oldarg, newarg);
 DECL_ATTRIBUTES (oldarg) = DECL_ATTRIBUTES (newarg);
-}
+	}
 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
 	  && !DECL_TEMPLATE_INSTANTIATION (newdecl))
 	{
 	  /* If newdecl is not a specialization, then it is not a
 	     template-related function at all.  And that means that we
 	      DECL_PENDING_INLINE_INFO (newdecl)
 		= DECL_PENDING_INLINE_INFO (olddecl);
 	    }
 	  else if (DECL_PENDING_INLINE_P (newdecl))
 	    ;
-	  else if (DECL_SAVED_FUNCTION_DATA (newdecl) == NULL)
+	  else if (DECL_SAVED_AUTO_RETURN_TYPE (newdecl) == NULL)
-	    DECL_SAVED_FUNCTION_DATA (newdecl)
+	    DECL_SAVED_AUTO_RETURN_TYPE (newdecl)
-	      = DECL_SAVED_FUNCTION_DATA (olddecl);
+	      = DECL_SAVED_AUTO_RETURN_TYPE (olddecl);
 	  DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
 	  DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
 	    = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
 	 if newdecl is a gnu_inline definition, or if newdecl is just
 	 a declaration.  */
 if (fndecl_built_in_p (olddecl)
 	  && (new_defines_function ? GNU_INLINE_P (newdecl) : types_match))
 	{
-	  DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
+	  copy_decl_built_in_function (newdecl, olddecl);
-	  DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
 	  /* If we're keeping the built-in definition, keep the rtl,
 	     regardless of declaration matches.  */
 	  COPY_DECL_RTL (olddecl, newdecl);
 	  if (DECL_BUILT_IN_CLASS (newdecl) == BUILT_IN_NORMAL)
 	    {
 		default:
 		  if (builtin_decl_explicit_p (fncode))
 		    set_builtin_decl_declared_p (fncode, true);
 		  break;
 		}
+	      copy_attributes_to_builtin (newdecl);
 	    }
-	  copy_attributes_to_builtin (newdecl);
 	}
 if (new_defines_function)
 	/* If defining a function declared with other language
 	   linkage, use the previously declared language linkage.  */
 	SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
 }
 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
 {
 tree nt, ot;
-if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
+if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == CONCEPT_DECL)
-	{
+return G_("redefinition of %q#D");
-	  if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
-	      && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
+if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL)
-	    return G_("redefinition of %q#D");
+	return redeclaration_error_message (DECL_TEMPLATE_RESULT (newdecl),
-	  return NULL;
+					    DECL_TEMPLATE_RESULT (olddecl));
-	}
+if (DECL_TEMPLATE_RESULT (newdecl) == DECL_TEMPLATE_RESULT (olddecl))
-if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
-	  || (DECL_TEMPLATE_RESULT (newdecl)
-	      == DECL_TEMPLATE_RESULT (olddecl)))
 	return NULL;
 nt = DECL_TEMPLATE_RESULT (newdecl);
 if (DECL_TEMPLATE_INFO (nt))
 	nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
 location_t loc = input_location;
 switch (b->kind)
 	{
 	case sk_try:
 	  if (!saw_eh)
-	    inf = N_("enters try block");
+	    inf = G_("  enters %<try%> block");
 	  saw_eh = true;
 	  break;
 	case sk_catch:
 	  if (!saw_eh)
-	    inf = N_("enters catch block");
+	    inf = G_("  enters %<catch%> block");
 	  saw_eh = true;
 	  break;
 	case sk_omp:
 	  if (!saw_omp)
-	    inf = N_("enters OpenMP structured block");
+	    inf = G_("  enters OpenMP structured block");
 	  saw_omp = true;
 	  break;
 	case sk_transaction:
 	  if (!saw_tm)
-	    inf = N_("enters synchronized or atomic statement");
+	    inf = G_("  enters synchronized or atomic statement");
 	  saw_tm = true;
 	  break;
 	case sk_block:
 	  if (!saw_cxif && level_for_constexpr_if (b->level_chain))
 	    {
-	      inf = N_("enters constexpr if statement");
+	      inf = G_("  enters %<constexpr if%> statement");
 	      loc = EXPR_LOCATION (b->level_chain->this_entity);
 	      saw_cxif = true;
 	    }
 	  break;
 	{
 	  if (identified < 2)
 	    complained = identify_goto (decl, input_location, locus, DK_ERROR);
 	  identified = 2;
 	  if (complained)
-	    inform (loc, "  %s", inf);
+	    inform (loc, inf);
 	}
 }
 return !identified;
 }
 	      complained = identify_goto (decl, DECL_SOURCE_LOCATION (decl),
 					  &input_location, DK_ERROR);
 	      identified = 2;
 	    }
 	  if (complained)
-	    inform (DECL_SOURCE_LOCATION (bad), "  enters catch block");
+	    inform (DECL_SOURCE_LOCATION (bad), "  enters %<catch%> block");
 	  saw_catch = true;
 	}
 else if (complained)
 	{
 	  if (u > 1)
 }
 if (complained)
 {
 if (ent->in_try_scope)
-	inform (input_location, "  enters try block");
+	inform (input_location, "  enters %<try%> block");
 else if (ent->in_catch_scope && !saw_catch)
-	inform (input_location, "  enters catch block");
+	inform (input_location, "  enters %<catch%> block");
 else if (ent->in_transaction_scope)
 	inform (input_location, "  enters synchronized or atomic statement");
 else if (ent->in_constexpr_if)
-	inform (input_location, "  enters %<constexpr%> if statement");
+	inform (input_location, "  enters %<constexpr if%> statement");
 }
 if (ent->in_omp_scope)
 {
 if (complained)
 element, or NULL_TREE if there is no high element.  Used to
 determine whether or not a new case label duplicates an old case
 label.  We need a tree, rather than simply a hash table, because
 of the GNU case range extension.  */
 splay_tree cases;
-/* Remember whether there was a case value that is outside the
-range of the original type of the controlling expression.  */
-bool outside_range_p;
 /* Remember whether a default: case label has been seen.  */
 bool has_default_p;
 /* Remember whether a BREAK_STMT has been seen in this SWITCH_STMT.  */
 bool break_stmt_seen_p;
 /* Set if inside of {FOR,DO,WHILE}_BODY nested inside of a switch,
 struct cp_switch *p = XNEW (struct cp_switch);
 p->level = current_binding_level;
 p->next = switch_stack;
 p->switch_stmt = switch_stmt;
 p->cases = splay_tree_new (case_compare, NULL, NULL);
-p->outside_range_p = false;
 p->has_default_p = false;
 p->break_stmt_seen_p = false;
 p->in_loop_body_p = false;
 switch_stack = p;
 }
 {
 struct cp_switch *cs = switch_stack;
 location_t switch_location;
 /* Emit warnings as needed.  */
-switch_location = cp_expr_loc_or_loc (cs->switch_stmt, input_location);
+switch_location = cp_expr_loc_or_input_loc (cs->switch_stmt);
 const bool bool_cond_p
 = (SWITCH_STMT_TYPE (cs->switch_stmt)
 && TREE_CODE (SWITCH_STMT_TYPE (cs->switch_stmt)) == BOOLEAN_TYPE);
 if (!processing_template_decl)
 c_do_switch_warnings (cs->cases, switch_location,
 			  SWITCH_STMT_TYPE (cs->switch_stmt),
-			  SWITCH_STMT_COND (cs->switch_stmt),
+			  SWITCH_STMT_COND (cs->switch_stmt), bool_cond_p);
-			  bool_cond_p, cs->outside_range_p);
 /* For the benefit of block_may_fallthru remember if the switch body
 case labels cover all possible values and if there are break; stmts.  */
 if (cs->has_default_p
 || (!processing_template_decl
 if (value == NULL_TREE)
 return value;
 value = mark_rvalue_use (value);
+if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
+type = type_promotes_to (type);
+tree ovalue = value;
+/* The constant-expression VALUE shall be a converted constant expression
+of the adjusted type of the switch condition, which doesn't allow
+narrowing conversions.  */
+value = build_converted_constant_expr (type, value, tf_warning_or_error);
 if (cxx_dialect >= cxx11
 && (SCOPED_ENUM_P (type)
-	  || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value))))
+	  || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (ovalue))))
-{
+/* Use the converted value.  */;
-if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
+else
-	type = type_promotes_to (type);
+/* The already integral case.  */
-value = (perform_implicit_conversion_flags
+value = ovalue;
-	       (type, value, tf_warning_or_error,
-		LOOKUP_IMPLICIT | LOOKUP_NO_NON_INTEGRAL));
-}
 return cxx_constant_value (value);
 }
 /* Note that we've seen a definition of a case label, and complain if this
 is a bad place for one.  */
 {
 tree label;
 /* For templates, just add the case label; we'll do semantic
 	 analysis at instantiation-time.  */
-label = build_decl (loc, LABEL_DECL, NULL_TREE, NULL_TREE);
+label = build_decl (loc, LABEL_DECL, NULL_TREE, void_type_node);
 return add_stmt (build_case_label (low_value, high_value, label));
 }
 /* Find the condition on which this switch statement depends.  */
 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
 return error_mark_node;
 low_value = case_conversion (type, low_value);
 high_value = case_conversion (type, high_value);
-r = c_add_case_label (loc, switch_stack->cases, cond, type,
+r = c_add_case_label (loc, switch_stack->cases, cond, low_value, high_value);
-			low_value, high_value,
-			&switch_stack->outside_range_p);
 /* After labels, make any new cleanups in the function go into their
 own new (temporary) binding contour.  */
 for (p = current_binding_level;
 p->kind != sk_function_parms;
 return error_mark_node;
 }
 gcc_assert (identifier_p (name));
 gcc_assert (TYPE_P (context));
-if (!MAYBE_CLASS_TYPE_P (context))
+if (TREE_CODE (context) == TYPE_PACK_EXPANSION)
+/* This can happen for C++17 variadic using (c++/88986).  */;
+else if (!MAYBE_CLASS_TYPE_P (context))
 {
 if (complain & tf_error)
 	error ("%q#T is not a class", context);
 return error_mark_node;
 }
 {"__delta", &delta_identifier, cik_normal},
 {"__pfn", &pfn_identifier, cik_normal},
 {"_vptr", &vptr_identifier, cik_normal},
 {"__vtt_parm", &vtt_parm_identifier, cik_normal},
 {"::", &global_identifier, cik_normal},
-{"std", &std_identifier, cik_normal},
 /* The demangler expects anonymous namespaces to be called
 	 something starting with '_GLOBAL__N_'.  It no longer needs
 	 to be unique to the TU.  */
 {"_GLOBAL__N_1", &anon_identifier, cik_normal},
 {"auto", &auto_identifier, cik_normal},
 {"tuple_size", &tuple_size_identifier, cik_normal},
 {"type", &type_identifier, cik_normal},
 {"value", &value_identifier, cik_normal},
 {"_FUN", &fun_identifier, cik_normal},
 {"__closure", &closure_identifier, cik_normal},
+{"heap uninit", &heap_uninit_identifier, cik_normal},
+{"heap ", &heap_identifier, cik_normal},
+{"heap deleted", &heap_deleted_identifier, cik_normal},
 {NULL, NULL, cik_normal}
 };
 for (const predefined_identifier *pid = predefined_identifiers;
 pid->name; ++pid)
 /* Initially, C.  */
 current_lang_name = lang_name_c;
 /* Create the `std' namespace.  */
-push_namespace (std_identifier);
+push_namespace (get_identifier ("std"));
 std_node = current_namespace;
 pop_namespace ();
 flag_noexcept_type = (cxx_dialect >= cxx17);
 tree bool_ftype = build_function_type_list (boolean_type_node, NULL_TREE);
 tree decl
 = add_builtin_function ("__builtin_is_constant_evaluated",
 			    bool_ftype, CP_BUILT_IN_IS_CONSTANT_EVALUATED,
 			    BUILT_IN_FRONTEND, NULL, NULL_TREE);
+set_call_expr_flags (decl, ECF_CONST | ECF_NOTHROW | ECF_LEAF);
+tree cptr_ftype = build_function_type_list (const_ptr_type_node, NULL_TREE);
+decl = add_builtin_function ("__builtin_source_location",
+			       cptr_ftype, CP_BUILT_IN_SOURCE_LOCATION,
+			       BUILT_IN_FRONTEND, NULL, NULL_TREE);
 set_call_expr_flags (decl, ECF_CONST | ECF_NOTHROW | ECF_LEAF);
 integer_two_node = build_int_cst (NULL_TREE, 2);
 /* Guess at the initial static decls size.  */
 current_lang_name = lang_name_cplusplus;
 if (aligned_new_threshold > 1
 && !pow2p_hwi (aligned_new_threshold))
 {
-error ("-faligned-new=%d is not a power of two", aligned_new_threshold);
+error ("%<-faligned-new=%d%> is not a power of two",
+	     aligned_new_threshold);
 aligned_new_threshold = 1;
 }
 if (aligned_new_threshold == -1)
 aligned_new_threshold = (cxx_dialect >= cxx17) ? 1 : 0;
 if (aligned_new_threshold == 1)
 {
 	tree bad_alloc_id;
 	tree bad_alloc_type_node;
 	tree bad_alloc_decl;
-	push_namespace (std_identifier);
+	push_nested_namespace (std_node);
 	bad_alloc_id = get_identifier ("bad_alloc");
 	bad_alloc_type_node = make_class_type (RECORD_TYPE);
 	TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
 	bad_alloc_decl
 	  = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
 	DECL_CONTEXT (bad_alloc_decl) = current_namespace;
-	pop_namespace ();
+	pop_nested_namespace (std_node);
 	new_eh_spec
 	  = add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1);
 }
 else
 new_eh_spec = noexcept_false_spec;
 /* Ensure attribs.c is initialized.  */
 init_attributes ();
-/* Ensure constraint.cc is initialized. */
-init_constraint_processing ();
 extvisattr = build_tree_list (get_identifier ("externally_visible"),
 				  NULL_TREE);
 newattrs = tree_cons (get_identifier ("alloc_size"),
 			  build_tree_list (NULL_TREE, integer_one_node),
 newtype = build_exception_variant (newtype, new_eh_spec);
 deltype = cp_build_type_attribute_variant (void_ftype_ptr, extvisattr);
 deltype = build_exception_variant (deltype, empty_except_spec);
 tree opnew = push_cp_library_fn (NEW_EXPR, newtype, 0);
 DECL_IS_MALLOC (opnew) = 1;
-DECL_IS_OPERATOR_NEW (opnew) = 1;
+DECL_SET_IS_OPERATOR_NEW (opnew, true);
 opnew = push_cp_library_fn (VEC_NEW_EXPR, newtype, 0);
 DECL_IS_MALLOC (opnew) = 1;
-DECL_IS_OPERATOR_NEW (opnew) = 1;
+DECL_SET_IS_OPERATOR_NEW (opnew, true);
-push_cp_library_fn (DELETE_EXPR, deltype, ECF_NOTHROW);
+tree opdel = push_cp_library_fn (DELETE_EXPR, deltype, ECF_NOTHROW);
-push_cp_library_fn (VEC_DELETE_EXPR, deltype, ECF_NOTHROW);
+DECL_SET_IS_OPERATOR_DELETE (opdel, true);
+opdel = push_cp_library_fn (VEC_DELETE_EXPR, deltype, ECF_NOTHROW);
+DECL_SET_IS_OPERATOR_DELETE (opdel, true);
 if (flag_sized_deallocation)
 {
 	/* Also push the sized deallocation variants:
 	     void operator delete(void*, std::size_t) throw();
 	     void operator delete[](void*, std::size_t) throw();  */
 	  = build_function_type_list (void_type_node, ptr_type_node,
 				      size_type_node, NULL_TREE);
 	deltype = cp_build_type_attribute_variant (void_ftype_ptr_size,
 						   extvisattr);
 	deltype = build_exception_variant (deltype, empty_except_spec);
-	push_cp_library_fn (DELETE_EXPR, deltype, ECF_NOTHROW);
+	opdel = push_cp_library_fn (DELETE_EXPR, deltype, ECF_NOTHROW);
-	push_cp_library_fn (VEC_DELETE_EXPR, deltype, ECF_NOTHROW);
+	DECL_SET_IS_OPERATOR_DELETE (opdel, true);
+	opdel = push_cp_library_fn (VEC_DELETE_EXPR, deltype, ECF_NOTHROW);
+	DECL_SET_IS_OPERATOR_DELETE (opdel, true);
 }
 if (aligned_new_threshold)
 {
-	push_namespace (std_identifier);
+	push_nested_namespace (std_node);
 	tree align_id = get_identifier ("align_val_t");
 	align_type_node = start_enum (align_id, NULL_TREE, size_type_node,
 				      NULL_TREE, /*scoped*/true, NULL);
-	pop_namespace ();
+	pop_nested_namespace (std_node);
 	/* operator new (size_t, align_val_t); */
 	newtype = build_function_type_list (ptr_type_node, size_type_node,
 					    align_type_node, NULL_TREE);
 	newtype = cp_build_type_attribute_variant (newtype, newattrs);
 	newtype = build_exception_variant (newtype, new_eh_spec);
 	opnew = push_cp_library_fn (NEW_EXPR, newtype, 0);
 	DECL_IS_MALLOC (opnew) = 1;
-	DECL_IS_OPERATOR_NEW (opnew) = 1;
+	DECL_SET_IS_OPERATOR_NEW (opnew, true);
 	opnew = push_cp_library_fn (VEC_NEW_EXPR, newtype, 0);
 	DECL_IS_MALLOC (opnew) = 1;
-	DECL_IS_OPERATOR_NEW (opnew) = 1;
+	DECL_SET_IS_OPERATOR_NEW (opnew, true);
 	/* operator delete (void *, align_val_t); */
 	deltype = build_function_type_list (void_type_node, ptr_type_node,
 					    align_type_node, NULL_TREE);
 	deltype = cp_build_type_attribute_variant (deltype, extvisattr);
 	deltype = build_exception_variant (deltype, empty_except_spec);
-	push_cp_library_fn (DELETE_EXPR, deltype, ECF_NOTHROW);
+	opdel = push_cp_library_fn (DELETE_EXPR, deltype, ECF_NOTHROW);
-	push_cp_library_fn (VEC_DELETE_EXPR, deltype, ECF_NOTHROW);
+	DECL_SET_IS_OPERATOR_DELETE (opdel, true);
+	opdel = push_cp_library_fn (VEC_DELETE_EXPR, deltype, ECF_NOTHROW);
+	DECL_SET_IS_OPERATOR_DELETE (opdel, true);
 	if (flag_sized_deallocation)
 	  {
 	    /* operator delete (void *, size_t, align_val_t); */
 	    deltype = build_function_type_list (void_type_node, ptr_type_node,
 						size_type_node, align_type_node,
 						NULL_TREE);
 	    deltype = cp_build_type_attribute_variant (deltype, extvisattr);
 	    deltype = build_exception_variant (deltype, empty_except_spec);
-	    push_cp_library_fn (DELETE_EXPR, deltype, ECF_NOTHROW);
+	    opdel = push_cp_library_fn (DELETE_EXPR, deltype, ECF_NOTHROW);
-	    push_cp_library_fn (VEC_DELETE_EXPR, deltype, ECF_NOTHROW);
+	    DECL_SET_IS_OPERATOR_DELETE (opdel, true);
+	    opdel = push_cp_library_fn (VEC_DELETE_EXPR, deltype, ECF_NOTHROW);
+	    DECL_SET_IS_OPERATOR_DELETE (opdel, true);
 	  }
 }
 nullptr_type_node = make_node (NULLPTR_TYPE);
 TYPE_SIZE (nullptr_type_node) = bitsize_int (GET_MODE_BITSIZE (ptr_mode));
 at the point of first use, so we mustn't push the decl now.  */
 static tree
 cp_make_fname_decl (location_t loc, tree id, int type_dep)
 {
-const char *const name = (type_dep && processing_template_decl
+const char * name = NULL;
-			    ? NULL : fname_as_string (type_dep));
+bool release_name = false;
+if (!(type_dep && in_template_function ()))
+{
+if (current_function_decl == NULL_TREE)
+	name = "top level";
+else if (type_dep == 1) /* __PRETTY_FUNCTION__ */
+	name = cxx_printable_name (current_function_decl, 2);
+else if (type_dep == 0) /* __FUNCTION__ */
+	{
+	  name = fname_as_string (type_dep);
+	  release_name = true;
+	}
+else
+	gcc_unreachable ();
+}
 tree type;
 tree init = cp_fname_init (name, &type);
 tree decl = build_decl (loc, VAR_DECL, id, type);
-if (name)
+if (release_name)
 free (CONST_CAST (char *, name));
-TREE_STATIC (decl) = 1;
+/* As we're using pushdecl_with_scope, we must set the context.  */
+DECL_CONTEXT (decl) = current_function_decl;
 TREE_READONLY (decl) = 1;
 DECL_ARTIFICIAL (decl) = 1;
+DECL_DECLARED_CONSTEXPR_P (decl) = 1;
+TREE_STATIC (decl) = 1;
 TREE_USED (decl) = 1;
+if (init)
+{
+SET_DECL_VALUE_EXPR (decl, init);
+DECL_HAS_VALUE_EXPR_P (decl) = 1;
+/* For decl_constant_var_p.  */
+DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
+}
 if (current_function_decl)
 {
 DECL_CONTEXT (decl) = current_function_decl;
 decl = pushdecl_outermost_localscope (decl);
-cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
+if (decl != error_mark_node)
-		      LOOKUP_ONLYCONVERTING);
+	add_decl_expr (decl);
 }
 else
 {
 DECL_THIS_STATIC (decl) = true;
-pushdecl_top_level_and_finish (decl, init);
+pushdecl_top_level_and_finish (decl, NULL_TREE);
 }
 return decl;
 }
-static tree
+/* Install DECL as a builtin function at current (global) scope.
-builtin_function_1 (tree decl, tree context, bool is_global)
+Return the new decl (if we found an existing version).  Also
-{
+installs it into ::std, if it's not '_*'.  */
-tree          id = DECL_NAME (decl);
-const char *name = IDENTIFIER_POINTER (id);
+tree
+cxx_builtin_function (tree decl)
+{
 retrofit_lang_decl (decl);
 DECL_ARTIFICIAL (decl) = 1;
 SET_DECL_LANGUAGE (decl, lang_c);
 /* Runtime library routines are, by definition, available in an
 external shared object.  */
 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
 DECL_VISIBILITY_SPECIFIED (decl) = 1;
-DECL_CONTEXT (decl) = context;
+tree id = DECL_NAME (decl);
+const char *name = IDENTIFIER_POINTER (id);
-/* A function in the user's namespace should have an explicit
-declaration before it is used.  Mark the built-in function as
-anticipated but not actually declared.  */
 if (name[0] != '_' || name[1] != '_')
+/* In the user's namespace, it must be declared before use.  */
 DECL_ANTICIPATED (decl) = 1;
-else if (strncmp (name + 2, "builtin_", strlen ("builtin_")) != 0)
+else if (IDENTIFIER_LENGTH (id) > strlen ("___chk")
-{
+	   && 0 != strncmp (name + 2, "builtin_", strlen ("builtin_"))
-size_t len = strlen (name);
+	   && 0 == memcmp (name + IDENTIFIER_LENGTH (id) - strlen ("_chk"),
+			   "_chk", strlen ("_chk") + 1))
 /* Treat __*_chk fortification functions as anticipated as well,
-	 unless they are __builtin_*.  */
+unless they are __builtin_*_chk.  */
-if (len > strlen ("___chk")
+DECL_ANTICIPATED (decl) = 1;
-	  && memcmp (name + len - strlen ("_chk"),
-		     "_chk", strlen ("_chk") + 1) == 0)
-	DECL_ANTICIPATED (decl) = 1;
-}
-if (is_global)
-pushdecl_top_level (decl);
-else
-pushdecl (decl);
-return decl;
-}
-tree
-cxx_builtin_function (tree decl)
-{
-tree          id = DECL_NAME (decl);
-const char *name = IDENTIFIER_POINTER (id);
 /* All builtins that don't begin with an '_' should additionally
 go in the 'std' namespace.  */
 if (name[0] != '_')
 {
-tree decl2 = copy_node(decl);
+tree std_decl = copy_decl (decl);
-push_namespace (std_identifier);
-builtin_function_1 (decl2, std_node, false);
+push_nested_namespace (std_node);
-pop_namespace ();
+DECL_CONTEXT (std_decl) = FROB_CONTEXT (std_node);
-}
+pushdecl (std_decl);
+pop_nested_namespace (std_node);
-return builtin_function_1 (decl, NULL_TREE, false);
+}
+DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
+decl = pushdecl (decl);
+return decl;
 }
 /* Like cxx_builtin_function, but guarantee the function is added to the global
 scope.  This is to allow function specific options to add new machine
 dependent builtins when the target ISA changes via attribute((target(...)))
 ISAs.  */
 tree
 cxx_builtin_function_ext_scope (tree decl)
 {
+push_nested_namespace (global_namespace);
-tree          id = DECL_NAME (decl);
+decl = cxx_builtin_function (decl);
-const char *name = IDENTIFIER_POINTER (id);
+pop_nested_namespace (global_namespace);
-/* All builtins that don't begin with an '_' should additionally
-go in the 'std' namespace.  */
+return decl;
-if (name[0] != '_')
+}
-{
-tree decl2 = copy_node(decl);
+/* Implement LANG_HOOKS_SIMULATE_BUILTIN_FUNCTION_DECL.  */
-push_namespace (std_identifier);
-builtin_function_1 (decl2, std_node, true);
+tree
-pop_namespace ();
+cxx_simulate_builtin_function_decl (tree decl)
-}
+{
+retrofit_lang_decl (decl);
-return builtin_function_1 (decl, NULL_TREE, true);
+DECL_ARTIFICIAL (decl) = 1;
+SET_DECL_LANGUAGE (decl, lang_cplusplus);
+DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
+return pushdecl (decl);
 }
 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
 function.  Not called directly.  */
 /* Warn for an attribute located at LOCATION that appertains to the
 class type CLASS_TYPE that has not been properly placed after its
 class-key, in it class-specifier.  */
 void
-warn_misplaced_attr_for_class_type (source_location location,
+warn_misplaced_attr_for_class_type (location_t location,
 				    tree class_type)
 {
 gcc_assert (OVERLOAD_TYPE_P (class_type));
 auto_diagnostic_group d;
 		  "attribute ignored in declaration "
 		  "of %q#T", class_type))
 inform (location,
 	    "attribute for %q#T must follow the %qs keyword",
 	    class_type, class_key_or_enum_as_string (class_type));
+}
+/* Returns the cv-qualifiers that apply to the type specified
+by the DECLSPECS.  */
+static int
+get_type_quals (const cp_decl_specifier_seq *declspecs)
+{
+int type_quals = TYPE_UNQUALIFIED;
+if (decl_spec_seq_has_spec_p (declspecs, ds_const))
+type_quals |= TYPE_QUAL_CONST;
+if (decl_spec_seq_has_spec_p (declspecs, ds_volatile))
+type_quals |= TYPE_QUAL_VOLATILE;
+if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
+type_quals |= TYPE_QUAL_RESTRICT;
+return type_quals;
 }
 /* Make sure that a declaration with no declarator is well-formed, i.e.
 just declares a tagged type or anonymous union.
 DECLARED_TYPE is set to the corresponding type.  */
 tree declared_type = NULL_TREE;
 bool error_p = false;
 if (declspecs->multiple_types_p)
-error ("multiple types in one declaration");
+error_at (smallest_type_location (declspecs),
+	      "multiple types in one declaration");
 else if (declspecs->redefined_builtin_type)
 {
-if (!in_system_header_at (input_location))
+location_t loc = declspecs->locations[ds_redefined_builtin_type_spec];
-	permerror (declspecs->locations[ds_redefined_builtin_type_spec],
+if (!in_system_header_at (loc))
-		   "redeclaration of C++ built-in type %qT",
+	permerror (loc, "redeclaration of C++ built-in type %qT",
 		   declspecs->redefined_builtin_type);
 return NULL_TREE;
 }
 if (declspecs->type
 	   && MAYBE_CLASS_TYPE_P (declspecs->type))
 	  || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
 declared_type = declspecs->type;
 else if (declspecs->type == error_mark_node)
 error_p = true;
-if (declared_type == NULL_TREE && ! saw_friend && !error_p)
-permerror (input_location, "declaration does not declare anything");
+if (type_uses_auto (declared_type))
-else if (declared_type != NULL_TREE && type_uses_auto (declared_type))
 {
 error_at (declspecs->locations[ds_type_spec],
 		"%<auto%> can only be specified for variables "
 		"or function declarations");
 return error_mark_node;
 }
+if (declared_type && !OVERLOAD_TYPE_P (declared_type))
+declared_type = NULL_TREE;
+if (!declared_type && !saw_friend && !error_p)
+permerror (input_location, "declaration does not declare anything");
 /* Check for an anonymous union.  */
 else if (declared_type && RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type))
 	   && TYPE_UNNAMED_P (declared_type))
 {
 /* 7/3 In a simple-declaration, the optional init-declarator-list
 	     enum { };			// ill-formed
 	     typedef class { };		// ill-formed
 	 --end example]  */
 if (saw_typedef)
 	{
-	  error ("missing type-name in typedef-declaration");
+	  error_at (declspecs->locations[ds_typedef],
+		    "missing type-name in typedef-declaration");
 	  return NULL_TREE;
 	}
 /* Anonymous unions are objects, so they can have specifiers.  */;
 SET_ANON_AGGR_TYPE_P (declared_type);
-if (TREE_CODE (declared_type) != UNION_TYPE
+if (TREE_CODE (declared_type) != UNION_TYPE)
-	  && !in_system_header_at (input_location))
+	pedwarn (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (declared_type)),
-	pedwarn (input_location, OPT_Wpedantic, "ISO C++ prohibits anonymous structs");
+		 OPT_Wpedantic, "ISO C++ prohibits anonymous structs");
 }
 else
 {
 if (decl_spec_seq_has_spec_p (declspecs, ds_inline))
 		  "%<__thread%> can only be specified for objects "
 		  "and functions");
 else if (saw_typedef)
 	warning_at (declspecs->locations[ds_typedef], 0,
 		    "%<typedef%> was ignored in this declaration");
-else if (decl_spec_seq_has_spec_p (declspecs,  ds_constexpr))
+else if (decl_spec_seq_has_spec_p (declspecs, ds_constexpr))
 error_at (declspecs->locations[ds_constexpr],
-		  "%<constexpr%> cannot be used for type declarations");
+		  "%qs cannot be used for type declarations", "constexpr");
+else if (decl_spec_seq_has_spec_p (declspecs, ds_constinit))
+	error_at (declspecs->locations[ds_constinit],
+		  "%qs cannot be used for type declarations", "constinit");
+else if (decl_spec_seq_has_spec_p (declspecs, ds_consteval))
+	error_at (declspecs->locations[ds_consteval],
+		  "%qs cannot be used for type declarations", "consteval");
 }
 if (declspecs->attributes && warn_attributes && declared_type)
 {
 location_t loc;
 If not, set INITIALIZED to zero, which will indirectly
 tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
 if (initialized
 && TREE_CODE (decl) == TYPE_DECL)
 {
-error ("typedef %qD is initialized (use decltype instead)", decl);
+error_at (DECL_SOURCE_LOCATION (decl),
+		"typedef %qD is initialized (use %qs instead)",
+		decl, "decltype");
 return error_mark_node;
 }
 if (initialized)
 {
 can be initialized in-class and dllimported) go through grokfield,
 not here, so we don't need to exclude those decls when checking for
 a definition.  */
 if (initialized && DECL_DLLIMPORT_P (decl))
 {
-error ("definition of %q#D is marked %<dllimport%>", decl);
+error_at (DECL_SOURCE_LOCATION (decl),
+		"definition of %q#D is marked %<dllimport%>", decl);
 DECL_DLLIMPORT_P (decl) = 0;
 }
 /* If #pragma weak was used, mark the decl weak now.  */
 if (!processing_template_decl && !DECL_DECOMPOSITION_P (decl))
 if (TREE_CODE (decl) == FUNCTION_DECL
 && DECL_DECLARED_INLINE_P (decl)
 && DECL_UNINLINABLE (decl)
 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
 warning_at (DECL_SOURCE_LOCATION (decl), 0,
-		"inline function %qD given attribute noinline", decl);
+		"inline function %qD given attribute %qs", decl, "noinline");
 if (TYPE_P (context) && COMPLETE_TYPE_P (complete_type (context)))
 {
 bool this_tmpl = (processing_template_decl
 			> template_class_depth (context));
 	}
 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl)
 	  /* Aliases are definitions. */
 	  && !alias)
-	permerror (input_location, "declaration of %q#D outside of class is not definition",
+	permerror (declarator->id_loc,
+		   "declaration of %q#D outside of class is not definition",
 		   decl);
 }
 was_public = TREE_PUBLIC (decl);
 if (!template_parm_scope_p ()
 || !VAR_P (decl))
 decl = maybe_push_decl (decl);
 if (processing_template_decl)
-decl = push_template_decl (decl);
+{
+/* Make sure that for a `constinit' decl push_template_decl creates
+	 a DECL_TEMPLATE_INFO info for us, so that cp_finish_decl can then set
+	 TINFO_VAR_DECLARED_CONSTINIT.  */
+if (decl_spec_seq_has_spec_p (declspecs, ds_constinit))
+	retrofit_lang_decl (decl);
+decl = push_template_decl (decl);
+}
 if (decl == error_mark_node)
 return error_mark_node;
 if (VAR_P (decl)
 && DECL_NAMESPACE_SCOPE_P (decl) && !TREE_PUBLIC (decl) && !was_public
 if (current_function_decl && VAR_P (decl)
 && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
 {
 bool ok = false;
 if (CP_DECL_THREAD_LOCAL_P (decl))
-	error ("%qD declared %<thread_local%> in %<constexpr%> function",
+	error_at (DECL_SOURCE_LOCATION (decl),
-	       decl);
+		  "%qD declared %<thread_local%> in %qs function", decl,
+		  DECL_IMMEDIATE_FUNCTION_P (current_function_decl)
+		  ? "consteval" : "constexpr");
 else if (TREE_STATIC (decl))
-	error ("%qD declared %<static%> in %<constexpr%> function", decl);
+	error_at (DECL_SOURCE_LOCATION (decl),
+		  "%qD declared %<static%> in %qs function", decl,
+		  DECL_IMMEDIATE_FUNCTION_P (current_function_decl)
+		  ? "consteval" : "constexpr");
 else
 	ok = true;
 if (!ok)
 	cp_function_chain->invalid_constexpr = true;
 }
 	 was "const", but incomplete, before this point.  But, now, we
 	 have a complete type, so we can try again.  */
 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
 }
+if (is_global_var (decl))
+{
+type_context_kind context = (DECL_THREAD_LOCAL_P (decl)
+				   ? TCTX_THREAD_STORAGE
+				   : TCTX_STATIC_STORAGE);
+verify_type_context (input_location, context, TREE_TYPE (decl));
+}
 if (initialized)
 /* Is it valid for this decl to have an initializer at all?  */
 {
 /* Don't allow initializations for incomplete types except for
 	 arrays which might be completed by the initialization.  */
 if (init == NULL_TREE)
 {
 if ((DECL_LANG_SPECIFIC (decl) == 0
 	   || DECL_IN_AGGR_P (decl) == 0)
 	  && ! DECL_THIS_EXTERN (decl))
-	error ("%qD declared as reference but not initialized", decl);
+	error_at (DECL_SOURCE_LOCATION (decl),
+		  "%qD declared as reference but not initialized", decl);
 return NULL_TREE;
 }
+tree ttype = TREE_TYPE (type);
 if (TREE_CODE (init) == TREE_LIST)
-init = build_x_compound_expr_from_list (init, ELK_INIT,
+{
-					    tf_warning_or_error);
+/* This handles (C++20 only) code like
-tree ttype = TREE_TYPE (type);
+	   const A& r(1, 2, 3);
+	 where we treat the parenthesized list as a CONSTRUCTOR.  */
+if (TREE_TYPE (init) == NULL_TREE
+	  && CP_AGGREGATE_TYPE_P (ttype)
+	  && !DECL_DECOMPOSITION_P (decl)
+	  && (cxx_dialect >= cxx2a))
+	{
+	  init = build_constructor_from_list (init_list_type_node, init);
+	  CONSTRUCTOR_IS_DIRECT_INIT (init) = true;
+	  CONSTRUCTOR_IS_PAREN_INIT (init) = true;
+	}
+else
+	init = build_x_compound_expr_from_list (init, ELK_INIT,
+						tf_warning_or_error);
+}
 if (TREE_CODE (ttype) != ARRAY_TYPE
 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
 /* Note: default conversion is only called in very special cases.  */
 init = decay_conversion (init, tf_warning_or_error);
 	    }
 	  else
 	    sorry ("non-trivial designated initializers not supported");
 	}
 else
-	error ("C99 designator %qE is not an integral constant-expression",
+	error_at (cp_expr_loc_or_input_loc (ce->index),
-	       ce->index);
+		  "C99 designator %qE is not an integral constant-expression",
+		  ce->index);
 return false;
 }
 return true;
 	      /* While for initialized variables, we must use internal
 		 linkage -- which means that multiple copies will not
 		 be merged.  */
 	      TREE_PUBLIC (decl) = 0;
 	      DECL_COMMON (decl) = 0;
+	      DECL_INTERFACE_KNOWN (decl) = 1;
 	      const char *msg;
 	      if (DECL_INLINE_VAR_P (decl))
 		msg = G_("sorry: semantics of inline variable "
 			 "%q#D are wrong (you%'ll wind up with "
 			 "multiple copies)");
 /* ``Unless explicitly declared extern, a const object does not have
 external linkage and must be initialized. ($8.4; $12.1)'' ARM
 7.1.6 */
 if (VAR_P (decl)
 && !TYPE_REF_P (type)
-&& (constexpr_context_p
+&& (CP_TYPE_CONST_P (type)
-	  || CP_TYPE_CONST_P (type) || var_in_constexpr_fn (decl))
+	  /* C++20 permits trivial default initialization in constexpr
+	     context (P1331R2).  */
+	  || (cxx_dialect < cxx2a
+	      && (constexpr_context_p
+		  || var_in_constexpr_fn (decl))))
 && !DECL_NONTRIVIALLY_INITIALIZED_P (decl))
 {
 tree field = default_init_uninitialized_part (type);
 if (!field)
 	return true;
-if (!constexpr_context_p)
+bool show_notes = true;
+if (!constexpr_context_p || cxx_dialect >= cxx2a)
 	{
 	  if (CP_TYPE_CONST_P (type))
 	    {
 	      if (complain & tf_error)
-		permerror (DECL_SOURCE_LOCATION (decl),
+		show_notes = permerror (DECL_SOURCE_LOCATION (decl),
-			   "uninitialized const %qD", decl);
+				        "uninitialized %<const %D%>", decl);
 	    }
 	  else
 	    {
 	      if (!is_instantiation_of_constexpr (current_function_decl)
 		  && (complain & tf_error))
 		error_at (DECL_SOURCE_LOCATION (decl),
 			  "uninitialized variable %qD in %<constexpr%> "
 			  "function", decl);
+	      else
+		show_notes = false;
 	      cp_function_chain->invalid_constexpr = true;
 	    }
 	}
 else if (complain & tf_error)
 	error_at (DECL_SOURCE_LOCATION (decl),
 		  "uninitialized variable %qD in %<constexpr%> context",
 		  decl);
-if (CLASS_TYPE_P (type) && (complain & tf_error))
+if (show_notes && CLASS_TYPE_P (type) && (complain & tf_error))
 	{
 	  tree defaulted_ctor;
 	  inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
 		  "%q#T has no user-provided default constructor", type);
 {
 constructor_elt *cur;
 constructor_elt *end;
 };
-static tree reshape_init_r (tree, reshape_iter *, bool, tsubst_flags_t);
+static tree reshape_init_r (tree, reshape_iter *, tree, tsubst_flags_t);
 /* FIELD is a FIELD_DECL or NULL.  In the former case, the value
 returned is the next FIELD_DECL (possibly FIELD itself) that can be
 initialized.  If there are no more such fields, the return value
 will be NULL.  */
 {
 while (field
 	 && (TREE_CODE (field) != FIELD_DECL
 	     || DECL_UNNAMED_BIT_FIELD (field)
 	     || (DECL_ARTIFICIAL (field)
-		 && !(cxx_dialect >= cxx17 && DECL_FIELD_IS_BASE (field)))))
+		 /* In C++17, don't skip base class fields.  */
+		 && !(cxx_dialect >= cxx17 && DECL_FIELD_IS_BASE (field))
+		 /* Don't skip vptr fields.  We might see them when we're
+		    called from reduced_constant_expression_p.  */
+		 && !DECL_VIRTUAL_P (field))))
 field = DECL_CHAIN (field);
 return field;
 }
 or NULL_TREE if the array was declared without specifying the size. D is
 the iterator within the constructor.  */
 static tree
 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d,
-		      tsubst_flags_t complain)
+		      tree first_initializer_p, tsubst_flags_t complain)
 {
 tree new_init;
 bool sized_array_p = (max_index && TREE_CONSTANT (max_index));
 unsigned HOST_WIDE_INT max_index_cst = 0;
 unsigned HOST_WIDE_INT index;
-/* The initializer for an array is always a CONSTRUCTOR.  */
+/* The initializer for an array is always a CONSTRUCTOR.  If this is the
-new_init = build_constructor (init_list_type_node, NULL);
+outermost CONSTRUCTOR and the element type is non-aggregate, we don't need
+to build a new one.  */
+bool reuse = (first_initializer_p
+		&& !CP_AGGREGATE_TYPE_P (elt_type)
+		&& !TREE_SIDE_EFFECTS (first_initializer_p));
+if (reuse)
+new_init = first_initializer_p;
+else
+new_init = build_constructor (init_list_type_node, NULL);
 if (sized_array_p)
 {
 /* Minus 1 is used for zero sized arrays.  */
 if (integer_all_onesp (max_index))
 /* sizetype is sign extended, not zero extended.  */
 else
 	max_index_cst = tree_to_uhwi (fold_convert (size_type_node, max_index));
 }
+/* Set to the index of the last element with a non-zero initializer.
+Zero initializers for elements past this one can be dropped.  */
+unsigned HOST_WIDE_INT last_nonzero = -1;
 /* Loop until there are no more initializers.  */
 for (index = 0;
 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
 ++index)
 {
 tree elt_init;
 constructor_elt *old_cur = d->cur;
 check_array_designated_initializer (d->cur, index);
-elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false,
+elt_init = reshape_init_r (elt_type, d,
+				 /*first_initializer_p=*/NULL_TREE,
 				 complain);
 if (elt_init == error_mark_node)
 	return error_mark_node;
-CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init),
+tree idx = size_int (index);
-			      size_int (index), elt_init);
+if (reuse)
+	{
+	  old_cur->index = idx;
+	  old_cur->value = elt_init;
+	}
+else
+	CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init),
+				idx, elt_init);
 if (!TREE_CONSTANT (elt_init))
 	TREE_CONSTANT (new_init) = false;
+/* Pointers initialized to strings must be treated as non-zero
+	 even if the string is empty.  */
+tree init_type = TREE_TYPE (elt_init);
+if (POINTER_TYPE_P (elt_type) != POINTER_TYPE_P (init_type)
+	  || !type_initializer_zero_p (elt_type, elt_init))
+	last_nonzero = index;
 /* This can happen with an invalid initializer (c++/54501).  */
 if (d->cur == old_cur && !sized_array_p)
 	break;
 }
+if (sized_array_p && trivial_type_p (elt_type))
+{
+/* Strip trailing zero-initializers from an array of a trivial
+	 type of known size.  They are redundant and get in the way
+	 of telling them apart from those with implicit zero value.  */
+unsigned HOST_WIDE_INT nelts = CONSTRUCTOR_NELTS (new_init);
+if (last_nonzero > nelts)
+	nelts = 0;
+else if (last_nonzero < nelts - 1)
+	nelts = last_nonzero + 1;
+vec_safe_truncate (CONSTRUCTOR_ELTS (new_init), nelts);
+}
 return new_init;
 }
 /* Subroutine of reshape_init_r, processes the initializers for arrays.
 Parameters are the same of reshape_init_r.  */
 static tree
-reshape_init_array (tree type, reshape_iter *d, tsubst_flags_t complain)
+reshape_init_array (tree type, reshape_iter *d, tree first_initializer_p,
+		    tsubst_flags_t complain)
 {
 tree max_index = NULL_TREE;
 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
 if (TYPE_DOMAIN (type))
 max_index = array_type_nelts (type);
-return reshape_init_array_1 (TREE_TYPE (type), max_index, d, complain);
+return reshape_init_array_1 (TREE_TYPE (type), max_index, d,
+			       first_initializer_p, complain);
 }
 /* Subroutine of reshape_init_r, processes the initializers for vectors.
 Parameters are the same of reshape_init_r.  */
 /* For a vector, we initialize it as an array of the appropriate size.  */
 if (VECTOR_TYPE_P (type))
 max_index = size_int (TYPE_VECTOR_SUBPARTS (type) - 1);
-return reshape_init_array_1 (TREE_TYPE (type), max_index, d, complain);
+return reshape_init_array_1 (TREE_TYPE (type), max_index, d,
+			       NULL_TREE, complain);
 }
 /* Subroutine of reshape_init_r, processes the initializers for classes
 or union. Parameters are the same of reshape_init_r.  */
 	      if (field != d->cur->index)
 		{
 		  tree id = DECL_NAME (d->cur->index);
 		  gcc_assert (id);
 		  gcc_checking_assert (d->cur->index
-				       == get_class_binding (type, id, false));
+				       == get_class_binding (type, id));
 		  field = d->cur->index;
 		}
 	    }
 	  else if (TREE_CODE (d->cur->index) == IDENTIFIER_NODE)
-	    field = get_class_binding (type, d->cur->index, false);
+	    field = get_class_binding (type, d->cur->index);
 	  else
 	    {
 	      if (complain & tf_error)
 		error ("%<[%E] =%> used in a GNU-style designated initializer"
 		       " for class %qT", d->cur->index, type);
 /* If we processed all the member of the class, we are done.  */
 if (!field)
 	break;
 field_init = reshape_init_r (TREE_TYPE (field), d,
-				   /*first_initializer_p=*/false, complain);
+				   /*first_initializer_p=*/NULL_TREE,
+				   complain);
 if (field_init == error_mark_node)
 	return error_mark_node;
 if (d->cur == old_cur && d->cur->index)
 	{
 has_designator_problem (reshape_iter *d, tsubst_flags_t complain)
 {
 if (d->cur->index)
 {
 if (complain & tf_error)
-	error ("C99 designator %qE outside aggregate initializer",
+	error_at (cp_expr_loc_or_input_loc (d->cur->index),
-	       d->cur->index);
+		  "C99 designator %qE outside aggregate initializer",
+		  d->cur->index);
 else
 	return true;
 }
 return false;
 }
 /* Subroutine of reshape_init, which processes a single initializer (part of
 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
 iterator within the CONSTRUCTOR which points to the initializer to process.
-FIRST_INITIALIZER_P is true if this is the first initializer of the
+If this is the first initializer of the outermost CONSTRUCTOR node,
-outermost CONSTRUCTOR node.  */
+FIRST_INITIALIZER_P is that CONSTRUCTOR; otherwise, it is NULL_TREE.  */
 static tree
-reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p,
+reshape_init_r (tree type, reshape_iter *d, tree first_initializer_p,
 		tsubst_flags_t complain)
 {
 tree init = d->cur->value;
 if (error_operand_p (init))
 if (first_initializer_p && !CP_AGGREGATE_TYPE_P (type)
 && has_designator_problem (d, complain))
 return error_mark_node;
+tree stripped_init = tree_strip_any_location_wrapper (init);
 if (TREE_CODE (type) == COMPLEX_TYPE)
 {
 /* A complex type can be initialized from one or two initializers,
 	 but braces are not elided.  */
 d->cur++;
-if (BRACE_ENCLOSED_INITIALIZER_P (init))
+if (BRACE_ENCLOSED_INITIALIZER_P (stripped_init))
 	{
-	  if (CONSTRUCTOR_NELTS (init) > 2)
+	  if (CONSTRUCTOR_NELTS (stripped_init) > 2)
 	    {
 	      if (complain & tf_error)
 		error ("too many initializers for %qT", type);
 	      else
 		return error_mark_node;
 /* It is invalid to initialize a non-aggregate type with a
 	 brace-enclosed initializer before C++0x.
 	 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
 	 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
 	 a CONSTRUCTOR (with a record type).  */
-if (TREE_CODE (init) == CONSTRUCTOR
+if (TREE_CODE (stripped_init) == CONSTRUCTOR
 	  /* Don't complain about a capture-init.  */
-	  && !CONSTRUCTOR_IS_DIRECT_INIT (init)
+	  && !CONSTRUCTOR_IS_DIRECT_INIT (stripped_init)
-	  && BRACE_ENCLOSED_INITIALIZER_P (init))  /* p7626.C */
+	  && BRACE_ENCLOSED_INITIALIZER_P (stripped_init))  /* p7626.C */
 	{
 	  if (SCALAR_TYPE_P (type))
 	    {
-	      if (cxx_dialect < cxx11
+	      if (cxx_dialect < cxx11)
-		  /* Isn't value-initialization.  */
-		  || CONSTRUCTOR_NELTS (init) > 0)
 		{
 		  if (complain & tf_error)
 		    error ("braces around scalar initializer for type %qT",
 			   type);
+		  init = error_mark_node;
+		}
+	      else if (first_initializer_p
+		       || (CONSTRUCTOR_NELTS (stripped_init) > 0
+			   && (BRACE_ENCLOSED_INITIALIZER_P
+			       (CONSTRUCTOR_ELT (stripped_init,0)->value))))
+		{
+		  if (complain & tf_error)
+		    error ("too many braces around scalar initializer "
+		           "for type %qT", type);
 		  init = error_mark_node;
 		}
 	    }
 	  else
 	    maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
 string-literal (optionally enclosed in braces).  */
 if (TREE_CODE (type) == ARRAY_TYPE
 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
 {
 tree str_init = init;
+tree stripped_str_init = stripped_init;
 /* Strip one level of braces if and only if they enclose a single
 	 element (as allowed by [dcl.init.string]).  */
 if (!first_initializer_p
-	  && TREE_CODE (str_init) == CONSTRUCTOR
+	  && TREE_CODE (stripped_str_init) == CONSTRUCTOR
-	  && CONSTRUCTOR_NELTS (str_init) == 1)
+	  && CONSTRUCTOR_NELTS (stripped_str_init) == 1)
 	{
-	  str_init = (*CONSTRUCTOR_ELTS (str_init))[0].value;
+	  str_init = (*CONSTRUCTOR_ELTS (stripped_str_init))[0].value;
+	  stripped_str_init = tree_strip_any_location_wrapper (str_init);
 	}
 /* If it's a string literal, then it's the initializer for the array
 	 as a whole. Otherwise, continue with normal initialization for
 	 array types (one value per array element).  */
-if (TREE_CODE (str_init) == STRING_CST)
+if (TREE_CODE (stripped_str_init) == STRING_CST)
 	{
 	  if (has_designator_problem (d, complain))
 	    return error_mark_node;
 	  d->cur++;
 	  return str_init;
 initializer already, and there is not a CONSTRUCTOR, it means that there
 is a missing set of braces (that is, we are processing the case for
 which reshape_init exists).  */
 if (!first_initializer_p)
 {
-if (TREE_CODE (init) == CONSTRUCTOR)
+if (TREE_CODE (stripped_init) == CONSTRUCTOR)
 	{
-	  if (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))
+	  tree init_type = TREE_TYPE (init);
-	    /* There is no need to reshape pointer-to-member function
+	  if (init_type && TYPE_PTRMEMFUNC_P (init_type))
-	       initializers, as they are always constructed correctly
+	    /* There is no need to call reshape_init for pointer-to-member
-	       by the front end.  */
+	       function initializers, as they are always constructed correctly
-;
+	       by the front end.  Here we have e.g. {.__pfn=0B, .__delta=0},
-	  else if (COMPOUND_LITERAL_P (init))
+	       which is missing outermost braces.  We should warn below, and
-	  /* For a nested compound literal, there is no need to reshape since
+	       one of the routines below will wrap it in additional { }.  */;
-	     brace elision is not allowed. Even if we decided to allow it,
+	  /* For a nested compound literal, proceed to specialized routines,
-	     we should add a call to reshape_init in finish_compound_literal,
+	     to handle initialization of arrays and similar.  */
-	     before calling digest_init, so changing this code would still
+	  else if (COMPOUND_LITERAL_P (stripped_init))
-	     not be necessary.  */
+	    gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (stripped_init));
-	    gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
+	  /* A CONSTRUCTOR of the target's type is a previously
+	     digested initializer.  */
+	  else if (same_type_ignoring_top_level_qualifiers_p (type, init_type))
+	    {
+	      ++d->cur;
+	      return init;
+	    }
 	  else
 	    {
+	      /* Something that hasn't been reshaped yet.  */
 	      ++d->cur;
-	      gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
+	      gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (stripped_init));
 	      return reshape_init (type, init, complain);
 	    }
 	}
 if (complain & tf_warning)
 /* Dispatch to specialized routines.  */
 if (CLASS_TYPE_P (type))
 return reshape_init_class (type, d, first_initializer_p, complain);
 else if (TREE_CODE (type) == ARRAY_TYPE)
-return reshape_init_array (type, d, complain);
+return reshape_init_array (type, d, first_initializer_p, complain);
 else if (VECTOR_TYPE_P (type))
 return reshape_init_vector (type, d, complain);
 else
 gcc_unreachable();
 }
 /* An empty constructor does not need reshaping, and it is always a valid
 initializer.  */
 if (vec_safe_is_empty (v))
 return init;
+/* Brace elision is not performed for a CONSTRUCTOR representing
+parenthesized aggregate initialization.  */
+if (CONSTRUCTOR_IS_PAREN_INIT (init))
+return init;
 /* Handle [dcl.init.list] direct-list-initialization from
 single element of enumeration with a fixed underlying type.  */
 if (is_direct_enum_init (type, init))
 {
 tree elt = CONSTRUCTOR_ELT (init, 0)->value;
 type = cv_unqualified (type);
 if (check_narrowing (ENUM_UNDERLYING_TYPE (type), elt, complain))
 	{
 	  warning_sentinel w (warn_useless_cast);
 	  warning_sentinel w2 (warn_ignored_qualifiers);
-	  return cp_build_c_cast (type, elt, tf_warning_or_error);
+	  return cp_build_c_cast (input_location, type, elt,
+				  tf_warning_or_error);
 	}
 else
 	return error_mark_node;
 }
 /* Recurse on this CONSTRUCTOR.  */
 d.cur = &(*v)[0];
 d.end = d.cur + v->length ();
-new_init = reshape_init_r (type, &d, true, complain);
+new_init = reshape_init_r (type, &d, init, complain);
 if (new_init == error_mark_node)
 return error_mark_node;
 /* Make sure all the element of the constructor were used. Otherwise,
 issue an error about exceeding initializers.  */
 }
 if (CONSTRUCTOR_IS_DIRECT_INIT (init)
 && BRACE_ENCLOSED_INITIALIZER_P (new_init))
 CONSTRUCTOR_IS_DIRECT_INIT (new_init) = true;
+if (CONSTRUCTOR_IS_DESIGNATED_INIT (init)
+&& BRACE_ENCLOSED_INITIALIZER_P (new_init))
+CONSTRUCTOR_IS_DESIGNATED_INIT (new_init) = true;
 return new_init;
 }
 /* Verify array initializer.  Returns true if errors have been reported.  */
 		  "elements of array %q#D have incomplete type", decl);
 else
 	error ("elements of array %q#T have incomplete type", type);
 return true;
 }
+location_t loc = (decl ? location_of (decl) : input_location);
+if (!verify_type_context (loc, TCTX_ARRAY_ELEMENT, element_type))
+return true;
 /* A compound literal can't have variable size.  */
 if (init && !decl
 && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
 	  || !TREE_CONSTANT (TYPE_SIZE (element_type))))
 {
 evaluated dynamically to initialize DECL.  */
 static tree
 check_initializer (tree decl, tree init, int flags, vec<tree, va_gc> **cleanups)
 {
-tree type = TREE_TYPE (decl);
+tree type;
 tree init_code = NULL;
 tree core_type;
 /* Things that are going to be initialized need to have complete
 type.  */
 	    {
 	      init = reshape_init (type, init, tf_warning_or_error);
 	      flags |= LOOKUP_NO_NARROWING;
 	    }
 	}
+/* [dcl.init] "Otherwise, if the destination type is an array, the object
+	 is initialized as follows..."  So handle things like
+	  int a[](1, 2, 3);
+	 which is permitted in C++20 by P0960.  */
+else if (TREE_CODE (init) == TREE_LIST
+	       && TREE_TYPE (init) == NULL_TREE
+	       && TREE_CODE (type) == ARRAY_TYPE
+	       && !DECL_DECOMPOSITION_P (decl)
+	       && (cxx_dialect >= cxx2a))
+	{
+	  /* [dcl.init.string] "An array of ordinary character type [...]
+	     can be initialized by an ordinary string literal [...] by an
+	     appropriately-typed string literal enclosed in braces" only
+	     talks about braces, but GCC has always accepted
+	       char a[]("foobar");
+	     so we continue to do so.  */
+	  tree val = TREE_VALUE (init);
+	  if (TREE_CHAIN (init) == NULL_TREE
+	      && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
+	      && TREE_CODE (tree_strip_any_location_wrapper (val))
+		 == STRING_CST)
+	    /* If the list has a single element and it's a string literal,
+	       then it's the initializer for the array as a whole.  */
+	    init = val;
+	  else
+	    {
+	      init = build_constructor_from_list (init_list_type_node, init);
+	      CONSTRUCTOR_IS_DIRECT_INIT (init) = true;
+	      CONSTRUCTOR_IS_PAREN_INIT (init) = true;
+	    }
+	}
 else if (TREE_CODE (init) == TREE_LIST
 	       && TREE_TYPE (init) != unknown_type_node
 	       && !MAYBE_CLASS_TYPE_P (type))
 	{
 	  gcc_assert (TREE_CODE (decl) != RESULT_DECL);
 	  while (TREE_CODE (init_code) == EXPR_STMT
 		 || TREE_CODE (init_code) == CONVERT_EXPR)
 	    init_code = TREE_OPERAND (init_code, 0);
 	  if (TREE_CODE (init_code) == INIT_EXPR)
 	    {
+	      /* In C++20, the call to build_aggr_init could have created
+		 an INIT_EXPR with a CONSTRUCTOR as the RHS to handle
+		 A(1, 2).  */
 	      init = TREE_OPERAND (init_code, 1);
 	      init_code = NULL_TREE;
 	      /* Don't call digest_init; it's unnecessary and will complain
 		 about aggregate initialization of non-aggregate classes.  */
 	      flags |= LOOKUP_ALREADY_DIGESTED;
 	    }
-	  else if (DECL_DECLARED_CONSTEXPR_P (decl))
+	  else if (DECL_DECLARED_CONSTEXPR_P (decl)
+		   || (flags & LOOKUP_CONSTINIT))
 	    {
-	      /* Declared constexpr, but no suitable initializer; massage
+	      /* Declared constexpr or constinit, but no suitable initializer;
-		 init appropriately so we can pass it into store_init_value
+		 massage init appropriately so we can pass it into
-		 for the error.  */
+		 store_init_value for the error.  */
 	      if (CLASS_TYPE_P (type)
 		  && (!init || TREE_CODE (init) == TREE_LIST))
 		{
-		  init = build_functional_cast (type, init, tf_none);
+		  init = build_functional_cast (input_location, type,
+						init, tf_none);
 		  if (TREE_CODE (init) == TARGET_EXPR)
 		    TARGET_EXPR_DIRECT_INIT_P (init) = true;
 		}
 	      init_code = NULL_TREE;
 	    }
 	    warning_at (cp_expr_loc_or_loc (DECL_INITIAL (decl),
 					 DECL_SOURCE_LOCATION (decl)),
 			0, "array %qD initialized by parenthesized "
 			"string literal %qE",
 			decl, DECL_INITIAL (decl));
-	  init = NULL;
+	  init = NULL_TREE;
 	}
 }
 else
 {
 if (CLASS_TYPE_P (core_type = strip_array_types (type))
 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = false;
 TREE_CONSTANT (decl) = false;
 }
 if (init_code
-&& (DECL_IN_AGGR_P (decl)
+&& DECL_IN_AGGR_P (decl)
-	  && DECL_INITIALIZED_IN_CLASS_P (decl)
+&& DECL_INITIALIZED_IN_CLASS_P (decl))
-	  && !DECL_VAR_DECLARED_INLINE_P (decl)))
 {
 static int explained = 0;
 if (cxx_dialect < cxx11)
 	error ("initializer invalid for static member with constructor");
 gcc_assert (TREE_STATIC (decl));
 /* An in-class declaration of a static data member should be
 	 external; it is only a declaration, and not a definition.  */
 if (init == NULL_TREE)
 	gcc_assert (DECL_EXTERNAL (decl)
-		    || !TREE_PUBLIC (decl)
+		    || !TREE_PUBLIC (decl));
-		    || DECL_INLINE_VAR_P (decl));
 }
 /* We don't create any RTL for local variables.  */
 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
 return;
 if (TREE_CODE (*tp) == LABEL_DECL)
 cfun->has_forced_label_in_static = 1;
 return NULL_TREE;
 }
+/* Return true if DECL has either a trivial destructor, or for C++2A
+is constexpr and has a constexpr destructor.  */
+static bool
+decl_maybe_constant_destruction (tree decl, tree type)
+{
+return (TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
+	  || (cxx_dialect >= cxx2a
+	      && VAR_P (decl)
+	      && DECL_DECLARED_CONSTEXPR_P (decl)
+	      && type_has_constexpr_destructor (strip_array_types (type))));
+}
+static tree declare_simd_adjust_this (tree *, int *, void *);
+/* Helper function of omp_declare_variant_finalize.  Finalize one
+"omp declare variant base" attribute.  Return true if it should be
+removed.  */
+static bool
+omp_declare_variant_finalize_one (tree decl, tree attr)
+{
+if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
+{
+walk_tree (&TREE_VALUE (TREE_VALUE (attr)), declare_simd_adjust_this,
+		 DECL_ARGUMENTS (decl), NULL);
+walk_tree (&TREE_PURPOSE (TREE_VALUE (attr)), declare_simd_adjust_this,
+		 DECL_ARGUMENTS (decl), NULL);
+}
+tree ctx = TREE_VALUE (TREE_VALUE (attr));
+tree simd = omp_get_context_selector (ctx, "construct", "simd");
+if (simd)
+{
+TREE_VALUE (simd)
+	= c_omp_declare_simd_clauses_to_numbers (DECL_ARGUMENTS (decl),
+						 TREE_VALUE (simd));
+/* FIXME, adjusting simd args unimplemented.  */
+return true;
+}
+tree chain = TREE_CHAIN (TREE_VALUE (attr));
+location_t varid_loc
+= cp_expr_loc_or_input_loc (TREE_PURPOSE (TREE_CHAIN (chain)));
+location_t match_loc = cp_expr_loc_or_input_loc (TREE_PURPOSE (chain));
+cp_id_kind idk = (cp_id_kind) tree_to_uhwi (TREE_VALUE (chain));
+tree variant = TREE_PURPOSE (TREE_VALUE (attr));
+location_t save_loc = input_location;
+input_location = varid_loc;
+releasing_vec args;
+tree parm = DECL_ARGUMENTS (decl);
+if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
+parm = DECL_CHAIN (parm);
+for (; parm; parm = DECL_CHAIN (parm))
+if (type_dependent_expression_p (parm))
+vec_safe_push (args, build_constructor (TREE_TYPE (parm), NULL));
+else if (MAYBE_CLASS_TYPE_P (TREE_TYPE (parm)))
+vec_safe_push (args, build_local_temp (TREE_TYPE (parm)));
+else
+vec_safe_push (args, build_zero_cst (TREE_TYPE (parm)));
+bool koenig_p = false;
+if (idk == CP_ID_KIND_UNQUALIFIED || idk == CP_ID_KIND_TEMPLATE_ID)
+{
+if (identifier_p (variant)
+	  /* In C++2A, we may need to perform ADL for a template
+	     name.  */
+	  || (TREE_CODE (variant) == TEMPLATE_ID_EXPR
+	      && identifier_p (TREE_OPERAND (variant, 0))))
+	{
+	  if (!args->is_empty ())
+	    {
+	      koenig_p = true;
+	      if (!any_type_dependent_arguments_p (args))
+		variant = perform_koenig_lookup (variant, args,
+						 tf_warning_or_error);
+	    }
+	  else
+	    variant = unqualified_fn_lookup_error (variant);
+	}
+else if (!args->is_empty () && is_overloaded_fn (variant))
+	{
+	  tree fn = get_first_fn (variant);
+	  fn = STRIP_TEMPLATE (fn);
+	  if (!((TREE_CODE (fn) == USING_DECL && DECL_DEPENDENT_P (fn))
+		 || DECL_FUNCTION_MEMBER_P (fn)
+		 || DECL_LOCAL_FUNCTION_P (fn)))
+	    {
+	      koenig_p = true;
+	      if (!any_type_dependent_arguments_p (args))
+		variant = perform_koenig_lookup (variant, args,
+						 tf_warning_or_error);
+	    }
+	}
+}
+if (idk == CP_ID_KIND_QUALIFIED)
+variant = finish_call_expr (variant, &args, /*disallow_virtual=*/true,
+				koenig_p, tf_warning_or_error);
+else
+variant = finish_call_expr (variant, &args, /*disallow_virtual=*/false,
+				koenig_p, tf_warning_or_error);
+if (variant == error_mark_node && !processing_template_decl)
+return true;
+variant = cp_get_callee (variant);
+if (variant)
+{
+if (TREE_CODE (variant) == FUNCTION_DECL)
+	;
+else if (TREE_TYPE (variant) && INDIRECT_TYPE_P (TREE_TYPE (variant)))
+	variant = cp_get_fndecl_from_callee (variant, false);
+else
+	variant = NULL_TREE;
+}
+input_location = save_loc;
+if (variant)
+{
+const char *varname = IDENTIFIER_POINTER (DECL_NAME (variant));
+if (!comptypes (TREE_TYPE (decl), TREE_TYPE (variant), 0))
+	{
+	  error_at (varid_loc, "variant %qD and base %qD have incompatible "
+			       "types", variant, decl);
+	  return true;
+	}
+if (fndecl_built_in_p (variant)
+	  && (strncmp (varname, "__builtin_", strlen ("__builtin_")) == 0
+	      || strncmp (varname, "__sync_", strlen ("__sync_")) == 0
+	      || strncmp (varname, "__atomic_", strlen ("__atomic_")) == 0))
+	{
+	  error_at (varid_loc, "variant %qD is a built-in", variant);
+	  return true;
+	}
+else
+	{
+	  tree construct = omp_get_context_selector (ctx, "construct", NULL);
+	  c_omp_mark_declare_variant (match_loc, variant, construct);
+	  if (!omp_context_selector_matches (ctx))
+	    return true;
+	  TREE_PURPOSE (TREE_VALUE (attr)) = variant;
+	}
+}
+else if (!processing_template_decl)
+{
+error_at (varid_loc, "could not find variant declaration");
+return true;
+}
+return false;
+}
+/* Helper function, finish up "omp declare variant base" attribute
+now that there is a DECL.  ATTR is the first "omp declare variant base"
+attribute.  */
+void
+omp_declare_variant_finalize (tree decl, tree attr)
+{
+size_t attr_len = strlen ("omp declare variant base");
+tree *list = &DECL_ATTRIBUTES (decl);
+bool remove_all = false;
+location_t match_loc = DECL_SOURCE_LOCATION (decl);
+if (TREE_CHAIN (TREE_VALUE (attr))
+&& TREE_PURPOSE (TREE_CHAIN (TREE_VALUE (attr)))
+&& EXPR_HAS_LOCATION (TREE_PURPOSE (TREE_CHAIN (TREE_VALUE (attr)))))
+match_loc = EXPR_LOCATION (TREE_PURPOSE (TREE_CHAIN (TREE_VALUE (attr))));
+if (DECL_CONSTRUCTOR_P (decl))
+{
+error_at (match_loc, "%<declare variant%> on constructor %qD", decl);
+remove_all = true;
+}
+else if (DECL_DESTRUCTOR_P (decl))
+{
+error_at (match_loc, "%<declare variant%> on destructor %qD", decl);
+remove_all = true;
+}
+else if (DECL_DEFAULTED_FN (decl))
+{
+error_at (match_loc, "%<declare variant%> on defaulted %qD", decl);
+remove_all = true;
+}
+else if (DECL_DELETED_FN (decl))
+{
+error_at (match_loc, "%<declare variant%> on deleted %qD", decl);
+remove_all = true;
+}
+else if (DECL_VIRTUAL_P (decl))
+{
+error_at (match_loc, "%<declare variant%> on virtual %qD", decl);
+remove_all = true;
+}
+/* This loop is like private_lookup_attribute, except that it works
+with tree * rather than tree, as we might want to remove the
+attributes that are diagnosed as errorneous.  */
+while (*list)
+{
+tree attr = get_attribute_name (*list);
+size_t ident_len = IDENTIFIER_LENGTH (attr);
+if (cmp_attribs ("omp declare variant base", attr_len,
+		       IDENTIFIER_POINTER (attr), ident_len))
+	{
+	  if (remove_all || omp_declare_variant_finalize_one (decl, *list))
+	    {
+	      *list = TREE_CHAIN (*list);
+	      continue;
+	    }
+	}
+list = &TREE_CHAIN (*list);
+}
+}
 /* Finish processing of a declaration;
 install its line number and initial value.
 If the length of an array type is not known before,
 it must be determined now, from the initial value, or it is an error.
 						   NULL_TREE, flags);
 if (type == error_mark_node)
 	return;
 if (TREE_CODE (type) == FUNCTION_TYPE)
 	{
-	  error ("initializer for %<decltype(auto) %D%> has function type "
+	  error ("initializer for %<decltype(auto) %D%> has function type; "
-		 "(did you forget the %<()%> ?)", decl);
+		 "did you forget the %<()%>?", decl);
 	  TREE_TYPE (decl) = error_mark_node;
 	  return;
 	}
 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
 }
 	}
 }
 if (VAR_P (decl)
 && DECL_CLASS_SCOPE_P (decl)
+&& verify_type_context (DECL_SOURCE_LOCATION (decl),
+			      TCTX_STATIC_STORAGE, type)
 && DECL_INITIALIZED_IN_CLASS_P (decl))
 check_static_variable_definition (decl, type);
 if (init && TREE_CODE (decl) == FUNCTION_DECL)
 {
 	      && !TYPE_REF_P (type))
 	    TREE_CONSTANT (decl) = 1;
 	}
 }
+if (flag_openmp
+&& TREE_CODE (decl) == FUNCTION_DECL
+/* #pragma omp declare variant on methods handled in finish_struct
+	 instead.  */
+&& (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
+	  || COMPLETE_TYPE_P (DECL_CONTEXT (decl))))
+if (tree attr = lookup_attribute ("omp declare variant base",
+				      DECL_ATTRIBUTES (decl)))
+omp_declare_variant_finalize (decl, attr);
 if (processing_template_decl)
 {
 bool type_dependent_p;
 /* Add this declaration to the statement-tree.  */
 if (check_for_bare_parameter_packs (init))
 	{
 	  init = NULL_TREE;
 	  DECL_INITIAL (decl) = NULL_TREE;
 	}
+/* Handle `constinit' on variable templates.  */
+if (flags & LOOKUP_CONSTINIT)
+	TINFO_VAR_DECLARED_CONSTINIT (DECL_TEMPLATE_INFO (decl)) = true;
 /* Generally, initializers in templates are expanded when the
 	 template is instantiated.  But, if DECL is a variable constant
 	 then it can be used in future constant expressions, so its value
 	 must be available. */
 	  init_code = check_initializer (decl, init, flags, &cleanups);
 	  if (init_code == NULL_TREE)
 	    init = NULL_TREE;
 	  release_tree_vector (cleanups);
 	}
-else if (!DECL_PRETTY_FUNCTION_P (decl))
+else
 	{
+	  gcc_assert (!DECL_PRETTY_FUNCTION_P (decl));
 	  /* Deduce array size even if the initializer is dependent.  */
 	  maybe_deduce_size_from_array_init (decl, init);
 	  /* And complain about multiple initializers.  */
 	  if (init && TREE_CODE (init) == TREE_LIST && TREE_CHAIN (init)
 	      && !MAYBE_CLASS_TYPE_P (type))
 {
 was_readonly = 1;
 TREE_READONLY (decl) = 0;
 }
+/* This needs to happen before extend_ref_init_temps.  */
+if (VAR_OR_FUNCTION_DECL_P (decl))
+{
+if (VAR_P (decl))
+	maybe_commonize_var (decl);
+determine_visibility (decl);
+}
 if (VAR_P (decl))
 {
+duration_kind dk = decl_storage_duration (decl);
+/* [dcl.constinit]/1 "The constinit specifier shall be applied
+	 only to a declaration of a variable with static or thread storage
+	 duration."  */
+if ((flags & LOOKUP_CONSTINIT)
+	  && !(dk == dk_thread || dk == dk_static))
+	{
+	  error_at (DECL_SOURCE_LOCATION (decl),
+		    "%<constinit%> can only be applied to a variable with "
+		    "static or thread storage duration");
+	  return;
+	}
 /* If this is a local variable that will need a mangled name,
 	 register it now.  We must do this before processing the
 	 initializer for the variable, since the initialization might
 	 require a guard variable, and since the mangled name of the
 	 guard variable will depend on the mangled name of this
 	 variable.  */
 if (DECL_FUNCTION_SCOPE_P (decl)
 	  && TREE_STATIC (decl)
 	  && !DECL_ARTIFICIAL (decl))
 	{
-	  push_local_name (decl);
+	  /* The variable holding an anonymous union will have had its
+	     discriminator set in finish_anon_union, after which it's
+	     NAME will have been cleared.  */
+	  if (DECL_NAME (decl))
+	    determine_local_discriminator (decl);
 	  /* Normally has_forced_label_in_static is set during GIMPLE
 	     lowering, but [cd]tors are never actually compiled directly.
 	     We need to set this early so we can deal with the label
 	     address extension.  */
 	  if ((DECL_CONSTRUCTOR_P (current_function_decl)
 if (VAR_OR_FUNCTION_DECL_P (decl))
 {
 if (VAR_P (decl))
 	{
 	  layout_var_decl (decl);
-	  maybe_commonize_var (decl);
+	  if (!flag_weak)
-	}
+	    /* Check again now that we have an initializer.  */
+	    maybe_commonize_var (decl);
-/* This needs to happen after the linkage is set. */
+	}
-determine_visibility (decl);
 if (var_definition_p && TREE_STATIC (decl))
 	{
 	  /* If a TREE_READONLY variable needs initialization
 	     at runtime, it is no longer readonly and we need to
 	    }
 	  else if (was_readonly)
 	    TREE_READONLY (decl) = 1;
 	  /* Likewise if it needs destruction.  */
-	  if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
+	  if (!decl_maybe_constant_destruction (decl, type))
 	    TREE_READONLY (decl) = 0;
 	}
 make_rtl_for_nonlocal_decl (decl, init, asmspec);
 		    maybe_explain_implicit_delete (decl);
 		  else if (DECL_INITIAL (decl) == error_mark_node)
 		    synthesize_method (decl);
 		}
 	      else
-		error ("function %q#D is initialized like a variable", decl);
+		error_at (cp_expr_loc_or_loc (init,
+					      DECL_SOURCE_LOCATION (decl)),
+			  "function %q#D is initialized like a variable",
+			  decl);
 	    }
 	  /* else no initialization required.  */
 	}
 else if (DECL_EXTERNAL (decl)
 	       && ! (DECL_LANG_SPECIFIC (decl)
 		     && DECL_NOT_REALLY_EXTERN (decl)))
 	{
-	  if (init)
+	  /* check_initializer will have done any constant initialization.  */
-	    DECL_INITIAL (decl) = init;
 	}
 /* A variable definition.  */
 else if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
 	/* Initialize the local variable.  */
 	initialize_local_var (decl, init);
 DECL_ATTRIBUTES (decl)
 	= remove_attribute ("omp declare target implicit",
 			    DECL_ATTRIBUTES (decl));
 complete_type (TREE_TYPE (decl));
 if (!cp_omp_mappable_type (TREE_TYPE (decl)))
-	error ("%q+D in declare target directive does not have mappable type",
+	{
-	       decl);
+	  error ("%q+D in declare target directive does not have mappable"
+		 " type", decl);
+	  cp_omp_emit_unmappable_type_notes (TREE_TYPE (decl));
+	}
 else if (!lookup_attribute ("omp declare target",
 				  DECL_ATTRIBUTES (decl))
 	       && !lookup_attribute ("omp declare target link",
 				     DECL_ATTRIBUTES (decl)))
 	DECL_ATTRIBUTES (decl)
 				    /*path*/NULL_TREE, LOOKUP_NORMAL,
 				    /*fn_p*/NULL, tf_warning_or_error);
 }
 else
 {
-vec<tree,va_gc> *args = make_tree_vector_single (e);
+releasing_vec args (make_tree_vector_single (e));
 fns = lookup_template_function (get__identifier, targs);
 fns = perform_koenig_lookup (fns, args, tf_warning_or_error);
 return finish_call_expr (fns, &args, /*novirt*/false,
 			       /*koenig*/true, tf_warning_or_error);
 }
 }
 /* It's impossible to recover the decltype of a tuple decomposition variable
 based on the actual type of the variable, so store it in a hash table.  */
-static GTY((cache)) tree_cache_map *decomp_type_table;
+static GTY((cache)) decl_tree_cache_map *decomp_type_table;
-static void
-store_decomp_type (tree v, tree t)
-{
-if (!decomp_type_table)
-decomp_type_table = tree_cache_map::create_ggc (13);
-decomp_type_table->put (v, t);
-}
 tree
 lookup_decomp_type (tree v)
 {
 return *decomp_type_table->get (v);
 void
 cp_maybe_mangle_decomp (tree decl, tree first, unsigned int count)
 {
 if (!processing_template_decl
 && !error_operand_p (decl)
-&& DECL_NAMESPACE_SCOPE_P (decl))
+&& TREE_STATIC (decl))
 {
 auto_vec<tree, 16> v;
 v.safe_grow (count);
 tree d = first;
 for (unsigned int i = 0; i < count; i++, d = DECL_CHAIN (d))
 	      inform (dloc, "in initialization of structured binding "
 		      "variable %qD", v[i]);
 	      goto error_out;
 	    }
 	  /* Save the decltype away before reference collapse.  */
-	  store_decomp_type (v[i], eltype);
+	  hash_map_safe_put<hm_ggc> (decomp_type_table, v[i], eltype);
 	  eltype = cp_build_reference_type (eltype, !lvalue_p (init));
 	  TREE_TYPE (v[i]) = eltype;
 	  layout_decl (v[i], 0);
 	  if (DECL_HAS_VALUE_EXPR_P (v[i]))
 	    {
 	      /* In this case the names are variables, not just proxies.  */
 	      SET_DECL_VALUE_EXPR (v[i], NULL_TREE);
 	      DECL_HAS_VALUE_EXPR_P (v[i]) = 0;
 	    }
 	  if (!processing_template_decl)
-	    cp_finish_decl (v[i], init, /*constexpr*/false,
+	    {
-			    /*asm*/NULL_TREE, LOOKUP_NORMAL);
+	      copy_linkage (v[i], decl);
+	      cp_finish_decl (v[i], init, /*constexpr*/false,
+			      /*asm*/NULL_TREE, LOOKUP_NORMAL);
+	    }
 	}
 /* Ignore reads from the underlying decl performed during initialization
 	 of the individual variables.  If those will be read, we'll mark
 	 the underlying decl as read at that point.  */
 DECL_READ_P (decl) = save_read;
 type = TREE_TYPE (decl);
 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
 return void_node;
+if (decl_maybe_constant_destruction (decl, type)
+&& DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
+{
+cxx_maybe_build_cleanup (decl, tf_warning_or_error);
+return void_node;
+}
 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
 "__aeabi_atexit"), and DECL is a class object, we can just pass the
 destructor to "__cxa_atexit"; we don't have to build a temporary
 function to do the cleanup.  */
 dso_parm = (flag_use_cxa_atexit
 {
 gcc_assert (VAR_P (decl));
 gcc_assert (TREE_STATIC (decl));
 /* Some variables require no dynamic initialization.  */
-if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
+if (decl_maybe_constant_destruction (decl, TREE_TYPE (decl)))
 {
 /* Make sure the destructor is callable.  */
 cxx_maybe_build_cleanup (decl, tf_warning_or_error);
 if (!init)
 	return;
 }
 if (CP_DECL_THREAD_LOCAL_P (decl) && DECL_GNU_TLS_P (decl)
 && !DECL_FUNCTION_SCOPE_P (decl))
 {
+location_t dloc = DECL_SOURCE_LOCATION (decl);
 if (init)
-	error ("non-local variable %qD declared %<__thread%> "
+	error_at (dloc, "non-local variable %qD declared %<__thread%> "
-	       "needs dynamic initialization", decl);
+		  "needs dynamic initialization", decl);
 else
-	error ("non-local variable %qD declared %<__thread%> "
+	error_at (dloc, "non-local variable %qD declared %<__thread%> "
-	       "has a non-trivial destructor", decl);
+		  "has a non-trivial destructor", decl);
 static bool informed;
 if (!informed)
 	{
-	  inform (DECL_SOURCE_LOCATION (decl),
+	  inform (dloc, "C++11 %<thread_local%> allows dynamic "
-		  "C++11 %<thread_local%> allows dynamic initialization "
+		  "initialization and destruction");
-		  "and destruction");
 	  informed = true;
 	}
 return;
 }
 	  if (!acquire_fn)
 	    acquire_fn = push_library_fn
 	      (acquire_name, build_function_type_list (integer_type_node,
 						       TREE_TYPE (guard_addr),
 						       NULL_TREE),
-	       NULL_TREE, ECF_NOTHROW | ECF_LEAF);
+	       NULL_TREE, ECF_NOTHROW);
 	  if (!release_fn || !abort_fn)
 	    vfntype = build_function_type_list (void_type_node,
 						TREE_TYPE (guard_addr),
 						NULL_TREE);
 	  if (!release_fn)
 	    release_fn = push_library_fn (release_name, vfntype, NULL_TREE,
-					   ECF_NOTHROW | ECF_LEAF);
+					  ECF_NOTHROW);
 	  if (!abort_fn)
 	    abort_fn = push_library_fn (abort_name, vfntype, NULL_TREE,
 					ECF_NOTHROW | ECF_LEAF);
 	  inner_if_stmt = begin_if_stmt ();
 	  && TREE_CODE (initial_value) == CONSTRUCTOR
 	  && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value)))
 	{
 	  vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (initial_value);
 	  tree value = (*v)[0].value;
+	  STRIP_ANY_LOCATION_WRAPPER (value);
 	  if (TREE_CODE (value) == STRING_CST
 	      && v->length () == 1)
 	    initial_value = value;
 	}
 tree t;
 if (location == UNKNOWN_LOCATION)
 location = input_location;
-// Was the concept specifier present?
+/* Was the concept specifier present?  */
 bool concept_p = inlinep & 4;
-// Concept declarations must have a corresponding definition.
+/* Concept declarations must have a corresponding definition.  */
 if (concept_p && !funcdef_flag)
 {
 error_at (location, "concept %qD has no definition", declarator);
 return NULL_TREE;
 }
 /* Set the constraints on the declaration. */
 if (flag_concepts)
 {
 tree tmpl_reqs = NULL_TREE;
-if (processing_template_decl > template_class_depth (ctype))
+tree ctx = friendp ? current_class_type : ctype;
+bool memtmpl = (processing_template_decl > template_class_depth (ctx));
+if (memtmpl)
 tmpl_reqs = TEMPLATE_PARMS_CONSTRAINTS (current_template_parms);
-/* Adjust the required expression into a constraint. */
-if (decl_reqs)
-decl_reqs = normalize_expression (decl_reqs);
 tree ci = build_constraints (tmpl_reqs, decl_reqs);
+if (concept_p && ci)
+{
+error_at (location, "a function concept cannot be constrained");
+ci = NULL_TREE;
+}
+/* C++20 CA378: Remove non-templated constrained functions.  */
+if (ci && !flag_concepts_ts
+	  && (!processing_template_decl
+	      || (friendp && !memtmpl && !funcdef_flag)))
+	{
+	  error_at (location, "constraints on a non-templated function");
+	  ci = NULL_TREE;
+	}
 set_constraints (decl, ci);
 }
 if (TREE_CODE (type) == METHOD_TYPE)
 {
 	  /* A friend declaration of the form friend void f<>().  Record
 	     the information in the TEMPLATE_ID_EXPR.  */
 	  SET_DECL_IMPLICIT_INSTANTIATION (decl);
-	  gcc_assert (identifier_p (fns) || TREE_CODE (fns) == OVERLOAD);
+	  gcc_assert (identifier_p (fns) || OVL_P (fns));
 	  DECL_TEMPLATE_INFO (decl) = build_template_info (fns, args);
 	  for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
 	    if (TREE_PURPOSE (t)
-		&& TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
+		&& TREE_CODE (TREE_PURPOSE (t)) == DEFERRED_PARSE)
 	    {
-	      error_at (defarg_location (TREE_PURPOSE (t)),
+	      error_at (defparse_location (TREE_PURPOSE (t)),
 			"default arguments are not allowed in declaration "
 			"of friend template specialization %qD",
 			decl);
 	      return NULL_TREE;
 	    }
 	   t && t != void_list_node; t = TREE_CHAIN (t))
 	if (TREE_PURPOSE (t))
 	  {
 	    permerror (DECL_SOURCE_LOCATION (decl),
 		       "friend declaration of %qD specifies default "
-		       "arguments and isn't a definition", decl);
+		       "arguments and isn%'t a definition", decl);
 	    break;
 	  }
+}
+/* FIXME: For now.  */
+if (virtualp && (inlinep & 8) != 0)
+{
+sorry_at (DECL_SOURCE_LOCATION (decl),
+		"%<virtual%> %<consteval%> method %qD not supported yet",
+		decl);
+inlinep &= ~8;
 }
 /* If this decl has namespace scope, set that up.  */
 if (in_namespace)
 set_decl_namespace (decl, in_namespace, friendp);
 if (inlinep & 1)
 	error_at (declspecs->locations[ds_inline],
 		  "cannot declare %<::main%> to be inline");
 if (inlinep & 2)
 	error_at (declspecs->locations[ds_constexpr],
-		  "cannot declare %<::main%> to be %<constexpr%>");
+		  "cannot declare %<::main%> to be %qs", "constexpr");
+if (inlinep & 8)
+	error_at (declspecs->locations[ds_consteval],
+		  "cannot declare %<::main%> to be %qs", "consteval");
 if (!publicp)
 	error_at (location, "cannot declare %<::main%> to be static");
 inlinep = 0;
 publicp = 1;
 }
 if (publicp)
 	DECL_COMDAT (decl) = 1;
 }
 if (inlinep & 2)
 DECL_DECLARED_CONSTEXPR_P (decl) = true;
+else if (inlinep & 8)
+{
+DECL_DECLARED_CONSTEXPR_P (decl) = true;
+SET_DECL_IMMEDIATE_FUNCTION_P (decl);
+}
 // If the concept declaration specifier was found, check
 // that the declaration satisfies the necessary requirements.
 if (concept_p)
 {
 			    " shadowed by implementation", suffix);
 	    }
 	  else if (long_double_p)
 	    {
 	      if (cpp_interpret_float_suffix (parse_in, suffix, strlen (suffix)))
-		warning_at (location, 0, "floating point suffix %qs"
+		warning_at (location, 0, "floating-point suffix %qs"
 			    " shadowed by implementation", suffix);
 	    }
 	  /* 17.6.3.3.5  */
 	  if (suffix[0] != '_'
-	      && !in_system_header_at (location)
 	      && !current_function_decl && !(friendp && !funcdef_flag))
 	    warning_at (location, OPT_Wliteral_suffix,
 			"literal operator suffixes not preceded by %<_%>"
 			" are reserved for future standardization");
 	}
 	     int initialized,
 	     int type_quals,
 	     int inlinep,
 	     bool conceptp,
 	     int template_count,
-	     tree scope)
+	     tree scope,
+	     location_t location)
 {
 tree decl;
 tree explicit_scope;
 gcc_assert (!name || identifier_p (name));
 	  /* Similarly for static data members.  */
 	  || TYPE_P (scope)
 	  /* Similarly for explicit specializations.  */
 	  || (orig_declarator
 	      && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)))
-decl = build_lang_decl (VAR_DECL, name, type);
+decl = build_lang_decl_loc (location, VAR_DECL, name, type);
 else
-decl = build_decl (input_location, VAR_DECL, name, type);
+decl = build_decl (location, VAR_DECL, name, type);
 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
 set_decl_namespace (decl, explicit_scope, 0);
 else
 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
 DECL_INTERFACE_KNOWN (decl) = 1;
 if (DECL_NAME (decl)
 && MAIN_NAME_P (DECL_NAME (decl))
 && scope == global_namespace)
-error ("cannot declare %<::main%> to be a global variable");
+error_at (DECL_SOURCE_LOCATION (decl),
+	      "cannot declare %<::main%> to be a global variable");
 /* Check that the variable can be safely declared as a concept.
 Note that this also forbids explicit specializations.  */
 if (conceptp)
 {
 else
 DECL_DECLARED_CONCEPT_P (decl) = true;
 if (!same_type_ignoring_top_level_qualifiers_p (type, boolean_type_node))
 	error_at (declspecs->locations[ds_type_spec],
 		  "concept must have type %<bool%>");
+if (TEMPLATE_PARMS_CONSTRAINTS (current_template_parms))
+{
+error_at (location, "a variable concept cannot be constrained");
+TEMPLATE_PARMS_CONSTRAINTS (current_template_parms) = NULL_TREE;
+}
 }
 else if (flag_concepts
 	   && processing_template_decl > template_class_depth (scope))
 {
 tree reqs = TEMPLATE_PARMS_CONSTRAINTS (current_template_parms);
 tree ci = build_constraints (reqs, NULL_TREE);
 set_constraints (decl, ci);
 }
 // Handle explicit specializations and instantiations of variable templates.
 if (orig_declarator)
 /* Let the front end know this is a pointer to member function.  */
 TYPE_PTRMEMFUNC_FLAG (t) = 1;
 field = build_decl (input_location, FIELD_DECL, pfn_identifier, type);
+DECL_NONADDRESSABLE_P (field) = 1;
 fields = field;
 field = build_decl (input_location, FIELD_DECL, delta_identifier,
 		      delta_type_node);
+DECL_NONADDRESSABLE_P (field) = 1;
 DECL_CHAIN (field) = fields;
 fields = field;
 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
 tree
 fold_sizeof_expr (tree t)
 {
 tree r;
 if (SIZEOF_EXPR_TYPE_P (t))
-r = cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t, 0)),
+r = cxx_sizeof_or_alignof_type (EXPR_LOCATION (t),
+				    TREE_TYPE (TREE_OPERAND (t, 0)),
 				    SIZEOF_EXPR, false, false);
 else if (TYPE_P (TREE_OPERAND (t, 0)))
-r = cxx_sizeof_or_alignof_type (TREE_OPERAND (t, 0), SIZEOF_EXPR,
+r = cxx_sizeof_or_alignof_type (EXPR_LOCATION (t),
+				    TREE_OPERAND (t, 0), SIZEOF_EXPR,
 				    false, false);
 else
-r = cxx_sizeof_or_alignof_expr (TREE_OPERAND (t, 0), SIZEOF_EXPR,
+r = cxx_sizeof_or_alignof_expr (EXPR_LOCATION (t),
+				    TREE_OPERAND (t, 0), SIZEOF_EXPR,
 				    false);
 if (r == error_mark_node)
 r = size_one_node;
 return r;
 }
 /* Given the SIZE (i.e., number of elements) in an array, compute
 an appropriate index type for the array.  If non-NULL, NAME is
 the name of the entity being declared.  */
-tree
+static tree
-compute_array_index_type (tree name, tree size, tsubst_flags_t complain)
+compute_array_index_type_loc (location_t name_loc, tree name, tree size,
-{
+			      tsubst_flags_t complain)
-tree itype;
+{
-tree osize = size;
 if (error_operand_p (size))
 return error_mark_node;
+/* The type of the index being computed.  */
+tree itype;
+/* The original numeric size as seen in the source code before
+conversion to size_t.  */
+tree origsize = size;
+location_t loc = cp_expr_loc_or_loc (size, name ? name_loc : input_location);
 if (!type_dependent_expression_p (size))
 {
-osize = size = mark_rvalue_use (size);
+origsize = size = mark_rvalue_use (size);
 if (cxx_dialect < cxx11 && TREE_CODE (size) == NOP_EXPR
 	  && TREE_SIDE_EFFECTS (size))
 	/* In C++98, we mark a non-constant array bound with a magic
 	   NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case.  */;
 else
 	{
 	  size = instantiate_non_dependent_expr_sfinae (size, complain);
 	  size = build_converted_constant_expr (size_type_node, size, complain);
-	  size = maybe_constant_value (size);
+	  /* Pedantically a constant expression is required here and so
+	     __builtin_is_constant_evaluated () should fold to true if it
+	     is successfully folded into a constant.  */
+	  size = maybe_constant_value (size, NULL_TREE,
+				       /*manifestly_const_eval=*/true);
 	  if (!TREE_CONSTANT (size))
-	    size = osize;
+	    size = origsize;
 	}
 if (error_operand_p (size))
 	return error_mark_node;
 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
 	{
 	  if (!(complain & tf_error))
 	    return error_mark_node;
 	  if (name)
-	    error ("size of array %qD has non-integral type %qT", name, type);
+	    error_at (loc, "size of array %qD has non-integral type %qT",
+		      name, type);
 	  else
-	    error ("size of array has non-integral type %qT", type);
+	    error_at (loc, "size of array has non-integral type %qT", type);
 	  size = integer_one_node;
 	}
 }
 /* A type is dependent if it is...an array type constructed from any
 if (TREE_CODE (size) != INTEGER_CST)
 {
 tree folded = cp_fully_fold (size);
 if (TREE_CODE (folded) == INTEGER_CST)
-	pedwarn (input_location, OPT_Wpedantic,
+	{
-		 "size of array is not an integral constant-expression");
+	  if (name)
+	    pedwarn (loc, OPT_Wpedantic, "size of array %qD is not an "
+		     "integral constant-expression", name);
+	  else
+	    pedwarn (loc, OPT_Wpedantic,
+		     "size of array is not an integral constant-expression");
+	}
 /* Use the folded result for VLAs, too; it will have resolved
 	 SIZEOF_EXPR.  */
 size = folded;
 }
 /* Normally, the array-bound will be a constant.  */
 if (TREE_CODE (size) == INTEGER_CST)
 {
-/* An array must have a positive number of elements.  */
+/* The size to use in diagnostics that reflects the constant
-if (!valid_constant_size_p (size))
+	 size used in the source, rather than SIZE massaged above.  */
+tree diagsize = size;
+/* If the original size before conversion to size_t was signed
+	 and negative, convert it to ssizetype to restore the sign.  */
+if (!TYPE_UNSIGNED (TREE_TYPE (origsize))
+	  && TREE_CODE (size) == INTEGER_CST
+	  && tree_int_cst_sign_bit (size))
+	{
+	  diagsize = fold_convert (ssizetype, size);
+	  /* Clear the overflow bit that may have been set as a result
+	     of the conversion from the sizetype of the new size to
+	     ssizetype.  */
+	  TREE_OVERFLOW (diagsize) = false;
+	}
+/* Verify that the array has a positive number of elements
+	 and issue the appropriate diagnostic if it doesn't.  */
+if (!valid_array_size_p (loc, diagsize, name, (complain & tf_error)))
 	{
 	  if (!(complain & tf_error))
 	    return error_mark_node;
-	  if (name)
-	    error ("size of array %qD is negative", name);
-	  else
-	    error ("size of array is negative");
 	  size = integer_one_node;
 	}
 /* As an extension we allow zero-sized arrays.  */
 else if (integer_zerop (size))
 	{
 	  if (!(complain & tf_error))
 	    /* We must fail if performing argument deduction (as
 	       indicated by the state of complain), so that
 	       another substitution can be found.  */
 	    return error_mark_node;
-	  else if (in_system_header_at (input_location))
-	    /* Allow them in system headers because glibc uses them.  */;
 	  else if (name)
-	    pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids zero-size array %qD", name);
+	    pedwarn (loc, OPT_Wpedantic,
+		     "ISO C++ forbids zero-size array %qD", name);
 	  else
-	    pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids zero-size array");
+	    pedwarn (loc, OPT_Wpedantic,
+		     "ISO C++ forbids zero-size array");
 	}
 }
 else if (TREE_CONSTANT (size)
 	   /* We don't allow VLAs at non-function scopes, or during
 	      tentative template substitution.  */
 {
 if (!(complain & tf_error))
 	return error_mark_node;
 /* `(int) &fn' is not a valid array bound.  */
 if (name)
-	error ("size of array %qD is not an integral constant-expression",
+	error_at (loc,
-	       name);
+		  "size of array %qD is not an integral constant-expression",
+		  name);
 else
-	error ("size of array is not an integral constant-expression");
+	error_at (loc, "size of array is not an integral constant-expression");
 size = integer_one_node;
 }
 else if (pedantic && warn_vla != 0)
 {
 if (name)
-	pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array %qD", name);
+	pedwarn (name_loc, OPT_Wvla,
+		 "ISO C++ forbids variable length array %qD", name);
 else
-	pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array");
+	pedwarn (input_location, OPT_Wvla,
+		 "ISO C++ forbids variable length array");
 }
 else if (warn_vla > 0)
 {
 if (name)
-	warning (OPT_Wvla,
+	warning_at (name_loc, OPT_Wvla,
-"variable length array %qD is used", name);
+		    "variable length array %qD is used", name);
 else
 	warning (OPT_Wvla,
 "variable length array is used");
 }
 TYPE_DEPENDENT_P (itype) = 0;
 TYPE_DEPENDENT_P_VALID (itype) = 1;
 return itype;
 }
+tree
+compute_array_index_type (tree name, tree size, tsubst_flags_t complain)
+{
+return compute_array_index_type_loc (input_location, name, size, complain);
+}
 /* Returns the scope (if any) in which the entity declared by
 DECLARATOR will be located.  If the entity was declared with an
 unqualified name, NULL_TREE is returned.  */
 tree
 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
 indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
 with this type.  */
 static tree
-create_array_type_for_decl (tree name, tree type, tree size)
+create_array_type_for_decl (tree name, tree type, tree size, location_t loc)
 {
 tree itype = NULL_TREE;
 /* If things have already gone awry, bail now.  */
 if (type == error_mark_node || size == error_mark_node)
 /* 8.3.4/1: If the type of the identifier of D contains the auto
 type-specifier, the program is ill-formed.  */
 if (type_uses_auto (type))
 {
 if (name)
-error ("%qD declared as array of %qT", name, type);
+	error_at (loc, "%qD declared as array of %qT", name, type);
 else
-error ("creating array of %qT", type);
+	error ("creating array of %qT", type);
 return error_mark_node;
 }
 /* If there are some types which cannot be array elements,
 issue an error-message and return.  */
 switch (TREE_CODE (type))
 {
 case VOID_TYPE:
 if (name)
-error ("declaration of %qD as array of void", name);
+	error_at (loc, "declaration of %qD as array of void", name);
 else
 error ("creating array of void");
 return error_mark_node;
 case FUNCTION_TYPE:
 if (name)
-error ("declaration of %qD as array of functions", name);
+	error_at (loc, "declaration of %qD as array of functions", name);
 else
 error ("creating array of functions");
 return error_mark_node;
 case REFERENCE_TYPE:
 if (name)
-error ("declaration of %qD as array of references", name);
+	error_at (loc, "declaration of %qD as array of references", name);
 else
 error ("creating array of references");
 return error_mark_node;
 case METHOD_TYPE:
 if (name)
-error ("declaration of %qD as array of function members", name);
+	error_at (loc, "declaration of %qD as array of function members",
+		  name);
 else
 error ("creating array of function members");
 return error_mark_node;
 default:
 break;
 }
+if (!verify_type_context (name ? loc : input_location,
+			    TCTX_ARRAY_ELEMENT, type))
+return error_mark_node;
 /* [dcl.array]
 The constant expressions that specify the bounds of the arrays
 can be omitted only for the first member of the sequence.  */
 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
 {
 if (name)
-	error ("declaration of %qD as multidimensional array must "
+	error_at (loc, "declaration of %qD as multidimensional array must "
-	       "have bounds for all dimensions except the first",
+		  "have bounds for all dimensions except the first",
-	       name);
+		  name);
 else
 	error ("multidimensional array must have bounds for all "
 	       "dimensions except the first");
 return error_mark_node;
 }
 /* Figure out the index type for the array.  */
 if (size)
-itype = compute_array_index_type (name, size, tf_warning_or_error);
+itype = compute_array_index_type_loc (loc, name, size,
+					  tf_warning_or_error);
 /* [dcl.array]
 T is called the array element type; this type shall not be [...] an
 abstract class type.  */
 abstract_virtuals_error (name, type);
 if (type_quals & TYPE_QUAL_RESTRICT)
 loc = min_location (loc, locations[ds_restrict]);
 return loc;
+}
+/* Returns the smallest among the latter and locations[ds_type_spec].  */
+static location_t
+smallest_type_location (int type_quals, const location_t* locations)
+{
+location_t loc = smallest_type_quals_location (type_quals, locations);
+return min_location (loc, locations[ds_type_spec]);
+}
+static location_t
+smallest_type_location (const cp_decl_specifier_seq *declspecs)
+{
+int type_quals = get_type_quals (declspecs);
+return smallest_type_location (type_quals, declspecs->locations);
 }
 /* Check that it's OK to declare a function with the indicated TYPE
 and TYPE_QUALS.  SFK indicates the kind of special function (if any)
 that this function is.  OPTYPE is the type given in a conversion
 {
 switch (sfk)
 {
 case sfk_constructor:
 if (type)
-	error ("return type specification for constructor invalid");
+	error_at (smallest_type_location (type_quals, locations),
+		  "return type specification for constructor invalid");
 else if (type_quals != TYPE_UNQUALIFIED)
 	error_at (smallest_type_quals_location (type_quals, locations),
 		  "qualifiers are not allowed on constructor declaration");
 if (targetm.cxx.cdtor_returns_this ())
 	type = void_type_node;
 break;
 case sfk_destructor:
 if (type)
-	error ("return type specification for destructor invalid");
+	error_at (smallest_type_location (type_quals, locations),
+		  "return type specification for destructor invalid");
 else if (type_quals != TYPE_UNQUALIFIED)
 	error_at (smallest_type_quals_location (type_quals, locations),
 		  "qualifiers are not allowed on destructor declaration");
 /* We can't use the proper return type here because we run into
 	type = void_type_node;
 break;
 case sfk_conversion:
 if (type)
-	error ("return type specified for %<operator %T%>", optype);
+	error_at (smallest_type_location (type_quals, locations),
+		  "return type specified for %<operator %T%>", optype);
 else if (type_quals != TYPE_UNQUALIFIED)
 	error_at (smallest_type_quals_location (type_quals, locations),
 		  "qualifiers are not allowed on declaration of "
 		  "%<operator %T%>", optype);
 type = optype;
 break;
 case sfk_deduction_guide:
 if (type)
-	error ("return type specified for deduction guide");
+	error_at (smallest_type_location (type_quals, locations),
+		  "return type specified for deduction guide");
 else if (type_quals != TYPE_UNQUALIFIED)
 	error_at (smallest_type_quals_location (type_quals, locations),
 		  "qualifiers are not allowed on declaration of "
 		  "deduction guide");
 if (TREE_CODE (optype) == TEMPLATE_TEMPLATE_PARM)
 else
 	type = make_template_placeholder (CLASSTYPE_TI_TEMPLATE (optype));
 for (int i = 0; i < ds_last; ++i)
 	if (i != ds_explicit && locations[i])
 	  error_at (locations[i],
-		    "decl-specifier in declaration of deduction guide");
+		    "%<decl-specifier%> in declaration of deduction guide");
 break;
 default:
 gcc_unreachable ();
 }
 has been declared with the indicated TYPE.  If the TYPE is not
 acceptable, issue an error message and return a type to use for
 error-recovery purposes.  */
 tree
-check_var_type (tree identifier, tree type)
+check_var_type (tree identifier, tree type, location_t loc)
 {
 if (VOID_TYPE_P (type))
 {
 if (!identifier)
-	error ("unnamed variable or field declared void");
+	error_at (loc, "unnamed variable or field declared void");
 else if (identifier_p (identifier))
 	{
 	  gcc_assert (!IDENTIFIER_ANY_OP_P (identifier));
-	  error ("variable or field %qE declared void", identifier);
+	  error_at (loc, "variable or field %qE declared void",
+		    identifier);
 	}
 else
-	error ("variable or field declared void");
+	error_at (loc, "variable or field declared void");
 type = error_mark_node;
 }
 return type;
 }
 		"%qD declared at block scope", decl);
 inlinep = false;
 }
 else if (cxx_dialect < cxx17)
 pedwarn (loc, 0, "inline variables are only available "
-	     "with -std=c++17 or -std=gnu++17");
+	     "with %<-std=c++17%> or %<-std=gnu++17%>");
 if (inlinep)
 {
 retrofit_lang_decl (decl);
 SET_DECL_VAR_DECLARED_INLINE_P (decl);
 }
 {
 gcc_assert (TYPE_UNNAMED_P (type));
 /* Replace the anonymous name with the real name everywhere.  */
 for (tree t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
-{
+if (IDENTIFIER_ANON_P (TYPE_IDENTIFIER (t)))
-if (anon_aggrname_p (TYPE_IDENTIFIER (t)))
+/* We do not rename the debug info representing the unnamed
-	/* We do not rename the debug info representing the
+	 tagged type because the standard says in [dcl.typedef] that
-	   unnamed tagged type because the standard says in
+	 the naming applies only for linkage purposes.  */
-	   [dcl.typedef] that the naming applies only for
+/*debug_hooks->set_name (t, decl);*/
-	   linkage purposes.  */
+TYPE_NAME (t) = decl;
-	/*debug_hooks->set_name (t, decl);*/
-	TYPE_NAME (t) = decl;
-}
-if (TYPE_LANG_SPECIFIC (type))
-TYPE_WAS_UNNAMED (type) = 1;
 /* If this is a typedef within a template class, the nested
 type is a (non-primary) template.  The name for the
 template needs updating as well.  */
 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
 		tree* attrlist)
 {
 tree type = NULL_TREE;
 int longlong = 0;
 int explicit_intN = 0;
+int int_n_alt = 0;
 int virtualp, explicitp, friendp, inlinep, staticp;
 int explicit_int = 0;
 int explicit_char = 0;
 int defaulted_int = 0;
 cp_virt_specifiers virt_specifiers = VIRT_SPEC_UNSPECIFIED;
 /* ref-qualifier that applies to the declarator, for a declaration of
 a member function.  */
 cp_ref_qualifier rqual = REF_QUAL_NONE;
 /* cv-qualifiers that apply to the type specified by the DECLSPECS.  */
-int type_quals = TYPE_UNQUALIFIED;
+int type_quals = get_type_quals (declspecs);
 tree raises = NULL_TREE;
 int template_count = 0;
 tree returned_attrs = NULL_TREE;
 tree parms = NULL_TREE;
 const cp_declarator *id_declarator;
 bool parameter_pack_p = declarator ? declarator->parameter_pack_p : false;
 bool template_type_arg = false;
 bool template_parm_flag = false;
 bool typedef_p = decl_spec_seq_has_spec_p (declspecs, ds_typedef);
 bool constexpr_p = decl_spec_seq_has_spec_p (declspecs, ds_constexpr);
+bool constinit_p = decl_spec_seq_has_spec_p (declspecs, ds_constinit);
+bool consteval_p = decl_spec_seq_has_spec_p (declspecs, ds_consteval);
 bool late_return_type_p = false;
 bool array_parameter_p = false;
-source_location saved_loc = input_location;
 tree reqs = NULL_TREE;
 signed_p = decl_spec_seq_has_spec_p (declspecs, ds_signed);
 unsigned_p = decl_spec_seq_has_spec_p (declspecs, ds_unsigned);
 short_p = decl_spec_seq_has_spec_p (declspecs, ds_short);
 long_p = decl_spec_seq_has_spec_p (declspecs, ds_long);
 longlong = decl_spec_seq_has_spec_p (declspecs, ds_long_long);
 explicit_intN = declspecs->explicit_intN_p;
+int_n_alt = declspecs->int_n_alt;
 thread_p = decl_spec_seq_has_spec_p (declspecs, ds_thread);
 // Was concept_p specified? Note that ds_concept
 // implies ds_constexpr!
 bool concept_p = decl_spec_seq_has_spec_p (declspecs, ds_concept);
 if (concept_p)
 constexpr_p = true;
-if (decl_spec_seq_has_spec_p (declspecs, ds_const))
-type_quals |= TYPE_QUAL_CONST;
-if (decl_spec_seq_has_spec_p (declspecs, ds_volatile))
-type_quals |= TYPE_QUAL_VOLATILE;
-if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
-type_quals |= TYPE_QUAL_RESTRICT;
 if (decl_context == FUNCDEF)
 funcdef_flag = true, decl_context = NORMAL;
 else if (decl_context == MEMFUNCDEF)
 funcdef_flag = true, decl_context = FIELD;
 template_parm_flag = true, decl_context = PARM;
 if (initialized > 1)
 funcdef_flag = true;
-location_t typespec_loc = smallest_type_quals_location (type_quals,
+location_t typespec_loc = smallest_type_location (type_quals,
-						      declspecs->locations);
+						    declspecs->locations);
-if (typespec_loc == UNKNOWN_LOCATION)
-typespec_loc = declspecs->locations[ds_type_spec];
 if (typespec_loc == UNKNOWN_LOCATION)
 typespec_loc = input_location;
+location_t id_loc = declarator ? declarator->id_loc : input_location;
+if (id_loc == UNKNOWN_LOCATION)
+id_loc = input_location;
 /* Look inside a declarator for the name being declared
 and get it as a string, for an error message.  */
 for (id_declarator = declarator;
 id_declarator;
 		else if (TYPE_P (qualifying_scope))
 		  {
 		    ctype = qualifying_scope;
 		    if (!MAYBE_CLASS_TYPE_P (ctype))
 		      {
-			error ("%q#T is not a class or a namespace", ctype);
+			error_at (id_declarator->id_loc,
+				  "%q#T is not a class or namespace", ctype);
 			ctype = NULL_TREE;
 		      }
 		    else if (innermost_code != cdk_function
 			     && current_class_type
 			     && !uniquely_derived_from_p (ctype,
 							  current_class_type))
 		      {
-			error ("invalid use of qualified-name %<%T::%D%>",
+			error_at (id_declarator->id_loc,
-			       qualifying_scope, decl);
+				  "invalid use of qualified-name %<%T::%D%>",
+				  qualifying_scope, decl);
 			return error_mark_node;
 		      }
 		  }
 		else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
 		  in_namespace = qualifying_scope;
 	      {
 	      case BIT_NOT_EXPR:
 		{
 		  if (innermost_code != cdk_function)
 		    {
-		      error ("declaration of %qD as non-function", decl);
+		      error_at (EXPR_LOCATION (decl),
+				"declaration of %qE as non-function", decl);
 		      return error_mark_node;
 		    }
 		  else if (!qualifying_scope
 			   && !(current_class_type && at_class_scope_p ()))
 		    {
-		      error ("declaration of %qD as non-member", decl);
+		      error_at (EXPR_LOCATION (decl),
+				"declaration of %qE as non-member", decl);
 		      return error_mark_node;
 		    }
 		  tree type = TREE_OPERAND (decl, 0);
 		  if (TYPE_P (type))
 The declarator in a function-definition shall have the form
 D1 ( parameter-declaration-clause) ...  */
 if (funcdef_flag && innermost_code != cdk_function)
 {
-error ("function definition does not declare parameters");
+error_at (id_loc, "function definition does not declare parameters");
 return error_mark_node;
 }
 if (flags == TYPENAME_FLAG
 && innermost_code != cdk_function
 && ! (ctype && !declspecs->any_specifiers_p))
 {
-error ("declaration of %qD as non-function", dname);
+error_at (id_loc, "declaration of %qD as non-function", dname);
 return error_mark_node;
 }
 if (dname && identifier_p (dname))
 {
 if (UDLIT_OPER_P (dname)
 	  && innermost_code != cdk_function)
 	{
-	  error ("declaration of %qD as non-function", dname);
+	  error_at (id_loc, "declaration of %qD as non-function", dname);
 	  return error_mark_node;
 	}
 if (IDENTIFIER_ANY_OP_P (dname))
 	{
 	  if (typedef_p)
 	    {
-	      error ("declaration of %qD as %<typedef%>", dname);
+	      error_at (id_loc, "declaration of %qD as %<typedef%>", dname);
 	      return error_mark_node;
 	    }
 	  else if (decl_context == PARM || decl_context == CATCHPARM)
 	    {
-	      error ("declaration of %qD as parameter", dname);
+	      error_at (id_loc, "declaration of %qD as parameter", dname);
 	      return error_mark_node;
 	    }
 	}
 }
 }
 if (name == NULL)
 name = decl_context == PARM ? "parameter" : "type name";
+if (consteval_p && constexpr_p)
+{
+error_at (declspecs->locations[ds_consteval],
+		"both %qs and %qs specified", "constexpr", "consteval");
+return error_mark_node;
+}
 if (concept_p && typedef_p)
 {
 error_at (declspecs->locations[ds_concept],
-		"%<concept%> cannot appear in a typedef declaration");
+		"%qs cannot appear in a typedef declaration", "concept");
 return error_mark_node;
 }
 if (constexpr_p && typedef_p)
 {
 error_at (declspecs->locations[ds_constexpr],
-		"%<constexpr%> cannot appear in a typedef declaration");
+		"%qs cannot appear in a typedef declaration", "constexpr");
+return error_mark_node;
+}
+if (consteval_p && typedef_p)
+{
+error_at (declspecs->locations[ds_consteval],
+		"%qs cannot appear in a typedef declaration", "consteval");
+return error_mark_node;
+}
+if (constinit_p && typedef_p)
+{
+error_at (declspecs->locations[ds_constinit],
+		"%<constinit%> cannot appear in a typedef declaration");
+return error_mark_node;
+}
+/* [dcl.spec]/2 "At most one of the constexpr, consteval, and constinit
+keywords shall appear in a decl-specifier-seq."  */
+if (constinit_p && constexpr_p)
+{
+gcc_rich_location richloc (declspecs->locations[ds_constinit]);
+richloc.add_range (declspecs->locations[ds_constexpr]);
+error_at (&richloc,
+		"can use at most one of the %<constinit%> and %<constexpr%> "
+		"specifiers");
 return error_mark_node;
 }
 /* If there were multiple types specified in the decl-specifier-seq,
 issue an error message.  */
 if (declspecs->multiple_types_p)
 {
-error ("two or more data types in declaration of %qs", name);
+error_at (typespec_loc,
+		"two or more data types in declaration of %qs", name);
 return error_mark_node;
 }
 if (declspecs->conflicting_specifiers_p)
 {
-error ("conflicting specifiers in declaration of %qs", name);
+error_at (min_location (declspecs->locations[ds_typedef],
+			      declspecs->locations[ds_storage_class]),
+		"conflicting specifiers in declaration of %qs", name);
 return error_mark_node;
 }
 /* Extract the basic type from the decl-specifier-seq.  */
 type = declspecs->type;
 type_was_error_mark_node = true;
 }
 cp_warn_deprecated_use (type);
 if (type && TREE_CODE (type) == TYPE_DECL)
 {
+cp_warn_deprecated_use_scopes (CP_DECL_CONTEXT (type));
 typedef_decl = type;
 type = TREE_TYPE (typedef_decl);
 if (DECL_ARTIFICIAL (typedef_decl))
 	cp_warn_deprecated_use (type);
 }
 		 && in_namespace == NULL_TREE
 		 && current_namespace == global_namespace);
 if (type_was_error_mark_node)
 	/* We've already issued an error, don't complain more.  */;
-else if (in_system_header_at (input_location) || flag_ms_extensions)
+else if (in_system_header_at (id_loc) || flag_ms_extensions)
 	/* Allow it, sigh.  */;
 else if (! is_main)
-	permerror (input_location, "ISO C++ forbids declaration of %qs with no type", name);
+	permerror (id_loc, "ISO C++ forbids declaration of %qs with no type",
+		   name);
 else if (pedantic)
-	pedwarn (input_location, OPT_Wpedantic,
+	pedwarn (id_loc, OPT_Wpedantic,
 		 "ISO C++ forbids declaration of %qs with no type", name);
 else
-	warning (OPT_Wreturn_type,
+	warning_at (id_loc, OPT_Wreturn_type,
-		 "ISO C++ forbids declaration of %qs with no type", name);
+		    "ISO C++ forbids declaration of %qs with no type", name);
 if (type_was_error_mark_node && template_parm_flag)
 	/* FIXME we should be able to propagate the error_mark_node as is
 	   for other contexts too.  */
 	type = error_mark_node;
 if (explicit_intN)
 {
 if (! int_n_enabled_p[declspecs->int_n_idx])
 	{
-	  error ("%<__int%d%> is not supported by this target",
+	  error_at (declspecs->locations[ds_type_spec],
-		 int_n_data[declspecs->int_n_idx].bitsize);
+		    "%<__int%d%> is not supported by this target",
+		    int_n_data[declspecs->int_n_idx].bitsize);
 	  explicit_intN = false;
 	}
-else if (pedantic && ! in_system_header_at (input_location))
+/* Don't pedwarn if the alternate "__intN__" form has been used instead
-	pedwarn (input_location, OPT_Wpedantic,
+	 of "__intN".  */
+else if (!int_n_alt && pedantic)
+	pedwarn (declspecs->locations[ds_type_spec], OPT_Wpedantic,
 		 "ISO C++ does not support %<__int%d%> for %qs",
 		 int_n_data[declspecs->int_n_idx].bitsize, name);
 }
 /* Now process the modifiers that were specified
 	  gcc_rich_location richloc (declspecs->locations[ds_long]);
 	  richloc.add_range (declspecs->locations[ds_short]);
 	  error_at (&richloc, "%<long%> and %<short%> specified together");
 	}
 else if (TREE_CODE (type) != INTEGER_TYPE
-	       || type == char16_type_node || type == char32_type_node
+	       || type == char8_type_node
+	       || type == char16_type_node
+	       || type == char32_type_node
 	       || ((long_p || short_p)
 		   && (explicit_char || explicit_intN)))
 	error_at (loc, "%qs specified with %qT", key, type);
 else if (!explicit_int && !defaulted_int
 	       && !explicit_char && !explicit_intN)
 type = short_integer_type_node;
 if (decl_spec_seq_has_spec_p (declspecs, ds_complex))
 {
 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
-	error ("complex invalid for %qs", name);
+	error_at (declspecs->locations[ds_complex],
+		  "complex invalid for %qs", name);
 /* If a modifier is specified, the resulting complex is the complex
 	 form of TYPE.  E.g, "complex short" is "complex short int".  */
 else if (type == integer_type_node)
 	type = complex_integer_type_node;
 else if (type == float_type_node)
 if (tree tmpl = CLASS_PLACEHOLDER_TEMPLATE (type))
 {
 error_at (typespec_loc, "template placeholder type %qT must be followed "
 		"by a simple declarator-id", type);
 inform (DECL_SOURCE_LOCATION (tmpl), "%qD declared here", tmpl);
+type = error_mark_node;
 }
 staticp = 0;
 inlinep = decl_spec_seq_has_spec_p (declspecs, ds_inline);
 virtualp =  decl_spec_seq_has_spec_p (declspecs, ds_virtual);
 if (constexpr_p && cxx_dialect < cxx2a)
 	{
 	  gcc_rich_location richloc (declspecs->locations[ds_virtual]);
 	  richloc.add_range (declspecs->locations[ds_constexpr]);
 	  pedwarn (&richloc, OPT_Wpedantic, "member %qD can be declared both "
-		   "%<virtual%> and %<constexpr%> only in -std=c++2a or "
+		   "%<virtual%> and %<constexpr%> only in %<-std=c++2a%> or "
-		   "-std=gnu++2a", dname);
+		   "%<-std=gnu++2a%>", dname);
 	}
 }
 friendp = decl_spec_seq_has_spec_p (declspecs, ds_friend);
 /* Issue errors about use of storage classes for parameters.  */
 	  return error_mark_node;
 	}
 /* Function parameters cannot be concept. */
 if (concept_p)
-	error_at (declspecs->locations[ds_concept],
+	{
-		  "a parameter cannot be declared %<concept%>");
+	  error_at (declspecs->locations[ds_concept],
+		    "a parameter cannot be declared %qs", "concept");
+	  concept_p = 0;
+	  constexpr_p = 0;
+	}
 /* Function parameters cannot be constexpr.  If we saw one, moan
 and pretend it wasn't there.  */
 else if (constexpr_p)
 {
 error_at (declspecs->locations[ds_constexpr],
-		    "a parameter cannot be declared %<constexpr%>");
+		    "a parameter cannot be declared %qs", "constexpr");
 constexpr_p = 0;
 }
+if (constinit_p)
+	{
+	  error_at (declspecs->locations[ds_constinit],
+		    "a parameter cannot be declared %qs", "constinit");
+	  constinit_p = 0;
+	}
+if (consteval_p)
+	{
+	  error_at (declspecs->locations[ds_consteval],
+		    "a parameter cannot be declared %qs", "consteval");
+	  consteval_p = 0;
+	}
 }
 /* Give error if `virtual' is used outside of class declaration.  */
 if (virtualp
 && (current_class_name == NULL_TREE || decl_context != FIELD))
 {
 location_t loc = (declarator->kind == cdk_reference
 			? declarator->declarator->id_loc : declarator->id_loc);
 if (inlinep)
 	error_at (declspecs->locations[ds_inline],
-		  "structured binding declaration cannot be %<inline%>");
+		  "structured binding declaration cannot be %qs", "inline");
 if (typedef_p)
 	error_at (declspecs->locations[ds_typedef],
-		  "structured binding declaration cannot be %<typedef%>");
+		  "structured binding declaration cannot be %qs", "typedef");
-if (constexpr_p)
+if (constexpr_p && !concept_p)
 	error_at (declspecs->locations[ds_constexpr], "structured "
-		  "binding declaration cannot be %<constexpr%>");
+		  "binding declaration cannot be %qs", "constexpr");
-if (thread_p)
+if (consteval_p)
-	error_at (declspecs->locations[ds_thread],
+	error_at (declspecs->locations[ds_consteval], "structured "
-		  "structured binding declaration cannot be %qs",
+		  "binding declaration cannot be %qs", "consteval");
-		  declspecs->gnu_thread_keyword_p
+if (thread_p && cxx_dialect < cxx2a)
-		  ? "__thread" : "thread_local");
+	pedwarn (declspecs->locations[ds_thread], 0,
+		 "structured binding declaration can be %qs only in "
+		 "%<-std=c++2a%> or %<-std=gnu++2a%>",
+		 declspecs->gnu_thread_keyword_p
+		 ? "__thread" : "thread_local");
 if (concept_p)
 	error_at (declspecs->locations[ds_concept],
-		  "structured binding declaration cannot be %<concept%>");
+		  "structured binding declaration cannot be %qs", "concept");
+/* [dcl.struct.bind] "A cv that includes volatile is deprecated."  */
+if (type_quals & TYPE_QUAL_VOLATILE)
+	warning_at (declspecs->locations[ds_volatile], OPT_Wvolatile,
+		    "%<volatile%>-qualified structured binding is deprecated");
 switch (storage_class)
 	{
 	case sc_none:
 	  break;
 	case sc_register:
-	  error_at (loc, "structured binding declaration cannot be "
+	  error_at (loc, "structured binding declaration cannot be %qs",
-		    "%<register%>");
+		    "register");
 	  break;
 	case sc_static:
-	  error_at (loc, "structured binding declaration cannot be "
+	  if (cxx_dialect < cxx2a)
-		    "%<static%>");
+	    pedwarn (loc, 0,
+		     "structured binding declaration can be %qs only in "
+		     "%<-std=c++2a%> or %<-std=gnu++2a%>", "static");
 	  break;
 	case sc_extern:
-	  error_at (loc, "structured binding declaration cannot be "
+	  error_at (loc, "structured binding declaration cannot be %qs",
-		    "%<extern%>");
+		    "extern");
 	  break;
 	case sc_mutable:
-	  error_at (loc, "structured binding declaration cannot be "
+	  error_at (loc, "structured binding declaration cannot be %qs",
-		    "%<mutable%>");
+		    "mutable");
 	  break;
 	case sc_auto:
 	  error_at (loc, "structured binding declaration cannot be "
 		    "C++98 %<auto%>");
 	  break;
 	  declspecs->type = type;
 	}
 inlinep = 0;
 typedef_p = 0;
 constexpr_p = 0;
-thread_p = 0;
+consteval_p = 0;
 concept_p = 0;
-storage_class = sc_none;
+if (storage_class != sc_static)
-staticp = 0;
+	{
-declspecs->storage_class = sc_none;
+	  storage_class = sc_none;
-declspecs->locations[ds_thread] = UNKNOWN_LOCATION;
+	  declspecs->storage_class = sc_none;
+	}
 }
 /* Static anonymous unions are dealt with here.  */
 if (staticp && decl_context == TYPENAME
 && declspecs->type
 && ((storage_class
 	   && storage_class != sc_extern
 	   && storage_class != sc_static)
 	  || typedef_p))
 {
-error ("multiple storage classes in declaration of %qs", name);
+location_t loc
+	= min_location (declspecs->locations[ds_thread],
+			declspecs->locations[ds_storage_class]);
+error_at (loc, "multiple storage classes in declaration of %qs", name);
 thread_p = false;
 }
 if (decl_context != NORMAL
 && ((storage_class != sc_none
 	   && storage_class != sc_mutable)
 	   && ! toplevel_bindings_p ())
 error ("nested function %qs declared %<extern%>", name);
 else if (toplevel_bindings_p ())
 {
 if (storage_class == sc_auto)
-	error ("top-level declaration of %qs specifies %<auto%>", name);
+	error_at (declspecs->locations[ds_storage_class],
+		  "top-level declaration of %qs specifies %<auto%>", name);
 }
 else if (thread_p
 	   && storage_class != sc_extern
 	   && storage_class != sc_static)
 {
 switch (declarator->kind)
 	{
 	case cdk_array:
 	  type = create_array_type_for_decl (dname, type,
-					     declarator->u.array.bounds);
+					     declarator->u.array.bounds,
-	  if (!valid_array_size_p (input_location, type, dname))
+					     declarator->id_loc);
+	  if (!valid_array_size_p (dname
+				   ? declarator->id_loc : input_location,
+				   type, dname))
 	    type = error_mark_node;
 	  if (declarator->std_attributes)
 	    /* [dcl.array]/1:
 	    tree arg_types;
 	    int funcdecl_p;
 	    /* Declaring a function type.  */
-	    input_location = declspecs->locations[ds_type_spec];
+	    {
-	    abstract_virtuals_error (ACU_RETURN, type);
+	      iloc_sentinel ils (declspecs->locations[ds_type_spec]);
-	    input_location = saved_loc;
+	      abstract_virtuals_error (ACU_RETURN, type);
+	    }
 	    /* Pick up type qualifiers which should be applied to `this'.  */
 	    memfn_quals = declarator->u.function.qualifiers;
 	    /* Pick up virt-specifiers.  */
 virt_specifiers = declarator->u.function.virt_specifiers;
 			if (current_class_type
 			    && LAMBDA_TYPE_P (current_class_type))
 			  /* OK for C++11 lambdas.  */;
 			else if (cxx_dialect < cxx14)
 			  {
-			    error ("%qs function uses "
+			    error_at (typespec_loc, "%qs function uses "
-				   "%<auto%> type specifier without trailing "
+				      "%<auto%> type specifier without "
-				   "return type", name);
+				      "trailing return type", name);
-			    inform (input_location, "deduced return type "
+			    inform (typespec_loc,
-				    "only available with -std=c++14 or "
+				    "deduced return type only available "
-				    "-std=gnu++14");
+				    "with %<-std=c++14%> or %<-std=gnu++14%>");
 			  }
 			else if (virtualp)
 			  {
-			    error ("virtual function cannot "
+			    error_at (typespec_loc, "virtual function "
-				   "have deduced return type");
+				      "cannot have deduced return type");
 			    virtualp = false;
 			  }
 		      }
 		    else if (!is_auto (type) && sfk != sfk_conversion)
 		      {
-			error ("%qs function with trailing return type has"
+			error_at (typespec_loc, "%qs function with trailing "
-			       " %qT as its type rather than plain %<auto%>",
+				  "return type has %qT as its type rather "
-			       name, type);
+				  "than plain %<auto%>", name, type);
 			return error_mark_node;
 		      }
 		    else if (is_auto (type) && AUTO_IS_DECLTYPE (type))
 		      {
 			if (funcdecl_p)
-			  error ("%qs function with trailing return type has "
+			  error_at (typespec_loc,
-				 "%<decltype(auto)%> as its type rather than "
+				    "%qs function with trailing return type "
-				 "plain %<auto%>", name);
+				    "has %<decltype(auto)%> as its type "
+				    "rather than plain %<auto%>", name);
 			else
-			  error ("invalid use of %<decltype(auto)%>");
+			  error_at (typespec_loc,
+				    "invalid use of %<decltype(auto)%>");
 			return error_mark_node;
 		      }
 		    tree tmpl = CLASS_PLACEHOLDER_TEMPLATE (auto_node);
 		    if (!tmpl)
 		      if (tree late_auto = type_uses_auto (late_return_type))
 			tmpl = CLASS_PLACEHOLDER_TEMPLATE (late_auto);
-		    if (tmpl)
+		    if (tmpl && funcdecl_p)
 		      {
 			if (!dguide_name_p (unqualified_id))
 			  {
 			    error_at (declarator->id_loc, "deduced class "
 				      "type %qD in function return type",
 		      }
 		  }
 		else if (late_return_type
 			 && sfk != sfk_conversion)
 		  {
+		    if (late_return_type == error_mark_node)
+		      return error_mark_node;
 		    if (cxx_dialect < cxx11)
 		      /* Not using maybe_warn_cpp0x because this should
 			 always be an error.  */
-		      error ("trailing return type only available with "
+		      error_at (typespec_loc,
-			     "-std=c++11 or -std=gnu++11");
+				"trailing return type only available "
+				"with %<-std=c++11%> or %<-std=gnu++11%>");
 		    else
-		      error ("%qs function with trailing return type not "
+		      error_at (typespec_loc, "%qs function with trailing "
-			     "declared with %<auto%> type specifier", name);
+				"return type not declared with %<auto%> "
+				"type specifier", name);
 		    return error_mark_node;
 		  }
 	      }
 	    type = splice_late_return_type (type, late_return_type);
 	    if (type == error_mark_node)
 	    if (type_quals != TYPE_UNQUALIFIED)
 	      {
 		if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type))
 		  warning_at (typespec_loc, OPT_Wignored_qualifiers, "type "
 			      "qualifiers ignored on function return type");
+		/* [dcl.fct] "A volatile-qualified return type is
+		   deprecated."  */
+		if (type_quals & TYPE_QUAL_VOLATILE)
+		  warning_at (typespec_loc, OPT_Wvolatile,
+			      "%<volatile%>-qualified return type is "
+			      "deprecated");
 		/* We now know that the TYPE_QUALS don't apply to the
 		   decl, but to its return type.  */
 		type_quals = TYPE_UNQUALIFIED;
 	      }
 	      {
 		error_at (typespec_loc, "%qs declared as function returning "
 			  "an array", name);
 		return error_mark_node;
 	      }
+	    if (constinit_p)
+	      {
+		error_at (declspecs->locations[ds_constinit],
+			  "%<constinit%> on function return type is not "
+			  "allowed");
+		return error_mark_node;
+	      }
+	    /* Only plain decltype(auto) is allowed.  */
+	    if (tree a = type_uses_auto (type))
+	      {
+		if (AUTO_IS_DECLTYPE (a) && a != type)
+		  {
+		    error_at (typespec_loc, "%qT as type rather than "
+			      "plain %<decltype(auto)%>", type);
+		    return error_mark_node;
+		  }
+	      }
 	    if (ctype == NULL_TREE
 		&& decl_context == FIELD
 		&& funcdecl_p
 		&& friendp == 0)
 		   ISO C++ 12.1.  A constructor may not be declared
 		   const or volatile.  A constructor may not be
 		   virtual.  A constructor may not be static.
 		   A constructor may not be declared with ref-qualifier. */
 		if (staticp == 2)
-		  error ((flags == DTOR_FLAG)
+		  error_at (declspecs->locations[ds_storage_class],
-			 ? G_("destructor cannot be static member function")
+			    (flags == DTOR_FLAG)
-			 : G_("constructor cannot be static member function"));
+			    ? G_("destructor cannot be static member "
+				 "function")
+			    : G_("constructor cannot be static member "
+				 "function"));
 		if (memfn_quals)
 		  {
 		    error ((flags == DTOR_FLAG)
 			   ? G_("destructors may not be cv-qualified")
 			   : G_("constructors may not be cv-qualified"));
 		    richloc.add_range (declspecs->locations[ds_friend]);
 		    error_at (&richloc, "virtual functions cannot be friends");
 		    friendp = 0;
 		  }
 		if (decl_context == NORMAL)
-		  error ("friend declaration not in class definition");
+		  error_at (declarator->id_loc,
+			    "friend declaration not in class definition");
 		if (current_function_decl && funcdef_flag)
 		  {
-		    error ("can%'t define friend function %qs in a local "
+		    error_at (declarator->id_loc,
-			   "class definition", name);
+			      "cannot define friend function %qs in a local "
+			      "class definition", name);
 		    friendp = 0;
+		  }
+		/* [class.friend]/6: A function can be defined in a friend
+		   declaration if the function name is unqualified.  */
+		if (funcdef_flag && in_namespace)
+		  {
+		    if (in_namespace == global_namespace)
+		      error_at (declarator->id_loc,
+				"friend function definition %qs cannot have "
+				"a name qualified with %<::%>", name);
+		    else
+		      error_at (declarator->id_loc,
+				"friend function definition %qs cannot have "
+				"a name qualified with %<%D::%>", name,
+				in_namespace);
 		  }
 	      }
 	    else if (ctype && sfk == sfk_conversion)
 	      {
 		if (explicitp == 1)
 	    if (inner_declarator
 		&& inner_declarator->kind == cdk_id
 		&& inner_declarator->u.id.sfk == sfk_destructor
 		&& arg_types != void_list_node)
 	      {
-		error ("destructors may not have parameters");
+		error_at (declarator->id_loc,
+			  "destructors may not have parameters");
 		arg_types = void_list_node;
 		parms = NULL_TREE;
 	      }
 	    type = build_function_type (type, arg_types);
 	    if (attrs)
 	      /* [dcl.fct]/2:
 		 The optional attribute-specifier-seq appertains to
 		 the function type.  */
-	      decl_attributes (&type, attrs, 0);
+	      cplus_decl_attributes (&type, attrs, 0);
 	    if (raises)
 	      type = build_exception_variant (type, raises);
 	  }
 	  break;
 	default:
 	  gcc_unreachable ();
 	}
 }
+id_loc = declarator ? declarator->id_loc : input_location;
 /* A `constexpr' specifier used in an object declaration declares
 the object as `const'.  */
 if (constexpr_p && innermost_code != cdk_function)
 {
 /* DR1688 says that a `constexpr' specifier in combination with
 	  type = cp_build_qualified_type (type, type_quals);
 	}
 }
 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
-&& TREE_CODE (type) != FUNCTION_TYPE
+&& !FUNC_OR_METHOD_TYPE_P (type)
-&& TREE_CODE (type) != METHOD_TYPE
 && !variable_template_p (TREE_OPERAND (unqualified_id, 0)))
 {
 error ("template-id %qD used as a declarator",
 	     unqualified_id);
 unqualified_id = dname;
 if (ctype == current_class_type)
 	{
 	  if (friendp)
 	    {
-	      permerror (input_location, "member functions are implicitly "
+	      permerror (declspecs->locations[ds_friend],
-					 "friends of their class");
+			 "member functions are implicitly "
+			 "friends of their class");
 	      friendp = 0;
 	    }
 	  else
-	    permerror (declarator->id_loc,
+	    permerror (id_loc, "extra qualification %<%T::%> on member %qs",
-		       "extra qualification %<%T::%> on member %qs",
 		       ctype, name);
 	}
 else if (/* If the qualifying type is already complete, then we
 		  can skip the following checks.  */
 	       !COMPLETE_TYPE_P (ctype)
 else if (TREE_CODE (type) == FUNCTION_TYPE)
 	{
 	  if (current_class_type
 	      && (!friendp || funcdef_flag || initialized))
 	    {
-	      error (funcdef_flag || initialized
+	      error_at (id_loc, funcdef_flag || initialized
-		     ? G_("cannot define member function %<%T::%s%> "
+			? G_("cannot define member function %<%T::%s%> "
-			  "within %qT")
+			     "within %qT")
-		     : G_("cannot declare member function %<%T::%s%> "
+			: G_("cannot declare member function %<%T::%s%> "
-			  "within %qT"),
+			     "within %qT"),
-		     ctype, name, current_class_type);
+			ctype, name, current_class_type);
 	      return error_mark_node;
 	    }
 	}
 else if (typedef_p && current_class_type)
 	{
-	  error ("cannot declare member %<%T::%s%> within %qT",
+	  error_at (id_loc, "cannot declare member %<%T::%s%> within %qT",
-		 ctype, name, current_class_type);
+		    ctype, name, current_class_type);
 	  return error_mark_node;
 	}
 }
 if (ctype == NULL_TREE && decl_context == FIELD && friendp == 0)
 if ((decl_context == FIELD || decl_context == PARM)
 && !processing_template_decl
 && variably_modified_type_p (type, NULL_TREE))
 {
 if (decl_context == FIELD)
-	error ("data member may not have variably modified type %qT", type);
+	error_at (id_loc,
+		  "data member may not have variably modified type %qT", type);
 else
-	error ("parameter may not have variably modified type %qT", type);
+	error_at (id_loc,
+		  "parameter may not have variably modified type %qT", type);
 type = error_mark_node;
 }
 if (explicitp == 1 || (explicitp && friendp))
 {
 explicitp = 0;
 }
 if (storage_class == sc_mutable)
 {
+location_t sloc = declspecs->locations[ds_storage_class];
 if (decl_context != FIELD || friendp)
 	{
-	  error ("non-member %qs cannot be declared %<mutable%>", name);
+	  error_at (sloc, "non-member %qs cannot be declared %<mutable%>",
+		    name);
 	  storage_class = sc_none;
 	}
 else if (decl_context == TYPENAME || typedef_p)
 	{
-	  error ("non-object member %qs cannot be declared %<mutable%>", name);
+	  error_at (sloc,
+		    "non-object member %qs cannot be declared %<mutable%>",
+		    name);
 	  storage_class = sc_none;
 	}
-else if (TREE_CODE (type) == FUNCTION_TYPE
+else if (FUNC_OR_METHOD_TYPE_P (type))
-	       || TREE_CODE (type) == METHOD_TYPE)
+	{
-	{
+	  error_at (sloc, "function %qs cannot be declared %<mutable%>",
-	  error ("function %qs cannot be declared %<mutable%>", name);
+		    name);
 	  storage_class = sc_none;
 	}
 else if (staticp)
 	{
-	  error ("static %qs cannot be declared %<mutable%>", name);
+	  error_at (sloc, "%<static%> %qs cannot be declared %<mutable%>",
+		    name);
 	  storage_class = sc_none;
 	}
 else if (type_quals & TYPE_QUAL_CONST)
 	{
-	  error ("const %qs cannot be declared %<mutable%>", name);
+	  error_at (sloc, "%<const%> %qs cannot be declared %<mutable%>",
+		    name);
 	  storage_class = sc_none;
 	}
 else if (TYPE_REF_P (type))
 	{
-	  permerror (input_location, "reference %qs cannot be declared "
+	  permerror (sloc, "reference %qs cannot be declared %<mutable%>",
-	             "%<mutable%>", name);
+		     name);
 	  storage_class = sc_none;
 	}
 }
 /* If this is declaring a typedef name, return a TYPE_DECL.  */
 if (typedef_p && decl_context != TYPENAME)
 {
 bool alias_p = decl_spec_seq_has_spec_p (declspecs, ds_alias);
 tree decl;
+if (funcdef_flag)
+	{
+	  if (decl_context == NORMAL)
+	    error_at (id_loc,
+		      "typedef may not be a function definition");
+	  else
+	    error_at (id_loc,
+		      "typedef may not be a member function definition");
+	  return error_mark_node;
+	}
 /* This declaration:
 	   typedef void f(int) const;
 if (reqs)
 	error_at (location_of (reqs), "requires-clause on typedef");
 if (id_declarator && declarator->u.id.qualifying_scope)
 	{
-	  error ("typedef name may not be a nested-name-specifier");
+	  error_at (id_loc, "typedef name may not be a nested-name-specifier");
 	  type = error_mark_node;
 	}
 if (decl_context == FIELD)
-	decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
+	decl = build_lang_decl_loc (id_loc, TYPE_DECL, unqualified_id, type);
 else
-	decl = build_decl (input_location, TYPE_DECL, unqualified_id, type);
+	decl = build_decl (id_loc, TYPE_DECL, unqualified_id, type);
 if (decl_context != FIELD)
 	{
 	  if (!current_function_decl)
 	    DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
 the clones should share a common implementation.  */
 	    DECL_ABSTRACT_P (decl) = true;
 	}
 else if (current_class_type
 	       && constructor_name_p (unqualified_id, current_class_type))
-	permerror (input_location, "ISO C++ forbids nested type %qD with same name "
+	permerror (id_loc, "ISO C++ forbids nested type %qD with same name "
 		   "as enclosing class",
 		   unqualified_id);
 /* If the user declares "typedef struct {...} foo" then the
 	 struct will have an anonymous name.  Fill that name in now.
 	  /* The qualifiers on the function type become the qualifiers on
 	     the non-static member function. */
 	  memfn_quals |= type_memfn_quals (type);
 	  rqual = type_memfn_rqual (type);
 	  type_quals = TYPE_UNQUALIFIED;
+	  raises = TYPE_RAISES_EXCEPTIONS (type);
 	}
 }
 /* If this is a type name (such as, in a cast or sizeof),
 compute the type and return it now.  */
 if (!FUNC_OR_METHOD_TYPE_P (type))
 {
 /* Only functions may be declared using an operator-function-id.  */
 if (dname && IDENTIFIER_ANY_OP_P (dname))
 	{
-	  error ("declaration of %qD as non-function", dname);
+	  error_at (id_loc, "declaration of %qD as non-function", dname);
 	  return error_mark_node;
 	}
 if (reqs)
 	error_at (location_of (reqs),
 /* We don't check parameter types here because we can emit a better
 error message later.  */
 if (decl_context != PARM)
 {
-type = check_var_type (unqualified_id, type);
+type = check_var_type (unqualified_id, type, id_loc);
 if (type == error_mark_node)
 return error_mark_node;
 }
 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
 if (decl_context == PARM || decl_context == CATCHPARM)
 {
 if (ctype || in_namespace)
 	error ("cannot use %<::%> in parameter declaration");
-if (type_uses_auto (type)
+tree auto_node = type_uses_auto (type);
-	  && !(cxx_dialect >= cxx17 && template_parm_flag))
+if (auto_node && !(cxx_dialect >= cxx17 && template_parm_flag))
 	{
 	  if (cxx_dialect >= cxx14)
-	    error ("%<auto%> parameter not permitted in this context");
+	    {
+	      if (decl_context == PARM && AUTO_IS_DECLTYPE (auto_node))
+		error_at (typespec_loc,
+			  "cannot declare a parameter with %<decltype(auto)%>");
+	      else
+		error_at (typespec_loc,
+			  "%<auto%> parameter not permitted in this context");
+	    }
 	  else
-	    error ("parameter declared %<auto%>");
+	    error_at (typespec_loc, "parameter declared %<auto%>");
 	  type = error_mark_node;
 	}
 /* A parameter declared as an array of T is really a pointer to T.
 	 One declared as a function is really a pointer to a function.
 else if (TREE_CODE (type) == FUNCTION_TYPE)
 	type = build_pointer_type (type);
 }
 if (ctype && TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
-&& !(identifier_p (unqualified_id)
+&& !(unqualified_id
+	   && identifier_p (unqualified_id)
 	   && IDENTIFIER_NEWDEL_OP_P (unqualified_id)))
 {
 cp_cv_quals real_quals = memfn_quals;
 if (cxx_dialect < cxx14 && constexpr_p
 	  && sfk != sfk_constructor && sfk != sfk_destructor)
 else if (decl_context == FIELD)
 {
 	if (!staticp && !friendp && TREE_CODE (type) != METHOD_TYPE)
 	  if (tree auto_node = type_uses_auto (type))
 	    {
-	      location_t loc = declspecs->locations[ds_type_spec];
+	      location_t tloc = declspecs->locations[ds_type_spec];
 	      if (CLASS_PLACEHOLDER_TEMPLATE (auto_node))
-		error_at (loc, "invalid use of template-name %qE without an "
+		error_at (tloc, "invalid use of template-name %qE without an "
 			  "argument list",
 			  CLASS_PLACEHOLDER_TEMPLATE (auto_node));
 	      else
-		error_at (loc, "non-static data member declared with "
+		error_at (tloc, "non-static data member declared with "
 			  "placeholder %qT", auto_node);
 	      type = error_mark_node;
 	    }
 	/* The C99 flexible array extension.  */
 	  {
 	    if (ctype
 		&& (TREE_CODE (ctype) == UNION_TYPE
 		    || TREE_CODE (ctype) == QUAL_UNION_TYPE))
 	      {
-		error ("flexible array member in union");
+		error_at (id_loc, "flexible array member in union");
 		type = error_mark_node;
 	      }
 	    else
 	      {
 		/* Array is a flexible member.  */
-		if (in_system_header_at (input_location))
+		if (name)
-		  /* Do not warn on flexible array members in system
+		  pedwarn (id_loc, OPT_Wpedantic,
-		     headers because glibc uses them.  */;
-		else if (name)
-		  pedwarn (input_location, OPT_Wpedantic,
 			   "ISO C++ forbids flexible array member %qs", name);
 		else
 		  pedwarn (input_location, OPT_Wpedantic,
 			   "ISO C++ forbids flexible array members");
 	    decl = NULL_TREE;
 	  }
 	else if (in_namespace && !friendp)
 	  {
 	    /* Something like struct S { int N::j; };  */
-	    error ("invalid use of %<::%>");
+	    error_at (id_loc, "invalid use of %<::%>");
 	    return error_mark_node;
 	  }
-	else if (TREE_CODE (type) == FUNCTION_TYPE
+	else if (FUNC_OR_METHOD_TYPE_P (type) && unqualified_id)
-		 || TREE_CODE (type) == METHOD_TYPE)
 	  {
 	    int publicp = 0;
 	    tree function_context;
 	    if (friendp == 0)
 		tree uqname = id_declarator->u.id.unqualified_name;
 		if (!ctype)
 		  {
 		    gcc_assert (friendp);
-		    error ("expected qualified name in friend declaration "
+		    error_at (id_loc, "expected qualified name in friend "
-			   "for destructor %qD", uqname);
+			      "declaration for destructor %qD", uqname);
 		    return error_mark_node;
 		  }
 		if (!check_dtor_name (ctype, TREE_OPERAND (uqname, 0)))
 		  {
-		    error ("declaration of %qD as member of %qT",
+		    error_at (id_loc, "declaration of %qD as member of %qT",
-			   uqname, ctype);
+			      uqname, ctype);
 		    return error_mark_node;
 		  }
 if (concept_p)
 {
 error_at (declspecs->locations[ds_concept],
-			      "a destructor cannot be %<concept%>");
+			      "a destructor cannot be %qs", "concept");
 return error_mark_node;
 }
-if (constexpr_p)
+		if (constexpr_p && cxx_dialect < cxx2a)
-{
+		  {
-error_at (declspecs->locations[ds_constexpr],
+		    error_at (declspecs->locations[ds_constexpr],
-			      "a destructor cannot be %<constexpr%>");
+			      "%<constexpr%> destructors only available"
-return error_mark_node;
+			      " with %<-std=c++2a%> or %<-std=gnu++2a%>");
-}
+		    return error_mark_node;
+		  }
+		if (consteval_p)
+		  {
+		    error_at (declspecs->locations[ds_consteval],
+			      "a destructor cannot be %qs", "consteval");
+		    return error_mark_node;
+		  }
 	      }
 	    else if (sfk == sfk_constructor && friendp && !ctype)
 	      {
 		error ("expected qualified name in friend declaration "
 		       "for constructor %qD",
 	      {
 		error_at (declspecs->locations[ds_concept],
 			  "a concept cannot be a member function");
 		concept_p = false;
 	      }
+	    else if (consteval_p
+		     && identifier_p (unqualified_id)
+		     && IDENTIFIER_NEWDEL_OP_P (unqualified_id))
+	      {
+		error_at (declspecs->locations[ds_consteval],
+			  "%qD cannot be %qs", unqualified_id, "consteval");
+		consteval_p = false;
+	      }
 	    if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
 	      {
 		tree tmpl = TREE_OPERAND (unqualified_id, 0);
 		if (variable_template_p (tmpl))
 		  {
-		    error ("specialization of variable template %qD "
+		    error_at (id_loc, "specialization of variable template "
-			   "declared as function", tmpl);
+			      "%qD declared as function", tmpl);
 		    inform (DECL_SOURCE_LOCATION (tmpl),
 			    "variable template declared here");
 		    return error_mark_node;
 		  }
 	      }
 	    /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
-	    function_context = (ctype != NULL_TREE) ?
+	    function_context
-	      decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
+	      = (ctype != NULL_TREE
-	    publicp = (! friendp || ! staticp)
+		 ? decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE);
-	      && function_context == NULL_TREE;
+	    publicp = ((! friendp || ! staticp)
+		       && function_context == NULL_TREE);
 	    decl = grokfndecl (ctype, type,
 			       TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
 			       ? unqualified_id : dname,
 			       parms,
 			       unqualified_id,
 			       declspecs,
 			       reqs,
 			       virtualp, flags, memfn_quals, rqual, raises,
 			       friendp ? -1 : 0, friendp, publicp,
-inlinep | (2 * constexpr_p) | (4 * concept_p),
+			       inlinep | (2 * constexpr_p) | (4 * concept_p)
+				       | (8 * consteval_p),
 			       initialized == SD_DELETED, sfk,
 			       funcdef_flag, late_return_type_p,
 			       template_count, in_namespace,
-			       attrlist, declarator->id_loc);
+			       attrlist, id_loc);
 decl = set_virt_specifiers (decl, virt_specifiers);
 	    if (decl == NULL_TREE)
 	      return error_mark_node;
 #if 0
 	    /* This clobbers the attrs stored in `decl' from `attrlist'.  */
 	       specifies a conversion from the type of its first
 	       parameter to the type of its class.  Such a constructor
 	       is called a converting constructor.  */
 	    if (explicitp == 2)
 	      DECL_NONCONVERTING_P (decl) = 1;
+	    if (declspecs->explicit_specifier)
+	      store_explicit_specifier (decl, declspecs->explicit_specifier);
 	  }
-	else if (!staticp && !dependent_type_p (type)
+	else if (!staticp
-		 && !COMPLETE_TYPE_P (complete_type (type))
+		 && ((current_class_type
-		 && (!complete_or_array_type_p (type)
+		      && same_type_p (type, current_class_type))
-		     || initialized == 0))
+		     || (!dependent_type_p (type)
+			 && !COMPLETE_TYPE_P (complete_type (type))
+			 && (!complete_or_array_type_p (type)
+			     || initialized == 0))))
 	  {
 	    if (TREE_CODE (type) != ARRAY_TYPE
 		|| !COMPLETE_TYPE_P (TREE_TYPE (type)))
 	      {
 		if (unqualified_id)
 		  {
-		    error ("field %qD has incomplete type %qT",
+		    error_at (id_loc, "field %qD has incomplete type %qT",
-			   unqualified_id, type);
+			      unqualified_id, type);
 		    cxx_incomplete_type_inform (strip_array_types (type));
 		  }
 		else
 		  error ("name %qT has incomplete type", type);
 		type = error_mark_node;
 		decl = NULL_TREE;
 	      }
+	  }
+	else if (!verify_type_context (input_location,
+				       staticp
+				       ? TCTX_STATIC_STORAGE
+				       : TCTX_FIELD, type))
+	  {
+	    type = error_mark_node;
+	    decl = NULL_TREE;
 	  }
 	else
 	  {
 	    if (friendp)
 	      {
-		error ("%qE is neither function nor member function; "
+		if (unqualified_id)
-		       "cannot be declared friend", unqualified_id);
+		  error_at (id_loc,
+			    "%qE is neither function nor member function; "
+			    "cannot be declared friend", unqualified_id);
+		else
+		  error ("unnamed field is neither function nor member "
+			 "function; cannot be declared friend");
 		return error_mark_node;
 	      }
 	    decl = NULL_TREE;
 	  }
 	    /* Friends are treated specially.  */
 	    if (ctype == current_class_type)
 	      ;  /* We already issued a permerror.  */
 	    else if (decl && DECL_NAME (decl))
 	      {
+		if (initialized)
+		  /* Kludge: We need funcdef_flag to be true in do_friend for
+		     in-class defaulted functions, but that breaks grokfndecl.
+		     So set it here.  */
+		  funcdef_flag = true;
 		if (template_class_depth (current_class_type) == 0)
 		  {
 		    decl = check_explicit_specialization
 		      (unqualified_id, decl, template_count,
 		       2 * funcdef_flag + 4);
 	  {
 	    if (staticp)
 	      {
 		/* C++ allows static class members.  All other work
 		   for this is done by grokfield.  */
-		decl = build_lang_decl_loc (declarator
+		decl = build_lang_decl_loc (id_loc, VAR_DECL,
-					    ? declarator->id_loc
+					    unqualified_id, type);
-					    : input_location,
-					    VAR_DECL, unqualified_id, type);
 		set_linkage_for_static_data_member (decl);
 		if (concept_p)
 		  error_at (declspecs->locations[ds_concept],
-			    "static data member %qE declared %<concept%>",
+			    "static data member %qE declared %qs",
-			    unqualified_id);
+			    unqualified_id, "concept");
 		else if (constexpr_p && !initialized)
 		  {
-		    error ("%<constexpr%> static data member %qD must have an "
+		    error_at (DECL_SOURCE_LOCATION (decl),
-			   "initializer", decl);
+			      "%<constexpr%> static data member %qD must "
+			      "have an initializer", decl);
 		    constexpr_p = false;
 		  }
+		if (consteval_p)
+		  error_at (declspecs->locations[ds_consteval],
+			    "static data member %qE declared %qs",
+			    unqualified_id, "consteval");
 		if (inlinep)
 		  mark_inline_variable (decl, declspecs->locations[ds_inline]);
 		if (!DECL_VAR_DECLARED_INLINE_P (decl)
 		  }
 	      }
 	    else
 	      {
 		if (concept_p)
-		  error_at (declspecs->locations[ds_concept],
+		  {
-			    "non-static data member %qE declared %<concept%>",
+		    error_at (declspecs->locations[ds_concept],
-			    unqualified_id);
+			      "non-static data member %qE declared %qs",
-else if (constexpr_p)
+			      unqualified_id, "concept");
+		    concept_p = false;
+		    constexpr_p = false;
+		  }
+		else if (constexpr_p)
 		  {
 		    error_at (declspecs->locations[ds_constexpr],
-			      "non-static data member %qE declared %<constexpr%>",
+			      "non-static data member %qE declared %qs",
-			      unqualified_id);
+			      unqualified_id, "constexpr");
 		    constexpr_p = false;
 		  }
-		decl = build_decl (input_location,
+		if (constinit_p)
-				   FIELD_DECL, unqualified_id, type);
+		  {
+		    error_at (declspecs->locations[ds_constinit],
+			      "non-static data member %qE declared %qs",
+			      unqualified_id, "constinit");
+		    constinit_p = false;
+		  }
+		if (consteval_p)
+		  {
+		    error_at (declspecs->locations[ds_consteval],
+			      "non-static data member %qE declared %qs",
+			      unqualified_id, "consteval");
+		    consteval_p = false;
+		  }
+		decl = build_decl (id_loc, FIELD_DECL, unqualified_id, type);
 		DECL_NONADDRESSABLE_P (decl) = bitfield;
 		if (bitfield && !unqualified_id)
 		  {
 		    TREE_NO_WARNING (decl) = 1;
 		    DECL_PADDING_P (decl) = 1;
 			    staticp ? false : inlinep, friendp,
 			    raises != NULL_TREE,
 			    declspecs->locations);
 	  }
 }
-else if (TREE_CODE (type) == FUNCTION_TYPE
+else if (FUNC_OR_METHOD_TYPE_P (type))
-	     || TREE_CODE (type) == METHOD_TYPE)
 {
 	tree original_name;
 	int publicp = 0;
 	if (!unqualified_id)
 	else
 	  original_name = unqualified_id;
 	// FIXME:gcc_assert (original_name == dname);
 	if (storage_class == sc_auto)
-	  error ("storage class %<auto%> invalid for function %qs", name);
+	  error_at (declspecs->locations[ds_storage_class],
+		    "storage class %<auto%> invalid for function %qs", name);
 	else if (storage_class == sc_register)
-	  error ("storage class %<register%> invalid for function %qs", name);
+	  error_at (declspecs->locations[ds_storage_class],
+		    "storage class %<register%> invalid for function %qs",
+		    name);
 	else if (thread_p)
 	  {
 	    if (declspecs->gnu_thread_keyword_p)
 	      error_at (declspecs->locations[ds_thread],
 			"storage class %<__thread%> invalid for function %qs",
 		       ? G_("%qs defined in a non-class scope")
 		       : G_("%qs declared in a non-class scope"), name);
 		sfk = sfk_none;
 	      }
 	  }
+	if (consteval_p
+	    && identifier_p (unqualified_id)
+	    && IDENTIFIER_NEWDEL_OP_P (unqualified_id))
+	  {
+	    error_at (declspecs->locations[ds_consteval],
+		      "%qD cannot be %qs", unqualified_id, "consteval");
+	    consteval_p = false;
+	  }
 	/* Record whether the function is public.  */
 	publicp = (ctype != NULL_TREE
 		   || storage_class != sc_static);
 	decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
 			   declspecs,
 reqs, virtualp, flags, memfn_quals, rqual, raises,
 			   1, friendp,
 			   publicp,
-inlinep | (2 * constexpr_p) | (4 * concept_p),
+			   inlinep | (2 * constexpr_p) | (4 * concept_p)
+				   | (8 * consteval_p),
 			   initialized == SD_DELETED,
 sfk,
 funcdef_flag,
 			   late_return_type_p,
 			   template_count, in_namespace, attrlist,
-			   declarator->id_loc);
+			   id_loc);
 	if (decl == NULL_TREE)
 	  return error_mark_node;
 	if (explicitp == 2)
 	  DECL_NONCONVERTING_P (decl) = 1;
 			    initialized,
 			    type_quals,
 			    inlinep,
 			    concept_p,
 			    template_count,
-			    ctype ? ctype : in_namespace);
+			    ctype ? ctype : in_namespace,
+			    id_loc);
 	if (decl == NULL_TREE)
 	  return error_mark_node;
 	bad_specifiers (decl, BSP_VAR, virtualp,
 			memfn_quals != TYPE_UNQUALIFIED,
 	if (ctype)
 	  {
 	    DECL_CONTEXT (decl) = ctype;
 	    if (staticp == 1)
 	      {
-		permerror (input_location, "%<static%> may not be used when defining "
+		permerror (declspecs->locations[ds_storage_class],
+			   "%<static%> may not be used when defining "
 			   "(as opposed to declaring) a static data member");
 		staticp = 0;
 		storage_class = sc_none;
 	      }
 	    if (storage_class == sc_register && TREE_STATIC (decl))
 		storage_class = sc_none;
 	      }
 	  }
 	else if (constexpr_p && DECL_EXTERNAL (decl))
 	  {
-	    error ("declaration of %<constexpr%> variable %qD "
+	    error_at (DECL_SOURCE_LOCATION (decl),
-		   "is not a definition", decl);
+		      "declaration of %<constexpr%> variable %qD "
+		      "is not a definition", decl);
 	    constexpr_p = false;
+	  }
+	if (consteval_p)
+	  {
+	    error_at (DECL_SOURCE_LOCATION (decl),
+		      "a variable cannot be declared %<consteval%>");
+	    consteval_p = false;
 	  }
 	if (inlinep)
 	  mark_inline_variable (decl, declspecs->locations[ds_inline]);
 	if (innermost_code == cdk_decomp)
 	  {
 	    gcc_assert (declarator && declarator->kind == cdk_decomp);
-	    DECL_SOURCE_LOCATION (decl) = declarator->id_loc;
+	    DECL_SOURCE_LOCATION (decl) = id_loc;
 	    DECL_ARTIFICIAL (decl) = 1;
 	    fit_decomposition_lang_decl (decl, NULL_TREE);
 	  }
 }
 	if (toplevel_bindings_p ())
 	  {
 	    /* It's common practice (and completely valid) to have a const
 	       be initialized and declared extern.  */
 	    if (!(type_quals & TYPE_QUAL_CONST))
-	      warning (0, "%qs initialized and declared %<extern%>", name);
+	      warning_at (DECL_SOURCE_LOCATION (decl), 0,
+			  "%qs initialized and declared %<extern%>", name);
 	  }
 	else
 	  {
-	    error ("%qs has both %<extern%> and initializer", name);
+	    error_at (DECL_SOURCE_LOCATION (decl),
+		      "%qs has both %<extern%> and initializer", name);
 	    return error_mark_node;
 	  }
 }
 /* Record `register' declaration for warnings on &
 check_default_argument (tree decl, tree arg, tsubst_flags_t complain)
 {
 tree var;
 tree decl_type;
-if (TREE_CODE (arg) == DEFAULT_ARG)
+if (TREE_CODE (arg) == DEFERRED_PARSE)
-/* We get a DEFAULT_ARG when looking at an in-class declaration
+/* We get a DEFERRED_PARSE when looking at an in-class declaration
 with a default argument.  Ignore the argument for now; we'll
 deal with it after the class is complete.  */
 return arg;
 if (TYPE_P (decl))
 --cp_unevaluated_operand;
 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
 the call sites.  */
 if (TYPE_PTR_OR_PTRMEM_P (decl_type)
-&& null_ptr_cst_p (arg))
+&& null_ptr_cst_p (arg)
+/* Don't lose side-effects as in PR90473.  */
+&& !TREE_SIDE_EFFECTS (arg))
 return nullptr_node;
 /* [dcl.fct.default]
 Local variables shall not be used in default argument
 if (TYPE_NAME (type))
 {
 if (TREE_DEPRECATED (TYPE_NAME (type)))
 	return type;
 else
-	return NULL_TREE;
+	{
+	  cp_warn_deprecated_use_scopes (CP_DECL_CONTEXT (TYPE_NAME (type)));
+	  return NULL_TREE;
+	}
 }
 /* Do warn about using typedefs to a deprecated class.  */
 if (OVERLOAD_TYPE_P (type) && type != TYPE_MAIN_VARIANT (type))
 return type_is_deprecated (TYPE_MAIN_VARIANT (type));
 	      tree deptype = type_is_deprecated (type);
 	      if (deptype)
 		cp_warn_deprecated_use (deptype);
 	    }
+	  /* [dcl.fct] "A parameter with volatile-qualified type is
+	     deprecated."  */
+	  if (CP_TYPE_VOLATILE_P (type))
+	    warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wvolatile,
+			"%<volatile%>-qualified parameter is "
+			"deprecated");
 	  /* Top-level qualifiers on the parameters are
 	     ignored for function types.  */
 	  type = cp_build_qualified_type (type, 0);
 	  if (TREE_CODE (type) == METHOD_TYPE)
 	    {
 void
 grok_special_member_properties (tree decl)
 {
 tree class_type;
-if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
+if (TREE_CODE (decl) == USING_DECL
+|| !DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
 return;
 class_type = DECL_CONTEXT (decl);
 if (IDENTIFIER_CTOR_P (DECL_NAME (decl)))
 {
 	     constructor if its first parameter is of type X&, const
 	     X&, volatile X& or const volatile X&, and either there
 	     are no other parameters or else all other parameters have
 	     default arguments.  */
 	  TYPE_HAS_COPY_CTOR (class_type) = 1;
-	  if (user_provided_p (decl))
-	    TYPE_HAS_COMPLEX_COPY_CTOR (class_type) = 1;
 	  if (ctor > 1)
 	    TYPE_HAS_CONST_COPY_CTOR (class_type) = 1;
 	}
 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
 	TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
-else if (move_fn_p (decl) && user_provided_p (decl))
-	TYPE_HAS_COMPLEX_MOVE_CTOR (class_type) = 1;
 else if (is_list_ctor (decl))
 	TYPE_HAS_LIST_CTOR (class_type) = 1;
 if (DECL_DECLARED_CONSTEXPR_P (decl)
 	  && !ctor && !move_fn_p (decl))
 int assop = copy_fn_p (decl);
 if (assop)
 	{
 	  TYPE_HAS_COPY_ASSIGN (class_type) = 1;
-	  if (user_provided_p (decl))
-	    TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type) = 1;
 	  if (assop != 1)
 	    TYPE_HAS_CONST_COPY_ASSIGN (class_type) = 1;
 	}
-else if (move_fn_p (decl) && user_provided_p (decl))
-	TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type) = 1;
 }
 else if (IDENTIFIER_CONV_OP_P (DECL_NAME (decl)))
 TYPE_HAS_CONVERSION (class_type) = true;
 /* Destructors are handled in check_methods.  */
 	 overload resolution will never prefer such a constructor to
 	 the non-template copy constructor (which is either explicitly
 	 or implicitly defined), there's no need to worry about their
 	 existence.  Theoretically, they should never even be
 	 instantiated, but that's hard to forestall.  */
-error ("invalid constructor; you probably meant %<%T (const %T&)%>",
+error_at (DECL_SOURCE_LOCATION (decl),
+		"invalid constructor; you probably meant %<%T (const %T&)%>",
 		ctype, ctype);
 return false;
 }
 return true;
 	      return false;
 	    }
 	}
 if (op_flags & OVL_OP_FLAG_DELETE)
-	TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl), loc);
+	{
+	  DECL_SET_IS_OPERATOR_DELETE (decl, true);
+	  coerce_delete_type (decl, loc);
+	}
 else
 	{
-	  DECL_IS_OPERATOR_NEW (decl) = 1;
+	  DECL_SET_IS_OPERATOR_NEW (decl, true);
 	  TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl), loc);
 	}
 return true;
 }
 return true;
 if (operator_code == COND_EXPR)
 {
 /* 13.4.0.3 */
-error_at (loc, "ISO C++ prohibits overloading operator ?:");
+error_at (loc, "ISO C++ prohibits overloading %<operator ?:%>");
 return false;
 }
 /* Count the number of arguments and check for ellipsis.  */
 int arity = 0;
 the type is declared.  */
 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
 	   && !DECL_SELF_REFERENCE_P (decl)
 	   && tag_code != typename_type)
 {
-if (alias_template_specialization_p (type))
+if (alias_template_specialization_p (type, nt_opaque))
 	error ("using alias template specialization %qT after %qs",
 	       type, tag_name (tag_code));
 else
 	error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
 inform (DECL_SOURCE_LOCATION (decl),
 }
 /* In case of anonymous name, xref_tag is only called to
 make type node and push name.  Name lookup is not required.  */
 tree t = NULL_TREE;
-if (scope != ts_lambda && !anon_aggrname_p (name))
+if (scope != ts_lambda && !IDENTIFIER_ANON_P (name))
 t = lookup_and_check_tag  (tag_code, name, scope, template_header_p);
 if (t == error_mark_node)
 return error_mark_node;
 /* If the precision of the type was specified with an attribute and it
 	 was too small, give an error.  Otherwise, use it.  */
 if (TYPE_PRECISION (enumtype))
 	{
 	  if (precision > TYPE_PRECISION (enumtype))
-	    error ("specified mode too small for enumeral values");
+	    error ("specified mode too small for enumerated values");
 	  else
 	    {
 	      use_short_enum = true;
 	      precision = TYPE_PRECISION (enumtype);
 	    }
 /* Convert each of the enumerators to the type of the underlying
 type of the enumeration.  */
 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
 {
-location_t saved_location;
 decl = TREE_VALUE (values);
-saved_location = input_location;
+iloc_sentinel ils (DECL_SOURCE_LOCATION (decl));
-input_location = DECL_SOURCE_LOCATION (decl);
 if (fixed_underlying_type_p)
 /* If the enumeration type has a fixed underlying type, we
 already checked all of the enumerator values.  */
 value = DECL_INITIAL (decl);
 else
 value = perform_implicit_conversion (underlying_type,
 DECL_INITIAL (decl),
 tf_warning_or_error);
-input_location = saved_location;
 /* Do not clobber shared ints.  */
 if (value != error_mark_node)
 	{
 	  value = copy_node (value);
 	  if (value != NULL_TREE)
 	    {
 	      if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
 		  (TREE_TYPE (value)))
 		{
-		  error ("enumerator value for %qD must have integral or "
+		  error_at (cp_expr_loc_or_input_loc (value),
-			 "unscoped enumeration type", name);
+			    "enumerator value for %qD must have integral or "
+			    "unscoped enumeration type", name);
 		  value = NULL_TREE;
 		}
 	      else
 		{
 		  value = cxx_constant_value (value);
 e = purpose_member (name, TYPE_VALUES (enumtype));
 return e? TREE_VALUE (e) : NULL_TREE;
 }
+/* Implement LANG_HOOKS_SIMULATE_ENUM_DECL.  */
+tree
+cxx_simulate_enum_decl (location_t loc, const char *name,
+			vec<string_int_pair> values)
+{
+location_t saved_loc = input_location;
+input_location = loc;
+tree enumtype = start_enum (get_identifier (name), NULL_TREE, NULL_TREE,
+			      NULL_TREE, false, NULL);
+if (!OPAQUE_ENUM_P (enumtype))
+{
+error_at (loc, "multiple definition of %q#T", enumtype);
+inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
+	      "previous definition here");
+return enumtype;
+}
+SET_OPAQUE_ENUM_P (enumtype, false);
+DECL_SOURCE_LOCATION (TYPE_NAME (enumtype)) = loc;
+string_int_pair *value;
+unsigned int i;
+FOR_EACH_VEC_ELT (values, i, value)
+build_enumerator (get_identifier (value->first),
+		      build_int_cst (integer_type_node, value->second),
+		      enumtype, NULL_TREE, loc);
+finish_enum_value_list (enumtype);
+finish_enum (enumtype);
+input_location = saved_loc;
+return enumtype;
+}
 /* We're defining DECL.  Make sure that its type is OK.  */
 static void
 check_function_type (tree decl, tree current_function_parms)
 }
 if (DECL_DECLARED_INLINE_P (decl1)
 && lookup_attribute ("noinline", attrs))
 warning_at (DECL_SOURCE_LOCATION (decl1), 0,
-		"inline function %qD given attribute noinline", decl1);
+		"inline function %qD given attribute %qs", decl1, "noinline");
 /* Handle gnu_inline attribute.  */
 if (GNU_INLINE_P (decl1))
 {
 DECL_EXTERNAL (decl1) = 1;
 a new function, we destroy temporaries in the usual way.  */
 cfun->language = ggc_cleared_alloc<language_function> ();
 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
 current_binding_level = bl;
+/* If we are (erroneously) defining a function that we have already
+defined before, wipe out what we knew before.  */
+gcc_checking_assert (!DECL_PENDING_INLINE_P (decl1));
+FNDECL_USED_AUTO (decl1) = false;
+DECL_SAVED_AUTO_RETURN_TYPE (decl1) = NULL;
 if (!processing_template_decl && type_uses_auto (restype))
 {
 FNDECL_USED_AUTO (decl1) = true;
-current_function_auto_return_pattern = restype;
+DECL_SAVED_AUTO_RETURN_TYPE (decl1) = restype;
 }
 /* Start the statement-tree, start the tree now.  */
 DECL_SAVED_TREE (decl1) = push_stmt_list ();
-/* If we are (erroneously) defining a function that we have already
-defined before, wipe out what we knew before.  */
-if (!DECL_PENDING_INLINE_P (decl1))
-DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
 {
 /* We know that this was set up by `grokclassfn'.  We do not
 	 wait until `store_parm_decls', since evil parse errors may
 }
 start_fname_decls ();
 store_parm_decls (current_function_parms);
+push_operator_bindings ();
 if (!processing_template_decl
 && (flag_lifetime_dse > 1)
 && DECL_CONSTRUCTOR_P (decl1)
 && !DECL_CLONED_FUNCTION_P (decl1)
 && sanitize_flags_p (SANITIZE_VPTR)
 && !DECL_CLONED_FUNCTION_P (decl1)
 && !implicit_default_ctor_p (decl1))
 cp_ubsan_maybe_initialize_vtbl_ptrs (current_class_ptr);
-start_lambda_scope (decl1);
+if (!DECL_OMP_DECLARE_REDUCTION_P (decl1))
+start_lambda_scope (decl1);
 return true;
 }
 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
 invoke_plugin_callbacks (PLUGIN_START_PARSE_FUNCTION, decl1);
 if (decl1 == error_mark_node)
 return false;
-/* If the declarator is not suitable for a function definition,
-cause a syntax error.  */
-if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
-{
-error ("invalid function declaration");
-return false;
-}
 if (DECL_MAIN_P (decl1))
 /* main must return int.  grokfndecl should have corrected it
 (and issued a diagnostic) if the user got it wrong.  */
 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
 	     and we avoid spurious warnings about unreachable
 	     code.  */
 	  && !DECL_DEFAULTED_FN (fn));
 }
+/* Helper function to push ARGS into the current lexical scope.  DECL
+is the function declaration.  NONPARMS is used to handle enum
+constants.  */
+void
+do_push_parm_decls (tree decl, tree args, tree *nonparms)
+{
+/* If we're doing semantic analysis, then we'll call pushdecl
+for each of these.  We must do them in reverse order so that
+they end in the correct forward order.  */
+args = nreverse (args);
+tree next;
+for (tree parm = args; parm; parm = next)
+{
+next = DECL_CHAIN (parm);
+if (TREE_CODE (parm) == PARM_DECL)
+	pushdecl (parm);
+else if (nonparms)
+	{
+	  /* If we find an enum constant or a type tag, put it aside for
+	     the moment.  */
+	  TREE_CHAIN (parm) = NULL_TREE;
+	  *nonparms = chainon (*nonparms, parm);
+	}
+}
+/* Get the decls in their original chain order and record in the
+function.  This is all and only the PARM_DECLs that were
+pushed into scope by the loop above.  */
+DECL_ARGUMENTS (decl) = get_local_decls ();
+}
 /* Store the parameter declarations into the current function declaration.
 This is called after parsing the parameter declarations, before
 digesting the body of the function.
 Also install to binding contour return value identifier, if any.  */
 static void
 store_parm_decls (tree current_function_parms)
 {
 tree fndecl = current_function_decl;
-tree parm;
 /* This is a chain of any other decls that came in among the parm
 declarations.  If a parm is declared with  enum {foo, bar} x;
 then CONST_DECLs for foo and bar are put here.  */
 tree nonparms = NULL_TREE;
 	 The parms already have decls, so we need not do anything here
 	 except record them as in effect
 	 and complain if any redundant old-style parm decls were written.  */
 tree specparms = current_function_parms;
-tree next;
 /* Must clear this because it might contain TYPE_DECLs declared
 	     at class level.  */
 current_binding_level->names = NULL;
-/* If we're doing semantic analysis, then we'll call pushdecl
+do_push_parm_decls (fndecl, specparms, &nonparms);
-	     for each of these.  We must do them in reverse order so that
-	     they end in the correct forward order.  */
-specparms = nreverse (specparms);
-for (parm = specparms; parm; parm = next)
-	{
-	  next = DECL_CHAIN (parm);
-	  if (TREE_CODE (parm) == PARM_DECL)
-	    pushdecl (parm);
-	  else
-	    {
-	      /* If we find an enum constant or a type tag,
-		 put it aside for the moment.  */
-	      TREE_CHAIN (parm) = NULL_TREE;
-	      nonparms = chainon (nonparms, parm);
-	    }
-	}
-/* Get the decls in their original chain order and record in the
-	 function.  This is all and only the PARM_DECLs that were
-	 pushed into scope by the loop above.  */
-DECL_ARGUMENTS (fndecl) = get_local_decls ();
 }
 else
 DECL_ARGUMENTS (fndecl) = NULL_TREE;
 /* Now store the final chain of decls for the arguments
 if (use_eh_spec_block (current_function_decl))
 current_eh_spec_block = begin_eh_spec_block ();
 }
-/* We have finished doing semantic analysis on DECL, but have not yet
-generated RTL for its body.  Save away our current state, so that
-when we want to generate RTL later we know what to do.  */
-static void
-save_function_data (tree decl)
-{
-struct language_function *f;
-/* Save the language-specific per-function data so that we can
-get it back when we really expand this function.  */
-gcc_assert (!DECL_PENDING_INLINE_P (decl));
-/* Make a copy.  */
-f = ggc_alloc<language_function> ();
-memcpy (f, cp_function_chain, sizeof (struct language_function));
-DECL_SAVED_FUNCTION_DATA (decl) = f;
-/* Clear out the bits we don't need.  */
-f->base.x_stmt_tree.x_cur_stmt_list = NULL;
-f->bindings = NULL;
-f->x_local_names = NULL;
-f->base.local_typedefs = NULL;
-}
 /* Set the return value of the constructor (if present).  */
 static void
 finish_constructor_body (void)
 {
 richloc->add_fixit_insert_formatted ("return *this;",
 				       richloc->get_loc (),
 				       indent);
 }
+/* This function carries out the subset of finish_function operations needed
+to emit the compiler-generated outlined helper functions used by the
+coroutines implementation.  */
+static void
+emit_coro_helper (tree helper)
+{
+/* This is a partial set of the operations done by finish_function()
+plus emitting the result.  */
+set_cfun (NULL);
+current_function_decl = helper;
+begin_scope (sk_function_parms, NULL);
+store_parm_decls (DECL_ARGUMENTS (helper));
+announce_function (helper);
+allocate_struct_function (helper, false);
+cfun->language = ggc_cleared_alloc<language_function> ();
+poplevel (1, 0, 1);
+maybe_save_function_definition (helper);
+/* We must start each function with a clear fold cache.  */
+clear_fold_cache ();
+cp_fold_function (helper);
+DECL_CONTEXT (DECL_RESULT (helper)) = helper;
+BLOCK_SUPERCONTEXT (DECL_INITIAL (helper)) = helper;
+/* This function has coroutine IFNs that we should handle in middle
+end lowering.  */
+cfun->coroutine_component = true;
+cp_genericize (helper);
+expand_or_defer_fn (helper);
+}
 /* Finish up a function declaration and compile that function
 all the way to assembler language output.  The free the storage
 for the function definition. INLINE_P is TRUE if we just
 finished processing the body of an in-class inline function
 definition.  (This processing will have taken place after the
 tree
 finish_function (bool inline_p)
 {
 tree fndecl = current_function_decl;
 tree fntype, ctype = NULL_TREE;
+tree resumer = NULL_TREE, destroyer = NULL_TREE;
+bool coro_p = flag_coroutines
+		&& !processing_template_decl
+		&& DECL_COROUTINE_P (fndecl);
 /* When we get some parse errors, we can end up without a
 current_function_decl, so cope.  */
 if (fndecl == NULL_TREE)
 return error_mark_node;
-finish_lambda_scope ();
+if (!DECL_OMP_DECLARE_REDUCTION_P (fndecl))
+finish_lambda_scope ();
 if (c_dialect_objc ())
 objc_finish_function ();
 record_key_method_defined (fndecl);
 /* The current function is being defined, so its DECL_INITIAL should
 be set, and unless there's a multiple definition, it should be
 error_mark_node.  */
 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
+if (coro_p)
+{
+if (!morph_fn_to_coro (fndecl, &resumer, &destroyer))
+	{
+	  DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
+	  poplevel (1, 0, 1);
+	  DECL_SAVED_TREE (fndecl) = error_mark_node;
+	  return fndecl;
+	}
+/* We should handle coroutine IFNs in middle end lowering.  */
+cfun->coroutine_component = true;
+if (use_eh_spec_block (fndecl))
+	finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
+			      (TREE_TYPE (fndecl)),
+			      current_eh_spec_block);
+}
+else
 /* For a cloned function, we've already got all the code we need;
 there's no need to add any extra bits.  */
 if (!DECL_CLONED_FUNCTION_P (fndecl))
 {
 /* Make it so that `main' always returns 0 by default.  */
 /* If there are no return statements in a function with auto return type,
 the return type is void.  But if the declared type is something like
 auto*, this is an error.  */
 if (!processing_template_decl && FNDECL_USED_AUTO (fndecl)
-&& TREE_TYPE (fntype) == current_function_auto_return_pattern)
+&& TREE_TYPE (fntype) == DECL_SAVED_AUTO_RETURN_TYPE (fndecl))
 {
-if (is_auto (current_function_auto_return_pattern))
+if (is_auto (DECL_SAVED_AUTO_RETURN_TYPE (fndecl))
-	{
+&& !current_function_returns_value
+&& !current_function_returns_null)
+	{
+	  /* We haven't applied return type deduction because we haven't
+seen any return statements. Do that now.  */
+	  tree node = type_uses_auto (DECL_SAVED_AUTO_RETURN_TYPE (fndecl));
+	  do_auto_deduction (DECL_SAVED_AUTO_RETURN_TYPE (fndecl),
+			     void_node, node, tf_warning_or_error,
+adc_return_type);
 	  apply_deduced_return_type (fndecl, void_type_node);
 	  fntype = TREE_TYPE (fndecl);
 	}
 else if (!current_function_returns_value
 	       && !current_function_returns_null)
 	{
 	  error ("no return statements in function returning %qT",
-		 current_function_auto_return_pattern);
+		 DECL_SAVED_AUTO_RETURN_TYPE (fndecl));
 	  inform (input_location, "only plain %<auto%> return type can be "
 		  "deduced to %<void%>");
 	}
+}
+/* Remember that we were in class scope.  */
+if (current_class_name)
+ctype = current_class_type;
+if (DECL_DELETED_FN (fndecl))
+{
+DECL_INITIAL (fndecl) = error_mark_node;
+DECL_SAVED_TREE (fndecl) = NULL_TREE;
+goto cleanup;
 }
 // If this is a concept, check that the definition is reasonable.
 if (DECL_DECLARED_CONCEPT_P (fndecl))
 check_function_concept (fndecl);
+if (flag_openmp)
+if (tree attr = lookup_attribute ("omp declare variant base",
+				      DECL_ATTRIBUTES (fndecl)))
+omp_declare_variant_finalize (fndecl, attr);
 /* Lambda closure members are implicitly constexpr if possible.  */
 if (cxx_dialect >= cxx17
 && LAMBDA_TYPE_P (CP_DECL_CONTEXT (fndecl)))
 DECL_DECLARED_CONSTEXPR_P (fndecl)
 /* Invoke the pre-genericize plugin before we start munging things.  */
 if (!processing_template_decl)
 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE, fndecl);
 /* Perform delayed folding before NRV transformation.  */
-if (!processing_template_decl)
+if (!processing_template_decl
+&& !DECL_IMMEDIATE_FUNCTION_P (fndecl)
+&& !DECL_OMP_DECLARE_REDUCTION_P (fndecl))
 cp_fold_function (fndecl);
 /* Set up the named return value optimization, if we can.  Candidate
 variables are selected in check_return_expr.  */
 if (current_function_return_value)
 	finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
 current_function_return_value = NULL_TREE;
 }
-/* Remember that we were in class scope.  */
-if (current_class_name)
-ctype = current_class_type;
 /* Must mark the RESULT_DECL as being in this function.  */
 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
 to the FUNCTION_DECL node itself.  */
 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
-/* Save away current state, if appropriate.  */
-if (!processing_template_decl)
-save_function_data (fndecl);
 /* Complain if there's just no return statement.  */
 if (warn_return_type
 && !VOID_TYPE_P (TREE_TYPE (fntype))
 && !dependent_type_p (TREE_TYPE (fntype))
 	 assignment operators.  */
 if (IDENTIFIER_ASSIGN_OP_P (DECL_NAME (fndecl)))
 	{
 	  tree valtype = TREE_TYPE (DECL_RESULT (fndecl));
 	  if (TREE_CODE (valtype) == REFERENCE_TYPE
+	      && current_class_ref
 	      && same_type_ignoring_top_level_qualifiers_p
-		  (TREE_TYPE (valtype), TREE_TYPE (current_class_ref)))
+		  (TREE_TYPE (valtype), TREE_TYPE (current_class_ref))
-	    if (global_dc->option_enabled (OPT_Wreturn_type,
+	      && global_dc->option_enabled (OPT_Wreturn_type,
-					   global_dc->option_state))
+					    global_dc->lang_mask,
-	      add_return_star_this_fixit (&richloc, fndecl);
+					    global_dc->option_state))
-	}
+	    add_return_star_this_fixit (&richloc, fndecl);
-warning_at (&richloc, OPT_Wreturn_type,
+	}
-		  "no return statement in function returning non-void");
+if (warning_at (&richloc, OPT_Wreturn_type,
-TREE_NO_WARNING (fndecl) = 1;
+	  "no return statement in function returning non-void"))
+	TREE_NO_WARNING (fndecl) = 1;
 }
 /* Store the end of the function, so that we get good line number
 info for the epilogue.  */
 cfun->function_end_locus = input_location;
 && !processing_template_decl
 && !DECL_CLONED_FUNCTION_P (fndecl))
 do_warn_unused_parameter (fndecl);
 /* Genericize before inlining.  */
-if (!processing_template_decl)
+if (!processing_template_decl
-{
+&& !DECL_IMMEDIATE_FUNCTION_P (fndecl)
-struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
+&& !DECL_OMP_DECLARE_REDUCTION_P (fndecl))
 cp_genericize (fndecl);
-/* Clear out the bits we don't need.  */
-f->x_current_class_ptr = NULL;
+/* Emit the resumer and destroyer functions now.  */
-f->x_current_class_ref = NULL;
+if (coro_p)
-f->x_eh_spec_block = NULL;
+{
-f->x_in_charge_parm = NULL;
+emit_coro_helper (resumer);
-f->x_vtt_parm = NULL;
+emit_coro_helper (destroyer);
-f->x_return_value = NULL;
+}
-f->bindings = NULL;
-f->extern_decl_map = NULL;
+cleanup:
-f->infinite_loops = NULL;
-}
-/* Clear out the bits we don't need.  */
-local_names = NULL;
 /* We're leaving the context of this function, so zap cfun.  It's still in
 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation.  */
 set_cfun (NULL);
 current_function_decl = NULL;
 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
 				&attrlist);
 if (fndecl == error_mark_node)
 return error_mark_node;
-if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
-{
-error ("invalid member function declaration");
-return error_mark_node;
-}
 if (attrlist)
 cplus_decl_attributes (&fndecl, attrlist, 0);
 /* Pass friends other than inline friend functions back.  */
 if (TREE_CODE (type) == ARRAY_TYPE)
 	addr = decl;
 else
 	addr = build_address (decl);
-call = build_delete (TREE_TYPE (addr), addr,
+call = build_delete (input_location, TREE_TYPE (addr), addr,
 			   sfk_complete_destructor, flags, 0, complain);
 if (call == error_mark_node)
 	cleanup = error_mark_node;
 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
 	/* Discard the call.  */;
+else if (decl_maybe_constant_destruction (decl, type)
+	       && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
+	cxx_constant_dtor (call, decl);
 else if (cleanup)
 	cleanup = cp_build_compound_expr (cleanup, call, complain);
 else
 	cleanup = call;
 }
 called later, at the end of the current scope.  This can lead to
 a "jumpy" behavior for users of debuggers when they step around
 the end of the block.  So let's unset the location of the
 destructor call instead.  */
 protected_set_expr_location (cleanup, UNKNOWN_LOCATION);
+if (cleanup && CONVERT_EXPR_P (cleanup))
+protected_set_expr_location (TREE_OPERAND (cleanup, 0), UNKNOWN_LOCATION);
 if (cleanup
 && DECL_P (decl)
 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl)))
 /* Treat objects with destructors as used; the destructor may do
 	 something substantive.  */
 && !mark_used (decl, complain) && !(complain & tf_error))
 return error_mark_node;
+if (cleanup && cfun && !processing_template_decl
+&& !expr_noexcept_p (cleanup, tf_none))
+cp_function_chain->throwing_cleanup = true;
 return cleanup;
 }
 enum cp_tree_node_structure_enum
 cp_tree_node_structure (union lang_tree_node * t)
 {
 switch (TREE_CODE (&t->generic))
 {
-case DEFAULT_ARG:		return TS_CP_DEFAULT_ARG;
+case ARGUMENT_PACK_SELECT:  return TS_CP_ARGUMENT_PACK_SELECT;
+case BASELINK:		return TS_CP_BASELINK;
+case CONSTRAINT_INFO:       return TS_CP_CONSTRAINT_INFO;
 case DEFERRED_NOEXCEPT:	return TS_CP_DEFERRED_NOEXCEPT;
+case DEFERRED_PARSE:	return TS_CP_DEFERRED_PARSE;
 case IDENTIFIER_NODE:	return TS_CP_IDENTIFIER;
+case LAMBDA_EXPR:		return TS_CP_LAMBDA_EXPR;
 case OVERLOAD:		return TS_CP_OVERLOAD;
+case PTRMEM_CST:		return TS_CP_PTRMEM;
+case STATIC_ASSERT:		return TS_CP_STATIC_ASSERT;
+case TEMPLATE_DECL:		return TS_CP_TEMPLATE_DECL;
+case TEMPLATE_INFO:		return TS_CP_TEMPLATE_INFO;
 case TEMPLATE_PARM_INDEX:	return TS_CP_TPI;
-case PTRMEM_CST:		return TS_CP_PTRMEM;
-case BASELINK:		return TS_CP_BASELINK;
-case TEMPLATE_DECL:		return TS_CP_TEMPLATE_DECL;
-case STATIC_ASSERT:		return TS_CP_STATIC_ASSERT;
-case ARGUMENT_PACK_SELECT:  return TS_CP_ARGUMENT_PACK_SELECT;
 case TRAIT_EXPR:		return TS_CP_TRAIT_EXPR;
-case LAMBDA_EXPR:		return TS_CP_LAMBDA_EXPR;
-case TEMPLATE_INFO:		return TS_CP_TEMPLATE_INFO;
-case CONSTRAINT_INFO:       return TS_CP_CONSTRAINT_INFO;
 case USERDEF_LITERAL:	return TS_CP_USERDEF_LITERAL;
 default:			return TS_CP_GENERIC;
 }
 }
 tree
 fndecl_declared_return_type (tree fn)
 {
 fn = STRIP_TEMPLATE (fn);
 if (FNDECL_USED_AUTO (fn))
-{
+return DECL_SAVED_AUTO_RETURN_TYPE (fn);
-struct language_function *f = NULL;
-if (DECL_STRUCT_FUNCTION (fn))
-	f = DECL_STRUCT_FUNCTION (fn)->language;
-if (f == NULL)
-	f = DECL_SAVED_FUNCTION_DATA (fn);
-return f->x_auto_return_pattern;
-}
 return TREE_TYPE (TREE_TYPE (fn));
 }
 /* Returns true iff DECL is a variable or function declared with an auto type
 that has not yet been deduced to a real type.  */
 bool
 undeduced_auto_decl (tree decl)
 {
 if (cxx_dialect < cxx11)
 return false;
+STRIP_ANY_LOCATION_WRAPPER (decl);
 return ((VAR_OR_FUNCTION_DECL_P (decl)
 	   || TREE_CODE (decl) == TEMPLATE_DECL)
 	  && type_uses_auto (TREE_TYPE (decl)));
 }
 bool
 require_deduced_type (tree decl, tsubst_flags_t complain)
 {
 if (undeduced_auto_decl (decl))
 {
-if (complain & tf_error)
+if (TREE_NO_WARNING (decl) && seen_error ())
+	/* We probably already complained about deduction failure.  */;
+else if (complain & tf_error)
 	error ("use of %qD before deduction of %<auto%>", decl);
 return false;
 }
 return true;
 }
+/* Create a representation of the explicit-specifier with
+constant-expression of EXPR.  COMPLAIN is as for tsubst.  */
+tree
+build_explicit_specifier (tree expr, tsubst_flags_t complain)
+{
+if (instantiation_dependent_expression_p (expr))
+/* Wait for instantiation, tsubst_function_decl will handle it.  */
+return expr;
+expr = instantiate_non_dependent_expr_sfinae (expr, complain);
+/* Don't let convert_like_real create more template codes.  */
+processing_template_decl_sentinel s;
+expr = build_converted_constant_bool_expr (expr, complain);
+expr = cxx_constant_value (expr);
+return expr;
+}
 #include "gt-cp-decl.h"

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cp/decl.c @ 145:1830386684a0