VirtualBox

Changeset 8826 in vbox


Ignore:
Timestamp:
May 15, 2008 1:11:24 AM (17 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
30833
Message:

lock mov wherever, whereever is an invalid lock sequence, so raise #UD. Wrote the proper checks for invalid lock sequence, but didn't dare enable this yet.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/recompiler/target-i386/translate.c

    r6726 r8826  
    11/*
    22 *  i386 translation
    3  * 
     3 *
    44 *  Copyright (c) 2003 Fabrice Bellard
    55 *
    … …  
    145145/* i386 arith/logic operations */
    146146enum {
    147     OP_ADDL, 
    148     OP_ORL, 
    149     OP_ADCL, 
     147    OP_ADDL,
     148    OP_ORL,
     149    OP_ADCL,
    150150    OP_SBBL,
    151     OP_ANDL, 
    152     OP_SUBL, 
    153     OP_XORL, 
     151    OP_ANDL,
     152    OP_SUBL,
     153    OP_XORL,
    154154    OP_CMPL,
    155155};
    … …  
    157157/* i386 shift ops */
    158158enum {
    159     OP_ROL, 
    160     OP_ROR, 
    161     OP_RCL, 
    162     OP_RCR, 
    163     OP_SHL, 
    164     OP_SHR, 
     159    OP_ROL,
     160    OP_ROR,
     161    OP_RCL,
     162    OP_RCR,
     163    OP_SHL,
     164    OP_SHR,
    165165    OP_SHL1, /* undocumented */
    166166    OP_SAR = 7,
    … …  
    180180    OT_BYTE = 0,
    181181    OT_WORD,
    182     OT_LONG, 
     182    OT_LONG,
    183183    OT_QUAD,
    184184};
    … …  
    369369};
    370370
    371 static GenOpFunc *gen_op_mov_TN_reg[NB_OP_SIZES][2][CPU_NB_REGS] = 
     371static GenOpFunc *gen_op_mov_TN_reg[NB_OP_SIZES][2][CPU_NB_REGS] =
    372372{
    373373    [OT_BYTE] = {
    … …  
    940940    X86_64_ONLY(gen_op_jnz_ecxq),
    941941};
    942    
     942
    943943static GenOpFunc1 *gen_op_jz_ecx[3] = {
    944944    gen_op_jz_ecxw,
    … …  
    10281028        gen_op_addq_ESI_T0();
    10291029        gen_op_addq_EDI_T0();
    1030     } else 
     1030    } else
    10311031#endif
    10321032    if (s->aflag) {
    … …  
    10711071    if (s->aflag == 2) {
    10721072        gen_op_addq_EDI_T0();
    1073     } else 
     1073    } else
    10741074#endif
    10751075    if (s->aflag) {
    … …  
    10891089    if (s->aflag == 2) {
    10901090        gen_op_addq_ESI_T0();
    1091     } else 
     1091    } else
    10921092#endif
    10931093    if (s->aflag) {
    … …  
    11081108    if (s->aflag == 2) {
    11091109        gen_op_addq_EDI_T0();
    1110     } else 
     1110    } else
    11111111#endif
    11121112    if (s->aflag) {
    … …  
    11291129        gen_op_addq_ESI_T0();
    11301130        gen_op_addq_EDI_T0();
    1131     } else 
     1131    } else
    11321132#endif
    11331133    if (s->aflag) {
    … …  
    11511151    if (s->aflag == 2) {
    11521152        gen_op_addq_EDI_T0();
    1153     } else 
     1153    } else
    11541154#endif
    11551155    if (s->aflag) {
    … …  
    11691169    if (s->aflag == 2) {
    11701170        gen_op_addq_ESI_T0();
    1171     } else 
     1171    } else
    11721172#endif
    11731173    if (s->aflag) {
    … …  
    13801380{
    13811381    GenOpFunc *gen_update_cc;
    1382    
     1382
    13831383    if (d != OR_TMP0) {
    13841384        gen_op_mov_TN_reg[ot][0][d]();
    … …  
    14701470    if (s1->cc_op != CC_OP_DYNAMIC)
    14711471        gen_op_set_cc_op(s1->cc_op);
    1472    
     1472
    14731473    if (d != OR_TMP0)
    14741474        gen_op_shift_T0_T1_cc[ot][op]();
    … …  
    15101510        index = 0;
    15111511        scale = 0;
    1512        
     1512
    15131513        if (base == 4) {
    15141514            havesib = 1;
    … …  
    15421542            break;
    15431543        }
    1544        
     1544
    15451545        if (base >= 0) {
    15461546            /* for correct popl handling with esp */
    … …  
    15561556                        gen_op_addq_A0_im64(disp >> 32, disp);
    15571557                }
    1558             } else 
     1558            } else
    15591559#endif
    15601560            {
    … …  
    15701570                else
    15711571                    gen_op_movq_A0_im64(disp >> 32, disp);
    1572             } else 
     1572            } else
    15731573#endif
    15741574            {
    … …  
    15811581            if (s->aflag == 2) {
    15821582                gen_op_addq_A0_reg_sN[scale][index]();
    1583             } else 
     1583            } else
    15841584#endif
    15851585            {
    … …  
    15971597            if (s->aflag == 2) {
    15981598                gen_op_addq_A0_seg(offsetof(CPUX86State,segs[override].base));
    1599             } else 
     1599            } else
    16001600#endif
    16011601            {
    … …  
    16891689
    16901690        base = rm;
    1691        
     1691
    16921692        if (base == 4) {
    16931693            code = ldub_code(s->pc++);
    16941694            base = (code & 7);
    16951695        }
    1696        
     1696
    16971697        switch (mod) {
    16981698        case 0:
    … …  
    17431743        if (CODE64(s)) {
    17441744            gen_op_addq_A0_seg(offsetof(CPUX86State,segs[override].base));
    1745         } else 
     1745        } else
    17461746#endif
    17471747        {
    … …  
    18381838}
    18391839
    1840 static inline void gen_jcc(DisasContext *s, int b, 
     1840static inline void gen_jcc(DisasContext *s, int b,
    18411841                           target_ulong val, target_ulong next_eip)
    18421842{
    … …  
    18491849    inv = b & 1;
    18501850    jcc_op = (b >> 1) & 7;
    1851    
     1851
    18521852    if (s->jmp_opt) {
    18531853#ifdef VBOX
    … …  
    18621862            func = gen_jcc_sub[s->cc_op - CC_OP_SUBB][jcc_op];
    18631863            break;
    1864            
     1864
    18651865            /* some jumps are easy to compute */
    18661866        case CC_OP_ADDB:
    … …  
    19291929            func = gen_op_jnz_T0_label;
    19301930        }
    1931    
     1931
    19321932        if (inv) {
    19331933            tmp = val;
    … …  
    19871987            goto slow_jcc;
    19881988        break;
    1989        
     1989
    19901990        /* some jumps are easy to compute */
    19911991    case CC_OP_ADDB:
    … …  
    20662066        if (addend == 8)
    20672067            gen_op_addq_ESP_8();
    2068         else 
     2068        else
    20692069            gen_op_addq_ESP_im(addend);
    20702070    } else
    … …  
    20752075        else if (addend == 4)
    20762076            gen_op_addl_ESP_4();
    2077         else 
     2077        else
    20782078            gen_op_addl_ESP_im(addend);
    20792079    } else {
    … …  
    21012101        }
    21022102        gen_op_movq_ESP_A0();
    2103     } else 
     2103    } else
    21042104#endif
    21052105    {
    … …  
    21422142        }
    21432143        gen_op_movq_ESP_A0();
    2144     } else 
     2144    } else
    21452145#endif
    21462146    {
    … …  
    21592159        }
    21602160        gen_op_st_T1_A0[s->dflag + 1 + s->mem_index]();
    2161        
     2161
    21622162        if (s->ss32 && !s->addseg)
    21632163            gen_op_movl_ESP_A0();
    … …  
    21742174        gen_op_movq_A0_reg[R_ESP]();
    21752175        gen_op_ld_T0_A0[(s->dflag ? OT_QUAD : OT_WORD) + s->mem_index]();
    2176     } else 
     2176    } else
    21772177#endif
    21782178    {
    … …  
    22612261        ot = s->dflag ? OT_QUAD : OT_WORD;
    22622262        opsize = 1 << ot;
    2263        
     2263
    22642264        gen_op_movl_A0_ESP();
    22652265        gen_op_addq_A0_im(-opsize);
    … …  
    22752275        gen_op_addl_T1_im( -esp_addend + (-opsize * level) );
    22762276        gen_op_mov_reg_T1[OT_QUAD][R_ESP]();
    2277     } else 
     2277    } else
    22782278#endif
    22792279    {
    22802280        ot = s->dflag + OT_WORD;
    22812281        opsize = 2 << s->dflag;
    2282        
     2282
    22832283        gen_op_movl_A0_ESP();
    22842284        gen_op_addl_A0_im(-opsize);
    … …  
    23112311/* an interrupt is different from an exception because of the
    23122312   priviledge checks */
    2313 static void gen_interrupt(DisasContext *s, int intno, 
     2313static void gen_interrupt(DisasContext *s, int intno,
    23142314                          target_ulong cur_eip, target_ulong next_eip)
    23152315{
    … …  
    23772377static void gen_movtl_T0_im(target_ulong val)
    23782378{
    2379 #ifdef TARGET_X86_64   
     2379#ifdef TARGET_X86_64
    23802380    if ((int32_t)val == val) {
    23812381        gen_op_movl_T0_im(val);
    … …  
    23902390static void gen_movtl_T1_im(target_ulong val)
    23912391{
    2392 #ifdef TARGET_X86_64   
     2392#ifdef TARGET_X86_64
    23932393    if ((int32_t)val == val) {
    23942394        gen_op_movl_T1_im(val);
    … …  
    24782478    [0x58] = SSE_FOP(add),
    24792479    [0x59] = SSE_FOP(mul),
    2480     [0x5a] = { gen_op_cvtps2pd, gen_op_cvtpd2ps, 
     2480    [0x5a] = { gen_op_cvtps2pd, gen_op_cvtpd2ps,
    24812481               gen_op_cvtss2sd, gen_op_cvtsd2ss },
    24822482    [0x5b] = { gen_op_cvtdq2ps, gen_op_cvtps2dq, gen_op_cvttps2dq },
    … …  
    25062506    [0x6e] = { SSE_SPECIAL, SSE_SPECIAL }, /* movd mm, ea */
    25072507    [0x6f] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movq, movdqa, , movqdu */
    2508     [0x70] = { (GenOpFunc2 *)gen_op_pshufw_mmx, 
    2509                (GenOpFunc2 *)gen_op_pshufd_xmm, 
    2510                (GenOpFunc2 *)gen_op_pshufhw_xmm, 
     2508    [0x70] = { (GenOpFunc2 *)gen_op_pshufw_mmx,
     2509               (GenOpFunc2 *)gen_op_pshufd_xmm,
     2510               (GenOpFunc2 *)gen_op_pshufhw_xmm,
    25112511               (GenOpFunc2 *)gen_op_pshuflw_xmm },
    25122512    [0x71] = { SSE_SPECIAL, SSE_SPECIAL }, /* shiftw */
    … …  
    25902590    X86_64_ONLY(gen_op_cvtsq2ss),
    25912591    X86_64_ONLY(gen_op_cvtsq2sd),
    2592    
     2592
    25932593    gen_op_cvttss2si,
    25942594    gen_op_cvttsd2si,
    … …  
    26012601    X86_64_ONLY(gen_op_cvtsd2sq),
    26022602};
    2603    
     2603
    26042604static GenOpFunc2 *sse_op_table4[8][4] = {
    26052605    SSE_FOP(cmpeq),
    … …  
    26122612    SSE_FOP(cmpord),
    26132613};
    2614    
     2614
    26152615static void gen_sse(DisasContext *s, int b, target_ulong pc_start, int rex_r)
    26162616{
    … …  
    26212621
    26222622    b &= 0xff;
    2623     if (s->prefix & PREFIX_DATA) 
     2623    if (s->prefix & PREFIX_DATA)
    26242624        b1 = 1;
    2625     else if (s->prefix & PREFIX_REPZ) 
     2625    else if (s->prefix & PREFIX_REPZ)
    26262626        b1 = 2;
    2627     else if (s->prefix & PREFIX_REPNZ) 
     2627    else if (s->prefix & PREFIX_REPNZ)
    26282628        b1 = 3;
    26292629    else
    26302630        b1 = 0;
    26312631    sse_op2 = sse_op_table1[b][b1];
    2632     if (!sse_op2) 
     2632    if (!sse_op2)
    26332633        goto illegal_op;
    26342634    if (b <= 0x5f || b == 0xc6 || b == 0xc2) {
    … …  
    26742674        switch(b) {
    26752675        case 0x0e7: /* movntq */
    2676             if (mod == 3) 
     2676            if (mod == 3)
    26772677                goto illegal_op;
    26782678            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
    … …  
    26932693                gen_ldst_modrm(s, modrm, OT_QUAD, OR_TMP0, 0);
    26942694                gen_op_movq_mm_T0_mmx(offsetof(CPUX86State,fpregs[reg].mmx));
    2695             } else 
     2695            } else
    26962696#endif
    26972697            {
    … …  
    27052705                gen_ldst_modrm(s, modrm, OT_QUAD, OR_TMP0, 0);
    27062706                gen_op_movq_mm_T0_xmm(offsetof(CPUX86State,xmm_regs[reg]));
    2707             } else 
     2707            } else
    27082708#endif
    27092709            {
    … …  
    28382838                gen_op_movq_T0_mm_mmx(offsetof(CPUX86State,fpregs[reg].mmx));
    28392839                gen_ldst_modrm(s, modrm, OT_QUAD, OR_TMP0, 1);
    2840             } else 
     2840            } else
    28412841#endif
    28422842            {
    … …  
    28502850                gen_op_movq_T0_mm_xmm(offsetof(CPUX86State,xmm_regs[reg]));
    28512851                gen_ldst_modrm(s, modrm, OT_QUAD, OR_TMP0, 1);
    2852             } else 
     2852            } else
    28532853#endif
    28542854            {
    … …  
    30503050                op2_offset = offsetof(CPUX86State,xmm_regs[rm]);
    30513051            }
    3052             sse_op_table3[(s->dflag == 2) * 2 + ((b >> 8) - 2) + 4 + 
     3052            sse_op_table3[(s->dflag == 2) * 2 + ((b >> 8) - 2) + 4 +
    30533053                          (b & 1) * 4](op2_offset);
    30543054            gen_op_mov_reg_T0[ot][reg]();
    30553055            break;
    30563056        case 0xc4: /* pinsrw */
    3057         case 0x1c4: 
     3057        case 0x1c4:
    30583058            s->rip_offset = 1;
    30593059            gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
    … …  
    30683068            break;
    30693069        case 0xc5: /* pextrw */
    3070         case 0x1c5: 
     3070        case 0x1c5:
    30713071            if (mod != 3)
    30723072                goto illegal_op;
    … …  
    31303130        case 0xf7:
    31313131            /* maskmov : we must prepare A0 */
    3132             if (mod != 3) 
     3132            if (mod != 3)
    31333133                goto illegal_op;
    31343134#ifdef TARGET_X86_64
    31353135            if (s->aflag == 2) {
    31363136                gen_op_movq_A0_reg[R_EDI]();
    3137             } else 
     3137            } else
    31383138#endif
    31393139            {
    … …  
    32113211}
    32123212
     3213#ifdef VBOX
     3214/* Checks if it's an invalid lock sequence. Only a few instructions
     3215   can be used together with the lock prefix and of those only the
     3216   form that write a memory operand. So, this is kind of annoying
     3217   work to do...
     3218   The AMD manual lists the following instructions.
     3219        ADC
     3220        ADD
     3221        AND
     3222        BTC
     3223        BTR
     3224        BTS
     3225        CMPXCHG
     3226        CMPXCHG8B
     3227        CMPXCHG16B
     3228        DEC
     3229        INC
     3230        NEG
     3231        NOT
     3232        OR
     3233        SBB
     3234        SUB
     3235        XADD
     3236        XCHG
     3237        XOR */
     3238static bool is_invalid_lock_sequence(DisasContext *s, target_ulong pc_start, int b)
     3239{
     3240#if 0 /** @todo test this properly! */
     3241    target_ulong pc = s->pc;
     3242    int modrm, mod, op;
     3243
     3244    /* X={8,16,32,64}  Y={16,32,64} */
     3245    switch (b)
     3246    {
     3247        /* /2: ADC reg/memX, immX */
     3248        /* /0: ADD reg/memX, immX */
     3249        /* /4: AND reg/memX, immX */
     3250        /* /1: OR  reg/memX, immX */
     3251        /* /3: SBB reg/memX, immX */
     3252        /* /5: SUB reg/memX, immX */
     3253        /* /6: XOR reg/memX, immX */
     3254        case 0x80:
     3255        case 0x81:
     3256        case 0x83:
     3257            modrm = ldub_code(pc++);
     3258            op = (modrm >> 3) & 7;
     3259            if (op == 7) /* /7: CMP */
     3260                break;
     3261            mod = (modrm >> 6) & 3;
     3262            if (mod == 3) /* register destination */
     3263                break;
     3264            return false;
     3265
     3266        case 0x10: /* /r: ADC reg/mem8, reg8 */
     3267        case 0x11: /* /r: ADC reg/memX, regY */
     3268        case 0x00: /* /r: ADD reg/mem8, reg8 */
     3269        case 0x01: /* /r: ADD reg/memX, regY */
     3270        case 0x20: /* /r: AND reg/mem8, reg8 */
     3271        case 0x21: /* /r: AND reg/memY, regY */
     3272        case 0x08: /* /r: OR  reg/mem8, reg8 */
     3273        case 0x09: /* /r: OR  reg/memY, regY */
     3274        case 0x18: /* /r: SBB reg/mem8, reg8 */
     3275        case 0x19: /* /r: SBB reg/memY, regY */
     3276        case 0x28: /* /r: SUB reg/mem8, reg8 */
     3277        case 0x29: /* /r: SUB reg/memY, regY */
     3278        case 0x86: /* /r: XCHG reg/mem8, reg8 or XCHG reg8, reg/mem8 */
     3279        case 0x87: /* /r: XCHG reg/memY, regY or XCHG regY, reg/memY */
     3280        case 0x30: /* /r: XOR reg/mem8, reg8 */
     3281        case 0x31: /* /r: XOR reg/memY, regY */
     3282            modrm = ldub_code(pc++);
     3283            mod = (modrm >> 6) & 3;
     3284            if (mod == 3) /* register destination */
     3285                break;
     3286            return false;
     3287
     3288        /* /1: DEC reg/memX */
     3289        /* /0: INC reg/memX */
     3290        case 0xfe:
     3291        case 0xff:
     3292            modrm = ldub_code(pc++);
     3293            mod = (modrm >> 6) & 3;
     3294            if (mod == 3) /* register destination */
     3295                break;
     3296            return false;
     3297
     3298        /* /3: NEG reg/memX */
     3299        /* /2: NOT reg/memX */
     3300        case 0xf6:
     3301        case 0xf7:
     3302            modrm = ldub_code(pc++);
     3303            mod = (modrm >> 6) & 3;
     3304            if (mod == 3) /* register destination */
     3305                break;
     3306            return false;
     3307
     3308        case 0x0f:
     3309            b = ldub_code(pc++);
     3310            switch (b)
     3311            {
     3312                /* /7: BTC reg/memY, imm8 */
     3313                /* /6: BTR reg/memY, imm8 */
     3314                /* /5: BTS reg/memY, imm8 */
     3315                case 0xba:
     3316                    modrm = ldub_code(pc++);
     3317                    op = (modrm >> 3) & 7;
     3318                    if (op < 5)
     3319                        break;
     3320                    mod = (modrm >> 6) & 3;
     3321                    if (mod == 3) /* register destination */
     3322                        break;
     3323                    return false;
     3324
     3325                case 0xbb: /* /r: BTC reg/memY, regY */
     3326                case 0xb3: /* /r: BTR reg/memY, regY */
     3327                case 0xab: /* /r: BTS reg/memY, regY */
     3328                case 0xb0: /* /r: CMPXCHG reg/mem8, reg8 */
     3329                case 0xb1: /* /r: CMPXCHG reg/memY, regY */
     3330                case 0xc0: /* /r: XADD reg/mem8, reg8 */
     3331                case 0xc1: /* /r: XADD reg/memY, regY */
     3332                    modrm = ldub_code(pc++);
     3333                    mod = (modrm >> 6) & 3;
     3334                    if (mod == 3) /* register destination */
     3335                        break;
     3336                    return false;
     3337
     3338                /* /1: CMPXCHG8B mem64 or CMPXCHG16B mem128 */
     3339                case 0xc7:
     3340                    return false;
     3341            }
     3342            break;
     3343    }
     3344
     3345    /* illegal sequence. */
     3346    Log(("illegal lock sequence %VGv (b=%#x)\n", pc_start, b));
     3347    s->pc = pc; /* XXX: What's the correct value here? */
     3348    return true;
     3349#else
     3350    return false;
     3351#endif
     3352}
     3353#endif /* VBOX */
     3354
    32133355
    32143356/* convert one instruction. s->is_jmp is set if the translation must
    … …  
    32323374    s->rex_x = 0;
    32333375    s->rex_b = 0;
    3234     x86_64_hregs = 0; 
     3376    x86_64_hregs = 0;
    32353377#endif
    32363378    s->rip_offset = 0; /* for relative ip address */
    … …  
    32993441        if (!(prefixes & PREFIX_ADR))
    33003442            aflag = 2;
    3301     } else 
     3443    } else
    33023444#endif
    33033445    {
    … …  
    33483490
    33493491    /* lock generation */
     3492#ifndef VBOX
    33503493    if (prefixes & PREFIX_LOCK)
    33513494        gen_op_lock();
     3495#else /* VBOX */
     3496    if (prefixes & PREFIX_LOCK) {
     3497        if (is_invalid_lock_sequence(s, pc_start, b)) {
     3498            gen_exception(s, EXCP06_ILLOP, pc_start - s->cs_base);
     3499            return s->pc;
     3500        }
     3501        gen_op_lock();
     3502    }
     3503#endif /* VBOX */
    33523504
    33533505    /* now check op code */
    … …  
    33593511        b = ldub_code(s->pc++) | 0x100;
    33603512        goto reswitch;
    3361        
     3513
    33623514        /**************************/
    33633515        /* arith & logic */
    … …  
    33793531            else
    33803532                ot = dflag + OT_WORD;
    3381            
     3533
    33823534            switch(f) {
    33833535            case 0: /* OP Ev, Gv */
    … …  
    34383590            else
    34393591                ot = dflag + OT_WORD;
    3440            
     3592
    34413593            modrm = ldub_code(s->pc++);
    34423594            mod = (modrm >> 6) & 3;
    34433595            rm = (modrm & 7) | REX_B(s);
    34443596            op = (modrm >> 3) & 7;
    3445            
     3597
    34463598            if (mod != 3) {
    34473599                if (b == 0x83)
    … …  
    37343886
    37353887    case 0x84: /* test Ev, Gv */
    3736     case 0x85: 
     3888    case 0x85:
    37373889        if ((b & 1) == 0)
    37383890            ot = OT_BYTE;
    … …  
    37443896        rm = (modrm & 7) | REX_B(s);
    37453897        reg = ((modrm >> 3) & 7) | rex_r;
    3746        
     3898
    37473899        gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
    37483900        gen_op_mov_TN_reg[ot][1][reg]();
    … …  
    37503902        s->cc_op = CC_OP_LOGICB + ot;
    37513903        break;
    3752        
     3904
    37533905    case 0xa8: /* test eAX, Iv */
    37543906    case 0xa9:
    … …  
    37643916        s->cc_op = CC_OP_LOGICB + ot;
    37653917        break;
    3766        
     3918
    37673919    case 0x98: /* CWDE/CBW */
    37683920#ifdef TARGET_X86_64
    … …  
    38814033        s->cc_op = CC_OP_EFLAGS;
    38824034        break;
    3883        
     4035
    38844036        /**************************/
    38854037        /* push/pop */
    … …  
    40324184        modrm = ldub_code(s->pc++);
    40334185        reg = ((modrm >> 3) & 7) | rex_r;
    4034        
     4186
    40354187        /* generate a generic store */
    40364188        gen_ldst_modrm(s, modrm, ot, reg, 1);
    … …  
    40574209    case 0x8a:
    40584210    case 0x8b: /* mov Ev, Gv */
     4211#ifdef VBOX /* dtrace hot fix */
     4212        if (prefixes & PREFIX_LOCK)
     4213            goto illegal_op;
     4214#endif
    40594215        if ((b & 1) == 0)
    40604216            ot = OT_BYTE;
    … …  
    40634219        modrm = ldub_code(s->pc++);
    40644220        reg = ((modrm >> 3) & 7) | rex_r;
    4065        
     4221
    40664222        gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
    40674223        gen_op_mov_reg_T0[ot][reg]();
    … …  
    41154271            mod = (modrm >> 6) & 3;
    41164272            rm = (modrm & 7) | REX_B(s);
    4117            
     4273
    41184274            if (mod == 3) {
    41194275                gen_op_mov_TN_reg[ot][0][rm]();
    … …  
    41614317        gen_op_mov_reg_A0[ot - OT_WORD][reg]();
    41624318        break;
    4163        
     4319
    41644320    case 0xa0: /* mov EAX, Ov */
    41654321    case 0xa1:
    … …  
    41814337                else
    41824338                    gen_op_movq_A0_im64(offset_addr >> 32, offset_addr);
    4183             } else 
     4339            } else
    41844340#endif
    41854341            {
    … …  
    42064362            gen_op_movq_A0_reg[R_EBX]();
    42074363            gen_op_addq_A0_AL();
    4208         } else 
     4364        } else
    42094365#endif
    42104366        {
    … …  
    42334389            gen_movtl_T0_im(tmp);
    42344390            gen_op_mov_reg_T0[OT_QUAD][reg]();
    4235         } else 
     4391        } else
    42364392#endif
    42374393        {
    … …  
    43164472        }
    43174473        break;
    4318        
     4474
    43194475        /************************/
    43204476        /* shifts */
    … …  
    43294485            else
    43304486                ot = dflag + OT_WORD;
    4331            
     4487
    43324488            modrm = ldub_code(s->pc++);
    43334489            mod = (modrm >> 6) & 3;
    43344490            op = (modrm >> 3) & 7;
    4335            
     4491
    43364492            if (mod != 3) {
    43374493                if (shift == 2) {
    … …  
    43874543        rm = (modrm & 7) | REX_B(s);
    43884544        reg = ((modrm >> 3) & 7) | rex_r;
    4389        
     4545
    43904546        if (mod != 3) {
    43914547            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
    … …  
    43954551        }
    43964552        gen_op_mov_TN_reg[ot][1][reg]();
    4397        
     4553
    43984554        if (shift) {
    43994555            val = ldub_code(s->pc++);
    … …  
    44284584        /************************/
    44294585        /* floats */
    4430     case 0xd8 ... 0xdf: 
     4586    case 0xd8 ... 0xdf:
    44314587        if (s->flags & (HF_EM_MASK | HF_TS_MASK)) {
    44324588            /* if CR0.EM or CR0.TS are set, generate an FPU exception */
    … …  
    44664622                        break;
    44674623                    }
    4468                    
     4624
    44694625                    gen_op_fp_arith_ST0_FT0[op1]();
    44704626                    if (op1 == 3) {
    … …  
    47234879                {
    47244880                    int op1;
    4725                    
     4881
    47264882                    op1 = op & 7;
    47274883                    if (op >= 0x20) {
    … …  
    47934949            case 0x28: /* ffree sti */
    47944950                gen_op_ffree_STN(opreg);
    4795                 break; 
     4951                break;
    47964952            case 0x2a: /* fst sti */
    47974953                gen_op_fmov_STN_ST0(opreg);
    … …  
    48935049        }
    48945050        break;
    4895        
     5051
    48965052    case 0xaa: /* stosS */
    48975053    case 0xab:
    … …  
    51275283        {
    51285284            unsigned int selector, offset;
    5129            
     5285
    51305286            if (CODE64(s))
    51315287                goto illegal_op;
    … …  
    51335289            offset = insn_get(s, ot);
    51345290            selector = insn_get(s, OT_WORD);
    5135            
     5291
    51365292            gen_op_movl_T0_im(selector);
    51375293            gen_op_movl_T1_imu(offset);
    … …  
    51575313            offset = insn_get(s, ot);
    51585314            selector = insn_get(s, OT_WORD);
    5159            
     5315
    51605316            gen_op_movl_T0_im(selector);
    51615317            gen_op_movl_T1_imu(offset);
    … …  
    51765332            tval = (int32_t)insn_get(s, OT_LONG);
    51775333        } else {
    5178             tval = (int16_t)insn_get(s, OT_WORD); 
     5334            tval = (int16_t)insn_get(s, OT_WORD);
    51795335        }
    51805336    do_jcc:
    … …  
    52065362        gen_op_cmov_reg_T1_T0[ot - OT_WORD][reg]();
    52075363        break;
    5208        
     5364
    52095365        /************************/
    52105366        /* flags */
    … …  
    54535609        break;
    54545610    case 0x9b: /* fwait */
    5455         if ((s->flags & (HF_MP_MASK | HF_TS_MASK)) == 
     5611        if ((s->flags & (HF_MP_MASK | HF_TS_MASK)) ==
    54565612            (HF_MP_MASK | HF_TS_MASK)) {
    54575613            gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
    … …  
    54665622#ifdef VBOX
    54675623        if (s->vm86 && s->iopl != 3 && !s->vme) {
    5468             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base); 
    5469         } else 
     5624            gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
     5625        } else
    54705626#endif
    54715627            gen_interrupt(s, EXCP03_INT3, pc_start - s->cs_base, s->pc - s->cs_base);
    … …  
    54785634        if (s->vm86 && s->iopl != 3) {
    54795635#endif
    5480             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base); 
     5636            gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
    54815637        } else {
    54825638            gen_interrupt(s, val, pc_start - s->cs_base, s->pc - s->cs_base);
    … …  
    55745730            gen_op_bswapq_T0();
    55755731            gen_op_mov_reg_T0[OT_QUAD][reg]();
    5576         } else 
     5732        } else
    55775733#endif
    55785734        {
    … …  
    56045760            if (s->dflag == 0)
    56055761                tval &= 0xffff;
    5606            
     5762
    56075763            l1 = gen_new_label();
    56085764            l2 = gen_new_label();
    … …  
    58045960                        gen_op_movq_A0_reg[R_EBX]();
    58055961                        gen_op_addq_A0_AL();
    5806                     } else 
     5962                    } else
    58075963#endif
    58085964                    {
    … …  
    58896045                        gen_op_movtl_env_T1(offsetof(CPUX86State,segs[R_GS].base));
    58906046                        gen_op_movtl_env_T0(offsetof(CPUX86State,kernelgsbase));
    5891                     } else 
     6047                    } else
    58926048#endif
    58936049                    {
    … …  
    59256081            mod = (modrm >> 6) & 3;
    59266082            rm = (modrm & 7) | REX_B(s);
    5927            
     6083
    59286084            if (mod == 3) {
    59296085                gen_op_mov_TN_reg[OT_LONG][0][rm]();
    … …  
    59416097                gen_op_mov_reg_T0[d_ot][reg]();
    59426098            }
    5943         } else 
     6099        } else
    59446100#endif
    59456101        {
    … …  
    60396195                    gen_eob(s);
    60406196                } else {
    6041 #if !defined(CONFIG_USER_ONLY) 
     6197#if !defined(CONFIG_USER_ONLY)
    60426198                    if (reg == 8)
    60436199                        gen_op_movtl_T0_cr8();
    … …  
    61106266        switch(op) {
    61116267        case 0: /* fxsave */
    6112             if (mod == 3 || !(s->cpuid_features & CPUID_FXSR) || 
     6268            if (mod == 3 || !(s->cpuid_features & CPUID_FXSR) ||
    61136269                (s->flags & HF_EM_MASK))
    61146270                goto illegal_op;
    … …  
    61216277            break;
    61226278        case 1: /* fxrstor */
    6123             if (mod == 3 || !(s->cpuid_features & CPUID_FXSR) || 
     6279            if (mod == 3 || !(s->cpuid_features & CPUID_FXSR) ||
    61246280                (s->flags & HF_EM_MASK))
    61256281                goto illegal_op;
    … …  
    62146370
    62156371/* flags read by an operation */
    6216 static uint16_t opc_read_flags[NB_OPS] = { 
     6372static uint16_t opc_read_flags[NB_OPS] = {
    62176373    [INDEX_op_aas] = CC_A,
    62186374    [INDEX_op_aaa] = CC_A,
    … …  
    62216377
    62226378    /* subtle: due to the incl/decl implementation, C is used */
    6223     [INDEX_op_update_inc_cc] = CC_C, 
     6379    [INDEX_op_update_inc_cc] = CC_C,
    62246380
    62256381    [INDEX_op_into] = CC_O,
    … …  
    63476503
    63486504/* flags written by an operation */
    6349 static uint16_t opc_write_flags[NB_OPS] = { 
     6505static uint16_t opc_write_flags[NB_OPS] = {
    63506506    [INDEX_op_update2_cc] = CC_OSZAPC,
    63516507    [INDEX_op_update1_cc] = CC_OSZAPC,
    … …  
    63536509    [INDEX_op_update_neg_cc] = CC_OSZAPC,
    63546510    /* subtle: due to the incl/decl implementation, C is used */
    6355     [INDEX_op_update_inc_cc] = CC_OSZAPC, 
     6511    [INDEX_op_update_inc_cc] = CC_OSZAPC,
    63566512    [INDEX_op_testl_T0_T1_cc] = CC_OSZAPC,
    63576513
    … …  
    64986654
    64996655/* simpler form of an operation if no flags need to be generated */
    6500 static uint16_t opc_simpler[NB_OPS] = { 
     6656static uint16_t opc_simpler[NB_OPS] = {
    65016657    [INDEX_op_update2_cc] = INDEX_op_nop,
    65026658    [INDEX_op_update1_cc] = INDEX_op_nop,
    … …  
    65826738   information for each intermediate instruction. */
    65836739static inline int gen_intermediate_code_internal(CPUState *env,
    6584                                                  TranslationBlock *tb, 
     6740                                                 TranslationBlock *tb,
    65856741                                                 int search_pc)
    65866742{
    … …  
    65916747    target_ulong pc_start;
    65926748    target_ulong cs_base;
    6593    
     6749
    65946750    /* generate intermediate code */
    65956751    pc_start = tb->pc;
    … …  
    66866842#ifdef DEBUG
    66876843/*
    6688         if(cpu_check_code_raw(env, pc_ptr, env->hflags | (env->eflags & (IOPL_MASK | TF_MASK | VM_MASK))) == ERROR_SUCCESS) 
     6844        if(cpu_check_code_raw(env, pc_ptr, env->hflags | (env->eflags & (IOPL_MASK | TF_MASK | VM_MASK))) == ERROR_SUCCESS)
    66896845        {
    66906846            //should never happen as the jump to the patch code terminates the translation block
    … …  
    66936849*/
    66946850#endif
    6695         if (env->state & CPU_EMULATE_SINGLE_INSTR) 
     6851        if (env->state & CPU_EMULATE_SINGLE_INSTR)
    66966852        {
    66976853            env->state &= ~CPU_EMULATE_SINGLE_INSTR;
    … …  
    67076863           the flag and abort the translation to give the irqs a
    67086864           change to be happen */
    6709         if (dc->tf || dc->singlestep_enabled || 
     6865        if (dc->tf || dc->singlestep_enabled ||
    67106866            (flags & HF_INHIBIT_IRQ_MASK) ||
    67116867            (cflags & CF_SINGLE_INSN)) {
    … …  
    67306886            gen_opc_instr_start[lj++] = 0;
    67316887    }
    6732        
     6888
    67336889#ifdef DEBUG_DISAS
    67346890    if (loglevel & CPU_LOG_TB_CPU) {
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