src/libcpu/m68kopnz.c

   1 #include "m68kcpu.h"
   2
   3 /* ======================================================================== */
   4 /* ========================= INSTRUCTION HANDLERS ========================= */
   5 /* ======================================================================== */
   6
   7
   8 void m68k_op_nbcd_8_d(void)
   9 {
  10         uint* r_dst = &DY;
  11         uint dst = *r_dst;
  12         uint res = MASK_OUT_ABOVE_8(0x9a - dst - XFLAG_AS_1());
  13
  14         if(res != 0x9a)
  15         {
  16                 FLAG_V = ~res; /* Undefined V behavior */
  17
  18                 if((res & 0x0f) == 0xa)
  19                         res = (res & 0xf0) + 0x10;
  20
  21                 res = MASK_OUT_ABOVE_8(res);
  22
  23                 FLAG_V &= res; /* Undefined V behavior part II */
  24
  25                 *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
  26
  27                 FLAG_Z |= res;
  28                 FLAG_C = CFLAG_SET;
  29                 FLAG_X = XFLAG_SET;
  30         }
  31         else
  32         {
  33                 FLAG_V = VFLAG_CLEAR;
  34                 FLAG_C = CFLAG_CLEAR;
  35                 FLAG_X = XFLAG_CLEAR;
  36         }
  37         FLAG_N = NFLAG_8(res);  /* Undefined N behavior */
  38 }
  39
  40
  41 void m68k_op_nbcd_8_ai(void)
  42 {
  43         uint ea = EA_AY_AI_8();
  44         uint dst = m68ki_read_8(ea);
  45         uint res = MASK_OUT_ABOVE_8(0x9a - dst - XFLAG_AS_1());
  46
  47         if(res != 0x9a)
  48         {
  49                 FLAG_V = ~res; /* Undefined V behavior */
  50
  51                 if((res & 0x0f) == 0xa)
  52                         res = (res & 0xf0) + 0x10;
  53
  54                 res = MASK_OUT_ABOVE_8(res);
  55
  56                 FLAG_V &= res; /* Undefined V behavior part II */
  57
  58                 m68ki_write_8(ea, MASK_OUT_ABOVE_8(res));
  59
  60                 FLAG_Z |= res;
  61                 FLAG_C = CFLAG_SET;
  62                 FLAG_X = XFLAG_SET;
  63         }
  64         else
  65         {
  66                 FLAG_V = VFLAG_CLEAR;
  67                 FLAG_C = CFLAG_CLEAR;
  68                 FLAG_X = XFLAG_CLEAR;
  69         }
  70         FLAG_N = NFLAG_8(res);  /* Undefined N behavior */
  71 }
  72
  73
  74 void m68k_op_nbcd_8_pi(void)
  75 {
  76         uint ea = EA_AY_PI_8();
  77         uint dst = m68ki_read_8(ea);
  78         uint res = MASK_OUT_ABOVE_8(0x9a - dst - XFLAG_AS_1());
  79
  80         if(res != 0x9a)
  81         {
  82                 FLAG_V = ~res; /* Undefined V behavior */
  83
  84                 if((res & 0x0f) == 0xa)
  85                         res = (res & 0xf0) + 0x10;
  86
  87                 res = MASK_OUT_ABOVE_8(res);
  88
  89                 FLAG_V &= res; /* Undefined V behavior part II */
  90
  91                 m68ki_write_8(ea, MASK_OUT_ABOVE_8(res));
  92
  93                 FLAG_Z |= res;
  94                 FLAG_C = CFLAG_SET;
  95                 FLAG_X = XFLAG_SET;
  96         }
  97         else
  98         {
  99                 FLAG_V = VFLAG_CLEAR;
 100                 FLAG_C = CFLAG_CLEAR;
 101                 FLAG_X = XFLAG_CLEAR;
 102         }
 103         FLAG_N = NFLAG_8(res);  /* Undefined N behavior */
 104 }
 105
 106
 107 void m68k_op_nbcd_8_pi7(void)
 108 {
 109         uint ea = EA_A7_PI_8();
 110         uint dst = m68ki_read_8(ea);
 111         uint res = MASK_OUT_ABOVE_8(0x9a - dst - XFLAG_AS_1());
 112
 113         if(res != 0x9a)
 114         {
 115                 FLAG_V = ~res; /* Undefined V behavior */
 116
 117                 if((res & 0x0f) == 0xa)
 118                         res = (res & 0xf0) + 0x10;
 119
 120                 res = MASK_OUT_ABOVE_8(res);
 121
 122                 FLAG_V &= res; /* Undefined V behavior part II */
 123
 124                 m68ki_write_8(ea, MASK_OUT_ABOVE_8(res));
 125
 126                 FLAG_Z |= res;
 127                 FLAG_C = CFLAG_SET;
 128                 FLAG_X = XFLAG_SET;
 129         }
 130         else
 131         {
 132                 FLAG_V = VFLAG_CLEAR;
 133                 FLAG_C = CFLAG_CLEAR;
 134                 FLAG_X = XFLAG_CLEAR;
 135         }
 136         FLAG_N = NFLAG_8(res);  /* Undefined N behavior */
 137 }
 138
 139
 140 void m68k_op_nbcd_8_pd(void)
 141 {
 142         uint ea = EA_AY_PD_8();
 143         uint dst = m68ki_read_8(ea);
 144         uint res = MASK_OUT_ABOVE_8(0x9a - dst - XFLAG_AS_1());
 145
 146         if(res != 0x9a)
 147         {
 148                 FLAG_V = ~res; /* Undefined V behavior */
 149
 150                 if((res & 0x0f) == 0xa)
 151                         res = (res & 0xf0) + 0x10;
 152
 153                 res = MASK_OUT_ABOVE_8(res);
 154
 155                 FLAG_V &= res; /* Undefined V behavior part II */
 156
 157                 m68ki_write_8(ea, MASK_OUT_ABOVE_8(res));
 158
 159                 FLAG_Z |= res;
 160                 FLAG_C = CFLAG_SET;
 161                 FLAG_X = XFLAG_SET;
 162         }
 163         else
 164         {
 165                 FLAG_V = VFLAG_CLEAR;
 166                 FLAG_C = CFLAG_CLEAR;
 167                 FLAG_X = XFLAG_CLEAR;
 168         }
 169         FLAG_N = NFLAG_8(res);  /* Undefined N behavior */
 170 }
 171
 172
 173 void m68k_op_nbcd_8_pd7(void)
 174 {
 175         uint ea = EA_A7_PD_8();
 176         uint dst = m68ki_read_8(ea);
 177         uint res = MASK_OUT_ABOVE_8(0x9a - dst - XFLAG_AS_1());
 178
 179         if(res != 0x9a)
 180         {
 181                 FLAG_V = ~res; /* Undefined V behavior */
 182
 183                 if((res & 0x0f) == 0xa)
 184                         res = (res & 0xf0) + 0x10;
 185
 186                 res = MASK_OUT_ABOVE_8(res);
 187
 188                 FLAG_V &= res; /* Undefined V behavior part II */
 189
 190                 m68ki_write_8(ea, MASK_OUT_ABOVE_8(res));
 191
 192                 FLAG_Z |= res;
 193                 FLAG_C = CFLAG_SET;
 194                 FLAG_X = XFLAG_SET;
 195         }
 196         else
 197         {
 198                 FLAG_V = VFLAG_CLEAR;
 199                 FLAG_C = CFLAG_CLEAR;
 200                 FLAG_X = XFLAG_CLEAR;
 201         }
 202         FLAG_N = NFLAG_8(res);  /* Undefined N behavior */
 203 }
 204
 205
 206 void m68k_op_nbcd_8_di(void)
 207 {
 208         uint ea = EA_AY_DI_8();
 209         uint dst = m68ki_read_8(ea);
 210         uint res = MASK_OUT_ABOVE_8(0x9a - dst - XFLAG_AS_1());
 211
 212         if(res != 0x9a)
 213         {
 214                 FLAG_V = ~res; /* Undefined V behavior */
 215
 216                 if((res & 0x0f) == 0xa)
 217                         res = (res & 0xf0) + 0x10;
 218
 219                 res = MASK_OUT_ABOVE_8(res);
 220
 221                 FLAG_V &= res; /* Undefined V behavior part II */
 222
 223                 m68ki_write_8(ea, MASK_OUT_ABOVE_8(res));
 224
 225                 FLAG_Z |= res;
 226                 FLAG_C = CFLAG_SET;
 227                 FLAG_X = XFLAG_SET;
 228         }
 229         else
 230         {
 231                 FLAG_V = VFLAG_CLEAR;
 232                 FLAG_C = CFLAG_CLEAR;
 233                 FLAG_X = XFLAG_CLEAR;
 234         }
 235         FLAG_N = NFLAG_8(res);  /* Undefined N behavior */
 236 }
 237
 238
 239 void m68k_op_nbcd_8_ix(void)
 240 {
 241         uint ea = EA_AY_IX_8();
 242         uint dst = m68ki_read_8(ea);
 243         uint res = MASK_OUT_ABOVE_8(0x9a - dst - XFLAG_AS_1());
 244
 245         if(res != 0x9a)
 246         {
 247                 FLAG_V = ~res; /* Undefined V behavior */
 248
 249                 if((res & 0x0f) == 0xa)
 250                         res = (res & 0xf0) + 0x10;
 251
 252                 res = MASK_OUT_ABOVE_8(res);
 253
 254                 FLAG_V &= res; /* Undefined V behavior part II */
 255
 256                 m68ki_write_8(ea, MASK_OUT_ABOVE_8(res));
 257
 258                 FLAG_Z |= res;
 259                 FLAG_C = CFLAG_SET;
 260                 FLAG_X = XFLAG_SET;
 261         }
 262         else
 263         {
 264                 FLAG_V = VFLAG_CLEAR;
 265                 FLAG_C = CFLAG_CLEAR;
 266                 FLAG_X = XFLAG_CLEAR;
 267         }
 268         FLAG_N = NFLAG_8(res);  /* Undefined N behavior */
 269 }
 270
 271
 272 void m68k_op_nbcd_8_aw(void)
 273 {
 274         uint ea = EA_AW_8();
 275         uint dst = m68ki_read_8(ea);
 276         uint res = MASK_OUT_ABOVE_8(0x9a - dst - XFLAG_AS_1());
 277
 278         if(res != 0x9a)
 279         {
 280                 FLAG_V = ~res; /* Undefined V behavior */
 281
 282                 if((res & 0x0f) == 0xa)
 283                         res = (res & 0xf0) + 0x10;
 284
 285                 res = MASK_OUT_ABOVE_8(res);
 286
 287                 FLAG_V &= res; /* Undefined V behavior part II */
 288
 289                 m68ki_write_8(ea, MASK_OUT_ABOVE_8(res));
 290
 291                 FLAG_Z |= res;
 292                 FLAG_C = CFLAG_SET;
 293                 FLAG_X = XFLAG_SET;
 294         }
 295         else
 296         {
 297                 FLAG_V = VFLAG_CLEAR;
 298                 FLAG_C = CFLAG_CLEAR;
 299                 FLAG_X = XFLAG_CLEAR;
 300         }
 301         FLAG_N = NFLAG_8(res);  /* Undefined N behavior */
 302 }
 303
 304
 305 void m68k_op_nbcd_8_al(void)
 306 {
 307         uint ea = EA_AL_8();
 308         uint dst = m68ki_read_8(ea);
 309         uint res = MASK_OUT_ABOVE_8(0x9a - dst - XFLAG_AS_1());
 310
 311         if(res != 0x9a)
 312         {
 313                 FLAG_V = ~res; /* Undefined V behavior */
 314
 315                 if((res & 0x0f) == 0xa)
 316                         res = (res & 0xf0) + 0x10;
 317
 318                 res = MASK_OUT_ABOVE_8(res);
 319
 320                 FLAG_V &= res; /* Undefined V behavior part II */
 321
 322                 m68ki_write_8(ea, MASK_OUT_ABOVE_8(res));
 323
 324                 FLAG_Z |= res;
 325                 FLAG_C = CFLAG_SET;
 326                 FLAG_X = XFLAG_SET;
 327         }
 328         else
 329         {
 330                 FLAG_V = VFLAG_CLEAR;
 331                 FLAG_C = CFLAG_CLEAR;
 332                 FLAG_X = XFLAG_CLEAR;
 333         }
 334         FLAG_N = NFLAG_8(res);  /* Undefined N behavior */
 335 }
 336
 337
 338 void m68k_op_neg_8_d(void)
 339 {
 340         uint* r_dst = &DY;
 341         uint res = 0 - MASK_OUT_ABOVE_8(*r_dst);
 342
 343         FLAG_N = NFLAG_8(res);
 344         FLAG_C = FLAG_X = CFLAG_8(res);
 345         FLAG_V = *r_dst & res;
 346         FLAG_Z = MASK_OUT_ABOVE_8(res);
 347
 348         *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
 349 }
 350
 351
 352 void m68k_op_neg_8_ai(void)
 353 {
 354         uint ea = EA_AY_AI_8();
 355         uint src = m68ki_read_8(ea);
 356         uint res = 0 - src;
 357
 358         FLAG_N = NFLAG_8(res);
 359         FLAG_C = FLAG_X = CFLAG_8(res);
 360         FLAG_V = src & res;
 361         FLAG_Z = MASK_OUT_ABOVE_8(res);
 362
 363         m68ki_write_8(ea, FLAG_Z);
 364 }
 365
 366
 367 void m68k_op_neg_8_pi(void)
 368 {
 369         uint ea = EA_AY_PI_8();
 370         uint src = m68ki_read_8(ea);
 371         uint res = 0 - src;
 372
 373         FLAG_N = NFLAG_8(res);
 374         FLAG_C = FLAG_X = CFLAG_8(res);
 375         FLAG_V = src & res;
 376         FLAG_Z = MASK_OUT_ABOVE_8(res);
 377
 378         m68ki_write_8(ea, FLAG_Z);
 379 }
 380
 381
 382 void m68k_op_neg_8_pi7(void)
 383 {
 384         uint ea = EA_A7_PI_8();
 385         uint src = m68ki_read_8(ea);
 386         uint res = 0 - src;
 387
 388         FLAG_N = NFLAG_8(res);
 389         FLAG_C = FLAG_X = CFLAG_8(res);
 390         FLAG_V = src & res;
 391         FLAG_Z = MASK_OUT_ABOVE_8(res);
 392
 393         m68ki_write_8(ea, FLAG_Z);
 394 }
 395
 396
 397 void m68k_op_neg_8_pd(void)
 398 {
 399         uint ea = EA_AY_PD_8();
 400         uint src = m68ki_read_8(ea);
 401         uint res = 0 - src;
 402
 403         FLAG_N = NFLAG_8(res);
 404         FLAG_C = FLAG_X = CFLAG_8(res);
 405         FLAG_V = src & res;
 406         FLAG_Z = MASK_OUT_ABOVE_8(res);
 407
 408         m68ki_write_8(ea, FLAG_Z);
 409 }
 410
 411
 412 void m68k_op_neg_8_pd7(void)
 413 {
 414         uint ea = EA_A7_PD_8();
 415         uint src = m68ki_read_8(ea);
 416         uint res = 0 - src;
 417
 418         FLAG_N = NFLAG_8(res);
 419         FLAG_C = FLAG_X = CFLAG_8(res);
 420         FLAG_V = src & res;
 421         FLAG_Z = MASK_OUT_ABOVE_8(res);
 422
 423         m68ki_write_8(ea, FLAG_Z);
 424 }
 425
 426
 427 void m68k_op_neg_8_di(void)
 428 {
 429         uint ea = EA_AY_DI_8();
 430         uint src = m68ki_read_8(ea);
 431         uint res = 0 - src;
 432
 433         FLAG_N = NFLAG_8(res);
 434         FLAG_C = FLAG_X = CFLAG_8(res);
 435         FLAG_V = src & res;
 436         FLAG_Z = MASK_OUT_ABOVE_8(res);
 437
 438         m68ki_write_8(ea, FLAG_Z);
 439 }
 440
 441
 442 void m68k_op_neg_8_ix(void)
 443 {
 444         uint ea = EA_AY_IX_8();
 445         uint src = m68ki_read_8(ea);
 446         uint res = 0 - src;
 447
 448         FLAG_N = NFLAG_8(res);
 449         FLAG_C = FLAG_X = CFLAG_8(res);
 450         FLAG_V = src & res;
 451         FLAG_Z = MASK_OUT_ABOVE_8(res);
 452
 453         m68ki_write_8(ea, FLAG_Z);
 454 }
 455
 456
 457 void m68k_op_neg_8_aw(void)
 458 {
 459         uint ea = EA_AW_8();
 460         uint src = m68ki_read_8(ea);
 461         uint res = 0 - src;
 462
 463         FLAG_N = NFLAG_8(res);
 464         FLAG_C = FLAG_X = CFLAG_8(res);
 465         FLAG_V = src & res;
 466         FLAG_Z = MASK_OUT_ABOVE_8(res);
 467
 468         m68ki_write_8(ea, FLAG_Z);
 469 }
 470
 471
 472 void m68k_op_neg_8_al(void)
 473 {
 474         uint ea = EA_AL_8();
 475         uint src = m68ki_read_8(ea);
 476         uint res = 0 - src;
 477
 478         FLAG_N = NFLAG_8(res);
 479         FLAG_C = FLAG_X = CFLAG_8(res);
 480         FLAG_V = src & res;
 481         FLAG_Z = MASK_OUT_ABOVE_8(res);
 482
 483         m68ki_write_8(ea, FLAG_Z);
 484 }
 485
 486
 487 void m68k_op_neg_16_d(void)
 488 {
 489         uint* r_dst = &DY;
 490         uint res = 0 - MASK_OUT_ABOVE_16(*r_dst);
 491
 492         FLAG_N = NFLAG_16(res);
 493         FLAG_C = FLAG_X = CFLAG_16(res);
 494         FLAG_V = (*r_dst & res)>>8;
 495         FLAG_Z = MASK_OUT_ABOVE_16(res);
 496
 497         *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
 498 }
 499
 500
 501 void m68k_op_neg_16_ai(void)
 502 {
 503         uint ea = EA_AY_AI_16();
 504         uint src = m68ki_read_16(ea);
 505         uint res = 0 - src;
 506
 507         FLAG_N = NFLAG_16(res);
 508         FLAG_C = FLAG_X = CFLAG_16(res);
 509         FLAG_V = (src & res)>>8;
 510         FLAG_Z = MASK_OUT_ABOVE_16(res);
 511
 512         m68ki_write_16(ea, FLAG_Z);
 513 }
 514
 515
 516 void m68k_op_neg_16_pi(void)
 517 {
 518         uint ea = EA_AY_PI_16();
 519         uint src = m68ki_read_16(ea);
 520         uint res = 0 - src;
 521
 522         FLAG_N = NFLAG_16(res);
 523         FLAG_C = FLAG_X = CFLAG_16(res);
 524         FLAG_V = (src & res)>>8;
 525         FLAG_Z = MASK_OUT_ABOVE_16(res);
 526
 527         m68ki_write_16(ea, FLAG_Z);
 528 }
 529
 530
 531 void m68k_op_neg_16_pd(void)
 532 {
 533         uint ea = EA_AY_PD_16();
 534         uint src = m68ki_read_16(ea);
 535         uint res = 0 - src;
 536
 537         FLAG_N = NFLAG_16(res);
 538         FLAG_C = FLAG_X = CFLAG_16(res);
 539         FLAG_V = (src & res)>>8;
 540         FLAG_Z = MASK_OUT_ABOVE_16(res);
 541
 542         m68ki_write_16(ea, FLAG_Z);
 543 }
 544
 545
 546 void m68k_op_neg_16_di(void)
 547 {
 548         uint ea = EA_AY_DI_16();
 549         uint src = m68ki_read_16(ea);
 550         uint res = 0 - src;
 551
 552         FLAG_N = NFLAG_16(res);
 553         FLAG_C = FLAG_X = CFLAG_16(res);
 554         FLAG_V = (src & res)>>8;
 555         FLAG_Z = MASK_OUT_ABOVE_16(res);
 556
 557         m68ki_write_16(ea, FLAG_Z);
 558 }
 559
 560
 561 void m68k_op_neg_16_ix(void)
 562 {
 563         uint ea = EA_AY_IX_16();
 564         uint src = m68ki_read_16(ea);
 565         uint res = 0 - src;
 566
 567         FLAG_N = NFLAG_16(res);
 568         FLAG_C = FLAG_X = CFLAG_16(res);
 569         FLAG_V = (src & res)>>8;
 570         FLAG_Z = MASK_OUT_ABOVE_16(res);
 571
 572         m68ki_write_16(ea, FLAG_Z);
 573 }
 574
 575
 576 void m68k_op_neg_16_aw(void)
 577 {
 578         uint ea = EA_AW_16();
 579         uint src = m68ki_read_16(ea);
 580         uint res = 0 - src;
 581
 582         FLAG_N = NFLAG_16(res);
 583         FLAG_C = FLAG_X = CFLAG_16(res);
 584         FLAG_V = (src & res)>>8;
 585         FLAG_Z = MASK_OUT_ABOVE_16(res);
 586
 587         m68ki_write_16(ea, FLAG_Z);
 588 }
 589
 590
 591 void m68k_op_neg_16_al(void)
 592 {
 593         uint ea = EA_AL_16();
 594         uint src = m68ki_read_16(ea);
 595         uint res = 0 - src;
 596
 597         FLAG_N = NFLAG_16(res);
 598         FLAG_C = FLAG_X = CFLAG_16(res);
 599         FLAG_V = (src & res)>>8;
 600         FLAG_Z = MASK_OUT_ABOVE_16(res);
 601
 602         m68ki_write_16(ea, FLAG_Z);
 603 }
 604
 605
 606 void m68k_op_neg_32_d(void)
 607 {
 608         uint* r_dst = &DY;
 609         uint res = 0 - *r_dst;
 610
 611         FLAG_N = NFLAG_32(res);
 612         FLAG_C = FLAG_X = CFLAG_SUB_32(*r_dst, 0, res);
 613         FLAG_V = (*r_dst & res)>>24;
 614         FLAG_Z = MASK_OUT_ABOVE_32(res);
 615
 616         *r_dst = FLAG_Z;
 617 }
 618
 619
 620 void m68k_op_neg_32_ai(void)
 621 {
 622         uint ea = EA_AY_AI_32();
 623         uint src = m68ki_read_32(ea);
 624         uint res = 0 - src;
 625
 626         FLAG_N = NFLAG_32(res);
 627         FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);
 628         FLAG_V = (src & res)>>24;
 629         FLAG_Z = MASK_OUT_ABOVE_32(res);
 630
 631         m68ki_write_32(ea, FLAG_Z);
 632 }
 633
 634
 635 void m68k_op_neg_32_pi(void)
 636 {
 637         uint ea = EA_AY_PI_32();
 638         uint src = m68ki_read_32(ea);
 639         uint res = 0 - src;
 640
 641         FLAG_N = NFLAG_32(res);
 642         FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);
 643         FLAG_V = (src & res)>>24;
 644         FLAG_Z = MASK_OUT_ABOVE_32(res);
 645
 646         m68ki_write_32(ea, FLAG_Z);
 647 }
 648
 649
 650 void m68k_op_neg_32_pd(void)
 651 {
 652         uint ea = EA_AY_PD_32();
 653         uint src = m68ki_read_32(ea);
 654         uint res = 0 - src;
 655
 656         FLAG_N = NFLAG_32(res);
 657         FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);
 658         FLAG_V = (src & res)>>24;
 659         FLAG_Z = MASK_OUT_ABOVE_32(res);
 660
 661         m68ki_write_32(ea, FLAG_Z);
 662 }
 663
 664
 665 void m68k_op_neg_32_di(void)
 666 {
 667         uint ea = EA_AY_DI_32();
 668         uint src = m68ki_read_32(ea);
 669         uint res = 0 - src;
 670
 671         FLAG_N = NFLAG_32(res);
 672         FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);
 673         FLAG_V = (src & res)>>24;
 674         FLAG_Z = MASK_OUT_ABOVE_32(res);
 675
 676         m68ki_write_32(ea, FLAG_Z);
 677 }
 678
 679
 680 void m68k_op_neg_32_ix(void)
 681 {
 682         uint ea = EA_AY_IX_32();
 683         uint src = m68ki_read_32(ea);
 684         uint res = 0 - src;
 685
 686         FLAG_N = NFLAG_32(res);
 687         FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);
 688         FLAG_V = (src & res)>>24;
 689         FLAG_Z = MASK_OUT_ABOVE_32(res);
 690
 691         m68ki_write_32(ea, FLAG_Z);
 692 }
 693
 694
 695 void m68k_op_neg_32_aw(void)
 696 {
 697         uint ea = EA_AW_32();
 698         uint src = m68ki_read_32(ea);
 699         uint res = 0 - src;
 700
 701         FLAG_N = NFLAG_32(res);
 702         FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);
 703         FLAG_V = (src & res)>>24;
 704         FLAG_Z = MASK_OUT_ABOVE_32(res);
 705
 706         m68ki_write_32(ea, FLAG_Z);
 707 }
 708
 709
 710 void m68k_op_neg_32_al(void)
 711 {
 712         uint ea = EA_AL_32();
 713         uint src = m68ki_read_32(ea);
 714         uint res = 0 - src;
 715
 716         FLAG_N = NFLAG_32(res);
 717         FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);
 718         FLAG_V = (src & res)>>24;
 719         FLAG_Z = MASK_OUT_ABOVE_32(res);
 720
 721         m68ki_write_32(ea, FLAG_Z);
 722 }
 723
 724
 725 void m68k_op_negx_8_d(void)
 726 {
 727         uint* r_dst = &DY;
 728         uint res = 0 - MASK_OUT_ABOVE_8(*r_dst) - XFLAG_AS_1();
 729
 730         FLAG_N = NFLAG_8(res);
 731         FLAG_X = FLAG_C = CFLAG_8(res);
 732         FLAG_V = *r_dst & res;
 733
 734         res = MASK_OUT_ABOVE_8(res);
 735         FLAG_Z |= res;
 736
 737         *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
 738 }
 739
 740
 741 void m68k_op_negx_8_ai(void)
 742 {
 743         uint ea = EA_AY_AI_8();
 744         uint src = m68ki_read_8(ea);
 745         uint res = 0 - src - XFLAG_AS_1();
 746
 747         FLAG_N = NFLAG_8(res);
 748         FLAG_X = FLAG_C = CFLAG_8(res);
 749         FLAG_V = src & res;
 750
 751         res = MASK_OUT_ABOVE_8(res);
 752         FLAG_Z |= res;
 753
 754         m68ki_write_8(ea, res);
 755 }
 756
 757
 758 void m68k_op_negx_8_pi(void)
 759 {
 760         uint ea = EA_AY_PI_8();
 761         uint src = m68ki_read_8(ea);
 762         uint res = 0 - src - XFLAG_AS_1();
 763
 764         FLAG_N = NFLAG_8(res);
 765         FLAG_X = FLAG_C = CFLAG_8(res);
 766         FLAG_V = src & res;
 767
 768         res = MASK_OUT_ABOVE_8(res);
 769         FLAG_Z |= res;
 770
 771         m68ki_write_8(ea, res);
 772 }
 773
 774
 775 void m68k_op_negx_8_pi7(void)
 776 {
 777         uint ea = EA_A7_PI_8();
 778         uint src = m68ki_read_8(ea);
 779         uint res = 0 - src - XFLAG_AS_1();
 780
 781         FLAG_N = NFLAG_8(res);
 782         FLAG_X = FLAG_C = CFLAG_8(res);
 783         FLAG_V = src & res;
 784
 785         res = MASK_OUT_ABOVE_8(res);
 786         FLAG_Z |= res;
 787
 788         m68ki_write_8(ea, res);
 789 }
 790
 791
 792 void m68k_op_negx_8_pd(void)
 793 {
 794         uint ea = EA_AY_PD_8();
 795         uint src = m68ki_read_8(ea);
 796         uint res = 0 - src - XFLAG_AS_1();
 797
 798         FLAG_N = NFLAG_8(res);
 799         FLAG_X = FLAG_C = CFLAG_8(res);
 800         FLAG_V = src & res;
 801
 802         res = MASK_OUT_ABOVE_8(res);
 803         FLAG_Z |= res;
 804
 805         m68ki_write_8(ea, res);
 806 }
 807
 808
 809 void m68k_op_negx_8_pd7(void)
 810 {
 811         uint ea = EA_A7_PD_8();
 812         uint src = m68ki_read_8(ea);
 813         uint res = 0 - src - XFLAG_AS_1();
 814
 815         FLAG_N = NFLAG_8(res);
 816         FLAG_X = FLAG_C = CFLAG_8(res);
 817         FLAG_V = src & res;
 818
 819         res = MASK_OUT_ABOVE_8(res);
 820         FLAG_Z |= res;
 821
 822         m68ki_write_8(ea, res);
 823 }
 824
 825
 826 void m68k_op_negx_8_di(void)
 827 {
 828         uint ea = EA_AY_DI_8();
 829         uint src = m68ki_read_8(ea);
 830         uint res = 0 - src - XFLAG_AS_1();
 831
 832         FLAG_N = NFLAG_8(res);
 833         FLAG_X = FLAG_C = CFLAG_8(res);
 834         FLAG_V = src & res;
 835
 836         res = MASK_OUT_ABOVE_8(res);
 837         FLAG_Z |= res;
 838
 839         m68ki_write_8(ea, res);
 840 }
 841
 842
 843 void m68k_op_negx_8_ix(void)
 844 {
 845         uint ea = EA_AY_IX_8();
 846         uint src = m68ki_read_8(ea);
 847         uint res = 0 - src - XFLAG_AS_1();
 848
 849         FLAG_N = NFLAG_8(res);
 850         FLAG_X = FLAG_C = CFLAG_8(res);
 851         FLAG_V = src & res;
 852
 853         res = MASK_OUT_ABOVE_8(res);
 854         FLAG_Z |= res;
 855
 856         m68ki_write_8(ea, res);
 857 }
 858
 859
 860 void m68k_op_negx_8_aw(void)
 861 {
 862         uint ea = EA_AW_8();
 863         uint src = m68ki_read_8(ea);
 864         uint res = 0 - src - XFLAG_AS_1();
 865
 866         FLAG_N = NFLAG_8(res);
 867         FLAG_X = FLAG_C = CFLAG_8(res);
 868         FLAG_V = src & res;
 869
 870         res = MASK_OUT_ABOVE_8(res);
 871         FLAG_Z |= res;
 872
 873         m68ki_write_8(ea, res);
 874 }
 875
 876
 877 void m68k_op_negx_8_al(void)
 878 {
 879         uint ea = EA_AL_8();
 880         uint src = m68ki_read_8(ea);
 881         uint res = 0 - src - XFLAG_AS_1();
 882
 883         FLAG_N = NFLAG_8(res);
 884         FLAG_X = FLAG_C = CFLAG_8(res);
 885         FLAG_V = src & res;
 886
 887         res = MASK_OUT_ABOVE_8(res);
 888         FLAG_Z |= res;
 889
 890         m68ki_write_8(ea, res);
 891 }
 892
 893
 894 void m68k_op_negx_16_d(void)
 895 {
 896         uint* r_dst = &DY;
 897         uint res = 0 - MASK_OUT_ABOVE_16(*r_dst) - XFLAG_AS_1();
 898
 899         FLAG_N = NFLAG_16(res);
 900         FLAG_X = FLAG_C = CFLAG_16(res);
 901         FLAG_V = (*r_dst & res)>>8;
 902
 903         res = MASK_OUT_ABOVE_16(res);
 904         FLAG_Z |= res;
 905
 906         *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
 907 }
 908
 909
 910 void m68k_op_negx_16_ai(void)
 911 {
 912         uint ea  = EA_AY_AI_16();
 913         uint src = m68ki_read_16(ea);
 914         uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();
 915
 916         FLAG_N = NFLAG_16(res);
 917         FLAG_X = FLAG_C = CFLAG_16(res);
 918         FLAG_V = (src & res)>>8;
 919
 920         res = MASK_OUT_ABOVE_16(res);
 921         FLAG_Z |= res;
 922
 923         m68ki_write_16(ea, res);
 924 }
 925
 926
 927 void m68k_op_negx_16_pi(void)
 928 {
 929         uint ea  = EA_AY_PI_16();
 930         uint src = m68ki_read_16(ea);
 931         uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();
 932
 933         FLAG_N = NFLAG_16(res);
 934         FLAG_X = FLAG_C = CFLAG_16(res);
 935         FLAG_V = (src & res)>>8;
 936
 937         res = MASK_OUT_ABOVE_16(res);
 938         FLAG_Z |= res;
 939
 940         m68ki_write_16(ea, res);
 941 }
 942
 943
 944 void m68k_op_negx_16_pd(void)
 945 {
 946         uint ea  = EA_AY_PD_16();
 947         uint src = m68ki_read_16(ea);
 948         uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();
 949
 950         FLAG_N = NFLAG_16(res);
 951         FLAG_X = FLAG_C = CFLAG_16(res);
 952         FLAG_V = (src & res)>>8;
 953
 954         res = MASK_OUT_ABOVE_16(res);
 955         FLAG_Z |= res;
 956
 957         m68ki_write_16(ea, res);
 958 }
 959
 960
 961 void m68k_op_negx_16_di(void)
 962 {
 963         uint ea  = EA_AY_DI_16();
 964         uint src = m68ki_read_16(ea);
 965         uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();
 966
 967         FLAG_N = NFLAG_16(res);
 968         FLAG_X = FLAG_C = CFLAG_16(res);
 969         FLAG_V = (src & res)>>8;
 970
 971         res = MASK_OUT_ABOVE_16(res);
 972         FLAG_Z |= res;
 973
 974         m68ki_write_16(ea, res);
 975 }
 976
 977
 978 void m68k_op_negx_16_ix(void)
 979 {
 980         uint ea  = EA_AY_IX_16();
 981         uint src = m68ki_read_16(ea);
 982         uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();
 983
 984         FLAG_N = NFLAG_16(res);
 985         FLAG_X = FLAG_C = CFLAG_16(res);
 986         FLAG_V = (src & res)>>8;
 987
 988         res = MASK_OUT_ABOVE_16(res);
 989         FLAG_Z |= res;
 990
 991         m68ki_write_16(ea, res);
 992 }
 993
 994
 995 void m68k_op_negx_16_aw(void)
 996 {
 997         uint ea  = EA_AW_16();
 998         uint src = m68ki_read_16(ea);
 999         uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();
1000
1001         FLAG_N = NFLAG_16(res);
1002         FLAG_X = FLAG_C = CFLAG_16(res);
1003         FLAG_V = (src & res)>>8;
1004
1005         res = MASK_OUT_ABOVE_16(res);
1006         FLAG_Z |= res;
1007
1008         m68ki_write_16(ea, res);
1009 }
1010
1011
1012 void m68k_op_negx_16_al(void)
1013 {
1014         uint ea  = EA_AL_16();
1015         uint src = m68ki_read_16(ea);
1016         uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();
1017
1018         FLAG_N = NFLAG_16(res);
1019         FLAG_X = FLAG_C = CFLAG_16(res);
1020         FLAG_V = (src & res)>>8;
1021
1022         res = MASK_OUT_ABOVE_16(res);
1023         FLAG_Z |= res;
1024
1025         m68ki_write_16(ea, res);
1026 }
1027
1028
1029 void m68k_op_negx_32_d(void)
1030 {
1031         uint* r_dst = &DY;
1032         uint res = 0 - MASK_OUT_ABOVE_32(*r_dst) - XFLAG_AS_1();
1033
1034         FLAG_N = NFLAG_32(res);
1035         FLAG_X = FLAG_C = CFLAG_SUB_32(*r_dst, 0, res);
1036         FLAG_V = (*r_dst & res)>>24;
1037
1038         res = MASK_OUT_ABOVE_32(res);
1039         FLAG_Z |= res;
1040
1041         *r_dst = res;
1042 }
1043
1044
1045 void m68k_op_negx_32_ai(void)
1046 {
1047         uint ea  = EA_AY_AI_32();
1048         uint src = m68ki_read_32(ea);
1049         uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();
1050
1051         FLAG_N = NFLAG_32(res);
1052         FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);
1053         FLAG_V = (src & res)>>24;
1054
1055         res = MASK_OUT_ABOVE_32(res);
1056         FLAG_Z |= res;
1057
1058         m68ki_write_32(ea, res);
1059 }
1060
1061
1062 void m68k_op_negx_32_pi(void)
1063 {
1064         uint ea  = EA_AY_PI_32();
1065         uint src = m68ki_read_32(ea);
1066         uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();
1067
1068         FLAG_N = NFLAG_32(res);
1069         FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);
1070         FLAG_V = (src & res)>>24;
1071
1072         res = MASK_OUT_ABOVE_32(res);
1073         FLAG_Z |= res;
1074
1075         m68ki_write_32(ea, res);
1076 }
1077
1078
1079 void m68k_op_negx_32_pd(void)
1080 {
1081         uint ea  = EA_AY_PD_32();
1082         uint src = m68ki_read_32(ea);
1083         uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();
1084
1085         FLAG_N = NFLAG_32(res);
1086         FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);
1087         FLAG_V = (src & res)>>24;
1088
1089         res = MASK_OUT_ABOVE_32(res);
1090         FLAG_Z |= res;
1091
1092         m68ki_write_32(ea, res);
1093 }
1094
1095
1096 void m68k_op_negx_32_di(void)
1097 {
1098         uint ea  = EA_AY_DI_32();
1099         uint src = m68ki_read_32(ea);
1100         uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();
1101
1102         FLAG_N = NFLAG_32(res);
1103         FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);
1104         FLAG_V = (src & res)>>24;
1105
1106         res = MASK_OUT_ABOVE_32(res);
1107         FLAG_Z |= res;
1108
1109         m68ki_write_32(ea, res);
1110 }
1111
1112
1113 void m68k_op_negx_32_ix(void)
1114 {
1115         uint ea  = EA_AY_IX_32();
1116         uint src = m68ki_read_32(ea);
1117         uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();
1118
1119         FLAG_N = NFLAG_32(res);
1120         FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);
1121         FLAG_V = (src & res)>>24;
1122
1123         res = MASK_OUT_ABOVE_32(res);
1124         FLAG_Z |= res;
1125
1126         m68ki_write_32(ea, res);
1127 }
1128
1129
1130 void m68k_op_negx_32_aw(void)
1131 {
1132         uint ea  = EA_AW_32();
1133         uint src = m68ki_read_32(ea);
1134         uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();
1135
1136         FLAG_N = NFLAG_32(res);
1137         FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);
1138         FLAG_V = (src & res)>>24;
1139
1140         res = MASK_OUT_ABOVE_32(res);
1141         FLAG_Z |= res;
1142
1143         m68ki_write_32(ea, res);
1144 }
1145
1146
1147 void m68k_op_negx_32_al(void)
1148 {
1149         uint ea  = EA_AL_32();
1150         uint src = m68ki_read_32(ea);
1151         uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();
1152
1153         FLAG_N = NFLAG_32(res);
1154         FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);
1155         FLAG_V = (src & res)>>24;
1156
1157         res = MASK_OUT_ABOVE_32(res);
1158         FLAG_Z |= res;
1159
1160         m68ki_write_32(ea, res);
1161 }
1162
1163
1164 void m68k_op_nop(void)
1165 {
1166         m68ki_trace_t0();                                  /* auto-disable (see m68kcpu.h) */
1167 }
1168
1169
1170 void m68k_op_not_8_d(void)
1171 {
1172         uint* r_dst = &DY;
1173         uint res = MASK_OUT_ABOVE_8(~*r_dst);
1174
1175         *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
1176
1177         FLAG_N = NFLAG_8(res);
1178         FLAG_Z = res;
1179         FLAG_C = CFLAG_CLEAR;
1180         FLAG_V = VFLAG_CLEAR;
1181 }
1182
1183
1184 void m68k_op_not_8_ai(void)
1185 {
1186         uint ea = EA_AY_AI_8();
1187         uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
1188
1189         m68ki_write_8(ea, res);
1190
1191         FLAG_N = NFLAG_8(res);
1192         FLAG_Z = res;
1193         FLAG_C = CFLAG_CLEAR;
1194         FLAG_V = VFLAG_CLEAR;
1195 }
1196
1197
1198 void m68k_op_not_8_pi(void)
1199 {
1200         uint ea = EA_AY_PI_8();
1201         uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
1202
1203         m68ki_write_8(ea, res);
1204
1205         FLAG_N = NFLAG_8(res);
1206         FLAG_Z = res;
1207         FLAG_C = CFLAG_CLEAR;
1208         FLAG_V = VFLAG_CLEAR;
1209 }
1210
1211
1212 void m68k_op_not_8_pi7(void)
1213 {
1214         uint ea = EA_A7_PI_8();
1215         uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
1216
1217         m68ki_write_8(ea, res);
1218
1219         FLAG_N = NFLAG_8(res);
1220         FLAG_Z = res;
1221         FLAG_C = CFLAG_CLEAR;
1222         FLAG_V = VFLAG_CLEAR;
1223 }
1224
1225
1226 void m68k_op_not_8_pd(void)
1227 {
1228         uint ea = EA_AY_PD_8();
1229         uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
1230
1231         m68ki_write_8(ea, res);
1232
1233         FLAG_N = NFLAG_8(res);
1234         FLAG_Z = res;
1235         FLAG_C = CFLAG_CLEAR;
1236         FLAG_V = VFLAG_CLEAR;
1237 }
1238
1239
1240 void m68k_op_not_8_pd7(void)
1241 {
1242         uint ea = EA_A7_PD_8();
1243         uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
1244
1245         m68ki_write_8(ea, res);
1246
1247         FLAG_N = NFLAG_8(res);
1248         FLAG_Z = res;
1249         FLAG_C = CFLAG_CLEAR;
1250         FLAG_V = VFLAG_CLEAR;
1251 }
1252
1253
1254 void m68k_op_not_8_di(void)
1255 {
1256         uint ea = EA_AY_DI_8();
1257         uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
1258
1259         m68ki_write_8(ea, res);
1260
1261         FLAG_N = NFLAG_8(res);
1262         FLAG_Z = res;
1263         FLAG_C = CFLAG_CLEAR;
1264         FLAG_V = VFLAG_CLEAR;
1265 }
1266
1267
1268 void m68k_op_not_8_ix(void)
1269 {
1270         uint ea = EA_AY_IX_8();
1271         uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
1272
1273         m68ki_write_8(ea, res);
1274
1275         FLAG_N = NFLAG_8(res);
1276         FLAG_Z = res;
1277         FLAG_C = CFLAG_CLEAR;
1278         FLAG_V = VFLAG_CLEAR;
1279 }
1280
1281
1282 void m68k_op_not_8_aw(void)
1283 {
1284         uint ea = EA_AW_8();
1285         uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
1286
1287         m68ki_write_8(ea, res);
1288
1289         FLAG_N = NFLAG_8(res);
1290         FLAG_Z = res;
1291         FLAG_C = CFLAG_CLEAR;
1292         FLAG_V = VFLAG_CLEAR;
1293 }
1294
1295
1296 void m68k_op_not_8_al(void)
1297 {
1298         uint ea = EA_AL_8();
1299         uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
1300
1301         m68ki_write_8(ea, res);
1302
1303         FLAG_N = NFLAG_8(res);
1304         FLAG_Z = res;
1305         FLAG_C = CFLAG_CLEAR;
1306         FLAG_V = VFLAG_CLEAR;
1307 }
1308
1309
1310 void m68k_op_not_16_d(void)
1311 {
1312         uint* r_dst = &DY;
1313         uint res = MASK_OUT_ABOVE_16(~*r_dst);
1314
1315         *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
1316
1317         FLAG_N = NFLAG_16(res);
1318         FLAG_Z = res;
1319         FLAG_C = CFLAG_CLEAR;
1320         FLAG_V = VFLAG_CLEAR;
1321 }
1322
1323
1324 void m68k_op_not_16_ai(void)
1325 {
1326         uint ea = EA_AY_AI_16();
1327         uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));
1328
1329         m68ki_write_16(ea, res);
1330
1331         FLAG_N = NFLAG_16(res);
1332         FLAG_Z = res;
1333         FLAG_C = CFLAG_CLEAR;
1334         FLAG_V = VFLAG_CLEAR;
1335 }
1336
1337
1338 void m68k_op_not_16_pi(void)
1339 {
1340         uint ea = EA_AY_PI_16();
1341         uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));
1342
1343         m68ki_write_16(ea, res);
1344
1345         FLAG_N = NFLAG_16(res);
1346         FLAG_Z = res;
1347         FLAG_C = CFLAG_CLEAR;
1348         FLAG_V = VFLAG_CLEAR;
1349 }
1350
1351
1352 void m68k_op_not_16_pd(void)
1353 {
1354         uint ea = EA_AY_PD_16();
1355         uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));
1356
1357         m68ki_write_16(ea, res);
1358
1359         FLAG_N = NFLAG_16(res);
1360         FLAG_Z = res;
1361         FLAG_C = CFLAG_CLEAR;
1362         FLAG_V = VFLAG_CLEAR;
1363 }
1364
1365
1366 void m68k_op_not_16_di(void)
1367 {
1368         uint ea = EA_AY_DI_16();
1369         uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));
1370
1371         m68ki_write_16(ea, res);
1372
1373         FLAG_N = NFLAG_16(res);
1374         FLAG_Z = res;
1375         FLAG_C = CFLAG_CLEAR;
1376         FLAG_V = VFLAG_CLEAR;
1377 }
1378
1379
1380 void m68k_op_not_16_ix(void)
1381 {
1382         uint ea = EA_AY_IX_16();
1383         uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));
1384
1385         m68ki_write_16(ea, res);
1386
1387         FLAG_N = NFLAG_16(res);
1388         FLAG_Z = res;
1389         FLAG_C = CFLAG_CLEAR;
1390         FLAG_V = VFLAG_CLEAR;
1391 }
1392
1393
1394 void m68k_op_not_16_aw(void)
1395 {
1396         uint ea = EA_AW_16();
1397         uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));
1398
1399         m68ki_write_16(ea, res);
1400
1401         FLAG_N = NFLAG_16(res);
1402         FLAG_Z = res;
1403         FLAG_C = CFLAG_CLEAR;
1404         FLAG_V = VFLAG_CLEAR;
1405 }
1406
1407
1408 void m68k_op_not_16_al(void)
1409 {
1410         uint ea = EA_AL_16();
1411         uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));
1412
1413         m68ki_write_16(ea, res);
1414
1415         FLAG_N = NFLAG_16(res);
1416         FLAG_Z = res;
1417         FLAG_C = CFLAG_CLEAR;
1418         FLAG_V = VFLAG_CLEAR;
1419 }
1420
1421
1422 void m68k_op_not_32_d(void)
1423 {
1424         uint* r_dst = &DY;
1425         uint res = *r_dst = MASK_OUT_ABOVE_32(~*r_dst);
1426
1427         FLAG_N = NFLAG_32(res);
1428         FLAG_Z = res;
1429         FLAG_C = CFLAG_CLEAR;
1430         FLAG_V = VFLAG_CLEAR;
1431 }
1432
1433
1434 void m68k_op_not_32_ai(void)
1435 {
1436         uint ea = EA_AY_AI_32();
1437         uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));
1438
1439         m68ki_write_32(ea, res);
1440
1441         FLAG_N = NFLAG_32(res);
1442         FLAG_Z = res;
1443         FLAG_C = CFLAG_CLEAR;
1444         FLAG_V = VFLAG_CLEAR;
1445 }
1446
1447
1448 void m68k_op_not_32_pi(void)
1449 {
1450         uint ea = EA_AY_PI_32();
1451         uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));
1452
1453         m68ki_write_32(ea, res);
1454
1455         FLAG_N = NFLAG_32(res);
1456         FLAG_Z = res;
1457         FLAG_C = CFLAG_CLEAR;
1458         FLAG_V = VFLAG_CLEAR;
1459 }
1460
1461
1462 void m68k_op_not_32_pd(void)
1463 {
1464         uint ea = EA_AY_PD_32();
1465         uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));
1466
1467         m68ki_write_32(ea, res);
1468
1469         FLAG_N = NFLAG_32(res);
1470         FLAG_Z = res;
1471         FLAG_C = CFLAG_CLEAR;
1472         FLAG_V = VFLAG_CLEAR;
1473 }
1474
1475
1476 void m68k_op_not_32_di(void)
1477 {
1478         uint ea = EA_AY_DI_32();
1479         uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));
1480
1481         m68ki_write_32(ea, res);
1482
1483         FLAG_N = NFLAG_32(res);
1484         FLAG_Z = res;
1485         FLAG_C = CFLAG_CLEAR;
1486         FLAG_V = VFLAG_CLEAR;
1487 }
1488
1489
1490 void m68k_op_not_32_ix(void)
1491 {
1492         uint ea = EA_AY_IX_32();
1493         uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));
1494
1495         m68ki_write_32(ea, res);
1496
1497         FLAG_N = NFLAG_32(res);
1498         FLAG_Z = res;
1499         FLAG_C = CFLAG_CLEAR;
1500         FLAG_V = VFLAG_CLEAR;
1501 }
1502
1503
1504 void m68k_op_not_32_aw(void)
1505 {
1506         uint ea = EA_AW_32();
1507         uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));
1508
1509         m68ki_write_32(ea, res);
1510
1511         FLAG_N = NFLAG_32(res);
1512         FLAG_Z = res;
1513         FLAG_C = CFLAG_CLEAR;
1514         FLAG_V = VFLAG_CLEAR;
1515 }
1516
1517
1518 void m68k_op_not_32_al(void)
1519 {
1520         uint ea = EA_AL_32();
1521         uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));
1522
1523         m68ki_write_32(ea, res);
1524
1525         FLAG_N = NFLAG_32(res);
1526         FLAG_Z = res;
1527         FLAG_C = CFLAG_CLEAR;
1528         FLAG_V = VFLAG_CLEAR;
1529 }
1530
1531
1532 void m68k_op_or_8_er_d(void)
1533 {
1534         uint res = MASK_OUT_ABOVE_8((DX |= MASK_OUT_ABOVE_8(DY)));
1535
1536         FLAG_N = NFLAG_8(res);
1537         FLAG_Z = res;
1538         FLAG_C = CFLAG_CLEAR;
1539         FLAG_V = VFLAG_CLEAR;
1540 }
1541
1542
1543 void m68k_op_or_8_er_ai(void)
1544 {
1545         uint res = MASK_OUT_ABOVE_8((DX |= OPER_AY_AI_8()));
1546
1547         FLAG_N = NFLAG_8(res);
1548         FLAG_Z = res;
1549         FLAG_C = CFLAG_CLEAR;
1550         FLAG_V = VFLAG_CLEAR;
1551 }
1552
1553
1554 void m68k_op_or_8_er_pi(void)
1555 {
1556         uint res = MASK_OUT_ABOVE_8((DX |= OPER_AY_PI_8()));
1557
1558         FLAG_N = NFLAG_8(res);
1559         FLAG_Z = res;
1560         FLAG_C = CFLAG_CLEAR;
1561         FLAG_V = VFLAG_CLEAR;
1562 }
1563
1564
1565 void m68k_op_or_8_er_pi7(void)
1566 {
1567         uint res = MASK_OUT_ABOVE_8((DX |= OPER_A7_PI_8()));
1568
1569         FLAG_N = NFLAG_8(res);
1570         FLAG_Z = res;
1571         FLAG_C = CFLAG_CLEAR;
1572         FLAG_V = VFLAG_CLEAR;
1573 }
1574
1575
1576 void m68k_op_or_8_er_pd(void)
1577 {
1578         uint res = MASK_OUT_ABOVE_8((DX |= OPER_AY_PD_8()));
1579
1580         FLAG_N = NFLAG_8(res);
1581         FLAG_Z = res;
1582         FLAG_C = CFLAG_CLEAR;
1583         FLAG_V = VFLAG_CLEAR;
1584 }
1585
1586
1587 void m68k_op_or_8_er_pd7(void)
1588 {
1589         uint res = MASK_OUT_ABOVE_8((DX |= OPER_A7_PD_8()));
1590
1591         FLAG_N = NFLAG_8(res);
1592         FLAG_Z = res;
1593         FLAG_C = CFLAG_CLEAR;
1594         FLAG_V = VFLAG_CLEAR;
1595 }
1596
1597
1598 void m68k_op_or_8_er_di(void)
1599 {
1600         uint res = MASK_OUT_ABOVE_8((DX |= OPER_AY_DI_8()));
1601
1602         FLAG_N = NFLAG_8(res);
1603         FLAG_Z = res;
1604         FLAG_C = CFLAG_CLEAR;
1605         FLAG_V = VFLAG_CLEAR;
1606 }
1607
1608
1609 void m68k_op_or_8_er_ix(void)
1610 {
1611         uint res = MASK_OUT_ABOVE_8((DX |= OPER_AY_IX_8()));
1612
1613         FLAG_N = NFLAG_8(res);
1614         FLAG_Z = res;
1615         FLAG_C = CFLAG_CLEAR;
1616         FLAG_V = VFLAG_CLEAR;
1617 }
1618
1619
1620 void m68k_op_or_8_er_aw(void)
1621 {
1622         uint res = MASK_OUT_ABOVE_8((DX |= OPER_AW_8()));
1623
1624         FLAG_N = NFLAG_8(res);
1625         FLAG_Z = res;
1626         FLAG_C = CFLAG_CLEAR;
1627         FLAG_V = VFLAG_CLEAR;
1628 }
1629
1630
1631 void m68k_op_or_8_er_al(void)
1632 {
1633         uint res = MASK_OUT_ABOVE_8((DX |= OPER_AL_8()));
1634
1635         FLAG_N = NFLAG_8(res);
1636         FLAG_Z = res;
1637         FLAG_C = CFLAG_CLEAR;
1638         FLAG_V = VFLAG_CLEAR;
1639 }
1640
1641
1642 void m68k_op_or_8_er_pcdi(void)
1643 {
1644         uint res = MASK_OUT_ABOVE_8((DX |= OPER_PCDI_8()));
1645
1646         FLAG_N = NFLAG_8(res);
1647         FLAG_Z = res;
1648         FLAG_C = CFLAG_CLEAR;
1649         FLAG_V = VFLAG_CLEAR;
1650 }
1651
1652
1653 void m68k_op_or_8_er_pcix(void)
1654 {
1655         uint res = MASK_OUT_ABOVE_8((DX |= OPER_PCIX_8()));
1656
1657         FLAG_N = NFLAG_8(res);
1658         FLAG_Z = res;
1659         FLAG_C = CFLAG_CLEAR;
1660         FLAG_V = VFLAG_CLEAR;
1661 }
1662
1663
1664 void m68k_op_or_8_er_i(void)
1665 {
1666         uint res = MASK_OUT_ABOVE_8((DX |= OPER_I_8()));
1667
1668         FLAG_N = NFLAG_8(res);
1669         FLAG_Z = res;
1670         FLAG_C = CFLAG_CLEAR;
1671         FLAG_V = VFLAG_CLEAR;
1672 }
1673
1674
1675 void m68k_op_or_16_er_d(void)
1676 {
1677         uint res = MASK_OUT_ABOVE_16((DX |= MASK_OUT_ABOVE_16(DY)));
1678
1679         FLAG_N = NFLAG_16(res);
1680         FLAG_Z = res;
1681         FLAG_C = CFLAG_CLEAR;
1682         FLAG_V = VFLAG_CLEAR;
1683 }
1684
1685
1686 void m68k_op_or_16_er_ai(void)
1687 {
1688         uint res = MASK_OUT_ABOVE_16((DX |= OPER_AY_AI_16()));
1689
1690         FLAG_N = NFLAG_16(res);
1691         FLAG_Z = res;
1692         FLAG_C = CFLAG_CLEAR;
1693         FLAG_V = VFLAG_CLEAR;
1694 }
1695
1696
1697 void m68k_op_or_16_er_pi(void)
1698 {
1699         uint res = MASK_OUT_ABOVE_16((DX |= OPER_AY_PI_16()));
1700
1701         FLAG_N = NFLAG_16(res);
1702         FLAG_Z = res;
1703         FLAG_C = CFLAG_CLEAR;
1704         FLAG_V = VFLAG_CLEAR;
1705 }
1706
1707
1708 void m68k_op_or_16_er_pd(void)
1709 {
1710         uint res = MASK_OUT_ABOVE_16((DX |= OPER_AY_PD_16()));
1711
1712         FLAG_N = NFLAG_16(res);
1713         FLAG_Z = res;
1714         FLAG_C = CFLAG_CLEAR;
1715         FLAG_V = VFLAG_CLEAR;
1716 }
1717
1718
1719 void m68k_op_or_16_er_di(void)
1720 {
1721         uint res = MASK_OUT_ABOVE_16((DX |= OPER_AY_DI_16()));
1722
1723         FLAG_N = NFLAG_16(res);
1724         FLAG_Z = res;
1725         FLAG_C = CFLAG_CLEAR;
1726         FLAG_V = VFLAG_CLEAR;
1727 }
1728
1729
1730 void m68k_op_or_16_er_ix(void)
1731 {
1732         uint res = MASK_OUT_ABOVE_16((DX |= OPER_AY_IX_16()));
1733
1734         FLAG_N = NFLAG_16(res);
1735         FLAG_Z = res;
1736         FLAG_C = CFLAG_CLEAR;
1737         FLAG_V = VFLAG_CLEAR;
1738 }
1739
1740
1741 void m68k_op_or_16_er_aw(void)
1742 {
1743         uint res = MASK_OUT_ABOVE_16((DX |= OPER_AW_16()));
1744
1745         FLAG_N = NFLAG_16(res);
1746         FLAG_Z = res;
1747         FLAG_C = CFLAG_CLEAR;
1748         FLAG_V = VFLAG_CLEAR;
1749 }
1750
1751
1752 void m68k_op_or_16_er_al(void)
1753 {
1754         uint res = MASK_OUT_ABOVE_16((DX |= OPER_AL_16()));
1755
1756         FLAG_N = NFLAG_16(res);
1757         FLAG_Z = res;
1758         FLAG_C = CFLAG_CLEAR;
1759         FLAG_V = VFLAG_CLEAR;
1760 }
1761
1762
1763 void m68k_op_or_16_er_pcdi(void)
1764 {
1765         uint res = MASK_OUT_ABOVE_16((DX |= OPER_PCDI_16()));
1766
1767         FLAG_N = NFLAG_16(res);
1768         FLAG_Z = res;
1769         FLAG_C = CFLAG_CLEAR;
1770         FLAG_V = VFLAG_CLEAR;
1771 }
1772
1773
1774 void m68k_op_or_16_er_pcix(void)
1775 {
1776         uint res = MASK_OUT_ABOVE_16((DX |= OPER_PCIX_16()));
1777
1778         FLAG_N = NFLAG_16(res);
1779         FLAG_Z = res;
1780         FLAG_C = CFLAG_CLEAR;
1781         FLAG_V = VFLAG_CLEAR;
1782 }
1783
1784
1785 void m68k_op_or_16_er_i(void)
1786 {
1787         uint res = MASK_OUT_ABOVE_16((DX |= OPER_I_16()));
1788
1789         FLAG_N = NFLAG_16(res);
1790         FLAG_Z = res;
1791         FLAG_C = CFLAG_CLEAR;
1792         FLAG_V = VFLAG_CLEAR;
1793 }
1794
1795
1796 void m68k_op_or_32_er_d(void)
1797 {
1798         uint res = DX |= DY;
1799
1800         FLAG_N = NFLAG_32(res);
1801         FLAG_Z = res;
1802         FLAG_C = CFLAG_CLEAR;
1803         FLAG_V = VFLAG_CLEAR;
1804 }
1805
1806
1807 void m68k_op_or_32_er_ai(void)
1808 {
1809         uint res = DX |= OPER_AY_AI_32();
1810
1811         FLAG_N = NFLAG_32(res);
1812         FLAG_Z = res;
1813         FLAG_C = CFLAG_CLEAR;
1814         FLAG_V = VFLAG_CLEAR;
1815 }
1816
1817
1818 void m68k_op_or_32_er_pi(void)
1819 {
1820         uint res = DX |= OPER_AY_PI_32();
1821
1822         FLAG_N = NFLAG_32(res);
1823         FLAG_Z = res;
1824         FLAG_C = CFLAG_CLEAR;
1825         FLAG_V = VFLAG_CLEAR;
1826 }
1827
1828
1829 void m68k_op_or_32_er_pd(void)
1830 {
1831         uint res = DX |= OPER_AY_PD_32();
1832
1833         FLAG_N = NFLAG_32(res);
1834         FLAG_Z = res;
1835         FLAG_C = CFLAG_CLEAR;
1836         FLAG_V = VFLAG_CLEAR;
1837 }
1838
1839
1840 void m68k_op_or_32_er_di(void)
1841 {
1842         uint res = DX |= OPER_AY_DI_32();
1843
1844         FLAG_N = NFLAG_32(res);
1845         FLAG_Z = res;
1846         FLAG_C = CFLAG_CLEAR;
1847         FLAG_V = VFLAG_CLEAR;
1848 }
1849
1850
1851 void m68k_op_or_32_er_ix(void)
1852 {
1853         uint res = DX |= OPER_AY_IX_32();
1854
1855         FLAG_N = NFLAG_32(res);
1856         FLAG_Z = res;
1857         FLAG_C = CFLAG_CLEAR;
1858         FLAG_V = VFLAG_CLEAR;
1859 }
1860
1861
1862 void m68k_op_or_32_er_aw(void)
1863 {
1864         uint res = DX |= OPER_AW_32();
1865
1866         FLAG_N = NFLAG_32(res);
1867         FLAG_Z = res;
1868         FLAG_C = CFLAG_CLEAR;
1869         FLAG_V = VFLAG_CLEAR;
1870 }
1871
1872
1873 void m68k_op_or_32_er_al(void)
1874 {
1875         uint res = DX |= OPER_AL_32();
1876
1877         FLAG_N = NFLAG_32(res);
1878         FLAG_Z = res;
1879         FLAG_C = CFLAG_CLEAR;
1880         FLAG_V = VFLAG_CLEAR;
1881 }
1882
1883
1884 void m68k_op_or_32_er_pcdi(void)
1885 {
1886         uint res = DX |= OPER_PCDI_32();
1887
1888         FLAG_N = NFLAG_32(res);
1889         FLAG_Z = res;
1890         FLAG_C = CFLAG_CLEAR;
1891         FLAG_V = VFLAG_CLEAR;
1892 }
1893
1894
1895 void m68k_op_or_32_er_pcix(void)
1896 {
1897         uint res = DX |= OPER_PCIX_32();
1898
1899         FLAG_N = NFLAG_32(res);
1900         FLAG_Z = res;
1901         FLAG_C = CFLAG_CLEAR;
1902         FLAG_V = VFLAG_CLEAR;
1903 }
1904
1905
1906 void m68k_op_or_32_er_i(void)
1907 {
1908         uint res = DX |= OPER_I_32();
1909
1910         FLAG_N = NFLAG_32(res);
1911         FLAG_Z = res;
1912         FLAG_C = CFLAG_CLEAR;
1913         FLAG_V = VFLAG_CLEAR;
1914 }
1915
1916
1917 void m68k_op_or_8_re_ai(void)
1918 {
1919         uint ea = EA_AY_AI_8();
1920         uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
1921
1922         m68ki_write_8(ea, res);
1923
1924         FLAG_N = NFLAG_8(res);
1925         FLAG_Z = res;
1926         FLAG_C = CFLAG_CLEAR;
1927         FLAG_V = VFLAG_CLEAR;
1928 }
1929
1930
1931 void m68k_op_or_8_re_pi(void)
1932 {
1933         uint ea = EA_AY_PI_8();
1934         uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
1935
1936         m68ki_write_8(ea, res);
1937
1938         FLAG_N = NFLAG_8(res);
1939         FLAG_Z = res;
1940         FLAG_C = CFLAG_CLEAR;
1941         FLAG_V = VFLAG_CLEAR;
1942 }
1943
1944
1945 void m68k_op_or_8_re_pi7(void)
1946 {
1947         uint ea = EA_A7_PI_8();
1948         uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
1949
1950         m68ki_write_8(ea, res);
1951
1952         FLAG_N = NFLAG_8(res);
1953         FLAG_Z = res;
1954         FLAG_C = CFLAG_CLEAR;
1955         FLAG_V = VFLAG_CLEAR;
1956 }
1957
1958
1959 void m68k_op_or_8_re_pd(void)
1960 {
1961         uint ea = EA_AY_PD_8();
1962         uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
1963
1964         m68ki_write_8(ea, res);
1965
1966         FLAG_N = NFLAG_8(res);
1967         FLAG_Z = res;
1968         FLAG_C = CFLAG_CLEAR;
1969         FLAG_V = VFLAG_CLEAR;
1970 }
1971
1972
1973 void m68k_op_or_8_re_pd7(void)
1974 {
1975         uint ea = EA_A7_PD_8();
1976         uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
1977
1978         m68ki_write_8(ea, res);
1979
1980         FLAG_N = NFLAG_8(res);
1981         FLAG_Z = res;
1982         FLAG_C = CFLAG_CLEAR;
1983         FLAG_V = VFLAG_CLEAR;
1984 }
1985
1986
1987 void m68k_op_or_8_re_di(void)
1988 {
1989         uint ea = EA_AY_DI_8();
1990         uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
1991
1992         m68ki_write_8(ea, res);
1993
1994         FLAG_N = NFLAG_8(res);
1995         FLAG_Z = res;
1996         FLAG_C = CFLAG_CLEAR;
1997         FLAG_V = VFLAG_CLEAR;
1998 }
1999
2000
2001 void m68k_op_or_8_re_ix(void)
2002 {
2003         uint ea = EA_AY_IX_8();
2004         uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
2005
2006         m68ki_write_8(ea, res);
2007
2008         FLAG_N = NFLAG_8(res);
2009         FLAG_Z = res;
2010         FLAG_C = CFLAG_CLEAR;
2011         FLAG_V = VFLAG_CLEAR;
2012 }
2013
2014
2015 void m68k_op_or_8_re_aw(void)
2016 {
2017         uint ea = EA_AW_8();
2018         uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
2019
2020         m68ki_write_8(ea, res);
2021
2022         FLAG_N = NFLAG_8(res);
2023         FLAG_Z = res;
2024         FLAG_C = CFLAG_CLEAR;
2025         FLAG_V = VFLAG_CLEAR;
2026 }
2027
2028
2029 void m68k_op_or_8_re_al(void)
2030 {
2031         uint ea = EA_AL_8();
2032         uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
2033
2034         m68ki_write_8(ea, res);
2035
2036         FLAG_N = NFLAG_8(res);
2037         FLAG_Z = res;
2038         FLAG_C = CFLAG_CLEAR;
2039         FLAG_V = VFLAG_CLEAR;
2040 }
2041
2042
2043 void m68k_op_or_16_re_ai(void)
2044 {
2045         uint ea = EA_AY_AI_16();
2046         uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));
2047
2048         m68ki_write_16(ea, res);
2049
2050         FLAG_N = NFLAG_16(res);
2051         FLAG_Z = res;
2052         FLAG_C = CFLAG_CLEAR;
2053         FLAG_V = VFLAG_CLEAR;
2054 }
2055
2056
2057 void m68k_op_or_16_re_pi(void)
2058 {
2059         uint ea = EA_AY_PI_16();
2060         uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));
2061
2062         m68ki_write_16(ea, res);
2063
2064         FLAG_N = NFLAG_16(res);
2065         FLAG_Z = res;
2066         FLAG_C = CFLAG_CLEAR;
2067         FLAG_V = VFLAG_CLEAR;
2068 }
2069
2070
2071 void m68k_op_or_16_re_pd(void)
2072 {
2073         uint ea = EA_AY_PD_16();
2074         uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));
2075
2076         m68ki_write_16(ea, res);
2077
2078         FLAG_N = NFLAG_16(res);
2079         FLAG_Z = res;
2080         FLAG_C = CFLAG_CLEAR;
2081         FLAG_V = VFLAG_CLEAR;
2082 }
2083
2084
2085 void m68k_op_or_16_re_di(void)
2086 {
2087         uint ea = EA_AY_DI_16();
2088         uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));
2089
2090         m68ki_write_16(ea, res);
2091
2092         FLAG_N = NFLAG_16(res);
2093         FLAG_Z = res;
2094         FLAG_C = CFLAG_CLEAR;
2095         FLAG_V = VFLAG_CLEAR;
2096 }
2097
2098
2099 void m68k_op_or_16_re_ix(void)
2100 {
2101         uint ea = EA_AY_IX_16();
2102         uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));
2103
2104         m68ki_write_16(ea, res);
2105
2106         FLAG_N = NFLAG_16(res);
2107         FLAG_Z = res;
2108         FLAG_C = CFLAG_CLEAR;
2109         FLAG_V = VFLAG_CLEAR;
2110 }
2111
2112
2113 void m68k_op_or_16_re_aw(void)
2114 {
2115         uint ea = EA_AW_16();
2116         uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));
2117
2118         m68ki_write_16(ea, res);
2119
2120         FLAG_N = NFLAG_16(res);
2121         FLAG_Z = res;
2122         FLAG_C = CFLAG_CLEAR;
2123         FLAG_V = VFLAG_CLEAR;
2124 }
2125
2126
2127 void m68k_op_or_16_re_al(void)
2128 {
2129         uint ea = EA_AL_16();
2130         uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));
2131
2132         m68ki_write_16(ea, res);
2133
2134         FLAG_N = NFLAG_16(res);
2135         FLAG_Z = res;
2136         FLAG_C = CFLAG_CLEAR;
2137         FLAG_V = VFLAG_CLEAR;
2138 }
2139
2140
2141 void m68k_op_or_32_re_ai(void)
2142 {
2143         uint ea = EA_AY_AI_32();
2144         uint res = DX | m68ki_read_32(ea);
2145
2146         m68ki_write_32(ea, res);
2147
2148         FLAG_N = NFLAG_32(res);
2149         FLAG_Z = res;
2150         FLAG_C = CFLAG_CLEAR;
2151         FLAG_V = VFLAG_CLEAR;
2152 }
2153
2154
2155 void m68k_op_or_32_re_pi(void)
2156 {
2157         uint ea = EA_AY_PI_32();
2158         uint res = DX | m68ki_read_32(ea);
2159
2160         m68ki_write_32(ea, res);
2161
2162         FLAG_N = NFLAG_32(res);
2163         FLAG_Z = res;
2164         FLAG_C = CFLAG_CLEAR;
2165         FLAG_V = VFLAG_CLEAR;
2166 }
2167
2168
2169 void m68k_op_or_32_re_pd(void)
2170 {
2171         uint ea = EA_AY_PD_32();
2172         uint res = DX | m68ki_read_32(ea);
2173
2174         m68ki_write_32(ea, res);
2175
2176         FLAG_N = NFLAG_32(res);
2177         FLAG_Z = res;
2178         FLAG_C = CFLAG_CLEAR;
2179         FLAG_V = VFLAG_CLEAR;
2180 }
2181
2182
2183 void m68k_op_or_32_re_di(void)
2184 {
2185         uint ea = EA_AY_DI_32();
2186         uint res = DX | m68ki_read_32(ea);
2187
2188         m68ki_write_32(ea, res);
2189
2190         FLAG_N = NFLAG_32(res);
2191         FLAG_Z = res;
2192         FLAG_C = CFLAG_CLEAR;
2193         FLAG_V = VFLAG_CLEAR;
2194 }
2195
2196
2197 void m68k_op_or_32_re_ix(void)
2198 {
2199         uint ea = EA_AY_IX_32();
2200         uint res = DX | m68ki_read_32(ea);
2201
2202         m68ki_write_32(ea, res);
2203
2204         FLAG_N = NFLAG_32(res);
2205         FLAG_Z = res;
2206         FLAG_C = CFLAG_CLEAR;
2207         FLAG_V = VFLAG_CLEAR;
2208 }
2209
2210
2211 void m68k_op_or_32_re_aw(void)
2212 {
2213         uint ea = EA_AW_32();
2214         uint res = DX | m68ki_read_32(ea);
2215
2216         m68ki_write_32(ea, res);
2217
2218         FLAG_N = NFLAG_32(res);
2219         FLAG_Z = res;
2220         FLAG_C = CFLAG_CLEAR;
2221         FLAG_V = VFLAG_CLEAR;
2222 }
2223
2224
2225 void m68k_op_or_32_re_al(void)
2226 {
2227         uint ea = EA_AL_32();
2228         uint res = DX | m68ki_read_32(ea);
2229
2230         m68ki_write_32(ea, res);
2231
2232         FLAG_N = NFLAG_32(res);
2233         FLAG_Z = res;
2234         FLAG_C = CFLAG_CLEAR;
2235         FLAG_V = VFLAG_CLEAR;
2236 }
2237
2238
2239 void m68k_op_ori_8_d(void)
2240 {
2241         uint res = MASK_OUT_ABOVE_8((DY |= OPER_I_8()));
2242
2243         FLAG_N = NFLAG_8(res);
2244         FLAG_Z = res;
2245         FLAG_C = CFLAG_CLEAR;
2246         FLAG_V = VFLAG_CLEAR;
2247 }
2248
2249
2250 void m68k_op_ori_8_ai(void)
2251 {
2252         uint src = OPER_I_8();
2253         uint ea = EA_AY_AI_8();
2254         uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
2255
2256         m68ki_write_8(ea, res);
2257
2258         FLAG_N = NFLAG_8(res);
2259         FLAG_Z = res;
2260         FLAG_C = CFLAG_CLEAR;
2261         FLAG_V = VFLAG_CLEAR;
2262 }
2263
2264
2265 void m68k_op_ori_8_pi(void)
2266 {
2267         uint src = OPER_I_8();
2268         uint ea = EA_AY_PI_8();
2269         uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
2270
2271         m68ki_write_8(ea, res);
2272
2273         FLAG_N = NFLAG_8(res);
2274         FLAG_Z = res;
2275         FLAG_C = CFLAG_CLEAR;
2276         FLAG_V = VFLAG_CLEAR;
2277 }
2278
2279
2280 void m68k_op_ori_8_pi7(void)
2281 {
2282         uint src = OPER_I_8();
2283         uint ea = EA_A7_PI_8();
2284         uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
2285
2286         m68ki_write_8(ea, res);
2287
2288         FLAG_N = NFLAG_8(res);
2289         FLAG_Z = res;
2290         FLAG_C = CFLAG_CLEAR;
2291         FLAG_V = VFLAG_CLEAR;
2292 }
2293
2294
2295 void m68k_op_ori_8_pd(void)
2296 {
2297         uint src = OPER_I_8();
2298         uint ea = EA_AY_PD_8();
2299         uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
2300
2301         m68ki_write_8(ea, res);
2302
2303         FLAG_N = NFLAG_8(res);
2304         FLAG_Z = res;
2305         FLAG_C = CFLAG_CLEAR;
2306         FLAG_V = VFLAG_CLEAR;
2307 }
2308
2309
2310 void m68k_op_ori_8_pd7(void)
2311 {
2312         uint src = OPER_I_8();
2313         uint ea = EA_A7_PD_8();
2314         uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
2315
2316         m68ki_write_8(ea, res);
2317
2318         FLAG_N = NFLAG_8(res);
2319         FLAG_Z = res;
2320         FLAG_C = CFLAG_CLEAR;
2321         FLAG_V = VFLAG_CLEAR;
2322 }
2323
2324
2325 void m68k_op_ori_8_di(void)
2326 {
2327         uint src = OPER_I_8();
2328         uint ea = EA_AY_DI_8();
2329         uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
2330
2331         m68ki_write_8(ea, res);
2332
2333         FLAG_N = NFLAG_8(res);
2334         FLAG_Z = res;
2335         FLAG_C = CFLAG_CLEAR;
2336         FLAG_V = VFLAG_CLEAR;
2337 }
2338
2339
2340 void m68k_op_ori_8_ix(void)
2341 {
2342         uint src = OPER_I_8();
2343         uint ea = EA_AY_IX_8();
2344         uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
2345
2346         m68ki_write_8(ea, res);
2347
2348         FLAG_N = NFLAG_8(res);
2349         FLAG_Z = res;
2350         FLAG_C = CFLAG_CLEAR;
2351         FLAG_V = VFLAG_CLEAR;
2352 }
2353
2354
2355 void m68k_op_ori_8_aw(void)
2356 {
2357         uint src = OPER_I_8();
2358         uint ea = EA_AW_8();
2359         uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
2360
2361         m68ki_write_8(ea, res);
2362
2363         FLAG_N = NFLAG_8(res);
2364         FLAG_Z = res;
2365         FLAG_C = CFLAG_CLEAR;
2366         FLAG_V = VFLAG_CLEAR;
2367 }
2368
2369
2370 void m68k_op_ori_8_al(void)
2371 {
2372         uint src = OPER_I_8();
2373         uint ea = EA_AL_8();
2374         uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
2375
2376         m68ki_write_8(ea, res);
2377
2378         FLAG_N = NFLAG_8(res);
2379         FLAG_Z = res;
2380         FLAG_C = CFLAG_CLEAR;
2381         FLAG_V = VFLAG_CLEAR;
2382 }
2383
2384
2385 void m68k_op_ori_16_d(void)
2386 {
2387         uint res = MASK_OUT_ABOVE_16(DY |= OPER_I_16());
2388
2389         FLAG_N = NFLAG_16(res);
2390         FLAG_Z = res;
2391         FLAG_C = CFLAG_CLEAR;
2392         FLAG_V = VFLAG_CLEAR;
2393 }
2394
2395
2396 void m68k_op_ori_16_ai(void)
2397 {
2398         uint src = OPER_I_16();
2399         uint ea = EA_AY_AI_16();
2400         uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));
2401
2402         m68ki_write_16(ea, res);
2403
2404         FLAG_N = NFLAG_16(res);
2405         FLAG_Z = res;
2406         FLAG_C = CFLAG_CLEAR;
2407         FLAG_V = VFLAG_CLEAR;
2408 }
2409
2410
2411 void m68k_op_ori_16_pi(void)
2412 {
2413         uint src = OPER_I_16();
2414         uint ea = EA_AY_PI_16();
2415         uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));
2416
2417         m68ki_write_16(ea, res);
2418
2419         FLAG_N = NFLAG_16(res);
2420         FLAG_Z = res;
2421         FLAG_C = CFLAG_CLEAR;
2422         FLAG_V = VFLAG_CLEAR;
2423 }
2424
2425
2426 void m68k_op_ori_16_pd(void)
2427 {
2428         uint src = OPER_I_16();
2429         uint ea = EA_AY_PD_16();
2430         uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));
2431
2432         m68ki_write_16(ea, res);
2433
2434         FLAG_N = NFLAG_16(res);
2435         FLAG_Z = res;
2436         FLAG_C = CFLAG_CLEAR;
2437         FLAG_V = VFLAG_CLEAR;
2438 }
2439
2440
2441 void m68k_op_ori_16_di(void)
2442 {
2443         uint src = OPER_I_16();
2444         uint ea = EA_AY_DI_16();
2445         uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));
2446
2447         m68ki_write_16(ea, res);
2448
2449         FLAG_N = NFLAG_16(res);
2450         FLAG_Z = res;
2451         FLAG_C = CFLAG_CLEAR;
2452         FLAG_V = VFLAG_CLEAR;
2453 }
2454
2455
2456 void m68k_op_ori_16_ix(void)
2457 {
2458         uint src = OPER_I_16();
2459         uint ea = EA_AY_IX_16();
2460         uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));
2461
2462         m68ki_write_16(ea, res);
2463
2464         FLAG_N = NFLAG_16(res);
2465         FLAG_Z = res;
2466         FLAG_C = CFLAG_CLEAR;
2467         FLAG_V = VFLAG_CLEAR;
2468 }
2469
2470
2471 void m68k_op_ori_16_aw(void)
2472 {
2473         uint src = OPER_I_16();
2474         uint ea = EA_AW_16();
2475         uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));
2476
2477         m68ki_write_16(ea, res);
2478
2479         FLAG_N = NFLAG_16(res);
2480         FLAG_Z = res;
2481         FLAG_C = CFLAG_CLEAR;
2482         FLAG_V = VFLAG_CLEAR;
2483 }
2484
2485
2486 void m68k_op_ori_16_al(void)
2487 {
2488         uint src = OPER_I_16();
2489         uint ea = EA_AL_16();
2490         uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));
2491
2492         m68ki_write_16(ea, res);
2493
2494         FLAG_N = NFLAG_16(res);
2495         FLAG_Z = res;
2496         FLAG_C = CFLAG_CLEAR;
2497         FLAG_V = VFLAG_CLEAR;
2498 }
2499
2500
2501 void m68k_op_ori_32_d(void)
2502 {
2503         uint res = DY |= OPER_I_32();
2504
2505         FLAG_N = NFLAG_32(res);
2506         FLAG_Z = res;
2507         FLAG_C = CFLAG_CLEAR;
2508         FLAG_V = VFLAG_CLEAR;
2509 }
2510
2511
2512 void m68k_op_ori_32_ai(void)
2513 {
2514         uint src = OPER_I_32();
2515         uint ea = EA_AY_AI_32();
2516         uint res = src | m68ki_read_32(ea);
2517
2518         m68ki_write_32(ea, res);
2519
2520         FLAG_N = NFLAG_32(res);
2521         FLAG_Z = res;
2522         FLAG_C = CFLAG_CLEAR;
2523         FLAG_V = VFLAG_CLEAR;
2524 }
2525
2526
2527 void m68k_op_ori_32_pi(void)
2528 {
2529         uint src = OPER_I_32();
2530         uint ea = EA_AY_PI_32();
2531         uint res = src | m68ki_read_32(ea);
2532
2533         m68ki_write_32(ea, res);
2534
2535         FLAG_N = NFLAG_32(res);
2536         FLAG_Z = res;
2537         FLAG_C = CFLAG_CLEAR;
2538         FLAG_V = VFLAG_CLEAR;
2539 }
2540
2541
2542 void m68k_op_ori_32_pd(void)
2543 {
2544         uint src = OPER_I_32();
2545         uint ea = EA_AY_PD_32();
2546         uint res = src | m68ki_read_32(ea);
2547
2548         m68ki_write_32(ea, res);
2549
2550         FLAG_N = NFLAG_32(res);
2551         FLAG_Z = res;
2552         FLAG_C = CFLAG_CLEAR;
2553         FLAG_V = VFLAG_CLEAR;
2554 }
2555
2556
2557 void m68k_op_ori_32_di(void)
2558 {
2559         uint src = OPER_I_32();
2560         uint ea = EA_AY_DI_32();
2561         uint res = src | m68ki_read_32(ea);
2562
2563         m68ki_write_32(ea, res);
2564
2565         FLAG_N = NFLAG_32(res);
2566         FLAG_Z = res;
2567         FLAG_C = CFLAG_CLEAR;
2568         FLAG_V = VFLAG_CLEAR;
2569 }
2570
2571
2572 void m68k_op_ori_32_ix(void)
2573 {
2574         uint src = OPER_I_32();
2575         uint ea = EA_AY_IX_32();
2576         uint res = src | m68ki_read_32(ea);
2577
2578         m68ki_write_32(ea, res);
2579
2580         FLAG_N = NFLAG_32(res);
2581         FLAG_Z = res;
2582         FLAG_C = CFLAG_CLEAR;
2583         FLAG_V = VFLAG_CLEAR;
2584 }
2585
2586
2587 void m68k_op_ori_32_aw(void)
2588 {
2589         uint src = OPER_I_32();
2590         uint ea = EA_AW_32();
2591         uint res = src | m68ki_read_32(ea);
2592
2593         m68ki_write_32(ea, res);
2594
2595         FLAG_N = NFLAG_32(res);
2596         FLAG_Z = res;
2597         FLAG_C = CFLAG_CLEAR;
2598         FLAG_V = VFLAG_CLEAR;
2599 }
2600
2601
2602 void m68k_op_ori_32_al(void)
2603 {
2604         uint src = OPER_I_32();
2605         uint ea = EA_AL_32();
2606         uint res = src | m68ki_read_32(ea);
2607
2608         m68ki_write_32(ea, res);
2609
2610         FLAG_N = NFLAG_32(res);
2611         FLAG_Z = res;
2612         FLAG_C = CFLAG_CLEAR;
2613         FLAG_V = VFLAG_CLEAR;
2614 }
2615
2616
2617 void m68k_op_ori_8_toc(void)
2618 {
2619         m68ki_set_ccr(m68ki_get_ccr() | OPER_I_8());
2620 }
2621
2622
2623 void m68k_op_ori_16_tos(void)
2624 {
2625         if(FLAG_S)
2626         {
2627                 uint src = OPER_I_16();
2628                 m68ki_trace_t0();                          /* auto-disable (see m68kcpu.h) */
2629                 m68ki_set_sr(m68ki_get_sr() | src);
2630                 return;
2631         }
2632         m68ki_exception_privilege_violation();
2633 }
2634
2635
2636 void m68k_op_pack_16_rr(void)
2637 {
2638         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
2639         {
2640                 /* Note: DX and DY are reversed in Motorola's docs */
2641                 uint src = DY + OPER_I_16();
2642                 uint* r_dst = &DX;
2643
2644                 *r_dst = MASK_OUT_BELOW_8(*r_dst) | ((src >> 4) & 0x00f0) | (src & 0x000f);
2645                 return;
2646         }
2647         m68ki_exception_illegal();
2648 }
2649
2650
2651 void m68k_op_pack_16_mm_ax7(void)
2652 {
2653         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
2654         {
2655                 /* Note: AX and AY are reversed in Motorola's docs */
2656                 uint ea_src = EA_AY_PD_8();
2657                 uint src = m68ki_read_8(ea_src);
2658                 ea_src = EA_AY_PD_8();
2659                 src = ((src << 8) | m68ki_read_8(ea_src)) + OPER_I_16();
2660
2661                 m68ki_write_8(EA_A7_PD_8(), ((src >> 4) & 0x00f0) | (src & 0x000f));
2662                 return;
2663         }
2664         m68ki_exception_illegal();
2665 }
2666
2667
2668 void m68k_op_pack_16_mm_ay7(void)
2669 {
2670         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
2671         {
2672                 /* Note: AX and AY are reversed in Motorola's docs */
2673                 uint ea_src = EA_A7_PD_8();
2674                 uint src = m68ki_read_8(ea_src);
2675                 ea_src = EA_A7_PD_8();
2676                 src = ((src << 8) | m68ki_read_8(ea_src)) + OPER_I_16();
2677
2678                 m68ki_write_8(EA_AX_PD_8(), ((src >> 4) & 0x00f0) | (src & 0x000f));
2679                 return;
2680         }
2681         m68ki_exception_illegal();
2682 }
2683
2684
2685 void m68k_op_pack_16_mm_axy7(void)
2686 {
2687         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
2688         {
2689                 uint ea_src = EA_A7_PD_8();
2690                 uint src = m68ki_read_8(ea_src);
2691                 ea_src = EA_A7_PD_8();
2692                 src = ((src << 8) | m68ki_read_8(ea_src)) + OPER_I_16();
2693
2694                 m68ki_write_8(EA_A7_PD_8(), ((src >> 4) & 0x00f0) | (src & 0x000f));
2695                 return;
2696         }
2697         m68ki_exception_illegal();
2698 }
2699
2700
2701 void m68k_op_pack_16_mm(void)
2702 {
2703         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
2704         {
2705                 /* Note: AX and AY are reversed in Motorola's docs */
2706                 uint ea_src = EA_AY_PD_8();
2707                 uint src = m68ki_read_8(ea_src);
2708                 ea_src = EA_AY_PD_8();
2709                 src = ((src << 8) | m68ki_read_8(ea_src)) + OPER_I_16();
2710
2711                 m68ki_write_8(EA_AX_PD_8(), ((src >> 4) & 0x00f0) | (src & 0x000f));
2712                 return;
2713         }
2714         m68ki_exception_illegal();
2715 }
2716
2717
2718 void m68k_op_pea_32_ai(void)
2719 {
2720         uint ea = EA_AY_AI_32();
2721
2722         m68ki_push_32(ea);
2723 }
2724
2725
2726 void m68k_op_pea_32_di(void)
2727 {
2728         uint ea = EA_AY_DI_32();
2729
2730         m68ki_push_32(ea);
2731 }
2732
2733
2734 void m68k_op_pea_32_ix(void)
2735 {
2736         uint ea = EA_AY_IX_32();
2737
2738         m68ki_push_32(ea);
2739 }
2740
2741
2742 void m68k_op_pea_32_aw(void)
2743 {
2744         uint ea = EA_AW_32();
2745
2746         m68ki_push_32(ea);
2747 }
2748
2749
2750 void m68k_op_pea_32_al(void)
2751 {
2752         uint ea = EA_AL_32();
2753
2754         m68ki_push_32(ea);
2755 }
2756
2757
2758 void m68k_op_pea_32_pcdi(void)
2759 {
2760         uint ea = EA_PCDI_32();
2761
2762         m68ki_push_32(ea);
2763 }
2764
2765
2766 void m68k_op_pea_32_pcix(void)
2767 {
2768         uint ea = EA_PCIX_32();
2769
2770         m68ki_push_32(ea);
2771 }
2772
2773
2774 void m68k_op_reset(void)
2775 {
2776         if(FLAG_S)
2777         {
2778                 m68ki_output_reset();              /* auto-disable (see m68kcpu.h) */
2779                 USE_CYCLES(CYC_RESET);
2780                 return;
2781         }
2782         m68ki_exception_privilege_violation();
2783 }
2784
2785
2786 void m68k_op_ror_8_s(void)
2787 {
2788         uint* r_dst = &DY;
2789         uint orig_shift = (((REG_IR >> 9) - 1) & 7) + 1;
2790         uint shift = orig_shift & 7;
2791         uint src = MASK_OUT_ABOVE_8(*r_dst);
2792         uint res = ROR_8(src, shift);
2793
2794         *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
2795
2796         FLAG_N = NFLAG_8(res);
2797         FLAG_Z = res;
2798         FLAG_C = src << (9-orig_shift);
2799         FLAG_V = VFLAG_CLEAR;
2800 }
2801
2802
2803 void m68k_op_ror_16_s(void)
2804 {
2805         uint* r_dst = &DY;
2806         uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
2807         uint src = MASK_OUT_ABOVE_16(*r_dst);
2808         uint res = ROR_16(src, shift);
2809
2810         *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
2811
2812         FLAG_N = NFLAG_16(res);
2813         FLAG_Z = res;
2814         FLAG_C = src << (9-shift);
2815         FLAG_V = VFLAG_CLEAR;
2816 }
2817
2818
2819 void m68k_op_ror_32_s(void)
2820 {
2821         uint* r_dst = &DY;
2822         uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
2823         uint64 src = *r_dst;
2824         uint res = ROR_32(src, shift);
2825
2826         *r_dst = res;
2827
2828         FLAG_N = NFLAG_32(res);
2829         FLAG_Z = res;
2830         FLAG_C = src << (9-shift);
2831         FLAG_V = VFLAG_CLEAR;
2832 }
2833
2834
2835 void m68k_op_ror_8_r(void)
2836 {
2837         uint* r_dst = &DY;
2838         uint orig_shift = DX & 0x3f;
2839         uint shift = orig_shift & 7;
2840         uint src = MASK_OUT_ABOVE_8(*r_dst);
2841         uint res = ROR_8(src, shift);
2842
2843         if(orig_shift != 0)
2844         {
2845                 USE_CYCLES(orig_shift<<CYC_SHIFT);
2846
2847                 *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
2848                 FLAG_C = src << (8-((shift-1)&7));
2849                 FLAG_N = NFLAG_8(res);
2850                 FLAG_Z = res;
2851                 FLAG_V = VFLAG_CLEAR;
2852                 return;
2853         }
2854
2855         FLAG_C = CFLAG_CLEAR;
2856         FLAG_N = NFLAG_8(src);
2857         FLAG_Z = src;
2858         FLAG_V = VFLAG_CLEAR;
2859 }
2860
2861
2862 void m68k_op_ror_16_r(void)
2863 {
2864         uint* r_dst = &DY;
2865         uint orig_shift = DX & 0x3f;
2866         uint shift = orig_shift & 15;
2867         uint src = MASK_OUT_ABOVE_16(*r_dst);
2868         uint res = ROR_16(src, shift);
2869
2870         if(orig_shift != 0)
2871         {
2872                 USE_CYCLES(orig_shift<<CYC_SHIFT);
2873
2874                 *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
2875                 FLAG_C = (src >> ((shift - 1) & 15)) << 8;
2876                 FLAG_N = NFLAG_16(res);
2877                 FLAG_Z = res;
2878                 FLAG_V = VFLAG_CLEAR;
2879                 return;
2880         }
2881
2882         FLAG_C = CFLAG_CLEAR;
2883         FLAG_N = NFLAG_16(src);
2884         FLAG_Z = src;
2885         FLAG_V = VFLAG_CLEAR;
2886 }
2887
2888
2889 void m68k_op_ror_32_r(void)
2890 {
2891         uint* r_dst = &DY;
2892         uint orig_shift = DX & 0x3f;
2893         uint shift = orig_shift & 31;
2894         uint64 src = *r_dst;
2895         uint res = ROR_32(src, shift);
2896
2897         if(orig_shift != 0)
2898         {
2899                 USE_CYCLES(orig_shift<<CYC_SHIFT);
2900
2901                 *r_dst = res;
2902                 FLAG_C = (src >> ((shift - 1) & 31)) << 8;
2903                 FLAG_N = NFLAG_32(res);
2904                 FLAG_Z = res;
2905                 FLAG_V = VFLAG_CLEAR;
2906                 return;
2907         }
2908
2909         FLAG_C = CFLAG_CLEAR;
2910         FLAG_N = NFLAG_32(src);
2911         FLAG_Z = src;
2912         FLAG_V = VFLAG_CLEAR;
2913 }
2914
2915
2916 void m68k_op_ror_16_ai(void)
2917 {
2918         uint ea = EA_AY_AI_16();
2919         uint src = m68ki_read_16(ea);
2920         uint res = ROR_16(src, 1);
2921
2922         m68ki_write_16(ea, res);
2923
2924         FLAG_N = NFLAG_16(res);
2925         FLAG_Z = res;
2926         FLAG_C = src << 8;
2927         FLAG_V = VFLAG_CLEAR;
2928 }
2929
2930
2931 void m68k_op_ror_16_pi(void)
2932 {
2933         uint ea = EA_AY_PI_16();
2934         uint src = m68ki_read_16(ea);
2935         uint res = ROR_16(src, 1);
2936
2937         m68ki_write_16(ea, res);
2938
2939         FLAG_N = NFLAG_16(res);
2940         FLAG_Z = res;
2941         FLAG_C = src << 8;
2942         FLAG_V = VFLAG_CLEAR;
2943 }
2944
2945
2946 void m68k_op_ror_16_pd(void)
2947 {
2948         uint ea = EA_AY_PD_16();
2949         uint src = m68ki_read_16(ea);
2950         uint res = ROR_16(src, 1);
2951
2952         m68ki_write_16(ea, res);
2953
2954         FLAG_N = NFLAG_16(res);
2955         FLAG_Z = res;
2956         FLAG_C = src << 8;
2957         FLAG_V = VFLAG_CLEAR;
2958 }
2959
2960
2961 void m68k_op_ror_16_di(void)
2962 {
2963         uint ea = EA_AY_DI_16();
2964         uint src = m68ki_read_16(ea);
2965         uint res = ROR_16(src, 1);
2966
2967         m68ki_write_16(ea, res);
2968
2969         FLAG_N = NFLAG_16(res);
2970         FLAG_Z = res;
2971         FLAG_C = src << 8;
2972         FLAG_V = VFLAG_CLEAR;
2973 }
2974
2975
2976 void m68k_op_ror_16_ix(void)
2977 {
2978         uint ea = EA_AY_IX_16();
2979         uint src = m68ki_read_16(ea);
2980         uint res = ROR_16(src, 1);
2981
2982         m68ki_write_16(ea, res);
2983
2984         FLAG_N = NFLAG_16(res);
2985         FLAG_Z = res;
2986         FLAG_C = src << 8;
2987         FLAG_V = VFLAG_CLEAR;
2988 }
2989
2990
2991 void m68k_op_ror_16_aw(void)
2992 {
2993         uint ea = EA_AW_16();
2994         uint src = m68ki_read_16(ea);
2995         uint res = ROR_16(src, 1);
2996
2997         m68ki_write_16(ea, res);
2998
2999         FLAG_N = NFLAG_16(res);
3000         FLAG_Z = res;
3001         FLAG_C = src << 8;
3002         FLAG_V = VFLAG_CLEAR;
3003 }
3004
3005
3006 void m68k_op_ror_16_al(void)
3007 {
3008         uint ea = EA_AL_16();
3009         uint src = m68ki_read_16(ea);
3010         uint res = ROR_16(src, 1);
3011
3012         m68ki_write_16(ea, res);
3013
3014         FLAG_N = NFLAG_16(res);
3015         FLAG_Z = res;
3016         FLAG_C = src << 8;
3017         FLAG_V = VFLAG_CLEAR;
3018 }
3019
3020
3021 void m68k_op_rol_8_s(void)
3022 {
3023         uint* r_dst = &DY;
3024         uint orig_shift = (((REG_IR >> 9) - 1) & 7) + 1;
3025         uint shift = orig_shift & 7;
3026         uint src = MASK_OUT_ABOVE_8(*r_dst);
3027         uint res = ROL_8(src, shift);
3028
3029         *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
3030
3031         FLAG_N = NFLAG_8(res);
3032         FLAG_Z = res;
3033         FLAG_C = src << orig_shift;
3034         FLAG_V = VFLAG_CLEAR;
3035 }
3036
3037
3038 void m68k_op_rol_16_s(void)
3039 {
3040         uint* r_dst = &DY;
3041         uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
3042         uint src = MASK_OUT_ABOVE_16(*r_dst);
3043         uint res = ROL_16(src, shift);
3044
3045         *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
3046
3047         FLAG_N = NFLAG_16(res);
3048         FLAG_Z = res;
3049         FLAG_C = src >> (8-shift);
3050         FLAG_V = VFLAG_CLEAR;
3051 }
3052
3053
3054 void m68k_op_rol_32_s(void)
3055 {
3056         uint* r_dst = &DY;
3057         uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
3058         uint64 src = *r_dst;
3059         uint res = ROL_32(src, shift);
3060
3061         *r_dst = res;
3062
3063         FLAG_N = NFLAG_32(res);
3064         FLAG_Z = res;
3065         FLAG_C = src >> (24-shift);
3066         FLAG_V = VFLAG_CLEAR;
3067 }
3068
3069
3070 void m68k_op_rol_8_r(void)
3071 {
3072         uint* r_dst = &DY;
3073         uint orig_shift = DX & 0x3f;
3074         uint shift = orig_shift & 7;
3075         uint src = MASK_OUT_ABOVE_8(*r_dst);
3076         uint res = ROL_8(src, shift);
3077
3078         if(orig_shift != 0)
3079         {
3080                 USE_CYCLES(orig_shift<<CYC_SHIFT);
3081
3082                 if(shift != 0)
3083                 {
3084                         *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
3085                         FLAG_C = src << shift;
3086                         FLAG_N = NFLAG_8(res);
3087                         FLAG_Z = res;
3088                         FLAG_V = VFLAG_CLEAR;
3089                         return;
3090                 }
3091                 FLAG_C = (src & 1)<<8;
3092                 FLAG_N = NFLAG_8(src);
3093                 FLAG_Z = src;
3094                 FLAG_V = VFLAG_CLEAR;
3095                 return;
3096         }
3097
3098         FLAG_C = CFLAG_CLEAR;
3099         FLAG_N = NFLAG_8(src);
3100         FLAG_Z = src;
3101         FLAG_V = VFLAG_CLEAR;
3102 }
3103
3104
3105 void m68k_op_rol_16_r(void)
3106 {
3107         uint* r_dst = &DY;
3108         uint orig_shift = DX & 0x3f;
3109         uint shift = orig_shift & 15;
3110         uint src = MASK_OUT_ABOVE_16(*r_dst);
3111         uint res = MASK_OUT_ABOVE_16(ROL_16(src, shift));
3112
3113         if(orig_shift != 0)
3114         {
3115                 USE_CYCLES(orig_shift<<CYC_SHIFT);
3116
3117                 if(shift != 0)
3118                 {
3119                         *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
3120                         FLAG_C = (src << shift) >> 8;
3121                         FLAG_N = NFLAG_16(res);
3122                         FLAG_Z = res;
3123                         FLAG_V = VFLAG_CLEAR;
3124                         return;
3125                 }
3126                 FLAG_C = (src & 1)<<8;
3127                 FLAG_N = NFLAG_16(src);
3128                 FLAG_Z = src;
3129                 FLAG_V = VFLAG_CLEAR;
3130                 return;
3131         }
3132
3133         FLAG_C = CFLAG_CLEAR;
3134         FLAG_N = NFLAG_16(src);
3135         FLAG_Z = src;
3136         FLAG_V = VFLAG_CLEAR;
3137 }
3138
3139
3140 void m68k_op_rol_32_r(void)
3141 {
3142         uint* r_dst = &DY;
3143         uint orig_shift = DX & 0x3f;
3144         uint shift = orig_shift & 31;
3145         uint64 src = *r_dst;
3146         uint res = ROL_32(src, shift);
3147
3148         if(orig_shift != 0)
3149         {
3150                 USE_CYCLES(orig_shift<<CYC_SHIFT);
3151
3152                 *r_dst = res;
3153
3154                 FLAG_C = (src >> (32 - shift)) << 8;
3155                 FLAG_N = NFLAG_32(res);
3156                 FLAG_Z = res;
3157                 FLAG_V = VFLAG_CLEAR;
3158                 return;
3159         }
3160
3161         FLAG_C = CFLAG_CLEAR;
3162         FLAG_N = NFLAG_32(src);
3163         FLAG_Z = src;
3164         FLAG_V = VFLAG_CLEAR;
3165 }
3166
3167
3168 void m68k_op_rol_16_ai(void)
3169 {
3170         uint ea = EA_AY_AI_16();
3171         uint src = m68ki_read_16(ea);
3172         uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));
3173
3174         m68ki_write_16(ea, res);
3175
3176         FLAG_N = NFLAG_16(res);
3177         FLAG_Z = res;
3178         FLAG_C = src >> 7;
3179         FLAG_V = VFLAG_CLEAR;
3180 }
3181
3182
3183 void m68k_op_rol_16_pi(void)
3184 {
3185         uint ea = EA_AY_PI_16();
3186         uint src = m68ki_read_16(ea);
3187         uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));
3188
3189         m68ki_write_16(ea, res);
3190
3191         FLAG_N = NFLAG_16(res);
3192         FLAG_Z = res;
3193         FLAG_C = src >> 7;
3194         FLAG_V = VFLAG_CLEAR;
3195 }
3196
3197
3198 void m68k_op_rol_16_pd(void)
3199 {
3200         uint ea = EA_AY_PD_16();
3201         uint src = m68ki_read_16(ea);
3202         uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));
3203
3204         m68ki_write_16(ea, res);
3205
3206         FLAG_N = NFLAG_16(res);
3207         FLAG_Z = res;
3208         FLAG_C = src >> 7;
3209         FLAG_V = VFLAG_CLEAR;
3210 }
3211
3212
3213 void m68k_op_rol_16_di(void)
3214 {
3215         uint ea = EA_AY_DI_16();
3216         uint src = m68ki_read_16(ea);
3217         uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));
3218
3219         m68ki_write_16(ea, res);
3220
3221         FLAG_N = NFLAG_16(res);
3222         FLAG_Z = res;
3223         FLAG_C = src >> 7;
3224         FLAG_V = VFLAG_CLEAR;
3225 }
3226
3227
3228 void m68k_op_rol_16_ix(void)
3229 {
3230         uint ea = EA_AY_IX_16();
3231         uint src = m68ki_read_16(ea);
3232         uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));
3233
3234         m68ki_write_16(ea, res);
3235
3236         FLAG_N = NFLAG_16(res);
3237         FLAG_Z = res;
3238         FLAG_C = src >> 7;
3239         FLAG_V = VFLAG_CLEAR;
3240 }
3241
3242
3243 void m68k_op_rol_16_aw(void)
3244 {
3245         uint ea = EA_AW_16();
3246         uint src = m68ki_read_16(ea);
3247         uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));
3248
3249         m68ki_write_16(ea, res);
3250
3251         FLAG_N = NFLAG_16(res);
3252         FLAG_Z = res;
3253         FLAG_C = src >> 7;
3254         FLAG_V = VFLAG_CLEAR;
3255 }
3256
3257
3258 void m68k_op_rol_16_al(void)
3259 {
3260         uint ea = EA_AL_16();
3261         uint src = m68ki_read_16(ea);
3262         uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));
3263
3264         m68ki_write_16(ea, res);
3265
3266         FLAG_N = NFLAG_16(res);
3267         FLAG_Z = res;
3268         FLAG_C = src >> 7;
3269         FLAG_V = VFLAG_CLEAR;
3270 }
3271
3272
3273 void m68k_op_roxr_8_s(void)
3274 {
3275         uint* r_dst = &DY;
3276         uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
3277         uint src = MASK_OUT_ABOVE_8(*r_dst);
3278         uint res = ROR_9(src | (XFLAG_AS_1() << 8), shift);
3279
3280         FLAG_C = FLAG_X = res;
3281         res = MASK_OUT_ABOVE_8(res);
3282
3283         *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
3284
3285         FLAG_N = NFLAG_8(res);
3286         FLAG_Z = res;
3287         FLAG_V = VFLAG_CLEAR;
3288 }
3289
3290
3291 void m68k_op_roxr_16_s(void)
3292 {
3293         uint* r_dst = &DY;
3294         uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
3295         uint src = MASK_OUT_ABOVE_16(*r_dst);
3296         uint res = ROR_17(src | (XFLAG_AS_1() << 16), shift);
3297
3298         FLAG_C = FLAG_X = res >> 8;
3299         res = MASK_OUT_ABOVE_16(res);
3300
3301         *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
3302
3303         FLAG_N = NFLAG_16(res);
3304         FLAG_Z = res;
3305         FLAG_V = VFLAG_CLEAR;
3306 }
3307
3308
3309 void m68k_op_roxr_32_s(void)
3310 {
3311 #if M68K_USE_64_BIT
3312
3313         uint*  r_dst = &DY;
3314         uint   shift = (((REG_IR >> 9) - 1) & 7) + 1;
3315         uint64 src   = *r_dst;
3316         uint64 res   = src | (((uint64)XFLAG_AS_1()) << 32);
3317
3318         res = ROR_33_64(res, shift);
3319
3320         FLAG_C = FLAG_X = res >> 24;
3321         res = MASK_OUT_ABOVE_32(res);
3322
3323         *r_dst =  res;
3324
3325         FLAG_N = NFLAG_32(res);
3326         FLAG_Z = res;
3327         FLAG_V = VFLAG_CLEAR;
3328
3329 #else
3330
3331         uint* r_dst = &DY;
3332         uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
3333         uint src = *r_dst;
3334         uint res = MASK_OUT_ABOVE_32((ROR_33(src, shift) & ~(1 << (32 - shift))) | (XFLAG_AS_1() << (32 - shift)));
3335         uint new_x_flag = src & (1 << (shift - 1));
3336
3337         *r_dst = res;
3338
3339         FLAG_C = FLAG_X = (new_x_flag != 0)<<8;
3340         FLAG_N = NFLAG_32(res);
3341         FLAG_Z = res;
3342         FLAG_V = VFLAG_CLEAR;
3343
3344 #endif
3345 }
3346
3347
3348 void m68k_op_roxr_8_r(void)
3349 {
3350         uint* r_dst = &DY;
3351         uint orig_shift = DX & 0x3f;
3352
3353         if(orig_shift != 0)
3354         {
3355                 uint shift = orig_shift % 9;
3356                 uint src   = MASK_OUT_ABOVE_8(*r_dst);
3357                 uint res   = ROR_9(src | (XFLAG_AS_1() << 8), shift);
3358
3359                 USE_CYCLES(orig_shift<<CYC_SHIFT);
3360
3361                 FLAG_C = FLAG_X = res;
3362                 res = MASK_OUT_ABOVE_8(res);
3363
3364                 *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
3365                 FLAG_N = NFLAG_8(res);
3366                 FLAG_Z = res;
3367                 FLAG_V = VFLAG_CLEAR;
3368                 return;
3369         }
3370
3371         FLAG_C = FLAG_X;
3372         FLAG_N = NFLAG_8(*r_dst);
3373         FLAG_Z = MASK_OUT_ABOVE_8(*r_dst);
3374         FLAG_V = VFLAG_CLEAR;
3375 }
3376
3377
3378 void m68k_op_roxr_16_r(void)
3379 {
3380         uint* r_dst = &DY;
3381         uint orig_shift = DX & 0x3f;
3382
3383         if(orig_shift != 0)
3384         {
3385                 uint shift = orig_shift % 17;
3386                 uint src   = MASK_OUT_ABOVE_16(*r_dst);
3387                 uint res   = ROR_17(src | (XFLAG_AS_1() << 16), shift);
3388
3389                 USE_CYCLES(orig_shift<<CYC_SHIFT);
3390
3391                 FLAG_C = FLAG_X = res >> 8;
3392                 res = MASK_OUT_ABOVE_16(res);
3393
3394                 *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
3395                 FLAG_N = NFLAG_16(res);
3396                 FLAG_Z = res;
3397                 FLAG_V = VFLAG_CLEAR;
3398                 return;
3399         }
3400
3401         FLAG_C = FLAG_X;
3402         FLAG_N = NFLAG_16(*r_dst);
3403         FLAG_Z = MASK_OUT_ABOVE_16(*r_dst);
3404         FLAG_V = VFLAG_CLEAR;
3405 }
3406
3407
3408 void m68k_op_roxr_32_r(void)
3409 {
3410 #if M68K_USE_64_BIT
3411
3412         uint*  r_dst = &DY;
3413         uint   orig_shift = DX & 0x3f;
3414
3415         if(orig_shift != 0)
3416         {
3417                 uint   shift = orig_shift % 33;
3418                 uint64 src   = *r_dst;
3419                 uint64 res   = src | (((uint64)XFLAG_AS_1()) << 32);
3420
3421                 res = ROR_33_64(res, shift);
3422
3423                 USE_CYCLES(orig_shift<<CYC_SHIFT);
3424
3425                 FLAG_C = FLAG_X = res >> 24;
3426                 res = MASK_OUT_ABOVE_32(res);
3427
3428                 *r_dst = res;
3429                 FLAG_N = NFLAG_32(res);
3430                 FLAG_Z = res;
3431                 FLAG_V = VFLAG_CLEAR;
3432                 return;
3433         }
3434
3435         FLAG_C = FLAG_X;
3436         FLAG_N = NFLAG_32(*r_dst);
3437         FLAG_Z = *r_dst;
3438         FLAG_V = VFLAG_CLEAR;
3439
3440 #else
3441
3442         uint* r_dst = &DY;
3443         uint orig_shift = DX & 0x3f;
3444         uint shift = orig_shift % 33;
3445         uint src = *r_dst;
3446         uint res = MASK_OUT_ABOVE_32((ROR_33(src, shift) & ~(1 << (32 - shift))) | (XFLAG_AS_1() << (32 - shift)));
3447         uint new_x_flag = src & (1 << (shift - 1));
3448
3449         if(orig_shift != 0)
3450                 USE_CYCLES(orig_shift<<CYC_SHIFT);
3451
3452         if(shift != 0)
3453         {
3454                 *r_dst = res;
3455                 FLAG_X = (new_x_flag != 0)<<8;
3456         }
3457         else
3458                 res = src;
3459         FLAG_C = FLAG_X;
3460         FLAG_N = NFLAG_32(res);
3461         FLAG_Z = res;
3462         FLAG_V = VFLAG_CLEAR;
3463
3464 #endif
3465 }
3466
3467
3468 void m68k_op_roxr_16_ai(void)
3469 {
3470         uint ea = EA_AY_AI_16();
3471         uint src = m68ki_read_16(ea);
3472         uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);
3473
3474         FLAG_C = FLAG_X = res >> 8;
3475         res = MASK_OUT_ABOVE_16(res);
3476
3477         m68ki_write_16(ea, res);
3478
3479         FLAG_N = NFLAG_16(res);
3480         FLAG_Z = res;
3481         FLAG_V = VFLAG_CLEAR;
3482 }
3483
3484
3485 void m68k_op_roxr_16_pi(void)
3486 {
3487         uint ea = EA_AY_PI_16();
3488         uint src = m68ki_read_16(ea);
3489         uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);
3490
3491         FLAG_C = FLAG_X = res >> 8;
3492         res = MASK_OUT_ABOVE_16(res);
3493
3494         m68ki_write_16(ea, res);
3495
3496         FLAG_N = NFLAG_16(res);
3497         FLAG_Z = res;
3498         FLAG_V = VFLAG_CLEAR;
3499 }
3500
3501
3502 void m68k_op_roxr_16_pd(void)
3503 {
3504         uint ea = EA_AY_PD_16();
3505         uint src = m68ki_read_16(ea);
3506         uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);
3507
3508         FLAG_C = FLAG_X = res >> 8;
3509         res = MASK_OUT_ABOVE_16(res);
3510
3511         m68ki_write_16(ea, res);
3512
3513         FLAG_N = NFLAG_16(res);
3514         FLAG_Z = res;
3515         FLAG_V = VFLAG_CLEAR;
3516 }
3517
3518
3519 void m68k_op_roxr_16_di(void)
3520 {
3521         uint ea = EA_AY_DI_16();
3522         uint src = m68ki_read_16(ea);
3523         uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);
3524
3525         FLAG_C = FLAG_X = res >> 8;
3526         res = MASK_OUT_ABOVE_16(res);
3527
3528         m68ki_write_16(ea, res);
3529
3530         FLAG_N = NFLAG_16(res);
3531         FLAG_Z = res;
3532         FLAG_V = VFLAG_CLEAR;
3533 }
3534
3535
3536 void m68k_op_roxr_16_ix(void)
3537 {
3538         uint ea = EA_AY_IX_16();
3539         uint src = m68ki_read_16(ea);
3540         uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);
3541
3542         FLAG_C = FLAG_X = res >> 8;
3543         res = MASK_OUT_ABOVE_16(res);
3544
3545         m68ki_write_16(ea, res);
3546
3547         FLAG_N = NFLAG_16(res);
3548         FLAG_Z = res;
3549         FLAG_V = VFLAG_CLEAR;
3550 }
3551
3552
3553 void m68k_op_roxr_16_aw(void)
3554 {
3555         uint ea = EA_AW_16();
3556         uint src = m68ki_read_16(ea);
3557         uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);
3558
3559         FLAG_C = FLAG_X = res >> 8;
3560         res = MASK_OUT_ABOVE_16(res);
3561
3562         m68ki_write_16(ea, res);
3563
3564         FLAG_N = NFLAG_16(res);
3565         FLAG_Z = res;
3566         FLAG_V = VFLAG_CLEAR;
3567 }
3568
3569
3570 void m68k_op_roxr_16_al(void)
3571 {
3572         uint ea = EA_AL_16();
3573         uint src = m68ki_read_16(ea);
3574         uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);
3575
3576         FLAG_C = FLAG_X = res >> 8;
3577         res = MASK_OUT_ABOVE_16(res);
3578
3579         m68ki_write_16(ea, res);
3580
3581         FLAG_N = NFLAG_16(res);
3582         FLAG_Z = res;
3583         FLAG_V = VFLAG_CLEAR;
3584 }
3585
3586
3587 void m68k_op_roxl_8_s(void)
3588 {
3589         uint* r_dst = &DY;
3590         uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
3591         uint src = MASK_OUT_ABOVE_8(*r_dst);
3592         uint res = ROL_9(src | (XFLAG_AS_1() << 8), shift);
3593
3594         FLAG_C = FLAG_X = res;
3595         res = MASK_OUT_ABOVE_8(res);
3596
3597         *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
3598
3599         FLAG_N = NFLAG_8(res);
3600         FLAG_Z = res;
3601         FLAG_V = VFLAG_CLEAR;
3602 }
3603
3604
3605 void m68k_op_roxl_16_s(void)
3606 {
3607         uint* r_dst = &DY;
3608         uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
3609         uint src = MASK_OUT_ABOVE_16(*r_dst);
3610         uint res = ROL_17(src | (XFLAG_AS_1() << 16), shift);
3611
3612         FLAG_C = FLAG_X = res >> 8;
3613         res = MASK_OUT_ABOVE_16(res);
3614
3615         *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
3616
3617         FLAG_N = NFLAG_16(res);
3618         FLAG_Z = res;
3619         FLAG_V = VFLAG_CLEAR;
3620 }
3621
3622
3623 void m68k_op_roxl_32_s(void)
3624 {
3625 #if M68K_USE_64_BIT
3626
3627         uint*  r_dst = &DY;
3628         uint   shift = (((REG_IR >> 9) - 1) & 7) + 1;
3629         uint64 src   = *r_dst;
3630         uint64 res   = src | (((uint64)XFLAG_AS_1()) << 32);
3631
3632         res = ROL_33_64(res, shift);
3633
3634         FLAG_C = FLAG_X = res >> 24;
3635         res = MASK_OUT_ABOVE_32(res);
3636
3637         *r_dst = res;
3638
3639         FLAG_N = NFLAG_32(res);
3640         FLAG_Z = res;
3641         FLAG_V = VFLAG_CLEAR;
3642
3643 #else
3644
3645         uint* r_dst = &DY;
3646         uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
3647         uint src = *r_dst;
3648         uint res = MASK_OUT_ABOVE_32((ROL_33(src, shift) & ~(1 << (shift - 1))) | (XFLAG_AS_1() << (shift - 1)));
3649         uint new_x_flag = src & (1 << (32 - shift));
3650
3651         *r_dst = res;
3652
3653         FLAG_C = FLAG_X = (new_x_flag != 0)<<8;
3654         FLAG_N = NFLAG_32(res);
3655         FLAG_Z = res;
3656         FLAG_V = VFLAG_CLEAR;
3657
3658 #endif
3659 }
3660
3661
3662 void m68k_op_roxl_8_r(void)
3663 {
3664         uint* r_dst = &DY;
3665         uint orig_shift = DX & 0x3f;
3666
3667
3668         if(orig_shift != 0)
3669         {
3670                 uint shift = orig_shift % 9;
3671                 uint src   = MASK_OUT_ABOVE_8(*r_dst);
3672                 uint res   = ROL_9(src | (XFLAG_AS_1() << 8), shift);
3673
3674                 USE_CYCLES(orig_shift<<CYC_SHIFT);
3675
3676                 FLAG_C = FLAG_X = res;
3677                 res = MASK_OUT_ABOVE_8(res);
3678
3679                 *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
3680                 FLAG_N = NFLAG_8(res);
3681                 FLAG_Z = res;
3682                 FLAG_V = VFLAG_CLEAR;
3683                 return;
3684         }
3685
3686         FLAG_C = FLAG_X;
3687         FLAG_N = NFLAG_8(*r_dst);
3688         FLAG_Z = MASK_OUT_ABOVE_8(*r_dst);
3689         FLAG_V = VFLAG_CLEAR;
3690 }
3691
3692
3693 void m68k_op_roxl_16_r(void)
3694 {
3695         uint* r_dst = &DY;
3696         uint orig_shift = DX & 0x3f;
3697
3698         if(orig_shift != 0)
3699         {
3700                 uint shift = orig_shift % 17;
3701                 uint src   = MASK_OUT_ABOVE_16(*r_dst);
3702                 uint res   = ROL_17(src | (XFLAG_AS_1() << 16), shift);
3703
3704                 USE_CYCLES(orig_shift<<CYC_SHIFT);
3705
3706                 FLAG_C = FLAG_X = res >> 8;
3707                 res = MASK_OUT_ABOVE_16(res);
3708
3709                 *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
3710                 FLAG_N = NFLAG_16(res);
3711                 FLAG_Z = res;
3712                 FLAG_V = VFLAG_CLEAR;
3713                 return;
3714         }
3715
3716         FLAG_C = FLAG_X;
3717         FLAG_N = NFLAG_16(*r_dst);
3718         FLAG_Z = MASK_OUT_ABOVE_16(*r_dst);
3719         FLAG_V = VFLAG_CLEAR;
3720 }
3721
3722
3723 void m68k_op_roxl_32_r(void)
3724 {
3725 #if M68K_USE_64_BIT
3726
3727         uint*  r_dst = &DY;
3728         uint   orig_shift = DX & 0x3f;
3729
3730         if(orig_shift != 0)
3731         {
3732                 uint   shift = orig_shift % 33;
3733                 uint64 src   = *r_dst;
3734                 uint64 res   = src | (((uint64)XFLAG_AS_1()) << 32);
3735
3736                 res = ROL_33_64(res, shift);
3737
3738                 USE_CYCLES(orig_shift<<CYC_SHIFT);
3739
3740                 FLAG_C = FLAG_X = res >> 24;
3741                 res = MASK_OUT_ABOVE_32(res);
3742
3743                 *r_dst = res;
3744                 FLAG_N = NFLAG_32(res);
3745                 FLAG_Z = res;
3746                 FLAG_V = VFLAG_CLEAR;
3747                 return;
3748         }
3749
3750         FLAG_C = FLAG_X;
3751         FLAG_N = NFLAG_32(*r_dst);
3752         FLAG_Z = *r_dst;
3753         FLAG_V = VFLAG_CLEAR;
3754
3755 #else
3756
3757         uint* r_dst = &DY;
3758         uint orig_shift = DX & 0x3f;
3759         uint shift = orig_shift % 33;
3760         uint src = *r_dst;
3761         uint res = MASK_OUT_ABOVE_32((ROL_33(src, shift) & ~(1 << (shift - 1))) | (XFLAG_AS_1() << (shift - 1)));
3762         uint new_x_flag = src & (1 << (32 - shift));
3763
3764         if(orig_shift != 0)
3765                 USE_CYCLES(orig_shift<<CYC_SHIFT);
3766
3767         if(shift != 0)
3768         {
3769                 *r_dst = res;
3770                 FLAG_X = (new_x_flag != 0)<<8;
3771         }
3772         else
3773                 res = src;
3774         FLAG_C = FLAG_X;
3775         FLAG_N = NFLAG_32(res);
3776         FLAG_Z = res;
3777         FLAG_V = VFLAG_CLEAR;
3778
3779 #endif
3780 }
3781
3782
3783 void m68k_op_roxl_16_ai(void)
3784 {
3785         uint ea = EA_AY_AI_16();
3786         uint src = m68ki_read_16(ea);
3787         uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);
3788
3789         FLAG_C = FLAG_X = res >> 8;
3790         res = MASK_OUT_ABOVE_16(res);
3791
3792         m68ki_write_16(ea, res);
3793
3794         FLAG_N = NFLAG_16(res);
3795         FLAG_Z = res;
3796         FLAG_V = VFLAG_CLEAR;
3797 }
3798
3799
3800 void m68k_op_roxl_16_pi(void)
3801 {
3802         uint ea = EA_AY_PI_16();
3803         uint src = m68ki_read_16(ea);
3804         uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);
3805
3806         FLAG_C = FLAG_X = res >> 8;
3807         res = MASK_OUT_ABOVE_16(res);
3808
3809         m68ki_write_16(ea, res);
3810
3811         FLAG_N = NFLAG_16(res);
3812         FLAG_Z = res;
3813         FLAG_V = VFLAG_CLEAR;
3814 }
3815
3816
3817 void m68k_op_roxl_16_pd(void)
3818 {
3819         uint ea = EA_AY_PD_16();
3820         uint src = m68ki_read_16(ea);
3821         uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);
3822
3823         FLAG_C = FLAG_X = res >> 8;
3824         res = MASK_OUT_ABOVE_16(res);
3825
3826         m68ki_write_16(ea, res);
3827
3828         FLAG_N = NFLAG_16(res);
3829         FLAG_Z = res;
3830         FLAG_V = VFLAG_CLEAR;
3831 }
3832
3833
3834 void m68k_op_roxl_16_di(void)
3835 {
3836         uint ea = EA_AY_DI_16();
3837         uint src = m68ki_read_16(ea);
3838         uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);
3839
3840         FLAG_C = FLAG_X = res >> 8;
3841         res = MASK_OUT_ABOVE_16(res);
3842
3843         m68ki_write_16(ea, res);
3844
3845         FLAG_N = NFLAG_16(res);
3846         FLAG_Z = res;
3847         FLAG_V = VFLAG_CLEAR;
3848 }
3849
3850
3851 void m68k_op_roxl_16_ix(void)
3852 {
3853         uint ea = EA_AY_IX_16();
3854         uint src = m68ki_read_16(ea);
3855         uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);
3856
3857         FLAG_C = FLAG_X = res >> 8;
3858         res = MASK_OUT_ABOVE_16(res);
3859
3860         m68ki_write_16(ea, res);
3861
3862         FLAG_N = NFLAG_16(res);
3863         FLAG_Z = res;
3864         FLAG_V = VFLAG_CLEAR;
3865 }
3866
3867
3868 void m68k_op_roxl_16_aw(void)
3869 {
3870         uint ea = EA_AW_16();
3871         uint src = m68ki_read_16(ea);
3872         uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);
3873
3874         FLAG_C = FLAG_X = res >> 8;
3875         res = MASK_OUT_ABOVE_16(res);
3876
3877         m68ki_write_16(ea, res);
3878
3879         FLAG_N = NFLAG_16(res);
3880         FLAG_Z = res;
3881         FLAG_V = VFLAG_CLEAR;
3882 }
3883
3884
3885 void m68k_op_roxl_16_al(void)
3886 {
3887         uint ea = EA_AL_16();
3888         uint src = m68ki_read_16(ea);
3889         uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);
3890
3891         FLAG_C = FLAG_X = res >> 8;
3892         res = MASK_OUT_ABOVE_16(res);
3893
3894         m68ki_write_16(ea, res);
3895
3896         FLAG_N = NFLAG_16(res);
3897         FLAG_Z = res;
3898         FLAG_V = VFLAG_CLEAR;
3899 }
3900
3901
3902 void m68k_op_rtd_32(void)
3903 {
3904         if(CPU_TYPE_IS_010_PLUS(CPU_TYPE))
3905         {
3906                 uint new_pc = m68ki_pull_32();
3907
3908                 m68ki_trace_t0();                          /* auto-disable (see m68kcpu.h) */
3909                 REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + MAKE_INT_16(OPER_I_16()));
3910                 m68ki_jump(new_pc);
3911                 return;
3912         }
3913         m68ki_exception_illegal();
3914 }
3915
3916
3917 void m68k_op_rte_32(void)
3918 {
3919         if(FLAG_S)
3920         {
3921                 uint new_sr;
3922                 uint new_pc;
3923                 uint format_word;
3924
3925                 m68ki_trace_t0();                          /* auto-disable (see m68kcpu.h) */
3926
3927                 if(CPU_TYPE_IS_000(CPU_TYPE))
3928                 {
3929                         new_sr = m68ki_pull_16();
3930                         new_pc = m68ki_pull_32();
3931                         m68ki_jump(new_pc);
3932                         m68ki_set_sr(new_sr);
3933
3934                         CPU_INSTR_MODE = INSTRUCTION_YES;
3935                         CPU_RUN_MODE = RUN_MODE_NORMAL;
3936
3937                         return;
3938                 }
3939
3940                 if(CPU_TYPE_IS_010(CPU_TYPE))
3941                 {
3942                         format_word = m68ki_read_16(REG_A[7]+6) >> 12;
3943                         if(format_word == 0)
3944                         {
3945                                 new_sr = m68ki_pull_16();
3946                                 new_pc = m68ki_pull_32();
3947                                 m68ki_fake_pull_16();   /* format word */
3948                                 m68ki_jump(new_pc);
3949                                 m68ki_set_sr(new_sr);
3950                                 CPU_INSTR_MODE = INSTRUCTION_YES;
3951                                 CPU_RUN_MODE = RUN_MODE_NORMAL;
3952                                 return;
3953                         }
3954                         CPU_INSTR_MODE = INSTRUCTION_YES;
3955                         CPU_RUN_MODE = RUN_MODE_NORMAL;
3956                         /* Not handling bus fault (9) */
3957                         m68ki_exception_format_error();
3958                         return;
3959                 }
3960
3961                 /* Otherwise it's 020 */
3962 rte_loop:
3963                 format_word = m68ki_read_16(REG_A[7]+6) >> 12;
3964                 switch(format_word)
3965                 {
3966                         case 0: /* Normal */
3967                                 new_sr = m68ki_pull_16();
3968                                 new_pc = m68ki_pull_32();
3969                                 m68ki_fake_pull_16();   /* format word */
3970                                 m68ki_jump(new_pc);
3971                                 m68ki_set_sr(new_sr);
3972                                 CPU_INSTR_MODE = INSTRUCTION_YES;
3973                                 CPU_RUN_MODE = RUN_MODE_NORMAL;
3974                                 return;
3975                         case 1: /* Throwaway */
3976                                 new_sr = m68ki_pull_16();
3977                                 m68ki_fake_pull_32();   /* program counter */
3978                                 m68ki_fake_pull_16();   /* format word */
3979                                 m68ki_set_sr_noint(new_sr);
3980                                 goto rte_loop;
3981                         case 2: /* Trap */
3982                                 new_sr = m68ki_pull_16();
3983                                 new_pc = m68ki_pull_32();
3984                                 m68ki_fake_pull_16();   /* format word */
3985                                 m68ki_fake_pull_32();   /* address */
3986                                 m68ki_jump(new_pc);
3987                                 m68ki_set_sr(new_sr);
3988                                 CPU_INSTR_MODE = INSTRUCTION_YES;
3989                                 CPU_RUN_MODE = RUN_MODE_NORMAL;
3990                                 return;
3991                 }
3992                 /* Not handling long or short bus fault */
3993                 CPU_INSTR_MODE = INSTRUCTION_YES;
3994                 CPU_RUN_MODE = RUN_MODE_NORMAL;
3995                 m68ki_exception_format_error();
3996                 return;
3997         }
3998         m68ki_exception_privilege_violation();
3999 }
4000
4001
4002 void m68k_op_rtm_32(void)
4003 {
4004         if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE))
4005         {
4006                 m68ki_trace_t0();                          /* auto-disable (see m68kcpu.h) */
4007                 M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
4008                                          m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR,
4009                                          m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2))));
4010                 return;
4011         }
4012         m68ki_exception_illegal();
4013 }
4014
4015
4016 void m68k_op_rtr_32(void)
4017 {
4018         m68ki_trace_t0();                                  /* auto-disable (see m68kcpu.h) */
4019         m68ki_set_ccr(m68ki_pull_16());
4020         m68ki_jump(m68ki_pull_32());
4021 }
4022
4023
4024 void m68k_op_rts_32(void)
4025 {
4026         m68ki_trace_t0();                                  /* auto-disable (see m68kcpu.h) */
4027         m68ki_jump(m68ki_pull_32());
4028 }
4029
4030
4031 void m68k_op_sbcd_8_rr(void)
4032 {
4033         uint* r_dst = &DX;
4034         uint src = DY;
4035         uint dst = *r_dst;
4036         uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();
4037
4038         FLAG_V = ~res; /* Undefined V behavior */
4039
4040         if(res > 9)
4041                 res -= 6;
4042         res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src);
4043         FLAG_X = FLAG_C = (res > 0x99) << 8;
4044         if(FLAG_C)
4045                 res += 0xa0;
4046
4047         res = MASK_OUT_ABOVE_8(res);
4048
4049         FLAG_V &= res; /* Undefined V behavior part II */
4050         FLAG_N = NFLAG_8(res); /* Undefined N behavior */
4051         FLAG_Z |= res;
4052
4053         *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
4054 }
4055
4056
4057 void m68k_op_sbcd_8_mm_ax7(void)
4058 {
4059         uint src = OPER_AY_PD_8();
4060         uint ea  = EA_A7_PD_8();
4061         uint dst = m68ki_read_8(ea);
4062         uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();
4063
4064         FLAG_V = ~res; /* Undefined V behavior */
4065
4066         if(res > 9)
4067                 res -= 6;
4068         res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src);
4069         FLAG_X = FLAG_C = (res > 0x99) << 8;
4070         if(FLAG_C)
4071                 res += 0xa0;
4072
4073         res = MASK_OUT_ABOVE_8(res);
4074
4075         FLAG_V &= res; /* Undefined V behavior part II */
4076         FLAG_N = NFLAG_8(res); /* Undefined N behavior */
4077         FLAG_Z |= res;
4078
4079         m68ki_write_8(ea, res);
4080 }
4081
4082
4083 void m68k_op_sbcd_8_mm_ay7(void)
4084 {
4085         uint src = OPER_A7_PD_8();
4086         uint ea  = EA_AX_PD_8();
4087         uint dst = m68ki_read_8(ea);
4088         uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();
4089
4090         FLAG_V = ~res; /* Undefined V behavior */
4091
4092         if(res > 9)
4093                 res -= 6;
4094         res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src);
4095         FLAG_X = FLAG_C = (res > 0x99) << 8;
4096         if(FLAG_C)
4097                 res += 0xa0;
4098
4099         res = MASK_OUT_ABOVE_8(res);
4100
4101         FLAG_V &= res; /* Undefined V behavior part II */
4102         FLAG_N = NFLAG_8(res); /* Undefined N behavior */
4103         FLAG_Z |= res;
4104
4105         m68ki_write_8(ea, res);
4106 }
4107
4108
4109 void m68k_op_sbcd_8_mm_axy7(void)
4110 {
4111         uint src = OPER_A7_PD_8();
4112         uint ea  = EA_A7_PD_8();
4113         uint dst = m68ki_read_8(ea);
4114         uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();
4115
4116         FLAG_V = ~res; /* Undefined V behavior */
4117
4118         if(res > 9)
4119                 res -= 6;
4120         res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src);
4121         FLAG_X = FLAG_C = (res > 0x99) << 8;
4122         if(FLAG_C)
4123                 res += 0xa0;
4124
4125         res = MASK_OUT_ABOVE_8(res);
4126
4127         FLAG_V &= res; /* Undefined V behavior part II */
4128         FLAG_N = NFLAG_8(res); /* Undefined N behavior */
4129         FLAG_Z |= res;
4130
4131         m68ki_write_8(ea, res);
4132 }
4133
4134
4135 void m68k_op_sbcd_8_mm(void)
4136 {
4137         uint src = OPER_AY_PD_8();
4138         uint ea  = EA_AX_PD_8();
4139         uint dst = m68ki_read_8(ea);
4140         uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();
4141
4142         FLAG_V = ~res; /* Undefined V behavior */
4143
4144         if(res > 9)
4145                 res -= 6;
4146         res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src);
4147         FLAG_X = FLAG_C = (res > 0x99) << 8;
4148         if(FLAG_C)
4149                 res += 0xa0;
4150
4151         res = MASK_OUT_ABOVE_8(res);
4152
4153         FLAG_V &= res; /* Undefined V behavior part II */
4154         FLAG_N = NFLAG_8(res); /* Undefined N behavior */
4155         FLAG_Z |= res;
4156
4157         m68ki_write_8(ea, res);
4158 }
4159
4160
4161 void m68k_op_st_8_d(void)
4162 {
4163         DY |= 0xff;
4164 }
4165
4166
4167 void m68k_op_st_8_ai(void)
4168 {
4169         m68ki_write_8(EA_AY_AI_8(), 0xff);
4170 }
4171
4172
4173 void m68k_op_st_8_pi(void)
4174 {
4175         m68ki_write_8(EA_AY_PI_8(), 0xff);
4176 }
4177
4178
4179 void m68k_op_st_8_pi7(void)
4180 {
4181         m68ki_write_8(EA_A7_PI_8(), 0xff);
4182 }
4183
4184
4185 void m68k_op_st_8_pd(void)
4186 {
4187         m68ki_write_8(EA_AY_PD_8(), 0xff);
4188 }
4189
4190
4191 void m68k_op_st_8_pd7(void)
4192 {
4193         m68ki_write_8(EA_A7_PD_8(), 0xff);
4194 }
4195
4196
4197 void m68k_op_st_8_di(void)
4198 {
4199         m68ki_write_8(EA_AY_DI_8(), 0xff);
4200 }
4201
4202
4203 void m68k_op_st_8_ix(void)
4204 {
4205         m68ki_write_8(EA_AY_IX_8(), 0xff);
4206 }
4207
4208
4209 void m68k_op_st_8_aw(void)
4210 {
4211         m68ki_write_8(EA_AW_8(), 0xff);
4212 }
4213
4214
4215 void m68k_op_st_8_al(void)
4216 {
4217         m68ki_write_8(EA_AL_8(), 0xff);
4218 }
4219
4220
4221 void m68k_op_sf_8_d(void)
4222 {
4223         DY &= 0xffffff00;
4224 }
4225
4226
4227 void m68k_op_sf_8_ai(void)
4228 {
4229         m68ki_write_8(EA_AY_AI_8(), 0);
4230 }
4231
4232
4233 void m68k_op_sf_8_pi(void)
4234 {
4235         m68ki_write_8(EA_AY_PI_8(), 0);
4236 }
4237
4238
4239 void m68k_op_sf_8_pi7(void)
4240 {
4241         m68ki_write_8(EA_A7_PI_8(), 0);
4242 }
4243
4244
4245 void m68k_op_sf_8_pd(void)
4246 {
4247         m68ki_write_8(EA_AY_PD_8(), 0);
4248 }
4249
4250
4251 void m68k_op_sf_8_pd7(void)
4252 {
4253         m68ki_write_8(EA_A7_PD_8(), 0);
4254 }
4255
4256
4257 void m68k_op_sf_8_di(void)
4258 {
4259         m68ki_write_8(EA_AY_DI_8(), 0);
4260 }
4261
4262
4263 void m68k_op_sf_8_ix(void)
4264 {
4265         m68ki_write_8(EA_AY_IX_8(), 0);
4266 }
4267
4268
4269 void m68k_op_sf_8_aw(void)
4270 {
4271         m68ki_write_8(EA_AW_8(), 0);
4272 }
4273
4274
4275 void m68k_op_sf_8_al(void)
4276 {
4277         m68ki_write_8(EA_AL_8(), 0);
4278 }
4279
4280
4281 void m68k_op_shi_8_d(void)
4282 {
4283         if(COND_HI())
4284         {
4285                 DY |= 0xff;
4286                 USE_CYCLES(CYC_SCC_R_TRUE);
4287                 return;
4288         }
4289         DY &= 0xffffff00;
4290 }
4291
4292
4293 void m68k_op_sls_8_d(void)
4294 {
4295         if(COND_LS())
4296         {
4297                 DY |= 0xff;
4298                 USE_CYCLES(CYC_SCC_R_TRUE);
4299                 return;
4300         }
4301         DY &= 0xffffff00;
4302 }
4303
4304
4305 void m68k_op_scc_8_d(void)
4306 {
4307         if(COND_CC())
4308         {
4309                 DY |= 0xff;
4310                 USE_CYCLES(CYC_SCC_R_TRUE);
4311                 return;
4312         }
4313         DY &= 0xffffff00;
4314 }
4315
4316
4317 void m68k_op_scs_8_d(void)
4318 {
4319         if(COND_CS())
4320         {
4321                 DY |= 0xff;
4322                 USE_CYCLES(CYC_SCC_R_TRUE);
4323                 return;
4324         }
4325         DY &= 0xffffff00;
4326 }
4327
4328
4329 void m68k_op_sne_8_d(void)
4330 {
4331         if(COND_NE())
4332         {
4333                 DY |= 0xff;
4334                 USE_CYCLES(CYC_SCC_R_TRUE);
4335                 return;
4336         }
4337         DY &= 0xffffff00;
4338 }
4339
4340
4341 void m68k_op_seq_8_d(void)
4342 {
4343         if(COND_EQ())
4344         {
4345                 DY |= 0xff;
4346                 USE_CYCLES(CYC_SCC_R_TRUE);
4347                 return;
4348         }
4349         DY &= 0xffffff00;
4350 }
4351
4352
4353 void m68k_op_svc_8_d(void)
4354 {
4355         if(COND_VC())
4356         {
4357                 DY |= 0xff;
4358                 USE_CYCLES(CYC_SCC_R_TRUE);
4359                 return;
4360         }
4361         DY &= 0xffffff00;
4362 }
4363
4364
4365 void m68k_op_svs_8_d(void)
4366 {
4367         if(COND_VS())
4368         {
4369                 DY |= 0xff;
4370                 USE_CYCLES(CYC_SCC_R_TRUE);
4371                 return;
4372         }
4373         DY &= 0xffffff00;
4374 }
4375
4376
4377 void m68k_op_spl_8_d(void)
4378 {
4379         if(COND_PL())
4380         {
4381                 DY |= 0xff;
4382                 USE_CYCLES(CYC_SCC_R_TRUE);
4383                 return;
4384         }
4385         DY &= 0xffffff00;
4386 }
4387
4388
4389 void m68k_op_smi_8_d(void)
4390 {
4391         if(COND_MI())
4392         {
4393                 DY |= 0xff;
4394                 USE_CYCLES(CYC_SCC_R_TRUE);
4395                 return;
4396         }
4397         DY &= 0xffffff00;
4398 }
4399
4400
4401 void m68k_op_sge_8_d(void)
4402 {
4403         if(COND_GE())
4404         {
4405                 DY |= 0xff;
4406                 USE_CYCLES(CYC_SCC_R_TRUE);
4407                 return;
4408         }
4409         DY &= 0xffffff00;
4410 }
4411
4412
4413 void m68k_op_slt_8_d(void)
4414 {
4415         if(COND_LT())
4416         {
4417                 DY |= 0xff;
4418                 USE_CYCLES(CYC_SCC_R_TRUE);
4419                 return;
4420         }
4421         DY &= 0xffffff00;
4422 }
4423
4424
4425 void m68k_op_sgt_8_d(void)
4426 {
4427         if(COND_GT())
4428         {
4429                 DY |= 0xff;
4430                 USE_CYCLES(CYC_SCC_R_TRUE);
4431                 return;
4432         }
4433         DY &= 0xffffff00;
4434 }
4435
4436
4437 void m68k_op_sle_8_d(void)
4438 {
4439         if(COND_LE())
4440         {
4441                 DY |= 0xff;
4442                 USE_CYCLES(CYC_SCC_R_TRUE);
4443                 return;
4444         }
4445         DY &= 0xffffff00;
4446 }
4447
4448
4449 void m68k_op_shi_8_ai(void)
4450 {
4451         m68ki_write_8(EA_AY_AI_8(), COND_HI() ? 0xff : 0);
4452 }
4453
4454
4455 void m68k_op_shi_8_pi(void)
4456 {
4457         m68ki_write_8(EA_AY_PI_8(), COND_HI() ? 0xff : 0);
4458 }
4459
4460
4461 void m68k_op_shi_8_pi7(void)
4462 {
4463         m68ki_write_8(EA_A7_PI_8(), COND_HI() ? 0xff : 0);
4464 }
4465
4466
4467 void m68k_op_shi_8_pd(void)
4468 {
4469         m68ki_write_8(EA_AY_PD_8(), COND_HI() ? 0xff : 0);
4470 }
4471
4472
4473 void m68k_op_shi_8_pd7(void)
4474 {
4475         m68ki_write_8(EA_A7_PD_8(), COND_HI() ? 0xff : 0);
4476 }
4477
4478
4479 void m68k_op_shi_8_di(void)
4480 {
4481         m68ki_write_8(EA_AY_DI_8(), COND_HI() ? 0xff : 0);
4482 }
4483
4484
4485 void m68k_op_shi_8_ix(void)
4486 {
4487         m68ki_write_8(EA_AY_IX_8(), COND_HI() ? 0xff : 0);
4488 }
4489
4490
4491 void m68k_op_shi_8_aw(void)
4492 {
4493         m68ki_write_8(EA_AW_8(), COND_HI() ? 0xff : 0);
4494 }
4495
4496
4497 void m68k_op_shi_8_al(void)
4498 {
4499         m68ki_write_8(EA_AL_8(), COND_HI() ? 0xff : 0);
4500 }
4501
4502
4503 void m68k_op_sls_8_ai(void)
4504 {
4505         m68ki_write_8(EA_AY_AI_8(), COND_LS() ? 0xff : 0);
4506 }
4507
4508
4509 void m68k_op_sls_8_pi(void)
4510 {
4511         m68ki_write_8(EA_AY_PI_8(), COND_LS() ? 0xff : 0);
4512 }
4513
4514
4515 void m68k_op_sls_8_pi7(void)
4516 {
4517         m68ki_write_8(EA_A7_PI_8(), COND_LS() ? 0xff : 0);
4518 }
4519
4520
4521 void m68k_op_sls_8_pd(void)
4522 {
4523         m68ki_write_8(EA_AY_PD_8(), COND_LS() ? 0xff : 0);
4524 }
4525
4526
4527 void m68k_op_sls_8_pd7(void)
4528 {
4529         m68ki_write_8(EA_A7_PD_8(), COND_LS() ? 0xff : 0);
4530 }
4531
4532
4533 void m68k_op_sls_8_di(void)
4534 {
4535         m68ki_write_8(EA_AY_DI_8(), COND_LS() ? 0xff : 0);
4536 }
4537
4538
4539 void m68k_op_sls_8_ix(void)
4540 {
4541         m68ki_write_8(EA_AY_IX_8(), COND_LS() ? 0xff : 0);
4542 }
4543
4544
4545 void m68k_op_sls_8_aw(void)
4546 {
4547         m68ki_write_8(EA_AW_8(), COND_LS() ? 0xff : 0);
4548 }
4549
4550
4551 void m68k_op_sls_8_al(void)
4552 {
4553         m68ki_write_8(EA_AL_8(), COND_LS() ? 0xff : 0);
4554 }
4555
4556
4557 void m68k_op_scc_8_ai(void)
4558 {
4559         m68ki_write_8(EA_AY_AI_8(), COND_CC() ? 0xff : 0);
4560 }
4561
4562
4563 void m68k_op_scc_8_pi(void)
4564 {
4565         m68ki_write_8(EA_AY_PI_8(), COND_CC() ? 0xff : 0);
4566 }
4567
4568
4569 void m68k_op_scc_8_pi7(void)
4570 {
4571         m68ki_write_8(EA_A7_PI_8(), COND_CC() ? 0xff : 0);
4572 }
4573
4574
4575 void m68k_op_scc_8_pd(void)
4576 {
4577         m68ki_write_8(EA_AY_PD_8(), COND_CC() ? 0xff : 0);
4578 }
4579
4580
4581 void m68k_op_scc_8_pd7(void)
4582 {
4583         m68ki_write_8(EA_A7_PD_8(), COND_CC() ? 0xff : 0);
4584 }
4585
4586
4587 void m68k_op_scc_8_di(void)
4588 {
4589         m68ki_write_8(EA_AY_DI_8(), COND_CC() ? 0xff : 0);
4590 }
4591
4592
4593 void m68k_op_scc_8_ix(void)
4594 {
4595         m68ki_write_8(EA_AY_IX_8(), COND_CC() ? 0xff : 0);
4596 }
4597
4598
4599 void m68k_op_scc_8_aw(void)
4600 {
4601         m68ki_write_8(EA_AW_8(), COND_CC() ? 0xff : 0);
4602 }
4603
4604
4605 void m68k_op_scc_8_al(void)
4606 {
4607         m68ki_write_8(EA_AL_8(), COND_CC() ? 0xff : 0);
4608 }
4609
4610
4611 void m68k_op_scs_8_ai(void)
4612 {
4613         m68ki_write_8(EA_AY_AI_8(), COND_CS() ? 0xff : 0);
4614 }
4615
4616
4617 void m68k_op_scs_8_pi(void)
4618 {
4619         m68ki_write_8(EA_AY_PI_8(), COND_CS() ? 0xff : 0);
4620 }
4621
4622
4623 void m68k_op_scs_8_pi7(void)
4624 {
4625         m68ki_write_8(EA_A7_PI_8(), COND_CS() ? 0xff : 0);
4626 }
4627
4628
4629 void m68k_op_scs_8_pd(void)
4630 {
4631         m68ki_write_8(EA_AY_PD_8(), COND_CS() ? 0xff : 0);
4632 }
4633
4634
4635 void m68k_op_scs_8_pd7(void)
4636 {
4637         m68ki_write_8(EA_A7_PD_8(), COND_CS() ? 0xff : 0);
4638 }
4639
4640
4641 void m68k_op_scs_8_di(void)
4642 {
4643         m68ki_write_8(EA_AY_DI_8(), COND_CS() ? 0xff : 0);
4644 }
4645
4646
4647 void m68k_op_scs_8_ix(void)
4648 {
4649         m68ki_write_8(EA_AY_IX_8(), COND_CS() ? 0xff : 0);
4650 }
4651
4652
4653 void m68k_op_scs_8_aw(void)
4654 {
4655         m68ki_write_8(EA_AW_8(), COND_CS() ? 0xff : 0);
4656 }
4657
4658
4659 void m68k_op_scs_8_al(void)
4660 {
4661         m68ki_write_8(EA_AL_8(), COND_CS() ? 0xff : 0);
4662 }
4663
4664
4665 void m68k_op_sne_8_ai(void)
4666 {
4667         m68ki_write_8(EA_AY_AI_8(), COND_NE() ? 0xff : 0);
4668 }
4669
4670
4671 void m68k_op_sne_8_pi(void)
4672 {
4673         m68ki_write_8(EA_AY_PI_8(), COND_NE() ? 0xff : 0);
4674 }
4675
4676
4677 void m68k_op_sne_8_pi7(void)
4678 {
4679         m68ki_write_8(EA_A7_PI_8(), COND_NE() ? 0xff : 0);
4680 }
4681
4682
4683 void m68k_op_sne_8_pd(void)
4684 {
4685         m68ki_write_8(EA_AY_PD_8(), COND_NE() ? 0xff : 0);
4686 }
4687
4688
4689 void m68k_op_sne_8_pd7(void)
4690 {
4691         m68ki_write_8(EA_A7_PD_8(), COND_NE() ? 0xff : 0);
4692 }
4693
4694
4695 void m68k_op_sne_8_di(void)
4696 {
4697         m68ki_write_8(EA_AY_DI_8(), COND_NE() ? 0xff : 0);
4698 }
4699
4700
4701 void m68k_op_sne_8_ix(void)
4702 {
4703         m68ki_write_8(EA_AY_IX_8(), COND_NE() ? 0xff : 0);
4704 }
4705
4706
4707 void m68k_op_sne_8_aw(void)
4708 {
4709         m68ki_write_8(EA_AW_8(), COND_NE() ? 0xff : 0);
4710 }
4711
4712
4713 void m68k_op_sne_8_al(void)
4714 {
4715         m68ki_write_8(EA_AL_8(), COND_NE() ? 0xff : 0);
4716 }
4717
4718
4719 void m68k_op_seq_8_ai(void)
4720 {
4721         m68ki_write_8(EA_AY_AI_8(), COND_EQ() ? 0xff : 0);
4722 }
4723
4724
4725 void m68k_op_seq_8_pi(void)
4726 {
4727         m68ki_write_8(EA_AY_PI_8(), COND_EQ() ? 0xff : 0);
4728 }
4729
4730
4731 void m68k_op_seq_8_pi7(void)
4732 {
4733         m68ki_write_8(EA_A7_PI_8(), COND_EQ() ? 0xff : 0);
4734 }
4735
4736
4737 void m68k_op_seq_8_pd(void)
4738 {
4739         m68ki_write_8(EA_AY_PD_8(), COND_EQ() ? 0xff : 0);
4740 }
4741
4742
4743 void m68k_op_seq_8_pd7(void)
4744 {
4745         m68ki_write_8(EA_A7_PD_8(), COND_EQ() ? 0xff : 0);
4746 }
4747
4748
4749 void m68k_op_seq_8_di(void)
4750 {
4751         m68ki_write_8(EA_AY_DI_8(), COND_EQ() ? 0xff : 0);
4752 }
4753
4754
4755 void m68k_op_seq_8_ix(void)
4756 {
4757         m68ki_write_8(EA_AY_IX_8(), COND_EQ() ? 0xff : 0);
4758 }
4759
4760
4761 void m68k_op_seq_8_aw(void)
4762 {
4763         m68ki_write_8(EA_AW_8(), COND_EQ() ? 0xff : 0);
4764 }
4765
4766
4767 void m68k_op_seq_8_al(void)
4768 {
4769         m68ki_write_8(EA_AL_8(), COND_EQ() ? 0xff : 0);
4770 }
4771
4772
4773 void m68k_op_svc_8_ai(void)
4774 {
4775         m68ki_write_8(EA_AY_AI_8(), COND_VC() ? 0xff : 0);
4776 }
4777
4778
4779 void m68k_op_svc_8_pi(void)
4780 {
4781         m68ki_write_8(EA_AY_PI_8(), COND_VC() ? 0xff : 0);
4782 }
4783
4784
4785 void m68k_op_svc_8_pi7(void)
4786 {
4787         m68ki_write_8(EA_A7_PI_8(), COND_VC() ? 0xff : 0);
4788 }
4789
4790
4791 void m68k_op_svc_8_pd(void)
4792 {
4793         m68ki_write_8(EA_AY_PD_8(), COND_VC() ? 0xff : 0);
4794 }
4795
4796
4797 void m68k_op_svc_8_pd7(void)
4798 {
4799         m68ki_write_8(EA_A7_PD_8(), COND_VC() ? 0xff : 0);
4800 }
4801
4802
4803 void m68k_op_svc_8_di(void)
4804 {
4805         m68ki_write_8(EA_AY_DI_8(), COND_VC() ? 0xff : 0);
4806 }
4807
4808
4809 void m68k_op_svc_8_ix(void)
4810 {
4811         m68ki_write_8(EA_AY_IX_8(), COND_VC() ? 0xff : 0);
4812 }
4813
4814
4815 void m68k_op_svc_8_aw(void)
4816 {
4817         m68ki_write_8(EA_AW_8(), COND_VC() ? 0xff : 0);
4818 }
4819
4820
4821 void m68k_op_svc_8_al(void)
4822 {
4823         m68ki_write_8(EA_AL_8(), COND_VC() ? 0xff : 0);
4824 }
4825
4826
4827 void m68k_op_svs_8_ai(void)
4828 {
4829         m68ki_write_8(EA_AY_AI_8(), COND_VS() ? 0xff : 0);
4830 }
4831
4832
4833 void m68k_op_svs_8_pi(void)
4834 {
4835         m68ki_write_8(EA_AY_PI_8(), COND_VS() ? 0xff : 0);
4836 }
4837
4838
4839 void m68k_op_svs_8_pi7(void)
4840 {
4841         m68ki_write_8(EA_A7_PI_8(), COND_VS() ? 0xff : 0);
4842 }
4843
4844
4845 void m68k_op_svs_8_pd(void)
4846 {
4847         m68ki_write_8(EA_AY_PD_8(), COND_VS() ? 0xff : 0);
4848 }
4849
4850
4851 void m68k_op_svs_8_pd7(void)
4852 {
4853         m68ki_write_8(EA_A7_PD_8(), COND_VS() ? 0xff : 0);
4854 }
4855
4856
4857 void m68k_op_svs_8_di(void)
4858 {
4859         m68ki_write_8(EA_AY_DI_8(), COND_VS() ? 0xff : 0);
4860 }
4861
4862
4863 void m68k_op_svs_8_ix(void)
4864 {
4865         m68ki_write_8(EA_AY_IX_8(), COND_VS() ? 0xff : 0);
4866 }
4867
4868
4869 void m68k_op_svs_8_aw(void)
4870 {
4871         m68ki_write_8(EA_AW_8(), COND_VS() ? 0xff : 0);
4872 }
4873
4874
4875 void m68k_op_svs_8_al(void)
4876 {
4877         m68ki_write_8(EA_AL_8(), COND_VS() ? 0xff : 0);
4878 }
4879
4880
4881 void m68k_op_spl_8_ai(void)
4882 {
4883         m68ki_write_8(EA_AY_AI_8(), COND_PL() ? 0xff : 0);
4884 }
4885
4886
4887 void m68k_op_spl_8_pi(void)
4888 {
4889         m68ki_write_8(EA_AY_PI_8(), COND_PL() ? 0xff : 0);
4890 }
4891
4892
4893 void m68k_op_spl_8_pi7(void)
4894 {
4895         m68ki_write_8(EA_A7_PI_8(), COND_PL() ? 0xff : 0);
4896 }
4897
4898
4899 void m68k_op_spl_8_pd(void)
4900 {
4901         m68ki_write_8(EA_AY_PD_8(), COND_PL() ? 0xff : 0);
4902 }
4903
4904
4905 void m68k_op_spl_8_pd7(void)
4906 {
4907         m68ki_write_8(EA_A7_PD_8(), COND_PL() ? 0xff : 0);
4908 }
4909
4910
4911 void m68k_op_spl_8_di(void)
4912 {
4913         m68ki_write_8(EA_AY_DI_8(), COND_PL() ? 0xff : 0);
4914 }
4915
4916
4917 void m68k_op_spl_8_ix(void)
4918 {
4919         m68ki_write_8(EA_AY_IX_8(), COND_PL() ? 0xff : 0);
4920 }
4921
4922
4923 void m68k_op_spl_8_aw(void)
4924 {
4925         m68ki_write_8(EA_AW_8(), COND_PL() ? 0xff : 0);
4926 }
4927
4928
4929 void m68k_op_spl_8_al(void)
4930 {
4931         m68ki_write_8(EA_AL_8(), COND_PL() ? 0xff : 0);
4932 }
4933
4934
4935 void m68k_op_smi_8_ai(void)
4936 {
4937         m68ki_write_8(EA_AY_AI_8(), COND_MI() ? 0xff : 0);
4938 }
4939
4940
4941 void m68k_op_smi_8_pi(void)
4942 {
4943         m68ki_write_8(EA_AY_PI_8(), COND_MI() ? 0xff : 0);
4944 }
4945
4946
4947 void m68k_op_smi_8_pi7(void)
4948 {
4949         m68ki_write_8(EA_A7_PI_8(), COND_MI() ? 0xff : 0);
4950 }
4951
4952
4953 void m68k_op_smi_8_pd(void)
4954 {
4955         m68ki_write_8(EA_AY_PD_8(), COND_MI() ? 0xff : 0);
4956 }
4957
4958
4959 void m68k_op_smi_8_pd7(void)
4960 {
4961         m68ki_write_8(EA_A7_PD_8(), COND_MI() ? 0xff : 0);
4962 }
4963
4964
4965 void m68k_op_smi_8_di(void)
4966 {
4967         m68ki_write_8(EA_AY_DI_8(), COND_MI() ? 0xff : 0);
4968 }
4969
4970
4971 void m68k_op_smi_8_ix(void)
4972 {
4973         m68ki_write_8(EA_AY_IX_8(), COND_MI() ? 0xff : 0);
4974 }
4975
4976
4977 void m68k_op_smi_8_aw(void)
4978 {
4979         m68ki_write_8(EA_AW_8(), COND_MI() ? 0xff : 0);
4980 }
4981
4982
4983 void m68k_op_smi_8_al(void)
4984 {
4985         m68ki_write_8(EA_AL_8(), COND_MI() ? 0xff : 0);
4986 }
4987
4988
4989 void m68k_op_sge_8_ai(void)
4990 {
4991         m68ki_write_8(EA_AY_AI_8(), COND_GE() ? 0xff : 0);
4992 }
4993
4994
4995 void m68k_op_sge_8_pi(void)
4996 {
4997         m68ki_write_8(EA_AY_PI_8(), COND_GE() ? 0xff : 0);
4998 }
4999
5000
5001 void m68k_op_sge_8_pi7(void)
5002 {
5003         m68ki_write_8(EA_A7_PI_8(), COND_GE() ? 0xff : 0);
5004 }
5005
5006
5007 void m68k_op_sge_8_pd(void)
5008 {
5009         m68ki_write_8(EA_AY_PD_8(), COND_GE() ? 0xff : 0);
5010 }
5011
5012
5013 void m68k_op_sge_8_pd7(void)
5014 {
5015         m68ki_write_8(EA_A7_PD_8(), COND_GE() ? 0xff : 0);
5016 }
5017
5018
5019 void m68k_op_sge_8_di(void)
5020 {
5021         m68ki_write_8(EA_AY_DI_8(), COND_GE() ? 0xff : 0);
5022 }
5023
5024
5025 void m68k_op_sge_8_ix(void)
5026 {
5027         m68ki_write_8(EA_AY_IX_8(), COND_GE() ? 0xff : 0);
5028 }
5029
5030
5031 void m68k_op_sge_8_aw(void)
5032 {
5033         m68ki_write_8(EA_AW_8(), COND_GE() ? 0xff : 0);
5034 }
5035
5036
5037 void m68k_op_sge_8_al(void)
5038 {
5039         m68ki_write_8(EA_AL_8(), COND_GE() ? 0xff : 0);
5040 }
5041
5042
5043 void m68k_op_slt_8_ai(void)
5044 {
5045         m68ki_write_8(EA_AY_AI_8(), COND_LT() ? 0xff : 0);
5046 }
5047
5048
5049 void m68k_op_slt_8_pi(void)
5050 {
5051         m68ki_write_8(EA_AY_PI_8(), COND_LT() ? 0xff : 0);
5052 }
5053
5054
5055 void m68k_op_slt_8_pi7(void)
5056 {
5057         m68ki_write_8(EA_A7_PI_8(), COND_LT() ? 0xff : 0);
5058 }
5059
5060
5061 void m68k_op_slt_8_pd(void)
5062 {
5063         m68ki_write_8(EA_AY_PD_8(), COND_LT() ? 0xff : 0);
5064 }
5065
5066
5067 void m68k_op_slt_8_pd7(void)
5068 {
5069         m68ki_write_8(EA_A7_PD_8(), COND_LT() ? 0xff : 0);
5070 }
5071
5072
5073 void m68k_op_slt_8_di(void)
5074 {
5075         m68ki_write_8(EA_AY_DI_8(), COND_LT() ? 0xff : 0);
5076 }
5077
5078
5079 void m68k_op_slt_8_ix(void)
5080 {
5081         m68ki_write_8(EA_AY_IX_8(), COND_LT() ? 0xff : 0);
5082 }
5083
5084
5085 void m68k_op_slt_8_aw(void)
5086 {
5087         m68ki_write_8(EA_AW_8(), COND_LT() ? 0xff : 0);
5088 }
5089
5090
5091 void m68k_op_slt_8_al(void)
5092 {
5093         m68ki_write_8(EA_AL_8(), COND_LT() ? 0xff : 0);
5094 }
5095
5096
5097 void m68k_op_sgt_8_ai(void)
5098 {
5099         m68ki_write_8(EA_AY_AI_8(), COND_GT() ? 0xff : 0);
5100 }
5101
5102
5103 void m68k_op_sgt_8_pi(void)
5104 {
5105         m68ki_write_8(EA_AY_PI_8(), COND_GT() ? 0xff : 0);
5106 }
5107
5108
5109 void m68k_op_sgt_8_pi7(void)
5110 {
5111         m68ki_write_8(EA_A7_PI_8(), COND_GT() ? 0xff : 0);
5112 }
5113
5114
5115 void m68k_op_sgt_8_pd(void)
5116 {
5117         m68ki_write_8(EA_AY_PD_8(), COND_GT() ? 0xff : 0);
5118 }
5119
5120
5121 void m68k_op_sgt_8_pd7(void)
5122 {
5123         m68ki_write_8(EA_A7_PD_8(), COND_GT() ? 0xff : 0);
5124 }
5125
5126
5127 void m68k_op_sgt_8_di(void)
5128 {
5129         m68ki_write_8(EA_AY_DI_8(), COND_GT() ? 0xff : 0);
5130 }
5131
5132
5133 void m68k_op_sgt_8_ix(void)
5134 {
5135         m68ki_write_8(EA_AY_IX_8(), COND_GT() ? 0xff : 0);
5136 }
5137
5138
5139 void m68k_op_sgt_8_aw(void)
5140 {
5141         m68ki_write_8(EA_AW_8(), COND_GT() ? 0xff : 0);
5142 }
5143
5144
5145 void m68k_op_sgt_8_al(void)
5146 {
5147         m68ki_write_8(EA_AL_8(), COND_GT() ? 0xff : 0);
5148 }
5149
5150
5151 void m68k_op_sle_8_ai(void)
5152 {
5153         m68ki_write_8(EA_AY_AI_8(), COND_LE() ? 0xff : 0);
5154 }
5155
5156
5157 void m68k_op_sle_8_pi(void)
5158 {
5159         m68ki_write_8(EA_AY_PI_8(), COND_LE() ? 0xff : 0);
5160 }
5161
5162
5163 void m68k_op_sle_8_pi7(void)
5164 {
5165         m68ki_write_8(EA_A7_PI_8(), COND_LE() ? 0xff : 0);
5166 }
5167
5168
5169 void m68k_op_sle_8_pd(void)
5170 {
5171         m68ki_write_8(EA_AY_PD_8(), COND_LE() ? 0xff : 0);
5172 }
5173
5174
5175 void m68k_op_sle_8_pd7(void)
5176 {
5177         m68ki_write_8(EA_A7_PD_8(), COND_LE() ? 0xff : 0);
5178 }
5179
5180
5181 void m68k_op_sle_8_di(void)
5182 {
5183         m68ki_write_8(EA_AY_DI_8(), COND_LE() ? 0xff : 0);
5184 }
5185
5186
5187 void m68k_op_sle_8_ix(void)
5188 {
5189         m68ki_write_8(EA_AY_IX_8(), COND_LE() ? 0xff : 0);
5190 }
5191
5192
5193 void m68k_op_sle_8_aw(void)
5194 {
5195         m68ki_write_8(EA_AW_8(), COND_LE() ? 0xff : 0);
5196 }
5197
5198
5199 void m68k_op_sle_8_al(void)
5200 {
5201         m68ki_write_8(EA_AL_8(), COND_LE() ? 0xff : 0);
5202 }
5203
5204
5205 void m68k_op_stop(void)
5206 {
5207         if(FLAG_S)
5208         {
5209                 uint new_sr = OPER_I_16();
5210                 m68ki_trace_t0();                          /* auto-disable (see m68kcpu.h) */
5211                 CPU_STOPPED |= STOP_LEVEL_STOP;
5212                 m68ki_set_sr(new_sr);
5213                 if(m68ki_remaining_cycles >= CYC_INSTRUCTION[REG_IR])
5214                         m68ki_remaining_cycles = CYC_INSTRUCTION[REG_IR];
5215                 else
5216                         USE_ALL_CYCLES();
5217                 return;
5218         }
5219         m68ki_exception_privilege_violation();
5220 }
5221
5222
5223 void m68k_op_sub_8_er_d(void)
5224 {
5225         uint* r_dst = &DX;
5226         uint src = MASK_OUT_ABOVE_8(DY);
5227         uint dst = MASK_OUT_ABOVE_8(*r_dst);
5228         uint res = dst - src;
5229
5230         FLAG_N = NFLAG_8(res);
5231         FLAG_X = FLAG_C = CFLAG_8(res);
5232         FLAG_V = VFLAG_SUB_8(src, dst, res);
5233         FLAG_Z = MASK_OUT_ABOVE_8(res);
5234
5235         *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
5236 }
5237
5238
5239 void m68k_op_sub_8_er_ai(void)
5240 {
5241         uint* r_dst = &DX;
5242         uint src = OPER_AY_AI_8();
5243         uint dst = MASK_OUT_ABOVE_8(*r_dst);
5244         uint res = dst - src;
5245
5246         FLAG_N = NFLAG_8(res);
5247         FLAG_X = FLAG_C = CFLAG_8(res);
5248         FLAG_V = VFLAG_SUB_8(src, dst, res);
5249         FLAG_Z = MASK_OUT_ABOVE_8(res);
5250
5251         *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
5252 }
5253
5254
5255 void m68k_op_sub_8_er_pi(void)
5256 {
5257         uint* r_dst = &DX;
5258         uint src = OPER_AY_PI_8();
5259         uint dst = MASK_OUT_ABOVE_8(*r_dst);
5260         uint res = dst - src;
5261
5262         FLAG_N = NFLAG_8(res);
5263         FLAG_X = FLAG_C = CFLAG_8(res);
5264         FLAG_V = VFLAG_SUB_8(src, dst, res);
5265         FLAG_Z = MASK_OUT_ABOVE_8(res);
5266
5267         *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
5268 }
5269
5270
5271 void m68k_op_sub_8_er_pi7(void)
5272 {
5273         uint* r_dst = &DX;
5274         uint src = OPER_A7_PI_8();
5275         uint dst = MASK_OUT_ABOVE_8(*r_dst);
5276         uint res = dst - src;
5277
5278         FLAG_N = NFLAG_8(res);
5279         FLAG_X = FLAG_C = CFLAG_8(res);
5280         FLAG_V = VFLAG_SUB_8(src, dst, res);
5281         FLAG_Z = MASK_OUT_ABOVE_8(res);
5282
5283         *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
5284 }
5285
5286
5287 void m68k_op_sub_8_er_pd(void)
5288 {
5289         uint* r_dst = &DX;
5290         uint src = OPER_AY_PD_8();
5291         uint dst = MASK_OUT_ABOVE_8(*r_dst);
5292         uint res = dst - src;
5293
5294         FLAG_N = NFLAG_8(res);
5295         FLAG_X = FLAG_C = CFLAG_8(res);
5296         FLAG_V = VFLAG_SUB_8(src, dst, res);
5297         FLAG_Z = MASK_OUT_ABOVE_8(res);
5298
5299         *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
5300 }
5301
5302
5303 void m68k_op_sub_8_er_pd7(void)
5304 {
5305         uint* r_dst = &DX;
5306         uint src = OPER_A7_PD_8();
5307         uint dst = MASK_OUT_ABOVE_8(*r_dst);
5308         uint res = dst - src;
5309
5310         FLAG_N = NFLAG_8(res);
5311         FLAG_X = FLAG_C = CFLAG_8(res);
5312         FLAG_V = VFLAG_SUB_8(src, dst, res);
5313         FLAG_Z = MASK_OUT_ABOVE_8(res);
5314
5315         *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
5316 }
5317
5318
5319 void m68k_op_sub_8_er_di(void)
5320 {
5321         uint* r_dst = &DX;
5322         uint src = OPER_AY_DI_8();
5323         uint dst = MASK_OUT_ABOVE_8(*r_dst);
5324         uint res = dst - src;
5325
5326         FLAG_N = NFLAG_8(res);
5327         FLAG_X = FLAG_C = CFLAG_8(res);
5328         FLAG_V = VFLAG_SUB_8(src, dst, res);
5329         FLAG_Z = MASK_OUT_ABOVE_8(res);
5330
5331         *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
5332 }
5333
5334
5335 void m68k_op_sub_8_er_ix(void)
5336 {
5337         uint* r_dst = &DX;
5338         uint src = OPER_AY_IX_8();
5339         uint dst = MASK_OUT_ABOVE_8(*r_dst);
5340         uint res = dst - src;
5341
5342         FLAG_N = NFLAG_8(res);
5343         FLAG_X = FLAG_C = CFLAG_8(res);
5344         FLAG_V = VFLAG_SUB_8(src, dst, res);
5345         FLAG_Z = MASK_OUT_ABOVE_8(res);
5346
5347         *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
5348 }
5349
5350
5351 void m68k_op_sub_8_er_aw(void)
5352 {
5353         uint* r_dst = &DX;
5354         uint src = OPER_AW_8();
5355         uint dst = MASK_OUT_ABOVE_8(*r_dst);
5356         uint res = dst - src;
5357
5358         FLAG_N = NFLAG_8(res);
5359         FLAG_X = FLAG_C = CFLAG_8(res);
5360         FLAG_V = VFLAG_SUB_8(src, dst, res);
5361         FLAG_Z = MASK_OUT_ABOVE_8(res);
5362
5363         *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
5364 }
5365
5366
5367 void m68k_op_sub_8_er_al(void)
5368 {
5369         uint* r_dst = &DX;
5370         uint src = OPER_AL_8();
5371         uint dst = MASK_OUT_ABOVE_8(*r_dst);
5372         uint res = dst - src;
5373
5374         FLAG_N = NFLAG_8(res);
5375         FLAG_X = FLAG_C = CFLAG_8(res);
5376         FLAG_V = VFLAG_SUB_8(src, dst, res);
5377         FLAG_Z = MASK_OUT_ABOVE_8(res);
5378
5379         *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
5380 }
5381
5382
5383 void m68k_op_sub_8_er_pcdi(void)
5384 {
5385         uint* r_dst = &DX;
5386         uint src = OPER_PCDI_8();
5387         uint dst = MASK_OUT_ABOVE_8(*r_dst);
5388         uint res = dst - src;
5389
5390         FLAG_N = NFLAG_8(res);
5391         FLAG_X = FLAG_C = CFLAG_8(res);
5392         FLAG_V = VFLAG_SUB_8(src, dst, res);
5393         FLAG_Z = MASK_OUT_ABOVE_8(res);
5394
5395         *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
5396 }
5397
5398
5399 void m68k_op_sub_8_er_pcix(void)
5400 {
5401         uint* r_dst = &DX;
5402         uint src = OPER_PCIX_8();
5403         uint dst = MASK_OUT_ABOVE_8(*r_dst);
5404         uint res = dst - src;
5405
5406         FLAG_N = NFLAG_8(res);
5407         FLAG_X = FLAG_C = CFLAG_8(res);
5408         FLAG_V = VFLAG_SUB_8(src, dst, res);
5409         FLAG_Z = MASK_OUT_ABOVE_8(res);
5410
5411         *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
5412 }
5413
5414
5415 void m68k_op_sub_8_er_i(void)
5416 {
5417         uint* r_dst = &DX;
5418         uint src = OPER_I_8();
5419         uint dst = MASK_OUT_ABOVE_8(*r_dst);
5420         uint res = dst - src;
5421
5422         FLAG_N = NFLAG_8(res);
5423         FLAG_X = FLAG_C = CFLAG_8(res);
5424         FLAG_V = VFLAG_SUB_8(src, dst, res);
5425         FLAG_Z = MASK_OUT_ABOVE_8(res);
5426
5427         *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
5428 }
5429
5430
5431 void m68k_op_sub_16_er_d(void)
5432 {
5433         uint* r_dst = &DX;
5434         uint src = MASK_OUT_ABOVE_16(DY);
5435         uint dst = MASK_OUT_ABOVE_16(*r_dst);
5436         uint res = dst - src;
5437
5438         FLAG_N = NFLAG_16(res);
5439         FLAG_X = FLAG_C = CFLAG_16(res);
5440         FLAG_V = VFLAG_SUB_16(src, dst, res);
5441         FLAG_Z = MASK_OUT_ABOVE_16(res);
5442
5443         *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
5444 }
5445
5446
5447 void m68k_op_sub_16_er_a(void)
5448 {
5449         uint* r_dst = &DX;
5450         uint src = MASK_OUT_ABOVE_16(AY);
5451         uint dst = MASK_OUT_ABOVE_16(*r_dst);
5452         uint res = dst - src;
5453
5454         FLAG_N = NFLAG_16(res);
5455         FLAG_X = FLAG_C = CFLAG_16(res);
5456         FLAG_V = VFLAG_SUB_16(src, dst, res);
5457         FLAG_Z = MASK_OUT_ABOVE_16(res);
5458
5459         *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
5460 }
5461
5462
5463 void m68k_op_sub_16_er_ai(void)
5464 {
5465         uint* r_dst = &DX;
5466         uint src = OPER_AY_AI_16();
5467         uint dst = MASK_OUT_ABOVE_16(*r_dst);
5468         uint res = dst - src;
5469
5470         FLAG_N = NFLAG_16(res);
5471         FLAG_X = FLAG_C = CFLAG_16(res);
5472         FLAG_V = VFLAG_SUB_16(src, dst, res);
5473         FLAG_Z = MASK_OUT_ABOVE_16(res);
5474
5475         *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
5476 }
5477
5478
5479 void m68k_op_sub_16_er_pi(void)
5480 {
5481         uint* r_dst = &DX;
5482         uint src = OPER_AY_PI_16();
5483         uint dst = MASK_OUT_ABOVE_16(*r_dst);
5484         uint res = dst - src;
5485
5486         FLAG_N = NFLAG_16(res);
5487         FLAG_X = FLAG_C = CFLAG_16(res);
5488         FLAG_V = VFLAG_SUB_16(src, dst, res);
5489         FLAG_Z = MASK_OUT_ABOVE_16(res);
5490
5491         *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
5492 }
5493
5494
5495 void m68k_op_sub_16_er_pd(void)
5496 {
5497         uint* r_dst = &DX;
5498         uint src = OPER_AY_PD_16();
5499         uint dst = MASK_OUT_ABOVE_16(*r_dst);
5500         uint res = dst - src;
5501
5502         FLAG_N = NFLAG_16(res);
5503         FLAG_X = FLAG_C = CFLAG_16(res);
5504         FLAG_V = VFLAG_SUB_16(src, dst, res);
5505         FLAG_Z = MASK_OUT_ABOVE_16(res);
5506
5507         *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
5508 }
5509
5510
5511 void m68k_op_sub_16_er_di(void)
5512 {
5513         uint* r_dst = &DX;
5514         uint src = OPER_AY_DI_16();
5515         uint dst = MASK_OUT_ABOVE_16(*r_dst);
5516         uint res = dst - src;
5517
5518         FLAG_N = NFLAG_16(res);
5519         FLAG_X = FLAG_C = CFLAG_16(res);
5520         FLAG_V = VFLAG_SUB_16(src, dst, res);
5521         FLAG_Z = MASK_OUT_ABOVE_16(res);
5522
5523         *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
5524 }
5525
5526
5527 void m68k_op_sub_16_er_ix(void)
5528 {
5529         uint* r_dst = &DX;
5530         uint src = OPER_AY_IX_16();
5531         uint dst = MASK_OUT_ABOVE_16(*r_dst);
5532         uint res = dst - src;
5533
5534         FLAG_N = NFLAG_16(res);
5535         FLAG_X = FLAG_C = CFLAG_16(res);
5536         FLAG_V = VFLAG_SUB_16(src, dst, res);
5537         FLAG_Z = MASK_OUT_ABOVE_16(res);
5538
5539         *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
5540 }
5541
5542
5543 void m68k_op_sub_16_er_aw(void)
5544 {
5545         uint* r_dst = &DX;
5546         uint src = OPER_AW_16();
5547         uint dst = MASK_OUT_ABOVE_16(*r_dst);
5548         uint res = dst - src;
5549
5550         FLAG_N = NFLAG_16(res);
5551         FLAG_X = FLAG_C = CFLAG_16(res);
5552         FLAG_V = VFLAG_SUB_16(src, dst, res);
5553         FLAG_Z = MASK_OUT_ABOVE_16(res);
5554
5555         *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
5556 }
5557
5558
5559 void m68k_op_sub_16_er_al(void)
5560 {
5561         uint* r_dst = &DX;
5562         uint src = OPER_AL_16();
5563         uint dst = MASK_OUT_ABOVE_16(*r_dst);
5564         uint res = dst - src;
5565
5566         FLAG_N = NFLAG_16(res);
5567         FLAG_X = FLAG_C = CFLAG_16(res);
5568         FLAG_V = VFLAG_SUB_16(src, dst, res);
5569         FLAG_Z = MASK_OUT_ABOVE_16(res);
5570
5571         *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
5572 }
5573
5574
5575 void m68k_op_sub_16_er_pcdi(void)
5576 {
5577         uint* r_dst = &DX;
5578         uint src = OPER_PCDI_16();
5579         uint dst = MASK_OUT_ABOVE_16(*r_dst);
5580         uint res = dst - src;
5581
5582         FLAG_N = NFLAG_16(res);
5583         FLAG_X = FLAG_C = CFLAG_16(res);
5584         FLAG_V = VFLAG_SUB_16(src, dst, res);
5585         FLAG_Z = MASK_OUT_ABOVE_16(res);
5586
5587         *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
5588 }
5589
5590
5591 void m68k_op_sub_16_er_pcix(void)
5592 {
5593         uint* r_dst = &DX;
5594         uint src = OPER_PCIX_16();
5595         uint dst = MASK_OUT_ABOVE_16(*r_dst);
5596         uint res = dst - src;
5597
5598         FLAG_N = NFLAG_16(res);
5599         FLAG_X = FLAG_C = CFLAG_16(res);
5600         FLAG_V = VFLAG_SUB_16(src, dst, res);
5601         FLAG_Z = MASK_OUT_ABOVE_16(res);
5602
5603         *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
5604 }
5605
5606
5607 void m68k_op_sub_16_er_i(void)
5608 {
5609         uint* r_dst = &DX;
5610         uint src = OPER_I_16();
5611         uint dst = MASK_OUT_ABOVE_16(*r_dst);
5612         uint res = dst - src;
5613
5614         FLAG_N = NFLAG_16(res);
5615         FLAG_X = FLAG_C = CFLAG_16(res);
5616         FLAG_V = VFLAG_SUB_16(src, dst, res);
5617         FLAG_Z = MASK_OUT_ABOVE_16(res);
5618
5619         *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
5620 }
5621
5622
5623 void m68k_op_sub_32_er_d(void)
5624 {
5625         uint* r_dst = &DX;
5626         uint src = DY;
5627         uint dst = *r_dst;
5628         uint res = dst - src;
5629
5630         FLAG_N = NFLAG_32(res);
5631         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
5632         FLAG_V = VFLAG_SUB_32(src, dst, res);
5633         FLAG_Z = MASK_OUT_ABOVE_32(res);
5634
5635         *r_dst = FLAG_Z;
5636 }
5637
5638
5639 void m68k_op_sub_32_er_a(void)
5640 {
5641         uint* r_dst = &DX;
5642         uint src = AY;
5643         uint dst = *r_dst;
5644         uint res = dst - src;
5645
5646         FLAG_N = NFLAG_32(res);
5647         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
5648         FLAG_V = VFLAG_SUB_32(src, dst, res);
5649         FLAG_Z = MASK_OUT_ABOVE_32(res);
5650
5651         *r_dst = FLAG_Z;
5652 }
5653
5654
5655 void m68k_op_sub_32_er_ai(void)
5656 {
5657         uint* r_dst = &DX;
5658         uint src = OPER_AY_AI_32();
5659         uint dst = *r_dst;
5660         uint res = dst - src;
5661
5662         FLAG_N = NFLAG_32(res);
5663         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
5664         FLAG_V = VFLAG_SUB_32(src, dst, res);
5665         FLAG_Z = MASK_OUT_ABOVE_32(res);
5666
5667         *r_dst = FLAG_Z;
5668 }
5669
5670
5671 void m68k_op_sub_32_er_pi(void)
5672 {
5673         uint* r_dst = &DX;
5674         uint src = OPER_AY_PI_32();
5675         uint dst = *r_dst;
5676         uint res = dst - src;
5677
5678         FLAG_N = NFLAG_32(res);
5679         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
5680         FLAG_V = VFLAG_SUB_32(src, dst, res);
5681         FLAG_Z = MASK_OUT_ABOVE_32(res);
5682
5683         *r_dst = FLAG_Z;
5684 }
5685
5686
5687 void m68k_op_sub_32_er_pd(void)
5688 {
5689         uint* r_dst = &DX;
5690         uint src = OPER_AY_PD_32();
5691         uint dst = *r_dst;
5692         uint res = dst - src;
5693
5694         FLAG_N = NFLAG_32(res);
5695         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
5696         FLAG_V = VFLAG_SUB_32(src, dst, res);
5697         FLAG_Z = MASK_OUT_ABOVE_32(res);
5698
5699         *r_dst = FLAG_Z;
5700 }
5701
5702
5703 void m68k_op_sub_32_er_di(void)
5704 {
5705         uint* r_dst = &DX;
5706         uint src = OPER_AY_DI_32();
5707         uint dst = *r_dst;
5708         uint res = dst - src;
5709
5710         FLAG_N = NFLAG_32(res);
5711         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
5712         FLAG_V = VFLAG_SUB_32(src, dst, res);
5713         FLAG_Z = MASK_OUT_ABOVE_32(res);
5714
5715         *r_dst = FLAG_Z;
5716 }
5717
5718
5719 void m68k_op_sub_32_er_ix(void)
5720 {
5721         uint* r_dst = &DX;
5722         uint src = OPER_AY_IX_32();
5723         uint dst = *r_dst;
5724         uint res = dst - src;
5725
5726         FLAG_N = NFLAG_32(res);
5727         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
5728         FLAG_V = VFLAG_SUB_32(src, dst, res);
5729         FLAG_Z = MASK_OUT_ABOVE_32(res);
5730
5731         *r_dst = FLAG_Z;
5732 }
5733
5734
5735 void m68k_op_sub_32_er_aw(void)
5736 {
5737         uint* r_dst = &DX;
5738         uint src = OPER_AW_32();
5739         uint dst = *r_dst;
5740         uint res = dst - src;
5741
5742         FLAG_N = NFLAG_32(res);
5743         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
5744         FLAG_V = VFLAG_SUB_32(src, dst, res);
5745         FLAG_Z = MASK_OUT_ABOVE_32(res);
5746
5747         *r_dst = FLAG_Z;
5748 }
5749
5750
5751 void m68k_op_sub_32_er_al(void)
5752 {
5753         uint* r_dst = &DX;
5754         uint src = OPER_AL_32();
5755         uint dst = *r_dst;
5756         uint res = dst - src;
5757
5758         FLAG_N = NFLAG_32(res);
5759         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
5760         FLAG_V = VFLAG_SUB_32(src, dst, res);
5761         FLAG_Z = MASK_OUT_ABOVE_32(res);
5762
5763         *r_dst = FLAG_Z;
5764 }
5765
5766
5767 void m68k_op_sub_32_er_pcdi(void)
5768 {
5769         uint* r_dst = &DX;
5770         uint src = OPER_PCDI_32();
5771         uint dst = *r_dst;
5772         uint res = dst - src;
5773
5774         FLAG_N = NFLAG_32(res);
5775         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
5776         FLAG_V = VFLAG_SUB_32(src, dst, res);
5777         FLAG_Z = MASK_OUT_ABOVE_32(res);
5778
5779         *r_dst = FLAG_Z;
5780 }
5781
5782
5783 void m68k_op_sub_32_er_pcix(void)
5784 {
5785         uint* r_dst = &DX;
5786         uint src = OPER_PCIX_32();
5787         uint dst = *r_dst;
5788         uint res = dst - src;
5789
5790         FLAG_N = NFLAG_32(res);
5791         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
5792         FLAG_V = VFLAG_SUB_32(src, dst, res);
5793         FLAG_Z = MASK_OUT_ABOVE_32(res);
5794
5795         *r_dst = FLAG_Z;
5796 }
5797
5798
5799 void m68k_op_sub_32_er_i(void)
5800 {
5801         uint* r_dst = &DX;
5802         uint src = OPER_I_32();
5803         uint dst = *r_dst;
5804         uint res = dst - src;
5805
5806         FLAG_N = NFLAG_32(res);
5807         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
5808         FLAG_V = VFLAG_SUB_32(src, dst, res);
5809         FLAG_Z = MASK_OUT_ABOVE_32(res);
5810
5811         *r_dst = FLAG_Z;
5812 }
5813
5814
5815 void m68k_op_sub_8_re_ai(void)
5816 {
5817         uint ea = EA_AY_AI_8();
5818         uint src = MASK_OUT_ABOVE_8(DX);
5819         uint dst = m68ki_read_8(ea);
5820         uint res = dst - src;
5821
5822         FLAG_N = NFLAG_8(res);
5823         FLAG_Z = MASK_OUT_ABOVE_8(res);
5824         FLAG_X = FLAG_C = CFLAG_8(res);
5825         FLAG_V = VFLAG_SUB_8(src, dst, res);
5826
5827         m68ki_write_8(ea, FLAG_Z);
5828 }
5829
5830
5831 void m68k_op_sub_8_re_pi(void)
5832 {
5833         uint ea = EA_AY_PI_8();
5834         uint src = MASK_OUT_ABOVE_8(DX);
5835         uint dst = m68ki_read_8(ea);
5836         uint res = dst - src;
5837
5838         FLAG_N = NFLAG_8(res);
5839         FLAG_Z = MASK_OUT_ABOVE_8(res);
5840         FLAG_X = FLAG_C = CFLAG_8(res);
5841         FLAG_V = VFLAG_SUB_8(src, dst, res);
5842
5843         m68ki_write_8(ea, FLAG_Z);
5844 }
5845
5846
5847 void m68k_op_sub_8_re_pi7(void)
5848 {
5849         uint ea = EA_A7_PI_8();
5850         uint src = MASK_OUT_ABOVE_8(DX);
5851         uint dst = m68ki_read_8(ea);
5852         uint res = dst - src;
5853
5854         FLAG_N = NFLAG_8(res);
5855         FLAG_Z = MASK_OUT_ABOVE_8(res);
5856         FLAG_X = FLAG_C = CFLAG_8(res);
5857         FLAG_V = VFLAG_SUB_8(src, dst, res);
5858
5859         m68ki_write_8(ea, FLAG_Z);
5860 }
5861
5862
5863 void m68k_op_sub_8_re_pd(void)
5864 {
5865         uint ea = EA_AY_PD_8();
5866         uint src = MASK_OUT_ABOVE_8(DX);
5867         uint dst = m68ki_read_8(ea);
5868         uint res = dst - src;
5869
5870         FLAG_N = NFLAG_8(res);
5871         FLAG_Z = MASK_OUT_ABOVE_8(res);
5872         FLAG_X = FLAG_C = CFLAG_8(res);
5873         FLAG_V = VFLAG_SUB_8(src, dst, res);
5874
5875         m68ki_write_8(ea, FLAG_Z);
5876 }
5877
5878
5879 void m68k_op_sub_8_re_pd7(void)
5880 {
5881         uint ea = EA_A7_PD_8();
5882         uint src = MASK_OUT_ABOVE_8(DX);
5883         uint dst = m68ki_read_8(ea);
5884         uint res = dst - src;
5885
5886         FLAG_N = NFLAG_8(res);
5887         FLAG_Z = MASK_OUT_ABOVE_8(res);
5888         FLAG_X = FLAG_C = CFLAG_8(res);
5889         FLAG_V = VFLAG_SUB_8(src, dst, res);
5890
5891         m68ki_write_8(ea, FLAG_Z);
5892 }
5893
5894
5895 void m68k_op_sub_8_re_di(void)
5896 {
5897         uint ea = EA_AY_DI_8();
5898         uint src = MASK_OUT_ABOVE_8(DX);
5899         uint dst = m68ki_read_8(ea);
5900         uint res = dst - src;
5901
5902         FLAG_N = NFLAG_8(res);
5903         FLAG_Z = MASK_OUT_ABOVE_8(res);
5904         FLAG_X = FLAG_C = CFLAG_8(res);
5905         FLAG_V = VFLAG_SUB_8(src, dst, res);
5906
5907         m68ki_write_8(ea, FLAG_Z);
5908 }
5909
5910
5911 void m68k_op_sub_8_re_ix(void)
5912 {
5913         uint ea = EA_AY_IX_8();
5914         uint src = MASK_OUT_ABOVE_8(DX);
5915         uint dst = m68ki_read_8(ea);
5916         uint res = dst - src;
5917
5918         FLAG_N = NFLAG_8(res);
5919         FLAG_Z = MASK_OUT_ABOVE_8(res);
5920         FLAG_X = FLAG_C = CFLAG_8(res);
5921         FLAG_V = VFLAG_SUB_8(src, dst, res);
5922
5923         m68ki_write_8(ea, FLAG_Z);
5924 }
5925
5926
5927 void m68k_op_sub_8_re_aw(void)
5928 {
5929         uint ea = EA_AW_8();
5930         uint src = MASK_OUT_ABOVE_8(DX);
5931         uint dst = m68ki_read_8(ea);
5932         uint res = dst - src;
5933
5934         FLAG_N = NFLAG_8(res);
5935         FLAG_Z = MASK_OUT_ABOVE_8(res);
5936         FLAG_X = FLAG_C = CFLAG_8(res);
5937         FLAG_V = VFLAG_SUB_8(src, dst, res);
5938
5939         m68ki_write_8(ea, FLAG_Z);
5940 }
5941
5942
5943 void m68k_op_sub_8_re_al(void)
5944 {
5945         uint ea = EA_AL_8();
5946         uint src = MASK_OUT_ABOVE_8(DX);
5947         uint dst = m68ki_read_8(ea);
5948         uint res = dst - src;
5949
5950         FLAG_N = NFLAG_8(res);
5951         FLAG_Z = MASK_OUT_ABOVE_8(res);
5952         FLAG_X = FLAG_C = CFLAG_8(res);
5953         FLAG_V = VFLAG_SUB_8(src, dst, res);
5954
5955         m68ki_write_8(ea, FLAG_Z);
5956 }
5957
5958
5959 void m68k_op_sub_16_re_ai(void)
5960 {
5961         uint ea = EA_AY_AI_16();
5962         uint src = MASK_OUT_ABOVE_16(DX);
5963         uint dst = m68ki_read_16(ea);
5964         uint res = dst - src;
5965
5966         FLAG_N = NFLAG_16(res);
5967         FLAG_Z = MASK_OUT_ABOVE_16(res);
5968         FLAG_X = FLAG_C = CFLAG_16(res);
5969         FLAG_V = VFLAG_SUB_16(src, dst, res);
5970
5971         m68ki_write_16(ea, FLAG_Z);
5972 }
5973
5974
5975 void m68k_op_sub_16_re_pi(void)
5976 {
5977         uint ea = EA_AY_PI_16();
5978         uint src = MASK_OUT_ABOVE_16(DX);
5979         uint dst = m68ki_read_16(ea);
5980         uint res = dst - src;
5981
5982         FLAG_N = NFLAG_16(res);
5983         FLAG_Z = MASK_OUT_ABOVE_16(res);
5984         FLAG_X = FLAG_C = CFLAG_16(res);
5985         FLAG_V = VFLAG_SUB_16(src, dst, res);
5986
5987         m68ki_write_16(ea, FLAG_Z);
5988 }
5989
5990
5991 void m68k_op_sub_16_re_pd(void)
5992 {
5993         uint ea = EA_AY_PD_16();
5994         uint src = MASK_OUT_ABOVE_16(DX);
5995         uint dst = m68ki_read_16(ea);
5996         uint res = dst - src;
5997
5998         FLAG_N = NFLAG_16(res);
5999         FLAG_Z = MASK_OUT_ABOVE_16(res);
6000         FLAG_X = FLAG_C = CFLAG_16(res);
6001         FLAG_V = VFLAG_SUB_16(src, dst, res);
6002
6003         m68ki_write_16(ea, FLAG_Z);
6004 }
6005
6006
6007 void m68k_op_sub_16_re_di(void)
6008 {
6009         uint ea = EA_AY_DI_16();
6010         uint src = MASK_OUT_ABOVE_16(DX);
6011         uint dst = m68ki_read_16(ea);
6012         uint res = dst - src;
6013
6014         FLAG_N = NFLAG_16(res);
6015         FLAG_Z = MASK_OUT_ABOVE_16(res);
6016         FLAG_X = FLAG_C = CFLAG_16(res);
6017         FLAG_V = VFLAG_SUB_16(src, dst, res);
6018
6019         m68ki_write_16(ea, FLAG_Z);
6020 }
6021
6022
6023 void m68k_op_sub_16_re_ix(void)
6024 {
6025         uint ea = EA_AY_IX_16();
6026         uint src = MASK_OUT_ABOVE_16(DX);
6027         uint dst = m68ki_read_16(ea);
6028         uint res = dst - src;
6029
6030         FLAG_N = NFLAG_16(res);
6031         FLAG_Z = MASK_OUT_ABOVE_16(res);
6032         FLAG_X = FLAG_C = CFLAG_16(res);
6033         FLAG_V = VFLAG_SUB_16(src, dst, res);
6034
6035         m68ki_write_16(ea, FLAG_Z);
6036 }
6037
6038
6039 void m68k_op_sub_16_re_aw(void)
6040 {
6041         uint ea = EA_AW_16();
6042         uint src = MASK_OUT_ABOVE_16(DX);
6043         uint dst = m68ki_read_16(ea);
6044         uint res = dst - src;
6045
6046         FLAG_N = NFLAG_16(res);
6047         FLAG_Z = MASK_OUT_ABOVE_16(res);
6048         FLAG_X = FLAG_C = CFLAG_16(res);
6049         FLAG_V = VFLAG_SUB_16(src, dst, res);
6050
6051         m68ki_write_16(ea, FLAG_Z);
6052 }
6053
6054
6055 void m68k_op_sub_16_re_al(void)
6056 {
6057         uint ea = EA_AL_16();
6058         uint src = MASK_OUT_ABOVE_16(DX);
6059         uint dst = m68ki_read_16(ea);
6060         uint res = dst - src;
6061
6062         FLAG_N = NFLAG_16(res);
6063         FLAG_Z = MASK_OUT_ABOVE_16(res);
6064         FLAG_X = FLAG_C = CFLAG_16(res);
6065         FLAG_V = VFLAG_SUB_16(src, dst, res);
6066
6067         m68ki_write_16(ea, FLAG_Z);
6068 }
6069
6070
6071 void m68k_op_sub_32_re_ai(void)
6072 {
6073         uint ea = EA_AY_AI_32();
6074         uint src = DX;
6075         uint dst = m68ki_read_32(ea);
6076         uint res = dst - src;
6077
6078         FLAG_N = NFLAG_32(res);
6079         FLAG_Z = MASK_OUT_ABOVE_32(res);
6080         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
6081         FLAG_V = VFLAG_SUB_32(src, dst, res);
6082
6083         m68ki_write_32(ea, FLAG_Z);
6084 }
6085
6086
6087 void m68k_op_sub_32_re_pi(void)
6088 {
6089         uint ea = EA_AY_PI_32();
6090         uint src = DX;
6091         uint dst = m68ki_read_32(ea);
6092         uint res = dst - src;
6093
6094         FLAG_N = NFLAG_32(res);
6095         FLAG_Z = MASK_OUT_ABOVE_32(res);
6096         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
6097         FLAG_V = VFLAG_SUB_32(src, dst, res);
6098
6099         m68ki_write_32(ea, FLAG_Z);
6100 }
6101
6102
6103 void m68k_op_sub_32_re_pd(void)
6104 {
6105         uint ea = EA_AY_PD_32();
6106         uint src = DX;
6107         uint dst = m68ki_read_32(ea);
6108         uint res = dst - src;
6109
6110         FLAG_N = NFLAG_32(res);
6111         FLAG_Z = MASK_OUT_ABOVE_32(res);
6112         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
6113         FLAG_V = VFLAG_SUB_32(src, dst, res);
6114
6115         m68ki_write_32(ea, FLAG_Z);
6116 }
6117
6118
6119 void m68k_op_sub_32_re_di(void)
6120 {
6121         uint ea = EA_AY_DI_32();
6122         uint src = DX;
6123         uint dst = m68ki_read_32(ea);
6124         uint res = dst - src;
6125
6126         FLAG_N = NFLAG_32(res);
6127         FLAG_Z = MASK_OUT_ABOVE_32(res);
6128         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
6129         FLAG_V = VFLAG_SUB_32(src, dst, res);
6130
6131         m68ki_write_32(ea, FLAG_Z);
6132 }
6133
6134
6135 void m68k_op_sub_32_re_ix(void)
6136 {
6137         uint ea = EA_AY_IX_32();
6138         uint src = DX;
6139         uint dst = m68ki_read_32(ea);
6140         uint res = dst - src;
6141
6142         FLAG_N = NFLAG_32(res);
6143         FLAG_Z = MASK_OUT_ABOVE_32(res);
6144         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
6145         FLAG_V = VFLAG_SUB_32(src, dst, res);
6146
6147         m68ki_write_32(ea, FLAG_Z);
6148 }
6149
6150
6151 void m68k_op_sub_32_re_aw(void)
6152 {
6153         uint ea = EA_AW_32();
6154         uint src = DX;
6155         uint dst = m68ki_read_32(ea);
6156         uint res = dst - src;
6157
6158         FLAG_N = NFLAG_32(res);
6159         FLAG_Z = MASK_OUT_ABOVE_32(res);
6160         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
6161         FLAG_V = VFLAG_SUB_32(src, dst, res);
6162
6163         m68ki_write_32(ea, FLAG_Z);
6164 }
6165
6166
6167 void m68k_op_sub_32_re_al(void)
6168 {
6169         uint ea = EA_AL_32();
6170         uint src = DX;
6171         uint dst = m68ki_read_32(ea);
6172         uint res = dst - src;
6173
6174         FLAG_N = NFLAG_32(res);
6175         FLAG_Z = MASK_OUT_ABOVE_32(res);
6176         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
6177         FLAG_V = VFLAG_SUB_32(src, dst, res);
6178
6179         m68ki_write_32(ea, FLAG_Z);
6180 }
6181
6182
6183 void m68k_op_suba_16_d(void)
6184 {
6185         uint* r_dst = &AX;
6186
6187         *r_dst = MASK_OUT_ABOVE_32(*r_dst - MAKE_INT_16(DY));
6188 }
6189
6190
6191 void m68k_op_suba_16_a(void)
6192 {
6193         uint* r_dst = &AX;
6194
6195         *r_dst = MASK_OUT_ABOVE_32(*r_dst - MAKE_INT_16(AY));
6196 }
6197
6198
6199 void m68k_op_suba_16_ai(void)
6200 {
6201         signed short src = MAKE_INT_16(OPER_AY_AI_16());
6202         uint* r_dst = &AX;
6203
6204         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6205 }
6206
6207
6208 void m68k_op_suba_16_pi(void)
6209 {
6210         signed short src = MAKE_INT_16(OPER_AY_PI_16());
6211         uint* r_dst = &AX;
6212
6213         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6214 }
6215
6216
6217 void m68k_op_suba_16_pd(void)
6218 {
6219         signed short src = MAKE_INT_16(OPER_AY_PD_16());
6220         uint* r_dst = &AX;
6221
6222         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6223 }
6224
6225
6226 void m68k_op_suba_16_di(void)
6227 {
6228         signed short src = MAKE_INT_16(OPER_AY_DI_16());
6229         uint* r_dst = &AX;
6230
6231         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6232 }
6233
6234
6235 void m68k_op_suba_16_ix(void)
6236 {
6237         signed short src = MAKE_INT_16(OPER_AY_IX_16());
6238         uint* r_dst = &AX;
6239
6240         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6241 }
6242
6243
6244 void m68k_op_suba_16_aw(void)
6245 {
6246         signed short src = MAKE_INT_16(OPER_AW_16());
6247         uint* r_dst = &AX;
6248
6249         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6250 }
6251
6252
6253 void m68k_op_suba_16_al(void)
6254 {
6255         signed short src = MAKE_INT_16(OPER_AL_16());
6256         uint* r_dst = &AX;
6257
6258         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6259 }
6260
6261
6262 void m68k_op_suba_16_pcdi(void)
6263 {
6264         signed short src = MAKE_INT_16(OPER_PCDI_16());
6265         uint* r_dst = &AX;
6266
6267         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6268 }
6269
6270
6271 void m68k_op_suba_16_pcix(void)
6272 {
6273         signed short src = MAKE_INT_16(OPER_PCIX_16());
6274         uint* r_dst = &AX;
6275
6276         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6277 }
6278
6279
6280 void m68k_op_suba_16_i(void)
6281 {
6282         signed short src = MAKE_INT_16(OPER_I_16());
6283         uint* r_dst = &AX;
6284
6285         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6286 }
6287
6288
6289 void m68k_op_suba_32_d(void)
6290 {
6291         uint* r_dst = &AX;
6292
6293         *r_dst = MASK_OUT_ABOVE_32(*r_dst - DY);
6294 }
6295
6296
6297 void m68k_op_suba_32_a(void)
6298 {
6299         uint* r_dst = &AX;
6300
6301         *r_dst = MASK_OUT_ABOVE_32(*r_dst - AY);
6302 }
6303
6304
6305 void m68k_op_suba_32_ai(void)
6306 {
6307         uint src = OPER_AY_AI_32();
6308         uint* r_dst = &AX;
6309
6310         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6311 }
6312
6313
6314 void m68k_op_suba_32_pi(void)
6315 {
6316         uint src = OPER_AY_PI_32();
6317         uint* r_dst = &AX;
6318
6319         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6320 }
6321
6322
6323 void m68k_op_suba_32_pd(void)
6324 {
6325         uint src = OPER_AY_PD_32();
6326         uint* r_dst = &AX;
6327
6328         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6329 }
6330
6331
6332 void m68k_op_suba_32_di(void)
6333 {
6334         uint src = OPER_AY_DI_32();
6335         uint* r_dst = &AX;
6336
6337         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6338 }
6339
6340
6341 void m68k_op_suba_32_ix(void)
6342 {
6343         uint src = OPER_AY_IX_32();
6344         uint* r_dst = &AX;
6345
6346         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6347 }
6348
6349
6350 void m68k_op_suba_32_aw(void)
6351 {
6352         uint src = OPER_AW_32();
6353         uint* r_dst = &AX;
6354
6355         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6356 }
6357
6358
6359 void m68k_op_suba_32_al(void)
6360 {
6361         uint src = OPER_AL_32();
6362         uint* r_dst = &AX;
6363
6364         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6365 }
6366
6367
6368 void m68k_op_suba_32_pcdi(void)
6369 {
6370         uint src = OPER_PCDI_32();
6371         uint* r_dst = &AX;
6372
6373         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6374 }
6375
6376
6377 void m68k_op_suba_32_pcix(void)
6378 {
6379         uint src = OPER_PCIX_32();
6380         uint* r_dst = &AX;
6381
6382         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6383 }
6384
6385
6386 void m68k_op_suba_32_i(void)
6387 {
6388         uint src = OPER_I_32();
6389         uint* r_dst = &AX;
6390
6391         *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
6392 }
6393
6394
6395 void m68k_op_subi_8_d(void)
6396 {
6397         uint* r_dst = &DY;
6398         uint src = OPER_I_8();
6399         uint dst = MASK_OUT_ABOVE_8(*r_dst);
6400         uint res = dst - src;
6401
6402         FLAG_N = NFLAG_8(res);
6403         FLAG_Z = MASK_OUT_ABOVE_8(res);
6404         FLAG_X = FLAG_C = CFLAG_8(res);
6405         FLAG_V = VFLAG_SUB_8(src, dst, res);
6406
6407         *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
6408 }
6409
6410
6411 void m68k_op_subi_8_ai(void)
6412 {
6413         uint src = OPER_I_8();
6414         uint ea = EA_AY_AI_8();
6415         uint dst = m68ki_read_8(ea);
6416         uint res = dst - src;
6417
6418         FLAG_N = NFLAG_8(res);
6419         FLAG_Z = MASK_OUT_ABOVE_8(res);
6420         FLAG_X = FLAG_C = CFLAG_8(res);
6421         FLAG_V = VFLAG_SUB_8(src, dst, res);
6422
6423         m68ki_write_8(ea, FLAG_Z);
6424 }
6425
6426
6427 void m68k_op_subi_8_pi(void)
6428 {
6429         uint src = OPER_I_8();
6430         uint ea = EA_AY_PI_8();
6431         uint dst = m68ki_read_8(ea);
6432         uint res = dst - src;
6433
6434         FLAG_N = NFLAG_8(res);
6435         FLAG_Z = MASK_OUT_ABOVE_8(res);
6436         FLAG_X = FLAG_C = CFLAG_8(res);
6437         FLAG_V = VFLAG_SUB_8(src, dst, res);
6438
6439         m68ki_write_8(ea, FLAG_Z);
6440 }
6441
6442
6443 void m68k_op_subi_8_pi7(void)
6444 {
6445         uint src = OPER_I_8();
6446         uint ea = EA_A7_PI_8();
6447         uint dst = m68ki_read_8(ea);
6448         uint res = dst - src;
6449
6450         FLAG_N = NFLAG_8(res);
6451         FLAG_Z = MASK_OUT_ABOVE_8(res);
6452         FLAG_X = FLAG_C = CFLAG_8(res);
6453         FLAG_V = VFLAG_SUB_8(src, dst, res);
6454
6455         m68ki_write_8(ea, FLAG_Z);
6456 }
6457
6458
6459 void m68k_op_subi_8_pd(void)
6460 {
6461         uint src = OPER_I_8();
6462         uint ea = EA_AY_PD_8();
6463         uint dst = m68ki_read_8(ea);
6464         uint res = dst - src;
6465
6466         FLAG_N = NFLAG_8(res);
6467         FLAG_Z = MASK_OUT_ABOVE_8(res);
6468         FLAG_X = FLAG_C = CFLAG_8(res);
6469         FLAG_V = VFLAG_SUB_8(src, dst, res);
6470
6471         m68ki_write_8(ea, FLAG_Z);
6472 }
6473
6474
6475 void m68k_op_subi_8_pd7(void)
6476 {
6477         uint src = OPER_I_8();
6478         uint ea = EA_A7_PD_8();
6479         uint dst = m68ki_read_8(ea);
6480         uint res = dst - src;
6481
6482         FLAG_N = NFLAG_8(res);
6483         FLAG_Z = MASK_OUT_ABOVE_8(res);
6484         FLAG_X = FLAG_C = CFLAG_8(res);
6485         FLAG_V = VFLAG_SUB_8(src, dst, res);
6486
6487         m68ki_write_8(ea, FLAG_Z);
6488 }
6489
6490
6491 void m68k_op_subi_8_di(void)
6492 {
6493         uint src = OPER_I_8();
6494         uint ea = EA_AY_DI_8();
6495         uint dst = m68ki_read_8(ea);
6496         uint res = dst - src;
6497
6498         FLAG_N = NFLAG_8(res);
6499         FLAG_Z = MASK_OUT_ABOVE_8(res);
6500         FLAG_X = FLAG_C = CFLAG_8(res);
6501         FLAG_V = VFLAG_SUB_8(src, dst, res);
6502
6503         m68ki_write_8(ea, FLAG_Z);
6504 }
6505
6506
6507 void m68k_op_subi_8_ix(void)
6508 {
6509         uint src = OPER_I_8();
6510         uint ea = EA_AY_IX_8();
6511         uint dst = m68ki_read_8(ea);
6512         uint res = dst - src;
6513
6514         FLAG_N = NFLAG_8(res);
6515         FLAG_Z = MASK_OUT_ABOVE_8(res);
6516         FLAG_X = FLAG_C = CFLAG_8(res);
6517         FLAG_V = VFLAG_SUB_8(src, dst, res);
6518
6519         m68ki_write_8(ea, FLAG_Z);
6520 }
6521
6522
6523 void m68k_op_subi_8_aw(void)
6524 {
6525         uint src = OPER_I_8();
6526         uint ea = EA_AW_8();
6527         uint dst = m68ki_read_8(ea);
6528         uint res = dst - src;
6529
6530         FLAG_N = NFLAG_8(res);
6531         FLAG_Z = MASK_OUT_ABOVE_8(res);
6532         FLAG_X = FLAG_C = CFLAG_8(res);
6533         FLAG_V = VFLAG_SUB_8(src, dst, res);
6534
6535         m68ki_write_8(ea, FLAG_Z);
6536 }
6537
6538
6539 void m68k_op_subi_8_al(void)
6540 {
6541         uint src = OPER_I_8();
6542         uint ea = EA_AL_8();
6543         uint dst = m68ki_read_8(ea);
6544         uint res = dst - src;
6545
6546         FLAG_N = NFLAG_8(res);
6547         FLAG_Z = MASK_OUT_ABOVE_8(res);
6548         FLAG_X = FLAG_C = CFLAG_8(res);
6549         FLAG_V = VFLAG_SUB_8(src, dst, res);
6550
6551         m68ki_write_8(ea, FLAG_Z);
6552 }
6553
6554
6555 void m68k_op_subi_16_d(void)
6556 {
6557         uint* r_dst = &DY;
6558         uint src = OPER_I_16();
6559         uint dst = MASK_OUT_ABOVE_16(*r_dst);
6560         uint res = dst - src;
6561
6562         FLAG_N = NFLAG_16(res);
6563         FLAG_Z = MASK_OUT_ABOVE_16(res);
6564         FLAG_X = FLAG_C = CFLAG_16(res);
6565         FLAG_V = VFLAG_SUB_16(src, dst, res);
6566
6567         *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
6568 }
6569
6570
6571 void m68k_op_subi_16_ai(void)
6572 {
6573         uint src = OPER_I_16();
6574         uint ea = EA_AY_AI_16();
6575         uint dst = m68ki_read_16(ea);
6576         uint res = dst - src;
6577
6578         FLAG_N = NFLAG_16(res);
6579         FLAG_Z = MASK_OUT_ABOVE_16(res);
6580         FLAG_X = FLAG_C = CFLAG_16(res);
6581         FLAG_V = VFLAG_SUB_16(src, dst, res);
6582
6583         m68ki_write_16(ea, FLAG_Z);
6584 }
6585
6586
6587 void m68k_op_subi_16_pi(void)
6588 {
6589         uint src = OPER_I_16();
6590         uint ea = EA_AY_PI_16();
6591         uint dst = m68ki_read_16(ea);
6592         uint res = dst - src;
6593
6594         FLAG_N = NFLAG_16(res);
6595         FLAG_Z = MASK_OUT_ABOVE_16(res);
6596         FLAG_X = FLAG_C = CFLAG_16(res);
6597         FLAG_V = VFLAG_SUB_16(src, dst, res);
6598
6599         m68ki_write_16(ea, FLAG_Z);
6600 }
6601
6602
6603 void m68k_op_subi_16_pd(void)
6604 {
6605         uint src = OPER_I_16();
6606         uint ea = EA_AY_PD_16();
6607         uint dst = m68ki_read_16(ea);
6608         uint res = dst - src;
6609
6610         FLAG_N = NFLAG_16(res);
6611         FLAG_Z = MASK_OUT_ABOVE_16(res);
6612         FLAG_X = FLAG_C = CFLAG_16(res);
6613         FLAG_V = VFLAG_SUB_16(src, dst, res);
6614
6615         m68ki_write_16(ea, FLAG_Z);
6616 }
6617
6618
6619 void m68k_op_subi_16_di(void)
6620 {
6621         uint src = OPER_I_16();
6622         uint ea = EA_AY_DI_16();
6623         uint dst = m68ki_read_16(ea);
6624         uint res = dst - src;
6625
6626         FLAG_N = NFLAG_16(res);
6627         FLAG_Z = MASK_OUT_ABOVE_16(res);
6628         FLAG_X = FLAG_C = CFLAG_16(res);
6629         FLAG_V = VFLAG_SUB_16(src, dst, res);
6630
6631         m68ki_write_16(ea, FLAG_Z);
6632 }
6633
6634
6635 void m68k_op_subi_16_ix(void)
6636 {
6637         uint src = OPER_I_16();
6638         uint ea = EA_AY_IX_16();
6639         uint dst = m68ki_read_16(ea);
6640         uint res = dst - src;
6641
6642         FLAG_N = NFLAG_16(res);
6643         FLAG_Z = MASK_OUT_ABOVE_16(res);
6644         FLAG_X = FLAG_C = CFLAG_16(res);
6645         FLAG_V = VFLAG_SUB_16(src, dst, res);
6646
6647         m68ki_write_16(ea, FLAG_Z);
6648 }
6649
6650
6651 void m68k_op_subi_16_aw(void)
6652 {
6653         uint src = OPER_I_16();
6654         uint ea = EA_AW_16();
6655         uint dst = m68ki_read_16(ea);
6656         uint res = dst - src;
6657
6658         FLAG_N = NFLAG_16(res);
6659         FLAG_Z = MASK_OUT_ABOVE_16(res);
6660         FLAG_X = FLAG_C = CFLAG_16(res);
6661         FLAG_V = VFLAG_SUB_16(src, dst, res);
6662
6663         m68ki_write_16(ea, FLAG_Z);
6664 }
6665
6666
6667 void m68k_op_subi_16_al(void)
6668 {
6669         uint src = OPER_I_16();
6670         uint ea = EA_AL_16();
6671         uint dst = m68ki_read_16(ea);
6672         uint res = dst - src;
6673
6674         FLAG_N = NFLAG_16(res);
6675         FLAG_Z = MASK_OUT_ABOVE_16(res);
6676         FLAG_X = FLAG_C = CFLAG_16(res);
6677         FLAG_V = VFLAG_SUB_16(src, dst, res);
6678
6679         m68ki_write_16(ea, FLAG_Z);
6680 }
6681
6682
6683 void m68k_op_subi_32_d(void)
6684 {
6685         uint* r_dst = &DY;
6686         uint src = OPER_I_32();
6687         uint dst = *r_dst;
6688         uint res = dst - src;
6689
6690         FLAG_N = NFLAG_32(res);
6691         FLAG_Z = MASK_OUT_ABOVE_32(res);
6692         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
6693         FLAG_V = VFLAG_SUB_32(src, dst, res);
6694
6695         *r_dst = FLAG_Z;
6696 }
6697
6698
6699 void m68k_op_subi_32_ai(void)
6700 {
6701         uint src = OPER_I_32();
6702         uint ea = EA_AY_AI_32();
6703         uint dst = m68ki_read_32(ea);
6704         uint res = dst - src;
6705
6706         FLAG_N = NFLAG_32(res);
6707         FLAG_Z = MASK_OUT_ABOVE_32(res);
6708         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
6709         FLAG_V = VFLAG_SUB_32(src, dst, res);
6710
6711         m68ki_write_32(ea, FLAG_Z);
6712 }
6713
6714
6715 void m68k_op_subi_32_pi(void)
6716 {
6717         uint src = OPER_I_32();
6718         uint ea = EA_AY_PI_32();
6719         uint dst = m68ki_read_32(ea);
6720         uint res = dst - src;
6721
6722         FLAG_N = NFLAG_32(res);
6723         FLAG_Z = MASK_OUT_ABOVE_32(res);
6724         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
6725         FLAG_V = VFLAG_SUB_32(src, dst, res);
6726
6727         m68ki_write_32(ea, FLAG_Z);
6728 }
6729
6730
6731 void m68k_op_subi_32_pd(void)
6732 {
6733         uint src = OPER_I_32();
6734         uint ea = EA_AY_PD_32();
6735         uint dst = m68ki_read_32(ea);
6736         uint res = dst - src;
6737
6738         FLAG_N = NFLAG_32(res);
6739         FLAG_Z = MASK_OUT_ABOVE_32(res);
6740         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
6741         FLAG_V = VFLAG_SUB_32(src, dst, res);
6742
6743         m68ki_write_32(ea, FLAG_Z);
6744 }
6745
6746
6747 void m68k_op_subi_32_di(void)
6748 {
6749         uint src = OPER_I_32();
6750         uint ea = EA_AY_DI_32();
6751         uint dst = m68ki_read_32(ea);
6752         uint res = dst - src;
6753
6754         FLAG_N = NFLAG_32(res);
6755         FLAG_Z = MASK_OUT_ABOVE_32(res);
6756         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
6757         FLAG_V = VFLAG_SUB_32(src, dst, res);
6758
6759         m68ki_write_32(ea, FLAG_Z);
6760 }
6761
6762
6763 void m68k_op_subi_32_ix(void)
6764 {
6765         uint src = OPER_I_32();
6766         uint ea = EA_AY_IX_32();
6767         uint dst = m68ki_read_32(ea);
6768         uint res = dst - src;
6769
6770         FLAG_N = NFLAG_32(res);
6771         FLAG_Z = MASK_OUT_ABOVE_32(res);
6772         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
6773         FLAG_V = VFLAG_SUB_32(src, dst, res);
6774
6775         m68ki_write_32(ea, FLAG_Z);
6776 }
6777
6778
6779 void m68k_op_subi_32_aw(void)
6780 {
6781         uint src = OPER_I_32();
6782         uint ea = EA_AW_32();
6783         uint dst = m68ki_read_32(ea);
6784         uint res = dst - src;
6785
6786         FLAG_N = NFLAG_32(res);
6787         FLAG_Z = MASK_OUT_ABOVE_32(res);
6788         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
6789         FLAG_V = VFLAG_SUB_32(src, dst, res);
6790
6791         m68ki_write_32(ea, FLAG_Z);
6792 }
6793
6794
6795 void m68k_op_subi_32_al(void)
6796 {
6797         uint src = OPER_I_32();
6798         uint ea = EA_AL_32();
6799         uint dst = m68ki_read_32(ea);
6800         uint res = dst - src;
6801
6802         FLAG_N = NFLAG_32(res);
6803         FLAG_Z = MASK_OUT_ABOVE_32(res);
6804         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
6805         FLAG_V = VFLAG_SUB_32(src, dst, res);
6806
6807         m68ki_write_32(ea, FLAG_Z);
6808 }
6809
6810
6811 void m68k_op_subq_8_d(void)
6812 {
6813         uint* r_dst = &DY;
6814         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
6815         uint dst = MASK_OUT_ABOVE_8(*r_dst);
6816         uint res = dst - src;
6817
6818         FLAG_N = NFLAG_8(res);
6819         FLAG_Z = MASK_OUT_ABOVE_8(res);
6820         FLAG_X = FLAG_C = CFLAG_8(res);
6821         FLAG_V = VFLAG_SUB_8(src, dst, res);
6822
6823         *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
6824 }
6825
6826
6827 void m68k_op_subq_8_ai(void)
6828 {
6829         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
6830         uint ea = EA_AY_AI_8();
6831         uint dst = m68ki_read_8(ea);
6832         uint res = dst - src;
6833
6834         FLAG_N = NFLAG_8(res);
6835         FLAG_Z = MASK_OUT_ABOVE_8(res);
6836         FLAG_X = FLAG_C = CFLAG_8(res);
6837         FLAG_V = VFLAG_SUB_8(src, dst, res);
6838
6839         m68ki_write_8(ea, FLAG_Z);
6840 }
6841
6842
6843 void m68k_op_subq_8_pi(void)
6844 {
6845         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
6846         uint ea = EA_AY_PI_8();
6847         uint dst = m68ki_read_8(ea);
6848         uint res = dst - src;
6849
6850         FLAG_N = NFLAG_8(res);
6851         FLAG_Z = MASK_OUT_ABOVE_8(res);
6852         FLAG_X = FLAG_C = CFLAG_8(res);
6853         FLAG_V = VFLAG_SUB_8(src, dst, res);
6854
6855         m68ki_write_8(ea, FLAG_Z);
6856 }
6857
6858
6859 void m68k_op_subq_8_pi7(void)
6860 {
6861         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
6862         uint ea = EA_A7_PI_8();
6863         uint dst = m68ki_read_8(ea);
6864         uint res = dst - src;
6865
6866         FLAG_N = NFLAG_8(res);
6867         FLAG_Z = MASK_OUT_ABOVE_8(res);
6868         FLAG_X = FLAG_C = CFLAG_8(res);
6869         FLAG_V = VFLAG_SUB_8(src, dst, res);
6870
6871         m68ki_write_8(ea, FLAG_Z);
6872 }
6873
6874
6875 void m68k_op_subq_8_pd(void)
6876 {
6877         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
6878         uint ea = EA_AY_PD_8();
6879         uint dst = m68ki_read_8(ea);
6880         uint res = dst - src;
6881
6882         FLAG_N = NFLAG_8(res);
6883         FLAG_Z = MASK_OUT_ABOVE_8(res);
6884         FLAG_X = FLAG_C = CFLAG_8(res);
6885         FLAG_V = VFLAG_SUB_8(src, dst, res);
6886
6887         m68ki_write_8(ea, FLAG_Z);
6888 }
6889
6890
6891 void m68k_op_subq_8_pd7(void)
6892 {
6893         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
6894         uint ea = EA_A7_PD_8();
6895         uint dst = m68ki_read_8(ea);
6896         uint res = dst - src;
6897
6898         FLAG_N = NFLAG_8(res);
6899         FLAG_Z = MASK_OUT_ABOVE_8(res);
6900         FLAG_X = FLAG_C = CFLAG_8(res);
6901         FLAG_V = VFLAG_SUB_8(src, dst, res);
6902
6903         m68ki_write_8(ea, FLAG_Z);
6904 }
6905
6906
6907 void m68k_op_subq_8_di(void)
6908 {
6909         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
6910         uint ea = EA_AY_DI_8();
6911         uint dst = m68ki_read_8(ea);
6912         uint res = dst - src;
6913
6914         FLAG_N = NFLAG_8(res);
6915         FLAG_Z = MASK_OUT_ABOVE_8(res);
6916         FLAG_X = FLAG_C = CFLAG_8(res);
6917         FLAG_V = VFLAG_SUB_8(src, dst, res);
6918
6919         m68ki_write_8(ea, FLAG_Z);
6920 }
6921
6922
6923 void m68k_op_subq_8_ix(void)
6924 {
6925         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
6926         uint ea = EA_AY_IX_8();
6927         uint dst = m68ki_read_8(ea);
6928         uint res = dst - src;
6929
6930         FLAG_N = NFLAG_8(res);
6931         FLAG_Z = MASK_OUT_ABOVE_8(res);
6932         FLAG_X = FLAG_C = CFLAG_8(res);
6933         FLAG_V = VFLAG_SUB_8(src, dst, res);
6934
6935         m68ki_write_8(ea, FLAG_Z);
6936 }
6937
6938
6939 void m68k_op_subq_8_aw(void)
6940 {
6941         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
6942         uint ea = EA_AW_8();
6943         uint dst = m68ki_read_8(ea);
6944         uint res = dst - src;
6945
6946         FLAG_N = NFLAG_8(res);
6947         FLAG_Z = MASK_OUT_ABOVE_8(res);
6948         FLAG_X = FLAG_C = CFLAG_8(res);
6949         FLAG_V = VFLAG_SUB_8(src, dst, res);
6950
6951         m68ki_write_8(ea, FLAG_Z);
6952 }
6953
6954
6955 void m68k_op_subq_8_al(void)
6956 {
6957         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
6958         uint ea = EA_AL_8();
6959         uint dst = m68ki_read_8(ea);
6960         uint res = dst - src;
6961
6962         FLAG_N = NFLAG_8(res);
6963         FLAG_Z = MASK_OUT_ABOVE_8(res);
6964         FLAG_X = FLAG_C = CFLAG_8(res);
6965         FLAG_V = VFLAG_SUB_8(src, dst, res);
6966
6967         m68ki_write_8(ea, FLAG_Z);
6968 }
6969
6970
6971 void m68k_op_subq_16_d(void)
6972 {
6973         uint* r_dst = &DY;
6974         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
6975         uint dst = MASK_OUT_ABOVE_16(*r_dst);
6976         uint res = dst - src;
6977
6978         FLAG_N = NFLAG_16(res);
6979         FLAG_Z = MASK_OUT_ABOVE_16(res);
6980         FLAG_X = FLAG_C = CFLAG_16(res);
6981         FLAG_V = VFLAG_SUB_16(src, dst, res);
6982
6983         *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
6984 }
6985
6986
6987 void m68k_op_subq_16_a(void)
6988 {
6989         uint* r_dst = &AY;
6990
6991         *r_dst = MASK_OUT_ABOVE_32(*r_dst - ((((REG_IR >> 9) - 1) & 7) + 1));
6992 }
6993
6994
6995 void m68k_op_subq_16_ai(void)
6996 {
6997         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
6998         uint ea = EA_AY_AI_16();
6999         uint dst = m68ki_read_16(ea);
7000         uint res = dst - src;
7001
7002         FLAG_N = NFLAG_16(res);
7003         FLAG_Z = MASK_OUT_ABOVE_16(res);
7004         FLAG_X = FLAG_C = CFLAG_16(res);
7005         FLAG_V = VFLAG_SUB_16(src, dst, res);
7006
7007         m68ki_write_16(ea, FLAG_Z);
7008 }
7009
7010
7011 void m68k_op_subq_16_pi(void)
7012 {
7013         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
7014         uint ea = EA_AY_PI_16();
7015         uint dst = m68ki_read_16(ea);
7016         uint res = dst - src;
7017
7018         FLAG_N = NFLAG_16(res);
7019         FLAG_Z = MASK_OUT_ABOVE_16(res);
7020         FLAG_X = FLAG_C = CFLAG_16(res);
7021         FLAG_V = VFLAG_SUB_16(src, dst, res);
7022
7023         m68ki_write_16(ea, FLAG_Z);
7024 }
7025
7026
7027 void m68k_op_subq_16_pd(void)
7028 {
7029         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
7030         uint ea = EA_AY_PD_16();
7031         uint dst = m68ki_read_16(ea);
7032         uint res = dst - src;
7033
7034         FLAG_N = NFLAG_16(res);
7035         FLAG_Z = MASK_OUT_ABOVE_16(res);
7036         FLAG_X = FLAG_C = CFLAG_16(res);
7037         FLAG_V = VFLAG_SUB_16(src, dst, res);
7038
7039         m68ki_write_16(ea, FLAG_Z);
7040 }
7041
7042
7043 void m68k_op_subq_16_di(void)
7044 {
7045         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
7046         uint ea = EA_AY_DI_16();
7047         uint dst = m68ki_read_16(ea);
7048         uint res = dst - src;
7049
7050         FLAG_N = NFLAG_16(res);
7051         FLAG_Z = MASK_OUT_ABOVE_16(res);
7052         FLAG_X = FLAG_C = CFLAG_16(res);
7053         FLAG_V = VFLAG_SUB_16(src, dst, res);
7054
7055         m68ki_write_16(ea, FLAG_Z);
7056 }
7057
7058
7059 void m68k_op_subq_16_ix(void)
7060 {
7061         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
7062         uint ea = EA_AY_IX_16();
7063         uint dst = m68ki_read_16(ea);
7064         uint res = dst - src;
7065
7066         FLAG_N = NFLAG_16(res);
7067         FLAG_Z = MASK_OUT_ABOVE_16(res);
7068         FLAG_X = FLAG_C = CFLAG_16(res);
7069         FLAG_V = VFLAG_SUB_16(src, dst, res);
7070
7071         m68ki_write_16(ea, FLAG_Z);
7072 }
7073
7074
7075 void m68k_op_subq_16_aw(void)
7076 {
7077         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
7078         uint ea = EA_AW_16();
7079         uint dst = m68ki_read_16(ea);
7080         uint res = dst - src;
7081
7082         FLAG_N = NFLAG_16(res);
7083         FLAG_Z = MASK_OUT_ABOVE_16(res);
7084         FLAG_X = FLAG_C = CFLAG_16(res);
7085         FLAG_V = VFLAG_SUB_16(src, dst, res);
7086
7087         m68ki_write_16(ea, FLAG_Z);
7088 }
7089
7090
7091 void m68k_op_subq_16_al(void)
7092 {
7093         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
7094         uint ea = EA_AL_16();
7095         uint dst = m68ki_read_16(ea);
7096         uint res = dst - src;
7097
7098         FLAG_N = NFLAG_16(res);
7099         FLAG_Z = MASK_OUT_ABOVE_16(res);
7100         FLAG_X = FLAG_C = CFLAG_16(res);
7101         FLAG_V = VFLAG_SUB_16(src, dst, res);
7102
7103         m68ki_write_16(ea, FLAG_Z);
7104 }
7105
7106
7107 void m68k_op_subq_32_d(void)
7108 {
7109         uint* r_dst = &DY;
7110         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
7111         uint dst = *r_dst;
7112         uint res = dst - src;
7113
7114         FLAG_N = NFLAG_32(res);
7115         FLAG_Z = MASK_OUT_ABOVE_32(res);
7116         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
7117         FLAG_V = VFLAG_SUB_32(src, dst, res);
7118
7119         *r_dst = FLAG_Z;
7120 }
7121
7122
7123 void m68k_op_subq_32_a(void)
7124 {
7125         uint* r_dst = &AY;
7126
7127         *r_dst = MASK_OUT_ABOVE_32(*r_dst - ((((REG_IR >> 9) - 1) & 7) + 1));
7128 }
7129
7130
7131 void m68k_op_subq_32_ai(void)
7132 {
7133         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
7134         uint ea = EA_AY_AI_32();
7135         uint dst = m68ki_read_32(ea);
7136         uint res = dst - src;
7137
7138         FLAG_N = NFLAG_32(res);
7139         FLAG_Z = MASK_OUT_ABOVE_32(res);
7140         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
7141         FLAG_V = VFLAG_SUB_32(src, dst, res);
7142
7143         m68ki_write_32(ea, FLAG_Z);
7144 }
7145
7146
7147 void m68k_op_subq_32_pi(void)
7148 {
7149         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
7150         uint ea = EA_AY_PI_32();
7151         uint dst = m68ki_read_32(ea);
7152         uint res = dst - src;
7153
7154         FLAG_N = NFLAG_32(res);
7155         FLAG_Z = MASK_OUT_ABOVE_32(res);
7156         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
7157         FLAG_V = VFLAG_SUB_32(src, dst, res);
7158
7159         m68ki_write_32(ea, FLAG_Z);
7160 }
7161
7162
7163 void m68k_op_subq_32_pd(void)
7164 {
7165         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
7166         uint ea = EA_AY_PD_32();
7167         uint dst = m68ki_read_32(ea);
7168         uint res = dst - src;
7169
7170         FLAG_N = NFLAG_32(res);
7171         FLAG_Z = MASK_OUT_ABOVE_32(res);
7172         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
7173         FLAG_V = VFLAG_SUB_32(src, dst, res);
7174
7175         m68ki_write_32(ea, FLAG_Z);
7176 }
7177
7178
7179 void m68k_op_subq_32_di(void)
7180 {
7181         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
7182         uint ea = EA_AY_DI_32();
7183         uint dst = m68ki_read_32(ea);
7184         uint res = dst - src;
7185
7186         FLAG_N = NFLAG_32(res);
7187         FLAG_Z = MASK_OUT_ABOVE_32(res);
7188         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
7189         FLAG_V = VFLAG_SUB_32(src, dst, res);
7190
7191         m68ki_write_32(ea, FLAG_Z);
7192 }
7193
7194
7195 void m68k_op_subq_32_ix(void)
7196 {
7197         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
7198         uint ea = EA_AY_IX_32();
7199         uint dst = m68ki_read_32(ea);
7200         uint res = dst - src;
7201
7202         FLAG_N = NFLAG_32(res);
7203         FLAG_Z = MASK_OUT_ABOVE_32(res);
7204         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
7205         FLAG_V = VFLAG_SUB_32(src, dst, res);
7206
7207         m68ki_write_32(ea, FLAG_Z);
7208 }
7209
7210
7211 void m68k_op_subq_32_aw(void)
7212 {
7213         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
7214         uint ea = EA_AW_32();
7215         uint dst = m68ki_read_32(ea);
7216         uint res = dst - src;
7217
7218         FLAG_N = NFLAG_32(res);
7219         FLAG_Z = MASK_OUT_ABOVE_32(res);
7220         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
7221         FLAG_V = VFLAG_SUB_32(src, dst, res);
7222
7223         m68ki_write_32(ea, FLAG_Z);
7224 }
7225
7226
7227 void m68k_op_subq_32_al(void)
7228 {
7229         uint src = (((REG_IR >> 9) - 1) & 7) + 1;
7230         uint ea = EA_AL_32();
7231         uint dst = m68ki_read_32(ea);
7232         uint res = dst - src;
7233
7234         FLAG_N = NFLAG_32(res);
7235         FLAG_Z = MASK_OUT_ABOVE_32(res);
7236         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
7237         FLAG_V = VFLAG_SUB_32(src, dst, res);
7238
7239         m68ki_write_32(ea, FLAG_Z);
7240 }
7241
7242
7243 void m68k_op_subx_8_rr(void)
7244 {
7245         uint* r_dst = &DX;
7246         uint src = MASK_OUT_ABOVE_8(DY);
7247         uint dst = MASK_OUT_ABOVE_8(*r_dst);
7248         uint res = dst - src - XFLAG_AS_1();
7249
7250         FLAG_N = NFLAG_8(res);
7251         FLAG_X = FLAG_C = CFLAG_8(res);
7252         FLAG_V = VFLAG_SUB_8(src, dst, res);
7253
7254         res = MASK_OUT_ABOVE_8(res);
7255         FLAG_Z |= res;
7256
7257         *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
7258 }
7259
7260
7261 void m68k_op_subx_16_rr(void)
7262 {
7263         uint* r_dst = &DX;
7264         uint src = MASK_OUT_ABOVE_16(DY);
7265         uint dst = MASK_OUT_ABOVE_16(*r_dst);
7266         uint res = dst - src - XFLAG_AS_1();
7267
7268         FLAG_N = NFLAG_16(res);
7269         FLAG_X = FLAG_C = CFLAG_16(res);
7270         FLAG_V = VFLAG_SUB_16(src, dst, res);
7271
7272         res = MASK_OUT_ABOVE_16(res);
7273         FLAG_Z |= res;
7274
7275         *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
7276 }
7277
7278
7279 void m68k_op_subx_32_rr(void)
7280 {
7281         uint* r_dst = &DX;
7282         uint src = DY;
7283         uint dst = *r_dst;
7284         uint res = dst - src - XFLAG_AS_1();
7285
7286         FLAG_N = NFLAG_32(res);
7287         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
7288         FLAG_V = VFLAG_SUB_32(src, dst, res);
7289
7290         res = MASK_OUT_ABOVE_32(res);
7291         FLAG_Z |= res;
7292
7293         *r_dst = res;
7294 }
7295
7296
7297 void m68k_op_subx_8_mm_ax7(void)
7298 {
7299         uint src = OPER_AY_PD_8();
7300         uint ea  = EA_A7_PD_8();
7301         uint dst = m68ki_read_8(ea);
7302         uint res = dst - src - XFLAG_AS_1();
7303
7304         FLAG_N = NFLAG_8(res);
7305         FLAG_X = FLAG_C = CFLAG_8(res);
7306         FLAG_V = VFLAG_SUB_8(src, dst, res);
7307
7308         res = MASK_OUT_ABOVE_8(res);
7309         FLAG_Z |= res;
7310
7311         m68ki_write_8(ea, res);
7312 }
7313
7314
7315 void m68k_op_subx_8_mm_ay7(void)
7316 {
7317         uint src = OPER_A7_PD_8();
7318         uint ea  = EA_AX_PD_8();
7319         uint dst = m68ki_read_8(ea);
7320         uint res = dst - src - XFLAG_AS_1();
7321
7322         FLAG_N = NFLAG_8(res);
7323         FLAG_X = FLAG_C = CFLAG_8(res);
7324         FLAG_V = VFLAG_SUB_8(src, dst, res);
7325
7326         res = MASK_OUT_ABOVE_8(res);
7327         FLAG_Z |= res;
7328
7329         m68ki_write_8(ea, res);
7330 }
7331
7332
7333 void m68k_op_subx_8_mm_axy7(void)
7334 {
7335         uint src = OPER_A7_PD_8();
7336         uint ea  = EA_A7_PD_8();
7337         uint dst = m68ki_read_8(ea);
7338         uint res = dst - src - XFLAG_AS_1();
7339
7340         FLAG_N = NFLAG_8(res);
7341         FLAG_X = FLAG_C = CFLAG_8(res);
7342         FLAG_V = VFLAG_SUB_8(src, dst, res);
7343
7344         res = MASK_OUT_ABOVE_8(res);
7345         FLAG_Z |= res;
7346
7347         m68ki_write_8(ea, res);
7348 }
7349
7350
7351 void m68k_op_subx_8_mm(void)
7352 {
7353         uint src = OPER_AY_PD_8();
7354         uint ea  = EA_AX_PD_8();
7355         uint dst = m68ki_read_8(ea);
7356         uint res = dst - src - XFLAG_AS_1();
7357
7358         FLAG_N = NFLAG_8(res);
7359         FLAG_X = FLAG_C = CFLAG_8(res);
7360         FLAG_V = VFLAG_SUB_8(src, dst, res);
7361
7362         res = MASK_OUT_ABOVE_8(res);
7363         FLAG_Z |= res;
7364
7365         m68ki_write_8(ea, res);
7366 }
7367
7368
7369 void m68k_op_subx_16_mm(void)
7370 {
7371         uint src = OPER_AY_PD_16();
7372         uint ea  = EA_AX_PD_16();
7373         uint dst = m68ki_read_16(ea);
7374         uint res = dst - src - XFLAG_AS_1();
7375
7376         FLAG_N = NFLAG_16(res);
7377         FLAG_X = FLAG_C = CFLAG_16(res);
7378         FLAG_V = VFLAG_SUB_16(src, dst, res);
7379
7380         res = MASK_OUT_ABOVE_16(res);
7381         FLAG_Z |= res;
7382
7383         m68ki_write_16(ea, res);
7384 }
7385
7386
7387 void m68k_op_subx_32_mm(void)
7388 {
7389         uint src = OPER_AY_PD_32();
7390         uint ea  = EA_AX_PD_32();
7391         uint dst = m68ki_read_32(ea);
7392         uint res = dst - src - XFLAG_AS_1();
7393
7394         FLAG_N = NFLAG_32(res);
7395         FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
7396         FLAG_V = VFLAG_SUB_32(src, dst, res);
7397
7398         res = MASK_OUT_ABOVE_32(res);
7399         FLAG_Z |= res;
7400
7401         m68ki_write_32(ea, res);
7402 }
7403
7404
7405 void m68k_op_swap_32(void)
7406 {
7407         uint* r_dst = &DY;
7408
7409         FLAG_Z = MASK_OUT_ABOVE_32(*r_dst<<16);
7410         *r_dst = (*r_dst>>16) | FLAG_Z;
7411
7412         FLAG_Z = *r_dst;
7413         FLAG_N = NFLAG_32(*r_dst);
7414         FLAG_C = CFLAG_CLEAR;
7415         FLAG_V = VFLAG_CLEAR;
7416 }
7417
7418
7419 void m68k_op_tas_8_d(void)
7420 {
7421         uint* r_dst = &DY;
7422
7423         FLAG_Z = MASK_OUT_ABOVE_8(*r_dst);
7424         FLAG_N = NFLAG_8(*r_dst);
7425         FLAG_V = VFLAG_CLEAR;
7426         FLAG_C = CFLAG_CLEAR;
7427         *r_dst |= 0x80;
7428 }
7429
7430
7431 void m68k_op_tas_8_ai(void)
7432 {
7433         uint ea = EA_AY_AI_8();
7434         uint dst = m68ki_read_8(ea);
7435
7436         FLAG_Z = dst;
7437         FLAG_N = NFLAG_8(dst);
7438         FLAG_V = VFLAG_CLEAR;
7439         FLAG_C = CFLAG_CLEAR;
7440         m68ki_write_8(ea, dst | 0x80);
7441 }
7442
7443
7444 void m68k_op_tas_8_pi(void)
7445 {
7446         uint ea = EA_AY_PI_8();
7447         uint dst = m68ki_read_8(ea);
7448
7449         FLAG_Z = dst;
7450         FLAG_N = NFLAG_8(dst);
7451         FLAG_V = VFLAG_CLEAR;
7452         FLAG_C = CFLAG_CLEAR;
7453         m68ki_write_8(ea, dst | 0x80);
7454 }
7455
7456
7457 void m68k_op_tas_8_pi7(void)
7458 {
7459         uint ea = EA_A7_PI_8();
7460         uint dst = m68ki_read_8(ea);
7461
7462         FLAG_Z = dst;
7463         FLAG_N = NFLAG_8(dst);
7464         FLAG_V = VFLAG_CLEAR;
7465         FLAG_C = CFLAG_CLEAR;
7466         m68ki_write_8(ea, dst | 0x80);
7467 }
7468
7469
7470 void m68k_op_tas_8_pd(void)
7471 {
7472         uint ea = EA_AY_PD_8();
7473         uint dst = m68ki_read_8(ea);
7474
7475         FLAG_Z = dst;
7476         FLAG_N = NFLAG_8(dst);
7477         FLAG_V = VFLAG_CLEAR;
7478         FLAG_C = CFLAG_CLEAR;
7479         m68ki_write_8(ea, dst | 0x80);
7480 }
7481
7482
7483 void m68k_op_tas_8_pd7(void)
7484 {
7485         uint ea = EA_A7_PD_8();
7486         uint dst = m68ki_read_8(ea);
7487
7488         FLAG_Z = dst;
7489         FLAG_N = NFLAG_8(dst);
7490         FLAG_V = VFLAG_CLEAR;
7491         FLAG_C = CFLAG_CLEAR;
7492         m68ki_write_8(ea, dst | 0x80);
7493 }
7494
7495
7496 void m68k_op_tas_8_di(void)
7497 {
7498         uint ea = EA_AY_DI_8();
7499         uint dst = m68ki_read_8(ea);
7500
7501         FLAG_Z = dst;
7502         FLAG_N = NFLAG_8(dst);
7503         FLAG_V = VFLAG_CLEAR;
7504         FLAG_C = CFLAG_CLEAR;
7505         m68ki_write_8(ea, dst | 0x80);
7506 }
7507
7508
7509 void m68k_op_tas_8_ix(void)
7510 {
7511         uint ea = EA_AY_IX_8();
7512         uint dst = m68ki_read_8(ea);
7513
7514         FLAG_Z = dst;
7515         FLAG_N = NFLAG_8(dst);
7516         FLAG_V = VFLAG_CLEAR;
7517         FLAG_C = CFLAG_CLEAR;
7518         m68ki_write_8(ea, dst | 0x80);
7519 }
7520
7521
7522 void m68k_op_tas_8_aw(void)
7523 {
7524         uint ea = EA_AW_8();
7525         uint dst = m68ki_read_8(ea);
7526
7527         FLAG_Z = dst;
7528         FLAG_N = NFLAG_8(dst);
7529         FLAG_V = VFLAG_CLEAR;
7530         FLAG_C = CFLAG_CLEAR;
7531         m68ki_write_8(ea, dst | 0x80);
7532 }
7533
7534
7535 void m68k_op_tas_8_al(void)
7536 {
7537         uint ea = EA_AL_8();
7538         uint dst = m68ki_read_8(ea);
7539
7540         FLAG_Z = dst;
7541         FLAG_N = NFLAG_8(dst);
7542         FLAG_V = VFLAG_CLEAR;
7543         FLAG_C = CFLAG_CLEAR;
7544         m68ki_write_8(ea, dst | 0x80);
7545 }
7546
7547
7548 void m68k_op_trap(void)
7549 {
7550         /* Trap#n stacks exception frame type 0 */
7551         m68ki_exception_trapN(EXCEPTION_TRAP_BASE + (REG_IR & 0xf));    /* HJB 990403 */
7552 }
7553
7554
7555 void m68k_op_trapt(void)
7556 {
7557         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7558         {
7559                 m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7560                 return;
7561         }
7562         m68ki_exception_illegal();
7563 }
7564
7565
7566 void m68k_op_trapt_16(void)
7567 {
7568         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7569         {
7570                 m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7571                 return;
7572         }
7573         m68ki_exception_illegal();
7574 }
7575
7576
7577 void m68k_op_trapt_32(void)
7578 {
7579         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7580         {
7581                 m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7582                 return;
7583         }
7584         m68ki_exception_illegal();
7585 }
7586
7587
7588 void m68k_op_trapf(void)
7589 {
7590         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7591         {
7592                 return;
7593         }
7594         m68ki_exception_illegal();
7595 }
7596
7597
7598 void m68k_op_trapf_16(void)
7599 {
7600         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7601         {
7602                 REG_PC += 2;
7603                 return;
7604         }
7605         m68ki_exception_illegal();
7606 }
7607
7608
7609 void m68k_op_trapf_32(void)
7610 {
7611         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7612         {
7613                 REG_PC += 4;
7614                 return;
7615         }
7616         m68ki_exception_illegal();
7617 }
7618
7619
7620 void m68k_op_traphi(void)
7621 {
7622         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7623         {
7624                 if(COND_HI())
7625                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7626                 return;
7627         }
7628         m68ki_exception_illegal();
7629 }
7630
7631
7632 void m68k_op_trapls(void)
7633 {
7634         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7635         {
7636                 if(COND_LS())
7637                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7638                 return;
7639         }
7640         m68ki_exception_illegal();
7641 }
7642
7643
7644 void m68k_op_trapcc(void)
7645 {
7646         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7647         {
7648                 if(COND_CC())
7649                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7650                 return;
7651         }
7652         m68ki_exception_illegal();
7653 }
7654
7655
7656 void m68k_op_trapcs(void)
7657 {
7658         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7659         {
7660                 if(COND_CS())
7661                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7662                 return;
7663         }
7664         m68ki_exception_illegal();
7665 }
7666
7667
7668 void m68k_op_trapne(void)
7669 {
7670         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7671         {
7672                 if(COND_NE())
7673                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7674                 return;
7675         }
7676         m68ki_exception_illegal();
7677 }
7678
7679
7680 void m68k_op_trapeq(void)
7681 {
7682         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7683         {
7684                 if(COND_EQ())
7685                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7686                 return;
7687         }
7688         m68ki_exception_illegal();
7689 }
7690
7691
7692 void m68k_op_trapvc(void)
7693 {
7694         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7695         {
7696                 if(COND_VC())
7697                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7698                 return;
7699         }
7700         m68ki_exception_illegal();
7701 }
7702
7703
7704 void m68k_op_trapvs(void)
7705 {
7706         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7707         {
7708                 if(COND_VS())
7709                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7710                 return;
7711         }
7712         m68ki_exception_illegal();
7713 }
7714
7715
7716 void m68k_op_trappl(void)
7717 {
7718         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7719         {
7720                 if(COND_PL())
7721                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7722                 return;
7723         }
7724         m68ki_exception_illegal();
7725 }
7726
7727
7728 void m68k_op_trapmi(void)
7729 {
7730         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7731         {
7732                 if(COND_MI())
7733                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7734                 return;
7735         }
7736         m68ki_exception_illegal();
7737 }
7738
7739
7740 void m68k_op_trapge(void)
7741 {
7742         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7743         {
7744                 if(COND_GE())
7745                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7746                 return;
7747         }
7748         m68ki_exception_illegal();
7749 }
7750
7751
7752 void m68k_op_traplt(void)
7753 {
7754         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7755         {
7756                 if(COND_LT())
7757                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7758                 return;
7759         }
7760         m68ki_exception_illegal();
7761 }
7762
7763
7764 void m68k_op_trapgt(void)
7765 {
7766         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7767         {
7768                 if(COND_GT())
7769                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7770                 return;
7771         }
7772         m68ki_exception_illegal();
7773 }
7774
7775
7776 void m68k_op_traple(void)
7777 {
7778         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7779         {
7780                 if(COND_LE())
7781                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7782                 return;
7783         }
7784         m68ki_exception_illegal();
7785 }
7786
7787
7788 void m68k_op_traphi_16(void)
7789 {
7790         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7791         {
7792                 if(COND_HI())
7793                 {
7794                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7795                         return;
7796                 }
7797                 REG_PC += 2;
7798                 return;
7799         }
7800         m68ki_exception_illegal();
7801 }
7802
7803
7804 void m68k_op_trapls_16(void)
7805 {
7806         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7807         {
7808                 if(COND_LS())
7809                 {
7810                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7811                         return;
7812                 }
7813                 REG_PC += 2;
7814                 return;
7815         }
7816         m68ki_exception_illegal();
7817 }
7818
7819
7820 void m68k_op_trapcc_16(void)
7821 {
7822         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7823         {
7824                 if(COND_CC())
7825                 {
7826                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7827                         return;
7828                 }
7829                 REG_PC += 2;
7830                 return;
7831         }
7832         m68ki_exception_illegal();
7833 }
7834
7835
7836 void m68k_op_trapcs_16(void)
7837 {
7838         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7839         {
7840                 if(COND_CS())
7841                 {
7842                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7843                         return;
7844                 }
7845                 REG_PC += 2;
7846                 return;
7847         }
7848         m68ki_exception_illegal();
7849 }
7850
7851
7852 void m68k_op_trapne_16(void)
7853 {
7854         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7855         {
7856                 if(COND_NE())
7857                 {
7858                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7859                         return;
7860                 }
7861                 REG_PC += 2;
7862                 return;
7863         }
7864         m68ki_exception_illegal();
7865 }
7866
7867
7868 void m68k_op_trapeq_16(void)
7869 {
7870         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7871         {
7872                 if(COND_EQ())
7873                 {
7874                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7875                         return;
7876                 }
7877                 REG_PC += 2;
7878                 return;
7879         }
7880         m68ki_exception_illegal();
7881 }
7882
7883
7884 void m68k_op_trapvc_16(void)
7885 {
7886         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7887         {
7888                 if(COND_VC())
7889                 {
7890                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7891                         return;
7892                 }
7893                 REG_PC += 2;
7894                 return;
7895         }
7896         m68ki_exception_illegal();
7897 }
7898
7899
7900 void m68k_op_trapvs_16(void)
7901 {
7902         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7903         {
7904                 if(COND_VS())
7905                 {
7906                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7907                         return;
7908                 }
7909                 REG_PC += 2;
7910                 return;
7911         }
7912         m68ki_exception_illegal();
7913 }
7914
7915
7916 void m68k_op_trappl_16(void)
7917 {
7918         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7919         {
7920                 if(COND_PL())
7921                 {
7922                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7923                         return;
7924                 }
7925                 REG_PC += 2;
7926                 return;
7927         }
7928         m68ki_exception_illegal();
7929 }
7930
7931
7932 void m68k_op_trapmi_16(void)
7933 {
7934         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7935         {
7936                 if(COND_MI())
7937                 {
7938                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7939                         return;
7940                 }
7941                 REG_PC += 2;
7942                 return;
7943         }
7944         m68ki_exception_illegal();
7945 }
7946
7947
7948 void m68k_op_trapge_16(void)
7949 {
7950         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7951         {
7952                 if(COND_GE())
7953                 {
7954                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7955                         return;
7956                 }
7957                 REG_PC += 2;
7958                 return;
7959         }
7960         m68ki_exception_illegal();
7961 }
7962
7963
7964 void m68k_op_traplt_16(void)
7965 {
7966         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7967         {
7968                 if(COND_LT())
7969                 {
7970                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7971                         return;
7972                 }
7973                 REG_PC += 2;
7974                 return;
7975         }
7976         m68ki_exception_illegal();
7977 }
7978
7979
7980 void m68k_op_trapgt_16(void)
7981 {
7982         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7983         {
7984                 if(COND_GT())
7985                 {
7986                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
7987                         return;
7988                 }
7989                 REG_PC += 2;
7990                 return;
7991         }
7992         m68ki_exception_illegal();
7993 }
7994
7995
7996 void m68k_op_traple_16(void)
7997 {
7998         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7999         {
8000                 if(COND_LE())
8001                 {
8002                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
8003                         return;
8004                 }
8005                 REG_PC += 2;
8006                 return;
8007         }
8008         m68ki_exception_illegal();
8009 }
8010
8011
8012 void m68k_op_traphi_32(void)
8013 {
8014         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8015         {
8016                 if(COND_HI())
8017                 {
8018                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
8019                         return;
8020                 }
8021                 REG_PC += 4;
8022                 return;
8023         }
8024         m68ki_exception_illegal();
8025 }
8026
8027
8028 void m68k_op_trapls_32(void)
8029 {
8030         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8031         {
8032                 if(COND_LS())
8033                 {
8034                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
8035                         return;
8036                 }
8037                 REG_PC += 4;
8038                 return;
8039         }
8040         m68ki_exception_illegal();
8041 }
8042
8043
8044 void m68k_op_trapcc_32(void)
8045 {
8046         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8047         {
8048                 if(COND_CC())
8049                 {
8050                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
8051                         return;
8052                 }
8053                 REG_PC += 4;
8054                 return;
8055         }
8056         m68ki_exception_illegal();
8057 }
8058
8059
8060 void m68k_op_trapcs_32(void)
8061 {
8062         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8063         {
8064                 if(COND_CS())
8065                 {
8066                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
8067                         return;
8068                 }
8069                 REG_PC += 4;
8070                 return;
8071         }
8072         m68ki_exception_illegal();
8073 }
8074
8075
8076 void m68k_op_trapne_32(void)
8077 {
8078         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8079         {
8080                 if(COND_NE())
8081                 {
8082                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
8083                         return;
8084                 }
8085                 REG_PC += 4;
8086                 return;
8087         }
8088         m68ki_exception_illegal();
8089 }
8090
8091
8092 void m68k_op_trapeq_32(void)
8093 {
8094         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8095         {
8096                 if(COND_EQ())
8097                 {
8098                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
8099                         return;
8100                 }
8101                 REG_PC += 4;
8102                 return;
8103         }
8104         m68ki_exception_illegal();
8105 }
8106
8107
8108 void m68k_op_trapvc_32(void)
8109 {
8110         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8111         {
8112                 if(COND_VC())
8113                 {
8114                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
8115                         return;
8116                 }
8117                 REG_PC += 4;
8118                 return;
8119         }
8120         m68ki_exception_illegal();
8121 }
8122
8123
8124 void m68k_op_trapvs_32(void)
8125 {
8126         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8127         {
8128                 if(COND_VS())
8129                 {
8130                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
8131                         return;
8132                 }
8133                 REG_PC += 4;
8134                 return;
8135         }
8136         m68ki_exception_illegal();
8137 }
8138
8139
8140 void m68k_op_trappl_32(void)
8141 {
8142         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8143         {
8144                 if(COND_PL())
8145                 {
8146                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
8147                         return;
8148                 }
8149                 REG_PC += 4;
8150                 return;
8151         }
8152         m68ki_exception_illegal();
8153 }
8154
8155
8156 void m68k_op_trapmi_32(void)
8157 {
8158         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8159         {
8160                 if(COND_MI())
8161                 {
8162                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
8163                         return;
8164                 }
8165                 REG_PC += 4;
8166                 return;
8167         }
8168         m68ki_exception_illegal();
8169 }
8170
8171
8172 void m68k_op_trapge_32(void)
8173 {
8174         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8175         {
8176                 if(COND_GE())
8177                 {
8178                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
8179                         return;
8180                 }
8181                 REG_PC += 4;
8182                 return;
8183         }
8184         m68ki_exception_illegal();
8185 }
8186
8187
8188 void m68k_op_traplt_32(void)
8189 {
8190         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8191         {
8192                 if(COND_LT())
8193                 {
8194                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
8195                         return;
8196                 }
8197                 REG_PC += 4;
8198                 return;
8199         }
8200         m68ki_exception_illegal();
8201 }
8202
8203
8204 void m68k_op_trapgt_32(void)
8205 {
8206         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8207         {
8208                 if(COND_GT())
8209                 {
8210                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
8211                         return;
8212                 }
8213                 REG_PC += 4;
8214                 return;
8215         }
8216         m68ki_exception_illegal();
8217 }
8218
8219
8220 void m68k_op_traple_32(void)
8221 {
8222         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8223         {
8224                 if(COND_LE())
8225                 {
8226                         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
8227                         return;
8228                 }
8229                 REG_PC += 4;
8230                 return;
8231         }
8232         m68ki_exception_illegal();
8233 }
8234
8235
8236 void m68k_op_trapv(void)
8237 {
8238         if(COND_VC())
8239         {
8240                 return;
8241         }
8242         m68ki_exception_trap(EXCEPTION_TRAPV);  /* HJB 990403 */
8243 }
8244
8245
8246 void m68k_op_tst_8_d(void)
8247 {
8248         uint res = MASK_OUT_ABOVE_8(DY);
8249
8250         FLAG_N = NFLAG_8(res);
8251         FLAG_Z = res;
8252         FLAG_V = VFLAG_CLEAR;
8253         FLAG_C = CFLAG_CLEAR;
8254 }
8255
8256
8257 void m68k_op_tst_8_ai(void)
8258 {
8259         uint res = OPER_AY_AI_8();
8260
8261         FLAG_N = NFLAG_8(res);
8262         FLAG_Z = res;
8263         FLAG_V = VFLAG_CLEAR;
8264         FLAG_C = CFLAG_CLEAR;
8265 }
8266
8267
8268 void m68k_op_tst_8_pi(void)
8269 {
8270         uint res = OPER_AY_PI_8();
8271
8272         FLAG_N = NFLAG_8(res);
8273         FLAG_Z = res;
8274         FLAG_V = VFLAG_CLEAR;
8275         FLAG_C = CFLAG_CLEAR;
8276 }
8277
8278
8279 void m68k_op_tst_8_pi7(void)
8280 {
8281         uint res = OPER_A7_PI_8();
8282
8283         FLAG_N = NFLAG_8(res);
8284         FLAG_Z = res;
8285         FLAG_V = VFLAG_CLEAR;
8286         FLAG_C = CFLAG_CLEAR;
8287 }
8288
8289
8290 void m68k_op_tst_8_pd(void)
8291 {
8292         uint res = OPER_AY_PD_8();
8293
8294         FLAG_N = NFLAG_8(res);
8295         FLAG_Z = res;
8296         FLAG_V = VFLAG_CLEAR;
8297         FLAG_C = CFLAG_CLEAR;
8298 }
8299
8300
8301 void m68k_op_tst_8_pd7(void)
8302 {
8303         uint res = OPER_A7_PD_8();
8304
8305         FLAG_N = NFLAG_8(res);
8306         FLAG_Z = res;
8307         FLAG_V = VFLAG_CLEAR;
8308         FLAG_C = CFLAG_CLEAR;
8309 }
8310
8311
8312 void m68k_op_tst_8_di(void)
8313 {
8314         uint res = OPER_AY_DI_8();
8315
8316         FLAG_N = NFLAG_8(res);
8317         FLAG_Z = res;
8318         FLAG_V = VFLAG_CLEAR;
8319         FLAG_C = CFLAG_CLEAR;
8320 }
8321
8322
8323 void m68k_op_tst_8_ix(void)
8324 {
8325         uint res = OPER_AY_IX_8();
8326
8327         FLAG_N = NFLAG_8(res);
8328         FLAG_Z = res;
8329         FLAG_V = VFLAG_CLEAR;
8330         FLAG_C = CFLAG_CLEAR;
8331 }
8332
8333
8334 void m68k_op_tst_8_aw(void)
8335 {
8336         uint res = OPER_AW_8();
8337
8338         FLAG_N = NFLAG_8(res);
8339         FLAG_Z = res;
8340         FLAG_V = VFLAG_CLEAR;
8341         FLAG_C = CFLAG_CLEAR;
8342 }
8343
8344
8345 void m68k_op_tst_8_al(void)
8346 {
8347         uint res = OPER_AL_8();
8348
8349         FLAG_N = NFLAG_8(res);
8350         FLAG_Z = res;
8351         FLAG_V = VFLAG_CLEAR;
8352         FLAG_C = CFLAG_CLEAR;
8353 }
8354
8355
8356 void m68k_op_tst_8_pcdi(void)
8357 {
8358         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8359         {
8360                 uint res = OPER_PCDI_8();
8361
8362                 FLAG_N = NFLAG_8(res);
8363                 FLAG_Z = res;
8364                 FLAG_V = VFLAG_CLEAR;
8365                 FLAG_C = CFLAG_CLEAR;
8366                 return;
8367         }
8368         m68ki_exception_illegal();
8369 }
8370
8371
8372 void m68k_op_tst_8_pcix(void)
8373 {
8374         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8375         {
8376                 uint res = OPER_PCIX_8();
8377
8378                 FLAG_N = NFLAG_8(res);
8379                 FLAG_Z = res;
8380                 FLAG_V = VFLAG_CLEAR;
8381                 FLAG_C = CFLAG_CLEAR;
8382                 return;
8383         }
8384         m68ki_exception_illegal();
8385 }
8386
8387
8388 void m68k_op_tst_8_i(void)
8389 {
8390         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8391         {
8392                 uint res = OPER_I_8();
8393
8394                 FLAG_N = NFLAG_8(res);
8395                 FLAG_Z = res;
8396                 FLAG_V = VFLAG_CLEAR;
8397                 FLAG_C = CFLAG_CLEAR;
8398                 return;
8399         }
8400         m68ki_exception_illegal();
8401 }
8402
8403
8404 void m68k_op_tst_16_d(void)
8405 {
8406         uint res = MASK_OUT_ABOVE_16(DY);
8407
8408         FLAG_N = NFLAG_16(res);
8409         FLAG_Z = res;
8410         FLAG_V = VFLAG_CLEAR;
8411         FLAG_C = CFLAG_CLEAR;
8412 }
8413
8414
8415 void m68k_op_tst_16_a(void)
8416 {
8417         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8418         {
8419                 uint res = MAKE_INT_16(AY);
8420
8421                 FLAG_N = NFLAG_16(res);
8422                 FLAG_Z = res;
8423                 FLAG_V = VFLAG_CLEAR;
8424                 FLAG_C = CFLAG_CLEAR;
8425                 return;
8426         }
8427         m68ki_exception_illegal();
8428 }
8429
8430
8431 void m68k_op_tst_16_ai(void)
8432 {
8433         uint res = OPER_AY_AI_16();
8434
8435         FLAG_N = NFLAG_16(res);
8436         FLAG_Z = res;
8437         FLAG_V = VFLAG_CLEAR;
8438         FLAG_C = CFLAG_CLEAR;
8439 }
8440
8441
8442 void m68k_op_tst_16_pi(void)
8443 {
8444         uint res = OPER_AY_PI_16();
8445
8446         FLAG_N = NFLAG_16(res);
8447         FLAG_Z = res;
8448         FLAG_V = VFLAG_CLEAR;
8449         FLAG_C = CFLAG_CLEAR;
8450 }
8451
8452
8453 void m68k_op_tst_16_pd(void)
8454 {
8455         uint res = OPER_AY_PD_16();
8456
8457         FLAG_N = NFLAG_16(res);
8458         FLAG_Z = res;
8459         FLAG_V = VFLAG_CLEAR;
8460         FLAG_C = CFLAG_CLEAR;
8461 }
8462
8463
8464 void m68k_op_tst_16_di(void)
8465 {
8466         uint res = OPER_AY_DI_16();
8467
8468         FLAG_N = NFLAG_16(res);
8469         FLAG_Z = res;
8470         FLAG_V = VFLAG_CLEAR;
8471         FLAG_C = CFLAG_CLEAR;
8472 }
8473
8474
8475 void m68k_op_tst_16_ix(void)
8476 {
8477         uint res = OPER_AY_IX_16();
8478
8479         FLAG_N = NFLAG_16(res);
8480         FLAG_Z = res;
8481         FLAG_V = VFLAG_CLEAR;
8482         FLAG_C = CFLAG_CLEAR;
8483 }
8484
8485
8486 void m68k_op_tst_16_aw(void)
8487 {
8488         uint res = OPER_AW_16();
8489
8490         FLAG_N = NFLAG_16(res);
8491         FLAG_Z = res;
8492         FLAG_V = VFLAG_CLEAR;
8493         FLAG_C = CFLAG_CLEAR;
8494 }
8495
8496
8497 void m68k_op_tst_16_al(void)
8498 {
8499         uint res = OPER_AL_16();
8500
8501         FLAG_N = NFLAG_16(res);
8502         FLAG_Z = res;
8503         FLAG_V = VFLAG_CLEAR;
8504         FLAG_C = CFLAG_CLEAR;
8505 }
8506
8507
8508 void m68k_op_tst_16_pcdi(void)
8509 {
8510         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8511         {
8512                 uint res = OPER_PCDI_16();
8513
8514                 FLAG_N = NFLAG_16(res);
8515                 FLAG_Z = res;
8516                 FLAG_V = VFLAG_CLEAR;
8517                 FLAG_C = CFLAG_CLEAR;
8518                 return;
8519         }
8520         m68ki_exception_illegal();
8521 }
8522
8523
8524 void m68k_op_tst_16_pcix(void)
8525 {
8526         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8527         {
8528                 uint res = OPER_PCIX_16();
8529
8530                 FLAG_N = NFLAG_16(res);
8531                 FLAG_Z = res;
8532                 FLAG_V = VFLAG_CLEAR;
8533                 FLAG_C = CFLAG_CLEAR;
8534                 return;
8535         }
8536         m68ki_exception_illegal();
8537 }
8538
8539
8540 void m68k_op_tst_16_i(void)
8541 {
8542         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8543         {
8544                 uint res = OPER_I_16();
8545
8546                 FLAG_N = NFLAG_16(res);
8547                 FLAG_Z = res;
8548                 FLAG_V = VFLAG_CLEAR;
8549                 FLAG_C = CFLAG_CLEAR;
8550                 return;
8551         }
8552         m68ki_exception_illegal();
8553 }
8554
8555
8556 void m68k_op_tst_32_d(void)
8557 {
8558         uint res = DY;
8559
8560         FLAG_N = NFLAG_32(res);
8561         FLAG_Z = res;
8562         FLAG_V = VFLAG_CLEAR;
8563         FLAG_C = CFLAG_CLEAR;
8564 }
8565
8566
8567 void m68k_op_tst_32_a(void)
8568 {
8569         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8570         {
8571                 uint res = AY;
8572
8573                 FLAG_N = NFLAG_32(res);
8574                 FLAG_Z = res;
8575                 FLAG_V = VFLAG_CLEAR;
8576                 FLAG_C = CFLAG_CLEAR;
8577                 return;
8578         }
8579         m68ki_exception_illegal();
8580 }
8581
8582
8583 void m68k_op_tst_32_ai(void)
8584 {
8585         uint res = OPER_AY_AI_32();
8586
8587         FLAG_N = NFLAG_32(res);
8588         FLAG_Z = res;
8589         FLAG_V = VFLAG_CLEAR;
8590         FLAG_C = CFLAG_CLEAR;
8591 }
8592
8593
8594 void m68k_op_tst_32_pi(void)
8595 {
8596         uint res = OPER_AY_PI_32();
8597
8598         FLAG_N = NFLAG_32(res);
8599         FLAG_Z = res;
8600         FLAG_V = VFLAG_CLEAR;
8601         FLAG_C = CFLAG_CLEAR;
8602 }
8603
8604
8605 void m68k_op_tst_32_pd(void)
8606 {
8607         uint res = OPER_AY_PD_32();
8608
8609         FLAG_N = NFLAG_32(res);
8610         FLAG_Z = res;
8611         FLAG_V = VFLAG_CLEAR;
8612         FLAG_C = CFLAG_CLEAR;
8613 }
8614
8615
8616 void m68k_op_tst_32_di(void)
8617 {
8618         uint res = OPER_AY_DI_32();
8619
8620         FLAG_N = NFLAG_32(res);
8621         FLAG_Z = res;
8622         FLAG_V = VFLAG_CLEAR;
8623         FLAG_C = CFLAG_CLEAR;
8624 }
8625
8626
8627 void m68k_op_tst_32_ix(void)
8628 {
8629         uint res = OPER_AY_IX_32();
8630
8631         FLAG_N = NFLAG_32(res);
8632         FLAG_Z = res;
8633         FLAG_V = VFLAG_CLEAR;
8634         FLAG_C = CFLAG_CLEAR;
8635 }
8636
8637
8638 void m68k_op_tst_32_aw(void)
8639 {
8640         uint res = OPER_AW_32();
8641
8642         FLAG_N = NFLAG_32(res);
8643         FLAG_Z = res;
8644         FLAG_V = VFLAG_CLEAR;
8645         FLAG_C = CFLAG_CLEAR;
8646 }
8647
8648
8649 void m68k_op_tst_32_al(void)
8650 {
8651         uint res = OPER_AL_32();
8652
8653         FLAG_N = NFLAG_32(res);
8654         FLAG_Z = res;
8655         FLAG_V = VFLAG_CLEAR;
8656         FLAG_C = CFLAG_CLEAR;
8657 }
8658
8659
8660 void m68k_op_tst_32_pcdi(void)
8661 {
8662         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8663         {
8664                 uint res = OPER_PCDI_32();
8665
8666                 FLAG_N = NFLAG_32(res);
8667                 FLAG_Z = res;
8668                 FLAG_V = VFLAG_CLEAR;
8669                 FLAG_C = CFLAG_CLEAR;
8670                 return;
8671         }
8672         m68ki_exception_illegal();
8673 }
8674
8675
8676 void m68k_op_tst_32_pcix(void)
8677 {
8678         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8679         {
8680                 uint res = OPER_PCIX_32();
8681
8682                 FLAG_N = NFLAG_32(res);
8683                 FLAG_Z = res;
8684                 FLAG_V = VFLAG_CLEAR;
8685                 FLAG_C = CFLAG_CLEAR;
8686                 return;
8687         }
8688         m68ki_exception_illegal();
8689 }
8690
8691
8692 void m68k_op_tst_32_i(void)
8693 {
8694         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8695         {
8696                 uint res = OPER_I_32();
8697
8698                 FLAG_N = NFLAG_32(res);
8699                 FLAG_Z = res;
8700                 FLAG_V = VFLAG_CLEAR;
8701                 FLAG_C = CFLAG_CLEAR;
8702                 return;
8703         }
8704         m68ki_exception_illegal();
8705 }
8706
8707
8708 void m68k_op_unlk_32_a7(void)
8709 {
8710         REG_A[7] = m68ki_read_32(REG_A[7]);
8711 }
8712
8713
8714 void m68k_op_unlk_32(void)
8715 {
8716         uint* r_dst = &AY;
8717
8718         REG_A[7] = *r_dst;
8719         *r_dst = m68ki_pull_32();
8720 }
8721
8722
8723 void m68k_op_unpk_16_rr(void)
8724 {
8725         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8726         {
8727                 /* Note: DX and DY are reversed in Motorola's docs */
8728                 uint src = DY;
8729                 uint* r_dst = &DX;
8730
8731                 *r_dst = MASK_OUT_BELOW_16(*r_dst) | (((((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16()) & 0xffff);
8732                 return;
8733         }
8734         m68ki_exception_illegal();
8735 }
8736
8737
8738 void m68k_op_unpk_16_mm_ax7(void)
8739 {
8740         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8741         {
8742                 /* Note: AX and AY are reversed in Motorola's docs */
8743                 uint src = OPER_AY_PD_8();
8744                 uint ea_dst;
8745
8746                 src = (((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16();
8747                 ea_dst = EA_A7_PD_8();
8748                 m68ki_write_8(ea_dst, (src >> 8) & 0xff);
8749                 ea_dst = EA_A7_PD_8();
8750                 m68ki_write_8(ea_dst, src & 0xff);
8751                 return;
8752         }
8753         m68ki_exception_illegal();
8754 }
8755
8756
8757 void m68k_op_unpk_16_mm_ay7(void)
8758 {
8759         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8760         {
8761                 /* Note: AX and AY are reversed in Motorola's docs */
8762                 uint src = OPER_A7_PD_8();
8763                 uint ea_dst;
8764
8765                 src = (((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16();
8766                 ea_dst = EA_AX_PD_8();
8767                 m68ki_write_8(ea_dst, (src >> 8) & 0xff);
8768                 ea_dst = EA_AX_PD_8();
8769                 m68ki_write_8(ea_dst, src & 0xff);
8770                 return;
8771         }
8772         m68ki_exception_illegal();
8773 }
8774
8775
8776 void m68k_op_unpk_16_mm_axy7(void)
8777 {
8778         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8779         {
8780                 uint src = OPER_A7_PD_8();
8781                 uint ea_dst;
8782
8783                 src = (((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16();
8784                 ea_dst = EA_A7_PD_8();
8785                 m68ki_write_8(ea_dst, (src >> 8) & 0xff);
8786                 ea_dst = EA_A7_PD_8();
8787                 m68ki_write_8(ea_dst, src & 0xff);
8788                 return;
8789         }
8790         m68ki_exception_illegal();
8791 }
8792
8793
8794 void m68k_op_unpk_16_mm(void)
8795 {
8796         if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8797         {
8798                 /* Note: AX and AY are reversed in Motorola's docs */
8799                 uint src = OPER_AY_PD_8();
8800                 uint ea_dst;
8801
8802                 src = (((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16();
8803                 ea_dst = EA_AX_PD_8();
8804                 m68ki_write_8(ea_dst, (src >> 8) & 0xff);
8805                 ea_dst = EA_AX_PD_8();
8806                 m68ki_write_8(ea_dst, src & 0xff);
8807                 return;
8808         }
8809         m68ki_exception_illegal();
8810 }
8811
8812
8813 /* ======================================================================== */
8814 /* ============================== END OF FILE ============================= */
8815 /* ======================================================================== */
8816
8817