Warning: This file is not a C or C++ file. It does not have highlighting.

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(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
165 defined(__BMI__)
166
167/* Define the default attributes for the functions in this file. */
168#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("bmi")))
169
170/// Performs a bitwise AND of the second operand with the one's
171/// complement of the first operand.
172///
173/// \headerfile <x86intrin.h>
174///
175/// This intrinsic corresponds to the \c ANDN instruction.
176///
177/// \param __X
178/// An unsigned integer containing one of the operands.
179/// \param __Y
180/// An unsigned integer containing one of the operands.
181/// \returns An unsigned integer containing the bitwise AND of the second
182/// operand with the one's complement of the first operand.
183/// \see _andn_u32
184static __inline__ unsigned int __DEFAULT_FN_ATTRS
185__andn_u32(unsigned int __X, unsigned int __Y)
186{
187 return ~__X & __Y;
188}
189
190/// Performs a bitwise AND of the second operand with the one's
191/// complement of the first operand.
192///
193/// \headerfile <x86intrin.h>
194///
195/// \code
196/// unsigned int _andn_u32(unsigned int __X, unsigned int __Y);
197/// \endcode
198///
199/// This intrinsic corresponds to the \c ANDN instruction.
200///
201/// \param __X
202/// An unsigned integer containing one of the operands.
203/// \param __Y
204/// An unsigned integer containing one of the operands.
205/// \returns An unsigned integer containing the bitwise AND of the second
206/// operand with the one's complement of the first operand.
207/// \see __andn_u32
208#define _andn_u32 __andn_u32
209
210/* AMD-specified, double-leading-underscore version of BEXTR */
211/// Extracts the specified bits from the first operand and returns them
212/// in the least significant bits of the result.
213///
214/// \headerfile <x86intrin.h>
215///
216/// This intrinsic corresponds to the \c BEXTR instruction.
217///
218/// \param __X
219/// An unsigned integer whose bits are to be extracted.
220/// \param __Y
221/// An unsigned integer used to specify which bits are extracted. Bits [7:0]
222/// specify the index of the least significant bit. Bits [15:8] specify the
223/// number of bits to be extracted.
224/// \returns An unsigned integer whose least significant bits contain the
225/// extracted bits.
226/// \see _bextr_u32
227static __inline__ unsigned int __DEFAULT_FN_ATTRS
228__bextr_u32(unsigned int __X, unsigned int __Y)
229{
230 return __builtin_ia32_bextr_u32(__X, __Y);
231}
232
233/* Intel-specified, single-leading-underscore version of BEXTR */
234/// Extracts the specified bits from the first operand and returns them
235/// in the least significant bits of the result.
236///
237/// \headerfile <x86intrin.h>
238///
239/// This intrinsic corresponds to the \c BEXTR instruction.
240///
241/// \param __X
242/// An unsigned integer whose bits are to be extracted.
243/// \param __Y
244/// An unsigned integer used to specify the index of the least significant
245/// bit for the bits to be extracted. Bits [7:0] specify the index.
246/// \param __Z
247/// An unsigned integer used to specify the number of bits to be extracted.
248/// Bits [7:0] specify the number of bits.
249/// \returns An unsigned integer whose least significant bits contain the
250/// extracted bits.
251/// \see __bextr_u32
252static __inline__ unsigned int __DEFAULT_FN_ATTRS
253_bextr_u32(unsigned int __X, unsigned int __Y, unsigned int __Z)
254{
255 return __builtin_ia32_bextr_u32 (__X, ((__Y & 0xff) | ((__Z & 0xff) << 8)));
256}
257
258/* Intel-specified, single-leading-underscore version of BEXTR2 */
259/// Extracts the specified bits from the first operand and returns them
260/// in the least significant bits of the result.
261///
262/// \headerfile <x86intrin.h>
263///
264/// This intrinsic corresponds to the \c BEXTR instruction.
265///
266/// \param __X
267/// An unsigned integer whose bits are to be extracted.
268/// \param __Y
269/// An unsigned integer used to specify which bits are extracted. Bits [7:0]
270/// specify the index of the least significant bit. Bits [15:8] specify the
271/// number of bits to be extracted.
272/// \returns An unsigned integer whose least significant bits contain the
273/// extracted bits.
274/// \see __bextr_u32
275static __inline__ unsigned int __DEFAULT_FN_ATTRS
276_bextr2_u32(unsigned int __X, unsigned int __Y) {
277 return __builtin_ia32_bextr_u32(__X, __Y);
278}
279
280/// Clears all bits in the source except for the least significant bit
281/// containing a value of 1 and returns the result.
282///
283/// \headerfile <x86intrin.h>
284///
285/// This intrinsic corresponds to the \c BLSI instruction.
286///
287/// \param __X
288/// An unsigned integer whose bits are to be cleared.
289/// \returns An unsigned integer containing the result of clearing the bits from
290/// the source operand.
291/// \see _blsi_u32
292static __inline__ unsigned int __DEFAULT_FN_ATTRS
293__blsi_u32(unsigned int __X)
294{
295 return __X & -__X;
296}
297
298/// Clears all bits in the source except for the least significant bit
299/// containing a value of 1 and returns the result.
300///
301/// \headerfile <x86intrin.h>
302///
303/// \code
304/// unsigned int _blsi_u32(unsigned int __X);
305/// \endcode
306///
307/// This intrinsic corresponds to the \c BLSI instruction.
308///
309/// \param __X
310/// An unsigned integer whose bits are to be cleared.
311/// \returns An unsigned integer containing the result of clearing the bits from
312/// the source operand.
313/// \see __blsi_u32
314#define _blsi_u32 __blsi_u32
315
316/// Creates a mask whose bits are set to 1, using bit 0 up to and
317/// including the least significant bit that is set to 1 in the source
318/// operand and returns the result.
319///
320/// \headerfile <x86intrin.h>
321///
322/// This intrinsic corresponds to the \c BLSMSK instruction.
323///
324/// \param __X
325/// An unsigned integer used to create the mask.
326/// \returns An unsigned integer containing the newly created mask.
327/// \see _blsmsk_u32
328static __inline__ unsigned int __DEFAULT_FN_ATTRS
329__blsmsk_u32(unsigned int __X)
330{
331 return __X ^ (__X - 1);
332}
333
334/// Creates a mask whose bits are set to 1, using bit 0 up to and
335/// including the least significant bit that is set to 1 in the source
336/// operand and returns the result.
337///
338/// \headerfile <x86intrin.h>
339///
340/// \code
341/// unsigned int _blsmsk_u32(unsigned int __X);
342/// \endcode
343///
344/// This intrinsic corresponds to the \c BLSMSK instruction.
345///
346/// \param __X
347/// An unsigned integer used to create the mask.
348/// \returns An unsigned integer containing the newly created mask.
349/// \see __blsmsk_u32
350#define _blsmsk_u32 __blsmsk_u32
351
352/// Clears the least significant bit that is set to 1 in the source
353/// operand and returns the result.
354///
355/// \headerfile <x86intrin.h>
356///
357/// This intrinsic corresponds to the \c BLSR instruction.
358///
359/// \param __X
360/// An unsigned integer containing the operand to be cleared.
361/// \returns An unsigned integer containing the result of clearing the source
362/// operand.
363/// \see _blsr_u32
364static __inline__ unsigned int __DEFAULT_FN_ATTRS
365__blsr_u32(unsigned int __X)
366{
367 return __X & (__X - 1);
368}
369
370/// Clears the least significant bit that is set to 1 in the source
371/// operand and returns the result.
372///
373/// \headerfile <x86intrin.h>
374///
375/// \code
376/// unsigned int _bls4_u32(unsigned int __X);
377/// \endcode
378///
379/// This intrinsic corresponds to the \c BLSR instruction.
380///
381/// \param __X
382/// An unsigned integer containing the operand to be cleared.
383/// \returns An unsigned integer containing the result of clearing the source
384/// operand.
385/// \see __blsr_u32
386#define _blsr_u32 __blsr_u32
387
388#ifdef __x86_64__
389
390/// Performs a bitwise AND of the second operand with the one's
391/// complement of the first operand.
392///
393/// \headerfile <x86intrin.h>
394///
395/// This intrinsic corresponds to the \c ANDN instruction.
396///
397/// \param __X
398/// An unsigned 64-bit integer containing one of the operands.
399/// \param __Y
400/// An unsigned 64-bit integer containing one of the operands.
401/// \returns An unsigned 64-bit integer containing the bitwise AND of the second
402/// operand with the one's complement of the first operand.
403/// \see _andn_u64
404static __inline__ unsigned long long __DEFAULT_FN_ATTRS
405__andn_u64 (unsigned long long __X, unsigned long long __Y)
406{
407 return ~__X & __Y;
408}
409
410/// Performs a bitwise AND of the second operand with the one's
411/// complement of the first operand.
412///
413/// \headerfile <x86intrin.h>
414///
415/// \code
416/// unsigned long long _andn_u64(unsigned long long __X,
417/// unsigned long long __Y);
418/// \endcode
419///
420/// This intrinsic corresponds to the \c ANDN instruction.
421///
422/// \param __X
423/// An unsigned 64-bit integer containing one of the operands.
424/// \param __Y
425/// An unsigned 64-bit integer containing one of the operands.
426/// \returns An unsigned 64-bit integer containing the bitwise AND of the second
427/// operand with the one's complement of the first operand.
428/// \see __andn_u64
429#define _andn_u64 __andn_u64
430
431/* AMD-specified, double-leading-underscore version of BEXTR */
432/// Extracts the specified bits from the first operand and returns them
433/// in the least significant bits of the result.
434///
435/// \headerfile <x86intrin.h>
436///
437/// This intrinsic corresponds to the \c BEXTR instruction.
438///
439/// \param __X
440/// An unsigned 64-bit integer whose bits are to be extracted.
441/// \param __Y
442/// An unsigned 64-bit integer used to specify which bits are extracted. Bits
443/// [7:0] specify the index of the least significant bit. Bits [15:8] specify
444/// the number of bits to be extracted.
445/// \returns An unsigned 64-bit integer whose least significant bits contain the
446/// extracted bits.
447/// \see _bextr_u64
448static __inline__ unsigned long long __DEFAULT_FN_ATTRS
449__bextr_u64(unsigned long long __X, unsigned long long __Y)
450{
451 return __builtin_ia32_bextr_u64(__X, __Y);
452}
453
454/* Intel-specified, single-leading-underscore version of BEXTR */
455/// Extracts the specified bits from the first operand and returns them
456/// in the least significant bits of the result.
457///
458/// \headerfile <x86intrin.h>
459///
460/// This intrinsic corresponds to the \c BEXTR instruction.
461///
462/// \param __X
463/// An unsigned 64-bit integer whose bits are to be extracted.
464/// \param __Y
465/// An unsigned integer used to specify the index of the least significant
466/// bit for the bits to be extracted. Bits [7:0] specify the index.
467/// \param __Z
468/// An unsigned integer used to specify the number of bits to be extracted.
469/// Bits [7:0] specify the number of bits.
470/// \returns An unsigned 64-bit integer whose least significant bits contain the
471/// extracted bits.
472/// \see __bextr_u64
473static __inline__ unsigned long long __DEFAULT_FN_ATTRS
474_bextr_u64(unsigned long long __X, unsigned int __Y, unsigned int __Z)
475{
476 return __builtin_ia32_bextr_u64 (__X, ((__Y & 0xff) | ((__Z & 0xff) << 8)));
477}
478
479/* Intel-specified, single-leading-underscore version of BEXTR2 */
480/// Extracts the specified bits from the first operand and returns them
481/// in the least significant bits of the result.
482///
483/// \headerfile <x86intrin.h>
484///
485/// This intrinsic corresponds to the \c BEXTR instruction.
486///
487/// \param __X
488/// An unsigned 64-bit integer whose bits are to be extracted.
489/// \param __Y
490/// An unsigned 64-bit integer used to specify which bits are extracted. Bits
491/// [7:0] specify the index of the least significant bit. Bits [15:8] specify
492/// the number of bits to be extracted.
493/// \returns An unsigned 64-bit integer whose least significant bits contain the
494/// extracted bits.
495/// \see __bextr_u64
496static __inline__ unsigned long long __DEFAULT_FN_ATTRS
497_bextr2_u64(unsigned long long __X, unsigned long long __Y) {
498 return __builtin_ia32_bextr_u64(__X, __Y);
499}
500
501/// Clears all bits in the source except for the least significant bit
502/// containing a value of 1 and returns the result.
503///
504/// \headerfile <x86intrin.h>
505///
506/// This intrinsic corresponds to the \c BLSI instruction.
507///
508/// \param __X
509/// An unsigned 64-bit integer whose bits are to be cleared.
510/// \returns An unsigned 64-bit integer containing the result of clearing the
511/// bits from the source operand.
512/// \see _blsi_u64
513static __inline__ unsigned long long __DEFAULT_FN_ATTRS
514__blsi_u64(unsigned long long __X)
515{
516 return __X & -__X;
517}
518
519/// Clears all bits in the source except for the least significant bit
520/// containing a value of 1 and returns the result.
521///
522/// \headerfile <x86intrin.h>
523///
524/// \code
525/// unsigned long long _blsi_u64(unsigned long long __X);
526/// \endcode
527///
528/// This intrinsic corresponds to the \c BLSI instruction.
529///
530/// \param __X
531/// An unsigned 64-bit integer whose bits are to be cleared.
532/// \returns An unsigned 64-bit integer containing the result of clearing the
533/// bits from the source operand.
534/// \see __blsi_u64
535#define _blsi_u64 __blsi_u64
536
537/// Creates a mask whose bits are set to 1, using bit 0 up to and
538/// including the least significant bit that is set to 1 in the source
539/// operand and returns the result.
540///
541/// \headerfile <x86intrin.h>
542///
543/// This intrinsic corresponds to the \c BLSMSK instruction.
544///
545/// \param __X
546/// An unsigned 64-bit integer used to create the mask.
547/// \returns An unsigned 64-bit integer containing the newly created mask.
548/// \see _blsmsk_u64
549static __inline__ unsigned long long __DEFAULT_FN_ATTRS
550__blsmsk_u64(unsigned long long __X)
551{
552 return __X ^ (__X - 1);
553}
554
555/// Creates a mask whose bits are set to 1, using bit 0 up to and
556/// including the least significant bit that is set to 1 in the source
557/// operand and returns the result.
558///
559/// \headerfile <x86intrin.h>
560///
561/// \code
562/// unsigned long long _blsmsk_u64(unsigned long long __X);
563/// \endcode
564///
565/// This intrinsic corresponds to the \c BLSMSK instruction.
566///
567/// \param __X
568/// An unsigned 64-bit integer used to create the mask.
569/// \returns An unsigned 64-bit integer containing the newly created mask.
570/// \see __blsmsk_u64
571#define _blsmsk_u64 __blsmsk_u64
572
573/// Clears the least significant bit that is set to 1 in the source
574/// operand and returns the result.
575///
576/// \headerfile <x86intrin.h>
577///
578/// This intrinsic corresponds to the \c BLSR instruction.
579///
580/// \param __X
581/// An unsigned 64-bit integer containing the operand to be cleared.
582/// \returns An unsigned 64-bit integer containing the result of clearing the
583/// source operand.
584/// \see _blsr_u64
585static __inline__ unsigned long long __DEFAULT_FN_ATTRS
586__blsr_u64(unsigned long long __X)
587{
588 return __X & (__X - 1);
589}
590
591/// Clears the least significant bit that is set to 1 in the source
592/// operand and returns the result.
593///
594/// \headerfile <x86intrin.h>
595///
596/// \code
597/// unsigned long long _blsr_u64(unsigned long long __X);
598/// \endcode
599///
600/// This intrinsic corresponds to the \c BLSR instruction.
601///
602/// \param __X
603/// An unsigned 64-bit integer containing the operand to be cleared.
604/// \returns An unsigned 64-bit integer containing the result of clearing the
605/// source operand.
606/// \see __blsr_u64
607#define _blsr_u64 __blsr_u64
608
609#endif /* __x86_64__ */
610
611#undef __DEFAULT_FN_ATTRS
612
613#endif /* !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) \
614 || defined(__BMI__) */
615
616#endif /* __BMIINTRIN_H */
617

Warning: This file is not a C or C++ file. It does not have highlighting.

source code of clang/lib/Headers/bmiintrin.h