zig

ia32intrin.h (25986B) - Raw

---

 /* ===-------- ia32intrin.h ---------------------------------------------------===
  *
  * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  * See https://llvm.org/LICENSE.txt for license information.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  *===-----------------------------------------------------------------------===
  */
 
 #ifndef __X86INTRIN_H
 #error "Never use <ia32intrin.h> directly; include <x86intrin.h> instead."
 #endif
 
 #ifndef __IA32INTRIN_H
 #define __IA32INTRIN_H
 
 /* Define the default attributes for the functions in this file. */
 #define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__))
 #define __DEFAULT_FN_ATTRS_CRC32 __attribute__((__always_inline__, __nodebug__, __target__("crc32")))
 
 #if defined(__cplusplus) && (__cplusplus >= 201103L)
 #define __DEFAULT_FN_ATTRS_CAST __attribute__((__always_inline__)) constexpr
 #define __DEFAULT_FN_ATTRS_CONSTEXPR __DEFAULT_FN_ATTRS constexpr
 #else
 #define __DEFAULT_FN_ATTRS_CAST __attribute__((__always_inline__))
 #define __DEFAULT_FN_ATTRS_CONSTEXPR __DEFAULT_FN_ATTRS
 #endif
 
 /// Finds the first set bit starting from the least significant bit. The result
 ///    is undefined if the input is 0.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c BSF instruction or the
 ///    \c TZCNT instruction.
 ///
 /// \param __A
 ///    A 32-bit integer operand.
 /// \returns A 32-bit integer containing the bit number.
 /// \see _bit_scan_forward
 static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
 __bsfd(int __A) {
   return __builtin_ctz((unsigned int)__A);
 }
 
 /// Finds the first set bit starting from the most significant bit. The result
 ///    is undefined if the input is 0.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c BSR instruction or the
 ///    \c LZCNT instruction and an \c XOR.
 ///
 /// \param __A
 ///    A 32-bit integer operand.
 /// \returns A 32-bit integer containing the bit number.
 /// \see _bit_scan_reverse
 static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
 __bsrd(int __A) {
   return 31 - __builtin_clz((unsigned int)__A);
 }
 
 /// Swaps the bytes in the input, converting little endian to big endian or
 ///    vice versa.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c BSWAP instruction.
 ///
 /// \param __A
 ///    A 32-bit integer operand.
 /// \returns A 32-bit integer containing the swapped bytes.
 static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
 __bswapd(int __A) {
   return (int)__builtin_bswap32((unsigned int)__A);
 }
 
 /// Swaps the bytes in the input, converting little endian to big endian or
 ///    vice versa.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c BSWAP instruction.
 ///
 /// \param __A
 ///    A 32-bit integer operand.
 /// \returns A 32-bit integer containing the swapped bytes.
 static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
 _bswap(int __A) {
   return (int)__builtin_bswap32((unsigned int)__A);
 }
 
 /// Finds the first set bit starting from the least significant bit. The result
 ///    is undefined if the input is 0.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// \code
 /// int _bit_scan_forward(int A);
 /// \endcode
 ///
 /// This intrinsic corresponds to the \c BSF instruction or the
 ///    \c TZCNT instruction.
 ///
 /// \param A
 ///    A 32-bit integer operand.
 /// \returns A 32-bit integer containing the bit number.
 /// \see __bsfd
 #define _bit_scan_forward(A) __bsfd((A))
 
 /// Finds the first set bit starting from the most significant bit. The result
 ///    is undefined if the input is 0.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// \code
 /// int _bit_scan_reverse(int A);
 /// \endcode
 ///
 /// This intrinsic corresponds to the \c BSR instruction or the
 ///    \c LZCNT instruction and an \c XOR.
 ///
 /// \param A
 ///    A 32-bit integer operand.
 /// \returns A 32-bit integer containing the bit number.
 /// \see __bsrd
 #define _bit_scan_reverse(A) __bsrd((A))
 
 #ifdef __x86_64__
 /// Finds the first set bit starting from the least significant bit. The result
 ///    is undefined if the input is 0.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c BSF instruction or the
 ///    \c TZCNT instruction.
 ///
 /// \param __A
 ///    A 64-bit integer operand.
 /// \returns A 32-bit integer containing the bit number.
 static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
 __bsfq(long long __A) {
   return (long long)__builtin_ctzll((unsigned long long)__A);
 }
 
 /// Finds the first set bit starting from the most significant bit. The result
 ///    is undefined if input is 0.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c BSR instruction or the
 ///    \c LZCNT instruction and an \c XOR.
 ///
 /// \param __A
 ///    A 64-bit integer operand.
 /// \returns A 32-bit integer containing the bit number.
 static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
 __bsrq(long long __A) {
   return 63 - __builtin_clzll((unsigned long long)__A);
 }
 
 /// Swaps the bytes in the input, converting little endian to big endian or
 ///    vice versa.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c BSWAP instruction.
 ///
 /// \param __A
 ///    A 64-bit integer operand.
 /// \returns A 64-bit integer containing the swapped bytes.
 /// \see _bswap64
 static __inline__ long long __DEFAULT_FN_ATTRS_CONSTEXPR
 __bswapq(long long __A) {
   return (long long)__builtin_bswap64((unsigned long long)__A);
 }
 
 /// Swaps the bytes in the input, converting little endian to big endian or
 ///    vice versa.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// \code
 /// long long _bswap64(long long A);
 /// \endcode
 ///
 /// This intrinsic corresponds to the \c BSWAP instruction.
 ///
 /// \param A
 ///    A 64-bit integer operand.
 /// \returns A 64-bit integer containing the swapped bytes.
 /// \see __bswapq
 #define _bswap64(A) __bswapq((A))
 #endif /* __x86_64__ */
 
 /// Counts the number of bits in the source operand having a value of 1.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c POPCNT instruction or a
 ///    sequence of arithmetic and logic operations to calculate it.
 ///
 /// \param __A
 ///    An unsigned 32-bit integer operand.
 /// \returns A 32-bit integer containing the number of bits with value 1 in the
 ///    source operand.
 /// \see _popcnt32
 static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
 __popcntd(unsigned int __A)
 {
   return __builtin_popcount(__A);
 }
 
 /// Counts the number of bits in the source operand having a value of 1.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// \code
 /// int _popcnt32(int A);
 /// \endcode
 ///
 /// This intrinsic corresponds to the \c POPCNT instruction or a
 ///    sequence of arithmetic and logic operations to calculate it.
 ///
 /// \param A
 ///    An unsigned 32-bit integer operand.
 /// \returns A 32-bit integer containing the number of bits with value 1 in the
 ///    source operand.
 /// \see __popcntd
 #define _popcnt32(A) __popcntd((A))
 
 #ifdef __x86_64__
 /// Counts the number of bits in the source operand having a value of 1.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c POPCNT instruction or a
 ///    sequence of arithmetic and logic operations to calculate it.
 ///
 /// \param __A
 ///    An unsigned 64-bit integer operand.
 /// \returns A 64-bit integer containing the number of bits with value 1 in the
 ///    source operand.
 /// \see _popcnt64
 static __inline__ long long __DEFAULT_FN_ATTRS_CONSTEXPR
 __popcntq(unsigned long long __A)
 {
   return __builtin_popcountll(__A);
 }
 
 /// Counts the number of bits in the source operand having a value of 1.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// \code
 /// long long _popcnt64(unsigned long long A);
 /// \endcode
 ///
 /// This intrinsic corresponds to the \c POPCNT instruction or a
 ///    sequence of arithmetic and logic operations to calculate it.
 ///
 /// \param A
 ///    An unsigned 64-bit integer operand.
 /// \returns A 64-bit integer containing the number of bits with value 1 in the
 ///    source operand.
 /// \see __popcntq
 #define _popcnt64(A) __popcntq((A))
 #endif /* __x86_64__ */
 
 #ifdef __x86_64__
 /// Returns the program status-and-control \c RFLAGS register with the \c VM
 ///    and \c RF flags cleared.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c PUSHFQ + \c POP instruction sequence.
 ///
 /// \returns The 64-bit value of the RFLAGS register.
 static __inline__ unsigned long long __DEFAULT_FN_ATTRS
 __readeflags(void)
 {
   return __builtin_ia32_readeflags_u64();
 }
 
 /// Writes the specified value to the program status-and-control \c RFLAGS
 ///    register. Reserved bits are not affected.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c PUSH + \c POPFQ instruction sequence.
 ///
 /// \param __f
 ///    The 64-bit value to write to \c RFLAGS.
 static __inline__ void __DEFAULT_FN_ATTRS
 __writeeflags(unsigned long long __f)
 {
   __builtin_ia32_writeeflags_u64(__f);
 }
 
 #else /* !__x86_64__ */
 /// Returns the program status-and-control \c EFLAGS register with the \c VM
 ///    and \c RF flags cleared.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c PUSHFD + \c POP instruction sequence.
 ///
 /// \returns The 32-bit value of the EFLAGS register.
 static __inline__ unsigned int __DEFAULT_FN_ATTRS
 __readeflags(void)
 {
   return __builtin_ia32_readeflags_u32();
 }
 
 /// Writes the specified value to the program status-and-control \c EFLAGS
 ///    register. Reserved bits are not affected.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c PUSH + \c POPFD instruction sequence.
 ///
 /// \param __f
 ///    The 32-bit value to write to \c EFLAGS.
 static __inline__ void __DEFAULT_FN_ATTRS
 __writeeflags(unsigned int __f)
 {
   __builtin_ia32_writeeflags_u32(__f);
 }
 #endif /* !__x86_64__ */
 
 /// Casts a 32-bit float value to a 32-bit unsigned integer value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c VMOVD / \c MOVD instruction in x86_64,
 ///    and corresponds to the \c VMOVL / \c MOVL instruction in ia32.
 ///
 /// \param __A
 ///    A 32-bit float value.
 /// \returns A 32-bit unsigned integer containing the converted value.
 static __inline__ unsigned int __DEFAULT_FN_ATTRS_CAST
 _castf32_u32(float __A) {
   return __builtin_bit_cast(unsigned int, __A);
 }
 
 /// Casts a 64-bit float value to a 64-bit unsigned integer value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c VMOVQ / \c MOVQ instruction in x86_64,
 ///    and corresponds to the \c VMOVL / \c MOVL instruction in ia32.
 ///
 /// \param __A
 ///    A 64-bit float value.
 /// \returns A 64-bit unsigned integer containing the converted value.
 static __inline__ unsigned long long __DEFAULT_FN_ATTRS_CAST
 _castf64_u64(double __A) {
   return __builtin_bit_cast(unsigned long long, __A);
 }
 
 /// Casts a 32-bit unsigned integer value to a 32-bit float value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c VMOVQ / \c MOVQ instruction in x86_64,
 ///    and corresponds to the \c FLDS instruction in ia32.
 ///
 /// \param __A
 ///    A 32-bit unsigned integer value.
 /// \returns A 32-bit float value containing the converted value.
 static __inline__ float __DEFAULT_FN_ATTRS_CAST
 _castu32_f32(unsigned int __A) {
   return __builtin_bit_cast(float, __A);
 }
 
 /// Casts a 64-bit unsigned integer value to a 64-bit float value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c VMOVQ / \c MOVQ instruction in x86_64,
 ///    and corresponds to the \c FLDL instruction in ia32.
 ///
 /// \param __A
 ///    A 64-bit unsigned integer value.
 /// \returns A 64-bit float value containing the converted value.
 static __inline__ double __DEFAULT_FN_ATTRS_CAST
 _castu64_f64(unsigned long long __A) {
   return __builtin_bit_cast(double, __A);
 }
 
 /// Adds the unsigned integer operand to the CRC-32C checksum of the
 ///     unsigned char operand.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c CRC32B instruction.
 ///
 /// \param __C
 ///    An unsigned integer operand to add to the CRC-32C checksum of operand
 ///    \a  __D.
 /// \param __D
 ///    An unsigned 8-bit integer operand used to compute the CRC-32C checksum.
 /// \returns The result of adding operand \a __C to the CRC-32C checksum of
 ///    operand \a __D.
 static __inline__ unsigned int __DEFAULT_FN_ATTRS_CRC32
 __crc32b(unsigned int __C, unsigned char __D)
 {
   return __builtin_ia32_crc32qi(__C, __D);
 }
 
 /// Adds the unsigned integer operand to the CRC-32C checksum of the
 ///    unsigned short operand.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c CRC32W instruction.
 ///
 /// \param __C
 ///    An unsigned integer operand to add to the CRC-32C checksum of operand
 ///    \a  __D.
 /// \param __D
 ///    An unsigned 16-bit integer operand used to compute the CRC-32C checksum.
 /// \returns The result of adding operand \a __C to the CRC-32C checksum of
 ///    operand \a __D.
 static __inline__ unsigned int __DEFAULT_FN_ATTRS_CRC32
 __crc32w(unsigned int __C, unsigned short __D)
 {
   return __builtin_ia32_crc32hi(__C, __D);
 }
 
 /// Adds the unsigned integer operand to the CRC-32C checksum of the
 ///    second unsigned integer operand.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c CRC32D instruction.
 ///
 /// \param __C
 ///    An unsigned integer operand to add to the CRC-32C checksum of operand
 ///    \a  __D.
 /// \param __D
 ///    An unsigned 32-bit integer operand used to compute the CRC-32C checksum.
 /// \returns The result of adding operand \a __C to the CRC-32C checksum of
 ///    operand \a __D.
 static __inline__ unsigned int __DEFAULT_FN_ATTRS_CRC32
 __crc32d(unsigned int __C, unsigned int __D)
 {
   return __builtin_ia32_crc32si(__C, __D);
 }
 
 #ifdef __x86_64__
 /// Adds the unsigned integer operand to the CRC-32C checksum of the
 ///    unsigned 64-bit integer operand.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c CRC32Q instruction.
 ///
 /// \param __C
 ///    An unsigned integer operand to add to the CRC-32C checksum of operand
 ///    \a  __D.
 /// \param __D
 ///    An unsigned 64-bit integer operand used to compute the CRC-32C checksum.
 /// \returns The result of adding operand \a __C to the CRC-32C checksum of
 ///    operand \a __D.
 static __inline__ unsigned long long __DEFAULT_FN_ATTRS_CRC32
 __crc32q(unsigned long long __C, unsigned long long __D)
 {
   return __builtin_ia32_crc32di(__C, __D);
 }
 #endif /* __x86_64__ */
 
 /// Reads the specified performance-monitoring counter. Refer to your
 ///    processor's documentation to determine which performance counters are
 ///    supported.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c RDPMC instruction.
 ///
 /// \param __A
 ///    The performance counter to read.
 /// \returns The 64-bit value read from the performance counter.
 /// \see _rdpmc
 static __inline__ unsigned long long __DEFAULT_FN_ATTRS
 __rdpmc(int __A) {
   return __builtin_ia32_rdpmc(__A);
 }
 
 /// Reads the processor's time-stamp counter and the \c IA32_TSC_AUX MSR
 ///    \c (0xc0000103).
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c RDTSCP instruction.
 ///
 /// \param __A
 ///    The address of where to store the 32-bit \c IA32_TSC_AUX value.
 /// \returns The 64-bit value of the time-stamp counter.
 static __inline__ unsigned long long __DEFAULT_FN_ATTRS
 __rdtscp(unsigned int *__A) {
   return __builtin_ia32_rdtscp(__A);
 }
 
 /// Reads the processor's time-stamp counter.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// \code
 /// unsigned long long _rdtsc();
 /// \endcode
 ///
 /// This intrinsic corresponds to the \c RDTSC instruction.
 ///
 /// \returns The 64-bit value of the time-stamp counter.
 #define _rdtsc() __rdtsc()
 
 /// Reads the specified performance monitoring counter. Refer to your
 ///    processor's documentation to determine which performance counters are
 ///    supported.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// \code
 /// unsigned long long _rdpmc(int A);
 /// \endcode
 ///
 /// This intrinsic corresponds to the \c RDPMC instruction.
 ///
 /// \param A
 ///    The performance counter to read.
 /// \returns The 64-bit value read from the performance counter.
 /// \see __rdpmc
 #define _rdpmc(A) __rdpmc(A)
 
 static __inline__ void __DEFAULT_FN_ATTRS
 _wbinvd(void) {
   __builtin_ia32_wbinvd();
 }
 
 /// Rotates an 8-bit value to the left by the specified number of bits.
 ///    This operation is undefined if the number of bits exceeds the size of
 ///    the value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c ROL instruction.
 ///
 /// \param __X
 ///    The unsigned 8-bit value to be rotated.
 /// \param __C
 ///    The number of bits to rotate the value.
 /// \returns The rotated value.
 static __inline__ unsigned char __DEFAULT_FN_ATTRS_CONSTEXPR
 __rolb(unsigned char __X, int __C) {
   return __builtin_rotateleft8(__X, __C);
 }
 
 /// Rotates an 8-bit value to the right by the specified number of bits.
 ///    This operation is undefined if the number of bits exceeds the size of
 ///    the value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c ROR instruction.
 ///
 /// \param __X
 ///    The unsigned 8-bit value to be rotated.
 /// \param __C
 ///    The number of bits to rotate the value.
 /// \returns The rotated value.
 static __inline__ unsigned char __DEFAULT_FN_ATTRS_CONSTEXPR
 __rorb(unsigned char __X, int __C) {
   return __builtin_rotateright8(__X, __C);
 }
 
 /// Rotates a 16-bit value to the left by the specified number of bits.
 ///    This operation is undefined if the number of bits exceeds the size of
 ///    the value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c ROL instruction.
 ///
 /// \param __X
 ///    The unsigned 16-bit value to be rotated.
 /// \param __C
 ///    The number of bits to rotate the value.
 /// \returns The rotated value.
 /// \see _rotwl
 static __inline__ unsigned short __DEFAULT_FN_ATTRS_CONSTEXPR
 __rolw(unsigned short __X, int __C) {
   return __builtin_rotateleft16(__X, __C);
 }
 
 /// Rotates a 16-bit value to the right by the specified number of bits.
 ///    This operation is undefined if the number of bits exceeds the size of
 ///    the value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c ROR instruction.
 ///
 /// \param __X
 ///    The unsigned 16-bit value to be rotated.
 /// \param __C
 ///    The number of bits to rotate the value.
 /// \returns The rotated value.
 /// \see _rotwr
 static __inline__ unsigned short __DEFAULT_FN_ATTRS_CONSTEXPR
 __rorw(unsigned short __X, int __C) {
   return __builtin_rotateright16(__X, __C);
 }
 
 /// Rotates a 32-bit value to the left by the specified number of bits.
 ///    This operation is undefined if the number of bits exceeds the size of
 ///    the value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c ROL instruction.
 ///
 /// \param __X
 ///    The unsigned 32-bit value to be rotated.
 /// \param __C
 ///    The number of bits to rotate the value.
 /// \returns The rotated value.
 /// \see _rotl
 static __inline__ unsigned int __DEFAULT_FN_ATTRS_CONSTEXPR
 __rold(unsigned int __X, int __C) {
   return __builtin_rotateleft32(__X, (unsigned int)__C);
 }
 
 /// Rotates a 32-bit value to the right by the specified number of bits.
 ///    This operation is undefined if the number of bits exceeds the size of
 ///    the value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c ROR instruction.
 ///
 /// \param __X
 ///    The unsigned 32-bit value to be rotated.
 /// \param __C
 ///    The number of bits to rotate the value.
 /// \returns The rotated value.
 /// \see _rotr
 static __inline__ unsigned int __DEFAULT_FN_ATTRS_CONSTEXPR
 __rord(unsigned int __X, int __C) {
   return __builtin_rotateright32(__X, (unsigned int)__C);
 }
 
 #ifdef __x86_64__
 /// Rotates a 64-bit value to the left by the specified number of bits.
 ///    This operation is undefined if the number of bits exceeds the size of
 ///    the value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c ROL instruction.
 ///
 /// \param __X
 ///    The unsigned 64-bit value to be rotated.
 /// \param __C
 ///    The number of bits to rotate the value.
 /// \returns The rotated value.
 static __inline__ unsigned long long __DEFAULT_FN_ATTRS_CONSTEXPR
 __rolq(unsigned long long __X, int __C) {
   return __builtin_rotateleft64(__X, (unsigned long long)__C);
 }
 
 /// Rotates a 64-bit value to the right by the specified number of bits.
 ///    This operation is undefined if the number of bits exceeds the size of
 ///    the value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c ROR instruction.
 ///
 /// \param __X
 ///    The unsigned 64-bit value to be rotated.
 /// \param __C
 ///    The number of bits to rotate the value.
 /// \returns The rotated value.
 static __inline__ unsigned long long __DEFAULT_FN_ATTRS_CONSTEXPR
 __rorq(unsigned long long __X, int __C) {
   return __builtin_rotateright64(__X, (unsigned long long)__C);
 }
 #endif /* __x86_64__ */
 
 #ifndef _MSC_VER
 /* These are already provided as builtins for MSVC. */
 /* Select the correct function based on the size of long. */
 #ifdef __LP64__
 /// Rotates a 64-bit value to the left by the specified number of bits.
 ///    This operation is undefined if the number of bits exceeds the size of
 ///    the value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// \code
 /// unsigned long long _lrotl(unsigned long long a, int b);
 /// \endcode
 ///
 /// This intrinsic corresponds to the \c ROL instruction.
 ///
 /// \param a
 ///    The unsigned 64-bit value to be rotated.
 /// \param b
 ///    The number of bits to rotate the value.
 /// \returns The rotated value.
 /// \see __rolq
 #define _lrotl(a,b) __rolq((a), (b))
 
 /// Rotates a 64-bit value to the right by the specified number of bits.
 ///    This operation is undefined if the number of bits exceeds the size of
 ///    the value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// \code
 /// unsigned long long _lrotr(unsigned long long a, int b);
 /// \endcode
 ///
 /// This intrinsic corresponds to the \c ROR instruction.
 ///
 /// \param a
 ///    The unsigned 64-bit value to be rotated.
 /// \param b
 ///    The number of bits to rotate the value.
 /// \returns The rotated value.
 /// \see __rorq
 #define _lrotr(a,b) __rorq((a), (b))
 #else // __LP64__
 /// Rotates a 32-bit value to the left by the specified number of bits.
 ///    This operation is undefined if the number of bits exceeds the size of
 ///    the value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// \code
 /// unsigned int _lrotl(unsigned int a, int b);
 /// \endcode
 ///
 /// This intrinsic corresponds to the \c ROL instruction.
 ///
 /// \param a
 ///    The unsigned 32-bit value to be rotated.
 /// \param b
 ///    The number of bits to rotate the value.
 /// \returns The rotated value.
 /// \see __rold
 #define _lrotl(a,b) __rold((a), (b))
 
 /// Rotates a 32-bit value to the right by the specified number of bits.
 ///    This operation is undefined if the number of bits exceeds the size of
 ///    the value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// \code
 /// unsigned int _lrotr(unsigned int a, int b);
 /// \endcode
 ///
 /// This intrinsic corresponds to the \c ROR instruction.
 ///
 /// \param a
 ///    The unsigned 32-bit value to be rotated.
 /// \param b
 ///    The number of bits to rotate the value.
 /// \returns The rotated value.
 /// \see __rord
 #define _lrotr(a,b) __rord((a), (b))
 #endif // __LP64__
 
 /// Rotates a 32-bit value to the left by the specified number of bits.
 ///    This operation is undefined if the number of bits exceeds the size of
 ///    the value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// \code
 /// unsigned int _rotl(unsigned int a, int b);
 /// \endcode
 ///
 /// This intrinsic corresponds to the \c ROL instruction.
 ///
 /// \param a
 ///    The unsigned 32-bit value to be rotated.
 /// \param b
 ///    The number of bits to rotate the value.
 /// \returns The rotated value.
 /// \see __rold
 #define _rotl(a,b) __rold((a), (b))
 
 /// Rotates a 32-bit value to the right by the specified number of bits.
 ///    This operation is undefined if the number of bits exceeds the size of
 ///    the value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// \code
 /// unsigned int _rotr(unsigned int a, int b);
 /// \endcode
 ///
 /// This intrinsic corresponds to the \c ROR instruction.
 ///
 /// \param a
 ///    The unsigned 32-bit value to be rotated.
 /// \param b
 ///    The number of bits to rotate the value.
 /// \returns The rotated value.
 /// \see __rord
 #define _rotr(a,b) __rord((a), (b))
 #endif // _MSC_VER
 
 /* These are not builtins so need to be provided in all modes. */
 /// Rotates a 16-bit value to the left by the specified number of bits.
 ///    This operation is undefined if the number of bits exceeds the size of
 ///    the value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// \code
 /// unsigned short _rotwl(unsigned short a, int b);
 /// \endcode
 ///
 /// This intrinsic corresponds to the \c ROL instruction.
 ///
 /// \param a
 ///    The unsigned 16-bit value to be rotated.
 /// \param b
 ///    The number of bits to rotate the value.
 /// \returns The rotated value.
 /// \see __rolw
 #define _rotwl(a,b) __rolw((a), (b))
 
 /// Rotates a 16-bit value to the right by the specified number of bits.
 ///    This operation is undefined if the number of bits exceeds the size of
 ///    the value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// \code
 /// unsigned short _rotwr(unsigned short a, int b);
 /// \endcode
 ///
 /// This intrinsic corresponds to the \c ROR instruction.
 ///
 /// \param a
 ///    The unsigned 16-bit value to be rotated.
 /// \param b
 ///    The number of bits to rotate the value.
 /// \returns The rotated value.
 /// \see __rorw
 #define _rotwr(a,b) __rorw((a), (b))
 
 #undef __DEFAULT_FN_ATTRS
 #undef __DEFAULT_FN_ATTRS_CAST
 #undef __DEFAULT_FN_ATTRS_CRC32
 #undef __DEFAULT_FN_ATTRS_CONSTEXPR
 
 #endif /* __IA32INTRIN_H */