procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

tree-optimization/113831 - revert original fix

Browse source 
This reverts the original fix for PR113831 which is better fixed by
the PR114121 fix.  I've XFAILed instead of removing the PR108355
testcase again.

	PR tree-optimization/113831
	PR tree-optimization/108355
	* tree-ssa-sccvn.cc (copy_reference_ops_from_ref): Revert
	PR113831 fix.

	* gcc.dg/tree-ssa/ssa-fre-104.c: XFAIL.
This commit is contained in:
Richard Biener 2024-02-28 13:45:57 +01:00
parent c841144a94
commit 5c01ede02a
2 changed files with 1 additions and 135 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-104.c
View file

@ -21,4 +21,4 @@ int main() {
*c = &d;
}
/* { dg-final { scan-tree-dump-not "foo" "fre1" } } */
/* { dg-final { scan-tree-dump-not "foo" "fre1" { xfail *-*-* } } } */

134
gcc/tree-ssa-sccvn.cc
View file

@ -912,8 +912,6 @@ copy_reference_ops_from_ref (tree ref, vec<vn_reference_op_s> *result)
{
/* For non-calls, store the information that makes up the address. */
tree orig = ref;
unsigned start = result->length ();
bool seen_variable_array_ref = false;
while (ref)
{
vn_reference_op_s temp;
@ -1000,12 +998,6 @@ copy_reference_ops_from_ref (tree ref, vec<vn_reference_op_s> *result)
tree eltype = TREE_TYPE (TREE_TYPE (TREE_OPERAND (ref, 0)));
/* Record index as operand. */
temp.op0 = TREE_OPERAND (ref, 1);
/* When the index is not constant we have to apply the same
logic as get_ref_base_and_extent which eventually uses
global ranges to refine the overall ref extent. Record
we've seen such a case, fixup below. */
if (TREE_CODE (temp.op0) == SSA_NAME)
seen_variable_array_ref = true;
/* Always record lower bounds and element size. */
temp.op1 = array_ref_low_bound (ref);
/* But record element size in units of the type alignment. */
@ -1098,132 +1090,6 @@ copy_reference_ops_from_ref (tree ref, vec<vn_reference_op_s> *result)
else
ref = NULL_TREE;
}
poly_int64 offset, size, max_size;
tree base;
bool rev;
if (seen_variable_array_ref
&& handled_component_p (orig)
&& (base = get_ref_base_and_extent (orig,
&offset, &size, &max_size, &rev))
&& known_size_p (max_size)
&& known_eq (size, max_size))
{
poly_int64 orig_offset = offset;
poly_int64 tem;
if (TREE_CODE (base) == MEM_REF
&& mem_ref_offset (base).to_shwi (&tem))
offset += tem * BITS_PER_UNIT;
HOST_WIDE_INT coffset = offset.to_constant ();
/* When get_ref_base_and_extent computes an offset constrained to
a constant position we have to fixup variable array indexes in
the ref to avoid the situation where based on context we'd have
to value-number the same vn_reference ops differently. Make
the vn_reference ops differ by adjusting those indexes to
appropriate constants. */
poly_int64 off = 0;
bool oob_index = false;
for (unsigned i = result->length (); i > start; --i)
{
auto &op = (*result)[i-1];
if (flag_checking
&& op.opcode == ARRAY_REF
&& TREE_CODE (op.op0) == INTEGER_CST)
{
/* The verifier below chokes on inconsistencies of handling
out-of-bound accesses so disable it in that case. */
tree atype = (*result)[i].type;
if (TREE_CODE (atype) == ARRAY_TYPE)
if (tree dom = TYPE_DOMAIN (atype))
if ((TYPE_MIN_VALUE (dom)
&& TREE_CODE (TYPE_MIN_VALUE (dom)) == INTEGER_CST
&& (wi::to_widest (op.op0)
< wi::to_widest (TYPE_MIN_VALUE (dom))))
|| (TYPE_MAX_VALUE (dom)
&& TREE_CODE (TYPE_MAX_VALUE (dom)) == INTEGER_CST
&& (wi::to_widest (op.op0)
> wi::to_widest (TYPE_MAX_VALUE (dom)))))
oob_index = true;
}
if ((op.opcode == ARRAY_REF
|| op.opcode == ARRAY_RANGE_REF)
&& TREE_CODE (op.op0) == SSA_NAME)
{
/* There's a single constant index that get's 'off' closer
to 'offset'. */
unsigned HOST_WIDE_INT elsz
= tree_to_uhwi (op.op2) * vn_ref_op_align_unit (&op);
unsigned HOST_WIDE_INT idx
= (coffset - off.to_constant ()) / BITS_PER_UNIT / elsz;
if (idx == 0)
op.op0 = op.op1;
else
op.op0 = wide_int_to_tree (TREE_TYPE (op.op0),
wi::to_poly_wide (op.op1) + idx);
op.off = idx * elsz;
off += op.off * BITS_PER_UNIT;
}
else
{
if (op.opcode == ERROR_MARK)
/* two-ops codes have the offset in the first op. */
;
else if (op.opcode == ADDR_EXPR
|| op.opcode == SSA_NAME
|| op.opcode == CONSTRUCTOR
|| TREE_CODE_CLASS (op.opcode) == tcc_declaration
|| TREE_CODE_CLASS (op.opcode) == tcc_constant)
/* end-of ref. */
gcc_assert (i == result->length ());
else if (op.opcode == COMPONENT_REF)
{
/* op.off is tracked in bytes, re-do it manually
because of bitfields. */
tree field = op.op0;
/* We do not have a complete COMPONENT_REF tree here so we
cannot use component_ref_field_offset. Do the interesting
parts manually. */
tree this_offset = DECL_FIELD_OFFSET (field);
if (op.op1 || !poly_int_tree_p (this_offset))
gcc_unreachable ();
else
{
poly_offset_int woffset
= (wi::to_poly_offset (this_offset)
<< LOG2_BITS_PER_UNIT);
woffset += wi::to_offset (DECL_FIELD_BIT_OFFSET (field));
off += woffset.force_shwi ();
}
}
else
{
gcc_assert (known_ne (op.off, -1)
/* The constant offset can be -1. */
|| op.opcode == MEM_REF
/* Out-of-bound indices can compute to
a known -1 offset. */
|| ((op.opcode == ARRAY_REF
|| op.opcode == ARRAY_RANGE_REF)
&& poly_int_tree_p (op.op0)
&& poly_int_tree_p (op.op1)
&& TREE_CODE (op.op2) == INTEGER_CST));
off += op.off * BITS_PER_UNIT;
}
}
}
if (flag_checking && !oob_index)
{
ao_ref r;
if (start != 0)
;
else if (ao_ref_init_from_vn_reference (&r, 0, 0, TREE_TYPE (orig),
*result))
gcc_assert (known_eq (r.offset, orig_offset)
&& known_eq (r.size, size)
&& known_eq (r.max_size, max_size));
else
gcc_unreachable ();
}
}
}
/* Build a alias-oracle reference abstraction in *REF from the vn_reference