Mercurial > hg > CbC > CbC_gcc
view gcc/tree-ssa-forwprop.c @ 88:f214c1d5b862
merge 89
| author | Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp> |
|---|---|
| date | Tue, 20 Dec 2011 18:53:46 +0900 |
| parents | f6334be47118 |
| children | 04ced10e8804 |
line wrap: on
line source
/* Forward propagation of expressions for single use variables. Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see <http://www.gnu.org/licenses/>. */ #include "config.h" #include "system.h" #include "coretypes.h" #include "tm.h" #include "tree.h" #include "tm_p.h" #include "basic-block.h" #include "timevar.h" #include "tree-pretty-print.h" #include "tree-flow.h" #include "tree-pass.h" #include "tree-dump.h" #include "langhooks.h" #include "flags.h" #include "gimple.h" #include "expr.h" /* This pass propagates the RHS of assignment statements into use sites of the LHS of the assignment. It's basically a specialized form of tree combination. It is hoped all of this can disappear when we have a generalized tree combiner. One class of common cases we handle is forward propagating a single use variable into a COND_EXPR. bb0: x = a COND b; if (x) goto ... else goto ... Will be transformed into: bb0: if (a COND b) goto ... else goto ... Similarly for the tests (x == 0), (x != 0), (x == 1) and (x != 1). Or (assuming c1 and c2 are constants): bb0: x = a + c1; if (x EQ/NEQ c2) goto ... else goto ... Will be transformed into: bb0: if (a EQ/NEQ (c2 - c1)) goto ... else goto ... Similarly for x = a - c1. Or bb0: x = !a if (x) goto ... else goto ... Will be transformed into: bb0: if (a == 0) goto ... else goto ... Similarly for the tests (x == 0), (x != 0), (x == 1) and (x != 1). For these cases, we propagate A into all, possibly more than one, COND_EXPRs that use X. Or bb0: x = (typecast) a if (x) goto ... else goto ... Will be transformed into: bb0: if (a != 0) goto ... else goto ... (Assuming a is an integral type and x is a boolean or x is an integral and a is a boolean.) Similarly for the tests (x == 0), (x != 0), (x == 1) and (x != 1). For these cases, we propagate A into all, possibly more than one, COND_EXPRs that use X. In addition to eliminating the variable and the statement which assigns a value to the variable, we may be able to later thread the jump without adding insane complexity in the dominator optimizer. Also note these transformations can cascade. We handle this by having a worklist of COND_EXPR statements to examine. As we make a change to a statement, we put it back on the worklist to examine on the next iteration of the main loop. A second class of propagation opportunities arises for ADDR_EXPR nodes. ptr = &x->y->z; res = *ptr; Will get turned into res = x->y->z; Or ptr = (type1*)&type2var; res = *ptr Will get turned into (if type1 and type2 are the same size and neither have volatile on them): res = VIEW_CONVERT_EXPR<type1>(type2var) Or ptr = &x[0]; ptr2 = ptr + <constant>; Will get turned into ptr2 = &x[constant/elementsize]; Or ptr = &x[0]; offset = index * element_size; offset_p = (pointer) offset; ptr2 = ptr + offset_p Will get turned into: ptr2 = &x[index]; Or ssa = (int) decl res = ssa & 1 Provided that decl has known alignment >= 2, will get turned into res = 0 We also propagate casts into SWITCH_EXPR and COND_EXPR conditions to allow us to remove the cast and {NOT_EXPR,NEG_EXPR} into a subsequent {NOT_EXPR,NEG_EXPR}. This will (of course) be extended as other needs arise. */ static bool forward_propagate_addr_expr (tree name, tree rhs); /* Set to true if we delete EH edges during the optimization. */ static bool cfg_changed; static tree rhs_to_tree (tree type, gimple stmt); /* Get the next statement we can propagate NAME's value into skipping trivial copies. Returns the statement that is suitable as a propagation destination or NULL_TREE if there is no such one. This only returns destinations in a single-use chain. FINAL_NAME_P if non-NULL is written to the ssa name that represents the use. */ static gimple get_prop_dest_stmt (tree name, tree *final_name_p) { use_operand_p use; gimple use_stmt; do { /* If name has multiple uses, bail out. */ if (!single_imm_use (name, &use, &use_stmt)) return NULL; /* If this is not a trivial copy, we found it. */ if (!gimple_assign_ssa_name_copy_p (use_stmt) || gimple_assign_rhs1 (use_stmt) != name) break; /* Continue searching uses of the copy destination. */ name = gimple_assign_lhs (use_stmt); } while (1); if (final_name_p) *final_name_p = name; return use_stmt; } /* Get the statement we can propagate from into NAME skipping trivial copies. Returns the statement which defines the propagation source or NULL_TREE if there is no such one. If SINGLE_USE_ONLY is set considers only sources which have a single use chain up to NAME. If SINGLE_USE_P is non-null, it is set to whether the chain to NAME is a single use chain or not. SINGLE_USE_P is not written to if SINGLE_USE_ONLY is set. */ static gimple get_prop_source_stmt (tree name, bool single_use_only, bool *single_use_p) { bool single_use = true; do { gimple def_stmt = SSA_NAME_DEF_STMT (name); if (!has_single_use (name)) { single_use = false; if (single_use_only) return NULL; } /* If name is defined by a PHI node or is the default def, bail out. */ if (!is_gimple_assign (def_stmt)) return NULL; /* If def_stmt is not a simple copy, we possibly found it. */ if (!gimple_assign_ssa_name_copy_p (def_stmt)) { tree rhs; if (!single_use_only && single_use_p) *single_use_p = single_use; /* We can look through pointer conversions in the search for a useful stmt for the comparison folding. */ rhs = gimple_assign_rhs1 (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))) name = rhs; else return def_stmt; } else { /* Continue searching the def of the copy source name. */ name = gimple_assign_rhs1 (def_stmt); } } while (1); } /* Checks if the destination ssa name in DEF_STMT can be used as propagation source. Returns true if so, otherwise false. */ static bool can_propagate_from (gimple def_stmt) { use_operand_p use_p; ssa_op_iter iter; gcc_assert (is_gimple_assign (def_stmt)); /* If the rhs has side-effects we cannot propagate from it. */ if (gimple_has_volatile_ops (def_stmt)) return false; /* If the rhs is a load we cannot propagate from it. */ if (TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt)) == tcc_reference || TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt)) == tcc_declaration) return false; /* Constants can be always propagated. */ if (gimple_assign_single_p (def_stmt) && is_gimple_min_invariant (gimple_assign_rhs1 (def_stmt))) return true; /* We cannot propagate ssa names that occur in abnormal phi nodes. */ FOR_EACH_SSA_USE_OPERAND (use_p, def_stmt, iter, SSA_OP_USE) if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (use_p))) return false; /* If the definition is a conversion of a pointer to a function type, then we can not apply optimizations as some targets require function pointers to be canonicalized and in this case this optimization could eliminate a necessary canonicalization. */ if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt))) { tree rhs = gimple_assign_rhs1 (def_stmt); if (POINTER_TYPE_P (TREE_TYPE (rhs)) && TREE_CODE (TREE_TYPE (TREE_TYPE (rhs))) == FUNCTION_TYPE) return false; } return true; } /* Remove a copy chain ending in NAME along the defs. If NAME was replaced in its only use then this function can be used to clean up dead stmts. Returns true if cleanup-cfg has to run. */ static bool remove_prop_source_from_use (tree name) { gimple_stmt_iterator gsi; gimple stmt; bool cfg_changed = false; do { basic_block bb; if (!has_zero_uses (name)) return cfg_changed; stmt = SSA_NAME_DEF_STMT (name); gsi = gsi_for_stmt (stmt); bb = gimple_bb (stmt); release_defs (stmt); gsi_remove (&gsi, true); cfg_changed |= gimple_purge_dead_eh_edges (bb); name = (gimple_assign_copy_p (stmt)) ? gimple_assign_rhs1 (stmt) : NULL; } while (name && TREE_CODE (name) == SSA_NAME); return cfg_changed; } /* Return the rhs of a gimple_assign STMT in a form of a single tree, converted to type TYPE. This should disappear, but is needed so we can combine expressions and use the fold() interfaces. Long term, we need to develop folding and combine routines that deal with gimple exclusively . */ static tree rhs_to_tree (tree type, gimple stmt) { location_t loc = gimple_location (stmt); enum tree_code code = gimple_assign_rhs_code (stmt); if (get_gimple_rhs_class (code) == GIMPLE_TERNARY_RHS) return fold_build3_loc (loc, code, type, gimple_assign_rhs1 (stmt), gimple_assign_rhs2 (stmt), gimple_assign_rhs3 (stmt)); else if (get_gimple_rhs_class (code) == GIMPLE_BINARY_RHS) return fold_build2_loc (loc, code, type, gimple_assign_rhs1 (stmt), gimple_assign_rhs2 (stmt)); else if (get_gimple_rhs_class (code) == GIMPLE_UNARY_RHS) return build1 (code, type, gimple_assign_rhs1 (stmt)); else if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS) return gimple_assign_rhs1 (stmt); else gcc_unreachable (); } /* Combine OP0 CODE OP1 in the context of a COND_EXPR. Returns the folded result in a form suitable for COND_EXPR_COND or NULL_TREE, if there is no suitable simplified form. If INVARIANT_ONLY is true only gimple_min_invariant results are considered simplified. */ static tree combine_cond_expr_cond (location_t loc, enum tree_code code, tree type, tree op0, tree op1, bool invariant_only) { tree t; gcc_assert (TREE_CODE_CLASS (code) == tcc_comparison); t = fold_binary_loc (loc, code, type, op0, op1); if (!t) return NULL_TREE; /* Require that we got a boolean type out if we put one in. */ gcc_assert (TREE_CODE (TREE_TYPE (t)) == TREE_CODE (type)); /* Canonicalize the combined condition for use in a COND_EXPR. */ t = canonicalize_cond_expr_cond (t); /* Bail out if we required an invariant but didn't get one. */ if (!t || (invariant_only && !is_gimple_min_invariant (t))) return NULL_TREE; return t; } /* Propagate from the ssa name definition statements of COND_EXPR in GIMPLE_COND statement STMT into the conditional if that simplifies it. Returns zero if no statement was changed, one if there were changes and two if cfg_cleanup needs to run. This must be kept in sync with forward_propagate_into_cond. */ static int forward_propagate_into_gimple_cond (gimple stmt) { int did_something = 0; location_t loc = gimple_location (stmt); do { tree tmp = NULL_TREE; tree name = NULL_TREE, rhs0 = NULL_TREE, rhs1 = NULL_TREE; gimple def_stmt; bool single_use0_p = false, single_use1_p = false; enum tree_code code = gimple_cond_code (stmt); /* We can do tree combining on SSA_NAME and comparison expressions. */ if (TREE_CODE_CLASS (gimple_cond_code (stmt)) == tcc_comparison) { /* For comparisons use the first operand, that is likely to simplify comparisons against constants. */ if (TREE_CODE (gimple_cond_lhs (stmt)) == SSA_NAME) { name = gimple_cond_lhs (stmt); def_stmt = get_prop_source_stmt (name, false, &single_use0_p); if (def_stmt && can_propagate_from (def_stmt)) { tree op1 = gimple_cond_rhs (stmt); rhs0 = rhs_to_tree (TREE_TYPE (op1), def_stmt); tmp = combine_cond_expr_cond (loc, code, boolean_type_node, rhs0, op1, !single_use0_p); } } /* If that wasn't successful, try the second operand. */ if (tmp == NULL_TREE && TREE_CODE (gimple_cond_rhs (stmt)) == SSA_NAME) { tree op0 = gimple_cond_lhs (stmt); name = gimple_cond_rhs (stmt); def_stmt = get_prop_source_stmt (name, false, &single_use1_p); if (!def_stmt || !can_propagate_from (def_stmt)) return did_something; rhs1 = rhs_to_tree (TREE_TYPE (op0), def_stmt); tmp = combine_cond_expr_cond (loc, code, boolean_type_node, op0, rhs1, !single_use1_p); } /* If that wasn't successful either, try both operands. */ if (tmp == NULL_TREE && rhs0 != NULL_TREE && rhs1 != NULL_TREE) tmp = combine_cond_expr_cond (loc, code, boolean_type_node, rhs0, fold_convert_loc (loc, TREE_TYPE (rhs0), rhs1), !(single_use0_p && single_use1_p)); } if (tmp) { if (dump_file && tmp) { tree cond = build2 (gimple_cond_code (stmt), boolean_type_node, gimple_cond_lhs (stmt), gimple_cond_rhs (stmt)); fprintf (dump_file, " Replaced '"); print_generic_expr (dump_file, cond, 0); fprintf (dump_file, "' with '"); print_generic_expr (dump_file, tmp, 0); fprintf (dump_file, "'\n"); } gimple_cond_set_condition_from_tree (stmt, unshare_expr (tmp)); update_stmt (stmt); /* Remove defining statements. */ if (remove_prop_source_from_use (name) || is_gimple_min_invariant (tmp)) did_something = 2; else if (did_something == 0) did_something = 1; /* Continue combining. */ continue; } break; } while (1); return did_something; } /* Propagate from the ssa name definition statements of COND_EXPR in the rhs of statement STMT into the conditional if that simplifies it. Returns zero if no statement was changed, one if there were changes and two if cfg_cleanup needs to run. This must be kept in sync with forward_propagate_into_gimple_cond. */ static int forward_propagate_into_cond (gimple_stmt_iterator *gsi_p) { gimple stmt = gsi_stmt (*gsi_p); location_t loc = gimple_location (stmt); int did_something = 0; do { tree tmp = NULL_TREE; tree cond = gimple_assign_rhs1 (stmt); tree name, rhs0 = NULL_TREE, rhs1 = NULL_TREE; gimple def_stmt; bool single_use0_p = false, single_use1_p = false; /* We can do tree combining on SSA_NAME and comparison expressions. */ if (COMPARISON_CLASS_P (cond) && TREE_CODE (TREE_OPERAND (cond, 0)) == SSA_NAME) { /* For comparisons use the first operand, that is likely to simplify comparisons against constants. */ name = TREE_OPERAND (cond, 0); def_stmt = get_prop_source_stmt (name, false, &single_use0_p); if (def_stmt && can_propagate_from (def_stmt)) { tree op1 = TREE_OPERAND (cond, 1); rhs0 = rhs_to_tree (TREE_TYPE (op1), def_stmt); tmp = combine_cond_expr_cond (loc, TREE_CODE (cond), boolean_type_node, rhs0, op1, !single_use0_p); } /* If that wasn't successful, try the second operand. */ if (tmp == NULL_TREE && TREE_CODE (TREE_OPERAND (cond, 1)) == SSA_NAME) { tree op0 = TREE_OPERAND (cond, 0); name = TREE_OPERAND (cond, 1); def_stmt = get_prop_source_stmt (name, false, &single_use1_p); if (!def_stmt || !can_propagate_from (def_stmt)) return did_something; rhs1 = rhs_to_tree (TREE_TYPE (op0), def_stmt); tmp = combine_cond_expr_cond (loc, TREE_CODE (cond), boolean_type_node, op0, rhs1, !single_use1_p); } /* If that wasn't successful either, try both operands. */ if (tmp == NULL_TREE && rhs0 != NULL_TREE && rhs1 != NULL_TREE) tmp = combine_cond_expr_cond (loc, TREE_CODE (cond), boolean_type_node, rhs0, fold_convert_loc (loc, TREE_TYPE (rhs0), rhs1), !(single_use0_p && single_use1_p)); } else if (TREE_CODE (cond) == SSA_NAME) { name = cond; def_stmt = get_prop_source_stmt (name, true, NULL); if (def_stmt || !can_propagate_from (def_stmt)) return did_something; rhs0 = gimple_assign_rhs1 (def_stmt); tmp = combine_cond_expr_cond (loc, NE_EXPR, boolean_type_node, rhs0, build_int_cst (TREE_TYPE (rhs0), 0), false); } if (tmp) { if (dump_file && tmp) { fprintf (dump_file, " Replaced '"); print_generic_expr (dump_file, cond, 0); fprintf (dump_file, "' with '"); print_generic_expr (dump_file, tmp, 0); fprintf (dump_file, "'\n"); } gimple_assign_set_rhs_from_tree (gsi_p, unshare_expr (tmp)); stmt = gsi_stmt (*gsi_p); update_stmt (stmt); /* Remove defining statements. */ if (remove_prop_source_from_use (name) || is_gimple_min_invariant (tmp)) did_something = 2; else if (did_something == 0) did_something = 1; /* Continue combining. */ continue; } break; } while (1); return did_something; } /* We've just substituted an ADDR_EXPR into stmt. Update all the relevant data structures to match. */ static void tidy_after_forward_propagate_addr (gimple stmt) { /* We may have turned a trapping insn into a non-trapping insn. */ if (maybe_clean_or_replace_eh_stmt (stmt, stmt) && gimple_purge_dead_eh_edges (gimple_bb (stmt))) cfg_changed = true; if (TREE_CODE (gimple_assign_rhs1 (stmt)) == ADDR_EXPR) recompute_tree_invariant_for_addr_expr (gimple_assign_rhs1 (stmt)); } /* DEF_RHS contains the address of the 0th element in an array. USE_STMT uses type of DEF_RHS to compute the address of an arbitrary element within the array. The (variable) byte offset of the element is contained in OFFSET. We walk back through the use-def chains of OFFSET to verify that it is indeed computing the offset of an element within the array and extract the index corresponding to the given byte offset. We then try to fold the entire address expression into a form &array[index]. If we are successful, we replace the right hand side of USE_STMT with the new address computation. */ static bool forward_propagate_addr_into_variable_array_index (tree offset, tree def_rhs, gimple_stmt_iterator *use_stmt_gsi) { tree index, tunit; gimple offset_def, use_stmt = gsi_stmt (*use_stmt_gsi); tree new_rhs, tmp; if (TREE_CODE (TREE_OPERAND (def_rhs, 0)) == ARRAY_REF) tunit = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (def_rhs))); else if (TREE_CODE (TREE_TYPE (TREE_OPERAND (def_rhs, 0))) == ARRAY_TYPE) tunit = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (TREE_TYPE (def_rhs)))); else return false; if (!host_integerp (tunit, 1)) return false; /* Get the offset's defining statement. */ offset_def = SSA_NAME_DEF_STMT (offset); /* Try to find an expression for a proper index. This is either a multiplication expression by the element size or just the ssa name we came along in case the element size is one. In that case, however, we do not allow multiplications because they can be computing index to a higher level dimension (PR 37861). */ if (integer_onep (tunit)) { if (is_gimple_assign (offset_def) && gimple_assign_rhs_code (offset_def) == MULT_EXPR) return false; index = offset; } else { /* The statement which defines OFFSET before type conversion must be a simple GIMPLE_ASSIGN. */ if (!is_gimple_assign (offset_def)) return false; /* The RHS of the statement which defines OFFSET must be a multiplication of an object by the size of the array elements. This implicitly verifies that the size of the array elements is constant. */ if (gimple_assign_rhs_code (offset_def) == MULT_EXPR && TREE_CODE (gimple_assign_rhs2 (offset_def)) == INTEGER_CST && tree_int_cst_equal (gimple_assign_rhs2 (offset_def), tunit)) { /* The first operand to the MULT_EXPR is the desired index. */ index = gimple_assign_rhs1 (offset_def); } /* If we have idx * tunit + CST * tunit re-associate that. */ else if ((gimple_assign_rhs_code (offset_def) == PLUS_EXPR || gimple_assign_rhs_code (offset_def) == MINUS_EXPR) && TREE_CODE (gimple_assign_rhs1 (offset_def)) == SSA_NAME && TREE_CODE (gimple_assign_rhs2 (offset_def)) == INTEGER_CST && (tmp = div_if_zero_remainder (EXACT_DIV_EXPR, gimple_assign_rhs2 (offset_def), tunit)) != NULL_TREE) { gimple offset_def2 = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (offset_def)); if (is_gimple_assign (offset_def2) && gimple_assign_rhs_code (offset_def2) == MULT_EXPR && TREE_CODE (gimple_assign_rhs2 (offset_def2)) == INTEGER_CST && tree_int_cst_equal (gimple_assign_rhs2 (offset_def2), tunit)) { index = fold_build2 (gimple_assign_rhs_code (offset_def), TREE_TYPE (offset), gimple_assign_rhs1 (offset_def2), tmp); } else return false; } else return false; } /* Replace the pointer addition with array indexing. */ index = force_gimple_operand_gsi (use_stmt_gsi, index, true, NULL_TREE, true, GSI_SAME_STMT); if (TREE_CODE (TREE_OPERAND (def_rhs, 0)) == ARRAY_REF) { new_rhs = unshare_expr (def_rhs); TREE_OPERAND (TREE_OPERAND (new_rhs, 0), 1) = index; } else { new_rhs = build4 (ARRAY_REF, TREE_TYPE (TREE_TYPE (TREE_TYPE (def_rhs))), unshare_expr (TREE_OPERAND (def_rhs, 0)), index, integer_zero_node, NULL_TREE); new_rhs = build_fold_addr_expr (new_rhs); if (!useless_type_conversion_p (TREE_TYPE (gimple_assign_lhs (use_stmt)), TREE_TYPE (new_rhs))) { new_rhs = force_gimple_operand_gsi (use_stmt_gsi, new_rhs, true, NULL_TREE, true, GSI_SAME_STMT); new_rhs = fold_convert (TREE_TYPE (gimple_assign_lhs (use_stmt)), new_rhs); } } gimple_assign_set_rhs_from_tree (use_stmt_gsi, new_rhs); use_stmt = gsi_stmt (*use_stmt_gsi); /* That should have created gimple, so there is no need to record information to undo the propagation. */ fold_stmt_inplace (use_stmt); tidy_after_forward_propagate_addr (use_stmt); return true; } /* NAME is a SSA_NAME representing DEF_RHS which is of the form ADDR_EXPR <whatever>. Try to forward propagate the ADDR_EXPR into the use USE_STMT. Often this will allow for removal of an ADDR_EXPR and INDIRECT_REF node or for recovery of array indexing from pointer arithmetic. Return true if the propagation was successful (the propagation can be not totally successful, yet things may have been changed). */ static bool forward_propagate_addr_expr_1 (tree name, tree def_rhs, gimple_stmt_iterator *use_stmt_gsi, bool single_use_p) { tree lhs, rhs, rhs2, array_ref; gimple use_stmt = gsi_stmt (*use_stmt_gsi); enum tree_code rhs_code; bool res = true; gcc_assert (TREE_CODE (def_rhs) == ADDR_EXPR); lhs = gimple_assign_lhs (use_stmt); rhs_code = gimple_assign_rhs_code (use_stmt); rhs = gimple_assign_rhs1 (use_stmt); /* Trivial cases. The use statement could be a trivial copy or a useless conversion. Recurse to the uses of the lhs as copyprop does not copy through different variant pointers and FRE does not catch all useless conversions. Treat the case of a single-use name and a conversion to def_rhs type separate, though. */ if (TREE_CODE (lhs) == SSA_NAME && ((rhs_code == SSA_NAME && rhs == name) || CONVERT_EXPR_CODE_P (rhs_code))) { /* Only recurse if we don't deal with a single use or we cannot do the propagation to the current statement. In particular we can end up with a conversion needed for a non-invariant address which we cannot do in a single statement. */ if (!single_use_p || (!useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (def_rhs)) && (!is_gimple_min_invariant (def_rhs) || (INTEGRAL_TYPE_P (TREE_TYPE (lhs)) && POINTER_TYPE_P (TREE_TYPE (def_rhs)) && (TYPE_PRECISION (TREE_TYPE (lhs)) > TYPE_PRECISION (TREE_TYPE (def_rhs))))))) return forward_propagate_addr_expr (lhs, def_rhs); gimple_assign_set_rhs1 (use_stmt, unshare_expr (def_rhs)); if (useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (def_rhs))) gimple_assign_set_rhs_code (use_stmt, TREE_CODE (def_rhs)); else gimple_assign_set_rhs_code (use_stmt, NOP_EXPR); return true; } /* Propagate through constant pointer adjustments. */ if (TREE_CODE (lhs) == SSA_NAME && rhs_code == POINTER_PLUS_EXPR && rhs == name && TREE_CODE (gimple_assign_rhs2 (use_stmt)) == INTEGER_CST) { tree new_def_rhs; /* As we come here with non-invariant addresses in def_rhs we need to make sure we can build a valid constant offsetted address for further propagation. Simply rely on fold building that and check after the fact. */ new_def_rhs = fold_build2 (MEM_REF, TREE_TYPE (TREE_TYPE (rhs)), def_rhs, fold_convert (ptr_type_node, gimple_assign_rhs2 (use_stmt))); if (TREE_CODE (new_def_rhs) == MEM_REF && !is_gimple_mem_ref_addr (TREE_OPERAND (new_def_rhs, 0))) return false; new_def_rhs = build_fold_addr_expr_with_type (new_def_rhs, TREE_TYPE (rhs)); /* Recurse. If we could propagate into all uses of lhs do not bother to replace into the current use but just pretend we did. */ if (TREE_CODE (new_def_rhs) == ADDR_EXPR && forward_propagate_addr_expr (lhs, new_def_rhs)) return true; if (useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (new_def_rhs))) gimple_assign_set_rhs_with_ops (use_stmt_gsi, TREE_CODE (new_def_rhs), new_def_rhs, NULL_TREE); else if (is_gimple_min_invariant (new_def_rhs)) gimple_assign_set_rhs_with_ops (use_stmt_gsi, NOP_EXPR, new_def_rhs, NULL_TREE); else return false; gcc_assert (gsi_stmt (*use_stmt_gsi) == use_stmt); update_stmt (use_stmt); return true; } /* Now strip away any outer COMPONENT_REF/ARRAY_REF nodes from the LHS. ADDR_EXPR will not appear on the LHS. */ lhs = gimple_assign_lhs (use_stmt); while (handled_component_p (lhs)) lhs = TREE_OPERAND (lhs, 0); /* Now see if the LHS node is a MEM_REF using NAME. If so, propagate the ADDR_EXPR into the use of NAME and fold the result. */ if (TREE_CODE (lhs) == MEM_REF && TREE_OPERAND (lhs, 0) == name) { tree def_rhs_base; HOST_WIDE_INT def_rhs_offset; /* If the address is invariant we can always fold it. */ if ((def_rhs_base = get_addr_base_and_unit_offset (TREE_OPERAND (def_rhs, 0), &def_rhs_offset))) { double_int off = mem_ref_offset (lhs); tree new_ptr; off = double_int_add (off, shwi_to_double_int (def_rhs_offset)); if (TREE_CODE (def_rhs_base) == MEM_REF) { off = double_int_add (off, mem_ref_offset (def_rhs_base)); new_ptr = TREE_OPERAND (def_rhs_base, 0); } else new_ptr = build_fold_addr_expr (def_rhs_base); TREE_OPERAND (lhs, 0) = new_ptr; TREE_OPERAND (lhs, 1) = double_int_to_tree (TREE_TYPE (TREE_OPERAND (lhs, 1)), off); tidy_after_forward_propagate_addr (use_stmt); /* Continue propagating into the RHS if this was not the only use. */ if (single_use_p) return true; } /* If the LHS is a plain dereference and the value type is the same as that of the pointed-to type of the address we can put the dereferenced address on the LHS preserving the original alias-type. */ else if (gimple_assign_lhs (use_stmt) == lhs && useless_type_conversion_p (TREE_TYPE (TREE_OPERAND (def_rhs, 0)), TREE_TYPE (gimple_assign_rhs1 (use_stmt)))) { tree *def_rhs_basep = &TREE_OPERAND (def_rhs, 0); tree new_offset, new_base, saved; while (handled_component_p (*def_rhs_basep)) def_rhs_basep = &TREE_OPERAND (*def_rhs_basep, 0); saved = *def_rhs_basep; if (TREE_CODE (*def_rhs_basep) == MEM_REF) { new_base = TREE_OPERAND (*def_rhs_basep, 0); new_offset = int_const_binop (PLUS_EXPR, TREE_OPERAND (lhs, 1), TREE_OPERAND (*def_rhs_basep, 1), 0); } else { new_base = build_fold_addr_expr (*def_rhs_basep); new_offset = TREE_OPERAND (lhs, 1); } *def_rhs_basep = build2 (MEM_REF, TREE_TYPE (*def_rhs_basep), new_base, new_offset); gimple_assign_set_lhs (use_stmt, unshare_expr (TREE_OPERAND (def_rhs, 0))); *def_rhs_basep = saved; tidy_after_forward_propagate_addr (use_stmt); /* Continue propagating into the RHS if this was not the only use. */ if (single_use_p) return true; } else /* We can have a struct assignment dereferencing our name twice. Note that we didn't propagate into the lhs to not falsely claim we did when propagating into the rhs. */ res = false; } /* Strip away any outer COMPONENT_REF, ARRAY_REF or ADDR_EXPR nodes from the RHS. */ rhs = gimple_assign_rhs1 (use_stmt); if (TREE_CODE (rhs) == ADDR_EXPR) rhs = TREE_OPERAND (rhs, 0); while (handled_component_p (rhs)) rhs = TREE_OPERAND (rhs, 0); /* Now see if the RHS node is a MEM_REF using NAME. If so, propagate the ADDR_EXPR into the use of NAME and fold the result. */ if (TREE_CODE (rhs) == MEM_REF && TREE_OPERAND (rhs, 0) == name) { tree def_rhs_base; HOST_WIDE_INT def_rhs_offset; if ((def_rhs_base = get_addr_base_and_unit_offset (TREE_OPERAND (def_rhs, 0), &def_rhs_offset))) { double_int off = mem_ref_offset (rhs); tree new_ptr; off = double_int_add (off, shwi_to_double_int (def_rhs_offset)); if (TREE_CODE (def_rhs_base) == MEM_REF) { off = double_int_add (off, mem_ref_offset (def_rhs_base)); new_ptr = TREE_OPERAND (def_rhs_base, 0); } else new_ptr = build_fold_addr_expr (def_rhs_base); TREE_OPERAND (rhs, 0) = new_ptr; TREE_OPERAND (rhs, 1) = double_int_to_tree (TREE_TYPE (TREE_OPERAND (rhs, 1)), off); fold_stmt_inplace (use_stmt); tidy_after_forward_propagate_addr (use_stmt); return res; } /* If the LHS is a plain dereference and the value type is the same as that of the pointed-to type of the address we can put the dereferenced address on the LHS preserving the original alias-type. */ else if (gimple_assign_rhs1 (use_stmt) == rhs && useless_type_conversion_p (TREE_TYPE (gimple_assign_lhs (use_stmt)), TREE_TYPE (TREE_OPERAND (def_rhs, 0)))) { tree *def_rhs_basep = &TREE_OPERAND (def_rhs, 0); tree new_offset, new_base, saved; while (handled_component_p (*def_rhs_basep)) def_rhs_basep = &TREE_OPERAND (*def_rhs_basep, 0); saved = *def_rhs_basep; if (TREE_CODE (*def_rhs_basep) == MEM_REF) { new_base = TREE_OPERAND (*def_rhs_basep, 0); new_offset = int_const_binop (PLUS_EXPR, TREE_OPERAND (rhs, 1), TREE_OPERAND (*def_rhs_basep, 1), 0); } else { new_base = build_fold_addr_expr (*def_rhs_basep); new_offset = TREE_OPERAND (rhs, 1); } *def_rhs_basep = build2 (MEM_REF, TREE_TYPE (*def_rhs_basep), new_base, new_offset); gimple_assign_set_rhs1 (use_stmt, unshare_expr (TREE_OPERAND (def_rhs, 0))); *def_rhs_basep = saved; fold_stmt_inplace (use_stmt); tidy_after_forward_propagate_addr (use_stmt); return res; } } /* If the use of the ADDR_EXPR is not a POINTER_PLUS_EXPR, there is nothing to do. */ if (gimple_assign_rhs_code (use_stmt) != POINTER_PLUS_EXPR || gimple_assign_rhs1 (use_stmt) != name) return false; /* The remaining cases are all for turning pointer arithmetic into array indexing. They only apply when we have the address of element zero in an array. If that is not the case then there is nothing to do. */ array_ref = TREE_OPERAND (def_rhs, 0); if ((TREE_CODE (array_ref) != ARRAY_REF || TREE_CODE (TREE_TYPE (TREE_OPERAND (array_ref, 0))) != ARRAY_TYPE || TREE_CODE (TREE_OPERAND (array_ref, 1)) != INTEGER_CST) && TREE_CODE (TREE_TYPE (array_ref)) != ARRAY_TYPE) return false; rhs2 = gimple_assign_rhs2 (use_stmt); /* Try to optimize &x[C1] p+ C2 where C2 is a multiple of the size of the elements in X into &x[C1 + C2/element size]. */ if (TREE_CODE (rhs2) == INTEGER_CST) { tree new_rhs = maybe_fold_stmt_addition (gimple_location (use_stmt), TREE_TYPE (def_rhs), def_rhs, rhs2); if (new_rhs) { tree type = TREE_TYPE (gimple_assign_lhs (use_stmt)); new_rhs = unshare_expr (new_rhs); if (!useless_type_conversion_p (type, TREE_TYPE (new_rhs))) { if (!is_gimple_min_invariant (new_rhs)) new_rhs = force_gimple_operand_gsi (use_stmt_gsi, new_rhs, true, NULL_TREE, true, GSI_SAME_STMT); new_rhs = fold_convert (type, new_rhs); } gimple_assign_set_rhs_from_tree (use_stmt_gsi, new_rhs); use_stmt = gsi_stmt (*use_stmt_gsi); update_stmt (use_stmt); tidy_after_forward_propagate_addr (use_stmt); return true; } } /* Try to optimize &x[0] p+ OFFSET where OFFSET is defined by converting a multiplication of an index by the size of the array elements, then the result is converted into the proper type for the arithmetic. */ if (TREE_CODE (rhs2) == SSA_NAME && (TREE_CODE (array_ref) != ARRAY_REF || integer_zerop (TREE_OPERAND (array_ref, 1))) && useless_type_conversion_p (TREE_TYPE (name), TREE_TYPE (def_rhs)) /* Avoid problems with IVopts creating PLUS_EXPRs with a different type than their operands. */ && useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (def_rhs))) return forward_propagate_addr_into_variable_array_index (rhs2, def_rhs, use_stmt_gsi); return false; } /* STMT is a statement of the form SSA_NAME = ADDR_EXPR <whatever>. Try to forward propagate the ADDR_EXPR into all uses of the SSA_NAME. Often this will allow for removal of an ADDR_EXPR and INDIRECT_REF node or for recovery of array indexing from pointer arithmetic. Returns true, if all uses have been propagated into. */ static bool forward_propagate_addr_expr (tree name, tree rhs) { int stmt_loop_depth = gimple_bb (SSA_NAME_DEF_STMT (name))->loop_depth; imm_use_iterator iter; gimple use_stmt; bool all = true; bool single_use_p = has_single_use (name); FOR_EACH_IMM_USE_STMT (use_stmt, iter, name) { bool result; tree use_rhs; /* If the use is not in a simple assignment statement, then there is nothing we can do. */ if (gimple_code (use_stmt) != GIMPLE_ASSIGN) { if (!is_gimple_debug (use_stmt)) all = false; continue; } /* If the use is in a deeper loop nest, then we do not want to propagate non-invariant ADDR_EXPRs into the loop as that is likely adding expression evaluations into the loop. */ if (gimple_bb (use_stmt)->loop_depth > stmt_loop_depth && !is_gimple_min_invariant (rhs)) { all = false; continue; } { gimple_stmt_iterator gsi = gsi_for_stmt (use_stmt); result = forward_propagate_addr_expr_1 (name, rhs, &gsi, single_use_p); /* If the use has moved to a different statement adjust the update machinery for the old statement too. */ if (use_stmt != gsi_stmt (gsi)) { update_stmt (use_stmt); use_stmt = gsi_stmt (gsi); } update_stmt (use_stmt); } all &= result; /* Remove intermediate now unused copy and conversion chains. */ use_rhs = gimple_assign_rhs1 (use_stmt); if (result && TREE_CODE (gimple_assign_lhs (use_stmt)) == SSA_NAME && TREE_CODE (use_rhs) == SSA_NAME && has_zero_uses (gimple_assign_lhs (use_stmt))) { gimple_stmt_iterator gsi = gsi_for_stmt (use_stmt); release_defs (use_stmt); gsi_remove (&gsi, true); } } return all && has_zero_uses (name); } /* Forward propagate the comparison defined in STMT like cond_1 = x CMP y to uses of the form a_1 = (T')cond_1 a_1 = !cond_1 a_1 = cond_1 != 0 Returns true if stmt is now unused. */ static bool forward_propagate_comparison (gimple stmt) { tree name = gimple_assign_lhs (stmt); gimple use_stmt; tree tmp = NULL_TREE; /* Don't propagate ssa names that occur in abnormal phis. */ if ((TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs1 (stmt))) || (TREE_CODE (gimple_assign_rhs2 (stmt)) == SSA_NAME && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs2 (stmt)))) return false; /* Do not un-cse comparisons. But propagate through copies. */ use_stmt = get_prop_dest_stmt (name, &name); if (!use_stmt) return false; /* Conversion of the condition result to another integral type. */ if (is_gimple_assign (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) && INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_lhs (use_stmt)))) { tree lhs = gimple_assign_lhs (use_stmt); /* We can propagate the condition into a conversion. */ 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. */ tmp = build2 (gimple_assign_rhs_code (stmt), TREE_TYPE (lhs), gimple_assign_rhs1 (stmt), gimple_assign_rhs2 (stmt)); } /* We can propagate the condition into X op CST where op is EQ_EXPR or NE_EXPR and CST is either one or zero. */ else if (TREE_CODE_CLASS (gimple_assign_rhs_code (use_stmt)) == tcc_comparison && TREE_CODE (gimple_assign_rhs1 (use_stmt)) == SSA_NAME && TREE_CODE (gimple_assign_rhs2 (use_stmt)) == INTEGER_CST) { enum tree_code code = gimple_assign_rhs_code (use_stmt); tree cst = gimple_assign_rhs2 (use_stmt); tree cond; cond = build2 (gimple_assign_rhs_code (stmt), TREE_TYPE (cst), gimple_assign_rhs1 (stmt), gimple_assign_rhs2 (stmt)); tmp = combine_cond_expr_cond (gimple_location (use_stmt), code, TREE_TYPE (lhs), cond, cst, false); if (tmp == NULL_TREE) return false; } /* We can propagate the condition into a statement that computes the logical negation of the comparison result. */ else if (gimple_assign_rhs_code (use_stmt) == TRUTH_NOT_EXPR) { tree type = TREE_TYPE (gimple_assign_rhs1 (stmt)); bool nans = HONOR_NANS (TYPE_MODE (type)); enum tree_code code; code = invert_tree_comparison (gimple_assign_rhs_code (stmt), nans); if (code == ERROR_MARK) return false; tmp = build2 (code, TREE_TYPE (lhs), gimple_assign_rhs1 (stmt), gimple_assign_rhs2 (stmt)); } else return false; { gimple_stmt_iterator gsi = gsi_for_stmt (use_stmt); gimple_assign_set_rhs_from_tree (&gsi, unshare_expr (tmp)); use_stmt = gsi_stmt (gsi); update_stmt (use_stmt); } if (dump_file && (dump_flags & TDF_DETAILS)) { tree old_rhs = rhs_to_tree (TREE_TYPE (gimple_assign_lhs (stmt)), stmt); fprintf (dump_file, " Replaced '"); print_generic_expr (dump_file, old_rhs, dump_flags); fprintf (dump_file, "' with '"); print_generic_expr (dump_file, tmp, dump_flags); fprintf (dump_file, "'\n"); } /* Remove defining statements. */ return remove_prop_source_from_use (name); } return false; } /* If we have lhs = ~x (STMT), look and see if earlier we had x = ~y. If so, we can change STMT into lhs = y which can later be copy propagated. Similarly for negation. This could trivially be formulated as a forward propagation to immediate uses. However, we already had an implementation from DOM which used backward propagation via the use-def links. It turns out that backward propagation is actually faster as there's less work to do for each NOT/NEG expression we find. Backwards propagation needs to look at the statement in a single backlink. Forward propagation needs to look at potentially more than one forward link. */ static void simplify_not_neg_expr (gimple_stmt_iterator *gsi_p) { gimple stmt = gsi_stmt (*gsi_p); tree rhs = gimple_assign_rhs1 (stmt); gimple rhs_def_stmt = SSA_NAME_DEF_STMT (rhs); /* See if the RHS_DEF_STMT has the same form as our statement. */ if (is_gimple_assign (rhs_def_stmt) && gimple_assign_rhs_code (rhs_def_stmt) == gimple_assign_rhs_code (stmt)) { tree rhs_def_operand = gimple_assign_rhs1 (rhs_def_stmt); /* Verify that RHS_DEF_OPERAND is a suitable SSA_NAME. */ if (TREE_CODE (rhs_def_operand) == SSA_NAME && ! SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs_def_operand)) { gimple_assign_set_rhs_from_tree (gsi_p, rhs_def_operand); stmt = gsi_stmt (*gsi_p); update_stmt (stmt); } } } /* STMT is a SWITCH_EXPR for which we attempt to find equivalent forms of the condition which we may be able to optimize better. */ static void simplify_gimple_switch (gimple stmt) { tree cond = gimple_switch_index (stmt); tree def, to, ti; gimple def_stmt; /* The optimization that we really care about is removing unnecessary casts. That will let us do much better in propagating the inferred constant at the switch target. */ if (TREE_CODE (cond) == SSA_NAME) { def_stmt = SSA_NAME_DEF_STMT (cond); if (is_gimple_assign (def_stmt)) { if (gimple_assign_rhs_code (def_stmt) == NOP_EXPR) { int need_precision; bool fail; def = gimple_assign_rhs1 (def_stmt); /* ??? Why was Jeff testing this? We are gimple... */ gcc_checking_assert (is_gimple_val (def)); to = TREE_TYPE (cond); ti = TREE_TYPE (def); /* If we have an extension that preserves value, then we can copy the source value into the switch. */ need_precision = TYPE_PRECISION (ti); fail = false; if (! INTEGRAL_TYPE_P (ti)) fail = true; else if (TYPE_UNSIGNED (to) && !TYPE_UNSIGNED (ti)) fail = true; else if (!TYPE_UNSIGNED (to) && TYPE_UNSIGNED (ti)) need_precision += 1; if (TYPE_PRECISION (to) < need_precision) fail = true; if (!fail) { gimple_switch_set_index (stmt, def); update_stmt (stmt); } } } } } /* For pointers p2 and p1 return p2 - p1 if the difference is known and constant, otherwise return NULL. */ static tree constant_pointer_difference (tree p1, tree p2) { int i, j; #define CPD_ITERATIONS 5 tree exps[2][CPD_ITERATIONS]; tree offs[2][CPD_ITERATIONS]; int cnt[2]; for (i = 0; i < 2; i++) { tree p = i ? p1 : p2; tree off = size_zero_node; gimple stmt; enum tree_code code; /* For each of p1 and p2 we need to iterate at least twice, to handle ADDR_EXPR directly in p1/p2, SSA_NAME with ADDR_EXPR or POINTER_PLUS_EXPR etc. on definition's stmt RHS. Iterate a few extra times. */ j = 0; do { if (!POINTER_TYPE_P (TREE_TYPE (p))) break; if (TREE_CODE (p) == ADDR_EXPR) { tree q = TREE_OPERAND (p, 0); HOST_WIDE_INT offset; tree base = get_addr_base_and_unit_offset (q, &offset); if (base) { q = base; if (offset) off = size_binop (PLUS_EXPR, off, size_int (offset)); } if (TREE_CODE (q) == MEM_REF && TREE_CODE (TREE_OPERAND (q, 0)) == SSA_NAME) { p = TREE_OPERAND (q, 0); off = size_binop (PLUS_EXPR, off, double_int_to_tree (sizetype, mem_ref_offset (q))); } else { exps[i][j] = q; offs[i][j++] = off; break; } } if (TREE_CODE (p) != SSA_NAME) break; exps[i][j] = p; offs[i][j++] = off; if (j == CPD_ITERATIONS) break; stmt = SSA_NAME_DEF_STMT (p); if (!is_gimple_assign (stmt) || gimple_assign_lhs (stmt) != p) break; code = gimple_assign_rhs_code (stmt); if (code == POINTER_PLUS_EXPR) { if (TREE_CODE (gimple_assign_rhs2 (stmt)) != INTEGER_CST) break; off = size_binop (PLUS_EXPR, off, gimple_assign_rhs2 (stmt)); p = gimple_assign_rhs1 (stmt); } else if (code == ADDR_EXPR || code == NOP_EXPR) p = gimple_assign_rhs1 (stmt); else break; } while (1); cnt[i] = j; } for (i = 0; i < cnt[0]; i++) for (j = 0; j < cnt[1]; j++) if (exps[0][i] == exps[1][j]) return size_binop (MINUS_EXPR, offs[0][i], offs[1][j]); return NULL_TREE; } /* *GSI_P is a GIMPLE_CALL to a builtin function. Optimize memcpy (p, "abcd", 4); memset (p + 4, ' ', 3); into memcpy (p, "abcd ", 7); call if the latter can be stored by pieces during expansion. */ static bool simplify_builtin_call (gimple_stmt_iterator *gsi_p, tree callee2) { gimple stmt1, stmt2 = gsi_stmt (*gsi_p); tree vuse = gimple_vuse (stmt2); if (vuse == NULL) return false; stmt1 = SSA_NAME_DEF_STMT (vuse); switch (DECL_FUNCTION_CODE (callee2)) { case BUILT_IN_MEMSET: if (gimple_call_num_args (stmt2) != 3 || gimple_call_lhs (stmt2) || CHAR_BIT != 8 || BITS_PER_UNIT != 8) break; else { tree callee1; tree ptr1, src1, str1, off1, len1, lhs1; tree ptr2 = gimple_call_arg (stmt2, 0); tree val2 = gimple_call_arg (stmt2, 1); tree len2 = gimple_call_arg (stmt2, 2); tree diff, vdef, new_str_cst; gimple use_stmt; unsigned int ptr1_align; unsigned HOST_WIDE_INT src_len; char *src_buf; use_operand_p use_p; if (!host_integerp (val2, 0) || !host_integerp (len2, 1)) break; if (is_gimple_call (stmt1)) { /* If first stmt is a call, it needs to be memcpy or mempcpy, with string literal as second argument and constant length. */ callee1 = gimple_call_fndecl (stmt1); if (callee1 == NULL_TREE || DECL_BUILT_IN_CLASS (callee1) != BUILT_IN_NORMAL || gimple_call_num_args (stmt1) != 3) break; if (DECL_FUNCTION_CODE (callee1) != BUILT_IN_MEMCPY && DECL_FUNCTION_CODE (callee1) != BUILT_IN_MEMPCPY) break; ptr1 = gimple_call_arg (stmt1, 0); src1 = gimple_call_arg (stmt1, 1); len1 = gimple_call_arg (stmt1, 2); lhs1 = gimple_call_lhs (stmt1); if (!host_integerp (len1, 1)) break; str1 = string_constant (src1, &off1); if (str1 == NULL_TREE) break; if (!host_integerp (off1, 1) || compare_tree_int (off1, TREE_STRING_LENGTH (str1) - 1) > 0 || compare_tree_int (len1, TREE_STRING_LENGTH (str1) - tree_low_cst (off1, 1)) > 0 || TREE_CODE (TREE_TYPE (str1)) != ARRAY_TYPE || TYPE_MODE (TREE_TYPE (TREE_TYPE (str1))) != TYPE_MODE (char_type_node)) break; } else if (gimple_assign_single_p (stmt1)) { /* Otherwise look for length 1 memcpy optimized into assignment. */ ptr1 = gimple_assign_lhs (stmt1); src1 = gimple_assign_rhs1 (stmt1); if (TREE_CODE (ptr1) != MEM_REF || TYPE_MODE (TREE_TYPE (ptr1)) != TYPE_MODE (char_type_node) || !host_integerp (src1, 0)) break; ptr1 = build_fold_addr_expr (ptr1); callee1 = NULL_TREE; len1 = size_one_node; lhs1 = NULL_TREE; off1 = size_zero_node; str1 = NULL_TREE; } else break; diff = constant_pointer_difference (ptr1, ptr2); if (diff == NULL && lhs1 != NULL) { diff = constant_pointer_difference (lhs1, ptr2); if (DECL_FUNCTION_CODE (callee1) == BUILT_IN_MEMPCPY && diff != NULL) diff = size_binop (PLUS_EXPR, diff, fold_convert (sizetype, len1)); } /* If the difference between the second and first destination pointer is not constant, or is bigger than memcpy length, bail out. */ if (diff == NULL || !host_integerp (diff, 1) || tree_int_cst_lt (len1, diff)) break; /* Use maximum of difference plus memset length and memcpy length as the new memcpy length, if it is too big, bail out. */ src_len = tree_low_cst (diff, 1); src_len += tree_low_cst (len2, 1); if (src_len < (unsigned HOST_WIDE_INT) tree_low_cst (len1, 1)) src_len = tree_low_cst (len1, 1); if (src_len > 1024) break; /* If mempcpy value is used elsewhere, bail out, as mempcpy with bigger length will return different result. */ if (lhs1 != NULL_TREE && DECL_FUNCTION_CODE (callee1) == BUILT_IN_MEMPCPY && (TREE_CODE (lhs1) != SSA_NAME || !single_imm_use (lhs1, &use_p, &use_stmt) || use_stmt != stmt2)) break; /* If anything reads memory in between memcpy and memset call, the modified memcpy call might change it. */ vdef = gimple_vdef (stmt1); if (vdef != NULL && (!single_imm_use (vdef, &use_p, &use_stmt) || use_stmt != stmt2)) break; ptr1_align = get_pointer_alignment (ptr1, BIGGEST_ALIGNMENT); /* Construct the new source string literal. */ src_buf = XALLOCAVEC (char, src_len + 1); if (callee1) memcpy (src_buf, TREE_STRING_POINTER (str1) + tree_low_cst (off1, 1), tree_low_cst (len1, 1)); else src_buf[0] = tree_low_cst (src1, 0); memset (src_buf + tree_low_cst (diff, 1), tree_low_cst (val2, 1), tree_low_cst (len2, 1)); src_buf[src_len] = '\0'; /* Neither builtin_strncpy_read_str nor builtin_memcpy_read_str handle embedded '\0's. */ if (strlen (src_buf) != src_len) break; rtl_profile_for_bb (gimple_bb (stmt2)); /* If the new memcpy wouldn't be emitted by storing the literal by pieces, this optimization might enlarge .rodata too much, as commonly used string literals couldn't be shared any longer. */ if (!can_store_by_pieces (src_len, builtin_strncpy_read_str, src_buf, ptr1_align, false)) break; new_str_cst = build_string_literal (src_len, src_buf); if (callee1) { /* If STMT1 is a mem{,p}cpy call, adjust it and remove memset call. */ if (lhs1 && DECL_FUNCTION_CODE (callee1) == BUILT_IN_MEMPCPY) gimple_call_set_lhs (stmt1, NULL_TREE); gimple_call_set_arg (stmt1, 1, new_str_cst); gimple_call_set_arg (stmt1, 2, build_int_cst (TREE_TYPE (len1), src_len)); update_stmt (stmt1); unlink_stmt_vdef (stmt2); gsi_remove (gsi_p, true); release_defs (stmt2); if (lhs1 && DECL_FUNCTION_CODE (callee1) == BUILT_IN_MEMPCPY) release_ssa_name (lhs1); return true; } else { /* Otherwise, if STMT1 is length 1 memcpy optimized into assignment, remove STMT1 and change memset call into memcpy call. */ gimple_stmt_iterator gsi = gsi_for_stmt (stmt1); if (!is_gimple_val (ptr1)) ptr1 = force_gimple_operand_gsi (gsi_p, ptr1, true, NULL_TREE, true, GSI_SAME_STMT); gimple_call_set_fndecl (stmt2, built_in_decls [BUILT_IN_MEMCPY]); gimple_call_set_arg (stmt2, 0, ptr1); gimple_call_set_arg (stmt2, 1, new_str_cst); gimple_call_set_arg (stmt2, 2, build_int_cst (TREE_TYPE (len2), src_len)); unlink_stmt_vdef (stmt1); gsi_remove (&gsi, true); release_defs (stmt1); update_stmt (stmt2); return false; } } break; default: break; } return false; } /* Run bitwise and assignments throug the folder. If the first argument is an ssa name that is itself a result of a typecast of an ADDR_EXPR to an integer, feed the ADDR_EXPR to the folder rather than the ssa name. */ static void simplify_bitwise_and (gimple_stmt_iterator *gsi, gimple stmt) { tree res; tree arg1 = gimple_assign_rhs1 (stmt); tree arg2 = gimple_assign_rhs2 (stmt); if (TREE_CODE (arg2) != INTEGER_CST) return; if (TREE_CODE (arg1) == SSA_NAME && !SSA_NAME_IS_DEFAULT_DEF (arg1)) { gimple def = SSA_NAME_DEF_STMT (arg1); if (gimple_assign_cast_p (def) && INTEGRAL_TYPE_P (gimple_expr_type (def))) { tree op = gimple_assign_rhs1 (def); if (TREE_CODE (op) == ADDR_EXPR) arg1 = op; } } res = fold_binary_loc (gimple_location (stmt), BIT_AND_EXPR, TREE_TYPE (gimple_assign_lhs (stmt)), arg1, arg2); if (res && is_gimple_min_invariant (res)) { gimple_assign_set_rhs_from_tree (gsi, res); update_stmt (stmt); } return; } /* Perform re-associations of the plus or minus statement STMT that are always permitted. Returns true if the CFG was changed. */ static bool associate_plusminus (gimple stmt) { tree rhs1 = gimple_assign_rhs1 (stmt); tree rhs2 = gimple_assign_rhs2 (stmt); enum tree_code code = gimple_assign_rhs_code (stmt); gimple_stmt_iterator gsi; bool changed; /* We can't reassociate at all for saturating types. */ if (TYPE_SATURATING (TREE_TYPE (rhs1))) return false; /* First contract negates. */ do { changed = false; /* A +- (-B) -> A -+ B. */ if (TREE_CODE (rhs2) == SSA_NAME) { gimple def_stmt = SSA_NAME_DEF_STMT (rhs2); if (is_gimple_assign (def_stmt) && gimple_assign_rhs_code (def_stmt) == NEGATE_EXPR) { code = (code == MINUS_EXPR) ? PLUS_EXPR : MINUS_EXPR; gimple_assign_set_rhs_code (stmt, code); rhs2 = gimple_assign_rhs1 (def_stmt); gimple_assign_set_rhs2 (stmt, rhs2); gimple_set_modified (stmt, true); changed = true; } } /* (-A) + B -> B - A. */ if (TREE_CODE (rhs1) == SSA_NAME && code == PLUS_EXPR) { gimple def_stmt = SSA_NAME_DEF_STMT (rhs1); if (is_gimple_assign (def_stmt) && gimple_assign_rhs_code (def_stmt) == NEGATE_EXPR) { code = MINUS_EXPR; gimple_assign_set_rhs_code (stmt, code); rhs1 = rhs2; gimple_assign_set_rhs1 (stmt, rhs1); rhs2 = gimple_assign_rhs1 (def_stmt); gimple_assign_set_rhs2 (stmt, rhs2); gimple_set_modified (stmt, true); changed = true; } } } while (changed); /* We can't reassociate floating-point or fixed-point plus or minus because of saturation to +-Inf. */ if (FLOAT_TYPE_P (TREE_TYPE (rhs1)) || FIXED_POINT_TYPE_P (TREE_TYPE (rhs1))) goto out; /* Second match patterns that allow contracting a plus-minus pair irrespective of overflow issues. (A +- B) - A -> +- B (A +- B) -+ B -> A (CST +- A) +- CST -> CST +- A (A + CST) +- CST -> A + CST ~A + A -> -1 ~A + 1 -> -A A - (A +- B) -> -+ B A +- (B +- A) -> +- B CST +- (CST +- A) -> CST +- A CST +- (A +- CST) -> CST +- A A + ~A -> -1 via commutating the addition and contracting operations to zero by reassociation. */ gsi = gsi_for_stmt (stmt); if (TREE_CODE (rhs1) == SSA_NAME) { gimple def_stmt = SSA_NAME_DEF_STMT (rhs1); if (is_gimple_assign (def_stmt)) { enum tree_code def_code = gimple_assign_rhs_code (def_stmt); if (def_code == PLUS_EXPR || def_code == MINUS_EXPR) { tree def_rhs1 = gimple_assign_rhs1 (def_stmt); tree def_rhs2 = gimple_assign_rhs2 (def_stmt); if (operand_equal_p (def_rhs1, rhs2, 0) && code == MINUS_EXPR) { /* (A +- B) - A -> +- B. */ code = ((def_code == PLUS_EXPR) ? TREE_CODE (def_rhs2) : NEGATE_EXPR); rhs1 = def_rhs2; rhs2 = NULL_TREE; gimple_assign_set_rhs_with_ops (&gsi, code, rhs1, NULL_TREE); gcc_assert (gsi_stmt (gsi) == stmt); gimple_set_modified (stmt, true); } else if (operand_equal_p (def_rhs2, rhs2, 0) && code != def_code) { /* (A +- B) -+ B -> A. */ code = TREE_CODE (def_rhs1); rhs1 = def_rhs1; rhs2 = NULL_TREE; gimple_assign_set_rhs_with_ops (&gsi, code, rhs1, NULL_TREE); gcc_assert (gsi_stmt (gsi) == stmt); gimple_set_modified (stmt, true); } else if (TREE_CODE (rhs2) == INTEGER_CST && TREE_CODE (def_rhs1) == INTEGER_CST) { /* (CST +- A) +- CST -> CST +- A. */ tree cst = fold_binary (code, TREE_TYPE (rhs1), def_rhs1, rhs2); if (cst && !TREE_OVERFLOW (cst)) { code = def_code; gimple_assign_set_rhs_code (stmt, code); rhs1 = cst; gimple_assign_set_rhs1 (stmt, rhs1); rhs2 = def_rhs2; gimple_assign_set_rhs2 (stmt, rhs2); gimple_set_modified (stmt, true); } } else if (TREE_CODE (rhs2) == INTEGER_CST && TREE_CODE (def_rhs2) == INTEGER_CST && def_code == PLUS_EXPR) { /* (A + CST) +- CST -> A + CST. */ tree cst = fold_binary (code, TREE_TYPE (rhs1), def_rhs2, rhs2); if (cst && !TREE_OVERFLOW (cst)) { code = PLUS_EXPR; gimple_assign_set_rhs_code (stmt, code); rhs1 = def_rhs1; gimple_assign_set_rhs1 (stmt, rhs1); rhs2 = cst; gimple_assign_set_rhs2 (stmt, rhs2); gimple_set_modified (stmt, true); } } } else if (def_code == BIT_NOT_EXPR && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))) { tree def_rhs1 = gimple_assign_rhs1 (def_stmt); if (code == PLUS_EXPR && operand_equal_p (def_rhs1, rhs2, 0)) { /* ~A + A -> -1. */ code = INTEGER_CST; rhs1 = build_int_cst (TREE_TYPE (rhs2), -1); rhs2 = NULL_TREE; gimple_assign_set_rhs_with_ops (&gsi, code, rhs1, NULL_TREE); gcc_assert (gsi_stmt (gsi) == stmt); gimple_set_modified (stmt, true); } else if (code == PLUS_EXPR && integer_onep (rhs1)) { /* ~A + 1 -> -A. */ code = NEGATE_EXPR; rhs1 = def_rhs1; rhs2 = NULL_TREE; gimple_assign_set_rhs_with_ops (&gsi, code, rhs1, NULL_TREE); gcc_assert (gsi_stmt (gsi) == stmt); gimple_set_modified (stmt, true); } } } } if (rhs2 && TREE_CODE (rhs2) == SSA_NAME) { gimple def_stmt = SSA_NAME_DEF_STMT (rhs2); if (is_gimple_assign (def_stmt)) { enum tree_code def_code = gimple_assign_rhs_code (def_stmt); if (def_code == PLUS_EXPR || def_code == MINUS_EXPR) { tree def_rhs1 = gimple_assign_rhs1 (def_stmt); tree def_rhs2 = gimple_assign_rhs2 (def_stmt); if (operand_equal_p (def_rhs1, rhs1, 0) && code == MINUS_EXPR) { /* A - (A +- B) -> -+ B. */ code = ((def_code == PLUS_EXPR) ? NEGATE_EXPR : TREE_CODE (def_rhs2)); rhs1 = def_rhs2; rhs2 = NULL_TREE; gimple_assign_set_rhs_with_ops (&gsi, code, rhs1, NULL_TREE); gcc_assert (gsi_stmt (gsi) == stmt); gimple_set_modified (stmt, true); } else if (operand_equal_p (def_rhs2, rhs1, 0) && code != def_code) { /* A +- (B +- A) -> +- B. */ code = ((code == PLUS_EXPR) ? TREE_CODE (def_rhs1) : NEGATE_EXPR); rhs1 = def_rhs1; rhs2 = NULL_TREE; gimple_assign_set_rhs_with_ops (&gsi, code, rhs1, NULL_TREE); gcc_assert (gsi_stmt (gsi) == stmt); gimple_set_modified (stmt, true); } else if (TREE_CODE (rhs1) == INTEGER_CST && TREE_CODE (def_rhs1) == INTEGER_CST) { /* CST +- (CST +- A) -> CST +- A. */ tree cst = fold_binary (code, TREE_TYPE (rhs2), rhs1, def_rhs1); if (cst && !TREE_OVERFLOW (cst)) { code = (code == def_code ? PLUS_EXPR : MINUS_EXPR); gimple_assign_set_rhs_code (stmt, code); rhs1 = cst; gimple_assign_set_rhs1 (stmt, rhs1); rhs2 = def_rhs2; gimple_assign_set_rhs2 (stmt, rhs2); gimple_set_modified (stmt, true); } } else if (TREE_CODE (rhs1) == INTEGER_CST && TREE_CODE (def_rhs2) == INTEGER_CST) { /* CST +- (A +- CST) -> CST +- A. */ tree cst = fold_binary (def_code == code ? PLUS_EXPR : MINUS_EXPR, TREE_TYPE (rhs2), rhs1, def_rhs2); if (cst && !TREE_OVERFLOW (cst)) { rhs1 = cst; gimple_assign_set_rhs1 (stmt, rhs1); rhs2 = def_rhs1; gimple_assign_set_rhs2 (stmt, rhs2); gimple_set_modified (stmt, true); } } } else if (def_code == BIT_NOT_EXPR && INTEGRAL_TYPE_P (TREE_TYPE (rhs2))) { tree def_rhs1 = gimple_assign_rhs1 (def_stmt); if (code == PLUS_EXPR && operand_equal_p (def_rhs1, rhs1, 0)) { /* A + ~A -> -1. */ code = INTEGER_CST; rhs1 = build_int_cst (TREE_TYPE (rhs1), -1); rhs2 = NULL_TREE; gimple_assign_set_rhs_with_ops (&gsi, code, rhs1, NULL_TREE); gcc_assert (gsi_stmt (gsi) == stmt); gimple_set_modified (stmt, true); } } } } out: if (gimple_modified_p (stmt)) { fold_stmt_inplace (stmt); update_stmt (stmt); if (maybe_clean_or_replace_eh_stmt (stmt, stmt) && gimple_purge_dead_eh_edges (gimple_bb (stmt))) return true; } return false; } /* Main entry point for the forward propagation optimizer. */ static unsigned int tree_ssa_forward_propagate_single_use_vars (void) { basic_block bb; unsigned int todoflags = 0; cfg_changed = false; FOR_EACH_BB (bb) { gimple_stmt_iterator gsi; /* Note we update GSI within the loop as necessary. */ for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); ) { gimple stmt = gsi_stmt (gsi); /* If this statement sets an SSA_NAME to an address, try to propagate the address into the uses of the SSA_NAME. */ if (is_gimple_assign (stmt)) { tree lhs = gimple_assign_lhs (stmt); tree rhs = gimple_assign_rhs1 (stmt); if (TREE_CODE (lhs) != SSA_NAME) { gsi_next (&gsi); continue; } if (gimple_assign_rhs_code (stmt) == ADDR_EXPR /* Handle pointer conversions on invariant addresses as well, as this is valid gimple. */ || (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt)) && TREE_CODE (rhs) == ADDR_EXPR && POINTER_TYPE_P (TREE_TYPE (lhs)))) { tree base = get_base_address (TREE_OPERAND (rhs, 0)); if ((!base || !DECL_P (base) || decl_address_invariant_p (base)) && !stmt_references_abnormal_ssa_name (stmt) && forward_propagate_addr_expr (lhs, rhs)) { release_defs (stmt); todoflags |= TODO_remove_unused_locals; gsi_remove (&gsi, true); } else gsi_next (&gsi); } else if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR && can_propagate_from (stmt)) { if (TREE_CODE (gimple_assign_rhs2 (stmt)) == INTEGER_CST /* ??? Better adjust the interface to that function instead of building new trees here. */ && forward_propagate_addr_expr (lhs, build1 (ADDR_EXPR, TREE_TYPE (rhs), fold_build2 (MEM_REF, TREE_TYPE (TREE_TYPE (rhs)), rhs, fold_convert (ptr_type_node, gimple_assign_rhs2 (stmt)))))) { release_defs (stmt); todoflags |= TODO_remove_unused_locals; gsi_remove (&gsi, true); } else if (is_gimple_min_invariant (rhs)) { /* Make sure to fold &a[0] + off_1 here. */ fold_stmt_inplace (stmt); update_stmt (stmt); if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR) gsi_next (&gsi); } else gsi_next (&gsi); } else if ((gimple_assign_rhs_code (stmt) == BIT_NOT_EXPR || gimple_assign_rhs_code (stmt) == NEGATE_EXPR) && TREE_CODE (rhs) == SSA_NAME) { simplify_not_neg_expr (&gsi); gsi_next (&gsi); } else if (gimple_assign_rhs_code (stmt) == COND_EXPR) { /* In this case the entire COND_EXPR is in rhs1. */ int did_something; fold_defer_overflow_warnings (); did_something = forward_propagate_into_cond (&gsi); stmt = gsi_stmt (gsi); if (did_something == 2) cfg_changed = true; fold_undefer_overflow_warnings (!TREE_NO_WARNING (rhs) && did_something, stmt, WARN_STRICT_OVERFLOW_CONDITIONAL); gsi_next (&gsi); } else if (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)) == tcc_comparison) { if (forward_propagate_comparison (stmt)) cfg_changed = true; gsi_next (&gsi); } else if (gimple_assign_rhs_code (stmt) == BIT_AND_EXPR) { simplify_bitwise_and (&gsi, stmt); gsi_next (&gsi); } else if (gimple_assign_rhs_code (stmt) == PLUS_EXPR || gimple_assign_rhs_code (stmt) == MINUS_EXPR) { cfg_changed |= associate_plusminus (stmt); gsi_next (&gsi); } else gsi_next (&gsi); } else if (gimple_code (stmt) == GIMPLE_SWITCH) { simplify_gimple_switch (stmt); gsi_next (&gsi); } else if (gimple_code (stmt) == GIMPLE_COND) { int did_something; fold_defer_overflow_warnings (); did_something = forward_propagate_into_gimple_cond (stmt); if (did_something == 2) cfg_changed = true; fold_undefer_overflow_warnings (did_something, stmt, WARN_STRICT_OVERFLOW_CONDITIONAL); gsi_next (&gsi); } else if (is_gimple_call (stmt)) { tree callee = gimple_call_fndecl (stmt); if (callee == NULL_TREE || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL || !simplify_builtin_call (&gsi, callee)) gsi_next (&gsi); } else gsi_next (&gsi); } } if (cfg_changed) todoflags |= TODO_cleanup_cfg; return todoflags; } static bool gate_forwprop (void) { return flag_tree_forwprop; } struct gimple_opt_pass pass_forwprop = { { GIMPLE_PASS, "forwprop", /* name */ gate_forwprop, /* gate */ tree_ssa_forward_propagate_single_use_vars, /* execute */ NULL, /* sub */ NULL, /* next */ 0, /* static_pass_number */ TV_TREE_FORWPROP, /* tv_id */ PROP_cfg | PROP_ssa, /* properties_required */ 0, /* properties_provided */ 0, /* properties_destroyed */ 0, /* todo_flags_start */ TODO_dump_func | TODO_ggc_collect | TODO_update_ssa | TODO_verify_ssa /* todo_flags_finish */ } };