* alias.c (get_alias_set): Remove handling of PLACEHOLDER_EXPR.

	* emit-rtl.c (component_ref_for_mem_expr): Likewise.
	(set_mem_attributes_minus_bitpos): Call SUBSTITUTE_PLACEHOLDER_IN_EXPR.
	* explow.c (expr_size): Likewise.
	* expr.h (placeholder_list, find_placeholder): Deleted.
	* expr.c (store_constructor): Likewise.
	(get_inner_reference): Likewise.  Also don't call find_placeholder.
	(placeholder_list, find_placeholder): Deleted.
	(is_aligning_offset): Don't handle WITH_RECORD_EXPR, PLACEHOLDER_EXPR.
	(expand_expr_real, cases PLACEHOLDER_EXPR, WITH_RECORD_EXPR): Likewise.
	(highest_pow2_factor, case WITH_RECORD_EXPR): Remove.
	* dojump.c (do_jump, case WITH_RECORD_EXPR): Likewise.
	* dwarf2out.c (loc_descriptor_from_tree, case WITH_RECORD_EXPR):
	Likewise.
	* fold-const.c (invert_truthvalue, case WITH_RECORD_EXPR): Likewise.
	(extract_muldiv, case WITH_RECORD_EXPR): Likewise.
	* tree.c (expr_align, case WITH_RECORD_EXPR): Likewise.
	(contains_placeholder_p): Don't handle WITH_RECORD_EXPR.
	Clean up by using first_rtl_op.
	(substitute_in_expr): Use SUBSTITUTE_IN_EXPR for recursive call.
	(substitute_placeholder_in_expr): New function.
	* tree.def (WITH_RECORD_EXPR): Deleted.
	* tree.h (SUBSTITUTE_IN_EXPR, SUBSTITUTE_PLACEHOLDER_IN_EXPR): New.
	(substitute_placeholder_in_expr): New.

	* ada/decl.c (gnat_to_gnu_entity): Use SUBSTITUTE_PLACEHOLDER_IN_EXPR.
	* ada/trans.c (tree_transform, emit_index_check): Likewise.
	* ada/utils.c (build_template): Likewise.
	(max_size, convert): Remove handling of WITH_RECORD_EXPR.
	(maybe_unconstrained_array, unchecked_convert): Likewise.
	* ada/utils2.c (gnat_truthvalue_conversion, build_binary_op): Likewise.
	(build_unary_op): Likewise.
	(compare_arrays, build_allocator): Use SUBSTITUTE_PLACEHOLDER_IN_EXPR.
	(fill_vms_descriptor): Likewise.
	(build_call_alloc_dealloc): Likewise.
	ALIGN is unsigned.
	* ada/gigi.h (build_call_alloc_dealloc): Alignment is unsigned.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@79789 138bc75d-0d04-0410-961f-82ee72b054a4

18 files changed, 260 insertions, 391 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 5a53bc9abbb..93f379d6b40 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,30 @@
+2004-03-21  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+
+	* alias.c (get_alias_set): Remove handling of PLACEHOLDER_EXPR.
+	* emit-rtl.c (component_ref_for_mem_expr): Likewise.
+	(set_mem_attributes_minus_bitpos): Call SUBSTITUTE_PLACEHOLDER_IN_EXPR.
+	* explow.c (expr_size): Likewise.
+	* expr.h (placeholder_list, find_placeholder): Deleted.
+	* expr.c (store_constructor): Likewise.
+	(get_inner_reference): Likewise.  Also don't call find_placeholder.
+	(placeholder_list, find_placeholder): Deleted.
+	(is_aligning_offset): Don't handle WITH_RECORD_EXPR, PLACEHOLDER_EXPR.
+	(expand_expr_real, cases PLACEHOLDER_EXPR, WITH_RECORD_EXPR): Likewise.
+	(highest_pow2_factor, case WITH_RECORD_EXPR): Remove.
+	* dojump.c (do_jump, case WITH_RECORD_EXPR): Likewise.
+	* dwarf2out.c (loc_descriptor_from_tree, case WITH_RECORD_EXPR):
+	Likewise.
+	* fold-const.c (invert_truthvalue, case WITH_RECORD_EXPR): Likewise.
+	(extract_muldiv, case WITH_RECORD_EXPR): Likewise.
+	* tree.c (expr_align, case WITH_RECORD_EXPR): Likewise.
+	(contains_placeholder_p): Don't handle WITH_RECORD_EXPR.
+	Clean up by using first_rtl_op.
+	(substitute_in_expr): Use SUBSTITUTE_IN_EXPR for recursive call.
+	(substitute_placeholder_in_expr): New function.
+	* tree.def (WITH_RECORD_EXPR): Deleted.
+	* tree.h (SUBSTITUTE_IN_EXPR, SUBSTITUTE_PLACEHOLDER_IN_EXPR): New.
+	(substitute_placeholder_in_expr): New.
+
 2004-03-21  Andrew Pinski  <pinskia@gcc.gnu.org>
 
 	* dojump.c (prefer_and_bit_test): Fix which part of
diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index 0da5c5914c6..ee6e709807d 100644
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -1,3 +1,18 @@
+2004-03-21  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+
+	* decl.c (gnat_to_gnu_entity): Use SUBSTITUTE_PLACEHOLDER_IN_EXPR.
+	* trans.c (tree_transform, emit_index_check): Likewise.
+	* utils.c (build_template): Likewise.
+	(max_size, convert): Remove handling of WITH_RECORD_EXPR.
+	(maybe_unconstrained_array, unchecked_convert): Likewise.
+	* utils2.c (gnat_truthvalue_conversion, build_binary_op): Likewise.
+	(build_unary_op): Likewise.
+	(compare_arrays, build_allocator): Use SUBSTITUTE_PLACEHOLDER_IN_EXPR.
+	(fill_vms_descriptor): Likewise.
+	(build_call_alloc_dealloc): Likewise.
+	ALIGN is unsigned.
+	* gigi.h (build_call_alloc_dealloc): Alignment is unsigned.
+
 2004-03-20  Joseph S. Myers  <jsm@polyomino.org.uk>
 
 	PR other/14630
diff --git a/gcc/ada/decl.c b/gcc/ada/decl.c
index fd82da9c87b..458213e08b1 100644
--- a/gcc/ada/decl.c
+++ b/gcc/ada/decl.c
@@ -565,12 +565,9 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	    && CONTAINS_PLACEHOLDER_P (TYPE_SIZE (gnu_type)))
 	  {
 	    if (gnu_expr != 0 && kind == E_Constant)
-	      {
-		gnu_size = TYPE_SIZE (TREE_TYPE (gnu_expr));
-		if (CONTAINS_PLACEHOLDER_P (gnu_size))
-		  gnu_size = build (WITH_RECORD_EXPR, bitsizetype,
-				    gnu_size, gnu_expr);
-	      }
+	      gnu_size
+		= SUBSTITUTE_PLACEHOLDER_IN_EXPR
+		  (TYPE_SIZE (TREE_TYPE (gnu_expr)), gnu_expr);
 
 	    /* We may have no GNU_EXPR because No_Initialization is
 	       set even though there's an Expression.  */
diff --git a/gcc/ada/gigi.h b/gcc/ada/gigi.h
index 4d4467127bc..423b8980b33 100644
--- a/gcc/ada/gigi.h
+++ b/gcc/ada/gigi.h
@@ -701,7 +701,7 @@ extern tree build_component_ref (tree, tree, tree, int);
    GNU_SIZE is the size of the object and ALIGN is the alignment.
    GNAT_PROC, if present is a procedure to call and GNAT_POOL is the
    storage pool to use.  If not preset, malloc and free will be used.  */
-extern tree build_call_alloc_dealloc (tree, tree, int, Entity_Id,
+extern tree build_call_alloc_dealloc (tree, tree, unsigned int, Entity_Id,
 				      Entity_Id, Node_Id);
 
 /* Build a GCC tree to correspond to allocating an object of TYPE whose
diff --git a/gcc/ada/trans.c b/gcc/ada/trans.c
index dc7c404d6e6..dc34b725cf6 100644
--- a/gcc/ada/trans.c
+++ b/gcc/ada/trans.c
@@ -1236,8 +1236,8 @@ tree_transform (Node_Id gnat_node)
 	    if (CONTAINS_PLACEHOLDER_P (gnu_result))
 	      {
 		if (TREE_CODE (gnu_prefix) != TYPE_DECL)
-		  gnu_result = build (WITH_RECORD_EXPR, TREE_TYPE (gnu_result),
-				      gnu_result, gnu_expr);
+		  gnu_result = substitute_placeholder_in_expr (gnu_result,
+							       gnu_expr);
 		else
 		  gnu_result = max_size (gnu_result, 1);
 	      }
@@ -1381,9 +1381,8 @@ tree_transform (Node_Id gnat_node)
 	      /* If this has a PLACEHOLDER_EXPR, qualify it by the object
 		 we are handling.  Note that these attributes could not
 		 have been used on an unconstrained array type.  */
-	      if (CONTAINS_PLACEHOLDER_P (gnu_result))
-		gnu_result = build (WITH_RECORD_EXPR, TREE_TYPE (gnu_result),
-				    gnu_result, gnu_prefix);
+	      gnu_result = SUBSTITUTE_PLACEHOLDER_IN_EXPR (gnu_result,
+							   gnu_prefix);
 
 	      break;
 	    }
@@ -1486,9 +1485,8 @@ tree_transform (Node_Id gnat_node)
 
 	      /* If this has a PLACEHOLDER_EXPR, qualify it by the object
 		 we are handling. */
-	      if (CONTAINS_PLACEHOLDER_P (gnu_result))
-		gnu_result = build (WITH_RECORD_EXPR, TREE_TYPE (gnu_result),
-				    gnu_result, gnu_prefix);
+	      gnu_result = SUBSTITUTE_PLACEHOLDER_IN_EXPR (gnu_result,
+							   gnu_prefix);
 
 	      break;
 	    }
@@ -1496,7 +1494,7 @@ tree_transform (Node_Id gnat_node)
 	  case Attr_Min:
 	  case Attr_Max:
 	    gnu_lhs = gnat_to_gnu (First (Expressions (gnat_node)));
-	    gnu_rhs =  gnat_to_gnu (Next (First (Expressions (gnat_node))));
+	    gnu_rhs = gnat_to_gnu (Next (First (Expressions (gnat_node))));
 
 	    gnu_result_type = get_unpadded_type (Etype (gnat_node));
 	    gnu_result = build_binary_op (attribute == Attr_Min
@@ -4622,13 +4620,8 @@ emit_index_check (tree gnu_array_object,
 
   /* If GNU_LOW or GNU_HIGH are a PLACEHOLDER_EXPR, qualify them by
      the object we are handling. */
-  if (CONTAINS_PLACEHOLDER_P (gnu_low))
-    gnu_low = build (WITH_RECORD_EXPR, TREE_TYPE (gnu_low),
-		     gnu_low, gnu_array_object);
-
-  if (CONTAINS_PLACEHOLDER_P (gnu_high))
-    gnu_high = build (WITH_RECORD_EXPR, TREE_TYPE (gnu_high),
-		      gnu_high, gnu_array_object);
+  gnu_low = SUBSTITUTE_PLACEHOLDER_IN_EXPR (gnu_low, gnu_array_object);
+  gnu_high = SUBSTITUTE_PLACEHOLDER_IN_EXPR (gnu_high, gnu_array_object);
 
   /* There's no good type to use here, so we might as well use
      integer_type_node.   */
diff --git a/gcc/ada/utils.c b/gcc/ada/utils.c
index 37a9fbd0aea..cd3f47c5b63 100644
--- a/gcc/ada/utils.c
+++ b/gcc/ada/utils.c
@@ -2180,8 +2180,6 @@ max_size (tree exp, int max_p)
 	    gigi_abort (407);
 	  else if (code == COMPOUND_EXPR)
 	    return max_size (TREE_OPERAND (exp, 1), max_p);
-	  else if (code == WITH_RECORD_EXPR)
-	    return exp;
 
 	  {
 	    tree lhs = max_size (TREE_OPERAND (exp, 0), max_p);
@@ -2275,12 +2273,9 @@ build_template (tree template_type, tree array_type, tree expr)
       max = convert (TREE_TYPE (field), TYPE_MAX_VALUE (bounds));
 
       /* If either MIN or MAX involve a PLACEHOLDER_EXPR, we must
-	 surround them with a WITH_RECORD_EXPR giving EXPR as the
-	 OBJECT.  */
-      if (CONTAINS_PLACEHOLDER_P (min))
-	min = build (WITH_RECORD_EXPR, TREE_TYPE (min), min, expr);
-      if (CONTAINS_PLACEHOLDER_P (max))
-	max = build (WITH_RECORD_EXPR, TREE_TYPE (max), max, expr);
+	 substitute it from OBJECT.  */
+      min = SUBSTITUTE_PLACEHOLDER_IN_EXPR (min, expr);
+      max = SUBSTITUTE_PLACEHOLDER_IN_EXPR (max, expr);
 
       template_elts = tree_cons (TREE_CHAIN (field), max,
 				 tree_cons (field, min, template_elts));
@@ -2865,12 +2860,6 @@ convert (tree type, tree expr)
   else if (AGGREGATE_TYPE_P (type)
 	   && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (etype))
     return build1 (NOP_EXPR, type, expr);
-  /* If EXPR is a WITH_RECORD_EXPR, do the conversion inside and then make a
-     new one.  */
-  else if (TREE_CODE (expr) == WITH_RECORD_EXPR)
-    return build (WITH_RECORD_EXPR, type,
-		  convert (type, TREE_OPERAND (expr, 0)),
-		  TREE_OPERAND (expr, 1));
 
   /* If the input type has padding, remove it by doing a component reference
      to the field.  If the output type has padding, make a constructor
@@ -3250,13 +3239,6 @@ maybe_unconstrained_array (tree exp)
 					     (TREE_TYPE (TREE_TYPE (exp))))),
 		       TREE_OPERAND (exp, 0));
 
-      else if (code == WITH_RECORD_EXPR
-	       && (TREE_OPERAND (exp, 0)
-		   != (new = maybe_unconstrained_array
-		       (TREE_OPERAND (exp, 0)))))
-	return build (WITH_RECORD_EXPR, TREE_TYPE (new), new,
-		      TREE_OPERAND (exp, 1));
-
     case RECORD_TYPE:
       /* If this is a padded type, convert to the unpadded type and see if
 	 it contains a template.  */
@@ -3295,13 +3277,6 @@ unchecked_convert (tree type, tree expr, int notrunc_p)
   if (etype == type)
     return expr;
 
-  /* If EXPR is a WITH_RECORD_EXPR, do the conversion inside and then make a
-     new one.  */
-  if (TREE_CODE (expr) == WITH_RECORD_EXPR)
-    return build (WITH_RECORD_EXPR, type,
-		  unchecked_convert (type, TREE_OPERAND (expr, 0), notrunc_p),
-		  TREE_OPERAND (expr, 1));
-
   /* If both types types are integral just do a normal conversion.
      Likewise for a conversion to an unconstrained array.  */
   if ((((INTEGRAL_TYPE_P (type)
diff --git a/gcc/ada/utils2.c b/gcc/ada/utils2.c
index a8f228d6eb0..a0d33db6580 100644
--- a/gcc/ada/utils2.c
+++ b/gcc/ada/utils2.c
@@ -90,11 +90,6 @@ gnat_truthvalue_conversion (tree expr)
 		gnat_truthvalue_conversion (TREE_OPERAND (expr, 1)),
 		gnat_truthvalue_conversion (TREE_OPERAND (expr, 2))));
 
-    case WITH_RECORD_EXPR:
-      return build (WITH_RECORD_EXPR, type,
-		    gnat_truthvalue_conversion (TREE_OPERAND (expr, 0)),
-		    TREE_OPERAND (expr, 1));
-
     default:
       return build_binary_op (NE_EXPR, type, expr,
 			      convert (type, integer_zero_node));
@@ -381,15 +376,10 @@ compare_arrays (tree result_type, tree a1, tree a2)
 	  tree lb = TYPE_MIN_VALUE (TYPE_INDEX_TYPE (TYPE_DOMAIN (t1)));
 
 	  comparison = build_binary_op (LT_EXPR, result_type, ub, lb);
-
-	  if (CONTAINS_PLACEHOLDER_P (comparison))
-	    comparison = build (WITH_RECORD_EXPR, result_type,
-				comparison, a1);
-	  if (CONTAINS_PLACEHOLDER_P (length1))
-	    length1 = build (WITH_RECORD_EXPR, bt, length1, a1);
+	  comparison = SUBSTITUTE_PLACEHOLDER_IN_EXPR (comparison, a1);
+	  length1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (length1, a1);
 
 	  length_zero_p = 1;
-
 	  this_a1_is_null = comparison;
 	  this_a2_is_null = convert (result_type, integer_one_node);
 	}
@@ -413,10 +403,8 @@ compare_arrays (tree result_type, tree a1, tree a2)
 	  /* Note that we know that UB2 and LB2 are constant and hence
 	     cannot contain a PLACEHOLDER_EXPR.  */
 
-	  if (CONTAINS_PLACEHOLDER_P (comparison))
-	    comparison = build (WITH_RECORD_EXPR, result_type, comparison, a1);
-	  if (CONTAINS_PLACEHOLDER_P (length1))
-	    length1 = build (WITH_RECORD_EXPR, bt, length1, a1);
+	  comparison = SUBSTITUTE_PLACEHOLDER_IN_EXPR (comparison, a1);
+	  length1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (length1, a1);
 
 	  this_a1_is_null = build_binary_op (LT_EXPR, result_type, ub1, lb1);
 	  this_a2_is_null = convert (result_type, integer_zero_node);
@@ -425,10 +413,8 @@ compare_arrays (tree result_type, tree a1, tree a2)
       /* Otherwise compare the computed lengths.  */
       else
 	{
-	  if (CONTAINS_PLACEHOLDER_P (length1))
-	    length1 = build (WITH_RECORD_EXPR, bt, length1, a1);
-	  if (CONTAINS_PLACEHOLDER_P (length2))
-	    length2 = build (WITH_RECORD_EXPR, bt, length2, a2);
+	  length1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (length1, a1);
+	  length2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (length2, a2);
 
 	  comparison
 	    = build_binary_op (EQ_EXPR, result_type, length1, length2);
@@ -606,39 +592,6 @@ build_binary_op (enum tree_code op_code,
   tree result;
   int has_side_effects = 0;
 
-  /* If one (but not both, unless they have the same object) operands are a
-     WITH_RECORD_EXPR, do the operation and then surround it with the
-     WITH_RECORD_EXPR.  Don't do this for assignment, for an ARRAY_REF, or
-     for an ARRAY_RANGE_REF because we need to keep track of the
-     WITH_RECORD_EXPRs on both operands very carefully.  */
-  if (op_code != MODIFY_EXPR && op_code != ARRAY_REF
-      && op_code != ARRAY_RANGE_REF
-      && TREE_CODE (left_operand) == WITH_RECORD_EXPR
-      && (TREE_CODE (right_operand) != WITH_RECORD_EXPR
-	  || operand_equal_p (TREE_OPERAND (left_operand, 1),
-			      TREE_OPERAND (right_operand, 1), 0)))
-    {
-      tree right = right_operand;
-
-      if (TREE_CODE (right) == WITH_RECORD_EXPR)
-	right = TREE_OPERAND (right, 0);
-
-      result = build_binary_op (op_code, result_type,
-				TREE_OPERAND (left_operand, 0), right);
-      return build (WITH_RECORD_EXPR, TREE_TYPE (result), result,
-		    TREE_OPERAND (left_operand, 1));
-    }
-  else if (op_code != MODIFY_EXPR && op_code != ARRAY_REF
-	   && op_code != ARRAY_RANGE_REF
-	   && TREE_CODE (left_operand) != WITH_RECORD_EXPR
-	   && TREE_CODE (right_operand) == WITH_RECORD_EXPR)
-    {
-      result = build_binary_op (op_code, result_type, left_operand,
-				TREE_OPERAND (right_operand, 0));
-      return build (WITH_RECORD_EXPR, TREE_TYPE (result), result,
-		    TREE_OPERAND (right_operand, 1));
-    }
-
   if (operation_type != 0
       && TREE_CODE (operation_type) == RECORD_TYPE
       && TYPE_LEFT_JUSTIFIED_MODULAR_P (operation_type))
@@ -755,7 +708,6 @@ build_binary_op (enum tree_code op_code,
 	      result = TREE_OPERAND (result, 0);
 	  else if (TREE_CODE (result) == REALPART_EXPR
 		   || TREE_CODE (result) == IMAGPART_EXPR
-		   || TREE_CODE (result) == WITH_RECORD_EXPR
 		   || ((TREE_CODE (result) == NOP_EXPR
 			|| TREE_CODE (result) == CONVERT_EXPR)
 		       && (((TREE_CODE (restype)
@@ -1091,17 +1043,6 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand)
   tree result;
   int side_effects = 0;
 
-  /* If we have a WITH_RECORD_EXPR as our operand, do the operation first,
-     then surround it with the WITH_RECORD_EXPR.  This allows GCC to do better
-     expression folding.  */
-  if (TREE_CODE (operand) == WITH_RECORD_EXPR)
-    {
-      result = build_unary_op (op_code, result_type,
-			       TREE_OPERAND (operand, 0));
-      return build (WITH_RECORD_EXPR, TREE_TYPE (result), result,
-		    TREE_OPERAND (operand, 1));
-    }
-
   if (operation_type != 0
       && TREE_CODE (operation_type) == RECORD_TYPE
       && TYPE_LEFT_JUSTIFIED_MODULAR_P (operation_type))
@@ -1716,18 +1657,13 @@ build_component_ref (tree record_variable,
    object dynamically on the stack frame.  */
 
 tree
-build_call_alloc_dealloc (tree gnu_obj,
-                          tree gnu_size,
-                          int align,
-                          Entity_Id gnat_proc,
-                          Entity_Id gnat_pool,
+build_call_alloc_dealloc (tree gnu_obj, tree gnu_size, unsigned align,
+                          Entity_Id gnat_proc, Entity_Id gnat_pool,
                           Node_Id gnat_node)
 {
   tree gnu_align = size_int (align / BITS_PER_UNIT);
 
-  if (CONTAINS_PLACEHOLDER_P (gnu_size))
-    gnu_size = build (WITH_RECORD_EXPR, sizetype, gnu_size,
-		      build_unary_op (INDIRECT_REF, NULL_TREE, gnu_obj));
+  gnu_size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (gnu_size, gnu_obj);
 
   if (Present (gnat_proc))
     {
@@ -1868,10 +1804,8 @@ build_allocator (tree type,
       tree storage;
       tree template_cons = NULL_TREE;
 
-      size = TYPE_SIZE_UNIT (storage_type);
-
-      if (CONTAINS_PLACEHOLDER_P (size))
-	size = build (WITH_RECORD_EXPR, sizetype, size, init);
+      size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_SIZE_UNIT (storage_type),
+					     init);
 
       /* If the size overflows, pass -1 so the allocator will raise
 	 storage error.  */
@@ -1943,7 +1877,7 @@ build_allocator (tree type,
       if (init == 0)
 	size = max_size (size, 1);
       else
-	size = build (WITH_RECORD_EXPR, sizetype, size, init);
+	size = substitute_placeholder_in_expr (size, init);
     }
 
   /* If the size overflows, pass -1 so the allocator will raise
@@ -2012,15 +1946,12 @@ fill_vms_descriptor (tree expr, Entity_Id gnat_formal)
   gnat_mark_addressable (expr);
 
   for (field = TYPE_FIELDS (record_type); field; field = TREE_CHAIN (field))
-    {
-      tree init = DECL_INITIAL (field);
-
-      if (CONTAINS_PLACEHOLDER_P (init))
-	init = build (WITH_RECORD_EXPR, TREE_TYPE (init), init, expr);
-
-      const_list = tree_cons (field, convert (TREE_TYPE (field), init),
-			      const_list);
-    }
+    const_list
+      = tree_cons (field,
+		   convert (TREE_TYPE (field),
+			    SUBSTITUTE_PLACEHOLDER_IN_EXPR
+			    (DECL_INITIAL (field), expr)),
+		   const_list);
 
   return gnat_build_constructor (record_type, nreverse (const_list));
 }
diff --git a/gcc/alias.c b/gcc/alias.c
index 2c7770d32f6..be10ba688a6 100644
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -481,7 +481,6 @@ get_alias_set (tree t)
   if (! TYPE_P (t))
     {
       tree inner = t;
-      tree placeholder_ptr = 0;
 
       /* Remove any nops, then give the language a chance to do
 	 something with this tree before we look at it.  */
@@ -491,16 +490,10 @@ get_alias_set (tree t)
 	return set;
 
       /* First see if the actual object referenced is an INDIRECT_REF from a
-	 restrict-qualified pointer or a "void *".  Replace
-	 PLACEHOLDER_EXPRs.  */
-      while (TREE_CODE (inner) == PLACEHOLDER_EXPR
-	     || handled_component_p (inner))
+	 restrict-qualified pointer or a "void *".  */
+      while (handled_component_p (inner))
 	{
-	  if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
-	    inner = find_placeholder (inner, &placeholder_ptr);
-	  else
-	    inner = TREE_OPERAND (inner, 0);
-
+	  inner = TREE_OPERAND (inner, 0);
 	  STRIP_NOPS (inner);
 	}
 
@@ -546,16 +539,10 @@ get_alias_set (tree t)
 	}
 
       /* Otherwise, pick up the outermost object that we could have a pointer
-	 to, processing conversion and PLACEHOLDER_EXPR as above.  */
-      placeholder_ptr = 0;
-      while (TREE_CODE (t) == PLACEHOLDER_EXPR
-	     || (handled_component_p (t) && ! can_address_p (t)))
+	 to, processing conversions as above.  */
+      while (handled_component_p (t) && ! can_address_p (t))
 	{
-	  if (TREE_CODE (t) == PLACEHOLDER_EXPR)
-	    t = find_placeholder (t, &placeholder_ptr);
-	  else
-	    t = TREE_OPERAND (t, 0);
-
+	  t = TREE_OPERAND (t, 0);
 	  STRIP_NOPS (t);
 	}
 
diff --git a/gcc/dojump.c b/gcc/dojump.c
index 09a13d988c5..f19cbcc3d91 100644
--- a/gcc/dojump.c
+++ b/gcc/dojump.c
@@ -217,15 +217,6 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label)
       do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
       break;
 
-    case WITH_RECORD_EXPR:
-      /* Put the object on the placeholder list, recurse through our first
-         operand, and pop the list.  */
-      placeholder_list = tree_cons (TREE_OPERAND (exp, 1), NULL_TREE,
-                                    placeholder_list);
-      do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
-      placeholder_list = TREE_CHAIN (placeholder_list);
-      break;
-
 #if 0
       /* This is never less insns than evaluating the PLUS_EXPR followed by
          a test and can be longer if the test is eliminated.  */
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 3cc1782c835..b3dcda0c5c0 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -8705,7 +8705,6 @@ loc_descriptor_from_tree (tree loc, int addressp)
     case ERROR_MARK:
       return 0;
 
-    case WITH_RECORD_EXPR:
     case PLACEHOLDER_EXPR:
       /* This case involves extracting fields from an object to determine the
 	 position of other fields.  We don't try to encode this here.  The
diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c
index 6d18b782094..8d8ead16f09 100644
--- a/gcc/emit-rtl.c
+++ b/gcc/emit-rtl.c
@@ -1409,19 +1409,13 @@ component_ref_for_mem_expr (tree ref)
     inner = component_ref_for_mem_expr (inner);
   else
     {
-      tree placeholder_ptr = 0;
-
       /* Now remove any conversions: they don't change what the underlying
-	 object is.  Likewise for SAVE_EXPR.  Also handle PLACEHOLDER_EXPR.  */
+	 object is.  Likewise for SAVE_EXPR.  */
       while (TREE_CODE (inner) == NOP_EXPR || TREE_CODE (inner) == CONVERT_EXPR
 	     || TREE_CODE (inner) == NON_LVALUE_EXPR
 	     || TREE_CODE (inner) == VIEW_CONVERT_EXPR
-	     || TREE_CODE (inner) == SAVE_EXPR
-	     || TREE_CODE (inner) == PLACEHOLDER_EXPR)
-	if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
-	  inner = find_placeholder (inner, &placeholder_ptr);
-	else
-	  inner = TREE_OPERAND (inner, 0);
+	     || TREE_CODE (inner) == SAVE_EXPR)
+	inner = TREE_OPERAND (inner, 0);
 
       if (! DECL_P (inner))
 	inner = NULL_TREE;
@@ -1608,20 +1602,14 @@ set_mem_attributes_minus_bitpos (rtx ref, tree t, int objectp,
 		index = fold (build (MINUS_EXPR, TREE_TYPE (index),
 				     index, low_bound));
 
-	      /* If the index has a self-referential type, pass it to a
-		 WITH_RECORD_EXPR; if the component size is, pass our
-		 component to one.  */
-	      if (CONTAINS_PLACEHOLDER_P (index))
-		index = build (WITH_RECORD_EXPR, TREE_TYPE (index), index, t2);
-	      if (CONTAINS_PLACEHOLDER_P (unit_size))
-		unit_size = build (WITH_RECORD_EXPR, sizetype,
-				   unit_size, array);
-
+	      /* If the index has a self-referential type, instantiate it;
+		 likewise for the component size.  */
+	      index = SUBSTITUTE_PLACEHOLDER_IN_EXPR (index, t2);
+	      unit_size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (unit_size, array);
 	      off_tree
 		= fold (build (PLUS_EXPR, sizetype,
 			       fold (build (MULT_EXPR, sizetype,
-					    index,
-					    unit_size)),
+					    index, unit_size)),
 			       off_tree));
 	      t2 = TREE_OPERAND (t2, 0);
 	    }
diff --git a/gcc/explow.c b/gcc/explow.c
index b3c82b836fd..1eec943eb26 100644
--- a/gcc/explow.c
+++ b/gcc/explow.c
@@ -240,10 +240,7 @@ eliminate_constant_term (rtx x, rtx *constptr)
 rtx
 expr_size (tree exp)
 {
-  tree size = lang_hooks.expr_size (exp);
-
-  if (CONTAINS_PLACEHOLDER_P (size))
-    size = build (WITH_RECORD_EXPR, sizetype, size, exp);
+  tree size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (lang_hooks.expr_size (exp), exp);
 
   return expand_expr (size, NULL_RTX, TYPE_MODE (sizetype), 0);
 }
diff --git a/gcc/expr.c b/gcc/expr.c
index b909c7c7b8f..80647265ef4 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -90,9 +90,6 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    the same indirect address eventually.  */
 int cse_not_expected;
 
-/* Chain of pending expressions for PLACEHOLDER_EXPR to replace.  */
-tree placeholder_list = 0;
-
 /* This structure is used by move_by_pieces to describe the move to
    be performed.  */
 struct move_by_pieces
@@ -4610,9 +4607,10 @@ store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size)
 	    {
 	      rtx offset_rtx;
 
-	      if (CONTAINS_PLACEHOLDER_P (offset))
-		offset = build (WITH_RECORD_EXPR, sizetype,
-				offset, make_tree (TREE_TYPE (exp), target));
+	      offset
+		= SUBSTITUTE_PLACEHOLDER_IN_EXPR (offset,
+						  make_tree (TREE_TYPE (exp),
+							     target));
 
 	      offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
 	      if (GET_CODE (to_rtx) != MEM)
@@ -5401,7 +5399,6 @@ get_inner_reference (tree exp, HOST_WIDE_INT *pbitsize,
   enum machine_mode mode = VOIDmode;
   tree offset = size_zero_node;
   tree bit_offset = bitsize_zero_node;
-  tree placeholder_ptr = 0;
   tree tem;
 
   /* First get the mode, signedness, and size.  We do this from just the
@@ -5454,8 +5451,8 @@ get_inner_reference (tree exp, HOST_WIDE_INT *pbitsize,
 	     made during type construction.  */
 	  if (this_offset == 0)
 	    break;
-	  else if (CONTAINS_PLACEHOLDER_P (this_offset))
-	    this_offset = build (WITH_RECORD_EXPR, sizetype, this_offset, exp);
+	  else
+	    this_offset = SUBSTITUTE_PLACEHOLDER_IN_EXPR (this_offset, exp);
 
 	  offset = size_binop (PLUS_EXPR, offset, this_offset);
 	  bit_offset = size_binop (PLUS_EXPR, bit_offset,
@@ -5481,35 +5478,16 @@ get_inner_reference (tree exp, HOST_WIDE_INT *pbitsize,
 	    index = fold (build (MINUS_EXPR, TREE_TYPE (index),
 				 index, low_bound));
 
-	  /* If the index has a self-referential type, pass it to a
-	     WITH_RECORD_EXPR; if the component size is, pass our
-	     component to one.  */
-	  if (CONTAINS_PLACEHOLDER_P (index))
-	    index = build (WITH_RECORD_EXPR, TREE_TYPE (index), index, exp);
-	  if (CONTAINS_PLACEHOLDER_P (unit_size))
-	    unit_size = build (WITH_RECORD_EXPR, sizetype, unit_size, array);
-
+	  /* If the index has a self-referential type, instantiate it with
+	     the object; likewise fkor the component size.  */
+	  index = SUBSTITUTE_PLACEHOLDER_IN_EXPR (index, exp);
+	  unit_size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (unit_size, array);
 	  offset = size_binop (PLUS_EXPR, offset,
 			       size_binop (MULT_EXPR,
 					   convert (sizetype, index),
 					   unit_size));
 	}
 
-      else if (TREE_CODE (exp) == PLACEHOLDER_EXPR)
-	{
-	  tree new = find_placeholder (exp, &placeholder_ptr);
-
-	  /* If we couldn't find the replacement, return the PLACEHOLDER_EXPR.
-	     We might have been called from tree optimization where we
-	     haven't set up an object yet.  */
-	  if (new == 0)
-	    break;
-	  else
-	    exp = new;
-
-	  continue;
-	}
-
       /* We can go inside most conversions: all NON_VALUE_EXPRs, all normal
 	 conversions that don't change the mode, and all view conversions
 	 except those that need to "step up" the alignment.  */
@@ -6033,7 +6011,7 @@ highest_pow2_factor (tree exp)
       break;
 
     case NON_LVALUE_EXPR:  case NOP_EXPR:  case CONVERT_EXPR:
-    case SAVE_EXPR: case WITH_RECORD_EXPR:
+    case SAVE_EXPR:
       return highest_pow2_factor (TREE_OPERAND (exp, 0));
 
     case COMPOUND_EXPR:
@@ -6069,70 +6047,6 @@ highest_pow2_factor_for_target (tree target, tree exp)
   return MAX (factor, target_align);
 }
 
-/* Return an object on the placeholder list that matches EXP, a
-   PLACEHOLDER_EXPR.  An object "matches" if it is of the type of the
-   PLACEHOLDER_EXPR or a pointer type to it.  For further information, see
-   tree.def.  If no such object is found, return 0.  If PLIST is nonzero, it
-   is a location which initially points to a starting location in the
-   placeholder list (zero means start of the list) and where a pointer into
-   the placeholder list at which the object is found is placed.  */
-
-tree
-find_placeholder (tree exp, tree *plist)
-{
-  tree type = TREE_TYPE (exp);
-  tree placeholder_expr;
-
-  for (placeholder_expr
-       = plist && *plist ? TREE_CHAIN (*plist) : placeholder_list;
-       placeholder_expr != 0;
-       placeholder_expr = TREE_CHAIN (placeholder_expr))
-    {
-      tree need_type = TYPE_MAIN_VARIANT (type);
-      tree elt;
-
-      /* Find the outermost reference that is of the type we want.  If none,
-	 see if any object has a type that is a pointer to the type we
-	 want.  */
-      for (elt = TREE_PURPOSE (placeholder_expr); elt != 0;
-	   elt = ((TREE_CODE (elt) == COMPOUND_EXPR
-		   || TREE_CODE (elt) == COND_EXPR)
-		  ? TREE_OPERAND (elt, 1)
-		  : (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
-		     || TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
-		     || TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
-		     || TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
-		  ? TREE_OPERAND (elt, 0) : 0))
-	if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
-	  {
-	    if (plist)
-	      *plist = placeholder_expr;
-	    return elt;
-	  }
-
-      for (elt = TREE_PURPOSE (placeholder_expr); elt != 0;
-	   elt
-	   = ((TREE_CODE (elt) == COMPOUND_EXPR
-	       || TREE_CODE (elt) == COND_EXPR)
-	      ? TREE_OPERAND (elt, 1)
-	      : (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
-		 || TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
-		 || TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
-		 || TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
-	      ? TREE_OPERAND (elt, 0) : 0))
-	if (POINTER_TYPE_P (TREE_TYPE (elt))
-	    && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
-		== need_type))
-	  {
-	    if (plist)
-	      *plist = placeholder_expr;
-	    return build1 (INDIRECT_REF, need_type, elt);
-	  }
-    }
-
-  return 0;
-}
-
 /* Subroutine of expand_expr.  Expand the two operands of a binary
    expression EXP0 and EXP1 placing the results in OP0 and OP1.
    The value may be stored in TARGET if TARGET is nonzero.  The
@@ -6653,31 +6567,6 @@ expand_expr_real (tree exp, rtx target, enum machine_mode tmode,
 	return temp;
       }
 
-    case PLACEHOLDER_EXPR:
-      {
-	tree old_list = placeholder_list;
-	tree placeholder_expr = 0;
-
-	exp = find_placeholder (exp, &placeholder_expr);
-	if (exp == 0)
-	  abort ();
-
-	placeholder_list = TREE_CHAIN (placeholder_expr);
-	temp = expand_expr (exp, original_target, tmode, modifier);
-	placeholder_list = old_list;
-	return temp;
-      }
-
-    case WITH_RECORD_EXPR:
-      /* Put the object on the placeholder list, expand our first operand,
-	 and pop the list.  */
-      placeholder_list = tree_cons (TREE_OPERAND (exp, 1), NULL_TREE,
-				    placeholder_list);
-      target = expand_expr (TREE_OPERAND (exp, 0), original_target, tmode,
-			    modifier);
-      placeholder_list = TREE_CHAIN (placeholder_list);
-      return target;
-
     case GOTO_EXPR:
       if (TREE_CODE (TREE_OPERAND (exp, 0)) == LABEL_DECL)
 	expand_goto (TREE_OPERAND (exp, 0));
@@ -9095,11 +8984,10 @@ expand_expr_real (tree exp, rtx target, enum machine_mode tmode,
 static int
 is_aligning_offset (tree offset, tree exp)
 {
-  /* Strip off any conversions and WITH_RECORD_EXPR nodes.  */
+  /* Strip off any conversions.  */
   while (TREE_CODE (offset) == NON_LVALUE_EXPR
 	 || TREE_CODE (offset) == NOP_EXPR
-	 || TREE_CODE (offset) == CONVERT_EXPR
-	 || TREE_CODE (offset) == WITH_RECORD_EXPR)
+	 || TREE_CODE (offset) == CONVERT_EXPR)
     offset = TREE_OPERAND (offset, 0);
 
   /* We must now have a BIT_AND_EXPR with a constant that is one less than
@@ -9128,13 +9016,8 @@ is_aligning_offset (tree offset, tree exp)
 	 || TREE_CODE (offset) == CONVERT_EXPR)
     offset = TREE_OPERAND (offset, 0);
 
-  /* This must now be the address either of EXP or of a PLACEHOLDER_EXPR
-     whose type is the same as EXP.  */
-  return (TREE_CODE (offset) == ADDR_EXPR
-	  && (TREE_OPERAND (offset, 0) == exp
-	      || (TREE_CODE (TREE_OPERAND (offset, 0)) == PLACEHOLDER_EXPR
-		  && (TREE_TYPE (TREE_OPERAND (offset, 0))
-		      == TREE_TYPE (exp)))));
+  /* This must now be the address of EXP.  */
+  return TREE_CODE (offset) == ADDR_EXPR && TREE_OPERAND (offset, 0) == exp;
 }
 
 /* Return the tree node if an ARG corresponds to a string constant or zero
diff --git a/gcc/expr.h b/gcc/expr.h
index dd7ac9c6058..5c7bbbe6c51 100644
--- a/gcc/expr.h
+++ b/gcc/expr.h
@@ -505,15 +505,6 @@ extern rtx store_expr (tree, rtx, int);
    Useful after calling expand_expr with 1 as sum_ok.  */
 extern rtx force_operand (rtx, rtx);
 
-/* Return an object on the placeholder list that matches EXP, a
-   PLACEHOLDER_EXPR.  An object "matches" if it is of the type of the
-   PLACEHOLDER_EXPR or a pointer type to it.  For further information, see
-   tree.def.  If no such object is found, abort.  If PLIST is nonzero, it is
-   a location which initially points to a starting location in the
-   placeholder list (zero means start of the list) and where a pointer into
-   the placeholder list at which the object is found is placed.  */
-extern tree find_placeholder (tree, tree *);
-
 /* Generate code for computing expression EXP.
    An rtx for the computed value is returned.  The value is never null.
    In the case of a void EXP, const0_rtx is returned.  */
@@ -808,5 +799,3 @@ extern void do_jump_by_parts_greater_rtx (enum machine_mode, int, rtx, rtx,
 extern void mark_seen_cases (tree, unsigned char *, HOST_WIDE_INT, int);
 
 extern int vector_mode_valid_p (enum machine_mode);
-
-extern tree placeholder_list;
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 64c68b8eb92..84c605528ba 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -2718,11 +2718,6 @@ invert_truthvalue (tree arg)
       return build (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
 		    invert_truthvalue (TREE_OPERAND (arg, 1)));
 
-    case WITH_RECORD_EXPR:
-      return build (WITH_RECORD_EXPR, type,
-		    invert_truthvalue (TREE_OPERAND (arg, 0)),
-		    TREE_OPERAND (arg, 1));
-
     case NON_LVALUE_EXPR:
       return invert_truthvalue (TREE_OPERAND (arg, 0));
 
@@ -4560,12 +4555,6 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type)
 	}
       break;
 
-    case WITH_RECORD_EXPR:
-      if ((t1 = extract_muldiv (TREE_OPERAND (t, 0), c, code, wide_type)) != 0)
-	return build (WITH_RECORD_EXPR, TREE_TYPE (t1), t1,
-		      TREE_OPERAND (t, 1));
-      break;
-
     case LSHIFT_EXPR:  case RSHIFT_EXPR:
       /* If the second operand is constant, this is a multiplication
 	 or floor division, by a power of two, so we can treat it that
diff --git a/gcc/tree.c b/gcc/tree.c
index ed7771a8804..240d3357454 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -1211,7 +1211,7 @@ expr_align (tree t)
 
     case SAVE_EXPR:         case COMPOUND_EXPR:       case MODIFY_EXPR:
     case INIT_EXPR:         case TARGET_EXPR:         case WITH_CLEANUP_EXPR:
-    case WITH_RECORD_EXPR:  case CLEANUP_POINT_EXPR:  case UNSAVE_EXPR:
+    case CLEANUP_POINT_EXPR:  case UNSAVE_EXPR:
       /* These don't change the alignment of an object.  */
       return expr_align (TREE_OPERAND (t, 0));
 
@@ -1699,12 +1699,8 @@ contains_placeholder_p (tree exp)
   if (!exp)
     return 0;
 
-  /* If we have a WITH_RECORD_EXPR, it "cancels" any PLACEHOLDER_EXPR
-     in it since it is supplying a value for it.  */
   code = TREE_CODE (exp);
-  if (code == WITH_RECORD_EXPR)
-    return 0;
-  else if (code == PLACEHOLDER_EXPR)
+  if (code == PLACEHOLDER_EXPR)
     return 1;
 
   switch (TREE_CODE_CLASS (code))
@@ -1731,10 +1727,6 @@ contains_placeholder_p (tree exp)
 	  /* Ignoring the first operand isn't quite right, but works best.  */
 	  return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
 
-	case RTL_EXPR:
-	case CONSTRUCTOR:
-	  return 0;
-
 	case COND_EXPR:
 	  return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
 		  || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
@@ -1753,14 +1745,11 @@ contains_placeholder_p (tree exp)
 
 	  return result;
 
-	case CALL_EXPR:
-	  return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
-
 	default:
 	  break;
 	}
 
-      switch (TREE_CODE_LENGTH (code))
+      switch (first_rtl_op (code))
 	{
 	case 1:
 	  return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
@@ -1954,9 +1943,8 @@ substitute_in_expr (tree exp, tree f, tree r)
   /* We handle TREE_LIST and COMPONENT_REF separately.  */
   if (code == TREE_LIST)
     {
-      op0 = (TREE_CHAIN (exp) == 0
-	     ? 0 : substitute_in_expr (TREE_CHAIN (exp), f, r));
-      op1 = substitute_in_expr (TREE_VALUE (exp), f, r);
+      op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
+      op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
 	return exp;
 
@@ -1979,7 +1967,7 @@ substitute_in_expr (tree exp, tree f, tree r)
      if (TREE_CODE (inner) == PLACEHOLDER_EXPR && TREE_TYPE (inner) == 0)
        return exp;
 
-     op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
+     op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
      if (op0 == TREE_OPERAND (exp, 0))
        return exp;
 
@@ -2004,7 +1992,7 @@ substitute_in_expr (tree exp, tree f, tree r)
 	    return exp;
 
 	  case 1:
-	    op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
+	    op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
 	    if (op0 == TREE_OPERAND (exp, 0))
 	      return exp;
 
@@ -2012,8 +2000,8 @@ substitute_in_expr (tree exp, tree f, tree r)
 	    break;
 
 	  case 2:
-	    op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
-	    op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
+	    op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
+	    op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
 
 	    if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
 	      return exp;
@@ -2022,9 +2010,9 @@ substitute_in_expr (tree exp, tree f, tree r)
 	    break;
 
 	  case 3:
-	    op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
-	    op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
-	    op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
+	    op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
+	    op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
+	    op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
 
 	    if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
 		&& op2 == TREE_OPERAND (exp, 2))
@@ -2045,6 +2033,121 @@ substitute_in_expr (tree exp, tree f, tree r)
   TREE_READONLY (new) = TREE_READONLY (exp);
   return new;
 }
+
+/* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
+   for it within OBJ, a tree that is an object or a chain of references.  */
+
+tree
+substitute_placeholder_in_expr (tree exp, tree obj)
+{
+  enum tree_code code = TREE_CODE (exp);
+  tree op0, op1, op2;
+
+  /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
+     in the chain of OBJ.  */
+  if (code == PLACEHOLDER_EXPR)
+    {
+      tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
+      tree elt;
+
+      for (elt = obj; elt != 0;
+	   elt = ((TREE_CODE (elt) == COMPOUND_EXPR
+		   || TREE_CODE (elt) == COND_EXPR)
+		  ? TREE_OPERAND (elt, 1)
+		  : (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
+		     || TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
+		     || TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
+		     || TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
+		  ? TREE_OPERAND (elt, 0) : 0))
+	if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
+	  return elt;
+
+      for (elt = obj; elt != 0;
+	   elt = ((TREE_CODE (elt) == COMPOUND_EXPR
+		   || TREE_CODE (elt) == COND_EXPR)
+		  ? TREE_OPERAND (elt, 1)
+		  : (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
+		     || TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
+		     || TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
+		     || TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
+		  ? TREE_OPERAND (elt, 0) : 0))
+	if (POINTER_TYPE_P (TREE_TYPE (elt))
+	    && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
+		== need_type))
+	  return fold (build1 (INDIRECT_REF, need_type, elt));
+
+      /* If we didn't find it, return the original PLACEHOLDER_EXPR.  If it
+	 survives until RTL generation, there will be an error.  */
+      return exp;
+    }
+
+  /* TREE_LIST is special because we need to look at TREE_VALUE
+     and TREE_CHAIN, not TREE_OPERANDS.  */
+  else if (code == TREE_LIST)
+    {
+      op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
+      op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
+      if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
+	return exp;
+
+      return tree_cons (TREE_PURPOSE (exp), op1, op0);
+    }
+  else
+    switch (TREE_CODE_CLASS (code))
+      {
+      case 'c':
+      case 'd':
+      case 'b':
+	return exp;
+
+      case 'x':
+      case '1':
+      case '2':
+      case '<':
+      case 'e':
+      case 'r':
+      case 's':
+	switch (first_rtl_op (code))
+	  {
+	  case 0:
+	    return exp;
+
+	  case 1:
+	    op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
+	    if (op0 == TREE_OPERAND (exp, 0))
+	      return exp;
+	    else
+	      return fold (build1 (code, TREE_TYPE (exp), op0));
+
+	  case 2:
+	    op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
+	    op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
+
+	    if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
+	      return exp;
+	    else
+	      return fold (build2 (code, TREE_TYPE (exp), op0, op1));
+
+	  case 3:
+	    op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
+	    op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
+	    op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
+
+	    if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
+		&& op2 == TREE_OPERAND (exp, 2))
+	      return exp;
+	    else
+	      return fold (build3 (code, TREE_TYPE (exp), op0, op1, op2));
+
+	  default:
+	    abort ();
+	  }
+	break;
+
+      default:
+	abort ();
+      }
+}
 
 /* Stabilize a reference so that we can use it any number of times
    without causing its operands to be evaluated more than once.
diff --git a/gcc/tree.def b/gcc/tree.def
index 78919740da3..d56142f4e81 100644
--- a/gcc/tree.def
+++ b/gcc/tree.def
@@ -541,35 +541,22 @@ DEFTREECODE (CLEANUP_POINT_EXPR, "cleanup_point_expr", 'e', 1)
    actual size at run-time.  In the following, we describe how this
    calculation is done.
 
-   When we wish to evaluate a size or offset, we check whether it
-   contains a PLACEHOLDER_EXPR.  If it does, we construct a
-   WITH_RECORD_EXPR that contains both the expression we wish to
-   evaluate and an expression within which the object may be found.
-   The latter expression is the object itself in the simple case of an
-   Ada record with discriminant, but it can be the array in the case of
-   an unconstrained array.
+   When we wish to evaluate a size or offset, we check whether it contains a
+   PLACEHOLDER_EXPR.  If it does, we call substitute_placeholder_in_expr
+   passing both that tree and an expression within which the object may be
+   found.  The latter expression is the object itself in the simple case of
+   an Ada record with discriminant, but it can be the array in the case of an
+   unconstrained array.
 
    In the latter case, we need the fat pointer, because the bounds of
    the array can only be accessed from it.  However, we rely here on the
    fact that the expression for the array contains the dereference of
-   the fat pointer that obtained the array pointer.
+   the fat pointer that obtained the array pointer.  */
 
-   Accordingly, when looking for the object to substitute in place of
-   a PLACEHOLDER_EXPR, we look down the first operand of the expression
-   passed as the second operand to WITH_RECORD_EXPR until we find
-   something of the desired type or reach a constant.  */
-
-/* Denotes a record to later be supplied with a WITH_RECORD_EXPR when
-   evaluating this expression.  The type of this expression is used to
-   find the record to replace it.  */
+/* Denotes a record to later be substitued before evaluating this expression.
+   The type of this expression is used to find the record to replace it.  */
 DEFTREECODE (PLACEHOLDER_EXPR, "placeholder_expr", 'x', 0)
 
-/* Provide an expression that references a record to be used in place
-   of a PLACEHOLDER_EXPR.  The record to be used is the record within
-   operand 1 that has the same type as the PLACEHOLDER_EXPR in
-   operand 0.  */
-DEFTREECODE (WITH_RECORD_EXPR, "with_record_expr", 'e', 2)
-
 /* Simple arithmetic.  */
 DEFTREECODE (PLUS_EXPR, "plus_expr", '2', 2)
 DEFTREECODE (MINUS_EXPR, "minus_expr", '2', 2)
diff --git a/gcc/tree.h b/gcc/tree.h
index 5e5a88e6d8f..28b26deb865 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -2675,6 +2675,24 @@ extern int has_cleanups (tree);
 
 extern tree substitute_in_expr (tree, tree, tree);
 
+/* This macro calls the above function but short-circuits the common
+   case of a constant to save time and also checks for NULL.  */
+
+#define SUBSTITUTE_IN_EXPR(EXP, F, R) \
+  ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) : substitute_in_expr (EXP, F, R))
+
+/* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
+   for it within OBJ, a tree that is an object or a chain of references.  */
+
+extern tree substitute_placeholder_in_expr (tree, tree);
+
+/* This macro calls the above function but short-circuits the common
+   case of a constant to save time and also checks for NULL.  */
+
+#define SUBSTITUTE_PLACEHOLDER_IN_EXPR(EXP, OBJ) \
+  ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP)	\
+   : substitute_placeholder_in_expr (EXP, OBJ))
+
 /* variable_size (EXP) is like save_expr (EXP) except that it
    is for the special case of something that is part of a
    variable size for a data type.  It makes special arrangements