From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 108716 invoked by alias); 2 Apr 2015 09:16:39 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 108680 invoked by uid 89); 2 Apr 2015 09:16:37 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.3 required=5.0 tests=AWL,BAYES_00,KAM_ASCII_DIVIDERS,KAM_LAZY_DOMAIN_SECURITY,T_RP_MATCHES_RCVD autolearn=no version=3.3.2 X-HELO: mx2.suse.de Received: from cantor2.suse.de (HELO mx2.suse.de) (195.135.220.15) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (CAMELLIA256-SHA encrypted) ESMTPS; Thu, 02 Apr 2015 09:16:35 +0000 Received: from relay1.suse.de (charybdis-ext.suse.de [195.135.220.254]) by mx2.suse.de (Postfix) with ESMTP id 46C93AC41 for ; Thu, 2 Apr 2015 09:16:32 +0000 (UTC) Date: Thu, 02 Apr 2015 09:16:00 -0000 From: Richard Biener To: gcc-patches@gcc.gnu.org Subject: [PATCH] Fix PR65650 (1/n in merging CCP and copyprop) Message-ID: User-Agent: Alpine 2.11 (LSU 23 2013-08-11) MIME-Version: 1.0 Content-Type: TEXT/PLAIN; charset=US-ASCII X-SW-Source: 2015-04/txt/msg00048.txt.bz2 The following makes CCP track copies which avoids pass ordering issues between CCP and copyprop as seen from the testcase. Bootstrapped and tested on x86_64-unknown-linux-gnu, queued for stage1. For stage1 I'd like to get rid of copyprop completely, a 2nd patch in the series will remove the copyprop instances immediately preceeding/following CCP. CCP needs some TLC and I'm going to apply that during stage1. Thanks, Richard. 2015-04-02 Richard Biener PR tree-optimization/65650 * tree-ssa-ccp.c (valid_lattice_transition): Allow lattice transitions involving copies. (set_lattice_value): Adjust for copy lattice state. (ccp_lattice_meet): Do not merge UNDEFINED and a copy to the copy. (bit_value_unop): Adjust what we treat as varying mask. (bit_value_binop): Likewise. (bit_value_assume_aligned): Likewise. (evaluate_stmt): When we simplified to a SSA name record a copy instead of dropping to varying. (visit_assignment): Simplify. * gimple-match.h (gimple_simplify): Add another callback. * gimple-fold.c (fold_stmt_1): Adjust caller. (gimple_fold_stmt_to_constant_1): Likewise - pass valueize for the 2nd callback. * gimple-match-head.c (gimple_simplify): Add a callback that is used to valueize the stmt operands and use it that way. * gcc.dg/tree-ssa/ssa-ccp-36.c: New testcase. Index: gcc/tree-ssa-ccp.c =================================================================== *** gcc/tree-ssa-ccp.c.orig 2015-04-01 15:13:46.424457049 +0200 --- gcc/tree-ssa-ccp.c 2015-04-01 16:33:50.194715581 +0200 *************** valid_lattice_transition (ccp_prop_value *** 439,444 **** --- 439,455 ---- /* Now both lattice values are CONSTANT. */ + /* Allow arbitrary copy changes as we might look through PHI + when only a single copy edge is executable. */ + if (TREE_CODE (old_val.value) == SSA_NAME + && TREE_CODE (new_val.value) == SSA_NAME) + return true; + + /* Allow transitioning from a constant to a copy. */ + if (is_gimple_min_invariant (old_val.value) + && TREE_CODE (new_val.value) == SSA_NAME) + return true; + /* Allow transitioning from PHI <&x, not executable> == &x to PHI <&x, &y> == common alignment. */ if (TREE_CODE (old_val.value) != INTEGER_CST *************** set_lattice_value (tree var, ccp_prop_va *** 527,535 **** caller that this was a non-transition. */ if (old_val->lattice_val != new_val.lattice_val || (new_val.lattice_val == CONSTANT ! && TREE_CODE (new_val.value) == INTEGER_CST ! && (TREE_CODE (old_val->value) != INTEGER_CST ! || new_val.mask != old_val->mask))) { /* ??? We would like to delay creation of INTEGER_CSTs from partially constants here. */ --- 538,547 ---- caller that this was a non-transition. */ if (old_val->lattice_val != new_val.lattice_val || (new_val.lattice_val == CONSTANT ! && (TREE_CODE (new_val.value) != TREE_CODE (old_val->value) ! || simple_cst_equal (new_val.value, old_val->value) != 1 ! || (TREE_CODE (new_val.value) == INTEGER_CST ! && new_val.mask != old_val->mask)))) { /* ??? We would like to delay creation of INTEGER_CSTs from partially constants here. */ *************** ccp_finalize (void) *** 958,969 **** static void ccp_lattice_meet (ccp_prop_value_t *val1, ccp_prop_value_t *val2) { ! if (val1->lattice_val == UNDEFINED) { /* UNDEFINED M any = any */ *val1 = *val2; } ! else if (val2->lattice_val == UNDEFINED) { /* any M UNDEFINED = any Nothing to do. VAL1 already contains the value we want. */ --- 970,989 ---- static void ccp_lattice_meet (ccp_prop_value_t *val1, ccp_prop_value_t *val2) { ! if (val1->lattice_val == UNDEFINED ! /* For UNDEFINED M SSA we can't use SSA because its definition ! may not dominate the PHI node. */ ! && (val2->lattice_val != CONSTANT ! || TREE_CODE (val2->value) != SSA_NAME)) { /* UNDEFINED M any = any */ *val1 = *val2; } ! else if (val2->lattice_val == UNDEFINED ! /* For UNDEFINED M SSA we can't use SSA because its definition ! may not dominate the PHI node. */ ! && (val1->lattice_val != CONSTANT ! || TREE_CODE (val1->value) != SSA_NAME)) { /* any M UNDEFINED = any Nothing to do. VAL1 already contains the value we want. */ *************** bit_value_unop (enum tree_code code, tre *** 1513,1519 **** || rval.mask == -1); bit_value_unop_1 (code, type, &value, &mask, TREE_TYPE (rhs), value_to_wide_int (rval), rval.mask); ! if (mask != -1) { val.lattice_val = CONSTANT; val.mask = mask; --- 1533,1539 ---- || rval.mask == -1); bit_value_unop_1 (code, type, &value, &mask, TREE_TYPE (rhs), value_to_wide_int (rval), rval.mask); ! if (wi::sext (mask, TYPE_PRECISION (type)) != -1) { val.lattice_val = CONSTANT; val.mask = mask; *************** bit_value_binop (enum tree_code code, tr *** 1568,1574 **** bit_value_binop_1 (code, type, &value, &mask, TREE_TYPE (rhs1), value_to_wide_int (r1val), r1val.mask, TREE_TYPE (rhs2), value_to_wide_int (r2val), r2val.mask); ! if (mask != -1) { val.lattice_val = CONSTANT; val.mask = mask; --- 1588,1594 ---- bit_value_binop_1 (code, type, &value, &mask, TREE_TYPE (rhs1), value_to_wide_int (r1val), r1val.mask, TREE_TYPE (rhs2), value_to_wide_int (r2val), r2val.mask); ! if (wi::sext (mask, TYPE_PRECISION (type)) != -1) { val.lattice_val = CONSTANT; val.mask = mask; *************** bit_value_assume_aligned (gimple stmt, t *** 1669,1675 **** bit_value_binop_1 (BIT_AND_EXPR, type, &value, &mask, type, value_to_wide_int (ptrval), ptrval.mask, type, value_to_wide_int (alignval), alignval.mask); ! if (mask != -1) { val.lattice_val = CONSTANT; val.mask = mask; --- 1689,1695 ---- bit_value_binop_1 (BIT_AND_EXPR, type, &value, &mask, type, value_to_wide_int (ptrval), ptrval.mask, type, value_to_wide_int (alignval), alignval.mask); ! if (wi::sext (mask, TYPE_PRECISION (type)) != -1) { val.lattice_val = CONSTANT; val.mask = mask; *************** evaluate_stmt (gimple stmt) *** 1946,1960 **** if (likelyvalue == UNDEFINED) { val.lattice_val = likelyvalue; val.mask = 0; } else { val.lattice_val = VARYING; val.mask = -1; } - - val.value = NULL_TREE; } return val; --- 1966,1988 ---- if (likelyvalue == UNDEFINED) { val.lattice_val = likelyvalue; + val.value = NULL_TREE; val.mask = 0; } + /* The statement produced a copy. */ + else if (simplified && TREE_CODE (simplified) == SSA_NAME + && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (simplified)) + { + val.lattice_val = CONSTANT; + val.value = simplified; + val.mask = -1; + } else { val.lattice_val = VARYING; + val.value = NULL_TREE; val.mask = -1; } } return val; *************** static enum ssa_prop_result *** 2266,2292 **** visit_assignment (gimple stmt, tree *output_p) { ccp_prop_value_t val; ! enum ssa_prop_result retval; tree lhs = gimple_get_lhs (stmt); - - gcc_assert (gimple_code (stmt) != GIMPLE_CALL - || gimple_call_lhs (stmt) != NULL_TREE); - - if (gimple_assign_single_p (stmt) - && gimple_assign_rhs_code (stmt) == SSA_NAME) - /* For a simple copy operation, we copy the lattice values. */ - val = *get_value (gimple_assign_rhs1 (stmt)); - else - /* Evaluate the statement, which could be - either a GIMPLE_ASSIGN or a GIMPLE_CALL. */ - val = evaluate_stmt (stmt); - - retval = SSA_PROP_NOT_INTERESTING; - - /* Set the lattice value of the statement's output. */ if (TREE_CODE (lhs) == SSA_NAME) { /* If STMT is an assignment to an SSA_NAME, we only have one value to set. */ if (set_lattice_value (lhs, val)) --- 2294,2308 ---- visit_assignment (gimple stmt, tree *output_p) { ccp_prop_value_t val; ! enum ssa_prop_result retval = SSA_PROP_NOT_INTERESTING; tree lhs = gimple_get_lhs (stmt); if (TREE_CODE (lhs) == SSA_NAME) { + /* Evaluate the statement, which could be + either a GIMPLE_ASSIGN or a GIMPLE_CALL. */ + val = evaluate_stmt (stmt); + /* If STMT is an assignment to an SSA_NAME, we only have one value to set. */ if (set_lattice_value (lhs, val)) Index: gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-36.c =================================================================== *** /dev/null 1970-01-01 00:00:00.000000000 +0000 --- gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-36.c 2015-04-01 15:14:45.183125909 +0200 *************** *** 0 **** --- 1,14 ---- + /* { dg-do compile } */ + /* { dg-options "-O -fdump-tree-ccp1" } */ + + int foo (int i) + { + int j = i; + int k = 0; + int l = j + k; + int m = l - j; + return m; + } + + /* { dg-final { scan-tree-dump "return 0;" "ccp1" } } */ + /* { dg-final { cleanup-tree-dump "ccp1" } } */ Index: gcc/gimple-match.h =================================================================== *** gcc/gimple-match.h.orig 2015-01-08 13:25:14.965227263 +0100 --- gcc/gimple-match.h 2015-04-01 15:14:45.183125909 +0200 *************** private: *** 41,47 **** }; bool gimple_simplify (gimple, code_helper *, tree *, gimple_seq *, ! tree (*)(tree)); tree maybe_push_res_to_seq (code_helper, tree, tree *, gimple_seq *, tree res = NULL_TREE); void maybe_build_generic_op (enum tree_code, tree, tree *, tree, tree); --- 41,47 ---- }; bool gimple_simplify (gimple, code_helper *, tree *, gimple_seq *, ! tree (*)(tree), tree (*)(tree)); tree maybe_push_res_to_seq (code_helper, tree, tree *, gimple_seq *, tree res = NULL_TREE); void maybe_build_generic_op (enum tree_code, tree, tree *, tree, tree); Index: gcc/gimple-fold.c =================================================================== *** gcc/gimple-fold.c.orig 2015-03-19 13:22:12.073305248 +0100 --- gcc/gimple-fold.c 2015-04-01 15:14:45.184125920 +0200 *************** fold_stmt_1 (gimple_stmt_iterator *gsi, *** 3621,3627 **** gimple_seq seq = NULL; code_helper rcode; tree ops[3] = {}; ! if (gimple_simplify (stmt, &rcode, ops, inplace ? NULL : &seq, valueize)) { if (replace_stmt_with_simplification (gsi, rcode, ops, &seq, inplace)) changed = true; --- 3621,3628 ---- gimple_seq seq = NULL; code_helper rcode; tree ops[3] = {}; ! if (gimple_simplify (stmt, &rcode, ops, inplace ? NULL : &seq, ! valueize, valueize)) { if (replace_stmt_with_simplification (gsi, rcode, ops, &seq, inplace)) changed = true; *************** gimple_fold_stmt_to_constant_1 (gimple s *** 4928,4934 **** edges if there are intermediate VARYING defs. For this reason do not follow SSA edges here even though SCCVN can technically just deal fine with that. */ ! if (gimple_simplify (stmt, &rcode, ops, NULL, gvalueize) && rcode.is_tree_code () && (TREE_CODE_LENGTH ((tree_code) rcode) == 0 || ((tree_code) rcode) == ADDR_EXPR) --- 4929,4935 ---- edges if there are intermediate VARYING defs. For this reason do not follow SSA edges here even though SCCVN can technically just deal fine with that. */ ! if (gimple_simplify (stmt, &rcode, ops, NULL, gvalueize, valueize) && rcode.is_tree_code () && (TREE_CODE_LENGTH ((tree_code) rcode) == 0 || ((tree_code) rcode) == ADDR_EXPR) Index: gcc/gimple-match-head.c =================================================================== *** gcc/gimple-match-head.c.orig 2015-01-19 14:56:30.246131739 +0100 --- gcc/gimple-match-head.c 2015-04-01 15:14:45.184125920 +0200 *************** gimple_simplify (enum built_in_function *** 601,607 **** bool gimple_simplify (gimple stmt, code_helper *rcode, tree *ops, ! gimple_seq *seq, tree (*valueize)(tree)) { switch (gimple_code (stmt)) { --- 601,608 ---- bool gimple_simplify (gimple stmt, code_helper *rcode, tree *ops, ! gimple_seq *seq, ! tree (*valueize)(tree), tree (*top_valueize)(tree)) { switch (gimple_code (stmt)) { *************** gimple_simplify (gimple stmt, *** 617,625 **** || code == VIEW_CONVERT_EXPR) { tree op0 = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0); ! if (valueize && TREE_CODE (op0) == SSA_NAME) { ! tree tem = valueize (op0); if (tem) op0 = tem; } --- 618,626 ---- || code == VIEW_CONVERT_EXPR) { tree op0 = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0); ! if (top_valueize && TREE_CODE (op0) == SSA_NAME) { ! tree tem = top_valueize (op0); if (tem) op0 = tem; } *************** gimple_simplify (gimple stmt, *** 631,639 **** { tree rhs1 = gimple_assign_rhs1 (stmt); tree op0 = TREE_OPERAND (rhs1, 0); ! if (valueize && TREE_CODE (op0) == SSA_NAME) { ! tree tem = valueize (op0); if (tem) op0 = tem; } --- 632,640 ---- { tree rhs1 = gimple_assign_rhs1 (stmt); tree op0 = TREE_OPERAND (rhs1, 0); ! if (top_valueize && TREE_CODE (op0) == SSA_NAME) { ! tree tem = top_valueize (op0); if (tem) op0 = tem; } *************** gimple_simplify (gimple stmt, *** 644,653 **** return gimple_resimplify3 (seq, rcode, type, ops, valueize); } else if (code == SSA_NAME ! && valueize) { tree op0 = gimple_assign_rhs1 (stmt); ! tree valueized = valueize (op0); if (!valueized || op0 == valueized) return false; ops[0] = valueized; --- 645,654 ---- return gimple_resimplify3 (seq, rcode, type, ops, valueize); } else if (code == SSA_NAME ! && top_valueize) { tree op0 = gimple_assign_rhs1 (stmt); ! tree valueized = top_valueize (op0); if (!valueized || op0 == valueized) return false; ops[0] = valueized; *************** gimple_simplify (gimple stmt, *** 658,666 **** case GIMPLE_UNARY_RHS: { tree rhs1 = gimple_assign_rhs1 (stmt); ! if (valueize && TREE_CODE (rhs1) == SSA_NAME) { ! tree tem = valueize (rhs1); if (tem) rhs1 = tem; } --- 659,667 ---- case GIMPLE_UNARY_RHS: { tree rhs1 = gimple_assign_rhs1 (stmt); ! if (top_valueize && TREE_CODE (rhs1) == SSA_NAME) { ! tree tem = top_valueize (rhs1); if (tem) rhs1 = tem; } *************** gimple_simplify (gimple stmt, *** 671,686 **** case GIMPLE_BINARY_RHS: { tree rhs1 = gimple_assign_rhs1 (stmt); ! if (valueize && TREE_CODE (rhs1) == SSA_NAME) { ! tree tem = valueize (rhs1); if (tem) rhs1 = tem; } tree rhs2 = gimple_assign_rhs2 (stmt); ! if (valueize && TREE_CODE (rhs2) == SSA_NAME) { ! tree tem = valueize (rhs2); if (tem) rhs2 = tem; } --- 672,687 ---- case GIMPLE_BINARY_RHS: { tree rhs1 = gimple_assign_rhs1 (stmt); ! if (top_valueize && TREE_CODE (rhs1) == SSA_NAME) { ! tree tem = top_valueize (rhs1); if (tem) rhs1 = tem; } tree rhs2 = gimple_assign_rhs2 (stmt); ! if (top_valueize && TREE_CODE (rhs2) == SSA_NAME) { ! tree tem = top_valueize (rhs2); if (tem) rhs2 = tem; } *************** gimple_simplify (gimple stmt, *** 692,714 **** case GIMPLE_TERNARY_RHS: { tree rhs1 = gimple_assign_rhs1 (stmt); ! if (valueize && TREE_CODE (rhs1) == SSA_NAME) { ! tree tem = valueize (rhs1); if (tem) rhs1 = tem; } tree rhs2 = gimple_assign_rhs2 (stmt); ! if (valueize && TREE_CODE (rhs2) == SSA_NAME) { ! tree tem = valueize (rhs2); if (tem) rhs2 = tem; } tree rhs3 = gimple_assign_rhs3 (stmt); ! if (valueize && TREE_CODE (rhs3) == SSA_NAME) { ! tree tem = valueize (rhs3); if (tem) rhs3 = tem; } --- 693,715 ---- case GIMPLE_TERNARY_RHS: { tree rhs1 = gimple_assign_rhs1 (stmt); ! if (top_valueize && TREE_CODE (rhs1) == SSA_NAME) { ! tree tem = top_valueize (rhs1); if (tem) rhs1 = tem; } tree rhs2 = gimple_assign_rhs2 (stmt); ! if (top_valueize && TREE_CODE (rhs2) == SSA_NAME) { ! tree tem = top_valueize (rhs2); if (tem) rhs2 = tem; } tree rhs3 = gimple_assign_rhs3 (stmt); ! if (top_valueize && TREE_CODE (rhs3) == SSA_NAME) { ! tree tem = top_valueize (rhs3); if (tem) rhs3 = tem; } *************** gimple_simplify (gimple stmt, *** 732,740 **** /* ??? Internal function support missing. */ if (!fn) return false; ! if (valueize && TREE_CODE (fn) == SSA_NAME) { ! tree tem = valueize (fn); if (tem) fn = tem; } --- 733,741 ---- /* ??? Internal function support missing. */ if (!fn) return false; ! if (top_valueize && TREE_CODE (fn) == SSA_NAME) { ! tree tem = top_valueize (fn); if (tem) fn = tem; } *************** gimple_simplify (gimple stmt, *** 754,762 **** case 1: { tree arg1 = gimple_call_arg (stmt, 0); ! if (valueize && TREE_CODE (arg1) == SSA_NAME) { ! tree tem = valueize (arg1); if (tem) arg1 = tem; } --- 755,763 ---- case 1: { tree arg1 = gimple_call_arg (stmt, 0); ! if (top_valueize && TREE_CODE (arg1) == SSA_NAME) { ! tree tem = top_valueize (arg1); if (tem) arg1 = tem; } *************** gimple_simplify (gimple stmt, *** 767,782 **** case 2: { tree arg1 = gimple_call_arg (stmt, 0); ! if (valueize && TREE_CODE (arg1) == SSA_NAME) { ! tree tem = valueize (arg1); if (tem) arg1 = tem; } tree arg2 = gimple_call_arg (stmt, 1); ! if (valueize && TREE_CODE (arg2) == SSA_NAME) { ! tree tem = valueize (arg2); if (tem) arg2 = tem; } --- 768,783 ---- case 2: { tree arg1 = gimple_call_arg (stmt, 0); ! if (top_valueize && TREE_CODE (arg1) == SSA_NAME) { ! tree tem = top_valueize (arg1); if (tem) arg1 = tem; } tree arg2 = gimple_call_arg (stmt, 1); ! if (top_valueize && TREE_CODE (arg2) == SSA_NAME) { ! tree tem = top_valueize (arg2); if (tem) arg2 = tem; } *************** gimple_simplify (gimple stmt, *** 788,810 **** case 3: { tree arg1 = gimple_call_arg (stmt, 0); ! if (valueize && TREE_CODE (arg1) == SSA_NAME) { ! tree tem = valueize (arg1); if (tem) arg1 = tem; } tree arg2 = gimple_call_arg (stmt, 1); ! if (valueize && TREE_CODE (arg2) == SSA_NAME) { ! tree tem = valueize (arg2); if (tem) arg2 = tem; } tree arg3 = gimple_call_arg (stmt, 2); ! if (valueize && TREE_CODE (arg3) == SSA_NAME) { ! tree tem = valueize (arg3); if (tem) arg3 = tem; } --- 789,811 ---- case 3: { tree arg1 = gimple_call_arg (stmt, 0); ! if (top_valueize && TREE_CODE (arg1) == SSA_NAME) { ! tree tem = top_valueize (arg1); if (tem) arg1 = tem; } tree arg2 = gimple_call_arg (stmt, 1); ! if (top_valueize && TREE_CODE (arg2) == SSA_NAME) { ! tree tem = top_valueize (arg2); if (tem) arg2 = tem; } tree arg3 = gimple_call_arg (stmt, 2); ! if (top_valueize && TREE_CODE (arg3) == SSA_NAME) { ! tree tem = top_valueize (arg3); if (tem) arg3 = tem; } *************** gimple_simplify (gimple stmt, *** 823,838 **** case GIMPLE_COND: { tree lhs = gimple_cond_lhs (stmt); ! if (valueize && TREE_CODE (lhs) == SSA_NAME) { ! tree tem = valueize (lhs); if (tem) lhs = tem; } tree rhs = gimple_cond_rhs (stmt); ! if (valueize && TREE_CODE (rhs) == SSA_NAME) { ! tree tem = valueize (rhs); if (tem) rhs = tem; } --- 824,839 ---- case GIMPLE_COND: { tree lhs = gimple_cond_lhs (stmt); ! if (top_valueize && TREE_CODE (lhs) == SSA_NAME) { ! tree tem = top_valueize (lhs); if (tem) lhs = tem; } tree rhs = gimple_cond_rhs (stmt); ! if (top_valueize && TREE_CODE (rhs) == SSA_NAME) { ! tree tem = top_valueize (rhs); if (tem) rhs = tem; }