Index: clang/lib/Headers/bmiintrin.h =================================================================== --- clang/lib/Headers/bmiintrin.h +++ clang/lib/Headers/bmiintrin.h @@ -19,8 +19,7 @@ to use it as a potentially faster version of BSF. */ #define __RELAXED_FN_ATTRS __attribute__((__always_inline__, __nodebug__)) -#define _tzcnt_u16(a) (__tzcnt_u16((a))) - +/* AMD-specified, double-leading-underscore version of TZCNT */ /// Counts the number of trailing zero bits in the operand. /// /// \headerfile @@ -31,12 +30,32 @@ /// An unsigned 16-bit integer whose trailing zeros are to be counted. /// \returns An unsigned 16-bit integer containing the number of trailing zero /// bits in the operand. +/// \see _tzcnt_u16 static __inline__ unsigned short __RELAXED_FN_ATTRS __tzcnt_u16(unsigned short __X) { return __builtin_ia32_tzcnt_u16(__X); } +/* Intel-specified, single-leading-underscore version of TZCNT */ +/// Counts the number of trailing zero bits in the operand. +/// +/// \headerfile +/// +/// This intrinsic corresponds to the TZCNT instruction. +/// +/// \param __X +/// An unsigned 16-bit integer whose trailing zeros are to be counted. +/// \returns An unsigned 16-bit integer containing the number of trailing zero +/// bits in the operand. +/// \see __tzcnt_u16 +static __inline__ unsigned short __RELAXED_FN_ATTRS +_tzcnt_u16(unsigned short __X) +{ + return __builtin_ia32_tzcnt_u16(__X); +} + +/* AMD-specified, double-leading-underscore version of TZCNT */ /// Counts the number of trailing zero bits in the operand. /// /// \headerfile @@ -47,13 +66,31 @@ /// An unsigned 32-bit integer whose trailing zeros are to be counted. /// \returns An unsigned 32-bit integer containing the number of trailing zero /// bits in the operand. -/// \see _mm_tzcnt_32 +/// \see _tzcnt_u32 static __inline__ unsigned int __RELAXED_FN_ATTRS __tzcnt_u32(unsigned int __X) { return __builtin_ia32_tzcnt_u32(__X); } +/* Intel-specified, single-leading-underscore version of TZCNT */ +/// Counts the number of trailing zero bits in the operand. +/// +/// \headerfile +/// +/// This intrinsic corresponds to the TZCNT instruction. +/// +/// \param __X +/// An unsigned 32-bit integer whose trailing zeros are to be counted. +/// \returns An unsigned 32-bit integer containing the number of trailing zero +/// bits in the operand. +/// \see __tzcnt_u32 +static __inline__ unsigned int __RELAXED_FN_ATTRS +_tzcnt_u32(unsigned int __X) +{ + return __builtin_ia32_tzcnt_u32(__X); +} + /// Counts the number of trailing zero bits in the operand. /// /// \headerfile @@ -71,10 +108,9 @@ return (int)__builtin_ia32_tzcnt_u32(__X); } -#define _tzcnt_u32(a) (__tzcnt_u32((a))) - #ifdef __x86_64__ +/* AMD-specified, double-leading-underscore version of TZCNT */ /// Counts the number of trailing zero bits in the operand. /// /// \headerfile @@ -85,13 +121,31 @@ /// An unsigned 64-bit integer whose trailing zeros are to be counted. /// \returns An unsigned 64-bit integer containing the number of trailing zero /// bits in the operand. -/// \see _mm_tzcnt_64 +/// \see _tzcnt_u64 static __inline__ unsigned long long __RELAXED_FN_ATTRS __tzcnt_u64(unsigned long long __X) { return __builtin_ia32_tzcnt_u64(__X); } +/* Intel-specified, single-leading-underscore version of TZCNT */ +/// Counts the number of trailing zero bits in the operand. +/// +/// \headerfile +/// +/// This intrinsic corresponds to the TZCNT instruction. +/// +/// \param __X +/// An unsigned 64-bit integer whose trailing zeros are to be counted. +/// \returns An unsigned 64-bit integer containing the number of trailing zero +/// bits in the operand. +/// \see __tzcnt_u64 +static __inline__ unsigned long long __RELAXED_FN_ATTRS +_tzcnt_u64(unsigned long long __X) +{ + return __builtin_ia32_tzcnt_u64(__X); +} + /// Counts the number of trailing zero bits in the operand. /// /// \headerfile @@ -109,8 +163,6 @@ return (long long)__builtin_ia32_tzcnt_u64(__X); } -#define _tzcnt_u64(a) (__tzcnt_u64((a))) - #endif /* __x86_64__ */ #undef __RELAXED_FN_ATTRS @@ -121,15 +173,7 @@ /* Define the default attributes for the functions in this file. */ #define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("bmi"))) -#define _andn_u32(a, b) (__andn_u32((a), (b))) - -/* _bextr_u32 != __bextr_u32 */ -#define _blsi_u32(a) (__blsi_u32((a))) - -#define _blsmsk_u32(a) (__blsmsk_u32((a))) - -#define _blsr_u32(a) (__blsr_u32((a))) - +/* AMD-specified, double-leading-underscore version of ANDN */ /// Performs a bitwise AND of the second operand with the one's /// complement of the first operand. /// @@ -143,12 +187,34 @@ /// An unsigned integer containing one of the operands. /// \returns An unsigned integer containing the bitwise AND of the second /// operand with the one's complement of the first operand. +/// \see _andn_u32 static __inline__ unsigned int __DEFAULT_FN_ATTRS __andn_u32(unsigned int __X, unsigned int __Y) { return ~__X & __Y; } +/* Intel-specified, single-leading-underscore version of ANDN */ +/// Performs a bitwise AND of the second operand with the one's +/// complement of the first operand. +/// +/// \headerfile +/// +/// This intrinsic corresponds to the ANDN instruction. +/// +/// \param __X +/// An unsigned integer containing one of the operands. +/// \param __Y +/// An unsigned integer containing one of the operands. +/// \returns An unsigned integer containing the bitwise AND of the second +/// operand with the one's complement of the first operand. +/// \see __andn_u32 +static __inline__ unsigned int __DEFAULT_FN_ATTRS +_andn_u32(unsigned int __X, unsigned int __Y) +{ + return ~__X & __Y; +} + /* AMD-specified, double-leading-underscore version of BEXTR */ /// Extracts the specified bits from the first operand and returns them /// in the least significant bits of the result. @@ -172,6 +238,7 @@ return __builtin_ia32_bextr_u32(__X, __Y); } +/* _bextr_u32 != __bextr_u32 */ /* Intel-specified, single-leading-underscore version of BEXTR */ /// Extracts the specified bits from the first operand and returns them /// in the least significant bits of the result. @@ -219,6 +286,7 @@ return __builtin_ia32_bextr_u32(__X, __Y); } +/* AMD-specified, double-leading-underscore version of BLSI */ /// Clears all bits in the source except for the least significant bit /// containing a value of 1 and returns the result. /// @@ -230,12 +298,33 @@ /// An unsigned integer whose bits are to be cleared. /// \returns An unsigned integer containing the result of clearing the bits from /// the source operand. +/// \see _blsi_u32 static __inline__ unsigned int __DEFAULT_FN_ATTRS __blsi_u32(unsigned int __X) { return __X & -__X; } +/* Intel-specified, single-leading-underscore version of BLSI */ +/// Clears all bits in the source except for the least significant bit +/// containing a value of 1 and returns the result. +/// +/// \headerfile +/// +/// This intrinsic corresponds to the BLSI instruction. +/// +/// \param __X +/// An unsigned integer whose bits are to be cleared. +/// \returns An unsigned integer containing the result of clearing the bits from +/// the source operand. +/// \see __blsi_u32 +static __inline__ unsigned int __DEFAULT_FN_ATTRS +_blsi_u32(unsigned int __X) +{ + return __X & -__X; +} + +/* AMD-specified, double-leading-underscore version of BLSMSK */ /// Creates a mask whose bits are set to 1, using bit 0 up to and /// including the least significant bit that is set to 1 in the source /// operand and returns the result. @@ -247,12 +336,33 @@ /// \param __X /// An unsigned integer used to create the mask. /// \returns An unsigned integer containing the newly created mask. +/// \see _blsmsk_u32 static __inline__ unsigned int __DEFAULT_FN_ATTRS __blsmsk_u32(unsigned int __X) { return __X ^ (__X - 1); } +/* Intel-specified, single-leading-underscore version of BLSMSK */ +/// Creates a mask whose bits are set to 1, using bit 0 up to and +/// including the least significant bit that is set to 1 in the source +/// operand and returns the result. +/// +/// \headerfile +/// +/// This intrinsic corresponds to the BLSMSK instruction. +/// +/// \param __X +/// An unsigned integer used to create the mask. +/// \returns An unsigned integer containing the newly created mask. +/// \see __blsmsk_u32 +static __inline__ unsigned int __DEFAULT_FN_ATTRS +_blsmsk_u32(unsigned int __X) +{ + return __X ^ (__X - 1); +} + +/* AMD-specified, double-leading-underscore version of BLSR */ /// Clears the least significant bit that is set to 1 in the source /// operand and returns the result. /// @@ -264,23 +374,35 @@ /// An unsigned integer containing the operand to be cleared. /// \returns An unsigned integer containing the result of clearing the source /// operand. +/// \see _blsr_u32 static __inline__ unsigned int __DEFAULT_FN_ATTRS __blsr_u32(unsigned int __X) { return __X & (__X - 1); } -#ifdef __x86_64__ - -#define _andn_u64(a, b) (__andn_u64((a), (b))) - -/* _bextr_u64 != __bextr_u64 */ -#define _blsi_u64(a) (__blsi_u64((a))) - -#define _blsmsk_u64(a) (__blsmsk_u64((a))) +/* Intel-specified, single-leading-underscore version of BLSR */ +/// Clears the least significant bit that is set to 1 in the source +/// operand and returns the result. +/// +/// \headerfile +/// +/// This intrinsic corresponds to the BLSR instruction. +/// +/// \param __X +/// An unsigned integer containing the operand to be cleared. +/// \returns An unsigned integer containing the result of clearing the source +/// operand. +/// \see __blsr_u32 +static __inline__ unsigned int __DEFAULT_FN_ATTRS +_blsr_u32(unsigned int __X) +{ + return __X & (__X - 1); +} -#define _blsr_u64(a) (__blsr_u64((a))) +#ifdef __x86_64__ +/* AMD-specified, double-leading-underscore version of ANDN */ /// Performs a bitwise AND of the second operand with the one's /// complement of the first operand. /// @@ -294,12 +416,34 @@ /// An unsigned 64-bit integer containing one of the operands. /// \returns An unsigned 64-bit integer containing the bitwise AND of the second /// operand with the one's complement of the first operand. +/// \see _andn_u64 static __inline__ unsigned long long __DEFAULT_FN_ATTRS __andn_u64 (unsigned long long __X, unsigned long long __Y) { return ~__X & __Y; } +/* Intel-specified, single-leading-underscore version of ANDN */ +/// Performs a bitwise AND of the second operand with the one's +/// complement of the first operand. +/// +/// \headerfile +/// +/// This intrinsic corresponds to the ANDN instruction. +/// +/// \param __X +/// An unsigned 64-bit integer containing one of the operands. +/// \param __Y +/// An unsigned 64-bit integer containing one of the operands. +/// \returns An unsigned 64-bit integer containing the bitwise AND of the second +/// operand with the one's complement of the first operand. +/// \see __andn_u64 +static __inline__ unsigned long long __DEFAULT_FN_ATTRS +_andn_u64 (unsigned long long __X, unsigned long long __Y) +{ + return ~__X & __Y; +} + /* AMD-specified, double-leading-underscore version of BEXTR */ /// Extracts the specified bits from the first operand and returns them /// in the least significant bits of the result. @@ -323,6 +467,7 @@ return __builtin_ia32_bextr_u64(__X, __Y); } +/* _bextr_u64 != __bextr_u64 */ /* Intel-specified, single-leading-underscore version of BEXTR */ /// Extracts the specified bits from the first operand and returns them /// in the least significant bits of the result. @@ -370,6 +515,7 @@ return __builtin_ia32_bextr_u64(__X, __Y); } +/* AMD-specified, double-leading-underscore version of BLSI */ /// Clears all bits in the source except for the least significant bit /// containing a value of 1 and returns the result. /// @@ -381,12 +527,33 @@ /// An unsigned 64-bit integer whose bits are to be cleared. /// \returns An unsigned 64-bit integer containing the result of clearing the /// bits from the source operand. +/// \see _blsi_u64 static __inline__ unsigned long long __DEFAULT_FN_ATTRS __blsi_u64(unsigned long long __X) { return __X & -__X; } +/* Intel-specified, single-leading-underscore version of BLSI */ +/// Clears all bits in the source except for the least significant bit +/// containing a value of 1 and returns the result. +/// +/// \headerfile +/// +/// This intrinsic corresponds to the BLSI instruction. +/// +/// \param __X +/// An unsigned 64-bit integer whose bits are to be cleared. +/// \returns An unsigned 64-bit integer containing the result of clearing the +/// bits from the source operand. +/// \see __blsi_u64 +static __inline__ unsigned long long __DEFAULT_FN_ATTRS +_blsi_u64(unsigned long long __X) +{ + return __X & -__X; +} + +/* AMD-specified, double-leading-underscore version of BLSMSK */ /// Creates a mask whose bits are set to 1, using bit 0 up to and /// including the least significant bit that is set to 1 in the source /// operand and returns the result. @@ -398,12 +565,33 @@ /// \param __X /// An unsigned 64-bit integer used to create the mask. /// \returns An unsigned 64-bit integer containing the newly created mask. +/// \see _blsmsk_u64 static __inline__ unsigned long long __DEFAULT_FN_ATTRS __blsmsk_u64(unsigned long long __X) { return __X ^ (__X - 1); } +/* Intel-specified, single-leading-underscore version of BLSMSK */ +/// Creates a mask whose bits are set to 1, using bit 0 up to and +/// including the least significant bit that is set to 1 in the source +/// operand and returns the result. +/// +/// \headerfile +/// +/// This intrinsic corresponds to the BLSMSK instruction. +/// +/// \param __X +/// An unsigned 64-bit integer used to create the mask. +/// \returns An unsigned 64-bit integer containing the newly created mask. +/// \see __blsmsk_u64 +static __inline__ unsigned long long __DEFAULT_FN_ATTRS +_blsmsk_u64(unsigned long long __X) +{ + return __X ^ (__X - 1); +} + +/* AMD-specified, double-leading-underscore version of BLSR */ /// Clears the least significant bit that is set to 1 in the source /// operand and returns the result. /// @@ -415,12 +603,32 @@ /// An unsigned 64-bit integer containing the operand to be cleared. /// \returns An unsigned 64-bit integer containing the result of clearing the /// source operand. +/// \see _blsr_u64 static __inline__ unsigned long long __DEFAULT_FN_ATTRS __blsr_u64(unsigned long long __X) { return __X & (__X - 1); } +/* Intel-specified, single-leading-underscore version of BLSR */ +/// Clears the least significant bit that is set to 1 in the source +/// operand and returns the result. +/// +/// \headerfile +/// +/// This intrinsic corresponds to the BLSR instruction. +/// +/// \param __X +/// An unsigned 64-bit integer containing the operand to be cleared. +/// \returns An unsigned 64-bit integer containing the result of clearing the +/// source operand. +/// \see __blsr_u64 +static __inline__ unsigned long long __DEFAULT_FN_ATTRS +_blsr_u64(unsigned long long __X) +{ + return __X & (__X - 1); +} + #endif /* __x86_64__ */ #undef __DEFAULT_FN_ATTRS