Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-vectorizer.h @ 67:f6334be47118

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
author nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date Tue, 22 Mar 2011 17:18:12 +0900
parents b7f97abdc517
children 04ced10e8804
comparison
equal deleted inserted replaced
65:65488c3d617d 67:f6334be47118
67 }; 67 };
68 68
69 #define VECTORIZABLE_CYCLE_DEF(D) (((D) == vect_reduction_def) \ 69 #define VECTORIZABLE_CYCLE_DEF(D) (((D) == vect_reduction_def) \
70 || ((D) == vect_double_reduction_def) \ 70 || ((D) == vect_double_reduction_def) \
71 || ((D) == vect_nested_cycle)) 71 || ((D) == vect_nested_cycle))
72
73 /* Define verbosity levels. */
74 enum verbosity_levels {
75 REPORT_NONE,
76 REPORT_VECTORIZED_LOCATIONS,
77 REPORT_UNVECTORIZED_LOCATIONS,
78 REPORT_COST,
79 REPORT_ALIGNMENT,
80 REPORT_DR_DETAILS,
81 REPORT_BAD_FORM_LOOPS,
82 REPORT_OUTER_LOOPS,
83 REPORT_SLP,
84 REPORT_DETAILS,
85 /* New verbosity levels should be added before this one. */
86 MAX_VERBOSITY_LEVEL
87 };
88 72
89 /************************************************************************ 73 /************************************************************************
90 SLP 74 SLP
91 ************************************************************************/ 75 ************************************************************************/
92 76
168 #define SLP_TREE_VEC_STMTS(S) (S)->vec_stmts 152 #define SLP_TREE_VEC_STMTS(S) (S)->vec_stmts
169 #define SLP_TREE_NUMBER_OF_VEC_STMTS(S) (S)->vec_stmts_size 153 #define SLP_TREE_NUMBER_OF_VEC_STMTS(S) (S)->vec_stmts_size
170 #define SLP_TREE_OUTSIDE_OF_LOOP_COST(S) (S)->cost.outside_of_loop 154 #define SLP_TREE_OUTSIDE_OF_LOOP_COST(S) (S)->cost.outside_of_loop
171 #define SLP_TREE_INSIDE_OF_LOOP_COST(S) (S)->cost.inside_of_loop 155 #define SLP_TREE_INSIDE_OF_LOOP_COST(S) (S)->cost.inside_of_loop
172 156
157
158 typedef struct _vect_peel_info
159 {
160 int npeel;
161 struct data_reference *dr;
162 unsigned int count;
163 } *vect_peel_info;
164
165 typedef struct _vect_peel_extended_info
166 {
167 struct _vect_peel_info peel_info;
168 unsigned int inside_cost;
169 unsigned int outside_cost;
170 } *vect_peel_extended_info;
171
173 /*-----------------------------------------------------------------*/ 172 /*-----------------------------------------------------------------*/
174 /* Info on vectorized loops. */ 173 /* Info on vectorized loops. */
175 /*-----------------------------------------------------------------*/ 174 /*-----------------------------------------------------------------*/
176 typedef struct _loop_vec_info { 175 typedef struct _loop_vec_info {
177 176
215 int peeling_for_alignment; 214 int peeling_for_alignment;
216 215
217 /* The mask used to check the alignment of pointers or arrays. */ 216 /* The mask used to check the alignment of pointers or arrays. */
218 int ptr_mask; 217 int ptr_mask;
219 218
219 /* The loop nest in which the data dependences are computed. */
220 VEC (loop_p, heap) *loop_nest;
221
220 /* All data references in the loop. */ 222 /* All data references in the loop. */
221 VEC (data_reference_p, heap) *datarefs; 223 VEC (data_reference_p, heap) *datarefs;
222 224
223 /* All data dependences in the loop. */ 225 /* All data dependences in the loop. */
224 VEC (ddr_p, heap) *ddrs; 226 VEC (ddr_p, heap) *ddrs;
243 applied to the loop, i.e., no unrolling is needed, this is 1. */ 245 applied to the loop, i.e., no unrolling is needed, this is 1. */
244 unsigned slp_unrolling_factor; 246 unsigned slp_unrolling_factor;
245 247
246 /* Reduction cycles detected in the loop. Used in loop-aware SLP. */ 248 /* Reduction cycles detected in the loop. Used in loop-aware SLP. */
247 VEC (gimple, heap) *reductions; 249 VEC (gimple, heap) *reductions;
250
251 /* Hash table used to choose the best peeling option. */
252 htab_t peeling_htab;
253
248 } *loop_vec_info; 254 } *loop_vec_info;
249 255
250 /* Access Functions. */ 256 /* Access Functions. */
251 #define LOOP_VINFO_LOOP(L) (L)->loop 257 #define LOOP_VINFO_LOOP(L) (L)->loop
252 #define LOOP_VINFO_BBS(L) (L)->bbs 258 #define LOOP_VINFO_BBS(L) (L)->bbs
256 #define LOOP_VINFO_NITERS_UNCHANGED(L) (L)->num_iters_unchanged 262 #define LOOP_VINFO_NITERS_UNCHANGED(L) (L)->num_iters_unchanged
257 #define LOOP_VINFO_COST_MODEL_MIN_ITERS(L) (L)->min_profitable_iters 263 #define LOOP_VINFO_COST_MODEL_MIN_ITERS(L) (L)->min_profitable_iters
258 #define LOOP_VINFO_VECTORIZABLE_P(L) (L)->vectorizable 264 #define LOOP_VINFO_VECTORIZABLE_P(L) (L)->vectorizable
259 #define LOOP_VINFO_VECT_FACTOR(L) (L)->vectorization_factor 265 #define LOOP_VINFO_VECT_FACTOR(L) (L)->vectorization_factor
260 #define LOOP_VINFO_PTR_MASK(L) (L)->ptr_mask 266 #define LOOP_VINFO_PTR_MASK(L) (L)->ptr_mask
267 #define LOOP_VINFO_LOOP_NEST(L) (L)->loop_nest
261 #define LOOP_VINFO_DATAREFS(L) (L)->datarefs 268 #define LOOP_VINFO_DATAREFS(L) (L)->datarefs
262 #define LOOP_VINFO_DDRS(L) (L)->ddrs 269 #define LOOP_VINFO_DDRS(L) (L)->ddrs
263 #define LOOP_VINFO_INT_NITERS(L) (TREE_INT_CST_LOW ((L)->num_iters)) 270 #define LOOP_VINFO_INT_NITERS(L) (TREE_INT_CST_LOW ((L)->num_iters))
264 #define LOOP_PEELING_FOR_ALIGNMENT(L) (L)->peeling_for_alignment 271 #define LOOP_PEELING_FOR_ALIGNMENT(L) (L)->peeling_for_alignment
265 #define LOOP_VINFO_UNALIGNED_DR(L) (L)->unaligned_dr 272 #define LOOP_VINFO_UNALIGNED_DR(L) (L)->unaligned_dr
268 #define LOOP_VINFO_MAY_ALIAS_DDRS(L) (L)->may_alias_ddrs 275 #define LOOP_VINFO_MAY_ALIAS_DDRS(L) (L)->may_alias_ddrs
269 #define LOOP_VINFO_STRIDED_STORES(L) (L)->strided_stores 276 #define LOOP_VINFO_STRIDED_STORES(L) (L)->strided_stores
270 #define LOOP_VINFO_SLP_INSTANCES(L) (L)->slp_instances 277 #define LOOP_VINFO_SLP_INSTANCES(L) (L)->slp_instances
271 #define LOOP_VINFO_SLP_UNROLLING_FACTOR(L) (L)->slp_unrolling_factor 278 #define LOOP_VINFO_SLP_UNROLLING_FACTOR(L) (L)->slp_unrolling_factor
272 #define LOOP_VINFO_REDUCTIONS(L) (L)->reductions 279 #define LOOP_VINFO_REDUCTIONS(L) (L)->reductions
280 #define LOOP_VINFO_PEELING_HTAB(L) (L)->peeling_htab
273 281
274 #define LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT(L) \ 282 #define LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT(L) \
275 VEC_length (gimple, (L)->may_misalign_stmts) > 0 283 VEC_length (gimple, (L)->may_misalign_stmts) > 0
276 #define LOOP_REQUIRES_VERSIONING_FOR_ALIAS(L) \ 284 #define LOOP_REQUIRES_VERSIONING_FOR_ALIAS(L) \
277 VEC_length (ddr_p, (L)->may_alias_ddrs) > 0 285 VEC_length (ddr_p, (L)->may_alias_ddrs) > 0
331 /*-----------------------------------------------------------------*/ 339 /*-----------------------------------------------------------------*/
332 enum stmt_vec_info_type { 340 enum stmt_vec_info_type {
333 undef_vec_info_type = 0, 341 undef_vec_info_type = 0,
334 load_vec_info_type, 342 load_vec_info_type,
335 store_vec_info_type, 343 store_vec_info_type,
344 shift_vec_info_type,
336 op_vec_info_type, 345 op_vec_info_type,
337 call_vec_info_type, 346 call_vec_info_type,
338 assignment_vec_info_type, 347 assignment_vec_info_type,
339 condition_vec_info_type, 348 condition_vec_info_type,
340 reduc_vec_info_type, 349 reduc_vec_info_type,
541 550
542 #define HYBRID_SLP_STMT(S) ((S)->slp_type == hybrid) 551 #define HYBRID_SLP_STMT(S) ((S)->slp_type == hybrid)
543 #define PURE_SLP_STMT(S) ((S)->slp_type == pure_slp) 552 #define PURE_SLP_STMT(S) ((S)->slp_type == pure_slp)
544 #define STMT_SLP_TYPE(S) (S)->slp_type 553 #define STMT_SLP_TYPE(S) (S)->slp_type
545 554
546 /* These are some defines for the initial implementation of the vectorizer's 555 #define VECT_MAX_COST 1000
547 cost model. These will later be target specific hooks. */
548
549 /* Cost of conditional taken branch. */
550 #ifndef TARG_COND_TAKEN_BRANCH_COST
551 #define TARG_COND_TAKEN_BRANCH_COST 3
552 #endif
553
554 /* Cost of conditional not taken branch. */
555 #ifndef TARG_COND_NOT_TAKEN_BRANCH_COST
556 #define TARG_COND_NOT_TAKEN_BRANCH_COST 1
557 #endif
558
559 /* Cost of any scalar operation, excluding load and store. */
560 #ifndef TARG_SCALAR_STMT_COST
561 #define TARG_SCALAR_STMT_COST 1
562 #endif
563
564 /* Cost of scalar load. */
565 #ifndef TARG_SCALAR_LOAD_COST
566 #define TARG_SCALAR_LOAD_COST 1
567 #endif
568
569 /* Cost of scalar store. */
570 #ifndef TARG_SCALAR_STORE_COST
571 #define TARG_SCALAR_STORE_COST 1
572 #endif
573
574 /* Cost of any vector operation, excluding load, store or vector to scalar
575 operation. */
576 #ifndef TARG_VEC_STMT_COST
577 #define TARG_VEC_STMT_COST 1
578 #endif
579
580 /* Cost of vector to scalar operation. */
581 #ifndef TARG_VEC_TO_SCALAR_COST
582 #define TARG_VEC_TO_SCALAR_COST 1
583 #endif
584
585 /* Cost of scalar to vector operation. */
586 #ifndef TARG_SCALAR_TO_VEC_COST
587 #define TARG_SCALAR_TO_VEC_COST 1
588 #endif
589
590 /* Cost of aligned vector load. */
591 #ifndef TARG_VEC_LOAD_COST
592 #define TARG_VEC_LOAD_COST 1
593 #endif
594
595 /* Cost of misaligned vector load. */
596 #ifndef TARG_VEC_UNALIGNED_LOAD_COST
597 #define TARG_VEC_UNALIGNED_LOAD_COST 2
598 #endif
599
600 /* Cost of vector store. */
601 #ifndef TARG_VEC_STORE_COST
602 #define TARG_VEC_STORE_COST 1
603 #endif
604
605 /* Cost of vector permutation. */
606 #ifndef TARG_VEC_PERMUTE_COST
607 #define TARG_VEC_PERMUTE_COST 1
608 #endif
609 556
610 /* The maximum number of intermediate steps required in multi-step type 557 /* The maximum number of intermediate steps required in multi-step type
611 conversion. */ 558 conversion. */
612 #define MAX_INTERM_CVT_STEPS 3 559 #define MAX_INTERM_CVT_STEPS 3
613 560
622 extern VEC(vec_void_p,heap) *stmt_vec_info_vec; 569 extern VEC(vec_void_p,heap) *stmt_vec_info_vec;
623 570
624 void init_stmt_vec_info_vec (void); 571 void init_stmt_vec_info_vec (void);
625 void free_stmt_vec_info_vec (void); 572 void free_stmt_vec_info_vec (void);
626 573
574 /* Return a stmt_vec_info corresponding to STMT. */
575
627 static inline stmt_vec_info 576 static inline stmt_vec_info
628 vinfo_for_stmt (gimple stmt) 577 vinfo_for_stmt (gimple stmt)
629 { 578 {
630 unsigned int uid = gimple_uid (stmt); 579 unsigned int uid = gimple_uid (stmt);
631 if (uid == 0) 580 if (uid == 0)
632 return NULL; 581 return NULL;
633 582
634 gcc_assert (uid <= VEC_length (vec_void_p, stmt_vec_info_vec));
635 return (stmt_vec_info) VEC_index (vec_void_p, stmt_vec_info_vec, uid - 1); 583 return (stmt_vec_info) VEC_index (vec_void_p, stmt_vec_info_vec, uid - 1);
636 } 584 }
585
586 /* Set vectorizer information INFO for STMT. */
637 587
638 static inline void 588 static inline void
639 set_vinfo_for_stmt (gimple stmt, stmt_vec_info info) 589 set_vinfo_for_stmt (gimple stmt, stmt_vec_info info)
640 { 590 {
641 unsigned int uid = gimple_uid (stmt); 591 unsigned int uid = gimple_uid (stmt);
642 if (uid == 0) 592 if (uid == 0)
643 { 593 {
644 gcc_assert (info); 594 gcc_checking_assert (info);
645 uid = VEC_length (vec_void_p, stmt_vec_info_vec) + 1; 595 uid = VEC_length (vec_void_p, stmt_vec_info_vec) + 1;
646 gimple_set_uid (stmt, uid); 596 gimple_set_uid (stmt, uid);
647 VEC_safe_push (vec_void_p, heap, stmt_vec_info_vec, (vec_void_p) info); 597 VEC_safe_push (vec_void_p, heap, stmt_vec_info_vec, (vec_void_p) info);
648 } 598 }
649 else 599 else
650 VEC_replace (vec_void_p, stmt_vec_info_vec, uid - 1, (vec_void_p) info); 600 VEC_replace (vec_void_p, stmt_vec_info_vec, uid - 1, (vec_void_p) info);
651 } 601 }
652 602
603 /* Return the earlier statement between STMT1 and STMT2. */
604
653 static inline gimple 605 static inline gimple
654 get_earlier_stmt (gimple stmt1, gimple stmt2) 606 get_earlier_stmt (gimple stmt1, gimple stmt2)
655 { 607 {
656 unsigned int uid1, uid2; 608 unsigned int uid1, uid2;
657 609
665 uid2 = gimple_uid (stmt2); 617 uid2 = gimple_uid (stmt2);
666 618
667 if (uid1 == 0 || uid2 == 0) 619 if (uid1 == 0 || uid2 == 0)
668 return NULL; 620 return NULL;
669 621
670 gcc_assert (uid1 <= VEC_length (vec_void_p, stmt_vec_info_vec)); 622 gcc_checking_assert (uid1 <= VEC_length (vec_void_p, stmt_vec_info_vec)
671 gcc_assert (uid2 <= VEC_length (vec_void_p, stmt_vec_info_vec)); 623 && uid2 <= VEC_length (vec_void_p, stmt_vec_info_vec));
672 624
673 if (uid1 < uid2) 625 if (uid1 < uid2)
674 return stmt1; 626 return stmt1;
675 else 627 else
676 return stmt2; 628 return stmt2;
677 } 629 }
630
631 /* Return the later statement between STMT1 and STMT2. */
632
633 static inline gimple
634 get_later_stmt (gimple stmt1, gimple stmt2)
635 {
636 unsigned int uid1, uid2;
637
638 if (stmt1 == NULL)
639 return stmt2;
640
641 if (stmt2 == NULL)
642 return stmt1;
643
644 uid1 = gimple_uid (stmt1);
645 uid2 = gimple_uid (stmt2);
646
647 if (uid1 == 0 || uid2 == 0)
648 return NULL;
649
650 gcc_assert (uid1 <= VEC_length (vec_void_p, stmt_vec_info_vec));
651 gcc_assert (uid2 <= VEC_length (vec_void_p, stmt_vec_info_vec));
652
653 if (uid1 > uid2)
654 return stmt1;
655 else
656 return stmt2;
657 }
658
659 /* Return TRUE if a statement represented by STMT_INFO is a part of a
660 pattern. */
678 661
679 static inline bool 662 static inline bool
680 is_pattern_stmt_p (stmt_vec_info stmt_info) 663 is_pattern_stmt_p (stmt_vec_info stmt_info)
681 { 664 {
682 gimple related_stmt; 665 gimple related_stmt;
689 return true; 672 return true;
690 673
691 return false; 674 return false;
692 } 675 }
693 676
677 /* Return true if BB is a loop header. */
678
694 static inline bool 679 static inline bool
695 is_loop_header_bb_p (basic_block bb) 680 is_loop_header_bb_p (basic_block bb)
696 { 681 {
697 if (bb == (bb->loop_father)->header) 682 if (bb == (bb->loop_father)->header)
698 return true; 683 return true;
699 gcc_assert (EDGE_COUNT (bb->preds) == 1); 684 gcc_checking_assert (EDGE_COUNT (bb->preds) == 1);
700 return false; 685 return false;
701 } 686 }
687
688 /* Set inside loop vectorization cost. */
702 689
703 static inline void 690 static inline void
704 stmt_vinfo_set_inside_of_loop_cost (stmt_vec_info stmt_info, slp_tree slp_node, 691 stmt_vinfo_set_inside_of_loop_cost (stmt_vec_info stmt_info, slp_tree slp_node,
705 int cost) 692 int cost)
706 { 693 {
708 SLP_TREE_INSIDE_OF_LOOP_COST (slp_node) = cost; 695 SLP_TREE_INSIDE_OF_LOOP_COST (slp_node) = cost;
709 else 696 else
710 STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info) = cost; 697 STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info) = cost;
711 } 698 }
712 699
700 /* Set inside loop vectorization cost. */
701
713 static inline void 702 static inline void
714 stmt_vinfo_set_outside_of_loop_cost (stmt_vec_info stmt_info, slp_tree slp_node, 703 stmt_vinfo_set_outside_of_loop_cost (stmt_vec_info stmt_info, slp_tree slp_node,
715 int cost) 704 int cost)
716 { 705 {
717 if (slp_node) 706 if (slp_node)
718 SLP_TREE_OUTSIDE_OF_LOOP_COST (slp_node) = cost; 707 SLP_TREE_OUTSIDE_OF_LOOP_COST (slp_node) = cost;
719 else 708 else
720 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info) = cost; 709 STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info) = cost;
721 } 710 }
722 711
712 /* Return pow2 (X). */
713
723 static inline int 714 static inline int
724 vect_pow2 (int x) 715 vect_pow2 (int x)
725 { 716 {
726 int i, res = 1; 717 int i, res = 1;
727 718
738 /* Reflects actual alignment of first access in the vectorized loop, 729 /* Reflects actual alignment of first access in the vectorized loop,
739 taking into account peeling/versioning if applied. */ 730 taking into account peeling/versioning if applied. */
740 #define DR_MISALIGNMENT(DR) ((int) (size_t) (DR)->aux) 731 #define DR_MISALIGNMENT(DR) ((int) (size_t) (DR)->aux)
741 #define SET_DR_MISALIGNMENT(DR, VAL) ((DR)->aux = (void *) (size_t) (VAL)) 732 #define SET_DR_MISALIGNMENT(DR, VAL) ((DR)->aux = (void *) (size_t) (VAL))
742 733
734 /* Return TRUE if the data access is aligned, and FALSE otherwise. */
735
743 static inline bool 736 static inline bool
744 aligned_access_p (struct data_reference *data_ref_info) 737 aligned_access_p (struct data_reference *data_ref_info)
745 { 738 {
746 return (DR_MISALIGNMENT (data_ref_info) == 0); 739 return (DR_MISALIGNMENT (data_ref_info) == 0);
747 } 740 }
741
742 /* Return TRUE if the alignment of the data access is known, and FALSE
743 otherwise. */
748 744
749 static inline bool 745 static inline bool
750 known_alignment_for_access_p (struct data_reference *data_ref_info) 746 known_alignment_for_access_p (struct data_reference *data_ref_info)
751 { 747 {
752 return (DR_MISALIGNMENT (data_ref_info) != -1); 748 return (DR_MISALIGNMENT (data_ref_info) != -1);
770 extern void vect_do_peeling_for_alignment (loop_vec_info); 766 extern void vect_do_peeling_for_alignment (loop_vec_info);
771 extern LOC find_loop_location (struct loop *); 767 extern LOC find_loop_location (struct loop *);
772 extern bool vect_can_advance_ivs_p (loop_vec_info); 768 extern bool vect_can_advance_ivs_p (loop_vec_info);
773 769
774 /* In tree-vect-stmts.c. */ 770 /* In tree-vect-stmts.c. */
771 extern unsigned int current_vector_size;
775 extern tree get_vectype_for_scalar_type (tree); 772 extern tree get_vectype_for_scalar_type (tree);
776 extern tree get_same_sized_vectype (tree, tree); 773 extern tree get_same_sized_vectype (tree, tree);
777 extern bool vect_is_simple_use (tree, loop_vec_info, bb_vec_info, gimple *, 774 extern bool vect_is_simple_use (tree, loop_vec_info, bb_vec_info, gimple *,
778 tree *, enum vect_def_type *); 775 tree *, enum vect_def_type *);
779 extern bool vect_is_simple_use_1 (tree, loop_vec_info, bb_vec_info, gimple *, 776 extern bool vect_is_simple_use_1 (tree, loop_vec_info, bb_vec_info, gimple *,
806 bool *, slp_tree, slp_instance); 803 bool *, slp_tree, slp_instance);
807 extern void vect_remove_stores (gimple); 804 extern void vect_remove_stores (gimple);
808 extern bool vect_analyze_stmt (gimple, bool *, slp_tree); 805 extern bool vect_analyze_stmt (gimple, bool *, slp_tree);
809 extern bool vectorizable_condition (gimple, gimple_stmt_iterator *, gimple *, 806 extern bool vectorizable_condition (gimple, gimple_stmt_iterator *, gimple *,
810 tree, int); 807 tree, int);
808 extern void vect_get_load_cost (struct data_reference *, int, bool,
809 unsigned int *, unsigned int *);
810 extern void vect_get_store_cost (struct data_reference *, int, unsigned int *);
811 811
812 /* In tree-vect-data-refs.c. */ 812 /* In tree-vect-data-refs.c. */
813 extern bool vect_can_force_dr_alignment_p (const_tree, unsigned int); 813 extern bool vect_can_force_dr_alignment_p (const_tree, unsigned int);
814 extern enum dr_alignment_support vect_supportable_dr_alignment 814 extern enum dr_alignment_support vect_supportable_dr_alignment
815 (struct data_reference *); 815 (struct data_reference *, bool);
816 extern tree vect_get_smallest_scalar_type (gimple, HOST_WIDE_INT *, 816 extern tree vect_get_smallest_scalar_type (gimple, HOST_WIDE_INT *,
817 HOST_WIDE_INT *); 817 HOST_WIDE_INT *);
818 extern bool vect_analyze_data_ref_dependences (loop_vec_info, bb_vec_info, 818 extern bool vect_analyze_data_ref_dependences (loop_vec_info, bb_vec_info,
819 int *); 819 int *, bool *);
820 extern bool vect_enhance_data_refs_alignment (loop_vec_info); 820 extern bool vect_enhance_data_refs_alignment (loop_vec_info);
821 extern bool vect_analyze_data_refs_alignment (loop_vec_info, bb_vec_info); 821 extern bool vect_analyze_data_refs_alignment (loop_vec_info, bb_vec_info);
822 extern bool vect_verify_datarefs_alignment (loop_vec_info, bb_vec_info); 822 extern bool vect_verify_datarefs_alignment (loop_vec_info, bb_vec_info);
823 extern bool vect_analyze_data_ref_accesses (loop_vec_info, bb_vec_info); 823 extern bool vect_analyze_data_ref_accesses (loop_vec_info, bb_vec_info);
824 extern bool vect_prune_runtime_alias_test_list (loop_vec_info); 824 extern bool vect_prune_runtime_alias_test_list (loop_vec_info);
858 slp_tree); 858 slp_tree);
859 extern bool vectorizable_induction (gimple, gimple_stmt_iterator *, gimple *); 859 extern bool vectorizable_induction (gimple, gimple_stmt_iterator *, gimple *);
860 extern int vect_estimate_min_profitable_iters (loop_vec_info); 860 extern int vect_estimate_min_profitable_iters (loop_vec_info);
861 extern tree get_initial_def_for_reduction (gimple, tree, tree *); 861 extern tree get_initial_def_for_reduction (gimple, tree, tree *);
862 extern int vect_min_worthwhile_factor (enum tree_code); 862 extern int vect_min_worthwhile_factor (enum tree_code);
863 863 extern int vect_get_known_peeling_cost (loop_vec_info, int, int *, int);
864 extern int vect_get_single_scalar_iteraion_cost (loop_vec_info);
864 865
865 /* In tree-vect-slp.c. */ 866 /* In tree-vect-slp.c. */
866 extern void vect_free_slp_instance (slp_instance); 867 extern void vect_free_slp_instance (slp_instance);
867 extern bool vect_transform_slp_perm_load (gimple, VEC (tree, heap) *, 868 extern bool vect_transform_slp_perm_load (gimple, VEC (tree, heap) *,
868 gimple_stmt_iterator *, int, 869 gimple_stmt_iterator *, int,
870 extern bool vect_schedule_slp (loop_vec_info, bb_vec_info); 871 extern bool vect_schedule_slp (loop_vec_info, bb_vec_info);
871 extern void vect_update_slp_costs_according_to_vf (loop_vec_info); 872 extern void vect_update_slp_costs_according_to_vf (loop_vec_info);
872 extern bool vect_analyze_slp (loop_vec_info, bb_vec_info); 873 extern bool vect_analyze_slp (loop_vec_info, bb_vec_info);
873 extern void vect_make_slp_decision (loop_vec_info); 874 extern void vect_make_slp_decision (loop_vec_info);
874 extern void vect_detect_hybrid_slp (loop_vec_info); 875 extern void vect_detect_hybrid_slp (loop_vec_info);
875 extern void vect_get_slp_defs (slp_tree, VEC (tree,heap) **, 876 extern void vect_get_slp_defs (tree, tree, slp_tree, VEC (tree,heap) **,
876 VEC (tree,heap) **, int); 877 VEC (tree,heap) **, int);
877 extern LOC find_bb_location (basic_block); 878 extern LOC find_bb_location (basic_block);
878 extern bb_vec_info vect_slp_analyze_bb (basic_block); 879 extern bb_vec_info vect_slp_analyze_bb (basic_block);
879 extern void vect_slp_transform_bb (basic_block); 880 extern void vect_slp_transform_bb (basic_block);
880 881
887 void vect_pattern_recog (loop_vec_info); 888 void vect_pattern_recog (loop_vec_info);
888 889
889 /* In tree-vectorizer.c. */ 890 /* In tree-vectorizer.c. */
890 unsigned vectorize_loops (void); 891 unsigned vectorize_loops (void);
891 /* Vectorization debug information */ 892 /* Vectorization debug information */
892 extern bool vect_print_dump_info (enum verbosity_levels); 893 extern bool vect_print_dump_info (enum vect_verbosity_levels);
893 894
894 #endif /* GCC_TREE_VECTORIZER_H */ 895 #endif /* GCC_TREE_VECTORIZER_H */