VirtualBox

Changeset 57446 in vbox


Ignore:
Timestamp:
Aug 18, 2015 5:33:53 PM (10 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
102213
Message:

VMM: Removing VBOX_WITH_HYBRID_32BIT_KERNEL and other 32-bit darwin fun.

Location:
trunk
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/vmm/pgm.h

    r56627 r57446  
    738738VMMR3DECL(int)      PGMR3MappingsUnfix(PVM pVM);
    739739VMMR3DECL(bool)     PGMR3MappingsNeedReFixing(PVM pVM);
    740 #if defined(VBOX_WITH_RAW_MODE) || (HC_ARCH_BITS != 64 && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL))
     740#if defined(VBOX_WITH_RAW_MODE) || HC_ARCH_BITS == 32 /* (latter for 64-bit guests on 32-bit hosts) */
    741741VMMR3DECL(int)      PGMR3MapIntermediate(PVM pVM, RTUINTPTR Addr, RTHCPHYS HCPhys, unsigned cbPages);
    742742#endif

  • trunk/src/VBox/Devices/Makefile.kmk

    r57296 r57446  
    10181018 #
    10191019 VBoxDDR0_TEMPLATE       = VBoxR0
    1020  VBoxDDR0_DEFS.darwin.x86= VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0 VBOX_WITH_2X_4GB_ADDR_SPACE
    10211020 VBoxDDR0_DEFS           = IN_RT_R0 $(if $(VBOX_WITH_HGCM),VBOX_WITH_HGCM,) # - WTF is IN_RT_R0 doing here?
    10221021 VBoxDDR0_DEFS.win      += VBOX_WITH_WIN_PARPORT_SUP

  • trunk/src/VBox/VMM/Makefile.kmk

    r57126 r57446  
    2626
    2727
     28# Fail on unsupported hosts.
     29ifeq ($(KBUILD_TARGET_ARCH),x86)
     30 ifeq ($(KBUILD_TARGET),darwin)
     31  $(error 32-bit darwin is no longer a supported VirtualBox host. Go back to 4.3 or older for 32-bit support.)
     32 else ifeq ($(KBUILD_TARGET),solaris)
     33  $(error 32-bit solaris is no longer a supported VirtualBox host. Go back to x.y or older for 32-bit support.)
     34 endif
     35endif
     36
     37
    2838#
    2939# Globals
    … …  
    120130endif
    121131VBoxVMM_DEFS.darwin = VMM_R0_SWITCH_STACK
    122 VBoxVMM_DEFS.darwin.x86 = \
    123         VBOX_WITH_2X_4GB_ADDR_SPACE   VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R3 \
    124         VBOX_WITH_HYBRID_32BIT_KERNEL VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R3
    125132
    126133VBoxVMM_INCS     = \
    … …  
    277284        VMMSwitcher/AMD64To32Bit.asm \
    278285        VMMSwitcher/AMD64ToPAE.asm
    279  VBoxVMM_SOURCES.darwin.x86 += \
    280         VMMSwitcher/AMD64ToPAE.asm
    281286endif
    282287VBoxVMM_SOURCES.x86 += \
    … …  
    423428 ifdef VBOX_WITH_VMM_R0_SWITCH_STACK
    424429  VMMRC_DEFS    += VMM_R0_SWITCH_STACK
    425  endif
    426  ifeq ($(KBUILD_TARGET_ARCH),x86)
    427   VMMRC_DEFS.darwin = VMM_R0_SWITCH_STACK
    428   VMMRC_DEFS.darwin = \
    429         VBOX_WITH_2X_4GB_ADDR_SPACE   VBOX_WITH_2X_4GB_ADDR_SPACE_IN_RC \
    430         VBOX_WITH_HYBRID_32BIT_KERNEL VBOX_WITH_HYBRID_32BIT_KERNEL_IN_RC
    431430 endif
    432431
    … …  
    551550 endif
    552551 VMMR0_DEFS.darwin = VMM_R0_SWITCH_STACK
    553  VMMR0_DEFS.darwin.x86 = \
    554         VBOX_WITH_2X_4GB_ADDR_SPACE   VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0 \
    555         VBOX_WITH_HYBRID_32BIT_KERNEL VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    556552 VMMR0_DEFS.win.amd64  = VBOX_WITH_KERNEL_USING_XMM
    557553
    … …  
    637633 VMMR0_SOURCES.x86 = \
    638634        VMMR0/VMMR0JmpA-x86.asm
    639  VMMR0_SOURCES.darwin.x86 = \
    640         VMMRZ/PGMRZDynMap.cpp
    641635
    642636 VMMR0_LIBS = \

  • trunk/src/VBox/VMM/VMMAll/CPUMAllRegs.cpp

    r57358 r57446  
    325325#ifdef IN_RING0
    326326# if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS)
    327 #  ifndef VBOX_WITH_HYBRID_32BIT_KERNEL
    328 #   define MAYBE_LOAD_DRx(a_pVCpu, a_fnLoad, a_uValue) \
     327#  define MAYBE_LOAD_DRx(a_pVCpu, a_fnLoad, a_uValue) \
    329328    do { \
    330329        if (!CPUMIsGuestInLongModeEx(&(a_pVCpu)->cpum.s.Guest)) \
    … …  
    333332            (a_pVCpu)->cpum.s.fUseFlags |= CPUM_SYNC_DEBUG_REGS_HYPER; \
    334333    } while (0)
    335 #  else
    336 #   define MAYBE_LOAD_DRx(a_pVCpu, a_fnLoad, a_uValue) \
    337     do { \
    338         /** @todo we're not loading the correct guest value here! */ \
    339         a_fnLoad(a_uValue); \
    340     } while (0)
    341 #  endif
    342334# else
    343 # define MAYBE_LOAD_DRx(a_pVCpu, a_fnLoad, a_uValue) \
     335#  define MAYBE_LOAD_DRx(a_pVCpu, a_fnLoad, a_uValue) \
    344336    do { \
    345337        a_fnLoad(a_uValue); \

  • trunk/src/VBox/VMM/VMMAll/EMAll.cpp

    r57358 r57446  
    23832383    NOREF(pvFault);
    23842384
    2385 #if HC_ARCH_BITS == 32 && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0)
     2385#if HC_ARCH_BITS == 32
    23862386    Assert(pDis->Param1.cb <= 4);
    23872387#endif
    … …  
    30153015    NOREF(pvFault);
    30163016
    3017 #if HC_ARCH_BITS == 32 && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0)
     3017#if HC_ARCH_BITS == 32
    30183018    Assert(pDis->Param1.cb <= 4);
    30193019#endif
    … …  
    37293729            &&  uOpCode != OP_BTR
    37303730            &&  uOpCode != OP_BTC
    3731 # ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    3732             &&  uOpCode != OP_CMPXCHG /* solaris */
    3733             &&  uOpCode != OP_AND     /* windows */
    3734             &&  uOpCode != OP_OR      /* windows */
    3735             &&  uOpCode != OP_XOR     /* because we can */
    3736             &&  uOpCode != OP_ADD     /* windows (dripple) */
    3737             &&  uOpCode != OP_ADC     /* because we can */
    3738             &&  uOpCode != OP_SUB     /* because we can */
    3739             /** @todo OP_BTS or is that a different kind of failure? */
    3740 # endif
    37413731            )
    37423732        {

  • trunk/src/VBox/VMM/VMMAll/EMAllA.asm

    r56287 r57446  
    4444 %define CAN_DO_8_BYTE_OP  1
    4545%endif
    46 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    47  %define CAN_DO_8_BYTE_OP  1
    48  %define MY_PTR_REG64   rcx
    49 %endif
    50 
    51 
    52 ;*******************************************************************************
    53 ;*  External Symbols                                                           *
    54 ;*******************************************************************************
    55 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    56 extern NAME(SUPR0Abs64bitKernelCS)
    57 extern NAME(SUPR0AbsKernelCS)
    58 %endif
    5946
    6047
    … …  
    188175    pop     MY_RET_REG
    189176    retn
    190 
    191 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    192 .do_qword:
    193     db      0xea                        ; jmp far .sixtyfourbit_mode
    194     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    195 BITS 64
    196 .sixtyfourbit_mode:
    197     and     esp, 0ffffffffh
    198     and     MY_PTR_REG, 0ffffffffh
    199     mov     rdx, qword [rsp + 08h]      ; rdx = second parameter
    200     and     [MY_PTR_REG64], rdx         ; do 8 bytes AND
    201     jmp far [.fpret wrt rip]
    202 .fpret:                                 ; 16:32 Pointer to .done.
    203     dd      .done, NAME(SUPR0AbsKernelCS)
    204 BITS 32
    205 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    206177ENDPROC     EMEmulateAnd
    207178
    … …  
    277248    mov     eax, VINF_SUCCESS
    278249    retn
    279 
    280 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    281 .do_qword:
    282     db      0xea                        ; jmp far .sixtyfourbit_mode
    283     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    284 BITS 64
    285 .sixtyfourbit_mode:
    286     and     esp, 0ffffffffh
    287     and     MY_PTR_REG, 0ffffffffh
    288     mov     rdx, qword [rsp + 08h]      ; rdx = second parameter
    289     lock and [MY_PTR_REG64], rdx         ; do 8 bytes OR
    290     jmp far [.fpret wrt rip]
    291 .fpret:                                 ; 16:32 Pointer to .done.
    292     dd      .done, NAME(SUPR0AbsKernelCS)
    293 BITS 32
    294 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    295250ENDPROC     EMEmulateLockAnd
    296251
    … …  
    357312    pop     MY_RET_REG
    358313    retn
    359 
    360 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    361 .do_qword:
    362     db      0xea                        ; jmp far .sixtyfourbit_mode
    363     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    364 BITS 64
    365 .sixtyfourbit_mode:
    366     and     esp, 0ffffffffh
    367     and     MY_PTR_REG, 0ffffffffh
    368     mov     rdx, qword [rsp + 08h]      ; rdx = second parameter
    369     or      [MY_PTR_REG64], rdx         ; do 8 bytes OR
    370     jmp far [.fpret wrt rip]
    371 .fpret:                                 ; 16:32 Pointer to .done.
    372     dd      .done, NAME(SUPR0AbsKernelCS)
    373 BITS 32
    374 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    375314ENDPROC     EMEmulateOr
    376315
    … …  
    446385    mov     eax, VINF_SUCCESS
    447386    retn
    448 
    449 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    450 .do_qword:
    451     db      0xea                        ; jmp far .sixtyfourbit_mode
    452     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    453 BITS 64
    454 .sixtyfourbit_mode:
    455     and     esp, 0ffffffffh
    456     and     MY_PTR_REG, 0ffffffffh
    457     mov     rdx, qword [rsp + 08h]      ; rdx = second parameter
    458     lock or [MY_PTR_REG64], rdx         ; do 8 bytes OR
    459     jmp far [.fpret wrt rip]
    460 .fpret:                                 ; 16:32 Pointer to .done.
    461     dd      .done, NAME(SUPR0AbsKernelCS)
    462 BITS 32
    463 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    464387ENDPROC     EMEmulateLockOr
    465388
    … …  
    527450    pop     MY_RET_REG
    528451    retn
    529 
    530 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    531 .do_qword:
    532     db      0xea                        ; jmp far .sixtyfourbit_mode
    533     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    534 BITS 64
    535 .sixtyfourbit_mode:
    536     and     esp, 0ffffffffh
    537     and     MY_PTR_REG, 0ffffffffh
    538     mov     rdx, qword [rsp + 08h]      ; rdx = second parameter
    539     xor     [MY_PTR_REG64], rdx         ; do 8 bytes XOR
    540     jmp far [.fpret wrt rip]
    541 .fpret:                                 ; 16:32 Pointer to .done.
    542     dd      .done, NAME(SUPR0AbsKernelCS)
    543 BITS 32
    544 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    545452ENDPROC     EMEmulateXor
    546453
    … …  
    615522    mov     eax, VINF_SUCCESS
    616523    retn
    617 
    618 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    619 .do_qword:
    620     db      0xea                        ; jmp far .sixtyfourbit_mode
    621     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    622 BITS 64
    623 .sixtyfourbit_mode:
    624     and     esp, 0ffffffffh
    625     and     MY_PTR_REG, 0ffffffffh
    626     mov     rdx, qword [rsp + 08h]      ; rdx = second parameter
    627     lock xor [MY_PTR_REG64], rdx         ; do 8 bytes OR
    628     jmp far [.fpret wrt rip]
    629 .fpret:                                 ; 16:32 Pointer to .done.
    630     dd      .done, NAME(SUPR0AbsKernelCS)
    631 BITS 32
    632 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    633524ENDPROC     EMEmulateLockXor
    634525
    … …  
    821712    pop     MY_RET_REG
    822713    retn
    823 
    824 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    825 .do_qword:
    826     db      0xea                        ; jmp far .sixtyfourbit_mode
    827     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    828 BITS 64
    829 .sixtyfourbit_mode:
    830     and     esp, 0ffffffffh
    831     and     MY_PTR_REG, 0ffffffffh
    832     mov     rdx, qword [rsp + 08h]      ; rdx = second parameter
    833     add     [MY_PTR_REG64], rdx         ; do 8 bytes ADD
    834     jmp far [.fpret wrt rip]
    835 .fpret:                                 ; 16:32 Pointer to .done.
    836     dd      .done, NAME(SUPR0AbsKernelCS)
    837 BITS 32
    838 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    839714ENDPROC     EMEmulateAdd
    840715
    … …  
    906781    pop     MY_RET_REG
    907782    retn
    908 
    909 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    910 .do_qword:
    911     db      0xea                        ; jmp far .sixtyfourbit_mode
    912     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    913 BITS 64
    914 .sixtyfourbit_mode:
    915     and     esp, 0ffffffffh
    916     and     MY_PTR_REG, 0ffffffffh
    917     mov     rdx, qword [rsp + 08h]      ; rdx = second parameter
    918     stc     ; set carry flag
    919     adc     [MY_PTR_REG64], rdx         ; do 8 bytes ADC
    920     jmp far [.fpret wrt rip]
    921 .fpret:                                 ; 16:32 Pointer to .done.
    922     dd      .done, NAME(SUPR0AbsKernelCS)
    923 BITS 32
    924 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    925783ENDPROC     EMEmulateAdcWithCarrySet
    926784
    … …  
    988846    pop     MY_RET_REG
    989847    retn
    990 
    991 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    992 .do_qword:
    993     db      0xea                        ; jmp far .sixtyfourbit_mode
    994     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    995 BITS 64
    996 .sixtyfourbit_mode:
    997     and     esp, 0ffffffffh
    998     and     MY_PTR_REG, 0ffffffffh
    999     mov     rdx, qword [rsp + 08h]      ; rdx = second parameter
    1000     sub     [MY_PTR_REG64], rdx         ; do 8 bytes SUB
    1001     jmp far [.fpret wrt rip]
    1002 .fpret:                                 ; 16:32 Pointer to .done.
    1003     dd      .done, NAME(SUPR0AbsKernelCS)
    1004 BITS 32
    1005 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    1006848ENDPROC     EMEmulateSub
    1007849
    … …  
    12201062    pop     xBX
    12211063    retn
    1222 
    1223 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    1224 .do_qword:
    1225     db      0xea                        ; jmp far .sixtyfourbit_mode
    1226     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    1227 BITS 64
    1228 .sixtyfourbit_mode:
    1229     and     ebx, 0ffffffffh
    1230     and     esp, 0ffffffffh
    1231     and     ecx, 0ffffffffh
    1232     mov     rax, qword [rbx]            ; load 2nd parameter's value
    1233     mov     rdx, qword [rsp + 0ch + 4]  ; rdx = third parameter
    1234 
    1235     lock cmpxchg qword [rcx], rdx       ; do 8 byte CMPXCHG
    1236     mov     qword [rbx], rax
    1237     jmp far [.fpret wrt rip]
    1238 .fpret:                                 ; 16:32 Pointer to .done.
    1239     dd      .done, NAME(SUPR0AbsKernelCS)
    1240 BITS 32
    1241 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    12421064ENDPROC     EMEmulateLockCmpXchg
    12431065
    … …  
    13281150    pop     xBX
    13291151    retn
    1330 
    1331 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    1332 .do_qword:
    1333     db      0xea                        ; jmp far .sixtyfourbit_mode
    1334     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    1335 BITS 64
    1336 .sixtyfourbit_mode:
    1337     and     ebx, 0ffffffffh
    1338     and     esp, 0ffffffffh
    1339     and     ecx, 0ffffffffh
    1340     mov     rax, qword [rbx]            ; load 2nd parameter's value
    1341     mov     rdx, qword [rsp + 0ch + 4]  ; rdx = third parameter
    1342 
    1343     cmpxchg qword [rcx], rdx            ; do 8 byte CMPXCHG
    1344     mov     qword [rbx], rax
    1345     jmp far [.fpret wrt rip]
    1346 .fpret:                                 ; 16:32 Pointer to .done.
    1347     dd      .done, NAME(SUPR0AbsKernelCS)
    1348 BITS 32
    1349 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    13501152ENDPROC     EMEmulateCmpXchg
    13511153
    … …  
    15651367
    15661368    retn
    1567 
    1568 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    1569 .do_qword:
    1570     db      0xea                        ; jmp far .sixtyfourbit_mode
    1571     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    1572 BITS 64
    1573 .sixtyfourbit_mode:
    1574     and     esp, 0ffffffffh
    1575     and     edx, 0ffffffffh
    1576     and     MY_PTR_REG, 0ffffffffh
    1577     mov     rax, qword [rdx]            ; load 2nd parameter's value
    1578     and     [MY_PTR_REG64], rax         ; do 8 bytes XADD
    1579     jmp far [.fpret wrt rip]
    1580 .fpret:                                 ; 16:32 Pointer to .done.
    1581     dd      .done, NAME(SUPR0AbsKernelCS)
    1582 BITS 32
    1583 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    15841369ENDPROC     EMEmulateLockXAdd
    15851370
    … …  
    16541439
    16551440    retn
    1656 
    1657 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    1658 .do_qword:
    1659     db      0xea                        ; jmp far .sixtyfourbit_mode
    1660     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    1661 BITS 64
    1662 .sixtyfourbit_mode:
    1663     and     esp, 0ffffffffh
    1664     and     edx, 0ffffffffh
    1665     and     MY_PTR_REG, 0ffffffffh
    1666     mov     rax, qword [rdx]            ; load 2nd parameter's value
    1667     and     [MY_PTR_REG64], rax         ; do 8 bytes XADD
    1668     jmp far [.fpret wrt rip]
    1669 .fpret:                                 ; 16:32 Pointer to .done.
    1670     dd      .done, NAME(SUPR0AbsKernelCS)
    1671 BITS 32
    1672 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    16731441ENDPROC     EMEmulateXAdd
    16741442

  • trunk/src/VBox/VMM/VMMAll/SELMAll.cpp

    r57358 r57446  
    10441044
    10451045
    1046 #if defined(VBOX_WITH_RAW_MODE) || (HC_ARCH_BITS != 64 && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL))
     1046#if defined(VBOX_WITH_RAW_MODE) || (HC_ARCH_BITS != 64 && defined(VBOX_WITH_64_BITS_GUESTS))
    10471047
    10481048/**
    … …  
    11181118}
    11191119
    1120 #endif /* defined(VBOX_WITH_RAW_MODE) || (HC_ARCH_BITS != 64 && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL)) */
     1120#endif /* defined(VBOX_WITH_RAW_MODE) || (HC_ARCH_BITS != 64 && defined(VBOX_WITH_64_BITS_GUESTS)) */
    11211121
    11221122/**

  • trunk/src/VBox/VMM/VMMR0/CPUMR0.cpp

    r57358 r57446  
    256256            {
    257257#ifdef RT_ARCH_X86
    258 # ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    259                 if (fExtFeaturesEDX & X86_CPUID_EXT_FEATURE_EDX_LONG_MODE)
    260 # else
    261258                if (!ASMIsIntelCpu())
    262 # endif
    263259#endif
    264260                {
    … …  
    400396{
    401397    Assert(!RTThreadPreemptIsEnabled(NIL_RTTHREAD));
    402 #if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS) && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
     398#if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS)
    403399    if (CPUMIsGuestInLongModeEx(pCtx))
    404400    {
    … …  
    464460    NOREF(pVM); NOREF(pCtx);
    465461
    466 #if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS) && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
     462#if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS)
    467463    if (CPUMIsGuestInLongModeEx(pCtx))
    468464    {
    … …  
    531527     * Save the host state.
    532528     */
    533 #ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    534     AssertCompile((uintptr_t)&pVCpu->cpum.s.Host.dr3 - (uintptr_t)&pVCpu->cpum.s.Host.dr0 == sizeof(uint64_t) * 3);
    535     cpumR0SaveDRx(&pVCpu->cpum.s.Host.dr0);
    536 #else
    537529    pVCpu->cpum.s.Host.dr0 = ASMGetDR0();
    538530    pVCpu->cpum.s.Host.dr1 = ASMGetDR1();
    539531    pVCpu->cpum.s.Host.dr2 = ASMGetDR2();
    540532    pVCpu->cpum.s.Host.dr3 = ASMGetDR3();
    541 #endif
    542533    pVCpu->cpum.s.Host.dr6 = ASMGetDR6();
    543534    /** @todo dr7 might already have been changed to 0x400; don't care right now as it's harmless. */
    … …  
    583574    if (pVCpu->cpum.s.fUseFlags & CPUM_USED_DEBUG_REGS_GUEST)
    584575    {
    585 #if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS) && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
     576#if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS)
    586577        if (CPUMIsGuestInLongModeEx(&pVCpu->cpum.s.Guest))
    587578        {
    … …  
    594585#endif
    595586        {
    596 #ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    597             cpumR0SaveDRx(&pVCpu->cpum.s.Guest.dr[0]);
    598 #else
    599587            pVCpu->cpum.s.Guest.dr[0] = ASMGetDR0();
    600588            pVCpu->cpum.s.Guest.dr[1] = ASMGetDR1();
    601589            pVCpu->cpum.s.Guest.dr[2] = ASMGetDR2();
    602590            pVCpu->cpum.s.Guest.dr[3] = ASMGetDR3();
    603 #endif
    604591            if (fDr6)
    605592                pVCpu->cpum.s.Guest.dr[6] = ASMGetDR6();
    … …  
    619606            ASMSetDR7(X86_DR7_INIT_VAL);
    620607
    621 #ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    622         AssertCompile((uintptr_t)&pVCpu->cpum.s.Host.dr3 - (uintptr_t)&pVCpu->cpum.s.Host.dr0 == sizeof(uint64_t) * 3);
    623         cpumR0LoadDRx(&pVCpu->cpum.s.Host.dr0);
    624 #else
    625608        ASMSetDR0(pVCpu->cpum.s.Host.dr0);
    626609        ASMSetDR1(pVCpu->cpum.s.Host.dr1);
    627610        ASMSetDR2(pVCpu->cpum.s.Host.dr2);
    628611        ASMSetDR3(pVCpu->cpum.s.Host.dr3);
    629 #endif
    630612        /** @todo consider only updating if they differ, esp. DR6. Need to figure how
    631613         *        expensive DRx reads are over DRx writes.  */
    … …  
    660642    if (pVCpu->cpum.s.fUseFlags & CPUM_USED_DEBUG_REGS_GUEST)
    661643    {
    662 #if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS) && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
     644#if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS)
    663645        if (CPUMIsGuestInLongModeEx(&pVCpu->cpum.s.Guest))
    664646        {
    … …  
    671653#endif
    672654        {
    673 #ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    674             cpumR0SaveDRx(&pVCpu->cpum.s.Guest.dr[0]);
    675 #else
    676655            pVCpu->cpum.s.Guest.dr[0] = ASMGetDR0();
    677656            pVCpu->cpum.s.Guest.dr[1] = ASMGetDR1();
    678657            pVCpu->cpum.s.Guest.dr[2] = ASMGetDR2();
    679658            pVCpu->cpum.s.Guest.dr[3] = ASMGetDR3();
    680 #endif
    681659            if (fDr6)
    682660                pVCpu->cpum.s.Guest.dr[6] = ASMGetDR6();
    … …  
    707685     * DR7 and DR6 (if fDr6 is true) are left to the caller.
    708686     */
    709 #if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS) && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
     687#if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS)
    710688    if (CPUMIsGuestInLongModeEx(&pVCpu->cpum.s.Guest))
    711689        ASMAtomicOrU32(&pVCpu->cpum.s.fUseFlags, CPUM_SYNC_DEBUG_REGS_GUEST); /* Postpone it to the world switch. */
    … …  
    713691#endif
    714692    {
    715 #ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    716         cpumR0LoadDRx(&pVCpu->cpum.s.Guest.dr[0]);
    717 #else
    718693        ASMSetDR0(pVCpu->cpum.s.Guest.dr[0]);
    719694        ASMSetDR1(pVCpu->cpum.s.Guest.dr[1]);
    720695        ASMSetDR2(pVCpu->cpum.s.Guest.dr[2]);
    721696        ASMSetDR3(pVCpu->cpum.s.Guest.dr[3]);
    722 #endif
    723697        if (fDr6)
    724698            ASMSetDR6(pVCpu->cpum.s.Guest.dr[6]);
    … …  
    754728     * DR7 and DR6 (if fDr6 is true) are left to the caller.
    755729     */
    756 #if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS) && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
     730#if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS)
    757731    if (CPUMIsGuestInLongModeEx(&pVCpu->cpum.s.Guest))
    758732        ASMAtomicOrU32(&pVCpu->cpum.s.fUseFlags, CPUM_SYNC_DEBUG_REGS_HYPER); /* Postpone it. */
    … …  
    760734#endif
    761735    {
    762 #ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    763         cpumR0LoadDRx(&pVCpu->cpum.s.Hyper.dr[0]);
    764 #else
    765736        ASMSetDR0(pVCpu->cpum.s.Hyper.dr[0]);
    766737        ASMSetDR1(pVCpu->cpum.s.Hyper.dr[1]);
    767738        ASMSetDR2(pVCpu->cpum.s.Hyper.dr[2]);
    768739        ASMSetDR3(pVCpu->cpum.s.Hyper.dr[3]);
    769 #endif
    770740        if (fDr6)
    771741            ASMSetDR6(X86_DR6_INIT_VAL);

  • trunk/src/VBox/VMM/VMMR0/CPUMR0A.asm

    r55738 r57446  
    4949
    5050
    51 ;*******************************************************************************
    52 ;* External Symbols                                                            *
    53 ;*******************************************************************************
    54 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    55 extern NAME(SUPR0AbsIs64bit)
    56 extern NAME(SUPR0Abs64bitKernelCS)
    57 extern NAME(SUPR0Abs64bitKernelSS)
    58 extern NAME(SUPR0Abs64bitKernelDS)
    59 extern NAME(SUPR0AbsKernelCS)
    60 %endif
    61 
    62 
    63 ;*******************************************************************************
    64 ;*  Global Variables                                                           *
    65 ;*******************************************************************************
    66 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    67 BEGINDATA
    68 %if 0 ; Currently not used.
    69 g_r32_Zero:    dd 0.0
    70 %endif
    71 
    72 ;;
    73 ; Store the SUPR0AbsIs64bit absolute value here so we can cmp/test without
    74 ; needing to clobber a register. (This trick doesn't quite work for PE btw.
    75 ; but that's not relevant atm.)
    76 GLOBALNAME g_fCPUMIs64bitHost
    77     dd  NAME(SUPR0AbsIs64bit)
    78 %endif
    79 
    8051
    8152BEGINCODE
    … …  
    161132        mov     eax, [pCpumCpu + CPUMCPU.Host.fXStateMask]
    162133
    163 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    164         ; The joy of 32-bit darwin kernels that runs the CPU in 64-bit mode.
    165         cmp     byte [NAME(g_fCPUMIs64bitHost)], 0
    166         jz      %%host_legacy_mode
    167         db      0xea                    ; jmp far .sixtyfourbit_mode
    168         dd      %%host_sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    169 BITS 64
    170 %%host_sixtyfourbit_mode:
    171         or      eax, eax
    172         jz      %%host_sixtyfourbit_fxsave
    173 
    174         ; XSAVE
    175         mov     edx, [pCpumCpu + CPUMCPU.Host.fXStateMask + 4]
    176         o64 xsave [pXState]
    177         jmp     %%host_sixtyfourbit_done
    178 
    179         ; FXSAVE
    180 %%host_sixtyfourbit_fxsave:
    181         o64 fxsave [pXState]
    182 
    183 %%host_sixtyfourbit_done:
    184         jmp far [%%host_fpret wrt rip]
    185 %%host_fpret:                           ; 16:32 Pointer to %%host_done.
    186         dd      %%host_done, NAME(SUPR0AbsKernelCS)
    187 BITS 32
    188 
    189 %%host_legacy_mode:
    190 %endif
    191 
    192134        ;
    193135        ; XSAVE or FXSAVE?
    … …  
    230172        mov     pXState, [pCpumCpu + CPUMCPU.Host.pXStateR0]
    231173        mov     eax, [pCpumCpu + CPUMCPU.Host.fXStateMask]
    232 
    233 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    234         ; The joy of 32-bit darwin kernels that runs the CPU in 64-bit mode.
    235         cmp     byte [NAME(g_fCPUMIs64bitHost)], 0
    236         jz      %%host_legacy_mode
    237         db      0xea                    ; jmp far .sixtyfourbit_mode
    238         dd      %%host_sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    239 BITS 64
    240 %%host_sixtyfourbit_mode:
    241         or      eax, eax
    242         jz      %%host_sixtyfourbit_fxrstor
    243 
    244         ; XRSTOR
    245         mov     edx, [pCpumCpu + CPUMCPU.Host.fXStateMask + 4]
    246         o64 xrstor [pXState]
    247         jmp     %%host_sixtyfourbit_done
    248 
    249         ; FXRSTOR
    250 %%host_sixtyfourbit_fxrstor:
    251         o64 fxrstor [pXState]
    252 
    253 %%host_sixtyfourbit_done:
    254         jmp far [%%host_fpret wrt rip]
    255 %%host_fpret:                           ; 16:32 Pointer to %%host_done.
    256         dd      %%host_done, NAME(SUPR0AbsKernelCS)
    257 BITS 32
    258 
    259 %%host_legacy_mode:
    260 %endif
    261174
    262175        ;
    … …  
    341254        mov     pXState, [pCpumCpu + CPUMCPU.Guest.pXStateR0]
    342255        mov     eax, [pCpumCpu + CPUMCPU.Guest.fXStateMask]
    343 
    344 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    345         ; The joy of 32-bit darwin kernels that runs the CPU in 64-bit mode.
    346         cmp     byte [NAME(g_fCPUMIs64bitHost)], 0
    347         jz      %%guest_legacy_mode
    348         db      0xea                    ; jmp far .sixtyfourbit_mode
    349         dd      %%guest_sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    350 BITS 64
    351 %%guest_sixtyfourbit_mode:
    352         or      eax, eax
    353         jz      %%guest_sixtyfourbit_fxsave
    354 
    355         ; XSAVE
    356         mov     edx, [pCpumCpu + CPUMCPU.Guest.fXStateMask + 4]
    357         o64 xsave [pXState]
    358         jmp     %%guest_sixtyfourbit_done
    359 
    360         ; FXSAVE
    361 %%guest_sixtyfourbit_fxsave:
    362         SAVE_32_OR_64_FPU pCpumCpu, pXState, 1
    363 
    364 %%guest_sixtyfourbit_done:
    365         jmp far [%%guest_fpret wrt rip]
    366 %%guest_fpret:                          ; 16:32 Pointer to %%guest_done.
    367         dd      %%guest_done, NAME(SUPR0AbsKernelCS)
    368 BITS 32
    369 
    370 %%guest_legacy_mode:
    371 %endif
    372256
    373257        ;
    … …  
    438322        mov     pXState, [pCpumCpu + CPUMCPU.Guest.pXStateR0]
    439323        mov     eax, [pCpumCpu + CPUMCPU.Guest.fXStateMask]
    440 
    441 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    442         ; The joy of 32-bit darwin kernels that runs the CPU in 64-bit mode.
    443         cmp     byte [NAME(g_fCPUMIs64bitHost)], 0
    444         jz      %%guest_legacy_mode
    445         db      0xea                    ; jmp far .sixtyfourbit_mode
    446         dd      %%guest_sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    447 BITS 64
    448 %%guest_sixtyfourbit_mode:
    449         or      eax, eax
    450         jz      %%guest_sixtyfourbit_fxrstor
    451 
    452         ; XRSTOR
    453         mov     edx, [pCpumCpu + CPUMCPU.Guest.fXStateMask + 4]
    454         o64 xrstor [pXState]
    455         jmp     %%guest_sixtyfourbit_done
    456 
    457         ; FXRSTOR
    458 %%guest_sixtyfourbit_fxrstor:
    459         RESTORE_32_OR_64_FPU pCpumCpu, pXState, 1
    460 
    461 %%guest_sixtyfourbit_done:
    462         jmp far [%%guest_fpret wrt rip]
    463 %%guest_fpret:                          ; 16:32 Pointer to %%guest_done.
    464         dd      %%guest_done, NAME(SUPR0AbsKernelCS)
    465 BITS 32
    466 
    467 %%guest_legacy_mode:
    468 %endif
    469324
    470325        ;
    … …  
    561416
    562417%ifndef RT_ARCH_AMD64
    563 %ifdef  VBOX_WITH_64_BITS_GUESTS
    564 %ifndef VBOX_WITH_HYBRID_32BIT_KERNEL
     418 %ifdef  VBOX_WITH_64_BITS_GUESTS
    565419;;
    566420; Saves the host FPU/SSE/AVX state.
    … …  
    571425align 16
    572426BEGINPROC cpumR0SaveHostFPUState
     427        ;
     428        ; Prologue - xAX+xDX must be free for XSAVE/XRSTOR input.
     429        ;
     430  %ifdef RT_ARCH_AMD64
     431   %ifdef RT_OS_WINDOWS
     432          mov     r11, rcx
     433   %else
     434          mov     r11, rdi
     435   %endif
     436   %define pCpumCpu   r11
     437   %define pXState    r10
     438  %else
     439        push    ebp
     440        mov     ebp, esp
     441        push    ebx
     442        push    esi
     443        mov     ebx, dword [ebp + 8]
     444   %define pCpumCpu ebx
     445   %define pXState  esi
     446  %endif
     447
     448        pushf                           ; The darwin kernel can get upset or upset things if an
     449        cli                             ; interrupt occurs while we're doing fxsave/fxrstor/cr0.
     450        SAVE_CR0_CLEAR_FPU_TRAPS xCX, xAX ; xCX is now old CR0 value, don't use!
     451
     452        CPUMR0_SAVE_HOST
     453
     454        RESTORE_CR0 xCX
     455        or      dword [pCpumCpu + CPUMCPU.fUseFlags], (CPUM_USED_FPU | CPUM_USED_FPU_SINCE_REM)
     456        popf
     457
     458  %ifdef RT_ARCH_X86
     459        pop     esi
     460        pop     ebx
     461        leave
     462  %endif
     463        xor     eax, eax
     464        ret
     465%undef pCpumCpu
     466%undef pXState
     467ENDPROC   cpumR0SaveHostFPUState
     468 %endif
     469%endif
     470
     471
     472;;
     473; Saves the guest FPU/SSE/AVX state and restores the host FPU/SSE/AVX state.
     474;
     475; @returns  VINF_SUCCESS (0) in eax.
     476; @param    pCpumCpu  x86:[ebp+8] gcc:rdi msc:rcx     CPUMCPU pointer
     477;
     478align 16
     479BEGINPROC cpumR0SaveGuestRestoreHostFPUState
    573480        ;
    574481        ; Prologue - xAX+xDX must be free for XSAVE/XRSTOR input.
    … …  
    592499%endif
    593500
     501        ;
     502        ; Only restore FPU if guest has used it.
     503        ;
     504        test    dword [pCpumCpu + CPUMCPU.fUseFlags], CPUM_USED_FPU
     505        jz      .fpu_not_used
     506
    594507        pushf                           ; The darwin kernel can get upset or upset things if an
    595508        cli                             ; interrupt occurs while we're doing fxsave/fxrstor/cr0.
    596509        SAVE_CR0_CLEAR_FPU_TRAPS xCX, xAX ; xCX is now old CR0 value, don't use!
    597510
    598         CPUMR0_SAVE_HOST
     511        CPUMR0_SAVE_GUEST
     512        CPUMR0_LOAD_HOST
    599513
    600514        RESTORE_CR0 xCX
    601         or      dword [pCpumCpu + CPUMCPU.fUseFlags], (CPUM_USED_FPU | CPUM_USED_FPU_SINCE_REM)
     515        and     dword [pCpumCpu + CPUMCPU.fUseFlags], ~CPUM_USED_FPU
    602516        popf
    603517
     518.fpu_not_used:
    604519%ifdef RT_ARCH_X86
    605520        pop     esi
    … …  
    609524        xor     eax, eax
    610525        ret
    611 
    612 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    613 ALIGNCODE(16)
    614 BITS 64
    615 .sixtyfourbit_mode:
    616         ; Save the guest FPU (32-bit or 64-bit), preserves existing broken state. See @bugref{7138}.
    617         o64 fxsave [pXstate]
    618         jmp far [.fpret wrt rip]
    619 .fpret:                                 ; 16:32 Pointer to .the_end.
    620         dd      .done, NAME(SUPR0AbsKernelCS)
    621 BITS 32
    622 %endif
    623526%undef pCpumCpu
    624527%undef pXState
    625 ENDPROC   cpumR0SaveHostFPUState
    626 %endif
    627 %endif
    628 %endif
    629 
    630 
    631 ;;
    632 ; Saves the guest FPU/SSE/AVX state and restores the host FPU/SSE/AVX state.
    633 ;
    634 ; @returns  VINF_SUCCESS (0) in eax.
     528ENDPROC   cpumR0SaveGuestRestoreHostFPUState
     529
     530
     531;;
     532; Restores the host's FPU/SSE/AVX state from pCpumCpu->Host.
     533;
     534; @returns  0
    635535; @param    pCpumCpu  x86:[ebp+8] gcc:rdi msc:rcx     CPUMCPU pointer
    636536;
    637537align 16
    638 BEGINPROC cpumR0SaveGuestRestoreHostFPUState
     538BEGINPROC cpumR0RestoreHostFPUState
    639539        ;
    640540        ; Prologue - xAX+xDX must be free for XSAVE/XRSTOR input.
    … …  
    659559
    660560        ;
    661         ; Only restore FPU if guest has used it.
     561        ; Restore FPU if guest has used it.
    662562        ;
    663563        test    dword [pCpumCpu + CPUMCPU.fUseFlags], CPUM_USED_FPU
    664         jz     .fpu_not_used
     564        jz short .fpu_not_used
    665565
    666566        pushf                           ; The darwin kernel can get upset or upset things if an
    … …  
    668568        SAVE_CR0_CLEAR_FPU_TRAPS xCX, xAX ; xCX is now old CR0 value, don't use!
    669569
    670         CPUMR0_SAVE_GUEST
    671570        CPUMR0_LOAD_HOST
    672571
    … …  
    683582        xor     eax, eax
    684583        ret
    685 %undef pCpumCpu
    686 %undef pXState
    687 ENDPROC   cpumR0SaveGuestRestoreHostFPUState
    688 
    689 
    690 ;;
    691 ; Restores the host's FPU/SSE/AVX state from pCpumCpu->Host.
    692 ;
    693 ; @returns  0
    694 ; @param    pCpumCpu  x86:[ebp+8] gcc:rdi msc:rcx     CPUMCPU pointer
    695 ;
    696 align 16
    697 BEGINPROC cpumR0RestoreHostFPUState
    698         ;
    699         ; Prologue - xAX+xDX must be free for XSAVE/XRSTOR input.
    700         ;
    701 %ifdef RT_ARCH_AMD64
    702  %ifdef RT_OS_WINDOWS
    703         mov     r11, rcx
    704  %else
    705         mov     r11, rdi
    706  %endif
    707  %define pCpumCpu   r11
    708  %define pXState    r10
    709 %else
    710         push    ebp
    711         mov     ebp, esp
    712         push    ebx
    713         push    esi
    714         mov     ebx, dword [ebp + 8]
    715  %define pCpumCpu ebx
    716  %define pXState  esi
    717 %endif
    718 
    719         ;
    720         ; Restore FPU if guest has used it.
    721         ;
    722         test    dword [pCpumCpu + CPUMCPU.fUseFlags], CPUM_USED_FPU
    723         jz short .fpu_not_used
    724 
    725         pushf                           ; The darwin kernel can get upset or upset things if an
    726         cli                             ; interrupt occurs while we're doing fxsave/fxrstor/cr0.
    727         SAVE_CR0_CLEAR_FPU_TRAPS xCX, xAX ; xCX is now old CR0 value, don't use!
    728 
    729         CPUMR0_LOAD_HOST
    730 
    731         RESTORE_CR0 xCX
    732         and     dword [pCpumCpu + CPUMCPU.fUseFlags], ~CPUM_USED_FPU
    733         popf
    734 
    735 .fpu_not_used:
    736 %ifdef RT_ARCH_X86
    737         pop     esi
    738         pop     ebx
    739         leave
    740 %endif
    741         xor     eax, eax
    742         ret
    743584%undef pCpumCPu
    744585%undef pXState
    745586ENDPROC   cpumR0RestoreHostFPUState
    746587
    747 
    748 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    749 ;;
    750 ; DECLASM(void)     cpumR0SaveDRx(uint64_t *pa4Regs);
    751 ;
    752 ALIGNCODE(16)
    753 BEGINPROC cpumR0SaveDRx
    754 %ifdef RT_ARCH_AMD64
    755  %ifdef ASM_CALL64_GCC
    756     mov     xCX, rdi
    757  %endif
    758 %else
    759     mov     xCX, dword [esp + 4]
    760 %endif
    761     pushf                               ; Just to be on the safe side.
    762     cli
    763 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    764     cmp     byte [NAME(g_fCPUMIs64bitHost)], 0
    765     jz      .legacy_mode
    766     db      0xea                        ; jmp far .sixtyfourbit_mode
    767     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    768 .legacy_mode:
    769 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL
    770 
    771     ;
    772     ; Do the job.
    773     ;
    774     mov     xAX, dr0
    775     mov     xDX, dr1
    776     mov     [xCX],         xAX
    777     mov     [xCX + 8 * 1], xDX
    778     mov     xAX, dr2
    779     mov     xDX, dr3
    780     mov     [xCX + 8 * 2], xAX
    781     mov     [xCX + 8 * 3], xDX
    782 
    783 .done:
    784     popf
    785     ret
    786 
    787 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    788 ALIGNCODE(16)
    789 BITS 64
    790 .sixtyfourbit_mode:
    791     and     ecx, 0ffffffffh
    792 
    793     mov     rax, dr0
    794     mov     rdx, dr1
    795     mov     r8,  dr2
    796     mov     r9,  dr3
    797     mov     [rcx],         rax
    798     mov     [rcx + 8 * 1], rdx
    799     mov     [rcx + 8 * 2], r8
    800     mov     [rcx + 8 * 3], r9
    801     jmp far [.fpret wrt rip]
    802 .fpret:                                 ; 16:32 Pointer to .the_end.
    803     dd      .done, NAME(SUPR0AbsKernelCS)
    804 BITS 32
    805 %endif
    806 ENDPROC   cpumR0SaveDRx
    807 
    808 
    809 ;;
    810 ; DECLASM(void)     cpumR0LoadDRx(uint64_t const *pa4Regs);
    811 ;
    812 ALIGNCODE(16)
    813 BEGINPROC cpumR0LoadDRx
    814 %ifdef RT_ARCH_AMD64
    815  %ifdef ASM_CALL64_GCC
    816     mov     xCX, rdi
    817  %endif
    818 %else
    819     mov     xCX, dword [esp + 4]
    820 %endif
    821     pushf                               ; Just to be on the safe side.
    822     cli
    823 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    824     cmp     byte [NAME(g_fCPUMIs64bitHost)], 0
    825     jz      .legacy_mode
    826     db      0xea                        ; jmp far .sixtyfourbit_mode
    827     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    828 .legacy_mode:
    829 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL
    830 
    831     ;
    832     ; Do the job.
    833     ;
    834     mov     xAX, [xCX]
    835     mov     xDX, [xCX + 8 * 1]
    836     mov     dr0, xAX
    837     mov     dr1, xDX
    838     mov     xAX, [xCX + 8 * 2]
    839     mov     xDX, [xCX + 8 * 3]
    840     mov     dr2, xAX
    841     mov     dr3, xDX
    842 
    843 .done:
    844     popf
    845     ret
    846 
    847 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    848 ALIGNCODE(16)
    849 BITS 64
    850 .sixtyfourbit_mode:
    851     and     ecx, 0ffffffffh
    852 
    853     mov     rax, [rcx]
    854     mov     rdx, [rcx + 8 * 1]
    855     mov     r8,  [rcx + 8 * 2]
    856     mov     r9,  [rcx + 8 * 3]
    857     mov     dr0, rax
    858     mov     dr1, rdx
    859     mov     dr2, r8
    860     mov     dr3, r9
    861     jmp far [.fpret wrt rip]
    862 .fpret:                                 ; 16:32 Pointer to .the_end.
    863     dd      .done, NAME(SUPR0AbsKernelCS)
    864 BITS 32
    865 %endif
    866 ENDPROC   cpumR0LoadDRx
    867 
    868 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    869 

  • trunk/src/VBox/VMM/VMMR0/CPUMR0UnusedA.asm

    r54674 r57446  
    3232
    3333
    34 ;*******************************************************************************
    35 ;* External Symbols                                                            *
    36 ;*******************************************************************************
    37 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    38 extern NAME(SUPR0AbsIs64bit)
    39 extern NAME(SUPR0Abs64bitKernelCS)
    40 extern NAME(SUPR0Abs64bitKernelSS)
    41 extern NAME(SUPR0Abs64bitKernelDS)
    42 extern NAME(SUPR0AbsKernelCS)
    43 extern NAME(g_fCPUMIs64bitHost)
    44 %endif
    45 
    4634
    4735;;
    … …  
    6351    mov     xDX, dword [esp + 4]
    6452%endif
    65 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    66     cmp     byte [NAME(g_fCPUMIs64bitHost)], 0
    67     jz      .legacy_mode
    68     db      0xea                        ; jmp far .sixtyfourbit_mode
    69     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    70 .legacy_mode:
    71 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL
    7253
    7354    fxrstor [xDX + CPUMCTX.fpu]
    7455.done:
    7556    ret
    76 
    77 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    78 ALIGNCODE(16)
    79 BITS 64
    80 .sixtyfourbit_mode:
    81     and     edx, 0ffffffffh
    82     fxrstor [rdx + CPUMCTX.fpu]
    83     jmp far [.fpret wrt rip]
    84 .fpret:                                 ; 16:32 Pointer to .the_end.
    85     dd      .done, NAME(SUPR0AbsKernelCS)
    86 BITS 32
    87 %endif
    8857ENDPROC     cpumR0LoadFPU
    8958
    … …  
    10776    mov     xDX, dword [esp + 4]
    10877%endif
    109 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    110     cmp     byte [NAME(g_fCPUMIs64bitHost)], 0
    111     jz      .legacy_mode
    112     db      0xea                        ; jmp far .sixtyfourbit_mode
    113     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    114 .legacy_mode:
    115 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL
    11678    fxsave  [xDX + CPUMCTX.fpu]
    11779.done:
    11880    ret
    119 
    120 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    121 ALIGNCODE(16)
    122 BITS 64
    123 .sixtyfourbit_mode:
    124     and     edx, 0ffffffffh
    125     fxsave  [rdx + CPUMCTX.fpu]
    126     jmp far [.fpret wrt rip]
    127 .fpret:                                 ; 16:32 Pointer to .the_end.
    128     dd      .done, NAME(SUPR0AbsKernelCS)
    129 BITS 32
    130 %endif
    13181ENDPROC cpumR0SaveFPU
    13282
    … …  
    150100    mov     xDX, dword [esp + 4]
    151101%endif
    152 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    153     cmp     byte [NAME(g_fCPUMIs64bitHost)], 0
    154     jz      .legacy_mode
    155     db      0xea                        ; jmp far .sixtyfourbit_mode
    156     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    157 .legacy_mode:
    158 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL
    159102
    160103    movdqa  xmm0, [xDX + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*0]
    … …  
    180123    movdqa  xmm15, [xDX + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*15]
    181124%endif
    182 .done:
    183     ret
    184 
    185 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    186 ALIGNCODE(16)
    187 BITS 64
    188 .sixtyfourbit_mode:
    189     and     edx, 0ffffffffh
    190 
    191     movdqa  xmm0, [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*0]
    192     movdqa  xmm1, [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*1]
    193     movdqa  xmm2, [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*2]
    194     movdqa  xmm3, [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*3]
    195     movdqa  xmm4, [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*4]
    196     movdqa  xmm5, [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*5]
    197     movdqa  xmm6, [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*6]
    198     movdqa  xmm7, [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*7]
    199 
    200     test qword [rdx + CPUMCTX.msrEFER], MSR_K6_EFER_LMA
    201     jz .sixtyfourbit_done
    202 
    203     movdqa  xmm8,  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*8]
    204     movdqa  xmm9,  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*9]
    205     movdqa  xmm10, [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*10]
    206     movdqa  xmm11, [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*11]
    207     movdqa  xmm12, [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*12]
    208     movdqa  xmm13, [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*13]
    209     movdqa  xmm14, [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*14]
    210     movdqa  xmm15, [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*15]
    211 .sixtyfourbit_done:
    212     jmp far [.fpret wrt rip]
    213 .fpret:                                 ; 16:32 Pointer to .the_end.
    214     dd      .done, NAME(SUPR0AbsKernelCS)
    215 BITS 32
    216 %endif
     125
     126.done:
     127    ret
    217128ENDPROC     cpumR0LoadXMM
    218129
    … …  
    236147    mov     xDX, dword [esp + 4]
    237148%endif
    238 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    239     cmp     byte [NAME(g_fCPUMIs64bitHost)], 0
    240     jz      .legacy_mode
    241     db      0xea                        ; jmp far .sixtyfourbit_mode
    242     dd      .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
    243 .legacy_mode:
    244 %endif ; VBOX_WITH_HYBRID_32BIT_KERNEL
    245149
    246150    movdqa  [xDX + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*0], xmm0
    … …  
    265169    movdqa  [xDX + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*14], xmm14
    266170    movdqa  [xDX + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*15], xmm15
    267 
    268 %endif
    269 .done:
    270     ret
    271 
    272 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
    273 ALIGNCODE(16)
    274 BITS 64
    275 .sixtyfourbit_mode:
    276     and     edx, 0ffffffffh
    277 
    278     movdqa  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*0], xmm0
    279     movdqa  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*1], xmm1
    280     movdqa  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*2], xmm2
    281     movdqa  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*3], xmm3
    282     movdqa  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*4], xmm4
    283     movdqa  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*5], xmm5
    284     movdqa  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*6], xmm6
    285     movdqa  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*7], xmm7
    286 
    287     test qword [rdx + CPUMCTX.msrEFER], MSR_K6_EFER_LMA
    288     jz .sixtyfourbit_done
    289 
    290     movdqa  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*8], xmm8
    291     movdqa  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*9], xmm9
    292     movdqa  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*10], xmm10
    293     movdqa  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*11], xmm11
    294     movdqa  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*12], xmm12
    295     movdqa  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*13], xmm13
    296     movdqa  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*14], xmm14
    297     movdqa  [rdx + CPUMCTX.fpu + X86FXSTATE.aXMM + 16*15], xmm15
    298 
    299 .sixtyfourbit_done:
    300     jmp far [.fpret wrt rip]
    301 .fpret:                                 ; 16:32 Pointer to .the_end.
    302     dd      .done, NAME(SUPR0AbsKernelCS)
    303 BITS 32
    304 %endif
     171%endif
     172
     173.done:
     174    ret
    305175ENDPROC     cpumR0SaveXMM
    306176

  • trunk/src/VBox/VMM/VMMR0/TRPMR0.cpp

    r57358 r57446  
    3131
    3232
     33#if defined(RT_OS_DARWIN) && ARCH_BITS == 32
     34# error "32-bit darwin is no longer supported. Go back to 4.3 or earlier!"
     35#endif
     36
     37
    3338/**
    3439 * Dispatches an interrupt that arrived while we were in the guest context.
    … …  
    5762
    5863#else  /* The complicated way: */
    59 
    60 # ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    61     /*
    62      * Check if we're in long mode or not.
    63      */
    64     if (    (ASMCpuId_EDX(0x80000001) & X86_CPUID_EXT_FEATURE_EDX_LONG_MODE)
    65         &&  (ASMRdMsr(MSR_K6_EFER) & MSR_K6_EFER_LMA))
    66     {
    67         trpmR0DispatchHostInterruptSimple(uActiveVector);
    68         return;
    69     }
    70 # endif
    7164
    7265    /*

  • trunk/src/VBox/VMM/VMMR0/VMMR0.cpp

    r57429 r57446  
    6161#  pragma intrinsic(_AddressOfReturnAddress)
    6262#endif
     63
     64#if defined(RT_OS_DARWIN) && ARCH_BITS == 32
     65# error "32-bit darwin is no longer supported. Go back to 4.3 or earlier!"
     66#endif
     67
    6368
    6469

  • trunk/src/VBox/VMM/VMMR3/CPUM.cpp

    r57358 r57446  
    20772077     */
    20782078#if HC_ARCH_BITS == 32
    2079 # ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    2080     if (!(pCtx->efer & MSR_K6_EFER_LMA))
    2081 # endif
    2082     {
    2083         pHlp->pfnPrintf(pHlp,
    2084             "eax=xxxxxxxx ebx=%08x ecx=xxxxxxxx edx=xxxxxxxx esi=%08x edi=%08x\n"
    2085             "eip=xxxxxxxx esp=%08x ebp=%08x iopl=%d %31s\n"
    2086             "cs=%04x ds=%04x es=%04x fs=%04x gs=%04x                       eflags=%08x\n"
    2087             "cr0=%08RX64 cr2=xxxxxxxx cr3=%08RX64 cr4=%08RX64 gdtr=%08x:%04x ldtr=%04x\n"
    2088             "dr[0]=%08RX64 dr[1]=%08RX64x dr[2]=%08RX64 dr[3]=%08RX64x dr[6]=%08RX64 dr[7]=%08RX64\n"
    2089             "SysEnter={cs=%04x eip=%08x esp=%08x}\n"
    2090             ,
    2091             /*pCtx->eax,*/ pCtx->ebx, /*pCtx->ecx, pCtx->edx,*/ pCtx->esi, pCtx->edi,
    2092             /*pCtx->eip,*/ pCtx->esp, pCtx->ebp, X86_EFL_GET_IOPL(efl), szEFlags,
    2093             pCtx->cs, pCtx->ds, pCtx->es, pCtx->fs, pCtx->gs, efl,
    2094             pCtx->cr0, /*pCtx->cr2,*/ pCtx->cr3, pCtx->cr4,
    2095             pCtx->dr0, pCtx->dr1, pCtx->dr2, pCtx->dr3, pCtx->dr6, pCtx->dr7,
    2096             (uint32_t)pCtx->gdtr.uAddr, pCtx->gdtr.cb, pCtx->ldtr,
    2097             pCtx->SysEnter.cs, pCtx->SysEnter.eip, pCtx->SysEnter.esp);
    2098     }
    2099 # ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    2100     else
    2101 # endif
    2102 #endif
    2103 #if HC_ARCH_BITS == 64 || defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
    2104     {
    2105         pHlp->pfnPrintf(pHlp,
    2106             "rax=xxxxxxxxxxxxxxxx rbx=%016RX64 rcx=xxxxxxxxxxxxxxxx\n"
    2107             "rdx=xxxxxxxxxxxxxxxx rsi=%016RX64 rdi=%016RX64\n"
    2108             "rip=xxxxxxxxxxxxxxxx rsp=%016RX64 rbp=%016RX64\n"
    2109             " r8=xxxxxxxxxxxxxxxx  r9=xxxxxxxxxxxxxxxx r10=%016RX64\n"
    2110             "r11=%016RX64 r12=%016RX64 r13=%016RX64\n"
    2111             "r14=%016RX64 r15=%016RX64\n"
    2112             "iopl=%d  %31s\n"
    2113             "cs=%04x  ds=%04x  es=%04x  fs=%04x  gs=%04x                   eflags=%08RX64\n"
    2114             "cr0=%016RX64 cr2=xxxxxxxxxxxxxxxx cr3=%016RX64\n"
    2115             "cr4=%016RX64 ldtr=%04x tr=%04x\n"
    2116             "dr[0]=%016RX64 dr[1]=%016RX64 dr[2]=%016RX64\n"
    2117             "dr[3]=%016RX64 dr[6]=%016RX64 dr[7]=%016RX64\n"
    2118             "gdtr=%016RX64:%04x  idtr=%016RX64:%04x\n"
    2119             "SysEnter={cs=%04x eip=%08x esp=%08x}\n"
    2120             "FSbase=%016RX64 GSbase=%016RX64 efer=%08RX64\n"
    2121             ,
    2122             /*pCtx->rax,*/ pCtx->rbx, /*pCtx->rcx,
    2123             pCtx->rdx,*/ pCtx->rsi, pCtx->rdi,
    2124             /*pCtx->rip,*/ pCtx->rsp, pCtx->rbp,
    2125             /*pCtx->r8,  pCtx->r9,*/  pCtx->r10,
    2126             pCtx->r11, pCtx->r12, pCtx->r13,
    2127             pCtx->r14, pCtx->r15,
    2128             X86_EFL_GET_IOPL(efl), szEFlags,
    2129             pCtx->cs, pCtx->ds, pCtx->es, pCtx->fs, pCtx->gs, efl,
    2130             pCtx->cr0, /*pCtx->cr2,*/ pCtx->cr3,
    2131             pCtx->cr4, pCtx->ldtr, pCtx->tr,
    2132             pCtx->dr0, pCtx->dr1, pCtx->dr2,
    2133             pCtx->dr3, pCtx->dr6, pCtx->dr7,
    2134             pCtx->gdtr.uAddr, pCtx->gdtr.cb, pCtx->idtr.uAddr, pCtx->idtr.cb,
    2135             pCtx->SysEnter.cs, pCtx->SysEnter.eip, pCtx->SysEnter.esp,
    2136             pCtx->FSbase, pCtx->GSbase, pCtx->efer);
    2137     }
     2079    pHlp->pfnPrintf(pHlp,
     2080        "eax=xxxxxxxx ebx=%08x ecx=xxxxxxxx edx=xxxxxxxx esi=%08x edi=%08x\n"
     2081        "eip=xxxxxxxx esp=%08x ebp=%08x iopl=%d %31s\n"
     2082        "cs=%04x ds=%04x es=%04x fs=%04x gs=%04x                       eflags=%08x\n"
     2083        "cr0=%08RX64 cr2=xxxxxxxx cr3=%08RX64 cr4=%08RX64 gdtr=%08x:%04x ldtr=%04x\n"
     2084        "dr[0]=%08RX64 dr[1]=%08RX64x dr[2]=%08RX64 dr[3]=%08RX64x dr[6]=%08RX64 dr[7]=%08RX64\n"
     2085        "SysEnter={cs=%04x eip=%08x esp=%08x}\n"
     2086        ,
     2087        /*pCtx->eax,*/ pCtx->ebx, /*pCtx->ecx, pCtx->edx,*/ pCtx->esi, pCtx->edi,
     2088        /*pCtx->eip,*/ pCtx->esp, pCtx->ebp, X86_EFL_GET_IOPL(efl), szEFlags,
     2089        pCtx->cs, pCtx->ds, pCtx->es, pCtx->fs, pCtx->gs, efl,
     2090        pCtx->cr0, /*pCtx->cr2,*/ pCtx->cr3, pCtx->cr4,
     2091        pCtx->dr0, pCtx->dr1, pCtx->dr2, pCtx->dr3, pCtx->dr6, pCtx->dr7,
     2092        (uint32_t)pCtx->gdtr.uAddr, pCtx->gdtr.cb, pCtx->ldtr,
     2093        pCtx->SysEnter.cs, pCtx->SysEnter.eip, pCtx->SysEnter.esp);
     2094#else
     2095    pHlp->pfnPrintf(pHlp,
     2096        "rax=xxxxxxxxxxxxxxxx rbx=%016RX64 rcx=xxxxxxxxxxxxxxxx\n"
     2097        "rdx=xxxxxxxxxxxxxxxx rsi=%016RX64 rdi=%016RX64\n"
     2098        "rip=xxxxxxxxxxxxxxxx rsp=%016RX64 rbp=%016RX64\n"
     2099        " r8=xxxxxxxxxxxxxxxx  r9=xxxxxxxxxxxxxxxx r10=%016RX64\n"
     2100        "r11=%016RX64 r12=%016RX64 r13=%016RX64\n"
     2101        "r14=%016RX64 r15=%016RX64\n"
     2102        "iopl=%d  %31s\n"
     2103        "cs=%04x  ds=%04x  es=%04x  fs=%04x  gs=%04x                   eflags=%08RX64\n"
     2104        "cr0=%016RX64 cr2=xxxxxxxxxxxxxxxx cr3=%016RX64\n"
     2105        "cr4=%016RX64 ldtr=%04x tr=%04x\n"
     2106        "dr[0]=%016RX64 dr[1]=%016RX64 dr[2]=%016RX64\n"
     2107        "dr[3]=%016RX64 dr[6]=%016RX64 dr[7]=%016RX64\n"
     2108        "gdtr=%016RX64:%04x  idtr=%016RX64:%04x\n"
     2109        "SysEnter={cs=%04x eip=%08x esp=%08x}\n"
     2110        "FSbase=%016RX64 GSbase=%016RX64 efer=%08RX64\n"
     2111        ,
     2112        /*pCtx->rax,*/ pCtx->rbx, /*pCtx->rcx,
     2113        pCtx->rdx,*/ pCtx->rsi, pCtx->rdi,
     2114        /*pCtx->rip,*/ pCtx->rsp, pCtx->rbp,
     2115        /*pCtx->r8,  pCtx->r9,*/  pCtx->r10,
     2116        pCtx->r11, pCtx->r12, pCtx->r13,
     2117        pCtx->r14, pCtx->r15,
     2118        X86_EFL_GET_IOPL(efl), szEFlags,
     2119        pCtx->cs, pCtx->ds, pCtx->es, pCtx->fs, pCtx->gs, efl,
     2120        pCtx->cr0, /*pCtx->cr2,*/ pCtx->cr3,
     2121        pCtx->cr4, pCtx->ldtr, pCtx->tr,
     2122        pCtx->dr0, pCtx->dr1, pCtx->dr2,
     2123        pCtx->dr3, pCtx->dr6, pCtx->dr7,
     2124        pCtx->gdtr.uAddr, pCtx->gdtr.cb, pCtx->idtr.uAddr, pCtx->idtr.cb,
     2125        pCtx->SysEnter.cs, pCtx->SysEnter.eip, pCtx->SysEnter.esp,
     2126        pCtx->FSbase, pCtx->GSbase, pCtx->efer);
    21382127#endif
    21392128}

  • trunk/src/VBox/VMM/VMMR3/PGM.cpp

    r57358 r57446  
    16541654        case SUPPAGINGMODE_AMD64_NX:
    16551655        case SUPPAGINGMODE_AMD64_GLOBAL_NX:
    1656 #ifndef VBOX_WITH_HYBRID_32BIT_KERNEL
    16571656            if (ARCH_BITS != 64)
    16581657            {
    … …  
    16611660                return VERR_PGM_UNSUPPORTED_HOST_PAGING_MODE;
    16621661            }
    1663 #endif
    16641662            break;
    16651663        default:

  • trunk/src/VBox/VMM/include/CPUMInternal.h

    r55466 r57446  
    111111#define CPUM_USE_SUPPORTS_LONGMODE      RT_BIT(20)
    112112/** @} */
    113 
    114 /* Sanity check. */
    115 #ifndef VBOX_FOR_DTRACE_LIB
    116 #if defined(VBOX_WITH_HYBRID_32BIT_KERNEL) && (HC_ARCH_BITS != 32 || R0_ARCH_BITS != 32)
    117 # error "VBOX_WITH_HYBRID_32BIT_KERNEL is only for 32 bit builds."
    118 #endif
    119 #endif
    120113
    121114
    … …  
    202195/**
    203196 * The saved host CPU state.
    204  *
    205  * @remark  The special VBOX_WITH_HYBRID_32BIT_KERNEL checks here are for the 10.4.x series
    206  *          of Mac OS X where the OS is essentially 32-bit but the cpu mode can be 64-bit.
    207197 */
    208198typedef struct CPUMHOSTCTX
    … …  
    210200    /** General purpose register, selectors, flags and more
    211201     * @{ */
    212 #if HC_ARCH_BITS == 64 || defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
     202#if HC_ARCH_BITS == 64
    213203    /** General purpose register ++
    214204     * { */
    … …  
    264254    /** @} */
    265255
    266 #if HC_ARCH_BITS == 32 && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
     256#if HC_ARCH_BITS == 32
    267257    /** Control registers.
    268258     * @{ */
    … …  
    309299    uint8_t         auPadding[20];
    310300
    311 #elif HC_ARCH_BITS == 64 || defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
     301#elif HC_ARCH_BITS == 64
    312302
    313303    /** Control registers.
    … …  
    352342
    353343    /* padding to get 32byte aligned size */
    354 # ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    355     uint8_t         auPadding[52];
    356 # else
    357344    uint8_t         auPadding[4];
    358 # endif
    359345
    360346#else
    361 # error HC_ARCH_BITS not defined
     347# error HC_ARCH_BITS not defined or unsupported
    362348#endif
    363349
    … …  
    558544DECLASM(void)       cpumR0SetMXCSR(uint32_t u32MXCSR);
    559545DECLASM(uint32_t)   cpumR0GetMXCSR(void);
    560 DECLASM(void)       cpumR0LoadDRx(uint64_t const *pa4Regs);
    561 DECLASM(void)       cpumR0SaveDRx(uint64_t *pa4Regs);
    562546#endif
    563547

  • trunk/src/VBox/VMM/include/CPUMInternal.mac

    r56286 r57446  
    6363%define CPUM_HANDLER_CTXCORE_IN_EBP     RT_BIT(31)
    6464
    65 
    66 ;; if anyone figures how to do %if HC_ARCH_BITS == 64 || defined(VBOX_WITH_HYBRID_32BIT_KERNEL) in
    67 ; nasm please tell / fix this hack.
    68 %ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
    69  %define fVBOX_WITH_HYBRID_32BIT_KERNEL 1
    70 %else
    71  %define fVBOX_WITH_HYBRID_32BIT_KERNEL 0
    72 %endif
    7365
    7466struc CPUM
    … …  
    249241    alignb 64
    250242    .Host                resb    0
    251 %if HC_ARCH_BITS == 64 || fVBOX_WITH_HYBRID_32BIT_KERNEL
     243%if HC_ARCH_BITS == 64
    252244    ;.Host.rax            resq    1 - scratch
    253245    .Host.rbx            resq    1
    … …  
    295287    .Host.csPadding      resw    1
    296288
    297 %if HC_ARCH_BITS == 32 && fVBOX_WITH_HYBRID_32BIT_KERNEL == 0
     289%if HC_ARCH_BITS == 32
    298290    .Host.cr0            resd    1
    299291    ;.Host.cr2            resd    1 - scratch
    … …  
    354346    .Host.GSbase         resq    1
    355347    .Host.efer           resq    1
    356  %if fVBOX_WITH_HYBRID_32BIT_KERNEL
    357     .Host.auPadding      resb    54
    358  %else
    359348    .Host.auPadding      resb    4
    360  %endif
    361349%endif ; 64-bit
    362350    .Host.pXStateRC RTRCPTR_RES  1

  • trunk/src/VBox/VMM/include/HMInternal.h

    r57429 r57446  
    3333#include <iprt/avl.h>
    3434#include <iprt/string.h>
     35
     36#if defined(RT_OS_DARWIN) && HC_ARCH_BITS == 32
     37# error "32-bit darwin is no longer supported. Go back to 4.3 or earlier!"
     38#endif
    3539
    3640#if HC_ARCH_BITS == 64 || defined (VBOX_WITH_64_BITS_GUESTS)

  • trunk/src/VBox/VMM/include/HMInternal.mac

    r56287 r57446  
    33; HM - Internal header file.
    44;
     5
    56;
    67; Copyright (C) 2006-2015 Oracle Corporation
    … …  
    1617
    1718%if HC_ARCH_BITS == 32
    18  %ifndef VBOX_WITH_HYBRID_32BIT_KERNEL
    19   %define VMX_USE_CACHED_VMCS_ACCESSES
    20  %endif
     19 %define VMX_USE_CACHED_VMCS_ACCESSES
    2120%endif
    2221

  • trunk/src/VBox/VMM/include/PGMInternal.h

    r56384 r57446  
    6868 * manages the page tables for intermediate switcher context, that's all done in
    6969 * ring-3.
    70  *
    71  * On 32-bit darwin (hybrid kernel) we do 64-bit guest support differently, so
    72  * there we can safely work without mappings if we don't compile in raw-mode.
    7370 */
    7471#if defined(IN_RING0) \
    7572  || (   !defined(VBOX_WITH_RAW_MODE) \
    7673      && (   HC_ARCH_BITS != 32 \
    77           || defined(VBOX_WITH_HYBRID_32BIT_KERNEL) \
    7874          || !defined(VBOX_WITH_64_BITS_GUESTS) \
    7975         ) \

  • trunk/src/VBox/VMM/include/VMMInternal.h

    r56287 r57446  
    2929# error "Not in VMM! This is an internal header!"
    3030#endif
     31#if defined(RT_OS_DARWIN) && HC_ARCH_BITS == 32
     32# error "32-bit darwin is no longer supported. Go back to 4.3 or earlier!"
     33#endif
     34
    3135
    3236

  • trunk/src/VBox/VMM/testcase/Makefile.kmk

    r56749 r57446  
    146146 tstVMStructRC_TEMPLATE  = VBoxRcExe
    147147 tstVMStructRC_DEFS      = IN_VMM_RC IN_DIS IN_RT_RC VBOX_WITH_RAW_MODE
    148  ifeq ($(KBUILD_TARGET).$(KBUILD_TARGET_ARCH),darwin.x86)
    149   tstVMStructRC_DEFS    += \
    150         VBOX_WITH_2X_4GB_ADDR_SPACE   VBOX_WITH_2X_4GB_ADDR_SPACE_IN_RC \
    151         VBOX_WITH_HYBRID_32BIT_KERNEL VBOX_WITH_HYBRID_32BIT_KERNEL_IN_RC
    152  endif
    153148 ifdef VBOX_WITH_R0_LOGGING
    154149  tstVMStructRC_DEFS    += VBOX_WITH_R0_LOGGING
    … …  
    165160tstVMStructSize_TEMPLATE= VBOXR3AUTOTST
    166161tstVMStructSize_DEFS    = IN_VMM_R3 IN_DIS
    167 ifeq ($(KBUILD_TARGET).$(KBUILD_TARGET_ARCH),darwin.x86)
    168  tstVMStructSize_DEFS   += \
    169         VBOX_WITH_2X_4GB_ADDR_SPACE   VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R3 \
    170         VBOX_WITH_HYBRID_32BIT_KERNEL VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R3
    171 endif
    172162ifdef VBOX_WITH_RAW_MODE
    173163 tstVMStructSize_DEFS  += VBOX_WITH_RAW_MODE
    … …  
    478468 tstVMStructDTrace_TEMPLATE= VBOXR3AUTOTST
    479469 tstVMStructDTrace_DEFS    = IN_VMM_R3 IN_DIS
    480  ifeq ($(KBUILD_TARGET).$(KBUILD_TARGET_ARCH),darwin.x86)
    481   tstVMStructDTrace_DEFS  += \
    482         VBOX_WITH_2X_4GB_ADDR_SPACE   VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R3 \
    483         VBOX_WITH_HYBRID_32BIT_KERNEL VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R3
    484  endif
    485470 ifdef VBOX_WITH_RAW_MODE
    486471  tstVMStructDTrace_DEFS  += VBOX_WITH_RAW_MODE
Note: See TracChangeset for help on using the changeset viewer.

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