2 Copyright (C) 2003-2014 Free Software Foundation, Inc.
3 Contributed by Dorit Naishlos <dorit@il.ibm.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* Loop and basic block vectorizer.
23 This file contains drivers for the three vectorizers:
24 (1) loop vectorizer (inter-iteration parallelism),
25 (2) loop-aware SLP (intra-iteration parallelism) (invoked by the loop
27 (3) BB vectorizer (out-of-loops), aka SLP
29 The rest of the vectorizer's code is organized as follows:
30 - tree-vect-loop.c - loop specific parts such as reductions, etc. These are
31 used by drivers (1) and (2).
32 - tree-vect-loop-manip.c - vectorizer's loop control-flow utilities, used by
34 - tree-vect-slp.c - BB vectorization specific analysis and transformation,
35 used by drivers (2) and (3).
36 - tree-vect-stmts.c - statements analysis and transformation (used by all).
37 - tree-vect-data-refs.c - vectorizer specific data-refs analysis and
38 manipulations (used by all).
39 - tree-vect-patterns.c - vectorizable code patterns detector (used by all)
41 Here's a poor attempt at illustrating that:
44 loop_vect() loop_aware_slp() slp_vect()
47 tree-vect-loop.c tree-vect-slp.c
52 tree-vect-stmts.c tree-vect-data-refs.c
59 #include "coretypes.h"
63 #include "stor-layout.h"
64 #include "tree-pretty-print.h"
70 #include "hard-reg-set.h"
73 #include "dominance.h"
75 #include "basic-block.h"
76 #include "tree-ssa-alias.h"
77 #include "internal-fn.h"
78 #include "gimple-expr.h"
81 #include "gimple-iterator.h"
82 #include "gimple-walk.h"
83 #include "gimple-ssa.h"
85 #include "plugin-api.h"
88 #include "tree-phinodes.h"
89 #include "ssa-iterators.h"
90 #include "tree-ssa-loop-manip.h"
93 #include "tree-vectorizer.h"
94 #include "tree-pass.h"
95 #include "tree-ssa-propagate.h"
97 #include "gimple-fold.h"
98 #include "tree-scalar-evolution.h"
101 /* Loop or bb location. */
102 source_location vect_location
;
104 /* Vector mapping GIMPLE stmt to stmt_vec_info. */
105 vec
<vec_void_p
> stmt_vec_info_vec
;
107 /* For mapping simduid to vectorization factor. */
109 struct simduid_to_vf
: typed_free_remove
<simduid_to_vf
>
111 unsigned int simduid
;
114 /* hash_table support. */
115 typedef simduid_to_vf value_type
;
116 typedef simduid_to_vf compare_type
;
117 static inline hashval_t
hash (const value_type
*);
118 static inline int equal (const value_type
*, const compare_type
*);
122 simduid_to_vf::hash (const value_type
*p
)
128 simduid_to_vf::equal (const value_type
*p1
, const value_type
*p2
)
130 return p1
->simduid
== p2
->simduid
;
133 /* This hash maps the OMP simd array to the corresponding simduid used
134 to index into it. Like thus,
136 _7 = GOMP_SIMD_LANE (simduid.0)
142 This hash maps from the OMP simd array (D.1737[]) to DECL_UID of
145 struct simd_array_to_simduid
: typed_free_remove
<simd_array_to_simduid
>
148 unsigned int simduid
;
150 /* hash_table support. */
151 typedef simd_array_to_simduid value_type
;
152 typedef simd_array_to_simduid compare_type
;
153 static inline hashval_t
hash (const value_type
*);
154 static inline int equal (const value_type
*, const compare_type
*);
158 simd_array_to_simduid::hash (const value_type
*p
)
160 return DECL_UID (p
->decl
);
164 simd_array_to_simduid::equal (const value_type
*p1
, const value_type
*p2
)
166 return p1
->decl
== p2
->decl
;
169 /* Fold IFN_GOMP_SIMD_LANE, IFN_GOMP_SIMD_VF and IFN_GOMP_SIMD_LAST_LANE
170 into their corresponding constants. */
173 adjust_simduid_builtins (hash_table
<simduid_to_vf
> **htab
)
177 FOR_EACH_BB_FN (bb
, cfun
)
179 gimple_stmt_iterator i
;
181 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
184 enum internal_fn ifn
;
185 gimple stmt
= gsi_stmt (i
);
187 if (!is_gimple_call (stmt
)
188 || !gimple_call_internal_p (stmt
))
190 ifn
= gimple_call_internal_fn (stmt
);
193 case IFN_GOMP_SIMD_LANE
:
194 case IFN_GOMP_SIMD_VF
:
195 case IFN_GOMP_SIMD_LAST_LANE
:
200 tree arg
= gimple_call_arg (stmt
, 0);
201 gcc_assert (arg
!= NULL_TREE
);
202 gcc_assert (TREE_CODE (arg
) == SSA_NAME
);
203 simduid_to_vf
*p
= NULL
, data
;
204 data
.simduid
= DECL_UID (SSA_NAME_VAR (arg
));
206 p
= (*htab
)->find (&data
);
211 case IFN_GOMP_SIMD_VF
:
212 t
= build_int_cst (unsigned_type_node
, vf
);
214 case IFN_GOMP_SIMD_LANE
:
215 t
= build_int_cst (unsigned_type_node
, 0);
217 case IFN_GOMP_SIMD_LAST_LANE
:
218 t
= gimple_call_arg (stmt
, 1);
223 update_call_from_tree (&i
, t
);
228 /* Helper structure for note_simd_array_uses. */
230 struct note_simd_array_uses_struct
232 hash_table
<simd_array_to_simduid
> **htab
;
233 unsigned int simduid
;
236 /* Callback for note_simd_array_uses, called through walk_gimple_op. */
239 note_simd_array_uses_cb (tree
*tp
, int *walk_subtrees
, void *data
)
241 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
242 struct note_simd_array_uses_struct
*ns
243 = (struct note_simd_array_uses_struct
*) wi
->info
;
248 && lookup_attribute ("omp simd array", DECL_ATTRIBUTES (*tp
))
249 && DECL_CONTEXT (*tp
) == current_function_decl
)
251 simd_array_to_simduid data
;
253 *ns
->htab
= new hash_table
<simd_array_to_simduid
> (15);
255 data
.simduid
= ns
->simduid
;
256 simd_array_to_simduid
**slot
= (*ns
->htab
)->find_slot (&data
, INSERT
);
259 simd_array_to_simduid
*p
= XNEW (simd_array_to_simduid
);
263 else if ((*slot
)->simduid
!= ns
->simduid
)
264 (*slot
)->simduid
= -1U;
270 /* Find "omp simd array" temporaries and map them to corresponding
274 note_simd_array_uses (hash_table
<simd_array_to_simduid
> **htab
)
277 gimple_stmt_iterator gsi
;
278 struct walk_stmt_info wi
;
279 struct note_simd_array_uses_struct ns
;
281 memset (&wi
, 0, sizeof (wi
));
285 FOR_EACH_BB_FN (bb
, cfun
)
286 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
288 gimple stmt
= gsi_stmt (gsi
);
289 if (!is_gimple_call (stmt
) || !gimple_call_internal_p (stmt
))
291 switch (gimple_call_internal_fn (stmt
))
293 case IFN_GOMP_SIMD_LANE
:
294 case IFN_GOMP_SIMD_VF
:
295 case IFN_GOMP_SIMD_LAST_LANE
:
300 tree lhs
= gimple_call_lhs (stmt
);
301 if (lhs
== NULL_TREE
)
303 imm_use_iterator use_iter
;
305 ns
.simduid
= DECL_UID (SSA_NAME_VAR (gimple_call_arg (stmt
, 0)));
306 FOR_EACH_IMM_USE_STMT (use_stmt
, use_iter
, lhs
)
307 if (!is_gimple_debug (use_stmt
))
308 walk_gimple_op (use_stmt
, note_simd_array_uses_cb
, &wi
);
312 /* A helper function to free data refs. */
315 vect_destroy_datarefs (loop_vec_info loop_vinfo
, bb_vec_info bb_vinfo
)
317 vec
<data_reference_p
> datarefs
;
318 struct data_reference
*dr
;
322 datarefs
= LOOP_VINFO_DATAREFS (loop_vinfo
);
324 datarefs
= BB_VINFO_DATAREFS (bb_vinfo
);
326 FOR_EACH_VEC_ELT (datarefs
, i
, dr
)
333 free_data_refs (datarefs
);
337 /* If LOOP has been versioned during ifcvt, return the internal call
341 vect_loop_vectorized_call (struct loop
*loop
)
343 basic_block bb
= loop_preheader_edge (loop
)->src
;
350 if (!single_pred_p (bb
))
352 bb
= single_pred (bb
);
355 if (g
&& gimple_code (g
) == GIMPLE_COND
)
357 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
359 if (!gsi_end_p (gsi
))
362 if (is_gimple_call (g
)
363 && gimple_call_internal_p (g
)
364 && gimple_call_internal_fn (g
) == IFN_LOOP_VECTORIZED
365 && (tree_to_shwi (gimple_call_arg (g
, 0)) == loop
->num
366 || tree_to_shwi (gimple_call_arg (g
, 1)) == loop
->num
))
373 /* Fold LOOP_VECTORIZED internal call G to VALUE and
374 update any immediate uses of it's LHS. */
377 fold_loop_vectorized_call (gimple g
, tree value
)
379 tree lhs
= gimple_call_lhs (g
);
381 imm_use_iterator iter
;
383 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
385 update_call_from_tree (&gsi
, value
);
386 FOR_EACH_IMM_USE_STMT (use_stmt
, iter
, lhs
)
388 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
389 SET_USE (use_p
, value
);
390 update_stmt (use_stmt
);
394 /* Function vectorize_loops.
396 Entry point to loop vectorization phase. */
399 vectorize_loops (void)
402 unsigned int num_vectorized_loops
= 0;
403 unsigned int vect_loops_num
;
405 hash_table
<simduid_to_vf
> *simduid_to_vf_htab
= NULL
;
406 hash_table
<simd_array_to_simduid
> *simd_array_to_simduid_htab
= NULL
;
407 bool any_ifcvt_loops
= false;
410 vect_loops_num
= number_of_loops (cfun
);
412 /* Bail out if there are no loops. */
413 if (vect_loops_num
<= 1)
415 if (cfun
->has_simduid_loops
)
416 adjust_simduid_builtins (&simduid_to_vf_htab
);
420 if (cfun
->has_simduid_loops
)
421 note_simd_array_uses (&simd_array_to_simduid_htab
);
423 init_stmt_vec_info_vec ();
425 /* ----------- Analyze loops. ----------- */
427 /* If some loop was duplicated, it gets bigger number
428 than all previously defined loops. This fact allows us to run
429 only over initial loops skipping newly generated ones. */
430 FOR_EACH_LOOP (loop
, 0)
431 if (loop
->dont_vectorize
)
432 any_ifcvt_loops
= true;
433 else if ((flag_tree_loop_vectorize
434 && optimize_loop_nest_for_speed_p (loop
))
435 || loop
->force_vectorize
)
437 loop_vec_info loop_vinfo
;
438 vect_location
= find_loop_location (loop
);
439 if (LOCATION_LOCUS (vect_location
) != UNKNOWN_LOCATION
440 && dump_enabled_p ())
441 dump_printf (MSG_NOTE
, "\nAnalyzing loop at %s:%d\n",
442 LOCATION_FILE (vect_location
),
443 LOCATION_LINE (vect_location
));
445 loop_vinfo
= vect_analyze_loop (loop
);
446 loop
->aux
= loop_vinfo
;
448 if (!loop_vinfo
|| !LOOP_VINFO_VECTORIZABLE_P (loop_vinfo
))
451 if (!dbg_cnt (vect_loop
))
454 gimple loop_vectorized_call
= vect_loop_vectorized_call (loop
);
455 if (loop_vectorized_call
)
457 tree arg
= gimple_call_arg (loop_vectorized_call
, 1);
460 struct loop
*scalar_loop
= get_loop (cfun
, tree_to_shwi (arg
));
462 LOOP_VINFO_SCALAR_LOOP (loop_vinfo
) = scalar_loop
;
463 gcc_checking_assert (vect_loop_vectorized_call
464 (LOOP_VINFO_SCALAR_LOOP (loop_vinfo
))
465 == loop_vectorized_call
);
466 bbs
= get_loop_body (scalar_loop
);
467 for (i
= 0; i
< scalar_loop
->num_nodes
; i
++)
469 basic_block bb
= bbs
[i
];
470 gimple_stmt_iterator gsi
;
471 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
474 gimple phi
= gsi_stmt (gsi
);
475 gimple_set_uid (phi
, 0);
477 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
480 gimple stmt
= gsi_stmt (gsi
);
481 gimple_set_uid (stmt
, 0);
487 if (LOCATION_LOCUS (vect_location
) != UNKNOWN_LOCATION
488 && dump_enabled_p ())
489 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, vect_location
,
490 "loop vectorized\n");
491 vect_transform_loop (loop_vinfo
);
492 num_vectorized_loops
++;
493 /* Now that the loop has been vectorized, allow it to be unrolled
495 loop
->force_vectorize
= false;
499 simduid_to_vf
*simduid_to_vf_data
= XNEW (simduid_to_vf
);
500 if (!simduid_to_vf_htab
)
501 simduid_to_vf_htab
= new hash_table
<simduid_to_vf
> (15);
502 simduid_to_vf_data
->simduid
= DECL_UID (loop
->simduid
);
503 simduid_to_vf_data
->vf
= loop_vinfo
->vectorization_factor
;
504 *simduid_to_vf_htab
->find_slot (simduid_to_vf_data
, INSERT
)
505 = simduid_to_vf_data
;
508 if (loop_vectorized_call
)
510 fold_loop_vectorized_call (loop_vectorized_call
, boolean_true_node
);
511 ret
|= TODO_cleanup_cfg
;
515 vect_location
= UNKNOWN_LOCATION
;
517 statistics_counter_event (cfun
, "Vectorized loops", num_vectorized_loops
);
518 if (dump_enabled_p ()
519 || (num_vectorized_loops
> 0 && dump_enabled_p ()))
520 dump_printf_loc (MSG_NOTE
, vect_location
,
521 "vectorized %u loops in function.\n",
522 num_vectorized_loops
);
524 /* ----------- Finalize. ----------- */
527 for (i
= 1; i
< vect_loops_num
; i
++)
529 loop
= get_loop (cfun
, i
);
530 if (loop
&& loop
->dont_vectorize
)
532 gimple g
= vect_loop_vectorized_call (loop
);
535 fold_loop_vectorized_call (g
, boolean_false_node
);
536 ret
|= TODO_cleanup_cfg
;
541 for (i
= 1; i
< vect_loops_num
; i
++)
543 loop_vec_info loop_vinfo
;
545 loop
= get_loop (cfun
, i
);
548 loop_vinfo
= (loop_vec_info
) loop
->aux
;
549 destroy_loop_vec_info (loop_vinfo
, true);
553 free_stmt_vec_info_vec ();
555 /* Fold IFN_GOMP_SIMD_{VF,LANE,LAST_LANE} builtins. */
556 if (cfun
->has_simduid_loops
)
557 adjust_simduid_builtins (&simduid_to_vf_htab
);
559 /* Shrink any "omp array simd" temporary arrays to the
560 actual vectorization factors. */
561 if (simd_array_to_simduid_htab
)
563 for (hash_table
<simd_array_to_simduid
>::iterator iter
564 = simd_array_to_simduid_htab
->begin ();
565 iter
!= simd_array_to_simduid_htab
->end (); ++iter
)
566 if ((*iter
)->simduid
!= -1U)
568 tree decl
= (*iter
)->decl
;
570 if (simduid_to_vf_htab
)
572 simduid_to_vf
*p
= NULL
, data
;
573 data
.simduid
= (*iter
)->simduid
;
574 p
= simduid_to_vf_htab
->find (&data
);
579 = build_array_type_nelts (TREE_TYPE (TREE_TYPE (decl
)), vf
);
580 TREE_TYPE (decl
) = atype
;
581 relayout_decl (decl
);
584 delete simd_array_to_simduid_htab
;
586 delete simduid_to_vf_htab
;
587 simduid_to_vf_htab
= NULL
;
589 if (num_vectorized_loops
> 0)
591 /* If we vectorized any loop only virtual SSA form needs to be updated.
592 ??? Also while we try hard to update loop-closed SSA form we fail
593 to properly do this in some corner-cases (see PR56286). */
594 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa_only_virtuals
);
595 return TODO_cleanup_cfg
;
602 /* Entry point to basic block SLP phase. */
606 const pass_data pass_data_slp_vectorize
=
608 GIMPLE_PASS
, /* type */
610 OPTGROUP_LOOP
| OPTGROUP_VEC
, /* optinfo_flags */
611 TV_TREE_SLP_VECTORIZATION
, /* tv_id */
612 ( PROP_ssa
| PROP_cfg
), /* properties_required */
613 0, /* properties_provided */
614 0, /* properties_destroyed */
615 0, /* todo_flags_start */
616 TODO_update_ssa
, /* todo_flags_finish */
619 class pass_slp_vectorize
: public gimple_opt_pass
622 pass_slp_vectorize (gcc::context
*ctxt
)
623 : gimple_opt_pass (pass_data_slp_vectorize
, ctxt
)
626 /* opt_pass methods: */
627 opt_pass
* clone () { return new pass_slp_vectorize (m_ctxt
); }
628 virtual bool gate (function
*) { return flag_tree_slp_vectorize
!= 0; }
629 virtual unsigned int execute (function
*);
631 }; // class pass_slp_vectorize
634 pass_slp_vectorize::execute (function
*fun
)
638 bool in_loop_pipeline
= scev_initialized_p ();
639 if (!in_loop_pipeline
)
641 loop_optimizer_init (LOOPS_NORMAL
);
645 init_stmt_vec_info_vec ();
647 FOR_EACH_BB_FN (bb
, fun
)
649 vect_location
= find_bb_location (bb
);
651 if (vect_slp_analyze_bb (bb
))
653 if (!dbg_cnt (vect_slp
))
656 vect_slp_transform_bb (bb
);
657 if (dump_enabled_p ())
658 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, vect_location
,
659 "basic block vectorized\n");
663 free_stmt_vec_info_vec ();
665 if (!in_loop_pipeline
)
668 loop_optimizer_finalize ();
677 make_pass_slp_vectorize (gcc::context
*ctxt
)
679 return new pass_slp_vectorize (ctxt
);
683 /* Increase alignment of global arrays to improve vectorization potential.
685 - Consider also structs that have an array field.
686 - Use ipa analysis to prune arrays that can't be vectorized?
687 This should involve global alignment analysis and in the future also
691 increase_alignment (void)
695 vect_location
= UNKNOWN_LOCATION
;
697 /* Increase the alignment of all global arrays for vectorization. */
698 FOR_EACH_DEFINED_VARIABLE (vnode
)
700 tree vectype
, decl
= vnode
->decl
;
702 unsigned int alignment
;
704 t
= TREE_TYPE (decl
);
705 if (TREE_CODE (t
) != ARRAY_TYPE
)
707 vectype
= get_vectype_for_scalar_type (strip_array_types (t
));
710 alignment
= TYPE_ALIGN (vectype
);
711 if (DECL_ALIGN (decl
) >= alignment
)
714 if (vect_can_force_dr_alignment_p (decl
, alignment
))
716 DECL_ALIGN (decl
) = TYPE_ALIGN (vectype
);
717 DECL_USER_ALIGN (decl
) = 1;
718 if (TREE_STATIC (decl
))
720 tree target
= symtab_node::get (decl
)->ultimate_alias_target ()->decl
;
721 DECL_ALIGN (target
) = TYPE_ALIGN (vectype
);
722 DECL_USER_ALIGN (target
) = 1;
724 dump_printf (MSG_NOTE
, "Increasing alignment of decl: ");
725 dump_generic_expr (MSG_NOTE
, TDF_SLIM
, decl
);
726 dump_printf (MSG_NOTE
, "\n");
735 const pass_data pass_data_ipa_increase_alignment
=
737 SIMPLE_IPA_PASS
, /* type */
738 "increase_alignment", /* name */
739 OPTGROUP_LOOP
| OPTGROUP_VEC
, /* optinfo_flags */
740 TV_IPA_OPT
, /* tv_id */
741 0, /* properties_required */
742 0, /* properties_provided */
743 0, /* properties_destroyed */
744 0, /* todo_flags_start */
745 0, /* todo_flags_finish */
748 class pass_ipa_increase_alignment
: public simple_ipa_opt_pass
751 pass_ipa_increase_alignment (gcc::context
*ctxt
)
752 : simple_ipa_opt_pass (pass_data_ipa_increase_alignment
, ctxt
)
755 /* opt_pass methods: */
756 virtual bool gate (function
*)
758 return flag_section_anchors
&& flag_tree_loop_vectorize
;
761 virtual unsigned int execute (function
*) { return increase_alignment (); }
763 }; // class pass_ipa_increase_alignment
767 simple_ipa_opt_pass
*
768 make_pass_ipa_increase_alignment (gcc::context
*ctxt
)
770 return new pass_ipa_increase_alignment (ctxt
);