VirtualBox

Changeset 105848 in vbox for trunk/src/VBox/Disassembler


Ignore:
Timestamp:
Aug 23, 2024 4:05:23 PM (8 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
164567
Message:

Disassembler/ARMv8: Support disassembling the load/store register offset instruction variants, bugref:10394

Location:
trunk/src/VBox/Disassembler
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Disassembler/DisasmCore-armv8.cpp

    r105832 r105848  
    7979static FNDISPARSEARMV8 disArmV8ParseImmAdr;
    8080static FNDISPARSEARMV8 disArmV8ParseReg;
     81static FNDISPARSEARMV8 disArmV8ParseRegOff;
    8182static FNDISPARSEARMV8 disArmV8ParseImmsImmrN;
    8283static FNDISPARSEARMV8 disArmV8ParseHw;
    … …  
    9091static FNDISPARSEARMV8 disArmV8ParseImmMemOff;
    9192static FNDISPARSEARMV8 disArmV8ParseSImmMemOff;
     93static FNDISPARSEARMV8 disArmV8ParseOption;
     94static FNDISPARSEARMV8 disArmV8ParseS;
    9295/** @}  */
    9396
    … …  
    113116    disArmV8ParseImmAdr,
    114117    disArmV8ParseReg,
     118    disArmV8ParseRegOff,
    115119    disArmV8ParseImmsImmrN,
    116120    disArmV8ParseHw,
    … …  
    124128    disArmV8ParseShiftAmount,
    125129    disArmV8ParseImmMemOff,
    126     disArmV8ParseSImmMemOff
     130    disArmV8ParseSImmMemOff,
     131    disArmV8ParseOption,
     132    disArmV8ParseS
    127133};
    128134
    … …  
    257263{
    258264    RT_NOREF(pDis, pOp, pInsnClass);
    259     pParam->armv8.Reg.idxGenReg = disArmV8ExtractBitVecFromInsn(u32Insn, pInsnParm->idxBitStart, pInsnParm->cBits);
    260     pParam->armv8.cb            = *pf64Bit ? sizeof(uint64_t) : sizeof(uint32_t);
    261     pParam->fUse |=   (*pf64Bit || (pParam->armv8.enmType == kDisArmv8OpParmAddrInGpr))
    262                     ? DISUSE_REG_GEN64
    263                     : DISUSE_REG_GEN32;
     265    pParam->armv8.Reg.Gpr.idGpr = disArmV8ExtractBitVecFromInsn(u32Insn, pInsnParm->idxBitStart, pInsnParm->cBits);
     266    if (*pf64Bit || (pParam->armv8.enmType == kDisArmv8OpParmAddrInGpr))
     267        pParam->armv8.Reg.Gpr.f32Bit = false;
     268    else
     269        pParam->armv8.Reg.Gpr.f32Bit = true;
     270    return VINF_SUCCESS;
     271}
     272
     273
     274static int disArmV8ParseRegOff(PDISSTATE pDis, uint32_t u32Insn, PCDISARMV8OPCODE pOp, PCDISARMV8INSNCLASS pInsnClass, PDISOPPARAM pParam, PCDISARMV8INSNPARAM pInsnParm, bool *pf64Bit)
     275{
     276    RT_NOREF(pDis, pOp, pInsnClass, pf64Bit);
     277    pParam->armv8.GprIndex.idGpr = disArmV8ExtractBitVecFromInsn(u32Insn, pInsnParm->idxBitStart, pInsnParm->cBits);
     278    pParam->armv8.Reg.Gpr.f32Bit = false; /* Might get overwritten later on. */
     279    pParam->fUse                |= DISUSE_INDEX;
    264280    return VINF_SUCCESS;
    265281}
    … …  
    306322    if (u32)
    307323    {
    308         pParam->armv8.enmShift = kDisArmv8OpParmShiftLeft;
    309         pParam->armv8.u.cShift = ((uint8_t)u32 & 0x3) << 4;
     324        pParam->armv8.enmExtend = kDisArmv8OpParmExtendLsl;
     325        pParam->armv8.u.cExtend = ((uint8_t)u32 & 0x3) << 4;
    310326    }
    311327    return VINF_SUCCESS;
    … …  
    414430    switch (u32Shift)
    415431    {
    416         case 0: pParam->armv8.enmShift = kDisArmv8OpParmShiftLeft;      break;
    417         case 1: pParam->armv8.enmShift = kDisArmv8OpParmShiftRight;      break;
    418         case 2: pParam->armv8.enmShift = kDisArmv8OpParmShiftArithRight; break;
    419         case 3: pParam->armv8.enmShift = kDisArmv8OpParmShiftRotate;    break;
     432        case 0: pParam->armv8.enmExtend = kDisArmv8OpParmExtendLsl; break;
     433        case 1: pParam->armv8.enmExtend = kDisArmv8OpParmExtendLsr; break;
     434        case 2: pParam->armv8.enmExtend = kDisArmv8OpParmExtendAsr; break;
     435        case 3: pParam->armv8.enmExtend = kDisArmv8OpParmExtendRor; break;
    420436        default:
    421437            AssertReleaseFailed();
    … …  
    435451        return VERR_DIS_INVALID_OPCODE;
    436452
    437     Assert(pParam->armv8.enmShift != kDisArmv8OpParmShiftNone);
     453    Assert(pParam->armv8.enmExtend != kDisArmv8OpParmExtendNone);
    438454    Assert(u32Amount < 64);
    439     pParam->armv8.u.cShift = (uint8_t)u32Amount;
     455    pParam->armv8.u.cExtend = (uint8_t)u32Amount;
    440456    /* Any shift operation with a 0 is essentially no shift being applied. */
    441     if (pParam->armv8.u.cShift == 0)
    442         pParam->armv8.enmShift = kDisArmv8OpParmShiftNone;
     457    if (pParam->armv8.u.cExtend == 0)
     458        pParam->armv8.enmExtend = kDisArmv8OpParmExtendNone;
    443459    return VINF_SUCCESS;
    444460}
    … …  
    484500
    485501
     502static int disArmV8ParseOption(PDISSTATE pDis, uint32_t u32Insn, PCDISARMV8OPCODE pOp, PCDISARMV8INSNCLASS pInsnClass, PDISOPPARAM pParam, PCDISARMV8INSNPARAM pInsnParm, bool *pf64Bit)
     503{
     504    RT_NOREF(pDis, u32Insn, pOp, pInsnClass, pParam, pInsnParm, pf64Bit);
     505
     506    AssertReturn(pInsnParm->cBits == 3, VERR_INTERNAL_ERROR_2);
     507    uint32_t u32Opt = disArmV8ExtractBitVecFromInsn(u32Insn, pInsnParm->idxBitStart, pInsnParm->cBits);
     508
     509    Assert(   pParam->armv8.enmExtend == kDisArmv8OpParmExtendNone
     510           && (pParam->fUse & DISUSE_INDEX));
     511    switch (u32Opt)
     512    {
     513        case 0: pParam->armv8.enmExtend = kDisArmv8OpParmExtendUxtB; break;
     514        case 1: pParam->armv8.enmExtend = kDisArmv8OpParmExtendUxtH; break;
     515        case 2: pParam->armv8.enmExtend = kDisArmv8OpParmExtendUxtW; break;
     516        case 3: pParam->armv8.enmExtend = kDisArmv8OpParmExtendUxtX; break;
     517        case 4: pParam->armv8.enmExtend = kDisArmv8OpParmExtendSxtB; break;
     518        case 5: pParam->armv8.enmExtend = kDisArmv8OpParmExtendSxtH; break;
     519        case 6: pParam->armv8.enmExtend = kDisArmv8OpParmExtendSxtW; break;
     520        case 7: pParam->armv8.enmExtend = kDisArmv8OpParmExtendSxtX; break;
     521        default:
     522            AssertFailed();
     523    }
     524
     525    /* When option<0> is set to 0, the 32-bit name of the GPR is used, 64-bit when option<0> is set to 1. */
     526    pParam->armv8.GprIndex.f32Bit = !RT_BOOL(u32Opt & 0x1);
     527    return VINF_SUCCESS;
     528}
     529
     530
     531static int disArmV8ParseS(PDISSTATE pDis, uint32_t u32Insn, PCDISARMV8OPCODE pOp, PCDISARMV8INSNCLASS pInsnClass, PDISOPPARAM pParam, PCDISARMV8INSNPARAM pInsnParm, bool *pf64Bit)
     532{
     533    RT_NOREF(pDis, u32Insn, pOp, pInsnClass, pParam, pInsnParm, pf64Bit);
     534
     535    AssertReturn(pInsnParm->cBits == 1, VERR_INTERNAL_ERROR_2);
     536    bool const fS = RT_BOOL(u32Insn & RT_BIT_32(pInsnParm->idxBitStart));
     537
     538    Assert(   pParam->armv8.enmExtend != kDisArmv8OpParmExtendNone
     539           && pDis->armv8.cbOperand > 0
     540           && pDis->armv8.cbOperand <= 8);
     541    if (fS)
     542    {
     543        switch (pDis->armv8.cbOperand)
     544        {
     545            case sizeof(uint8_t):  pParam->armv8.u.cExtend = 0; break;
     546            case sizeof(uint16_t): pParam->armv8.u.cExtend = 1; break;
     547            case sizeof(uint32_t): pParam->armv8.u.cExtend = 2; break;
     548            case sizeof(uint64_t): pParam->armv8.u.cExtend = 3; break;
     549            default:
     550                AssertReleaseFailed();
     551        }
     552    }
     553    else if (pParam->armv8.enmExtend == kDisArmv8OpParmExtendUxtX) /* UXTX aka LSL can be ignored if S is not set. */
     554    {
     555        pParam->armv8.u.cExtend = 0;
     556        pParam->armv8.enmExtend = kDisArmv8OpParmExtendNone;
     557    }
     558
     559    return VINF_SUCCESS;
     560}
     561
     562
    486563static uint32_t disArmV8DecodeIllegal(PDISSTATE pDis, uint32_t u32Insn, PCDISARMV8INSNCLASS pInsnClass)
    487564{
    … …  
    554631
    555632            if (   pDis->aParams[2].armv8.enmType == kDisArmv8OpParmGpr
    556                 && pDis->aParams[2].armv8.enmShift == kDisArmv8OpParmShiftNone
    557                 && pDis->aParams[1].armv8.Reg.idxGenReg == ARMV8_A64_REG_XZR)
     633                && pDis->aParams[2].armv8.enmExtend == kDisArmv8OpParmExtendNone
     634                && pDis->aParams[1].armv8.Reg.Gpr.idGpr == ARMV8_A64_REG_XZR)
    558635            {
    559636                DIS_ARMV8_ALIAS_CREATE(Mov, "mov", OP_ARMV8_A64_MOV, DISOPTYPE_HARMLESS);
    … …  
    568645        {
    569646            Assert(pDis->aParams[0].armv8.enmType == kDisArmv8OpParmGpr);
    570             if (pDis->aParams[0].armv8.Reg.idxGenReg == ARMV8_A64_REG_XZR)
     647            if (pDis->aParams[0].armv8.Reg.Gpr.idGpr == ARMV8_A64_REG_XZR)
    571648            {
    572649                DIS_ARMV8_ALIAS_CREATE(Cmp, "cmp", OP_ARMV8_A64_CMP, DISOPTYPE_HARMLESS);
    … …  
    594671
    595672    /* Should contain the parameter type on input. */
    596     pDis->aParams[0].armv8.enmType  = pInsnClass->aenmParamTypes[0];
    597     pDis->aParams[1].armv8.enmType  = pInsnClass->aenmParamTypes[1];
    598     pDis->aParams[2].armv8.enmType  = pInsnClass->aenmParamTypes[2];
    599     pDis->aParams[3].armv8.enmType  = pInsnClass->aenmParamTypes[3];
    600     pDis->aParams[0].armv8.enmShift = kDisArmv8OpParmShiftNone;
    601     pDis->aParams[1].armv8.enmShift = kDisArmv8OpParmShiftNone;
    602     pDis->aParams[2].armv8.enmShift = kDisArmv8OpParmShiftNone;
    603     pDis->aParams[3].armv8.enmShift = kDisArmv8OpParmShiftNone;
    604     pDis->armv8.enmCond             = kDisArmv8InstrCond_Al;
    605     pDis->armv8.cbOperand           = 0;
     673    pDis->aParams[0].fUse            = 0;
     674    pDis->aParams[1].fUse            = 0;
     675    pDis->aParams[2].fUse            = 0;
     676    pDis->aParams[3].fUse            = 0;
     677    pDis->aParams[0].armv8.enmType   = pInsnClass->aenmParamTypes[0];
     678    pDis->aParams[1].armv8.enmType   = pInsnClass->aenmParamTypes[1];
     679    pDis->aParams[2].armv8.enmType   = pInsnClass->aenmParamTypes[2];
     680    pDis->aParams[3].armv8.enmType   = pInsnClass->aenmParamTypes[3];
     681    pDis->aParams[0].armv8.enmExtend = kDisArmv8OpParmExtendNone;
     682    pDis->aParams[1].armv8.enmExtend = kDisArmv8OpParmExtendNone;
     683    pDis->aParams[2].armv8.enmExtend = kDisArmv8OpParmExtendNone;
     684    pDis->aParams[3].armv8.enmExtend = kDisArmv8OpParmExtendNone;
     685    pDis->armv8.enmCond              = kDisArmv8InstrCond_Al;
     686    pDis->armv8.cbOperand            = 0;
    606687
    607688    pDis->pCurInstr = &pOp->Opc;

  • trunk/src/VBox/Disassembler/DisasmFormatArmV8.cpp

    r105830 r105848  
    306306 * @param   pcchReg     Where to store the length of the name.
    307307 */
    308 static const char *disasmFormatArmV8Reg(PCDISSTATE pDis, PCDISOPPARAM pParam, size_t *pcchReg)
     308DECLINLINE(const char *) disasmFormatArmV8Reg(PCDISSTATE pDis, PCDISOPPARAMARMV8REG pReg, size_t *pcchReg)
    309309{
    310310    RT_NOREF_PV(pDis);
    311311
    312     switch (pParam->fUse & (  DISUSE_REG_GEN8 | DISUSE_REG_GEN16 | DISUSE_REG_GEN32 | DISUSE_REG_GEN64
    313                             | DISUSE_REG_FP   | DISUSE_REG_MMX   | DISUSE_REG_XMM   | DISUSE_REG_YMM
    314                             | DISUSE_REG_CR   | DISUSE_REG_DBG   | DISUSE_REG_SEG   | DISUSE_REG_TEST))
    315 
     312    if (pReg->f32Bit)
    316313    {
    317         case DISUSE_REG_GEN32:
    318         {
    319             Assert(pParam->armv8.Reg.idxGenReg < RT_ELEMENTS(g_aszArmV8RegGen32));
    320             const char *psz = g_aszArmV8RegGen32[pParam->armv8.Reg.idxGenReg];
    321             *pcchReg = 2 + !!psz[2];
    322             return psz;
    323         }
    324 
    325         case DISUSE_REG_GEN64:
    326         {
    327             Assert(pParam->armv8.Reg.idxGenReg < RT_ELEMENTS(g_aszArmV8RegGen64));
    328             const char *psz = g_aszArmV8RegGen64[pParam->armv8.Reg.idxGenReg];
    329             *pcchReg = 2 + !!psz[2];
    330             return psz;
    331         }
    332 
    333         default:
    334             AssertMsgFailed(("%#x\n", pParam->fUse));
    335             *pcchReg = 3;
    336             return "r??";
     314        Assert(pReg->idGpr < RT_ELEMENTS(g_aszArmV8RegGen32));
     315        const char *psz = g_aszArmV8RegGen32[pReg->idGpr];
     316        *pcchReg = 2 + !!psz[2];
     317        return psz;
    337318    }
     319
     320    Assert(pReg->idGpr < RT_ELEMENTS(g_aszArmV8RegGen64));
     321    const char *psz = g_aszArmV8RegGen64[pReg->idGpr];
     322    *pcchReg = 2 + !!psz[2];
     323    return psz;
    338324}
    339325
    … …  
    699685
    700686                    size_t cchReg;
    701                     const char *pszReg = disasmFormatArmV8Reg(pDis, pParam, &cchReg);
     687                    const char *pszReg = disasmFormatArmV8Reg(pDis, &pParam->armv8.Reg.Gpr, &cchReg);
    702688                    PUT_STR(pszReg, cchReg);
    703689                    break;
    … …  
    718704
    719705                    size_t cchReg;
    720                     const char *pszReg = disasmFormatArmV8Reg(pDis, pParam, &cchReg);
     706                    const char *pszReg = disasmFormatArmV8Reg(pDis, &pParam->armv8.Reg.Gpr, &cchReg);
    721707                    PUT_STR(pszReg, cchReg);
    722708
    723                     if (pParam->armv8.u.offBase)
     709                    if (pParam->fUse & DISUSE_INDEX)
     710                    {
     711                        PUT_SZ(", ");
     712
     713                        pszReg = disasmFormatArmV8Reg(pDis, &pParam->armv8.GprIndex, &cchReg);
     714                        PUT_STR(pszReg, cchReg);
     715                    }
     716                    else if (pParam->armv8.u.offBase)
    724717                    {
    725718                        PUT_SZ(", #");
    726719                        PUT_NUM_S16(pParam->armv8.u.offBase);
     720                    }
     721
     722                    if (pParam->armv8.enmExtend != kDisArmv8OpParmExtendNone)
     723                    {
     724                        PUT_SZ(", ");
     725                        switch (pParam->armv8.enmExtend)
     726                        {
     727                            case kDisArmv8OpParmExtendUxtX: /* UXTX is same as LSL which is preferred by most disassemblers/assemblers. */
     728                            case kDisArmv8OpParmExtendLsl:
     729                                PUT_SZ("LSL #");
     730                                break;
     731                            case kDisArmv8OpParmExtendUxtB: PUT_SZ("UXTB #"); break;
     732                            case kDisArmv8OpParmExtendUxtH: PUT_SZ("UXTH #"); break;
     733                            case kDisArmv8OpParmExtendUxtW: PUT_SZ("UXTW #"); break;
     734                            case kDisArmv8OpParmExtendSxtB: PUT_SZ("SXTB #"); break;
     735                            case kDisArmv8OpParmExtendSxtH: PUT_SZ("SXTH #"); break;
     736                            case kDisArmv8OpParmExtendSxtW: PUT_SZ("SXTW #"); break;
     737                            case kDisArmv8OpParmExtendSxtX: PUT_SZ("SXTX #"); break;
     738                            default:
     739                                AssertFailed();
     740                        }
     741                        PUT_NUM_8(pParam->armv8.u.cExtend);
    727742                    }
    728743
    … …  
    740755            }
    741756
    742             if (pParam->armv8.enmShift != kDisArmv8OpParmShiftNone)
     757            if (   pParam->armv8.enmType != kDisArmv8OpParmAddrInGpr
     758                && pParam->armv8.enmExtend != kDisArmv8OpParmExtendNone)
    743759            {
    744760                Assert(   pParam->armv8.enmType == kDisArmv8OpParmImm
    745761                       || pParam->armv8.enmType == kDisArmv8OpParmGpr);
    746762                PUT_SZ(", ");
    747                 switch (pParam->armv8.enmShift)
     763                switch (pParam->armv8.enmExtend)
    748764                {
    749                     case kDisArmv8OpParmShiftLeft:
     765                    case kDisArmv8OpParmExtendLsl:
    750766                        PUT_SZ("LSL #");
    751767                        break;
    752                     case kDisArmv8OpParmShiftRight:
     768                    case kDisArmv8OpParmExtendLsr:
    753769                        PUT_SZ("LSR #");
    754770                        break;
    755                     case kDisArmv8OpParmShiftArithRight:
     771                    case kDisArmv8OpParmExtendAsr:
    756772                        PUT_SZ("ASR #");
    757773                        break;
    758                     case kDisArmv8OpParmShiftRotate:
     774                    case kDisArmv8OpParmExtendRor:
    759775                        PUT_SZ("ROR #");
    760776                        break;
    … …  
    762778                        AssertFailed();
    763779                }
    764                 PUT_NUM_8(pParam->armv8.u.cShift);
     780                PUT_NUM_8(pParam->armv8.u.cExtend);
    765781            }
    766782        }

  • trunk/src/VBox/Disassembler/DisasmInternal-armv8.h

    r105830 r105848  
    5656    kDisParmParseImmAdr,
    5757    kDisParmParseReg,
     58    kDisParmParseRegOff,
    5859    kDisParmParseImmsImmrN,
    5960    kDisParmParseHw,
    … …  
    6869    kDisParmParseImmMemOff,
    6970    kDisParmParseSImmMemOff,
     71    kDisParmParseOption,
     72    kDisParmParseS,
    7073    kDisParmParseMax
    7174} DISPARMPARSEIDX;

  • trunk/src/VBox/Disassembler/DisasmTables-armv8-a64.cpp

    r105830 r105848  
    594594
    595595
     596/* STRB/LDRB/LDRSB/STR/LDR/STRH/LDRH/LDRSH/LDRSW/PRFM
     597 *
     598 * Note: The size,opc bitfields are concatenated to form an index.
     599 */
     600DIS_ARMV8_DECODE_INSN_CLASS_DEFINE_BEGIN(LdStRegOffGpr)
     601    DIS_ARMV8_OP(0x38200800, "strb",            OP_ARMV8_A64_STRB,      DISOPTYPE_HARMLESS),
     602    DIS_ARMV8_OP(0x38600800, "ldrb",            OP_ARMV8_A64_LDRB,      DISOPTYPE_HARMLESS),
     603 DIS_ARMV8_OP_EX(0x38a00800, "ldrsb",           OP_ARMV8_A64_LDRSB,     DISOPTYPE_HARMLESS, DISARMV8INSNCLASS_F_FORCED_64BIT),
     604    DIS_ARMV8_OP(0x38e00800, "ldrsb",           OP_ARMV8_A64_LDRSB,     DISOPTYPE_HARMLESS),
     605    DIS_ARMV8_OP(0x78200800, "strh",            OP_ARMV8_A64_STRH,      DISOPTYPE_HARMLESS),
     606    DIS_ARMV8_OP(0x78600800, "ldrh",            OP_ARMV8_A64_LDRH,      DISOPTYPE_HARMLESS),
     607 DIS_ARMV8_OP_EX(0x78a00800, "ldrsh",           OP_ARMV8_A64_LDRSH,     DISOPTYPE_HARMLESS, DISARMV8INSNCLASS_F_FORCED_64BIT),
     608    DIS_ARMV8_OP(0x78e00800, "ldrsh",           OP_ARMV8_A64_LDRSH,     DISOPTYPE_HARMLESS),
     609    DIS_ARMV8_OP(0xb8200800, "str",             OP_ARMV8_A64_STR,       DISOPTYPE_HARMLESS),
     610    DIS_ARMV8_OP(0xb8600800, "ldr",             OP_ARMV8_A64_LDR,       DISOPTYPE_HARMLESS),
     611 DIS_ARMV8_OP_EX(0xb8a00800, "ldrsw",           OP_ARMV8_A64_LDRSW,     DISOPTYPE_HARMLESS, DISARMV8INSNCLASS_F_FORCED_64BIT),
     612    INVALID_OPCODE,
     613    DIS_ARMV8_OP(0xf8200800, "str",             OP_ARMV8_A64_STR,       DISOPTYPE_HARMLESS),
     614    DIS_ARMV8_OP(0xf8600800, "ldr",             OP_ARMV8_A64_LDR,       DISOPTYPE_HARMLESS),
     615    INVALID_OPCODE, /** @todo PRFM */
     616    INVALID_OPCODE,
     617DIS_ARMV8_DECODE_INSN_CLASS_DEFINE_DECODER(LdStRegOffGpr)
     618    DIS_ARMV8_INSN_DECODE(kDisParmParseSize,          30,  2, DIS_ARMV8_INSN_PARAM_UNSET),
     619    DIS_ARMV8_INSN_DECODE(kDisParmParseReg,            0,  5, 0 /*idxParam*/),
     620    DIS_ARMV8_INSN_DECODE(kDisParmParseReg,            5,  5, 1 /*idxParam*/),
     621    DIS_ARMV8_INSN_DECODE(kDisParmParseRegOff,        16,  5, 1 /*idxParam*/),
     622    DIS_ARMV8_INSN_DECODE(kDisParmParseOption,        13,  3, 1 /*idxParam*/),
     623    DIS_ARMV8_INSN_DECODE(kDisParmParseS,             12,  1, 1 /*idxParam*/),
     624DIS_ARMV8_DECODE_INSN_CLASS_DEFINE_END_PARAMS_2(LdStRegOffGpr, 0xffe00c00 /*fFixedInsn*/, 0 /*fClass*/,
     625                                                kDisArmV8OpcDecodeCollate,
     626                                                RT_BIT_32(22) | RT_BIT_32(23) | RT_BIT_32(30) | RT_BIT_32(31), 22,
     627                                                kDisArmv8OpParmGpr, kDisArmv8OpParmAddrInGpr);
     628
     629
     630/*
     631 * C4.1.94 - Loads and Stores - Load/Store register (register offset) variants
     632 *
     633 * Differentiate further based on the VR field.
     634 *
     635 *     Bit  26
     636 *     +-------------------------------------------
     637 *           0 GPR variants.
     638 *           1 SIMD/FP variants
     639 */
     640DIS_ARMV8_DECODE_MAP_DEFINE_BEGIN(LdStRegOff)
     641    DIS_ARMV8_DECODE_MAP_ENTRY(LdStRegOffGpr),
     642    DIS_ARMV8_DECODE_MAP_INVALID_ENTRY,             /** @todo */
     643DIS_ARMV8_DECODE_MAP_DEFINE_END(LdStRegOff, RT_BIT_32(26), 26);
     644
     645
    596646/*
    597647 * C4.1.94 - Loads and Stores - Load/Store register variants
    598648 *
     649 * Differentiate further based on the op2<1:0> field.
     650 *
     651 *     Bit  11 10
     652 *     +-------------------------------------------
     653 *           0  0 Atomic memory operations
     654 *           0  1 Load/store register (pac)
     655 *           1  0 Load/store register (register offset)
     656 *           1  1 Load/store register (pac)
     657 */
     658DIS_ARMV8_DECODE_MAP_DEFINE_BEGIN(LdStRegOp_0_1)
     659    DIS_ARMV8_DECODE_MAP_INVALID_ENTRY,         /** @todo */
     660    DIS_ARMV8_DECODE_MAP_INVALID_ENTRY,         /** @todo */
     661    DIS_ARMV8_DECODE_MAP_ENTRY(LdStRegOff),
     662    DIS_ARMV8_DECODE_MAP_INVALID_ENTRY,         /** @todo */
     663DIS_ARMV8_DECODE_MAP_DEFINE_END(LdStRegOp_0_1, RT_BIT_32(11) | RT_BIT_32(11), 10);
     664
     665
     666/*
     667 * C4.1.94 - Loads and Stores - Load/Store register variants
     668 *
     669 * Differentiate further based on the op2<11> field.
     670 *
     671 *     Bit  21
     672 *     +-------------------------------------------
     673 *           0 Load/store register (unscaled immediate) / Load/store register (immediate post-indexed) / Load/store register (unprivileged) / Load/store register (immediate pre-indexed)
     674 *           1 Atomic memory operations / Load/store register (register offset) / Load/store register (pac).
     675 */
     676DIS_ARMV8_DECODE_MAP_DEFINE_BEGIN(LdStRegOp11)
     677    DIS_ARMV8_DECODE_MAP_INVALID_ENTRY,         /** @todo */
     678    DIS_ARMV8_DECODE_MAP_ENTRY(LdStRegOp_0_1),
     679DIS_ARMV8_DECODE_MAP_DEFINE_END(LdStRegOp11, RT_BIT_32(21), 21);
     680
     681
     682/*
     683 * C4.1.94 - Loads and Stores - Load/Store register variants
     684 *
    599685 * Differentiate further based on the op2<14> field.
    600686 *
    601  *     Bit  14
     687 *     Bit  24
    602688 *     +-------------------------------------------
    603689 *           0 All the other Load/store register variants and Atomic memory operations.
    … …  
    605691 */
    606692DIS_ARMV8_DECODE_MAP_DEFINE_BEGIN(LdStReg)
    607     DIS_ARMV8_DECODE_MAP_INVALID_ENTRY,             /** @todo */
     693    DIS_ARMV8_DECODE_MAP_ENTRY(LdStRegOp11),
    608694    DIS_ARMV8_DECODE_MAP_ENTRY(LdStRegUImm),
    609695DIS_ARMV8_DECODE_MAP_DEFINE_END(LdStReg, RT_BIT_32(24), 24);

  • trunk/src/VBox/Disassembler/testcase/tstDisasmArmv8-1-asm.S

    r105830 r105848  
    420420        ldp x0, x1, [x28, #504]
    421421
     422        ldr  x0, [x1, x2]
     423        ldr  w0, [x1, x2]
     424        ldr  x0, [x1, x2, SXTX #0]
     425        ldr  x0, [x1, x2, LSL  #3]  ; UXTX
     426        ldr  x0, [x1, x2, SXTX #3]
     427        ldr  w0, [x1, w2, UXTW #0]
     428        ldr  w0, [x1, w2, SXTW #0]
     429        ldr  w0, [x1, w2, UXTW #2]
     430        ldr  w0, [x1, w2, SXTW #2]
     431
     432        ldrb w0, [x1, x2]
     433        ldrb w0, [x1, x2, LSL  #0]  ; UXTX
     434        ldrb w0, [x1, x2, SXTX #0]
     435        ldrb w0, [x1, w2, UXTW #0]
     436        ldrb w0, [x1, w2, SXTW #0]
     437
     438        ldrsb w0, [x1, x2]
     439        ldrsb w0, [x1, x2, LSL  #0] ; UXTX
     440        ldrsb w0, [x1, x2, SXTX #0]
     441        ldrsb w0, [x1, w2, UXTW #0]
     442        ldrsb w0, [x1, w2, SXTW #0]
     443
     444        ldrh w0, [x1, x2]
     445        ;ldrh w0, [x1, x2, LSL  #0]  ; UXTX
     446        ldrh w0, [x1, x2, SXTX #0]
     447        ldrh w0, [x1, x2, LSL  #1]   ; UXTX
     448        ldrh w0, [x1, x2, SXTX #1]
     449        ldrh w0, [x1, w2, UXTW #0]
     450        ldrh w0, [x1, w2, SXTW #0]
     451        ldrh w0, [x1, w2, UXTW #1]
     452        ldrh w0, [x1, w2, SXTW #1]
     453
     454        ldrsh w0, [x1, x2]
     455        ;ldrsh w0, [x1, x2, LSL  #0] ; UXTX
     456        ldrsh w0, [x1, x2, SXTX #0]
     457        ldrsh w0, [x1, x2, LSL  #1]   ; UXTX
     458        ldrsh w0, [x1, x2, SXTX #1]
     459        ldrsh w0, [x1, w2, UXTW #0]
     460        ldrsh w0, [x1, w2, SXTW #0]
     461        ldrsh w0, [x1, w2, UXTW #1]
     462        ldrsh w0, [x1, w2, SXTW #1]
     463
     464        ldrsw x0, [x1, x2]
     465        ;ldrsw x0, [x1, x2, LSL  #0] ; UXTX
     466        ldrsw x0, [x1, x2, SXTX #0]
     467        ldrsw x0, [x1, x2, LSL  #2]  ; UXTX
     468        ldrsw x0, [x1, x2, SXTX #2]
     469        ldrsw x0, [x1, w2, UXTW #0]
     470        ldrsw x0, [x1, w2, SXTW #0]
     471        ldrsw x0, [x1, w2, UXTW #2]
     472        ldrsw x0, [x1, w2, SXTW #2]
     473
    422474        ; Memory stores
    423475        strb w0, [x28]
    … …  
    446498        stp x0, x1, [x28, #-512]
    447499        stp x0, x1, [x28, #504]
     500
     501        str  x0, [x1, x2]
     502        str  w0, [x1, x2]
     503        str  x0, [x1, x2, SXTX #0]
     504        str  x0, [x1, x2, LSL  #3]  ; UXTX
     505        str  x0, [x1, x2, SXTX #3]
     506        str  w0, [x1, w2, UXTW #0]
     507        str  w0, [x1, w2, SXTW #0]
     508        str  w0, [x1, w2, UXTW #2]
     509        str  w0, [x1, w2, SXTW #2]
     510
     511        strb w0, [x1, x2]
     512        strb w0, [x1, x2, LSL  #0x0]
     513        strb w0, [x1, x2, SXTX #0x0]
     514        strb w0, [x1, w2, UXTW #0x0]
     515        strb w0, [x1, w2, SXTW #0x0]
     516
     517        strh w0, [x1, x2]
     518        ;strh w0, [x1, x2, LSL  #0x0] ; UXTX
     519        strh w0, [x1, x2, SXTX #0x0]
     520        strh w0, [x1, x2, LSL  #1]   ; UXTX
     521        strh w0, [x1, x2, SXTX #1]
     522        strh w0, [x1, w2, UXTW #0x0]
     523        strh w0, [x1, w2, SXTW #0x0]
     524        strh w0, [x1, w2, UXTW #1]
     525        strh w0, [x1, w2, SXTW #1]
    448526
    449527        ; Conditional compare

  • trunk/src/VBox/Disassembler/testcase/tstDisasmArmv8-1.cpp

    r105759 r105848  
    3030*   Header Files                                                                                                                 *
    3131*********************************************************************************************************************************/
     32#define VBOX_DIS_WITH_ARMV8
    3233#include <VBox/dis.h>
    3334#include <iprt/test.h>
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