diff options
Diffstat (limited to 'gcc/tree-vect-slp.c')
| -rw-r--r-- | gcc/tree-vect-slp.c | 507 |
1 files changed, 247 insertions, 260 deletions
diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c index 7dd5e93ba15..e6f3da9bdfb 100644 --- a/gcc/tree-vect-slp.c +++ b/gcc/tree-vect-slp.c @@ -73,14 +73,12 @@ vect_free_slp_tree (slp_tree node) if (!node) return; - FOR_EACH_VEC_ELT (slp_void_p, SLP_TREE_CHILDREN (node), i, child) + FOR_EACH_VEC_ELT (SLP_TREE_CHILDREN (node), i, child) vect_free_slp_tree ((slp_tree) child); - VEC_free (slp_void_p, heap, SLP_TREE_CHILDREN (node)); - VEC_free (gimple, heap, SLP_TREE_SCALAR_STMTS (node)); - - if (SLP_TREE_VEC_STMTS (node)) - VEC_free (gimple, heap, SLP_TREE_VEC_STMTS (node)); + SLP_TREE_CHILDREN (node).release (); + SLP_TREE_SCALAR_STMTS (node).release (); + SLP_TREE_VEC_STMTS (node).release (); free (node); } @@ -92,9 +90,9 @@ void vect_free_slp_instance (slp_instance instance) { vect_free_slp_tree (SLP_INSTANCE_TREE (instance)); - VEC_free (int, heap, SLP_INSTANCE_LOAD_PERMUTATION (instance)); - VEC_free (slp_tree, heap, SLP_INSTANCE_LOADS (instance)); - VEC_free (stmt_info_for_cost, heap, SLP_INSTANCE_BODY_COST_VEC (instance)); + SLP_INSTANCE_LOAD_PERMUTATION (instance).release (); + SLP_INSTANCE_LOADS (instance).release (); + SLP_INSTANCE_BODY_COST_VEC (instance).release (); free (instance); } @@ -102,10 +100,10 @@ vect_free_slp_instance (slp_instance instance) /* Create an SLP node for SCALAR_STMTS. */ static slp_tree -vect_create_new_slp_node (VEC (gimple, heap) *scalar_stmts) +vect_create_new_slp_node (vec<gimple> scalar_stmts) { slp_tree node; - gimple stmt = VEC_index (gimple, scalar_stmts, 0); + gimple stmt = scalar_stmts[0]; unsigned int nops; if (is_gimple_call (stmt)) @@ -121,8 +119,8 @@ vect_create_new_slp_node (VEC (gimple, heap) *scalar_stmts) node = XNEW (struct _slp_tree); SLP_TREE_SCALAR_STMTS (node) = scalar_stmts; - SLP_TREE_VEC_STMTS (node) = NULL; - SLP_TREE_CHILDREN (node) = VEC_alloc (slp_void_p, heap, nops); + SLP_TREE_VEC_STMTS (node).create (0); + SLP_TREE_CHILDREN (node).create (nops); return node; } @@ -130,23 +128,23 @@ vect_create_new_slp_node (VEC (gimple, heap) *scalar_stmts) /* Allocate operands info for NOPS operands, and GROUP_SIZE def-stmts for each operand. */ -static VEC (slp_oprnd_info, heap) * +static vec<slp_oprnd_info> vect_create_oprnd_info (int nops, int group_size) { int i; slp_oprnd_info oprnd_info; - VEC (slp_oprnd_info, heap) *oprnds_info; + vec<slp_oprnd_info> oprnds_info; - oprnds_info = VEC_alloc (slp_oprnd_info, heap, nops); + oprnds_info.create (nops); for (i = 0; i < nops; i++) { oprnd_info = XNEW (struct _slp_oprnd_info); - oprnd_info->def_stmts = VEC_alloc (gimple, heap, group_size); + oprnd_info->def_stmts.create (group_size); oprnd_info->first_dt = vect_uninitialized_def; oprnd_info->first_def_type = NULL_TREE; oprnd_info->first_const_oprnd = NULL_TREE; oprnd_info->first_pattern = false; - VEC_quick_push (slp_oprnd_info, oprnds_info, oprnd_info); + oprnds_info.quick_push (oprnd_info); } return oprnds_info; @@ -156,18 +154,18 @@ vect_create_oprnd_info (int nops, int group_size) /* Free operands info. */ static void -vect_free_oprnd_info (VEC (slp_oprnd_info, heap) **oprnds_info) +vect_free_oprnd_info (vec<slp_oprnd_info> &oprnds_info) { int i; slp_oprnd_info oprnd_info; - FOR_EACH_VEC_ELT (slp_oprnd_info, *oprnds_info, i, oprnd_info) + FOR_EACH_VEC_ELT (oprnds_info, i, oprnd_info) { - VEC_free (gimple, heap, oprnd_info->def_stmts); + oprnd_info->def_stmts.release (); XDELETE (oprnd_info); } - VEC_free (slp_oprnd_info, heap, *oprnds_info); + oprnds_info.release (); } @@ -179,7 +177,7 @@ static bool vect_get_and_check_slp_defs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, slp_tree slp_node, gimple stmt, int ncopies_for_cost, bool first, - VEC (slp_oprnd_info, heap) **oprnds_info, + vec<slp_oprnd_info> *oprnds_info, stmt_vector_for_cost *prologue_cost_vec, stmt_vector_for_cost *body_cost_vec) { @@ -226,7 +224,7 @@ vect_get_and_check_slp_defs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, else oprnd = gimple_op (stmt, op_idx++); - oprnd_info = VEC_index (slp_oprnd_info, *oprnds_info, i); + oprnd_info = (*oprnds_info)[i]; if (COMPARISON_CLASS_P (oprnd)) { @@ -373,7 +371,7 @@ vect_get_and_check_slp_defs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, different_types = true; else { - oprnd0_info = VEC_index (slp_oprnd_info, *oprnds_info, 0); + oprnd0_info = (*oprnds_info)[0]; if (is_gimple_assign (stmt) && (rhs_code = gimple_assign_rhs_code (stmt)) && TREE_CODE_CLASS (rhs_code) == tcc_binary @@ -421,15 +419,15 @@ vect_get_and_check_slp_defs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, case vect_internal_def: if (different_types) { - oprnd0_info = VEC_index (slp_oprnd_info, *oprnds_info, 0); - oprnd1_info = VEC_index (slp_oprnd_info, *oprnds_info, 0); + oprnd0_info = (*oprnds_info)[0]; + oprnd1_info = (*oprnds_info)[0]; if (i == 0) - VEC_quick_push (gimple, oprnd1_info->def_stmts, def_stmt); + oprnd1_info->def_stmts.quick_push (def_stmt); else - VEC_quick_push (gimple, oprnd0_info->def_stmts, def_stmt); + oprnd0_info->def_stmts.quick_push (def_stmt); } else - VEC_quick_push (gimple, oprnd_info->def_stmts, def_stmt); + oprnd_info->def_stmts.quick_push (def_stmt); break; @@ -459,15 +457,15 @@ static bool vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, slp_tree *node, unsigned int group_size, int *outside_cost, int ncopies_for_cost, unsigned int *max_nunits, - VEC (int, heap) **load_permutation, - VEC (slp_tree, heap) **loads, + vec<int> *load_permutation, + vec<slp_tree> *loads, unsigned int vectorization_factor, bool *loads_permuted, stmt_vector_for_cost *prologue_cost_vec, stmt_vector_for_cost *body_cost_vec) { unsigned int i; - VEC (gimple, heap) *stmts = SLP_TREE_SCALAR_STMTS (*node); - gimple stmt = VEC_index (gimple, stmts, 0); + vec<gimple> stmts = SLP_TREE_SCALAR_STMTS (*node); + gimple stmt = stmts[0]; enum tree_code first_stmt_code = ERROR_MARK, rhs_code = ERROR_MARK; enum tree_code first_cond_code = ERROR_MARK; tree lhs; @@ -483,7 +481,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, bool permutation = false; unsigned int load_place; gimple first_load = NULL, prev_first_load = NULL, old_first_load = NULL; - VEC (slp_oprnd_info, heap) *oprnds_info; + vec<slp_oprnd_info> oprnds_info; unsigned int nops; slp_oprnd_info oprnd_info; tree cond; @@ -502,7 +500,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, oprnds_info = vect_create_oprnd_info (nops, group_size); /* For every stmt in NODE find its def stmt/s. */ - FOR_EACH_VEC_ELT (gimple, stmts, i, stmt) + FOR_EACH_VEC_ELT (stmts, i, stmt) { if (dump_enabled_p ()) { @@ -520,7 +518,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, dump_gimple_stmt (MSG_MISSED_OPTIMIZATION, TDF_SLIM, stmt, 0); } - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } @@ -535,7 +533,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, dump_gimple_stmt (MSG_MISSED_OPTIMIZATION, TDF_SLIM, stmt, 0); } - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } @@ -552,7 +550,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, dump_gimple_stmt (MSG_MISSED_OPTIMIZATION, TDF_SLIM, stmt, 0); } - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } @@ -568,7 +566,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, scalar_type); } - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } @@ -598,7 +596,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, dump_gimple_stmt (MSG_MISSED_OPTIMIZATION, TDF_SLIM, stmt, 0); } - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } } @@ -634,7 +632,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, if (dump_enabled_p ()) dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, "Build SLP failed: no optab."); - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } icode = (int) optab_handler (optab, vec_mode); @@ -644,7 +642,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, "Build SLP failed: " "op not supported by target."); - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } optab_op2_mode = insn_data[icode].operand[2].mode; @@ -682,7 +680,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, dump_gimple_stmt (MSG_MISSED_OPTIMIZATION, TDF_SLIM, stmt, 0); } - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } @@ -697,13 +695,13 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, dump_gimple_stmt (MSG_MISSED_OPTIMIZATION, TDF_SLIM, stmt, 0); } - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } if (rhs_code == CALL_EXPR) { - gimple first_stmt = VEC_index (gimple, stmts, 0); + gimple first_stmt = stmts[0]; if (gimple_call_num_args (stmt) != nops || !operand_equal_p (gimple_call_fn (first_stmt), gimple_call_fn (stmt), 0) @@ -718,7 +716,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, stmt, 0); } - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } } @@ -736,7 +734,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, prologue_cost_vec, body_cost_vec)) { - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } } @@ -758,7 +756,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, stmt, 0); } - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } @@ -777,7 +775,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, stmt, 0); } - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } @@ -802,7 +800,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, stmt, 0); } - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } } @@ -827,7 +825,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, stmt, 0); } - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } @@ -845,7 +843,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, if (load_place != i) permutation = true; - VEC_safe_push (int, heap, *load_permutation, load_place); + load_permutation->safe_push (load_place); /* We stop the tree when we reach a group of loads. */ stop_recursion = true; @@ -865,7 +863,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, } /* FORNOW: Not grouped loads are not supported. */ - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } @@ -883,7 +881,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, dump_gimple_stmt (MSG_MISSED_OPTIMIZATION, TDF_SLIM, stmt, 0); } - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } @@ -904,7 +902,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, stmt, 0); } - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } } @@ -915,7 +913,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, &oprnds_info, prologue_cost_vec, body_cost_vec)) { - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } } @@ -924,10 +922,10 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, /* Grouped loads were reached - stop the recursion. */ if (stop_recursion) { - VEC_safe_push (slp_tree, heap, *loads, *node); + loads->safe_push (*node); if (permutation) { - gimple first_stmt = VEC_index (gimple, stmts, 0); + gimple first_stmt = stmts[0]; *loads_permuted = true; (void) record_stmt_cost (body_cost_vec, group_size, vec_perm, vinfo_for_stmt (first_stmt), 0, vect_body); @@ -941,12 +939,12 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, *loads_permuted = true; } - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return true; } /* Create SLP_TREE nodes for the definition node/s. */ - FOR_EACH_VEC_ELT (slp_oprnd_info, oprnds_info, i, oprnd_info) + FOR_EACH_VEC_ELT (oprnds_info, i, oprnd_info) { slp_tree child; @@ -962,17 +960,17 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, prologue_cost_vec, body_cost_vec)) { if (child) - oprnd_info->def_stmts = NULL; + oprnd_info->def_stmts = vec<gimple>(); vect_free_slp_tree (child); - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return false; } - oprnd_info->def_stmts = NULL; - VEC_quick_push (slp_void_p, SLP_TREE_CHILDREN (*node), child); + oprnd_info->def_stmts.create (0); + SLP_TREE_CHILDREN (*node).quick_push (child); } - vect_free_oprnd_info (&oprnds_info); + vect_free_oprnd_info (oprnds_info); return true; } @@ -989,14 +987,14 @@ vect_print_slp_tree (int dump_kind, slp_tree node) return; dump_printf (dump_kind, "node "); - FOR_EACH_VEC_ELT (gimple, SLP_TREE_SCALAR_STMTS (node), i, stmt) + FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (node), i, stmt) { dump_printf (dump_kind, "\n\tstmt %d ", i); dump_gimple_stmt (dump_kind, TDF_SLIM, stmt, 0); } dump_printf (dump_kind, "\n"); - FOR_EACH_VEC_ELT (slp_void_p, SLP_TREE_CHILDREN (node), i, child) + FOR_EACH_VEC_ELT (SLP_TREE_CHILDREN (node), i, child) vect_print_slp_tree (dump_kind, (slp_tree) child); } @@ -1016,11 +1014,11 @@ vect_mark_slp_stmts (slp_tree node, enum slp_vect_type mark, int j) if (!node) return; - FOR_EACH_VEC_ELT (gimple, SLP_TREE_SCALAR_STMTS (node), i, stmt) + FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (node), i, stmt) if (j < 0 || i == j) STMT_SLP_TYPE (vinfo_for_stmt (stmt)) = mark; - FOR_EACH_VEC_ELT (slp_void_p, SLP_TREE_CHILDREN (node), i, child) + FOR_EACH_VEC_ELT (SLP_TREE_CHILDREN (node), i, child) vect_mark_slp_stmts ((slp_tree) child, mark, j); } @@ -1038,7 +1036,7 @@ vect_mark_slp_stmts_relevant (slp_tree node) if (!node) return; - FOR_EACH_VEC_ELT (gimple, SLP_TREE_SCALAR_STMTS (node), i, stmt) + FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (node), i, stmt) { stmt_info = vinfo_for_stmt (stmt); gcc_assert (!STMT_VINFO_RELEVANT (stmt_info) @@ -1046,7 +1044,7 @@ vect_mark_slp_stmts_relevant (slp_tree node) STMT_VINFO_RELEVANT (stmt_info) = vect_used_in_scope; } - FOR_EACH_VEC_ELT (slp_void_p, SLP_TREE_CHILDREN (node), i, child) + FOR_EACH_VEC_ELT (SLP_TREE_CHILDREN (node), i, child) vect_mark_slp_stmts_relevant ((slp_tree) child); } @@ -1057,10 +1055,10 @@ vect_mark_slp_stmts_relevant (slp_tree node) static bool vect_supported_slp_permutation_p (slp_instance instance) { - slp_tree node = VEC_index (slp_tree, SLP_INSTANCE_LOADS (instance), 0); - gimple stmt = VEC_index (gimple, SLP_TREE_SCALAR_STMTS (node), 0); + slp_tree node = SLP_INSTANCE_LOADS (instance)[0]; + gimple stmt = SLP_TREE_SCALAR_STMTS (node)[0]; gimple first_load = GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)); - VEC (slp_tree, heap) *sorted_loads = NULL; + vec<slp_tree> sorted_loads = vec<slp_tree>(); int index; slp_tree *tmp_loads = NULL; int group_size = SLP_INSTANCE_GROUP_SIZE (instance), i, j; @@ -1072,11 +1070,11 @@ vect_supported_slp_permutation_p (slp_instance instance) Sort the nodes according to the order of accesses in the chain. */ tmp_loads = (slp_tree *) xmalloc (sizeof (slp_tree) * group_size); for (i = 0, j = 0; - VEC_iterate (int, SLP_INSTANCE_LOAD_PERMUTATION (instance), i, index) - && VEC_iterate (slp_tree, SLP_INSTANCE_LOADS (instance), j, load); + SLP_INSTANCE_LOAD_PERMUTATION (instance).iterate (i, &index) + && SLP_INSTANCE_LOADS (instance).iterate (j, &load); i += group_size, j++) { - gimple scalar_stmt = VEC_index (gimple, SLP_TREE_SCALAR_STMTS (load), 0); + gimple scalar_stmt = SLP_TREE_SCALAR_STMTS (load)[0]; /* Check that the loads are all in the same interleaving chain. */ if (GROUP_FIRST_ELEMENT (vinfo_for_stmt (scalar_stmt)) != first_load) { @@ -1096,15 +1094,15 @@ vect_supported_slp_permutation_p (slp_instance instance) tmp_loads[index] = load; } - sorted_loads = VEC_alloc (slp_tree, heap, group_size); + sorted_loads.create (group_size); for (i = 0; i < group_size; i++) - VEC_safe_push (slp_tree, heap, sorted_loads, tmp_loads[i]); + sorted_loads.safe_push (tmp_loads[i]); - VEC_free (slp_tree, heap, SLP_INSTANCE_LOADS (instance)); + SLP_INSTANCE_LOADS (instance).release (); SLP_INSTANCE_LOADS (instance) = sorted_loads; free (tmp_loads); - if (!vect_transform_slp_perm_load (stmt, NULL, NULL, + if (!vect_transform_slp_perm_load (stmt, vec<tree>(), NULL, SLP_INSTANCE_UNROLLING_FACTOR (instance), instance, true)) return false; @@ -1117,32 +1115,32 @@ vect_supported_slp_permutation_p (slp_instance instance) static void vect_slp_rearrange_stmts (slp_tree node, unsigned int group_size, - VEC (int, heap) *permutation) + vec<int> permutation) { gimple stmt; - VEC (gimple, heap) *tmp_stmts; + vec<gimple> tmp_stmts; unsigned int index, i; slp_void_p child; if (!node) return; - FOR_EACH_VEC_ELT (slp_void_p, SLP_TREE_CHILDREN (node), i, child) + FOR_EACH_VEC_ELT (SLP_TREE_CHILDREN (node), i, child) vect_slp_rearrange_stmts ((slp_tree) child, group_size, permutation); - gcc_assert (group_size == VEC_length (gimple, SLP_TREE_SCALAR_STMTS (node))); - tmp_stmts = VEC_alloc (gimple, heap, group_size); + gcc_assert (group_size == SLP_TREE_SCALAR_STMTS (node).length ()); + tmp_stmts.create (group_size); for (i = 0; i < group_size; i++) - VEC_safe_push (gimple, heap, tmp_stmts, NULL); + tmp_stmts.safe_push (NULL); - FOR_EACH_VEC_ELT (gimple, SLP_TREE_SCALAR_STMTS (node), i, stmt) + FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (node), i, stmt) { - index = VEC_index (int, permutation, i); - VEC_replace (gimple, tmp_stmts, index, stmt); + index = permutation[i]; + tmp_stmts[index] = stmt; } - VEC_free (gimple, heap, SLP_TREE_SCALAR_STMTS (node)); + SLP_TREE_SCALAR_STMTS (node).release (); SLP_TREE_SCALAR_STMTS (node) = tmp_stmts; } @@ -1154,7 +1152,7 @@ vect_slp_rearrange_stmts (slp_tree node, unsigned int group_size, static bool vect_supported_load_permutation_p (slp_instance slp_instn, int group_size, - VEC (int, heap) *load_permutation) + vec<int> load_permutation) { int i = 0, j, prev = -1, next, k, number_of_groups; bool supported, bad_permutation = false; @@ -1172,7 +1170,7 @@ vect_supported_load_permutation_p (slp_instance slp_instn, int group_size, if (dump_enabled_p ()) { dump_printf_loc (MSG_NOTE, vect_location, "Load permutation "); - FOR_EACH_VEC_ELT (int, load_permutation, i, next) + FOR_EACH_VEC_ELT (load_permutation, i, next) dump_printf (MSG_NOTE, "%d ", next); } @@ -1184,13 +1182,12 @@ vect_supported_load_permutation_p (slp_instance slp_instn, int group_size, permutation). */ /* Check that all the load nodes are of the same size. */ - FOR_EACH_VEC_ELT (slp_tree, SLP_INSTANCE_LOADS (slp_instn), i, node) + FOR_EACH_VEC_ELT (SLP_INSTANCE_LOADS (slp_instn), i, node) { - if (VEC_length (gimple, SLP_TREE_SCALAR_STMTS (node)) - != (unsigned) group_size) + if (SLP_TREE_SCALAR_STMTS (node).length () != (unsigned) group_size) return false; - stmt = VEC_index (gimple, SLP_TREE_SCALAR_STMTS (node), 0); + stmt = SLP_TREE_SCALAR_STMTS (node)[0]; if (is_gimple_assign (stmt) && (gimple_assign_rhs_code (stmt) == REALPART_EXPR || gimple_assign_rhs_code (stmt) == IMAGPART_EXPR)) @@ -1205,9 +1202,9 @@ vect_supported_load_permutation_p (slp_instance slp_instn, int group_size, chains are mixed, they match the above pattern. */ if (complex_numbers) { - FOR_EACH_VEC_ELT (slp_tree, SLP_INSTANCE_LOADS (slp_instn), i, node) + FOR_EACH_VEC_ELT (SLP_INSTANCE_LOADS (slp_instn), i, node) { - FOR_EACH_VEC_ELT (gimple, SLP_TREE_SCALAR_STMTS (node), j, stmt) + FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (node), j, stmt) { if (j == 0) first = stmt; @@ -1223,10 +1220,9 @@ vect_supported_load_permutation_p (slp_instance slp_instn, int group_size, else k = 0; - other_complex_node = VEC_index (slp_tree, - SLP_INSTANCE_LOADS (slp_instn), k); - other_node_first = VEC_index (gimple, - SLP_TREE_SCALAR_STMTS (other_complex_node), 0); + other_complex_node = SLP_INSTANCE_LOADS (slp_instn)[k]; + other_node_first = + SLP_TREE_SCALAR_STMTS (other_complex_node)[0]; if (GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)) != other_node_first) @@ -1240,20 +1236,20 @@ vect_supported_load_permutation_p (slp_instance slp_instn, int group_size, /* We checked that this case ok, so there is no need to proceed with permutation tests. */ if (complex_numbers == 2 - && VEC_length (slp_tree, SLP_INSTANCE_LOADS (slp_instn)) == 2) + && SLP_INSTANCE_LOADS (slp_instn).length () == 2) { - VEC_free (slp_tree, heap, SLP_INSTANCE_LOADS (slp_instn)); - VEC_free (int, heap, SLP_INSTANCE_LOAD_PERMUTATION (slp_instn)); + SLP_INSTANCE_LOADS (slp_instn).release (); + SLP_INSTANCE_LOAD_PERMUTATION (slp_instn).release (); return true; } node = SLP_INSTANCE_TREE (slp_instn); - stmt = VEC_index (gimple, SLP_TREE_SCALAR_STMTS (node), 0); + stmt = SLP_TREE_SCALAR_STMTS (node)[0]; /* LOAD_PERMUTATION is a list of indices of all the loads of the SLP instance, not all the loads belong to the same node or interleaving group. Hence, we need to divide them into groups according to GROUP_SIZE. */ - number_of_groups = VEC_length (int, load_permutation) / group_size; + number_of_groups = load_permutation.length () / group_size; /* Reduction (there are no data-refs in the root). In reduction chain the order of the loads is important. */ @@ -1268,8 +1264,8 @@ vect_supported_load_permutation_p (slp_instance slp_instn, int group_size, k = 0; for (j = i * group_size; j < i * group_size + group_size; j++) { - next = VEC_index (int, load_permutation, j); - first_group_load_index = VEC_index (int, load_permutation, k); + next = load_permutation[j]; + first_group_load_index = load_permutation[k]; if (next != first_group_load_index) { @@ -1292,7 +1288,7 @@ vect_supported_load_permutation_p (slp_instance slp_instn, int group_size, bitmap_clear (load_index); for (k = 0; k < group_size; k++) { - first_group_load_index = VEC_index (int, load_permutation, k); + first_group_load_index = load_permutation[k]; if (bitmap_bit_p (load_index, first_group_load_index)) { bad_permutation = true; @@ -1321,7 +1317,7 @@ vect_supported_load_permutation_p (slp_instance slp_instn, int group_size, according to the order of the loads. */ vect_slp_rearrange_stmts (SLP_INSTANCE_TREE (slp_instn), group_size, load_permutation); - VEC_free (int, heap, SLP_INSTANCE_LOAD_PERMUTATION (slp_instn)); + SLP_INSTANCE_LOAD_PERMUTATION (slp_instn).release (); return true; } } @@ -1334,11 +1330,11 @@ vect_supported_load_permutation_p (slp_instance slp_instn, int group_size, /* Check that for every node in the instance the loads form a subchain. */ if (bb_vinfo) { - FOR_EACH_VEC_ELT (slp_tree, SLP_INSTANCE_LOADS (slp_instn), i, node) + FOR_EACH_VEC_ELT (SLP_INSTANCE_LOADS (slp_instn), i, node) { next_load = NULL; first_load = NULL; - FOR_EACH_VEC_ELT (gimple, SLP_TREE_SCALAR_STMTS (node), j, load) + FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (node), j, load) { if (!first_load) first_load = GROUP_FIRST_ELEMENT (vinfo_for_stmt (load)); @@ -1366,9 +1362,9 @@ vect_supported_load_permutation_p (slp_instance slp_instn, int group_size, the first statement in every load node, is supported. */ if (!bad_permutation) { - FOR_EACH_VEC_ELT (slp_tree, SLP_INSTANCE_LOADS (slp_instn), i, node) + FOR_EACH_VEC_ELT (SLP_INSTANCE_LOADS (slp_instn), i, node) { - first_load = VEC_index (gimple, SLP_TREE_SCALAR_STMTS (node), 0); + first_load = SLP_TREE_SCALAR_STMTS (node)[0]; if (first_load != GROUP_FIRST_ELEMENT (vinfo_for_stmt (first_load))) { @@ -1392,7 +1388,7 @@ vect_supported_load_permutation_p (slp_instance slp_instn, int group_size, if (!bad_permutation) { - VEC_free (int, heap, SLP_INSTANCE_LOAD_PERMUTATION (slp_instn)); + SLP_INSTANCE_LOAD_PERMUTATION (slp_instn).release (); return true; } } @@ -1401,7 +1397,7 @@ vect_supported_load_permutation_p (slp_instance slp_instn, int group_size, /* FORNOW: the only supported permutation is 0..01..1.. of length equal to GROUP_SIZE and where each sequence of same drs is of GROUP_SIZE length as well (unless it's reduction). */ - if (VEC_length (int, load_permutation) + if (load_permutation.length () != (unsigned int) (group_size * group_size)) return false; @@ -1411,7 +1407,7 @@ vect_supported_load_permutation_p (slp_instance slp_instn, int group_size, for (j = 0; j < group_size; j++) { for (i = j * group_size, k = 0; - VEC_iterate (int, load_permutation, i, next) && k < group_size; + load_permutation.iterate (i, &next) && k < group_size; i++, k++) { if (i != j * group_size && next != prev) @@ -1460,8 +1456,8 @@ vect_find_first_load_in_slp_instance (slp_instance instance) slp_tree load_node; gimple first_load = NULL, load; - FOR_EACH_VEC_ELT (slp_tree, SLP_INSTANCE_LOADS (instance), i, load_node) - FOR_EACH_VEC_ELT (gimple, SLP_TREE_SCALAR_STMTS (load_node), j, load) + FOR_EACH_VEC_ELT (SLP_INSTANCE_LOADS (instance), i, load_node) + FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (load_node), j, load) first_load = get_earlier_stmt (load, first_load); return first_load; @@ -1478,9 +1474,7 @@ vect_find_last_store_in_slp_instance (slp_instance instance) gimple last_store = NULL, store; node = SLP_INSTANCE_TREE (instance); - for (i = 0; - VEC_iterate (gimple, SLP_TREE_SCALAR_STMTS (node), i, store); - i++) + for (i = 0; SLP_TREE_SCALAR_STMTS (node).iterate (i, &store); i++) last_store = get_later_stmt (store, last_store); return last_store; @@ -1504,11 +1498,11 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, unsigned int vectorization_factor = 0; int outside_cost = 0, ncopies_for_cost, i; unsigned int max_nunits = 0; - VEC (int, heap) *load_permutation; - VEC (slp_tree, heap) *loads; + vec<int> load_permutation; + vec<slp_tree> loads; struct data_reference *dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt)); bool loads_permuted = false; - VEC (gimple, heap) *scalar_stmts; + vec<gimple> scalar_stmts; stmt_vector_for_cost body_cost_vec, prologue_cost_vec; stmt_info_for_cost *si; @@ -1531,7 +1525,7 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, { gcc_assert (loop_vinfo); vectype = STMT_VINFO_VECTYPE (vinfo_for_stmt (stmt)); - group_size = VEC_length (gimple, LOOP_VINFO_REDUCTIONS (loop_vinfo)); + group_size = LOOP_VINFO_REDUCTIONS (loop_vinfo).length (); } if (!vectype) @@ -1565,7 +1559,7 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, } /* Create a node (a root of the SLP tree) for the packed grouped stores. */ - scalar_stmts = VEC_alloc (gimple, heap, group_size); + scalar_stmts.create (group_size); next = stmt; if (GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt))) { @@ -1574,19 +1568,19 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, { if (STMT_VINFO_IN_PATTERN_P (vinfo_for_stmt (next)) && STMT_VINFO_RELATED_STMT (vinfo_for_stmt (next))) - VEC_safe_push (gimple, heap, scalar_stmts, - STMT_VINFO_RELATED_STMT (vinfo_for_stmt (next))); + scalar_stmts.safe_push ( + STMT_VINFO_RELATED_STMT (vinfo_for_stmt (next))); else - VEC_safe_push (gimple, heap, scalar_stmts, next); + scalar_stmts.safe_push (next); next = GROUP_NEXT_ELEMENT (vinfo_for_stmt (next)); } } else { /* Collect reduction statements. */ - VEC (gimple, heap) *reductions = LOOP_VINFO_REDUCTIONS (loop_vinfo); - for (i = 0; VEC_iterate (gimple, reductions, i, next); i++) - VEC_safe_push (gimple, heap, scalar_stmts, next); + vec<gimple> reductions = LOOP_VINFO_REDUCTIONS (loop_vinfo); + for (i = 0; reductions.iterate (i, &next); i++) + scalar_stmts.safe_push (next); } node = vect_create_new_slp_node (scalar_stmts); @@ -1596,10 +1590,10 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, GROUP_SIZE / NUNITS otherwise. */ ncopies_for_cost = unrolling_factor * group_size / nunits; - load_permutation = VEC_alloc (int, heap, group_size * group_size); - loads = VEC_alloc (slp_tree, heap, group_size); - prologue_cost_vec = VEC_alloc (stmt_info_for_cost, heap, 10); - body_cost_vec = VEC_alloc (stmt_info_for_cost, heap, 10); + load_permutation.create (group_size * group_size); + loads.create (group_size); + prologue_cost_vec.create (10); + body_cost_vec.create (10); /* Build the tree for the SLP instance. */ if (vect_build_slp_tree (loop_vinfo, bb_vinfo, &node, group_size, @@ -1623,10 +1617,10 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, "Build SLP failed: unrolling required in basic" " block SLP"); vect_free_slp_tree (node); - VEC_free (stmt_info_for_cost, heap, body_cost_vec); - VEC_free (stmt_info_for_cost, heap, prologue_cost_vec); - VEC_free (int, heap, load_permutation); - VEC_free (slp_tree, heap, loads); + body_cost_vec.release (); + prologue_cost_vec.release (); + load_permutation.release (); + loads.release (); return false; } @@ -1654,7 +1648,7 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, } vect_free_slp_instance (new_instance); - VEC_free (stmt_info_for_cost, heap, prologue_cost_vec); + prologue_cost_vec.release (); return false; } @@ -1662,12 +1656,12 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, = vect_find_first_load_in_slp_instance (new_instance); } else - VEC_free (int, heap, SLP_INSTANCE_LOAD_PERMUTATION (new_instance)); + SLP_INSTANCE_LOAD_PERMUTATION (new_instance).release (); /* Record the prologue costs, which were delayed until we were sure that SLP was successful. Unlike the body costs, we know the final values now regardless of the loop vectorization factor. */ - FOR_EACH_VEC_ELT (stmt_info_for_cost, prologue_cost_vec, i, si) + FOR_EACH_VEC_ELT (prologue_cost_vec, i, si) { struct _stmt_vec_info *stmt_info = si->stmt ? vinfo_for_stmt (si->stmt) : NULL; @@ -1675,15 +1669,12 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, si->misalign, vect_prologue); } - VEC_free (stmt_info_for_cost, heap, prologue_cost_vec); + prologue_cost_vec.release (); if (loop_vinfo) - VEC_safe_push (slp_instance, heap, - LOOP_VINFO_SLP_INSTANCES (loop_vinfo), - new_instance); + LOOP_VINFO_SLP_INSTANCES (loop_vinfo).safe_push (new_instance); else - VEC_safe_push (slp_instance, heap, BB_VINFO_SLP_INSTANCES (bb_vinfo), - new_instance); + BB_VINFO_SLP_INSTANCES (bb_vinfo).safe_push (new_instance); if (dump_enabled_p ()) vect_print_slp_tree (MSG_NOTE, node); @@ -1692,15 +1683,15 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, } else { - VEC_free (stmt_info_for_cost, heap, body_cost_vec); - VEC_free (stmt_info_for_cost, heap, prologue_cost_vec); + body_cost_vec.release (); + prologue_cost_vec.release (); } /* Failed to SLP. */ /* Free the allocated memory. */ vect_free_slp_tree (node); - VEC_free (int, heap, load_permutation); - VEC_free (slp_tree, heap, loads); + load_permutation.release (); + loads.release (); return false; } @@ -1713,7 +1704,9 @@ bool vect_analyze_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo) { unsigned int i; - VEC (gimple, heap) *grouped_stores, *reductions = NULL, *reduc_chains = NULL; + vec<gimple> grouped_stores; + vec<gimple> reductions = vec<gimple>(); + vec<gimple> reduc_chains = vec<gimple>(); gimple first_element; bool ok = false; @@ -1730,7 +1723,7 @@ vect_analyze_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo) grouped_stores = BB_VINFO_GROUPED_STORES (bb_vinfo); /* Find SLP sequences starting from groups of grouped stores. */ - FOR_EACH_VEC_ELT (gimple, grouped_stores, i, first_element) + FOR_EACH_VEC_ELT (grouped_stores, i, first_element) if (vect_analyze_slp_instance (loop_vinfo, bb_vinfo, first_element)) ok = true; @@ -1744,10 +1737,10 @@ vect_analyze_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo) } if (loop_vinfo - && VEC_length (gimple, LOOP_VINFO_REDUCTION_CHAINS (loop_vinfo)) > 0) + && LOOP_VINFO_REDUCTION_CHAINS (loop_vinfo).length () > 0) { /* Find SLP sequences starting from reduction chains. */ - FOR_EACH_VEC_ELT (gimple, reduc_chains, i, first_element) + FOR_EACH_VEC_ELT (reduc_chains, i, first_element) if (vect_analyze_slp_instance (loop_vinfo, bb_vinfo, first_element)) ok = true; else @@ -1759,9 +1752,8 @@ vect_analyze_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo) } /* Find SLP sequences starting from groups of reductions. */ - if (loop_vinfo && VEC_length (gimple, LOOP_VINFO_REDUCTIONS (loop_vinfo)) > 1 - && vect_analyze_slp_instance (loop_vinfo, bb_vinfo, - VEC_index (gimple, reductions, 0))) + if (loop_vinfo && LOOP_VINFO_REDUCTIONS (loop_vinfo).length () > 1 + && vect_analyze_slp_instance (loop_vinfo, bb_vinfo, reductions[0])) ok = true; return true; @@ -1776,14 +1768,14 @@ bool vect_make_slp_decision (loop_vec_info loop_vinfo) { unsigned int i, unrolling_factor = 1; - VEC (slp_instance, heap) *slp_instances = LOOP_VINFO_SLP_INSTANCES (loop_vinfo); + vec<slp_instance> slp_instances = LOOP_VINFO_SLP_INSTANCES (loop_vinfo); slp_instance instance; int decided_to_slp = 0; if (dump_enabled_p ()) dump_printf_loc (MSG_NOTE, vect_location, "=== vect_make_slp_decision ==="); - FOR_EACH_VEC_ELT (slp_instance, slp_instances, i, instance) + FOR_EACH_VEC_ELT (slp_instances, i, instance) { /* FORNOW: SLP if you can. */ if (unrolling_factor < SLP_INSTANCE_UNROLLING_FACTOR (instance)) @@ -1814,8 +1806,8 @@ static void vect_detect_hybrid_slp_stmts (slp_tree node) { int i; - VEC (gimple, heap) *stmts = SLP_TREE_SCALAR_STMTS (node); - gimple stmt = VEC_index (gimple, stmts, 0); + vec<gimple> stmts = SLP_TREE_SCALAR_STMTS (node); + gimple stmt = stmts[0]; imm_use_iterator imm_iter; gimple use_stmt; stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt); @@ -1833,7 +1825,7 @@ vect_detect_hybrid_slp_stmts (slp_tree node) else bb = BB_VINFO_BB (bb_vinfo); - FOR_EACH_VEC_ELT (gimple, SLP_TREE_SCALAR_STMTS (node), i, stmt) + FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (node), i, stmt) if (PURE_SLP_STMT (vinfo_for_stmt (stmt)) && TREE_CODE (gimple_op (stmt, 0)) == SSA_NAME) FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, gimple_op (stmt, 0)) @@ -1849,7 +1841,7 @@ vect_detect_hybrid_slp_stmts (slp_tree node) == vect_reduction_def)) vect_mark_slp_stmts (node, hybrid, i); - FOR_EACH_VEC_ELT (slp_void_p, SLP_TREE_CHILDREN (node), i, child) + FOR_EACH_VEC_ELT (SLP_TREE_CHILDREN (node), i, child) vect_detect_hybrid_slp_stmts ((slp_tree) child); } @@ -1860,13 +1852,13 @@ void vect_detect_hybrid_slp (loop_vec_info loop_vinfo) { unsigned int i; - VEC (slp_instance, heap) *slp_instances = LOOP_VINFO_SLP_INSTANCES (loop_vinfo); + vec<slp_instance> slp_instances = LOOP_VINFO_SLP_INSTANCES (loop_vinfo); slp_instance instance; if (dump_enabled_p ()) dump_printf_loc (MSG_NOTE, vect_location, "=== vect_detect_hybrid_slp ==="); - FOR_EACH_VEC_ELT (slp_instance, slp_instances, i, instance) + FOR_EACH_VEC_ELT (slp_instances, i, instance) vect_detect_hybrid_slp_stmts (SLP_INSTANCE_TREE (instance)); } @@ -1890,8 +1882,8 @@ new_bb_vec_info (basic_block bb) set_vinfo_for_stmt (stmt, new_stmt_vec_info (stmt, NULL, res)); } - BB_VINFO_GROUPED_STORES (res) = VEC_alloc (gimple, heap, 10); - BB_VINFO_SLP_INSTANCES (res) = VEC_alloc (slp_instance, heap, 2); + BB_VINFO_GROUPED_STORES (res).create (10); + BB_VINFO_SLP_INSTANCES (res).create (2); BB_VINFO_TARGET_COST_DATA (res) = init_cost (NULL); bb->aux = res; @@ -1905,7 +1897,7 @@ new_bb_vec_info (basic_block bb) static void destroy_bb_vec_info (bb_vec_info bb_vinfo) { - VEC (slp_instance, heap) *slp_instances; + vec<slp_instance> slp_instances; slp_instance instance; basic_block bb; gimple_stmt_iterator si; @@ -1928,11 +1920,11 @@ destroy_bb_vec_info (bb_vec_info bb_vinfo) free_data_refs (BB_VINFO_DATAREFS (bb_vinfo)); free_dependence_relations (BB_VINFO_DDRS (bb_vinfo)); - VEC_free (gimple, heap, BB_VINFO_GROUPED_STORES (bb_vinfo)); + BB_VINFO_GROUPED_STORES (bb_vinfo).release (); slp_instances = BB_VINFO_SLP_INSTANCES (bb_vinfo); - FOR_EACH_VEC_ELT (slp_instance, slp_instances, i, instance) + FOR_EACH_VEC_ELT (slp_instances, i, instance) vect_free_slp_instance (instance); - VEC_free (slp_instance, heap, BB_VINFO_SLP_INSTANCES (bb_vinfo)); + BB_VINFO_SLP_INSTANCES (bb_vinfo).release (); destroy_cost_data (BB_VINFO_TARGET_COST_DATA (bb_vinfo)); free (bb_vinfo); bb->aux = NULL; @@ -1953,11 +1945,11 @@ vect_slp_analyze_node_operations (bb_vec_info bb_vinfo, slp_tree node) if (!node) return true; - FOR_EACH_VEC_ELT (slp_void_p, SLP_TREE_CHILDREN (node), i, child) + FOR_EACH_VEC_ELT (SLP_TREE_CHILDREN (node), i, child) if (!vect_slp_analyze_node_operations (bb_vinfo, (slp_tree) child)) return false; - FOR_EACH_VEC_ELT (gimple, SLP_TREE_SCALAR_STMTS (node), i, stmt) + FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (node), i, stmt) { stmt_vec_info stmt_info = vinfo_for_stmt (stmt); gcc_assert (stmt_info); @@ -1977,23 +1969,23 @@ vect_slp_analyze_node_operations (bb_vec_info bb_vinfo, slp_tree node) static bool vect_slp_analyze_operations (bb_vec_info bb_vinfo) { - VEC (slp_instance, heap) *slp_instances = BB_VINFO_SLP_INSTANCES (bb_vinfo); + vec<slp_instance> slp_instances = BB_VINFO_SLP_INSTANCES (bb_vinfo); slp_instance instance; int i; - for (i = 0; VEC_iterate (slp_instance, slp_instances, i, instance); ) + for (i = 0; slp_instances.iterate (i, &instance); ) { if (!vect_slp_analyze_node_operations (bb_vinfo, SLP_INSTANCE_TREE (instance))) { vect_free_slp_instance (instance); - VEC_ordered_remove (slp_instance, slp_instances, i); + slp_instances.ordered_remove (i); } else i++; } - if (!VEC_length (slp_instance, slp_instances)) + if (!slp_instances.length ()) return false; return true; @@ -2004,7 +1996,7 @@ vect_slp_analyze_operations (bb_vec_info bb_vinfo) static bool vect_bb_vectorization_profitable_p (bb_vec_info bb_vinfo) { - VEC (slp_instance, heap) *slp_instances = BB_VINFO_SLP_INSTANCES (bb_vinfo); + vec<slp_instance> slp_instances = BB_VINFO_SLP_INSTANCES (bb_vinfo); slp_instance instance; int i, j; unsigned int vec_inside_cost = 0, vec_outside_cost = 0, scalar_cost = 0; @@ -2019,11 +2011,11 @@ vect_bb_vectorization_profitable_p (bb_vec_info bb_vinfo) stmt_info_for_cost *ci; /* Calculate vector costs. */ - FOR_EACH_VEC_ELT (slp_instance, slp_instances, i, instance) + FOR_EACH_VEC_ELT (slp_instances, i, instance) { body_cost_vec = SLP_INSTANCE_BODY_COST_VEC (instance); - FOR_EACH_VEC_ELT (stmt_info_for_cost, body_cost_vec, j, ci) + FOR_EACH_VEC_ELT (body_cost_vec, j, ci) { stmt_info = ci->stmt ? vinfo_for_stmt (ci->stmt) : NULL; (void) add_stmt_cost (target_cost_data, ci->count, ci->kind, @@ -2084,8 +2076,8 @@ static bb_vec_info vect_slp_analyze_bb_1 (basic_block bb) { bb_vec_info bb_vinfo; - VEC (ddr_p, heap) *ddrs; - VEC (slp_instance, heap) *slp_instances; + vec<ddr_p> ddrs; + vec<slp_instance> slp_instances; slp_instance instance; int i; int min_vf = 2; @@ -2107,7 +2099,7 @@ vect_slp_analyze_bb_1 (basic_block bb) } ddrs = BB_VINFO_DDRS (bb_vinfo); - if (!VEC_length (ddr_p, ddrs)) + if (!ddrs.length ()) { if (dump_enabled_p ()) dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, @@ -2171,7 +2163,7 @@ vect_slp_analyze_bb_1 (basic_block bb) /* Mark all the statements that we want to vectorize as pure SLP and relevant. */ - FOR_EACH_VEC_ELT (slp_instance, slp_instances, i, instance) + FOR_EACH_VEC_ELT (slp_instances, i, instance) { vect_mark_slp_stmts (SLP_INSTANCE_TREE (instance), pure_slp, -1); vect_mark_slp_stmts_relevant (SLP_INSTANCE_TREE (instance)); @@ -2286,7 +2278,7 @@ void vect_update_slp_costs_according_to_vf (loop_vec_info loop_vinfo) { unsigned int i, j, vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo); - VEC (slp_instance, heap) *slp_instances = LOOP_VINFO_SLP_INSTANCES (loop_vinfo); + vec<slp_instance> slp_instances = LOOP_VINFO_SLP_INSTANCES (loop_vinfo); slp_instance instance; stmt_vector_for_cost body_cost_vec; stmt_info_for_cost *si; @@ -2296,7 +2288,7 @@ vect_update_slp_costs_according_to_vf (loop_vec_info loop_vinfo) dump_printf_loc (MSG_NOTE, vect_location, "=== vect_update_slp_costs_according_to_vf ==="); - FOR_EACH_VEC_ELT (slp_instance, slp_instances, i, instance) + FOR_EACH_VEC_ELT (slp_instances, i, instance) { /* We assume that costs are linear in ncopies. */ int ncopies = vf / SLP_INSTANCE_UNROLLING_FACTOR (instance); @@ -2306,7 +2298,7 @@ vect_update_slp_costs_according_to_vf (loop_vec_info loop_vinfo) isn't known beforehand. */ body_cost_vec = SLP_INSTANCE_BODY_COST_VEC (instance); - FOR_EACH_VEC_ELT (stmt_info_for_cost, body_cost_vec, j, si) + FOR_EACH_VEC_ELT (body_cost_vec, j, si) (void) add_stmt_cost (data, si->count * ncopies, si->kind, vinfo_for_stmt (si->stmt), si->misalign, vect_body); @@ -2323,12 +2315,12 @@ vect_update_slp_costs_according_to_vf (loop_vec_info loop_vinfo) static void vect_get_constant_vectors (tree op, slp_tree slp_node, - VEC (tree, heap) **vec_oprnds, + vec<tree> *vec_oprnds, unsigned int op_num, unsigned int number_of_vectors, int reduc_index) { - VEC (gimple, heap) *stmts = SLP_TREE_SCALAR_STMTS (slp_node); - gimple stmt = VEC_index (gimple, stmts, 0); + vec<gimple> stmts = SLP_TREE_SCALAR_STMTS (slp_node); + gimple stmt = stmts[0]; stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt); unsigned nunits; tree vec_cst; @@ -2336,10 +2328,11 @@ vect_get_constant_vectors (tree op, slp_tree slp_node, unsigned j, number_of_places_left_in_vector; tree vector_type; tree vop; - int group_size = VEC_length (gimple, stmts); + int group_size = stmts.length (); unsigned int vec_num, i; unsigned number_of_copies = 1; - VEC (tree, heap) *voprnds = VEC_alloc (tree, heap, number_of_vectors); + vec<tree> voprnds; + voprnds.create (number_of_vectors); bool constant_p, is_store; tree neutral_op = NULL; enum tree_code code = gimple_expr_code (stmt); @@ -2436,7 +2429,7 @@ vect_get_constant_vectors (tree op, slp_tree slp_node, elts = XALLOCAVEC (tree, nunits); for (j = 0; j < number_of_copies; j++) { - for (i = group_size - 1; VEC_iterate (gimple, stmts, i, stmt); i--) + for (i = group_size - 1; stmts.iterate (i, &stmt); i--) { if (is_store) op = gimple_assign_rhs1 (stmt); @@ -2536,20 +2529,18 @@ vect_get_constant_vectors (tree op, slp_tree slp_node, vec_cst = build_vector (vector_type, elts); else { - VEC(constructor_elt,gc) *v; + vec<constructor_elt, va_gc> *v; unsigned k; - v = VEC_alloc (constructor_elt, gc, nunits); + vec_alloc (v, nunits); for (k = 0; k < nunits; ++k) CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, elts[k]); vec_cst = build_constructor (vector_type, v); } - VEC_quick_push (tree, voprnds, - vect_init_vector (stmt, vec_cst, - vector_type, NULL)); + voprnds.quick_push (vect_init_vector (stmt, vec_cst, + vector_type, NULL)); if (ctor_seq != NULL) { - gimple init_stmt - = SSA_NAME_DEF_STMT (VEC_last (tree, voprnds)); + gimple init_stmt = SSA_NAME_DEF_STMT (voprnds.last ()); gimple_stmt_iterator gsi = gsi_for_stmt (init_stmt); gsi_insert_seq_before_without_update (&gsi, ctor_seq, GSI_SAME_STMT); @@ -2561,20 +2552,20 @@ vect_get_constant_vectors (tree op, slp_tree slp_node, /* Since the vectors are created in the reverse order, we should invert them. */ - vec_num = VEC_length (tree, voprnds); + vec_num = voprnds.length (); for (j = vec_num; j != 0; j--) { - vop = VEC_index (tree, voprnds, j - 1); - VEC_quick_push (tree, *vec_oprnds, vop); + vop = voprnds[j - 1]; + vec_oprnds->quick_push (vop); } - VEC_free (tree, heap, voprnds); + voprnds.release (); /* In case that VF is greater than the unrolling factor needed for the SLP group of stmts, NUMBER_OF_VECTORS to be created is greater than NUMBER_OF_SCALARS/NUNITS or NUNITS/NUMBER_OF_SCALARS, and hence we have to replicate the vectors. */ - while (number_of_vectors > VEC_length (tree, *vec_oprnds)) + while (number_of_vectors > vec_oprnds->length ()) { tree neutral_vec = NULL; @@ -2583,12 +2574,12 @@ vect_get_constant_vectors (tree op, slp_tree slp_node, if (!neutral_vec) neutral_vec = build_vector_from_val (vector_type, neutral_op); - VEC_quick_push (tree, *vec_oprnds, neutral_vec); + vec_oprnds->quick_push (neutral_vec); } else { - for (i = 0; VEC_iterate (tree, *vec_oprnds, i, vop) && i < vec_num; i++) - VEC_quick_push (tree, *vec_oprnds, vop); + for (i = 0; vec_oprnds->iterate (i, &vop) && i < vec_num; i++) + vec_oprnds->quick_push (vop); } } } @@ -2598,19 +2589,19 @@ vect_get_constant_vectors (tree op, slp_tree slp_node, vectorized def-stmts. */ static void -vect_get_slp_vect_defs (slp_tree slp_node, VEC (tree,heap) **vec_oprnds) +vect_get_slp_vect_defs (slp_tree slp_node, vec<tree> *vec_oprnds) { tree vec_oprnd; gimple vec_def_stmt; unsigned int i; - gcc_assert (SLP_TREE_VEC_STMTS (slp_node)); + gcc_assert (SLP_TREE_VEC_STMTS (slp_node).exists ()); - FOR_EACH_VEC_ELT (gimple, SLP_TREE_VEC_STMTS (slp_node), i, vec_def_stmt) + FOR_EACH_VEC_ELT (SLP_TREE_VEC_STMTS (slp_node), i, vec_def_stmt) { gcc_assert (vec_def_stmt); vec_oprnd = gimple_get_lhs (vec_def_stmt); - VEC_quick_push (tree, *vec_oprnds, vec_oprnd); + vec_oprnds->quick_push (vec_oprnd); } } @@ -2623,20 +2614,20 @@ vect_get_slp_vect_defs (slp_tree slp_node, VEC (tree,heap) **vec_oprnds) vect_get_slp_vect_defs () to retrieve them. */ void -vect_get_slp_defs (VEC (tree, heap) *ops, slp_tree slp_node, - VEC (slp_void_p, heap) **vec_oprnds, int reduc_index) +vect_get_slp_defs (vec<tree> ops, slp_tree slp_node, + vec<slp_void_p> *vec_oprnds, int reduc_index) { gimple first_stmt, first_def; int number_of_vects = 0, i; unsigned int child_index = 0; HOST_WIDE_INT lhs_size_unit, rhs_size_unit; slp_tree child = NULL; - VEC (tree, heap) *vec_defs; + vec<tree> *vec_defs; tree oprnd, def_lhs; bool vectorized_defs; - first_stmt = VEC_index (gimple, SLP_TREE_SCALAR_STMTS (slp_node), 0); - FOR_EACH_VEC_ELT (tree, ops, i, oprnd) + first_stmt = SLP_TREE_SCALAR_STMTS (slp_node)[0]; + FOR_EACH_VEC_ELT (ops, i, oprnd) { /* For each operand we check if it has vectorized definitions in a child node or we need to create them (for invariants and constants). We @@ -2645,12 +2636,10 @@ vect_get_slp_defs (VEC (tree, heap) *ops, slp_tree slp_node, vect_get_constant_vectors (), and not advance CHILD_INDEX in order to check this child node for the next operand. */ vectorized_defs = false; - if (VEC_length (slp_void_p, SLP_TREE_CHILDREN (slp_node)) > child_index) + if (SLP_TREE_CHILDREN (slp_node).length () > child_index) { - child = (slp_tree) VEC_index (slp_void_p, - SLP_TREE_CHILDREN (slp_node), - child_index); - first_def = VEC_index (gimple, SLP_TREE_SCALAR_STMTS (child), 0); + child = (slp_tree) SLP_TREE_CHILDREN (slp_node)[child_index]; + first_def = SLP_TREE_SCALAR_STMTS (child)[0]; /* In the end of a pattern sequence we have a use of the original stmt, so we need to compare OPRND with the original def. */ @@ -2695,19 +2684,19 @@ vect_get_slp_defs (VEC (tree, heap) *ops, slp_tree slp_node, } /* Allocate memory for vectorized defs. */ - vec_defs = VEC_alloc (tree, heap, number_of_vects); + vec_alloc (vec_defs, number_of_vects); /* For reduction defs we call vect_get_constant_vectors (), since we are looking for initial loop invariant values. */ if (vectorized_defs && reduc_index == -1) /* The defs are already vectorized. */ - vect_get_slp_vect_defs (child, &vec_defs); + vect_get_slp_vect_defs (child, vec_defs); else /* Build vectors from scalar defs. */ - vect_get_constant_vectors (oprnd, slp_node, &vec_defs, i, + vect_get_constant_vectors (oprnd, slp_node, vec_defs, i, number_of_vects, reduc_index); - VEC_quick_push (slp_void_p, *vec_oprnds, (slp_void_p) vec_defs); + vec_oprnds->quick_push ((slp_void_p) vec_defs); /* For reductions, we only need initial values. */ if (reduc_index != -1) @@ -2729,7 +2718,7 @@ static inline void vect_create_mask_and_perm (gimple stmt, gimple next_scalar_stmt, tree mask, int first_vec_indx, int second_vec_indx, gimple_stmt_iterator *gsi, slp_tree node, - tree vectype, VEC(tree,heap) *dr_chain, + tree vectype, vec<tree> dr_chain, int ncopies, int vect_stmts_counter) { tree perm_dest; @@ -2742,15 +2731,15 @@ vect_create_mask_and_perm (gimple stmt, gimple next_scalar_stmt, /* Initialize the vect stmts of NODE to properly insert the generated stmts later. */ - for (i = VEC_length (gimple, SLP_TREE_VEC_STMTS (node)); + for (i = SLP_TREE_VEC_STMTS (node).length (); i < (int) SLP_TREE_NUMBER_OF_VEC_STMTS (node); i++) - VEC_quick_push (gimple, SLP_TREE_VEC_STMTS (node), NULL); + SLP_TREE_VEC_STMTS (node).quick_push (NULL); perm_dest = vect_create_destination_var (gimple_assign_lhs (stmt), vectype); for (i = 0; i < ncopies; i++) { - first_vec = VEC_index (tree, dr_chain, first_vec_indx); - second_vec = VEC_index (tree, dr_chain, second_vec_indx); + first_vec = dr_chain[first_vec_indx]; + second_vec = dr_chain[second_vec_indx]; /* Generate the permute statement. */ perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, perm_dest, @@ -2760,8 +2749,7 @@ vect_create_mask_and_perm (gimple stmt, gimple next_scalar_stmt, vect_finish_stmt_generation (stmt, perm_stmt, gsi); /* Store the vector statement in NODE. */ - VEC_replace (gimple, SLP_TREE_VEC_STMTS (node), - stride * i + vect_stmts_counter, perm_stmt); + SLP_TREE_VEC_STMTS (node)[stride * i + vect_stmts_counter] = perm_stmt; first_vec_indx += stride; second_vec_indx += stride; @@ -2859,7 +2847,7 @@ vect_get_mask_element (gimple stmt, int first_mask_element, int m, If ANALYZE_ONLY is TRUE, only check that it is possible to create valid permute statements for SLP_NODE_INSTANCE. */ bool -vect_transform_slp_perm_load (gimple stmt, VEC (tree, heap) *dr_chain, +vect_transform_slp_perm_load (gimple stmt, vec<tree> dr_chain, gimple_stmt_iterator *gsi, int vf, slp_instance slp_node_instance, bool analyze_only) { @@ -2931,7 +2919,7 @@ vect_transform_slp_perm_load (gimple stmt, VEC (tree, heap) *dr_chain, we need the second and the third vectors: {b1,c1,a2,b2} and {c2,a3,b3,c3}. */ - FOR_EACH_VEC_ELT (slp_tree, SLP_INSTANCE_LOADS (slp_node_instance), i, node) + FOR_EACH_VEC_ELT (SLP_INSTANCE_LOADS (slp_node_instance), i, node) { scalar_index = 0; index = 0; @@ -2991,8 +2979,8 @@ vect_transform_slp_perm_load (gimple stmt, VEC (tree, heap) *dr_chain, second_vec_index = vec_index; } - next_scalar_stmt = VEC_index (gimple, - SLP_TREE_SCALAR_STMTS (node), scalar_index++); + next_scalar_stmt + = SLP_TREE_SCALAR_STMTS (node)[scalar_index++]; vect_create_mask_and_perm (stmt, next_scalar_stmt, mask_vec, first_vec_index, second_vec_index, @@ -3028,11 +3016,11 @@ vect_schedule_slp_instance (slp_tree node, slp_instance instance, if (!node) return false; - FOR_EACH_VEC_ELT (slp_void_p, SLP_TREE_CHILDREN (node), i, child) + FOR_EACH_VEC_ELT (SLP_TREE_CHILDREN (node), i, child) vect_schedule_slp_instance ((slp_tree) child, instance, vectorization_factor); - stmt = VEC_index (gimple, SLP_TREE_SCALAR_STMTS (node), 0); + stmt = SLP_TREE_SCALAR_STMTS (node)[0]; stmt_info = vinfo_for_stmt (stmt); /* VECTYPE is the type of the destination. */ @@ -3049,22 +3037,21 @@ vect_schedule_slp_instance (slp_tree node, slp_instance instance, /* In case of load permutation we have to allocate vectorized statements for all the nodes that participate in that permutation. */ - if (SLP_INSTANCE_LOAD_PERMUTATION (instance)) + if (SLP_INSTANCE_LOAD_PERMUTATION (instance).exists ()) { - FOR_EACH_VEC_ELT (slp_tree, SLP_INSTANCE_LOADS (instance), i, loads_node) + FOR_EACH_VEC_ELT (SLP_INSTANCE_LOADS (instance), i, loads_node) { - if (!SLP_TREE_VEC_STMTS (loads_node)) + if (!SLP_TREE_VEC_STMTS (loads_node).exists ()) { - SLP_TREE_VEC_STMTS (loads_node) = VEC_alloc (gimple, heap, - vec_stmts_size); + SLP_TREE_VEC_STMTS (loads_node).create (vec_stmts_size); SLP_TREE_NUMBER_OF_VEC_STMTS (loads_node) = vec_stmts_size; } } } - if (!SLP_TREE_VEC_STMTS (node)) + if (!SLP_TREE_VEC_STMTS (node).exists ()) { - SLP_TREE_VEC_STMTS (node) = VEC_alloc (gimple, heap, vec_stmts_size); + SLP_TREE_VEC_STMTS (node).create (vec_stmts_size); SLP_TREE_NUMBER_OF_VEC_STMTS (node) = vec_stmts_size; } @@ -3079,7 +3066,7 @@ vect_schedule_slp_instance (slp_tree node, slp_instance instance, if (SLP_INSTANCE_FIRST_LOAD_STMT (instance) && STMT_VINFO_GROUPED_ACCESS (stmt_info) && !REFERENCE_CLASS_P (gimple_get_lhs (stmt)) - && SLP_INSTANCE_LOAD_PERMUTATION (instance)) + && SLP_INSTANCE_LOAD_PERMUTATION (instance).exists ()) si = gsi_for_stmt (SLP_INSTANCE_FIRST_LOAD_STMT (instance)); else if (is_pattern_stmt_p (stmt_info)) si = gsi_for_stmt (STMT_VINFO_RELATED_STMT (stmt_info)); @@ -3128,10 +3115,10 @@ vect_remove_slp_scalar_calls (slp_tree node) if (!node) return; - FOR_EACH_VEC_ELT (slp_void_p, SLP_TREE_CHILDREN (node), i, child) + FOR_EACH_VEC_ELT (SLP_TREE_CHILDREN (node), i, child) vect_remove_slp_scalar_calls ((slp_tree) child); - FOR_EACH_VEC_ELT (gimple, SLP_TREE_SCALAR_STMTS (node), i, stmt) + FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (node), i, stmt) { if (!is_gimple_call (stmt) || gimple_bb (stmt) == NULL) continue; @@ -3156,7 +3143,7 @@ vect_remove_slp_scalar_calls (slp_tree node) bool vect_schedule_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo) { - VEC (slp_instance, heap) *slp_instances; + vec<slp_instance> slp_instances; slp_instance instance; unsigned int i, vf; bool is_store = false; @@ -3172,7 +3159,7 @@ vect_schedule_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo) vf = 1; } - FOR_EACH_VEC_ELT (slp_instance, slp_instances, i, instance) + FOR_EACH_VEC_ELT (slp_instances, i, instance) { /* Schedule the tree of INSTANCE. */ is_store = vect_schedule_slp_instance (SLP_INSTANCE_TREE (instance), @@ -3182,7 +3169,7 @@ vect_schedule_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo) "vectorizing stmts using SLP."); } - FOR_EACH_VEC_ELT (slp_instance, slp_instances, i, instance) + FOR_EACH_VEC_ELT (slp_instances, i, instance) { slp_tree root = SLP_INSTANCE_TREE (instance); gimple store; @@ -3191,7 +3178,7 @@ vect_schedule_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo) vect_remove_slp_scalar_calls (root); - for (j = 0; VEC_iterate (gimple, SLP_TREE_SCALAR_STMTS (root), j, store) + for (j = 0; SLP_TREE_SCALAR_STMTS (root).iterate (j, &store) && j < SLP_INSTANCE_GROUP_SIZE (instance); j++) { if (!STMT_VINFO_DATA_REF (vinfo_for_stmt (store))) |