diff options
Diffstat (limited to 'gcc/tree-vect-stmts.c')
| -rw-r--r-- | gcc/tree-vect-stmts.c | 250 |
1 files changed, 125 insertions, 125 deletions
diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c index d4a436d38b0..cb9e7e835e7 100644 --- a/gcc/tree-vect-stmts.c +++ b/gcc/tree-vect-stmts.c @@ -69,7 +69,7 @@ stmt_vectype (struct _stmt_vec_info *stmt_info) bool stmt_in_inner_loop_p (struct _stmt_vec_info *stmt_info) { - gimple stmt = STMT_VINFO_STMT (stmt_info); + gimple *stmt = STMT_VINFO_STMT (stmt_info); basic_block bb = gimple_bb (stmt); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); struct loop* loop; @@ -132,11 +132,11 @@ create_vector_array (tree elem_type, unsigned HOST_WIDE_INT nelems) with scalar destination SCALAR_DEST. */ static tree -read_vector_array (gimple stmt, gimple_stmt_iterator *gsi, tree scalar_dest, +read_vector_array (gimple *stmt, gimple_stmt_iterator *gsi, tree scalar_dest, tree array, unsigned HOST_WIDE_INT n) { tree vect_type, vect, vect_name, array_ref; - gimple new_stmt; + gimple *new_stmt; gcc_assert (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE); vect_type = TREE_TYPE (TREE_TYPE (array)); @@ -158,11 +158,11 @@ read_vector_array (gimple stmt, gimple_stmt_iterator *gsi, tree scalar_dest, The store is part of the vectorization of STMT. */ static void -write_vector_array (gimple stmt, gimple_stmt_iterator *gsi, tree vect, +write_vector_array (gimple *stmt, gimple_stmt_iterator *gsi, tree vect, tree array, unsigned HOST_WIDE_INT n) { tree array_ref; - gimple new_stmt; + gimple *new_stmt; array_ref = build4 (ARRAY_REF, TREE_TYPE (vect), array, build_int_cst (size_type_node, n), @@ -195,14 +195,14 @@ create_array_ref (tree type, tree ptr, struct data_reference *first_dr) Mark STMT as "relevant for vectorization" and add it to WORKLIST. */ static void -vect_mark_relevant (vec<gimple> *worklist, gimple stmt, +vect_mark_relevant (vec<gimple *> *worklist, gimple *stmt, enum vect_relevant relevant, bool live_p, bool used_in_pattern) { stmt_vec_info stmt_info = vinfo_for_stmt (stmt); enum vect_relevant save_relevant = STMT_VINFO_RELEVANT (stmt_info); bool save_live_p = STMT_VINFO_LIVE_P (stmt_info); - gimple pattern_stmt; + gimple *pattern_stmt; if (dump_enabled_p ()) dump_printf_loc (MSG_NOTE, vect_location, @@ -219,7 +219,7 @@ vect_mark_relevant (vec<gimple> *worklist, gimple stmt, { imm_use_iterator imm_iter; use_operand_p use_p; - gimple use_stmt; + gimple *use_stmt; tree lhs; loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); @@ -302,7 +302,7 @@ vect_mark_relevant (vec<gimple> *worklist, gimple stmt, CHECKME: what other side effects would the vectorizer allow? */ static bool -vect_stmt_relevant_p (gimple stmt, loop_vec_info loop_vinfo, +vect_stmt_relevant_p (gimple *stmt, loop_vec_info loop_vinfo, enum vect_relevant *relevant, bool *live_p) { struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); @@ -366,7 +366,7 @@ vect_stmt_relevant_p (gimple stmt, loop_vec_info loop_vinfo, used in STMT for anything other than indexing an array. */ static bool -exist_non_indexing_operands_for_use_p (tree use, gimple stmt) +exist_non_indexing_operands_for_use_p (tree use, gimple *stmt) { tree operand; stmt_vec_info stmt_info = vinfo_for_stmt (stmt); @@ -453,8 +453,8 @@ exist_non_indexing_operands_for_use_p (tree use, gimple stmt) Return true if everything is as expected. Return false otherwise. */ static bool -process_use (gimple stmt, tree use, loop_vec_info loop_vinfo, bool live_p, - enum vect_relevant relevant, vec<gimple> *worklist, +process_use (gimple *stmt, tree use, loop_vec_info loop_vinfo, bool live_p, + enum vect_relevant relevant, vec<gimple *> *worklist, bool force) { struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); @@ -462,7 +462,7 @@ process_use (gimple stmt, tree use, loop_vec_info loop_vinfo, bool live_p, stmt_vec_info dstmt_vinfo; basic_block bb, def_bb; tree def; - gimple def_stmt; + gimple *def_stmt; enum vect_def_type dt; /* case 1: we are only interested in uses that need to be vectorized. Uses @@ -614,11 +614,11 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo) basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo); unsigned int nbbs = loop->num_nodes; gimple_stmt_iterator si; - gimple stmt; + gimple *stmt; unsigned int i; stmt_vec_info stmt_vinfo; basic_block bb; - gimple phi; + gimple *phi; bool live_p; enum vect_relevant relevant, tmp_relevant; enum vect_def_type def_type; @@ -627,7 +627,7 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo) dump_printf_loc (MSG_NOTE, vect_location, "=== vect_mark_stmts_to_be_vectorized ===\n"); - auto_vec<gimple, 64> worklist; + auto_vec<gimple *, 64> worklist; /* 1. Init worklist. */ for (i = 0; i < nbbs; i++) @@ -907,7 +907,7 @@ vect_model_promotion_demotion_cost (stmt_vec_info stmt_info, static int vect_cost_group_size (stmt_vec_info stmt_info) { - gimple first_stmt = GROUP_FIRST_ELEMENT (stmt_info); + gimple *first_stmt = GROUP_FIRST_ELEMENT (stmt_info); if (first_stmt == STMT_VINFO_STMT (stmt_info)) return GROUP_SIZE (stmt_info); @@ -931,7 +931,7 @@ vect_model_store_cost (stmt_vec_info stmt_info, int ncopies, int group_size; unsigned int inside_cost = 0, prologue_cost = 0; struct data_reference *first_dr; - gimple first_stmt; + gimple *first_stmt; if (dt == vect_constant_def || dt == vect_external_def) prologue_cost += record_stmt_cost (prologue_cost_vec, 1, scalar_to_vec, @@ -1011,7 +1011,7 @@ vect_get_store_cost (struct data_reference *dr, int ncopies, stmt_vector_for_cost *body_cost_vec) { int alignment_support_scheme = vect_supportable_dr_alignment (dr, false); - gimple stmt = DR_STMT (dr); + gimple *stmt = DR_STMT (dr); stmt_vec_info stmt_info = vinfo_for_stmt (stmt); switch (alignment_support_scheme) @@ -1071,7 +1071,7 @@ vect_model_load_cost (stmt_vec_info stmt_info, int ncopies, stmt_vector_for_cost *body_cost_vec) { int group_size; - gimple first_stmt; + gimple *first_stmt; struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info), *first_dr; unsigned int inside_cost = 0, prologue_cost = 0; @@ -1145,7 +1145,7 @@ vect_get_load_cost (struct data_reference *dr, int ncopies, bool record_prologue_costs) { int alignment_support_scheme = vect_supportable_dr_alignment (dr, false); - gimple stmt = DR_STMT (dr); + gimple *stmt = DR_STMT (dr); stmt_vec_info stmt_info = vinfo_for_stmt (stmt); switch (alignment_support_scheme) @@ -1252,7 +1252,7 @@ vect_get_load_cost (struct data_reference *dr, int ncopies, the loop preheader for the vectorized stmt STMT. */ static void -vect_init_vector_1 (gimple stmt, gimple new_stmt, gimple_stmt_iterator *gsi) +vect_init_vector_1 (gimple *stmt, gimple *new_stmt, gimple_stmt_iterator *gsi) { if (gsi) vect_finish_stmt_generation (stmt, new_stmt, gsi); @@ -1306,10 +1306,10 @@ vect_init_vector_1 (gimple stmt, gimple new_stmt, gimple_stmt_iterator *gsi) It will be used in the vectorization of STMT. */ tree -vect_init_vector (gimple stmt, tree val, tree type, gimple_stmt_iterator *gsi) +vect_init_vector (gimple *stmt, tree val, tree type, gimple_stmt_iterator *gsi) { tree new_var; - gimple init_stmt; + gimple *init_stmt; tree vec_oprnd; tree new_temp; @@ -1353,11 +1353,11 @@ vect_init_vector (gimple stmt, tree val, tree type, gimple_stmt_iterator *gsi) needs to be introduced. */ tree -vect_get_vec_def_for_operand (tree op, gimple stmt, tree *scalar_def) +vect_get_vec_def_for_operand (tree op, gimple *stmt, tree *scalar_def) { tree vec_oprnd; - gimple vec_stmt; - gimple def_stmt; + gimple *vec_stmt; + gimple *def_stmt; stmt_vec_info def_stmt_info = NULL; stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt); unsigned int nunits; @@ -1555,7 +1555,7 @@ vect_get_vec_def_for_operand (tree op, gimple stmt, tree *scalar_def) tree vect_get_vec_def_for_stmt_copy (enum vect_def_type dt, tree vec_oprnd) { - gimple vec_stmt_for_operand; + gimple *vec_stmt_for_operand; stmt_vec_info def_stmt_info; /* Do nothing; can reuse same def. */ @@ -1603,7 +1603,7 @@ vect_get_vec_defs_for_stmt_copy (enum vect_def_type *dt, and -1 otherwise. */ void -vect_get_vec_defs (tree op0, tree op1, gimple stmt, +vect_get_vec_defs (tree op0, tree op1, gimple *stmt, vec<tree> *vec_oprnds0, vec<tree> *vec_oprnds1, slp_tree slp_node, int reduc_index) @@ -1647,7 +1647,7 @@ vect_get_vec_defs (tree op0, tree op1, gimple stmt, Insert a new stmt. */ void -vect_finish_stmt_generation (gimple stmt, gimple vec_stmt, +vect_finish_stmt_generation (gimple *stmt, gimple *vec_stmt, gimple_stmt_iterator *gsi) { stmt_vec_info stmt_info = vinfo_for_stmt (stmt); @@ -1659,7 +1659,7 @@ vect_finish_stmt_generation (gimple stmt, gimple vec_stmt, if (!gsi_end_p (*gsi) && gimple_has_mem_ops (vec_stmt)) { - gimple at_stmt = gsi_stmt (*gsi); + gimple *at_stmt = gsi_stmt (*gsi); tree vuse = gimple_vuse (at_stmt); if (vuse && TREE_CODE (vuse) == SSA_NAME) { @@ -1727,7 +1727,7 @@ vectorizable_function (gcall *call, tree vectype_out, tree vectype_in) } -static tree permute_vec_elements (tree, tree, tree, gimple, +static tree permute_vec_elements (tree, tree, tree, gimple *, gimple_stmt_iterator *); @@ -1739,8 +1739,8 @@ static tree permute_vec_elements (tree, tree, tree, gimple, Return FALSE if not a vectorizable STMT, TRUE otherwise. */ static bool -vectorizable_mask_load_store (gimple stmt, gimple_stmt_iterator *gsi, - gimple *vec_stmt, slp_tree slp_node) +vectorizable_mask_load_store (gimple *stmt, gimple_stmt_iterator *gsi, + gimple **vec_stmt, slp_tree slp_node) { tree vec_dest = NULL; stmt_vec_info stmt_info = vinfo_for_stmt (stmt); @@ -1751,10 +1751,10 @@ vectorizable_mask_load_store (gimple stmt, gimple_stmt_iterator *gsi, struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info); tree vectype = STMT_VINFO_VECTYPE (stmt_info); tree elem_type; - gimple new_stmt; + gimple *new_stmt; tree dummy; tree dataref_ptr = NULL_TREE; - gimple ptr_incr; + gimple *ptr_incr; int nunits = TYPE_VECTOR_SUBPARTS (vectype); int ncopies; int i, j; @@ -1765,7 +1765,7 @@ vectorizable_mask_load_store (gimple stmt, gimple_stmt_iterator *gsi, enum vect_def_type gather_dt = vect_unknown_def_type; bool is_store; tree mask; - gimple def_stmt; + gimple *def_stmt; tree def; enum vect_def_type dt; @@ -1809,7 +1809,7 @@ vectorizable_mask_load_store (gimple stmt, gimple_stmt_iterator *gsi, if (STMT_VINFO_GATHER_SCATTER_P (stmt_info)) { - gimple def_stmt; + gimple *def_stmt; tree def; gather_decl = vect_check_gather_scatter (stmt, loop_vinfo, &gather_base, &gather_off, &gather_scale); @@ -2178,7 +2178,7 @@ vectorizable_mask_load_store (gimple stmt, gimple_stmt_iterator *gsi, Return FALSE if not a vectorizable STMT, TRUE otherwise. */ static bool -vectorizable_call (gimple gs, gimple_stmt_iterator *gsi, gimple *vec_stmt, +vectorizable_call (gimple *gs, gimple_stmt_iterator *gsi, gimple **vec_stmt, slp_tree slp_node) { gcall *stmt; @@ -2193,10 +2193,10 @@ vectorizable_call (gimple gs, gimple_stmt_iterator *gsi, gimple *vec_stmt, loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info); tree fndecl, new_temp, def, rhs_type; - gimple def_stmt; + gimple *def_stmt; enum vect_def_type dt[3] = {vect_unknown_def_type, vect_unknown_def_type, vect_unknown_def_type}; - gimple new_stmt = NULL; + gimple *new_stmt = NULL; int ncopies, j; vec<tree> vargs = vNULL; enum { NARROW, NONE, WIDEN } modifier; @@ -2449,7 +2449,7 @@ vectorizable_call (gimple gs, gimple_stmt_iterator *gsi, gimple *vec_stmt, tree cst = build_vector (vectype_out, v); tree new_var = vect_get_new_vect_var (vectype_out, vect_simple_var, "cst_"); - gimple init_stmt = gimple_build_assign (new_var, cst); + gimple *init_stmt = gimple_build_assign (new_var, cst); new_temp = make_ssa_name (new_var, init_stmt); gimple_assign_set_lhs (init_stmt, new_temp); vect_init_vector_1 (stmt, init_stmt, NULL); @@ -2589,7 +2589,7 @@ vectorizable_call (gimple gs, gimple_stmt_iterator *gsi, gimple *vec_stmt, vectorized loop. */ imm_use_iterator iter; use_operand_p use_p; - gimple use_stmt; + gimple *use_stmt; FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs) { basic_block use_bb = gimple_bb (use_stmt); @@ -2632,7 +2632,7 @@ static void vect_simd_lane_linear (tree op, struct loop *loop, struct simd_call_arg_info *arginfo) { - gimple def_stmt = SSA_NAME_DEF_STMT (op); + gimple *def_stmt = SSA_NAME_DEF_STMT (op); if (!is_gimple_assign (def_stmt) || gimple_assign_rhs_code (def_stmt) != POINTER_PLUS_EXPR @@ -2703,8 +2703,8 @@ vect_simd_lane_linear (tree op, struct loop *loop, Return FALSE if not a vectorizable STMT, TRUE otherwise. */ static bool -vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi, - gimple *vec_stmt, slp_tree slp_node) +vectorizable_simd_clone_call (gimple *stmt, gimple_stmt_iterator *gsi, + gimple **vec_stmt, slp_tree slp_node) { tree vec_dest; tree scalar_dest; @@ -2717,8 +2717,8 @@ vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi, bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info); struct loop *loop = loop_vinfo ? LOOP_VINFO_LOOP (loop_vinfo) : NULL; tree fndecl, new_temp, def; - gimple def_stmt; - gimple new_stmt = NULL; + gimple *def_stmt; + gimple *new_stmt = NULL; int ncopies, j; vec<simd_call_arg_info> arginfo = vNULL; vec<tree> vargs = vNULL; @@ -3351,14 +3351,14 @@ vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi, needs to be created (DECL is a function-decl of a target-builtin). STMT is the original scalar stmt that we are vectorizing. */ -static gimple +static gimple * vect_gen_widened_results_half (enum tree_code code, tree decl, tree vec_oprnd0, tree vec_oprnd1, int op_type, tree vec_dest, gimple_stmt_iterator *gsi, - gimple stmt) + gimple *stmt) { - gimple new_stmt; + gimple *new_stmt; tree new_temp; /* Generate half of the widened result: */ @@ -3396,7 +3396,7 @@ vect_gen_widened_results_half (enum tree_code code, The vectors are collected into VEC_OPRNDS. */ static void -vect_get_loop_based_defs (tree *oprnd, gimple stmt, enum vect_def_type dt, +vect_get_loop_based_defs (tree *oprnd, gimple *stmt, enum vect_def_type dt, vec<tree> *vec_oprnds, int multi_step_cvt) { tree vec_oprnd; @@ -3430,7 +3430,7 @@ vect_get_loop_based_defs (tree *oprnd, gimple stmt, enum vect_def_type dt, static void vect_create_vectorized_demotion_stmts (vec<tree> *vec_oprnds, - int multi_step_cvt, gimple stmt, + int multi_step_cvt, gimple *stmt, vec<tree> vec_dsts, gimple_stmt_iterator *gsi, slp_tree slp_node, enum tree_code code, @@ -3438,7 +3438,7 @@ vect_create_vectorized_demotion_stmts (vec<tree> *vec_oprnds, { unsigned int i; tree vop0, vop1, new_tmp, vec_dest; - gimple new_stmt; + gimple *new_stmt; stmt_vec_info stmt_info = vinfo_for_stmt (stmt); vec_dest = vec_dsts.pop (); @@ -3501,7 +3501,7 @@ vect_create_vectorized_demotion_stmts (vec<tree> *vec_oprnds, static void vect_create_vectorized_promotion_stmts (vec<tree> *vec_oprnds0, vec<tree> *vec_oprnds1, - gimple stmt, tree vec_dest, + gimple *stmt, tree vec_dest, gimple_stmt_iterator *gsi, enum tree_code code1, enum tree_code code2, tree decl1, @@ -3509,7 +3509,7 @@ vect_create_vectorized_promotion_stmts (vec<tree> *vec_oprnds0, { int i; tree vop0, vop1, new_tmp1, new_tmp2; - gimple new_stmt1, new_stmt2; + gimple *new_stmt1, *new_stmt2; vec<tree> vec_tmp = vNULL; vec_tmp.create (vec_oprnds0->length () * 2); @@ -3552,8 +3552,8 @@ vect_create_vectorized_promotion_stmts (vec<tree> *vec_oprnds0, Return FALSE if not a vectorizable STMT, TRUE otherwise. */ static bool -vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi, - gimple *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; @@ -3566,9 +3566,9 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi, tree decl1 = NULL_TREE, decl2 = NULL_TREE; tree new_temp; tree def; - gimple def_stmt; + gimple *def_stmt; enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type}; - gimple new_stmt = NULL; + gimple *new_stmt = NULL; stmt_vec_info prev_stmt_info; int nunits_in; int nunits_out; @@ -4133,8 +4133,8 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi, Return FALSE if not a vectorizable STMT, TRUE otherwise. */ static bool -vectorizable_assignment (gimple stmt, gimple_stmt_iterator *gsi, - gimple *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; @@ -4143,14 +4143,14 @@ vectorizable_assignment (gimple stmt, gimple_stmt_iterator *gsi, loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); tree new_temp; tree def; - gimple def_stmt; + gimple *def_stmt; enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type}; int ncopies; int i, j; vec<tree> vec_oprnds = vNULL; tree vop; bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info); - gimple new_stmt = NULL; + gimple *new_stmt = NULL; stmt_vec_info prev_stmt_info = NULL; enum tree_code code; tree vectype_in; @@ -4332,8 +4332,8 @@ vect_supportable_shift (enum tree_code code, tree scalar_type) Return FALSE if not a vectorizable STMT, TRUE otherwise. */ static bool -vectorizable_shift (gimple stmt, gimple_stmt_iterator *gsi, - gimple *vec_stmt, slp_tree slp_node) +vectorizable_shift (gimple *stmt, gimple_stmt_iterator *gsi, + gimple **vec_stmt, slp_tree slp_node) { tree vec_dest; tree scalar_dest; @@ -4349,9 +4349,9 @@ vectorizable_shift (gimple stmt, gimple_stmt_iterator *gsi, int icode; machine_mode optab_op2_mode; tree def; - gimple def_stmt; + gimple *def_stmt; enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type}; - gimple new_stmt = NULL; + gimple *new_stmt = NULL; stmt_vec_info prev_stmt_info; int nunits_in; int nunits_out; @@ -4466,8 +4466,8 @@ vectorizable_shift (gimple stmt, gimple_stmt_iterator *gsi, a scalar shift. */ if (slp_node) { - vec<gimple> stmts = SLP_TREE_SCALAR_STMTS (slp_node); - gimple slpstmt; + vec<gimple *> stmts = SLP_TREE_SCALAR_STMTS (slp_node); + gimple *slpstmt; FOR_EACH_VEC_ELT (stmts, k, slpstmt) if (!operand_equal_p (gimple_assign_rhs2 (slpstmt), op1, 0)) @@ -4697,8 +4697,8 @@ vectorizable_shift (gimple stmt, gimple_stmt_iterator *gsi, Return FALSE if not a vectorizable STMT, TRUE otherwise. */ static bool -vectorizable_operation (gimple stmt, gimple_stmt_iterator *gsi, - gimple *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; @@ -4713,10 +4713,10 @@ vectorizable_operation (gimple stmt, gimple_stmt_iterator *gsi, optab optab; bool target_support_p; tree def; - gimple def_stmt; + gimple *def_stmt; enum vect_def_type dt[3] = {vect_unknown_def_type, vect_unknown_def_type, vect_unknown_def_type}; - gimple new_stmt = NULL; + gimple *new_stmt = NULL; stmt_vec_info prev_stmt_info; int nunits_in; int nunits_out; @@ -5093,7 +5093,7 @@ perm_mask_for_reverse (tree vectype) Return FALSE if not a vectorizable STMT, TRUE otherwise. */ static bool -vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, +vectorizable_store (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt, slp_tree slp_node) { tree scalar_dest; @@ -5109,15 +5109,15 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, tree dummy; enum dr_alignment_support alignment_support_scheme; tree def; - gimple def_stmt; + gimple *def_stmt; enum vect_def_type dt; stmt_vec_info prev_stmt_info = NULL; tree dataref_ptr = NULL_TREE; tree dataref_offset = NULL_TREE; - gimple ptr_incr = NULL; + gimple *ptr_incr = NULL; int ncopies; int j; - gimple next_stmt, first_stmt = NULL; + gimple *next_stmt, *first_stmt = NULL; bool grouped_store = false; bool store_lanes_p = false; unsigned int group_size, i; @@ -5137,7 +5137,7 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, int scatter_scale = 1; enum vect_def_type scatter_idx_dt = vect_unknown_def_type; enum vect_def_type scatter_src_dt = vect_unknown_def_type; - gimple new_stmt; + gimple *new_stmt; if (!STMT_VINFO_RELEVANT_P (stmt_info) && !bb_vinfo) return false; @@ -5297,7 +5297,7 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, if (STMT_VINFO_GATHER_SCATTER_P (stmt_info)) { - gimple def_stmt; + gimple *def_stmt; tree def; scatter_decl = vect_check_gather_scatter (stmt, loop_vinfo, &scatter_base, &scatter_off, &scatter_scale); @@ -5517,7 +5517,7 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, { gimple_stmt_iterator incr_gsi; bool insert_after; - gimple incr; + gimple *incr; tree offvar; tree ivstep; tree running_off; @@ -5637,7 +5637,7 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, for (i = 0; i < nstores; i++) { tree newref, newoff; - gimple incr, assign; + gimple *incr, *assign; tree size = TYPE_SIZE (ltype); /* Extract the i'th component. */ tree pos = fold_build2 (MULT_EXPR, bitsizetype, @@ -5925,7 +5925,7 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, tree new_temp = make_ssa_name (perm_dest); /* Generate the permute statement. */ - gimple perm_stmt + gimple *perm_stmt = gimple_build_assign (new_temp, VEC_PERM_EXPR, vec_oprnd, vec_oprnd, perm_mask); vect_finish_stmt_generation (stmt, perm_stmt, gsi); @@ -6005,12 +6005,12 @@ vect_gen_perm_mask_checked (tree vectype, const unsigned char *sel) permuted vector variable. */ static tree -permute_vec_elements (tree x, tree y, tree mask_vec, gimple stmt, +permute_vec_elements (tree x, tree y, tree mask_vec, gimple *stmt, gimple_stmt_iterator *gsi) { tree vectype = TREE_TYPE (x); tree perm_dest, data_ref; - gimple perm_stmt; + gimple *perm_stmt; perm_dest = vect_create_destination_var (gimple_get_lhs (stmt), vectype); data_ref = make_ssa_name (perm_dest); @@ -6028,7 +6028,7 @@ permute_vec_elements (tree x, tree y, tree mask_vec, gimple stmt, otherwise returns false. */ static bool -hoist_defs_of_uses (gimple stmt, struct loop *loop) +hoist_defs_of_uses (gimple *stmt, struct loop *loop) { ssa_op_iter i; tree op; @@ -6036,7 +6036,7 @@ hoist_defs_of_uses (gimple stmt, struct loop *loop) FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE) { - gimple def_stmt = SSA_NAME_DEF_STMT (op); + gimple *def_stmt = SSA_NAME_DEF_STMT (op); if (!gimple_nop_p (def_stmt) && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))) { @@ -6050,7 +6050,7 @@ hoist_defs_of_uses (gimple stmt, struct loop *loop) return false; FOR_EACH_SSA_TREE_OPERAND (op2, def_stmt, i2, SSA_OP_USE) { - gimple def_stmt2 = SSA_NAME_DEF_STMT (op2); + gimple *def_stmt2 = SSA_NAME_DEF_STMT (op2); if (!gimple_nop_p (def_stmt2) && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt2))) return false; @@ -6064,7 +6064,7 @@ hoist_defs_of_uses (gimple stmt, struct loop *loop) FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE) { - gimple def_stmt = SSA_NAME_DEF_STMT (op); + gimple *def_stmt = SSA_NAME_DEF_STMT (op); if (!gimple_nop_p (def_stmt) && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))) { @@ -6086,7 +6086,7 @@ hoist_defs_of_uses (gimple stmt, struct loop *loop) Return FALSE if not a vectorizable STMT, TRUE otherwise. */ static bool -vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, +vectorizable_load (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt, slp_tree slp_node, slp_instance slp_node_instance) { tree scalar_dest; @@ -6102,12 +6102,12 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, tree elem_type; tree new_temp; machine_mode mode; - gimple new_stmt = NULL; + gimple *new_stmt = NULL; tree dummy; enum dr_alignment_support alignment_support_scheme; tree dataref_ptr = NULL_TREE; tree dataref_offset = NULL_TREE; - gimple ptr_incr = NULL; + gimple *ptr_incr = NULL; int ncopies; int i, j, group_size = -1, group_gap_adj; tree msq = NULL_TREE, lsq; @@ -6118,7 +6118,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, vec<tree> dr_chain = vNULL; bool grouped_load = false; bool load_lanes_p = false; - gimple first_stmt; + gimple *first_stmt; bool inv_p; bool negative = false; bool compute_in_loop = false; @@ -6291,7 +6291,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, if (STMT_VINFO_GATHER_SCATTER_P (stmt_info)) { - gimple def_stmt; + gimple *def_stmt; tree def; gather_decl = vect_check_gather_scatter (stmt, loop_vinfo, &gather_base, &gather_off, &gather_scale); @@ -6553,7 +6553,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, { gimple_stmt_iterator incr_gsi; bool insert_after; - gimple incr; + gimple *incr; tree offvar; tree ivstep; tree running_off; @@ -6637,7 +6637,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, for (i = 0; i < nloads; i++) { tree newref, newoff; - gimple incr; + gimple *incr; newref = build2 (MEM_REF, ltype, running_off, alias_off); newref = force_gimple_operand_gsi (gsi, newref, true, @@ -6664,7 +6664,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, vect_finish_stmt_generation (stmt, new_stmt, gsi); tree newoff = copy_ssa_name (running_off); - gimple incr = gimple_build_assign (newoff, POINTER_PLUS_EXPR, + gimple *incr = gimple_build_assign (newoff, POINTER_PLUS_EXPR, running_off, stride_step); vect_finish_stmt_generation (stmt, incr, gsi); @@ -7229,7 +7229,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, condition operands are supportable using vec_is_simple_use. */ static bool -vect_is_simple_cond (tree cond, gimple stmt, loop_vec_info loop_vinfo, +vect_is_simple_cond (tree cond, gimple *stmt, loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, tree *comp_vectype) { tree lhs, rhs; @@ -7245,7 +7245,7 @@ vect_is_simple_cond (tree cond, gimple stmt, loop_vec_info loop_vinfo, if (TREE_CODE (lhs) == SSA_NAME) { - gimple lhs_def_stmt = SSA_NAME_DEF_STMT (lhs); + gimple *lhs_def_stmt = SSA_NAME_DEF_STMT (lhs); if (!vect_is_simple_use_1 (lhs, stmt, loop_vinfo, bb_vinfo, &lhs_def_stmt, &def, &dt, &vectype1)) return false; @@ -7256,7 +7256,7 @@ vect_is_simple_cond (tree cond, gimple stmt, loop_vec_info loop_vinfo, if (TREE_CODE (rhs) == SSA_NAME) { - gimple rhs_def_stmt = SSA_NAME_DEF_STMT (rhs); + gimple *rhs_def_stmt = SSA_NAME_DEF_STMT (rhs); if (!vect_is_simple_use_1 (rhs, stmt, loop_vinfo, bb_vinfo, &rhs_def_stmt, &def, &dt, &vectype2)) return false; @@ -7283,8 +7283,8 @@ vect_is_simple_cond (tree cond, gimple stmt, loop_vec_info loop_vinfo, Return FALSE if not a vectorizable STMT, TRUE otherwise. */ bool -vectorizable_condition (gimple stmt, gimple_stmt_iterator *gsi, - gimple *vec_stmt, tree reduc_def, int reduc_index, +vectorizable_condition (gimple *stmt, gimple_stmt_iterator *gsi, + gimple **vec_stmt, tree reduc_def, int reduc_index, slp_tree slp_node) { tree scalar_dest = NULL_TREE; @@ -7362,7 +7362,7 @@ vectorizable_condition (gimple stmt, gimple_stmt_iterator *gsi, if (TREE_CODE (then_clause) == SSA_NAME) { - gimple 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, stmt, loop_vinfo, bb_vinfo, &then_def_stmt, &def, &dt)) return false; @@ -7374,7 +7374,7 @@ vectorizable_condition (gimple stmt, gimple_stmt_iterator *gsi, if (TREE_CODE (else_clause) == SSA_NAME) { - gimple 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, stmt, loop_vinfo, bb_vinfo, &else_def_stmt, &def, &dt)) return false; @@ -7437,7 +7437,7 @@ vectorizable_condition (gimple stmt, gimple_stmt_iterator *gsi, } else { - gimple gtemp; + gimple *gtemp; vec_cond_lhs = vect_get_vec_def_for_operand (TREE_OPERAND (cond_expr, 0), stmt, NULL); @@ -7532,14 +7532,14 @@ vectorizable_condition (gimple stmt, gimple_stmt_iterator *gsi, /* Make sure the statement is vectorizable. */ bool -vect_analyze_stmt (gimple stmt, bool *need_to_vectorize, slp_tree node) +vect_analyze_stmt (gimple *stmt, bool *need_to_vectorize, slp_tree node) { stmt_vec_info stmt_info = vinfo_for_stmt (stmt); bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info); enum vect_relevant relevance = STMT_VINFO_RELEVANT (stmt_info); bool ok; tree scalar_type, vectype; - gimple pattern_stmt; + gimple *pattern_stmt; gimple_seq pattern_def_seq; if (dump_enabled_p ()) @@ -7624,7 +7624,7 @@ vect_analyze_stmt (gimple stmt, bool *need_to_vectorize, slp_tree node) for (si = gsi_start (pattern_def_seq); !gsi_end_p (si); gsi_next (&si)) { - gimple pattern_def_stmt = gsi_stmt (si); + gimple *pattern_def_stmt = gsi_stmt (si); if (STMT_VINFO_RELEVANT_P (vinfo_for_stmt (pattern_def_stmt)) || STMT_VINFO_LIVE_P (vinfo_for_stmt (pattern_def_stmt))) { @@ -7790,16 +7790,16 @@ vect_analyze_stmt (gimple stmt, bool *need_to_vectorize, slp_tree node) Create a vectorized stmt to replace STMT, and insert it at BSI. */ bool -vect_transform_stmt (gimple stmt, gimple_stmt_iterator *gsi, +vect_transform_stmt (gimple *stmt, gimple_stmt_iterator *gsi, bool *grouped_store, slp_tree slp_node, slp_instance slp_node_instance) { bool is_store = false; - gimple vec_stmt = NULL; + gimple *vec_stmt = NULL; stmt_vec_info stmt_info = vinfo_for_stmt (stmt); bool done; - gimple old_vec_stmt = STMT_VINFO_VEC_STMT (stmt_info); + gimple *old_vec_stmt = STMT_VINFO_VEC_STMT (stmt_info); switch (STMT_VINFO_TYPE (stmt_info)) { @@ -7910,7 +7910,7 @@ vect_transform_stmt (gimple stmt, gimple_stmt_iterator *gsi, imm_use_iterator imm_iter; use_operand_p use_p; tree scalar_dest; - gimple exit_phi; + gimple *exit_phi; if (dump_enabled_p ()) dump_printf_loc (MSG_NOTE, vect_location, @@ -7954,10 +7954,10 @@ vect_transform_stmt (gimple stmt, gimple_stmt_iterator *gsi, stmt_vec_info. */ void -vect_remove_stores (gimple first_stmt) +vect_remove_stores (gimple *first_stmt) { - gimple next = first_stmt; - gimple tmp; + gimple *next = first_stmt; + gimple *tmp; gimple_stmt_iterator next_si; while (next) @@ -7983,7 +7983,7 @@ vect_remove_stores (gimple first_stmt) Create and initialize a new stmt_vec_info struct for STMT. */ stmt_vec_info -new_stmt_vec_info (gimple stmt, loop_vec_info loop_vinfo, +new_stmt_vec_info (gimple *stmt, loop_vec_info loop_vinfo, bb_vec_info bb_vinfo) { stmt_vec_info res; @@ -8056,7 +8056,7 @@ free_stmt_vec_info_vec (void) /* Free stmt vectorization related info. */ void -free_stmt_vec_info (gimple stmt) +free_stmt_vec_info (gimple *stmt) { stmt_vec_info stmt_info = vinfo_for_stmt (stmt); @@ -8074,7 +8074,7 @@ free_stmt_vec_info (gimple stmt) if (patt_info) { gimple_seq seq = STMT_VINFO_PATTERN_DEF_SEQ (patt_info); - gimple patt_stmt = STMT_VINFO_STMT (patt_info); + gimple *patt_stmt = STMT_VINFO_STMT (patt_info); gimple_set_bb (patt_stmt, NULL); tree lhs = gimple_get_lhs (patt_stmt); if (TREE_CODE (lhs) == SSA_NAME) @@ -8084,7 +8084,7 @@ free_stmt_vec_info (gimple stmt) gimple_stmt_iterator si; for (si = gsi_start (seq); !gsi_end_p (si); gsi_next (&si)) { - gimple seq_stmt = gsi_stmt (si); + gimple *seq_stmt = gsi_stmt (si); gimple_set_bb (seq_stmt, NULL); lhs = gimple_get_lhs (patt_stmt); if (TREE_CODE (lhs) == SSA_NAME) @@ -8222,8 +8222,8 @@ get_same_sized_vectype (tree scalar_type, tree vector_type) For now, operands defined outside the basic block are not supported. */ bool -vect_is_simple_use (tree operand, gimple stmt, loop_vec_info loop_vinfo, - bb_vec_info bb_vinfo, gimple *def_stmt, +vect_is_simple_use (tree operand, gimple *stmt, loop_vec_info loop_vinfo, + bb_vec_info bb_vinfo, gimple **def_stmt, tree *def, enum vect_def_type *dt) { *def_stmt = NULL; @@ -8369,8 +8369,8 @@ vect_is_simple_use (tree operand, gimple stmt, loop_vec_info loop_vinfo, scalar operand. */ bool -vect_is_simple_use_1 (tree operand, gimple stmt, loop_vec_info loop_vinfo, - bb_vec_info bb_vinfo, gimple *def_stmt, +vect_is_simple_use_1 (tree operand, gimple *stmt, loop_vec_info loop_vinfo, + bb_vec_info bb_vinfo, gimple **def_stmt, tree *def, enum vect_def_type *dt, tree *vectype) { if (!vect_is_simple_use (operand, stmt, loop_vinfo, bb_vinfo, def_stmt, @@ -8429,7 +8429,7 @@ vect_is_simple_use_1 (tree operand, gimple stmt, loop_vec_info loop_vinfo, widening operation (short in the above example). */ bool -supportable_widening_operation (enum tree_code code, gimple stmt, +supportable_widening_operation (enum tree_code code, gimple *stmt, tree vectype_out, tree vectype_in, enum tree_code *code1, enum tree_code *code2, int *multi_step_cvt, @@ -8504,7 +8504,7 @@ supportable_widening_operation (enum tree_code code, gimple stmt, by STMT is only directly used in the reduction statement. */ tree lhs = gimple_assign_lhs (stmt); use_operand_p dummy; - gimple use_stmt; + gimple *use_stmt; stmt_vec_info use_stmt_info = NULL; if (single_imm_use (lhs, &dummy, &use_stmt) && (use_stmt_info = vinfo_for_stmt (use_stmt)) |