2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
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;
184 gimple stmt, pattern_stmt = NULL;
185 gimple_seq pattern_def_seq = NULL;
186 gimple_stmt_iterator pattern_def_si = gsi_start (NULL);
187 bool analyze_pattern_stmt = false;
189 if (vect_print_dump_info (REPORT_DETAILS))
190 fprintf (vect_dump, "=== vect_determine_vectorization_factor ===");
192 for (i = 0; i < nbbs; i++)
194 basic_block bb = bbs[i];
196 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
199 stmt_info = vinfo_for_stmt (phi);
200 if (vect_print_dump_info (REPORT_DETAILS))
202 fprintf (vect_dump, "==> examining phi: ");
203 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
206 gcc_assert (stmt_info);
208 if (STMT_VINFO_RELEVANT_P (stmt_info))
210 gcc_assert (!STMT_VINFO_VECTYPE (stmt_info));
211 scalar_type = TREE_TYPE (PHI_RESULT (phi));
213 if (vect_print_dump_info (REPORT_DETAILS))
215 fprintf (vect_dump, "get vectype for scalar type: ");
216 print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
219 vectype = get_vectype_for_scalar_type (scalar_type);
222 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
225 "not vectorized: unsupported data-type ");
226 print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
230 STMT_VINFO_VECTYPE (stmt_info) = vectype;
232 if (vect_print_dump_info (REPORT_DETAILS))
234 fprintf (vect_dump, "vectype: ");
235 print_generic_expr (vect_dump, vectype, TDF_SLIM);
238 nunits = TYPE_VECTOR_SUBPARTS (vectype);
239 if (vect_print_dump_info (REPORT_DETAILS))
240 fprintf (vect_dump, "nunits = %d", nunits);
242 if (!vectorization_factor
243 || (nunits > vectorization_factor))
244 vectorization_factor = nunits;
248 for (si = gsi_start_bb (bb); !gsi_end_p (si) || analyze_pattern_stmt;)
252 if (analyze_pattern_stmt)
255 stmt = gsi_stmt (si);
257 stmt_info = vinfo_for_stmt (stmt);
259 if (vect_print_dump_info (REPORT_DETAILS))
261 fprintf (vect_dump, "==> examining statement: ");
262 print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
265 gcc_assert (stmt_info);
267 /* Skip stmts which do not need to be vectorized. */
268 if (!STMT_VINFO_RELEVANT_P (stmt_info)
269 && !STMT_VINFO_LIVE_P (stmt_info))
271 if (STMT_VINFO_IN_PATTERN_P (stmt_info)
272 && (pattern_stmt = STMT_VINFO_RELATED_STMT (stmt_info))
273 && (STMT_VINFO_RELEVANT_P (vinfo_for_stmt (pattern_stmt))
274 || STMT_VINFO_LIVE_P (vinfo_for_stmt (pattern_stmt))))
277 stmt_info = vinfo_for_stmt (pattern_stmt);
278 if (vect_print_dump_info (REPORT_DETAILS))
280 fprintf (vect_dump, "==> examining pattern statement: ");
281 print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
286 if (vect_print_dump_info (REPORT_DETAILS))
287 fprintf (vect_dump, "skip.");
292 else if (STMT_VINFO_IN_PATTERN_P (stmt_info)
293 && (pattern_stmt = STMT_VINFO_RELATED_STMT (stmt_info))
294 && (STMT_VINFO_RELEVANT_P (vinfo_for_stmt (pattern_stmt))
295 || STMT_VINFO_LIVE_P (vinfo_for_stmt (pattern_stmt))))
296 analyze_pattern_stmt = true;
298 /* If a pattern statement has def stmts, analyze them too. */
299 if (is_pattern_stmt_p (stmt_info))
301 if (pattern_def_seq == NULL)
303 pattern_def_seq = STMT_VINFO_PATTERN_DEF_SEQ (stmt_info);
304 pattern_def_si = gsi_start (pattern_def_seq);
306 else if (!gsi_end_p (pattern_def_si))
307 gsi_next (&pattern_def_si);
308 if (pattern_def_seq != NULL)
310 gimple pattern_def_stmt = NULL;
311 stmt_vec_info pattern_def_stmt_info = NULL;
313 while (!gsi_end_p (pattern_def_si))
315 pattern_def_stmt = gsi_stmt (pattern_def_si);
316 pattern_def_stmt_info
317 = vinfo_for_stmt (pattern_def_stmt);
318 if (STMT_VINFO_RELEVANT_P (pattern_def_stmt_info)
319 || STMT_VINFO_LIVE_P (pattern_def_stmt_info))
321 gsi_next (&pattern_def_si);
324 if (!gsi_end_p (pattern_def_si))
326 if (vect_print_dump_info (REPORT_DETAILS))
329 "==> examining pattern def stmt: ");
330 print_gimple_stmt (vect_dump, pattern_def_stmt, 0,
334 stmt = pattern_def_stmt;
335 stmt_info = pattern_def_stmt_info;
339 pattern_def_si = gsi_start (NULL);
340 analyze_pattern_stmt = false;
344 analyze_pattern_stmt = false;
347 if (gimple_get_lhs (stmt) == NULL_TREE)
349 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
351 fprintf (vect_dump, "not vectorized: irregular stmt.");
352 print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
357 if (VECTOR_MODE_P (TYPE_MODE (gimple_expr_type (stmt))))
359 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
361 fprintf (vect_dump, "not vectorized: vector stmt in loop:");
362 print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
367 if (STMT_VINFO_VECTYPE (stmt_info))
369 /* The only case when a vectype had been already set is for stmts
370 that contain a dataref, or for "pattern-stmts" (stmts
371 generated by the vectorizer to represent/replace a certain
373 gcc_assert (STMT_VINFO_DATA_REF (stmt_info)
374 || is_pattern_stmt_p (stmt_info)
375 || !gsi_end_p (pattern_def_si));
376 vectype = STMT_VINFO_VECTYPE (stmt_info);
380 gcc_assert (!STMT_VINFO_DATA_REF (stmt_info));
381 scalar_type = TREE_TYPE (gimple_get_lhs (stmt));
382 if (vect_print_dump_info (REPORT_DETAILS))
384 fprintf (vect_dump, "get vectype for scalar type: ");
385 print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
387 vectype = get_vectype_for_scalar_type (scalar_type);
390 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
393 "not vectorized: unsupported data-type ");
394 print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
399 STMT_VINFO_VECTYPE (stmt_info) = vectype;
402 /* The vectorization factor is according to the smallest
403 scalar type (or the largest vector size, but we only
404 support one vector size per loop). */
405 scalar_type = vect_get_smallest_scalar_type (stmt, &dummy,
407 if (vect_print_dump_info (REPORT_DETAILS))
409 fprintf (vect_dump, "get vectype for scalar type: ");
410 print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
412 vf_vectype = get_vectype_for_scalar_type (scalar_type);
415 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
418 "not vectorized: unsupported data-type ");
419 print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
424 if ((GET_MODE_SIZE (TYPE_MODE (vectype))
425 != GET_MODE_SIZE (TYPE_MODE (vf_vectype))))
427 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
430 "not vectorized: different sized vector "
431 "types in statement, ");
432 print_generic_expr (vect_dump, vectype, TDF_SLIM);
433 fprintf (vect_dump, " and ");
434 print_generic_expr (vect_dump, vf_vectype, TDF_SLIM);
439 if (vect_print_dump_info (REPORT_DETAILS))
441 fprintf (vect_dump, "vectype: ");
442 print_generic_expr (vect_dump, vf_vectype, TDF_SLIM);
445 nunits = TYPE_VECTOR_SUBPARTS (vf_vectype);
446 if (vect_print_dump_info (REPORT_DETAILS))
447 fprintf (vect_dump, "nunits = %d", nunits);
449 if (!vectorization_factor
450 || (nunits > vectorization_factor))
451 vectorization_factor = nunits;
453 if (!analyze_pattern_stmt && gsi_end_p (pattern_def_si))
455 pattern_def_seq = NULL;
461 /* TODO: Analyze cost. Decide if worth while to vectorize. */
462 if (vect_print_dump_info (REPORT_DETAILS))
463 fprintf (vect_dump, "vectorization factor = %d", vectorization_factor);
464 if (vectorization_factor <= 1)
466 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
467 fprintf (vect_dump, "not vectorized: unsupported data-type");
470 LOOP_VINFO_VECT_FACTOR (loop_vinfo) = vectorization_factor;
476 /* Function vect_is_simple_iv_evolution.
478 FORNOW: A simple evolution of an induction variables in the loop is
479 considered a polynomial evolution with constant step. */
482 vect_is_simple_iv_evolution (unsigned loop_nb, tree access_fn, tree * init,
487 tree evolution_part = evolution_part_in_loop_num (access_fn, loop_nb);
489 /* When there is no evolution in this loop, the evolution function
491 if (evolution_part == NULL_TREE)
494 /* When the evolution is a polynomial of degree >= 2
495 the evolution function is not "simple". */
496 if (tree_is_chrec (evolution_part))
499 step_expr = evolution_part;
500 init_expr = unshare_expr (initial_condition_in_loop_num (access_fn, loop_nb));
502 if (vect_print_dump_info (REPORT_DETAILS))
504 fprintf (vect_dump, "step: ");
505 print_generic_expr (vect_dump, step_expr, TDF_SLIM);
506 fprintf (vect_dump, ", init: ");
507 print_generic_expr (vect_dump, init_expr, TDF_SLIM);
513 if (TREE_CODE (step_expr) != INTEGER_CST)
515 if (vect_print_dump_info (REPORT_DETAILS))
516 fprintf (vect_dump, "step unknown.");
523 /* Function vect_analyze_scalar_cycles_1.
525 Examine the cross iteration def-use cycles of scalar variables
526 in LOOP. LOOP_VINFO represents the loop that is now being
527 considered for vectorization (can be LOOP, or an outer-loop
531 vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop)
533 basic_block bb = loop->header;
535 VEC(gimple,heap) *worklist = VEC_alloc (gimple, heap, 64);
536 gimple_stmt_iterator gsi;
539 if (vect_print_dump_info (REPORT_DETAILS))
540 fprintf (vect_dump, "=== vect_analyze_scalar_cycles ===");
542 /* First - identify all inductions. Reduction detection assumes that all the
543 inductions have been identified, therefore, this order must not be
545 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
547 gimple phi = gsi_stmt (gsi);
548 tree access_fn = NULL;
549 tree def = PHI_RESULT (phi);
550 stmt_vec_info stmt_vinfo = vinfo_for_stmt (phi);
552 if (vect_print_dump_info (REPORT_DETAILS))
554 fprintf (vect_dump, "Analyze phi: ");
555 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
558 /* Skip virtual phi's. The data dependences that are associated with
559 virtual defs/uses (i.e., memory accesses) are analyzed elsewhere. */
560 if (!is_gimple_reg (SSA_NAME_VAR (def)))
563 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_unknown_def_type;
565 /* Analyze the evolution function. */
566 access_fn = analyze_scalar_evolution (loop, def);
569 STRIP_NOPS (access_fn);
570 if (vect_print_dump_info (REPORT_DETAILS))
572 fprintf (vect_dump, "Access function of PHI: ");
573 print_generic_expr (vect_dump, access_fn, TDF_SLIM);
575 STMT_VINFO_LOOP_PHI_EVOLUTION_PART (stmt_vinfo)
576 = evolution_part_in_loop_num (access_fn, loop->num);
580 || !vect_is_simple_iv_evolution (loop->num, access_fn, &dumy, &dumy))
582 VEC_safe_push (gimple, heap, worklist, phi);
586 gcc_assert (STMT_VINFO_LOOP_PHI_EVOLUTION_PART (stmt_vinfo) != NULL_TREE);
588 if (vect_print_dump_info (REPORT_DETAILS))
589 fprintf (vect_dump, "Detected induction.");
590 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_induction_def;
594 /* Second - identify all reductions and nested cycles. */
595 while (VEC_length (gimple, worklist) > 0)
597 gimple phi = VEC_pop (gimple, worklist);
598 tree def = PHI_RESULT (phi);
599 stmt_vec_info stmt_vinfo = vinfo_for_stmt (phi);
603 if (vect_print_dump_info (REPORT_DETAILS))
605 fprintf (vect_dump, "Analyze phi: ");
606 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
609 gcc_assert (is_gimple_reg (SSA_NAME_VAR (def)));
610 gcc_assert (STMT_VINFO_DEF_TYPE (stmt_vinfo) == vect_unknown_def_type);
612 nested_cycle = (loop != LOOP_VINFO_LOOP (loop_vinfo));
613 reduc_stmt = vect_force_simple_reduction (loop_vinfo, phi, !nested_cycle,
619 if (vect_print_dump_info (REPORT_DETAILS))
620 fprintf (vect_dump, "Detected double reduction.");
622 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_double_reduction_def;
623 STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) =
624 vect_double_reduction_def;
630 if (vect_print_dump_info (REPORT_DETAILS))
631 fprintf (vect_dump, "Detected vectorizable nested cycle.");
633 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_nested_cycle;
634 STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) =
639 if (vect_print_dump_info (REPORT_DETAILS))
640 fprintf (vect_dump, "Detected reduction.");
642 STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_reduction_def;
643 STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) =
645 /* Store the reduction cycles for possible vectorization in
647 VEC_safe_push (gimple, heap,
648 LOOP_VINFO_REDUCTIONS (loop_vinfo),
654 if (vect_print_dump_info (REPORT_DETAILS))
655 fprintf (vect_dump, "Unknown def-use cycle pattern.");
658 VEC_free (gimple, heap, worklist);
662 /* Function vect_analyze_scalar_cycles.
664 Examine the cross iteration def-use cycles of scalar variables, by
665 analyzing the loop-header PHIs of scalar variables. Classify each
666 cycle as one of the following: invariant, induction, reduction, unknown.
667 We do that for the loop represented by LOOP_VINFO, and also to its
668 inner-loop, if exists.
669 Examples for scalar cycles:
684 vect_analyze_scalar_cycles (loop_vec_info loop_vinfo)
686 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
688 vect_analyze_scalar_cycles_1 (loop_vinfo, loop);
690 /* When vectorizing an outer-loop, the inner-loop is executed sequentially.
691 Reductions in such inner-loop therefore have different properties than
692 the reductions in the nest that gets vectorized:
693 1. When vectorized, they are executed in the same order as in the original
694 scalar loop, so we can't change the order of computation when
696 2. FIXME: Inner-loop reductions can be used in the inner-loop, so the
697 current checks are too strict. */
700 vect_analyze_scalar_cycles_1 (loop_vinfo, loop->inner);
703 /* Function vect_get_loop_niters.
705 Determine how many iterations the loop is executed.
706 If an expression that represents the number of iterations
707 can be constructed, place it in NUMBER_OF_ITERATIONS.
708 Return the loop exit condition. */
711 vect_get_loop_niters (struct loop *loop, tree *number_of_iterations)
715 if (vect_print_dump_info (REPORT_DETAILS))
716 fprintf (vect_dump, "=== get_loop_niters ===");
718 niters = number_of_exit_cond_executions (loop);
720 if (niters != NULL_TREE
721 && niters != chrec_dont_know)
723 *number_of_iterations = niters;
725 if (vect_print_dump_info (REPORT_DETAILS))
727 fprintf (vect_dump, "==> get_loop_niters:" );
728 print_generic_expr (vect_dump, *number_of_iterations, TDF_SLIM);
732 return get_loop_exit_condition (loop);
736 /* Function bb_in_loop_p
738 Used as predicate for dfs order traversal of the loop bbs. */
741 bb_in_loop_p (const_basic_block bb, const void *data)
743 const struct loop *const loop = (const struct loop *)data;
744 if (flow_bb_inside_loop_p (loop, bb))
750 /* Function new_loop_vec_info.
752 Create and initialize a new loop_vec_info struct for LOOP, as well as
753 stmt_vec_info structs for all the stmts in LOOP. */
756 new_loop_vec_info (struct loop *loop)
760 gimple_stmt_iterator si;
761 unsigned int i, nbbs;
763 res = (loop_vec_info) xcalloc (1, sizeof (struct _loop_vec_info));
764 LOOP_VINFO_LOOP (res) = loop;
766 bbs = get_loop_body (loop);
768 /* Create/Update stmt_info for all stmts in the loop. */
769 for (i = 0; i < loop->num_nodes; i++)
771 basic_block bb = bbs[i];
773 /* BBs in a nested inner-loop will have been already processed (because
774 we will have called vect_analyze_loop_form for any nested inner-loop).
775 Therefore, for stmts in an inner-loop we just want to update the
776 STMT_VINFO_LOOP_VINFO field of their stmt_info to point to the new
777 loop_info of the outer-loop we are currently considering to vectorize
778 (instead of the loop_info of the inner-loop).
779 For stmts in other BBs we need to create a stmt_info from scratch. */
780 if (bb->loop_father != loop)
783 gcc_assert (loop->inner && bb->loop_father == loop->inner);
784 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
786 gimple phi = gsi_stmt (si);
787 stmt_vec_info stmt_info = vinfo_for_stmt (phi);
788 loop_vec_info inner_loop_vinfo =
789 STMT_VINFO_LOOP_VINFO (stmt_info);
790 gcc_assert (loop->inner == LOOP_VINFO_LOOP (inner_loop_vinfo));
791 STMT_VINFO_LOOP_VINFO (stmt_info) = res;
793 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
795 gimple stmt = gsi_stmt (si);
796 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
797 loop_vec_info inner_loop_vinfo =
798 STMT_VINFO_LOOP_VINFO (stmt_info);
799 gcc_assert (loop->inner == LOOP_VINFO_LOOP (inner_loop_vinfo));
800 STMT_VINFO_LOOP_VINFO (stmt_info) = res;
805 /* bb in current nest. */
806 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
808 gimple phi = gsi_stmt (si);
809 gimple_set_uid (phi, 0);
810 set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, res, NULL));
813 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
815 gimple stmt = gsi_stmt (si);
816 gimple_set_uid (stmt, 0);
817 set_vinfo_for_stmt (stmt, new_stmt_vec_info (stmt, res, NULL));
822 /* CHECKME: We want to visit all BBs before their successors (except for
823 latch blocks, for which this assertion wouldn't hold). In the simple
824 case of the loop forms we allow, a dfs order of the BBs would the same
825 as reversed postorder traversal, so we are safe. */
828 bbs = XCNEWVEC (basic_block, loop->num_nodes);
829 nbbs = dfs_enumerate_from (loop->header, 0, bb_in_loop_p,
830 bbs, loop->num_nodes, loop);
831 gcc_assert (nbbs == loop->num_nodes);
833 LOOP_VINFO_BBS (res) = bbs;
834 LOOP_VINFO_NITERS (res) = NULL;
835 LOOP_VINFO_NITERS_UNCHANGED (res) = NULL;
836 LOOP_VINFO_COST_MODEL_MIN_ITERS (res) = 0;
837 LOOP_VINFO_VECTORIZABLE_P (res) = 0;
838 LOOP_PEELING_FOR_ALIGNMENT (res) = 0;
839 LOOP_VINFO_VECT_FACTOR (res) = 0;
840 LOOP_VINFO_LOOP_NEST (res) = VEC_alloc (loop_p, heap, 3);
841 LOOP_VINFO_DATAREFS (res) = VEC_alloc (data_reference_p, heap, 10);
842 LOOP_VINFO_DDRS (res) = VEC_alloc (ddr_p, heap, 10 * 10);
843 LOOP_VINFO_UNALIGNED_DR (res) = NULL;
844 LOOP_VINFO_MAY_MISALIGN_STMTS (res) =
845 VEC_alloc (gimple, heap,
846 PARAM_VALUE (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS));
847 LOOP_VINFO_MAY_ALIAS_DDRS (res) =
848 VEC_alloc (ddr_p, heap,
849 PARAM_VALUE (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS));
850 LOOP_VINFO_STRIDED_STORES (res) = VEC_alloc (gimple, heap, 10);
851 LOOP_VINFO_REDUCTIONS (res) = VEC_alloc (gimple, heap, 10);
852 LOOP_VINFO_REDUCTION_CHAINS (res) = VEC_alloc (gimple, heap, 10);
853 LOOP_VINFO_SLP_INSTANCES (res) = VEC_alloc (slp_instance, heap, 10);
854 LOOP_VINFO_SLP_UNROLLING_FACTOR (res) = 1;
855 LOOP_VINFO_PEELING_HTAB (res) = NULL;
856 LOOP_VINFO_PEELING_FOR_GAPS (res) = false;
862 /* Function destroy_loop_vec_info.
864 Free LOOP_VINFO struct, as well as all the stmt_vec_info structs of all the
865 stmts in the loop. */
868 destroy_loop_vec_info (loop_vec_info loop_vinfo, bool clean_stmts)
873 gimple_stmt_iterator si;
875 VEC (slp_instance, heap) *slp_instances;
876 slp_instance instance;
881 loop = LOOP_VINFO_LOOP (loop_vinfo);
883 bbs = LOOP_VINFO_BBS (loop_vinfo);
884 nbbs = loop->num_nodes;
888 free (LOOP_VINFO_BBS (loop_vinfo));
889 free_data_refs (LOOP_VINFO_DATAREFS (loop_vinfo));
890 free_dependence_relations (LOOP_VINFO_DDRS (loop_vinfo));
891 VEC_free (loop_p, heap, LOOP_VINFO_LOOP_NEST (loop_vinfo));
892 VEC_free (gimple, heap, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo));
893 VEC_free (ddr_p, heap, LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo));
900 for (j = 0; j < nbbs; j++)
902 basic_block bb = bbs[j];
903 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
904 free_stmt_vec_info (gsi_stmt (si));
906 for (si = gsi_start_bb (bb); !gsi_end_p (si); )
908 gimple stmt = gsi_stmt (si);
909 /* Free stmt_vec_info. */
910 free_stmt_vec_info (stmt);
915 free (LOOP_VINFO_BBS (loop_vinfo));
916 free_data_refs (LOOP_VINFO_DATAREFS (loop_vinfo));
917 free_dependence_relations (LOOP_VINFO_DDRS (loop_vinfo));
918 VEC_free (loop_p, heap, LOOP_VINFO_LOOP_NEST (loop_vinfo));
919 VEC_free (gimple, heap, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo));
920 VEC_free (ddr_p, heap, LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo));
921 slp_instances = LOOP_VINFO_SLP_INSTANCES (loop_vinfo);
922 FOR_EACH_VEC_ELT (slp_instance, slp_instances, j, instance)
923 vect_free_slp_instance (instance);
925 VEC_free (slp_instance, heap, LOOP_VINFO_SLP_INSTANCES (loop_vinfo));
926 VEC_free (gimple, heap, LOOP_VINFO_STRIDED_STORES (loop_vinfo));
927 VEC_free (gimple, heap, LOOP_VINFO_REDUCTIONS (loop_vinfo));
928 VEC_free (gimple, heap, LOOP_VINFO_REDUCTION_CHAINS (loop_vinfo));
930 if (LOOP_VINFO_PEELING_HTAB (loop_vinfo))
931 htab_delete (LOOP_VINFO_PEELING_HTAB (loop_vinfo));
938 /* Function vect_analyze_loop_1.
940 Apply a set of analyses on LOOP, and create a loop_vec_info struct
941 for it. The different analyses will record information in the
942 loop_vec_info struct. This is a subset of the analyses applied in
943 vect_analyze_loop, to be applied on an inner-loop nested in the loop
944 that is now considered for (outer-loop) vectorization. */
947 vect_analyze_loop_1 (struct loop *loop)
949 loop_vec_info loop_vinfo;
951 if (vect_print_dump_info (REPORT_DETAILS))
952 fprintf (vect_dump, "===== analyze_loop_nest_1 =====");
954 /* Check the CFG characteristics of the loop (nesting, entry/exit, etc. */
956 loop_vinfo = vect_analyze_loop_form (loop);
959 if (vect_print_dump_info (REPORT_DETAILS))
960 fprintf (vect_dump, "bad inner-loop form.");
968 /* Function vect_analyze_loop_form.
970 Verify that certain CFG restrictions hold, including:
971 - the loop has a pre-header
972 - the loop has a single entry and exit
973 - the loop exit condition is simple enough, and the number of iterations
974 can be analyzed (a countable loop). */
977 vect_analyze_loop_form (struct loop *loop)
979 loop_vec_info loop_vinfo;
981 tree number_of_iterations = NULL;
982 loop_vec_info inner_loop_vinfo = NULL;
984 if (vect_print_dump_info (REPORT_DETAILS))
985 fprintf (vect_dump, "=== vect_analyze_loop_form ===");
987 /* Different restrictions apply when we are considering an inner-most loop,
988 vs. an outer (nested) loop.
989 (FORNOW. May want to relax some of these restrictions in the future). */
993 /* Inner-most loop. We currently require that the number of BBs is
994 exactly 2 (the header and latch). Vectorizable inner-most loops
1005 if (loop->num_nodes != 2)
1007 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1008 fprintf (vect_dump, "not vectorized: control flow in loop.");
1012 if (empty_block_p (loop->header))
1014 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1015 fprintf (vect_dump, "not vectorized: empty loop.");
1021 struct loop *innerloop = loop->inner;
1024 /* Nested loop. We currently require that the loop is doubly-nested,
1025 contains a single inner loop, and the number of BBs is exactly 5.
1026 Vectorizable outer-loops look like this:
1038 The inner-loop has the properties expected of inner-most loops
1039 as described above. */
1041 if ((loop->inner)->inner || (loop->inner)->next)
1043 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1044 fprintf (vect_dump, "not vectorized: multiple nested loops.");
1048 /* Analyze the inner-loop. */
1049 inner_loop_vinfo = vect_analyze_loop_1 (loop->inner);
1050 if (!inner_loop_vinfo)
1052 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1053 fprintf (vect_dump, "not vectorized: Bad inner loop.");
1057 if (!expr_invariant_in_loop_p (loop,
1058 LOOP_VINFO_NITERS (inner_loop_vinfo)))
1060 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1062 "not vectorized: inner-loop count not invariant.");
1063 destroy_loop_vec_info (inner_loop_vinfo, true);
1067 if (loop->num_nodes != 5)
1069 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1070 fprintf (vect_dump, "not vectorized: control flow in loop.");
1071 destroy_loop_vec_info (inner_loop_vinfo, true);
1075 gcc_assert (EDGE_COUNT (innerloop->header->preds) == 2);
1076 entryedge = EDGE_PRED (innerloop->header, 0);
1077 if (EDGE_PRED (innerloop->header, 0)->src == innerloop->latch)
1078 entryedge = EDGE_PRED (innerloop->header, 1);
1080 if (entryedge->src != loop->header
1081 || !single_exit (innerloop)
1082 || single_exit (innerloop)->dest != EDGE_PRED (loop->latch, 0)->src)
1084 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1085 fprintf (vect_dump, "not vectorized: unsupported outerloop form.");
1086 destroy_loop_vec_info (inner_loop_vinfo, true);
1090 if (vect_print_dump_info (REPORT_DETAILS))
1091 fprintf (vect_dump, "Considering outer-loop vectorization.");
1094 if (!single_exit (loop)
1095 || EDGE_COUNT (loop->header->preds) != 2)
1097 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1099 if (!single_exit (loop))
1100 fprintf (vect_dump, "not vectorized: multiple exits.");
1101 else if (EDGE_COUNT (loop->header->preds) != 2)
1102 fprintf (vect_dump, "not vectorized: too many incoming edges.");
1104 if (inner_loop_vinfo)
1105 destroy_loop_vec_info (inner_loop_vinfo, true);
1109 /* We assume that the loop exit condition is at the end of the loop. i.e,
1110 that the loop is represented as a do-while (with a proper if-guard
1111 before the loop if needed), where the loop header contains all the
1112 executable statements, and the latch is empty. */
1113 if (!empty_block_p (loop->latch)
1114 || !gimple_seq_empty_p (phi_nodes (loop->latch)))
1116 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1117 fprintf (vect_dump, "not vectorized: unexpected loop form.");
1118 if (inner_loop_vinfo)
1119 destroy_loop_vec_info (inner_loop_vinfo, true);
1123 /* Make sure there exists a single-predecessor exit bb: */
1124 if (!single_pred_p (single_exit (loop)->dest))
1126 edge e = single_exit (loop);
1127 if (!(e->flags & EDGE_ABNORMAL))
1129 split_loop_exit_edge (e);
1130 if (vect_print_dump_info (REPORT_DETAILS))
1131 fprintf (vect_dump, "split exit edge.");
1135 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1136 fprintf (vect_dump, "not vectorized: abnormal loop exit edge.");
1137 if (inner_loop_vinfo)
1138 destroy_loop_vec_info (inner_loop_vinfo, true);
1143 loop_cond = vect_get_loop_niters (loop, &number_of_iterations);
1146 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1147 fprintf (vect_dump, "not vectorized: complicated exit condition.");
1148 if (inner_loop_vinfo)
1149 destroy_loop_vec_info (inner_loop_vinfo, true);
1153 if (!number_of_iterations)
1155 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1157 "not vectorized: number of iterations cannot be computed.");
1158 if (inner_loop_vinfo)
1159 destroy_loop_vec_info (inner_loop_vinfo, true);
1163 if (chrec_contains_undetermined (number_of_iterations))
1165 if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
1166 fprintf (vect_dump, "Infinite number of iterations.");
1167 if (inner_loop_vinfo)
1168 destroy_loop_vec_info (inner_loop_vinfo, true);
1172 if (!NITERS_KNOWN_P (number_of_iterations))
1174 if (vect_print_dump_info (REPORT_DETAILS))
1176 fprintf (vect_dump, "Symbolic number of iterations is ");
1177 print_generic_expr (vect_dump, number_of_iterations, TDF_DETAILS);
1180 else if (TREE_INT_CST_LOW (number_of_iterations) == 0)
1182 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1183 fprintf (vect_dump, "not vectorized: number of iterations = 0.");
1184 if (inner_loop_vinfo)
1185 destroy_loop_vec_info (inner_loop_vinfo, false);
1189 loop_vinfo = new_loop_vec_info (loop);
1190 LOOP_VINFO_NITERS (loop_vinfo) = number_of_iterations;
1191 LOOP_VINFO_NITERS_UNCHANGED (loop_vinfo) = number_of_iterations;
1193 STMT_VINFO_TYPE (vinfo_for_stmt (loop_cond)) = loop_exit_ctrl_vec_info_type;
1195 /* CHECKME: May want to keep it around it in the future. */
1196 if (inner_loop_vinfo)
1197 destroy_loop_vec_info (inner_loop_vinfo, false);
1199 gcc_assert (!loop->aux);
1200 loop->aux = loop_vinfo;
1205 /* Get cost by calling cost target builtin. */
1208 vect_get_cost (enum vect_cost_for_stmt type_of_cost)
1210 tree dummy_type = NULL;
1213 return targetm.vectorize.builtin_vectorization_cost (type_of_cost,
1218 /* Function vect_analyze_loop_operations.
1220 Scan the loop stmts and make sure they are all vectorizable. */
1223 vect_analyze_loop_operations (loop_vec_info loop_vinfo, bool slp)
1225 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
1226 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
1227 int nbbs = loop->num_nodes;
1228 gimple_stmt_iterator si;
1229 unsigned int vectorization_factor = 0;
1232 stmt_vec_info stmt_info;
1233 bool need_to_vectorize = false;
1234 int min_profitable_iters;
1235 int min_scalar_loop_bound;
1237 bool only_slp_in_loop = true, ok;
1239 if (vect_print_dump_info (REPORT_DETAILS))
1240 fprintf (vect_dump, "=== vect_analyze_loop_operations ===");
1242 gcc_assert (LOOP_VINFO_VECT_FACTOR (loop_vinfo));
1243 vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
1246 /* If all the stmts in the loop can be SLPed, we perform only SLP, and
1247 vectorization factor of the loop is the unrolling factor required by
1248 the SLP instances. If that unrolling factor is 1, we say, that we
1249 perform pure SLP on loop - cross iteration parallelism is not
1251 for (i = 0; i < nbbs; i++)
1253 basic_block bb = bbs[i];
1254 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
1256 gimple stmt = gsi_stmt (si);
1257 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
1258 gcc_assert (stmt_info);
1259 if ((STMT_VINFO_RELEVANT_P (stmt_info)
1260 || VECTORIZABLE_CYCLE_DEF (STMT_VINFO_DEF_TYPE (stmt_info)))
1261 && !PURE_SLP_STMT (stmt_info))
1262 /* STMT needs both SLP and loop-based vectorization. */
1263 only_slp_in_loop = false;
1267 if (only_slp_in_loop)
1268 vectorization_factor = LOOP_VINFO_SLP_UNROLLING_FACTOR (loop_vinfo);
1270 vectorization_factor = least_common_multiple (vectorization_factor,
1271 LOOP_VINFO_SLP_UNROLLING_FACTOR (loop_vinfo));
1273 LOOP_VINFO_VECT_FACTOR (loop_vinfo) = vectorization_factor;
1274 if (vect_print_dump_info (REPORT_DETAILS))
1275 fprintf (vect_dump, "Updating vectorization factor to %d ",
1276 vectorization_factor);
1279 for (i = 0; i < nbbs; i++)
1281 basic_block bb = bbs[i];
1283 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
1285 phi = gsi_stmt (si);
1288 stmt_info = vinfo_for_stmt (phi);
1289 if (vect_print_dump_info (REPORT_DETAILS))
1291 fprintf (vect_dump, "examining phi: ");
1292 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
1295 /* Inner-loop loop-closed exit phi in outer-loop vectorization
1296 (i.e., a phi in the tail of the outer-loop). */
1297 if (! is_loop_header_bb_p (bb))
1299 /* FORNOW: we currently don't support the case that these phis
1300 are not used in the outerloop (unless it is double reduction,
1301 i.e., this phi is vect_reduction_def), cause this case
1302 requires to actually do something here. */
1303 if ((!STMT_VINFO_RELEVANT_P (stmt_info)
1304 || STMT_VINFO_LIVE_P (stmt_info))
1305 && STMT_VINFO_DEF_TYPE (stmt_info)
1306 != vect_double_reduction_def)
1308 if (vect_print_dump_info (REPORT_DETAILS))
1310 "Unsupported loop-closed phi in outer-loop.");
1314 /* If PHI is used in the outer loop, we check that its operand
1315 is defined in the inner loop. */
1316 if (STMT_VINFO_RELEVANT_P (stmt_info))
1321 if (gimple_phi_num_args (phi) != 1)
1324 phi_op = PHI_ARG_DEF (phi, 0);
1325 if (TREE_CODE (phi_op) != SSA_NAME)
1328 op_def_stmt = SSA_NAME_DEF_STMT (phi_op);
1330 || !flow_bb_inside_loop_p (loop, gimple_bb (op_def_stmt))
1331 || !vinfo_for_stmt (op_def_stmt))
1334 if (STMT_VINFO_RELEVANT (vinfo_for_stmt (op_def_stmt))
1335 != vect_used_in_outer
1336 && STMT_VINFO_RELEVANT (vinfo_for_stmt (op_def_stmt))
1337 != vect_used_in_outer_by_reduction)
1344 gcc_assert (stmt_info);
1346 if (STMT_VINFO_LIVE_P (stmt_info))
1348 /* FORNOW: not yet supported. */
1349 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1350 fprintf (vect_dump, "not vectorized: value used after loop.");
1354 if (STMT_VINFO_RELEVANT (stmt_info) == vect_used_in_scope
1355 && STMT_VINFO_DEF_TYPE (stmt_info) != vect_induction_def)
1357 /* A scalar-dependence cycle that we don't support. */
1358 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1359 fprintf (vect_dump, "not vectorized: scalar dependence cycle.");
1363 if (STMT_VINFO_RELEVANT_P (stmt_info))
1365 need_to_vectorize = true;
1366 if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_induction_def)
1367 ok = vectorizable_induction (phi, NULL, NULL);
1372 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1375 "not vectorized: relevant phi not supported: ");
1376 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
1382 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
1384 gimple stmt = gsi_stmt (si);
1385 if (!vect_analyze_stmt (stmt, &need_to_vectorize, NULL))
1390 /* All operations in the loop are either irrelevant (deal with loop
1391 control, or dead), or only used outside the loop and can be moved
1392 out of the loop (e.g. invariants, inductions). The loop can be
1393 optimized away by scalar optimizations. We're better off not
1394 touching this loop. */
1395 if (!need_to_vectorize)
1397 if (vect_print_dump_info (REPORT_DETAILS))
1399 "All the computation can be taken out of the loop.");
1400 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1402 "not vectorized: redundant loop. no profit to vectorize.");
1406 if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
1407 && vect_print_dump_info (REPORT_DETAILS))
1409 "vectorization_factor = %d, niters = " HOST_WIDE_INT_PRINT_DEC,
1410 vectorization_factor, LOOP_VINFO_INT_NITERS (loop_vinfo));
1412 if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
1413 && (LOOP_VINFO_INT_NITERS (loop_vinfo) < vectorization_factor))
1415 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1416 fprintf (vect_dump, "not vectorized: iteration count too small.");
1417 if (vect_print_dump_info (REPORT_DETAILS))
1418 fprintf (vect_dump,"not vectorized: iteration count smaller than "
1419 "vectorization factor.");
1423 /* Analyze cost. Decide if worth while to vectorize. */
1425 /* Once VF is set, SLP costs should be updated since the number of created
1426 vector stmts depends on VF. */
1427 vect_update_slp_costs_according_to_vf (loop_vinfo);
1429 min_profitable_iters = vect_estimate_min_profitable_iters (loop_vinfo);
1430 LOOP_VINFO_COST_MODEL_MIN_ITERS (loop_vinfo) = min_profitable_iters;
1432 if (min_profitable_iters < 0)
1434 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1435 fprintf (vect_dump, "not vectorized: vectorization not profitable.");
1436 if (vect_print_dump_info (REPORT_DETAILS))
1437 fprintf (vect_dump, "not vectorized: vector version will never be "
1442 min_scalar_loop_bound = ((PARAM_VALUE (PARAM_MIN_VECT_LOOP_BOUND)
1443 * vectorization_factor) - 1);
1445 /* Use the cost model only if it is more conservative than user specified
1448 th = (unsigned) min_scalar_loop_bound;
1449 if (min_profitable_iters
1450 && (!min_scalar_loop_bound
1451 || min_profitable_iters > min_scalar_loop_bound))
1452 th = (unsigned) min_profitable_iters;
1454 if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
1455 && LOOP_VINFO_INT_NITERS (loop_vinfo) <= th)
1457 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1458 fprintf (vect_dump, "not vectorized: vectorization not "
1460 if (vect_print_dump_info (REPORT_DETAILS))
1461 fprintf (vect_dump, "not vectorized: iteration count smaller than "
1462 "user specified loop bound parameter or minimum "
1463 "profitable iterations (whichever is more conservative).");
1467 if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
1468 || LOOP_VINFO_INT_NITERS (loop_vinfo) % vectorization_factor != 0
1469 || LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo))
1471 if (vect_print_dump_info (REPORT_DETAILS))
1472 fprintf (vect_dump, "epilog loop required.");
1473 if (!vect_can_advance_ivs_p (loop_vinfo))
1475 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1477 "not vectorized: can't create epilog loop 1.");
1480 if (!slpeel_can_duplicate_loop_p (loop, single_exit (loop)))
1482 if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
1484 "not vectorized: can't create epilog loop 2.");
1493 /* Function vect_analyze_loop_2.
1495 Apply a set of analyses on LOOP, and create a loop_vec_info struct
1496 for it. The different analyses will record information in the
1497 loop_vec_info struct. */
1499 vect_analyze_loop_2 (loop_vec_info loop_vinfo)
1501 bool ok, slp = false;
1502 int max_vf = MAX_VECTORIZATION_FACTOR;
1505 /* Find all data references in the loop (which correspond to vdefs/vuses)
1506 and analyze their evolution in the loop. Also adjust the minimal
1507 vectorization factor according to the loads and stores.
1509 FORNOW: Handle only simple, array references, which
1510 alignment can be forced, and aligned pointer-references. */
1512 ok = vect_analyze_data_refs (loop_vinfo, NULL, &min_vf);
1515 if (vect_print_dump_info (REPORT_DETAILS))
1516 fprintf (vect_dump, "bad data references.");
1520 /* Classify all cross-iteration scalar data-flow cycles.
1521 Cross-iteration cycles caused by virtual phis are analyzed separately. */
1523 vect_analyze_scalar_cycles (loop_vinfo);
1525 vect_pattern_recog (loop_vinfo);
1527 /* Data-flow analysis to detect stmts that do not need to be vectorized. */
1529 ok = vect_mark_stmts_to_be_vectorized (loop_vinfo);
1532 if (vect_print_dump_info (REPORT_DETAILS))
1533 fprintf (vect_dump, "unexpected pattern.");
1537 /* Analyze data dependences between the data-refs in the loop
1538 and adjust the maximum vectorization factor according to
1540 FORNOW: fail at the first data dependence that we encounter. */
1542 ok = vect_analyze_data_ref_dependences (loop_vinfo, NULL, &max_vf);
1546 if (vect_print_dump_info (REPORT_DETAILS))
1547 fprintf (vect_dump, "bad data dependence.");
1551 ok = vect_determine_vectorization_factor (loop_vinfo);
1554 if (vect_print_dump_info (REPORT_DETAILS))
1555 fprintf (vect_dump, "can't determine vectorization factor.");
1558 if (max_vf < LOOP_VINFO_VECT_FACTOR (loop_vinfo))
1560 if (vect_print_dump_info (REPORT_DETAILS))
1561 fprintf (vect_dump, "bad data dependence.");
1565 /* Analyze the alignment of the data-refs in the loop.
1566 Fail if a data reference is found that cannot be vectorized. */
1568 ok = vect_analyze_data_refs_alignment (loop_vinfo, NULL);
1571 if (vect_print_dump_info (REPORT_DETAILS))
1572 fprintf (vect_dump, "bad data alignment.");
1576 /* Analyze the access patterns of the data-refs in the loop (consecutive,
1577 complex, etc.). FORNOW: Only handle consecutive access pattern. */
1579 ok = vect_analyze_data_ref_accesses (loop_vinfo, NULL);
1582 if (vect_print_dump_info (REPORT_DETAILS))
1583 fprintf (vect_dump, "bad data access.");
1587 /* Prune the list of ddrs to be tested at run-time by versioning for alias.
1588 It is important to call pruning after vect_analyze_data_ref_accesses,
1589 since we use grouping information gathered by interleaving analysis. */
1590 ok = vect_prune_runtime_alias_test_list (loop_vinfo);
1593 if (vect_print_dump_info (REPORT_DETAILS))
1594 fprintf (vect_dump, "too long list of versioning for alias "
1599 /* This pass will decide on using loop versioning and/or loop peeling in
1600 order to enhance the alignment of data references in the loop. */
1602 ok = vect_enhance_data_refs_alignment (loop_vinfo);
1605 if (vect_print_dump_info (REPORT_DETAILS))
1606 fprintf (vect_dump, "bad data alignment.");
1610 /* Check the SLP opportunities in the loop, analyze and build SLP trees. */
1611 ok = vect_analyze_slp (loop_vinfo, NULL);
1614 /* Decide which possible SLP instances to SLP. */
1615 slp = vect_make_slp_decision (loop_vinfo);
1617 /* Find stmts that need to be both vectorized and SLPed. */
1618 vect_detect_hybrid_slp (loop_vinfo);
1623 /* Scan all the operations in the loop and make sure they are
1626 ok = vect_analyze_loop_operations (loop_vinfo, slp);
1629 if (vect_print_dump_info (REPORT_DETAILS))
1630 fprintf (vect_dump, "bad operation or unsupported loop bound.");
1637 /* Function vect_analyze_loop.
1639 Apply a set of analyses on LOOP, and create a loop_vec_info struct
1640 for it. The different analyses will record information in the
1641 loop_vec_info struct. */
1643 vect_analyze_loop (struct loop *loop)
1645 loop_vec_info loop_vinfo;
1646 unsigned int vector_sizes;
1648 /* Autodetect first vector size we try. */
1649 current_vector_size = 0;
1650 vector_sizes = targetm.vectorize.autovectorize_vector_sizes ();
1652 if (vect_print_dump_info (REPORT_DETAILS))
1653 fprintf (vect_dump, "===== analyze_loop_nest =====");
1655 if (loop_outer (loop)
1656 && loop_vec_info_for_loop (loop_outer (loop))
1657 && LOOP_VINFO_VECTORIZABLE_P (loop_vec_info_for_loop (loop_outer (loop))))
1659 if (vect_print_dump_info (REPORT_DETAILS))
1660 fprintf (vect_dump, "outer-loop already vectorized.");
1666 /* Check the CFG characteristics of the loop (nesting, entry/exit). */
1667 loop_vinfo = vect_analyze_loop_form (loop);
1670 if (vect_print_dump_info (REPORT_DETAILS))
1671 fprintf (vect_dump, "bad loop form.");
1675 if (vect_analyze_loop_2 (loop_vinfo))
1677 LOOP_VINFO_VECTORIZABLE_P (loop_vinfo) = 1;
1682 destroy_loop_vec_info (loop_vinfo, true);
1684 vector_sizes &= ~current_vector_size;
1685 if (vector_sizes == 0
1686 || current_vector_size == 0)
1689 /* Try the next biggest vector size. */
1690 current_vector_size = 1 << floor_log2 (vector_sizes);
1691 if (vect_print_dump_info (REPORT_DETAILS))
1692 fprintf (vect_dump, "***** Re-trying analysis with "
1693 "vector size %d\n", current_vector_size);
1698 /* Function reduction_code_for_scalar_code
1701 CODE - tree_code of a reduction operations.
1704 REDUC_CODE - the corresponding tree-code to be used to reduce the
1705 vector of partial results into a single scalar result (which
1706 will also reside in a vector) or ERROR_MARK if the operation is
1707 a supported reduction operation, but does not have such tree-code.
1709 Return FALSE if CODE currently cannot be vectorized as reduction. */
1712 reduction_code_for_scalar_code (enum tree_code code,
1713 enum tree_code *reduc_code)
1718 *reduc_code = REDUC_MAX_EXPR;
1722 *reduc_code = REDUC_MIN_EXPR;
1726 *reduc_code = REDUC_PLUS_EXPR;
1734 *reduc_code = ERROR_MARK;
1743 /* Error reporting helper for vect_is_simple_reduction below. GIMPLE statement
1744 STMT is printed with a message MSG. */
1747 report_vect_op (gimple stmt, const char *msg)
1749 fprintf (vect_dump, "%s", msg);
1750 print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
1754 /* Detect SLP reduction of the form:
1764 PHI is the reduction phi node (#a1 = phi <a5, a0> above)
1765 FIRST_STMT is the first reduction stmt in the chain
1766 (a2 = operation (a1)).
1768 Return TRUE if a reduction chain was detected. */
1771 vect_is_slp_reduction (loop_vec_info loop_info, gimple phi, gimple first_stmt)
1773 struct loop *loop = (gimple_bb (phi))->loop_father;
1774 struct loop *vect_loop = LOOP_VINFO_LOOP (loop_info);
1775 enum tree_code code;
1776 gimple current_stmt = NULL, loop_use_stmt = NULL, first, next_stmt;
1777 stmt_vec_info use_stmt_info, current_stmt_info;
1779 imm_use_iterator imm_iter;
1780 use_operand_p use_p;
1781 int nloop_uses, size = 0, n_out_of_loop_uses;
1784 if (loop != vect_loop)
1787 lhs = PHI_RESULT (phi);
1788 code = gimple_assign_rhs_code (first_stmt);
1792 n_out_of_loop_uses = 0;
1793 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, lhs)
1795 gimple use_stmt = USE_STMT (use_p);
1796 if (is_gimple_debug (use_stmt))
1799 use_stmt = USE_STMT (use_p);
1801 /* Check if we got back to the reduction phi. */
1802 if (use_stmt == phi)
1804 loop_use_stmt = use_stmt;
1809 if (flow_bb_inside_loop_p (loop, gimple_bb (use_stmt)))
1811 if (vinfo_for_stmt (use_stmt)
1812 && !STMT_VINFO_IN_PATTERN_P (vinfo_for_stmt (use_stmt)))
1814 loop_use_stmt = use_stmt;
1819 n_out_of_loop_uses++;
1821 /* There are can be either a single use in the loop or two uses in
1823 if (nloop_uses > 1 || (n_out_of_loop_uses && nloop_uses))
1830 /* We reached a statement with no loop uses. */
1831 if (nloop_uses == 0)
1834 /* This is a loop exit phi, and we haven't reached the reduction phi. */
1835 if (gimple_code (loop_use_stmt) == GIMPLE_PHI)
1838 if (!is_gimple_assign (loop_use_stmt)
1839 || code != gimple_assign_rhs_code (loop_use_stmt)
1840 || !flow_bb_inside_loop_p (loop, gimple_bb (loop_use_stmt)))
1843 /* Insert USE_STMT into reduction chain. */
1844 use_stmt_info = vinfo_for_stmt (loop_use_stmt);
1847 current_stmt_info = vinfo_for_stmt (current_stmt);
1848 GROUP_NEXT_ELEMENT (current_stmt_info) = loop_use_stmt;
1849 GROUP_FIRST_ELEMENT (use_stmt_info)
1850 = GROUP_FIRST_ELEMENT (current_stmt_info);
1853 GROUP_FIRST_ELEMENT (use_stmt_info) = loop_use_stmt;
1855 lhs = gimple_assign_lhs (loop_use_stmt);
1856 current_stmt = loop_use_stmt;
1860 if (!found || loop_use_stmt != phi || size < 2)
1863 /* Swap the operands, if needed, to make the reduction operand be the second
1865 lhs = PHI_RESULT (phi);
1866 next_stmt = GROUP_FIRST_ELEMENT (vinfo_for_stmt (current_stmt));
1869 if (gimple_assign_rhs2 (next_stmt) == lhs)
1871 tree op = gimple_assign_rhs1 (next_stmt);
1872 gimple def_stmt = NULL;
1874 if (TREE_CODE (op) == SSA_NAME)
1875 def_stmt = SSA_NAME_DEF_STMT (op);
1877 /* Check that the other def is either defined in the loop
1878 ("vect_internal_def"), or it's an induction (defined by a
1879 loop-header phi-node). */
1881 && gimple_bb (def_stmt)
1882 && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))
1883 && (is_gimple_assign (def_stmt)
1884 || is_gimple_call (def_stmt)
1885 || STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def_stmt))
1886 == vect_induction_def
1887 || (gimple_code (def_stmt) == GIMPLE_PHI
1888 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def_stmt))
1889 == vect_internal_def
1890 && !is_loop_header_bb_p (gimple_bb (def_stmt)))))
1892 lhs = gimple_assign_lhs (next_stmt);
1893 next_stmt = GROUP_NEXT_ELEMENT (vinfo_for_stmt (next_stmt));
1901 tree op = gimple_assign_rhs2 (next_stmt);
1902 gimple def_stmt = NULL;
1904 if (TREE_CODE (op) == SSA_NAME)
1905 def_stmt = SSA_NAME_DEF_STMT (op);
1907 /* Check that the other def is either defined in the loop
1908 ("vect_internal_def"), or it's an induction (defined by a
1909 loop-header phi-node). */
1911 && gimple_bb (def_stmt)
1912 && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))
1913 && (is_gimple_assign (def_stmt)
1914 || is_gimple_call (def_stmt)
1915 || STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def_stmt))
1916 == vect_induction_def
1917 || (gimple_code (def_stmt) == GIMPLE_PHI
1918 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def_stmt))
1919 == vect_internal_def
1920 && !is_loop_header_bb_p (gimple_bb (def_stmt)))))
1922 if (vect_print_dump_info (REPORT_DETAILS))
1924 fprintf (vect_dump, "swapping oprnds: ");
1925 print_gimple_stmt (vect_dump, next_stmt, 0, TDF_SLIM);
1928 swap_tree_operands (next_stmt,
1929 gimple_assign_rhs1_ptr (next_stmt),
1930 gimple_assign_rhs2_ptr (next_stmt));
1931 mark_symbols_for_renaming (next_stmt);
1937 lhs = gimple_assign_lhs (next_stmt);
1938 next_stmt = GROUP_NEXT_ELEMENT (vinfo_for_stmt (next_stmt));
1941 /* Save the chain for further analysis in SLP detection. */
1942 first = GROUP_FIRST_ELEMENT (vinfo_for_stmt (current_stmt));
1943 VEC_safe_push (gimple, heap, LOOP_VINFO_REDUCTION_CHAINS (loop_info), first);
1944 GROUP_SIZE (vinfo_for_stmt (first)) = size;
1950 /* Function vect_is_simple_reduction_1
1952 (1) Detect a cross-iteration def-use cycle that represents a simple
1953 reduction computation. We look for the following pattern:
1958 a2 = operation (a3, a1)
1961 1. operation is commutative and associative and it is safe to
1962 change the order of the computation (if CHECK_REDUCTION is true)
1963 2. no uses for a2 in the loop (a2 is used out of the loop)
1964 3. no uses of a1 in the loop besides the reduction operation
1965 4. no uses of a1 outside the loop.
1967 Conditions 1,4 are tested here.
1968 Conditions 2,3 are tested in vect_mark_stmts_to_be_vectorized.
1970 (2) Detect a cross-iteration def-use cycle in nested loops, i.e.,
1971 nested cycles, if CHECK_REDUCTION is false.
1973 (3) Detect cycles of phi nodes in outer-loop vectorization, i.e., double
1977 inner loop (def of a3)
1980 If MODIFY is true it tries also to rework the code in-place to enable
1981 detection of more reduction patterns. For the time being we rewrite
1982 "res -= RHS" into "rhs += -RHS" when it seems worthwhile.
1986 vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
1987 bool check_reduction, bool *double_reduc,
1990 struct loop *loop = (gimple_bb (phi))->loop_father;
1991 struct loop *vect_loop = LOOP_VINFO_LOOP (loop_info);
1992 edge latch_e = loop_latch_edge (loop);
1993 tree loop_arg = PHI_ARG_DEF_FROM_EDGE (phi, latch_e);
1994 gimple def_stmt, def1 = NULL, def2 = NULL;
1995 enum tree_code orig_code, code;
1996 tree op1, op2, op3 = NULL_TREE, op4 = NULL_TREE;
2000 imm_use_iterator imm_iter;
2001 use_operand_p use_p;
2004 *double_reduc = false;
2006 /* If CHECK_REDUCTION is true, we assume inner-most loop vectorization,
2007 otherwise, we assume outer loop vectorization. */
2008 gcc_assert ((check_reduction && loop == vect_loop)
2009 || (!check_reduction && flow_loop_nested_p (vect_loop, loop)));
2011 name = PHI_RESULT (phi);
2013 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, name)
2015 gimple use_stmt = USE_STMT (use_p);
2016 if (is_gimple_debug (use_stmt))
2019 if (!flow_bb_inside_loop_p (loop, gimple_bb (use_stmt)))
2021 if (vect_print_dump_info (REPORT_DETAILS))
2022 fprintf (vect_dump, "intermediate value used outside loop.");
2027 if (vinfo_for_stmt (use_stmt)
2028 && !is_pattern_stmt_p (vinfo_for_stmt (use_stmt)))
2032 if (vect_print_dump_info (REPORT_DETAILS))
2033 fprintf (vect_dump, "reduction used in loop.");
2038 if (TREE_CODE (loop_arg) != SSA_NAME)
2040 if (vect_print_dump_info (REPORT_DETAILS))
2042 fprintf (vect_dump, "reduction: not ssa_name: ");
2043 print_generic_expr (vect_dump, loop_arg, TDF_SLIM);
2048 def_stmt = SSA_NAME_DEF_STMT (loop_arg);
2051 if (vect_print_dump_info (REPORT_DETAILS))
2052 fprintf (vect_dump, "reduction: no def_stmt.");
2056 if (!is_gimple_assign (def_stmt) && gimple_code (def_stmt) != GIMPLE_PHI)
2058 if (vect_print_dump_info (REPORT_DETAILS))
2059 print_gimple_stmt (vect_dump, def_stmt, 0, TDF_SLIM);
2063 if (is_gimple_assign (def_stmt))
2065 name = gimple_assign_lhs (def_stmt);
2070 name = PHI_RESULT (def_stmt);
2075 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, name)
2077 gimple use_stmt = USE_STMT (use_p);
2078 if (is_gimple_debug (use_stmt))
2080 if (flow_bb_inside_loop_p (loop, gimple_bb (use_stmt))
2081 && vinfo_for_stmt (use_stmt)
2082 && !is_pattern_stmt_p (vinfo_for_stmt (use_stmt)))
2086 if (vect_print_dump_info (REPORT_DETAILS))
2087 fprintf (vect_dump, "reduction used in loop.");
2092 /* If DEF_STMT is a phi node itself, we expect it to have a single argument
2093 defined in the inner loop. */
2096 op1 = PHI_ARG_DEF (def_stmt, 0);
2098 if (gimple_phi_num_args (def_stmt) != 1
2099 || TREE_CODE (op1) != SSA_NAME)
2101 if (vect_print_dump_info (REPORT_DETAILS))
2102 fprintf (vect_dump, "unsupported phi node definition.");
2107 def1 = SSA_NAME_DEF_STMT (op1);
2108 if (flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))
2110 && flow_bb_inside_loop_p (loop->inner, gimple_bb (def1))
2111 && is_gimple_assign (def1))
2113 if (vect_print_dump_info (REPORT_DETAILS))
2114 report_vect_op (def_stmt, "detected double reduction: ");
2116 *double_reduc = true;
2123 code = orig_code = gimple_assign_rhs_code (def_stmt);
2125 /* We can handle "res -= x[i]", which is non-associative by
2126 simply rewriting this into "res += -x[i]". Avoid changing
2127 gimple instruction for the first simple tests and only do this
2128 if we're allowed to change code at all. */
2129 if (code == MINUS_EXPR
2131 && (op1 = gimple_assign_rhs1 (def_stmt))
2132 && TREE_CODE (op1) == SSA_NAME
2133 && SSA_NAME_DEF_STMT (op1) == phi)
2137 && (!commutative_tree_code (code) || !associative_tree_code (code)))
2139 if (vect_print_dump_info (REPORT_DETAILS))
2140 report_vect_op (def_stmt, "reduction: not commutative/associative: ");
2144 if (get_gimple_rhs_class (code) != GIMPLE_BINARY_RHS)
2146 if (code != COND_EXPR)
2148 if (vect_print_dump_info (REPORT_DETAILS))
2149 report_vect_op (def_stmt, "reduction: not binary operation: ");
2154 op3 = gimple_assign_rhs1 (def_stmt);
2155 if (COMPARISON_CLASS_P (op3))
2157 op4 = TREE_OPERAND (op3, 1);
2158 op3 = TREE_OPERAND (op3, 0);
2161 op1 = gimple_assign_rhs2 (def_stmt);
2162 op2 = gimple_assign_rhs3 (def_stmt);
2164 if (TREE_CODE (op1) != SSA_NAME && TREE_CODE (op2) != SSA_NAME)
2166 if (vect_print_dump_info (REPORT_DETAILS))
2167 report_vect_op (def_stmt, "reduction: uses not ssa_names: ");
2174 op1 = gimple_assign_rhs1 (def_stmt);
2175 op2 = gimple_assign_rhs2 (def_stmt);
2177 if (TREE_CODE (op1) != SSA_NAME && TREE_CODE (op2) != SSA_NAME)
2179 if (vect_print_dump_info (REPORT_DETAILS))
2180 report_vect_op (def_stmt, "reduction: uses not ssa_names: ");
2186 type = TREE_TYPE (gimple_assign_lhs (def_stmt));
2187 if ((TREE_CODE (op1) == SSA_NAME
2188 && !types_compatible_p (type,TREE_TYPE (op1)))
2189 || (TREE_CODE (op2) == SSA_NAME
2190 && !types_compatible_p (type, TREE_TYPE (op2)))
2191 || (op3 && TREE_CODE (op3) == SSA_NAME
2192 && !types_compatible_p (type, TREE_TYPE (op3)))
2193 || (op4 && TREE_CODE (op4) == SSA_NAME
2194 && !types_compatible_p (type, TREE_TYPE (op4))))
2196 if (vect_print_dump_info (REPORT_DETAILS))
2198 fprintf (vect_dump, "reduction: multiple types: operation type: ");
2199 print_generic_expr (vect_dump, type, TDF_SLIM);
2200 fprintf (vect_dump, ", operands types: ");
2201 print_generic_expr (vect_dump, TREE_TYPE (op1), TDF_SLIM);
2202 fprintf (vect_dump, ",");
2203 print_generic_expr (vect_dump, TREE_TYPE (op2), TDF_SLIM);
2206 fprintf (vect_dump, ",");
2207 print_generic_expr (vect_dump, TREE_TYPE (op3), TDF_SLIM);
2212 fprintf (vect_dump, ",");
2213 print_generic_expr (vect_dump, TREE_TYPE (op4), TDF_SLIM);
2220 /* Check that it's ok to change the order of the computation.
2221 Generally, when vectorizing a reduction we change the order of the
2222 computation. This may change the behavior of the program in some
2223 cases, so we need to check that this is ok. One exception is when
2224 vectorizing an outer-loop: the inner-loop is executed sequentially,
2225 and therefore vectorizing reductions in the inner-loop during
2226 outer-loop vectorization is safe. */
2228 /* CHECKME: check for !flag_finite_math_only too? */
2229 if (SCALAR_FLOAT_TYPE_P (type) && !flag_associative_math
2232 /* Changing the order of operations changes the semantics. */
2233 if (vect_print_dump_info (REPORT_DETAILS))
2234 report_vect_op (def_stmt, "reduction: unsafe fp math optimization: ");
2237 else if (INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type)
2240 /* Changing the order of operations changes the semantics. */
2241 if (vect_print_dump_info (REPORT_DETAILS))
2242 report_vect_op (def_stmt, "reduction: unsafe int math optimization: ");
2245 else if (SAT_FIXED_POINT_TYPE_P (type) && check_reduction)
2247 /* Changing the order of operations changes the semantics. */
2248 if (vect_print_dump_info (REPORT_DETAILS))
2249 report_vect_op (def_stmt,
2250 "reduction: unsafe fixed-point math optimization: ");
2254 /* If we detected "res -= x[i]" earlier, rewrite it into
2255 "res += -x[i]" now. If this turns out to be useless reassoc
2256 will clean it up again. */
2257 if (orig_code == MINUS_EXPR)
2259 tree rhs = gimple_assign_rhs2 (def_stmt);
2260 tree negrhs = make_ssa_name (SSA_NAME_VAR (rhs), NULL);
2261 gimple negate_stmt = gimple_build_assign_with_ops (NEGATE_EXPR, negrhs,
2263 gimple_stmt_iterator gsi = gsi_for_stmt (def_stmt);
2264 set_vinfo_for_stmt (negate_stmt, new_stmt_vec_info (negate_stmt,
2266 gsi_insert_before (&gsi, negate_stmt, GSI_NEW_STMT);
2267 gimple_assign_set_rhs2 (def_stmt, negrhs);
2268 gimple_assign_set_rhs_code (def_stmt, PLUS_EXPR);
2269 update_stmt (def_stmt);
2272 /* Reduction is safe. We're dealing with one of the following:
2273 1) integer arithmetic and no trapv
2274 2) floating point arithmetic, and special flags permit this optimization
2275 3) nested cycle (i.e., outer loop vectorization). */
2276 if (TREE_CODE (op1) == SSA_NAME)
2277 def1 = SSA_NAME_DEF_STMT (op1);
2279 if (TREE_CODE (op2) == SSA_NAME)
2280 def2 = SSA_NAME_DEF_STMT (op2);
2282 if (code != COND_EXPR
2283 && ((!def1 || gimple_nop_p (def1)) && (!def2 || gimple_nop_p (def2))))
2285 if (vect_print_dump_info (REPORT_DETAILS))
2286 report_vect_op (def_stmt, "reduction: no defs for operands: ");
2290 /* Check that one def is the reduction def, defined by PHI,
2291 the other def is either defined in the loop ("vect_internal_def"),
2292 or it's an induction (defined by a loop-header phi-node). */
2294 if (def2 && def2 == phi
2295 && (code == COND_EXPR
2296 || !def1 || gimple_nop_p (def1)
2297 || (def1 && flow_bb_inside_loop_p (loop, gimple_bb (def1))
2298 && (is_gimple_assign (def1)
2299 || is_gimple_call (def1)
2300 || STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def1))
2301 == vect_induction_def
2302 || (gimple_code (def1) == GIMPLE_PHI
2303 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def1))
2304 == vect_internal_def
2305 && !is_loop_header_bb_p (gimple_bb (def1)))))))
2307 if (vect_print_dump_info (REPORT_DETAILS))
2308 report_vect_op (def_stmt, "detected reduction: ");
2312 if (def1 && def1 == phi
2313 && (code == COND_EXPR
2314 || !def2 || gimple_nop_p (def2)
2315 || (def2 && flow_bb_inside_loop_p (loop, gimple_bb (def2))
2316 && (is_gimple_assign (def2)
2317 || is_gimple_call (def2)
2318 || STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def2))
2319 == vect_induction_def
2320 || (gimple_code (def2) == GIMPLE_PHI
2321 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def2))
2322 == vect_internal_def
2323 && !is_loop_header_bb_p (gimple_bb (def2)))))))
2325 if (check_reduction)
2327 /* Swap operands (just for simplicity - so that the rest of the code
2328 can assume that the reduction variable is always the last (second)
2330 if (vect_print_dump_info (REPORT_DETAILS))
2331 report_vect_op (def_stmt,
2332 "detected reduction: need to swap operands: ");
2334 swap_tree_operands (def_stmt, gimple_assign_rhs1_ptr (def_stmt),
2335 gimple_assign_rhs2_ptr (def_stmt));
2339 if (vect_print_dump_info (REPORT_DETAILS))
2340 report_vect_op (def_stmt, "detected reduction: ");
2346 /* Try to find SLP reduction chain. */
2347 if (check_reduction && vect_is_slp_reduction (loop_info, phi, def_stmt))
2349 if (vect_print_dump_info (REPORT_DETAILS))
2350 report_vect_op (def_stmt, "reduction: detected reduction chain: ");
2355 if (vect_print_dump_info (REPORT_DETAILS))
2356 report_vect_op (def_stmt, "reduction: unknown pattern: ");
2361 /* Wrapper around vect_is_simple_reduction_1, that won't modify code
2362 in-place. Arguments as there. */
2365 vect_is_simple_reduction (loop_vec_info loop_info, gimple phi,
2366 bool check_reduction, bool *double_reduc)
2368 return vect_is_simple_reduction_1 (loop_info, phi, check_reduction,
2369 double_reduc, false);
2372 /* Wrapper around vect_is_simple_reduction_1, which will modify code
2373 in-place if it enables detection of more reductions. Arguments
2377 vect_force_simple_reduction (loop_vec_info loop_info, gimple phi,
2378 bool check_reduction, bool *double_reduc)
2380 return vect_is_simple_reduction_1 (loop_info, phi, check_reduction,
2381 double_reduc, true);
2384 /* Calculate the cost of one scalar iteration of the loop. */
2386 vect_get_single_scalar_iteraion_cost (loop_vec_info loop_vinfo)
2388 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2389 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
2390 int nbbs = loop->num_nodes, factor, scalar_single_iter_cost = 0;
2391 int innerloop_iters, i, stmt_cost;
2393 /* Count statements in scalar loop. Using this as scalar cost for a single
2396 TODO: Add outer loop support.
2398 TODO: Consider assigning different costs to different scalar
2402 innerloop_iters = 1;
2404 innerloop_iters = 50; /* FIXME */
2406 for (i = 0; i < nbbs; i++)
2408 gimple_stmt_iterator si;
2409 basic_block bb = bbs[i];
2411 if (bb->loop_father == loop->inner)
2412 factor = innerloop_iters;
2416 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
2418 gimple stmt = gsi_stmt (si);
2419 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
2421 if (!is_gimple_assign (stmt) && !is_gimple_call (stmt))
2424 /* Skip stmts that are not vectorized inside the loop. */
2426 && !STMT_VINFO_RELEVANT_P (stmt_info)
2427 && (!STMT_VINFO_LIVE_P (stmt_info)
2428 || !VECTORIZABLE_CYCLE_DEF (STMT_VINFO_DEF_TYPE (stmt_info)))
2429 && !STMT_VINFO_IN_PATTERN_P (stmt_info))
2432 if (STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt)))
2434 if (DR_IS_READ (STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt))))
2435 stmt_cost = vect_get_cost (scalar_load);
2437 stmt_cost = vect_get_cost (scalar_store);
2440 stmt_cost = vect_get_cost (scalar_stmt);
2442 scalar_single_iter_cost += stmt_cost * factor;
2445 return scalar_single_iter_cost;
2448 /* Calculate cost of peeling the loop PEEL_ITERS_PROLOGUE times. */
2450 vect_get_known_peeling_cost (loop_vec_info loop_vinfo, int peel_iters_prologue,
2451 int *peel_iters_epilogue,
2452 int scalar_single_iter_cost)
2454 int peel_guard_costs = 0;
2455 int vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
2457 if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo))
2459 *peel_iters_epilogue = vf/2;
2460 if (vect_print_dump_info (REPORT_COST))
2461 fprintf (vect_dump, "cost model: "
2462 "epilogue peel iters set to vf/2 because "
2463 "loop iterations are unknown .");
2465 /* If peeled iterations are known but number of scalar loop
2466 iterations are unknown, count a taken branch per peeled loop. */
2467 peel_guard_costs = 2 * vect_get_cost (cond_branch_taken);
2471 int niters = LOOP_VINFO_INT_NITERS (loop_vinfo);
2472 peel_iters_prologue = niters < peel_iters_prologue ?
2473 niters : peel_iters_prologue;
2474 *peel_iters_epilogue = (niters - peel_iters_prologue) % vf;
2475 /* If we need to peel for gaps, but no peeling is required, we have to
2476 peel VF iterations. */
2477 if (LOOP_VINFO_PEELING_FOR_GAPS (loop_vinfo) && !*peel_iters_epilogue)
2478 *peel_iters_epilogue = vf;
2481 return (peel_iters_prologue * scalar_single_iter_cost)
2482 + (*peel_iters_epilogue * scalar_single_iter_cost)
2486 /* Function vect_estimate_min_profitable_iters
2488 Return the number of iterations required for the vector version of the
2489 loop to be profitable relative to the cost of the scalar version of the
2492 TODO: Take profile info into account before making vectorization
2493 decisions, if available. */
2496 vect_estimate_min_profitable_iters (loop_vec_info loop_vinfo)
2499 int min_profitable_iters;
2500 int peel_iters_prologue;
2501 int peel_iters_epilogue;
2502 int vec_inside_cost = 0;
2503 int vec_outside_cost = 0;
2504 int scalar_single_iter_cost = 0;
2505 int scalar_outside_cost = 0;
2506 int vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
2507 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2508 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
2509 int nbbs = loop->num_nodes;
2510 int npeel = LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo);
2511 int peel_guard_costs = 0;
2512 int innerloop_iters = 0, factor;
2513 VEC (slp_instance, heap) *slp_instances;
2514 slp_instance instance;
2516 /* Cost model disabled. */
2517 if (!flag_vect_cost_model)
2519 if (vect_print_dump_info (REPORT_COST))
2520 fprintf (vect_dump, "cost model disabled.");
2524 /* Requires loop versioning tests to handle misalignment. */
2525 if (LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo))
2527 /* FIXME: Make cost depend on complexity of individual check. */
2529 VEC_length (gimple, LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo));
2530 if (vect_print_dump_info (REPORT_COST))
2531 fprintf (vect_dump, "cost model: Adding cost of checks for loop "
2532 "versioning to treat misalignment.\n");
2535 /* Requires loop versioning with alias checks. */
2536 if (LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
2538 /* FIXME: Make cost depend on complexity of individual check. */
2540 VEC_length (ddr_p, LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo));
2541 if (vect_print_dump_info (REPORT_COST))
2542 fprintf (vect_dump, "cost model: Adding cost of checks for loop "
2543 "versioning aliasing.\n");
2546 if (LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)
2547 || LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
2548 vec_outside_cost += vect_get_cost (cond_branch_taken);
2550 /* Count statements in scalar loop. Using this as scalar cost for a single
2553 TODO: Add outer loop support.
2555 TODO: Consider assigning different costs to different scalar
2560 innerloop_iters = 50; /* FIXME */
2562 for (i = 0; i < nbbs; i++)
2564 gimple_stmt_iterator si;
2565 basic_block bb = bbs[i];
2567 if (bb->loop_father == loop->inner)
2568 factor = innerloop_iters;
2572 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
2574 gimple stmt = gsi_stmt (si);
2575 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
2577 if (STMT_VINFO_IN_PATTERN_P (stmt_info))
2579 stmt = STMT_VINFO_RELATED_STMT (stmt_info);
2580 stmt_info = vinfo_for_stmt (stmt);
2583 /* Skip stmts that are not vectorized inside the loop. */
2584 if (!STMT_VINFO_RELEVANT_P (stmt_info)
2585 && (!STMT_VINFO_LIVE_P (stmt_info)
2586 || !VECTORIZABLE_CYCLE_DEF (STMT_VINFO_DEF_TYPE (stmt_info))))
2589 vec_inside_cost += STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info) * factor;
2590 /* FIXME: for stmts in the inner-loop in outer-loop vectorization,
2591 some of the "outside" costs are generated inside the outer-loop. */
2592 vec_outside_cost += STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info);
2593 if (is_pattern_stmt_p (stmt_info)
2594 && STMT_VINFO_PATTERN_DEF_SEQ (stmt_info))
2596 gimple_stmt_iterator gsi;
2598 for (gsi = gsi_start (STMT_VINFO_PATTERN_DEF_SEQ (stmt_info));
2599 !gsi_end_p (gsi); gsi_next (&gsi))
2601 gimple pattern_def_stmt = gsi_stmt (gsi);
2602 stmt_vec_info pattern_def_stmt_info
2603 = vinfo_for_stmt (pattern_def_stmt);
2604 if (STMT_VINFO_RELEVANT_P (pattern_def_stmt_info)
2605 || STMT_VINFO_LIVE_P (pattern_def_stmt_info))
2608 += STMT_VINFO_INSIDE_OF_LOOP_COST
2609 (pattern_def_stmt_info) * factor;
2611 += STMT_VINFO_OUTSIDE_OF_LOOP_COST
2612 (pattern_def_stmt_info);
2619 scalar_single_iter_cost = vect_get_single_scalar_iteraion_cost (loop_vinfo);
2621 /* Add additional cost for the peeled instructions in prologue and epilogue
2624 FORNOW: If we don't know the value of peel_iters for prologue or epilogue
2625 at compile-time - we assume it's vf/2 (the worst would be vf-1).
2627 TODO: Build an expression that represents peel_iters for prologue and
2628 epilogue to be used in a run-time test. */
2632 peel_iters_prologue = vf/2;
2633 if (vect_print_dump_info (REPORT_COST))
2634 fprintf (vect_dump, "cost model: "
2635 "prologue peel iters set to vf/2.");
2637 /* If peeling for alignment is unknown, loop bound of main loop becomes
2639 peel_iters_epilogue = vf/2;
2640 if (vect_print_dump_info (REPORT_COST))
2641 fprintf (vect_dump, "cost model: "
2642 "epilogue peel iters set to vf/2 because "
2643 "peeling for alignment is unknown .");
2645 /* If peeled iterations are unknown, count a taken branch and a not taken
2646 branch per peeled loop. Even if scalar loop iterations are known,
2647 vector iterations are not known since peeled prologue iterations are
2648 not known. Hence guards remain the same. */
2649 peel_guard_costs += 2 * (vect_get_cost (cond_branch_taken)
2650 + vect_get_cost (cond_branch_not_taken));
2651 vec_outside_cost += (peel_iters_prologue * scalar_single_iter_cost)
2652 + (peel_iters_epilogue * scalar_single_iter_cost)
2657 peel_iters_prologue = npeel;
2658 vec_outside_cost += vect_get_known_peeling_cost (loop_vinfo,
2659 peel_iters_prologue, &peel_iters_epilogue,
2660 scalar_single_iter_cost);
2663 /* FORNOW: The scalar outside cost is incremented in one of the
2666 1. The vectorizer checks for alignment and aliasing and generates
2667 a condition that allows dynamic vectorization. A cost model
2668 check is ANDED with the versioning condition. Hence scalar code
2669 path now has the added cost of the versioning check.
2671 if (cost > th & versioning_check)
2674 Hence run-time scalar is incremented by not-taken branch cost.
2676 2. The vectorizer then checks if a prologue is required. If the
2677 cost model check was not done before during versioning, it has to
2678 be done before the prologue check.
2681 prologue = scalar_iters
2686 if (prologue == num_iters)
2689 Hence the run-time scalar cost is incremented by a taken branch,
2690 plus a not-taken branch, plus a taken branch cost.
2692 3. The vectorizer then checks if an epilogue is required. If the
2693 cost model check was not done before during prologue check, it
2694 has to be done with the epilogue check.
2700 if (prologue == num_iters)
2703 if ((cost <= th) | (scalar_iters-prologue-epilogue == 0))
2706 Hence the run-time scalar cost should be incremented by 2 taken
2709 TODO: The back end may reorder the BBS's differently and reverse
2710 conditions/branch directions. Change the estimates below to
2711 something more reasonable. */
2713 /* If the number of iterations is known and we do not do versioning, we can
2714 decide whether to vectorize at compile time. Hence the scalar version
2715 do not carry cost model guard costs. */
2716 if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
2717 || LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)
2718 || LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
2720 /* Cost model check occurs at versioning. */
2721 if (LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)
2722 || LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
2723 scalar_outside_cost += vect_get_cost (cond_branch_not_taken);
2726 /* Cost model check occurs at prologue generation. */
2727 if (LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo) < 0)
2728 scalar_outside_cost += 2 * vect_get_cost (cond_branch_taken)
2729 + vect_get_cost (cond_branch_not_taken);
2730 /* Cost model check occurs at epilogue generation. */
2732 scalar_outside_cost += 2 * vect_get_cost (cond_branch_taken);
2736 /* Add SLP costs. */
2737 slp_instances = LOOP_VINFO_SLP_INSTANCES (loop_vinfo);
2738 FOR_EACH_VEC_ELT (slp_instance, slp_instances, i, instance)
2740 vec_outside_cost += SLP_INSTANCE_OUTSIDE_OF_LOOP_COST (instance);
2741 vec_inside_cost += SLP_INSTANCE_INSIDE_OF_LOOP_COST (instance);
2744 /* Calculate number of iterations required to make the vector version
2745 profitable, relative to the loop bodies only. The following condition
2747 SIC * niters + SOC > VIC * ((niters-PL_ITERS-EP_ITERS)/VF) + VOC
2749 SIC = scalar iteration cost, VIC = vector iteration cost,
2750 VOC = vector outside cost, VF = vectorization factor,
2751 PL_ITERS = prologue iterations, EP_ITERS= epilogue iterations
2752 SOC = scalar outside cost for run time cost model check. */
2754 if ((scalar_single_iter_cost * vf) > vec_inside_cost)
2756 if (vec_outside_cost <= 0)
2757 min_profitable_iters = 1;
2760 min_profitable_iters = ((vec_outside_cost - scalar_outside_cost) * vf
2761 - vec_inside_cost * peel_iters_prologue
2762 - vec_inside_cost * peel_iters_epilogue)
2763 / ((scalar_single_iter_cost * vf)
2766 if ((scalar_single_iter_cost * vf * min_profitable_iters)
2767 <= ((vec_inside_cost * min_profitable_iters)
2768 + ((vec_outside_cost - scalar_outside_cost) * vf)))
2769 min_profitable_iters++;
2772 /* vector version will never be profitable. */
2775 if (vect_print_dump_info (REPORT_COST))
2776 fprintf (vect_dump, "cost model: the vector iteration cost = %d "
2777 "divided by the scalar iteration cost = %d "
2778 "is greater or equal to the vectorization factor = %d.",
2779 vec_inside_cost, scalar_single_iter_cost, vf);
2783 if (vect_print_dump_info (REPORT_COST))
2785 fprintf (vect_dump, "Cost model analysis: \n");
2786 fprintf (vect_dump, " Vector inside of loop cost: %d\n",
2788 fprintf (vect_dump, " Vector outside of loop cost: %d\n",
2790 fprintf (vect_dump, " Scalar iteration cost: %d\n",
2791 scalar_single_iter_cost);
2792 fprintf (vect_dump, " Scalar outside cost: %d\n", scalar_outside_cost);
2793 fprintf (vect_dump, " prologue iterations: %d\n",
2794 peel_iters_prologue);
2795 fprintf (vect_dump, " epilogue iterations: %d\n",
2796 peel_iters_epilogue);
2797 fprintf (vect_dump, " Calculated minimum iters for profitability: %d\n",
2798 min_profitable_iters);
2801 min_profitable_iters =
2802 min_profitable_iters < vf ? vf : min_profitable_iters;
2804 /* Because the condition we create is:
2805 if (niters <= min_profitable_iters)
2806 then skip the vectorized loop. */
2807 min_profitable_iters--;
2809 if (vect_print_dump_info (REPORT_COST))
2810 fprintf (vect_dump, " Profitability threshold = %d\n",
2811 min_profitable_iters);
2813 return min_profitable_iters;
2817 /* TODO: Close dependency between vect_model_*_cost and vectorizable_*
2818 functions. Design better to avoid maintenance issues. */
2820 /* Function vect_model_reduction_cost.
2822 Models cost for a reduction operation, including the vector ops
2823 generated within the strip-mine loop, the initial definition before
2824 the loop, and the epilogue code that must be generated. */
2827 vect_model_reduction_cost (stmt_vec_info stmt_info, enum tree_code reduc_code,
2831 enum tree_code code;
2834 gimple stmt, orig_stmt;
2836 enum machine_mode mode;
2837 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
2838 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2841 /* Cost of reduction op inside loop. */
2842 STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info)
2843 += ncopies * vect_get_cost (vector_stmt);
2845 stmt = STMT_VINFO_STMT (stmt_info);
2847 switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
2849 case GIMPLE_SINGLE_RHS:
2850 gcc_assert (TREE_OPERAND_LENGTH (gimple_assign_rhs1 (stmt)) == ternary_op);
2851 reduction_op = TREE_OPERAND (gimple_assign_rhs1 (stmt), 2);
2853 case GIMPLE_UNARY_RHS:
2854 reduction_op = gimple_assign_rhs1 (stmt);
2856 case GIMPLE_BINARY_RHS:
2857 reduction_op = gimple_assign_rhs2 (stmt);
2859 case GIMPLE_TERNARY_RHS:
2860 reduction_op = gimple_assign_rhs3 (stmt);
2866 vectype = get_vectype_for_scalar_type (TREE_TYPE (reduction_op));
2869 if (vect_print_dump_info (REPORT_COST))
2871 fprintf (vect_dump, "unsupported data-type ");
2872 print_generic_expr (vect_dump, TREE_TYPE (reduction_op), TDF_SLIM);
2877 mode = TYPE_MODE (vectype);
2878 orig_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
2881 orig_stmt = STMT_VINFO_STMT (stmt_info);
2883 code = gimple_assign_rhs_code (orig_stmt);
2885 /* Add in cost for initial definition. */
2886 outer_cost += vect_get_cost (scalar_to_vec);
2888 /* Determine cost of epilogue code.
2890 We have a reduction operator that will reduce the vector in one statement.
2891 Also requires scalar extract. */
2893 if (!nested_in_vect_loop_p (loop, orig_stmt))
2895 if (reduc_code != ERROR_MARK)
2896 outer_cost += vect_get_cost (vector_stmt)
2897 + vect_get_cost (vec_to_scalar);
2900 int vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1);
2902 TYPE_SIZE (TREE_TYPE (gimple_assign_lhs (orig_stmt)));
2903 int element_bitsize = tree_low_cst (bitsize, 1);
2904 int nelements = vec_size_in_bits / element_bitsize;
2906 optab = optab_for_tree_code (code, vectype, optab_default);
2908 /* We have a whole vector shift available. */
2909 if (VECTOR_MODE_P (mode)
2910 && optab_handler (optab, mode) != CODE_FOR_nothing
2911 && optab_handler (vec_shr_optab, mode) != CODE_FOR_nothing)
2912 /* Final reduction via vector shifts and the reduction operator. Also
2913 requires scalar extract. */
2914 outer_cost += ((exact_log2(nelements) * 2)
2915 * vect_get_cost (vector_stmt)
2916 + vect_get_cost (vec_to_scalar));
2918 /* Use extracts and reduction op for final reduction. For N elements,
2919 we have N extracts and N-1 reduction ops. */
2920 outer_cost += ((nelements + nelements - 1)
2921 * vect_get_cost (vector_stmt));
2925 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info) = outer_cost;
2927 if (vect_print_dump_info (REPORT_COST))
2928 fprintf (vect_dump, "vect_model_reduction_cost: inside_cost = %d, "
2929 "outside_cost = %d .", STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info),
2930 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info));
2936 /* Function vect_model_induction_cost.
2938 Models cost for induction operations. */
2941 vect_model_induction_cost (stmt_vec_info stmt_info, int ncopies)
2943 /* loop cost for vec_loop. */
2944 STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info)
2945 = ncopies * vect_get_cost (vector_stmt);
2946 /* prologue cost for vec_init and vec_step. */
2947 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info)
2948 = 2 * vect_get_cost (scalar_to_vec);
2950 if (vect_print_dump_info (REPORT_COST))
2951 fprintf (vect_dump, "vect_model_induction_cost: inside_cost = %d, "
2952 "outside_cost = %d .", STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info),
2953 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info));
2957 /* Function get_initial_def_for_induction
2960 STMT - a stmt that performs an induction operation in the loop.
2961 IV_PHI - the initial value of the induction variable
2964 Return a vector variable, initialized with the first VF values of
2965 the induction variable. E.g., for an iv with IV_PHI='X' and
2966 evolution S, for a vector of 4 units, we want to return:
2967 [X, X + S, X + 2*S, X + 3*S]. */
2970 get_initial_def_for_induction (gimple iv_phi)
2972 stmt_vec_info stmt_vinfo = vinfo_for_stmt (iv_phi);
2973 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
2974 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
2978 edge pe = loop_preheader_edge (loop);
2979 struct loop *iv_loop;
2981 tree vec, vec_init, vec_step, t;
2985 gimple init_stmt, induction_phi, new_stmt;
2986 tree induc_def, vec_def, vec_dest;
2987 tree init_expr, step_expr;
2988 int vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
2993 stmt_vec_info phi_info = vinfo_for_stmt (iv_phi);
2994 bool nested_in_vect_loop = false;
2995 gimple_seq stmts = NULL;
2996 imm_use_iterator imm_iter;
2997 use_operand_p use_p;
3001 gimple_stmt_iterator si;
3002 basic_block bb = gimple_bb (iv_phi);
3006 /* Is phi in an inner-loop, while vectorizing an enclosing outer-loop? */
3007 if (nested_in_vect_loop_p (loop, iv_phi))
3009 nested_in_vect_loop = true;
3010 iv_loop = loop->inner;
3014 gcc_assert (iv_loop == (gimple_bb (iv_phi))->loop_father);
3016 latch_e = loop_latch_edge (iv_loop);
3017 loop_arg = PHI_ARG_DEF_FROM_EDGE (iv_phi, latch_e);
3019 access_fn = analyze_scalar_evolution (iv_loop, PHI_RESULT (iv_phi));
3020 gcc_assert (access_fn);
3021 STRIP_NOPS (access_fn);
3022 ok = vect_is_simple_iv_evolution (iv_loop->num, access_fn,
3023 &init_expr, &step_expr);
3025 pe = loop_preheader_edge (iv_loop);
3027 scalar_type = TREE_TYPE (init_expr);
3028 vectype = get_vectype_for_scalar_type (scalar_type);
3029 resvectype = get_vectype_for_scalar_type (TREE_TYPE (PHI_RESULT (iv_phi)));
3030 gcc_assert (vectype);
3031 nunits = TYPE_VECTOR_SUBPARTS (vectype);
3032 ncopies = vf / nunits;
3034 gcc_assert (phi_info);
3035 gcc_assert (ncopies >= 1);
3037 /* Find the first insertion point in the BB. */
3038 si = gsi_after_labels (bb);
3040 /* Create the vector that holds the initial_value of the induction. */
3041 if (nested_in_vect_loop)
3043 /* iv_loop is nested in the loop to be vectorized. init_expr had already
3044 been created during vectorization of previous stmts. We obtain it
3045 from the STMT_VINFO_VEC_STMT of the defining stmt. */
3046 tree iv_def = PHI_ARG_DEF_FROM_EDGE (iv_phi,
3047 loop_preheader_edge (iv_loop));
3048 vec_init = vect_get_vec_def_for_operand (iv_def, iv_phi, NULL);
3052 /* iv_loop is the loop to be vectorized. Create:
3053 vec_init = [X, X+S, X+2*S, X+3*S] (S = step_expr, X = init_expr) */
3054 new_var = vect_get_new_vect_var (scalar_type, vect_scalar_var, "var_");
3055 add_referenced_var (new_var);
3057 new_name = force_gimple_operand (init_expr, &stmts, false, new_var);
3060 new_bb = gsi_insert_seq_on_edge_immediate (pe, stmts);
3061 gcc_assert (!new_bb);
3065 t = tree_cons (NULL_TREE, new_name, t);
3066 for (i = 1; i < nunits; i++)
3068 /* Create: new_name_i = new_name + step_expr */
3069 enum tree_code code = POINTER_TYPE_P (scalar_type)
3070 ? POINTER_PLUS_EXPR : PLUS_EXPR;
3071 init_stmt = gimple_build_assign_with_ops (code, new_var,
3072 new_name, step_expr);
3073 new_name = make_ssa_name (new_var, init_stmt);
3074 gimple_assign_set_lhs (init_stmt, new_name);
3076 new_bb = gsi_insert_on_edge_immediate (pe, init_stmt);
3077 gcc_assert (!new_bb);
3079 if (vect_print_dump_info (REPORT_DETAILS))
3081 fprintf (vect_dump, "created new init_stmt: ");
3082 print_gimple_stmt (vect_dump, init_stmt, 0, TDF_SLIM);
3084 t = tree_cons (NULL_TREE, new_name, t);
3086 /* Create a vector from [new_name_0, new_name_1, ..., new_name_nunits-1] */
3087 vec = build_constructor_from_list (vectype, nreverse (t));
3088 vec_init = vect_init_vector (iv_phi, vec, vectype, NULL);
3092 /* Create the vector that holds the step of the induction. */
3093 if (nested_in_vect_loop)
3094 /* iv_loop is nested in the loop to be vectorized. Generate:
3095 vec_step = [S, S, S, S] */
3096 new_name = step_expr;
3099 /* iv_loop is the loop to be vectorized. Generate:
3100 vec_step = [VF*S, VF*S, VF*S, VF*S] */
3101 expr = build_int_cst (TREE_TYPE (step_expr), vf);
3102 new_name = fold_build2 (MULT_EXPR, TREE_TYPE (step_expr),
3106 t = unshare_expr (new_name);
3107 gcc_assert (CONSTANT_CLASS_P (new_name));
3108 stepvectype = get_vectype_for_scalar_type (TREE_TYPE (new_name));
3109 gcc_assert (stepvectype);
3110 vec = build_vector_from_val (stepvectype, t);
3111 vec_step = vect_init_vector (iv_phi, vec, stepvectype, NULL);
3114 /* Create the following def-use cycle:
3119 vec_iv = PHI <vec_init, vec_loop>
3123 vec_loop = vec_iv + vec_step; */
3125 /* Create the induction-phi that defines the induction-operand. */
3126 vec_dest = vect_get_new_vect_var (vectype, vect_simple_var, "vec_iv_");
3127 add_referenced_var (vec_dest);
3128 induction_phi = create_phi_node (vec_dest, iv_loop->header);
3129 set_vinfo_for_stmt (induction_phi,
3130 new_stmt_vec_info (induction_phi, loop_vinfo, NULL));
3131 induc_def = PHI_RESULT (induction_phi);
3133 /* Create the iv update inside the loop */
3134 new_stmt = gimple_build_assign_with_ops (PLUS_EXPR, vec_dest,
3135 induc_def, vec_step);
3136 vec_def = make_ssa_name (vec_dest, new_stmt);
3137 gimple_assign_set_lhs (new_stmt, vec_def);
3138 gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
3139 set_vinfo_for_stmt (new_stmt, new_stmt_vec_info (new_stmt, loop_vinfo,
3142 /* Set the arguments of the phi node: */
3143 add_phi_arg (induction_phi, vec_init, pe, UNKNOWN_LOCATION);
3144 add_phi_arg (induction_phi, vec_def, loop_latch_edge (iv_loop),
3148 /* In case that vectorization factor (VF) is bigger than the number
3149 of elements that we can fit in a vectype (nunits), we have to generate
3150 more than one vector stmt - i.e - we need to "unroll" the
3151 vector stmt by a factor VF/nunits. For more details see documentation
3152 in vectorizable_operation. */
3156 stmt_vec_info prev_stmt_vinfo;
3157 /* FORNOW. This restriction should be relaxed. */
3158 gcc_assert (!nested_in_vect_loop);
3160 /* Create the vector that holds the step of the induction. */
3161 expr = build_int_cst (TREE_TYPE (step_expr), nunits);
3162 new_name = fold_build2 (MULT_EXPR, TREE_TYPE (step_expr),
3164 t = unshare_expr (new_name);
3165 gcc_assert (CONSTANT_CLASS_P (new_name));
3166 vec = build_vector_from_val (stepvectype, t);
3167 vec_step = vect_init_vector (iv_phi, vec, stepvectype, NULL);
3169 vec_def = induc_def;
3170 prev_stmt_vinfo = vinfo_for_stmt (induction_phi);
3171 for (i = 1; i < ncopies; i++)
3173 /* vec_i = vec_prev + vec_step */
3174 new_stmt = gimple_build_assign_with_ops (PLUS_EXPR, vec_dest,
3176 vec_def = make_ssa_name (vec_dest, new_stmt);
3177 gimple_assign_set_lhs (new_stmt, vec_def);
3179 gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
3180 if (!useless_type_conversion_p (resvectype, vectype))
3182 new_stmt = gimple_build_assign_with_ops
3184 vect_get_new_vect_var (resvectype, vect_simple_var,
3186 build1 (VIEW_CONVERT_EXPR, resvectype,
3187 gimple_assign_lhs (new_stmt)), NULL_TREE);
3188 gimple_assign_set_lhs (new_stmt,
3190 (gimple_assign_lhs (new_stmt), new_stmt));
3191 gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
3193 set_vinfo_for_stmt (new_stmt,
3194 new_stmt_vec_info (new_stmt, loop_vinfo, NULL));
3195 STMT_VINFO_RELATED_STMT (prev_stmt_vinfo) = new_stmt;
3196 prev_stmt_vinfo = vinfo_for_stmt (new_stmt);
3200 if (nested_in_vect_loop)
3202 /* Find the loop-closed exit-phi of the induction, and record
3203 the final vector of induction results: */
3205 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, loop_arg)
3207 if (!flow_bb_inside_loop_p (iv_loop, gimple_bb (USE_STMT (use_p))))
3209 exit_phi = USE_STMT (use_p);
3215 stmt_vec_info stmt_vinfo = vinfo_for_stmt (exit_phi);
3216 /* FORNOW. Currently not supporting the case that an inner-loop induction
3217 is not used in the outer-loop (i.e. only outside the outer-loop). */
3218 gcc_assert (STMT_VINFO_RELEVANT_P (stmt_vinfo)
3219 && !STMT_VINFO_LIVE_P (stmt_vinfo));
3221 STMT_VINFO_VEC_STMT (stmt_vinfo) = new_stmt;
3222 if (vect_print_dump_info (REPORT_DETAILS))
3224 fprintf (vect_dump, "vector of inductions after inner-loop:");
3225 print_gimple_stmt (vect_dump, new_stmt, 0, TDF_SLIM);
3231 if (vect_print_dump_info (REPORT_DETAILS))
3233 fprintf (vect_dump, "transform induction: created def-use cycle: ");
3234 print_gimple_stmt (vect_dump, induction_phi, 0, TDF_SLIM);
3235 fprintf (vect_dump, "\n");
3236 print_gimple_stmt (vect_dump, SSA_NAME_DEF_STMT (vec_def), 0, TDF_SLIM);
3239 STMT_VINFO_VEC_STMT (phi_info) = induction_phi;
3240 if (!useless_type_conversion_p (resvectype, vectype))
3242 new_stmt = gimple_build_assign_with_ops
3244 vect_get_new_vect_var (resvectype, vect_simple_var, "vec_iv_"),
3245 build1 (VIEW_CONVERT_EXPR, resvectype, induc_def), NULL_TREE);
3246 induc_def = make_ssa_name (gimple_assign_lhs (new_stmt), new_stmt);
3247 gimple_assign_set_lhs (new_stmt, induc_def);
3248 si = gsi_start_bb (bb);
3249 gsi_insert_before (&si, new_stmt, GSI_SAME_STMT);
3250 set_vinfo_for_stmt (new_stmt,
3251 new_stmt_vec_info (new_stmt, loop_vinfo, NULL));
3252 STMT_VINFO_RELATED_STMT (vinfo_for_stmt (new_stmt))
3253 = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (induction_phi));
3260 /* Function get_initial_def_for_reduction
3263 STMT - a stmt that performs a reduction operation in the loop.
3264 INIT_VAL - the initial value of the reduction variable
3267 ADJUSTMENT_DEF - a tree that holds a value to be added to the final result
3268 of the reduction (used for adjusting the epilog - see below).
3269 Return a vector variable, initialized according to the operation that STMT
3270 performs. This vector will be used as the initial value of the
3271 vector of partial results.
3273 Option1 (adjust in epilog): Initialize the vector as follows:
3274 add/bit or/xor: [0,0,...,0,0]
3275 mult/bit and: [1,1,...,1,1]
3276 min/max/cond_expr: [init_val,init_val,..,init_val,init_val]
3277 and when necessary (e.g. add/mult case) let the caller know
3278 that it needs to adjust the result by init_val.
3280 Option2: Initialize the vector as follows:
3281 add/bit or/xor: [init_val,0,0,...,0]
3282 mult/bit and: [init_val,1,1,...,1]
3283 min/max/cond_expr: [init_val,init_val,...,init_val]
3284 and no adjustments are needed.
3286 For example, for the following code:
3292 STMT is 's = s + a[i]', and the reduction variable is 's'.
3293 For a vector of 4 units, we want to return either [0,0,0,init_val],
3294 or [0,0,0,0] and let the caller know that it needs to adjust
3295 the result at the end by 'init_val'.
3297 FORNOW, we are using the 'adjust in epilog' scheme, because this way the
3298 initialization vector is simpler (same element in all entries), if
3299 ADJUSTMENT_DEF is not NULL, and Option2 otherwise.
3301 A cost model should help decide between these two schemes. */
3304 get_initial_def_for_reduction (gimple stmt, tree init_val,
3305 tree *adjustment_def)
3307 stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt);
3308 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
3309 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
3310 tree scalar_type = TREE_TYPE (init_val);
3311 tree vectype = get_vectype_for_scalar_type (scalar_type);
3313 enum tree_code code = gimple_assign_rhs_code (stmt);
3318 bool nested_in_vect_loop = false;
3320 REAL_VALUE_TYPE real_init_val = dconst0;
3321 int int_init_val = 0;
3322 gimple def_stmt = NULL;
3324 gcc_assert (vectype);
3325 nunits = TYPE_VECTOR_SUBPARTS (vectype);
3327 gcc_assert (POINTER_TYPE_P (scalar_type) || INTEGRAL_TYPE_P (scalar_type)
3328 || SCALAR_FLOAT_TYPE_P (scalar_type));
3330 if (nested_in_vect_loop_p (loop, stmt))
3331 nested_in_vect_loop = true;
3333 gcc_assert (loop == (gimple_bb (stmt))->loop_father);
3335 /* In case of double reduction we only create a vector variable to be put
3336 in the reduction phi node. The actual statement creation is done in
3337 vect_create_epilog_for_reduction. */
3338 if (adjustment_def && nested_in_vect_loop
3339 && TREE_CODE (init_val) == SSA_NAME
3340 && (def_stmt = SSA_NAME_DEF_STMT (init_val))
3341 && gimple_code (def_stmt) == GIMPLE_PHI
3342 && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))
3343 && vinfo_for_stmt (def_stmt)
3344 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def_stmt))
3345 == vect_double_reduction_def)
3347 *adjustment_def = NULL;
3348 return vect_create_destination_var (init_val, vectype);
3351 if (TREE_CONSTANT (init_val))
3353 if (SCALAR_FLOAT_TYPE_P (scalar_type))
3354 init_value = build_real (scalar_type, TREE_REAL_CST (init_val));
3356 init_value = build_int_cst (scalar_type, TREE_INT_CST_LOW (init_val));
3359 init_value = init_val;
3363 case WIDEN_SUM_EXPR:
3371 /* ADJUSMENT_DEF is NULL when called from
3372 vect_create_epilog_for_reduction to vectorize double reduction. */
3375 if (nested_in_vect_loop)
3376 *adjustment_def = vect_get_vec_def_for_operand (init_val, stmt,
3379 *adjustment_def = init_val;
3382 if (code == MULT_EXPR)
3384 real_init_val = dconst1;
3388 if (code == BIT_AND_EXPR)
3391 if (SCALAR_FLOAT_TYPE_P (scalar_type))
3392 def_for_init = build_real (scalar_type, real_init_val);
3394 def_for_init = build_int_cst (scalar_type, int_init_val);
3396 /* Create a vector of '0' or '1' except the first element. */
3397 for (i = nunits - 2; i >= 0; --i)
3398 t = tree_cons (NULL_TREE, def_for_init, t);
3400 /* Option1: the first element is '0' or '1' as well. */
3403 t = tree_cons (NULL_TREE, def_for_init, t);
3404 init_def = build_vector (vectype, t);
3408 /* Option2: the first element is INIT_VAL. */
3409 t = tree_cons (NULL_TREE, init_value, t);
3410 if (TREE_CONSTANT (init_val))
3411 init_def = build_vector (vectype, t);
3413 init_def = build_constructor_from_list (vectype, t);
3422 *adjustment_def = NULL_TREE;
3423 init_def = vect_get_vec_def_for_operand (init_val, stmt, NULL);
3427 init_def = build_vector_from_val (vectype, init_value);
3438 /* Function vect_create_epilog_for_reduction
3440 Create code at the loop-epilog to finalize the result of a reduction
3443 VECT_DEFS is list of vector of partial results, i.e., the lhs's of vector
3444 reduction statements.
3445 STMT is the scalar reduction stmt that is being vectorized.
3446 NCOPIES is > 1 in case the vectorization factor (VF) is bigger than the
3447 number of elements that we can fit in a vectype (nunits). In this case
3448 we have to generate more than one vector stmt - i.e - we need to "unroll"
3449 the vector stmt by a factor VF/nunits. For more details see documentation
3450 in vectorizable_operation.
3451 REDUC_CODE is the tree-code for the epilog reduction.
3452 REDUCTION_PHIS is a list of the phi-nodes that carry the reduction
3454 REDUC_INDEX is the index of the operand in the right hand side of the
3455 statement that is defined by REDUCTION_PHI.
3456 DOUBLE_REDUC is TRUE if double reduction phi nodes should be handled.
3457 SLP_NODE is an SLP node containing a group of reduction statements. The
3458 first one in this group is STMT.
3461 1. Creates the reduction def-use cycles: sets the arguments for
3463 The loop-entry argument is the vectorized initial-value of the reduction.
3464 The loop-latch argument is taken from VECT_DEFS - the vector of partial
3466 2. "Reduces" each vector of partial results VECT_DEFS into a single result,
3467 by applying the operation specified by REDUC_CODE if available, or by
3468 other means (whole-vector shifts or a scalar loop).
3469 The function also creates a new phi node at the loop exit to preserve
3470 loop-closed form, as illustrated below.
3472 The flow at the entry to this function:
3475 vec_def = phi <null, null> # REDUCTION_PHI
3476 VECT_DEF = vector_stmt # vectorized form of STMT
3477 s_loop = scalar_stmt # (scalar) STMT
3479 s_out0 = phi <s_loop> # (scalar) EXIT_PHI
3483 The above is transformed by this function into:
3486 vec_def = phi <vec_init, VECT_DEF> # REDUCTION_PHI
3487 VECT_DEF = vector_stmt # vectorized form of STMT
3488 s_loop = scalar_stmt # (scalar) STMT
3490 s_out0 = phi <s_loop> # (scalar) EXIT_PHI
3491 v_out1 = phi <VECT_DEF> # NEW_EXIT_PHI
3492 v_out2 = reduce <v_out1>
3493 s_out3 = extract_field <v_out2, 0>
3494 s_out4 = adjust_result <s_out3>
3500 vect_create_epilog_for_reduction (VEC (tree, heap) *vect_defs, gimple stmt,
3501 int ncopies, enum tree_code reduc_code,
3502 VEC (gimple, heap) *reduction_phis,
3503 int reduc_index, bool double_reduc,
3506 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
3507 stmt_vec_info prev_phi_info;
3509 enum machine_mode mode;
3510 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
3511 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo), *outer_loop = NULL;
3512 basic_block exit_bb;
3515 gimple new_phi = NULL, phi;
3516 gimple_stmt_iterator exit_gsi;
3518 tree new_temp = NULL_TREE, new_dest, new_name, new_scalar_dest;
3519 gimple epilog_stmt = NULL;
3520 enum tree_code code = gimple_assign_rhs_code (stmt);
3522 tree bitsize, bitpos;
3523 tree adjustment_def = NULL;
3524 tree vec_initial_def = NULL;
3525 tree reduction_op, expr, def;
3526 tree orig_name, scalar_result;
3527 imm_use_iterator imm_iter, phi_imm_iter;
3528 use_operand_p use_p, phi_use_p;
3529 bool extract_scalar_result = false;
3530 gimple use_stmt, orig_stmt, reduction_phi = NULL;
3531 bool nested_in_vect_loop = false;
3532 VEC (gimple, heap) *new_phis = NULL;
3533 VEC (gimple, heap) *inner_phis = NULL;
3534 enum vect_def_type dt = vect_unknown_def_type;
3536 VEC (tree, heap) *scalar_results = NULL;
3537 unsigned int group_size = 1, k, ratio;
3538 VEC (tree, heap) *vec_initial_defs = NULL;
3539 VEC (gimple, heap) *phis;
3540 bool slp_reduc = false;
3541 tree new_phi_result;
3542 gimple inner_phi = NULL;
3545 group_size = VEC_length (gimple, SLP_TREE_SCALAR_STMTS (slp_node));
3547 if (nested_in_vect_loop_p (loop, stmt))
3551 nested_in_vect_loop = true;
3552 gcc_assert (!slp_node);
3555 switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
3557 case GIMPLE_SINGLE_RHS:
3558 gcc_assert (TREE_OPERAND_LENGTH (gimple_assign_rhs1 (stmt))
3560 reduction_op = TREE_OPERAND (gimple_assign_rhs1 (stmt), reduc_index);
3562 case GIMPLE_UNARY_RHS:
3563 reduction_op = gimple_assign_rhs1 (stmt);
3565 case GIMPLE_BINARY_RHS:
3566 reduction_op = reduc_index ?
3567 gimple_assign_rhs2 (stmt) : gimple_assign_rhs1 (stmt);
3569 case GIMPLE_TERNARY_RHS:
3570 reduction_op = gimple_op (stmt, reduc_index + 1);
3576 vectype = get_vectype_for_scalar_type (TREE_TYPE (reduction_op));
3577 gcc_assert (vectype);
3578 mode = TYPE_MODE (vectype);
3580 /* 1. Create the reduction def-use cycle:
3581 Set the arguments of REDUCTION_PHIS, i.e., transform
3584 vec_def = phi <null, null> # REDUCTION_PHI
3585 VECT_DEF = vector_stmt # vectorized form of STMT
3591 vec_def = phi <vec_init, VECT_DEF> # REDUCTION_PHI
3592 VECT_DEF = vector_stmt # vectorized form of STMT
3595 (in case of SLP, do it for all the phis). */
3597 /* Get the loop-entry arguments. */
3599 vect_get_vec_defs (reduction_op, NULL_TREE, stmt, &vec_initial_defs,
3600 NULL, slp_node, reduc_index);
3603 vec_initial_defs = VEC_alloc (tree, heap, 1);
3604 /* For the case of reduction, vect_get_vec_def_for_operand returns
3605 the scalar def before the loop, that defines the initial value
3606 of the reduction variable. */
3607 vec_initial_def = vect_get_vec_def_for_operand (reduction_op, stmt,
3609 VEC_quick_push (tree, vec_initial_defs, vec_initial_def);
3612 /* Set phi nodes arguments. */
3613 FOR_EACH_VEC_ELT (gimple, reduction_phis, i, phi)
3615 tree vec_init_def = VEC_index (tree, vec_initial_defs, i);
3616 tree def = VEC_index (tree, vect_defs, i);
3617 for (j = 0; j < ncopies; j++)
3619 /* Set the loop-entry arg of the reduction-phi. */
3620 add_phi_arg (phi, vec_init_def, loop_preheader_edge (loop),
3623 /* Set the loop-latch arg for the reduction-phi. */
3625 def = vect_get_vec_def_for_stmt_copy (vect_unknown_def_type, def);
3627 add_phi_arg (phi, def, loop_latch_edge (loop), UNKNOWN_LOCATION);
3629 if (vect_print_dump_info (REPORT_DETAILS))
3631 fprintf (vect_dump, "transform reduction: created def-use"
3633 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
3634 fprintf (vect_dump, "\n");
3635 print_gimple_stmt (vect_dump, SSA_NAME_DEF_STMT (def), 0,
3639 phi = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (phi));
3643 VEC_free (tree, heap, vec_initial_defs);
3645 /* 2. Create epilog code.
3646 The reduction epilog code operates across the elements of the vector
3647 of partial results computed by the vectorized loop.
3648 The reduction epilog code consists of:
3650 step 1: compute the scalar result in a vector (v_out2)
3651 step 2: extract the scalar result (s_out3) from the vector (v_out2)
3652 step 3: adjust the scalar result (s_out3) if needed.
3654 Step 1 can be accomplished using one the following three schemes:
3655 (scheme 1) using reduc_code, if available.
3656 (scheme 2) using whole-vector shifts, if available.
3657 (scheme 3) using a scalar loop. In this case steps 1+2 above are
3660 The overall epilog code looks like this:
3662 s_out0 = phi <s_loop> # original EXIT_PHI
3663 v_out1 = phi <VECT_DEF> # NEW_EXIT_PHI
3664 v_out2 = reduce <v_out1> # step 1
3665 s_out3 = extract_field <v_out2, 0> # step 2
3666 s_out4 = adjust_result <s_out3> # step 3
3668 (step 3 is optional, and steps 1 and 2 may be combined).
3669 Lastly, the uses of s_out0 are replaced by s_out4. */
3672 /* 2.1 Create new loop-exit-phis to preserve loop-closed form:
3673 v_out1 = phi <VECT_DEF>
3674 Store them in NEW_PHIS. */
3676 exit_bb = single_exit (loop)->dest;
3677 prev_phi_info = NULL;
3678 new_phis = VEC_alloc (gimple, heap, VEC_length (tree, vect_defs));
3679 FOR_EACH_VEC_ELT (tree, vect_defs, i, def)
3681 for (j = 0; j < ncopies; j++)
3683 phi = create_phi_node (SSA_NAME_VAR (def), exit_bb);
3684 set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, loop_vinfo, NULL));
3686 VEC_quick_push (gimple, new_phis, phi);
3689 def = vect_get_vec_def_for_stmt_copy (dt, def);
3690 STMT_VINFO_RELATED_STMT (prev_phi_info) = phi;
3693 SET_PHI_ARG_DEF (phi, single_exit (loop)->dest_idx, def);
3694 prev_phi_info = vinfo_for_stmt (phi);
3698 /* The epilogue is created for the outer-loop, i.e., for the loop being
3699 vectorized. Create exit phis for the outer loop. */
3703 exit_bb = single_exit (loop)->dest;
3704 inner_phis = VEC_alloc (gimple, heap, VEC_length (tree, vect_defs));
3705 FOR_EACH_VEC_ELT (gimple, new_phis, i, phi)
3707 gimple outer_phi = create_phi_node (SSA_NAME_VAR (PHI_RESULT (phi)),
3709 SET_PHI_ARG_DEF (outer_phi, single_exit (loop)->dest_idx,
3711 set_vinfo_for_stmt (outer_phi, new_stmt_vec_info (outer_phi,
3713 VEC_quick_push (gimple, inner_phis, phi);
3714 VEC_replace (gimple, new_phis, i, outer_phi);
3715 prev_phi_info = vinfo_for_stmt (outer_phi);
3716 while (STMT_VINFO_RELATED_STMT (vinfo_for_stmt (phi)))
3718 phi = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (phi));
3719 outer_phi = create_phi_node (SSA_NAME_VAR (PHI_RESULT (phi)),
3721 SET_PHI_ARG_DEF (outer_phi, single_exit (loop)->dest_idx,
3723 set_vinfo_for_stmt (outer_phi, new_stmt_vec_info (outer_phi,
3725 STMT_VINFO_RELATED_STMT (prev_phi_info) = outer_phi;
3726 prev_phi_info = vinfo_for_stmt (outer_phi);
3731 exit_gsi = gsi_after_labels (exit_bb);
3733 /* 2.2 Get the relevant tree-code to use in the epilog for schemes 2,3
3734 (i.e. when reduc_code is not available) and in the final adjustment
3735 code (if needed). Also get the original scalar reduction variable as
3736 defined in the loop. In case STMT is a "pattern-stmt" (i.e. - it
3737 represents a reduction pattern), the tree-code and scalar-def are
3738 taken from the original stmt that the pattern-stmt (STMT) replaces.
3739 Otherwise (it is a regular reduction) - the tree-code and scalar-def
3740 are taken from STMT. */
3742 orig_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
3745 /* Regular reduction */
3750 /* Reduction pattern */
3751 stmt_vec_info stmt_vinfo = vinfo_for_stmt (orig_stmt);
3752 gcc_assert (STMT_VINFO_IN_PATTERN_P (stmt_vinfo));
3753 gcc_assert (STMT_VINFO_RELATED_STMT (stmt_vinfo) == stmt);
3756 code = gimple_assign_rhs_code (orig_stmt);
3757 /* For MINUS_EXPR the initial vector is [init_val,0,...,0], therefore,
3758 partial results are added and not subtracted. */
3759 if (code == MINUS_EXPR)
3762 scalar_dest = gimple_assign_lhs (orig_stmt);
3763 scalar_type = TREE_TYPE (scalar_dest);
3764 scalar_results = VEC_alloc (tree, heap, group_size);
3765 new_scalar_dest = vect_create_destination_var (scalar_dest, NULL);
3766 bitsize = TYPE_SIZE (scalar_type);
3768 /* In case this is a reduction in an inner-loop while vectorizing an outer
3769 loop - we don't need to extract a single scalar result at the end of the
3770 inner-loop (unless it is double reduction, i.e., the use of reduction is
3771 outside the outer-loop). The final vector of partial results will be used
3772 in the vectorized outer-loop, or reduced to a scalar result at the end of
3774 if (nested_in_vect_loop && !double_reduc)
3775 goto vect_finalize_reduction;
3777 /* SLP reduction without reduction chain, e.g.,
3781 b2 = operation (b1) */
3782 slp_reduc = (slp_node && !GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)));
3784 /* In case of reduction chain, e.g.,
3787 a3 = operation (a2),
3789 we may end up with more than one vector result. Here we reduce them to
3791 if (GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)))
3793 tree first_vect = PHI_RESULT (VEC_index (gimple, new_phis, 0));
3795 gimple new_vec_stmt = NULL;
3797 vec_dest = vect_create_destination_var (scalar_dest, vectype);
3798 for (k = 1; k < VEC_length (gimple, new_phis); k++)
3800 gimple next_phi = VEC_index (gimple, new_phis, k);
3801 tree second_vect = PHI_RESULT (next_phi);
3803 tmp = build2 (code, vectype, first_vect, second_vect);
3804 new_vec_stmt = gimple_build_assign (vec_dest, tmp);
3805 first_vect = make_ssa_name (vec_dest, new_vec_stmt);
3806 gimple_assign_set_lhs (new_vec_stmt, first_vect);
3807 gsi_insert_before (&exit_gsi, new_vec_stmt, GSI_SAME_STMT);
3810 new_phi_result = first_vect;
3813 VEC_truncate (gimple, new_phis, 0);
3814 VEC_safe_push (gimple, heap, new_phis, new_vec_stmt);
3818 new_phi_result = PHI_RESULT (VEC_index (gimple, new_phis, 0));
3820 /* 2.3 Create the reduction code, using one of the three schemes described
3821 above. In SLP we simply need to extract all the elements from the
3822 vector (without reducing them), so we use scalar shifts. */
3823 if (reduc_code != ERROR_MARK && !slp_reduc)
3827 /*** Case 1: Create:
3828 v_out2 = reduc_expr <v_out1> */
3830 if (vect_print_dump_info (REPORT_DETAILS))
3831 fprintf (vect_dump, "Reduce using direct vector reduction.");
3833 vec_dest = vect_create_destination_var (scalar_dest, vectype);
3834 tmp = build1 (reduc_code, vectype, new_phi_result);
3835 epilog_stmt = gimple_build_assign (vec_dest, tmp);
3836 new_temp = make_ssa_name (vec_dest, epilog_stmt);
3837 gimple_assign_set_lhs (epilog_stmt, new_temp);
3838 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3840 extract_scalar_result = true;
3844 enum tree_code shift_code = ERROR_MARK;
3845 bool have_whole_vector_shift = true;
3847 int element_bitsize = tree_low_cst (bitsize, 1);
3848 int vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1);
3851 if (optab_handler (vec_shr_optab, mode) != CODE_FOR_nothing)
3852 shift_code = VEC_RSHIFT_EXPR;
3854 have_whole_vector_shift = false;
3856 /* Regardless of whether we have a whole vector shift, if we're
3857 emulating the operation via tree-vect-generic, we don't want
3858 to use it. Only the first round of the reduction is likely
3859 to still be profitable via emulation. */
3860 /* ??? It might be better to emit a reduction tree code here, so that
3861 tree-vect-generic can expand the first round via bit tricks. */
3862 if (!VECTOR_MODE_P (mode))
3863 have_whole_vector_shift = false;
3866 optab optab = optab_for_tree_code (code, vectype, optab_default);
3867 if (optab_handler (optab, mode) == CODE_FOR_nothing)
3868 have_whole_vector_shift = false;
3871 if (have_whole_vector_shift && !slp_reduc)
3873 /*** Case 2: Create:
3874 for (offset = VS/2; offset >= element_size; offset/=2)
3876 Create: va' = vec_shift <va, offset>
3877 Create: va = vop <va, va'>
3880 if (vect_print_dump_info (REPORT_DETAILS))
3881 fprintf (vect_dump, "Reduce using vector shifts");
3883 vec_dest = vect_create_destination_var (scalar_dest, vectype);
3884 new_temp = new_phi_result;
3885 for (bit_offset = vec_size_in_bits/2;
3886 bit_offset >= element_bitsize;
3889 tree bitpos = size_int (bit_offset);
3891 epilog_stmt = gimple_build_assign_with_ops (shift_code,
3892 vec_dest, new_temp, bitpos);
3893 new_name = make_ssa_name (vec_dest, epilog_stmt);
3894 gimple_assign_set_lhs (epilog_stmt, new_name);
3895 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3897 epilog_stmt = gimple_build_assign_with_ops (code, vec_dest,
3898 new_name, new_temp);
3899 new_temp = make_ssa_name (vec_dest, epilog_stmt);
3900 gimple_assign_set_lhs (epilog_stmt, new_temp);
3901 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3904 extract_scalar_result = true;
3910 /*** Case 3: Create:
3911 s = extract_field <v_out2, 0>
3912 for (offset = element_size;
3913 offset < vector_size;
3914 offset += element_size;)
3916 Create: s' = extract_field <v_out2, offset>
3917 Create: s = op <s, s'> // For non SLP cases
3920 if (vect_print_dump_info (REPORT_DETAILS))
3921 fprintf (vect_dump, "Reduce using scalar code. ");
3923 vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1);
3924 FOR_EACH_VEC_ELT (gimple, new_phis, i, new_phi)
3926 if (gimple_code (new_phi) == GIMPLE_PHI)
3927 vec_temp = PHI_RESULT (new_phi);
3929 vec_temp = gimple_assign_lhs (new_phi);
3930 rhs = build3 (BIT_FIELD_REF, scalar_type, vec_temp, bitsize,
3932 epilog_stmt = gimple_build_assign (new_scalar_dest, rhs);
3933 new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
3934 gimple_assign_set_lhs (epilog_stmt, new_temp);
3935 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3937 /* In SLP we don't need to apply reduction operation, so we just
3938 collect s' values in SCALAR_RESULTS. */
3940 VEC_safe_push (tree, heap, scalar_results, new_temp);
3942 for (bit_offset = element_bitsize;
3943 bit_offset < vec_size_in_bits;
3944 bit_offset += element_bitsize)
3946 tree bitpos = bitsize_int (bit_offset);
3947 tree rhs = build3 (BIT_FIELD_REF, scalar_type, vec_temp,
3950 epilog_stmt = gimple_build_assign (new_scalar_dest, rhs);
3951 new_name = make_ssa_name (new_scalar_dest, epilog_stmt);
3952 gimple_assign_set_lhs (epilog_stmt, new_name);
3953 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3957 /* In SLP we don't need to apply reduction operation, so
3958 we just collect s' values in SCALAR_RESULTS. */
3959 new_temp = new_name;
3960 VEC_safe_push (tree, heap, scalar_results, new_name);
3964 epilog_stmt = gimple_build_assign_with_ops (code,
3965 new_scalar_dest, new_name, new_temp);
3966 new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
3967 gimple_assign_set_lhs (epilog_stmt, new_temp);
3968 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
3973 /* The only case where we need to reduce scalar results in SLP, is
3974 unrolling. If the size of SCALAR_RESULTS is greater than
3975 GROUP_SIZE, we reduce them combining elements modulo
3979 tree res, first_res, new_res;
3982 /* Reduce multiple scalar results in case of SLP unrolling. */
3983 for (j = group_size; VEC_iterate (tree, scalar_results, j, res);
3986 first_res = VEC_index (tree, scalar_results, j % group_size);
3987 new_stmt = gimple_build_assign_with_ops (code,
3988 new_scalar_dest, first_res, res);
3989 new_res = make_ssa_name (new_scalar_dest, new_stmt);
3990 gimple_assign_set_lhs (new_stmt, new_res);
3991 gsi_insert_before (&exit_gsi, new_stmt, GSI_SAME_STMT);
3992 VEC_replace (tree, scalar_results, j % group_size, new_res);
3996 /* Not SLP - we have one scalar to keep in SCALAR_RESULTS. */
3997 VEC_safe_push (tree, heap, scalar_results, new_temp);
3999 extract_scalar_result = false;
4003 /* 2.4 Extract the final scalar result. Create:
4004 s_out3 = extract_field <v_out2, bitpos> */
4006 if (extract_scalar_result)
4010 if (vect_print_dump_info (REPORT_DETAILS))
4011 fprintf (vect_dump, "extract scalar result");
4013 if (BYTES_BIG_ENDIAN)
4014 bitpos = size_binop (MULT_EXPR,
4015 bitsize_int (TYPE_VECTOR_SUBPARTS (vectype) - 1),
4016 TYPE_SIZE (scalar_type));
4018 bitpos = bitsize_zero_node;
4020 rhs = build3 (BIT_FIELD_REF, scalar_type, new_temp, bitsize, bitpos);
4021 epilog_stmt = gimple_build_assign (new_scalar_dest, rhs);
4022 new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
4023 gimple_assign_set_lhs (epilog_stmt, new_temp);
4024 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
4025 VEC_safe_push (tree, heap, scalar_results, new_temp);
4028 vect_finalize_reduction:
4033 /* 2.5 Adjust the final result by the initial value of the reduction
4034 variable. (When such adjustment is not needed, then
4035 'adjustment_def' is zero). For example, if code is PLUS we create:
4036 new_temp = loop_exit_def + adjustment_def */
4040 gcc_assert (!slp_reduc);
4041 if (nested_in_vect_loop)
4043 new_phi = VEC_index (gimple, new_phis, 0);
4044 gcc_assert (TREE_CODE (TREE_TYPE (adjustment_def)) == VECTOR_TYPE);
4045 expr = build2 (code, vectype, PHI_RESULT (new_phi), adjustment_def);
4046 new_dest = vect_create_destination_var (scalar_dest, vectype);
4050 new_temp = VEC_index (tree, scalar_results, 0);
4051 gcc_assert (TREE_CODE (TREE_TYPE (adjustment_def)) != VECTOR_TYPE);
4052 expr = build2 (code, scalar_type, new_temp, adjustment_def);
4053 new_dest = vect_create_destination_var (scalar_dest, scalar_type);
4056 epilog_stmt = gimple_build_assign (new_dest, expr);
4057 new_temp = make_ssa_name (new_dest, epilog_stmt);
4058 gimple_assign_set_lhs (epilog_stmt, new_temp);
4059 SSA_NAME_DEF_STMT (new_temp) = epilog_stmt;
4060 gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
4061 if (nested_in_vect_loop)
4063 set_vinfo_for_stmt (epilog_stmt,
4064 new_stmt_vec_info (epilog_stmt, loop_vinfo,
4066 STMT_VINFO_RELATED_STMT (vinfo_for_stmt (epilog_stmt)) =
4067 STMT_VINFO_RELATED_STMT (vinfo_for_stmt (new_phi));
4070 VEC_quick_push (tree, scalar_results, new_temp);
4072 VEC_replace (tree, scalar_results, 0, new_temp);
4075 VEC_replace (tree, scalar_results, 0, new_temp);
4077 VEC_replace (gimple, new_phis, 0, epilog_stmt);
4080 /* 2.6 Handle the loop-exit phis. Replace the uses of scalar loop-exit
4081 phis with new adjusted scalar results, i.e., replace use <s_out0>
4086 s_out0 = phi <s_loop> # (scalar) EXIT_PHI
4087 v_out1 = phi <VECT_DEF> # NEW_EXIT_PHI
4088 v_out2 = reduce <v_out1>
4089 s_out3 = extract_field <v_out2, 0>
4090 s_out4 = adjust_result <s_out3>
4097 s_out0 = phi <s_loop> # (scalar) EXIT_PHI
4098 v_out1 = phi <VECT_DEF> # NEW_EXIT_PHI
4099 v_out2 = reduce <v_out1>
4100 s_out3 = extract_field <v_out2, 0>
4101 s_out4 = adjust_result <s_out3>
4106 /* In SLP reduction chain we reduce vector results into one vector if
4107 necessary, hence we set here GROUP_SIZE to 1. SCALAR_DEST is the LHS of
4108 the last stmt in the reduction chain, since we are looking for the loop
4110 if (GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)))
4112 scalar_dest = gimple_assign_lhs (VEC_index (gimple,
4113 SLP_TREE_SCALAR_STMTS (slp_node),
4118 /* In SLP we may have several statements in NEW_PHIS and REDUCTION_PHIS (in
4119 case that GROUP_SIZE is greater than vectorization factor). Therefore, we
4120 need to match SCALAR_RESULTS with corresponding statements. The first
4121 (GROUP_SIZE / number of new vector stmts) scalar results correspond to
4122 the first vector stmt, etc.
4123 (RATIO is equal to (GROUP_SIZE / number of new vector stmts)). */
4124 if (group_size > VEC_length (gimple, new_phis))
4126 ratio = group_size / VEC_length (gimple, new_phis);
4127 gcc_assert (!(group_size % VEC_length (gimple, new_phis)));
4132 for (k = 0; k < group_size; k++)
4136 epilog_stmt = VEC_index (gimple, new_phis, k / ratio);
4137 reduction_phi = VEC_index (gimple, reduction_phis, k / ratio);
4139 inner_phi = VEC_index (gimple, inner_phis, k / ratio);
4144 gimple current_stmt = VEC_index (gimple,
4145 SLP_TREE_SCALAR_STMTS (slp_node), k);
4147 orig_stmt = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (current_stmt));
4148 /* SLP statements can't participate in patterns. */
4149 gcc_assert (!orig_stmt);
4150 scalar_dest = gimple_assign_lhs (current_stmt);
4153 phis = VEC_alloc (gimple, heap, 3);
4154 /* Find the loop-closed-use at the loop exit of the original scalar
4155 result. (The reduction result is expected to have two immediate uses -
4156 one at the latch block, and one at the loop exit). */
4157 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, scalar_dest)
4158 if (!flow_bb_inside_loop_p (loop, gimple_bb (USE_STMT (use_p))))
4159 VEC_safe_push (gimple, heap, phis, USE_STMT (use_p));
4161 /* We expect to have found an exit_phi because of loop-closed-ssa
4163 gcc_assert (!VEC_empty (gimple, phis));
4165 FOR_EACH_VEC_ELT (gimple, phis, i, exit_phi)
4169 stmt_vec_info exit_phi_vinfo = vinfo_for_stmt (exit_phi);
4172 /* FORNOW. Currently not supporting the case that an inner-loop
4173 reduction is not used in the outer-loop (but only outside the
4174 outer-loop), unless it is double reduction. */
4175 gcc_assert ((STMT_VINFO_RELEVANT_P (exit_phi_vinfo)
4176 && !STMT_VINFO_LIVE_P (exit_phi_vinfo))
4179 STMT_VINFO_VEC_STMT (exit_phi_vinfo) = epilog_stmt;
4181 || STMT_VINFO_DEF_TYPE (exit_phi_vinfo)
4182 != vect_double_reduction_def)
4185 /* Handle double reduction:
4187 stmt1: s1 = phi <s0, s2> - double reduction phi (outer loop)
4188 stmt2: s3 = phi <s1, s4> - (regular) reduc phi (inner loop)
4189 stmt3: s4 = use (s3) - (regular) reduc stmt (inner loop)
4190 stmt4: s2 = phi <s4> - double reduction stmt (outer loop)
4192 At that point the regular reduction (stmt2 and stmt3) is
4193 already vectorized, as well as the exit phi node, stmt4.
4194 Here we vectorize the phi node of double reduction, stmt1, and
4195 update all relevant statements. */
4197 /* Go through all the uses of s2 to find double reduction phi
4198 node, i.e., stmt1 above. */
4199 orig_name = PHI_RESULT (exit_phi);
4200 FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, orig_name)
4202 stmt_vec_info use_stmt_vinfo = vinfo_for_stmt (use_stmt);
4203 stmt_vec_info new_phi_vinfo;
4204 tree vect_phi_init, preheader_arg, vect_phi_res, init_def;
4205 basic_block bb = gimple_bb (use_stmt);
4208 /* Check that USE_STMT is really double reduction phi
4210 if (gimple_code (use_stmt) != GIMPLE_PHI
4211 || gimple_phi_num_args (use_stmt) != 2
4213 || STMT_VINFO_DEF_TYPE (use_stmt_vinfo)
4214 != vect_double_reduction_def
4215 || bb->loop_father != outer_loop)
4218 /* Create vector phi node for double reduction:
4219 vs1 = phi <vs0, vs2>
4220 vs1 was created previously in this function by a call to
4221 vect_get_vec_def_for_operand and is stored in
4223 vs2 is defined by INNER_PHI, the vectorized EXIT_PHI;
4224 vs0 is created here. */
4226 /* Create vector phi node. */
4227 vect_phi = create_phi_node (vec_initial_def, bb);
4228 new_phi_vinfo = new_stmt_vec_info (vect_phi,
4229 loop_vec_info_for_loop (outer_loop), NULL);
4230 set_vinfo_for_stmt (vect_phi, new_phi_vinfo);
4232 /* Create vs0 - initial def of the double reduction phi. */
4233 preheader_arg = PHI_ARG_DEF_FROM_EDGE (use_stmt,
4234 loop_preheader_edge (outer_loop));
4235 init_def = get_initial_def_for_reduction (stmt,
4236 preheader_arg, NULL);
4237 vect_phi_init = vect_init_vector (use_stmt, init_def,
4240 /* Update phi node arguments with vs0 and vs2. */
4241 add_phi_arg (vect_phi, vect_phi_init,
4242 loop_preheader_edge (outer_loop),
4244 add_phi_arg (vect_phi, PHI_RESULT (inner_phi),
4245 loop_latch_edge (outer_loop), UNKNOWN_LOCATION);
4246 if (vect_print_dump_info (REPORT_DETAILS))
4248 fprintf (vect_dump, "created double reduction phi "
4250 print_gimple_stmt (vect_dump, vect_phi, 0, TDF_SLIM);
4253 vect_phi_res = PHI_RESULT (vect_phi);
4255 /* Replace the use, i.e., set the correct vs1 in the regular
4256 reduction phi node. FORNOW, NCOPIES is always 1, so the
4257 loop is redundant. */
4258 use = reduction_phi;
4259 for (j = 0; j < ncopies; j++)
4261 edge pr_edge = loop_preheader_edge (loop);
4262 SET_PHI_ARG_DEF (use, pr_edge->dest_idx, vect_phi_res);
4263 use = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (use));
4269 VEC_free (gimple, heap, phis);
4270 if (nested_in_vect_loop)
4278 phis = VEC_alloc (gimple, heap, 3);
4279 /* Find the loop-closed-use at the loop exit of the original scalar
4280 result. (The reduction result is expected to have two immediate uses,
4281 one at the latch block, and one at the loop exit). For double
4282 reductions we are looking for exit phis of the outer loop. */
4283 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, scalar_dest)
4285 if (!flow_bb_inside_loop_p (loop, gimple_bb (USE_STMT (use_p))))
4286 VEC_safe_push (gimple, heap, phis, USE_STMT (use_p));
4289 if (double_reduc && gimple_code (USE_STMT (use_p)) == GIMPLE_PHI)
4291 tree phi_res = PHI_RESULT (USE_STMT (use_p));
4293 FOR_EACH_IMM_USE_FAST (phi_use_p, phi_imm_iter, phi_res)
4295 if (!flow_bb_inside_loop_p (loop,
4296 gimple_bb (USE_STMT (phi_use_p))))
4297 VEC_safe_push (gimple, heap, phis,
4298 USE_STMT (phi_use_p));
4304 FOR_EACH_VEC_ELT (gimple, phis, i, exit_phi)
4306 /* Replace the uses: */
4307 orig_name = PHI_RESULT (exit_phi);
4308 scalar_result = VEC_index (tree, scalar_results, k);
4309 FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, orig_name)
4310 FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
4311 SET_USE (use_p, scalar_result);
4314 VEC_free (gimple, heap, phis);
4317 VEC_free (tree, heap, scalar_results);
4318 VEC_free (gimple, heap, new_phis);
4322 /* Function vectorizable_reduction.
4324 Check if STMT performs a reduction operation that can be vectorized.
4325 If VEC_STMT is also passed, vectorize the STMT: create a vectorized
4326 stmt to replace it, put it in VEC_STMT, and insert it at GSI.
4327 Return FALSE if not a vectorizable STMT, TRUE otherwise.
4329 This function also handles reduction idioms (patterns) that have been
4330 recognized in advance during vect_pattern_recog. In this case, STMT may be
4332 X = pattern_expr (arg0, arg1, ..., X)
4333 and it's STMT_VINFO_RELATED_STMT points to the last stmt in the original
4334 sequence that had been detected and replaced by the pattern-stmt (STMT).
4336 In some cases of reduction patterns, the type of the reduction variable X is
4337 different than the type of the other arguments of STMT.
4338 In such cases, the vectype that is used when transforming STMT into a vector
4339 stmt is different than the vectype that is used to determine the
4340 vectorization factor, because it consists of a different number of elements
4341 than the actual number of elements that are being operated upon in parallel.
4343 For example, consider an accumulation of shorts into an int accumulator.
4344 On some targets it's possible to vectorize this pattern operating on 8
4345 shorts at a time (hence, the vectype for purposes of determining the
4346 vectorization factor should be V8HI); on the other hand, the vectype that
4347 is used to create the vector form is actually V4SI (the type of the result).
4349 Upon entry to this function, STMT_VINFO_VECTYPE records the vectype that
4350 indicates what is the actual level of parallelism (V8HI in the example), so
4351 that the right vectorization factor would be derived. This vectype
4352 corresponds to the type of arguments to the reduction stmt, and should *NOT*
4353 be used to create the vectorized stmt. The right vectype for the vectorized
4354 stmt is obtained from the type of the result X:
4355 get_vectype_for_scalar_type (TREE_TYPE (X))
4357 This means that, contrary to "regular" reductions (or "regular" stmts in
4358 general), the following equation:
4359 STMT_VINFO_VECTYPE == get_vectype_for_scalar_type (TREE_TYPE (X))
4360 does *NOT* necessarily hold for reduction patterns. */
4363 vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
4364 gimple *vec_stmt, slp_tree slp_node)
4368 tree loop_vec_def0 = NULL_TREE, loop_vec_def1 = NULL_TREE;
4369 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
4370 tree vectype_out = STMT_VINFO_VECTYPE (stmt_info);
4371 tree vectype_in = NULL_TREE;
4372 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
4373 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
4374 enum tree_code code, orig_code, epilog_reduc_code;
4375 enum machine_mode vec_mode;
4377 optab optab, reduc_optab;
4378 tree new_temp = NULL_TREE;
4381 enum vect_def_type dt;
4382 gimple new_phi = NULL;
4386 stmt_vec_info orig_stmt_info;
4387 tree expr = NULL_TREE;
4391 stmt_vec_info prev_stmt_info, prev_phi_info;
4392 bool single_defuse_cycle = false;
4393 tree reduc_def = NULL_TREE;
4394 gimple new_stmt = NULL;
4397 bool nested_cycle = false, found_nested_cycle_def = false;
4398 gimple reduc_def_stmt = NULL;
4399 /* The default is that the reduction variable is the last in statement. */
4400 int reduc_index = 2;
4401 bool double_reduc = false, dummy;
4403 struct loop * def_stmt_loop, *outer_loop = NULL;
4405 gimple def_arg_stmt;
4406 VEC (tree, heap) *vec_oprnds0 = NULL, *vec_oprnds1 = NULL, *vect_defs = NULL;
4407 VEC (gimple, heap) *phis = NULL;
4409 tree def0, def1, tem, op0, op1 = NULL_TREE;
4411 /* In case of reduction chain we switch to the first stmt in the chain, but
4412 we don't update STMT_INFO, since only the last stmt is marked as reduction
4413 and has reduction properties. */
4414 if (GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)))
4415 stmt = GROUP_FIRST_ELEMENT (stmt_info);
4417 if (nested_in_vect_loop_p (loop, stmt))
4421 nested_cycle = true;
4424 /* 1. Is vectorizable reduction? */
4425 /* Not supportable if the reduction variable is used in the loop, unless
4426 it's a reduction chain. */
4427 if (STMT_VINFO_RELEVANT (stmt_info) > vect_used_in_outer
4428 && !GROUP_FIRST_ELEMENT (stmt_info))
4431 /* Reductions that are not used even in an enclosing outer-loop,
4432 are expected to be "live" (used out of the loop). */
4433 if (STMT_VINFO_RELEVANT (stmt_info) == vect_unused_in_scope
4434 && !STMT_VINFO_LIVE_P (stmt_info))
4437 /* Make sure it was already recognized as a reduction computation. */
4438 if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_reduction_def
4439 && STMT_VINFO_DEF_TYPE (stmt_info) != vect_nested_cycle)
4442 /* 2. Has this been recognized as a reduction pattern?
4444 Check if STMT represents a pattern that has been recognized
4445 in earlier analysis stages. For stmts that represent a pattern,
4446 the STMT_VINFO_RELATED_STMT field records the last stmt in
4447 the original sequence that constitutes the pattern. */
4449 orig_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
4452 orig_stmt_info = vinfo_for_stmt (orig_stmt);
4453 gcc_assert (STMT_VINFO_RELATED_STMT (orig_stmt_info) == stmt);
4454 gcc_assert (STMT_VINFO_IN_PATTERN_P (orig_stmt_info));
4455 gcc_assert (!STMT_VINFO_IN_PATTERN_P (stmt_info));
4458 /* 3. Check the operands of the operation. The first operands are defined
4459 inside the loop body. The last operand is the reduction variable,
4460 which is defined by the loop-header-phi. */
4462 gcc_assert (is_gimple_assign (stmt));
4465 switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
4467 case GIMPLE_SINGLE_RHS:
4468 op_type = TREE_OPERAND_LENGTH (gimple_assign_rhs1 (stmt));
4469 if (op_type == ternary_op)
4471 tree rhs = gimple_assign_rhs1 (stmt);
4472 ops[0] = TREE_OPERAND (rhs, 0);
4473 ops[1] = TREE_OPERAND (rhs, 1);
4474 ops[2] = TREE_OPERAND (rhs, 2);
4475 code = TREE_CODE (rhs);
4481 case GIMPLE_BINARY_RHS:
4482 code = gimple_assign_rhs_code (stmt);
4483 op_type = TREE_CODE_LENGTH (code);
4484 gcc_assert (op_type == binary_op);
4485 ops[0] = gimple_assign_rhs1 (stmt);
4486 ops[1] = gimple_assign_rhs2 (stmt);
4489 case GIMPLE_TERNARY_RHS:
4490 code = gimple_assign_rhs_code (stmt);
4491 op_type = TREE_CODE_LENGTH (code);
4492 gcc_assert (op_type == ternary_op);
4493 ops[0] = gimple_assign_rhs1 (stmt);
4494 ops[1] = gimple_assign_rhs2 (stmt);
4495 ops[2] = gimple_assign_rhs3 (stmt);
4498 case GIMPLE_UNARY_RHS:
4505 if (code == COND_EXPR && slp_node)
4508 scalar_dest = gimple_assign_lhs (stmt);
4509 scalar_type = TREE_TYPE (scalar_dest);
4510 if (!POINTER_TYPE_P (scalar_type) && !INTEGRAL_TYPE_P (scalar_type)
4511 && !SCALAR_FLOAT_TYPE_P (scalar_type))
4514 /* Do not try to vectorize bit-precision reductions. */
4515 if ((TYPE_PRECISION (scalar_type)
4516 != GET_MODE_PRECISION (TYPE_MODE (scalar_type))))
4519 /* All uses but the last are expected to be defined in the loop.
4520 The last use is the reduction variable. In case of nested cycle this
4521 assumption is not true: we use reduc_index to record the index of the
4522 reduction variable. */
4523 for (i = 0; i < op_type-1; i++)
4525 /* The condition of COND_EXPR is checked in vectorizable_condition(). */
4526 if (i == 0 && code == COND_EXPR)
4529 is_simple_use = vect_is_simple_use_1 (ops[i], stmt, loop_vinfo, NULL,
4530 &def_stmt, &def, &dt, &tem);
4533 gcc_assert (is_simple_use);
4535 if (dt != vect_internal_def
4536 && dt != vect_external_def
4537 && dt != vect_constant_def
4538 && dt != vect_induction_def
4539 && !(dt == vect_nested_cycle && nested_cycle))
4542 if (dt == vect_nested_cycle)
4544 found_nested_cycle_def = true;
4545 reduc_def_stmt = def_stmt;
4550 is_simple_use = vect_is_simple_use_1 (ops[i], stmt, loop_vinfo, NULL,
4551 &def_stmt, &def, &dt, &tem);
4554 gcc_assert (is_simple_use);
4555 gcc_assert (dt == vect_reduction_def
4556 || dt == vect_nested_cycle
4557 || ((dt == vect_internal_def || dt == vect_external_def
4558 || dt == vect_constant_def || dt == vect_induction_def)
4559 && nested_cycle && found_nested_cycle_def));
4560 if (!found_nested_cycle_def)
4561 reduc_def_stmt = def_stmt;
4563 gcc_assert (gimple_code (reduc_def_stmt) == GIMPLE_PHI);
4565 gcc_assert (orig_stmt == vect_is_simple_reduction (loop_vinfo,
4571 gimple tmp = vect_is_simple_reduction (loop_vinfo, reduc_def_stmt,
4572 !nested_cycle, &dummy);
4573 /* We changed STMT to be the first stmt in reduction chain, hence we
4574 check that in this case the first element in the chain is STMT. */
4575 gcc_assert (stmt == tmp
4576 || GROUP_FIRST_ELEMENT (vinfo_for_stmt (tmp)) == stmt);
4579 if (STMT_VINFO_LIVE_P (vinfo_for_stmt (reduc_def_stmt)))
4582 if (slp_node || PURE_SLP_STMT (stmt_info))
4585 ncopies = (LOOP_VINFO_VECT_FACTOR (loop_vinfo)
4586 / TYPE_VECTOR_SUBPARTS (vectype_in));
4588 gcc_assert (ncopies >= 1);
4590 vec_mode = TYPE_MODE (vectype_in);
4592 if (code == COND_EXPR)
4594 if (!vectorizable_condition (stmt, gsi, NULL, ops[reduc_index], 0, NULL))
4596 if (vect_print_dump_info (REPORT_DETAILS))
4597 fprintf (vect_dump, "unsupported condition in reduction");
4604 /* 4. Supportable by target? */
4606 /* 4.1. check support for the operation in the loop */
4607 optab = optab_for_tree_code (code, vectype_in, optab_default);
4610 if (vect_print_dump_info (REPORT_DETAILS))
4611 fprintf (vect_dump, "no optab.");
4616 if (optab_handler (optab, vec_mode) == CODE_FOR_nothing)
4618 if (vect_print_dump_info (REPORT_DETAILS))
4619 fprintf (vect_dump, "op not supported by target.");
4621 if (GET_MODE_SIZE (vec_mode) != UNITS_PER_WORD
4622 || LOOP_VINFO_VECT_FACTOR (loop_vinfo)
4623 < vect_min_worthwhile_factor (code))
4626 if (vect_print_dump_info (REPORT_DETAILS))
4627 fprintf (vect_dump, "proceeding using word mode.");
4630 /* Worthwhile without SIMD support? */
4631 if (!VECTOR_MODE_P (TYPE_MODE (vectype_in))
4632 && LOOP_VINFO_VECT_FACTOR (loop_vinfo)
4633 < vect_min_worthwhile_factor (code))
4635 if (vect_print_dump_info (REPORT_DETAILS))
4636 fprintf (vect_dump, "not worthwhile without SIMD support.");
4642 /* 4.2. Check support for the epilog operation.
4644 If STMT represents a reduction pattern, then the type of the
4645 reduction variable may be different than the type of the rest
4646 of the arguments. For example, consider the case of accumulation
4647 of shorts into an int accumulator; The original code:
4648 S1: int_a = (int) short_a;
4649 orig_stmt-> S2: int_acc = plus <int_a ,int_acc>;
4652 STMT: int_acc = widen_sum <short_a, int_acc>
4655 1. The tree-code that is used to create the vector operation in the
4656 epilog code (that reduces the partial results) is not the
4657 tree-code of STMT, but is rather the tree-code of the original
4658 stmt from the pattern that STMT is replacing. I.e, in the example
4659 above we want to use 'widen_sum' in the loop, but 'plus' in the
4661 2. The type (mode) we use to check available target support
4662 for the vector operation to be created in the *epilog*, is
4663 determined by the type of the reduction variable (in the example
4664 above we'd check this: optab_handler (plus_optab, vect_int_mode])).
4665 However the type (mode) we use to check available target support
4666 for the vector operation to be created *inside the loop*, is
4667 determined by the type of the other arguments to STMT (in the
4668 example we'd check this: optab_handler (widen_sum_optab,
4671 This is contrary to "regular" reductions, in which the types of all
4672 the arguments are the same as the type of the reduction variable.
4673 For "regular" reductions we can therefore use the same vector type
4674 (and also the same tree-code) when generating the epilog code and
4675 when generating the code inside the loop. */
4679 /* This is a reduction pattern: get the vectype from the type of the
4680 reduction variable, and get the tree-code from orig_stmt. */
4681 orig_code = gimple_assign_rhs_code (orig_stmt);
4682 gcc_assert (vectype_out);
4683 vec_mode = TYPE_MODE (vectype_out);
4687 /* Regular reduction: use the same vectype and tree-code as used for
4688 the vector code inside the loop can be used for the epilog code. */
4694 def_bb = gimple_bb (reduc_def_stmt);
4695 def_stmt_loop = def_bb->loop_father;
4696 def_arg = PHI_ARG_DEF_FROM_EDGE (reduc_def_stmt,
4697 loop_preheader_edge (def_stmt_loop));
4698 if (TREE_CODE (def_arg) == SSA_NAME
4699 && (def_arg_stmt = SSA_NAME_DEF_STMT (def_arg))
4700 && gimple_code (def_arg_stmt) == GIMPLE_PHI
4701 && flow_bb_inside_loop_p (outer_loop, gimple_bb (def_arg_stmt))
4702 && vinfo_for_stmt (def_arg_stmt)
4703 && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def_arg_stmt))
4704 == vect_double_reduction_def)
4705 double_reduc = true;
4708 epilog_reduc_code = ERROR_MARK;
4709 if (reduction_code_for_scalar_code (orig_code, &epilog_reduc_code))
4711 reduc_optab = optab_for_tree_code (epilog_reduc_code, vectype_out,
4715 if (vect_print_dump_info (REPORT_DETAILS))
4716 fprintf (vect_dump, "no optab for reduction.");
4718 epilog_reduc_code = ERROR_MARK;
4722 && optab_handler (reduc_optab, vec_mode) == CODE_FOR_nothing)
4724 if (vect_print_dump_info (REPORT_DETAILS))
4725 fprintf (vect_dump, "reduc op not supported by target.");
4727 epilog_reduc_code = ERROR_MARK;
4732 if (!nested_cycle || double_reduc)
4734 if (vect_print_dump_info (REPORT_DETAILS))
4735 fprintf (vect_dump, "no reduc code for scalar code.");
4741 if (double_reduc && ncopies > 1)
4743 if (vect_print_dump_info (REPORT_DETAILS))
4744 fprintf (vect_dump, "multiple types in double reduction");
4749 /* In case of widenning multiplication by a constant, we update the type
4750 of the constant to be the type of the other operand. We check that the
4751 constant fits the type in the pattern recognition pass. */
4752 if (code == DOT_PROD_EXPR
4753 && !types_compatible_p (TREE_TYPE (ops[0]), TREE_TYPE (ops[1])))
4755 if (TREE_CODE (ops[0]) == INTEGER_CST)
4756 ops[0] = fold_convert (TREE_TYPE (ops[1]), ops[0]);
4757 else if (TREE_CODE (ops[1]) == INTEGER_CST)
4758 ops[1] = fold_convert (TREE_TYPE (ops[0]), ops[1]);
4761 if (vect_print_dump_info (REPORT_DETAILS))
4762 fprintf (vect_dump, "invalid types in dot-prod");
4768 if (!vec_stmt) /* transformation not required. */
4770 if (!vect_model_reduction_cost (stmt_info, epilog_reduc_code, ncopies))
4772 STMT_VINFO_TYPE (stmt_info) = reduc_vec_info_type;
4778 if (vect_print_dump_info (REPORT_DETAILS))
4779 fprintf (vect_dump, "transform reduction.");
4781 /* FORNOW: Multiple types are not supported for condition. */
4782 if (code == COND_EXPR)
4783 gcc_assert (ncopies == 1);
4785 /* Create the destination vector */
4786 vec_dest = vect_create_destination_var (scalar_dest, vectype_out);
4788 /* In case the vectorization factor (VF) is bigger than the number
4789 of elements that we can fit in a vectype (nunits), we have to generate
4790 more than one vector stmt - i.e - we need to "unroll" the
4791 vector stmt by a factor VF/nunits. For more details see documentation
4792 in vectorizable_operation. */
4794 /* If the reduction is used in an outer loop we need to generate
4795 VF intermediate results, like so (e.g. for ncopies=2):
4800 (i.e. we generate VF results in 2 registers).
4801 In this case we have a separate def-use cycle for each copy, and therefore
4802 for each copy we get the vector def for the reduction variable from the
4803 respective phi node created for this copy.
4805 Otherwise (the reduction is unused in the loop nest), we can combine
4806 together intermediate results, like so (e.g. for ncopies=2):
4810 (i.e. we generate VF/2 results in a single register).
4811 In this case for each copy we get the vector def for the reduction variable
4812 from the vectorized reduction operation generated in the previous iteration.
4815 if (STMT_VINFO_RELEVANT (stmt_info) == vect_unused_in_scope)
4817 single_defuse_cycle = true;
4821 epilog_copies = ncopies;
4823 prev_stmt_info = NULL;
4824 prev_phi_info = NULL;
4827 vec_num = SLP_TREE_NUMBER_OF_VEC_STMTS (slp_node);
4828 gcc_assert (TYPE_VECTOR_SUBPARTS (vectype_out)
4829 == TYPE_VECTOR_SUBPARTS (vectype_in));
4834 vec_oprnds0 = VEC_alloc (tree, heap, 1);
4835 if (op_type == ternary_op)
4836 vec_oprnds1 = VEC_alloc (tree, heap, 1);
4839 phis = VEC_alloc (gimple, heap, vec_num);
4840 vect_defs = VEC_alloc (tree, heap, vec_num);
4842 VEC_quick_push (tree, vect_defs, NULL_TREE);
4844 for (j = 0; j < ncopies; j++)
4846 if (j == 0 || !single_defuse_cycle)
4848 for (i = 0; i < vec_num; i++)
4850 /* Create the reduction-phi that defines the reduction
4852 new_phi = create_phi_node (vec_dest, loop->header);
4853 set_vinfo_for_stmt (new_phi,
4854 new_stmt_vec_info (new_phi, loop_vinfo,
4856 if (j == 0 || slp_node)
4857 VEC_quick_push (gimple, phis, new_phi);
4861 if (code == COND_EXPR)
4863 gcc_assert (!slp_node);
4864 vectorizable_condition (stmt, gsi, vec_stmt,
4865 PHI_RESULT (VEC_index (gimple, phis, 0)),
4867 /* Multiple types are not supported for condition. */
4874 op0 = ops[!reduc_index];
4875 if (op_type == ternary_op)
4877 if (reduc_index == 0)
4884 vect_get_vec_defs (op0, op1, stmt, &vec_oprnds0, &vec_oprnds1,
4888 loop_vec_def0 = vect_get_vec_def_for_operand (ops[!reduc_index],
4890 VEC_quick_push (tree, vec_oprnds0, loop_vec_def0);
4891 if (op_type == ternary_op)
4893 loop_vec_def1 = vect_get_vec_def_for_operand (op1, stmt,
4895 VEC_quick_push (tree, vec_oprnds1, loop_vec_def1);
4903 enum vect_def_type dt;
4907 vect_is_simple_use (ops[!reduc_index], stmt, loop_vinfo, NULL,
4908 &dummy_stmt, &dummy, &dt);
4909 loop_vec_def0 = vect_get_vec_def_for_stmt_copy (dt,
4911 VEC_replace (tree, vec_oprnds0, 0, loop_vec_def0);
4912 if (op_type == ternary_op)
4914 vect_is_simple_use (op1, stmt, loop_vinfo, NULL, &dummy_stmt,
4916 loop_vec_def1 = vect_get_vec_def_for_stmt_copy (dt,
4918 VEC_replace (tree, vec_oprnds1, 0, loop_vec_def1);
4922 if (single_defuse_cycle)
4923 reduc_def = gimple_assign_lhs (new_stmt);
4925 STMT_VINFO_RELATED_STMT (prev_phi_info) = new_phi;
4928 FOR_EACH_VEC_ELT (tree, vec_oprnds0, i, def0)
4931 reduc_def = PHI_RESULT (VEC_index (gimple, phis, i));
4934 if (!single_defuse_cycle || j == 0)
4935 reduc_def = PHI_RESULT (new_phi);
4938 def1 = ((op_type == ternary_op)
4939 ? VEC_index (tree, vec_oprnds1, i) : NULL);
4940 if (op_type == binary_op)
4942 if (reduc_index == 0)
4943 expr = build2 (code, vectype_out, reduc_def, def0);
4945 expr = build2 (code, vectype_out, def0, reduc_def);
4949 if (reduc_index == 0)
4950 expr = build3 (code, vectype_out, reduc_def, def0, def1);
4953 if (reduc_index == 1)
4954 expr = build3 (code, vectype_out, def0, reduc_def, def1);
4956 expr = build3 (code, vectype_out, def0, def1, reduc_def);
4960 new_stmt = gimple_build_assign (vec_dest, expr);
4961 new_temp = make_ssa_name (vec_dest, new_stmt);
4962 gimple_assign_set_lhs (new_stmt, new_temp);
4963 vect_finish_stmt_generation (stmt, new_stmt, gsi);
4967 VEC_quick_push (gimple, SLP_TREE_VEC_STMTS (slp_node), new_stmt);
4968 VEC_quick_push (tree, vect_defs, new_temp);
4971 VEC_replace (tree, vect_defs, 0, new_temp);
4978 STMT_VINFO_VEC_STMT (stmt_info) = *vec_stmt = new_stmt;
4980 STMT_VINFO_RELATED_STMT (prev_stmt_info) = new_stmt;
4982 prev_stmt_info = vinfo_for_stmt (new_stmt);
4983 prev_phi_info = vinfo_for_stmt (new_phi);
4986 /* Finalize the reduction-phi (set its arguments) and create the
4987 epilog reduction code. */
4988 if ((!single_defuse_cycle || code == COND_EXPR) && !slp_node)
4990 new_temp = gimple_assign_lhs (*vec_stmt);
4991 VEC_replace (tree, vect_defs, 0, new_temp);
4994 vect_create_epilog_for_reduction (vect_defs, stmt, epilog_copies,
4995 epilog_reduc_code, phis, reduc_index,
4996 double_reduc, slp_node);
4998 VEC_free (gimple, heap, phis);
4999 VEC_free (tree, heap, vec_oprnds0);
5001 VEC_free (tree, heap, vec_oprnds1);
5006 /* Function vect_min_worthwhile_factor.
5008 For a loop where we could vectorize the operation indicated by CODE,
5009 return the minimum vectorization factor that makes it worthwhile
5010 to use generic vectors. */
5012 vect_min_worthwhile_factor (enum tree_code code)
5033 /* Function vectorizable_induction
5035 Check if PHI performs an induction computation that can be vectorized.
5036 If VEC_STMT is also passed, vectorize the induction PHI: create a vectorized
5037 phi to replace it, put it in VEC_STMT, and add it to the same basic block.
5038 Return FALSE if not a vectorizable STMT, TRUE otherwise. */
5041 vectorizable_induction (gimple phi, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
5044 stmt_vec_info stmt_info = vinfo_for_stmt (phi);
5045 tree vectype = STMT_VINFO_VECTYPE (stmt_info);
5046 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
5047 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
5048 int nunits = TYPE_VECTOR_SUBPARTS (vectype);
5049 int ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits;
5052 gcc_assert (ncopies >= 1);
5053 /* FORNOW. These restrictions should be relaxed. */
5054 if (nested_in_vect_loop_p (loop, phi))
5056 imm_use_iterator imm_iter;
5057 use_operand_p use_p;
5064 if (vect_print_dump_info (REPORT_DETAILS))
5065 fprintf (vect_dump, "multiple types in nested loop.");
5070 latch_e = loop_latch_edge (loop->inner);
5071 loop_arg = PHI_ARG_DEF_FROM_EDGE (phi, latch_e);
5072 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, loop_arg)
5074 if (!flow_bb_inside_loop_p (loop->inner,
5075 gimple_bb (USE_STMT (use_p))))
5077 exit_phi = USE_STMT (use_p);
5083 stmt_vec_info exit_phi_vinfo = vinfo_for_stmt (exit_phi);
5084 if (!(STMT_VINFO_RELEVANT_P (exit_phi_vinfo)
5085 && !STMT_VINFO_LIVE_P (exit_phi_vinfo)))
5087 if (vect_print_dump_info (REPORT_DETAILS))
5088 fprintf (vect_dump, "inner-loop induction only used outside "
5089 "of the outer vectorized loop.");
5095 if (!STMT_VINFO_RELEVANT_P (stmt_info))
5098 /* FORNOW: SLP not supported. */
5099 if (STMT_SLP_TYPE (stmt_info))
5102 gcc_assert (STMT_VINFO_DEF_TYPE (stmt_info) == vect_induction_def);
5104 if (gimple_code (phi) != GIMPLE_PHI)
5107 if (!vec_stmt) /* transformation not required. */
5109 STMT_VINFO_TYPE (stmt_info) = induc_vec_info_type;
5110 if (vect_print_dump_info (REPORT_DETAILS))
5111 fprintf (vect_dump, "=== vectorizable_induction ===");
5112 vect_model_induction_cost (stmt_info, ncopies);
5118 if (vect_print_dump_info (REPORT_DETAILS))
5119 fprintf (vect_dump, "transform induction phi.");
5121 vec_def = get_initial_def_for_induction (phi);
5122 *vec_stmt = SSA_NAME_DEF_STMT (vec_def);
5126 /* Function vectorizable_live_operation.
5128 STMT computes a value that is used outside the loop. Check if
5129 it can be supported. */
5132 vectorizable_live_operation (gimple stmt,
5133 gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
5134 gimple *vec_stmt ATTRIBUTE_UNUSED)
5136 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
5137 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
5138 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
5144 enum vect_def_type dt;
5145 enum tree_code code;
5146 enum gimple_rhs_class rhs_class;
5148 gcc_assert (STMT_VINFO_LIVE_P (stmt_info));
5150 if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_reduction_def)
5153 if (!is_gimple_assign (stmt))
5156 if (TREE_CODE (gimple_assign_lhs (stmt)) != SSA_NAME)
5159 /* FORNOW. CHECKME. */
5160 if (nested_in_vect_loop_p (loop, stmt))
5163 code = gimple_assign_rhs_code (stmt);
5164 op_type = TREE_CODE_LENGTH (code);
5165 rhs_class = get_gimple_rhs_class (code);
5166 gcc_assert (rhs_class != GIMPLE_UNARY_RHS || op_type == unary_op);
5167 gcc_assert (rhs_class != GIMPLE_BINARY_RHS || op_type == binary_op);
5169 /* FORNOW: support only if all uses are invariant. This means
5170 that the scalar operations can remain in place, unvectorized.
5171 The original last scalar value that they compute will be used. */
5173 for (i = 0; i < op_type; i++)
5175 if (rhs_class == GIMPLE_SINGLE_RHS)
5176 op = TREE_OPERAND (gimple_op (stmt, 1), i);
5178 op = gimple_op (stmt, i + 1);
5180 && !vect_is_simple_use (op, stmt, loop_vinfo, NULL, &def_stmt, &def,
5183 if (vect_print_dump_info (REPORT_DETAILS))
5184 fprintf (vect_dump, "use not simple.");
5188 if (dt != vect_external_def && dt != vect_constant_def)
5192 /* No transformation is required for the cases we currently support. */
5196 /* Kill any debug uses outside LOOP of SSA names defined in STMT. */
5199 vect_loop_kill_debug_uses (struct loop *loop, gimple stmt)
5201 ssa_op_iter op_iter;
5202 imm_use_iterator imm_iter;
5203 def_operand_p def_p;
5206 FOR_EACH_PHI_OR_STMT_DEF (def_p, stmt, op_iter, SSA_OP_DEF)
5208 FOR_EACH_IMM_USE_STMT (ustmt, imm_iter, DEF_FROM_PTR (def_p))
5212 if (!is_gimple_debug (ustmt))
5215 bb = gimple_bb (ustmt);
5217 if (!flow_bb_inside_loop_p (loop, bb))
5219 if (gimple_debug_bind_p (ustmt))
5221 if (vect_print_dump_info (REPORT_DETAILS))
5222 fprintf (vect_dump, "killing debug use");
5224 gimple_debug_bind_reset_value (ustmt);
5225 update_stmt (ustmt);
5234 /* Function vect_transform_loop.
5236 The analysis phase has determined that the loop is vectorizable.
5237 Vectorize the loop - created vectorized stmts to replace the scalar
5238 stmts in the loop, and update the loop exit condition. */
5241 vect_transform_loop (loop_vec_info loop_vinfo)
5243 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
5244 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
5245 int nbbs = loop->num_nodes;
5246 gimple_stmt_iterator si;
5249 int vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
5251 bool slp_scheduled = false;
5252 unsigned int nunits;
5253 tree cond_expr = NULL_TREE;
5254 gimple_seq cond_expr_stmt_list = NULL;
5255 bool do_peeling_for_loop_bound;
5256 gimple stmt, pattern_stmt;
5257 gimple_seq pattern_def_seq = NULL;
5258 gimple_stmt_iterator pattern_def_si = gsi_start (NULL);
5259 bool transform_pattern_stmt = false;
5261 if (vect_print_dump_info (REPORT_DETAILS))
5262 fprintf (vect_dump, "=== vec_transform_loop ===");
5264 /* Peel the loop if there are data refs with unknown alignment.
5265 Only one data ref with unknown store is allowed. */
5267 if (LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo))
5268 vect_do_peeling_for_alignment (loop_vinfo);
5270 do_peeling_for_loop_bound
5271 = (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
5272 || (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
5273 && LOOP_VINFO_INT_NITERS (loop_vinfo) % vectorization_factor != 0)
5274 || LOOP_VINFO_PEELING_FOR_GAPS (loop_vinfo));
5276 if (LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)
5277 || LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo))
5278 vect_loop_versioning (loop_vinfo,
5279 !do_peeling_for_loop_bound,
5280 &cond_expr, &cond_expr_stmt_list);
5282 /* If the loop has a symbolic number of iterations 'n' (i.e. it's not a
5283 compile time constant), or it is a constant that doesn't divide by the
5284 vectorization factor, then an epilog loop needs to be created.
5285 We therefore duplicate the loop: the original loop will be vectorized,
5286 and will compute the first (n/VF) iterations. The second copy of the loop
5287 will remain scalar and will compute the remaining (n%VF) iterations.
5288 (VF is the vectorization factor). */
5290 if (do_peeling_for_loop_bound)
5291 vect_do_peeling_for_loop_bound (loop_vinfo, &ratio,
5292 cond_expr, cond_expr_stmt_list);
5294 ratio = build_int_cst (TREE_TYPE (LOOP_VINFO_NITERS (loop_vinfo)),
5295 LOOP_VINFO_INT_NITERS (loop_vinfo) / vectorization_factor);
5297 /* 1) Make sure the loop header has exactly two entries
5298 2) Make sure we have a preheader basic block. */
5300 gcc_assert (EDGE_COUNT (loop->header->preds) == 2);
5302 split_edge (loop_preheader_edge (loop));
5304 /* FORNOW: the vectorizer supports only loops which body consist
5305 of one basic block (header + empty latch). When the vectorizer will
5306 support more involved loop forms, the order by which the BBs are
5307 traversed need to be reconsidered. */
5309 for (i = 0; i < nbbs; i++)
5311 basic_block bb = bbs[i];
5312 stmt_vec_info stmt_info;
5315 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
5317 phi = gsi_stmt (si);
5318 if (vect_print_dump_info (REPORT_DETAILS))
5320 fprintf (vect_dump, "------>vectorizing phi: ");
5321 print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
5323 stmt_info = vinfo_for_stmt (phi);
5327 if (MAY_HAVE_DEBUG_STMTS && !STMT_VINFO_LIVE_P (stmt_info))
5328 vect_loop_kill_debug_uses (loop, phi);
5330 if (!STMT_VINFO_RELEVANT_P (stmt_info)
5331 && !STMT_VINFO_LIVE_P (stmt_info))
5334 if ((TYPE_VECTOR_SUBPARTS (STMT_VINFO_VECTYPE (stmt_info))
5335 != (unsigned HOST_WIDE_INT) vectorization_factor)
5336 && vect_print_dump_info (REPORT_DETAILS))
5337 fprintf (vect_dump, "multiple-types.");
5339 if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_induction_def)
5341 if (vect_print_dump_info (REPORT_DETAILS))
5342 fprintf (vect_dump, "transform phi.");
5343 vect_transform_stmt (phi, NULL, NULL, NULL, NULL);
5347 pattern_stmt = NULL;
5348 for (si = gsi_start_bb (bb); !gsi_end_p (si) || transform_pattern_stmt;)
5352 if (transform_pattern_stmt)
5353 stmt = pattern_stmt;
5355 stmt = gsi_stmt (si);
5357 if (vect_print_dump_info (REPORT_DETAILS))
5359 fprintf (vect_dump, "------>vectorizing statement: ");
5360 print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
5363 stmt_info = vinfo_for_stmt (stmt);
5365 /* vector stmts created in the outer-loop during vectorization of
5366 stmts in an inner-loop may not have a stmt_info, and do not
5367 need to be vectorized. */
5374 if (MAY_HAVE_DEBUG_STMTS && !STMT_VINFO_LIVE_P (stmt_info))
5375 vect_loop_kill_debug_uses (loop, stmt);
5377 if (!STMT_VINFO_RELEVANT_P (stmt_info)
5378 && !STMT_VINFO_LIVE_P (stmt_info))
5380 if (STMT_VINFO_IN_PATTERN_P (stmt_info)
5381 && (pattern_stmt = STMT_VINFO_RELATED_STMT (stmt_info))
5382 && (STMT_VINFO_RELEVANT_P (vinfo_for_stmt (pattern_stmt))
5383 || STMT_VINFO_LIVE_P (vinfo_for_stmt (pattern_stmt))))
5385 stmt = pattern_stmt;
5386 stmt_info = vinfo_for_stmt (stmt);
5394 else if (STMT_VINFO_IN_PATTERN_P (stmt_info)
5395 && (pattern_stmt = STMT_VINFO_RELATED_STMT (stmt_info))
5396 && (STMT_VINFO_RELEVANT_P (vinfo_for_stmt (pattern_stmt))
5397 || STMT_VINFO_LIVE_P (vinfo_for_stmt (pattern_stmt))))
5398 transform_pattern_stmt = true;
5400 /* If pattern statement has def stmts, vectorize them too. */
5401 if (is_pattern_stmt_p (stmt_info))
5403 if (pattern_def_seq == NULL)
5405 pattern_def_seq = STMT_VINFO_PATTERN_DEF_SEQ (stmt_info);
5406 pattern_def_si = gsi_start (pattern_def_seq);
5408 else if (!gsi_end_p (pattern_def_si))
5409 gsi_next (&pattern_def_si);
5410 if (pattern_def_seq != NULL)
5412 gimple pattern_def_stmt = NULL;
5413 stmt_vec_info pattern_def_stmt_info = NULL;
5415 while (!gsi_end_p (pattern_def_si))
5417 pattern_def_stmt = gsi_stmt (pattern_def_si);
5418 pattern_def_stmt_info
5419 = vinfo_for_stmt (pattern_def_stmt);
5420 if (STMT_VINFO_RELEVANT_P (pattern_def_stmt_info)
5421 || STMT_VINFO_LIVE_P (pattern_def_stmt_info))
5423 gsi_next (&pattern_def_si);
5426 if (!gsi_end_p (pattern_def_si))
5428 if (vect_print_dump_info (REPORT_DETAILS))
5430 fprintf (vect_dump, "==> vectorizing pattern def"
5432 print_gimple_stmt (vect_dump, pattern_def_stmt, 0,
5436 stmt = pattern_def_stmt;
5437 stmt_info = pattern_def_stmt_info;
5441 pattern_def_si = gsi_start (NULL);
5442 transform_pattern_stmt = false;
5446 transform_pattern_stmt = false;
5449 gcc_assert (STMT_VINFO_VECTYPE (stmt_info));
5450 nunits = (unsigned int) TYPE_VECTOR_SUBPARTS (
5451 STMT_VINFO_VECTYPE (stmt_info));
5452 if (!STMT_SLP_TYPE (stmt_info)
5453 && nunits != (unsigned int) vectorization_factor
5454 && vect_print_dump_info (REPORT_DETAILS))
5455 /* For SLP VF is set according to unrolling factor, and not to
5456 vector size, hence for SLP this print is not valid. */
5457 fprintf (vect_dump, "multiple-types.");
5459 /* SLP. Schedule all the SLP instances when the first SLP stmt is
5461 if (STMT_SLP_TYPE (stmt_info))
5465 slp_scheduled = true;
5467 if (vect_print_dump_info (REPORT_DETAILS))
5468 fprintf (vect_dump, "=== scheduling SLP instances ===");
5470 vect_schedule_slp (loop_vinfo, NULL);
5473 /* Hybrid SLP stmts must be vectorized in addition to SLP. */
5474 if (!vinfo_for_stmt (stmt) || PURE_SLP_STMT (stmt_info))
5476 if (!transform_pattern_stmt && gsi_end_p (pattern_def_si))
5478 pattern_def_seq = NULL;
5485 /* -------- vectorize statement ------------ */
5486 if (vect_print_dump_info (REPORT_DETAILS))
5487 fprintf (vect_dump, "transform statement.");
5489 strided_store = false;
5490 is_store = vect_transform_stmt (stmt, &si, &strided_store, NULL, NULL);
5493 if (STMT_VINFO_STRIDED_ACCESS (stmt_info))
5495 /* Interleaving. If IS_STORE is TRUE, the vectorization of the
5496 interleaving chain was completed - free all the stores in
5499 vect_remove_stores (GROUP_FIRST_ELEMENT (stmt_info));
5504 /* Free the attached stmt_vec_info and remove the stmt. */
5505 free_stmt_vec_info (gsi_stmt (si));
5506 gsi_remove (&si, true);
5511 if (!transform_pattern_stmt && gsi_end_p (pattern_def_si))
5513 pattern_def_seq = NULL;
5519 slpeel_make_loop_iterate_ntimes (loop, ratio);
5521 /* The memory tags and pointers in vectorized statements need to
5522 have their SSA forms updated. FIXME, why can't this be delayed
5523 until all the loops have been transformed? */
5524 update_ssa (TODO_update_ssa);
5526 if (vect_print_dump_info (REPORT_VECTORIZED_LOCATIONS))
5527 fprintf (vect_dump, "LOOP VECTORIZED.");
5528 if (loop->inner && vect_print_dump_info (REPORT_VECTORIZED_LOCATIONS))
5529 fprintf (vect_dump, "OUTER LOOP VECTORIZED.");