diff options
Diffstat (limited to 'gcc/graphite-sese-to-poly.c')
| -rw-r--r-- | gcc/graphite-sese-to-poly.c | 140 |
1 files changed, 73 insertions, 67 deletions
diff --git a/gcc/graphite-sese-to-poly.c b/gcc/graphite-sese-to-poly.c index 755b0433c8e..bdeba166633 100644 --- a/gcc/graphite-sese-to-poly.c +++ b/gcc/graphite-sese-to-poly.c @@ -100,7 +100,7 @@ tree_int_to_gmp (tree t, mpz_t res) loop. */ static size_t -phi_arg_in_outermost_loop (gimple phi) +phi_arg_in_outermost_loop (gphi *phi) { loop_p loop = gimple_bb (phi)->loop_father; size_t i, res = 0; @@ -119,13 +119,13 @@ phi_arg_in_outermost_loop (gimple phi) PSI by inserting on the loop ENTRY edge assignment "RES = INIT". */ static void -remove_simple_copy_phi (gimple_stmt_iterator *psi) +remove_simple_copy_phi (gphi_iterator *psi) { - gimple phi = gsi_stmt (*psi); + gphi *phi = psi->phi (); tree res = gimple_phi_result (phi); size_t entry = phi_arg_in_outermost_loop (phi); tree init = gimple_phi_arg_def (phi, entry); - gimple stmt = gimple_build_assign (res, init); + gassign *stmt = gimple_build_assign (res, init); edge e = gimple_phi_arg_edge (phi, entry); remove_phi_node (psi, false); @@ -136,16 +136,16 @@ remove_simple_copy_phi (gimple_stmt_iterator *psi) loop ENTRY edge the assignment RES = INIT. */ static void -remove_invariant_phi (sese region, gimple_stmt_iterator *psi) +remove_invariant_phi (sese region, gphi_iterator *psi) { - gimple phi = gsi_stmt (*psi); + gphi *phi = psi->phi (); loop_p loop = loop_containing_stmt (phi); tree res = gimple_phi_result (phi); tree scev = scalar_evolution_in_region (region, loop, res); size_t entry = phi_arg_in_outermost_loop (phi); edge e = gimple_phi_arg_edge (phi, entry); tree var; - gimple stmt; + gassign *stmt; gimple_seq stmts = NULL; if (tree_contains_chrecs (scev, NULL)) @@ -164,7 +164,7 @@ remove_invariant_phi (sese region, gimple_stmt_iterator *psi) /* Returns true when the phi node at PSI is of the form "a = phi (a, x)". */ static inline bool -simple_copy_phi_p (gimple phi) +simple_copy_phi_p (gphi *phi) { tree res; @@ -181,10 +181,10 @@ simple_copy_phi_p (gimple phi) be considered. */ static bool -reduction_phi_p (sese region, gimple_stmt_iterator *psi) +reduction_phi_p (sese region, gphi_iterator *psi) { loop_p loop; - gimple phi = gsi_stmt (*psi); + gphi *phi = psi->phi (); tree res = gimple_phi_result (phi); loop = loop_containing_stmt (phi); @@ -1128,7 +1128,7 @@ create_pw_aff_from_tree (poly_bb_p pbb, tree t) inequalities. */ static void -add_condition_to_pbb (poly_bb_p pbb, gimple stmt, enum tree_code code) +add_condition_to_pbb (poly_bb_p pbb, gcond *stmt, enum tree_code code) { isl_pw_aff *lhs = create_pw_aff_from_tree (pbb, gimple_cond_lhs (stmt)); isl_pw_aff *rhs = create_pw_aff_from_tree (pbb, gimple_cond_rhs (stmt)); @@ -1188,13 +1188,14 @@ add_conditions_to_domain (poly_bb_p pbb) { case GIMPLE_COND: { - enum tree_code code = gimple_cond_code (stmt); + gcond *cond_stmt = as_a <gcond *> (stmt); + enum tree_code code = gimple_cond_code (cond_stmt); /* The conditions for ELSE-branches are inverted. */ if (!GBB_CONDITION_CASES (gbb)[i]) code = invert_tree_comparison (code, false); - add_condition_to_pbb (pbb, stmt, code); + add_condition_to_pbb (pbb, cond_stmt, code); break; } @@ -1224,7 +1225,7 @@ add_conditions_to_constraints (scop_p scop) edge between BB and its predecessor is not a loop exit edge, and the last statement of the single predecessor is a COND_EXPR. */ -static gimple +static gcond * single_pred_cond_non_loop_exit (basic_block bb) { if (single_pred_p (bb)) @@ -1239,7 +1240,7 @@ single_pred_cond_non_loop_exit (basic_block bb) stmt = last_stmt (pred); if (stmt && gimple_code (stmt) == GIMPLE_COND) - return stmt; + return as_a <gcond *> (stmt); } return NULL; @@ -1270,7 +1271,7 @@ void sese_dom_walker::before_dom_children (basic_block bb) { gimple_bb_p gbb; - gimple stmt; + gcond *stmt; if (!bb_in_sese_p (bb, m_region)) return; @@ -1936,14 +1937,14 @@ build_scop_drs (scop_p scop) /* Return a gsi at the position of the phi node STMT. */ -static gimple_stmt_iterator -gsi_for_phi_node (gimple stmt) +static gphi_iterator +gsi_for_phi_node (gphi *stmt) { - gimple_stmt_iterator psi; + gphi_iterator psi; basic_block bb = gimple_bb (stmt); for (psi = gsi_start_phis (bb); !gsi_end_p (psi); gsi_next (&psi)) - if (stmt == gsi_stmt (psi)) + if (stmt == psi.phi ()) return psi; gcc_unreachable (); @@ -2011,7 +2012,7 @@ insert_out_of_ssa_copy (scop_p scop, tree res, tree expr, gimple after_stmt) gimple_seq stmts; gimple_stmt_iterator gsi; tree var = force_gimple_operand (expr, &stmts, true, NULL_TREE); - gimple stmt = gimple_build_assign (unshare_expr (res), var); + gassign *stmt = gimple_build_assign (unshare_expr (res), var); auto_vec<gimple, 3> x; gimple_seq_add_stmt (&stmts, stmt); @@ -2240,10 +2241,10 @@ rewrite_close_phi_out_of_ssa (scop_p scop, gimple_stmt_iterator *psi) dimension array for it. */ static void -rewrite_phi_out_of_ssa (scop_p scop, gimple_stmt_iterator *psi) +rewrite_phi_out_of_ssa (scop_p scop, gphi_iterator *psi) { size_t i; - gimple phi = gsi_stmt (*psi); + gphi *phi = psi->phi (); basic_block bb = gimple_bb (phi); tree res = gimple_phi_result (phi); tree zero_dim_array = create_zero_dim_array (res, "phi_out_of_ssa"); @@ -2274,12 +2275,12 @@ rewrite_phi_out_of_ssa (scop_p scop, gimple_stmt_iterator *psi) form "x = phi (y, y, ..., y)" to "x = y". */ static void -rewrite_degenerate_phi (gimple_stmt_iterator *psi) +rewrite_degenerate_phi (gphi_iterator *psi) { tree rhs; gimple stmt; gimple_stmt_iterator gsi; - gimple phi = gsi_stmt (*psi); + gphi *phi = psi->phi (); tree res = gimple_phi_result (phi); basic_block bb; @@ -2300,14 +2301,14 @@ static void rewrite_reductions_out_of_ssa (scop_p scop) { basic_block bb; - gimple_stmt_iterator psi; + gphi_iterator psi; sese region = SCOP_REGION (scop); FOR_EACH_BB_FN (bb, cfun) if (bb_in_sese_p (bb, region)) for (psi = gsi_start_phis (bb); !gsi_end_p (psi);) { - gimple phi = gsi_stmt (psi); + gphi *phi = psi.phi (); if (virtual_operand_p (gimple_phi_result (phi))) { @@ -2454,7 +2455,7 @@ rewrite_cross_bb_scalar_deps (scop_p scop, gimple_stmt_iterator *gsi) if (gimple_code (use_stmt) == GIMPLE_PHI && (res = true)) { - gimple_stmt_iterator psi = gsi_for_stmt (use_stmt); + gphi_iterator psi = gsi_start_phis (gimple_bb (use_stmt)); if (scalar_close_phi_node_p (gsi_stmt (psi))) rewrite_close_phi_out_of_ssa (scop, &psi); @@ -2623,7 +2624,7 @@ is_reduction_operation_p (gimple stmt) /* Returns true when PHI contains an argument ARG. */ static bool -phi_contains_arg (gimple phi, tree arg) +phi_contains_arg (gphi *phi, tree arg) { size_t i; @@ -2636,7 +2637,7 @@ phi_contains_arg (gimple phi, tree arg) /* Return a loop phi node that corresponds to a reduction containing LHS. */ -static gimple +static gphi * follow_ssa_with_commutative_ops (tree arg, tree lhs) { gimple stmt; @@ -2650,10 +2651,10 @@ follow_ssa_with_commutative_ops (tree arg, tree lhs) || gimple_code (stmt) == GIMPLE_CALL) return NULL; - if (gimple_code (stmt) == GIMPLE_PHI) + if (gphi *phi = dyn_cast <gphi *> (stmt)) { - if (phi_contains_arg (stmt, lhs)) - return stmt; + if (phi_contains_arg (phi, lhs)) + return phi; return NULL; } @@ -2665,7 +2666,8 @@ follow_ssa_with_commutative_ops (tree arg, tree lhs) if (is_reduction_operation_p (stmt)) { - gimple res = follow_ssa_with_commutative_ops (gimple_assign_rhs1 (stmt), lhs); + gphi *res + = follow_ssa_with_commutative_ops (gimple_assign_rhs1 (stmt), lhs); return res ? res : follow_ssa_with_commutative_ops (gimple_assign_rhs2 (stmt), lhs); @@ -2677,12 +2679,12 @@ follow_ssa_with_commutative_ops (tree arg, tree lhs) /* Detect commutative and associative scalar reductions starting at the STMT. Return the phi node of the reduction cycle, or NULL. */ -static gimple +static gphi * detect_commutative_reduction_arg (tree lhs, gimple stmt, tree arg, vec<gimple> *in, vec<gimple> *out) { - gimple phi = follow_ssa_with_commutative_ops (arg, lhs); + gphi *phi = follow_ssa_with_commutative_ops (arg, lhs); if (!phi) return NULL; @@ -2695,7 +2697,7 @@ detect_commutative_reduction_arg (tree lhs, gimple stmt, tree arg, /* Detect commutative and associative scalar reductions starting at STMT. Return the phi node of the reduction cycle, or NULL. */ -static gimple +static gphi * detect_commutative_reduction_assign (gimple stmt, vec<gimple> *in, vec<gimple> *out) { @@ -2708,9 +2710,9 @@ detect_commutative_reduction_assign (gimple stmt, vec<gimple> *in, if (is_reduction_operation_p (stmt)) { - gimple res = detect_commutative_reduction_arg (lhs, stmt, - gimple_assign_rhs1 (stmt), - in, out); + gphi *res = detect_commutative_reduction_arg (lhs, stmt, + gimple_assign_rhs1 (stmt), + in, out); return res ? res : detect_commutative_reduction_arg (lhs, stmt, gimple_assign_rhs2 (stmt), @@ -2722,7 +2724,7 @@ detect_commutative_reduction_assign (gimple stmt, vec<gimple> *in, /* Return a loop phi node that corresponds to a reduction containing LHS. */ -static gimple +static gphi * follow_inital_value_to_phi (tree arg, tree lhs) { gimple stmt; @@ -2732,9 +2734,9 @@ follow_inital_value_to_phi (tree arg, tree lhs) stmt = SSA_NAME_DEF_STMT (arg); - if (gimple_code (stmt) == GIMPLE_PHI - && phi_contains_arg (stmt, lhs)) - return stmt; + if (gphi *phi = dyn_cast <gphi *> (stmt)) + if (phi_contains_arg (phi, lhs)) + return phi; return NULL; } @@ -2744,7 +2746,7 @@ follow_inital_value_to_phi (tree arg, tree lhs) from outside the loop. */ static edge -edge_initial_value_for_loop_phi (gimple phi) +edge_initial_value_for_loop_phi (gphi *phi) { size_t i; @@ -2764,7 +2766,7 @@ edge_initial_value_for_loop_phi (gimple phi) from outside the loop. */ static tree -initial_value_for_loop_phi (gimple phi) +initial_value_for_loop_phi (gphi *phi) { size_t i; @@ -2808,13 +2810,14 @@ used_outside_reduction (tree def, gimple loop_phi) the SCOP starting at the loop closed phi node STMT. Return the phi node of the reduction cycle, or NULL. */ -static gimple +static gphi * detect_commutative_reduction (scop_p scop, gimple stmt, vec<gimple> *in, vec<gimple> *out) { if (scalar_close_phi_node_p (stmt)) { - gimple def, loop_phi, phi, close_phi = stmt; + gimple def; + gphi *loop_phi, *phi, *close_phi = as_a <gphi *> (stmt); tree init, lhs, arg = gimple_phi_arg_def (close_phi, 0); if (TREE_CODE (arg) != SSA_NAME) @@ -2854,10 +2857,10 @@ detect_commutative_reduction (scop_p scop, gimple stmt, vec<gimple> *in, static void translate_scalar_reduction_to_array_for_stmt (scop_p scop, tree red, - gimple stmt, gimple loop_phi) + gimple stmt, gphi *loop_phi) { tree res = gimple_phi_result (loop_phi); - gimple assign = gimple_build_assign (res, unshare_expr (red)); + gassign *assign = gimple_build_assign (res, unshare_expr (red)); gimple_stmt_iterator gsi; insert_stmts (scop, assign, NULL, gsi_after_labels (gimple_bb (loop_phi))); @@ -2872,7 +2875,7 @@ translate_scalar_reduction_to_array_for_stmt (scop_p scop, tree red, the PHI_RESULT. */ static void -remove_phi (gimple phi) +remove_phi (gphi *phi) { imm_use_iterator imm_iter; tree def; @@ -2935,7 +2938,7 @@ dr_indices_valid_in_loop (tree ref ATTRIBUTE_UNUSED, tree *index, void *data) NULL_TREE. */ static tree -close_phi_written_to_memory (gimple close_phi) +close_phi_written_to_memory (gphi *close_phi) { imm_use_iterator imm_iter; use_operand_p use_p; @@ -2990,30 +2993,33 @@ translate_scalar_reduction_to_array (scop_p scop, vec<gimple> in, vec<gimple> out) { - gimple loop_phi; + gimple loop_stmt; unsigned int i = out.length () - 1; - tree red = close_phi_written_to_memory (out[i]); + tree red = close_phi_written_to_memory (as_a <gphi *> (out[i])); - FOR_EACH_VEC_ELT (in, i, loop_phi) + FOR_EACH_VEC_ELT (in, i, loop_stmt) { - gimple close_phi = out[i]; + gimple close_stmt = out[i]; if (i == 0) { - gimple stmt = loop_phi; - basic_block bb = split_reduction_stmt (scop, stmt); + basic_block bb = split_reduction_stmt (scop, loop_stmt); poly_bb_p pbb = pbb_from_bb (bb); PBB_IS_REDUCTION (pbb) = true; - gcc_assert (close_phi == loop_phi); + gcc_assert (close_stmt == loop_stmt); if (!red) red = create_zero_dim_array - (gimple_assign_lhs (stmt), "Commutative_Associative_Reduction"); + (gimple_assign_lhs (loop_stmt), "Commutative_Associative_Reduction"); - translate_scalar_reduction_to_array_for_stmt (scop, red, stmt, in[1]); + translate_scalar_reduction_to_array_for_stmt (scop, red, loop_stmt, + as_a <gphi *> (in[1])); continue; } + gphi *loop_phi = as_a <gphi *> (loop_stmt); + gphi *close_phi = as_a <gphi *> (close_stmt); + if (i == in.length () - 1) { insert_out_of_ssa_copy (scop, gimple_phi_result (close_phi), @@ -3033,7 +3039,7 @@ translate_scalar_reduction_to_array (scop_p scop, static bool rewrite_commutative_reductions_out_of_ssa_close_phi (scop_p scop, - gimple close_phi) + gphi *close_phi) { bool res; auto_vec<gimple, 10> in; @@ -3054,7 +3060,7 @@ static bool rewrite_commutative_reductions_out_of_ssa_loop (scop_p scop, loop_p loop) { - gimple_stmt_iterator gsi; + gphi_iterator gsi; edge exit = single_exit (loop); tree res; bool changed = false; @@ -3063,11 +3069,11 @@ rewrite_commutative_reductions_out_of_ssa_loop (scop_p scop, return false; for (gsi = gsi_start_phis (exit->dest); !gsi_end_p (gsi); gsi_next (&gsi)) - if ((res = gimple_phi_result (gsi_stmt (gsi))) + if ((res = gimple_phi_result (gsi.phi ())) && !virtual_operand_p (res) && !scev_analyzable_p (res, SCOP_REGION (scop))) changed |= rewrite_commutative_reductions_out_of_ssa_close_phi - (scop, gsi_stmt (gsi)); + (scop, gsi.phi ()); return changed; } @@ -3104,7 +3110,7 @@ static bool scop_ivs_can_be_represented (scop_p scop) { loop_p loop; - gimple_stmt_iterator psi; + gphi_iterator psi; bool result = true; FOR_EACH_LOOP (loop, 0) @@ -3115,7 +3121,7 @@ scop_ivs_can_be_represented (scop_p scop) for (psi = gsi_start_phis (loop->header); !gsi_end_p (psi); gsi_next (&psi)) { - gimple phi = gsi_stmt (psi); + gphi *phi = psi.phi (); tree res = PHI_RESULT (phi); tree type = TREE_TYPE (res); |