[tree-optimization] : Fix for PR/49806

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  <ktietz@redhat.com>

	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

PING

2011/8/9 Kai Tietz <ktietz70@googlemail.com>:
> 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  <ktietz@redhat.com>
>
>        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))
>