Clang Project

clang_source_code/lib/Headers/bmiintrin.h
1/*===---- bmiintrin.h - BMI intrinsics -------------------------------------===
2 *
3 * Permission is hereby granted, free of charge, to any person obtaining a copy
4 * of this software and associated documentation files (the "Software"), to deal
5 * in the Software without restriction, including without limitation the rights
6 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 * copies of the Software, and to permit persons to whom the Software is
8 * furnished to do so, subject to the following conditions:
9 *
10 * The above copyright notice and this permission notice shall be included in
11 * all copies or substantial portions of the Software.
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 * THE SOFTWARE.
20 *
21 *===-----------------------------------------------------------------------===
22 */
23
24#if !defined __X86INTRIN_H && !defined __IMMINTRIN_H
25#error "Never use <bmiintrin.h> directly; include <x86intrin.h> instead."
26#endif
27
28#ifndef __BMIINTRIN_H
29#define __BMIINTRIN_H
30
31#define _tzcnt_u16(a)     (__tzcnt_u16((a)))
32
33#define _andn_u32(a, b)   (__andn_u32((a), (b)))
34
35/* _bextr_u32 != __bextr_u32 */
36#define _blsi_u32(a)      (__blsi_u32((a)))
37
38#define _blsmsk_u32(a)    (__blsmsk_u32((a)))
39
40#define _blsr_u32(a)      (__blsr_u32((a)))
41
42#define _tzcnt_u32(a)     (__tzcnt_u32((a)))
43
44/* Define the default attributes for the functions in this file. */
45#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("bmi")))
46
47/* Allow using the tzcnt intrinsics even for non-BMI targets. Since the TZCNT
48   instruction behaves as BSF on non-BMI targets, there is code that expects
49   to use it as a potentially faster version of BSF. */
50#define __RELAXED_FN_ATTRS __attribute__((__always_inline__, __nodebug__))
51
52/// Counts the number of trailing zero bits in the operand.
53///
54/// \headerfile <x86intrin.h>
55///
56/// This intrinsic corresponds to the <c> TZCNT </c> instruction.
57///
58/// \param __X
59///    An unsigned 16-bit integer whose trailing zeros are to be counted.
60/// \returns An unsigned 16-bit integer containing the number of trailing zero
61///    bits in the operand.
62static __inline__ unsigned short __RELAXED_FN_ATTRS
63__tzcnt_u16(unsigned short __X)
64{
65  return __builtin_ia32_tzcnt_u16(__X);
66}
67
68/// Performs a bitwise AND of the second operand with the one's
69///    complement of the first operand.
70///
71/// \headerfile <x86intrin.h>
72///
73/// This intrinsic corresponds to the <c> ANDN </c> instruction.
74///
75/// \param __X
76///    An unsigned integer containing one of the operands.
77/// \param __Y
78///    An unsigned integer containing one of the operands.
79/// \returns An unsigned integer containing the bitwise AND of the second
80///    operand with the one's complement of the first operand.
81static __inline__ unsigned int __DEFAULT_FN_ATTRS
82__andn_u32(unsigned int __X, unsigned int __Y)
83{
84  return ~__X & __Y;
85}
86
87/* AMD-specified, double-leading-underscore version of BEXTR */
88/// Extracts the specified bits from the first operand and returns them
89///    in the least significant bits of the result.
90///
91/// \headerfile <x86intrin.h>
92///
93/// This intrinsic corresponds to the <c> BEXTR </c> instruction.
94///
95/// \param __X
96///    An unsigned integer whose bits are to be extracted.
97/// \param __Y
98///    An unsigned integer used to specify which bits are extracted. Bits [7:0]
99///    specify the index of the least significant bit. Bits [15:8] specify the
100///    number of bits to be extracted.
101/// \returns An unsigned integer whose least significant bits contain the
102///    extracted bits.
103/// \see _bextr_u32
104static __inline__ unsigned int __DEFAULT_FN_ATTRS
105__bextr_u32(unsigned int __X, unsigned int __Y)
106{
107  return __builtin_ia32_bextr_u32(__X, __Y);
108}
109
110/* Intel-specified, single-leading-underscore version of BEXTR */
111/// Extracts the specified bits from the first operand and returns them
112///    in the least significant bits of the result.
113///
114/// \headerfile <x86intrin.h>
115///
116/// This intrinsic corresponds to the <c> BEXTR </c> instruction.
117///
118/// \param __X
119///    An unsigned integer whose bits are to be extracted.
120/// \param __Y
121///    An unsigned integer used to specify the index of the least significant
122///    bit for the bits to be extracted. Bits [7:0] specify the index.
123/// \param __Z
124///    An unsigned integer used to specify the number of bits to be extracted.
125///    Bits [7:0] specify the number of bits.
126/// \returns An unsigned integer whose least significant bits contain the
127///    extracted bits.
128/// \see __bextr_u32
129static __inline__ unsigned int __DEFAULT_FN_ATTRS
130_bextr_u32(unsigned int __X, unsigned int __Y, unsigned int __Z)
131{
132  return __builtin_ia32_bextr_u32 (__X, ((__Y & 0xff) | ((__Z & 0xff) << 8)));
133}
134
135/// Clears all bits in the source except for the least significant bit
136///    containing a value of 1 and returns the result.
137///
138/// \headerfile <x86intrin.h>
139///
140/// This intrinsic corresponds to the <c> BLSI </c> instruction.
141///
142/// \param __X
143///    An unsigned integer whose bits are to be cleared.
144/// \returns An unsigned integer containing the result of clearing the bits from
145///    the source operand.
146static __inline__ unsigned int __DEFAULT_FN_ATTRS
147__blsi_u32(unsigned int __X)
148{
149  return __X & -__X;
150}
151
152/// Creates a mask whose bits are set to 1, using bit 0 up to and
153///    including the least significant bit that is set to 1 in the source
154///    operand and returns the result.
155///
156/// \headerfile <x86intrin.h>
157///
158/// This intrinsic corresponds to the <c> BLSMSK </c> instruction.
159///
160/// \param __X
161///    An unsigned integer used to create the mask.
162/// \returns An unsigned integer containing the newly created mask.
163static __inline__ unsigned int __DEFAULT_FN_ATTRS
164__blsmsk_u32(unsigned int __X)
165{
166  return __X ^ (__X - 1);
167}
168
169/// Clears the least significant bit that is set to 1 in the source
170///    operand and returns the result.
171///
172/// \headerfile <x86intrin.h>
173///
174/// This intrinsic corresponds to the <c> BLSR </c> instruction.
175///
176/// \param __X
177///    An unsigned integer containing the operand to be cleared.
178/// \returns An unsigned integer containing the result of clearing the source
179///    operand.
180static __inline__ unsigned int __DEFAULT_FN_ATTRS
181__blsr_u32(unsigned int __X)
182{
183  return __X & (__X - 1);
184}
185
186/// Counts the number of trailing zero bits in the operand.
187///
188/// \headerfile <x86intrin.h>
189///
190/// This intrinsic corresponds to the <c> TZCNT </c> instruction.
191///
192/// \param __X
193///    An unsigned 32-bit integer whose trailing zeros are to be counted.
194/// \returns An unsigned 32-bit integer containing the number of trailing zero
195///    bits in the operand.
196static __inline__ unsigned int __RELAXED_FN_ATTRS
197__tzcnt_u32(unsigned int __X)
198{
199  return __builtin_ia32_tzcnt_u32(__X);
200}
201
202/// Counts the number of trailing zero bits in the operand.
203///
204/// \headerfile <x86intrin.h>
205///
206/// This intrinsic corresponds to the <c> TZCNT </c> instruction.
207///
208/// \param __X
209///    An unsigned 32-bit integer whose trailing zeros are to be counted.
210/// \returns An 32-bit integer containing the number of trailing zero bits in
211///    the operand.
212static __inline__ int __RELAXED_FN_ATTRS
213_mm_tzcnt_32(unsigned int __X)
214{
215  return __builtin_ia32_tzcnt_u32(__X);
216}
217
218#ifdef __x86_64__
219
220#define _andn_u64(a, b)   (__andn_u64((a), (b)))
221
222/* _bextr_u64 != __bextr_u64 */
223#define _blsi_u64(a)      (__blsi_u64((a)))
224
225#define _blsmsk_u64(a)    (__blsmsk_u64((a)))
226
227#define _blsr_u64(a)      (__blsr_u64((a)))
228
229#define _tzcnt_u64(a)     (__tzcnt_u64((a)))
230
231/// Performs a bitwise AND of the second operand with the one's
232///    complement of the first operand.
233///
234/// \headerfile <x86intrin.h>
235///
236/// This intrinsic corresponds to the <c> ANDN </c> instruction.
237///
238/// \param __X
239///    An unsigned 64-bit integer containing one of the operands.
240/// \param __Y
241///    An unsigned 64-bit integer containing one of the operands.
242/// \returns An unsigned 64-bit integer containing the bitwise AND of the second
243///    operand with the one's complement of the first operand.
244static __inline__ unsigned long long __DEFAULT_FN_ATTRS
245__andn_u64 (unsigned long long __X, unsigned long long __Y)
246{
247  return ~__X & __Y;
248}
249
250/* AMD-specified, double-leading-underscore version of BEXTR */
251/// Extracts the specified bits from the first operand and returns them
252///    in the least significant bits of the result.
253///
254/// \headerfile <x86intrin.h>
255///
256/// This intrinsic corresponds to the <c> BEXTR </c> instruction.
257///
258/// \param __X
259///    An unsigned 64-bit integer whose bits are to be extracted.
260/// \param __Y
261///    An unsigned 64-bit integer used to specify which bits are extracted. Bits
262///    [7:0] specify the index of the least significant bit. Bits [15:8] specify
263///    the number of bits to be extracted.
264/// \returns An unsigned 64-bit integer whose least significant bits contain the
265///    extracted bits.
266/// \see _bextr_u64
267static __inline__ unsigned long long __DEFAULT_FN_ATTRS
268__bextr_u64(unsigned long long __X, unsigned long long __Y)
269{
270  return __builtin_ia32_bextr_u64(__X, __Y);
271}
272
273/* Intel-specified, single-leading-underscore version of BEXTR */
274/// Extracts the specified bits from the first operand and returns them
275///     in the least significant bits of the result.
276///
277/// \headerfile <x86intrin.h>
278///
279/// This intrinsic corresponds to the <c> BEXTR </c> instruction.
280///
281/// \param __X
282///    An unsigned 64-bit integer whose bits are to be extracted.
283/// \param __Y
284///    An unsigned integer used to specify the index of the least significant
285///    bit for the bits to be extracted. Bits [7:0] specify the index.
286/// \param __Z
287///    An unsigned integer used to specify the number of bits to be extracted.
288///    Bits [7:0] specify the number of bits.
289/// \returns An unsigned 64-bit integer whose least significant bits contain the
290///    extracted bits.
291/// \see __bextr_u64
292static __inline__ unsigned long long __DEFAULT_FN_ATTRS
293_bextr_u64(unsigned long long __X, unsigned int __Y, unsigned int __Z)
294{
295  return __builtin_ia32_bextr_u64 (__X, ((__Y & 0xff) | ((__Z & 0xff) << 8)));
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/// This intrinsic corresponds to the <c> BLSI </c> instruction.
304///
305/// \param __X
306///    An unsigned 64-bit integer whose bits are to be cleared.
307/// \returns An unsigned 64-bit integer containing the result of clearing the
308///    bits from the source operand.
309static __inline__ unsigned long long __DEFAULT_FN_ATTRS
310__blsi_u64(unsigned long long __X)
311{
312  return __X & -__X;
313}
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 </c> instruction.
322///
323/// \param __X
324///    An unsigned 64-bit integer used to create the mask.
325/// \returns An unsigned 64-bit integer containing the newly created mask.
326static __inline__ unsigned long long __DEFAULT_FN_ATTRS
327__blsmsk_u64(unsigned long long __X)
328{
329  return __X ^ (__X - 1);
330}
331
332/// Clears the least significant bit that is set to 1 in the source
333///    operand and returns the result.
334///
335/// \headerfile <x86intrin.h>
336///
337/// This intrinsic corresponds to the <c> BLSR </c> instruction.
338///
339/// \param __X
340///    An unsigned 64-bit integer containing the operand to be cleared.
341/// \returns An unsigned 64-bit integer containing the result of clearing the
342///    source operand.
343static __inline__ unsigned long long __DEFAULT_FN_ATTRS
344__blsr_u64(unsigned long long __X)
345{
346  return __X & (__X - 1);
347}
348
349/// Counts the number of trailing zero bits in the operand.
350///
351/// \headerfile <x86intrin.h>
352///
353/// This intrinsic corresponds to the <c> TZCNT </c> instruction.
354///
355/// \param __X
356///    An unsigned 64-bit integer whose trailing zeros are to be counted.
357/// \returns An unsigned 64-bit integer containing the number of trailing zero
358///    bits in the operand.
359static __inline__ unsigned long long __RELAXED_FN_ATTRS
360__tzcnt_u64(unsigned long long __X)
361{
362  return __builtin_ia32_tzcnt_u64(__X);
363}
364
365/// Counts the number of trailing zero bits in the operand.
366///
367/// \headerfile <x86intrin.h>
368///
369/// This intrinsic corresponds to the <c> TZCNT </c> instruction.
370///
371/// \param __X
372///    An unsigned 64-bit integer whose trailing zeros are to be counted.
373/// \returns An 64-bit integer containing the number of trailing zero bits in
374///    the operand.
375static __inline__ long long __RELAXED_FN_ATTRS
376_mm_tzcnt_64(unsigned long long __X)
377{
378  return __builtin_ia32_tzcnt_u64(__X);
379}
380
381#endif /* __x86_64__ */
382
383#undef __DEFAULT_FN_ATTRS
384#undef __RELAXED_FN_ATTRS
385
386#endif /* __BMIINTRIN_H */
387
CodeThinker, Enjoy your reading code