VirtualBox

Changeset 80050 in vbox


Ignore:
Timestamp:
Jul 29, 2019 8:04:35 PM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
132487
Message:

Main: Kicking out raw-mode - CPUM*Hyper*(). bugref:9517

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed

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

    r79576 r80050  
    14371437VMMDECL(bool)          CPUMSetGuestCpuIdPerCpuApicFeature(PVMCPU pVCpu, bool fVisible);
    14381438VMMDECL(void)          CPUMSetGuestCtx(PVMCPU pVCpu, const PCPUMCTX pCtx);
    1439 VMM_INT_DECL(void)     CPUMGuestLazyLoadHiddenCsAndSs(PVMCPU pVCpu);
    1440 VMM_INT_DECL(void)     CPUMGuestLazyLoadHiddenSelectorReg(PVMCPU pVCpu, PCPUMSELREG pSReg);
    14411439VMM_INT_DECL(void)     CPUMSetGuestTscAux(PVMCPU pVCpu, uint64_t uValue);
    14421440VMM_INT_DECL(uint64_t) CPUMGetGuestTscAux(PVMCPU pVCpu);
    … …  
    24812479/** @name Hypervisor Register Getters.
    24822480 * @{ */
    2483 VMMDECL(RTSEL)          CPUMGetHyperCS(PVMCPU pVCpu);
    2484 VMMDECL(RTSEL)          CPUMGetHyperDS(PVMCPU pVCpu);
    2485 VMMDECL(RTSEL)          CPUMGetHyperES(PVMCPU pVCpu);
    2486 VMMDECL(RTSEL)          CPUMGetHyperFS(PVMCPU pVCpu);
    2487 VMMDECL(RTSEL)          CPUMGetHyperGS(PVMCPU pVCpu);
    2488 VMMDECL(RTSEL)          CPUMGetHyperSS(PVMCPU pVCpu);
    2489 #if 0 /* these are not correct. */
    2490 VMMDECL(uint32_t)       CPUMGetHyperCR0(PVMCPU pVCpu);
    2491 VMMDECL(uint32_t)       CPUMGetHyperCR2(PVMCPU pVCpu);
    2492 VMMDECL(uint32_t)       CPUMGetHyperCR3(PVMCPU pVCpu);
    2493 VMMDECL(uint32_t)       CPUMGetHyperCR4(PVMCPU pVCpu);
    2494 #endif
    2495 /** This register is only saved on fatal traps. */
    2496 VMMDECL(uint32_t)       CPUMGetHyperEAX(PVMCPU pVCpu);
    2497 VMMDECL(uint32_t)       CPUMGetHyperEBX(PVMCPU pVCpu);
    2498 /** This register is only saved on fatal traps. */
    2499 VMMDECL(uint32_t)       CPUMGetHyperECX(PVMCPU pVCpu);
    2500 /** This register is only saved on fatal traps. */
    2501 VMMDECL(uint32_t)       CPUMGetHyperEDX(PVMCPU pVCpu);
    2502 VMMDECL(uint32_t)       CPUMGetHyperESI(PVMCPU pVCpu);
    2503 VMMDECL(uint32_t)       CPUMGetHyperEDI(PVMCPU pVCpu);
    2504 VMMDECL(uint32_t)       CPUMGetHyperEBP(PVMCPU pVCpu);
    2505 VMMDECL(uint32_t)       CPUMGetHyperESP(PVMCPU pVCpu);
    2506 VMMDECL(uint32_t)       CPUMGetHyperEFlags(PVMCPU pVCpu);
    2507 VMMDECL(uint32_t)       CPUMGetHyperEIP(PVMCPU pVCpu);
    2508 VMMDECL(uint64_t)       CPUMGetHyperRIP(PVMCPU pVCpu);
    2509 VMMDECL(uint32_t)       CPUMGetHyperIDTR(PVMCPU pVCpu, uint16_t *pcbLimit);
    2510 VMMDECL(uint32_t)       CPUMGetHyperGDTR(PVMCPU pVCpu, uint16_t *pcbLimit);
    2511 VMMDECL(RTSEL)          CPUMGetHyperLDTR(PVMCPU pVCpu);
    25122481VMMDECL(RTGCUINTREG)    CPUMGetHyperDR0(PVMCPU pVCpu);
    25132482VMMDECL(RTGCUINTREG)    CPUMGetHyperDR1(PVMCPU pVCpu);
    … …  
    25162485VMMDECL(RTGCUINTREG)    CPUMGetHyperDR6(PVMCPU pVCpu);
    25172486VMMDECL(RTGCUINTREG)    CPUMGetHyperDR7(PVMCPU pVCpu);
    2518 VMMDECL(void)           CPUMGetHyperCtx(PVMCPU pVCpu, PCPUMCTX pCtx);
    25192487VMMDECL(uint32_t)       CPUMGetHyperCR3(PVMCPU pVCpu);
    25202488/** @} */
    … …  
    25222490/** @name Hypervisor Register Setters.
    25232491 * @{ */
    2524 VMMDECL(void)           CPUMSetHyperGDTR(PVMCPU pVCpu, uint32_t addr, uint16_t limit);
    2525 VMMDECL(void)           CPUMSetHyperLDTR(PVMCPU pVCpu, RTSEL SelLDTR);
    2526 VMMDECL(void)           CPUMSetHyperIDTR(PVMCPU pVCpu, uint32_t addr, uint16_t limit);
    25272492VMMDECL(void)           CPUMSetHyperCR3(PVMCPU pVCpu, uint32_t cr3);
    2528 VMMDECL(void)           CPUMSetHyperTR(PVMCPU pVCpu, RTSEL SelTR);
    2529 VMMDECL(void)           CPUMSetHyperCS(PVMCPU pVCpu, RTSEL SelCS);
    2530 VMMDECL(void)           CPUMSetHyperDS(PVMCPU pVCpu, RTSEL SelDS);
    2531 VMMDECL(void)           CPUMSetHyperES(PVMCPU pVCpu, RTSEL SelDS);
    2532 VMMDECL(void)           CPUMSetHyperFS(PVMCPU pVCpu, RTSEL SelDS);
    2533 VMMDECL(void)           CPUMSetHyperGS(PVMCPU pVCpu, RTSEL SelDS);
    2534 VMMDECL(void)           CPUMSetHyperSS(PVMCPU pVCpu, RTSEL SelSS);
    25352493VMMDECL(void)           CPUMSetHyperESP(PVMCPU pVCpu, uint32_t u32ESP);
    2536 VMMDECL(int)            CPUMSetHyperEFlags(PVMCPU pVCpu, uint32_t Efl);
    25372494VMMDECL(void)           CPUMSetHyperEIP(PVMCPU pVCpu, uint32_t u32EIP);
    2538 VMM_INT_DECL(void)      CPUMSetHyperState(PVMCPU pVCpu, uint32_t u32EIP, uint32_t u32ESP, uint32_t u32EAX, uint32_t u32EDX);
    25392495VMMDECL(void)           CPUMSetHyperDR0(PVMCPU pVCpu, RTGCUINTREG uDr0);
    25402496VMMDECL(void)           CPUMSetHyperDR1(PVMCPU pVCpu, RTGCUINTREG uDr1);
    … …  
    25482504
    25492505VMMDECL(void)           CPUMPushHyper(PVMCPU pVCpu, uint32_t u32);
    2550 VMMDECL(int)            CPUMQueryHyperCtxPtr(PVMCPU pVCpu, PCPUMCTX *ppCtx);
    2551 VMMDECL(PCPUMCTX)       CPUMGetHyperCtxPtr(PVMCPU pVCpu);
    2552 VMMDECL(PCCPUMCTXCORE)  CPUMGetHyperCtxCore(PVMCPU pVCpu);
    25532506VMMDECL(PCPUMCTX)       CPUMQueryGuestCtxPtr(PVMCPU pVCpu);
    25542507VMM_INT_DECL(PCPUMCTXMSRS) CPUMQueryGuestCtxMsrsPtr(PVMCPU pVCpu);

  • trunk/src/VBox/Debugger/testcase/tstDBGCStubs.cpp

    r79164 r80050  
    644644}
    645645
    646 VMMDECL(RTSEL) CPUMGetHyperCS(PVMCPU pVCpu)
    647 {
    648     return 0xfff8;
    649 }
    650 
    651 VMMDECL(uint32_t) CPUMGetHyperEIP(PVMCPU pVCpu)
    652 {
    653     return 0;
    654 }
    655 
    656646VMMDECL(PCPUMCTX) CPUMQueryGuestCtxPtr(PVMCPU pVCpu)
    657647{

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

    r80024 r80050  
    7171 * Lazily loads the hidden parts of a selector register when using raw-mode.
    7272 */
    73 #if defined(VBOX_WITH_RAW_MODE) && !defined(IN_RING0)
    74 # define CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(a_pVCpu, a_pSReg) \
    75     do \
    76     { \
    77         if (!CPUMSELREG_ARE_HIDDEN_PARTS_VALID(a_pVCpu, a_pSReg)) \
    78             cpumGuestLazyLoadHiddenSelectorReg(a_pVCpu, a_pSReg); \
    79     } while (0)
    80 #else
    81 # define CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(a_pVCpu, a_pSReg) \
    82     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(a_pVCpu, a_pSReg));
    83 #endif
     73#define CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(a_pVCpu, a_pSReg) \
     74    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(a_pVCpu, a_pSReg))
    8475
    8576/** @def CPUM_INT_ASSERT_NOT_EXTRN
    … …  
    9283    AssertMsg(!((a_pVCpu)->cpum.s.Guest.fExtrn & (a_fNotExtrn)), \
    9384              ("%#RX64; a_fNotExtrn=%#RX64\n", (a_pVCpu)->cpum.s.Guest.fExtrn, (a_fNotExtrn)))
    94 
    95 
    96 
    97 
    98 #ifdef VBOX_WITH_RAW_MODE_NOT_R0
    99 
    100 /**
    101  * Does the lazy hidden selector register loading.
    102  *
    103  * @param   pVCpu       The cross context virtual CPU structure of the calling EMT.
    104  * @param   pSReg       The selector register to lazily load hidden parts of.
    105  */
    106 static void cpumGuestLazyLoadHiddenSelectorReg(PVMCPU pVCpu, PCPUMSELREG pSReg)
    107 {
    108     Assert(!CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, pSReg));
    109     Assert(VM_IS_RAW_MODE_ENABLED(pVCpu->CTX_SUFF(pVM)));
    110     Assert((uintptr_t)(pSReg - &pVCpu->cpum.s.Guest.es) < X86_SREG_COUNT);
    111 
    112     if (pVCpu->cpum.s.Guest.eflags.Bits.u1VM)
    113     {
    114         /* V8086 mode - Tightly controlled environment, no question about the limit or flags. */
    115         pSReg->Attr.u               = 0;
    116         pSReg->Attr.n.u4Type        = pSReg == &pVCpu->cpum.s.Guest.cs ? X86_SEL_TYPE_ER_ACC : X86_SEL_TYPE_RW_ACC;
    117         pSReg->Attr.n.u1DescType    = 1; /* code/data segment */
    118         pSReg->Attr.n.u2Dpl         = 3;
    119         pSReg->Attr.n.u1Present     = 1;
    120         pSReg->u32Limit             = 0x0000ffff;
    121         pSReg->u64Base              = (uint32_t)pSReg->Sel << 4;
    122         pSReg->ValidSel             = pSReg->Sel;
    123         pSReg->fFlags               = CPUMSELREG_FLAGS_VALID;
    124         /** @todo Check what the accessed bit should be (VT-x and AMD-V). */
    125     }
    126     else if (!(pVCpu->cpum.s.Guest.cr0 & X86_CR0_PE))
    127     {
    128         /* Real mode - leave the limit and flags alone here, at least for now. */
    129         pSReg->u64Base              = (uint32_t)pSReg->Sel << 4;
    130         pSReg->ValidSel             = pSReg->Sel;
    131         pSReg->fFlags               = CPUMSELREG_FLAGS_VALID;
    132     }
    133     else
    134     {
    135         /* Protected mode - get it from the selector descriptor tables. */
    136         if (!(pSReg->Sel & X86_SEL_MASK_OFF_RPL))
    137         {
    138             Assert(!CPUMIsGuestInLongMode(pVCpu));
    139             pSReg->Sel              = 0;
    140             pSReg->u64Base          = 0;
    141             pSReg->u32Limit         = 0;
    142             pSReg->Attr.u           = 0;
    143             pSReg->ValidSel         = 0;
    144             pSReg->fFlags           = CPUMSELREG_FLAGS_VALID;
    145             /** @todo see todo in iemHlpLoadNullDataSelectorProt. */
    146         }
    147         else
    148             SELMLoadHiddenSelectorReg(pVCpu, &pVCpu->cpum.s.Guest, pSReg);
    149     }
    150 }
    151 
    152 
    153 /**
    154  * Makes sure the hidden CS and SS selector registers are valid, loading them if
    155  * necessary.
    156  *
    157  * @param   pVCpu               The cross context virtual CPU structure of the calling EMT.
    158  */
    159 VMM_INT_DECL(void) CPUMGuestLazyLoadHiddenCsAndSs(PVMCPU pVCpu)
    160 {
    161     CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(pVCpu, &pVCpu->cpum.s.Guest.cs);
    162     CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(pVCpu, &pVCpu->cpum.s.Guest.ss);
    163 }
    164 
    165 
    166 /**
    167  * Loads a the hidden parts of a selector register.
    168  *
    169  * @param   pVCpu       The cross context virtual CPU structure of the calling EMT.
    170  * @param   pSReg       The selector register to lazily load hidden parts of.
    171  */
    172 VMM_INT_DECL(void) CPUMGuestLazyLoadHiddenSelectorReg(PVMCPU pVCpu, PCPUMSELREG pSReg)
    173 {
    174     CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(pVCpu, pSReg);
    175 }
    176 
    177 #endif /* VBOX_WITH_RAW_MODE_NOT_R0 */
    178 
    179 
    180 /**
    181  * Obsolete.
    182  *
    183  * We don't support nested hypervisor context interrupts or traps.  Life is much
    184  * simpler when we don't.  It's also slightly faster at times.
    185  *
    186  * @param   pVCpu       The cross context virtual CPU structure.
    187  */
    188 VMMDECL(PCCPUMCTXCORE) CPUMGetHyperCtxCore(PVMCPU pVCpu)
    189 {
    190     return CPUMCTX2CORE(&pVCpu->cpum.s.Hyper);
    191 }
    192 
    193 
    194 /**
    195  * Gets the pointer to the hypervisor CPU context structure of a virtual CPU.
    196  *
    197  * @param   pVCpu       The cross context virtual CPU structure.
    198  */
    199 VMMDECL(PCPUMCTX) CPUMGetHyperCtxPtr(PVMCPU pVCpu)
    200 {
    201     return &pVCpu->cpum.s.Hyper;
    202 }
    203 
    204 
    205 VMMDECL(void) CPUMSetHyperGDTR(PVMCPU pVCpu, uint32_t addr, uint16_t limit)
    206 {
    207     pVCpu->cpum.s.Hyper.gdtr.cbGdt = limit;
    208     pVCpu->cpum.s.Hyper.gdtr.pGdt  = addr;
    209 }
    210 
    211 
    212 VMMDECL(void) CPUMSetHyperIDTR(PVMCPU pVCpu, uint32_t addr, uint16_t limit)
    213 {
    214     pVCpu->cpum.s.Hyper.idtr.cbIdt = limit;
    215     pVCpu->cpum.s.Hyper.idtr.pIdt  = addr;
    216 }
    21785
    21886
    … …  
    233101
    234102
    235 VMMDECL(void) CPUMSetHyperCS(PVMCPU pVCpu, RTSEL SelCS)
    236 {
    237     pVCpu->cpum.s.Hyper.cs.Sel = SelCS;
    238 }
    239 
    240 
    241 VMMDECL(void) CPUMSetHyperDS(PVMCPU pVCpu, RTSEL SelDS)
    242 {
    243     pVCpu->cpum.s.Hyper.ds.Sel = SelDS;
    244 }
    245 
    246 
    247 VMMDECL(void) CPUMSetHyperES(PVMCPU pVCpu, RTSEL SelES)
    248 {
    249     pVCpu->cpum.s.Hyper.es.Sel = SelES;
    250 }
    251 
    252 
    253 VMMDECL(void) CPUMSetHyperFS(PVMCPU pVCpu, RTSEL SelFS)
    254 {
    255     pVCpu->cpum.s.Hyper.fs.Sel = SelFS;
    256 }
    257 
    258 
    259 VMMDECL(void) CPUMSetHyperGS(PVMCPU pVCpu, RTSEL SelGS)
    260 {
    261     pVCpu->cpum.s.Hyper.gs.Sel = SelGS;
    262 }
    263 
    264 
    265 VMMDECL(void) CPUMSetHyperSS(PVMCPU pVCpu, RTSEL SelSS)
    266 {
    267     pVCpu->cpum.s.Hyper.ss.Sel = SelSS;
    268 }
    269 
    270 
    271103VMMDECL(void) CPUMSetHyperESP(PVMCPU pVCpu, uint32_t u32ESP)
    272104{
    … …  
    275107
    276108
    277 VMMDECL(void) CPUMSetHyperEDX(PVMCPU pVCpu, uint32_t u32ESP)
    278 {
    279     pVCpu->cpum.s.Hyper.esp = u32ESP;
    280 }
    281 
    282 
    283 VMMDECL(int) CPUMSetHyperEFlags(PVMCPU pVCpu, uint32_t Efl)
    284 {
    285     pVCpu->cpum.s.Hyper.eflags.u32 = Efl;
    286     return VINF_SUCCESS;
    287 }
    288 
    289 
    290109VMMDECL(void) CPUMSetHyperEIP(PVMCPU pVCpu, uint32_t u32EIP)
    291110{
    292111    pVCpu->cpum.s.Hyper.eip = u32EIP;
    293 }
    294 
    295 
    296 /**
    297  * Used by VMMR3RawRunGC to reinitialize the general raw-mode context registers,
    298  * EFLAGS and EIP prior to resuming guest execution.
    299  *
    300  * All general register not given as a parameter will be set to 0.  The EFLAGS
    301  * register will be set to sane values for C/C++ code execution with interrupts
    302  * disabled and IOPL 0.
    303  *
    304  * @param   pVCpu               The cross context virtual CPU structure of the calling EMT.
    305  * @param   u32EIP              The EIP value.
    306  * @param   u32ESP              The ESP value.
    307  * @param   u32EAX              The EAX value.
    308  * @param   u32EDX              The EDX value.
    309  */
    310 VMM_INT_DECL(void) CPUMSetHyperState(PVMCPU pVCpu, uint32_t u32EIP, uint32_t u32ESP, uint32_t u32EAX, uint32_t u32EDX)
    311 {
    312     pVCpu->cpum.s.Hyper.eip      = u32EIP;
    313     pVCpu->cpum.s.Hyper.esp      = u32ESP;
    314     pVCpu->cpum.s.Hyper.eax      = u32EAX;
    315     pVCpu->cpum.s.Hyper.edx      = u32EDX;
    316     pVCpu->cpum.s.Hyper.ecx      = 0;
    317     pVCpu->cpum.s.Hyper.ebx      = 0;
    318     pVCpu->cpum.s.Hyper.ebp      = 0;
    319     pVCpu->cpum.s.Hyper.esi      = 0;
    320     pVCpu->cpum.s.Hyper.edi      = 0;
    321     pVCpu->cpum.s.Hyper.eflags.u = X86_EFL_1;
    322 }
    323 
    324 
    325 VMMDECL(void) CPUMSetHyperTR(PVMCPU pVCpu, RTSEL SelTR)
    326 {
    327     pVCpu->cpum.s.Hyper.tr.Sel = SelTR;
    328 }
    329 
    330 
    331 VMMDECL(void) CPUMSetHyperLDTR(PVMCPU pVCpu, RTSEL SelLDTR)
    332 {
    333     pVCpu->cpum.s.Hyper.ldtr.Sel = SelLDTR;
    334112}
    335113
    … …  
    408186
    409187
    410 VMMDECL(RTSEL) CPUMGetHyperCS(PVMCPU pVCpu)
    411 {
    412     return pVCpu->cpum.s.Hyper.cs.Sel;
    413 }
    414 
    415 
    416 VMMDECL(RTSEL) CPUMGetHyperDS(PVMCPU pVCpu)
    417 {
    418     return pVCpu->cpum.s.Hyper.ds.Sel;
    419 }
    420 
    421 
    422 VMMDECL(RTSEL) CPUMGetHyperES(PVMCPU pVCpu)
    423 {
    424     return pVCpu->cpum.s.Hyper.es.Sel;
    425 }
    426 
    427 
    428 VMMDECL(RTSEL) CPUMGetHyperFS(PVMCPU pVCpu)
    429 {
    430     return pVCpu->cpum.s.Hyper.fs.Sel;
    431 }
    432 
    433 
    434 VMMDECL(RTSEL) CPUMGetHyperGS(PVMCPU pVCpu)
    435 {
    436     return pVCpu->cpum.s.Hyper.gs.Sel;
    437 }
    438 
    439 
    440 VMMDECL(RTSEL) CPUMGetHyperSS(PVMCPU pVCpu)
    441 {
    442     return pVCpu->cpum.s.Hyper.ss.Sel;
    443 }
    444 
    445 
    446 VMMDECL(uint32_t) CPUMGetHyperEAX(PVMCPU pVCpu)
    447 {
    448     return pVCpu->cpum.s.Hyper.eax;
    449 }
    450 
    451 
    452 VMMDECL(uint32_t) CPUMGetHyperEBX(PVMCPU pVCpu)
    453 {
    454     return pVCpu->cpum.s.Hyper.ebx;
    455 }
    456 
    457 
    458 VMMDECL(uint32_t) CPUMGetHyperECX(PVMCPU pVCpu)
    459 {
    460     return pVCpu->cpum.s.Hyper.ecx;
    461 }
    462 
    463 
    464 VMMDECL(uint32_t) CPUMGetHyperEDX(PVMCPU pVCpu)
    465 {
    466     return pVCpu->cpum.s.Hyper.edx;
    467 }
    468 
    469 
    470 VMMDECL(uint32_t) CPUMGetHyperESI(PVMCPU pVCpu)
    471 {
    472     return pVCpu->cpum.s.Hyper.esi;
    473 }
    474 
    475 
    476 VMMDECL(uint32_t) CPUMGetHyperEDI(PVMCPU pVCpu)
    477 {
    478     return pVCpu->cpum.s.Hyper.edi;
    479 }
    480 
    481 
    482 VMMDECL(uint32_t) CPUMGetHyperEBP(PVMCPU pVCpu)
    483 {
    484     return pVCpu->cpum.s.Hyper.ebp;
    485 }
    486 
    487 
    488 VMMDECL(uint32_t) CPUMGetHyperESP(PVMCPU pVCpu)
    489 {
    490     return pVCpu->cpum.s.Hyper.esp;
    491 }
    492 
    493 
    494 VMMDECL(uint32_t) CPUMGetHyperEFlags(PVMCPU pVCpu)
    495 {
    496     return pVCpu->cpum.s.Hyper.eflags.u32;
    497 }
    498 
    499 
    500 VMMDECL(uint32_t) CPUMGetHyperEIP(PVMCPU pVCpu)
    501 {
    502     return pVCpu->cpum.s.Hyper.eip;
    503 }
    504 
    505 
    506 VMMDECL(uint64_t) CPUMGetHyperRIP(PVMCPU pVCpu)
    507 {
    508     return pVCpu->cpum.s.Hyper.rip;
    509 }
    510 
    511 
    512 VMMDECL(uint32_t) CPUMGetHyperIDTR(PVMCPU pVCpu, uint16_t *pcbLimit)
    513 {
    514     if (pcbLimit)
    515         *pcbLimit = pVCpu->cpum.s.Hyper.idtr.cbIdt;
    516     return pVCpu->cpum.s.Hyper.idtr.pIdt;
    517 }
    518 
    519 
    520 VMMDECL(uint32_t) CPUMGetHyperGDTR(PVMCPU pVCpu, uint16_t *pcbLimit)
    521 {
    522     if (pcbLimit)
    523         *pcbLimit = pVCpu->cpum.s.Hyper.gdtr.cbGdt;
    524     return pVCpu->cpum.s.Hyper.gdtr.pGdt;
    525 }
    526 
    527 
    528 VMMDECL(RTSEL) CPUMGetHyperLDTR(PVMCPU pVCpu)
    529 {
    530     return pVCpu->cpum.s.Hyper.ldtr.Sel;
    531 }
    532 
    533 
    534188VMMDECL(RTGCUINTREG) CPUMGetHyperDR0(PVMCPU pVCpu)
    535189{
    … …  
    658312VMMDECL(int) CPUMSetGuestCR0(PVMCPU pVCpu, uint64_t cr0)
    659313{
    660 #ifdef IN_RC
    661     /*
    662      * Check if we need to change hypervisor CR0 because
    663      * of math stuff.
    664      */
    665     if (    (cr0                     & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP))
    666         !=  (pVCpu->cpum.s.Guest.cr0 & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP)))
    667     {
    668         if (!(pVCpu->cpum.s.fUseFlags & CPUM_USED_FPU_GUEST))
    669         {
    670             /*
    671              * We haven't loaded the guest FPU state yet, so TS and MT are both set
    672              * and EM should be reflecting the guest EM (it always does this).
    673              */
    674             if ((cr0 & X86_CR0_EM) != (pVCpu->cpum.s.Guest.cr0 & X86_CR0_EM))
    675             {
    676                 uint32_t HyperCR0 = ASMGetCR0();
    677                 AssertMsg((HyperCR0 & (X86_CR0_TS | X86_CR0_MP)) == (X86_CR0_TS | X86_CR0_MP), ("%#x\n", HyperCR0));
    678                 AssertMsg((HyperCR0 & X86_CR0_EM) == (pVCpu->cpum.s.Guest.cr0 & X86_CR0_EM), ("%#x\n", HyperCR0));
    679                 HyperCR0 &= ~X86_CR0_EM;
    680                 HyperCR0 |= cr0 & X86_CR0_EM;
    681                 Log(("CPUM: New HyperCR0=%#x\n", HyperCR0));
    682                 ASMSetCR0(HyperCR0);
    683             }
    684 # ifdef VBOX_STRICT
    685             else
    686             {
    687                 uint32_t HyperCR0 = ASMGetCR0();
    688                 AssertMsg((HyperCR0 & (X86_CR0_TS | X86_CR0_MP)) == (X86_CR0_TS | X86_CR0_MP), ("%#x\n", HyperCR0));
    689                 AssertMsg((HyperCR0 & X86_CR0_EM) == (pVCpu->cpum.s.Guest.cr0 & X86_CR0_EM), ("%#x\n", HyperCR0));
    690             }
    691 # endif
    692         }
    693         else
    694         {
    695             /*
    696              * Already loaded the guest FPU state, so we're just mirroring
    697              * the guest flags.
    698              */
    699             uint32_t HyperCR0 = ASMGetCR0();
    700             AssertMsg(     (HyperCR0                 & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP))
    701                       ==   (pVCpu->cpum.s.Guest.cr0  & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP)),
    702                       ("%#x %#x\n", HyperCR0, pVCpu->cpum.s.Guest.cr0));
    703             HyperCR0 &= ~(X86_CR0_TS | X86_CR0_EM | X86_CR0_MP);
    704             HyperCR0 |= cr0 & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP);
    705             Log(("CPUM: New HyperCR0=%#x\n", HyperCR0));
    706             ASMSetCR0(HyperCR0);
    707         }
    708     }
    709 #endif /* IN_RC */
    710 
    711314    /*
    712315     * Check for changes causing TLB flushes (for REM).
    … …  
    16321235    const RTGCUINTREG uDbgfDr7 = DBGFBpGetDR7(pVM);
    16331236
     1237    /** @todo r=bird: I'm totally confused by fForceHyper! */
    16341238#ifdef IN_RING0
    16351239    if (!fForceHyper && (pVCpu->cpum.s.fUseFlags & CPUM_USED_DEBUG_REGS_HYPER))
    16361240        fForceHyper = true;
    16371241#endif
    1638     if (  (!VM_IS_RAW_MODE_ENABLED(pVCpu->CTX_SUFF(pVM)) && !fForceHyper ? uDbgfDr7 : (uGstDr7 | uDbgfDr7))
    1639         & X86_DR7_ENABLED_MASK)
     1242    if ((!fForceHyper ? uDbgfDr7 : (uGstDr7 | uDbgfDr7)) & X86_DR7_ENABLED_MASK)
    16401243    {
    16411244        Assert(!CPUMIsGuestDebugStateActive(pVCpu));
    1642 #ifdef IN_RC
    1643         bool const fRawModeEnabled = true;
    1644 #elif defined(IN_RING3)
    1645         bool const fRawModeEnabled = VM_IS_RAW_MODE_ENABLED(pVM);
    1646 #endif
    16471245
    16481246        /*
    … …  
    16631261        {
    16641262            uNewDr0 = CPUMGetGuestDR0(pVCpu);
    1665 #ifndef IN_RING0
    1666             if (fRawModeEnabled && MMHyperIsInsideArea(pVM, uNewDr0))
    1667                 uNewDr0 = 0;
    1668             else
    1669 #endif
    1670                 uNewDr7 |= uGstDr7 & (X86_DR7_L0 | X86_DR7_G0 | X86_DR7_RW0_MASK | X86_DR7_LEN0_MASK);
     1263            uNewDr7 |= uGstDr7 & (X86_DR7_L0 | X86_DR7_G0 | X86_DR7_RW0_MASK | X86_DR7_LEN0_MASK);
    16711264        }
    16721265        else
    … …  
    16831276        {
    16841277            uNewDr1 = CPUMGetGuestDR1(pVCpu);
    1685 #ifndef IN_RING0
    1686             if (fRawModeEnabled && MMHyperIsInsideArea(pVM, uNewDr1))
    1687                 uNewDr1 = 0;
    1688             else
    1689 #endif
    1690                 uNewDr7 |= uGstDr7 & (X86_DR7_L1 | X86_DR7_G1 | X86_DR7_RW1_MASK | X86_DR7_LEN1_MASK);
     1278            uNewDr7 |= uGstDr7 & (X86_DR7_L1 | X86_DR7_G1 | X86_DR7_RW1_MASK | X86_DR7_LEN1_MASK);
    16911279        }
    16921280        else
    … …  
    17031291        {
    17041292            uNewDr2 = CPUMGetGuestDR2(pVCpu);
    1705 #ifndef IN_RING0
    1706             if (fRawModeEnabled && MMHyperIsInsideArea(pVM, uNewDr2))
    1707                 uNewDr2 = 0;
    1708             else
    1709 #endif
    1710                 uNewDr7 |= uGstDr7 & (X86_DR7_L2 | X86_DR7_G2 | X86_DR7_RW2_MASK | X86_DR7_LEN2_MASK);
     1293            uNewDr7 |= uGstDr7 & (X86_DR7_L2 | X86_DR7_G2 | X86_DR7_RW2_MASK | X86_DR7_LEN2_MASK);
    17111294        }
    17121295        else
    … …  
    17231306        {
    17241307            uNewDr3 = CPUMGetGuestDR3(pVCpu);
    1725 #ifndef IN_RING0
    1726             if (fRawModeEnabled && MMHyperIsInsideArea(pVM, uNewDr3))
    1727                 uNewDr3 = 0;
    1728             else
    1729 #endif
    1730                 uNewDr7 |= uGstDr7 & (X86_DR7_L3 | X86_DR7_G3 | X86_DR7_RW3_MASK | X86_DR7_LEN3_MASK);
     1308            uNewDr7 |= uGstDr7 & (X86_DR7_L3 | X86_DR7_G3 | X86_DR7_RW3_MASK | X86_DR7_LEN3_MASK);
    17311309        }
    17321310        else
    … …  
    17361314         * Apply the updates.
    17371315         */
    1738 #ifdef IN_RC
    1739         /* Make sure to save host registers first. */
    1740         if (!(pVCpu->cpum.s.fUseFlags & CPUM_USED_DEBUG_REGS_HOST))
    1741         {
    1742             if (!(pVCpu->cpum.s.fUseFlags & CPUM_USE_DEBUG_REGS_HOST))
    1743             {
    1744                 pVCpu->cpum.s.Host.dr6 = ASMGetDR6();
    1745                 pVCpu->cpum.s.Host.dr7 = ASMGetDR7();
    1746             }
    1747             pVCpu->cpum.s.Host.dr0 = ASMGetDR0();
    1748             pVCpu->cpum.s.Host.dr1 = ASMGetDR1();
    1749             pVCpu->cpum.s.Host.dr2 = ASMGetDR2();
    1750             pVCpu->cpum.s.Host.dr3 = ASMGetDR3();
    1751             pVCpu->cpum.s.fUseFlags |= CPUM_USED_DEBUG_REGS_HOST | CPUM_USE_DEBUG_REGS_HYPER | CPUM_USED_DEBUG_REGS_HYPER;
    1752 
    1753             /* We haven't loaded any hyper DRxes yet, so we'll have to load them all now. */
    1754             pVCpu->cpum.s.Hyper.dr[0] = uNewDr0;
    1755             ASMSetDR0(uNewDr0);
    1756             pVCpu->cpum.s.Hyper.dr[1] = uNewDr1;
    1757             ASMSetDR1(uNewDr1);
    1758             pVCpu->cpum.s.Hyper.dr[2] = uNewDr2;
    1759             ASMSetDR2(uNewDr2);
    1760             pVCpu->cpum.s.Hyper.dr[3] = uNewDr3;
    1761             ASMSetDR3(uNewDr3);
    1762             ASMSetDR6(X86_DR6_INIT_VAL);
    1763             pVCpu->cpum.s.Hyper.dr[7] = uNewDr7;
    1764             ASMSetDR7(uNewDr7);
    1765         }
    1766         else
    1767 #endif
    1768         {
    1769             pVCpu->cpum.s.fUseFlags |= CPUM_USE_DEBUG_REGS_HYPER;
    1770             if (uNewDr3 != pVCpu->cpum.s.Hyper.dr[3])
    1771                 CPUMSetHyperDR3(pVCpu, uNewDr3);
    1772             if (uNewDr2 != pVCpu->cpum.s.Hyper.dr[2])
    1773                 CPUMSetHyperDR2(pVCpu, uNewDr2);
    1774             if (uNewDr1 != pVCpu->cpum.s.Hyper.dr[1])
    1775                 CPUMSetHyperDR1(pVCpu, uNewDr1);
    1776             if (uNewDr0 != pVCpu->cpum.s.Hyper.dr[0])
    1777                 CPUMSetHyperDR0(pVCpu, uNewDr0);
    1778             if (uNewDr7 != pVCpu->cpum.s.Hyper.dr[7])
    1779                 CPUMSetHyperDR7(pVCpu, uNewDr7);
    1780         }
     1316        pVCpu->cpum.s.fUseFlags |= CPUM_USE_DEBUG_REGS_HYPER;
     1317        if (uNewDr3 != pVCpu->cpum.s.Hyper.dr[3])
     1318            CPUMSetHyperDR3(pVCpu, uNewDr3);
     1319        if (uNewDr2 != pVCpu->cpum.s.Hyper.dr[2])
     1320            CPUMSetHyperDR2(pVCpu, uNewDr2);
     1321        if (uNewDr1 != pVCpu->cpum.s.Hyper.dr[1])
     1322            CPUMSetHyperDR1(pVCpu, uNewDr1);
     1323        if (uNewDr0 != pVCpu->cpum.s.Hyper.dr[0])
     1324            CPUMSetHyperDR0(pVCpu, uNewDr0);
     1325        if (uNewDr7 != pVCpu->cpum.s.Hyper.dr[7])
     1326            CPUMSetHyperDR7(pVCpu, uNewDr7);
    17811327    }
    17821328#ifdef IN_RING0

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

    r76553 r80050  
    676676 * @interface_method_impl{DBGFREGDESC,pfnGet}
    677677 */
    678 static DECLCALLBACK(int) cpumR3RegHyperGet_crX(void *pvUser, PCDBGFREGDESC pDesc, PDBGFREGVAL pValue)
    679 {
    680     PVMCPU pVCpu = (PVMCPU)pvUser;
    681     VMCPU_ASSERT_EMT(pVCpu);
    682 
    683     uint64_t u64Value;
    684     switch (pDesc->offRegister)
    685     {
    686         case 0: u64Value = UINT64_MAX; break;
    687         case 2: u64Value = UINT64_MAX; break;
    688         case 3: u64Value = CPUMGetHyperCR3(pVCpu); break;
    689         case 4: u64Value = UINT64_MAX; break;
    690         case 8: u64Value = UINT64_MAX; break;
    691         default:
    692             AssertFailedReturn(VERR_IPE_NOT_REACHED_DEFAULT_CASE);
    693     }
    694     switch (pDesc->enmType)
    695     {
    696         case DBGFREGVALTYPE_U64:    pValue->u64 = u64Value; break;
    697         case DBGFREGVALTYPE_U32:    pValue->u32 = (uint32_t)u64Value; break;
    698         default:
    699             AssertFailedReturn(VERR_IPE_NOT_REACHED_DEFAULT_CASE);
    700     }
    701     return VINF_SUCCESS;
    702 }
    703 
    704 
    705 /**
    706  * @interface_method_impl{DBGFREGDESC,pfnGet}
    707  */
    708 static DECLCALLBACK(int) cpumR3RegHyperSet_crX(void *pvUser, PCDBGFREGDESC pDesc, PCDBGFREGVAL pValue, PCDBGFREGVAL pfMask)
    709 {
    710     /* Not settable, prevents killing your host. */
    711     NOREF(pvUser); NOREF(pDesc); NOREF(pValue); NOREF(pfMask);
    712     return VERR_ACCESS_DENIED;
    713 }
    714 
    715 
    716 /**
    717  * @interface_method_impl{DBGFREGDESC,pfnGet}
    718  */
    719678static DECLCALLBACK(int) cpumR3RegHyperGet_drX(void *pvUser, PCDBGFREGDESC pDesc, PDBGFREGVAL pValue)
    720679{
    … …  
    751710{
    752711    /* Not settable, prevents killing your host. */
    753     NOREF(pvUser); NOREF(pDesc); NOREF(pValue); NOREF(pfMask);
    754     return VERR_ACCESS_DENIED;
    755 }
    756 
    757 
    758 /**
    759  * @interface_method_impl{DBGFREGDESC,pfnGet}
    760  */
    761 static DECLCALLBACK(int) cpumR3RegHyperGet_msr(void *pvUser, PCDBGFREGDESC pDesc, PDBGFREGVAL pValue)
    762 {
    763     NOREF(pvUser);
    764 
    765     /* Not availble at present, return all FFs to keep things quiet */
    766     uint64_t u64Value = UINT64_MAX;
    767     switch (pDesc->enmType)
    768     {
    769         case DBGFREGVALTYPE_U64:    pValue->u64 = u64Value; break;
    770         case DBGFREGVALTYPE_U32:    pValue->u32 = (uint32_t)u64Value; break;
    771         case DBGFREGVALTYPE_U16:    pValue->u16 = (uint16_t)u64Value; break;
    772         default:
    773             AssertFailedReturn(VERR_IPE_NOT_REACHED_DEFAULT_CASE);
    774     }
    775     return VINF_SUCCESS;
    776 }
    777 
    778 
    779 /**
    780  * @interface_method_impl{DBGFREGDESC,pfnGet}
    781  */
    782 static DECLCALLBACK(int) cpumR3RegHyperSet_msr(void *pvUser, PCDBGFREGDESC pDesc, PCDBGFREGVAL pValue, PCDBGFREGVAL pfMask)
    783 {
    784     /* Not settable, return failure. */
    785712    NOREF(pvUser); NOREF(pDesc); NOREF(pValue); NOREF(pfMask);
    786713    return VERR_ACCESS_DENIED;
    … …  
    13641291static DBGFREGDESC const g_aCpumRegHyperDescs[] =
    13651292{
    1366 #define CPU_REG_RW_AS(a_szName, a_RegSuff, a_TypeSuff, a_CpumCtxMemb, a_pfnGet, a_pfnSet, a_paAliases, a_paSubFields) \
    1367     { a_szName, DBGFREG_##a_RegSuff, DBGFREGVALTYPE_##a_TypeSuff, 0 /*fFlags*/,            RT_OFFSETOF(CPUMCPU, Hyper.a_CpumCtxMemb), a_pfnGet, a_pfnSet, a_paAliases, a_paSubFields }
    1368 #define CPU_REG_RO_AS(a_szName, a_RegSuff, a_TypeSuff, a_CpumCtxMemb, a_pfnGet, a_pfnSet, a_paAliases, a_paSubFields) \
    1369     { a_szName, DBGFREG_##a_RegSuff, DBGFREGVALTYPE_##a_TypeSuff, DBGFREG_FLAGS_READ_ONLY, RT_OFFSETOF(CPUMCPU, Hyper.a_CpumCtxMemb), a_pfnGet, a_pfnSet, a_paAliases, a_paSubFields }
    1370 #define CPU_REG_DUMMY(a_szName, a_RegSuff, a_TypeSuff) \
    1371     { a_szName, DBGFREG_##a_RegSuff, DBGFREGVALTYPE_##a_TypeSuff, DBGFREG_FLAGS_READ_ONLY, 0, cpumR3RegGet_Dummy, cpumR3RegSet_Dummy, NULL, NULL}
    1372 #define CPU_REG_MSR(a_szName, UName, a_TypeSuff, a_paSubFields) \
    1373     CPU_REG_EX_AS(a_szName,         MSR_##UName,    a_TypeSuff, MSR_##UName,    cpumR3RegHyperGet_msr,  cpumR3RegHyperSet_msr,  NULL,                       a_paSubFields)
    1374 
    1375     CPU_REG_REG(RAX, rax),
    1376     CPU_REG_REG(RCX, rcx),
    1377     CPU_REG_REG(RDX, rdx),
    1378     CPU_REG_REG(RBX, rbx),
    1379     CPU_REG_REG(RSP, rsp),
    1380     CPU_REG_REG(RBP, rbp),
    1381     CPU_REG_REG(RSI, rsi),
    1382     CPU_REG_REG(RDI, rdi),
    1383     CPU_REG_REG(R8,   r8),
    1384     CPU_REG_REG(R9,   r9),
    1385     CPU_REG_REG(R10, r10),
    1386     CPU_REG_REG(R11, r11),
    1387     CPU_REG_REG(R12, r12),
    1388     CPU_REG_REG(R13, r13),
    1389     CPU_REG_REG(R14, r14),
    1390     CPU_REG_REG(R15, r15),
    1391     CPU_REG_SEG(CS, cs),
    1392     CPU_REG_SEG(DS, ds),
    1393     CPU_REG_SEG(ES, es),
    1394     CPU_REG_SEG(FS, fs),
    1395     CPU_REG_SEG(GS, gs),
    1396     CPU_REG_SEG(SS, ss),
    1397     CPU_REG_REG(RIP, rip),
    1398     CPU_REG_RW_AS("rflags",         RFLAGS,         U64, rflags,                cpumR3RegGet_Generic,   cpumR3RegSet_Generic,   g_aCpumRegAliases_rflags,   g_aCpumRegFields_rflags ),
    1399     CPU_REG_DUMMY("fcw",            FCW,            U16),
    1400     CPU_REG_DUMMY("fsw",            FSW,            U16),
    1401     CPU_REG_DUMMY("ftw",            FTW,            U16),
    1402     CPU_REG_DUMMY("fop",            FOP,            U16),
    1403     CPU_REG_DUMMY("fpuip",          FPUIP,          U32),
    1404     CPU_REG_DUMMY("fpucs",          FPUCS,          U16),
    1405     CPU_REG_DUMMY("fpudp",          FPUDP,          U32),
    1406     CPU_REG_DUMMY("fpuds",          FPUDS,          U16),
    1407     CPU_REG_DUMMY("mxcsr",          MXCSR,          U32),
    1408     CPU_REG_DUMMY("mxcsr_mask",     MXCSR_MASK,     U32),
    1409     CPU_REG_DUMMY("st0",            ST0,            R80),
    1410     CPU_REG_DUMMY("st1",            ST1,            R80),
    1411     CPU_REG_DUMMY("st2",            ST2,            R80),
    1412     CPU_REG_DUMMY("st3",            ST3,            R80),
    1413     CPU_REG_DUMMY("st4",            ST4,            R80),
    1414     CPU_REG_DUMMY("st5",            ST5,            R80),
    1415     CPU_REG_DUMMY("st6",            ST6,            R80),
    1416     CPU_REG_DUMMY("st7",            ST7,            R80),
    1417     CPU_REG_DUMMY("mm0",            MM0,            U64),
    1418     CPU_REG_DUMMY("mm1",            MM1,            U64),
    1419     CPU_REG_DUMMY("mm2",            MM2,            U64),
    1420     CPU_REG_DUMMY("mm3",            MM3,            U64),
    1421     CPU_REG_DUMMY("mm4",            MM4,            U64),
    1422     CPU_REG_DUMMY("mm5",            MM5,            U64),
    1423     CPU_REG_DUMMY("mm6",            MM6,            U64),
    1424     CPU_REG_DUMMY("mm7",            MM7,            U64),
    1425     CPU_REG_DUMMY("xmm0",           XMM0,           U128),
    1426     CPU_REG_DUMMY("xmm1",           XMM1,           U128),
    1427     CPU_REG_DUMMY("xmm2",           XMM2,           U128),
    1428     CPU_REG_DUMMY("xmm3",           XMM3,           U128),
    1429     CPU_REG_DUMMY("xmm4",           XMM4,           U128),
    1430     CPU_REG_DUMMY("xmm5",           XMM5,           U128),
    1431     CPU_REG_DUMMY("xmm6",           XMM6,           U128),
    1432     CPU_REG_DUMMY("xmm7",           XMM7,           U128),
    1433     CPU_REG_DUMMY("xmm8",           XMM8,           U128),
    1434     CPU_REG_DUMMY("xmm9",           XMM9,           U128),
    1435     CPU_REG_DUMMY("xmm10",          XMM10,          U128),
    1436     CPU_REG_DUMMY("xmm11",          XMM11,          U128),
    1437     CPU_REG_DUMMY("xmm12",          XMM12,          U128),
    1438     CPU_REG_DUMMY("xmm13",          XMM13,          U128),
    1439     CPU_REG_DUMMY("xmm14",          XMM14,          U128),
    1440     CPU_REG_DUMMY("xmm15",          XMM15,          U128),
    1441     CPU_REG_DUMMY("ymm0",           YMM0,           U256),
    1442     CPU_REG_DUMMY("ymm1",           YMM1,           U256),
    1443     CPU_REG_DUMMY("ymm2",           YMM2,           U256),
    1444     CPU_REG_DUMMY("ymm3",           YMM3,           U256),
    1445     CPU_REG_DUMMY("ymm4",           YMM4,           U256),
    1446     CPU_REG_DUMMY("ymm5",           YMM5,           U256),
    1447     CPU_REG_DUMMY("ymm6",           YMM6,           U256),
    1448     CPU_REG_DUMMY("ymm7",           YMM7,           U256),
    1449     CPU_REG_DUMMY("ymm8",           YMM8,           U256),
    1450     CPU_REG_DUMMY("ymm9",           YMM9,           U256),
    1451     CPU_REG_DUMMY("ymm10",          YMM10,          U256),
    1452     CPU_REG_DUMMY("ymm11",          YMM11,          U256),
    1453     CPU_REG_DUMMY("ymm12",          YMM12,          U256),
    1454     CPU_REG_DUMMY("ymm13",          YMM13,          U256),
    1455     CPU_REG_DUMMY("ymm14",          YMM14,          U256),
    1456     CPU_REG_DUMMY("ymm15",          YMM15,          U256),
    1457     CPU_REG_RW_AS("gdtr_base",      GDTR_BASE,      U64, gdtr.pGdt,             cpumR3RegGet_Generic,   cpumR3RegSet_Generic,   NULL,                       NULL                    ),
    1458     CPU_REG_RW_AS("gdtr_lim",       GDTR_LIMIT,     U16, gdtr.cbGdt,            cpumR3RegGet_Generic,   cpumR3RegSet_Generic,   NULL,                       NULL                    ),
    1459     CPU_REG_RW_AS("idtr_base",      IDTR_BASE,      U64, idtr.pIdt,             cpumR3RegGet_Generic,   cpumR3RegSet_Generic,   NULL,                       NULL                    ),
    1460     CPU_REG_RW_AS("idtr_lim",       IDTR_LIMIT,     U16, idtr.cbIdt,            cpumR3RegGet_Generic,   cpumR3RegSet_Generic,   NULL,                       NULL                    ),
    1461     CPU_REG_SEG(LDTR, ldtr),
    1462     CPU_REG_SEG(TR, tr),
    1463     CPU_REG_EX_AS("cr0",            CR0,            U32, 0,                     cpumR3RegHyperGet_crX,  cpumR3RegHyperSet_crX,  g_aCpumRegAliases_cr0,      g_aCpumRegFields_cr0    ),
    1464     CPU_REG_EX_AS("cr2",            CR2,            U64, 2,                     cpumR3RegHyperGet_crX,  cpumR3RegHyperSet_crX,  NULL,                       NULL                    ),
    1465     CPU_REG_EX_AS("cr3",            CR3,            U64, 3,                     cpumR3RegHyperGet_crX,  cpumR3RegHyperSet_crX,  NULL,                       g_aCpumRegFields_cr3    ),
    1466     CPU_REG_EX_AS("cr4",            CR4,            U32, 4,                     cpumR3RegHyperGet_crX,  cpumR3RegHyperSet_crX,  NULL,                       g_aCpumRegFields_cr4    ),
    1467     CPU_REG_EX_AS("cr8",            CR8,            U32, 8,                     cpumR3RegHyperGet_crX,  cpumR3RegHyperSet_crX,  NULL,                       NULL                    ),
    14681293    CPU_REG_EX_AS("dr0",            DR0,            U64, 0,                     cpumR3RegHyperGet_drX,  cpumR3RegHyperSet_drX,  NULL,                       NULL                    ),
    14691294    CPU_REG_EX_AS("dr1",            DR1,            U64, 1,                     cpumR3RegHyperGet_drX,  cpumR3RegHyperSet_drX,  NULL,                       NULL                    ),
    … …  
    14721297    CPU_REG_EX_AS("dr6",            DR6,            U32, 6,                     cpumR3RegHyperGet_drX,  cpumR3RegHyperSet_drX,  NULL,                       g_aCpumRegFields_dr6    ),
    14731298    CPU_REG_EX_AS("dr7",            DR7,            U32, 7,                     cpumR3RegHyperGet_drX,  cpumR3RegHyperSet_drX,  NULL,                       g_aCpumRegFields_dr7    ),
    1474     CPU_REG_MSR("apic_base",     IA32_APICBASE,     U32, g_aCpumRegFields_apic_base  ),
    1475     CPU_REG_MSR("pat",           IA32_CR_PAT,       U64, g_aCpumRegFields_cr_pat     ),
    1476     CPU_REG_MSR("perf_status",   IA32_PERF_STATUS,  U64, g_aCpumRegFields_perf_status),
    1477     CPU_REG_MSR("sysenter_cs",   IA32_SYSENTER_CS,  U16, NULL                        ),
    1478     CPU_REG_MSR("sysenter_eip",  IA32_SYSENTER_EIP, U32, NULL                        ),
    1479     CPU_REG_MSR("sysenter_esp",  IA32_SYSENTER_ESP, U32, NULL                        ),
    1480     CPU_REG_MSR("tsc",           IA32_TSC,          U32, NULL                        ),
    1481     CPU_REG_MSR("efer",          K6_EFER,           U32, g_aCpumRegFields_efer       ),
    1482     CPU_REG_MSR("star",          K6_STAR,           U64, g_aCpumRegFields_star       ),
    1483     CPU_REG_MSR("cstar",         K8_CSTAR,          U64, g_aCpumRegFields_cstar      ),
    1484     CPU_REG_MSR("msr_fs_base",   K8_FS_BASE,        U64, NULL                        ),
    1485     CPU_REG_MSR("msr_gs_base",   K8_GS_BASE,        U64, NULL                        ),
    1486     CPU_REG_MSR("krnl_gs_base",  K8_KERNEL_GS_BASE, U64, NULL                        ),
    1487     CPU_REG_MSR("lstar",         K8_LSTAR,          U64, g_aCpumRegFields_lstar      ),
    1488     CPU_REG_MSR("sf_mask",       K8_SF_MASK,        U64, NULL                        ),
    1489     CPU_REG_MSR("tsc_aux",       K8_TSC_AUX,        U64, NULL                        ),
    1490     CPU_REG_EX_AS("ah",             AH,             U8,  RT_OFFSETOF(CPUMCPU, Hyper.rax) + 1, cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL,             NULL                    ),
    1491     CPU_REG_EX_AS("ch",             CH,             U8,  RT_OFFSETOF(CPUMCPU, Hyper.rcx) + 1, cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL,             NULL                    ),
    1492     CPU_REG_EX_AS("dh",             DH,             U8,  RT_OFFSETOF(CPUMCPU, Hyper.rdx) + 1, cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL,             NULL                    ),
    1493     CPU_REG_EX_AS("bh",             BH,             U8,  RT_OFFSETOF(CPUMCPU, Hyper.rbx) + 1, cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL,             NULL                    ),
    1494     CPU_REG_RW_AS("gdtr",           GDTR,           DTR, gdtr,                  cpumR3RegGet_gdtr,        cpumR3RegSet_gdtr,    NULL,                       NULL                    ),
    1495     CPU_REG_RW_AS("idtr",           IDTR,           DTR, idtr,                  cpumR3RegGet_idtr,        cpumR3RegSet_idtr,    NULL,                       NULL                    ),
    14961299    DBGFREGDESC_TERMINATOR()
    1497 #undef CPU_REG_RW_AS
    1498 #undef CPU_REG_RO_AS
    1499 #undef CPU_REG_MSR
    1500 #undef CPU_REG_ST
    15011300};
    15021301

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

    r76553 r80050  
    13541354     * Read the instruction.
    13551355     */
    1356     bool     fIsHyper = dbgfR3FigureEventCtx(pVM) == DBGFEVENTCTX_HYPER;
    13571356    size_t   cbRead   = 0;
    13581357    uint8_t  abOpcode[16] = { 0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 0 };
    1359     int rc = PGMR3DbgReadGCPtr(pVM, abOpcode, !fIsHyper ? CPUMGetGuestFlatPC(pVCpu) : CPUMGetHyperRIP(pVCpu),
    1360                                sizeof(abOpcode) - 1, 0 /*fFlags*/, &cbRead);
     1358    int rc = PGMR3DbgReadGCPtr(pVM, abOpcode, CPUMGetGuestFlatPC(pVCpu), sizeof(abOpcode) - 1, 0 /*fFlags*/, &cbRead);
    13611359    if (RT_SUCCESS(rc))
    13621360    {
    … …  
    14071405                case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47:
    14081406                case 0x48: case 0x49: case 0x4a: case 0x4b: case 0x4c: case 0x4d: case 0x4e: case 0x4f:
    1409                     if (fIsHyper) /* ASSUMES 32-bit raw-mode! */
    1410                         return DBGFSTEPINSTRTYPE_OTHER;
    14111407                    if (!CPUMIsGuestIn64BitCode(pVCpu))
    14121408                        return DBGFSTEPINSTRTYPE_OTHER;
    … …  
    14641460                if (pVM->dbgf.s.SteppingFilter.fFlags & (DBGF_STEP_F_STOP_ON_ADDRESS | DBGF_STEP_F_STOP_ON_STACK_POP))
    14651461                {
    1466                     bool fIsHyper = dbgfR3FigureEventCtx(pVM) == DBGFEVENTCTX_HYPER;
    14671462                    if (   (pVM->dbgf.s.SteppingFilter.fFlags & DBGF_STEP_F_STOP_ON_ADDRESS)
    1468                         && pVM->dbgf.s.SteppingFilter.AddrPc == (!fIsHyper ? CPUMGetGuestFlatPC(pVCpu) : CPUMGetHyperRIP(pVCpu)))
     1463                        && pVM->dbgf.s.SteppingFilter.AddrPc == CPUMGetGuestFlatPC(pVCpu))
    14691464                        return true;
    14701465                    if (   (pVM->dbgf.s.SteppingFilter.fFlags & DBGF_STEP_F_STOP_ON_STACK_POP)
    1471                         &&     (!fIsHyper ? CPUMGetGuestFlatSP(pVCpu) : (uint64_t)CPUMGetHyperESP(pVCpu))
    1472                              - pVM->dbgf.s.SteppingFilter.AddrStackPop
     1466                        &&   CPUMGetGuestFlatSP(pVCpu) - pVM->dbgf.s.SteppingFilter.AddrStackPop
    14731467                           < pVM->dbgf.s.SteppingFilter.cbStackPop)
    14741468                        return true;

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

    r80003 r80050  
    351351             * assisted virtualization mode, thus the different messages.
    352352             */
    353             uint32_t        uEIP       = CPUMGetHyperEIP(pVCpu);
     353            uint32_t        uEIP       = 0; //CPUMGetHyperEIP(pVCpu);
    354354            TRPMEVENT       enmType;
    355355            uint8_t         u8TrapNo   =       0xce;
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