lygstate updated this revision to Diff 550413.
lygstate added a comment.
creating proper function definitions instead of macro define
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D157297/new/
https://reviews.llvm.org/D157297
Files:
clang/lib/Headers/bmiintrin.h
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 <x86intrin.h>
@@ -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 <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> TZCNT </c> 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 <x86intrin.h>
@@ -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 <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> TZCNT </c> 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 <x86intrin.h>
@@ -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 <x86intrin.h>
@@ -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 <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> TZCNT </c> 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 <x86intrin.h>
@@ -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 <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> ANDN </c> 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 <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> BLSI </c> 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 <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> BLSMSK </c> 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 <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> BLSR </c> 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 <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> ANDN </c> 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 <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> BLSI </c> 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 <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> BLSMSK </c> 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 <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> BLSR </c> 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
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
