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"
41 #include "tree-chrec.h"
42 #include "tree-scalar-evolution.h"
43 #include "tree-vectorizer.h"
46 /* Loop Vectorization Pass.
48 This pass tries to vectorize loops.
50 For example, the vectorizer transforms the following simple loop:
52 short a[N]; short b[N]; short c[N]; int i;
58 as if it was manually vectorized by rewriting the source code into:
60 typedef int __attribute__((mode(V8HI))) v8hi;
61 short a[N]; short b[N]; short c[N]; int i;
62 v8hi *pa = (v8hi*)a, *pb = (v8hi*)b, *pc = (v8hi*)c;
65 for (i=0; i<N/8; i++){
72 The main entry to this pass is vectorize_loops(), in which
73 the vectorizer applies a set of analyses on a given set of loops,
74 followed by the actual vectorization transformation for the loops that
75 had successfully passed the analysis phase.
76 Throughout this pass we make a distinction between two types of
77 data: scalars (which are represented by SSA_NAMES), and memory references
78 ("data-refs"). These two types of data require different handling both
79 during analysis and transformation. The types of data-refs that the
80 vectorizer currently supports are ARRAY_REFS which base is an array DECL
81 (not a pointer), and INDIRECT_REFS through pointers; both array and pointer
82 accesses are required to have a simple (consecutive) access pattern.
86 The driver for the analysis phase is vect_analyze_loop().
87 It applies a set of analyses, some of which rely on the scalar evolution
88 analyzer (scev) developed by Sebastian Pop.
90 During the analysis phase the vectorizer records some information
91 per stmt in a "stmt_vec_info" struct which is attached to each stmt in the
92 loop, as well as general information about the loop as a whole, which is
93 recorded in a "loop_vec_info" struct attached to each loop.
97 The loop transformation phase scans all the stmts in the loop, and
98 creates a vector stmt (or a sequence of stmts) for each scalar stmt S in
99 the loop that needs to be vectorized. It inserts the vector code sequence
100 just before the scalar stmt S, and records a pointer to the vector code
101 in STMT_VINFO_VEC_STMT (stmt_info) (stmt_info is the stmt_vec_info struct
102 attached to S). This pointer will be used for the vectorization of following
103 stmts which use the def of stmt S. Stmt S is removed if it writes to memory;
104 otherwise, we rely on dead code elimination for removing it.
106 For example, say stmt S1 was vectorized into stmt VS1:
109 S1: b = x[i]; STMT_VINFO_VEC_STMT (stmt_info (S1)) = VS1
112 To vectorize stmt S2, the vectorizer first finds the stmt that defines
113 the operand 'b' (S1), and gets the relevant vector def 'vb' from the
114 vector stmt VS1 pointed to by STMT_VINFO_VEC_STMT (stmt_info (S1)). The
115 resulting sequence would be:
118 S1: b = x[i]; STMT_VINFO_VEC_STMT (stmt_info (S1)) = VS1
120 S2: a = b; STMT_VINFO_VEC_STMT (stmt_info (S2)) = VS2
122 Operands that are not SSA_NAMEs, are data-refs that appear in
123 load/store operations (like 'x[i]' in S1), and are handled differently.
127 Currently the only target specific information that is used is the
128 size of the vector (in bytes) - "TARGET_VECTORIZE_UNITS_PER_SIMD_WORD".
129 Targets that can support different sizes of vectors, for now will need
130 to specify one value for "TARGET_VECTORIZE_UNITS_PER_SIMD_WORD". More
131 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);
482 STRIP_NOPS (access_fn);
483 if (access_fn && vect_print_dump_info (REPORT_DETAILS))
485 fprintf (vect_dump, "Access function of PHI: ");
486 print_generic_expr (vect_dump, access_fn, TDF_SLIM);
490 || !vect_is_simple_iv_evolution (loop->num, access_fn, &dumy, &dumy))
492 VEC_safe_push (gimple, heap, worklist, phi);
496 if (vect_print_dump_info (REPORT_DETAILS))
497 fprintf (vect_dump, "Detected induction.");
498 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_induction_def;
502 /* Second - identify all reductions and nested cycles. */
503 while (VEC_length (gimple, worklist) > 0)
505 gimple phi = VEC_pop (gimple, worklist);
506 tree def = PHI_RESULT (phi);
507 stmt_vec_info stmt_vinfo = vinfo_for_stmt (phi);
511 if (vect_print_dump_info (REPORT_DETAILS))
513 fprintf (vect_dump, "Analyze phi: ");
514 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
517 gcc_assert (is_gimple_reg (SSA_NAME_VAR (def)));
518 gcc_assert (STMT_VINFO_DEF_TYPE (stmt_vinfo) == vect_unknown_def_type);
520 nested_cycle = (loop != LOOP_VINFO_LOOP (loop_vinfo));
521 reduc_stmt = vect_force_simple_reduction (loop_vinfo, phi, !nested_cycle,
527 if (vect_print_dump_info (REPORT_DETAILS))
528 fprintf (vect_dump, "Detected double reduction.");
530 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_double_reduction_def;
531 STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) =
532 vect_double_reduction_def;
538 if (vect_print_dump_info (REPORT_DETAILS))
539 fprintf (vect_dump, "Detected vectorizable nested cycle.");
541 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_nested_cycle;
542 STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) =
547 if (vect_print_dump_info (REPORT_DETAILS))
548 fprintf (vect_dump, "Detected reduction.");
550 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_reduction_def;
551 STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) =
553 /* Store the reduction cycles for possible vectorization in
555 VEC_safe_push (gimple, heap,
556 LOOP_VINFO_REDUCTIONS (loop_vinfo),
562 if (vect_print_dump_info (REPORT_DETAILS))
563 fprintf (vect_dump, "Unknown def-use cycle pattern.");
566 VEC_free (gimple, heap, worklist);
570 /* Function vect_analyze_scalar_cycles.
572 Examine the cross iteration def-use cycles of scalar variables, by
573 analyzing the loop-header PHIs of scalar variables. Classify each
574 cycle as one of the following: invariant, induction, reduction, unknown.
575 We do that for the loop represented by LOOP_VINFO, and also to its
576 inner-loop, if exists.
577 Examples for scalar cycles:
592 vect_analyze_scalar_cycles (loop_vec_info loop_vinfo)
594 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
596 vect_analyze_scalar_cycles_1 (loop_vinfo, loop);
598 /* When vectorizing an outer-loop, the inner-loop is executed sequentially.
599 Reductions in such inner-loop therefore have different properties than
600 the reductions in the nest that gets vectorized:
601 1. When vectorized, they are executed in the same order as in the original
602 scalar loop, so we can't change the order of computation when
604 2. FIXME: Inner-loop reductions can be used in the inner-loop, so the
605 current checks are too strict. */
608 vect_analyze_scalar_cycles_1 (loop_vinfo, loop->inner);
611 /* Function vect_get_loop_niters.
613 Determine how many iterations the loop is executed.
614 If an expression that represents the number of iterations
615 can be constructed, place it in NUMBER_OF_ITERATIONS.
616 Return the loop exit condition. */
619 vect_get_loop_niters (struct loop *loop, tree *number_of_iterations)
623 if (vect_print_dump_info (REPORT_DETAILS))
624 fprintf (vect_dump, "=== get_loop_niters ===");
626 niters = number_of_exit_cond_executions (loop);
628 if (niters != NULL_TREE
629 && niters != chrec_dont_know)
631 *number_of_iterations = niters;
633 if (vect_print_dump_info (REPORT_DETAILS))
635 fprintf (vect_dump, "==> get_loop_niters:" );
636 print_generic_expr (vect_dump, *number_of_iterations, TDF_SLIM);
640 return get_loop_exit_condition (loop);
644 /* Function bb_in_loop_p
646 Used as predicate for dfs order traversal of the loop bbs. */
649 bb_in_loop_p (const_basic_block bb, const void *data)
651 const struct loop *const loop = (const struct loop *)data;
652 if (flow_bb_inside_loop_p (loop, bb))
658 /* Function new_loop_vec_info.
660 Create and initialize a new loop_vec_info struct for LOOP, as well as
661 stmt_vec_info structs for all the stmts in LOOP. */
664 new_loop_vec_info (struct loop *loop)
668 gimple_stmt_iterator si;
669 unsigned int i, nbbs;
671 res = (loop_vec_info) xcalloc (1, sizeof (struct _loop_vec_info));
672 LOOP_VINFO_LOOP (res) = loop;
674 bbs = get_loop_body (loop);
676 /* Create/Update stmt_info for all stmts in the loop. */
677 for (i = 0; i < loop->num_nodes; i++)
679 basic_block bb = bbs[i];
681 /* BBs in a nested inner-loop will have been already processed (because
682 we will have called vect_analyze_loop_form for any nested inner-loop).
683 Therefore, for stmts in an inner-loop we just want to update the
684 STMT_VINFO_LOOP_VINFO field of their stmt_info to point to the new
685 loop_info of the outer-loop we are currently considering to vectorize
686 (instead of the loop_info of the inner-loop).
687 For stmts in other BBs we need to create a stmt_info from scratch. */
688 if (bb->loop_father != loop)
691 gcc_assert (loop->inner && bb->loop_father == loop->inner);
692 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
694 gimple phi = gsi_stmt (si);
695 stmt_vec_info stmt_info = vinfo_for_stmt (phi);
696 loop_vec_info inner_loop_vinfo =
697 STMT_VINFO_LOOP_VINFO (stmt_info);
698 gcc_assert (loop->inner == LOOP_VINFO_LOOP (inner_loop_vinfo));
699 STMT_VINFO_LOOP_VINFO (stmt_info) = res;
701 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
703 gimple stmt = gsi_stmt (si);
704 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
705 loop_vec_info inner_loop_vinfo =
706 STMT_VINFO_LOOP_VINFO (stmt_info);
707 gcc_assert (loop->inner == LOOP_VINFO_LOOP (inner_loop_vinfo));
708 STMT_VINFO_LOOP_VINFO (stmt_info) = res;
713 /* bb in current nest. */
714 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
716 gimple phi = gsi_stmt (si);
717 gimple_set_uid (phi, 0);
718 set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, res, NULL));
721 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
723 gimple stmt = gsi_stmt (si);
724 gimple_set_uid (stmt, 0);
725 set_vinfo_for_stmt (stmt, new_stmt_vec_info (stmt, res, NULL));
730 /* CHECKME: We want to visit all BBs before their successors (except for
731 latch blocks, for which this assertion wouldn't hold). In the simple
732 case of the loop forms we allow, a dfs order of the BBs would the same
733 as reversed postorder traversal, so we are safe. */
736 bbs = XCNEWVEC (basic_block, loop->num_nodes);
737 nbbs = dfs_enumerate_from (loop->header, 0, bb_in_loop_p,
738 bbs, loop->num_nodes, loop);
739 gcc_assert (nbbs == loop->num_nodes);
741 LOOP_VINFO_BBS (res) = bbs;
742 LOOP_VINFO_NITERS (res) = NULL;
743 LOOP_VINFO_NITERS_UNCHANGED (res) = NULL;
744 LOOP_VINFO_COST_MODEL_MIN_ITERS (res) = 0;
745 LOOP_VINFO_VECTORIZABLE_P (res) = 0;
746 LOOP_PEELING_FOR_ALIGNMENT (res) = 0;
747 LOOP_VINFO_VECT_FACTOR (res) = 0;
748 LOOP_VINFO_LOOP_NEST (res) = VEC_alloc (loop_p, heap, 3);
749 LOOP_VINFO_DATAREFS (res) = VEC_alloc (data_reference_p, heap, 10);
750 LOOP_VINFO_DDRS (res) = VEC_alloc (ddr_p, heap, 10 * 10);
751 LOOP_VINFO_UNALIGNED_DR (res) = NULL;
752 LOOP_VINFO_MAY_MISALIGN_STMTS (res) =
753 VEC_alloc (gimple, heap,
754 PARAM_VALUE (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS));
755 LOOP_VINFO_MAY_ALIAS_DDRS (res) =
756 VEC_alloc (ddr_p, heap,
757 PARAM_VALUE (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS));
758 LOOP_VINFO_STRIDED_STORES (res) = VEC_alloc (gimple, heap, 10);
759 LOOP_VINFO_REDUCTIONS (res) = VEC_alloc (gimple, heap, 10);
760 LOOP_VINFO_SLP_INSTANCES (res) = VEC_alloc (slp_instance, heap, 10);
761 LOOP_VINFO_SLP_UNROLLING_FACTOR (res) = 1;
762 LOOP_VINFO_PEELING_HTAB (res) = NULL;
768 /* Function destroy_loop_vec_info.
770 Free LOOP_VINFO struct, as well as all the stmt_vec_info structs of all the
771 stmts in the loop. */
774 destroy_loop_vec_info (loop_vec_info loop_vinfo, bool clean_stmts)
779 gimple_stmt_iterator si;
781 VEC (slp_instance, heap) *slp_instances;
782 slp_instance instance;
787 loop = LOOP_VINFO_LOOP (loop_vinfo);
789 bbs = LOOP_VINFO_BBS (loop_vinfo);
790 nbbs = loop->num_nodes;
794 free (LOOP_VINFO_BBS (loop_vinfo));
795 free_data_refs (LOOP_VINFO_DATAREFS (loop_vinfo));
796 free_dependence_relations (LOOP_VINFO_DDRS (loop_vinfo));
797 VEC_free (loop_p, heap, LOOP_VINFO_LOOP_NEST (loop_vinfo));
798 VEC_free (gimple, heap, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo));
799 VEC_free (ddr_p, heap, LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo));
806 for (j = 0; j < nbbs; j++)
808 basic_block bb = bbs[j];
809 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
810 free_stmt_vec_info (gsi_stmt (si));
812 for (si = gsi_start_bb (bb); !gsi_end_p (si); )
814 gimple stmt = gsi_stmt (si);
815 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
819 /* Check if this is a "pattern stmt" (introduced by the
820 vectorizer during the pattern recognition pass). */
821 bool remove_stmt_p = false;
822 gimple orig_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
825 stmt_vec_info orig_stmt_info = vinfo_for_stmt (orig_stmt);
827 && STMT_VINFO_IN_PATTERN_P (orig_stmt_info))
828 remove_stmt_p = true;
831 /* Free stmt_vec_info. */
832 free_stmt_vec_info (stmt);
834 /* Remove dead "pattern stmts". */
836 gsi_remove (&si, true);
842 free (LOOP_VINFO_BBS (loop_vinfo));
843 free_data_refs (LOOP_VINFO_DATAREFS (loop_vinfo));
844 free_dependence_relations (LOOP_VINFO_DDRS (loop_vinfo));
845 VEC_free (loop_p, heap, LOOP_VINFO_LOOP_NEST (loop_vinfo));
846 VEC_free (gimple, heap, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo));
847 VEC_free (ddr_p, heap, LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo));
848 slp_instances = LOOP_VINFO_SLP_INSTANCES (loop_vinfo);
849 FOR_EACH_VEC_ELT (slp_instance, slp_instances, j, instance)
850 vect_free_slp_instance (instance);
852 VEC_free (slp_instance, heap, LOOP_VINFO_SLP_INSTANCES (loop_vinfo));
853 VEC_free (gimple, heap, LOOP_VINFO_STRIDED_STORES (loop_vinfo));
854 VEC_free (gimple, heap, LOOP_VINFO_REDUCTIONS (loop_vinfo));
856 if (LOOP_VINFO_PEELING_HTAB (loop_vinfo))
857 htab_delete (LOOP_VINFO_PEELING_HTAB (loop_vinfo));
864 /* Function vect_analyze_loop_1.
866 Apply a set of analyses on LOOP, and create a loop_vec_info struct
867 for it. The different analyses will record information in the
868 loop_vec_info struct. This is a subset of the analyses applied in
869 vect_analyze_loop, to be applied on an inner-loop nested in the loop
870 that is now considered for (outer-loop) vectorization. */
873 vect_analyze_loop_1 (struct loop *loop)
875 loop_vec_info loop_vinfo;
877 if (vect_print_dump_info (REPORT_DETAILS))
878 fprintf (vect_dump, "===== analyze_loop_nest_1 =====");
880 /* Check the CFG characteristics of the loop (nesting, entry/exit, etc. */
882 loop_vinfo = vect_analyze_loop_form (loop);
885 if (vect_print_dump_info (REPORT_DETAILS))
886 fprintf (vect_dump, "bad inner-loop form.");
894 /* Function vect_analyze_loop_form.
896 Verify that certain CFG restrictions hold, including:
897 - the loop has a pre-header
898 - the loop has a single entry and exit
899 - the loop exit condition is simple enough, and the number of iterations
900 can be analyzed (a countable loop). */
903 vect_analyze_loop_form (struct loop *loop)
905 loop_vec_info loop_vinfo;
907 tree number_of_iterations = NULL;
908 loop_vec_info inner_loop_vinfo = NULL;
910 if (vect_print_dump_info (REPORT_DETAILS))
911 fprintf (vect_dump, "=== vect_analyze_loop_form ===");
913 /* Different restrictions apply when we are considering an inner-most loop,
914 vs. an outer (nested) loop.
915 (FORNOW. May want to relax some of these restrictions in the future). */
919 /* Inner-most loop. We currently require that the number of BBs is
920 exactly 2 (the header and latch). Vectorizable inner-most loops
931 if (loop->num_nodes != 2)
933 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
934 fprintf (vect_dump, "not vectorized: control flow in loop.");
938 if (empty_block_p (loop->header))
940 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
941 fprintf (vect_dump, "not vectorized: empty loop.");
947 struct loop *innerloop = loop->inner;
950 /* Nested loop. We currently require that the loop is doubly-nested,
951 contains a single inner loop, and the number of BBs is exactly 5.
952 Vectorizable outer-loops look like this:
964 The inner-loop has the properties expected of inner-most loops
965 as described above. */
967 if ((loop->inner)->inner || (loop->inner)->next)
969 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
970 fprintf (vect_dump, "not vectorized: multiple nested loops.");
974 /* Analyze the inner-loop. */
975 inner_loop_vinfo = vect_analyze_loop_1 (loop->inner);
976 if (!inner_loop_vinfo)
978 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
979 fprintf (vect_dump, "not vectorized: Bad inner loop.");
983 if (!expr_invariant_in_loop_p (loop,
984 LOOP_VINFO_NITERS (inner_loop_vinfo)))
986 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
988 "not vectorized: inner-loop count not invariant.");
989 destroy_loop_vec_info (inner_loop_vinfo, true);
993 if (loop->num_nodes != 5)
995 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
996 fprintf (vect_dump, "not vectorized: control flow in loop.");
997 destroy_loop_vec_info (inner_loop_vinfo, true);
1001 gcc_assert (EDGE_COUNT (innerloop->header->preds) == 2);
1002 entryedge = EDGE_PRED (innerloop->header, 0);
1003 if (EDGE_PRED (innerloop->header, 0)->src == innerloop->latch)
1004 entryedge = EDGE_PRED (innerloop->header, 1);
1006 if (entryedge->src != loop->header
1007 || !single_exit (innerloop)
1008 || single_exit (innerloop)->dest != EDGE_PRED (loop->latch, 0)->src)
1010 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1011 fprintf (vect_dump, "not vectorized: unsupported outerloop form.");
1012 destroy_loop_vec_info (inner_loop_vinfo, true);
1016 if (vect_print_dump_info (REPORT_DETAILS))
1017 fprintf (vect_dump, "Considering outer-loop vectorization.");
1020 if (!single_exit (loop)
1021 || EDGE_COUNT (loop->header->preds) != 2)
1023 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1025 if (!single_exit (loop))
1026 fprintf (vect_dump, "not vectorized: multiple exits.");
1027 else if (EDGE_COUNT (loop->header->preds) != 2)
1028 fprintf (vect_dump, "not vectorized: too many incoming edges.");
1030 if (inner_loop_vinfo)
1031 destroy_loop_vec_info (inner_loop_vinfo, true);
1035 /* We assume that the loop exit condition is at the end of the loop. i.e,
1036 that the loop is represented as a do-while (with a proper if-guard
1037 before the loop if needed), where the loop header contains all the
1038 executable statements, and the latch is empty. */
1039 if (!empty_block_p (loop->latch)
1040 || !gimple_seq_empty_p (phi_nodes (loop->latch)))
1042 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1043 fprintf (vect_dump, "not vectorized: unexpected loop form.");
1044 if (inner_loop_vinfo)
1045 destroy_loop_vec_info (inner_loop_vinfo, true);
1049 /* Make sure there exists a single-predecessor exit bb: */
1050 if (!single_pred_p (single_exit (loop)->dest))
1052 edge e = single_exit (loop);
1053 if (!(e->flags & EDGE_ABNORMAL))
1055 split_loop_exit_edge (e);
1056 if (vect_print_dump_info (REPORT_DETAILS))
1057 fprintf (vect_dump, "split exit edge.");
1061 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1062 fprintf (vect_dump, "not vectorized: abnormal loop exit edge.");
1063 if (inner_loop_vinfo)
1064 destroy_loop_vec_info (inner_loop_vinfo, true);
1069 loop_cond = vect_get_loop_niters (loop, &number_of_iterations);
1072 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1073 fprintf (vect_dump, "not vectorized: complicated exit condition.");
1074 if (inner_loop_vinfo)
1075 destroy_loop_vec_info (inner_loop_vinfo, true);
1079 if (!number_of_iterations)
1081 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1083 "not vectorized: number of iterations cannot be computed.");
1084 if (inner_loop_vinfo)
1085 destroy_loop_vec_info (inner_loop_vinfo, true);
1089 if (chrec_contains_undetermined (number_of_iterations))
1091 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1092 fprintf (vect_dump, "Infinite number of iterations.");
1093 if (inner_loop_vinfo)
1094 destroy_loop_vec_info (inner_loop_vinfo, true);
1098 if (!NITERS_KNOWN_P (number_of_iterations))
1100 if (vect_print_dump_info (REPORT_DETAILS))
1102 fprintf (vect_dump, "Symbolic number of iterations is ");
1103 print_generic_expr (vect_dump, number_of_iterations, TDF_DETAILS);
1106 else if (TREE_INT_CST_LOW (number_of_iterations) == 0)
1108 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1109 fprintf (vect_dump, "not vectorized: number of iterations = 0.");
1110 if (inner_loop_vinfo)
1111 destroy_loop_vec_info (inner_loop_vinfo, false);
1115 loop_vinfo = new_loop_vec_info (loop);
1116 LOOP_VINFO_NITERS (loop_vinfo) = number_of_iterations;
1117 LOOP_VINFO_NITERS_UNCHANGED (loop_vinfo) = number_of_iterations;
1119 STMT_VINFO_TYPE (vinfo_for_stmt (loop_cond)) = loop_exit_ctrl_vec_info_type;
1121 /* CHECKME: May want to keep it around it in the future. */
1122 if (inner_loop_vinfo)
1123 destroy_loop_vec_info (inner_loop_vinfo, false);
1125 gcc_assert (!loop->aux);
1126 loop->aux = loop_vinfo;
1131 /* Get cost by calling cost target builtin. */
1134 vect_get_cost (enum vect_cost_for_stmt type_of_cost)
1136 tree dummy_type = NULL;
1139 return targetm.vectorize.builtin_vectorization_cost (type_of_cost,
1144 /* Function vect_analyze_loop_operations.
1146 Scan the loop stmts and make sure they are all vectorizable. */
1149 vect_analyze_loop_operations (loop_vec_info loop_vinfo)
1151 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
1152 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
1153 int nbbs = loop->num_nodes;
1154 gimple_stmt_iterator si;
1155 unsigned int vectorization_factor = 0;
1158 stmt_vec_info stmt_info;
1159 bool need_to_vectorize = false;
1160 int min_profitable_iters;
1161 int min_scalar_loop_bound;
1163 bool only_slp_in_loop = true, ok;
1165 if (vect_print_dump_info (REPORT_DETAILS))
1166 fprintf (vect_dump, "=== vect_analyze_loop_operations ===");
1168 gcc_assert (LOOP_VINFO_VECT_FACTOR (loop_vinfo));
1169 vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
1171 for (i = 0; i < nbbs; i++)
1173 basic_block bb = bbs[i];
1175 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
1177 phi = gsi_stmt (si);
1180 stmt_info = vinfo_for_stmt (phi);
1181 if (vect_print_dump_info (REPORT_DETAILS))
1183 fprintf (vect_dump, "examining phi: ");
1184 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
1187 if (! is_loop_header_bb_p (bb))
1189 /* inner-loop loop-closed exit phi in outer-loop vectorization
1190 (i.e. a phi in the tail of the outer-loop).
1191 FORNOW: we currently don't support the case that these phis
1192 are not used in the outerloop (unless it is double reduction,
1193 i.e., this phi is vect_reduction_def), cause this case
1194 requires to actually do something here. */
1195 if ((!STMT_VINFO_RELEVANT_P (stmt_info)
1196 || STMT_VINFO_LIVE_P (stmt_info))
1197 && STMT_VINFO_DEF_TYPE (stmt_info)
1198 != vect_double_reduction_def)
1200 if (vect_print_dump_info (REPORT_DETAILS))
1202 "Unsupported loop-closed phi in outer-loop.");
1208 gcc_assert (stmt_info);
1210 if (STMT_VINFO_LIVE_P (stmt_info))
1212 /* FORNOW: not yet supported. */
1213 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1214 fprintf (vect_dump, "not vectorized: value used after loop.");
1218 if (STMT_VINFO_RELEVANT (stmt_info) == vect_used_in_scope
1219 && STMT_VINFO_DEF_TYPE (stmt_info) != vect_induction_def)
1221 /* A scalar-dependence cycle that we don't support. */
1222 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1223 fprintf (vect_dump, "not vectorized: scalar dependence cycle.");
1227 if (STMT_VINFO_RELEVANT_P (stmt_info))
1229 need_to_vectorize = true;
1230 if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_induction_def)
1231 ok = vectorizable_induction (phi, NULL, NULL);
1236 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1239 "not vectorized: relevant phi not supported: ");
1240 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
1246 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
1248 gimple stmt = gsi_stmt (si);
1249 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
1251 gcc_assert (stmt_info);
1253 if (!vect_analyze_stmt (stmt, &need_to_vectorize, NULL))
1256 if ((STMT_VINFO_RELEVANT_P (stmt_info)
1257 || VECTORIZABLE_CYCLE_DEF (STMT_VINFO_DEF_TYPE (stmt_info)))
1258 && !PURE_SLP_STMT (stmt_info))
1259 /* STMT needs both SLP and loop-based vectorization. */
1260 only_slp_in_loop = false;
1264 /* All operations in the loop are either irrelevant (deal with loop
1265 control, or dead), or only used outside the loop and can be moved
1266 out of the loop (e.g. invariants, inductions). The loop can be
1267 optimized away by scalar optimizations. We're better off not
1268 touching this loop. */
1269 if (!need_to_vectorize)
1271 if (vect_print_dump_info (REPORT_DETAILS))
1273 "All the computation can be taken out of the loop.");
1274 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1276 "not vectorized: redundant loop. no profit to vectorize.");
1280 /* If all the stmts in the loop can be SLPed, we perform only SLP, and
1281 vectorization factor of the loop is the unrolling factor required by the
1282 SLP instances. If that unrolling factor is 1, we say, that we perform
1283 pure SLP on loop - cross iteration parallelism is not exploited. */
1284 if (only_slp_in_loop)
1285 vectorization_factor = LOOP_VINFO_SLP_UNROLLING_FACTOR (loop_vinfo);
1287 vectorization_factor = least_common_multiple (vectorization_factor,
1288 LOOP_VINFO_SLP_UNROLLING_FACTOR (loop_vinfo));
1290 LOOP_VINFO_VECT_FACTOR (loop_vinfo) = vectorization_factor;
1292 if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
1293 && vect_print_dump_info (REPORT_DETAILS))
1295 "vectorization_factor = %d, niters = " HOST_WIDE_INT_PRINT_DEC,
1296 vectorization_factor, LOOP_VINFO_INT_NITERS (loop_vinfo));
1298 if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
1299 && (LOOP_VINFO_INT_NITERS (loop_vinfo) < vectorization_factor))
1301 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1302 fprintf (vect_dump, "not vectorized: iteration count too small.");
1303 if (vect_print_dump_info (REPORT_DETAILS))
1304 fprintf (vect_dump,"not vectorized: iteration count smaller than "
1305 "vectorization factor.");
1309 /* Analyze cost. Decide if worth while to vectorize. */
1311 /* Once VF is set, SLP costs should be updated since the number of created
1312 vector stmts depends on VF. */
1313 vect_update_slp_costs_according_to_vf (loop_vinfo);
1315 min_profitable_iters = vect_estimate_min_profitable_iters (loop_vinfo);
1316 LOOP_VINFO_COST_MODEL_MIN_ITERS (loop_vinfo) = min_profitable_iters;
1318 if (min_profitable_iters < 0)
1320 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1321 fprintf (vect_dump, "not vectorized: vectorization not profitable.");
1322 if (vect_print_dump_info (REPORT_DETAILS))
1323 fprintf (vect_dump, "not vectorized: vector version will never be "
1328 min_scalar_loop_bound = ((PARAM_VALUE (PARAM_MIN_VECT_LOOP_BOUND)
1329 * vectorization_factor) - 1);
1331 /* Use the cost model only if it is more conservative than user specified
1334 th = (unsigned) min_scalar_loop_bound;
1335 if (min_profitable_iters
1336 && (!min_scalar_loop_bound
1337 || min_profitable_iters > min_scalar_loop_bound))
1338 th = (unsigned) min_profitable_iters;
1340 if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
1341 && LOOP_VINFO_INT_NITERS (loop_vinfo) <= th)
1343 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1344 fprintf (vect_dump, "not vectorized: vectorization not "
1346 if (vect_print_dump_info (REPORT_DETAILS))
1347 fprintf (vect_dump, "not vectorized: iteration count smaller than "
1348 "user specified loop bound parameter or minimum "
1349 "profitable iterations (whichever is more conservative).");
1353 if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
1354 || LOOP_VINFO_INT_NITERS (loop_vinfo) % vectorization_factor != 0
1355 || LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo))
1357 if (vect_print_dump_info (REPORT_DETAILS))
1358 fprintf (vect_dump, "epilog loop required.");
1359 if (!vect_can_advance_ivs_p (loop_vinfo))
1361 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1363 "not vectorized: can't create epilog loop 1.");
1366 if (!slpeel_can_duplicate_loop_p (loop, single_exit (loop)))
1368 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1370 "not vectorized: can't create epilog loop 2.");
1379 /* Function vect_analyze_loop_2.
1381 Apply a set of analyses on LOOP, and create a loop_vec_info struct
1382 for it. The different analyses will record information in the
1383 loop_vec_info struct. */
1385 vect_analyze_loop_2 (loop_vec_info loop_vinfo)
1388 int max_vf = MAX_VECTORIZATION_FACTOR;
1391 /* Find all data references in the loop (which correspond to vdefs/vuses)
1392 and analyze their evolution in the loop. Also adjust the minimal
1393 vectorization factor according to the loads and stores.
1395 FORNOW: Handle only simple, array references, which
1396 alignment can be forced, and aligned pointer-references. */
1398 ok = vect_analyze_data_refs (loop_vinfo, NULL, &min_vf);
1401 if (vect_print_dump_info (REPORT_DETAILS))
1402 fprintf (vect_dump, "bad data references.");
1406 /* Classify all cross-iteration scalar data-flow cycles.
1407 Cross-iteration cycles caused by virtual phis are analyzed separately. */
1409 vect_analyze_scalar_cycles (loop_vinfo);
1411 vect_pattern_recog (loop_vinfo);
1413 /* Data-flow analysis to detect stmts that do not need to be vectorized. */
1415 ok = vect_mark_stmts_to_be_vectorized (loop_vinfo);
1418 if (vect_print_dump_info (REPORT_DETAILS))
1419 fprintf (vect_dump, "unexpected pattern.");
1423 /* Analyze data dependences between the data-refs in the loop
1424 and adjust the maximum vectorization factor according to
1426 FORNOW: fail at the first data dependence that we encounter. */
1428 ok = vect_analyze_data_ref_dependences (loop_vinfo, NULL, &max_vf, &dummy);
1432 if (vect_print_dump_info (REPORT_DETAILS))
1433 fprintf (vect_dump, "bad data dependence.");
1437 ok = vect_determine_vectorization_factor (loop_vinfo);
1440 if (vect_print_dump_info (REPORT_DETAILS))
1441 fprintf (vect_dump, "can't determine vectorization factor.");
1444 if (max_vf < LOOP_VINFO_VECT_FACTOR (loop_vinfo))
1446 if (vect_print_dump_info (REPORT_DETAILS))
1447 fprintf (vect_dump, "bad data dependence.");
1451 /* Analyze the alignment of the data-refs in the loop.
1452 Fail if a data reference is found that cannot be vectorized. */
1454 ok = vect_analyze_data_refs_alignment (loop_vinfo, NULL);
1457 if (vect_print_dump_info (REPORT_DETAILS))
1458 fprintf (vect_dump, "bad data alignment.");
1462 /* Analyze the access patterns of the data-refs in the loop (consecutive,
1463 complex, etc.). FORNOW: Only handle consecutive access pattern. */
1465 ok = vect_analyze_data_ref_accesses (loop_vinfo, NULL);
1468 if (vect_print_dump_info (REPORT_DETAILS))
1469 fprintf (vect_dump, "bad data access.");
1473 /* Prune the list of ddrs to be tested at run-time by versioning for alias.
1474 It is important to call pruning after vect_analyze_data_ref_accesses,
1475 since we use grouping information gathered by interleaving analysis. */
1476 ok = vect_prune_runtime_alias_test_list (loop_vinfo);
1479 if (vect_print_dump_info (REPORT_DETAILS))
1480 fprintf (vect_dump, "too long list of versioning for alias "
1485 /* This pass will decide on using loop versioning and/or loop peeling in
1486 order to enhance the alignment of data references in the loop. */
1488 ok = vect_enhance_data_refs_alignment (loop_vinfo);
1491 if (vect_print_dump_info (REPORT_DETAILS))
1492 fprintf (vect_dump, "bad data alignment.");
1496 /* Check the SLP opportunities in the loop, analyze and build SLP trees. */
1497 ok = vect_analyze_slp (loop_vinfo, NULL);
1500 /* Decide which possible SLP instances to SLP. */
1501 vect_make_slp_decision (loop_vinfo);
1503 /* Find stmts that need to be both vectorized and SLPed. */
1504 vect_detect_hybrid_slp (loop_vinfo);
1507 /* Scan all the operations in the loop and make sure they are
1510 ok = vect_analyze_loop_operations (loop_vinfo);
1513 if (vect_print_dump_info (REPORT_DETAILS))
1514 fprintf (vect_dump, "bad operation or unsupported loop bound.");
1521 /* Function vect_analyze_loop.
1523 Apply a set of analyses on LOOP, and create a loop_vec_info struct
1524 for it. The different analyses will record information in the
1525 loop_vec_info struct. */
1527 vect_analyze_loop (struct loop *loop)
1529 loop_vec_info loop_vinfo;
1530 unsigned int vector_sizes;
1532 /* Autodetect first vector size we try. */
1533 current_vector_size = 0;
1534 vector_sizes = targetm.vectorize.autovectorize_vector_sizes ();
1536 if (vect_print_dump_info (REPORT_DETAILS))
1537 fprintf (vect_dump, "===== analyze_loop_nest =====");
1539 if (loop_outer (loop)
1540 && loop_vec_info_for_loop (loop_outer (loop))
1541 && LOOP_VINFO_VECTORIZABLE_P (loop_vec_info_for_loop (loop_outer (loop))))
1543 if (vect_print_dump_info (REPORT_DETAILS))
1544 fprintf (vect_dump, "outer-loop already vectorized.");
1550 /* Check the CFG characteristics of the loop (nesting, entry/exit). */
1551 loop_vinfo = vect_analyze_loop_form (loop);
1554 if (vect_print_dump_info (REPORT_DETAILS))
1555 fprintf (vect_dump, "bad loop form.");
1559 if (vect_analyze_loop_2 (loop_vinfo))
1561 LOOP_VINFO_VECTORIZABLE_P (loop_vinfo) = 1;
1566 destroy_loop_vec_info (loop_vinfo, true);
1568 vector_sizes &= ~current_vector_size;
1569 if (vector_sizes == 0
1570 || current_vector_size == 0)
1573 /* Try the next biggest vector size. */
1574 current_vector_size = 1 << floor_log2 (vector_sizes);
1575 if (vect_print_dump_info (REPORT_DETAILS))
1576 fprintf (vect_dump, "***** Re-trying analysis with "
1577 "vector size %d\n", current_vector_size);
1582 /* Function reduction_code_for_scalar_code
1585 CODE - tree_code of a reduction operations.
1588 REDUC_CODE - the corresponding tree-code to be used to reduce the
1589 vector of partial results into a single scalar result (which
1590 will also reside in a vector) or ERROR_MARK if the operation is
1591 a supported reduction operation, but does not have such tree-code.
1593 Return FALSE if CODE currently cannot be vectorized as reduction. */
1596 reduction_code_for_scalar_code (enum tree_code code,
1597 enum tree_code *reduc_code)
1602 *reduc_code = REDUC_MAX_EXPR;
1606 *reduc_code = REDUC_MIN_EXPR;
1610 *reduc_code = REDUC_PLUS_EXPR;
1618 *reduc_code = ERROR_MARK;
1627 /* Error reporting helper for vect_is_simple_reduction below. GIMPLE statement
1628 STMT is printed with a message MSG. */
1631 report_vect_op (gimple stmt, const char *msg)
1633 fprintf (vect_dump, "%s", msg);
1634 print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
1638 /* Function vect_is_simple_reduction_1
1640 (1) Detect a cross-iteration def-use cycle that represents a simple
1641 reduction computation. We look for the following pattern:
1646 a2 = operation (a3, a1)
1649 1. operation is commutative and associative and it is safe to
1650 change the order of the computation (if CHECK_REDUCTION is true)
1651 2. no uses for a2 in the loop (a2 is used out of the loop)
1652 3. no uses of a1 in the loop besides the reduction operation.
1654 Condition 1 is tested here.
1655 Conditions 2,3 are tested in vect_mark_stmts_to_be_vectorized.
1657 (2) Detect a cross-iteration def-use cycle in nested loops, i.e.,
1658 nested cycles, if CHECK_REDUCTION is false.
1660 (3) Detect cycles of phi nodes in outer-loop vectorization, i.e., double
1664 inner loop (def of a3)
1667 If MODIFY is true it tries also to rework the code in-place to enable
1668 detection of more reduction patterns. For the time being we rewrite
1669 "res -= RHS" into "rhs += -RHS" when it seems worthwhile.
1673 vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
1674 bool check_reduction, bool *double_reduc,
1677 struct loop *loop = (gimple_bb (phi))->loop_father;
1678 struct loop *vect_loop = LOOP_VINFO_LOOP (loop_info);
1679 edge latch_e = loop_latch_edge (loop);
1680 tree loop_arg = PHI_ARG_DEF_FROM_EDGE (phi, latch_e);
1681 gimple def_stmt, def1 = NULL, def2 = NULL;
1682 enum tree_code orig_code, code;
1683 tree op1, op2, op3 = NULL_TREE, op4 = NULL_TREE;
1687 imm_use_iterator imm_iter;
1688 use_operand_p use_p;
1691 *double_reduc = false;
1693 /* If CHECK_REDUCTION is true, we assume inner-most loop vectorization,
1694 otherwise, we assume outer loop vectorization. */
1695 gcc_assert ((check_reduction && loop == vect_loop)
1696 || (!check_reduction && flow_loop_nested_p (vect_loop, loop)));
1698 name = PHI_RESULT (phi);
1700 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, name)
1702 gimple use_stmt = USE_STMT (use_p);
1703 if (is_gimple_debug (use_stmt))
1705 if (flow_bb_inside_loop_p (loop, gimple_bb (use_stmt))
1706 && vinfo_for_stmt (use_stmt)
1707 && !is_pattern_stmt_p (vinfo_for_stmt (use_stmt)))
1711 if (vect_print_dump_info (REPORT_DETAILS))
1712 fprintf (vect_dump, "reduction used in loop.");
1717 if (TREE_CODE (loop_arg) != SSA_NAME)
1719 if (vect_print_dump_info (REPORT_DETAILS))
1721 fprintf (vect_dump, "reduction: not ssa_name: ");
1722 print_generic_expr (vect_dump, loop_arg, TDF_SLIM);
1727 def_stmt = SSA_NAME_DEF_STMT (loop_arg);
1730 if (vect_print_dump_info (REPORT_DETAILS))
1731 fprintf (vect_dump, "reduction: no def_stmt.");
1735 if (!is_gimple_assign (def_stmt) && gimple_code (def_stmt) != GIMPLE_PHI)
1737 if (vect_print_dump_info (REPORT_DETAILS))
1738 print_gimple_stmt (vect_dump, def_stmt, 0, TDF_SLIM);
1742 if (is_gimple_assign (def_stmt))
1744 name = gimple_assign_lhs (def_stmt);
1749 name = PHI_RESULT (def_stmt);
1754 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, name)
1756 gimple use_stmt = USE_STMT (use_p);
1757 if (is_gimple_debug (use_stmt))
1759 if (flow_bb_inside_loop_p (loop, gimple_bb (use_stmt))
1760 && vinfo_for_stmt (use_stmt)
1761 && !is_pattern_stmt_p (vinfo_for_stmt (use_stmt)))
1765 if (vect_print_dump_info (REPORT_DETAILS))
1766 fprintf (vect_dump, "reduction used in loop.");
1771 /* If DEF_STMT is a phi node itself, we expect it to have a single argument
1772 defined in the inner loop. */
1775 op1 = PHI_ARG_DEF (def_stmt, 0);
1777 if (gimple_phi_num_args (def_stmt) != 1
1778 || TREE_CODE (op1) != SSA_NAME)
1780 if (vect_print_dump_info (REPORT_DETAILS))
1781 fprintf (vect_dump, "unsupported phi node definition.");
1786 def1 = SSA_NAME_DEF_STMT (op1);
1787 if (flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))
1789 && flow_bb_inside_loop_p (loop->inner, gimple_bb (def1))
1790 && is_gimple_assign (def1))
1792 if (vect_print_dump_info (REPORT_DETAILS))
1793 report_vect_op (def_stmt, "detected double reduction: ");
1795 *double_reduc = true;
1802 code = orig_code = gimple_assign_rhs_code (def_stmt);
1804 /* We can handle "res -= x[i]", which is non-associative by
1805 simply rewriting this into "res += -x[i]". Avoid changing
1806 gimple instruction for the first simple tests and only do this
1807 if we're allowed to change code at all. */
1808 if (code == MINUS_EXPR
1810 && (op1 = gimple_assign_rhs1 (def_stmt))
1811 && TREE_CODE (op1) == SSA_NAME
1812 && SSA_NAME_DEF_STMT (op1) == phi)
1816 && (!commutative_tree_code (code) || !associative_tree_code (code)))
1818 if (vect_print_dump_info (REPORT_DETAILS))
1819 report_vect_op (def_stmt, "reduction: not commutative/associative: ");
1823 if (get_gimple_rhs_class (code) != GIMPLE_BINARY_RHS)
1825 if (code != COND_EXPR)
1827 if (vect_print_dump_info (REPORT_DETAILS))
1828 report_vect_op (def_stmt, "reduction: not binary operation: ");
1833 op3 = TREE_OPERAND (gimple_assign_rhs1 (def_stmt), 0);
1834 if (COMPARISON_CLASS_P (op3))
1836 op4 = TREE_OPERAND (op3, 1);
1837 op3 = TREE_OPERAND (op3, 0);
1840 op1 = TREE_OPERAND (gimple_assign_rhs1 (def_stmt), 1);
1841 op2 = TREE_OPERAND (gimple_assign_rhs1 (def_stmt), 2);
1843 if (TREE_CODE (op1) != SSA_NAME && TREE_CODE (op2) != SSA_NAME)
1845 if (vect_print_dump_info (REPORT_DETAILS))
1846 report_vect_op (def_stmt, "reduction: uses not ssa_names: ");
1853 op1 = gimple_assign_rhs1 (def_stmt);
1854 op2 = gimple_assign_rhs2 (def_stmt);
1856 if (TREE_CODE (op1) != SSA_NAME || TREE_CODE (op2) != SSA_NAME)
1858 if (vect_print_dump_info (REPORT_DETAILS))
1859 report_vect_op (def_stmt, "reduction: uses not ssa_names: ");
1865 type = TREE_TYPE (gimple_assign_lhs (def_stmt));
1866 if ((TREE_CODE (op1) == SSA_NAME
1867 && !types_compatible_p (type,TREE_TYPE (op1)))
1868 || (TREE_CODE (op2) == SSA_NAME
1869 && !types_compatible_p (type, TREE_TYPE (op2)))
1870 || (op3 && TREE_CODE (op3) == SSA_NAME
1871 && !types_compatible_p (type, TREE_TYPE (op3)))
1872 || (op4 && TREE_CODE (op4) == SSA_NAME
1873 && !types_compatible_p (type, TREE_TYPE (op4))))
1875 if (vect_print_dump_info (REPORT_DETAILS))
1877 fprintf (vect_dump, "reduction: multiple types: operation type: ");
1878 print_generic_expr (vect_dump, type, TDF_SLIM);
1879 fprintf (vect_dump, ", operands types: ");
1880 print_generic_expr (vect_dump, TREE_TYPE (op1), TDF_SLIM);
1881 fprintf (vect_dump, ",");
1882 print_generic_expr (vect_dump, TREE_TYPE (op2), TDF_SLIM);
1885 fprintf (vect_dump, ",");
1886 print_generic_expr (vect_dump, TREE_TYPE (op3), TDF_SLIM);
1891 fprintf (vect_dump, ",");
1892 print_generic_expr (vect_dump, TREE_TYPE (op4), TDF_SLIM);
1899 /* Check that it's ok to change the order of the computation.
1900 Generally, when vectorizing a reduction we change the order of the
1901 computation. This may change the behavior of the program in some
1902 cases, so we need to check that this is ok. One exception is when
1903 vectorizing an outer-loop: the inner-loop is executed sequentially,
1904 and therefore vectorizing reductions in the inner-loop during
1905 outer-loop vectorization is safe. */
1907 /* CHECKME: check for !flag_finite_math_only too? */
1908 if (SCALAR_FLOAT_TYPE_P (type) && !flag_associative_math
1911 /* Changing the order of operations changes the semantics. */
1912 if (vect_print_dump_info (REPORT_DETAILS))
1913 report_vect_op (def_stmt, "reduction: unsafe fp math optimization: ");
1916 else if (INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type)
1919 /* Changing the order of operations changes the semantics. */
1920 if (vect_print_dump_info (REPORT_DETAILS))
1921 report_vect_op (def_stmt, "reduction: unsafe int math optimization: ");
1924 else if (SAT_FIXED_POINT_TYPE_P (type) && check_reduction)
1926 /* Changing the order of operations changes the semantics. */
1927 if (vect_print_dump_info (REPORT_DETAILS))
1928 report_vect_op (def_stmt,
1929 "reduction: unsafe fixed-point math optimization: ");
1933 /* If we detected "res -= x[i]" earlier, rewrite it into
1934 "res += -x[i]" now. If this turns out to be useless reassoc
1935 will clean it up again. */
1936 if (orig_code == MINUS_EXPR)
1938 tree rhs = gimple_assign_rhs2 (def_stmt);
1939 tree negrhs = make_ssa_name (SSA_NAME_VAR (rhs), NULL);
1940 gimple negate_stmt = gimple_build_assign_with_ops (NEGATE_EXPR, negrhs,
1942 gimple_stmt_iterator gsi = gsi_for_stmt (def_stmt);
1943 set_vinfo_for_stmt (negate_stmt, new_stmt_vec_info (negate_stmt,
1945 gsi_insert_before (&gsi, negate_stmt, GSI_NEW_STMT);
1946 gimple_assign_set_rhs2 (def_stmt, negrhs);
1947 gimple_assign_set_rhs_code (def_stmt, PLUS_EXPR);
1948 update_stmt (def_stmt);
1951 /* Reduction is safe. We're dealing with one of the following:
1952 1) integer arithmetic and no trapv
1953 2) floating point arithmetic, and special flags permit this optimization
1954 3) nested cycle (i.e., outer loop vectorization). */
1955 if (TREE_CODE (op1) == SSA_NAME)
1956 def1 = SSA_NAME_DEF_STMT (op1);
1958 if (TREE_CODE (op2) == SSA_NAME)
1959 def2 = SSA_NAME_DEF_STMT (op2);
1961 if (code != COND_EXPR
1962 && (!def1 || !def2 || gimple_nop_p (def1) || gimple_nop_p (def2)))
1964 if (vect_print_dump_info (REPORT_DETAILS))
1965 report_vect_op (def_stmt, "reduction: no defs for operands: ");
1969 /* Check that one def is the reduction def, defined by PHI,
1970 the other def is either defined in the loop ("vect_internal_def"),
1971 or it's an induction (defined by a loop-header phi-node). */
1973 if (def2 && def2 == phi
1974 && (code == COND_EXPR
1975 || (def1 && flow_bb_inside_loop_p (loop, gimple_bb (def1))
1976 && (is_gimple_assign (def1)
1977 || is_gimple_call (def1)
1978 || STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def1))
1979 == vect_induction_def
1980 || (gimple_code (def1) == GIMPLE_PHI
1981 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def1))
1982 == vect_internal_def
1983 && !is_loop_header_bb_p (gimple_bb (def1)))))))
1985 if (vect_print_dump_info (REPORT_DETAILS))
1986 report_vect_op (def_stmt, "detected reduction: ");
1989 else if (def1 && def1 == phi
1990 && (code == COND_EXPR
1991 || (def2 && flow_bb_inside_loop_p (loop, gimple_bb (def2))
1992 && (is_gimple_assign (def2)
1993 || is_gimple_call (def2)
1994 || STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def2))
1995 == vect_induction_def
1996 || (gimple_code (def2) == GIMPLE_PHI
1997 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def2))
1998 == vect_internal_def
1999 && !is_loop_header_bb_p (gimple_bb (def2)))))))
2001 if (check_reduction)
2003 /* Swap operands (just for simplicity - so that the rest of the code
2004 can assume that the reduction variable is always the last (second)
2006 if (vect_print_dump_info (REPORT_DETAILS))
2007 report_vect_op (def_stmt,
2008 "detected reduction: need to swap operands: ");
2010 swap_tree_operands (def_stmt, gimple_assign_rhs1_ptr (def_stmt),
2011 gimple_assign_rhs2_ptr (def_stmt));
2015 if (vect_print_dump_info (REPORT_DETAILS))
2016 report_vect_op (def_stmt, "detected reduction: ");
2023 if (vect_print_dump_info (REPORT_DETAILS))
2024 report_vect_op (def_stmt, "reduction: unknown pattern: ");
2030 /* Wrapper around vect_is_simple_reduction_1, that won't modify code
2031 in-place. Arguments as there. */
2034 vect_is_simple_reduction (loop_vec_info loop_info, gimple phi,
2035 bool check_reduction, bool *double_reduc)
2037 return vect_is_simple_reduction_1 (loop_info, phi, check_reduction,
2038 double_reduc, false);
2041 /* Wrapper around vect_is_simple_reduction_1, which will modify code
2042 in-place if it enables detection of more reductions. Arguments
2046 vect_force_simple_reduction (loop_vec_info loop_info, gimple phi,
2047 bool check_reduction, bool *double_reduc)
2049 return vect_is_simple_reduction_1 (loop_info, phi, check_reduction,
2050 double_reduc, true);
2053 /* Calculate the cost of one scalar iteration of the loop. */
2055 vect_get_single_scalar_iteraion_cost (loop_vec_info loop_vinfo)
2057 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2058 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
2059 int nbbs = loop->num_nodes, factor, scalar_single_iter_cost = 0;
2060 int innerloop_iters, i, stmt_cost;
2062 /* Count statements in scalar loop. Using this as scalar cost for a single
2065 TODO: Add outer loop support.
2067 TODO: Consider assigning different costs to different scalar
2071 innerloop_iters = 1;
2073 innerloop_iters = 50; /* FIXME */
2075 for (i = 0; i < nbbs; i++)
2077 gimple_stmt_iterator si;
2078 basic_block bb = bbs[i];
2080 if (bb->loop_father == loop->inner)
2081 factor = innerloop_iters;
2085 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
2087 gimple stmt = gsi_stmt (si);
2088 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
2090 if (!is_gimple_assign (stmt) && !is_gimple_call (stmt))
2093 /* Skip stmts that are not vectorized inside the loop. */
2095 && !STMT_VINFO_RELEVANT_P (stmt_info)
2096 && (!STMT_VINFO_LIVE_P (stmt_info)
2097 || STMT_VINFO_DEF_TYPE (stmt_info) != vect_reduction_def))
2100 if (STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt)))
2102 if (DR_IS_READ (STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt))))
2103 stmt_cost = vect_get_cost (scalar_load);
2105 stmt_cost = vect_get_cost (scalar_store);
2108 stmt_cost = vect_get_cost (scalar_stmt);
2110 scalar_single_iter_cost += stmt_cost * factor;
2113 return scalar_single_iter_cost;
2116 /* Calculate cost of peeling the loop PEEL_ITERS_PROLOGUE times. */
2118 vect_get_known_peeling_cost (loop_vec_info loop_vinfo, int peel_iters_prologue,
2119 int *peel_iters_epilogue,
2120 int scalar_single_iter_cost)
2122 int peel_guard_costs = 0;
2123 int vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
2125 if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo))
2127 *peel_iters_epilogue = vf/2;
2128 if (vect_print_dump_info (REPORT_COST))
2129 fprintf (vect_dump, "cost model: "
2130 "epilogue peel iters set to vf/2 because "
2131 "loop iterations are unknown .");
2133 /* If peeled iterations are known but number of scalar loop
2134 iterations are unknown, count a taken branch per peeled loop. */
2135 peel_guard_costs = 2 * vect_get_cost (cond_branch_taken);
2139 int niters = LOOP_VINFO_INT_NITERS (loop_vinfo);
2140 peel_iters_prologue = niters < peel_iters_prologue ?
2141 niters : peel_iters_prologue;
2142 *peel_iters_epilogue = (niters - peel_iters_prologue) % vf;
2145 return (peel_iters_prologue * scalar_single_iter_cost)
2146 + (*peel_iters_epilogue * scalar_single_iter_cost)
2150 /* Function vect_estimate_min_profitable_iters
2152 Return the number of iterations required for the vector version of the
2153 loop to be profitable relative to the cost of the scalar version of the
2156 TODO: Take profile info into account before making vectorization
2157 decisions, if available. */
2160 vect_estimate_min_profitable_iters (loop_vec_info loop_vinfo)
2163 int min_profitable_iters;
2164 int peel_iters_prologue;
2165 int peel_iters_epilogue;
2166 int vec_inside_cost = 0;
2167 int vec_outside_cost = 0;
2168 int scalar_single_iter_cost = 0;
2169 int scalar_outside_cost = 0;
2170 int vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
2171 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2172 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
2173 int nbbs = loop->num_nodes;
2174 int npeel = LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo);
2175 int peel_guard_costs = 0;
2176 int innerloop_iters = 0, factor;
2177 VEC (slp_instance, heap) *slp_instances;
2178 slp_instance instance;
2180 /* Cost model disabled. */
2181 if (!flag_vect_cost_model)
2183 if (vect_print_dump_info (REPORT_COST))
2184 fprintf (vect_dump, "cost model disabled.");
2188 /* Requires loop versioning tests to handle misalignment. */
2189 if (LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo))
2191 /* FIXME: Make cost depend on complexity of individual check. */
2193 VEC_length (gimple, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo));
2194 if (vect_print_dump_info (REPORT_COST))
2195 fprintf (vect_dump, "cost model: Adding cost of checks for loop "
2196 "versioning to treat misalignment.\n");
2199 /* Requires loop versioning with alias checks. */
2200 if (LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
2202 /* FIXME: Make cost depend on complexity of individual check. */
2204 VEC_length (ddr_p, LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo));
2205 if (vect_print_dump_info (REPORT_COST))
2206 fprintf (vect_dump, "cost model: Adding cost of checks for loop "
2207 "versioning aliasing.\n");
2210 if (LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)
2211 || LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
2212 vec_outside_cost += vect_get_cost (cond_branch_taken);
2214 /* Count statements in scalar loop. Using this as scalar cost for a single
2217 TODO: Add outer loop support.
2219 TODO: Consider assigning different costs to different scalar
2224 innerloop_iters = 50; /* FIXME */
2226 for (i = 0; i < nbbs; i++)
2228 gimple_stmt_iterator si;
2229 basic_block bb = bbs[i];
2231 if (bb->loop_father == loop->inner)
2232 factor = innerloop_iters;
2236 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
2238 gimple stmt = gsi_stmt (si);
2239 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
2240 /* Skip stmts that are not vectorized inside the loop. */
2241 if (!STMT_VINFO_RELEVANT_P (stmt_info)
2242 && (!STMT_VINFO_LIVE_P (stmt_info)
2243 || STMT_VINFO_DEF_TYPE (stmt_info) != vect_reduction_def))
2245 vec_inside_cost += STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info) * factor;
2246 /* FIXME: for stmts in the inner-loop in outer-loop vectorization,
2247 some of the "outside" costs are generated inside the outer-loop. */
2248 vec_outside_cost += STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info);
2252 scalar_single_iter_cost = vect_get_single_scalar_iteraion_cost (loop_vinfo);
2254 /* Add additional cost for the peeled instructions in prologue and epilogue
2257 FORNOW: If we don't know the value of peel_iters for prologue or epilogue
2258 at compile-time - we assume it's vf/2 (the worst would be vf-1).
2260 TODO: Build an expression that represents peel_iters for prologue and
2261 epilogue to be used in a run-time test. */
2265 peel_iters_prologue = vf/2;
2266 if (vect_print_dump_info (REPORT_COST))
2267 fprintf (vect_dump, "cost model: "
2268 "prologue peel iters set to vf/2.");
2270 /* If peeling for alignment is unknown, loop bound of main loop becomes
2272 peel_iters_epilogue = vf/2;
2273 if (vect_print_dump_info (REPORT_COST))
2274 fprintf (vect_dump, "cost model: "
2275 "epilogue peel iters set to vf/2 because "
2276 "peeling for alignment is unknown .");
2278 /* If peeled iterations are unknown, count a taken branch and a not taken
2279 branch per peeled loop. Even if scalar loop iterations are known,
2280 vector iterations are not known since peeled prologue iterations are
2281 not known. Hence guards remain the same. */
2282 peel_guard_costs += 2 * (vect_get_cost (cond_branch_taken)
2283 + vect_get_cost (cond_branch_not_taken));
2284 vec_outside_cost += (peel_iters_prologue * scalar_single_iter_cost)
2285 + (peel_iters_epilogue * scalar_single_iter_cost)
2290 peel_iters_prologue = npeel;
2291 vec_outside_cost += vect_get_known_peeling_cost (loop_vinfo,
2292 peel_iters_prologue, &peel_iters_epilogue,
2293 scalar_single_iter_cost);
2296 /* FORNOW: The scalar outside cost is incremented in one of the
2299 1. The vectorizer checks for alignment and aliasing and generates
2300 a condition that allows dynamic vectorization. A cost model
2301 check is ANDED with the versioning condition. Hence scalar code
2302 path now has the added cost of the versioning check.
2304 if (cost > th & versioning_check)
2307 Hence run-time scalar is incremented by not-taken branch cost.
2309 2. The vectorizer then checks if a prologue is required. If the
2310 cost model check was not done before during versioning, it has to
2311 be done before the prologue check.
2314 prologue = scalar_iters
2319 if (prologue == num_iters)
2322 Hence the run-time scalar cost is incremented by a taken branch,
2323 plus a not-taken branch, plus a taken branch cost.
2325 3. The vectorizer then checks if an epilogue is required. If the
2326 cost model check was not done before during prologue check, it
2327 has to be done with the epilogue check.
2333 if (prologue == num_iters)
2336 if ((cost <= th) | (scalar_iters-prologue-epilogue == 0))
2339 Hence the run-time scalar cost should be incremented by 2 taken
2342 TODO: The back end may reorder the BBS's differently and reverse
2343 conditions/branch directions. Change the estimates below to
2344 something more reasonable. */
2346 /* If the number of iterations is known and we do not do versioning, we can
2347 decide whether to vectorize at compile time. Hence the scalar version
2348 do not carry cost model guard costs. */
2349 if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
2350 || LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)
2351 || LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
2353 /* Cost model check occurs at versioning. */
2354 if (LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)
2355 || LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
2356 scalar_outside_cost += vect_get_cost (cond_branch_not_taken);
2359 /* Cost model check occurs at prologue generation. */
2360 if (LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo) < 0)
2361 scalar_outside_cost += 2 * vect_get_cost (cond_branch_taken)
2362 + vect_get_cost (cond_branch_not_taken);
2363 /* Cost model check occurs at epilogue generation. */
2365 scalar_outside_cost += 2 * vect_get_cost (cond_branch_taken);
2369 /* Add SLP costs. */
2370 slp_instances = LOOP_VINFO_SLP_INSTANCES (loop_vinfo);
2371 FOR_EACH_VEC_ELT (slp_instance, slp_instances, i, instance)
2373 vec_outside_cost += SLP_INSTANCE_OUTSIDE_OF_LOOP_COST (instance);
2374 vec_inside_cost += SLP_INSTANCE_INSIDE_OF_LOOP_COST (instance);
2377 /* Calculate number of iterations required to make the vector version
2378 profitable, relative to the loop bodies only. The following condition
2380 SIC * niters + SOC > VIC * ((niters-PL_ITERS-EP_ITERS)/VF) + VOC
2382 SIC = scalar iteration cost, VIC = vector iteration cost,
2383 VOC = vector outside cost, VF = vectorization factor,
2384 PL_ITERS = prologue iterations, EP_ITERS= epilogue iterations
2385 SOC = scalar outside cost for run time cost model check. */
2387 if ((scalar_single_iter_cost * vf) > vec_inside_cost)
2389 if (vec_outside_cost <= 0)
2390 min_profitable_iters = 1;
2393 min_profitable_iters = ((vec_outside_cost - scalar_outside_cost) * vf
2394 - vec_inside_cost * peel_iters_prologue
2395 - vec_inside_cost * peel_iters_epilogue)
2396 / ((scalar_single_iter_cost * vf)
2399 if ((scalar_single_iter_cost * vf * min_profitable_iters)
2400 <= ((vec_inside_cost * min_profitable_iters)
2401 + ((vec_outside_cost - scalar_outside_cost) * vf)))
2402 min_profitable_iters++;
2405 /* vector version will never be profitable. */
2408 if (vect_print_dump_info (REPORT_COST))
2409 fprintf (vect_dump, "cost model: the vector iteration cost = %d "
2410 "divided by the scalar iteration cost = %d "
2411 "is greater or equal to the vectorization factor = %d.",
2412 vec_inside_cost, scalar_single_iter_cost, vf);
2416 if (vect_print_dump_info (REPORT_COST))
2418 fprintf (vect_dump, "Cost model analysis: \n");
2419 fprintf (vect_dump, " Vector inside of loop cost: %d\n",
2421 fprintf (vect_dump, " Vector outside of loop cost: %d\n",
2423 fprintf (vect_dump, " Scalar iteration cost: %d\n",
2424 scalar_single_iter_cost);
2425 fprintf (vect_dump, " Scalar outside cost: %d\n", scalar_outside_cost);
2426 fprintf (vect_dump, " prologue iterations: %d\n",
2427 peel_iters_prologue);
2428 fprintf (vect_dump, " epilogue iterations: %d\n",
2429 peel_iters_epilogue);
2430 fprintf (vect_dump, " Calculated minimum iters for profitability: %d\n",
2431 min_profitable_iters);
2434 min_profitable_iters =
2435 min_profitable_iters < vf ? vf : min_profitable_iters;
2437 /* Because the condition we create is:
2438 if (niters <= min_profitable_iters)
2439 then skip the vectorized loop. */
2440 min_profitable_iters--;
2442 if (vect_print_dump_info (REPORT_COST))
2443 fprintf (vect_dump, " Profitability threshold = %d\n",
2444 min_profitable_iters);
2446 return min_profitable_iters;
2450 /* TODO: Close dependency between vect_model_*_cost and vectorizable_*
2451 functions. Design better to avoid maintenance issues. */
2453 /* Function vect_model_reduction_cost.
2455 Models cost for a reduction operation, including the vector ops
2456 generated within the strip-mine loop, the initial definition before
2457 the loop, and the epilogue code that must be generated. */
2460 vect_model_reduction_cost (stmt_vec_info stmt_info, enum tree_code reduc_code,
2464 enum tree_code code;
2467 gimple stmt, orig_stmt;
2469 enum machine_mode mode;
2470 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
2471 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2474 /* Cost of reduction op inside loop. */
2475 STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info)
2476 += ncopies * vect_get_cost (vector_stmt);
2478 stmt = STMT_VINFO_STMT (stmt_info);
2480 switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
2482 case GIMPLE_SINGLE_RHS:
2483 gcc_assert (TREE_OPERAND_LENGTH (gimple_assign_rhs1 (stmt)) == ternary_op);
2484 reduction_op = TREE_OPERAND (gimple_assign_rhs1 (stmt), 2);
2486 case GIMPLE_UNARY_RHS:
2487 reduction_op = gimple_assign_rhs1 (stmt);
2489 case GIMPLE_BINARY_RHS:
2490 reduction_op = gimple_assign_rhs2 (stmt);
2496 vectype = get_vectype_for_scalar_type (TREE_TYPE (reduction_op));
2499 if (vect_print_dump_info (REPORT_COST))
2501 fprintf (vect_dump, "unsupported data-type ");
2502 print_generic_expr (vect_dump, TREE_TYPE (reduction_op), TDF_SLIM);
2507 mode = TYPE_MODE (vectype);
2508 orig_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
2511 orig_stmt = STMT_VINFO_STMT (stmt_info);
2513 code = gimple_assign_rhs_code (orig_stmt);
2515 /* Add in cost for initial definition. */
2516 outer_cost += vect_get_cost (scalar_to_vec);
2518 /* Determine cost of epilogue code.
2520 We have a reduction operator that will reduce the vector in one statement.
2521 Also requires scalar extract. */
2523 if (!nested_in_vect_loop_p (loop, orig_stmt))
2525 if (reduc_code != ERROR_MARK)
2526 outer_cost += vect_get_cost (vector_stmt)
2527 + vect_get_cost (vec_to_scalar);
2530 int vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1);
2532 TYPE_SIZE (TREE_TYPE (gimple_assign_lhs (orig_stmt)));
2533 int element_bitsize = tree_low_cst (bitsize, 1);
2534 int nelements = vec_size_in_bits / element_bitsize;
2536 optab = optab_for_tree_code (code, vectype, optab_default);
2538 /* We have a whole vector shift available. */
2539 if (VECTOR_MODE_P (mode)
2540 && optab_handler (optab, mode) != CODE_FOR_nothing
2541 && optab_handler (vec_shr_optab, mode) != CODE_FOR_nothing)
2542 /* Final reduction via vector shifts and the reduction operator. Also
2543 requires scalar extract. */
2544 outer_cost += ((exact_log2(nelements) * 2)
2545 * vect_get_cost (vector_stmt)
2546 + vect_get_cost (vec_to_scalar));
2548 /* Use extracts and reduction op for final reduction. For N elements,
2549 we have N extracts and N-1 reduction ops. */
2550 outer_cost += ((nelements + nelements - 1)
2551 * vect_get_cost (vector_stmt));
2555 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info) = outer_cost;
2557 if (vect_print_dump_info (REPORT_COST))
2558 fprintf (vect_dump, "vect_model_reduction_cost: inside_cost = %d, "
2559 "outside_cost = %d .", STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info),
2560 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info));
2566 /* Function vect_model_induction_cost.
2568 Models cost for induction operations. */
2571 vect_model_induction_cost (stmt_vec_info stmt_info, int ncopies)
2573 /* loop cost for vec_loop. */
2574 STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info)
2575 = ncopies * vect_get_cost (vector_stmt);
2576 /* prologue cost for vec_init and vec_step. */
2577 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info)
2578 = 2 * vect_get_cost (scalar_to_vec);
2580 if (vect_print_dump_info (REPORT_COST))
2581 fprintf (vect_dump, "vect_model_induction_cost: inside_cost = %d, "
2582 "outside_cost = %d .", STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info),
2583 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info));
2587 /* Function get_initial_def_for_induction
2590 STMT - a stmt that performs an induction operation in the loop.
2591 IV_PHI - the initial value of the induction variable
2594 Return a vector variable, initialized with the first VF values of
2595 the induction variable. E.g., for an iv with IV_PHI='X' and
2596 evolution S, for a vector of 4 units, we want to return:
2597 [X, X + S, X + 2*S, X + 3*S]. */
2600 get_initial_def_for_induction (gimple iv_phi)
2602 stmt_vec_info stmt_vinfo = vinfo_for_stmt (iv_phi);
2603 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
2604 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2608 edge pe = loop_preheader_edge (loop);
2609 struct loop *iv_loop;
2611 tree vec, vec_init, vec_step, t;
2615 gimple init_stmt, induction_phi, new_stmt;
2616 tree induc_def, vec_def, vec_dest;
2617 tree init_expr, step_expr;
2618 int vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
2623 stmt_vec_info phi_info = vinfo_for_stmt (iv_phi);
2624 bool nested_in_vect_loop = false;
2625 gimple_seq stmts = NULL;
2626 imm_use_iterator imm_iter;
2627 use_operand_p use_p;
2631 gimple_stmt_iterator si;
2632 basic_block bb = gimple_bb (iv_phi);
2636 /* Is phi in an inner-loop, while vectorizing an enclosing outer-loop? */
2637 if (nested_in_vect_loop_p (loop, iv_phi))
2639 nested_in_vect_loop = true;
2640 iv_loop = loop->inner;
2644 gcc_assert (iv_loop == (gimple_bb (iv_phi))->loop_father);
2646 latch_e = loop_latch_edge (iv_loop);
2647 loop_arg = PHI_ARG_DEF_FROM_EDGE (iv_phi, latch_e);
2649 access_fn = analyze_scalar_evolution (iv_loop, PHI_RESULT (iv_phi));
2650 gcc_assert (access_fn);
2651 STRIP_NOPS (access_fn);
2652 ok = vect_is_simple_iv_evolution (iv_loop->num, access_fn,
2653 &init_expr, &step_expr);
2655 pe = loop_preheader_edge (iv_loop);
2657 scalar_type = TREE_TYPE (init_expr);
2658 vectype = get_vectype_for_scalar_type (scalar_type);
2659 resvectype = get_vectype_for_scalar_type (TREE_TYPE (PHI_RESULT (iv_phi)));
2660 gcc_assert (vectype);
2661 nunits = TYPE_VECTOR_SUBPARTS (vectype);
2662 ncopies = vf / nunits;
2664 gcc_assert (phi_info);
2665 gcc_assert (ncopies >= 1);
2667 /* Find the first insertion point in the BB. */
2668 si = gsi_after_labels (bb);
2670 /* Create the vector that holds the initial_value of the induction. */
2671 if (nested_in_vect_loop)
2673 /* iv_loop is nested in the loop to be vectorized. init_expr had already
2674 been created during vectorization of previous stmts. We obtain it
2675 from the STMT_VINFO_VEC_STMT of the defining stmt. */
2676 tree iv_def = PHI_ARG_DEF_FROM_EDGE (iv_phi,
2677 loop_preheader_edge (iv_loop));
2678 vec_init = vect_get_vec_def_for_operand (iv_def, iv_phi, NULL);
2682 /* iv_loop is the loop to be vectorized. Create:
2683 vec_init = [X, X+S, X+2*S, X+3*S] (S = step_expr, X = init_expr) */
2684 new_var = vect_get_new_vect_var (scalar_type, vect_scalar_var, "var_");
2685 add_referenced_var (new_var);
2687 new_name = force_gimple_operand (init_expr, &stmts, false, new_var);
2690 new_bb = gsi_insert_seq_on_edge_immediate (pe, stmts);
2691 gcc_assert (!new_bb);
2695 t = tree_cons (NULL_TREE, new_name, t);
2696 for (i = 1; i < nunits; i++)
2698 /* Create: new_name_i = new_name + step_expr */
2699 enum tree_code code = POINTER_TYPE_P (scalar_type)
2700 ? POINTER_PLUS_EXPR : PLUS_EXPR;
2701 init_stmt = gimple_build_assign_with_ops (code, new_var,
2702 new_name, step_expr);
2703 new_name = make_ssa_name (new_var, init_stmt);
2704 gimple_assign_set_lhs (init_stmt, new_name);
2706 new_bb = gsi_insert_on_edge_immediate (pe, init_stmt);
2707 gcc_assert (!new_bb);
2709 if (vect_print_dump_info (REPORT_DETAILS))
2711 fprintf (vect_dump, "created new init_stmt: ");
2712 print_gimple_stmt (vect_dump, init_stmt, 0, TDF_SLIM);
2714 t = tree_cons (NULL_TREE, new_name, t);
2716 /* Create a vector from [new_name_0, new_name_1, ..., new_name_nunits-1] */
2717 vec = build_constructor_from_list (vectype, nreverse (t));
2718 vec_init = vect_init_vector (iv_phi, vec, vectype, NULL);
2722 /* Create the vector that holds the step of the induction. */
2723 if (nested_in_vect_loop)
2724 /* iv_loop is nested in the loop to be vectorized. Generate:
2725 vec_step = [S, S, S, S] */
2726 new_name = step_expr;
2729 /* iv_loop is the loop to be vectorized. Generate:
2730 vec_step = [VF*S, VF*S, VF*S, VF*S] */
2731 expr = build_int_cst (TREE_TYPE (step_expr), vf);
2732 new_name = fold_build2 (MULT_EXPR, TREE_TYPE (step_expr),
2736 t = unshare_expr (new_name);
2737 gcc_assert (CONSTANT_CLASS_P (new_name));
2738 stepvectype = get_vectype_for_scalar_type (TREE_TYPE (new_name));
2739 gcc_assert (stepvectype);
2740 vec = build_vector_from_val (stepvectype, t);
2741 vec_step = vect_init_vector (iv_phi, vec, stepvectype, NULL);
2744 /* Create the following def-use cycle:
2749 vec_iv = PHI <vec_init, vec_loop>
2753 vec_loop = vec_iv + vec_step; */
2755 /* Create the induction-phi that defines the induction-operand. */
2756 vec_dest = vect_get_new_vect_var (vectype, vect_simple_var, "vec_iv_");
2757 add_referenced_var (vec_dest);
2758 induction_phi = create_phi_node (vec_dest, iv_loop->header);
2759 set_vinfo_for_stmt (induction_phi,
2760 new_stmt_vec_info (induction_phi, loop_vinfo, NULL));
2761 induc_def = PHI_RESULT (induction_phi);
2763 /* Create the iv update inside the loop */
2764 new_stmt = gimple_build_assign_with_ops (PLUS_EXPR, vec_dest,
2765 induc_def, vec_step);
2766 vec_def = make_ssa_name (vec_dest, new_stmt);
2767 gimple_assign_set_lhs (new_stmt, vec_def);
2768 gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
2769 set_vinfo_for_stmt (new_stmt, new_stmt_vec_info (new_stmt, loop_vinfo,
2772 /* Set the arguments of the phi node: */
2773 add_phi_arg (induction_phi, vec_init, pe, UNKNOWN_LOCATION);
2774 add_phi_arg (induction_phi, vec_def, loop_latch_edge (iv_loop),
2778 /* In case that vectorization factor (VF) is bigger than the number
2779 of elements that we can fit in a vectype (nunits), we have to generate
2780 more than one vector stmt - i.e - we need to "unroll" the
2781 vector stmt by a factor VF/nunits. For more details see documentation
2782 in vectorizable_operation. */
2786 stmt_vec_info prev_stmt_vinfo;
2787 /* FORNOW. This restriction should be relaxed. */
2788 gcc_assert (!nested_in_vect_loop);
2790 /* Create the vector that holds the step of the induction. */
2791 expr = build_int_cst (TREE_TYPE (step_expr), nunits);
2792 new_name = fold_build2 (MULT_EXPR, TREE_TYPE (step_expr),
2794 t = unshare_expr (new_name);
2795 gcc_assert (CONSTANT_CLASS_P (new_name));
2796 vec = build_vector_from_val (stepvectype, t);
2797 vec_step = vect_init_vector (iv_phi, vec, stepvectype, NULL);
2799 vec_def = induc_def;
2800 prev_stmt_vinfo = vinfo_for_stmt (induction_phi);
2801 for (i = 1; i < ncopies; i++)
2803 /* vec_i = vec_prev + vec_step */
2804 new_stmt = gimple_build_assign_with_ops (PLUS_EXPR, vec_dest,
2806 vec_def = make_ssa_name (vec_dest, new_stmt);
2807 gimple_assign_set_lhs (new_stmt, vec_def);
2809 gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
2810 if (!useless_type_conversion_p (resvectype, vectype))
2812 new_stmt = gimple_build_assign_with_ops
2814 vect_get_new_vect_var (resvectype, vect_simple_var,
2816 build1 (VIEW_CONVERT_EXPR, resvectype,
2817 gimple_assign_lhs (new_stmt)), NULL_TREE);
2818 gimple_assign_set_lhs (new_stmt,
2820 (gimple_assign_lhs (new_stmt), new_stmt));
2821 gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
2823 set_vinfo_for_stmt (new_stmt,
2824 new_stmt_vec_info (new_stmt, loop_vinfo, NULL));
2825 STMT_VINFO_RELATED_STMT (prev_stmt_vinfo) = new_stmt;
2826 prev_stmt_vinfo = vinfo_for_stmt (new_stmt);
2830 if (nested_in_vect_loop)
2832 /* Find the loop-closed exit-phi of the induction, and record
2833 the final vector of induction results: */
2835 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, loop_arg)
2837 if (!flow_bb_inside_loop_p (iv_loop, gimple_bb (USE_STMT (use_p))))
2839 exit_phi = USE_STMT (use_p);
2845 stmt_vec_info stmt_vinfo = vinfo_for_stmt (exit_phi);
2846 /* FORNOW. Currently not supporting the case that an inner-loop induction
2847 is not used in the outer-loop (i.e. only outside the outer-loop). */
2848 gcc_assert (STMT_VINFO_RELEVANT_P (stmt_vinfo)
2849 && !STMT_VINFO_LIVE_P (stmt_vinfo));
2851 STMT_VINFO_VEC_STMT (stmt_vinfo) = new_stmt;
2852 if (vect_print_dump_info (REPORT_DETAILS))
2854 fprintf (vect_dump, "vector of inductions after inner-loop:");
2855 print_gimple_stmt (vect_dump, new_stmt, 0, TDF_SLIM);
2861 if (vect_print_dump_info (REPORT_DETAILS))
2863 fprintf (vect_dump, "transform induction: created def-use cycle: ");
2864 print_gimple_stmt (vect_dump, induction_phi, 0, TDF_SLIM);
2865 fprintf (vect_dump, "\n");
2866 print_gimple_stmt (vect_dump, SSA_NAME_DEF_STMT (vec_def), 0, TDF_SLIM);
2869 STMT_VINFO_VEC_STMT (phi_info) = induction_phi;
2870 if (!useless_type_conversion_p (resvectype, vectype))
2872 new_stmt = gimple_build_assign_with_ops
2874 vect_get_new_vect_var (resvectype, vect_simple_var, "vec_iv_"),
2875 build1 (VIEW_CONVERT_EXPR, resvectype, induc_def), NULL_TREE);
2876 induc_def = make_ssa_name (gimple_assign_lhs (new_stmt), new_stmt);
2877 gimple_assign_set_lhs (new_stmt, induc_def);
2878 si = gsi_start_bb (bb);
2879 gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
2886 /* Function get_initial_def_for_reduction
2889 STMT - a stmt that performs a reduction operation in the loop.
2890 INIT_VAL - the initial value of the reduction variable
2893 ADJUSTMENT_DEF - a tree that holds a value to be added to the final result
2894 of the reduction (used for adjusting the epilog - see below).
2895 Return a vector variable, initialized according to the operation that STMT
2896 performs. This vector will be used as the initial value of the
2897 vector of partial results.
2899 Option1 (adjust in epilog): Initialize the vector as follows:
2900 add/bit or/xor: [0,0,...,0,0]
2901 mult/bit and: [1,1,...,1,1]
2902 min/max/cond_expr: [init_val,init_val,..,init_val,init_val]
2903 and when necessary (e.g. add/mult case) let the caller know
2904 that it needs to adjust the result by init_val.
2906 Option2: Initialize the vector as follows:
2907 add/bit or/xor: [init_val,0,0,...,0]
2908 mult/bit and: [init_val,1,1,...,1]
2909 min/max/cond_expr: [init_val,init_val,...,init_val]
2910 and no adjustments are needed.
2912 For example, for the following code:
2918 STMT is 's = s + a[i]', and the reduction variable is 's'.
2919 For a vector of 4 units, we want to return either [0,0,0,init_val],
2920 or [0,0,0,0] and let the caller know that it needs to adjust
2921 the result at the end by 'init_val'.
2923 FORNOW, we are using the 'adjust in epilog' scheme, because this way the
2924 initialization vector is simpler (same element in all entries), if
2925 ADJUSTMENT_DEF is not NULL, and Option2 otherwise.
2927 A cost model should help decide between these two schemes. */
2930 get_initial_def_for_reduction (gimple stmt, tree init_val,
2931 tree *adjustment_def)
2933 stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt);
2934 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
2935 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2936 tree scalar_type = TREE_TYPE (init_val);
2937 tree vectype = get_vectype_for_scalar_type (scalar_type);
2939 enum tree_code code = gimple_assign_rhs_code (stmt);
2944 bool nested_in_vect_loop = false;
2946 REAL_VALUE_TYPE real_init_val = dconst0;
2947 int int_init_val = 0;
2948 gimple def_stmt = NULL;
2950 gcc_assert (vectype);
2951 nunits = TYPE_VECTOR_SUBPARTS (vectype);
2953 gcc_assert (POINTER_TYPE_P (scalar_type) || INTEGRAL_TYPE_P (scalar_type)
2954 || SCALAR_FLOAT_TYPE_P (scalar_type));
2956 if (nested_in_vect_loop_p (loop, stmt))
2957 nested_in_vect_loop = true;
2959 gcc_assert (loop == (gimple_bb (stmt))->loop_father);
2961 /* In case of double reduction we only create a vector variable to be put
2962 in the reduction phi node. The actual statement creation is done in
2963 vect_create_epilog_for_reduction. */
2964 if (adjustment_def && nested_in_vect_loop
2965 && TREE_CODE (init_val) == SSA_NAME
2966 && (def_stmt = SSA_NAME_DEF_STMT (init_val))
2967 && gimple_code (def_stmt) == GIMPLE_PHI
2968 && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))
2969 && vinfo_for_stmt (def_stmt)
2970 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def_stmt))
2971 == vect_double_reduction_def)
2973 *adjustment_def = NULL;
2974 return vect_create_destination_var (init_val, vectype);
2977 if (TREE_CONSTANT (init_val))
2979 if (SCALAR_FLOAT_TYPE_P (scalar_type))
2980 init_value = build_real (scalar_type, TREE_REAL_CST (init_val));
2982 init_value = build_int_cst (scalar_type, TREE_INT_CST_LOW (init_val));
2985 init_value = init_val;
2989 case WIDEN_SUM_EXPR:
2997 /* ADJUSMENT_DEF is NULL when called from
2998 vect_create_epilog_for_reduction to vectorize double reduction. */
3001 if (nested_in_vect_loop)
3002 *adjustment_def = vect_get_vec_def_for_operand (init_val, stmt,
3005 *adjustment_def = init_val;
3008 if (code == MULT_EXPR)
3010 real_init_val = dconst1;
3014 if (code == BIT_AND_EXPR)
3017 if (SCALAR_FLOAT_TYPE_P (scalar_type))
3018 def_for_init = build_real (scalar_type, real_init_val);
3020 def_for_init = build_int_cst (scalar_type, int_init_val);
3022 /* Create a vector of '0' or '1' except the first element. */
3023 for (i = nunits - 2; i >= 0; --i)
3024 t = tree_cons (NULL_TREE, def_for_init, t);
3026 /* Option1: the first element is '0' or '1' as well. */
3029 t = tree_cons (NULL_TREE, def_for_init, t);
3030 init_def = build_vector (vectype, t);
3034 /* Option2: the first element is INIT_VAL. */
3035 t = tree_cons (NULL_TREE, init_value, t);
3036 if (TREE_CONSTANT (init_val))
3037 init_def = build_vector (vectype, t);
3039 init_def = build_constructor_from_list (vectype, t);
3048 *adjustment_def = NULL_TREE;
3049 init_def = vect_get_vec_def_for_operand (init_val, stmt, NULL);
3053 init_def = build_vector_from_val (vectype, init_value);
3064 /* Function vect_create_epilog_for_reduction
3066 Create code at the loop-epilog to finalize the result of a reduction
3069 VECT_DEFS is list of vector of partial results, i.e., the lhs's of vector
3070 reduction statements.
3071 STMT is the scalar reduction stmt that is being vectorized.
3072 NCOPIES is > 1 in case the vectorization factor (VF) is bigger than the
3073 number of elements that we can fit in a vectype (nunits). In this case
3074 we have to generate more than one vector stmt - i.e - we need to "unroll"
3075 the vector stmt by a factor VF/nunits. For more details see documentation
3076 in vectorizable_operation.
3077 REDUC_CODE is the tree-code for the epilog reduction.
3078 REDUCTION_PHIS is a list of the phi-nodes that carry the reduction
3080 REDUC_INDEX is the index of the operand in the right hand side of the
3081 statement that is defined by REDUCTION_PHI.
3082 DOUBLE_REDUC is TRUE if double reduction phi nodes should be handled.
3083 SLP_NODE is an SLP node containing a group of reduction statements. The
3084 first one in this group is STMT.
3087 1. Creates the reduction def-use cycles: sets the arguments for
3089 The loop-entry argument is the vectorized initial-value of the reduction.
3090 The loop-latch argument is taken from VECT_DEFS - the vector of partial
3092 2. "Reduces" each vector of partial results VECT_DEFS into a single result,
3093 by applying the operation specified by REDUC_CODE if available, or by
3094 other means (whole-vector shifts or a scalar loop).
3095 The function also creates a new phi node at the loop exit to preserve
3096 loop-closed form, as illustrated below.
3098 The flow at the entry to this function:
3101 vec_def = phi <null, null> # REDUCTION_PHI
3102 VECT_DEF = vector_stmt # vectorized form of STMT
3103 s_loop = scalar_stmt # (scalar) STMT
3105 s_out0 = phi <s_loop> # (scalar) EXIT_PHI
3109 The above is transformed by this function into:
3112 vec_def = phi <vec_init, VECT_DEF> # REDUCTION_PHI
3113 VECT_DEF = vector_stmt # vectorized form of STMT
3114 s_loop = scalar_stmt # (scalar) STMT
3116 s_out0 = phi <s_loop> # (scalar) EXIT_PHI
3117 v_out1 = phi <VECT_DEF> # NEW_EXIT_PHI
3118 v_out2 = reduce <v_out1>
3119 s_out3 = extract_field <v_out2, 0>
3120 s_out4 = adjust_result <s_out3>
3126 vect_create_epilog_for_reduction (VEC (tree, heap) *vect_defs, gimple stmt,
3127 int ncopies, enum tree_code reduc_code,
3128 VEC (gimple, heap) *reduction_phis,
3129 int reduc_index, bool double_reduc,
3132 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
3133 stmt_vec_info prev_phi_info;
3135 enum machine_mode mode;
3136 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
3137 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo), *outer_loop = NULL;
3138 basic_block exit_bb;
3141 gimple new_phi = NULL, phi;
3142 gimple_stmt_iterator exit_gsi;
3144 tree new_temp = NULL_TREE, new_dest, new_name, new_scalar_dest;
3145 gimple epilog_stmt = NULL;
3146 enum tree_code code = gimple_assign_rhs_code (stmt);
3148 tree bitsize, bitpos;
3149 tree adjustment_def = NULL;
3150 tree vec_initial_def = NULL;
3151 tree reduction_op, expr, def;
3152 tree orig_name, scalar_result;
3153 imm_use_iterator imm_iter, phi_imm_iter;
3154 use_operand_p use_p, phi_use_p;
3155 bool extract_scalar_result = false;
3156 gimple use_stmt, orig_stmt, reduction_phi = NULL;
3157 bool nested_in_vect_loop = false;
3158 VEC (gimple, heap) *new_phis = NULL;
3159 enum vect_def_type dt = vect_unknown_def_type;
3161 VEC (tree, heap) *scalar_results = NULL;
3162 unsigned int group_size = 1, k, ratio;
3163 VEC (tree, heap) *vec_initial_defs = NULL;
3164 VEC (gimple, heap) *phis;
3167 group_size = VEC_length (gimple, SLP_TREE_SCALAR_STMTS (slp_node));
3169 if (nested_in_vect_loop_p (loop, stmt))
3173 nested_in_vect_loop = true;
3174 gcc_assert (!slp_node);
3177 switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
3179 case GIMPLE_SINGLE_RHS:
3180 gcc_assert (TREE_OPERAND_LENGTH (gimple_assign_rhs1 (stmt))
3182 reduction_op = TREE_OPERAND (gimple_assign_rhs1 (stmt), reduc_index);
3184 case GIMPLE_UNARY_RHS:
3185 reduction_op = gimple_assign_rhs1 (stmt);
3187 case GIMPLE_BINARY_RHS:
3188 reduction_op = reduc_index ?
3189 gimple_assign_rhs2 (stmt) : gimple_assign_rhs1 (stmt);
3195 vectype = get_vectype_for_scalar_type (TREE_TYPE (reduction_op));
3196 gcc_assert (vectype);
3197 mode = TYPE_MODE (vectype);
3199 /* 1. Create the reduction def-use cycle:
3200 Set the arguments of REDUCTION_PHIS, i.e., transform
3203 vec_def = phi <null, null> # REDUCTION_PHI
3204 VECT_DEF = vector_stmt # vectorized form of STMT
3210 vec_def = phi <vec_init, VECT_DEF> # REDUCTION_PHI
3211 VECT_DEF = vector_stmt # vectorized form of STMT
3214 (in case of SLP, do it for all the phis). */
3216 /* Get the loop-entry arguments. */
3218 vect_get_slp_defs (reduction_op, NULL_TREE, slp_node, &vec_initial_defs,
3222 vec_initial_defs = VEC_alloc (tree, heap, 1);
3223 /* For the case of reduction, vect_get_vec_def_for_operand returns
3224 the scalar def before the loop, that defines the initial value
3225 of the reduction variable. */
3226 vec_initial_def = vect_get_vec_def_for_operand (reduction_op, stmt,
3228 VEC_quick_push (tree, vec_initial_defs, vec_initial_def);
3231 /* Set phi nodes arguments. */
3232 FOR_EACH_VEC_ELT (gimple, reduction_phis, i, phi)
3234 tree vec_init_def = VEC_index (tree, vec_initial_defs, i);
3235 tree def = VEC_index (tree, vect_defs, i);
3236 for (j = 0; j < ncopies; j++)
3238 /* Set the loop-entry arg of the reduction-phi. */
3239 add_phi_arg (phi, vec_init_def, loop_preheader_edge (loop),
3242 /* Set the loop-latch arg for the reduction-phi. */
3244 def = vect_get_vec_def_for_stmt_copy (vect_unknown_def_type, def);
3246 add_phi_arg (phi, def, loop_latch_edge (loop), UNKNOWN_LOCATION);
3248 if (vect_print_dump_info (REPORT_DETAILS))
3250 fprintf (vect_dump, "transform reduction: created def-use"
3252 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
3253 fprintf (vect_dump, "\n");
3254 print_gimple_stmt (vect_dump, SSA_NAME_DEF_STMT (def), 0,
3258 phi = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (phi));
3262 VEC_free (tree, heap, vec_initial_defs);
3264 /* 2. Create epilog code.
3265 The reduction epilog code operates across the elements of the vector
3266 of partial results computed by the vectorized loop.
3267 The reduction epilog code consists of:
3269 step 1: compute the scalar result in a vector (v_out2)
3270 step 2: extract the scalar result (s_out3) from the vector (v_out2)
3271 step 3: adjust the scalar result (s_out3) if needed.
3273 Step 1 can be accomplished using one the following three schemes:
3274 (scheme 1) using reduc_code, if available.
3275 (scheme 2) using whole-vector shifts, if available.
3276 (scheme 3) using a scalar loop. In this case steps 1+2 above are
3279 The overall epilog code looks like this:
3281 s_out0 = phi <s_loop> # original EXIT_PHI
3282 v_out1 = phi <VECT_DEF> # NEW_EXIT_PHI
3283 v_out2 = reduce <v_out1> # step 1
3284 s_out3 = extract_field <v_out2, 0> # step 2
3285 s_out4 = adjust_result <s_out3> # step 3
3287 (step 3 is optional, and steps 1 and 2 may be combined).
3288 Lastly, the uses of s_out0 are replaced by s_out4. */
3291 /* 2.1 Create new loop-exit-phis to preserve loop-closed form:
3292 v_out1 = phi <VECT_DEF>
3293 Store them in NEW_PHIS. */
3295 exit_bb = single_exit (loop)->dest;
3296 prev_phi_info = NULL;
3297 new_phis = VEC_alloc (gimple, heap, VEC_length (tree, vect_defs));
3298 FOR_EACH_VEC_ELT (tree, vect_defs, i, def)
3300 for (j = 0; j < ncopies; j++)
3302 phi = create_phi_node (SSA_NAME_VAR (def), exit_bb);
3303 set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, loop_vinfo, NULL));
3305 VEC_quick_push (gimple, new_phis, phi);
3308 def = vect_get_vec_def_for_stmt_copy (dt, def);
3309 STMT_VINFO_RELATED_STMT (prev_phi_info) = phi;
3312 SET_PHI_ARG_DEF (phi, single_exit (loop)->dest_idx, def);
3313 prev_phi_info = vinfo_for_stmt (phi);
3317 /* The epilogue is created for the outer-loop, i.e., for the loop being
3322 exit_bb = single_exit (loop)->dest;
3325 exit_gsi = gsi_after_labels (exit_bb);
3327 /* 2.2 Get the relevant tree-code to use in the epilog for schemes 2,3
3328 (i.e. when reduc_code is not available) and in the final adjustment
3329 code (if needed). Also get the original scalar reduction variable as
3330 defined in the loop. In case STMT is a "pattern-stmt" (i.e. - it
3331 represents a reduction pattern), the tree-code and scalar-def are
3332 taken from the original stmt that the pattern-stmt (STMT) replaces.
3333 Otherwise (it is a regular reduction) - the tree-code and scalar-def
3334 are taken from STMT. */
3336 orig_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
3339 /* Regular reduction */
3344 /* Reduction pattern */
3345 stmt_vec_info stmt_vinfo = vinfo_for_stmt (orig_stmt);
3346 gcc_assert (STMT_VINFO_IN_PATTERN_P (stmt_vinfo));
3347 gcc_assert (STMT_VINFO_RELATED_STMT (stmt_vinfo) == stmt);
3350 code = gimple_assign_rhs_code (orig_stmt);
3351 /* For MINUS_EXPR the initial vector is [init_val,0,...,0], therefore,
3352 partial results are added and not subtracted. */
3353 if (code == MINUS_EXPR)
3356 scalar_dest = gimple_assign_lhs (orig_stmt);
3357 scalar_type = TREE_TYPE (scalar_dest);
3358 scalar_results = VEC_alloc (tree, heap, group_size);
3359 new_scalar_dest = vect_create_destination_var (scalar_dest, NULL);
3360 bitsize = TYPE_SIZE (scalar_type);
3362 /* In case this is a reduction in an inner-loop while vectorizing an outer
3363 loop - we don't need to extract a single scalar result at the end of the
3364 inner-loop (unless it is double reduction, i.e., the use of reduction is
3365 outside the outer-loop). The final vector of partial results will be used
3366 in the vectorized outer-loop, or reduced to a scalar result at the end of
3368 if (nested_in_vect_loop && !double_reduc)
3369 goto vect_finalize_reduction;
3371 /* 2.3 Create the reduction code, using one of the three schemes described
3372 above. In SLP we simply need to extract all the elements from the
3373 vector (without reducing them), so we use scalar shifts. */
3374 if (reduc_code != ERROR_MARK && !slp_node)
3378 /*** Case 1: Create:
3379 v_out2 = reduc_expr <v_out1> */
3381 if (vect_print_dump_info (REPORT_DETAILS))
3382 fprintf (vect_dump, "Reduce using direct vector reduction.");
3384 vec_dest = vect_create_destination_var (scalar_dest, vectype);
3385 new_phi = VEC_index (gimple, new_phis, 0);
3386 tmp = build1 (reduc_code, vectype, PHI_RESULT (new_phi));
3387 epilog_stmt = gimple_build_assign (vec_dest, tmp);
3388 new_temp = make_ssa_name (vec_dest, epilog_stmt);
3389 gimple_assign_set_lhs (epilog_stmt, new_temp);
3390 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3392 extract_scalar_result = true;
3396 enum tree_code shift_code = ERROR_MARK;
3397 bool have_whole_vector_shift = true;
3399 int element_bitsize = tree_low_cst (bitsize, 1);
3400 int vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1);
3403 if (optab_handler (vec_shr_optab, mode) != CODE_FOR_nothing)
3404 shift_code = VEC_RSHIFT_EXPR;
3406 have_whole_vector_shift = false;
3408 /* Regardless of whether we have a whole vector shift, if we're
3409 emulating the operation via tree-vect-generic, we don't want
3410 to use it. Only the first round of the reduction is likely
3411 to still be profitable via emulation. */
3412 /* ??? It might be better to emit a reduction tree code here, so that
3413 tree-vect-generic can expand the first round via bit tricks. */
3414 if (!VECTOR_MODE_P (mode))
3415 have_whole_vector_shift = false;
3418 optab optab = optab_for_tree_code (code, vectype, optab_default);
3419 if (optab_handler (optab, mode) == CODE_FOR_nothing)
3420 have_whole_vector_shift = false;
3423 if (have_whole_vector_shift && !slp_node)
3425 /*** Case 2: Create:
3426 for (offset = VS/2; offset >= element_size; offset/=2)
3428 Create: va' = vec_shift <va, offset>
3429 Create: va = vop <va, va'>
3432 if (vect_print_dump_info (REPORT_DETAILS))
3433 fprintf (vect_dump, "Reduce using vector shifts");
3435 vec_dest = vect_create_destination_var (scalar_dest, vectype);
3436 new_phi = VEC_index (gimple, new_phis, 0);
3437 new_temp = PHI_RESULT (new_phi);
3438 for (bit_offset = vec_size_in_bits/2;
3439 bit_offset >= element_bitsize;
3442 tree bitpos = size_int (bit_offset);
3444 epilog_stmt = gimple_build_assign_with_ops (shift_code,
3445 vec_dest, new_temp, bitpos);
3446 new_name = make_ssa_name (vec_dest, epilog_stmt);
3447 gimple_assign_set_lhs (epilog_stmt, new_name);
3448 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3450 epilog_stmt = gimple_build_assign_with_ops (code, vec_dest,
3451 new_name, new_temp);
3452 new_temp = make_ssa_name (vec_dest, epilog_stmt);
3453 gimple_assign_set_lhs (epilog_stmt, new_temp);
3454 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3457 extract_scalar_result = true;
3463 /*** Case 3: Create:
3464 s = extract_field <v_out2, 0>
3465 for (offset = element_size;
3466 offset < vector_size;
3467 offset += element_size;)
3469 Create: s' = extract_field <v_out2, offset>
3470 Create: s = op <s, s'> // For non SLP cases
3473 if (vect_print_dump_info (REPORT_DETAILS))
3474 fprintf (vect_dump, "Reduce using scalar code. ");
3476 vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1);
3477 FOR_EACH_VEC_ELT (gimple, new_phis, i, new_phi)
3479 vec_temp = PHI_RESULT (new_phi);
3480 rhs = build3 (BIT_FIELD_REF, scalar_type, vec_temp, bitsize,
3482 epilog_stmt = gimple_build_assign (new_scalar_dest, rhs);
3483 new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
3484 gimple_assign_set_lhs (epilog_stmt, new_temp);
3485 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3487 /* In SLP we don't need to apply reduction operation, so we just
3488 collect s' values in SCALAR_RESULTS. */
3490 VEC_safe_push (tree, heap, scalar_results, new_temp);
3492 for (bit_offset = element_bitsize;
3493 bit_offset < vec_size_in_bits;
3494 bit_offset += element_bitsize)
3496 tree bitpos = bitsize_int (bit_offset);
3497 tree rhs = build3 (BIT_FIELD_REF, scalar_type, vec_temp,
3500 epilog_stmt = gimple_build_assign (new_scalar_dest, rhs);
3501 new_name = make_ssa_name (new_scalar_dest, epilog_stmt);
3502 gimple_assign_set_lhs (epilog_stmt, new_name);
3503 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3507 /* In SLP we don't need to apply reduction operation, so
3508 we just collect s' values in SCALAR_RESULTS. */
3509 new_temp = new_name;
3510 VEC_safe_push (tree, heap, scalar_results, new_name);
3514 epilog_stmt = gimple_build_assign_with_ops (code,
3515 new_scalar_dest, new_name, new_temp);
3516 new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
3517 gimple_assign_set_lhs (epilog_stmt, new_temp);
3518 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3523 /* The only case where we need to reduce scalar results in SLP, is
3524 unrolling. If the size of SCALAR_RESULTS is greater than
3525 GROUP_SIZE, we reduce them combining elements modulo
3529 tree res, first_res, new_res;
3532 /* Reduce multiple scalar results in case of SLP unrolling. */
3533 for (j = group_size; VEC_iterate (tree, scalar_results, j, res);
3536 first_res = VEC_index (tree, scalar_results, j % group_size);
3537 new_stmt = gimple_build_assign_with_ops (code,
3538 new_scalar_dest, first_res, res);
3539 new_res = make_ssa_name (new_scalar_dest, new_stmt);
3540 gimple_assign_set_lhs (new_stmt, new_res);
3541 gsi_insert_before (&exit_gsi, new_stmt, GSI_SAME_STMT);
3542 VEC_replace (tree, scalar_results, j % group_size, new_res);
3546 /* Not SLP - we have one scalar to keep in SCALAR_RESULTS. */
3547 VEC_safe_push (tree, heap, scalar_results, new_temp);
3549 extract_scalar_result = false;
3553 /* 2.4 Extract the final scalar result. Create:
3554 s_out3 = extract_field <v_out2, bitpos> */
3556 if (extract_scalar_result)
3560 if (vect_print_dump_info (REPORT_DETAILS))
3561 fprintf (vect_dump, "extract scalar result");
3563 if (BYTES_BIG_ENDIAN)
3564 bitpos = size_binop (MULT_EXPR,
3565 bitsize_int (TYPE_VECTOR_SUBPARTS (vectype) - 1),
3566 TYPE_SIZE (scalar_type));
3568 bitpos = bitsize_zero_node;
3570 rhs = build3 (BIT_FIELD_REF, scalar_type, new_temp, bitsize, bitpos);
3571 epilog_stmt = gimple_build_assign (new_scalar_dest, rhs);
3572 new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
3573 gimple_assign_set_lhs (epilog_stmt, new_temp);
3574 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3575 VEC_safe_push (tree, heap, scalar_results, new_temp);
3578 vect_finalize_reduction:
3583 /* 2.5 Adjust the final result by the initial value of the reduction
3584 variable. (When such adjustment is not needed, then
3585 'adjustment_def' is zero). For example, if code is PLUS we create:
3586 new_temp = loop_exit_def + adjustment_def */
3590 gcc_assert (!slp_node);
3591 if (nested_in_vect_loop)
3593 new_phi = VEC_index (gimple, new_phis, 0);
3594 gcc_assert (TREE_CODE (TREE_TYPE (adjustment_def)) == VECTOR_TYPE);
3595 expr = build2 (code, vectype, PHI_RESULT (new_phi), adjustment_def);
3596 new_dest = vect_create_destination_var (scalar_dest, vectype);
3600 new_temp = VEC_index (tree, scalar_results, 0);
3601 gcc_assert (TREE_CODE (TREE_TYPE (adjustment_def)) != VECTOR_TYPE);
3602 expr = build2 (code, scalar_type, new_temp, adjustment_def);
3603 new_dest = vect_create_destination_var (scalar_dest, scalar_type);
3606 epilog_stmt = gimple_build_assign (new_dest, expr);
3607 new_temp = make_ssa_name (new_dest, epilog_stmt);
3608 gimple_assign_set_lhs (epilog_stmt, new_temp);
3609 SSA_NAME_DEF_STMT (new_temp) = epilog_stmt;
3610 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3611 if (nested_in_vect_loop)
3613 set_vinfo_for_stmt (epilog_stmt,
3614 new_stmt_vec_info (epilog_stmt, loop_vinfo,
3616 STMT_VINFO_RELATED_STMT (vinfo_for_stmt (epilog_stmt)) =
3617 STMT_VINFO_RELATED_STMT (vinfo_for_stmt (new_phi));
3620 VEC_quick_push (tree, scalar_results, new_temp);
3622 VEC_replace (tree, scalar_results, 0, new_temp);
3625 VEC_replace (tree, scalar_results, 0, new_temp);
3627 VEC_replace (gimple, new_phis, 0, epilog_stmt);
3630 /* 2.6 Handle the loop-exit phis. Replace the uses of scalar loop-exit
3631 phis with new adjusted scalar results, i.e., replace use <s_out0>
3636 s_out0 = phi <s_loop> # (scalar) EXIT_PHI
3637 v_out1 = phi <VECT_DEF> # NEW_EXIT_PHI
3638 v_out2 = reduce <v_out1>
3639 s_out3 = extract_field <v_out2, 0>
3640 s_out4 = adjust_result <s_out3>
3647 s_out0 = phi <s_loop> # (scalar) EXIT_PHI
3648 v_out1 = phi <VECT_DEF> # NEW_EXIT_PHI
3649 v_out2 = reduce <v_out1>
3650 s_out3 = extract_field <v_out2, 0>
3651 s_out4 = adjust_result <s_out3>
3655 /* In SLP we may have several statements in NEW_PHIS and REDUCTION_PHIS (in
3656 case that GROUP_SIZE is greater than vectorization factor). Therefore, we
3657 need to match SCALAR_RESULTS with corresponding statements. The first
3658 (GROUP_SIZE / number of new vector stmts) scalar results correspond to
3659 the first vector stmt, etc.
3660 (RATIO is equal to (GROUP_SIZE / number of new vector stmts)). */
3661 if (group_size > VEC_length (gimple, new_phis))
3663 ratio = group_size / VEC_length (gimple, new_phis);
3664 gcc_assert (!(group_size % VEC_length (gimple, new_phis)));
3669 for (k = 0; k < group_size; k++)
3673 epilog_stmt = VEC_index (gimple, new_phis, k / ratio);
3674 reduction_phi = VEC_index (gimple, reduction_phis, k / ratio);
3679 gimple current_stmt = VEC_index (gimple,
3680 SLP_TREE_SCALAR_STMTS (slp_node), k);
3682 orig_stmt = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (current_stmt));
3683 /* SLP statements can't participate in patterns. */
3684 gcc_assert (!orig_stmt);
3685 scalar_dest = gimple_assign_lhs (current_stmt);
3688 phis = VEC_alloc (gimple, heap, 3);
3689 /* Find the loop-closed-use at the loop exit of the original scalar
3690 result. (The reduction result is expected to have two immediate uses -
3691 one at the latch block, and one at the loop exit). */
3692 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, scalar_dest)
3693 if (!flow_bb_inside_loop_p (loop, gimple_bb (USE_STMT (use_p))))
3694 VEC_safe_push (gimple, heap, phis, USE_STMT (use_p));
3696 /* We expect to have found an exit_phi because of loop-closed-ssa
3698 gcc_assert (!VEC_empty (gimple, phis));
3700 FOR_EACH_VEC_ELT (gimple, phis, i, exit_phi)
3704 stmt_vec_info exit_phi_vinfo = vinfo_for_stmt (exit_phi);
3707 /* FORNOW. Currently not supporting the case that an inner-loop
3708 reduction is not used in the outer-loop (but only outside the
3709 outer-loop), unless it is double reduction. */
3710 gcc_assert ((STMT_VINFO_RELEVANT_P (exit_phi_vinfo)
3711 && !STMT_VINFO_LIVE_P (exit_phi_vinfo))
3714 STMT_VINFO_VEC_STMT (exit_phi_vinfo) = epilog_stmt;
3716 || STMT_VINFO_DEF_TYPE (exit_phi_vinfo)
3717 != vect_double_reduction_def)
3720 /* Handle double reduction:
3722 stmt1: s1 = phi <s0, s2> - double reduction phi (outer loop)
3723 stmt2: s3 = phi <s1, s4> - (regular) reduc phi (inner loop)
3724 stmt3: s4 = use (s3) - (regular) reduc stmt (inner loop)
3725 stmt4: s2 = phi <s4> - double reduction stmt (outer loop)
3727 At that point the regular reduction (stmt2 and stmt3) is
3728 already vectorized, as well as the exit phi node, stmt4.
3729 Here we vectorize the phi node of double reduction, stmt1, and
3730 update all relevant statements. */
3732 /* Go through all the uses of s2 to find double reduction phi
3733 node, i.e., stmt1 above. */
3734 orig_name = PHI_RESULT (exit_phi);
3735 FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, orig_name)
3737 stmt_vec_info use_stmt_vinfo = vinfo_for_stmt (use_stmt);
3738 stmt_vec_info new_phi_vinfo;
3739 tree vect_phi_init, preheader_arg, vect_phi_res, init_def;
3740 basic_block bb = gimple_bb (use_stmt);
3743 /* Check that USE_STMT is really double reduction phi
3745 if (gimple_code (use_stmt) != GIMPLE_PHI
3746 || gimple_phi_num_args (use_stmt) != 2
3748 || STMT_VINFO_DEF_TYPE (use_stmt_vinfo)
3749 != vect_double_reduction_def
3750 || bb->loop_father != outer_loop)
3753 /* Create vector phi node for double reduction:
3754 vs1 = phi <vs0, vs2>
3755 vs1 was created previously in this function by a call to
3756 vect_get_vec_def_for_operand and is stored in
3758 vs2 is defined by EPILOG_STMT, the vectorized EXIT_PHI;
3759 vs0 is created here. */
3761 /* Create vector phi node. */
3762 vect_phi = create_phi_node (vec_initial_def, bb);
3763 new_phi_vinfo = new_stmt_vec_info (vect_phi,
3764 loop_vec_info_for_loop (outer_loop), NULL);
3765 set_vinfo_for_stmt (vect_phi, new_phi_vinfo);
3767 /* Create vs0 - initial def of the double reduction phi. */
3768 preheader_arg = PHI_ARG_DEF_FROM_EDGE (use_stmt,
3769 loop_preheader_edge (outer_loop));
3770 init_def = get_initial_def_for_reduction (stmt,
3771 preheader_arg, NULL);
3772 vect_phi_init = vect_init_vector (use_stmt, init_def,
3775 /* Update phi node arguments with vs0 and vs2. */
3776 add_phi_arg (vect_phi, vect_phi_init,
3777 loop_preheader_edge (outer_loop),
3779 add_phi_arg (vect_phi, PHI_RESULT (epilog_stmt),
3780 loop_latch_edge (outer_loop), UNKNOWN_LOCATION);
3781 if (vect_print_dump_info (REPORT_DETAILS))
3783 fprintf (vect_dump, "created double reduction phi "
3785 print_gimple_stmt (vect_dump, vect_phi, 0, TDF_SLIM);
3788 vect_phi_res = PHI_RESULT (vect_phi);
3790 /* Replace the use, i.e., set the correct vs1 in the regular
3791 reduction phi node. FORNOW, NCOPIES is always 1, so the
3792 loop is redundant. */
3793 use = reduction_phi;
3794 for (j = 0; j < ncopies; j++)
3796 edge pr_edge = loop_preheader_edge (loop);
3797 SET_PHI_ARG_DEF (use, pr_edge->dest_idx, vect_phi_res);
3798 use = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (use));
3804 VEC_free (gimple, heap, phis);
3805 if (nested_in_vect_loop)
3813 phis = VEC_alloc (gimple, heap, 3);
3814 /* Find the loop-closed-use at the loop exit of the original scalar
3815 result. (The reduction result is expected to have two immediate uses,
3816 one at the latch block, and one at the loop exit). For double
3817 reductions we are looking for exit phis of the outer loop. */
3818 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, scalar_dest)
3820 if (!flow_bb_inside_loop_p (loop, gimple_bb (USE_STMT (use_p))))
3821 VEC_safe_push (gimple, heap, phis, USE_STMT (use_p));
3824 if (double_reduc && gimple_code (USE_STMT (use_p)) == GIMPLE_PHI)
3826 tree phi_res = PHI_RESULT (USE_STMT (use_p));
3828 FOR_EACH_IMM_USE_FAST (phi_use_p, phi_imm_iter, phi_res)
3830 if (!flow_bb_inside_loop_p (loop,
3831 gimple_bb (USE_STMT (phi_use_p))))
3832 VEC_safe_push (gimple, heap, phis,
3833 USE_STMT (phi_use_p));
3839 FOR_EACH_VEC_ELT (gimple, phis, i, exit_phi)
3841 /* Replace the uses: */
3842 orig_name = PHI_RESULT (exit_phi);
3843 scalar_result = VEC_index (tree, scalar_results, k);
3844 FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, orig_name)
3845 FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
3846 SET_USE (use_p, scalar_result);
3849 VEC_free (gimple, heap, phis);
3852 VEC_free (tree, heap, scalar_results);
3853 VEC_free (gimple, heap, new_phis);
3857 /* Function vectorizable_reduction.
3859 Check if STMT performs a reduction operation that can be vectorized.
3860 If VEC_STMT is also passed, vectorize the STMT: create a vectorized
3861 stmt to replace it, put it in VEC_STMT, and insert it at GSI.
3862 Return FALSE if not a vectorizable STMT, TRUE otherwise.
3864 This function also handles reduction idioms (patterns) that have been
3865 recognized in advance during vect_pattern_recog. In this case, STMT may be
3867 X = pattern_expr (arg0, arg1, ..., X)
3868 and it's STMT_VINFO_RELATED_STMT points to the last stmt in the original
3869 sequence that had been detected and replaced by the pattern-stmt (STMT).
3871 In some cases of reduction patterns, the type of the reduction variable X is
3872 different than the type of the other arguments of STMT.
3873 In such cases, the vectype that is used when transforming STMT into a vector
3874 stmt is different than the vectype that is used to determine the
3875 vectorization factor, because it consists of a different number of elements
3876 than the actual number of elements that are being operated upon in parallel.
3878 For example, consider an accumulation of shorts into an int accumulator.
3879 On some targets it's possible to vectorize this pattern operating on 8
3880 shorts at a time (hence, the vectype for purposes of determining the
3881 vectorization factor should be V8HI); on the other hand, the vectype that
3882 is used to create the vector form is actually V4SI (the type of the result).
3884 Upon entry to this function, STMT_VINFO_VECTYPE records the vectype that
3885 indicates what is the actual level of parallelism (V8HI in the example), so
3886 that the right vectorization factor would be derived. This vectype
3887 corresponds to the type of arguments to the reduction stmt, and should *NOT*
3888 be used to create the vectorized stmt. The right vectype for the vectorized
3889 stmt is obtained from the type of the result X:
3890 get_vectype_for_scalar_type (TREE_TYPE (X))
3892 This means that, contrary to "regular" reductions (or "regular" stmts in
3893 general), the following equation:
3894 STMT_VINFO_VECTYPE == get_vectype_for_scalar_type (TREE_TYPE (X))
3895 does *NOT* necessarily hold for reduction patterns. */
3898 vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
3899 gimple *vec_stmt, slp_tree slp_node)
3903 tree loop_vec_def0 = NULL_TREE, loop_vec_def1 = NULL_TREE;
3904 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
3905 tree vectype_out = STMT_VINFO_VECTYPE (stmt_info);
3906 tree vectype_in = NULL_TREE;
3907 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
3908 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
3909 enum tree_code code, orig_code, epilog_reduc_code;
3910 enum machine_mode vec_mode;
3912 optab optab, reduc_optab;
3913 tree new_temp = NULL_TREE;
3916 enum vect_def_type dt;
3917 gimple new_phi = NULL;
3921 stmt_vec_info orig_stmt_info;
3922 tree expr = NULL_TREE;
3926 stmt_vec_info prev_stmt_info, prev_phi_info;
3927 bool single_defuse_cycle = false;
3928 tree reduc_def = NULL_TREE;
3929 gimple new_stmt = NULL;
3932 bool nested_cycle = false, found_nested_cycle_def = false;
3933 gimple reduc_def_stmt = NULL;
3934 /* The default is that the reduction variable is the last in statement. */
3935 int reduc_index = 2;
3936 bool double_reduc = false, dummy;
3938 struct loop * def_stmt_loop, *outer_loop = NULL;
3940 gimple def_arg_stmt;
3941 VEC (tree, heap) *vec_oprnds0 = NULL, *vec_oprnds1 = NULL, *vect_defs = NULL;
3942 VEC (gimple, heap) *phis = NULL;
3944 tree def0, def1, tem;
3946 if (nested_in_vect_loop_p (loop, stmt))
3950 nested_cycle = true;
3953 /* 1. Is vectorizable reduction? */
3954 /* Not supportable if the reduction variable is used in the loop. */
3955 if (STMT_VINFO_RELEVANT (stmt_info) > vect_used_in_outer)
3958 /* Reductions that are not used even in an enclosing outer-loop,
3959 are expected to be "live" (used out of the loop). */
3960 if (STMT_VINFO_RELEVANT (stmt_info) == vect_unused_in_scope
3961 && !STMT_VINFO_LIVE_P (stmt_info))
3964 /* Make sure it was already recognized as a reduction computation. */
3965 if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_reduction_def
3966 && STMT_VINFO_DEF_TYPE (stmt_info) != vect_nested_cycle)
3969 /* 2. Has this been recognized as a reduction pattern?
3971 Check if STMT represents a pattern that has been recognized
3972 in earlier analysis stages. For stmts that represent a pattern,
3973 the STMT_VINFO_RELATED_STMT field records the last stmt in
3974 the original sequence that constitutes the pattern. */
3976 orig_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
3979 orig_stmt_info = vinfo_for_stmt (orig_stmt);
3980 gcc_assert (STMT_VINFO_RELATED_STMT (orig_stmt_info) == stmt);
3981 gcc_assert (STMT_VINFO_IN_PATTERN_P (orig_stmt_info));
3982 gcc_assert (!STMT_VINFO_IN_PATTERN_P (stmt_info));
3985 /* 3. Check the operands of the operation. The first operands are defined
3986 inside the loop body. The last operand is the reduction variable,
3987 which is defined by the loop-header-phi. */
3989 gcc_assert (is_gimple_assign (stmt));
3992 switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
3994 case GIMPLE_SINGLE_RHS:
3995 op_type = TREE_OPERAND_LENGTH (gimple_assign_rhs1 (stmt));
3996 if (op_type == ternary_op)
3998 tree rhs = gimple_assign_rhs1 (stmt);
3999 ops[0] = TREE_OPERAND (rhs, 0);
4000 ops[1] = TREE_OPERAND (rhs, 1);
4001 ops[2] = TREE_OPERAND (rhs, 2);
4002 code = TREE_CODE (rhs);
4008 case GIMPLE_BINARY_RHS:
4009 code = gimple_assign_rhs_code (stmt);
4010 op_type = TREE_CODE_LENGTH (code);
4011 gcc_assert (op_type == binary_op);
4012 ops[0] = gimple_assign_rhs1 (stmt);
4013 ops[1] = gimple_assign_rhs2 (stmt);
4016 case GIMPLE_UNARY_RHS:
4023 scalar_dest = gimple_assign_lhs (stmt);
4024 scalar_type = TREE_TYPE (scalar_dest);
4025 if (!POINTER_TYPE_P (scalar_type) && !INTEGRAL_TYPE_P (scalar_type)
4026 && !SCALAR_FLOAT_TYPE_P (scalar_type))
4029 /* All uses but the last are expected to be defined in the loop.
4030 The last use is the reduction variable. In case of nested cycle this
4031 assumption is not true: we use reduc_index to record the index of the
4032 reduction variable. */
4033 for (i = 0; i < op_type-1; i++)
4035 /* The condition of COND_EXPR is checked in vectorizable_condition(). */
4036 if (i == 0 && code == COND_EXPR)
4039 is_simple_use = vect_is_simple_use_1 (ops[i], loop_vinfo, NULL,
4040 &def_stmt, &def, &dt, &tem);
4043 gcc_assert (is_simple_use);
4044 if (dt != vect_internal_def
4045 && dt != vect_external_def
4046 && dt != vect_constant_def
4047 && dt != vect_induction_def
4048 && !(dt == vect_nested_cycle && nested_cycle))
4051 if (dt == vect_nested_cycle)
4053 found_nested_cycle_def = true;
4054 reduc_def_stmt = def_stmt;
4059 is_simple_use = vect_is_simple_use_1 (ops[i], loop_vinfo, NULL, &def_stmt,
4063 gcc_assert (is_simple_use);
4064 gcc_assert (dt == vect_reduction_def
4065 || dt == vect_nested_cycle
4066 || ((dt == vect_internal_def || dt == vect_external_def
4067 || dt == vect_constant_def || dt == vect_induction_def)
4068 && nested_cycle && found_nested_cycle_def));
4069 if (!found_nested_cycle_def)
4070 reduc_def_stmt = def_stmt;
4072 gcc_assert (gimple_code (reduc_def_stmt) == GIMPLE_PHI);
4074 gcc_assert (orig_stmt == vect_is_simple_reduction (loop_vinfo,
4079 gcc_assert (stmt == vect_is_simple_reduction (loop_vinfo, reduc_def_stmt,
4080 !nested_cycle, &dummy));
4082 if (STMT_VINFO_LIVE_P (vinfo_for_stmt (reduc_def_stmt)))
4088 ncopies = (LOOP_VINFO_VECT_FACTOR (loop_vinfo)
4089 / TYPE_VECTOR_SUBPARTS (vectype_in));
4091 gcc_assert (ncopies >= 1);
4093 vec_mode = TYPE_MODE (vectype_in);
4095 if (code == COND_EXPR)
4097 if (!vectorizable_condition (stmt, gsi, NULL, ops[reduc_index], 0))
4099 if (vect_print_dump_info (REPORT_DETAILS))
4100 fprintf (vect_dump, "unsupported condition in reduction");
4107 /* 4. Supportable by target? */
4109 /* 4.1. check support for the operation in the loop */
4110 optab = optab_for_tree_code (code, vectype_in, optab_default);
4113 if (vect_print_dump_info (REPORT_DETAILS))
4114 fprintf (vect_dump, "no optab.");
4119 if (optab_handler (optab, vec_mode) == CODE_FOR_nothing)
4121 if (vect_print_dump_info (REPORT_DETAILS))
4122 fprintf (vect_dump, "op not supported by target.");
4124 if (GET_MODE_SIZE (vec_mode) != UNITS_PER_WORD
4125 || LOOP_VINFO_VECT_FACTOR (loop_vinfo)
4126 < vect_min_worthwhile_factor (code))
4129 if (vect_print_dump_info (REPORT_DETAILS))
4130 fprintf (vect_dump, "proceeding using word mode.");
4133 /* Worthwhile without SIMD support? */
4134 if (!VECTOR_MODE_P (TYPE_MODE (vectype_in))
4135 && LOOP_VINFO_VECT_FACTOR (loop_vinfo)
4136 < vect_min_worthwhile_factor (code))
4138 if (vect_print_dump_info (REPORT_DETAILS))
4139 fprintf (vect_dump, "not worthwhile without SIMD support.");
4145 /* 4.2. Check support for the epilog operation.
4147 If STMT represents a reduction pattern, then the type of the
4148 reduction variable may be different than the type of the rest
4149 of the arguments. For example, consider the case of accumulation
4150 of shorts into an int accumulator; The original code:
4151 S1: int_a = (int) short_a;
4152 orig_stmt-> S2: int_acc = plus <int_a ,int_acc>;
4155 STMT: int_acc = widen_sum <short_a, int_acc>
4158 1. The tree-code that is used to create the vector operation in the
4159 epilog code (that reduces the partial results) is not the
4160 tree-code of STMT, but is rather the tree-code of the original
4161 stmt from the pattern that STMT is replacing. I.e, in the example
4162 above we want to use 'widen_sum' in the loop, but 'plus' in the
4164 2. The type (mode) we use to check available target support
4165 for the vector operation to be created in the *epilog*, is
4166 determined by the type of the reduction variable (in the example
4167 above we'd check this: optab_handler (plus_optab, vect_int_mode])).
4168 However the type (mode) we use to check available target support
4169 for the vector operation to be created *inside the loop*, is
4170 determined by the type of the other arguments to STMT (in the
4171 example we'd check this: optab_handler (widen_sum_optab,
4174 This is contrary to "regular" reductions, in which the types of all
4175 the arguments are the same as the type of the reduction variable.
4176 For "regular" reductions we can therefore use the same vector type
4177 (and also the same tree-code) when generating the epilog code and
4178 when generating the code inside the loop. */
4182 /* This is a reduction pattern: get the vectype from the type of the
4183 reduction variable, and get the tree-code from orig_stmt. */
4184 orig_code = gimple_assign_rhs_code (orig_stmt);
4185 gcc_assert (vectype_out);
4186 vec_mode = TYPE_MODE (vectype_out);
4190 /* Regular reduction: use the same vectype and tree-code as used for
4191 the vector code inside the loop can be used for the epilog code. */
4197 def_bb = gimple_bb (reduc_def_stmt);
4198 def_stmt_loop = def_bb->loop_father;
4199 def_arg = PHI_ARG_DEF_FROM_EDGE (reduc_def_stmt,
4200 loop_preheader_edge (def_stmt_loop));
4201 if (TREE_CODE (def_arg) == SSA_NAME
4202 && (def_arg_stmt = SSA_NAME_DEF_STMT (def_arg))
4203 && gimple_code (def_arg_stmt) == GIMPLE_PHI
4204 && flow_bb_inside_loop_p (outer_loop, gimple_bb (def_arg_stmt))
4205 && vinfo_for_stmt (def_arg_stmt)
4206 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def_arg_stmt))
4207 == vect_double_reduction_def)
4208 double_reduc = true;
4211 epilog_reduc_code = ERROR_MARK;
4212 if (reduction_code_for_scalar_code (orig_code, &epilog_reduc_code))
4214 reduc_optab = optab_for_tree_code (epilog_reduc_code, vectype_out,
4218 if (vect_print_dump_info (REPORT_DETAILS))
4219 fprintf (vect_dump, "no optab for reduction.");
4221 epilog_reduc_code = ERROR_MARK;
4225 && optab_handler (reduc_optab, vec_mode) == CODE_FOR_nothing)
4227 if (vect_print_dump_info (REPORT_DETAILS))
4228 fprintf (vect_dump, "reduc op not supported by target.");
4230 epilog_reduc_code = ERROR_MARK;
4235 if (!nested_cycle || double_reduc)
4237 if (vect_print_dump_info (REPORT_DETAILS))
4238 fprintf (vect_dump, "no reduc code for scalar code.");
4244 if (double_reduc && ncopies > 1)
4246 if (vect_print_dump_info (REPORT_DETAILS))
4247 fprintf (vect_dump, "multiple types in double reduction");
4252 if (!vec_stmt) /* transformation not required. */
4254 STMT_VINFO_TYPE (stmt_info) = reduc_vec_info_type;
4255 if (!vect_model_reduction_cost (stmt_info, epilog_reduc_code, ncopies))
4262 if (vect_print_dump_info (REPORT_DETAILS))
4263 fprintf (vect_dump, "transform reduction.");
4265 /* FORNOW: Multiple types are not supported for condition. */
4266 if (code == COND_EXPR)
4267 gcc_assert (ncopies == 1);
4269 /* Create the destination vector */
4270 vec_dest = vect_create_destination_var (scalar_dest, vectype_out);
4272 /* In case the vectorization factor (VF) is bigger than the number
4273 of elements that we can fit in a vectype (nunits), we have to generate
4274 more than one vector stmt - i.e - we need to "unroll" the
4275 vector stmt by a factor VF/nunits. For more details see documentation
4276 in vectorizable_operation. */
4278 /* If the reduction is used in an outer loop we need to generate
4279 VF intermediate results, like so (e.g. for ncopies=2):
4284 (i.e. we generate VF results in 2 registers).
4285 In this case we have a separate def-use cycle for each copy, and therefore
4286 for each copy we get the vector def for the reduction variable from the
4287 respective phi node created for this copy.
4289 Otherwise (the reduction is unused in the loop nest), we can combine
4290 together intermediate results, like so (e.g. for ncopies=2):
4294 (i.e. we generate VF/2 results in a single register).
4295 In this case for each copy we get the vector def for the reduction variable
4296 from the vectorized reduction operation generated in the previous iteration.
4299 if (STMT_VINFO_RELEVANT (stmt_info) == vect_unused_in_scope)
4301 single_defuse_cycle = true;
4305 epilog_copies = ncopies;
4307 prev_stmt_info = NULL;
4308 prev_phi_info = NULL;
4311 vec_num = SLP_TREE_NUMBER_OF_VEC_STMTS (slp_node);
4312 gcc_assert (TYPE_VECTOR_SUBPARTS (vectype_out)
4313 == TYPE_VECTOR_SUBPARTS (vectype_in));
4318 vec_oprnds0 = VEC_alloc (tree, heap, 1);
4319 if (op_type == ternary_op)
4320 vec_oprnds1 = VEC_alloc (tree, heap, 1);
4323 phis = VEC_alloc (gimple, heap, vec_num);
4324 vect_defs = VEC_alloc (tree, heap, vec_num);
4326 VEC_quick_push (tree, vect_defs, NULL_TREE);
4328 for (j = 0; j < ncopies; j++)
4330 if (j == 0 || !single_defuse_cycle)
4332 for (i = 0; i < vec_num; i++)
4334 /* Create the reduction-phi that defines the reduction
4336 new_phi = create_phi_node (vec_dest, loop->header);
4337 set_vinfo_for_stmt (new_phi,
4338 new_stmt_vec_info (new_phi, loop_vinfo,
4340 if (j == 0 || slp_node)
4341 VEC_quick_push (gimple, phis, new_phi);
4345 if (code == COND_EXPR)
4347 gcc_assert (!slp_node);
4348 vectorizable_condition (stmt, gsi, vec_stmt,
4349 PHI_RESULT (VEC_index (gimple, phis, 0)),
4351 /* Multiple types are not supported for condition. */
4358 tree op0, op1 = NULL_TREE;
4360 op0 = ops[!reduc_index];
4361 if (op_type == ternary_op)
4363 if (reduc_index == 0)
4370 vect_get_slp_defs (op0, op1, slp_node, &vec_oprnds0, &vec_oprnds1,
4374 loop_vec_def0 = vect_get_vec_def_for_operand (ops[!reduc_index],
4376 VEC_quick_push (tree, vec_oprnds0, loop_vec_def0);
4377 if (op_type == ternary_op)
4379 loop_vec_def1 = vect_get_vec_def_for_operand (op1, stmt,
4381 VEC_quick_push (tree, vec_oprnds1, loop_vec_def1);
4389 enum vect_def_type dt = vect_unknown_def_type; /* Dummy */
4390 loop_vec_def0 = vect_get_vec_def_for_stmt_copy (dt, loop_vec_def0);
4391 VEC_replace (tree, vec_oprnds0, 0, loop_vec_def0);
4392 if (op_type == ternary_op)
4394 loop_vec_def1 = vect_get_vec_def_for_stmt_copy (dt,
4396 VEC_replace (tree, vec_oprnds1, 0, loop_vec_def1);
4400 if (single_defuse_cycle)
4401 reduc_def = gimple_assign_lhs (new_stmt);
4403 STMT_VINFO_RELATED_STMT (prev_phi_info) = new_phi;
4406 FOR_EACH_VEC_ELT (tree, vec_oprnds0, i, def0)
4409 reduc_def = PHI_RESULT (VEC_index (gimple, phis, i));
4412 if (!single_defuse_cycle || j == 0)
4413 reduc_def = PHI_RESULT (new_phi);
4416 def1 = ((op_type == ternary_op)
4417 ? VEC_index (tree, vec_oprnds1, i) : NULL);
4418 if (op_type == binary_op)
4420 if (reduc_index == 0)
4421 expr = build2 (code, vectype_out, reduc_def, def0);
4423 expr = build2 (code, vectype_out, def0, reduc_def);
4427 if (reduc_index == 0)
4428 expr = build3 (code, vectype_out, reduc_def, def0, def1);
4431 if (reduc_index == 1)
4432 expr = build3 (code, vectype_out, def0, reduc_def, def1);
4434 expr = build3 (code, vectype_out, def0, def1, reduc_def);
4438 new_stmt = gimple_build_assign (vec_dest, expr);
4439 new_temp = make_ssa_name (vec_dest, new_stmt);
4440 gimple_assign_set_lhs (new_stmt, new_temp);
4441 vect_finish_stmt_generation (stmt, new_stmt, gsi);
4444 VEC_quick_push (gimple, SLP_TREE_VEC_STMTS (slp_node), new_stmt);
4445 VEC_quick_push (tree, vect_defs, new_temp);
4448 VEC_replace (tree, vect_defs, 0, new_temp);
4455 STMT_VINFO_VEC_STMT (stmt_info) = *vec_stmt = new_stmt;
4457 STMT_VINFO_RELATED_STMT (prev_stmt_info) = new_stmt;
4459 prev_stmt_info = vinfo_for_stmt (new_stmt);
4460 prev_phi_info = vinfo_for_stmt (new_phi);
4463 /* Finalize the reduction-phi (set its arguments) and create the
4464 epilog reduction code. */
4465 if ((!single_defuse_cycle || code == COND_EXPR) && !slp_node)
4467 new_temp = gimple_assign_lhs (*vec_stmt);
4468 VEC_replace (tree, vect_defs, 0, new_temp);
4471 vect_create_epilog_for_reduction (vect_defs, stmt, epilog_copies,
4472 epilog_reduc_code, phis, reduc_index,
4473 double_reduc, slp_node);
4475 VEC_free (gimple, heap, phis);
4476 VEC_free (tree, heap, vec_oprnds0);
4478 VEC_free (tree, heap, vec_oprnds1);
4483 /* Function vect_min_worthwhile_factor.
4485 For a loop where we could vectorize the operation indicated by CODE,
4486 return the minimum vectorization factor that makes it worthwhile
4487 to use generic vectors. */
4489 vect_min_worthwhile_factor (enum tree_code code)
4510 /* Function vectorizable_induction
4512 Check if PHI performs an induction computation that can be vectorized.
4513 If VEC_STMT is also passed, vectorize the induction PHI: create a vectorized
4514 phi to replace it, put it in VEC_STMT, and add it to the same basic block.
4515 Return FALSE if not a vectorizable STMT, TRUE otherwise. */
4518 vectorizable_induction (gimple phi, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
4521 stmt_vec_info stmt_info = vinfo_for_stmt (phi);
4522 tree vectype = STMT_VINFO_VECTYPE (stmt_info);
4523 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
4524 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
4525 int nunits = TYPE_VECTOR_SUBPARTS (vectype);
4526 int ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits;
4529 gcc_assert (ncopies >= 1);
4530 /* FORNOW. This restriction should be relaxed. */
4531 if (nested_in_vect_loop_p (loop, phi) && ncopies > 1)
4533 if (vect_print_dump_info (REPORT_DETAILS))
4534 fprintf (vect_dump, "multiple types in nested loop.");
4538 if (!STMT_VINFO_RELEVANT_P (stmt_info))
4541 /* FORNOW: SLP not supported. */
4542 if (STMT_SLP_TYPE (stmt_info))
4545 gcc_assert (STMT_VINFO_DEF_TYPE (stmt_info) == vect_induction_def);
4547 if (gimple_code (phi) != GIMPLE_PHI)
4550 if (!vec_stmt) /* transformation not required. */
4552 STMT_VINFO_TYPE (stmt_info) = induc_vec_info_type;
4553 if (vect_print_dump_info (REPORT_DETAILS))
4554 fprintf (vect_dump, "=== vectorizable_induction ===");
4555 vect_model_induction_cost (stmt_info, ncopies);
4561 if (vect_print_dump_info (REPORT_DETAILS))
4562 fprintf (vect_dump, "transform induction phi.");
4564 vec_def = get_initial_def_for_induction (phi);
4565 *vec_stmt = SSA_NAME_DEF_STMT (vec_def);
4569 /* Function vectorizable_live_operation.
4571 STMT computes a value that is used outside the loop. Check if
4572 it can be supported. */
4575 vectorizable_live_operation (gimple stmt,
4576 gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
4577 gimple *vec_stmt ATTRIBUTE_UNUSED)
4579 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
4580 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
4581 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
4587 enum vect_def_type dt;
4588 enum tree_code code;
4589 enum gimple_rhs_class rhs_class;
4591 gcc_assert (STMT_VINFO_LIVE_P (stmt_info));
4593 if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_reduction_def)
4596 if (!is_gimple_assign (stmt))
4599 if (TREE_CODE (gimple_assign_lhs (stmt)) != SSA_NAME)
4602 /* FORNOW. CHECKME. */
4603 if (nested_in_vect_loop_p (loop, stmt))
4606 code = gimple_assign_rhs_code (stmt);
4607 op_type = TREE_CODE_LENGTH (code);
4608 rhs_class = get_gimple_rhs_class (code);
4609 gcc_assert (rhs_class != GIMPLE_UNARY_RHS || op_type == unary_op);
4610 gcc_assert (rhs_class != GIMPLE_BINARY_RHS || op_type == binary_op);
4612 /* FORNOW: support only if all uses are invariant. This means
4613 that the scalar operations can remain in place, unvectorized.
4614 The original last scalar value that they compute will be used. */
4616 for (i = 0; i < op_type; i++)
4618 if (rhs_class == GIMPLE_SINGLE_RHS)
4619 op = TREE_OPERAND (gimple_op (stmt, 1), i);
4621 op = gimple_op (stmt, i + 1);
4623 && !vect_is_simple_use (op, loop_vinfo, NULL, &def_stmt, &def, &dt))
4625 if (vect_print_dump_info (REPORT_DETAILS))
4626 fprintf (vect_dump, "use not simple.");
4630 if (dt != vect_external_def && dt != vect_constant_def)
4634 /* No transformation is required for the cases we currently support. */
4638 /* Kill any debug uses outside LOOP of SSA names defined in STMT. */
4641 vect_loop_kill_debug_uses (struct loop *loop, gimple stmt)
4643 ssa_op_iter op_iter;
4644 imm_use_iterator imm_iter;
4645 def_operand_p def_p;
4648 FOR_EACH_PHI_OR_STMT_DEF (def_p, stmt, op_iter, SSA_OP_DEF)
4650 FOR_EACH_IMM_USE_STMT (ustmt, imm_iter, DEF_FROM_PTR (def_p))
4654 if (!is_gimple_debug (ustmt))
4657 bb = gimple_bb (ustmt);
4659 if (!flow_bb_inside_loop_p (loop, bb))
4661 if (gimple_debug_bind_p (ustmt))
4663 if (vect_print_dump_info (REPORT_DETAILS))
4664 fprintf (vect_dump, "killing debug use");
4666 gimple_debug_bind_reset_value (ustmt);
4667 update_stmt (ustmt);
4676 /* Function vect_transform_loop.
4678 The analysis phase has determined that the loop is vectorizable.
4679 Vectorize the loop - created vectorized stmts to replace the scalar
4680 stmts in the loop, and update the loop exit condition. */
4683 vect_transform_loop (loop_vec_info loop_vinfo)
4685 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
4686 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
4687 int nbbs = loop->num_nodes;
4688 gimple_stmt_iterator si;
4691 int vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
4693 bool slp_scheduled = false;
4694 unsigned int nunits;
4695 tree cond_expr = NULL_TREE;
4696 gimple_seq cond_expr_stmt_list = NULL;
4697 bool do_peeling_for_loop_bound;
4699 if (vect_print_dump_info (REPORT_DETAILS))
4700 fprintf (vect_dump, "=== vec_transform_loop ===");
4702 /* Peel the loop if there are data refs with unknown alignment.
4703 Only one data ref with unknown store is allowed. */
4705 if (LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo))
4706 vect_do_peeling_for_alignment (loop_vinfo);
4708 do_peeling_for_loop_bound
4709 = (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
4710 || (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
4711 && LOOP_VINFO_INT_NITERS (loop_vinfo) % vectorization_factor != 0));
4713 if (LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)
4714 || LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
4715 vect_loop_versioning (loop_vinfo,
4716 !do_peeling_for_loop_bound,
4717 &cond_expr, &cond_expr_stmt_list);
4719 /* If the loop has a symbolic number of iterations 'n' (i.e. it's not a
4720 compile time constant), or it is a constant that doesn't divide by the
4721 vectorization factor, then an epilog loop needs to be created.
4722 We therefore duplicate the loop: the original loop will be vectorized,
4723 and will compute the first (n/VF) iterations. The second copy of the loop
4724 will remain scalar and will compute the remaining (n%VF) iterations.
4725 (VF is the vectorization factor). */
4727 if (do_peeling_for_loop_bound)
4728 vect_do_peeling_for_loop_bound (loop_vinfo, &ratio,
4729 cond_expr, cond_expr_stmt_list);
4731 ratio = build_int_cst (TREE_TYPE (LOOP_VINFO_NITERS (loop_vinfo)),
4732 LOOP_VINFO_INT_NITERS (loop_vinfo) / vectorization_factor);
4734 /* 1) Make sure the loop header has exactly two entries
4735 2) Make sure we have a preheader basic block. */
4737 gcc_assert (EDGE_COUNT (loop->header->preds) == 2);
4739 split_edge (loop_preheader_edge (loop));
4741 /* FORNOW: the vectorizer supports only loops which body consist
4742 of one basic block (header + empty latch). When the vectorizer will
4743 support more involved loop forms, the order by which the BBs are
4744 traversed need to be reconsidered. */
4746 for (i = 0; i < nbbs; i++)
4748 basic_block bb = bbs[i];
4749 stmt_vec_info stmt_info;
4752 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
4754 phi = gsi_stmt (si);
4755 if (vect_print_dump_info (REPORT_DETAILS))
4757 fprintf (vect_dump, "------>vectorizing phi: ");
4758 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
4760 stmt_info = vinfo_for_stmt (phi);
4764 if (MAY_HAVE_DEBUG_STMTS && !STMT_VINFO_LIVE_P (stmt_info))
4765 vect_loop_kill_debug_uses (loop, phi);
4767 if (!STMT_VINFO_RELEVANT_P (stmt_info)
4768 && !STMT_VINFO_LIVE_P (stmt_info))
4771 if ((TYPE_VECTOR_SUBPARTS (STMT_VINFO_VECTYPE (stmt_info))
4772 != (unsigned HOST_WIDE_INT) vectorization_factor)
4773 && vect_print_dump_info (REPORT_DETAILS))
4774 fprintf (vect_dump, "multiple-types.");
4776 if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_induction_def)
4778 if (vect_print_dump_info (REPORT_DETAILS))
4779 fprintf (vect_dump, "transform phi.");
4780 vect_transform_stmt (phi, NULL, NULL, NULL, NULL);
4784 for (si = gsi_start_bb (bb); !gsi_end_p (si);)
4786 gimple stmt = gsi_stmt (si);
4789 if (vect_print_dump_info (REPORT_DETAILS))
4791 fprintf (vect_dump, "------>vectorizing statement: ");
4792 print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
4795 stmt_info = vinfo_for_stmt (stmt);
4797 /* vector stmts created in the outer-loop during vectorization of
4798 stmts in an inner-loop may not have a stmt_info, and do not
4799 need to be vectorized. */
4806 if (MAY_HAVE_DEBUG_STMTS && !STMT_VINFO_LIVE_P (stmt_info))
4807 vect_loop_kill_debug_uses (loop, stmt);
4809 if (!STMT_VINFO_RELEVANT_P (stmt_info)
4810 && !STMT_VINFO_LIVE_P (stmt_info))
4816 gcc_assert (STMT_VINFO_VECTYPE (stmt_info));
4818 (unsigned int) TYPE_VECTOR_SUBPARTS (STMT_VINFO_VECTYPE (stmt_info));
4819 if (!STMT_SLP_TYPE (stmt_info)
4820 && nunits != (unsigned int) vectorization_factor
4821 && vect_print_dump_info (REPORT_DETAILS))
4822 /* For SLP VF is set according to unrolling factor, and not to
4823 vector size, hence for SLP this print is not valid. */
4824 fprintf (vect_dump, "multiple-types.");
4826 /* SLP. Schedule all the SLP instances when the first SLP stmt is
4828 if (STMT_SLP_TYPE (stmt_info))
4832 slp_scheduled = true;
4834 if (vect_print_dump_info (REPORT_DETAILS))
4835 fprintf (vect_dump, "=== scheduling SLP instances ===");
4837 vect_schedule_slp (loop_vinfo, NULL);
4840 /* Hybrid SLP stmts must be vectorized in addition to SLP. */
4841 if (!vinfo_for_stmt (stmt) || PURE_SLP_STMT (stmt_info))
4848 /* -------- vectorize statement ------------ */
4849 if (vect_print_dump_info (REPORT_DETAILS))
4850 fprintf (vect_dump, "transform statement.");
4852 strided_store = false;
4853 is_store = vect_transform_stmt (stmt, &si, &strided_store, NULL, NULL);
4856 if (STMT_VINFO_STRIDED_ACCESS (stmt_info))
4858 /* Interleaving. If IS_STORE is TRUE, the vectorization of the
4859 interleaving chain was completed - free all the stores in
4861 vect_remove_stores (DR_GROUP_FIRST_DR (stmt_info));
4862 gsi_remove (&si, true);
4867 /* Free the attached stmt_vec_info and remove the stmt. */
4868 free_stmt_vec_info (stmt);
4869 gsi_remove (&si, true);
4877 slpeel_make_loop_iterate_ntimes (loop, ratio);
4879 /* The memory tags and pointers in vectorized statements need to
4880 have their SSA forms updated. FIXME, why can't this be delayed
4881 until all the loops have been transformed? */
4882 update_ssa (TODO_update_ssa);
4884 if (vect_print_dump_info (REPORT_VECTORIZED_LOCATIONS))
4885 fprintf (vect_dump, "LOOP VECTORIZED.");
4886 if (loop->inner && vect_print_dump_info (REPORT_VECTORIZED_LOCATIONS))
4887 fprintf (vect_dump, "OUTER LOOP VECTORIZED.");