VirtualBox

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


Ignore:
Timestamp:
Aug 19, 2024 1:27:44 PM (8 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
164428
Message:

Disassembler,VMM,HostDrivers,Debugger,MakeAlternativeSource: Convert DISSTATE::Param1,...,DISSTATE::Param4 to DISSTATE::aParams[4] for easier indexing, bugref:10394

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

Legend:

Unmodified
Added
Removed

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

    r101539 r105724  
    308308
    309309#ifdef VBOX_STRICT
    310     pDis->Param1.uValue     = UINT64_C(0xb1b1b1b1b1b1b1b1);
    311     pDis->Param2.uValue     = UINT64_C(0xb2b2b2b2b2b2b2b2);
    312     pDis->Param3.uValue     = UINT64_C(0xb3b3b3b3b3b3b3b3);
     310    pDis->aParams[0].uValue = UINT64_C(0xb1b1b1b1b1b1b1b1);
     311    pDis->aParams[1].uValue = UINT64_C(0xb2b2b2b2b2b2b2b2);
     312    pDis->aParams[2].uValue = UINT64_C(0xb3b3b3b3b3b3b3b3);
     313    pDis->aParams[3].uValue = UINT64_C(0xb4b4b4b4b4b4b4b4);
    313314#endif
    314315

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

    r101539 r105724  
    301301
    302302    /* Should contain the parameter type on input. */
    303     pDis->Param1.armv8.fParam = pOp->Opc.fParam1;
    304     pDis->Param2.armv8.fParam = pOp->Opc.fParam2;
    305     pDis->Param3.armv8.fParam = pOp->Opc.fParam3;
    306     pDis->Param4.armv8.fParam = pOp->Opc.fParam4;
     303    pDis->aParams[0].armv8.fParam = pOp->Opc.fParam1;
     304    pDis->aParams[1].armv8.fParam = pOp->Opc.fParam2;
     305    pDis->aParams[2].armv8.fParam = pOp->Opc.fParam3;
     306    pDis->aParams[3].armv8.fParam = pOp->Opc.fParam4;
    307307
    308308    pDis->pCurInstr = &pOp->Opc;
    … …  
    318318    int rc = VINF_SUCCESS;
    319319    if (pInsnClass->aParms[0].idxParse != kDisParmParseNop)
    320         rc = g_apfnDisasm[pInsnClass->aParms[0].idxParse](pDis, u32Insn, pInsnClass, &pDis->Param1, &pInsnClass->aParms[0], f64Bit);
     320        rc = g_apfnDisasm[pInsnClass->aParms[0].idxParse](pDis, u32Insn, pInsnClass, &pDis->aParams[0], &pInsnClass->aParms[0], f64Bit);
    321321
    322322    if (   pInsnClass->aParms[1].idxParse != kDisParmParseNop
    323323        && RT_SUCCESS(rc))
    324         rc = g_apfnDisasm[pInsnClass->aParms[1].idxParse](pDis, u32Insn, pInsnClass, &pDis->Param2, &pInsnClass->aParms[1], f64Bit);
     324        rc = g_apfnDisasm[pInsnClass->aParms[1].idxParse](pDis, u32Insn, pInsnClass, &pDis->aParams[1], &pInsnClass->aParms[1], f64Bit);
    325325
    326326    if (   pInsnClass->aParms[2].idxParse != kDisParmParseNop
    327327        && RT_SUCCESS(rc))
    328         rc = g_apfnDisasm[pInsnClass->aParms[2].idxParse](pDis, u32Insn, pInsnClass, &pDis->Param3, &pInsnClass->aParms[2], f64Bit);
     328        rc = g_apfnDisasm[pInsnClass->aParms[2].idxParse](pDis, u32Insn, pInsnClass, &pDis->aParams[2], &pInsnClass->aParms[2], f64Bit);
    329329
    330330    if (   pInsnClass->aParms[3].idxParse != kDisParmParseNop
    331331        && RT_SUCCESS(rc))
    332         rc = g_apfnDisasm[pInsnClass->aParms[3].idxParse](pDis, u32Insn, pInsnClass, &pDis->Param4, &pInsnClass->aParms[3], f64Bit);
     332        rc = g_apfnDisasm[pInsnClass->aParms[3].idxParse](pDis, u32Insn, pInsnClass, &pDis->aParams[3], &pInsnClass->aParms[3], f64Bit);
    333333
    334334    /* If parameter parsing returned an invalid opcode error the encoding is invalid. */
    … …  
    337337        pDis->pCurInstr = &g_ArmV8A64InvalidOpcode[0];
    338338
    339         pDis->Param1.armv8.fParam = g_ArmV8A64InvalidOpcode[0].fParam1;
    340         pDis->Param2.armv8.fParam = g_ArmV8A64InvalidOpcode[0].fParam2;
    341         pDis->Param3.armv8.fParam = g_ArmV8A64InvalidOpcode[0].fParam3;
    342         pDis->Param4.armv8.fParam = g_ArmV8A64InvalidOpcode[0].fParam4;
     339        pDis->aParams[0].armv8.fParam = g_ArmV8A64InvalidOpcode[0].fParam1;
     340        pDis->aParams[1].armv8.fParam = g_ArmV8A64InvalidOpcode[0].fParam2;
     341        pDis->aParams[2].armv8.fParam = g_ArmV8A64InvalidOpcode[0].fParam3;
     342        pDis->aParams[3].armv8.fParam = g_ArmV8A64InvalidOpcode[0].fParam4;
    343343    }
    344344    pDis->rc = rc;

  • trunk/src/VBox/Disassembler/DisasmCore-x86-amd64.cpp

    r103927 r105724  
    265265
    266266    // Should contain the parameter type on input
    267     pDis->Param1.x86.fParam = pOp->fParam1;
    268     pDis->Param2.x86.fParam = pOp->fParam2;
    269     pDis->Param3.x86.fParam = pOp->fParam3;
    270     pDis->Param4.x86.fParam = pOp->fParam4;
     267    pDis->aParams[0].x86.fParam = pOp->fParam1;
     268    pDis->aParams[1].x86.fParam = pOp->fParam2;
     269    pDis->aParams[2].x86.fParam = pOp->fParam3;
     270    pDis->aParams[3].x86.fParam = pOp->fParam4;
    271271
    272272    /* Correct the operand size if the instruction is marked as forced or default 64 bits */
    … …  
    293293    if (pOp->idxParse1 != IDX_ParseNop)
    294294    {
    295         offInstr = pDis->x86.pfnDisasmFnTable[pOp->idxParse1](offInstr, pOp, pDis, &pDis->Param1);
    296         if (fFiltered == false) pDis->Param1.x86.cb = DISGetParamSize(pDis, &pDis->Param1);
     295        offInstr = pDis->x86.pfnDisasmFnTable[pOp->idxParse1](offInstr, pOp, pDis, &pDis->aParams[0]);
     296        if (fFiltered == false) pDis->aParams[0].x86.cb = DISGetParamSize(pDis, &pDis->aParams[0]);
    297297    }
    298298
    299299    if (pOp->idxParse2 != IDX_ParseNop)
    300300    {
    301         offInstr = pDis->x86.pfnDisasmFnTable[pOp->idxParse2](offInstr, pOp, pDis, &pDis->Param2);
    302         if (fFiltered == false) pDis->Param2.x86.cb = DISGetParamSize(pDis, &pDis->Param2);
     301        offInstr = pDis->x86.pfnDisasmFnTable[pOp->idxParse2](offInstr, pOp, pDis, &pDis->aParams[1]);
     302        if (fFiltered == false) pDis->aParams[1].x86.cb = DISGetParamSize(pDis, &pDis->aParams[1]);
    303303    }
    304304
    305305    if (pOp->idxParse3 != IDX_ParseNop)
    306306    {
    307         offInstr = pDis->x86.pfnDisasmFnTable[pOp->idxParse3](offInstr, pOp, pDis, &pDis->Param3);
    308         if (fFiltered == false) pDis->Param3.x86.cb = DISGetParamSize(pDis, &pDis->Param3);
     307        offInstr = pDis->x86.pfnDisasmFnTable[pOp->idxParse3](offInstr, pOp, pDis, &pDis->aParams[2]);
     308        if (fFiltered == false) pDis->aParams[2].x86.cb = DISGetParamSize(pDis, &pDis->aParams[2]);
    309309    }
    310310
    311311    if (pOp->idxParse4 != IDX_ParseNop)
    312312    {
    313         offInstr = pDis->x86.pfnDisasmFnTable[pOp->idxParse4](offInstr, pOp, pDis, &pDis->Param4);
    314         if (fFiltered == false) pDis->Param4.x86.cb = DISGetParamSize(pDis, &pDis->Param4);
     313        offInstr = pDis->x86.pfnDisasmFnTable[pOp->idxParse4](offInstr, pOp, pDis, &pDis->aParams[3]);
     314        if (fFiltered == false) pDis->aParams[3].x86.cb = DISGetParamSize(pDis, &pDis->aParams[3]);
    315315    }
    316316    // else simple one byte instruction
    … …  
    334334
    335335        // Should contain the parameter type on input
    336         pDis->Param1.x86.fParam = fpop->fParam1;
    337         pDis->Param2.x86.fParam = fpop->fParam2;
     336        pDis->aParams[0].x86.fParam = fpop->fParam1;
     337        pDis->aParams[1].x86.fParam = fpop->fParam2;
    338338    }
    339339    else
    … …  
    14791479
    14801480        if (    (pOp->fOpType & DISOPTYPE_X86_REXB_EXTENDS_OPREG)
    1481             &&  pParam == &pDis->Param1             /* ugly assumption that it only applies to the first parameter */
     1481            &&  pParam == &pDis->aParams[0]         /* ugly assumption that it only applies to the first parameter */
    14821482            &&  (pDis->x86.fPrefix & DISPREFIX_REX)
    14831483            &&  (pDis->x86.fRexPrefix & DISPREFIX_REX_FLAGS_B))
    … …  
    15101510        if (   pDis->uCpuMode == DISCPUMODE_64BIT
    15111511            && (pOp->fOpType & DISOPTYPE_X86_REXB_EXTENDS_OPREG)
    1512             &&  pParam == &pDis->Param1             /* ugly assumption that it only applies to the first parameter */
     1512            &&  pParam == &pDis->aParams[0]         /* ugly assumption that it only applies to the first parameter */
    15131513            &&  (pDis->x86.fPrefix & DISPREFIX_REX))
    15141514        {
    … …  
    24522452        case OP_XCHG:
    24532453        case OP_XOR:
    2454             if (pDis->Param1.fUse & (DISUSE_BASE | DISUSE_INDEX | DISUSE_DISPLACEMENT64 | DISUSE_DISPLACEMENT32
    2455                                      | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT8 | DISUSE_RIPDISPLACEMENT32))
     2454            if (pDis->aParams[0].fUse & (  DISUSE_BASE | DISUSE_INDEX | DISUSE_DISPLACEMENT64 | DISUSE_DISPLACEMENT32
     2455                                         | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT8 | DISUSE_RIPDISPLACEMENT32))
    24562456                return;
    24572457            break;
    … …  
    26002600{
    26012601#ifdef VBOX_STRICT /* poison */
    2602     pDis->Param1.x86.Base.idxGenReg    = 0xc1;
    2603     pDis->Param2.x86.Base.idxGenReg    = 0xc2;
    2604     pDis->Param3.x86.Base.idxGenReg    = 0xc3;
    2605     pDis->Param1.x86.Index.idxGenReg   = 0xc4;
    2606     pDis->Param2.x86.Index.idxGenReg   = 0xc5;
    2607     pDis->Param3.x86.Index.idxGenReg   = 0xc6;
    2608     pDis->Param1.x86.uDisp.u64         = UINT64_C(0xd1d1d1d1d1d1d1d1);
    2609     pDis->Param2.x86.uDisp.u64         = UINT64_C(0xd2d2d2d2d2d2d2d2);
    2610     pDis->Param3.x86.uDisp.u64         = UINT64_C(0xd3d3d3d3d3d3d3d3);
    2611     pDis->Param1.uValue                     = UINT64_C(0xb1b1b1b1b1b1b1b1);
    2612     pDis->Param2.uValue                     = UINT64_C(0xb2b2b2b2b2b2b2b2);
    2613     pDis->Param3.uValue                     = UINT64_C(0xb3b3b3b3b3b3b3b3);
    2614     pDis->Param1.x86.uScale            = 28;
    2615     pDis->Param2.x86.uScale            = 29;
    2616     pDis->Param3.x86.uScale            = 30;
     2602    pDis->aParams[0].x86.Base.idxGenReg    = 0xc1;
     2603    pDis->aParams[1].x86.Base.idxGenReg    = 0xc2;
     2604    pDis->aParams[2].x86.Base.idxGenReg    = 0xc3;
     2605    pDis->aParams[0].x86.Index.idxGenReg   = 0xc4;
     2606    pDis->aParams[1].x86.Index.idxGenReg   = 0xc5;
     2607    pDis->aParams[2].x86.Index.idxGenReg   = 0xc6;
     2608    pDis->aParams[0].x86.uDisp.u64         = UINT64_C(0xd1d1d1d1d1d1d1d1);
     2609    pDis->aParams[1].x86.uDisp.u64         = UINT64_C(0xd2d2d2d2d2d2d2d2);
     2610    pDis->aParams[2].x86.uDisp.u64         = UINT64_C(0xd3d3d3d3d3d3d3d3);
     2611    pDis->aParams[0].uValue                = UINT64_C(0xb1b1b1b1b1b1b1b1);
     2612    pDis->aParams[1].uValue                = UINT64_C(0xb2b2b2b2b2b2b2b2);
     2613    pDis->aParams[2].uValue                = UINT64_C(0xb3b3b3b3b3b3b3b3);
     2614    pDis->aParams[0].x86.uScale            = 28;
     2615    pDis->aParams[1].x86.uScale            = 29;
     2616    pDis->aParams[2].x86.uScale            = 30;
    26172617#endif
    26182618

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

    r101540 r105724  
    286286         * Formatting context and associated macros.
    287287         */
    288         PCDISOPPARAM pParam = &pDis->Param1;
    289         int iParam = 1;
     288        PCDISOPPARAM pParam = &pDis->aParams[0];
     289        uint32_t iParam = 0;
    290290
    291291        const char *pszFmt = pOp->pszOpcode;
    … …  
    401401                            pszFmt++;
    402402
    403                         switch (++iParam)
     403                        iParam++;
     404                        if (iParam >= RT_ELEMENTS(pDis->aParams))
    404405                        {
    405                             case 2: pParam = &pDis->Param2; break;
    406                             case 3: pParam = &pDis->Param3; break;
    407                             case 4: pParam = &pDis->Param4; break;
    408                             default: pParam = NULL; break;
     406                            AssertFailed();
     407                            pParam = NULL;
    409408                        }
     409                        else
     410                            pParam = &pDis->aParams[iParam];
    410411                        break;
    411412                    }
    … …  
    424425                    Assert(*pszFmt != ' ');
    425426                    PUT_C(' ');
    426                     switch (++iParam)
     427                    iParam++;
     428                    if (iParam >= RT_ELEMENTS(pDis->aParams))
    427429                    {
    428                         case 2: pParam = &pDis->Param2; break;
    429                         case 3: pParam = &pDis->Param3; break;
    430                         case 4: pParam = &pDis->Param4; break;
    431                         default: pParam = NULL; break;
     430                        AssertFailed();
     431                        pParam = NULL;
    432432                    }
     433                    else
     434                        pParam = &pDis->aParams[iParam];
    433435                }
    434436            }

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

    r103928 r105724  
    642642                        if (   (*pszFmt == '#' && !(pDis->x86.bVexByte2 & DISPREFIX_VEX_F_W)) /** @todo check this*/
    643643                            || (*pszFmt == '@' && !VEXREG_IS256B(pDis->x86.bVexDestReg))
    644                             || (*pszFmt == '&' && (   DISUSE_IS_EFFECTIVE_ADDR(pDis->Param1.fUse)
    645                                                    || DISUSE_IS_EFFECTIVE_ADDR(pDis->Param2.fUse)
    646                                                    || DISUSE_IS_EFFECTIVE_ADDR(pDis->Param3.fUse)
    647                                                    || DISUSE_IS_EFFECTIVE_ADDR(pDis->Param4.fUse))))
     644                            || (*pszFmt == '&' && (   DISUSE_IS_EFFECTIVE_ADDR(pDis->aParams[0].fUse)
     645                                                   || DISUSE_IS_EFFECTIVE_ADDR(pDis->aParams[1].fUse)
     646                                                   || DISUSE_IS_EFFECTIVE_ADDR(pDis->aParams[2].fUse)
     647                                                   || DISUSE_IS_EFFECTIVE_ADDR(pDis->aParams[3].fUse))))
    648648                        {
    649649                            strncpy(pszFmtDst, pszFmt + 1, pszDelim - pszFmt - 1);
    … …  
    666666            case OP_FLD:
    667667                if (pDis->x86.bOpCode == 0xdb) /* m80fp workaround. */
    668                     *(int *)&pDis->Param1.x86.fParam &= ~0x1f; /* make it pure OP_PARM_M */
     668                    *(int *)&pDis->aParams[0].x86.fParam &= ~0x1f; /* make it pure OP_PARM_M */
    669669                break;
    670670            case OP_LAR: /* hack w -> v, probably not correct. */
    671                 *(int *)&pDis->Param2.x86.fParam &= ~0x1f;
    672                 *(int *)&pDis->Param2.x86.fParam |= OP_PARM_v;
     671                *(int *)&pDis->aParams[1].x86.fParam &= ~0x1f;
     672                *(int *)&pDis->aParams[2].x86.fParam |= OP_PARM_v;
    673673                break;
    674674        }
    … …  
    698698         * Formatting context and associated macros.
    699699         */
    700         PCDISOPPARAM pParam = &pDis->Param1;
    701         int iParam = 1;
     700        PCDISOPPARAM pParam = &pDis->aParams[0];
     701        uint32_t iParam = 0;
    702702
    703703#define PUT_FAR() \
    … …  
    787787         */
    788788        if (    (pDis->x86.fPrefix & DISPREFIX_SEG)
    789             &&  !DISUSE_IS_EFFECTIVE_ADDR(pDis->Param1.fUse)
    790             &&  !DISUSE_IS_EFFECTIVE_ADDR(pDis->Param2.fUse)
    791             &&  !DISUSE_IS_EFFECTIVE_ADDR(pDis->Param3.fUse))
     789            &&  !DISUSE_IS_EFFECTIVE_ADDR(pDis->aParams[0].fUse)
     790            &&  !DISUSE_IS_EFFECTIVE_ADDR(pDis->aParams[1].fUse)
     791            &&  !DISUSE_IS_EFFECTIVE_ADDR(pDis->aParams[2].fUse))
    792792        {
    793793            PUT_STR(s_szSegPrefix[pDis->x86.idxSegPrefix], 2);
    … …  
    10851085                    {
    10861086                        int32_t offDisplacement;
    1087                         Assert(iParam == 1);
     1087                        Assert(iParam == 0);
    10881088                        bool fPrefix = (fFlags & DIS_FMT_FLAGS_STRICT)
    10891089                                    && pOp->uOpcode != OP_CALL
    … …  
    12871287                    Assert(*pszFmt != ' ');
    12881288                    PUT_C(' ');
    1289                     switch (++iParam)
     1289                    iParam++;
     1290                    if (iParam >= RT_ELEMENTS(pDis->aParams))
    12901291                    {
    1291                         case 2: pParam = &pDis->Param2; break;
    1292                         case 3: pParam = &pDis->Param3; break;
    1293                         case 4: pParam = &pDis->Param4; break;
    1294                         default: pParam = NULL; break;
     1292                        AssertFailed();
     1293                        pParam = NULL;
    12951294                    }
     1295                    else
     1296                        pParam = &pDis->aParams[iParam];
    12961297                }
    12971298            }
    … …  
    14781479        /* no effective address which it may apply to. */
    14791480        Assert((pDis->x86.fPrefix & DISPREFIX_SEG) || pDis->uCpuMode == DISCPUMODE_64BIT);
    1480         if (    !DISUSE_IS_EFFECTIVE_ADDR(pDis->Param1.fUse)
    1481             &&  !DISUSE_IS_EFFECTIVE_ADDR(pDis->Param2.fUse)
    1482             &&  !DISUSE_IS_EFFECTIVE_ADDR(pDis->Param3.fUse))
     1481        if (    !DISUSE_IS_EFFECTIVE_ADDR(pDis->aParams[0].fUse)
     1482            &&  !DISUSE_IS_EFFECTIVE_ADDR(pDis->aParams[1].fUse)
     1483            &&  !DISUSE_IS_EFFECTIVE_ADDR(pDis->aParams[2].fUse))
    14831484            return true;
    14841485
    … …  
    16891690    /* shl eax,1 will be assembled to the form without the immediate byte. */
    16901691    if (    pDis->pCurInstr->fParam2 == OP_PARM_Ib
    1691         &&  (uint8_t)pDis->Param2.uValue == 1)
     1692        &&  (uint8_t)pDis->aParams[1].uValue == 1)
    16921693    {
    16931694        switch (pDis->pCurInstr->uOpcode)

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

    r101539 r105724  
    160160        {
    161161            uint32_t cb2;
    162             RTTESTI_CHECK_MSG((cb2 = DISGetParamSize(&Dis, &Dis.Param1)) == s_gInstrs[i].cbParam1,
     162            RTTESTI_CHECK_MSG((cb2 = DISGetParamSize(&Dis, &Dis.aParams[0])) == s_gInstrs[i].cbParam1,
    163163                              ("%u: %#x vs %#x\n", i , cb2, s_gInstrs[i].cbParam1));
    164164#ifndef DIS_CORE_ONLY
    165             RTTESTI_CHECK_MSG((cb2 = DISGetParamSize(&Dis, &Dis.Param2)) == s_gInstrs[i].cbParam2,
     165            RTTESTI_CHECK_MSG((cb2 = DISGetParamSize(&Dis, &Dis.aParams[1])) == s_gInstrs[i].cbParam2,
    166166                              ("%u: %#x vs %#x (%s)\n", i , cb2, s_gInstrs[i].cbParam2, Dis.pCurInstr->pszOpcode));
    167167#else
    168             RTTESTI_CHECK_MSG((cb2 = DISGetParamSize(&Dis, &Dis.Param2)) == s_gInstrs[i].cbParam2,
     168            RTTESTI_CHECK_MSG((cb2 = DISGetParamSize(&Dis, &Dis.aParams[1])) == s_gInstrs[i].cbParam2,
    169169                              ("%u: %#x vs %#x\n", i , cb2, s_gInstrs[i].cbParam2));
    170170#endif
    171             RTTESTI_CHECK_MSG((cb2 = DISGetParamSize(&Dis, &Dis.Param3)) == s_gInstrs[i].cbParam3,
     171            RTTESTI_CHECK_MSG((cb2 = DISGetParamSize(&Dis, &Dis.aParams[2])) == s_gInstrs[i].cbParam3,
    172172                              ("%u: %#x vs %#x\n", i , cb2, s_gInstrs[i].cbParam3));
    173173        }
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