1/* ===-------- ia32intrin.h ---------------------------------------------------===
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#ifndef __X86INTRIN_H
11#error "Never use <ia32intrin.h> directly; include <x86intrin.h> instead."
12#endif
13
14#ifndef __IA32INTRIN_H
15#define __IA32INTRIN_H
16
17/* Define the default attributes for the functions in this file. */
18#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__))
19#define __DEFAULT_FN_ATTRS_CRC32 __attribute__((__always_inline__, __nodebug__, __target__("crc32")))
20
21#if defined(__cplusplus) && (__cplusplus >= 201103L)
22#define __DEFAULT_FN_ATTRS_CAST __attribute__((__always_inline__)) constexpr
23#define __DEFAULT_FN_ATTRS_CONSTEXPR __DEFAULT_FN_ATTRS constexpr
24#else
25#define __DEFAULT_FN_ATTRS_CAST __attribute__((__always_inline__))
26#define __DEFAULT_FN_ATTRS_CONSTEXPR __DEFAULT_FN_ATTRS
27#endif
28
29/// Finds the first set bit starting from the least significant bit. The result
30/// is undefined if the input is 0.
31///
32/// \headerfile <x86intrin.h>
33///
34/// This intrinsic corresponds to the \c BSF instruction or the
35/// \c TZCNT instruction.
36///
37/// \param __A
38/// A 32-bit integer operand.
39/// \returns A 32-bit integer containing the bit number.
40/// \see _bit_scan_forward
41static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
42__bsfd(int __A) {
43 return __builtin_ctz((unsigned int)__A);
44}
45
46/// Finds the first set bit starting from the most significant bit. The result
47/// is undefined if the input is 0.
48///
49/// \headerfile <x86intrin.h>
50///
51/// This intrinsic corresponds to the \c BSR instruction or the
52/// \c LZCNT instruction and an \c XOR.
53///
54/// \param __A
55/// A 32-bit integer operand.
56/// \returns A 32-bit integer containing the bit number.
57/// \see _bit_scan_reverse
58static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
59__bsrd(int __A) {
60 return 31 - __builtin_clz((unsigned int)__A);
61}
62
63/// Swaps the bytes in the input, converting little endian to big endian or
64/// vice versa.
65///
66/// \headerfile <x86intrin.h>
67///
68/// This intrinsic corresponds to the \c BSWAP instruction.
69///
70/// \param __A
71/// A 32-bit integer operand.
72/// \returns A 32-bit integer containing the swapped bytes.
73static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
74__bswapd(int __A) {
75 return (int)__builtin_bswap32((unsigned int)__A);
76}
77
78/// Swaps the bytes in the input, converting little endian to big endian or
79/// vice versa.
80///
81/// \headerfile <x86intrin.h>
82///
83/// This intrinsic corresponds to the \c BSWAP instruction.
84///
85/// \param __A
86/// A 32-bit integer operand.
87/// \returns A 32-bit integer containing the swapped bytes.
88static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
89_bswap(int __A) {
90 return (int)__builtin_bswap32((unsigned int)__A);
91}
92
93/// Finds the first set bit starting from the least significant bit. The result
94/// is undefined if the input is 0.
95///
96/// \headerfile <x86intrin.h>
97///
98/// \code
99/// int _bit_scan_forward(int A);
100/// \endcode
101///
102/// This intrinsic corresponds to the \c BSF instruction or the
103/// \c TZCNT instruction.
104///
105/// \param A
106/// A 32-bit integer operand.
107/// \returns A 32-bit integer containing the bit number.
108/// \see __bsfd
109#define _bit_scan_forward(A) __bsfd((A))
110
111/// Finds the first set bit starting from the most significant bit. The result
112/// is undefined if the input is 0.
113///
114/// \headerfile <x86intrin.h>
115///
116/// \code
117/// int _bit_scan_reverse(int A);
118/// \endcode
119///
120/// This intrinsic corresponds to the \c BSR instruction or the
121/// \c LZCNT instruction and an \c XOR.
122///
123/// \param A
124/// A 32-bit integer operand.
125/// \returns A 32-bit integer containing the bit number.
126/// \see __bsrd
127#define _bit_scan_reverse(A) __bsrd((A))
128
129#ifdef __x86_64__
130/// Finds the first set bit starting from the least significant bit. The result
131/// is undefined if the input is 0.
132///
133/// \headerfile <x86intrin.h>
134///
135/// This intrinsic corresponds to the \c BSF instruction or the
136/// \c TZCNT instruction.
137///
138/// \param __A
139/// A 64-bit integer operand.
140/// \returns A 32-bit integer containing the bit number.
141static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
142__bsfq(long long __A) {
143 return (long long)__builtin_ctzll((unsigned long long)__A);
144}
145
146/// Finds the first set bit starting from the most significant bit. The result
147/// is undefined if input is 0.
148///
149/// \headerfile <x86intrin.h>
150///
151/// This intrinsic corresponds to the \c BSR instruction or the
152/// \c LZCNT instruction and an \c XOR.
153///
154/// \param __A
155/// A 64-bit integer operand.
156/// \returns A 32-bit integer containing the bit number.
157static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
158__bsrq(long long __A) {
159 return 63 - __builtin_clzll((unsigned long long)__A);
160}
161
162/// Swaps the bytes in the input, converting little endian to big endian or
163/// vice versa.
164///
165/// \headerfile <x86intrin.h>
166///
167/// This intrinsic corresponds to the \c BSWAP instruction.
168///
169/// \param __A
170/// A 64-bit integer operand.
171/// \returns A 64-bit integer containing the swapped bytes.
172/// \see _bswap64
173static __inline__ long long __DEFAULT_FN_ATTRS_CONSTEXPR
174__bswapq(long long __A) {
175 return (long long)__builtin_bswap64((unsigned long long)__A);
176}
177
178/// Swaps the bytes in the input, converting little endian to big endian or
179/// vice versa.
180///
181/// \headerfile <x86intrin.h>
182///
183/// \code
184/// long long _bswap64(long long A);
185/// \endcode
186///
187/// This intrinsic corresponds to the \c BSWAP instruction.
188///
189/// \param A
190/// A 64-bit integer operand.
191/// \returns A 64-bit integer containing the swapped bytes.
192/// \see __bswapq
193#define _bswap64(A) __bswapq((A))
194#endif /* __x86_64__ */
195
196/// Counts the number of bits in the source operand having a value of 1.
197///
198/// \headerfile <x86intrin.h>
199///
200/// This intrinsic corresponds to the \c POPCNT instruction or a
201/// sequence of arithmetic and logic operations to calculate it.
202///
203/// \param __A
204/// An unsigned 32-bit integer operand.
205/// \returns A 32-bit integer containing the number of bits with value 1 in the
206/// source operand.
207/// \see _popcnt32
208static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
209__popcntd(unsigned int __A)
210{
211 return __builtin_popcount(__A);
212}
213
214/// Counts the number of bits in the source operand having a value of 1.
215///
216/// \headerfile <x86intrin.h>
217///
218/// \code
219/// int _popcnt32(int A);
220/// \endcode
221///
222/// This intrinsic corresponds to the \c POPCNT instruction or a
223/// sequence of arithmetic and logic operations to calculate it.
224///
225/// \param A
226/// An unsigned 32-bit integer operand.
227/// \returns A 32-bit integer containing the number of bits with value 1 in the
228/// source operand.
229/// \see __popcntd
230#define _popcnt32(A) __popcntd((A))
231
232#ifdef __x86_64__
233/// Counts the number of bits in the source operand having a value of 1.
234///
235/// \headerfile <x86intrin.h>
236///
237/// This intrinsic corresponds to the \c POPCNT instruction or a
238/// sequence of arithmetic and logic operations to calculate it.
239///
240/// \param __A
241/// An unsigned 64-bit integer operand.
242/// \returns A 64-bit integer containing the number of bits with value 1 in the
243/// source operand.
244/// \see _popcnt64
245static __inline__ long long __DEFAULT_FN_ATTRS_CONSTEXPR
246__popcntq(unsigned long long __A)
247{
248 return __builtin_popcountll(__A);
249}
250
251/// Counts the number of bits in the source operand having a value of 1.
252///
253/// \headerfile <x86intrin.h>
254///
255/// \code
256/// long long _popcnt64(unsigned long long A);
257/// \endcode
258///
259/// This intrinsic corresponds to the \c POPCNT instruction or a
260/// sequence of arithmetic and logic operations to calculate it.
261///
262/// \param A
263/// An unsigned 64-bit integer operand.
264/// \returns A 64-bit integer containing the number of bits with value 1 in the
265/// source operand.
266/// \see __popcntq
267#define _popcnt64(A) __popcntq((A))
268#endif /* __x86_64__ */
269
270#ifdef __x86_64__
271/// Returns the program status-and-control \c RFLAGS register with the \c VM
272/// and \c RF flags cleared.
273///
274/// \headerfile <x86intrin.h>
275///
276/// This intrinsic corresponds to the \c PUSHFQ + \c POP instruction sequence.
277///
278/// \returns The 64-bit value of the RFLAGS register.
279static __inline__ unsigned long long __DEFAULT_FN_ATTRS
280__readeflags(void)
281{
282 return __builtin_ia32_readeflags_u64();
283}
284
285/// Writes the specified value to the program status-and-control \c RFLAGS
286/// register. Reserved bits are not affected.
287///
288/// \headerfile <x86intrin.h>
289///
290/// This intrinsic corresponds to the \c PUSH + \c POPFQ instruction sequence.
291///
292/// \param __f
293/// The 64-bit value to write to \c RFLAGS.
294static __inline__ void __DEFAULT_FN_ATTRS
295__writeeflags(unsigned long long __f)
296{
297 __builtin_ia32_writeeflags_u64(__f);
298}
299
300#else /* !__x86_64__ */
301/// Returns the program status-and-control \c EFLAGS register with the \c VM
302/// and \c RF flags cleared.
303///
304/// \headerfile <x86intrin.h>
305///
306/// This intrinsic corresponds to the \c PUSHFD + \c POP instruction sequence.
307///
308/// \returns The 32-bit value of the EFLAGS register.
309static __inline__ unsigned int __DEFAULT_FN_ATTRS
310__readeflags(void)
311{
312 return __builtin_ia32_readeflags_u32();
313}
314
315/// Writes the specified value to the program status-and-control \c EFLAGS
316/// register. Reserved bits are not affected.
317///
318/// \headerfile <x86intrin.h>
319///
320/// This intrinsic corresponds to the \c PUSH + \c POPFD instruction sequence.
321///
322/// \param __f
323/// The 32-bit value to write to \c EFLAGS.
324static __inline__ void __DEFAULT_FN_ATTRS
325__writeeflags(unsigned int __f)
326{
327 __builtin_ia32_writeeflags_u32(__f);
328}
329#endif /* !__x86_64__ */
330
331/// Casts a 32-bit float value to a 32-bit unsigned integer value.
332///
333/// \headerfile <x86intrin.h>
334///
335/// This intrinsic corresponds to the \c VMOVD / \c MOVD instruction in x86_64,
336/// and corresponds to the \c VMOVL / \c MOVL instruction in ia32.
337///
338/// \param __A
339/// A 32-bit float value.
340/// \returns A 32-bit unsigned integer containing the converted value.
341static __inline__ unsigned int __DEFAULT_FN_ATTRS_CAST
342_castf32_u32(float __A) {
343 return __builtin_bit_cast(unsigned int, __A);
344}
345
346/// Casts a 64-bit float value to a 64-bit unsigned integer value.
347///
348/// \headerfile <x86intrin.h>
349///
350/// This intrinsic corresponds to the \c VMOVQ / \c MOVQ instruction in x86_64,
351/// and corresponds to the \c VMOVL / \c MOVL instruction in ia32.
352///
353/// \param __A
354/// A 64-bit float value.
355/// \returns A 64-bit unsigned integer containing the converted value.
356static __inline__ unsigned long long __DEFAULT_FN_ATTRS_CAST
357_castf64_u64(double __A) {
358 return __builtin_bit_cast(unsigned long long, __A);
359}
360
361/// Casts a 32-bit unsigned integer value to a 32-bit float value.
362///
363/// \headerfile <x86intrin.h>
364///
365/// This intrinsic corresponds to the \c VMOVQ / \c MOVQ instruction in x86_64,
366/// and corresponds to the \c FLDS instruction in ia32.
367///
368/// \param __A
369/// A 32-bit unsigned integer value.
370/// \returns A 32-bit float value containing the converted value.
371static __inline__ float __DEFAULT_FN_ATTRS_CAST
372_castu32_f32(unsigned int __A) {
373 return __builtin_bit_cast(float, __A);
374}
375
376/// Casts a 64-bit unsigned integer value to a 64-bit float value.
377///
378/// \headerfile <x86intrin.h>
379///
380/// This intrinsic corresponds to the \c VMOVQ / \c MOVQ instruction in x86_64,
381/// and corresponds to the \c FLDL instruction in ia32.
382///
383/// \param __A
384/// A 64-bit unsigned integer value.
385/// \returns A 64-bit float value containing the converted value.
386static __inline__ double __DEFAULT_FN_ATTRS_CAST
387_castu64_f64(unsigned long long __A) {
388 return __builtin_bit_cast(double, __A);
389}
390
391/// Adds the unsigned integer operand to the CRC-32C checksum of the
392/// unsigned char operand.
393///
394/// \headerfile <x86intrin.h>
395///
396/// This intrinsic corresponds to the \c CRC32B instruction.
397///
398/// \param __C
399/// An unsigned integer operand to add to the CRC-32C checksum of operand
400/// \a __D.
401/// \param __D
402/// An unsigned 8-bit integer operand used to compute the CRC-32C checksum.
403/// \returns The result of adding operand \a __C to the CRC-32C checksum of
404/// operand \a __D.
405static __inline__ unsigned int __DEFAULT_FN_ATTRS_CRC32
406__crc32b(unsigned int __C, unsigned char __D)
407{
408 return __builtin_ia32_crc32qi(__C, __D);
409}
410
411/// Adds the unsigned integer operand to the CRC-32C checksum of the
412/// unsigned short operand.
413///
414/// \headerfile <x86intrin.h>
415///
416/// This intrinsic corresponds to the \c CRC32W instruction.
417///
418/// \param __C
419/// An unsigned integer operand to add to the CRC-32C checksum of operand
420/// \a __D.
421/// \param __D
422/// An unsigned 16-bit integer operand used to compute the CRC-32C checksum.
423/// \returns The result of adding operand \a __C to the CRC-32C checksum of
424/// operand \a __D.
425static __inline__ unsigned int __DEFAULT_FN_ATTRS_CRC32
426__crc32w(unsigned int __C, unsigned short __D)
427{
428 return __builtin_ia32_crc32hi(__C, __D);
429}
430
431/// Adds the unsigned integer operand to the CRC-32C checksum of the
432/// second unsigned integer operand.
433///
434/// \headerfile <x86intrin.h>
435///
436/// This intrinsic corresponds to the \c CRC32D instruction.
437///
438/// \param __C
439/// An unsigned integer operand to add to the CRC-32C checksum of operand
440/// \a __D.
441/// \param __D
442/// An unsigned 32-bit integer operand used to compute the CRC-32C checksum.
443/// \returns The result of adding operand \a __C to the CRC-32C checksum of
444/// operand \a __D.
445static __inline__ unsigned int __DEFAULT_FN_ATTRS_CRC32
446__crc32d(unsigned int __C, unsigned int __D)
447{
448 return __builtin_ia32_crc32si(__C, __D);
449}
450
451#ifdef __x86_64__
452/// Adds the unsigned integer operand to the CRC-32C checksum of the
453/// unsigned 64-bit integer operand.
454///
455/// \headerfile <x86intrin.h>
456///
457/// This intrinsic corresponds to the \c CRC32Q instruction.
458///
459/// \param __C
460/// An unsigned integer operand to add to the CRC-32C checksum of operand
461/// \a __D.
462/// \param __D
463/// An unsigned 64-bit integer operand used to compute the CRC-32C checksum.
464/// \returns The result of adding operand \a __C to the CRC-32C checksum of
465/// operand \a __D.
466static __inline__ unsigned long long __DEFAULT_FN_ATTRS_CRC32
467__crc32q(unsigned long long __C, unsigned long long __D)
468{
469 return __builtin_ia32_crc32di(__C, __D);
470}
471#endif /* __x86_64__ */
472
473/// Reads the specified performance-monitoring counter. Refer to your
474/// processor's documentation to determine which performance counters are
475/// supported.
476///
477/// \headerfile <x86intrin.h>
478///
479/// This intrinsic corresponds to the \c RDPMC instruction.
480///
481/// \param __A
482/// The performance counter to read.
483/// \returns The 64-bit value read from the performance counter.
484/// \see _rdpmc
485static __inline__ unsigned long long __DEFAULT_FN_ATTRS
486__rdpmc(int __A) {
487 return __builtin_ia32_rdpmc(__A);
488}
489
490/// Reads the processor's time-stamp counter and the \c IA32_TSC_AUX MSR
491/// \c (0xc0000103).
492///
493/// \headerfile <x86intrin.h>
494///
495/// This intrinsic corresponds to the \c RDTSCP instruction.
496///
497/// \param __A
498/// The address of where to store the 32-bit \c IA32_TSC_AUX value.
499/// \returns The 64-bit value of the time-stamp counter.
500static __inline__ unsigned long long __DEFAULT_FN_ATTRS
501__rdtscp(unsigned int *__A) {
502 return __builtin_ia32_rdtscp(__A);
503}
504
505/// Reads the processor's time-stamp counter.
506///
507/// \headerfile <x86intrin.h>
508///
509/// \code
510/// unsigned long long _rdtsc();
511/// \endcode
512///
513/// This intrinsic corresponds to the \c RDTSC instruction.
514///
515/// \returns The 64-bit value of the time-stamp counter.
516#define _rdtsc() __rdtsc()
517
518/// Reads the specified performance monitoring counter. Refer to your
519/// processor's documentation to determine which performance counters are
520/// supported.
521///
522/// \headerfile <x86intrin.h>
523///
524/// \code
525/// unsigned long long _rdpmc(int A);
526/// \endcode
527///
528/// This intrinsic corresponds to the \c RDPMC instruction.
529///
530/// \param A
531/// The performance counter to read.
532/// \returns The 64-bit value read from the performance counter.
533/// \see __rdpmc
534#define _rdpmc(A) __rdpmc(A)
535
536static __inline__ void __DEFAULT_FN_ATTRS
537_wbinvd(void) {
538 __builtin_ia32_wbinvd();
539}
540
541/// Rotates an 8-bit value to the left by the specified number of bits.
542/// This operation is undefined if the number of bits exceeds the size of
543/// the value.
544///
545/// \headerfile <x86intrin.h>
546///
547/// This intrinsic corresponds to the \c ROL instruction.
548///
549/// \param __X
550/// The unsigned 8-bit value to be rotated.
551/// \param __C
552/// The number of bits to rotate the value.
553/// \returns The rotated value.
554static __inline__ unsigned char __DEFAULT_FN_ATTRS_CONSTEXPR
555__rolb(unsigned char __X, int __C) {
556 return __builtin_rotateleft8(__X, __C);
557}
558
559/// Rotates an 8-bit value to the right by the specified number of bits.
560/// This operation is undefined if the number of bits exceeds the size of
561/// the value.
562///
563/// \headerfile <x86intrin.h>
564///
565/// This intrinsic corresponds to the \c ROR instruction.
566///
567/// \param __X
568/// The unsigned 8-bit value to be rotated.
569/// \param __C
570/// The number of bits to rotate the value.
571/// \returns The rotated value.
572static __inline__ unsigned char __DEFAULT_FN_ATTRS_CONSTEXPR
573__rorb(unsigned char __X, int __C) {
574 return __builtin_rotateright8(__X, __C);
575}
576
577/// Rotates a 16-bit value to the left by the specified number of bits.
578/// This operation is undefined if the number of bits exceeds the size of
579/// the value.
580///
581/// \headerfile <x86intrin.h>
582///
583/// This intrinsic corresponds to the \c ROL instruction.
584///
585/// \param __X
586/// The unsigned 16-bit value to be rotated.
587/// \param __C
588/// The number of bits to rotate the value.
589/// \returns The rotated value.
590/// \see _rotwl
591static __inline__ unsigned short __DEFAULT_FN_ATTRS_CONSTEXPR
592__rolw(unsigned short __X, int __C) {
593 return __builtin_rotateleft16(__X, __C);
594}
595
596/// Rotates a 16-bit value to the right by the specified number of bits.
597/// This operation is undefined if the number of bits exceeds the size of
598/// the value.
599///
600/// \headerfile <x86intrin.h>
601///
602/// This intrinsic corresponds to the \c ROR instruction.
603///
604/// \param __X
605/// The unsigned 16-bit value to be rotated.
606/// \param __C
607/// The number of bits to rotate the value.
608/// \returns The rotated value.
609/// \see _rotwr
610static __inline__ unsigned short __DEFAULT_FN_ATTRS_CONSTEXPR
611__rorw(unsigned short __X, int __C) {
612 return __builtin_rotateright16(__X, __C);
613}
614
615/// Rotates a 32-bit value to the left by the specified number of bits.
616/// This operation is undefined if the number of bits exceeds the size of
617/// the value.
618///
619/// \headerfile <x86intrin.h>
620///
621/// This intrinsic corresponds to the \c ROL instruction.
622///
623/// \param __X
624/// The unsigned 32-bit value to be rotated.
625/// \param __C
626/// The number of bits to rotate the value.
627/// \returns The rotated value.
628/// \see _rotl
629static __inline__ unsigned int __DEFAULT_FN_ATTRS_CONSTEXPR
630__rold(unsigned int __X, int __C) {
631 return __builtin_rotateleft32(__X, (unsigned int)__C);
632}
633
634/// Rotates a 32-bit value to the right by the specified number of bits.
635/// This operation is undefined if the number of bits exceeds the size of
636/// the value.
637///
638/// \headerfile <x86intrin.h>
639///
640/// This intrinsic corresponds to the \c ROR instruction.
641///
642/// \param __X
643/// The unsigned 32-bit value to be rotated.
644/// \param __C
645/// The number of bits to rotate the value.
646/// \returns The rotated value.
647/// \see _rotr
648static __inline__ unsigned int __DEFAULT_FN_ATTRS_CONSTEXPR
649__rord(unsigned int __X, int __C) {
650 return __builtin_rotateright32(__X, (unsigned int)__C);
651}
652
653#ifdef __x86_64__
654/// Rotates a 64-bit value to the left by the specified number of bits.
655/// This operation is undefined if the number of bits exceeds the size of
656/// the value.
657///
658/// \headerfile <x86intrin.h>
659///
660/// This intrinsic corresponds to the \c ROL instruction.
661///
662/// \param __X
663/// The unsigned 64-bit value to be rotated.
664/// \param __C
665/// The number of bits to rotate the value.
666/// \returns The rotated value.
667static __inline__ unsigned long long __DEFAULT_FN_ATTRS_CONSTEXPR
668__rolq(unsigned long long __X, int __C) {
669 return __builtin_rotateleft64(__X, (unsigned long long)__C);
670}
671
672/// Rotates a 64-bit value to the right by the specified number of bits.
673/// This operation is undefined if the number of bits exceeds the size of
674/// the value.
675///
676/// \headerfile <x86intrin.h>
677///
678/// This intrinsic corresponds to the \c ROR instruction.
679///
680/// \param __X
681/// The unsigned 64-bit value to be rotated.
682/// \param __C
683/// The number of bits to rotate the value.
684/// \returns The rotated value.
685static __inline__ unsigned long long __DEFAULT_FN_ATTRS_CONSTEXPR
686__rorq(unsigned long long __X, int __C) {
687 return __builtin_rotateright64(__X, (unsigned long long)__C);
688}
689#endif /* __x86_64__ */
690
691#ifndef _MSC_VER
692/* These are already provided as builtins for MSVC. */
693/* Select the correct function based on the size of long. */
694#ifdef __LP64__
695/// Rotates a 64-bit value to the left by the specified number of bits.
696/// This operation is undefined if the number of bits exceeds the size of
697/// the value.
698///
699/// \headerfile <x86intrin.h>
700///
701/// \code
702/// unsigned long long _lrotl(unsigned long long a, int b);
703/// \endcode
704///
705/// This intrinsic corresponds to the \c ROL instruction.
706///
707/// \param a
708/// The unsigned 64-bit value to be rotated.
709/// \param b
710/// The number of bits to rotate the value.
711/// \returns The rotated value.
712/// \see __rolq
713#define _lrotl(a,b) __rolq((a), (b))
714
715/// Rotates a 64-bit value to the right by the specified number of bits.
716/// This operation is undefined if the number of bits exceeds the size of
717/// the value.
718///
719/// \headerfile <x86intrin.h>
720///
721/// \code
722/// unsigned long long _lrotr(unsigned long long a, int b);
723/// \endcode
724///
725/// This intrinsic corresponds to the \c ROR instruction.
726///
727/// \param a
728/// The unsigned 64-bit value to be rotated.
729/// \param b
730/// The number of bits to rotate the value.
731/// \returns The rotated value.
732/// \see __rorq
733#define _lrotr(a,b) __rorq((a), (b))
734#else // __LP64__
735/// Rotates a 32-bit value to the left by the specified number of bits.
736/// This operation is undefined if the number of bits exceeds the size of
737/// the value.
738///
739/// \headerfile <x86intrin.h>
740///
741/// \code
742/// unsigned int _lrotl(unsigned int a, int b);
743/// \endcode
744///
745/// This intrinsic corresponds to the \c ROL instruction.
746///
747/// \param a
748/// The unsigned 32-bit value to be rotated.
749/// \param b
750/// The number of bits to rotate the value.
751/// \returns The rotated value.
752/// \see __rold
753#define _lrotl(a,b) __rold((a), (b))
754
755/// Rotates a 32-bit value to the right by the specified number of bits.
756/// This operation is undefined if the number of bits exceeds the size of
757/// the value.
758///
759/// \headerfile <x86intrin.h>
760///
761/// \code
762/// unsigned int _lrotr(unsigned int a, int b);
763/// \endcode
764///
765/// This intrinsic corresponds to the \c ROR instruction.
766///
767/// \param a
768/// The unsigned 32-bit value to be rotated.
769/// \param b
770/// The number of bits to rotate the value.
771/// \returns The rotated value.
772/// \see __rord
773#define _lrotr(a,b) __rord((a), (b))
774#endif // __LP64__
775
776/// Rotates a 32-bit value to the left by the specified number of bits.
777/// This operation is undefined if the number of bits exceeds the size of
778/// the value.
779///
780/// \headerfile <x86intrin.h>
781///
782/// \code
783/// unsigned int _rotl(unsigned int a, int b);
784/// \endcode
785///
786/// This intrinsic corresponds to the \c ROL instruction.
787///
788/// \param a
789/// The unsigned 32-bit value to be rotated.
790/// \param b
791/// The number of bits to rotate the value.
792/// \returns The rotated value.
793/// \see __rold
794#define _rotl(a,b) __rold((a), (b))
795
796/// Rotates a 32-bit value to the right by the specified number of bits.
797/// This operation is undefined if the number of bits exceeds the size of
798/// the value.
799///
800/// \headerfile <x86intrin.h>
801///
802/// \code
803/// unsigned int _rotr(unsigned int a, int b);
804/// \endcode
805///
806/// This intrinsic corresponds to the \c ROR instruction.
807///
808/// \param a
809/// The unsigned 32-bit value to be rotated.
810/// \param b
811/// The number of bits to rotate the value.
812/// \returns The rotated value.
813/// \see __rord
814#define _rotr(a,b) __rord((a), (b))
815#endif // _MSC_VER
816
817/* These are not builtins so need to be provided in all modes. */
818/// Rotates a 16-bit value to the left by the specified number of bits.
819/// This operation is undefined if the number of bits exceeds the size of
820/// the value.
821///
822/// \headerfile <x86intrin.h>
823///
824/// \code
825/// unsigned short _rotwl(unsigned short a, int b);
826/// \endcode
827///
828/// This intrinsic corresponds to the \c ROL instruction.
829///
830/// \param a
831/// The unsigned 16-bit value to be rotated.
832/// \param b
833/// The number of bits to rotate the value.
834/// \returns The rotated value.
835/// \see __rolw
836#define _rotwl(a,b) __rolw((a), (b))
837
838/// Rotates a 16-bit value to the right by the specified number of bits.
839/// This operation is undefined if the number of bits exceeds the size of
840/// the value.
841///
842/// \headerfile <x86intrin.h>
843///
844/// \code
845/// unsigned short _rotwr(unsigned short a, int b);
846/// \endcode
847///
848/// This intrinsic corresponds to the \c ROR instruction.
849///
850/// \param a
851/// The unsigned 16-bit value to be rotated.
852/// \param b
853/// The number of bits to rotate the value.
854/// \returns The rotated value.
855/// \see __rorw
856#define _rotwr(a,b) __rorw((a), (b))
857
858#undef __DEFAULT_FN_ATTRS
859#undef __DEFAULT_FN_ATTRS_CAST
860#undef __DEFAULT_FN_ATTRS_CRC32
861#undef __DEFAULT_FN_ATTRS_CONSTEXPR
862
863#endif /* __IA32INTRIN_H */