| blob | 7cdabe1106bed343611f1f8560759318a7686840 |
1 /* Statement Analysis and Transformation for Vectorization
2 Copyright (C) 2003-2018 Free Software Foundation, Inc.
3 Contributed by Dorit Naishlos <dorit@il.ibm.com>
4 and Ira Rosen <irar@il.ibm.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
56 /* For lang_hooks.types.type_for_mode. */
59 /* Return the vectorized type for the given statement. */
61 tree
63 {
65 }
67 /* Return TRUE iff the given statement is in an inner loop relative to
68 the loop being vectorized. */
69 bool
71 {
83 }
85 /* Record the cost of a statement, either by directly informing the
86 target model or by saving it in a vector for later processing.
87 Return a preliminary estimate of the statement's cost. */
89 unsigned
93 {
101 {
105 misalign };
109 }
110 else
113 }
115 /* Return a variable of type ELEM_TYPE[NELEMS]. */
117 static tree
119 {
122 }
124 /* ARRAY is an array of vectors created by create_vector_array.
125 Return an SSA_NAME for the vector in index N. The reference
126 is part of the vectorization of STMT and the vector is associated
127 with scalar destination SCALAR_DEST. */
129 static tree
132 {
149 }
151 /* ARRAY is an array of vectors created by create_vector_array.
152 Emit code to store SSA_NAME VECT in index N of the array.
153 The store is part of the vectorization of STMT. */
155 static void
158 {
159 tree array_ref;
168 }
170 /* PTR is a pointer to an array of type TYPE. Return a representation
171 of *PTR. The memory reference replaces those in FIRST_DR
172 (and its group). */
174 static tree
176 {
177 tree mem_ref;
180 /* Arrays have the same alignment as their type. */
183 }
185 /* Utility functions used by vect_mark_stmts_to_be_vectorized. */
187 /* Function vect_mark_relevant.
189 Mark STMT as "relevant for vectorization" and add it to WORKLIST. */
191 static void
194 {
201 {
205 }
207 /* If this stmt is an original stmt in a pattern, we might need to mark its
208 related pattern stmt instead of the original stmt. However, such stmts
209 may have their own uses that are not in any pattern, in such cases the
210 stmt itself should be marked. */
212 {
213 /* This is the last stmt in a sequence that was detected as a
214 pattern that can potentially be vectorized. Don't mark the stmt
215 as relevant/live because it's not going to be vectorized.
216 Instead mark the pattern-stmt that replaces it. */
222 "last stmt in pattern. don't mark"
229 }
237 {
242 }
245 }
248 /* Function is_simple_and_all_uses_invariant
250 Return true if STMT is simple and all uses of it are invariant. */
252 bool
254 {
255 tree op;
257 ssa_op_iter iter;
263 {
267 {
272 }
276 }
278 }
280 /* Function vect_stmt_relevant_p.
282 Return true if STMT in loop that is represented by LOOP_VINFO is
283 "relevant for vectorization".
285 A stmt is considered "relevant for vectorization" if:
286 - it has uses outside the loop.
287 - it has vdefs (it alters memory).
288 - control stmts in the loop (except for the exit condition).
290 CHECKME: what other side effects would the vectorizer allow? */
292 static bool
295 {
297 ssa_op_iter op_iter;
298 imm_use_iterator imm_iter;
299 use_operand_p use_p;
300 def_operand_p def_p;
305 /* cond stmt other than loop exit cond. */
311 /* changing memory. */
315 {
320 }
322 /* uses outside the loop. */
324 {
326 {
329 {
337 /* We expect all such uses to be in the loop exit phis
338 (because of loop closed form) */
343 }
344 }
345 }
349 {
354 }
357 }
360 /* Function exist_non_indexing_operands_for_use_p
362 USE is one of the uses attached to STMT. Check if USE is
363 used in STMT for anything other than indexing an array. */
365 static bool
367 {
368 tree operand;
371 /* USE corresponds to some operand in STMT. If there is no data
372 reference in STMT, then any operand that corresponds to USE
373 is not indexing an array. */
377 /* STMT has a data_ref. FORNOW this means that its of one of
378 the following forms:
379 -1- ARRAY_REF = var
380 -2- var = ARRAY_REF
381 (This should have been verified in analyze_data_refs).
383 'var' in the second case corresponds to a def, not a use,
384 so USE cannot correspond to any operands that are not used
385 for array indexing.
387 Therefore, all we need to check is if STMT falls into the
388 first case, and whether var corresponds to USE. */
391 {
394 {
407 }
409 }
421 }
424 /*
425 Function process_use.
427 Inputs:
428 - a USE in STMT in a loop represented by LOOP_VINFO
429 - RELEVANT - enum value to be set in the STMT_VINFO of the stmt
430 that defined USE. This is done by calling mark_relevant and passing it
431 the WORKLIST (to add DEF_STMT to the WORKLIST in case it is relevant).
432 - FORCE is true if exist_non_indexing_operands_for_use_p check shouldn't
433 be performed.
435 Outputs:
436 Generally, LIVE_P and RELEVANT are used to define the liveness and
437 relevance info of the DEF_STMT of this USE:
438 STMT_VINFO_LIVE_P (DEF_STMT_info) <-- live_p
439 STMT_VINFO_RELEVANT (DEF_STMT_info) <-- relevant
440 Exceptions:
441 - case 1: If USE is used only for address computations (e.g. array indexing),
442 which does not need to be directly vectorized, then the liveness/relevance
443 of the respective DEF_STMT is left unchanged.
444 - case 2: If STMT is a reduction phi and DEF_STMT is a reduction stmt, we
445 skip DEF_STMT cause it had already been processed.
446 - case 3: If DEF_STMT and STMT are in different nests, then "relevant" will
447 be modified accordingly.
449 Return true if everything is as expected. Return false otherwise. */
451 static bool
455 {
458 stmt_vec_info dstmt_vinfo;
463 /* case 1: we are only interested in uses that need to be vectorized. Uses
464 that are used for address computation are not considered relevant. */
469 {
474 }
481 {
485 }
487 /* case 2: A reduction phi (STMT) defined by a reduction stmt (DEF_STMT).
488 DEF_STMT must have already been processed, because this should be the
489 only way that STMT, which is a reduction-phi, was put in the worklist,
490 as there should be no other uses for DEF_STMT in the loop. So we just
491 check that everything is as expected, and we are done. */
499 {
509 }
511 /* case 3a: outer-loop stmt defining an inner-loop stmt:
512 outer-loop-header-bb:
513 d = def_stmt
514 inner-loop:
515 stmt # use (d)
516 outer-loop-tail-bb:
517 ... */
519 {
525 {
546 }
547 }
549 /* case 3b: inner-loop stmt defining an outer-loop stmt:
550 outer-loop-header-bb:
551 ...
552 inner-loop:
553 d = def_stmt
554 outer-loop-tail-bb (or outer-loop-exit-bb in double reduction):
555 stmt # use (d) */
557 {
563 {
581 }
582 }
583 /* We are also not interested in uses on loop PHI backedges that are
584 inductions. Otherwise we'll needlessly vectorize the IV increment
585 and cause hybrid SLP for SLP inductions. Unless the PHI is live
586 of course. */
592 {
597 }
602 }
605 /* Function vect_mark_stmts_to_be_vectorized.
607 Not all stmts in the loop need to be vectorized. For example:
609 for i...
610 for j...
611 1. T0 = i + j
612 2. T1 = a[T0]
614 3. j = j + 1
616 Stmt 1 and 3 do not need to be vectorized, because loop control and
617 addressing of vectorized data-refs are handled differently.
619 This pass detects such stmts. */
621 bool
623 {
627 gimple_stmt_iterator si;
630 stmt_vec_info stmt_vinfo;
631 basic_block bb;
642 /* 1. Init worklist. */
644 {
647 {
650 {
653 }
657 }
659 {
662 {
665 }
669 }
670 }
672 /* 2. Process_worklist */
674 {
675 use_operand_p use_p;
676 ssa_op_iter iter;
680 {
683 }
685 /* Examine the USEs of STMT. For each USE, mark the stmt that defines it
686 (DEF_STMT) as relevant/irrelevant according to the relevance property
687 of STMT. */
691 /* Generally, the relevance property of STMT (in STMT_VINFO_RELEVANT) is
692 propagated as is to the DEF_STMTs of its USEs.
694 One exception is when STMT has been identified as defining a reduction
695 variable; in this case we set the relevance to vect_used_by_reduction.
696 This is because we distinguish between two kinds of relevant stmts -
697 those that are used by a reduction computation, and those that are
698 (also) used by a regular computation. This allows us later on to
699 identify stmts that are used solely by a reduction, and therefore the
700 order of the results that they produce does not have to be kept. */
703 {
710 {
715 }
722 {
728 }
735 {
741 }
746 }
749 {
750 /* Pattern statements are not inserted into the code, so
751 FOR_EACH_PHI_OR_STMT_USE optimizes their operands out, and we
752 have to scan the RHS or function arguments instead. */
754 {
760 {
767 }
769 {
775 }
776 }
778 {
780 {
785 }
786 }
787 }
788 else
790 {
795 }
798 {
799 gather_scatter_info gs_info;
805 }
809 }
812 /* Function vect_model_simple_cost.
814 Models cost for simple operations, i.e. those that only emit ncopies of a
815 single op. Right now, this does not account for multiple insns that could
816 be generated for the single vector op. We will handle that shortly. */
818 void
824 {
828 /* The SLP costs were already calculated during SLP tree build. */
831 /* Cost the "broadcast" of a scalar operand in to a vector operand.
832 Use scalar_to_vec to cost the broadcast, as elsewhere in the vector
833 cost model. */
839 /* Pass the inside-of-loop statements to the target-specific cost model. */
845 "vect_model_simple_cost: inside_cost = %d, "
847 }
850 /* Model cost for type demotion and promotion operations. PWR is normally
851 zero for single-step promotions and demotions. It will be one if
852 two-step promotion/demotion is required, and so on. Each additional
853 step doubles the number of instructions required. */
855 static void
858 {
865 /* The SLP costs were already calculated during SLP tree build. */
870 else
874 {
879 vect_body);
880 }
882 /* FORNOW: Assuming maximum 2 args per stmts. */
890 "vect_model_promotion_demotion_cost: inside_cost = %d, "
892 }
894 /* Function vect_model_store_cost
896 Models cost for stores. In the case of grouped accesses, one access
897 has the overhead of the grouped access attributed to it. */
899 void
901 vect_memory_access_type memory_access_type,
905 {
915 /* Grouped stores update all elements in the group at once,
916 so we want the DR for the first statement. */
918 {
921 }
923 /* True if we should include any once-per-group costs as well as
924 the cost of the statement itself. For SLP we only get called
925 once per group anyhow. */
928 /* We assume that the cost of a single store-lanes instruction is
929 equivalent to the cost of GROUP_SIZE separate stores. If a grouped
930 access is instead being provided by a permute-and-store operation,
931 include the cost of the permutes. */
934 {
935 /* Uses a high and low interleave or shuffle operations for each
936 needed permute. */
945 group_size);
946 }
949 /* Costs of the stores. */
952 {
953 /* N scalar stores plus extracting the elements. */
958 }
959 else
964 {
965 /* N scalar stores plus extracting the elements. */
970 }
974 "vect_model_store_cost: inside_cost = %d, "
976 }
979 /* Calculate cost of DR's memory access. */
980 void
984 {
990 {
992 {
995 vect_body);
1001 }
1004 {
1005 /* Here, we assign an additional cost for the unaligned store. */
1011 "vect_model_store_cost: unaligned supported by "
1014 }
1017 {
1024 }
1028 }
1029 }
1032 /* Function vect_model_load_cost
1034 Models cost for loads. In the case of grouped accesses, one access has
1035 the overhead of the grouped access attributed to it. Since unaligned
1036 accesses are supported for loads, we also account for the costs of the
1037 access scheme chosen. */
1039 void
1041 vect_memory_access_type memory_access_type,
1042 slp_tree slp_node,
1045 {
1051 /* Grouped loads read all elements in the group at once,
1052 so we want the DR for the first statement. */
1054 {
1057 }
1059 /* True if we should include any once-per-group costs as well as
1060 the cost of the statement itself. For SLP we only get called
1061 once per group anyhow. */
1064 /* We assume that the cost of a single load-lanes instruction is
1065 equivalent to the cost of GROUP_SIZE separate loads. If a grouped
1066 access is instead being provided by a load-and-permute operation,
1067 include the cost of the permutes. */
1070 {
1071 /* Uses an even and odd extract operations or shuffle operations
1072 for each needed permute. */
1081 group_size);
1082 }
1084 /* The loads themselves. */
1087 {
1088 /* N scalar loads plus gathering them into a vector. */
1094 }
1095 else
1106 "vect_model_load_cost: inside_cost = %d, "
1108 }
1111 /* Calculate cost of DR's memory access. */
1112 void
1119 {
1125 {
1127 {
1136 }
1138 {
1139 /* Here, we assign an additional cost for the unaligned load. */
1146 "vect_model_load_cost: unaligned supported by "
1150 }
1152 {
1158 /* FIXME: If the misalignment remains fixed across the iterations of
1159 the containing loop, the following cost should be added to the
1160 prologue costs. */
1170 }
1172 {
1175 "vect_model_load_cost: unaligned software "
1178 /* Unaligned software pipeline has a load of an address, an initial
1179 load, and possibly a mask operation to "prime" the loop. However,
1180 if this is an access in a group of loads, which provide grouped
1181 access, then the above cost should only be considered for one
1182 access in the group. Inside the loop, there is a load op
1183 and a realignment op. */
1186 {
1194 }
1203 "vect_model_load_cost: explicit realign optimized"
1207 }
1210 {
1217 }
1221 }
1222 }
1224 /* Insert the new stmt NEW_STMT at *GSI or at the appropriate place in
1225 the loop preheader for the vectorized stmt STMT. */
1227 static void
1229 {
1232 else
1233 {
1238 {
1240 basic_block new_bb;
1241 edge pe;
1249 }
1250 else
1251 {
1253 basic_block bb;
1254 gimple_stmt_iterator gsi_bb_start;
1260 }
1261 }
1264 {
1268 }
1269 }
1271 /* Function vect_init_vector.
1273 Insert a new stmt (INIT_STMT) that initializes a new variable of type
1274 TYPE with the value VAL. If TYPE is a vector type and VAL does not have
1275 vector type a vector with all elements equal to VAL is created first.
1276 Place the initialization at BSI if it is not NULL. Otherwise, place the
1277 initialization at the loop preheader.
1278 Return the DEF of INIT_STMT.
1279 It will be used in the vectorization of STMT. */
1281 tree
1283 {
1285 tree new_temp;
1287 /* We abuse this function to push sth to a SSA name with initial 'val'. */
1289 {
1292 {
1293 /* Scalar boolean value should be transformed into
1294 all zeros or all ones value before building a vector. */
1296 {
1302 else
1303 {
1309 }
1310 }
1313 else
1314 {
1320 val));
1321 else
1325 }
1326 }
1328 }
1334 }
1336 /* Function vect_get_vec_def_for_operand_1.
1338 For a defining stmt DEF_STMT of a scalar stmt, return a vector def with type
1339 DT that will be used in the vectorized stmt. */
1341 tree
1343 {
1344 tree vec_oprnd;
1349 {
1350 /* operand is a constant or a loop invariant. */
1353 /* Code should use vect_get_vec_def_for_operand. */
1356 /* operand is defined inside the loop. */
1358 {
1359 /* Get the def from the vectorized stmt. */
1363 /* Get vectorized pattern statement. */
1374 else
1377 }
1379 /* operand is defined by a loop header phi. */
1384 {
1387 /* Get the def from the vectorized stmt. */
1392 else
1395 }
1399 }
1400 }
1403 /* Function vect_get_vec_def_for_operand.
1405 OP is an operand in STMT. This function returns a (vector) def that will be
1406 used in the vectorized stmt for STMT.
1408 In the case that OP is an SSA_NAME which is defined in the loop, then
1409 STMT_VINFO_VEC_STMT of the defining stmt holds the relevant def.
1411 In case OP is an invariant or constant, a new stmt that creates a vector def
1412 needs to be introduced. VECTYPE may be used to specify a required type for
1413 vector invariant. */
1415 tree
1417 {
1425 {
1430 }
1435 {
1438 }
1441 {
1443 tree vector_type;
1450 else
1455 }
1456 else
1458 }
1461 /* Function vect_get_vec_def_for_stmt_copy
1463 Return a vector-def for an operand. This function is used when the
1464 vectorized stmt to be created (by the caller to this function) is a "copy"
1465 created in case the vectorized result cannot fit in one vector, and several
1466 copies of the vector-stmt are required. In this case the vector-def is
1467 retrieved from the vector stmt recorded in the STMT_VINFO_RELATED_STMT field
1468 of the stmt that defines VEC_OPRND.
1469 DT is the type of the vector def VEC_OPRND.
1471 Context:
1472 In case the vectorization factor (VF) is bigger than the number
1473 of elements that can fit in a vectype (nunits), we have to generate
1474 more than one vector stmt to vectorize the scalar stmt. This situation
1475 arises when there are multiple data-types operated upon in the loop; the
1476 smallest data-type determines the VF, and as a result, when vectorizing
1477 stmts operating on wider types we need to create 'VF/nunits' "copies" of the
1478 vector stmt (each computing a vector of 'nunits' results, and together
1479 computing 'VF' results in each iteration). This function is called when
1480 vectorizing such a stmt (e.g. vectorizing S2 in the illustration below, in
1481 which VF=16 and nunits=4, so the number of copies required is 4):
1483 scalar stmt: vectorized into: STMT_VINFO_RELATED_STMT
1485 S1: x = load VS1.0: vx.0 = memref0 VS1.1
1486 VS1.1: vx.1 = memref1 VS1.2
1487 VS1.2: vx.2 = memref2 VS1.3
1488 VS1.3: vx.3 = memref3
1490 S2: z = x + ... VSnew.0: vz0 = vx.0 + ... VSnew.1
1491 VSnew.1: vz1 = vx.1 + ... VSnew.2
1492 VSnew.2: vz2 = vx.2 + ... VSnew.3
1493 VSnew.3: vz3 = vx.3 + ...
1495 The vectorization of S1 is explained in vectorizable_load.
1496 The vectorization of S2:
1497 To create the first vector-stmt out of the 4 copies - VSnew.0 -
1498 the function 'vect_get_vec_def_for_operand' is called to
1499 get the relevant vector-def for each operand of S2. For operand x it
1500 returns the vector-def 'vx.0'.
1502 To create the remaining copies of the vector-stmt (VSnew.j), this
1503 function is called to get the relevant vector-def for each operand. It is
1504 obtained from the respective VS1.j stmt, which is recorded in the
1505 STMT_VINFO_RELATED_STMT field of the stmt that defines VEC_OPRND.
1507 For example, to obtain the vector-def 'vx.1' in order to create the
1508 vector stmt 'VSnew.1', this function is called with VEC_OPRND='vx.0'.
1509 Given 'vx0' we obtain the stmt that defines it ('VS1.0'); from the
1510 STMT_VINFO_RELATED_STMT field of 'VS1.0' we obtain the next copy - 'VS1.1',
1511 and return its def ('vx.1').
1512 Overall, to create the above sequence this function will be called 3 times:
1513 vx.1 = vect_get_vec_def_for_stmt_copy (dt, vx.0);
1514 vx.2 = vect_get_vec_def_for_stmt_copy (dt, vx.1);
1515 vx.3 = vect_get_vec_def_for_stmt_copy (dt, vx.2); */
1517 tree
1519 {
1521 stmt_vec_info def_stmt_info;
1523 /* Do nothing; can reuse same def. */
1534 else
1537 }
1540 /* Get vectorized definitions for the operands to create a copy of an original
1541 stmt. See vect_get_vec_def_for_stmt_copy () for details. */
1543 void
1547 {
1554 {
1558 }
1559 }
1562 /* Get vectorized definitions for OP0 and OP1. */
1564 void
1568 slp_tree slp_node)
1569 {
1571 {
1585 }
1586 else
1587 {
1588 tree vec_oprnd;
1595 {
1599 }
1600 }
1601 }
1603 /* Helper function called by vect_finish_replace_stmt and
1604 vect_finish_stmt_generation. Set the location of the new
1605 statement and create a stmt_vec_info for it. */
1607 static void
1609 {
1616 {
1619 }
1623 /* While EH edges will generally prevent vectorization, stmt might
1624 e.g. be in a must-not-throw region. Ensure newly created stmts
1625 that could throw are part of the same region. */
1629 }
1631 /* Replace the scalar statement STMT with a new vector statement VEC_STMT,
1632 which sets the same scalar result as STMT did. */
1634 void
1636 {
1643 }
1645 /* Function vect_finish_stmt_generation.
1647 Insert a new stmt. */
1649 void
1652 {
1657 {
1661 {
1664 /* If we have an SSA vuse and insert a store, update virtual
1665 SSA form to avoid triggering the renamer. Do so only
1666 if we can easily see all uses - which is what almost always
1667 happens with the way vectorized stmts are inserted. */
1674 {
1678 }
1679 }
1680 }
1683 }
1685 /* We want to vectorize a call to combined function CFN with function
1686 decl FNDECL, using VECTYPE_OUT as the type of the output and VECTYPE_IN
1687 as the types of all inputs. Check whether this is possible using
1688 an internal function, returning its code if so or IFN_LAST if not. */
1690 static internal_fn
1693 {
1694 internal_fn ifn;
1697 else
1700 {
1703 {
1707 OPTIMIZE_FOR_SPEED))
1709 }
1710 }
1712 }
1716 gimple_stmt_iterator *);
1718 /* Check whether a load or store statement in the loop described by
1719 LOOP_VINFO is possible in a fully-masked loop. This is testing
1720 whether the vectorizer pass has the appropriate support, as well as
1721 whether the target does.
1723 VLS_TYPE says whether the statement is a load or store and VECTYPE
1724 is the type of the vector being loaded or stored. MEMORY_ACCESS_TYPE
1725 says how the load or store is going to be implemented and GROUP_SIZE
1726 is the number of load or store statements in the containing group.
1727 If the access is a gather load or scatter store, GS_INFO describes
1728 its arguments.
1730 Clear LOOP_VINFO_CAN_FULLY_MASK_P if a fully-masked loop is not
1731 supported, otherwise record the required mask types. */
1733 static void
1736 vect_memory_access_type memory_access_type,
1738 {
1739 /* Invariant loads need no special support. */
1747 {
1751 {
1754 "can't use a fully-masked loop because the"
1755 " target doesn't have an appropriate masked"
1759 }
1763 }
1766 {
1767 internal_fn ifn = (is_load
1768 ? IFN_MASK_GATHER_LOAD
1775 {
1778 "can't use a fully-masked loop because the"
1779 " target doesn't have an appropriate masked"
1783 }
1787 }
1791 {
1792 /* Element X of the data must come from iteration i * VF + X of the
1793 scalar loop. We need more work to support other mappings. */
1796 "can't use a fully-masked loop because an access"
1800 }
1802 machine_mode mask_mode;
1807 {
1810 "can't use a fully-masked loop because the target"
1811 " doesn't have the appropriate masked load or"
1815 }
1816 /* We might load more scalars than we need for permuting SLP loads.
1817 We checked in get_group_load_store_type that the extra elements
1818 don't leak into a new vector. */
1824 else
1826 }
1828 /* Return the mask input to a masked load or store. VEC_MASK is the vectorized
1829 form of the scalar mask condition and LOOP_MASK, if nonnull, is the mask
1830 that needs to be applied to all loads and stores in a vectorized loop.
1831 Return VEC_MASK if LOOP_MASK is null, otherwise return VEC_MASK & LOOP_MASK.
1833 MASK_TYPE is the type of both masks. If new statements are needed,
1834 insert them before GSI. */
1836 static tree
1839 {
1850 }
1852 /* Determine whether we can use a gather load or scatter store to vectorize
1853 strided load or store STMT by truncating the current offset to a smaller
1854 width. We need to be able to construct an offset vector:
1856 { 0, X, X*2, X*3, ... }
1858 without loss of precision, where X is STMT's DR_STEP.
1860 Return true if this is possible, describing the gather load or scatter
1861 store in GS_INFO. MASKED_P is true if the load or store is conditional. */
1863 static bool
1867 {
1872 {
1873 /* ??? Perhaps we could use range information here? */
1878 }
1880 /* Get the number of bits in an element. */
1885 /* Set COUNT to the upper limit on the number of elements - 1.
1886 Start with the maximum vectorization factor. */
1889 /* Try lowering COUNT to the number of scalar latch iterations. */
1891 widest_int max_iters;
1896 /* Try scales of 1 and the element size. */
1900 {
1902 widest_int factor;
1906 /* See whether we can calculate (COUNT - 1) * STEP / SCALE
1907 in OFFSET_BITS bits. */
1913 {
1916 }
1918 /* See whether the target supports the operation. */
1929 /* Logically the sum of DR_BASE_ADDRESS, DR_INIT and DR_OFFSET,
1930 but we don't need to store that here. */
1938 }
1942 "truncating gather/scatter offset to %d bits"
1946 }
1948 /* Return true if we can use gather/scatter internal functions to
1949 vectorize STMT, which is a grouped or strided load or store.
1950 MASKED_P is true if load or store is conditional. When returning
1951 true, fill in GS_INFO with the information required to perform the
1952 operation. */
1954 static bool
1958 {
1969 /* Enforced by vect_check_gather_scatter. */
1972 /* If the elements are wider than the offset, convert the offset to the
1973 same width, without changing its sign. */
1975 {
1979 }
1983 "using gather/scatter for strided/grouped access,"
1987 }
1989 /* STMT is a non-strided load or store, meaning that it accesses
1990 elements with a known constant step. Return -1 if that step
1991 is negative, 0 if it is zero, and 1 if it is greater than zero. */
1993 static int
1995 {
1999 size_zero_node);
2000 }
2002 /* If the target supports a permute mask that reverses the elements in
2003 a vector of type VECTYPE, return that mask, otherwise return null. */
2005 static tree
2007 {
2010 /* The encoding has a single stepped pattern. */
2019 }
2021 /* STMT is either a masked or unconditional store. Return the value
2022 being stored. */
2024 tree
2026 {
2028 {
2031 }
2033 {
2038 }
2040 }
2042 /* A subroutine of get_load_store_type, with a subset of the same
2043 arguments. Handle the case where STMT is part of a grouped load
2044 or store.
2046 For stores, the statements in the group are all consecutive
2047 and there is no gap at the end. For loads, the statements in the
2048 group might not be consecutive; there can be gaps between statements
2049 as well as at the end. */
2051 static bool
2056 {
2069 /* True if the vectorized statements would access beyond the last
2070 statement in the group. */
2073 /* True if we can cope with such overrun by peeling for gaps, so that
2074 there is at least one final scalar iteration after the vector loop. */
2077 && loop_vinfo
2080 /* There can only be a gap at the end of the group if the stride is
2081 known at compile time. */
2084 /* Stores can't yet have gaps. */
2088 {
2090 {
2091 /* Try to use consecutive accesses of GROUP_SIZE elements,
2092 separated by the stride, until we have a complete vector.
2093 Fall back to scalar accesses if that isn't possible. */
2096 else
2098 }
2099 else
2100 {
2103 {
2105 "Grouped store with gaps requires"
2108 }
2109 /* An overrun is fine if the trailing elements are smaller
2110 than the alignment boundary B. Every vector access will
2111 be a multiple of B and so we are guaranteed to access a
2112 non-gap element in the same B-sized block. */
2118 {
2123 }
2125 }
2126 }
2127 else
2128 {
2129 /* We can always handle this case using elementwise accesses,
2130 but see if something more efficient is available. */
2133 /* If there is a gap at the end of the group then these optimizations
2134 would access excess elements in the last iteration. */
2136 /* An overrun is fine if the trailing elements are smaller than the
2137 alignment boundary B. Every vector access will be a multiple of B
2138 and so we are guaranteed to access a non-gap element in the
2139 same B-sized block. */
2141 && !masked_p
2149 {
2150 /* First cope with the degenerate case of a single-element
2151 vector. */
2155 /* Otherwise try using LOAD/STORE_LANES. */
2160 masked_p)))
2161 {
2164 }
2166 /* If that fails, try using permuting loads. */
2170 group_size)
2172 {
2175 }
2176 }
2178 /* As a last resort, trying using a gather load or scatter store.
2180 ??? Although the code can handle all group sizes correctly,
2181 it probably isn't a win to use separate strided accesses based
2182 on nearby locations. Or, even if it's a win over scalar code,
2183 it might not be a win over vectorizing at a lower VF, if that
2184 allows us to use contiguous accesses. */
2186 && single_element_p
2187 && loop_vinfo
2191 }
2194 {
2195 /* STMT is the leader of the group. Check the operands of all the
2196 stmts of the group. */
2199 {
2204 {
2209 }
2211 }
2212 }
2215 {
2219 "Data access with gaps requires scalar "
2222 }
2225 }
2227 /* A subroutine of get_load_store_type, with a subset of the same
2228 arguments. Handle the case where STMT is a load or store that
2229 accesses consecutive elements with a negative step. */
2231 static vect_memory_access_type
2233 vec_load_store_type vls_type,
2235 {
2238 dr_alignment_support alignment_support_scheme;
2241 {
2246 }
2251 {
2256 }
2259 {
2262 "negative step with invariant source;"
2265 }
2268 {
2273 }
2276 }
2278 /* Analyze load or store statement STMT of type VLS_TYPE. Return true
2279 if there is a memory access type that the vectorized form can use,
2280 storing it in *MEMORY_ACCESS_TYPE if so. If we decide to use gathers
2281 or scatters, fill in GS_INFO accordingly.
2283 SLP says whether we're performing SLP rather than loop vectorization.
2284 MASKED_P is true if the statement is conditional on a vectorized mask.
2285 VECTYPE is the vector type that the vectorized statements will use.
2286 NCOPIES is the number of vector statements that will be needed. */
2288 static bool
2293 {
2299 {
2307 {
2313 }
2314 }
2316 {
2320 }
2322 {
2328 else
2330 }
2331 else
2332 {
2338 {
2341 }
2342 else
2344 }
2349 {
2352 "Not using elementwise accesses due to variable "
2355 }
2357 /* FIXME: At the moment the cost model seems to underestimate the
2358 cost of using elementwise accesses. This check preserves the
2359 traditional behavior until that can be fixed. */
2365 {
2370 }
2372 }
2374 /* Return true if boolean argument MASK is suitable for vectorizing
2375 conditional load or store STMT. When returning true, store the type
2376 of the definition in *MASK_DT_OUT and the type of the vectorized mask
2377 in *MASK_VECTYPE_OUT. */
2379 static bool
2383 {
2385 {
2390 }
2393 {
2398 }
2403 tree mask_vectype;
2406 {
2411 }
2418 {
2423 }
2427 {
2429 {
2437 }
2439 }
2444 }
2446 /* Return true if stored value RHS is suitable for vectorizing store
2447 statement STMT. When returning true, store the type of the
2448 definition in *RHS_DT_OUT, the type of the vectorized store value in
2449 *RHS_VECTYPE_OUT and the type of the store in *VLS_TYPE_OUT. */
2451 static bool
2454 {
2455 /* In the case this is a store from a constant make sure
2456 native_encode_expr can handle it. */
2458 {
2463 }
2468 tree rhs_vectype;
2471 {
2476 }
2480 {
2485 }
2491 else
2494 }
2496 /* Build an all-ones vector mask of type MASKTYPE while vectorizing STMT.
2497 Note that we support masks with floating-point type, in which case the
2498 floats are interpreted as a bitmask. */
2500 static tree
2502 {
2506 {
2510 }
2512 {
2513 REAL_VALUE_TYPE r;
2521 }
2523 }
2525 /* Build an all-zero merge value of type VECTYPE while vectorizing
2526 STMT as a gather load. */
2528 static tree
2530 {
2531 tree merge;
2535 {
2536 REAL_VALUE_TYPE r;
2542 }
2543 else
2547 }
2549 /* Build a gather load call while vectorizing STMT. Insert new instructions
2550 before GSI and add them to VEC_STMT. GS_INFO describes the gather load
2551 operation. If the load is conditional, MASK is the unvectorized
2552 condition and MASK_DT is its definition type, otherwise MASK is null. */
2554 static void
2558 {
2567 poly_uint64 gather_off_nunits
2585 {
2588 /* Currently widening gathers and scatters are only supported for
2589 fixed-length vectors. */
2597 indices);
2598 }
2600 {
2603 /* Currently narrowing gathers and scatters are only supported for
2604 fixed-length vectors. */
2616 {
2621 }
2622 }
2623 else
2627 vectype);
2631 {
2632 gimple_seq seq;
2636 }
2648 {
2651 }
2654 {
2661 op = vec_oprnd0
2663 else
2664 op = vec_oprnd0
2668 {
2676 }
2679 {
2683 else
2684 {
2687 else
2692 {
2693 gcc_assert
2699 mask_op);
2702 }
2703 }
2705 }
2711 {
2720 }
2721 else
2722 {
2725 }
2730 {
2732 {
2735 }
2738 }
2742 else
2745 }
2746 }
2748 /* Prepare the base and offset in GS_INFO for vectorization.
2749 Set *DATAREF_PTR to the loop-invariant base address and *VEC_OFFSET
2750 to the vectorized offset argument for the first copy of STMT. STMT
2751 is the statement described by GS_INFO and LOOP is the containing loop. */
2753 static void
2757 {
2761 {
2762 basic_block new_bb;
2766 }
2770 offset_vectype);
2771 }
2773 /* Prepare to implement a grouped or strided load or store using
2774 the gather load or scatter store operation described by GS_INFO.
2775 STMT is the load or store statement.
2777 Set *DATAREF_BUMP to the amount that should be added to the base
2778 address after each copy of the vectorized statement. Set *VEC_OFFSET
2779 to an invariant offset vector in which element I has the value
2780 I * DR_STEP / SCALE. */
2782 static void
2786 {
2791 gimple_seq stmts;
2800 /* The offset given in GS_INFO can have pointer type, so use the element
2801 type of the vector instead. */
2806 /* Calculate X = DR_STEP / SCALE and convert it to the appropriate type. */
2812 /* Create {0, X, X*2, X*3, ...}. */
2817 }
2819 /* Return the amount that should be added to a vector pointer to move
2820 to the next or previous copy of AGGR_TYPE. DR is the data reference
2821 being vectorized and MEMORY_ACCESS_TYPE describes the type of
2822 vectorization. */
2824 static tree
2826 vect_memory_access_type memory_access_type)
2827 {
2836 }
2838 /* Check and perform vectorization of BUILT_IN_BSWAP{16,32,64}. */
2840 static bool
2844 {
2857 /* Multiple types in SLP are handled by creating the appropriate number of
2858 vectorized stmts for each SLP node. Hence, NCOPIES is always 1 in
2859 case of SLP. */
2862 else
2876 /* The encoding uses one stepped pattern for each byte in the word. */
2887 {
2893 {
2898 }
2900 }
2904 /* Transform. */
2909 {
2910 /* Handle uses. */
2913 else
2916 /* Arguments are ready. create the new vector stmt. */
2918 tree vop;
2920 {
2935 }
2942 else
2946 }
2950 }
2952 /* Return true if vector types VECTYPE_IN and VECTYPE_OUT have
2953 integer elements and if we can narrow VECTYPE_IN to VECTYPE_OUT
2954 in a single step. On success, store the binary pack code in
2955 *CONVERT_CODE. */
2957 static bool
2960 {
2965 tree_code code;
2976 }
2978 /* Function vectorizable_call.
2980 Check if GS performs a function call that can be vectorized.
2981 If VEC_STMT is also passed, vectorize the STMT: create a vectorized
2982 stmt to replace it, put it in VEC_STMT, and insert it at BSI.
2983 Return FALSE if not a vectorizable STMT, TRUE otherwise. */
2985 static bool
2987 slp_tree slp_node)
2988 {
2990 tree vec_dest;
2991 tree scalar_dest;
2996 poly_uint64 nunits_in;
2997 poly_uint64 nunits_out;
3011 tree lhs;
3020 /* Is GS a vectorizable call? */
3028 /* Handled by vectorizable_load and vectorizable_store. */
3039 /* Process function arguments. */
3044 /* Bail out if the function has more than three arguments, we do not have
3045 interesting builtin functions to vectorize with more than two arguments
3046 except for fma. No arguments is also not good. */
3050 /* Ignore the argument of IFN_GOMP_SIMD_LANE, it is magic. */
3053 {
3056 }
3059 {
3060 tree opvectype;
3064 /* We can only handle calls with arguments of the same type. */
3067 {
3072 }
3077 {
3082 }
3088 {
3093 }
3094 }
3095 /* If all arguments are external or constant defs use a vector type with
3096 the same size as the output vector type. */
3102 {
3104 {
3109 }
3112 }
3114 /* FORNOW */
3123 else
3126 /* We only handle functions that do not read or clobber memory. */
3128 {
3133 }
3135 /* For now, we only vectorize functions if a target specific builtin
3136 is available. TODO -- in some cases, it might be profitable to
3137 insert the calls for pieces of the vector, in order to be able
3138 to vectorize other operations in the loop. */
3144 /* First try using an internal function. */
3152 vectype_in);
3154 /* If that fails, try asking for a target-specific built-in function. */
3156 {
3163 }
3166 {
3168 && !slp_node
3169 && loop_vinfo
3174 {
3175 /* We can handle IFN_GOMP_SIMD_LANE by returning a
3176 { 0, 1, 2, ... vf - 1 } vector. */
3178 }
3185 else
3186 {
3191 }
3192 }
3198 else
3201 /* Sanity check: make sure that at least one copy of the vectorized stmt
3202 needs to be generated. */
3206 {
3212 {
3217 }
3220 }
3222 /* Transform. */
3227 /* Handle def. */
3233 {
3236 {
3237 /* Build argument list for the vectorized call. */
3240 else
3244 {
3253 /* Arguments are ready. Create the new vector stmt. */
3255 {
3258 {
3261 }
3263 {
3265 gcall *call
3272 {
3275 }
3279 }
3280 else
3281 {
3285 else
3291 }
3294 }
3297 {
3300 }
3302 }
3305 {
3308 vec_oprnd0
3310 else
3311 {
3313 vec_oprnd0
3315 }
3318 }
3322 {
3324 tree new_var
3330 }
3332 {
3340 {
3343 }
3347 }
3348 else
3349 {
3353 else
3359 }
3364 else
3368 }
3369 }
3371 {
3373 {
3374 /* Build argument list for the vectorized call. */
3377 else
3381 {
3390 /* Arguments are ready. Create the new vector stmt. */
3392 {
3396 {
3400 }
3404 else
3412 }
3415 {
3418 }
3420 }
3423 {
3426 {
3427 vec_oprnd0
3429 vec_oprnd1
3431 }
3432 else
3433 {
3435 vec_oprnd0
3437 vec_oprnd1
3439 }
3443 }
3452 else
3456 }
3459 }
3460 else
3461 /* No current target implements this case. */
3466 /* The call in STMT might prevent it from being removed in dce.
3467 We however cannot remove it here, due to the way the ssa name
3468 it defines is mapped to the new definition. So just replace
3469 rhs of the statement with something harmless. */
3477 else
3487 }
3490 struct simd_call_arg_info
3491 {
3492 tree vectype;
3493 tree op;
3494 HOST_WIDE_INT linear_step;
3498 };
3500 /* Helper function of vectorizable_simd_clone_call. If OP, an SSA_NAME,
3501 is linear within simd lane (but not within whole loop), note it in
3502 *ARGINFO. */
3504 static void
3507 {
3519 {
3520 tree t;
3524 {
3539 CASE_CONVERT:
3551 }
3557 {
3564 }
3565 }
3566 }
3568 /* Return the number of elements in vector type VECTYPE, which is associated
3569 with a SIMD clone. At present these vectors always have a constant
3570 length. */
3572 static unsigned HOST_WIDE_INT
3574 {
3576 }
3578 /* Function vectorizable_simd_clone_call.
3580 Check if STMT performs a function call that can be vectorized
3581 by calling a simd clone of the function.
3582 If VEC_STMT is also passed, vectorize the STMT: create a vectorized
3583 stmt to replace it, put it in VEC_STMT, and insert it at BSI.
3584 Return FALSE if not a vectorizable STMT, TRUE otherwise. */
3586 static bool
3589 {
3590 tree vec_dest;
3591 tree scalar_dest;
3595 tree vectype;
3611 /* Is STMT a vectorizable call? */
3641 /* FORNOW */
3645 /* Process function arguments. */
3648 /* Bail out if the function has zero arguments. */
3655 {
3656 simd_call_arg_info thisarginfo;
3657 affine_iv iv;
3668 {
3673 }
3678 else
3681 /* For linear arguments, the analyze phase should have saved
3682 the base and step in STMT_VINFO_SIMD_CLONE_INFO. */
3685 {
3687 thisarginfo.linear_step
3689 thisarginfo.op
3691 thisarginfo.simd_lane_linear
3694 /* If loop has been peeled for alignment, we need to adjust it. */
3698 {
3704 thisarginfo.op
3708 }
3709 }
3713 && loop_vinfo
3718 {
3721 }
3726 /* Addresses of array elements indexed by GOMP_SIMD_LANE are
3727 linear too. */
3730 && !vec_stmt
3733 && loop_vinfo
3734 && !slp_node
3739 }
3743 {
3746 "not considering SIMD clones; not yet supported"
3749 }
3755 else
3758 {
3772 /* FORNOW: Have to add code to add the mask argument. */
3776 {
3778 {
3808 /* FORNOW */
3813 }
3817 {
3820 }
3824 }
3828 {
3831 }
3832 }
3841 {
3844 i)));
3849 }
3855 /* If the function isn't const, only allow it in simd loops where user
3856 has asserted that at least nunits consecutive iterations can be
3857 performed using SIMD instructions. */
3862 /* Sanity check: make sure that at least one copy of the vectorized stmt
3863 needs to be generated. */
3867 {
3874 {
3885 }
3890 /* vect_model_simple_cost (stmt_info, ncopies, dt, NULL, NULL); */
3892 }
3894 /* Transform. */
3899 /* Handle def. */
3905 {
3909 {
3912 }
3913 }
3917 {
3918 /* Build argument list for the vectorized call. */
3921 else
3925 {
3927 tree atype;
3930 {
3935 {
3938 {
3944 vec_oprnd0
3946 else
3947 {
3950 vec_oprnd0
3952 vec_oprnd0);
3953 }
3955 vec_oprnd0
3959 new_stmt
3961 vec_oprnd0);
3964 }
3965 else
3966 {
3973 else
3976 {
3978 vec_oprnd0
3980 else
3981 vec_oprnd0
3988 vec_oprnd0);
3989 }
3992 else
3993 {
3995 new_stmt
3997 vec_oprnd0);
4000 }
4001 }
4002 }
4010 {
4011 gimple_seq stmts;
4014 NULL_TREE);
4016 {
4017 basic_block new_bb;
4021 }
4023 {
4026 }
4033 enum tree_code code
4038 widest_int cst
4043 new_stmt
4050 UNKNOWN_LOCATION);
4053 }
4054 else
4055 {
4056 enum tree_code code
4061 widest_int cst
4070 }
4080 }
4081 }
4085 {
4092 else
4095 }
4099 {
4101 {
4108 {
4109 tree t;
4111 {
4115 }
4116 else
4119 new_stmt
4124 else
4128 }
4131 {
4136 }
4138 }
4140 {
4147 {
4150 {
4153 new_stmt
4158 }
4163 }
4164 else
4169 new_stmt
4175 else
4180 }
4182 {
4186 new_stmt
4194 }
4195 }
4199 else
4203 }
4207 /* The call in STMT might prevent it from being removed in dce.
4208 We however cannot remove it here, due to the way the ssa name
4209 it defines is mapped to the new definition. So just replace
4210 rhs of the statement with something harmless. */
4216 {
4220 else
4223 }
4224 else
4233 }
4236 /* Function vect_gen_widened_results_half
4238 Create a vector stmt whose code, type, number of arguments, and result
4239 variable are CODE, OP_TYPE, and VEC_DEST, and its arguments are
4240 VEC_OPRND0 and VEC_OPRND1. The new vector stmt is to be inserted at BSI.
4241 In the case that CODE is a CALL_EXPR, this means that a call to DECL
4242 needs to be created (DECL is a function-decl of a target-builtin).
4243 STMT is the original scalar stmt that we are vectorizing. */
4247 tree decl,
4251 {
4253 tree new_temp;
4255 /* Generate half of the widened result: */
4257 {
4258 /* Target specific support */
4261 else
4265 }
4266 else
4267 {
4268 /* Generic support */
4275 }
4279 }
4282 /* Get vectorized definitions for loop-based vectorization. For the first
4283 operand we call vect_get_vec_def_for_operand() (with OPRND containing
4284 scalar operand), and for the rest we get a copy with
4285 vect_get_vec_def_for_stmt_copy() using the previous vector definition
4286 (stored in OPRND). See vect_get_vec_def_for_stmt_copy() for details.
4287 The vectors are collected into VEC_OPRNDS. */
4289 static void
4292 {
4293 tree vec_oprnd;
4295 /* Get first vector operand. */
4296 /* All the vector operands except the very first one (that is scalar oprnd)
4297 are stmt copies. */
4300 else
4305 /* Get second vector operand. */
4311 /* For conversion in multiple steps, continue to get operands
4312 recursively. */
4315 }
4318 /* Create vectorized demotion statements for vector operands from VEC_OPRNDS.
4319 For multi-step conversions store the resulting vectors and call the function
4320 recursively. */
4322 static void
4329 {
4338 {
4339 /* Create demotion operation. */
4348 /* Store the resulting vector for next recursive call. */
4350 else
4351 {
4352 /* This is the last step of the conversion sequence. Store the
4353 vectors in SLP_NODE or in vector info of the scalar statement
4354 (or in STMT_VINFO_RELATED_STMT chain). */
4357 else
4358 {
4361 else
4365 }
4366 }
4367 }
4369 /* For multi-step demotion operations we first generate demotion operations
4370 from the source type to the intermediate types, and then combine the
4371 results (stored in VEC_OPRNDS) in demotion operation to the destination
4372 type. */
4374 {
4375 /* At each level of recursion we have half of the operands we had at the
4376 previous level. */
4380 VEC_PACK_TRUNC_EXPR,
4381 prev_stmt_info);
4382 }
4385 }
4388 /* Create vectorized promotion statements for vector operands from VEC_OPRNDS0
4389 and VEC_OPRNDS1 (for binary operations). For multi-step conversions store
4390 the resulting vectors and call the function recursively. */
4392 static void
4400 {
4408 {
4411 else
4414 /* Generate the two halves of promotion operation. */
4420 {
4423 }
4424 else
4425 {
4428 }
4430 /* Store the results for the next step. */
4433 }
4437 }
4440 /* Check if STMT performs a conversion operation, that can be vectorized.
4441 If VEC_STMT is also passed, vectorize the STMT: create a vectorized
4442 stmt to replace it, put it in VEC_STMT, and insert it at GSI.
4443 Return FALSE if not a vectorizable STMT, TRUE otherwise. */
4445 static bool
4448 {
4449 tree vec_dest;
4450 tree scalar_dest;
4458 tree new_temp;
4463 stmt_vec_info prev_stmt_info;
4464 poly_uint64 nunits_in;
4465 poly_uint64 nunits_out;
4472 tree vop0;
4481 /* Is STMT a vectorizable conversion? */
4506 /* Check types of lhs and rhs. */
4526 {
4529 "type conversion to/from bit-precision unsupported."
4532 }
4534 /* Check the operands of the operation. */
4536 {
4541 }
4543 {
4548 /* For WIDEN_MULT_EXPR, if OP0 is a constant, use the type of
4549 OP1. */
4552 else
4556 {
4561 }
4562 }
4564 /* If op0 is an external or constant defs use a vector type of
4565 the same size as the output vector type. */
4571 {
4573 {
4578 }
4581 }
4585 {
4587 {
4589 "can't convert between boolean and non "
4593 }
4596 }
4604 else
4605 {
4608 }
4610 /* Multiple types in SLP are handled by creating the appropriate number of
4611 vectorized stmts for each SLP node. Hence, NCOPIES is always 1 in
4612 case of SLP. */
4617 else
4620 /* Sanity check: make sure that at least one copy of the vectorized stmt
4621 needs to be generated. */
4627 opt_scalar_mode rhs_mode_iter;
4629 /* Supportable by target? */
4631 {
4638 /* FALLTHRU */
4639 unsupported:
4649 {
4650 /* Binary widening operation can only be supported directly by the
4651 architecture. */
4654 }
4662 {
4667 cvt_type
4674 {
4678 }
4684 else
4690 {
4693 }
4694 }
4701 else
4702 {
4703 multi_step_cvt++;
4706 }
4720 cvt_type
4736 }
4739 {
4744 {
4748 }
4750 {
4754 }
4755 else
4756 {
4760 }
4763 }
4765 /* Transform. */
4771 {
4776 }
4778 /* In case of multi-step conversion, we first generate conversion operations
4779 to the intermediate types, and then from that types to the final one.
4780 We create vector destinations for the intermediate type (TYPES) received
4781 from supportable_*_operation, and store them in the correct order
4782 for future use in vect_create_vectorized_*_stmts (). */
4790 {
4793 {
4795 intermediate_type);
4797 }
4798 }
4802 modifier == WIDEN
4806 {
4808 {
4812 }
4816 }
4823 {
4826 {
4829 else
4833 {
4834 /* Arguments are ready, create the new vector stmt. */
4836 {
4840 }
4841 else
4842 {
4847 }
4852 else
4853 {
4856 else
4859 }
4860 }
4861 }
4865 /* In case the vectorization factor (VF) is bigger than the number
4866 of elements that we can fit in a vectype (nunits), we have to
4867 generate more than one vector stmt - i.e - we need to "unroll"
4868 the vector stmt by a factor VF/nunits. */
4870 {
4871 /* Handle uses. */
4873 {
4875 {
4877 {
4881 /* Store vec_oprnd1 for every vector stmt to be created
4882 for SLP_NODE. We check during the analysis that all
4883 the shift arguments are the same. */
4888 slp_node);
4889 }
4890 else
4893 }
4894 else
4895 {
4899 {
4902 else
4905 }
4906 }
4907 }
4908 else
4909 {
4914 {
4917 else
4919 vec_oprnd1);
4922 }
4923 }
4925 /* Arguments are ready. Create the new vector stmts. */
4927 {
4931 {
4934 }
4939 op_type);
4940 }
4943 {
4945 {
4947 {
4951 }
4952 else
4953 {
4957 vop0);
4958 }
4961 }
4962 else
4967 else
4968 {
4971 else
4974 }
4975 }
4976 }
4982 /* In case the vectorization factor (VF) is bigger than the number
4983 of elements that we can fit in a vectype (nunits), we have to
4984 generate more than one vector stmt - i.e - we need to "unroll"
4985 the vector stmt by a factor VF/nunits. */
4987 {
4988 /* Handle uses. */
4991 slp_node);
4992 else
4993 {
4997 }
4999 /* Arguments are ready. Create the new vector stmts. */
5002 {
5004 {
5008 }
5009 else
5010 {
5014 vop0);
5015 }
5019 }
5025 }
5029 }
5036 }
5039 /* Function vectorizable_assignment.
5041 Check if STMT performs an assignment (copy) that can be vectorized.
5042 If VEC_STMT is also passed, vectorize the STMT: create a vectorized
5043 stmt to replace it, put it in VEC_STMT, and insert it at BSI.
5044 Return FALSE if not a vectorizable STMT, TRUE otherwise. */
5046 static bool
5049 {
5050 tree vec_dest;
5051 tree scalar_dest;
5052 tree op;
5055 tree new_temp;
5062 tree vop;
5068 tree vectype_in;
5077 /* Is vectorizable assignment? */
5090 else
5099 /* Multiple types in SLP are handled by creating the appropriate number of
5100 vectorized stmts for each SLP node. Hence, NCOPIES is always 1 in
5101 case of SLP. */
5104 else
5110 {
5115 }
5117 /* We can handle NOP_EXPR conversions that do not change the number
5118 of elements or the vector size. */
5121 && (!vectype_in
5127 /* We do not handle bit-precision changes. */
5133 /* But a conversion that does not change the bit-pattern is ok. */
5137 /* Conversion between boolean types of different sizes is
5138 a simple assignment in case their vectypes are same
5139 boolean vectors. */
5142 {
5145 "type conversion to/from bit-precision "
5148 }
5151 {
5159 }
5161 /* Transform. */
5165 /* Handle def. */
5168 /* Handle use. */
5170 {
5171 /* Handle uses. */
5174 else
5177 /* Arguments are ready. create the new vector stmt. */
5179 {
5189 }
5196 else
5200 }
5204 }
5207 /* Return TRUE if CODE (a shift operation) is supported for SCALAR_TYPE
5208 either as shift by a scalar or by a vector. */
5210 bool
5212 {
5214 machine_mode vec_mode;
5215 optab optab;
5217 tree vectype;
5226 {
5232 }
5240 }
5243 /* Function vectorizable_shift.
5245 Check if STMT performs a shift operation that can be vectorized.
5246 If VEC_STMT is also passed, vectorize the STMT: create a vectorized
5247 stmt to replace it, put it in VEC_STMT, and insert it at BSI.
5248 Return FALSE if not a vectorizable STMT, TRUE otherwise. */
5250 static bool
5253 {
5254 tree vec_dest;
5255 tree scalar_dest;
5259 tree vectype;
5262 machine_mode vec_mode;
5263 tree new_temp;
5264 optab optab;
5266 machine_mode optab_op2_mode;
5271 stmt_vec_info prev_stmt_info;
5272 poly_uint64 nunits_in;
5273 poly_uint64 nunits_out;
5274 tree vectype_out;
5275 tree op1_vectype;
5293 /* Is STMT a vectorizable binary/unary operation? */
5309 {
5314 }
5318 {
5323 }
5324 /* If op0 is an external or constant def use a vector type with
5325 the same size as the output vector type. */
5331 {
5336 }
5345 {
5350 }
5352 /* Multiple types in SLP are handled by creating the appropriate number of
5353 vectorized stmts for each SLP node. Hence, NCOPIES is always 1 in
5354 case of SLP. */
5357 else
5362 /* Determine whether the shift amount is a vector, or scalar. If the
5363 shift/rotate amount is a vector, use the vector/vector shift optabs. */
5372 {
5373 /* In SLP, need to check whether the shift count is the same,
5374 in loops if it is a constant or invariant, it is always
5375 a scalar shift. */
5377 {
5384 }
5386 /* If the shift amount is computed by a pattern stmt we cannot
5387 use the scalar amount directly thus give up and use a vector
5388 shift. */
5390 {
5394 }
5395 }
5396 else
5397 {
5402 }
5404 /* Vector shifted by vector. */
5406 {
5416 {
5419 "unusable type for last operand in"
5422 }
5423 }
5424 /* See if the machine has a vector shifted by scalar insn and if not
5425 then see if it has a vector shifted by vector insn. */
5426 else
5427 {
5431 {
5435 }
5436 else
5437 {
5442 {
5449 /* Unlike the other binary operators, shifts/rotates have
5450 the rhs being int, instead of the same type as the lhs,
5451 so make sure the scalar is the right type if we are
5452 dealing with vectors of long long/long/short/char. */
5457 {
5461 {
5464 "unusable type for last operand in"
5467 }
5469 {
5473 }
5474 }
5475 }
5476 }
5477 }
5479 /* Supportable by target? */
5481 {
5486 }
5490 {
5494 /* Check only during analysis. */
5496 || (!vec_stmt
5502 }
5504 /* Worthwhile without SIMD support? Check only during analysis. */
5508 {
5513 }
5516 {
5524 }
5526 /* Transform. */
5532 /* Handle def. */
5537 {
5538 /* Handle uses. */
5540 {
5542 {
5543 /* Vector shl and shr insn patterns can be defined with scalar
5544 operand 2 (shift operand). In this case, use constant or loop
5545 invariant op1 directly, without extending it to vector mode
5546 first. */
5549 {
5557 {
5558 /* Store vec_oprnd1 for every vector stmt to be created
5559 for SLP_NODE. We check during the analysis that all
5560 the shift arguments are the same.
5561 TODO: Allow different constants for different vector
5562 stmts generated for an SLP instance. */
5565 }
5566 }
5567 }
5569 /* vec_oprnd1 is available if operand 1 should be of a scalar-type
5570 (a special case for certain kind of vector shifts); otherwise,
5571 operand 1 should be of a vector type (the usual case). */
5574 slp_node);
5575 else
5577 slp_node);
5578 }
5579 else
5582 /* Arguments are ready. Create the new vector stmt. */
5584 {
5592 }
5599 else
5602 }
5608 }
5611 /* Function vectorizable_operation.
5613 Check if STMT performs a binary, unary or ternary operation that can
5614 be vectorized.
5615 If VEC_STMT is also passed, vectorize the STMT: create a vectorized
5616 stmt to replace it, put it in VEC_STMT, and insert it at BSI.
5617 Return FALSE if not a vectorizable STMT, TRUE otherwise. */
5619 static bool
5622 {
5623 tree vec_dest;
5624 tree scalar_dest;
5627 tree vectype;
5630 machine_mode vec_mode;
5631 tree new_temp;
5633 optab optab;
5640 stmt_vec_info prev_stmt_info;
5641 poly_uint64 nunits_in;
5642 poly_uint64 nunits_out;
5643 tree vectype_out;
5660 /* Is STMT a vectorizable binary/unary operation? */
5669 /* For pointer addition and subtraction, we should use the normal
5670 plus and minus for the vector operation. */
5676 /* Support only unary or binary operations. */
5679 {
5683 op_type);
5685 }
5690 /* Most operations cannot handle bit-precision types without extra
5691 truncations. */
5694 /* Exception are bitwise binary operations. */
5698 {
5703 }
5707 {
5712 }
5713 /* If op0 is an external or constant def use a vector type with
5714 the same size as the output vector type. */
5716 {
5717 /* For boolean type we cannot determine vectype by
5718 invariant value (don't know whether it is a vector
5719 of booleans or vector of integers). We use output
5720 vectype because operations on boolean don't change
5721 type. */
5723 {
5725 {
5730 }
5732 }
5733 else
5735 }
5739 {
5741 {
5747 }
5750 }
5758 {
5761 {
5766 }
5767 }
5769 {
5772 {
5777 }
5778 }
5780 /* Multiple types in SLP are handled by creating the appropriate number of
5781 vectorized stmts for each SLP node. Hence, NCOPIES is always 1 in
5782 case of SLP. */
5785 else
5790 /* Shifts are handled in vectorizable_shift (). */
5795 /* Supportable by target? */
5800 else
5801 {
5804 {
5809 }
5812 }
5815 {
5819 /* Check only during analysis. */
5826 }
5828 /* Worthwhile without SIMD support? Check only during analysis. */
5830 && !vec_stmt
5832 {
5837 }
5840 {
5848 }
5850 /* Transform. */
5856 /* Handle def. */
5859 /* POINTER_DIFF_EXPR has pointer arguments which are vectorized as
5860 vectors with unsigned elements, but the result is signed. So, we
5861 need to compute the MINUS_EXPR into vectype temporary and
5862 VIEW_CONVERT_EXPR it into the final vectype_out result. */
5867 /* In case the vectorization factor (VF) is bigger than the number
5868 of elements that we can fit in a vectype (nunits), we have to generate
5869 more than one vector stmt - i.e - we need to "unroll" the
5870 vector stmt by a factor VF/nunits. In doing so, we record a pointer
5871 from one copy of the vector stmt to the next, in the field
5872 STMT_VINFO_RELATED_STMT. This is necessary in order to allow following
5873 stages to find the correct vector defs to be used when vectorizing
5874 stmts that use the defs of the current stmt. The example below
5875 illustrates the vectorization process when VF=16 and nunits=4 (i.e.,
5876 we need to create 4 vectorized stmts):
5878 before vectorization:
5879 RELATED_STMT VEC_STMT
5880 S1: x = memref - -
5881 S2: z = x + 1 - -
5883 step 1: vectorize stmt S1 (done in vectorizable_load. See more details
5884 there):
5885 RELATED_STMT VEC_STMT
5886 VS1_0: vx0 = memref0 VS1_1 -
5887 VS1_1: vx1 = memref1 VS1_2 -
5888 VS1_2: vx2 = memref2 VS1_3 -
5889 VS1_3: vx3 = memref3 - -
5890 S1: x = load - VS1_0
5891 S2: z = x + 1 - -
5893 step2: vectorize stmt S2 (done here):
5894 To vectorize stmt S2 we first need to find the relevant vector
5895 def for the first operand 'x'. This is, as usual, obtained from
5896 the vector stmt recorded in the STMT_VINFO_VEC_STMT of the stmt
5897 that defines 'x' (S1). This way we find the stmt VS1_0, and the
5898 relevant vector def 'vx0'. Having found 'vx0' we can generate
5899 the vector stmt VS2_0, and as usual, record it in the
5900 STMT_VINFO_VEC_STMT of stmt S2.
5901 When creating the second copy (VS2_1), we obtain the relevant vector
5902 def from the vector stmt recorded in the STMT_VINFO_RELATED_STMT of
5903 stmt VS1_0. This way we find the stmt VS1_1 and the relevant
5904 vector def 'vx1'. Using 'vx1' we create stmt VS2_1 and record a
5905 pointer to it in the STMT_VINFO_RELATED_STMT of the vector stmt VS2_0.
5906 Similarly when creating stmts VS2_2 and VS2_3. This is the resulting
5907 chain of stmts and pointers:
5908 RELATED_STMT VEC_STMT
5909 VS1_0: vx0 = memref0 VS1_1 -
5910 VS1_1: vx1 = memref1 VS1_2 -
5911 VS1_2: vx2 = memref2 VS1_3 -
5912 VS1_3: vx3 = memref3 - -
5913 S1: x = load - VS1_0
5914 VS2_0: vz0 = vx0 + v1 VS2_1 -
5915 VS2_1: vz1 = vx1 + v1 VS2_2 -
5916 VS2_2: vz2 = vx2 + v1 VS2_3 -
5917 VS2_3: vz3 = vx3 + v1 - -
5918 S2: z = x + 1 - VS2_0 */
5922 {
5923 /* Handle uses. */
5925 {
5928 slp_node);
5929 else
5931 slp_node);
5934 slp_node);
5935 }
5936 else
5937 {
5940 {
5943 vec_oprnd));
5944 }
5945 }
5947 /* Arguments are ready. Create the new vector stmt. */
5949 {
5959 {
5962 new_temp);
5966 }
5969 }
5976 else
5979 }
5986 }
5988 /* A helper function to ensure data reference DR's base alignment. */
5990 static void
5992 {
5997 {
6004 else
6005 {
6008 }
6010 }
6011 }
6014 /* Function get_group_alias_ptr_type.
6016 Return the alias type for the group starting at FIRST_STMT. */
6018 static tree
6020 {
6027 {
6031 {
6036 }
6038 }
6040 }
6043 /* Function vectorizable_store.
6045 Check if STMT defines a non scalar data-ref (array/pointer/structure) that
6046 can be vectorized.
6047 If VEC_STMT is also passed, vectorize the STMT: create a vectorized
6048 stmt to replace it, put it in VEC_STMT, and insert it at BSI.
6049 Return FALSE if not a vectorizable STMT, TRUE otherwise. */
6051 static bool
6053 slp_tree slp_node)
6054 {
6055 tree data_ref;
6056 tree op;
6060 tree elem_type;
6063 machine_mode vec_mode;
6064 tree dummy;
6087 tree aggr_type;
6088 gather_scatter_info gs_info;
6090 poly_uint64 vf;
6091 vec_load_store_type vls_type;
6092 tree ref_type;
6101 /* Is vectorizable store? */
6105 {
6118 }
6119 else
6120 {
6130 {
6135 }
6139 {
6144 }
6145 }
6149 /* Cannot have hybrid store SLP -- that would mean storing to the
6150 same location twice. */
6157 {
6160 }
6161 else
6164 /* Multiple types in SLP are handled by creating the appropriate number of
6165 vectorized stmts for each SLP node. Hence, NCOPIES is always 1 in
6166 case of SLP. */
6169 else
6174 /* FORNOW. This restriction should be relaxed. */
6176 {
6181 }
6192 vect_memory_access_type memory_access_type;
6198 {
6200 {
6205 }
6208 {
6213 }
6214 }
6215 else
6216 {
6217 /* FORNOW. In some cases can vectorize even if data-type not supported
6218 (e.g. - array initialization with 0). */
6221 }
6227 {
6231 }
6232 else
6233 {
6237 }
6240 {
6249 /* The SLP costs are calculated during SLP analysis. */
6254 }
6257 /* Transform. */
6262 {
6268 gimple_seq seq;
6269 basic_block new_bb;
6271 poly_uint64 scatter_off_nunits
6277 {
6280 /* Currently gathers and scatters are only supported for
6281 fixed-length vectors. */
6289 indices);
6291 }
6293 {
6296 /* Currently gathers and scatters are only supported for
6297 fixed-length vectors. */
6307 }
6308 else
6323 {
6327 }
6329 /* Currently we support only unconditional scatter stores,
6330 so mask should be all ones. */
6338 {
6340 {
6341 src = vec_oprnd1
6343 op = vec_oprnd0
6345 }
6347 {
6349 {
6350 src = vec_oprnd1
6354 }
6356 {
6359 op = vec_oprnd0
6361 vec_oprnd0);
6362 }
6363 else
6365 }
6366 else
6367 {
6368 src = vec_oprnd1
6370 op = vec_oprnd0
6372 vec_oprnd0);
6373 }
6376 {
6384 }
6387 {
6395 }
6397 new_stmt
6404 else
6407 }
6409 }
6412 {
6415 }
6418 {
6419 /* FORNOW */
6422 /* We vectorize all the stmts of the interleaving group when we
6423 reach the last stmt in the group. */
6427 {
6430 }
6433 {
6435 /* VEC_NUM is the number of vect stmts to be created for this
6436 group. */
6442 }
6443 else
6444 /* VEC_NUM is the number of vect stmts to be created for this
6445 group. */
6449 }
6450 else
6459 {
6460 gimple_stmt_iterator incr_gsi;
6463 tree offvar;
6464 tree ivstep;
6465 tree running_off;
6467 tree vec_oprnd;
6469 /* Checked by get_load_store_type. */
6475 stride_base
6476 = fold_build_pointer_plus
6483 /* For a store with loop-invariant (but other than power-of-2)
6484 stride (i.e. not a grouped access) like so:
6486 for (i = 0; i < n; i += stride)
6487 array[i] = ...;
6489 we generate a new induction variable and new stores from
6490 the components of the (vectorized) rhs:
6492 for (j = 0; ; j += VF*stride)
6493 vectemp = ...;
6494 tmp1 = vectemp[0];
6495 array[j] = tmp1;
6496 tmp2 = vectemp[1];
6497 array[j + stride] = tmp2;
6498 ...
6499 */
6506 {
6509 {
6515 /* First check if vec_extract optab doesn't support extraction
6516 of vector elts directly. */
6518 machine_mode vmode;
6525 {
6526 /* Try to avoid emitting an extract of vector elements
6527 by performing the extracts using an integer type of the
6528 same size, extracting from a vector of those and then
6529 re-interpreting it as the original vector type if
6530 supported. */
6531 unsigned lsize
6535 /* If we can't construct such a vector fall back to
6536 element extracts from the original vector type and
6537 element size stores. */
6544 {
6549 }
6550 /* Else fall back to vector extraction anyway.
6551 Fewer stores are more important than avoiding spilling
6552 of the vector we extract from. Compared to the
6553 construction case in vectorizable_load no store-forwarding
6554 issue exists here for reasonable archs. */
6555 }
6556 }
6559 {
6564 }
6567 }
6589 {
6592 {
6595 size);
6601 }
6603 unsigned HOST_WIDE_INT
6606 {
6607 /* We've set op and dt above, from vect_get_store_rhs,
6608 and first_stmt == stmt. */
6610 {
6612 {
6614 slp_node);
6616 }
6617 else
6618 {
6621 }
6622 }
6623 else
6624 {
6627 else
6628 {
6631 vec_oprnd);
6632 }
6633 }
6634 /* Pun the vector to extract from if necessary. */
6636 {
6638 gimple *pun
6643 }
6645 {
6649 /* Extract the i'th component. */
6657 GSI_SAME_STMT);
6664 /* And store it to *running_off. */
6671 {
6679 }
6682 {
6686 else
6689 }
6690 }
6691 }
6695 }
6699 }
6706 vec_loop_masks *loop_masks
6710 /* Targets with store-lane instructions must not require explicit
6711 realignment. vect_supportable_dr_alignment always returns either
6712 dr_aligned or dr_unaligned_supported for masked operations. */
6714 && !mask
6723 tree bump;
6726 {
6729 }
6731 {
6735 }
6736 else
6737 {
6740 else
6743 }
6748 /* In case the vectorization factor (VF) is bigger than the number
6749 of elements that we can fit in a vectype (nunits), we have to generate
6750 more than one vector stmt - i.e - we need to "unroll" the
6751 vector stmt by a factor VF/nunits. For more details see documentation in
6752 vect_get_vec_def_for_copy_stmt. */
6754 /* In case of interleaving (non-unit grouped access):
6756 S1: &base + 2 = x2
6757 S2: &base = x0
6758 S3: &base + 1 = x1
6759 S4: &base + 3 = x3
6761 We create vectorized stores starting from base address (the access of the
6762 first stmt in the chain (S2 in the above example), when the last store stmt
6763 of the chain (S4) is reached:
6765 VS1: &base = vx2
6766 VS2: &base + vec_size*1 = vx0
6767 VS3: &base + vec_size*2 = vx1
6768 VS4: &base + vec_size*3 = vx3
6770 Then permutation statements are generated:
6772 VS5: vx5 = VEC_PERM_EXPR < vx0, vx3, {0, 8, 1, 9, 2, 10, 3, 11} >
6773 VS6: vx6 = VEC_PERM_EXPR < vx0, vx3, {4, 12, 5, 13, 6, 14, 7, 15} >
6774 ...
6776 And they are put in STMT_VINFO_VEC_STMT of the corresponding scalar stmts
6777 (the order of the data-refs in the output of vect_permute_store_chain
6778 corresponds to the order of scalar stmts in the interleaving chain - see
6779 the documentation of vect_permute_store_chain()).
6781 In case of both multiple types and interleaving, above vector stores and
6782 permutation stmts are created for every copy. The result vector stmts are
6783 put in STMT_VINFO_VEC_STMT for the first copy and in the corresponding
6784 STMT_VINFO_RELATED_STMT for the next copies.
6785 */
6790 {
6793 {
6795 {
6796 /* Get vectorized arguments for SLP_NODE. */
6801 }
6802 else
6803 {
6804 /* For interleaved stores we collect vectorized defs for all the
6805 stores in the group in DR_CHAIN and OPRNDS. DR_CHAIN is then
6806 used as an input to vect_permute_store_chain(), and OPRNDS as
6807 an input to vect_get_vec_def_for_stmt_copy() for the next copy.
6809 If the store is not grouped, GROUP_SIZE is 1, and DR_CHAIN and
6810 OPRNDS are of size 1. */
6813 {
6814 /* Since gaps are not supported for interleaved stores,
6815 GROUP_SIZE is the exact number of stmts in the chain.
6816 Therefore, NEXT_STMT can't be NULL_TREE. In case that
6817 there is no interleaving, GROUP_SIZE is 1, and only one
6818 iteration of the loop will be executed. */
6824 }
6827 mask_vectype);
6828 }
6830 /* We should have catched mismatched types earlier. */
6833 bool simd_lane_access_p
6842 {
6846 }
6848 {
6852 }
6853 else
6854 dataref_ptr
6861 }
6862 else
6863 {
6864 /* For interleaved stores we created vectorized defs for all the
6865 defs stored in OPRNDS in the previous iteration (previous copy).
6866 DR_CHAIN is then used as an input to vect_permute_store_chain(),
6867 and OPRNDS as an input to vect_get_vec_def_for_stmt_copy() for the
6868 next copy.
6869 If the store is not grouped, GROUP_SIZE is 1, and DR_CHAIN and
6870 OPRNDS are of size 1. */
6872 {
6878 }
6882 dataref_offset
6886 vec_offset);
6887 else
6889 bump);
6890 }
6893 {
6894 tree vec_array;
6896 /* Combine all the vectors into an array. */
6899 {
6902 }
6914 {
6915 /* Emit:
6916 MASK_STORE_LANES (DATAREF_PTR, ALIAS_PTR, VEC_MASK,
6917 VEC_ARRAY). */
6923 }
6924 else
6925 {
6926 /* Emit:
6927 MEM_REF[...all elements...] = STORE_LANES (VEC_ARRAY). */
6930 vec_array);
6932 }
6936 }
6937 else
6938 {
6941 {
6944 /* Permute. */
6947 }
6951 {
6964 {
6968 call = gimple_build_call_internal
6971 else
6972 call = gimple_build_call_internal
6979 }
6982 /* Bump the vector pointer. */
6989 /* For grouped stores vectorized defs are interleaved in
6990 vect_permute_store_chain(). */
6997 {
7000 }
7001 else
7006 misalign);
7009 {
7011 tree perm_dest
7013 vectype);
7016 /* Generate the permute statement. */
7017 gimple *perm_stmt
7024 }
7026 /* Arguments are ready. Create the new vector stmt. */
7028 {
7031 gcall *call
7037 }
7038 else
7039 {
7041 dataref_ptr,
7042 dataref_offset
7043 ? dataref_offset
7046 ;
7051 else
7056 }
7065 }
7066 }
7068 {
7071 else
7074 }
7075 }
7082 }
7084 /* Given a vector type VECTYPE, turns permutation SEL into the equivalent
7085 VECTOR_CST mask. No checks are made that the target platform supports the
7086 mask, so callers may wish to test can_vec_perm_const_p separately, or use
7087 vect_gen_perm_mask_checked. */
7089 tree
7091 {
7092 tree mask_type;
7099 }
7101 /* Checked version of vect_gen_perm_mask_any. Asserts can_vec_perm_const_p,
7102 i.e. that the target supports the pattern _for arbitrary input vectors_. */
7104 tree
7106 {
7109 }
7111 /* Given a vector variable X and Y, that was generated for the scalar
7112 STMT, generate instructions to permute the vector elements of X and Y
7113 using permutation mask MASK_VEC, insert them at *GSI and return the
7114 permuted vector variable. */
7116 static tree
7119 {
7127 else
7131 /* Generate the permute statement. */
7136 }
7138 /* Hoist the definitions of all SSA uses on STMT out of the loop LOOP,
7139 inserting them on the loops preheader edge. Returns true if we
7140 were successful in doing so (and thus STMT can be moved then),
7141 otherwise returns false. */
7143 static bool
7145 {
7146 ssa_op_iter i;
7147 tree op;
7151 {
7155 {
7156 /* Make sure we don't need to recurse. While we could do
7157 so in simple cases when there are more complex use webs
7158 we don't have an easy way to preserve stmt order to fulfil
7159 dependencies within them. */
7160 tree op2;
7161 ssa_op_iter i2;
7165 {
7170 }
7172 }
7173 }
7179 {
7183 {
7187 }
7188 }
7191 }
7193 /* vectorizable_load.
7195 Check if STMT reads a non scalar data-ref (array/pointer/structure) that
7196 can be vectorized.
7197 If VEC_STMT is also passed, vectorize the STMT: create a vectorized
7198 stmt to replace it, put it in VEC_STMT, and insert it at BSI.
7199 Return FALSE if not a vectorizable STMT, TRUE otherwise. */
7201 static bool
7204 {
7205 tree scalar_dest;
7209 stmt_vec_info prev_stmt_info;
7215 tree elem_type;
7216 tree new_temp;
7217 machine_mode mode;
7219 tree dummy;
7227 poly_uint64 group_gap_adj;
7244 poly_uint64 vf;
7245 tree aggr_type;
7246 gather_scatter_info gs_info;
7248 tree ref_type;
7260 {
7275 }
7276 else
7277 {
7291 {
7296 }
7300 {
7305 }
7306 }
7315 {
7319 }
7320 else
7323 /* Multiple types in SLP are handled by creating the appropriate number of
7324 vectorized stmts for each SLP node. Hence, NCOPIES is always 1 in
7325 case of SLP. */
7328 else
7333 /* FORNOW. This restriction should be relaxed. */
7335 {
7340 }
7342 /* Invalidate assumptions made by dependence analysis when vectorization
7343 on the unrolled body effectively re-orders stmts. */
7348 {
7351 "cannot perform implicit CSE when unrolling "
7354 }
7359 /* FORNOW. In some cases can vectorize even if data-type not supported
7360 (e.g. - data copies). */
7362 {
7367 }
7369 /* Check if the load is a part of an interleaving chain. */
7371 {
7373 /* FORNOW */
7383 /* Invalidate assumptions made by dependence analysis when vectorization
7384 on the unrolled body effectively re-orders stmts. */
7389 {
7392 "cannot perform implicit CSE when performing "
7395 }
7397 /* Similarly when the stmt is a load that is both part of a SLP
7398 instance and a loop vectorized stmt via the same-dr mechanism
7399 we have to give up. */
7404 {
7409 }
7410 }
7411 else
7414 vect_memory_access_type memory_access_type;
7420 {
7422 {
7428 }
7430 {
7432 tree masktype
7435 {
7438 "masked gather with integer mask not"
7441 }
7442 }
7445 {
7450 }
7451 }
7454 {
7464 /* The SLP costs are calculated during SLP analysis. */
7469 }
7479 /* Transform. */
7484 {
7486 mask_dt);
7488 }
7492 {
7493 gimple_stmt_iterator incr_gsi;
7496 tree offvar;
7497 tree ivstep;
7498 tree running_off;
7501 /* Checked by get_load_store_type. */
7509 {
7512 }
7513 else
7514 {
7517 }
7519 {
7522 }
7523 else
7524 {
7526 cst_offset
7531 }
7533 stride_base
7534 = fold_build_pointer_plus
7541 /* For a load with loop-invariant (but other than power-of-2)
7542 stride (i.e. not a grouped access) like so:
7544 for (i = 0; i < n; i += stride)
7545 ... = array[i];
7547 we generate a new induction variable and new accesses to
7548 form a new vector (or vectors, depending on ncopies):
7550 for (j = 0; ; j += VF*stride)
7551 tmp1 = array[j];
7552 tmp2 = array[j + stride];
7553 ...
7554 vectemp = {tmp1, tmp2, ...}
7555 */
7581 {
7583 {
7584 /* First check if vec_init optab supports construction from
7585 vector elts directly. */
7587 machine_mode vmode;
7594 {
7598 }
7599 else
7600 {
7601 /* Otherwise avoid emitting a constructor of vector elements
7602 by performing the loads using an integer type of the same
7603 size, constructing a vector of those and then
7604 re-interpreting it as the original vector type.
7605 This avoids a huge runtime penalty due to the general
7606 inability to perform store forwarding from smaller stores
7607 to a larger load. */
7608 unsigned lsize
7612 /* If we can't construct such a vector fall back to
7613 element loads of the original vector type. */
7619 {
7624 }
7625 }
7626 }
7627 else
7628 {
7632 }
7634 }
7636 {
7637 /* For SLP permutation support we need to load the whole group,
7638 not only the number of vector stmts the permutation result
7639 fits in. */
7641 {
7642 /* We don't yet generate SLP_TREE_LOAD_PERMUTATIONs for
7643 variable VF. */
7647 }
7648 else
7650 }
7652 unsigned HOST_WIDE_INT
7655 {
7659 {
7673 {
7681 }
7682 }
7684 {
7689 {
7691 VIEW_CONVERT_EXPR,
7695 }
7696 }
7699 {
7702 else
7704 }
7705 else
7706 {
7709 else
7712 }
7713 }
7715 {
7719 }
7721 }
7728 {
7731 /* For SLP vectorization we directly vectorize a subchain
7732 without permutation. */
7735 /* For BB vectorization always use the first stmt to base
7736 the data ref pointer on. */
7740 /* Check if the chain of loads is already vectorized. */
7742 /* For SLP we would need to copy over SLP_TREE_VEC_STMTS.
7743 ??? But we can only do so if there is exactly one
7744 as we have no way to get at the rest. Leave the CSE
7745 opportunity alone.
7746 ??? With the group load eventually participating
7747 in multiple different permutations (having multiple
7748 slp nodes which refer to the same group) the CSE
7749 is even wrong code. See PR56270. */
7751 {
7754 }
7758 /* VEC_NUM is the number of vect stmts to be created for this group. */
7760 {
7762 /* For SLP permutation support we need to load the whole group,
7763 not only the number of vector stmts the permutation result
7764 fits in. */
7766 {
7767 /* We don't yet generate SLP_TREE_LOAD_PERMUTATIONs for
7768 variable VF. */
7773 }
7774 else
7775 {
7777 group_gap_adj
7779 }
7780 }
7781 else
7785 }
7786 else
7787 {
7793 }
7797 vec_loop_masks *loop_masks
7801 /* Targets with store-lane instructions must not require explicit
7802 realignment. vect_supportable_dr_alignment always returns either
7803 dr_aligned or dr_unaligned_supported for masked operations. */
7805 && !mask
7810 /* In case the vectorization factor (VF) is bigger than the number
7811 of elements that we can fit in a vectype (nunits), we have to generate
7812 more than one vector stmt - i.e - we need to "unroll" the
7813 vector stmt by a factor VF/nunits. In doing so, we record a pointer
7814 from one copy of the vector stmt to the next, in the field
7815 STMT_VINFO_RELATED_STMT. This is necessary in order to allow following
7816 stages to find the correct vector defs to be used when vectorizing
7817 stmts that use the defs of the current stmt. The example below
7818 illustrates the vectorization process when VF=16 and nunits=4 (i.e., we
7819 need to create 4 vectorized stmts):
7821 before vectorization:
7822 RELATED_STMT VEC_STMT
7823 S1: x = memref - -
7824 S2: z = x + 1 - -
7826 step 1: vectorize stmt S1:
7827 We first create the vector stmt VS1_0, and, as usual, record a
7828 pointer to it in the STMT_VINFO_VEC_STMT of the scalar stmt S1.
7829 Next, we create the vector stmt VS1_1, and record a pointer to
7830 it in the STMT_VINFO_RELATED_STMT of the vector stmt VS1_0.
7831 Similarly, for VS1_2 and VS1_3. This is the resulting chain of
7832 stmts and pointers:
7833 RELATED_STMT VEC_STMT
7834 VS1_0: vx0 = memref0 VS1_1 -
7835 VS1_1: vx1 = memref1 VS1_2 -
7836 VS1_2: vx2 = memref2 VS1_3 -
7837 VS1_3: vx3 = memref3 - -
7838 S1: x = load - VS1_0
7839 S2: z = x + 1 - -
7841 See in documentation in vect_get_vec_def_for_stmt_copy for how the
7842 information we recorded in RELATED_STMT field is used to vectorize
7843 stmt S2. */
7845 /* In case of interleaving (non-unit grouped access):
7847 S1: x2 = &base + 2
7848 S2: x0 = &base
7849 S3: x1 = &base + 1
7850 S4: x3 = &base + 3
7852 Vectorized loads are created in the order of memory accesses
7853 starting from the access of the first stmt of the chain:
7855 VS1: vx0 = &base
7856 VS2: vx1 = &base + vec_size*1
7857 VS3: vx3 = &base + vec_size*2
7858 VS4: vx4 = &base + vec_size*3
7860 Then permutation statements are generated:
7862 VS5: vx5 = VEC_PERM_EXPR < vx0, vx1, { 0, 2, ..., i*2 } >
7863 VS6: vx6 = VEC_PERM_EXPR < vx0, vx1, { 1, 3, ..., i*2+1 } >
7864 ...
7866 And they are put in STMT_VINFO_VEC_STMT of the corresponding scalar stmts
7867 (the order of the data-refs in the output of vect_permute_load_chain
7868 corresponds to the order of scalar stmts in the interleaving chain - see
7869 the documentation of vect_permute_load_chain()).
7870 The generation of permutation stmts and recording them in
7871 STMT_VINFO_VEC_STMT is done in vect_transform_grouped_load().
7873 In case of both multiple types and interleaving, the vector loads and
7874 permutation stmts above are created for every copy. The result vector
7875 stmts are put in STMT_VINFO_VEC_STMT for the first copy and in the
7876 corresponding STMT_VINFO_RELATED_STMT for the next copies. */
7878 /* If the data reference is aligned (dr_aligned) or potentially unaligned
7879 on a target that supports unaligned accesses (dr_unaligned_supported)
7880 we generate the following code:
7881 p = initial_addr;
7882 indx = 0;
7883 loop {
7884 p = p + indx * vectype_size;
7885 vec_dest = *(p);
7886 indx = indx + 1;
7887 }
7889 Otherwise, the data reference is potentially unaligned on a target that
7890 does not support unaligned accesses (dr_explicit_realign_optimized) -
7891 then generate the following code, in which the data in each iteration is
7892 obtained by two vector loads, one from the previous iteration, and one
7893 from the current iteration:
7894 p1 = initial_addr;
7895 msq_init = *(floor(p1))
7896 p2 = initial_addr + VS - 1;
7897 realignment_token = call target_builtin;
7898 indx = 0;
7899 loop {
7900 p2 = p2 + indx * vectype_size
7901 lsq = *(floor(p2))
7902 vec_dest = realign_load (msq, lsq, realignment_token)
7903 indx = indx + 1;
7904 msq = lsq;
7905 } */
7907 /* If the misalignment remains the same throughout the execution of the
7908 loop, we can create the init_addr and permutation mask at the loop
7909 preheader. Otherwise, it needs to be created inside the loop.
7910 This can only occur when vectorizing memory accesses in the inner-loop
7911 nested within an outer-loop that is being vectorized. */
7916 {
7919 }
7924 {
7929 {
7932 size_one_node);
7933 }
7934 }
7935 else
7941 tree bump;
7944 {
7947 }
7949 {
7953 }
7954 else
7955 {
7958 else
7961 }
7967 {
7968 /* 1. Create the vector or array pointer update chain. */
7970 {
7971 bool simd_lane_access_p
7982 {
7986 }
7989 {
7990 dataref_ptr
7995 /* Adjust the pointer by the difference to first_stmt. */
7996 data_reference_p ptrdr
8004 }
8006 {
8010 }
8011 else
8012 dataref_ptr
8019 mask_vectype);
8020 }
8021 else
8022 {
8025 bump);
8028 vec_offset);
8029 else
8034 }
8040 {
8041 tree vec_array;
8055 {
8056 /* Emit:
8057 VEC_ARRAY = MASK_LOAD_LANES (DATAREF_PTR, ALIAS_PTR,
8058 VEC_MASK). */
8063 final_mask);
8064 }
8065 else
8066 {
8067 /* Emit:
8068 VEC_ARRAY = LOAD_LANES (MEM_REF[...all elements...]). */
8071 }
8077 /* Extract each vector into an SSA_NAME. */
8079 {
8083 }
8085 /* Record the mapping between SSA_NAMEs and statements. */
8087 }
8088 else
8089 {
8091 {
8106 /* 2. Create the vector-load in the loop. */
8108 {
8111 {
8115 {
8119 call = gimple_build_call_internal
8122 else
8123 call = gimple_build_call_internal
8130 }
8134 {
8137 }
8139 {
8142 }
8143 else
8151 {
8154 gcall *call
8157 final_mask);
8161 }
8162 else
8163 {
8164 data_ref
8166 dataref_offset
8167 ? dataref_offset
8170 ;
8175 else
8179 }
8181 }
8183 {
8191 dr_explicit_realign,
8196 else
8199 new_stmt = gimple_build_assign
8201 build_int_cst
8205 data_ref
8209 vectype);
8222 new_stmt = gimple_build_assign
8224 build_int_cst
8229 data_ref
8233 }
8235 {
8238 else
8241 new_stmt = gimple_build_assign
8246 data_ref
8250 }
8253 }
8255 /* DATA_REF is null if we've already built the statement. */
8262 /* 3. Handle explicit realignment if necessary/supported.
8263 Create in loop:
8264 vec_dest = realign_load (msq, lsq, realignment_token) */
8267 {
8279 {
8284 UNKNOWN_LOCATION);
8286 }
8287 }
8289 /* 4. Handle invariant-load. */
8291 {
8293 /* If we have versioned for aliasing or the loop doesn't
8294 have any data dependencies that would preclude this,
8295 then we are sure this is a loop invariant load and
8296 thus we can insert it on the preheader edge. */
8298 && !nested_in_vect_loop
8300 {
8302 {
8304 "hoisting out of the vectorized "
8307 }
8309 gsi_insert_on_edge_immediate
8312 unshare_expr
8318 }
8319 else
8320 {
8326 }
8327 }
8330 {
8335 }
8337 /* Collect vector loads and later create their permutation in
8338 vect_transform_grouped_load (). */
8342 /* Store vector loads in the corresponding SLP_NODE. */
8346 /* With SLP permutation we load the gaps as well, without
8347 we need to skip the gaps after we manage to fully load
8348 all elements. group_gap_adj is GROUP_SIZE here. */
8351 && !slp_perm
8353 {
8354 poly_wide_int bump_val
8361 }
8362 }
8363 /* Bump the vector pointer to account for a gap or for excess
8364 elements loaded for a permuted SLP load. */
8366 {
8367 poly_wide_int bump_val
8373 }
8374 }
8380 {
8385 {
8388 }
8389 }
8390 else
8391 {
8393 {
8397 }
8398 else
8399 {
8402 else
8405 }
8406 }
8408 }
8411 }
8413 /* Function vect_is_simple_cond.
8415 Input:
8416 LOOP - the loop that is being vectorized.
8417 COND - Condition that is checked for simple use.
8419 Output:
8420 *COMP_VECTYPE - the vector type for the comparison.
8421 *DTS - The def types for the arguments of the comparison
8423 Returns whether a COND can be vectorized. Checks whether
8424 condition operands are supportable using vec_is_simple_use. */
8426 static bool
8429 tree vectype)
8430 {
8434 /* Mask case. */
8437 {
8441 || !*comp_vectype
8445 }
8454 {
8458 }
8462 else
8466 {
8470 }
8474 else
8483 /* Invariant comparison. */
8485 {
8487 /* If we can widen the comparison to match vectype do so. */
8491 scalar_type = build_nonstandard_integer_type
8495 }
8498 }
8500 /* vectorizable_condition.
8502 Check if STMT is conditional modify expression that can be vectorized.
8503 If VEC_STMT is also passed, vectorize the STMT: create a vectorized
8504 stmt using VEC_COND_EXPR to replace it, put it in VEC_STMT, and insert it
8505 at GSI.
8507 When STMT is vectorized as nested cycle, REDUC_DEF is the vector variable
8508 to be used at REDUC_INDEX (in then clause if REDUC_INDEX is 1, and in
8509 else clause if it is 2).
8511 Return FALSE if not a vectorizable STMT, TRUE otherwise. */
8513 bool
8516 slp_tree slp_node)
8517 {
8526 tree vec_compare;
8527 tree new_temp;
8542 tree vec_cmp_type;
8548 vect_reduction_type reduction_type
8551 {
8560 /* FORNOW: not yet supported. */
8562 {
8567 }
8568 }
8570 /* Is vectorizable conditional operation? */
8584 else
8622 {
8625 }
8628 {
8629 /* Boolean values may have another representation in vectors
8630 and therefore we prefer bit operations over comparison for
8631 them (which also works for scalar masks). We store opcodes
8632 to use in bitop1 and bitop2. Statement is vectorized as
8633 BITOP2 (rhs1 BITOP1 rhs2) or rhs1 BITOP2 (BITOP1 rhs2)
8634 depending on bitop1 and bitop2 arity. */
8636 {
8664 }
8666 }
8669 {
8672 {
8674 optab optab;
8681 {
8683 optab_default);
8686 }
8687 }
8689 cond_code))
8690 {
8694 }
8696 }
8698 /* Transform. */
8701 {
8706 }
8708 /* Handle def. */
8713 /* Handle cond expr. */
8715 {
8718 {
8720 {
8726 else
8727 {
8730 }
8739 }
8740 else
8741 {
8744 {
8745 vec_cond_lhs
8747 comp_vectype);
8750 }
8751 else
8752 {
8753 vec_cond_lhs
8758 vec_cond_rhs
8762 }
8765 else
8766 {
8768 stmt);
8771 }
8774 else
8775 {
8777 stmt);
8779 }
8780 }
8781 }
8782 else
8783 {
8784 vec_cond_lhs
8788 vec_cond_rhs
8796 }
8799 {
8805 }
8807 /* Arguments are ready. Create the new vector stmt. */
8809 {
8815 else
8816 {
8821 else
8822 {
8826 vec_cond_rhs);
8827 else
8828 new_stmt
8830 vec_cond_rhs);
8835 {
8836 /* Instead of doing ~x ? y : z do x ? z : y. */
8839 }
8840 else
8841 {
8843 new_stmt
8847 }
8848 }
8849 }
8851 {
8853 {
8856 vec_compare);
8859 }
8861 new_stmt = gimple_build_call_internal
8863 vec_then_clause);
8868 else
8869 {
8870 /* In this case we're moving the definition to later in the
8871 block. That doesn't matter because the only uses of the
8872 lhs are in phi statements. */
8876 }
8877 }
8878 else
8879 {
8883 vec_else_clause);
8885 }
8888 }
8895 else
8899 }
8907 }
8909 /* vectorizable_comparison.
8911 Check if STMT is comparison expression that can be vectorized.
8912 If VEC_STMT is also passed, vectorize the STMT: create a vectorized
8913 comparison, put it in VEC_STMT, and insert it at GSI.
8915 Return FALSE if not a vectorizable STMT, TRUE otherwise. */
8917 static bool
8920 slp_tree slp_node)
8921 {
8927 tree new_temp;
8931 poly_uint64 nunits;
8940 tree mask_type;
8941 tree mask;
8954 else
8964 {
8969 }
8997 /* Invariant comparison. */
8999 {
9003 }
9007 /* Can't compare mask and non-mask types. */
9012 /* Boolean values may have another representation in vectors
9013 and therefore we prefer bit operations over comparison for
9014 them (which also works for scalar masks). We store opcodes
9015 to use in bitop1 and bitop2. Statement is vectorized as
9016 BITOP2 (rhs1 BITOP1 rhs2) or
9017 rhs1 BITOP2 (BITOP1 rhs2)
9018 depending on bitop1 and bitop2 arity. */
9020 {
9022 {
9025 }
9027 {
9030 }
9032 {
9037 }
9039 {
9044 }
9045 else
9046 {
9050 }
9051 }
9054 {
9061 else
9062 {
9064 optab optab;
9071 {
9075 }
9077 }
9078 }
9080 /* Transform. */
9082 {
9085 }
9087 /* Handle def. */
9091 /* Handle cmp expr. */
9093 {
9096 {
9098 {
9107 }
9108 else
9109 {
9112 }
9113 }
9114 else
9115 {
9120 }
9123 {
9126 }
9128 /* Arguments are ready. Create the new vector stmt. */
9130 {
9135 {
9139 }
9140 else
9141 {
9144 else
9146 vec_rhs2);
9149 {
9153 else
9155 new_temp);
9157 }
9158 }
9161 }
9168 else
9172 }
9178 }
9180 /* If SLP_NODE is nonnull, return true if vectorizable_live_operation
9181 can handle all live statements in the node. Otherwise return true
9182 if STMT is not live or if vectorizable_live_operation can handle it.
9183 GSI and VEC_STMT are as for vectorizable_live_operation. */
9185 static bool
9188 {
9190 {
9194 {
9198 vec_stmt))
9200 }
9201 }
9207 }
9209 /* Make sure the statement is vectorizable. */
9211 bool
9213 slp_instance node_instance)
9214 {
9220 gimple_seq pattern_def_seq;
9223 {
9226 }
9229 {
9235 }
9237 /* Skip stmts that do not need to be vectorized. In loops this is expected
9238 to include:
9239 - the COND_EXPR which is the loop exit condition
9240 - any LABEL_EXPRs in the loop
9241 - computations that are used only for array indexing or loop control.
9242 In basic blocks we only analyze statements that are a part of some SLP
9243 instance, therefore, all the statements are relevant.
9245 Pattern statement needs to be analyzed instead of the original statement
9246 if the original statement is not relevant. Otherwise, we analyze both
9247 statements. In basic blocks we are called from some SLP instance
9248 traversal, don't analyze pattern stmts instead, the pattern stmts
9249 already will be part of SLP instance. */
9254 {
9256 && pattern_stmt
9259 {
9260 /* Analyze PATTERN_STMT instead of the original stmt. */
9264 {
9268 }
9269 }
9270 else
9271 {
9276 }
9277 }
9280 && pattern_stmt
9283 {
9284 /* Analyze PATTERN_STMT too. */
9286 {
9290 }
9293 node_instance))
9295 }
9300 {
9301 gimple_stmt_iterator si;
9304 {
9308 {
9309 /* Analyze def stmt of STMT if it's a pattern stmt. */
9311 {
9315 }
9320 }
9321 }
9322 }
9325 {
9348 }
9351 {
9357 }
9360 {
9364 }
9382 else
9383 {
9395 }
9398 {
9400 {
9405 }
9408 }
9413 /* Stmts that are (also) "live" (i.e. - that are used out of the loop)
9414 need extra handling, except for vectorizable reductions. */
9417 {
9419 {
9423 }
9426 }
9429 }
9432 /* Function vect_transform_stmt.
9434 Create a vectorized stmt to replace STMT, and insert it at BSI. */
9436 bool
9439 slp_instance slp_node_instance)
9440 {
9450 && nested_in_vect_loop_p
9452 stmt));
9455 {
9485 slp_node_instance);
9493 {
9494 /* In case of interleaving, the whole chain is vectorized when the
9495 last store in the chain is reached. Store stmts before the last
9496 one are skipped, and there vec_stmt_info shouldn't be freed
9497 meanwhile. */
9499 stmt_vec_info group_info
9503 }
9504 else
9530 slp_node_instance);
9536 {
9541 }
9542 }
9544 /* Verify SLP vectorization doesn't mess with STMT_VINFO_VEC_STMT.
9545 This would break hybrid SLP vectorization. */
9550 /* Handle inner-loop stmts whose DEF is used in the loop-nest that
9551 is being vectorized, but outside the immediately enclosing loop. */
9553 && nested_p
9557 vect_used_in_outer_by_reduction))
9558 {
9561 imm_use_iterator imm_iter;
9562 use_operand_p use_p;
9563 tree scalar_dest;
9570 /* Find the relevant loop-exit phi-node, and reord the vec_stmt there
9571 (to be used when vectorizing outer-loop stmts that use the DEF of
9572 STMT). */
9575 else
9579 {
9581 {
9584 }
9585 }
9586 }
9588 /* Handle stmts whose DEF is used outside the loop-nest that is
9589 being vectorized. */
9591 {
9594 }
9600 }
9603 /* Remove a group of stores (for SLP or interleaving), free their
9604 stmt_vec_info. */
9606 void
9608 {
9611 gimple_stmt_iterator next_si;
9614 {
9620 /* Free the attached stmt_vec_info and remove the stmt. */
9627 }
9628 }
9631 /* Function new_stmt_vec_info.
9633 Create and initialize a new stmt_vec_info struct for STMT. */
9635 stmt_vec_info
9637 {
9638 stmt_vec_info res;
9659 else
9674 }
9677 /* Create a hash table for stmt_vec_info. */
9679 void
9681 {
9684 }
9687 /* Free hash table for stmt_vec_info. */
9689 void
9691 {
9693 stmt_vec_info info;
9699 }
9702 /* Free stmt vectorization related info. */
9704 void
9706 {
9712 /* Check if this statement has a related "pattern stmt"
9713 (introduced by the vectorizer during the pattern recognition
9714 pass). Free pattern's stmt_vec_info and def stmt's stmt_vec_info
9715 too. */
9717 {
9718 stmt_vec_info patt_info
9721 {
9729 {
9730 gimple_stmt_iterator si;
9732 {
9739 }
9740 }
9742 }
9743 }
9749 }
9752 /* Function get_vectype_for_scalar_type_and_size.
9754 Returns the vector type corresponding to SCALAR_TYPE and SIZE as supported
9755 by the target. */
9757 tree
9759 {
9761 scalar_mode inner_mode;
9762 machine_mode simd_mode;
9763 poly_uint64 nunits;
9764 tree vectype;
9772 /* For vector types of elements whose mode precision doesn't
9773 match their types precision we use a element type of mode
9774 precision. The vectorization routines will have to make sure
9775 they support the proper result truncation/extension.
9776 We also make sure to build vector types with INTEGER_TYPE
9777 component type only. */
9784 /* We shouldn't end up building VECTOR_TYPEs of non-scalar components.
9785 When the component mode passes the above test simply use a type
9786 corresponding to that mode. The theory is that any use that
9787 would cause problems with this will disable vectorization anyway. */
9792 /* We can't build a vector type of elements with alignment bigger than
9793 their size. */
9798 /* If we felt back to using the mode fail if there was
9799 no scalar type for it. */
9803 /* If no size was supplied use the mode the target prefers. Otherwise
9804 lookup a vector mode of the specified size. */
9810 /* NOTE: nunits == 1 is allowed to support single element vector types. */
9820 /* Re-attach the address-space qualifier if we canonicalized the scalar
9821 type. */
9823 return build_qualified_type
9827 }
9829 poly_uint64 current_vector_size;
9831 /* Function get_vectype_for_scalar_type.
9833 Returns the vector type corresponding to SCALAR_TYPE as supported
9834 by the target. */
9836 tree
9838 {
9839 tree vectype;
9841 current_vector_size);
9846 }
9848 /* Function get_mask_type_for_scalar_type.
9850 Returns the mask type corresponding to a result of comparison
9851 of vectors of specified SCALAR_TYPE as supported by target. */
9853 tree
9855 {
9862 current_vector_size);
9863 }
9865 /* Function get_same_sized_vectype
9867 Returns a vector type corresponding to SCALAR_TYPE of size
9868 VECTOR_TYPE if supported by the target. */
9870 tree
9872 {
9876 return get_vectype_for_scalar_type_and_size
9878 }
9880 /* Function vect_is_simple_use.
9882 Input:
9883 VINFO - the vect info of the loop or basic block that is being vectorized.
9884 OPERAND - operand in the loop or bb.
9885 Output:
9886 DEF_STMT - the defining stmt in case OPERAND is an SSA_NAME.
9887 DT - the type of definition
9889 Returns whether a stmt with OPERAND can be vectorized.
9890 For loops, supportable operands are constants, loop invariants, and operands
9891 that are defined by the current iteration of the loop. Unsupportable
9892 operands are those that are defined by a previous iteration of the loop (as
9893 is the case in reduction/induction computations).
9894 For basic blocks, supportable operands are constants and bb invariants.
9895 For now, operands defined outside the basic block are not supported. */
9897 bool
9900 {
9905 {
9910 }
9913 {
9916 }
9919 {
9922 }
9925 {
9930 }
9933 {
9936 }
9940 {
9943 }
9947 else
9948 {
9951 }
9954 {
9957 {
9985 }
9986 }
9989 {
9994 }
9997 {
10007 }
10010 }
10012 /* Function vect_is_simple_use.
10014 Same as vect_is_simple_use but also determines the vector operand
10015 type of OPERAND and stores it to *VECTYPE. If the definition of
10016 OPERAND is vect_uninitialized_def, vect_constant_def or
10017 vect_external_def *VECTYPE will be set to NULL_TREE and the caller
10018 is responsible to compute the best suited vector type for the
10019 scalar operand. */
10021 bool
10024 {
10028 /* Now get a vector type if the def is internal, otherwise supply
10029 NULL_TREE and leave it up to the caller to figure out a proper
10030 type for the use stmt. */
10036 {
10046 }
10051 else
10055 }
10058 /* Function supportable_widening_operation
10060 Check whether an operation represented by the code CODE is a
10061 widening operation that is supported by the target platform in
10062 vector form (i.e., when operating on arguments of type VECTYPE_IN
10063 producing a result of type VECTYPE_OUT).
10065 Widening operations we currently support are NOP (CONVERT), FLOAT
10066 and WIDEN_MULT. This function checks if these operations are supported
10067 by the target platform either directly (via vector tree-codes), or via
10068 target builtins.
10070 Output:
10071 - CODE1 and CODE2 are codes of vector operations to be used when
10072 vectorizing the operation, if available.
10073 - MULTI_STEP_CVT determines the number of required intermediate steps in
10074 case of multi-step conversion (like char->short->int - in that case
10075 MULTI_STEP_CVT will be 1).
10076 - INTERM_TYPES contains the intermediate type required to perform the
10077 widening operation (short in the above example). */
10079 bool
10085 {
10089 machine_mode vec_mode;
10105 {
10107 /* The result of a vectorized widening operation usually requires
10108 two vectors (because the widened results do not fit into one vector).
10109 The generated vector results would normally be expected to be
10110 generated in the same order as in the original scalar computation,
10111 i.e. if 8 results are generated in each vector iteration, they are
10112 to be organized as follows:
10113 vect1: [res1,res2,res3,res4],
10114 vect2: [res5,res6,res7,res8].
10116 However, in the special case that the result of the widening
10117 operation is used in a reduction computation only, the order doesn't
10118 matter (because when vectorizing a reduction we change the order of
10119 the computation). Some targets can take advantage of this and
10120 generate more efficient code. For example, targets like Altivec,
10121 that support widen_mult using a sequence of {mult_even,mult_odd}
10122 generate the following vectors:
10123 vect1: [res1,res3,res5,res7],
10124 vect2: [res2,res4,res6,res8].
10126 When vectorizing outer-loops, we execute the inner-loop sequentially
10127 (each vectorized inner-loop iteration contributes to VF outer-loop
10128 iterations in parallel). We therefore don't allow to change the
10129 order of the computation in the inner-loop during outer-loop
10130 vectorization. */
10131 /* TODO: Another case in which order doesn't *really* matter is when we
10132 widen and then contract again, e.g. (short)((int)x * y >> 8).
10133 Normally, pack_trunc performs an even/odd permute, whereas the
10134 repack from an even/odd expansion would be an interleave, which
10135 would be significantly simpler for e.g. AVX2. */
10136 /* In any case, in order to avoid duplicating the code below, recurse
10137 on VEC_WIDEN_MULT_EVEN_EXPR. If it succeeds, all the return values
10138 are properly set up for the caller. If we fail, we'll continue with
10139 a VEC_WIDEN_MULT_LO/HI_EXPR check. */
10146 interm_types))
10147 {
10148 /* Elements in a vector with vect_used_by_reduction property cannot
10149 be reordered if the use chain with this property does not have the
10150 same operation. One such an example is s += a * b, where elements
10151 in a and b cannot be reordered. Here we check if the vector defined
10152 by STMT is only directly used in the reduction statement. */
10154 use_operand_p dummy;
10161 }
10177 /* Support the recursion induced just above. */
10187 CASE_CONVERT:
10198 /* ??? Not yet implemented due to missing VEC_UNPACK_FIX_TRUNC_HI_EXPR/
10199 VEC_UNPACK_FIX_TRUNC_LO_EXPR tree codes and optabs used for
10200 computing the operation. */
10205 }
10211 {
10212 /* The signedness is determined from output operand. */
10215 }
10216 else
10217 {
10220 }
10235 /* For scalar masks we may have different boolean
10236 vector types having the same QImode. Thus we
10237 add additional check for elements number. */
10242 /* Check if it's a multi-step conversion that can be done using intermediate
10243 types. */
10251 /* We assume here that there will not be more than MAX_INTERM_CVT_STEPS
10252 intermediate steps in promotion sequence. We try
10253 MAX_INTERM_CVT_STEPS to get to NARROW_VECTYPE, and fail if we do
10254 not. */
10257 {
10260 {
10264 }
10265 else
10266 intermediate_type
10295 }
10299 }
10302 /* Function supportable_narrowing_operation
10304 Check whether an operation represented by the code CODE is a
10305 narrowing operation that is supported by the target platform in
10306 vector form (i.e., when operating on arguments of type VECTYPE_IN
10307 and producing a result of type VECTYPE_OUT).
10309 Narrowing operations we currently support are NOP (CONVERT) and
10310 FIX_TRUNC. This function checks if these operations are supported by
10311 the target platform directly via vector tree-codes.
10313 Output:
10314 - CODE1 is the code of a vector operation to be used when
10315 vectorizing the operation, if available.
10316 - MULTI_STEP_CVT determines the number of required intermediate steps in
10317 case of multi-step conversion (like int->short->char - in that case
10318 MULTI_STEP_CVT will be 1).
10319 - INTERM_TYPES contains the intermediate type required to perform the
10320 narrowing operation (short in the above example). */
10322 bool
10327 {
10328 machine_mode vec_mode;
10341 {
10342 CASE_CONVERT:
10351 /* ??? Not yet implemented due to missing VEC_PACK_FLOAT_EXPR
10352 tree code and optabs used for computing the operation. */
10357 }
10360 /* The signedness is determined from output operand. */
10362 else
10375 /* For scalar masks we may have different boolean
10376 vector types having the same QImode. Thus we
10377 add additional check for elements number. */
10382 /* Check if it's a multi-step conversion that can be done using intermediate
10383 types. */
10388 else
10391 /* For multi-step FIX_TRUNC_EXPR prefer signed floating to integer
10392 conversion over unsigned, as unsigned FIX_TRUNC_EXPR is often more
10393 costly than signed. */
10395 {
10398 intermediate_type
10400 interm_optab
10406 {
10410 }
10411 }
10413 /* We assume here that there will not be more than MAX_INTERM_CVT_STEPS
10414 intermediate steps in promotion sequence. We try
10415 MAX_INTERM_CVT_STEPS to get to NARROW_VECTYPE, and fail if we do not. */
10418 {
10421 {
10425 }
10426 else
10427 intermediate_type
10429 interm_optab
10431 optab_default);
10450 }
10454 }
10456 /* Generate and return a statement that sets vector mask MASK such that
10457 MASK[I] is true iff J + START_INDEX < END_INDEX for all J <= I. */
10459 gcall *
10461 {
10466 OPTIMIZE_FOR_SPEED));
10472 }
10474 /* Generate a vector mask of type MASK_TYPE for which index I is false iff
10475 J + START_INDEX < END_INDEX for all J <= I. Add the statements to SEQ. */
10477 tree
10479 tree end_index)
10480 {
10485 }