/* ===-------- 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 directly; include 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 /// Find the first set bit starting from the lsb. Result is undefined if /// input is 0. /// /// \headerfile /// /// 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); } /// Find the first set bit starting from the msb. Result is undefined if /// input is 0. /// /// \headerfile /// /// 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 /// /// 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 /// /// 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); } /// Find the first set bit starting from the lsb. Result is undefined if /// input is 0. /// /// \headerfile /// /// \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)) /// Find the first set bit starting from the msb. Result is undefined if /// input is 0. /// /// \headerfile /// /// \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__ /// Find the first set bit starting from the lsb. Result is undefined if /// input is 0. /// /// \headerfile /// /// 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); } /// Find the first set bit starting from the msb. Result is undefined if /// input is 0. /// /// \headerfile /// /// 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 /// /// 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 /// /// \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 /// /// This intrinsic corresponds to the \c POPCNT instruction or a /// a sequence of arithmetic and logic ops 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 /// /// \code /// int _popcnt32(int A); /// \endcode /// /// This intrinsic corresponds to the \c POPCNT instruction or a /// a sequence of arithmetic and logic ops 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 /// /// This intrinsic corresponds to the \c POPCNT instruction or a /// a sequence of arithmetic and logic ops 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 /// /// \code /// long long _popcnt64(unsigned long long A); /// \endcode /// /// This intrinsic corresponds to the \c POPCNT instruction or a /// a sequence of arithmetic and logic ops 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 /// /// 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 /// /// 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 /// /// 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 /// /// 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__ */ /// Cast a 32-bit float value to a 32-bit unsigned integer value. /// /// \headerfile /// /// 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); } /// Cast a 64-bit float value to a 64-bit unsigned integer value. /// /// \headerfile /// /// 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); } /// Cast a 32-bit unsigned integer value to a 32-bit float value. /// /// \headerfile /// /// 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); } /// Cast a 64-bit unsigned integer value to a 64-bit float value. /// /// \headerfile /// /// 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 /// /// 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 /// /// 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 /// /// 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 /// /// 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 /// /// 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 /// /// This intrinsic corresponds to the \c RDTSCP instruction. /// /// \param __A /// 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 /// /// \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 /// /// \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 /// /// 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 /// /// 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 /// /// 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 /// /// 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 /// /// 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 /// /// 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 /// /// 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 /// /// 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 /// /// \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 /// /// \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 /// /// \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 /// /// \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 /// /// \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 /// /// \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 /// /// \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 /// /// \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 */