1 /* Analysis Utilities for Loop Vectorization.
2 Copyright (C) 2006, 2007 Free Software Foundation, Inc.
3 Contributed by Dorit Nuzman <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 2, 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 COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
24 #include "coretypes.h"
30 #include "basic-block.h"
31 #include "diagnostic.h"
32 #include "tree-flow.h"
33 #include "tree-dump.h"
39 #include "tree-data-ref.h"
40 #include "tree-vectorizer.h"
44 /* Function prototypes */
45 static void vect_pattern_recog_1
46 (tree (* ) (tree, tree *, tree *), block_stmt_iterator);
47 static bool widened_name_p (tree, tree, tree *, tree *);
49 /* Pattern recognition functions */
50 static tree vect_recog_widen_sum_pattern (tree, tree *, tree *);
51 static tree vect_recog_widen_mult_pattern (tree, tree *, tree *);
52 static tree vect_recog_dot_prod_pattern (tree, tree *, tree *);
53 static tree vect_recog_pow_pattern (tree, tree *, tree *);
54 static vect_recog_func_ptr vect_vect_recog_func_ptrs[NUM_PATTERNS] = {
55 vect_recog_widen_mult_pattern,
56 vect_recog_widen_sum_pattern,
57 vect_recog_dot_prod_pattern,
58 vect_recog_pow_pattern};
61 /* Function widened_name_p
63 Check whether NAME, an ssa-name used in USE_STMT,
64 is a result of a type-promotion, such that:
65 DEF_STMT: NAME = NOP (name0)
66 where the type of name0 (HALF_TYPE) is smaller than the type of NAME.
70 widened_name_p (tree name, tree use_stmt, tree *half_type, tree *def_stmt)
73 loop_vec_info loop_vinfo;
74 stmt_vec_info stmt_vinfo;
76 tree type = TREE_TYPE (name);
78 enum vect_def_type dt;
81 stmt_vinfo = vinfo_for_stmt (use_stmt);
82 loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
84 if (!vect_is_simple_use (name, loop_vinfo, def_stmt, &def, &dt))
87 if (dt != vect_loop_def
88 && dt != vect_invariant_def && dt != vect_constant_def)
94 if (TREE_CODE (*def_stmt) != GIMPLE_MODIFY_STMT)
97 expr = GIMPLE_STMT_OPERAND (*def_stmt, 1);
98 if (TREE_CODE (expr) != NOP_EXPR)
101 oprnd0 = TREE_OPERAND (expr, 0);
103 *half_type = TREE_TYPE (oprnd0);
104 if (!INTEGRAL_TYPE_P (type) || !INTEGRAL_TYPE_P (*half_type)
105 || (TYPE_UNSIGNED (type) != TYPE_UNSIGNED (*half_type))
106 || (TYPE_PRECISION (type) < (TYPE_PRECISION (*half_type) * 2)))
109 if (!vect_is_simple_use (oprnd0, loop_vinfo, &dummy, &dummy, &dt))
116 /* Function vect_recog_dot_prod_pattern
118 Try to find the following pattern:
124 sum_0 = phi <init, sum_1>
127 S3 x_T = (TYPE1) x_t;
128 S4 y_T = (TYPE1) y_t;
130 [S6 prod = (TYPE2) prod; #optional]
131 S7 sum_1 = prod + sum_0;
133 where 'TYPE1' is exactly double the size of type 'type', and 'TYPE2' is the
134 same size of 'TYPE1' or bigger. This is a special case of a reduction
139 * LAST_STMT: A stmt from which the pattern search begins. In the example,
140 when this function is called with S7, the pattern {S3,S4,S5,S6,S7} will be
145 * TYPE_IN: The type of the input arguments to the pattern.
147 * TYPE_OUT: The type of the output of this pattern.
149 * Return value: A new stmt that will be used to replace the sequence of
150 stmts that constitute the pattern. In this case it will be:
151 WIDEN_DOT_PRODUCT <x_t, y_t, sum_0>
155 vect_recog_dot_prod_pattern (tree last_stmt, tree *type_in, tree *type_out)
159 tree oprnd00, oprnd01;
160 stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt);
161 tree type, half_type;
165 if (TREE_CODE (last_stmt) != GIMPLE_MODIFY_STMT)
168 expr = GIMPLE_STMT_OPERAND (last_stmt, 1);
169 type = TREE_TYPE (expr);
171 /* Look for the following pattern
175 DDPROD = (TYPE2) DPROD;
176 sum_1 = DDPROD + sum_0;
178 - DX is double the size of X
179 - DY is double the size of Y
180 - DX, DY, DPROD all have the same type
181 - sum is the same size of DPROD or bigger
182 - sum has been recognized as a reduction variable.
184 This is equivalent to:
185 DPROD = X w* Y; #widen mult
186 sum_1 = DPROD w+ sum_0; #widen summation
188 DPROD = X w* Y; #widen mult
189 sum_1 = DPROD + sum_0; #summation
192 /* Starting from LAST_STMT, follow the defs of its uses in search
193 of the above pattern. */
195 if (TREE_CODE (expr) != PLUS_EXPR)
198 if (STMT_VINFO_IN_PATTERN_P (stmt_vinfo))
200 /* Has been detected as widening-summation? */
202 stmt = STMT_VINFO_RELATED_STMT (stmt_vinfo);
203 expr = GIMPLE_STMT_OPERAND (stmt, 1);
204 type = TREE_TYPE (expr);
205 if (TREE_CODE (expr) != WIDEN_SUM_EXPR)
207 oprnd0 = TREE_OPERAND (expr, 0);
208 oprnd1 = TREE_OPERAND (expr, 1);
209 half_type = TREE_TYPE (oprnd0);
215 if (STMT_VINFO_DEF_TYPE (stmt_vinfo) != vect_reduction_def)
217 oprnd0 = TREE_OPERAND (expr, 0);
218 oprnd1 = TREE_OPERAND (expr, 1);
219 if (TYPE_MAIN_VARIANT (TREE_TYPE (oprnd0)) != TYPE_MAIN_VARIANT (type)
220 || TYPE_MAIN_VARIANT (TREE_TYPE (oprnd1)) != TYPE_MAIN_VARIANT (type))
224 if (widened_name_p (oprnd0, stmt, &half_type, &def_stmt))
227 expr = GIMPLE_STMT_OPERAND (stmt, 1);
228 oprnd0 = TREE_OPERAND (expr, 0);
234 /* So far so good. Since last_stmt was detected as a (summation) reduction,
235 we know that oprnd1 is the reduction variable (defined by a loop-header
236 phi), and oprnd0 is an ssa-name defined by a stmt in the loop body.
237 Left to check that oprnd0 is defined by a (widen_)mult_expr */
239 prod_type = half_type;
240 stmt = SSA_NAME_DEF_STMT (oprnd0);
242 stmt_vinfo = vinfo_for_stmt (stmt);
243 gcc_assert (stmt_vinfo);
244 if (STMT_VINFO_DEF_TYPE (stmt_vinfo) != vect_loop_def)
246 expr = GIMPLE_STMT_OPERAND (stmt, 1);
247 if (TREE_CODE (expr) != MULT_EXPR)
249 if (STMT_VINFO_IN_PATTERN_P (stmt_vinfo))
251 /* Has been detected as a widening multiplication? */
253 stmt = STMT_VINFO_RELATED_STMT (stmt_vinfo);
254 expr = GIMPLE_STMT_OPERAND (stmt, 1);
255 if (TREE_CODE (expr) != WIDEN_MULT_EXPR)
257 stmt_vinfo = vinfo_for_stmt (stmt);
258 gcc_assert (stmt_vinfo);
259 gcc_assert (STMT_VINFO_DEF_TYPE (stmt_vinfo) == vect_loop_def);
260 oprnd00 = TREE_OPERAND (expr, 0);
261 oprnd01 = TREE_OPERAND (expr, 1);
265 tree half_type0, half_type1;
269 oprnd0 = TREE_OPERAND (expr, 0);
270 oprnd1 = TREE_OPERAND (expr, 1);
271 if (TYPE_MAIN_VARIANT (TREE_TYPE (oprnd0))
272 != TYPE_MAIN_VARIANT (prod_type)
273 || TYPE_MAIN_VARIANT (TREE_TYPE (oprnd1))
274 != TYPE_MAIN_VARIANT (prod_type))
276 if (!widened_name_p (oprnd0, stmt, &half_type0, &def_stmt))
278 oprnd00 = TREE_OPERAND (GIMPLE_STMT_OPERAND (def_stmt, 1), 0);
279 if (!widened_name_p (oprnd1, stmt, &half_type1, &def_stmt))
281 oprnd01 = TREE_OPERAND (GIMPLE_STMT_OPERAND (def_stmt, 1), 0);
282 if (TYPE_MAIN_VARIANT (half_type0) != TYPE_MAIN_VARIANT (half_type1))
284 if (TYPE_PRECISION (prod_type) != TYPE_PRECISION (half_type0) * 2)
288 half_type = TREE_TYPE (oprnd00);
289 *type_in = half_type;
292 /* Pattern detected. Create a stmt to be used to replace the pattern: */
293 pattern_expr = build3 (DOT_PROD_EXPR, type, oprnd00, oprnd01, oprnd1);
294 if (vect_print_dump_info (REPORT_DETAILS))
296 fprintf (vect_dump, "vect_recog_dot_prod_pattern: detected: ");
297 print_generic_expr (vect_dump, pattern_expr, TDF_SLIM);
303 /* Function vect_recog_widen_mult_pattern
305 Try to find the following pattern:
308 TYPE a_T, b_T, prod_T;
314 S5 prod_T = a_T * b_T;
316 where type 'TYPE' is at least double the size of type 'type'.
320 * LAST_STMT: A stmt from which the pattern search begins. In the example,
321 when this function is called with S5, the pattern {S3,S4,S5} is be detected.
325 * TYPE_IN: The type of the input arguments to the pattern.
327 * TYPE_OUT: The type of the output of this pattern.
329 * Return value: A new stmt that will be used to replace the sequence of
330 stmts that constitute the pattern. In this case it will be:
331 WIDEN_MULT <a_t, b_t>
335 vect_recog_widen_mult_pattern (tree last_stmt,
340 tree def_stmt0, def_stmt1;
342 tree type, half_type0, half_type1;
346 enum tree_code dummy_code;
348 if (TREE_CODE (last_stmt) != GIMPLE_MODIFY_STMT)
351 expr = GIMPLE_STMT_OPERAND (last_stmt, 1);
352 type = TREE_TYPE (expr);
354 /* Starting from LAST_STMT, follow the defs of its uses in search
355 of the above pattern. */
357 if (TREE_CODE (expr) != MULT_EXPR)
360 oprnd0 = TREE_OPERAND (expr, 0);
361 oprnd1 = TREE_OPERAND (expr, 1);
362 if (TYPE_MAIN_VARIANT (TREE_TYPE (oprnd0)) != TYPE_MAIN_VARIANT (type)
363 || TYPE_MAIN_VARIANT (TREE_TYPE (oprnd1)) != TYPE_MAIN_VARIANT (type))
366 /* Check argument 0 */
367 if (!widened_name_p (oprnd0, last_stmt, &half_type0, &def_stmt0))
369 oprnd0 = TREE_OPERAND (GIMPLE_STMT_OPERAND (def_stmt0, 1), 0);
371 /* Check argument 1 */
372 if (!widened_name_p (oprnd1, last_stmt, &half_type1, &def_stmt1))
374 oprnd1 = TREE_OPERAND (GIMPLE_STMT_OPERAND (def_stmt1, 1), 0);
376 if (TYPE_MAIN_VARIANT (half_type0) != TYPE_MAIN_VARIANT (half_type1))
379 /* Pattern detected. */
380 if (vect_print_dump_info (REPORT_DETAILS))
381 fprintf (vect_dump, "vect_recog_widen_mult_pattern: detected: ");
383 /* Check target support */
384 vectype = get_vectype_for_scalar_type (half_type0);
386 || !supportable_widening_operation (WIDEN_MULT_EXPR, last_stmt, vectype,
387 &dummy, &dummy, &dummy_code,
392 *type_out = NULL_TREE;
394 /* Pattern supported. Create a stmt to be used to replace the pattern: */
395 pattern_expr = build2 (WIDEN_MULT_EXPR, type, oprnd0, oprnd1);
396 if (vect_print_dump_info (REPORT_DETAILS))
397 print_generic_expr (vect_dump, pattern_expr, TDF_SLIM);
402 /* Function vect_recog_pow_pattern
404 Try to find the following pattern:
408 with POW being one of pow, powf, powi, powif and N being
413 * LAST_STMT: A stmt from which the pattern search begins.
417 * TYPE_IN: The type of the input arguments to the pattern.
419 * TYPE_OUT: The type of the output of this pattern.
421 * Return value: A new stmt that will be used to replace the sequence of
422 stmts that constitute the pattern. In this case it will be:
429 vect_recog_pow_pattern (tree last_stmt, tree *type_in, tree *type_out)
435 if (TREE_CODE (last_stmt) != GIMPLE_MODIFY_STMT)
438 expr = GIMPLE_STMT_OPERAND (last_stmt, 1);
439 type = TREE_TYPE (expr);
441 if (TREE_CODE (expr) != CALL_EXPR)
444 fn = get_callee_fndecl (expr);
445 switch (DECL_FUNCTION_CODE (fn))
451 base = CALL_EXPR_ARG (expr, 0);
452 exp = CALL_EXPR_ARG (expr, 1);
453 if (TREE_CODE (exp) != REAL_CST
454 && TREE_CODE (exp) != INTEGER_CST)
462 /* We now have a pow or powi builtin function call with a constant
465 *type_out = NULL_TREE;
467 /* Catch squaring. */
468 if ((host_integerp (exp, 0)
469 && tree_low_cst (exp, 0) == 2)
470 || (TREE_CODE (exp) == REAL_CST
471 && REAL_VALUES_EQUAL (TREE_REAL_CST (exp), dconst2)))
473 *type_in = TREE_TYPE (base);
474 return build2 (MULT_EXPR, TREE_TYPE (base), base, base);
477 /* Catch square root. */
478 if (TREE_CODE (exp) == REAL_CST
479 && REAL_VALUES_EQUAL (TREE_REAL_CST (exp), dconsthalf))
481 tree newfn = mathfn_built_in (TREE_TYPE (base), BUILT_IN_SQRT);
482 *type_in = get_vectype_for_scalar_type (TREE_TYPE (base));
485 newfn = build_call_expr (newfn, 1, base);
486 if (vectorizable_function (newfn, *type_in, *type_in) != NULL_TREE)
495 /* Function vect_recog_widen_sum_pattern
497 Try to find the following pattern:
500 TYPE x_T, sum = init;
502 sum_0 = phi <init, sum_1>
505 S3 sum_1 = x_T + sum_0;
507 where type 'TYPE' is at least double the size of type 'type', i.e - we're
508 summing elements of type 'type' into an accumulator of type 'TYPE'. This is
509 a special case of a reduction computation.
513 * LAST_STMT: A stmt from which the pattern search begins. In the example,
514 when this function is called with S3, the pattern {S2,S3} will be detected.
518 * TYPE_IN: The type of the input arguments to the pattern.
520 * TYPE_OUT: The type of the output of this pattern.
522 * Return value: A new stmt that will be used to replace the sequence of
523 stmts that constitute the pattern. In this case it will be:
524 WIDEN_SUM <x_t, sum_0>
528 vect_recog_widen_sum_pattern (tree last_stmt, tree *type_in, tree *type_out)
532 stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt);
533 tree type, half_type;
536 if (TREE_CODE (last_stmt) != GIMPLE_MODIFY_STMT)
539 expr = GIMPLE_STMT_OPERAND (last_stmt, 1);
540 type = TREE_TYPE (expr);
542 /* Look for the following pattern
545 In which DX is at least double the size of X, and sum_1 has been
546 recognized as a reduction variable.
549 /* Starting from LAST_STMT, follow the defs of its uses in search
550 of the above pattern. */
552 if (TREE_CODE (expr) != PLUS_EXPR)
555 if (STMT_VINFO_DEF_TYPE (stmt_vinfo) != vect_reduction_def)
558 oprnd0 = TREE_OPERAND (expr, 0);
559 oprnd1 = TREE_OPERAND (expr, 1);
560 if (TYPE_MAIN_VARIANT (TREE_TYPE (oprnd0)) != TYPE_MAIN_VARIANT (type)
561 || TYPE_MAIN_VARIANT (TREE_TYPE (oprnd1)) != TYPE_MAIN_VARIANT (type))
564 /* So far so good. Since last_stmt was detected as a (summation) reduction,
565 we know that oprnd1 is the reduction variable (defined by a loop-header
566 phi), and oprnd0 is an ssa-name defined by a stmt in the loop body.
567 Left to check that oprnd0 is defined by a cast from type 'type' to type
570 if (!widened_name_p (oprnd0, last_stmt, &half_type, &stmt))
573 oprnd0 = TREE_OPERAND (GIMPLE_STMT_OPERAND (stmt, 1), 0);
574 *type_in = half_type;
577 /* Pattern detected. Create a stmt to be used to replace the pattern: */
578 pattern_expr = build2 (WIDEN_SUM_EXPR, type, oprnd0, oprnd1);
579 if (vect_print_dump_info (REPORT_DETAILS))
581 fprintf (vect_dump, "vect_recog_widen_sum_pattern: detected: ");
582 print_generic_expr (vect_dump, pattern_expr, TDF_SLIM);
588 /* Function vect_pattern_recog_1
591 PATTERN_RECOG_FUNC: A pointer to a function that detects a certain
593 STMT: A stmt from which the pattern search should start.
595 If PATTERN_RECOG_FUNC successfully detected the pattern, it creates an
596 expression that computes the same functionality and can be used to
597 replace the sequence of stmts that are involved in the pattern.
600 This function checks if the expression returned by PATTERN_RECOG_FUNC is
601 supported in vector form by the target. We use 'TYPE_IN' to obtain the
602 relevant vector type. If 'TYPE_IN' is already a vector type, then this
603 indicates that target support had already been checked by PATTERN_RECOG_FUNC.
604 If 'TYPE_OUT' is also returned by PATTERN_RECOG_FUNC, we check that it fits
605 to the available target pattern.
607 This function also does some bookkeeping, as explained in the documentation
608 for vect_recog_pattern. */
611 vect_pattern_recog_1 (
612 tree (* vect_recog_func) (tree, tree *, tree *),
613 block_stmt_iterator si)
615 tree stmt = bsi_stmt (si);
616 stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
617 stmt_vec_info pattern_stmt_info;
618 loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
620 tree pattern_vectype;
621 tree type_in, type_out;
627 pattern_expr = (* vect_recog_func) (stmt, &type_in, &type_out);
631 if (VECTOR_MODE_P (TYPE_MODE (type_in)))
633 /* No need to check target support (already checked by the pattern
634 recognition function). */
635 pattern_vectype = type_in;
639 enum tree_code vec_mode;
640 enum insn_code icode;
643 /* Check target support */
644 pattern_vectype = get_vectype_for_scalar_type (type_in);
645 if (!pattern_vectype)
648 optab = optab_for_tree_code (TREE_CODE (pattern_expr), pattern_vectype);
649 vec_mode = TYPE_MODE (pattern_vectype);
651 || (icode = optab->handlers[(int) vec_mode].insn_code) ==
654 && (insn_data[icode].operand[0].mode !=
655 TYPE_MODE (get_vectype_for_scalar_type (type_out)))))
659 /* Found a vectorizable pattern. */
660 if (vect_print_dump_info (REPORT_DETAILS))
662 fprintf (vect_dump, "pattern recognized: ");
663 print_generic_expr (vect_dump, pattern_expr, TDF_SLIM);
666 /* Mark the stmts that are involved in the pattern,
667 create a new stmt to express the pattern and insert it. */
668 code = TREE_CODE (pattern_expr);
669 pattern_type = TREE_TYPE (pattern_expr);
670 var = create_tmp_var (pattern_type, "patt");
671 add_referenced_var (var);
672 var_name = make_ssa_name (var, NULL_TREE);
673 pattern_expr = build_gimple_modify_stmt (var_name, pattern_expr);
674 SSA_NAME_DEF_STMT (var_name) = pattern_expr;
675 bsi_insert_before (&si, pattern_expr, BSI_SAME_STMT);
676 ann = stmt_ann (pattern_expr);
677 set_stmt_info (ann, new_stmt_vec_info (pattern_expr, loop_vinfo));
678 pattern_stmt_info = vinfo_for_stmt (pattern_expr);
680 STMT_VINFO_RELATED_STMT (pattern_stmt_info) = stmt;
681 STMT_VINFO_DEF_TYPE (pattern_stmt_info) = STMT_VINFO_DEF_TYPE (stmt_info);
682 STMT_VINFO_VECTYPE (pattern_stmt_info) = pattern_vectype;
683 STMT_VINFO_IN_PATTERN_P (stmt_info) = true;
684 STMT_VINFO_RELATED_STMT (stmt_info) = pattern_expr;
690 /* Function vect_pattern_recog
693 LOOP_VINFO - a struct_loop_info of a loop in which we want to look for
696 Output - for each computation idiom that is detected we insert a new stmt
697 that provides the same functionality and that can be vectorized. We
698 also record some information in the struct_stmt_info of the relevant
699 stmts, as explained below:
701 At the entry to this function we have the following stmts, with the
702 following initial value in the STMT_VINFO fields:
704 stmt in_pattern_p related_stmt vec_stmt
706 S2: a_2 = ..use(a_i).. - - -
707 S3: a_1 = ..use(a_2).. - - -
708 S4: a_0 = ..use(a_1).. - - -
709 S5: ... = ..use(a_0).. - - -
711 Say the sequence {S1,S2,S3,S4} was detected as a pattern that can be
712 represented by a single stmt. We then:
713 - create a new stmt S6 that will replace the pattern.
714 - insert the new stmt S6 before the last stmt in the pattern
715 - fill in the STMT_VINFO fields as follows:
717 in_pattern_p related_stmt vec_stmt
719 S2: a_2 = ..use(a_i).. - - -
720 S3: a_1 = ..use(a_2).. - - -
721 > S6: a_new = .... - S4 -
722 S4: a_0 = ..use(a_1).. true S6 -
723 S5: ... = ..use(a_0).. - - -
725 (the last stmt in the pattern (S4) and the new pattern stmt (S6) point
726 to each other through the RELATED_STMT field).
728 S6 will be marked as relevant in vect_mark_stmts_to_be_vectorized instead
729 of S4 because it will replace all its uses. Stmts {S1,S2,S3} will
730 remain irrelevant unless used by stmts other than S4.
732 If vectorization succeeds, vect_transform_stmt will skip over {S1,S2,S3}
733 (because they are marked as irrelevant). It will vectorize S6, and record
734 a pointer to the new vector stmt VS6 both from S6 (as usual), and also
735 from S4. We do that so that when we get to vectorizing stmts that use the
736 def of S4 (like S5 that uses a_0), we'll know where to take the relevant
737 vector-def from. S4 will be skipped, and S5 will be vectorized as usual:
739 in_pattern_p related_stmt vec_stmt
741 S2: a_2 = ..use(a_i).. - - -
742 S3: a_1 = ..use(a_2).. - - -
743 > VS6: va_new = .... - - -
744 S6: a_new = .... - S4 VS6
745 S4: a_0 = ..use(a_1).. true S6 VS6
746 > VS5: ... = ..vuse(va_new).. - - -
747 S5: ... = ..use(a_0).. - - -
749 DCE could then get rid of {S1,S2,S3,S4,S5,S6} (if their defs are not used
750 elsewhere), and we'll end up with:
753 VS5: ... = ..vuse(va_new)..
755 If vectorization does not succeed, DCE will clean S6 away (its def is
756 not used), and we'll end up with the original sequence.
760 vect_pattern_recog (loop_vec_info loop_vinfo)
762 struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
763 basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
764 unsigned int nbbs = loop->num_nodes;
765 block_stmt_iterator si;
768 tree (* vect_recog_func_ptr) (tree, tree *, tree *);
770 if (vect_print_dump_info (REPORT_DETAILS))
771 fprintf (vect_dump, "=== vect_pattern_recog ===");
773 /* Scan through the loop stmts, applying the pattern recognition
774 functions starting at each stmt visited: */
775 for (i = 0; i < nbbs; i++)
777 basic_block bb = bbs[i];
778 for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
780 stmt = bsi_stmt (si);
782 /* Scan over all generic vect_recog_xxx_pattern functions. */
783 for (j = 0; j < NUM_PATTERNS; j++)
785 vect_recog_func_ptr = vect_vect_recog_func_ptrs[j];
786 vect_pattern_recog_1 (vect_recog_func_ptr, si);