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

comparison gcc/cp/class.c @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 /* Functions related to building classes and their related objects.
-Copyright (C) 1987-2017 Free Software Foundation, Inc.
+Copyright (C) 1987-2018 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
 static void determine_primary_bases (tree);
 static void maybe_warn_about_overly_private_class (tree);
 static void add_implicitly_declared_members (tree, tree*, int, int);
 static tree fixed_type_or_null (tree, int *, int *);
 static tree build_simple_base_path (tree expr, tree binfo);
-static tree build_vtbl_ref_1 (tree, tree);
 static void build_vtbl_initializer (tree, tree, tree, tree, int *,
 				    vec<constructor_elt, va_gc> **);
 static bool check_bitfield_decl (tree);
 static bool check_field_decl (tree, tree, int *, int *);
 static void check_field_decls (tree, tree *, int *, int *);
 static void dump_thunk (FILE *, int, tree);
 static tree build_vtable (tree, tree, tree);
 static void initialize_vtable (tree, vec<constructor_elt, va_gc> *);
 static void layout_nonempty_base_or_field (record_layout_info,
 					   tree, tree, splay_tree);
-static tree end_of_class (tree, int);
-static bool layout_empty_base (record_layout_info, tree, tree, splay_tree);
 static void accumulate_vtbl_inits (tree, tree, tree, tree, tree,
 				   vec<constructor_elt, va_gc> **);
 static void dfs_accumulate_vtbl_inits (tree, tree, tree, tree, tree,
 				       vec<constructor_elt, va_gc> **);
 static void build_rtti_vtbl_entries (tree, vtbl_init_data *);
 static tree dfs_fixup_binfo_vtbls (tree, void *);
 static int record_subobject_offset (tree, tree, splay_tree);
 static int check_subobject_offset (tree, tree, splay_tree);
 static int walk_subobject_offsets (tree, subobject_offset_fn,
 				   tree, splay_tree, tree, int);
-static void record_subobject_offsets (tree, tree, splay_tree, bool);
 static int layout_conflict_p (tree, tree, splay_tree, int);
 static int splay_tree_compare_integer_csts (splay_tree_key k1,
 					    splay_tree_key k2);
 static void warn_about_ambiguous_bases (tree);
 static bool type_requires_array_cookie (tree);
 static bool base_derived_from (tree, tree);
 static int empty_base_at_nonzero_offset_p (tree, tree, splay_tree);
 static tree end_of_base (tree);
 static tree get_vcall_index (tree, tree);
 static bool type_maybe_constexpr_default_constructor (tree);
-/* Variables shared between class.c and call.c.  */
-int n_vtables = 0;
-int n_vtable_entries = 0;
-int n_vtable_searches = 0;
-int n_vtable_elems = 0;
-int n_convert_harshness = 0;
-int n_compute_conversion_costs = 0;
-int n_inner_fields_searched = 0;
 /* Return a COND_EXPR that executes TRUE_STMT if this execution of the
 'structor is in charge of 'structing virtual bases, or FALSE_STMT
 otherwise.  */
 }
 probe = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
 if (want_pointer)
 probe = TYPE_MAIN_VARIANT (TREE_TYPE (probe));
+if (dependent_type_p (probe))
+if (tree open = currently_open_class (probe))
+probe = open;
 if (code == PLUS_EXPR
 && !SAME_BINFO_TYPE_P (BINFO_TYPE (d_binfo), probe))
 {
 /* This can happen when adjust_result_of_qualified_name_lookup can't
 {
 expr = build_nop (ptr_target_type, expr);
 goto indout;
 }
+if (!COMPLETE_TYPE_P (probe))
+{
+if (complain & tf_error)
+	error ("cannot convert from %qT to base class %qT because %qT is "
+	       "incomplete", BINFO_TYPE (d_binfo), BINFO_TYPE (binfo),
+	       BINFO_TYPE (d_binfo));
+return error_mark_node;
+}
 /* If we're in an NSDMI, we don't have the full constructor context yet
 that we need for converting to a virtual base, so just build a stub
 CONVERT_EXPR and expand it later in bot_replace.  */
 if (virtual_access && fixed_type_p < 0
 && current_scope () != current_function_decl)
 if (code == PLUS_EXPR && !virtual_access
 /* We don't build base fields for empty bases, and they aren't very
 	 interesting to the optimizers anyway.  */
 && !has_empty)
 {
-expr = cp_build_indirect_ref (expr, RO_NULL, complain);
+expr = cp_build_fold_indirect_ref (expr);
 expr = build_simple_base_path (expr, binfo);
-if (rvalue)
+if (rvalue && lvalue_p (expr))
 	expr = move (expr);
 if (want_pointer)
 	expr = build_address (expr);
 target_type = TREE_TYPE (expr);
 goto out;
 	  tree t;
 	  t = TREE_TYPE (TYPE_VFIELD (current_class_type));
 	  t = build_pointer_type (t);
 	  v_offset = fold_convert (t, current_vtt_parm);
-	  v_offset = cp_build_indirect_ref (v_offset, RO_NULL, complain);
+	  v_offset = cp_build_fold_indirect_ref (v_offset);
 	}
 else
 	{
 	  tree t = expr;
 	  if (sanitize_flags_p (SANITIZE_VPTR)
 	      t = cp_ubsan_maybe_instrument_cast_to_vbase (input_location,
 							   probe, expr);
 	      if (t == NULL_TREE)
 		t = expr;
 	    }
-	  v_offset = build_vfield_ref (cp_build_indirect_ref (t, RO_NULL,
+	  v_offset = build_vfield_ref (cp_build_fold_indirect_ref (t),
-							      complain),
 	  TREE_TYPE (TREE_TYPE (expr)));
 	}
 if (v_offset == error_mark_node)
 	return error_mark_node;
 v_offset = fold_build_pointer_plus (v_offset, BINFO_VPTR_FIELD (v_binfo));
 v_offset = build1 (NOP_EXPR,
 			 build_pointer_type (ptrdiff_type_node),
 			 v_offset);
-v_offset = cp_build_indirect_ref (v_offset, RO_NULL, complain);
+v_offset = cp_build_fold_indirect_ref (v_offset);
 TREE_CONSTANT (v_offset) = 1;
 offset = convert_to_integer (ptrdiff_type_node,
 				   size_diffop_loc (input_location, offset,
 						BINFO_OFFSET (v_binfo)));
 null_test = NULL;
 indout:
 if (!want_pointer)
 {
-expr = cp_build_indirect_ref (expr, RO_NULL, complain);
+expr = cp_build_fold_indirect_ref (expr);
 if (rvalue)
 	expr = move (expr);
 }
 out:
 	 into `(*(a ?  &b : &c)).x', and so on.  A COND_EXPR is only
 	 an lvalue in the front end; only _DECLs and _REFs are lvalues
 	 in the back end.  */
 temp = unary_complex_lvalue (ADDR_EXPR, expr);
 if (temp)
-	expr = cp_build_indirect_ref (temp, RO_NULL, tf_warning_or_error);
+	expr = cp_build_fold_indirect_ref (temp);
 return expr;
 }
 /* Recurse.  */
 /* Given an object INSTANCE, return an expression which yields the
 vtable element corresponding to INDEX.  There are many special
 cases for INSTANCE which we take care of here, mainly to avoid
 creating extra tree nodes when we don't have to.  */
-static tree
+tree
-build_vtbl_ref_1 (tree instance, tree idx)
+build_vtbl_ref (tree instance, tree idx)
 {
 tree aref;
 tree vtbl = NULL_TREE;
 /* Try to figure out what a reference refers to, and
 TREE_CONSTANT (aref) |= TREE_CONSTANT (vtbl) && TREE_CONSTANT (idx);
 return aref;
 }
-tree
-build_vtbl_ref (tree instance, tree idx)
-{
-tree aref = build_vtbl_ref_1 (instance, idx);
-return aref;
-}
 /* Given a stable object pointer INSTANCE_PTR, return an expression which
 yields a function pointer corresponding to vtable element INDEX.  */
 tree
 build_vfn_ref (tree instance_ptr, tree idx)
 {
 tree aref;
-aref = build_vtbl_ref_1 (cp_build_indirect_ref (instance_ptr, RO_NULL,
+aref = build_vtbl_ref (cp_build_fold_indirect_ref (instance_ptr), idx);
-tf_warning_or_error),
-idx);
 /* When using function descriptors, the address of the
 vtable entry is treated as a function pointer.  */
 if (TARGET_VTABLE_USES_DESCRIPTORS)
 aref = build1 (NOP_EXPR, TREE_TYPE (aref),
 {
 gcc_assert (TREE_TYPE (decl) == vtbl_type_node);
 virtuals = NULL_TREE;
 }
-if (GATHER_STATISTICS)
-{
-n_vtables += 1;
-n_vtable_elems += list_length (virtuals);
-}
 /* Initialize the association list for this type, based
 on our first approximation.  */
 BINFO_VTABLE (TYPE_BINFO (type)) = decl;
 BINFO_VIRTUALS (TYPE_BINFO (type)) = virtuals;
 SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type));
 add_method (tree type, tree method, bool via_using)
 {
 if (method == error_mark_node)
 return false;
-/* Maintain TYPE_HAS_USER_CONSTRUCTOR, etc.  */
-grok_special_member_properties (method);
-tree *slot = get_member_slot (type, DECL_NAME (method));
-tree current_fns = *slot;
 gcc_assert (!DECL_EXTERN_C_P (method));
+tree *slot = find_member_slot (type, DECL_NAME (method));
+tree current_fns = slot ? *slot : NULL_TREE;
 /* Check to see if we've already got this method.  */
 for (ovl_iterator iter (current_fns); iter; ++iter)
 {
 tree fn = *iter;
 && equivalently_constrained (fn, method))
 	{
 	  /* If these are versions of the same function, process and
 	     move on.  */
 	  if (TREE_CODE (fn) == FUNCTION_DECL
-	      && maybe_version_functions (method, fn))
+	      && maybe_version_functions (method, fn, true))
 	    continue;
 	  if (DECL_INHERITED_CTOR (method))
 	    {
 	      if (DECL_INHERITED_CTOR (fn))
 /* A class should never have more than one destructor.  */
 gcc_assert (!current_fns || !DECL_DESTRUCTOR_P (method));
 current_fns = ovl_insert (method, current_fns, via_using);
-if (!DECL_CONV_FN_P (method) && !COMPLETE_TYPE_P (type))
+if (!COMPLETE_TYPE_P (type) && !DECL_CONV_FN_P (method)
-push_class_level_binding (DECL_NAME (method), current_fns);
+&& !push_class_level_binding (DECL_NAME (method), current_fns))
+return false;
+if (!slot)
+slot = add_member_slot (type, DECL_NAME (method));
+/* Maintain TYPE_HAS_USER_CONSTRUCTOR, etc.  */
+grok_special_member_properties (method);
 *slot = current_fns;
 return true;
 }
 	}
 /* Otherwise we're diagnosing missing tags.  */
 if (TREE_CODE (p->t) == FUNCTION_DECL)
 	{
+	  auto_diagnostic_group d;
 	  if (warning (OPT_Wabi_tag, "%qD inherits the %E ABI tag "
 		       "that %qT (used in its return type) has",
 		       p->t, tag, *tp))
 	    inform (location_of (*tp), "%qT declared here", *tp);
 	}
 else if (VAR_P (p->t))
 	{
+	  auto_diagnostic_group d;
 	  if (warning (OPT_Wabi_tag, "%qD inherits the %E ABI tag "
 		       "that %qT (used in its type) has", p->t, tag, *tp))
 	    inform (location_of (*tp), "%qT declared here", *tp);
 	}
 else if (TYPE_P (p->subob))
 	{
+	  auto_diagnostic_group d;
 	  if (warning (OPT_Wabi_tag, "%qT does not have the %E ABI tag "
 		       "that base %qT has", p->t, tag, p->subob))
 	    inform (location_of (p->subob), "%qT declared here",
 		    p->subob);
 	}
 else
 	{
+	  auto_diagnostic_group d;
 	  if (warning (OPT_Wabi_tag, "%qT does not have the %E ABI tag "
 		       "that %qT (used in the type of %qD) has",
 		       p->t, tag, *tp, p->subob))
 	    {
 	      inform (location_of (p->subob), "%qD declared here",
 tree attr = lookup_attribute ("abi_tag", DECL_ATTRIBUTES (t));
 if (attr)
 	TREE_VALUE (attr) = chainon (data.tags, TREE_VALUE (attr));
 else
 	DECL_ATTRIBUTES (t)
-	  = tree_cons (get_identifier ("abi_tag"), data.tags,
+	  = tree_cons (abi_tag_identifier, data.tags, DECL_ATTRIBUTES (t));
-		       DECL_ATTRIBUTES (t));
 }
 mark_abi_tags (t, false);
 return data.tags;
 tree attr = lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (t));
 if (attr)
 	TREE_VALUE (attr) = chainon (data.tags, TREE_VALUE (attr));
 else
 	TYPE_ATTRIBUTES (t)
-	  = tree_cons (get_identifier ("abi_tag"), data.tags,
+	  = tree_cons (abi_tag_identifier, data.tags, TYPE_ATTRIBUTES (t));
-		       TYPE_ATTRIBUTES (t));
 }
 mark_abi_tags (t, false);
 }
 static void
 maybe_warn_about_overly_private_class (tree t)
 {
 int has_member_fn = 0;
 int has_nonprivate_method = 0;
+bool nonprivate_ctor = false;
 if (!warn_ctor_dtor_privacy
 /* If the class has friends, those entities might create and
 	 access instances, so we should not warn.  */
 || (CLASSTYPE_FRIEND_CLASSES (t)
 /* Check to see if all (non-constructor, non-destructor) member
 functions are private.  (Since there are no friends or
 non-private statics, we can't ever call any of the private member
 functions.)  */
 for (tree fn = TYPE_FIELDS (t); fn; fn = DECL_CHAIN (fn))
-if (!DECL_DECLARES_FUNCTION_P (fn))
+if (TREE_CODE (fn) == USING_DECL
+	&& DECL_NAME (fn) == ctor_identifier
+	&& !TREE_PRIVATE (fn))
+nonprivate_ctor = true;
+else if (!DECL_DECLARES_FUNCTION_P (fn))
 /* Not a function.  */;
 else if (DECL_ARTIFICIAL (fn))
 /* We're not interested in compiler-generated methods; they don't
 	 provide any way to call private members.  */;
 else if (!TREE_PRIVATE (fn))
 /* Warn about classes that have private constructors and no friends.  */
 if (TYPE_HAS_USER_CONSTRUCTOR (t)
 /* Implicitly generated constructors are always public.  */
 && !CLASSTYPE_LAZY_DEFAULT_CTOR (t))
 {
-bool nonprivate_ctor = false;
 tree copy_or_move = NULL_TREE;
 /* If a non-template class does not define a copy
 	 constructor, one is defined for it, enabling it to avoid
 	 this warning.  For a template class, this does not
 /* Check for adjusting covariant return types.  */
 over_return = TREE_TYPE (TREE_TYPE (overrider_target));
 base_return = TREE_TYPE (TREE_TYPE (target_fn));
-if (POINTER_TYPE_P (over_return)
+if (INDIRECT_TYPE_P (over_return)
 && TREE_CODE (over_return) == TREE_CODE (base_return)
 && CLASS_TYPE_P (TREE_TYPE (over_return))
 && CLASS_TYPE_P (TREE_TYPE (base_return))
 /* If the overrider is invalid, don't even try.  */
 && !DECL_INVALID_OVERRIDER_P (overrider_target))
 	     has already been checked), so we can just iterate along
 	     the binfos, which have been chained in inheritance graph
 	     order.  Of course it is lame that we have to repeat the
 	     search here anyway -- we should really be caching pieces
 	     of the vtable and avoiding this repeated work.  */
-	  tree thunk_binfo, base_binfo;
+	  tree thunk_binfo = NULL_TREE;
+	  tree base_binfo = TYPE_BINFO (base_return);
 	  /* Find the base binfo within the overriding function's
 	     return type.  We will always find a thunk_binfo, except
 	     when the covariancy is invalid (which we will have
 	     already diagnosed).  */
-	  for (base_binfo = TYPE_BINFO (base_return),
+	  if (base_binfo)
-	       thunk_binfo = TYPE_BINFO (over_return);
+	    for (thunk_binfo = TYPE_BINFO (over_return); thunk_binfo;
-	       thunk_binfo;
+		 thunk_binfo = TREE_CHAIN (thunk_binfo))
-	       thunk_binfo = TREE_CHAIN (thunk_binfo))
+	      if (SAME_BINFO_TYPE_P (BINFO_TYPE (thunk_binfo),
-	    if (SAME_BINFO_TYPE_P (BINFO_TYPE (thunk_binfo),
+				     BINFO_TYPE (base_binfo)))
-				   BINFO_TYPE (base_binfo)))
+		break;
-	      break;
+	  gcc_assert (thunk_binfo || errorcount);
 	  /* See if virtual inheritance is involved.  */
 	  for (virtual_offset = thunk_binfo;
 	       virtual_offset;
 	       virtual_offset = BINFO_INHERITANCE_CHAIN (virtual_offset))
 /* Recursive helper for finish_struct_anon.  */
 static void
 finish_struct_anon_r (tree field, bool complain)
 {
-bool is_union = TREE_CODE (TREE_TYPE (field)) == UNION_TYPE;
+for (tree elt = TYPE_FIELDS (TREE_TYPE (field)); elt; elt = DECL_CHAIN (elt))
-tree elt = TYPE_FIELDS (TREE_TYPE (field));
-for (; elt; elt = DECL_CHAIN (elt))
 {
 /* We're generally only interested in entities the user
 	 declared, but we also find nested classes by noticing
 	 the TYPE_DECL that we create implicitly.  You're
 	 allowed to put one anonymous union inside another,
 if (DECL_ARTIFICIAL (elt)
 	  && (!DECL_IMPLICIT_TYPEDEF_P (elt)
 	      || TYPE_UNNAMED_P (TREE_TYPE (elt))))
 	continue;
-if (TREE_CODE (elt) != FIELD_DECL)
+if (complain
+	  && (TREE_CODE (elt) != FIELD_DECL
+	      || (TREE_PRIVATE (elt) || TREE_PROTECTED (elt))))
 	{
 	  /* We already complained about static data members in
 	     finish_static_data_member_decl.  */
-	  if (complain && !VAR_P (elt))
+	  if (!VAR_P (elt))
 	    {
-	      if (is_union)
+	      auto_diagnostic_group d;
-		permerror (DECL_SOURCE_LOCATION (elt),
+	      if (permerror (DECL_SOURCE_LOCATION (elt),
-			   "%q#D invalid; an anonymous union can "
+			     TREE_CODE (TREE_TYPE (field)) == UNION_TYPE
-			   "only have non-static data members", elt);
+			     ? "%q#D invalid; an anonymous union may "
-	      else
+			     "only have public non-static data members"
-		permerror (DECL_SOURCE_LOCATION (elt),
+			     : "%q#D invalid; an anonymous struct may "
-			   "%q#D invalid; an anonymous struct can "
+			     "only have public non-static data members", elt))
-			   "only have non-static data members", elt);
+		{
-	    }
+		  static bool hint;
-	  continue;
+		  if (flag_permissive && !hint)
-	}
+		    {
+		      hint = true;
-if (complain)
+		      inform (DECL_SOURCE_LOCATION (elt),
-	{
+			      "this flexibility is deprecated and will be "
-	  if (TREE_PRIVATE (elt))
+			      "removed");
-	    {
+		    }
-	      if (is_union)
+		}
-		permerror (DECL_SOURCE_LOCATION (elt),
-			   "private member %q#D in anonymous union", elt);
-	      else
-		permerror (DECL_SOURCE_LOCATION (elt),
-			   "private member %q#D in anonymous struct", elt);
-	    }
-	  else if (TREE_PROTECTED (elt))
-	    {
-	      if (is_union)
-		permerror (DECL_SOURCE_LOCATION (elt),
-			   "protected member %q#D in anonymous union", elt);
-	      else
-		permerror (DECL_SOURCE_LOCATION (elt),
-			   "protected member %q#D in anonymous struct", elt);
 	    }
 	}
 TREE_PRIVATE (elt) = TREE_PRIVATE (field);
 TREE_PROTECTED (elt) = TREE_PROTECTED (field);
-/* Recurse into the anonymous aggregates to handle correctly
+/* Recurse into the anonymous aggregates to correctly handle
 	 access control (c++/24926):
 	 class A {
 	   union {
 	     union {
 static tree
 dfs_declare_virt_assop_and_dtor (tree binfo, void *data)
 {
 tree bv, fn, t = (tree)data;
-tree opname = cp_assignment_operator_id (NOP_EXPR);
+tree opname = assign_op_identifier;
 gcc_assert (t && CLASS_TYPE_P (t));
 gcc_assert (binfo && TREE_CODE (binfo) == TREE_BINFO);
 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
 /* We don't declare an inheriting ctor that would be a default,
 copy or move ctor for derived or base.  */
 if (nparms == 0)
 return;
 if (nparms == 1
-&& TREE_CODE (parms[0]) == REFERENCE_TYPE)
+&& TYPE_REF_P (parms[0]))
 {
 tree parm = TYPE_MAIN_VARIANT (TREE_TYPE (parms[0]));
 if (parm == t || parm == DECL_CONTEXT (ctor))
 	return;
 }
 new_parms[i++] = TREE_VALUE (parms);
 }
 one_inheriting_sig (t, ctor, new_parms, i);
 if (parms == NULL_TREE)
 {
+auto_diagnostic_group d;
 if (warning (OPT_Winherited_variadic_ctor,
 		   "the ellipsis in %qD is not inherited", ctor))
 	inform (DECL_SOURCE_LOCATION (ctor), "%qD declared here", ctor);
 }
 }
 	       || ((TREE_CODE (type) == ENUMERAL_TYPE
 		    || TREE_CODE (type) == BOOLEAN_TYPE)
 		   && tree_int_cst_lt (TYPE_SIZE (type), w)))
 	warning_at (DECL_SOURCE_LOCATION (field), 0,
 		    "width of %qD exceeds its type", field);
-else if (TREE_CODE (type) == ENUMERAL_TYPE
+else if (TREE_CODE (type) == ENUMERAL_TYPE)
-	       && (0 > (compare_tree_int
+	{
-			(w, TYPE_PRECISION (ENUM_UNDERLYING_TYPE (type))))))
+	  int prec = TYPE_PRECISION (ENUM_UNDERLYING_TYPE (type));
-	warning_at (DECL_SOURCE_LOCATION (field), 0,
+	  if (compare_tree_int (w, prec) < 0)
-		    "%qD is too small to hold all values of %q#T",
+	    warning_at (DECL_SOURCE_LOCATION (field), 0,
-		    field, type);
+			"%qD is too small to hold all values of %q#T",
+			field, type);
+	}
 }
 if (w != error_mark_node)
 {
 DECL_SIZE (field) = fold_convert (bitsizetype, w);
 	    {
 	      error ("in C++98 %q+D may not be static because it is "
 		     "a member of a union", x);
 	      continue;
 	    }
-	  if (TREE_CODE (type) == REFERENCE_TYPE
+	  if (TYPE_REF_P (type)
 	      && TREE_CODE (x) == FIELD_DECL)
 	    {
 	      error ("non-static data member %q+D in a union may not "
 		     "have reference type %qT", x, type);
 	      continue;
 	field_access = this_field_access;
 else if (this_field_access != field_access)
 	CLASSTYPE_NON_STD_LAYOUT (t) = 1;
 /* If this is of reference type, check if it needs an init.  */
-if (TREE_CODE (type) == REFERENCE_TYPE)
+if (TYPE_REF_P (type))
 	{
 	  CLASSTYPE_NON_LAYOUT_POD_P (t) = 1;
 	  CLASSTYPE_NON_STD_LAYOUT (t) = 1;
 	  if (DECL_INITIAL (x) == NULL_TREE)
 	    SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
 	    {
 	      error ("member %q+D cannot be declared both %<const%> "
 		     "and %<mutable%>", x);
 	      continue;
 	    }
-	  if (TREE_CODE (type) == REFERENCE_TYPE)
+	  if (TYPE_REF_P (type))
 	    {
 	      error ("member %q+D cannot be declared as a %<mutable%> "
 		     "reference", x);
 	      continue;
 	    }
 }
 return 0;
 }
-/* Record all of the empty subobjects of TYPE (either a type or a
+/* Return true iff FIELD_DECL DECL is potentially overlapping.  */
-binfo).  If IS_DATA_MEMBER is true, then a non-static data member
-is being placed at OFFSET; otherwise, it is a base class that is
+static bool
-being placed at OFFSET.  */
+field_poverlapping_p (tree decl)
+{
+/* Base fields are actually potentially overlapping, but C++ bases go through
+a different code path based on binfos, and ObjC++ base fields are laid out
+in objc-act, so we don't want layout_class_type to mess with them.  */
+if (DECL_FIELD_IS_BASE (decl))
+{
+gcc_checking_assert (c_dialect_objc ());
+return false;
+}
+return lookup_attribute ("no_unique_address",
+			   DECL_ATTRIBUTES (decl));
+}
+/* Record all of the empty subobjects of DECL_OR_BINFO.  */
 static void
-record_subobject_offsets (tree type,
+record_subobject_offsets (tree decl_or_binfo,
-			  tree offset,
+			  splay_tree offsets)
-			  splay_tree offsets,
+{
-			  bool is_data_member)
+tree type, offset;
-{
+bool overlapping, vbases_p;
+if (DECL_P (decl_or_binfo))
+{
+tree decl = decl_or_binfo;
+type = TREE_TYPE (decl);
+offset = byte_position (decl);
+overlapping = field_poverlapping_p (decl);
+vbases_p = true;
+}
+else
+{
+type = BINFO_TYPE (decl_or_binfo);
+offset = BINFO_OFFSET (decl_or_binfo);
+overlapping = true;
+vbases_p = false;
+}
 tree max_offset;
 /* If recording subobjects for a non-static data member or a
-non-empty base class , we do not need to record offsets beyond
+non-empty base class, we do not need to record offsets beyond
 the size of the biggest empty class.  Additional data members
 will go at the end of the class.  Additional base classes will go
 either at offset zero (if empty, in which case they cannot
 overlap with offsets past the size of the biggest empty class) or
 at the end of the class.
 However, if we are placing an empty base class, then we must record
 all offsets, as either the empty class is at offset zero (where
 other empty classes might later be placed) or at the end of the
 class (where other objects might then be placed, so other empty
 subobjects might later overlap).  */
-if (is_data_member
+if (!overlapping
-|| !is_empty_class (BINFO_TYPE (type)))
+|| !is_empty_class (type))
 max_offset = sizeof_biggest_empty_class;
 else
 max_offset = NULL_TREE;
 walk_subobject_offsets (type, record_subobject_offset, offset,
-			  offsets, max_offset, is_data_member);
+			  offsets, max_offset, vbases_p);
 }
 /* Returns nonzero if any of the empty subobjects of TYPE (located at
 OFFSET) conflict with entries in OFFSETS.  If VBASES_P is nonzero,
 virtual bases of TYPE are examined.  */
 class of the type indicated by BINFO; OFFSETS gives the offsets of
 the empty bases allocated so far. T is the most derived
 type.  Return nonzero iff we added it at the end.  */
 static bool
-layout_empty_base (record_layout_info rli, tree binfo,
+layout_empty_base_or_field (record_layout_info rli, tree binfo_or_decl,
-		   tree eoc, splay_tree offsets)
+			    splay_tree offsets)
 {
 tree alignment;
-tree basetype = BINFO_TYPE (binfo);
 bool atend = false;
+tree binfo = NULL_TREE;
+tree decl = NULL_TREE;
+tree type;
+if (TREE_CODE (binfo_or_decl) == TREE_BINFO)
+{
+binfo = binfo_or_decl;
+type = BINFO_TYPE (binfo);
+}
+else
+{
+decl = binfo_or_decl;
+type = TREE_TYPE (decl);
+}
+/* On some platforms (ARM), even empty classes will not be
+byte-aligned.  */
+tree eoc = round_up_loc (input_location,
+			   rli_size_unit_so_far (rli),
+			   CLASSTYPE_ALIGN_UNIT (type));
 /* This routine should only be used for empty classes.  */
-gcc_assert (is_empty_class (basetype));
+gcc_assert (is_empty_class (type));
-alignment = ssize_int (CLASSTYPE_ALIGN_UNIT (basetype));
+alignment = size_int (CLASSTYPE_ALIGN_UNIT (type));
-if (!integer_zerop (BINFO_OFFSET (binfo)))
-propagate_binfo_offsets
-(binfo, size_diffop_loc (input_location,
-			       size_zero_node, BINFO_OFFSET (binfo)));
 /* This is an empty base class.  We first try to put it at offset
 zero.  */
-if (layout_conflict_p (binfo,
+tree offset = size_zero_node;
-			 BINFO_OFFSET (binfo),
+if (layout_conflict_p (type,
+			 offset,
 			 offsets,
 			 /*vbases_p=*/0))
 {
 /* That didn't work.  Now, we move forward from the next
 	 available spot in the class.  */
 atend = true;
-propagate_binfo_offsets (binfo, fold_convert (ssizetype, eoc));
+offset = eoc;
 while (1)
 	{
-	  if (!layout_conflict_p (binfo,
+	  if (!layout_conflict_p (type,
-				  BINFO_OFFSET (binfo),
+				  offset,
 				  offsets,
 				  /*vbases_p=*/0))
 	    /* We finally found a spot where there's no overlap.  */
 	    break;
 	  /* There's overlap here, too.  Bump along to the next spot.  */
-	  propagate_binfo_offsets (binfo, alignment);
+	  offset = size_binop (PLUS_EXPR, offset, alignment);
 	}
 }
-if (CLASSTYPE_USER_ALIGN (basetype))
+if (CLASSTYPE_USER_ALIGN (type))
 {
-rli->record_align = MAX (rli->record_align, CLASSTYPE_ALIGN (basetype));
+rli->record_align = MAX (rli->record_align, CLASSTYPE_ALIGN (type));
 if (warn_packed)
-	rli->unpacked_align = MAX (rli->unpacked_align, CLASSTYPE_ALIGN (basetype));
+	rli->unpacked_align = MAX (rli->unpacked_align, CLASSTYPE_ALIGN (type));
 TYPE_USER_ALIGN (rli->t) = 1;
+}
+if (binfo)
+/* Adjust BINFO_OFFSET (binfo) to be exactly OFFSET.  */
+propagate_binfo_offsets (binfo,
+			     size_diffop (offset, BINFO_OFFSET (binfo)));
+else
+{
+DECL_FIELD_OFFSET (decl) = offset;
+DECL_FIELD_BIT_OFFSET (decl) = bitsize_zero_node;
+SET_DECL_OFFSET_ALIGN (decl, BITS_PER_UNIT);
 }
 return atend;
 }
 tree decl = build_decl (input_location,
 			  FIELD_DECL, NULL_TREE, CLASSTYPE_AS_BASE (basetype));
 DECL_ARTIFICIAL (decl) = 1;
 DECL_IGNORED_P (decl) = 1;
 DECL_FIELD_CONTEXT (decl) = t;
-DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
+if (is_empty_class (basetype))
-DECL_SIZE_UNIT (decl) = CLASSTYPE_SIZE_UNIT (basetype);
+/* CLASSTYPE_SIZE is one byte, but the field needs to have size zero.  */
+DECL_SIZE (decl) = DECL_SIZE_UNIT (decl) = size_zero_node;
+else
+{
+DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
+DECL_SIZE_UNIT (decl) = CLASSTYPE_SIZE_UNIT (basetype);
+}
 SET_DECL_ALIGN (decl, CLASSTYPE_ALIGN (basetype));
 DECL_USER_ALIGN (decl) = CLASSTYPE_USER_ALIGN (basetype);
 SET_DECL_MODE (decl, TYPE_MODE (basetype));
 DECL_FIELD_IS_BASE (decl) = 1;
 	 objects of the same type at the same address.  */
 layout_nonempty_base_or_field (rli, decl, binfo, offsets);
 }
 else
 {
-tree eoc;
+bool atend = layout_empty_base_or_field (rli, binfo, offsets);
-bool atend;
-/* On some platforms (ARM), even empty classes will not be
-	 byte-aligned.  */
-eoc = round_up_loc (input_location,
-		      rli_size_unit_so_far (rli),
-		      CLASSTYPE_ALIGN_UNIT (basetype));
-atend = layout_empty_base (rli, binfo, eoc, offsets);
 /* A nearly-empty class "has no proper base class that is empty,
 	 not morally virtual, and at an offset other than zero."  */
 if (!BINFO_VIRTUAL_P (binfo) && CLASSTYPE_NEARLY_EMPTY_P (t))
 	{
 	  if (atend)
 	 here because that was already done when the virtual table
 	 pointer was created.  */
 }
 /* Record the offsets of BINFO and its base subobjects.  */
-record_subobject_offsets (binfo,
+record_subobject_offsets (binfo, offsets);
-			    BINFO_OFFSET (binfo),
-			    offsets,
-			    /*is_data_member=*/false);
 return next_field;
 }
 /* Layout all of the non-virtual base classes.  Record empty
 /* If there was an in-charge parameter, drop it from the function
 type.  */
 if (DECL_HAS_IN_CHARGE_PARM_P (clone))
 {
-tree basetype;
+tree basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
-tree parmtypes;
+tree parmtypes = TYPE_ARG_TYPES (TREE_TYPE (clone));
-tree exceptions;
-exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
-basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
-parmtypes = TYPE_ARG_TYPES (TREE_TYPE (clone));
 /* Skip the `this' parameter.  */
 parmtypes = TREE_CHAIN (parmtypes);
 /* Skip the in-charge parameter.  */
 parmtypes = TREE_CHAIN (parmtypes);
 /* And the VTT parm, in a complete [cd]tor.  */
 	}
 TREE_TYPE (clone)
 	= build_method_type_directly (basetype,
 				      TREE_TYPE (TREE_TYPE (clone)),
 				      parmtypes);
-if (exceptions)
-	TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone),
-						     exceptions);
 TREE_TYPE (clone)
 	= cp_build_type_attribute_variant (TREE_TYPE (clone),
 					   TYPE_ATTRIBUTES (TREE_TYPE (fn)));
+TREE_TYPE (clone)
+	= cxx_copy_lang_qualifiers (TREE_TYPE (clone), TREE_TYPE (fn));
 }
 /* Copy the function parameters.  */
 DECL_ARGUMENTS (clone) = copy_list (DECL_ARGUMENTS (clone));
 /* Remove the in-charge parameter.  */
 	  if (TREE_PURPOSE (decl_parms) && !TREE_PURPOSE (clone_parms))
 	    {
 	      /* A default parameter has been added. Adjust the
 		 clone's parameters.  */
-	      tree exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
-	      tree attrs = TYPE_ATTRIBUTES (TREE_TYPE (clone));
-	      tree basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
-	      tree type;
 	      clone_parms = orig_decl_parms;
 	      if (DECL_HAS_VTT_PARM_P (clone))
 		{
 		  clone_parms = tree_cons (TREE_PURPOSE (orig_clone_parms),
 					   TREE_VALUE (orig_clone_parms),
 					   clone_parms);
 		  TREE_TYPE (clone_parms) = TREE_TYPE (orig_clone_parms);
 		}
-	      type = build_method_type_directly (basetype,
-						 TREE_TYPE (TREE_TYPE (clone)),
+	      tree basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
-						 clone_parms);
+	      tree type
-	      if (exceptions)
+		= build_method_type_directly (basetype,
-		type = build_exception_variant (type, exceptions);
+					      TREE_TYPE (TREE_TYPE (clone)),
-	      if (attrs)
+					      clone_parms);
+	      if (tree attrs = TYPE_ATTRIBUTES (TREE_TYPE (clone)))
 		type = cp_build_type_attribute_variant (type, attrs);
+	      type = cxx_copy_lang_qualifiers (type, TREE_TYPE (clone));
 	      TREE_TYPE (clone) = type;
 	      clone_parms = NULL_TREE;
 	      break;
 	    }
 {
 return (DECL_CONSTRUCTOR_P (fn)
 	  && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn)));
 }
-/* Returns true iff class T has a user-defined constructor that can be called
+/* Returns true iff class T has a user-provided constructor that can be called
 with more than zero arguments.  */
 bool
 type_has_user_nondefault_constructor (tree t)
 {
 return false;
 for (ovl_iterator iter (CLASSTYPE_CONSTRUCTORS (t)); iter; ++iter)
 {
 tree fn = *iter;
-if (!DECL_ARTIFICIAL (fn)
+if (user_provided_p (fn)
 	  && (TREE_CODE (fn) == TEMPLATE_DECL
 	      || (skip_artificial_parms_for (fn, DECL_ARGUMENTS (fn))
 		  != NULL_TREE)))
 	return true;
 }
 vbase_has_user_provided_move_assign (tree type)
 {
 /* Does the type itself have a user-provided move assignment operator?  */
 if (!CLASSTYPE_LAZY_MOVE_ASSIGN (type))
 for (ovl_iterator iter (get_class_binding_direct
-			    (type, cp_assignment_operator_id (NOP_EXPR)));
+			    (type, assign_op_identifier));
 	 iter; ++iter)
-if (!DECL_ARTIFICIAL (*iter) && move_fn_p (*iter))
+if (user_provided_p (*iter) && move_fn_p (*iter))
 	return true;
 /* Do any of its bases?  */
 tree binfo = TYPE_BINFO (type);
 tree base_binfo;
 if ((!user_p || !DECL_ARTIFICIAL (*iter)) && move_fn_p (*iter))
 	return true;
 if (!CLASSTYPE_LAZY_MOVE_ASSIGN (t))
 for (ovl_iterator iter (get_class_binding_direct
-			    (t, cp_assignment_operator_id (NOP_EXPR)));
+			    (t, assign_op_identifier));
 	 iter; ++iter)
 if ((!user_p || !DECL_ARTIFICIAL (*iter)) && move_fn_p (*iter))
 	return true;
 return false;
+}
+/* True iff T has a move constructor that is not deleted.  */
+bool
+classtype_has_non_deleted_move_ctor (tree t)
+{
+if (CLASSTYPE_LAZY_MOVE_CTOR (t))
+lazily_declare_fn (sfk_move_constructor, t);
+for (ovl_iterator iter (CLASSTYPE_CONSTRUCTORS (t)); iter; ++iter)
+if (move_fn_p (*iter) && !DECL_DELETED_FN (*iter))
+return true;
+return false;
+}
+/* If T, a class, has a user-provided copy constructor, copy assignment
+operator, or destructor, returns that function.  Otherwise, null.  */
+tree
+classtype_has_user_copy_or_dtor (tree t)
+{
+if (!CLASSTYPE_LAZY_COPY_CTOR (t))
+for (ovl_iterator iter (CLASSTYPE_CONSTRUCTORS (t)); iter; ++iter)
+{
+	tree fn = *iter;
+	if (user_provided_p (fn) && copy_fn_p (fn))
+	  return fn;
+}
+if (!CLASSTYPE_LAZY_COPY_ASSIGN (t))
+for (ovl_iterator iter (get_class_binding_direct
+			    (t, assign_op_identifier));
+	 iter; ++iter)
+{
+	tree fn = *iter;
+	if (user_provided_p (fn) && copy_fn_p (fn))
+	  return fn;
+}
+if (!CLASSTYPE_LAZY_DESTRUCTOR (t))
+{
+tree fn = CLASSTYPE_DESTRUCTOR (t);
+if (user_provided_p (fn))
+	return fn;
+}
+return NULL_TREE;
 }
 /* Nonzero if we need to build up a constructor call when initializing an
 object of this class, either because it has a user-declared constructor
 or because it doesn't have a default constructor (so we need to give an
 for (ovl_iterator iter (get_class_binding (inner, complete_ctor_identifier));
 iter; ++iter)
 {
 tree fn = *iter;
 if (!DECL_ARTIFICIAL (fn)
+	  || TREE_DEPRECATED (fn)
 	  || DECL_DELETED_FN (fn))
 	return true;
 }
 return false;
 }
 for (ovl_iterator iter (get_class_binding (inner, complete_dtor_identifier));
 iter; ++iter)
 {
 tree fn = *iter;
 if (!DECL_ARTIFICIAL (fn)
+	  || TREE_DEPRECATED (fn)
 	  || DECL_DELETED_FN (fn))
 	return true;
 }
 return false;
 }
 /* If the usual deallocation function is a two-argument whose second
 argument is of type `size_t', then we have to pass the size of
 the array to the deallocation function, so we will need to store
 a cookie.  */
 fns = lookup_fnfields (TYPE_BINFO (type),
-			 cp_operator_id (VEC_DELETE_EXPR),
+			 ovl_op_identifier (false, VEC_DELETE_EXPR),
 			 /*protect=*/0);
 /* If there are no `operator []' members, or the lookup is
 ambiguous, then we don't need a cookie.  */
 if (!fns || fns == error_mark_node)
 return false;
 	  && DECL_DECLARED_CONSTEXPR_P (fn)
 	  && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
 	  && !DECL_CONSTRUCTOR_P (fn))
 	{
 	  DECL_DECLARED_CONSTEXPR_P (fn) = false;
-	  if (!DECL_GENERATED_P (fn)
+	  if (!DECL_GENERATED_P (fn))
-	      && pedwarn (DECL_SOURCE_LOCATION (fn), OPT_Wpedantic,
+	    {
-			  "enclosing class of constexpr non-static member "
+	      auto_diagnostic_group d;
-			  "function %q+#D is not a literal type", fn))
+	      if (pedwarn (DECL_SOURCE_LOCATION (fn), OPT_Wpedantic,
-	    explain_non_literal_class (t);
+			     "enclosing class of %<constexpr%> non-static "
+			     "member function %q+#D is not a literal type", fn))
+		explain_non_literal_class (t);
+	    }
 	}
 }
 /* T is a non-literal type used in a context which requires a constant
 expression.  Explain why it isn't literal.  */
 diagnosed = new hash_set<tree>;
 if (diagnosed->add (t))
 /* Already explained.  */
 return;
-inform (0, "%q+T is not literal because:", t);
+auto_diagnostic_group d;
+inform (UNKNOWN_LOCATION, "%q+T is not literal because:", t);
 if (cxx_dialect < cxx17 && LAMBDA_TYPE_P (t))
-inform (0, "  %qT is a closure type, which is only literal in "
+inform (UNKNOWN_LOCATION,
+	    "  %qT is a closure type, which is only literal in "
 	    "C++17 and later", t);
 else if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
-inform (0, "  %q+T has a non-trivial destructor", t);
+inform (UNKNOWN_LOCATION, "  %q+T has a non-trivial destructor", t);
 else if (CLASSTYPE_NON_AGGREGATE (t)
 	   && !TYPE_HAS_TRIVIAL_DFLT (t)
 	   && !LAMBDA_TYPE_P (t)
 	   && !TYPE_HAS_CONSTEXPR_CTOR (t))
 {
-inform (0, "  %q+T is not an aggregate, does not have a trivial "
+inform (UNKNOWN_LOCATION,
-	      "default constructor, and has no constexpr constructor that "
+	      "  %q+T is not an aggregate, does not have a trivial "
+	      "default constructor, and has no %<constexpr%> constructor that "
 	      "is not a copy or move constructor", t);
 if (type_has_non_user_provided_default_constructor (t))
 	/* Note that we can't simply call locate_ctor because when the
 	   constructor is deleted it just returns NULL_TREE.  */
 	for (ovl_iterator iter (CLASSTYPE_CONSTRUCTORS (t)); iter; ++iter)
 	   BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 	{
 	  tree basetype = TREE_TYPE (base_binfo);
 	  if (!CLASSTYPE_LITERAL_P (basetype))
 	    {
-	      inform (0, "  base class %qT of %q+T is non-literal",
+	      inform (UNKNOWN_LOCATION,
+		      "  base class %qT of %q+T is non-literal",
 		      basetype, t);
 	      explain_non_literal_class (basetype);
 	      return;
 	    }
 	}
 constructors ... and no virtual functions.
 Again, other conditions for being an aggregate are checked
 elsewhere.  */
 CLASSTYPE_NON_AGGREGATE (t)
-|= (type_has_user_provided_or_explicit_constructor (t)
+|= ((cxx_dialect < cxx2a
+	 ? type_has_user_provided_or_explicit_constructor (t)
+	 : TYPE_HAS_USER_CONSTRUCTOR (t))
 	|| TYPE_POLYMORPHIC_P (t));
 /* This is the C++98/03 definition of POD; it changed in C++0x, but we
 retain the old definition internally for ABI reasons.  */
 CLASSTYPE_NON_LAYOUT_POD_P (t)
 |= (CLASSTYPE_NON_AGGREGATE (t)
 	  if (TREE_CODE (field) != FIELD_DECL
 	      || DECL_INITIAL (field) != NULL_TREE)
 	    continue;
 	  type = TREE_TYPE (field);
-	  if (TREE_CODE (type) == REFERENCE_TYPE)
+	  if (TYPE_REF_P (type))
 	    warning_at (DECL_SOURCE_LOCATION (field),
 			OPT_Wuninitialized, "non-static reference %q#D "
 			"in class without a constructor", field);
 	  else if (CP_TYPE_CONST_P (type)
 		   && (!CLASS_TYPE_P (type)
 		 : !no_const_asn_ref);
 	    bool fn_const_p = (copy == 2);
 	    if (fn_const_p && !imp_const_p)
 	      /* If the function is defaulted outside the class, we just
-		 give the synthesis error.  */
+		 give the synthesis error.  Core Issue #1331 says this is
-	      error ("%q+D declared to take const reference, but implicit "
+		 no longer ill-formed, it is defined as deleted instead.  */
-		     "declaration would take non-const", fn);
+	      DECL_DELETED_FN (fn) = true;
 	  }
 	defaulted_late_check (fn);
 }
 if (LAMBDA_TYPE_P (t))
 return size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), size);
 }
 /* Returns the offset of the byte just past the end of the base class
 with the highest offset in T.  If INCLUDE_VIRTUALS_P is zero, then
-only non-virtual bases are included.  */
+only non-virtual bases are included.  If INCLUDE_FIELDS_P is true,
+then also consider non-static data members.  */
 static tree
-end_of_class (tree t, int include_virtuals_p)
+end_of_class (tree t, bool include_virtuals_p, bool include_fields_p = false)
 {
 tree result = size_zero_node;
 vec<tree, va_gc> *vbases;
 tree binfo;
 tree base_binfo;
 offset = end_of_base (base_binfo);
 if (tree_int_cst_lt (result, offset))
 	result = offset;
 }
+if (include_fields_p)
+for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
+if (TREE_CODE (field) == FIELD_DECL)
+	{
+	  offset = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (field),
+			       DECL_SIZE_UNIT (field));
+	  if (tree_int_cst_lt (result, offset))
+	    result = offset;
+	}
 if (include_virtuals_p)
 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
 	 vec_safe_iterate (vbases, i, &base_binfo); i++)
 {
 type = TREE_TYPE (field);
 if (type == error_mark_node)
 	continue;
 padding = NULL_TREE;
+bool might_overlap = field_poverlapping_p (field);
+if (might_overlap && CLASS_TYPE_P (type)
+	  && CLASSTYPE_NON_LAYOUT_POD_P (type))
+	{
+	  /* if D is a potentially-overlapping data member, update sizeof(C) to
+	     max (sizeof(C), offset(D)+max (nvsize(D), dsize(D))).  */
+	  tree nvsize = CLASSTYPE_SIZE_UNIT (type);
+	  tree dsize = end_of_class (type, /*vbases*/true, /*fields*/true);
+	  if (tree_int_cst_le (dsize, nvsize))
+	    {
+	      DECL_SIZE_UNIT (field) = nvsize;
+	      DECL_SIZE (field) = CLASSTYPE_SIZE (type);
+	    }
+	  else
+	    {
+	      DECL_SIZE_UNIT (field) = dsize;
+	      DECL_SIZE (field) = bit_from_pos (dsize, bitsize_zero_node);
+	    }
+	}
 /* If this field is a bit-field whose width is greater than its
 	 type, then there are some special rules for allocating
 	 it.  */
 if (DECL_C_BIT_FIELD (field)
 	     field is effectively invisible.  */
 	  DECL_SIZE (field) = TYPE_SIZE (type);
 	  /* We must also reset the DECL_MODE of the field.  */
 	  SET_DECL_MODE (field, TYPE_MODE (type));
 	}
+else if (might_overlap && is_empty_class (type))
+	layout_empty_base_or_field (rli, field, empty_base_offsets);
 else
 	layout_nonempty_base_or_field (rli, field, NULL_TREE,
 				       empty_base_offsets);
 /* Remember the location of any empty classes in FIELD.  */
-record_subobject_offsets (TREE_TYPE (field),
+record_subobject_offsets (field, empty_base_offsets);
-				byte_position(field),
-				empty_base_offsets,
-				/*is_data_member=*/true);
 /* If a bit-field does not immediately follow another bit-field,
 	 and yet it starts in the middle of a byte, we have failed to
 	 comply with the ABI.  */
 if (warn_abi
 	  DECL_BIT_FIELD (padding_field) = 1;
 	  DECL_SIZE (padding_field) = padding;
 	  DECL_CONTEXT (padding_field) = t;
 	  DECL_ARTIFICIAL (padding_field) = 1;
 	  DECL_IGNORED_P (padding_field) = 1;
+	  DECL_PADDING_P (padding_field) = 1;
 	  layout_nonempty_base_or_field (rli, padding_field,
 					 NULL_TREE,
 					 empty_base_offsets);
 	}
 		      size_binop (MULT_EXPR,
 				  fold_convert (bitsizetype, eoc),
 				  bitsize_int (BITS_PER_UNIT)));
 SET_TYPE_ALIGN (base_t, rli->record_align);
 TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t);
+TYPE_TYPELESS_STORAGE (base_t) = TYPE_TYPELESS_STORAGE (t);
 /* Copy the non-static data members of T. This will include its
 	 direct non-virtual bases & vtable.  */
 next_field = &TYPE_FIELDS (base_t);
 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
 /* Determine the type of the array element or object referenced
 	 by the member so that it can be checked for flexible array
 	 members if it hasn't been yet.  */
 tree eltype = fldtype;
 while (TREE_CODE (eltype) == ARRAY_TYPE
-	     || TREE_CODE (eltype) == POINTER_TYPE
+	     || INDIRECT_TYPE_P (eltype))
-	     || TREE_CODE (eltype) == REFERENCE_TYPE)
 	eltype = TREE_TYPE (eltype);
 if (RECORD_OR_UNION_TYPE_P (eltype))
 	{
 	  if (fmem->array && !fmem->after[bool (pun)])
 else
 	{
 	  /* Flexible array members have no upper bound.  */
 	  if (fmem->array)
 	    {
-	      /* Replace the zero-length array if it's been stored and
-		 reset the after pointer.  */
 	      if (TYPE_DOMAIN (TREE_TYPE (fmem->array)))
 		{
+		  /* Replace the zero-length array if it's been stored and
+		     reset the after pointer.  */
 		  fmem->after[bool (pun)] = NULL_TREE;
 		  fmem->array = fld;
 		  fmem->enclosing = pstr;
 		}
+	      else if (!fmem->after[bool (pun)])
+		/* Make a record of another flexible array member.  */
+		fmem->after[bool (pun)] = fld;
 	    }
 	  else
 	    {
 	      fmem->array = fld;
 	      fmem->enclosing = pstr;
 a flexible array member (or the zero-length array extension).  */
 static void
 diagnose_invalid_flexarray (const flexmems_t *fmem)
 {
-if (fmem->array && fmem->enclosing
+if (fmem->array && fmem->enclosing)
-&& pedwarn (location_of (fmem->enclosing), OPT_Wpedantic,
+{
-		  TYPE_DOMAIN (TREE_TYPE (fmem->array))
+auto_diagnostic_group d;
-		  ? G_("invalid use of %q#T with a zero-size array "
+if (pedwarn (location_of (fmem->enclosing), OPT_Wpedantic,
-		       "in %q#D")
+		     TYPE_DOMAIN (TREE_TYPE (fmem->array))
-		  : G_("invalid use of %q#T with a flexible array member "
+		     ? G_("invalid use of %q#T with a zero-size array "
-		       "in %q#T"),
+			  "in %q#D")
-		  DECL_CONTEXT (fmem->array),
+		     : G_("invalid use of %q#T with a flexible array member "
-		  DECL_CONTEXT (fmem->enclosing)))
+			  "in %q#T"),
-inform (DECL_SOURCE_LOCATION (fmem->array),
+		     DECL_CONTEXT (fmem->array),
-	    "array member %q#D declared here", fmem->array);
+		     DECL_CONTEXT (fmem->enclosing)))
+	inform (DECL_SOURCE_LOCATION (fmem->array),
+		  "array member %q#D declared here", fmem->array);
+}
 }
 /* Issue diagnostics for invalid flexible array members or zero-length
 arrays that are not the last elements of the containing class or its
 base classes or that are its sole members.  */
 if (msg)
 	{
 	  location_t loc = DECL_SOURCE_LOCATION (fmem->array);
+	  auto_diagnostic_group d;
 	  if (pedwarn (loc, OPT_Wpedantic, msg, fmem->array, t))
 	    {
 	      inform (location_of (t), "in the definition of %q#T", t);
 	      diagd = true;
 	    }
 if (msg)
 	{
 	  location_t loc = DECL_SOURCE_LOCATION (fmem->array);
 	  diagd = true;
+	  auto_diagnostic_group d;
 	  error_at (loc, msg, fmem->array, t);
 	  /* In the unlikely event that the member following the flexible
 	     array member is declared in a different class, or the member
 	     overlaps another member of a common union, point to it.
 if (is_std_init_list (t))
 {
 /* People keep complaining that the compiler crashes on an invalid
 	 definition of initializer_list, so I guess we should explicitly
 	 reject it.  What the compiler internals care about is that it's a
-	 template and has a pointer field followed by an integer field.  */
+	 template and has a pointer field followed by size_type field.  */
 bool ok = false;
 if (processing_template_decl)
 	{
 	  tree f = next_initializable_field (TYPE_FIELDS (t));
-	  if (f && TREE_CODE (TREE_TYPE (f)) == POINTER_TYPE)
+	  if (f && TYPE_PTR_P (TREE_TYPE (f)))
 	    {
 	      f = next_initializable_field (DECL_CHAIN (f));
 	      if (f && same_type_p (TREE_TYPE (f), size_type_node))
 		ok = true;
 	    }
 	}
 if (!ok)
-	fatal_error (input_location,
+	fatal_error (input_location, "definition of %qD does not match "
-		     "definition of std::initializer_list does not match "
+		     "%<#include <initializer_list>%>", TYPE_NAME (t));
-		     "#include <initializer_list>");
 }
 input_location = saved_loc;
 TYPE_BEING_DEFINED (t) = 0;
 #define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp)
 switch (TREE_CODE (instance))
 {
 case INDIRECT_REF:
-if (POINTER_TYPE_P (TREE_TYPE (instance)))
+if (INDIRECT_TYPE_P (TREE_TYPE (instance)))
 	return NULL_TREE;
 else
 	return RECUR (TREE_OPERAND (instance, 0));
 case CALL_EXPR:
 /* This is a call to a constructor, hence it's never zero.  */
-if (TREE_HAS_CONSTRUCTOR (instance))
+if (CALL_EXPR_FN (instance)
+	  && TREE_HAS_CONSTRUCTOR (instance))
 	{
 	  if (nonnull)
 	    *nonnull = 1;
 	  return TREE_TYPE (instance);
 	}
 	      if (cdtorp)
 		*cdtorp = 1;
 	      return TREE_TYPE (TREE_TYPE (instance));
 	    }
 	}
-else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
+else if (TYPE_REF_P (TREE_TYPE (instance)))
 	{
 	  /* We only need one hash table because it is always left empty.  */
 	  if (!fixed_type_or_null_ref_ht)
 	    fixed_type_or_null_ref_ht
 	      = new hash_table<nofree_ptr_hash<tree_node> > (37);
 }
 fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
 if (fixed == NULL_TREE)
 return 0;
-if (POINTER_TYPE_P (t))
+if (INDIRECT_TYPE_P (t))
 t = TREE_TYPE (t);
 if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
 return 0;
 return cdtorp ? -1 : 1;
 }
 {
 if (current_class_depth)
 --current_class_stack[current_class_depth - 1].hidden;
 }
-/* Returns 1 if the class type currently being defined is either T or
+/* If the class type currently being defined is either T or
-a nested type of T.  Returns the type from the current_class_stack,
+a nested type of T, returns the type from the current_class_stack,
 which might be equivalent to but not equal to T in case of
 constrained partial specializations.  */
 tree
 currently_open_class (tree t)
 	  /* Try to do argument deduction.  */
 	  targs = make_tree_vec (DECL_NTPARMS (fn));
 	  instantiation = fn_type_unification (fn, explicit_targs, targs, args,
 					       nargs, ret,
 					      DEDUCE_EXACT, LOOKUP_NORMAL,
-					       false, false);
+					       NULL, false, false);
 	  if (instantiation == error_mark_node)
 	    /* Instantiation failed.  */
 	    continue;
 	  /* Constraints must be satisfied. This is done before
 static int explained;
 if (!(complain & tf_error))
 	return error_mark_node;
-permerror (input_location, "assuming pointer to member %qD", fn);
+auto_diagnostic_group d;
-if (!explained)
+if (permerror (input_location, "assuming pointer to member %qD", fn)
-	{
+	  && !explained)
-	  inform (input_location, "(a pointer to member can only be formed with %<&%E%>)", fn);
+	{
+	  inform (input_location, "(a pointer to member can only be "
+		  "formed with %<&%E%>)", fn);
 	  explained = 1;
 	}
 }
 /* If a pointer to a function that is multi-versioned is requested, the
 		   rhs, TREE_TYPE (rhs), fntype);
 	  return error_mark_node;
 	}
 }
-if (BASELINK_P (rhs))
-{
-access_path = BASELINK_ACCESS_BINFO (rhs);
-rhs = BASELINK_FUNCTIONS (rhs);
-}
-/* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
-deduce any type information.  */
-if (TREE_CODE (rhs) == NON_DEPENDENT_EXPR)
-{
-if (complain & tf_error)
-	error ("not enough type information");
-return error_mark_node;
-}
 /* If we instantiate a template, and it is a A ?: C expression
 with omitted B, look through the SAVE_EXPR.  */
 if (TREE_CODE (rhs) == SAVE_EXPR)
 rhs = TREE_OPERAND (rhs, 0);
+if (BASELINK_P (rhs))
+{
+access_path = BASELINK_ACCESS_BINFO (rhs);
+rhs = BASELINK_FUNCTIONS (rhs);
+}
+/* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
+deduce any type information.  */
+if (TREE_CODE (rhs) == NON_DEPENDENT_EXPR)
+{
+if (complain & tf_error)
+	error ("not enough type information");
+return error_mark_node;
+}
 /* There are only a few kinds of expressions that may have a type
 dependent on overload resolution.  */
 gcc_assert (TREE_CODE (rhs) == ADDR_EXPR
 	      || TREE_CODE (rhs) == COMPONENT_REF
 			       + IDENTIFIER_LENGTH (ctor_name) + 2);
 sprintf (buf, VFIELD_NAME_FORMAT, IDENTIFIER_POINTER (ctor_name));
 return get_identifier (buf);
 }
-void
-print_class_statistics (void)
-{
-if (! GATHER_STATISTICS)
-return;
-fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
-fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
-if (n_vtables)
-{
-fprintf (stderr, "vtables = %d; vtable searches = %d\n",
-	       n_vtables, n_vtable_searches);
-fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
-	       n_vtable_entries, n_vtable_elems);
-}
-}
 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
 according to [class]:
 					  The class-name is also inserted
 into  the scope of the class itself.  For purposes of access checking,
 the inserted class name is treated as if it were a public member name.  */
 	  return false;
 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
 	if (TREE_CODE (field) == FIELD_DECL
 	    && !DECL_ARTIFICIAL (field)
 	    /* An unnamed bit-field is not a data member.  */
-	    && (DECL_NAME (field) || !DECL_C_BIT_FIELD (field))
+	    && !DECL_UNNAMED_BIT_FIELD (field)
 	    && !is_really_empty_class (TREE_TYPE (field)))
 	  return false;
 return true;
 }
 else if (TREE_CODE (type) == ARRAY_TYPE)
 /* [basic.scope.class]
 	 A name N used in a class S shall refer to the same declaration
 	 in its context and when re-evaluated in the completed scope of
 	 S.  */
-permerror (input_location, "declaration of %q#D", decl);
+if (permerror (location_of (decl),
-permerror (location_of ((tree) n->value),
+		     "declaration of %q#D changes meaning of %qD",
-		 "changes meaning of %qD from %q#D",
+		     decl, OVL_NAME (decl)))
-		 OVL_NAME (decl), (tree) n->value);
+	inform (location_of ((tree) n->value),
+		"%qD declared here as %q#D",
+		OVL_NAME (decl), (tree) n->value);
 }
 }
 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
 Secondary vtables are merged with primary vtables; this function
 {
 tree delta;
 tree vcall_index;
 tree fn, fn_original;
 tree init = NULL_TREE;
+tree idx = size_int (jx++);
 fn = BV_FN (v);
 fn_original = fn;
 if (DECL_THUNK_P (fn))
 	{
 if (TARGET_VTABLE_USES_DESCRIPTORS)
 	{
 	  int i;
 	  if (init == size_zero_node)
 	    for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
-	      CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init);
+	      CONSTRUCTOR_APPEND_ELT (*inits, idx, init);
 	  else
 	    for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
 	      {
 		tree fdesc = build2 (FDESC_EXPR, vfunc_ptr_type_node,
 				     fn, build_int_cst (NULL_TREE, i));
 		TREE_CONSTANT (fdesc) = 1;
-		CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, fdesc);
+		CONSTRUCTOR_APPEND_ELT (*inits, idx, fdesc);
 	      }
 	}
 else
-	CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init);
+	CONSTRUCTOR_APPEND_ELT (*inits, idx, init);
 }
 }
 /* Adds to vid->inits the initializers for the vbase and vcall
 offsets in BINFO, which is in the hierarchy dominated by T.  */

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cp/class.c @ 131:84e7813d76e9