From 3168cb992791efed6b803d0f44a37528245b7a96 Mon Sep 17 00:00:00 2001 From: Jeff Law Date: Mon, 2 Feb 2004 20:03:43 -0700 Subject: [PATCH] tree.c (commutative_tree_code, [...]): New functions. * tree.c (commutative_tree_code, associative_tree_code): New functions. (iterative_hash_expr): Use commutative_tree_code. * tree.h (commutative_tree_code, associative_tree_code): Declare. * fold-const.c (operand_equal_p): Use commutative_tree_code rather than inlining the commutativity check. (fold): Likewise. Co-Authored-By: Roger Sayle From-SVN: r77152 --- gcc/ChangeLog | 11 ++++++++++ gcc/fold-const.c | 12 ++--------- gcc/tree.c | 53 +++++++++++++++++++++++++++++++++++++++++++++--- gcc/tree.h | 2 ++ 4 files changed, 65 insertions(+), 13 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 3ca1898728b..a467635fd04 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,14 @@ +2004-02-02 Jeff Law + Roger Sayle + + * tree.c (commutative_tree_code, associative_tree_code): New + functions. + (iterative_hash_expr): Use commutative_tree_code. + * tree.h (commutative_tree_code, associative_tree_code): Declare. + * fold-const.c (operand_equal_p): Use commutative_tree_code + rather than inlining the commutativity check. + (fold): Likewise. + 2004-02-02 Kazu Hirata * system.h (FUNCTION_ARG_KEEP_AS_REFERENCE): Poison. diff --git a/gcc/fold-const.c b/gcc/fold-const.c index de72a76f1ff..264e5f01f28 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -833,7 +833,6 @@ negate_mathfn_p (enum built_in_function code) return false; } - /* Determine whether an expression T can be cheaply negated using the function negate_expr. */ @@ -2105,12 +2104,7 @@ operand_equal_p (tree arg0, tree arg1, int only_const) return 1; /* For commutative ops, allow the other order. */ - return ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MULT_EXPR - || TREE_CODE (arg0) == MIN_EXPR || TREE_CODE (arg0) == MAX_EXPR - || TREE_CODE (arg0) == BIT_IOR_EXPR - || TREE_CODE (arg0) == BIT_XOR_EXPR - || TREE_CODE (arg0) == BIT_AND_EXPR - || TREE_CODE (arg0) == NE_EXPR || TREE_CODE (arg0) == EQ_EXPR) + return (commutative_tree_code (TREE_CODE (arg0)) && operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0) && operand_equal_p (TREE_OPERAND (arg0, 1), @@ -5299,9 +5293,7 @@ fold (tree expr) /* If this is a commutative operation, and ARG0 is a constant, move it to ARG1 to reduce the number of tests below. */ - if ((code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR - || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR - || code == BIT_AND_EXPR) + if (commutative_tree_code (code) && tree_swap_operands_p (arg0, arg1, true)) return fold (build (code, type, arg1, arg0)); diff --git a/gcc/tree.c b/gcc/tree.c index 1be80e9dd20..47ae7ba5e95 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -3538,6 +3538,55 @@ compare_tree_int (tree t, unsigned HOST_WIDE_INT u) return 1; } +/* Return true if CODE represents an associative tree code. Otherwise + return false. */ +bool +associative_tree_code (enum tree_code code) +{ + switch (code) + { + case BIT_IOR_EXPR: + case BIT_AND_EXPR: + case BIT_XOR_EXPR: + case PLUS_EXPR: + case MINUS_EXPR: + case MULT_EXPR: + case LSHIFT_EXPR: + case RSHIFT_EXPR: + case MIN_EXPR: + case MAX_EXPR: + return true; + + default: + break; + } + return false; +} + +/* Return true if CODE represents an commutative tree code. Otherwise + return false. */ +bool +commutative_tree_code (enum tree_code code) +{ + switch (code) + { + case PLUS_EXPR: + case MULT_EXPR: + case MIN_EXPR: + case MAX_EXPR: + case BIT_IOR_EXPR: + case BIT_XOR_EXPR: + case BIT_AND_EXPR: + case NE_EXPR: + case EQ_EXPR: + return true; + + default: + break; + } + return false; +} + /* Generate a hash value for an expression. This can be used iteratively by passing a previous result as the "val" argument. @@ -3595,9 +3644,7 @@ iterative_hash_expr (tree t, hashval_t val) || code == NON_LVALUE_EXPR) val = iterative_hash_object (TREE_TYPE (t), val); - if (code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR - || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR - || code == BIT_AND_EXPR || code == NE_EXPR || code == EQ_EXPR) + if (commutative_tree_code (code)) { /* It's a commutative expression. We want to hash it the same however it appears. We do this by first hashing both operands diff --git a/gcc/tree.h b/gcc/tree.h index 7503fa5aaef..a69678285ee 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -2713,6 +2713,8 @@ extern tree get_callee_fndecl (tree); extern void change_decl_assembler_name (tree, tree); extern int type_num_arguments (tree); extern tree lhd_unsave_expr_now (tree); +extern bool associative_tree_code (enum tree_code); +extern bool commutative_tree_code (enum tree_code); /* In stmt.c */ -- 2.30.2