clang 20.0.0git
bmiintrin.h
Go to the documentation of this file.
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/* Allow using the tzcnt intrinsics even for non-BMI targets. Since the TZCNT
18 instruction behaves as BSF on non-BMI targets, there is code that expects
19 to use it as a potentially faster version of BSF. */
20#define __RELAXED_FN_ATTRS __attribute__((__always_inline__, __nodebug__))
21
22/// Counts the number of trailing zero bits in the operand.
23///
24/// \headerfile <x86intrin.h>
25///
26/// This intrinsic corresponds to the \c TZCNT instruction.
27///
28/// \param __X
29/// An unsigned 16-bit integer whose trailing zeros are to be counted.
30/// \returns An unsigned 16-bit integer containing the number of trailing zero
31/// bits in the operand.
32/// \see _tzcnt_u16
33static __inline__ unsigned short __RELAXED_FN_ATTRS
34__tzcnt_u16(unsigned short __X)
35{
36 return __builtin_ia32_tzcnt_u16(__X);
37}
38
39/// Counts the number of trailing zero bits in the operand.
40///
41/// \headerfile <x86intrin.h>
42///
43/// \code
44/// unsigned short _tzcnt_u16(unsigned short __X);
45/// \endcode
46///
47/// This intrinsic corresponds to the \c TZCNT instruction.
48///
49/// \param __X
50/// An unsigned 16-bit integer whose trailing zeros are to be counted.
51/// \returns An unsigned 16-bit integer containing the number of trailing zero
52/// bits in the operand.
53/// \see __tzcnt_u16
54#define _tzcnt_u16 __tzcnt_u16
55
56/// Counts the number of trailing zero bits in the operand.
57///
58/// \headerfile <x86intrin.h>
59///
60/// This intrinsic corresponds to the \c TZCNT instruction.
61///
62/// \param __X
63/// An unsigned 32-bit integer whose trailing zeros are to be counted.
64/// \returns An unsigned 32-bit integer containing the number of trailing zero
65/// bits in the operand.
66/// \see { _mm_tzcnt_32 _tzcnt_u32 }
67static __inline__ unsigned int __RELAXED_FN_ATTRS
68__tzcnt_u32(unsigned int __X)
69{
70 return __builtin_ia32_tzcnt_u32(__X);
71}
72
73/// Counts the number of trailing zero bits in the operand.
74///
75/// \headerfile <x86intrin.h>
76///
77/// This intrinsic corresponds to the \c TZCNT instruction.
78///
79/// \param __X
80/// An unsigned 32-bit integer whose trailing zeros are to be counted.
81/// \returns A 32-bit integer containing the number of trailing zero bits in
82/// the operand.
83/// \see { __tzcnt_u32 _tzcnt_u32 }
84static __inline__ int __RELAXED_FN_ATTRS
85_mm_tzcnt_32(unsigned int __X)
86{
87 return (int)__builtin_ia32_tzcnt_u32(__X);
88}
89
90/// Counts the number of trailing zero bits in the operand.
91///
92/// \headerfile <x86intrin.h>
93///
94/// \code
95/// unsigned int _tzcnt_u32(unsigned int __X);
96/// \endcode
97///
98/// This intrinsic corresponds to the \c TZCNT instruction.
99///
100/// \param __X
101/// An unsigned 32-bit integer whose trailing zeros are to be counted.
102/// \returns An unsigned 32-bit integer containing the number of trailing zero
103/// bits in the operand.
104/// \see { _mm_tzcnt_32 __tzcnt_u32 }
105#define _tzcnt_u32 __tzcnt_u32
106
107#ifdef __x86_64__
108
109/// Counts the number of trailing zero bits in the operand.
110///
111/// \headerfile <x86intrin.h>
112///
113/// This intrinsic corresponds to the \c TZCNT instruction.
114///
115/// \param __X
116/// An unsigned 64-bit integer whose trailing zeros are to be counted.
117/// \returns An unsigned 64-bit integer containing the number of trailing zero
118/// bits in the operand.
119/// \see { _mm_tzcnt_64 _tzcnt_u64 }
120static __inline__ unsigned long long __RELAXED_FN_ATTRS
121__tzcnt_u64(unsigned long long __X)
122{
123 return __builtin_ia32_tzcnt_u64(__X);
124}
125
126/// Counts the number of trailing zero bits in the operand.
127///
128/// \headerfile <x86intrin.h>
129///
130/// This intrinsic corresponds to the \c TZCNT instruction.
131///
132/// \param __X
133/// An unsigned 64-bit integer whose trailing zeros are to be counted.
134/// \returns An 64-bit integer containing the number of trailing zero bits in
135/// the operand.
136/// \see { __tzcnt_u64 _tzcnt_u64 }
137static __inline__ long long __RELAXED_FN_ATTRS
138_mm_tzcnt_64(unsigned long long __X)
139{
140 return (long long)__builtin_ia32_tzcnt_u64(__X);
141}
142
143/// Counts the number of trailing zero bits in the operand.
144///
145/// \headerfile <x86intrin.h>
146///
147/// \code
148/// unsigned long long _tzcnt_u64(unsigned long long __X);
149/// \endcode
150///
151/// This intrinsic corresponds to the \c TZCNT instruction.
152///
153/// \param __X
154/// An unsigned 64-bit integer whose trailing zeros are to be counted.
155/// \returns An unsigned 64-bit integer containing the number of trailing zero
156/// bits in the operand.
157/// \see { _mm_tzcnt_64 __tzcnt_u64
158#define _tzcnt_u64 __tzcnt_u64
159
160#endif /* __x86_64__ */
161
162#undef __RELAXED_FN_ATTRS
163
164#if !defined(__SCE__) || __has_feature(modules) || defined(__BMI__)
165
166/* Define the default attributes for the functions in this file. */
167#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("bmi")))
168
169/// Performs a bitwise AND of the second operand with the one's
170/// complement of the first operand.
171///
172/// \headerfile <x86intrin.h>
173///
174/// This intrinsic corresponds to the \c ANDN instruction.
175///
176/// \param __X
177/// An unsigned integer containing one of the operands.
178/// \param __Y
179/// An unsigned integer containing one of the operands.
180/// \returns An unsigned integer containing the bitwise AND of the second
181/// operand with the one's complement of the first operand.
182/// \see _andn_u32
183static __inline__ unsigned int __DEFAULT_FN_ATTRS
184__andn_u32(unsigned int __X, unsigned int __Y)
185{
186 return ~__X & __Y;
187}
188
189/// Performs a bitwise AND of the second operand with the one's
190/// complement of the first operand.
191///
192/// \headerfile <x86intrin.h>
193///
194/// \code
195/// unsigned int _andn_u32(unsigned int __X, unsigned int __Y);
196/// \endcode
197///
198/// This intrinsic corresponds to the \c ANDN instruction.
199///
200/// \param __X
201/// An unsigned integer containing one of the operands.
202/// \param __Y
203/// An unsigned integer containing one of the operands.
204/// \returns An unsigned integer containing the bitwise AND of the second
205/// operand with the one's complement of the first operand.
206/// \see __andn_u32
207#define _andn_u32 __andn_u32
208
209/* AMD-specified, double-leading-underscore version of BEXTR */
210/// Extracts the specified bits from the first operand and returns them
211/// in the least significant bits of the result.
212///
213/// \headerfile <x86intrin.h>
214///
215/// This intrinsic corresponds to the \c BEXTR instruction.
216///
217/// \param __X
218/// An unsigned integer whose bits are to be extracted.
219/// \param __Y
220/// An unsigned integer used to specify which bits are extracted. Bits [7:0]
221/// specify the index of the least significant bit. Bits [15:8] specify the
222/// number of bits to be extracted.
223/// \returns An unsigned integer whose least significant bits contain the
224/// extracted bits.
225/// \see _bextr_u32
226static __inline__ unsigned int __DEFAULT_FN_ATTRS
227__bextr_u32(unsigned int __X, unsigned int __Y)
228{
229 return __builtin_ia32_bextr_u32(__X, __Y);
230}
231
232/* Intel-specified, single-leading-underscore version of BEXTR */
233/// Extracts the specified bits from the first operand and returns them
234/// in the least significant bits of the result.
235///
236/// \headerfile <x86intrin.h>
237///
238/// This intrinsic corresponds to the \c BEXTR instruction.
239///
240/// \param __X
241/// An unsigned integer whose bits are to be extracted.
242/// \param __Y
243/// An unsigned integer used to specify the index of the least significant
244/// bit for the bits to be extracted. Bits [7:0] specify the index.
245/// \param __Z
246/// An unsigned integer used to specify the number of bits to be extracted.
247/// Bits [7:0] specify the number of bits.
248/// \returns An unsigned integer whose least significant bits contain the
249/// extracted bits.
250/// \see __bextr_u32
251static __inline__ unsigned int __DEFAULT_FN_ATTRS
252_bextr_u32(unsigned int __X, unsigned int __Y, unsigned int __Z)
253{
254 return __builtin_ia32_bextr_u32 (__X, ((__Y & 0xff) | ((__Z & 0xff) << 8)));
255}
256
257/* Intel-specified, single-leading-underscore version of BEXTR2 */
258/// Extracts the specified bits from the first operand and returns them
259/// in the least significant bits of the result.
260///
261/// \headerfile <x86intrin.h>
262///
263/// This intrinsic corresponds to the \c BEXTR instruction.
264///
265/// \param __X
266/// An unsigned integer whose bits are to be extracted.
267/// \param __Y
268/// An unsigned integer used to specify which bits are extracted. Bits [7:0]
269/// specify the index of the least significant bit. Bits [15:8] specify the
270/// number of bits to be extracted.
271/// \returns An unsigned integer whose least significant bits contain the
272/// extracted bits.
273/// \see __bextr_u32
274static __inline__ unsigned int __DEFAULT_FN_ATTRS
275_bextr2_u32(unsigned int __X, unsigned int __Y) {
276 return __builtin_ia32_bextr_u32(__X, __Y);
277}
278
279/// Clears all bits in the source except for the least significant bit
280/// containing a value of 1 and returns the result.
281///
282/// \headerfile <x86intrin.h>
283///
284/// This intrinsic corresponds to the \c BLSI instruction.
285///
286/// \param __X
287/// An unsigned integer whose bits are to be cleared.
288/// \returns An unsigned integer containing the result of clearing the bits from
289/// the source operand.
290/// \see _blsi_u32
291static __inline__ unsigned int __DEFAULT_FN_ATTRS
292__blsi_u32(unsigned int __X)
293{
294 return __X & -__X;
295}
296
297/// Clears all bits in the source except for the least significant bit
298/// containing a value of 1 and returns the result.
299///
300/// \headerfile <x86intrin.h>
301///
302/// \code
303/// unsigned int _blsi_u32(unsigned int __X);
304/// \endcode
305///
306/// This intrinsic corresponds to the \c BLSI instruction.
307///
308/// \param __X
309/// An unsigned integer whose bits are to be cleared.
310/// \returns An unsigned integer containing the result of clearing the bits from
311/// the source operand.
312/// \see __blsi_u32
313#define _blsi_u32 __blsi_u32
314
315/// Creates a mask whose bits are set to 1, using bit 0 up to and
316/// including the least significant bit that is set to 1 in the source
317/// operand and returns the result.
318///
319/// \headerfile <x86intrin.h>
320///
321/// This intrinsic corresponds to the \c BLSMSK instruction.
322///
323/// \param __X
324/// An unsigned integer used to create the mask.
325/// \returns An unsigned integer containing the newly created mask.
326/// \see _blsmsk_u32
327static __inline__ unsigned int __DEFAULT_FN_ATTRS
328__blsmsk_u32(unsigned int __X)
329{
330 return __X ^ (__X - 1);
331}
332
333/// Creates a mask whose bits are set to 1, using bit 0 up to and
334/// including the least significant bit that is set to 1 in the source
335/// operand and returns the result.
336///
337/// \headerfile <x86intrin.h>
338///
339/// \code
340/// unsigned int _blsmsk_u32(unsigned int __X);
341/// \endcode
342///
343/// This intrinsic corresponds to the \c BLSMSK instruction.
344///
345/// \param __X
346/// An unsigned integer used to create the mask.
347/// \returns An unsigned integer containing the newly created mask.
348/// \see __blsmsk_u32
349#define _blsmsk_u32 __blsmsk_u32
350
351/// Clears the least significant bit that is set to 1 in the source
352/// operand and returns the result.
353///
354/// \headerfile <x86intrin.h>
355///
356/// This intrinsic corresponds to the \c BLSR instruction.
357///
358/// \param __X
359/// An unsigned integer containing the operand to be cleared.
360/// \returns An unsigned integer containing the result of clearing the source
361/// operand.
362/// \see _blsr_u32
363static __inline__ unsigned int __DEFAULT_FN_ATTRS
364__blsr_u32(unsigned int __X)
365{
366 return __X & (__X - 1);
367}
368
369/// Clears the least significant bit that is set to 1 in the source
370/// operand and returns the result.
371///
372/// \headerfile <x86intrin.h>
373///
374/// \code
375/// unsigned int _bls4_u32(unsigned int __X);
376/// \endcode
377///
378/// This intrinsic corresponds to the \c BLSR instruction.
379///
380/// \param __X
381/// An unsigned integer containing the operand to be cleared.
382/// \returns An unsigned integer containing the result of clearing the source
383/// operand.
384/// \see __blsr_u32
385#define _blsr_u32 __blsr_u32
386
387#ifdef __x86_64__
388
389/// Performs a bitwise AND of the second operand with the one's
390/// complement of the first operand.
391///
392/// \headerfile <x86intrin.h>
393///
394/// This intrinsic corresponds to the \c ANDN instruction.
395///
396/// \param __X
397/// An unsigned 64-bit integer containing one of the operands.
398/// \param __Y
399/// An unsigned 64-bit integer containing one of the operands.
400/// \returns An unsigned 64-bit integer containing the bitwise AND of the second
401/// operand with the one's complement of the first operand.
402/// \see _andn_u64
403static __inline__ unsigned long long __DEFAULT_FN_ATTRS
404__andn_u64 (unsigned long long __X, unsigned long long __Y)
405{
406 return ~__X & __Y;
407}
408
409/// Performs a bitwise AND of the second operand with the one's
410/// complement of the first operand.
411///
412/// \headerfile <x86intrin.h>
413///
414/// \code
415/// unsigned long long _andn_u64(unsigned long long __X,
416/// unsigned long long __Y);
417/// \endcode
418///
419/// This intrinsic corresponds to the \c ANDN instruction.
420///
421/// \param __X
422/// An unsigned 64-bit integer containing one of the operands.
423/// \param __Y
424/// An unsigned 64-bit integer containing one of the operands.
425/// \returns An unsigned 64-bit integer containing the bitwise AND of the second
426/// operand with the one's complement of the first operand.
427/// \see __andn_u64
428#define _andn_u64 __andn_u64
429
430/* AMD-specified, double-leading-underscore version of BEXTR */
431/// Extracts the specified bits from the first operand and returns them
432/// in the least significant bits of the result.
433///
434/// \headerfile <x86intrin.h>
435///
436/// This intrinsic corresponds to the \c BEXTR instruction.
437///
438/// \param __X
439/// An unsigned 64-bit integer whose bits are to be extracted.
440/// \param __Y
441/// An unsigned 64-bit integer used to specify which bits are extracted. Bits
442/// [7:0] specify the index of the least significant bit. Bits [15:8] specify
443/// the number of bits to be extracted.
444/// \returns An unsigned 64-bit integer whose least significant bits contain the
445/// extracted bits.
446/// \see _bextr_u64
447static __inline__ unsigned long long __DEFAULT_FN_ATTRS
448__bextr_u64(unsigned long long __X, unsigned long long __Y)
449{
450 return __builtin_ia32_bextr_u64(__X, __Y);
451}
452
453/* Intel-specified, single-leading-underscore version of BEXTR */
454/// Extracts the specified bits from the first operand and returns them
455/// in the least significant bits of the result.
456///
457/// \headerfile <x86intrin.h>
458///
459/// This intrinsic corresponds to the \c BEXTR instruction.
460///
461/// \param __X
462/// An unsigned 64-bit integer whose bits are to be extracted.
463/// \param __Y
464/// An unsigned integer used to specify the index of the least significant
465/// bit for the bits to be extracted. Bits [7:0] specify the index.
466/// \param __Z
467/// An unsigned integer used to specify the number of bits to be extracted.
468/// Bits [7:0] specify the number of bits.
469/// \returns An unsigned 64-bit integer whose least significant bits contain the
470/// extracted bits.
471/// \see __bextr_u64
472static __inline__ unsigned long long __DEFAULT_FN_ATTRS
473_bextr_u64(unsigned long long __X, unsigned int __Y, unsigned int __Z)
474{
475 return __builtin_ia32_bextr_u64 (__X, ((__Y & 0xff) | ((__Z & 0xff) << 8)));
476}
477
478/* Intel-specified, single-leading-underscore version of BEXTR2 */
479/// Extracts the specified bits from the first operand and returns them
480/// in the least significant bits of the result.
481///
482/// \headerfile <x86intrin.h>
483///
484/// This intrinsic corresponds to the \c BEXTR instruction.
485///
486/// \param __X
487/// An unsigned 64-bit integer whose bits are to be extracted.
488/// \param __Y
489/// An unsigned 64-bit integer used to specify which bits are extracted. Bits
490/// [7:0] specify the index of the least significant bit. Bits [15:8] specify
491/// the number of bits to be extracted.
492/// \returns An unsigned 64-bit integer whose least significant bits contain the
493/// extracted bits.
494/// \see __bextr_u64
495static __inline__ unsigned long long __DEFAULT_FN_ATTRS
496_bextr2_u64(unsigned long long __X, unsigned long long __Y) {
497 return __builtin_ia32_bextr_u64(__X, __Y);
498}
499
500/// Clears all bits in the source except for the least significant bit
501/// containing a value of 1 and returns the result.
502///
503/// \headerfile <x86intrin.h>
504///
505/// This intrinsic corresponds to the \c BLSI instruction.
506///
507/// \param __X
508/// An unsigned 64-bit integer whose bits are to be cleared.
509/// \returns An unsigned 64-bit integer containing the result of clearing the
510/// bits from the source operand.
511/// \see _blsi_u64
512static __inline__ unsigned long long __DEFAULT_FN_ATTRS
513__blsi_u64(unsigned long long __X)
514{
515 return __X & -__X;
516}
517
518/// Clears all bits in the source except for the least significant bit
519/// containing a value of 1 and returns the result.
520///
521/// \headerfile <x86intrin.h>
522///
523/// \code
524/// unsigned long long _blsi_u64(unsigned long long __X);
525/// \endcode
526///
527/// This intrinsic corresponds to the \c BLSI instruction.
528///
529/// \param __X
530/// An unsigned 64-bit integer whose bits are to be cleared.
531/// \returns An unsigned 64-bit integer containing the result of clearing the
532/// bits from the source operand.
533/// \see __blsi_u64
534#define _blsi_u64 __blsi_u64
535
536/// Creates a mask whose bits are set to 1, using bit 0 up to and
537/// including the least significant bit that is set to 1 in the source
538/// operand and returns the result.
539///
540/// \headerfile <x86intrin.h>
541///
542/// This intrinsic corresponds to the \c BLSMSK instruction.
543///
544/// \param __X
545/// An unsigned 64-bit integer used to create the mask.
546/// \returns An unsigned 64-bit integer containing the newly created mask.
547/// \see _blsmsk_u64
548static __inline__ unsigned long long __DEFAULT_FN_ATTRS
549__blsmsk_u64(unsigned long long __X)
550{
551 return __X ^ (__X - 1);
552}
553
554/// Creates a mask whose bits are set to 1, using bit 0 up to and
555/// including the least significant bit that is set to 1 in the source
556/// operand and returns the result.
557///
558/// \headerfile <x86intrin.h>
559///
560/// \code
561/// unsigned long long _blsmsk_u64(unsigned long long __X);
562/// \endcode
563///
564/// This intrinsic corresponds to the \c BLSMSK instruction.
565///
566/// \param __X
567/// An unsigned 64-bit integer used to create the mask.
568/// \returns An unsigned 64-bit integer containing the newly created mask.
569/// \see __blsmsk_u64
570#define _blsmsk_u64 __blsmsk_u64
571
572/// Clears the least significant bit that is set to 1 in the source
573/// operand and returns the result.
574///
575/// \headerfile <x86intrin.h>
576///
577/// This intrinsic corresponds to the \c BLSR instruction.
578///
579/// \param __X
580/// An unsigned 64-bit integer containing the operand to be cleared.
581/// \returns An unsigned 64-bit integer containing the result of clearing the
582/// source operand.
583/// \see _blsr_u64
584static __inline__ unsigned long long __DEFAULT_FN_ATTRS
585__blsr_u64(unsigned long long __X)
586{
587 return __X & (__X - 1);
588}
589
590/// Clears the least significant bit that is set to 1 in the source
591/// operand and returns the result.
592///
593/// \headerfile <x86intrin.h>
594///
595/// \code
596/// unsigned long long _blsr_u64(unsigned long long __X);
597/// \endcode
598///
599/// This intrinsic corresponds to the \c BLSR instruction.
600///
601/// \param __X
602/// An unsigned 64-bit integer containing the operand to be cleared.
603/// \returns An unsigned 64-bit integer containing the result of clearing the
604/// source operand.
605/// \see __blsr_u64
606#define _blsr_u64 __blsr_u64
607
608#endif /* __x86_64__ */
609
610#undef __DEFAULT_FN_ATTRS
611
612#endif /* !defined(__SCE__) || __has_feature(modules) || defined(__BMI__) */
613
614#endif /* __BMIINTRIN_H */
static __inline__ unsigned int __RELAXED_FN_ATTRS __tzcnt_u32(unsigned int __X)
Counts the number of trailing zero bits in the operand.
Definition: bmiintrin.h:68
#define __DEFAULT_FN_ATTRS
Definition: bmiintrin.h:167
static __inline__ unsigned int __DEFAULT_FN_ATTRS __bextr_u32(unsigned int __X, unsigned int __Y)
Extracts the specified bits from the first operand and returns them in the least significant bits of ...
Definition: bmiintrin.h:227
static __inline__ unsigned int __DEFAULT_FN_ATTRS __blsmsk_u32(unsigned int __X)
Creates a mask whose bits are set to 1, using bit 0 up to and including the least significant bit tha...
Definition: bmiintrin.h:328
static __inline__ unsigned int __DEFAULT_FN_ATTRS __blsi_u32(unsigned int __X)
Clears all bits in the source except for the least significant bit containing a value of 1 and return...
Definition: bmiintrin.h:292
static __inline__ unsigned int __DEFAULT_FN_ATTRS _bextr_u32(unsigned int __X, unsigned int __Y, unsigned int __Z)
Extracts the specified bits from the first operand and returns them in the least significant bits of ...
Definition: bmiintrin.h:252
static __inline__ unsigned int __DEFAULT_FN_ATTRS _bextr2_u32(unsigned int __X, unsigned int __Y)
Extracts the specified bits from the first operand and returns them in the least significant bits of ...
Definition: bmiintrin.h:275
#define __RELAXED_FN_ATTRS
Definition: bmiintrin.h:20
static __inline__ unsigned int __DEFAULT_FN_ATTRS __andn_u32(unsigned int __X, unsigned int __Y)
Performs a bitwise AND of the second operand with the one's complement of the first operand.
Definition: bmiintrin.h:184
static __inline__ unsigned short __RELAXED_FN_ATTRS __tzcnt_u16(unsigned short __X)
Counts the number of trailing zero bits in the operand.
Definition: bmiintrin.h:34
static __inline__ int __RELAXED_FN_ATTRS _mm_tzcnt_32(unsigned int __X)
Counts the number of trailing zero bits in the operand.
Definition: bmiintrin.h:85
static __inline__ unsigned int __DEFAULT_FN_ATTRS __blsr_u32(unsigned int __X)
Clears the least significant bit that is set to 1 in the source operand and returns the result.
Definition: bmiintrin.h:364
__inline unsigned int unsigned int __Y
Definition: bmi2intrin.h:19