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

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