VirtualBox

Changeset 8333

Show
Ignore:
Timestamp:
04/23/08 16:42:17 (9 months ago)
Author:
vboxsync
Message:

Disassembler updates for 64 bits support

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/include/VBox/dis.h

    r8299 r8333  
    412412    OP_PARAMETER    param3; 
    413413 
    414     /** ModRM byte. */ 
    415     uint32_t        ModRM; 
    416     /** scalar, index, base byte. */ 
    417     uint32_t        SIB; 
     414    /** ModRM fields. */ 
     415    union 
     416    { 
     417        /* Bitfield view */ 
     418        struct 
     419        { 
     420            unsigned        Rm  : 4; 
     421            unsigned        Reg : 4; 
     422            unsigned        Mod : 2; 
     423        } Bits; 
     424        /* unsigned view */ 
     425        unsigned            u; 
     426    } ModRM; 
     427 
     428    /** SIB fields. */ 
     429    union 
     430    { 
     431        /* Bitfield view */ 
     432        struct 
     433        { 
     434            unsigned        Base  : 4; 
     435            unsigned        Index : 4; 
     436            unsigned        Scale : 2; 
     437        } Bits; 
     438        /* unsigned view */ 
     439        unsigned            u; 
     440    } SIB; 
    418441 
    419442    int32_t         disp; 

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

    r8299 r8333  
    126126    pCpu->addrmode    = pCpu->mode; 
    127127    pCpu->opmode      = pCpu->mode; 
    128     pCpu->ModRM       = 0; 
    129     pCpu->SIB         = 0; 
     128    pCpu->ModRM.u     = 0; 
     129    pCpu->SIB.u       = 0; 
    130130    pCpu->lastprefix  = 0; 
    131131    pCpu->param1.parval = 0; 

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

    r8299 r8333  
    6565#endif 
    6666 
    67 static unsigned QueryModRM(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, int *pSibInc = NULL); 
    68 static unsigned QueryModRM_SizeOnly(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, int *pSibInc = NULL); 
     67static unsigned QueryModRM(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc = NULL); 
     68static unsigned QueryModRM_SizeOnly(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc = NULL); 
    6969static void     UseSIB(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu); 
    7070static unsigned ParseSIB_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu); 
    …… 
    176176    pCpu->addrmode   = pCpu->mode; 
    177177    pCpu->opmode     = pCpu->mode; 
    178     pCpu->ModRM      = 0; 
    179     pCpu->SIB        = 0; 
     178    pCpu->ModRM.u    = 0; 
     179    pCpu->SIB.u      = 0; 
    180180    pCpu->param1.parval = 0; 
    181181    pCpu->param2.parval = 0; 
    …… 
    223223    pCpu->addrmode   = enmCpuMode; 
    224224    pCpu->opmode     = enmCpuMode; 
    225     pCpu->ModRM      = 0; 
    226     pCpu->SIB        = 0; 
     225    pCpu->ModRM.u    = 0; 
     226    pCpu->SIB.u      = 0; 
    227227    pCpu->param1.parval = 0; 
    228228    pCpu->param2.parval = 0; 
    …… 
    410410    int index; 
    411411    const OPCODE *fpop; 
    412     unsigned size = 0; 
    413  
    414     pCpu->ModRM = DISReadByte(pCpu, lpszCodeBlock); 
     412    unsigned size = 0, ModRM; 
     413 
     414    ModRM = DISReadByte(pCpu, lpszCodeBlock); 
    415415 
    416416    index = pCpu->opcode - 0xD8; 
    417     if (pCpu->ModRM <= 0xBF) 
    418     { 
    419         fpop            = &(g_paMapX86_FP_Low[index])[MODRM_REG(pCpu->ModRM)]; 
     417    if (ModRM <= 0xBF) 
     418    { 
     419        fpop            = &(g_paMapX86_FP_Low[index])[MODRM_REG(ModRM)]; 
    420420        pCpu->pCurInstr = (PCOPCODE)fpop; 
    421421 
    …… 
    423423        pCpu->param1.parval = fpop->param1; 
    424424        pCpu->param2.parval = fpop->param2; 
    425  
    426         /* 
    427          * Apply filter to instruction type to determine if a full disassembly is required. 
    428          * @note Multibyte opcodes are always marked harmless until the final byte. 
    429          */ 
    430         if ((fpop->optype & pCpu->uFilter) == 0) 
    431         { 
    432             pCpu->pfnDisasmFnTable = pfnCalcSize; 
    433         } 
    434         else 
    435         { 
    436             /* Not filtered out -> full disassembly */ 
    437             pCpu->pfnDisasmFnTable = pfnFullDisasm; 
    438         } 
    439  
    440         // Little hack to make sure the ModRM byte is included in the returned size 
    441         if (fpop->idxParse1 != IDX_ParseModRM && fpop->idxParse2 != IDX_ParseModRM) 
    442             size = sizeof(uint8_t); //ModRM byte 
    443  
    444         if (fpop->idxParse1 != IDX_ParseNop) 
    445             size += pCpu->pfnDisasmFnTable[fpop->idxParse1](lpszCodeBlock+size, (PCOPCODE)fpop, pParam, pCpu); 
    446  
    447         if (fpop->idxParse2 != IDX_ParseNop) 
    448             size += pCpu->pfnDisasmFnTable[fpop->idxParse2](lpszCodeBlock+size, (PCOPCODE)fpop, pParam, pCpu); 
    449     } 
    450     else 
    451     { 
    452         size            = sizeof(uint8_t); //ModRM byte only 
    453         fpop            = &(g_paMapX86_FP_High[index])[pCpu->ModRM - 0xC0]; 
     425    } 
     426    else 
     427    { 
     428        fpop            = &(g_paMapX86_FP_High[index])[ModRM - 0xC0]; 
    454429        pCpu->pCurInstr = (PCOPCODE)fpop; 
    455  
    456         /* 
    457          * Apply filter to instruction type to determine if a full disassembly is required. 
    458          * @note Multibyte opcodes are always marked harmless until the final byte. 
    459          */ 
    460         if ((fpop->optype & pCpu->uFilter) == 0) 
    461         { 
    462             pCpu->pfnDisasmFnTable = pfnCalcSize; 
    463         } 
    464         else 
    465         { 
    466             /* Not filtered out -> full disassembly */ 
    467             pCpu->pfnDisasmFnTable = pfnFullDisasm; 
    468         } 
    469     } 
     430    } 
     431 
     432    /* 
     433     * Apply filter to instruction type to determine if a full disassembly is required. 
     434     * @note Multibyte opcodes are always marked harmless until the final byte. 
     435     */ 
     436    if ((fpop->optype & pCpu->uFilter) == 0) 
     437    { 
     438        pCpu->pfnDisasmFnTable = pfnCalcSize; 
     439    } 
     440    else 
     441    { 
     442        /* Not filtered out -> full disassembly */ 
     443        pCpu->pfnDisasmFnTable = pfnFullDisasm; 
     444    } 
     445 
     446    // Little hack to make sure the ModRM byte is included in the returned size 
     447    if (fpop->idxParse1 != IDX_ParseModRM && fpop->idxParse2 != IDX_ParseModRM) 
     448        size = sizeof(uint8_t); //ModRM byte 
     449 
     450    if (fpop->idxParse1 != IDX_ParseNop) 
     451        size += pCpu->pfnDisasmFnTable[fpop->idxParse1](lpszCodeBlock+size, (PCOPCODE)fpop, pParam, pCpu); 
     452 
     453    if (fpop->idxParse2 != IDX_ParseNop) 
     454        size += pCpu->pfnDisasmFnTable[fpop->idxParse2](lpszCodeBlock+size, (PCOPCODE)fpop, pParam, pCpu); 
    470455 
    471456    // Store the opcode format string for disasmPrintf 
    …… 
    488473void UseSIB(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu) 
    489474{ 
    490     int scale, base, index; 
     475    unsigned scale, base, index; 
    491476    char szTemp[32]; 
    492477    szTemp[0] = '\0'; 
    493478 
    494     scale = SIB_SCALE(pCpu->SIB); 
    495     base  = SIB_BASE(pCpu->SIB); 
    496     index = SIB_INDEX(pCpu->SIB); 
     479    scale = pCpu->SIB.Bits.Scale; 
     480    base  = pCpu->SIB.Bits.Base; 
     481    index = pCpu->SIB.Bits.Index; 
    497482 
    498483    if (szSIBIndexReg[index]) 
    …… 
    507492         } 
    508493 
    509          if (base == 5 && MODRM_MOD(pCpu->ModRM) == 0) 
     494         if (base == 5 && pCpu->ModRM.Bits.Mod == 0) 
    510495             disasmAddStringF(szTemp, sizeof(szTemp), "%s%s", szSIBIndexReg[index], szSIBScale[scale]); 
    511496         else 
    …… 
    514499    else 
    515500    { 
    516          if (base != 5 || MODRM_MOD(pCpu->ModRM) != 0) 
     501         if (base != 5 || pCpu->ModRM.Bits.Mod != 0) 
    517502             disasmAddStringF(szTemp, sizeof(szTemp), "%s", szSIBBaseReg[base]); 
    518503    } 
    519504 
    520     if (base == 5 && MODRM_MOD(pCpu->ModRM) == 0) 
     505    if (base == 5 && pCpu->ModRM.Bits.Mod == 0) 
    521506    { 
    522507        // [scaled index] + disp32 
    …… 
    540525unsigned ParseSIB(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu) 
    541526{ 
    542     unsigned size = sizeof(uint8_t), base; 
    543  
    544     pCpu->SIB = DISReadByte(pCpu, lpszCodeBlock); 
     527    unsigned size = sizeof(uint8_t); 
     528    unsigned SIB; 
     529 
     530    SIB = DISReadByte(pCpu, lpszCodeBlock); 
    545531    lpszCodeBlock += size; 
    546532 
    547     base = SIB_BASE(pCpu->SIB); 
    548     if (base == 5 && MODRM_MOD(pCpu->ModRM) == 0) 
    549     {//additional 32 bits displacement 
     533    pCpu->SIB.Bits.Base  = SIB_BASE(SIB); 
     534    pCpu->SIB.Bits.Index = SIB_INDEX(SIB); 
     535    pCpu->SIB.Bits.Scale = SIB_SCALE(SIB); 
     536 
     537    if (pCpu->prefix & PREFIX_REX) 
     538    { 
     539        pCpu->SIB.Bits.Base  |= ((!!(pCpu->prefix_rex & PREFIX_REX_FLAGS_B)) << 3); 
     540        pCpu->SIB.Bits.Index |= ((!!(pCpu->prefix_rex & PREFIX_REX_FLAGS_X)) << 3); 
     541    } 
     542 
     543    if (    pCpu->SIB.Bits.Base == 5  
     544        &&  pCpu->ModRM.Bits.Mod == 0) 
     545    {    
     546        /* Additional 32 bits displacement. No change in long mode. */ 
    550547        pCpu->disp = DISReadDWord(pCpu, lpszCodeBlock); 
    551548        size += sizeof(int32_t); 
    …… 
    557554unsigned ParseSIB_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu) 
    558555{ 
    559     unsigned size = sizeof(uint8_t), base; 
    560  
    561     pCpu->SIB = DISReadByte(pCpu, lpszCodeBlock); 
     556    unsigned size = sizeof(uint8_t); 
     557    unsigned SIB; 
     558 
     559    SIB = DISReadByte(pCpu, lpszCodeBlock); 
    562560    lpszCodeBlock += size; 
    563561 
    564     base = SIB_BASE(pCpu->SIB); 
    565     if (base == 5 && MODRM_MOD(pCpu->ModRM) == 0) 
    566     {//additional 32 bits displacement 
     562    pCpu->SIB.Bits.Base  = SIB_BASE(SIB); 
     563    pCpu->SIB.Bits.Index = SIB_INDEX(SIB); 
     564    pCpu->SIB.Bits.Scale = SIB_SCALE(SIB); 
     565 
     566    if (pCpu->prefix & PREFIX_REX) 
     567    { 
     568        /* REX.B extends the Base field. */ 
     569        pCpu->SIB.Bits.Base  |= ((!!(pCpu->prefix_rex & PREFIX_REX_FLAGS_B)) << 3); 
     570        /* REX.X extends the Index field. */ 
     571        pCpu->SIB.Bits.Index |= ((!!(pCpu->prefix_rex & PREFIX_REX_FLAGS_X)) << 3); 
     572    } 
     573 
     574    if (    pCpu->SIB.Bits.Base == 5  
     575        &&  pCpu->ModRM.Bits.Mod == 0) 
     576    { 
     577        /* Additional 32 bits displacement. No change in long mode. */ 
    567578        size += sizeof(int32_t); 
    568579    } 
    …… 
    576587unsigned UseModRM(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu) 
    577588{ 
    578     int reg   = MODRM_REG(pCpu->ModRM); 
    579     int rm    = MODRM_RM(pCpu->ModRM); 
    580     int mod   = MODRM_MOD(pCpu->ModRM); 
    581     int vtype = OP_PARM_VTYPE(pParam->param); 
     589    int      vtype = OP_PARM_VTYPE(pParam->param); 
     590    unsigned reg = pCpu->ModRM.Bits.Reg; 
     591    unsigned mod = pCpu->ModRM.Bits.Mod; 
     592    unsigned rm  = pCpu->ModRM.Bits.Rm; 
    582593 
    583594    switch (vtype) 
    …… 
    777788// Query the size of the ModRM parameters and fetch the immediate data (if any) 
    778789//***************************************************************************** 
    779 unsigned QueryModRM(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, int *pSibInc) 
    780 { 
    781     int mod, rm, sibinc; 
     790unsigned QueryModRM(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc) 
     791{ 
     792    unsigned sibinc; 
    782793    unsigned size = 0; 
    783  
    784     rm  = MODRM_RM(pCpu->ModRM); 
    785     mod = MODRM_MOD(pCpu->ModRM); 
     794    unsigned reg = pCpu->ModRM.Bits.Reg; 
     795    unsigned mod = pCpu->ModRM.Bits.Mod; 
     796    unsigned rm  = pCpu->ModRM.Bits.Rm; 
    786797 
    787798    if (!pSibInc) 
    788     { 
    789799        pSibInc = &sibinc; 
    790     } 
    791800 
    792801    *pSibInc = 0; 
    793802 
    794     if (pCpu->addrmode == CPUMODE_32BIT) 
    795     {//32 bits addressing mode 
     803    if (pCpu->addrmode != CPUMODE_16BIT) 
     804    { 
     805        Assert(pCpu->addrmode == CPUMODE_32BIT || pCpu->addrmode == CPUMODE_64BIT); 
     806 
     807        /* 
     808         * Note: displacements in long mode are 8 or 32 bits and sign-extended to 64 bits 
     809         */ 
    796810        if (mod != 3 && rm == 4) 
    797         {//SIB byte follows ModRM 
     811        {   /* SIB byte follows ModRM */ 
    798812            *pSibInc = ParseSIB(lpszCodeBlock, pOp, pParam, pCpu); 
    799813            lpszCodeBlock += *pSibInc; 
    …… 
    803817        switch (mod) 
    804818        { 
    805         case 0: //effective address 
    806             if (rm == 5) {//32 bits displacement 
     819        case 0: /* Effective address */ 
     820            if (rm == 5) {  /* 32 bits displacement */ 
    807821                pCpu->disp = DISReadDWord(pCpu, lpszCodeBlock); 
    808822                size += sizeof(int32_t); 
    809823            } 
    810             //else register address 
    811             break; 
    812  
    813         case 1: //effective address + 8 bits displacement 
     824            /* else register address */ 
     825            break; 
     826 
     827        case 1: /* Effective address + 8 bits displacement */ 
    814828            pCpu->disp = (int8_t)DISReadByte(pCpu, lpszCodeBlock); 
    815829            size += sizeof(char); 
    816830            break; 
    817831 
    818         case 2: //effective address + 32 bits displacement 
     832        case 2: /* Effective address + 32 bits displacement */ 
    819833            pCpu->disp = DISReadDWord(pCpu, lpszCodeBlock); 
    820834            size += sizeof(int32_t); 
    821835            break; 
    822836 
    823         case 3: //registers 
    824             break; 
    825         } 
    826     } 
    827     else 
    828     {//16 bits addressing mode 
     837        case 3: /* registers */ 
     838            break; 
     839        } 
     840    } 
     841    else 
     842    { 
     843        /* 16 bits mode */ 
    829844        switch (mod) 
    830845        { 
    831         case 0: //effective address 
     846        case 0: /* Effective address */ 
    832847            if (rm == 6) { 
    833848                pCpu->disp = DISReadWord(pCpu, lpszCodeBlock); 
    834849                size += sizeof(uint16_t); 
    835850            } 
    836             break; 
    837  
    838         case 1: //effective address + 8 bits displacement 
     851            /* else register address */ 
     852            break; 
     853 
     854        case 1: /* Effective address + 8 bits displacement */ 
    839855            pCpu->disp = (int8_t)DISReadByte(pCpu, lpszCodeBlock); 
    840856            size += sizeof(char); 
    841857            break; 
    842858 
    843         case 2: //effective address + 16 bits displacement 
     859        case 2: /* Effective address + 32 bits displacement */ 
    844860            pCpu->disp = (int16_t)DISReadWord(pCpu, lpszCodeBlock); 
    845861            size += sizeof(uint16_t); 
    846862            break; 
    847863 
    848         case 3: //registers 
     864        case 3: /* registers */ 
    849865            break; 
    850866        } 
    …… 
    855871// Query the size of the ModRM parameters and fetch the immediate data (if any) 
    856872//***************************************************************************** 
    857 unsigned QueryModRM_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, int *pSibInc) 
    858 { 
    859     int mod, rm, sibinc; 
     873unsigned QueryModRM_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc) 
     874{ 
     875    unsigned sibinc; 
    860876    unsigned size = 0; 
    861  
    862     rm  = MODRM_RM(pCpu->ModRM); 
    863     mod = MODRM_MOD(pCpu->ModRM); 
     877    unsigned reg = pCpu->ModRM.Bits.Reg; 
     878    unsigned mod = pCpu->ModRM.Bits.Mod; 
     879    unsigned rm  = pCpu->ModRM.Bits.Rm; 
    864880 
    865881    if (!pSibInc) 
    866     { 
    867882        pSibInc = &sibinc; 
    868     } 
    869883 
    870884    *pSibInc = 0; 
    871885 
    872     if (pCpu->addrmode == CPUMODE_32BIT) 
    873     {//32 bits addressing mode 
     886    if (pCpu->addrmode != CPUMODE_16BIT) 
     887    { 
     888        Assert(pCpu->addrmode == CPUMODE_32BIT || pCpu->addrmode == CPUMODE_64BIT); 
     889        /* 
     890         * Note: displacements in long mode are 8 or 32 bits and sign-extended to 64 bits 
     891         */ 
    874892        if (mod != 3 && rm == 4) 
    875         {//SIB byte follows ModRM 
     893        {   /* SIB byte follows ModRM */ 
    876894            *pSibInc = ParseSIB_SizeOnly(lpszCodeBlock, pOp, pParam, pCpu); 
    877895            lpszCodeBlock += *pSibInc; 
    …… 
    882900        { 
    883901        case 0: //effective address 
    884             if (rm == 5) {//32 bits displacement 
     902            if (rm == 5) {  /* 32 bits displacement */ 
    885903                size += sizeof(int32_t); 
    886904            } 
    887             //else register address 
    888             break; 
    889  
    890         case 1: //effective address + 8 bits displacement 
     905            /* else register address */ 
     906            break; 
     907 
     908        case 1: /* Effective address + 8 bits displacement */ 
    891909            size += sizeof(char); 
    892910            break; 
    893911 
    894         case 2: //effective address + 32 bits displacement 
     912        case 2: /* Effective address + 32 bits displacement */ 
    895913            size += sizeof(int32_t); 
    896914            break; 
    897915 
    898         case 3: //registers 
    899             break; 
    900         } 
    901     } 
    902     else 
    903     {//16 bits addressing mode 
     916        case 3: /* registers */ 
     917            break; 
     918        } 
     919    } 
     920    else 
     921    { 
     922        /* 16 bits mode */ 
    904923        switch (mod) 
    905924        { 
    …… 
    908927                size += sizeof(uint16_t); 
    909928            } 
    910             break; 
    911  
    912         case 1: //effective address + 8 bits displacement 
     929            /* else register address */ 
     930            break; 
     931 
     932        case 1: /* Effective address + 8 bits displacement */ 
    913933            size += sizeof(char); 
    914934            break; 
    915935 
    916         case 2: //effective address + 16 bits displacement 
     936        case 2: /* Effective address + 32 bits displacement */ 
    917937            size += sizeof(uint16_t); 
    918938            break; 
    919939 
    920         case 3: //registers 
     940        case 3: /* registers */ 
    921941            break; 
    922942        } 
    …… 
    936956{ 
    937957    unsigned size = sizeof(uint8_t);   //ModRM byte 
    938     int sibinc; 
    939  
    940     pCpu->ModRM    = DISReadByte(pCpu, lpszCodeBlock); 
     958    unsigned sibinc, ModRM; 
     959 
     960    ModRM = DISReadByte(pCpu, lpszCodeBlock); 
    941961    lpszCodeBlock += sizeof(uint8_t); 
    942962 
     963    pCpu->ModRM.Bits.Rm  = MODRM_RM(ModRM); 
     964    pCpu->ModRM.Bits.Mod = MODRM_MOD(ModRM); 
     965    pCpu->ModRM.Bits.Reg = MODRM_REG(ModRM); 
     966 
     967    if (pCpu->prefix & PREFIX_REX) 
     968    { 
     969        /* REX.R extends the Reg field. */ 
     970        pCpu->ModRM.Bits.Reg |= ((!!(pCpu->prefix_rex & PREFIX_REX_FLAGS_R)) << 3); 
     971 
     972        /* REX.B extends the Rm field if there is no SIB byte. */ 
     973        if (    pCpu->ModRM.Bits.Mod != 3  
     974            &&  pCpu->ModRM.Bits.Rm == 4) 
     975        { 
     976            pCpu->ModRM.Bits.Rm |= ((!!(pCpu->prefix_rex & PREFIX_REX_FLAGS_B)) << 3); 
     977        } 
     978    } 
    943979    size += QueryModRM(lpszCodeBlock, pOp, pParam, pCpu, &sibinc); 
    944980    lpszCodeBlock += sibinc; 
    …… 
    953989{ 
    954990    unsigned size = sizeof(uint8_t);   //ModRM byte 
    955     int sibinc; 
    956  
    957     pCpu->ModRM    = DISReadByte(pCpu, lpszCodeBlock); 
     991    unsigned sibinc, ModRM; 
     992 
     993    ModRM = DISReadByte(pCpu, lpszCodeBlock); 
    958994    lpszCodeBlock += sizeof(uint8_t); 
     995 
     996    pCpu->ModRM.Bits.Rm  = MODRM_RM(ModRM); 
     997    pCpu->ModRM.Bits.Mod = MODRM_MOD(ModRM); 
     998    pCpu->ModRM.Bits.Reg = MODRM_REG(ModRM); 
     999 
     1000    if (pCpu->prefix & PREFIX_REX) 
     1001    { 
     1002        /* REX.R extends the Reg field. */ 
     1003        pCpu->ModRM.Bits.Reg |= ((!!(pCpu->prefix_rex & PREFIX_REX_FLAGS_R)) << 3); 
     1004 
     1005        /* REX.B extends the Rm field if there is no SIB byte. */ 
     1006        if (    pCpu->ModRM.Bits.Mod != 3  
     1007            &&  pCpu->ModRM.Bits.Rm == 4) 
     1008        { 
     1009            pCpu->ModRM.Bits.Rm |= ((!!(pCpu->prefix_rex & PREFIX_REX_FLAGS_B)) << 3); 
     1010        } 
     1011    } 
    9591012 
    9601013    size += QueryModRM_SizeOnly(lpszCodeBlock, pOp, pParam, pCpu, &sibinc); 
    …… 
    15731626#endif 
    15741627 
    1575     pCpu->ModRM    = DISReadByte(pCpu, lpszCodeBlock); 
     1628    unsigned ModRM = DISReadByte(pCpu, lpszCodeBlock); 
     1629    pCpu->ModRM.Bits.Rm  = MODRM_RM(ModRM); 
     1630    pCpu->ModRM.Bits.Mod = MODRM_MOD(ModRM); 
     1631    pCpu->ModRM.Bits.Reg = MODRM_REG(ModRM); 
    15761632 
    15771633    modrmsize = QueryModRM(lpszCodeBlock+sizeof(uint8_t), pOp, pParam, pCpu); 
    …… 
    18031859} 
    18041860//***************************************************************************** 
    1805 const char *szModRMReg8[]   = {"AL", "CL", "DL", "BL", "AH", "CH", "DH", "BH"}; 
    1806 const char *szModRMReg16[]  = {"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"}; 
    1807 const char *szModRMReg32[]  = {"EAX", "ECX", "EDX", "EBX", "ESP", "EBP", "ESI", "EDI"}; 
     1861#if !defined(DIS_CORE_ONLY) && defined(LOG_ENABLED) 
     1862const char *szModRMReg8[]      = {"AL", "CL", "DL", "BL", "AH", "CH", "DH", "BH"}; 
     1863const char *szModRMReg16[]     = {"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"}; 
     1864const char *szModRMReg32[]     = {"EAX", "ECX", "EDX", "EBX", "ESP", "EBP", "ESI", "EDI"}; 
     1865const char *szModRMReg64[]     = {"RAX", "RCX", "RDX", "RBX", "RSP", "RBP", "RSI", "RDI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}; 
     1866const char *szModRMReg1616[8]  = {"BX+SI", "BX+DI", "BP+SI", "BP+DI", "SI", "DI", "BP", "BX"}; 
     1867#endif 
     1868const char *szModRMSegReg[6]   = {"ES", "CS", "SS", "DS", "FS", "GS"}; 
     1869const int   BaseModRMReg16[8]  = { USE_REG_BX, USE_REG_BX, USE_REG_BP, USE_REG_BP, USE_REG_SI, USE_REG_DI, USE_REG_BP, USE_REG_BX}; 
     1870const int   IndexModRMReg16[4] = { USE_REG_SI, USE_REG_DI, USE_REG_SI, USE_REG_DI}; 
    18081871//***************************************************************************** 
    18091872void disasmModRMReg(PDISCPUSTATE pCpu, PCOPCODE pOp, int idx, POP_PARAMETER pParam, int fRegAddr) 
    …… 
    18111874    int subtype, type, mod; 
    18121875 
    1813     mod     = MODRM_MOD(pCpu->ModRM); 
     1876    mod     = pCpu->ModRM.Bits.Mod; 
    18141877 
    18151878    type    = OP_PARM_VTYPE(pParam->param); 
    …… 
    18521915} 
    18531916//***************************************************************************** 
    1854 const char *szModRMReg1616[8]  = {"BX+SI", "BX+DI", "BP+SI", "BP+DI", "SI", "DI", "BP", "BX"}; 
    1855 int   BaseModRMReg16[8]  = { USE_REG_BX, USE_REG_BX, USE_REG_BP, USE_REG_BP, USE_REG_SI, USE_REG_DI, USE_REG_BP, USE_REG_BX}; 
    1856 int   IndexModRMReg16[4] = { USE_REG_SI, USE_REG_DI, USE_REG_SI, USE_REG_DI}; 
    18571917//***************************************************************************** 
    18581918void disasmModRMReg16(PDISCPUSTATE pCpu, PCOPCODE pOp, int idx, POP_PARAMETER pParam) 
    …… 
    18681928} 
    18691929//***************************************************************************** 
    1870 const char *szModRMSegReg[6] = {"ES", "CS", "SS", "DS", "FS", "GS"}; 
    18711930//***************************************************************************** 
    18721931void disasmModRMSReg(PDISCPUSTATE pCpu, PCOPCODE pOp, int idx, POP_PARAMETER pParam) 

  • trunk/src/VBox/VMM/PATM/PATMPatch.cpp

    r8234 r8333  
    703703            pPB[offset++] = DISQuerySegPrefixByte(pCpu); 
    704704        pPB[offset++] = 0xFF;              // push r/m32 
    705         pPB[offset++] = MAKE_MODRM(MODRM_MOD(pCpu->ModRM), 6 /* group 5 */, MODRM_RM(pCpu->ModRM)); 
     705        pPB[offset++] = MAKE_MODRM(pCpu->ModRM.Bits.Mod, 6 /* group 5 */, pCpu->ModRM.Bits.Rm); 
    706706        i = 2;  /* standard offset of modrm bytes */ 
    707707        if (pCpu->prefix & PREFIX_OPSIZE) 
    …… 
    800800 
    801801    pPB[offset++] = 0xFF;              // push r/m32 
    802     pPB[offset++] = MAKE_MODRM(MODRM_MOD(pCpu->ModRM), 6 /* group 5 */, MODRM_RM(pCpu->ModRM)); 
     802    pPB[offset++] = MAKE_MODRM(pCpu->ModRM.Bits.Mod, 6 /* group 5 */, pCpu->ModRM.Bits.Rm); 
    803803    i = 2;  /* standard offset of modrm bytes */ 
    804804    if (pCpu->prefix & PREFIX_OPSIZE) 
    …… 
    13941394        pPB[offset++] = 0x8D;              // lea       edx, dword ptr [dest] 
    13951395        // duplicate and modify modrm byte and additional bytes if present (e.g. direct address) 
    1396         pPB[offset++] = MAKE_MODRM(MODRM_MOD(pCpu->ModRM), USE_REG_EDX, MODRM_RM(pCpu->ModRM)); 
     1396        pPB[offset++] = MAKE_MODRM(pCpu->ModRM.Bits.Mod, USE_REG_EDX, pCpu->ModRM.Bits.Rm); 
    13971397 
    13981398        i = 3;  /* standard offset of modrm bytes */ 
    …… 
    14891489    pPB[offset++] = 0x8D;              // lea       edx, dword ptr [dest] 
    14901490    // duplicate and modify modrm byte and additional bytes if present (e.g. direct address) 
    1491     pPB[offset++] = MAKE_MODRM(MODRM_MOD(pCpu->ModRM), USE_REG_EDX, MODRM_RM(pCpu->ModRM)); 
     1491    pPB[offset++] = MAKE_MODRM(pCpu->ModRM.Bits.Mod, USE_REG_EDX, pCpu->ModRM.Bits.Rm); 
    14921492 
    14931493    i = 3;  /* standard offset of modrm bytes */ 

© 2008 Sun Microsystems, Inc.
Contact – Privacy policy