VirtualBox

source: vbox/trunk/include/iprt/asm-amd64-x86.h@ 60491

Last change on this file since 60491 was 60235, checked in by vboxsync, 9 years ago

iprt/asm-amd64-x86.h: doxygen fix
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 73.5 KB
Line 
1/** @file
2 * IPRT - AMD64 and x86 Specific Assembly Functions.
3 */
4
5/*
6 * Copyright (C) 2006-2015 Oracle Corporation
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 *
16 * The contents of this file may alternatively be used under the terms
17 * of the Common Development and Distribution License Version 1.0
18 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19 * VirtualBox OSE distribution, in which case the provisions of the
20 * CDDL are applicable instead of those of the GPL.
21 *
22 * You may elect to license modified versions of this file under the
23 * terms and conditions of either the GPL or the CDDL or both.
24 */
25
26#ifndef ___iprt_asm_amd64_x86_h
27#define ___iprt_asm_amd64_x86_h
28
29#include <iprt/types.h>
30#include <iprt/assert.h>
31#if !defined(RT_ARCH_AMD64) && !defined(RT_ARCH_X86)
32# error "Not on AMD64 or x86"
33#endif
34
35#if defined(_MSC_VER) && RT_INLINE_ASM_USES_INTRIN
36# include <intrin.h>
37 /* Emit the intrinsics at all optimization levels. */
38# pragma intrinsic(_ReadWriteBarrier)
39# pragma intrinsic(__cpuid)
40# pragma intrinsic(_enable)
41# pragma intrinsic(_disable)
42# pragma intrinsic(__rdtsc)
43# pragma intrinsic(__readmsr)
44# pragma intrinsic(__writemsr)
45# pragma intrinsic(__outbyte)
46# pragma intrinsic(__outbytestring)
47# pragma intrinsic(__outword)
48# pragma intrinsic(__outwordstring)
49# pragma intrinsic(__outdword)
50# pragma intrinsic(__outdwordstring)
51# pragma intrinsic(__inbyte)
52# pragma intrinsic(__inbytestring)
53# pragma intrinsic(__inword)
54# pragma intrinsic(__inwordstring)
55# pragma intrinsic(__indword)
56# pragma intrinsic(__indwordstring)
57# pragma intrinsic(__invlpg)
58# pragma intrinsic(__wbinvd)
59# pragma intrinsic(__readcr0)
60# pragma intrinsic(__readcr2)
61# pragma intrinsic(__readcr3)
62# pragma intrinsic(__readcr4)
63# pragma intrinsic(__writecr0)
64# pragma intrinsic(__writecr3)
65# pragma intrinsic(__writecr4)
66# pragma intrinsic(__readdr)
67# pragma intrinsic(__writedr)
68# ifdef RT_ARCH_AMD64
69# pragma intrinsic(__readcr8)
70# pragma intrinsic(__writecr8)
71# endif
72# if RT_INLINE_ASM_USES_INTRIN >= 14
73# pragma intrinsic(__halt)
74# endif
75# if RT_INLINE_ASM_USES_INTRIN >= 15
76# pragma intrinsic(__readeflags)
77# pragma intrinsic(__writeeflags)
78# pragma intrinsic(__rdtscp)
79# endif
80#endif
81
82
83/*
84 * Include #pragma aux definitions for Watcom C/C++.
85 */
86#if defined(__WATCOMC__) && ARCH_BITS == 16
87# include "asm-amd64-x86-watcom-16.h"
88#elif defined(__WATCOMC__) && ARCH_BITS == 32
89# include "asm-amd64-x86-watcom-32.h"
90#endif
91
92
93/** @defgroup grp_rt_asm_amd64_x86 AMD64 and x86 Specific ASM Routines
94 * @ingroup grp_rt_asm
95 * @{
96 */
97
98/** @todo find a more proper place for these structures? */
99
100#pragma pack(1)
101/** IDTR */
102typedef struct RTIDTR
103{
104 /** Size of the IDT. */
105 uint16_t cbIdt;
106 /** Address of the IDT. */
107#if ARCH_BITS != 64
108 uint32_t pIdt;
109#else
110 uint64_t pIdt;
111#endif
112} RTIDTR, *PRTIDTR;
113#pragma pack()
114
115#pragma pack(1)
116/** @internal */
117typedef struct RTIDTRALIGNEDINT
118{
119 /** Alignment padding. */
120 uint16_t au16Padding[ARCH_BITS == 64 ? 3 : 1];
121 /** The IDTR structure. */
122 RTIDTR Idtr;
123} RTIDTRALIGNEDINT;
124#pragma pack()
125
126/** Wrapped RTIDTR for preventing misalignment exceptions. */
127typedef union RTIDTRALIGNED
128{
129 /** Try make sure this structure has optimal alignment. */
130 uint64_t auAlignmentHack[ARCH_BITS == 64 ? 2 : 1];
131 /** Aligned structure. */
132 RTIDTRALIGNEDINT s;
133} RTIDTRALIGNED;
134AssertCompileSize(RTIDTRALIGNED, ((ARCH_BITS == 64) + 1) * 8);
135/** Pointer to a an RTIDTR alignment wrapper. */
136typedef RTIDTRALIGNED *PRIDTRALIGNED;
137
138
139#pragma pack(1)
140/** GDTR */
141typedef struct RTGDTR
142{
143 /** Size of the GDT. */
144 uint16_t cbGdt;
145 /** Address of the GDT. */
146#if ARCH_BITS != 64
147 uint32_t pGdt;
148#else
149 uint64_t pGdt;
150#endif
151} RTGDTR, *PRTGDTR;
152#pragma pack()
153
154#pragma pack(1)
155/** @internal */
156typedef struct RTGDTRALIGNEDINT
157{
158 /** Alignment padding. */
159 uint16_t au16Padding[ARCH_BITS == 64 ? 3 : 1];
160 /** The GDTR structure. */
161 RTGDTR Gdtr;
162} RTGDTRALIGNEDINT;
163#pragma pack()
164
165/** Wrapped RTGDTR for preventing misalignment exceptions. */
166typedef union RTGDTRALIGNED
167{
168 /** Try make sure this structure has optimal alignment. */
169 uint64_t auAlignmentHack[ARCH_BITS == 64 ? 2 : 1];
170 /** Aligned structure. */
171 RTGDTRALIGNEDINT s;
172} RTGDTRALIGNED;
173AssertCompileSize(RTIDTRALIGNED, ((ARCH_BITS == 64) + 1) * 8);
174/** Pointer to a an RTGDTR alignment wrapper. */
175typedef RTGDTRALIGNED *PRGDTRALIGNED;
176
177
178/**
179 * Gets the content of the IDTR CPU register.
180 * @param pIdtr Where to store the IDTR contents.
181 */
182#if RT_INLINE_ASM_EXTERNAL
183DECLASM(void) ASMGetIDTR(PRTIDTR pIdtr);
184#else
185DECLINLINE(void) ASMGetIDTR(PRTIDTR pIdtr)
186{
187# if RT_INLINE_ASM_GNU_STYLE
188 __asm__ __volatile__("sidt %0" : "=m" (*pIdtr));
189# else
190 __asm
191 {
192# ifdef RT_ARCH_AMD64
193 mov rax, [pIdtr]
194 sidt [rax]
195# else
196 mov eax, [pIdtr]
197 sidt [eax]
198# endif
199 }
200# endif
201}
202#endif
203
204
205/**
206 * Gets the content of the IDTR.LIMIT CPU register.
207 * @returns IDTR limit.
208 */
209#if RT_INLINE_ASM_EXTERNAL
210DECLASM(uint16_t) ASMGetIdtrLimit(void);
211#else
212DECLINLINE(uint16_t) ASMGetIdtrLimit(void)
213{
214 RTIDTRALIGNED TmpIdtr;
215# if RT_INLINE_ASM_GNU_STYLE
216 __asm__ __volatile__("sidt %0" : "=m" (TmpIdtr.s.Idtr));
217# else
218 __asm
219 {
220 sidt [TmpIdtr.s.Idtr]
221 }
222# endif
223 return TmpIdtr.s.Idtr.cbIdt;
224}
225#endif
226
227
228/**
229 * Sets the content of the IDTR CPU register.
230 * @param pIdtr Where to load the IDTR contents from
231 */
232#if RT_INLINE_ASM_EXTERNAL
233DECLASM(void) ASMSetIDTR(const RTIDTR *pIdtr);
234#else
235DECLINLINE(void) ASMSetIDTR(const RTIDTR *pIdtr)
236{
237# if RT_INLINE_ASM_GNU_STYLE
238 __asm__ __volatile__("lidt %0" : : "m" (*pIdtr));
239# else
240 __asm
241 {
242# ifdef RT_ARCH_AMD64
243 mov rax, [pIdtr]
244 lidt [rax]
245# else
246 mov eax, [pIdtr]
247 lidt [eax]
248# endif
249 }
250# endif
251}
252#endif
253
254
255/**
256 * Gets the content of the GDTR CPU register.
257 * @param pGdtr Where to store the GDTR contents.
258 */
259#if RT_INLINE_ASM_EXTERNAL
260DECLASM(void) ASMGetGDTR(PRTGDTR pGdtr);
261#else
262DECLINLINE(void) ASMGetGDTR(PRTGDTR pGdtr)
263{
264# if RT_INLINE_ASM_GNU_STYLE
265 __asm__ __volatile__("sgdt %0" : "=m" (*pGdtr));
266# else
267 __asm
268 {
269# ifdef RT_ARCH_AMD64
270 mov rax, [pGdtr]
271 sgdt [rax]
272# else
273 mov eax, [pGdtr]
274 sgdt [eax]
275# endif
276 }
277# endif
278}
279#endif
280
281
282/**
283 * Sets the content of the GDTR CPU register.
284 * @param pGdtr Where to load the GDTR contents from
285 */
286#if RT_INLINE_ASM_EXTERNAL
287DECLASM(void) ASMSetGDTR(const RTGDTR *pGdtr);
288#else
289DECLINLINE(void) ASMSetGDTR(const RTGDTR *pGdtr)
290{
291# if RT_INLINE_ASM_GNU_STYLE
292 __asm__ __volatile__("lgdt %0" : : "m" (*pGdtr));
293# else
294 __asm
295 {
296# ifdef RT_ARCH_AMD64
297 mov rax, [pGdtr]
298 lgdt [rax]
299# else
300 mov eax, [pGdtr]
301 lgdt [eax]
302# endif
303 }
304# endif
305}
306#endif
307
308
309
310/**
311 * Get the cs register.
312 * @returns cs.
313 */
314#if RT_INLINE_ASM_EXTERNAL
315DECLASM(RTSEL) ASMGetCS(void);
316#else
317DECLINLINE(RTSEL) ASMGetCS(void)
318{
319 RTSEL SelCS;
320# if RT_INLINE_ASM_GNU_STYLE
321 __asm__ __volatile__("movw %%cs, %0\n\t" : "=r" (SelCS));
322# else
323 __asm
324 {
325 mov ax, cs
326 mov [SelCS], ax
327 }
328# endif
329 return SelCS;
330}
331#endif
332
333
334/**
335 * Get the DS register.
336 * @returns DS.
337 */
338#if RT_INLINE_ASM_EXTERNAL
339DECLASM(RTSEL) ASMGetDS(void);
340#else
341DECLINLINE(RTSEL) ASMGetDS(void)
342{
343 RTSEL SelDS;
344# if RT_INLINE_ASM_GNU_STYLE
345 __asm__ __volatile__("movw %%ds, %0\n\t" : "=r" (SelDS));
346# else
347 __asm
348 {
349 mov ax, ds
350 mov [SelDS], ax
351 }
352# endif
353 return SelDS;
354}
355#endif
356
357
358/**
359 * Get the ES register.
360 * @returns ES.
361 */
362#if RT_INLINE_ASM_EXTERNAL
363DECLASM(RTSEL) ASMGetES(void);
364#else
365DECLINLINE(RTSEL) ASMGetES(void)
366{
367 RTSEL SelES;
368# if RT_INLINE_ASM_GNU_STYLE
369 __asm__ __volatile__("movw %%es, %0\n\t" : "=r" (SelES));
370# else
371 __asm
372 {
373 mov ax, es
374 mov [SelES], ax
375 }
376# endif
377 return SelES;
378}
379#endif
380
381
382/**
383 * Get the FS register.
384 * @returns FS.
385 */
386#if RT_INLINE_ASM_EXTERNAL
387DECLASM(RTSEL) ASMGetFS(void);
388#else
389DECLINLINE(RTSEL) ASMGetFS(void)
390{
391 RTSEL SelFS;
392# if RT_INLINE_ASM_GNU_STYLE
393 __asm__ __volatile__("movw %%fs, %0\n\t" : "=r" (SelFS));
394# else
395 __asm
396 {
397 mov ax, fs
398 mov [SelFS], ax
399 }
400# endif
401 return SelFS;
402}
403# endif
404
405
406/**
407 * Get the GS register.
408 * @returns GS.
409 */
410#if RT_INLINE_ASM_EXTERNAL
411DECLASM(RTSEL) ASMGetGS(void);
412#else
413DECLINLINE(RTSEL) ASMGetGS(void)
414{
415 RTSEL SelGS;
416# if RT_INLINE_ASM_GNU_STYLE
417 __asm__ __volatile__("movw %%gs, %0\n\t" : "=r" (SelGS));
418# else
419 __asm
420 {
421 mov ax, gs
422 mov [SelGS], ax
423 }
424# endif
425 return SelGS;
426}
427#endif
428
429
430/**
431 * Get the SS register.
432 * @returns SS.
433 */
434#if RT_INLINE_ASM_EXTERNAL
435DECLASM(RTSEL) ASMGetSS(void);
436#else
437DECLINLINE(RTSEL) ASMGetSS(void)
438{
439 RTSEL SelSS;
440# if RT_INLINE_ASM_GNU_STYLE
441 __asm__ __volatile__("movw %%ss, %0\n\t" : "=r" (SelSS));
442# else
443 __asm
444 {
445 mov ax, ss
446 mov [SelSS], ax
447 }
448# endif
449 return SelSS;
450}
451#endif
452
453
454/**
455 * Get the TR register.
456 * @returns TR.
457 */
458#if RT_INLINE_ASM_EXTERNAL
459DECLASM(RTSEL) ASMGetTR(void);
460#else
461DECLINLINE(RTSEL) ASMGetTR(void)
462{
463 RTSEL SelTR;
464# if RT_INLINE_ASM_GNU_STYLE
465 __asm__ __volatile__("str %w0\n\t" : "=r" (SelTR));
466# else
467 __asm
468 {
469 str ax
470 mov [SelTR], ax
471 }
472# endif
473 return SelTR;
474}
475#endif
476
477
478/**
479 * Get the LDTR register.
480 * @returns LDTR.
481 */
482#if RT_INLINE_ASM_EXTERNAL
483DECLASM(RTSEL) ASMGetLDTR(void);
484#else
485DECLINLINE(RTSEL) ASMGetLDTR(void)
486{
487 RTSEL SelLDTR;
488# if RT_INLINE_ASM_GNU_STYLE
489 __asm__ __volatile__("sldt %w0\n\t" : "=r" (SelLDTR));
490# else
491 __asm
492 {
493 sldt ax
494 mov [SelLDTR], ax
495 }
496# endif
497 return SelLDTR;
498}
499#endif
500
501
502/**
503 * Get the access rights for the segment selector.
504 *
505 * @returns The access rights on success or UINT32_MAX on failure.
506 * @param uSel The selector value.
507 *
508 * @remarks Using UINT32_MAX for failure is chosen because valid access rights
509 * always have bits 0:7 as 0 (on both Intel & AMD).
510 */
511#if RT_INLINE_ASM_EXTERNAL
512DECLASM(uint32_t) ASMGetSegAttr(uint32_t uSel);
513#else
514DECLINLINE(uint32_t) ASMGetSegAttr(uint32_t uSel)
515{
516 uint32_t uAttr;
517 /* LAR only accesses 16-bit of the source operand, but eax for the
518 destination operand is required for getting the full 32-bit access rights. */
519# if RT_INLINE_ASM_GNU_STYLE
520 __asm__ __volatile__("lar %1, %%eax\n\t"
521 "jz done%=\n\t"
522 "movl $0xffffffff, %%eax\n\t"
523 "done%=:\n\t"
524 "movl %%eax, %0\n\t"
525 : "=r" (uAttr)
526 : "r" (uSel)
527 : "cc", "%eax");
528# else
529 __asm
530 {
531 lar eax, [uSel]
532 jz done
533 mov eax, 0ffffffffh
534 done:
535 mov [uAttr], eax
536 }
537# endif
538 return uAttr;
539}
540#endif
541
542
543/**
544 * Get the [RE]FLAGS register.
545 * @returns [RE]FLAGS.
546 */
547#if RT_INLINE_ASM_EXTERNAL && RT_INLINE_ASM_USES_INTRIN < 15
548DECLASM(RTCCUINTREG) ASMGetFlags(void);
549#else
550DECLINLINE(RTCCUINTREG) ASMGetFlags(void)
551{
552 RTCCUINTREG uFlags;
553# if RT_INLINE_ASM_GNU_STYLE
554# ifdef RT_ARCH_AMD64
555 __asm__ __volatile__("pushfq\n\t"
556 "popq %0\n\t"
557 : "=r" (uFlags));
558# else
559 __asm__ __volatile__("pushfl\n\t"
560 "popl %0\n\t"
561 : "=r" (uFlags));
562# endif
563# elif RT_INLINE_ASM_USES_INTRIN >= 15
564 uFlags = __readeflags();
565# else
566 __asm
567 {
568# ifdef RT_ARCH_AMD64
569 pushfq
570 pop [uFlags]
571# else
572 pushfd
573 pop [uFlags]
574# endif
575 }
576# endif
577 return uFlags;
578}
579#endif
580
581
582/**
583 * Set the [RE]FLAGS register.
584 * @param uFlags The new [RE]FLAGS value.
585 */
586#if RT_INLINE_ASM_EXTERNAL && RT_INLINE_ASM_USES_INTRIN < 15
587DECLASM(void) ASMSetFlags(RTCCUINTREG uFlags);
588#else
589DECLINLINE(void) ASMSetFlags(RTCCUINTREG uFlags)
590{
591# if RT_INLINE_ASM_GNU_STYLE
592# ifdef RT_ARCH_AMD64
593 __asm__ __volatile__("pushq %0\n\t"
594 "popfq\n\t"
595 : : "g" (uFlags));
596# else
597 __asm__ __volatile__("pushl %0\n\t"
598 "popfl\n\t"
599 : : "g" (uFlags));
600# endif
601# elif RT_INLINE_ASM_USES_INTRIN >= 15
602 __writeeflags(uFlags);
603# else
604 __asm
605 {
606# ifdef RT_ARCH_AMD64
607 push [uFlags]
608 popfq
609# else
610 push [uFlags]
611 popfd
612# endif
613 }
614# endif
615}
616#endif
617
618
619/**
620 * Modifies the [RE]FLAGS register.
621 * @returns Original value.
622 * @param fAndEfl Flags to keep (applied first).
623 * @param fOrEfl Flags to be set.
624 */
625#if RT_INLINE_ASM_EXTERNAL && RT_INLINE_ASM_USES_INTRIN < 15
626DECLASM(RTCCUINTREG) ASMChangeFlags(RTCCUINTREG fAndEfl, RTCCUINTREG fOrEfl);
627#else
628DECLINLINE(RTCCUINTREG) ASMChangeFlags(RTCCUINTREG fAndEfl, RTCCUINTREG fOrEfl)
629{
630 RTCCUINTREG fOldEfl;
631# if RT_INLINE_ASM_GNU_STYLE
632# ifdef RT_ARCH_AMD64
633 __asm__ __volatile__("pushfq\n\t"
634 "movq (%%rsp), %0\n\t"
635 "andq %0, %1\n\t"
636 "orq %3, %1\n\t"
637 "mov %1, (%%rsp)\n\t"
638 "popfq\n\t"
639 : "=&r" (fOldEfl),
640 "=r" (fAndEfl)
641 : "1" (fAndEfl),
642 "rn" (fOrEfl) );
643# else
644 __asm__ __volatile__("pushfl\n\t"
645 "movl (%%esp), %0\n\t"
646 "andl %1, (%%esp)\n\t"
647 "orl %2, (%%esp)\n\t"
648 "popfl\n\t"
649 : "=&r" (fOldEfl)
650 : "rn" (fAndEfl),
651 "rn" (fOrEfl) );
652# endif
653# elif RT_INLINE_ASM_USES_INTRIN >= 15
654 fOldEfl = __readeflags();
655 __writeeflags((fOldEfl & fAndEfl) | fOrEfl);
656# else
657 __asm
658 {
659# ifdef RT_ARCH_AMD64
660 mov rdx, [fAndEfl]
661 mov rcx, [fOrEfl]
662 pushfq
663 mov rax, [rsp]
664 and rdx, rax
665 or rdx, rcx
666 mov [rsp], rdx
667 popfq
668 mov [fOldEfl], rax
669# else
670 mov edx, [fAndEfl]
671 mov ecx, [fOrEfl]
672 pushfd
673 mov eax, [esp]
674 and edx, eax
675 or edx, ecx
676 mov [esp], edx
677 popfd
678 mov [fOldEfl], eax
679# endif
680 }
681# endif
682 return fOldEfl;
683}
684#endif
685
686
687/**
688 * Modifies the [RE]FLAGS register by ORing in one or more flags.
689 * @returns Original value.
690 * @param fOrEfl The flags to be set (ORed in).
691 */
692#if RT_INLINE_ASM_EXTERNAL && RT_INLINE_ASM_USES_INTRIN < 15
693DECLASM(RTCCUINTREG) ASMAddFlags(RTCCUINTREG fOrEfl);
694#else
695DECLINLINE(RTCCUINTREG) ASMAddFlags(RTCCUINTREG fOrEfl)
696{
697 RTCCUINTREG fOldEfl;
698# if RT_INLINE_ASM_GNU_STYLE
699# ifdef RT_ARCH_AMD64
700 __asm__ __volatile__("pushfq\n\t"
701 "movq (%%rsp), %0\n\t"
702 "orq %1, (%%rsp)\n\t"
703 "popfq\n\t"
704 : "=&r" (fOldEfl)
705 : "rn" (fOrEfl) );
706# else
707 __asm__ __volatile__("pushfl\n\t"
708 "movl (%%esp), %0\n\t"
709 "orl %1, (%%esp)\n\t"
710 "popfl\n\t"
711 : "=&r" (fOldEfl)
712 : "rn" (fOrEfl) );
713# endif
714# elif RT_INLINE_ASM_USES_INTRIN >= 15
715 fOldEfl = __readeflags();
716 __writeeflags(fOldEfl | fOrEfl);
717# else
718 __asm
719 {
720# ifdef RT_ARCH_AMD64
721 mov rcx, [fOrEfl]
722 pushfq
723 mov rdx, [rsp]
724 or [rsp], rcx
725 popfq
726 mov [fOldEfl], rax
727# else
728 mov ecx, [fOrEfl]
729 pushfd
730 mov edx, [esp]
731 or [esp], ecx
732 popfd
733 mov [fOldEfl], eax
734# endif
735 }
736# endif
737 return fOldEfl;
738}
739#endif
740
741
742/**
743 * Modifies the [RE]FLAGS register by AND'ing out one or more flags.
744 * @returns Original value.
745 * @param fAndEfl The flags to keep.
746 */
747#if RT_INLINE_ASM_EXTERNAL && RT_INLINE_ASM_USES_INTRIN < 15
748DECLASM(RTCCUINTREG) ASMClearFlags(RTCCUINTREG fAndEfl);
749#else
750DECLINLINE(RTCCUINTREG) ASMClearFlags(RTCCUINTREG fAndEfl)
751{
752 RTCCUINTREG fOldEfl;
753# if RT_INLINE_ASM_GNU_STYLE
754# ifdef RT_ARCH_AMD64
755 __asm__ __volatile__("pushfq\n\t"
756 "movq (%%rsp), %0\n\t"
757 "andq %1, (%%rsp)\n\t"
758 "popfq\n\t"
759 : "=&r" (fOldEfl)
760 : "rn" (fAndEfl) );
761# else
762 __asm__ __volatile__("pushfl\n\t"
763 "movl (%%esp), %0\n\t"
764 "andl %1, (%%esp)\n\t"
765 "popfl\n\t"
766 : "=&r" (fOldEfl)
767 : "rn" (fAndEfl) );
768# endif
769# elif RT_INLINE_ASM_USES_INTRIN >= 15
770 fOldEfl = __readeflags();
771 __writeeflags(fOldEfl & fAndEfl);
772# else
773 __asm
774 {
775# ifdef RT_ARCH_AMD64
776 mov rdx, [fAndEfl]
777 pushfq
778 mov rdx, [rsp]
779 and [rsp], rdx
780 popfq
781 mov [fOldEfl], rax
782# else
783 mov edx, [fAndEfl]
784 pushfd
785 mov edx, [esp]
786 and [esp], edx
787 popfd
788 mov [fOldEfl], eax
789# endif
790 }
791# endif
792 return fOldEfl;
793}
794#endif
795
796
797/**
798 * Gets the content of the CPU timestamp counter register.
799 *
800 * @returns TSC.
801 */
802#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
803DECLASM(uint64_t) ASMReadTSC(void);
804#else
805DECLINLINE(uint64_t) ASMReadTSC(void)
806{
807 RTUINT64U u;
808# if RT_INLINE_ASM_GNU_STYLE
809 __asm__ __volatile__("rdtsc\n\t" : "=a" (u.s.Lo), "=d" (u.s.Hi));
810# else
811# if RT_INLINE_ASM_USES_INTRIN
812 u.u = __rdtsc();
813# else
814 __asm
815 {
816 rdtsc
817 mov [u.s.Lo], eax
818 mov [u.s.Hi], edx
819 }
820# endif
821# endif
822 return u.u;
823}
824#endif
825
826
827/**
828 * Gets the content of the CPU timestamp counter register and the
829 * assoicated AUX value.
830 *
831 * @returns TSC.
832 * @param puAux Where to store the AUX value.
833 */
834#if RT_INLINE_ASM_EXTERNAL && RT_INLINE_ASM_USES_INTRIN < 15
835DECLASM(uint64_t) ASMReadTscWithAux(uint32_t *puAux);
836#else
837DECLINLINE(uint64_t) ASMReadTscWithAux(uint32_t *puAux)
838{
839 RTUINT64U u;
840# if RT_INLINE_ASM_GNU_STYLE
841 /* rdtscp is not supported by ancient linux build VM of course :-( */
842 /*__asm__ __volatile__("rdtscp\n\t" : "=a" (u.s.Lo), "=d" (u.s.Hi), "=c" (*puAux)); */
843 __asm__ __volatile__(".byte 0x0f,0x01,0xf9\n\t" : "=a" (u.s.Lo), "=d" (u.s.Hi), "=c" (*puAux));
844# else
845# if RT_INLINE_ASM_USES_INTRIN >= 15
846 u.u = __rdtscp(puAux);
847# else
848 __asm
849 {
850 rdtscp
851 mov [u.s.Lo], eax
852 mov [u.s.Hi], edx
853 mov eax, [puAux]
854 mov [eax], ecx
855 }
856# endif
857# endif
858 return u.u;
859}
860#endif
861
862
863/**
864 * Performs the cpuid instruction returning all registers.
865 *
866 * @param uOperator CPUID operation (eax).
867 * @param pvEAX Where to store eax.
868 * @param pvEBX Where to store ebx.
869 * @param pvECX Where to store ecx.
870 * @param pvEDX Where to store edx.
871 * @remark We're using void pointers to ease the use of special bitfield structures and such.
872 */
873#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
874DECLASM(void) ASMCpuId(uint32_t uOperator, void *pvEAX, void *pvEBX, void *pvECX, void *pvEDX);
875#else
876DECLINLINE(void) ASMCpuId(uint32_t uOperator, void *pvEAX, void *pvEBX, void *pvECX, void *pvEDX)
877{
878# if RT_INLINE_ASM_GNU_STYLE
879# ifdef RT_ARCH_AMD64
880 RTCCUINTREG uRAX, uRBX, uRCX, uRDX;
881 __asm__ __volatile__ ("cpuid\n\t"
882 : "=a" (uRAX),
883 "=b" (uRBX),
884 "=c" (uRCX),
885 "=d" (uRDX)
886 : "0" (uOperator), "2" (0));
887 *(uint32_t *)pvEAX = (uint32_t)uRAX;
888 *(uint32_t *)pvEBX = (uint32_t)uRBX;
889 *(uint32_t *)pvECX = (uint32_t)uRCX;
890 *(uint32_t *)pvEDX = (uint32_t)uRDX;
891# else
892 __asm__ __volatile__ ("xchgl %%ebx, %1\n\t"
893 "cpuid\n\t"
894 "xchgl %%ebx, %1\n\t"
895 : "=a" (*(uint32_t *)pvEAX),
896 "=r" (*(uint32_t *)pvEBX),
897 "=c" (*(uint32_t *)pvECX),
898 "=d" (*(uint32_t *)pvEDX)
899 : "0" (uOperator), "2" (0));
900# endif
901
902# elif RT_INLINE_ASM_USES_INTRIN
903 int aInfo[4];
904 __cpuid(aInfo, uOperator);
905 *(uint32_t *)pvEAX = aInfo[0];
906 *(uint32_t *)pvEBX = aInfo[1];
907 *(uint32_t *)pvECX = aInfo[2];
908 *(uint32_t *)pvEDX = aInfo[3];
909
910# else
911 uint32_t uEAX;
912 uint32_t uEBX;
913 uint32_t uECX;
914 uint32_t uEDX;
915 __asm
916 {
917 push ebx
918 mov eax, [uOperator]
919 cpuid
920 mov [uEAX], eax
921 mov [uEBX], ebx
922 mov [uECX], ecx
923 mov [uEDX], edx
924 pop ebx
925 }
926 *(uint32_t *)pvEAX = uEAX;
927 *(uint32_t *)pvEBX = uEBX;
928 *(uint32_t *)pvECX = uECX;
929 *(uint32_t *)pvEDX = uEDX;
930# endif
931}
932#endif
933
934
935/**
936 * Performs the CPUID instruction with EAX and ECX input returning ALL output
937 * registers.
938 *
939 * @param uOperator CPUID operation (eax).
940 * @param uIdxECX ecx index
941 * @param pvEAX Where to store eax.
942 * @param pvEBX Where to store ebx.
943 * @param pvECX Where to store ecx.
944 * @param pvEDX Where to store edx.
945 * @remark We're using void pointers to ease the use of special bitfield structures and such.
946 */
947#if RT_INLINE_ASM_EXTERNAL || RT_INLINE_ASM_USES_INTRIN
948DECLASM(void) ASMCpuId_Idx_ECX(uint32_t uOperator, uint32_t uIdxECX, void *pvEAX, void *pvEBX, void *pvECX, void *pvEDX);
949#else
950DECLINLINE(void) ASMCpuId_Idx_ECX(uint32_t uOperator, uint32_t uIdxECX, void *pvEAX, void *pvEBX, void *pvECX, void *pvEDX)
951{
952# if RT_INLINE_ASM_GNU_STYLE
953# ifdef RT_ARCH_AMD64
954 RTCCUINTREG uRAX, uRBX, uRCX, uRDX;
955 __asm__ ("cpuid\n\t"
956 : "=a" (uRAX),
957 "=b" (uRBX),
958 "=c" (uRCX),
959 "=d" (uRDX)
960 : "0" (uOperator),
961 "2" (uIdxECX));
962 *(uint32_t *)pvEAX = (uint32_t)uRAX;
963 *(uint32_t *)pvEBX = (uint32_t)uRBX;
964 *(uint32_t *)pvECX = (uint32_t)uRCX;
965 *(uint32_t *)pvEDX = (uint32_t)uRDX;
966# else
967 __asm__ ("xchgl %%ebx, %1\n\t"
968 "cpuid\n\t"
969 "xchgl %%ebx, %1\n\t"
970 : "=a" (*(uint32_t *)pvEAX),
971 "=r" (*(uint32_t *)pvEBX),
972 "=c" (*(uint32_t *)pvECX),
973 "=d" (*(uint32_t *)pvEDX)
974 : "0" (uOperator),
975 "2" (uIdxECX));
976# endif
977
978# elif RT_INLINE_ASM_USES_INTRIN
979 int aInfo[4];
980 __cpuidex(aInfo, uOperator, uIdxECX);
981 *(uint32_t *)pvEAX = aInfo[0];
982 *(uint32_t *)pvEBX = aInfo[1];
983 *(uint32_t *)pvECX = aInfo[2];
984 *(uint32_t *)pvEDX = aInfo[3];
985
986# else
987 uint32_t uEAX;
988 uint32_t uEBX;
989 uint32_t uECX;
990 uint32_t uEDX;
991 __asm
992 {
993 push ebx
994 mov eax, [uOperator]
995 mov ecx, [uIdxECX]
996 cpuid
997 mov [uEAX], eax
998 mov [uEBX], ebx
999 mov [uECX], ecx
1000 mov [uEDX], edx
1001 pop ebx
1002 }
1003 *(uint32_t *)pvEAX = uEAX;
1004 *(uint32_t *)pvEBX = uEBX;
1005 *(uint32_t *)pvECX = uECX;
1006 *(uint32_t *)pvEDX = uEDX;
1007# endif
1008}
1009#endif
1010
1011
1012/**
1013 * CPUID variant that initializes all 4 registers before the CPUID instruction.
1014 *
1015 * @returns The EAX result value.
1016 * @param uOperator CPUID operation (eax).
1017 * @param uInitEBX The value to assign EBX prior to the CPUID instruction.
1018 * @param uInitECX The value to assign ECX prior to the CPUID instruction.
1019 * @param uInitEDX The value to assign EDX prior to the CPUID instruction.
1020 * @param pvEAX Where to store eax. Optional.
1021 * @param pvEBX Where to store ebx. Optional.
1022 * @param pvECX Where to store ecx. Optional.
1023 * @param pvEDX Where to store edx. Optional.
1024 */
1025DECLASM(uint32_t) ASMCpuIdExSlow(uint32_t uOperator, uint32_t uInitEBX, uint32_t uInitECX, uint32_t uInitEDX,
1026 void *pvEAX, void *pvEBX, void *pvECX, void *pvEDX);
1027
1028
1029/**
1030 * Performs the cpuid instruction returning ecx and edx.
1031 *
1032 * @param uOperator CPUID operation (eax).
1033 * @param pvECX Where to store ecx.
1034 * @param pvEDX Where to store edx.
1035 * @remark We're using void pointers to ease the use of special bitfield structures and such.
1036 */
1037#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
1038DECLASM(void) ASMCpuId_ECX_EDX(uint32_t uOperator, void *pvECX, void *pvEDX);
1039#else
1040DECLINLINE(void) ASMCpuId_ECX_EDX(uint32_t uOperator, void *pvECX, void *pvEDX)
1041{
1042 uint32_t uEBX;
1043 ASMCpuId(uOperator, &uOperator, &uEBX, pvECX, pvEDX);
1044}
1045#endif
1046
1047
1048/**
1049 * Performs the cpuid instruction returning eax.
1050 *
1051 * @param uOperator CPUID operation (eax).
1052 * @returns EAX after cpuid operation.
1053 */
1054#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
1055DECLASM(uint32_t) ASMCpuId_EAX(uint32_t uOperator);
1056#else
1057DECLINLINE(uint32_t) ASMCpuId_EAX(uint32_t uOperator)
1058{
1059 RTCCUINTREG xAX;
1060# if RT_INLINE_ASM_GNU_STYLE
1061# ifdef RT_ARCH_AMD64
1062 __asm__ ("cpuid"
1063 : "=a" (xAX)
1064 : "0" (uOperator)
1065 : "rbx", "rcx", "rdx");
1066# elif (defined(PIC) || defined(__PIC__)) && defined(__i386__)
1067 __asm__ ("push %%ebx\n\t"
1068 "cpuid\n\t"
1069 "pop %%ebx\n\t"
1070 : "=a" (xAX)
1071 : "0" (uOperator)
1072 : "ecx", "edx");
1073# else
1074 __asm__ ("cpuid"
1075 : "=a" (xAX)
1076 : "0" (uOperator)
1077 : "edx", "ecx", "ebx");
1078# endif
1079
1080# elif RT_INLINE_ASM_USES_INTRIN
1081 int aInfo[4];
1082 __cpuid(aInfo, uOperator);
1083 xAX = aInfo[0];
1084
1085# else
1086 __asm
1087 {
1088 push ebx
1089 mov eax, [uOperator]
1090 cpuid
1091 mov [xAX], eax
1092 pop ebx
1093 }
1094# endif
1095 return (uint32_t)xAX;
1096}
1097#endif
1098
1099
1100/**
1101 * Performs the cpuid instruction returning ebx.
1102 *
1103 * @param uOperator CPUID operation (eax).
1104 * @returns EBX after cpuid operation.
1105 */
1106#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
1107DECLASM(uint32_t) ASMCpuId_EBX(uint32_t uOperator);
1108#else
1109DECLINLINE(uint32_t) ASMCpuId_EBX(uint32_t uOperator)
1110{
1111 RTCCUINTREG xBX;
1112# if RT_INLINE_ASM_GNU_STYLE
1113# ifdef RT_ARCH_AMD64
1114 RTCCUINTREG uSpill;
1115 __asm__ ("cpuid"
1116 : "=a" (uSpill),
1117 "=b" (xBX)
1118 : "0" (uOperator)
1119 : "rdx", "rcx");
1120# elif (defined(PIC) || defined(__PIC__)) && defined(__i386__)
1121 __asm__ ("push %%ebx\n\t"
1122 "cpuid\n\t"
1123 "mov %%ebx, %%edx\n\t"
1124 "pop %%ebx\n\t"
1125 : "=a" (uOperator),
1126 "=d" (xBX)
1127 : "0" (uOperator)
1128 : "ecx");
1129# else
1130 __asm__ ("cpuid"
1131 : "=a" (uOperator),
1132 "=b" (xBX)
1133 : "0" (uOperator)
1134 : "edx", "ecx");
1135# endif
1136
1137# elif RT_INLINE_ASM_USES_INTRIN
1138 int aInfo[4];
1139 __cpuid(aInfo, uOperator);
1140 xBX = aInfo[1];
1141
1142# else
1143 __asm
1144 {
1145 push ebx
1146 mov eax, [uOperator]
1147 cpuid
1148 mov [xBX], ebx
1149 pop ebx
1150 }
1151# endif
1152 return (uint32_t)xBX;
1153}
1154#endif
1155
1156
1157/**
1158 * Performs the cpuid instruction returning ecx.
1159 *
1160 * @param uOperator CPUID operation (eax).
1161 * @returns ECX after cpuid operation.
1162 */
1163#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
1164DECLASM(uint32_t) ASMCpuId_ECX(uint32_t uOperator);
1165#else
1166DECLINLINE(uint32_t) ASMCpuId_ECX(uint32_t uOperator)
1167{
1168 RTCCUINTREG xCX;
1169# if RT_INLINE_ASM_GNU_STYLE
1170# ifdef RT_ARCH_AMD64
1171 RTCCUINTREG uSpill;
1172 __asm__ ("cpuid"
1173 : "=a" (uSpill),
1174 "=c" (xCX)
1175 : "0" (uOperator)
1176 : "rbx", "rdx");
1177# elif (defined(PIC) || defined(__PIC__)) && defined(__i386__)
1178 __asm__ ("push %%ebx\n\t"
1179 "cpuid\n\t"
1180 "pop %%ebx\n\t"
1181 : "=a" (uOperator),
1182 "=c" (xCX)
1183 : "0" (uOperator)
1184 : "edx");
1185# else
1186 __asm__ ("cpuid"
1187 : "=a" (uOperator),
1188 "=c" (xCX)
1189 : "0" (uOperator)
1190 : "ebx", "edx");
1191
1192# endif
1193
1194# elif RT_INLINE_ASM_USES_INTRIN
1195 int aInfo[4];
1196 __cpuid(aInfo, uOperator);
1197 xCX = aInfo[2];
1198
1199# else
1200 __asm
1201 {
1202 push ebx
1203 mov eax, [uOperator]
1204 cpuid
1205 mov [xCX], ecx
1206 pop ebx
1207 }
1208# endif
1209 return (uint32_t)xCX;
1210}
1211#endif
1212
1213
1214/**
1215 * Performs the cpuid instruction returning edx.
1216 *
1217 * @param uOperator CPUID operation (eax).
1218 * @returns EDX after cpuid operation.
1219 */
1220#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
1221DECLASM(uint32_t) ASMCpuId_EDX(uint32_t uOperator);
1222#else
1223DECLINLINE(uint32_t) ASMCpuId_EDX(uint32_t uOperator)
1224{
1225 RTCCUINTREG xDX;
1226# if RT_INLINE_ASM_GNU_STYLE
1227# ifdef RT_ARCH_AMD64
1228 RTCCUINTREG uSpill;
1229 __asm__ ("cpuid"
1230 : "=a" (uSpill),
1231 "=d" (xDX)
1232 : "0" (uOperator)
1233 : "rbx", "rcx");
1234# elif (defined(PIC) || defined(__PIC__)) && defined(__i386__)
1235 __asm__ ("push %%ebx\n\t"
1236 "cpuid\n\t"
1237 "pop %%ebx\n\t"
1238 : "=a" (uOperator),
1239 "=d" (xDX)
1240 : "0" (uOperator)
1241 : "ecx");
1242# else
1243 __asm__ ("cpuid"
1244 : "=a" (uOperator),
1245 "=d" (xDX)
1246 : "0" (uOperator)
1247 : "ebx", "ecx");
1248# endif
1249
1250# elif RT_INLINE_ASM_USES_INTRIN
1251 int aInfo[4];
1252 __cpuid(aInfo, uOperator);
1253 xDX = aInfo[3];
1254
1255# else
1256 __asm
1257 {
1258 push ebx
1259 mov eax, [uOperator]
1260 cpuid
1261 mov [xDX], edx
1262 pop ebx
1263 }
1264# endif
1265 return (uint32_t)xDX;
1266}
1267#endif
1268
1269
1270/**
1271 * Checks if the current CPU supports CPUID.
1272 *
1273 * @returns true if CPUID is supported.
1274 */
1275#ifdef __WATCOMC__
1276DECLASM(bool) ASMHasCpuId(void);
1277#else
1278DECLINLINE(bool) ASMHasCpuId(void)
1279{
1280# ifdef RT_ARCH_AMD64
1281 return true; /* ASSUME that all amd64 compatible CPUs have cpuid. */
1282# else /* !RT_ARCH_AMD64 */
1283 bool fRet = false;
1284# if RT_INLINE_ASM_GNU_STYLE
1285 uint32_t u1;
1286 uint32_t u2;
1287 __asm__ ("pushf\n\t"
1288 "pop %1\n\t"
1289 "mov %1, %2\n\t"
1290 "xorl $0x200000, %1\n\t"
1291 "push %1\n\t"
1292 "popf\n\t"
1293 "pushf\n\t"
1294 "pop %1\n\t"
1295 "cmpl %1, %2\n\t"
1296 "setne %0\n\t"
1297 "push %2\n\t"
1298 "popf\n\t"
1299 : "=m" (fRet), "=r" (u1), "=r" (u2));
1300# else
1301 __asm
1302 {
1303 pushfd
1304 pop eax
1305 mov ebx, eax
1306 xor eax, 0200000h
1307 push eax
1308 popfd
1309 pushfd
1310 pop eax
1311 cmp eax, ebx
1312 setne fRet
1313 push ebx
1314 popfd
1315 }
1316# endif
1317 return fRet;
1318# endif /* !RT_ARCH_AMD64 */
1319}
1320#endif
1321
1322
1323/**
1324 * Gets the APIC ID of the current CPU.
1325 *
1326 * @returns the APIC ID.
1327 */
1328#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
1329DECLASM(uint8_t) ASMGetApicId(void);
1330#else
1331DECLINLINE(uint8_t) ASMGetApicId(void)
1332{
1333 RTCCUINTREG xBX;
1334# if RT_INLINE_ASM_GNU_STYLE
1335# ifdef RT_ARCH_AMD64
1336 RTCCUINTREG uSpill;
1337 __asm__ __volatile__ ("cpuid"
1338 : "=a" (uSpill),
1339 "=b" (xBX)
1340 : "0" (1)
1341 : "rcx", "rdx");
1342# elif (defined(PIC) || defined(__PIC__)) && defined(__i386__)
1343 RTCCUINTREG uSpill;
1344 __asm__ __volatile__ ("mov %%ebx,%1\n\t"
1345 "cpuid\n\t"
1346 "xchgl %%ebx,%1\n\t"
1347 : "=a" (uSpill),
1348 "=rm" (xBX)
1349 : "0" (1)
1350 : "ecx", "edx");
1351# else
1352 RTCCUINTREG uSpill;
1353 __asm__ __volatile__ ("cpuid"
1354 : "=a" (uSpill),
1355 "=b" (xBX)
1356 : "0" (1)
1357 : "ecx", "edx");
1358# endif
1359
1360# elif RT_INLINE_ASM_USES_INTRIN
1361 int aInfo[4];
1362 __cpuid(aInfo, 1);
1363 xBX = aInfo[1];
1364
1365# else
1366 __asm
1367 {
1368 push ebx
1369 mov eax, 1
1370 cpuid
1371 mov [xBX], ebx
1372 pop ebx
1373 }
1374# endif
1375 return (uint8_t)(xBX >> 24);
1376}
1377#endif
1378
1379
1380/**
1381 * Tests if it a genuine Intel CPU based on the ASMCpuId(0) output.
1382 *
1383 * @returns true/false.
1384 * @param uEBX EBX return from ASMCpuId(0)
1385 * @param uECX ECX return from ASMCpuId(0)
1386 * @param uEDX EDX return from ASMCpuId(0)
1387 */
1388DECLINLINE(bool) ASMIsIntelCpuEx(uint32_t uEBX, uint32_t uECX, uint32_t uEDX)
1389{
1390 return uEBX == UINT32_C(0x756e6547)
1391 && uECX == UINT32_C(0x6c65746e)
1392 && uEDX == UINT32_C(0x49656e69);
1393}
1394
1395
1396/**
1397 * Tests if this is a genuine Intel CPU.
1398 *
1399 * @returns true/false.
1400 * @remarks ASSUMES that cpuid is supported by the CPU.
1401 */
1402DECLINLINE(bool) ASMIsIntelCpu(void)
1403{
1404 uint32_t uEAX, uEBX, uECX, uEDX;
1405 ASMCpuId(0, &uEAX, &uEBX, &uECX, &uEDX);
1406 return ASMIsIntelCpuEx(uEBX, uECX, uEDX);
1407}
1408
1409
1410/**
1411 * Tests if it an authentic AMD CPU based on the ASMCpuId(0) output.
1412 *
1413 * @returns true/false.
1414 * @param uEBX EBX return from ASMCpuId(0)
1415 * @param uECX ECX return from ASMCpuId(0)
1416 * @param uEDX EDX return from ASMCpuId(0)
1417 */
1418DECLINLINE(bool) ASMIsAmdCpuEx(uint32_t uEBX, uint32_t uECX, uint32_t uEDX)
1419{
1420 return uEBX == UINT32_C(0x68747541)
1421 && uECX == UINT32_C(0x444d4163)
1422 && uEDX == UINT32_C(0x69746e65);
1423}
1424
1425
1426/**
1427 * Tests if this is an authentic AMD CPU.
1428 *
1429 * @returns true/false.
1430 * @remarks ASSUMES that cpuid is supported by the CPU.
1431 */
1432DECLINLINE(bool) ASMIsAmdCpu(void)
1433{
1434 uint32_t uEAX, uEBX, uECX, uEDX;
1435 ASMCpuId(0, &uEAX, &uEBX, &uECX, &uEDX);
1436 return ASMIsAmdCpuEx(uEBX, uECX, uEDX);
1437}
1438
1439
1440/**
1441 * Tests if it a centaur hauling VIA CPU based on the ASMCpuId(0) output.
1442 *
1443 * @returns true/false.
1444 * @param uEBX EBX return from ASMCpuId(0).
1445 * @param uECX ECX return from ASMCpuId(0).
1446 * @param uEDX EDX return from ASMCpuId(0).
1447 */
1448DECLINLINE(bool) ASMIsViaCentaurCpuEx(uint32_t uEBX, uint32_t uECX, uint32_t uEDX)
1449{
1450 return uEBX == UINT32_C(0x746e6543)
1451 && uECX == UINT32_C(0x736c7561)
1452 && uEDX == UINT32_C(0x48727561);
1453}
1454
1455
1456/**
1457 * Tests if this is a centaur hauling VIA CPU.
1458 *
1459 * @returns true/false.
1460 * @remarks ASSUMES that cpuid is supported by the CPU.
1461 */
1462DECLINLINE(bool) ASMIsViaCentaurCpu(void)
1463{
1464 uint32_t uEAX, uEBX, uECX, uEDX;
1465 ASMCpuId(0, &uEAX, &uEBX, &uECX, &uEDX);
1466 return ASMIsAmdCpuEx(uEBX, uECX, uEDX);
1467}
1468
1469
1470/**
1471 * Checks whether ASMCpuId_EAX(0x00000000) indicates a valid range.
1472 *
1473 *
1474 * @returns true/false.
1475 * @param uEAX The EAX value of CPUID leaf 0x00000000.
1476 *
1477 * @note This only succeeds if there are at least two leaves in the range.
1478 * @remarks The upper range limit is just some half reasonable value we've
1479 * picked out of thin air.
1480 */
1481DECLINLINE(bool) ASMIsValidStdRange(uint32_t uEAX)
1482{
1483 return uEAX >= UINT32_C(0x00000001) && uEAX <= UINT32_C(0x000fffff);
1484}
1485
1486
1487/**
1488 * Checks whether ASMCpuId_EAX(0x80000000) indicates a valid range.
1489 *
1490 * This only succeeds if there are at least two leaves in the range.
1491 *
1492 * @returns true/false.
1493 * @param uEAX The EAX value of CPUID leaf 0x80000000.
1494 *
1495 * @note This only succeeds if there are at least two leaves in the range.
1496 * @remarks The upper range limit is just some half reasonable value we've
1497 * picked out of thin air.
1498 */
1499DECLINLINE(bool) ASMIsValidExtRange(uint32_t uEAX)
1500{
1501 return uEAX >= UINT32_C(0x80000001) && uEAX <= UINT32_C(0x800fffff);
1502}
1503
1504
1505/**
1506 * Extracts the CPU family from ASMCpuId(1) or ASMCpuId(0x80000001)
1507 *
1508 * @returns Family.
1509 * @param uEAX EAX return from ASMCpuId(1) or ASMCpuId(0x80000001).
1510 */
1511DECLINLINE(uint32_t) ASMGetCpuFamily(uint32_t uEAX)
1512{
1513 return ((uEAX >> 8) & 0xf) == 0xf
1514 ? ((uEAX >> 20) & 0x7f) + 0xf
1515 : ((uEAX >> 8) & 0xf);
1516}
1517
1518
1519/**
1520 * Extracts the CPU model from ASMCpuId(1) or ASMCpuId(0x80000001), Intel variant.
1521 *
1522 * @returns Model.
1523 * @param uEAX EAX from ASMCpuId(1) or ASMCpuId(0x80000001).
1524 */
1525DECLINLINE(uint32_t) ASMGetCpuModelIntel(uint32_t uEAX)
1526{
1527 return ((uEAX >> 8) & 0xf) == 0xf || (((uEAX >> 8) & 0xf) == 0x6) /* family! */
1528 ? ((uEAX >> 4) & 0xf) | ((uEAX >> 12) & 0xf0)
1529 : ((uEAX >> 4) & 0xf);
1530}
1531
1532
1533/**
1534 * Extracts the CPU model from ASMCpuId(1) or ASMCpuId(0x80000001), AMD variant.
1535 *
1536 * @returns Model.
1537 * @param uEAX EAX from ASMCpuId(1) or ASMCpuId(0x80000001).
1538 */
1539DECLINLINE(uint32_t) ASMGetCpuModelAMD(uint32_t uEAX)
1540{
1541 return ((uEAX >> 8) & 0xf) == 0xf
1542 ? ((uEAX >> 4) & 0xf) | ((uEAX >> 12) & 0xf0)
1543 : ((uEAX >> 4) & 0xf);
1544}
1545
1546
1547/**
1548 * Extracts the CPU model from ASMCpuId(1) or ASMCpuId(0x80000001)
1549 *
1550 * @returns Model.
1551 * @param uEAX EAX from ASMCpuId(1) or ASMCpuId(0x80000001).
1552 * @param fIntel Whether it's an intel CPU. Use ASMIsIntelCpuEx() or ASMIsIntelCpu().
1553 */
1554DECLINLINE(uint32_t) ASMGetCpuModel(uint32_t uEAX, bool fIntel)
1555{
1556 return ((uEAX >> 8) & 0xf) == 0xf || (((uEAX >> 8) & 0xf) == 0x6 && fIntel) /* family! */
1557 ? ((uEAX >> 4) & 0xf) | ((uEAX >> 12) & 0xf0)
1558 : ((uEAX >> 4) & 0xf);
1559}
1560
1561
1562/**
1563 * Extracts the CPU stepping from ASMCpuId(1) or ASMCpuId(0x80000001)
1564 *
1565 * @returns Model.
1566 * @param uEAX EAX from ASMCpuId(1) or ASMCpuId(0x80000001).
1567 */
1568DECLINLINE(uint32_t) ASMGetCpuStepping(uint32_t uEAX)
1569{
1570 return uEAX & 0xf;
1571}
1572
1573
1574/**
1575 * Get cr0.
1576 * @returns cr0.
1577 */
1578#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
1579DECLASM(RTCCUINTXREG) ASMGetCR0(void);
1580#else
1581DECLINLINE(RTCCUINTXREG) ASMGetCR0(void)
1582{
1583 RTCCUINTXREG uCR0;
1584# if RT_INLINE_ASM_USES_INTRIN
1585 uCR0 = __readcr0();
1586
1587# elif RT_INLINE_ASM_GNU_STYLE
1588# ifdef RT_ARCH_AMD64
1589 __asm__ __volatile__("movq %%cr0, %0\t\n" : "=r" (uCR0));
1590# else
1591 __asm__ __volatile__("movl %%cr0, %0\t\n" : "=r" (uCR0));
1592# endif
1593# else
1594 __asm
1595 {
1596# ifdef RT_ARCH_AMD64
1597 mov rax, cr0
1598 mov [uCR0], rax
1599# else
1600 mov eax, cr0
1601 mov [uCR0], eax
1602# endif
1603 }
1604# endif
1605 return uCR0;
1606}
1607#endif
1608
1609
1610/**
1611 * Sets the CR0 register.
1612 * @param uCR0 The new CR0 value.
1613 */
1614#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
1615DECLASM(void) ASMSetCR0(RTCCUINTXREG uCR0);
1616#else
1617DECLINLINE(void) ASMSetCR0(RTCCUINTXREG uCR0)
1618{
1619# if RT_INLINE_ASM_USES_INTRIN
1620 __writecr0(uCR0);
1621
1622# elif RT_INLINE_ASM_GNU_STYLE
1623# ifdef RT_ARCH_AMD64
1624 __asm__ __volatile__("movq %0, %%cr0\n\t" :: "r" (uCR0));
1625# else
1626 __asm__ __volatile__("movl %0, %%cr0\n\t" :: "r" (uCR0));
1627# endif
1628# else
1629 __asm
1630 {
1631# ifdef RT_ARCH_AMD64
1632 mov rax, [uCR0]
1633 mov cr0, rax
1634# else
1635 mov eax, [uCR0]
1636 mov cr0, eax
1637# endif
1638 }
1639# endif
1640}
1641#endif
1642
1643
1644/**
1645 * Get cr2.
1646 * @returns cr2.
1647 */
1648#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
1649DECLASM(RTCCUINTXREG) ASMGetCR2(void);
1650#else
1651DECLINLINE(RTCCUINTXREG) ASMGetCR2(void)
1652{
1653 RTCCUINTXREG uCR2;
1654# if RT_INLINE_ASM_USES_INTRIN
1655 uCR2 = __readcr2();
1656
1657# elif RT_INLINE_ASM_GNU_STYLE
1658# ifdef RT_ARCH_AMD64
1659 __asm__ __volatile__("movq %%cr2, %0\t\n" : "=r" (uCR2));
1660# else
1661 __asm__ __volatile__("movl %%cr2, %0\t\n" : "=r" (uCR2));
1662# endif
1663# else
1664 __asm
1665 {
1666# ifdef RT_ARCH_AMD64
1667 mov rax, cr2
1668 mov [uCR2], rax
1669# else
1670 mov eax, cr2
1671 mov [uCR2], eax
1672# endif
1673 }
1674# endif
1675 return uCR2;
1676}
1677#endif
1678
1679
1680/**
1681 * Sets the CR2 register.
1682 * @param uCR2 The new CR0 value.
1683 */
1684#if RT_INLINE_ASM_EXTERNAL
1685DECLASM(void) ASMSetCR2(RTCCUINTXREG uCR2);
1686#else
1687DECLINLINE(void) ASMSetCR2(RTCCUINTXREG uCR2)
1688{
1689# if RT_INLINE_ASM_GNU_STYLE
1690# ifdef RT_ARCH_AMD64
1691 __asm__ __volatile__("movq %0, %%cr2\n\t" :: "r" (uCR2));
1692# else
1693 __asm__ __volatile__("movl %0, %%cr2\n\t" :: "r" (uCR2));
1694# endif
1695# else
1696 __asm
1697 {
1698# ifdef RT_ARCH_AMD64
1699 mov rax, [uCR2]
1700 mov cr2, rax
1701# else
1702 mov eax, [uCR2]
1703 mov cr2, eax
1704# endif
1705 }
1706# endif
1707}
1708#endif
1709
1710
1711/**
1712 * Get cr3.
1713 * @returns cr3.
1714 */
1715#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
1716DECLASM(RTCCUINTXREG) ASMGetCR3(void);
1717#else
1718DECLINLINE(RTCCUINTXREG) ASMGetCR3(void)
1719{
1720 RTCCUINTXREG uCR3;
1721# if RT_INLINE_ASM_USES_INTRIN
1722 uCR3 = __readcr3();
1723
1724# elif RT_INLINE_ASM_GNU_STYLE
1725# ifdef RT_ARCH_AMD64
1726 __asm__ __volatile__("movq %%cr3, %0\t\n" : "=r" (uCR3));
1727# else
1728 __asm__ __volatile__("movl %%cr3, %0\t\n" : "=r" (uCR3));
1729# endif
1730# else
1731 __asm
1732 {
1733# ifdef RT_ARCH_AMD64
1734 mov rax, cr3
1735 mov [uCR3], rax
1736# else
1737 mov eax, cr3
1738 mov [uCR3], eax
1739# endif
1740 }
1741# endif
1742 return uCR3;
1743}
1744#endif
1745
1746
1747/**
1748 * Sets the CR3 register.
1749 *
1750 * @param uCR3 New CR3 value.
1751 */
1752#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
1753DECLASM(void) ASMSetCR3(RTCCUINTXREG uCR3);
1754#else
1755DECLINLINE(void) ASMSetCR3(RTCCUINTXREG uCR3)
1756{
1757# if RT_INLINE_ASM_USES_INTRIN
1758 __writecr3(uCR3);
1759
1760# elif RT_INLINE_ASM_GNU_STYLE
1761# ifdef RT_ARCH_AMD64
1762 __asm__ __volatile__("movq %0, %%cr3\n\t" : : "r" (uCR3));
1763# else
1764 __asm__ __volatile__("movl %0, %%cr3\n\t" : : "r" (uCR3));
1765# endif
1766# else
1767 __asm
1768 {
1769# ifdef RT_ARCH_AMD64
1770 mov rax, [uCR3]
1771 mov cr3, rax
1772# else
1773 mov eax, [uCR3]
1774 mov cr3, eax
1775# endif
1776 }
1777# endif
1778}
1779#endif
1780
1781
1782/**
1783 * Reloads the CR3 register.
1784 */
1785#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
1786DECLASM(void) ASMReloadCR3(void);
1787#else
1788DECLINLINE(void) ASMReloadCR3(void)
1789{
1790# if RT_INLINE_ASM_USES_INTRIN
1791 __writecr3(__readcr3());
1792
1793# elif RT_INLINE_ASM_GNU_STYLE
1794 RTCCUINTXREG u;
1795# ifdef RT_ARCH_AMD64
1796 __asm__ __volatile__("movq %%cr3, %0\n\t"
1797 "movq %0, %%cr3\n\t"
1798 : "=r" (u));
1799# else
1800 __asm__ __volatile__("movl %%cr3, %0\n\t"
1801 "movl %0, %%cr3\n\t"
1802 : "=r" (u));
1803# endif
1804# else
1805 __asm
1806 {
1807# ifdef RT_ARCH_AMD64
1808 mov rax, cr3
1809 mov cr3, rax
1810# else
1811 mov eax, cr3
1812 mov cr3, eax
1813# endif
1814 }
1815# endif
1816}
1817#endif
1818
1819
1820/**
1821 * Get cr4.
1822 * @returns cr4.
1823 */
1824#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
1825DECLASM(RTCCUINTXREG) ASMGetCR4(void);
1826#else
1827DECLINLINE(RTCCUINTXREG) ASMGetCR4(void)
1828{
1829 RTCCUINTXREG uCR4;
1830# if RT_INLINE_ASM_USES_INTRIN
1831 uCR4 = __readcr4();
1832
1833# elif RT_INLINE_ASM_GNU_STYLE
1834# ifdef RT_ARCH_AMD64
1835 __asm__ __volatile__("movq %%cr4, %0\t\n" : "=r" (uCR4));
1836# else
1837 __asm__ __volatile__("movl %%cr4, %0\t\n" : "=r" (uCR4));
1838# endif
1839# else
1840 __asm
1841 {
1842# ifdef RT_ARCH_AMD64
1843 mov rax, cr4
1844 mov [uCR4], rax
1845# else
1846 push eax /* just in case */
1847 /*mov eax, cr4*/
1848 _emit 0x0f
1849 _emit 0x20
1850 _emit 0xe0
1851 mov [uCR4], eax
1852 pop eax
1853# endif
1854 }
1855# endif
1856 return uCR4;
1857}
1858#endif
1859
1860
1861/**
1862 * Sets the CR4 register.
1863 *
1864 * @param uCR4 New CR4 value.
1865 */
1866#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
1867DECLASM(void) ASMSetCR4(RTCCUINTXREG uCR4);
1868#else
1869DECLINLINE(void) ASMSetCR4(RTCCUINTXREG uCR4)
1870{
1871# if RT_INLINE_ASM_USES_INTRIN
1872 __writecr4(uCR4);
1873
1874# elif RT_INLINE_ASM_GNU_STYLE
1875# ifdef RT_ARCH_AMD64
1876 __asm__ __volatile__("movq %0, %%cr4\n\t" : : "r" (uCR4));
1877# else
1878 __asm__ __volatile__("movl %0, %%cr4\n\t" : : "r" (uCR4));
1879# endif
1880# else
1881 __asm
1882 {
1883# ifdef RT_ARCH_AMD64
1884 mov rax, [uCR4]
1885 mov cr4, rax
1886# else
1887 mov eax, [uCR4]
1888 _emit 0x0F
1889 _emit 0x22
1890 _emit 0xE0 /* mov cr4, eax */
1891# endif
1892 }
1893# endif
1894}
1895#endif
1896
1897
1898/**
1899 * Get cr8.
1900 * @returns cr8.
1901 * @remark The lock prefix hack for access from non-64-bit modes is NOT used and 0 is returned.
1902 */
1903#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
1904DECLASM(RTCCUINTXREG) ASMGetCR8(void);
1905#else
1906DECLINLINE(RTCCUINTXREG) ASMGetCR8(void)
1907{
1908# ifdef RT_ARCH_AMD64
1909 RTCCUINTXREG uCR8;
1910# if RT_INLINE_ASM_USES_INTRIN
1911 uCR8 = __readcr8();
1912
1913# elif RT_INLINE_ASM_GNU_STYLE
1914 __asm__ __volatile__("movq %%cr8, %0\t\n" : "=r" (uCR8));
1915# else
1916 __asm
1917 {
1918 mov rax, cr8
1919 mov [uCR8], rax
1920 }
1921# endif
1922 return uCR8;
1923# else /* !RT_ARCH_AMD64 */
1924 return 0;
1925# endif /* !RT_ARCH_AMD64 */
1926}
1927#endif
1928
1929
1930/**
1931 * Get XCR0 (eXtended feature Control Register 0).
1932 * @returns xcr0.
1933 */
1934DECLASM(uint64_t) ASMGetXcr0(void);
1935
1936/**
1937 * Sets the XCR0 register.
1938 * @param uXcr0 The new XCR0 value.
1939 */
1940DECLASM(void) ASMSetXcr0(uint64_t uXcr0);
1941
1942struct X86XSAVEAREA;
1943/**
1944 * Save extended CPU state.
1945 * @param pXStateArea Where to save the state.
1946 * @param fComponents Which state components to save.
1947 */
1948DECLASM(void) ASMXSave(struct X86XSAVEAREA *pXStateArea, uint64_t fComponents);
1949
1950/**
1951 * Loads extended CPU state.
1952 * @param pXStateArea Where to load the state from.
1953 * @param fComponents Which state components to load.
1954 */
1955DECLASM(void) ASMXRstor(struct X86XSAVEAREA const *pXStateArea, uint64_t fComponents);
1956
1957
1958/**
1959 * Enables interrupts (EFLAGS.IF).
1960 */
1961#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
1962DECLASM(void) ASMIntEnable(void);
1963#else
1964DECLINLINE(void) ASMIntEnable(void)
1965{
1966# if RT_INLINE_ASM_GNU_STYLE
1967 __asm("sti\n");
1968# elif RT_INLINE_ASM_USES_INTRIN
1969 _enable();
1970# else
1971 __asm sti
1972# endif
1973}
1974#endif
1975
1976
1977/**
1978 * Disables interrupts (!EFLAGS.IF).
1979 */
1980#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
1981DECLASM(void) ASMIntDisable(void);
1982#else
1983DECLINLINE(void) ASMIntDisable(void)
1984{
1985# if RT_INLINE_ASM_GNU_STYLE
1986 __asm("cli\n");
1987# elif RT_INLINE_ASM_USES_INTRIN
1988 _disable();
1989# else
1990 __asm cli
1991# endif
1992}
1993#endif
1994
1995
1996/**
1997 * Disables interrupts and returns previous xFLAGS.
1998 */
1999#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2000DECLASM(RTCCUINTREG) ASMIntDisableFlags(void);
2001#else
2002DECLINLINE(RTCCUINTREG) ASMIntDisableFlags(void)
2003{
2004 RTCCUINTREG xFlags;
2005# if RT_INLINE_ASM_GNU_STYLE
2006# ifdef RT_ARCH_AMD64
2007 __asm__ __volatile__("pushfq\n\t"
2008 "cli\n\t"
2009 "popq %0\n\t"
2010 : "=r" (xFlags));
2011# else
2012 __asm__ __volatile__("pushfl\n\t"
2013 "cli\n\t"
2014 "popl %0\n\t"
2015 : "=r" (xFlags));
2016# endif
2017# elif RT_INLINE_ASM_USES_INTRIN && !defined(RT_ARCH_X86)
2018 xFlags = ASMGetFlags();
2019 _disable();
2020# else
2021 __asm {
2022 pushfd
2023 cli
2024 pop [xFlags]
2025 }
2026# endif
2027 return xFlags;
2028}
2029#endif
2030
2031
2032/**
2033 * Are interrupts enabled?
2034 *
2035 * @returns true / false.
2036 */
2037DECLINLINE(bool) ASMIntAreEnabled(void)
2038{
2039 RTCCUINTREG uFlags = ASMGetFlags();
2040 return uFlags & 0x200 /* X86_EFL_IF */ ? true : false;
2041}
2042
2043
2044/**
2045 * Halts the CPU until interrupted.
2046 */
2047#if RT_INLINE_ASM_EXTERNAL && RT_INLINE_ASM_USES_INTRIN < 14
2048DECLASM(void) ASMHalt(void);
2049#else
2050DECLINLINE(void) ASMHalt(void)
2051{
2052# if RT_INLINE_ASM_GNU_STYLE
2053 __asm__ __volatile__("hlt\n\t");
2054# elif RT_INLINE_ASM_USES_INTRIN
2055 __halt();
2056# else
2057 __asm {
2058 hlt
2059 }
2060# endif
2061}
2062#endif
2063
2064
2065/**
2066 * Reads a machine specific register.
2067 *
2068 * @returns Register content.
2069 * @param uRegister Register to read.
2070 */
2071#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2072DECLASM(uint64_t) ASMRdMsr(uint32_t uRegister);
2073#else
2074DECLINLINE(uint64_t) ASMRdMsr(uint32_t uRegister)
2075{
2076 RTUINT64U u;
2077# if RT_INLINE_ASM_GNU_STYLE
2078 __asm__ __volatile__("rdmsr\n\t"
2079 : "=a" (u.s.Lo),
2080 "=d" (u.s.Hi)
2081 : "c" (uRegister));
2082
2083# elif RT_INLINE_ASM_USES_INTRIN
2084 u.u = __readmsr(uRegister);
2085
2086# else
2087 __asm
2088 {
2089 mov ecx, [uRegister]
2090 rdmsr
2091 mov [u.s.Lo], eax
2092 mov [u.s.Hi], edx
2093 }
2094# endif
2095
2096 return u.u;
2097}
2098#endif
2099
2100
2101/**
2102 * Writes a machine specific register.
2103 *
2104 * @returns Register content.
2105 * @param uRegister Register to write to.
2106 * @param u64Val Value to write.
2107 */
2108#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2109DECLASM(void) ASMWrMsr(uint32_t uRegister, uint64_t u64Val);
2110#else
2111DECLINLINE(void) ASMWrMsr(uint32_t uRegister, uint64_t u64Val)
2112{
2113 RTUINT64U u;
2114
2115 u.u = u64Val;
2116# if RT_INLINE_ASM_GNU_STYLE
2117 __asm__ __volatile__("wrmsr\n\t"
2118 ::"a" (u.s.Lo),
2119 "d" (u.s.Hi),
2120 "c" (uRegister));
2121
2122# elif RT_INLINE_ASM_USES_INTRIN
2123 __writemsr(uRegister, u.u);
2124
2125# else
2126 __asm
2127 {
2128 mov ecx, [uRegister]
2129 mov edx, [u.s.Hi]
2130 mov eax, [u.s.Lo]
2131 wrmsr
2132 }
2133# endif
2134}
2135#endif
2136
2137
2138/**
2139 * Reads a machine specific register, extended version (for AMD).
2140 *
2141 * @returns Register content.
2142 * @param uRegister Register to read.
2143 * @param uXDI RDI/EDI value.
2144 */
2145#if RT_INLINE_ASM_EXTERNAL
2146DECLASM(uint64_t) ASMRdMsrEx(uint32_t uRegister, RTCCUINTXREG uXDI);
2147#else
2148DECLINLINE(uint64_t) ASMRdMsrEx(uint32_t uRegister, RTCCUINTXREG uXDI)
2149{
2150 RTUINT64U u;
2151# if RT_INLINE_ASM_GNU_STYLE
2152 __asm__ __volatile__("rdmsr\n\t"
2153 : "=a" (u.s.Lo),
2154 "=d" (u.s.Hi)
2155 : "c" (uRegister),
2156 "D" (uXDI));
2157
2158# else
2159 __asm
2160 {
2161 mov ecx, [uRegister]
2162 xchg edi, [uXDI]
2163 rdmsr
2164 mov [u.s.Lo], eax
2165 mov [u.s.Hi], edx
2166 xchg edi, [uXDI]
2167 }
2168# endif
2169
2170 return u.u;
2171}
2172#endif
2173
2174
2175/**
2176 * Writes a machine specific register, extended version (for AMD).
2177 *
2178 * @returns Register content.
2179 * @param uRegister Register to write to.
2180 * @param uXDI RDI/EDI value.
2181 * @param u64Val Value to write.
2182 */
2183#if RT_INLINE_ASM_EXTERNAL
2184DECLASM(void) ASMWrMsrEx(uint32_t uRegister, RTCCUINTXREG uXDI, uint64_t u64Val);
2185#else
2186DECLINLINE(void) ASMWrMsrEx(uint32_t uRegister, RTCCUINTXREG uXDI, uint64_t u64Val)
2187{
2188 RTUINT64U u;
2189
2190 u.u = u64Val;
2191# if RT_INLINE_ASM_GNU_STYLE
2192 __asm__ __volatile__("wrmsr\n\t"
2193 ::"a" (u.s.Lo),
2194 "d" (u.s.Hi),
2195 "c" (uRegister),
2196 "D" (uXDI));
2197
2198# else
2199 __asm
2200 {
2201 mov ecx, [uRegister]
2202 xchg edi, [uXDI]
2203 mov edx, [u.s.Hi]
2204 mov eax, [u.s.Lo]
2205 wrmsr
2206 xchg edi, [uXDI]
2207 }
2208# endif
2209}
2210#endif
2211
2212
2213
2214/**
2215 * Reads low part of a machine specific register.
2216 *
2217 * @returns Register content.
2218 * @param uRegister Register to read.
2219 */
2220#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2221DECLASM(uint32_t) ASMRdMsr_Low(uint32_t uRegister);
2222#else
2223DECLINLINE(uint32_t) ASMRdMsr_Low(uint32_t uRegister)
2224{
2225 uint32_t u32;
2226# if RT_INLINE_ASM_GNU_STYLE
2227 __asm__ __volatile__("rdmsr\n\t"
2228 : "=a" (u32)
2229 : "c" (uRegister)
2230 : "edx");
2231
2232# elif RT_INLINE_ASM_USES_INTRIN
2233 u32 = (uint32_t)__readmsr(uRegister);
2234
2235#else
2236 __asm
2237 {
2238 mov ecx, [uRegister]
2239 rdmsr
2240 mov [u32], eax
2241 }
2242# endif
2243
2244 return u32;
2245}
2246#endif
2247
2248
2249/**
2250 * Reads high part of a machine specific register.
2251 *
2252 * @returns Register content.
2253 * @param uRegister Register to read.
2254 */
2255#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2256DECLASM(uint32_t) ASMRdMsr_High(uint32_t uRegister);
2257#else
2258DECLINLINE(uint32_t) ASMRdMsr_High(uint32_t uRegister)
2259{
2260 uint32_t u32;
2261# if RT_INLINE_ASM_GNU_STYLE
2262 __asm__ __volatile__("rdmsr\n\t"
2263 : "=d" (u32)
2264 : "c" (uRegister)
2265 : "eax");
2266
2267# elif RT_INLINE_ASM_USES_INTRIN
2268 u32 = (uint32_t)(__readmsr(uRegister) >> 32);
2269
2270# else
2271 __asm
2272 {
2273 mov ecx, [uRegister]
2274 rdmsr
2275 mov [u32], edx
2276 }
2277# endif
2278
2279 return u32;
2280}
2281#endif
2282
2283
2284/**
2285 * Gets dr0.
2286 *
2287 * @returns dr0.
2288 */
2289#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2290DECLASM(RTCCUINTXREG) ASMGetDR0(void);
2291#else
2292DECLINLINE(RTCCUINTXREG) ASMGetDR0(void)
2293{
2294 RTCCUINTXREG uDR0;
2295# if RT_INLINE_ASM_USES_INTRIN
2296 uDR0 = __readdr(0);
2297# elif RT_INLINE_ASM_GNU_STYLE
2298# ifdef RT_ARCH_AMD64
2299 __asm__ __volatile__("movq %%dr0, %0\n\t" : "=r" (uDR0));
2300# else
2301 __asm__ __volatile__("movl %%dr0, %0\n\t" : "=r" (uDR0));
2302# endif
2303# else
2304 __asm
2305 {
2306# ifdef RT_ARCH_AMD64
2307 mov rax, dr0
2308 mov [uDR0], rax
2309# else
2310 mov eax, dr0
2311 mov [uDR0], eax
2312# endif
2313 }
2314# endif
2315 return uDR0;
2316}
2317#endif
2318
2319
2320/**
2321 * Gets dr1.
2322 *
2323 * @returns dr1.
2324 */
2325#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2326DECLASM(RTCCUINTXREG) ASMGetDR1(void);
2327#else
2328DECLINLINE(RTCCUINTXREG) ASMGetDR1(void)
2329{
2330 RTCCUINTXREG uDR1;
2331# if RT_INLINE_ASM_USES_INTRIN
2332 uDR1 = __readdr(1);
2333# elif RT_INLINE_ASM_GNU_STYLE
2334# ifdef RT_ARCH_AMD64
2335 __asm__ __volatile__("movq %%dr1, %0\n\t" : "=r" (uDR1));
2336# else
2337 __asm__ __volatile__("movl %%dr1, %0\n\t" : "=r" (uDR1));
2338# endif
2339# else
2340 __asm
2341 {
2342# ifdef RT_ARCH_AMD64
2343 mov rax, dr1
2344 mov [uDR1], rax
2345# else
2346 mov eax, dr1
2347 mov [uDR1], eax
2348# endif
2349 }
2350# endif
2351 return uDR1;
2352}
2353#endif
2354
2355
2356/**
2357 * Gets dr2.
2358 *
2359 * @returns dr2.
2360 */
2361#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2362DECLASM(RTCCUINTXREG) ASMGetDR2(void);
2363#else
2364DECLINLINE(RTCCUINTXREG) ASMGetDR2(void)
2365{
2366 RTCCUINTXREG uDR2;
2367# if RT_INLINE_ASM_USES_INTRIN
2368 uDR2 = __readdr(2);
2369# elif RT_INLINE_ASM_GNU_STYLE
2370# ifdef RT_ARCH_AMD64
2371 __asm__ __volatile__("movq %%dr2, %0\n\t" : "=r" (uDR2));
2372# else
2373 __asm__ __volatile__("movl %%dr2, %0\n\t" : "=r" (uDR2));
2374# endif
2375# else
2376 __asm
2377 {
2378# ifdef RT_ARCH_AMD64
2379 mov rax, dr2
2380 mov [uDR2], rax
2381# else
2382 mov eax, dr2
2383 mov [uDR2], eax
2384# endif
2385 }
2386# endif
2387 return uDR2;
2388}
2389#endif
2390
2391
2392/**
2393 * Gets dr3.
2394 *
2395 * @returns dr3.
2396 */
2397#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2398DECLASM(RTCCUINTXREG) ASMGetDR3(void);
2399#else
2400DECLINLINE(RTCCUINTXREG) ASMGetDR3(void)
2401{
2402 RTCCUINTXREG uDR3;
2403# if RT_INLINE_ASM_USES_INTRIN
2404 uDR3 = __readdr(3);
2405# elif RT_INLINE_ASM_GNU_STYLE
2406# ifdef RT_ARCH_AMD64
2407 __asm__ __volatile__("movq %%dr3, %0\n\t" : "=r" (uDR3));
2408# else
2409 __asm__ __volatile__("movl %%dr3, %0\n\t" : "=r" (uDR3));
2410# endif
2411# else
2412 __asm
2413 {
2414# ifdef RT_ARCH_AMD64
2415 mov rax, dr3
2416 mov [uDR3], rax
2417# else
2418 mov eax, dr3
2419 mov [uDR3], eax
2420# endif
2421 }
2422# endif
2423 return uDR3;
2424}
2425#endif
2426
2427
2428/**
2429 * Gets dr6.
2430 *
2431 * @returns dr6.
2432 */
2433#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2434DECLASM(RTCCUINTXREG) ASMGetDR6(void);
2435#else
2436DECLINLINE(RTCCUINTXREG) ASMGetDR6(void)
2437{
2438 RTCCUINTXREG uDR6;
2439# if RT_INLINE_ASM_USES_INTRIN
2440 uDR6 = __readdr(6);
2441# elif RT_INLINE_ASM_GNU_STYLE
2442# ifdef RT_ARCH_AMD64
2443 __asm__ __volatile__("movq %%dr6, %0\n\t" : "=r" (uDR6));
2444# else
2445 __asm__ __volatile__("movl %%dr6, %0\n\t" : "=r" (uDR6));
2446# endif
2447# else
2448 __asm
2449 {
2450# ifdef RT_ARCH_AMD64
2451 mov rax, dr6
2452 mov [uDR6], rax
2453# else
2454 mov eax, dr6
2455 mov [uDR6], eax
2456# endif
2457 }
2458# endif
2459 return uDR6;
2460}
2461#endif
2462
2463
2464/**
2465 * Reads and clears DR6.
2466 *
2467 * @returns DR6.
2468 */
2469#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2470DECLASM(RTCCUINTXREG) ASMGetAndClearDR6(void);
2471#else
2472DECLINLINE(RTCCUINTXREG) ASMGetAndClearDR6(void)
2473{
2474 RTCCUINTXREG uDR6;
2475# if RT_INLINE_ASM_USES_INTRIN
2476 uDR6 = __readdr(6);
2477 __writedr(6, 0xffff0ff0U); /* 31-16 and 4-11 are 1's, 12 and 63-31 are zero. */
2478# elif RT_INLINE_ASM_GNU_STYLE
2479 RTCCUINTXREG uNewValue = 0xffff0ff0U;/* 31-16 and 4-11 are 1's, 12 and 63-31 are zero. */
2480# ifdef RT_ARCH_AMD64
2481 __asm__ __volatile__("movq %%dr6, %0\n\t"
2482 "movq %1, %%dr6\n\t"
2483 : "=r" (uDR6)
2484 : "r" (uNewValue));
2485# else
2486 __asm__ __volatile__("movl %%dr6, %0\n\t"
2487 "movl %1, %%dr6\n\t"
2488 : "=r" (uDR6)
2489 : "r" (uNewValue));
2490# endif
2491# else
2492 __asm
2493 {
2494# ifdef RT_ARCH_AMD64
2495 mov rax, dr6
2496 mov [uDR6], rax
2497 mov rcx, rax
2498 mov ecx, 0ffff0ff0h; /* 31-16 and 4-11 are 1's, 12 and 63-31 are zero. */
2499 mov dr6, rcx
2500# else
2501 mov eax, dr6
2502 mov [uDR6], eax
2503 mov ecx, 0ffff0ff0h; /* 31-16 and 4-11 are 1's, 12 is zero. */
2504 mov dr6, ecx
2505# endif
2506 }
2507# endif
2508 return uDR6;
2509}
2510#endif
2511
2512
2513/**
2514 * Gets dr7.
2515 *
2516 * @returns dr7.
2517 */
2518#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2519DECLASM(RTCCUINTXREG) ASMGetDR7(void);
2520#else
2521DECLINLINE(RTCCUINTXREG) ASMGetDR7(void)
2522{
2523 RTCCUINTXREG uDR7;
2524# if RT_INLINE_ASM_USES_INTRIN
2525 uDR7 = __readdr(7);
2526# elif RT_INLINE_ASM_GNU_STYLE
2527# ifdef RT_ARCH_AMD64
2528 __asm__ __volatile__("movq %%dr7, %0\n\t" : "=r" (uDR7));
2529# else
2530 __asm__ __volatile__("movl %%dr7, %0\n\t" : "=r" (uDR7));
2531# endif
2532# else
2533 __asm
2534 {
2535# ifdef RT_ARCH_AMD64
2536 mov rax, dr7
2537 mov [uDR7], rax
2538# else
2539 mov eax, dr7
2540 mov [uDR7], eax
2541# endif
2542 }
2543# endif
2544 return uDR7;
2545}
2546#endif
2547
2548
2549/**
2550 * Sets dr0.
2551 *
2552 * @param uDRVal Debug register value to write
2553 */
2554#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2555DECLASM(void) ASMSetDR0(RTCCUINTXREG uDRVal);
2556#else
2557DECLINLINE(void) ASMSetDR0(RTCCUINTXREG uDRVal)
2558{
2559# if RT_INLINE_ASM_USES_INTRIN
2560 __writedr(0, uDRVal);
2561# elif RT_INLINE_ASM_GNU_STYLE
2562# ifdef RT_ARCH_AMD64
2563 __asm__ __volatile__("movq %0, %%dr0\n\t" : : "r" (uDRVal));
2564# else
2565 __asm__ __volatile__("movl %0, %%dr0\n\t" : : "r" (uDRVal));
2566# endif
2567# else
2568 __asm
2569 {
2570# ifdef RT_ARCH_AMD64
2571 mov rax, [uDRVal]
2572 mov dr0, rax
2573# else
2574 mov eax, [uDRVal]
2575 mov dr0, eax
2576# endif
2577 }
2578# endif
2579}
2580#endif
2581
2582
2583/**
2584 * Sets dr1.
2585 *
2586 * @param uDRVal Debug register value to write
2587 */
2588#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2589DECLASM(void) ASMSetDR1(RTCCUINTXREG uDRVal);
2590#else
2591DECLINLINE(void) ASMSetDR1(RTCCUINTXREG uDRVal)
2592{
2593# if RT_INLINE_ASM_USES_INTRIN
2594 __writedr(1, uDRVal);
2595# elif RT_INLINE_ASM_GNU_STYLE
2596# ifdef RT_ARCH_AMD64
2597 __asm__ __volatile__("movq %0, %%dr1\n\t" : : "r" (uDRVal));
2598# else
2599 __asm__ __volatile__("movl %0, %%dr1\n\t" : : "r" (uDRVal));
2600# endif
2601# else
2602 __asm
2603 {
2604# ifdef RT_ARCH_AMD64
2605 mov rax, [uDRVal]
2606 mov dr1, rax
2607# else
2608 mov eax, [uDRVal]
2609 mov dr1, eax
2610# endif
2611 }
2612# endif
2613}
2614#endif
2615
2616
2617/**
2618 * Sets dr2.
2619 *
2620 * @param uDRVal Debug register value to write
2621 */
2622#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2623DECLASM(void) ASMSetDR2(RTCCUINTXREG uDRVal);
2624#else
2625DECLINLINE(void) ASMSetDR2(RTCCUINTXREG uDRVal)
2626{
2627# if RT_INLINE_ASM_USES_INTRIN
2628 __writedr(2, uDRVal);
2629# elif RT_INLINE_ASM_GNU_STYLE
2630# ifdef RT_ARCH_AMD64
2631 __asm__ __volatile__("movq %0, %%dr2\n\t" : : "r" (uDRVal));
2632# else
2633 __asm__ __volatile__("movl %0, %%dr2\n\t" : : "r" (uDRVal));
2634# endif
2635# else
2636 __asm
2637 {
2638# ifdef RT_ARCH_AMD64
2639 mov rax, [uDRVal]
2640 mov dr2, rax
2641# else
2642 mov eax, [uDRVal]
2643 mov dr2, eax
2644# endif
2645 }
2646# endif
2647}
2648#endif
2649
2650
2651/**
2652 * Sets dr3.
2653 *
2654 * @param uDRVal Debug register value to write
2655 */
2656#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2657DECLASM(void) ASMSetDR3(RTCCUINTXREG uDRVal);
2658#else
2659DECLINLINE(void) ASMSetDR3(RTCCUINTXREG uDRVal)
2660{
2661# if RT_INLINE_ASM_USES_INTRIN
2662 __writedr(3, uDRVal);
2663# elif RT_INLINE_ASM_GNU_STYLE
2664# ifdef RT_ARCH_AMD64
2665 __asm__ __volatile__("movq %0, %%dr3\n\t" : : "r" (uDRVal));
2666# else
2667 __asm__ __volatile__("movl %0, %%dr3\n\t" : : "r" (uDRVal));
2668# endif
2669# else
2670 __asm
2671 {
2672# ifdef RT_ARCH_AMD64
2673 mov rax, [uDRVal]
2674 mov dr3, rax
2675# else
2676 mov eax, [uDRVal]
2677 mov dr3, eax
2678# endif
2679 }
2680# endif
2681}
2682#endif
2683
2684
2685/**
2686 * Sets dr6.
2687 *
2688 * @param uDRVal Debug register value to write
2689 */
2690#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2691DECLASM(void) ASMSetDR6(RTCCUINTXREG uDRVal);
2692#else
2693DECLINLINE(void) ASMSetDR6(RTCCUINTXREG uDRVal)
2694{
2695# if RT_INLINE_ASM_USES_INTRIN
2696 __writedr(6, uDRVal);
2697# elif RT_INLINE_ASM_GNU_STYLE
2698# ifdef RT_ARCH_AMD64
2699 __asm__ __volatile__("movq %0, %%dr6\n\t" : : "r" (uDRVal));
2700# else
2701 __asm__ __volatile__("movl %0, %%dr6\n\t" : : "r" (uDRVal));
2702# endif
2703# else
2704 __asm
2705 {
2706# ifdef RT_ARCH_AMD64
2707 mov rax, [uDRVal]
2708 mov dr6, rax
2709# else
2710 mov eax, [uDRVal]
2711 mov dr6, eax
2712# endif
2713 }
2714# endif
2715}
2716#endif
2717
2718
2719/**
2720 * Sets dr7.
2721 *
2722 * @param uDRVal Debug register value to write
2723 */
2724#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2725DECLASM(void) ASMSetDR7(RTCCUINTXREG uDRVal);
2726#else
2727DECLINLINE(void) ASMSetDR7(RTCCUINTXREG uDRVal)
2728{
2729# if RT_INLINE_ASM_USES_INTRIN
2730 __writedr(7, uDRVal);
2731# elif RT_INLINE_ASM_GNU_STYLE
2732# ifdef RT_ARCH_AMD64
2733 __asm__ __volatile__("movq %0, %%dr7\n\t" : : "r" (uDRVal));
2734# else
2735 __asm__ __volatile__("movl %0, %%dr7\n\t" : : "r" (uDRVal));
2736# endif
2737# else
2738 __asm
2739 {
2740# ifdef RT_ARCH_AMD64
2741 mov rax, [uDRVal]
2742 mov dr7, rax
2743# else
2744 mov eax, [uDRVal]
2745 mov dr7, eax
2746# endif
2747 }
2748# endif
2749}
2750#endif
2751
2752
2753/**
2754 * Writes a 8-bit unsigned integer to an I/O port, ordered.
2755 *
2756 * @param Port I/O port to write to.
2757 * @param u8 8-bit integer to write.
2758 */
2759#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2760DECLASM(void) ASMOutU8(RTIOPORT Port, uint8_t u8);
2761#else
2762DECLINLINE(void) ASMOutU8(RTIOPORT Port, uint8_t u8)
2763{
2764# if RT_INLINE_ASM_GNU_STYLE
2765 __asm__ __volatile__("outb %b1, %w0\n\t"
2766 :: "Nd" (Port),
2767 "a" (u8));
2768
2769# elif RT_INLINE_ASM_USES_INTRIN
2770 __outbyte(Port, u8);
2771
2772# else
2773 __asm
2774 {
2775 mov dx, [Port]
2776 mov al, [u8]
2777 out dx, al
2778 }
2779# endif
2780}
2781#endif
2782
2783
2784/**
2785 * Reads a 8-bit unsigned integer from an I/O port, ordered.
2786 *
2787 * @returns 8-bit integer.
2788 * @param Port I/O port to read from.
2789 */
2790#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2791DECLASM(uint8_t) ASMInU8(RTIOPORT Port);
2792#else
2793DECLINLINE(uint8_t) ASMInU8(RTIOPORT Port)
2794{
2795 uint8_t u8;
2796# if RT_INLINE_ASM_GNU_STYLE
2797 __asm__ __volatile__("inb %w1, %b0\n\t"
2798 : "=a" (u8)
2799 : "Nd" (Port));
2800
2801# elif RT_INLINE_ASM_USES_INTRIN
2802 u8 = __inbyte(Port);
2803
2804# else
2805 __asm
2806 {
2807 mov dx, [Port]
2808 in al, dx
2809 mov [u8], al
2810 }
2811# endif
2812 return u8;
2813}
2814#endif
2815
2816
2817/**
2818 * Writes a 16-bit unsigned integer to an I/O port, ordered.
2819 *
2820 * @param Port I/O port to write to.
2821 * @param u16 16-bit integer to write.
2822 */
2823#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2824DECLASM(void) ASMOutU16(RTIOPORT Port, uint16_t u16);
2825#else
2826DECLINLINE(void) ASMOutU16(RTIOPORT Port, uint16_t u16)
2827{
2828# if RT_INLINE_ASM_GNU_STYLE
2829 __asm__ __volatile__("outw %w1, %w0\n\t"
2830 :: "Nd" (Port),
2831 "a" (u16));
2832
2833# elif RT_INLINE_ASM_USES_INTRIN
2834 __outword(Port, u16);
2835
2836# else
2837 __asm
2838 {
2839 mov dx, [Port]
2840 mov ax, [u16]
2841 out dx, ax
2842 }
2843# endif
2844}
2845#endif
2846
2847
2848/**
2849 * Reads a 16-bit unsigned integer from an I/O port, ordered.
2850 *
2851 * @returns 16-bit integer.
2852 * @param Port I/O port to read from.
2853 */
2854#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2855DECLASM(uint16_t) ASMInU16(RTIOPORT Port);
2856#else
2857DECLINLINE(uint16_t) ASMInU16(RTIOPORT Port)
2858{
2859 uint16_t u16;
2860# if RT_INLINE_ASM_GNU_STYLE
2861 __asm__ __volatile__("inw %w1, %w0\n\t"
2862 : "=a" (u16)
2863 : "Nd" (Port));
2864
2865# elif RT_INLINE_ASM_USES_INTRIN
2866 u16 = __inword(Port);
2867
2868# else
2869 __asm
2870 {
2871 mov dx, [Port]
2872 in ax, dx
2873 mov [u16], ax
2874 }
2875# endif
2876 return u16;
2877}
2878#endif
2879
2880
2881/**
2882 * Writes a 32-bit unsigned integer to an I/O port, ordered.
2883 *
2884 * @param Port I/O port to write to.
2885 * @param u32 32-bit integer to write.
2886 */
2887#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2888DECLASM(void) ASMOutU32(RTIOPORT Port, uint32_t u32);
2889#else
2890DECLINLINE(void) ASMOutU32(RTIOPORT Port, uint32_t u32)
2891{
2892# if RT_INLINE_ASM_GNU_STYLE
2893 __asm__ __volatile__("outl %1, %w0\n\t"
2894 :: "Nd" (Port),
2895 "a" (u32));
2896
2897# elif RT_INLINE_ASM_USES_INTRIN
2898 __outdword(Port, u32);
2899
2900# else
2901 __asm
2902 {
2903 mov dx, [Port]
2904 mov eax, [u32]
2905 out dx, eax
2906 }
2907# endif
2908}
2909#endif
2910
2911
2912/**
2913 * Reads a 32-bit unsigned integer from an I/O port, ordered.
2914 *
2915 * @returns 32-bit integer.
2916 * @param Port I/O port to read from.
2917 */
2918#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2919DECLASM(uint32_t) ASMInU32(RTIOPORT Port);
2920#else
2921DECLINLINE(uint32_t) ASMInU32(RTIOPORT Port)
2922{
2923 uint32_t u32;
2924# if RT_INLINE_ASM_GNU_STYLE
2925 __asm__ __volatile__("inl %w1, %0\n\t"
2926 : "=a" (u32)
2927 : "Nd" (Port));
2928
2929# elif RT_INLINE_ASM_USES_INTRIN
2930 u32 = __indword(Port);
2931
2932# else
2933 __asm
2934 {
2935 mov dx, [Port]
2936 in eax, dx
2937 mov [u32], eax
2938 }
2939# endif
2940 return u32;
2941}
2942#endif
2943
2944
2945/**
2946 * Writes a string of 8-bit unsigned integer items to an I/O port, ordered.
2947 *
2948 * @param Port I/O port to write to.
2949 * @param pau8 Pointer to the string buffer.
2950 * @param c The number of items to write.
2951 */
2952#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2953DECLASM(void) ASMOutStrU8(RTIOPORT Port, uint8_t const *pau8, size_t c);
2954#else
2955DECLINLINE(void) ASMOutStrU8(RTIOPORT Port, uint8_t const *pau8, size_t c)
2956{
2957# if RT_INLINE_ASM_GNU_STYLE
2958 __asm__ __volatile__("rep; outsb\n\t"
2959 : "+S" (pau8),
2960 "+c" (c)
2961 : "d" (Port));
2962
2963# elif RT_INLINE_ASM_USES_INTRIN
2964 __outbytestring(Port, (unsigned char *)pau8, (unsigned long)c);
2965
2966# else
2967 __asm
2968 {
2969 mov dx, [Port]
2970 mov ecx, [c]
2971 mov eax, [pau8]
2972 xchg esi, eax
2973 rep outsb
2974 xchg esi, eax
2975 }
2976# endif
2977}
2978#endif
2979
2980
2981/**
2982 * Reads a string of 8-bit unsigned integer items from an I/O port, ordered.
2983 *
2984 * @param Port I/O port to read from.
2985 * @param pau8 Pointer to the string buffer (output).
2986 * @param c The number of items to read.
2987 */
2988#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
2989DECLASM(void) ASMInStrU8(RTIOPORT Port, uint8_t *pau8, size_t c);
2990#else
2991DECLINLINE(void) ASMInStrU8(RTIOPORT Port, uint8_t *pau8, size_t c)
2992{
2993# if RT_INLINE_ASM_GNU_STYLE
2994 __asm__ __volatile__("rep; insb\n\t"
2995 : "+D" (pau8),
2996 "+c" (c)
2997 : "d" (Port));
2998
2999# elif RT_INLINE_ASM_USES_INTRIN
3000 __inbytestring(Port, pau8, (unsigned long)c);
3001
3002# else
3003 __asm
3004 {
3005 mov dx, [Port]
3006 mov ecx, [c]
3007 mov eax, [pau8]
3008 xchg edi, eax
3009 rep insb
3010 xchg edi, eax
3011 }
3012# endif
3013}
3014#endif
3015
3016
3017/**
3018 * Writes a string of 16-bit unsigned integer items to an I/O port, ordered.
3019 *
3020 * @param Port I/O port to write to.
3021 * @param pau16 Pointer to the string buffer.
3022 * @param c The number of items to write.
3023 */
3024#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
3025DECLASM(void) ASMOutStrU16(RTIOPORT Port, uint16_t const *pau16, size_t c);
3026#else
3027DECLINLINE(void) ASMOutStrU16(RTIOPORT Port, uint16_t const *pau16, size_t c)
3028{
3029# if RT_INLINE_ASM_GNU_STYLE
3030 __asm__ __volatile__("rep; outsw\n\t"
3031 : "+S" (pau16),
3032 "+c" (c)
3033 : "d" (Port));
3034
3035# elif RT_INLINE_ASM_USES_INTRIN
3036 __outwordstring(Port, (unsigned short *)pau16, (unsigned long)c);
3037
3038# else
3039 __asm
3040 {
3041 mov dx, [Port]
3042 mov ecx, [c]
3043 mov eax, [pau16]
3044 xchg esi, eax
3045 rep outsw
3046 xchg esi, eax
3047 }
3048# endif
3049}
3050#endif
3051
3052
3053/**
3054 * Reads a string of 16-bit unsigned integer items from an I/O port, ordered.
3055 *
3056 * @param Port I/O port to read from.
3057 * @param pau16 Pointer to the string buffer (output).
3058 * @param c The number of items to read.
3059 */
3060#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
3061DECLASM(void) ASMInStrU16(RTIOPORT Port, uint16_t *pau16, size_t c);
3062#else
3063DECLINLINE(void) ASMInStrU16(RTIOPORT Port, uint16_t *pau16, size_t c)
3064{
3065# if RT_INLINE_ASM_GNU_STYLE
3066 __asm__ __volatile__("rep; insw\n\t"
3067 : "+D" (pau16),
3068 "+c" (c)
3069 : "d" (Port));
3070
3071# elif RT_INLINE_ASM_USES_INTRIN
3072 __inwordstring(Port, pau16, (unsigned long)c);
3073
3074# else
3075 __asm
3076 {
3077 mov dx, [Port]
3078 mov ecx, [c]
3079 mov eax, [pau16]
3080 xchg edi, eax
3081 rep insw
3082 xchg edi, eax
3083 }
3084# endif
3085}
3086#endif
3087
3088
3089/**
3090 * Writes a string of 32-bit unsigned integer items to an I/O port, ordered.
3091 *
3092 * @param Port I/O port to write to.
3093 * @param pau32 Pointer to the string buffer.
3094 * @param c The number of items to write.
3095 */
3096#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
3097DECLASM(void) ASMOutStrU32(RTIOPORT Port, uint32_t const *pau32, size_t c);
3098#else
3099DECLINLINE(void) ASMOutStrU32(RTIOPORT Port, uint32_t const *pau32, size_t c)
3100{
3101# if RT_INLINE_ASM_GNU_STYLE
3102 __asm__ __volatile__("rep; outsl\n\t"
3103 : "+S" (pau32),
3104 "+c" (c)
3105 : "d" (Port));
3106
3107# elif RT_INLINE_ASM_USES_INTRIN
3108 __outdwordstring(Port, (unsigned long *)pau32, (unsigned long)c);
3109
3110# else
3111 __asm
3112 {
3113 mov dx, [Port]
3114 mov ecx, [c]
3115 mov eax, [pau32]
3116 xchg esi, eax
3117 rep outsd
3118 xchg esi, eax
3119 }
3120# endif
3121}
3122#endif
3123
3124
3125/**
3126 * Reads a string of 32-bit unsigned integer items from an I/O port, ordered.
3127 *
3128 * @param Port I/O port to read from.
3129 * @param pau32 Pointer to the string buffer (output).
3130 * @param c The number of items to read.
3131 */
3132#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
3133DECLASM(void) ASMInStrU32(RTIOPORT Port, uint32_t *pau32, size_t c);
3134#else
3135DECLINLINE(void) ASMInStrU32(RTIOPORT Port, uint32_t *pau32, size_t c)
3136{
3137# if RT_INLINE_ASM_GNU_STYLE
3138 __asm__ __volatile__("rep; insl\n\t"
3139 : "+D" (pau32),
3140 "+c" (c)
3141 : "d" (Port));
3142
3143# elif RT_INLINE_ASM_USES_INTRIN
3144 __indwordstring(Port, (unsigned long *)pau32, (unsigned long)c);
3145
3146# else
3147 __asm
3148 {
3149 mov dx, [Port]
3150 mov ecx, [c]
3151 mov eax, [pau32]
3152 xchg edi, eax
3153 rep insd
3154 xchg edi, eax
3155 }
3156# endif
3157}
3158#endif
3159
3160
3161/**
3162 * Invalidate page.
3163 *
3164 * @param uPtr Address of the page to invalidate.
3165 */
3166#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
3167DECLASM(void) ASMInvalidatePage(RTCCUINTXREG uPtr);
3168#else
3169DECLINLINE(void) ASMInvalidatePage(RTCCUINTXREG uPtr)
3170{
3171# if RT_INLINE_ASM_USES_INTRIN
3172 __invlpg((void *)uPtr);
3173
3174# elif RT_INLINE_ASM_GNU_STYLE
3175 __asm__ __volatile__("invlpg %0\n\t"
3176 : : "m" (*(uint8_t *)(uintptr_t)uPtr));
3177# else
3178 __asm
3179 {
3180# ifdef RT_ARCH_AMD64
3181 mov rax, [uPtr]
3182 invlpg [rax]
3183# else
3184 mov eax, [uPtr]
3185 invlpg [eax]
3186# endif
3187 }
3188# endif
3189}
3190#endif
3191
3192
3193/**
3194 * Write back the internal caches and invalidate them.
3195 */
3196#if RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN
3197DECLASM(void) ASMWriteBackAndInvalidateCaches(void);
3198#else
3199DECLINLINE(void) ASMWriteBackAndInvalidateCaches(void)
3200{
3201# if RT_INLINE_ASM_USES_INTRIN
3202 __wbinvd();
3203
3204# elif RT_INLINE_ASM_GNU_STYLE
3205 __asm__ __volatile__("wbinvd");
3206# else
3207 __asm
3208 {
3209 wbinvd
3210 }
3211# endif
3212}
3213#endif
3214
3215
3216/**
3217 * Invalidate internal and (perhaps) external caches without first
3218 * flushing dirty cache lines. Use with extreme care.
3219 */
3220#if RT_INLINE_ASM_EXTERNAL
3221DECLASM(void) ASMInvalidateInternalCaches(void);
3222#else
3223DECLINLINE(void) ASMInvalidateInternalCaches(void)
3224{
3225# if RT_INLINE_ASM_GNU_STYLE
3226 __asm__ __volatile__("invd");
3227# else
3228 __asm
3229 {
3230 invd
3231 }
3232# endif
3233}
3234#endif
3235
3236
3237/**
3238 * Memory load/store fence, waits for any pending writes and reads to complete.
3239 * Requires the X86_CPUID_FEATURE_EDX_SSE2 CPUID bit set.
3240 */
3241DECLINLINE(void) ASMMemoryFenceSSE2(void)
3242{
3243#if RT_INLINE_ASM_GNU_STYLE
3244 __asm__ __volatile__ (".byte 0x0f,0xae,0xf0\n\t");
3245#elif RT_INLINE_ASM_USES_INTRIN
3246 _mm_mfence();
3247#else
3248 __asm
3249 {
3250 _emit 0x0f
3251 _emit 0xae
3252 _emit 0xf0
3253 }
3254#endif
3255}
3256
3257
3258/**
3259 * Memory store fence, waits for any writes to complete.
3260 * Requires the X86_CPUID_FEATURE_EDX_SSE CPUID bit set.
3261 */
3262DECLINLINE(void) ASMWriteFenceSSE(void)
3263{
3264#if RT_INLINE_ASM_GNU_STYLE
3265 __asm__ __volatile__ (".byte 0x0f,0xae,0xf8\n\t");
3266#elif RT_INLINE_ASM_USES_INTRIN
3267 _mm_sfence();
3268#else
3269 __asm
3270 {
3271 _emit 0x0f
3272 _emit 0xae
3273 _emit 0xf8
3274 }
3275#endif
3276}
3277
3278
3279/**
3280 * Memory load fence, waits for any pending reads to complete.
3281 * Requires the X86_CPUID_FEATURE_EDX_SSE2 CPUID bit set.
3282 */
3283DECLINLINE(void) ASMReadFenceSSE2(void)
3284{
3285#if RT_INLINE_ASM_GNU_STYLE
3286 __asm__ __volatile__ (".byte 0x0f,0xae,0xe8\n\t");
3287#elif RT_INLINE_ASM_USES_INTRIN
3288 _mm_lfence();
3289#else
3290 __asm
3291 {
3292 _emit 0x0f
3293 _emit 0xae
3294 _emit 0xe8
3295 }
3296#endif
3297}
3298
3299#if !defined(_MSC_VER) || !defined(RT_ARCH_AMD64)
3300
3301/*
3302 * Clear the AC bit in the EFLAGS register.
3303 * Requires the X86_CPUID_STEXT_FEATURE_EBX_SMAP CPUID bit set.
3304 * Requires to be executed in R0.
3305 */
3306DECLINLINE(void) ASMClearAC(void)
3307{
3308#if RT_INLINE_ASM_GNU_STYLE
3309 __asm__ __volatile__ (".byte 0x0f,0x01,0xca\n\t");
3310#else
3311 __asm
3312 {
3313 _emit 0x0f
3314 _emit 0x01
3315 _emit 0xca
3316 }
3317#endif
3318}
3319
3320
3321/*
3322 * Set the AC bit in the EFLAGS register.
3323 * Requires the X86_CPUID_STEXT_FEATURE_EBX_SMAP CPUID bit set.
3324 * Requires to be executed in R0.
3325 */
3326DECLINLINE(void) ASMSetAC(void)
3327{
3328#if RT_INLINE_ASM_GNU_STYLE
3329 __asm__ __volatile__ (".byte 0x0f,0x01,0xcb\n\t");
3330#else
3331 __asm
3332 {
3333 _emit 0x0f
3334 _emit 0x01
3335 _emit 0xcb
3336 }
3337#endif
3338}
3339
3340#endif /* !_MSC_VER) || !RT_ARCH_AMD64 */
3341
3342/** @} */
3343#endif
3344
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette