Lines Matching +full:non +full:- +full:interleaved
1 /*===---- avxintrin.h - AVX intrinsics -------------------------------------===
5 * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 *===-----------------------------------------------------------------------===
54 __attribute__((__always_inline__, __nodebug__, __target__("avx,no-evex512"), \
57 __attribute__((__always_inline__, __nodebug__, __target__("avx,no-evex512"), \
61 /// Adds two 256-bit vectors of [4 x double].
68 /// A 256-bit vector of [4 x double] containing one of the source operands.
70 /// A 256-bit vector of [4 x double] containing one of the source operands.
71 /// \returns A 256-bit vector of [4 x double] containing the sums of both
79 /// Adds two 256-bit vectors of [8 x float].
86 /// A 256-bit vector of [8 x float] containing one of the source operands.
88 /// A 256-bit vector of [8 x float] containing one of the source operands.
89 /// \returns A 256-bit vector of [8 x float] containing the sums of both
97 /// Subtracts two 256-bit vectors of [4 x double].
104 /// A 256-bit vector of [4 x double] containing the minuend.
106 /// A 256-bit vector of [4 x double] containing the subtrahend.
107 /// \returns A 256-bit vector of [4 x double] containing the differences between
112 return (__m256d)((__v4df)__a-(__v4df)__b); in _mm256_sub_pd()
115 /// Subtracts two 256-bit vectors of [8 x float].
122 /// A 256-bit vector of [8 x float] containing the minuend.
124 /// A 256-bit vector of [8 x float] containing the subtrahend.
125 /// \returns A 256-bit vector of [8 x float] containing the differences between
130 return (__m256)((__v8sf)__a-(__v8sf)__b); in _mm256_sub_ps()
133 /// Adds the even-indexed values and subtracts the odd-indexed values of
134 /// two 256-bit vectors of [4 x double].
141 /// A 256-bit vector of [4 x double] containing the left source operand.
143 /// A 256-bit vector of [4 x double] containing the right source operand.
144 /// \returns A 256-bit vector of [4 x double] containing the alternating sums
152 /// Adds the even-indexed values and subtracts the odd-indexed values of
153 /// two 256-bit vectors of [8 x float].
160 /// A 256-bit vector of [8 x float] containing the left source operand.
162 /// A 256-bit vector of [8 x float] containing the right source operand.
163 /// \returns A 256-bit vector of [8 x float] containing the alternating sums and
171 /// Divides two 256-bit vectors of [4 x double].
178 /// A 256-bit vector of [4 x double] containing the dividend.
180 /// A 256-bit vector of [4 x double] containing the divisor.
181 /// \returns A 256-bit vector of [4 x double] containing the quotients of both
189 /// Divides two 256-bit vectors of [8 x float].
196 /// A 256-bit vector of [8 x float] containing the dividend.
198 /// A 256-bit vector of [8 x float] containing the divisor.
199 /// \returns A 256-bit vector of [8 x float] containing the quotients of both
207 /// Compares two 256-bit vectors of [4 x double] and returns the greater
217 /// A 256-bit vector of [4 x double] containing one of the operands.
219 /// A 256-bit vector of [4 x double] containing one of the operands.
220 /// \returns A 256-bit vector of [4 x double] containing the maximum values
228 /// Compares two 256-bit vectors of [8 x float] and returns the greater
238 /// A 256-bit vector of [8 x float] containing one of the operands.
240 /// A 256-bit vector of [8 x float] containing one of the operands.
241 /// \returns A 256-bit vector of [8 x float] containing the maximum values
249 /// Compares two 256-bit vectors of [4 x double] and returns the lesser
259 /// A 256-bit vector of [4 x double] containing one of the operands.
261 /// A 256-bit vector of [4 x double] containing one of the operands.
262 /// \returns A 256-bit vector of [4 x double] containing the minimum values
270 /// Compares two 256-bit vectors of [8 x float] and returns the lesser
280 /// A 256-bit vector of [8 x float] containing one of the operands.
282 /// A 256-bit vector of [8 x float] containing one of the operands.
283 /// \returns A 256-bit vector of [8 x float] containing the minimum values
291 /// Multiplies two 256-bit vectors of [4 x double].
298 /// A 256-bit vector of [4 x double] containing one of the operands.
300 /// A 256-bit vector of [4 x double] containing one of the operands.
301 /// \returns A 256-bit vector of [4 x double] containing the products of both
309 /// Multiplies two 256-bit vectors of [8 x float].
316 /// A 256-bit vector of [8 x float] containing one of the operands.
318 /// A 256-bit vector of [8 x float] containing one of the operands.
319 /// \returns A 256-bit vector of [8 x float] containing the products of both
327 /// Calculates the square roots of the values in a 256-bit vector of
335 /// A 256-bit vector of [4 x double].
336 /// \returns A 256-bit vector of [4 x double] containing the square roots of the
344 /// Calculates the square roots of the values in a 256-bit vector of
352 /// A 256-bit vector of [8 x float].
353 /// \returns A 256-bit vector of [8 x float] containing the square roots of the
361 /// Calculates the reciprocal square roots of the values in a 256-bit
369 /// A 256-bit vector of [8 x float].
370 /// \returns A 256-bit vector of [8 x float] containing the reciprocal square
378 /// Calculates the reciprocals of the values in a 256-bit vector of
386 /// A 256-bit vector of [8 x float].
387 /// \returns A 256-bit vector of [8 x float] containing the reciprocals of the
395 /// Rounds the values in a 256-bit vector of [4 x double] as specified
397 /// returned as 64-bit double-precision floating-point values.
408 /// A 256-bit vector of [4 x double].
423 /// \returns A 256-bit vector of [4 x double] containing the rounded values.
427 /// Rounds the values stored in a 256-bit vector of [8 x float] as
429 /// values and returned as floating-point values.
440 /// A 256-bit vector of [8 x float].
455 /// \returns A 256-bit vector of [8 x float] containing the rounded values.
459 /// Rounds up the values stored in a 256-bit vector of [4 x double]. The
460 /// source values are rounded up to integer values and returned as 64-bit
461 /// double-precision floating-point values.
472 /// A 256-bit vector of [4 x double].
473 /// \returns A 256-bit vector of [4 x double] containing the rounded up values.
476 /// Rounds down the values stored in a 256-bit vector of [4 x double].
478 /// 64-bit double-precision floating-point values.
489 /// A 256-bit vector of [4 x double].
490 /// \returns A 256-bit vector of [4 x double] containing the rounded down
494 /// Rounds up the values stored in a 256-bit vector of [8 x float]. The
496 /// floating-point values.
507 /// A 256-bit vector of [8 x float].
508 /// \returns A 256-bit vector of [8 x float] containing the rounded up values.
511 /// Rounds down the values stored in a 256-bit vector of [8 x float]. The
513 /// floating-point values.
524 /// A 256-bit vector of [8 x float].
525 /// \returns A 256-bit vector of [8 x float] containing the rounded down values.
529 /// Performs a bitwise AND of two 256-bit vectors of [4 x double].
536 /// A 256-bit vector of [4 x double] containing one of the source operands.
538 /// A 256-bit vector of [4 x double] containing one of the source operands.
539 /// \returns A 256-bit vector of [4 x double] containing the bitwise AND of the
547 /// Performs a bitwise AND of two 256-bit vectors of [8 x float].
554 /// A 256-bit vector of [8 x float] containing one of the source operands.
556 /// A 256-bit vector of [8 x float] containing one of the source operands.
557 /// \returns A 256-bit vector of [8 x float] containing the bitwise AND of the
565 /// Performs a bitwise AND of two 256-bit vectors of [4 x double], using
573 /// A 256-bit vector of [4 x double] containing the left source operand. The
576 /// A 256-bit vector of [4 x double] containing the right source operand.
577 /// \returns A 256-bit vector of [4 x double] containing the bitwise AND of the
586 /// Performs a bitwise AND of two 256-bit vectors of [8 x float], using
594 /// A 256-bit vector of [8 x float] containing the left source operand. The
597 /// A 256-bit vector of [8 x float] containing the right source operand.
598 /// \returns A 256-bit vector of [8 x float] containing the bitwise AND of the
607 /// Performs a bitwise OR of two 256-bit vectors of [4 x double].
614 /// A 256-bit vector of [4 x double] containing one of the source operands.
616 /// A 256-bit vector of [4 x double] containing one of the source operands.
617 /// \returns A 256-bit vector of [4 x double] containing the bitwise OR of the
625 /// Performs a bitwise OR of two 256-bit vectors of [8 x float].
632 /// A 256-bit vector of [8 x float] containing one of the source operands.
634 /// A 256-bit vector of [8 x float] containing one of the source operands.
635 /// \returns A 256-bit vector of [8 x float] containing the bitwise OR of the
643 /// Performs a bitwise XOR of two 256-bit vectors of [4 x double].
650 /// A 256-bit vector of [4 x double] containing one of the source operands.
652 /// A 256-bit vector of [4 x double] containing one of the source operands.
653 /// \returns A 256-bit vector of [4 x double] containing the bitwise XOR of the
661 /// Performs a bitwise XOR of two 256-bit vectors of [8 x float].
668 /// A 256-bit vector of [8 x float] containing one of the source operands.
670 /// A 256-bit vector of [8 x float] containing one of the source operands.
671 /// \returns A 256-bit vector of [8 x float] containing the bitwise XOR of the
681 /// 256-bit vectors of [4 x double].
688 /// A 256-bit vector of [4 x double] containing one of the source operands.
689 /// The horizontal sums of the values are returned in the even-indexed
692 /// A 256-bit vector of [4 x double] containing one of the source operands.
693 /// The horizontal sums of the values are returned in the odd-indexed
695 /// \returns A 256-bit vector of [4 x double] containing the horizontal sums of
704 /// 256-bit vectors of [8 x float].
711 /// A 256-bit vector of [8 x float] containing one of the source operands.
715 /// A 256-bit vector of [8 x float] containing one of the source operands.
718 /// \returns A 256-bit vector of [8 x float] containing the horizontal sums of
727 /// 256-bit vectors of [4 x double].
734 /// A 256-bit vector of [4 x double] containing one of the source operands.
736 /// even-indexed elements of a vector of [4 x double].
738 /// A 256-bit vector of [4 x double] containing one of the source operands.
740 /// odd-indexed elements of a vector of [4 x double].
741 /// \returns A 256-bit vector of [4 x double] containing the horizontal
750 /// 256-bit vectors of [8 x float].
757 /// A 256-bit vector of [8 x float] containing one of the source operands.
761 /// A 256-bit vector of [8 x float] containing one of the source operands.
764 /// \returns A 256-bit vector of [8 x float] containing the horizontal
773 /// Copies the values in a 128-bit vector of [2 x double] as specified
774 /// by the 128-bit integer vector operand.
781 /// A 128-bit vector of [2 x double].
783 /// A 128-bit integer vector operand specifying how the values are to be
795 /// \returns A 128-bit vector of [2 x double] containing the copied values.
802 /// Copies the values in a 256-bit vector of [4 x double] as specified
803 /// by the 256-bit integer vector operand.
810 /// A 256-bit vector of [4 x double].
812 /// A 256-bit integer vector operand specifying how the values are to be
834 /// \returns A 256-bit vector of [4 x double] containing the copied values.
841 /// Copies the values stored in a 128-bit vector of [4 x float] as
842 /// specified by the 128-bit integer vector operand.
849 /// A 128-bit vector of [4 x float].
851 /// A 128-bit integer vector operand specifying how the values are to be
889 /// \returns A 128-bit vector of [4 x float] containing the copied values.
896 /// Copies the values stored in a 256-bit vector of [8 x float] as
897 /// specified by the 256-bit integer vector operand.
904 /// A 256-bit vector of [8 x float].
906 /// A 256-bit integer vector operand specifying how the values are to be
980 /// \returns A 256-bit vector of [8 x float] containing the copied values.
987 /// Copies the values in a 128-bit vector of [2 x double] as specified
999 /// A 128-bit vector of [2 x double].
1013 /// \returns A 128-bit vector of [2 x double] containing the copied values.
1017 /// Copies the values in a 256-bit vector of [4 x double] as specified by
1029 /// A 256-bit vector of [4 x double].
1053 /// \returns A 256-bit vector of [4 x double] containing the copied values.
1057 /// Copies the values in a 128-bit vector of [4 x float] as specified by
1069 /// A 128-bit vector of [4 x float].
1109 /// \returns A 128-bit vector of [4 x float] containing the copied values.
1113 /// Copies the values in a 256-bit vector of [8 x float] as specified by
1125 /// A 256-bit vector of [8 x float].
1201 /// \returns A 256-bit vector of [8 x float] containing the copied values.
1205 /// Permutes 128-bit data values stored in two 256-bit vectors of
1217 /// A 256-bit vector of [4 x double].
1219 /// A 256-bit vector of [4 x double.
1241 /// \returns A 256-bit vector of [4 x double] containing the copied values.
1246 /// Permutes 128-bit data values stored in two 256-bit vectors of
1258 /// A 256-bit vector of [8 x float].
1260 /// A 256-bit vector of [8 x float].
1282 /// \returns A 256-bit vector of [8 x float] containing the copied values.
1287 /// Permutes 128-bit data values stored in two 256-bit integer vectors,
1299 /// A 256-bit integer vector.
1301 /// A 256-bit integer vector.
1322 /// \returns A 256-bit integer vector containing the copied values.
1328 /// Merges 64-bit double-precision data values stored in either of the
1329 /// two 256-bit vectors of [4 x double], as specified by the immediate
1341 /// A 256-bit vector of [4 x double].
1343 /// A 256-bit vector of [4 x double].
1347 /// index of a copied value. When a mask bit is 0, the corresponding 64-bit
1349 /// destination. When a mask bit is 1, the corresponding 64-bit element in
1351 /// \returns A 256-bit vector of [4 x double] containing the copied values.
1356 /// Merges 32-bit single-precision data values stored in either of the
1357 /// two 256-bit vectors of [8 x float], as specified by the immediate
1369 /// A 256-bit vector of [8 x float].
1371 /// A 256-bit vector of [8 x float].
1375 /// index of a copied value. When a mask bit is 0, the corresponding 32-bit
1377 /// destination. When a mask bit is 1, the corresponding 32-bit element in
1379 /// \returns A 256-bit vector of [8 x float] containing the copied values.
1384 /// Merges 64-bit double-precision data values stored in either of the
1385 /// two 256-bit vectors of [4 x double], as specified by the 256-bit vector
1393 /// A 256-bit vector of [4 x double].
1395 /// A 256-bit vector of [4 x double].
1397 /// A 256-bit vector operand, with mask bits 255, 191, 127, and 63 specifying
1400 /// corresponding 64-bit element in operand \a __a is copied to the same
1402 /// 64-bit element in operand \a __b is copied to the same position in the
1404 /// \returns A 256-bit vector of [4 x double] containing the copied values.
1412 /// Merges 32-bit single-precision data values stored in either of the
1413 /// two 256-bit vectors of [8 x float], as specified by the 256-bit vector
1421 /// A 256-bit vector of [8 x float].
1423 /// A 256-bit vector of [8 x float].
1425 /// A 256-bit vector operand, with mask bits 255, 223, 191, 159, 127, 95, 63,
1428 /// a mask bit is 0, the corresponding 32-bit element in operand \a __a is
1430 /// corresponding 32-bit element in operand \a __b is copied to the same
1432 /// \returns A 256-bit vector of [8 x float] containing the copied values.
1477 /// \returns A 256-bit vector of [8 x float] containing the two dot products.
1483 /// Selects 8 float values from the 256-bit operands of [8 x float], as
1488 /// elements from the first 256-bit operand are copied to bits [63:0] and
1490 /// second 256-bit operand are copied to bits [127:64] and bits [255:192] of
1492 /// contain a value of 0xFF, the 256-bit destination vector would contain the
1504 /// A 256-bit vector of [8 x float]. The four selected elements in this
1508 /// A 256-bit vector of [8 x float]. The four selected elements in this
1512 /// An immediate value containing an 8-bit value specifying which elements to
1516 /// The destinations within the 256-bit destination are assigned values as
1532 /// <c>_MM_SHUFFLE(b6, b4, b2, b0)</c> can create an 8-bit mask of the form
1534 /// \returns A 256-bit vector of [8 x float] containing the shuffled values.
1539 /// Selects four double-precision values from the 256-bit operands of
1542 /// The selected elements from the first 256-bit operand are copied to bits
1544 /// from the second 256-bit operand are copied to bits [127:64] and bits
1546 /// operand contain a value of 0xF, the 256-bit destination vector would
1558 /// A 256-bit vector of [4 x double].
1560 /// A 256-bit vector of [4 x double].
1562 /// An immediate value containing 8-bit values specifying which elements to
1580 /// \returns A 256-bit vector of [4 x double] containing the shuffled values.
1586 #define _CMP_EQ_UQ 0x08 /* Equal (unordered, non-signaling) */
1587 #define _CMP_NGE_US 0x09 /* Not-greater-than-or-equal (unordered, signaling) */
1588 #define _CMP_NGT_US 0x0a /* Not-greater-than (unordered, signaling) */
1589 #define _CMP_FALSE_OQ 0x0b /* False (ordered, non-signaling) */
1590 #define _CMP_NEQ_OQ 0x0c /* Not-equal (ordered, non-signaling) */
1591 #define _CMP_GE_OS 0x0d /* Greater-than-or-equal (ordered, signaling) */
1592 #define _CMP_GT_OS 0x0e /* Greater-than (ordered, signaling) */
1593 #define _CMP_TRUE_UQ 0x0f /* True (unordered, non-signaling) */
1595 #define _CMP_LT_OQ 0x11 /* Less-than (ordered, non-signaling) */
1596 #define _CMP_LE_OQ 0x12 /* Less-than-or-equal (ordered, non-signaling) */
1598 #define _CMP_NEQ_US 0x14 /* Not-equal (unordered, signaling) */
1599 #define _CMP_NLT_UQ 0x15 /* Not-less-than (unordered, non-signaling) */
1600 #define _CMP_NLE_UQ 0x16 /* Not-less-than-or-equal (unordered, non-signaling) */
1603 #define _CMP_NGE_UQ 0x19 /* Not-greater-than-or-equal (unordered, non-signaling) */
1604 #define _CMP_NGT_UQ 0x1a /* Not-greater-than (unordered, non-signaling) */
1606 #define _CMP_NEQ_OS 0x1c /* Not-equal (ordered, signaling) */
1607 #define _CMP_GE_OQ 0x1d /* Greater-than-or-equal (ordered, non-signaling) */
1608 #define _CMP_GT_OQ 0x1e /* Greater-than (ordered, non-signaling) */
1612 /// Compares each of the corresponding double-precision values of two
1613 /// 128-bit vectors of [2 x double], using the operation specified by the
1629 /// A 128-bit vector of [2 x double].
1631 /// A 128-bit vector of [2 x double].
1635 /// 0x00: Equal (ordered, non-signaling) \n
1636 /// 0x01: Less-than (ordered, signaling) \n
1637 /// 0x02: Less-than-or-equal (ordered, signaling) \n
1638 /// 0x03: Unordered (non-signaling) \n
1639 /// 0x04: Not-equal (unordered, non-signaling) \n
1640 /// 0x05: Not-less-than (unordered, signaling) \n
1641 /// 0x06: Not-less-than-or-equal (unordered, signaling) \n
1642 /// 0x07: Ordered (non-signaling) \n
1643 /// 0x08: Equal (unordered, non-signaling) \n
1644 /// 0x09: Not-greater-than-or-equal (unordered, signaling) \n
1645 /// 0x0A: Not-greater-than (unordered, signaling) \n
1646 /// 0x0B: False (ordered, non-signaling) \n
1647 /// 0x0C: Not-equal (ordered, non-signaling) \n
1648 /// 0x0D: Greater-than-or-equal (ordered, signaling) \n
1649 /// 0x0E: Greater-than (ordered, signaling) \n
1650 /// 0x0F: True (unordered, non-signaling) \n
1652 /// 0x11: Less-than (ordered, non-signaling) \n
1653 /// 0x12: Less-than-or-equal (ordered, non-signaling) \n
1655 /// 0x14: Not-equal (unordered, signaling) \n
1656 /// 0x15: Not-less-than (unordered, non-signaling) \n
1657 /// 0x16: Not-less-than-or-equal (unordered, non-signaling) \n
1660 /// 0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
1661 /// 0x1A: Not-greater-than (unordered, non-signaling) \n
1663 /// 0x1C: Not-equal (ordered, signaling) \n
1664 /// 0x1D: Greater-than-or-equal (ordered, non-signaling) \n
1665 /// 0x1E: Greater-than (ordered, non-signaling) \n
1667 /// \returns A 128-bit vector of [2 x double] containing the comparison results.
1671 /// Compares each of the corresponding values of two 128-bit vectors of
1688 /// A 128-bit vector of [4 x float].
1690 /// A 128-bit vector of [4 x float].
1694 /// 0x00: Equal (ordered, non-signaling) \n
1695 /// 0x01: Less-than (ordered, signaling) \n
1696 /// 0x02: Less-than-or-equal (ordered, signaling) \n
1697 /// 0x03: Unordered (non-signaling) \n
1698 /// 0x04: Not-equal (unordered, non-signaling) \n
1699 /// 0x05: Not-less-than (unordered, signaling) \n
1700 /// 0x06: Not-less-than-or-equal (unordered, signaling) \n
1701 /// 0x07: Ordered (non-signaling) \n
1702 /// 0x08: Equal (unordered, non-signaling) \n
1703 /// 0x09: Not-greater-than-or-equal (unordered, signaling) \n
1704 /// 0x0A: Not-greater-than (unordered, signaling) \n
1705 /// 0x0B: False (ordered, non-signaling) \n
1706 /// 0x0C: Not-equal (ordered, non-signaling) \n
1707 /// 0x0D: Greater-than-or-equal (ordered, signaling) \n
1708 /// 0x0E: Greater-than (ordered, signaling) \n
1709 /// 0x0F: True (unordered, non-signaling) \n
1711 /// 0x11: Less-than (ordered, non-signaling) \n
1712 /// 0x12: Less-than-or-equal (ordered, non-signaling) \n
1714 /// 0x14: Not-equal (unordered, signaling) \n
1715 /// 0x15: Not-less-than (unordered, non-signaling) \n
1716 /// 0x16: Not-less-than-or-equal (unordered, non-signaling) \n
1719 /// 0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
1720 /// 0x1A: Not-greater-than (unordered, non-signaling) \n
1722 /// 0x1C: Not-equal (ordered, signaling) \n
1723 /// 0x1D: Greater-than-or-equal (ordered, non-signaling) \n
1724 /// 0x1E: Greater-than (ordered, non-signaling) \n
1726 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
1729 /// Compares each of the corresponding double-precision values of two
1730 /// 256-bit vectors of [4 x double], using the operation specified by the
1746 /// A 256-bit vector of [4 x double].
1748 /// A 256-bit vector of [4 x double].
1752 /// 0x00: Equal (ordered, non-signaling) \n
1753 /// 0x01: Less-than (ordered, signaling) \n
1754 /// 0x02: Less-than-or-equal (ordered, signaling) \n
1755 /// 0x03: Unordered (non-signaling) \n
1756 /// 0x04: Not-equal (unordered, non-signaling) \n
1757 /// 0x05: Not-less-than (unordered, signaling) \n
1758 /// 0x06: Not-less-than-or-equal (unordered, signaling) \n
1759 /// 0x07: Ordered (non-signaling) \n
1760 /// 0x08: Equal (unordered, non-signaling) \n
1761 /// 0x09: Not-greater-than-or-equal (unordered, signaling) \n
1762 /// 0x0A: Not-greater-than (unordered, signaling) \n
1763 /// 0x0B: False (ordered, non-signaling) \n
1764 /// 0x0C: Not-equal (ordered, non-signaling) \n
1765 /// 0x0D: Greater-than-or-equal (ordered, signaling) \n
1766 /// 0x0E: Greater-than (ordered, signaling) \n
1767 /// 0x0F: True (unordered, non-signaling) \n
1769 /// 0x11: Less-than (ordered, non-signaling) \n
1770 /// 0x12: Less-than-or-equal (ordered, non-signaling) \n
1772 /// 0x14: Not-equal (unordered, signaling) \n
1773 /// 0x15: Not-less-than (unordered, non-signaling) \n
1774 /// 0x16: Not-less-than-or-equal (unordered, non-signaling) \n
1777 /// 0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
1778 /// 0x1A: Not-greater-than (unordered, non-signaling) \n
1780 /// 0x1C: Not-equal (ordered, signaling) \n
1781 /// 0x1D: Greater-than-or-equal (ordered, non-signaling) \n
1782 /// 0x1E: Greater-than (ordered, non-signaling) \n
1784 /// \returns A 256-bit vector of [4 x double] containing the comparison results.
1789 /// Compares each of the corresponding values of two 256-bit vectors of
1806 /// A 256-bit vector of [8 x float].
1808 /// A 256-bit vector of [8 x float].
1812 /// 0x00: Equal (ordered, non-signaling) \n
1813 /// 0x01: Less-than (ordered, signaling) \n
1814 /// 0x02: Less-than-or-equal (ordered, signaling) \n
1815 /// 0x03: Unordered (non-signaling) \n
1816 /// 0x04: Not-equal (unordered, non-signaling) \n
1817 /// 0x05: Not-less-than (unordered, signaling) \n
1818 /// 0x06: Not-less-than-or-equal (unordered, signaling) \n
1819 /// 0x07: Ordered (non-signaling) \n
1820 /// 0x08: Equal (unordered, non-signaling) \n
1821 /// 0x09: Not-greater-than-or-equal (unordered, signaling) \n
1822 /// 0x0A: Not-greater-than (unordered, signaling) \n
1823 /// 0x0B: False (ordered, non-signaling) \n
1824 /// 0x0C: Not-equal (ordered, non-signaling) \n
1825 /// 0x0D: Greater-than-or-equal (ordered, signaling) \n
1826 /// 0x0E: Greater-than (ordered, signaling) \n
1827 /// 0x0F: True (unordered, non-signaling) \n
1829 /// 0x11: Less-than (ordered, non-signaling) \n
1830 /// 0x12: Less-than-or-equal (ordered, non-signaling) \n
1832 /// 0x14: Not-equal (unordered, signaling) \n
1833 /// 0x15: Not-less-than (unordered, non-signaling) \n
1834 /// 0x16: Not-less-than-or-equal (unordered, non-signaling) \n
1837 /// 0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
1838 /// 0x1A: Not-greater-than (unordered, non-signaling) \n
1840 /// 0x1C: Not-equal (ordered, signaling) \n
1841 /// 0x1D: Greater-than-or-equal (ordered, non-signaling) \n
1842 /// 0x1E: Greater-than (ordered, non-signaling) \n
1844 /// \returns A 256-bit vector of [8 x float] containing the comparison results.
1850 /// Compares each of the corresponding scalar double-precision values of
1851 /// two 128-bit vectors of [2 x double], using the operation specified by the
1867 /// A 128-bit vector of [2 x double].
1869 /// A 128-bit vector of [2 x double].
1873 /// 0x00: Equal (ordered, non-signaling) \n
1874 /// 0x01: Less-than (ordered, signaling) \n
1875 /// 0x02: Less-than-or-equal (ordered, signaling) \n
1876 /// 0x03: Unordered (non-signaling) \n
1877 /// 0x04: Not-equal (unordered, non-signaling) \n
1878 /// 0x05: Not-less-than (unordered, signaling) \n
1879 /// 0x06: Not-less-than-or-equal (unordered, signaling) \n
1880 /// 0x07: Ordered (non-signaling) \n
1881 /// 0x08: Equal (unordered, non-signaling) \n
1882 /// 0x09: Not-greater-than-or-equal (unordered, signaling) \n
1883 /// 0x0A: Not-greater-than (unordered, signaling) \n
1884 /// 0x0B: False (ordered, non-signaling) \n
1885 /// 0x0C: Not-equal (ordered, non-signaling) \n
1886 /// 0x0D: Greater-than-or-equal (ordered, signaling) \n
1887 /// 0x0E: Greater-than (ordered, signaling) \n
1888 /// 0x0F: True (unordered, non-signaling) \n
1890 /// 0x11: Less-than (ordered, non-signaling) \n
1891 /// 0x12: Less-than-or-equal (ordered, non-signaling) \n
1893 /// 0x14: Not-equal (unordered, signaling) \n
1894 /// 0x15: Not-less-than (unordered, non-signaling) \n
1895 /// 0x16: Not-less-than-or-equal (unordered, non-signaling) \n
1898 /// 0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
1899 /// 0x1A: Not-greater-than (unordered, non-signaling) \n
1901 /// 0x1C: Not-equal (ordered, signaling) \n
1902 /// 0x1D: Greater-than-or-equal (ordered, non-signaling) \n
1903 /// 0x1E: Greater-than (ordered, non-signaling) \n
1905 /// \returns A 128-bit vector of [2 x double] containing the comparison results.
1909 /// Compares each of the corresponding scalar values of two 128-bit
1926 /// A 128-bit vector of [4 x float].
1928 /// A 128-bit vector of [4 x float].
1932 /// 0x00: Equal (ordered, non-signaling) \n
1933 /// 0x01: Less-than (ordered, signaling) \n
1934 /// 0x02: Less-than-or-equal (ordered, signaling) \n
1935 /// 0x03: Unordered (non-signaling) \n
1936 /// 0x04: Not-equal (unordered, non-signaling) \n
1937 /// 0x05: Not-less-than (unordered, signaling) \n
1938 /// 0x06: Not-less-than-or-equal (unordered, signaling) \n
1939 /// 0x07: Ordered (non-signaling) \n
1940 /// 0x08: Equal (unordered, non-signaling) \n
1941 /// 0x09: Not-greater-than-or-equal (unordered, signaling) \n
1942 /// 0x0A: Not-greater-than (unordered, signaling) \n
1943 /// 0x0B: False (ordered, non-signaling) \n
1944 /// 0x0C: Not-equal (ordered, non-signaling) \n
1945 /// 0x0D: Greater-than-or-equal (ordered, signaling) \n
1946 /// 0x0E: Greater-than (ordered, signaling) \n
1947 /// 0x0F: True (unordered, non-signaling) \n
1949 /// 0x11: Less-than (ordered, non-signaling) \n
1950 /// 0x12: Less-than-or-equal (ordered, non-signaling) \n
1952 /// 0x14: Not-equal (unordered, signaling) \n
1953 /// 0x15: Not-less-than (unordered, non-signaling) \n
1954 /// 0x16: Not-less-than-or-equal (unordered, non-signaling) \n
1957 /// 0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
1958 /// 0x1A: Not-greater-than (unordered, non-signaling) \n
1960 /// 0x1C: Not-equal (ordered, signaling) \n
1961 /// 0x1D: Greater-than-or-equal (ordered, non-signaling) \n
1962 /// 0x1E: Greater-than (ordered, non-signaling) \n
1964 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
1980 /// A 256-bit vector of [8 x i32].
1984 /// \returns A 32-bit integer containing the extracted 32 bits of extended
2002 /// A 256-bit integer vector of [16 x i16].
2006 /// \returns A 32-bit integer containing the extracted 16 bits of zero extended
2025 /// A 256-bit integer vector of [32 x i8].
2029 /// \returns A 32-bit integer containing the extracted 8 bits of zero extended
2049 /// A 256-bit integer vector of [4 x i64].
2053 /// \returns A 64-bit integer containing the extracted 64 bits of extended
2155 /// A 64-bit integer value. The replacement value for the insert operation.
2174 /// A 128-bit integer vector of [4 x i32].
2175 /// \returns A 256-bit vector of [4 x double] containing the converted values.
2189 /// A 256-bit integer vector.
2190 /// \returns A 256-bit vector of [8 x float] containing the converted values.
2197 /// Converts a 256-bit vector of [4 x double] into a 128-bit vector of
2205 /// A 256-bit vector of [4 x double].
2206 /// \returns A 128-bit vector of [4 x float] containing the converted values.
2215 /// If a converted value does not fit in a 32-bit integer, raises a
2216 /// floating-point invalid exception. If the exception is masked, returns
2224 /// A 256-bit vector of [8 x float].
2225 /// \returns A 256-bit integer vector containing the converted values.
2232 /// Converts a 128-bit vector of [4 x float] into a 256-bit vector of [4
2240 /// A 128-bit vector of [4 x float].
2241 /// \returns A 256-bit vector of [4 x double] containing the converted values.
2248 /// Converts a 256-bit vector of [4 x double] into four signed truncated
2249 /// (rounded toward zero) 32-bit integers returned in a 128-bit vector of
2252 /// If a converted value does not fit in a 32-bit integer, raises a
2253 /// floating-point invalid exception. If the exception is masked, returns
2261 /// A 256-bit vector of [4 x double].
2262 /// \returns A 128-bit integer vector containing the converted values.
2269 /// Converts a 256-bit vector of [4 x double] into a 128-bit vector of
2272 /// If a converted value does not fit in a 32-bit integer, raises a
2273 /// floating-point invalid exception. If the exception is masked, returns
2281 /// A 256-bit vector of [4 x double].
2282 /// \returns A 128-bit integer vector containing the converted values.
2290 /// toward zero) 32-bit integers returned in a vector of [8 x i32].
2292 /// If a converted value does not fit in a 32-bit integer, raises a
2293 /// floating-point invalid exception. If the exception is masked, returns
2301 /// A 256-bit vector of [8 x float].
2302 /// \returns A 256-bit integer vector containing the converted values.
2317 /// A 256-bit vector of [4 x double].
2333 /// A 256-bit vector of [8 x i32].
2350 /// A 256-bit vector of [8 x float].
2359 /// Moves and duplicates odd-indexed values from a 256-bit vector of
2360 /// [8 x float] to float values in a 256-bit vector of [8 x float].
2367 /// A 256-bit vector of [8 x float]. \n
2376 /// \returns A 256-bit vector of [8 x float] containing the moved and duplicated
2384 /// Moves and duplicates even-indexed values from a 256-bit vector of
2385 /// [8 x float] to float values in a 256-bit vector of [8 x float].
2392 /// A 256-bit vector of [8 x float]. \n
2401 /// \returns A 256-bit vector of [8 x float] containing the moved and duplicated
2409 /// Moves and duplicates double-precision floating point values from a
2410 /// 256-bit vector of [4 x double] to double-precision values in a 256-bit
2418 /// A 256-bit vector of [4 x double]. \n
2423 /// \returns A 256-bit vector of [4 x double] containing the moved and
2432 /// Unpacks the odd-indexed vector elements from two 256-bit vectors of
2433 /// [4 x double] and interleaves them into a 256-bit vector of [4 x double].
2440 /// A 256-bit floating-point vector of [4 x double]. \n
2444 /// A 256-bit floating-point vector of [4 x double]. \n
2447 /// \returns A 256-bit vector of [4 x double] containing the interleaved values.
2454 /// Unpacks the even-indexed vector elements from two 256-bit vectors of
2455 /// [4 x double] and interleaves them into a 256-bit vector of [4 x double].
2462 /// A 256-bit floating-point vector of [4 x double]. \n
2466 /// A 256-bit floating-point vector of [4 x double]. \n
2469 /// \returns A 256-bit vector of [4 x double] containing the interleaved values.
2476 /// Unpacks the 32-bit vector elements 2, 3, 6 and 7 from each of the
2477 /// two 256-bit vectors of [8 x float] and interleaves them into a 256-bit
2485 /// A 256-bit vector of [8 x float]. \n
2491 /// A 256-bit vector of [8 x float]. \n
2496 /// \returns A 256-bit vector of [8 x float] containing the interleaved values.
2503 /// Unpacks the 32-bit vector elements 0, 1, 4 and 5 from each of the
2504 /// two 256-bit vectors of [8 x float] and interleaves them into a 256-bit
2512 /// A 256-bit vector of [8 x float]. \n
2518 /// A 256-bit vector of [8 x float]. \n
2523 /// \returns A 256-bit vector of [8 x float] containing the interleaved values.
2531 /// Given two 128-bit floating-point vectors of [2 x double], perform an
2532 /// element-by-element comparison of the double-precision element in the
2537 /// If there is at least one pair of double-precision elements where the
2538 /// sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2540 /// If there is at least one pair of double-precision elements where the
2541 /// sign-bit of the first element is 0 and the sign-bit of the second element
2550 /// A 128-bit vector of [2 x double].
2552 /// A 128-bit vector of [2 x double].
2560 /// Given two 128-bit floating-point vectors of [2 x double], perform an
2561 /// element-by-element comparison of the double-precision element in the
2566 /// If there is at least one pair of double-precision elements where the
2567 /// sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2569 /// If there is at least one pair of double-precision elements where the
2570 /// sign-bit of the first element is 0 and the sign-bit of the second element
2579 /// A 128-bit vector of [2 x double].
2581 /// A 128-bit vector of [2 x double].
2589 /// Given two 128-bit floating-point vectors of [2 x double], perform an
2590 /// element-by-element comparison of the double-precision element in the
2595 /// If there is at least one pair of double-precision elements where the
2596 /// sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2598 /// If there is at least one pair of double-precision elements where the
2599 /// sign-bit of the first element is 0 and the sign-bit of the second element
2609 /// A 128-bit vector of [2 x double].
2611 /// A 128-bit vector of [2 x double].
2619 /// Given two 128-bit floating-point vectors of [4 x float], perform an
2620 /// element-by-element comparison of the single-precision element in the
2625 /// If there is at least one pair of single-precision elements where the
2626 /// sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2628 /// If there is at least one pair of single-precision elements where the
2629 /// sign-bit of the first element is 0 and the sign-bit of the second element
2638 /// A 128-bit vector of [4 x float].
2640 /// A 128-bit vector of [4 x float].
2648 /// Given two 128-bit floating-point vectors of [4 x float], perform an
2649 /// element-by-element comparison of the single-precision element in the
2654 /// If there is at least one pair of single-precision elements where the
2655 /// sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2657 /// If there is at least one pair of single-precision elements where the
2658 /// sign-bit of the first element is 0 and the sign-bit of the second element
2667 /// A 128-bit vector of [4 x float].
2669 /// A 128-bit vector of [4 x float].
2677 /// Given two 128-bit floating-point vectors of [4 x float], perform an
2678 /// element-by-element comparison of the single-precision element in the
2683 /// If there is at least one pair of single-precision elements where the
2684 /// sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2686 /// If there is at least one pair of single-precision elements where the
2687 /// sign-bit of the first element is 0 and the sign-bit of the second element
2697 /// A 128-bit vector of [4 x float].
2699 /// A 128-bit vector of [4 x float].
2707 /// Given two 256-bit floating-point vectors of [4 x double], perform an
2708 /// element-by-element comparison of the double-precision elements in the
2713 /// If there is at least one pair of double-precision elements where the
2714 /// sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2716 /// If there is at least one pair of double-precision elements where the
2717 /// sign-bit of the first element is 0 and the sign-bit of the second element
2726 /// A 256-bit vector of [4 x double].
2728 /// A 256-bit vector of [4 x double].
2736 /// Given two 256-bit floating-point vectors of [4 x double], perform an
2737 /// element-by-element comparison of the double-precision elements in the
2742 /// If there is at least one pair of double-precision elements where the
2743 /// sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2745 /// If there is at least one pair of double-precision elements where the
2746 /// sign-bit of the first element is 0 and the sign-bit of the second element
2755 /// A 256-bit vector of [4 x double].
2757 /// A 256-bit vector of [4 x double].
2765 /// Given two 256-bit floating-point vectors of [4 x double], perform an
2766 /// element-by-element comparison of the double-precision elements in the
2771 /// If there is at least one pair of double-precision elements where the
2772 /// sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2774 /// If there is at least one pair of double-precision elements where the
2775 /// sign-bit of the first element is 0 and the sign-bit of the second element
2785 /// A 256-bit vector of [4 x double].
2787 /// A 256-bit vector of [4 x double].
2795 /// Given two 256-bit floating-point vectors of [8 x float], perform an
2796 /// element-by-element comparison of the single-precision element in the
2801 /// If there is at least one pair of single-precision elements where the
2802 /// sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2804 /// If there is at least one pair of single-precision elements where the
2805 /// sign-bit of the first element is 0 and the sign-bit of the second element
2814 /// A 256-bit vector of [8 x float].
2816 /// A 256-bit vector of [8 x float].
2824 /// Given two 256-bit floating-point vectors of [8 x float], perform an
2825 /// element-by-element comparison of the single-precision element in the
2830 /// If there is at least one pair of single-precision elements where the
2831 /// sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2833 /// If there is at least one pair of single-precision elements where the
2834 /// sign-bit of the first element is 0 and the sign-bit of the second element
2843 /// A 256-bit vector of [8 x float].
2845 /// A 256-bit vector of [8 x float].
2853 /// Given two 256-bit floating-point vectors of [8 x float], perform an
2854 /// element-by-element comparison of the single-precision elements in the
2859 /// If there is at least one pair of single-precision elements where the
2860 /// sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2862 /// If there is at least one pair of single-precision elements where the
2863 /// sign-bit of the first element is 0 and the sign-bit of the second element
2873 /// A 256-bit vector of [8 x float].
2875 /// A 256-bit vector of [8 x float].
2883 /// Given two 256-bit integer vectors, perform a bit-by-bit comparison
2899 /// A 256-bit integer vector.
2901 /// A 256-bit integer vector.
2909 /// Given two 256-bit integer vectors, perform a bit-by-bit comparison
2925 /// A 256-bit integer vector.
2927 /// A 256-bit integer vector.
2935 /// Given two 256-bit integer vectors, perform a bit-by-bit comparison
2952 /// A 256-bit integer vector.
2954 /// A 256-bit integer vector.
2963 /// Extracts the sign bits of double-precision floating point elements
2964 /// in a 256-bit vector of [4 x double] and writes them to the lower order
2972 /// A 256-bit vector of [4 x double] containing the double-precision
2981 /// Extracts the sign bits of single-precision floating point elements
2982 /// in a 256-bit vector of [8 x float] and writes them to the lower order
2990 /// A 256-bit vector of [8 x float] containing the single-precision floating
3023 /// Loads a scalar single-precision floating point value from the
3032 /// The single-precision floating point value to be broadcast.
3033 /// \returns A 128-bit vector of [4 x float] whose 32-bit elements are set
3041 float __f = ((const struct __mm_broadcast_ss_struct*)__a)->__f; in _mm_broadcast_ss()
3045 /// Loads a scalar double-precision floating point value from the
3054 /// The double-precision floating point value to be broadcast.
3055 /// \returns A 256-bit vector of [4 x double] whose 64-bit elements are set
3063 double __d = ((const struct __mm256_broadcast_sd_struct*)__a)->__d; in _mm256_broadcast_sd()
3067 /// Loads a scalar single-precision floating point value from the
3076 /// The single-precision floating point value to be broadcast.
3077 /// \returns A 256-bit vector of [8 x float] whose 32-bit elements are set
3085 float __f = ((const struct __mm256_broadcast_ss_struct*)__a)->__f; in _mm256_broadcast_ss()
3089 /// Loads the data from a 128-bit vector of [2 x double] from the
3090 /// specified address pointed to by \a __a and broadcasts it to 128-bit
3091 /// elements in a 256-bit vector of [4 x double].
3098 /// The 128-bit vector of [2 x double] to be broadcast.
3099 /// \returns A 256-bit vector of [4 x double] whose 128-bit elements are set
3109 /// Loads the data from a 128-bit vector of [4 x float] from the
3110 /// specified address pointed to by \a __a and broadcasts it to 128-bit
3111 /// elements in a 256-bit vector of [8 x float].
3118 /// The 128-bit vector of [4 x float] to be broadcast.
3119 /// \returns A 256-bit vector of [8 x float] whose 128-bit elements are set
3130 /// Loads 4 double-precision floating point values from a 32-byte aligned
3138 /// A 32-byte aligned pointer to a memory location containing
3139 /// double-precision floating point values.
3140 /// \returns A 256-bit vector of [4 x double] containing the moved values.
3147 /// Loads 8 single-precision floating point values from a 32-byte aligned
3155 /// A 32-byte aligned pointer to a memory location containing float values.
3156 /// \returns A 256-bit vector of [8 x float] containing the moved values.
3163 /// Loads 4 double-precision floating point values from an unaligned
3171 /// A pointer to a memory location containing double-precision floating
3173 /// \returns A 256-bit vector of [4 x double] containing the moved values.
3180 return ((const struct __loadu_pd*)__p)->__v; in _mm256_loadu_pd()
3183 /// Loads 8 single-precision floating point values from an unaligned
3191 /// A pointer to a memory location containing single-precision floating
3193 /// \returns A 256-bit vector of [8 x float] containing the moved values.
3200 return ((const struct __loadu_ps*)__p)->__v; in _mm256_loadu_ps()
3203 /// Loads 256 bits of integer data from a 32-byte aligned memory
3204 /// location pointed to by \a __p into elements of a 256-bit integer vector.
3211 /// A 32-byte aligned pointer to a 256-bit integer vector containing integer
3213 /// \returns A 256-bit integer vector containing the moved values.
3221 /// pointed to by \a __p into a 256-bit integer vector.
3228 /// A pointer to a 256-bit integer vector containing integer values.
3229 /// \returns A 256-bit integer vector containing the moved values.
3236 return ((const struct __loadu_si256*)__p)->__v; in _mm256_loadu_si256()
3240 /// pointed to by \a __p into a 256-bit integer vector. This intrinsic may
3249 /// A pointer to a 256-bit integer vector containing integer values.
3250 /// \returns A 256-bit integer vector containing the moved values.
3258 /// Stores double-precision floating point values from a 256-bit vector
3259 /// of [4 x double] to a 32-byte aligned memory location pointed to by
3267 /// A 32-byte aligned pointer to a memory location that will receive the
3268 /// double-precision floaing point values.
3270 /// A 256-bit vector of [4 x double] containing the values to be moved.
3277 /// Stores single-precision floating point values from a 256-bit vector
3278 /// of [8 x float] to a 32-byte aligned memory location pointed to by \a __p.
3285 /// A 32-byte aligned pointer to a memory location that will receive the
3288 /// A 256-bit vector of [8 x float] containing the values to be moved.
3295 /// Stores double-precision floating point values from a 256-bit vector
3303 /// A pointer to a memory location that will receive the double-precision
3306 /// A 256-bit vector of [4 x double] containing the values to be moved.
3313 ((struct __storeu_pd*)__p)->__v = __a; in _mm256_storeu_pd()
3316 /// Stores single-precision floating point values from a 256-bit vector
3326 /// A 256-bit vector of [8 x float] containing the values to be moved.
3333 ((struct __storeu_ps*)__p)->__v = __a; in _mm256_storeu_ps()
3336 /// Stores integer values from a 256-bit integer vector to a 32-byte
3344 /// A 32-byte aligned pointer to a memory location that will receive the
3347 /// A 256-bit integer vector containing the values to be moved.
3354 /// Stores integer values from a 256-bit integer vector to an unaligned
3364 /// A 256-bit integer vector containing the values to be moved.
3371 ((struct __storeu_si256*)__p)->__v = __a; in _mm256_storeu_si256()
3375 /// Conditionally loads double-precision floating point elements from a
3376 /// memory location pointed to by \a __p into a 128-bit vector of
3385 /// A pointer to a memory location that contains the double-precision
3388 /// A 128-bit integer vector containing the mask. The most significant bit of
3392 /// \returns A 128-bit vector of [2 x double] containing the loaded values.
3399 /// Conditionally loads double-precision floating point elements from a
3400 /// memory location pointed to by \a __p into a 256-bit vector of
3409 /// A pointer to a memory location that contains the double-precision
3412 /// A 256-bit integer vector of [4 x quadword] containing the mask. The most
3416 /// \returns A 256-bit vector of [4 x double] containing the loaded values.
3424 /// Conditionally loads single-precision floating point elements from a
3425 /// memory location pointed to by \a __p into a 128-bit vector of
3434 /// A pointer to a memory location that contains the single-precision
3437 /// A 128-bit integer vector containing the mask. The most significant bit of
3441 /// \returns A 128-bit vector of [4 x float] containing the loaded values.
3448 /// Conditionally loads single-precision floating point elements from a
3449 /// memory location pointed to by \a __p into a 256-bit vector of
3458 /// A pointer to a memory location that contains the single-precision
3461 /// A 256-bit integer vector of [8 x dword] containing the mask. The most
3465 /// \returns A 256-bit vector of [8 x float] containing the loaded values.
3473 /// Moves single-precision floating point values from a 256-bit vector
3484 /// A 256-bit integer vector of [8 x dword] containing the mask. The most
3490 /// A 256-bit vector of [8 x float] containing the values to be stored.
3497 /// Moves double-precision values from a 128-bit vector of [2 x double]
3508 /// A 128-bit integer vector containing the mask. The most significant bit of
3514 /// A 128-bit vector of [2 x double] containing the values to be stored.
3521 /// Moves double-precision values from a 256-bit vector of [4 x double]
3532 /// A 256-bit integer vector of [4 x quadword] containing the mask. The most
3538 /// A 256-bit vector of [4 x double] containing the values to be stored.
3545 /// Moves single-precision floating point values from a 128-bit vector
3556 /// A 128-bit integer vector containing the mask. The most significant bit of
3562 /// A 128-bit vector of [4 x float] containing the values to be stored.
3570 /// Moves integer data from a 256-bit integer vector to a 32-byte
3572 /// non-temporal (unlikely to be used again soon).
3579 /// A pointer to a 32-byte aligned memory location that will receive the
3582 /// A 256-bit integer vector containing the values to be moved.
3590 /// Moves double-precision values from a 256-bit vector of [4 x double]
3591 /// to a 32-byte aligned memory location. To minimize caching, the data is
3592 /// flagged as non-temporal (unlikely to be used again soon).
3599 /// A pointer to a 32-byte aligned memory location that will receive the
3600 /// double-precision floating-point values.
3602 /// A 256-bit vector of [4 x double] containing the values to be moved.
3610 /// Moves single-precision floating point values from a 256-bit vector
3611 /// of [8 x float] to a 32-byte aligned memory location. To minimize
3612 /// caching, the data is flagged as non-temporal (unlikely to be used again
3620 /// A pointer to a 32-byte aligned memory location that will receive the
3621 /// single-precision floating point values.
3623 /// A 256-bit vector of [8 x float] containing the values to be moved.
3632 /// Create a 256-bit vector of [4 x double] with undefined values.
3638 /// \returns A 256-bit vector of [4 x double] containing undefined values.
3645 /// Create a 256-bit vector of [8 x float] with undefined values.
3651 /// \returns A 256-bit vector of [8 x float] containing undefined values.
3658 /// Create a 256-bit integer vector with undefined values.
3664 /// \returns A 256-bit integer vector containing undefined values.
3671 /// Constructs a 256-bit floating-point vector of [4 x double]
3672 /// initialized with the specified double-precision floating-point values.
3680 /// A double-precision floating-point value used to initialize bits [255:192]
3683 /// A double-precision floating-point value used to initialize bits [191:128]
3686 /// A double-precision floating-point value used to initialize bits [127:64]
3689 /// A double-precision floating-point value used to initialize bits [63:0]
3691 /// \returns An initialized 256-bit floating-point vector of [4 x double].
3698 /// Constructs a 256-bit floating-point vector of [8 x float] initialized
3699 /// with the specified single-precision floating-point values.
3707 /// A single-precision floating-point value used to initialize bits [255:224]
3710 /// A single-precision floating-point value used to initialize bits [223:192]
3713 /// A single-precision floating-point value used to initialize bits [191:160]
3716 /// A single-precision floating-point value used to initialize bits [159:128]
3719 /// A single-precision floating-point value used to initialize bits [127:96]
3722 /// A single-precision floating-point value used to initialize bits [95:64]
3725 /// A single-precision floating-point value used to initialize bits [63:32]
3728 /// A single-precision floating-point value used to initialize bits [31:0]
3730 /// \returns An initialized 256-bit floating-point vector of [8 x float].
3738 /// Constructs a 256-bit integer vector initialized with the specified
3739 /// 32-bit integral values.
3747 /// A 32-bit integral value used to initialize bits [255:224] of the result.
3749 /// A 32-bit integral value used to initialize bits [223:192] of the result.
3751 /// A 32-bit integral value used to initialize bits [191:160] of the result.
3753 /// A 32-bit integral value used to initialize bits [159:128] of the result.
3755 /// A 32-bit integral value used to initialize bits [127:96] of the result.
3757 /// A 32-bit integral value used to initialize bits [95:64] of the result.
3759 /// A 32-bit integral value used to initialize bits [63:32] of the result.
3761 /// A 32-bit integral value used to initialize bits [31:0] of the result.
3762 /// \returns An initialized 256-bit integer vector.
3770 /// Constructs a 256-bit integer vector initialized with the specified
3771 /// 16-bit integral values.
3779 /// A 16-bit integral value used to initialize bits [255:240] of the result.
3781 /// A 16-bit integral value used to initialize bits [239:224] of the result.
3783 /// A 16-bit integral value used to initialize bits [223:208] of the result.
3785 /// A 16-bit integral value used to initialize bits [207:192] of the result.
3787 /// A 16-bit integral value used to initialize bits [191:176] of the result.
3789 /// A 16-bit integral value used to initialize bits [175:160] of the result.
3791 /// A 16-bit integral value used to initialize bits [159:144] of the result.
3793 /// A 16-bit integral value used to initialize bits [143:128] of the result.
3795 /// A 16-bit integral value used to initialize bits [127:112] of the result.
3797 /// A 16-bit integral value used to initialize bits [111:96] of the result.
3799 /// A 16-bit integral value used to initialize bits [95:80] of the result.
3801 /// A 16-bit integral value used to initialize bits [79:64] of the result.
3803 /// A 16-bit integral value used to initialize bits [63:48] of the result.
3805 /// A 16-bit integral value used to initialize bits [47:32] of the result.
3807 /// A 16-bit integral value used to initialize bits [31:16] of the result.
3809 /// A 16-bit integral value used to initialize bits [15:0] of the result.
3810 /// \returns An initialized 256-bit integer vector.
3821 /// Constructs a 256-bit integer vector initialized with the specified
3822 /// 8-bit integral values.
3830 /// An 8-bit integral value used to initialize bits [255:248] of the result.
3832 /// An 8-bit integral value used to initialize bits [247:240] of the result.
3834 /// An 8-bit integral value used to initialize bits [239:232] of the result.
3836 /// An 8-bit integral value used to initialize bits [231:224] of the result.
3838 /// An 8-bit integral value used to initialize bits [223:216] of the result.
3840 /// An 8-bit integral value used to initialize bits [215:208] of the result.
3842 /// An 8-bit integral value used to initialize bits [207:200] of the result.
3844 /// An 8-bit integral value used to initialize bits [199:192] of the result.
3846 /// An 8-bit integral value used to initialize bits [191:184] of the result.
3848 /// An 8-bit integral value used to initialize bits [183:176] of the result.
3850 /// An 8-bit integral value used to initialize bits [175:168] of the result.
3852 /// An 8-bit integral value used to initialize bits [167:160] of the result.
3854 /// An 8-bit integral value used to initialize bits [159:152] of the result.
3856 /// An 8-bit integral value used to initialize bits [151:144] of the result.
3858 /// An 8-bit integral value used to initialize bits [143:136] of the result.
3860 /// An 8-bit integral value used to initialize bits [135:128] of the result.
3862 /// An 8-bit integral value used to initialize bits [127:120] of the result.
3864 /// An 8-bit integral value used to initialize bits [119:112] of the result.
3866 /// An 8-bit integral value used to initialize bits [111:104] of the result.
3868 /// An 8-bit integral value used to initialize bits [103:96] of the result.
3870 /// An 8-bit integral value used to initialize bits [95:88] of the result.
3872 /// An 8-bit integral value used to initialize bits [87:80] of the result.
3874 /// An 8-bit integral value used to initialize bits [79:72] of the result.
3876 /// An 8-bit integral value used to initialize bits [71:64] of the result.
3878 /// An 8-bit integral value used to initialize bits [63:56] of the result.
3880 /// An 8-bit integral value used to initialize bits [55:48] of the result.
3882 /// An 8-bit integral value used to initialize bits [47:40] of the result.
3884 /// An 8-bit integral value used to initialize bits [39:32] of the result.
3886 /// An 8-bit integral value used to initialize bits [31:24] of the result.
3888 /// An 8-bit integral value used to initialize bits [23:16] of the result.
3890 /// An 8-bit integral value used to initialize bits [15:8] of the result.
3892 /// An 8-bit integral value used to initialize bits [7:0] of the result.
3893 /// \returns An initialized 256-bit integer vector.
3912 /// Constructs a 256-bit integer vector initialized with the specified
3913 /// 64-bit integral values.
3921 /// A 64-bit integral value used to initialize bits [255:192] of the result.
3923 /// A 64-bit integral value used to initialize bits [191:128] of the result.
3925 /// A 64-bit integral value used to initialize bits [127:64] of the result.
3927 /// A 64-bit integral value used to initialize bits [63:0] of the result.
3928 /// \returns An initialized 256-bit integer vector.
3936 /// Constructs a 256-bit floating-point vector of [4 x double],
3937 /// initialized in reverse order with the specified double-precision
3938 /// floating-point values.
3946 /// A double-precision floating-point value used to initialize bits [63:0]
3949 /// A double-precision floating-point value used to initialize bits [127:64]
3952 /// A double-precision floating-point value used to initialize bits [191:128]
3955 /// A double-precision floating-point value used to initialize bits [255:192]
3957 /// \returns An initialized 256-bit floating-point vector of [4 x double].
3964 /// Constructs a 256-bit floating-point vector of [8 x float],
3965 /// initialized in reverse order with the specified single-precision
3966 /// float-point values.
3974 /// A single-precision floating-point value used to initialize bits [31:0]
3977 /// A single-precision floating-point value used to initialize bits [63:32]
3980 /// A single-precision floating-point value used to initialize bits [95:64]
3983 /// A single-precision floating-point value used to initialize bits [127:96]
3986 /// A single-precision floating-point value used to initialize bits [159:128]
3989 /// A single-precision floating-point value used to initialize bits [191:160]
3992 /// A single-precision floating-point value used to initialize bits [223:192]
3995 /// A single-precision floating-point value used to initialize bits [255:224]
3997 /// \returns An initialized 256-bit floating-point vector of [8 x float].
4005 /// Constructs a 256-bit integer vector, initialized in reverse order
4006 /// with the specified 32-bit integral values.
4014 /// A 32-bit integral value used to initialize bits [31:0] of the result.
4016 /// A 32-bit integral value used to initialize bits [63:32] of the result.
4018 /// A 32-bit integral value used to initialize bits [95:64] of the result.
4020 /// A 32-bit integral value used to initialize bits [127:96] of the result.
4022 /// A 32-bit integral value used to initialize bits [159:128] of the result.
4024 /// A 32-bit integral value used to initialize bits [191:160] of the result.
4026 /// A 32-bit integral value used to initialize bits [223:192] of the result.
4028 /// A 32-bit integral value used to initialize bits [255:224] of the result.
4029 /// \returns An initialized 256-bit integer vector.
4037 /// Constructs a 256-bit integer vector, initialized in reverse order
4038 /// with the specified 16-bit integral values.
4046 /// A 16-bit integral value used to initialize bits [15:0] of the result.
4048 /// A 16-bit integral value used to initialize bits [31:16] of the result.
4050 /// A 16-bit integral value used to initialize bits [47:32] of the result.
4052 /// A 16-bit integral value used to initialize bits [63:48] of the result.
4054 /// A 16-bit integral value used to initialize bits [79:64] of the result.
4056 /// A 16-bit integral value used to initialize bits [95:80] of the result.
4058 /// A 16-bit integral value used to initialize bits [111:96] of the result.
4060 /// A 16-bit integral value used to initialize bits [127:112] of the result.
4062 /// A 16-bit integral value used to initialize bits [143:128] of the result.
4064 /// A 16-bit integral value used to initialize bits [159:144] of the result.
4066 /// A 16-bit integral value used to initialize bits [175:160] of the result.
4068 /// A 16-bit integral value used to initialize bits [191:176] of the result.
4070 /// A 16-bit integral value used to initialize bits [207:192] of the result.
4072 /// A 16-bit integral value used to initialize bits [223:208] of the result.
4074 /// A 16-bit integral value used to initialize bits [239:224] of the result.
4076 /// A 16-bit integral value used to initialize bits [255:240] of the result.
4077 /// \returns An initialized 256-bit integer vector.
4090 /// Constructs a 256-bit integer vector, initialized in reverse order
4091 /// with the specified 8-bit integral values.
4099 /// An 8-bit integral value used to initialize bits [7:0] of the result.
4101 /// An 8-bit integral value used to initialize bits [15:8] of the result.
4103 /// An 8-bit integral value used to initialize bits [23:16] of the result.
4105 /// An 8-bit integral value used to initialize bits [31:24] of the result.
4107 /// An 8-bit integral value used to initialize bits [39:32] of the result.
4109 /// An 8-bit integral value used to initialize bits [47:40] of the result.
4111 /// An 8-bit integral value used to initialize bits [55:48] of the result.
4113 /// An 8-bit integral value used to initialize bits [63:56] of the result.
4115 /// An 8-bit integral value used to initialize bits [71:64] of the result.
4117 /// An 8-bit integral value used to initialize bits [79:72] of the result.
4119 /// An 8-bit integral value used to initialize bits [87:80] of the result.
4121 /// An 8-bit integral value used to initialize bits [95:88] of the result.
4123 /// An 8-bit integral value used to initialize bits [103:96] of the result.
4125 /// An 8-bit integral value used to initialize bits [111:104] of the result.
4127 /// An 8-bit integral value used to initialize bits [119:112] of the result.
4129 /// An 8-bit integral value used to initialize bits [127:120] of the result.
4131 /// An 8-bit integral value used to initialize bits [135:128] of the result.
4133 /// An 8-bit integral value used to initialize bits [143:136] of the result.
4135 /// An 8-bit integral value used to initialize bits [151:144] of the result.
4137 /// An 8-bit integral value used to initialize bits [159:152] of the result.
4139 /// An 8-bit integral value used to initialize bits [167:160] of the result.
4141 /// An 8-bit integral value used to initialize bits [175:168] of the result.
4143 /// An 8-bit integral value used to initialize bits [183:176] of the result.
4145 /// An 8-bit integral value used to initialize bits [191:184] of the result.
4147 /// An 8-bit integral value used to initialize bits [199:192] of the result.
4149 /// An 8-bit integral value used to initialize bits [207:200] of the result.
4151 /// An 8-bit integral value used to initialize bits [215:208] of the result.
4153 /// An 8-bit integral value used to initialize bits [223:216] of the result.
4155 /// An 8-bit integral value used to initialize bits [231:224] of the result.
4157 /// An 8-bit integral value used to initialize bits [239:232] of the result.
4159 /// An 8-bit integral value used to initialize bits [247:240] of the result.
4161 /// An 8-bit integral value used to initialize bits [255:248] of the result.
4162 /// \returns An initialized 256-bit integer vector.
4179 /// Constructs a 256-bit integer vector, initialized in reverse order
4180 /// with the specified 64-bit integral values.
4188 /// A 64-bit integral value used to initialize bits [63:0] of the result.
4190 /// A 64-bit integral value used to initialize bits [127:64] of the result.
4192 /// A 64-bit integral value used to initialize bits [191:128] of the result.
4194 /// A 64-bit integral value used to initialize bits [255:192] of the result.
4195 /// \returns An initialized 256-bit integer vector.
4203 /// Constructs a 256-bit floating-point vector of [4 x double], with each
4204 /// of the four double-precision floating-point vector elements set to the
4205 /// specified double-precision floating-point value.
4212 /// A double-precision floating-point value used to initialize each vector
4214 /// \returns An initialized 256-bit floating-point vector of [4 x double].
4221 /// Constructs a 256-bit floating-point vector of [8 x float], with each
4222 /// of the eight single-precision floating-point vector elements set to the
4223 /// specified single-precision floating-point value.
4231 /// A single-precision floating-point value used to initialize each vector
4233 /// \returns An initialized 256-bit floating-point vector of [8 x float].
4240 /// Constructs a 256-bit integer vector of [8 x i32], with each of the
4241 /// 32-bit integral vector elements set to the specified 32-bit integral
4250 /// A 32-bit integral value used to initialize each vector element of the
4252 /// \returns An initialized 256-bit integer vector of [8 x i32].
4259 /// Constructs a 256-bit integer vector of [16 x i16], with each of the
4260 /// 16-bit integral vector elements set to the specified 16-bit integral
4268 /// A 16-bit integral value used to initialize each vector element of the
4270 /// \returns An initialized 256-bit integer vector of [16 x i16].
4278 /// Constructs a 256-bit integer vector of [32 x i8], with each of the
4279 /// 8-bit integral vector elements set to the specified 8-bit integral value.
4286 /// An 8-bit integral value used to initialize each vector element of the
4288 /// \returns An initialized 256-bit integer vector of [32 x i8].
4298 /// Constructs a 256-bit integer vector of [4 x i64], with each of the
4299 /// 64-bit integral vector elements set to the specified 64-bit integral
4307 /// A 64-bit integral value used to initialize each vector element of the
4309 /// \returns An initialized 256-bit integer vector of [4 x i64].
4317 /// Constructs a 256-bit floating-point vector of [4 x double] with all
4324 /// \returns A 256-bit vector of [4 x double] with all elements set to zero.
4331 /// Constructs a 256-bit floating-point vector of [8 x float] with all
4338 /// \returns A 256-bit vector of [8 x float] with all elements set to zero.
4345 /// Constructs a 256-bit integer vector initialized to zero.
4351 /// \returns A 256-bit integer vector initialized to zero.
4359 /// Casts a 256-bit floating-point vector of [4 x double] into a 256-bit
4360 /// floating-point vector of [8 x float].
4367 /// A 256-bit floating-point vector of [4 x double].
4368 /// \returns A 256-bit floating-point vector of [8 x float] containing the same
4376 /// Casts a 256-bit floating-point vector of [4 x double] into a 256-bit
4384 /// A 256-bit floating-point vector of [4 x double].
4385 /// \returns A 256-bit integer vector containing the same bitwise pattern as the
4393 /// Casts a 256-bit floating-point vector of [8 x float] into a 256-bit
4394 /// floating-point vector of [4 x double].
4401 /// A 256-bit floating-point vector of [8 x float].
4402 /// \returns A 256-bit floating-point vector of [4 x double] containing the same
4410 /// Casts a 256-bit floating-point vector of [8 x float] into a 256-bit
4418 /// A 256-bit floating-point vector of [8 x float].
4419 /// \returns A 256-bit integer vector containing the same bitwise pattern as the
4427 /// Casts a 256-bit integer vector into a 256-bit floating-point vector
4435 /// A 256-bit integer vector.
4436 /// \returns A 256-bit floating-point vector of [8 x float] containing the same
4444 /// Casts a 256-bit integer vector into a 256-bit floating-point vector
4452 /// A 256-bit integer vector.
4453 /// \returns A 256-bit floating-point vector of [4 x double] containing the same
4461 /// Returns the lower 128 bits of a 256-bit floating-point vector of
4462 /// [4 x double] as a 128-bit floating-point vector of [2 x double].
4469 /// A 256-bit floating-point vector of [4 x double].
4470 /// \returns A 128-bit floating-point vector of [2 x double] containing the
4478 /// Returns the lower 128 bits of a 256-bit floating-point vector of
4479 /// [8 x float] as a 128-bit floating-point vector of [4 x float].
4486 /// A 256-bit floating-point vector of [8 x float].
4487 /// \returns A 128-bit floating-point vector of [4 x float] containing the
4495 /// Truncates a 256-bit integer vector into a 128-bit integer vector.
4502 /// A 256-bit integer vector.
4503 /// \returns A 128-bit integer vector containing the lower 128 bits of the
4511 /// Constructs a 256-bit floating-point vector of [4 x double] from a
4512 /// 128-bit floating-point vector of [2 x double].
4522 /// A 128-bit vector of [2 x double].
4523 /// \returns A 256-bit floating-point vector of [4 x double]. The lower 128 bits
4533 /// Constructs a 256-bit floating-point vector of [8 x float] from a
4534 /// 128-bit floating-point vector of [4 x float].
4544 /// A 128-bit vector of [4 x float].
4545 /// \returns A 256-bit floating-point vector of [8 x float]. The lower 128 bits
4556 /// Constructs a 256-bit integer vector from a 128-bit integer vector.
4566 /// A 128-bit integer vector.
4567 /// \returns A 256-bit integer vector. The lower 128 bits contain the value of
4576 /// Constructs a 256-bit floating-point vector of [4 x double] from a
4577 /// 128-bit floating-point vector of [2 x double]. The lower 128 bits
4586 /// A 128-bit vector of [2 x double].
4587 /// \returns A 256-bit floating-point vector of [4 x double]. The lower 128 bits
4595 /// Constructs a 256-bit floating-point vector of [8 x float] from a
4596 /// 128-bit floating-point vector of [4 x float]. The lower 128 bits contain
4604 /// A 128-bit vector of [4 x float].
4605 /// \returns A 256-bit floating-point vector of [8 x float]. The lower 128 bits
4613 /// Constructs a 256-bit integer vector from a 128-bit integer vector.
4622 /// A 128-bit integer vector.
4623 /// \returns A 256-bit integer vector. The lower 128 bits contain the value of
4636 /// Constructs a new 256-bit vector of [8 x float] by first duplicating
4637 /// a 256-bit vector of [8 x float] given in the first parameter, and then
4639 /// 128-bit vector of [4 x float] in the second parameter.
4653 /// A 256-bit vector of [8 x float]. This vector is copied to the result
4657 /// A 128-bit vector of [4 x float]. The contents of this parameter are
4662 /// from the two parameters are interleaved: \n
4669 /// \returns A 256-bit vector of [8 x float] containing the interleaved values.
4674 /// Constructs a new 256-bit vector of [4 x double] by first duplicating
4675 /// a 256-bit vector of [4 x double] given in the first parameter, and then
4677 /// 128-bit vector of [2 x double] in the second parameter.
4691 /// A 256-bit vector of [4 x double]. This vector is copied to the result
4695 /// A 128-bit vector of [2 x double]. The contents of this parameter are
4700 /// from the two parameters are interleaved: \n
4707 /// \returns A 256-bit vector of [4 x double] containing the interleaved values.
4712 /// Constructs a new 256-bit integer vector by first duplicating a
4713 /// 256-bit integer vector given in the first parameter, and then replacing
4714 /// either the upper or the lower 128 bits with the contents of a 128-bit
4729 /// A 256-bit integer vector. This vector is copied to the result first, and
4733 /// A 128-bit integer vector. The contents of this parameter are written to
4738 /// from the two parameters are interleaved: \n
4745 /// \returns A 256-bit integer vector containing the interleaved values.
4755 /// Extracts either the upper or the lower 128 bits from a 256-bit vector
4757 /// returns the extracted bits as a 128-bit vector of [4 x float].
4768 /// A 256-bit vector of [8 x float].
4775 /// \returns A 128-bit vector of [4 x float] containing the extracted bits.
4779 /// Extracts either the upper or the lower 128 bits from a 256-bit vector
4781 /// returns the extracted bits as a 128-bit vector of [2 x double].
4792 /// A 256-bit vector of [4 x double].
4799 /// \returns A 128-bit vector of [2 x double] containing the extracted bits.
4803 /// Extracts either the upper or the lower 128 bits from a 256-bit
4805 /// returns the extracted bits as a 128-bit integer vector.
4816 /// A 256-bit integer vector.
4823 /// \returns A 128-bit integer vector containing the extracted bits.
4827 /// Constructs a 256-bit floating-point vector of [8 x float] by
4828 /// concatenating two 128-bit floating-point vectors of [4 x float].
4835 /// A 128-bit floating-point vector of [4 x float] to be copied to the upper
4838 /// A 128-bit floating-point vector of [4 x float] to be copied to the lower
4840 /// \returns A 256-bit floating-point vector of [8 x float] containing the
4848 /// Constructs a 256-bit floating-point vector of [4 x double] by
4849 /// concatenating two 128-bit floating-point vectors of [2 x double].
4856 /// A 128-bit floating-point vector of [2 x double] to be copied to the upper
4859 /// A 128-bit floating-point vector of [2 x double] to be copied to the lower
4861 /// \returns A 256-bit floating-point vector of [4 x double] containing the
4869 /// Constructs a 256-bit integer vector by concatenating two 128-bit
4877 /// A 128-bit integer vector to be copied to the upper 128 bits of the
4880 /// A 128-bit integer vector to be copied to the lower 128 bits of the
4882 /// \returns A 256-bit integer vector containing the concatenated result.
4889 /// Constructs a 256-bit floating-point vector of [8 x float] by
4890 /// concatenating two 128-bit floating-point vectors of [4 x float]. This is
4899 /// A 128-bit floating-point vector of [4 x float] to be copied to the lower
4902 /// A 128-bit floating-point vector of [4 x float] to be copied to the upper
4904 /// \returns A 256-bit floating-point vector of [8 x float] containing the
4912 /// Constructs a 256-bit floating-point vector of [4 x double] by
4913 /// concatenating two 128-bit floating-point vectors of [2 x double]. This is
4922 /// A 128-bit floating-point vector of [2 x double] to be copied to the lower
4925 /// A 128-bit floating-point vector of [2 x double] to be copied to the upper
4927 /// \returns A 256-bit floating-point vector of [4 x double] containing the
4935 /// Constructs a 256-bit integer vector by concatenating two 128-bit
4944 /// A 128-bit integer vector to be copied to the lower 128 bits of the
4947 /// A 128-bit integer vector to be copied to the upper 128 bits of the
4949 /// \returns A 256-bit integer vector containing the concatenated result.
4957 /// Loads two 128-bit floating-point vectors of [4 x float] from
4958 /// unaligned memory locations and constructs a 256-bit floating-point vector
4959 /// of [8 x float] by concatenating the two 128-bit vectors.
4967 /// A pointer to a 128-bit memory location containing 4 consecutive
4968 /// single-precision floating-point values. These values are to be copied to
4972 /// A pointer to a 128-bit memory location containing 4 consecutive
4973 /// single-precision floating-point values. These values are to be copied to
4976 /// \returns A 256-bit floating-point vector of [8 x float] containing the
4984 /// Loads two 128-bit floating-point vectors of [2 x double] from
4985 /// unaligned memory locations and constructs a 256-bit floating-point vector
4986 /// of [4 x double] by concatenating the two 128-bit vectors.
4994 /// A pointer to a 128-bit memory location containing two consecutive
4995 /// double-precision floating-point values. These values are to be copied to
4999 /// A pointer to a 128-bit memory location containing two consecutive
5000 /// double-precision floating-point values. These values are to be copied to
5003 /// \returns A 256-bit floating-point vector of [4 x double] containing the
5011 /// Loads two 128-bit integer vectors from unaligned memory locations and
5012 /// constructs a 256-bit integer vector by concatenating the two 128-bit
5021 /// A pointer to a 128-bit memory location containing a 128-bit integer
5025 /// A pointer to a 128-bit memory location containing a 128-bit integer
5028 /// \returns A 256-bit integer vector containing the concatenated result.
5036 /// Stores the upper and lower 128 bits of a 256-bit floating-point
5045 /// A pointer to a 128-bit memory location. Bits[255:128] of \a __a are to be
5049 /// A pointer to a 128-bit memory location. Bits[127:0] of \a __a are to be
5053 /// A 256-bit floating-point vector of [8 x float].
5065 /// Stores the upper and lower 128 bits of a 256-bit floating-point
5074 /// A pointer to a 128-bit memory location. Bits[255:128] of \a __a are to be
5078 /// A pointer to a 128-bit memory location. Bits[127:0] of \a __a are to be
5082 /// A 256-bit floating-point vector of [4 x double].
5094 /// Stores the upper and lower 128 bits of a 256-bit integer vector into
5103 /// A pointer to a 128-bit memory location. Bits[255:128] of \a __a are to be
5107 /// A pointer to a 128-bit memory location. Bits[127:0] of \a __a are to be
5111 /// A 256-bit integer vector.