diff options
Diffstat (limited to 'gcc/tree-vect-transform.c')
| -rw-r--r-- | gcc/tree-vect-transform.c | 1397 |
1 files changed, 742 insertions, 655 deletions
diff --git a/gcc/tree-vect-transform.c b/gcc/tree-vect-transform.c index 1fa786da0b9..362d37cf861 100644 --- a/gcc/tree-vect-transform.c +++ b/gcc/tree-vect-transform.c @@ -46,20 +46,22 @@ along with GCC; see the file COPYING3. If not see #include "real.h" /* Utility functions for the code transformation. */ -static bool vect_transform_stmt (tree, block_stmt_iterator *, bool *, slp_tree); +static bool vect_transform_stmt (gimple, gimple_stmt_iterator *, bool *, + slp_tree); static tree vect_create_destination_var (tree, tree); static tree vect_create_data_ref_ptr - (tree, struct loop*, tree, tree *, tree *, bool, bool *); + (gimple, struct loop*, tree, tree *, gimple *, bool, bool *); static tree vect_create_addr_base_for_vector_ref - (tree, tree *, tree, struct loop *); + (gimple, gimple_seq *, tree, struct loop *); static tree vect_get_new_vect_var (tree, enum vect_var_kind, const char *); -static tree vect_get_vec_def_for_operand (tree, tree, tree *); -static tree vect_init_vector (tree, tree, tree, block_stmt_iterator *); +static tree vect_get_vec_def_for_operand (tree, gimple, tree *); +static tree vect_init_vector (gimple, tree, tree, gimple_stmt_iterator *); static void vect_finish_stmt_generation - (tree stmt, tree vec_stmt, block_stmt_iterator *); + (gimple stmt, gimple vec_stmt, gimple_stmt_iterator *); static bool vect_is_simple_cond (tree, loop_vec_info); -static void vect_create_epilog_for_reduction (tree, tree, enum tree_code, tree); -static tree get_initial_def_for_reduction (tree, tree, tree *); +static void vect_create_epilog_for_reduction (tree, gimple, enum tree_code, + gimple); +static tree get_initial_def_for_reduction (gimple, tree, tree *); /* Utility function dealing with loop peeling (not peeling itself). */ static void vect_generate_tmps_on_preheader @@ -73,7 +75,7 @@ static int vect_min_worthwhile_factor (enum tree_code); static int -cost_for_stmt (tree stmt) +cost_for_stmt (gimple stmt) { stmt_vec_info stmt_info = vinfo_for_stmt (stmt); @@ -148,11 +150,11 @@ vect_estimate_min_profitable_iters (loop_vec_info loop_vinfo) /* Requires loop versioning tests to handle misalignment. */ - if (VEC_length (tree, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo))) + if (VEC_length (gimple, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo))) { /* FIXME: Make cost depend on complexity of individual check. */ vec_outside_cost += - VEC_length (tree, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)); + VEC_length (gimple, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)); if (vect_print_dump_info (REPORT_COST)) fprintf (vect_dump, "cost model: Adding cost of checks for loop " "versioning to treat misalignment.\n"); @@ -168,7 +170,7 @@ vect_estimate_min_profitable_iters (loop_vec_info loop_vinfo) "versioning aliasing.\n"); } - if (VEC_length (tree, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)) + if (VEC_length (gimple, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)) || VEC_length (ddr_p, LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo))) { vec_outside_cost += TARG_COND_TAKEN_BRANCH_COST; @@ -188,7 +190,7 @@ vect_estimate_min_profitable_iters (loop_vec_info loop_vinfo) for (i = 0; i < nbbs; i++) { - block_stmt_iterator si; + gimple_stmt_iterator si; basic_block bb = bbs[i]; if (bb->loop_father == loop->inner) @@ -196,9 +198,9 @@ vect_estimate_min_profitable_iters (loop_vec_info loop_vinfo) else factor = 1; - 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); /* Skip stmts that are not vectorized inside the loop. */ if (!STMT_VINFO_RELEVANT_P (stmt_info) @@ -338,7 +340,7 @@ vect_estimate_min_profitable_iters (loop_vec_info loop_vinfo) if (runtime_test) { /* Cost model check occurs at versioning. */ - if (VEC_length (tree, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)) + if (VEC_length (gimple, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)) || VEC_length (ddr_p, LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo))) scalar_outside_cost += TARG_COND_NOT_TAKEN_BRANCH_COST; else @@ -451,18 +453,34 @@ vect_model_reduction_cost (stmt_vec_info stmt_info, enum tree_code reduc_code, enum tree_code code; optab optab; tree vectype; - tree orig_stmt; + gimple stmt, orig_stmt; tree reduction_op; enum machine_mode mode; - tree operation = GIMPLE_STMT_OPERAND (STMT_VINFO_STMT (stmt_info), 1); - int op_type = TREE_CODE_LENGTH (TREE_CODE (operation)); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); + /* Cost of reduction op inside loop. */ STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info) += ncopies * TARG_VEC_STMT_COST; - reduction_op = TREE_OPERAND (operation, op_type-1); + stmt = STMT_VINFO_STMT (stmt_info); + + switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))) + { + case GIMPLE_SINGLE_RHS: + gcc_assert (TREE_OPERAND_LENGTH (gimple_assign_rhs1 (stmt)) == ternary_op); + reduction_op = TREE_OPERAND (gimple_assign_rhs1 (stmt), 2); + break; + case GIMPLE_UNARY_RHS: + reduction_op = gimple_assign_rhs1 (stmt); + break; + case GIMPLE_BINARY_RHS: + reduction_op = gimple_assign_rhs2 (stmt); + break; + default: + gcc_unreachable (); + } + vectype = get_vectype_for_scalar_type (TREE_TYPE (reduction_op)); if (!vectype) { @@ -480,7 +498,7 @@ vect_model_reduction_cost (stmt_vec_info stmt_info, enum tree_code reduc_code, if (!orig_stmt) orig_stmt = STMT_VINFO_STMT (stmt_info); - code = TREE_CODE (GIMPLE_STMT_OPERAND (orig_stmt, 1)); + code = gimple_assign_rhs_code (orig_stmt); /* Add in cost for initial definition. */ outer_cost += TARG_SCALAR_TO_VEC_COST; @@ -498,7 +516,7 @@ vect_model_reduction_cost (stmt_vec_info stmt_info, enum tree_code reduc_code, { int vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1); tree bitsize = - TYPE_SIZE (TREE_TYPE ( GIMPLE_STMT_OPERAND (orig_stmt, 0))); + TYPE_SIZE (TREE_TYPE (gimple_assign_lhs (orig_stmt))); int element_bitsize = tree_low_cst (bitsize, 1); int nelements = vec_size_in_bits / element_bitsize; @@ -590,7 +608,7 @@ vect_model_simple_cost (stmt_vec_info stmt_info, int ncopies, static int vect_cost_strided_group_size (stmt_vec_info stmt_info) { - tree first_stmt = DR_GROUP_FIRST_DR (stmt_info); + gimple first_stmt = DR_GROUP_FIRST_DR (stmt_info); if (first_stmt == STMT_VINFO_STMT (stmt_info)) return DR_GROUP_SIZE (stmt_info); @@ -661,7 +679,7 @@ vect_model_load_cost (stmt_vec_info stmt_info, int ncopies, slp_tree slp_node) { int group_size; int alignment_support_cheme; - tree first_stmt; + gimple first_stmt; struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info), *first_dr; int inside_cost = 0, outside_cost = 0; @@ -846,21 +864,21 @@ vect_get_new_vect_var (tree type, enum vect_var_kind var_kind, const char *name) FORNOW: We are only handling array accesses with step 1. */ static tree -vect_create_addr_base_for_vector_ref (tree stmt, - tree *new_stmt_list, +vect_create_addr_base_for_vector_ref (gimple stmt, + gimple_seq *new_stmt_list, tree offset, struct loop *loop) { stmt_vec_info stmt_info = vinfo_for_stmt (stmt); struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info); - struct loop *containing_loop = (bb_for_stmt (stmt))->loop_father; + struct loop *containing_loop = (gimple_bb (stmt))->loop_father; tree data_ref_base = unshare_expr (DR_BASE_ADDRESS (dr)); tree base_name; tree data_ref_base_var; - tree new_base_stmt; tree vec_stmt; tree addr_base, addr_expr; - tree dest, new_stmt; + tree dest; + gimple_seq seq = NULL; tree base_offset = unshare_expr (DR_OFFSET (dr)); tree init = unshare_expr (DR_INIT (dr)); tree vect_ptr_type, addr_expr2; @@ -883,17 +901,17 @@ vect_create_addr_base_for_vector_ref (tree stmt, base_name = build_fold_indirect_ref (data_ref_base); data_ref_base_var = create_tmp_var (TREE_TYPE (data_ref_base), "batmp"); add_referenced_var (data_ref_base_var); - data_ref_base = force_gimple_operand (data_ref_base, &new_base_stmt, - true, data_ref_base_var); - append_to_statement_list_force(new_base_stmt, new_stmt_list); + data_ref_base = force_gimple_operand (data_ref_base, &seq, true, + data_ref_base_var); + gimple_seq_add_seq (new_stmt_list, seq); /* Create base_offset */ base_offset = size_binop (PLUS_EXPR, base_offset, init); base_offset = fold_convert (sizetype, base_offset); dest = create_tmp_var (TREE_TYPE (base_offset), "base_off"); add_referenced_var (dest); - base_offset = force_gimple_operand (base_offset, &new_stmt, true, dest); - append_to_statement_list_force (new_stmt, new_stmt_list); + base_offset = force_gimple_operand (base_offset, &seq, true, dest); + gimple_seq_add_seq (new_stmt_list, seq); if (offset) { @@ -903,8 +921,8 @@ vect_create_addr_base_for_vector_ref (tree stmt, offset = fold_build2 (MULT_EXPR, TREE_TYPE (offset), offset, step); base_offset = fold_build2 (PLUS_EXPR, TREE_TYPE (base_offset), base_offset, offset); - base_offset = force_gimple_operand (base_offset, &new_stmt, false, tmp); - append_to_statement_list_force (new_stmt, new_stmt_list); + base_offset = force_gimple_operand (base_offset, &seq, false, tmp); + gimple_seq_add_seq (new_stmt_list, seq); } /* base + base_offset */ @@ -921,8 +939,8 @@ vect_create_addr_base_for_vector_ref (tree stmt, addr_expr2 = vect_get_new_vect_var (vect_ptr_type, vect_pointer_var, get_name (base_name)); add_referenced_var (addr_expr2); - vec_stmt = force_gimple_operand (vec_stmt, &new_stmt, false, addr_expr2); - append_to_statement_list_force (new_stmt, new_stmt_list); + vec_stmt = force_gimple_operand (vec_stmt, &seq, false, addr_expr2); + gimple_seq_add_seq (new_stmt_list, seq); if (vect_print_dump_info (REPORT_DETAILS)) { @@ -944,8 +962,8 @@ vect_create_addr_base_for_vector_ref (tree stmt, Input: 1. STMT: a stmt that references memory. Expected to be of the form - GIMPLE_MODIFY_STMT <name, data-ref> or - GIMPLE_MODIFY_STMT <data-ref, name>. + GIMPLE_ASSIGN <name, data-ref> or + GIMPLE_ASSIGN <data-ref, name>. 2. AT_LOOP: the loop where the vector memref is to be created. 3. OFFSET (optional): an offset to be added to the initial address accessed by the data-ref in STMT. @@ -978,8 +996,8 @@ vect_create_addr_base_for_vector_ref (tree stmt, 4. Return the pointer. */ static tree -vect_create_data_ref_ptr (tree stmt, struct loop *at_loop, - tree offset, tree *initial_address, tree *ptr_incr, +vect_create_data_ref_ptr (gimple stmt, struct loop *at_loop, + tree offset, tree *initial_address, gimple *ptr_incr, bool only_init, bool *inv_p) { tree base_name; @@ -987,23 +1005,23 @@ vect_create_data_ref_ptr (tree stmt, struct loop *at_loop, loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); bool nested_in_vect_loop = nested_in_vect_loop_p (loop, stmt); - struct loop *containing_loop = (bb_for_stmt (stmt))->loop_father; + struct loop *containing_loop = (gimple_bb (stmt))->loop_father; tree vectype = STMT_VINFO_VECTYPE (stmt_info); tree vect_ptr_type; tree vect_ptr; tree tag; tree new_temp; - tree vec_stmt; - tree new_stmt_list = NULL_TREE; + gimple vec_stmt; + gimple_seq new_stmt_list = NULL; edge pe; basic_block new_bb; tree vect_ptr_init; struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info); tree vptr; - block_stmt_iterator incr_bsi; + gimple_stmt_iterator incr_gsi; bool insert_after; tree indx_before_incr, indx_after_incr; - tree incr; + gimple incr; tree step; /* Check the step (evolution) of the load in LOOP, and record @@ -1020,7 +1038,7 @@ vect_create_data_ref_ptr (tree stmt, struct loop *at_loop, /* Create an expression for the first address accessed by this load in LOOP. */ - base_name = build_fold_indirect_ref (unshare_expr (DR_BASE_ADDRESS (dr))); + base_name = build_fold_indirect_ref (unshare_expr (DR_BASE_ADDRESS (dr))); if (vect_print_dump_info (REPORT_DETAILS)) { @@ -1099,18 +1117,18 @@ vect_create_data_ref_ptr (tree stmt, struct loop *at_loop, pe = loop_preheader_edge (loop); if (new_stmt_list) { - new_bb = bsi_insert_on_edge_immediate (pe, new_stmt_list); + new_bb = gsi_insert_seq_on_edge_immediate (pe, new_stmt_list); gcc_assert (!new_bb); } *initial_address = new_temp; /* Create: p = (vectype *) initial_base */ - vec_stmt = fold_convert (vect_ptr_type, new_temp); - vec_stmt = build_gimple_modify_stmt (vect_ptr, vec_stmt); + vec_stmt = gimple_build_assign (vect_ptr, + fold_convert (vect_ptr_type, new_temp)); vect_ptr_init = make_ssa_name (vect_ptr, vec_stmt); - GIMPLE_STMT_OPERAND (vec_stmt, 0) = vect_ptr_init; - new_bb = bsi_insert_on_edge_immediate (pe, vec_stmt); + gimple_assign_set_lhs (vec_stmt, vect_ptr_init); + new_bb = gsi_insert_on_edge_immediate (pe, vec_stmt); gcc_assert (!new_bb); @@ -1135,15 +1153,14 @@ vect_create_data_ref_ptr (tree stmt, struct loop *at_loop, if (*inv_p) step = size_zero_node; - standard_iv_increment_position (loop, &incr_bsi, &insert_after); + standard_iv_increment_position (loop, &incr_gsi, &insert_after); create_iv (vect_ptr_init, fold_convert (vect_ptr_type, step), - NULL_TREE, loop, &incr_bsi, insert_after, + NULL_TREE, loop, &incr_gsi, insert_after, &indx_before_incr, &indx_after_incr); - incr = bsi_stmt (incr_bsi); - set_stmt_info (stmt_ann (incr), - new_stmt_vec_info (incr, loop_vinfo)); + incr = gsi_stmt (incr_gsi); + set_vinfo_for_stmt (incr, new_stmt_vec_info (incr, loop_vinfo)); /* Copy the points-to information if it exists. */ if (DR_PTR_INFO (dr)) @@ -1169,13 +1186,13 @@ vect_create_data_ref_ptr (tree stmt, struct loop *at_loop, gcc_assert (nested_in_vect_loop); if (!only_init) { - standard_iv_increment_position (containing_loop, &incr_bsi, + standard_iv_increment_position (containing_loop, &incr_gsi, &insert_after); create_iv (vptr, fold_convert (vect_ptr_type, DR_STEP (dr)), NULL_TREE, - containing_loop, &incr_bsi, insert_after, &indx_before_incr, + containing_loop, &incr_gsi, insert_after, &indx_before_incr, &indx_after_incr); - incr = bsi_stmt (incr_bsi); - set_stmt_info (stmt_ann (incr), new_stmt_vec_info (incr, loop_vinfo)); + incr = gsi_stmt (incr_gsi); + set_vinfo_for_stmt (incr, new_stmt_vec_info (incr, loop_vinfo)); /* Copy the points-to information if it exists. */ if (DR_PTR_INFO (dr)) @@ -1230,16 +1247,15 @@ vect_create_data_ref_ptr (tree stmt, struct loop *at_loop, */ static tree -bump_vector_ptr (tree dataref_ptr, tree ptr_incr, block_stmt_iterator *bsi, - tree stmt, tree bump) +bump_vector_ptr (tree dataref_ptr, gimple ptr_incr, gimple_stmt_iterator *gsi, + gimple stmt, tree bump) { stmt_vec_info stmt_info = vinfo_for_stmt (stmt); struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info); tree vectype = STMT_VINFO_VECTYPE (stmt_info); - tree vptr_type = TREE_TYPE (dataref_ptr); tree ptr_var = SSA_NAME_VAR (dataref_ptr); tree update = TYPE_SIZE_UNIT (vectype); - tree incr_stmt; + gimple incr_stmt; ssa_op_iter iter; use_operand_p use_p; tree new_dataref_ptr; @@ -1247,12 +1263,11 @@ bump_vector_ptr (tree dataref_ptr, tree ptr_incr, block_stmt_iterator *bsi, if (bump) update = bump; - incr_stmt = build_gimple_modify_stmt (ptr_var, - build2 (POINTER_PLUS_EXPR, vptr_type, - dataref_ptr, update)); + incr_stmt = gimple_build_assign_with_ops (POINTER_PLUS_EXPR, ptr_var, + dataref_ptr, update); new_dataref_ptr = make_ssa_name (ptr_var, incr_stmt); - GIMPLE_STMT_OPERAND (incr_stmt, 0) = new_dataref_ptr; - vect_finish_stmt_generation (stmt, incr_stmt, bsi); + gimple_assign_set_lhs (incr_stmt, new_dataref_ptr); + vect_finish_stmt_generation (stmt, incr_stmt, gsi); /* Copy the points-to information if it exists. */ if (DR_PTR_INFO (dr)) @@ -1313,12 +1328,12 @@ vect_create_destination_var (tree scalar_dest, tree vectype) It will be used in the vectorization of STMT. */ static tree -vect_init_vector (tree stmt, tree vector_var, tree vector_type, - block_stmt_iterator *bsi) +vect_init_vector (gimple stmt, tree vector_var, tree vector_type, + gimple_stmt_iterator *gsi) { stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt); tree new_var; - tree init_stmt; + gimple init_stmt; tree vec_oprnd; edge pe; tree new_temp; @@ -1326,12 +1341,12 @@ vect_init_vector (tree stmt, tree vector_var, tree vector_type, new_var = vect_get_new_vect_var (vector_type, vect_simple_var, "cst_"); add_referenced_var (new_var); - init_stmt = build_gimple_modify_stmt (new_var, vector_var); + init_stmt = gimple_build_assign (new_var, vector_var); new_temp = make_ssa_name (new_var, init_stmt); - GIMPLE_STMT_OPERAND (init_stmt, 0) = new_temp; + gimple_assign_set_lhs (init_stmt, new_temp); - if (bsi) - vect_finish_stmt_generation (stmt, init_stmt, bsi); + if (gsi) + vect_finish_stmt_generation (stmt, init_stmt, gsi); else { loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo); @@ -1340,17 +1355,17 @@ vect_init_vector (tree stmt, tree vector_var, tree vector_type, if (nested_in_vect_loop_p (loop, stmt)) loop = loop->inner; pe = loop_preheader_edge (loop); - new_bb = bsi_insert_on_edge_immediate (pe, init_stmt); + new_bb = gsi_insert_on_edge_immediate (pe, init_stmt); gcc_assert (!new_bb); } if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "created new init_stmt: "); - print_generic_expr (vect_dump, init_stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, init_stmt, 0, TDF_SLIM); } - vec_oprnd = GIMPLE_STMT_OPERAND (init_stmt, 0); + vec_oprnd = gimple_assign_lhs (init_stmt); return vec_oprnd; } @@ -1364,8 +1379,8 @@ static void vect_get_constant_vectors (slp_tree slp_node, VEC(tree,heap) **vec_oprnds, unsigned int op_num) { - VEC (tree, heap) *stmts = SLP_TREE_SCALAR_STMTS (slp_node); - tree stmt = VEC_index (tree, stmts, 0); + VEC (gimple, heap) *stmts = SLP_TREE_SCALAR_STMTS (slp_node); + gimple stmt = VEC_index (gimple, stmts, 0); stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt); tree vectype = STMT_VINFO_VECTYPE (stmt_vinfo); int nunits = TYPE_VECTOR_SUBPARTS (vectype); @@ -1373,8 +1388,8 @@ vect_get_constant_vectors (slp_tree slp_node, VEC(tree,heap) **vec_oprnds, tree t = NULL_TREE; int j, number_of_places_left_in_vector; tree vector_type; - tree op, vop, operation; - int group_size = VEC_length (tree, stmts); + tree op, vop; + int group_size = VEC_length (gimple, stmts); unsigned int vec_num, i; int number_of_copies = 1; bool is_store = false; @@ -1407,13 +1422,12 @@ vect_get_constant_vectors (slp_tree slp_node, VEC(tree,heap) **vec_oprnds, constant_p = true; for (j = 0; j < number_of_copies; j++) { - for (i = group_size - 1; VEC_iterate (tree, stmts, i, stmt); i--) + for (i = group_size - 1; VEC_iterate (gimple, stmts, i, stmt); i--) { - operation = GIMPLE_STMT_OPERAND (stmt, 1); if (is_store) - op = operation; + op = gimple_assign_rhs1 (stmt); else - op = TREE_OPERAND (operation, op_num); + op = gimple_op (stmt, op_num + 1); if (!CONSTANT_CLASS_P (op)) constant_p = false; @@ -1471,17 +1485,17 @@ static void vect_get_slp_vect_defs (slp_tree slp_node, VEC (tree,heap) **vec_oprnds) { tree vec_oprnd; - tree vec_def_stmt; + gimple vec_def_stmt; unsigned int i; gcc_assert (SLP_TREE_VEC_STMTS (slp_node)); for (i = 0; - VEC_iterate (tree, SLP_TREE_VEC_STMTS (slp_node), i, vec_def_stmt); + VEC_iterate (gimple, SLP_TREE_VEC_STMTS (slp_node), i, vec_def_stmt); i++) { gcc_assert (vec_def_stmt); - vec_oprnd = GIMPLE_STMT_OPERAND (vec_def_stmt, 0); + vec_oprnd = gimple_get_lhs (vec_def_stmt); VEC_quick_push (tree, *vec_oprnds, vec_oprnd); } } @@ -1500,7 +1514,8 @@ static void vect_get_slp_defs (slp_tree slp_node, VEC (tree,heap) **vec_oprnds0, VEC (tree,heap) **vec_oprnds1) { - tree operation, first_stmt; + gimple first_stmt; + enum tree_code code; /* Allocate memory for vectorized defs. */ *vec_oprnds0 = VEC_alloc (tree, heap, @@ -1515,14 +1530,14 @@ vect_get_slp_defs (slp_tree slp_node, VEC (tree,heap) **vec_oprnds0, /* Build vectors from scalar defs. */ vect_get_constant_vectors (slp_node, vec_oprnds0, 0); - first_stmt = VEC_index (tree, SLP_TREE_SCALAR_STMTS (slp_node), 0); + first_stmt = VEC_index (gimple, SLP_TREE_SCALAR_STMTS (slp_node), 0); if (STMT_VINFO_DATA_REF (vinfo_for_stmt (first_stmt))) /* Since we don't call this function with loads, this is a group of stores. */ return; - operation = GIMPLE_STMT_OPERAND (first_stmt, 1); - if (TREE_OPERAND_LENGTH (operation) == unary_op || !vec_oprnds1) + code = gimple_assign_rhs_code (first_stmt); + if (get_gimple_rhs_class (code) != GIMPLE_BINARY_RHS || !vec_oprnds1) return; *vec_oprnds1 = VEC_alloc (tree, heap, @@ -1550,12 +1565,12 @@ vect_get_slp_defs (slp_tree slp_node, VEC (tree,heap) **vec_oprnds0, [X, X + S, X + 2*S, X + 3*S]. */ static tree -get_initial_def_for_induction (tree iv_phi) +get_initial_def_for_induction (gimple iv_phi) { stmt_vec_info stmt_vinfo = vinfo_for_stmt (iv_phi); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo); struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); - tree scalar_type = TREE_TYPE (PHI_RESULT_TREE (iv_phi)); + tree scalar_type = TREE_TYPE (gimple_phi_result (iv_phi)); tree vectype; int nunits; edge pe = loop_preheader_edge (loop); @@ -1565,8 +1580,8 @@ get_initial_def_for_induction (tree iv_phi) tree access_fn; tree new_var; tree new_name; - tree init_stmt; - tree induction_phi, induc_def, new_stmt, vec_def, vec_dest; + gimple init_stmt, induction_phi, new_stmt; + tree induc_def, vec_def, vec_dest; tree init_expr, step_expr; int vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo); int i; @@ -1575,14 +1590,14 @@ get_initial_def_for_induction (tree iv_phi) tree expr; stmt_vec_info phi_info = vinfo_for_stmt (iv_phi); bool nested_in_vect_loop = false; - tree stmts; + gimple_seq stmts = NULL; imm_use_iterator imm_iter; use_operand_p use_p; - tree exit_phi; + gimple exit_phi; edge latch_e; tree loop_arg; - block_stmt_iterator si; - basic_block bb = bb_for_stmt (iv_phi); + gimple_stmt_iterator si; + basic_block bb = gimple_bb (iv_phi); vectype = get_vectype_for_scalar_type (scalar_type); gcc_assert (vectype); @@ -1593,9 +1608,9 @@ get_initial_def_for_induction (tree iv_phi) gcc_assert (ncopies >= 1); /* Find the first insertion point in the BB. */ - si = bsi_after_labels (bb); + si = gsi_after_labels (bb); - if (INTEGRAL_TYPE_P (scalar_type)) + if (INTEGRAL_TYPE_P (scalar_type) || POINTER_TYPE_P (scalar_type)) step_expr = build_int_cst (scalar_type, 0); else step_expr = build_real (scalar_type, dconst0); @@ -1608,7 +1623,7 @@ get_initial_def_for_induction (tree iv_phi) } else iv_loop = loop; - gcc_assert (iv_loop == (bb_for_stmt (iv_phi))->loop_father); + gcc_assert (iv_loop == (gimple_bb (iv_phi))->loop_father); latch_e = loop_latch_edge (iv_loop); loop_arg = PHI_ARG_DEF_FROM_EDGE (iv_phi, latch_e); @@ -1639,7 +1654,7 @@ get_initial_def_for_induction (tree iv_phi) new_name = force_gimple_operand (init_expr, &stmts, false, new_var); if (stmts) { - new_bb = bsi_insert_on_edge_immediate (pe, stmts); + new_bb = gsi_insert_seq_on_edge_immediate (pe, stmts); gcc_assert (!new_bb); } @@ -1647,21 +1662,21 @@ get_initial_def_for_induction (tree iv_phi) t = tree_cons (NULL_TREE, init_expr, t); for (i = 1; i < nunits; i++) { - tree tmp; - /* Create: new_name_i = new_name + step_expr */ - tmp = fold_build2 (PLUS_EXPR, scalar_type, new_name, step_expr); - init_stmt = build_gimple_modify_stmt (new_var, tmp); + enum tree_code code = POINTER_TYPE_P (scalar_type) + ? POINTER_PLUS_EXPR : PLUS_EXPR; + init_stmt = gimple_build_assign_with_ops (code, new_var, + new_name, step_expr); new_name = make_ssa_name (new_var, init_stmt); - GIMPLE_STMT_OPERAND (init_stmt, 0) = new_name; + gimple_assign_set_lhs (init_stmt, new_name); - new_bb = bsi_insert_on_edge_immediate (pe, init_stmt); + new_bb = gsi_insert_on_edge_immediate (pe, init_stmt); gcc_assert (!new_bb); if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "created new init_stmt: "); - print_generic_expr (vect_dump, init_stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, init_stmt, 0, TDF_SLIM); } t = tree_cons (NULL_TREE, new_name, t); } @@ -1707,19 +1722,17 @@ get_initial_def_for_induction (tree iv_phi) vec_dest = vect_get_new_vect_var (vectype, vect_simple_var, "vec_iv_"); add_referenced_var (vec_dest); induction_phi = create_phi_node (vec_dest, iv_loop->header); - set_stmt_info (get_stmt_ann (induction_phi), - new_stmt_vec_info (induction_phi, loop_vinfo)); + set_vinfo_for_stmt (induction_phi, + new_stmt_vec_info (induction_phi, loop_vinfo)); induc_def = PHI_RESULT (induction_phi); /* Create the iv update inside the loop */ - new_stmt = build_gimple_modify_stmt (NULL_TREE, - build2 (PLUS_EXPR, vectype, - induc_def, vec_step)); + new_stmt = gimple_build_assign_with_ops (PLUS_EXPR, vec_dest, + induc_def, vec_step); vec_def = make_ssa_name (vec_dest, new_stmt); - GIMPLE_STMT_OPERAND (new_stmt, 0) = vec_def; - bsi_insert_before (&si, new_stmt, BSI_SAME_STMT); - set_stmt_info (get_stmt_ann (new_stmt), - new_stmt_vec_info (new_stmt, loop_vinfo)); + gimple_assign_set_lhs (new_stmt, vec_def); + gsi_insert_before (&si, new_stmt, GSI_SAME_STMT); + set_vinfo_for_stmt (new_stmt, new_stmt_vec_info (new_stmt, loop_vinfo)); /* Set the arguments of the phi node: */ add_phi_arg (induction_phi, vec_init, pe); @@ -1752,16 +1765,15 @@ get_initial_def_for_induction (tree iv_phi) prev_stmt_vinfo = vinfo_for_stmt (induction_phi); for (i = 1; i < ncopies; i++) { - tree tmp; - /* vec_i = vec_prev + vec_step */ - tmp = build2 (PLUS_EXPR, vectype, vec_def, vec_step); - new_stmt = build_gimple_modify_stmt (NULL_TREE, tmp); + new_stmt = gimple_build_assign_with_ops (PLUS_EXPR, vec_dest, + vec_def, vec_step); vec_def = make_ssa_name (vec_dest, new_stmt); - GIMPLE_STMT_OPERAND (new_stmt, 0) = vec_def; - bsi_insert_before (&si, new_stmt, BSI_SAME_STMT); - set_stmt_info (get_stmt_ann (new_stmt), - new_stmt_vec_info (new_stmt, loop_vinfo)); + gimple_assign_set_lhs (new_stmt, vec_def); + + gsi_insert_before (&si, new_stmt, GSI_SAME_STMT); + set_vinfo_for_stmt (new_stmt, + new_stmt_vec_info (new_stmt, loop_vinfo)); STMT_VINFO_RELATED_STMT (prev_stmt_vinfo) = new_stmt; prev_stmt_vinfo = vinfo_for_stmt (new_stmt); } @@ -1774,7 +1786,7 @@ get_initial_def_for_induction (tree iv_phi) exit_phi = NULL; FOR_EACH_IMM_USE_FAST (use_p, imm_iter, loop_arg) { - if (!flow_bb_inside_loop_p (iv_loop, bb_for_stmt (USE_STMT (use_p)))) + if (!flow_bb_inside_loop_p (iv_loop, gimple_bb (USE_STMT (use_p)))) { exit_phi = USE_STMT (use_p); break; @@ -1792,7 +1804,7 @@ get_initial_def_for_induction (tree iv_phi) if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "vector of inductions after inner-loop:"); - print_generic_expr (vect_dump, new_stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, new_stmt, 0, TDF_SLIM); } } } @@ -1801,9 +1813,9 @@ get_initial_def_for_induction (tree iv_phi) if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "transform induction: created def-use cycle:"); - print_generic_expr (vect_dump, induction_phi, TDF_SLIM); + print_gimple_stmt (vect_dump, induction_phi, 0, TDF_SLIM); fprintf (vect_dump, "\n"); - print_generic_expr (vect_dump, SSA_NAME_DEF_STMT (vec_def), TDF_SLIM); + print_gimple_stmt (vect_dump, SSA_NAME_DEF_STMT (vec_def), 0, TDF_SLIM); } STMT_VINFO_VEC_STMT (phi_info) = induction_phi; @@ -1823,11 +1835,11 @@ get_initial_def_for_induction (tree iv_phi) needs to be introduced. */ static tree -vect_get_vec_def_for_operand (tree op, tree stmt, tree *scalar_def) +vect_get_vec_def_for_operand (tree op, gimple stmt, tree *scalar_def) { tree vec_oprnd; - tree vec_stmt; - tree def_stmt; + gimple vec_stmt; + gimple def_stmt; stmt_vec_info def_stmt_info = NULL; stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt); tree vectype = STMT_VINFO_VECTYPE (stmt_vinfo); @@ -1860,7 +1872,7 @@ vect_get_vec_def_for_operand (tree op, tree stmt, tree *scalar_def) if (def_stmt) { fprintf (vect_dump, " def_stmt = "); - print_generic_expr (vect_dump, def_stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, def_stmt, 0, TDF_SLIM); } } @@ -1913,16 +1925,18 @@ vect_get_vec_def_for_operand (tree op, tree stmt, tree *scalar_def) case vect_loop_def: { if (scalar_def) - *scalar_def = def_stmt; + *scalar_def = NULL/* FIXME tuples: def_stmt*/; /* Get the def from the vectorized stmt. */ def_stmt_info = vinfo_for_stmt (def_stmt); vec_stmt = STMT_VINFO_VEC_STMT (def_stmt_info); gcc_assert (vec_stmt); - if (TREE_CODE (vec_stmt) == PHI_NODE) + if (gimple_code (vec_stmt) == GIMPLE_PHI) vec_oprnd = PHI_RESULT (vec_stmt); + else if (is_gimple_call (vec_stmt)) + vec_oprnd = gimple_call_lhs (vec_stmt); else - vec_oprnd = GIMPLE_STMT_OPERAND (vec_stmt, 0); + vec_oprnd = gimple_assign_lhs (vec_stmt); return vec_oprnd; } @@ -1931,8 +1945,8 @@ vect_get_vec_def_for_operand (tree op, tree stmt, tree *scalar_def) { struct loop *loop; - gcc_assert (TREE_CODE (def_stmt) == PHI_NODE); - loop = (bb_for_stmt (def_stmt))->loop_father; + gcc_assert (gimple_code (def_stmt) == GIMPLE_PHI); + loop = (gimple_bb (def_stmt))->loop_father; /* Get the def before the loop */ op = PHI_ARG_DEF_FROM_EDGE (def_stmt, loop_preheader_edge (loop)); @@ -1942,12 +1956,12 @@ vect_get_vec_def_for_operand (tree op, tree stmt, tree *scalar_def) /* Case 5: operand is defined by loop-header phi - induction. */ case vect_induction_def: { - gcc_assert (TREE_CODE (def_stmt) == PHI_NODE); + gcc_assert (gimple_code (def_stmt) == GIMPLE_PHI); /* Get the def from the vectorized stmt. */ def_stmt_info = vinfo_for_stmt (def_stmt); vec_stmt = STMT_VINFO_VEC_STMT (def_stmt_info); - gcc_assert (vec_stmt && (TREE_CODE (vec_stmt) == PHI_NODE)); + gcc_assert (vec_stmt && gimple_code (vec_stmt) == GIMPLE_PHI); vec_oprnd = PHI_RESULT (vec_stmt); return vec_oprnd; } @@ -2017,7 +2031,7 @@ vect_get_vec_def_for_operand (tree op, tree stmt, tree *scalar_def) static tree vect_get_vec_def_for_stmt_copy (enum vect_def_type dt, tree vec_oprnd) { - tree vec_stmt_for_operand; + gimple vec_stmt_for_operand; stmt_vec_info def_stmt_info; /* Do nothing; can reuse same def. */ @@ -2029,7 +2043,7 @@ vect_get_vec_def_for_stmt_copy (enum vect_def_type dt, tree vec_oprnd) gcc_assert (def_stmt_info); vec_stmt_for_operand = STMT_VINFO_RELATED_STMT (def_stmt_info); gcc_assert (vec_stmt_for_operand); - vec_oprnd = GIMPLE_STMT_OPERAND (vec_stmt_for_operand, 0); + vec_oprnd = gimple_get_lhs (vec_stmt_for_operand); return vec_oprnd; } @@ -2059,8 +2073,9 @@ vect_get_vec_defs_for_stmt_copy (enum vect_def_type *dt, /* Get vectorized definitions for OP0 and OP1, or SLP_NODE if it is not NULL. */ static void -vect_get_vec_defs (tree op0, tree op1, tree stmt, VEC(tree,heap) **vec_oprnds0, - VEC(tree,heap) **vec_oprnds1, slp_tree slp_node) +vect_get_vec_defs (tree op0, tree op1, gimple stmt, + VEC(tree,heap) **vec_oprnds0, VEC(tree,heap) **vec_oprnds1, + slp_tree slp_node) { if (slp_node) vect_get_slp_defs (slp_node, vec_oprnds0, vec_oprnds1); @@ -2087,30 +2102,29 @@ vect_get_vec_defs (tree op0, tree op1, tree stmt, VEC(tree,heap) **vec_oprnds0, Insert a new stmt. */ static void -vect_finish_stmt_generation (tree stmt, tree vec_stmt, - block_stmt_iterator *bsi) +vect_finish_stmt_generation (gimple stmt, gimple vec_stmt, + gimple_stmt_iterator *gsi) { stmt_vec_info stmt_info = vinfo_for_stmt (stmt); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); - gcc_assert (stmt == bsi_stmt (*bsi)); - gcc_assert (TREE_CODE (stmt) != LABEL_EXPR); + gcc_assert (stmt == gsi_stmt (*gsi)); + gcc_assert (gimple_code (stmt) != GIMPLE_LABEL); - bsi_insert_before (bsi, vec_stmt, BSI_SAME_STMT); + gsi_insert_before (gsi, vec_stmt, GSI_SAME_STMT); - set_stmt_info (get_stmt_ann (vec_stmt), - new_stmt_vec_info (vec_stmt, loop_vinfo)); + set_vinfo_for_stmt (vec_stmt, new_stmt_vec_info (vec_stmt, loop_vinfo)); if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "add new stmt: "); - print_generic_expr (vect_dump, vec_stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, vec_stmt, 0, TDF_SLIM); } - /* Make sure bsi points to the stmt that is being vectorized. */ - gcc_assert (stmt == bsi_stmt (*bsi)); + /* Make sure gsi points to the stmt that is being vectorized. */ + gcc_assert (stmt == gsi_stmt (*gsi)); - SET_EXPR_LOCATION (vec_stmt, EXPR_LOCATION (stmt)); + gimple_set_location (vec_stmt, gimple_location (stmt)); } @@ -2158,14 +2172,14 @@ vect_finish_stmt_generation (tree stmt, tree vec_stmt, A cost model should help decide between these two schemes. */ static tree -get_initial_def_for_reduction (tree stmt, tree init_val, tree *adjustment_def) +get_initial_def_for_reduction (gimple stmt, tree init_val, tree *adjustment_def) { stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo); struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); tree vectype = STMT_VINFO_VECTYPE (stmt_vinfo); int nunits = TYPE_VECTOR_SUBPARTS (vectype); - enum tree_code code = TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)); + enum tree_code code = gimple_assign_rhs_code (stmt); tree type = TREE_TYPE (init_val); tree vecdef; tree def_for_init; @@ -2179,7 +2193,7 @@ get_initial_def_for_reduction (tree stmt, tree init_val, tree *adjustment_def) if (nested_in_vect_loop_p (loop, stmt)) nested_in_vect_loop = true; else - gcc_assert (loop == (bb_for_stmt (stmt))->loop_father); + gcc_assert (loop == (gimple_bb (stmt))->loop_father); vecdef = vect_get_vec_def_for_operand (init_val, stmt, NULL); @@ -2267,8 +2281,9 @@ get_initial_def_for_reduction (tree stmt, tree init_val, tree *adjustment_def) */ static void -vect_create_epilog_for_reduction (tree vect_def, tree stmt, - enum tree_code reduc_code, tree reduction_phi) +vect_create_epilog_for_reduction (tree vect_def, gimple stmt, + enum tree_code reduc_code, + gimple reduction_phi) { stmt_vec_info stmt_info = vinfo_for_stmt (stmt); tree vectype; @@ -2278,15 +2293,16 @@ vect_create_epilog_for_reduction (tree vect_def, tree stmt, basic_block exit_bb; tree scalar_dest; tree scalar_type; - tree new_phi; - block_stmt_iterator exit_bsi; + gimple new_phi; + gimple_stmt_iterator exit_gsi; tree vec_dest; tree new_temp = NULL_TREE; tree new_name; - tree epilog_stmt = NULL_TREE; - tree new_scalar_dest, exit_phi, new_dest; + gimple epilog_stmt = NULL; + tree new_scalar_dest, new_dest; + gimple exit_phi; tree bitsize, bitpos, bytesize; - enum tree_code code = TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)); + enum tree_code code = gimple_assign_rhs_code (stmt); tree adjustment_def; tree vec_initial_def; tree orig_name; @@ -2294,12 +2310,10 @@ vect_create_epilog_for_reduction (tree vect_def, tree stmt, use_operand_p use_p; bool extract_scalar_result = false; tree reduction_op, expr; - tree orig_stmt; - tree use_stmt; - tree operation = GIMPLE_STMT_OPERAND (stmt, 1); + gimple orig_stmt; + gimple use_stmt; bool nested_in_vect_loop = false; - int op_type; - VEC(tree,heap) *phis = NULL; + VEC(gimple,heap) *phis = NULL; int i; if (nested_in_vect_loop_p (loop, stmt)) @@ -2308,8 +2322,22 @@ vect_create_epilog_for_reduction (tree vect_def, tree stmt, nested_in_vect_loop = true; } - op_type = TREE_OPERAND_LENGTH (operation); - reduction_op = TREE_OPERAND (operation, op_type-1); + switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))) + { + case GIMPLE_SINGLE_RHS: + gcc_assert (TREE_OPERAND_LENGTH (gimple_assign_rhs1 (stmt)) == ternary_op); + reduction_op = TREE_OPERAND (gimple_assign_rhs1 (stmt), 2); + break; + case GIMPLE_UNARY_RHS: + reduction_op = gimple_assign_rhs1 (stmt); + break; + case GIMPLE_BINARY_RHS: + reduction_op = gimple_assign_rhs2 (stmt); + break; + default: + gcc_unreachable (); + } + vectype = get_vectype_for_scalar_type (TREE_TYPE (reduction_op)); gcc_assert (vectype); mode = TYPE_MODE (vectype); @@ -2330,9 +2358,9 @@ vect_create_epilog_for_reduction (tree vect_def, tree stmt, if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "transform reduction: created def-use cycle:"); - print_generic_expr (vect_dump, reduction_phi, TDF_SLIM); + print_gimple_stmt (vect_dump, reduction_phi, 0, TDF_SLIM); fprintf (vect_dump, "\n"); - print_generic_expr (vect_dump, SSA_NAME_DEF_STMT (vect_def), TDF_SLIM); + print_gimple_stmt (vect_dump, SSA_NAME_DEF_STMT (vect_def), 0, TDF_SLIM); } @@ -2369,7 +2397,7 @@ vect_create_epilog_for_reduction (tree vect_def, tree stmt, exit_bb = single_exit (loop)->dest; new_phi = create_phi_node (SSA_NAME_VAR (vect_def), exit_bb); SET_PHI_ARG_DEF (new_phi, single_exit (loop)->dest_idx, vect_def); - exit_bsi = bsi_after_labels (exit_bb); + exit_gsi = gsi_after_labels (exit_bb); /* 2.2 Get the relevant tree-code to use in the epilog for schemes 2,3 (i.e. when reduc_code is not available) and in the final adjustment @@ -2393,8 +2421,8 @@ vect_create_epilog_for_reduction (tree vect_def, tree stmt, gcc_assert (STMT_VINFO_IN_PATTERN_P (stmt_vinfo)); gcc_assert (STMT_VINFO_RELATED_STMT (stmt_vinfo) == stmt); } - code = TREE_CODE (GIMPLE_STMT_OPERAND (orig_stmt, 1)); - scalar_dest = GIMPLE_STMT_OPERAND (orig_stmt, 0); + code = gimple_assign_rhs_code (orig_stmt); + scalar_dest = gimple_assign_lhs (orig_stmt); scalar_type = TREE_TYPE (scalar_dest); new_scalar_dest = vect_create_destination_var (scalar_dest, NULL); bitsize = TYPE_SIZE (scalar_type); @@ -2424,10 +2452,10 @@ vect_create_epilog_for_reduction (tree vect_def, tree stmt, vec_dest = vect_create_destination_var (scalar_dest, vectype); tmp = build1 (reduc_code, vectype, PHI_RESULT (new_phi)); - epilog_stmt = build_gimple_modify_stmt (vec_dest, tmp); + epilog_stmt = gimple_build_assign (vec_dest, tmp); new_temp = make_ssa_name (vec_dest, epilog_stmt); - GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_temp; - bsi_insert_before (&exit_bsi, epilog_stmt, BSI_SAME_STMT); + gimple_assign_set_lhs (epilog_stmt, new_temp); + gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); extract_scalar_result = true; } @@ -2480,17 +2508,17 @@ vect_create_epilog_for_reduction (tree vect_def, tree stmt, bit_offset /= 2) { tree bitpos = size_int (bit_offset); - tree tmp = build2 (shift_code, vectype, new_temp, bitpos); - epilog_stmt = build_gimple_modify_stmt (vec_dest, tmp); + epilog_stmt = gimple_build_assign_with_ops (shift_code, vec_dest, + new_temp, bitpos); new_name = make_ssa_name (vec_dest, epilog_stmt); - GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_name; - bsi_insert_before (&exit_bsi, epilog_stmt, BSI_SAME_STMT); + gimple_assign_set_lhs (epilog_stmt, new_name); + gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); - tmp = build2 (code, vectype, new_name, new_temp); - epilog_stmt = build_gimple_modify_stmt (vec_dest, tmp); + epilog_stmt = gimple_build_assign_with_ops (code, vec_dest, + new_name, new_temp); new_temp = make_ssa_name (vec_dest, epilog_stmt); - GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_temp; - bsi_insert_before (&exit_bsi, epilog_stmt, BSI_SAME_STMT); + gimple_assign_set_lhs (epilog_stmt, new_temp); + gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); } extract_scalar_result = true; @@ -2516,30 +2544,30 @@ vect_create_epilog_for_reduction (tree vect_def, tree stmt, vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1); rhs = build3 (BIT_FIELD_REF, scalar_type, vec_temp, bitsize, bitsize_zero_node); - epilog_stmt = build_gimple_modify_stmt (new_scalar_dest, rhs); + epilog_stmt = gimple_build_assign (new_scalar_dest, rhs); new_temp = make_ssa_name (new_scalar_dest, epilog_stmt); - GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_temp; - bsi_insert_before (&exit_bsi, epilog_stmt, BSI_SAME_STMT); + gimple_assign_set_lhs (epilog_stmt, new_temp); + gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); for (bit_offset = element_bitsize; bit_offset < vec_size_in_bits; bit_offset += element_bitsize) { - tree tmp; tree bitpos = bitsize_int (bit_offset); tree rhs = build3 (BIT_FIELD_REF, scalar_type, vec_temp, bitsize, bitpos); - epilog_stmt = build_gimple_modify_stmt (new_scalar_dest, rhs); + epilog_stmt = gimple_build_assign (new_scalar_dest, rhs); new_name = make_ssa_name (new_scalar_dest, epilog_stmt); - GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_name; - bsi_insert_before (&exit_bsi, epilog_stmt, BSI_SAME_STMT); + gimple_assign_set_lhs (epilog_stmt, new_name); + gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); - tmp = build2 (code, scalar_type, new_name, new_temp); - epilog_stmt = build_gimple_modify_stmt (new_scalar_dest, tmp); + epilog_stmt = gimple_build_assign_with_ops (code, + new_scalar_dest, + new_name, new_temp); new_temp = make_ssa_name (new_scalar_dest, epilog_stmt); - GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_temp; - bsi_insert_before (&exit_bsi, epilog_stmt, BSI_SAME_STMT); + gimple_assign_set_lhs (epilog_stmt, new_temp); + gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); } extract_scalar_result = false; @@ -2565,10 +2593,10 @@ vect_create_epilog_for_reduction (tree vect_def, tree stmt, bitpos = bitsize_zero_node; rhs = build3 (BIT_FIELD_REF, scalar_type, new_temp, bitsize, bitpos); - epilog_stmt = build_gimple_modify_stmt (new_scalar_dest, rhs); + epilog_stmt = gimple_build_assign (new_scalar_dest, rhs); new_temp = make_ssa_name (new_scalar_dest, epilog_stmt); - GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_temp; - bsi_insert_before (&exit_bsi, epilog_stmt, BSI_SAME_STMT); + gimple_assign_set_lhs (epilog_stmt, new_temp); + gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); } vect_finalize_reduction: @@ -2592,10 +2620,11 @@ vect_finalize_reduction: expr = build2 (code, scalar_type, new_temp, adjustment_def); new_dest = vect_create_destination_var (scalar_dest, scalar_type); } - epilog_stmt = build_gimple_modify_stmt (new_dest, expr); + epilog_stmt = gimple_build_assign (new_dest, expr); new_temp = make_ssa_name (new_dest, epilog_stmt); - GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_temp; - bsi_insert_before (&exit_bsi, epilog_stmt, BSI_SAME_STMT); + gimple_assign_set_lhs (epilog_stmt, new_temp); + SSA_NAME_DEF_STMT (new_temp) = epilog_stmt; + gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); } @@ -2605,19 +2634,19 @@ vect_finalize_reduction: Find the loop-closed-use at the loop exit of the original scalar result. (The reduction result is expected to have two immediate uses - one at the latch block, and one at the loop exit). */ - phis = VEC_alloc (tree, heap, 10); + phis = VEC_alloc (gimple, heap, 10); FOR_EACH_IMM_USE_FAST (use_p, imm_iter, scalar_dest) { - if (!flow_bb_inside_loop_p (loop, bb_for_stmt (USE_STMT (use_p)))) + if (!flow_bb_inside_loop_p (loop, gimple_bb (USE_STMT (use_p)))) { exit_phi = USE_STMT (use_p); - VEC_quick_push (tree, phis, exit_phi); + VEC_quick_push (gimple, phis, exit_phi); } } /* We expect to have found an exit_phi because of loop-closed-ssa form. */ - gcc_assert (!VEC_empty (tree, phis)); + gcc_assert (!VEC_empty (gimple, phis)); - for (i = 0; VEC_iterate (tree, phis, i, exit_phi); i++) + for (i = 0; VEC_iterate (gimple, phis, i, exit_phi); i++) { if (nested_in_vect_loop) { @@ -2630,8 +2659,8 @@ vect_finalize_reduction: epilog_stmt = adjustment_def ? epilog_stmt : new_phi; STMT_VINFO_VEC_STMT (stmt_vinfo) = epilog_stmt; - set_stmt_info (get_stmt_ann (epilog_stmt), - new_stmt_vec_info (epilog_stmt, loop_vinfo)); + set_vinfo_for_stmt (epilog_stmt, + new_stmt_vec_info (epilog_stmt, loop_vinfo)); continue; } @@ -2641,7 +2670,7 @@ vect_finalize_reduction: FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter) SET_USE (use_p, new_temp); } - VEC_free (tree, heap, phis); + VEC_free (gimple, heap, phis); } @@ -2686,28 +2715,28 @@ vect_finalize_reduction: does *NOT* necessarily hold for reduction patterns. */ bool -vectorizable_reduction (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) +vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi, + gimple *vec_stmt) { tree vec_dest; tree scalar_dest; - tree op; tree loop_vec_def0 = NULL_TREE, loop_vec_def1 = NULL_TREE; stmt_vec_info stmt_info = vinfo_for_stmt (stmt); tree vectype = STMT_VINFO_VECTYPE (stmt_info); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); - tree operation; enum tree_code code, orig_code, epilog_reduc_code = 0; enum machine_mode vec_mode; int op_type; optab optab, reduc_optab; tree new_temp = NULL_TREE; - tree def, def_stmt; + tree def; + gimple def_stmt; enum vect_def_type dt; - tree new_phi; + gimple new_phi; tree scalar_type; bool is_simple_use; - tree orig_stmt; + gimple orig_stmt; stmt_vec_info orig_stmt_info; tree expr = NULL_TREE; int i; @@ -2715,8 +2744,9 @@ vectorizable_reduction (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) int ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits; stmt_vec_info prev_stmt_info; tree reduc_def; - tree new_stmt = NULL_TREE; + gimple new_stmt = NULL; int j; + tree ops[3]; if (nested_in_vect_loop_p (loop, stmt)) { @@ -2772,14 +2802,41 @@ vectorizable_reduction (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) inside the loop body. The last operand is the reduction variable, which is defined by the loop-header-phi. */ - gcc_assert (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT); + gcc_assert (is_gimple_assign (stmt)); - operation = GIMPLE_STMT_OPERAND (stmt, 1); - code = TREE_CODE (operation); - op_type = TREE_OPERAND_LENGTH (operation); - if (op_type != binary_op && op_type != ternary_op) - return false; - scalar_dest = GIMPLE_STMT_OPERAND (stmt, 0); + /* Flatten RHS */ + switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))) + { + case GIMPLE_SINGLE_RHS: + op_type = TREE_OPERAND_LENGTH (gimple_assign_rhs1 (stmt)); + if (op_type == ternary_op) + { + tree rhs = gimple_assign_rhs1 (stmt); + ops[0] = TREE_OPERAND (rhs, 0); + ops[1] = TREE_OPERAND (rhs, 1); + ops[2] = TREE_OPERAND (rhs, 2); + code = TREE_CODE (rhs); + } + else + return false; + break; + + case GIMPLE_BINARY_RHS: + code = gimple_assign_rhs_code (stmt); + op_type = TREE_CODE_LENGTH (code); + gcc_assert (op_type == binary_op); + ops[0] = gimple_assign_rhs1 (stmt); + ops[1] = gimple_assign_rhs2 (stmt); + break; + + case GIMPLE_UNARY_RHS: + return false; + + default: + gcc_unreachable (); + } + + scalar_dest = gimple_assign_lhs (stmt); scalar_type = TREE_TYPE (scalar_dest); if (!POINTER_TYPE_P (scalar_type) && !INTEGRAL_TYPE_P (scalar_type) && !SCALAR_FLOAT_TYPE_P (scalar_type)) @@ -2789,8 +2846,8 @@ vectorizable_reduction (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) The last use is the reduction variable. */ for (i = 0; i < op_type-1; i++) { - op = TREE_OPERAND (operation, i); - is_simple_use = vect_is_simple_use (op, loop_vinfo, &def_stmt, &def, &dt); + is_simple_use = vect_is_simple_use (ops[i], loop_vinfo, &def_stmt, + &def, &dt); gcc_assert (is_simple_use); if (dt != vect_loop_def && dt != vect_invariant_def @@ -2799,11 +2856,10 @@ vectorizable_reduction (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) return false; } - op = TREE_OPERAND (operation, i); - is_simple_use = vect_is_simple_use (op, loop_vinfo, &def_stmt, &def, &dt); + is_simple_use = vect_is_simple_use (ops[i], loop_vinfo, &def_stmt, &def, &dt); gcc_assert (is_simple_use); gcc_assert (dt == vect_reduction_def); - gcc_assert (TREE_CODE (def_stmt) == PHI_NODE); + gcc_assert (gimple_code (def_stmt) == GIMPLE_PHI); if (orig_stmt) gcc_assert (orig_stmt == vect_is_simple_reduction (loop_vinfo, def_stmt)); else @@ -2883,7 +2939,7 @@ vectorizable_reduction (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) { /* This is a reduction pattern: get the vectype from the type of the reduction variable, and get the tree-code from orig_stmt. */ - orig_code = TREE_CODE (GIMPLE_STMT_OPERAND (orig_stmt, 1)); + orig_code = gimple_assign_rhs_code (orig_stmt); vectype = get_vectype_for_scalar_type (TREE_TYPE (def)); if (!vectype) { @@ -2951,12 +3007,10 @@ vectorizable_reduction (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) /* Handle uses. */ if (j == 0) { - op = TREE_OPERAND (operation, 0); - loop_vec_def0 = vect_get_vec_def_for_operand (op, stmt, NULL); + loop_vec_def0 = vect_get_vec_def_for_operand (ops[0], stmt, NULL); if (op_type == ternary_op) { - op = TREE_OPERAND (operation, 1); - loop_vec_def1 = vect_get_vec_def_for_operand (op, stmt, NULL); + loop_vec_def1 = vect_get_vec_def_for_operand (ops[1], stmt, NULL); } /* Get the vector def for the reduction variable from the phi node */ @@ -2971,7 +3025,7 @@ vectorizable_reduction (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) /* Get the vector def for the reduction variable from the vectorized reduction operation generated in the previous iteration (j-1) */ - reduc_def = GIMPLE_STMT_OPERAND (new_stmt ,0); + reduc_def = gimple_assign_lhs (new_stmt); } /* Arguments are ready. create the new vector stmt. */ @@ -2980,10 +3034,10 @@ vectorizable_reduction (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) else expr = build3 (code, vectype, loop_vec_def0, loop_vec_def1, reduc_def); - new_stmt = build_gimple_modify_stmt (vec_dest, expr); + new_stmt = gimple_build_assign (vec_dest, expr); new_temp = make_ssa_name (vec_dest, new_stmt); - GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp; - vect_finish_stmt_generation (stmt, new_stmt, bsi); + gimple_assign_set_lhs (new_stmt, new_temp); + vect_finish_stmt_generation (stmt, new_stmt, gsi); if (j == 0) STMT_VINFO_VEC_STMT (stmt_info) = *vec_stmt = new_stmt; @@ -3003,14 +3057,14 @@ vectorizable_reduction (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) of the function, or NULL_TREE if the function cannot be vectorized. */ tree -vectorizable_function (tree call, tree vectype_out, tree vectype_in) +vectorizable_function (gimple call, tree vectype_out, tree vectype_in) { - tree fndecl = get_callee_fndecl (call); + tree fndecl = gimple_call_fndecl (call); enum built_in_function code; /* We only handle functions that do not read or clobber memory -- i.e. const or novops ones. */ - if (!(call_expr_flags (call) & (ECF_CONST | ECF_NOVOPS))) + if (!(gimple_call_flags (call) & (ECF_CONST | ECF_NOVOPS))) return NULL_TREE; if (!fndecl @@ -3031,11 +3085,10 @@ vectorizable_function (tree call, tree vectype_out, tree vectype_in) Return FALSE if not a vectorizable STMT, TRUE otherwise. */ bool -vectorizable_call (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) +vectorizable_call (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt) { tree vec_dest; tree scalar_dest; - tree operation; tree op, type; tree vec_oprnd0 = NULL_TREE, vec_oprnd1 = NULL_TREE; stmt_vec_info stmt_info = vinfo_for_stmt (stmt), prev_stmt_info; @@ -3044,13 +3097,14 @@ vectorizable_call (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) int nunits_out; loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); - tree fndecl, rhs, new_temp, def, def_stmt, rhs_type, lhs_type; + tree fndecl, new_temp, def, rhs_type, lhs_type; + gimple def_stmt; enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type}; - tree new_stmt; - int ncopies, j, nargs; - call_expr_arg_iterator iter; - tree vargs; + gimple new_stmt; + int ncopies, j; + VEC(tree, heap) *vargs = NULL; enum { NARROW, NONE, WIDEN } modifier; + size_t i, nargs; if (!STMT_VINFO_RELEVANT_P (stmt_info)) return false; @@ -3063,25 +3117,24 @@ vectorizable_call (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) return false; /* Is STMT a vectorizable call? */ - if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT) + if (!is_gimple_call (stmt)) return false; - if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) != SSA_NAME) - return false; - - operation = GIMPLE_STMT_OPERAND (stmt, 1); - if (TREE_CODE (operation) != CALL_EXPR) + if (TREE_CODE (gimple_call_lhs (stmt)) != SSA_NAME) return false; /* Process function arguments. */ rhs_type = NULL_TREE; - nargs = 0; - FOR_EACH_CALL_EXPR_ARG (op, iter, operation) + nargs = gimple_call_num_args (stmt); + + for (i = 0; i < nargs; i++) { + op = gimple_call_arg (stmt, i); + /* Bail out if the function has more than two arguments, we do not have interesting builtin functions to vectorize with more than two arguments. */ - if (nargs >= 2) + if (i >= 2) return false; /* We can only handle calls with arguments of the same type. */ @@ -3100,8 +3153,6 @@ vectorizable_call (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) fprintf (vect_dump, "use not simple."); return false; } - - ++nargs; } /* No arguments is also not good. */ @@ -3113,7 +3164,7 @@ vectorizable_call (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) return false; nunits_in = TYPE_VECTOR_SUBPARTS (vectype_in); - lhs_type = TREE_TYPE (GIMPLE_STMT_OPERAND (stmt, 0)); + lhs_type = TREE_TYPE (gimple_call_lhs (stmt)); vectype_out = get_vectype_for_scalar_type (lhs_type); if (!vectype_out) return false; @@ -3133,7 +3184,7 @@ vectorizable_call (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) is available. TODO -- in some cases, it might be profitable to insert the calls for pieces of the vector, in order to be able to vectorize other operations in the loop. */ - fndecl = vectorizable_function (operation, vectype_out, vectype_in); + fndecl = vectorizable_function (stmt, vectype_out, vectype_in); if (fndecl == NULL_TREE) { if (vect_print_dump_info (REPORT_DETAILS)) @@ -3184,7 +3235,7 @@ vectorizable_call (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) } /* Handle def. */ - scalar_dest = GIMPLE_STMT_OPERAND (stmt, 0); + scalar_dest = gimple_call_lhs (stmt); vec_dest = vect_create_destination_var (scalar_dest, vectype_out); prev_stmt_info = NULL; @@ -3194,12 +3245,14 @@ vectorizable_call (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) for (j = 0; j < ncopies; ++j) { /* Build argument list for the vectorized call. */ - /* FIXME: Rewrite this so that it doesn't - construct a temporary list. */ - vargs = NULL_TREE; - nargs = 0; - FOR_EACH_CALL_EXPR_ARG (op, iter, operation) + if (j == 0) + vargs = VEC_alloc (tree, heap, nargs); + else + VEC_truncate (tree, vargs, 0); + + for (i = 0; i < nargs; i++) { + op = gimple_call_arg (stmt, i); if (j == 0) vec_oprnd0 = vect_get_vec_def_for_operand (op, stmt, NULL); @@ -3207,18 +3260,14 @@ vectorizable_call (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) vec_oprnd0 = vect_get_vec_def_for_stmt_copy (dt[nargs], vec_oprnd0); - vargs = tree_cons (NULL_TREE, vec_oprnd0, vargs); - - ++nargs; + VEC_quick_push (tree, vargs, vec_oprnd0); } - vargs = nreverse (vargs); - rhs = build_function_call_expr (fndecl, vargs); - new_stmt = build_gimple_modify_stmt (vec_dest, rhs); + new_stmt = gimple_build_call_vec (fndecl, vargs); new_temp = make_ssa_name (vec_dest, new_stmt); - GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp; + gimple_call_set_lhs (new_stmt, new_temp); - vect_finish_stmt_generation (stmt, new_stmt, bsi); + vect_finish_stmt_generation (stmt, new_stmt, gsi); if (j == 0) STMT_VINFO_VEC_STMT (stmt_info) = *vec_stmt = new_stmt; @@ -3234,12 +3283,14 @@ vectorizable_call (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) for (j = 0; j < ncopies; ++j) { /* Build argument list for the vectorized call. */ - /* FIXME: Rewrite this so that it doesn't - construct a temporary list. */ - vargs = NULL_TREE; - nargs = 0; - FOR_EACH_CALL_EXPR_ARG (op, iter, operation) + if (j == 0) + vargs = VEC_alloc (tree, heap, nargs * 2); + else + VEC_truncate (tree, vargs, 0); + + for (i = 0; i < nargs; i++) { + op = gimple_call_arg (stmt, i); if (j == 0) { vec_oprnd0 @@ -3255,19 +3306,15 @@ vectorizable_call (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) = vect_get_vec_def_for_stmt_copy (dt[nargs], vec_oprnd0); } - vargs = tree_cons (NULL_TREE, vec_oprnd0, vargs); - vargs = tree_cons (NULL_TREE, vec_oprnd1, vargs); - - ++nargs; + VEC_quick_push (tree, vargs, vec_oprnd0); + VEC_quick_push (tree, vargs, vec_oprnd1); } - vargs = nreverse (vargs); - rhs = build_function_call_expr (fndecl, vargs); - new_stmt = build_gimple_modify_stmt (vec_dest, rhs); + new_stmt = gimple_build_call_vec (fndecl, vargs); new_temp = make_ssa_name (vec_dest, new_stmt); - GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp; + gimple_call_set_lhs (new_stmt, new_temp); - vect_finish_stmt_generation (stmt, new_stmt, bsi); + vect_finish_stmt_generation (stmt, new_stmt, gsi); if (j == 0) STMT_VINFO_VEC_STMT (stmt_info) = new_stmt; @@ -3286,13 +3333,21 @@ vectorizable_call (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) return false; } + VEC_free (tree, heap, vargs); + /* The call in STMT might prevent it from being removed in dce. We however cannot remove it here, due to the way the ssa name it defines is mapped to the new definition. So just replace rhs of the statement with something harmless. */ + type = TREE_TYPE (scalar_dest); - GIMPLE_STMT_OPERAND (stmt, 1) = fold_convert (type, integer_zero_node); - update_stmt (stmt); + new_stmt = gimple_build_assign (gimple_call_lhs (stmt), + fold_convert (type, integer_zero_node)); + set_vinfo_for_stmt (new_stmt, stmt_info); + set_vinfo_for_stmt (stmt, NULL); + STMT_VINFO_STMT (stmt_info) = new_stmt; + gsi_replace (gsi, new_stmt, false); + SSA_NAME_DEF_STMT (gimple_assign_lhs (new_stmt)) = new_stmt; return true; } @@ -3307,14 +3362,15 @@ vectorizable_call (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) needs to be created (DECL is a function-decl of a target-builtin). STMT is the original scalar stmt that we are vectorizing. */ -static tree -vect_gen_widened_results_half (enum tree_code code, tree vectype, tree decl, +static gimple +vect_gen_widened_results_half (enum tree_code code, + tree vectype ATTRIBUTE_UNUSED, + tree decl, tree vec_oprnd0, tree vec_oprnd1, int op_type, - tree vec_dest, block_stmt_iterator *bsi, - tree stmt) + tree vec_dest, gimple_stmt_iterator *gsi, + gimple stmt) { - tree expr; - tree new_stmt; + gimple new_stmt; tree new_temp; tree sym; ssa_op_iter iter; @@ -3324,23 +3380,24 @@ vect_gen_widened_results_half (enum tree_code code, tree vectype, tree decl, { /* Target specific support */ if (op_type == binary_op) - expr = build_call_expr (decl, 2, vec_oprnd0, vec_oprnd1); + new_stmt = gimple_build_call (decl, 2, vec_oprnd0, vec_oprnd1); else - expr = build_call_expr (decl, 1, vec_oprnd0); + new_stmt = gimple_build_call (decl, 1, vec_oprnd0); + new_temp = make_ssa_name (vec_dest, new_stmt); + gimple_call_set_lhs (new_stmt, new_temp); } else - { + { /* Generic support */ gcc_assert (op_type == TREE_CODE_LENGTH (code)); - if (op_type == binary_op) - expr = build2 (code, vectype, vec_oprnd0, vec_oprnd1); - else - expr = build1 (code, vectype, vec_oprnd0); + if (op_type != binary_op) + vec_oprnd1 = NULL; + new_stmt = gimple_build_assign_with_ops (code, vec_dest, vec_oprnd0, + vec_oprnd1); + new_temp = make_ssa_name (vec_dest, new_stmt); + gimple_assign_set_lhs (new_stmt, new_temp); } - new_stmt = build_gimple_modify_stmt (vec_dest, expr); - new_temp = make_ssa_name (vec_dest, new_stmt); - GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp; - vect_finish_stmt_generation (stmt, new_stmt, bsi); + vect_finish_stmt_generation (stmt, new_stmt, gsi); if (code == CALL_EXPR) { @@ -3362,12 +3419,11 @@ vect_gen_widened_results_half (enum tree_code code, tree vectype, tree decl, Return FALSE if not a vectorizable STMT, TRUE otherwise. */ bool -vectorizable_conversion (tree stmt, block_stmt_iterator *bsi, - tree *vec_stmt, slp_tree slp_node) +vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi, + gimple *vec_stmt, slp_tree slp_node) { tree vec_dest; tree scalar_dest; - tree operation; tree op0; tree vec_oprnd0 = NULL_TREE, vec_oprnd1 = NULL_TREE; stmt_vec_info stmt_info = vinfo_for_stmt (stmt); @@ -3376,9 +3432,10 @@ vectorizable_conversion (tree stmt, block_stmt_iterator *bsi, enum tree_code code, code1 = ERROR_MARK, code2 = ERROR_MARK; tree decl1 = NULL_TREE, decl2 = NULL_TREE; tree new_temp; - tree def, def_stmt; + tree def; + gimple def_stmt; enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type}; - tree new_stmt = NULL_TREE; + gimple new_stmt = NULL; stmt_vec_info prev_stmt_info; int nunits_in; int nunits_out; @@ -3400,26 +3457,25 @@ vectorizable_conversion (tree stmt, block_stmt_iterator *bsi, if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_loop_def) return false; - if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT) + if (!is_gimple_assign (stmt)) return false; - if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) != SSA_NAME) + if (TREE_CODE (gimple_assign_lhs (stmt)) != SSA_NAME) return false; - operation = GIMPLE_STMT_OPERAND (stmt, 1); - code = TREE_CODE (operation); + code = gimple_assign_rhs_code (stmt); if (code != FIX_TRUNC_EXPR && code != FLOAT_EXPR) return false; /* Check types of lhs and rhs. */ - op0 = TREE_OPERAND (operation, 0); + op0 = gimple_assign_rhs1 (stmt); rhs_type = TREE_TYPE (op0); vectype_in = get_vectype_for_scalar_type (rhs_type); if (!vectype_in) return false; nunits_in = TYPE_VECTOR_SUBPARTS (vectype_in); - scalar_dest = GIMPLE_STMT_OPERAND (stmt, 0); + scalar_dest = gimple_assign_lhs (stmt); lhs_type = TREE_TYPE (scalar_dest); vectype_out = get_vectype_for_scalar_type (lhs_type); if (!vectype_out) @@ -3532,13 +3588,11 @@ vectorizable_conversion (tree stmt, block_stmt_iterator *bsi, targetm.vectorize.builtin_conversion (code, vectype_in); for (i = 0; VEC_iterate (tree, vec_oprnds0, i, vop0); i++) { - new_stmt = build_call_expr (builtin_decl, 1, vop0); - /* Arguments are ready. create the new vector stmt. */ - new_stmt = build_gimple_modify_stmt (vec_dest, new_stmt); + new_stmt = gimple_build_call (builtin_decl, 1, vop0); new_temp = make_ssa_name (vec_dest, new_stmt); - GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp; - vect_finish_stmt_generation (stmt, new_stmt, bsi); + gimple_call_set_lhs (new_stmt, new_temp); + vect_finish_stmt_generation (stmt, new_stmt, gsi); FOR_EACH_SSA_TREE_OPERAND (sym, new_stmt, iter, SSA_OP_ALL_VIRTUALS) { @@ -3547,7 +3601,7 @@ vectorizable_conversion (tree stmt, block_stmt_iterator *bsi, mark_sym_for_renaming (sym); } if (slp_node) - VEC_quick_push (tree, SLP_TREE_VEC_STMTS (slp_node), new_stmt); + VEC_quick_push (gimple, SLP_TREE_VEC_STMTS (slp_node), new_stmt); } if (j == 0) @@ -3576,7 +3630,7 @@ vectorizable_conversion (tree stmt, block_stmt_iterator *bsi, new_stmt = vect_gen_widened_results_half (code1, vectype_out, decl1, vec_oprnd0, vec_oprnd1, - unary_op, vec_dest, bsi, stmt); + unary_op, vec_dest, gsi, stmt); if (j == 0) STMT_VINFO_VEC_STMT (stmt_info) = new_stmt; else @@ -3587,7 +3641,7 @@ vectorizable_conversion (tree stmt, block_stmt_iterator *bsi, new_stmt = vect_gen_widened_results_half (code2, vectype_out, decl2, vec_oprnd0, vec_oprnd1, - unary_op, vec_dest, bsi, stmt); + unary_op, vec_dest, gsi, stmt); STMT_VINFO_RELATED_STMT (prev_stmt_info) = new_stmt; prev_stmt_info = vinfo_for_stmt (new_stmt); } @@ -3614,10 +3668,11 @@ vectorizable_conversion (tree stmt, block_stmt_iterator *bsi, /* Arguments are ready. Create the new vector stmt. */ expr = build2 (code1, vectype_out, vec_oprnd0, vec_oprnd1); - new_stmt = build_gimple_modify_stmt (vec_dest, expr); + new_stmt = gimple_build_assign_with_ops (code1, vec_dest, vec_oprnd0, + vec_oprnd1); new_temp = make_ssa_name (vec_dest, new_stmt); - GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp; - vect_finish_stmt_generation (stmt, new_stmt, bsi); + gimple_assign_set_lhs (new_stmt, new_temp); + vect_finish_stmt_generation (stmt, new_stmt, gsi); if (j == 0) STMT_VINFO_VEC_STMT (stmt_info) = new_stmt; @@ -3645,8 +3700,8 @@ vectorizable_conversion (tree stmt, block_stmt_iterator *bsi, Return FALSE if not a vectorizable STMT, TRUE otherwise. */ bool -vectorizable_assignment (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, - slp_tree slp_node) +vectorizable_assignment (gimple stmt, gimple_stmt_iterator *gsi, + gimple *vec_stmt, slp_tree slp_node) { tree vec_dest; tree scalar_dest; @@ -3655,7 +3710,8 @@ vectorizable_assignment (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, tree vectype = STMT_VINFO_VECTYPE (stmt_info); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); tree new_temp; - tree def, def_stmt; + tree def; + gimple def_stmt; enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type}; int nunits = TYPE_VECTOR_SUBPARTS (vectype); int ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits; @@ -3679,14 +3735,19 @@ vectorizable_assignment (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, return false; /* Is vectorizable assignment? */ - if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT) + if (!is_gimple_assign (stmt)) return false; - scalar_dest = GIMPLE_STMT_OPERAND (stmt, 0); + scalar_dest = gimple_assign_lhs (stmt); if (TREE_CODE (scalar_dest) != SSA_NAME) return false; - op = GIMPLE_STMT_OPERAND (stmt, 1); + if (gimple_assign_single_p (stmt) + || gimple_assign_rhs_code (stmt) == PAREN_EXPR) + op = gimple_assign_rhs1 (stmt); + else + return false; + if (!vect_is_simple_use (op, loop_vinfo, &def_stmt, &def, &dt[0])) { if (vect_print_dump_info (REPORT_DETAILS)) @@ -3716,14 +3777,14 @@ vectorizable_assignment (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, /* Arguments are ready. create the new vector stmt. */ for (i = 0; VEC_iterate (tree, vec_oprnds, i, vop); i++) { - *vec_stmt = build_gimple_modify_stmt (vec_dest, vop); + *vec_stmt = gimple_build_assign (vec_dest, vop); new_temp = make_ssa_name (vec_dest, *vec_stmt); - GIMPLE_STMT_OPERAND (*vec_stmt, 0) = new_temp; - vect_finish_stmt_generation (stmt, *vec_stmt, bsi); + gimple_assign_set_lhs (*vec_stmt, new_temp); + vect_finish_stmt_generation (stmt, *vec_stmt, gsi); STMT_VINFO_VEC_STMT (stmt_info) = *vec_stmt; if (slp_node) - VEC_quick_push (tree, SLP_TREE_VEC_STMTS (slp_node), *vec_stmt); + VEC_quick_push (gimple, SLP_TREE_VEC_STMTS (slp_node), *vec_stmt); } VEC_free (tree, heap, vec_oprnds); @@ -3766,8 +3827,8 @@ vect_min_worthwhile_factor (enum tree_code code) Return FALSE if not a vectorizable STMT, TRUE otherwise. */ bool -vectorizable_induction (tree phi, block_stmt_iterator *bsi ATTRIBUTE_UNUSED, - tree *vec_stmt) +vectorizable_induction (gimple phi, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED, + gimple *vec_stmt) { stmt_vec_info stmt_info = vinfo_for_stmt (phi); tree vectype = STMT_VINFO_VECTYPE (stmt_info); @@ -3787,7 +3848,7 @@ vectorizable_induction (tree phi, block_stmt_iterator *bsi ATTRIBUTE_UNUSED, gcc_assert (STMT_VINFO_DEF_TYPE (stmt_info) == vect_induction_def); - if (TREE_CODE (phi) != PHI_NODE) + if (gimple_code (phi) != GIMPLE_PHI) return false; if (!vec_stmt) /* transformation not required. */ @@ -3818,12 +3879,11 @@ vectorizable_induction (tree phi, block_stmt_iterator *bsi ATTRIBUTE_UNUSED, Return FALSE if not a vectorizable STMT, TRUE otherwise. */ bool -vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, - slp_tree slp_node) +vectorizable_operation (gimple stmt, gimple_stmt_iterator *gsi, + gimple *vec_stmt, slp_tree slp_node) { tree vec_dest; tree scalar_dest; - tree operation; tree op0, op1 = NULL; tree vec_oprnd1 = NULL_TREE; stmt_vec_info stmt_info = vinfo_for_stmt (stmt); @@ -3837,9 +3897,10 @@ vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, optab optab; int icode; enum machine_mode optab_op2_mode; - tree def, def_stmt; + tree def; + gimple def_stmt; enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type}; - tree new_stmt = NULL_TREE; + gimple new_stmt = NULL; stmt_vec_info prev_stmt_info; int nunits_in = TYPE_VECTOR_SUBPARTS (vectype); int nunits_out; @@ -3872,13 +3933,13 @@ vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, return false; /* Is STMT a vectorizable binary/unary operation? */ - if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT) + if (!is_gimple_assign (stmt)) return false; - if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) != SSA_NAME) + if (TREE_CODE (gimple_assign_lhs (stmt)) != SSA_NAME) return false; - scalar_dest = GIMPLE_STMT_OPERAND (stmt, 0); + scalar_dest = gimple_assign_lhs (stmt); vectype_out = get_vectype_for_scalar_type (TREE_TYPE (scalar_dest)); if (!vectype_out) return false; @@ -3886,8 +3947,7 @@ vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, if (nunits_out != nunits_in) return false; - operation = GIMPLE_STMT_OPERAND (stmt, 1); - code = TREE_CODE (operation); + code = gimple_assign_rhs_code (stmt); /* For pointer addition, we should use the normal plus for the vector addition. */ @@ -3895,7 +3955,7 @@ vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, code = PLUS_EXPR; /* Support only unary or binary operations. */ - op_type = TREE_OPERAND_LENGTH (operation); + op_type = TREE_CODE_LENGTH (code); if (op_type != unary_op && op_type != binary_op) { if (vect_print_dump_info (REPORT_DETAILS)) @@ -3903,7 +3963,7 @@ vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, return false; } - op0 = TREE_OPERAND (operation, 0); + op0 = gimple_assign_rhs1 (stmt); if (!vect_is_simple_use (op0, loop_vinfo, &def_stmt, &def, &dt[0])) { if (vect_print_dump_info (REPORT_DETAILS)) @@ -3913,7 +3973,7 @@ vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, if (op_type == binary_op) { - op1 = TREE_OPERAND (operation, 1); + op1 = gimple_assign_rhs2 (stmt); if (!vect_is_simple_use (op1, loop_vinfo, &def_stmt, &def, &dt[1])) { if (vect_print_dump_info (REPORT_DETAILS)) @@ -4140,21 +4200,14 @@ vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, /* Arguments are ready. Create the new vector stmt. */ for (i = 0; VEC_iterate (tree, vec_oprnds0, i, vop0); i++) { - if (op_type == binary_op) - { - vop1 = VEC_index (tree, vec_oprnds1, i); - new_stmt = build_gimple_modify_stmt (vec_dest, - build2 (code, vectype, vop0, vop1)); - } - else - new_stmt = build_gimple_modify_stmt (vec_dest, - build1 (code, vectype, vop0)); - + vop1 = ((op_type == binary_op) + ? VEC_index (tree, vec_oprnds1, i) : NULL); + new_stmt = gimple_build_assign_with_ops (code, vec_dest, vop0, vop1); new_temp = make_ssa_name (vec_dest, new_stmt); - GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp; - vect_finish_stmt_generation (stmt, new_stmt, bsi); + gimple_assign_set_lhs (new_stmt, new_temp); + vect_finish_stmt_generation (stmt, new_stmt, gsi); if (slp_node) - VEC_quick_push (tree, SLP_TREE_VEC_STMTS (slp_node), new_stmt); + VEC_quick_push (gimple, SLP_TREE_VEC_STMTS (slp_node), new_stmt); } if (j == 0) @@ -4181,12 +4234,11 @@ vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, Return FALSE if not a vectorizable STMT, TRUE otherwise. */ bool -vectorizable_type_demotion (tree stmt, block_stmt_iterator *bsi, - tree *vec_stmt) +vectorizable_type_demotion (gimple stmt, gimple_stmt_iterator *gsi, + gimple *vec_stmt) { tree vec_dest; tree scalar_dest; - tree operation; tree op0; tree vec_oprnd0=NULL, vec_oprnd1=NULL; stmt_vec_info stmt_info = vinfo_for_stmt (stmt); @@ -4194,16 +4246,16 @@ vectorizable_type_demotion (tree stmt, block_stmt_iterator *bsi, struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); enum tree_code code, code1 = ERROR_MARK; tree new_temp; - tree def, def_stmt; + tree def; + gimple def_stmt; enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type}; - tree new_stmt; + gimple new_stmt; stmt_vec_info prev_stmt_info; int nunits_in; int nunits_out; tree vectype_out; int ncopies; int j; - tree expr; tree vectype_in; if (!STMT_VINFO_RELEVANT_P (stmt_info)) @@ -4213,24 +4265,23 @@ vectorizable_type_demotion (tree stmt, block_stmt_iterator *bsi, return false; /* Is STMT a vectorizable type-demotion operation? */ - if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT) + if (!is_gimple_assign (stmt)) return false; - if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) != SSA_NAME) + if (TREE_CODE (gimple_assign_lhs (stmt)) != SSA_NAME) return false; - operation = GIMPLE_STMT_OPERAND (stmt, 1); - code = TREE_CODE (operation); + code = gimple_assign_rhs_code (stmt); if (code != NOP_EXPR && code != CONVERT_EXPR) return false; - op0 = TREE_OPERAND (operation, 0); + op0 = gimple_assign_rhs1 (stmt); vectype_in = get_vectype_for_scalar_type (TREE_TYPE (op0)); if (!vectype_in) return false; nunits_in = TYPE_VECTOR_SUBPARTS (vectype_in); - scalar_dest = GIMPLE_STMT_OPERAND (stmt, 0); + scalar_dest = gimple_assign_lhs (stmt); vectype_out = get_vectype_for_scalar_type (TREE_TYPE (scalar_dest)); if (!vectype_out) return false; @@ -4306,11 +4357,11 @@ vectorizable_type_demotion (tree stmt, block_stmt_iterator *bsi, } /* Arguments are ready. Create the new vector stmt. */ - expr = build2 (code1, vectype_out, vec_oprnd0, vec_oprnd1); - new_stmt = build_gimple_modify_stmt (vec_dest, expr); + new_stmt = gimple_build_assign_with_ops (code1, vec_dest, vec_oprnd0, + vec_oprnd1); new_temp = make_ssa_name (vec_dest, new_stmt); - GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp; - vect_finish_stmt_generation (stmt, new_stmt, bsi); + gimple_assign_set_lhs (new_stmt, new_temp); + vect_finish_stmt_generation (stmt, new_stmt, gsi); if (j == 0) STMT_VINFO_VEC_STMT (stmt_info) = new_stmt; @@ -4334,12 +4385,11 @@ vectorizable_type_demotion (tree stmt, block_stmt_iterator *bsi, Return FALSE if not a vectorizable STMT, TRUE otherwise. */ bool -vectorizable_type_promotion (tree stmt, block_stmt_iterator *bsi, - tree *vec_stmt) +vectorizable_type_promotion (gimple stmt, gimple_stmt_iterator *gsi, + gimple *vec_stmt) { tree vec_dest; tree scalar_dest; - tree operation; tree op0, op1 = NULL; tree vec_oprnd0=NULL, vec_oprnd1=NULL; stmt_vec_info stmt_info = vinfo_for_stmt (stmt); @@ -4348,9 +4398,10 @@ vectorizable_type_promotion (tree stmt, block_stmt_iterator *bsi, enum tree_code code, code1 = ERROR_MARK, code2 = ERROR_MARK; tree decl1 = NULL_TREE, decl2 = NULL_TREE; int op_type; - tree def, def_stmt; + tree def; + gimple def_stmt; enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type}; - tree new_stmt; + gimple new_stmt; stmt_vec_info prev_stmt_info; int nunits_in; int nunits_out; @@ -4366,25 +4417,24 @@ vectorizable_type_promotion (tree stmt, block_stmt_iterator *bsi, return false; /* Is STMT a vectorizable type-promotion operation? */ - if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT) + if (!is_gimple_assign (stmt)) return false; - if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) != SSA_NAME) + if (TREE_CODE (gimple_assign_lhs (stmt)) != SSA_NAME) return false; - operation = GIMPLE_STMT_OPERAND (stmt, 1); - code = TREE_CODE (operation); + code = gimple_assign_rhs_code (stmt); if (code != NOP_EXPR && code != CONVERT_EXPR && code != WIDEN_MULT_EXPR) return false; - op0 = TREE_OPERAND (operation, 0); + op0 = gimple_assign_rhs1 (stmt); vectype_in = get_vectype_for_scalar_type (TREE_TYPE (op0)); if (!vectype_in) return false; nunits_in = TYPE_VECTOR_SUBPARTS (vectype_in); - scalar_dest = GIMPLE_STMT_OPERAND (stmt, 0); + scalar_dest = gimple_assign_lhs (stmt); vectype_out = get_vectype_for_scalar_type (TREE_TYPE (scalar_dest)); if (!vectype_out) return false; @@ -4420,7 +4470,7 @@ vectorizable_type_promotion (tree stmt, block_stmt_iterator *bsi, op_type = TREE_CODE_LENGTH (code); if (op_type == binary_op) { - op1 = TREE_OPERAND (operation, 1); + op1 = gimple_assign_rhs2 (stmt); if (!vect_is_simple_use (op1, loop_vinfo, &def_stmt, &def, &dt[1])) { if (vect_print_dump_info (REPORT_DETAILS)) @@ -4482,7 +4532,7 @@ vectorizable_type_promotion (tree stmt, block_stmt_iterator *bsi, or a using a tree-code. */ /* Generate first half of the widened result: */ new_stmt = vect_gen_widened_results_half (code1, vectype_out, decl1, - vec_oprnd0, vec_oprnd1, op_type, vec_dest, bsi, stmt); + vec_oprnd0, vec_oprnd1, op_type, vec_dest, gsi, stmt); if (j == 0) STMT_VINFO_VEC_STMT (stmt_info) = new_stmt; else @@ -4491,7 +4541,7 @@ vectorizable_type_promotion (tree stmt, block_stmt_iterator *bsi, /* Generate second half of the widened result: */ new_stmt = vect_gen_widened_results_half (code2, vectype_out, decl2, - vec_oprnd0, vec_oprnd1, op_type, vec_dest, bsi, stmt); + vec_oprnd0, vec_oprnd1, op_type, vec_dest, gsi, stmt); STMT_VINFO_RELATED_STMT (prev_stmt_info) = new_stmt; prev_stmt_info = vinfo_for_stmt (new_stmt); @@ -4605,17 +4655,19 @@ vect_strided_store_supported (tree vectype) static bool vect_permute_store_chain (VEC(tree,heap) *dr_chain, unsigned int length, - tree stmt, - block_stmt_iterator *bsi, + gimple stmt, + gimple_stmt_iterator *gsi, VEC(tree,heap) **result_chain) { - tree perm_dest, perm_stmt, vect1, vect2, high, low; + tree perm_dest, vect1, vect2, high, low; + gimple perm_stmt; tree vectype = STMT_VINFO_VECTYPE (vinfo_for_stmt (stmt)); - tree scalar_dest, tmp; + tree scalar_dest; int i; unsigned int j; + enum tree_code high_code, low_code; - scalar_dest = GIMPLE_STMT_OPERAND (stmt, 0); + scalar_dest = gimple_assign_lhs (stmt); /* Check that the operation is supported. */ if (!vect_strided_store_supported (vectype)) @@ -4639,13 +4691,20 @@ vect_permute_store_chain (VEC(tree,heap) *dr_chain, DECL_GIMPLE_REG_P (perm_dest) = 1; add_referenced_var (perm_dest); if (BYTES_BIG_ENDIAN) - tmp = build2 (VEC_INTERLEAVE_HIGH_EXPR, vectype, vect1, vect2); + { + high_code = VEC_INTERLEAVE_HIGH_EXPR; + low_code = VEC_INTERLEAVE_LOW_EXPR; + } else - tmp = build2 (VEC_INTERLEAVE_LOW_EXPR, vectype, vect1, vect2); - perm_stmt = build_gimple_modify_stmt (perm_dest, tmp); + { + low_code = VEC_INTERLEAVE_HIGH_EXPR; + high_code = VEC_INTERLEAVE_LOW_EXPR; + } + perm_stmt = gimple_build_assign_with_ops (high_code, perm_dest, + vect1, vect2); high = make_ssa_name (perm_dest, perm_stmt); - GIMPLE_STMT_OPERAND (perm_stmt, 0) = high; - vect_finish_stmt_generation (stmt, perm_stmt, bsi); + gimple_assign_set_lhs (perm_stmt, high); + vect_finish_stmt_generation (stmt, perm_stmt, gsi); VEC_replace (tree, *result_chain, 2*j, high); /* Create interleaving stmt: @@ -4656,14 +4715,11 @@ vect_permute_store_chain (VEC(tree,heap) *dr_chain, perm_dest = create_tmp_var (vectype, "vect_inter_low"); DECL_GIMPLE_REG_P (perm_dest) = 1; add_referenced_var (perm_dest); - if (BYTES_BIG_ENDIAN) - tmp = build2 (VEC_INTERLEAVE_LOW_EXPR, vectype, vect1, vect2); - else - tmp = build2 (VEC_INTERLEAVE_HIGH_EXPR, vectype, vect1, vect2); - perm_stmt = build_gimple_modify_stmt (perm_dest, tmp); + perm_stmt = gimple_build_assign_with_ops (low_code, perm_dest, + vect1, vect2); low = make_ssa_name (perm_dest, perm_stmt); - GIMPLE_STMT_OPERAND (perm_stmt, 0) = low; - vect_finish_stmt_generation (stmt, perm_stmt, bsi); + gimple_assign_set_lhs (perm_stmt, low); + vect_finish_stmt_generation (stmt, perm_stmt, gsi); VEC_replace (tree, *result_chain, 2*j+1, low); } dr_chain = VEC_copy (tree, heap, *result_chain); @@ -4681,7 +4737,7 @@ vect_permute_store_chain (VEC(tree,heap) *dr_chain, Return FALSE if not a vectorizable STMT, TRUE otherwise. */ bool -vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, +vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, slp_tree slp_node) { tree scalar_dest; @@ -4696,14 +4752,15 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, enum machine_mode vec_mode; tree dummy; enum dr_alignment_support alignment_support_scheme; - tree def, def_stmt; + tree def; + gimple def_stmt; enum vect_def_type dt; stmt_vec_info prev_stmt_info = NULL; tree dataref_ptr = NULL_TREE; int nunits = TYPE_VECTOR_SUBPARTS (vectype); int ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits; int j; - tree next_stmt, first_stmt = NULL_TREE; + gimple next_stmt, first_stmt = NULL; bool strided_store = false; unsigned int group_size, i; VEC(tree,heap) *dr_chain = NULL, *oprnds = NULL, *result_chain = NULL; @@ -4736,16 +4793,17 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, /* Is vectorizable store? */ - if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT) + if (!is_gimple_assign (stmt)) return false; - scalar_dest = GIMPLE_STMT_OPERAND (stmt, 0); + scalar_dest = gimple_assign_lhs (stmt); if (TREE_CODE (scalar_dest) != ARRAY_REF && TREE_CODE (scalar_dest) != INDIRECT_REF && !STMT_VINFO_STRIDED_ACCESS (stmt_info)) return false; - op = GIMPLE_STMT_OPERAND (stmt, 1); + gcc_assert (gimple_assign_single_p (stmt)); + op = gimple_assign_rhs1 (stmt); if (!vect_is_simple_use (op, loop_vinfo, &def_stmt, &def, &dt)) { if (vect_print_dump_info (REPORT_DETAILS)) @@ -4795,7 +4853,8 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, next_stmt = DR_GROUP_NEXT_DR (stmt_info); while (next_stmt) { - op = GIMPLE_STMT_OPERAND (next_stmt, 1); + gcc_assert (gimple_assign_single_p (next_stmt)); + op = gimple_assign_rhs1 (next_stmt); if (!vect_is_simple_use (op, loop_vinfo, &def_stmt, &def, &dt)) { if (vect_print_dump_info (REPORT_DETAILS)) @@ -4833,7 +4892,7 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, < DR_GROUP_SIZE (vinfo_for_stmt (first_stmt)) && !slp) { - *vec_stmt = NULL_TREE; + *vec_stmt = NULL; return true; } @@ -4906,8 +4965,8 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, prev_stmt_info = NULL; for (j = 0; j < ncopies; j++) { - tree new_stmt; - tree ptr_incr; + gimple new_stmt; + gimple ptr_incr; if (j == 0) { @@ -4936,7 +4995,8 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, there is no interleaving, GROUP_SIZE is 1, and only one iteration of the loop will be executed. */ gcc_assert (next_stmt); - op = GIMPLE_STMT_OPERAND (next_stmt, 1); + gcc_assert (gimple_assign_single_p (next_stmt)); + op = gimple_assign_rhs1 (next_stmt); vec_oprnd = vect_get_vec_def_for_operand (op, next_stmt, NULL); @@ -4972,14 +5032,14 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, VEC_replace(tree, oprnds, i, vec_oprnd); } dataref_ptr = - bump_vector_ptr (dataref_ptr, ptr_incr, bsi, stmt, NULL_TREE); + bump_vector_ptr (dataref_ptr, ptr_incr, gsi, stmt, NULL_TREE); } if (strided_store) { result_chain = VEC_alloc (tree, heap, group_size); /* Permute. */ - if (!vect_permute_store_chain (dr_chain, group_size, stmt, bsi, + if (!vect_permute_store_chain (dr_chain, group_size, stmt, gsi, &result_chain)) return false; } @@ -4989,7 +5049,7 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, { if (i > 0) /* Bump the vector pointer. */ - dataref_ptr = bump_vector_ptr (dataref_ptr, ptr_incr, bsi, stmt, + dataref_ptr = bump_vector_ptr (dataref_ptr, ptr_incr, gsi, stmt, NULL_TREE); if (slp) @@ -5001,8 +5061,8 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, data_ref = build_fold_indirect_ref (dataref_ptr); /* Arguments are ready. Create the new vector stmt. */ - new_stmt = build_gimple_modify_stmt (data_ref, vec_oprnd); - vect_finish_stmt_generation (stmt, new_stmt, bsi); + new_stmt = gimple_build_assign (data_ref, vec_oprnd); + vect_finish_stmt_generation (stmt, new_stmt, gsi); mark_symbols_for_renaming (new_stmt); if (j == 0) @@ -5078,7 +5138,7 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, Return value - the result of the loop-header phi node. */ static tree -vect_setup_realignment (tree stmt, block_stmt_iterator *bsi, +vect_setup_realignment (gimple stmt, gimple_stmt_iterator *gsi, tree *realignment_token, enum dr_alignment_support alignment_support_scheme, tree init_addr, @@ -5089,22 +5149,22 @@ vect_setup_realignment (tree stmt, block_stmt_iterator *bsi, loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); edge pe; - tree scalar_dest = GIMPLE_STMT_OPERAND (stmt, 0); + tree scalar_dest = gimple_assign_lhs (stmt); tree vec_dest; - tree inc; + gimple inc; tree ptr; tree data_ref; - tree new_stmt; + gimple new_stmt; basic_block new_bb; tree msq_init = NULL_TREE; tree new_temp; - tree phi_stmt; + gimple phi_stmt; tree msq = NULL_TREE; - tree stmts = NULL_TREE; + gimple_seq stmts = NULL; bool inv_p; bool compute_in_loop = false; bool nested_in_vect_loop = nested_in_vect_loop_p (loop, stmt); - struct loop *containing_loop = (bb_for_stmt (stmt))->loop_father; + struct loop *containing_loop = (gimple_bb (stmt))->loop_father; struct loop *loop_for_initial_load; gcc_assert (alignment_support_scheme == dr_explicit_realign @@ -5188,13 +5248,13 @@ vect_setup_realignment (tree stmt, block_stmt_iterator *bsi, ptr = vect_create_data_ref_ptr (stmt, loop_for_initial_load, NULL_TREE, &init_addr, &inc, true, &inv_p); data_ref = build1 (ALIGN_INDIRECT_REF, vectype, ptr); - new_stmt = build_gimple_modify_stmt (vec_dest, data_ref); + new_stmt = gimple_build_assign (vec_dest, data_ref); new_temp = make_ssa_name (vec_dest, new_stmt); - GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp; + gimple_assign_set_lhs (new_stmt, new_temp); mark_symbols_for_renaming (new_stmt); - new_bb = bsi_insert_on_edge_immediate (pe, new_stmt); + new_bb = gsi_insert_on_edge_immediate (pe, new_stmt); gcc_assert (!new_bb); - msq_init = GIMPLE_STMT_OPERAND (new_stmt, 0); + msq_init = gimple_assign_lhs (new_stmt); } /* 4. Create realignment token using a target builtin, if available. @@ -5214,29 +5274,29 @@ vect_setup_realignment (tree stmt, block_stmt_iterator *bsi, init_addr = vect_create_addr_base_for_vector_ref (stmt, &stmts, NULL_TREE, loop); pe = loop_preheader_edge (loop); - new_bb = bsi_insert_on_edge_immediate (pe, stmts); + new_bb = gsi_insert_seq_on_edge_immediate (pe, stmts); gcc_assert (!new_bb); } builtin_decl = targetm.vectorize.builtin_mask_for_load (); - new_stmt = build_call_expr (builtin_decl, 1, init_addr); - vec_dest = vect_create_destination_var (scalar_dest, - TREE_TYPE (new_stmt)); - new_stmt = build_gimple_modify_stmt (vec_dest, new_stmt); + new_stmt = gimple_build_call (builtin_decl, 1, init_addr); + vec_dest = + vect_create_destination_var (scalar_dest, + gimple_call_return_type (new_stmt)); new_temp = make_ssa_name (vec_dest, new_stmt); - GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp; + gimple_call_set_lhs (new_stmt, new_temp); if (compute_in_loop) - bsi_insert_before (bsi, new_stmt, BSI_SAME_STMT); + gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT); else { /* Generate the misalignment computation outside LOOP. */ pe = loop_preheader_edge (loop); - new_bb = bsi_insert_on_edge_immediate (pe, new_stmt); + new_bb = gsi_insert_on_edge_immediate (pe, new_stmt); gcc_assert (!new_bb); } - *realignment_token = GIMPLE_STMT_OPERAND (new_stmt, 0); + *realignment_token = gimple_call_lhs (new_stmt); /* The result of the CALL_EXPR to this builtin is determined from the value of the parameter and no global variables are touched @@ -5257,7 +5317,7 @@ vect_setup_realignment (tree stmt, block_stmt_iterator *bsi, pe = loop_preheader_edge (containing_loop); vec_dest = vect_create_destination_var (scalar_dest, vectype); - msq = make_ssa_name (vec_dest, NULL_TREE); + msq = make_ssa_name (vec_dest, NULL); phi_stmt = create_phi_node (msq, containing_loop->header); SSA_NAME_DEF_STMT (msq) = phi_stmt; add_phi_arg (phi_stmt, msq_init, pe); @@ -5393,13 +5453,13 @@ vect_strided_load_supported (tree vectype) static bool vect_permute_load_chain (VEC(tree,heap) *dr_chain, unsigned int length, - tree stmt, - block_stmt_iterator *bsi, + gimple stmt, + gimple_stmt_iterator *gsi, VEC(tree,heap) **result_chain) { - tree perm_dest, perm_stmt, data_ref, first_vect, second_vect; + tree perm_dest, data_ref, first_vect, second_vect; + gimple perm_stmt; tree vectype = STMT_VINFO_VECTYPE (vinfo_for_stmt (stmt)); - tree tmp; int i; unsigned int j; @@ -5420,13 +5480,13 @@ vect_permute_load_chain (VEC(tree,heap) *dr_chain, DECL_GIMPLE_REG_P (perm_dest) = 1; add_referenced_var (perm_dest); - tmp = build2 (VEC_EXTRACT_EVEN_EXPR, vectype, - first_vect, second_vect); - perm_stmt = build_gimple_modify_stmt (perm_dest, tmp); + perm_stmt = gimple_build_assign_with_ops (VEC_EXTRACT_EVEN_EXPR, + perm_dest, first_vect, + second_vect); data_ref = make_ssa_name (perm_dest, perm_stmt); - GIMPLE_STMT_OPERAND (perm_stmt, 0) = data_ref; - vect_finish_stmt_generation (stmt, perm_stmt, bsi); + gimple_assign_set_lhs (perm_stmt, data_ref); + vect_finish_stmt_generation (stmt, perm_stmt, gsi); mark_symbols_for_renaming (perm_stmt); VEC_replace (tree, *result_chain, j/2, data_ref); @@ -5436,12 +5496,12 @@ vect_permute_load_chain (VEC(tree,heap) *dr_chain, DECL_GIMPLE_REG_P (perm_dest) = 1; add_referenced_var (perm_dest); - tmp = build2 (VEC_EXTRACT_ODD_EXPR, vectype, - first_vect, second_vect); - perm_stmt = build_gimple_modify_stmt (perm_dest, tmp); + perm_stmt = gimple_build_assign_with_ops (VEC_EXTRACT_ODD_EXPR, + perm_dest, first_vect, + second_vect); data_ref = make_ssa_name (perm_dest, perm_stmt); - GIMPLE_STMT_OPERAND (perm_stmt, 0) = data_ref; - vect_finish_stmt_generation (stmt, perm_stmt, bsi); + gimple_assign_set_lhs (perm_stmt, data_ref); + vect_finish_stmt_generation (stmt, perm_stmt, gsi); mark_symbols_for_renaming (perm_stmt); VEC_replace (tree, *result_chain, j/2+length/2, data_ref); @@ -5460,12 +5520,12 @@ vect_permute_load_chain (VEC(tree,heap) *dr_chain, */ static bool -vect_transform_strided_load (tree stmt, VEC(tree,heap) *dr_chain, int size, - block_stmt_iterator *bsi) +vect_transform_strided_load (gimple stmt, VEC(tree,heap) *dr_chain, int size, + gimple_stmt_iterator *gsi) { stmt_vec_info stmt_info = vinfo_for_stmt (stmt); - tree first_stmt = DR_GROUP_FIRST_DR (stmt_info); - tree next_stmt, new_stmt; + gimple first_stmt = DR_GROUP_FIRST_DR (stmt_info); + gimple next_stmt, new_stmt; VEC(tree,heap) *result_chain = NULL; unsigned int i, gap_count; tree tmp_data_ref; @@ -5475,7 +5535,7 @@ vect_transform_strided_load (tree stmt, VEC(tree,heap) *dr_chain, int size, vectors, that are ready for vector computation. */ result_chain = VEC_alloc (tree, heap, size); /* Permute. */ - if (!vect_permute_load_chain (dr_chain, size, stmt, bsi, &result_chain)) + if (!vect_permute_load_chain (dr_chain, size, stmt, gsi, &result_chain)) return false; /* Put a permuted data-ref in the VECTORIZED_STMT field. @@ -5512,9 +5572,10 @@ vect_transform_strided_load (tree stmt, VEC(tree,heap) *dr_chain, int size, STMT_VINFO_VEC_STMT (vinfo_for_stmt (next_stmt)) = new_stmt; else { - tree prev_stmt = STMT_VINFO_VEC_STMT (vinfo_for_stmt (next_stmt)); - tree rel_stmt = STMT_VINFO_RELATED_STMT ( - vinfo_for_stmt (prev_stmt)); + gimple prev_stmt = + STMT_VINFO_VEC_STMT (vinfo_for_stmt (next_stmt)); + gimple rel_stmt = + STMT_VINFO_RELATED_STMT (vinfo_for_stmt (prev_stmt)); while (rel_stmt) { prev_stmt = rel_stmt; @@ -5546,44 +5607,44 @@ vect_transform_strided_load (tree stmt, VEC(tree,heap) *dr_chain, int size, Return FALSE if not a vectorizable STMT, TRUE otherwise. */ bool -vectorizable_load (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, +vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, slp_tree slp_node) { tree scalar_dest; tree vec_dest = NULL; tree data_ref = NULL; - tree op; stmt_vec_info stmt_info = vinfo_for_stmt (stmt); stmt_vec_info prev_stmt_info; loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); - struct loop *containing_loop = (bb_for_stmt (stmt))->loop_father; + struct loop *containing_loop = (gimple_bb (stmt))->loop_father; bool nested_in_vect_loop = nested_in_vect_loop_p (loop, stmt); struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info), *first_dr; tree vectype = STMT_VINFO_VECTYPE (stmt_info); tree new_temp; int mode; - tree new_stmt = NULL_TREE; + gimple new_stmt = NULL; tree dummy; enum dr_alignment_support alignment_support_scheme; tree dataref_ptr = NULL_TREE; - tree ptr_incr; + gimple ptr_incr; int nunits = TYPE_VECTOR_SUBPARTS (vectype); int ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits; int i, j, group_size; tree msq = NULL_TREE, lsq; tree offset = NULL_TREE; tree realignment_token = NULL_TREE; - tree phi = NULL_TREE; + gimple phi = NULL; VEC(tree,heap) *dr_chain = NULL; bool strided_load = false; - tree first_stmt; + gimple first_stmt; tree scalar_type; bool inv_p; bool compute_in_loop = false; struct loop *at_loop; int vec_num; bool slp = (slp_node != NULL); + enum tree_code code; /* FORNOW: SLP with multiple types is not supported. The SLP analysis verifies this, so we can safely override NCOPIES with 1 here. */ @@ -5607,16 +5668,16 @@ vectorizable_load (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, return false; /* Is vectorizable load? */ - if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT) + if (!is_gimple_assign (stmt)) return false; - scalar_dest = GIMPLE_STMT_OPERAND (stmt, 0); + scalar_dest = gimple_assign_lhs (stmt); if (TREE_CODE (scalar_dest) != SSA_NAME) return false; - op = GIMPLE_STMT_OPERAND (stmt, 1); - if (TREE_CODE (op) != ARRAY_REF - && TREE_CODE (op) != INDIRECT_REF + code = gimple_assign_rhs_code (stmt); + if (code != ARRAY_REF + && code != INDIRECT_REF && !STMT_VINFO_STRIDED_ACCESS (stmt_info)) return false; @@ -5818,7 +5879,7 @@ vectorizable_load (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, || alignment_support_scheme == dr_explicit_realign) && !compute_in_loop) { - msq = vect_setup_realignment (first_stmt, bsi, &realignment_token, + msq = vect_setup_realignment (first_stmt, gsi, &realignment_token, alignment_support_scheme, NULL_TREE, &at_loop); if (alignment_support_scheme == dr_explicit_realign_optimized) @@ -5841,12 +5902,12 @@ vectorizable_load (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, &inv_p); else dataref_ptr = - bump_vector_ptr (dataref_ptr, ptr_incr, bsi, stmt, NULL_TREE); + bump_vector_ptr (dataref_ptr, ptr_incr, gsi, stmt, NULL_TREE); for (i = 0; i < vec_num; i++) { if (i > 0) - dataref_ptr = bump_vector_ptr (dataref_ptr, ptr_incr, bsi, stmt, + dataref_ptr = bump_vector_ptr (dataref_ptr, ptr_incr, gsi, stmt, NULL_TREE); /* 2. Create the vector-load in the loop. */ @@ -5872,24 +5933,24 @@ vectorizable_load (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, tree vs_minus_1 = size_int (TYPE_VECTOR_SUBPARTS (vectype) - 1); if (compute_in_loop) - msq = vect_setup_realignment (first_stmt, bsi, + msq = vect_setup_realignment (first_stmt, gsi, &realignment_token, dr_explicit_realign, dataref_ptr, NULL); data_ref = build1 (ALIGN_INDIRECT_REF, vectype, dataref_ptr); vec_dest = vect_create_destination_var (scalar_dest, vectype); - new_stmt = build_gimple_modify_stmt (vec_dest, data_ref); + new_stmt = gimple_build_assign (vec_dest, data_ref); new_temp = make_ssa_name (vec_dest, new_stmt); - GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp; - vect_finish_stmt_generation (stmt, new_stmt, bsi); + gimple_assign_set_lhs (new_stmt, new_temp); + vect_finish_stmt_generation (stmt, new_stmt, gsi); copy_virtual_operands (new_stmt, stmt); mark_symbols_for_renaming (new_stmt); msq = new_temp; bump = size_binop (MULT_EXPR, vs_minus_1, TYPE_SIZE_UNIT (scalar_type)); - ptr = bump_vector_ptr (dataref_ptr, NULL_TREE, bsi, stmt, bump); + ptr = bump_vector_ptr (dataref_ptr, NULL, gsi, stmt, bump); data_ref = build1 (ALIGN_INDIRECT_REF, vectype, ptr); break; } @@ -5900,10 +5961,10 @@ vectorizable_load (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, gcc_unreachable (); } vec_dest = vect_create_destination_var (scalar_dest, vectype); - new_stmt = build_gimple_modify_stmt (vec_dest, data_ref); + new_stmt = gimple_build_assign (vec_dest, data_ref); new_temp = make_ssa_name (vec_dest, new_stmt); - GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp; - vect_finish_stmt_generation (stmt, new_stmt, bsi); + gimple_assign_set_lhs (new_stmt, new_temp); + vect_finish_stmt_generation (stmt, new_stmt, gsi); mark_symbols_for_renaming (new_stmt); /* 3. Handle explicit realignment if necessary/supported. Create in @@ -5911,19 +5972,22 @@ vectorizable_load (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, if (alignment_support_scheme == dr_explicit_realign_optimized || alignment_support_scheme == dr_explicit_realign) { - lsq = GIMPLE_STMT_OPERAND (new_stmt, 0); + tree tmp; + + lsq = gimple_assign_lhs (new_stmt); if (!realignment_token) realignment_token = dataref_ptr; vec_dest = vect_create_destination_var (scalar_dest, vectype); - new_stmt = build3 (REALIGN_LOAD_EXPR, vectype, msq, lsq, - realignment_token); - new_stmt = build_gimple_modify_stmt (vec_dest, new_stmt); + tmp = build3 (REALIGN_LOAD_EXPR, vectype, msq, lsq, + realignment_token); + new_stmt = gimple_build_assign (vec_dest, tmp); new_temp = make_ssa_name (vec_dest, new_stmt); - GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp; - vect_finish_stmt_generation (stmt, new_stmt, bsi); + gimple_assign_set_lhs (new_stmt, new_temp); + vect_finish_stmt_generation (stmt, new_stmt, gsi); if (alignment_support_scheme == dr_explicit_realign_optimized) { + gcc_assert (phi); if (i == vec_num - 1 && j == ncopies - 1) add_phi_arg (phi, lsq, loop_latch_edge (containing_loop)); msq = lsq; @@ -5944,19 +6008,19 @@ vectorizable_load (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, /* CHECKME: bitpos depends on endianess? */ bitpos = bitsize_zero_node; vec_inv = build3 (BIT_FIELD_REF, scalar_type, new_temp, - bitsize, bitpos); + bitsize, bitpos); vec_dest = vect_create_destination_var (scalar_dest, NULL_TREE); - new_stmt = build_gimple_modify_stmt (vec_dest, vec_inv); + new_stmt = gimple_build_assign (vec_dest, vec_inv); new_temp = make_ssa_name (vec_dest, new_stmt); - GIMPLE_STMT_OPERAND (new_stmt, 0) = new_temp; - vect_finish_stmt_generation (stmt, new_stmt, bsi); + gimple_assign_set_lhs (new_stmt, new_temp); + vect_finish_stmt_generation (stmt, new_stmt, gsi); for (k = nunits - 1; k >= 0; --k) t = tree_cons (NULL_TREE, new_temp, t); /* FIXME: use build_constructor directly. */ vec_inv = build_constructor_from_list (vectype, t); - new_temp = vect_init_vector (stmt, vec_inv, vectype, bsi); + new_temp = vect_init_vector (stmt, vec_inv, vectype, gsi); new_stmt = SSA_NAME_DEF_STMT (new_temp); } else @@ -5970,7 +6034,7 @@ vectorizable_load (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, /* Store vector loads in the corresponding SLP_NODE. */ if (slp) - VEC_quick_push (tree, SLP_TREE_VEC_STMTS (slp_node), new_stmt); + VEC_quick_push (gimple, SLP_TREE_VEC_STMTS (slp_node), new_stmt); } /* FORNOW: SLP with multiple types is unsupported. */ @@ -5979,7 +6043,7 @@ vectorizable_load (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, if (strided_load) { - if (!vect_transform_strided_load (stmt, dr_chain, group_size, bsi)) + if (!vect_transform_strided_load (stmt, dr_chain, group_size, gsi)) return false; *vec_stmt = STMT_VINFO_VEC_STMT (stmt_info); VEC_free (tree, heap, dr_chain); @@ -6008,37 +6072,42 @@ vectorizable_load (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt, it can be supported. */ bool -vectorizable_live_operation (tree stmt, - block_stmt_iterator *bsi ATTRIBUTE_UNUSED, - tree *vec_stmt ATTRIBUTE_UNUSED) +vectorizable_live_operation (gimple stmt, + gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED, + gimple *vec_stmt ATTRIBUTE_UNUSED) { - tree operation; 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); int i; int op_type; tree op; - tree def, def_stmt; + tree def; + gimple def_stmt; enum vect_def_type dt; + enum tree_code code; + enum gimple_rhs_class rhs_class; gcc_assert (STMT_VINFO_LIVE_P (stmt_info)); if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_reduction_def) return false; - if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT) + if (!is_gimple_assign (stmt)) return false; - if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) != SSA_NAME) + if (TREE_CODE (gimple_assign_lhs (stmt)) != SSA_NAME) return false; /* FORNOW. CHECKME. */ if (nested_in_vect_loop_p (loop, stmt)) return false; - operation = GIMPLE_STMT_OPERAND (stmt, 1); - op_type = TREE_OPERAND_LENGTH (operation); + code = gimple_assign_rhs_code (stmt); + op_type = TREE_CODE_LENGTH (code); + rhs_class = get_gimple_rhs_class (code); + gcc_assert (rhs_class != GIMPLE_UNARY_RHS || op_type == unary_op); + gcc_assert (rhs_class != GIMPLE_BINARY_RHS || op_type == binary_op); /* FORNOW: support only if all uses are invariant. This means that the scalar operations can remain in place, unvectorized. @@ -6046,7 +6115,10 @@ vectorizable_live_operation (tree stmt, for (i = 0; i < op_type; i++) { - op = TREE_OPERAND (operation, i); + if (rhs_class == GIMPLE_SINGLE_RHS) + op = TREE_OPERAND (gimple_op (stmt, 1), i); + else + op = gimple_op (stmt, i + 1); if (op && !vect_is_simple_use (op, loop_vinfo, &def_stmt, &def, &dt)) { if (vect_print_dump_info (REPORT_DETAILS)) @@ -6087,7 +6159,7 @@ vect_is_simple_cond (tree cond, loop_vec_info loop_vinfo) if (TREE_CODE (lhs) == SSA_NAME) { - tree lhs_def_stmt = SSA_NAME_DEF_STMT (lhs); + gimple lhs_def_stmt = SSA_NAME_DEF_STMT (lhs); if (!vect_is_simple_use (lhs, loop_vinfo, &lhs_def_stmt, &def, &dt)) return false; } @@ -6097,7 +6169,7 @@ vect_is_simple_cond (tree cond, loop_vec_info loop_vinfo) if (TREE_CODE (rhs) == SSA_NAME) { - tree rhs_def_stmt = SSA_NAME_DEF_STMT (rhs); + gimple rhs_def_stmt = SSA_NAME_DEF_STMT (rhs); if (!vect_is_simple_use (rhs, loop_vinfo, &rhs_def_stmt, &def, &dt)) return false; } @@ -6118,7 +6190,8 @@ vect_is_simple_cond (tree cond, loop_vec_info loop_vinfo) Return FALSE if not a vectorizable STMT, TRUE otherwise. */ bool -vectorizable_condition (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) +vectorizable_condition (gimple stmt, gimple_stmt_iterator *gsi, + gimple *vec_stmt) { tree scalar_dest = NULL_TREE; tree vec_dest = NULL_TREE; @@ -6135,6 +6208,7 @@ vectorizable_condition (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) enum vect_def_type dt; int nunits = TYPE_VECTOR_SUBPARTS (vectype); int ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits; + enum tree_code code; gcc_assert (ncopies >= 1); if (ncopies > 1) @@ -6159,14 +6233,16 @@ vectorizable_condition (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) } /* Is vectorizable conditional operation? */ - if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT) + if (!is_gimple_assign (stmt)) return false; - op = GIMPLE_STMT_OPERAND (stmt, 1); + code = gimple_assign_rhs_code (stmt); - if (TREE_CODE (op) != COND_EXPR) + if (code != COND_EXPR) return false; + gcc_assert (gimple_assign_single_p (stmt)); + op = gimple_assign_rhs1 (stmt); cond_expr = TREE_OPERAND (op, 0); then_clause = TREE_OPERAND (op, 1); else_clause = TREE_OPERAND (op, 2); @@ -6181,7 +6257,7 @@ vectorizable_condition (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) if (TREE_CODE (then_clause) == SSA_NAME) { - tree then_def_stmt = SSA_NAME_DEF_STMT (then_clause); + gimple then_def_stmt = SSA_NAME_DEF_STMT (then_clause); if (!vect_is_simple_use (then_clause, loop_vinfo, &then_def_stmt, &def, &dt)) return false; @@ -6193,7 +6269,7 @@ vectorizable_condition (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) if (TREE_CODE (else_clause) == SSA_NAME) { - tree else_def_stmt = SSA_NAME_DEF_STMT (else_clause); + gimple else_def_stmt = SSA_NAME_DEF_STMT (else_clause); if (!vect_is_simple_use (else_clause, loop_vinfo, &else_def_stmt, &def, &dt)) return false; @@ -6215,7 +6291,7 @@ vectorizable_condition (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) /* Transform */ /* Handle def. */ - scalar_dest = GIMPLE_STMT_OPERAND (stmt, 0); + scalar_dest = gimple_assign_lhs (stmt); vec_dest = vect_create_destination_var (scalar_dest, vectype); /* Handle cond expr. */ @@ -6232,10 +6308,10 @@ vectorizable_condition (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) vec_cond_expr = build3 (VEC_COND_EXPR, vectype, vec_compare, vec_then_clause, vec_else_clause); - *vec_stmt = build_gimple_modify_stmt (vec_dest, vec_cond_expr); + *vec_stmt = gimple_build_assign (vec_dest, vec_cond_expr); new_temp = make_ssa_name (vec_dest, *vec_stmt); - GIMPLE_STMT_OPERAND (*vec_stmt, 0) = new_temp; - vect_finish_stmt_generation (stmt, *vec_stmt, bsi); + gimple_assign_set_lhs (*vec_stmt, new_temp); + vect_finish_stmt_generation (stmt, *vec_stmt, gsi); return true; } @@ -6246,57 +6322,57 @@ vectorizable_condition (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) Create a vectorized stmt to replace STMT, and insert it at BSI. */ static bool -vect_transform_stmt (tree stmt, block_stmt_iterator *bsi, bool *strided_store, - slp_tree slp_node) +vect_transform_stmt (gimple stmt, gimple_stmt_iterator *gsi, + bool *strided_store, slp_tree slp_node) { bool is_store = false; - tree vec_stmt = NULL_TREE; + gimple vec_stmt = NULL; stmt_vec_info stmt_info = vinfo_for_stmt (stmt); - tree orig_stmt_in_pattern; + gimple orig_stmt_in_pattern; bool done; switch (STMT_VINFO_TYPE (stmt_info)) { case type_demotion_vec_info_type: gcc_assert (!slp_node); - done = vectorizable_type_demotion (stmt, bsi, &vec_stmt); + done = vectorizable_type_demotion (stmt, gsi, &vec_stmt); gcc_assert (done); break; case type_promotion_vec_info_type: gcc_assert (!slp_node); - done = vectorizable_type_promotion (stmt, bsi, &vec_stmt); + done = vectorizable_type_promotion (stmt, gsi, &vec_stmt); gcc_assert (done); break; case type_conversion_vec_info_type: - done = vectorizable_conversion (stmt, bsi, &vec_stmt, slp_node); + done = vectorizable_conversion (stmt, gsi, &vec_stmt, slp_node); gcc_assert (done); break; case induc_vec_info_type: gcc_assert (!slp_node); - done = vectorizable_induction (stmt, bsi, &vec_stmt); + done = vectorizable_induction (stmt, gsi, &vec_stmt); gcc_assert (done); break; case op_vec_info_type: - done = vectorizable_operation (stmt, bsi, &vec_stmt, slp_node); + done = vectorizable_operation (stmt, gsi, &vec_stmt, slp_node); gcc_assert (done); break; case assignment_vec_info_type: - done = vectorizable_assignment (stmt, bsi, &vec_stmt, slp_node); + done = vectorizable_assignment (stmt, gsi, &vec_stmt, slp_node); gcc_assert (done); break; case load_vec_info_type: - done = vectorizable_load (stmt, bsi, &vec_stmt, slp_node); + done = vectorizable_load (stmt, gsi, &vec_stmt, slp_node); gcc_assert (done); break; case store_vec_info_type: - done = vectorizable_store (stmt, bsi, &vec_stmt, slp_node); + done = vectorizable_store (stmt, gsi, &vec_stmt, slp_node); gcc_assert (done); if (STMT_VINFO_STRIDED_ACCESS (stmt_info)) { @@ -6314,18 +6390,18 @@ vect_transform_stmt (tree stmt, block_stmt_iterator *bsi, bool *strided_store, case condition_vec_info_type: gcc_assert (!slp_node); - done = vectorizable_condition (stmt, bsi, &vec_stmt); + done = vectorizable_condition (stmt, gsi, &vec_stmt); gcc_assert (done); break; case call_vec_info_type: gcc_assert (!slp_node); - done = vectorizable_call (stmt, bsi, &vec_stmt); + done = vectorizable_call (stmt, gsi, &vec_stmt); break; case reduc_vec_info_type: gcc_assert (!slp_node); - done = vectorizable_reduction (stmt, bsi, &vec_stmt); + done = vectorizable_reduction (stmt, gsi, &vec_stmt); gcc_assert (done); break; @@ -6341,7 +6417,7 @@ vect_transform_stmt (tree stmt, block_stmt_iterator *bsi, bool *strided_store, if (STMT_VINFO_LIVE_P (stmt_info) && STMT_VINFO_TYPE (stmt_info) != reduc_vec_info_type) { - done = vectorizable_live_operation (stmt, bsi, &vec_stmt); + done = vectorizable_live_operation (stmt, gsi, &vec_stmt); gcc_assert (done); } @@ -6375,19 +6451,20 @@ vect_transform_stmt (tree stmt, block_stmt_iterator *bsi, bool *strided_store, static tree vect_build_loop_niters (loop_vec_info loop_vinfo) { - tree ni_name, stmt, var; + tree ni_name, var; + gimple_seq stmts = NULL; edge pe; struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); tree ni = unshare_expr (LOOP_VINFO_NITERS (loop_vinfo)); var = create_tmp_var (TREE_TYPE (ni), "niters"); add_referenced_var (var); - ni_name = force_gimple_operand (ni, &stmt, false, var); + ni_name = force_gimple_operand (ni, &stmts, false, var); pe = loop_preheader_edge (loop); - if (stmt) + if (stmts) { - basic_block new_bb = bsi_insert_on_edge_immediate (pe, stmt); + basic_block new_bb = gsi_insert_seq_on_edge_immediate (pe, stmts); gcc_assert (!new_bb); } @@ -6412,7 +6489,8 @@ vect_generate_tmps_on_preheader (loop_vec_info loop_vinfo, edge pe; basic_block new_bb; - tree stmt, ni_name; + gimple_seq stmts; + tree ni_name; tree var; tree ratio_name; tree ratio_mult_vf_name; @@ -6437,9 +6515,10 @@ vect_generate_tmps_on_preheader (loop_vec_info loop_vinfo, var = create_tmp_var (TREE_TYPE (ni), "bnd"); add_referenced_var (var); - ratio_name = force_gimple_operand (ratio_name, &stmt, true, var); + stmts = NULL; + ratio_name = force_gimple_operand (ratio_name, &stmts, true, var); pe = loop_preheader_edge (loop); - new_bb = bsi_insert_on_edge_immediate (pe, stmt); + new_bb = gsi_insert_seq_on_edge_immediate (pe, stmts); gcc_assert (!new_bb); } @@ -6452,10 +6531,11 @@ vect_generate_tmps_on_preheader (loop_vec_info loop_vinfo, var = create_tmp_var (TREE_TYPE (ni), "ratio_mult_vf"); add_referenced_var (var); - ratio_mult_vf_name = force_gimple_operand (ratio_mult_vf_name, &stmt, + stmts = NULL; + ratio_mult_vf_name = force_gimple_operand (ratio_mult_vf_name, &stmts, true, var); pe = loop_preheader_edge (loop); - new_bb = bsi_insert_on_edge_immediate (pe, stmt); + new_bb = gsi_insert_seq_on_edge_immediate (pe, stmts); gcc_assert (!new_bb); } @@ -6514,7 +6594,8 @@ vect_update_ivs_after_vectorizer (loop_vec_info loop_vinfo, tree niters, { struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); basic_block exit_bb = single_exit (loop)->dest; - tree phi, phi1; + gimple phi, phi1; + gimple_stmt_iterator gsi, gsi1; basic_block update_bb = update_e->dest; /* gcc_assert (vect_can_advance_ivs_p (loop_vinfo)); */ @@ -6522,21 +6603,23 @@ vect_update_ivs_after_vectorizer (loop_vec_info loop_vinfo, tree niters, /* Make sure there exists a single-predecessor exit bb: */ gcc_assert (single_pred_p (exit_bb)); - for (phi = phi_nodes (loop->header), phi1 = phi_nodes (update_bb); - phi && phi1; - phi = PHI_CHAIN (phi), phi1 = PHI_CHAIN (phi1)) + for (gsi = gsi_start_phis (loop->header), gsi1 = gsi_start_phis (update_bb); + !gsi_end_p (gsi) && !gsi_end_p (gsi1); + gsi_next (&gsi), gsi_next (&gsi1)) { tree access_fn = NULL; tree evolution_part; tree init_expr; tree step_expr; tree var, ni, ni_name; - block_stmt_iterator last_bsi; + gimple_stmt_iterator last_gsi; + phi = gsi_stmt (gsi); + phi1 = gsi_stmt (gsi1); if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "vect_update_ivs_after_vectorizer: phi: "); - print_generic_expr (vect_dump, phi, TDF_SLIM); + print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM); } /* Skip virtual phi's. */ @@ -6588,9 +6671,9 @@ vect_update_ivs_after_vectorizer (loop_vec_info loop_vinfo, tree niters, var = create_tmp_var (TREE_TYPE (init_expr), "tmp"); add_referenced_var (var); - last_bsi = bsi_last (exit_bb); - ni_name = force_gimple_operand_bsi (&last_bsi, ni, false, var, - true, BSI_SAME_STMT); + last_gsi = gsi_last_bb (exit_bb); + ni_name = force_gimple_operand_gsi (&last_gsi, ni, false, var, + true, GSI_SAME_STMT); /* Fix phi expressions in the successor bb. */ SET_PHI_ARG_DEF (phi1, update_e->dest_idx, ni_name); @@ -6665,7 +6748,7 @@ vect_do_peeling_for_loop_bound (loop_vec_info loop_vinfo, tree *ratio) /* If cost model check not done during versioning and peeling for alignment. */ - if (!VEC_length (tree, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)) + if (!VEC_length (gimple, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)) && !VEC_length (ddr_p, LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo)) && !LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo)) { @@ -6745,11 +6828,12 @@ vect_gen_niters_for_prolog_loop (loop_vec_info loop_vinfo, tree loop_niters) { struct data_reference *dr = LOOP_VINFO_UNALIGNED_DR (loop_vinfo); struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); - tree var, stmt; + tree var; + gimple_seq stmts; tree iters, iters_name; edge pe; basic_block new_bb; - tree dr_stmt = DR_STMT (dr); + gimple dr_stmt = DR_STMT (dr); stmt_vec_info stmt_info = vinfo_for_stmt (dr_stmt); tree vectype = STMT_VINFO_VECTYPE (stmt_info); int vectype_align = TYPE_ALIGN (vectype) / BITS_PER_UNIT; @@ -6776,7 +6860,7 @@ vect_gen_niters_for_prolog_loop (loop_vec_info loop_vinfo, tree loop_niters) } else { - tree new_stmts = NULL_TREE; + gimple_seq new_stmts = NULL; tree start_addr = vect_create_addr_base_for_vector_ref (dr_stmt, &new_stmts, NULL_TREE, loop); tree ptr_type = TREE_TYPE (start_addr); @@ -6790,7 +6874,7 @@ vect_gen_niters_for_prolog_loop (loop_vec_info loop_vinfo, tree loop_niters) tree byte_misalign; tree elem_misalign; - new_bb = bsi_insert_on_edge_immediate (pe, new_stmts); + new_bb = gsi_insert_seq_on_edge_immediate (pe, new_stmts); gcc_assert (!new_bb); /* Create: byte_misalign = addr & (vectype_size - 1) */ @@ -6822,12 +6906,13 @@ vect_gen_niters_for_prolog_loop (loop_vec_info loop_vinfo, tree loop_niters) var = create_tmp_var (niters_type, "prolog_loop_niters"); add_referenced_var (var); - iters_name = force_gimple_operand (iters, &stmt, false, var); + stmts = NULL; + iters_name = force_gimple_operand (iters, &stmts, false, var); /* Insert stmt on loop preheader edge. */ - if (stmt) + if (stmts) { - basic_block new_bb = bsi_insert_on_edge_immediate (pe, stmt); + basic_block new_bb = gsi_insert_seq_on_edge_immediate (pe, stmts); gcc_assert (!new_bb); } @@ -6905,7 +6990,7 @@ vect_do_peeling_for_alignment (loop_vec_info loop_vinfo) /* If cost model check not done during versioning. */ - if (!VEC_length (tree, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)) + if (!VEC_length (gimple, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)) && !VEC_length (ddr_p, LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo))) { check_profitability = true; @@ -6971,12 +7056,12 @@ vect_do_peeling_for_alignment (loop_vec_info loop_vinfo) static void vect_create_cond_for_align_checks (loop_vec_info loop_vinfo, tree *cond_expr, - tree *cond_expr_stmt_list) + gimple_seq *cond_expr_stmt_list) { struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); - VEC(tree,heap) *may_misalign_stmts + VEC(gimple,heap) *may_misalign_stmts = LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo); - tree ref_stmt, tmp; + gimple ref_stmt; int mask = LOOP_VINFO_PTR_MASK (loop_vinfo); tree mask_cst; unsigned int i; @@ -6984,7 +7069,8 @@ vect_create_cond_for_align_checks (loop_vec_info loop_vinfo, tree int_ptrsize_type; char tmp_name[20]; tree or_tmp_name = NULL_TREE; - tree and_tmp, and_tmp_name, and_stmt; + tree and_tmp, and_tmp_name; + gimple and_stmt; tree ptrsize_zero; tree part_cond_expr; @@ -7001,28 +7087,28 @@ vect_create_cond_for_align_checks (loop_vec_info loop_vinfo, /* Create expression (mask & (dr_1 || ... || dr_n)) where dr_i is the address of the first vector of the i'th data reference. */ - for (i = 0; VEC_iterate (tree, may_misalign_stmts, i, ref_stmt); i++) + for (i = 0; VEC_iterate (gimple, may_misalign_stmts, i, ref_stmt); i++) { - tree new_stmt_list = NULL_TREE; + gimple_seq new_stmt_list = NULL; tree addr_base; - tree addr_tmp, addr_tmp_name, addr_stmt; - tree or_tmp, new_or_tmp_name, or_stmt; + tree addr_tmp, addr_tmp_name; + tree or_tmp, new_or_tmp_name; + gimple addr_stmt, or_stmt; /* create: addr_tmp = (int)(address_of_first_vector) */ - addr_base = vect_create_addr_base_for_vector_ref (ref_stmt, - &new_stmt_list, NULL_TREE, loop); - - if (new_stmt_list != NULL_TREE) - append_to_statement_list_force (new_stmt_list, cond_expr_stmt_list); + addr_base = + vect_create_addr_base_for_vector_ref (ref_stmt, &new_stmt_list, + NULL_TREE, loop); + if (new_stmt_list != NULL) + gimple_seq_add_seq (cond_expr_stmt_list, new_stmt_list); sprintf (tmp_name, "%s%d", "addr2int", i); addr_tmp = create_tmp_var (int_ptrsize_type, tmp_name); add_referenced_var (addr_tmp); - addr_tmp_name = make_ssa_name (addr_tmp, NULL_TREE); - addr_stmt = fold_convert (int_ptrsize_type, addr_base); - addr_stmt = build_gimple_modify_stmt (addr_tmp_name, addr_stmt); + addr_tmp_name = make_ssa_name (addr_tmp, NULL); + addr_stmt = gimple_build_assign (addr_tmp_name, addr_base); SSA_NAME_DEF_STMT (addr_tmp_name) = addr_stmt; - append_to_statement_list_force (addr_stmt, cond_expr_stmt_list); + gimple_seq_add_stmt (cond_expr_stmt_list, addr_stmt); /* The addresses are OR together. */ @@ -7032,12 +7118,12 @@ vect_create_cond_for_align_checks (loop_vec_info loop_vinfo, sprintf (tmp_name, "%s%d", "orptrs", i); or_tmp = create_tmp_var (int_ptrsize_type, tmp_name); add_referenced_var (or_tmp); - new_or_tmp_name = make_ssa_name (or_tmp, NULL_TREE); - tmp = build2 (BIT_IOR_EXPR, int_ptrsize_type, - or_tmp_name, addr_tmp_name); - or_stmt = build_gimple_modify_stmt (new_or_tmp_name, tmp); + new_or_tmp_name = make_ssa_name (or_tmp, NULL); + or_stmt = gimple_build_assign_with_ops (BIT_IOR_EXPR, + new_or_tmp_name, + or_tmp_name, addr_tmp_name); SSA_NAME_DEF_STMT (new_or_tmp_name) = or_stmt; - append_to_statement_list_force (or_stmt, cond_expr_stmt_list); + gimple_seq_add_stmt (cond_expr_stmt_list, or_stmt); or_tmp_name = new_or_tmp_name; } else @@ -7050,12 +7136,12 @@ vect_create_cond_for_align_checks (loop_vec_info loop_vinfo, /* create: and_tmp = or_tmp & mask */ and_tmp = create_tmp_var (int_ptrsize_type, "andmask" ); add_referenced_var (and_tmp); - and_tmp_name = make_ssa_name (and_tmp, NULL_TREE); + and_tmp_name = make_ssa_name (and_tmp, NULL); - tmp = build2 (BIT_AND_EXPR, int_ptrsize_type, or_tmp_name, mask_cst); - and_stmt = build_gimple_modify_stmt (and_tmp_name, tmp); + and_stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, and_tmp_name, + or_tmp_name, mask_cst); SSA_NAME_DEF_STMT (and_tmp_name) = and_stmt; - append_to_statement_list_force (and_stmt, cond_expr_stmt_list); + gimple_seq_add_stmt (cond_expr_stmt_list, and_stmt); /* Make and_tmp the left operand of the conditional test against zero. if and_tmp has a nonzero bit then some address is unaligned. */ @@ -7124,7 +7210,7 @@ vect_vfa_segment_size (struct data_reference *dr, tree vect_factor) static void vect_create_cond_for_alias_checks (loop_vec_info loop_vinfo, tree * cond_expr, - tree * cond_expr_stmt_list) + gimple_seq * cond_expr_stmt_list) { struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); VEC (ddr_p, heap) * may_alias_ddrs = @@ -7151,10 +7237,10 @@ vect_create_cond_for_alias_checks (loop_vec_info loop_vinfo, for (i = 0; VEC_iterate (ddr_p, may_alias_ddrs, i, ddr); i++) { struct data_reference *dr_a, *dr_b; - tree dr_group_first_a, dr_group_first_b; + gimple dr_group_first_a, dr_group_first_b; tree addr_base_a, addr_base_b; tree segment_length_a, segment_length_b; - tree stmt_a, stmt_b; + gimple stmt_a, stmt_b; dr_a = DDR_A (ddr); stmt_a = DR_STMT (DDR_A (ddr)); @@ -7209,7 +7295,7 @@ vect_create_cond_for_alias_checks (loop_vec_info loop_vinfo, if (*cond_expr) *cond_expr = fold_build2 (TRUTH_AND_EXPR, boolean_type_node, - *cond_expr, part_cond_expr); + *cond_expr, part_cond_expr); else *cond_expr = part_cond_expr; } @@ -7241,15 +7327,16 @@ vect_loop_versioning (loop_vec_info loop_vinfo) struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); struct loop *nloop; tree cond_expr = NULL_TREE; - tree cond_expr_stmt_list = NULL_TREE; + gimple_seq cond_expr_stmt_list = NULL; basic_block condition_bb; - block_stmt_iterator cond_exp_bsi; + gimple_stmt_iterator gsi, cond_exp_gsi; basic_block merge_bb; basic_block new_exit_bb; edge new_exit_e, e; - tree orig_phi, new_phi, arg; + gimple orig_phi, new_phi; + tree arg; unsigned prob = 4 * REG_BR_PROB_BASE / 5; - tree gimplify_stmt_list; + gimple_seq gimplify_stmt_list = NULL; tree scalar_loop_iters = LOOP_VINFO_NITERS (loop_vinfo); int min_profitable_iters = 0; unsigned int th; @@ -7267,7 +7354,7 @@ vect_loop_versioning (loop_vec_info loop_vinfo) cond_expr = force_gimple_operand (cond_expr, &cond_expr_stmt_list, false, NULL_TREE); - if (VEC_length (tree, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo))) + if (VEC_length (gimple, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo))) vect_create_cond_for_align_checks (loop_vinfo, &cond_expr, &cond_expr_stmt_list); @@ -7278,9 +7365,8 @@ vect_loop_versioning (loop_vec_info loop_vinfo) cond_expr = fold_build2 (NE_EXPR, boolean_type_node, cond_expr, integer_zero_node); cond_expr = - force_gimple_operand (cond_expr, &gimplify_stmt_list, true, - NULL_TREE); - append_to_statement_list (gimplify_stmt_list, &cond_expr_stmt_list); + force_gimple_operand (cond_expr, &gimplify_stmt_list, true, NULL_TREE); + gimple_seq_add_seq (&cond_expr_stmt_list, gimplify_stmt_list); initialize_original_copy_tables (); nloop = loop_version (loop, cond_expr, &condition_bb, @@ -7301,9 +7387,9 @@ vect_loop_versioning (loop_vec_info loop_vinfo) new_exit_e = single_exit (loop); e = EDGE_SUCC (new_exit_bb, 0); - for (orig_phi = phi_nodes (merge_bb); orig_phi; - orig_phi = PHI_CHAIN (orig_phi)) + for (gsi = gsi_start_phis (merge_bb); !gsi_end_p (gsi); gsi_next (&gsi)) { + orig_phi = gsi_stmt (gsi); new_phi = create_phi_node (SSA_NAME_VAR (PHI_RESULT (orig_phi)), new_exit_bb); arg = PHI_ARG_DEF_FROM_EDGE (orig_phi, e); @@ -7316,8 +7402,8 @@ vect_loop_versioning (loop_vec_info loop_vinfo) update_ssa (TODO_update_ssa); if (cond_expr_stmt_list) { - cond_exp_bsi = bsi_last (condition_bb); - bsi_insert_before (&cond_exp_bsi, cond_expr_stmt_list, BSI_SAME_STMT); + cond_exp_gsi = gsi_last_bb (condition_bb); + gsi_insert_seq_before (&cond_exp_gsi, cond_expr_stmt_list, GSI_SAME_STMT); } } @@ -7325,17 +7411,17 @@ vect_loop_versioning (loop_vec_info loop_vinfo) stmt_vec_info. */ static void -vect_remove_stores (tree first_stmt) +vect_remove_stores (gimple first_stmt) { - tree next = first_stmt; - tree tmp; - block_stmt_iterator next_si; + gimple next = first_stmt; + gimple tmp; + gimple_stmt_iterator next_si; while (next) { /* Free the attached stmt_vec_info and remove the stmt. */ - next_si = bsi_for_stmt (next); - bsi_remove (&next_si, true); + next_si = gsi_for_stmt (next); + gsi_remove (&next_si, true); tmp = DR_GROUP_NEXT_DR (vinfo_for_stmt (next)); free_stmt_vec_info (next); next = tmp; @@ -7348,9 +7434,9 @@ vect_remove_stores (tree first_stmt) static bool vect_schedule_slp_instance (slp_tree node, unsigned int vec_stmts_size) { - tree stmt; + gimple stmt; bool strided_store, is_store; - block_stmt_iterator si; + gimple_stmt_iterator si; stmt_vec_info stmt_info; if (!node) @@ -7359,18 +7445,18 @@ vect_schedule_slp_instance (slp_tree node, unsigned int vec_stmts_size) vect_schedule_slp_instance (SLP_TREE_LEFT (node), vec_stmts_size); vect_schedule_slp_instance (SLP_TREE_RIGHT (node), vec_stmts_size); - stmt = VEC_index(tree, SLP_TREE_SCALAR_STMTS (node), 0); + stmt = VEC_index(gimple, SLP_TREE_SCALAR_STMTS (node), 0); stmt_info = vinfo_for_stmt (stmt); - SLP_TREE_VEC_STMTS (node) = VEC_alloc (tree, heap, vec_stmts_size); + SLP_TREE_VEC_STMTS (node) = VEC_alloc (gimple, heap, vec_stmts_size); SLP_TREE_NUMBER_OF_VEC_STMTS (node) = vec_stmts_size; if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "------>vectorizing SLP node starting from: "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } - si = bsi_for_stmt (stmt); + si = gsi_for_stmt (stmt); is_store = vect_transform_stmt (stmt, &si, &strided_store, node); if (is_store) { @@ -7436,7 +7522,7 @@ vect_transform_loop (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; int i; tree ratio = NULL; int vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo); @@ -7447,7 +7533,7 @@ vect_transform_loop (loop_vec_info loop_vinfo) if (vect_print_dump_info (REPORT_DETAILS)) fprintf (vect_dump, "=== vec_transform_loop ==="); - if (VEC_length (tree, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)) + if (VEC_length (gimple, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)) || VEC_length (ddr_p, LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo))) vect_loop_versioning (loop_vinfo); @@ -7493,14 +7579,15 @@ vect_transform_loop (loop_vec_info loop_vinfo) { basic_block bb = bbs[i]; stmt_vec_info stmt_info; - tree phi; + gimple phi; - 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, "------>vectorizing phi: "); - print_generic_expr (vect_dump, phi, TDF_SLIM); + print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM); } stmt_info = vinfo_for_stmt (phi); if (!stmt_info) @@ -7523,15 +7610,15 @@ vect_transform_loop (loop_vec_info loop_vinfo) } } - for (si = bsi_start (bb); !bsi_end_p (si);) + for (si = gsi_start_bb (bb); !gsi_end_p (si);) { - tree stmt = bsi_stmt (si); + gimple stmt = gsi_stmt (si); bool is_store; if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "------>vectorizing statement: "); - print_generic_expr (vect_dump, stmt, TDF_SLIM); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); } stmt_info = vinfo_for_stmt (stmt); @@ -7541,14 +7628,14 @@ vect_transform_loop (loop_vec_info loop_vinfo) need to be vectorized. */ if (!stmt_info) { - bsi_next (&si); + gsi_next (&si); continue; } if (!STMT_VINFO_RELEVANT_P (stmt_info) && !STMT_VINFO_LIVE_P (stmt_info)) { - bsi_next (&si); + gsi_next (&si); continue; } @@ -7580,7 +7667,7 @@ vect_transform_loop (loop_vec_info loop_vinfo) vect_schedule_slp_instance and their vinfo is destroyed. */ if (is_store) { - bsi_next (&si); + gsi_next (&si); continue; } } @@ -7588,7 +7675,7 @@ vect_transform_loop (loop_vec_info loop_vinfo) /* Hybrid SLP stmts must be vectorized in addition to SLP. */ if (PURE_SLP_STMT (stmt_info)) { - bsi_next (&si); + gsi_next (&si); continue; } } @@ -7607,18 +7694,18 @@ vect_transform_loop (loop_vec_info loop_vinfo) interleaving chain was completed - free all the stores in the chain. */ vect_remove_stores (DR_GROUP_FIRST_DR (stmt_info)); - bsi_remove (&si, true); + gsi_remove (&si, true); continue; } else { /* Free the attached stmt_vec_info and remove the stmt. */ free_stmt_vec_info (stmt); - bsi_remove (&si, true); + gsi_remove (&si, true); continue; } } - bsi_next (&si); + gsi_next (&si); } /* stmts in BB */ } /* BBs in loop */ |