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

comparison gcc/cp/init.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
 /* Handle initialization things in C++.
-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
 items with static storage duration that are not otherwise
 initialized are initialized to zero.  */
 ;
 else if (TYPE_PTR_OR_PTRMEM_P (type))
 init = fold (convert (type, nullptr_node));
+else if (NULLPTR_TYPE_P (type))
+init = build_int_cst (type, 0);
 else if (SCALAR_TYPE_P (type))
 init = fold (convert (type, integer_zero_node));
 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (type)))
 {
 tree field;
 init = build_constructor (type, v);
 }
 else if (VECTOR_TYPE_P (type))
 init = build_zero_cst (type);
 else
-gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
+{
+gcc_assert (TYPE_REF_P (type));
+init = build_zero_cst (type);
+}
 /* In all cases, the initializer is a constant.  */
 if (init)
 TREE_CONSTANT (init) = 1;
 {
 if (complain & tf_error)
 	error ("value-initialization of function type %qT", type);
 return error_mark_node;
 }
-else if (TREE_CODE (type) == REFERENCE_TYPE)
+else if (TYPE_REF_P (type))
 {
 if (complain & tf_error)
 	error ("value-initialization of reference type %qT", type);
 return error_mark_node;
 }
 }
 }
 /* Return the non-static data initializer for FIELD_DECL MEMBER.  */
-static GTY(()) hash_map<tree, tree> *nsdmi_inst;
+static GTY((cache)) tree_cache_map *nsdmi_inst;
 tree
 get_nsdmi (tree member, bool in_ctor, tsubst_flags_t complain)
 {
 tree init;
 if (DECL_LANG_SPECIFIC (member) && DECL_TEMPLATE_INFO (member))
 {
 init = DECL_INITIAL (DECL_TI_TEMPLATE (member));
 location_t expr_loc
-	= EXPR_LOC_OR_LOC (init, DECL_SOURCE_LOCATION (member));
+	= cp_expr_loc_or_loc (init, DECL_SOURCE_LOCATION (member));
 tree *slot;
 if (TREE_CODE (init) == DEFAULT_ARG)
 	/* Unparsed.  */;
 else if (nsdmi_inst && (slot = nsdmi_inst->get (member)))
 	init = *slot;
 	  location_t sloc = input_location;
 	  input_location = expr_loc;
 	  DECL_INSTANTIATING_NSDMI_P (member) = 1;
+	  bool pushed = false;
+	  if (!currently_open_class (DECL_CONTEXT (member)))
+	    {
+	      push_to_top_level ();
+	      push_nested_class (DECL_CONTEXT (member));
+	      pushed = true;
+	    }
+	  gcc_checking_assert (!processing_template_decl);
 	  inject_this_parameter (DECL_CONTEXT (member), TYPE_UNQUALIFIED);
 	  start_lambda_scope (member);
 	  /* Do deferred instantiation of the NSDMI.  */
 	  DECL_INSTANTIATING_NSDMI_P (member) = 0;
 	  if (init != error_mark_node)
 	    {
 	      if (!nsdmi_inst)
-		nsdmi_inst = hash_map<tree,tree>::create_ggc (37);
+		nsdmi_inst = tree_cache_map::create_ggc (37);
 	      nsdmi_inst->put (member, init);
+	    }
+	  if (pushed)
+	    {
+	      pop_nested_class ();
+	      pop_from_top_level ();
 	    }
 	  input_location = sloc;
 	  cp_unevaluated_operand = un;
 	}
 /* Strip redundant TARGET_EXPR so we don't need to remap it, and
 so the aggregate init code below will see a CONSTRUCTOR.  */
 bool simple_target = (init && SIMPLE_TARGET_EXPR_P (init));
 if (simple_target)
 init = TARGET_EXPR_INITIAL (init);
-init = break_out_target_exprs (init);
+init = break_out_target_exprs (init, /*loc*/true);
 if (simple_target && TREE_CODE (init) != CONSTRUCTOR)
 /* Now put it back so C++17 copy elision works.  */
 init = get_target_expr (init);
 current_class_ptr = save_ccp;
 error_at (loc, "initializer for flexible array member %q#D", member);
 return true;
 }
+/* If INIT's value can come from a call to std::initializer_list<T>::begin,
+return that function.  Otherwise, NULL_TREE.  */
+static tree
+find_list_begin (tree init)
+{
+STRIP_NOPS (init);
+while (TREE_CODE (init) == COMPOUND_EXPR)
+init = TREE_OPERAND (init, 1);
+STRIP_NOPS (init);
+if (TREE_CODE (init) == COND_EXPR)
+{
+tree left = TREE_OPERAND (init, 1);
+if (!left)
+	left = TREE_OPERAND (init, 0);
+left = find_list_begin (left);
+if (left)
+	return left;
+return find_list_begin (TREE_OPERAND (init, 2));
+}
+if (TREE_CODE (init) == CALL_EXPR)
+if (tree fn = get_callee_fndecl (init))
+if (id_equal (DECL_NAME (fn), "begin")
+	  && is_std_init_list (DECL_CONTEXT (fn)))
+	return fn;
+return NULL_TREE;
+}
+/* If INIT initializing MEMBER is copying the address of the underlying array
+of an initializer_list, warn.  */
+static void
+maybe_warn_list_ctor (tree member, tree init)
+{
+tree memtype = TREE_TYPE (member);
+if (!init || !TYPE_PTR_P (memtype)
+|| !is_list_ctor (current_function_decl))
+return;
+tree parms = FUNCTION_FIRST_USER_PARMTYPE (current_function_decl);
+tree initlist = non_reference (TREE_VALUE (parms));
+tree targs = CLASSTYPE_TI_ARGS (initlist);
+tree elttype = TREE_VEC_ELT (targs, 0);
+if (!same_type_ignoring_top_level_qualifiers_p
+(TREE_TYPE (memtype), elttype))
+return;
+tree begin = find_list_begin (init);
+if (!begin)
+return;
+location_t loc = cp_expr_loc_or_loc (init, input_location);
+warning_at (loc, OPT_Winit_list_lifetime,
+	     "initializing %qD from %qE does not extend the lifetime "
+	     "of the underlying array", member, begin);
+}
 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
 arguments.  If TREE_LIST is void_type_node, an empty initializer
 list was given; if NULL_TREE no initializer was given.  */
 static void
 	  init = build2 (INIT_EXPR, type, decl, TREE_VALUE (init));
 	  finish_expr_stmt (init);
 	}
 }
 else if (init
-	   && (TREE_CODE (type) == REFERENCE_TYPE
+	   && (TYPE_REF_P (type)
 	       /* Pre-digested NSDMI.  */
 	       || (((TREE_CODE (init) == CONSTRUCTOR
 		     && TREE_TYPE (init) == type)
 		    /* { } mem-initializer.  */
 		    || (TREE_CODE (init) == TREE_LIST
 	      && init == NULL_TREE
 	      && default_init_uninitialized_part (type))
 	    {
 	      /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
 		 vtable; still give this diagnostic.  */
+	      auto_diagnostic_group d;
 	      if (permerror (DECL_SOURCE_LOCATION (current_function_decl),
 			     "uninitialized const member in %q#T", type))
 		inform (DECL_SOURCE_LOCATION (member),
 			"%q#D should be initialized", member );
 	    }
 {
 if (init == NULL_TREE)
 	{
 	  tree core_type;
 	  /* member traversal: note it leaves init NULL */
-	  if (TREE_CODE (type) == REFERENCE_TYPE)
+	  if (TYPE_REF_P (type))
 	    {
+	      auto_diagnostic_group d;
 	      if (permerror (DECL_SOURCE_LOCATION (current_function_decl),
 			     "uninitialized reference member in %q#T", type))
 		inform (DECL_SOURCE_LOCATION (member),
 			"%q#D should be initialized", member);
 	    }
 	  else if (CP_TYPE_CONST_P (type))
 	    {
+	      auto_diagnostic_group d;
 	      if (permerror (DECL_SOURCE_LOCATION (current_function_decl),
 			     "uninitialized const member in %q#T", type))
 		  inform (DECL_SOURCE_LOCATION (member),
 			  "%q#D should be initialized", member );
 	    }
 else if (TREE_CODE (init) == TREE_LIST)
 	/* There was an explicit member initialization.  Do some work
 	   in that case.  */
 	init = build_x_compound_expr_from_list (init, ELK_MEM_INIT,
 						tf_warning_or_error);
+maybe_warn_list_ctor (member, init);
 /* Reject a member initializer for a flexible array member.  */
 if (init && !maybe_reject_flexarray_init (member, init))
 	finish_expr_stmt (cp_build_modify_expr (input_location, decl,
 						INIT_EXPR, init,
 	  tree base_addr;
 	  base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
 				       subobject, 1, tf_warning_or_error);
 	  expand_aggr_init_1 (subobject, NULL_TREE,
-			      cp_build_indirect_ref (base_addr, RO_NULL,
+			      cp_build_fold_indirect_ref (base_addr),
-tf_warning_or_error),
 			      arguments,
 			      flags,
 tf_warning_or_error);
 	  expand_cleanup_for_base (subobject, NULL_TREE);
 	}
 tree vtt_parm;
 /* Compute the value to use, when there's a VTT.  */
 vtt_parm = current_vtt_parm;
 vtbl2 = fold_build_pointer_plus (vtt_parm, vtt_index);
-vtbl2 = cp_build_indirect_ref (vtbl2, RO_NULL, tf_warning_or_error);
+vtbl2 = cp_build_fold_indirect_ref (vtbl2);
 vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
 /* The actual initializer is the VTT value only in the subobject
 	 constructor.  In maybe_clone_body we'll substitute NULL for
 	 the vtt_parm in the case of the non-subobject constructor.  */
 vtbl = build_if_in_charge (vtbl, vtbl2);
 }
 /* Compute the location of the vtpr.  */
-vtbl_ptr = build_vfield_ref (cp_build_indirect_ref (decl, RO_NULL,
+vtbl_ptr = build_vfield_ref (cp_build_fold_indirect_ref (decl),
-tf_warning_or_error),
 			       TREE_TYPE (binfo));
 gcc_assert (vtbl_ptr != error_mark_node);
 /* Assign the vtable to the vptr.  */
 vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0, tf_warning_or_error);
 if (init == error_mark_node)
 return error_mark_node;
 location_t init_loc = (init
-			 ? EXPR_LOC_OR_LOC (init, input_location)
+			 ? cp_expr_loc_or_loc (init, input_location)
 			 : location_of (exp));
 TREE_READONLY (exp) = 0;
 TREE_THIS_VOLATILE (exp) = 0;
 int from_array = 0;
 if (VAR_P (exp) && DECL_DECOMPOSITION_P (exp))
 	{
 	  from_array = 1;
+	  init = mark_rvalue_use (init);
 	  if (init && DECL_P (init)
 	      && !(flags & LOOKUP_ONLYCONVERTING))
 	    {
 	      /* Wrap the initializer in a CONSTRUCTOR so that build_vec_init
 		 recognizes it as direct-initialization.  */
 	      CONSTRUCTOR_IS_DIRECT_INIT (init) = true;
 	    }
 	}
 else
 	{
-	  /* An array may not be initialized use the parenthesized
-	     initialization form -- unless the initializer is "()".  */
-	  if (init && TREE_CODE (init) == TREE_LIST)
-	    {
-	      if (complain & tf_error)
-		error ("bad array initializer");
-	      return error_mark_node;
-	    }
 	  /* Must arrange to initialize each element of EXP
 	     from elements of INIT.  */
 	  if (cv_qualified_p (type))
 	    TREE_TYPE (exp) = cv_unqualified (type);
 	  if (itype && cv_qualified_p (itype))
 	    TREE_TYPE (init) = cv_unqualified (itype);
 	  from_array = (itype && same_type_p (TREE_TYPE (init),
 					      TREE_TYPE (exp)));
-	  if (init && !from_array
+	  if (init && !BRACE_ENCLOSED_INITIALIZER_P (init)
-	      && !BRACE_ENCLOSED_INITIALIZER_P (init))
+	      && (!from_array
+		  || (TREE_CODE (init) != CONSTRUCTOR
+		      /* Can happen, eg, handling the compound-literals
+			 extension (ext/complit12.C).  */
+		      && TREE_CODE (init) != TARGET_EXPR)))
 	    {
 	      if (complain & tf_error)
-		permerror (init_loc, "array must be initialized "
+		error_at (init_loc, "array must be initialized "
-			   "with a brace-enclosed initializer");
+			  "with a brace-enclosed initializer");
-	      else
+	      return error_mark_node;
-		return error_mark_node;
 	    }
 	}
 stmt_expr = build_vec_init (exp, NULL_TREE, init,
 				  /*explicit_value_init_p=*/false,
 && !(TREE_CODE (init) == TARGET_EXPR
 	   && TARGET_EXPR_DIRECT_INIT_P (init))
 && !DIRECT_LIST_INIT_P (init))
 flags |= LOOKUP_ONLYCONVERTING;
-if ((VAR_P (exp) || TREE_CODE (exp) == PARM_DECL)
-&& !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (type)))
-/* Just know that we've seen something for this node.  */
-TREE_USED (exp) = 1;
 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
 destroy_temps = stmts_are_full_exprs_p ();
 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
 expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
 		      init, LOOKUP_NORMAL|flags, complain);
 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
 TREE_READONLY (exp) = was_const;
 TREE_THIS_VOLATILE (exp) = was_volatile;
+if ((VAR_P (exp) || TREE_CODE (exp) == PARM_DECL)
+&& TREE_SIDE_EFFECTS (stmt_expr)
+&& !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (type)))
+/* Just know that we've seen something for this node.  */
+TREE_USED (exp) = 1;
 return stmt_expr;
 }
 static void
 field_type = strip_array_types (TREE_TYPE (field));
 if (type_has_user_provided_constructor (field_type))
 	continue;
-if (TREE_CODE (field_type) == REFERENCE_TYPE)
+if (TYPE_REF_P (field_type))
 	{
 	  ++ error_count;
 	  if (complain)
 	    {
 	      if (DECL_CONTEXT (field) == origin)
 }
 return build_cxx_call (fn, 0, NULL, tf_warning_or_error);
 }
-/* Attempt to find the initializer for field T in the initializer INIT,
+/* Attempt to find the initializer for flexible array field T in the
-when non-null.  Returns the initializer when successful and NULL
+initializer INIT, when non-null.  Returns the initializer when
-otherwise.  */
+successful and NULL otherwise.  */
 static tree
-find_field_init (tree t, tree init)
+find_flexarray_init (tree t, tree init)
 {
-if (!init)
+if (!init || init == error_mark_node)
 return NULL_TREE;
 unsigned HOST_WIDE_INT idx;
 tree field, elt;
 /* Iterate over all top-level initializer elements.  */
 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx, field, elt)
-{
+/* If the member T is found, return it.  */
-/* If the member T is found, return it.  */
+if (field == t)
-if (field == t)
+return elt;
-	return elt;
-/* Otherwise continue and/or recurse into nested initializers.  */
-if (TREE_CODE (elt) == CONSTRUCTOR
-	  && (init = find_field_init (t, elt)))
-	return init;
-}
 return NULL_TREE;
 }
 /* Attempt to verify that the argument, OPER, of a placement new expression
 refers to an object sufficiently large for an object of TYPE or an array
 not diagnosed since we don't know how they use the buffer (this could
 be a future extension).  */
 static void
 warn_placement_new_too_small (tree type, tree nelts, tree size, tree oper)
 {
-location_t loc = EXPR_LOC_OR_LOC (oper, input_location);
+location_t loc = cp_expr_loc_or_loc (oper, input_location);
 /* The number of bytes to add to or subtract from the size of the provided
 buffer based on an offset into an array or an array element reference.
-Although intermediate results may be negative (as in a[3] - 2) the final
+Although intermediate results may be negative (as in a[3] - 2) a valid
-result cannot be.  */
+final result cannot be.  */
-HOST_WIDE_INT adjust = 0;
+offset_int adjust = 0;
 /* True when the size of the entire destination object should be used
 to compute the possibly optimistic estimate of the available space.  */
 bool use_obj_size = false;
 /* True when the reference to the destination buffer is an ADDR_EXPR.  */
 bool addr_expr = false;
 /* Handle the common case of array + offset expression when the offset
 is a constant.  */
 if (TREE_CODE (oper) == POINTER_PLUS_EXPR)
 {
-/* If the offset is comple-time constant, use it to compute a more
+/* If the offset is compile-time constant, use it to compute a more
 	 accurate estimate of the size of the buffer.  Since the operand
 	 of POINTER_PLUS_EXPR is represented as an unsigned type, convert
 	 it to signed first.
 	 Otherwise, use the size of the entire array as an optimistic
 	 estimate (this may lead to false negatives).  */
 tree adj = TREE_OPERAND (oper, 1);
 if (CONSTANT_CLASS_P (adj))
-	adjust += tree_to_shwi (convert (ssizetype, adj));
+	adjust += wi::to_offset (convert (ssizetype, adj));
 else
 	use_obj_size = true;
 oper = TREE_OPERAND (oper, 0);
 /* Similar to the offset computed above, see if the array index
 	 is a compile-time constant.  If so, and unless the offset was
 	 not a compile-time constant, use the index to determine the
 	 size of the buffer.  Otherwise, use the entire array as
 	 an optimistic estimate of the size.  */
-const_tree adj = TREE_OPERAND (oper, 1);
+const_tree adj = fold_non_dependent_expr (TREE_OPERAND (oper, 1));
 if (!use_obj_size && CONSTANT_CLASS_P (adj))
-	adjust += tree_to_shwi (adj);
+	adjust += wi::to_offset (adj);
 else
 	{
 	  use_obj_size = true;
 	  adjust = 0;
 	}
 tree var_decl = NULL_TREE;
 /* True when operand is a COMPONENT_REF, to distinguish flexible array
 members from arrays of unspecified size.  */
 bool compref = TREE_CODE (oper) == COMPONENT_REF;
+/* For COMPONENT_REF (i.e., a struct member) the size of the entire
+enclosing struct.  Used to validate the adjustment (offset) into
+an array at the end of a struct.  */
+offset_int compsize = 0;
 /* Descend into a struct or union to find the member whose address
 is being used as the argument.  */
 if (TREE_CODE (oper) == COMPONENT_REF)
 {
+tree comptype = TREE_TYPE (TREE_OPERAND (oper, 0));
+compsize = wi::to_offset (TYPE_SIZE_UNIT (comptype));
 tree op0 = oper;
 while (TREE_CODE (op0 = TREE_OPERAND (op0, 0)) == COMPONENT_REF);
 if (VAR_P (op0))
 	var_decl = op0;
 oper = TREE_OPERAND (oper, 1);
 }
-if ((addr_expr || !POINTER_TYPE_P (TREE_TYPE (oper)))
+tree opertype = TREE_TYPE (oper);
+if ((addr_expr || !INDIRECT_TYPE_P (opertype))
 && (VAR_P (oper)
 	  || TREE_CODE (oper) == FIELD_DECL
 	  || TREE_CODE (oper) == PARM_DECL))
 {
 /* A possibly optimistic estimate of the number of bytes available
 	 in the destination buffer.  */
-unsigned HOST_WIDE_INT bytes_avail = 0;
+offset_int bytes_avail = 0;
 /* True when the estimate above is in fact the exact size
 	 of the destination buffer rather than an estimate.  */
 bool exact_size = true;
 /* Treat members of unions and members of structs uniformly, even
 	  && tree_fits_uhwi_p (DECL_SIZE_UNIT (oper)))
 	{
 	  /* Use the size of the entire array object when the expression
 	     refers to a variable or its size depends on an expression
 	     that's not a compile-time constant.  */
-	  bytes_avail = tree_to_uhwi (DECL_SIZE_UNIT (oper));
+	  bytes_avail = wi::to_offset (DECL_SIZE_UNIT (oper));
 	  exact_size = !use_obj_size;
 	}
-else if (TYPE_SIZE_UNIT (TREE_TYPE (oper))
+else if (tree opersize = TYPE_SIZE_UNIT (opertype))
-	       && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (oper))))
 	{
 	  /* Use the size of the type of the destination buffer object
-	     as the optimistic estimate of the available space in it.  */
+	     as the optimistic estimate of the available space in it.
-	  bytes_avail = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (oper)));
+	     Use the maximum possible size for zero-size arrays and
-	}
+	     flexible array members (except of initialized objects
-else if (var_decl)
+	     thereof).  */
-	{
+	  if (TREE_CODE (opersize) == INTEGER_CST)
-	  /* Constructing into a buffer provided by the flexible array
+	    bytes_avail = wi::to_offset (opersize);
-	     member of a declared object (which is permitted as a G++
+	}
-	     extension).  If the array member has been initialized,
-	     determine its size from the initializer.  Otherwise,
+if (bytes_avail == 0)
-	     the array size is zero.  */
+	{
-	  bytes_avail = 0;
+	  if (var_decl)
+	    {
-	  if (tree init = find_field_init (oper, DECL_INITIAL (var_decl)))
+	      /* Constructing into a buffer provided by the flexible array
-	    bytes_avail = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (init)));
+		 member of a declared object (which is permitted as a G++
-	}
+		 extension).  If the array member has been initialized,
-else
+		 determine its size from the initializer.  Otherwise,
-	{
+		 the array size is zero.  */
-	  /* Bail if neither the size of the object nor its type is known.  */
+	      if (tree init = find_flexarray_init (oper,
-	  return;
+						   DECL_INITIAL (var_decl)))
-	}
+		bytes_avail = wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (init)));
+	    }
-tree_code oper_code = TREE_CODE (TREE_TYPE (oper));
+	  else
+	    bytes_avail = (wi::to_offset (TYPE_MAX_VALUE (ptrdiff_type_node))
+			   - compsize);
+	}
+tree_code oper_code = TREE_CODE (opertype);
 if (compref && oper_code == ARRAY_TYPE)
 	{
-	  /* Avoid diagnosing flexible array members (which are accepted
+	  tree nelts = array_type_nelts_top (opertype);
-	     as an extension and diagnosed with -Wpedantic) and zero-length
-	     arrays (also an extension).
-	     Overflowing construction in one-element arrays is diagnosed
-	     only at level 2.  */
-	  if (bytes_avail == 0 && !var_decl)
-	    return;
-	  tree nelts = array_type_nelts_top (TREE_TYPE (oper));
 	  tree nelts_cst = maybe_constant_value (nelts);
 	  if (TREE_CODE (nelts_cst) == INTEGER_CST
 	      && integer_onep (nelts_cst)
 	      && !var_decl
 	      && warn_placement_new < 2)
 	    return;
 	}
-/* The size of the buffer can only be adjusted down but not up.  */
-gcc_checking_assert (0 <= adjust);
 /* Reduce the size of the buffer by the adjustment computed above
 	 from the offset and/or the index into the array.  */
-if (bytes_avail < static_cast<unsigned HOST_WIDE_INT>(adjust))
+if (bytes_avail < adjust || adjust < 0)
 	bytes_avail = 0;
 else
-	bytes_avail -= adjust;
+	{
+	  tree elttype = (TREE_CODE (opertype) == ARRAY_TYPE
+			  ? TREE_TYPE (opertype) : opertype);
+	  if (tree eltsize = TYPE_SIZE_UNIT (elttype))
+	    {
+	      bytes_avail -= adjust * wi::to_offset (eltsize);
+	      if (bytes_avail < 0)
+		bytes_avail = 0;
+	    }
+	}
 /* The minimum amount of space needed for the allocation.  This
 	 is an optimistic estimate that makes it possible to detect
 	 placement new invocation for some undersize buffers but not
 	 others.  */
-unsigned HOST_WIDE_INT bytes_need;
+offset_int bytes_need;
 if (CONSTANT_CLASS_P (size))
-	bytes_need = tree_to_uhwi (size);
+	bytes_need = wi::to_offset (size);
 else if (nelts && CONSTANT_CLASS_P (nelts))
-	  bytes_need = tree_to_uhwi (nelts)
+	bytes_need = (wi::to_offset (nelts)
-	    * tree_to_uhwi (TYPE_SIZE_UNIT (type));
+		      * wi::to_offset (TYPE_SIZE_UNIT (type)));
 else if (tree_fits_uhwi_p (TYPE_SIZE_UNIT (type)))
-	bytes_need = tree_to_uhwi (TYPE_SIZE_UNIT (type));
+	bytes_need = wi::to_offset (TYPE_SIZE_UNIT (type));
 else
 	{
 	  /* The type is a VLA.  */
 	  return;
 	}
 			  "%<%T [%wu]%> and size %qwu in a region of type %qT "
 			  "and size %qwi"
 			  : "placement new constructing an object of type "
 			  "%<%T [%wu]%> and size %qwu in a region of type %qT "
 			  "and size at most %qwu",
-			  type, tree_to_uhwi (nelts), bytes_need,
+			  type, tree_to_uhwi (nelts), bytes_need.to_uhwi (),
-			  TREE_TYPE (oper),
+			  opertype, bytes_avail.to_uhwi ());
-			  bytes_avail);
 	    else
 	      warning_at (loc, OPT_Wplacement_new_,
 			  exact_size ?
 			  "placement new constructing an array of objects "
 			  "of type %qT and size %qwu in a region of type %qT "
 			  "and size %qwi"
 			  : "placement new constructing an array of objects "
 			  "of type %qT and size %qwu in a region of type %qT "
 			  "and size at most %qwu",
-			  type, bytes_need, TREE_TYPE (oper),
+			  type, bytes_need.to_uhwi (), opertype,
-			  bytes_avail);
+			  bytes_avail.to_uhwi ());
 	  else
 	    warning_at (loc, OPT_Wplacement_new_,
 			exact_size ?
 			"placement new constructing an object of type %qT "
 			"and size %qwu in a region of type %qT and size %qwi"
 			: "placement new constructing an object of type %qT "
 			"and size %qwu in a region of type %qT and size "
 			"at most %qwu",
-			type, bytes_need, TREE_TYPE (oper),
+			type, bytes_need.to_uhwi (), opertype,
-			bytes_avail);
+			bytes_avail.to_uhwi ());
 	}
 }
 }
 /* True if alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__.  */
 non-replaceable placement new function. See DR 1748.
 TODO: Enable in all standard modes.  */
 static bool
 std_placement_new_fn_p (tree alloc_fn)
 {
-if ((cxx_dialect > cxx14) && DECL_NAMESPACE_SCOPE_P (alloc_fn))
+if (DECL_NAMESPACE_SCOPE_P (alloc_fn))
 {
 tree first_arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
 if ((TREE_VALUE (first_arg) == ptr_type_node)
 	  && TREE_CHAIN (first_arg) == void_list_node)
 	return true;
 outer_nelts = nelts;
 type = TREE_TYPE (type);
 outer_nelts_from_type = true;
 }
-/* Lots of logic below. depends on whether we have a constant number of
+/* Lots of logic below depends on whether we have a constant number of
 elements, so go ahead and fold it now.  */
-if (outer_nelts)
+const_tree cst_outer_nelts = fold_non_dependent_expr (outer_nelts, complain);
-outer_nelts = maybe_constant_value (outer_nelts);
 /* If our base type is an array, then make sure we know how many elements
 it has.  */
 for (elt_type = type;
 TREE_CODE (elt_type) == ARRAY_TYPE;
 {
 tree inner_nelts = array_type_nelts_top (elt_type);
 tree inner_nelts_cst = maybe_constant_value (inner_nelts);
 if (TREE_CODE (inner_nelts_cst) == INTEGER_CST)
 	{
-	  bool overflow;
+	  wi::overflow_type overflow;
 	  offset_int result = wi::mul (wi::to_offset (inner_nelts_cst),
 				       inner_nelts_count, SIGNED, &overflow);
 	  if (overflow)
 	    {
 	      if (complain & tf_error)
 	}
 else
 	{
 	  if (complain & tf_error)
 	    {
-	      error_at (EXPR_LOC_OR_LOC (inner_nelts, input_location),
+	      error_at (cp_expr_loc_or_loc (inner_nelts, input_location),
 			"array size in new-expression must be constant");
 	      cxx_constant_value(inner_nelts);
 	    }
 	  nelts = error_mark_node;
 	}
 return error_mark_node;
 /* Warn if we performed the (T[N]) to T[N] transformation and N is
 variable.  */
 if (outer_nelts_from_type
-&& !TREE_CONSTANT (outer_nelts))
+&& !TREE_CONSTANT (cst_outer_nelts))
 {
 if (complain & tf_warning_or_error)
 	{
-	  pedwarn (EXPR_LOC_OR_LOC (outer_nelts, input_location), OPT_Wvla,
+	  pedwarn (cp_expr_loc_or_loc (outer_nelts, input_location), OPT_Wvla,
 		   typedef_variant_p (orig_type)
 		   ? G_("non-constant array new length must be specified "
 			"directly, not by typedef")
 		   : G_("non-constant array new length must be specified "
 			"without parentheses around the type-id"));
 {
 if (complain & tf_error)
 error ("invalid type %<void%> for new");
 return error_mark_node;
 }
+if (is_std_init_list (elt_type))
+warning (OPT_Winit_list_lifetime,
+	     "%<new%> of initializer_list does not "
+	     "extend the lifetime of the underlying array");
 if (abstract_virtuals_error_sfinae (ACU_NEW, elt_type, complain))
 return error_mark_node;
 is_initialized = (type_build_ctor_call (elt_type) || *init != NULL);
 gcc_checking_assert (wi::ltu_p (wi::to_offset (cookie_size), max_size));
 /* Unconditionally subtract the cookie size.  This decreases the
 	 maximum object size and is safe even if we choose not to use
 	 a cookie after all.  */
 max_size -= wi::to_offset (cookie_size);
-bool overflow;
+wi::overflow_type overflow;
 inner_size = wi::mul (wi::to_offset (size), inner_nelts_count, SIGNED,
 			    &overflow);
 if (overflow || wi::gtu_p (inner_size, max_size))
 	{
 	  if (complain & tf_error)
 max_outer_nelts = wi::udiv_trunc (max_size, inner_size);
 max_outer_nelts_tree = wide_int_to_tree (sizetype, max_outer_nelts);
 size = size_binop (MULT_EXPR, size, fold_convert (sizetype, nelts));
-if (INTEGER_CST == TREE_CODE (outer_nelts))
+if (TREE_CODE (cst_outer_nelts) == INTEGER_CST)
 	{
-	  if (tree_int_cst_lt (max_outer_nelts_tree, outer_nelts))
+	  if (tree_int_cst_lt (max_outer_nelts_tree, cst_outer_nelts))
 	    {
 	      /* When the array size is constant, check it at compile time
 		 to make sure it doesn't exceed the implementation-defined
 		 maximum, as required by C++ 14 (in C++ 11 this requirement
 		 isn't explicitly stated but it's enforced anyway -- see
 /* Allocate the object.  */
 tree fnname;
 tree fns;
-fnname = cp_operator_id (array_p ? VEC_NEW_EXPR : NEW_EXPR);
+fnname = ovl_op_identifier (false, array_p ? VEC_NEW_EXPR : NEW_EXPR);
 member_new_p = !globally_qualified_p
 		 && CLASS_TYPE_P (elt_type)
 		 && (array_p
 		     ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
 && TYPE_ALIGN (elt_type) > malloc_alignment ()
 && (warn_aligned_new > 1
 	  || CP_DECL_CONTEXT (alloc_fn) == global_namespace)
 && !aligned_allocation_fn_p (alloc_fn))
 {
+auto_diagnostic_group d;
 if (warning (OPT_Waligned_new_, "%<new%> of type %qT with extended "
 		   "alignment %d", elt_type, TYPE_ALIGN_UNIT (elt_type)))
 	{
 	  inform (input_location, "uses %qD, which does not have an alignment "
 		  "parameter", alloc_fn);
 cookie_ptr = size_binop (MINUS_EXPR, cookie_size, size_in_bytes (sizetype));
 cookie_ptr = fold_build_pointer_plus_loc (input_location,
 						alloc_node, cookie_ptr);
 size_ptr_type = build_pointer_type (sizetype);
 cookie_ptr = fold_convert (size_ptr_type, cookie_ptr);
-cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
+cookie = cp_build_fold_indirect_ref (cookie_ptr);
 cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
 if (targetm.cxx.cookie_has_size ())
 	{
 	  cookie_ptr = fold_build_pointer_plus (cookie_ptr,
 			       fold_build1_loc (input_location,
 						NEGATE_EXPR, sizetype,
 						size_in_bytes (sizetype)));
-	  cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
+	  cookie = cp_build_fold_indirect_ref (cookie_ptr);
 	  cookie = build2 (MODIFY_EXPR, sizetype, cookie,
 			   size_in_bytes (elt_type));
 	  cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
 				cookie, cookie_expr);
 	}
 	{
 	  /* build_value_init doesn't work in templates, and we don't need
 	     the initializer anyway since we're going to throw it away and
 	     rebuild it at instantiation time, so just build up a single
 	     constructor call to get any appropriate diagnostics.  */
-	  init_expr = cp_build_indirect_ref (data_addr, RO_NULL, complain);
+	  init_expr = cp_build_fold_indirect_ref (data_addr);
 	  if (type_build_ctor_call (elt_type))
 	    init_expr = build_special_member_call (init_expr,
 						   complete_ctor_identifier,
 						   init, elt_type,
 						   LOOKUP_NORMAL,
 		}
 	    }
 	  else if (*init)
 {
 if (complain & tf_error)
-permerror (input_location,
+error ("parenthesized initializer in array new");
-			   "parenthesized initializer in array new");
+	      return error_mark_node;
-else
-return error_mark_node;
-	      vecinit = build_tree_list_vec (*init);
 }
 	  init_expr
 	    = build_vec_init (data_addr,
 			      cp_build_binary_op (input_location,
 						  MINUS_EXPR, outer_nelts,
 	     leak out.  */
 	  stable = true;
 	}
 else
 	{
-	  init_expr = cp_build_indirect_ref (data_addr, RO_NULL, complain);
+	  init_expr = cp_build_fold_indirect_ref (data_addr);
 	  if (type_build_ctor_call (type) && !explicit_value_init_p)
 	    {
 	      init_expr = build_special_member_call (init_expr,
 						     complete_ctor_identifier,
 {
 tree auto_node = type_uses_auto (type);
 if (auto_node)
 	{
 	  tree d_init = NULL_TREE;
-	  if (vec_safe_length (*init) == 1)
+	  const size_t len = vec_safe_length (*init);
+	  /* E.g. new auto(x) must have exactly one element, or
+	     a {} initializer will have one element.  */
+	  if (len == 1)
 	    {
 	      d_init = (**init)[0];
 	      d_init = resolve_nondeduced_context (d_init, complain);
 	    }
-	  type = do_auto_deduction (type, d_init, auto_node);
+	  /* For the rest, e.g. new A(1, 2, 3), create a list.  */
+	  else if (len > 1)
+	    {
+	      unsigned int n;
+	      tree t;
+	      tree *pp = &d_init;
+	      FOR_EACH_VEC_ELT (**init, n, t)
+		{
+		  t = resolve_nondeduced_context (t, complain);
+		  *pp = build_tree_list (NULL_TREE, t);
+		  pp = &TREE_CHAIN (*pp);
+		}
+	    }
+	  type = do_auto_deduction (type, d_init, auto_node, complain);
 	}
 }
 if (processing_template_decl)
 {
 }
 /* Try to determine the constant value only for the purposes
 	 of the diagnostic below but continue to use the original
 	 value and handle const folding later.  */
-const_tree cst_nelts = maybe_constant_value (nelts);
+const_tree cst_nelts = fold_non_dependent_expr (nelts, complain);
 /* The expression in a noptr-new-declarator is erroneous if it's of
 	 non-class type and its value before converting to std::size_t is
 	 less than zero. ... If the expression is a constant expression,
 	 the program is ill-fomed.  */
-if (INTEGER_CST == TREE_CODE (cst_nelts)
+if (TREE_CODE (cst_nelts) == INTEGER_CST
 	  && tree_int_cst_sgn (cst_nelts) == -1)
 	{
 	  if (complain & tf_error)
 	    error ("size of array is negative");
 	  return error_mark_node;
 }
 /* ``A reference cannot be created by the new operator.  A reference
 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
 returned by new.'' ARM 5.3.3 */
-if (TREE_CODE (type) == REFERENCE_TYPE)
+if (TYPE_REF_P (type))
 {
 if (complain & tf_error)
 error ("new cannot be applied to a reference type");
 else
 return error_mark_node;
 if (base == error_mark_node || maxindex == error_mark_node)
 return error_mark_node;
 if (!COMPLETE_TYPE_P (type))
 {
-if ((complain & tf_warning)
+if (complain & tf_warning)
-	  && warning (OPT_Wdelete_incomplete,
+	{
-		      "possible problem detected in invocation of "
+	  auto_diagnostic_group d;
-		      "delete [] operator:"))
+	  if (warning (OPT_Wdelete_incomplete,
-{
+			 "possible problem detected in invocation of "
-cxx_incomplete_type_diagnostic (base, type, DK_WARNING);
+			 "delete [] operator:"))
-inform (input_location, "neither the destructor nor the "
+	    {
-"class-specific operator delete [] will be called, "
+	      cxx_incomplete_type_diagnostic (base, type, DK_WARNING);
-"even if they are declared when the class is defined");
+	      inform (input_location, "neither the destructor nor the "
-}
+			"class-specific operator delete [] will be called, "
+			"even if they are declared when the class is defined");
+	    }
+	}
 /* This size won't actually be used.  */
 size_exp = size_one_node;
 goto no_destructor;
 }
 int num_initialized_elts = 0;
 bool is_global;
 tree obase = base;
 bool xvalue = false;
 bool errors = false;
-location_t loc = (init ? EXPR_LOC_OR_LOC (init, input_location)
+location_t loc = (init ? cp_expr_loc_or_loc (init, input_location)
 		    : location_of (base));
 if (TREE_CODE (atype) == ARRAY_TYPE && TYPE_DOMAIN (atype))
 maxindex = array_type_nelts (atype);
 for_stmt = begin_for_stmt (NULL_TREE, NULL_TREE);
 finish_init_stmt (for_stmt);
 finish_for_cond (build2 (GT_EXPR, boolean_type_node, iterator,
 			       build_int_cst (TREE_TYPE (iterator), -1)),
-		       for_stmt, false);
+		       for_stmt, false, 0);
 elt_init = cp_build_unary_op (PREDECREMENT_EXPR, iterator, false,
 				    complain);
 if (elt_init == error_mark_node)
 	errors = true;
 finish_for_expr (elt_init, for_stmt);
 		from = build_tree_list (NULL_TREE, from);
 	    }
 	  else
 	    from = NULL_TREE;
-	  if (from_array == 2)
+	  if (TREE_CODE (type) == ARRAY_TYPE)
+	    elt_init = build_vec_init (to, NULL_TREE, from, /*val_init*/false,
+				       from_array, complain);
+	  else if (from_array == 2)
 	    elt_init = cp_build_modify_expr (input_location, to, NOP_EXPR,
 					     from, complain);
 	  else if (type_build_ctor_call (type))
 	    elt_init = build_aggr_init (to, from, 0, complain);
 	  else if (from)
 	    gcc_unreachable ();
 	}
 else if (TREE_CODE (type) == ARRAY_TYPE)
 	{
 	  if (init && !BRACE_ENCLOSED_INITIALIZER_P (init))
-	    sorry
+	    {
-	      ("cannot initialize multi-dimensional array with initializer");
+	      if ((complain & tf_error))
-	  elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
+		error_at (loc, "array must be initialized "
-				     0, init,
+			  "with a brace-enclosed initializer");
-				     explicit_value_init_p,
+	      elt_init = error_mark_node;
-				     0, complain);
+	    }
+	  else
+	    elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
+				       0, init,
+				       explicit_value_init_p,
+				       0, complain);
 	}
 else if (explicit_value_init_p)
 	{
 	  elt_init = build_value_init (type, complain);
 	  if (elt_init != error_mark_node)
 	  else
 	    {
 	      if (TREE_CODE (init) == TREE_LIST)
 		init = build_x_compound_expr_from_list (init, ELK_INIT,
 							complain);
-	      elt_init = build2 (INIT_EXPR, type, to, init);
+	      elt_init = (init == error_mark_node
+			  ? error_mark_node
+			  : build2 (INIT_EXPR, type, to, init));
 	    }
 	}
 if (elt_init == error_mark_node)
 	errors = true;
 		}
 	    }
 	}
 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
-if (elt_init)
+if (elt_init && !errors)
 	finish_expr_stmt (elt_init);
 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, false,
 complain));
 /* Now make the result have the correct type.  */
 if (TREE_CODE (atype) == ARRAY_TYPE)
 {
 atype = build_pointer_type (atype);
 stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
-stmt_expr = cp_build_indirect_ref (stmt_expr, RO_NULL, complain);
+stmt_expr = cp_build_fold_indirect_ref (stmt_expr);
 TREE_NO_WARNING (stmt_expr) = 1;
 }
 return stmt_expr;
 }
 static tree
 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags,
 		 tsubst_flags_t complain)
 {
 tree name;
-tree fn;
 switch (dtor_kind)
 {
 case sfk_complete_destructor:
 name = complete_dtor_identifier;
 break;
 break;
 default:
 gcc_unreachable ();
 }
-fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
-return build_new_method_call (exp, fn,
+return build_special_member_call (exp, name,
-				/*args=*/NULL,
+				    /*args=*/NULL,
-				/*conversion_path=*/NULL_TREE,
+				    /*binfo=*/TREE_TYPE (exp),
-				flags,
+				    flags,
-				/*fn_p=*/NULL,
+				    complain);
-				complain);
 }
 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
 ADDR is an expression which yields the store to be destroyed.
 AUTO_DELETE is the name of the destructor to call, i.e., either
 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
 set to `error_mark_node' before it gets properly cleaned up.  */
 if (type == error_mark_node)
 return error_mark_node;
-if (TREE_CODE (type) == POINTER_TYPE)
+if (TYPE_PTR_P (type))
 type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
 if (TREE_CODE (type) == ARRAY_TYPE)
 {
 if (TYPE_DOMAIN (type) == NULL_TREE)
 	  return error_mark_node;
 	}
 return build_vec_delete (addr, array_type_nelts (type),
 			       auto_delete, use_global_delete, complain);
 }
+bool deleting = (auto_delete == sfk_deleting_destructor);
+gcc_assert (deleting == !(flags & LOOKUP_DESTRUCTOR));
 if (TYPE_PTR_P (otype))
 {
 addr = mark_rvalue_use (addr);
 if (!VOID_TYPE_P (type))
 	{
 	  complete_type (type);
 	  if (!COMPLETE_TYPE_P (type))
 	    {
-	      if ((complain & tf_warning)
+	      if (complain & tf_warning)
-		  && warning (OPT_Wdelete_incomplete,
-			      "possible problem detected in invocation of "
-			      "delete operator:"))
 		{
-		  cxx_incomplete_type_diagnostic (addr, type, DK_WARNING);
+		  auto_diagnostic_group d;
-		  inform (input_location,
+		  if (warning (OPT_Wdelete_incomplete,
-			  "neither the destructor nor the class-specific "
+				 "possible problem detected in invocation of "
-			  "operator delete will be called, even if they are "
+				 "delete operator:"))
-			  "declared when the class is defined");
+		    {
+		      cxx_incomplete_type_diagnostic (addr, type, DK_WARNING);
+		      inform (input_location,
+				"neither the destructor nor the class-specific "
+				"operator delete will be called, even if they "
+				"are declared when the class is defined");
+		    }
 		}
 	    }
-	  else if (auto_delete == sfk_deleting_destructor && warn_delnonvdtor
+	  else if (deleting && warn_delnonvdtor
 	           && MAYBE_CLASS_TYPE_P (type) && !CLASSTYPE_FINAL (type)
 		   && TYPE_POLYMORPHIC_P (type))
 	    {
 	      tree dtor = CLASSTYPE_DESTRUCTOR (type);
 	      if (!dtor || !DECL_VINDEX (dtor))
 			     " which has non-virtual destructor"
 			     " might cause undefined behavior", type);
 		}
 	    }
 	}
-if (TREE_SIDE_EFFECTS (addr))
-	addr = save_expr (addr);
 /* Throw away const and volatile on target type of addr.  */
 addr = convert_force (build_pointer_type (type), addr, 0, complain);
 }
 else
 	 destructor.  If the destructor is accessible, call it,
 	 else report error.  */
 addr = cp_build_addr_expr (addr, complain);
 if (addr == error_mark_node)
 	return error_mark_node;
-if (TREE_SIDE_EFFECTS (addr))
-	addr = save_expr (addr);
 addr = convert_force (build_pointer_type (type), addr, 0, complain);
 }
-if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
+if (deleting)
-{
+/* We will use ADDR multiple times so we must save it.  */
-/* Make sure the destructor is callable.  */
+addr = save_expr (addr);
-if (type_build_dtor_call (type))
-	{
+bool virtual_p = false;
-	  expr = build_dtor_call (cp_build_indirect_ref (addr, RO_NULL,
+if (type_build_dtor_call (type))
-							 complain),
+{
-				  sfk_complete_destructor, flags, complain);
-	  if (expr == error_mark_node)
-	    return error_mark_node;
-	}
-if (auto_delete != sfk_deleting_destructor)
-	return void_node;
-return build_op_delete_call (DELETE_EXPR, addr,
-				   cxx_sizeof_nowarn (type),
-				   use_global_delete,
-				   /*placement=*/NULL_TREE,
-				   /*alloc_fn=*/NULL_TREE,
-				   complain);
-}
-else
-{
-tree head = NULL_TREE;
-tree do_delete = NULL_TREE;
-tree ifexp;
 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
 	lazily_declare_fn (sfk_destructor, type);
+virtual_p = DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTOR (type));
-/* For `::delete x', we must not use the deleting destructor
+}
-	 since then we would not be sure to get the global `operator
-	 delete'.  */
+tree head = NULL_TREE;
-if (use_global_delete && auto_delete == sfk_deleting_destructor)
+tree do_delete = NULL_TREE;
-	{
-	  /* We will use ADDR multiple times so we must save it.  */
+if (!deleting)
-	  addr = save_expr (addr);
+{
-	  head = get_target_expr (build_headof (addr));
+/* Leave do_delete null.  */
-	  /* Delete the object.  */
+}
-	  do_delete = build_op_delete_call (DELETE_EXPR,
+/* For `::delete x', we must not use the deleting destructor
-					    head,
+since then we would not be sure to get the global `operator
-					    cxx_sizeof_nowarn (type),
+delete'.  */
-					    /*global_p=*/true,
+else if (use_global_delete)
-					    /*placement=*/NULL_TREE,
+{
-					    /*alloc_fn=*/NULL_TREE,
+head = get_target_expr (build_headof (addr));
-					    complain);
+/* Delete the object.  */
-	  /* Otherwise, treat this like a complete object destructor
+do_delete = build_op_delete_call (DELETE_EXPR,
-	     call.  */
+					head,
-	  auto_delete = sfk_complete_destructor;
+					cxx_sizeof_nowarn (type),
-	}
+					/*global_p=*/true,
-/* If the destructor is non-virtual, there is no deleting
+					/*placement=*/NULL_TREE,
-	 variant.  Instead, we must explicitly call the appropriate
+					/*alloc_fn=*/NULL_TREE,
-	 `operator delete' here.  */
+					complain);
-else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTOR (type))
+/* Otherwise, treat this like a complete object destructor
-	       && auto_delete == sfk_deleting_destructor)
+	 call.  */
-	{
+auto_delete = sfk_complete_destructor;
-	  /* We will use ADDR multiple times so we must save it.  */
+}
-	  addr = save_expr (addr);
+/* If the destructor is non-virtual, there is no deleting
-	  /* Build the call.  */
+variant.  Instead, we must explicitly call the appropriate
-	  do_delete = build_op_delete_call (DELETE_EXPR,
+`operator delete' here.  */
-					    addr,
+else if (!virtual_p)
-					    cxx_sizeof_nowarn (type),
+{
-					    /*global_p=*/false,
+/* Build the call.  */
-					    /*placement=*/NULL_TREE,
+do_delete = build_op_delete_call (DELETE_EXPR,
-					    /*alloc_fn=*/NULL_TREE,
+					addr,
-					    complain);
+					cxx_sizeof_nowarn (type),
-	  /* Call the complete object destructor.  */
+					/*global_p=*/false,
-	  auto_delete = sfk_complete_destructor;
+					/*placement=*/NULL_TREE,
-	}
+					/*alloc_fn=*/NULL_TREE,
-else if (auto_delete == sfk_deleting_destructor
+					complain);
-	       && TYPE_GETS_REG_DELETE (type))
+/* Call the complete object destructor.  */
-	{
+auto_delete = sfk_complete_destructor;
-	  /* Make sure we have access to the member op delete, even though
+}
-	     we'll actually be calling it from the destructor.  */
+else if (TYPE_GETS_REG_DELETE (type))
-	  build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
+{
-				/*global_p=*/false,
+/* Make sure we have access to the member op delete, even though
-				/*placement=*/NULL_TREE,
+	 we'll actually be calling it from the destructor.  */
-				/*alloc_fn=*/NULL_TREE,
+build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
-				complain);
+			    /*global_p=*/false,
-	}
+			    /*placement=*/NULL_TREE,
+			    /*alloc_fn=*/NULL_TREE,
-expr = build_dtor_call (cp_build_indirect_ref (addr, RO_NULL, complain),
+			    complain);
-			      auto_delete, flags, complain);
+}
-if (expr == error_mark_node)
-	return error_mark_node;
+if (type_build_dtor_call (type))
-if (do_delete)
+expr = build_dtor_call (cp_build_fold_indirect_ref (addr),
-	/* The delete operator must be called, regardless of whether
+			    auto_delete, flags, complain);
-	   the destructor throws.
+else
+expr = build_trivial_dtor_call (addr);
-	   [expr.delete]/7 The deallocation function is called
+if (expr == error_mark_node)
-	   regardless of whether the destructor for the object or some
+return error_mark_node;
-	   element of the array throws an exception.  */
-	expr = build2 (TRY_FINALLY_EXPR, void_type_node, expr, do_delete);
+if (!deleting)
+return expr;
-/* We need to calculate this before the dtor changes the vptr.  */
-if (head)
+if (do_delete && !TREE_SIDE_EFFECTS (expr))
-	expr = build2 (COMPOUND_EXPR, void_type_node, head, expr);
+expr = do_delete;
+else if (do_delete)
-if (flags & LOOKUP_DESTRUCTOR)
+/* The delete operator must be called, regardless of whether
-	/* Explicit destructor call; don't check for null pointer.  */
+the destructor throws.
-	ifexp = integer_one_node;
-else
+[expr.delete]/7 The deallocation function is called
-	{
+regardless of whether the destructor for the object or some
-	  /* Handle deleting a null pointer.  */
+element of the array throws an exception.  */
-	  warning_sentinel s (warn_address);
+expr = build2 (TRY_FINALLY_EXPR, void_type_node, expr, do_delete);
-	  ifexp = cp_build_binary_op (input_location, NE_EXPR, addr,
-				      nullptr_node, complain);
+/* We need to calculate this before the dtor changes the vptr.  */
-	  if (ifexp == error_mark_node)
+if (head)
-	    return error_mark_node;
+expr = build2 (COMPOUND_EXPR, void_type_node, head, expr);
-	  /* This is a compiler generated comparison, don't emit
-	     e.g. -Wnonnull-compare warning for it.  */
+/* Handle deleting a null pointer.  */
-	  else if (TREE_CODE (ifexp) == NE_EXPR)
+warning_sentinel s (warn_address);
-	    TREE_NO_WARNING (ifexp) = 1;
+tree ifexp = cp_build_binary_op (input_location, NE_EXPR, addr,
-	}
+				   nullptr_node, complain);
+ifexp = cp_fully_fold (ifexp);
-if (ifexp != integer_one_node)
-	expr = build3 (COND_EXPR, void_type_node, ifexp, expr, void_node);
+if (ifexp == error_mark_node)
+return error_mark_node;
-return expr;
+/* This is a compiler generated comparison, don't emit
-}
+e.g. -Wnonnull-compare warning for it.  */
+else if (TREE_CODE (ifexp) == NE_EXPR)
+TREE_NO_WARNING (ifexp) = 1;
+if (!integer_nonzerop (ifexp))
+expr = build3 (COND_EXPR, void_type_node, ifexp, expr, void_node);
+return expr;
 }
 /* At the beginning of a destructor, push cleanups that will call the
 destructors for our base classes and members.
 type = strip_array_types (TREE_TYPE (type));
 cookie_addr = fold_build1_loc (input_location, NEGATE_EXPR,
 				 sizetype, TYPE_SIZE_UNIT (sizetype));
 cookie_addr = fold_build_pointer_plus (fold_convert (size_ptr_type, base),
 					     cookie_addr);
-maxindex = cp_build_indirect_ref (cookie_addr, RO_NULL, complain);
+maxindex = cp_build_fold_indirect_ref (cookie_addr);
 }
 else if (TREE_CODE (type) == ARRAY_TYPE)
 {
 /* Get the total number of things in the array, maxindex is a
 	 bad name.  */

Mercurial > hg > CbC > CbC_gcc

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