source/src/vm/libcpu_newdev/libcpu_i386/pentops.cpp

   1 // license:BSD-3-Clause
   2 // copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
   3 // Pentium+ specific opcodes
   4 #include "./i386_opdef.h"
   5
   6 #define FAULT(fault,error) {cpustate->ext = 1; i386_trap_with_error(fault,0,0,error); return;}
   7 #define FAULT_EXP(fault,error) {cpustate->ext = 1; i386_trap_with_error(fault,0,trap_level+1,error); return;}
   8
   9 extern flag float32_is_nan( float32 a ); // since its not defined in softfloat.h
  10 extern flag float64_is_nan( float64 a ); // since its not defined in softfloat.h
  11
  12 void I386_OPS_BASE::PENTIUMOP(rdmsr)()          // Opcode 0x0f 32
  13 {
  14         UINT64 data;
  15         UINT8 valid_msr = 0;
  16
  17         data = MSR_READ(REG32(ECX),&valid_msr);
  18
  19         if(cpustate->CPL != 0 || valid_msr == 0) // if current privilege level isn't 0 or the register isn't recognized ...
  20                 FAULT(FAULT_GP,0) // ... throw a general exception fault
  21         else
  22         {
  23                 REG32(EDX) = data >> 32;
  24                 REG32(EAX) = data & 0xffffffff;
  25         }
  26
  27         CYCLES(CYCLES_RDMSR);
  28 }
  29
  30  void I386_OPS_BASE::PENTIUMOP(wrmsr)()          // Opcode 0x0f 30
  31 {
  32         UINT64 data;
  33         UINT8 valid_msr = 0;
  34
  35         data = (UINT64)REG32(EAX);
  36         data |= (UINT64)(REG32(EDX)) << 32;
  37
  38         MSR_WRITE(REG32(ECX),data,&valid_msr);
  39
  40         if(cpustate->CPL != 0 || valid_msr == 0) // if current privilege level isn't 0 or the register isn't recognized
  41                 FAULT(FAULT_GP,0) // ... throw a general exception fault
  42
  43         CYCLES(1);     // TODO: correct cycle count (~30-45)
  44 }
  45
  46  void I386_OPS_BASE::PENTIUMOP(rdtsc)()          // Opcode 0x0f 31
  47 {
  48         UINT64 ts = cpustate->tsc + (cpustate->base_cycles - cpustate->cycles);
  49         REG32(EAX) = (UINT32)(ts);
  50         REG32(EDX) = (UINT32)(ts >> 32);
  51
  52         CYCLES(CYCLES_RDTSC);
  53 }
  54
  55  void I386_OPS_BASE::PENTIUMOP(ud2)()    // Opcode 0x0f 0b
  56 {
  57         i386_trap( 6, 0, 0);
  58 }
  59
  60  void I386_OPS_BASE::PENTIUMOP(rsm)()
  61 {
  62         UINT32 smram_state = cpustate->smbase + 0xfe00;
  63         if(!cpustate->smm)
  64         {
  65                 logerror("i386: Invalid RSM outside SMM at %08X\n", cpustate->pc - 1);
  66                 i386_trap( 6, 0, 0);
  67                 return;
  68         }
  69
  70         // load state, no sanity checks anywhere
  71         cpustate->smbase = READ32(smram_state+SMRAM_SMBASE);
  72         cpustate->cr[4] = READ32(smram_state+SMRAM_IP5_CR4);
  73         cpustate->sreg[ES].limit = READ32(smram_state+SMRAM_IP5_ESLIM);
  74         cpustate->sreg[ES].base = READ32(smram_state+SMRAM_IP5_ESBASE);
  75         cpustate->sreg[ES].flags = READ32(smram_state+SMRAM_IP5_ESACC);
  76         cpustate->sreg[CS].limit = READ32(smram_state+SMRAM_IP5_CSLIM);
  77         cpustate->sreg[CS].base = READ32(smram_state+SMRAM_IP5_CSBASE);
  78         cpustate->sreg[CS].flags = READ32(smram_state+SMRAM_IP5_CSACC);
  79         cpustate->sreg[SS].limit = READ32(smram_state+SMRAM_IP5_SSLIM);
  80         cpustate->sreg[SS].base = READ32(smram_state+SMRAM_IP5_SSBASE);
  81         cpustate->sreg[SS].flags = READ32(smram_state+SMRAM_IP5_SSACC);
  82         cpustate->sreg[DS].limit = READ32(smram_state+SMRAM_IP5_DSLIM);
  83         cpustate->sreg[DS].base = READ32(smram_state+SMRAM_IP5_DSBASE);
  84         cpustate->sreg[DS].flags = READ32(smram_state+SMRAM_IP5_DSACC);
  85         cpustate->sreg[FS].limit = READ32(smram_state+SMRAM_IP5_FSLIM);
  86         cpustate->sreg[FS].base = READ32(smram_state+SMRAM_IP5_FSBASE);
  87         cpustate->sreg[FS].flags = READ32(smram_state+SMRAM_IP5_FSACC);
  88         cpustate->sreg[GS].limit = READ32(smram_state+SMRAM_IP5_GSLIM);
  89         cpustate->sreg[GS].base = READ32(smram_state+SMRAM_IP5_GSBASE);
  90         cpustate->sreg[GS].flags = READ32(smram_state+SMRAM_IP5_GSACC);
  91         cpustate->ldtr.flags = READ32(smram_state+SMRAM_IP5_LDTACC);
  92         cpustate->ldtr.limit = READ32(smram_state+SMRAM_IP5_LDTLIM);
  93         cpustate->ldtr.base = READ32(smram_state+SMRAM_IP5_LDTBASE);
  94         cpustate->gdtr.limit = READ32(smram_state+SMRAM_IP5_GDTLIM);
  95         cpustate->gdtr.base = READ32(smram_state+SMRAM_IP5_GDTBASE);
  96         cpustate->idtr.limit = READ32(smram_state+SMRAM_IP5_IDTLIM);
  97         cpustate->idtr.base = READ32(smram_state+SMRAM_IP5_IDTBASE);
  98         cpustate->task.limit = READ32(smram_state+SMRAM_IP5_TRLIM);
  99         cpustate->task.base = READ32(smram_state+SMRAM_IP5_TRBASE);
 100         cpustate->task.flags = READ32(smram_state+SMRAM_IP5_TRACC);
 101
 102         cpustate->sreg[ES].selector = READ32(smram_state+SMRAM_ES);
 103         cpustate->sreg[CS].selector = READ32(smram_state+SMRAM_CS);
 104         cpustate->sreg[SS].selector = READ32(smram_state+SMRAM_SS);
 105         cpustate->sreg[DS].selector = READ32(smram_state+SMRAM_DS);
 106         cpustate->sreg[FS].selector = READ32(smram_state+SMRAM_FS);
 107         cpustate->sreg[GS].selector = READ32(smram_state+SMRAM_GS);
 108         cpustate->ldtr.segment = READ32(smram_state+SMRAM_LDTR);
 109         cpustate->task.segment = READ32(smram_state+SMRAM_TR);
 110
 111         cpustate->dr[7] = READ32(smram_state+SMRAM_DR7);
 112         cpustate->dr[6] = READ32(smram_state+SMRAM_DR6);
 113         REG32(EAX) = READ32(smram_state+SMRAM_EAX);
 114         REG32(ECX) = READ32(smram_state+SMRAM_ECX);
 115         REG32(EDX) = READ32(smram_state+SMRAM_EDX);
 116         REG32(EBX) = READ32(smram_state+SMRAM_EBX);
 117         REG32(ESP) = READ32(smram_state+SMRAM_ESP);
 118         REG32(EBP) = READ32(smram_state+SMRAM_EBP);
 119         REG32(ESI) = READ32(smram_state+SMRAM_ESI);
 120         REG32(EDI) = READ32(smram_state+SMRAM_EDI);
 121         cpustate->eip = READ32(smram_state+SMRAM_EIP);
 122         cpustate->eflags = READ32(smram_state+SMRAM_EFLAGS);
 123         cpustate->cr[3] = READ32(smram_state+SMRAM_CR3);
 124         cpustate->cr[0] = READ32(smram_state+SMRAM_CR0);
 125
 126         cpustate->CPL = (cpustate->sreg[SS].flags >> 13) & 3; // cpl == dpl of ss
 127
 128         for(int i = 0; i <= GS; i++)
 129         {
 130                 if(PROTECTED_MODE && !V8086_MODE)
 131                 {
 132                         cpustate->sreg[i].valid = cpustate->sreg[i].selector ? true : false;
 133                         cpustate->sreg[i].d = (cpustate->sreg[i].flags & 0x4000) ? 1 : 0;
 134                 }
 135                 else
 136                         cpustate->sreg[i].valid = true;
 137         }
 138
 139 //      if(!cpustate->smiact.isnull())
 140 //              cpustate->smiact(false);
 141         cpustate->smm = false;
 142
 143         CHANGE_PC(cpustate->eip);
 144         cpustate->nmi_masked = false;
 145         if(cpustate->smi_latched)
 146         {
 147                 pentium_smi();
 148                 return;
 149         }
 150         if(cpustate->nmi_latched)
 151         {
 152                 cpustate->nmi_latched = false;
 153                 i386_trap( 2, 1, 0);
 154         }
 155 }
 156
 157  void I386_OPS_BASE::PENTIUMOP(prefetch_m8)()    // Opcode 0x0f 18
 158 {
 159         UINT8 modrm = FETCH();
 160         UINT32 ea = GetEA(modrm, 0, 1);
 161         CYCLES(1+(ea & 1)); // TODO: correct cycle count
 162 }
 163
 164  void I386_OPS_BASE::PENTIUMOP(cmovo_r16_rm16)()    // Opcode 0x0f 40
 165 {
 166         UINT16 src;
 167         UINT8 modrm = FETCH();
 168
 169         if( modrm >= 0xc0 )
 170         {
 171                 if (cpustate->OF == 1)
 172                 {
 173                         src = LOAD_RM16(modrm);
 174                         STORE_REG16(modrm, src);
 175                 }
 176                 CYCLES(1); // TODO: correct cycle count
 177         }
 178         else
 179         {
 180                 UINT32 ea = GetEA(modrm, 0, 2);
 181                 if (cpustate->OF == 1)
 182                 {
 183                         src = READ16(ea);
 184                         STORE_REG16(modrm, src);
 185                 }
 186                 CYCLES(1); // TODO: correct cycle count
 187         }
 188 }
 189
 190  void I386_OPS_BASE::PENTIUMOP(cmovo_r32_rm32)()    // Opcode 0x0f 40
 191 {
 192         UINT32 src;
 193         UINT8 modrm = FETCH();
 194
 195         if( modrm >= 0xc0 )
 196         {
 197                 if (cpustate->OF == 1)
 198                 {
 199                         src = LOAD_RM32(modrm);
 200                         STORE_REG32(modrm, src);
 201                 }
 202                 CYCLES(1); // TODO: correct cycle count
 203         }
 204         else
 205         {
 206                 UINT32 ea = GetEA(modrm, 0, 4);
 207                 if (cpustate->OF == 1)
 208                 {
 209                         src = READ32(ea);
 210                         STORE_REG32(modrm, src);
 211                 }
 212                 CYCLES(1); // TODO: correct cycle count
 213         }
 214 }
 215
 216  void I386_OPS_BASE::PENTIUMOP(cmovno_r16_rm16)()    // Opcode 0x0f 41
 217 {
 218         UINT16 src;
 219         UINT8 modrm = FETCH();
 220
 221         if( modrm >= 0xc0 )
 222         {
 223                 if (cpustate->OF == 0)
 224                 {
 225                         src = LOAD_RM16(modrm);
 226                         STORE_REG16(modrm, src);
 227                 }
 228                 CYCLES(1); // TODO: correct cycle count
 229         }
 230         else
 231         {
 232                 UINT32 ea = GetEA(modrm, 0, 2);
 233                 if (cpustate->OF == 0)
 234                 {
 235                         src = READ16(ea);
 236                         STORE_REG16(modrm, src);
 237                 }
 238                 CYCLES(1); // TODO: correct cycle count
 239         }
 240 }
 241
 242  void I386_OPS_BASE::PENTIUMOP(cmovno_r32_rm32)()    // Opcode 0x0f 41
 243 {
 244         UINT32 src;
 245         UINT8 modrm = FETCH();
 246
 247         if( modrm >= 0xc0 )
 248         {
 249                 if (cpustate->OF == 0)
 250                 {
 251                         src = LOAD_RM32(modrm);
 252                         STORE_REG32(modrm, src);
 253                 }
 254                 CYCLES(1); // TODO: correct cycle count
 255         }
 256         else
 257         {
 258                 UINT32 ea = GetEA(modrm, 0, 4);
 259                 if (cpustate->OF == 0)
 260                 {
 261                         src = READ32(ea);
 262                         STORE_REG32(modrm, src);
 263                 }
 264                 CYCLES(1); // TODO: correct cycle count
 265         }
 266 }
 267
 268  void I386_OPS_BASE::PENTIUMOP(cmovb_r16_rm16)()    // Opcode 0x0f 42
 269 {
 270         UINT16 src;
 271         UINT8 modrm = FETCH();
 272
 273         if( modrm >= 0xc0 )
 274         {
 275                 if (cpustate->CF == 1)
 276                 {
 277                         src = LOAD_RM16(modrm);
 278                         STORE_REG16(modrm, src);
 279                 }
 280                 CYCLES(1); // TODO: correct cycle count
 281         }
 282         else
 283         {
 284                 UINT32 ea = GetEA(modrm, 0, 2);
 285                 if (cpustate->CF == 1)
 286                 {
 287                         src = READ16(ea);
 288                         STORE_REG16(modrm, src);
 289                 }
 290                 CYCLES(1); // TODO: correct cycle count
 291         }
 292 }
 293
 294  void I386_OPS_BASE::PENTIUMOP(cmovb_r32_rm32)()    // Opcode 0x0f 42
 295 {
 296         UINT32 src;
 297         UINT8 modrm = FETCH();
 298
 299         if( modrm >= 0xc0 )
 300         {
 301                 if (cpustate->CF == 1)
 302                 {
 303                         src = LOAD_RM32(modrm);
 304                         STORE_REG32(modrm, src);
 305                 }
 306                 CYCLES(1); // TODO: correct cycle count
 307         }
 308         else
 309         {
 310                 UINT32 ea = GetEA(modrm, 0, 4);
 311                 if (cpustate->CF == 1)
 312                 {
 313                         src = READ32(ea);
 314                         STORE_REG32(modrm, src);
 315                 }
 316                 CYCLES(1); // TODO: correct cycle count
 317         }
 318 }
 319
 320  void I386_OPS_BASE::PENTIUMOP(cmovae_r16_rm16)()    // Opcode 0x0f 43
 321 {
 322         UINT16 src;
 323         UINT8 modrm = FETCH();
 324
 325         if( modrm >= 0xc0 )
 326         {
 327                 if (cpustate->CF == 0)
 328                 {
 329                         src = LOAD_RM16(modrm);
 330                         STORE_REG16(modrm, src);
 331                 }
 332                 CYCLES(1); // TODO: correct cycle count
 333         }
 334         else
 335         {
 336                 UINT32 ea = GetEA(modrm, 0, 2);
 337                 if (cpustate->CF == 0)
 338                 {
 339                         src = READ16(ea);
 340                         STORE_REG16(modrm, src);
 341                 }
 342                 CYCLES(1); // TODO: correct cycle count
 343         }
 344 }
 345
 346  void I386_OPS_BASE::PENTIUMOP(cmovae_r32_rm32)()    // Opcode 0x0f 43
 347 {
 348         UINT32 src;
 349         UINT8 modrm = FETCH();
 350
 351         if( modrm >= 0xc0 )
 352         {
 353                 if (cpustate->CF == 0)
 354                 {
 355                         src = LOAD_RM32(modrm);
 356                         STORE_REG32(modrm, src);
 357                 }
 358                 CYCLES(1); // TODO: correct cycle count
 359         }
 360         else
 361         {
 362                 UINT32 ea = GetEA(modrm, 0, 4);
 363                 if (cpustate->CF == 0)
 364                 {
 365                         src = READ32(ea);
 366                         STORE_REG32(modrm, src);
 367                 }
 368                 CYCLES(1); // TODO: correct cycle count
 369         }
 370 }
 371
 372  void I386_OPS_BASE::PENTIUMOP(cmove_r16_rm16)()    // Opcode 0x0f 44
 373 {
 374         UINT16 src;
 375         UINT8 modrm = FETCH();
 376
 377         if( modrm >= 0xc0 )
 378         {
 379                 if (cpustate->ZF == 1)
 380                 {
 381                         src = LOAD_RM16(modrm);
 382                         STORE_REG16(modrm, src);
 383                 }
 384                 CYCLES(1); // TODO: correct cycle count
 385         }
 386         else
 387         {
 388                 UINT32 ea = GetEA(modrm, 0, 2);
 389                 if (cpustate->ZF == 1)
 390                 {
 391                         src = READ16(ea);
 392                         STORE_REG16(modrm, src);
 393                 }
 394                 CYCLES(1); // TODO: correct cycle count
 395         }
 396 }
 397
 398  void I386_OPS_BASE::PENTIUMOP(cmove_r32_rm32)()    // Opcode 0x0f 44
 399 {
 400         UINT32 src;
 401         UINT8 modrm = FETCH();
 402
 403         if( modrm >= 0xc0 )
 404         {
 405                 if (cpustate->ZF == 1)
 406                 {
 407                         src = LOAD_RM32(modrm);
 408                         STORE_REG32(modrm, src);
 409                 }
 410                 CYCLES(1); // TODO: correct cycle count
 411         }
 412         else
 413         {
 414                 UINT32 ea = GetEA(modrm, 0, 4);
 415                 if (cpustate->ZF == 1)
 416                 {
 417                         src = READ32(ea);
 418                         STORE_REG32(modrm, src);
 419                 }
 420                 CYCLES(1); // TODO: correct cycle count
 421         }
 422 }
 423
 424  void I386_OPS_BASE::PENTIUMOP(cmovne_r16_rm16)()    // Opcode 0x0f 45
 425 {
 426         UINT16 src;
 427         UINT8 modrm = FETCH();
 428
 429         if( modrm >= 0xc0 )
 430         {
 431                 if (cpustate->ZF == 0)
 432                 {
 433                         src = LOAD_RM16(modrm);
 434                         STORE_REG16(modrm, src);
 435                 }
 436                 CYCLES(1); // TODO: correct cycle count
 437         }
 438         else
 439         {
 440                 UINT32 ea = GetEA(modrm, 0, 2);
 441                 if (cpustate->ZF == 0)
 442                 {
 443                         src = READ16(ea);
 444                         STORE_REG16(modrm, src);
 445                 }
 446                 CYCLES(1); // TODO: correct cycle count
 447         }
 448 }
 449
 450  void I386_OPS_BASE::PENTIUMOP(cmovne_r32_rm32)()    // Opcode 0x0f 45
 451 {
 452         UINT32 src;
 453         UINT8 modrm = FETCH();
 454
 455         if( modrm >= 0xc0 )
 456         {
 457                 if (cpustate->ZF == 0)
 458                 {
 459                         src = LOAD_RM32(modrm);
 460                         STORE_REG32(modrm, src);
 461                 }
 462                 CYCLES(1); // TODO: correct cycle count
 463         }
 464         else
 465         {
 466                 UINT32 ea = GetEA(modrm, 0, 4);
 467                 if (cpustate->ZF == 0)
 468                 {
 469                         src = READ32(ea);
 470                         STORE_REG32(modrm, src);
 471                 }
 472                 CYCLES(1); // TODO: correct cycle count
 473         }
 474 }
 475
 476  void I386_OPS_BASE::PENTIUMOP(cmovbe_r16_rm16)()    // Opcode 0x0f 46
 477 {
 478         UINT16 src;
 479         UINT8 modrm = FETCH();
 480
 481         if( modrm >= 0xc0 )
 482         {
 483                 if ((cpustate->CF == 1) || (cpustate->ZF == 1))
 484                 {
 485                         src = LOAD_RM16(modrm);
 486                         STORE_REG16(modrm, src);
 487                 }
 488                 CYCLES(1); // TODO: correct cycle count
 489         }
 490         else
 491         {
 492                 UINT32 ea = GetEA(modrm, 0, 2);
 493                 if ((cpustate->CF == 1) || (cpustate->ZF == 1))
 494                 {
 495                         src = READ16(ea);
 496                         STORE_REG16(modrm, src);
 497                 }
 498                 CYCLES(1); // TODO: correct cycle count
 499         }
 500 }
 501
 502  void I386_OPS_BASE::PENTIUMOP(cmovbe_r32_rm32)()    // Opcode 0x0f 46
 503 {
 504         UINT32 src;
 505         UINT8 modrm = FETCH();
 506
 507         if( modrm >= 0xc0 )
 508         {
 509                 if ((cpustate->CF == 1) || (cpustate->ZF == 1))
 510                 {
 511                         src = LOAD_RM32(modrm);
 512                         STORE_REG32(modrm, src);
 513                 }
 514                 CYCLES(1); // TODO: correct cycle count
 515         }
 516         else
 517         {
 518                 UINT32 ea = GetEA(modrm, 0, 4);
 519                 if ((cpustate->CF == 1) || (cpustate->ZF == 1))
 520                 {
 521                         src = READ32(ea);
 522                         STORE_REG32(modrm, src);
 523                 }
 524                 CYCLES(1); // TODO: correct cycle count
 525         }
 526 }
 527
 528  void I386_OPS_BASE::PENTIUMOP(cmova_r16_rm16)()    // Opcode 0x0f 47
 529 {
 530         UINT16 src;
 531         UINT8 modrm = FETCH();
 532
 533         if( modrm >= 0xc0 )
 534         {
 535                 if ((cpustate->CF == 0) && (cpustate->ZF == 0))
 536                 {
 537                         src = LOAD_RM16(modrm);
 538                         STORE_REG16(modrm, src);
 539                 }
 540                 CYCLES(1); // TODO: correct cycle count
 541         }
 542         else
 543         {
 544                 UINT32 ea = GetEA(modrm, 0, 2);
 545                 if ((cpustate->CF == 0) && (cpustate->ZF == 0))
 546                 {
 547                         src = READ16(ea);
 548                         STORE_REG16(modrm, src);
 549                 }
 550                 CYCLES(1); // TODO: correct cycle count
 551         }
 552 }
 553
 554  void I386_OPS_BASE::PENTIUMOP(cmova_r32_rm32)()    // Opcode 0x0f 47
 555 {
 556         UINT32 src;
 557         UINT8 modrm = FETCH();
 558
 559         if( modrm >= 0xc0 )
 560         {
 561                 if ((cpustate->CF == 0) && (cpustate->ZF == 0))
 562                 {
 563                         src = LOAD_RM32(modrm);
 564                         STORE_REG32(modrm, src);
 565                 }
 566                 CYCLES(1); // TODO: correct cycle count
 567         }
 568         else
 569         {
 570                 UINT32 ea = GetEA(modrm, 0, 4);
 571                 if ((cpustate->CF == 0) && (cpustate->ZF == 0))
 572                 {
 573                         src = READ32(ea);
 574                         STORE_REG32(modrm, src);
 575                 }
 576                 CYCLES(1); // TODO: correct cycle count
 577         }
 578 }
 579
 580  void I386_OPS_BASE::PENTIUMOP(cmovs_r16_rm16)()    // Opcode 0x0f 48
 581 {
 582         UINT16 src;
 583         UINT8 modrm = FETCH();
 584
 585         if( modrm >= 0xc0 )
 586         {
 587                 if (cpustate->SF == 1)
 588                 {
 589                         src = LOAD_RM16(modrm);
 590                         STORE_REG16(modrm, src);
 591                 }
 592                 CYCLES(1); // TODO: correct cycle count
 593         }
 594         else
 595         {
 596                 UINT32 ea = GetEA(modrm, 0, 2);
 597                 if (cpustate->SF == 1)
 598                 {
 599                         src = READ16(ea);
 600                         STORE_REG16(modrm, src);
 601                 }
 602                 CYCLES(1); // TODO: correct cycle count
 603         }
 604 }
 605
 606  void I386_OPS_BASE::PENTIUMOP(cmovs_r32_rm32)()    // Opcode 0x0f 48
 607 {
 608         UINT32 src;
 609         UINT8 modrm = FETCH();
 610
 611         if( modrm >= 0xc0 )
 612         {
 613                 if (cpustate->SF == 1)
 614                 {
 615                         src = LOAD_RM32(modrm);
 616                         STORE_REG32(modrm, src);
 617                 }
 618                 CYCLES(1); // TODO: correct cycle count
 619         }
 620         else
 621         {
 622                 UINT32 ea = GetEA(modrm, 0, 4);
 623                 if (cpustate->SF == 1)
 624                 {
 625                         src = READ32(ea);
 626                         STORE_REG32(modrm, src);
 627                 }
 628                 CYCLES(1); // TODO: correct cycle count
 629         }
 630 }
 631
 632  void I386_OPS_BASE::PENTIUMOP(cmovns_r16_rm16)()    // Opcode 0x0f 49
 633 {
 634         UINT16 src;
 635         UINT8 modrm = FETCH();
 636
 637         if( modrm >= 0xc0 )
 638         {
 639                 if (cpustate->SF == 0)
 640                 {
 641                         src = LOAD_RM16(modrm);
 642                         STORE_REG16(modrm, src);
 643                 }
 644                 CYCLES(1); // TODO: correct cycle count
 645         }
 646         else
 647         {
 648                 UINT32 ea = GetEA(modrm, 0, 2);
 649                 if (cpustate->SF == 0)
 650                 {
 651                         src = READ16(ea);
 652                         STORE_REG16(modrm, src);
 653                 }
 654                 CYCLES(1); // TODO: correct cycle count
 655         }
 656 }
 657
 658  void I386_OPS_BASE::PENTIUMOP(cmovns_r32_rm32)()    // Opcode 0x0f 49
 659 {
 660         UINT32 src;
 661         UINT8 modrm = FETCH();
 662
 663         if( modrm >= 0xc0 )
 664         {
 665                 if (cpustate->SF == 0)
 666                 {
 667                         src = LOAD_RM32(modrm);
 668                         STORE_REG32(modrm, src);
 669                 }
 670                 CYCLES(1); // TODO: correct cycle count
 671         }
 672         else
 673         {
 674                 UINT32 ea = GetEA(modrm, 0, 4);
 675                 if (cpustate->SF == 0)
 676                 {
 677                         src = READ32(ea);
 678                         STORE_REG32(modrm, src);
 679                 }
 680                 CYCLES(1); // TODO: correct cycle count
 681         }
 682 }
 683
 684  void I386_OPS_BASE::PENTIUMOP(cmovp_r16_rm16)()    // Opcode 0x0f 4a
 685 {
 686         UINT16 src;
 687         UINT8 modrm = FETCH();
 688
 689         if( modrm >= 0xc0 )
 690         {
 691                 if (cpustate->PF == 1)
 692                 {
 693                         src = LOAD_RM16(modrm);
 694                         STORE_REG16(modrm, src);
 695                 }
 696                 CYCLES(1); // TODO: correct cycle count
 697         }
 698         else
 699         {
 700                 UINT32 ea = GetEA(modrm, 0, 2);
 701                 if (cpustate->PF == 1)
 702                 {
 703                         src = READ16(ea);
 704                         STORE_REG16(modrm, src);
 705                 }
 706                 CYCLES(1); // TODO: correct cycle count
 707         }
 708 }
 709
 710  void I386_OPS_BASE::PENTIUMOP(cmovp_r32_rm32)()    // Opcode 0x0f 4a
 711 {
 712         UINT32 src;
 713         UINT8 modrm = FETCH();
 714
 715         if( modrm >= 0xc0 )
 716         {
 717                 if (cpustate->PF == 1)
 718                 {
 719                         src = LOAD_RM32(modrm);
 720                         STORE_REG32(modrm, src);
 721                 }
 722                 CYCLES(1); // TODO: correct cycle count
 723         }
 724         else
 725         {
 726                 UINT32 ea = GetEA(modrm, 0, 4);
 727                 if (cpustate->PF == 1)
 728                 {
 729                         src = READ32(ea);
 730                         STORE_REG32(modrm, src);
 731                 }
 732                 CYCLES(1); // TODO: correct cycle count
 733         }
 734 }
 735
 736  void I386_OPS_BASE::PENTIUMOP(cmovnp_r16_rm16)()    // Opcode 0x0f 4b
 737 {
 738         UINT16 src;
 739         UINT8 modrm = FETCH();
 740
 741         if( modrm >= 0xc0 )
 742         {
 743                 if (cpustate->PF == 0)
 744                 {
 745                         src = LOAD_RM16(modrm);
 746                         STORE_REG16(modrm, src);
 747                 }
 748                 CYCLES(1); // TODO: correct cycle count
 749         }
 750         else
 751         {
 752                 UINT32 ea = GetEA(modrm, 0, 2);
 753                 if (cpustate->PF == 0)
 754                 {
 755                         src = READ16(ea);
 756                         STORE_REG16(modrm, src);
 757                 }
 758                 CYCLES(1); // TODO: correct cycle count
 759         }
 760 }
 761
 762  void I386_OPS_BASE::PENTIUMOP(cmovnp_r32_rm32)()    // Opcode 0x0f 4b
 763 {
 764         UINT32 src;
 765         UINT8 modrm = FETCH();
 766
 767         if( modrm >= 0xc0 )
 768         {
 769                 if (cpustate->PF == 0)
 770                 {
 771                         src = LOAD_RM32(modrm);
 772                         STORE_REG32(modrm, src);
 773                 }
 774                 CYCLES(1); // TODO: correct cycle count
 775         }
 776         else
 777         {
 778                 UINT32 ea = GetEA(modrm, 0, 4);
 779                 if (cpustate->PF == 0)
 780                 {
 781                         src = READ32(ea);
 782                         STORE_REG32(modrm, src);
 783                 }
 784                 CYCLES(1); // TODO: correct cycle count
 785         }
 786 }
 787
 788  void I386_OPS_BASE::PENTIUMOP(cmovl_r16_rm16)()    // Opcode 0x0f 4c
 789 {
 790         UINT16 src;
 791         UINT8 modrm = FETCH();
 792
 793         if( modrm >= 0xc0 )
 794         {
 795                 if (cpustate->SF != cpustate->OF)
 796                 {
 797                         src = LOAD_RM16(modrm);
 798                         STORE_REG16(modrm, src);
 799                 }
 800                 CYCLES(1); // TODO: correct cycle count
 801         }
 802         else
 803         {
 804                 UINT32 ea = GetEA(modrm, 0, 2);
 805                 if (cpustate->SF != cpustate->OF)
 806                 {
 807                         src = READ16(ea);
 808                         STORE_REG16(modrm, src);
 809                 }
 810                 CYCLES(1); // TODO: correct cycle count
 811         }
 812 }
 813
 814  void I386_OPS_BASE::PENTIUMOP(cmovl_r32_rm32)()    // Opcode 0x0f 4c
 815 {
 816         UINT32 src;
 817         UINT8 modrm = FETCH();
 818
 819         if( modrm >= 0xc0 )
 820         {
 821                 if (cpustate->SF != cpustate->OF)
 822                 {
 823                         src = LOAD_RM32(modrm);
 824                         STORE_REG32(modrm, src);
 825                 }
 826                 CYCLES(1); // TODO: correct cycle count
 827         }
 828         else
 829         {
 830                 UINT32 ea = GetEA(modrm, 0, 4);
 831                 if (cpustate->SF != cpustate->OF)
 832                 {
 833                         src = READ32(ea);
 834                         STORE_REG32(modrm, src);
 835                 }
 836                 CYCLES(1); // TODO: correct cycle count
 837         }
 838 }
 839
 840  void I386_OPS_BASE::PENTIUMOP(cmovge_r16_rm16)()    // Opcode 0x0f 4d
 841 {
 842         UINT16 src;
 843         UINT8 modrm = FETCH();
 844
 845         if( modrm >= 0xc0 )
 846         {
 847                 if (cpustate->SF == cpustate->OF)
 848                 {
 849                         src = LOAD_RM16(modrm);
 850                         STORE_REG16(modrm, src);
 851                 }
 852                 CYCLES(1); // TODO: correct cycle count
 853         }
 854         else
 855         {
 856                 UINT32 ea = GetEA(modrm, 0, 2);
 857                 if (cpustate->SF == cpustate->OF)
 858                 {
 859                         src = READ16(ea);
 860                         STORE_REG16(modrm, src);
 861                 }
 862                 CYCLES(1); // TODO: correct cycle count
 863         }
 864 }
 865
 866  void I386_OPS_BASE::PENTIUMOP(cmovge_r32_rm32)()    // Opcode 0x0f 4d
 867 {
 868         UINT32 src;
 869         UINT8 modrm = FETCH();
 870
 871         if( modrm >= 0xc0 )
 872         {
 873                 if (cpustate->SF == cpustate->OF)
 874                 {
 875                         src = LOAD_RM32(modrm);
 876                         STORE_REG32(modrm, src);
 877                 }
 878                 CYCLES(1); // TODO: correct cycle count
 879         }
 880         else
 881         {
 882                 UINT32 ea = GetEA(modrm, 0, 4);
 883                 if (cpustate->SF == cpustate->OF)
 884                 {
 885                         src = READ32(ea);
 886                         STORE_REG32(modrm, src);
 887                 }
 888                 CYCLES(1); // TODO: correct cycle count
 889         }
 890 }
 891
 892  void I386_OPS_BASE::PENTIUMOP(cmovle_r16_rm16)()    // Opcode 0x0f 4e
 893 {
 894         UINT16 src;
 895         UINT8 modrm = FETCH();
 896
 897         if( modrm >= 0xc0 )
 898         {
 899                 if ((cpustate->ZF == 1) || (cpustate->SF != cpustate->OF))
 900                 {
 901                         src = LOAD_RM16(modrm);
 902                         STORE_REG16(modrm, src);
 903                 }
 904                 CYCLES(1); // TODO: correct cycle count
 905         }
 906         else
 907         {
 908                 UINT32 ea = GetEA(modrm, 0, 2);
 909                 if ((cpustate->ZF == 1) || (cpustate->SF != cpustate->OF))
 910                 {
 911                         src = READ16(ea);
 912                         STORE_REG16(modrm, src);
 913                 }
 914                 CYCLES(1); // TODO: correct cycle count
 915         }
 916 }
 917
 918  void I386_OPS_BASE::PENTIUMOP(cmovle_r32_rm32)()    // Opcode 0x0f 4e
 919 {
 920         UINT32 src;
 921         UINT8 modrm = FETCH();
 922
 923         if( modrm >= 0xc0 )
 924         {
 925                 if ((cpustate->ZF == 1) || (cpustate->SF != cpustate->OF))
 926                 {
 927                         src = LOAD_RM32(modrm);
 928                         STORE_REG32(modrm, src);
 929                 }
 930                 CYCLES(1); // TODO: correct cycle count
 931         }
 932         else
 933         {
 934                 UINT32 ea = GetEA(modrm, 0, 4);
 935                 if ((cpustate->ZF == 1) || (cpustate->SF != cpustate->OF))
 936                 {
 937                         src = READ32(ea);
 938                         STORE_REG32(modrm, src);
 939                 }
 940                 CYCLES(1); // TODO: correct cycle count
 941         }
 942 }
 943
 944  void I386_OPS_BASE::PENTIUMOP(cmovg_r16_rm16)()    // Opcode 0x0f 4f
 945 {
 946         UINT16 src;
 947         UINT8 modrm = FETCH();
 948
 949         if( modrm >= 0xc0 )
 950         {
 951                 if ((cpustate->ZF == 0) && (cpustate->SF == cpustate->OF))
 952                 {
 953                         src = LOAD_RM16(modrm);
 954                         STORE_REG16(modrm, src);
 955                 }
 956                 CYCLES(1); // TODO: correct cycle count
 957         }
 958         else
 959         {
 960                 UINT32 ea = GetEA(modrm, 0, 2);
 961                 if ((cpustate->ZF == 0) && (cpustate->SF == cpustate->OF))
 962                 {
 963                         src = READ16(ea);
 964                         STORE_REG16(modrm, src);
 965                 }
 966                 CYCLES(1); // TODO: correct cycle count
 967         }
 968 }
 969
 970  void I386_OPS_BASE::PENTIUMOP(cmovg_r32_rm32)()    // Opcode 0x0f 4f
 971 {
 972         UINT32 src;
 973         UINT8 modrm = FETCH();
 974
 975         if( modrm >= 0xc0 )
 976         {
 977                 if ((cpustate->ZF == 0) && (cpustate->SF == cpustate->OF))
 978                 {
 979                         src = LOAD_RM32(modrm);
 980                         STORE_REG32(modrm, src);
 981                 }
 982                 CYCLES(1); // TODO: correct cycle count
 983         }
 984         else
 985         {
 986                 UINT32 ea = GetEA(modrm, 0, 4);
 987                 if ((cpustate->ZF == 0) && (cpustate->SF == cpustate->OF))
 988                 {
 989                         src = READ32(ea);
 990                         STORE_REG32(modrm, src);
 991                 }
 992                 CYCLES(1); // TODO: correct cycle count
 993         }
 994 }
 995
 996  void I386_OPS_BASE::PENTIUMOP(movnti_m16_r16)() // Opcode 0f c3
 997 {
 998         UINT8 modrm = FETCH();
 999         if( modrm >= 0xc0 ) {
1000                 // unsupported by cpu
1001                 CYCLES(1);     // TODO: correct cycle count
1002         } else {
1003                 // since cache is not implemented
1004                 UINT32 ea = GetEA(modrm, 0, 2);
1005                 WRITE16(ea,LOAD_RM16(modrm));
1006                 CYCLES(1);     // TODO: correct cycle count
1007         }
1008 }
1009
1010  void I386_OPS_BASE::PENTIUMOP(movnti_m32_r32)() // Opcode 0f c3
1011 {
1012         UINT8 modrm = FETCH();
1013         if( modrm >= 0xc0 ) {
1014                 // unsupported by cpu
1015                 CYCLES(1);     // TODO: correct cycle count
1016         } else {
1017                 // since cache is not implemented
1018                 UINT32 ea = GetEA(modrm, 0, 4);
1019                 WRITE32(ea,LOAD_RM32(modrm));
1020                 CYCLES(1);     // TODO: correct cycle count
1021         }
1022 }
1023
1024 void I386_OPS_BASE::I386OP(cyrix_special)()     // Opcode 0x0f 3a-3d
1025 {
1026 /*
1027 0f 3a       BB0_RESET (set BB0 pointer = base)
1028 0f 3b       BB1_RESET (set BB1 pointer = base)
1029 0f 3c       CPU_WRITE (write special CPU memory-mapped register, [ebx] = eax)
1030 0f 3d       CPU_READ (read special CPU memory-mapped register, eax, = [ebx])
1031 */
1032
1033         CYCLES(1);
1034 }
1035
1036  void I386_OPS_BASE::I386OP(cyrix_unknown)()     // Opcode 0x0f 74
1037 {
1038         logerror("Unemulated 0x0f 0x74 opcode called\n");
1039
1040         CYCLES(1);
1041 }
1042
1043  void I386_OPS_BASE::PENTIUMOP(cmpxchg8b_m64)()  // Opcode 0x0f c7
1044 {
1045         UINT8 modm = FETCH();
1046         if( modm >= 0xc0 ) {
1047                 report_invalid_modrm( "cmpxchg8b_m64", modm);
1048         } else {
1049                 UINT32 ea = GetEA(modm, 0, 8);
1050                 UINT64 value = READ64( ea);
1051                 UINT64 edx_eax = (((UINT64) REG32(EDX)) << 32) | REG32(EAX);
1052                 UINT64 ecx_ebx = (((UINT64) REG32(ECX)) << 32) | REG32(EBX);
1053
1054                 if( value == edx_eax ) {
1055                         WRITE64( ea, ecx_ebx);
1056                         cpustate->ZF = 1;
1057                         CYCLES(CYCLES_CMPXCHG_REG_MEM_T);
1058                 } else {
1059                         REG32(EDX) = (UINT32) (value >> 32);
1060                         REG32(EAX) = (UINT32) (value >>  0);
1061                         cpustate->ZF = 0;
1062                         CYCLES(CYCLES_CMPXCHG_REG_MEM_F);
1063                 }
1064         }
1065 }
1066
1067  void I386_OPS_BASE::PENTIUMOP(movntq_m64_r64)() // Opcode 0f e7
1068 {
1069         //MMXPROLOG(); // TODO: check if needed
1070         UINT8 modrm = FETCH();
1071         if( modrm >= 0xc0 ) {
1072                 CYCLES(1);     // unsupported
1073         } else {
1074                 // since cache is not implemented
1075                 UINT32 ea = GetEA(modrm, 0, 8);
1076                 WRITEMMX( ea, MMX((modrm >> 3) & 0x7));
1077                 CYCLES(1);     // TODO: correct cycle count
1078         }
1079 }
1080
1081  void I386_OPS_BASE::PENTIUMOP(maskmovq_r64_r64)()  // Opcode 0f f7
1082 {
1083         int s,m,n;
1084         UINT8 modm = FETCH();
1085         UINT32 ea = GetEA(7, 0, 8); // ds:di/edi/rdi register
1086         MMXPROLOG();
1087         s=(modm >> 3) & 7;
1088         m=modm & 7;
1089         for (n=0;n <= 7;n++)
1090                 if (MMX(m).b[n] & 127)
1091                         WRITE8(ea+n, MMX(s).b[n]);
1092 }
1093
1094  void I386_OPS_BASE::SSEOP(maskmovdqu_r128_r128)()  // Opcode 66 0f f7
1095 {
1096         int s,m,n;
1097         UINT8 modm = FETCH();
1098         UINT32 ea = GetEA(7, 0, 16); // ds:di/edi/rdi register
1099         s=(modm >> 3) & 7;
1100         m=modm & 7;
1101         for (n=0;n < 16;n++)
1102                 if (XMM(m).b[n] & 127)
1103                         WRITE8(ea+n, XMM(s).b[n]);
1104 }
1105
1106  void I386_OPS_BASE::PENTIUMOP(popcnt_r16_rm16)()    // Opcode f3 0f b8
1107 {
1108         UINT16 src;
1109         UINT8 modrm = FETCH();
1110         int n,count;
1111
1112         if( modrm >= 0xc0 ) {
1113                 src = LOAD_RM16(modrm);
1114         } else {
1115                 UINT32 ea = GetEA(modrm, 0, 2);
1116                 src = READ16(ea);
1117         }
1118         count=0;
1119         for (n=0;n < 16;n++) {
1120                 count=count+(src & 1);
1121                 src=src >> 1;
1122         }
1123         STORE_REG16(modrm, count);
1124         CYCLES(1); // TODO: correct cycle count
1125 }
1126
1127  void I386_OPS_BASE::PENTIUMOP(popcnt_r32_rm32)()    // Opcode f3 0f b8
1128 {
1129         UINT32 src;
1130         UINT8 modrm = FETCH();
1131         int n,count;
1132
1133         if( modrm >= 0xc0 ) {
1134                 src = LOAD_RM32(modrm);
1135         } else {
1136                 UINT32 ea = GetEA(modrm, 0, 4);
1137                 src = READ32(ea);
1138         }
1139         count=0;
1140         for (n=0;n < 32;n++) {
1141                 count=count+(src & 1);
1142                 src=src >> 1;
1143         }
1144         STORE_REG32(modrm, count);
1145         CYCLES(1); // TODO: correct cycle count
1146 }
1147
1148  void I386_OPS_BASE::PENTIUMOP(tzcnt_r16_rm16)()
1149 {
1150         // for CPUs that don't support TZCNT, fall back to BSF
1151         i386_bsf_r16_rm16();
1152         // TODO: actually implement TZCNT
1153 }
1154
1155  void I386_OPS_BASE::PENTIUMOP(tzcnt_r32_rm32)()
1156 {
1157         // for CPUs that don't support TZCNT, fall back to BSF
1158         i386_bsf_r32_rm32();
1159         // TODO: actually implement TZCNT
1160 }
1161
1162
1163  void I386_OPS_BASE::MMXOP(group_0f71)()  // Opcode 0f 71
1164 {
1165         UINT8 modm = FETCH();
1166         UINT8 imm8 = FETCH();
1167         MMXPROLOG();
1168         if( modm >= 0xc0 ) {
1169                 switch ( (modm & 0x38) >> 3 )
1170                 {
1171                         case 2: // psrlw
1172                                 MMX(modm & 7).w[0]=MMX(modm & 7).w[0] >> imm8;
1173                                 MMX(modm & 7).w[1]=MMX(modm & 7).w[1] >> imm8;
1174                                 MMX(modm & 7).w[2]=MMX(modm & 7).w[2] >> imm8;
1175                                 MMX(modm & 7).w[3]=MMX(modm & 7).w[3] >> imm8;
1176                                 break;
1177                         case 4: // psraw
1178                                 MMX(modm & 7).s[0]=MMX(modm & 7).s[0] >> imm8;
1179                                 MMX(modm & 7).s[1]=MMX(modm & 7).s[1] >> imm8;
1180                                 MMX(modm & 7).s[2]=MMX(modm & 7).s[2] >> imm8;
1181                                 MMX(modm & 7).s[3]=MMX(modm & 7).s[3] >> imm8;
1182                                 break;
1183                         case 6: // psllw
1184                                 MMX(modm & 7).w[0]=MMX(modm & 7).w[0] << imm8;
1185                                 MMX(modm & 7).w[1]=MMX(modm & 7).w[1] << imm8;
1186                                 MMX(modm & 7).w[2]=MMX(modm & 7).w[2] << imm8;
1187                                 MMX(modm & 7).w[3]=MMX(modm & 7).w[3] << imm8;
1188                                 break;
1189                         default:
1190                                 report_invalid_modrm( "mmx_group0f71", modm);
1191                 }
1192         }
1193 }
1194
1195  void I386_OPS_BASE::I386_OPS_BASE::SSEOP(group_660f71)()  // Opcode 66 0f 71
1196 {
1197         UINT8 modm = FETCH();
1198         UINT8 imm8 = FETCH();
1199         if (modm >= 0xc0) {
1200                 switch ((modm & 0x38) >> 3)
1201                 {
1202                         case 2: // psrlw
1203                                 for (int n = 0; n < 8;n++)
1204                                         XMM(modm & 7).w[n] = XMM(modm & 7).w[n] >> imm8;
1205                                 break;
1206                         case 4: // psraw
1207                                 for (int n = 0; n < 8;n++)
1208                                         XMM(modm & 7).s[n] = XMM(modm & 7).s[n] >> imm8;
1209                                 break;
1210                         case 6: // psllw
1211                                 for (int n = 0; n < 8;n++)
1212                                         XMM(modm & 7).w[n] = XMM(modm & 7).w[n] << imm8;
1213                                 break;
1214                         default:
1215                                 report_invalid_modrm( "mmx_group660f71", modm);
1216                 }
1217         }
1218 }
1219
1220  void I386_OPS_BASE::MMXOP(group_0f72)()  // Opcode 0f 72
1221 {
1222         UINT8 modm = FETCH();
1223         UINT8 imm8 = FETCH();
1224         MMXPROLOG();
1225         if( modm >= 0xc0 ) {
1226                 switch ( (modm & 0x38) >> 3 )
1227                 {
1228                         case 2: // psrld
1229                                 MMX(modm & 7).d[0]=MMX(modm & 7).d[0] >> imm8;
1230                                 MMX(modm & 7).d[1]=MMX(modm & 7).d[1] >> imm8;
1231                                 break;
1232                         case 4: // psrad
1233                                 MMX(modm & 7).i[0]=MMX(modm & 7).i[0] >> imm8;
1234                                 MMX(modm & 7).i[1]=MMX(modm & 7).i[1] >> imm8;
1235                                 break;
1236                         case 6: // pslld
1237                                 MMX(modm & 7).d[0]=MMX(modm & 7).d[0] << imm8;
1238                                 MMX(modm & 7).d[1]=MMX(modm & 7).d[1] << imm8;
1239                                 break;
1240                         default:
1241                                 report_invalid_modrm( "mmx_group0f72", modm);
1242                 }
1243         }
1244 }
1245
1246  void I386_OPS_BASE::SSEOP(group_660f72)()  // Opcode 66 0f 72
1247 {
1248         UINT8 modm = FETCH();
1249         UINT8 imm8 = FETCH();
1250         if (modm >= 0xc0) {
1251                 switch ((modm & 0x38) >> 3)
1252                 {
1253                         case 2: // psrld
1254                                 for (int n = 0; n < 4;n++)
1255                                         XMM(modm & 7).d[n] = XMM(modm & 7).d[n] >> imm8;
1256                                 break;
1257                         case 4: // psrad
1258                                 for (int n = 0; n < 4;n++)
1259                                         XMM(modm & 7).i[n] = XMM(modm & 7).i[n] >> imm8;
1260                                 break;
1261                         case 6: // pslld
1262                                 for (int n = 0; n < 4;n++)
1263                                         XMM(modm & 7).d[n] = XMM(modm & 7).d[n] << imm8;
1264                                 break;
1265                         default:
1266                                 report_invalid_modrm( "mmx_group660f72", modm);
1267                 }
1268         }
1269 }
1270
1271  void I386_OPS_BASE::MMXOP(group_0f73)()  // Opcode 0f 73
1272 {
1273         UINT8 modm = FETCH();
1274         UINT8 imm8 = FETCH();
1275         MMXPROLOG();
1276         if( modm >= 0xc0 ) {
1277                 switch ( (modm & 0x38) >> 3 )
1278                 {
1279                         case 2: // psrlq
1280                                 MMX(modm & 7).q = imm8 > 63 ? 0 : MMX(modm & 7).q >> imm8;
1281                                 break;
1282                         case 6: // psllq
1283                                 MMX(modm & 7).q = imm8 > 63 ? 0 : MMX(modm & 7).q << imm8;
1284                                 break;
1285                         default:
1286                                 report_invalid_modrm( "mmx_group0f73", modm);
1287                 }
1288         }
1289 }
1290
1291  void I386_OPS_BASE::SSEOP(group_660f73)()  // Opcode 66 0f 73
1292 {
1293         UINT64 t0;
1294         UINT8 modm = FETCH();
1295         UINT8 imm8 = FETCH();
1296         if (modm >= 0xc0) {
1297                 switch ((modm & 0x38) >> 3)
1298                 {
1299                 case 2: // psrlq
1300                         XMM(modm & 7).q[0] = imm8 > 63 ? 0 : XMM(modm & 7).q[0] >> imm8;
1301                         XMM(modm & 7).q[1] = imm8 > 63 ? 0 : XMM(modm & 7).q[1] >> imm8;
1302                         break;
1303                 case 3: // psrldq
1304                         if (imm8 >= 16)
1305                         {
1306                                 XMM(modm & 7).q[0] = 0;
1307                                 XMM(modm & 7).q[1] = 0;
1308                         }
1309                         else if (imm8 >= 8)
1310                         {
1311                                 imm8 = (imm8 & 7) << 3;
1312                                 XMM(modm & 7).q[0] = XMM(modm & 7).q[1] >> imm8;
1313                                 XMM(modm & 7).q[1] = 0;
1314                         }
1315                         else if (imm8)
1316                         {
1317                                 t0 = XMM(modm & 7).q[0];
1318                                 imm8 = imm8 << 3;
1319                                 XMM(modm & 7).q[0] = (XMM(modm & 7).q[1] << (64 - imm8)) | (t0 >> imm8);
1320                                 XMM(modm & 7).q[1] = t0 >> imm8;
1321                         }
1322                         break;
1323                 case 6: // psllq
1324                         XMM(modm & 7).q[0] = imm8 > 63 ? 0 : XMM(modm & 7).q[0] << imm8;
1325                         XMM(modm & 7).q[1] = imm8 > 63 ? 0 : XMM(modm & 7).q[1] << imm8;
1326                         break;
1327                 case 7: // pslldq
1328                         if (imm8 >= 16)
1329                         {
1330                                 XMM(modm & 7).q[0] = 0;
1331                                 XMM(modm & 7).q[1] = 0;
1332                         }
1333                         else if (imm8 >= 8)
1334                         {
1335                                 imm8 = (imm8 & 7) << 3;
1336                                 XMM(modm & 7).q[1] = XMM(modm & 7).q[0] << imm8;
1337                                 XMM(modm & 7).q[0] = 0;
1338                         }
1339                         else if (imm8)
1340                         {
1341                                 imm8 = imm8 << 3;
1342                                 XMM(modm & 7).q[1] = (XMM(modm & 7).q[0] >> (64 - imm8)) | (XMM(modm & 7).q[1] << imm8);
1343                                 XMM(modm & 7).q[0] = XMM(modm & 7).q[0] << imm8;
1344                         }
1345                         break;
1346                 default:
1347                         report_invalid_modrm( "sse_group660f73", modm);
1348                 }
1349         }
1350 }
1351
1352  void I386_OPS_BASE::MMXOP(psrlw_r64_rm64)()  // Opcode 0f d1
1353 {
1354         MMXPROLOG();
1355         UINT8 modrm = FETCH();
1356         if( modrm >= 0xc0 ) {
1357                 int count=(int)MMX(modrm & 7).q;
1358                 MMX((modrm >> 3) & 0x7).w[0]=MMX((modrm >> 3) & 0x7).w[0] >> count;
1359                 MMX((modrm >> 3) & 0x7).w[1]=MMX((modrm >> 3) & 0x7).w[1] >> count;
1360                 MMX((modrm >> 3) & 0x7).w[2]=MMX((modrm >> 3) & 0x7).w[2] >> count;
1361                 MMX((modrm >> 3) & 0x7).w[3]=MMX((modrm >> 3) & 0x7).w[3] >> count;
1362         } else {
1363                 MMX_REG src;
1364                 UINT32 ea = GetEA(modrm, 0, 8);
1365                 READMMX( ea, src);
1366                 int count=(int)src.q;
1367                 MMX((modrm >> 3) & 0x7).w[0]=MMX((modrm >> 3) & 0x7).w[0] >> count;
1368                 MMX((modrm >> 3) & 0x7).w[1]=MMX((modrm >> 3) & 0x7).w[1] >> count;
1369                 MMX((modrm >> 3) & 0x7).w[2]=MMX((modrm >> 3) & 0x7).w[2] >> count;
1370                 MMX((modrm >> 3) & 0x7).w[3]=MMX((modrm >> 3) & 0x7).w[3] >> count;
1371         }
1372         CYCLES(1);     // TODO: correct cycle count
1373 }
1374
1375  void I386_OPS_BASE::MMXOP(psrld_r64_rm64)()  // Opcode 0f d2
1376 {
1377         MMXPROLOG();
1378         UINT8 modrm = FETCH();
1379         if( modrm >= 0xc0 ) {
1380                 int count=(int)MMX(modrm & 7).q;
1381                 MMX((modrm >> 3) & 0x7).d[0]=MMX((modrm >> 3) & 0x7).d[0] >> count;
1382                 MMX((modrm >> 3) & 0x7).d[1]=MMX((modrm >> 3) & 0x7).d[1] >> count;
1383         } else {
1384                 MMX_REG src;
1385                 UINT32 ea = GetEA(modrm, 0, 8);
1386                 READMMX( ea, src);
1387                 int count=(int)src.q;
1388                 MMX((modrm >> 3) & 0x7).d[0]=MMX((modrm >> 3) & 0x7).d[0] >> count;
1389                 MMX((modrm >> 3) & 0x7).d[1]=MMX((modrm >> 3) & 0x7).d[1] >> count;
1390         }
1391         CYCLES(1);     // TODO: correct cycle count
1392 }
1393
1394  void I386_OPS_BASE::MMXOP(psrlq_r64_rm64)()  // Opcode 0f d3
1395 {
1396         MMXPROLOG();
1397         UINT8 modrm = FETCH();
1398         if( modrm >= 0xc0 ) {
1399                 int count=(int)MMX(modrm & 7).q;
1400                 MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q >> count;
1401         } else {
1402                 MMX_REG src;
1403                 UINT32 ea = GetEA(modrm, 0, 8);
1404                 READMMX( ea, src);
1405                 int count=(int)src.q;
1406                 MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q >> count;
1407         }
1408         CYCLES(1);     // TODO: correct cycle count
1409 }
1410
1411  void I386_OPS_BASE::MMXOP(paddq_r64_rm64)()  // Opcode 0f d4
1412 {
1413         MMXPROLOG();
1414         UINT8 modrm = FETCH();
1415         if( modrm >= 0xc0 ) {
1416                 MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q+MMX(modrm & 7).q;
1417         } else {
1418                 MMX_REG src;
1419                 UINT32 ea = GetEA(modrm, 0, 8);
1420                 READMMX( ea, src);
1421                 MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q+src.q;
1422         }
1423         CYCLES(1);     // TODO: correct cycle count
1424 }
1425
1426  void I386_OPS_BASE::MMXOP(pmullw_r64_rm64)()  // Opcode 0f d5
1427 {
1428         MMXPROLOG();
1429         UINT8 modrm = FETCH();
1430         if( modrm >= 0xc0 ) {
1431                 MMX((modrm >> 3) & 0x7).w[0]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[0]*(INT32)MMX(modrm & 7).s[0]) & 0xffff;
1432                 MMX((modrm >> 3) & 0x7).w[1]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[1]*(INT32)MMX(modrm & 7).s[1]) & 0xffff;
1433                 MMX((modrm >> 3) & 0x7).w[2]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[2]*(INT32)MMX(modrm & 7).s[2]) & 0xffff;
1434                 MMX((modrm >> 3) & 0x7).w[3]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[3]*(INT32)MMX(modrm & 7).s[3]) & 0xffff;
1435         } else {
1436                 MMX_REG src;
1437                 UINT32 ea = GetEA(modrm, 0, 8);
1438                 READMMX( ea, src);
1439                 MMX((modrm >> 3) & 0x7).w[0]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[0]*(INT32)src.s[0]) & 0xffff;
1440                 MMX((modrm >> 3) & 0x7).w[1]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[1]*(INT32)src.s[1]) & 0xffff;
1441                 MMX((modrm >> 3) & 0x7).w[2]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[2]*(INT32)src.s[2]) & 0xffff;
1442                 MMX((modrm >> 3) & 0x7).w[3]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[3]*(INT32)src.s[3]) & 0xffff;
1443         }
1444         CYCLES(1);     // TODO: correct cycle count
1445 }
1446
1447  void I386_OPS_BASE::MMXOP(psubusb_r64_rm64)()  // Opcode 0f d8
1448 {
1449         int n;
1450         MMXPROLOG();
1451         UINT8 modrm = FETCH();
1452         if( modrm >= 0xc0 ) {
1453                 for (n=0;n < 8;n++)
1454                         MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] < MMX(modrm & 7).b[n] ? 0 : MMX((modrm >> 3) & 0x7).b[n]-MMX(modrm & 7).b[n];
1455         } else {
1456                 MMX_REG src;
1457                 UINT32 ea = GetEA(modrm, 0, 8);
1458                 READMMX( ea, src);
1459                 for (n=0;n < 8;n++)
1460                         MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] < src.b[n] ? 0 : MMX((modrm >> 3) & 0x7).b[n]-src.b[n];
1461         }
1462         CYCLES(1);     // TODO: correct cycle count
1463 }
1464
1465  void I386_OPS_BASE::MMXOP(psubusw_r64_rm64)()  // Opcode 0f d9
1466 {
1467         int n;
1468         MMXPROLOG();
1469         UINT8 modrm = FETCH();
1470         if( modrm >= 0xc0 ) {
1471                 for (n=0;n < 4;n++)
1472                         MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] < MMX(modrm & 7).w[n] ? 0 : MMX((modrm >> 3) & 0x7).w[n]-MMX(modrm & 7).w[n];
1473         } else {
1474                 MMX_REG src;
1475                 UINT32 ea = GetEA(modrm, 0, 8);
1476                 READMMX( ea, src);
1477                 for (n=0;n < 4;n++)
1478                         MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] < src.w[n] ? 0 : MMX((modrm >> 3) & 0x7).w[n]-src.w[n];
1479         }
1480         CYCLES(1);     // TODO: correct cycle count
1481 }
1482
1483  void I386_OPS_BASE::MMXOP(pand_r64_rm64)()  // Opcode 0f db
1484 {
1485         MMXPROLOG();
1486         UINT8 modrm = FETCH();
1487         if( modrm >= 0xc0 ) {
1488                 MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q & MMX(modrm & 7).q;
1489         } else {
1490                 MMX_REG src;
1491                 UINT32 ea = GetEA(modrm, 0, 8);
1492                 READMMX( ea, src);
1493                 MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q & src.q;
1494         }
1495         CYCLES(1);     // TODO: correct cycle count
1496 }
1497
1498  void I386_OPS_BASE::MMXOP(paddusb_r64_rm64)()  // Opcode 0f dc
1499 {
1500         int n;
1501         MMXPROLOG();
1502         UINT8 modrm = FETCH();
1503         if( modrm >= 0xc0 ) {
1504                 for (n=0;n < 8;n++)
1505                         MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] > (0xff-MMX(modrm & 7).b[n]) ? 0xff : MMX((modrm >> 3) & 0x7).b[n]+MMX(modrm & 7).b[n];
1506         } else {
1507                 MMX_REG src;
1508                 UINT32 ea = GetEA(modrm, 0, 8);
1509                 READMMX( ea, src);
1510                 for (n=0;n < 8;n++)
1511                         MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] > (0xff-src.b[n]) ? 0xff : MMX((modrm >> 3) & 0x7).b[n]+src.b[n];
1512         }
1513         CYCLES(1);     // TODO: correct cycle count
1514 }
1515
1516  void I386_OPS_BASE::MMXOP(paddusw_r64_rm64)()  // Opcode 0f dd
1517 {
1518         int n;
1519         MMXPROLOG();
1520         UINT8 modrm = FETCH();
1521         if( modrm >= 0xc0 ) {
1522                 for (n=0;n < 4;n++)
1523                         MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] > (0xffff-MMX(modrm & 7).w[n]) ? 0xffff : MMX((modrm >> 3) & 0x7).w[n]+MMX(modrm & 7).w[n];
1524         } else {
1525                 MMX_REG src;
1526                 UINT32 ea = GetEA(modrm, 0, 8);
1527                 READMMX( ea, src);
1528                 for (n=0;n < 4;n++)
1529                         MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] > (0xffff-src.w[n]) ? 0xffff : MMX((modrm >> 3) & 0x7).w[n]+src.w[n];
1530         }
1531         CYCLES(1);     // TODO: correct cycle count
1532 }
1533
1534  void I386_OPS_BASE::MMXOP(pandn_r64_rm64)()  // Opcode 0f df
1535 {
1536         MMXPROLOG();
1537         UINT8 modrm = FETCH();
1538         if( modrm >= 0xc0 ) {
1539                 MMX((modrm >> 3) & 0x7).q=(~MMX((modrm >> 3) & 0x7).q) & MMX(modrm & 7).q;
1540         } else {
1541                 MMX_REG src;
1542                 UINT32 ea = GetEA(modrm, 0, 8);
1543                 READMMX( ea, src);
1544                 MMX((modrm >> 3) & 0x7).q=(~MMX((modrm >> 3) & 0x7).q) & src.q;
1545         }
1546         CYCLES(1);     // TODO: correct cycle count
1547 }
1548
1549  void I386_OPS_BASE::MMXOP(psraw_r64_rm64)()  // Opcode 0f e1
1550 {
1551         MMXPROLOG();
1552         UINT8 modrm = FETCH();
1553         if( modrm >= 0xc0 ) {
1554                 int count=(int)MMX(modrm & 7).q;
1555                 MMX((modrm >> 3) & 0x7).s[0]=MMX((modrm >> 3) & 0x7).s[0] >> count;
1556                 MMX((modrm >> 3) & 0x7).s[1]=MMX((modrm >> 3) & 0x7).s[1] >> count;
1557                 MMX((modrm >> 3) & 0x7).s[2]=MMX((modrm >> 3) & 0x7).s[2] >> count;
1558                 MMX((modrm >> 3) & 0x7).s[3]=MMX((modrm >> 3) & 0x7).s[3] >> count;
1559         } else {
1560                 MMX_REG src;
1561                 UINT32 ea = GetEA(modrm, 0, 8);
1562                 READMMX( ea, src);
1563                 int count=(int)src.q;
1564                 MMX((modrm >> 3) & 0x7).s[0]=MMX((modrm >> 3) & 0x7).s[0] >> count;
1565                 MMX((modrm >> 3) & 0x7).s[1]=MMX((modrm >> 3) & 0x7).s[1] >> count;
1566                 MMX((modrm >> 3) & 0x7).s[2]=MMX((modrm >> 3) & 0x7).s[2] >> count;
1567                 MMX((modrm >> 3) & 0x7).s[3]=MMX((modrm >> 3) & 0x7).s[3] >> count;
1568         }
1569         CYCLES(1);     // TODO: correct cycle count
1570 }
1571
1572  void I386_OPS_BASE::MMXOP(psrad_r64_rm64)()  // Opcode 0f e2
1573 {
1574         MMXPROLOG();
1575         UINT8 modrm = FETCH();
1576         if( modrm >= 0xc0 ) {
1577                 int count=(int)MMX(modrm & 7).q;
1578                 MMX((modrm >> 3) & 0x7).i[0]=MMX((modrm >> 3) & 0x7).i[0] >> count;
1579                 MMX((modrm >> 3) & 0x7).i[1]=MMX((modrm >> 3) & 0x7).i[1] >> count;
1580         } else {
1581                 MMX_REG src;
1582                 UINT32 ea = GetEA(modrm, 0, 8);
1583                 READMMX( ea, src);
1584                 int count=(int)src.q;
1585                 MMX((modrm >> 3) & 0x7).i[0]=MMX((modrm >> 3) & 0x7).i[0] >> count;
1586                 MMX((modrm >> 3) & 0x7).i[1]=MMX((modrm >> 3) & 0x7).i[1] >> count;
1587         }
1588         CYCLES(1);     // TODO: correct cycle count
1589 }
1590
1591  void I386_OPS_BASE::MMXOP(pmulhw_r64_rm64)()  // Opcode 0f e5
1592 {
1593         MMXPROLOG();
1594         UINT8 modrm = FETCH();
1595         if( modrm >= 0xc0 ) {
1596                 MMX((modrm >> 3) & 0x7).w[0]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[0]*(INT32)MMX(modrm & 7).s[0]) >> 16;
1597                 MMX((modrm >> 3) & 0x7).w[1]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[1]*(INT32)MMX(modrm & 7).s[1]) >> 16;
1598                 MMX((modrm >> 3) & 0x7).w[2]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[2]*(INT32)MMX(modrm & 7).s[2]) >> 16;
1599                 MMX((modrm >> 3) & 0x7).w[3]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[3]*(INT32)MMX(modrm & 7).s[3]) >> 16;
1600         } else {
1601                 MMX_REG src;
1602                 UINT32 ea = GetEA(modrm, 0, 8);
1603                 READMMX( ea, src);
1604                 MMX((modrm >> 3) & 0x7).w[0]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[0]*(INT32)src.s[0]) >> 16;
1605                 MMX((modrm >> 3) & 0x7).w[1]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[1]*(INT32)src.s[1]) >> 16;
1606                 MMX((modrm >> 3) & 0x7).w[2]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[2]*(INT32)src.s[2]) >> 16;
1607                 MMX((modrm >> 3) & 0x7).w[3]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[3]*(INT32)src.s[3]) >> 16;
1608         }
1609         CYCLES(1);     // TODO: correct cycle count
1610 }
1611
1612  void I386_OPS_BASE::MMXOP(psubsb_r64_rm64)()  // Opcode 0f e8
1613 {
1614         int n;
1615         MMXPROLOG();
1616         UINT8 modrm = FETCH();
1617         if( modrm >= 0xc0 ) {
1618                 for (n=0;n < 8;n++)
1619                         MMX((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)MMX((modrm >> 3) & 0x7).c[n] - (INT16)MMX(modrm & 7).c[n]);
1620         } else {
1621                 MMX_REG s;
1622                 UINT32 ea = GetEA(modrm, 0, 8);
1623                 READMMX( ea, s);
1624                 for (n=0;n < 8;n++)
1625                         MMX((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)MMX((modrm >> 3) & 0x7).c[n] - (INT16)s.c[n]);
1626         }
1627         CYCLES(1);     // TODO: correct cycle count
1628 }
1629
1630  void I386_OPS_BASE::MMXOP(psubsw_r64_rm64)()  // Opcode 0f e9
1631 {
1632         int n;
1633         MMXPROLOG();
1634         UINT8 modrm = FETCH();
1635         if( modrm >= 0xc0 ) {
1636                 for (n=0;n < 4;n++)
1637                         MMX((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)MMX((modrm >> 3) & 0x7).s[n] - (INT32)MMX(modrm & 7).s[n]);
1638         } else {
1639                 MMX_REG s;
1640                 UINT32 ea = GetEA(modrm, 0, 8);
1641                 READMMX( ea, s);
1642                 for (n=0;n < 4;n++)
1643                         MMX((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)MMX((modrm >> 3) & 0x7).s[n] - (INT32)s.s[n]);
1644         }
1645         CYCLES(1);     // TODO: correct cycle count
1646 }
1647
1648  void I386_OPS_BASE::MMXOP(por_r64_rm64)()  // Opcode 0f eb
1649 {
1650         MMXPROLOG();
1651         UINT8 modrm = FETCH();
1652         if( modrm >= 0xc0 ) {
1653                 MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q | MMX(modrm & 7).q;
1654         } else {
1655                 MMX_REG s;
1656                 UINT32 ea = GetEA(modrm, 0, 8);
1657                 READMMX( ea, s);
1658                 MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q | s.q;
1659         }
1660         CYCLES(1);     // TODO: correct cycle count
1661 }
1662
1663  void I386_OPS_BASE::MMXOP(paddsb_r64_rm64)()  // Opcode 0f ec
1664 {
1665         int n;
1666         MMXPROLOG();
1667         UINT8 modrm = FETCH();
1668         if( modrm >= 0xc0 ) {
1669                 for (n=0;n < 8;n++)
1670                         MMX((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)MMX((modrm >> 3) & 0x7).c[n] + (INT16)MMX(modrm & 7).c[n]);
1671         } else {
1672                 MMX_REG s;
1673                 UINT32 ea = GetEA(modrm, 0, 8);
1674                 READMMX( ea, s);
1675                 for (n=0;n < 8;n++)
1676                         MMX((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)MMX((modrm >> 3) & 0x7).c[n] + (INT16)s.c[n]);
1677         }
1678         CYCLES(1);     // TODO: correct cycle count
1679 }
1680
1681  void I386_OPS_BASE::MMXOP(paddsw_r64_rm64)()  // Opcode 0f ed
1682 {
1683         int n;
1684         MMXPROLOG();
1685         UINT8 modrm = FETCH();
1686         if( modrm >= 0xc0 ) {
1687                 for (n=0;n < 4;n++)
1688                         MMX((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)MMX((modrm >> 3) & 0x7).s[n] + (INT32)MMX(modrm & 7).s[n]);
1689         } else {
1690                 MMX_REG s;
1691                 UINT32 ea = GetEA(modrm, 0, 8);
1692                 READMMX( ea, s);
1693                 for (n=0;n < 4;n++)
1694                         MMX((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)MMX((modrm >> 3) & 0x7).s[n] + (INT32)s.s[n]);
1695         }
1696         CYCLES(1);     // TODO: correct cycle count
1697 }
1698
1699  void I386_OPS_BASE::MMXOP(pxor_r64_rm64)()  // Opcode 0f ef
1700 {
1701         MMXPROLOG();
1702         UINT8 modrm = FETCH();
1703         if( modrm >= 0xc0 ) {
1704                 MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q ^ MMX(modrm & 7).q;
1705         } else {
1706                 MMX_REG s;
1707                 UINT32 ea = GetEA(modrm, 0, 8);
1708                 READMMX( ea, s);
1709                 MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q ^ s.q;
1710         }
1711         CYCLES(1);     // TODO: correct cycle count
1712 }
1713
1714  void I386_OPS_BASE::MMXOP(psllw_r64_rm64)()  // Opcode 0f f1
1715 {
1716         MMXPROLOG();
1717         UINT8 modrm = FETCH();
1718         if( modrm >= 0xc0 ) {
1719                 int count=(int)MMX(modrm & 7).q;
1720                 MMX((modrm >> 3) & 0x7).w[0]=MMX((modrm >> 3) & 0x7).w[0] << count;
1721                 MMX((modrm >> 3) & 0x7).w[1]=MMX((modrm >> 3) & 0x7).w[1] << count;
1722                 MMX((modrm >> 3) & 0x7).w[2]=MMX((modrm >> 3) & 0x7).w[2] << count;
1723                 MMX((modrm >> 3) & 0x7).w[3]=MMX((modrm >> 3) & 0x7).w[3] << count;
1724         } else {
1725                 MMX_REG s;
1726                 UINT32 ea = GetEA(modrm, 0, 8);
1727                 READMMX( ea, s);
1728                 int count=(int)s.q;
1729                 MMX((modrm >> 3) & 0x7).w[0]=MMX((modrm >> 3) & 0x7).w[0] << count;
1730                 MMX((modrm >> 3) & 0x7).w[1]=MMX((modrm >> 3) & 0x7).w[1] << count;
1731                 MMX((modrm >> 3) & 0x7).w[2]=MMX((modrm >> 3) & 0x7).w[2] << count;
1732                 MMX((modrm >> 3) & 0x7).w[3]=MMX((modrm >> 3) & 0x7).w[3] << count;
1733         }
1734         CYCLES(1);     // TODO: correct cycle count
1735 }
1736
1737  void I386_OPS_BASE::MMXOP(pslld_r64_rm64)()  // Opcode 0f f2
1738 {
1739         MMXPROLOG();
1740         UINT8 modrm = FETCH();
1741         if( modrm >= 0xc0 ) {
1742                 int count=(int)MMX(modrm & 7).q;
1743                 MMX((modrm >> 3) & 0x7).d[0]=MMX((modrm >> 3) & 0x7).d[0] << count;
1744                 MMX((modrm >> 3) & 0x7).d[1]=MMX((modrm >> 3) & 0x7).d[1] << count;
1745         } else {
1746                 MMX_REG s;
1747                 UINT32 ea = GetEA(modrm, 0, 8);
1748                 READMMX( ea, s);
1749                 int count=(int)s.q;
1750                 MMX((modrm >> 3) & 0x7).d[0]=MMX((modrm >> 3) & 0x7).d[0] << count;
1751                 MMX((modrm >> 3) & 0x7).d[1]=MMX((modrm >> 3) & 0x7).d[1] << count;
1752         }
1753         CYCLES(1);     // TODO: correct cycle count
1754 }
1755
1756  void I386_OPS_BASE::MMXOP(psllq_r64_rm64)()  // Opcode 0f f3
1757 {
1758         MMXPROLOG();
1759         UINT8 modrm = FETCH();
1760         if( modrm >= 0xc0 ) {
1761                 int count=(int)MMX(modrm & 7).q;
1762                 MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q << count;
1763         } else {
1764                 MMX_REG s;
1765                 UINT32 ea = GetEA(modrm, 0, 8);
1766                 READMMX( ea, s);
1767                 int count=(int)s.q;
1768                 MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q << count;
1769         }
1770         CYCLES(1);     // TODO: correct cycle count
1771 }
1772
1773  void I386_OPS_BASE::MMXOP(pmaddwd_r64_rm64)()  // Opcode 0f f5
1774 {
1775         MMXPROLOG();
1776         UINT8 modrm = FETCH();
1777         if( modrm >= 0xc0 ) {
1778                 MMX((modrm >> 3) & 0x7).i[0]=(INT32)MMX((modrm >> 3) & 0x7).s[0]*(INT32)MMX(modrm & 7).s[0]+
1779                                                                                 (INT32)MMX((modrm >> 3) & 0x7).s[1]*(INT32)MMX(modrm & 7).s[1];
1780                 MMX((modrm >> 3) & 0x7).i[1]=(INT32)MMX((modrm >> 3) & 0x7).s[2]*(INT32)MMX(modrm & 7).s[2]+
1781                                                                                 (INT32)MMX((modrm >> 3) & 0x7).s[3]*(INT32)MMX(modrm & 7).s[3];
1782         } else {
1783                 MMX_REG s;
1784                 UINT32 ea = GetEA(modrm, 0, 8);
1785                 READMMX( ea, s);
1786                 MMX((modrm >> 3) & 0x7).i[0]=(INT32)MMX((modrm >> 3) & 0x7).s[0]*(INT32)s.s[0]+
1787                                                                                 (INT32)MMX((modrm >> 3) & 0x7).s[1]*(INT32)s.s[1];
1788                 MMX((modrm >> 3) & 0x7).i[1]=(INT32)MMX((modrm >> 3) & 0x7).s[2]*(INT32)s.s[2]+
1789                                                                                 (INT32)MMX((modrm >> 3) & 0x7).s[3]*(INT32)s.s[3];
1790         }
1791         CYCLES(1);     // TODO: correct cycle count
1792 }
1793
1794  void I386_OPS_BASE::MMXOP(psubb_r64_rm64)()  // Opcode 0f f8
1795 {
1796         int n;
1797         MMXPROLOG();
1798         UINT8 modrm = FETCH();
1799         if( modrm >= 0xc0 ) {
1800                 for (n=0;n < 8;n++)
1801                         MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] - MMX(modrm & 7).b[n];
1802         } else {
1803                 MMX_REG s;
1804                 UINT32 ea = GetEA(modrm, 0, 8);
1805                 READMMX( ea, s);
1806                 for (n=0;n < 8;n++)
1807                         MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] - s.b[n];
1808         }
1809         CYCLES(1);     // TODO: correct cycle count
1810 }
1811
1812  void I386_OPS_BASE::MMXOP(psubw_r64_rm64)()  // Opcode 0f f9
1813 {
1814         int n;
1815         MMXPROLOG();
1816         UINT8 modrm = FETCH();
1817         if( modrm >= 0xc0 ) {
1818                 for (n=0;n < 4;n++)
1819                         MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] - MMX(modrm & 7).w[n];
1820         } else {
1821                 MMX_REG s;
1822                 UINT32 ea = GetEA(modrm, 0, 8);
1823                 READMMX( ea, s);
1824                 for (n=0;n < 4;n++)
1825                         MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] - s.w[n];
1826         }
1827         CYCLES(1);     // TODO: correct cycle count
1828 }
1829
1830  void I386_OPS_BASE::MMXOP(psubd_r64_rm64)()  // Opcode 0f fa
1831 {
1832         int n;
1833         MMXPROLOG();
1834         UINT8 modrm = FETCH();
1835         if( modrm >= 0xc0 ) {
1836                 for (n=0;n < 2;n++)
1837                         MMX((modrm >> 3) & 0x7).d[n]=MMX((modrm >> 3) & 0x7).d[n] - MMX(modrm & 7).d[n];
1838         } else {
1839                 MMX_REG s;
1840                 UINT32 ea = GetEA(modrm, 0, 8);
1841                 READMMX( ea, s);
1842                 for (n=0;n < 2;n++)
1843                         MMX((modrm >> 3) & 0x7).d[n]=MMX((modrm >> 3) & 0x7).d[n] - s.d[n];
1844         }
1845         CYCLES(1);     // TODO: correct cycle count
1846 }
1847
1848  void I386_OPS_BASE::MMXOP(paddb_r64_rm64)()  // Opcode 0f fc
1849 {
1850         int n;
1851         MMXPROLOG();
1852         UINT8 modrm = FETCH();
1853         if( modrm >= 0xc0 ) {
1854                 for (n=0;n < 8;n++)
1855                         MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] + MMX(modrm & 7).b[n];
1856         } else {
1857                 MMX_REG s;
1858                 UINT32 ea = GetEA(modrm, 0, 8);
1859                 READMMX( ea, s);
1860                 for (n=0;n < 8;n++)
1861                         MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] + s.b[n];
1862         }
1863         CYCLES(1);     // TODO: correct cycle count
1864 }
1865
1866  void I386_OPS_BASE::MMXOP(paddw_r64_rm64)()  // Opcode 0f fd
1867 {
1868         int n;
1869         MMXPROLOG();
1870         UINT8 modrm = FETCH();
1871         if( modrm >= 0xc0 ) {
1872                 for (n=0;n < 4;n++)
1873                         MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] + MMX(modrm & 7).w[n];
1874         } else {
1875                 MMX_REG s;
1876                 UINT32 ea = GetEA(modrm, 0, 8);
1877                 READMMX( ea, s);
1878                 for (n=0;n < 4;n++)
1879                         MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] + s.w[n];
1880         }
1881         CYCLES(1);     // TODO: correct cycle count
1882 }
1883
1884  void I386_OPS_BASE::MMXOP(paddd_r64_rm64)()  // Opcode 0f fe
1885 {
1886         int n;
1887         MMXPROLOG();
1888         UINT8 modrm = FETCH();
1889         if( modrm >= 0xc0 ) {
1890                 for (n=0;n < 2;n++)
1891                         MMX((modrm >> 3) & 0x7).d[n]=MMX((modrm >> 3) & 0x7).d[n] + MMX(modrm & 7).d[n];
1892         } else {
1893                 MMX_REG s;
1894                 UINT32 ea = GetEA(modrm, 0, 8);
1895                 READMMX( ea, s);
1896                 for (n=0;n < 2;n++)
1897                         MMX((modrm >> 3) & 0x7).d[n]=MMX((modrm >> 3) & 0x7).d[n] + s.d[n];
1898         }
1899         CYCLES(1);     // TODO: correct cycle count
1900 }
1901
1902  void I386_OPS_BASE::MMXOP(emms)() // Opcode 0f 77
1903 {
1904         cpustate->x87_tw = 0xffff; // tag word = 0xffff
1905         // TODO
1906         CYCLES(1);     // TODO: correct cycle count
1907 }
1908
1909  void I386_OPS_BASE::I386OP(cyrix_svdc)() // Opcode 0f 78
1910 {
1911         UINT8 modrm = FETCH();
1912
1913         if( modrm < 0xc0 ) {
1914                 UINT32 ea = GetEA(modrm, 0, 10);
1915                 int index = (modrm >> 3) & 7;
1916                 int limit;
1917                 switch (index)
1918                 {
1919                         case 0:
1920                         {
1921                                 index = ES;
1922                                 break;
1923                         }
1924
1925                         case 2:
1926                         {
1927                                 index = SS;
1928                                 break;
1929                         }
1930
1931                         case 3:
1932                         {
1933                                 index = DS;
1934                                 break;
1935                         }
1936
1937                         case 4:
1938                         {
1939                                 index = FS;
1940                                 break;
1941                         }
1942
1943                         case 5:
1944                         {
1945                                 index = GS;
1946                                 break;
1947                         }
1948
1949                         default:
1950                         {
1951                                 i386_trap( 6, 0, 0);
1952                         }
1953                 }
1954
1955                 limit = cpustate->sreg[index].limit;
1956
1957                 if (cpustate->sreg[index].flags & 0x8000) //G bit
1958                 {
1959                         limit >>= 12;
1960                 }
1961
1962                 WRITE16(ea + 0, limit);
1963                 WRITE32(ea + 2, cpustate->sreg[index].base);
1964                 WRITE16(ea + 5, cpustate->sreg[index].flags); //replace top 8 bits of base
1965                 WRITE8(ea + 7, cpustate->sreg[index].base >> 24);
1966                 WRITE16(ea + 8, cpustate->sreg[index].selector);
1967         } else {
1968                 i386_trap( 6, 0, 0);
1969         }
1970         CYCLES(1);     // TODO: correct cycle count
1971 }
1972
1973  void I386_OPS_BASE::I386OP(cyrix_rsdc)() // Opcode 0f 79
1974 {
1975         UINT8 modrm = FETCH();
1976
1977         if( modrm < 0xc0 ) {
1978                 UINT32 ea = GetEA(modrm, 0, 10);
1979                 int index = (modrm >> 3) & 7;
1980                 UINT16 flags;
1981                 UINT32 base;
1982                 UINT32 limit;
1983                 switch (index)
1984                 {
1985                         case 0:
1986                         {
1987                                 index = ES;
1988                                 break;
1989                         }
1990
1991                         case 2:
1992                         {
1993                                 index = SS;
1994                                 break;
1995                         }
1996
1997                         case 3:
1998                         {
1999                                 index = DS;
2000                                 break;
2001                         }
2002
2003                         case 4:
2004                         {
2005                                 index = FS;
2006                                 break;
2007                         }
2008
2009                         case 5:
2010                         {
2011                                 index = GS;
2012                                 break;
2013                         }
2014
2015                         default:
2016                         {
2017                                 i386_trap( 6, 0, 0);
2018                         }
2019                 }
2020
2021                 base = (READ32(ea + 2) & 0x00ffffff) | (READ8(ea + 7) << 24);
2022                 flags = READ16(ea + 5);
2023                 limit = READ16(ea + 0) | ((flags & 3) << 16);
2024
2025                 if (flags & 0x8000) //G bit
2026                 {
2027                         limit = (limit << 12) | 0xfff;
2028                 }
2029
2030                 cpustate->sreg[index].selector = READ16(ea + 8);
2031                 cpustate->sreg[index].flags = flags;
2032                 cpustate->sreg[index].base = base;
2033                 cpustate->sreg[index].limit = limit;
2034         } else {
2035                 i386_trap( 6, 0, 0);
2036         }
2037         CYCLES(1);     // TODO: correct cycle count
2038 }
2039
2040  void I386_OPS_BASE::I386OP(cyrix_svldt)() // Opcode 0f 7a
2041 {
2042         if ( PROTECTED_MODE && !V8086_MODE )
2043         {
2044                 UINT8 modrm = FETCH();
2045
2046                 if( !(modrm & 0xf8) ) {
2047                         UINT32 ea = GetEA(modrm, 0, 10);
2048                         UINT32 limit = cpustate->ldtr.limit;
2049
2050                         if (cpustate->ldtr.flags & 0x8000) //G bit
2051                         {
2052                                 limit >>= 12;
2053                         }
2054
2055                         WRITE16(ea + 0, limit);
2056                         WRITE32(ea + 2, cpustate->ldtr.base);
2057                         WRITE16(ea + 5, cpustate->ldtr.flags); //replace top 8 bits of base
2058                         WRITE8(ea + 7, cpustate->ldtr.base >> 24);
2059                         WRITE16(ea + 8, cpustate->ldtr.segment);
2060                 } else {
2061                         i386_trap( 6, 0, 0);
2062                 }
2063         } else {
2064                 i386_trap( 6, 0, 0);
2065         }
2066         CYCLES(1);     // TODO: correct cycle count
2067 }
2068
2069  void I386_OPS_BASE::I386OP(cyrix_rsldt)() // Opcode 0f 7b
2070 {
2071         if ( PROTECTED_MODE && !V8086_MODE )
2072         {
2073                 if(cpustate->CPL)
2074                         FAULT(FAULT_GP,0)
2075
2076                 UINT8 modrm = FETCH();
2077
2078                 if( !(modrm & 0xf8) ) {
2079                         UINT32 ea = GetEA(modrm, 0, 10);
2080                         UINT16 flags = READ16(ea + 5);
2081                         UINT32 base = (READ32(ea + 2) | 0x00ffffff) | (READ8(ea + 7) << 24);
2082                         UINT32 limit = READ16(ea + 0) | ((flags & 3) << 16);
2083                         I386_SREG seg;
2084
2085                         if (flags & 0x8000) //G bit
2086                         {
2087                                 limit = (limit << 12) | 0xfff;
2088                         }
2089
2090                         memset(&seg, 0, sizeof(seg));
2091                         seg.selector = READ16(ea + 8);
2092                         i386_load_protected_mode_segment(&seg,NULL);
2093                         cpustate->ldtr.limit = limit;
2094                         cpustate->ldtr.base = base;
2095                         cpustate->ldtr.flags = flags;
2096                 } else {
2097                         i386_trap( 6, 0, 0);
2098                 }
2099         } else {
2100                 i386_trap( 6, 0, 0);
2101         }
2102         CYCLES(1);     // TODO: correct cycle count
2103 }
2104
2105  void I386_OPS_BASE::I386OP(cyrix_svts)() // Opcode 0f 7c
2106 {
2107         if ( PROTECTED_MODE )
2108         {
2109                 UINT8 modrm = FETCH();
2110
2111                 if( !(modrm & 0xf8) ) {
2112                         UINT32 ea = GetEA(modrm, 0, 10);
2113                         UINT32 limit = cpustate->task.limit;
2114
2115                         if (cpustate->task.flags & 0x8000) //G bit
2116                         {
2117                                 limit >>= 12;
2118                         }
2119
2120                         WRITE16(ea + 0, limit);
2121                         WRITE32(ea + 2, cpustate->task.base);
2122                         WRITE16(ea + 5, cpustate->task.flags); //replace top 8 bits of base
2123                         WRITE8(ea + 7, cpustate->task.base >> 24);
2124                         WRITE16(ea + 8, cpustate->task.segment);
2125                 } else {
2126                         i386_trap( 6, 0, 0);
2127                 }
2128         } else {
2129                 i386_trap( 6, 0, 0);
2130         }
2131 }
2132
2133  void I386_OPS_BASE::I386OP(cyrix_rsts)() // Opcode 0f 7d
2134 {
2135         if ( PROTECTED_MODE )
2136         {
2137                 if(cpustate->CPL)
2138                         FAULT(FAULT_GP,0)
2139
2140                 UINT8 modrm = FETCH();
2141
2142                 if( !(modrm & 0xf8) ) {
2143                         UINT32 ea = GetEA(modrm, 0, 10);
2144                         UINT16 flags = READ16(ea + 5);
2145                         UINT32 base = (READ32(ea + 2) | 0x00ffffff) | (READ8(ea + 7) << 24);
2146                         UINT32 limit = READ16(ea + 0) | ((flags & 3) << 16);
2147
2148                         if (flags & 0x8000) //G bit
2149                         {
2150                                 limit = (limit << 12) | 0xfff;
2151                         }
2152                         cpustate->task.segment = READ16(ea + 8);
2153                         cpustate->task.limit = limit;
2154                         cpustate->task.base = base;
2155                         cpustate->task.flags = flags;
2156                 } else {
2157                         i386_trap( 6, 0, 0);
2158                 }
2159         } else {
2160                 i386_trap( 6, 0, 0);
2161         }
2162         CYCLES(1);     // TODO: correct cycle count
2163 }
2164
2165  void I386_OPS_BASE::MMXOP(movd_r64_rm32)() // Opcode 0f 6e
2166 {
2167         MMXPROLOG();
2168         UINT8 modrm = FETCH();
2169         if( modrm >= 0xc0 ) {
2170                 MMX((modrm >> 3) & 0x7).d[0]=LOAD_RM32(modrm);
2171         } else {
2172                 UINT32 ea = GetEA(modrm, 0, 4);
2173                 MMX((modrm >> 3) & 0x7).d[0]=READ32(ea);
2174         }
2175         MMX((modrm >> 3) & 0x7).d[1]=0;
2176         CYCLES(1);     // TODO: correct cycle count
2177 }
2178
2179  void I386_OPS_BASE::MMXOP(movq_r64_rm64)() // Opcode 0f 6f
2180 {
2181         MMXPROLOG();
2182         UINT8 modrm = FETCH();
2183         if( modrm >= 0xc0 ) {
2184                 MMX((modrm >> 3) & 0x7).l=MMX(modrm & 0x7).l;
2185         } else {
2186                 UINT32 ea = GetEA(modrm, 0, 8);
2187                 READMMX( ea, MMX((modrm >> 3) & 0x7));
2188         }
2189         CYCLES(1);     // TODO: correct cycle count
2190 }
2191
2192  void I386_OPS_BASE::MMXOP(movd_rm32_r64)() // Opcode 0f 7e
2193 {
2194         MMXPROLOG();
2195         UINT8 modrm = FETCH();
2196         if( modrm >= 0xc0 ) {
2197                 STORE_RM32(modrm, MMX((modrm >> 3) & 0x7).d[0]);
2198         } else {
2199                 UINT32 ea = GetEA(modrm, 0, 4);
2200                 WRITE32(ea, MMX((modrm >> 3) & 0x7).d[0]);
2201         }
2202         CYCLES(1);     // TODO: correct cycle count
2203 }
2204
2205  void I386_OPS_BASE::MMXOP(movq_rm64_r64)() // Opcode 0f 7f
2206 {
2207         MMXPROLOG();
2208         UINT8 modrm = FETCH();
2209         if( modrm >= 0xc0 ) {
2210                 MMX(modrm & 0x7)=MMX((modrm >> 3) & 0x7);
2211         } else {
2212                 UINT32 ea = GetEA(modrm, 0, 8);
2213                 WRITEMMX( ea, MMX((modrm >> 3) & 0x7));
2214         }
2215         CYCLES(1);     // TODO: correct cycle count
2216 }
2217
2218  void I386_OPS_BASE::MMXOP(pcmpeqb_r64_rm64)() // Opcode 0f 74
2219 {
2220         int c;
2221         MMXPROLOG();
2222         UINT8 modrm = FETCH();
2223         if( modrm >= 0xc0 ) {
2224                 int s,d;
2225                 s=modrm & 0x7;
2226                 d=(modrm >> 3) & 0x7;
2227                 for (c=0;c <= 7;c++)
2228                         MMX(d).b[c]=(MMX(d).b[c] == MMX(s).b[c]) ? 0xff : 0;
2229         } else {
2230                 MMX_REG s;
2231                 int d=(modrm >> 3) & 0x7;
2232                 UINT32 ea = GetEA(modrm, 0, 8);
2233                 READMMX( ea, s);
2234                 for (c=0;c <= 7;c++)
2235                         MMX(d).b[c]=(MMX(d).b[c] == s.b[c]) ? 0xff : 0;
2236         }
2237         CYCLES(1);     // TODO: correct cycle count
2238 }
2239
2240  void I386_OPS_BASE::MMXOP(pcmpeqw_r64_rm64)() // Opcode 0f 75
2241 {
2242         MMXPROLOG();
2243         UINT8 modrm = FETCH();
2244         if( modrm >= 0xc0 ) {
2245                 int s,d;
2246                 s=modrm & 0x7;
2247                 d=(modrm >> 3) & 0x7;
2248                 MMX(d).w[0]=(MMX(d).w[0] == MMX(s).w[0]) ? 0xffff : 0;
2249                 MMX(d).w[1]=(MMX(d).w[1] == MMX(s).w[1]) ? 0xffff : 0;
2250                 MMX(d).w[2]=(MMX(d).w[2] == MMX(s).w[2]) ? 0xffff : 0;
2251                 MMX(d).w[3]=(MMX(d).w[3] == MMX(s).w[3]) ? 0xffff : 0;
2252         } else {
2253                 MMX_REG s;
2254                 int d=(modrm >> 3) & 0x7;
2255                 UINT32 ea = GetEA(modrm, 0, 8);
2256                 READMMX( ea, s);
2257                 MMX(d).w[0]=(MMX(d).w[0] == s.w[0]) ? 0xffff : 0;
2258                 MMX(d).w[1]=(MMX(d).w[1] == s.w[1]) ? 0xffff : 0;
2259                 MMX(d).w[2]=(MMX(d).w[2] == s.w[2]) ? 0xffff : 0;
2260                 MMX(d).w[3]=(MMX(d).w[3] == s.w[3]) ? 0xffff : 0;
2261         }
2262         CYCLES(1);     // TODO: correct cycle count
2263 }
2264
2265  void I386_OPS_BASE::MMXOP(pcmpeqd_r64_rm64)() // Opcode 0f 76
2266 {
2267         MMXPROLOG();
2268         UINT8 modrm = FETCH();
2269         if( modrm >= 0xc0 ) {
2270                 int s,d;
2271                 s=modrm & 0x7;
2272                 d=(modrm >> 3) & 0x7;
2273                 MMX(d).d[0]=(MMX(d).d[0] == MMX(s).d[0]) ? 0xffffffff : 0;
2274                 MMX(d).d[1]=(MMX(d).d[1] == MMX(s).d[1]) ? 0xffffffff : 0;
2275         } else {
2276                 MMX_REG s;
2277                 int d=(modrm >> 3) & 0x7;
2278                 UINT32 ea = GetEA(modrm, 0, 8);
2279                 READMMX( ea, s);
2280                 MMX(d).d[0]=(MMX(d).d[0] == s.d[0]) ? 0xffffffff : 0;
2281                 MMX(d).d[1]=(MMX(d).d[1] == s.d[1]) ? 0xffffffff : 0;
2282         }
2283         CYCLES(1);     // TODO: correct cycle count
2284 }
2285
2286  void I386_OPS_BASE::MMXOP(pshufw_r64_rm64_i8)() // Opcode 0f 70
2287 {
2288         MMXPROLOG();
2289         UINT8 modrm = FETCH();
2290         if( modrm >= 0xc0 ) {
2291                 MMX_REG t;
2292                 int s,d;
2293                 UINT8 imm8 = FETCH();
2294                 s=modrm & 0x7;
2295                 d=(modrm >> 3) & 0x7;
2296                 t.q=MMX(s).q;
2297                 MMX(d).w[0]=t.w[imm8 & 3];
2298                 MMX(d).w[1]=t.w[(imm8 >> 2) & 3];
2299                 MMX(d).w[2]=t.w[(imm8 >> 4) & 3];
2300                 MMX(d).w[3]=t.w[(imm8 >> 6) & 3];
2301         } else {
2302                 MMX_REG s;
2303                 int d=(modrm >> 3) & 0x7;
2304                 UINT32 ea = GetEA(modrm, 0, 8);
2305                 UINT8 imm8 = FETCH();
2306                 READMMX( ea, s);
2307                 MMX(d).w[0]=s.w[imm8 & 3];
2308                 MMX(d).w[1]=s.w[(imm8 >> 2) & 3];
2309                 MMX(d).w[2]=s.w[(imm8 >> 4) & 3];
2310                 MMX(d).w[3]=s.w[(imm8 >> 6) & 3];
2311         }
2312         CYCLES(1);     // TODO: correct cycle count
2313 }
2314
2315  void I386_OPS_BASE::SSEOP(punpcklbw_r128_rm128)() // Opcode 66 0f 60
2316 {
2317         UINT8 modrm = FETCH();
2318         if (modrm >= 0xc0) {
2319                 XMM_REG xd,xs;
2320                 int s, d;
2321                 s = modrm & 0x7;
2322                 d = (modrm >> 3) & 0x7;
2323                 xd.l[0] = XMM(d).l[0];
2324                 xs.l[0] = XMM(s).l[0];
2325                 XMM(d).b[0] = xd.b[0];
2326                 XMM(d).b[1] = xs.b[0];
2327                 XMM(d).b[2] = xd.b[1];
2328                 XMM(d).b[3] = xs.b[1];
2329                 XMM(d).b[4] = xd.b[2];
2330                 XMM(d).b[5] = xs.b[2];
2331                 XMM(d).b[6] = xd.b[3];
2332                 XMM(d).b[7] = xs.b[3];
2333                 XMM(d).b[8] = xd.b[4];
2334                 XMM(d).b[9] = xs.b[4];
2335                 XMM(d).b[10] = xd.b[5];
2336                 XMM(d).b[11] = xs.b[5];
2337                 XMM(d).b[12] = xd.b[6];
2338                 XMM(d).b[13] = xs.b[6];
2339                 XMM(d).b[14] = xd.b[7];
2340                 XMM(d).b[15] = xs.b[7];
2341         }
2342         else {
2343                 XMM_REG xd, xs;
2344                 int d = (modrm >> 3) & 0x7;
2345                 UINT32 ea = GetEA(modrm, 0, 8);
2346                 xd.l[0] = XMM(d).l[0];
2347                 xs.q[0] = READ64( ea);
2348                 for (int n = 0; n < 8; n++) {
2349                         XMM(d).b[n << 1] = xd.b[n];
2350                         XMM(d).b[(n << 1) | 1] = xs.b[n];
2351                 }
2352         }
2353         CYCLES(1);     // TODO: correct cycle count
2354 }
2355
2356  void I386_OPS_BASE::SSEOP(punpcklwd_r128_rm128)()
2357 {
2358         UINT8 modrm = FETCH();
2359         if (modrm >= 0xc0) {
2360                 XMM_REG xd, xs;
2361                 int s, d;
2362                 s = modrm & 0x7;
2363                 d = (modrm >> 3) & 0x7;
2364                 xd.l[0] = XMM(d).l[0];
2365                 xs.l[0] = XMM(s).l[0];
2366                 for (int n = 0; n < 4; n++) {
2367                         XMM(d).w[n << 1] = xd.w[n];
2368                         XMM(d).w[(n << 1) | 1] = xs.w[n];
2369                 }
2370         }
2371         else {
2372                 XMM_REG xd, xs;
2373                 int d = (modrm >> 3) & 0x7;
2374                 UINT32 ea = GetEA(modrm, 0, 8);
2375                 xd.l[0] = XMM(d).l[0];
2376                 xs.q[0] = READ64( ea);
2377                 for (int n = 0; n < 4; n++) {
2378                         XMM(d).w[n << 1] = xd.w[n];
2379                         XMM(d).w[(n << 1) | 1] = xs.w[n];
2380                 }
2381         }
2382         CYCLES(1);     // TODO: correct cycle count
2383 }
2384
2385  void I386_OPS_BASE::SSEOP(punpckldq_r128_rm128)()
2386 {
2387         UINT8 modrm = FETCH();
2388         if (modrm >= 0xc0) {
2389                 XMM_REG xd, xs;
2390                 int s, d;
2391                 s = modrm & 0x7;
2392                 d = (modrm >> 3) & 0x7;
2393                 xd.l[0] = XMM(d).l[0];
2394                 xs.l[0] = XMM(s).l[0];
2395                 for (int n = 0; n < 2; n++) {
2396                         XMM(d).d[n << 1] = xd.d[n];
2397                         XMM(d).d[(n << 1) | 1] = xs.d[n];
2398                 }
2399         }
2400         else {
2401                 XMM_REG xd, xs;
2402                 int d = (modrm >> 3) & 0x7;
2403                 UINT32 ea = GetEA(modrm, 0, 8);
2404                 xd.l[0] = XMM(d).l[0];
2405                 xs.q[0] = READ64( ea);
2406                 for (int n = 0; n < 2; n++) {
2407                         XMM(d).d[n << 1] = xd.d[n];
2408                         XMM(d).d[(n << 1) | 1] = xs.d[n];
2409                 }
2410         }
2411         CYCLES(1);     // TODO: correct cycle count
2412 }
2413
2414  void I386_OPS_BASE::SSEOP(punpcklqdq_r128_rm128)()
2415 {
2416         UINT8 modrm = FETCH();
2417         if (modrm >= 0xc0) {
2418                 XMM_REG xd, xs;
2419                 int s, d;
2420                 s = modrm & 0x7;
2421                 d = (modrm >> 3) & 0x7;
2422                 xd.l[0] = XMM(d).l[0];
2423                 xs.l[0] = XMM(s).l[0];
2424                 XMM(d).q[0] = xd.q[0];
2425                 XMM(d).q[1] = xs.q[0];
2426         }
2427         else {
2428                 XMM_REG xd, xs;
2429                 int d = (modrm >> 3) & 0x7;
2430                 UINT32 ea = GetEA(modrm, 0, 8);
2431                 xd.l[0] = XMM(d).l[0];
2432                 xs.q[0] = READ64( ea);
2433                 XMM(d).q[0] = xd.q[0];
2434                 XMM(d).q[1] = xs.q[0];
2435         }
2436         CYCLES(1);     // TODO: correct cycle count
2437 }
2438
2439  void I386_OPS_BASE::MMXOP(punpcklbw_r64_r64m32)() // Opcode 0f 60
2440 {
2441         MMXPROLOG();
2442         UINT8 modrm = FETCH();
2443         if( modrm >= 0xc0 ) {
2444                 UINT32 t;
2445                 int s,d;
2446                 s=modrm & 0x7;
2447                 d=(modrm >> 3) & 0x7;
2448                 t=MMX(d).d[0];
2449                 MMX(d).b[0]=t & 0xff;
2450                 MMX(d).b[1]=MMX(s).b[0];
2451                 MMX(d).b[2]=(t >> 8) & 0xff;
2452                 MMX(d).b[3]=MMX(s).b[1];
2453                 MMX(d).b[4]=(t >> 16) & 0xff;
2454                 MMX(d).b[5]=MMX(s).b[2];
2455                 MMX(d).b[6]=(t >> 24) & 0xff;
2456                 MMX(d).b[7]=MMX(s).b[3];
2457         } else {
2458                 UINT32 s,t;
2459                 int d=(modrm >> 3) & 0x7;
2460                 UINT32 ea = GetEA(modrm, 0, 4);
2461                 s = READ32(ea);
2462                 t=MMX(d).d[0];
2463                 MMX(d).b[0]=t & 0xff;
2464                 MMX(d).b[1]=s & 0xff;
2465                 MMX(d).b[2]=(t >> 8) & 0xff;
2466                 MMX(d).b[3]=(s >> 8) & 0xff;
2467                 MMX(d).b[4]=(t >> 16) & 0xff;
2468                 MMX(d).b[5]=(s >> 16) & 0xff;
2469                 MMX(d).b[6]=(t >> 24) & 0xff;
2470                 MMX(d).b[7]=(s >> 24) & 0xff;
2471         }
2472         CYCLES(1);     // TODO: correct cycle count
2473 }
2474
2475  void I386_OPS_BASE::MMXOP(punpcklwd_r64_r64m32)() // Opcode 0f 61
2476 {
2477         MMXPROLOG();
2478         UINT8 modrm = FETCH();
2479         if( modrm >= 0xc0 ) {
2480                 UINT16 t;
2481                 int s,d;
2482                 s=modrm & 0x7;
2483                 d=(modrm >> 3) & 0x7;
2484                 t=MMX(d).w[1];
2485                 MMX(d).w[0]=MMX(d).w[0];
2486                 MMX(d).w[1]=MMX(s).w[0];
2487                 MMX(d).w[2]=t;
2488                 MMX(d).w[3]=MMX(s).w[1];
2489         } else {
2490                 UINT32 s;
2491                 UINT16 t;
2492                 int d=(modrm >> 3) & 0x7;
2493                 UINT32 ea = GetEA(modrm, 0, 4);
2494                 s = READ32(ea);
2495                 t=MMX(d).w[1];
2496                 MMX(d).w[0]=MMX(d).w[0];
2497                 MMX(d).w[1]=s & 0xffff;
2498                 MMX(d).w[2]=t;
2499                 MMX(d).w[3]=(s >> 16) & 0xffff;
2500         }
2501         CYCLES(1);     // TODO: correct cycle count
2502 }
2503
2504  void I386_OPS_BASE::MMXOP(punpckldq_r64_r64m32)() // Opcode 0f 62
2505 {
2506         MMXPROLOG();
2507         UINT8 modrm = FETCH();
2508         if( modrm >= 0xc0 ) {
2509                 int s,d;
2510                 s=modrm & 0x7;
2511                 d=(modrm >> 3) & 0x7;
2512                 MMX(d).d[0]=MMX(d).d[0];
2513                 MMX(d).d[1]=MMX(s).d[0];
2514         } else {
2515                 UINT32 s;
2516                 int d=(modrm >> 3) & 0x7;
2517                 UINT32 ea = GetEA(modrm, 0, 4);
2518                 s = READ32(ea);
2519                 MMX(d).d[0]=MMX(d).d[0];
2520                 MMX(d).d[1]=s;
2521         }
2522         CYCLES(1);     // TODO: correct cycle count
2523 }
2524
2525  void I386_OPS_BASE::MMXOP(packsswb_r64_rm64)() // Opcode 0f 63
2526 {
2527         MMXPROLOG();
2528         UINT8 modrm = FETCH();
2529         if( modrm >= 0xc0 ) {
2530                 int s,d;
2531                 s=modrm & 0x7;
2532                 d=(modrm >> 3) & 0x7;
2533                 MMX(d).c[0]=SaturatedSignedWordToSignedByte(MMX(d).s[0]);
2534                 MMX(d).c[1]=SaturatedSignedWordToSignedByte(MMX(d).s[1]);
2535                 MMX(d).c[2]=SaturatedSignedWordToSignedByte(MMX(d).s[2]);
2536                 MMX(d).c[3]=SaturatedSignedWordToSignedByte(MMX(d).s[3]);
2537                 MMX(d).c[4]=SaturatedSignedWordToSignedByte(MMX(s).s[0]);
2538                 MMX(d).c[5]=SaturatedSignedWordToSignedByte(MMX(s).s[1]);
2539                 MMX(d).c[6]=SaturatedSignedWordToSignedByte(MMX(s).s[2]);
2540                 MMX(d).c[7]=SaturatedSignedWordToSignedByte(MMX(s).s[3]);
2541         } else {
2542                 MMX_REG s;
2543                 int d=(modrm >> 3) & 0x7;
2544                 UINT32 ea = GetEA(modrm, 0, 8);
2545                 READMMX( ea, s);
2546                 MMX(d).c[0]=SaturatedSignedWordToSignedByte(MMX(d).s[0]);
2547                 MMX(d).c[1]=SaturatedSignedWordToSignedByte(MMX(d).s[1]);
2548                 MMX(d).c[2]=SaturatedSignedWordToSignedByte(MMX(d).s[2]);
2549                 MMX(d).c[3]=SaturatedSignedWordToSignedByte(MMX(d).s[3]);
2550                 MMX(d).c[4]=SaturatedSignedWordToSignedByte(s.s[0]);
2551                 MMX(d).c[5]=SaturatedSignedWordToSignedByte(s.s[1]);
2552                 MMX(d).c[6]=SaturatedSignedWordToSignedByte(s.s[2]);
2553                 MMX(d).c[7]=SaturatedSignedWordToSignedByte(s.s[3]);
2554         }
2555         CYCLES(1);     // TODO: correct cycle count
2556 }
2557
2558  void I386_OPS_BASE::MMXOP(pcmpgtb_r64_rm64)() // Opcode 0f 64
2559 {
2560         int c;
2561         MMXPROLOG();
2562         UINT8 modrm = FETCH();
2563         if( modrm >= 0xc0 ) {
2564                 int s,d;
2565                 s=modrm & 0x7;
2566                 d=(modrm >> 3) & 0x7;
2567                 for (c=0;c <= 7;c++)
2568                         MMX(d).b[c]=(MMX(d).c[c] > MMX(s).c[c]) ? 0xff : 0;
2569         } else {
2570                 MMX_REG s;
2571                 int d=(modrm >> 3) & 0x7;
2572                 UINT32 ea = GetEA(modrm, 0, 8);
2573                 READMMX( ea, s);
2574                 for (c=0;c <= 7;c++)
2575                         MMX(d).b[c]=(MMX(d).c[c] > s.c[c]) ? 0xff : 0;
2576         }
2577         CYCLES(1);     // TODO: correct cycle count
2578 }
2579
2580  void I386_OPS_BASE::MMXOP(pcmpgtw_r64_rm64)() // Opcode 0f 65
2581 {
2582         int c;
2583         MMXPROLOG();
2584         UINT8 modrm = FETCH();
2585         if( modrm >= 0xc0 ) {
2586                 int s,d;
2587                 s=modrm & 0x7;
2588                 d=(modrm >> 3) & 0x7;
2589                 for (c=0;c <= 3;c++)
2590                         MMX(d).w[c]=(MMX(d).s[c] > MMX(s).s[c]) ? 0xffff : 0;
2591         } else {
2592                 MMX_REG s;
2593                 int d=(modrm >> 3) & 0x7;
2594                 UINT32 ea = GetEA(modrm, 0, 8);
2595                 READMMX( ea, s);
2596                 for (c=0;c <= 3;c++)
2597                         MMX(d).w[c]=(MMX(d).s[c] > s.s[c]) ? 0xffff : 0;
2598         }
2599         CYCLES(1);     // TODO: correct cycle count
2600 }
2601
2602  void I386_OPS_BASE::MMXOP(pcmpgtd_r64_rm64)() // Opcode 0f 66
2603 {
2604         int c;
2605         MMXPROLOG();
2606         UINT8 modrm = FETCH();
2607         if( modrm >= 0xc0 ) {
2608                 int s,d;
2609                 s=modrm & 0x7;
2610                 d=(modrm >> 3) & 0x7;
2611                 for (c=0;c <= 1;c++)
2612                         MMX(d).d[c]=(MMX(d).i[c] > MMX(s).i[c]) ? 0xffffffff : 0;
2613         } else {
2614                 MMX_REG s;
2615                 int d=(modrm >> 3) & 0x7;
2616                 UINT32 ea = GetEA(modrm, 0, 8);
2617                 READMMX( ea, s);
2618                 for (c=0;c <= 1;c++)
2619                         MMX(d).d[c]=(MMX(d).i[c] > s.i[c]) ? 0xffffffff : 0;
2620         }
2621         CYCLES(1);     // TODO: correct cycle count
2622 }
2623
2624  void I386_OPS_BASE::MMXOP(packuswb_r64_rm64)() // Opcode 0f 67
2625 {
2626         MMXPROLOG();
2627         UINT8 modrm = FETCH();
2628         if( modrm >= 0xc0 ) {
2629                 MMX_REG ds, sd;
2630                 int s,d;
2631                 s=modrm & 0x7;
2632                 d=(modrm >> 3) & 0x7;
2633                 ds.q = MMX(d).q;
2634                 sd.q = MMX(s).q;
2635                 MMX(d).b[0]=SaturatedSignedWordToUnsignedByte(ds.s[0]);
2636                 MMX(d).b[1]=SaturatedSignedWordToUnsignedByte(ds.s[1]);
2637                 MMX(d).b[2]=SaturatedSignedWordToUnsignedByte(ds.s[2]);
2638                 MMX(d).b[3]=SaturatedSignedWordToUnsignedByte(ds.s[3]);
2639                 MMX(d).b[4]=SaturatedSignedWordToUnsignedByte(sd.s[0]);
2640                 MMX(d).b[5]=SaturatedSignedWordToUnsignedByte(sd.s[1]);
2641                 MMX(d).b[6]=SaturatedSignedWordToUnsignedByte(sd.s[2]);
2642                 MMX(d).b[7]=SaturatedSignedWordToUnsignedByte(sd.s[3]);
2643         } else {
2644                 MMX_REG s,t;
2645                 int d=(modrm >> 3) & 0x7;
2646                 UINT32 ea = GetEA(modrm, 0, 8);
2647                 READMMX( ea, s);
2648                 t.q = MMX(d).q;
2649                 MMX(d).b[0]=SaturatedSignedWordToUnsignedByte(t.s[0]);
2650                 MMX(d).b[1]=SaturatedSignedWordToUnsignedByte(t.s[1]);
2651                 MMX(d).b[2]=SaturatedSignedWordToUnsignedByte(t.s[2]);
2652                 MMX(d).b[3]=SaturatedSignedWordToUnsignedByte(t.s[3]);
2653                 MMX(d).b[4]=SaturatedSignedWordToUnsignedByte(s.s[0]);
2654                 MMX(d).b[5]=SaturatedSignedWordToUnsignedByte(s.s[1]);
2655                 MMX(d).b[6]=SaturatedSignedWordToUnsignedByte(s.s[2]);
2656                 MMX(d).b[7]=SaturatedSignedWordToUnsignedByte(s.s[3]);
2657         }
2658         CYCLES(1);     // TODO: correct cycle count
2659 }
2660
2661  void I386_OPS_BASE::MMXOP(punpckhbw_r64_rm64)() // Opcode 0f 68
2662 {
2663         MMXPROLOG();
2664         UINT8 modrm = FETCH();
2665         if( modrm >= 0xc0 ) {
2666                 int s,d;
2667                 s=modrm & 0x7;
2668                 d=(modrm >> 3) & 0x7;
2669                 MMX(d).b[0]=MMX(d).b[4];
2670                 MMX(d).b[1]=MMX(s).b[4];
2671                 MMX(d).b[2]=MMX(d).b[5];
2672                 MMX(d).b[3]=MMX(s).b[5];
2673                 MMX(d).b[4]=MMX(d).b[6];
2674                 MMX(d).b[5]=MMX(s).b[6];
2675                 MMX(d).b[6]=MMX(d).b[7];
2676                 MMX(d).b[7]=MMX(s).b[7];
2677         } else {
2678                 MMX_REG s;
2679                 int d=(modrm >> 3) & 0x7;
2680                 UINT32 ea = GetEA(modrm, 0, 8);
2681                 READMMX( ea, s);
2682                 MMX(d).b[0]=MMX(d).b[4];
2683                 MMX(d).b[1]=s.b[4];
2684                 MMX(d).b[2]=MMX(d).b[5];
2685                 MMX(d).b[3]=s.b[5];
2686                 MMX(d).b[4]=MMX(d).b[6];
2687                 MMX(d).b[5]=s.b[6];
2688                 MMX(d).b[6]=MMX(d).b[7];
2689                 MMX(d).b[7]=s.b[7];
2690         }
2691         CYCLES(1);     // TODO: correct cycle count
2692 }
2693
2694  void I386_OPS_BASE::MMXOP(punpckhwd_r64_rm64)() // Opcode 0f 69
2695 {
2696         MMXPROLOG();
2697         UINT8 modrm = FETCH();
2698         if( modrm >= 0xc0 ) {
2699                 int s,d;
2700                 s=modrm & 0x7;
2701                 d=(modrm >> 3) & 0x7;
2702                 MMX(d).w[0]=MMX(d).w[2];
2703                 MMX(d).w[1]=MMX(s).w[2];
2704                 MMX(d).w[2]=MMX(d).w[3];
2705                 MMX(d).w[3]=MMX(s).w[3];
2706         } else {
2707                 MMX_REG s;
2708                 int d=(modrm >> 3) & 0x7;
2709                 UINT32 ea = GetEA(modrm, 0, 8);
2710                 READMMX( ea, s);
2711                 MMX(d).w[0]=MMX(d).w[2];
2712                 MMX(d).w[1]=s.w[2];
2713                 MMX(d).w[2]=MMX(d).w[3];
2714                 MMX(d).w[3]=s.w[3];
2715         }
2716         CYCLES(1);     // TODO: correct cycle count
2717 }
2718
2719  void I386_OPS_BASE::MMXOP(punpckhdq_r64_rm64)() // Opcode 0f 6a
2720 {
2721         MMXPROLOG();
2722         UINT8 modrm = FETCH();
2723         if( modrm >= 0xc0 ) {
2724                 int s,d;
2725                 s=modrm & 0x7;
2726                 d=(modrm >> 3) & 0x7;
2727                 MMX(d).d[0]=MMX(d).d[1];
2728                 MMX(d).d[1]=MMX(s).d[1];
2729         } else {
2730                 MMX_REG s;
2731                 int d=(modrm >> 3) & 0x7;
2732                 UINT32 ea = GetEA(modrm, 0, 8);
2733                 READMMX( ea, s);
2734                 MMX(d).d[0]=MMX(d).d[1];
2735                 MMX(d).d[1]=s.d[1];
2736         }
2737         CYCLES(1);     // TODO: correct cycle count
2738 }
2739
2740  void I386_OPS_BASE::MMXOP(packssdw_r64_rm64)() // Opcode 0f 6b
2741 {
2742         MMXPROLOG();
2743         UINT8 modrm = FETCH();
2744         if( modrm >= 0xc0 ) {
2745                 int s,d;
2746                 INT32 t1, t2, t3, t4;
2747                 s=modrm & 0x7;
2748                 d=(modrm >> 3) & 0x7;
2749                 t1 = MMX(d).i[0];
2750                 t2 = MMX(d).i[1];
2751                 t3 = MMX(s).i[0];
2752                 t4 = MMX(s).i[1];
2753                 MMX(d).s[0] = SaturatedSignedDwordToSignedWord(t1);
2754                 MMX(d).s[1] = SaturatedSignedDwordToSignedWord(t2);
2755                 MMX(d).s[2] = SaturatedSignedDwordToSignedWord(t3);
2756                 MMX(d).s[3] = SaturatedSignedDwordToSignedWord(t4);
2757         }
2758         else {
2759                 MMX_REG s;
2760                 INT32 t1, t2;
2761                 int d=(modrm >> 3) & 0x7;
2762                 UINT32 ea = GetEA(modrm, 0, 8);
2763                 READMMX( ea, s);
2764                 t1 = MMX(d).i[0];
2765                 t2 = MMX(d).i[1];
2766                 MMX(d).s[0] = SaturatedSignedDwordToSignedWord(t1);
2767                 MMX(d).s[1] = SaturatedSignedDwordToSignedWord(t2);
2768                 MMX(d).s[2] = SaturatedSignedDwordToSignedWord(s.i[0]);
2769                 MMX(d).s[3] = SaturatedSignedDwordToSignedWord(s.i[1]);
2770         }
2771         CYCLES(1);     // TODO: correct cycle count
2772 }
2773
2774  void I386_OPS_BASE::SSEOP(group_0fae)()  // Opcode 0f ae
2775 {
2776         UINT8 modm = FETCH();
2777         if( modm == 0xf8 ) {
2778                 logerror("Unemulated SFENCE opcode called\n");
2779                 CYCLES(1); // sfence instruction
2780         } else if( modm == 0xf0 ) {
2781                 CYCLES(1); // mfence instruction
2782         } else if( modm == 0xe8 ) {
2783                 CYCLES(1); // lfence instruction
2784         } else if( modm < 0xc0 ) {
2785                 UINT32 ea;
2786                 switch ( (modm & 0x38) >> 3 )
2787                 {
2788                         case 2: // ldmxcsr m32
2789                                 ea = GetEA(modm, 0, 4);
2790                                 cpustate->mxcsr = READ32(ea);
2791                                 break;
2792                         case 3: // stmxcsr m32
2793                                 ea = GetEA(modm, 0, 4);
2794                                 WRITE32(ea, cpustate->mxcsr);
2795                                 break;
2796                         case 7: // clflush m8
2797                                 GetNonTranslatedEA(modm, NULL);
2798                                 break;
2799                         default:
2800                                 report_invalid_modrm( "sse_group_0fae", modm);
2801                 }
2802         } else {
2803                 report_invalid_modrm( "sse_group_0fae", modm);
2804         }
2805 }
2806
2807  void I386_OPS_BASE::SSEOP(cvttps2dq_r128_rm128)() // Opcode f3 0f 5b
2808 {
2809         UINT8 modrm = FETCH();
2810         if( modrm >= 0xc0 ) {
2811                 XMM((modrm >> 3) & 0x7).i[0]=(INT32)XMM(modrm & 0x7).f[0];
2812                 XMM((modrm >> 3) & 0x7).i[1]=(INT32)XMM(modrm & 0x7).f[1];
2813                 XMM((modrm >> 3) & 0x7).i[2]=(INT32)XMM(modrm & 0x7).f[2];
2814                 XMM((modrm >> 3) & 0x7).i[3]=(INT32)XMM(modrm & 0x7).f[3];
2815         } else {
2816                 XMM_REG src;
2817                 UINT32 ea = GetEA(modrm, 0, 16);
2818                 READXMM( ea, src);
2819                 XMM((modrm >> 3) & 0x7).i[0]=(INT32)src.f[0];
2820                 XMM((modrm >> 3) & 0x7).i[1]=(INT32)src.f[1];
2821                 XMM((modrm >> 3) & 0x7).i[2]=(INT32)src.f[2];
2822                 XMM((modrm >> 3) & 0x7).i[3]=(INT32)src.f[3];
2823         }
2824         CYCLES(1);     // TODO: correct cycle count
2825 }
2826
2827  void I386_OPS_BASE::SSEOP(cvtss2sd_r128_r128m32)() // Opcode f3 0f 5a
2828 {
2829         UINT8 modrm = FETCH();
2830         if( modrm >= 0xc0 ) {
2831                 XMM((modrm >> 3) & 0x7).f64[0] = XMM(modrm & 0x7).f[0];
2832         } else {
2833                 XMM_REG s;
2834                 UINT32 ea = GetEA(modrm, 0, 4);
2835                 s.d[0] = READ32(ea);
2836                 XMM((modrm >> 3) & 0x7).f64[0] = s.f[0];
2837         }
2838         CYCLES(1);     // TODO: correct cycle count
2839 }
2840
2841  void I386_OPS_BASE::SSEOP(cvttss2si_r32_r128m32)() // Opcode f3 0f 2c
2842 {
2843         INT32 src;
2844         UINT8 modrm = FETCH(); // get mordm byte
2845         if( modrm >= 0xc0 ) { // if bits 7-6 are 11 the source is a xmm register (low doubleword)
2846                 src = (INT32)XMM(modrm & 0x7).f[0^NATIVE_ENDIAN_VALUE_LE_BE(0,1)];
2847         } else { // otherwise is a memory address
2848                 XMM_REG t;
2849                 UINT32 ea = GetEA(modrm, 0, 4);
2850                 t.d[0] = READ32(ea);
2851                 src = (INT32)t.f[0];
2852         }
2853         STORE_REG32(modrm, (UINT32)src);
2854         CYCLES(1);     // TODO: correct cycle count
2855 }
2856
2857  void I386_OPS_BASE::SSEOP(cvtss2si_r32_r128m32)() // Opcode f3 0f 2d
2858 {
2859         INT32 src;
2860         UINT8 modrm = FETCH();
2861         if( modrm >= 0xc0 ) {
2862                 src = (INT32)XMM(modrm & 0x7).f[0];
2863         } else {
2864                 XMM_REG t;
2865                 UINT32 ea = GetEA(modrm, 0, 4);
2866                 t.d[0] = READ32(ea);
2867                 src = (INT32)t.f[0];
2868         }
2869         STORE_REG32(modrm, (UINT32)src);
2870         CYCLES(1);     // TODO: correct cycle count
2871 }
2872
2873  void I386_OPS_BASE::SSEOP(cvtsi2ss_r128_rm32)() // Opcode f3 0f 2a
2874 {
2875         UINT8 modrm = FETCH();
2876         if( modrm >= 0xc0 ) {
2877                 XMM((modrm >> 3) & 0x7).f[0] = (INT32)LOAD_RM32(modrm);
2878         } else {
2879                 UINT32 ea = GetEA(modrm, 0, 4);
2880                 XMM((modrm >> 3) & 0x7).f[0] = (INT32)READ32(ea);
2881         }
2882         CYCLES(1);     // TODO: correct cycle count
2883 }
2884
2885  void I386_OPS_BASE::SSEOP(cvtpi2ps_r128_rm64)() // Opcode 0f 2a
2886 {
2887         UINT8 modrm = FETCH();
2888         MMXPROLOG();
2889         if( modrm >= 0xc0 ) {
2890                 XMM((modrm >> 3) & 0x7).f[0] = (float)MMX(modrm & 0x7).i[0];
2891                 XMM((modrm >> 3) & 0x7).f[1] = (float)MMX(modrm & 0x7).i[1];
2892         } else {
2893                 MMX_REG r;
2894                 UINT32 ea = GetEA(modrm, 0, 8);
2895                 READMMX( ea, r);
2896                 XMM((modrm >> 3) & 0x7).f[0] = (float)r.i[0];
2897                 XMM((modrm >> 3) & 0x7).f[1] = (float)r.i[1];
2898         }
2899         CYCLES(1);     // TODO: correct cycle count
2900 }
2901
2902  void I386_OPS_BASE::SSEOP(cvttps2pi_r64_r128m64)() // Opcode 0f 2c
2903 {
2904         UINT8 modrm = FETCH();
2905         MMXPROLOG();
2906         if( modrm >= 0xc0 ) {
2907                 MMX((modrm >> 3) & 0x7).i[0] = XMM(modrm & 0x7).f[0];
2908                 MMX((modrm >> 3) & 0x7).i[1] = XMM(modrm & 0x7).f[1];
2909         } else {
2910                 XMM_REG r;
2911                 UINT32 ea = GetEA(modrm, 0, 16);
2912                 READXMM( ea, r);
2913                 XMM((modrm >> 3) & 0x7).i[0] = r.f[0];
2914                 XMM((modrm >> 3) & 0x7).i[1] = r.f[1];
2915         }
2916         CYCLES(1);     // TODO: correct cycle count
2917 }
2918
2919  void I386_OPS_BASE::SSEOP(cvtps2pi_r64_r128m64)() // Opcode 0f 2d
2920 {
2921         UINT8 modrm = FETCH();
2922         MMXPROLOG();
2923         if( modrm >= 0xc0 ) {
2924                 MMX((modrm >> 3) & 0x7).i[0] = XMM(modrm & 0x7).f[0];
2925                 MMX((modrm >> 3) & 0x7).i[1] = XMM(modrm & 0x7).f[1];
2926         } else {
2927                 XMM_REG r;
2928                 UINT32 ea = GetEA(modrm, 0, 16);
2929                 READXMM( ea, r);
2930                 XMM((modrm >> 3) & 0x7).i[0] = r.f[0];
2931                 XMM((modrm >> 3) & 0x7).i[1] = r.f[1];
2932         }
2933         CYCLES(1);     // TODO: correct cycle count
2934 }
2935
2936  void I386_OPS_BASE::SSEOP(cvtps2pd_r128_r128m64)() // Opcode 0f 5a
2937 {
2938         UINT8 modrm = FETCH();
2939         if( modrm >= 0xc0 ) {
2940                 XMM((modrm >> 3) & 0x7).f64[0] = (double)XMM(modrm & 0x7).f[0];
2941                 XMM((modrm >> 3) & 0x7).f64[1] = (double)XMM(modrm & 0x7).f[1];
2942         } else {
2943                 MMX_REG r;
2944                 UINT32 ea = GetEA(modrm, 0, 8);
2945                 READMMX( ea, r);
2946                 XMM((modrm >> 3) & 0x7).f64[0] = (double)r.f[0];
2947                 XMM((modrm >> 3) & 0x7).f64[1] = (double)r.f[1];
2948         }
2949         CYCLES(1);     // TODO: correct cycle count
2950 }
2951
2952  void I386_OPS_BASE::SSEOP(cvtdq2ps_r128_rm128)() // Opcode 0f 5b
2953 {
2954         UINT8 modrm = FETCH();
2955         if( modrm >= 0xc0 ) {
2956                 XMM((modrm >> 3) & 0x7).f[0] = (float)XMM(modrm & 0x7).i[0];
2957                 XMM((modrm >> 3) & 0x7).f[1] = (float)XMM(modrm & 0x7).i[1];
2958                 XMM((modrm >> 3) & 0x7).f[2] = (float)XMM(modrm & 0x7).i[2];
2959                 XMM((modrm >> 3) & 0x7).f[3] = (float)XMM(modrm & 0x7).i[3];
2960         } else {
2961                 XMM_REG r;
2962                 UINT32 ea = GetEA(modrm, 0, 16);
2963                 READXMM( ea, r);
2964                 XMM((modrm >> 3) & 0x7).f[0] = (float)r.i[0];
2965                 XMM((modrm >> 3) & 0x7).f[1] = (float)r.i[1];
2966                 XMM((modrm >> 3) & 0x7).f[2] = (float)r.i[2];
2967                 XMM((modrm >> 3) & 0x7).f[3] = (float)r.i[3];
2968         }
2969         CYCLES(1);     // TODO: correct cycle count
2970 }
2971
2972  void I386_OPS_BASE::SSEOP(cvtdq2pd_r128_r128m64)() // Opcode f3 0f e6
2973 {
2974         UINT8 modrm = FETCH();
2975         if( modrm >= 0xc0 ) {
2976                 XMM((modrm >> 3) & 0x7).f64[0] = (double)XMM(modrm & 0x7).i[0];
2977                 XMM((modrm >> 3) & 0x7).f64[1] = (double)XMM(modrm & 0x7).i[1];
2978         } else {
2979                 MMX_REG s;
2980                 UINT32 ea = GetEA(modrm, 0, 8);
2981                 READMMX( ea, s);
2982                 XMM((modrm >> 3) & 0x7).f64[0] = (double)s.i[0];
2983                 XMM((modrm >> 3) & 0x7).f64[1] = (double)s.i[1];
2984         }
2985         CYCLES(1);     // TODO: correct cycle count
2986 }
2987
2988  void I386_OPS_BASE::SSEOP(movss_r128_rm128)() // Opcode f3 0f 10
2989 {
2990         UINT8 modrm = FETCH();
2991         if( modrm >= 0xc0 ) {
2992                 XMM((modrm >> 3) & 0x7).d[0] = XMM(modrm & 0x7).d[0];
2993         } else {
2994                 UINT32 ea = GetEA(modrm, 0, 4);
2995                 XMM((modrm >> 3) & 0x7).d[0] = READ32(ea);
2996         }
2997         CYCLES(1);     // TODO: correct cycle count
2998 }
2999
3000  void I386_OPS_BASE::SSEOP(movss_rm128_r128)() // Opcode f3 0f 11
3001 {
3002         UINT8 modrm = FETCH();
3003         if( modrm >= 0xc0 ) {
3004                 XMM(modrm & 0x7).d[0] = XMM((modrm >> 3) & 0x7).d[0];
3005         } else {
3006                 UINT32 ea = GetEA(modrm, 0, 4);
3007                 WRITE32(ea, XMM((modrm >> 3) & 0x7).d[0]);
3008         }
3009         CYCLES(1);     // TODO: correct cycle count
3010 }
3011
3012  void I386_OPS_BASE::SSEOP(movsldup_r128_rm128)() // Opcode f3 0f 12
3013 {
3014         UINT8 modrm = FETCH();
3015         if( modrm >= 0xc0 ) {
3016                 XMM((modrm >> 3) & 0x7).d[0] = XMM(modrm & 0x7).d[0];
3017                 XMM((modrm >> 3) & 0x7).d[1] = XMM(modrm & 0x7).d[0];
3018                 XMM((modrm >> 3) & 0x7).d[2] = XMM(modrm & 0x7).d[2];
3019                 XMM((modrm >> 3) & 0x7).d[3] = XMM(modrm & 0x7).d[2];
3020         } else {
3021                 XMM_REG src;
3022                 UINT32 ea = GetEA(modrm, 0, 16);
3023                 READXMM( ea, src);
3024                 XMM((modrm >> 3) & 0x7).d[0] = src.d[0];
3025                 XMM((modrm >> 3) & 0x7).d[1] = src.d[0];
3026                 XMM((modrm >> 3) & 0x7).d[2] = src.d[2];
3027                 XMM((modrm >> 3) & 0x7).d[3] = src.d[2];
3028         }
3029         CYCLES(1);     // TODO: correct cycle count
3030 }
3031
3032  void I386_OPS_BASE::SSEOP(movshdup_r128_rm128)() // Opcode f3 0f 16
3033 {
3034         UINT8 modrm = FETCH();
3035         if( modrm >= 0xc0 ) {
3036                 XMM((modrm >> 3) & 0x7).d[0] = XMM(modrm & 0x7).d[1];
3037                 XMM((modrm >> 3) & 0x7).d[1] = XMM(modrm & 0x7).d[1];
3038                 XMM((modrm >> 3) & 0x7).d[2] = XMM(modrm & 0x7).d[3];
3039                 XMM((modrm >> 3) & 0x7).d[3] = XMM(modrm & 0x7).d[3];
3040         } else {
3041                 XMM_REG src;
3042                 UINT32 ea = GetEA(modrm, 0, 16);
3043                 READXMM( ea, src);
3044                 XMM((modrm >> 3) & 0x7).d[0] = src.d[1];
3045                 XMM((modrm >> 3) & 0x7).d[1] = src.d[1];
3046                 XMM((modrm >> 3) & 0x7).d[2] = src.d[3];
3047                 XMM((modrm >> 3) & 0x7).d[3] = src.d[3];
3048         }
3049         CYCLES(1);     // TODO: correct cycle count
3050 }
3051
3052  void I386_OPS_BASE::SSEOP(movaps_r128_rm128)() // Opcode 0f 28
3053 {
3054         UINT8 modrm = FETCH();
3055         if( modrm >= 0xc0 ) {
3056                 XMM((modrm >> 3) & 0x7) = XMM(modrm & 0x7);
3057         } else {
3058                 UINT32 ea = GetEA(modrm, 0, 16);
3059                 READXMM( ea, XMM((modrm >> 3) & 0x7));
3060         }
3061         CYCLES(1);     // TODO: correct cycle count
3062 }
3063
3064  void I386_OPS_BASE::SSEOP(movaps_rm128_r128)() // Opcode 0f 29
3065 {
3066         UINT8 modrm = FETCH();
3067         if( modrm >= 0xc0 ) {
3068                 XMM(modrm & 0x7) = XMM((modrm >> 3) & 0x7);
3069         } else {
3070                 UINT32 ea = GetEA(modrm, 0, 16);
3071                 WRITEXMM( ea, XMM((modrm >> 3) & 0x7));
3072         }
3073         CYCLES(1);     // TODO: correct cycle count
3074 }
3075
3076  void I386_OPS_BASE::SSEOP(movups_r128_rm128)() // Opcode 0f 10
3077 {
3078         UINT8 modrm = FETCH();
3079         if( modrm >= 0xc0 ) {
3080                 XMM((modrm >> 3) & 0x7) = XMM(modrm & 0x7);
3081         } else {
3082                 UINT32 ea = GetEA(modrm, 0, 16);
3083                 READXMM( ea, XMM((modrm >> 3) & 0x7)); // address does not need to be 16-byte aligned
3084         }
3085         CYCLES(1);     // TODO: correct cycle count
3086 }
3087
3088  void I386_OPS_BASE::SSEOP(movupd_r128_rm128)() // Opcode 66 0f 10
3089 {
3090         UINT8 modrm = FETCH();
3091         if( modrm >= 0xc0 ) {
3092                 XMM((modrm >> 3) & 0x7) = XMM(modrm & 0x7);
3093         } else {
3094                 UINT32 ea = GetEA(modrm, 0, 16);
3095                 READXMM( ea, XMM((modrm >> 3) & 0x7)); // address does not need to be 16-byte aligned
3096         }
3097         CYCLES(1);     // TODO: correct cycle count
3098 }
3099
3100  void I386_OPS_BASE::SSEOP(movups_rm128_r128)() // Opcode 0f 11
3101 {
3102         UINT8 modrm = FETCH();
3103         if( modrm >= 0xc0 ) {
3104                 XMM(modrm & 0x7) = XMM((modrm >> 3) & 0x7);
3105         } else {
3106                 UINT32 ea = GetEA(modrm, 0, 16);
3107                 WRITEXMM( ea, XMM((modrm >> 3) & 0x7)); // address does not need to be 16-byte aligned
3108         }
3109         CYCLES(1);     // TODO: correct cycle count
3110 }
3111
3112  void I386_OPS_BASE::SSEOP(movupd_rm128_r128)() // Opcode 66 0f 11
3113 {
3114         UINT8 modrm = FETCH();
3115         if( modrm >= 0xc0 ) {
3116                 XMM(modrm & 0x7) = XMM((modrm >> 3) & 0x7);
3117         } else {
3118                 UINT32 ea = GetEA(modrm, 0, 16);
3119                 WRITEXMM( ea, XMM((modrm >> 3) & 0x7)); // address does not need to be 16-byte aligned
3120         }
3121         CYCLES(1);     // TODO: correct cycle count
3122 }
3123
3124  void I386_OPS_BASE::SSEOP(movlps_r128_m64)() // Opcode 0f 12
3125 {
3126         UINT8 modrm = FETCH();
3127         if( modrm >= 0xc0 ) {
3128                 // MOVHLPS opcode
3129                 XMM((modrm >> 3) & 0x7).q[0] = XMM(modrm & 0x7).q[1];
3130                 CYCLES(1);     // TODO: correct cycle count
3131         } else {
3132                 // MOVLPS opcode
3133                 UINT32 ea = GetEA(modrm, 0, 8);
3134                 READXMM_LO64( ea, XMM((modrm >> 3) & 0x7));
3135                 CYCLES(1);     // TODO: correct cycle count
3136         }
3137 }
3138
3139  void I386_OPS_BASE::SSEOP(movlpd_r128_m64)() // Opcode 66 0f 12
3140 {
3141         UINT8 modrm = FETCH();
3142         if( modrm >= 0xc0 ) {
3143                 CYCLES(1);     // TODO: correct cycle count
3144         } else {
3145                 // MOVLPS opcode
3146                 UINT32 ea = GetEA(modrm, 0, 8);
3147                 READXMM_LO64( ea, XMM((modrm >> 3) & 0x7));
3148                 CYCLES(1);     // TODO: correct cycle count
3149         }
3150 }
3151
3152  void I386_OPS_BASE::SSEOP(movlps_m64_r128)() // Opcode 0f 13
3153 {
3154         UINT8 modrm = FETCH();
3155         if( modrm >= 0xc0 ) {
3156                 // unsupported by cpu
3157                 CYCLES(1);     // TODO: correct cycle count
3158         } else {
3159                 UINT32 ea = GetEA(modrm, 0, 8);
3160                 WRITEXMM_LO64( ea, XMM((modrm >> 3) & 0x7));
3161                 CYCLES(1);     // TODO: correct cycle count
3162         }
3163 }
3164
3165  void I386_OPS_BASE::SSEOP(movlpd_m64_r128)() // Opcode 66 0f 13
3166 {
3167         UINT8 modrm = FETCH();
3168         if( modrm >= 0xc0 ) {
3169                 // unsupported by cpu
3170                 CYCLES(1);     // TODO: correct cycle count
3171         } else {
3172                 UINT32 ea = GetEA(modrm, 0, 8);
3173                 WRITEXMM_LO64( ea, XMM((modrm >> 3) & 0x7));
3174                 CYCLES(1);     // TODO: correct cycle count
3175         }
3176 }
3177
3178  void I386_OPS_BASE::SSEOP(movhps_r128_m64)() // Opcode 0f 16
3179 {
3180         UINT8 modrm = FETCH();
3181         if( modrm >= 0xc0 ) {
3182                 // MOVLHPS opcode
3183                 XMM((modrm >> 3) & 0x7).q[1] = XMM(modrm & 0x7).q[0];
3184                 CYCLES(1);     // TODO: correct cycle count
3185         } else {
3186                 // MOVHPS opcode
3187                 UINT32 ea = GetEA(modrm, 0, 8);
3188                 READXMM_HI64( ea, XMM((modrm >> 3) & 0x7));
3189                 CYCLES(1);     // TODO: correct cycle count
3190         }
3191 }
3192
3193  void I386_OPS_BASE::SSEOP(movhpd_r128_m64)() // Opcode 66 0f 16
3194 {
3195         UINT8 modrm = FETCH();
3196         if( modrm >= 0xc0 ) {
3197                 // unsupported by cpu
3198                 CYCLES(1);     // TODO: correct cycle count
3199         } else {
3200                 // MOVHPS opcode
3201                 UINT32 ea = GetEA(modrm, 0, 8);
3202                 READXMM_HI64( ea, XMM((modrm >> 3) & 0x7));
3203                 CYCLES(1);     // TODO: correct cycle count
3204         }
3205 }
3206
3207  void I386_OPS_BASE::SSEOP(movhps_m64_r128)() // Opcode 0f 17
3208 {
3209         UINT8 modrm = FETCH();
3210         if( modrm >= 0xc0 ) {
3211                 // unsupported by cpu
3212                 CYCLES(1);     // TODO: correct cycle count
3213         } else {
3214                 UINT32 ea = GetEA(modrm, 0, 8);
3215                 WRITEXMM_HI64( ea, XMM((modrm >> 3) & 0x7));
3216                 CYCLES(1);     // TODO: correct cycle count
3217         }
3218 }
3219
3220  void I386_OPS_BASE::SSEOP(movhpd_m64_r128)() // Opcode 66 0f 17
3221 {
3222         UINT8 modrm = FETCH();
3223         if( modrm >= 0xc0 ) {
3224                 // unsupported by cpu
3225                 CYCLES(1);     // TODO: correct cycle count
3226         } else {
3227                 UINT32 ea = GetEA(modrm, 0, 8);
3228                 WRITEXMM_HI64( ea, XMM((modrm >> 3) & 0x7));
3229                 CYCLES(1);     // TODO: correct cycle count
3230         }
3231 }
3232
3233  void I386_OPS_BASE::SSEOP(movntps_m128_r128)() // Opcode 0f 2b
3234 {
3235         UINT8 modrm = FETCH();
3236         if( modrm >= 0xc0 ) {
3237                 // unsupported by cpu
3238                 CYCLES(1);     // TODO: correct cycle count
3239         } else {
3240                 // since cache is not implemented
3241                 UINT32 ea = GetEA(modrm, 0, 16);
3242                 WRITEXMM( ea, XMM((modrm >> 3) & 0x7));
3243                 CYCLES(1);     // TODO: correct cycle count
3244         }
3245 }
3246
3247  void I386_OPS_BASE::SSEOP(movmskps_r16_r128)() // Opcode 0f 50
3248 {
3249         UINT8 modrm = FETCH();
3250         if( modrm >= 0xc0 ) {
3251                 int b;
3252                 b=(XMM(modrm & 0x7).d[0] >> 31) & 1;
3253                 b=b | ((XMM(modrm & 0x7).d[1] >> 30) & 2);
3254                 b=b | ((XMM(modrm & 0x7).d[2] >> 29) & 4);
3255                 b=b | ((XMM(modrm & 0x7).d[3] >> 28) & 8);
3256                 STORE_REG16(modrm, b);
3257         }
3258         CYCLES(1);     // TODO: correct cycle count
3259 }
3260
3261  void I386_OPS_BASE::SSEOP(movmskps_r32_r128)() // Opcode 0f 50
3262 {
3263         UINT8 modrm = FETCH();
3264         if( modrm >= 0xc0 ) {
3265                 int b;
3266                 b=(XMM(modrm & 0x7).d[0] >> 31) & 1;
3267                 b=b | ((XMM(modrm & 0x7).d[1] >> 30) & 2);
3268                 b=b | ((XMM(modrm & 0x7).d[2] >> 29) & 4);
3269                 b=b | ((XMM(modrm & 0x7).d[3] >> 28) & 8);
3270                 STORE_REG32(modrm, b);
3271         }
3272         CYCLES(1);     // TODO: correct cycle count
3273 }
3274
3275  void I386_OPS_BASE::SSEOP(movmskpd_r32_r128)() // Opcode 66 0f 50
3276 {
3277         UINT8 modrm = FETCH();
3278         if( modrm >= 0xc0 ) {
3279                 int b;
3280                 b=(XMM(modrm & 0x7).q[0] >> 63) & 1;
3281                 b=b | ((XMM(modrm & 0x7).q[1] >> 62) & 2);
3282                 STORE_REG32(modrm, b);
3283         }
3284         CYCLES(1);     // TODO: correct cycle count
3285 }
3286
3287  void I386_OPS_BASE::SSEOP(movq2dq_r128_r64)() // Opcode f3 0f d6
3288 {
3289         MMXPROLOG();
3290         UINT8 modrm = FETCH();
3291         if( modrm >= 0xc0 ) {
3292                 XMM((modrm >> 3) & 0x7).q[0] = MMX(modrm & 7).q;
3293                 XMM((modrm >> 3) & 0x7).q[1] = 0;
3294         }
3295         CYCLES(1);     // TODO: correct cycle count
3296 }
3297
3298  void I386_OPS_BASE::SSEOP(movdqu_r128_rm128)() // Opcode f3 0f 6f
3299 {
3300         MMXPROLOG();
3301         UINT8 modrm = FETCH();
3302         if( modrm >= 0xc0 ) {
3303                 XMM((modrm >> 3) & 0x7).q[0] = XMM(modrm & 0x7).q[0];
3304                 XMM((modrm >> 3) & 0x7).q[1] = XMM(modrm & 0x7).q[1];
3305         } else {
3306                 UINT32 ea = GetEA(modrm, 0, 16);
3307                 READXMM( ea, XMM((modrm >> 3) & 0x7));
3308         }
3309         CYCLES(1);     // TODO: correct cycle count
3310 }
3311
3312  void I386_OPS_BASE::SSEOP(movdqu_rm128_r128)() // Opcode f3 0f 7f
3313 {
3314         MMXPROLOG();
3315         UINT8 modrm = FETCH();
3316         if( modrm >= 0xc0 ) {
3317                 XMM(modrm & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0];
3318                 XMM(modrm & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1];
3319         } else {
3320                 UINT32 ea = GetEA(modrm, 0, 16);
3321                 WRITEXMM( ea, XMM((modrm >> 3) & 0x7));
3322         }
3323         CYCLES(1);     // TODO: correct cycle count
3324 }
3325
3326  void I386_OPS_BASE::SSEOP(movd_m128_rm32)() // Opcode 66 0f 6e
3327 {
3328         UINT8 modrm = FETCH();
3329         if (modrm >= 0xc0) {
3330                 XMM((modrm >> 3) & 0x7).d[0] = LOAD_RM32(modrm);
3331         }
3332         else {
3333                 UINT32 ea = GetEA(modrm, 0, 4);
3334                 XMM((modrm >> 3) & 0x7).d[0] = READ32(ea);
3335         }
3336         XMM((modrm >> 3) & 0x7).d[1] = 0;
3337         XMM((modrm >> 3) & 0x7).q[1] = 0;
3338         CYCLES(1);     // TODO: correct cycle count
3339 }
3340
3341  void I386_OPS_BASE::SSEOP(movdqa_m128_rm128)() // Opcode 66 0f 6f
3342 {
3343         UINT8 modrm = FETCH();
3344         if (modrm >= 0xc0) {
3345                 XMM((modrm >> 3) & 0x7).q[0] = XMM(modrm & 0x7).q[0];
3346                 XMM((modrm >> 3) & 0x7).q[1] = XMM(modrm & 0x7).q[1];
3347         }
3348         else {
3349                 UINT32 ea = GetEA(modrm, 0, 16);
3350                 READXMM( ea, XMM((modrm >> 3) & 0x7));
3351         }
3352         CYCLES(1);     // TODO: correct cycle count
3353 }
3354
3355  void I386_OPS_BASE::SSEOP(movq_r128_r128m64)() // Opcode f3 0f 7e
3356 {
3357         MMXPROLOG();
3358         UINT8 modrm = FETCH();
3359         if( modrm >= 0xc0 ) {
3360                 XMM((modrm >> 3) & 0x7).q[0] = XMM(modrm & 0x7).q[0];
3361                 XMM((modrm >> 3) & 0x7).q[1] = 0;
3362         } else {
3363                 UINT32 ea = GetEA(modrm, 0, 8);
3364                 XMM((modrm >> 3) & 0x7).q[0] = READ64( ea);
3365                 XMM((modrm >> 3) & 0x7).q[1] = 0;
3366         }
3367         CYCLES(1);     // TODO: correct cycle count
3368 }
3369
3370  void I386_OPS_BASE::SSEOP(movd_rm32_r128)() // Opcode 66 0f 7e
3371 {
3372         UINT8 modrm = FETCH();
3373         if (modrm >= 0xc0) {
3374                 STORE_RM32(modrm, XMM((modrm >> 3) & 0x7).d[0]);
3375         }
3376         else {
3377                 UINT32 ea = GetEA(modrm, 0, 4);
3378                 WRITE32(ea, XMM((modrm >> 3) & 0x7).d[0]);
3379         }
3380         CYCLES(1);     // TODO: correct cycle count
3381 }
3382
3383  void I386_OPS_BASE::SSEOP(movdqa_rm128_r128)() // Opcode 66 0f 7f
3384 {
3385         UINT8 modrm = FETCH();
3386         if (modrm >= 0xc0) {
3387                 XMM(modrm & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0];
3388                 XMM(modrm & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1];
3389         }
3390         else {
3391                 UINT32 ea = GetEA(modrm, 0, 16);
3392                 WRITEXMM( ea, XMM((modrm >> 3) & 0x7));
3393         }
3394         CYCLES(1);     // TODO: correct cycle count
3395 }
3396
3397  void I386_OPS_BASE::SSEOP(pmovmskb_r16_r64)() // Opcode 0f d7
3398 {
3399         //MMXPROLOG();
3400         UINT8 modrm = FETCH();
3401         if( modrm >= 0xc0 ) {
3402                 int b;
3403                 b=(MMX(modrm & 0x7).b[0] >> 7) & 1;
3404                 b=b | ((MMX(modrm & 0x7).b[1] >> 6) & 2);
3405                 b=b | ((MMX(modrm & 0x7).b[2] >> 5) & 4);
3406                 b=b | ((MMX(modrm & 0x7).b[3] >> 4) & 8);
3407                 b=b | ((MMX(modrm & 0x7).b[4] >> 3) & 16);
3408                 b=b | ((MMX(modrm & 0x7).b[5] >> 2) & 32);
3409                 b=b | ((MMX(modrm & 0x7).b[6] >> 1) & 64);
3410                 b=b | ((MMX(modrm & 0x7).b[7] >> 0) & 128);
3411                 STORE_REG16(modrm, b);
3412         }
3413         CYCLES(1);     // TODO: correct cycle count
3414 }
3415
3416  void I386_OPS_BASE::SSEOP(pmovmskb_r32_r64)() // Opcode 0f d7
3417 {
3418         //MMXPROLOG();
3419         UINT8 modrm = FETCH();
3420         if( modrm >= 0xc0 ) {
3421                 int b;
3422                 b=(MMX(modrm & 0x7).b[0] >> 7) & 1;
3423                 b=b | ((MMX(modrm & 0x7).b[1] >> 6) & 2);
3424                 b=b | ((MMX(modrm & 0x7).b[2] >> 5) & 4);
3425                 b=b | ((MMX(modrm & 0x7).b[3] >> 4) & 8);
3426                 b=b | ((MMX(modrm & 0x7).b[4] >> 3) & 16);
3427                 b=b | ((MMX(modrm & 0x7).b[5] >> 2) & 32);
3428                 b=b | ((MMX(modrm & 0x7).b[6] >> 1) & 64);
3429                 b=b | ((MMX(modrm & 0x7).b[7] >> 0) & 128);
3430                 STORE_REG32(modrm, b);
3431         }
3432         CYCLES(1);     // TODO: correct cycle count
3433 }
3434
3435  void I386_OPS_BASE::SSEOP(pmovmskb_r32_r128)() // Opcode 66 0f d7
3436 {
3437         UINT8 modrm = FETCH();
3438         if( modrm >= 0xc0 ) {
3439                 UINT32 b;
3440                 b=(XMM(modrm & 0x7).b[0] >> 7) & 1;
3441                 b=b | ((XMM(modrm & 0x7).b[1] >> 6) & 2);
3442                 b=b | ((XMM(modrm & 0x7).b[2] >> 5) & 4);
3443                 b=b | ((XMM(modrm & 0x7).b[3] >> 4) & 8);
3444                 b=b | ((XMM(modrm & 0x7).b[4] >> 3) & 16);
3445                 b=b | ((XMM(modrm & 0x7).b[5] >> 2) & 32);
3446                 b=b | ((XMM(modrm & 0x7).b[6] >> 1) & 64);
3447                 b=b | ((XMM(modrm & 0x7).b[7] >> 0) & 128);
3448                 b=b | ((XMM(modrm & 0x7).b[8] << 1) & 256);
3449                 b=b | ((XMM(modrm & 0x7).b[9] << 2) & 512);
3450                 b=b | ((XMM(modrm & 0x7).b[10] << 3) & 1024);
3451                 b=b | ((XMM(modrm & 0x7).b[11] << 4) & 2048);
3452                 b=b | ((XMM(modrm & 0x7).b[12] << 5) & 4096);
3453                 b=b | ((XMM(modrm & 0x7).b[13] << 6) & 8192);
3454                 b=b | ((XMM(modrm & 0x7).b[14] << 7) & 16384);
3455                 b=b | ((XMM(modrm & 0x7).b[15] << 8) & 32768);
3456                 STORE_REG32(modrm, b);
3457         }
3458         CYCLES(1);     // TODO: correct cycle count
3459 }
3460
3461  void I386_OPS_BASE::SSEOP(xorps)() // Opcode 0f 57
3462 {
3463         UINT8 modrm = FETCH();
3464         if( modrm >= 0xc0 ) {
3465                 XMM((modrm >> 3) & 0x7).d[0] = XMM((modrm >> 3) & 0x7).d[0] ^ XMM(modrm & 0x7).d[0];
3466                 XMM((modrm >> 3) & 0x7).d[1] = XMM((modrm >> 3) & 0x7).d[1] ^ XMM(modrm & 0x7).d[1];
3467                 XMM((modrm >> 3) & 0x7).d[2] = XMM((modrm >> 3) & 0x7).d[2] ^ XMM(modrm & 0x7).d[2];
3468                 XMM((modrm >> 3) & 0x7).d[3] = XMM((modrm >> 3) & 0x7).d[3] ^ XMM(modrm & 0x7).d[3];
3469         } else {
3470                 XMM_REG src;
3471                 UINT32 ea = GetEA(modrm, 0, 16);
3472                 READXMM( ea, src);
3473                 XMM((modrm >> 3) & 0x7).d[0] = XMM((modrm >> 3) & 0x7).d[0] ^ src.d[0];
3474                 XMM((modrm >> 3) & 0x7).d[1] = XMM((modrm >> 3) & 0x7).d[1] ^ src.d[1];
3475                 XMM((modrm >> 3) & 0x7).d[2] = XMM((modrm >> 3) & 0x7).d[2] ^ src.d[2];
3476                 XMM((modrm >> 3) & 0x7).d[3] = XMM((modrm >> 3) & 0x7).d[3] ^ src.d[3];
3477         }
3478         CYCLES(1);     // TODO: correct cycle count
3479 }
3480
3481  void I386_OPS_BASE::SSEOP(xorpd_r128_rm128)() // Opcode 66 0f 57
3482 {
3483         UINT8 modrm = FETCH();
3484         if( modrm >= 0xc0 ) {
3485                 XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] ^ XMM(modrm & 0x7).q[0];
3486                 XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] ^ XMM(modrm & 0x7).q[1];
3487         } else {
3488                 XMM_REG src;
3489                 UINT32 ea = GetEA(modrm, 0, 16);
3490                 READXMM( ea, src);
3491                 XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] ^ src.q[0];
3492                 XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] ^ src.q[1];
3493         }
3494         CYCLES(1);     // TODO: correct cycle count
3495 }
3496
3497  void I386_OPS_BASE::SSEOP(addps)() // Opcode 0f 58
3498 {
3499         UINT8 modrm = FETCH();
3500         if( modrm >= 0xc0 ) {
3501                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] + XMM(modrm & 0x7).f[0];
3502                 XMM((modrm >> 3) & 0x7).f[1] = XMM((modrm >> 3) & 0x7).f[1] + XMM(modrm & 0x7).f[1];
3503                 XMM((modrm >> 3) & 0x7).f[2] = XMM((modrm >> 3) & 0x7).f[2] + XMM(modrm & 0x7).f[2];
3504                 XMM((modrm >> 3) & 0x7).f[3] = XMM((modrm >> 3) & 0x7).f[3] + XMM(modrm & 0x7).f[3];
3505         } else {
3506                 XMM_REG src;
3507                 UINT32 ea = GetEA(modrm, 0, 16);
3508                 READXMM( ea, src);
3509                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] + src.f[0];
3510                 XMM((modrm >> 3) & 0x7).f[1] = XMM((modrm >> 3) & 0x7).f[1] + src.f[1];
3511                 XMM((modrm >> 3) & 0x7).f[2] = XMM((modrm >> 3) & 0x7).f[2] + src.f[2];
3512                 XMM((modrm >> 3) & 0x7).f[3] = XMM((modrm >> 3) & 0x7).f[3] + src.f[3];
3513         }
3514         CYCLES(1);     // TODO: correct cycle count
3515 }
3516
3517  void I386_OPS_BASE::SSEOP(sqrtps_r128_rm128)() // Opcode 0f 51
3518 {
3519         UINT8 modrm = FETCH();
3520         if( modrm >= 0xc0 ) {
3521                 XMM((modrm >> 3) & 0x7).f[0] = sqrt(XMM(modrm & 0x7).f[0]);
3522                 XMM((modrm >> 3) & 0x7).f[1] = sqrt(XMM(modrm & 0x7).f[1]);
3523                 XMM((modrm >> 3) & 0x7).f[2] = sqrt(XMM(modrm & 0x7).f[2]);
3524                 XMM((modrm >> 3) & 0x7).f[3] = sqrt(XMM(modrm & 0x7).f[3]);
3525         } else {
3526                 XMM_REG src;
3527                 UINT32 ea = GetEA(modrm, 0, 16);
3528                 READXMM( ea, src);
3529                 XMM((modrm >> 3) & 0x7).f[0] = sqrt(src.f[0]);
3530                 XMM((modrm >> 3) & 0x7).f[1] = sqrt(src.f[1]);
3531                 XMM((modrm >> 3) & 0x7).f[2] = sqrt(src.f[2]);
3532                 XMM((modrm >> 3) & 0x7).f[3] = sqrt(src.f[3]);
3533         }
3534         CYCLES(1);     // TODO: correct cycle count
3535 }
3536
3537  void I386_OPS_BASE::SSEOP(rsqrtps_r128_rm128)() // Opcode 0f 52
3538 {
3539         UINT8 modrm = FETCH();
3540         if( modrm >= 0xc0 ) {
3541                 XMM((modrm >> 3) & 0x7).f[0] = 1.0 / sqrt(XMM(modrm & 0x7).f[0]);
3542                 XMM((modrm >> 3) & 0x7).f[1] = 1.0 / sqrt(XMM(modrm & 0x7).f[1]);
3543                 XMM((modrm >> 3) & 0x7).f[2] = 1.0 / sqrt(XMM(modrm & 0x7).f[2]);
3544                 XMM((modrm >> 3) & 0x7).f[3] = 1.0 / sqrt(XMM(modrm & 0x7).f[3]);
3545         } else {
3546                 XMM_REG src;
3547                 UINT32 ea = GetEA(modrm, 0, 16);
3548                 READXMM( ea, src);
3549                 XMM((modrm >> 3) & 0x7).f[0] = 1.0 / sqrt(src.f[0]);
3550                 XMM((modrm >> 3) & 0x7).f[1] = 1.0 / sqrt(src.f[1]);
3551                 XMM((modrm >> 3) & 0x7).f[2] = 1.0 / sqrt(src.f[2]);
3552                 XMM((modrm >> 3) & 0x7).f[3] = 1.0 / sqrt(src.f[3]);
3553         }
3554         CYCLES(1);     // TODO: correct cycle count
3555 }
3556
3557  void I386_OPS_BASE::SSEOP(rcpps_r128_rm128)() // Opcode 0f 53
3558 {
3559         UINT8 modrm = FETCH();
3560         if( modrm >= 0xc0 ) {
3561                 XMM((modrm >> 3) & 0x7).f[0] = 1.0f / XMM(modrm & 0x7).f[0];
3562                 XMM((modrm >> 3) & 0x7).f[1] = 1.0f / XMM(modrm & 0x7).f[1];
3563                 XMM((modrm >> 3) & 0x7).f[2] = 1.0f / XMM(modrm & 0x7).f[2];
3564                 XMM((modrm >> 3) & 0x7).f[3] = 1.0f / XMM(modrm & 0x7).f[3];
3565         } else {
3566                 XMM_REG src;
3567                 UINT32 ea = GetEA(modrm, 0, 16);
3568                 READXMM( ea, src);
3569                 XMM((modrm >> 3) & 0x7).f[0] = 1.0f / src.f[0];
3570                 XMM((modrm >> 3) & 0x7).f[1] = 1.0f / src.f[1];
3571                 XMM((modrm >> 3) & 0x7).f[2] = 1.0f / src.f[2];
3572                 XMM((modrm >> 3) & 0x7).f[3] = 1.0f / src.f[3];
3573         }
3574         CYCLES(1);     // TODO: correct cycle count
3575 }
3576
3577  void I386_OPS_BASE::SSEOP(andps_r128_rm128)() // Opcode 0f 54
3578 {
3579         UINT8 modrm = FETCH();
3580         if( modrm >= 0xc0 ) {
3581                 XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] & XMM(modrm & 0x7).q[0];
3582                 XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] & XMM(modrm & 0x7).q[1];
3583         } else {
3584                 XMM_REG src;
3585                 UINT32 ea = GetEA(modrm, 0, 16);
3586                 READXMM( ea, src);
3587                 XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] & src.q[0];
3588                 XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] & src.q[1];
3589         }
3590         CYCLES(1);     // TODO: correct cycle count
3591 }
3592
3593  void I386_OPS_BASE::SSEOP(andpd_r128_rm128)() // Opcode 66 0f 54
3594 {
3595         UINT8 modrm = FETCH();
3596         if( modrm >= 0xc0 ) {
3597                 XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] & XMM(modrm & 0x7).q[0];
3598                 XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] & XMM(modrm & 0x7).q[1];
3599         } else {
3600                 XMM_REG src;
3601                 UINT32 ea = GetEA(modrm, 0, 16);
3602                 READXMM( ea, src);
3603                 XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] & src.q[0];
3604                 XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] & src.q[1];
3605         }
3606         CYCLES(1);     // TODO: correct cycle count
3607 }
3608
3609  void I386_OPS_BASE::SSEOP(andnps_r128_rm128)() // Opcode 0f 55
3610 {
3611         UINT8 modrm = FETCH();
3612         if( modrm >= 0xc0 ) {
3613                 XMM((modrm >> 3) & 0x7).q[0] = ~(XMM((modrm >> 3) & 0x7).q[0]) & XMM(modrm & 0x7).q[0];
3614                 XMM((modrm >> 3) & 0x7).q[1] = ~(XMM((modrm >> 3) & 0x7).q[1]) & XMM(modrm & 0x7).q[1];
3615         } else {
3616                 XMM_REG src;
3617                 UINT32 ea = GetEA(modrm, 0, 16);
3618                 READXMM( ea, src);
3619                 XMM((modrm >> 3) & 0x7).q[0] = ~(XMM((modrm >> 3) & 0x7).q[0]) & src.q[0];
3620                 XMM((modrm >> 3) & 0x7).q[1] = ~(XMM((modrm >> 3) & 0x7).q[1]) & src.q[1];
3621         }
3622         CYCLES(1);     // TODO: correct cycle count
3623 }
3624
3625  void I386_OPS_BASE::SSEOP(andnpd_r128_rm128)() // Opcode 66 0f 55
3626 {
3627         UINT8 modrm = FETCH();
3628         if( modrm >= 0xc0 ) {
3629                 XMM((modrm >> 3) & 0x7).q[0] = ~(XMM((modrm >> 3) & 0x7).q[0]) & XMM(modrm & 0x7).q[0];
3630                 XMM((modrm >> 3) & 0x7).q[1] = ~(XMM((modrm >> 3) & 0x7).q[1]) & XMM(modrm & 0x7).q[1];
3631         } else {
3632                 XMM_REG src;
3633                 UINT32 ea = GetEA(modrm, 0, 16);
3634                 READXMM( ea, src);
3635                 XMM((modrm >> 3) & 0x7).q[0] = ~(XMM((modrm >> 3) & 0x7).q[0]) & src.q[0];
3636                 XMM((modrm >> 3) & 0x7).q[1] = ~(XMM((modrm >> 3) & 0x7).q[1]) & src.q[1];
3637         }
3638         CYCLES(1);     // TODO: correct cycle count
3639 }
3640
3641  void I386_OPS_BASE::SSEOP(orps_r128_rm128)() // Opcode 0f 56
3642 {
3643         UINT8 modrm = FETCH();
3644         if( modrm >= 0xc0 ) {
3645                 XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] | XMM(modrm & 0x7).q[0];
3646                 XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] | XMM(modrm & 0x7).q[1];
3647         } else {
3648                 XMM_REG src;
3649                 UINT32 ea = GetEA(modrm, 0, 16);
3650                 READXMM( ea, src);
3651                 XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] | src.q[0];
3652                 XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] | src.q[1];
3653         }
3654         CYCLES(1);     // TODO: correct cycle count
3655 }
3656
3657  void I386_OPS_BASE::SSEOP(orpd_r128_rm128)() // Opcode 66 0f 56
3658 {
3659         UINT8 modrm = FETCH();
3660         if( modrm >= 0xc0 ) {
3661                 XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] | XMM(modrm & 0x7).q[0];
3662                 XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] | XMM(modrm & 0x7).q[1];
3663         } else {
3664                 XMM_REG src;
3665                 UINT32 ea = GetEA(modrm, 0, 16);
3666                 READXMM( ea, src);
3667                 XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] | src.q[0];
3668                 XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] | src.q[1];
3669         }
3670         CYCLES(1);     // TODO: correct cycle count
3671 }
3672
3673  void I386_OPS_BASE::SSEOP(mulps)() // Opcode 0f 59 ????
3674 {
3675         UINT8 modrm = FETCH();
3676         if( modrm >= 0xc0 ) {
3677                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] * XMM(modrm & 0x7).f[0];
3678                 XMM((modrm >> 3) & 0x7).f[1] = XMM((modrm >> 3) & 0x7).f[1] * XMM(modrm & 0x7).f[1];
3679                 XMM((modrm >> 3) & 0x7).f[2] = XMM((modrm >> 3) & 0x7).f[2] * XMM(modrm & 0x7).f[2];
3680                 XMM((modrm >> 3) & 0x7).f[3] = XMM((modrm >> 3) & 0x7).f[3] * XMM(modrm & 0x7).f[3];
3681         } else {
3682                 XMM_REG src;
3683                 UINT32 ea = GetEA(modrm, 0, 16);
3684                 READXMM( ea, src);
3685                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] * src.f[0];
3686                 XMM((modrm >> 3) & 0x7).f[1] = XMM((modrm >> 3) & 0x7).f[1] * src.f[1];
3687                 XMM((modrm >> 3) & 0x7).f[2] = XMM((modrm >> 3) & 0x7).f[2] * src.f[2];
3688                 XMM((modrm >> 3) & 0x7).f[3] = XMM((modrm >> 3) & 0x7).f[3] * src.f[3];
3689         }
3690         CYCLES(1);     // TODO: correct cycle count
3691 }
3692
3693  void I386_OPS_BASE::SSEOP(subps)() // Opcode 0f 5c
3694 {
3695         UINT8 modrm = FETCH();
3696         if( modrm >= 0xc0 ) {
3697                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] - XMM(modrm & 0x7).f[0];
3698                 XMM((modrm >> 3) & 0x7).f[1] = XMM((modrm >> 3) & 0x7).f[1] - XMM(modrm & 0x7).f[1];
3699                 XMM((modrm >> 3) & 0x7).f[2] = XMM((modrm >> 3) & 0x7).f[2] - XMM(modrm & 0x7).f[2];
3700                 XMM((modrm >> 3) & 0x7).f[3] = XMM((modrm >> 3) & 0x7).f[3] - XMM(modrm & 0x7).f[3];
3701         } else {
3702                 XMM_REG src;
3703                 UINT32 ea = GetEA(modrm, 0, 16);
3704                 READXMM( ea, src);
3705                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] - src.f[0];
3706                 XMM((modrm >> 3) & 0x7).f[1] = XMM((modrm >> 3) & 0x7).f[1] - src.f[1];
3707                 XMM((modrm >> 3) & 0x7).f[2] = XMM((modrm >> 3) & 0x7).f[2] - src.f[2];
3708                 XMM((modrm >> 3) & 0x7).f[3] = XMM((modrm >> 3) & 0x7).f[3] - src.f[3];
3709         }
3710         CYCLES(1);     // TODO: correct cycle count
3711 }
3712
3713 INLINE float sse_min_single(float src1, float src2)
3714 {
3715         /*if ((src1 == 0) && (src2 == 0))
3716             return src2;
3717         if (src1 = SNaN)
3718             return src2;
3719         if (src2 = SNaN)
3720             return src2;*/
3721         if (src1 < src2)
3722                 return src1;
3723         return src2;
3724 }
3725
3726 INLINE double sse_min_double(double src1, double src2)
3727 {
3728         /*if ((src1 == 0) && (src2 == 0))
3729             return src2;
3730         if (src1 = SNaN)
3731             return src2;
3732         if (src2 = SNaN)
3733             return src2;*/
3734         if (src1 < src2)
3735                 return src1;
3736         return src2;
3737 }
3738
3739  void I386_OPS_BASE::SSEOP(minps)() // Opcode 0f 5d
3740 {
3741         UINT8 modrm = FETCH();
3742         if( modrm >= 0xc0 ) {
3743                 XMM((modrm >> 3) & 0x7).f[0] = sse_min_single(XMM((modrm >> 3) & 0x7).f[0], XMM(modrm & 0x7).f[0]);
3744                 XMM((modrm >> 3) & 0x7).f[1] = sse_min_single(XMM((modrm >> 3) & 0x7).f[1], XMM(modrm & 0x7).f[1]);
3745                 XMM((modrm >> 3) & 0x7).f[2] = sse_min_single(XMM((modrm >> 3) & 0x7).f[2], XMM(modrm & 0x7).f[2]);
3746                 XMM((modrm >> 3) & 0x7).f[3] = sse_min_single(XMM((modrm >> 3) & 0x7).f[3], XMM(modrm & 0x7).f[3]);
3747         } else {
3748                 XMM_REG src;
3749                 UINT32 ea = GetEA(modrm, 0, 16);
3750                 READXMM( ea, src);
3751                 XMM((modrm >> 3) & 0x7).f[0] = sse_min_single(XMM((modrm >> 3) & 0x7).f[0], src.f[0]);
3752                 XMM((modrm >> 3) & 0x7).f[1] = sse_min_single(XMM((modrm >> 3) & 0x7).f[1], src.f[1]);
3753                 XMM((modrm >> 3) & 0x7).f[2] = sse_min_single(XMM((modrm >> 3) & 0x7).f[2], src.f[2]);
3754                 XMM((modrm >> 3) & 0x7).f[3] = sse_min_single(XMM((modrm >> 3) & 0x7).f[3], src.f[3]);
3755         }
3756         CYCLES(1);     // TODO: correct cycle count
3757 }
3758
3759  void I386_OPS_BASE::SSEOP(divps)() // Opcode 0f 5e
3760 {
3761         UINT8 modrm = FETCH();
3762         if( modrm >= 0xc0 ) {
3763                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] / XMM(modrm & 0x7).f[0];
3764                 XMM((modrm >> 3) & 0x7).f[1] = XMM((modrm >> 3) & 0x7).f[1] / XMM(modrm & 0x7).f[1];
3765                 XMM((modrm >> 3) & 0x7).f[2] = XMM((modrm >> 3) & 0x7).f[2] / XMM(modrm & 0x7).f[2];
3766                 XMM((modrm >> 3) & 0x7).f[3] = XMM((modrm >> 3) & 0x7).f[3] / XMM(modrm & 0x7).f[3];
3767         } else {
3768                 XMM_REG src;
3769                 UINT32 ea = GetEA(modrm, 0, 16);
3770                 READXMM( ea, src);
3771                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] / src.f[0];
3772                 XMM((modrm >> 3) & 0x7).f[1] = XMM((modrm >> 3) & 0x7).f[1] / src.f[1];
3773                 XMM((modrm >> 3) & 0x7).f[2] = XMM((modrm >> 3) & 0x7).f[2] / src.f[2];
3774                 XMM((modrm >> 3) & 0x7).f[3] = XMM((modrm >> 3) & 0x7).f[3] / src.f[3];
3775         }
3776         CYCLES(1);     // TODO: correct cycle count
3777 }
3778
3779 INLINE float sse_max_single(float src1, float src2)
3780 {
3781         /*if ((src1 == 0) && (src2 == 0))
3782             return src2;
3783         if (src1 = SNaN)
3784             return src2;
3785         if (src2 = SNaN)
3786             return src2;*/
3787         if (src1 > src2)
3788                 return src1;
3789         return src2;
3790 }
3791
3792 INLINE double sse_max_double(double src1, double src2)
3793 {
3794         /*if ((src1 == 0) && (src2 == 0))
3795             return src2;
3796         if (src1 = SNaN)
3797             return src2;
3798         if (src2 = SNaN)
3799             return src2;*/
3800         if (src1 > src2)
3801                 return src1;
3802         return src2;
3803 }
3804
3805  void I386_OPS_BASE::SSEOP(maxps)() // Opcode 0f 5f
3806 {
3807         UINT8 modrm = FETCH();
3808         if( modrm >= 0xc0 ) {
3809                 XMM((modrm >> 3) & 0x7).f[0] = sse_max_single(XMM((modrm >> 3) & 0x7).f[0], XMM(modrm & 0x7).f[0]);
3810                 XMM((modrm >> 3) & 0x7).f[1] = sse_max_single(XMM((modrm >> 3) & 0x7).f[1], XMM(modrm & 0x7).f[1]);
3811                 XMM((modrm >> 3) & 0x7).f[2] = sse_max_single(XMM((modrm >> 3) & 0x7).f[2], XMM(modrm & 0x7).f[2]);
3812                 XMM((modrm >> 3) & 0x7).f[3] = sse_max_single(XMM((modrm >> 3) & 0x7).f[3], XMM(modrm & 0x7).f[3]);
3813         } else {
3814                 XMM_REG src;
3815                 UINT32 ea = GetEA(modrm, 0, 16);
3816                 READXMM( ea, src);
3817                 XMM((modrm >> 3) & 0x7).f[0] = sse_max_single(XMM((modrm >> 3) & 0x7).f[0], src.f[0]);
3818                 XMM((modrm >> 3) & 0x7).f[1] = sse_max_single(XMM((modrm >> 3) & 0x7).f[1], src.f[1]);
3819                 XMM((modrm >> 3) & 0x7).f[2] = sse_max_single(XMM((modrm >> 3) & 0x7).f[2], src.f[2]);
3820                 XMM((modrm >> 3) & 0x7).f[3] = sse_max_single(XMM((modrm >> 3) & 0x7).f[3], src.f[3]);
3821         }
3822         CYCLES(1);     // TODO: correct cycle count
3823 }
3824
3825  void I386_OPS_BASE::SSEOP(maxss_r128_r128m32)() // Opcode f3 0f 5f
3826 {
3827         UINT8 modrm = FETCH();
3828         if( modrm >= 0xc0 ) {
3829                 XMM((modrm >> 3) & 0x7).f[0] = sse_max_single(XMM((modrm >> 3) & 0x7).f[0], XMM(modrm & 0x7).f[0]);
3830         } else {
3831                 XMM_REG src;
3832                 UINT32 ea = GetEA(modrm, 0, 4);
3833                 src.d[0]=READ32(ea);
3834                 XMM((modrm >> 3) & 0x7).f[0] = sse_max_single(XMM((modrm >> 3) & 0x7).f[0], src.f[0]);
3835         }
3836         CYCLES(1);     // TODO: correct cycle count
3837 }
3838
3839  void I386_OPS_BASE::SSEOP(addss)() // Opcode f3 0f 58
3840 {
3841         UINT8 modrm = FETCH();
3842         if( modrm >= 0xc0 ) {
3843                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] + XMM(modrm & 0x7).f[0];
3844         } else {
3845                 XMM_REG src;
3846                 UINT32 ea = GetEA(modrm, 0, 16);
3847                 READXMM( ea, src);
3848                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] + src.f[0];
3849         }
3850         CYCLES(1);     // TODO: correct cycle count
3851 }
3852
3853  void I386_OPS_BASE::SSEOP(subss)() // Opcode f3 0f 5c
3854 {
3855         UINT8 modrm = FETCH();
3856         if( modrm >= 0xc0 ) {
3857                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] - XMM(modrm & 0x7).f[0];
3858         } else {
3859                 XMM_REG src;
3860                 UINT32 ea = GetEA(modrm, 0, 16);
3861                 READXMM( ea, src);
3862                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] - src.f[0];
3863         }
3864         CYCLES(1);     // TODO: correct cycle count
3865 }
3866
3867  void I386_OPS_BASE::SSEOP(mulss)() // Opcode f3 0f 5e
3868 {
3869         UINT8 modrm = FETCH();
3870         if( modrm >= 0xc0 ) {
3871                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] * XMM(modrm & 0x7).f[0];
3872         } else {
3873                 XMM_REG src;
3874                 UINT32 ea = GetEA(modrm, 0, 16);
3875                 READXMM( ea, src);
3876                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] * src.f[0];
3877         }
3878         CYCLES(1);     // TODO: correct cycle count
3879 }
3880
3881  void I386_OPS_BASE::SSEOP(divss)() // Opcode 0f 59
3882 {
3883         UINT8 modrm = FETCH();
3884         if( modrm >= 0xc0 ) {
3885                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] / XMM(modrm & 0x7).f[0];
3886         } else {
3887                 XMM_REG src;
3888                 UINT32 ea = GetEA(modrm, 0, 16);
3889                 READXMM( ea, src);
3890                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] / src.f[0];
3891         }
3892         CYCLES(1);     // TODO: correct cycle count
3893 }
3894
3895  void I386_OPS_BASE::SSEOP(rcpss_r128_r128m32)() // Opcode f3 0f 53
3896 {
3897         UINT8 modrm = FETCH();
3898         if( modrm >= 0xc0 ) {
3899                 XMM((modrm >> 3) & 0x7).f[0] = 1.0f / XMM(modrm & 0x7).f[0];
3900         } else {
3901                 XMM_REG s;
3902                 UINT32 ea = GetEA(modrm, 0, 4);
3903                 s.d[0]=READ32(ea);
3904                 XMM((modrm >> 3) & 0x7).f[0] = 1.0f / s.f[0];
3905         }
3906         CYCLES(1);     // TODO: correct cycle count
3907 }
3908
3909  void I386_OPS_BASE::SSEOP(sqrtss_r128_r128m32)() // Opcode f3 0f 51
3910 {
3911         UINT8 modrm = FETCH();
3912         if( modrm >= 0xc0 ) {
3913                 XMM((modrm >> 3) & 0x7).f[0] = sqrt(XMM(modrm & 0x7).f[0]);
3914         } else {
3915                 XMM_REG s;
3916                 UINT32 ea = GetEA(modrm, 0, 4);
3917                 s.d[0]=READ32(ea);
3918                 XMM((modrm >> 3) & 0x7).f[0] = sqrt(s.f[0]);
3919         }
3920         CYCLES(1);     // TODO: correct cycle count
3921 }
3922
3923  void I386_OPS_BASE::SSEOP(rsqrtss_r128_r128m32)() // Opcode f3 0f 52
3924 {
3925         UINT8 modrm = FETCH();
3926         if( modrm >= 0xc0 ) {
3927                 XMM((modrm >> 3) & 0x7).f[0] = 1.0 / sqrt(XMM(modrm & 0x7).f[0]);
3928         } else {
3929                 XMM_REG s;
3930                 UINT32 ea = GetEA(modrm, 0, 4);
3931                 s.d[0]=READ32(ea);
3932                 XMM((modrm >> 3) & 0x7).f[0] = 1.0 / sqrt(s.f[0]);
3933         }
3934         CYCLES(1);     // TODO: correct cycle count
3935 }
3936
3937  void I386_OPS_BASE::SSEOP(minss_r128_r128m32)() // Opcode f3 0f 5d
3938 {
3939         UINT8 modrm = FETCH();
3940         if( modrm >= 0xc0 ) {
3941                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] < XMM(modrm & 0x7).f[0] ? XMM((modrm >> 3) & 0x7).f[0] : XMM(modrm & 0x7).f[0];
3942         } else {
3943                 XMM_REG s;
3944                 UINT32 ea = GetEA(modrm, 0, 4);
3945                 s.d[0] = READ32(ea);
3946                 XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] < s.f[0] ? XMM((modrm >> 3) & 0x7).f[0] : s.f[0];
3947         }
3948         CYCLES(1);     // TODO: correct cycle count
3949 }
3950
3951  void I386_OPS_BASE::SSEOP(comiss_r128_r128m32)() // Opcode 0f 2f
3952 {
3953         float32 a,b;
3954         UINT8 modrm = FETCH();
3955         if( modrm >= 0xc0 ) {
3956                 a = XMM((modrm >> 3) & 0x7).d[0];
3957                 b = XMM(modrm & 0x7).d[0];
3958         } else {
3959                 XMM_REG src;
3960                 UINT32 ea = GetEA(modrm, 0, 16);
3961                 READXMM( ea, src);
3962                 a = XMM((modrm >> 3) & 0x7).d[0];
3963                 b = src.d[0];
3964         }
3965         cpustate->OF=0;
3966         cpustate->SF=0;
3967         cpustate->AF=0;
3968         if (float32_is_nan(a) || float32_is_nan(b))
3969         {
3970                 cpustate->ZF = 1;
3971                 cpustate->PF = 1;
3972                 cpustate->CF = 1;
3973         }
3974         else
3975         {
3976                 cpustate->ZF = 0;
3977                 cpustate->PF = 0;
3978                 cpustate->CF = 0;
3979                 if (float32_eq(a, b))
3980                         cpustate->ZF = 1;
3981                 if (float32_lt(a, b))
3982                         cpustate->CF = 1;
3983         }
3984         // should generate exception when at least one of the operands is either QNaN or SNaN
3985         CYCLES(1);     // TODO: correct cycle count
3986 }
3987
3988  void I386_OPS_BASE::SSEOP(comisd_r128_r128m64)() // Opcode 66 0f 2f
3989 {
3990         float64 a,b;
3991         UINT8 modrm = FETCH();
3992         if( modrm >= 0xc0 ) {
3993                 a = XMM((modrm >> 3) & 0x7).q[0];
3994                 b = XMM(modrm & 0x7).q[0];
3995         } else {
3996                 XMM_REG src;
3997                 UINT32 ea = GetEA(modrm, 0, 16);
3998                 READXMM( ea, src);
3999                 a = XMM((modrm >> 3) & 0x7).q[0];
4000                 b = src.q[0];
4001         }
4002         cpustate->OF=0;
4003         cpustate->SF=0;
4004         cpustate->AF=0;
4005         if (float64_is_nan(a) || float64_is_nan(b))
4006         {
4007                 cpustate->ZF = 1;
4008                 cpustate->PF = 1;
4009                 cpustate->CF = 1;
4010         }
4011         else
4012         {
4013                 cpustate->ZF = 0;
4014                 cpustate->PF = 0;
4015                 cpustate->CF = 0;
4016                 if (float64_eq(a, b))
4017                         cpustate->ZF = 1;
4018                 if (float64_lt(a, b))
4019                         cpustate->CF = 1;
4020         }
4021         // should generate exception when at least one of the operands is either QNaN or SNaN
4022         CYCLES(1);     // TODO: correct cycle count
4023 }
4024
4025  void I386_OPS_BASE::SSEOP(ucomiss_r128_r128m32)() // Opcode 0f 2e
4026 {
4027         float32 a,b;
4028         UINT8 modrm = FETCH();
4029         if( modrm >= 0xc0 ) {
4030                 a = XMM((modrm >> 3) & 0x7).d[0];
4031                 b = XMM(modrm & 0x7).d[0];
4032         } else {
4033                 XMM_REG src;
4034                 UINT32 ea = GetEA(modrm, 0, 16);
4035                 READXMM( ea, src);
4036                 a = XMM((modrm >> 3) & 0x7).d[0];
4037                 b = src.d[0];
4038         }
4039         cpustate->OF=0;
4040         cpustate->SF=0;
4041         cpustate->AF=0;
4042         if (float32_is_nan(a) || float32_is_nan(b))
4043         {
4044                 cpustate->ZF = 1;
4045                 cpustate->PF = 1;
4046                 cpustate->CF = 1;
4047         }
4048         else
4049         {
4050                 cpustate->ZF = 0;
4051                 cpustate->PF = 0;
4052                 cpustate->CF = 0;
4053                 if (float32_eq(a, b))
4054                         cpustate->ZF = 1;
4055                 if (float32_lt(a, b))
4056                         cpustate->CF = 1;
4057         }
4058         // should generate exception when at least one of the operands is SNaN
4059         CYCLES(1);     // TODO: correct cycle count
4060 }
4061
4062  void I386_OPS_BASE::SSEOP(ucomisd_r128_r128m64)() // Opcode 66 0f 2e
4063 {
4064         float64 a,b;
4065         UINT8 modrm = FETCH();
4066         if( modrm >= 0xc0 ) {
4067                 a = XMM((modrm >> 3) & 0x7).q[0];
4068                 b = XMM(modrm & 0x7).q[0];
4069         } else {
4070                 XMM_REG src;
4071                 UINT32 ea = GetEA(modrm, 0, 16);
4072                 READXMM( ea, src);
4073                 a = XMM((modrm >> 3) & 0x7).q[0];
4074                 b = src.q[0];
4075         }
4076         cpustate->OF=0;
4077         cpustate->SF=0;
4078         cpustate->AF=0;
4079         if (float64_is_nan(a) || float64_is_nan(b))
4080         {
4081                 cpustate->ZF = 1;
4082                 cpustate->PF = 1;
4083                 cpustate->CF = 1;
4084         }
4085         else
4086         {
4087                 cpustate->ZF = 0;
4088                 cpustate->PF = 0;
4089                 cpustate->CF = 0;
4090                 if (float64_eq(a, b))
4091                         cpustate->ZF = 1;
4092                 if (float64_lt(a, b))
4093                         cpustate->CF = 1;
4094         }
4095         // should generate exception when at least one of the operands is SNaN
4096         CYCLES(1);     // TODO: correct cycle count
4097 }
4098
4099  void I386_OPS_BASE::SSEOP(shufps)() // Opcode 0f c6
4100 {
4101         UINT8 modrm = FETCH();
4102         UINT8 sel = FETCH();
4103         int m1,m2,m3,m4;
4104         int s,d;
4105         m1=sel & 3;
4106         m2=(sel >> 2) & 3;
4107         m3=(sel >> 4) & 3;
4108         m4=(sel >> 6) & 3;
4109         s=modrm & 0x7;
4110         d=(modrm >> 3) & 0x7;
4111         if( modrm >= 0xc0 ) {
4112                 UINT32 t1,t2,t3,t4;
4113                 t1=XMM(d).d[m1];
4114                 t2=XMM(d).d[m2];
4115                 t3=XMM(s).d[m3];
4116                 t4=XMM(s).d[m4];
4117                 XMM(d).d[0]=t1;
4118                 XMM(d).d[1]=t2;
4119                 XMM(d).d[2]=t3;
4120                 XMM(d).d[3]=t4;
4121         } else {
4122                 UINT32 t1,t2;
4123                 XMM_REG src;
4124                 UINT32 ea = GetEA(modrm, 0, 16);
4125                 READXMM( ea, src);
4126                 t1=XMM(d).d[m1];
4127                 t2=XMM(d).d[m2];
4128                 XMM(d).d[0]=t1;
4129                 XMM(d).d[1]=t2;
4130                 XMM(d).d[2]=src.d[m3];
4131                 XMM(d).d[3]=src.d[m4];
4132         }
4133         CYCLES(1);     // TODO: correct cycle count
4134 }
4135
4136  void I386_OPS_BASE::SSEOP(shufpd_r128_rm128_i8)() // Opcode 66 0f c6
4137 {
4138         UINT8 modrm = FETCH();
4139         UINT8 sel = FETCH();
4140         int m1,m2;
4141         int s,d;
4142         m1=sel & 1;
4143         m2=(sel >> 1) & 1;
4144         s=modrm & 0x7;
4145         d=(modrm >> 3) & 0x7;
4146         if( modrm >= 0xc0 ) {
4147                 UINT64 t1,t2;
4148                 t1=XMM(d).q[m1];
4149                 t2=XMM(s).q[m2];
4150                 XMM(d).q[0]=t1;
4151                 XMM(d).q[1]=t2;
4152         } else {
4153                 UINT64 t1;
4154                 XMM_REG src;
4155                 UINT32 ea = GetEA(modrm, 0, 16);
4156                 READXMM( ea, src);
4157                 t1=XMM(d).q[m1];
4158                 XMM(d).q[0]=t1;
4159                 XMM(d).q[1]=src.q[m2];
4160         }
4161         CYCLES(1);     // TODO: correct cycle count
4162 }
4163
4164  void I386_OPS_BASE::SSEOP(unpcklps_r128_rm128)() // Opcode 0f 14
4165 {
4166         UINT8 modrm = FETCH();
4167         int s,d;
4168         UINT32 t1, t2, t3, t4;
4169         s=modrm & 0x7;
4170         d=(modrm >> 3) & 0x7;
4171         if( modrm >= 0xc0 ) {
4172                 t1 = XMM(s).d[1];
4173                 t2 = XMM(d).d[1];
4174                 t3 = XMM(s).d[0];
4175                 t4 = XMM(d).d[0];
4176                 XMM(d).d[3]=t1;
4177                 XMM(d).d[2]=t2;
4178                 XMM(d).d[1]=t3;
4179                 XMM(d).d[0]=t4;
4180         } else {
4181                 XMM_REG src;
4182                 UINT32 ea = GetEA(modrm, 0, 16);
4183                 READXMM( ea, src);
4184                 t2 = XMM(d).d[1];
4185                 XMM(d).d[3]=src.d[1];
4186                 XMM(d).d[2]=t2;
4187                 XMM(d).d[1]=src.d[0];
4188         }
4189         CYCLES(1);     // TODO: correct cycle count
4190 }
4191
4192  void I386_OPS_BASE::SSEOP(unpcklpd_r128_rm128)() // Opcode 66 0f 14
4193 {
4194         UINT8 modrm = FETCH();
4195         int s,d;
4196         s=modrm & 0x7;
4197         d=(modrm >> 3) & 0x7;
4198         if( modrm >= 0xc0 ) {
4199                 XMM(d).q[1]=XMM(s).q[0];
4200                 XMM(d).q[0]=XMM(d).q[0];
4201         } else {
4202                 XMM_REG src;
4203                 UINT32 ea = GetEA(modrm, 0, 16);
4204                 READXMM( ea, src);
4205                 XMM(d).q[1]=src.q[0];
4206                 XMM(d).q[0]=XMM(d).q[0];
4207         }
4208         CYCLES(1);     // TODO: correct cycle count
4209 }
4210
4211  void I386_OPS_BASE::SSEOP(unpckhps_r128_rm128)() // Opcode 0f 15
4212 {
4213         UINT8 modrm = FETCH();
4214         int s,d;
4215         UINT32 t1, t2, t3, t4;
4216         s=modrm & 0x7;
4217         d=(modrm >> 3) & 0x7;
4218         if( modrm >= 0xc0 ) {
4219                 t1 = XMM(d).d[2];
4220                 t2 = XMM(s).d[2];
4221                 t3 = XMM(d).d[3];
4222                 t4 = XMM(s).d[3];
4223                 XMM(d).d[0]=t1;
4224                 XMM(d).d[1]=t2;
4225                 XMM(d).d[2]=t3;
4226                 XMM(d).d[3]=t4;
4227         } else {
4228                 XMM_REG src;
4229                 UINT32 ea = GetEA(modrm, 0, 16);
4230                 READXMM( ea, src);
4231                 t1 = XMM(d).d[2];
4232                 t2 = XMM(d).d[3];
4233                 XMM(d).d[0]=t1;
4234                 XMM(d).d[1]=src.d[2];
4235                 XMM(d).d[2]=t2;
4236                 XMM(d).d[3]=src.d[3];
4237         }
4238         CYCLES(1);     // TODO: correct cycle count
4239 }
4240
4241  void I386_OPS_BASE::SSEOP(unpckhpd_r128_rm128)() // Opcode 66 0f 15
4242 {
4243         UINT8 modrm = FETCH();
4244         int s,d;
4245         s=modrm & 0x7;
4246         d=(modrm >> 3) & 0x7;
4247         if( modrm >= 0xc0 ) {
4248                 XMM(d).q[0]=XMM(d).q[1];
4249                 XMM(d).q[1]=XMM(s).q[1];
4250         } else {
4251                 XMM_REG src;
4252                 UINT32 ea = GetEA(modrm, 0, 16);
4253                 READXMM( ea, src);
4254                 XMM(d).q[0]=XMM(d).q[1];
4255                 XMM(d).q[1]=src.q[1];
4256         }
4257         CYCLES(1);     // TODO: correct cycle count
4258 }
4259
4260 INLINE bool sse_issingleordered(float op1, float op2)
4261 {
4262         // TODO: true when at least one of the two source operands being compared is a NaN
4263         return (op1 != op1) || (op1 != op2);
4264 }
4265
4266 INLINE bool sse_issingleunordered(float op1, float op2)
4267 {
4268         // TODO: true when neither source operand is a NaN
4269         return !((op1 != op1) || (op1 != op2));
4270 }
4271
4272 INLINE bool sse_isdoubleordered(double op1, double op2)
4273 {
4274         // TODO: true when at least one of the two source operands being compared is a NaN
4275         return (op1 != op1) || (op1 != op2);
4276 }
4277
4278 INLINE bool sse_isdoubleunordered(double op1, double op2)
4279 {
4280         // TODO: true when neither source operand is a NaN
4281         return !((op1 != op1) || (op1 != op2));
4282 }
4283
4284  void I386_OPS_BASE::SSEOP(predicate_compare_single)(UINT8 imm8, XMM_REG d, XMM_REG s)
4285 {
4286         switch (imm8 & 7)
4287         {
4288         case 0:
4289                 d.d[0]=d.f[0] == s.f[0] ? 0xffffffff : 0;
4290                 d.d[1]=d.f[1] == s.f[1] ? 0xffffffff : 0;
4291                 d.d[2]=d.f[2] == s.f[2] ? 0xffffffff : 0;
4292                 d.d[3]=d.f[3] == s.f[3] ? 0xffffffff : 0;
4293                 break;
4294         case 1:
4295                 d.d[0]=d.f[0] < s.f[0] ? 0xffffffff : 0;
4296                 d.d[1]=d.f[1] < s.f[1] ? 0xffffffff : 0;
4297                 d.d[2]=d.f[2] < s.f[2] ? 0xffffffff : 0;
4298                 d.d[3]=d.f[3] < s.f[3] ? 0xffffffff : 0;
4299                 break;
4300         case 2:
4301                 d.d[0]=d.f[0] <= s.f[0] ? 0xffffffff : 0;
4302                 d.d[1]=d.f[1] <= s.f[1] ? 0xffffffff : 0;
4303                 d.d[2]=d.f[2] <= s.f[2] ? 0xffffffff : 0;
4304                 d.d[3]=d.f[3] <= s.f[3] ? 0xffffffff : 0;
4305                 break;
4306         case 3:
4307                 d.d[0]=sse_issingleunordered(d.f[0], s.f[0]) ? 0xffffffff : 0;
4308                 d.d[1]=sse_issingleunordered(d.f[1], s.f[1]) ? 0xffffffff : 0;
4309                 d.d[2]=sse_issingleunordered(d.f[2], s.f[2]) ? 0xffffffff : 0;
4310                 d.d[3]=sse_issingleunordered(d.f[3], s.f[3]) ? 0xffffffff : 0;
4311                 break;
4312         case 4:
4313                 d.d[0]=d.f[0] != s.f[0] ? 0xffffffff : 0;
4314                 d.d[1]=d.f[1] != s.f[1] ? 0xffffffff : 0;
4315                 d.d[2]=d.f[2] != s.f[2] ? 0xffffffff : 0;
4316                 d.d[3]=d.f[3] != s.f[3] ? 0xffffffff : 0;
4317                 break;
4318         case 5:
4319                 d.d[0]=d.f[0] < s.f[0] ? 0 : 0xffffffff;
4320                 d.d[1]=d.f[1] < s.f[1] ? 0 : 0xffffffff;
4321                 d.d[2]=d.f[2] < s.f[2] ? 0 : 0xffffffff;
4322                 d.d[3]=d.f[3] < s.f[3] ? 0 : 0xffffffff;
4323                 break;
4324         case 6:
4325                 d.d[0]=d.f[0] <= s.f[0] ? 0 : 0xffffffff;
4326                 d.d[1]=d.f[1] <= s.f[1] ? 0 : 0xffffffff;
4327                 d.d[2]=d.f[2] <= s.f[2] ? 0 : 0xffffffff;
4328                 d.d[3]=d.f[3] <= s.f[3] ? 0 : 0xffffffff;
4329                 break;
4330         case 7:
4331                 d.d[0]=sse_issingleordered(d.f[0], s.f[0]) ? 0xffffffff : 0;
4332                 d.d[1]=sse_issingleordered(d.f[1], s.f[1]) ? 0xffffffff : 0;
4333                 d.d[2]=sse_issingleordered(d.f[2], s.f[2]) ? 0xffffffff : 0;
4334                 d.d[3]=sse_issingleordered(d.f[3], s.f[3]) ? 0xffffffff : 0;
4335                 break;
4336         }
4337 }
4338
4339  void I386_OPS_BASE::SSEOP(predicate_compare_double)(UINT8 imm8, XMM_REG d, XMM_REG s)
4340 {
4341         switch (imm8 & 7)
4342         {
4343         case 0:
4344                 d.q[0]=d.f64[0] == s.f64[0] ? U64(0xffffffffffffffff) : 0;
4345                 d.q[1]=d.f64[1] == s.f64[1] ? U64(0xffffffffffffffff) : 0;
4346                 break;
4347         case 1:
4348                 d.q[0]=d.f64[0] < s.f64[0] ? U64(0xffffffffffffffff) : 0;
4349                 d.q[1]=d.f64[1] < s.f64[1] ? U64(0xffffffffffffffff) : 0;
4350                 break;
4351         case 2:
4352                 d.q[0]=d.f64[0] <= s.f64[0] ? U64(0xffffffffffffffff) : 0;
4353                 d.q[1]=d.f64[1] <= s.f64[1] ? U64(0xffffffffffffffff) : 0;
4354                 break;
4355         case 3:
4356                 d.q[0]=sse_isdoubleunordered(d.f64[0], s.f64[0]) ? U64(0xffffffffffffffff) : 0;
4357                 d.q[1]=sse_isdoubleunordered(d.f64[1], s.f64[1]) ? U64(0xffffffffffffffff) : 0;
4358                 break;
4359         case 4:
4360                 d.q[0]=d.f64[0] != s.f64[0] ? U64(0xffffffffffffffff) : 0;
4361                 d.q[1]=d.f64[1] != s.f64[1] ? U64(0xffffffffffffffff) : 0;
4362                 break;
4363         case 5:
4364                 d.q[0]=d.f64[0] < s.f64[0] ? 0 : U64(0xffffffffffffffff);
4365                 d.q[1]=d.f64[1] < s.f64[1] ? 0 : U64(0xffffffffffffffff);
4366                 break;
4367         case 6:
4368                 d.q[0]=d.f64[0] <= s.f64[0] ? 0 : U64(0xffffffffffffffff);
4369                 d.q[1]=d.f64[1] <= s.f64[1] ? 0 : U64(0xffffffffffffffff);
4370                 break;
4371         case 7:
4372                 d.q[0]=sse_isdoubleordered(d.f64[0], s.f64[0]) ? U64(0xffffffffffffffff) : 0;
4373                 d.q[1]=sse_isdoubleordered(d.f64[1], s.f64[1]) ? U64(0xffffffffffffffff) : 0;
4374                 break;
4375         }
4376 }
4377
4378  void I386_OPS_BASE::SSEOP(predicate_compare_single_scalar)(UINT8 imm8, XMM_REG d, XMM_REG s)
4379 {
4380         switch (imm8 & 7)
4381         {
4382         case 0:
4383                 d.d[0]=d.f[0] == s.f[0] ? 0xffffffff : 0;
4384                 break;
4385         case 1:
4386                 d.d[0]=d.f[0] < s.f[0] ? 0xffffffff : 0;
4387                 break;
4388         case 2:
4389                 d.d[0]=d.f[0] <= s.f[0] ? 0xffffffff : 0;
4390                 break;
4391         case 3:
4392                 d.d[0]=sse_issingleunordered(d.f[0], s.f[0]) ? 0xffffffff : 0;
4393                 break;
4394         case 4:
4395                 d.d[0]=d.f[0] != s.f[0] ? 0xffffffff : 0;
4396                 break;
4397         case 5:
4398                 d.d[0]=d.f[0] < s.f[0] ? 0 : 0xffffffff;
4399                 break;
4400         case 6:
4401                 d.d[0]=d.f[0] <= s.f[0] ? 0 : 0xffffffff;
4402                 break;
4403         case 7:
4404                 d.d[0]=sse_issingleordered(d.f[0], s.f[0]) ? 0xffffffff : 0;
4405                 break;
4406         }
4407 }
4408
4409  void I386_OPS_BASE::SSEOP(predicate_compare_double_scalar)(UINT8 imm8, XMM_REG d, XMM_REG s)
4410 {
4411         switch (imm8 & 7)
4412         {
4413         case 0:
4414                 d.q[0]=d.f64[0] == s.f64[0] ? 0xffffffffffffffff : 0;
4415                 break;
4416         case 1:
4417                 d.q[0]=d.f64[0] < s.f64[0] ? 0xffffffffffffffff : 0;
4418                 break;
4419         case 2:
4420                 d.q[0]=d.f64[0] <= s.f64[0] ? 0xffffffffffffffff : 0;
4421                 break;
4422         case 3:
4423                 d.q[0]=sse_isdoubleunordered(d.f64[0], s.f64[0]) ? 0xffffffffffffffff : 0;
4424                 break;
4425         case 4:
4426                 d.q[0]=d.f64[0] != s.f64[0] ? 0xffffffffffffffff : 0;
4427                 break;
4428         case 5:
4429                 d.q[0]=d.f64[0] < s.f64[0] ? 0 : 0xffffffffffffffff;
4430                 break;
4431         case 6:
4432                 d.q[0]=d.f64[0] <= s.f64[0] ? 0 : 0xffffffffffffffff;
4433                 break;
4434         case 7:
4435                 d.q[0]=sse_isdoubleordered(d.f64[0], s.f64[0]) ? 0xffffffffffffffff : 0;
4436                 break;
4437         }
4438 }
4439
4440  void I386_OPS_BASE::SSEOP(cmpps_r128_rm128_i8)() // Opcode 0f c2
4441 {
4442         UINT8 modrm = FETCH();
4443         if( modrm >= 0xc0 ) {
4444                 int s,d;
4445                 UINT8 imm8 = FETCH();
4446                 s=modrm & 0x7;
4447                 d=(modrm >> 3) & 0x7;
4448                 sse_predicate_compare_single(imm8, XMM(d), XMM(s));
4449         } else {
4450                 int d;
4451                 XMM_REG s;
4452                 UINT32 ea = GetEA(modrm, 0, 16);
4453                 UINT8 imm8 = FETCH();
4454                 READXMM( ea, s);
4455                 d=(modrm >> 3) & 0x7;
4456                 sse_predicate_compare_single(imm8, XMM(d), s);
4457         }
4458         CYCLES(1);     // TODO: correct cycle count
4459 }
4460
4461  void I386_OPS_BASE::SSEOP(cmppd_r128_rm128_i8)() // Opcode 66 0f c2
4462 {
4463         UINT8 modrm = FETCH();
4464         if( modrm >= 0xc0 ) {
4465                 int s,d;
4466                 UINT8 imm8 = FETCH();
4467                 s=modrm & 0x7;
4468                 d=(modrm >> 3) & 0x7;
4469                 sse_predicate_compare_double(imm8, XMM(d), XMM(s));
4470         } else {
4471                 int d;
4472                 XMM_REG s;
4473                 UINT32 ea = GetEA(modrm, 0, 16);
4474                 UINT8 imm8 = FETCH();
4475                 READXMM( ea, s);
4476                 d=(modrm >> 3) & 0x7;
4477                 sse_predicate_compare_double(imm8, XMM(d), s);
4478         }
4479         CYCLES(1);     // TODO: correct cycle count
4480 }
4481
4482  void I386_OPS_BASE::SSEOP(cmpss_r128_r128m32_i8)() // Opcode f3 0f c2
4483 {
4484         UINT8 modrm = FETCH();
4485         if( modrm >= 0xc0 ) {
4486                 int s,d;
4487                 UINT8 imm8 = FETCH();
4488                 s=modrm & 0x7;
4489                 d=(modrm >> 3) & 0x7;
4490                 sse_predicate_compare_single_scalar(imm8, XMM(d), XMM(s));
4491         } else {
4492                 int d;
4493                 XMM_REG s;
4494                 UINT32 ea = GetEA(modrm, 0, 4);
4495                 UINT8 imm8 = FETCH();
4496                 s.d[0]=READ32(ea);
4497                 d=(modrm >> 3) & 0x7;
4498                 sse_predicate_compare_single_scalar(imm8, XMM(d), s);
4499         }
4500         CYCLES(1);     // TODO: correct cycle count
4501 }
4502
4503  void I386_OPS_BASE::SSEOP(pinsrw_r64_r16m16_i8)() // Opcode 0f c4, 16bit register
4504 {
4505         MMXPROLOG();
4506         UINT8 modrm = FETCH();
4507         if( modrm >= 0xc0 ) {
4508                 UINT8 imm8 = FETCH();
4509                 UINT16 v = LOAD_RM16(modrm);
4510                 if (cpustate->xmm_operand_size)
4511                         XMM((modrm >> 3) & 0x7).w[imm8 & 7] = v;
4512                 else
4513                         MMX((modrm >> 3) & 0x7).w[imm8 & 3] = v;
4514         } else {
4515                 UINT32 ea = GetEA(modrm, 0, 2);
4516                 UINT8 imm8 = FETCH();
4517                 UINT16 v = READ16(ea);
4518                 if (cpustate->xmm_operand_size)
4519                         XMM((modrm >> 3) & 0x7).w[imm8 & 7] = v;
4520                 else
4521                         MMX((modrm >> 3) & 0x7).w[imm8 & 3] = v;
4522         }
4523         CYCLES(1);     // TODO: correct cycle count
4524 }
4525
4526  void I386_OPS_BASE::SSEOP(pinsrw_r64_r32m16_i8)() // Opcode 0f c4, 32bit register
4527 {
4528         MMXPROLOG();
4529         UINT8 modrm = FETCH();
4530         if( modrm >= 0xc0 ) {
4531                 UINT8 imm8 = FETCH();
4532                 UINT16 v = (UINT16)LOAD_RM32(modrm);
4533                 MMX((modrm >> 3) & 0x7).w[imm8 & 3] = v;
4534         } else {
4535                 UINT32 ea = GetEA(modrm, 0, 2);
4536                 UINT8 imm8 = FETCH();
4537                 UINT16 v = READ16(ea);
4538                 MMX((modrm >> 3) & 0x7).w[imm8 & 3] = v;
4539         }
4540         CYCLES(1);     // TODO: correct cycle count
4541 }
4542
4543  void I386_OPS_BASE::SSEOP(pinsrw_r128_r32m16_i8)() // Opcode 66 0f c4
4544 {
4545         UINT8 modrm = FETCH();
4546         if (modrm >= 0xc0) {
4547                 UINT8 imm8 = FETCH();
4548                 UINT16 v = (UINT16)LOAD_RM32(modrm);
4549                 XMM((modrm >> 3) & 0x7).w[imm8 & 7] = v;
4550         }
4551         else {
4552                 UINT32 ea = GetEA(modrm, 0, 2);
4553                 UINT8 imm8 = FETCH();
4554                 UINT16 v = READ16(ea);
4555                 XMM((modrm >> 3) & 0x7).w[imm8 & 7] = v;
4556         }
4557         CYCLES(1);     // TODO: correct cycle count
4558 }
4559
4560  void I386_OPS_BASE::SSEOP(pextrw_r16_r64_i8)() // Opcode 0f c5
4561 {
4562         //MMXPROLOG();
4563         UINT8 modrm = FETCH();
4564         if( modrm >= 0xc0 ) {
4565                 UINT8 imm8 = FETCH();
4566                 if (cpustate->xmm_operand_size)
4567                         STORE_REG16(modrm, XMM(modrm & 0x7).w[imm8 & 7]);
4568                 else
4569                         STORE_REG16(modrm, MMX(modrm & 0x7).w[imm8 & 3]);
4570         } else {
4571                 //UINT8 imm8 = FETCH();
4572                 report_invalid_modrm( "pextrw_r16_r64_i8", modrm);
4573         }
4574         CYCLES(1);     // TODO: correct cycle count
4575 }
4576
4577  void I386_OPS_BASE::SSEOP(pextrw_r32_r64_i8)() // Opcode 0f c5
4578 {
4579         //MMXPROLOG();
4580         UINT8 modrm = FETCH();
4581         if( modrm >= 0xc0 ) {
4582                 UINT8 imm8 = FETCH();
4583                 STORE_REG32(modrm, MMX(modrm & 0x7).w[imm8 & 3]);
4584         } else {
4585                 //UINT8 imm8 = FETCH();
4586                 report_invalid_modrm( "pextrw_r32_r64_i8", modrm);
4587         }
4588         CYCLES(1);     // TODO: correct cycle count
4589 }
4590
4591  void I386_OPS_BASE::SSEOP(pextrw_reg_r128_i8)() // Opcode 66 0f c5
4592 {
4593         UINT8 modrm = FETCH();
4594         if (modrm >= 0xc0) {
4595                 UINT8 imm8 = FETCH();
4596                 STORE_REG32(modrm, XMM(modrm & 0x7).w[imm8 & 7]);
4597         }
4598         else {
4599                 //UINT8 imm8 = FETCH();
4600                 report_invalid_modrm( "sse_pextrw_reg_r128_i8", modrm);
4601         }
4602         CYCLES(1);     // TODO: correct cycle count
4603 }
4604
4605  void I386_OPS_BASE::SSEOP(pminub_r64_rm64)() // Opcode 0f da
4606 {
4607         int n;
4608         MMXPROLOG();
4609         UINT8 modrm = FETCH();
4610         if( modrm >= 0xc0 ) {
4611                 for (n=0;n < 8;n++)
4612                         MMX((modrm >> 3) & 0x7).b[n] = MMX((modrm >> 3) & 0x7).b[n] < MMX(modrm & 0x7).b[n] ? MMX((modrm >> 3) & 0x7).b[n] : MMX(modrm & 0x7).b[n];
4613         } else {
4614                 MMX_REG s;
4615                 UINT32 ea = GetEA(modrm, 0, 8);
4616                 READMMX( ea, s);
4617                 for (n=0;n < 8;n++)
4618                         MMX((modrm >> 3) & 0x7).b[n] = MMX((modrm >> 3) & 0x7).b[n] < s.b[n] ? MMX((modrm >> 3) & 0x7).b[n] : s.b[n];
4619         }
4620         CYCLES(1);     // TODO: correct cycle count
4621 }
4622
4623  void I386_OPS_BASE::SSEOP(pminub_r128_rm128)() // Opcode 66 0f da
4624 {
4625         UINT8 modrm = FETCH();
4626         if( modrm >= 0xc0 ) {
4627                 for (int n=0;n < 16;n++)
4628                         XMM((modrm >> 3) & 0x7).b[n] = XMM((modrm >> 3) & 0x7).b[n] < XMM(modrm & 0x7).b[n] ? XMM((modrm >> 3) & 0x7).b[n] : XMM(modrm & 0x7).b[n];
4629         } else {
4630                 XMM_REG s;
4631                 UINT32 ea = GetEA(modrm, 0, 16);
4632                 READXMM( ea, s);
4633                 for (int n=0;n < 16;n++)
4634                         XMM((modrm >> 3) & 0x7).b[n] = XMM((modrm >> 3) & 0x7).b[n] < s.b[n] ? XMM((modrm >> 3) & 0x7).b[n] : s.b[n];
4635         }
4636         CYCLES(1);     // TODO: correct cycle count
4637 }
4638
4639  void I386_OPS_BASE::SSEOP(pmaxub_r64_rm64)() // Opcode 0f de
4640 {
4641         int n;
4642         MMXPROLOG();
4643         UINT8 modrm = FETCH();
4644         if( modrm >= 0xc0 ) {
4645                 for (n=0;n < 8;n++)
4646                         MMX((modrm >> 3) & 0x7).b[n] = MMX((modrm >> 3) & 0x7).b[n] > MMX(modrm & 0x7).b[n] ? MMX((modrm >> 3) & 0x7).b[n] : MMX(modrm & 0x7).b[n];
4647         } else {
4648                 MMX_REG s;
4649                 UINT32 ea = GetEA(modrm, 0, 8);
4650                 READMMX( ea, s);
4651                 for (n=0;n < 8;n++)
4652                         MMX((modrm >> 3) & 0x7).b[n] = MMX((modrm >> 3) & 0x7).b[n] > s.b[n] ? MMX((modrm >> 3) & 0x7).b[n] : s.b[n];
4653         }
4654         CYCLES(1);     // TODO: correct cycle count
4655 }
4656
4657  void I386_OPS_BASE::SSEOP(pavgb_r64_rm64)() // Opcode 0f e0
4658 {
4659         int n;
4660         MMXPROLOG();
4661         UINT8 modrm = FETCH();
4662         if( modrm >= 0xc0 ) {
4663                 for (n=0;n < 8;n++)
4664                         MMX((modrm >> 3) & 0x7).b[n] = ((UINT16)MMX((modrm >> 3) & 0x7).b[n] + (UINT16)MMX(modrm & 0x7).b[n] + 1) >> 1;
4665         } else {
4666                 MMX_REG s;
4667                 UINT32 ea = GetEA(modrm, 0, 8);
4668                 READMMX( ea, s);
4669                 for (n=0;n < 8;n++)
4670                         MMX((modrm >> 3) & 0x7).b[n] = ((UINT16)MMX((modrm >> 3) & 0x7).b[n] + (UINT16)s.b[n] + 1) >> 1;
4671         }
4672         CYCLES(1);     // TODO: correct cycle count
4673 }
4674
4675  void I386_OPS_BASE::SSEOP(pavgw_r64_rm64)() // Opcode 0f e3
4676 {
4677         int n;
4678         MMXPROLOG();
4679         UINT8 modrm = FETCH();
4680         if( modrm >= 0xc0 ) {
4681                 for (n=0;n < 4;n++)
4682                         MMX((modrm >> 3) & 0x7).w[n] = ((UINT32)MMX((modrm >> 3) & 0x7).w[n] + (UINT32)MMX(modrm & 0x7).w[n] + 1) >> 1;
4683         } else {
4684                 MMX_REG s;
4685                 UINT32 ea = GetEA(modrm, 0, 8);
4686                 READMMX( ea, s);
4687                 for (n=0;n < 4;n++)
4688                         MMX((modrm >> 3) & 0x7).w[n] = ((UINT32)MMX((modrm >> 3) & 0x7).w[n] + (UINT32)s.w[n] + 1) >> 1;
4689         }
4690         CYCLES(1);     // TODO: correct cycle count
4691 }
4692
4693  void I386_OPS_BASE::SSEOP(pmulhuw_r64_rm64)()  // Opcode 0f e4
4694 {
4695         MMXPROLOG();
4696         UINT8 modrm = FETCH();
4697         if( modrm >= 0xc0 ) {
4698                 MMX((modrm >> 3) & 0x7).w[0]=((UINT32)MMX((modrm >> 3) & 0x7).w[0]*(UINT32)MMX(modrm & 7).w[0]) >> 16;
4699                 MMX((modrm >> 3) & 0x7).w[1]=((UINT32)MMX((modrm >> 3) & 0x7).w[1]*(UINT32)MMX(modrm & 7).w[1]) >> 16;
4700                 MMX((modrm >> 3) & 0x7).w[2]=((UINT32)MMX((modrm >> 3) & 0x7).w[2]*(UINT32)MMX(modrm & 7).w[2]) >> 16;
4701                 MMX((modrm >> 3) & 0x7).w[3]=((UINT32)MMX((modrm >> 3) & 0x7).w[3]*(UINT32)MMX(modrm & 7).w[3]) >> 16;
4702         } else {
4703                 MMX_REG s;
4704                 UINT32 ea = GetEA(modrm, 0, 8);
4705                 READMMX( ea, s);
4706                 MMX((modrm >> 3) & 0x7).w[0]=((UINT32)MMX((modrm >> 3) & 0x7).w[0]*(UINT32)s.w[0]) >> 16;
4707                 MMX((modrm >> 3) & 0x7).w[1]=((UINT32)MMX((modrm >> 3) & 0x7).w[1]*(UINT32)s.w[1]) >> 16;
4708                 MMX((modrm >> 3) & 0x7).w[2]=((UINT32)MMX((modrm >> 3) & 0x7).w[2]*(UINT32)s.w[2]) >> 16;
4709                 MMX((modrm >> 3) & 0x7).w[3]=((UINT32)MMX((modrm >> 3) & 0x7).w[3]*(UINT32)s.w[3]) >> 16;
4710         }
4711         CYCLES(1);     // TODO: correct cycle count
4712 }
4713
4714  void I386_OPS_BASE::SSEOP(pminsw_r64_rm64)() // Opcode 0f ea
4715 {
4716         int n;
4717         MMXPROLOG();
4718         UINT8 modrm = FETCH();
4719         if( modrm >= 0xc0 ) {
4720                 for (n=0;n < 4;n++)
4721                         MMX((modrm >> 3) & 0x7).s[n] = MMX((modrm >> 3) & 0x7).s[n] < MMX(modrm & 0x7).s[n] ? MMX((modrm >> 3) & 0x7).s[n] : MMX(modrm & 0x7).s[n];
4722         } else {
4723                 MMX_REG s;
4724                 UINT32 ea = GetEA(modrm, 0, 8);
4725                 READMMX( ea, s);
4726                 for (n=0;n < 4;n++)
4727                         MMX((modrm >> 3) & 0x7).s[n] = MMX((modrm >> 3) & 0x7).s[n] < s.s[n] ? MMX((modrm >> 3) & 0x7).s[n] : s.s[n];
4728         }
4729         CYCLES(1);     // TODO: correct cycle count
4730 }
4731
4732  void I386_OPS_BASE::SSEOP(pmaxsw_r64_rm64)() // Opcode 0f ee
4733 {
4734         int n;
4735         MMXPROLOG();
4736         UINT8 modrm = FETCH();
4737         if( modrm >= 0xc0 ) {
4738                 for (n=0;n < 4;n++)
4739                         MMX((modrm >> 3) & 0x7).s[n] = MMX((modrm >> 3) & 0x7).s[n] > MMX(modrm & 0x7).s[n] ? MMX((modrm >> 3) & 0x7).s[n] : MMX(modrm & 0x7).s[n];
4740         } else {
4741                 MMX_REG s;
4742                 UINT32 ea = GetEA(modrm, 0, 8);
4743                 READMMX( ea, s);
4744                 for (n=0;n < 4;n++)
4745                         MMX((modrm >> 3) & 0x7).s[n] = MMX((modrm >> 3) & 0x7).s[n] > s.s[n] ? MMX((modrm >> 3) & 0x7).s[n] : s.s[n];
4746         }
4747         CYCLES(1);     // TODO: correct cycle count
4748 }
4749
4750  void I386_OPS_BASE::SSEOP(pmuludq_r64_rm64)() // Opcode 0f f4
4751 {
4752         MMXPROLOG();
4753         UINT8 modrm = FETCH();
4754         if( modrm >= 0xc0 ) {
4755                 MMX((modrm >> 3) & 0x7).q = (UINT64)MMX((modrm >> 3) & 0x7).d[0] * (UINT64)MMX(modrm & 0x7).d[0];
4756         } else {
4757                 MMX_REG s;
4758                 UINT32 ea = GetEA(modrm, 0, 8);
4759                 READMMX( ea, s);
4760                 MMX((modrm >> 3) & 0x7).q = (UINT64)MMX((modrm >> 3) & 0x7).d[0] * (UINT64)s.d[0];
4761         }
4762         CYCLES(1);     // TODO: correct cycle count
4763 }
4764
4765  void I386_OPS_BASE::SSEOP(pmuludq_r128_rm128)() // Opcode 66 0f f4
4766 {
4767         UINT8 modrm = FETCH();
4768         if( modrm >= 0xc0 ) {
4769                 XMM((modrm >> 3) & 0x7).q[0] = (UINT64)XMM((modrm >> 3) & 0x7).d[0] * (UINT64)XMM(modrm & 0x7).d[0];
4770                 XMM((modrm >> 3) & 0x7).q[1] = (UINT64)XMM((modrm >> 3) & 0x7).d[2] * (UINT64)XMM(modrm & 0x7).d[2];
4771         } else {
4772                 XMM_REG s;
4773                 UINT32 ea = GetEA(modrm, 0, 16);
4774                 READXMM( ea, s);
4775                 XMM((modrm >> 3) & 0x7).q[0] = (UINT64)XMM((modrm >> 3) & 0x7).d[0] * (UINT64)s.d[0];
4776                 XMM((modrm >> 3) & 0x7).q[1] = (UINT64)XMM((modrm >> 3) & 0x7).d[2] * (UINT64)s.d[2];
4777         }
4778         CYCLES(1);     // TODO: correct cycle count
4779 }
4780
4781  void I386_OPS_BASE::SSEOP(psadbw_r64_rm64)() // Opcode 0f f6
4782 {
4783         int n;
4784         INT32 temp;
4785         MMXPROLOG();
4786         UINT8 modrm = FETCH();
4787         if( modrm >= 0xc0 ) {
4788                 temp=0;
4789                 for (n=0;n < 8;n++)
4790                         temp += abs((INT32)MMX((modrm >> 3) & 0x7).b[n] - (INT32)MMX(modrm & 0x7).b[n]);
4791                 MMX((modrm >> 3) & 0x7).l=(UINT64)temp & 0xffff;
4792         } else {
4793                 MMX_REG s;
4794                 UINT32 ea = GetEA(modrm, 0, 8);
4795                 READMMX( ea, s);
4796                 temp=0;
4797                 for (n=0;n < 8;n++)
4798                         temp += abs((INT32)MMX((modrm >> 3) & 0x7).b[n] - (INT32)s.b[n]);
4799                 MMX((modrm >> 3) & 0x7).l=(UINT64)temp & 0xffff;
4800         }
4801         CYCLES(1);     // TODO: correct cycle count
4802 }
4803
4804  void I386_OPS_BASE::SSEOP(psubq_r64_rm64)()  // Opcode 0f fb
4805 {
4806         MMXPROLOG();
4807         UINT8 modrm = FETCH();
4808         if( modrm >= 0xc0 ) {
4809                 MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q - MMX(modrm & 7).q;
4810         } else {
4811                 MMX_REG s;
4812                 UINT32 ea = GetEA(modrm, 0, 8);
4813                 READMMX( ea, s);
4814                 MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q - s.q;
4815         }
4816         CYCLES(1);     // TODO: correct cycle count
4817 }
4818
4819  void I386_OPS_BASE::SSEOP(psubq_r128_rm128)()  // Opcode 66 0f fb
4820 {
4821         UINT8 modrm = FETCH();
4822         if( modrm >= 0xc0 ) {
4823                 XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] - XMM(modrm & 7).q[0];
4824                 XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] - XMM(modrm & 7).q[1];
4825         } else {
4826                 XMM_REG s;
4827                 UINT32 ea = GetEA(modrm, 0, 16);
4828                 READXMM( ea, s);
4829                 XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] - s.q[0];
4830                 XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] - s.q[1];
4831         }
4832         CYCLES(1);     // TODO: correct cycle count
4833 }
4834
4835  void I386_OPS_BASE::SSEOP(pshufd_r128_rm128_i8)() // Opcode 66 0f 70
4836 {
4837         UINT8 modrm = FETCH();
4838         if( modrm >= 0xc0 ) {
4839                 XMM_REG t;
4840                 int s,d;
4841                 UINT8 imm8 = FETCH();
4842                 s=modrm & 0x7;
4843                 d=(modrm >> 3) & 0x7;
4844                 t.q[0]=XMM(s).q[0];
4845                 t.q[1]=XMM(s).q[1];
4846                 XMM(d).d[0]=t.d[imm8 & 3];
4847                 XMM(d).d[1]=t.d[(imm8 >> 2) & 3];
4848                 XMM(d).d[2]=t.d[(imm8 >> 4) & 3];
4849                 XMM(d).d[3]=t.d[(imm8 >> 6) & 3];
4850         } else {
4851                 XMM_REG s;
4852                 int d=(modrm >> 3) & 0x7;
4853                 UINT32 ea = GetEA(modrm, 0, 16);
4854                 UINT8 imm8 = FETCH();
4855                 READXMM( ea, s);
4856                 XMM(d).d[0]=s.d[(imm8 & 3)];
4857                 XMM(d).d[1]=s.d[((imm8 >> 2) & 3)];
4858                 XMM(d).d[2]=s.d[((imm8 >> 4) & 3)];
4859                 XMM(d).d[3]=s.d[((imm8 >> 6) & 3)];
4860         }
4861         CYCLES(1);     // TODO: correct cycle count
4862 }
4863
4864  void I386_OPS_BASE::SSEOP(pshuflw_r128_rm128_i8)() // Opcode f2 0f 70
4865 {
4866         UINT8 modrm = FETCH();
4867         if( modrm >= 0xc0 ) {
4868                 XMM_REG t;
4869                 int s,d;
4870                 UINT8 imm8 = FETCH();
4871                 s=modrm & 0x7;
4872                 d=(modrm >> 3) & 0x7;
4873                 t.q[0]=XMM(s).q[0];
4874                 XMM(d).q[1]=XMM(s).q[1];
4875                 XMM(d).w[0]=t.w[imm8 & 3];
4876                 XMM(d).w[1]=t.w[(imm8 >> 2) & 3];
4877                 XMM(d).w[2]=t.w[(imm8 >> 4) & 3];
4878                 XMM(d).w[3]=t.w[(imm8 >> 6) & 3];
4879         } else {
4880                 XMM_REG s;
4881                 int d=(modrm >> 3) & 0x7;
4882                 UINT32 ea = GetEA(modrm, 0, 16);
4883                 UINT8 imm8 = FETCH();
4884                 READXMM( ea, s);
4885                 XMM(d).q[1]=s.q[1];
4886                 XMM(d).w[0]=s.w[imm8 & 3];
4887                 XMM(d).w[1]=s.w[(imm8 >> 2) & 3];
4888                 XMM(d).w[2]=s.w[(imm8 >> 4) & 3];
4889                 XMM(d).w[3]=s.w[(imm8 >> 6) & 3];
4890         }
4891         CYCLES(1);     // TODO: correct cycle count
4892 }
4893
4894  void I386_OPS_BASE::SSEOP(pshufhw_r128_rm128_i8)() // Opcode f3 0f 70
4895 {
4896         UINT8 modrm = FETCH();
4897         if( modrm >= 0xc0 ) {
4898                 XMM_REG t;
4899                 int s,d;
4900                 UINT8 imm8 = FETCH();
4901                 s=modrm & 0x7;
4902                 d=(modrm >> 3) & 0x7;
4903                 t.q[0]=XMM(s).q[1];
4904                 XMM(d).q[0]=XMM(s).q[0];
4905                 XMM(d).w[4]=t.w[imm8 & 3];
4906                 XMM(d).w[5]=t.w[(imm8 >> 2) & 3];
4907                 XMM(d).w[6]=t.w[(imm8 >> 4) & 3];
4908                 XMM(d).w[7]=t.w[(imm8 >> 6) & 3];
4909         } else {
4910                 XMM_REG s;
4911                 int d=(modrm >> 3) & 0x7;
4912                 UINT32 ea = GetEA(modrm, 0, 16);
4913                 UINT8 imm8 = FETCH();
4914                 READXMM( ea, s);
4915                 XMM(d).q[0]=s.q[0];
4916                 XMM(d).w[4]=s.w[4 + (imm8 & 3)];
4917                 XMM(d).w[5]=s.w[4 + ((imm8 >> 2) & 3)];
4918                 XMM(d).w[6]=s.w[4 + ((imm8 >> 4) & 3)];
4919                 XMM(d).w[7]=s.w[4 + ((imm8 >> 6) & 3)];
4920         }
4921         CYCLES(1);     // TODO: correct cycle count
4922 }
4923
4924  void I386_OPS_BASE::SSEOP(packsswb_r128_rm128)() // Opcode 66 0f 63
4925 {
4926         UINT8 modrm = FETCH();
4927         if (modrm >= 0xc0) {
4928                 XMM_REG t;
4929                 int s, d;
4930                 s = modrm & 0x7;
4931                 d = (modrm >> 3) & 0x7;
4932                 t.q[0] = XMM(s).q[0];
4933                 t.q[1] = XMM(s).q[1];
4934                 for (int n = 0; n < 8; n++)
4935                         XMM(d).c[n] = SaturatedSignedWordToSignedByte(XMM(d).s[n]);
4936                 for (int n = 0; n < 8; n++)
4937                         XMM(d).c[n+8] = SaturatedSignedWordToSignedByte(t.s[n]);
4938         }
4939         else {
4940                 XMM_REG s;
4941                 int d = (modrm >> 3) & 0x7;
4942                 UINT32 ea = GetEA(modrm, 0, 16);
4943                 READXMM( ea, s);
4944                 for (int n = 0; n < 8; n++)
4945                         XMM(d).c[n] = SaturatedSignedWordToSignedByte(XMM(d).s[n]);
4946                 for (int n = 0; n < 8; n++)
4947                         XMM(d).c[n + 8] = SaturatedSignedWordToSignedByte(s.s[n]);
4948         }
4949         CYCLES(1);     // TODO: correct cycle count
4950 }
4951
4952  void I386_OPS_BASE::SSEOP(packssdw_r128_rm128)() // Opcode 66 0f 6b
4953 {
4954         UINT8 modrm = FETCH();
4955         if (modrm >= 0xc0) {
4956                 XMM_REG t;
4957                 int s, d;
4958                 s = modrm & 0x7;
4959                 d = (modrm >> 3) & 0x7;
4960                 t.q[0] = XMM(s).q[0];
4961                 t.q[1] = XMM(s).q[1];
4962                 XMM(d).s[0] = SaturatedSignedDwordToSignedWord(XMM(d).i[0]);
4963                 XMM(d).s[1] = SaturatedSignedDwordToSignedWord(XMM(d).i[1]);
4964                 XMM(d).s[2] = SaturatedSignedDwordToSignedWord(XMM(d).i[2]);
4965                 XMM(d).s[3] = SaturatedSignedDwordToSignedWord(XMM(d).i[3]);
4966                 XMM(d).s[4] = SaturatedSignedDwordToSignedWord(t.i[0]);
4967                 XMM(d).s[5] = SaturatedSignedDwordToSignedWord(t.i[1]);
4968                 XMM(d).s[6] = SaturatedSignedDwordToSignedWord(t.i[2]);
4969                 XMM(d).s[7] = SaturatedSignedDwordToSignedWord(t.i[3]);
4970         }
4971         else {
4972                 XMM_REG s;
4973                 int d = (modrm >> 3) & 0x7;
4974                 UINT32 ea = GetEA(modrm, 0, 16);
4975                 READXMM( ea, s);
4976                 XMM(d).s[0] = SaturatedSignedDwordToSignedWord(XMM(d).i[0]);
4977                 XMM(d).s[1] = SaturatedSignedDwordToSignedWord(XMM(d).i[1]);
4978                 XMM(d).s[2] = SaturatedSignedDwordToSignedWord(XMM(d).i[2]);
4979                 XMM(d).s[3] = SaturatedSignedDwordToSignedWord(XMM(d).i[3]);
4980                 XMM(d).s[4] = SaturatedSignedDwordToSignedWord(s.i[0]);
4981                 XMM(d).s[5] = SaturatedSignedDwordToSignedWord(s.i[1]);
4982                 XMM(d).s[6] = SaturatedSignedDwordToSignedWord(s.i[2]);
4983                 XMM(d).s[7] = SaturatedSignedDwordToSignedWord(s.i[3]);
4984         }
4985         CYCLES(1);     // TODO: correct cycle count
4986 }
4987
4988  void I386_OPS_BASE::SSEOP(pcmpgtb_r128_rm128)() // Opcode 66 0f 64
4989 {
4990         UINT8 modrm = FETCH();
4991         if( modrm >= 0xc0 ) {
4992                 int s,d;
4993                 s=modrm & 0x7;
4994                 d=(modrm >> 3) & 0x7;
4995                 for (int c=0;c <= 15;c++)
4996                         XMM(d).b[c]=(XMM(d).c[c] > XMM(s).c[c]) ? 0xff : 0;
4997         } else {
4998                 XMM_REG s;
4999                 int d=(modrm >> 3) & 0x7;
5000                 UINT32 ea = GetEA(modrm, 0, 16);
5001                 READXMM( ea, s);
5002                 for (int c=0;c <= 15;c++)
5003                         XMM(d).b[c]=(XMM(d).c[c] > s.c[c]) ? 0xff : 0;
5004         }
5005         CYCLES(1);     // TODO: correct cycle count
5006 }
5007
5008  void I386_OPS_BASE::SSEOP(pcmpgtw_r128_rm128)() // Opcode 66 0f 65
5009 {
5010         UINT8 modrm = FETCH();
5011         if( modrm >= 0xc0 ) {
5012                 int s,d;
5013                 s=modrm & 0x7;
5014                 d=(modrm >> 3) & 0x7;
5015                 for (int c=0;c <= 7;c++)
5016                         XMM(d).w[c]=(XMM(d).s[c] > XMM(s).s[c]) ? 0xffff : 0;
5017         } else {
5018                 XMM_REG s;
5019                 int d=(modrm >> 3) & 0x7;
5020                 UINT32 ea = GetEA(modrm, 0, 16);
5021                 READXMM( ea, s);
5022                 for (int c=0;c <= 7;c++)
5023                         XMM(d).w[c]=(XMM(d).s[c] > s.s[c]) ? 0xffff : 0;
5024         }
5025         CYCLES(1);     // TODO: correct cycle count
5026 }
5027
5028  void I386_OPS_BASE::SSEOP(pcmpgtd_r128_rm128)() // Opcode 66 0f 66
5029 {
5030         UINT8 modrm = FETCH();
5031         if( modrm >= 0xc0 ) {
5032                 int s,d;
5033                 s=modrm & 0x7;
5034                 d=(modrm >> 3) & 0x7;
5035                 for (int c=0;c <= 3;c++)
5036                         XMM(d).d[c]=(XMM(d).i[c] > XMM(s).i[c]) ? 0xffffffff : 0;
5037         } else {
5038                 XMM_REG s;
5039                 int d=(modrm >> 3) & 0x7;
5040                 UINT32 ea = GetEA(modrm, 0, 16);
5041                 READXMM( ea, s);
5042                 for (int c=0;c <= 3;c++)
5043                         XMM(d).d[c]=(XMM(d).i[c] > s.i[c]) ? 0xffffffff : 0;
5044         }
5045         CYCLES(1);     // TODO: correct cycle count
5046 }
5047
5048  void I386_OPS_BASE::SSEOP(packuswb_r128_rm128)() // Opcode 66 0f 67
5049 {
5050         UINT8 modrm = FETCH();
5051         if( modrm >= 0xc0 ) {
5052                 XMM_REG t;
5053                 int s,d;
5054                 s=modrm & 0x7;
5055                 d=(modrm >> 3) & 0x7;
5056                 t.q[0] = XMM(s).q[0];
5057                 t.q[1] = XMM(s).q[1];
5058                 for (int n = 0; n < 8;n++)
5059                         XMM(d).b[n]=SaturatedSignedWordToUnsignedByte(XMM(d).s[n]);
5060                 for (int n = 0; n < 8;n++)
5061                         XMM(d).b[n+8]=SaturatedSignedWordToUnsignedByte(t.s[n]);
5062         } else {
5063                 XMM_REG s;
5064                 int d=(modrm >> 3) & 0x7;
5065                 UINT32 ea = GetEA(modrm, 0, 16);
5066                 READXMM( ea, s);
5067                 for (int n = 0; n < 8;n++)
5068                         XMM(d).b[n]=SaturatedSignedWordToUnsignedByte(XMM(d).s[n]);
5069                 for (int n = 0; n < 8;n++)
5070                         XMM(d).b[n+8]=SaturatedSignedWordToUnsignedByte(s.s[n]);
5071         }
5072         CYCLES(1);     // TODO: correct cycle count
5073 }
5074
5075  void I386_OPS_BASE::SSEOP(punpckhbw_r128_rm128)() // Opcode 66 0f 68
5076 {
5077         UINT8 modrm = FETCH();
5078         if( modrm >= 0xc0 ) {
5079                 XMM_REG t;
5080                 int s,d;
5081                 s=modrm & 0x7;
5082                 d=(modrm >> 3) & 0x7;
5083                 t.q[1] = XMM(s).q[1];
5084                 for (int n = 0; n < 16; n += 2) {
5085                         XMM(d).b[n]=XMM(d).b[8+(n >> 1)];
5086                         XMM(d).b[n+1]=t.b[8+(n >> 1)];
5087                 }
5088         } else {
5089                 XMM_REG s;
5090                 int d=(modrm >> 3) & 0x7;
5091                 UINT32 ea = GetEA(modrm, 0, 16);
5092                 READXMM( ea, s);
5093                 for (int n = 0; n < 16; n += 2) {
5094                         XMM(d).b[n]=XMM(d).b[8+(n >> 1)];
5095                         XMM(d).b[n+1]=s.b[8+(n >> 1)];
5096                 }
5097         }
5098         CYCLES(1);     // TODO: correct cycle count
5099 }
5100
5101  void I386_OPS_BASE::SSEOP(punpckhwd_r128_rm128)() // Opcode 66 0f 69
5102 {
5103         UINT8 modrm = FETCH();
5104         if( modrm >= 0xc0 ) {
5105                 XMM_REG t;
5106                 int s,d;
5107                 s=modrm & 0x7;
5108                 d=(modrm >> 3) & 0x7;
5109                 t.q[1] = XMM(s).q[1];
5110                 for (int n = 0; n < 8; n += 2) {
5111                         XMM(d).w[n]=XMM(d).w[4+(n >> 1)];
5112                         XMM(d).w[n+1]=t.w[4+(n >> 1)];
5113                 }
5114         } else {
5115                 XMM_REG s;
5116                 int d=(modrm >> 3) & 0x7;
5117                 UINT32 ea = GetEA(modrm, 0, 16);
5118                 READXMM( ea, s);
5119                 for (int n = 0; n < 8; n += 2) {
5120                         XMM(d).w[n]=XMM(d).w[4+(n >> 1)];
5121                         XMM(d).w[n+1]=s.w[4+(n >> 1)];
5122                 }
5123         }
5124         CYCLES(1);     // TODO: correct cycle count
5125 }
5126
5127  void I386_OPS_BASE::SSEOP(unpckhdq_r128_rm128)() // Opcode 66 0f 6a
5128 {
5129         UINT8 modrm = FETCH();
5130         if( modrm >= 0xc0 ) {
5131                 XMM_REG t;
5132                 int s,d;
5133                 s=modrm & 0x7;
5134                 d=(modrm >> 3) & 0x7;
5135                 t.q[1] = XMM(s).q[1];
5136                 XMM(d).d[0]=XMM(d).d[2];
5137                 XMM(d).d[1]=t.d[2];
5138                 XMM(d).d[2]=XMM(d).d[3];
5139                 XMM(d).d[3]=t.d[3];
5140         } else {
5141                 XMM_REG s;
5142                 int d=(modrm >> 3) & 0x7;
5143                 UINT32 ea = GetEA(modrm, 0, 16);
5144                 READXMM( ea, s);
5145                 XMM(d).d[0]=XMM(d).d[2];
5146                 XMM(d).d[1]=s.d[2];
5147                 XMM(d).d[2]=XMM(d).d[3];
5148                 XMM(d).d[3]=s.d[3];
5149         }
5150         CYCLES(1);     // TODO: correct cycle count
5151 }
5152
5153  void I386_OPS_BASE::SSEOP(punpckhqdq_r128_rm128)() // Opcode 66 0f 6d
5154 {
5155         UINT8 modrm = FETCH();
5156         if( modrm >= 0xc0 ) {
5157                 XMM_REG t;
5158                 int s,d;
5159                 s=modrm & 0x7;
5160                 d=(modrm >> 3) & 0x7;
5161                 t.q[1] = XMM(s).q[1];
5162                 XMM(d).q[0]=XMM(d).q[1];
5163                 XMM(d).q[1]=t.q[1];
5164         } else {
5165                 XMM_REG s;
5166                 int d=(modrm >> 3) & 0x7;
5167                 UINT32 ea = GetEA(modrm, 0, 16);
5168                 READXMM( ea, s);
5169                 XMM(d).q[0]=XMM(d).q[1];
5170                 XMM(d).q[1]=s.q[1];
5171         }
5172         CYCLES(1);     // TODO: correct cycle count
5173 }
5174
5175  void I386_OPS_BASE::SSEOP(pcmpeqb_r128_rm128)() // Opcode 66 0f 74
5176 {
5177         UINT8 modrm = FETCH();
5178         if( modrm >= 0xc0 ) {
5179                 int s,d;
5180                 s=modrm & 0x7;
5181                 d=(modrm >> 3) & 0x7;
5182                 for (int c=0;c <= 15;c++)
5183                         XMM(d).b[c]=(XMM(d).c[c] == XMM(s).c[c]) ? 0xff : 0;
5184         } else {
5185                 XMM_REG s;
5186                 int d=(modrm >> 3) & 0x7;
5187                 UINT32 ea = GetEA(modrm, 0, 16);
5188                 READXMM( ea, s);
5189                 for (int c=0;c <= 15;c++)
5190                         XMM(d).b[c]=(XMM(d).c[c] == s.c[c]) ? 0xff : 0;
5191         }
5192         CYCLES(1);     // TODO: correct cycle count
5193 }
5194
5195  void I386_OPS_BASE::SSEOP(pcmpeqw_r128_rm128)() // Opcode 66 0f 75
5196 {
5197         UINT8 modrm = FETCH();
5198         if( modrm >= 0xc0 ) {
5199                 int s,d;
5200                 s=modrm & 0x7;
5201                 d=(modrm >> 3) & 0x7;
5202                 for (int c=0;c <= 7;c++)
5203                         XMM(d).w[c]=(XMM(d).s[c] == XMM(s).s[c]) ? 0xffff : 0;
5204         } else {
5205                 XMM_REG s;
5206                 int d=(modrm >> 3) & 0x7;
5207                 UINT32 ea = GetEA(modrm, 0, 16);
5208                 READXMM( ea, s);
5209                 for (int c=0;c <= 7;c++)
5210                         XMM(d).w[c]=(XMM(d).s[c] == s.s[c]) ? 0xffff : 0;
5211         }
5212         CYCLES(1);     // TODO: correct cycle count
5213 }
5214
5215  void I386_OPS_BASE::SSEOP(pcmpeqd_r128_rm128)() // Opcode 66 0f 76
5216 {
5217         UINT8 modrm = FETCH();
5218         if( modrm >= 0xc0 ) {
5219                 int s,d;
5220                 s=modrm & 0x7;
5221                 d=(modrm >> 3) & 0x7;
5222                 for (int c=0;c <= 3;c++)
5223                         XMM(d).d[c]=(XMM(d).i[c] == XMM(s).i[c]) ? 0xffffffff : 0;
5224         } else {
5225                 XMM_REG s;
5226                 int d=(modrm >> 3) & 0x7;
5227                 UINT32 ea = GetEA(modrm, 0, 16);
5228                 READXMM( ea, s);
5229                 for (int c=0;c <= 3;c++)
5230                         XMM(d).d[c]=(XMM(d).i[c] == s.i[c]) ? 0xffffffff : 0;
5231         }
5232         CYCLES(1);     // TODO: correct cycle count
5233 }
5234
5235  void I386_OPS_BASE::SSEOP(paddq_r128_rm128)()  // Opcode 66 0f d4
5236 {
5237         UINT8 modrm = FETCH();
5238         if( modrm >= 0xc0 ) {
5239                 int s,d;
5240                 s=modrm & 0x7;
5241                 d=(modrm >> 3) & 0x7;
5242                 XMM(d).q[0]=XMM(d).q[0]+XMM(s).q[0];
5243                 XMM(d).q[1]=XMM(d).q[1]+XMM(s).q[1];
5244         } else {
5245                 XMM_REG src;
5246                 int d=(modrm >> 3) & 0x7;
5247                 UINT32 ea = GetEA(modrm, 0, 16);
5248                 READXMM( ea, src);
5249                 XMM(d).q[0]=XMM(d).q[0]+src.q[0];
5250                 XMM(d).q[1]=XMM(d).q[1]+src.q[1];
5251         }
5252         CYCLES(1);     // TODO: correct cycle count
5253 }
5254
5255  void I386_OPS_BASE::SSEOP(pmullw_r128_rm128)()  // Opcode 66 0f d5
5256 {
5257         UINT8 modrm = FETCH();
5258         if( modrm >= 0xc0 ) {
5259                 int s,d;
5260                 s=modrm & 0x7;
5261                 d=(modrm >> 3) & 0x7;
5262                 for (int n = 0; n < 8;n++)
5263                         XMM(d).w[n]=(UINT32)((INT32)XMM(d).s[n]*(INT32)XMM(s).s[n]) & 0xffff;
5264         } else {
5265                 XMM_REG src;
5266                 int d;
5267                 UINT32 ea = GetEA(modrm, 0, 16);
5268                 READXMM( ea, src);
5269                 d=(modrm >> 3) & 0x7;
5270                 for (int n = 0; n < 8;n++)
5271                         XMM(d).w[n]=(UINT32)((INT32)XMM(d).s[n]*(INT32)src.s[n]) & 0xffff;
5272         }
5273         CYCLES(1);     // TODO: correct cycle count
5274 }
5275
5276  void I386_OPS_BASE::SSEOP(paddb_r128_rm128)()  // Opcode 66 0f fc
5277 {
5278         UINT8 modrm = FETCH();
5279         if( modrm >= 0xc0 ) {
5280                 for (int n=0;n < 16;n++)
5281                         XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] + XMM(modrm & 7).b[n];
5282         } else {
5283                 XMM_REG s;
5284                 UINT32 ea = GetEA(modrm, 0, 16);
5285                 READXMM( ea, s);
5286                 for (int n=0;n < 16;n++)
5287                         XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] + s.b[n];
5288         }
5289         CYCLES(1);     // TODO: correct cycle count
5290 }
5291
5292  void I386_OPS_BASE::SSEOP(paddw_r128_rm128)()  // Opcode 66 0f fd
5293 {
5294         UINT8 modrm = FETCH();
5295         if( modrm >= 0xc0 ) {
5296                 for (int n=0;n < 8;n++)
5297                         XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] + XMM(modrm & 7).w[n];
5298         } else {
5299                 XMM_REG s;
5300                 UINT32 ea = GetEA(modrm, 0, 16);
5301                 READXMM( ea, s);
5302                 for (int n=0;n < 8;n++)
5303                         XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] + s.w[n];
5304         }
5305         CYCLES(1);     // TODO: correct cycle count
5306 }
5307
5308  void I386_OPS_BASE::SSEOP(paddd_r128_rm128)()  // Opcode 66 0f fe
5309 {
5310         UINT8 modrm = FETCH();
5311         if( modrm >= 0xc0 ) {
5312                 for (int n=0;n < 4;n++)
5313                         XMM((modrm >> 3) & 0x7).d[n]=XMM((modrm >> 3) & 0x7).d[n] + XMM(modrm & 7).d[n];
5314         } else {
5315                 XMM_REG s;
5316                 UINT32 ea = GetEA(modrm, 0, 16);
5317                 READXMM( ea, s);
5318                 for (int n=0;n < 4;n++)
5319                         XMM((modrm >> 3) & 0x7).d[n]=XMM((modrm >> 3) & 0x7).d[n] + s.d[n];
5320         }
5321         CYCLES(1);     // TODO: correct cycle count
5322 }
5323
5324  void I386_OPS_BASE::SSEOP(psubusb_r128_rm128)()  // Opcode 66 0f d8
5325 {
5326         UINT8 modrm = FETCH();
5327         if( modrm >= 0xc0 ) {
5328                 for (int n=0;n < 16;n++)
5329                         XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] < XMM(modrm & 7).b[n] ? 0 : XMM((modrm >> 3) & 0x7).b[n]-XMM(modrm & 7).b[n];
5330         } else {
5331                 XMM_REG src;
5332                 UINT32 ea = GetEA(modrm, 0, 16);
5333                 READXMM( ea, src);
5334                 for (int n=0;n < 16;n++)
5335                         XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] < src.b[n] ? 0 : XMM((modrm >> 3) & 0x7).b[n]-src.b[n];
5336         }
5337         CYCLES(1);     // TODO: correct cycle count
5338 }
5339
5340  void I386_OPS_BASE::SSEOP(psubusw_r128_rm128)()  // Opcode 66 0f d9
5341 {
5342         UINT8 modrm = FETCH();
5343         if( modrm >= 0xc0 ) {
5344                 for (int n=0;n < 8;n++)
5345                         XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] < XMM(modrm & 7).w[n] ? 0 : XMM((modrm >> 3) & 0x7).w[n]-XMM(modrm & 7).w[n];
5346         } else {
5347                 XMM_REG src;
5348                 UINT32 ea = GetEA(modrm, 0, 16);
5349                 READXMM( ea, src);
5350                 for (int n=0;n < 8;n++)
5351                         XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] < src.w[n] ? 0 : XMM((modrm >> 3) & 0x7).w[n]-src.w[n];
5352         }
5353         CYCLES(1);     // TODO: correct cycle count
5354 }
5355
5356  void I386_OPS_BASE::SSEOP(pand_r128_rm128)()  // Opcode 66 0f db
5357 {
5358         UINT8 modrm = FETCH();
5359         if( modrm >= 0xc0 ) {
5360                 XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] & XMM(modrm & 7).q[0];
5361                 XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] & XMM(modrm & 7).q[1];
5362         } else {
5363                 XMM_REG src;
5364                 UINT32 ea = GetEA(modrm, 0, 16);
5365                 READXMM( ea, src);
5366                 XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] & src.q[0];
5367                 XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] & src.q[1];
5368         }
5369         CYCLES(1);     // TODO: correct cycle count
5370 }
5371
5372  void I386_OPS_BASE::SSEOP(pandn_r128_rm128)()  // Opcode 66 0f df
5373 {
5374         UINT8 modrm = FETCH();
5375         if( modrm >= 0xc0 ) {
5376                 XMM((modrm >> 3) & 0x7).q[0]=(~XMM((modrm >> 3) & 0x7).q[0]) & XMM(modrm & 7).q[0];
5377                 XMM((modrm >> 3) & 0x7).q[1]=(~XMM((modrm >> 3) & 0x7).q[1]) & XMM(modrm & 7).q[1];
5378         } else {
5379                 XMM_REG src;
5380                 UINT32 ea = GetEA(modrm, 0, 16);
5381                 READXMM( ea, src);
5382                 XMM((modrm >> 3) & 0x7).q[0]=(~XMM((modrm >> 3) & 0x7).q[0]) & src.q[0];
5383                 XMM((modrm >> 3) & 0x7).q[1]=(~XMM((modrm >> 3) & 0x7).q[1]) & src.q[1];
5384         }
5385         CYCLES(1);     // TODO: correct cycle count
5386 }
5387
5388  void I386_OPS_BASE::SSEOP(paddusb_r128_rm128)()  // Opcode 66 0f dc
5389 {
5390         UINT8 modrm = FETCH();
5391         if( modrm >= 0xc0 ) {
5392                 for (int n=0;n < 16;n++)
5393                         XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] > (0xff-XMM(modrm & 7).b[n]) ? 0xff : XMM((modrm >> 3) & 0x7).b[n]+XMM(modrm & 7).b[n];
5394         } else {
5395                 XMM_REG src;
5396                 UINT32 ea = GetEA(modrm, 0, 16);
5397                 READXMM( ea, src);
5398                 for (int n=0;n < 16;n++)
5399                         XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] > (0xff-src.b[n]) ? 0xff : XMM((modrm >> 3) & 0x7).b[n]+src.b[n];
5400         }
5401         CYCLES(1);     // TODO: correct cycle count
5402 }
5403
5404  void I386_OPS_BASE::SSEOP(paddusw_r128_rm128)()  // Opcode 66 0f dd
5405 {
5406         UINT8 modrm = FETCH();
5407         if( modrm >= 0xc0 ) {
5408                 for (int n=0;n < 8;n++)
5409                         XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] > (0xffff-XMM(modrm & 7).w[n]) ? 0xffff : XMM((modrm >> 3) & 0x7).w[n]+XMM(modrm & 7).w[n];
5410         } else {
5411                 XMM_REG src;
5412                 UINT32 ea = GetEA(modrm, 0, 16);
5413                 READXMM( ea, src);
5414                 for (int n=0;n < 8;n++)
5415                         XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] > (0xffff-src.w[n]) ? 0xffff : XMM((modrm >> 3) & 0x7).w[n]+src.w[n];
5416         }
5417         CYCLES(1);     // TODO: correct cycle count
5418 }
5419
5420  void I386_OPS_BASE::SSEOP(pmaxub_r128_rm128)() // Opcode 66 0f de
5421 {
5422         UINT8 modrm = FETCH();
5423         if( modrm >= 0xc0 ) {
5424                 for (int n=0;n < 16;n++)
5425                         XMM((modrm >> 3) & 0x7).b[n] = XMM((modrm >> 3) & 0x7).b[n] > XMM(modrm & 0x7).b[n] ? XMM((modrm >> 3) & 0x7).b[n] : XMM(modrm & 0x7).b[n];
5426         } else {
5427                 XMM_REG s;
5428                 UINT32 ea = GetEA(modrm, 0, 16);
5429                 READXMM( ea, s);
5430                 for (int n=0;n < 16;n++)
5431                         XMM((modrm >> 3) & 0x7).b[n] = XMM((modrm >> 3) & 0x7).b[n] > s.b[n] ? XMM((modrm >> 3) & 0x7).b[n] : s.b[n];
5432         }
5433         CYCLES(1);     // TODO: correct cycle count
5434 }
5435
5436  void I386_OPS_BASE::SSEOP(pmulhuw_r128_rm128)()  // Opcode 66 0f e4
5437 {
5438         UINT8 modrm = FETCH();
5439         if( modrm >= 0xc0 ) {
5440                 for (int n=0;n < 8;n++)
5441                         XMM((modrm >> 3) & 0x7).w[n]=((UINT32)XMM((modrm >> 3) & 0x7).w[n]*(UINT32)XMM(modrm & 7).w[n]) >> 16;
5442         } else {
5443                 XMM_REG s;
5444                 UINT32 ea = GetEA(modrm, 0, 16);
5445                 READXMM( ea, s);
5446                 for (int n=0;n < 8;n++)
5447                         XMM((modrm >> 3) & 0x7).w[n]=((UINT32)XMM((modrm >> 3) & 0x7).w[n]*(UINT32)s.w[n]) >> 16;
5448         }
5449         CYCLES(1);     // TODO: correct cycle count
5450 }
5451
5452  void I386_OPS_BASE::SSEOP(pmulhw_r128_rm128)()  // Opcode 66 0f e5
5453 {
5454         UINT8 modrm = FETCH();
5455         if( modrm >= 0xc0 ) {
5456                 for (int n=0;n < 8;n++)
5457                         XMM((modrm >> 3) & 0x7).w[n]=(UINT32)((INT32)XMM((modrm >> 3) & 0x7).s[n]*(INT32)XMM(modrm & 7).s[n]) >> 16;
5458         } else {
5459                 XMM_REG src;
5460                 UINT32 ea = GetEA(modrm, 0, 16);
5461                 READXMM( ea, src);
5462                 for (int n=0;n < 8;n++)
5463                         XMM((modrm >> 3) & 0x7).w[n]=(UINT32)((INT32)XMM((modrm >> 3) & 0x7).s[n]*(INT32)src.s[n]) >> 16;
5464         }
5465         CYCLES(1);     // TODO: correct cycle count
5466 }
5467
5468  void I386_OPS_BASE::SSEOP(psubsb_r128_rm128)()  // Opcode 66 0f e8
5469 {
5470         UINT8 modrm = FETCH();
5471         if( modrm >= 0xc0 ) {
5472                 for (int n=0;n < 16;n++)
5473                         XMM((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)XMM((modrm >> 3) & 0x7).c[n] - (INT16)XMM(modrm & 7).c[n]);
5474         } else {
5475                 XMM_REG s;
5476                 UINT32 ea = GetEA(modrm, 0, 16);
5477                 READXMM( ea, s);
5478                 for (int n=0;n < 16;n++)
5479                         XMM((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)XMM((modrm >> 3) & 0x7).c[n] - (INT16)s.c[n]);
5480         }
5481         CYCLES(1);     // TODO: correct cycle count
5482 }
5483
5484  void I386_OPS_BASE::SSEOP(psubsw_r128_rm128)()  // Opcode 66 0f e9
5485 {
5486         UINT8 modrm = FETCH();
5487         if( modrm >= 0xc0 ) {
5488                 for (int n=0;n < 8;n++)
5489                         XMM((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)XMM((modrm >> 3) & 0x7).s[n] - (INT32)XMM(modrm & 7).s[n]);
5490         } else {
5491                 XMM_REG s;
5492                 UINT32 ea = GetEA(modrm, 0, 16);
5493                 READXMM( ea, s);
5494                 for (int n=0;n < 8;n++)
5495                         XMM((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)XMM((modrm >> 3) & 0x7).s[n] - (INT32)s.s[n]);
5496         }
5497         CYCLES(1);     // TODO: correct cycle count
5498 }
5499
5500  void I386_OPS_BASE::SSEOP(pminsw_r128_rm128)() // Opcode 66 0f ea
5501 {
5502         UINT8 modrm = FETCH();
5503         if( modrm >= 0xc0 ) {
5504                 for (int n=0;n < 8;n++)
5505                         XMM((modrm >> 3) & 0x7).s[n] = XMM((modrm >> 3) & 0x7).s[n] < XMM(modrm & 0x7).s[n] ? XMM((modrm >> 3) & 0x7).s[n] : XMM(modrm & 0x7).s[n];
5506         } else {
5507                 XMM_REG s;
5508                 UINT32 ea = GetEA(modrm, 0, 16);
5509                 READXMM( ea, s);
5510                 for (int n=0;n < 8;n++)
5511                         XMM((modrm >> 3) & 0x7).s[n] = XMM((modrm >> 3) & 0x7).s[n] < s.s[n] ? XMM((modrm >> 3) & 0x7).s[n] : s.s[n];
5512         }
5513         CYCLES(1);     // TODO: correct cycle count
5514 }
5515
5516  void I386_OPS_BASE::SSEOP(pmaxsw_r128_rm128)() // Opcode 66 0f ee
5517 {
5518         UINT8 modrm = FETCH();
5519         if( modrm >= 0xc0 ) {
5520                 for (int n=0;n < 8;n++)
5521                         XMM((modrm >> 3) & 0x7).s[n] = XMM((modrm >> 3) & 0x7).s[n] > XMM(modrm & 0x7).s[n] ? XMM((modrm >> 3) & 0x7).s[n] : XMM(modrm & 0x7).s[n];
5522         } else {
5523                 XMM_REG s;
5524                 UINT32 ea = GetEA(modrm, 0, 16);
5525                 READXMM( ea, s);
5526                 for (int n=0;n < 8;n++)
5527                         XMM((modrm >> 3) & 0x7).s[n] = XMM((modrm >> 3) & 0x7).s[n] > s.s[n] ? XMM((modrm >> 3) & 0x7).s[n] : s.s[n];
5528         }
5529         CYCLES(1);     // TODO: correct cycle count
5530 }
5531
5532  void I386_OPS_BASE::SSEOP(paddsb_r128_rm128)()  // Opcode 66 0f ec
5533 {
5534         UINT8 modrm = FETCH();
5535         if( modrm >= 0xc0 ) {
5536                 for (int n=0;n < 16;n++)
5537                         XMM((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)XMM((modrm >> 3) & 0x7).c[n] + (INT16)XMM(modrm & 7).c[n]);
5538         } else {
5539                 XMM_REG s;
5540                 UINT32 ea = GetEA(modrm, 0, 16);
5541                 READXMM( ea, s);
5542                 for (int n=0;n < 16;n++)
5543                         XMM((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)XMM((modrm >> 3) & 0x7).c[n] + (INT16)s.c[n]);
5544         }
5545         CYCLES(1);     // TODO: correct cycle count
5546 }
5547
5548  void I386_OPS_BASE::SSEOP(paddsw_r128_rm128)()  // Opcode 66 0f ed
5549 {
5550         UINT8 modrm = FETCH();
5551         if( modrm >= 0xc0 ) {
5552                 for (int n=0;n < 8;n++)
5553                         XMM((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)XMM((modrm >> 3) & 0x7).s[n] + (INT32)XMM(modrm & 7).s[n]);
5554         } else {
5555                 XMM_REG s;
5556                 UINT32 ea = GetEA(modrm, 0, 16);
5557                 READXMM( ea, s);
5558                 for (int n=0;n < 8;n++)
5559                         XMM((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)XMM((modrm >> 3) & 0x7).s[n] + (INT32)s.s[n]);
5560         }
5561         CYCLES(1);     // TODO: correct cycle count
5562 }
5563
5564  void I386_OPS_BASE::SSEOP(por_r128_rm128)()  // Opcode 66 0f eb
5565 {
5566         UINT8 modrm = FETCH();
5567         if( modrm >= 0xc0 ) {
5568                 XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] | XMM(modrm & 7).q[0];
5569                 XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] | XMM(modrm & 7).q[1];
5570         } else {
5571                 XMM_REG s;
5572                 UINT32 ea = GetEA(modrm, 0, 16);
5573                 READXMM( ea, s);
5574                 XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] | s.q[0];
5575                 XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] | s.q[1];
5576         }
5577         CYCLES(1);     // TODO: correct cycle count
5578 }
5579
5580  void I386_OPS_BASE::SSEOP(pxor_r128_rm128)()  // Opcode 66 0f ef
5581 {
5582         UINT8 modrm = FETCH();
5583         if( modrm >= 0xc0 ) {
5584                 XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] ^ XMM(modrm & 7).q[0];
5585                 XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] ^ XMM(modrm & 7).q[1];
5586         } else {
5587                 XMM_REG s;
5588                 UINT32 ea = GetEA(modrm, 0, 16);
5589                 READXMM( ea, s);
5590                 XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] ^ s.q[0];
5591                 XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] ^ s.q[1];
5592         }
5593         CYCLES(1);     // TODO: correct cycle count
5594 }
5595
5596  void I386_OPS_BASE::SSEOP(pmaddwd_r128_rm128)()  // Opcode 66 0f f5
5597 {
5598         UINT8 modrm = FETCH();
5599         if( modrm >= 0xc0 ) {
5600                 for (int n=0;n < 4;n++)
5601                         XMM((modrm >> 3) & 0x7).i[n]=(INT32)XMM((modrm >> 3) & 0x7).s[n]*(INT32)XMM(modrm & 7).s[n]+
5602                                                                                 (INT32)XMM((modrm >> 3) & 0x7).s[n]*(INT32)XMM(modrm & 7).s[n];
5603         } else {
5604                 XMM_REG s;
5605                 UINT32 ea = GetEA(modrm, 0, 16);
5606                 READXMM( ea, s);
5607                 for (int n=0;n < 4;n++)
5608                         XMM((modrm >> 3) & 0x7).i[n]=(INT32)XMM((modrm >> 3) & 0x7).s[n]*(INT32)s.s[n]+
5609                                                                                 (INT32)XMM((modrm >> 3) & 0x7).s[n]*(INT32)s.s[n];
5610         }
5611         CYCLES(1);     // TODO: correct cycle count
5612 }
5613
5614  void I386_OPS_BASE::SSEOP(psubb_r128_rm128)()  // Opcode 66 0f f8
5615 {
5616         UINT8 modrm = FETCH();
5617         if( modrm >= 0xc0 ) {
5618                 for (int n=0;n < 16;n++)
5619                         XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] - XMM(modrm & 7).b[n];
5620         } else {
5621                 XMM_REG s;
5622                 UINT32 ea = GetEA(modrm, 0, 16);
5623                 READXMM( ea, s);
5624                 for (int n=0;n < 16;n++)
5625                         XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] - s.b[n];
5626         }
5627         CYCLES(1);     // TODO: correct cycle count
5628 }
5629
5630  void I386_OPS_BASE::SSEOP(psubw_r128_rm128)()  // Opcode 66 0f f9
5631 {
5632         UINT8 modrm = FETCH();
5633         if( modrm >= 0xc0 ) {
5634                 for (int n=0;n < 8;n++)
5635                         XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] - XMM(modrm & 7).w[n];
5636         } else {
5637                 XMM_REG s;
5638                 UINT32 ea = GetEA(modrm, 0, 16);
5639                 READXMM( ea, s);
5640                 for (int n=0;n < 8;n++)
5641                         XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] - s.w[n];
5642         }
5643         CYCLES(1);     // TODO: correct cycle count
5644 }
5645
5646  void I386_OPS_BASE::SSEOP(psubd_r128_rm128)()  // Opcode 66 0f fa
5647 {
5648         UINT8 modrm = FETCH();
5649         if( modrm >= 0xc0 ) {
5650                 for (int n=0;n < 4;n++)
5651                         XMM((modrm >> 3) & 0x7).d[n]=XMM((modrm >> 3) & 0x7).d[n] - XMM(modrm & 7).d[n];
5652         } else {
5653                 XMM_REG s;
5654                 UINT32 ea = GetEA(modrm, 0, 16);
5655                 READXMM( ea, s);
5656                 for (int n=0;n < 4;n++)
5657                         XMM((modrm >> 3) & 0x7).d[n]=XMM((modrm >> 3) & 0x7).d[n] - s.d[n];
5658         }
5659         CYCLES(1);     // TODO: correct cycle count
5660 }
5661
5662  void I386_OPS_BASE::SSEOP(psadbw_r128_rm128)() // Opcode 66 0f f6
5663 {
5664         INT32 temp;
5665         UINT8 modrm = FETCH();
5666         if( modrm >= 0xc0 ) {
5667                 temp=0;
5668                 for (int n=0;n < 8;n++)
5669                         temp += abs((INT32)XMM((modrm >> 3) & 0x7).b[n] - (INT32)XMM(modrm & 0x7).b[n]);
5670                 XMM((modrm >> 3) & 0x7).l[0]=(UINT64)temp & 0xffff;
5671                 temp=0;
5672                 for (int n=8;n < 16;n++)
5673                         temp += abs((INT32)XMM((modrm >> 3) & 0x7).b[n] - (INT32)XMM(modrm & 0x7).b[n]);
5674                 XMM((modrm >> 3) & 0x7).l[1]=(UINT64)temp & 0xffff;
5675         } else {
5676                 XMM_REG s;
5677                 UINT32 ea = GetEA(modrm, 0, 16);
5678                 READXMM( ea, s);
5679                 temp=0;
5680                 for (int n=0;n < 8;n++)
5681                         temp += abs((INT32)XMM((modrm >> 3) & 0x7).b[n] - (INT32)s.b[n]);
5682                 XMM((modrm >> 3) & 0x7).l[0]=(UINT64)temp & 0xffff;
5683                 temp=0;
5684                 for (int n=8;n < 16;n++)
5685                         temp += abs((INT32)XMM((modrm >> 3) & 0x7).b[n] - (INT32)s.b[n]);
5686                 XMM((modrm >> 3) & 0x7).l[1]=(UINT64)temp & 0xffff;
5687         }
5688         CYCLES(1);     // TODO: correct cycle count
5689 }
5690
5691  void I386_OPS_BASE::SSEOP(pavgb_r128_rm128)() // Opcode 66 0f e0
5692 {
5693         UINT8 modrm = FETCH();
5694         if( modrm >= 0xc0 ) {
5695                 for (int n=0;n < 16;n++)
5696                         XMM((modrm >> 3) & 0x7).b[n] = ((UINT16)XMM((modrm >> 3) & 0x7).b[n] + (UINT16)XMM(modrm & 0x7).b[n] + 1) >> 1;
5697         } else {
5698                 XMM_REG s;
5699                 UINT32 ea = GetEA(modrm, 0, 16);
5700                 READXMM( ea, s);
5701                 for (int n=0;n < 16;n++)
5702                         XMM((modrm >> 3) & 0x7).b[n] = ((UINT16)XMM((modrm >> 3) & 0x7).b[n] + (UINT16)s.b[n] + 1) >> 1;
5703         }
5704         CYCLES(1);     // TODO: correct cycle count
5705 }
5706
5707  void I386_OPS_BASE::SSEOP(pavgw_r128_rm128)() // Opcode 66 0f e3
5708 {
5709         UINT8 modrm = FETCH();
5710         if( modrm >= 0xc0 ) {
5711                 for (int n=0;n < 8;n++)
5712                         XMM((modrm >> 3) & 0x7).w[n] = ((UINT32)XMM((modrm >> 3) & 0x7).w[n] + (UINT32)XMM(modrm & 0x7).w[n] + 1) >> 1;
5713         } else {
5714                 XMM_REG s;
5715                 UINT32 ea = GetEA(modrm, 0, 16);
5716                 READXMM( ea, s);
5717                 for (int n=0;n < 8;n++)
5718                         XMM((modrm >> 3) & 0x7).w[n] = ((UINT32)XMM((modrm >> 3) & 0x7).w[n] + (UINT32)s.w[n] + 1) >> 1;
5719         }
5720         CYCLES(1);     // TODO: correct cycle count
5721 }
5722
5723  void I386_OPS_BASE::SSEOP(psrlw_r128_rm128)()  // Opcode 66 0f d1
5724 {
5725         UINT8 modrm = FETCH();
5726         if( modrm >= 0xc0 ) {
5727                 int count=(int)XMM(modrm & 7).q[0];
5728                 for (int n=0; n < 8;n++)
5729                         XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] >> count;
5730         } else {
5731                 XMM_REG src;
5732                 UINT32 ea = GetEA(modrm, 0, 16);
5733                 READXMM( ea, src);
5734                 int count=(int)src.q[0];
5735                 for (int n=0; n < 8;n++)
5736                         XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] >> count;
5737         }
5738         CYCLES(1);     // TODO: correct cycle count
5739 }
5740
5741  void I386_OPS_BASE::SSEOP(psrld_r128_rm128)()  // Opcode 66 0f d2
5742 {
5743         UINT8 modrm = FETCH();
5744         if( modrm >= 0xc0 ) {
5745                 int count=(int)XMM(modrm & 7).q[0];
5746                 XMM((modrm >> 3) & 0x7).d[0]=XMM((modrm >> 3) & 0x7).d[0] >> count;
5747                 XMM((modrm >> 3) & 0x7).d[1]=XMM((modrm >> 3) & 0x7).d[1] >> count;
5748                 XMM((modrm >> 3) & 0x7).d[2]=XMM((modrm >> 3) & 0x7).d[2] >> count;
5749                 XMM((modrm >> 3) & 0x7).d[3]=XMM((modrm >> 3) & 0x7).d[3] >> count;
5750         } else {
5751                 XMM_REG src;
5752                 UINT32 ea = GetEA(modrm, 0, 16);
5753                 READXMM( ea, src);
5754                 int count=(int)src.q[0];
5755                 XMM((modrm >> 3) & 0x7).d[0]=XMM((modrm >> 3) & 0x7).d[0] >> count;
5756                 XMM((modrm >> 3) & 0x7).d[1]=XMM((modrm >> 3) & 0x7).d[1] >> count;
5757                 XMM((modrm >> 3) & 0x7).d[2]=XMM((modrm >> 3) & 0x7).d[2] >> count;
5758                 XMM((modrm >> 3) & 0x7).d[3]=XMM((modrm >> 3) & 0x7).d[3] >> count;
5759         }
5760         CYCLES(1);     // TODO: correct cycle count
5761 }
5762
5763  void I386_OPS_BASE::SSEOP(psrlq_r128_rm128)()  // Opcode 66 0f d3
5764 {
5765         UINT8 modrm = FETCH();
5766         if( modrm >= 0xc0 ) {
5767                 int count=(int)XMM(modrm & 7).q[0];
5768                 XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] >> count;
5769                 XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] >> count;
5770         } else {
5771                 XMM_REG src;
5772                 UINT32 ea = GetEA(modrm, 0, 16);
5773                 READXMM( ea, src);
5774                 int count=(int)src.q[0];
5775                 XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] >> count;
5776                 XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] >> count;
5777         }
5778         CYCLES(1);     // TODO: correct cycle count
5779 }
5780
5781  void I386_OPS_BASE::SSEOP(psllw_r128_rm128)()  // Opcode 66 0f f1
5782 {
5783         UINT8 modrm = FETCH();
5784         if( modrm >= 0xc0 ) {
5785                 int count=(int)XMM(modrm & 7).q[0];
5786                 for (int n=0; n < 8;n++)
5787                         XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] << count;
5788         } else {
5789                 XMM_REG s;
5790                 UINT32 ea = GetEA(modrm, 0, 16);
5791                 READXMM( ea, s);
5792                 int count=(int)s.q[0];
5793                 for (int n=0; n < 8;n++)
5794                         XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] << count;
5795         }
5796         CYCLES(1);     // TODO: correct cycle count
5797 }
5798
5799  void I386_OPS_BASE::SSEOP(pslld_r128_rm128)()  // Opcode 66 0f f2
5800 {
5801         UINT8 modrm = FETCH();
5802         if( modrm >= 0xc0 ) {
5803                 int count=(int)XMM(modrm & 7).q[0];
5804                 XMM((modrm >> 3) & 0x7).d[0]=XMM((modrm >> 3) & 0x7).d[0] << count;
5805                 XMM((modrm >> 3) & 0x7).d[1]=XMM((modrm >> 3) & 0x7).d[1] << count;
5806                 XMM((modrm >> 3) & 0x7).d[2]=XMM((modrm >> 3) & 0x7).d[2] << count;
5807                 XMM((modrm >> 3) & 0x7).d[3]=XMM((modrm >> 3) & 0x7).d[3] << count;
5808         } else {
5809                 XMM_REG s;
5810                 UINT32 ea = GetEA(modrm, 0, 16);
5811                 READXMM( ea, s);
5812                 int count=(int)s.q[0];
5813                 XMM((modrm >> 3) & 0x7).d[0]=XMM((modrm >> 3) & 0x7).d[0] << count;
5814                 XMM((modrm >> 3) & 0x7).d[1]=XMM((modrm >> 3) & 0x7).d[1] << count;
5815                 XMM((modrm >> 3) & 0x7).d[2]=XMM((modrm >> 3) & 0x7).d[2] << count;
5816                 XMM((modrm >> 3) & 0x7).d[3]=XMM((modrm >> 3) & 0x7).d[3] << count;
5817         }
5818         CYCLES(1);     // TODO: correct cycle count
5819 }
5820
5821  void I386_OPS_BASE::SSEOP(psllq_r128_rm128)()  // Opcode 66 0f f3
5822 {
5823         UINT8 modrm = FETCH();
5824         if( modrm >= 0xc0 ) {
5825                 int count=(int)XMM(modrm & 7).q[0];
5826                 XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] << count;
5827                 XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] << count;
5828         } else {
5829                 XMM_REG s;
5830                 UINT32 ea = GetEA(modrm, 0, 16);
5831                 READXMM( ea, s);
5832                 int count=(int)s.q[0];
5833                 XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] << count;
5834                 XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] << count;
5835         }
5836         CYCLES(1);     // TODO: correct cycle count
5837 }
5838
5839  void I386_OPS_BASE::SSEOP(psraw_r128_rm128)()  // Opcode 66 0f e1
5840 {
5841         UINT8 modrm = FETCH();
5842         if( modrm >= 0xc0 ) {
5843                 int count=(int)XMM(modrm & 7).q[0];
5844                 for (int n=0; n < 8;n++)
5845                         XMM((modrm >> 3) & 0x7).s[n]=XMM((modrm >> 3) & 0x7).s[n] >> count;
5846         } else {
5847                 XMM_REG src;
5848                 UINT32 ea = GetEA(modrm, 0, 16);
5849                 READXMM( ea, src);
5850                 int count=(int)src.q[0];
5851                 for (int n=0; n < 8;n++)
5852                         XMM((modrm >> 3) & 0x7).s[n]=XMM((modrm >> 3) & 0x7).s[n] >> count;
5853         }
5854         CYCLES(1);     // TODO: correct cycle count
5855 }
5856
5857  void I386_OPS_BASE::SSEOP(psrad_r128_rm128)()  // Opcode 66 0f e2
5858 {
5859         UINT8 modrm = FETCH();
5860         if( modrm >= 0xc0 ) {
5861                 int count=(int)XMM(modrm & 7).q[0];
5862                 XMM((modrm >> 3) & 0x7).i[0]=XMM((modrm >> 3) & 0x7).i[0] >> count;
5863                 XMM((modrm >> 3) & 0x7).i[1]=XMM((modrm >> 3) & 0x7).i[1] >> count;
5864                 XMM((modrm >> 3) & 0x7).i[2]=XMM((modrm >> 3) & 0x7).i[2] >> count;
5865                 XMM((modrm >> 3) & 0x7).i[3]=XMM((modrm >> 3) & 0x7).i[3] >> count;
5866         } else {
5867                 XMM_REG src;
5868                 UINT32 ea = GetEA(modrm, 0, 16);
5869                 READXMM( ea, src);
5870                 int count=(int)src.q[0];
5871                 XMM((modrm >> 3) & 0x7).i[0]=XMM((modrm >> 3) & 0x7).i[0] >> count;
5872                 XMM((modrm >> 3) & 0x7).i[1]=XMM((modrm >> 3) & 0x7).i[1] >> count;
5873                 XMM((modrm >> 3) & 0x7).i[2]=XMM((modrm >> 3) & 0x7).i[2] >> count;
5874                 XMM((modrm >> 3) & 0x7).i[3]=XMM((modrm >> 3) & 0x7).i[3] >> count;
5875         }
5876         CYCLES(1);     // TODO: correct cycle count
5877 }
5878
5879  void I386_OPS_BASE::SSEOP(movntdq_m128_r128)()  // Opcode 66 0f e7
5880 {
5881         UINT8 modrm = FETCH();
5882         if( modrm >= 0xc0 ) {
5883                 CYCLES(1);     // unsupported
5884         } else {
5885                 // since cache is not implemented
5886                 UINT32 ea = GetEA(modrm, 0, 16);
5887                 WRITEXMM( ea, XMM((modrm >> 3) & 0x7));
5888                 CYCLES(1);     // TODO: correct cycle count
5889         }
5890 }
5891
5892  void I386_OPS_BASE::SSEOP(cvttpd2dq_r128_rm128)()  // Opcode 66 0f e6
5893 {
5894         UINT8 modrm = FETCH();
5895         if( modrm >= 0xc0 ) {
5896                 XMM((modrm >> 3) & 0x7).i[0]=(INT32)XMM((modrm >> 3) & 0x7).f64[0];
5897                 XMM((modrm >> 3) & 0x7).i[1]=(INT32)XMM((modrm >> 3) & 0x7).f64[1];
5898                 XMM((modrm >> 3) & 0x7).q[1] = 0;
5899         } else {
5900                 XMM_REG src;
5901                 UINT32 ea = GetEA(modrm, 0, 16);
5902                 READXMM( ea, src);
5903                 XMM((modrm >> 3) & 0x7).i[0]=(INT32)src.f64[0];
5904                 XMM((modrm >> 3) & 0x7).i[1]=(INT32)src.f64[1];
5905                 XMM((modrm >> 3) & 0x7).q[1] = 0;
5906         }
5907         CYCLES(1);     // TODO: correct cycle count
5908 }
5909
5910  void I386_OPS_BASE::SSEOP(movq_r128m64_r128)()  // Opcode 66 0f d6
5911 {
5912         UINT8 modrm = FETCH();
5913         if( modrm >= 0xc0 ) {
5914                 XMM(modrm & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0];
5915                 XMM(modrm & 0x7).q[1] = 0;
5916         } else {
5917                 UINT32 ea = GetEA(modrm, 0, 16);
5918                 WRITE64( ea, XMM((modrm >> 3) & 0x7).q[0]);
5919         }
5920         CYCLES(1);     // TODO: correct cycle count
5921 }
5922
5923  void I386_OPS_BASE::SSEOP(addsubpd_r128_rm128)()  // Opcode 66 0f d0
5924 {
5925         UINT8 modrm = FETCH();
5926         if( modrm >= 0xc0 ) {
5927                 int s, d;
5928                 s=modrm & 0x7;
5929                 d=(modrm >> 3) & 0x7;
5930                 XMM(d).f64[0]=XMM(d).f64[0]-XMM(s).f64[0];
5931                 XMM(d).f64[1]=XMM(d).f64[1]+XMM(s).f64[1];
5932         } else {
5933                 XMM_REG src;
5934                 int d;
5935                 UINT32 ea = GetEA(modrm, 0, 16);
5936                 d=(modrm >> 3) & 0x7;
5937                 READXMM( ea, src);
5938                 XMM(d).f64[0]=XMM(d).f64[0]-src.f64[0];
5939                 XMM(d).f64[1]=XMM(d).f64[1]+src.f64[1];
5940         }
5941         CYCLES(1);     // TODO: correct cycle count
5942 }
5943
5944  void I386_OPS_BASE::SSEOP(haddpd_r128_rm128)()  // Opcode 66 0f 7c
5945 {
5946         UINT8 modrm = FETCH();
5947         if( modrm >= 0xc0 ) {
5948                 int s, d;
5949                 s=modrm & 0x7;
5950                 d=(modrm >> 3) & 0x7;
5951                 XMM(d).f64[0]=XMM(d).f64[0]+XMM(d).f64[1];
5952                 XMM(d).f64[1]=XMM(s).f64[0]+XMM(s).f64[1];
5953         } else {
5954                 XMM_REG src;
5955                 int d;
5956                 UINT32 ea = GetEA(modrm, 0, 16);
5957                 d=(modrm >> 3) & 0x7;
5958                 READXMM( ea, src);
5959                 XMM(d).f64[0]=XMM(d).f64[0]+XMM(d).f64[1];
5960                 XMM(d).f64[1]=src.f64[0]+src.f64[1];
5961         }
5962         CYCLES(1);     // TODO: correct cycle count
5963 }
5964
5965  void I386_OPS_BASE::SSEOP(hsubpd_r128_rm128)()  // Opcode 66 0f 7d
5966 {
5967         UINT8 modrm = FETCH();
5968         if( modrm >= 0xc0 ) {
5969                 int s, d;
5970                 s=modrm & 0x7;
5971                 d=(modrm >> 3) & 0x7;
5972                 XMM(d).f64[0]=XMM(d).f64[0]-XMM(d).f64[1];
5973                 XMM(d).f64[1]=XMM(s).f64[0]-XMM(s).f64[1];
5974         } else {
5975                 XMM_REG src;
5976                 int d;
5977                 UINT32 ea = GetEA(modrm, 0, 16);
5978                 d=(modrm >> 3) & 0x7;
5979                 READXMM( ea, src);
5980                 XMM(d).f64[0]=XMM(d).f64[0]-XMM(d).f64[1];
5981                 XMM(d).f64[1]=src.f64[0]-src.f64[1];
5982         }
5983         CYCLES(1);     // TODO: correct cycle count
5984 }
5985
5986  void I386_OPS_BASE::SSEOP(sqrtpd_r128_rm128)()  // Opcode 66 0f 51
5987 {
5988         UINT8 modrm = FETCH();
5989         if( modrm >= 0xc0 ) {
5990                 int s, d;
5991                 s=modrm & 0x7;
5992                 d=(modrm >> 3) & 0x7;
5993                 XMM(d).f64[0]=sqrt(XMM(s).f64[0]);
5994                 XMM(d).f64[1]=sqrt(XMM(s).f64[1]);
5995         } else {
5996                 XMM_REG src;
5997                 int d;
5998                 UINT32 ea = GetEA(modrm, 0, 16);
5999                 d=(modrm >> 3) & 0x7;
6000                 READXMM( ea, src);
6001                 XMM(d).f64[0]=sqrt(src.f64[0]);
6002                 XMM(d).f64[1]=sqrt(src.f64[1]);
6003         }
6004         CYCLES(1);     // TODO: correct cycle count
6005 }
6006
6007  void I386_OPS_BASE::SSEOP(cvtpi2pd_r128_rm64)()  // Opcode 66 0f 2a
6008 {
6009         UINT8 modrm = FETCH();
6010         if( modrm >= 0xc0 ) {
6011                 MMXPROLOG();
6012                 XMM((modrm >> 3) & 0x7).f64[0] = (double)MMX(modrm & 0x7).i[0];
6013                 XMM((modrm >> 3) & 0x7).f64[1] = (double)MMX(modrm & 0x7).i[1];
6014         } else {
6015                 MMX_REG r;
6016                 UINT32 ea = GetEA(modrm, 0, 8);
6017                 READMMX( ea, r);
6018                 XMM((modrm >> 3) & 0x7).f64[0] = (double)r.i[0];
6019                 XMM((modrm >> 3) & 0x7).f64[1] = (double)r.i[1];
6020         }
6021         CYCLES(1);     // TODO: correct cycle count
6022 }
6023
6024  void I386_OPS_BASE::SSEOP(cvttpd2pi_r64_rm128)()  // Opcode 66 0f 2c
6025 {
6026         UINT8 modrm = FETCH();
6027         MMXPROLOG();
6028         if( modrm >= 0xc0 ) {
6029                 MMX((modrm >> 3) & 0x7).i[0] = XMM(modrm & 0x7).f64[0];
6030                 MMX((modrm >> 3) & 0x7).i[1] = XMM(modrm & 0x7).f64[1];
6031         } else {
6032                 XMM_REG r;
6033                 UINT32 ea = GetEA(modrm, 0, 16);
6034                 READXMM( ea, r);
6035                 MMX((modrm >> 3) & 0x7).i[0] = r.f64[0];
6036                 MMX((modrm >> 3) & 0x7).i[1] = r.f64[1];
6037         }
6038         CYCLES(1);     // TODO: correct cycle count
6039 }
6040
6041  void I386_OPS_BASE::SSEOP(cvtpd2pi_r64_rm128)()  // Opcode 66 0f 2d
6042 {
6043         UINT8 modrm = FETCH();
6044         MMXPROLOG();
6045         if( modrm >= 0xc0 ) {
6046                 MMX((modrm >> 3) & 0x7).i[0] = XMM(modrm & 0x7).f64[0];
6047                 MMX((modrm >> 3) & 0x7).i[1] = XMM(modrm & 0x7).f64[1];
6048         } else {
6049                 XMM_REG r;
6050                 UINT32 ea = GetEA(modrm, 0, 16);
6051                 READXMM( ea, r);
6052                 MMX((modrm >> 3) & 0x7).i[0] = r.f64[0];
6053                 MMX((modrm >> 3) & 0x7).i[1] = r.f64[1];
6054         }
6055         CYCLES(1);     // TODO: correct cycle count
6056 }
6057
6058  void I386_OPS_BASE::SSEOP(cvtpd2ps_r128_rm128)()  // Opcode 66 0f 5a
6059 {
6060         UINT8 modrm = FETCH();
6061         if( modrm >= 0xc0 ) {
6062                 XMM((modrm >> 3) & 0x7).f[0] = (float)XMM(modrm & 0x7).f64[0];
6063                 XMM((modrm >> 3) & 0x7).f[1] = (float)XMM(modrm & 0x7).f64[1];
6064                 XMM((modrm >> 3) & 0x7).q[1] = 0;
6065         } else {
6066                 XMM_REG r;
6067                 UINT32 ea = GetEA(modrm, 0, 16);
6068                 READXMM( ea, r);
6069                 XMM((modrm >> 3) & 0x7).f[0] = (float)r.f64[0];
6070                 XMM((modrm >> 3) & 0x7).f[1] = (float)r.f64[1];
6071                 XMM((modrm >> 3) & 0x7).q[1] = 0;
6072         }
6073         CYCLES(1);     // TODO: correct cycle count
6074 }
6075
6076  void I386_OPS_BASE::SSEOP(cvtps2dq_r128_rm128)()  // Opcode 66 0f 5b
6077 {
6078         UINT8 modrm = FETCH();
6079         if( modrm >= 0xc0 ) {
6080                 XMM((modrm >> 3) & 0x7).i[0] = XMM(modrm & 0x7).f[0];
6081                 XMM((modrm >> 3) & 0x7).i[1] = XMM(modrm & 0x7).f[1];
6082                 XMM((modrm >> 3) & 0x7).i[2] = XMM(modrm & 0x7).f[2];
6083                 XMM((modrm >> 3) & 0x7).i[3] = XMM(modrm & 0x7).f[3];
6084         } else {
6085                 XMM_REG r;
6086                 UINT32 ea = GetEA(modrm, 0, 16);
6087                 READXMM( ea, r);
6088                 XMM((modrm >> 3) & 0x7).i[0] = r.f[0];
6089                 XMM((modrm >> 3) & 0x7).i[1] = r.f[1];
6090                 XMM((modrm >> 3) & 0x7).i[2] = r.f[2];
6091                 XMM((modrm >> 3) & 0x7).i[3] = r.f[3];
6092         }
6093         CYCLES(1);     // TODO: correct cycle count
6094 }
6095
6096  void I386_OPS_BASE::SSEOP(addpd_r128_rm128)()  // Opcode 66 0f 58
6097 {
6098         UINT8 modrm = FETCH();
6099         if( modrm >= 0xc0 ) {
6100                 XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] + XMM(modrm & 0x7).f64[0];
6101                 XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] + XMM(modrm & 0x7).f64[1];
6102         } else {
6103                 XMM_REG src;
6104                 UINT32 ea = GetEA(modrm, 0, 16);
6105                 READXMM( ea, src);
6106                 XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] + src.f64[0];
6107                 XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] + src.f64[1];
6108         }
6109         CYCLES(1);     // TODO: correct cycle count
6110 }
6111
6112  void I386_OPS_BASE::SSEOP(mulpd_r128_rm128)()  // Opcode 66 0f 59
6113 {
6114         UINT8 modrm = FETCH();
6115         if( modrm >= 0xc0 ) {
6116                 XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] * XMM(modrm & 0x7).f64[0];
6117                 XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] * XMM(modrm & 0x7).f64[1];
6118         } else {
6119                 XMM_REG src;
6120                 UINT32 ea = GetEA(modrm, 0, 16);
6121                 READXMM( ea, src);
6122                 XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] * src.f64[0];
6123                 XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] * src.f64[1];
6124         }
6125         CYCLES(1);     // TODO: correct cycle count
6126 }
6127
6128  void I386_OPS_BASE::SSEOP(subpd_r128_rm128)()  // Opcode 66 0f 5c
6129 {
6130         UINT8 modrm = FETCH();
6131         if( modrm >= 0xc0 ) {
6132                 XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] - XMM(modrm & 0x7).f64[0];
6133                 XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] - XMM(modrm & 0x7).f64[1];
6134         } else {
6135                 XMM_REG src;
6136                 UINT32 ea = GetEA(modrm, 0, 16);
6137                 READXMM( ea, src);
6138                 XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] - src.f64[0];
6139                 XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] - src.f64[1];
6140         }
6141         CYCLES(1);     // TODO: correct cycle count
6142 }
6143
6144  void I386_OPS_BASE::SSEOP(minpd_r128_rm128)()  // Opcode 66 0f 5d
6145 {
6146         UINT8 modrm = FETCH();
6147         if( modrm >= 0xc0 ) {
6148                 XMM((modrm >> 3) & 0x7).f64[0] = sse_min_double(XMM((modrm >> 3) & 0x7).f64[0], XMM(modrm & 0x7).f64[0]);
6149                 XMM((modrm >> 3) & 0x7).f64[1] = sse_min_double(XMM((modrm >> 3) & 0x7).f64[1], XMM(modrm & 0x7).f64[1]);
6150         } else {
6151                 XMM_REG src;
6152                 UINT32 ea = GetEA(modrm, 0, 16);
6153                 READXMM( ea, src);
6154                 XMM((modrm >> 3) & 0x7).f64[0] = sse_min_double(XMM((modrm >> 3) & 0x7).f64[0], src.f64[0]);
6155                 XMM((modrm >> 3) & 0x7).f64[1] = sse_min_double(XMM((modrm >> 3) & 0x7).f64[1], src.f64[1]);
6156         }
6157         CYCLES(1);     // TODO: correct cycle count
6158 }
6159
6160  void I386_OPS_BASE::SSEOP(divpd_r128_rm128)()  // Opcode 66 0f 5e
6161 {
6162         UINT8 modrm = FETCH();
6163         if( modrm >= 0xc0 ) {
6164                 XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] / XMM(modrm & 0x7).f64[0];
6165                 XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] / XMM(modrm & 0x7).f64[1];
6166         } else {
6167                 XMM_REG src;
6168                 UINT32 ea = GetEA(modrm, 0, 16);
6169                 READXMM( ea, src);
6170                 XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] / src.f64[0];
6171                 XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] / src.f64[1];
6172         }
6173         CYCLES(1);     // TODO: correct cycle count
6174 }
6175
6176  void I386_OPS_BASE::SSEOP(maxpd_r128_rm128)()  // Opcode 66 0f 5f
6177 {
6178         UINT8 modrm = FETCH();
6179         if( modrm >= 0xc0 ) {
6180                 XMM((modrm >> 3) & 0x7).f64[0] = sse_max_double(XMM((modrm >> 3) & 0x7).f64[0], XMM(modrm & 0x7).f64[0]);
6181                 XMM((modrm >> 3) & 0x7).f64[1] = sse_max_double(XMM((modrm >> 3) & 0x7).f64[1], XMM(modrm & 0x7).f64[1]);
6182         } else {
6183                 XMM_REG src;
6184                 UINT32 ea = GetEA(modrm, 0, 16);
6185                 READXMM( ea, src);
6186                 XMM((modrm >> 3) & 0x7).f64[0] = sse_max_double(XMM((modrm >> 3) & 0x7).f64[0], src.f64[0]);
6187                 XMM((modrm >> 3) & 0x7).f64[1] = sse_max_double(XMM((modrm >> 3) & 0x7).f64[1], src.f64[1]);
6188         }
6189         CYCLES(1);     // TODO: correct cycle count
6190 }
6191
6192  void I386_OPS_BASE::SSEOP(movntpd_m128_r128)()  // Opcode 66 0f 2b
6193 {
6194         UINT8 modrm = FETCH();
6195         if( modrm >= 0xc0 ) {
6196                 // unsupported by cpu
6197                 CYCLES(1);     // TODO: correct cycle count
6198         } else {
6199                 // since cache is not implemented
6200                 UINT32 ea = GetEA(modrm, 0, 16);
6201                 WRITEXMM( ea, XMM((modrm >> 3) & 0x7));
6202                 CYCLES(1);     // TODO: correct cycle count
6203         }
6204 }
6205
6206  void I386_OPS_BASE::SSEOP(movapd_r128_rm128)()  // Opcode 66 0f 28
6207 {
6208         UINT8 modrm = FETCH();
6209         if( modrm >= 0xc0 ) {
6210                 XMM((modrm >> 3) & 0x7) = XMM(modrm & 0x7);
6211         } else {
6212                 UINT32 ea = GetEA(modrm, 0, 16);
6213                 READXMM( ea, XMM((modrm >> 3) & 0x7));
6214         }
6215         CYCLES(1);     // TODO: correct cycle count
6216 }
6217
6218  void I386_OPS_BASE::SSEOP(movapd_rm128_r128)()  // Opcode 66 0f 29
6219 {
6220         UINT8 modrm = FETCH();
6221         if( modrm >= 0xc0 ) {
6222                 XMM(modrm & 0x7) = XMM((modrm >> 3) & 0x7);
6223         } else {
6224                 UINT32 ea = GetEA(modrm, 0, 16);
6225                 WRITEXMM( ea, XMM((modrm >> 3) & 0x7));
6226         }
6227         CYCLES(1);     // TODO: correct cycle count
6228 }
6229
6230  void I386_OPS_BASE::SSEOP(movsd_r128_r128m64)() // Opcode f2 0f 10
6231 {
6232         UINT8 modrm = FETCH();
6233         if( modrm >= 0xc0 ) {
6234                 XMM((modrm >> 3) & 0x7).q[0] = XMM(modrm & 0x7).q[0];
6235         } else {
6236                 UINT32 ea = GetEA(modrm, 0, 8);
6237                 READXMM_LO64( ea, XMM((modrm >> 3) & 0x7));
6238                 XMM((modrm >> 3) & 0x7).q[1] = 0;
6239         }
6240         CYCLES(1);     // TODO: correct cycle count
6241 }
6242
6243  void I386_OPS_BASE::SSEOP(movsd_r128m64_r128)() // Opcode f2 0f 11
6244 {
6245         UINT8 modrm = FETCH();
6246         if( modrm >= 0xc0 ) {
6247                 XMM(modrm & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0];
6248         } else {
6249                 UINT32 ea = GetEA(modrm, 0, 8);
6250                 WRITEXMM_LO64( ea, XMM((modrm >> 3) & 0x7));
6251         }
6252         CYCLES(1);     // TODO: correct cycle count
6253 }
6254
6255  void I386_OPS_BASE::SSEOP(movddup_r128_r128m64)() // Opcode f2 0f 12
6256 {
6257         UINT8 modrm = FETCH();
6258         if( modrm >= 0xc0 ) {
6259                 XMM((modrm >> 3) & 0x7).q[0] = XMM(modrm & 0x7).q[0];
6260                 XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[0];
6261         } else {
6262                 UINT32 ea = GetEA(modrm, 0, 8);
6263                 READXMM_LO64( ea, XMM((modrm >> 3) & 0x7));
6264                 XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[0];
6265         }
6266         CYCLES(1);     // TODO: correct cycle count
6267 }
6268
6269  void I386_OPS_BASE::SSEOP(cvtsi2sd_r128_rm32)() // Opcode f2 0f 2a
6270 {
6271         UINT8 modrm = FETCH();
6272         if( modrm >= 0xc0 ) {
6273                 XMM((modrm >> 3) & 0x7).f64[0] = (INT32)LOAD_RM32(modrm);
6274         } else {
6275                 UINT32 ea = GetEA(modrm, 0, 4);
6276                 XMM((modrm >> 3) & 0x7).f64[0] = (INT32)READ32(ea);
6277         }
6278         CYCLES(1);     // TODO: correct cycle count
6279 }
6280
6281  void I386_OPS_BASE::SSEOP(cvttsd2si_r32_r128m64)() // Opcode f2 0f 2c
6282 {
6283         INT32 src;
6284         UINT8 modrm = FETCH();
6285         if( modrm >= 0xc0 ) {
6286                 src = (INT32)XMM(modrm & 0x7).f64[0];
6287         } else { // otherwise is a memory address
6288                 XMM_REG t;
6289                 UINT32 ea = GetEA(modrm, 0, 8);
6290                 READXMM_LO64( ea, t);
6291                 src = (INT32)t.f64[0];
6292         }
6293         STORE_REG32(modrm, (UINT32)src);
6294         CYCLES(1);     // TODO: correct cycle count
6295 }
6296
6297  void I386_OPS_BASE::SSEOP(cvtsd2si_r32_r128m64)() // Opcode f2 0f 2d
6298 {
6299         INT32 src;
6300         UINT8 modrm = FETCH();
6301         if( modrm >= 0xc0 ) {
6302                 src = (INT32)XMM(modrm & 0x7).f64[0];
6303         } else { // otherwise is a memory address
6304                 XMM_REG t;
6305                 UINT32 ea = GetEA(modrm, 0, 8);
6306                 READXMM_LO64( ea, t);
6307                 src = (INT32)t.f64[0];
6308         }
6309         STORE_REG32(modrm, (UINT32)src);
6310         CYCLES(1);     // TODO: correct cycle count
6311 }
6312
6313  void I386_OPS_BASE::SSEOP(sqrtsd_r128_r128m64)() // Opcode f2 0f 51
6314 {
6315         UINT8 modrm = FETCH();
6316         if( modrm >= 0xc0 ) {
6317                 int s, d;
6318                 s=modrm & 0x7;
6319                 d=(modrm >> 3) & 0x7;
6320                 XMM(d).f64[0]=sqrt(XMM(s).f64[0]);
6321         } else {
6322                 XMM_REG src;
6323                 int d;
6324                 UINT32 ea = GetEA(modrm, 0, 16);
6325                 d=(modrm >> 3) & 0x7;
6326                 READXMM( ea, src);
6327                 XMM(d).f64[0]=sqrt(src.f64[0]);
6328         }
6329         CYCLES(1);     // TODO: correct cycle count
6330 }
6331
6332  void I386_OPS_BASE::SSEOP(addsd_r128_r128m64)() // Opcode f2 0f 58
6333 {
6334         UINT8 modrm = FETCH();
6335         if( modrm >= 0xc0 ) {
6336                 XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] + XMM(modrm & 0x7).f64[0];
6337         } else {
6338                 XMM_REG src;
6339                 UINT32 ea = GetEA(modrm, 0, 16);
6340                 READXMM( ea, src);
6341                 XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] + src.f64[0];
6342         }
6343         CYCLES(1);     // TODO: correct cycle count
6344 }
6345
6346  void I386_OPS_BASE::SSEOP(mulsd_r128_r128m64)() // Opcode f2 0f 59
6347 {
6348         UINT8 modrm = FETCH();
6349         if( modrm >= 0xc0 ) {
6350                 XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] * XMM(modrm & 0x7).f64[0];
6351         } else {
6352                 XMM_REG src;
6353                 UINT32 ea = GetEA(modrm, 0, 16);
6354                 READXMM( ea, src);
6355                 XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] * src.f64[0];
6356         }
6357         CYCLES(1);     // TODO: correct cycle count
6358 }
6359
6360  void I386_OPS_BASE::SSEOP(cvtsd2ss_r128_r128m64)() // Opcode f2 0f 5a
6361 {
6362         UINT8 modrm = FETCH();
6363         if( modrm >= 0xc0 ) {
6364                 XMM((modrm >> 3) & 0x7).f[0] = XMM(modrm & 0x7).f64[0];
6365         } else {
6366                 XMM_REG s;
6367                 UINT32 ea = GetEA(modrm, 0, 8);
6368                 READXMM_LO64( ea, s);
6369                 XMM((modrm >> 3) & 0x7).f[0] = s.f64[0];
6370         }
6371         CYCLES(1);     // TODO: correct cycle count
6372 }
6373
6374  void I386_OPS_BASE::SSEOP(subsd_r128_r128m64)() // Opcode f2 0f 5c
6375 {
6376         UINT8 modrm = FETCH();
6377         if( modrm >= 0xc0 ) {
6378                 XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] - XMM(modrm & 0x7).f64[0];
6379         } else {
6380                 XMM_REG src;
6381                 UINT32 ea = GetEA(modrm, 0, 16);
6382                 READXMM( ea, src);
6383                 XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] - src.f64[0];
6384         }
6385         CYCLES(1);     // TODO: correct cycle count
6386 }
6387
6388  void I386_OPS_BASE::SSEOP(minsd_r128_r128m64)() // Opcode f2 0f 5d
6389 {
6390         UINT8 modrm = FETCH();
6391         if( modrm >= 0xc0 ) {
6392                 XMM((modrm >> 3) & 0x7).f64[0] = sse_min_double(XMM((modrm >> 3) & 0x7).f64[0], XMM(modrm & 0x7).f64[0]);
6393         } else {
6394                 XMM_REG src;
6395                 UINT32 ea = GetEA(modrm, 0, 16);
6396                 READXMM( ea, src);
6397                 XMM((modrm >> 3) & 0x7).f64[0] = sse_min_double(XMM((modrm >> 3) & 0x7).f64[0], src.f64[0]);
6398         }
6399         CYCLES(1);     // TODO: correct cycle count
6400 }
6401
6402  void I386_OPS_BASE::SSEOP(divsd_r128_r128m64)() // Opcode f2 0f 5e
6403 {
6404         UINT8 modrm = FETCH();
6405         if( modrm >= 0xc0 ) {
6406                 XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] / XMM(modrm & 0x7).f64[0];
6407         } else {
6408                 XMM_REG src;
6409                 UINT32 ea = GetEA(modrm, 0, 16);
6410                 READXMM( ea, src);
6411                 XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] / src.f64[0];
6412         }
6413         CYCLES(1);     // TODO: correct cycle count
6414 }
6415
6416  void I386_OPS_BASE::SSEOP(maxsd_r128_r128m64)() // Opcode f2 0f 5f
6417 {
6418         UINT8 modrm = FETCH();
6419         if( modrm >= 0xc0 ) {
6420                 XMM((modrm >> 3) & 0x7).f64[0] = sse_max_double(XMM((modrm >> 3) & 0x7).f64[0], XMM(modrm & 0x7).f64[0]);
6421         } else {
6422                 XMM_REG src;
6423                 UINT32 ea = GetEA(modrm, 0, 16);
6424                 READXMM( ea, src);
6425                 XMM((modrm >> 3) & 0x7).f64[0] = sse_max_double(XMM((modrm >> 3) & 0x7).f64[0], src.f64[0]);
6426         }
6427         CYCLES(1);     // TODO: correct cycle count
6428 }
6429
6430  void I386_OPS_BASE::SSEOP(haddps_r128_rm128)() // Opcode f2 0f 7c
6431 {
6432         UINT8 modrm = FETCH();
6433         if( modrm >= 0xc0 ) {
6434                 int s, d;
6435                 float f1, f2, f3, f4;
6436                 s=modrm & 0x7;
6437                 d=(modrm >> 3) & 0x7;
6438                 f1=XMM(d).f[0]+XMM(d).f[1];
6439                 f2=XMM(d).f[2]+XMM(d).f[3];
6440                 f3=XMM(s).f[0]+XMM(s).f[1];
6441                 f4=XMM(s).f[2]+XMM(s).f[3];
6442                 XMM(d).f[0]=f1;
6443                 XMM(d).f[1]=f2;
6444                 XMM(d).f[2]=f3;
6445                 XMM(d).f[3]=f4;
6446         } else {
6447                 XMM_REG src;
6448                 int d;
6449                 float f1, f2;
6450                 UINT32 ea = GetEA(modrm, 0, 16);
6451                 d=(modrm >> 3) & 0x7;
6452                 READXMM( ea, src);
6453                 f1=XMM(d).f[0]+XMM(d).f[1];
6454                 f2=XMM(d).f[2]+XMM(d).f[3];
6455                 XMM(d).f[0]=f1;
6456                 XMM(d).f[1]=f2;
6457                 XMM(d).f[2]=src.f[0]+src.f[1];
6458                 XMM(d).f[3]=src.f[2]+src.f[3];
6459         }
6460         CYCLES(1);     // TODO: correct cycle count
6461 }
6462
6463  void I386_OPS_BASE::SSEOP(hsubps_r128_rm128)() // Opcode f2 0f 7d
6464 {
6465         UINT8 modrm = FETCH();
6466         if( modrm >= 0xc0 ) {
6467                 int s, d;
6468                 float f1, f2, f3, f4;
6469                 s=modrm & 0x7;
6470                 d=(modrm >> 3) & 0x7;
6471                 f1=XMM(d).f[0]-XMM(d).f[1];
6472                 f2=XMM(d).f[2]-XMM(d).f[3];
6473                 f3=XMM(s).f[0]-XMM(s).f[1];
6474                 f4=XMM(s).f[2]-XMM(s).f[3];
6475                 XMM(d).f[0]=f1;
6476                 XMM(d).f[1]=f2;
6477                 XMM(d).f[2]=f3;
6478                 XMM(d).f[3]=f4;
6479         } else {
6480                 XMM_REG src;
6481                 int d;
6482                 float f1, f2;
6483                 UINT32 ea = GetEA(modrm, 0, 16);
6484                 d=(modrm >> 3) & 0x7;
6485                 READXMM( ea, src);
6486                 f1=XMM(d).f[0]-XMM(d).f[1];
6487                 f2=XMM(d).f[2]-XMM(d).f[3];
6488                 XMM(d).f[0]=f1;
6489                 XMM(d).f[1]=f2;
6490                 XMM(d).f[2]=src.f[0]-src.f[1];
6491                 XMM(d).f[3]=src.f[2]-src.f[3];
6492         }
6493         CYCLES(1);     // TODO: correct cycle count
6494 }
6495
6496  void I386_OPS_BASE::SSEOP(cmpsd_r128_r128m64_i8)() // Opcode f2 0f c2
6497 {
6498         UINT8 modrm = FETCH();
6499         if( modrm >= 0xc0 ) {
6500                 int s,d;
6501                 UINT8 imm8 = FETCH();
6502                 s=modrm & 0x7;
6503                 d=(modrm >> 3) & 0x7;
6504                 sse_predicate_compare_double_scalar(imm8, XMM(d), XMM(s));
6505         } else {
6506                 int d;
6507                 XMM_REG s;
6508                 UINT32 ea = GetEA(modrm, 0, 8);
6509                 UINT8 imm8 = FETCH();
6510                 READXMM_LO64( ea, s);
6511                 d=(modrm >> 3) & 0x7;
6512                 sse_predicate_compare_double_scalar(imm8, XMM(d), s);
6513         }
6514         CYCLES(1);     // TODO: correct cycle count
6515 }
6516
6517  void I386_OPS_BASE::SSEOP(addsubps_r128_rm128)() // Opcode f2 0f d0
6518 {
6519         UINT8 modrm = FETCH();
6520         if( modrm >= 0xc0 ) {
6521                 XMM((modrm >> 3) & 0x7).f[0]=XMM((modrm >> 3) & 0x7).f[0] - XMM(modrm & 0x7).f[0];
6522                 XMM((modrm >> 3) & 0x7).f[1]=XMM((modrm >> 3) & 0x7).f[1] + XMM(modrm & 0x7).f[1];
6523                 XMM((modrm >> 3) & 0x7).f[2]=XMM((modrm >> 3) & 0x7).f[2] - XMM(modrm & 0x7).f[2];
6524                 XMM((modrm >> 3) & 0x7).f[3]=XMM((modrm >> 3) & 0x7).f[3] + XMM(modrm & 0x7).f[3];
6525         } else {
6526                 XMM_REG src;
6527                 UINT32 ea = GetEA(modrm, 0, 16);
6528                 READXMM( ea, src);
6529                 XMM((modrm >> 3) & 0x7).f[0]=XMM((modrm >> 3) & 0x7).f[0] - src.f[0];
6530                 XMM((modrm >> 3) & 0x7).f[1]=XMM((modrm >> 3) & 0x7).f[1] + src.f[1];
6531                 XMM((modrm >> 3) & 0x7).f[2]=XMM((modrm >> 3) & 0x7).f[2] - src.f[2];
6532                 XMM((modrm >> 3) & 0x7).f[3]=XMM((modrm >> 3) & 0x7).f[3] + src.f[3];
6533         }
6534         CYCLES(1);     // TODO: correct cycle count
6535 }
6536
6537  void I386_OPS_BASE::SSEOP(movdq2q_r64_r128)() // Opcode f2 0f d6
6538 {
6539         UINT8 modrm = FETCH();
6540         MMXPROLOG();
6541         if( modrm >= 0xc0 ) {
6542                 MMX((modrm >> 3) & 0x7).q = XMM(modrm & 0x7).q[0];
6543                 CYCLES(1);     // TODO: correct cycle count
6544         } else {
6545                 // unsupported by cpu
6546                 CYCLES(1);     // TODO: correct cycle count
6547         }
6548 }
6549
6550  void I386_OPS_BASE::SSEOP(cvtpd2dq_r128_rm128)() // Opcode f2 0f e6
6551 {
6552         UINT8 modrm = FETCH();
6553         if( modrm >= 0xc0 ) {
6554                 XMM((modrm >> 3) & 0x7).i[0]=(INT32)XMM((modrm >> 3) & 0x7).f64[0];
6555                 XMM((modrm >> 3) & 0x7).i[1]=(INT32)XMM((modrm >> 3) & 0x7).f64[1];
6556                 XMM((modrm >> 3) & 0x7).q[1] = 0;
6557         } else {
6558                 XMM_REG src;
6559                 UINT32 ea = GetEA(modrm, 0, 16);
6560                 READXMM( ea, src);
6561                 XMM((modrm >> 3) & 0x7).i[0]=(INT32)src.f64[0];
6562                 XMM((modrm >> 3) & 0x7).i[1]=(INT32)src.f64[1];
6563                 XMM((modrm >> 3) & 0x7).q[1] = 0;
6564         }
6565         CYCLES(1);     // TODO: correct cycle count
6566 }
6567
6568 void I386_OPS_BASE::SSEOP(lddqu_r128_m128)() // Opcode f2 0f f0
6569 {
6570         UINT8 modrm = FETCH();
6571         if( modrm >= 0xc0 ) {
6572                 // unsupported by cpu
6573                 CYCLES(1);     // TODO: correct cycle count
6574         } else {
6575                 UINT32 ea = GetEA(modrm, 0, 16);
6576                 READXMM(ea, XMM((modrm >> 3) & 0x7));
6577         }
6578 }