OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fold-const.c (operand_equal_p): Remove kludge allowing ARG0 and ARG1 to be null... 

* fold-const.c (operand_equal_p): Remove kludge allowing ARG0 and
	ARG1 to be null; instead define OP_SAME and OP_SAME_NULL and use them.

From-SVN: r91170
This commit is contained in:
Richard Kenner 2004-11-24 15:57:08 +00:00 committed by Richard Kenner
parent 0492baf2cc
commit 624b15fa3f
2 changed files with 42 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
gcc/ChangeLog
View File

@ -1,3 +1,8 @@
2004-11-24 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
* fold-const.c (operand_equal_p): Remove kludge allowing ARG0 and
ARG1 to be null; instead define OP_SAME and OP_SAME_NULL and use them.
2004-11-24 Nathan Sidwell <nathan@codesourcery.com>
* bitmap.c (INLINE): Do not define.

91
gcc/fold-const.c
View File

@ -2331,17 +2331,8 @@ truth_value_p (enum tree_code code)
int
operand_equal_p (tree arg0, tree arg1, unsigned int flags)
{
/* If one is specified and the other isn't, they aren't equal and if
neither is specified, they are.
??? This is temporary and is meant only to handle the cases of the
optional operands for COMPONENT_REF and ARRAY_REF. */
if ((arg0 && !arg1) || (!arg0 && arg1))
return 0;
else if (!arg0 && !arg1)
return 1;
/* If either is ERROR_MARK, they aren't equal. */
else if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK)
if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK)
return 0;
/* If both types don't have the same signedness, then we can't consider
@ -2433,6 +2424,17 @@ operand_equal_p (tree arg0, tree arg1, unsigned int flags)
if (flags & OEP_ONLY_CONST)
return 0;
/* Define macros to test an operan from arg0 and arg1 for equality and a
variant that allows null and views null as being different from any
non-null value. In the latter case, if either is null, the both
must be; otherwise, do the normal comparison. */
#define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
TREE_OPERAND (arg1, N), flags)
#define OP_SAME_WITH_NULL(N) \
((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
{
case tcc_unary:
@ -2453,15 +2455,12 @@ operand_equal_p (tree arg0, tree arg1, unsigned int flags)
break;
}
return operand_equal_p (TREE_OPERAND (arg0, 0),
TREE_OPERAND (arg1, 0), flags);
return OP_SAME (0);
case tcc_comparison:
case tcc_binary:
if (operand_equal_p (TREE_OPERAND (arg0, 0),
TREE_OPERAND (arg1, 0), flags)
&& operand_equal_p (TREE_OPERAND (arg0, 1),
TREE_OPERAND (arg1, 1), flags))
if (OP_SAME (0) && OP_SAME (1))
return 1;
/* For commutative ops, allow the other order. */
@ -2485,37 +2484,23 @@ operand_equal_p (tree arg0, tree arg1, unsigned int flags)
case MISALIGNED_INDIRECT_REF:
case REALPART_EXPR:
case IMAGPART_EXPR:
return operand_equal_p (TREE_OPERAND (arg0, 0),
TREE_OPERAND (arg1, 0), flags);
return OP_SAME (0);
case ARRAY_REF:
case ARRAY_RANGE_REF:
return (operand_equal_p (TREE_OPERAND (arg0, 0),
TREE_OPERAND (arg1, 0), flags)
&& operand_equal_p (TREE_OPERAND (arg0, 1),
TREE_OPERAND (arg1, 1), flags)
&& operand_equal_p (TREE_OPERAND (arg0, 2),
TREE_OPERAND (arg1, 2), flags)
&& operand_equal_p (TREE_OPERAND (arg0, 3),
TREE_OPERAND (arg1, 3), flags));
/* Operands 2 and 3 may be null. */
return (OP_SAME (0)
&& OP_SAME (1)
&& OP_SAME_WITH_NULL (2)
&& OP_SAME_WITH_NULL (3));
case COMPONENT_REF:
return (operand_equal_p (TREE_OPERAND (arg0, 0),
TREE_OPERAND (arg1, 0), flags)
&& operand_equal_p (TREE_OPERAND (arg0, 1),
TREE_OPERAND (arg1, 1), flags)
&& operand_equal_p (TREE_OPERAND (arg0, 2),
TREE_OPERAND (arg1, 2), flags));
/* Handle operand 2 the same as for ARRAY_REF. */
return OP_SAME (0) && OP_SAME (1) && OP_SAME_WITH_NULL (2);
case BIT_FIELD_REF:
return (operand_equal_p (TREE_OPERAND (arg0, 0),
TREE_OPERAND (arg1, 0), flags)
&& operand_equal_p (TREE_OPERAND (arg0, 1),
TREE_OPERAND (arg1, 1), flags)
&& operand_equal_p (TREE_OPERAND (arg0, 2),
TREE_OPERAND (arg1, 2), flags));
return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
default:
return 0;
}
@ -2525,33 +2510,28 @@ operand_equal_p (tree arg0, tree arg1, unsigned int flags)
{
case ADDR_EXPR:
case TRUTH_NOT_EXPR:
return operand_equal_p (TREE_OPERAND (arg0, 0),
TREE_OPERAND (arg1, 0), flags);
return OP_SAME (0);
case TRUTH_ANDIF_EXPR:
case TRUTH_ORIF_EXPR:
return operand_equal_p (TREE_OPERAND (arg0, 0),
TREE_OPERAND (arg1, 0), flags)
&& operand_equal_p (TREE_OPERAND (arg0, 1),
TREE_OPERAND (arg1, 1), flags);
return OP_SAME (0) && OP_SAME (1);
case TRUTH_AND_EXPR:
case TRUTH_OR_EXPR:
case TRUTH_XOR_EXPR:
if (OP_SAME (0) && OP_SAME (1))
return 1;
/* Otherwise take into account this is a commutative operation. */
return (operand_equal_p (TREE_OPERAND (arg0, 0),
TREE_OPERAND (arg1, 0), flags)
TREE_OPERAND (arg1, 1), flags)
&& operand_equal_p (TREE_OPERAND (arg0, 1),
TREE_OPERAND (arg1, 1), flags))
|| (operand_equal_p (TREE_OPERAND (arg0, 0),
TREE_OPERAND (arg1, 1), flags)
&& operand_equal_p (TREE_OPERAND (arg0, 1),
TREE_OPERAND (arg1, 0), flags));
TREE_OPERAND (arg1, 0), flags));
case CALL_EXPR:
/* If the CALL_EXPRs call different functions, then they
clearly can not be equal. */
if (! operand_equal_p (TREE_OPERAND (arg0, 0),
TREE_OPERAND (arg1, 0), flags))
if (!OP_SAME (0))
return 0;
{
@ -2597,6 +2577,9 @@ operand_equal_p (tree arg0, tree arg1, unsigned int flags)
default:
return 0;
}
#undef OP_SAME
#undef OP_SAME_WITH_NULL
}
/* Similar to operand_equal_p, but see if ARG0 might have been made by