VirtualBox

Changeset 35513 in vbox


Ignore:
Timestamp:
Jan 12, 2011 5:50:43 PM (14 years ago)
Author:
vboxsync
Message:

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

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/err.h

    r35466 r35513  
    279279/** The requested type conversion was not supported. */
    280280#define VERR_DBGF_UNSUPPORTED_CAST          (-1213)
     281/** The register is read-only and cannot be modified. */
     282#define VERR_DBGF_READ_ONLY_REGISTER        (-1214)
    281283/** @} */
    282284

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

    r35490 r35513  
    12321232    DBGFREGVALTYPE_U128,
    12331233    /** Long double register value. */
    1234     DBGFREGVALTYPE_LRD,
     1234    DBGFREGVALTYPE_R80,
    12351235    /** Descriptor table register value. */
    12361236    DBGFREGVALTYPE_DTR,
    … …  
    12531253    uint64_t    u64;            /**< The 64-bit view. */
    12541254    RTUINT128U  u128;           /**< The 128-bit view. */
    1255     long double lrd;            /**< The long double view. */
     1255    RTFLOAT80U2 r80;            /**< The 80-bit floating point view. */
    12561256    /** GDTR or LDTR (DBGFREGVALTYPE_DTR). */
    12571257    struct
    … …  
    14471447VMMR3DECL(int) DBGFR3RegNmQueryU64( PVM pVM, VMCPUID idDefCpu, const char *pszReg, uint64_t    *pu64);
    14481448VMMR3DECL(int) DBGFR3RegNmQueryU128(PVM pVM, VMCPUID idDefCpu, const char *pszReg, PRTUINT128U  pu128);
    1449 VMMR3DECL(int) DBGFR3RegNmQueryLrd( PVM pVM, VMCPUID idDefCpu, const char *pszReg, long double *plrd);
     1449/*VMMR3DECL(int) DBGFR3RegNmQueryLrd( PVM pVM, VMCPUID idDefCpu, const char *pszReg, long double *plrd);*/
    14501450VMMR3DECL(int) DBGFR3RegNmQueryXdtr(PVM pVM, VMCPUID idDefCpu, const char *pszReg, uint64_t *pu64Base, uint16_t *pu16Limit);
    14511451VMMR3DECL(int) DBGFR3RegNmQueryBatch(PVM pVM,VMCPUID idDefCpu, DBGFREGENTRYNM paRegs, size_t cRegs);

  • trunk/include/VBox/x86.h

    r35493 r35513  
    19351935        /** FPU view - todo. */
    19361936        X86FPUMMX   fpu;
     1937        /** Extended precision floating point view. */
     1938        RTFLOAT80U2 r80;
    19371939        /** 8-bit view. */
    19381940        uint8_t     au8[16];
    … …  
    19871989        /** FPU view - todo. */
    19881990        X86FPUMMX   fpu;
     1991        /** Extended precision floating point view. */
     1992        RTFLOAT80U2 r80;
    19891993        /** 8-bit view. */
    19901994        uint8_t     au8[16];

  • trunk/src/VBox/Debugger/DBGCOps.cpp

    r35490 r35513  
    522522                return VINF_SUCCESS;
    523523
    524             case DBGFREGVALTYPE_LRD:
    525                 DBGCVAR_INIT_NUMBER(pResult, (uint64_t)Value.lrd);
     524            case DBGFREGVALTYPE_R80:
     525#ifdef RT_COMPILER_WITH_80BIT_LONG_DOUBLE
     526                DBGCVAR_INIT_NUMBER(pResult, (uint64_t)Value.r80.lrd);
     527#else
     528                DBGCVAR_INIT_NUMBER(pResult, (uint64_t)Value.r80.sj64.u63Fraction);
     529#endif
    526530                return VINF_SUCCESS;
    527531

  • trunk/src/VBox/Main/src-client/MachineDebuggerImpl.cpp

    r35504 r35513  
    10851085            return S_OK;
    10861086
    1087         case DBGFREGVALTYPE_LRD:
    1088             /** @todo long double -> string conversion. */
    1089             /** @todo long double == double on MSC. Stupid, stupid,
    1090              *        microsoft! */
    1091             RTStrFormatNumber(szHex, a_pValue->au16[5], 16, 2+4, 0, RTSTR_F_SPECIAL | RTSTR_F_ZEROPAD | RTSTR_F_16BIT);
    1092             RTStrFormatNumber(&szHex[2+4], a_pValue->au64[0], 16, 16, 0, RTSTR_F_ZEROPAD | RTSTR_F_64BIT);
     1087        case DBGFREGVALTYPE_R80:
     1088        {
     1089            char *pszHex = szHex;
     1090            if (a_pValue->r80.s.fSign)
     1091                *pszHex++ = '-';
     1092
     1093            if (a_pValue->r80.s.uExponent == 0)
     1094            {
     1095                if (   !a_pValue->r80.sj64.u63Fraction
     1096                    && a_pValue->r80.sj64.fInteger)
     1097                    *pszHex++ = '0';
     1098                /* else: Denormal, handled way below. */
     1099            }
     1100            else if (a_pValue->r80.sj64.uExponent == UINT16_C(0x7fff))
     1101            {
     1102                /** @todo Figure out Pseudo inf/nan... */
     1103                if (a_pValue->r80.sj64.fInteger)
     1104                    *pszHex++ = 'P';
     1105                if (a_pValue->r80.sj64.u63Fraction == 0)
     1106                {
     1107                    *pszHex++ = 'I';
     1108                    *pszHex++ = 'n';
     1109                    *pszHex++ = 'f';
     1110                }
     1111                else
     1112                {
     1113                    *pszHex++ = 'N';
     1114                    *pszHex++ = 'a';
     1115                    *pszHex++ = 'N';
     1116                }
     1117            }
     1118            if (pszHex != &szHex[1])
     1119                *pszHex = '\0';
     1120            else
     1121            {
     1122                *pszHex++ = a_pValue->r80.sj64.fInteger ? '1' : '0';
     1123                *pszHex++ = 'm';
     1124                pszHex += RTStrFormatNumber(pszHex, a_pValue->r80.sj64.u63Fraction, 16, 2+16, 0,
     1125                                            RTSTR_F_SPECIAL | RTSTR_F_ZEROPAD | RTSTR_F_64BIT);
     1126
     1127                *pszHex++ = 'e';
     1128                pszHex += RTStrFormatNumber(pszHex, (int32_t)a_pValue->r80.sj64.uExponent - 16383, 10, 0, 0,
     1129                                            RTSTR_F_ZEROPAD | RTSTR_F_32BIT | RTSTR_F_VALSIGNED);
     1130            }
    10931131            *a_pbstr = szHex;
    10941132            return S_OK;
     1133        }
    10951134
    10961135        case DBGFREGVALTYPE_DTR:

  • 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