2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Contributed by Dorit Naishlos <dorit@il.ibm.com> and
5 Ira Rosen <irar@il.ibm.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
29 #include "basic-block.h"
30 #include "tree-pretty-print.h"
31 #include "gimple-pretty-print.h"
32 #include "tree-flow.h"
33 #include "tree-dump.h"
35 #include "cfglayout.h"
40 #include "diagnostic-core.h"
42 #include "tree-chrec.h"
43 #include "tree-scalar-evolution.h"
44 #include "tree-vectorizer.h"
47 /* Loop Vectorization Pass.
49 This pass tries to vectorize loops.
51 For example, the vectorizer transforms the following simple loop:
53 short a[N]; short b[N]; short c[N]; int i;
59 as if it was manually vectorized by rewriting the source code into:
61 typedef int __attribute__((mode(V8HI))) v8hi;
62 short a[N]; short b[N]; short c[N]; int i;
63 v8hi *pa = (v8hi*)a, *pb = (v8hi*)b, *pc = (v8hi*)c;
66 for (i=0; i<N/8; i++){
73 The main entry to this pass is vectorize_loops(), in which
74 the vectorizer applies a set of analyses on a given set of loops,
75 followed by the actual vectorization transformation for the loops that
76 had successfully passed the analysis phase.
77 Throughout this pass we make a distinction between two types of
78 data: scalars (which are represented by SSA_NAMES), and memory references
79 ("data-refs"). These two types of data require different handling both
80 during analysis and transformation. The types of data-refs that the
81 vectorizer currently supports are ARRAY_REFS which base is an array DECL
82 (not a pointer), and INDIRECT_REFS through pointers; both array and pointer
83 accesses are required to have a simple (consecutive) access pattern.
87 The driver for the analysis phase is vect_analyze_loop().
88 It applies a set of analyses, some of which rely on the scalar evolution
89 analyzer (scev) developed by Sebastian Pop.
91 During the analysis phase the vectorizer records some information
92 per stmt in a "stmt_vec_info" struct which is attached to each stmt in the
93 loop, as well as general information about the loop as a whole, which is
94 recorded in a "loop_vec_info" struct attached to each loop.
98 The loop transformation phase scans all the stmts in the loop, and
99 creates a vector stmt (or a sequence of stmts) for each scalar stmt S in
100 the loop that needs to be vectorized. It inserts the vector code sequence
101 just before the scalar stmt S, and records a pointer to the vector code
102 in STMT_VINFO_VEC_STMT (stmt_info) (stmt_info is the stmt_vec_info struct
103 attached to S). This pointer will be used for the vectorization of following
104 stmts which use the def of stmt S. Stmt S is removed if it writes to memory;
105 otherwise, we rely on dead code elimination for removing it.
107 For example, say stmt S1 was vectorized into stmt VS1:
110 S1: b = x[i]; STMT_VINFO_VEC_STMT (stmt_info (S1)) = VS1
113 To vectorize stmt S2, the vectorizer first finds the stmt that defines
114 the operand 'b' (S1), and gets the relevant vector def 'vb' from the
115 vector stmt VS1 pointed to by STMT_VINFO_VEC_STMT (stmt_info (S1)). The
116 resulting sequence would be:
119 S1: b = x[i]; STMT_VINFO_VEC_STMT (stmt_info (S1)) = VS1
121 S2: a = b; STMT_VINFO_VEC_STMT (stmt_info (S2)) = VS2
123 Operands that are not SSA_NAMEs, are data-refs that appear in
124 load/store operations (like 'x[i]' in S1), and are handled differently.
128 Currently the only target specific information that is used is the
129 size of the vector (in bytes) - "UNITS_PER_SIMD_WORD". Targets that can
130 support different sizes of vectors, for now will need to specify one value
131 for "UNITS_PER_SIMD_WORD". More flexibility will be added in the future.
133 Since we only vectorize operations which vector form can be
134 expressed using existing tree codes, to verify that an operation is
135 supported, the vectorizer checks the relevant optab at the relevant
136 machine_mode (e.g, optab_handler (add_optab, V8HImode)). If
137 the value found is CODE_FOR_nothing, then there's no target support, and
138 we can't vectorize the stmt.
140 For additional information on this project see:
141 http://gcc.gnu.org/projects/tree-ssa/vectorization.html
144 /* Function vect_determine_vectorization_factor
146 Determine the vectorization factor (VF). VF is the number of data elements
147 that are operated upon in parallel in a single iteration of the vectorized
148 loop. For example, when vectorizing a loop that operates on 4byte elements,
149 on a target with vector size (VS) 16byte, the VF is set to 4, since 4
150 elements can fit in a single vector register.
152 We currently support vectorization of loops in which all types operated upon
153 are of the same size. Therefore this function currently sets VF according to
154 the size of the types operated upon, and fails if there are multiple sizes
157 VF is also the factor by which the loop iterations are strip-mined, e.g.:
164 for (i=0; i<N; i+=VF){
165 a[i:VF] = b[i:VF] + c[i:VF];
170 vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
172 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
173 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
174 int nbbs = loop->num_nodes;
175 gimple_stmt_iterator si;
176 unsigned int vectorization_factor = 0;
181 stmt_vec_info stmt_info;
185 if (vect_print_dump_info (REPORT_DETAILS))
186 fprintf (vect_dump, "=== vect_determine_vectorization_factor ===");
188 for (i = 0; i < nbbs; i++)
190 basic_block bb = bbs[i];
192 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
195 stmt_info = vinfo_for_stmt (phi);
196 if (vect_print_dump_info (REPORT_DETAILS))
198 fprintf (vect_dump, "==> examining phi: ");
199 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
202 gcc_assert (stmt_info);
204 if (STMT_VINFO_RELEVANT_P (stmt_info))
206 gcc_assert (!STMT_VINFO_VECTYPE (stmt_info));
207 scalar_type = TREE_TYPE (PHI_RESULT (phi));
209 if (vect_print_dump_info (REPORT_DETAILS))
211 fprintf (vect_dump, "get vectype for scalar type: ");
212 print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
215 vectype = get_vectype_for_scalar_type (scalar_type);
218 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
221 "not vectorized: unsupported data-type ");
222 print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
226 STMT_VINFO_VECTYPE (stmt_info) = vectype;
228 if (vect_print_dump_info (REPORT_DETAILS))
230 fprintf (vect_dump, "vectype: ");
231 print_generic_expr (vect_dump, vectype, TDF_SLIM);
234 nunits = TYPE_VECTOR_SUBPARTS (vectype);
235 if (vect_print_dump_info (REPORT_DETAILS))
236 fprintf (vect_dump, "nunits = %d", nunits);
238 if (!vectorization_factor
239 || (nunits > vectorization_factor))
240 vectorization_factor = nunits;
244 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
247 gimple stmt = gsi_stmt (si);
248 stmt_info = vinfo_for_stmt (stmt);
250 if (vect_print_dump_info (REPORT_DETAILS))
252 fprintf (vect_dump, "==> examining statement: ");
253 print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
256 gcc_assert (stmt_info);
258 /* skip stmts which do not need to be vectorized. */
259 if (!STMT_VINFO_RELEVANT_P (stmt_info)
260 && !STMT_VINFO_LIVE_P (stmt_info))
262 if (vect_print_dump_info (REPORT_DETAILS))
263 fprintf (vect_dump, "skip.");
267 if (gimple_get_lhs (stmt) == NULL_TREE)
269 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
271 fprintf (vect_dump, "not vectorized: irregular stmt.");
272 print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
277 if (VECTOR_MODE_P (TYPE_MODE (gimple_expr_type (stmt))))
279 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
281 fprintf (vect_dump, "not vectorized: vector stmt in loop:");
282 print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
287 if (STMT_VINFO_VECTYPE (stmt_info))
289 /* The only case when a vectype had been already set is for stmts
290 that contain a dataref, or for "pattern-stmts" (stmts generated
291 by the vectorizer to represent/replace a certain idiom). */
292 gcc_assert (STMT_VINFO_DATA_REF (stmt_info)
293 || is_pattern_stmt_p (stmt_info));
294 vectype = STMT_VINFO_VECTYPE (stmt_info);
298 gcc_assert (!STMT_VINFO_DATA_REF (stmt_info)
299 && !is_pattern_stmt_p (stmt_info));
301 scalar_type = TREE_TYPE (gimple_get_lhs (stmt));
302 if (vect_print_dump_info (REPORT_DETAILS))
304 fprintf (vect_dump, "get vectype for scalar type: ");
305 print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
307 vectype = get_vectype_for_scalar_type (scalar_type);
310 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
313 "not vectorized: unsupported data-type ");
314 print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
319 STMT_VINFO_VECTYPE (stmt_info) = vectype;
322 /* The vectorization factor is according to the smallest
323 scalar type (or the largest vector size, but we only
324 support one vector size per loop). */
325 scalar_type = vect_get_smallest_scalar_type (stmt, &dummy,
327 if (vect_print_dump_info (REPORT_DETAILS))
329 fprintf (vect_dump, "get vectype for scalar type: ");
330 print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
332 vf_vectype = get_vectype_for_scalar_type (scalar_type);
335 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
338 "not vectorized: unsupported data-type ");
339 print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
344 if ((GET_MODE_SIZE (TYPE_MODE (vectype))
345 != GET_MODE_SIZE (TYPE_MODE (vf_vectype))))
347 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
350 "not vectorized: different sized vector "
351 "types in statement, ");
352 print_generic_expr (vect_dump, vectype, TDF_SLIM);
353 fprintf (vect_dump, " and ");
354 print_generic_expr (vect_dump, vf_vectype, TDF_SLIM);
359 if (vect_print_dump_info (REPORT_DETAILS))
361 fprintf (vect_dump, "vectype: ");
362 print_generic_expr (vect_dump, vf_vectype, TDF_SLIM);
365 nunits = TYPE_VECTOR_SUBPARTS (vf_vectype);
366 if (vect_print_dump_info (REPORT_DETAILS))
367 fprintf (vect_dump, "nunits = %d", nunits);
369 if (!vectorization_factor
370 || (nunits > vectorization_factor))
371 vectorization_factor = nunits;
375 /* TODO: Analyze cost. Decide if worth while to vectorize. */
376 if (vect_print_dump_info (REPORT_DETAILS))
377 fprintf (vect_dump, "vectorization factor = %d", vectorization_factor);
378 if (vectorization_factor <= 1)
380 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
381 fprintf (vect_dump, "not vectorized: unsupported data-type");
384 LOOP_VINFO_VECT_FACTOR (loop_vinfo) = vectorization_factor;
390 /* Function vect_is_simple_iv_evolution.
392 FORNOW: A simple evolution of an induction variables in the loop is
393 considered a polynomial evolution with constant step. */
396 vect_is_simple_iv_evolution (unsigned loop_nb, tree access_fn, tree * init,
401 tree evolution_part = evolution_part_in_loop_num (access_fn, loop_nb);
403 /* When there is no evolution in this loop, the evolution function
405 if (evolution_part == NULL_TREE)
408 /* When the evolution is a polynomial of degree >= 2
409 the evolution function is not "simple". */
410 if (tree_is_chrec (evolution_part))
413 step_expr = evolution_part;
414 init_expr = unshare_expr (initial_condition_in_loop_num (access_fn, loop_nb));
416 if (vect_print_dump_info (REPORT_DETAILS))
418 fprintf (vect_dump, "step: ");
419 print_generic_expr (vect_dump, step_expr, TDF_SLIM);
420 fprintf (vect_dump, ", init: ");
421 print_generic_expr (vect_dump, init_expr, TDF_SLIM);
427 if (TREE_CODE (step_expr) != INTEGER_CST)
429 if (vect_print_dump_info (REPORT_DETAILS))
430 fprintf (vect_dump, "step unknown.");
437 /* Function vect_analyze_scalar_cycles_1.
439 Examine the cross iteration def-use cycles of scalar variables
440 in LOOP. LOOP_VINFO represents the loop that is now being
441 considered for vectorization (can be LOOP, or an outer-loop
445 vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop)
447 basic_block bb = loop->header;
449 VEC(gimple,heap) *worklist = VEC_alloc (gimple, heap, 64);
450 gimple_stmt_iterator gsi;
453 if (vect_print_dump_info (REPORT_DETAILS))
454 fprintf (vect_dump, "=== vect_analyze_scalar_cycles ===");
456 /* First - identify all inductions. Reduction detection assumes that all the
457 inductions have been identified, therefore, this order must not be
459 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
461 gimple phi = gsi_stmt (gsi);
462 tree access_fn = NULL;
463 tree def = PHI_RESULT (phi);
464 stmt_vec_info stmt_vinfo = vinfo_for_stmt (phi);
466 if (vect_print_dump_info (REPORT_DETAILS))
468 fprintf (vect_dump, "Analyze phi: ");
469 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
472 /* Skip virtual phi's. The data dependences that are associated with
473 virtual defs/uses (i.e., memory accesses) are analyzed elsewhere. */
474 if (!is_gimple_reg (SSA_NAME_VAR (def)))
477 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_unknown_def_type;
479 /* Analyze the evolution function. */
480 access_fn = analyze_scalar_evolution (loop, def);
481 if (access_fn && vect_print_dump_info (REPORT_DETAILS))
483 fprintf (vect_dump, "Access function of PHI: ");
484 print_generic_expr (vect_dump, access_fn, TDF_SLIM);
488 || !vect_is_simple_iv_evolution (loop->num, access_fn, &dumy, &dumy))
490 VEC_safe_push (gimple, heap, worklist, phi);
494 if (vect_print_dump_info (REPORT_DETAILS))
495 fprintf (vect_dump, "Detected induction.");
496 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_induction_def;
500 /* Second - identify all reductions and nested cycles. */
501 while (VEC_length (gimple, worklist) > 0)
503 gimple phi = VEC_pop (gimple, worklist);
504 tree def = PHI_RESULT (phi);
505 stmt_vec_info stmt_vinfo = vinfo_for_stmt (phi);
509 if (vect_print_dump_info (REPORT_DETAILS))
511 fprintf (vect_dump, "Analyze phi: ");
512 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
515 gcc_assert (is_gimple_reg (SSA_NAME_VAR (def)));
516 gcc_assert (STMT_VINFO_DEF_TYPE (stmt_vinfo) == vect_unknown_def_type);
518 nested_cycle = (loop != LOOP_VINFO_LOOP (loop_vinfo));
519 reduc_stmt = vect_force_simple_reduction (loop_vinfo, phi, !nested_cycle,
525 if (vect_print_dump_info (REPORT_DETAILS))
526 fprintf (vect_dump, "Detected double reduction.");
528 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_double_reduction_def;
529 STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) =
530 vect_double_reduction_def;
536 if (vect_print_dump_info (REPORT_DETAILS))
537 fprintf (vect_dump, "Detected vectorizable nested cycle.");
539 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_nested_cycle;
540 STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) =
545 if (vect_print_dump_info (REPORT_DETAILS))
546 fprintf (vect_dump, "Detected reduction.");
548 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_reduction_def;
549 STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) =
551 /* Store the reduction cycles for possible vectorization in
553 VEC_safe_push (gimple, heap,
554 LOOP_VINFO_REDUCTIONS (loop_vinfo),
560 if (vect_print_dump_info (REPORT_DETAILS))
561 fprintf (vect_dump, "Unknown def-use cycle pattern.");
564 VEC_free (gimple, heap, worklist);
568 /* Function vect_analyze_scalar_cycles.
570 Examine the cross iteration def-use cycles of scalar variables, by
571 analyzing the loop-header PHIs of scalar variables; Classify each
572 cycle as one of the following: invariant, induction, reduction, unknown.
573 We do that for the loop represented by LOOP_VINFO, and also to its
574 inner-loop, if exists.
575 Examples for scalar cycles:
590 vect_analyze_scalar_cycles (loop_vec_info loop_vinfo)
592 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
594 vect_analyze_scalar_cycles_1 (loop_vinfo, loop);
596 /* When vectorizing an outer-loop, the inner-loop is executed sequentially.
597 Reductions in such inner-loop therefore have different properties than
598 the reductions in the nest that gets vectorized:
599 1. When vectorized, they are executed in the same order as in the original
600 scalar loop, so we can't change the order of computation when
602 2. FIXME: Inner-loop reductions can be used in the inner-loop, so the
603 current checks are too strict. */
606 vect_analyze_scalar_cycles_1 (loop_vinfo, loop->inner);
609 /* Function vect_get_loop_niters.
611 Determine how many iterations the loop is executed.
612 If an expression that represents the number of iterations
613 can be constructed, place it in NUMBER_OF_ITERATIONS.
614 Return the loop exit condition. */
617 vect_get_loop_niters (struct loop *loop, tree *number_of_iterations)
621 if (vect_print_dump_info (REPORT_DETAILS))
622 fprintf (vect_dump, "=== get_loop_niters ===");
624 niters = number_of_exit_cond_executions (loop);
626 if (niters != NULL_TREE
627 && niters != chrec_dont_know)
629 *number_of_iterations = niters;
631 if (vect_print_dump_info (REPORT_DETAILS))
633 fprintf (vect_dump, "==> get_loop_niters:" );
634 print_generic_expr (vect_dump, *number_of_iterations, TDF_SLIM);
638 return get_loop_exit_condition (loop);
642 /* Function bb_in_loop_p
644 Used as predicate for dfs order traversal of the loop bbs. */
647 bb_in_loop_p (const_basic_block bb, const void *data)
649 const struct loop *const loop = (const struct loop *)data;
650 if (flow_bb_inside_loop_p (loop, bb))
656 /* Function new_loop_vec_info.
658 Create and initialize a new loop_vec_info struct for LOOP, as well as
659 stmt_vec_info structs for all the stmts in LOOP. */
662 new_loop_vec_info (struct loop *loop)
666 gimple_stmt_iterator si;
667 unsigned int i, nbbs;
669 res = (loop_vec_info) xcalloc (1, sizeof (struct _loop_vec_info));
670 LOOP_VINFO_LOOP (res) = loop;
672 bbs = get_loop_body (loop);
674 /* Create/Update stmt_info for all stmts in the loop. */
675 for (i = 0; i < loop->num_nodes; i++)
677 basic_block bb = bbs[i];
679 /* BBs in a nested inner-loop will have been already processed (because
680 we will have called vect_analyze_loop_form for any nested inner-loop).
681 Therefore, for stmts in an inner-loop we just want to update the
682 STMT_VINFO_LOOP_VINFO field of their stmt_info to point to the new
683 loop_info of the outer-loop we are currently considering to vectorize
684 (instead of the loop_info of the inner-loop).
685 For stmts in other BBs we need to create a stmt_info from scratch. */
686 if (bb->loop_father != loop)
689 gcc_assert (loop->inner && bb->loop_father == loop->inner);
690 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
692 gimple phi = gsi_stmt (si);
693 stmt_vec_info stmt_info = vinfo_for_stmt (phi);
694 loop_vec_info inner_loop_vinfo =
695 STMT_VINFO_LOOP_VINFO (stmt_info);
696 gcc_assert (loop->inner == LOOP_VINFO_LOOP (inner_loop_vinfo));
697 STMT_VINFO_LOOP_VINFO (stmt_info) = res;
699 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
701 gimple stmt = gsi_stmt (si);
702 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
703 loop_vec_info inner_loop_vinfo =
704 STMT_VINFO_LOOP_VINFO (stmt_info);
705 gcc_assert (loop->inner == LOOP_VINFO_LOOP (inner_loop_vinfo));
706 STMT_VINFO_LOOP_VINFO (stmt_info) = res;
711 /* bb in current nest. */
712 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
714 gimple phi = gsi_stmt (si);
715 gimple_set_uid (phi, 0);
716 set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, res, NULL));
719 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
721 gimple stmt = gsi_stmt (si);
722 gimple_set_uid (stmt, 0);
723 set_vinfo_for_stmt (stmt, new_stmt_vec_info (stmt, res, NULL));
728 /* CHECKME: We want to visit all BBs before their successors (except for
729 latch blocks, for which this assertion wouldn't hold). In the simple
730 case of the loop forms we allow, a dfs order of the BBs would the same
731 as reversed postorder traversal, so we are safe. */
734 bbs = XCNEWVEC (basic_block, loop->num_nodes);
735 nbbs = dfs_enumerate_from (loop->header, 0, bb_in_loop_p,
736 bbs, loop->num_nodes, loop);
737 gcc_assert (nbbs == loop->num_nodes);
739 LOOP_VINFO_BBS (res) = bbs;
740 LOOP_VINFO_NITERS (res) = NULL;
741 LOOP_VINFO_NITERS_UNCHANGED (res) = NULL;
742 LOOP_VINFO_COST_MODEL_MIN_ITERS (res) = 0;
743 LOOP_VINFO_VECTORIZABLE_P (res) = 0;
744 LOOP_PEELING_FOR_ALIGNMENT (res) = 0;
745 LOOP_VINFO_VECT_FACTOR (res) = 0;
746 LOOP_VINFO_DATAREFS (res) = VEC_alloc (data_reference_p, heap, 10);
747 LOOP_VINFO_DDRS (res) = VEC_alloc (ddr_p, heap, 10 * 10);
748 LOOP_VINFO_UNALIGNED_DR (res) = NULL;
749 LOOP_VINFO_MAY_MISALIGN_STMTS (res) =
750 VEC_alloc (gimple, heap,
751 PARAM_VALUE (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS));
752 LOOP_VINFO_MAY_ALIAS_DDRS (res) =
753 VEC_alloc (ddr_p, heap,
754 PARAM_VALUE (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS));
755 LOOP_VINFO_STRIDED_STORES (res) = VEC_alloc (gimple, heap, 10);
756 LOOP_VINFO_REDUCTIONS (res) = VEC_alloc (gimple, heap, 10);
757 LOOP_VINFO_SLP_INSTANCES (res) = VEC_alloc (slp_instance, heap, 10);
758 LOOP_VINFO_SLP_UNROLLING_FACTOR (res) = 1;
759 LOOP_VINFO_PEELING_HTAB (res) = NULL;
765 /* Function destroy_loop_vec_info.
767 Free LOOP_VINFO struct, as well as all the stmt_vec_info structs of all the
768 stmts in the loop. */
771 destroy_loop_vec_info (loop_vec_info loop_vinfo, bool clean_stmts)
776 gimple_stmt_iterator si;
778 VEC (slp_instance, heap) *slp_instances;
779 slp_instance instance;
784 loop = LOOP_VINFO_LOOP (loop_vinfo);
786 bbs = LOOP_VINFO_BBS (loop_vinfo);
787 nbbs = loop->num_nodes;
791 free (LOOP_VINFO_BBS (loop_vinfo));
792 free_data_refs (LOOP_VINFO_DATAREFS (loop_vinfo));
793 free_dependence_relations (LOOP_VINFO_DDRS (loop_vinfo));
794 VEC_free (gimple, heap, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo));
801 for (j = 0; j < nbbs; j++)
803 basic_block bb = bbs[j];
804 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
805 free_stmt_vec_info (gsi_stmt (si));
807 for (si = gsi_start_bb (bb); !gsi_end_p (si); )
809 gimple stmt = gsi_stmt (si);
810 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
814 /* Check if this is a "pattern stmt" (introduced by the
815 vectorizer during the pattern recognition pass). */
816 bool remove_stmt_p = false;
817 gimple orig_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
820 stmt_vec_info orig_stmt_info = vinfo_for_stmt (orig_stmt);
822 && STMT_VINFO_IN_PATTERN_P (orig_stmt_info))
823 remove_stmt_p = true;
826 /* Free stmt_vec_info. */
827 free_stmt_vec_info (stmt);
829 /* Remove dead "pattern stmts". */
831 gsi_remove (&si, true);
837 free (LOOP_VINFO_BBS (loop_vinfo));
838 free_data_refs (LOOP_VINFO_DATAREFS (loop_vinfo));
839 free_dependence_relations (LOOP_VINFO_DDRS (loop_vinfo));
840 VEC_free (gimple, heap, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo));
841 VEC_free (ddr_p, heap, LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo));
842 slp_instances = LOOP_VINFO_SLP_INSTANCES (loop_vinfo);
843 FOR_EACH_VEC_ELT (slp_instance, slp_instances, j, instance)
844 vect_free_slp_instance (instance);
846 VEC_free (slp_instance, heap, LOOP_VINFO_SLP_INSTANCES (loop_vinfo));
847 VEC_free (gimple, heap, LOOP_VINFO_STRIDED_STORES (loop_vinfo));
848 VEC_free (gimple, heap, LOOP_VINFO_REDUCTIONS (loop_vinfo));
850 if (LOOP_VINFO_PEELING_HTAB (loop_vinfo))
851 htab_delete (LOOP_VINFO_PEELING_HTAB (loop_vinfo));
858 /* Function vect_analyze_loop_1.
860 Apply a set of analyses on LOOP, and create a loop_vec_info struct
861 for it. The different analyses will record information in the
862 loop_vec_info struct. This is a subset of the analyses applied in
863 vect_analyze_loop, to be applied on an inner-loop nested in the loop
864 that is now considered for (outer-loop) vectorization. */
867 vect_analyze_loop_1 (struct loop *loop)
869 loop_vec_info loop_vinfo;
871 if (vect_print_dump_info (REPORT_DETAILS))
872 fprintf (vect_dump, "===== analyze_loop_nest_1 =====");
874 /* Check the CFG characteristics of the loop (nesting, entry/exit, etc. */
876 loop_vinfo = vect_analyze_loop_form (loop);
879 if (vect_print_dump_info (REPORT_DETAILS))
880 fprintf (vect_dump, "bad inner-loop form.");
888 /* Function vect_analyze_loop_form.
890 Verify that certain CFG restrictions hold, including:
891 - the loop has a pre-header
892 - the loop has a single entry and exit
893 - the loop exit condition is simple enough, and the number of iterations
894 can be analyzed (a countable loop). */
897 vect_analyze_loop_form (struct loop *loop)
899 loop_vec_info loop_vinfo;
901 tree number_of_iterations = NULL;
902 loop_vec_info inner_loop_vinfo = NULL;
904 if (vect_print_dump_info (REPORT_DETAILS))
905 fprintf (vect_dump, "=== vect_analyze_loop_form ===");
907 /* Different restrictions apply when we are considering an inner-most loop,
908 vs. an outer (nested) loop.
909 (FORNOW. May want to relax some of these restrictions in the future). */
913 /* Inner-most loop. We currently require that the number of BBs is
914 exactly 2 (the header and latch). Vectorizable inner-most loops
925 if (loop->num_nodes != 2)
927 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
928 fprintf (vect_dump, "not vectorized: control flow in loop.");
932 if (empty_block_p (loop->header))
934 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
935 fprintf (vect_dump, "not vectorized: empty loop.");
941 struct loop *innerloop = loop->inner;
944 /* Nested loop. We currently require that the loop is doubly-nested,
945 contains a single inner loop, and the number of BBs is exactly 5.
946 Vectorizable outer-loops look like this:
958 The inner-loop has the properties expected of inner-most loops
959 as described above. */
961 if ((loop->inner)->inner || (loop->inner)->next)
963 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
964 fprintf (vect_dump, "not vectorized: multiple nested loops.");
968 /* Analyze the inner-loop. */
969 inner_loop_vinfo = vect_analyze_loop_1 (loop->inner);
970 if (!inner_loop_vinfo)
972 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
973 fprintf (vect_dump, "not vectorized: Bad inner loop.");
977 if (!expr_invariant_in_loop_p (loop,
978 LOOP_VINFO_NITERS (inner_loop_vinfo)))
980 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
982 "not vectorized: inner-loop count not invariant.");
983 destroy_loop_vec_info (inner_loop_vinfo, true);
987 if (loop->num_nodes != 5)
989 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
990 fprintf (vect_dump, "not vectorized: control flow in loop.");
991 destroy_loop_vec_info (inner_loop_vinfo, true);
995 gcc_assert (EDGE_COUNT (innerloop->header->preds) == 2);
996 entryedge = EDGE_PRED (innerloop->header, 0);
997 if (EDGE_PRED (innerloop->header, 0)->src == innerloop->latch)
998 entryedge = EDGE_PRED (innerloop->header, 1);
1000 if (entryedge->src != loop->header
1001 || !single_exit (innerloop)
1002 || single_exit (innerloop)->dest != EDGE_PRED (loop->latch, 0)->src)
1004 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1005 fprintf (vect_dump, "not vectorized: unsupported outerloop form.");
1006 destroy_loop_vec_info (inner_loop_vinfo, true);
1010 if (vect_print_dump_info (REPORT_DETAILS))
1011 fprintf (vect_dump, "Considering outer-loop vectorization.");
1014 if (!single_exit (loop)
1015 || EDGE_COUNT (loop->header->preds) != 2)
1017 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1019 if (!single_exit (loop))
1020 fprintf (vect_dump, "not vectorized: multiple exits.");
1021 else if (EDGE_COUNT (loop->header->preds) != 2)
1022 fprintf (vect_dump, "not vectorized: too many incoming edges.");
1024 if (inner_loop_vinfo)
1025 destroy_loop_vec_info (inner_loop_vinfo, true);
1029 /* We assume that the loop exit condition is at the end of the loop. i.e,
1030 that the loop is represented as a do-while (with a proper if-guard
1031 before the loop if needed), where the loop header contains all the
1032 executable statements, and the latch is empty. */
1033 if (!empty_block_p (loop->latch)
1034 || !gimple_seq_empty_p (phi_nodes (loop->latch)))
1036 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1037 fprintf (vect_dump, "not vectorized: unexpected loop form.");
1038 if (inner_loop_vinfo)
1039 destroy_loop_vec_info (inner_loop_vinfo, true);
1043 /* Make sure there exists a single-predecessor exit bb: */
1044 if (!single_pred_p (single_exit (loop)->dest))
1046 edge e = single_exit (loop);
1047 if (!(e->flags & EDGE_ABNORMAL))
1049 split_loop_exit_edge (e);
1050 if (vect_print_dump_info (REPORT_DETAILS))
1051 fprintf (vect_dump, "split exit edge.");
1055 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1056 fprintf (vect_dump, "not vectorized: abnormal loop exit edge.");
1057 if (inner_loop_vinfo)
1058 destroy_loop_vec_info (inner_loop_vinfo, true);
1063 loop_cond = vect_get_loop_niters (loop, &number_of_iterations);
1066 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1067 fprintf (vect_dump, "not vectorized: complicated exit condition.");
1068 if (inner_loop_vinfo)
1069 destroy_loop_vec_info (inner_loop_vinfo, true);
1073 if (!number_of_iterations)
1075 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1077 "not vectorized: number of iterations cannot be computed.");
1078 if (inner_loop_vinfo)
1079 destroy_loop_vec_info (inner_loop_vinfo, true);
1083 if (chrec_contains_undetermined (number_of_iterations))
1085 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1086 fprintf (vect_dump, "Infinite number of iterations.");
1087 if (inner_loop_vinfo)
1088 destroy_loop_vec_info (inner_loop_vinfo, true);
1092 if (!NITERS_KNOWN_P (number_of_iterations))
1094 if (vect_print_dump_info (REPORT_DETAILS))
1096 fprintf (vect_dump, "Symbolic number of iterations is ");
1097 print_generic_expr (vect_dump, number_of_iterations, TDF_DETAILS);
1100 else if (TREE_INT_CST_LOW (number_of_iterations) == 0)
1102 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1103 fprintf (vect_dump, "not vectorized: number of iterations = 0.");
1104 if (inner_loop_vinfo)
1105 destroy_loop_vec_info (inner_loop_vinfo, false);
1109 loop_vinfo = new_loop_vec_info (loop);
1110 LOOP_VINFO_NITERS (loop_vinfo) = number_of_iterations;
1111 LOOP_VINFO_NITERS_UNCHANGED (loop_vinfo) = number_of_iterations;
1113 STMT_VINFO_TYPE (vinfo_for_stmt (loop_cond)) = loop_exit_ctrl_vec_info_type;
1115 /* CHECKME: May want to keep it around it in the future. */
1116 if (inner_loop_vinfo)
1117 destroy_loop_vec_info (inner_loop_vinfo, false);
1119 gcc_assert (!loop->aux);
1120 loop->aux = loop_vinfo;
1125 /* Get cost by calling cost target builtin. */
1128 int vect_get_cost (enum vect_cost_for_stmt type_of_cost)
1130 tree dummy_type = NULL;
1133 return targetm.vectorize.builtin_vectorization_cost (type_of_cost,
1138 /* Function vect_analyze_loop_operations.
1140 Scan the loop stmts and make sure they are all vectorizable. */
1143 vect_analyze_loop_operations (loop_vec_info loop_vinfo)
1145 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
1146 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
1147 int nbbs = loop->num_nodes;
1148 gimple_stmt_iterator si;
1149 unsigned int vectorization_factor = 0;
1152 stmt_vec_info stmt_info;
1153 bool need_to_vectorize = false;
1154 int min_profitable_iters;
1155 int min_scalar_loop_bound;
1157 bool only_slp_in_loop = true, ok;
1159 if (vect_print_dump_info (REPORT_DETAILS))
1160 fprintf (vect_dump, "=== vect_analyze_loop_operations ===");
1162 gcc_assert (LOOP_VINFO_VECT_FACTOR (loop_vinfo));
1163 vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
1165 for (i = 0; i < nbbs; i++)
1167 basic_block bb = bbs[i];
1169 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
1171 phi = gsi_stmt (si);
1174 stmt_info = vinfo_for_stmt (phi);
1175 if (vect_print_dump_info (REPORT_DETAILS))
1177 fprintf (vect_dump, "examining phi: ");
1178 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
1181 if (! is_loop_header_bb_p (bb))
1183 /* inner-loop loop-closed exit phi in outer-loop vectorization
1184 (i.e. a phi in the tail of the outer-loop).
1185 FORNOW: we currently don't support the case that these phis
1186 are not used in the outerloop (unless it is double reduction,
1187 i.e., this phi is vect_reduction_def), cause this case
1188 requires to actually do something here. */
1189 if ((!STMT_VINFO_RELEVANT_P (stmt_info)
1190 || STMT_VINFO_LIVE_P (stmt_info))
1191 && STMT_VINFO_DEF_TYPE (stmt_info)
1192 != vect_double_reduction_def)
1194 if (vect_print_dump_info (REPORT_DETAILS))
1196 "Unsupported loop-closed phi in outer-loop.");
1202 gcc_assert (stmt_info);
1204 if (STMT_VINFO_LIVE_P (stmt_info))
1206 /* FORNOW: not yet supported. */
1207 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1208 fprintf (vect_dump, "not vectorized: value used after loop.");
1212 if (STMT_VINFO_RELEVANT (stmt_info) == vect_used_in_scope
1213 && STMT_VINFO_DEF_TYPE (stmt_info) != vect_induction_def)
1215 /* A scalar-dependence cycle that we don't support. */
1216 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1217 fprintf (vect_dump, "not vectorized: scalar dependence cycle.");
1221 if (STMT_VINFO_RELEVANT_P (stmt_info))
1223 need_to_vectorize = true;
1224 if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_induction_def)
1225 ok = vectorizable_induction (phi, NULL, NULL);
1230 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1233 "not vectorized: relevant phi not supported: ");
1234 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
1240 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
1242 gimple stmt = gsi_stmt (si);
1243 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
1245 gcc_assert (stmt_info);
1247 if (!vect_analyze_stmt (stmt, &need_to_vectorize, NULL))
1250 if ((STMT_VINFO_RELEVANT_P (stmt_info)
1251 || VECTORIZABLE_CYCLE_DEF (STMT_VINFO_DEF_TYPE (stmt_info)))
1252 && !PURE_SLP_STMT (stmt_info))
1253 /* STMT needs both SLP and loop-based vectorization. */
1254 only_slp_in_loop = false;
1258 /* All operations in the loop are either irrelevant (deal with loop
1259 control, or dead), or only used outside the loop and can be moved
1260 out of the loop (e.g. invariants, inductions). The loop can be
1261 optimized away by scalar optimizations. We're better off not
1262 touching this loop. */
1263 if (!need_to_vectorize)
1265 if (vect_print_dump_info (REPORT_DETAILS))
1267 "All the computation can be taken out of the loop.");
1268 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1270 "not vectorized: redundant loop. no profit to vectorize.");
1274 /* If all the stmts in the loop can be SLPed, we perform only SLP, and
1275 vectorization factor of the loop is the unrolling factor required by the
1276 SLP instances. If that unrolling factor is 1, we say, that we perform
1277 pure SLP on loop - cross iteration parallelism is not exploited. */
1278 if (only_slp_in_loop)
1279 vectorization_factor = LOOP_VINFO_SLP_UNROLLING_FACTOR (loop_vinfo);
1281 vectorization_factor = least_common_multiple (vectorization_factor,
1282 LOOP_VINFO_SLP_UNROLLING_FACTOR (loop_vinfo));
1284 LOOP_VINFO_VECT_FACTOR (loop_vinfo) = vectorization_factor;
1286 if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
1287 && vect_print_dump_info (REPORT_DETAILS))
1289 "vectorization_factor = %d, niters = " HOST_WIDE_INT_PRINT_DEC,
1290 vectorization_factor, LOOP_VINFO_INT_NITERS (loop_vinfo));
1292 if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
1293 && (LOOP_VINFO_INT_NITERS (loop_vinfo) < vectorization_factor))
1295 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1296 fprintf (vect_dump, "not vectorized: iteration count too small.");
1297 if (vect_print_dump_info (REPORT_DETAILS))
1298 fprintf (vect_dump,"not vectorized: iteration count smaller than "
1299 "vectorization factor.");
1303 /* Analyze cost. Decide if worth while to vectorize. */
1305 /* Once VF is set, SLP costs should be updated since the number of created
1306 vector stmts depends on VF. */
1307 vect_update_slp_costs_according_to_vf (loop_vinfo);
1309 min_profitable_iters = vect_estimate_min_profitable_iters (loop_vinfo);
1310 LOOP_VINFO_COST_MODEL_MIN_ITERS (loop_vinfo) = min_profitable_iters;
1312 if (min_profitable_iters < 0)
1314 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1315 fprintf (vect_dump, "not vectorized: vectorization not profitable.");
1316 if (vect_print_dump_info (REPORT_DETAILS))
1317 fprintf (vect_dump, "not vectorized: vector version will never be "
1322 min_scalar_loop_bound = ((PARAM_VALUE (PARAM_MIN_VECT_LOOP_BOUND)
1323 * vectorization_factor) - 1);
1325 /* Use the cost model only if it is more conservative than user specified
1328 th = (unsigned) min_scalar_loop_bound;
1329 if (min_profitable_iters
1330 && (!min_scalar_loop_bound
1331 || min_profitable_iters > min_scalar_loop_bound))
1332 th = (unsigned) min_profitable_iters;
1334 if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
1335 && LOOP_VINFO_INT_NITERS (loop_vinfo) <= th)
1337 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1338 fprintf (vect_dump, "not vectorized: vectorization not "
1340 if (vect_print_dump_info (REPORT_DETAILS))
1341 fprintf (vect_dump, "not vectorized: iteration count smaller than "
1342 "user specified loop bound parameter or minimum "
1343 "profitable iterations (whichever is more conservative).");
1347 if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
1348 || LOOP_VINFO_INT_NITERS (loop_vinfo) % vectorization_factor != 0
1349 || LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo))
1351 if (vect_print_dump_info (REPORT_DETAILS))
1352 fprintf (vect_dump, "epilog loop required.");
1353 if (!vect_can_advance_ivs_p (loop_vinfo))
1355 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1357 "not vectorized: can't create epilog loop 1.");
1360 if (!slpeel_can_duplicate_loop_p (loop, single_exit (loop)))
1362 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1364 "not vectorized: can't create epilog loop 2.");
1373 /* Function vect_analyze_loop.
1375 Apply a set of analyses on LOOP, and create a loop_vec_info struct
1376 for it. The different analyses will record information in the
1377 loop_vec_info struct. */
1379 vect_analyze_loop (struct loop *loop)
1382 loop_vec_info loop_vinfo;
1383 int max_vf = MAX_VECTORIZATION_FACTOR;
1386 if (vect_print_dump_info (REPORT_DETAILS))
1387 fprintf (vect_dump, "===== analyze_loop_nest =====");
1389 if (loop_outer (loop)
1390 && loop_vec_info_for_loop (loop_outer (loop))
1391 && LOOP_VINFO_VECTORIZABLE_P (loop_vec_info_for_loop (loop_outer (loop))))
1393 if (vect_print_dump_info (REPORT_DETAILS))
1394 fprintf (vect_dump, "outer-loop already vectorized.");
1398 /* Check the CFG characteristics of the loop (nesting, entry/exit, etc. */
1400 loop_vinfo = vect_analyze_loop_form (loop);
1403 if (vect_print_dump_info (REPORT_DETAILS))
1404 fprintf (vect_dump, "bad loop form.");
1408 /* Find all data references in the loop (which correspond to vdefs/vuses)
1409 and analyze their evolution in the loop. Also adjust the minimal
1410 vectorization factor according to the loads and stores.
1412 FORNOW: Handle only simple, array references, which
1413 alignment can be forced, and aligned pointer-references. */
1415 ok = vect_analyze_data_refs (loop_vinfo, NULL, &min_vf);
1418 if (vect_print_dump_info (REPORT_DETAILS))
1419 fprintf (vect_dump, "bad data references.");
1420 destroy_loop_vec_info (loop_vinfo, true);
1424 /* Classify all cross-iteration scalar data-flow cycles.
1425 Cross-iteration cycles caused by virtual phis are analyzed separately. */
1427 vect_analyze_scalar_cycles (loop_vinfo);
1429 vect_pattern_recog (loop_vinfo);
1431 /* Data-flow analysis to detect stmts that do not need to be vectorized. */
1433 ok = vect_mark_stmts_to_be_vectorized (loop_vinfo);
1436 if (vect_print_dump_info (REPORT_DETAILS))
1437 fprintf (vect_dump, "unexpected pattern.");
1438 destroy_loop_vec_info (loop_vinfo, true);
1442 /* Analyze data dependences between the data-refs in the loop
1443 and adjust the maximum vectorization factor according to
1445 FORNOW: fail at the first data dependence that we encounter. */
1447 ok = vect_analyze_data_ref_dependences (loop_vinfo, NULL, &max_vf, &dummy);
1451 if (vect_print_dump_info (REPORT_DETAILS))
1452 fprintf (vect_dump, "bad data dependence.");
1453 destroy_loop_vec_info (loop_vinfo, true);
1457 ok = vect_determine_vectorization_factor (loop_vinfo);
1460 if (vect_print_dump_info (REPORT_DETAILS))
1461 fprintf (vect_dump, "can't determine vectorization factor.");
1462 destroy_loop_vec_info (loop_vinfo, true);
1465 if (max_vf < LOOP_VINFO_VECT_FACTOR (loop_vinfo))
1467 if (vect_print_dump_info (REPORT_DETAILS))
1468 fprintf (vect_dump, "bad data dependence.");
1469 destroy_loop_vec_info (loop_vinfo, true);
1473 /* Analyze the alignment of the data-refs in the loop.
1474 Fail if a data reference is found that cannot be vectorized. */
1476 ok = vect_analyze_data_refs_alignment (loop_vinfo, NULL);
1479 if (vect_print_dump_info (REPORT_DETAILS))
1480 fprintf (vect_dump, "bad data alignment.");
1481 destroy_loop_vec_info (loop_vinfo, true);
1485 /* Analyze the access patterns of the data-refs in the loop (consecutive,
1486 complex, etc.). FORNOW: Only handle consecutive access pattern. */
1488 ok = vect_analyze_data_ref_accesses (loop_vinfo, NULL);
1491 if (vect_print_dump_info (REPORT_DETAILS))
1492 fprintf (vect_dump, "bad data access.");
1493 destroy_loop_vec_info (loop_vinfo, true);
1497 /* Prune the list of ddrs to be tested at run-time by versioning for alias.
1498 It is important to call pruning after vect_analyze_data_ref_accesses,
1499 since we use grouping information gathered by interleaving analysis. */
1500 ok = vect_prune_runtime_alias_test_list (loop_vinfo);
1503 if (vect_print_dump_info (REPORT_DETAILS))
1504 fprintf (vect_dump, "too long list of versioning for alias "
1506 destroy_loop_vec_info (loop_vinfo, true);
1510 /* This pass will decide on using loop versioning and/or loop peeling in
1511 order to enhance the alignment of data references in the loop. */
1513 ok = vect_enhance_data_refs_alignment (loop_vinfo);
1516 if (vect_print_dump_info (REPORT_DETAILS))
1517 fprintf (vect_dump, "bad data alignment.");
1518 destroy_loop_vec_info (loop_vinfo, true);
1522 /* Check the SLP opportunities in the loop, analyze and build SLP trees. */
1523 ok = vect_analyze_slp (loop_vinfo, NULL);
1526 /* Decide which possible SLP instances to SLP. */
1527 vect_make_slp_decision (loop_vinfo);
1529 /* Find stmts that need to be both vectorized and SLPed. */
1530 vect_detect_hybrid_slp (loop_vinfo);
1533 /* Scan all the operations in the loop and make sure they are
1536 ok = vect_analyze_loop_operations (loop_vinfo);
1539 if (vect_print_dump_info (REPORT_DETAILS))
1540 fprintf (vect_dump, "bad operation or unsupported loop bound.");
1541 destroy_loop_vec_info (loop_vinfo, true);
1545 LOOP_VINFO_VECTORIZABLE_P (loop_vinfo) = 1;
1551 /* Function reduction_code_for_scalar_code
1554 CODE - tree_code of a reduction operations.
1557 REDUC_CODE - the corresponding tree-code to be used to reduce the
1558 vector of partial results into a single scalar result (which
1559 will also reside in a vector) or ERROR_MARK if the operation is
1560 a supported reduction operation, but does not have such tree-code.
1562 Return FALSE if CODE currently cannot be vectorized as reduction. */
1565 reduction_code_for_scalar_code (enum tree_code code,
1566 enum tree_code *reduc_code)
1571 *reduc_code = REDUC_MAX_EXPR;
1575 *reduc_code = REDUC_MIN_EXPR;
1579 *reduc_code = REDUC_PLUS_EXPR;
1587 *reduc_code = ERROR_MARK;
1596 /* Error reporting helper for vect_is_simple_reduction below. GIMPLE statement
1597 STMT is printed with a message MSG. */
1600 report_vect_op (gimple stmt, const char *msg)
1602 fprintf (vect_dump, "%s", msg);
1603 print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
1607 /* Function vect_is_simple_reduction_1
1609 (1) Detect a cross-iteration def-use cycle that represents a simple
1610 reduction computation. We look for the following pattern:
1615 a2 = operation (a3, a1)
1618 1. operation is commutative and associative and it is safe to
1619 change the order of the computation (if CHECK_REDUCTION is true)
1620 2. no uses for a2 in the loop (a2 is used out of the loop)
1621 3. no uses of a1 in the loop besides the reduction operation.
1623 Condition 1 is tested here.
1624 Conditions 2,3 are tested in vect_mark_stmts_to_be_vectorized.
1626 (2) Detect a cross-iteration def-use cycle in nested loops, i.e.,
1627 nested cycles, if CHECK_REDUCTION is false.
1629 (3) Detect cycles of phi nodes in outer-loop vectorization, i.e., double
1633 inner loop (def of a3)
1636 If MODIFY is true it tries also to rework the code in-place to enable
1637 detection of more reduction patterns. For the time being we rewrite
1638 "res -= RHS" into "rhs += -RHS" when it seems worthwhile.
1642 vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
1643 bool check_reduction, bool *double_reduc,
1646 struct loop *loop = (gimple_bb (phi))->loop_father;
1647 struct loop *vect_loop = LOOP_VINFO_LOOP (loop_info);
1648 edge latch_e = loop_latch_edge (loop);
1649 tree loop_arg = PHI_ARG_DEF_FROM_EDGE (phi, latch_e);
1650 gimple def_stmt, def1 = NULL, def2 = NULL;
1651 enum tree_code orig_code, code;
1652 tree op1, op2, op3 = NULL_TREE, op4 = NULL_TREE;
1656 imm_use_iterator imm_iter;
1657 use_operand_p use_p;
1660 *double_reduc = false;
1662 /* If CHECK_REDUCTION is true, we assume inner-most loop vectorization,
1663 otherwise, we assume outer loop vectorization. */
1664 gcc_assert ((check_reduction && loop == vect_loop)
1665 || (!check_reduction && flow_loop_nested_p (vect_loop, loop)));
1667 name = PHI_RESULT (phi);
1669 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, name)
1671 gimple use_stmt = USE_STMT (use_p);
1672 if (is_gimple_debug (use_stmt))
1674 if (flow_bb_inside_loop_p (loop, gimple_bb (use_stmt))
1675 && vinfo_for_stmt (use_stmt)
1676 && !is_pattern_stmt_p (vinfo_for_stmt (use_stmt)))
1680 if (vect_print_dump_info (REPORT_DETAILS))
1681 fprintf (vect_dump, "reduction used in loop.");
1686 if (TREE_CODE (loop_arg) != SSA_NAME)
1688 if (vect_print_dump_info (REPORT_DETAILS))
1690 fprintf (vect_dump, "reduction: not ssa_name: ");
1691 print_generic_expr (vect_dump, loop_arg, TDF_SLIM);
1696 def_stmt = SSA_NAME_DEF_STMT (loop_arg);
1699 if (vect_print_dump_info (REPORT_DETAILS))
1700 fprintf (vect_dump, "reduction: no def_stmt.");
1704 if (!is_gimple_assign (def_stmt) && gimple_code (def_stmt) != GIMPLE_PHI)
1706 if (vect_print_dump_info (REPORT_DETAILS))
1707 print_gimple_stmt (vect_dump, def_stmt, 0, TDF_SLIM);
1711 if (is_gimple_assign (def_stmt))
1713 name = gimple_assign_lhs (def_stmt);
1718 name = PHI_RESULT (def_stmt);
1723 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, name)
1725 gimple use_stmt = USE_STMT (use_p);
1726 if (is_gimple_debug (use_stmt))
1728 if (flow_bb_inside_loop_p (loop, gimple_bb (use_stmt))
1729 && vinfo_for_stmt (use_stmt)
1730 && !is_pattern_stmt_p (vinfo_for_stmt (use_stmt)))
1734 if (vect_print_dump_info (REPORT_DETAILS))
1735 fprintf (vect_dump, "reduction used in loop.");
1740 /* If DEF_STMT is a phi node itself, we expect it to have a single argument
1741 defined in the inner loop. */
1744 op1 = PHI_ARG_DEF (def_stmt, 0);
1746 if (gimple_phi_num_args (def_stmt) != 1
1747 || TREE_CODE (op1) != SSA_NAME)
1749 if (vect_print_dump_info (REPORT_DETAILS))
1750 fprintf (vect_dump, "unsupported phi node definition.");
1755 def1 = SSA_NAME_DEF_STMT (op1);
1756 if (flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))
1758 && flow_bb_inside_loop_p (loop->inner, gimple_bb (def1))
1759 && is_gimple_assign (def1))
1761 if (vect_print_dump_info (REPORT_DETAILS))
1762 report_vect_op (def_stmt, "detected double reduction: ");
1764 *double_reduc = true;
1771 code = orig_code = gimple_assign_rhs_code (def_stmt);
1773 /* We can handle "res -= x[i]", which is non-associative by
1774 simply rewriting this into "res += -x[i]". Avoid changing
1775 gimple instruction for the first simple tests and only do this
1776 if we're allowed to change code at all. */
1777 if (code == MINUS_EXPR && modify)
1781 && (!commutative_tree_code (code) || !associative_tree_code (code)))
1783 if (vect_print_dump_info (REPORT_DETAILS))
1784 report_vect_op (def_stmt, "reduction: not commutative/associative: ");
1788 if (get_gimple_rhs_class (code) != GIMPLE_BINARY_RHS)
1790 if (code != COND_EXPR)
1792 if (vect_print_dump_info (REPORT_DETAILS))
1793 report_vect_op (def_stmt, "reduction: not binary operation: ");
1798 op3 = TREE_OPERAND (gimple_assign_rhs1 (def_stmt), 0);
1799 if (COMPARISON_CLASS_P (op3))
1801 op4 = TREE_OPERAND (op3, 1);
1802 op3 = TREE_OPERAND (op3, 0);
1805 op1 = TREE_OPERAND (gimple_assign_rhs1 (def_stmt), 1);
1806 op2 = TREE_OPERAND (gimple_assign_rhs1 (def_stmt), 2);
1808 if (TREE_CODE (op1) != SSA_NAME && TREE_CODE (op2) != SSA_NAME)
1810 if (vect_print_dump_info (REPORT_DETAILS))
1811 report_vect_op (def_stmt, "reduction: uses not ssa_names: ");
1818 op1 = gimple_assign_rhs1 (def_stmt);
1819 op2 = gimple_assign_rhs2 (def_stmt);
1821 if (TREE_CODE (op1) != SSA_NAME || TREE_CODE (op2) != SSA_NAME)
1823 if (vect_print_dump_info (REPORT_DETAILS))
1824 report_vect_op (def_stmt, "reduction: uses not ssa_names: ");
1830 type = TREE_TYPE (gimple_assign_lhs (def_stmt));
1831 if ((TREE_CODE (op1) == SSA_NAME
1832 && !types_compatible_p (type,TREE_TYPE (op1)))
1833 || (TREE_CODE (op2) == SSA_NAME
1834 && !types_compatible_p (type, TREE_TYPE (op2)))
1835 || (op3 && TREE_CODE (op3) == SSA_NAME
1836 && !types_compatible_p (type, TREE_TYPE (op3)))
1837 || (op4 && TREE_CODE (op4) == SSA_NAME
1838 && !types_compatible_p (type, TREE_TYPE (op4))))
1840 if (vect_print_dump_info (REPORT_DETAILS))
1842 fprintf (vect_dump, "reduction: multiple types: operation type: ");
1843 print_generic_expr (vect_dump, type, TDF_SLIM);
1844 fprintf (vect_dump, ", operands types: ");
1845 print_generic_expr (vect_dump, TREE_TYPE (op1), TDF_SLIM);
1846 fprintf (vect_dump, ",");
1847 print_generic_expr (vect_dump, TREE_TYPE (op2), TDF_SLIM);
1850 fprintf (vect_dump, ",");
1851 print_generic_expr (vect_dump, TREE_TYPE (op3), TDF_SLIM);
1856 fprintf (vect_dump, ",");
1857 print_generic_expr (vect_dump, TREE_TYPE (op4), TDF_SLIM);
1864 /* Check that it's ok to change the order of the computation.
1865 Generally, when vectorizing a reduction we change the order of the
1866 computation. This may change the behavior of the program in some
1867 cases, so we need to check that this is ok. One exception is when
1868 vectorizing an outer-loop: the inner-loop is executed sequentially,
1869 and therefore vectorizing reductions in the inner-loop during
1870 outer-loop vectorization is safe. */
1872 /* CHECKME: check for !flag_finite_math_only too? */
1873 if (SCALAR_FLOAT_TYPE_P (type) && !flag_associative_math
1876 /* Changing the order of operations changes the semantics. */
1877 if (vect_print_dump_info (REPORT_DETAILS))
1878 report_vect_op (def_stmt, "reduction: unsafe fp math optimization: ");
1881 else if (INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type)
1884 /* Changing the order of operations changes the semantics. */
1885 if (vect_print_dump_info (REPORT_DETAILS))
1886 report_vect_op (def_stmt, "reduction: unsafe int math optimization: ");
1889 else if (SAT_FIXED_POINT_TYPE_P (type) && check_reduction)
1891 /* Changing the order of operations changes the semantics. */
1892 if (vect_print_dump_info (REPORT_DETAILS))
1893 report_vect_op (def_stmt,
1894 "reduction: unsafe fixed-point math optimization: ");
1898 /* If we detected "res -= x[i]" earlier, rewrite it into
1899 "res += -x[i]" now. If this turns out to be useless reassoc
1900 will clean it up again. */
1901 if (orig_code == MINUS_EXPR)
1903 tree rhs = gimple_assign_rhs2 (def_stmt);
1904 tree negrhs = make_ssa_name (SSA_NAME_VAR (rhs), NULL);
1905 gimple negate_stmt = gimple_build_assign_with_ops (NEGATE_EXPR, negrhs,
1907 gimple_stmt_iterator gsi = gsi_for_stmt (def_stmt);
1908 set_vinfo_for_stmt (negate_stmt, new_stmt_vec_info (negate_stmt,
1910 gsi_insert_before (&gsi, negate_stmt, GSI_NEW_STMT);
1911 gimple_assign_set_rhs2 (def_stmt, negrhs);
1912 gimple_assign_set_rhs_code (def_stmt, PLUS_EXPR);
1913 update_stmt (def_stmt);
1916 /* Reduction is safe. We're dealing with one of the following:
1917 1) integer arithmetic and no trapv
1918 2) floating point arithmetic, and special flags permit this optimization
1919 3) nested cycle (i.e., outer loop vectorization). */
1920 if (TREE_CODE (op1) == SSA_NAME)
1921 def1 = SSA_NAME_DEF_STMT (op1);
1923 if (TREE_CODE (op2) == SSA_NAME)
1924 def2 = SSA_NAME_DEF_STMT (op2);
1926 if (code != COND_EXPR
1927 && (!def1 || !def2 || gimple_nop_p (def1) || gimple_nop_p (def2)))
1929 if (vect_print_dump_info (REPORT_DETAILS))
1930 report_vect_op (def_stmt, "reduction: no defs for operands: ");
1934 /* Check that one def is the reduction def, defined by PHI,
1935 the other def is either defined in the loop ("vect_internal_def"),
1936 or it's an induction (defined by a loop-header phi-node). */
1938 if (def2 && def2 == phi
1939 && (code == COND_EXPR
1940 || (def1 && flow_bb_inside_loop_p (loop, gimple_bb (def1))
1941 && (is_gimple_assign (def1)
1942 || STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def1))
1943 == vect_induction_def
1944 || (gimple_code (def1) == GIMPLE_PHI
1945 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def1))
1946 == vect_internal_def
1947 && !is_loop_header_bb_p (gimple_bb (def1)))))))
1949 if (vect_print_dump_info (REPORT_DETAILS))
1950 report_vect_op (def_stmt, "detected reduction: ");
1953 else if (def1 && def1 == phi
1954 && (code == COND_EXPR
1955 || (def2 && flow_bb_inside_loop_p (loop, gimple_bb (def2))
1956 && (is_gimple_assign (def2)
1957 || STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def2))
1958 == vect_induction_def
1959 || (gimple_code (def2) == GIMPLE_PHI
1960 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def2))
1961 == vect_internal_def
1962 && !is_loop_header_bb_p (gimple_bb (def2)))))))
1964 if (check_reduction)
1966 /* Swap operands (just for simplicity - so that the rest of the code
1967 can assume that the reduction variable is always the last (second)
1969 if (vect_print_dump_info (REPORT_DETAILS))
1970 report_vect_op (def_stmt,
1971 "detected reduction: need to swap operands: ");
1973 swap_tree_operands (def_stmt, gimple_assign_rhs1_ptr (def_stmt),
1974 gimple_assign_rhs2_ptr (def_stmt));
1978 if (vect_print_dump_info (REPORT_DETAILS))
1979 report_vect_op (def_stmt, "detected reduction: ");
1986 if (vect_print_dump_info (REPORT_DETAILS))
1987 report_vect_op (def_stmt, "reduction: unknown pattern: ");
1993 /* Wrapper around vect_is_simple_reduction_1, that won't modify code
1994 in-place. Arguments as there. */
1997 vect_is_simple_reduction (loop_vec_info loop_info, gimple phi,
1998 bool check_reduction, bool *double_reduc)
2000 return vect_is_simple_reduction_1 (loop_info, phi, check_reduction,
2001 double_reduc, false);
2004 /* Wrapper around vect_is_simple_reduction_1, which will modify code
2005 in-place if it enables detection of more reductions. Arguments
2009 vect_force_simple_reduction (loop_vec_info loop_info, gimple phi,
2010 bool check_reduction, bool *double_reduc)
2012 return vect_is_simple_reduction_1 (loop_info, phi, check_reduction,
2013 double_reduc, true);
2016 /* Calculate the cost of one scalar iteration of the loop. */
2018 vect_get_single_scalar_iteraion_cost (loop_vec_info loop_vinfo)
2020 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2021 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
2022 int nbbs = loop->num_nodes, factor, scalar_single_iter_cost = 0;
2023 int innerloop_iters, i, stmt_cost;
2025 /* Count statements in scalar loop. Using this as scalar cost for a single
2028 TODO: Add outer loop support.
2030 TODO: Consider assigning different costs to different scalar
2034 innerloop_iters = 1;
2036 innerloop_iters = 50; /* FIXME */
2038 for (i = 0; i < nbbs; i++)
2040 gimple_stmt_iterator si;
2041 basic_block bb = bbs[i];
2043 if (bb->loop_father == loop->inner)
2044 factor = innerloop_iters;
2048 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
2050 gimple stmt = gsi_stmt (si);
2051 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
2053 if (!is_gimple_assign (stmt) && !is_gimple_call (stmt))
2056 /* Skip stmts that are not vectorized inside the loop. */
2058 && !STMT_VINFO_RELEVANT_P (stmt_info)
2059 && (!STMT_VINFO_LIVE_P (stmt_info)
2060 || STMT_VINFO_DEF_TYPE (stmt_info) != vect_reduction_def))
2063 if (STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt)))
2065 if (DR_IS_READ (STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt))))
2066 stmt_cost = vect_get_cost (scalar_load);
2068 stmt_cost = vect_get_cost (scalar_store);
2071 stmt_cost = vect_get_cost (scalar_stmt);
2073 scalar_single_iter_cost += stmt_cost * factor;
2076 return scalar_single_iter_cost;
2079 /* Calculate cost of peeling the loop PEEL_ITERS_PROLOGUE times. */
2081 vect_get_known_peeling_cost (loop_vec_info loop_vinfo, int peel_iters_prologue,
2082 int *peel_iters_epilogue,
2083 int scalar_single_iter_cost)
2085 int peel_guard_costs = 0;
2086 int vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
2088 if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo))
2090 *peel_iters_epilogue = vf/2;
2091 if (vect_print_dump_info (REPORT_COST))
2092 fprintf (vect_dump, "cost model: "
2093 "epilogue peel iters set to vf/2 because "
2094 "loop iterations are unknown .");
2096 /* If peeled iterations are known but number of scalar loop
2097 iterations are unknown, count a taken branch per peeled loop. */
2098 peel_guard_costs = 2 * vect_get_cost (cond_branch_taken);
2102 int niters = LOOP_VINFO_INT_NITERS (loop_vinfo);
2103 peel_iters_prologue = niters < peel_iters_prologue ?
2104 niters : peel_iters_prologue;
2105 *peel_iters_epilogue = (niters - peel_iters_prologue) % vf;
2108 return (peel_iters_prologue * scalar_single_iter_cost)
2109 + (*peel_iters_epilogue * scalar_single_iter_cost)
2113 /* Function vect_estimate_min_profitable_iters
2115 Return the number of iterations required for the vector version of the
2116 loop to be profitable relative to the cost of the scalar version of the
2119 TODO: Take profile info into account before making vectorization
2120 decisions, if available. */
2123 vect_estimate_min_profitable_iters (loop_vec_info loop_vinfo)
2126 int min_profitable_iters;
2127 int peel_iters_prologue;
2128 int peel_iters_epilogue;
2129 int vec_inside_cost = 0;
2130 int vec_outside_cost = 0;
2131 int scalar_single_iter_cost = 0;
2132 int scalar_outside_cost = 0;
2133 int vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
2134 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2135 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
2136 int nbbs = loop->num_nodes;
2137 int npeel = LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo);
2138 int peel_guard_costs = 0;
2139 int innerloop_iters = 0, factor;
2140 VEC (slp_instance, heap) *slp_instances;
2141 slp_instance instance;
2143 /* Cost model disabled. */
2144 if (!flag_vect_cost_model)
2146 if (vect_print_dump_info (REPORT_COST))
2147 fprintf (vect_dump, "cost model disabled.");
2151 /* Requires loop versioning tests to handle misalignment. */
2152 if (LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo))
2154 /* FIXME: Make cost depend on complexity of individual check. */
2156 VEC_length (gimple, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo));
2157 if (vect_print_dump_info (REPORT_COST))
2158 fprintf (vect_dump, "cost model: Adding cost of checks for loop "
2159 "versioning to treat misalignment.\n");
2162 /* Requires loop versioning with alias checks. */
2163 if (LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
2165 /* FIXME: Make cost depend on complexity of individual check. */
2167 VEC_length (ddr_p, LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo));
2168 if (vect_print_dump_info (REPORT_COST))
2169 fprintf (vect_dump, "cost model: Adding cost of checks for loop "
2170 "versioning aliasing.\n");
2173 if (LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)
2174 || LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
2175 vec_outside_cost += vect_get_cost (cond_branch_taken);
2177 /* Count statements in scalar loop. Using this as scalar cost for a single
2180 TODO: Add outer loop support.
2182 TODO: Consider assigning different costs to different scalar
2187 innerloop_iters = 50; /* FIXME */
2189 for (i = 0; i < nbbs; i++)
2191 gimple_stmt_iterator si;
2192 basic_block bb = bbs[i];
2194 if (bb->loop_father == loop->inner)
2195 factor = innerloop_iters;
2199 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
2201 gimple stmt = gsi_stmt (si);
2202 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
2203 /* Skip stmts that are not vectorized inside the loop. */
2204 if (!STMT_VINFO_RELEVANT_P (stmt_info)
2205 && (!STMT_VINFO_LIVE_P (stmt_info)
2206 || STMT_VINFO_DEF_TYPE (stmt_info) != vect_reduction_def))
2208 vec_inside_cost += STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info) * factor;
2209 /* FIXME: for stmts in the inner-loop in outer-loop vectorization,
2210 some of the "outside" costs are generated inside the outer-loop. */
2211 vec_outside_cost += STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info);
2215 scalar_single_iter_cost = vect_get_single_scalar_iteraion_cost (loop_vinfo);
2217 /* Add additional cost for the peeled instructions in prologue and epilogue
2220 FORNOW: If we don't know the value of peel_iters for prologue or epilogue
2221 at compile-time - we assume it's vf/2 (the worst would be vf-1).
2223 TODO: Build an expression that represents peel_iters for prologue and
2224 epilogue to be used in a run-time test. */
2228 peel_iters_prologue = vf/2;
2229 if (vect_print_dump_info (REPORT_COST))
2230 fprintf (vect_dump, "cost model: "
2231 "prologue peel iters set to vf/2.");
2233 /* If peeling for alignment is unknown, loop bound of main loop becomes
2235 peel_iters_epilogue = vf/2;
2236 if (vect_print_dump_info (REPORT_COST))
2237 fprintf (vect_dump, "cost model: "
2238 "epilogue peel iters set to vf/2 because "
2239 "peeling for alignment is unknown .");
2241 /* If peeled iterations are unknown, count a taken branch and a not taken
2242 branch per peeled loop. Even if scalar loop iterations are known,
2243 vector iterations are not known since peeled prologue iterations are
2244 not known. Hence guards remain the same. */
2245 peel_guard_costs += 2 * (vect_get_cost (cond_branch_taken)
2246 + vect_get_cost (cond_branch_not_taken));
2247 vec_outside_cost += (peel_iters_prologue * scalar_single_iter_cost)
2248 + (peel_iters_epilogue * scalar_single_iter_cost)
2253 peel_iters_prologue = npeel;
2254 vec_outside_cost += vect_get_known_peeling_cost (loop_vinfo,
2255 peel_iters_prologue, &peel_iters_epilogue,
2256 scalar_single_iter_cost);
2259 /* FORNOW: The scalar outside cost is incremented in one of the
2262 1. The vectorizer checks for alignment and aliasing and generates
2263 a condition that allows dynamic vectorization. A cost model
2264 check is ANDED with the versioning condition. Hence scalar code
2265 path now has the added cost of the versioning check.
2267 if (cost > th & versioning_check)
2270 Hence run-time scalar is incremented by not-taken branch cost.
2272 2. The vectorizer then checks if a prologue is required. If the
2273 cost model check was not done before during versioning, it has to
2274 be done before the prologue check.
2277 prologue = scalar_iters
2282 if (prologue == num_iters)
2285 Hence the run-time scalar cost is incremented by a taken branch,
2286 plus a not-taken branch, plus a taken branch cost.
2288 3. The vectorizer then checks if an epilogue is required. If the
2289 cost model check was not done before during prologue check, it
2290 has to be done with the epilogue check.
2296 if (prologue == num_iters)
2299 if ((cost <= th) | (scalar_iters-prologue-epilogue == 0))
2302 Hence the run-time scalar cost should be incremented by 2 taken
2305 TODO: The back end may reorder the BBS's differently and reverse
2306 conditions/branch directions. Change the estimates below to
2307 something more reasonable. */
2309 /* If the number of iterations is known and we do not do versioning, we can
2310 decide whether to vectorize at compile time. Hence the scalar version
2311 do not carry cost model guard costs. */
2312 if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
2313 || LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)
2314 || LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
2316 /* Cost model check occurs at versioning. */
2317 if (LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)
2318 || LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
2319 scalar_outside_cost += vect_get_cost (cond_branch_not_taken);
2322 /* Cost model check occurs at prologue generation. */
2323 if (LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo) < 0)
2324 scalar_outside_cost += 2 * vect_get_cost (cond_branch_taken)
2325 + vect_get_cost (cond_branch_not_taken);
2326 /* Cost model check occurs at epilogue generation. */
2328 scalar_outside_cost += 2 * vect_get_cost (cond_branch_taken);
2332 /* Add SLP costs. */
2333 slp_instances = LOOP_VINFO_SLP_INSTANCES (loop_vinfo);
2334 FOR_EACH_VEC_ELT (slp_instance, slp_instances, i, instance)
2336 vec_outside_cost += SLP_INSTANCE_OUTSIDE_OF_LOOP_COST (instance);
2337 vec_inside_cost += SLP_INSTANCE_INSIDE_OF_LOOP_COST (instance);
2340 /* Calculate number of iterations required to make the vector version
2341 profitable, relative to the loop bodies only. The following condition
2343 SIC * niters + SOC > VIC * ((niters-PL_ITERS-EP_ITERS)/VF) + VOC
2345 SIC = scalar iteration cost, VIC = vector iteration cost,
2346 VOC = vector outside cost, VF = vectorization factor,
2347 PL_ITERS = prologue iterations, EP_ITERS= epilogue iterations
2348 SOC = scalar outside cost for run time cost model check. */
2350 if ((scalar_single_iter_cost * vf) > vec_inside_cost)
2352 if (vec_outside_cost <= 0)
2353 min_profitable_iters = 1;
2356 min_profitable_iters = ((vec_outside_cost - scalar_outside_cost) * vf
2357 - vec_inside_cost * peel_iters_prologue
2358 - vec_inside_cost * peel_iters_epilogue)
2359 / ((scalar_single_iter_cost * vf)
2362 if ((scalar_single_iter_cost * vf * min_profitable_iters)
2363 <= ((vec_inside_cost * min_profitable_iters)
2364 + ((vec_outside_cost - scalar_outside_cost) * vf)))
2365 min_profitable_iters++;
2368 /* vector version will never be profitable. */
2371 if (vect_print_dump_info (REPORT_COST))
2372 fprintf (vect_dump, "cost model: the vector iteration cost = %d "
2373 "divided by the scalar iteration cost = %d "
2374 "is greater or equal to the vectorization factor = %d.",
2375 vec_inside_cost, scalar_single_iter_cost, vf);
2379 if (vect_print_dump_info (REPORT_COST))
2381 fprintf (vect_dump, "Cost model analysis: \n");
2382 fprintf (vect_dump, " Vector inside of loop cost: %d\n",
2384 fprintf (vect_dump, " Vector outside of loop cost: %d\n",
2386 fprintf (vect_dump, " Scalar iteration cost: %d\n",
2387 scalar_single_iter_cost);
2388 fprintf (vect_dump, " Scalar outside cost: %d\n", scalar_outside_cost);
2389 fprintf (vect_dump, " prologue iterations: %d\n",
2390 peel_iters_prologue);
2391 fprintf (vect_dump, " epilogue iterations: %d\n",
2392 peel_iters_epilogue);
2393 fprintf (vect_dump, " Calculated minimum iters for profitability: %d\n",
2394 min_profitable_iters);
2397 min_profitable_iters =
2398 min_profitable_iters < vf ? vf : min_profitable_iters;
2400 /* Because the condition we create is:
2401 if (niters <= min_profitable_iters)
2402 then skip the vectorized loop. */
2403 min_profitable_iters--;
2405 if (vect_print_dump_info (REPORT_COST))
2406 fprintf (vect_dump, " Profitability threshold = %d\n",
2407 min_profitable_iters);
2409 return min_profitable_iters;
2413 /* TODO: Close dependency between vect_model_*_cost and vectorizable_*
2414 functions. Design better to avoid maintenance issues. */
2416 /* Function vect_model_reduction_cost.
2418 Models cost for a reduction operation, including the vector ops
2419 generated within the strip-mine loop, the initial definition before
2420 the loop, and the epilogue code that must be generated. */
2423 vect_model_reduction_cost (stmt_vec_info stmt_info, enum tree_code reduc_code,
2427 enum tree_code code;
2430 gimple stmt, orig_stmt;
2432 enum machine_mode mode;
2433 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
2434 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2437 /* Cost of reduction op inside loop. */
2438 STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info)
2439 += ncopies * vect_get_cost (vector_stmt);
2441 stmt = STMT_VINFO_STMT (stmt_info);
2443 switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
2445 case GIMPLE_SINGLE_RHS:
2446 gcc_assert (TREE_OPERAND_LENGTH (gimple_assign_rhs1 (stmt)) == ternary_op);
2447 reduction_op = TREE_OPERAND (gimple_assign_rhs1 (stmt), 2);
2449 case GIMPLE_UNARY_RHS:
2450 reduction_op = gimple_assign_rhs1 (stmt);
2452 case GIMPLE_BINARY_RHS:
2453 reduction_op = gimple_assign_rhs2 (stmt);
2459 vectype = get_vectype_for_scalar_type (TREE_TYPE (reduction_op));
2462 if (vect_print_dump_info (REPORT_COST))
2464 fprintf (vect_dump, "unsupported data-type ");
2465 print_generic_expr (vect_dump, TREE_TYPE (reduction_op), TDF_SLIM);
2470 mode = TYPE_MODE (vectype);
2471 orig_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
2474 orig_stmt = STMT_VINFO_STMT (stmt_info);
2476 code = gimple_assign_rhs_code (orig_stmt);
2478 /* Add in cost for initial definition. */
2479 outer_cost += vect_get_cost (scalar_to_vec);
2481 /* Determine cost of epilogue code.
2483 We have a reduction operator that will reduce the vector in one statement.
2484 Also requires scalar extract. */
2486 if (!nested_in_vect_loop_p (loop, orig_stmt))
2488 if (reduc_code != ERROR_MARK)
2489 outer_cost += vect_get_cost (vector_stmt)
2490 + vect_get_cost (vec_to_scalar);
2493 int vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1);
2495 TYPE_SIZE (TREE_TYPE (gimple_assign_lhs (orig_stmt)));
2496 int element_bitsize = tree_low_cst (bitsize, 1);
2497 int nelements = vec_size_in_bits / element_bitsize;
2499 optab = optab_for_tree_code (code, vectype, optab_default);
2501 /* We have a whole vector shift available. */
2502 if (VECTOR_MODE_P (mode)
2503 && optab_handler (optab, mode) != CODE_FOR_nothing
2504 && optab_handler (vec_shr_optab, mode) != CODE_FOR_nothing)
2505 /* Final reduction via vector shifts and the reduction operator. Also
2506 requires scalar extract. */
2507 outer_cost += ((exact_log2(nelements) * 2)
2508 * vect_get_cost (vector_stmt)
2509 + vect_get_cost (vec_to_scalar));
2511 /* Use extracts and reduction op for final reduction. For N elements,
2512 we have N extracts and N-1 reduction ops. */
2513 outer_cost += ((nelements + nelements - 1)
2514 * vect_get_cost (vector_stmt));
2518 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info) = outer_cost;
2520 if (vect_print_dump_info (REPORT_COST))
2521 fprintf (vect_dump, "vect_model_reduction_cost: inside_cost = %d, "
2522 "outside_cost = %d .", STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info),
2523 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info));
2529 /* Function vect_model_induction_cost.
2531 Models cost for induction operations. */
2534 vect_model_induction_cost (stmt_vec_info stmt_info, int ncopies)
2536 /* loop cost for vec_loop. */
2537 STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info)
2538 = ncopies * vect_get_cost (vector_stmt);
2539 /* prologue cost for vec_init and vec_step. */
2540 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info)
2541 = 2 * vect_get_cost (scalar_to_vec);
2543 if (vect_print_dump_info (REPORT_COST))
2544 fprintf (vect_dump, "vect_model_induction_cost: inside_cost = %d, "
2545 "outside_cost = %d .", STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info),
2546 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info));
2550 /* Function get_initial_def_for_induction
2553 STMT - a stmt that performs an induction operation in the loop.
2554 IV_PHI - the initial value of the induction variable
2557 Return a vector variable, initialized with the first VF values of
2558 the induction variable. E.g., for an iv with IV_PHI='X' and
2559 evolution S, for a vector of 4 units, we want to return:
2560 [X, X + S, X + 2*S, X + 3*S]. */
2563 get_initial_def_for_induction (gimple iv_phi)
2565 stmt_vec_info stmt_vinfo = vinfo_for_stmt (iv_phi);
2566 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
2567 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2568 tree scalar_type = TREE_TYPE (gimple_phi_result (iv_phi));
2571 edge pe = loop_preheader_edge (loop);
2572 struct loop *iv_loop;
2574 tree vec, vec_init, vec_step, t;
2578 gimple init_stmt, induction_phi, new_stmt;
2579 tree induc_def, vec_def, vec_dest;
2580 tree init_expr, step_expr;
2581 int vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
2586 stmt_vec_info phi_info = vinfo_for_stmt (iv_phi);
2587 bool nested_in_vect_loop = false;
2588 gimple_seq stmts = NULL;
2589 imm_use_iterator imm_iter;
2590 use_operand_p use_p;
2594 gimple_stmt_iterator si;
2595 basic_block bb = gimple_bb (iv_phi);
2598 vectype = get_vectype_for_scalar_type (scalar_type);
2599 gcc_assert (vectype);
2600 nunits = TYPE_VECTOR_SUBPARTS (vectype);
2601 ncopies = vf / nunits;
2603 gcc_assert (phi_info);
2604 gcc_assert (ncopies >= 1);
2606 /* Find the first insertion point in the BB. */
2607 si = gsi_after_labels (bb);
2609 if (INTEGRAL_TYPE_P (scalar_type))
2610 step_expr = build_int_cst (scalar_type, 0);
2611 else if (POINTER_TYPE_P (scalar_type))
2612 step_expr = size_zero_node;
2614 step_expr = build_real (scalar_type, dconst0);
2616 /* Is phi in an inner-loop, while vectorizing an enclosing outer-loop? */
2617 if (nested_in_vect_loop_p (loop, iv_phi))
2619 nested_in_vect_loop = true;
2620 iv_loop = loop->inner;
2624 gcc_assert (iv_loop == (gimple_bb (iv_phi))->loop_father);
2626 latch_e = loop_latch_edge (iv_loop);
2627 loop_arg = PHI_ARG_DEF_FROM_EDGE (iv_phi, latch_e);
2629 access_fn = analyze_scalar_evolution (iv_loop, PHI_RESULT (iv_phi));
2630 gcc_assert (access_fn);
2631 ok = vect_is_simple_iv_evolution (iv_loop->num, access_fn,
2632 &init_expr, &step_expr);
2634 pe = loop_preheader_edge (iv_loop);
2636 /* Create the vector that holds the initial_value of the induction. */
2637 if (nested_in_vect_loop)
2639 /* iv_loop is nested in the loop to be vectorized. init_expr had already
2640 been created during vectorization of previous stmts; We obtain it from
2641 the STMT_VINFO_VEC_STMT of the defining stmt. */
2642 tree iv_def = PHI_ARG_DEF_FROM_EDGE (iv_phi,
2643 loop_preheader_edge (iv_loop));
2644 vec_init = vect_get_vec_def_for_operand (iv_def, iv_phi, NULL);
2648 /* iv_loop is the loop to be vectorized. Create:
2649 vec_init = [X, X+S, X+2*S, X+3*S] (S = step_expr, X = init_expr) */
2650 new_var = vect_get_new_vect_var (scalar_type, vect_scalar_var, "var_");
2651 add_referenced_var (new_var);
2653 new_name = force_gimple_operand (init_expr, &stmts, false, new_var);
2656 new_bb = gsi_insert_seq_on_edge_immediate (pe, stmts);
2657 gcc_assert (!new_bb);
2661 t = tree_cons (NULL_TREE, init_expr, t);
2662 for (i = 1; i < nunits; i++)
2664 /* Create: new_name_i = new_name + step_expr */
2665 enum tree_code code = POINTER_TYPE_P (scalar_type)
2666 ? POINTER_PLUS_EXPR : PLUS_EXPR;
2667 init_stmt = gimple_build_assign_with_ops (code, new_var,
2668 new_name, step_expr);
2669 new_name = make_ssa_name (new_var, init_stmt);
2670 gimple_assign_set_lhs (init_stmt, new_name);
2672 new_bb = gsi_insert_on_edge_immediate (pe, init_stmt);
2673 gcc_assert (!new_bb);
2675 if (vect_print_dump_info (REPORT_DETAILS))
2677 fprintf (vect_dump, "created new init_stmt: ");
2678 print_gimple_stmt (vect_dump, init_stmt, 0, TDF_SLIM);
2680 t = tree_cons (NULL_TREE, new_name, t);
2682 /* Create a vector from [new_name_0, new_name_1, ..., new_name_nunits-1] */
2683 vec = build_constructor_from_list (vectype, nreverse (t));
2684 vec_init = vect_init_vector (iv_phi, vec, vectype, NULL);
2688 /* Create the vector that holds the step of the induction. */
2689 if (nested_in_vect_loop)
2690 /* iv_loop is nested in the loop to be vectorized. Generate:
2691 vec_step = [S, S, S, S] */
2692 new_name = step_expr;
2695 /* iv_loop is the loop to be vectorized. Generate:
2696 vec_step = [VF*S, VF*S, VF*S, VF*S] */
2697 expr = build_int_cst (TREE_TYPE (step_expr), vf);
2698 new_name = fold_build2 (MULT_EXPR, TREE_TYPE (step_expr),
2703 for (i = 0; i < nunits; i++)
2704 t = tree_cons (NULL_TREE, unshare_expr (new_name), t);
2705 gcc_assert (CONSTANT_CLASS_P (new_name));
2706 stepvectype = get_vectype_for_scalar_type (TREE_TYPE (new_name));
2707 gcc_assert (stepvectype);
2708 vec = build_vector (stepvectype, t);
2709 vec_step = vect_init_vector (iv_phi, vec, stepvectype, NULL);
2712 /* Create the following def-use cycle:
2717 vec_iv = PHI <vec_init, vec_loop>
2721 vec_loop = vec_iv + vec_step; */
2723 /* Create the induction-phi that defines the induction-operand. */
2724 vec_dest = vect_get_new_vect_var (vectype, vect_simple_var, "vec_iv_");
2725 add_referenced_var (vec_dest);
2726 induction_phi = create_phi_node (vec_dest, iv_loop->header);
2727 set_vinfo_for_stmt (induction_phi,
2728 new_stmt_vec_info (induction_phi, loop_vinfo, NULL));
2729 induc_def = PHI_RESULT (induction_phi);
2731 /* Create the iv update inside the loop */
2732 new_stmt = gimple_build_assign_with_ops (PLUS_EXPR, vec_dest,
2733 induc_def, vec_step);
2734 vec_def = make_ssa_name (vec_dest, new_stmt);
2735 gimple_assign_set_lhs (new_stmt, vec_def);
2736 gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
2737 set_vinfo_for_stmt (new_stmt, new_stmt_vec_info (new_stmt, loop_vinfo,
2740 /* Set the arguments of the phi node: */
2741 add_phi_arg (induction_phi, vec_init, pe, UNKNOWN_LOCATION);
2742 add_phi_arg (induction_phi, vec_def, loop_latch_edge (iv_loop),
2746 /* In case that vectorization factor (VF) is bigger than the number
2747 of elements that we can fit in a vectype (nunits), we have to generate
2748 more than one vector stmt - i.e - we need to "unroll" the
2749 vector stmt by a factor VF/nunits. For more details see documentation
2750 in vectorizable_operation. */
2754 stmt_vec_info prev_stmt_vinfo;
2755 /* FORNOW. This restriction should be relaxed. */
2756 gcc_assert (!nested_in_vect_loop);
2758 /* Create the vector that holds the step of the induction. */
2759 expr = build_int_cst (TREE_TYPE (step_expr), nunits);
2760 new_name = fold_build2 (MULT_EXPR, TREE_TYPE (step_expr),
2763 for (i = 0; i < nunits; i++)
2764 t = tree_cons (NULL_TREE, unshare_expr (new_name), t);
2765 gcc_assert (CONSTANT_CLASS_P (new_name));
2766 vec = build_vector (stepvectype, t);
2767 vec_step = vect_init_vector (iv_phi, vec, stepvectype, NULL);
2769 vec_def = induc_def;
2770 prev_stmt_vinfo = vinfo_for_stmt (induction_phi);
2771 for (i = 1; i < ncopies; i++)
2773 /* vec_i = vec_prev + vec_step */
2774 new_stmt = gimple_build_assign_with_ops (PLUS_EXPR, vec_dest,
2776 vec_def = make_ssa_name (vec_dest, new_stmt);
2777 gimple_assign_set_lhs (new_stmt, vec_def);
2779 gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
2780 set_vinfo_for_stmt (new_stmt,
2781 new_stmt_vec_info (new_stmt, loop_vinfo, NULL));
2782 STMT_VINFO_RELATED_STMT (prev_stmt_vinfo) = new_stmt;
2783 prev_stmt_vinfo = vinfo_for_stmt (new_stmt);
2787 if (nested_in_vect_loop)
2789 /* Find the loop-closed exit-phi of the induction, and record
2790 the final vector of induction results: */
2792 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, loop_arg)
2794 if (!flow_bb_inside_loop_p (iv_loop, gimple_bb (USE_STMT (use_p))))
2796 exit_phi = USE_STMT (use_p);
2802 stmt_vec_info stmt_vinfo = vinfo_for_stmt (exit_phi);
2803 /* FORNOW. Currently not supporting the case that an inner-loop induction
2804 is not used in the outer-loop (i.e. only outside the outer-loop). */
2805 gcc_assert (STMT_VINFO_RELEVANT_P (stmt_vinfo)
2806 && !STMT_VINFO_LIVE_P (stmt_vinfo));
2808 STMT_VINFO_VEC_STMT (stmt_vinfo) = new_stmt;
2809 if (vect_print_dump_info (REPORT_DETAILS))
2811 fprintf (vect_dump, "vector of inductions after inner-loop:");
2812 print_gimple_stmt (vect_dump, new_stmt, 0, TDF_SLIM);
2818 if (vect_print_dump_info (REPORT_DETAILS))
2820 fprintf (vect_dump, "transform induction: created def-use cycle: ");
2821 print_gimple_stmt (vect_dump, induction_phi, 0, TDF_SLIM);
2822 fprintf (vect_dump, "\n");
2823 print_gimple_stmt (vect_dump, SSA_NAME_DEF_STMT (vec_def), 0, TDF_SLIM);
2826 STMT_VINFO_VEC_STMT (phi_info) = induction_phi;
2831 /* Function get_initial_def_for_reduction
2834 STMT - a stmt that performs a reduction operation in the loop.
2835 INIT_VAL - the initial value of the reduction variable
2838 ADJUSTMENT_DEF - a tree that holds a value to be added to the final result
2839 of the reduction (used for adjusting the epilog - see below).
2840 Return a vector variable, initialized according to the operation that STMT
2841 performs. This vector will be used as the initial value of the
2842 vector of partial results.
2844 Option1 (adjust in epilog): Initialize the vector as follows:
2845 add/bit or/xor: [0,0,...,0,0]
2846 mult/bit and: [1,1,...,1,1]
2847 min/max/cond_expr: [init_val,init_val,..,init_val,init_val]
2848 and when necessary (e.g. add/mult case) let the caller know
2849 that it needs to adjust the result by init_val.
2851 Option2: Initialize the vector as follows:
2852 add/bit or/xor: [init_val,0,0,...,0]
2853 mult/bit and: [init_val,1,1,...,1]
2854 min/max/cond_expr: [init_val,init_val,...,init_val]
2855 and no adjustments are needed.
2857 For example, for the following code:
2863 STMT is 's = s + a[i]', and the reduction variable is 's'.
2864 For a vector of 4 units, we want to return either [0,0,0,init_val],
2865 or [0,0,0,0] and let the caller know that it needs to adjust
2866 the result at the end by 'init_val'.
2868 FORNOW, we are using the 'adjust in epilog' scheme, because this way the
2869 initialization vector is simpler (same element in all entries), if
2870 ADJUSTMENT_DEF is not NULL, and Option2 otherwise.
2872 A cost model should help decide between these two schemes. */
2875 get_initial_def_for_reduction (gimple stmt, tree init_val,
2876 tree *adjustment_def)
2878 stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt);
2879 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
2880 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2881 tree scalar_type = TREE_TYPE (init_val);
2882 tree vectype = get_vectype_for_scalar_type (scalar_type);
2884 enum tree_code code = gimple_assign_rhs_code (stmt);
2889 bool nested_in_vect_loop = false;
2891 REAL_VALUE_TYPE real_init_val = dconst0;
2892 int int_init_val = 0;
2893 gimple def_stmt = NULL;
2895 gcc_assert (vectype);
2896 nunits = TYPE_VECTOR_SUBPARTS (vectype);
2898 gcc_assert (POINTER_TYPE_P (scalar_type) || INTEGRAL_TYPE_P (scalar_type)
2899 || SCALAR_FLOAT_TYPE_P (scalar_type));
2901 if (nested_in_vect_loop_p (loop, stmt))
2902 nested_in_vect_loop = true;
2904 gcc_assert (loop == (gimple_bb (stmt))->loop_father);
2906 /* In case of double reduction we only create a vector variable to be put
2907 in the reduction phi node. The actual statement creation is done in
2908 vect_create_epilog_for_reduction. */
2909 if (adjustment_def && nested_in_vect_loop
2910 && TREE_CODE (init_val) == SSA_NAME
2911 && (def_stmt = SSA_NAME_DEF_STMT (init_val))
2912 && gimple_code (def_stmt) == GIMPLE_PHI
2913 && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))
2914 && vinfo_for_stmt (def_stmt)
2915 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def_stmt))
2916 == vect_double_reduction_def)
2918 *adjustment_def = NULL;
2919 return vect_create_destination_var (init_val, vectype);
2922 if (TREE_CONSTANT (init_val))
2924 if (SCALAR_FLOAT_TYPE_P (scalar_type))
2925 init_value = build_real (scalar_type, TREE_REAL_CST (init_val));
2927 init_value = build_int_cst (scalar_type, TREE_INT_CST_LOW (init_val));
2930 init_value = init_val;
2934 case WIDEN_SUM_EXPR:
2942 /* ADJUSMENT_DEF is NULL when called from
2943 vect_create_epilog_for_reduction to vectorize double reduction. */
2946 if (nested_in_vect_loop)
2947 *adjustment_def = vect_get_vec_def_for_operand (init_val, stmt,
2950 *adjustment_def = init_val;
2953 if (code == MULT_EXPR)
2955 real_init_val = dconst1;
2959 if (code == BIT_AND_EXPR)
2962 if (SCALAR_FLOAT_TYPE_P (scalar_type))
2963 def_for_init = build_real (scalar_type, real_init_val);
2965 def_for_init = build_int_cst (scalar_type, int_init_val);
2967 /* Create a vector of '0' or '1' except the first element. */
2968 for (i = nunits - 2; i >= 0; --i)
2969 t = tree_cons (NULL_TREE, def_for_init, t);
2971 /* Option1: the first element is '0' or '1' as well. */
2974 t = tree_cons (NULL_TREE, def_for_init, t);
2975 init_def = build_vector (vectype, t);
2979 /* Option2: the first element is INIT_VAL. */
2980 t = tree_cons (NULL_TREE, init_value, t);
2981 if (TREE_CONSTANT (init_val))
2982 init_def = build_vector (vectype, t);
2984 init_def = build_constructor_from_list (vectype, t);
2993 *adjustment_def = NULL_TREE;
2994 init_def = vect_get_vec_def_for_operand (init_val, stmt, NULL);
2998 for (i = nunits - 1; i >= 0; --i)
2999 t = tree_cons (NULL_TREE, init_value, t);
3001 if (TREE_CONSTANT (init_val))
3002 init_def = build_vector (vectype, t);
3004 init_def = build_constructor_from_list (vectype, t);
3016 /* Function vect_create_epilog_for_reduction
3018 Create code at the loop-epilog to finalize the result of a reduction
3021 VECT_DEFS is list of vector of partial results, i.e., the lhs's of vector
3022 reduction statements.
3023 STMT is the scalar reduction stmt that is being vectorized.
3024 NCOPIES is > 1 in case the vectorization factor (VF) is bigger than the
3025 number of elements that we can fit in a vectype (nunits). In this case
3026 we have to generate more than one vector stmt - i.e - we need to "unroll"
3027 the vector stmt by a factor VF/nunits. For more details see documentation
3028 in vectorizable_operation.
3029 REDUC_CODE is the tree-code for the epilog reduction.
3030 REDUCTION_PHIS is a list of the phi-nodes that carry the reduction
3032 REDUC_INDEX is the index of the operand in the right hand side of the
3033 statement that is defined by REDUCTION_PHI.
3034 DOUBLE_REDUC is TRUE if double reduction phi nodes should be handled.
3035 SLP_NODE is an SLP node containing a group of reduction statements. The
3036 first one in this group is STMT.
3039 1. Creates the reduction def-use cycles: sets the arguments for
3041 The loop-entry argument is the vectorized initial-value of the reduction.
3042 The loop-latch argument is taken from VECT_DEFS - the vector of partial
3044 2. "Reduces" each vector of partial results VECT_DEFS into a single result,
3045 by applying the operation specified by REDUC_CODE if available, or by
3046 other means (whole-vector shifts or a scalar loop).
3047 The function also creates a new phi node at the loop exit to preserve
3048 loop-closed form, as illustrated below.
3050 The flow at the entry to this function:
3053 vec_def = phi <null, null> # REDUCTION_PHI
3054 VECT_DEF = vector_stmt # vectorized form of STMT
3055 s_loop = scalar_stmt # (scalar) STMT
3057 s_out0 = phi <s_loop> # (scalar) EXIT_PHI
3061 The above is transformed by this function into:
3064 vec_def = phi <vec_init, VECT_DEF> # REDUCTION_PHI
3065 VECT_DEF = vector_stmt # vectorized form of STMT
3066 s_loop = scalar_stmt # (scalar) STMT
3068 s_out0 = phi <s_loop> # (scalar) EXIT_PHI
3069 v_out1 = phi <VECT_DEF> # NEW_EXIT_PHI
3070 v_out2 = reduce <v_out1>
3071 s_out3 = extract_field <v_out2, 0>
3072 s_out4 = adjust_result <s_out3>
3078 vect_create_epilog_for_reduction (VEC (tree, heap) *vect_defs, gimple stmt,
3079 int ncopies, enum tree_code reduc_code,
3080 VEC (gimple, heap) *reduction_phis,
3081 int reduc_index, bool double_reduc,
3084 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
3085 stmt_vec_info prev_phi_info;
3087 enum machine_mode mode;
3088 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
3089 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo), *outer_loop = NULL;
3090 basic_block exit_bb;
3093 gimple new_phi = NULL, phi;
3094 gimple_stmt_iterator exit_gsi;
3096 tree new_temp = NULL_TREE, new_dest, new_name, new_scalar_dest;
3097 gimple epilog_stmt = NULL;
3098 enum tree_code code = gimple_assign_rhs_code (stmt);
3100 tree bitsize, bitpos;
3101 tree adjustment_def = NULL;
3102 tree vec_initial_def = NULL;
3103 tree reduction_op, expr, def;
3104 tree orig_name, scalar_result;
3105 imm_use_iterator imm_iter, phi_imm_iter;
3106 use_operand_p use_p, phi_use_p;
3107 bool extract_scalar_result = false;
3108 gimple use_stmt, orig_stmt, reduction_phi = NULL;
3109 bool nested_in_vect_loop = false;
3110 VEC (gimple, heap) *new_phis = NULL;
3111 enum vect_def_type dt = vect_unknown_def_type;
3113 VEC (tree, heap) *scalar_results = NULL;
3114 unsigned int group_size = 1, k, ratio;
3115 VEC (tree, heap) *vec_initial_defs = NULL;
3116 VEC (gimple, heap) *phis;
3119 group_size = VEC_length (gimple, SLP_TREE_SCALAR_STMTS (slp_node));
3121 if (nested_in_vect_loop_p (loop, stmt))
3125 nested_in_vect_loop = true;
3126 gcc_assert (!slp_node);
3129 switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
3131 case GIMPLE_SINGLE_RHS:
3132 gcc_assert (TREE_OPERAND_LENGTH (gimple_assign_rhs1 (stmt))
3134 reduction_op = TREE_OPERAND (gimple_assign_rhs1 (stmt), reduc_index);
3136 case GIMPLE_UNARY_RHS:
3137 reduction_op = gimple_assign_rhs1 (stmt);
3139 case GIMPLE_BINARY_RHS:
3140 reduction_op = reduc_index ?
3141 gimple_assign_rhs2 (stmt) : gimple_assign_rhs1 (stmt);
3147 vectype = get_vectype_for_scalar_type (TREE_TYPE (reduction_op));
3148 gcc_assert (vectype);
3149 mode = TYPE_MODE (vectype);
3151 /* 1. Create the reduction def-use cycle:
3152 Set the arguments of REDUCTION_PHIS, i.e., transform
3155 vec_def = phi <null, null> # REDUCTION_PHI
3156 VECT_DEF = vector_stmt # vectorized form of STMT
3162 vec_def = phi <vec_init, VECT_DEF> # REDUCTION_PHI
3163 VECT_DEF = vector_stmt # vectorized form of STMT
3166 (in case of SLP, do it for all the phis). */
3168 /* Get the loop-entry arguments. */
3170 vect_get_slp_defs (slp_node, &vec_initial_defs, NULL, reduc_index);
3173 vec_initial_defs = VEC_alloc (tree, heap, 1);
3174 /* For the case of reduction, vect_get_vec_def_for_operand returns
3175 the scalar def before the loop, that defines the initial value
3176 of the reduction variable. */
3177 vec_initial_def = vect_get_vec_def_for_operand (reduction_op, stmt,
3179 VEC_quick_push (tree, vec_initial_defs, vec_initial_def);
3182 /* Set phi nodes arguments. */
3183 FOR_EACH_VEC_ELT (gimple, reduction_phis, i, phi)
3185 tree vec_init_def = VEC_index (tree, vec_initial_defs, i);
3186 tree def = VEC_index (tree, vect_defs, i);
3187 for (j = 0; j < ncopies; j++)
3189 /* Set the loop-entry arg of the reduction-phi. */
3190 add_phi_arg (phi, vec_init_def, loop_preheader_edge (loop),
3193 /* Set the loop-latch arg for the reduction-phi. */
3195 def = vect_get_vec_def_for_stmt_copy (vect_unknown_def_type, def);
3197 add_phi_arg (phi, def, loop_latch_edge (loop), UNKNOWN_LOCATION);
3199 if (vect_print_dump_info (REPORT_DETAILS))
3201 fprintf (vect_dump, "transform reduction: created def-use"
3203 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
3204 fprintf (vect_dump, "\n");
3205 print_gimple_stmt (vect_dump, SSA_NAME_DEF_STMT (def), 0,
3209 phi = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (phi));
3213 VEC_free (tree, heap, vec_initial_defs);
3215 /* 2. Create epilog code.
3216 The reduction epilog code operates across the elements of the vector
3217 of partial results computed by the vectorized loop.
3218 The reduction epilog code consists of:
3220 step 1: compute the scalar result in a vector (v_out2)
3221 step 2: extract the scalar result (s_out3) from the vector (v_out2)
3222 step 3: adjust the scalar result (s_out3) if needed.
3224 Step 1 can be accomplished using one the following three schemes:
3225 (scheme 1) using reduc_code, if available.
3226 (scheme 2) using whole-vector shifts, if available.
3227 (scheme 3) using a scalar loop. In this case steps 1+2 above are
3230 The overall epilog code looks like this:
3232 s_out0 = phi <s_loop> # original EXIT_PHI
3233 v_out1 = phi <VECT_DEF> # NEW_EXIT_PHI
3234 v_out2 = reduce <v_out1> # step 1
3235 s_out3 = extract_field <v_out2, 0> # step 2
3236 s_out4 = adjust_result <s_out3> # step 3
3238 (step 3 is optional, and steps 1 and 2 may be combined).
3239 Lastly, the uses of s_out0 are replaced by s_out4. */
3242 /* 2.1 Create new loop-exit-phis to preserve loop-closed form:
3243 v_out1 = phi <VECT_DEF>
3244 Store them in NEW_PHIS. */
3246 exit_bb = single_exit (loop)->dest;
3247 prev_phi_info = NULL;
3248 new_phis = VEC_alloc (gimple, heap, VEC_length (tree, vect_defs));
3249 FOR_EACH_VEC_ELT (tree, vect_defs, i, def)
3251 for (j = 0; j < ncopies; j++)
3253 phi = create_phi_node (SSA_NAME_VAR (def), exit_bb);
3254 set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, loop_vinfo, NULL));
3256 VEC_quick_push (gimple, new_phis, phi);
3259 def = vect_get_vec_def_for_stmt_copy (dt, def);
3260 STMT_VINFO_RELATED_STMT (prev_phi_info) = phi;
3263 SET_PHI_ARG_DEF (phi, single_exit (loop)->dest_idx, def);
3264 prev_phi_info = vinfo_for_stmt (phi);
3268 /* The epilogue is created for the outer-loop, i.e., for the loop being
3273 exit_bb = single_exit (loop)->dest;
3276 exit_gsi = gsi_after_labels (exit_bb);
3278 /* 2.2 Get the relevant tree-code to use in the epilog for schemes 2,3
3279 (i.e. when reduc_code is not available) and in the final adjustment
3280 code (if needed). Also get the original scalar reduction variable as
3281 defined in the loop. In case STMT is a "pattern-stmt" (i.e. - it
3282 represents a reduction pattern), the tree-code and scalar-def are
3283 taken from the original stmt that the pattern-stmt (STMT) replaces.
3284 Otherwise (it is a regular reduction) - the tree-code and scalar-def
3285 are taken from STMT. */
3287 orig_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
3290 /* Regular reduction */
3295 /* Reduction pattern */
3296 stmt_vec_info stmt_vinfo = vinfo_for_stmt (orig_stmt);
3297 gcc_assert (STMT_VINFO_IN_PATTERN_P (stmt_vinfo));
3298 gcc_assert (STMT_VINFO_RELATED_STMT (stmt_vinfo) == stmt);
3301 code = gimple_assign_rhs_code (orig_stmt);
3302 /* For MINUS_EXPR the initial vector is [init_val,0,...,0], therefore,
3303 partial results are added and not subtracted. */
3304 if (code == MINUS_EXPR)
3307 scalar_dest = gimple_assign_lhs (orig_stmt);
3308 scalar_type = TREE_TYPE (scalar_dest);
3309 scalar_results = VEC_alloc (tree, heap, group_size);
3310 new_scalar_dest = vect_create_destination_var (scalar_dest, NULL);
3311 bitsize = TYPE_SIZE (scalar_type);
3313 /* In case this is a reduction in an inner-loop while vectorizing an outer
3314 loop - we don't need to extract a single scalar result at the end of the
3315 inner-loop (unless it is double reduction, i.e., the use of reduction is
3316 outside the outer-loop). The final vector of partial results will be used
3317 in the vectorized outer-loop, or reduced to a scalar result at the end of
3319 if (nested_in_vect_loop && !double_reduc)
3320 goto vect_finalize_reduction;
3322 /* 2.3 Create the reduction code, using one of the three schemes described
3323 above. In SLP we simply need to extract all the elements from the
3324 vector (without reducing them), so we use scalar shifts. */
3325 if (reduc_code != ERROR_MARK && !slp_node)
3329 /*** Case 1: Create:
3330 v_out2 = reduc_expr <v_out1> */
3332 if (vect_print_dump_info (REPORT_DETAILS))
3333 fprintf (vect_dump, "Reduce using direct vector reduction.");
3335 vec_dest = vect_create_destination_var (scalar_dest, vectype);
3336 new_phi = VEC_index (gimple, new_phis, 0);
3337 tmp = build1 (reduc_code, vectype, PHI_RESULT (new_phi));
3338 epilog_stmt = gimple_build_assign (vec_dest, tmp);
3339 new_temp = make_ssa_name (vec_dest, epilog_stmt);
3340 gimple_assign_set_lhs (epilog_stmt, new_temp);
3341 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3343 extract_scalar_result = true;
3347 enum tree_code shift_code = ERROR_MARK;
3348 bool have_whole_vector_shift = true;
3350 int element_bitsize = tree_low_cst (bitsize, 1);
3351 int vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1);
3354 if (optab_handler (vec_shr_optab, mode) != CODE_FOR_nothing)
3355 shift_code = VEC_RSHIFT_EXPR;
3357 have_whole_vector_shift = false;
3359 /* Regardless of whether we have a whole vector shift, if we're
3360 emulating the operation via tree-vect-generic, we don't want
3361 to use it. Only the first round of the reduction is likely
3362 to still be profitable via emulation. */
3363 /* ??? It might be better to emit a reduction tree code here, so that
3364 tree-vect-generic can expand the first round via bit tricks. */
3365 if (!VECTOR_MODE_P (mode))
3366 have_whole_vector_shift = false;
3369 optab optab = optab_for_tree_code (code, vectype, optab_default);
3370 if (optab_handler (optab, mode) == CODE_FOR_nothing)
3371 have_whole_vector_shift = false;
3374 if (have_whole_vector_shift && !slp_node)
3376 /*** Case 2: Create:
3377 for (offset = VS/2; offset >= element_size; offset/=2)
3379 Create: va' = vec_shift <va, offset>
3380 Create: va = vop <va, va'>
3383 if (vect_print_dump_info (REPORT_DETAILS))
3384 fprintf (vect_dump, "Reduce using vector shifts");
3386 vec_dest = vect_create_destination_var (scalar_dest, vectype);
3387 new_phi = VEC_index (gimple, new_phis, 0);
3388 new_temp = PHI_RESULT (new_phi);
3389 for (bit_offset = vec_size_in_bits/2;
3390 bit_offset >= element_bitsize;
3393 tree bitpos = size_int (bit_offset);
3395 epilog_stmt = gimple_build_assign_with_ops (shift_code,
3396 vec_dest, new_temp, bitpos);
3397 new_name = make_ssa_name (vec_dest, epilog_stmt);
3398 gimple_assign_set_lhs (epilog_stmt, new_name);
3399 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3401 epilog_stmt = gimple_build_assign_with_ops (code, vec_dest,
3402 new_name, new_temp);
3403 new_temp = make_ssa_name (vec_dest, epilog_stmt);
3404 gimple_assign_set_lhs (epilog_stmt, new_temp);
3405 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3408 extract_scalar_result = true;
3414 /*** Case 3: Create:
3415 s = extract_field <v_out2, 0>
3416 for (offset = element_size;
3417 offset < vector_size;
3418 offset += element_size;)
3420 Create: s' = extract_field <v_out2, offset>
3421 Create: s = op <s, s'> // For non SLP cases
3424 if (vect_print_dump_info (REPORT_DETAILS))
3425 fprintf (vect_dump, "Reduce using scalar code. ");
3427 vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1);
3428 FOR_EACH_VEC_ELT (gimple, new_phis, i, new_phi)
3430 vec_temp = PHI_RESULT (new_phi);
3431 rhs = build3 (BIT_FIELD_REF, scalar_type, vec_temp, bitsize,
3433 epilog_stmt = gimple_build_assign (new_scalar_dest, rhs);
3434 new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
3435 gimple_assign_set_lhs (epilog_stmt, new_temp);
3436 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3438 /* In SLP we don't need to apply reduction operation, so we just
3439 collect s' values in SCALAR_RESULTS. */
3441 VEC_safe_push (tree, heap, scalar_results, new_temp);
3443 for (bit_offset = element_bitsize;
3444 bit_offset < vec_size_in_bits;
3445 bit_offset += element_bitsize)
3447 tree bitpos = bitsize_int (bit_offset);
3448 tree rhs = build3 (BIT_FIELD_REF, scalar_type, vec_temp,
3451 epilog_stmt = gimple_build_assign (new_scalar_dest, rhs);
3452 new_name = make_ssa_name (new_scalar_dest, epilog_stmt);
3453 gimple_assign_set_lhs (epilog_stmt, new_name);
3454 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3458 /* In SLP we don't need to apply reduction operation, so
3459 we just collect s' values in SCALAR_RESULTS. */
3460 new_temp = new_name;
3461 VEC_safe_push (tree, heap, scalar_results, new_name);
3465 epilog_stmt = gimple_build_assign_with_ops (code,
3466 new_scalar_dest, new_name, new_temp);
3467 new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
3468 gimple_assign_set_lhs (epilog_stmt, new_temp);
3469 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3474 /* The only case where we need to reduce scalar results in SLP, is
3475 unrolling. If the size of SCALAR_RESULTS is greater than
3476 GROUP_SIZE, we reduce them combining elements modulo
3480 tree res, first_res, new_res;
3483 /* Reduce multiple scalar results in case of SLP unrolling. */
3484 for (j = group_size; VEC_iterate (tree, scalar_results, j, res);
3487 first_res = VEC_index (tree, scalar_results, j % group_size);
3488 new_stmt = gimple_build_assign_with_ops (code,
3489 new_scalar_dest, first_res, res);
3490 new_res = make_ssa_name (new_scalar_dest, new_stmt);
3491 gimple_assign_set_lhs (new_stmt, new_res);
3492 gsi_insert_before (&exit_gsi, new_stmt, GSI_SAME_STMT);
3493 VEC_replace (tree, scalar_results, j % group_size, new_res);
3497 /* Not SLP - we have one scalar to keep in SCALAR_RESULTS. */
3498 VEC_safe_push (tree, heap, scalar_results, new_temp);
3500 extract_scalar_result = false;
3504 /* 2.4 Extract the final scalar result. Create:
3505 s_out3 = extract_field <v_out2, bitpos> */
3507 if (extract_scalar_result)
3511 if (vect_print_dump_info (REPORT_DETAILS))
3512 fprintf (vect_dump, "extract scalar result");
3514 if (BYTES_BIG_ENDIAN)
3515 bitpos = size_binop (MULT_EXPR,
3516 bitsize_int (TYPE_VECTOR_SUBPARTS (vectype) - 1),
3517 TYPE_SIZE (scalar_type));
3519 bitpos = bitsize_zero_node;
3521 rhs = build3 (BIT_FIELD_REF, scalar_type, new_temp, bitsize, bitpos);
3522 epilog_stmt = gimple_build_assign (new_scalar_dest, rhs);
3523 new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
3524 gimple_assign_set_lhs (epilog_stmt, new_temp);
3525 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3526 VEC_safe_push (tree, heap, scalar_results, new_temp);
3529 vect_finalize_reduction:
3534 /* 2.5 Adjust the final result by the initial value of the reduction
3535 variable. (When such adjustment is not needed, then
3536 'adjustment_def' is zero). For example, if code is PLUS we create:
3537 new_temp = loop_exit_def + adjustment_def */
3541 gcc_assert (!slp_node);
3542 if (nested_in_vect_loop)
3544 new_phi = VEC_index (gimple, new_phis, 0);
3545 gcc_assert (TREE_CODE (TREE_TYPE (adjustment_def)) == VECTOR_TYPE);
3546 expr = build2 (code, vectype, PHI_RESULT (new_phi), adjustment_def);
3547 new_dest = vect_create_destination_var (scalar_dest, vectype);
3551 new_temp = VEC_index (tree, scalar_results, 0);
3552 gcc_assert (TREE_CODE (TREE_TYPE (adjustment_def)) != VECTOR_TYPE);
3553 expr = build2 (code, scalar_type, new_temp, adjustment_def);
3554 new_dest = vect_create_destination_var (scalar_dest, scalar_type);
3557 epilog_stmt = gimple_build_assign (new_dest, expr);
3558 new_temp = make_ssa_name (new_dest, epilog_stmt);
3559 gimple_assign_set_lhs (epilog_stmt, new_temp);
3560 SSA_NAME_DEF_STMT (new_temp) = epilog_stmt;
3561 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3562 if (nested_in_vect_loop)
3564 set_vinfo_for_stmt (epilog_stmt,
3565 new_stmt_vec_info (epilog_stmt, loop_vinfo,
3567 STMT_VINFO_RELATED_STMT (vinfo_for_stmt (epilog_stmt)) =
3568 STMT_VINFO_RELATED_STMT (vinfo_for_stmt (new_phi));
3571 VEC_quick_push (tree, scalar_results, new_temp);
3573 VEC_replace (tree, scalar_results, 0, new_temp);
3576 VEC_replace (tree, scalar_results, 0, new_temp);
3578 VEC_replace (gimple, new_phis, 0, epilog_stmt);
3581 /* 2.6 Handle the loop-exit phis. Replace the uses of scalar loop-exit
3582 phis with new adjusted scalar results, i.e., replace use <s_out0>
3587 s_out0 = phi <s_loop> # (scalar) EXIT_PHI
3588 v_out1 = phi <VECT_DEF> # NEW_EXIT_PHI
3589 v_out2 = reduce <v_out1>
3590 s_out3 = extract_field <v_out2, 0>
3591 s_out4 = adjust_result <s_out3>
3598 s_out0 = phi <s_loop> # (scalar) EXIT_PHI
3599 v_out1 = phi <VECT_DEF> # NEW_EXIT_PHI
3600 v_out2 = reduce <v_out1>
3601 s_out3 = extract_field <v_out2, 0>
3602 s_out4 = adjust_result <s_out3>
3606 /* In SLP we may have several statements in NEW_PHIS and REDUCTION_PHIS (in
3607 case that GROUP_SIZE is greater than vectorization factor). Therefore, we
3608 need to match SCALAR_RESULTS with corresponding statements. The first
3609 (GROUP_SIZE / number of new vector stmts) scalar results correspond to
3610 the first vector stmt, etc.
3611 (RATIO is equal to (GROUP_SIZE / number of new vector stmts)). */
3612 if (group_size > VEC_length (gimple, new_phis))
3614 ratio = group_size / VEC_length (gimple, new_phis);
3615 gcc_assert (!(group_size % VEC_length (gimple, new_phis)));
3620 for (k = 0; k < group_size; k++)
3624 epilog_stmt = VEC_index (gimple, new_phis, k / ratio);
3625 reduction_phi = VEC_index (gimple, reduction_phis, k / ratio);
3630 gimple current_stmt = VEC_index (gimple,
3631 SLP_TREE_SCALAR_STMTS (slp_node), k);
3633 orig_stmt = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (current_stmt));
3634 /* SLP statements can't participate in patterns. */
3635 gcc_assert (!orig_stmt);
3636 scalar_dest = gimple_assign_lhs (current_stmt);
3639 phis = VEC_alloc (gimple, heap, 3);
3640 /* Find the loop-closed-use at the loop exit of the original scalar
3641 result. (The reduction result is expected to have two immediate uses -
3642 one at the latch block, and one at the loop exit). */
3643 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, scalar_dest)
3644 if (!flow_bb_inside_loop_p (loop, gimple_bb (USE_STMT (use_p))))
3645 VEC_safe_push (gimple, heap, phis, USE_STMT (use_p));
3647 /* We expect to have found an exit_phi because of loop-closed-ssa
3649 gcc_assert (!VEC_empty (gimple, phis));
3651 FOR_EACH_VEC_ELT (gimple, phis, i, exit_phi)
3655 stmt_vec_info exit_phi_vinfo = vinfo_for_stmt (exit_phi);
3658 /* FORNOW. Currently not supporting the case that an inner-loop
3659 reduction is not used in the outer-loop (but only outside the
3660 outer-loop), unless it is double reduction. */
3661 gcc_assert ((STMT_VINFO_RELEVANT_P (exit_phi_vinfo)
3662 && !STMT_VINFO_LIVE_P (exit_phi_vinfo))
3665 STMT_VINFO_VEC_STMT (exit_phi_vinfo) = epilog_stmt;
3667 || STMT_VINFO_DEF_TYPE (exit_phi_vinfo)
3668 != vect_double_reduction_def)
3671 /* Handle double reduction:
3673 stmt1: s1 = phi <s0, s2> - double reduction phi (outer loop)
3674 stmt2: s3 = phi <s1, s4> - (regular) reduc phi (inner loop)
3675 stmt3: s4 = use (s3) - (regular) reduc stmt (inner loop)
3676 stmt4: s2 = phi <s4> - double reduction stmt (outer loop)
3678 At that point the regular reduction (stmt2 and stmt3) is
3679 already vectorized, as well as the exit phi node, stmt4.
3680 Here we vectorize the phi node of double reduction, stmt1, and
3681 update all relevant statements. */
3683 /* Go through all the uses of s2 to find double reduction phi
3684 node, i.e., stmt1 above. */
3685 orig_name = PHI_RESULT (exit_phi);
3686 FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, orig_name)
3688 stmt_vec_info use_stmt_vinfo = vinfo_for_stmt (use_stmt);
3689 stmt_vec_info new_phi_vinfo;
3690 tree vect_phi_init, preheader_arg, vect_phi_res, init_def;
3691 basic_block bb = gimple_bb (use_stmt);
3694 /* Check that USE_STMT is really double reduction phi
3696 if (gimple_code (use_stmt) != GIMPLE_PHI
3697 || gimple_phi_num_args (use_stmt) != 2
3699 || STMT_VINFO_DEF_TYPE (use_stmt_vinfo)
3700 != vect_double_reduction_def
3701 || bb->loop_father != outer_loop)
3704 /* Create vector phi node for double reduction:
3705 vs1 = phi <vs0, vs2>
3706 vs1 was created previously in this function by a call to
3707 vect_get_vec_def_for_operand and is stored in
3709 vs2 is defined by EPILOG_STMT, the vectorized EXIT_PHI;
3710 vs0 is created here. */
3712 /* Create vector phi node. */
3713 vect_phi = create_phi_node (vec_initial_def, bb);
3714 new_phi_vinfo = new_stmt_vec_info (vect_phi,
3715 loop_vec_info_for_loop (outer_loop), NULL);
3716 set_vinfo_for_stmt (vect_phi, new_phi_vinfo);
3718 /* Create vs0 - initial def of the double reduction phi. */
3719 preheader_arg = PHI_ARG_DEF_FROM_EDGE (use_stmt,
3720 loop_preheader_edge (outer_loop));
3721 init_def = get_initial_def_for_reduction (stmt,
3722 preheader_arg, NULL);
3723 vect_phi_init = vect_init_vector (use_stmt, init_def,
3726 /* Update phi node arguments with vs0 and vs2. */
3727 add_phi_arg (vect_phi, vect_phi_init,
3728 loop_preheader_edge (outer_loop),
3730 add_phi_arg (vect_phi, PHI_RESULT (epilog_stmt),
3731 loop_latch_edge (outer_loop), UNKNOWN_LOCATION);
3732 if (vect_print_dump_info (REPORT_DETAILS))
3734 fprintf (vect_dump, "created double reduction phi "
3736 print_gimple_stmt (vect_dump, vect_phi, 0, TDF_SLIM);
3739 vect_phi_res = PHI_RESULT (vect_phi);
3741 /* Replace the use, i.e., set the correct vs1 in the regular
3742 reduction phi node. FORNOW, NCOPIES is always 1, so the
3743 loop is redundant. */
3744 use = reduction_phi;
3745 for (j = 0; j < ncopies; j++)
3747 edge pr_edge = loop_preheader_edge (loop);
3748 SET_PHI_ARG_DEF (use, pr_edge->dest_idx, vect_phi_res);
3749 use = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (use));
3755 VEC_free (gimple, heap, phis);
3756 if (nested_in_vect_loop)
3764 phis = VEC_alloc (gimple, heap, 3);
3765 /* Find the loop-closed-use at the loop exit of the original scalar
3766 result. (The reduction result is expected to have two immediate uses -
3767 one at the latch block, and one at the loop exit). For double
3768 reductions we are looking for exit phis of the outer loop. */
3769 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, scalar_dest)
3771 if (!flow_bb_inside_loop_p (loop, gimple_bb (USE_STMT (use_p))))
3772 VEC_safe_push (gimple, heap, phis, USE_STMT (use_p));
3775 if (double_reduc && gimple_code (USE_STMT (use_p)) == GIMPLE_PHI)
3777 tree phi_res = PHI_RESULT (USE_STMT (use_p));
3779 FOR_EACH_IMM_USE_FAST (phi_use_p, phi_imm_iter, phi_res)
3781 if (!flow_bb_inside_loop_p (loop,
3782 gimple_bb (USE_STMT (phi_use_p))))
3783 VEC_safe_push (gimple, heap, phis,
3784 USE_STMT (phi_use_p));
3790 FOR_EACH_VEC_ELT (gimple, phis, i, exit_phi)
3792 /* Replace the uses: */
3793 orig_name = PHI_RESULT (exit_phi);
3794 scalar_result = VEC_index (tree, scalar_results, k);
3795 FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, orig_name)
3796 FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
3797 SET_USE (use_p, scalar_result);
3800 VEC_free (gimple, heap, phis);
3803 VEC_free (tree, heap, scalar_results);
3804 VEC_free (gimple, heap, new_phis);
3808 /* Function vectorizable_reduction.
3810 Check if STMT performs a reduction operation that can be vectorized.
3811 If VEC_STMT is also passed, vectorize the STMT: create a vectorized
3812 stmt to replace it, put it in VEC_STMT, and insert it at GSI.
3813 Return FALSE if not a vectorizable STMT, TRUE otherwise.
3815 This function also handles reduction idioms (patterns) that have been
3816 recognized in advance during vect_pattern_recog. In this case, STMT may be
3818 X = pattern_expr (arg0, arg1, ..., X)
3819 and it's STMT_VINFO_RELATED_STMT points to the last stmt in the original
3820 sequence that had been detected and replaced by the pattern-stmt (STMT).
3822 In some cases of reduction patterns, the type of the reduction variable X is
3823 different than the type of the other arguments of STMT.
3824 In such cases, the vectype that is used when transforming STMT into a vector
3825 stmt is different than the vectype that is used to determine the
3826 vectorization factor, because it consists of a different number of elements
3827 than the actual number of elements that are being operated upon in parallel.
3829 For example, consider an accumulation of shorts into an int accumulator.
3830 On some targets it's possible to vectorize this pattern operating on 8
3831 shorts at a time (hence, the vectype for purposes of determining the
3832 vectorization factor should be V8HI); on the other hand, the vectype that
3833 is used to create the vector form is actually V4SI (the type of the result).
3835 Upon entry to this function, STMT_VINFO_VECTYPE records the vectype that
3836 indicates what is the actual level of parallelism (V8HI in the example), so
3837 that the right vectorization factor would be derived. This vectype
3838 corresponds to the type of arguments to the reduction stmt, and should *NOT*
3839 be used to create the vectorized stmt. The right vectype for the vectorized
3840 stmt is obtained from the type of the result X:
3841 get_vectype_for_scalar_type (TREE_TYPE (X))
3843 This means that, contrary to "regular" reductions (or "regular" stmts in
3844 general), the following equation:
3845 STMT_VINFO_VECTYPE == get_vectype_for_scalar_type (TREE_TYPE (X))
3846 does *NOT* necessarily hold for reduction patterns. */
3849 vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
3850 gimple *vec_stmt, slp_tree slp_node)
3854 tree loop_vec_def0 = NULL_TREE, loop_vec_def1 = NULL_TREE;
3855 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
3856 tree vectype_out = STMT_VINFO_VECTYPE (stmt_info);
3857 tree vectype_in = NULL_TREE;
3858 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
3859 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
3860 enum tree_code code, orig_code, epilog_reduc_code;
3861 enum machine_mode vec_mode;
3863 optab optab, reduc_optab;
3864 tree new_temp = NULL_TREE;
3867 enum vect_def_type dt;
3868 gimple new_phi = NULL;
3872 stmt_vec_info orig_stmt_info;
3873 tree expr = NULL_TREE;
3877 stmt_vec_info prev_stmt_info, prev_phi_info;
3878 bool single_defuse_cycle = false;
3879 tree reduc_def = NULL_TREE;
3880 gimple new_stmt = NULL;
3883 bool nested_cycle = false, found_nested_cycle_def = false;
3884 gimple reduc_def_stmt = NULL;
3885 /* The default is that the reduction variable is the last in statement. */
3886 int reduc_index = 2;
3887 bool double_reduc = false, dummy;
3889 struct loop * def_stmt_loop, *outer_loop = NULL;
3891 gimple def_arg_stmt;
3892 VEC (tree, heap) *vec_oprnds0 = NULL, *vec_oprnds1 = NULL, *vect_defs = NULL;
3893 VEC (gimple, heap) *phis = NULL;
3897 if (nested_in_vect_loop_p (loop, stmt))
3901 nested_cycle = true;
3904 /* 1. Is vectorizable reduction? */
3905 /* Not supportable if the reduction variable is used in the loop. */
3906 if (STMT_VINFO_RELEVANT (stmt_info) > vect_used_in_outer)
3909 /* Reductions that are not used even in an enclosing outer-loop,
3910 are expected to be "live" (used out of the loop). */
3911 if (STMT_VINFO_RELEVANT (stmt_info) == vect_unused_in_scope
3912 && !STMT_VINFO_LIVE_P (stmt_info))
3915 /* Make sure it was already recognized as a reduction computation. */
3916 if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_reduction_def
3917 && STMT_VINFO_DEF_TYPE (stmt_info) != vect_nested_cycle)
3920 /* 2. Has this been recognized as a reduction pattern?
3922 Check if STMT represents a pattern that has been recognized
3923 in earlier analysis stages. For stmts that represent a pattern,
3924 the STMT_VINFO_RELATED_STMT field records the last stmt in
3925 the original sequence that constitutes the pattern. */
3927 orig_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
3930 orig_stmt_info = vinfo_for_stmt (orig_stmt);
3931 gcc_assert (STMT_VINFO_RELATED_STMT (orig_stmt_info) == stmt);
3932 gcc_assert (STMT_VINFO_IN_PATTERN_P (orig_stmt_info));
3933 gcc_assert (!STMT_VINFO_IN_PATTERN_P (stmt_info));
3936 /* 3. Check the operands of the operation. The first operands are defined
3937 inside the loop body. The last operand is the reduction variable,
3938 which is defined by the loop-header-phi. */
3940 gcc_assert (is_gimple_assign (stmt));
3943 switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
3945 case GIMPLE_SINGLE_RHS:
3946 op_type = TREE_OPERAND_LENGTH (gimple_assign_rhs1 (stmt));
3947 if (op_type == ternary_op)
3949 tree rhs = gimple_assign_rhs1 (stmt);
3950 ops[0] = TREE_OPERAND (rhs, 0);
3951 ops[1] = TREE_OPERAND (rhs, 1);
3952 ops[2] = TREE_OPERAND (rhs, 2);
3953 code = TREE_CODE (rhs);
3959 case GIMPLE_BINARY_RHS:
3960 code = gimple_assign_rhs_code (stmt);
3961 op_type = TREE_CODE_LENGTH (code);
3962 gcc_assert (op_type == binary_op);
3963 ops[0] = gimple_assign_rhs1 (stmt);
3964 ops[1] = gimple_assign_rhs2 (stmt);
3967 case GIMPLE_UNARY_RHS:
3974 scalar_dest = gimple_assign_lhs (stmt);
3975 scalar_type = TREE_TYPE (scalar_dest);
3976 if (!POINTER_TYPE_P (scalar_type) && !INTEGRAL_TYPE_P (scalar_type)
3977 && !SCALAR_FLOAT_TYPE_P (scalar_type))
3980 /* All uses but the last are expected to be defined in the loop.
3981 The last use is the reduction variable. In case of nested cycle this
3982 assumption is not true: we use reduc_index to record the index of the
3983 reduction variable. */
3984 for (i = 0; i < op_type-1; i++)
3988 /* The condition of COND_EXPR is checked in vectorizable_condition(). */
3989 if (i == 0 && code == COND_EXPR)
3992 is_simple_use = vect_is_simple_use_1 (ops[i], loop_vinfo, NULL,
3993 &def_stmt, &def, &dt, &tem);
3996 gcc_assert (is_simple_use);
3997 if (dt != vect_internal_def
3998 && dt != vect_external_def
3999 && dt != vect_constant_def
4000 && dt != vect_induction_def
4001 && !(dt == vect_nested_cycle && nested_cycle))
4004 if (dt == vect_nested_cycle)
4006 found_nested_cycle_def = true;
4007 reduc_def_stmt = def_stmt;
4012 is_simple_use = vect_is_simple_use (ops[i], loop_vinfo, NULL, &def_stmt,
4014 gcc_assert (is_simple_use);
4015 gcc_assert (dt == vect_reduction_def
4016 || dt == vect_nested_cycle
4017 || ((dt == vect_internal_def || dt == vect_external_def
4018 || dt == vect_constant_def || dt == vect_induction_def)
4019 && nested_cycle && found_nested_cycle_def));
4020 if (!found_nested_cycle_def)
4021 reduc_def_stmt = def_stmt;
4023 gcc_assert (gimple_code (reduc_def_stmt) == GIMPLE_PHI);
4025 gcc_assert (orig_stmt == vect_is_simple_reduction (loop_vinfo,
4030 gcc_assert (stmt == vect_is_simple_reduction (loop_vinfo, reduc_def_stmt,
4031 !nested_cycle, &dummy));
4033 if (STMT_VINFO_LIVE_P (vinfo_for_stmt (reduc_def_stmt)))
4039 ncopies = (LOOP_VINFO_VECT_FACTOR (loop_vinfo)
4040 / TYPE_VECTOR_SUBPARTS (vectype_in));
4042 gcc_assert (ncopies >= 1);
4044 vec_mode = TYPE_MODE (vectype_in);
4046 if (code == COND_EXPR)
4048 if (!vectorizable_condition (stmt, gsi, NULL, ops[reduc_index], 0))
4050 if (vect_print_dump_info (REPORT_DETAILS))
4051 fprintf (vect_dump, "unsupported condition in reduction");
4058 /* 4. Supportable by target? */
4060 /* 4.1. check support for the operation in the loop */
4061 optab = optab_for_tree_code (code, vectype_in, optab_default);
4064 if (vect_print_dump_info (REPORT_DETAILS))
4065 fprintf (vect_dump, "no optab.");
4070 if (optab_handler (optab, vec_mode) == CODE_FOR_nothing)
4072 if (vect_print_dump_info (REPORT_DETAILS))
4073 fprintf (vect_dump, "op not supported by target.");
4075 if (GET_MODE_SIZE (vec_mode) != UNITS_PER_WORD
4076 || LOOP_VINFO_VECT_FACTOR (loop_vinfo)
4077 < vect_min_worthwhile_factor (code))
4080 if (vect_print_dump_info (REPORT_DETAILS))
4081 fprintf (vect_dump, "proceeding using word mode.");
4084 /* Worthwhile without SIMD support? */
4085 if (!VECTOR_MODE_P (TYPE_MODE (vectype_in))
4086 && LOOP_VINFO_VECT_FACTOR (loop_vinfo)
4087 < vect_min_worthwhile_factor (code))
4089 if (vect_print_dump_info (REPORT_DETAILS))
4090 fprintf (vect_dump, "not worthwhile without SIMD support.");
4096 /* 4.2. Check support for the epilog operation.
4098 If STMT represents a reduction pattern, then the type of the
4099 reduction variable may be different than the type of the rest
4100 of the arguments. For example, consider the case of accumulation
4101 of shorts into an int accumulator; The original code:
4102 S1: int_a = (int) short_a;
4103 orig_stmt-> S2: int_acc = plus <int_a ,int_acc>;
4106 STMT: int_acc = widen_sum <short_a, int_acc>
4109 1. The tree-code that is used to create the vector operation in the
4110 epilog code (that reduces the partial results) is not the
4111 tree-code of STMT, but is rather the tree-code of the original
4112 stmt from the pattern that STMT is replacing. I.e, in the example
4113 above we want to use 'widen_sum' in the loop, but 'plus' in the
4115 2. The type (mode) we use to check available target support
4116 for the vector operation to be created in the *epilog*, is
4117 determined by the type of the reduction variable (in the example
4118 above we'd check this: optab_handler (plus_optab, vect_int_mode])).
4119 However the type (mode) we use to check available target support
4120 for the vector operation to be created *inside the loop*, is
4121 determined by the type of the other arguments to STMT (in the
4122 example we'd check this: optab_handler (widen_sum_optab,
4125 This is contrary to "regular" reductions, in which the types of all
4126 the arguments are the same as the type of the reduction variable.
4127 For "regular" reductions we can therefore use the same vector type
4128 (and also the same tree-code) when generating the epilog code and
4129 when generating the code inside the loop. */
4133 /* This is a reduction pattern: get the vectype from the type of the
4134 reduction variable, and get the tree-code from orig_stmt. */
4135 orig_code = gimple_assign_rhs_code (orig_stmt);
4136 gcc_assert (vectype_out);
4137 vec_mode = TYPE_MODE (vectype_out);
4141 /* Regular reduction: use the same vectype and tree-code as used for
4142 the vector code inside the loop can be used for the epilog code. */
4148 def_bb = gimple_bb (reduc_def_stmt);
4149 def_stmt_loop = def_bb->loop_father;
4150 def_arg = PHI_ARG_DEF_FROM_EDGE (reduc_def_stmt,
4151 loop_preheader_edge (def_stmt_loop));
4152 if (TREE_CODE (def_arg) == SSA_NAME
4153 && (def_arg_stmt = SSA_NAME_DEF_STMT (def_arg))
4154 && gimple_code (def_arg_stmt) == GIMPLE_PHI
4155 && flow_bb_inside_loop_p (outer_loop, gimple_bb (def_arg_stmt))
4156 && vinfo_for_stmt (def_arg_stmt)
4157 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def_arg_stmt))
4158 == vect_double_reduction_def)
4159 double_reduc = true;
4162 epilog_reduc_code = ERROR_MARK;
4163 if (reduction_code_for_scalar_code (orig_code, &epilog_reduc_code))
4165 reduc_optab = optab_for_tree_code (epilog_reduc_code, vectype_out,
4169 if (vect_print_dump_info (REPORT_DETAILS))
4170 fprintf (vect_dump, "no optab for reduction.");
4172 epilog_reduc_code = ERROR_MARK;
4176 && optab_handler (reduc_optab, vec_mode) == CODE_FOR_nothing)
4178 if (vect_print_dump_info (REPORT_DETAILS))
4179 fprintf (vect_dump, "reduc op not supported by target.");
4181 epilog_reduc_code = ERROR_MARK;
4186 if (!nested_cycle || double_reduc)
4188 if (vect_print_dump_info (REPORT_DETAILS))
4189 fprintf (vect_dump, "no reduc code for scalar code.");
4195 if (double_reduc && ncopies > 1)
4197 if (vect_print_dump_info (REPORT_DETAILS))
4198 fprintf (vect_dump, "multiple types in double reduction");
4203 if (!vec_stmt) /* transformation not required. */
4205 STMT_VINFO_TYPE (stmt_info) = reduc_vec_info_type;
4206 if (!vect_model_reduction_cost (stmt_info, epilog_reduc_code, ncopies))
4213 if (vect_print_dump_info (REPORT_DETAILS))
4214 fprintf (vect_dump, "transform reduction.");
4216 /* FORNOW: Multiple types are not supported for condition. */
4217 if (code == COND_EXPR)
4218 gcc_assert (ncopies == 1);
4220 /* Create the destination vector */
4221 vec_dest = vect_create_destination_var (scalar_dest, vectype_out);
4223 /* In case the vectorization factor (VF) is bigger than the number
4224 of elements that we can fit in a vectype (nunits), we have to generate
4225 more than one vector stmt - i.e - we need to "unroll" the
4226 vector stmt by a factor VF/nunits. For more details see documentation
4227 in vectorizable_operation. */
4229 /* If the reduction is used in an outer loop we need to generate
4230 VF intermediate results, like so (e.g. for ncopies=2):
4235 (i.e. we generate VF results in 2 registers).
4236 In this case we have a separate def-use cycle for each copy, and therefore
4237 for each copy we get the vector def for the reduction variable from the
4238 respective phi node created for this copy.
4240 Otherwise (the reduction is unused in the loop nest), we can combine
4241 together intermediate results, like so (e.g. for ncopies=2):
4245 (i.e. we generate VF/2 results in a single register).
4246 In this case for each copy we get the vector def for the reduction variable
4247 from the vectorized reduction operation generated in the previous iteration.
4250 if (STMT_VINFO_RELEVANT (stmt_info) == vect_unused_in_scope)
4252 single_defuse_cycle = true;
4256 epilog_copies = ncopies;
4258 prev_stmt_info = NULL;
4259 prev_phi_info = NULL;
4262 vec_num = SLP_TREE_NUMBER_OF_VEC_STMTS (slp_node);
4263 gcc_assert (TYPE_VECTOR_SUBPARTS (vectype_out)
4264 == TYPE_VECTOR_SUBPARTS (vectype_in));
4269 vec_oprnds0 = VEC_alloc (tree, heap, 1);
4270 if (op_type == ternary_op)
4271 vec_oprnds1 = VEC_alloc (tree, heap, 1);
4274 phis = VEC_alloc (gimple, heap, vec_num);
4275 vect_defs = VEC_alloc (tree, heap, vec_num);
4277 VEC_quick_push (tree, vect_defs, NULL_TREE);
4279 for (j = 0; j < ncopies; j++)
4281 if (j == 0 || !single_defuse_cycle)
4283 for (i = 0; i < vec_num; i++)
4285 /* Create the reduction-phi that defines the reduction
4287 new_phi = create_phi_node (vec_dest, loop->header);
4288 set_vinfo_for_stmt (new_phi,
4289 new_stmt_vec_info (new_phi, loop_vinfo,
4291 if (j == 0 || slp_node)
4292 VEC_quick_push (gimple, phis, new_phi);
4296 if (code == COND_EXPR)
4298 gcc_assert (!slp_node);
4299 vectorizable_condition (stmt, gsi, vec_stmt,
4300 PHI_RESULT (VEC_index (gimple, phis, 0)),
4302 /* Multiple types are not supported for condition. */
4310 vect_get_slp_defs (slp_node, &vec_oprnds0, &vec_oprnds1, -1);
4313 loop_vec_def0 = vect_get_vec_def_for_operand (ops[!reduc_index],
4315 VEC_quick_push (tree, vec_oprnds0, loop_vec_def0);
4316 if (op_type == ternary_op)
4318 if (reduc_index == 0)
4319 loop_vec_def1 = vect_get_vec_def_for_operand (ops[2], stmt,
4322 loop_vec_def1 = vect_get_vec_def_for_operand (ops[1], stmt,
4325 VEC_quick_push (tree, vec_oprnds1, loop_vec_def1);
4333 enum vect_def_type dt = vect_unknown_def_type; /* Dummy */
4334 loop_vec_def0 = vect_get_vec_def_for_stmt_copy (dt, loop_vec_def0);
4335 VEC_replace (tree, vec_oprnds0, 0, loop_vec_def0);
4336 if (op_type == ternary_op)
4338 loop_vec_def1 = vect_get_vec_def_for_stmt_copy (dt,
4340 VEC_replace (tree, vec_oprnds1, 0, loop_vec_def1);
4344 if (single_defuse_cycle)
4345 reduc_def = gimple_assign_lhs (new_stmt);
4347 STMT_VINFO_RELATED_STMT (prev_phi_info) = new_phi;
4350 FOR_EACH_VEC_ELT (tree, vec_oprnds0, i, def0)
4353 reduc_def = PHI_RESULT (VEC_index (gimple, phis, i));
4356 if (!single_defuse_cycle || j == 0)
4357 reduc_def = PHI_RESULT (new_phi);
4360 def1 = ((op_type == ternary_op)
4361 ? VEC_index (tree, vec_oprnds1, i) : NULL);
4362 if (op_type == binary_op)
4364 if (reduc_index == 0)
4365 expr = build2 (code, vectype_out, reduc_def, def0);
4367 expr = build2 (code, vectype_out, def0, reduc_def);
4371 if (reduc_index == 0)
4372 expr = build3 (code, vectype_out, reduc_def, def0, def1);
4375 if (reduc_index == 1)
4376 expr = build3 (code, vectype_out, def0, reduc_def, def1);
4378 expr = build3 (code, vectype_out, def0, def1, reduc_def);
4382 new_stmt = gimple_build_assign (vec_dest, expr);
4383 new_temp = make_ssa_name (vec_dest, new_stmt);
4384 gimple_assign_set_lhs (new_stmt, new_temp);
4385 vect_finish_stmt_generation (stmt, new_stmt, gsi);
4388 VEC_quick_push (gimple, SLP_TREE_VEC_STMTS (slp_node), new_stmt);
4389 VEC_quick_push (tree, vect_defs, new_temp);
4392 VEC_replace (tree, vect_defs, 0, new_temp);
4399 STMT_VINFO_VEC_STMT (stmt_info) = *vec_stmt = new_stmt;
4401 STMT_VINFO_RELATED_STMT (prev_stmt_info) = new_stmt;
4403 prev_stmt_info = vinfo_for_stmt (new_stmt);
4404 prev_phi_info = vinfo_for_stmt (new_phi);
4407 /* Finalize the reduction-phi (set its arguments) and create the
4408 epilog reduction code. */
4409 if ((!single_defuse_cycle || code == COND_EXPR) && !slp_node)
4411 new_temp = gimple_assign_lhs (*vec_stmt);
4412 VEC_replace (tree, vect_defs, 0, new_temp);
4415 vect_create_epilog_for_reduction (vect_defs, stmt, epilog_copies,
4416 epilog_reduc_code, phis, reduc_index,
4417 double_reduc, slp_node);
4419 VEC_free (gimple, heap, phis);
4420 VEC_free (tree, heap, vec_oprnds0);
4422 VEC_free (tree, heap, vec_oprnds1);
4427 /* Function vect_min_worthwhile_factor.
4429 For a loop where we could vectorize the operation indicated by CODE,
4430 return the minimum vectorization factor that makes it worthwhile
4431 to use generic vectors. */
4433 vect_min_worthwhile_factor (enum tree_code code)
4454 /* Function vectorizable_induction
4456 Check if PHI performs an induction computation that can be vectorized.
4457 If VEC_STMT is also passed, vectorize the induction PHI: create a vectorized
4458 phi to replace it, put it in VEC_STMT, and add it to the same basic block.
4459 Return FALSE if not a vectorizable STMT, TRUE otherwise. */
4462 vectorizable_induction (gimple phi, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
4465 stmt_vec_info stmt_info = vinfo_for_stmt (phi);
4466 tree vectype = STMT_VINFO_VECTYPE (stmt_info);
4467 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
4468 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
4469 int nunits = TYPE_VECTOR_SUBPARTS (vectype);
4470 int ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits;
4473 gcc_assert (ncopies >= 1);
4474 /* FORNOW. This restriction should be relaxed. */
4475 if (nested_in_vect_loop_p (loop, phi) && ncopies > 1)
4477 if (vect_print_dump_info (REPORT_DETAILS))
4478 fprintf (vect_dump, "multiple types in nested loop.");
4482 if (!STMT_VINFO_RELEVANT_P (stmt_info))
4485 /* FORNOW: SLP not supported. */
4486 if (STMT_SLP_TYPE (stmt_info))
4489 gcc_assert (STMT_VINFO_DEF_TYPE (stmt_info) == vect_induction_def);
4491 if (gimple_code (phi) != GIMPLE_PHI)
4494 if (!vec_stmt) /* transformation not required. */
4496 STMT_VINFO_TYPE (stmt_info) = induc_vec_info_type;
4497 if (vect_print_dump_info (REPORT_DETAILS))
4498 fprintf (vect_dump, "=== vectorizable_induction ===");
4499 vect_model_induction_cost (stmt_info, ncopies);
4505 if (vect_print_dump_info (REPORT_DETAILS))
4506 fprintf (vect_dump, "transform induction phi.");
4508 vec_def = get_initial_def_for_induction (phi);
4509 *vec_stmt = SSA_NAME_DEF_STMT (vec_def);
4513 /* Function vectorizable_live_operation.
4515 STMT computes a value that is used outside the loop. Check if
4516 it can be supported. */
4519 vectorizable_live_operation (gimple stmt,
4520 gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
4521 gimple *vec_stmt ATTRIBUTE_UNUSED)
4523 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
4524 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
4525 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
4531 enum vect_def_type dt;
4532 enum tree_code code;
4533 enum gimple_rhs_class rhs_class;
4535 gcc_assert (STMT_VINFO_LIVE_P (stmt_info));
4537 if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_reduction_def)
4540 if (!is_gimple_assign (stmt))
4543 if (TREE_CODE (gimple_assign_lhs (stmt)) != SSA_NAME)
4546 /* FORNOW. CHECKME. */
4547 if (nested_in_vect_loop_p (loop, stmt))
4550 code = gimple_assign_rhs_code (stmt);
4551 op_type = TREE_CODE_LENGTH (code);
4552 rhs_class = get_gimple_rhs_class (code);
4553 gcc_assert (rhs_class != GIMPLE_UNARY_RHS || op_type == unary_op);
4554 gcc_assert (rhs_class != GIMPLE_BINARY_RHS || op_type == binary_op);
4556 /* FORNOW: support only if all uses are invariant. This means
4557 that the scalar operations can remain in place, unvectorized.
4558 The original last scalar value that they compute will be used. */
4560 for (i = 0; i < op_type; i++)
4562 if (rhs_class == GIMPLE_SINGLE_RHS)
4563 op = TREE_OPERAND (gimple_op (stmt, 1), i);
4565 op = gimple_op (stmt, i + 1);
4567 && !vect_is_simple_use (op, loop_vinfo, NULL, &def_stmt, &def, &dt))
4569 if (vect_print_dump_info (REPORT_DETAILS))
4570 fprintf (vect_dump, "use not simple.");
4574 if (dt != vect_external_def && dt != vect_constant_def)
4578 /* No transformation is required for the cases we currently support. */
4582 /* Kill any debug uses outside LOOP of SSA names defined in STMT. */
4585 vect_loop_kill_debug_uses (struct loop *loop, gimple stmt)
4587 ssa_op_iter op_iter;
4588 imm_use_iterator imm_iter;
4589 def_operand_p def_p;
4592 FOR_EACH_PHI_OR_STMT_DEF (def_p, stmt, op_iter, SSA_OP_DEF)
4594 FOR_EACH_IMM_USE_STMT (ustmt, imm_iter, DEF_FROM_PTR (def_p))
4598 if (!is_gimple_debug (ustmt))
4601 bb = gimple_bb (ustmt);
4603 if (!flow_bb_inside_loop_p (loop, bb))
4605 if (gimple_debug_bind_p (ustmt))
4607 if (vect_print_dump_info (REPORT_DETAILS))
4608 fprintf (vect_dump, "killing debug use");
4610 gimple_debug_bind_reset_value (ustmt);
4611 update_stmt (ustmt);
4620 /* Function vect_transform_loop.
4622 The analysis phase has determined that the loop is vectorizable.
4623 Vectorize the loop - created vectorized stmts to replace the scalar
4624 stmts in the loop, and update the loop exit condition. */
4627 vect_transform_loop (loop_vec_info loop_vinfo)
4629 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
4630 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
4631 int nbbs = loop->num_nodes;
4632 gimple_stmt_iterator si;
4635 int vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
4637 bool slp_scheduled = false;
4638 unsigned int nunits;
4639 tree cond_expr = NULL_TREE;
4640 gimple_seq cond_expr_stmt_list = NULL;
4641 bool do_peeling_for_loop_bound;
4643 if (vect_print_dump_info (REPORT_DETAILS))
4644 fprintf (vect_dump, "=== vec_transform_loop ===");
4646 /* Peel the loop if there are data refs with unknown alignment.
4647 Only one data ref with unknown store is allowed. */
4649 if (LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo))
4650 vect_do_peeling_for_alignment (loop_vinfo);
4652 do_peeling_for_loop_bound
4653 = (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
4654 || (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
4655 && LOOP_VINFO_INT_NITERS (loop_vinfo) % vectorization_factor != 0));
4657 if (LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)
4658 || LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
4659 vect_loop_versioning (loop_vinfo,
4660 !do_peeling_for_loop_bound,
4661 &cond_expr, &cond_expr_stmt_list);
4663 /* If the loop has a symbolic number of iterations 'n' (i.e. it's not a
4664 compile time constant), or it is a constant that doesn't divide by the
4665 vectorization factor, then an epilog loop needs to be created.
4666 We therefore duplicate the loop: the original loop will be vectorized,
4667 and will compute the first (n/VF) iterations. The second copy of the loop
4668 will remain scalar and will compute the remaining (n%VF) iterations.
4669 (VF is the vectorization factor). */
4671 if (do_peeling_for_loop_bound)
4672 vect_do_peeling_for_loop_bound (loop_vinfo, &ratio,
4673 cond_expr, cond_expr_stmt_list);
4675 ratio = build_int_cst (TREE_TYPE (LOOP_VINFO_NITERS (loop_vinfo)),
4676 LOOP_VINFO_INT_NITERS (loop_vinfo) / vectorization_factor);
4678 /* 1) Make sure the loop header has exactly two entries
4679 2) Make sure we have a preheader basic block. */
4681 gcc_assert (EDGE_COUNT (loop->header->preds) == 2);
4683 split_edge (loop_preheader_edge (loop));
4685 /* FORNOW: the vectorizer supports only loops which body consist
4686 of one basic block (header + empty latch). When the vectorizer will
4687 support more involved loop forms, the order by which the BBs are
4688 traversed need to be reconsidered. */
4690 for (i = 0; i < nbbs; i++)
4692 basic_block bb = bbs[i];
4693 stmt_vec_info stmt_info;
4696 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
4698 phi = gsi_stmt (si);
4699 if (vect_print_dump_info (REPORT_DETAILS))
4701 fprintf (vect_dump, "------>vectorizing phi: ");
4702 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
4704 stmt_info = vinfo_for_stmt (phi);
4708 if (MAY_HAVE_DEBUG_STMTS && !STMT_VINFO_LIVE_P (stmt_info))
4709 vect_loop_kill_debug_uses (loop, phi);
4711 if (!STMT_VINFO_RELEVANT_P (stmt_info)
4712 && !STMT_VINFO_LIVE_P (stmt_info))
4715 if ((TYPE_VECTOR_SUBPARTS (STMT_VINFO_VECTYPE (stmt_info))
4716 != (unsigned HOST_WIDE_INT) vectorization_factor)
4717 && vect_print_dump_info (REPORT_DETAILS))
4718 fprintf (vect_dump, "multiple-types.");
4720 if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_induction_def)
4722 if (vect_print_dump_info (REPORT_DETAILS))
4723 fprintf (vect_dump, "transform phi.");
4724 vect_transform_stmt (phi, NULL, NULL, NULL, NULL);
4728 for (si = gsi_start_bb (bb); !gsi_end_p (si);)
4730 gimple stmt = gsi_stmt (si);
4733 if (vect_print_dump_info (REPORT_DETAILS))
4735 fprintf (vect_dump, "------>vectorizing statement: ");
4736 print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
4739 stmt_info = vinfo_for_stmt (stmt);
4741 /* vector stmts created in the outer-loop during vectorization of
4742 stmts in an inner-loop may not have a stmt_info, and do not
4743 need to be vectorized. */
4750 if (MAY_HAVE_DEBUG_STMTS && !STMT_VINFO_LIVE_P (stmt_info))
4751 vect_loop_kill_debug_uses (loop, stmt);
4753 if (!STMT_VINFO_RELEVANT_P (stmt_info)
4754 && !STMT_VINFO_LIVE_P (stmt_info))
4760 gcc_assert (STMT_VINFO_VECTYPE (stmt_info));
4762 (unsigned int) TYPE_VECTOR_SUBPARTS (STMT_VINFO_VECTYPE (stmt_info));
4763 if (!STMT_SLP_TYPE (stmt_info)
4764 && nunits != (unsigned int) vectorization_factor
4765 && vect_print_dump_info (REPORT_DETAILS))
4766 /* For SLP VF is set according to unrolling factor, and not to
4767 vector size, hence for SLP this print is not valid. */
4768 fprintf (vect_dump, "multiple-types.");
4770 /* SLP. Schedule all the SLP instances when the first SLP stmt is
4772 if (STMT_SLP_TYPE (stmt_info))
4776 slp_scheduled = true;
4778 if (vect_print_dump_info (REPORT_DETAILS))
4779 fprintf (vect_dump, "=== scheduling SLP instances ===");
4781 vect_schedule_slp (loop_vinfo, NULL);
4784 /* Hybrid SLP stmts must be vectorized in addition to SLP. */
4785 if (!vinfo_for_stmt (stmt) || PURE_SLP_STMT (stmt_info))
4792 /* -------- vectorize statement ------------ */
4793 if (vect_print_dump_info (REPORT_DETAILS))
4794 fprintf (vect_dump, "transform statement.");
4796 strided_store = false;
4797 is_store = vect_transform_stmt (stmt, &si, &strided_store, NULL, NULL);
4800 if (STMT_VINFO_STRIDED_ACCESS (stmt_info))
4802 /* Interleaving. If IS_STORE is TRUE, the vectorization of the
4803 interleaving chain was completed - free all the stores in
4805 vect_remove_stores (DR_GROUP_FIRST_DR (stmt_info));
4806 gsi_remove (&si, true);
4811 /* Free the attached stmt_vec_info and remove the stmt. */
4812 free_stmt_vec_info (stmt);
4813 gsi_remove (&si, true);
4821 slpeel_make_loop_iterate_ntimes (loop, ratio);
4823 /* The memory tags and pointers in vectorized statements need to
4824 have their SSA forms updated. FIXME, why can't this be delayed
4825 until all the loops have been transformed? */
4826 update_ssa (TODO_update_ssa);
4828 if (vect_print_dump_info (REPORT_VECTORIZED_LOCATIONS))
4829 fprintf (vect_dump, "LOOP VECTORIZED.");
4830 if (loop->inner && vect_print_dump_info (REPORT_VECTORIZED_LOCATIONS))
4831 fprintf (vect_dump, "OUTER LOOP VECTORIZED.");