diff options
Diffstat (limited to 'gcc/tree-vect-analyze.c')
| -rw-r--r-- | gcc/tree-vect-analyze.c | 413 |
1 files changed, 212 insertions, 201 deletions
diff --git a/gcc/tree-vect-analyze.c b/gcc/tree-vect-analyze.c index 818ae7ce53f..c9753a0598d 100644 --- a/gcc/tree-vect-analyze.c +++ b/gcc/tree-vect-analyze.c @@ -75,10 +75,10 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo) struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo); int nbbs = loop->num_nodes; - block_stmt_iterator si; + gimple_stmt_iterator si; unsigned int vectorization_factor = 0; tree scalar_type; - tree phi; + gimple phi; tree vectype; unsigned int nunits; stmt_vec_info stmt_info; @@ -91,13 +91,14 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo) { basic_block bb = bbs[i]; - for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi)) + for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si)) { + phi = gsi_stmt (si); stmt_info = vinfo_for_stmt (phi); if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "==> examining phi: "); - print_generic_expr (vect_dump, phi, TDF_SLIM); + print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM); } gcc_assert (stmt_info); @@ -142,15 +143,15 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo) } } - for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si)) + for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si)) { - tree stmt = bsi_stmt (si); + gimple stmt = gsi_stmt (si); stmt_info = vinfo_for_stmt (stmt); if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "==> examining statement: "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } gcc_assert (stmt_info); @@ -164,23 +165,22 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo) continue; } - if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT) + if (gimple_get_lhs (stmt) == NULL_TREE) { if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS)) { fprintf (vect_dump, "not vectorized: irregular stmt."); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } return false; } - if (!GIMPLE_STMT_P (stmt) - && VECTOR_MODE_P (TYPE_MODE (TREE_TYPE (stmt)))) + if (VECTOR_MODE_P (TYPE_MODE (gimple_expr_type (stmt)))) { if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS)) { fprintf (vect_dump, "not vectorized: vector stmt in loop:"); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } return false; } @@ -196,7 +196,6 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo) } else { - tree operation; gcc_assert (! STMT_VINFO_DATA_REF (stmt_info) && !is_pattern_stmt_p (stmt_info)); @@ -216,16 +215,16 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo) cannot rely on invariant motion to always take invariants out of the loop, and so in the case of promotion we also have to check the rhs. */ - scalar_type = TREE_TYPE (GIMPLE_STMT_OPERAND (stmt, 0)); + scalar_type = gimple_expr_type (stmt); - operation = GIMPLE_STMT_OPERAND (stmt, 1); - if (CONVERT_EXPR_P (operation) - || TREE_CODE (operation) == WIDEN_MULT_EXPR - || TREE_CODE (operation) == FLOAT_EXPR) + if (is_gimple_assign (stmt) + && (gimple_assign_cast_p (stmt) + || gimple_assign_rhs_code (stmt) == WIDEN_MULT_EXPR + || gimple_assign_rhs_code (stmt) == FLOAT_EXPR)) { - tree rhs_type = TREE_TYPE (TREE_OPERAND (operation, 0)); - if (TREE_INT_CST_LOW (TYPE_SIZE_UNIT (rhs_type)) < - TREE_INT_CST_LOW (TYPE_SIZE_UNIT (scalar_type))) + tree rhs_type = TREE_TYPE (gimple_assign_rhs1 (stmt)); + if (TREE_INT_CST_LOW (TYPE_SIZE_UNIT (rhs_type)) + < TREE_INT_CST_LOW (TYPE_SIZE_UNIT (scalar_type))) scalar_type = rhs_type; } @@ -315,11 +314,11 @@ vect_analyze_operations (loop_vec_info loop_vinfo) struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo); int nbbs = loop->num_nodes; - block_stmt_iterator si; + gimple_stmt_iterator si; unsigned int vectorization_factor = 0; int i; bool ok; - tree phi; + gimple phi; stmt_vec_info stmt_info; bool need_to_vectorize = false; int min_profitable_iters; @@ -337,15 +336,16 @@ vect_analyze_operations (loop_vec_info loop_vinfo) { basic_block bb = bbs[i]; - for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi)) + for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si)) { + phi = gsi_stmt (si); ok = true; stmt_info = vinfo_for_stmt (phi); if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "examining phi: "); - print_generic_expr (vect_dump, phi, TDF_SLIM); + print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM); } if (! is_loop_header_bb_p (bb)) @@ -398,22 +398,22 @@ vect_analyze_operations (loop_vec_info loop_vinfo) { fprintf (vect_dump, "not vectorized: relevant phi not supported: "); - print_generic_expr (vect_dump, phi, TDF_SLIM); + print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM); } return false; } } - for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si)) + for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si)) { - tree stmt = bsi_stmt (si); + gimple stmt = gsi_stmt (si); stmt_vec_info stmt_info = vinfo_for_stmt (stmt); enum vect_def_type relevance = STMT_VINFO_RELEVANT (stmt_info); if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "==> examining statement: "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } gcc_assert (stmt_info); @@ -454,8 +454,7 @@ vect_analyze_operations (loop_vec_info loop_vinfo) if (STMT_VINFO_RELEVANT_P (stmt_info)) { - gcc_assert (GIMPLE_STMT_P (stmt) - || !VECTOR_MODE_P (TYPE_MODE (TREE_TYPE (stmt)))); + gcc_assert (!VECTOR_MODE_P (TYPE_MODE (gimple_expr_type (stmt)))); gcc_assert (STMT_VINFO_VECTYPE (stmt_info)); need_to_vectorize = true; } @@ -480,7 +479,7 @@ vect_analyze_operations (loop_vec_info loop_vinfo) { fprintf (vect_dump, "not vectorized: relevant stmt not "); fprintf (vect_dump, "supported: "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } return false; } @@ -497,7 +496,7 @@ vect_analyze_operations (loop_vec_info loop_vinfo) { fprintf (vect_dump, "not vectorized: live stmt not "); fprintf (vect_dump, "supported: "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } return false; } @@ -520,7 +519,7 @@ vect_analyze_operations (loop_vec_info loop_vinfo) { fprintf (vect_dump, "not vectorized: the size of group " "of strided accesses is not a power of 2"); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } return false; } @@ -649,7 +648,7 @@ vect_analyze_operations (loop_vec_info loop_vinfo) used in STMT for anything other than indexing an array. */ static bool -exist_non_indexing_operands_for_use_p (tree use, tree stmt) +exist_non_indexing_operands_for_use_p (tree use, gimple stmt) { tree operand; stmt_vec_info stmt_info = vinfo_for_stmt (stmt); @@ -673,10 +672,12 @@ exist_non_indexing_operands_for_use_p (tree use, tree stmt) Therefore, all we need to check is if STMT falls into the first case, and whether var corresponds to USE. */ - if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == SSA_NAME) + if (TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME) return false; - operand = GIMPLE_STMT_OPERAND (stmt, 1); + if (!gimple_assign_copy_p (stmt)) + return false; + operand = gimple_assign_rhs1 (stmt); if (TREE_CODE (operand) != SSA_NAME) return false; @@ -698,17 +699,18 @@ exist_non_indexing_operands_for_use_p (tree use, tree stmt) static void vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop) { - tree phi; basic_block bb = loop->header; tree dumy; - VEC(tree,heap) *worklist = VEC_alloc (tree, heap, 64); + VEC(gimple,heap) *worklist = VEC_alloc (gimple, heap, 64); + gimple_stmt_iterator gsi; if (vect_print_dump_info (REPORT_DETAILS)) fprintf (vect_dump, "=== vect_analyze_scalar_cycles ==="); /* First - identify all inductions. */ - for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi)) + for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) { + gimple phi = gsi_stmt (gsi); tree access_fn = NULL; tree def = PHI_RESULT (phi); stmt_vec_info stmt_vinfo = vinfo_for_stmt (phi); @@ -716,7 +718,7 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop) if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "Analyze phi: "); - print_generic_expr (vect_dump, phi, TDF_SLIM); + print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM); } /* Skip virtual phi's. The data dependences that are associated with @@ -737,7 +739,7 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop) if (!access_fn || !vect_is_simple_iv_evolution (loop->num, access_fn, &dumy, &dumy)) { - VEC_safe_push (tree, heap, worklist, phi); + VEC_safe_push (gimple, heap, worklist, phi); continue; } @@ -748,17 +750,17 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop) /* Second - identify all reductions. */ - while (VEC_length (tree, worklist) > 0) + while (VEC_length (gimple, worklist) > 0) { - tree phi = VEC_pop (tree, worklist); + gimple phi = VEC_pop (gimple, worklist); tree def = PHI_RESULT (phi); stmt_vec_info stmt_vinfo = vinfo_for_stmt (phi); - tree reduc_stmt; + gimple reduc_stmt; if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "Analyze phi: "); - print_generic_expr (vect_dump, phi, TDF_SLIM); + print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM); } gcc_assert (is_gimple_reg (SSA_NAME_VAR (def))); @@ -778,7 +780,7 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop) fprintf (vect_dump, "Unknown def-use cycle pattern."); } - VEC_free (tree, heap, worklist); + VEC_free (gimple, heap, worklist); return; } @@ -833,7 +835,8 @@ static void vect_insert_into_interleaving_chain (struct data_reference *dra, struct data_reference *drb) { - tree prev, next, next_init; + gimple prev, next; + tree next_init; stmt_vec_info stmtinfo_a = vinfo_for_stmt (DR_STMT (dra)); stmt_vec_info stmtinfo_b = vinfo_for_stmt (DR_STMT (drb)); @@ -855,7 +858,7 @@ vect_insert_into_interleaving_chain (struct data_reference *dra, /* We got to the end of the list. Insert here. */ DR_GROUP_NEXT_DR (vinfo_for_stmt (prev)) = DR_STMT (dra); - DR_GROUP_NEXT_DR (stmtinfo_a) = NULL_TREE; + DR_GROUP_NEXT_DR (stmtinfo_a) = NULL; } @@ -888,8 +891,10 @@ vect_update_interleaving_chain (struct data_reference *drb, { stmt_vec_info stmtinfo_a = vinfo_for_stmt (DR_STMT (dra)); stmt_vec_info stmtinfo_b = vinfo_for_stmt (DR_STMT (drb)); - tree next_init, init_dra_chain, init_drb_chain, first_a, first_b; - tree node, prev, next, node_init, first_stmt; + tree next_init, init_dra_chain, init_drb_chain; + gimple first_a, first_b; + tree node_init; + gimple node, prev, next, first_stmt; /* 1. New stmts - both DRA and DRB are not a part of any chain. */ if (!DR_GROUP_FIRST_DR (stmtinfo_a) && !DR_GROUP_FIRST_DR (stmtinfo_b)) @@ -912,10 +917,10 @@ vect_update_interleaving_chain (struct data_reference *drb, /* 3. DRA is a part of a chain and DRB is not. */ if (DR_GROUP_FIRST_DR (stmtinfo_a) && !DR_GROUP_FIRST_DR (stmtinfo_b)) { - tree old_first_stmt = DR_GROUP_FIRST_DR (stmtinfo_a); + gimple old_first_stmt = DR_GROUP_FIRST_DR (stmtinfo_a); tree init_old = DR_INIT (STMT_VINFO_DATA_REF (vinfo_for_stmt ( old_first_stmt))); - tree tmp; + gimple tmp; if (tree_int_cst_compare (init_old, DR_INIT (drb)) > 0) { @@ -991,7 +996,7 @@ vect_update_interleaving_chain (struct data_reference *drb, { /* We got to the end of the list. Insert here. */ DR_GROUP_NEXT_DR (vinfo_for_stmt (prev)) = node; - DR_GROUP_NEXT_DR (vinfo_for_stmt (node)) = NULL_TREE; + DR_GROUP_NEXT_DR (vinfo_for_stmt (node)) = NULL; prev = node; } DR_GROUP_FIRST_DR (vinfo_for_stmt (node)) = first_stmt; @@ -1122,8 +1127,8 @@ vect_check_interleaving (struct data_reference *dra, static bool vect_same_range_drs (data_reference_p dr_i, data_reference_p dr_j) { - tree stmt_i = DR_STMT (dr_i); - tree stmt_j = DR_STMT (dr_j); + gimple stmt_i = DR_STMT (dr_i); + gimple stmt_j = DR_STMT (dr_j); if (operand_equal_p (DR_REF (dr_i), DR_REF (dr_j), 0) || (DR_GROUP_FIRST_DR (vinfo_for_stmt (stmt_i)) @@ -1351,7 +1356,7 @@ vect_analyze_data_ref_dependences (loop_vec_info loop_vinfo) static bool vect_compute_data_ref_alignment (struct data_reference *dr) { - tree stmt = DR_STMT (dr); + gimple stmt = DR_STMT (dr); stmt_vec_info stmt_info = vinfo_for_stmt (stmt); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); @@ -1570,7 +1575,7 @@ vect_verify_datarefs_alignment (loop_vec_info loop_vinfo) for (i = 0; VEC_iterate (data_reference_p, datarefs, i, dr); i++) { - tree stmt = DR_STMT (dr); + gimple stmt = DR_STMT (dr); stmt_vec_info stmt_info = vinfo_for_stmt (stmt); /* For interleaving, only the alignment of the first access matters. */ @@ -1608,7 +1613,7 @@ vect_verify_datarefs_alignment (loop_vec_info loop_vinfo) static bool vector_alignment_reachable_p (struct data_reference *dr) { - tree stmt = DR_STMT (dr); + gimple stmt = DR_STMT (dr); stmt_vec_info stmt_info = vinfo_for_stmt (stmt); tree vectype = STMT_VINFO_VECTYPE (stmt_info); @@ -1773,7 +1778,7 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo) bool do_peeling = false; bool do_versioning = false; bool stat; - tree stmt; + gimple stmt; stmt_vec_info stmt_info; int vect_versioning_for_alias_required; @@ -1857,7 +1862,7 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo) { int mis; int npeel = 0; - tree stmt = DR_STMT (dr0); + gimple stmt = DR_STMT (dr0); stmt_vec_info stmt_info = vinfo_for_stmt (stmt); tree vectype = STMT_VINFO_VECTYPE (stmt_info); int nelements = TYPE_VECTOR_SUBPARTS (vectype); @@ -1973,12 +1978,12 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo) if (!supportable_dr_alignment) { - tree stmt; + gimple stmt; int mask; tree vectype; if (known_alignment_for_access_p (dr) - || VEC_length (tree, + || VEC_length (gimple, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)) >= (unsigned) PARAM_VALUE (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS)) { @@ -2004,29 +2009,29 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo) gcc_assert (!LOOP_VINFO_PTR_MASK (loop_vinfo) || LOOP_VINFO_PTR_MASK (loop_vinfo) == mask); LOOP_VINFO_PTR_MASK (loop_vinfo) = mask; - VEC_safe_push (tree, heap, + VEC_safe_push (gimple, heap, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo), DR_STMT (dr)); } } /* Versioning requires at least one misaligned data reference. */ - if (VEC_length (tree, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)) == 0) + if (VEC_length (gimple, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)) == 0) do_versioning = false; else if (!do_versioning) - VEC_truncate (tree, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo), 0); + VEC_truncate (gimple, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo), 0); } if (do_versioning) { - VEC(tree,heap) *may_misalign_stmts + VEC(gimple,heap) *may_misalign_stmts = LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo); - tree stmt; + gimple stmt; /* It can now be assumed that the data references in the statements in LOOP_VINFO_MAY_MISALIGN_STMTS will be aligned in the version of the loop being vectorized. */ - for (i = 0; VEC_iterate (tree, may_misalign_stmts, i, stmt); i++) + for (i = 0; VEC_iterate (gimple, may_misalign_stmts, i, stmt); i++) { stmt_vec_info stmt_info = vinfo_for_stmt (stmt); dr = STMT_VINFO_DATA_REF (stmt_info); @@ -2088,7 +2093,7 @@ vect_analyze_group_access (struct data_reference *dr) tree step = DR_STEP (dr); tree scalar_type = TREE_TYPE (DR_REF (dr)); HOST_WIDE_INT type_size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (scalar_type)); - tree stmt = DR_STMT (dr); + gimple stmt = DR_STMT (dr); stmt_vec_info stmt_info = vinfo_for_stmt (stmt); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); HOST_WIDE_INT dr_step = TREE_INT_CST_LOW (step); @@ -2132,12 +2137,12 @@ vect_analyze_group_access (struct data_reference *dr) if (DR_GROUP_FIRST_DR (vinfo_for_stmt (stmt)) == stmt) { /* First stmt in the interleaving chain. Check the chain. */ - tree next = DR_GROUP_NEXT_DR (vinfo_for_stmt (stmt)); + gimple next = DR_GROUP_NEXT_DR (vinfo_for_stmt (stmt)); struct data_reference *data_ref = dr; unsigned int count = 1; tree next_step; tree prev_init = DR_INIT (data_ref); - tree prev = stmt; + gimple prev = stmt; HOST_WIDE_INT diff, count_in_bytes; while (next) @@ -2280,7 +2285,7 @@ vect_analyze_group_access (struct data_reference *dr) /* SLP: create an SLP data structure for every interleaving group of stores for further analysis in vect_analyse_slp. */ if (!DR_IS_READ (dr) && !slp_impossible) - VEC_safe_push (tree, heap, LOOP_VINFO_STRIDED_STORES (loop_vinfo), stmt); + VEC_safe_push (gimple, heap, LOOP_VINFO_STRIDED_STORES (loop_vinfo), stmt); } return true; @@ -2296,7 +2301,7 @@ vect_analyze_data_ref_access (struct data_reference *dr) { tree step = DR_STEP (dr); tree scalar_type = TREE_TYPE (DR_REF (dr)); - tree stmt = DR_STMT (dr); + gimple stmt = DR_STMT (dr); stmt_vec_info stmt_info = vinfo_for_stmt (stmt); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); @@ -2317,7 +2322,7 @@ vect_analyze_data_ref_access (struct data_reference *dr) { /* Interleaved accesses are not yet supported within outer-loop vectorization for references in the inner-loop. */ - DR_GROUP_FIRST_DR (vinfo_for_stmt (stmt)) = NULL_TREE; + DR_GROUP_FIRST_DR (vinfo_for_stmt (stmt)) = NULL; /* For the rest of the analysis we use the outer-loop step. */ step = STMT_VINFO_DR_STEP (stmt_info); @@ -2338,7 +2343,7 @@ vect_analyze_data_ref_access (struct data_reference *dr) if (!tree_int_cst_compare (step, TYPE_SIZE_UNIT (scalar_type))) { /* Mark that it is not interleaving. */ - DR_GROUP_FIRST_DR (vinfo_for_stmt (stmt)) = NULL_TREE; + DR_GROUP_FIRST_DR (vinfo_for_stmt (stmt)) = NULL; return true; } @@ -2470,23 +2475,23 @@ vect_free_slp_tree (slp_tree node) if (SLP_TREE_RIGHT (node)) vect_free_slp_tree (SLP_TREE_RIGHT (node)); - VEC_free (tree, heap, SLP_TREE_SCALAR_STMTS (node)); + VEC_free (gimple, heap, SLP_TREE_SCALAR_STMTS (node)); if (SLP_TREE_VEC_STMTS (node)) - VEC_free (tree, heap, SLP_TREE_VEC_STMTS (node)); + VEC_free (gimple, heap, SLP_TREE_VEC_STMTS (node)); free (node); } -/* Get the defs for the RHS (collect them in DEF_STMTS0/1), check that they are - of a legal type and that they match the defs of the first stmt of the SLP - group (stored in FIRST_STMT_...). */ +/* Get the defs for the rhs of STMT (collect them in DEF_STMTS0/1), check that + they are of a legal type and that they match the defs of the first stmt of + the SLP group (stored in FIRST_STMT_...). */ static bool vect_get_and_check_slp_defs (loop_vec_info loop_vinfo, slp_tree slp_node, - tree rhs, VEC (tree, heap) **def_stmts0, - VEC (tree, heap) **def_stmts1, + gimple stmt, VEC (gimple, heap) **def_stmts0, + VEC (gimple, heap) **def_stmts1, enum vect_def_type *first_stmt_dt0, enum vect_def_type *first_stmt_dt1, tree *first_stmt_def0_type, @@ -2495,25 +2500,20 @@ vect_get_and_check_slp_defs (loop_vec_info loop_vinfo, slp_tree slp_node, int ncopies_for_cost) { tree oprnd; - enum operation_type op_type = TREE_OPERAND_LENGTH (rhs); - unsigned int i, number_of_oprnds = op_type; - tree def, def_stmt; + unsigned int i, number_of_oprnds; + tree def; + gimple def_stmt; enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type}; stmt_vec_info stmt_info = - vinfo_for_stmt (VEC_index (tree, SLP_TREE_SCALAR_STMTS (slp_node), 0)); + vinfo_for_stmt (VEC_index (gimple, SLP_TREE_SCALAR_STMTS (slp_node), 0)); + enum gimple_rhs_class rhs_class; - /* Store. */ - if (!op_type) - number_of_oprnds = 1; - else - gcc_assert (op_type == unary_op || op_type == binary_op); + rhs_class = get_gimple_rhs_class (gimple_assign_rhs_code (stmt)); + number_of_oprnds = gimple_num_ops (stmt) - 1; /* RHS only */ for (i = 0; i < number_of_oprnds; i++) { - if (op_type) - oprnd = TREE_OPERAND (rhs, i); - else - oprnd = rhs; + oprnd = gimple_op (stmt, i + 1); if (!vect_is_simple_use (oprnd, loop_vinfo, &def_stmt, &def, &dt[i]) || (!def_stmt && dt[i] != vect_constant_def)) @@ -2537,7 +2537,7 @@ vect_get_and_check_slp_defs (loop_vec_info loop_vinfo, slp_tree slp_node, *first_stmt_const_oprnd = oprnd; /* Analyze costs (for the first stmt of the group only). */ - if (op_type) + if (rhs_class != GIMPLE_SINGLE_RHS) /* Not memory operation (we don't call this functions for loads). */ vect_model_simple_cost (stmt_info, ncopies_for_cost, dt, slp_node); else @@ -2600,9 +2600,9 @@ vect_get_and_check_slp_defs (loop_vec_info loop_vinfo, slp_tree slp_node, case vect_loop_def: if (i == 0) - VEC_safe_push (tree, heap, *def_stmts0, def_stmt); + VEC_safe_push (gimple, heap, *def_stmts0, def_stmt); else - VEC_safe_push (tree, heap, *def_stmts1, def_stmt); + VEC_safe_push (gimple, heap, *def_stmts1, def_stmt); break; default: @@ -2634,15 +2634,16 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, slp_tree *node, int *inside_cost, int *outside_cost, int ncopies_for_cost) { - VEC (tree, heap) *def_stmts0 = VEC_alloc (tree, heap, group_size); - VEC (tree, heap) *def_stmts1 = VEC_alloc (tree, heap, group_size); + VEC (gimple, heap) *def_stmts0 = VEC_alloc (gimple, heap, group_size); + VEC (gimple, heap) *def_stmts1 = VEC_alloc (gimple, heap, group_size); unsigned int i; - VEC (tree, heap) *stmts = SLP_TREE_SCALAR_STMTS (*node); - tree stmt = VEC_index (tree, stmts, 0); + VEC (gimple, heap) *stmts = SLP_TREE_SCALAR_STMTS (*node); + gimple stmt = VEC_index (gimple, stmts, 0); enum vect_def_type first_stmt_dt0 = 0, first_stmt_dt1 = 0; - enum tree_code first_stmt_code = 0; + enum tree_code first_stmt_code = 0, rhs_code; tree first_stmt_def1_type = NULL_TREE, first_stmt_def0_type = NULL_TREE; - tree lhs, rhs, prev_stmt = NULL_TREE; + tree lhs; + gimple prev_stmt = NULL; bool stop_recursion = false, need_same_oprnds = false; tree vectype, scalar_type, first_op1 = NULL_TREE; unsigned int vectorization_factor = 0, ncopies; @@ -2654,26 +2655,28 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, slp_tree *node, struct data_reference *first_dr; /* For every stmt in NODE find its def stmt/s. */ - for (i = 0; VEC_iterate (tree, stmts, i, stmt); i++) + for (i = 0; VEC_iterate (gimple, stmts, i, stmt); i++) { if (vect_print_dump_info (REPORT_SLP)) { fprintf (vect_dump, "Build SLP for "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } - if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT) + lhs = gimple_get_lhs (stmt); + if (lhs == NULL_TREE) { if (vect_print_dump_info (REPORT_SLP)) { - fprintf (vect_dump, "Build SLP failed: not MODIFY_STMT "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + fprintf (vect_dump, + "Build SLP failed: not GIMPLE_ASSIGN nor GIMPLE_CALL"); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } return false; } - scalar_type = TREE_TYPE (GIMPLE_STMT_OPERAND (stmt, 0)); + scalar_type = TREE_TYPE (lhs); vectype = get_vectype_for_scalar_type (scalar_type); if (!vectype) { @@ -2698,24 +2701,26 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, slp_tree *node, return false; } - lhs = GIMPLE_STMT_OPERAND (stmt, 0); - rhs = GIMPLE_STMT_OPERAND (stmt, 1); + if (is_gimple_call (stmt)) + rhs_code = CALL_EXPR; + else + rhs_code = gimple_assign_rhs_code (stmt); /* Check the operation. */ if (i == 0) { - first_stmt_code = TREE_CODE (rhs); + first_stmt_code = rhs_code; /* Shift arguments should be equal in all the packed stmts for a vector shift with scalar shift operand. */ - if (TREE_CODE (rhs) == LSHIFT_EXPR || TREE_CODE (rhs) == RSHIFT_EXPR - || TREE_CODE (rhs) == LROTATE_EXPR - || TREE_CODE (rhs) == RROTATE_EXPR) + if (rhs_code == LSHIFT_EXPR || rhs_code == RSHIFT_EXPR + || rhs_code == LROTATE_EXPR + || rhs_code == RROTATE_EXPR) { vec_mode = TYPE_MODE (vectype); /* First see if we have a vector/vector shift. */ - optab = optab_for_tree_code (TREE_CODE (rhs), vectype, + optab = optab_for_tree_code (rhs_code, vectype, optab_vector); if (!optab @@ -2723,7 +2728,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, slp_tree *node, == CODE_FOR_nothing)) { /* No vector/vector shift, try for a vector/scalar shift. */ - optab = optab_for_tree_code (TREE_CODE (rhs), vectype, + optab = optab_for_tree_code (rhs_code, vectype, optab_scalar); if (!optab) @@ -2744,35 +2749,37 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, slp_tree *node, if (!VECTOR_MODE_P (optab_op2_mode)) { need_same_oprnds = true; - first_op1 = TREE_OPERAND (rhs, 1); + first_op1 = gimple_assign_rhs2 (stmt); } } } } else { - if ((first_stmt_code != TREE_CODE (rhs)) - && ((first_stmt_code != IMAGPART_EXPR) || (TREE_CODE (rhs) != REALPART_EXPR)) - && ((first_stmt_code != REALPART_EXPR) || (TREE_CODE (rhs) != IMAGPART_EXPR))) + if (first_stmt_code != rhs_code + && (first_stmt_code != IMAGPART_EXPR + || rhs_code != REALPART_EXPR) + && (first_stmt_code != REALPART_EXPR + || rhs_code != IMAGPART_EXPR)) { if (vect_print_dump_info (REPORT_SLP)) { fprintf (vect_dump, "Build SLP failed: different operation in stmt "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } return false; } if (need_same_oprnds - && !operand_equal_p (first_op1, TREE_OPERAND (rhs, 1), 0)) + && !operand_equal_p (first_op1, gimple_assign_rhs2 (stmt), 0)) { if (vect_print_dump_info (REPORT_SLP)) { fprintf (vect_dump, "Build SLP failed: different shift arguments in "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } return false; @@ -2785,7 +2792,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, slp_tree *node, if (REFERENCE_CLASS_P (lhs)) { /* Store. */ - if (!vect_get_and_check_slp_defs (loop_vinfo, *node, rhs, + if (!vect_get_and_check_slp_defs (loop_vinfo, *node, stmt, &def_stmts0, &def_stmts1, &first_stmt_dt0, &first_stmt_dt1, @@ -2812,7 +2819,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, slp_tree *node, { fprintf (vect_dump, "Build SLP failed: strided " " loads need permutation or have gaps "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } return false; @@ -2826,7 +2833,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, slp_tree *node, { fprintf (vect_dump, "Build SLP failed: unsupported " " unaligned load "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } return false; @@ -2849,7 +2856,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, slp_tree *node, { fprintf (vect_dump, "Build SLP failed: strided " " loads need permutation or have gaps "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } return false; } @@ -2864,13 +2871,13 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, slp_tree *node, } /* Strided access. */ else { - if (REFERENCE_CLASS_P (rhs)) + if (TREE_CODE_CLASS (rhs_code) == tcc_reference) { /* Not strided load. */ if (vect_print_dump_info (REPORT_SLP)) { fprintf (vect_dump, "Build SLP failed: not strided load "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } /* FORNOW: Not strided loads are not supported. */ @@ -2878,22 +2885,23 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, slp_tree *node, } /* Not memory operation. */ - if (!BINARY_CLASS_P (rhs) && !UNARY_CLASS_P (rhs)) + if (TREE_CODE_CLASS (rhs_code) != tcc_binary + && TREE_CODE_CLASS (rhs_code) != tcc_unary) { if (vect_print_dump_info (REPORT_SLP)) { fprintf (vect_dump, "Build SLP failed: operation"); fprintf (vect_dump, " unsupported "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } return false; } /* Find the def-stmts. */ - if (!vect_get_and_check_slp_defs (loop_vinfo, *node, rhs, &def_stmts0, - &def_stmts1, &first_stmt_dt0, - &first_stmt_dt1, + if (!vect_get_and_check_slp_defs (loop_vinfo, *node, stmt, + &def_stmts0, &def_stmts1, + &first_stmt_dt0, &first_stmt_dt1, &first_stmt_def0_type, &first_stmt_def1_type, &first_stmt_const_oprnd, @@ -2953,16 +2961,16 @@ static void vect_print_slp_tree (slp_tree node) { int i; - tree stmt; + gimple stmt; if (!node) return; fprintf (vect_dump, "node "); - for (i = 0; VEC_iterate (tree, SLP_TREE_SCALAR_STMTS (node), i, stmt); i++) + for (i = 0; VEC_iterate (gimple, SLP_TREE_SCALAR_STMTS (node), i, stmt); i++) { fprintf (vect_dump, "\n\tstmt %d ", i); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } fprintf (vect_dump, "\n"); @@ -2980,12 +2988,12 @@ static void vect_mark_slp_stmts (slp_tree node, enum slp_vect_type mark, int j) { int i; - tree stmt; + gimple stmt; if (!node) return; - for (i = 0; VEC_iterate (tree, SLP_TREE_SCALAR_STMTS (node), i, stmt); i++) + for (i = 0; VEC_iterate (gimple, SLP_TREE_SCALAR_STMTS (node), i, stmt); i++) if (j < 0 || i == j) STMT_SLP_TYPE (vinfo_for_stmt (stmt)) = mark; @@ -2999,13 +3007,14 @@ vect_mark_slp_stmts (slp_tree node, enum slp_vect_type mark, int j) Return FALSE if it's impossible to SLP any stmt in the loop. */ static bool -vect_analyze_slp_instance (loop_vec_info loop_vinfo, tree stmt) +vect_analyze_slp_instance (loop_vec_info loop_vinfo, gimple stmt) { slp_instance new_instance; slp_tree node = XNEW (struct _slp_tree); unsigned int group_size = DR_GROUP_SIZE (vinfo_for_stmt (stmt)); unsigned int unrolling_factor = 1, nunits; - tree vectype, scalar_type, next; + tree vectype, scalar_type; + gimple next; unsigned int vectorization_factor = 0, ncopies; bool slp_impossible = false; int inside_cost = 0, outside_cost = 0, ncopies_for_cost; @@ -3035,12 +3044,12 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, tree stmt) } /* Create a node (a root of the SLP tree) for the packed strided stores. */ - SLP_TREE_SCALAR_STMTS (node) = VEC_alloc (tree, heap, group_size); + SLP_TREE_SCALAR_STMTS (node) = VEC_alloc (gimple, heap, group_size); next = stmt; /* Collect the stores and store them in SLP_TREE_SCALAR_STMTS. */ while (next) { - VEC_safe_push (tree, heap, SLP_TREE_SCALAR_STMTS (node), next); + VEC_safe_push (gimple, heap, SLP_TREE_SCALAR_STMTS (node), next); next = DR_GROUP_NEXT_DR (vinfo_for_stmt (next)); } @@ -3098,13 +3107,13 @@ static bool vect_analyze_slp (loop_vec_info loop_vinfo) { unsigned int i; - VEC (tree, heap) *strided_stores = LOOP_VINFO_STRIDED_STORES (loop_vinfo); - tree store; + VEC (gimple, heap) *strided_stores = LOOP_VINFO_STRIDED_STORES (loop_vinfo); + gimple store; if (vect_print_dump_info (REPORT_SLP)) fprintf (vect_dump, "=== vect_analyze_slp ==="); - for (i = 0; VEC_iterate (tree, strided_stores, i, store); i++) + for (i = 0; VEC_iterate (gimple, strided_stores, i, store); i++) if (!vect_analyze_slp_instance (loop_vinfo, store)) { /* SLP failed. No instance can be SLPed in the loop. */ @@ -3160,17 +3169,17 @@ static void vect_detect_hybrid_slp_stmts (slp_tree node) { int i; - tree stmt; + gimple stmt; imm_use_iterator imm_iter; - tree use_stmt; + gimple use_stmt; if (!node) return; - for (i = 0; VEC_iterate (tree, SLP_TREE_SCALAR_STMTS (node), i, stmt); i++) + for (i = 0; VEC_iterate (gimple, SLP_TREE_SCALAR_STMTS (node), i, stmt); i++) if (PURE_SLP_STMT (vinfo_for_stmt (stmt)) - && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == SSA_NAME) - FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, GIMPLE_STMT_OPERAND (stmt, 0)) + && TREE_CODE (gimple_op (stmt, 0)) == SSA_NAME) + FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, gimple_op (stmt, 0)) if (vinfo_for_stmt (use_stmt) && !STMT_SLP_TYPE (vinfo_for_stmt (use_stmt))) vect_mark_slp_stmts (node, hybrid, i); @@ -3233,7 +3242,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo) for (i = 0; VEC_iterate (data_reference_p, datarefs, i, dr); i++) { - tree stmt; + gimple stmt; stmt_vec_info stmt_info; basic_block bb; tree base, offset, init; @@ -3255,7 +3264,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS)) { fprintf (vect_dump, "not vectorized: data ref analysis failed "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } return false; } @@ -3283,7 +3292,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo) init = unshare_expr (DR_INIT (dr)); /* Update DR field in stmt_vec_info struct. */ - bb = bb_for_stmt (stmt); + bb = gimple_bb (stmt); /* If the dataref is in an inner-loop of the loop that is considered for for vectorization, we also want to analyze the access relative to @@ -3394,7 +3403,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo) { fprintf (vect_dump, "not vectorized: more than one data ref in stmt: "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } return false; } @@ -3410,7 +3419,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo) { fprintf (vect_dump, "not vectorized: no vectype for stmt: "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); fprintf (vect_dump, " scalar_type: "); print_generic_expr (vect_dump, scalar_type, TDF_DETAILS); } @@ -3429,7 +3438,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo) Mark STMT as "relevant for vectorization" and add it to WORKLIST. */ static void -vect_mark_relevant (VEC(tree,heap) **worklist, tree stmt, +vect_mark_relevant (VEC(gimple,heap) **worklist, gimple stmt, enum vect_relevant relevant, bool live_p) { stmt_vec_info stmt_info = vinfo_for_stmt (stmt); @@ -3441,7 +3450,7 @@ vect_mark_relevant (VEC(tree,heap) **worklist, tree stmt, if (STMT_VINFO_IN_PATTERN_P (stmt_info)) { - tree pattern_stmt; + gimple pattern_stmt; /* This is the last stmt in a sequence that was detected as a pattern that can potentially be vectorized. Don't mark the stmt @@ -3471,7 +3480,7 @@ vect_mark_relevant (VEC(tree,heap) **worklist, tree stmt, return; } - VEC_safe_push (tree, heap, *worklist, stmt); + VEC_safe_push (gimple, heap, *worklist, stmt); } @@ -3488,7 +3497,7 @@ vect_mark_relevant (VEC(tree,heap) **worklist, tree stmt, CHECKME: what other side effects would the vectorizer allow? */ static bool -vect_stmt_relevant_p (tree stmt, loop_vec_info loop_vinfo, +vect_stmt_relevant_p (gimple stmt, loop_vec_info loop_vinfo, enum vect_relevant *relevant, bool *live_p) { struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); @@ -3506,7 +3515,7 @@ vect_stmt_relevant_p (tree stmt, loop_vec_info loop_vinfo, *relevant = vect_used_in_loop; /* changing memory. */ - if (TREE_CODE (stmt) != PHI_NODE) + if (gimple_code (stmt) != GIMPLE_PHI) if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_VIRTUAL_DEFS)) { if (vect_print_dump_info (REPORT_DETAILS)) @@ -3519,7 +3528,7 @@ vect_stmt_relevant_p (tree stmt, loop_vec_info loop_vinfo, { FOR_EACH_IMM_USE_FAST (use_p, imm_iter, DEF_FROM_PTR (def_p)) { - basic_block bb = bb_for_stmt (USE_STMT (use_p)); + basic_block bb = gimple_bb (USE_STMT (use_p)); if (!flow_bb_inside_loop_p (loop, bb)) { if (vect_print_dump_info (REPORT_DETAILS)) @@ -3527,7 +3536,7 @@ vect_stmt_relevant_p (tree stmt, loop_vec_info loop_vinfo, /* We expect all such uses to be in the loop exit phis (because of loop closed form) */ - gcc_assert (TREE_CODE (USE_STMT (use_p)) == PHI_NODE); + gcc_assert (gimple_code (USE_STMT (use_p)) == GIMPLE_PHI); gcc_assert (bb == single_exit (loop)->dest); *live_p = true; @@ -3565,14 +3574,15 @@ vect_stmt_relevant_p (tree stmt, loop_vec_info loop_vinfo, Return true if everything is as expected. Return false otherwise. */ static bool -process_use (tree stmt, tree use, loop_vec_info loop_vinfo, bool live_p, - enum vect_relevant relevant, VEC(tree,heap) **worklist) +process_use (gimple stmt, tree use, loop_vec_info loop_vinfo, bool live_p, + enum vect_relevant relevant, VEC(gimple,heap) **worklist) { struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt); stmt_vec_info dstmt_vinfo; basic_block bb, def_bb; - tree def, def_stmt; + tree def; + gimple def_stmt; enum vect_def_type dt; /* case 1: we are only interested in uses that need to be vectorized. Uses @@ -3587,10 +3597,10 @@ process_use (tree stmt, tree use, loop_vec_info loop_vinfo, bool live_p, return false; } - if (!def_stmt || IS_EMPTY_STMT (def_stmt)) + if (!def_stmt || gimple_nop_p (def_stmt)) return true; - def_bb = bb_for_stmt (def_stmt); + def_bb = gimple_bb (def_stmt); if (!flow_bb_inside_loop_p (loop, def_bb)) { if (vect_print_dump_info (REPORT_DETAILS)) @@ -3604,10 +3614,10 @@ process_use (tree stmt, tree use, loop_vec_info loop_vinfo, bool live_p, as there should be no other uses for DEF_STMT in the loop. So we just check that everything is as expected, and we are done. */ dstmt_vinfo = vinfo_for_stmt (def_stmt); - bb = bb_for_stmt (stmt); - if (TREE_CODE (stmt) == PHI_NODE + bb = gimple_bb (stmt); + if (gimple_code (stmt) == GIMPLE_PHI && STMT_VINFO_DEF_TYPE (stmt_vinfo) == vect_reduction_def - && TREE_CODE (def_stmt) != PHI_NODE + && gimple_code (def_stmt) != GIMPLE_PHI && STMT_VINFO_DEF_TYPE (dstmt_vinfo) == vect_reduction_def && bb->loop_father == def_bb->loop_father) { @@ -3712,47 +3722,47 @@ process_use (tree stmt, tree use, loop_vec_info loop_vinfo, bool live_p, static bool vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo) { - VEC(tree,heap) *worklist; + VEC(gimple,heap) *worklist; struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo); unsigned int nbbs = loop->num_nodes; - block_stmt_iterator si; - tree stmt; - stmt_ann_t ann; + gimple_stmt_iterator si; + gimple stmt; unsigned int i; stmt_vec_info stmt_vinfo; basic_block bb; - tree phi; + gimple phi; bool live_p; enum vect_relevant relevant; if (vect_print_dump_info (REPORT_DETAILS)) fprintf (vect_dump, "=== vect_mark_stmts_to_be_vectorized ==="); - worklist = VEC_alloc (tree, heap, 64); + worklist = VEC_alloc (gimple, heap, 64); /* 1. Init worklist. */ for (i = 0; i < nbbs; i++) { bb = bbs[i]; - for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi)) + for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si)) { + phi = gsi_stmt (si); if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "init: phi relevant? "); - print_generic_expr (vect_dump, phi, TDF_SLIM); + print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM); } if (vect_stmt_relevant_p (phi, loop_vinfo, &relevant, &live_p)) vect_mark_relevant (&worklist, phi, relevant, live_p); } - for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si)) + for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si)) { - stmt = bsi_stmt (si); + stmt = gsi_stmt (si); if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "init: stmt relevant? "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } if (vect_stmt_relevant_p (stmt, loop_vinfo, &relevant, &live_p)) @@ -3761,22 +3771,21 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo) } /* 2. Process_worklist */ - while (VEC_length (tree, worklist) > 0) + while (VEC_length (gimple, worklist) > 0) { use_operand_p use_p; ssa_op_iter iter; - stmt = VEC_pop (tree, worklist); + stmt = VEC_pop (gimple, worklist); if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "worklist: examine stmt: "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } /* Examine the USEs of STMT. For each USE, mark the stmt that defines it (DEF_STMT) as relevant/irrelevant and live/dead according to the liveness and relevance properties of STMT. */ - ann = stmt_ann (stmt); stmt_vinfo = vinfo_for_stmt (stmt); relevant = STMT_VINFO_RELEVANT (stmt_vinfo); live_p = STMT_VINFO_LIVE_P (stmt_vinfo); @@ -3814,25 +3823,25 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo) switch (tmp_relevant) { case vect_unused_in_loop: - gcc_assert (TREE_CODE (stmt) != PHI_NODE); + gcc_assert (gimple_code (stmt) != GIMPLE_PHI); relevant = vect_used_by_reduction; break; case vect_used_in_outer_by_reduction: case vect_used_in_outer: - gcc_assert (TREE_CODE (stmt) != WIDEN_SUM_EXPR - && TREE_CODE (stmt) != DOT_PROD_EXPR); + gcc_assert (gimple_code (stmt) != WIDEN_SUM_EXPR + && gimple_code (stmt) != DOT_PROD_EXPR); break; case vect_used_by_reduction: - if (TREE_CODE (stmt) == PHI_NODE) + if (gimple_code (stmt) == GIMPLE_PHI) break; /* fall through */ case vect_used_in_loop: default: if (vect_print_dump_info (REPORT_DETAILS)) fprintf (vect_dump, "unsupported use of reduction."); - VEC_free (tree, heap, worklist); + VEC_free (gimple, heap, worklist); return false; } live_p = false; @@ -3843,13 +3852,13 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo) tree op = USE_FROM_PTR (use_p); if (!process_use (stmt, op, loop_vinfo, live_p, relevant, &worklist)) { - VEC_free (tree, heap, worklist); + VEC_free (gimple, heap, worklist); return false; } } } /* while worklist */ - VEC_free (tree, heap, worklist); + VEC_free (gimple, heap, worklist); return true; } @@ -3868,22 +3877,24 @@ vect_can_advance_ivs_p (loop_vec_info loop_vinfo) { struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); basic_block bb = loop->header; - tree phi; + gimple phi; + gimple_stmt_iterator gsi; /* Analyze phi functions of the loop header. */ if (vect_print_dump_info (REPORT_DETAILS)) fprintf (vect_dump, "vect_can_advance_ivs_p:"); - for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi)) + for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) { tree access_fn = NULL; tree evolution_part; + phi = gsi_stmt (gsi); if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "Analyze phi: "); - print_generic_expr (vect_dump, phi, TDF_SLIM); + print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM); } /* Skip virtual phi's. The data dependences that are associated with @@ -3950,7 +3961,7 @@ vect_can_advance_ivs_p (loop_vec_info loop_vinfo) can be constructed, place it in NUMBER_OF_ITERATIONS. Return the loop exit condition. */ -static tree +static gimple vect_get_loop_niters (struct loop *loop, tree *number_of_iterations) { tree niters; @@ -4018,7 +4029,7 @@ loop_vec_info vect_analyze_loop_form (struct loop *loop) { loop_vec_info loop_vinfo; - tree loop_cond; + gimple loop_cond; tree number_of_iterations = NULL; loop_vec_info inner_loop_vinfo = NULL; |