bmiintrin.h revision 360660
1/*===---- bmiintrin.h - BMI intrinsics -------------------------------------=== 2 * 3 * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 * See https://llvm.org/LICENSE.txt for license information. 5 * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 * 7 *===-----------------------------------------------------------------------=== 8 */ 9 10#if !defined __X86INTRIN_H && !defined __IMMINTRIN_H 11#error "Never use <bmiintrin.h> directly; include <x86intrin.h> instead." 12#endif 13 14#ifndef __BMIINTRIN_H 15#define __BMIINTRIN_H 16 17#define _tzcnt_u16(a) (__tzcnt_u16((a))) 18 19#define _andn_u32(a, b) (__andn_u32((a), (b))) 20 21/* _bextr_u32 != __bextr_u32 */ 22#define _blsi_u32(a) (__blsi_u32((a))) 23 24#define _blsmsk_u32(a) (__blsmsk_u32((a))) 25 26#define _blsr_u32(a) (__blsr_u32((a))) 27 28#define _tzcnt_u32(a) (__tzcnt_u32((a))) 29 30/* Define the default attributes for the functions in this file. */ 31#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("bmi"))) 32 33/* Allow using the tzcnt intrinsics even for non-BMI targets. Since the TZCNT 34 instruction behaves as BSF on non-BMI targets, there is code that expects 35 to use it as a potentially faster version of BSF. */ 36#define __RELAXED_FN_ATTRS __attribute__((__always_inline__, __nodebug__)) 37 38/// Counts the number of trailing zero bits in the operand. 39/// 40/// \headerfile <x86intrin.h> 41/// 42/// This intrinsic corresponds to the <c> TZCNT </c> instruction. 43/// 44/// \param __X 45/// An unsigned 16-bit integer whose trailing zeros are to be counted. 46/// \returns An unsigned 16-bit integer containing the number of trailing zero 47/// bits in the operand. 48static __inline__ unsigned short __RELAXED_FN_ATTRS 49__tzcnt_u16(unsigned short __X) 50{ 51 return __builtin_ia32_tzcnt_u16(__X); 52} 53 54/// Performs a bitwise AND of the second operand with the one's 55/// complement of the first operand. 56/// 57/// \headerfile <x86intrin.h> 58/// 59/// This intrinsic corresponds to the <c> ANDN </c> instruction. 60/// 61/// \param __X 62/// An unsigned integer containing one of the operands. 63/// \param __Y 64/// An unsigned integer containing one of the operands. 65/// \returns An unsigned integer containing the bitwise AND of the second 66/// operand with the one's complement of the first operand. 67static __inline__ unsigned int __DEFAULT_FN_ATTRS 68__andn_u32(unsigned int __X, unsigned int __Y) 69{ 70 return ~__X & __Y; 71} 72 73/* AMD-specified, double-leading-underscore version of BEXTR */ 74/// Extracts the specified bits from the first operand and returns them 75/// in the least significant bits of the result. 76/// 77/// \headerfile <x86intrin.h> 78/// 79/// This intrinsic corresponds to the <c> BEXTR </c> instruction. 80/// 81/// \param __X 82/// An unsigned integer whose bits are to be extracted. 83/// \param __Y 84/// An unsigned integer used to specify which bits are extracted. Bits [7:0] 85/// specify the index of the least significant bit. Bits [15:8] specify the 86/// number of bits to be extracted. 87/// \returns An unsigned integer whose least significant bits contain the 88/// extracted bits. 89/// \see _bextr_u32 90static __inline__ unsigned int __DEFAULT_FN_ATTRS 91__bextr_u32(unsigned int __X, unsigned int __Y) 92{ 93 return __builtin_ia32_bextr_u32(__X, __Y); 94} 95 96/* Intel-specified, single-leading-underscore version of BEXTR */ 97/// Extracts the specified bits from the first operand and returns them 98/// in the least significant bits of the result. 99/// 100/// \headerfile <x86intrin.h> 101/// 102/// This intrinsic corresponds to the <c> BEXTR </c> instruction. 103/// 104/// \param __X 105/// An unsigned integer whose bits are to be extracted. 106/// \param __Y 107/// An unsigned integer used to specify the index of the least significant 108/// bit for the bits to be extracted. Bits [7:0] specify the index. 109/// \param __Z 110/// An unsigned integer used to specify the number of bits to be extracted. 111/// Bits [7:0] specify the number of bits. 112/// \returns An unsigned integer whose least significant bits contain the 113/// extracted bits. 114/// \see __bextr_u32 115static __inline__ unsigned int __DEFAULT_FN_ATTRS 116_bextr_u32(unsigned int __X, unsigned int __Y, unsigned int __Z) 117{ 118 return __builtin_ia32_bextr_u32 (__X, ((__Y & 0xff) | ((__Z & 0xff) << 8))); 119} 120 121/// Clears all bits in the source except for the least significant bit 122/// containing a value of 1 and returns the result. 123/// 124/// \headerfile <x86intrin.h> 125/// 126/// This intrinsic corresponds to the <c> BLSI </c> instruction. 127/// 128/// \param __X 129/// An unsigned integer whose bits are to be cleared. 130/// \returns An unsigned integer containing the result of clearing the bits from 131/// the source operand. 132static __inline__ unsigned int __DEFAULT_FN_ATTRS 133__blsi_u32(unsigned int __X) 134{ 135 return __X & -__X; 136} 137 138/// Creates a mask whose bits are set to 1, using bit 0 up to and 139/// including the least significant bit that is set to 1 in the source 140/// operand and returns the result. 141/// 142/// \headerfile <x86intrin.h> 143/// 144/// This intrinsic corresponds to the <c> BLSMSK </c> instruction. 145/// 146/// \param __X 147/// An unsigned integer used to create the mask. 148/// \returns An unsigned integer containing the newly created mask. 149static __inline__ unsigned int __DEFAULT_FN_ATTRS 150__blsmsk_u32(unsigned int __X) 151{ 152 return __X ^ (__X - 1); 153} 154 155/// Clears the least significant bit that is set to 1 in the source 156/// operand and returns the result. 157/// 158/// \headerfile <x86intrin.h> 159/// 160/// This intrinsic corresponds to the <c> BLSR </c> instruction. 161/// 162/// \param __X 163/// An unsigned integer containing the operand to be cleared. 164/// \returns An unsigned integer containing the result of clearing the source 165/// operand. 166static __inline__ unsigned int __DEFAULT_FN_ATTRS 167__blsr_u32(unsigned int __X) 168{ 169 return __X & (__X - 1); 170} 171 172/// Counts the number of trailing zero bits in the operand. 173/// 174/// \headerfile <x86intrin.h> 175/// 176/// This intrinsic corresponds to the <c> TZCNT </c> instruction. 177/// 178/// \param __X 179/// An unsigned 32-bit integer whose trailing zeros are to be counted. 180/// \returns An unsigned 32-bit integer containing the number of trailing zero 181/// bits in the operand. 182static __inline__ unsigned int __RELAXED_FN_ATTRS 183__tzcnt_u32(unsigned int __X) 184{ 185 return __builtin_ia32_tzcnt_u32(__X); 186} 187 188/// Counts the number of trailing zero bits in the operand. 189/// 190/// \headerfile <x86intrin.h> 191/// 192/// This intrinsic corresponds to the <c> TZCNT </c> instruction. 193/// 194/// \param __X 195/// An unsigned 32-bit integer whose trailing zeros are to be counted. 196/// \returns An 32-bit integer containing the number of trailing zero bits in 197/// the operand. 198static __inline__ int __RELAXED_FN_ATTRS 199_mm_tzcnt_32(unsigned int __X) 200{ 201 return __builtin_ia32_tzcnt_u32(__X); 202} 203 204#ifdef __x86_64__ 205 206#define _andn_u64(a, b) (__andn_u64((a), (b))) 207 208/* _bextr_u64 != __bextr_u64 */ 209#define _blsi_u64(a) (__blsi_u64((a))) 210 211#define _blsmsk_u64(a) (__blsmsk_u64((a))) 212 213#define _blsr_u64(a) (__blsr_u64((a))) 214 215#define _tzcnt_u64(a) (__tzcnt_u64((a))) 216 217/// Performs a bitwise AND of the second operand with the one's 218/// complement of the first operand. 219/// 220/// \headerfile <x86intrin.h> 221/// 222/// This intrinsic corresponds to the <c> ANDN </c> instruction. 223/// 224/// \param __X 225/// An unsigned 64-bit integer containing one of the operands. 226/// \param __Y 227/// An unsigned 64-bit integer containing one of the operands. 228/// \returns An unsigned 64-bit integer containing the bitwise AND of the second 229/// operand with the one's complement of the first operand. 230static __inline__ unsigned long long __DEFAULT_FN_ATTRS 231__andn_u64 (unsigned long long __X, unsigned long long __Y) 232{ 233 return ~__X & __Y; 234} 235 236/* AMD-specified, double-leading-underscore version of BEXTR */ 237/// Extracts the specified bits from the first operand and returns them 238/// in the least significant bits of the result. 239/// 240/// \headerfile <x86intrin.h> 241/// 242/// This intrinsic corresponds to the <c> BEXTR </c> instruction. 243/// 244/// \param __X 245/// An unsigned 64-bit integer whose bits are to be extracted. 246/// \param __Y 247/// An unsigned 64-bit integer used to specify which bits are extracted. Bits 248/// [7:0] specify the index of the least significant bit. Bits [15:8] specify 249/// the number of bits to be extracted. 250/// \returns An unsigned 64-bit integer whose least significant bits contain the 251/// extracted bits. 252/// \see _bextr_u64 253static __inline__ unsigned long long __DEFAULT_FN_ATTRS 254__bextr_u64(unsigned long long __X, unsigned long long __Y) 255{ 256 return __builtin_ia32_bextr_u64(__X, __Y); 257} 258 259/* Intel-specified, single-leading-underscore version of BEXTR */ 260/// Extracts the specified bits from the first operand and returns them 261/// in the least significant bits of the result. 262/// 263/// \headerfile <x86intrin.h> 264/// 265/// This intrinsic corresponds to the <c> BEXTR </c> instruction. 266/// 267/// \param __X 268/// An unsigned 64-bit integer whose bits are to be extracted. 269/// \param __Y 270/// An unsigned integer used to specify the index of the least significant 271/// bit for the bits to be extracted. Bits [7:0] specify the index. 272/// \param __Z 273/// An unsigned integer used to specify the number of bits to be extracted. 274/// Bits [7:0] specify the number of bits. 275/// \returns An unsigned 64-bit integer whose least significant bits contain the 276/// extracted bits. 277/// \see __bextr_u64 278static __inline__ unsigned long long __DEFAULT_FN_ATTRS 279_bextr_u64(unsigned long long __X, unsigned int __Y, unsigned int __Z) 280{ 281 return __builtin_ia32_bextr_u64 (__X, ((__Y & 0xff) | ((__Z & 0xff) << 8))); 282} 283 284/// Clears all bits in the source except for the least significant bit 285/// containing a value of 1 and returns the result. 286/// 287/// \headerfile <x86intrin.h> 288/// 289/// This intrinsic corresponds to the <c> BLSI </c> instruction. 290/// 291/// \param __X 292/// An unsigned 64-bit integer whose bits are to be cleared. 293/// \returns An unsigned 64-bit integer containing the result of clearing the 294/// bits from the source operand. 295static __inline__ unsigned long long __DEFAULT_FN_ATTRS 296__blsi_u64(unsigned long long __X) 297{ 298 return __X & -__X; 299} 300 301/// Creates a mask whose bits are set to 1, using bit 0 up to and 302/// including the least significant bit that is set to 1 in the source 303/// operand and returns the result. 304/// 305/// \headerfile <x86intrin.h> 306/// 307/// This intrinsic corresponds to the <c> BLSMSK </c> instruction. 308/// 309/// \param __X 310/// An unsigned 64-bit integer used to create the mask. 311/// \returns An unsigned 64-bit integer containing the newly created mask. 312static __inline__ unsigned long long __DEFAULT_FN_ATTRS 313__blsmsk_u64(unsigned long long __X) 314{ 315 return __X ^ (__X - 1); 316} 317 318/// Clears the least significant bit that is set to 1 in the source 319/// operand and returns the result. 320/// 321/// \headerfile <x86intrin.h> 322/// 323/// This intrinsic corresponds to the <c> BLSR </c> instruction. 324/// 325/// \param __X 326/// An unsigned 64-bit integer containing the operand to be cleared. 327/// \returns An unsigned 64-bit integer containing the result of clearing the 328/// source operand. 329static __inline__ unsigned long long __DEFAULT_FN_ATTRS 330__blsr_u64(unsigned long long __X) 331{ 332 return __X & (__X - 1); 333} 334 335/// Counts the number of trailing zero bits in the operand. 336/// 337/// \headerfile <x86intrin.h> 338/// 339/// This intrinsic corresponds to the <c> TZCNT </c> instruction. 340/// 341/// \param __X 342/// An unsigned 64-bit integer whose trailing zeros are to be counted. 343/// \returns An unsigned 64-bit integer containing the number of trailing zero 344/// bits in the operand. 345static __inline__ unsigned long long __RELAXED_FN_ATTRS 346__tzcnt_u64(unsigned long long __X) 347{ 348 return __builtin_ia32_tzcnt_u64(__X); 349} 350 351/// Counts the number of trailing zero bits in the operand. 352/// 353/// \headerfile <x86intrin.h> 354/// 355/// This intrinsic corresponds to the <c> TZCNT </c> instruction. 356/// 357/// \param __X 358/// An unsigned 64-bit integer whose trailing zeros are to be counted. 359/// \returns An 64-bit integer containing the number of trailing zero bits in 360/// the operand. 361static __inline__ long long __RELAXED_FN_ATTRS 362_mm_tzcnt_64(unsigned long long __X) 363{ 364 return __builtin_ia32_tzcnt_u64(__X); 365} 366 367#endif /* __x86_64__ */ 368 369#undef __DEFAULT_FN_ATTRS 370#undef __RELAXED_FN_ATTRS 371 372#endif /* __BMIINTRIN_H */ 373