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);
481 if (access_fn && vect_print_dump_info (REPORT_DETAILS))
483 fprintf (vect_dump, "Access function of PHI: ");
484 print_generic_expr (vect_dump, access_fn, TDF_SLIM);
488 || !vect_is_simple_iv_evolution (loop->num, access_fn, &dumy, &dumy))
490 VEC_safe_push (gimple, heap, worklist, phi);
494 if (vect_print_dump_info (REPORT_DETAILS))
495 fprintf (vect_dump, "Detected induction.");
496 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_induction_def;
500 /* Second - identify all reductions and nested cycles. */
501 while (VEC_length (gimple, worklist) > 0)
503 gimple phi = VEC_pop (gimple, worklist);
504 tree def = PHI_RESULT (phi);
505 stmt_vec_info stmt_vinfo = vinfo_for_stmt (phi);
509 if (vect_print_dump_info (REPORT_DETAILS))
511 fprintf (vect_dump, "Analyze phi: ");
512 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
515 gcc_assert (is_gimple_reg (SSA_NAME_VAR (def)));
516 gcc_assert (STMT_VINFO_DEF_TYPE (stmt_vinfo) == vect_unknown_def_type);
518 nested_cycle = (loop != LOOP_VINFO_LOOP (loop_vinfo));
519 reduc_stmt = vect_force_simple_reduction (loop_vinfo, phi, !nested_cycle,
525 if (vect_print_dump_info (REPORT_DETAILS))
526 fprintf (vect_dump, "Detected double reduction.");
528 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_double_reduction_def;
529 STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) =
530 vect_double_reduction_def;
536 if (vect_print_dump_info (REPORT_DETAILS))
537 fprintf (vect_dump, "Detected vectorizable nested cycle.");
539 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_nested_cycle;
540 STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) =
545 if (vect_print_dump_info (REPORT_DETAILS))
546 fprintf (vect_dump, "Detected reduction.");
548 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_reduction_def;
549 STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) =
551 /* Store the reduction cycles for possible vectorization in
553 VEC_safe_push (gimple, heap,
554 LOOP_VINFO_REDUCTIONS (loop_vinfo),
560 if (vect_print_dump_info (REPORT_DETAILS))
561 fprintf (vect_dump, "Unknown def-use cycle pattern.");
564 VEC_free (gimple, heap, worklist);
568 /* Function vect_analyze_scalar_cycles.
570 Examine the cross iteration def-use cycles of scalar variables, by
571 analyzing the loop-header PHIs of scalar variables. Classify each
572 cycle as one of the following: invariant, induction, reduction, unknown.
573 We do that for the loop represented by LOOP_VINFO, and also to its
574 inner-loop, if exists.
575 Examples for scalar cycles:
590 vect_analyze_scalar_cycles (loop_vec_info loop_vinfo)
592 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
594 vect_analyze_scalar_cycles_1 (loop_vinfo, loop);
596 /* When vectorizing an outer-loop, the inner-loop is executed sequentially.
597 Reductions in such inner-loop therefore have different properties than
598 the reductions in the nest that gets vectorized:
599 1. When vectorized, they are executed in the same order as in the original
600 scalar loop, so we can't change the order of computation when
602 2. FIXME: Inner-loop reductions can be used in the inner-loop, so the
603 current checks are too strict. */
606 vect_analyze_scalar_cycles_1 (loop_vinfo, loop->inner);
609 /* Function vect_get_loop_niters.
611 Determine how many iterations the loop is executed.
612 If an expression that represents the number of iterations
613 can be constructed, place it in NUMBER_OF_ITERATIONS.
614 Return the loop exit condition. */
617 vect_get_loop_niters (struct loop *loop, tree *number_of_iterations)
621 if (vect_print_dump_info (REPORT_DETAILS))
622 fprintf (vect_dump, "=== get_loop_niters ===");
624 niters = number_of_exit_cond_executions (loop);
626 if (niters != NULL_TREE
627 && niters != chrec_dont_know)
629 *number_of_iterations = niters;
631 if (vect_print_dump_info (REPORT_DETAILS))
633 fprintf (vect_dump, "==> get_loop_niters:" );
634 print_generic_expr (vect_dump, *number_of_iterations, TDF_SLIM);
638 return get_loop_exit_condition (loop);
642 /* Function bb_in_loop_p
644 Used as predicate for dfs order traversal of the loop bbs. */
647 bb_in_loop_p (const_basic_block bb, const void *data)
649 const struct loop *const loop = (const struct loop *)data;
650 if (flow_bb_inside_loop_p (loop, bb))
656 /* Function new_loop_vec_info.
658 Create and initialize a new loop_vec_info struct for LOOP, as well as
659 stmt_vec_info structs for all the stmts in LOOP. */
662 new_loop_vec_info (struct loop *loop)
666 gimple_stmt_iterator si;
667 unsigned int i, nbbs;
669 res = (loop_vec_info) xcalloc (1, sizeof (struct _loop_vec_info));
670 LOOP_VINFO_LOOP (res) = loop;
672 bbs = get_loop_body (loop);
674 /* Create/Update stmt_info for all stmts in the loop. */
675 for (i = 0; i < loop->num_nodes; i++)
677 basic_block bb = bbs[i];
679 /* BBs in a nested inner-loop will have been already processed (because
680 we will have called vect_analyze_loop_form for any nested inner-loop).
681 Therefore, for stmts in an inner-loop we just want to update the
682 STMT_VINFO_LOOP_VINFO field of their stmt_info to point to the new
683 loop_info of the outer-loop we are currently considering to vectorize
684 (instead of the loop_info of the inner-loop).
685 For stmts in other BBs we need to create a stmt_info from scratch. */
686 if (bb->loop_father != loop)
689 gcc_assert (loop->inner && bb->loop_father == loop->inner);
690 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
692 gimple phi = gsi_stmt (si);
693 stmt_vec_info stmt_info = vinfo_for_stmt (phi);
694 loop_vec_info inner_loop_vinfo =
695 STMT_VINFO_LOOP_VINFO (stmt_info);
696 gcc_assert (loop->inner == LOOP_VINFO_LOOP (inner_loop_vinfo));
697 STMT_VINFO_LOOP_VINFO (stmt_info) = res;
699 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
701 gimple stmt = gsi_stmt (si);
702 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
703 loop_vec_info inner_loop_vinfo =
704 STMT_VINFO_LOOP_VINFO (stmt_info);
705 gcc_assert (loop->inner == LOOP_VINFO_LOOP (inner_loop_vinfo));
706 STMT_VINFO_LOOP_VINFO (stmt_info) = res;
711 /* bb in current nest. */
712 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
714 gimple phi = gsi_stmt (si);
715 gimple_set_uid (phi, 0);
716 set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, res, NULL));
719 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
721 gimple stmt = gsi_stmt (si);
722 gimple_set_uid (stmt, 0);
723 set_vinfo_for_stmt (stmt, new_stmt_vec_info (stmt, res, NULL));
728 /* CHECKME: We want to visit all BBs before their successors (except for
729 latch blocks, for which this assertion wouldn't hold). In the simple
730 case of the loop forms we allow, a dfs order of the BBs would the same
731 as reversed postorder traversal, so we are safe. */
734 bbs = XCNEWVEC (basic_block, loop->num_nodes);
735 nbbs = dfs_enumerate_from (loop->header, 0, bb_in_loop_p,
736 bbs, loop->num_nodes, loop);
737 gcc_assert (nbbs == loop->num_nodes);
739 LOOP_VINFO_BBS (res) = bbs;
740 LOOP_VINFO_NITERS (res) = NULL;
741 LOOP_VINFO_NITERS_UNCHANGED (res) = NULL;
742 LOOP_VINFO_COST_MODEL_MIN_ITERS (res) = 0;
743 LOOP_VINFO_VECTORIZABLE_P (res) = 0;
744 LOOP_PEELING_FOR_ALIGNMENT (res) = 0;
745 LOOP_VINFO_VECT_FACTOR (res) = 0;
746 LOOP_VINFO_DATAREFS (res) = VEC_alloc (data_reference_p, heap, 10);
747 LOOP_VINFO_DDRS (res) = VEC_alloc (ddr_p, heap, 10 * 10);
748 LOOP_VINFO_UNALIGNED_DR (res) = NULL;
749 LOOP_VINFO_MAY_MISALIGN_STMTS (res) =
750 VEC_alloc (gimple, heap,
751 PARAM_VALUE (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS));
752 LOOP_VINFO_MAY_ALIAS_DDRS (res) =
753 VEC_alloc (ddr_p, heap,
754 PARAM_VALUE (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS));
755 LOOP_VINFO_STRIDED_STORES (res) = VEC_alloc (gimple, heap, 10);
756 LOOP_VINFO_REDUCTIONS (res) = VEC_alloc (gimple, heap, 10);
757 LOOP_VINFO_SLP_INSTANCES (res) = VEC_alloc (slp_instance, heap, 10);
758 LOOP_VINFO_SLP_UNROLLING_FACTOR (res) = 1;
759 LOOP_VINFO_PEELING_HTAB (res) = NULL;
765 /* Function destroy_loop_vec_info.
767 Free LOOP_VINFO struct, as well as all the stmt_vec_info structs of all the
768 stmts in the loop. */
771 destroy_loop_vec_info (loop_vec_info loop_vinfo, bool clean_stmts)
776 gimple_stmt_iterator si;
778 VEC (slp_instance, heap) *slp_instances;
779 slp_instance instance;
784 loop = LOOP_VINFO_LOOP (loop_vinfo);
786 bbs = LOOP_VINFO_BBS (loop_vinfo);
787 nbbs = loop->num_nodes;
791 free (LOOP_VINFO_BBS (loop_vinfo));
792 free_data_refs (LOOP_VINFO_DATAREFS (loop_vinfo));
793 free_dependence_relations (LOOP_VINFO_DDRS (loop_vinfo));
794 VEC_free (gimple, heap, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo));
801 for (j = 0; j < nbbs; j++)
803 basic_block bb = bbs[j];
804 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
805 free_stmt_vec_info (gsi_stmt (si));
807 for (si = gsi_start_bb (bb); !gsi_end_p (si); )
809 gimple stmt = gsi_stmt (si);
810 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
814 /* Check if this is a "pattern stmt" (introduced by the
815 vectorizer during the pattern recognition pass). */
816 bool remove_stmt_p = false;
817 gimple orig_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
820 stmt_vec_info orig_stmt_info = vinfo_for_stmt (orig_stmt);
822 && STMT_VINFO_IN_PATTERN_P (orig_stmt_info))
823 remove_stmt_p = true;
826 /* Free stmt_vec_info. */
827 free_stmt_vec_info (stmt);
829 /* Remove dead "pattern stmts". */
831 gsi_remove (&si, true);
837 free (LOOP_VINFO_BBS (loop_vinfo));
838 free_data_refs (LOOP_VINFO_DATAREFS (loop_vinfo));
839 free_dependence_relations (LOOP_VINFO_DDRS (loop_vinfo));
840 VEC_free (gimple, heap, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo));
841 VEC_free (ddr_p, heap, LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo));
842 slp_instances = LOOP_VINFO_SLP_INSTANCES (loop_vinfo);
843 FOR_EACH_VEC_ELT (slp_instance, slp_instances, j, instance)
844 vect_free_slp_instance (instance);
846 VEC_free (slp_instance, heap, LOOP_VINFO_SLP_INSTANCES (loop_vinfo));
847 VEC_free (gimple, heap, LOOP_VINFO_STRIDED_STORES (loop_vinfo));
848 VEC_free (gimple, heap, LOOP_VINFO_REDUCTIONS (loop_vinfo));
850 if (LOOP_VINFO_PEELING_HTAB (loop_vinfo))
851 htab_delete (LOOP_VINFO_PEELING_HTAB (loop_vinfo));
858 /* Function vect_analyze_loop_1.
860 Apply a set of analyses on LOOP, and create a loop_vec_info struct
861 for it. The different analyses will record information in the
862 loop_vec_info struct. This is a subset of the analyses applied in
863 vect_analyze_loop, to be applied on an inner-loop nested in the loop
864 that is now considered for (outer-loop) vectorization. */
867 vect_analyze_loop_1 (struct loop *loop)
869 loop_vec_info loop_vinfo;
871 if (vect_print_dump_info (REPORT_DETAILS))
872 fprintf (vect_dump, "===== analyze_loop_nest_1 =====");
874 /* Check the CFG characteristics of the loop (nesting, entry/exit, etc. */
876 loop_vinfo = vect_analyze_loop_form (loop);
879 if (vect_print_dump_info (REPORT_DETAILS))
880 fprintf (vect_dump, "bad inner-loop form.");
888 /* Function vect_analyze_loop_form.
890 Verify that certain CFG restrictions hold, including:
891 - the loop has a pre-header
892 - the loop has a single entry and exit
893 - the loop exit condition is simple enough, and the number of iterations
894 can be analyzed (a countable loop). */
897 vect_analyze_loop_form (struct loop *loop)
899 loop_vec_info loop_vinfo;
901 tree number_of_iterations = NULL;
902 loop_vec_info inner_loop_vinfo = NULL;
904 if (vect_print_dump_info (REPORT_DETAILS))
905 fprintf (vect_dump, "=== vect_analyze_loop_form ===");
907 /* Different restrictions apply when we are considering an inner-most loop,
908 vs. an outer (nested) loop.
909 (FORNOW. May want to relax some of these restrictions in the future). */
913 /* Inner-most loop. We currently require that the number of BBs is
914 exactly 2 (the header and latch). Vectorizable inner-most loops
925 if (loop->num_nodes != 2)
927 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
928 fprintf (vect_dump, "not vectorized: control flow in loop.");
932 if (empty_block_p (loop->header))
934 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
935 fprintf (vect_dump, "not vectorized: empty loop.");
941 struct loop *innerloop = loop->inner;
944 /* Nested loop. We currently require that the loop is doubly-nested,
945 contains a single inner loop, and the number of BBs is exactly 5.
946 Vectorizable outer-loops look like this:
958 The inner-loop has the properties expected of inner-most loops
959 as described above. */
961 if ((loop->inner)->inner || (loop->inner)->next)
963 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
964 fprintf (vect_dump, "not vectorized: multiple nested loops.");
968 /* Analyze the inner-loop. */
969 inner_loop_vinfo = vect_analyze_loop_1 (loop->inner);
970 if (!inner_loop_vinfo)
972 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
973 fprintf (vect_dump, "not vectorized: Bad inner loop.");
977 if (!expr_invariant_in_loop_p (loop,
978 LOOP_VINFO_NITERS (inner_loop_vinfo)))
980 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
982 "not vectorized: inner-loop count not invariant.");
983 destroy_loop_vec_info (inner_loop_vinfo, true);
987 if (loop->num_nodes != 5)
989 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
990 fprintf (vect_dump, "not vectorized: control flow in loop.");
991 destroy_loop_vec_info (inner_loop_vinfo, true);
995 gcc_assert (EDGE_COUNT (innerloop->header->preds) == 2);
996 entryedge = EDGE_PRED (innerloop->header, 0);
997 if (EDGE_PRED (innerloop->header, 0)->src == innerloop->latch)
998 entryedge = EDGE_PRED (innerloop->header, 1);
1000 if (entryedge->src != loop->header
1001 || !single_exit (innerloop)
1002 || single_exit (innerloop)->dest != EDGE_PRED (loop->latch, 0)->src)
1004 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1005 fprintf (vect_dump, "not vectorized: unsupported outerloop form.");
1006 destroy_loop_vec_info (inner_loop_vinfo, true);
1010 if (vect_print_dump_info (REPORT_DETAILS))
1011 fprintf (vect_dump, "Considering outer-loop vectorization.");
1014 if (!single_exit (loop)
1015 || EDGE_COUNT (loop->header->preds) != 2)
1017 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1019 if (!single_exit (loop))
1020 fprintf (vect_dump, "not vectorized: multiple exits.");
1021 else if (EDGE_COUNT (loop->header->preds) != 2)
1022 fprintf (vect_dump, "not vectorized: too many incoming edges.");
1024 if (inner_loop_vinfo)
1025 destroy_loop_vec_info (inner_loop_vinfo, true);
1029 /* We assume that the loop exit condition is at the end of the loop. i.e,
1030 that the loop is represented as a do-while (with a proper if-guard
1031 before the loop if needed), where the loop header contains all the
1032 executable statements, and the latch is empty. */
1033 if (!empty_block_p (loop->latch)
1034 || !gimple_seq_empty_p (phi_nodes (loop->latch)))
1036 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1037 fprintf (vect_dump, "not vectorized: unexpected loop form.");
1038 if (inner_loop_vinfo)
1039 destroy_loop_vec_info (inner_loop_vinfo, true);
1043 /* Make sure there exists a single-predecessor exit bb: */
1044 if (!single_pred_p (single_exit (loop)->dest))
1046 edge e = single_exit (loop);
1047 if (!(e->flags & EDGE_ABNORMAL))
1049 split_loop_exit_edge (e);
1050 if (vect_print_dump_info (REPORT_DETAILS))
1051 fprintf (vect_dump, "split exit edge.");
1055 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1056 fprintf (vect_dump, "not vectorized: abnormal loop exit edge.");
1057 if (inner_loop_vinfo)
1058 destroy_loop_vec_info (inner_loop_vinfo, true);
1063 loop_cond = vect_get_loop_niters (loop, &number_of_iterations);
1066 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1067 fprintf (vect_dump, "not vectorized: complicated exit condition.");
1068 if (inner_loop_vinfo)
1069 destroy_loop_vec_info (inner_loop_vinfo, true);
1073 if (!number_of_iterations)
1075 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1077 "not vectorized: number of iterations cannot be computed.");
1078 if (inner_loop_vinfo)
1079 destroy_loop_vec_info (inner_loop_vinfo, true);
1083 if (chrec_contains_undetermined (number_of_iterations))
1085 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1086 fprintf (vect_dump, "Infinite number of iterations.");
1087 if (inner_loop_vinfo)
1088 destroy_loop_vec_info (inner_loop_vinfo, true);
1092 if (!NITERS_KNOWN_P (number_of_iterations))
1094 if (vect_print_dump_info (REPORT_DETAILS))
1096 fprintf (vect_dump, "Symbolic number of iterations is ");
1097 print_generic_expr (vect_dump, number_of_iterations, TDF_DETAILS);
1100 else if (TREE_INT_CST_LOW (number_of_iterations) == 0)
1102 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1103 fprintf (vect_dump, "not vectorized: number of iterations = 0.");
1104 if (inner_loop_vinfo)
1105 destroy_loop_vec_info (inner_loop_vinfo, false);
1109 loop_vinfo = new_loop_vec_info (loop);
1110 LOOP_VINFO_NITERS (loop_vinfo) = number_of_iterations;
1111 LOOP_VINFO_NITERS_UNCHANGED (loop_vinfo) = number_of_iterations;
1113 STMT_VINFO_TYPE (vinfo_for_stmt (loop_cond)) = loop_exit_ctrl_vec_info_type;
1115 /* CHECKME: May want to keep it around it in the future. */
1116 if (inner_loop_vinfo)
1117 destroy_loop_vec_info (inner_loop_vinfo, false);
1119 gcc_assert (!loop->aux);
1120 loop->aux = loop_vinfo;
1125 /* Get cost by calling cost target builtin. */
1128 vect_get_cost (enum vect_cost_for_stmt type_of_cost)
1130 tree dummy_type = NULL;
1133 return targetm.vectorize.builtin_vectorization_cost (type_of_cost,
1138 /* Function vect_analyze_loop_operations.
1140 Scan the loop stmts and make sure they are all vectorizable. */
1143 vect_analyze_loop_operations (loop_vec_info loop_vinfo)
1145 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
1146 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
1147 int nbbs = loop->num_nodes;
1148 gimple_stmt_iterator si;
1149 unsigned int vectorization_factor = 0;
1152 stmt_vec_info stmt_info;
1153 bool need_to_vectorize = false;
1154 int min_profitable_iters;
1155 int min_scalar_loop_bound;
1157 bool only_slp_in_loop = true, ok;
1159 if (vect_print_dump_info (REPORT_DETAILS))
1160 fprintf (vect_dump, "=== vect_analyze_loop_operations ===");
1162 gcc_assert (LOOP_VINFO_VECT_FACTOR (loop_vinfo));
1163 vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
1165 for (i = 0; i < nbbs; i++)
1167 basic_block bb = bbs[i];
1169 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
1171 phi = gsi_stmt (si);
1174 stmt_info = vinfo_for_stmt (phi);
1175 if (vect_print_dump_info (REPORT_DETAILS))
1177 fprintf (vect_dump, "examining phi: ");
1178 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
1181 if (! is_loop_header_bb_p (bb))
1183 /* inner-loop loop-closed exit phi in outer-loop vectorization
1184 (i.e. a phi in the tail of the outer-loop).
1185 FORNOW: we currently don't support the case that these phis
1186 are not used in the outerloop (unless it is double reduction,
1187 i.e., this phi is vect_reduction_def), cause this case
1188 requires to actually do something here. */
1189 if ((!STMT_VINFO_RELEVANT_P (stmt_info)
1190 || STMT_VINFO_LIVE_P (stmt_info))
1191 && STMT_VINFO_DEF_TYPE (stmt_info)
1192 != vect_double_reduction_def)
1194 if (vect_print_dump_info (REPORT_DETAILS))
1196 "Unsupported loop-closed phi in outer-loop.");
1202 gcc_assert (stmt_info);
1204 if (STMT_VINFO_LIVE_P (stmt_info))
1206 /* FORNOW: not yet supported. */
1207 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1208 fprintf (vect_dump, "not vectorized: value used after loop.");
1212 if (STMT_VINFO_RELEVANT (stmt_info) == vect_used_in_scope
1213 && STMT_VINFO_DEF_TYPE (stmt_info) != vect_induction_def)
1215 /* A scalar-dependence cycle that we don't support. */
1216 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1217 fprintf (vect_dump, "not vectorized: scalar dependence cycle.");
1221 if (STMT_VINFO_RELEVANT_P (stmt_info))
1223 need_to_vectorize = true;
1224 if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_induction_def)
1225 ok = vectorizable_induction (phi, NULL, NULL);
1230 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1233 "not vectorized: relevant phi not supported: ");
1234 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
1240 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
1242 gimple stmt = gsi_stmt (si);
1243 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
1245 gcc_assert (stmt_info);
1247 if (!vect_analyze_stmt (stmt, &need_to_vectorize, NULL))
1250 if ((STMT_VINFO_RELEVANT_P (stmt_info)
1251 || VECTORIZABLE_CYCLE_DEF (STMT_VINFO_DEF_TYPE (stmt_info)))
1252 && !PURE_SLP_STMT (stmt_info))
1253 /* STMT needs both SLP and loop-based vectorization. */
1254 only_slp_in_loop = false;
1258 /* All operations in the loop are either irrelevant (deal with loop
1259 control, or dead), or only used outside the loop and can be moved
1260 out of the loop (e.g. invariants, inductions). The loop can be
1261 optimized away by scalar optimizations. We're better off not
1262 touching this loop. */
1263 if (!need_to_vectorize)
1265 if (vect_print_dump_info (REPORT_DETAILS))
1267 "All the computation can be taken out of the loop.");
1268 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1270 "not vectorized: redundant loop. no profit to vectorize.");
1274 /* If all the stmts in the loop can be SLPed, we perform only SLP, and
1275 vectorization factor of the loop is the unrolling factor required by the
1276 SLP instances. If that unrolling factor is 1, we say, that we perform
1277 pure SLP on loop - cross iteration parallelism is not exploited. */
1278 if (only_slp_in_loop)
1279 vectorization_factor = LOOP_VINFO_SLP_UNROLLING_FACTOR (loop_vinfo);
1281 vectorization_factor = least_common_multiple (vectorization_factor,
1282 LOOP_VINFO_SLP_UNROLLING_FACTOR (loop_vinfo));
1284 LOOP_VINFO_VECT_FACTOR (loop_vinfo) = vectorization_factor;
1286 if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
1287 && vect_print_dump_info (REPORT_DETAILS))
1289 "vectorization_factor = %d, niters = " HOST_WIDE_INT_PRINT_DEC,
1290 vectorization_factor, LOOP_VINFO_INT_NITERS (loop_vinfo));
1292 if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
1293 && (LOOP_VINFO_INT_NITERS (loop_vinfo) < vectorization_factor))
1295 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1296 fprintf (vect_dump, "not vectorized: iteration count too small.");
1297 if (vect_print_dump_info (REPORT_DETAILS))
1298 fprintf (vect_dump,"not vectorized: iteration count smaller than "
1299 "vectorization factor.");
1303 /* Analyze cost. Decide if worth while to vectorize. */
1305 /* Once VF is set, SLP costs should be updated since the number of created
1306 vector stmts depends on VF. */
1307 vect_update_slp_costs_according_to_vf (loop_vinfo);
1309 min_profitable_iters = vect_estimate_min_profitable_iters (loop_vinfo);
1310 LOOP_VINFO_COST_MODEL_MIN_ITERS (loop_vinfo) = min_profitable_iters;
1312 if (min_profitable_iters < 0)
1314 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1315 fprintf (vect_dump, "not vectorized: vectorization not profitable.");
1316 if (vect_print_dump_info (REPORT_DETAILS))
1317 fprintf (vect_dump, "not vectorized: vector version will never be "
1322 min_scalar_loop_bound = ((PARAM_VALUE (PARAM_MIN_VECT_LOOP_BOUND)
1323 * vectorization_factor) - 1);
1325 /* Use the cost model only if it is more conservative than user specified
1328 th = (unsigned) min_scalar_loop_bound;
1329 if (min_profitable_iters
1330 && (!min_scalar_loop_bound
1331 || min_profitable_iters > min_scalar_loop_bound))
1332 th = (unsigned) min_profitable_iters;
1334 if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
1335 && LOOP_VINFO_INT_NITERS (loop_vinfo) <= th)
1337 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1338 fprintf (vect_dump, "not vectorized: vectorization not "
1340 if (vect_print_dump_info (REPORT_DETAILS))
1341 fprintf (vect_dump, "not vectorized: iteration count smaller than "
1342 "user specified loop bound parameter or minimum "
1343 "profitable iterations (whichever is more conservative).");
1347 if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
1348 || LOOP_VINFO_INT_NITERS (loop_vinfo) % vectorization_factor != 0
1349 || LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo))
1351 if (vect_print_dump_info (REPORT_DETAILS))
1352 fprintf (vect_dump, "epilog loop required.");
1353 if (!vect_can_advance_ivs_p (loop_vinfo))
1355 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1357 "not vectorized: can't create epilog loop 1.");
1360 if (!slpeel_can_duplicate_loop_p (loop, single_exit (loop)))
1362 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1364 "not vectorized: can't create epilog loop 2.");
1373 /* Function vect_analyze_loop_2.
1375 Apply a set of analyses on LOOP, and create a loop_vec_info struct
1376 for it. The different analyses will record information in the
1377 loop_vec_info struct. */
1379 vect_analyze_loop_2 (loop_vec_info loop_vinfo)
1382 int max_vf = MAX_VECTORIZATION_FACTOR;
1385 /* Find all data references in the loop (which correspond to vdefs/vuses)
1386 and analyze their evolution in the loop. Also adjust the minimal
1387 vectorization factor according to the loads and stores.
1389 FORNOW: Handle only simple, array references, which
1390 alignment can be forced, and aligned pointer-references. */
1392 ok = vect_analyze_data_refs (loop_vinfo, NULL, &min_vf);
1395 if (vect_print_dump_info (REPORT_DETAILS))
1396 fprintf (vect_dump, "bad data references.");
1400 /* Classify all cross-iteration scalar data-flow cycles.
1401 Cross-iteration cycles caused by virtual phis are analyzed separately. */
1403 vect_analyze_scalar_cycles (loop_vinfo);
1405 vect_pattern_recog (loop_vinfo);
1407 /* Data-flow analysis to detect stmts that do not need to be vectorized. */
1409 ok = vect_mark_stmts_to_be_vectorized (loop_vinfo);
1412 if (vect_print_dump_info (REPORT_DETAILS))
1413 fprintf (vect_dump, "unexpected pattern.");
1417 /* Analyze data dependences between the data-refs in the loop
1418 and adjust the maximum vectorization factor according to
1420 FORNOW: fail at the first data dependence that we encounter. */
1422 ok = vect_analyze_data_ref_dependences (loop_vinfo, NULL, &max_vf, &dummy);
1426 if (vect_print_dump_info (REPORT_DETAILS))
1427 fprintf (vect_dump, "bad data dependence.");
1431 ok = vect_determine_vectorization_factor (loop_vinfo);
1434 if (vect_print_dump_info (REPORT_DETAILS))
1435 fprintf (vect_dump, "can't determine vectorization factor.");
1438 if (max_vf < LOOP_VINFO_VECT_FACTOR (loop_vinfo))
1440 if (vect_print_dump_info (REPORT_DETAILS))
1441 fprintf (vect_dump, "bad data dependence.");
1445 /* Analyze the alignment of the data-refs in the loop.
1446 Fail if a data reference is found that cannot be vectorized. */
1448 ok = vect_analyze_data_refs_alignment (loop_vinfo, NULL);
1451 if (vect_print_dump_info (REPORT_DETAILS))
1452 fprintf (vect_dump, "bad data alignment.");
1456 /* Analyze the access patterns of the data-refs in the loop (consecutive,
1457 complex, etc.). FORNOW: Only handle consecutive access pattern. */
1459 ok = vect_analyze_data_ref_accesses (loop_vinfo, NULL);
1462 if (vect_print_dump_info (REPORT_DETAILS))
1463 fprintf (vect_dump, "bad data access.");
1467 /* Prune the list of ddrs to be tested at run-time by versioning for alias.
1468 It is important to call pruning after vect_analyze_data_ref_accesses,
1469 since we use grouping information gathered by interleaving analysis. */
1470 ok = vect_prune_runtime_alias_test_list (loop_vinfo);
1473 if (vect_print_dump_info (REPORT_DETAILS))
1474 fprintf (vect_dump, "too long list of versioning for alias "
1479 /* This pass will decide on using loop versioning and/or loop peeling in
1480 order to enhance the alignment of data references in the loop. */
1482 ok = vect_enhance_data_refs_alignment (loop_vinfo);
1485 if (vect_print_dump_info (REPORT_DETAILS))
1486 fprintf (vect_dump, "bad data alignment.");
1490 /* Check the SLP opportunities in the loop, analyze and build SLP trees. */
1491 ok = vect_analyze_slp (loop_vinfo, NULL);
1494 /* Decide which possible SLP instances to SLP. */
1495 vect_make_slp_decision (loop_vinfo);
1497 /* Find stmts that need to be both vectorized and SLPed. */
1498 vect_detect_hybrid_slp (loop_vinfo);
1501 /* Scan all the operations in the loop and make sure they are
1504 ok = vect_analyze_loop_operations (loop_vinfo);
1507 if (vect_print_dump_info (REPORT_DETAILS))
1508 fprintf (vect_dump, "bad operation or unsupported loop bound.");
1515 /* Function vect_analyze_loop.
1517 Apply a set of analyses on LOOP, and create a loop_vec_info struct
1518 for it. The different analyses will record information in the
1519 loop_vec_info struct. */
1521 vect_analyze_loop (struct loop *loop)
1523 loop_vec_info loop_vinfo;
1524 unsigned int vector_sizes;
1526 /* Autodetect first vector size we try. */
1527 current_vector_size = 0;
1528 vector_sizes = targetm.vectorize.autovectorize_vector_sizes ();
1530 if (vect_print_dump_info (REPORT_DETAILS))
1531 fprintf (vect_dump, "===== analyze_loop_nest =====");
1533 if (loop_outer (loop)
1534 && loop_vec_info_for_loop (loop_outer (loop))
1535 && LOOP_VINFO_VECTORIZABLE_P (loop_vec_info_for_loop (loop_outer (loop))))
1537 if (vect_print_dump_info (REPORT_DETAILS))
1538 fprintf (vect_dump, "outer-loop already vectorized.");
1544 /* Check the CFG characteristics of the loop (nesting, entry/exit). */
1545 loop_vinfo = vect_analyze_loop_form (loop);
1548 if (vect_print_dump_info (REPORT_DETAILS))
1549 fprintf (vect_dump, "bad loop form.");
1553 if (vect_analyze_loop_2 (loop_vinfo))
1555 LOOP_VINFO_VECTORIZABLE_P (loop_vinfo) = 1;
1560 destroy_loop_vec_info (loop_vinfo, true);
1562 vector_sizes &= ~current_vector_size;
1563 if (vector_sizes == 0
1564 || current_vector_size == 0)
1567 /* Try the next biggest vector size. */
1568 current_vector_size = 1 << floor_log2 (vector_sizes);
1569 if (vect_print_dump_info (REPORT_DETAILS))
1570 fprintf (vect_dump, "***** Re-trying analysis with "
1571 "vector size %d\n", current_vector_size);
1576 /* Function reduction_code_for_scalar_code
1579 CODE - tree_code of a reduction operations.
1582 REDUC_CODE - the corresponding tree-code to be used to reduce the
1583 vector of partial results into a single scalar result (which
1584 will also reside in a vector) or ERROR_MARK if the operation is
1585 a supported reduction operation, but does not have such tree-code.
1587 Return FALSE if CODE currently cannot be vectorized as reduction. */
1590 reduction_code_for_scalar_code (enum tree_code code,
1591 enum tree_code *reduc_code)
1596 *reduc_code = REDUC_MAX_EXPR;
1600 *reduc_code = REDUC_MIN_EXPR;
1604 *reduc_code = REDUC_PLUS_EXPR;
1612 *reduc_code = ERROR_MARK;
1621 /* Error reporting helper for vect_is_simple_reduction below. GIMPLE statement
1622 STMT is printed with a message MSG. */
1625 report_vect_op (gimple stmt, const char *msg)
1627 fprintf (vect_dump, "%s", msg);
1628 print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
1632 /* Function vect_is_simple_reduction_1
1634 (1) Detect a cross-iteration def-use cycle that represents a simple
1635 reduction computation. We look for the following pattern:
1640 a2 = operation (a3, a1)
1643 1. operation is commutative and associative and it is safe to
1644 change the order of the computation (if CHECK_REDUCTION is true)
1645 2. no uses for a2 in the loop (a2 is used out of the loop)
1646 3. no uses of a1 in the loop besides the reduction operation.
1648 Condition 1 is tested here.
1649 Conditions 2,3 are tested in vect_mark_stmts_to_be_vectorized.
1651 (2) Detect a cross-iteration def-use cycle in nested loops, i.e.,
1652 nested cycles, if CHECK_REDUCTION is false.
1654 (3) Detect cycles of phi nodes in outer-loop vectorization, i.e., double
1658 inner loop (def of a3)
1661 If MODIFY is true it tries also to rework the code in-place to enable
1662 detection of more reduction patterns. For the time being we rewrite
1663 "res -= RHS" into "rhs += -RHS" when it seems worthwhile.
1667 vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
1668 bool check_reduction, bool *double_reduc,
1671 struct loop *loop = (gimple_bb (phi))->loop_father;
1672 struct loop *vect_loop = LOOP_VINFO_LOOP (loop_info);
1673 edge latch_e = loop_latch_edge (loop);
1674 tree loop_arg = PHI_ARG_DEF_FROM_EDGE (phi, latch_e);
1675 gimple def_stmt, def1 = NULL, def2 = NULL;
1676 enum tree_code orig_code, code;
1677 tree op1, op2, op3 = NULL_TREE, op4 = NULL_TREE;
1681 imm_use_iterator imm_iter;
1682 use_operand_p use_p;
1685 *double_reduc = false;
1687 /* If CHECK_REDUCTION is true, we assume inner-most loop vectorization,
1688 otherwise, we assume outer loop vectorization. */
1689 gcc_assert ((check_reduction && loop == vect_loop)
1690 || (!check_reduction && flow_loop_nested_p (vect_loop, loop)));
1692 name = PHI_RESULT (phi);
1694 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, name)
1696 gimple use_stmt = USE_STMT (use_p);
1697 if (is_gimple_debug (use_stmt))
1699 if (flow_bb_inside_loop_p (loop, gimple_bb (use_stmt))
1700 && vinfo_for_stmt (use_stmt)
1701 && !is_pattern_stmt_p (vinfo_for_stmt (use_stmt)))
1705 if (vect_print_dump_info (REPORT_DETAILS))
1706 fprintf (vect_dump, "reduction used in loop.");
1711 if (TREE_CODE (loop_arg) != SSA_NAME)
1713 if (vect_print_dump_info (REPORT_DETAILS))
1715 fprintf (vect_dump, "reduction: not ssa_name: ");
1716 print_generic_expr (vect_dump, loop_arg, TDF_SLIM);
1721 def_stmt = SSA_NAME_DEF_STMT (loop_arg);
1724 if (vect_print_dump_info (REPORT_DETAILS))
1725 fprintf (vect_dump, "reduction: no def_stmt.");
1729 if (!is_gimple_assign (def_stmt) && gimple_code (def_stmt) != GIMPLE_PHI)
1731 if (vect_print_dump_info (REPORT_DETAILS))
1732 print_gimple_stmt (vect_dump, def_stmt, 0, TDF_SLIM);
1736 if (is_gimple_assign (def_stmt))
1738 name = gimple_assign_lhs (def_stmt);
1743 name = PHI_RESULT (def_stmt);
1748 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, name)
1750 gimple use_stmt = USE_STMT (use_p);
1751 if (is_gimple_debug (use_stmt))
1753 if (flow_bb_inside_loop_p (loop, gimple_bb (use_stmt))
1754 && vinfo_for_stmt (use_stmt)
1755 && !is_pattern_stmt_p (vinfo_for_stmt (use_stmt)))
1759 if (vect_print_dump_info (REPORT_DETAILS))
1760 fprintf (vect_dump, "reduction used in loop.");
1765 /* If DEF_STMT is a phi node itself, we expect it to have a single argument
1766 defined in the inner loop. */
1769 op1 = PHI_ARG_DEF (def_stmt, 0);
1771 if (gimple_phi_num_args (def_stmt) != 1
1772 || TREE_CODE (op1) != SSA_NAME)
1774 if (vect_print_dump_info (REPORT_DETAILS))
1775 fprintf (vect_dump, "unsupported phi node definition.");
1780 def1 = SSA_NAME_DEF_STMT (op1);
1781 if (flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))
1783 && flow_bb_inside_loop_p (loop->inner, gimple_bb (def1))
1784 && is_gimple_assign (def1))
1786 if (vect_print_dump_info (REPORT_DETAILS))
1787 report_vect_op (def_stmt, "detected double reduction: ");
1789 *double_reduc = true;
1796 code = orig_code = gimple_assign_rhs_code (def_stmt);
1798 /* We can handle "res -= x[i]", which is non-associative by
1799 simply rewriting this into "res += -x[i]". Avoid changing
1800 gimple instruction for the first simple tests and only do this
1801 if we're allowed to change code at all. */
1802 if (code == MINUS_EXPR
1804 && (op1 = gimple_assign_rhs1 (def_stmt))
1805 && TREE_CODE (op1) == SSA_NAME
1806 && SSA_NAME_DEF_STMT (op1) == phi)
1810 && (!commutative_tree_code (code) || !associative_tree_code (code)))
1812 if (vect_print_dump_info (REPORT_DETAILS))
1813 report_vect_op (def_stmt, "reduction: not commutative/associative: ");
1817 if (get_gimple_rhs_class (code) != GIMPLE_BINARY_RHS)
1819 if (code != COND_EXPR)
1821 if (vect_print_dump_info (REPORT_DETAILS))
1822 report_vect_op (def_stmt, "reduction: not binary operation: ");
1827 op3 = TREE_OPERAND (gimple_assign_rhs1 (def_stmt), 0);
1828 if (COMPARISON_CLASS_P (op3))
1830 op4 = TREE_OPERAND (op3, 1);
1831 op3 = TREE_OPERAND (op3, 0);
1834 op1 = TREE_OPERAND (gimple_assign_rhs1 (def_stmt), 1);
1835 op2 = TREE_OPERAND (gimple_assign_rhs1 (def_stmt), 2);
1837 if (TREE_CODE (op1) != SSA_NAME && TREE_CODE (op2) != SSA_NAME)
1839 if (vect_print_dump_info (REPORT_DETAILS))
1840 report_vect_op (def_stmt, "reduction: uses not ssa_names: ");
1847 op1 = gimple_assign_rhs1 (def_stmt);
1848 op2 = gimple_assign_rhs2 (def_stmt);
1850 if (TREE_CODE (op1) != SSA_NAME || TREE_CODE (op2) != SSA_NAME)
1852 if (vect_print_dump_info (REPORT_DETAILS))
1853 report_vect_op (def_stmt, "reduction: uses not ssa_names: ");
1859 type = TREE_TYPE (gimple_assign_lhs (def_stmt));
1860 if ((TREE_CODE (op1) == SSA_NAME
1861 && !types_compatible_p (type,TREE_TYPE (op1)))
1862 || (TREE_CODE (op2) == SSA_NAME
1863 && !types_compatible_p (type, TREE_TYPE (op2)))
1864 || (op3 && TREE_CODE (op3) == SSA_NAME
1865 && !types_compatible_p (type, TREE_TYPE (op3)))
1866 || (op4 && TREE_CODE (op4) == SSA_NAME
1867 && !types_compatible_p (type, TREE_TYPE (op4))))
1869 if (vect_print_dump_info (REPORT_DETAILS))
1871 fprintf (vect_dump, "reduction: multiple types: operation type: ");
1872 print_generic_expr (vect_dump, type, TDF_SLIM);
1873 fprintf (vect_dump, ", operands types: ");
1874 print_generic_expr (vect_dump, TREE_TYPE (op1), TDF_SLIM);
1875 fprintf (vect_dump, ",");
1876 print_generic_expr (vect_dump, TREE_TYPE (op2), TDF_SLIM);
1879 fprintf (vect_dump, ",");
1880 print_generic_expr (vect_dump, TREE_TYPE (op3), TDF_SLIM);
1885 fprintf (vect_dump, ",");
1886 print_generic_expr (vect_dump, TREE_TYPE (op4), TDF_SLIM);
1893 /* Check that it's ok to change the order of the computation.
1894 Generally, when vectorizing a reduction we change the order of the
1895 computation. This may change the behavior of the program in some
1896 cases, so we need to check that this is ok. One exception is when
1897 vectorizing an outer-loop: the inner-loop is executed sequentially,
1898 and therefore vectorizing reductions in the inner-loop during
1899 outer-loop vectorization is safe. */
1901 /* CHECKME: check for !flag_finite_math_only too? */
1902 if (SCALAR_FLOAT_TYPE_P (type) && !flag_associative_math
1905 /* Changing the order of operations changes the semantics. */
1906 if (vect_print_dump_info (REPORT_DETAILS))
1907 report_vect_op (def_stmt, "reduction: unsafe fp math optimization: ");
1910 else if (INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type)
1913 /* Changing the order of operations changes the semantics. */
1914 if (vect_print_dump_info (REPORT_DETAILS))
1915 report_vect_op (def_stmt, "reduction: unsafe int math optimization: ");
1918 else if (SAT_FIXED_POINT_TYPE_P (type) && check_reduction)
1920 /* Changing the order of operations changes the semantics. */
1921 if (vect_print_dump_info (REPORT_DETAILS))
1922 report_vect_op (def_stmt,
1923 "reduction: unsafe fixed-point math optimization: ");
1927 /* If we detected "res -= x[i]" earlier, rewrite it into
1928 "res += -x[i]" now. If this turns out to be useless reassoc
1929 will clean it up again. */
1930 if (orig_code == MINUS_EXPR)
1932 tree rhs = gimple_assign_rhs2 (def_stmt);
1933 tree negrhs = make_ssa_name (SSA_NAME_VAR (rhs), NULL);
1934 gimple negate_stmt = gimple_build_assign_with_ops (NEGATE_EXPR, negrhs,
1936 gimple_stmt_iterator gsi = gsi_for_stmt (def_stmt);
1937 set_vinfo_for_stmt (negate_stmt, new_stmt_vec_info (negate_stmt,
1939 gsi_insert_before (&gsi, negate_stmt, GSI_NEW_STMT);
1940 gimple_assign_set_rhs2 (def_stmt, negrhs);
1941 gimple_assign_set_rhs_code (def_stmt, PLUS_EXPR);
1942 update_stmt (def_stmt);
1945 /* Reduction is safe. We're dealing with one of the following:
1946 1) integer arithmetic and no trapv
1947 2) floating point arithmetic, and special flags permit this optimization
1948 3) nested cycle (i.e., outer loop vectorization). */
1949 if (TREE_CODE (op1) == SSA_NAME)
1950 def1 = SSA_NAME_DEF_STMT (op1);
1952 if (TREE_CODE (op2) == SSA_NAME)
1953 def2 = SSA_NAME_DEF_STMT (op2);
1955 if (code != COND_EXPR
1956 && (!def1 || !def2 || gimple_nop_p (def1) || gimple_nop_p (def2)))
1958 if (vect_print_dump_info (REPORT_DETAILS))
1959 report_vect_op (def_stmt, "reduction: no defs for operands: ");
1963 /* Check that one def is the reduction def, defined by PHI,
1964 the other def is either defined in the loop ("vect_internal_def"),
1965 or it's an induction (defined by a loop-header phi-node). */
1967 if (def2 && def2 == phi
1968 && (code == COND_EXPR
1969 || (def1 && flow_bb_inside_loop_p (loop, gimple_bb (def1))
1970 && (is_gimple_assign (def1)
1971 || STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def1))
1972 == vect_induction_def
1973 || (gimple_code (def1) == GIMPLE_PHI
1974 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def1))
1975 == vect_internal_def
1976 && !is_loop_header_bb_p (gimple_bb (def1)))))))
1978 if (vect_print_dump_info (REPORT_DETAILS))
1979 report_vect_op (def_stmt, "detected reduction: ");
1982 else if (def1 && def1 == phi
1983 && (code == COND_EXPR
1984 || (def2 && flow_bb_inside_loop_p (loop, gimple_bb (def2))
1985 && (is_gimple_assign (def2)
1986 || STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def2))
1987 == vect_induction_def
1988 || (gimple_code (def2) == GIMPLE_PHI
1989 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def2))
1990 == vect_internal_def
1991 && !is_loop_header_bb_p (gimple_bb (def2)))))))
1993 if (check_reduction)
1995 /* Swap operands (just for simplicity - so that the rest of the code
1996 can assume that the reduction variable is always the last (second)
1998 if (vect_print_dump_info (REPORT_DETAILS))
1999 report_vect_op (def_stmt,
2000 "detected reduction: need to swap operands: ");
2002 swap_tree_operands (def_stmt, gimple_assign_rhs1_ptr (def_stmt),
2003 gimple_assign_rhs2_ptr (def_stmt));
2007 if (vect_print_dump_info (REPORT_DETAILS))
2008 report_vect_op (def_stmt, "detected reduction: ");
2015 if (vect_print_dump_info (REPORT_DETAILS))
2016 report_vect_op (def_stmt, "reduction: unknown pattern: ");
2022 /* Wrapper around vect_is_simple_reduction_1, that won't modify code
2023 in-place. Arguments as there. */
2026 vect_is_simple_reduction (loop_vec_info loop_info, gimple phi,
2027 bool check_reduction, bool *double_reduc)
2029 return vect_is_simple_reduction_1 (loop_info, phi, check_reduction,
2030 double_reduc, false);
2033 /* Wrapper around vect_is_simple_reduction_1, which will modify code
2034 in-place if it enables detection of more reductions. Arguments
2038 vect_force_simple_reduction (loop_vec_info loop_info, gimple phi,
2039 bool check_reduction, bool *double_reduc)
2041 return vect_is_simple_reduction_1 (loop_info, phi, check_reduction,
2042 double_reduc, true);
2045 /* Calculate the cost of one scalar iteration of the loop. */
2047 vect_get_single_scalar_iteraion_cost (loop_vec_info loop_vinfo)
2049 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2050 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
2051 int nbbs = loop->num_nodes, factor, scalar_single_iter_cost = 0;
2052 int innerloop_iters, i, stmt_cost;
2054 /* Count statements in scalar loop. Using this as scalar cost for a single
2057 TODO: Add outer loop support.
2059 TODO: Consider assigning different costs to different scalar
2063 innerloop_iters = 1;
2065 innerloop_iters = 50; /* FIXME */
2067 for (i = 0; i < nbbs; i++)
2069 gimple_stmt_iterator si;
2070 basic_block bb = bbs[i];
2072 if (bb->loop_father == loop->inner)
2073 factor = innerloop_iters;
2077 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
2079 gimple stmt = gsi_stmt (si);
2080 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
2082 if (!is_gimple_assign (stmt) && !is_gimple_call (stmt))
2085 /* Skip stmts that are not vectorized inside the loop. */
2087 && !STMT_VINFO_RELEVANT_P (stmt_info)
2088 && (!STMT_VINFO_LIVE_P (stmt_info)
2089 || STMT_VINFO_DEF_TYPE (stmt_info) != vect_reduction_def))
2092 if (STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt)))
2094 if (DR_IS_READ (STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt))))
2095 stmt_cost = vect_get_cost (scalar_load);
2097 stmt_cost = vect_get_cost (scalar_store);
2100 stmt_cost = vect_get_cost (scalar_stmt);
2102 scalar_single_iter_cost += stmt_cost * factor;
2105 return scalar_single_iter_cost;
2108 /* Calculate cost of peeling the loop PEEL_ITERS_PROLOGUE times. */
2110 vect_get_known_peeling_cost (loop_vec_info loop_vinfo, int peel_iters_prologue,
2111 int *peel_iters_epilogue,
2112 int scalar_single_iter_cost)
2114 int peel_guard_costs = 0;
2115 int vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
2117 if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo))
2119 *peel_iters_epilogue = vf/2;
2120 if (vect_print_dump_info (REPORT_COST))
2121 fprintf (vect_dump, "cost model: "
2122 "epilogue peel iters set to vf/2 because "
2123 "loop iterations are unknown .");
2125 /* If peeled iterations are known but number of scalar loop
2126 iterations are unknown, count a taken branch per peeled loop. */
2127 peel_guard_costs = 2 * vect_get_cost (cond_branch_taken);
2131 int niters = LOOP_VINFO_INT_NITERS (loop_vinfo);
2132 peel_iters_prologue = niters < peel_iters_prologue ?
2133 niters : peel_iters_prologue;
2134 *peel_iters_epilogue = (niters - peel_iters_prologue) % vf;
2137 return (peel_iters_prologue * scalar_single_iter_cost)
2138 + (*peel_iters_epilogue * scalar_single_iter_cost)
2142 /* Function vect_estimate_min_profitable_iters
2144 Return the number of iterations required for the vector version of the
2145 loop to be profitable relative to the cost of the scalar version of the
2148 TODO: Take profile info into account before making vectorization
2149 decisions, if available. */
2152 vect_estimate_min_profitable_iters (loop_vec_info loop_vinfo)
2155 int min_profitable_iters;
2156 int peel_iters_prologue;
2157 int peel_iters_epilogue;
2158 int vec_inside_cost = 0;
2159 int vec_outside_cost = 0;
2160 int scalar_single_iter_cost = 0;
2161 int scalar_outside_cost = 0;
2162 int vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
2163 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2164 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
2165 int nbbs = loop->num_nodes;
2166 int npeel = LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo);
2167 int peel_guard_costs = 0;
2168 int innerloop_iters = 0, factor;
2169 VEC (slp_instance, heap) *slp_instances;
2170 slp_instance instance;
2172 /* Cost model disabled. */
2173 if (!flag_vect_cost_model)
2175 if (vect_print_dump_info (REPORT_COST))
2176 fprintf (vect_dump, "cost model disabled.");
2180 /* Requires loop versioning tests to handle misalignment. */
2181 if (LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo))
2183 /* FIXME: Make cost depend on complexity of individual check. */
2185 VEC_length (gimple, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo));
2186 if (vect_print_dump_info (REPORT_COST))
2187 fprintf (vect_dump, "cost model: Adding cost of checks for loop "
2188 "versioning to treat misalignment.\n");
2191 /* Requires loop versioning with alias checks. */
2192 if (LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
2194 /* FIXME: Make cost depend on complexity of individual check. */
2196 VEC_length (ddr_p, LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo));
2197 if (vect_print_dump_info (REPORT_COST))
2198 fprintf (vect_dump, "cost model: Adding cost of checks for loop "
2199 "versioning aliasing.\n");
2202 if (LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)
2203 || LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
2204 vec_outside_cost += vect_get_cost (cond_branch_taken);
2206 /* Count statements in scalar loop. Using this as scalar cost for a single
2209 TODO: Add outer loop support.
2211 TODO: Consider assigning different costs to different scalar
2216 innerloop_iters = 50; /* FIXME */
2218 for (i = 0; i < nbbs; i++)
2220 gimple_stmt_iterator si;
2221 basic_block bb = bbs[i];
2223 if (bb->loop_father == loop->inner)
2224 factor = innerloop_iters;
2228 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
2230 gimple stmt = gsi_stmt (si);
2231 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
2232 /* Skip stmts that are not vectorized inside the loop. */
2233 if (!STMT_VINFO_RELEVANT_P (stmt_info)
2234 && (!STMT_VINFO_LIVE_P (stmt_info)
2235 || STMT_VINFO_DEF_TYPE (stmt_info) != vect_reduction_def))
2237 vec_inside_cost += STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info) * factor;
2238 /* FIXME: for stmts in the inner-loop in outer-loop vectorization,
2239 some of the "outside" costs are generated inside the outer-loop. */
2240 vec_outside_cost += STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info);
2244 scalar_single_iter_cost = vect_get_single_scalar_iteraion_cost (loop_vinfo);
2246 /* Add additional cost for the peeled instructions in prologue and epilogue
2249 FORNOW: If we don't know the value of peel_iters for prologue or epilogue
2250 at compile-time - we assume it's vf/2 (the worst would be vf-1).
2252 TODO: Build an expression that represents peel_iters for prologue and
2253 epilogue to be used in a run-time test. */
2257 peel_iters_prologue = vf/2;
2258 if (vect_print_dump_info (REPORT_COST))
2259 fprintf (vect_dump, "cost model: "
2260 "prologue peel iters set to vf/2.");
2262 /* If peeling for alignment is unknown, loop bound of main loop becomes
2264 peel_iters_epilogue = vf/2;
2265 if (vect_print_dump_info (REPORT_COST))
2266 fprintf (vect_dump, "cost model: "
2267 "epilogue peel iters set to vf/2 because "
2268 "peeling for alignment is unknown .");
2270 /* If peeled iterations are unknown, count a taken branch and a not taken
2271 branch per peeled loop. Even if scalar loop iterations are known,
2272 vector iterations are not known since peeled prologue iterations are
2273 not known. Hence guards remain the same. */
2274 peel_guard_costs += 2 * (vect_get_cost (cond_branch_taken)
2275 + vect_get_cost (cond_branch_not_taken));
2276 vec_outside_cost += (peel_iters_prologue * scalar_single_iter_cost)
2277 + (peel_iters_epilogue * scalar_single_iter_cost)
2282 peel_iters_prologue = npeel;
2283 vec_outside_cost += vect_get_known_peeling_cost (loop_vinfo,
2284 peel_iters_prologue, &peel_iters_epilogue,
2285 scalar_single_iter_cost);
2288 /* FORNOW: The scalar outside cost is incremented in one of the
2291 1. The vectorizer checks for alignment and aliasing and generates
2292 a condition that allows dynamic vectorization. A cost model
2293 check is ANDED with the versioning condition. Hence scalar code
2294 path now has the added cost of the versioning check.
2296 if (cost > th & versioning_check)
2299 Hence run-time scalar is incremented by not-taken branch cost.
2301 2. The vectorizer then checks if a prologue is required. If the
2302 cost model check was not done before during versioning, it has to
2303 be done before the prologue check.
2306 prologue = scalar_iters
2311 if (prologue == num_iters)
2314 Hence the run-time scalar cost is incremented by a taken branch,
2315 plus a not-taken branch, plus a taken branch cost.
2317 3. The vectorizer then checks if an epilogue is required. If the
2318 cost model check was not done before during prologue check, it
2319 has to be done with the epilogue check.
2325 if (prologue == num_iters)
2328 if ((cost <= th) | (scalar_iters-prologue-epilogue == 0))
2331 Hence the run-time scalar cost should be incremented by 2 taken
2334 TODO: The back end may reorder the BBS's differently and reverse
2335 conditions/branch directions. Change the estimates below to
2336 something more reasonable. */
2338 /* If the number of iterations is known and we do not do versioning, we can
2339 decide whether to vectorize at compile time. Hence the scalar version
2340 do not carry cost model guard costs. */
2341 if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
2342 || LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)
2343 || LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
2345 /* Cost model check occurs at versioning. */
2346 if (LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)
2347 || LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
2348 scalar_outside_cost += vect_get_cost (cond_branch_not_taken);
2351 /* Cost model check occurs at prologue generation. */
2352 if (LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo) < 0)
2353 scalar_outside_cost += 2 * vect_get_cost (cond_branch_taken)
2354 + vect_get_cost (cond_branch_not_taken);
2355 /* Cost model check occurs at epilogue generation. */
2357 scalar_outside_cost += 2 * vect_get_cost (cond_branch_taken);
2361 /* Add SLP costs. */
2362 slp_instances = LOOP_VINFO_SLP_INSTANCES (loop_vinfo);
2363 FOR_EACH_VEC_ELT (slp_instance, slp_instances, i, instance)
2365 vec_outside_cost += SLP_INSTANCE_OUTSIDE_OF_LOOP_COST (instance);
2366 vec_inside_cost += SLP_INSTANCE_INSIDE_OF_LOOP_COST (instance);
2369 /* Calculate number of iterations required to make the vector version
2370 profitable, relative to the loop bodies only. The following condition
2372 SIC * niters + SOC > VIC * ((niters-PL_ITERS-EP_ITERS)/VF) + VOC
2374 SIC = scalar iteration cost, VIC = vector iteration cost,
2375 VOC = vector outside cost, VF = vectorization factor,
2376 PL_ITERS = prologue iterations, EP_ITERS= epilogue iterations
2377 SOC = scalar outside cost for run time cost model check. */
2379 if ((scalar_single_iter_cost * vf) > vec_inside_cost)
2381 if (vec_outside_cost <= 0)
2382 min_profitable_iters = 1;
2385 min_profitable_iters = ((vec_outside_cost - scalar_outside_cost) * vf
2386 - vec_inside_cost * peel_iters_prologue
2387 - vec_inside_cost * peel_iters_epilogue)
2388 / ((scalar_single_iter_cost * vf)
2391 if ((scalar_single_iter_cost * vf * min_profitable_iters)
2392 <= ((vec_inside_cost * min_profitable_iters)
2393 + ((vec_outside_cost - scalar_outside_cost) * vf)))
2394 min_profitable_iters++;
2397 /* vector version will never be profitable. */
2400 if (vect_print_dump_info (REPORT_COST))
2401 fprintf (vect_dump, "cost model: the vector iteration cost = %d "
2402 "divided by the scalar iteration cost = %d "
2403 "is greater or equal to the vectorization factor = %d.",
2404 vec_inside_cost, scalar_single_iter_cost, vf);
2408 if (vect_print_dump_info (REPORT_COST))
2410 fprintf (vect_dump, "Cost model analysis: \n");
2411 fprintf (vect_dump, " Vector inside of loop cost: %d\n",
2413 fprintf (vect_dump, " Vector outside of loop cost: %d\n",
2415 fprintf (vect_dump, " Scalar iteration cost: %d\n",
2416 scalar_single_iter_cost);
2417 fprintf (vect_dump, " Scalar outside cost: %d\n", scalar_outside_cost);
2418 fprintf (vect_dump, " prologue iterations: %d\n",
2419 peel_iters_prologue);
2420 fprintf (vect_dump, " epilogue iterations: %d\n",
2421 peel_iters_epilogue);
2422 fprintf (vect_dump, " Calculated minimum iters for profitability: %d\n",
2423 min_profitable_iters);
2426 min_profitable_iters =
2427 min_profitable_iters < vf ? vf : min_profitable_iters;
2429 /* Because the condition we create is:
2430 if (niters <= min_profitable_iters)
2431 then skip the vectorized loop. */
2432 min_profitable_iters--;
2434 if (vect_print_dump_info (REPORT_COST))
2435 fprintf (vect_dump, " Profitability threshold = %d\n",
2436 min_profitable_iters);
2438 return min_profitable_iters;
2442 /* TODO: Close dependency between vect_model_*_cost and vectorizable_*
2443 functions. Design better to avoid maintenance issues. */
2445 /* Function vect_model_reduction_cost.
2447 Models cost for a reduction operation, including the vector ops
2448 generated within the strip-mine loop, the initial definition before
2449 the loop, and the epilogue code that must be generated. */
2452 vect_model_reduction_cost (stmt_vec_info stmt_info, enum tree_code reduc_code,
2456 enum tree_code code;
2459 gimple stmt, orig_stmt;
2461 enum machine_mode mode;
2462 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
2463 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2466 /* Cost of reduction op inside loop. */
2467 STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info)
2468 += ncopies * vect_get_cost (vector_stmt);
2470 stmt = STMT_VINFO_STMT (stmt_info);
2472 switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
2474 case GIMPLE_SINGLE_RHS:
2475 gcc_assert (TREE_OPERAND_LENGTH (gimple_assign_rhs1 (stmt)) == ternary_op);
2476 reduction_op = TREE_OPERAND (gimple_assign_rhs1 (stmt), 2);
2478 case GIMPLE_UNARY_RHS:
2479 reduction_op = gimple_assign_rhs1 (stmt);
2481 case GIMPLE_BINARY_RHS:
2482 reduction_op = gimple_assign_rhs2 (stmt);
2488 vectype = get_vectype_for_scalar_type (TREE_TYPE (reduction_op));
2491 if (vect_print_dump_info (REPORT_COST))
2493 fprintf (vect_dump, "unsupported data-type ");
2494 print_generic_expr (vect_dump, TREE_TYPE (reduction_op), TDF_SLIM);
2499 mode = TYPE_MODE (vectype);
2500 orig_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
2503 orig_stmt = STMT_VINFO_STMT (stmt_info);
2505 code = gimple_assign_rhs_code (orig_stmt);
2507 /* Add in cost for initial definition. */
2508 outer_cost += vect_get_cost (scalar_to_vec);
2510 /* Determine cost of epilogue code.
2512 We have a reduction operator that will reduce the vector in one statement.
2513 Also requires scalar extract. */
2515 if (!nested_in_vect_loop_p (loop, orig_stmt))
2517 if (reduc_code != ERROR_MARK)
2518 outer_cost += vect_get_cost (vector_stmt)
2519 + vect_get_cost (vec_to_scalar);
2522 int vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1);
2524 TYPE_SIZE (TREE_TYPE (gimple_assign_lhs (orig_stmt)));
2525 int element_bitsize = tree_low_cst (bitsize, 1);
2526 int nelements = vec_size_in_bits / element_bitsize;
2528 optab = optab_for_tree_code (code, vectype, optab_default);
2530 /* We have a whole vector shift available. */
2531 if (VECTOR_MODE_P (mode)
2532 && optab_handler (optab, mode) != CODE_FOR_nothing
2533 && optab_handler (vec_shr_optab, mode) != CODE_FOR_nothing)
2534 /* Final reduction via vector shifts and the reduction operator. Also
2535 requires scalar extract. */
2536 outer_cost += ((exact_log2(nelements) * 2)
2537 * vect_get_cost (vector_stmt)
2538 + vect_get_cost (vec_to_scalar));
2540 /* Use extracts and reduction op for final reduction. For N elements,
2541 we have N extracts and N-1 reduction ops. */
2542 outer_cost += ((nelements + nelements - 1)
2543 * vect_get_cost (vector_stmt));
2547 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info) = outer_cost;
2549 if (vect_print_dump_info (REPORT_COST))
2550 fprintf (vect_dump, "vect_model_reduction_cost: inside_cost = %d, "
2551 "outside_cost = %d .", STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info),
2552 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info));
2558 /* Function vect_model_induction_cost.
2560 Models cost for induction operations. */
2563 vect_model_induction_cost (stmt_vec_info stmt_info, int ncopies)
2565 /* loop cost for vec_loop. */
2566 STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info)
2567 = ncopies * vect_get_cost (vector_stmt);
2568 /* prologue cost for vec_init and vec_step. */
2569 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info)
2570 = 2 * vect_get_cost (scalar_to_vec);
2572 if (vect_print_dump_info (REPORT_COST))
2573 fprintf (vect_dump, "vect_model_induction_cost: inside_cost = %d, "
2574 "outside_cost = %d .", STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info),
2575 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info));
2579 /* Function get_initial_def_for_induction
2582 STMT - a stmt that performs an induction operation in the loop.
2583 IV_PHI - the initial value of the induction variable
2586 Return a vector variable, initialized with the first VF values of
2587 the induction variable. E.g., for an iv with IV_PHI='X' and
2588 evolution S, for a vector of 4 units, we want to return:
2589 [X, X + S, X + 2*S, X + 3*S]. */
2592 get_initial_def_for_induction (gimple iv_phi)
2594 stmt_vec_info stmt_vinfo = vinfo_for_stmt (iv_phi);
2595 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
2596 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2597 tree scalar_type = TREE_TYPE (gimple_phi_result (iv_phi));
2600 edge pe = loop_preheader_edge (loop);
2601 struct loop *iv_loop;
2603 tree vec, vec_init, vec_step, t;
2607 gimple init_stmt, induction_phi, new_stmt;
2608 tree induc_def, vec_def, vec_dest;
2609 tree init_expr, step_expr;
2610 int vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
2615 stmt_vec_info phi_info = vinfo_for_stmt (iv_phi);
2616 bool nested_in_vect_loop = false;
2617 gimple_seq stmts = NULL;
2618 imm_use_iterator imm_iter;
2619 use_operand_p use_p;
2623 gimple_stmt_iterator si;
2624 basic_block bb = gimple_bb (iv_phi);
2627 vectype = get_vectype_for_scalar_type (scalar_type);
2628 gcc_assert (vectype);
2629 nunits = TYPE_VECTOR_SUBPARTS (vectype);
2630 ncopies = vf / nunits;
2632 gcc_assert (phi_info);
2633 gcc_assert (ncopies >= 1);
2635 /* Find the first insertion point in the BB. */
2636 si = gsi_after_labels (bb);
2638 if (INTEGRAL_TYPE_P (scalar_type))
2639 step_expr = build_int_cst (scalar_type, 0);
2640 else if (POINTER_TYPE_P (scalar_type))
2641 step_expr = size_zero_node;
2643 step_expr = build_real (scalar_type, dconst0);
2645 /* Is phi in an inner-loop, while vectorizing an enclosing outer-loop? */
2646 if (nested_in_vect_loop_p (loop, iv_phi))
2648 nested_in_vect_loop = true;
2649 iv_loop = loop->inner;
2653 gcc_assert (iv_loop == (gimple_bb (iv_phi))->loop_father);
2655 latch_e = loop_latch_edge (iv_loop);
2656 loop_arg = PHI_ARG_DEF_FROM_EDGE (iv_phi, latch_e);
2658 access_fn = analyze_scalar_evolution (iv_loop, PHI_RESULT (iv_phi));
2659 gcc_assert (access_fn);
2660 ok = vect_is_simple_iv_evolution (iv_loop->num, access_fn,
2661 &init_expr, &step_expr);
2663 pe = loop_preheader_edge (iv_loop);
2665 /* Create the vector that holds the initial_value of the induction. */
2666 if (nested_in_vect_loop)
2668 /* iv_loop is nested in the loop to be vectorized. init_expr had already
2669 been created during vectorization of previous stmts. We obtain it
2670 from the STMT_VINFO_VEC_STMT of the defining stmt. */
2671 tree iv_def = PHI_ARG_DEF_FROM_EDGE (iv_phi,
2672 loop_preheader_edge (iv_loop));
2673 vec_init = vect_get_vec_def_for_operand (iv_def, iv_phi, NULL);
2677 /* iv_loop is the loop to be vectorized. Create:
2678 vec_init = [X, X+S, X+2*S, X+3*S] (S = step_expr, X = init_expr) */
2679 new_var = vect_get_new_vect_var (scalar_type, vect_scalar_var, "var_");
2680 add_referenced_var (new_var);
2682 new_name = force_gimple_operand (init_expr, &stmts, false, new_var);
2685 new_bb = gsi_insert_seq_on_edge_immediate (pe, stmts);
2686 gcc_assert (!new_bb);
2690 t = tree_cons (NULL_TREE, init_expr, t);
2691 for (i = 1; i < nunits; i++)
2693 /* Create: new_name_i = new_name + step_expr */
2694 enum tree_code code = POINTER_TYPE_P (scalar_type)
2695 ? POINTER_PLUS_EXPR : PLUS_EXPR;
2696 init_stmt = gimple_build_assign_with_ops (code, new_var,
2697 new_name, step_expr);
2698 new_name = make_ssa_name (new_var, init_stmt);
2699 gimple_assign_set_lhs (init_stmt, new_name);
2701 new_bb = gsi_insert_on_edge_immediate (pe, init_stmt);
2702 gcc_assert (!new_bb);
2704 if (vect_print_dump_info (REPORT_DETAILS))
2706 fprintf (vect_dump, "created new init_stmt: ");
2707 print_gimple_stmt (vect_dump, init_stmt, 0, TDF_SLIM);
2709 t = tree_cons (NULL_TREE, new_name, t);
2711 /* Create a vector from [new_name_0, new_name_1, ..., new_name_nunits-1] */
2712 vec = build_constructor_from_list (vectype, nreverse (t));
2713 vec_init = vect_init_vector (iv_phi, vec, vectype, NULL);
2717 /* Create the vector that holds the step of the induction. */
2718 if (nested_in_vect_loop)
2719 /* iv_loop is nested in the loop to be vectorized. Generate:
2720 vec_step = [S, S, S, S] */
2721 new_name = step_expr;
2724 /* iv_loop is the loop to be vectorized. Generate:
2725 vec_step = [VF*S, VF*S, VF*S, VF*S] */
2726 expr = build_int_cst (TREE_TYPE (step_expr), vf);
2727 new_name = fold_build2 (MULT_EXPR, TREE_TYPE (step_expr),
2731 t = unshare_expr (new_name);
2732 gcc_assert (CONSTANT_CLASS_P (new_name));
2733 stepvectype = get_vectype_for_scalar_type (TREE_TYPE (new_name));
2734 gcc_assert (stepvectype);
2735 vec = build_vector_from_val (stepvectype, t);
2736 vec_step = vect_init_vector (iv_phi, vec, stepvectype, NULL);
2739 /* Create the following def-use cycle:
2744 vec_iv = PHI <vec_init, vec_loop>
2748 vec_loop = vec_iv + vec_step; */
2750 /* Create the induction-phi that defines the induction-operand. */
2751 vec_dest = vect_get_new_vect_var (vectype, vect_simple_var, "vec_iv_");
2752 add_referenced_var (vec_dest);
2753 induction_phi = create_phi_node (vec_dest, iv_loop->header);
2754 set_vinfo_for_stmt (induction_phi,
2755 new_stmt_vec_info (induction_phi, loop_vinfo, NULL));
2756 induc_def = PHI_RESULT (induction_phi);
2758 /* Create the iv update inside the loop */
2759 new_stmt = gimple_build_assign_with_ops (PLUS_EXPR, vec_dest,
2760 induc_def, vec_step);
2761 vec_def = make_ssa_name (vec_dest, new_stmt);
2762 gimple_assign_set_lhs (new_stmt, vec_def);
2763 gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
2764 set_vinfo_for_stmt (new_stmt, new_stmt_vec_info (new_stmt, loop_vinfo,
2767 /* Set the arguments of the phi node: */
2768 add_phi_arg (induction_phi, vec_init, pe, UNKNOWN_LOCATION);
2769 add_phi_arg (induction_phi, vec_def, loop_latch_edge (iv_loop),
2773 /* In case that vectorization factor (VF) is bigger than the number
2774 of elements that we can fit in a vectype (nunits), we have to generate
2775 more than one vector stmt - i.e - we need to "unroll" the
2776 vector stmt by a factor VF/nunits. For more details see documentation
2777 in vectorizable_operation. */
2781 stmt_vec_info prev_stmt_vinfo;
2782 /* FORNOW. This restriction should be relaxed. */
2783 gcc_assert (!nested_in_vect_loop);
2785 /* Create the vector that holds the step of the induction. */
2786 expr = build_int_cst (TREE_TYPE (step_expr), nunits);
2787 new_name = fold_build2 (MULT_EXPR, TREE_TYPE (step_expr),
2789 t = unshare_expr (new_name);
2790 gcc_assert (CONSTANT_CLASS_P (new_name));
2791 vec = build_vector_from_val (stepvectype, t);
2792 vec_step = vect_init_vector (iv_phi, vec, stepvectype, NULL);
2794 vec_def = induc_def;
2795 prev_stmt_vinfo = vinfo_for_stmt (induction_phi);
2796 for (i = 1; i < ncopies; i++)
2798 /* vec_i = vec_prev + vec_step */
2799 new_stmt = gimple_build_assign_with_ops (PLUS_EXPR, vec_dest,
2801 vec_def = make_ssa_name (vec_dest, new_stmt);
2802 gimple_assign_set_lhs (new_stmt, vec_def);
2804 gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
2805 set_vinfo_for_stmt (new_stmt,
2806 new_stmt_vec_info (new_stmt, loop_vinfo, NULL));
2807 STMT_VINFO_RELATED_STMT (prev_stmt_vinfo) = new_stmt;
2808 prev_stmt_vinfo = vinfo_for_stmt (new_stmt);
2812 if (nested_in_vect_loop)
2814 /* Find the loop-closed exit-phi of the induction, and record
2815 the final vector of induction results: */
2817 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, loop_arg)
2819 if (!flow_bb_inside_loop_p (iv_loop, gimple_bb (USE_STMT (use_p))))
2821 exit_phi = USE_STMT (use_p);
2827 stmt_vec_info stmt_vinfo = vinfo_for_stmt (exit_phi);
2828 /* FORNOW. Currently not supporting the case that an inner-loop induction
2829 is not used in the outer-loop (i.e. only outside the outer-loop). */
2830 gcc_assert (STMT_VINFO_RELEVANT_P (stmt_vinfo)
2831 && !STMT_VINFO_LIVE_P (stmt_vinfo));
2833 STMT_VINFO_VEC_STMT (stmt_vinfo) = new_stmt;
2834 if (vect_print_dump_info (REPORT_DETAILS))
2836 fprintf (vect_dump, "vector of inductions after inner-loop:");
2837 print_gimple_stmt (vect_dump, new_stmt, 0, TDF_SLIM);
2843 if (vect_print_dump_info (REPORT_DETAILS))
2845 fprintf (vect_dump, "transform induction: created def-use cycle: ");
2846 print_gimple_stmt (vect_dump, induction_phi, 0, TDF_SLIM);
2847 fprintf (vect_dump, "\n");
2848 print_gimple_stmt (vect_dump, SSA_NAME_DEF_STMT (vec_def), 0, TDF_SLIM);
2851 STMT_VINFO_VEC_STMT (phi_info) = induction_phi;
2856 /* Function get_initial_def_for_reduction
2859 STMT - a stmt that performs a reduction operation in the loop.
2860 INIT_VAL - the initial value of the reduction variable
2863 ADJUSTMENT_DEF - a tree that holds a value to be added to the final result
2864 of the reduction (used for adjusting the epilog - see below).
2865 Return a vector variable, initialized according to the operation that STMT
2866 performs. This vector will be used as the initial value of the
2867 vector of partial results.
2869 Option1 (adjust in epilog): Initialize the vector as follows:
2870 add/bit or/xor: [0,0,...,0,0]
2871 mult/bit and: [1,1,...,1,1]
2872 min/max/cond_expr: [init_val,init_val,..,init_val,init_val]
2873 and when necessary (e.g. add/mult case) let the caller know
2874 that it needs to adjust the result by init_val.
2876 Option2: Initialize the vector as follows:
2877 add/bit or/xor: [init_val,0,0,...,0]
2878 mult/bit and: [init_val,1,1,...,1]
2879 min/max/cond_expr: [init_val,init_val,...,init_val]
2880 and no adjustments are needed.
2882 For example, for the following code:
2888 STMT is 's = s + a[i]', and the reduction variable is 's'.
2889 For a vector of 4 units, we want to return either [0,0,0,init_val],
2890 or [0,0,0,0] and let the caller know that it needs to adjust
2891 the result at the end by 'init_val'.
2893 FORNOW, we are using the 'adjust in epilog' scheme, because this way the
2894 initialization vector is simpler (same element in all entries), if
2895 ADJUSTMENT_DEF is not NULL, and Option2 otherwise.
2897 A cost model should help decide between these two schemes. */
2900 get_initial_def_for_reduction (gimple stmt, tree init_val,
2901 tree *adjustment_def)
2903 stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt);
2904 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
2905 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2906 tree scalar_type = TREE_TYPE (init_val);
2907 tree vectype = get_vectype_for_scalar_type (scalar_type);
2909 enum tree_code code = gimple_assign_rhs_code (stmt);
2914 bool nested_in_vect_loop = false;
2916 REAL_VALUE_TYPE real_init_val = dconst0;
2917 int int_init_val = 0;
2918 gimple def_stmt = NULL;
2920 gcc_assert (vectype);
2921 nunits = TYPE_VECTOR_SUBPARTS (vectype);
2923 gcc_assert (POINTER_TYPE_P (scalar_type) || INTEGRAL_TYPE_P (scalar_type)
2924 || SCALAR_FLOAT_TYPE_P (scalar_type));
2926 if (nested_in_vect_loop_p (loop, stmt))
2927 nested_in_vect_loop = true;
2929 gcc_assert (loop == (gimple_bb (stmt))->loop_father);
2931 /* In case of double reduction we only create a vector variable to be put
2932 in the reduction phi node. The actual statement creation is done in
2933 vect_create_epilog_for_reduction. */
2934 if (adjustment_def && nested_in_vect_loop
2935 && TREE_CODE (init_val) == SSA_NAME
2936 && (def_stmt = SSA_NAME_DEF_STMT (init_val))
2937 && gimple_code (def_stmt) == GIMPLE_PHI
2938 && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))
2939 && vinfo_for_stmt (def_stmt)
2940 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def_stmt))
2941 == vect_double_reduction_def)
2943 *adjustment_def = NULL;
2944 return vect_create_destination_var (init_val, vectype);
2947 if (TREE_CONSTANT (init_val))
2949 if (SCALAR_FLOAT_TYPE_P (scalar_type))
2950 init_value = build_real (scalar_type, TREE_REAL_CST (init_val));
2952 init_value = build_int_cst (scalar_type, TREE_INT_CST_LOW (init_val));
2955 init_value = init_val;
2959 case WIDEN_SUM_EXPR:
2967 /* ADJUSMENT_DEF is NULL when called from
2968 vect_create_epilog_for_reduction to vectorize double reduction. */
2971 if (nested_in_vect_loop)
2972 *adjustment_def = vect_get_vec_def_for_operand (init_val, stmt,
2975 *adjustment_def = init_val;
2978 if (code == MULT_EXPR)
2980 real_init_val = dconst1;
2984 if (code == BIT_AND_EXPR)
2987 if (SCALAR_FLOAT_TYPE_P (scalar_type))
2988 def_for_init = build_real (scalar_type, real_init_val);
2990 def_for_init = build_int_cst (scalar_type, int_init_val);
2992 /* Create a vector of '0' or '1' except the first element. */
2993 for (i = nunits - 2; i >= 0; --i)
2994 t = tree_cons (NULL_TREE, def_for_init, t);
2996 /* Option1: the first element is '0' or '1' as well. */
2999 t = tree_cons (NULL_TREE, def_for_init, t);
3000 init_def = build_vector (vectype, t);
3004 /* Option2: the first element is INIT_VAL. */
3005 t = tree_cons (NULL_TREE, init_value, t);
3006 if (TREE_CONSTANT (init_val))
3007 init_def = build_vector (vectype, t);
3009 init_def = build_constructor_from_list (vectype, t);
3018 *adjustment_def = NULL_TREE;
3019 init_def = vect_get_vec_def_for_operand (init_val, stmt, NULL);
3023 init_def = build_vector_from_val (vectype, init_value);
3034 /* Function vect_create_epilog_for_reduction
3036 Create code at the loop-epilog to finalize the result of a reduction
3039 VECT_DEFS is list of vector of partial results, i.e., the lhs's of vector
3040 reduction statements.
3041 STMT is the scalar reduction stmt that is being vectorized.
3042 NCOPIES is > 1 in case the vectorization factor (VF) is bigger than the
3043 number of elements that we can fit in a vectype (nunits). In this case
3044 we have to generate more than one vector stmt - i.e - we need to "unroll"
3045 the vector stmt by a factor VF/nunits. For more details see documentation
3046 in vectorizable_operation.
3047 REDUC_CODE is the tree-code for the epilog reduction.
3048 REDUCTION_PHIS is a list of the phi-nodes that carry the reduction
3050 REDUC_INDEX is the index of the operand in the right hand side of the
3051 statement that is defined by REDUCTION_PHI.
3052 DOUBLE_REDUC is TRUE if double reduction phi nodes should be handled.
3053 SLP_NODE is an SLP node containing a group of reduction statements. The
3054 first one in this group is STMT.
3057 1. Creates the reduction def-use cycles: sets the arguments for
3059 The loop-entry argument is the vectorized initial-value of the reduction.
3060 The loop-latch argument is taken from VECT_DEFS - the vector of partial
3062 2. "Reduces" each vector of partial results VECT_DEFS into a single result,
3063 by applying the operation specified by REDUC_CODE if available, or by
3064 other means (whole-vector shifts or a scalar loop).
3065 The function also creates a new phi node at the loop exit to preserve
3066 loop-closed form, as illustrated below.
3068 The flow at the entry to this function:
3071 vec_def = phi <null, null> # REDUCTION_PHI
3072 VECT_DEF = vector_stmt # vectorized form of STMT
3073 s_loop = scalar_stmt # (scalar) STMT
3075 s_out0 = phi <s_loop> # (scalar) EXIT_PHI
3079 The above is transformed by this function into:
3082 vec_def = phi <vec_init, VECT_DEF> # REDUCTION_PHI
3083 VECT_DEF = vector_stmt # vectorized form of STMT
3084 s_loop = scalar_stmt # (scalar) STMT
3086 s_out0 = phi <s_loop> # (scalar) EXIT_PHI
3087 v_out1 = phi <VECT_DEF> # NEW_EXIT_PHI
3088 v_out2 = reduce <v_out1>
3089 s_out3 = extract_field <v_out2, 0>
3090 s_out4 = adjust_result <s_out3>
3096 vect_create_epilog_for_reduction (VEC (tree, heap) *vect_defs, gimple stmt,
3097 int ncopies, enum tree_code reduc_code,
3098 VEC (gimple, heap) *reduction_phis,
3099 int reduc_index, bool double_reduc,
3102 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
3103 stmt_vec_info prev_phi_info;
3105 enum machine_mode mode;
3106 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
3107 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo), *outer_loop = NULL;
3108 basic_block exit_bb;
3111 gimple new_phi = NULL, phi;
3112 gimple_stmt_iterator exit_gsi;
3114 tree new_temp = NULL_TREE, new_dest, new_name, new_scalar_dest;
3115 gimple epilog_stmt = NULL;
3116 enum tree_code code = gimple_assign_rhs_code (stmt);
3118 tree bitsize, bitpos;
3119 tree adjustment_def = NULL;
3120 tree vec_initial_def = NULL;
3121 tree reduction_op, expr, def;
3122 tree orig_name, scalar_result;
3123 imm_use_iterator imm_iter, phi_imm_iter;
3124 use_operand_p use_p, phi_use_p;
3125 bool extract_scalar_result = false;
3126 gimple use_stmt, orig_stmt, reduction_phi = NULL;
3127 bool nested_in_vect_loop = false;
3128 VEC (gimple, heap) *new_phis = NULL;
3129 enum vect_def_type dt = vect_unknown_def_type;
3131 VEC (tree, heap) *scalar_results = NULL;
3132 unsigned int group_size = 1, k, ratio;
3133 VEC (tree, heap) *vec_initial_defs = NULL;
3134 VEC (gimple, heap) *phis;
3137 group_size = VEC_length (gimple, SLP_TREE_SCALAR_STMTS (slp_node));
3139 if (nested_in_vect_loop_p (loop, stmt))
3143 nested_in_vect_loop = true;
3144 gcc_assert (!slp_node);
3147 switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
3149 case GIMPLE_SINGLE_RHS:
3150 gcc_assert (TREE_OPERAND_LENGTH (gimple_assign_rhs1 (stmt))
3152 reduction_op = TREE_OPERAND (gimple_assign_rhs1 (stmt), reduc_index);
3154 case GIMPLE_UNARY_RHS:
3155 reduction_op = gimple_assign_rhs1 (stmt);
3157 case GIMPLE_BINARY_RHS:
3158 reduction_op = reduc_index ?
3159 gimple_assign_rhs2 (stmt) : gimple_assign_rhs1 (stmt);
3165 vectype = get_vectype_for_scalar_type (TREE_TYPE (reduction_op));
3166 gcc_assert (vectype);
3167 mode = TYPE_MODE (vectype);
3169 /* 1. Create the reduction def-use cycle:
3170 Set the arguments of REDUCTION_PHIS, i.e., transform
3173 vec_def = phi <null, null> # REDUCTION_PHI
3174 VECT_DEF = vector_stmt # vectorized form of STMT
3180 vec_def = phi <vec_init, VECT_DEF> # REDUCTION_PHI
3181 VECT_DEF = vector_stmt # vectorized form of STMT
3184 (in case of SLP, do it for all the phis). */
3186 /* Get the loop-entry arguments. */
3188 vect_get_slp_defs (reduction_op, NULL_TREE, slp_node, &vec_initial_defs,
3192 vec_initial_defs = VEC_alloc (tree, heap, 1);
3193 /* For the case of reduction, vect_get_vec_def_for_operand returns
3194 the scalar def before the loop, that defines the initial value
3195 of the reduction variable. */
3196 vec_initial_def = vect_get_vec_def_for_operand (reduction_op, stmt,
3198 VEC_quick_push (tree, vec_initial_defs, vec_initial_def);
3201 /* Set phi nodes arguments. */
3202 FOR_EACH_VEC_ELT (gimple, reduction_phis, i, phi)
3204 tree vec_init_def = VEC_index (tree, vec_initial_defs, i);
3205 tree def = VEC_index (tree, vect_defs, i);
3206 for (j = 0; j < ncopies; j++)
3208 /* Set the loop-entry arg of the reduction-phi. */
3209 add_phi_arg (phi, vec_init_def, loop_preheader_edge (loop),
3212 /* Set the loop-latch arg for the reduction-phi. */
3214 def = vect_get_vec_def_for_stmt_copy (vect_unknown_def_type, def);
3216 add_phi_arg (phi, def, loop_latch_edge (loop), UNKNOWN_LOCATION);
3218 if (vect_print_dump_info (REPORT_DETAILS))
3220 fprintf (vect_dump, "transform reduction: created def-use"
3222 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
3223 fprintf (vect_dump, "\n");
3224 print_gimple_stmt (vect_dump, SSA_NAME_DEF_STMT (def), 0,
3228 phi = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (phi));
3232 VEC_free (tree, heap, vec_initial_defs);
3234 /* 2. Create epilog code.
3235 The reduction epilog code operates across the elements of the vector
3236 of partial results computed by the vectorized loop.
3237 The reduction epilog code consists of:
3239 step 1: compute the scalar result in a vector (v_out2)
3240 step 2: extract the scalar result (s_out3) from the vector (v_out2)
3241 step 3: adjust the scalar result (s_out3) if needed.
3243 Step 1 can be accomplished using one the following three schemes:
3244 (scheme 1) using reduc_code, if available.
3245 (scheme 2) using whole-vector shifts, if available.
3246 (scheme 3) using a scalar loop. In this case steps 1+2 above are
3249 The overall epilog code looks like this:
3251 s_out0 = phi <s_loop> # original EXIT_PHI
3252 v_out1 = phi <VECT_DEF> # NEW_EXIT_PHI
3253 v_out2 = reduce <v_out1> # step 1
3254 s_out3 = extract_field <v_out2, 0> # step 2
3255 s_out4 = adjust_result <s_out3> # step 3
3257 (step 3 is optional, and steps 1 and 2 may be combined).
3258 Lastly, the uses of s_out0 are replaced by s_out4. */
3261 /* 2.1 Create new loop-exit-phis to preserve loop-closed form:
3262 v_out1 = phi <VECT_DEF>
3263 Store them in NEW_PHIS. */
3265 exit_bb = single_exit (loop)->dest;
3266 prev_phi_info = NULL;
3267 new_phis = VEC_alloc (gimple, heap, VEC_length (tree, vect_defs));
3268 FOR_EACH_VEC_ELT (tree, vect_defs, i, def)
3270 for (j = 0; j < ncopies; j++)
3272 phi = create_phi_node (SSA_NAME_VAR (def), exit_bb);
3273 set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, loop_vinfo, NULL));
3275 VEC_quick_push (gimple, new_phis, phi);
3278 def = vect_get_vec_def_for_stmt_copy (dt, def);
3279 STMT_VINFO_RELATED_STMT (prev_phi_info) = phi;
3282 SET_PHI_ARG_DEF (phi, single_exit (loop)->dest_idx, def);
3283 prev_phi_info = vinfo_for_stmt (phi);
3287 /* The epilogue is created for the outer-loop, i.e., for the loop being
3292 exit_bb = single_exit (loop)->dest;
3295 exit_gsi = gsi_after_labels (exit_bb);
3297 /* 2.2 Get the relevant tree-code to use in the epilog for schemes 2,3
3298 (i.e. when reduc_code is not available) and in the final adjustment
3299 code (if needed). Also get the original scalar reduction variable as
3300 defined in the loop. In case STMT is a "pattern-stmt" (i.e. - it
3301 represents a reduction pattern), the tree-code and scalar-def are
3302 taken from the original stmt that the pattern-stmt (STMT) replaces.
3303 Otherwise (it is a regular reduction) - the tree-code and scalar-def
3304 are taken from STMT. */
3306 orig_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
3309 /* Regular reduction */
3314 /* Reduction pattern */
3315 stmt_vec_info stmt_vinfo = vinfo_for_stmt (orig_stmt);
3316 gcc_assert (STMT_VINFO_IN_PATTERN_P (stmt_vinfo));
3317 gcc_assert (STMT_VINFO_RELATED_STMT (stmt_vinfo) == stmt);
3320 code = gimple_assign_rhs_code (orig_stmt);
3321 /* For MINUS_EXPR the initial vector is [init_val,0,...,0], therefore,
3322 partial results are added and not subtracted. */
3323 if (code == MINUS_EXPR)
3326 scalar_dest = gimple_assign_lhs (orig_stmt);
3327 scalar_type = TREE_TYPE (scalar_dest);
3328 scalar_results = VEC_alloc (tree, heap, group_size);
3329 new_scalar_dest = vect_create_destination_var (scalar_dest, NULL);
3330 bitsize = TYPE_SIZE (scalar_type);
3332 /* In case this is a reduction in an inner-loop while vectorizing an outer
3333 loop - we don't need to extract a single scalar result at the end of the
3334 inner-loop (unless it is double reduction, i.e., the use of reduction is
3335 outside the outer-loop). The final vector of partial results will be used
3336 in the vectorized outer-loop, or reduced to a scalar result at the end of
3338 if (nested_in_vect_loop && !double_reduc)
3339 goto vect_finalize_reduction;
3341 /* 2.3 Create the reduction code, using one of the three schemes described
3342 above. In SLP we simply need to extract all the elements from the
3343 vector (without reducing them), so we use scalar shifts. */
3344 if (reduc_code != ERROR_MARK && !slp_node)
3348 /*** Case 1: Create:
3349 v_out2 = reduc_expr <v_out1> */
3351 if (vect_print_dump_info (REPORT_DETAILS))
3352 fprintf (vect_dump, "Reduce using direct vector reduction.");
3354 vec_dest = vect_create_destination_var (scalar_dest, vectype);
3355 new_phi = VEC_index (gimple, new_phis, 0);
3356 tmp = build1 (reduc_code, vectype, PHI_RESULT (new_phi));
3357 epilog_stmt = gimple_build_assign (vec_dest, tmp);
3358 new_temp = make_ssa_name (vec_dest, epilog_stmt);
3359 gimple_assign_set_lhs (epilog_stmt, new_temp);
3360 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3362 extract_scalar_result = true;
3366 enum tree_code shift_code = ERROR_MARK;
3367 bool have_whole_vector_shift = true;
3369 int element_bitsize = tree_low_cst (bitsize, 1);
3370 int vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1);
3373 if (optab_handler (vec_shr_optab, mode) != CODE_FOR_nothing)
3374 shift_code = VEC_RSHIFT_EXPR;
3376 have_whole_vector_shift = false;
3378 /* Regardless of whether we have a whole vector shift, if we're
3379 emulating the operation via tree-vect-generic, we don't want
3380 to use it. Only the first round of the reduction is likely
3381 to still be profitable via emulation. */
3382 /* ??? It might be better to emit a reduction tree code here, so that
3383 tree-vect-generic can expand the first round via bit tricks. */
3384 if (!VECTOR_MODE_P (mode))
3385 have_whole_vector_shift = false;
3388 optab optab = optab_for_tree_code (code, vectype, optab_default);
3389 if (optab_handler (optab, mode) == CODE_FOR_nothing)
3390 have_whole_vector_shift = false;
3393 if (have_whole_vector_shift && !slp_node)
3395 /*** Case 2: Create:
3396 for (offset = VS/2; offset >= element_size; offset/=2)
3398 Create: va' = vec_shift <va, offset>
3399 Create: va = vop <va, va'>
3402 if (vect_print_dump_info (REPORT_DETAILS))
3403 fprintf (vect_dump, "Reduce using vector shifts");
3405 vec_dest = vect_create_destination_var (scalar_dest, vectype);
3406 new_phi = VEC_index (gimple, new_phis, 0);
3407 new_temp = PHI_RESULT (new_phi);
3408 for (bit_offset = vec_size_in_bits/2;
3409 bit_offset >= element_bitsize;
3412 tree bitpos = size_int (bit_offset);
3414 epilog_stmt = gimple_build_assign_with_ops (shift_code,
3415 vec_dest, new_temp, bitpos);
3416 new_name = make_ssa_name (vec_dest, epilog_stmt);
3417 gimple_assign_set_lhs (epilog_stmt, new_name);
3418 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3420 epilog_stmt = gimple_build_assign_with_ops (code, vec_dest,
3421 new_name, new_temp);
3422 new_temp = make_ssa_name (vec_dest, epilog_stmt);
3423 gimple_assign_set_lhs (epilog_stmt, new_temp);
3424 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3427 extract_scalar_result = true;
3433 /*** Case 3: Create:
3434 s = extract_field <v_out2, 0>
3435 for (offset = element_size;
3436 offset < vector_size;
3437 offset += element_size;)
3439 Create: s' = extract_field <v_out2, offset>
3440 Create: s = op <s, s'> // For non SLP cases
3443 if (vect_print_dump_info (REPORT_DETAILS))
3444 fprintf (vect_dump, "Reduce using scalar code. ");
3446 vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1);
3447 FOR_EACH_VEC_ELT (gimple, new_phis, i, new_phi)
3449 vec_temp = PHI_RESULT (new_phi);
3450 rhs = build3 (BIT_FIELD_REF, scalar_type, vec_temp, bitsize,
3452 epilog_stmt = gimple_build_assign (new_scalar_dest, rhs);
3453 new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
3454 gimple_assign_set_lhs (epilog_stmt, new_temp);
3455 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3457 /* In SLP we don't need to apply reduction operation, so we just
3458 collect s' values in SCALAR_RESULTS. */
3460 VEC_safe_push (tree, heap, scalar_results, new_temp);
3462 for (bit_offset = element_bitsize;
3463 bit_offset < vec_size_in_bits;
3464 bit_offset += element_bitsize)
3466 tree bitpos = bitsize_int (bit_offset);
3467 tree rhs = build3 (BIT_FIELD_REF, scalar_type, vec_temp,
3470 epilog_stmt = gimple_build_assign (new_scalar_dest, rhs);
3471 new_name = make_ssa_name (new_scalar_dest, epilog_stmt);
3472 gimple_assign_set_lhs (epilog_stmt, new_name);
3473 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3477 /* In SLP we don't need to apply reduction operation, so
3478 we just collect s' values in SCALAR_RESULTS. */
3479 new_temp = new_name;
3480 VEC_safe_push (tree, heap, scalar_results, new_name);
3484 epilog_stmt = gimple_build_assign_with_ops (code,
3485 new_scalar_dest, new_name, new_temp);
3486 new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
3487 gimple_assign_set_lhs (epilog_stmt, new_temp);
3488 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3493 /* The only case where we need to reduce scalar results in SLP, is
3494 unrolling. If the size of SCALAR_RESULTS is greater than
3495 GROUP_SIZE, we reduce them combining elements modulo
3499 tree res, first_res, new_res;
3502 /* Reduce multiple scalar results in case of SLP unrolling. */
3503 for (j = group_size; VEC_iterate (tree, scalar_results, j, res);
3506 first_res = VEC_index (tree, scalar_results, j % group_size);
3507 new_stmt = gimple_build_assign_with_ops (code,
3508 new_scalar_dest, first_res, res);
3509 new_res = make_ssa_name (new_scalar_dest, new_stmt);
3510 gimple_assign_set_lhs (new_stmt, new_res);
3511 gsi_insert_before (&exit_gsi, new_stmt, GSI_SAME_STMT);
3512 VEC_replace (tree, scalar_results, j % group_size, new_res);
3516 /* Not SLP - we have one scalar to keep in SCALAR_RESULTS. */
3517 VEC_safe_push (tree, heap, scalar_results, new_temp);
3519 extract_scalar_result = false;
3523 /* 2.4 Extract the final scalar result. Create:
3524 s_out3 = extract_field <v_out2, bitpos> */
3526 if (extract_scalar_result)
3530 if (vect_print_dump_info (REPORT_DETAILS))
3531 fprintf (vect_dump, "extract scalar result");
3533 if (BYTES_BIG_ENDIAN)
3534 bitpos = size_binop (MULT_EXPR,
3535 bitsize_int (TYPE_VECTOR_SUBPARTS (vectype) - 1),
3536 TYPE_SIZE (scalar_type));
3538 bitpos = bitsize_zero_node;
3540 rhs = build3 (BIT_FIELD_REF, scalar_type, new_temp, bitsize, bitpos);
3541 epilog_stmt = gimple_build_assign (new_scalar_dest, rhs);
3542 new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
3543 gimple_assign_set_lhs (epilog_stmt, new_temp);
3544 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3545 VEC_safe_push (tree, heap, scalar_results, new_temp);
3548 vect_finalize_reduction:
3553 /* 2.5 Adjust the final result by the initial value of the reduction
3554 variable. (When such adjustment is not needed, then
3555 'adjustment_def' is zero). For example, if code is PLUS we create:
3556 new_temp = loop_exit_def + adjustment_def */
3560 gcc_assert (!slp_node);
3561 if (nested_in_vect_loop)
3563 new_phi = VEC_index (gimple, new_phis, 0);
3564 gcc_assert (TREE_CODE (TREE_TYPE (adjustment_def)) == VECTOR_TYPE);
3565 expr = build2 (code, vectype, PHI_RESULT (new_phi), adjustment_def);
3566 new_dest = vect_create_destination_var (scalar_dest, vectype);
3570 new_temp = VEC_index (tree, scalar_results, 0);
3571 gcc_assert (TREE_CODE (TREE_TYPE (adjustment_def)) != VECTOR_TYPE);
3572 expr = build2 (code, scalar_type, new_temp, adjustment_def);
3573 new_dest = vect_create_destination_var (scalar_dest, scalar_type);
3576 epilog_stmt = gimple_build_assign (new_dest, expr);
3577 new_temp = make_ssa_name (new_dest, epilog_stmt);
3578 gimple_assign_set_lhs (epilog_stmt, new_temp);
3579 SSA_NAME_DEF_STMT (new_temp) = epilog_stmt;
3580 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3581 if (nested_in_vect_loop)
3583 set_vinfo_for_stmt (epilog_stmt,
3584 new_stmt_vec_info (epilog_stmt, loop_vinfo,
3586 STMT_VINFO_RELATED_STMT (vinfo_for_stmt (epilog_stmt)) =
3587 STMT_VINFO_RELATED_STMT (vinfo_for_stmt (new_phi));
3590 VEC_quick_push (tree, scalar_results, new_temp);
3592 VEC_replace (tree, scalar_results, 0, new_temp);
3595 VEC_replace (tree, scalar_results, 0, new_temp);
3597 VEC_replace (gimple, new_phis, 0, epilog_stmt);
3600 /* 2.6 Handle the loop-exit phis. Replace the uses of scalar loop-exit
3601 phis with new adjusted scalar results, i.e., replace use <s_out0>
3606 s_out0 = phi <s_loop> # (scalar) EXIT_PHI
3607 v_out1 = phi <VECT_DEF> # NEW_EXIT_PHI
3608 v_out2 = reduce <v_out1>
3609 s_out3 = extract_field <v_out2, 0>
3610 s_out4 = adjust_result <s_out3>
3617 s_out0 = phi <s_loop> # (scalar) EXIT_PHI
3618 v_out1 = phi <VECT_DEF> # NEW_EXIT_PHI
3619 v_out2 = reduce <v_out1>
3620 s_out3 = extract_field <v_out2, 0>
3621 s_out4 = adjust_result <s_out3>
3625 /* In SLP we may have several statements in NEW_PHIS and REDUCTION_PHIS (in
3626 case that GROUP_SIZE is greater than vectorization factor). Therefore, we
3627 need to match SCALAR_RESULTS with corresponding statements. The first
3628 (GROUP_SIZE / number of new vector stmts) scalar results correspond to
3629 the first vector stmt, etc.
3630 (RATIO is equal to (GROUP_SIZE / number of new vector stmts)). */
3631 if (group_size > VEC_length (gimple, new_phis))
3633 ratio = group_size / VEC_length (gimple, new_phis);
3634 gcc_assert (!(group_size % VEC_length (gimple, new_phis)));
3639 for (k = 0; k < group_size; k++)
3643 epilog_stmt = VEC_index (gimple, new_phis, k / ratio);
3644 reduction_phi = VEC_index (gimple, reduction_phis, k / ratio);
3649 gimple current_stmt = VEC_index (gimple,
3650 SLP_TREE_SCALAR_STMTS (slp_node), k);
3652 orig_stmt = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (current_stmt));
3653 /* SLP statements can't participate in patterns. */
3654 gcc_assert (!orig_stmt);
3655 scalar_dest = gimple_assign_lhs (current_stmt);
3658 phis = VEC_alloc (gimple, heap, 3);
3659 /* Find the loop-closed-use at the loop exit of the original scalar
3660 result. (The reduction result is expected to have two immediate uses -
3661 one at the latch block, and one at the loop exit). */
3662 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, scalar_dest)
3663 if (!flow_bb_inside_loop_p (loop, gimple_bb (USE_STMT (use_p))))
3664 VEC_safe_push (gimple, heap, phis, USE_STMT (use_p));
3666 /* We expect to have found an exit_phi because of loop-closed-ssa
3668 gcc_assert (!VEC_empty (gimple, phis));
3670 FOR_EACH_VEC_ELT (gimple, phis, i, exit_phi)
3674 stmt_vec_info exit_phi_vinfo = vinfo_for_stmt (exit_phi);
3677 /* FORNOW. Currently not supporting the case that an inner-loop
3678 reduction is not used in the outer-loop (but only outside the
3679 outer-loop), unless it is double reduction. */
3680 gcc_assert ((STMT_VINFO_RELEVANT_P (exit_phi_vinfo)
3681 && !STMT_VINFO_LIVE_P (exit_phi_vinfo))
3684 STMT_VINFO_VEC_STMT (exit_phi_vinfo) = epilog_stmt;
3686 || STMT_VINFO_DEF_TYPE (exit_phi_vinfo)
3687 != vect_double_reduction_def)
3690 /* Handle double reduction:
3692 stmt1: s1 = phi <s0, s2> - double reduction phi (outer loop)
3693 stmt2: s3 = phi <s1, s4> - (regular) reduc phi (inner loop)
3694 stmt3: s4 = use (s3) - (regular) reduc stmt (inner loop)
3695 stmt4: s2 = phi <s4> - double reduction stmt (outer loop)
3697 At that point the regular reduction (stmt2 and stmt3) is
3698 already vectorized, as well as the exit phi node, stmt4.
3699 Here we vectorize the phi node of double reduction, stmt1, and
3700 update all relevant statements. */
3702 /* Go through all the uses of s2 to find double reduction phi
3703 node, i.e., stmt1 above. */
3704 orig_name = PHI_RESULT (exit_phi);
3705 FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, orig_name)
3707 stmt_vec_info use_stmt_vinfo = vinfo_for_stmt (use_stmt);
3708 stmt_vec_info new_phi_vinfo;
3709 tree vect_phi_init, preheader_arg, vect_phi_res, init_def;
3710 basic_block bb = gimple_bb (use_stmt);
3713 /* Check that USE_STMT is really double reduction phi
3715 if (gimple_code (use_stmt) != GIMPLE_PHI
3716 || gimple_phi_num_args (use_stmt) != 2
3718 || STMT_VINFO_DEF_TYPE (use_stmt_vinfo)
3719 != vect_double_reduction_def
3720 || bb->loop_father != outer_loop)
3723 /* Create vector phi node for double reduction:
3724 vs1 = phi <vs0, vs2>
3725 vs1 was created previously in this function by a call to
3726 vect_get_vec_def_for_operand and is stored in
3728 vs2 is defined by EPILOG_STMT, the vectorized EXIT_PHI;
3729 vs0 is created here. */
3731 /* Create vector phi node. */
3732 vect_phi = create_phi_node (vec_initial_def, bb);
3733 new_phi_vinfo = new_stmt_vec_info (vect_phi,
3734 loop_vec_info_for_loop (outer_loop), NULL);
3735 set_vinfo_for_stmt (vect_phi, new_phi_vinfo);
3737 /* Create vs0 - initial def of the double reduction phi. */
3738 preheader_arg = PHI_ARG_DEF_FROM_EDGE (use_stmt,
3739 loop_preheader_edge (outer_loop));
3740 init_def = get_initial_def_for_reduction (stmt,
3741 preheader_arg, NULL);
3742 vect_phi_init = vect_init_vector (use_stmt, init_def,
3745 /* Update phi node arguments with vs0 and vs2. */
3746 add_phi_arg (vect_phi, vect_phi_init,
3747 loop_preheader_edge (outer_loop),
3749 add_phi_arg (vect_phi, PHI_RESULT (epilog_stmt),
3750 loop_latch_edge (outer_loop), UNKNOWN_LOCATION);
3751 if (vect_print_dump_info (REPORT_DETAILS))
3753 fprintf (vect_dump, "created double reduction phi "
3755 print_gimple_stmt (vect_dump, vect_phi, 0, TDF_SLIM);
3758 vect_phi_res = PHI_RESULT (vect_phi);
3760 /* Replace the use, i.e., set the correct vs1 in the regular
3761 reduction phi node. FORNOW, NCOPIES is always 1, so the
3762 loop is redundant. */
3763 use = reduction_phi;
3764 for (j = 0; j < ncopies; j++)
3766 edge pr_edge = loop_preheader_edge (loop);
3767 SET_PHI_ARG_DEF (use, pr_edge->dest_idx, vect_phi_res);
3768 use = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (use));
3774 VEC_free (gimple, heap, phis);
3775 if (nested_in_vect_loop)
3783 phis = VEC_alloc (gimple, heap, 3);
3784 /* Find the loop-closed-use at the loop exit of the original scalar
3785 result. (The reduction result is expected to have two immediate uses,
3786 one at the latch block, and one at the loop exit). For double
3787 reductions we are looking for exit phis of the outer loop. */
3788 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, scalar_dest)
3790 if (!flow_bb_inside_loop_p (loop, gimple_bb (USE_STMT (use_p))))
3791 VEC_safe_push (gimple, heap, phis, USE_STMT (use_p));
3794 if (double_reduc && gimple_code (USE_STMT (use_p)) == GIMPLE_PHI)
3796 tree phi_res = PHI_RESULT (USE_STMT (use_p));
3798 FOR_EACH_IMM_USE_FAST (phi_use_p, phi_imm_iter, phi_res)
3800 if (!flow_bb_inside_loop_p (loop,
3801 gimple_bb (USE_STMT (phi_use_p))))
3802 VEC_safe_push (gimple, heap, phis,
3803 USE_STMT (phi_use_p));
3809 FOR_EACH_VEC_ELT (gimple, phis, i, exit_phi)
3811 /* Replace the uses: */
3812 orig_name = PHI_RESULT (exit_phi);
3813 scalar_result = VEC_index (tree, scalar_results, k);
3814 FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, orig_name)
3815 FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
3816 SET_USE (use_p, scalar_result);
3819 VEC_free (gimple, heap, phis);
3822 VEC_free (tree, heap, scalar_results);
3823 VEC_free (gimple, heap, new_phis);
3827 /* Function vectorizable_reduction.
3829 Check if STMT performs a reduction operation that can be vectorized.
3830 If VEC_STMT is also passed, vectorize the STMT: create a vectorized
3831 stmt to replace it, put it in VEC_STMT, and insert it at GSI.
3832 Return FALSE if not a vectorizable STMT, TRUE otherwise.
3834 This function also handles reduction idioms (patterns) that have been
3835 recognized in advance during vect_pattern_recog. In this case, STMT may be
3837 X = pattern_expr (arg0, arg1, ..., X)
3838 and it's STMT_VINFO_RELATED_STMT points to the last stmt in the original
3839 sequence that had been detected and replaced by the pattern-stmt (STMT).
3841 In some cases of reduction patterns, the type of the reduction variable X is
3842 different than the type of the other arguments of STMT.
3843 In such cases, the vectype that is used when transforming STMT into a vector
3844 stmt is different than the vectype that is used to determine the
3845 vectorization factor, because it consists of a different number of elements
3846 than the actual number of elements that are being operated upon in parallel.
3848 For example, consider an accumulation of shorts into an int accumulator.
3849 On some targets it's possible to vectorize this pattern operating on 8
3850 shorts at a time (hence, the vectype for purposes of determining the
3851 vectorization factor should be V8HI); on the other hand, the vectype that
3852 is used to create the vector form is actually V4SI (the type of the result).
3854 Upon entry to this function, STMT_VINFO_VECTYPE records the vectype that
3855 indicates what is the actual level of parallelism (V8HI in the example), so
3856 that the right vectorization factor would be derived. This vectype
3857 corresponds to the type of arguments to the reduction stmt, and should *NOT*
3858 be used to create the vectorized stmt. The right vectype for the vectorized
3859 stmt is obtained from the type of the result X:
3860 get_vectype_for_scalar_type (TREE_TYPE (X))
3862 This means that, contrary to "regular" reductions (or "regular" stmts in
3863 general), the following equation:
3864 STMT_VINFO_VECTYPE == get_vectype_for_scalar_type (TREE_TYPE (X))
3865 does *NOT* necessarily hold for reduction patterns. */
3868 vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
3869 gimple *vec_stmt, slp_tree slp_node)
3873 tree loop_vec_def0 = NULL_TREE, loop_vec_def1 = NULL_TREE;
3874 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
3875 tree vectype_out = STMT_VINFO_VECTYPE (stmt_info);
3876 tree vectype_in = NULL_TREE;
3877 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
3878 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
3879 enum tree_code code, orig_code, epilog_reduc_code;
3880 enum machine_mode vec_mode;
3882 optab optab, reduc_optab;
3883 tree new_temp = NULL_TREE;
3886 enum vect_def_type dt;
3887 gimple new_phi = NULL;
3891 stmt_vec_info orig_stmt_info;
3892 tree expr = NULL_TREE;
3896 stmt_vec_info prev_stmt_info, prev_phi_info;
3897 bool single_defuse_cycle = false;
3898 tree reduc_def = NULL_TREE;
3899 gimple new_stmt = NULL;
3902 bool nested_cycle = false, found_nested_cycle_def = false;
3903 gimple reduc_def_stmt = NULL;
3904 /* The default is that the reduction variable is the last in statement. */
3905 int reduc_index = 2;
3906 bool double_reduc = false, dummy;
3908 struct loop * def_stmt_loop, *outer_loop = NULL;
3910 gimple def_arg_stmt;
3911 VEC (tree, heap) *vec_oprnds0 = NULL, *vec_oprnds1 = NULL, *vect_defs = NULL;
3912 VEC (gimple, heap) *phis = NULL;
3914 tree def0, def1, tem;
3916 if (nested_in_vect_loop_p (loop, stmt))
3920 nested_cycle = true;
3923 /* 1. Is vectorizable reduction? */
3924 /* Not supportable if the reduction variable is used in the loop. */
3925 if (STMT_VINFO_RELEVANT (stmt_info) > vect_used_in_outer)
3928 /* Reductions that are not used even in an enclosing outer-loop,
3929 are expected to be "live" (used out of the loop). */
3930 if (STMT_VINFO_RELEVANT (stmt_info) == vect_unused_in_scope
3931 && !STMT_VINFO_LIVE_P (stmt_info))
3934 /* Make sure it was already recognized as a reduction computation. */
3935 if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_reduction_def
3936 && STMT_VINFO_DEF_TYPE (stmt_info) != vect_nested_cycle)
3939 /* 2. Has this been recognized as a reduction pattern?
3941 Check if STMT represents a pattern that has been recognized
3942 in earlier analysis stages. For stmts that represent a pattern,
3943 the STMT_VINFO_RELATED_STMT field records the last stmt in
3944 the original sequence that constitutes the pattern. */
3946 orig_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
3949 orig_stmt_info = vinfo_for_stmt (orig_stmt);
3950 gcc_assert (STMT_VINFO_RELATED_STMT (orig_stmt_info) == stmt);
3951 gcc_assert (STMT_VINFO_IN_PATTERN_P (orig_stmt_info));
3952 gcc_assert (!STMT_VINFO_IN_PATTERN_P (stmt_info));
3955 /* 3. Check the operands of the operation. The first operands are defined
3956 inside the loop body. The last operand is the reduction variable,
3957 which is defined by the loop-header-phi. */
3959 gcc_assert (is_gimple_assign (stmt));
3962 switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
3964 case GIMPLE_SINGLE_RHS:
3965 op_type = TREE_OPERAND_LENGTH (gimple_assign_rhs1 (stmt));
3966 if (op_type == ternary_op)
3968 tree rhs = gimple_assign_rhs1 (stmt);
3969 ops[0] = TREE_OPERAND (rhs, 0);
3970 ops[1] = TREE_OPERAND (rhs, 1);
3971 ops[2] = TREE_OPERAND (rhs, 2);
3972 code = TREE_CODE (rhs);
3978 case GIMPLE_BINARY_RHS:
3979 code = gimple_assign_rhs_code (stmt);
3980 op_type = TREE_CODE_LENGTH (code);
3981 gcc_assert (op_type == binary_op);
3982 ops[0] = gimple_assign_rhs1 (stmt);
3983 ops[1] = gimple_assign_rhs2 (stmt);
3986 case GIMPLE_UNARY_RHS:
3993 scalar_dest = gimple_assign_lhs (stmt);
3994 scalar_type = TREE_TYPE (scalar_dest);
3995 if (!POINTER_TYPE_P (scalar_type) && !INTEGRAL_TYPE_P (scalar_type)
3996 && !SCALAR_FLOAT_TYPE_P (scalar_type))
3999 /* All uses but the last are expected to be defined in the loop.
4000 The last use is the reduction variable. In case of nested cycle this
4001 assumption is not true: we use reduc_index to record the index of the
4002 reduction variable. */
4003 for (i = 0; i < op_type-1; i++)
4005 /* The condition of COND_EXPR is checked in vectorizable_condition(). */
4006 if (i == 0 && code == COND_EXPR)
4009 is_simple_use = vect_is_simple_use_1 (ops[i], loop_vinfo, NULL,
4010 &def_stmt, &def, &dt, &tem);
4013 gcc_assert (is_simple_use);
4014 if (dt != vect_internal_def
4015 && dt != vect_external_def
4016 && dt != vect_constant_def
4017 && dt != vect_induction_def
4018 && !(dt == vect_nested_cycle && nested_cycle))
4021 if (dt == vect_nested_cycle)
4023 found_nested_cycle_def = true;
4024 reduc_def_stmt = def_stmt;
4029 is_simple_use = vect_is_simple_use_1 (ops[i], loop_vinfo, NULL, &def_stmt,
4033 gcc_assert (is_simple_use);
4034 gcc_assert (dt == vect_reduction_def
4035 || dt == vect_nested_cycle
4036 || ((dt == vect_internal_def || dt == vect_external_def
4037 || dt == vect_constant_def || dt == vect_induction_def)
4038 && nested_cycle && found_nested_cycle_def));
4039 if (!found_nested_cycle_def)
4040 reduc_def_stmt = def_stmt;
4042 gcc_assert (gimple_code (reduc_def_stmt) == GIMPLE_PHI);
4044 gcc_assert (orig_stmt == vect_is_simple_reduction (loop_vinfo,
4049 gcc_assert (stmt == vect_is_simple_reduction (loop_vinfo, reduc_def_stmt,
4050 !nested_cycle, &dummy));
4052 if (STMT_VINFO_LIVE_P (vinfo_for_stmt (reduc_def_stmt)))
4058 ncopies = (LOOP_VINFO_VECT_FACTOR (loop_vinfo)
4059 / TYPE_VECTOR_SUBPARTS (vectype_in));
4061 gcc_assert (ncopies >= 1);
4063 vec_mode = TYPE_MODE (vectype_in);
4065 if (code == COND_EXPR)
4067 if (!vectorizable_condition (stmt, gsi, NULL, ops[reduc_index], 0))
4069 if (vect_print_dump_info (REPORT_DETAILS))
4070 fprintf (vect_dump, "unsupported condition in reduction");
4077 /* 4. Supportable by target? */
4079 /* 4.1. check support for the operation in the loop */
4080 optab = optab_for_tree_code (code, vectype_in, optab_default);
4083 if (vect_print_dump_info (REPORT_DETAILS))
4084 fprintf (vect_dump, "no optab.");
4089 if (optab_handler (optab, vec_mode) == CODE_FOR_nothing)
4091 if (vect_print_dump_info (REPORT_DETAILS))
4092 fprintf (vect_dump, "op not supported by target.");
4094 if (GET_MODE_SIZE (vec_mode) != UNITS_PER_WORD
4095 || LOOP_VINFO_VECT_FACTOR (loop_vinfo)
4096 < vect_min_worthwhile_factor (code))
4099 if (vect_print_dump_info (REPORT_DETAILS))
4100 fprintf (vect_dump, "proceeding using word mode.");
4103 /* Worthwhile without SIMD support? */
4104 if (!VECTOR_MODE_P (TYPE_MODE (vectype_in))
4105 && LOOP_VINFO_VECT_FACTOR (loop_vinfo)
4106 < vect_min_worthwhile_factor (code))
4108 if (vect_print_dump_info (REPORT_DETAILS))
4109 fprintf (vect_dump, "not worthwhile without SIMD support.");
4115 /* 4.2. Check support for the epilog operation.
4117 If STMT represents a reduction pattern, then the type of the
4118 reduction variable may be different than the type of the rest
4119 of the arguments. For example, consider the case of accumulation
4120 of shorts into an int accumulator; The original code:
4121 S1: int_a = (int) short_a;
4122 orig_stmt-> S2: int_acc = plus <int_a ,int_acc>;
4125 STMT: int_acc = widen_sum <short_a, int_acc>
4128 1. The tree-code that is used to create the vector operation in the
4129 epilog code (that reduces the partial results) is not the
4130 tree-code of STMT, but is rather the tree-code of the original
4131 stmt from the pattern that STMT is replacing. I.e, in the example
4132 above we want to use 'widen_sum' in the loop, but 'plus' in the
4134 2. The type (mode) we use to check available target support
4135 for the vector operation to be created in the *epilog*, is
4136 determined by the type of the reduction variable (in the example
4137 above we'd check this: optab_handler (plus_optab, vect_int_mode])).
4138 However the type (mode) we use to check available target support
4139 for the vector operation to be created *inside the loop*, is
4140 determined by the type of the other arguments to STMT (in the
4141 example we'd check this: optab_handler (widen_sum_optab,
4144 This is contrary to "regular" reductions, in which the types of all
4145 the arguments are the same as the type of the reduction variable.
4146 For "regular" reductions we can therefore use the same vector type
4147 (and also the same tree-code) when generating the epilog code and
4148 when generating the code inside the loop. */
4152 /* This is a reduction pattern: get the vectype from the type of the
4153 reduction variable, and get the tree-code from orig_stmt. */
4154 orig_code = gimple_assign_rhs_code (orig_stmt);
4155 gcc_assert (vectype_out);
4156 vec_mode = TYPE_MODE (vectype_out);
4160 /* Regular reduction: use the same vectype and tree-code as used for
4161 the vector code inside the loop can be used for the epilog code. */
4167 def_bb = gimple_bb (reduc_def_stmt);
4168 def_stmt_loop = def_bb->loop_father;
4169 def_arg = PHI_ARG_DEF_FROM_EDGE (reduc_def_stmt,
4170 loop_preheader_edge (def_stmt_loop));
4171 if (TREE_CODE (def_arg) == SSA_NAME
4172 && (def_arg_stmt = SSA_NAME_DEF_STMT (def_arg))
4173 && gimple_code (def_arg_stmt) == GIMPLE_PHI
4174 && flow_bb_inside_loop_p (outer_loop, gimple_bb (def_arg_stmt))
4175 && vinfo_for_stmt (def_arg_stmt)
4176 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def_arg_stmt))
4177 == vect_double_reduction_def)
4178 double_reduc = true;
4181 epilog_reduc_code = ERROR_MARK;
4182 if (reduction_code_for_scalar_code (orig_code, &epilog_reduc_code))
4184 reduc_optab = optab_for_tree_code (epilog_reduc_code, vectype_out,
4188 if (vect_print_dump_info (REPORT_DETAILS))
4189 fprintf (vect_dump, "no optab for reduction.");
4191 epilog_reduc_code = ERROR_MARK;
4195 && optab_handler (reduc_optab, vec_mode) == CODE_FOR_nothing)
4197 if (vect_print_dump_info (REPORT_DETAILS))
4198 fprintf (vect_dump, "reduc op not supported by target.");
4200 epilog_reduc_code = ERROR_MARK;
4205 if (!nested_cycle || double_reduc)
4207 if (vect_print_dump_info (REPORT_DETAILS))
4208 fprintf (vect_dump, "no reduc code for scalar code.");
4214 if (double_reduc && ncopies > 1)
4216 if (vect_print_dump_info (REPORT_DETAILS))
4217 fprintf (vect_dump, "multiple types in double reduction");
4222 if (!vec_stmt) /* transformation not required. */
4224 STMT_VINFO_TYPE (stmt_info) = reduc_vec_info_type;
4225 if (!vect_model_reduction_cost (stmt_info, epilog_reduc_code, ncopies))
4232 if (vect_print_dump_info (REPORT_DETAILS))
4233 fprintf (vect_dump, "transform reduction.");
4235 /* FORNOW: Multiple types are not supported for condition. */
4236 if (code == COND_EXPR)
4237 gcc_assert (ncopies == 1);
4239 /* Create the destination vector */
4240 vec_dest = vect_create_destination_var (scalar_dest, vectype_out);
4242 /* In case the vectorization factor (VF) is bigger than the number
4243 of elements that we can fit in a vectype (nunits), we have to generate
4244 more than one vector stmt - i.e - we need to "unroll" the
4245 vector stmt by a factor VF/nunits. For more details see documentation
4246 in vectorizable_operation. */
4248 /* If the reduction is used in an outer loop we need to generate
4249 VF intermediate results, like so (e.g. for ncopies=2):
4254 (i.e. we generate VF results in 2 registers).
4255 In this case we have a separate def-use cycle for each copy, and therefore
4256 for each copy we get the vector def for the reduction variable from the
4257 respective phi node created for this copy.
4259 Otherwise (the reduction is unused in the loop nest), we can combine
4260 together intermediate results, like so (e.g. for ncopies=2):
4264 (i.e. we generate VF/2 results in a single register).
4265 In this case for each copy we get the vector def for the reduction variable
4266 from the vectorized reduction operation generated in the previous iteration.
4269 if (STMT_VINFO_RELEVANT (stmt_info) == vect_unused_in_scope)
4271 single_defuse_cycle = true;
4275 epilog_copies = ncopies;
4277 prev_stmt_info = NULL;
4278 prev_phi_info = NULL;
4281 vec_num = SLP_TREE_NUMBER_OF_VEC_STMTS (slp_node);
4282 gcc_assert (TYPE_VECTOR_SUBPARTS (vectype_out)
4283 == TYPE_VECTOR_SUBPARTS (vectype_in));
4288 vec_oprnds0 = VEC_alloc (tree, heap, 1);
4289 if (op_type == ternary_op)
4290 vec_oprnds1 = VEC_alloc (tree, heap, 1);
4293 phis = VEC_alloc (gimple, heap, vec_num);
4294 vect_defs = VEC_alloc (tree, heap, vec_num);
4296 VEC_quick_push (tree, vect_defs, NULL_TREE);
4298 for (j = 0; j < ncopies; j++)
4300 if (j == 0 || !single_defuse_cycle)
4302 for (i = 0; i < vec_num; i++)
4304 /* Create the reduction-phi that defines the reduction
4306 new_phi = create_phi_node (vec_dest, loop->header);
4307 set_vinfo_for_stmt (new_phi,
4308 new_stmt_vec_info (new_phi, loop_vinfo,
4310 if (j == 0 || slp_node)
4311 VEC_quick_push (gimple, phis, new_phi);
4315 if (code == COND_EXPR)
4317 gcc_assert (!slp_node);
4318 vectorizable_condition (stmt, gsi, vec_stmt,
4319 PHI_RESULT (VEC_index (gimple, phis, 0)),
4321 /* Multiple types are not supported for condition. */
4328 tree op0, op1 = NULL_TREE;
4330 op0 = ops[!reduc_index];
4331 if (op_type == ternary_op)
4333 if (reduc_index == 0)
4340 vect_get_slp_defs (op0, op1, slp_node, &vec_oprnds0, &vec_oprnds1,
4344 loop_vec_def0 = vect_get_vec_def_for_operand (ops[!reduc_index],
4346 VEC_quick_push (tree, vec_oprnds0, loop_vec_def0);
4347 if (op_type == ternary_op)
4349 loop_vec_def1 = vect_get_vec_def_for_operand (op1, stmt,
4351 VEC_quick_push (tree, vec_oprnds1, loop_vec_def1);
4359 enum vect_def_type dt = vect_unknown_def_type; /* Dummy */
4360 loop_vec_def0 = vect_get_vec_def_for_stmt_copy (dt, loop_vec_def0);
4361 VEC_replace (tree, vec_oprnds0, 0, loop_vec_def0);
4362 if (op_type == ternary_op)
4364 loop_vec_def1 = vect_get_vec_def_for_stmt_copy (dt,
4366 VEC_replace (tree, vec_oprnds1, 0, loop_vec_def1);
4370 if (single_defuse_cycle)
4371 reduc_def = gimple_assign_lhs (new_stmt);
4373 STMT_VINFO_RELATED_STMT (prev_phi_info) = new_phi;
4376 FOR_EACH_VEC_ELT (tree, vec_oprnds0, i, def0)
4379 reduc_def = PHI_RESULT (VEC_index (gimple, phis, i));
4382 if (!single_defuse_cycle || j == 0)
4383 reduc_def = PHI_RESULT (new_phi);
4386 def1 = ((op_type == ternary_op)
4387 ? VEC_index (tree, vec_oprnds1, i) : NULL);
4388 if (op_type == binary_op)
4390 if (reduc_index == 0)
4391 expr = build2 (code, vectype_out, reduc_def, def0);
4393 expr = build2 (code, vectype_out, def0, reduc_def);
4397 if (reduc_index == 0)
4398 expr = build3 (code, vectype_out, reduc_def, def0, def1);
4401 if (reduc_index == 1)
4402 expr = build3 (code, vectype_out, def0, reduc_def, def1);
4404 expr = build3 (code, vectype_out, def0, def1, reduc_def);
4408 new_stmt = gimple_build_assign (vec_dest, expr);
4409 new_temp = make_ssa_name (vec_dest, new_stmt);
4410 gimple_assign_set_lhs (new_stmt, new_temp);
4411 vect_finish_stmt_generation (stmt, new_stmt, gsi);
4414 VEC_quick_push (gimple, SLP_TREE_VEC_STMTS (slp_node), new_stmt);
4415 VEC_quick_push (tree, vect_defs, new_temp);
4418 VEC_replace (tree, vect_defs, 0, new_temp);
4425 STMT_VINFO_VEC_STMT (stmt_info) = *vec_stmt = new_stmt;
4427 STMT_VINFO_RELATED_STMT (prev_stmt_info) = new_stmt;
4429 prev_stmt_info = vinfo_for_stmt (new_stmt);
4430 prev_phi_info = vinfo_for_stmt (new_phi);
4433 /* Finalize the reduction-phi (set its arguments) and create the
4434 epilog reduction code. */
4435 if ((!single_defuse_cycle || code == COND_EXPR) && !slp_node)
4437 new_temp = gimple_assign_lhs (*vec_stmt);
4438 VEC_replace (tree, vect_defs, 0, new_temp);
4441 vect_create_epilog_for_reduction (vect_defs, stmt, epilog_copies,
4442 epilog_reduc_code, phis, reduc_index,
4443 double_reduc, slp_node);
4445 VEC_free (gimple, heap, phis);
4446 VEC_free (tree, heap, vec_oprnds0);
4448 VEC_free (tree, heap, vec_oprnds1);
4453 /* Function vect_min_worthwhile_factor.
4455 For a loop where we could vectorize the operation indicated by CODE,
4456 return the minimum vectorization factor that makes it worthwhile
4457 to use generic vectors. */
4459 vect_min_worthwhile_factor (enum tree_code code)
4480 /* Function vectorizable_induction
4482 Check if PHI performs an induction computation that can be vectorized.
4483 If VEC_STMT is also passed, vectorize the induction PHI: create a vectorized
4484 phi to replace it, put it in VEC_STMT, and add it to the same basic block.
4485 Return FALSE if not a vectorizable STMT, TRUE otherwise. */
4488 vectorizable_induction (gimple phi, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
4491 stmt_vec_info stmt_info = vinfo_for_stmt (phi);
4492 tree vectype = STMT_VINFO_VECTYPE (stmt_info);
4493 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
4494 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
4495 int nunits = TYPE_VECTOR_SUBPARTS (vectype);
4496 int ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits;
4499 gcc_assert (ncopies >= 1);
4500 /* FORNOW. This restriction should be relaxed. */
4501 if (nested_in_vect_loop_p (loop, phi) && ncopies > 1)
4503 if (vect_print_dump_info (REPORT_DETAILS))
4504 fprintf (vect_dump, "multiple types in nested loop.");
4508 if (!STMT_VINFO_RELEVANT_P (stmt_info))
4511 /* FORNOW: SLP not supported. */
4512 if (STMT_SLP_TYPE (stmt_info))
4515 gcc_assert (STMT_VINFO_DEF_TYPE (stmt_info) == vect_induction_def);
4517 if (gimple_code (phi) != GIMPLE_PHI)
4520 if (!vec_stmt) /* transformation not required. */
4522 STMT_VINFO_TYPE (stmt_info) = induc_vec_info_type;
4523 if (vect_print_dump_info (REPORT_DETAILS))
4524 fprintf (vect_dump, "=== vectorizable_induction ===");
4525 vect_model_induction_cost (stmt_info, ncopies);
4531 if (vect_print_dump_info (REPORT_DETAILS))
4532 fprintf (vect_dump, "transform induction phi.");
4534 vec_def = get_initial_def_for_induction (phi);
4535 *vec_stmt = SSA_NAME_DEF_STMT (vec_def);
4539 /* Function vectorizable_live_operation.
4541 STMT computes a value that is used outside the loop. Check if
4542 it can be supported. */
4545 vectorizable_live_operation (gimple stmt,
4546 gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
4547 gimple *vec_stmt ATTRIBUTE_UNUSED)
4549 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
4550 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
4551 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
4557 enum vect_def_type dt;
4558 enum tree_code code;
4559 enum gimple_rhs_class rhs_class;
4561 gcc_assert (STMT_VINFO_LIVE_P (stmt_info));
4563 if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_reduction_def)
4566 if (!is_gimple_assign (stmt))
4569 if (TREE_CODE (gimple_assign_lhs (stmt)) != SSA_NAME)
4572 /* FORNOW. CHECKME. */
4573 if (nested_in_vect_loop_p (loop, stmt))
4576 code = gimple_assign_rhs_code (stmt);
4577 op_type = TREE_CODE_LENGTH (code);
4578 rhs_class = get_gimple_rhs_class (code);
4579 gcc_assert (rhs_class != GIMPLE_UNARY_RHS || op_type == unary_op);
4580 gcc_assert (rhs_class != GIMPLE_BINARY_RHS || op_type == binary_op);
4582 /* FORNOW: support only if all uses are invariant. This means
4583 that the scalar operations can remain in place, unvectorized.
4584 The original last scalar value that they compute will be used. */
4586 for (i = 0; i < op_type; i++)
4588 if (rhs_class == GIMPLE_SINGLE_RHS)
4589 op = TREE_OPERAND (gimple_op (stmt, 1), i);
4591 op = gimple_op (stmt, i + 1);
4593 && !vect_is_simple_use (op, loop_vinfo, NULL, &def_stmt, &def, &dt))
4595 if (vect_print_dump_info (REPORT_DETAILS))
4596 fprintf (vect_dump, "use not simple.");
4600 if (dt != vect_external_def && dt != vect_constant_def)
4604 /* No transformation is required for the cases we currently support. */
4608 /* Kill any debug uses outside LOOP of SSA names defined in STMT. */
4611 vect_loop_kill_debug_uses (struct loop *loop, gimple stmt)
4613 ssa_op_iter op_iter;
4614 imm_use_iterator imm_iter;
4615 def_operand_p def_p;
4618 FOR_EACH_PHI_OR_STMT_DEF (def_p, stmt, op_iter, SSA_OP_DEF)
4620 FOR_EACH_IMM_USE_STMT (ustmt, imm_iter, DEF_FROM_PTR (def_p))
4624 if (!is_gimple_debug (ustmt))
4627 bb = gimple_bb (ustmt);
4629 if (!flow_bb_inside_loop_p (loop, bb))
4631 if (gimple_debug_bind_p (ustmt))
4633 if (vect_print_dump_info (REPORT_DETAILS))
4634 fprintf (vect_dump, "killing debug use");
4636 gimple_debug_bind_reset_value (ustmt);
4637 update_stmt (ustmt);
4646 /* Function vect_transform_loop.
4648 The analysis phase has determined that the loop is vectorizable.
4649 Vectorize the loop - created vectorized stmts to replace the scalar
4650 stmts in the loop, and update the loop exit condition. */
4653 vect_transform_loop (loop_vec_info loop_vinfo)
4655 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
4656 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
4657 int nbbs = loop->num_nodes;
4658 gimple_stmt_iterator si;
4661 int vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
4663 bool slp_scheduled = false;
4664 unsigned int nunits;
4665 tree cond_expr = NULL_TREE;
4666 gimple_seq cond_expr_stmt_list = NULL;
4667 bool do_peeling_for_loop_bound;
4669 if (vect_print_dump_info (REPORT_DETAILS))
4670 fprintf (vect_dump, "=== vec_transform_loop ===");
4672 /* Peel the loop if there are data refs with unknown alignment.
4673 Only one data ref with unknown store is allowed. */
4675 if (LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo))
4676 vect_do_peeling_for_alignment (loop_vinfo);
4678 do_peeling_for_loop_bound
4679 = (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
4680 || (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
4681 && LOOP_VINFO_INT_NITERS (loop_vinfo) % vectorization_factor != 0));
4683 if (LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)
4684 || LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
4685 vect_loop_versioning (loop_vinfo,
4686 !do_peeling_for_loop_bound,
4687 &cond_expr, &cond_expr_stmt_list);
4689 /* If the loop has a symbolic number of iterations 'n' (i.e. it's not a
4690 compile time constant), or it is a constant that doesn't divide by the
4691 vectorization factor, then an epilog loop needs to be created.
4692 We therefore duplicate the loop: the original loop will be vectorized,
4693 and will compute the first (n/VF) iterations. The second copy of the loop
4694 will remain scalar and will compute the remaining (n%VF) iterations.
4695 (VF is the vectorization factor). */
4697 if (do_peeling_for_loop_bound)
4698 vect_do_peeling_for_loop_bound (loop_vinfo, &ratio,
4699 cond_expr, cond_expr_stmt_list);
4701 ratio = build_int_cst (TREE_TYPE (LOOP_VINFO_NITERS (loop_vinfo)),
4702 LOOP_VINFO_INT_NITERS (loop_vinfo) / vectorization_factor);
4704 /* 1) Make sure the loop header has exactly two entries
4705 2) Make sure we have a preheader basic block. */
4707 gcc_assert (EDGE_COUNT (loop->header->preds) == 2);
4709 split_edge (loop_preheader_edge (loop));
4711 /* FORNOW: the vectorizer supports only loops which body consist
4712 of one basic block (header + empty latch). When the vectorizer will
4713 support more involved loop forms, the order by which the BBs are
4714 traversed need to be reconsidered. */
4716 for (i = 0; i < nbbs; i++)
4718 basic_block bb = bbs[i];
4719 stmt_vec_info stmt_info;
4722 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
4724 phi = gsi_stmt (si);
4725 if (vect_print_dump_info (REPORT_DETAILS))
4727 fprintf (vect_dump, "------>vectorizing phi: ");
4728 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
4730 stmt_info = vinfo_for_stmt (phi);
4734 if (MAY_HAVE_DEBUG_STMTS && !STMT_VINFO_LIVE_P (stmt_info))
4735 vect_loop_kill_debug_uses (loop, phi);
4737 if (!STMT_VINFO_RELEVANT_P (stmt_info)
4738 && !STMT_VINFO_LIVE_P (stmt_info))
4741 if ((TYPE_VECTOR_SUBPARTS (STMT_VINFO_VECTYPE (stmt_info))
4742 != (unsigned HOST_WIDE_INT) vectorization_factor)
4743 && vect_print_dump_info (REPORT_DETAILS))
4744 fprintf (vect_dump, "multiple-types.");
4746 if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_induction_def)
4748 if (vect_print_dump_info (REPORT_DETAILS))
4749 fprintf (vect_dump, "transform phi.");
4750 vect_transform_stmt (phi, NULL, NULL, NULL, NULL);
4754 for (si = gsi_start_bb (bb); !gsi_end_p (si);)
4756 gimple stmt = gsi_stmt (si);
4759 if (vect_print_dump_info (REPORT_DETAILS))
4761 fprintf (vect_dump, "------>vectorizing statement: ");
4762 print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
4765 stmt_info = vinfo_for_stmt (stmt);
4767 /* vector stmts created in the outer-loop during vectorization of
4768 stmts in an inner-loop may not have a stmt_info, and do not
4769 need to be vectorized. */
4776 if (MAY_HAVE_DEBUG_STMTS && !STMT_VINFO_LIVE_P (stmt_info))
4777 vect_loop_kill_debug_uses (loop, stmt);
4779 if (!STMT_VINFO_RELEVANT_P (stmt_info)
4780 && !STMT_VINFO_LIVE_P (stmt_info))
4786 gcc_assert (STMT_VINFO_VECTYPE (stmt_info));
4788 (unsigned int) TYPE_VECTOR_SUBPARTS (STMT_VINFO_VECTYPE (stmt_info));
4789 if (!STMT_SLP_TYPE (stmt_info)
4790 && nunits != (unsigned int) vectorization_factor
4791 && vect_print_dump_info (REPORT_DETAILS))
4792 /* For SLP VF is set according to unrolling factor, and not to
4793 vector size, hence for SLP this print is not valid. */
4794 fprintf (vect_dump, "multiple-types.");
4796 /* SLP. Schedule all the SLP instances when the first SLP stmt is
4798 if (STMT_SLP_TYPE (stmt_info))
4802 slp_scheduled = true;
4804 if (vect_print_dump_info (REPORT_DETAILS))
4805 fprintf (vect_dump, "=== scheduling SLP instances ===");
4807 vect_schedule_slp (loop_vinfo, NULL);
4810 /* Hybrid SLP stmts must be vectorized in addition to SLP. */
4811 if (!vinfo_for_stmt (stmt) || PURE_SLP_STMT (stmt_info))
4818 /* -------- vectorize statement ------------ */
4819 if (vect_print_dump_info (REPORT_DETAILS))
4820 fprintf (vect_dump, "transform statement.");
4822 strided_store = false;
4823 is_store = vect_transform_stmt (stmt, &si, &strided_store, NULL, NULL);
4826 if (STMT_VINFO_STRIDED_ACCESS (stmt_info))
4828 /* Interleaving. If IS_STORE is TRUE, the vectorization of the
4829 interleaving chain was completed - free all the stores in
4831 vect_remove_stores (DR_GROUP_FIRST_DR (stmt_info));
4832 gsi_remove (&si, true);
4837 /* Free the attached stmt_vec_info and remove the stmt. */
4838 free_stmt_vec_info (stmt);
4839 gsi_remove (&si, true);
4847 slpeel_make_loop_iterate_ntimes (loop, ratio);
4849 /* The memory tags and pointers in vectorized statements need to
4850 have their SSA forms updated. FIXME, why can't this be delayed
4851 until all the loops have been transformed? */
4852 update_ssa (TODO_update_ssa);
4854 if (vect_print_dump_info (REPORT_VECTORIZED_LOCATIONS))
4855 fprintf (vect_dump, "LOOP VECTORIZED.");
4856 if (loop->inner && vect_print_dump_info (REPORT_VECTORIZED_LOCATIONS))
4857 fprintf (vect_dump, "OUTER LOOP VECTORIZED.");