PING
2011/8/9 Kai Tietz <[email protected]>:
> Hello,
>
> actual the remaining issue about this PR is that vrp
> constructs by range analyzis for bitwise and/or expressions
> type-casted results, like ((type) A) op ((type) B), or ((type) A) op CST.
> So I've added to simplify_bit_ops_using_rnages the transformation of
> ((type) A) op ((type) B) -> (type) (A op B)
> ((type) A) op CST -> (type) (A op CST'), with CST'=(type-A)
>
> This first transformation is valid if A has an integral type, TYPE
> is of integral kind,
> and type of B has compatible type to type of A.
> The second transformation is valid if A has integral type, TYPE is
> of integral kind,
> and CST fits into type of A.
>
> 2011-08-09 Kai Tietz <[email protected]>
>
> PR middle-end/49806
> * tree-vrp.c (simplify_bit_ops_using_ranges): Add
> code for type-cast sinking for bitwise-operations.
>
> * gcc.dg/tree-ssa/vrp47.c: Remove dom-dump and adjusted
> scan test for vrp result.
>
> Bootstrapped and regression tested for all languages (including Ada
> and Obj-C++) on host x86_64-pc-linux-gnu. Ok for apply?
>
> Regards,
> Kai
>
> Index: gcc/gcc/testsuite/gcc.dg/tree-ssa/vrp47.c
> ===================================================================
> --- gcc.orig/gcc/testsuite/gcc.dg/tree-ssa/vrp47.c
> +++ gcc/gcc/testsuite/gcc.dg/tree-ssa/vrp47.c
> @@ -4,8 +4,8 @@
> jumps when evaluating an && condition. VRP is not able to optimize
> this. */
> /* { dg-do compile { target { ! "mips*-*-* s390*-*-* avr-*-*
> mn10300-*-*" } } } */
> -/* { dg-options "-O2 -fdump-tree-vrp1 -fdump-tree-dom1" } */
> -/* { dg-options "-O2 -fdump-tree-vrp1 -fdump-tree-dom1 -march=i586" {
> target { i?86-*-* && ilp32 } } } */
> +/* { dg-options "-O2 -fdump-tree-vrp1" } */
> +/* { dg-options "-O2 -fdump-tree-vrp1 -march=i586" { target {
> i?86-*-* && ilp32 } } } */
>
> int h(int x, int y)
> {
> @@ -37,12 +37,10 @@ int f(int x)
> /* { dg-final { scan-tree-dump-times "\[xy\]\[^ \]* !=" 0 "vrp1" } } */
>
> /* This one needs more copy propagation that only happens in dom1. */
> -/* { dg-final { scan-tree-dump-times "x\[^ \]* & y" 1 "dom1" } } */
> -/* { dg-final { scan-tree-dump-times "x\[^ \]* & y" 1 "vrp1" { xfail
> *-*-* } } } */
> +/* { dg-final { scan-tree-dump-times "x\[^ \]* & y" 1 "vrp1" } } */
>
> /* These two are fully simplified by VRP. */
> /* { dg-final { scan-tree-dump-times "x\[^ \]* \[|\] y" 1 "vrp1" } } */
> /* { dg-final { scan-tree-dump-times "x\[^ \]* \\^ 1" 1 "vrp1" } } */
>
> /* { dg-final { cleanup-tree-dump "vrp1" } } */
> -/* { dg-final { cleanup-tree-dump "dom1" } } */
> Index: gcc/gcc/tree-vrp.c
> ===================================================================
> --- gcc.orig/gcc/tree-vrp.c
> +++ gcc/gcc/tree-vrp.c
> @@ -6968,15 +6968,63 @@ simplify_abs_using_ranges (gimple stmt)
> static bool
> simplify_bit_ops_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
> {
> + gimple def0, def1;
> tree op0 = gimple_assign_rhs1 (stmt);
> tree op1 = gimple_assign_rhs2 (stmt);
> - tree op = NULL_TREE;
> + tree op = NULL_TREE, nop0 = NULL_TREE, nop1 = NULL_TREE;
> value_range_t vr0 = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL };
> value_range_t vr1 = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL };
> double_int may_be_nonzero0, may_be_nonzero1;
> double_int must_be_nonzero0, must_be_nonzero1;
> double_int mask;
>
> + def0 = TREE_CODE (op0) == SSA_NAME ? SSA_NAME_DEF_STMT (op0) : NULL;
> + def1 = TREE_CODE (op1) == SSA_NAME ? SSA_NAME_DEF_STMT (op1) : NULL;
> + if (def0 && is_gimple_assign (def0))
> + nop0 = gimple_assign_rhs1 (def0);
> + if (def1 && is_gimple_assign (def1))
> + nop1 = gimple_assign_rhs1 (def1);
> +
> + /* Simplify ((type) X) op ((type) Y) -> (type) (X op Y), if X and Y have
> + compatible integral types. */
> + if (nop0 != NULL_TREE && nop1 != NULL_TREE
> + && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def0))
> + && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def1))
> + && INTEGRAL_TYPE_P (TREE_TYPE (nop0))
> + && types_compatible_p (TREE_TYPE (nop0), TREE_TYPE (nop1)))
> + {
> + gimple newop;
> + tree tem = create_tmp_reg (TREE_TYPE (nop0), NULL);
> + newop = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt),
> + tem, nop0, nop1);
> + tem = make_ssa_name (tem, newop);
> + gimple_assign_set_lhs (newop, tem);
> + gsi_insert_before (gsi, newop, GSI_SAME_STMT);
> + update_stmt (newop);
> + gimple_assign_set_rhs_with_ops (gsi, NOP_EXPR, tem, NULL_TREE);
> + return true;
> + }
> + /* Simplify ((type) X) op CST -> (type) (X op (type-X) CST), if X has
> + an integral types. Additiona CST has to fit into type of X. */
> + else if (nop0 != NULL_TREE && TREE_CODE (op1) == INTEGER_CST
> + && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def0))
> + && INTEGRAL_TYPE_P (TREE_TYPE (nop0))
> + && int_fits_type_p (op1, TREE_TYPE (nop0)))
> + {
> + tree nop0 = gimple_assign_rhs1 (def0);
> + tree nop1 = fold_convert (TREE_TYPE (nop0), op1);
> + gimple newop;
> + tree tem = create_tmp_reg (TREE_TYPE (nop0), NULL);
> + newop = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt),
> + tem, nop0, nop1);
> + tem = make_ssa_name (tem, newop);
> + gimple_assign_set_lhs (newop, tem);
> + gsi_insert_before (gsi, newop, GSI_SAME_STMT);
> + update_stmt (newop);
> + gimple_assign_set_rhs_with_ops (gsi, NOP_EXPR, tem, NULL_TREE);
> + return true;
> + }
> +
> if (TREE_CODE (op0) == SSA_NAME)
> vr0 = *(get_value_range (op0));
> else if (is_gimple_min_invariant (op0))
>
--
| (\_/) This is Bunny. Copy and paste
| (='.'=) Bunny into your signature to help
| (")_(") him gain world domination
