From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 37188 invoked by alias); 24 Jul 2018 09:59:50 -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 36021 invoked by uid 89); 24 Jul 2018 09:59:48 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-11.1 required=5.0 tests=BAYES_00,GIT_PATCH_2,GIT_PATCH_3,KAM_ASCII_DIVIDERS,SPF_PASS autolearn=ham version=3.3.2 spammy= X-HELO: foss.arm.com Received: from foss.arm.com (HELO foss.arm.com) (217.140.101.70) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 24 Jul 2018 09:59:45 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.72.51.249]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 986347A9 for ; Tue, 24 Jul 2018 02:59:44 -0700 (PDT) Received: from localhost (unknown [10.32.99.48]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id F0FE73F237 for ; Tue, 24 Jul 2018 02:59:43 -0700 (PDT) From: Richard Sandiford To: gcc-patches@gcc.gnu.org Mail-Followup-To: gcc-patches@gcc.gnu.org, richard.sandiford@arm.com Subject: [17/46] Make LOOP_VINFO_REDUCTIONS an auto_vec References: <87wotlrmen.fsf@arm.com> Date: Tue, 24 Jul 2018 09:59:00 -0000 In-Reply-To: <87wotlrmen.fsf@arm.com> (Richard Sandiford's message of "Tue, 24 Jul 2018 10:52:16 +0100") Message-ID: <87va95osxd.fsf@arm.com> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/26.1 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-SW-Source: 2018-07/txt/msg01326.txt.bz2 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. 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);