From 6fce44af562fae5ad9275e183abdf6cf87a87f6e Mon Sep 17 00:00:00 2001 From: Richard Kenner Date: Sun, 21 Mar 2004 18:09:20 +0000 Subject: [PATCH] alias.c (get_alias_set): Remove handling of PLACEHOLDER_EXPR. * 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. From-SVN: r79789 --- gcc/ChangeLog | 27 +++++++++ gcc/ada/ChangeLog | 15 +++++ gcc/ada/decl.c | 9 +-- gcc/ada/gigi.h | 2 +- gcc/ada/trans.c | 25 +++----- gcc/ada/utils.c | 31 +--------- gcc/ada/utils2.c | 105 ++++++-------------------------- gcc/alias.c | 25 ++------ gcc/dojump.c | 9 --- gcc/dwarf2out.c | 1 - gcc/emit-rtl.c | 28 +++------ gcc/explow.c | 5 +- gcc/expr.c | 147 +++++--------------------------------------- gcc/expr.h | 11 ---- gcc/fold-const.c | 11 ---- gcc/tree.c | 151 ++++++++++++++++++++++++++++++++++++++-------- gcc/tree.def | 31 +++------- gcc/tree.h | 18 ++++++ 18 files changed, 260 insertions(+), 391 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 5a53bc9abbbf..93f379d6b404 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,30 @@ +2004-03-21 Richard Kenner + + * 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 * dojump.c (prefer_and_bit_test): Fix which part of diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index 0da5c5914c67..ee6e709807d3 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,18 @@ +2004-03-21 Richard Kenner + + * 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 PR other/14630 diff --git a/gcc/ada/decl.c b/gcc/ada/decl.c index fd82da9c87b5..458213e08b1c 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 4d4467127bc5..423b8980b338 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 dc7c404d6e63..dc34b725cf6d 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 37a9fbd0aea9..cd3f47c5b63b 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 a8f228d6eb03..a0d33db6580e 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 2c7770d32f6b..be10ba688a67 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 09a13d988c5a..f19cbcc3d914 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 3cc1782c8359..b3dcda0c5c05 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 6d18b7820942..8d8ead16f092 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 b3c82b836fd4..1eec943eb26e 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 b909c7c7b8fc..80647265ef46 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 dd7ac9c6058b..5c7bbbe6c515 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 64c68b8eb92e..84c605528baf 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 ed7771a8804d..240d3357454e 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 78919740da33..d56142f4e814 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 5e5a88e6d8fd..28b26deb865f 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 -- 2.39.2