Lines Matching +full:64 +full:- +full:bit
1 /*===---- xmmintrin.h - SSE intrinsics -------------------------------------===
21 *===-----------------------------------------------------------------------===
45 /// \brief Adds the 32-bit float values in the low-order bits of the operands.
52 /// A 128-bit vector of [4 x float] containing one of the source operands.
55 /// A 128-bit vector of [4 x float] containing one of the source operands.
57 /// \returns A 128-bit vector of [4 x float] whose lower 32 bits contain the sum
67 /// \brief Adds two 128-bit vectors of [4 x float], and returns the results of
75 /// A 128-bit vector of [4 x float] containing one of the source operands.
77 /// A 128-bit vector of [4 x float] containing one of the source operands.
78 /// \returns A 128-bit vector of [4 x float] containing the sums of both
86 /// \brief Subtracts the 32-bit float value in the low-order bits of the second
94 /// A 128-bit vector of [4 x float] containing the minuend. The lower 32 bits
97 /// A 128-bit vector of [4 x float] containing the subtrahend. The lower 32
99 /// \returns A 128-bit vector of [4 x float] whose lower 32 bits contain the
105 __a[0] -= __b[0]; in _mm_sub_ss()
110 /// operand, both of which are 128-bit vectors of [4 x float] and returns
118 /// A 128-bit vector of [4 x float] containing the minuend.
120 /// A 128-bit vector of [4 x float] containing the subtrahend.
121 /// \returns A 128-bit vector of [4 x float] containing the differences between
126 return (__m128)((__v4sf)__a - (__v4sf)__b); in _mm_sub_ps()
129 /// \brief Multiplies two 32-bit float values in the low-order bits of the
137 /// A 128-bit vector of [4 x float] containing one of the source operands.
140 /// A 128-bit vector of [4 x float] containing one of the source operands.
142 /// \returns A 128-bit vector of [4 x float] containing the product of the lower
152 /// \brief Multiplies two 128-bit vectors of [4 x float] and returns the
160 /// A 128-bit vector of [4 x float] containing one of the source operands.
162 /// A 128-bit vector of [4 x float] containing one of the source operands.
163 /// \returns A 128-bit vector of [4 x float] containing the products of both
171 /// \brief Divides the value in the low-order 32 bits of the first operand by
179 /// A 128-bit vector of [4 x float] containing the dividend. The lower 32
182 /// A 128-bit vector of [4 x float] containing the divisor. The lower 32 bits
184 /// \returns A 128-bit vector of [4 x float] containing the quotients of the
194 /// \brief Divides two 128-bit vectors of [4 x float].
201 /// A 128-bit vector of [4 x float] containing the dividend.
203 /// A 128-bit vector of [4 x float] containing the divisor.
204 /// \returns A 128-bit vector of [4 x float] containing the quotients of both
212 /// \brief Calculates the square root of the value stored in the low-order bits
213 /// of a 128-bit vector of [4 x float].
220 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
222 /// \returns A 128-bit vector of [4 x float] containing the square root of the
223 /// value in the low-order bits of the operand.
231 /// \brief Calculates the square roots of the values stored in a 128-bit vector
239 /// A 128-bit vector of [4 x float].
240 /// \returns A 128-bit vector of [4 x float] containing the square roots of the
249 /// low-order bits of a 128-bit vector of [4 x float].
256 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
258 /// \returns A 128-bit vector of [4 x float] containing the approximate
259 /// reciprocal of the value in the low-order bits of the operand.
268 /// 128-bit vector of [4 x float].
275 /// A 128-bit vector of [4 x float].
276 /// \returns A 128-bit vector of [4 x float] containing the approximate
285 /// stored in the low-order bits of a 128-bit vector of [4 x float].
292 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
294 /// \returns A 128-bit vector of [4 x float] containing the approximate
295 /// reciprocal of the square root of the value in the low-order bits of the
305 /// values stored in a 128-bit vector of [4 x float].
312 /// A 128-bit vector of [4 x float].
313 /// \returns A 128-bit vector of [4 x float] containing the approximate
321 /// \brief Compares two 32-bit float values in the low-order bits of both
322 /// operands and returns the lesser value in the low-order bits of the
330 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
333 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
335 /// \returns A 128-bit vector of [4 x float] whose lower 32 bits contain the
344 /// \brief Compares two 128-bit vectors of [4 x float] and returns the
352 /// A 128-bit vector of [4 x float] containing one of the operands.
354 /// A 128-bit vector of [4 x float] containing one of the operands.
355 /// \returns A 128-bit vector of [4 x float] containing the minimum values
363 /// \brief Compares two 32-bit float values in the low-order bits of both
364 /// operands and returns the greater value in the low-order bits of
372 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
375 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
377 /// \returns A 128-bit vector of [4 x float] whose lower 32 bits contain the
386 /// \brief Compares two 128-bit vectors of [4 x float] and returns the greater
394 /// A 128-bit vector of [4 x float] containing one of the operands.
396 /// A 128-bit vector of [4 x float] containing one of the operands.
397 /// \returns A 128-bit vector of [4 x float] containing the maximum values
405 /// \brief Performs a bitwise AND of two 128-bit vectors of [4 x float].
412 /// A 128-bit vector containing one of the source operands.
414 /// A 128-bit vector containing one of the source operands.
415 /// \returns A 128-bit vector of [4 x float] containing the bitwise AND of the
423 /// \brief Performs a bitwise AND of two 128-bit vectors of [4 x float], using
432 /// A 128-bit vector of [4 x float] containing the first source operand. The
435 /// A 128-bit vector of [4 x float] containing the second source operand.
436 /// \returns A 128-bit vector of [4 x float] containing the bitwise AND of the
445 /// \brief Performs a bitwise OR of two 128-bit vectors of [4 x float].
452 /// A 128-bit vector of [4 x float] containing one of the source operands.
454 /// A 128-bit vector of [4 x float] containing one of the source operands.
455 /// \returns A 128-bit vector of [4 x float] containing the bitwise OR of the
463 /// \brief Performs a bitwise exclusive OR of two 128-bit vectors of
471 /// A 128-bit vector of [4 x float] containing one of the source operands.
473 /// A 128-bit vector of [4 x float] containing one of the source operands.
474 /// \returns A 128-bit vector of [4 x float] containing the bitwise exclusive OR
482 /// \brief Compares two 32-bit float values in the low-order bits of both
484 /// low-order bits of a vector [4 x float].
491 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
494 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
496 /// \returns A 128-bit vector of [4 x float] containing the comparison results
497 /// in the low-order bits.
504 /// \brief Compares each of the corresponding 32-bit float values of the
505 /// 128-bit vectors of [4 x float] for equality.
512 /// A 128-bit vector of [4 x float].
514 /// A 128-bit vector of [4 x float].
515 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
522 /// \brief Compares two 32-bit float values in the low-order bits of both
525 /// comparison in the low-order bits of a vector of [4 x float].
532 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
535 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
537 /// \returns A 128-bit vector of [4 x float] containing the comparison results
538 /// in the low-order bits.
545 /// \brief Compares each of the corresponding 32-bit float values of the
546 /// 128-bit vectors of [4 x float] to determine if the values in the first
554 /// A 128-bit vector of [4 x float].
556 /// A 128-bit vector of [4 x float].
557 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
564 /// \brief Compares two 32-bit float values in the low-order bits of both
567 /// result of the comparison in the low-order bits of a vector of
575 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
578 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
580 /// \returns A 128-bit vector of [4 x float] containing the comparison results
581 /// in the low-order bits.
588 /// \brief Compares each of the corresponding 32-bit float values of the
589 /// 128-bit vectors of [4 x float] to determine if the values in the first
597 /// A 128-bit vector of [4 x float].
599 /// A 128-bit vector of [4 x float].
600 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
607 /// \brief Compares two 32-bit float values in the low-order bits of both
610 /// the comparison in the low-order bits of a vector of [4 x float].
617 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
620 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
622 /// \returns A 128-bit vector of [4 x float] containing the comparison results
623 /// in the low-order bits.
632 /// \brief Compares each of the corresponding 32-bit float values of the
633 /// 128-bit vectors of [4 x float] to determine if the values in the first
641 /// A 128-bit vector of [4 x float].
643 /// A 128-bit vector of [4 x float].
644 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
651 /// \brief Compares two 32-bit float values in the low-order bits of both
654 /// the result of the comparison in the low-order bits of a vector of
662 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
665 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
667 /// \returns A 128-bit vector of [4 x float] containing the comparison results
668 /// in the low-order bits.
677 /// \brief Compares each of the corresponding 32-bit float values of the
678 /// 128-bit vectors of [4 x float] to determine if the values in the first
686 /// A 128-bit vector of [4 x float].
688 /// A 128-bit vector of [4 x float].
689 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
696 /// \brief Compares two 32-bit float values in the low-order bits of both
698 /// low-order bits of a vector of [4 x float].
705 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
708 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
710 /// \returns A 128-bit vector of [4 x float] containing the comparison results
711 /// in the low-order bits.
718 /// \brief Compares each of the corresponding 32-bit float values of the
719 /// 128-bit vectors of [4 x float] for inequality.
726 /// A 128-bit vector of [4 x float].
728 /// A 128-bit vector of [4 x float].
729 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
736 /// \brief Compares two 32-bit float values in the low-order bits of both
739 /// the comparison in the low-order bits of a vector of [4 x float].
746 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
749 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
751 /// \returns A 128-bit vector of [4 x float] containing the comparison results
752 /// in the low-order bits.
759 /// \brief Compares each of the corresponding 32-bit float values of the
760 /// 128-bit vectors of [4 x float] to determine if the values in the first
768 /// A 128-bit vector of [4 x float].
770 /// A 128-bit vector of [4 x float].
771 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
778 /// \brief Compares two 32-bit float values in the low-order bits of both
781 /// the result of the comparison in the low-order bits of a vector of
789 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
792 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
794 /// \returns A 128-bit vector of [4 x float] containing the comparison results
795 /// in the low-order bits.
802 /// \brief Compares each of the corresponding 32-bit float values of the
803 /// 128-bit vectors of [4 x float] to determine if the values in the first
811 /// A 128-bit vector of [4 x float].
813 /// A 128-bit vector of [4 x float].
814 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
821 /// \brief Compares two 32-bit float values in the low-order bits of both
824 /// result of the comparison in the low-order bits of a vector of
832 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
835 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
837 /// \returns A 128-bit vector of [4 x float] containing the comparison results
838 /// in the low-order bits.
847 /// \brief Compares each of the corresponding 32-bit float values of the
848 /// 128-bit vectors of [4 x float] to determine if the values in the first
856 /// A 128-bit vector of [4 x float].
858 /// A 128-bit vector of [4 x float].
859 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
866 /// \brief Compares two 32-bit float values in the low-order bits of both
869 /// returns the result of the comparison in the low-order bits of a vector
877 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
880 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
882 /// \returns A 128-bit vector of [4 x float] containing the comparison results
883 /// in the low-order bits.
892 /// \brief Compares each of the corresponding 32-bit float values of the
893 /// 128-bit vectors of [4 x float] to determine if the values in the first
901 /// A 128-bit vector of [4 x float].
903 /// A 128-bit vector of [4 x float].
904 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
911 /// \brief Compares two 32-bit float values in the low-order bits of both
914 /// result of the comparison in the low-order bits of a vector of
922 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
925 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
927 /// \returns A 128-bit vector of [4 x float] containing the comparison results
928 /// in the low-order bits.
935 /// \brief Compares each of the corresponding 32-bit float values of the
936 /// 128-bit vectors of [4 x float] to determine if the values in the first
944 /// A 128-bit vector of [4 x float].
946 /// A 128-bit vector of [4 x float].
947 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
954 /// \brief Compares two 32-bit float values in the low-order bits of both
957 /// returns the result of the comparison in the low-order bits of a vector
965 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
968 /// A 128-bit vector of [4 x float] containing one of the operands. The lower
970 /// \returns A 128-bit vector of [4 x float] containing the comparison results
971 /// in the low-order bits.
978 /// \brief Compares each of the corresponding 32-bit float values of the
979 /// 128-bit vectors of [4 x float] to determine if the values in the first
987 /// A 128-bit vector of [4 x float].
989 /// A 128-bit vector of [4 x float].
990 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
997 /// \brief Compares two 32-bit float values in the low-order bits of both
1005 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1008 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1017 /// \brief Compares two 32-bit float values in the low-order bits of both
1026 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1029 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1038 /// \brief Compares two 32-bit float values in the low-order bits of both
1047 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1050 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1059 /// \brief Compares two 32-bit float values in the low-order bits of both
1068 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1071 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1080 /// \brief Compares two 32-bit float values in the low-order bits of both
1089 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1092 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1101 /// \brief Compares two 32-bit float values in the low-order bits of both
1110 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1113 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1122 /// \brief Performs an unordered comparison of two 32-bit float values using
1123 /// the low-order bits of both operands to determine equality and returns
1131 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1134 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1143 /// \brief Performs an unordered comparison of two 32-bit float values using
1144 /// the low-order bits of both operands to determine if the first operand is
1152 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1155 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1164 /// \brief Performs an unordered comparison of two 32-bit float values using
1165 /// the low-order bits of both operands to determine if the first operand
1174 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1177 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1186 /// \brief Performs an unordered comparison of two 32-bit float values using
1187 /// the low-order bits of both operands to determine if the first operand
1196 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1199 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1208 /// \brief Performs an unordered comparison of two 32-bit float values using
1209 /// the low-order bits of both operands to determine if the first operand is
1218 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1221 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1230 /// \brief Performs an unordered comparison of two 32-bit float values using
1231 /// the low-order bits of both operands to determine inequality and returns
1239 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1242 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1252 /// [4 x float] into a 32-bit integer.
1259 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1261 /// \returns A 32-bit integer containing the converted value.
1269 /// [4 x float] into a 32-bit integer.
1276 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1278 /// \returns A 32-bit integer containing the converted value.
1288 /// [4 x float] into a 64-bit integer.
1295 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1297 /// \returns A 64-bit integer containing the converted value.
1306 /// \brief Converts two low-order float values in a 128-bit vector of
1307 /// [4 x float] into a 64-bit vector of [2 x i32].
1314 /// A 128-bit vector of [4 x float].
1315 /// \returns A 64-bit integer vector containing the converted values.
1322 /// \brief Converts two low-order float values in a 128-bit vector of
1323 /// [4 x float] into a 64-bit vector of [2 x i32].
1330 /// A 128-bit vector of [4 x float].
1331 /// \returns A 64-bit integer vector containing the converted values.
1339 /// [4 x float] into a 32-bit integer, truncating the result when it is
1347 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1349 /// \returns A 32-bit integer containing the converted value.
1357 /// [4 x float] into a 32-bit integer, truncating the result when it is
1365 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1367 /// \returns A 32-bit integer containing the converted value.
1375 /// [4 x float] into a 64-bit integer, truncating the result when it is
1383 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1385 /// \returns A 64-bit integer containing the converted value.
1392 /// \brief Converts two low-order float values in a 128-bit vector of
1393 /// [4 x float] into a 64-bit vector of [2 x i32], truncating the result
1401 /// A 128-bit vector of [4 x float].
1402 /// \returns A 64-bit integer vector containing the converted values.
1409 /// \brief Converts two low-order float values in a 128-bit vector of [4 x
1410 /// float] into a 64-bit vector of [2 x i32], truncating the result when it
1418 /// A 128-bit vector of [4 x float].
1419 /// \returns A 64-bit integer vector containing the converted values.
1426 /// \brief Converts a 32-bit signed integer value into a floating point value
1436 /// A 128-bit vector of [4 x float].
1438 /// A 32-bit signed integer operand containing the value to be converted.
1439 /// \returns A 128-bit vector of [4 x float] whose lower 32 bits contain the
1449 /// \brief Converts a 32-bit signed integer value into a floating point value
1459 /// A 128-bit vector of [4 x float].
1461 /// A 32-bit signed integer operand containing the value to be converted.
1462 /// \returns A 128-bit vector of [4 x float] whose lower 32 bits contain the
1473 /// \brief Converts a 64-bit signed integer value into a floating point value
1483 /// A 128-bit vector of [4 x float].
1485 /// A 64-bit signed integer operand containing the value to be converted.
1486 /// \returns A 128-bit vector of [4 x float] whose lower 32 bits contain the
1498 /// \brief Converts two elements of a 64-bit vector of [2 x i32] into two
1499 /// floating point values and writes them to the lower 64-bits of the
1508 /// A 128-bit vector of [4 x float].
1510 /// A 64-bit vector of [2 x i32]. The elements in this vector are converted
1511 /// and written to the corresponding low-order elements in the destination.
1512 /// \returns A 128-bit vector of [4 x float] whose lower 64 bits contain the
1513 /// converted value of the second operand. The upper 64 bits are copied from
1514 /// the upper 64 bits of the first operand.
1521 /// \brief Converts two elements of a 64-bit vector of [2 x i32] into two
1522 /// floating point values and writes them to the lower 64-bits of the
1531 /// A 128-bit vector of [4 x float].
1533 /// A 64-bit vector of [2 x i32]. The elements in this vector are converted
1534 /// and written to the corresponding low-order elements in the destination.
1535 /// \returns A 128-bit vector of [4 x float] whose lower 64 bits contain the
1536 /// converted value from the second operand. The upper 64 bits are copied
1537 /// from the upper 64 bits of the first operand.
1552 /// A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
1554 /// \returns A 32-bit float containing the extracted value.
1562 /// high-order bits of a 128-bit vector of [4 x float]. The low-order bits
1563 /// are copied from the low-order bits of the first operand.
1570 /// A 128-bit vector of [4 x float]. Bits [63:0] are written to bits [63:0]
1574 /// [127:64] of the destination.
1575 /// \returns A 128-bit vector of [4 x float] containing the moved values.
1583 __mm_loadh_pi_v2f32 __b = ((struct __mm_loadh_pi_struct*)__p)->__u; in _mm_loadh_pi()
1588 /// \brief Loads two packed float values from the address __p into the low-order
1589 /// bits of a 128-bit vector of [4 x float]. The high-order bits are copied
1590 /// from the high-order bits of the first operand.
1597 /// A 128-bit vector of [4 x float]. Bits [127:64] are written to bits
1598 /// [127:64] of the destination.
1602 /// \returns A 128-bit vector of [4 x float] containing the moved values.
1610 __mm_loadl_pi_v2f32 __b = ((struct __mm_loadl_pi_struct*)__p)->__u; in _mm_loadl_pi()
1615 /// \brief Constructs a 128-bit floating-point vector of [4 x float]. The lower
1616 /// 32 bits of the vector are initialized with the single-precision
1617 /// floating-point value loaded from a specified memory location. The upper
1625 /// A pointer to a 32-bit memory location containing a single-precision
1626 /// floating-point value.
1627 /// \returns An initialized 128-bit floating-point vector of [4 x float]. The
1636 float __u = ((struct __mm_load_ss_struct*)__p)->__u; in _mm_load_ss()
1640 /// \brief Loads a 32-bit float value and duplicates it to all four vector
1641 /// elements of a 128-bit vector of [4 x float].
1650 /// \returns A 128-bit vector of [4 x float] containing the loaded
1658 float __u = ((struct __mm_load1_ps_struct*)__p)->__u; in _mm_load1_ps()
1664 /// \brief Loads a 128-bit floating-point vector of [4 x float] from an aligned
1672 /// A pointer to a 128-bit memory location. The address of the memory
1673 /// location has to be 128-bit aligned.
1674 /// \returns A 128-bit vector of [4 x float] containing the loaded valus.
1681 /// \brief Loads a 128-bit floating-point vector of [4 x float] from an
1689 /// A pointer to a 128-bit memory location. The address of the memory
1691 /// \returns A 128-bit vector of [4 x float] containing the loaded values.
1698 return ((struct __loadu_ps*)__p)->__v; in _mm_loadu_ps()
1702 /// memory location to 32-bit elements in a 128-bit vector of [4 x float].
1710 /// A pointer to a 128-bit memory location. The address of the memory
1711 /// location has to be 128-bit aligned.
1712 /// \returns A 128-bit vector of [4 x float] containing the moved values, loaded
1721 /// \brief Create a 128-bit vector of [4 x float] with undefined values.
1727 /// \returns A 128-bit vector of [4 x float] containing undefined values.
1735 /// \brief Constructs a 128-bit floating-point vector of [4 x float]. The lower
1736 /// 32 bits of the vector are initialized with the specified single-precision
1737 /// floating-point value. The upper 96 bits are set to zero.
1744 /// A single-precision floating-point value used to initialize the lower 32
1746 /// \returns An initialized 128-bit floating-point vector of [4 x float]. The
1755 /// \brief Constructs a 128-bit floating-point vector of [4 x float], with each
1756 /// of the four single-precision floating-point vector elements set to the
1757 /// specified single-precision floating-point value.
1764 /// A single-precision floating-point value used to initialize each vector
1766 /// \returns An initialized 128-bit floating-point vector of [4 x float].
1774 /// \brief Constructs a 128-bit floating-point vector of [4 x float], with each
1775 /// of the four single-precision floating-point vector elements set to the
1776 /// specified single-precision floating-point value.
1783 /// A single-precision floating-point value used to initialize each vector
1785 /// \returns An initialized 128-bit floating-point vector of [4 x float].
1792 /// \brief Constructs a 128-bit floating-point vector of [4 x float]
1793 /// initialized with the specified single-precision floating-point values.
1801 /// A single-precision floating-point value used to initialize bits [127:96]
1804 /// A single-precision floating-point value used to initialize bits [95:64]
1807 /// A single-precision floating-point value used to initialize bits [63:32]
1810 /// A single-precision floating-point value used to initialize bits [31:0]
1812 /// \returns An initialized 128-bit floating-point vector of [4 x float].
1819 /// \brief Constructs a 128-bit floating-point vector of [4 x float],
1820 /// initialized in reverse order with the specified 32-bit single-precision
1821 /// float-point values.
1829 /// A single-precision floating-point value used to initialize bits [31:0]
1832 /// A single-precision floating-point value used to initialize bits [63:32]
1835 /// A single-precision floating-point value used to initialize bits [95:64]
1838 /// A single-precision floating-point value used to initialize bits [127:96]
1840 /// \returns An initialized 128-bit floating-point vector of [4 x float].
1847 /// \brief Constructs a 128-bit floating-point vector of [4 x float] initialized
1854 /// \returns An initialized 128-bit floating-point vector of [4 x float] with
1862 /// \brief Stores the upper 64 bits of a 128-bit vector of [4 x float] to a
1870 /// A pointer to a 64-bit memory location.
1872 /// A 128-bit vector of [4 x float] containing the values to be stored.
1879 /// \brief Stores the lower 64 bits of a 128-bit vector of [4 x float] to a
1889 /// A 128-bit vector of [4 x float] containing the values to be stored.
1896 /// \brief Stores the lower 32 bits of a 128-bit vector of [4 x float] to a
1904 /// A pointer to a 32-bit memory location.
1906 /// A 128-bit vector of [4 x float] containing the value to be stored.
1913 ((struct __mm_store_ss_struct*)__p)->__u = __a[0]; in _mm_store_ss()
1916 /// \brief Stores float values from a 128-bit vector of [4 x float] to an
1924 /// A pointer to a 128-bit memory location. The address of the memory
1927 /// A 128-bit vector of [4 x float] containing the values to be stored.
1934 ((struct __storeu_ps*)__p)->__v = __a; in _mm_storeu_ps()
1937 /// \brief Stores the lower 32 bits of a 128-bit vector of [4 x float] into
1946 /// A pointer to a 128-bit memory location.
1948 /// A 128-bit vector of [4 x float] whose lower 32 bits are stored to each
1956 /// \brief Stores the lower 32 bits of a 128-bit vector of [4 x float] into
1965 /// A pointer to a 128-bit memory location.
1967 /// A 128-bit vector of [4 x float] whose lower 32 bits are stored to each
1976 /// \brief Stores float values from a 128-bit vector of [4 x float] to an
1984 /// A pointer to a 128-bit memory location. The address of the memory
1985 /// location has to be 128-bit aligned.
1987 /// A 128-bit vector of [4 x float] containing the values to be stored.
1994 /// \brief Stores float values from a 128-bit vector of [4 x float] to an
2003 /// A pointer to a 128-bit memory location. The address of the memory
2004 /// location has to be 128-bit aligned.
2006 /// A 128-bit vector of [4 x float] containing the values to be stored.
2038 /// _MM_HINT_NTA: Move data using the non-temporal access (NTA) hint.
2049 /// \brief Stores a 64-bit integer in the specified aligned memory location. To
2050 /// minimize caching, the data is flagged as non-temporal (unlikely to be
2060 /// A 64-bit integer containing the value to be stored.
2067 /// \brief Moves packed float values from a 128-bit vector of [4 x float] to a
2068 /// 128-bit aligned memory location. To minimize caching, the data is flagged
2069 /// as non-temporal (unlikely to be used again soon).
2076 /// A pointer to a 128-bit aligned memory location that will receive the
2079 /// A 128-bit vector of [4 x float] containing the values to be moved.
2101 /// \brief Extracts 16-bit element from a 64-bit vector of [4 x i16] and
2109 /// A 64-bit vector of [4 x i16].
2116 /// \returns A 16-bit integer containing the extracted 16 bits of packed data.
2120 /// \brief Copies data from the 64-bit vector of [4 x i16] to the destination,
2121 /// and inserts the lower 16-bits of an integer operand at the 16-bit offset
2129 /// A 64-bit vector of [4 x i16].
2131 /// An integer. The lower 16-bit value from this operand is written to the
2142 /// \returns A 64-bit integer vector containing the copied packed data from the
2147 /// \brief Compares each of the corresponding packed 16-bit integer values of
2148 /// the 64-bit integer vectors, and writes the greater value to the
2156 /// A 64-bit integer vector containing one of the source operands.
2158 /// A 64-bit integer vector containing one of the source operands.
2159 /// \returns A 64-bit integer vector containing the comparison results.
2166 /// \brief Compares each of the corresponding packed 8-bit unsigned integer
2167 /// values of the 64-bit integer vectors, and writes the greater value to the
2175 /// A 64-bit integer vector containing one of the source operands.
2177 /// A 64-bit integer vector containing one of the source operands.
2178 /// \returns A 64-bit integer vector containing the comparison results.
2185 /// \brief Compares each of the corresponding packed 16-bit integer values of
2186 /// the 64-bit integer vectors, and writes the lesser value to the
2194 /// A 64-bit integer vector containing one of the source operands.
2196 /// A 64-bit integer vector containing one of the source operands.
2197 /// \returns A 64-bit integer vector containing the comparison results.
2204 /// \brief Compares each of the corresponding packed 8-bit unsigned integer
2205 /// values of the 64-bit integer vectors, and writes the lesser value to the
2213 /// A 64-bit integer vector containing one of the source operands.
2215 /// A 64-bit integer vector containing one of the source operands.
2216 /// \returns A 64-bit integer vector containing the comparison results.
2223 /// \brief Takes the most significant bit from each 8-bit element in a 64-bit
2224 /// integer vector to create a 16-bit mask value. Zero-extends the value to
2225 /// 32-bit integer and writes it to the destination.
2232 /// A 64-bit integer vector containing the values with bits to be extracted.
2233 /// \returns The most significant bit from each 8-bit element in the operand,
2241 /// \brief Multiplies packed 16-bit unsigned integer values and writes the
2242 /// high-order 16 bits of each 32-bit product to the corresponding bits in
2250 /// A 64-bit integer vector containing one of the source operands.
2252 /// A 64-bit integer vector containing one of the source operands.
2253 /// \returns A 64-bit integer vector containing the products of both operands.
2260 /// \brief Shuffles the 4 16-bit integers from a 64-bit integer vector to the
2272 /// A 64-bit integer vector containing the values to be shuffled.
2274 /// An immediate value containing an 8-bit value specifying which elements to
2275 /// copy from a. The destinations within the 64-bit destination are assigned
2281 /// Bit value assignments:
2286 /// \returns A 64-bit integer vector containing the shuffled values.
2290 /// \brief Conditionally copies the values from each 8-bit element in the first
2291 /// 64-bit integer vector operand to the specified memory location, as
2292 /// specified by the most significant bit in the corresponding element in the
2293 /// second 64-bit integer vector operand. To minimize caching, the data is
2294 /// flagged as non-temporal (unlikely to be used again soon).
2301 /// A 64-bit integer vector containing the values with elements to be copied.
2303 /// A 64-bit integer vector operand. The most significant bit from each 8-bit
2305 /// copied. If the most significant bit of a given element is 1, the
2308 /// A pointer to a 64-bit memory location that will receive the conditionally
2317 /// \brief Computes the rounded averages of the packed unsigned 8-bit integer
2326 /// A 64-bit integer vector containing one of the source operands.
2328 /// A 64-bit integer vector containing one of the source operands.
2329 /// \returns A 64-bit integer vector containing the averages of both operands.
2336 /// \brief Computes the rounded averages of the packed unsigned 16-bit integer
2345 /// A 64-bit integer vector containing one of the source operands.
2347 /// A 64-bit integer vector containing one of the source operands.
2348 /// \returns A 64-bit integer vector containing the averages of both operands.
2355 /// \brief Subtracts the corresponding 8-bit unsigned integer values of the two
2356 /// 64-bit vector operands and computes the absolute value for each of the
2365 /// A 64-bit integer vector containing one of the source operands.
2367 /// A 64-bit integer vector containing one of the source operands.
2368 /// \returns A 64-bit integer vector whose lower 16 bits contain the sums of the
2377 /// \brief Returns the contents of the MXCSR register as a 32-bit unsigned
2390 /// * For checking flush-to-zero mode: _MM_FLUSH_ZERO_ON, _MM_FLUSH_ZERO_OFF.
2392 /// * For checking denormals-are-zero mode: _MM_DENORMALS_ZERO_ON,
2407 /// \returns A 32-bit unsigned integer containing the contents of the MXCSR
2415 /// \brief Sets the MXCSR register with the 32-bit unsigned integer value. There
2428 /// * For setting flush-to-zero mode: _MM_FLUSH_ZERO_ON, _MM_FLUSH_ZERO_OFF.
2431 /// * For setting denormals-are-zero mode: _MM_DENORMALS_ZERO_ON,
2435 /// For example, the following expression causes subsequent floating-point
2450 /// A 32-bit unsigned integer value to be written to the MXCSR register.
2457 /// \brief Selects 4 float values from the 128-bit operands of [4 x float], as
2469 /// A 128-bit vector of [4 x float].
2471 /// A 128-bit vector of [4 x float].
2473 /// An immediate value containing an 8-bit value specifying which elements to
2477 /// within the 128-bit destination are assigned values as follows:
2480 /// Bits [5:4] are used to assign values to bits [95:64] in the destination.
2482 /// Bit value assignments:
2485 /// 10: Bits [95:64] copied from the specified operand.
2487 /// \returns A 128-bit vector of [4 x float] containing the shuffled values.
2495 /// \brief Unpacks the high-order (index 2,3) values from two 128-bit vectors of
2496 /// [4 x float] and interleaves them into a 128-bit vector of [4 x
2504 /// A 128-bit vector of [4 x float].
2505 /// Bits [95:64] are written to bits [31:0] of the destination.
2506 /// Bits [127:96] are written to bits [95:64] of the destination.
2508 /// A 128-bit vector of [4 x float].
2509 /// Bits [95:64] are written to bits [63:32] of the destination.
2511 /// \returns A 128-bit vector of [4 x float] containing the interleaved values.
2518 /// \brief Unpacks the low-order (index 0,1) values from two 128-bit vectors of
2519 /// [4 x float] and interleaves them into a 128-bit vector of [4 x
2527 /// A 128-bit vector of [4 x float].
2529 /// Bits [63:32] are written to bits [95:64] of the destination.
2531 /// A 128-bit vector of [4 x float].
2534 /// \returns A 128-bit vector of [4 x float] containing the interleaved values.
2541 /// \brief Constructs a 128-bit floating-point vector of [4 x float]. The lower
2550 /// A 128-bit floating-point vector of [4 x float]. The upper 96 bits are
2553 /// A 128-bit floating-point vector of [4 x float]. The lower 32 bits are
2555 /// \returns A 128-bit floating-point vector of [4 x float].
2562 /// \brief Constructs a 128-bit floating-point vector of [4 x float]. The lower
2563 /// 64 bits are set to the upper 64 bits of the second parameter. The upper
2564 /// 64 bits are set to the upper 64 bits of the first parameter.
2571 /// A 128-bit floating-point vector of [4 x float]. The upper 64 bits are
2572 /// written to the upper 64 bits of the result.
2574 /// A 128-bit floating-point vector of [4 x float]. The upper 64 bits are
2575 /// written to the lower 64 bits of the result.
2576 /// \returns A 128-bit floating-point vector of [4 x float].
2583 /// \brief Constructs a 128-bit floating-point vector of [4 x float]. The lower
2584 /// 64 bits are set to the lower 64 bits of the first parameter. The upper
2585 /// 64 bits are set to the lower 64 bits of the second parameter.
2592 /// A 128-bit floating-point vector of [4 x float]. The lower 64 bits are
2593 /// written to the lower 64 bits of the result.
2595 /// A 128-bit floating-point vector of [4 x float]. The lower 64 bits are
2596 /// written to the upper 64 bits of the result.
2597 /// \returns A 128-bit floating-point vector of [4 x float].
2604 /// \brief Converts a 64-bit vector of [4 x i16] into a 128-bit vector of [4 x
2612 /// A 64-bit vector of [4 x i16]. The elements of the destination are copied
2614 /// \returns A 128-bit vector of [4 x float] containing the copied and converted
2634 /// \brief Converts a 64-bit vector of 16-bit unsigned integer values into a
2635 /// 128-bit vector of [4 x float].
2642 /// A 64-bit vector of 16-bit unsigned integer values. The elements of the
2644 /// \returns A 128-bit vector of [4 x float] containing the copied and converted
2663 /// \brief Converts the lower four 8-bit values from a 64-bit vector of [8 x i8]
2664 /// into a 128-bit vector of [4 x float].
2671 /// A 64-bit vector of [8 x i8]. The elements of the destination are copied
2673 /// \returns A 128-bit vector of [4 x float] containing the copied and converted
2687 /// \brief Converts the lower four unsigned 8-bit integer values from a 64-bit
2688 /// vector of [8 x u8] into a 128-bit vector of [4 x float].
2695 /// A 64-bit vector of unsigned 8-bit integer values. The elements of the
2698 /// \returns A 128-bit vector of [4 x float] containing the copied and converted
2711 /// \brief Converts the two 32-bit signed integer values from each 64-bit vector
2712 /// operand of [2 x i32] into a 128-bit vector of [4 x float].
2719 /// A 64-bit vector of [2 x i32]. The lower elements of the destination are
2722 /// A 64-bit vector of [2 x i32]. The upper elements of the destination are
2724 /// \returns A 128-bit vector of [4 x float] whose lower 64 bits contain the
2725 /// copied and converted values from the first operand. The upper 64 bits
2739 /// \brief Converts each single-precision floating-point element of a 128-bit
2740 /// floating-point vector of [4 x float] into a 16-bit signed integer, and
2741 /// packs the results into a 64-bit integer vector of [4 x i16]. If the
2742 /// floating-point element is NaN or infinity, or if the floating-point
2743 /// element is greater than 0x7FFFFFFF or less than -0x8000, it is converted
2744 /// to 0x8000. Otherwise if the floating-point element is greater
2752 /// A 128-bit floating-point vector of [4 x float].
2753 /// \returns A 64-bit integer vector of [4 x i16] containing the converted
2767 /// \brief Converts each single-precision floating-point element of a 128-bit
2768 /// floating-point vector of [4 x float] into an 8-bit signed integer, and
2769 /// packs the results into the lower 32 bits of a 64-bit integer vector of
2771 /// floating-point element is NaN or infinity, or if the floating-point
2772 /// element is greater than 0x7FFFFFFF or less than -0x80, it is converted
2773 /// to 0x80. Otherwise if the floating-point element is greater
2781 /// 128-bit floating-point vector of [4 x float].
2782 /// \returns A 64-bit integer vector of [8 x i8]. The lower 32 bits contain the
2795 /// \brief Extracts the sign bits from each single-precision floating-point
2796 /// element of a 128-bit floating-point vector of [4 x float] and returns the
2805 /// A 128-bit floating-point vector of [4 x float].
2806 /// \returns A 32-bit integer value. Bits [3:0] contain the sign bits from each
2807 /// single-precision floating-point element of the parameter. Bits [31:4] are
2888 /* Ugly hack for backwards-compatibility (compatible with gcc) */