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

tree.h (IS_CONVERT_EXPR_CODE_P): Renamed to 

* tree.h (IS_CONVERT_EXPR_CODE_P): Renamed to
        * CONVERT_EXPR_CODE_P.
        * tree-ssa-threadedge.c (simplify_control_stmt_condition): Use
        CONVERT_EXPR_P.
        * tree-data-ref.c (split_constant_offset_1): Likewise.
        * tree-inline.c (estimate_operator_cost): Use CASE_CONVERT.
        * tree-sra.c (sra_walk_expr): Likewise.
        * matrix-reorg.c (ssa_accessed_in_assign_rhs): Likewise.
        * tree-ssa-loop-niter.c (expand_simple_operations): Likewise.
        * gimple.h (gimple_assign_cast_p): Use CONVERT_EXPR_CODE_P.
        * tree-ssa-structalias.c (find_func_aliases, find_func_aliases):
        * Likewise.
        * gimple.c (gimple_assign_unary_nop_p): Likewise.
        * tree-vect-transform.c (vectorizable_type_demotion)
        (vectorizable_type_promotion): Likewise.
        * tree-inline.c (expand_call_inline): 
        * tree-ssa-forwprop.c (get_prop_source_stmt, can_propagate_from)
        (forward_propagate_addr_expr_1, forward_propagate_comparison)
        (tree_ssa_forward_propagate_single_use_vars): Likewise.
        * expr.c (expand_expr_real_1): Likewise.
        * tree-ssa-dom.c (hashable_expr_equal_p,
        * iterative_hash_hashable_expr)
        (gimple_assign_unary_useless_conversion_p): Likewise.
        * tree-stdarg.c (execute_optimize_stdarg): Likewise.
        * tree-ssa-ccp.c (ccp_fold, fold_gimple_assign): Likewise.
        * fold-const.c (fold_unary): Likewise.
        * tree.h (CONVERT_EXPR_P): Likewise.
        * tree.c (simple_cst_equal, iterative_hash_expr): Likewise.
        * tree-ssa-loop-im.c (rewrite_bittest): Likewise.
        * tree-vrp.c: 
        (register_edge_assert_for_2, extract_range_from_unary_expr)
        (register_edge_assert_for_1): Likewise.

        * cp/tree.c (cp_tree_equal): Likewise.

From-SVN: r139204
This commit is contained in:
Tomas Bily 2008-08-18 18:23:47 +02:00 committed by Tomas Bily
parent 3c7c6d39d0
commit 1a87cf0c4c
23 changed files with 79 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
gcc/ChangeLog
View File

@ -1,3 +1,36 @@
2008-08-18 Tomas Bily <tbily@suse.cz>
* tree.h (IS_CONVERT_EXPR_CODE_P): Renamed to CONVERT_EXPR_CODE_P.
* tree-ssa-threadedge.c (simplify_control_stmt_condition): Use
CONVERT_EXPR_P.
* tree-data-ref.c (split_constant_offset_1): Likewise.
* tree-inline.c (estimate_operator_cost): Use CASE_CONVERT.
* tree-sra.c (sra_walk_expr): Likewise.
* matrix-reorg.c (ssa_accessed_in_assign_rhs): Likewise.
* tree-ssa-loop-niter.c (expand_simple_operations): Likewise.
* gimple.h (gimple_assign_cast_p): Use CONVERT_EXPR_CODE_P.
* tree-ssa-structalias.c (find_func_aliases, find_func_aliases):
Likewise.
* gimple.c (gimple_assign_unary_nop_p): Likewise.
* tree-vect-transform.c (vectorizable_type_demotion)
(vectorizable_type_promotion): Likewise.
* tree-inline.c (expand_call_inline):
* tree-ssa-forwprop.c (get_prop_source_stmt, can_propagate_from)
(forward_propagate_addr_expr_1, forward_propagate_comparison)
(tree_ssa_forward_propagate_single_use_vars): Likewise.
* expr.c (expand_expr_real_1): Likewise.
* tree-ssa-dom.c (hashable_expr_equal_p, iterative_hash_hashable_expr)
(gimple_assign_unary_useless_conversion_p): Likewise.
* tree-stdarg.c (execute_optimize_stdarg): Likewise.
* tree-ssa-ccp.c (ccp_fold, fold_gimple_assign): Likewise.
* fold-const.c (fold_unary): Likewise.
* tree.h (CONVERT_EXPR_P): Likewise.
* tree.c (simple_cst_equal, iterative_hash_expr): Likewise.
* tree-ssa-loop-im.c (rewrite_bittest): Likewise.
* tree-vrp.c:
(register_edge_assert_for_2, extract_range_from_unary_expr)
(register_edge_assert_for_1): Likewise.
2008-08-18 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
* real.h (dconst_e, dconst_third, dconst_sqrt2, dconst_e_ptr,

4
gcc/cp/ChangeLog
View File

@ -1,3 +1,7 @@
2008-08-18 Tomas Bily <tbily@suse.cz>
* tree.c (cp_tree_equal): Use CONVERT_EXPR_CODE_P.
2008-08-18 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
* typeck.c: Update all callers of permerror.

4
gcc/cp/tree.c
View File

@ -1739,12 +1739,12 @@ cp_tree_equal (tree t1, tree t2)
return false;
for (code1 = TREE_CODE (t1);
code1 == NOP_EXPR || code1 == CONVERT_EXPR
CONVERT_EXPR_CODE_P (code1)
|| code1 == NON_LVALUE_EXPR;
code1 = TREE_CODE (t1))
t1 = TREE_OPERAND (t1, 0);
for (code2 = TREE_CODE (t2);
code2 == NOP_EXPR || code2 == CONVERT_EXPR
CONVERT_EXPR_CODE_P (code2)
|| code1 == NON_LVALUE_EXPR;
code2 = TREE_CODE (t2))
t2 = TREE_OPERAND (t2, 0);

2
gcc/expr.c
View File

@ -7153,7 +7153,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
unsignedp = TYPE_UNSIGNED (type);
ignore = (target == const0_rtx
|| ((code == NOP_EXPR || code == CONVERT_EXPR
|| ((CONVERT_EXPR_CODE_P (code)
|| code == COND_EXPR || code == VIEW_CONVERT_EXPR)
&& TREE_CODE (type) == VOID_TYPE));

4
gcc/fold-const.c
View File

@ -7625,7 +7625,7 @@ fold_unary (enum tree_code code, tree type, tree op0)
arg0 = op0;
if (arg0)
{
if (code == NOP_EXPR || code == CONVERT_EXPR
if (CONVERT_EXPR_CODE_P (code)
|| code == FLOAT_EXPR || code == ABS_EXPR)
{
/* Don't use STRIP_NOPS, because signedness of argument type
@ -7674,7 +7674,7 @@ fold_unary (enum tree_code code, tree type, tree op0)
so we don't get into an infinite recursion loop taking the
conversion out and then back in. */
if ((code == NOP_EXPR || code == CONVERT_EXPR
if ((CONVERT_EXPR_CODE_P (code)
|| code == NON_LVALUE_EXPR)
&& TREE_CODE (tem) == COND_EXPR
&& TREE_CODE (TREE_OPERAND (tem, 1)) == code

3
gcc/gimple.c
View File

@ -1899,8 +1899,7 @@ bool
gimple_assign_unary_nop_p (gimple gs)
{
return (gimple_code (gs) == GIMPLE_ASSIGN
&& (gimple_assign_rhs_code (gs) == NOP_EXPR
|| gimple_assign_rhs_code (gs) == CONVERT_EXPR
&& (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
|| gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
&& gimple_assign_rhs1 (gs) != error_mark_node
&& (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))

3
gcc/gimple.h
View File

@ -1853,8 +1853,7 @@ gimple_assign_cast_p (gimple s)
if (is_gimple_assign (s))
{
enum tree_code sc = gimple_assign_rhs_code (s);
return sc == NOP_EXPR
|| sc == CONVERT_EXPR
return CONVERT_EXPR_CODE_P (sc)
|| sc == VIEW_CONVERT_EXPR
|| sc == FIX_TRUNC_EXPR;
}

3
gcc/matrix-reorg.c
View File

@ -658,8 +658,7 @@ ssa_accessed_in_assign_rhs (gimple stmt, struct ssa_acc_in_tree *a)
case SSA_NAME:
case INDIRECT_REF:
case CONVERT_EXPR:
case NOP_EXPR:
CASE_CONVERT:
case VIEW_CONVERT_EXPR:
ssa_accessed_in_tree (gimple_assign_rhs1 (stmt), a);
break;

3
gcc/tree-data-ref.c
View File

@ -581,8 +581,7 @@ split_constant_offset_1 (tree type, tree op0, enum tree_code code, tree op1,
To compute that ARRAY_REF's element size TYPE_SIZE_UNIT, which
possibly no longer appears in current GIMPLE, might resurface.
This perhaps could run
if (TREE_CODE (var0) == NOP_EXPR
|| TREE_CODE (var0) == CONVERT_EXPR)
if (CONVERT_EXPR_P (var0))
{
gimplify_conversion (&var0);
// Attempt to fill in any within var0 found ARRAY_REF's

6
gcc/tree-inline.c
View File

@ -2632,10 +2632,9 @@ estimate_operator_cost (enum tree_code code, eni_weights *weights)
/* These are "free" conversions, or their presumed cost
is folded into other operations. */
case RANGE_EXPR:
case CONVERT_EXPR:
CASE_CONVERT:
case COMPLEX_EXPR:
case PAREN_EXPR:
case NOP_EXPR:
return 0;
/* Assign cost of 1 to usual operations.
@ -3346,8 +3345,7 @@ expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id)
if (is_gimple_assign (stmt))
{
gcc_assert (gimple_assign_single_p (stmt)
|| gimple_assign_rhs_code (stmt) == NOP_EXPR
|| gimple_assign_rhs_code (stmt) == CONVERT_EXPR);
|| CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt)));
TREE_USED (gimple_assign_rhs1 (stmt)) = 1;
}

3
gcc/tree-sra.c
View File

@ -881,8 +881,7 @@ sra_walk_expr (tree *expr_p, gimple_stmt_iterator *gsi, bool is_output,
outer element, to which walk_tree will bring us next. */
goto use_all;
case NOP_EXPR:
case CONVERT_EXPR:
CASE_CONVERT:
/* Similarly, a nop explicitly wants to look at an object in a
type other than the one we've scalarized. */
goto use_all;

5
gcc/tree-ssa-ccp.c
View File

@ -988,7 +988,7 @@ ccp_fold (gimple stmt)
useless_type_conversion_p places for pointer type conversions
do not apply here. Substitution later will only substitute to
allowed places. */
if (IS_CONVERT_EXPR_CODE_P (subcode)
if (CONVERT_EXPR_CODE_P (subcode)
&& POINTER_TYPE_P (TREE_TYPE (lhs))
&& POINTER_TYPE_P (TREE_TYPE (op0))
/* Do not allow differences in volatile qualification
@ -2781,8 +2781,7 @@ fold_gimple_assign (gimple_stmt_iterator *si)
if (valid_gimple_rhs_p (result))
return result;
}
else if ((gimple_assign_rhs_code (stmt) == NOP_EXPR
|| gimple_assign_rhs_code (stmt) == CONVERT_EXPR)
else if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))
&& POINTER_TYPE_P (gimple_expr_type (stmt))
&& POINTER_TYPE_P (TREE_TYPE (gimple_assign_rhs1 (stmt))))
{

9
gcc/tree-ssa-dom.c
View File

@ -381,8 +381,7 @@ hashable_expr_equal_p (const struct hashable_expr *expr0,
if (expr0->ops.unary.op != expr1->ops.unary.op)
return false;
if ((expr0->ops.unary.op == NOP_EXPR
|| expr0->ops.unary.op == CONVERT_EXPR
if ((CONVERT_EXPR_CODE_P (expr0->ops.unary.op)
|| expr0->ops.unary.op == NON_LVALUE_EXPR)
&& TYPE_UNSIGNED (expr0->type) != TYPE_UNSIGNED (expr1->type))
return false;
@ -460,8 +459,7 @@ iterative_hash_hashable_expr (const struct hashable_expr *expr, hashval_t val)
Don't hash the type, that can lead to having nodes which
compare equal according to operand_equal_p, but which
have different hash codes. */
if (expr->ops.unary.op == NOP_EXPR
|| expr->ops.unary.op == CONVERT_EXPR
if (CONVERT_EXPR_CODE_P (expr->ops.unary.op)
|| expr->ops.unary.op == NON_LVALUE_EXPR)
val += TYPE_UNSIGNED (expr->type);
@ -1929,8 +1927,7 @@ static bool
gimple_assign_unary_useless_conversion_p (gimple gs)
{
if (is_gimple_assign (gs)
&& (gimple_assign_rhs_code (gs) == NOP_EXPR
|| gimple_assign_rhs_code (gs) == CONVERT_EXPR
&& (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
|| gimple_assign_rhs_code (gs) == VIEW_CONVERT_EXPR
|| gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR))
{

12
gcc/tree-ssa-forwprop.c
View File

@ -232,7 +232,7 @@ get_prop_source_stmt (tree name, bool single_use_only, bool *single_use_p)
/* We can look through pointer conversions in the search
for a useful stmt for the comparison folding. */
rhs = gimple_assign_rhs1 (def_stmt);
if (IS_CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt))
if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt))
&& TREE_CODE (rhs) == SSA_NAME
&& POINTER_TYPE_P (TREE_TYPE (gimple_assign_lhs (def_stmt)))
&& POINTER_TYPE_P (TREE_TYPE (rhs)))
@ -282,7 +282,7 @@ can_propagate_from (gimple def_stmt)
function pointers to be canonicalized and in this case this
optimization could eliminate a necessary canonicalization. */
if (is_gimple_assign (def_stmt)
&& (IS_CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt))))
&& (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt))))
{
tree rhs = gimple_assign_rhs1 (def_stmt);
if (POINTER_TYPE_P (TREE_TYPE (rhs))
@ -689,7 +689,7 @@ forward_propagate_addr_expr_1 (tree name, tree def_rhs,
a conversion to def_rhs type separate, though. */
if (TREE_CODE (lhs) == SSA_NAME
&& ((rhs_code == SSA_NAME && rhs == name)
|| IS_CONVERT_EXPR_CODE_P (rhs_code))
|| CONVERT_EXPR_CODE_P (rhs_code))
&& useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (def_rhs)))
{
/* Only recurse if we don't deal with a single use. */
@ -928,7 +928,7 @@ forward_propagate_comparison (gimple stmt)
/* Conversion of the condition result to another integral type. */
if (is_gimple_assign (use_stmt)
&& (IS_CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (use_stmt))
&& (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (use_stmt))
|| TREE_CODE_CLASS (gimple_assign_rhs_code (use_stmt))
== tcc_comparison
|| gimple_assign_rhs_code (use_stmt) == TRUTH_NOT_EXPR)
@ -937,7 +937,7 @@ forward_propagate_comparison (gimple stmt)
tree lhs = gimple_assign_lhs (use_stmt);
/* We can propagate the condition into a conversion. */
if (IS_CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (use_stmt)))
if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (use_stmt)))
{
/* Avoid using fold here as that may create a COND_EXPR with
non-boolean condition as canonical form. */
@ -1138,7 +1138,7 @@ tree_ssa_forward_propagate_single_use_vars (void)
if (gimple_assign_rhs_code (stmt) == ADDR_EXPR
/* Handle pointer conversions on invariant addresses
as well, as this is valid gimple. */
|| (IS_CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))
|| (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))
&& TREE_CODE (rhs) == ADDR_EXPR
&& POINTER_TYPE_P (TREE_TYPE (lhs))))
{

3
gcc/tree-ssa-loop-im.c
View File

@ -819,8 +819,7 @@ rewrite_bittest (gimple_stmt_iterator *bsi)
return stmt;
/* There is a conversion in between possibly inserted by fold. */
if (gimple_assign_rhs_code (stmt1) == NOP_EXPR
|| gimple_assign_rhs_code (stmt1) == CONVERT_EXPR)
if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt1)))
{
t = gimple_assign_rhs1 (stmt1);
if (TREE_CODE (t) != SSA_NAME

3
gcc/tree-ssa-loop-niter.c
View File

@ -1451,8 +1451,7 @@ expand_simple_operations (tree expr)
switch (code)
{
case NOP_EXPR:
case CONVERT_EXPR:
CASE_CONVERT:
/* Casts are simple. */
ee = expand_simple_operations (e);
return fold_build1 (code, TREE_TYPE (expr), ee);

4
gcc/tree-ssa-structalias.c
View File

@ -3852,7 +3852,7 @@ find_func_aliases (gimple origt)
if (gimple_assign_rhs_code (t) == POINTER_PLUS_EXPR)
get_constraint_for_ptr_offset (gimple_assign_rhs1 (t),
gimple_assign_rhs2 (t), &rhsc);
else if ((IS_CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (t))
else if ((CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (t))
&& !(POINTER_TYPE_P (gimple_expr_type (t))
&& !POINTER_TYPE_P (TREE_TYPE (rhsop))))
|| gimple_assign_single_p (t))
@ -3908,7 +3908,7 @@ find_func_aliases (gimple origt)
else if (stmt_escape_type == ESCAPE_BAD_CAST)
{
gcc_assert (is_gimple_assign (t));
gcc_assert (IS_CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (t))
gcc_assert (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (t))
|| gimple_assign_rhs_code (t) == VIEW_CONVERT_EXPR);
make_escape_constraint (gimple_assign_rhs1 (t));
}

3
gcc/tree-ssa-threadedge.c
View File

@ -483,8 +483,7 @@ simplify_control_stmt_condition (edge e,
cached_lhs = fold_binary (cond_code, boolean_type_node, op0, op1);
if (cached_lhs)
while (TREE_CODE (cached_lhs) == NOP_EXPR
|| TREE_CODE (cached_lhs) == CONVERT_EXPR)
while (CONVERT_EXPR_P (cached_lhs))
cached_lhs = TREE_OPERAND (cached_lhs, 0);
fold_undefer_overflow_warnings ((cached_lhs

2
gcc/tree-stdarg.c
View File

@ -811,7 +811,7 @@ execute_optimize_stdarg (void)
if ((gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR
&& TREE_CODE (gimple_assign_rhs2 (stmt)) == INTEGER_CST)
|| IS_CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))
|| CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))
|| (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
== GIMPLE_SINGLE_RHS))
check_va_list_escapes (&si, lhs, rhs);

8
gcc/tree-vect-transform.c
View File

@ -4341,7 +4341,7 @@ vectorizable_type_demotion (gimple stmt, gimple_stmt_iterator *gsi,
return false;
code = gimple_assign_rhs_code (stmt);
if (code != NOP_EXPR && code != CONVERT_EXPR)
if (!CONVERT_EXPR_CODE_P (code))
return false;
op0 = gimple_assign_rhs1 (stmt);
@ -4366,7 +4366,7 @@ vectorizable_type_demotion (gimple stmt, gimple_stmt_iterator *gsi,
&& INTEGRAL_TYPE_P (TREE_TYPE (op0)))
|| (SCALAR_FLOAT_TYPE_P (TREE_TYPE (scalar_dest))
&& SCALAR_FLOAT_TYPE_P (TREE_TYPE (op0))
&& (code == NOP_EXPR || code == CONVERT_EXPR))))
&& CONVERT_EXPR_CODE_P (code))))
return false;
/* Check the operands of the operation. */
@ -4534,7 +4534,7 @@ vectorizable_type_promotion (gimple stmt, gimple_stmt_iterator *gsi,
return false;
code = gimple_assign_rhs_code (stmt);
if (code != NOP_EXPR && code != CONVERT_EXPR
if (!CONVERT_EXPR_CODE_P (code)
&& code != WIDEN_MULT_EXPR)
return false;
@ -4559,7 +4559,7 @@ vectorizable_type_promotion (gimple stmt, gimple_stmt_iterator *gsi,
&& INTEGRAL_TYPE_P (TREE_TYPE (op0)))
|| (SCALAR_FLOAT_TYPE_P (TREE_TYPE (scalar_dest))
&& SCALAR_FLOAT_TYPE_P (TREE_TYPE (op0))
&& (code == CONVERT_EXPR || code == NOP_EXPR))))
&& CONVERT_EXPR_CODE_P (code))))
return false;
/* Check the operands of the operation. */

9
gcc/tree-vrp.c
View File

@ -2483,8 +2483,7 @@ extract_range_from_unary_expr (value_range_t *vr, enum tree_code code,
}
/* Handle unary expressions on integer ranges. */
if ((code == NOP_EXPR
|| code == CONVERT_EXPR)
if (CONVERT_EXPR_CODE_P (code)
&& INTEGRAL_TYPE_P (type)
&& INTEGRAL_TYPE_P (TREE_TYPE (op0)))
{
@ -3944,8 +3943,7 @@ register_edge_assert_for_2 (tree name, edge e, gimple_stmt_iterator bsi,
/* Extract NAME2 from the (optional) sign-changing cast. */
if (gimple_assign_cast_p (def_stmt))
{
if ((gimple_assign_rhs_code (def_stmt) == NOP_EXPR
|| gimple_assign_rhs_code (def_stmt) == CONVERT_EXPR)
if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt))
&& ! TYPE_UNSIGNED (TREE_TYPE (gimple_assign_rhs1 (def_stmt)))
&& (TYPE_PRECISION (gimple_expr_type (def_stmt))
== TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (def_stmt)))))
@ -4098,8 +4096,7 @@ register_edge_assert_for_1 (tree op, enum tree_code code,
retval |= register_edge_assert_for_1 (gimple_assign_rhs1 (op_def),
code, e, bsi);
}
else if (gimple_assign_rhs_code (op_def) == NOP_EXPR
|| gimple_assign_rhs_code (op_def) == CONVERT_EXPR)
else if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (op_def)))
{
/* Recurse through the type conversion. */
retval |= register_edge_assert_for_1 (gimple_assign_rhs1 (op_def),

9
gcc/tree.c
View File

@ -5022,16 +5022,16 @@ simple_cst_equal (const_tree t1, const_tree t2)
code1 = TREE_CODE (t1);
code2 = TREE_CODE (t2);
if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR)
{
if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
if (CONVERT_EXPR_CODE_P (code2)
|| code2 == NON_LVALUE_EXPR)
return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
else
return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
}
else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
else if (CONVERT_EXPR_CODE_P (code2)
|| code2 == NON_LVALUE_EXPR)
return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
@ -5338,8 +5338,7 @@ iterative_hash_expr (const_tree t, hashval_t val)
/* Don't hash the type, that can lead to having nodes which
compare equal according to operand_equal_p, but which
have different hash codes. */
if (code == NOP_EXPR
|| code == CONVERT_EXPR
if (CONVERT_EXPR_CODE_P (code)
|| code == NON_LVALUE_EXPR)
{
/* Make sure to include signness in the hash computation. */

4
gcc/tree.h
View File

@ -962,11 +962,11 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int,
#define TREE_HASH(NODE) ((size_t) (NODE) & 0777777)
/* Tests if CODE is a conversion expr (NOP_EXPR or CONVERT_EXPR). */
#define IS_CONVERT_EXPR_CODE_P(CODE) \
#define CONVERT_EXPR_CODE_P(CODE) \
((CODE) == NOP_EXPR || (CODE) == CONVERT_EXPR)
/* Similarly, but accept an expressions instead of a tree code. */
#define CONVERT_EXPR_P(EXP) IS_CONVERT_EXPR_CODE_P (TREE_CODE (EXP))
#define CONVERT_EXPR_P(EXP) CONVERT_EXPR_CODE_P (TREE_CODE (EXP))
/* Generate case for NOP_EXPR, CONVERT_EXPR. */