From patchwork Thu Jul 21 13:20:16 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kai Tietz X-Patchwork-Id: 106061 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id F29AAB6F80 for ; Thu, 21 Jul 2011 23:21:07 +1000 (EST) Received: (qmail 4044 invoked by alias); 21 Jul 2011 13:20:57 -0000 Received: (qmail 4017 invoked by uid 22791); 21 Jul 2011 13:20:52 -0000 X-SWARE-Spam-Status: No, hits=-1.8 required=5.0 tests=AWL, BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, FREEMAIL_ENVFROM_END_DIGIT, FREEMAIL_FROM, RCVD_IN_DNSWL_LOW, TW_TM X-Spam-Check-By: sourceware.org Received: from mail-qy0-f175.google.com (HELO mail-qy0-f175.google.com) (209.85.216.175) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Thu, 21 Jul 2011 13:20:17 +0000 Received: by qyk30 with SMTP id 30so3372892qyk.20 for ; Thu, 21 Jul 2011 06:20:16 -0700 (PDT) MIME-Version: 1.0 Received: by 10.229.17.17 with SMTP id q17mr201638qca.154.1311254416840; Thu, 21 Jul 2011 06:20:16 -0700 (PDT) Received: by 10.229.38.195 with HTTP; Thu, 21 Jul 2011 06:20:16 -0700 (PDT) Date: Thu, 21 Jul 2011 15:20:16 +0200 Message-ID: Subject: [patch tree-optimization]: Fix regression about vrp47.c (and co) From: Kai Tietz To: GCC Patches Cc: Richard Guenther X-IsSubscribed: yes Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Hello, this patch adds the ability for bitwise-truth operations to sink into use-statement, if it is a cast, if type of it is compatible. By this we can sink cases like _Bool D1, D2, D3; int R, x, y; D1 = (bool) x; D2 = (bool) y; D3 = D1 & D2 R = (int) D3; into R-statment as R = x & y; This fixes known vrp47.c regression. ChangeLog gcc 2011-07-21 Kai Tietz * tree-vrp.c (ssa_name_get_inner_ssa_name_p): New helper. (ssa_name_get_cast_to_p): Likewise. (simplify_truth_ops_using_ranges): Try to use type-cast for simplification of bitwise-binary expressions. (simplify_stmt_using_ranges): Try to sink into cast for bitwise-truth operations. 2011-07-21 Kai Tietz * gcc.dg/tree-ssa/vrp47.c: Adjust testcase. Bootstrapped and regression tested for all standard languages (including Ada and Obj-C++) on host x86_64-pc-linux-gnu. Ok for apply? Regards, Kai int h(int x, int y) @@ -36,13 +36,10 @@ int f(int x) 0 or 1. */ /* { 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 "vrp\[0-9\]" } } */ -/* { dg-final { cleanup-tree-dump "dom\[0-9\]" } } */ Index: gcc-head/gcc/tree-vrp.c =================================================================== --- gcc-head.orig/gcc/tree-vrp.c +++ gcc-head/gcc/tree-vrp.c @@ -6747,19 +6746,92 @@ varying: return SSA_PROP_VARYING; } +/* Returns operand1 of ssa-name with SSA_NAME as code, Otherwise it + returns NULL_TREE. */ +static tree +ssa_name_get_inner_ssa_name_p (tree op) +{ + gimple stmt; + + if (TREE_CODE (op) != SSA_NAME + || !is_gimple_assign (SSA_NAME_DEF_STMT (op))) + return NULL_TREE; + stmt = SSA_NAME_DEF_STMT (op); + if (gimple_assign_rhs_code (stmt) != SSA_NAME) + return NULL_TREE; + return gimple_assign_rhs1 (stmt); +} + +/* Returns operand of cast operation, if OP is a type-conversion. Otherwise + return NULL_TREE. */ +static tree +ssa_name_get_cast_to_p (tree op) +{ + gimple stmt; + + if (TREE_CODE (op) != SSA_NAME + || !is_gimple_assign (SSA_NAME_DEF_STMT (op))) + return NULL_TREE; + stmt = SSA_NAME_DEF_STMT (op); + if (!CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))) + return NULL_TREE; + return gimple_assign_rhs1 (stmt); +} + /* Simplify boolean operations if the source is known to be already a boolean. */ static bool simplify_truth_ops_using_ranges (gimple_stmt_iterator *gsi, gimple stmt) { enum tree_code rhs_code = gimple_assign_rhs_code (stmt); + gimple stmt2 = stmt; tree val = NULL; tree op0, op1; value_range_t *vr; bool sop = false; bool need_conversion; + location_t loc = gimple_location (stmt); op0 = gimple_assign_rhs1 (stmt); + op1 = NULL_TREE; + + /* Handle cases with prefixed type-cast. */ + if (CONVERT_EXPR_CODE_P (rhs_code) + && INTEGRAL_TYPE_P (TREE_TYPE (op0)) + && TREE_CODE (op0) == SSA_NAME + && is_gimple_assign (SSA_NAME_DEF_STMT (op0)) + && INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_lhs (stmt)))) + { + stmt2 = SSA_NAME_DEF_STMT (op0); + op0 = gimple_assign_rhs1 (stmt2); + if (!INTEGRAL_TYPE_P (TREE_TYPE (op0))) + return false; + rhs_code = gimple_assign_rhs_code (stmt2); + if (rhs_code != BIT_NOT_EXPR + && rhs_code != BIT_AND_EXPR + && rhs_code != BIT_IOR_EXPR + && rhs_code != BIT_XOR_EXPR + && rhs_code != NE_EXPR && rhs_code != EQ_EXPR) + return false; + + if (rhs_code != BIT_NOT_EXPR) + op1 = gimple_assign_rhs2 (stmt2); + + if (gimple_has_location (stmt2)) + loc = gimple_location (stmt2); + } + else if (CONVERT_EXPR_CODE_P (rhs_code)) + return false; + else if (rhs_code != BIT_NOT_EXPR) + op1 = gimple_assign_rhs2 (stmt); + + /* ~X is only equivalent to !X, if type-precision is one and X has + an integral type. */ + if (rhs_code == BIT_NOT_EXPR + && (!INTEGRAL_TYPE_P (TREE_TYPE (op0)) + || TYPE_PRECISION (TREE_TYPE (op0)) != 1)) + return false; + if (TYPE_PRECISION (TREE_TYPE (op0)) != 1) { if (TREE_CODE (op0) != SSA_NAME) @@ -6775,19 +6847,83 @@ simplify_truth_ops_using_ranges (gimple_ return false; } - if (rhs_code == BIT_NOT_EXPR && TYPE_PRECISION (TREE_TYPE (op0)) == 1) + need_conversion = + !useless_type_conversion_p (TREE_TYPE (gimple_assign_lhs (stmt)), + TREE_TYPE (op0)); + /* As comparisons X != 0 getting folded to (bool) X by VRP, + but X == 0 might be not folded for none boolean type of X + to (bool) (X ^ 1), we need to handle this case special + to simplify this. + For bitwise-binary operations we have three cases to handle: + a) ((bool) X) op ((bool) Y) + b) ((bool) X) op (Y == 0) -OR- (X == 0) op ((bool) Y) + c) (X == 0) op (Y == 0) + The later two cases can't be handled for now, as we would beed to + insert new statements. */ + if (need_conversion + && (rhs_code == BIT_XOR_EXPR + || rhs_code == BIT_AND_EXPR + || rhs_code == BIT_IOR_EXPR) + && TREE_CODE (op1) == SSA_NAME + && TREE_CODE (op0) == SSA_NAME) { - rhs_code = NE_EXPR; - op1 = build_int_cst (TREE_TYPE (op0), 1); + tree cop0 = ssa_name_get_cast_to_p (op0); + tree cop1 = ssa_name_get_cast_to_p (op1); + + /* We would need an new statment for cases b and c, and we can't + due vr table, so bail out. */ + if (!cop0 || !cop1) + return false; + + if (!INTEGRAL_TYPE_P (TREE_TYPE (cop0)) + || !types_compatible_p (TREE_TYPE (cop0), TREE_TYPE (cop1))) + return false; + + need_conversion = + !useless_type_conversion_p (TREE_TYPE (gimple_assign_lhs (stmt)), + TREE_TYPE (cop0)); + if (need_conversion) + return false; + + op0 = cop0; + op1 = cop1; + + /* We need to re-check if value ranges for new operands + for 1-bit precision/range. */ + if (TYPE_PRECISION (TREE_TYPE (op0)) != 1) + { + if (TREE_CODE (op0) != SSA_NAME) + return false; + vr = get_value_range (op0); + + val = compare_range_with_value (GE_EXPR, vr, integer_zero_node, &sop); + if (!val || !integer_onep (val)) + return false; + + val = compare_range_with_value (LE_EXPR, vr, integer_one_node, &sop); + if (!val || !integer_onep (val)) + return false; + } + + if (TYPE_PRECISION (TREE_TYPE (op1)) != 1) + { + vr = get_value_range (op1); + val = compare_range_with_value (GE_EXPR, vr, integer_zero_node, &sop); + if (!val || !integer_onep (val)) + return false; + + val = compare_range_with_value (LE_EXPR, vr, integer_one_node, &sop); + if (!val || !integer_onep (val)) + return false; + } } - else - { - op1 = gimple_assign_rhs2 (stmt); - /* Reduce number of cases to handle. */ + /* Reduce number of cases to handle. */ + if (op1 != NULL_TREE) + { if (is_gimple_min_invariant (op1)) { - /* Exclude anything that should have been already folded. */ + /* Exclude anything that should have been already folded. */ if (rhs_code != EQ_EXPR && rhs_code != NE_EXPR && rhs_code != BIT_XOR_EXPR) @@ -6818,32 +6954,34 @@ simplify_truth_ops_using_ranges (gimple_ vr = get_value_range (op1); val = compare_range_with_value (GE_EXPR, vr, integer_zero_node, &sop); if (!val || !integer_onep (val)) - return false; + return false; val = compare_range_with_value (LE_EXPR, vr, integer_one_node, &sop); if (!val || !integer_onep (val)) - return false; + return false; } } - } - if (sop && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC)) - { - location_t location; + if (sop && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC)) + { + location_t location; - if (!gimple_has_location (stmt)) - location = input_location; - else - location = gimple_location (stmt); + if (!gimple_has_location (stmt)) + location = input_location; + else + location = gimple_location (stmt); - warning_at (location, OPT_Wstrict_overflow, - _("assuming signed overflow does not occur when " - "simplifying ==, != or ! to identity or ^")); + warning_at (location, OPT_Wstrict_overflow, + _("assuming signed overflow does not occur when " + "simplifying ==, != or ! to identity or ^")); + } } - need_conversion = - !useless_type_conversion_p (TREE_TYPE (gimple_assign_lhs (stmt)), - TREE_TYPE (op0)); + if (rhs_code == BIT_NOT_EXPR) + { + rhs_code = NE_EXPR; + op1 = build_int_cst (TREE_TYPE (op0), 1); + } /* Make sure to not sign-extend -1 as a boolean value. */ if (need_conversion @@ -6863,6 +7001,7 @@ simplify_truth_ops_using_ranges (gimple_ gimple_assign_set_rhs_with_ops (gsi, need_conversion ? NOP_EXPR : SSA_NAME, op0, NULL); + gimple_set_location (stmt, loc); update_stmt (gsi_stmt (*gsi)); return true; } @@ -6873,10 +7012,20 @@ simplify_truth_ops_using_ranges (gimple_ gcc_unreachable (); } + /* We can't insert here new expression as otherwise + tracked vr tables getting out of bounds. */ if (need_conversion) return false; + /* Reduce here simple SSA_NAME assignments to other expressions. + This produces better results. */ + while ((val = ssa_name_get_inner_ssa_name_p (op0)) != NULL_TREE) + op0 = val; + while ((val = ssa_name_get_inner_ssa_name_p (op1)) != NULL_TREE) + op1 = val; + gimple_assign_set_rhs_with_ops (gsi, rhs_code, op0, op1); + gimple_set_location (stmt, loc); update_stmt (gsi_stmt (*gsi)); return true; } @@ -7455,7 +7604,11 @@ simplify_stmt_using_ranges (gimple_stmt_ CASE_CONVERT: if (TREE_CODE (rhs1) == SSA_NAME && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))) - return simplify_conversion_using_ranges (stmt); + { + if (simplify_truth_ops_using_ranges (gsi, stmt)) + return true; + return simplify_conversion_using_ranges (stmt); + } break; default: Index: gcc-head/gcc/testsuite/gcc.dg/tree-ssa/vrp47.c =================================================================== --- gcc-head.orig/gcc/testsuite/gcc.dg/tree-ssa/vrp47.c +++ gcc-head/gcc/testsuite/gcc.dg/tree-ssa/vrp47.c @@ -4,7 +4,7 @@ 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-vrp -fdump-tree-dom" } */ +/* { dg-options "-O2 -fdump-tree-vrp" } */ /* { dg-options "-O2 -fdump-tree-vrp -fdump-tree-dom -march=i586" { target { i?86-*-* && ilp32 } } } */