VirtualBox

Changeset 35513 in vbox for trunk/src/VBox/VMM


Ignore:
Timestamp:
Jan 12, 2011 5:50:43 PM (14 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
69396
Message:

DBGFReg: long double -> RTFLOAT80U2. Get floating point registers and stuff.

Location:
trunk/src/VBox/VMM/VMMR3
Files:
2 edited

Legend:

Unmodified
Added
Removed

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

    r35490 r35513  
    397397}
    398398
     399
     400/**
     401 * Is the FPU state in FXSAVE format or not.
     402 *
     403 * @returns true if it is, false if it's in FNSAVE.
     404 * @param   pVCpu               The virtual CPU handle.
     405 */
     406DECLINLINE(bool) cpumR3RegIsFxSaveFormat(PVMCPU pVCpu)
     407{
     408#ifdef RT_ARCH_AMD64
     409    return true;
     410#else
     411    return pVCpu->pVMR3->cpum.s.CPUFeatures.edx.u1FXSR;
     412#endif
     413}
     414
     415
     416/**
     417 * Determins the tag register value for a CPU register when the FPU state
     418 * format is FXSAVE.
     419 *
     420 * @returns The tag register value.
     421 * @param   pVCpu               The virtual CPU handle.
     422 * @param   iReg                The register number (0..7).
     423 */
     424DECLINLINE(uint16_t) cpumR3RegCalcFpuTagFromFxSave(PVMCPU pVCpu, unsigned iReg)
     425{
     426    /*
     427     * See table 11-1 in the AMD docs.
     428     */
     429    if (!(pVCpu->cpum.s.Guest.fpu.FTW & RT_BIT_32(iReg)))
     430        return 3; /* b11 - empty */
     431
     432    uint16_t const uExp  = pVCpu->cpum.s.Guest.fpu.aRegs[iReg].au16[4];
     433    if (uExp == 0)
     434    {
     435        if (pVCpu->cpum.s.Guest.fpu.aRegs[iReg].au64[0] == 0) /* J & M == 0 */
     436            return 1; /* b01 - zero */
     437        return 2; /* b10 - special */
     438    }
     439
     440    if (uExp == UINT16_C(0xffff))
     441        return 2; /* b10 - special */
     442
     443    if (!(pVCpu->cpum.s.Guest.fpu.aRegs[iReg].au64[0] >> 63)) /* J == 0 */
     444        return 2; /* b10 - special */
     445
     446    return 0; /* b00 - valid (normal) */
     447}
     448
     449
    399450/**
    400451 * @interface_method_impl{DBGFREGDESC, pfnGet}
    … …  
    402453static DECLCALLBACK(int) cpumR3RegGet_ftw(void *pvUser, PCDBGFREGDESC pDesc, PDBGFREGVAL pValue)
    403454{
    404     return VERR_NOT_IMPLEMENTED;
    405 }
     455    PVMCPU      pVCpu   = (PVMCPU)pvUser;
     456    void const *pv      = (uint8_t const *)&pVCpu->cpum.s.Guest + pDesc->offRegister;
     457
     458    VMCPU_ASSERT_EMT(pVCpu);
     459    Assert(pDesc->enmType == DBGFREGVALTYPE_U16);
     460
     461    if (cpumR3RegIsFxSaveFormat(pVCpu))
     462        pValue->u16 =  cpumR3RegCalcFpuTagFromFxSave(pVCpu, 0)
     463                    | (cpumR3RegCalcFpuTagFromFxSave(pVCpu, 1) <<  2)
     464                    | (cpumR3RegCalcFpuTagFromFxSave(pVCpu, 2) <<  4)
     465                    | (cpumR3RegCalcFpuTagFromFxSave(pVCpu, 3) <<  6)
     466                    | (cpumR3RegCalcFpuTagFromFxSave(pVCpu, 4) <<  8)
     467                    | (cpumR3RegCalcFpuTagFromFxSave(pVCpu, 5) << 10)
     468                    | (cpumR3RegCalcFpuTagFromFxSave(pVCpu, 6) << 12)
     469                    | (cpumR3RegCalcFpuTagFromFxSave(pVCpu, 7) << 14);
     470    else
     471    {
     472        PCX86FPUSTATE pOldFpu = (PCX86FPUSTATE)&pVCpu->cpum.s.Guest.fpu;
     473        pValue->u16 = pOldFpu->FTW;
     474    }
     475    return VINF_SUCCESS;
     476}
     477
    406478
    407479/**
    … …  
    410482static DECLCALLBACK(int) cpumR3RegSet_ftw(void *pvUser, PCDBGFREGDESC pDesc, PCDBGFREGVAL pValue, PCDBGFREGVAL pfMask)
    411483{
    412     return VERR_NOT_IMPLEMENTED;
    413 }
     484    return VERR_DBGF_READ_ONLY_REGISTER;
     485}
     486
    414487
    415488/**
    … …  
    418491static DECLCALLBACK(int) cpumR3RegGet_stN(void *pvUser, PCDBGFREGDESC pDesc, PDBGFREGVAL pValue)
    419492{
    420     return VERR_NOT_IMPLEMENTED;
     493    PVMCPU      pVCpu   = (PVMCPU)pvUser;
     494    void const *pv      = (uint8_t const *)&pVCpu->cpum.s.Guest + pDesc->offRegister;
     495
     496    VMCPU_ASSERT_EMT(pVCpu);
     497    Assert(pDesc->enmType == DBGFREGVALTYPE_R80);
     498
     499    if (cpumR3RegIsFxSaveFormat(pVCpu))
     500    {
     501        unsigned iReg = (pVCpu->cpum.s.Guest.fpu.FSW >> 11) & 7;
     502        iReg += pDesc->offRegister;
     503        iReg &= 7;
     504        pValue->r80 = pVCpu->cpum.s.Guest.fpu.aRegs[iReg].r80;
     505    }
     506    else
     507    {
     508        PCX86FPUSTATE pOldFpu = (PCX86FPUSTATE)&pVCpu->cpum.s.Guest.fpu;
     509
     510        unsigned iReg = (pOldFpu->FSW >> 11) & 7;
     511        iReg += pDesc->offRegister;
     512        iReg &= 7;
     513
     514        pValue->r80 = pOldFpu->regs[iReg].r80;
     515    }
     516
     517    return VINF_SUCCESS;
    421518}
    422519
    … …  
    780877    CPUMREGDESC_RW_AS("fcw",            FCW,            U16, fpu.FCW,               cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL,                       g_aCpumRegFields_fcw    ),
    781878    CPUMREGDESC_RW_AS("fsw",            FSW,            U16, fpu.FSW,               cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL,                       g_aCpumRegFields_fsw    ),
    782     CPUMREGDESC_RW_AS("ftw",            FTW,            U16, fpu.FTW,               cpumR3RegGet_ftw,     cpumR3RegSet_ftw,     NULL,                       g_aCpumRegFields_ftw    ),
     879    CPUMREGDESC_RO_AS("ftw",            FTW,            U16, fpu.FTW,               cpumR3RegGet_ftw,     cpumR3RegSet_ftw,     NULL,                       g_aCpumRegFields_ftw    ),
    783880    CPUMREGDESC_RW_AS("fop",            FOP,            U16, fpu.FOP,               cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL,                       NULL                    ),
    784881    CPUMREGDESC_RW_AS("fpuip",          FPUIP,          U32, fpu.FPUIP,             cpumR3RegGet_Generic, cpumR3RegSet_Generic, g_aCpumRegAliases_fpuip,    NULL                    ),
    … …  
    789886    CPUMREGDESC_RW_AS("mxcsr_mask",     MXCSR_MASK,     U32, fpu.MXCSR_MASK,        cpumR3RegGet_Generic, cpumR3RegSet_Generic, NULL,                       g_aCpumRegFields_mxcsr  ),
    790887#define CPUMREGDESC_ST(n) \
    791     CPUMREGDESC_RW_AS("st" #n,          ST##n,          LRD, fpu.aRegs[n],          cpumR3RegGet_stN,     cpumR3RegSet_stN,     NULL,                       g_aCpumRegFields_stN    )
     888    CPUMREGDESC_RW_AS("st" #n,          ST##n,          R80, fpu.aRegs[n],          cpumR3RegGet_stN,     cpumR3RegSet_stN,     NULL,                       g_aCpumRegFields_stN    )
    792889    CPUMREGDESC_ST(0),
    793890    CPUMREGDESC_ST(1),

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

    r35505 r35513  
    470470
    471471/**
     472 * Sets a 80-bit floating point variable to a 64-bit unsigned interger value.
     473 *
     474 * @param   pValue              The value.
     475 * @param   u64                 The integer value.
     476 */
     477DECLINLINE(void) dbgfR3RegValR80SetU64(PDBGFREGVAL pValue, uint64_t u64)
     478{
     479    /** @todo fixme  */
     480    pValue->r80.s.fSign       = 0;
     481    pValue->r80.s.uExponent   = 16383;
     482    pValue->r80.s.u64Mantissa = u64;
     483}
     484
     485
     486/**
     487 * Sets a 80-bit floating point variable to a 64-bit unsigned interger value.
     488 *
     489 * @param   pValue              The value.
     490 * @param   u128                The integer value.
     491 */
     492DECLINLINE(void) dbgfR3RegValR80SetU128(PDBGFREGVAL pValue, RTUINT128U u128)
     493{
     494    /** @todo fixme  */
     495    pValue->r80.s.fSign       = 0;
     496    pValue->r80.s.uExponent   = 16383;
     497    pValue->r80.s.u64Mantissa = u128.s.Lo;
     498}
     499
     500
     501/**
     502 * Get a 80-bit floating point variable as a 64-bit unsigned integer.
     503 *
     504 * @returns 64-bit unsigned integer.
     505 * @param   pValue              The value.
     506 */
     507DECLINLINE(uint64_t) dbgfR3RegValR80GetU64(PCDBGFREGVAL pValue)
     508{
     509    /** @todo stupid, stupid MSC. */
     510    return pValue->r80.s.u64Mantissa;
     511}
     512
     513
     514/**
     515 * Get a 80-bit floating point variable as a 128-bit unsigned integer.
     516 *
     517 * @returns 128-bit unsigned integer.
     518 * @param   pValue              The value.
     519 */
     520DECLINLINE(RTUINT128U) dbgfR3RegValR80GetU128(PCDBGFREGVAL pValue)
     521{
     522    /** @todo stupid, stupid MSC. */
     523    RTUINT128U uRet;
     524#if 0
     525    uRet.s.Lo = (uint64_t)InVal.lrd;
     526    uRet.s.Hi = (uint64_t)InVal.lrd / _4G / _4G;
     527#else
     528    uRet.s.Lo = pValue->r80.s.u64Mantissa;
     529    uRet.s.Hi = 0;
     530#endif
     531    return uRet;
     532}
     533
     534
     535/**
    472536 * Performs a cast between register value types.
    473537 *
    … …  
    498562                case DBGFREGVALTYPE_U64:    pValue->u64       = InVal.u8; return VINF_DBGF_ZERO_EXTENDED_REGISTER;
    499563                case DBGFREGVALTYPE_U128:   pValue->u128.s.Lo = InVal.u8; return VINF_DBGF_ZERO_EXTENDED_REGISTER;
    500                 case DBGFREGVALTYPE_LRD:    pValue->lrd       = InVal.u8; return VINF_DBGF_ZERO_EXTENDED_REGISTER;
     564                case DBGFREGVALTYPE_R80:    dbgfR3RegValR80SetU64(pValue, InVal.u8); return VINF_DBGF_ZERO_EXTENDED_REGISTER;
    501565                case DBGFREGVALTYPE_DTR:                                  return VERR_DBGF_UNSUPPORTED_CAST;
    502566
    … …  
    516580                case DBGFREGVALTYPE_U64:    pValue->u64       = InVal.u16;  return VINF_DBGF_ZERO_EXTENDED_REGISTER;
    517581                case DBGFREGVALTYPE_U128:   pValue->u128.s.Lo = InVal.u16;  return VINF_DBGF_ZERO_EXTENDED_REGISTER;
    518                 case DBGFREGVALTYPE_LRD:    pValue->lrd       = InVal.u16; return VINF_DBGF_ZERO_EXTENDED_REGISTER;
     582                case DBGFREGVALTYPE_R80:    dbgfR3RegValR80SetU64(pValue, InVal.u16); return VINF_DBGF_ZERO_EXTENDED_REGISTER;
    519583                case DBGFREGVALTYPE_DTR:                                    return VERR_DBGF_UNSUPPORTED_CAST;
    520584
    … …  
    534598                case DBGFREGVALTYPE_U64:    pValue->u64       = InVal.u32;  return VINF_DBGF_ZERO_EXTENDED_REGISTER;
    535599                case DBGFREGVALTYPE_U128:   pValue->u128.s.Lo = InVal.u32;  return VINF_DBGF_ZERO_EXTENDED_REGISTER;
    536                 case DBGFREGVALTYPE_LRD:    pValue->lrd       = InVal.u32; return VINF_DBGF_ZERO_EXTENDED_REGISTER;
     600                case DBGFREGVALTYPE_R80:    dbgfR3RegValR80SetU64(pValue, InVal.u32); return VINF_DBGF_ZERO_EXTENDED_REGISTER;
    537601                case DBGFREGVALTYPE_DTR:                                    return VERR_DBGF_UNSUPPORTED_CAST;
    538602
    … …  
    552616                case DBGFREGVALTYPE_U64:    pValue->u64       = InVal.u64;  return VINF_SUCCESS;
    553617                case DBGFREGVALTYPE_U128:   pValue->u128.s.Lo = InVal.u64;  return VINF_DBGF_TRUNCATED_REGISTER;
    554                 case DBGFREGVALTYPE_LRD:    pValue->lrd       = InVal.u64;  return VINF_DBGF_ZERO_EXTENDED_REGISTER;
     618                case DBGFREGVALTYPE_R80:    dbgfR3RegValR80SetU64(pValue, InVal.u64); return VINF_DBGF_TRUNCATED_REGISTER;
    555619                case DBGFREGVALTYPE_DTR:                                    return VERR_DBGF_UNSUPPORTED_CAST;
    556620
    … …  
    570634                case DBGFREGVALTYPE_U64:    pValue->u64       = InVal.u128.s.Lo;  return VINF_DBGF_TRUNCATED_REGISTER;
    571635                case DBGFREGVALTYPE_U128:   pValue->u128      = InVal.u128;       return VINF_SUCCESS;
    572                 case DBGFREGVALTYPE_LRD:    pValue->lrd       = InVal.u64;        return VINF_DBGF_TRUNCATED_REGISTER;
     636                case DBGFREGVALTYPE_R80:    dbgfR3RegValR80SetU128(pValue, InVal.u128); return VINF_DBGF_TRUNCATED_REGISTER;
    573637                case DBGFREGVALTYPE_DTR:                                          return VERR_DBGF_UNSUPPORTED_CAST;
    574638
    … …  
    580644            break;
    581645
    582         case DBGFREGVALTYPE_LRD:
     646        case DBGFREGVALTYPE_R80:
    583647            switch (enmToType)
    584648            {
    585                 case DBGFREGVALTYPE_U8:     pValue->u8        = (uint8_t)InVal.lrd;  return VINF_DBGF_TRUNCATED_REGISTER;
    586                 case DBGFREGVALTYPE_U16:    pValue->u16       = (uint16_t)InVal.lrd;  return VINF_DBGF_TRUNCATED_REGISTER;
    587                 case DBGFREGVALTYPE_U32:    pValue->u32       = (uint32_t)InVal.lrd;  return VINF_DBGF_TRUNCATED_REGISTER;
    588                 case DBGFREGVALTYPE_U64:    pValue->u64       = (uint64_t)InVal.lrd;  return VINF_DBGF_TRUNCATED_REGISTER;
    589                 case DBGFREGVALTYPE_U128:
    590                     pValue->u128.s.Lo = (uint64_t)InVal.lrd;
    591                     pValue->u128.s.Hi = (uint64_t)InVal.lrd / _4G / _4G;
    592                     return VINF_DBGF_TRUNCATED_REGISTER;
    593                 case DBGFREGVALTYPE_LRD:    pValue->lrd       = InVal.lrd;  return VINF_SUCCESS;
    594                 case DBGFREGVALTYPE_DTR:                                    return VERR_DBGF_UNSUPPORTED_CAST;
     649                case DBGFREGVALTYPE_U8:     pValue->u8        = (uint8_t )dbgfR3RegValR80GetU64(&InVal);  return VINF_DBGF_TRUNCATED_REGISTER;
     650                case DBGFREGVALTYPE_U16:    pValue->u16       = (uint16_t)dbgfR3RegValR80GetU64(&InVal);  return VINF_DBGF_TRUNCATED_REGISTER;
     651                case DBGFREGVALTYPE_U32:    pValue->u32       = (uint32_t)dbgfR3RegValR80GetU64(&InVal);  return VINF_DBGF_TRUNCATED_REGISTER;
     652                case DBGFREGVALTYPE_U64:    pValue->u64       = (uint64_t)dbgfR3RegValR80GetU64(&InVal);  return VINF_DBGF_TRUNCATED_REGISTER;
     653                case DBGFREGVALTYPE_U128:   pValue->u128      = dbgfR3RegValR80GetU128(&InVal);           return VINF_DBGF_TRUNCATED_REGISTER;
     654                case DBGFREGVALTYPE_R80:    pValue->r80       = InVal.r80;          return VINF_SUCCESS;
     655                case DBGFREGVALTYPE_DTR:                                            return VERR_DBGF_UNSUPPORTED_CAST;
    595656
    596657                case DBGFREGVALTYPE_32BIT_HACK:
    … …  
    609670                case DBGFREGVALTYPE_U64:    pValue->u64       = InVal.dtr.u64Base;  return VINF_DBGF_TRUNCATED_REGISTER;
    610671                case DBGFREGVALTYPE_U128:   pValue->u128.s.Lo = InVal.dtr.u64Base;  return VINF_DBGF_TRUNCATED_REGISTER;
    611                 case DBGFREGVALTYPE_LRD:    pValue->lrd       = InVal.dtr.u64Base;  return VINF_DBGF_TRUNCATED_REGISTER;
     672                case DBGFREGVALTYPE_R80:    dbgfR3RegValR80SetU64(pValue, InVal.dtr.u64Base);  return VINF_DBGF_TRUNCATED_REGISTER;
    612673                case DBGFREGVALTYPE_DTR:    pValue->dtr       = InVal.dtr;          return VINF_SUCCESS;
    613674
    … …  
    873934                        pReg->Val.au64[1] = pu->au64[1];
    874935                        break;
    875                     case DBGFREGVALTYPE_LRD:
     936                    case DBGFREGVALTYPE_R80:
    876937                        pReg->Val.au64[0] = pu->au64[0];
    877938                        pReg->Val.au16[5] = pu->au16[5];
    … …  
    14171478
    14181479
     1480#if 0
    14191481/**
    14201482 * Queries a long double register value.
    … …  
    14391501{
    14401502    DBGFREGVAL Value;
    1441     int rc = dbgfR3RegNmQueryWorker(pVM, idDefCpu, pszReg, DBGFREGVALTYPE_LRD, &Value, NULL);
     1503    int rc = dbgfR3RegNmQueryWorker(pVM, idDefCpu, pszReg, DBGFREGVALTYPE_R80, &Value, NULL);
    14421504    if (RT_SUCCESS(rc))
    14431505        *plrd = Value.lrd;
    … …  
    14461508    return rc;
    14471509}
     1510#endif
    14481511
    14491512
Note: See TracChangeset for help on using the changeset viewer.

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