From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 70255 invoked by alias); 25 Jul 2018 09:23:54 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 70235 invoked by uid 89); 25 Jul 2018 09:23:53 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-11.2 required=5.0 tests=AWL,BAYES_00,FREEMAIL_FROM,GIT_PATCH_2,GIT_PATCH_3,KAM_ASCII_DIVIDERS,RCVD_IN_DNSWL_NONE,SPF_PASS autolearn=ham version=3.3.2 spammy=H*r:sk:j8-v6so, 25928, chains X-HELO: mail-lf1-f68.google.com Received: from mail-lf1-f68.google.com (HELO mail-lf1-f68.google.com) (209.85.167.68) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 25 Jul 2018 09:23:50 +0000 Received: by mail-lf1-f68.google.com with SMTP id j8-v6so4951813lfb.4 for ; Wed, 25 Jul 2018 02:23:50 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to; bh=1+/WiFYlzWEt9Vu4YTbrdBcpZQDP4lOxo5zc8NY1q44=; b=Q+Lhu664JtfSQsBnmlS+NlbL3ImyWLMv2W/FKxIQLp47Dk30klhguq4JiCRg0+ew3g S+Nbd+gBvHprSc+Sl6VRU7PGBHoPywcXH3/PgFpybpCqTWXSdOiuFCIXuD9WIYhxCygf nMSccfKHCuqmqwdrg4ywtRsqjrBEU/dtBZAkrin9YWTOZJSBCNoQempFK2G6+FlTeFmW RKy7Qc2JYkuLIsVYlRxJX7h+3aLe0aoeicxJvHkxuq51nD5mEDjtmtDGvN/nrzq4vGyw T6bFsukOlr2K7GjctMwT1TFkotUjXgwIzBYmyl0N6JX00wRWhFPEKD96LXnp0uoY8B10 6lvA== MIME-Version: 1.0 References: <87wotlrmen.fsf@arm.com> <87va95osxd.fsf@arm.com> In-Reply-To: <87va95osxd.fsf@arm.com> From: Richard Biener Date: Wed, 25 Jul 2018 09:23:00 -0000 Message-ID: Subject: Re: [17/46] Make LOOP_VINFO_REDUCTIONS an auto_vec To: GCC Patches , richard.sandiford@arm.com Content-Type: text/plain; charset="UTF-8" X-IsSubscribed: yes X-SW-Source: 2018-07/txt/msg01479.txt.bz2 On Tue, Jul 24, 2018 at 11:59 AM Richard Sandiford wrote: > > This patch changes LOOP_VINFO_REDUCTIONS from an auto_vec > to an auto_vec. It also changes the associated > vect_force_simple_reduction so that it takes and returns stmt_vec_infos > instead of gimple stmts. OK. Highlights that reduction detection needs refactoring to be usable outside of the vectorizer (see tree-parloops.c). Exposing vinfos doesn't make the situation better here... Richard. > > 2018-07-24 Richard Sandiford > > gcc/ > * tree-vectorizer.h (_loop_vec_info::reductions): Change from an > auto_vec to an auto_vec. > (vect_force_simple_reduction): Take and return stmt_vec_infos rather > than gimple stmts. > * tree-parloops.c (valid_reduction_p): Take a stmt_vec_info instead > of a gimple stmt. > (gather_scalar_reductions): Update after above interface changes. > * tree-vect-loop.c (vect_analyze_scalar_cycles_1): Likewise. > (vect_is_simple_reduction): Take and return stmt_vec_infos rather > than gimple stmts. > (vect_force_simple_reduction): Likewise. > * tree-vect-patterns.c (vect_pattern_recog_1): Update use of > LOOP_VINFO_REDUCTIONS. > * tree-vect-slp.c (vect_analyze_slp_instance): Likewise. > > Index: gcc/tree-vectorizer.h > =================================================================== > --- gcc/tree-vectorizer.h 2018-07-24 10:22:53.909100298 +0100 > +++ gcc/tree-vectorizer.h 2018-07-24 10:22:57.277070390 +0100 > @@ -475,7 +475,7 @@ typedef struct _loop_vec_info : public v > auto_vec may_misalign_stmts; > > /* Reduction cycles detected in the loop. Used in loop-aware SLP. */ > - auto_vec reductions; > + auto_vec reductions; > > /* All reduction chains in the loop, represented by the first > stmt in the chain. */ > @@ -1627,8 +1627,8 @@ extern tree vect_create_addr_base_for_ve > > /* In tree-vect-loop.c. */ > /* FORNOW: Used in tree-parloops.c. */ > -extern gimple *vect_force_simple_reduction (loop_vec_info, gimple *, > - bool *, bool); > +extern stmt_vec_info vect_force_simple_reduction (loop_vec_info, stmt_vec_info, > + bool *, bool); > /* Used in gimple-loop-interchange.c. */ > extern bool check_reduction_path (dump_user_location_t, loop_p, gphi *, tree, > enum tree_code); > Index: gcc/tree-parloops.c > =================================================================== > --- gcc/tree-parloops.c 2018-06-27 10:27:09.778650686 +0100 > +++ gcc/tree-parloops.c 2018-07-24 10:22:57.273070426 +0100 > @@ -2570,15 +2570,14 @@ set_reduc_phi_uids (reduction_info **slo > return 1; > } > > -/* Return true if the type of reduction performed by STMT is suitable > +/* Return true if the type of reduction performed by STMT_INFO is suitable > for this pass. */ > > static bool > -valid_reduction_p (gimple *stmt) > +valid_reduction_p (stmt_vec_info stmt_info) > { > /* Parallelization would reassociate the operation, which isn't > allowed for in-order reductions. */ > - stmt_vec_info stmt_info = vinfo_for_stmt (stmt); > vect_reduction_type reduc_type = STMT_VINFO_REDUC_TYPE (stmt_info); > return reduc_type != FOLD_LEFT_REDUCTION; > } > @@ -2615,10 +2614,11 @@ gather_scalar_reductions (loop_p loop, r > if (simple_iv (loop, loop, res, &iv, true)) > continue; > > - gimple *reduc_stmt > - = vect_force_simple_reduction (simple_loop_info, phi, > + stmt_vec_info reduc_stmt_info > + = vect_force_simple_reduction (simple_loop_info, > + simple_loop_info->lookup_stmt (phi), > &double_reduc, true); > - if (!reduc_stmt || !valid_reduction_p (reduc_stmt)) > + if (!reduc_stmt_info || !valid_reduction_p (reduc_stmt_info)) > continue; > > if (double_reduc) > @@ -2627,11 +2627,11 @@ gather_scalar_reductions (loop_p loop, r > continue; > > double_reduc_phis.safe_push (phi); > - double_reduc_stmts.safe_push (reduc_stmt); > + double_reduc_stmts.safe_push (reduc_stmt_info->stmt); > continue; > } > > - build_new_reduction (reduction_list, reduc_stmt, phi); > + build_new_reduction (reduction_list, reduc_stmt_info->stmt, phi); > } > delete simple_loop_info; > > @@ -2661,12 +2661,15 @@ gather_scalar_reductions (loop_p loop, r > &iv, true)) > continue; > > - gimple *inner_reduc_stmt > - = vect_force_simple_reduction (simple_loop_info, inner_phi, > + stmt_vec_info inner_phi_info > + = simple_loop_info->lookup_stmt (inner_phi); > + stmt_vec_info inner_reduc_stmt_info > + = vect_force_simple_reduction (simple_loop_info, > + inner_phi_info, > &double_reduc, true); > gcc_assert (!double_reduc); > - if (inner_reduc_stmt == NULL > - || !valid_reduction_p (inner_reduc_stmt)) > + if (!inner_reduc_stmt_info > + || !valid_reduction_p (inner_reduc_stmt_info)) > continue; > > build_new_reduction (reduction_list, double_reduc_stmts[i], phi); > Index: gcc/tree-vect-loop.c > =================================================================== > --- gcc/tree-vect-loop.c 2018-07-24 10:22:53.909100298 +0100 > +++ gcc/tree-vect-loop.c 2018-07-24 10:22:57.273070426 +0100 > @@ -546,7 +546,6 @@ vect_analyze_scalar_cycles_1 (loop_vec_i > gimple *phi = worklist.pop (); > tree def = PHI_RESULT (phi); > stmt_vec_info stmt_vinfo = vinfo_for_stmt (phi); > - gimple *reduc_stmt; > > if (dump_enabled_p ()) > { > @@ -557,9 +556,10 @@ vect_analyze_scalar_cycles_1 (loop_vec_i > gcc_assert (!virtual_operand_p (def) > && STMT_VINFO_DEF_TYPE (stmt_vinfo) == vect_unknown_def_type); > > - reduc_stmt = vect_force_simple_reduction (loop_vinfo, phi, > - &double_reduc, false); > - if (reduc_stmt) > + stmt_vec_info reduc_stmt_info > + = vect_force_simple_reduction (loop_vinfo, stmt_vinfo, > + &double_reduc, false); > + if (reduc_stmt_info) > { > if (double_reduc) > { > @@ -568,8 +568,8 @@ vect_analyze_scalar_cycles_1 (loop_vec_i > "Detected double reduction.\n"); > > STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_double_reduction_def; > - STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) = > - vect_double_reduction_def; > + STMT_VINFO_DEF_TYPE (reduc_stmt_info) > + = vect_double_reduction_def; > } > else > { > @@ -580,8 +580,7 @@ vect_analyze_scalar_cycles_1 (loop_vec_i > "Detected vectorizable nested cycle.\n"); > > STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_nested_cycle; > - STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) = > - vect_nested_cycle; > + STMT_VINFO_DEF_TYPE (reduc_stmt_info) = vect_nested_cycle; > } > else > { > @@ -590,13 +589,13 @@ vect_analyze_scalar_cycles_1 (loop_vec_i > "Detected reduction.\n"); > > STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_reduction_def; > - STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) = > - vect_reduction_def; > + STMT_VINFO_DEF_TYPE (reduc_stmt_info) = vect_reduction_def; > /* Store the reduction cycles for possible vectorization in > loop-aware SLP if it was not detected as reduction > chain. */ > - if (! REDUC_GROUP_FIRST_ELEMENT (vinfo_for_stmt (reduc_stmt))) > - LOOP_VINFO_REDUCTIONS (loop_vinfo).safe_push (reduc_stmt); > + if (! REDUC_GROUP_FIRST_ELEMENT (reduc_stmt_info)) > + LOOP_VINFO_REDUCTIONS (loop_vinfo).safe_push > + (reduc_stmt_info); > } > } > } > @@ -2530,8 +2529,8 @@ vect_is_slp_reduction (loop_vec_info loo > struct loop *loop = (gimple_bb (phi))->loop_father; > struct loop *vect_loop = LOOP_VINFO_LOOP (loop_info); > enum tree_code code; > - gimple *current_stmt = NULL, *loop_use_stmt = NULL, *first, *next_stmt; > - stmt_vec_info use_stmt_info, current_stmt_info; > + gimple *loop_use_stmt = NULL, *first, *next_stmt; > + stmt_vec_info use_stmt_info, current_stmt_info = NULL; > tree lhs; > imm_use_iterator imm_iter; > use_operand_p use_p; > @@ -2593,9 +2592,8 @@ vect_is_slp_reduction (loop_vec_info loo > > /* Insert USE_STMT into reduction chain. */ > use_stmt_info = loop_info->lookup_stmt (loop_use_stmt); > - if (current_stmt) > + if (current_stmt_info) > { > - current_stmt_info = vinfo_for_stmt (current_stmt); > REDUC_GROUP_NEXT_ELEMENT (current_stmt_info) = loop_use_stmt; > REDUC_GROUP_FIRST_ELEMENT (use_stmt_info) > = REDUC_GROUP_FIRST_ELEMENT (current_stmt_info); > @@ -2604,7 +2602,7 @@ vect_is_slp_reduction (loop_vec_info loo > REDUC_GROUP_FIRST_ELEMENT (use_stmt_info) = loop_use_stmt; > > lhs = gimple_assign_lhs (loop_use_stmt); > - current_stmt = loop_use_stmt; > + current_stmt_info = use_stmt_info; > size++; > } > > @@ -2614,7 +2612,7 @@ vect_is_slp_reduction (loop_vec_info loo > /* Swap the operands, if needed, to make the reduction operand be the second > operand. */ > lhs = PHI_RESULT (phi); > - next_stmt = REDUC_GROUP_FIRST_ELEMENT (vinfo_for_stmt (current_stmt)); > + next_stmt = REDUC_GROUP_FIRST_ELEMENT (current_stmt_info); > while (next_stmt) > { > if (gimple_assign_rhs2 (next_stmt) == lhs) > @@ -2671,7 +2669,7 @@ vect_is_slp_reduction (loop_vec_info loo > } > > /* Save the chain for further analysis in SLP detection. */ > - first = REDUC_GROUP_FIRST_ELEMENT (vinfo_for_stmt (current_stmt)); > + first = REDUC_GROUP_FIRST_ELEMENT (current_stmt_info); > LOOP_VINFO_REDUCTION_CHAINS (loop_info).safe_push (first); > REDUC_GROUP_SIZE (vinfo_for_stmt (first)) = size; > > @@ -2867,15 +2865,16 @@ check_reduction_path (dump_user_location > > */ > > -static gimple * > -vect_is_simple_reduction (loop_vec_info loop_info, gimple *phi, > +static stmt_vec_info > +vect_is_simple_reduction (loop_vec_info loop_info, stmt_vec_info phi_info, > bool *double_reduc, > bool need_wrapping_integral_overflow, > enum vect_reduction_type *v_reduc_type) > { > + gphi *phi = as_a (phi_info->stmt); > struct loop *loop = (gimple_bb (phi))->loop_father; > struct loop *vect_loop = LOOP_VINFO_LOOP (loop_info); > - gimple *def_stmt, *phi_use_stmt = NULL; > + gimple *phi_use_stmt = NULL; > enum tree_code orig_code, code; > tree op1, op2, op3 = NULL_TREE, op4 = NULL_TREE; > tree type; > @@ -2937,13 +2936,16 @@ vect_is_simple_reduction (loop_vec_info > return NULL; > } > > - def_stmt = SSA_NAME_DEF_STMT (loop_arg); > - if (is_gimple_assign (def_stmt)) > + stmt_vec_info def_stmt_info = loop_info->lookup_def (loop_arg); > + if (!def_stmt_info) > + return NULL; > + > + if (gassign *def_stmt = dyn_cast (def_stmt_info->stmt)) > { > name = gimple_assign_lhs (def_stmt); > phi_def = false; > } > - else if (gimple_code (def_stmt) == GIMPLE_PHI) > + else if (gphi *def_stmt = dyn_cast (def_stmt_info->stmt)) > { > name = PHI_RESULT (def_stmt); > phi_def = true; > @@ -2954,14 +2956,12 @@ vect_is_simple_reduction (loop_vec_info > { > dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, > "reduction: unhandled reduction operation: "); > - dump_gimple_stmt (MSG_MISSED_OPTIMIZATION, TDF_SLIM, def_stmt, 0); > + dump_gimple_stmt (MSG_MISSED_OPTIMIZATION, TDF_SLIM, > + def_stmt_info->stmt, 0); > } > return NULL; > } > > - if (! flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))) > - return NULL; > - > nloop_uses = 0; > auto_vec lcphis; > FOR_EACH_IMM_USE_FAST (use_p, imm_iter, name) > @@ -2987,6 +2987,7 @@ vect_is_simple_reduction (loop_vec_info > defined in the inner loop. */ > if (phi_def) > { > + gphi *def_stmt = as_a (def_stmt_info->stmt); > op1 = PHI_ARG_DEF (def_stmt, 0); > > if (gimple_phi_num_args (def_stmt) != 1 > @@ -3012,7 +3013,7 @@ vect_is_simple_reduction (loop_vec_info > "detected double reduction: "); > > *double_reduc = true; > - return def_stmt; > + return def_stmt_info; > } > > return NULL; > @@ -3038,6 +3039,7 @@ vect_is_simple_reduction (loop_vec_info > } > } > > + gassign *def_stmt = as_a (def_stmt_info->stmt); > bool nested_in_vect_loop = flow_loop_nested_p (vect_loop, loop); > code = orig_code = gimple_assign_rhs_code (def_stmt); > > @@ -3178,7 +3180,7 @@ vect_is_simple_reduction (loop_vec_info > { > if (dump_enabled_p ()) > report_vect_op (MSG_NOTE, def_stmt, "detected reduction: "); > - return def_stmt; > + return def_stmt_info; > } > > if (def1_info > @@ -3237,7 +3239,7 @@ vect_is_simple_reduction (loop_vec_info > report_vect_op (MSG_NOTE, def_stmt, "detected reduction: "); > } > > - return def_stmt; > + return def_stmt_info; > } > > /* Try to find SLP reduction chain. */ > @@ -3250,7 +3252,7 @@ vect_is_simple_reduction (loop_vec_info > report_vect_op (MSG_NOTE, def_stmt, > "reduction: detected reduction chain: "); > > - return def_stmt; > + return def_stmt_info; > } > > /* Dissolve group eventually half-built by vect_is_slp_reduction. */ > @@ -3264,9 +3266,8 @@ vect_is_simple_reduction (loop_vec_info > } > > /* Look for the expression computing loop_arg from loop PHI result. */ > - if (check_reduction_path (vect_location, loop, as_a (phi), loop_arg, > - code)) > - return def_stmt; > + if (check_reduction_path (vect_location, loop, phi, loop_arg, code)) > + return def_stmt_info; > > if (dump_enabled_p ()) > { > @@ -3281,25 +3282,24 @@ vect_is_simple_reduction (loop_vec_info > in-place if it enables detection of more reductions. Arguments > as there. */ > > -gimple * > -vect_force_simple_reduction (loop_vec_info loop_info, gimple *phi, > +stmt_vec_info > +vect_force_simple_reduction (loop_vec_info loop_info, stmt_vec_info phi_info, > bool *double_reduc, > bool need_wrapping_integral_overflow) > { > enum vect_reduction_type v_reduc_type; > - gimple *def = vect_is_simple_reduction (loop_info, phi, double_reduc, > - need_wrapping_integral_overflow, > - &v_reduc_type); > - if (def) > + stmt_vec_info def_info > + = vect_is_simple_reduction (loop_info, phi_info, double_reduc, > + need_wrapping_integral_overflow, > + &v_reduc_type); > + if (def_info) > { > - stmt_vec_info phi_info = vinfo_for_stmt (phi); > - stmt_vec_info def_info = vinfo_for_stmt (def); > STMT_VINFO_REDUC_TYPE (phi_info) = v_reduc_type; > STMT_VINFO_REDUC_DEF (phi_info) = def_info; > STMT_VINFO_REDUC_TYPE (def_info) = v_reduc_type; > STMT_VINFO_REDUC_DEF (def_info) = phi_info; > } > - return def; > + return def_info; > } > > /* Calculate cost of peeling the loop PEEL_ITERS_PROLOGUE times. */ > Index: gcc/tree-vect-patterns.c > =================================================================== > --- gcc/tree-vect-patterns.c 2018-07-24 10:22:44.289185723 +0100 > +++ gcc/tree-vect-patterns.c 2018-07-24 10:22:57.277070390 +0100 > @@ -4851,9 +4851,9 @@ vect_pattern_recog_1 (vect_recog_func *r > if (loop_vinfo) > { > unsigned ix, ix2; > - gimple **elem_ptr; > + stmt_vec_info *elem_ptr; > VEC_ORDERED_REMOVE_IF (LOOP_VINFO_REDUCTIONS (loop_vinfo), ix, ix2, > - elem_ptr, *elem_ptr == stmt); > + elem_ptr, *elem_ptr == stmt_info); > } > } > > Index: gcc/tree-vect-slp.c > =================================================================== > --- gcc/tree-vect-slp.c 2018-07-24 10:22:50.777128110 +0100 > +++ gcc/tree-vect-slp.c 2018-07-24 10:22:57.277070390 +0100 > @@ -1931,6 +1931,7 @@ vect_analyze_slp_instance (vec_info *vin > unsigned int group_size; > tree vectype, scalar_type = NULL_TREE; > gimple *next; > + stmt_vec_info next_info; > unsigned int i; > vec loads; > struct data_reference *dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt)); > @@ -2008,9 +2009,9 @@ vect_analyze_slp_instance (vec_info *vin > else > { > /* Collect reduction statements. */ > - vec reductions = as_a (vinfo)->reductions; > - for (i = 0; reductions.iterate (i, &next); i++) > - scalar_stmts.safe_push (next); > + vec reductions = as_a (vinfo)->reductions; > + for (i = 0; reductions.iterate (i, &next_info); i++) > + scalar_stmts.safe_push (next_info); > } > > loads.create (group_size);