source/src/vm/mc6800.cpp

   1 /*
   2         Skelton for retropc emulator
   3
   4         Origin : MAME 0.142
   5         Author : Takeda.Toshiya
   6         Date  : 2011.04.23-
   7
   8         [ MC6800 ]
   9 */
  10
  11 #if defined(_MSC_VER) && (_MSC_VER >= 1400)
  12 #pragma warning( disable : 4996 )
  13 #endif
  14
  15 #include "mc6800.h"
  16 #if defined(HAS_MC6801) || defined(HAS_HD6301)
  17 #include "../fifo.h"
  18 #endif
  19 #ifdef USE_DEBUGGER
  20 #include "debugger.h"
  21 #endif
  22
  23 #define INT_REQ_BIT     1
  24 #define NMI_REQ_BIT     2
  25
  26 #define MC6800_WAI      8
  27 #define HD6301_SLP      0x10
  28
  29 #define pPC     pc
  30 #define pS      sp
  31 #define pX      ix
  32 #define pD      acc_d
  33 #define pEA     ea
  34
  35 #define PC      pc.w.l
  36 #define PCD     pc.d
  37 #define S       sp.w.l
  38 #define SD      sp.d
  39 #define X       ix.w.l
  40 #define D       acc_d.w.l
  41 #define A       acc_d.b.h
  42 #define B       acc_d.b.l
  43 #define CC      cc
  44
  45 #define EAD     ea.d
  46 #define EA      ea.w.l
  47
  48 /****************************************************************************/
  49 /* memory                                                                   */
  50 /****************************************************************************/
  51
  52 uint32 MC6800::RM(uint32 Addr)
  53 {
  54 #if defined(HAS_MC6801) || defined(HAS_HD6301)
  55         if(Addr < 0x20) {
  56                 return mc6801_io_r(Addr);
  57         } else if(Addr >= 0x80 && Addr < 0x100 && (ram_ctrl & 0x40)) {
  58                 return ram[Addr & 0x7f];
  59         }
  60 #endif
  61         return d_mem->read_data8(Addr);
  62 }
  63
  64 void MC6800::WM(uint32 Addr, uint32 Value)
  65 {
  66 #if defined(HAS_MC6801) || defined(HAS_HD6301)
  67         if(Addr < 0x20) {
  68                 mc6801_io_w(Addr, Value);
  69         } else if(Addr >= 0x80 && Addr < 0x100 && (ram_ctrl & 0x40)) {
  70                 ram[Addr & 0x7f] = Value;
  71         } else
  72 #endif
  73         d_mem->write_data8(Addr, Value);
  74 }
  75
  76 uint32 MC6800::RM16(uint32 Addr)
  77 {
  78         uint32 result = RM(Addr) << 8;
  79         return result | RM((Addr + 1) & 0xffff);
  80 }
  81
  82 void MC6800::WM16(uint32 Addr, pair *p)
  83 {
  84         WM(Addr, p->b.h);
  85         WM((Addr + 1) & 0xffff, p->b.l);
  86 }
  87
  88 #define M_RDOP(Addr)            d_mem->read_data8(Addr)
  89 #define M_RDOP_ARG(Addr)        d_mem->read_data8(Addr)
  90
  91 /* macros to access memory */
  92 #define IMMBYTE(b)      b = M_RDOP_ARG(PCD); PC++
  93 #define IMMWORD(w)      w.b.h = M_RDOP_ARG(PCD); w.b.l = M_RDOP_ARG((PCD + 1) & 0xffff); PC += 2
  94
  95 #define PUSHBYTE(b)     WM(SD, b); --S
  96 #define PUSHWORD(w)     WM(SD, w.b.l); --S; WM(SD, w.b.h); --S
  97 #define PULLBYTE(b)     S++; b = RM(SD)
  98 #define PULLWORD(w)     S++; w.b.h = RM(SD); S++; w.b.l = RM(SD)
  99
 100 /****************************************************************************/
 101 /* MC6801/HD6301 internal i/o port                                          */
 102 /****************************************************************************/
 103
 104 #if defined(HAS_MC6801) || defined(HAS_HD6301)
 105
 106 #define CT      counter.w.l
 107 #define CTH     counter.w.h
 108 #define CTD     counter.d
 109 #define OC      output_compare.w.l
 110 #define OCH     output_compare.w.h
 111 #define OCD     output_compare.d
 112 #define TOH     timer_over.w.l
 113 #define TOD     timer_over.d
 114
 115 #define SET_TIMER_EVENT { \
 116         timer_next = (OCD - CTD < TOD - CTD) ? OCD : TOD; \
 117 }
 118
 119 #define CLEANUP_COUNTERS() { \
 120         OCH -= CTH; \
 121         TOH -= CTH; \
 122         CTH = 0; \
 123         SET_TIMER_EVENT; \
 124 }
 125
 126 #define MODIFIED_counters { \
 127         OCH = (OC >= CT) ? CTH : CTH + 1; \
 128         SET_TIMER_EVENT; \
 129 }
 130
 131 #define TCSR_OLVL       0x01
 132 #define TCSR_IEDG       0x02
 133 #define TCSR_ETOI       0x04
 134 #define TCSR_EOCI       0x08
 135 #define TCSR_EICI       0x10
 136 #define TCSR_TOF        0x20
 137 #define TCSR_OCF        0x40
 138 #define TCSR_ICF        0x80
 139
 140 #define TRCSR_WU        0x01
 141 #define TRCSR_TE        0x02
 142 #define TRCSR_TIE       0x04
 143 #define TRCSR_RE        0x08
 144 #define TRCSR_RIE       0x10
 145 #define TRCSR_TDRE      0x20
 146 #define TRCSR_ORFE      0x40
 147 #define TRCSR_RDRF      0x80
 148
 149 #define P3CSR_LE                0x08
 150 #define P3CSR_IS3_ENABLE        0x40
 151 #define P3CSR_IS3_FLAG          0x80
 152
 153 static const int RMCR_SS[] = { 16, 128, 1024, 4096 };
 154
 155 /* take interrupt */
 156 #define TAKE_ICI        enter_interrupt(0xfff6)
 157 #define TAKE_OCI        enter_interrupt(0xfff4)
 158 #define TAKE_TOI        enter_interrupt(0xfff2)
 159 #define TAKE_SCI        enter_interrupt(0xfff0)
 160 #define TAKE_TRAP       enter_interrupt(0xffee)
 161
 162 uint32 MC6800::mc6801_io_r(uint32 offset)
 163 {
 164         switch (offset) {
 165         case 0x00:
 166                 // port1 data direction register
 167                 return port[0].ddr;
 168         case 0x01:
 169                 // port2 data direction register
 170                 return port[1].ddr;
 171         case 0x02:
 172                 // port1 data register
 173                 return (port[0].rreg & ~port[0].ddr) | (port[0].wreg & port[0].ddr);
 174         case 0x03:
 175                 // port2 data register
 176                 return (port[1].rreg & ~port[1].ddr) | (port[1].wreg & port[1].ddr);
 177         case 0x04:
 178                 // port3 data direction register (write only???)
 179                 return port[2].ddr;
 180         case 0x05:
 181                 // port4 data direction register
 182                 return port[3].ddr;
 183         case 0x06:
 184                 // port3 data register
 185                 if(p3csr_is3_flag_read) {
 186                         p3csr_is3_flag_read = false;
 187                         p3csr &= ~P3CSR_IS3_FLAG;
 188                 }
 189                 if(port[2].latched) {
 190                         port[2].latched = false;
 191                         return (port[2].latched_data & ~port[2].ddr) | (port[2].wreg & port[2].ddr);
 192                 }
 193                 return (port[2].rreg & ~port[2].ddr) | (port[2].wreg & port[2].ddr);
 194         case 0x07:
 195                 // port4 data register
 196                 return (port[3].rreg & ~port[3].ddr) | (port[3].wreg & port[3].ddr);
 197         case 0x08:
 198                 // timer control register
 199                 pending_tcsr = 0;
 200                 return tcsr;
 201         case 0x09:
 202                 // free running counter (msb)
 203                 if(!(pending_tcsr & TCSR_TOF)) {
 204                         tcsr &= ~TCSR_TOF;
 205                 }
 206                 return counter.b.h;
 207         case 0x0a:
 208                 // free running counter (lsb)
 209                 return counter.b.l;
 210         case 0x0b:
 211                 // output compare register (msb)
 212                 if(!(pending_tcsr & TCSR_OCF)) {
 213                         tcsr &= ~TCSR_OCF;
 214                 }
 215                 return output_compare.b.h;
 216         case 0x0c:
 217                 // output compare register (lsb)
 218                 if(!(pending_tcsr & TCSR_OCF)) {
 219                         tcsr &= ~TCSR_OCF;
 220                 }
 221                 return output_compare.b.l;
 222         case 0x0d:
 223                 // input capture register (msb)
 224                 if(!(pending_tcsr & TCSR_ICF)) {
 225                         tcsr &= ~TCSR_ICF;
 226                 }
 227                 return (input_capture >> 0) & 0xff;
 228         case 0x0e:
 229                 // input capture register (lsb)
 230                 return (input_capture >> 8) & 0xff;
 231         case 0x0f:
 232                 // port3 control/status register
 233                 p3csr_is3_flag_read = true;
 234                 return p3csr;
 235         case 0x10:
 236                 // rate and mode control register
 237                 return rmcr;
 238         case 0x11:
 239                 if(trcsr & TRCSR_TDRE) {
 240                         trcsr_read_tdre = true;
 241                 }
 242                 if(trcsr & TRCSR_ORFE) {
 243                         trcsr_read_orfe = true;
 244                 }
 245                 if(trcsr & TRCSR_RDRF) {
 246                         trcsr_read_rdrf = true;
 247                 }
 248                 return trcsr;
 249         case 0x12:
 250                 // receive data register
 251                 if(trcsr_read_orfe) {
 252                         trcsr_read_orfe = false;
 253                         trcsr &= ~TRCSR_ORFE;
 254                 }
 255                 if(trcsr_read_rdrf) {
 256                         trcsr_read_rdrf = false;
 257                         trcsr &= ~TRCSR_RDRF;
 258                 }
 259                 return rdr;
 260         case 0x13:
 261                 // transmit data register
 262                 return tdr;
 263         case 0x14:
 264                 // ram control register
 265                 return (ram_ctrl & 0x40) | 0x3f;
 266         }
 267         return 0;
 268 }
 269
 270 void MC6800::mc6801_io_w(uint32 offset, uint32 data)
 271 {
 272         switch(offset) {
 273         case 0x00:
 274                 // port1 data direction register
 275                 port[0].ddr = data;
 276                 break;
 277         case 0x01:
 278                 // port2 data direction register
 279                 port[1].ddr = data;
 280                 break;
 281         case 0x02:
 282                 // port1 data register
 283                 if(port[0].wreg != data || port[0].first_write) {
 284                         write_signals(&port[0].outputs, data);
 285                         port[0].wreg = data;
 286                         port[0].first_write = false;
 287                 }
 288                 break;
 289         case 0x03:
 290                 // port2 data register
 291                 if(port[1].wreg != data || port[1].first_write) {
 292                         write_signals(&port[1].outputs, data);
 293                         port[1].wreg = data;
 294                         port[1].first_write = false;
 295                 }
 296                 break;
 297         case 0x04:
 298                 // port3 data direction register
 299                 port[2].ddr = data;
 300                 break;
 301         case 0x05:
 302                 // port4 data direction register
 303                 port[3].ddr = data;
 304                 break;
 305         case 0x06:
 306                 // port3 data register
 307                 if(p3csr_is3_flag_read) {
 308                         p3csr_is3_flag_read = false;
 309                         p3csr &= ~P3CSR_IS3_FLAG;
 310                 }
 311                 if(port[2].wreg != data || port[2].first_write) {
 312                         write_signals(&port[2].outputs, data);
 313                         port[2].wreg = data;
 314                         port[2].first_write = false;
 315                 }
 316                 break;
 317         case 0x07:
 318                 // port4 data register
 319                 if(port[3].wreg != data || port[3].first_write) {
 320                         write_signals(&port[3].outputs, data);
 321                         port[3].wreg = data;
 322                         port[3].first_write = false;
 323                 }
 324                 break;
 325         case 0x08:
 326                 // timer control/status register
 327                 tcsr = data;
 328                 pending_tcsr &= tcsr;
 329                 break;
 330         case 0x09:
 331                 // free running counter (msb)
 332 #ifdef HAS_HD6301
 333                 latch09 = data & 0xff;
 334 #endif
 335                 CT = 0xfff8;
 336                 TOH = CTH;
 337                 MODIFIED_counters;
 338                 break;
 339 #ifdef HAS_HD6301
 340         case 0x0a:
 341                 // free running counter (lsb)
 342                 CT = (latch09 << 8) | (data & 0xff);
 343                 TOH = CTH;
 344                 MODIFIED_counters;
 345                 break;
 346 #endif
 347         case 0x0b:
 348                 // output compare register (msb)
 349                 if(output_compare.b.h != data) {
 350                         output_compare.b.h = data;
 351                         MODIFIED_counters;
 352                 }
 353                 break;
 354         case 0x0c:
 355                 // output compare register (lsb)
 356                 if(output_compare.b.l != data) {
 357                         output_compare.b.l = data;
 358                         MODIFIED_counters;
 359                 }
 360                 break;
 361         case 0x0f:
 362                 // port3 control/status register
 363                 p3csr = (p3csr & P3CSR_IS3_FLAG) | (data & ~P3CSR_IS3_FLAG);
 364                 break;
 365         case 0x10:
 366                 // rate and mode control register
 367                 rmcr = data;
 368                 break;
 369         case 0x11:
 370                 // transmit/receive control/status register
 371                 trcsr = (trcsr & 0xe0) | (data & 0x1f);
 372                 break;
 373         case 0x13:
 374                 // transmit data register
 375                 if(trcsr_read_tdre) {
 376                         trcsr_read_tdre = false;
 377                         trcsr &= ~TRCSR_TDRE;
 378                 }
 379                 tdr = data;
 380                 break;
 381         case 0x14:
 382                 // ram control register
 383                 ram_ctrl = data;
 384                 break;
 385         }
 386 }
 387
 388 void MC6800::increment_counter(int amount)
 389 {
 390         icount -= amount;
 391
 392         // timer
 393         if((CTD += amount) >= timer_next) {
 394                 /* OCI */
 395                 if( CTD >= OCD) {
 396                         OCH++;  // next IRQ point
 397                         tcsr |= TCSR_OCF;
 398                         pending_tcsr |= TCSR_OCF;
 399                 }
 400                 /* TOI */
 401                 if( CTD >= TOD) {
 402                         TOH++;  // next IRQ point
 403                         tcsr |= TCSR_TOF;
 404                         pending_tcsr |= TCSR_TOF;
 405                 }
 406                 /* set next event */
 407                 SET_TIMER_EVENT;
 408         }
 409
 410         // serial i/o
 411         if((sio_counter -= amount) <= 0) {
 412                 if((trcsr & TRCSR_TE) && !(trcsr & TRCSR_TDRE)) {
 413                         write_signals(&outputs_sio, tdr);
 414                         trcsr |= TRCSR_TDRE;
 415                 }
 416                 if((trcsr & TRCSR_RE) && !recv_buffer->empty()) {
 417                         if(trcsr & TRCSR_WU) {
 418                                 // skip 10 bits
 419                                 trcsr &= ~TRCSR_WU;
 420                                 recv_buffer->read();
 421                         } else if(!(trcsr & TRCSR_RDRF)) {
 422                                 // note: wait reveived data is read by cpu, so overrun framing error never occurs
 423                                 rdr = recv_buffer->read();
 424                                 trcsr |= TRCSR_RDRF;
 425                         }
 426                 }
 427                 sio_counter += RMCR_SS[rmcr & 3];
 428         }
 429 }
 430
 431 #else
 432
 433 #define increment_counter(amount) icount -= amount
 434
 435 #endif
 436
 437 #define CLR_HNZVC       CC &= 0xd0
 438 #define CLR_NZV         CC &= 0xf1
 439 #define CLR_HNZC        CC &= 0xd2
 440 #define CLR_NZVC        CC &= 0xf0
 441 #define CLR_NZ          CC &= 0xf3
 442 #define CLR_Z           CC &= 0xfb
 443 #define CLR_NZC         CC &= 0xf2
 444 #define CLR_ZC          CC &= 0xfa
 445 #define CLR_C           CC &= 0xfe
 446
 447 #define SET_Z(a)        if(!(a)) SEZ
 448 #define SET_Z8(a)       SET_Z((uint8)(a))
 449 #define SET_Z16(a)      SET_Z((uint16)(a))
 450 #define SET_N8(a)       CC |= (((a) & 0x80) >> 4)
 451 #define SET_N16(a)      CC |= (((a) & 0x8000) >> 12)
 452 #define SET_H(a,b,r)    CC |= ((((a) ^ (b) ^ (r)) & 0x10) << 1)
 453 #define SET_C8(a)       CC |= (((a) & 0x100) >> 8)
 454 #define SET_C16(a)      CC |= (((a) & 0x10000) >> 16)
 455 #define SET_V8(a,b,r)   CC |= ((((a) ^ (b) ^ (r) ^ ((r) >> 1)) & 0x80) >> 6)
 456 #define SET_V16(a,b,r)  CC |= ((((a) ^ (b) ^ (r) ^ ((r) >> 1)) & 0x8000) >> 14)
 457
 458 static const uint8 flags8i[256] = {
 459         /* increment */
 460         0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 461         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 462         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 463         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 464         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 465         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 466         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 467         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 468         0x0a,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,
 469         0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,
 470         0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,
 471         0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,
 472         0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,
 473         0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,
 474         0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,
 475         0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08
 476 };
 477
 478 static const uint8 flags8d[256] = {
 479         /* decrement */
 480         0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 481         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 482         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 483         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 484         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 485         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 486         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 487         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,
 488         0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,
 489         0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,
 490         0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,
 491         0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,
 492         0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,
 493         0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,
 494         0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,
 495         0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08
 496 };
 497
 498 #define SET_FLAGS8I(a)          {CC |= flags8i[(a) & 0xff];}
 499 #define SET_FLAGS8D(a)          {CC |= flags8d[(a) & 0xff];}
 500
 501 /* combos */
 502 #define SET_NZ8(a)              {SET_N8(a);  SET_Z8(a);}
 503 #define SET_NZ16(a)             {SET_N16(a); SET_Z16(a);}
 504 #define SET_FLAGS8(a,b,r)       {SET_N8(r);  SET_Z8(r);  SET_V8(a,b,r);  SET_C8(r); }
 505 #define SET_FLAGS16(a,b,r)      {SET_N16(r); SET_Z16(r); SET_V16(a,b,r); SET_C16(r);}
 506
 507 /* for treating an uint8 as a signed int16 */
 508 #define SIGNED(b)       ((int16)(b & 0x80 ? b | 0xff00 : b))
 509
 510 /* Macros for addressing modes */
 511 #define DIRECT          IMMBYTE(EAD)
 512 #define IMM8            EA = PC++
 513 #define IMM16           {EA = PC; PC += 2;}
 514 #define EXTENDED        IMMWORD(pEA)
 515 #define INDEXED         {EA = X + (uint8)M_RDOP_ARG(PCD); PC++;}
 516
 517 /* macros to set status flags */
 518 #define SEC     CC |= 0x01
 519 #define CLC     CC &= 0xfe
 520 #define SEZ     CC |= 0x04
 521 #define CLZ     CC &= 0xfb
 522 #define SEN     CC |= 0x08
 523 #define CLN     CC &= 0xf7
 524 #define SEV     CC |= 0x02
 525 #define CLV     CC &= 0xfd
 526 #define SEH     CC |= 0x20
 527 #define CLH     CC &= 0xdf
 528 #define SEI     CC |= 0x10
 529 #define CLI     CC &= ~0x10
 530
 531 /* macros for convenience */
 532 #define DIRBYTE(b)      {DIRECT;   b   = RM(EAD);  }
 533 #define DIRWORD(w)      {DIRECT;   w.d = RM16(EAD);}
 534 #define EXTBYTE(b)      {EXTENDED; b   = RM(EAD);  }
 535 #define EXTWORD(w)      {EXTENDED; w.d = RM16(EAD);}
 536
 537 #define IDXBYTE(b)      {INDEXED;  b   = RM(EAD);  }
 538 #define IDXWORD(w)      {INDEXED;  w.d = RM16(EAD);}
 539
 540 /* Macros for branch instructions */
 541 #define BRANCH(f)       {IMMBYTE(t); if(f) {PC += SIGNED(t);}}
 542 #define NXORV           ((CC & 0x08) ^ ((CC & 0x02) << 2))
 543
 544 /* Note: don't use 0 cycles here for invalid opcodes so that we don't */
 545 /* hang in an infinite loop if we hit one */
 546 #define XX 5 // invalid opcode unknown cc
 547 static const uint8 cycles[] = {
 548 #if defined(HAS_MC6800)
 549         XX, 2,XX,XX,XX,XX, 2, 2, 4, 4, 2, 2, 2, 2, 2, 2,
 550          2, 2,XX,XX,XX,XX, 2, 2,XX, 2,XX, 2,XX,XX,XX,XX,
 551          4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 552          4, 4, 4, 4, 4, 4, 4, 4,XX, 5,XX,10,XX,XX, 9,12,
 553          2,XX,XX, 2, 2,XX, 2, 2, 2, 2, 2,XX, 2, 2,XX, 2,
 554          2,XX,XX, 2, 2,XX, 2, 2, 2, 2, 2,XX, 2, 2,XX, 2,
 555          7,XX,XX, 7, 7,XX, 7, 7, 7, 7, 7,XX, 7, 7, 4, 7,
 556          6,XX,XX, 6, 6,XX, 6, 6, 6, 6, 6,XX, 6, 6, 3, 6,
 557          2, 2, 2,XX, 2, 2, 2, 3, 2, 2, 2, 2, 3, 8, 3, 4,
 558          3, 3, 3,XX, 3, 3, 3, 4, 3, 3, 3, 3, 4, 6, 4, 5,
 559          5, 5, 5,XX, 5, 5, 5, 6, 5, 5, 5, 5, 6, 8, 6, 7,
 560          4, 4, 4,XX, 4, 4, 4, 5, 4, 4, 4, 4, 5, 9, 5, 6,
 561          2, 2, 2,XX, 2, 2, 2, 3, 2, 2, 2, 2,XX,XX, 3, 4,
 562          3, 3, 3,XX, 3, 3, 3, 4, 3, 3, 3, 3,XX,XX, 4, 5,
 563          5, 5, 5,XX, 5, 5, 5, 6, 5, 5, 5, 5,XX,XX, 6, 7,
 564          4, 4, 4,XX, 4, 4, 4, 5, 4, 4, 4, 4,XX,XX, 5, 6
 565 #elif defined(HAS_MC6801)
 566         XX, 2,XX,XX, 3, 3, 2, 2, 3, 3, 2, 2, 2, 2, 2, 2,
 567          2, 2,XX,XX,XX,XX, 2, 2,XX, 2,XX, 2,XX,XX,XX,XX,
 568          3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 569          3, 3, 4, 4, 3, 3, 3, 3, 5, 5, 3,10, 4,10, 9,12,
 570          2,XX,XX, 2, 2,XX, 2, 2, 2, 2, 2,XX, 2, 2,XX, 2,
 571          2,XX,XX, 2, 2,XX, 2, 2, 2, 2, 2,XX, 2, 2,XX, 2,
 572          6,XX,XX, 6, 6,XX, 6, 6, 6, 6, 6,XX, 6, 6, 3, 6,
 573          6,XX,XX, 6, 6,XX, 6, 6, 6, 6, 6,XX, 6, 6, 3, 6,
 574          2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 2, 4, 6, 3, 3,
 575          3, 3, 3, 5, 3, 3, 3, 3, 3, 3, 3, 3, 5, 5, 4, 4,
 576          4, 4, 4, 6, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 5, 5,
 577          4, 4, 4, 6, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 5, 5,
 578          2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 2, 3,XX, 3, 3,
 579          3, 3, 3, 5, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
 580          4, 4, 4, 6, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5,
 581          4, 4, 4, 6, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5
 582 #elif defined(HAS_HD6301)
 583         XX, 1,XX,XX, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 584          1, 1,XX,XX,XX,XX, 1, 1, 2, 2, 4, 1,XX,XX,XX,XX,
 585          3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 586          1, 1, 3, 3, 1, 1, 4, 4, 4, 5, 1,10, 5, 7, 9,12,
 587          1,XX,XX, 1, 1,XX, 1, 1, 1, 1, 1,XX, 1, 1,XX, 1,
 588          1,XX,XX, 1, 1,XX, 1, 1, 1, 1, 1,XX, 1, 1,XX, 1,
 589          6, 7, 7, 6, 6, 7, 6, 6, 6, 6, 6, 5, 6, 4, 3, 5,
 590          6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 4, 6, 4, 3, 5,
 591          2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 3, 5, 3, 3,
 592          3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 4, 5, 4, 4,
 593          4, 4, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5,
 594          4, 4, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4, 5, 6, 5, 5,
 595          2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 3,XX, 3, 3,
 596          3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
 597          4, 4, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5,
 598          4, 4, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5
 599 #elif defined(HAS_MB8861)
 600         XX, 2,XX,XX,XX,XX, 2, 2, 4, 4, 2, 2, 2, 2, 2, 2,
 601          2, 2,XX,XX,XX,XX, 2, 2,XX, 2,XX, 2,XX,XX,XX,XX,
 602          4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 603          4, 4, 4, 4, 4, 4, 4, 4,XX, 5,XX,10,XX,XX, 9,12,
 604          2,XX,XX, 2, 2,XX, 2, 2, 2, 2, 2,XX, 2, 2,XX, 2,
 605          2,XX,XX, 2, 2,XX, 2, 2, 2, 2, 2,XX, 2, 2,XX, 2,
 606          7,XX,XX, 7, 7,XX, 7, 7, 7, 7, 7,XX, 7, 7, 4, 7,
 607          6, 8, 8, 6, 6, 8, 6, 6, 6, 6, 6, 7, 6, 6, 3, 6,
 608          2, 2, 2,XX, 2, 2, 2, 3, 2, 2, 2, 2, 3, 8, 3, 4,
 609          3, 3, 3,XX, 3, 3, 3, 4, 3, 3, 3, 3, 4, 6, 4, 5,
 610          5, 5, 5,XX, 5, 5, 5, 6, 5, 5, 5, 5, 6, 8, 6, 7,
 611          4, 4, 4,XX, 4, 4, 4, 5, 4, 4, 4, 4, 5, 9, 5, 6,
 612          2, 2, 2,XX, 2, 2, 2, 3, 2, 2, 2, 2,XX,XX, 3, 4,
 613          3, 3, 3,XX, 3, 3, 3, 4, 3, 3, 3, 3,XX,XX, 4, 5,
 614          5, 5, 5,XX, 5, 5, 5, 6, 5, 5, 5, 5, 4,XX, 6, 7,
 615          4, 4, 4,XX, 4, 4, 4, 5, 4, 4, 4, 4, 7,XX, 5, 6
 616 #endif
 617 };
 618 #undef XX // invalid opcode unknown cc
 619
 620
 621 void MC6800::initialize()
 622 {
 623 #if defined(HAS_MC6801) || defined(HAS_HD6301)
 624         recv_buffer = new FIFO(0x10000);
 625         ram_ctrl = 0xc0;
 626 #endif
 627 #ifdef USE_DEBUGGER
 628         d_mem_stored = d_mem;
 629         d_debugger->set_context_mem(d_mem);
 630 #endif
 631 }
 632
 633 #if defined(HAS_MC6801) || defined(HAS_HD6301)
 634 void MC6800::release()
 635 {
 636         recv_buffer->release();
 637         delete recv_buffer;
 638 }
 639 #endif
 640
 641 void MC6800::reset()
 642 {
 643         CC = 0xc0;
 644         SEI; /* IRQ disabled */
 645         PCD = RM16(0xfffe);
 646         S = X = D = EA = 0;
 647
 648         wai_state = 0;
 649         int_state = 0;
 650
 651         icount = 0;
 652
 653 #if defined(HAS_MC6801) || defined(HAS_HD6301)
 654         for(int i = 0; i < 4; i++) {
 655                 port[i].ddr = 0x00;
 656                 port[i].first_write = true;
 657                 port[i].latched = false;
 658         }
 659         p3csr = 0x00;
 660         p3csr_is3_flag_read = false;
 661         sc1_state = sc2_state = false;
 662
 663         tcsr = pending_tcsr = 0x00;
 664         CTD = 0x0000;
 665         OCD = 0xffff;
 666         TOD = 0xffff;
 667
 668         recv_buffer->clear();
 669         trcsr = TRCSR_TDRE;
 670         trcsr_read_tdre = trcsr_read_orfe = trcsr_read_rdrf = false;
 671         rmcr = 0x00;
 672         sio_counter = RMCR_SS[rmcr & 3];
 673
 674         ram_ctrl |= 0x40;
 675 #endif
 676 }
 677
 678 void MC6800::write_signal(int id, uint32 data, uint32 mask)
 679 {
 680         switch(id) {
 681         case SIG_CPU_IRQ:
 682                 if(data & mask) {
 683                         int_state |= INT_REQ_BIT;
 684                 } else {
 685                         int_state &= ~INT_REQ_BIT;
 686                 }
 687                 break;
 688         case SIG_CPU_NMI:
 689                 if(data & mask) {
 690                         int_state |= NMI_REQ_BIT;
 691                 } else {
 692                         int_state &= ~NMI_REQ_BIT;
 693                 }
 694                 break;
 695 #if defined(HAS_MC6801) || defined(HAS_HD6301)
 696         case SIG_MC6801_PORT_1:
 697                 port[0].rreg = (port[0].rreg & ~mask) | (data & mask);
 698                 break;
 699         case SIG_MC6801_PORT_2:
 700                 if((mask & 1) && (port[1].rreg & 1) != (data & 1) && (tcsr & 2) == ((data << 1) & 2)) {
 701                         // active TIN edge in
 702                         tcsr |= TCSR_ICF;
 703                         pending_tcsr |= TCSR_ICF;
 704                         input_capture = CT;
 705                 }
 706                 port[1].rreg = (port[1].rreg & ~mask) | (data & mask);
 707                 break;
 708         case SIG_MC6801_PORT_3:
 709                 port[2].rreg = (port[2].rreg & ~mask) | (data & mask);
 710                 break;
 711         case SIG_MC6801_PORT_4:
 712                 port[3].rreg = (port[3].rreg & ~mask) | (data & mask);
 713                 break;
 714         case SIG_MC6801_PORT_3_SC1:
 715                 if(sc1_state && !(data & mask)) {
 716                         // SC1: H -> L
 717                         if(!port[2].latched && (p3csr & P3CSR_LE)) {
 718                                 port[2].latched_data = port[2].rreg;
 719                                 port[2].latched = true;
 720                                 p3csr |= P3CSR_IS3_FLAG;
 721                         }
 722                 }
 723                 sc1_state = ((data & mask) != 0);
 724                 break;
 725         case SIG_MC6801_PORT_3_SC2:
 726                 sc2_state = ((data & mask) != 0);
 727                 break;
 728         case SIG_MC6801_SIO_RECV:
 729                 recv_buffer->write(data & mask);
 730                 break;
 731 #endif
 732         }
 733 }
 734
 735 int MC6800::run(int clock)
 736 {
 737         // run cpu
 738         if(clock == -1) {
 739                 // run only one opcode
 740 #if defined(HAS_MC6801) || defined(HAS_HD6301)
 741                 CLEANUP_COUNTERS();
 742 #endif
 743                 icount = 0;
 744 #ifdef USE_DEBUGGER
 745                 bool now_debugging = d_debugger->now_debugging;
 746                 if(now_debugging) {
 747                         d_debugger->check_break_points(PC);
 748                         if(d_debugger->now_suspended) {
 749                                 emu->mute_sound();
 750                                 while(d_debugger->now_debugging && d_debugger->now_suspended) {
 751                                         emu->sleep(10);
 752                                 }
 753                         }
 754                         if(d_debugger->now_debugging) {
 755                                 d_mem = d_debugger;
 756                         } else {
 757                                 now_debugging = false;
 758                         }
 759
 760                         run_one_opecode();
 761
 762                         if(now_debugging) {
 763                                 if(!d_debugger->now_going) {
 764                                         d_debugger->now_suspended = true;
 765                                 }
 766                                 d_mem = d_mem_stored;
 767                         }
 768                 } else {
 769 #endif
 770                         run_one_opecode();
 771 #ifdef USE_DEBUGGER
 772                 }
 773 #endif
 774                 return -icount;
 775         } else {
 776                 /* run cpu while given clocks */
 777 #if defined(HAS_MC6801) || defined(HAS_HD6301)
 778                 CLEANUP_COUNTERS();
 779 #endif
 780                 icount += clock;
 781                 int first_icount = icount;
 782
 783                 while(icount > 0) {
 784 #ifdef USE_DEBUGGER
 785                         bool now_debugging = d_debugger->now_debugging;
 786                         if(now_debugging) {
 787                                 d_debugger->check_break_points(PC);
 788                                 if(d_debugger->now_suspended) {
 789                                         emu->mute_sound();
 790                                         while(d_debugger->now_debugging && d_debugger->now_suspended) {
 791                                                 emu->sleep(10);
 792                                         }
 793                                 }
 794                                 if(d_debugger->now_debugging) {
 795                                         d_mem = d_debugger;
 796                                 } else {
 797                                         now_debugging = false;
 798                                 }
 799
 800                                 run_one_opecode();
 801
 802                                 if(now_debugging) {
 803                                         if(!d_debugger->now_going) {
 804                                                 d_debugger->now_suspended = true;
 805                                         }
 806                                         d_mem = d_mem_stored;
 807                                 }
 808                         } else {
 809 #endif
 810                                 run_one_opecode();
 811 #ifdef USE_DEBUGGER
 812                         }
 813 #endif
 814                 }
 815                 return first_icount - icount;
 816         }
 817 }
 818
 819 void MC6800::run_one_opecode()
 820 {
 821         if(wai_state & (MC6800_WAI | HD6301_SLP)) {
 822                 increment_counter(1);
 823         } else {
 824                 uint8 ireg = M_RDOP(PCD);
 825                 prevpc = PC;
 826                 PC++;
 827                 insn(ireg);
 828                 increment_counter(cycles[ireg]);
 829         }
 830
 831         // check interrupt
 832         if(int_state & NMI_REQ_BIT) {
 833                 wai_state &= ~HD6301_SLP;
 834                 int_state &= ~NMI_REQ_BIT;
 835                 enter_interrupt(0xfffc);
 836         } else if(int_state & INT_REQ_BIT) {
 837                 wai_state &= ~HD6301_SLP;
 838                 if(!(CC & 0x10)) {
 839                         int_state &= ~INT_REQ_BIT;
 840                         enter_interrupt(0xfff8);
 841                 }
 842 #if defined(HAS_MC6801) || defined(HAS_HD6301)
 843         } else if((tcsr & (TCSR_EICI | TCSR_ICF)) == (TCSR_EICI | TCSR_ICF)) {
 844                 wai_state &= ~HD6301_SLP;
 845                 if(!(CC & 0x10)) {
 846                         TAKE_ICI;
 847                 }
 848         } else if((tcsr & (TCSR_EOCI | TCSR_OCF)) == (TCSR_EOCI | TCSR_OCF)) {
 849                 wai_state &= ~HD6301_SLP;
 850                 if(!(CC & 0x10)) {
 851                         TAKE_OCI;
 852                 }
 853         } else if((tcsr & (TCSR_ETOI | TCSR_TOF)) == (TCSR_ETOI | TCSR_TOF)) {
 854                 wai_state &= ~HD6301_SLP;
 855                 if(!(CC & 0x10)) {
 856                         TAKE_TOI;
 857                 }
 858         } else if(((trcsr & (TRCSR_RIE | TRCSR_RDRF)) == (TRCSR_RIE | TRCSR_RDRF)) ||
 859                   ((trcsr & (TRCSR_RIE | TRCSR_ORFE)) == (TRCSR_RIE | TRCSR_ORFE)) ||
 860                   ((trcsr & (TRCSR_TIE | TRCSR_TDRE)) == (TRCSR_TIE | TRCSR_TDRE))) {
 861                 wai_state &= ~HD6301_SLP;
 862                 if(!(CC & 0x10)) {
 863                         TAKE_SCI;
 864                 }
 865 #endif
 866         }
 867 }
 868
 869 #ifdef USE_DEBUGGER
 870 void MC6800::debug_write_data8(uint32 addr, uint32 data)
 871 {
 872         int wait;
 873         d_mem_stored->write_data8w(addr, data, &wait);
 874 }
 875
 876 uint32 MC6800::debug_read_data8(uint32 addr)
 877 {
 878         int wait;
 879         return d_mem_stored->read_data8w(addr, &wait);
 880 }
 881
 882 void MC6800::debug_write_data16(uint32 addr, uint32 data)
 883 {
 884         debug_write_data8(addr, (data >> 8) & 0xff);
 885         debug_write_data8(addr + 1, data & 0xff);
 886 }
 887
 888 uint32 MC6800::debug_read_data16(uint32 addr)
 889 {
 890         uint32 val = debug_read_data8(addr) << 8;
 891         val |= debug_read_data8(addr + 1);
 892         return val;
 893 }
 894
 895 void MC6800::debug_write_data32(uint32 addr, uint32 data)
 896 {
 897         debug_write_data16(addr, (data >> 16) & 0xffff);
 898         debug_write_data16(addr + 2, data & 0xffff);
 899 }
 900
 901 uint32 MC6800::debug_read_data32(uint32 addr)
 902 {
 903         uint32 val = debug_read_data16(addr) << 16;
 904         val |= debug_read_data16(addr + 2);
 905         return val;
 906 }
 907
 908 bool MC6800::debug_write_reg(const _TCHAR *reg, uint32 data)
 909 {
 910         if(_tcsicmp(reg, _T("A")) == 0) {
 911                 A = data;
 912         } else if(_tcsicmp(reg, _T("B")) == 0) {
 913                 B = data;
 914         } else if(_tcsicmp(reg, _T("X")) == 0 || _tcsicmp(reg, _T("IX")) == 0) {
 915                 X = data;
 916         } else if(_tcsicmp(reg, _T("PC")) == 0) {
 917                 PC = data;
 918         } else if(_tcsicmp(reg, _T("SP")) == 0) {
 919                 S = data;
 920         } else {
 921                 return false;
 922         }
 923         return true;
 924 }
 925
 926 void MC6800::debug_regs_info(_TCHAR *buffer, size_t buffer_len)
 927 {
 928         my_stprintf_s(buffer, buffer_len,
 929         _T("CCR = [%c%c%c%c%c%c]  A = %02X  B = %02X  IX = %04X  PC = %04X  SP = %04X"),
 930         (CC & 0x01) ? _T('C') : _T('-'), (CC & 0x02) ? _T('V') : _T('-'), (CC & 0x04) ? _T('Z') : _T('-'), (CC & 0x08) ? _T('N') : _T('-'),
 931         (CC & 0x10) ? _T('I') : _T('-'), (CC & 0x20) ? _T('X') : _T('-'), A, B, X, PC, S);
 932 }
 933
 934 /*
 935  *   A quick-hack 6803/6808 disassembler
 936  *
 937  *   Note: this is not the good and proper way to disassemble anything, but it works
 938  *
 939  *   I'm afraid to put my name on it, but I feel obligated:
 940  *   This code written by Aaron Giles (agiles@sirius.com) for the MAME project
 941  *
 942  * History:
 943  * 990314 HJB
 944  * The disassembler knows about valid opcodes for M6800/1/2/3/8 and HD63701.
 945  * 990302 HJB
 946  * Changed the string array into a table of opcode names (or tokens) and
 947  * argument types. This second try should give somewhat better results.
 948  * Named the undocumented HD63701YO opcodes $12 and $13 'asx1' and 'asx2',
 949  * since 'add contents of stack to x register' is what they do.
 950  *
 951  */
 952
 953 enum addr_mode {
 954         inh,    /* inherent */
 955         rel,    /* relative */
 956         imb,    /* immediate (byte) */
 957         imw,    /* immediate (word) */
 958         dir,    /* direct address */
 959         imd,    /* HD63701YO: immediate, direct address */
 960         ext,    /* extended address */
 961         idx,    /* x + byte offset */
 962         imx,    /* HD63701YO: immediate, x + byte offset */
 963         sx1     /* HD63701YO: undocumented opcodes: byte from (s+1) */
 964 };
 965
 966 enum op_names {
 967         aba=0,  abx,    adca,   adcb,   adda,   addb,   addd,   aim,
 968         anda,   andb,   asl,    asla,   aslb,   asld,   asr,    asra,
 969         asrb,   bcc,    bcs,    beq,    bge,    bgt,    bhi,    bita,
 970         bitb,   ble,    bls,    blt,    bmi,    bne,    bpl,    bra,
 971         brn,    bsr,    bvc,    bvs,    cba,    clc,    cli,    clr,
 972         clra,   clrb,   clv,    cmpa,   cmpb,   cmpx,   com,    coma,
 973         comb,   daa,    dec,    deca,   decb,   des,    dex,    eim,
 974         eora,   eorb,   ill,    inc,    inca,   incb,   ins,    inx,
 975         jmp,    jsr,    lda,    ldb,    ldd,    lds,    ldx,    lsr,
 976         lsra,   lsrb,   lsrd,   mul,    neg,    nega,   negb,   nop,
 977         oim,    ora,    orb,    psha,   pshb,   pshx,   pula,   pulb,
 978         pulx,   rol,    rola,   rolb,   ror,    rora,   rorb,   rti,
 979         rts,    sba,    sbca,   sbcb,   sec,    sev,    sta,    stb,
 980         _std,   sei,    sts,    stx,    suba,   subb,   subd,   swi,
 981         wai,    tab,    tap,    tba,    tim,    tpa,    tst,    tsta,
 982         tstb,   tsx,    txs,    asx1,   asx2,   xgdx,   addx,   adcx
 983 };
 984
 985 static const char *const op_name_str[] = {
 986         "aba",   "abx",   "adca",  "adcb",  "adda",  "addb",  "addd",  "aim",
 987         "anda",  "andb",  "asl",   "asla",  "aslb",  "asld",  "asr",   "asra",
 988         "asrb",  "bcc",   "bcs",   "beq",   "bge",   "bgt",   "bhi",   "bita",
 989         "bitb",  "ble",   "bls",   "blt",   "bmi",   "bne",   "bpl",   "bra",
 990         "brn",   "bsr",   "bvc",   "bvs",   "cba",   "clc",   "cli",   "clr",
 991         "clra",  "clrb",  "clv",   "cmpa",  "cmpb",  "cmpx",  "com",   "coma",
 992         "comb",  "daa",   "dec",   "deca",  "decb",  "des",   "dex",   "eim",
 993         "eora",  "eorb",  "illegal","inc",   "inca",  "incb",  "ins",   "inx",
 994         "jmp",   "jsr",   "lda",   "ldb",   "ldd",   "lds",   "ldx",   "lsr",
 995         "lsra",  "lsrb",  "lsrd",  "mul",   "neg",   "nega",  "negb",  "nop",
 996         "oim",   "ora",   "orb",   "psha",  "pshb",  "pshx",  "pula",  "pulb",
 997         "pulx",  "rol",   "rola",  "rolb",  "ror",   "rora",  "rorb",  "rti",
 998         "rts",   "sba",   "sbca",  "sbcb",  "sec",   "sev",   "sta",   "stb",
 999         "std",   "sei",   "sts",   "stx",   "suba",  "subb",  "subd",  "swi",
1000         "wai",   "tab",   "tap",   "tba",   "tim",   "tpa",   "tst",   "tsta",
1001         "tstb",  "tsx",   "txs",   "asx1",  "asx2",  "xgdx",  "addx",  "adcx"
1002 };
1003
1004 /*
1005  * This table defines the opcodes:
1006  * byte meaning
1007  * 0    token (menmonic)
1008  * 1    addressing mode
1009  * 2    invalid opcode for 1:6800/6802/6808, 2:6801/6803, 4:HD63701
1010  */
1011
1012 static const UINT8 table[0x102][3] = {
1013         {ill, inh,7},{nop, inh,0},{ill, inh,7},{ill, inh,7},/* 00 */
1014         {lsrd,inh,1},{asld,inh,1},{tap, inh,0},{tpa, inh,0},
1015         {inx, inh,0},{dex, inh,0},{clv, inh,0},{sev, inh,0},
1016         {clc, inh,0},{sec, inh,0},{cli, inh,0},{sei, inh,0},
1017         {sba, inh,0},{cba, inh,0},{asx1,sx1,0},{asx2,sx1,0},/* 10 */
1018         {ill, inh,7},{ill, inh,7},{tab, inh,0},{tba, inh,0},
1019         {xgdx,inh,3},{daa, inh,0},{ill, inh,7},{aba, inh,0},
1020         {ill, inh,7},{ill, inh,7},{ill, inh,7},{ill, inh,7},
1021         {bra, rel,0},{brn, rel,0},{bhi, rel,0},{bls, rel,0},/* 20 */
1022         {bcc, rel,0},{bcs, rel,0},{bne, rel,0},{beq, rel,0},
1023         {bvc, rel,0},{bvs, rel,0},{bpl, rel,0},{bmi, rel,0},
1024         {bge, rel,0},{blt, rel,0},{bgt, rel,0},{ble, rel,0},
1025         {tsx, inh,0},{ins, inh,0},{pula,inh,0},{pulb,inh,0},/* 30 */
1026         {des, inh,0},{txs, inh,0},{psha,inh,0},{pshb,inh,0},
1027         {pulx,inh,1},{rts, inh,0},{abx, inh,1},{rti, inh,0},
1028         {pshx,inh,1},{mul, inh,1},{wai, inh,0},{swi, inh,0},
1029         {nega,inh,0},{ill, inh,7},{ill, inh,7},{coma,inh,0},/* 40 */
1030         {lsra,inh,0},{ill, inh,7},{rora,inh,0},{asra,inh,0},
1031         {asla,inh,0},{rola,inh,0},{deca,inh,0},{ill, inh,7},
1032         {inca,inh,0},{tsta,inh,0},{ill, inh,7},{clra,inh,0},
1033         {negb,inh,0},{ill, inh,7},{ill, inh,7},{comb,inh,0},/* 50 */
1034         {lsrb,inh,0},{ill, inh,7},{rorb,inh,0},{asrb,inh,0},
1035         {aslb,inh,0},{rolb,inh,0},{decb,inh,0},{ill, inh,7},
1036         {incb,inh,0},{tstb,inh,0},{ill, inh,7},{clrb,inh,0},
1037         {neg, idx,0},{aim, imx,3},{oim, imx,3},{com, idx,0},/* 60 */
1038         {lsr, idx,0},{eim, imx,3},{ror, idx,0},{asr, idx,0},
1039         {asl, idx,0},{rol, idx,0},{dec, idx,0},{tim, imx,3},
1040         {inc, idx,0},{tst, idx,0},{jmp, idx,0},{clr, idx,0},
1041         {neg, ext,0},{aim, imd,3},{oim, imd,3},{com, ext,0},/* 70 */
1042         {lsr, ext,0},{eim, imd,3},{ror, ext,0},{asr, ext,0},
1043         {asl, ext,0},{rol, ext,0},{dec, ext,0},{tim, imd,3},
1044         {inc, ext,0},{tst, ext,0},{jmp, ext,0},{clr, ext,0},
1045         {suba,imb,0},{cmpa,imb,0},{sbca,imb,0},{subd,imw,1},/* 80 */
1046         {anda,imb,0},{bita,imb,0},{lda, imb,0},{sta, imb,0},
1047         {eora,imb,0},{adca,imb,0},{ora, imb,0},{adda,imb,0},
1048         {cmpx,imw,0},{bsr, rel,0},{lds, imw,0},{sts, imw,0},
1049         {suba,dir,0},{cmpa,dir,0},{sbca,dir,0},{subd,dir,1},/* 90 */
1050         {anda,dir,0},{bita,dir,0},{lda, dir,0},{sta, dir,0},
1051         {eora,dir,0},{adca,dir,0},{ora, dir,0},{adda,dir,0},
1052         {cmpx,dir,0},{jsr, dir,0},{lds, dir,0},{sts, dir,0},
1053         {suba,idx,0},{cmpa,idx,0},{sbca,idx,0},{subd,idx,1},/* a0 */
1054         {anda,idx,0},{bita,idx,0},{lda, idx,0},{sta, idx,0},
1055         {eora,idx,0},{adca,idx,0},{ora, idx,0},{adda,idx,0},
1056         {cmpx,idx,0},{jsr, idx,0},{lds, idx,0},{sts, idx,0},
1057         {suba,ext,0},{cmpa,ext,0},{sbca,ext,0},{subd,ext,1},/* b0 */
1058         {anda,ext,0},{bita,ext,0},{lda, ext,0},{sta, ext,0},
1059         {eora,ext,0},{adca,ext,0},{ora, ext,0},{adda,ext,0},
1060         {cmpx,ext,0},{jsr, ext,0},{lds, ext,0},{sts, ext,0},
1061         {subb,imb,0},{cmpb,imb,0},{sbcb,imb,0},{addd,imw,1},/* c0 */
1062         {andb,imb,0},{bitb,imb,0},{ldb, imb,0},{stb, imb,0},
1063         {eorb,imb,0},{adcb,imb,0},{orb, imb,0},{addb,imb,0},
1064         {ldd, imw,1},{_std,imw,1},{ldx, imw,0},{stx, imw,0},
1065         {subb,dir,0},{cmpb,dir,0},{sbcb,dir,0},{addd,dir,1},/* d0 */
1066         {andb,dir,0},{bitb,dir,0},{ldb, dir,0},{stb, dir,0},
1067         {eorb,dir,0},{adcb,dir,0},{orb, dir,0},{addb,dir,0},
1068         {ldd, dir,1},{_std,dir,1},{ldx, dir,0},{stx, dir,0},
1069         {subb,idx,0},{cmpb,idx,0},{sbcb,idx,0},{addd,idx,1},/* e0 */
1070         {andb,idx,0},{bitb,idx,0},{ldb, idx,0},{stb, idx,0},
1071         {eorb,idx,0},{adcb,idx,0},{orb, idx,0},{addb,idx,0},
1072         {ldd, idx,1},{_std,idx,1},{ldx, idx,0},{stx, idx,0},
1073         {subb,ext,0},{cmpb,ext,0},{sbcb,ext,0},{addd,ext,1},/* f0 */
1074         {andb,ext,0},{bitb,ext,0},{ldb, ext,0},{stb, ext,0},
1075         {eorb,ext,0},{adcb,ext,0},{orb, ext,0},{addb,ext,0},
1076         {ldd, ext,1},{_std,ext,1},{ldx, ext,0},{stx, ext,0},
1077
1078         /* extra instruction $fc for NSC-8105 */
1079         {addx,ext,0},
1080         /* extra instruction $ec for NSC-8105 */
1081         {adcx,imb,0}
1082 };
1083
1084 /* some macros to keep things short */
1085 #define OP      oprom[0]
1086 #define ARG1    opram[1]
1087 #define ARG2    opram[2]
1088 #define ARGW    (opram[1]<<8) + opram[2]
1089
1090 static unsigned Dasm680x (int subtype, char *buf, unsigned pc, const UINT8 *oprom, const UINT8 *opram)
1091 {
1092 //      UINT32 flags = 0;
1093         int invalid_mask;
1094         int code = OP;
1095         UINT8 opcode, args, invalid;
1096
1097         switch( subtype )
1098         {
1099                 case 6800: case 6802: case 6808: case 8105:
1100                         invalid_mask = 1;
1101                         break;
1102                 case 6801: case 6803:
1103                         invalid_mask = 2;
1104                         break;
1105                 default:
1106                         invalid_mask = 4;
1107         }
1108
1109         /* NSC-8105 is a special case */
1110         if (subtype == 8105)
1111         {
1112                 /* swap bits */
1113                 code = (code & 0x3c) | ((code & 0x41) << 1) | ((code & 0x82) >> 1);
1114
1115                 /* and check for extra instruction */
1116                 if (code == 0xfc)  code = 0x0100;
1117                 if (code == 0xec)  code = 0x0101;
1118         }
1119
1120         opcode = table[code][0];
1121         args = table[code][1];
1122         invalid = table[code][2];
1123
1124 //      if (opcode == bsr || opcode == jsr) {
1125 //              flags = DASMFLAG_STEP_OVER;
1126 //      } else if (opcode == rti || opcode == rts) {
1127 //              flags = DASMFLAG_STEP_OUT;
1128 //      }
1129
1130         if ( invalid & invalid_mask )   /* invalid for this cpu type ? */
1131         {
1132                 strcpy(buf, "illegal");
1133                 return 1;// | flags | DASMFLAG_SUPPORTED;
1134         }
1135
1136         buf += sprintf(buf, "%-5s", op_name_str[opcode]);
1137
1138         switch( args )
1139         {
1140                 case rel:  /* relative */
1141                         sprintf (buf, "$%04X", pc + (INT8)ARG1 + 2);
1142                         return 2;// | flags | DASMFLAG_SUPPORTED;
1143                 case imb:  /* immediate (byte) */
1144                         sprintf (buf, "#$%02X", ARG1);
1145                         return 2;// | flags | DASMFLAG_SUPPORTED;
1146                 case imw:  /* immediate (word) */
1147                         sprintf (buf, "#$%04X", ARGW);
1148                         return 3;// | flags | DASMFLAG_SUPPORTED;
1149                 case idx:  /* indexed + byte offset */
1150                         sprintf (buf, "(x+$%02X)", ARG1 );
1151                         return 2;// | flags | DASMFLAG_SUPPORTED;
1152                 case imx:  /* immediate, indexed + byte offset */
1153                         sprintf (buf, "#$%02X,(x+$%02x)", ARG1, ARG2 );
1154                         return 3;// | flags | DASMFLAG_SUPPORTED;
1155                 case dir:  /* direct address */
1156                         sprintf (buf, "$%02X", ARG1 );
1157                         return 2;// | flags | DASMFLAG_SUPPORTED;
1158                 case imd:  /* immediate, direct address */
1159                         sprintf (buf, "#$%02X,$%02X", ARG1, ARG2);
1160                         return 3;// | flags | DASMFLAG_SUPPORTED;
1161                 case ext:  /* extended address */
1162                         sprintf (buf, "$%04X", ARGW);
1163                         return 3;// | flags | DASMFLAG_SUPPORTED;
1164                 case sx1:  /* byte from address (s + 1) */
1165                         sprintf (buf, "(s+1)");
1166                         return 1;// | flags | DASMFLAG_SUPPORTED;
1167                 default:
1168                         return 1;// | flags | DASMFLAG_SUPPORTED;
1169         }
1170 }
1171
1172 int MC6800::debug_dasm(uint32 pc, _TCHAR *buffer, size_t buffer_len)
1173 {
1174         uint8 ops[4];
1175         for(int i = 0; i < 4; i++) {
1176                 int wait;
1177                 ops[i] = d_mem_stored->read_data8w(pc + i, &wait);
1178         }
1179 #if defined(HAS_MC6800)
1180         return Dasm680x(6800, buffer, pc, ops, ops);
1181 #elif defined(HAS_MC6801)
1182         return Dasm680x(6801, buffer, pc, ops, ops);
1183 #elif defined(HAS_HD6301)
1184         return Dasm680x(6301, buffer, pc, ops, ops);
1185 #elif defined(HAS_MB8861)
1186         return Dasm680x(6800, buffer, pc, ops, ops);    // FIXME
1187 #endif
1188         return 0;
1189 }
1190 #endif
1191
1192 void MC6800::enter_interrupt(uint16 irq_vector)
1193 {
1194         if(wai_state & MC6800_WAI) {
1195                 icount -= 4;
1196                 wai_state &= ~MC6800_WAI;
1197         } else {
1198                 PUSHWORD(pPC);
1199                 PUSHWORD(pX);
1200                 PUSHBYTE(A);
1201                 PUSHBYTE(B);
1202                 PUSHBYTE(CC);
1203                 icount -= 12;
1204         }
1205         SEI;
1206         PCD = RM16(irq_vector);
1207 }
1208
1209 // opcodes
1210
1211 void MC6800::insn(uint8 code)
1212 {
1213         switch(code) {
1214         case 0x00: illegal(); break;
1215         case 0x01: nop(); break;
1216         case 0x02: illegal(); break;
1217         case 0x03: illegal(); break;
1218 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1219         case 0x04: lsrd(); break;
1220         case 0x05: asld(); break;
1221 #else
1222         case 0x04: illegal(); break;
1223         case 0x05: illegal(); break;
1224 #endif
1225         case 0x06: tap(); break;
1226         case 0x07: tpa(); break;
1227         case 0x08: inx(); break;
1228         case 0x09: dex(); break;
1229         case 0x0a: clv(); break;
1230         case 0x0b: sev(); break;
1231         case 0x0c: clc(); break;
1232         case 0x0d: sec(); break;
1233         case 0x0e: cli(); break;
1234         case 0x0f: sei(); break;
1235         case 0x10: sba(); break;
1236         case 0x11: cba(); break;
1237 #if defined(HAS_HD6301)
1238         case 0x12: undoc1(); break;
1239         case 0x13: undoc2(); break;
1240 #else
1241         case 0x12: illegal(); break;
1242         case 0x13: illegal(); break;
1243 #endif
1244         case 0x14: illegal(); break;
1245         case 0x15: illegal(); break;
1246         case 0x16: tab(); break;
1247         case 0x17: tba(); break;
1248 #if defined(HAS_HD6301)
1249         case 0x18: xgdx(); break;
1250 #else
1251         case 0x18: illegal(); break;
1252 #endif
1253         case 0x19: daa(); break;
1254 #if defined(HAS_HD6301)
1255         case 0x1a: slp(); break;
1256 #else
1257         case 0x1a: illegal(); break;
1258 #endif
1259         case 0x1b: aba(); break;
1260         case 0x1c: illegal(); break;
1261         case 0x1d: illegal(); break;
1262         case 0x1e: illegal(); break;
1263         case 0x1f: illegal(); break;
1264         case 0x20: bra(); break;
1265         case 0x21: brn(); break;
1266         case 0x22: bhi(); break;
1267         case 0x23: bls(); break;
1268         case 0x24: bcc(); break;
1269         case 0x25: bcs(); break;
1270         case 0x26: bne(); break;
1271         case 0x27: beq(); break;
1272         case 0x28: bvc(); break;
1273         case 0x29: bvs(); break;
1274         case 0x2a: bpl(); break;
1275         case 0x2b: bmi(); break;
1276         case 0x2c: bge(); break;
1277         case 0x2d: blt(); break;
1278         case 0x2e: bgt(); break;
1279         case 0x2f: ble(); break;
1280         case 0x30: tsx(); break;
1281         case 0x31: ins(); break;
1282         case 0x32: pula(); break;
1283         case 0x33: pulb(); break;
1284         case 0x34: des(); break;
1285         case 0x35: txs(); break;
1286         case 0x36: psha(); break;
1287         case 0x37: pshb(); break;
1288 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1289         case 0x38: pulx(); break;
1290 #else
1291         case 0x38: illegal(); break;
1292 #endif
1293         case 0x39: rts(); break;
1294 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1295         case 0x3a: abx(); break;
1296 #else
1297         case 0x3a: illegal(); break;
1298 #endif
1299         case 0x3b: rti(); break;
1300 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1301         case 0x3c: pshx(); break;
1302         case 0x3d: mul(); break;
1303 #else
1304         case 0x3c: illegal(); break;
1305         case 0x3d: illegal(); break;
1306 #endif
1307         case 0x3e: wai(); break;
1308         case 0x3f: swi(); break;
1309         case 0x40: nega(); break;
1310         case 0x41: illegal(); break;
1311         case 0x42: illegal(); break;
1312         case 0x43: coma(); break;
1313         case 0x44: lsra(); break;
1314         case 0x45: illegal(); break;
1315         case 0x46: rora(); break;
1316         case 0x47: asra(); break;
1317         case 0x48: asla(); break;
1318         case 0x49: rola(); break;
1319         case 0x4a: deca(); break;
1320         case 0x4b: illegal(); break;
1321         case 0x4c: inca(); break;
1322         case 0x4d: tsta(); break;
1323         case 0x4e: illegal(); break;
1324         case 0x4f: clra(); break;
1325         case 0x50: negb(); break;
1326         case 0x51: illegal(); break;
1327         case 0x52: illegal(); break;
1328         case 0x53: comb(); break;
1329         case 0x54: lsrb(); break;
1330         case 0x55: illegal(); break;
1331         case 0x56: rorb(); break;
1332         case 0x57: asrb(); break;
1333         case 0x58: aslb(); break;
1334         case 0x59: rolb(); break;
1335         case 0x5a: decb(); break;
1336         case 0x5b: illegal(); break;
1337         case 0x5c: incb(); break;
1338         case 0x5d: tstb(); break;
1339         case 0x5e: illegal(); break;
1340         case 0x5f: clrb(); break;
1341         case 0x60: neg_ix(); break;
1342 #if defined(HAS_HD6301)
1343         case 0x61: aim_ix(); break;
1344         case 0x62: oim_ix(); break;
1345 #else
1346         case 0x61: illegal(); break;
1347         case 0x62: illegal(); break;
1348 #endif
1349         case 0x63: com_ix(); break;
1350         case 0x64: lsr_ix(); break;
1351 #if defined(HAS_HD6301)
1352         case 0x65: eim_ix(); break;
1353 #else
1354         case 0x65: illegal(); break;
1355 #endif
1356         case 0x66: ror_ix(); break;
1357         case 0x67: asr_ix(); break;
1358         case 0x68: asl_ix(); break;
1359         case 0x69: rol_ix(); break;
1360         case 0x6a: dec_ix(); break;
1361 #if defined(HAS_HD6301)
1362         case 0x6b: tim_ix(); break;
1363 #else
1364         case 0x6b: illegal(); break;
1365 #endif
1366         case 0x6c: inc_ix(); break;
1367         case 0x6d: tst_ix(); break;
1368         case 0x6e: jmp_ix(); break;
1369         case 0x6f: clr_ix(); break;
1370         case 0x70: neg_ex(); break;
1371 #if defined(HAS_HD6301)
1372         case 0x71: aim_di(); break;
1373         case 0x72: oim_di(); break;
1374 #elif defined(HAS_MB8861)
1375         case 0x71: nim_ix(); break;
1376         case 0x72: oim_ix_mb8861(); break;
1377 #else
1378         case 0x71: illegal(); break;
1379         case 0x72: illegal(); break;
1380 #endif
1381         case 0x73: com_ex(); break;
1382         case 0x74: lsr_ex(); break;
1383 #if defined(HAS_HD6301)
1384         case 0x75: eim_di(); break;
1385 #elif defined(HAS_MB8861)
1386         case 0x75: xim_ix(); break;
1387 #else
1388         case 0x75: illegal(); break;
1389 #endif
1390         case 0x76: ror_ex(); break;
1391         case 0x77: asr_ex(); break;
1392         case 0x78: asl_ex(); break;
1393         case 0x79: rol_ex(); break;
1394         case 0x7a: dec_ex(); break;
1395 #if defined(HAS_HD6301)
1396         case 0x7b: tim_di(); break;
1397 #elif defined(HAS_MB8861)
1398         case 0x7b: tmm_ix(); break;
1399 #else
1400         case 0x7b: illegal(); break;
1401 #endif
1402         case 0x7c: inc_ex(); break;
1403         case 0x7d: tst_ex(); break;
1404         case 0x7e: jmp_ex(); break;
1405         case 0x7f: clr_ex(); break;
1406         case 0x80: suba_im(); break;
1407         case 0x81: cmpa_im(); break;
1408         case 0x82: sbca_im(); break;
1409 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1410         case 0x83: subd_im(); break;
1411 #else
1412         case 0x83: illegal(); break;
1413 #endif
1414         case 0x84: anda_im(); break;
1415         case 0x85: bita_im(); break;
1416         case 0x86: lda_im(); break;
1417         case 0x87: sta_im(); break;
1418         case 0x88: eora_im(); break;
1419         case 0x89: adca_im(); break;
1420         case 0x8a: ora_im(); break;
1421         case 0x8b: adda_im(); break;
1422 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1423         case 0x8c: cpx_im (); break;
1424 #else
1425         case 0x8c: cmpx_im(); break;
1426 #endif
1427         case 0x8d: bsr(); break;
1428         case 0x8e: lds_im(); break;
1429         case 0x8f: sts_im(); break;
1430         case 0x90: suba_di(); break;
1431         case 0x91: cmpa_di(); break;
1432         case 0x92: sbca_di(); break;
1433 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1434         case 0x93: subd_di(); break;
1435 #else
1436         case 0x93: illegal(); break;
1437 #endif
1438         case 0x94: anda_di(); break;
1439         case 0x95: bita_di(); break;
1440         case 0x96: lda_di(); break;
1441         case 0x97: sta_di(); break;
1442         case 0x98: eora_di(); break;
1443         case 0x99: adca_di(); break;
1444         case 0x9a: ora_di(); break;
1445         case 0x9b: adda_di(); break;
1446 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1447         case 0x9c: cpx_di (); break;
1448 #else
1449         case 0x9c: cmpx_di(); break;
1450 #endif
1451         case 0x9d: jsr_di(); break;
1452         case 0x9e: lds_di(); break;
1453         case 0x9f: sts_di(); break;
1454         case 0xa0: suba_ix(); break;
1455         case 0xa1: cmpa_ix(); break;
1456         case 0xa2: sbca_ix(); break;
1457 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1458         case 0xa3: subd_ix(); break;
1459 #else
1460         case 0xa3: illegal(); break;
1461 #endif
1462         case 0xa4: anda_ix(); break;
1463         case 0xa5: bita_ix(); break;
1464         case 0xa6: lda_ix(); break;
1465         case 0xa7: sta_ix(); break;
1466         case 0xa8: eora_ix(); break;
1467         case 0xa9: adca_ix(); break;
1468         case 0xaa: ora_ix(); break;
1469         case 0xab: adda_ix(); break;
1470 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1471         case 0xac: cpx_ix (); break;
1472 #else
1473         case 0xac: cmpx_ix(); break;
1474 #endif
1475         case 0xad: jsr_ix(); break;
1476         case 0xae: lds_ix(); break;
1477         case 0xaf: sts_ix(); break;
1478         case 0xb0: suba_ex(); break;
1479         case 0xb1: cmpa_ex(); break;
1480         case 0xb2: sbca_ex(); break;
1481 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1482         case 0xb3: subd_ex(); break;
1483 #else
1484         case 0xb3: illegal(); break;
1485 #endif
1486         case 0xb4: anda_ex(); break;
1487         case 0xb5: bita_ex(); break;
1488         case 0xb6: lda_ex(); break;
1489         case 0xb7: sta_ex(); break;
1490         case 0xb8: eora_ex(); break;
1491         case 0xb9: adca_ex(); break;
1492         case 0xba: ora_ex(); break;
1493         case 0xbb: adda_ex(); break;
1494 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1495         case 0xbc: cpx_ex (); break;
1496 #else
1497         case 0xbc: cmpx_ex(); break;
1498 #endif
1499         case 0xbd: jsr_ex(); break;
1500         case 0xbe: lds_ex(); break;
1501         case 0xbf: sts_ex(); break;
1502         case 0xc0: subb_im(); break;
1503         case 0xc1: cmpb_im(); break;
1504         case 0xc2: sbcb_im(); break;
1505 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1506         case 0xc3: addd_im(); break;
1507 #else
1508         case 0xc3: illegal(); break;
1509 #endif
1510         case 0xc4: andb_im(); break;
1511         case 0xc5: bitb_im(); break;
1512         case 0xc6: ldb_im(); break;
1513         case 0xc7: stb_im(); break;
1514         case 0xc8: eorb_im(); break;
1515         case 0xc9: adcb_im(); break;
1516         case 0xca: orb_im(); break;
1517         case 0xcb: addb_im(); break;
1518 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1519         case 0xcc: ldd_im(); break;
1520         case 0xcd: std_im(); break;
1521 #else
1522         case 0xcc: illegal(); break;
1523         case 0xcd: illegal(); break;
1524 #endif
1525         case 0xce: ldx_im(); break;
1526         case 0xcf: stx_im(); break;
1527         case 0xd0: subb_di(); break;
1528         case 0xd1: cmpb_di(); break;
1529         case 0xd2: sbcb_di(); break;
1530 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1531         case 0xd3: addd_di(); break;
1532 #else
1533         case 0xd3: illegal(); break;
1534 #endif
1535         case 0xd4: andb_di(); break;
1536         case 0xd5: bitb_di(); break;
1537         case 0xd6: ldb_di(); break;
1538         case 0xd7: stb_di(); break;
1539         case 0xd8: eorb_di(); break;
1540         case 0xd9: adcb_di(); break;
1541         case 0xda: orb_di(); break;
1542         case 0xdb: addb_di(); break;
1543 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1544         case 0xdc: ldd_di(); break;
1545         case 0xdd: std_di(); break;
1546 #else
1547         case 0xdc: illegal(); break;
1548         case 0xdd: illegal(); break;
1549 #endif
1550         case 0xde: ldx_di(); break;
1551         case 0xdf: stx_di(); break;
1552         case 0xe0: subb_ix(); break;
1553         case 0xe1: cmpb_ix(); break;
1554         case 0xe2: sbcb_ix(); break;
1555 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1556         case 0xe3: addd_ix(); break;
1557 #else
1558         case 0xe3: illegal(); break;
1559 #endif
1560         case 0xe4: andb_ix(); break;
1561         case 0xe5: bitb_ix(); break;
1562         case 0xe6: ldb_ix(); break;
1563         case 0xe7: stb_ix(); break;
1564         case 0xe8: eorb_ix(); break;
1565         case 0xe9: adcb_ix(); break;
1566         case 0xea: orb_ix(); break;
1567         case 0xeb: addb_ix(); break;
1568 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1569         case 0xec: ldd_ix(); break;
1570         case 0xed: std_ix(); break;
1571 #elif defined(HAS_MB8861)
1572         case 0xec: adx_im(); break;
1573         case 0xed: illegal(); break;
1574 #else
1575         case 0xec: illegal(); break;
1576         case 0xed: illegal(); break;
1577 #endif
1578         case 0xee: ldx_ix(); break;
1579         case 0xef: stx_ix(); break;
1580         case 0xf0: subb_ex(); break;
1581         case 0xf1: cmpb_ex(); break;
1582         case 0xf2: sbcb_ex(); break;
1583 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1584         case 0xf3: addd_ex(); break;
1585 #else
1586         case 0xf3: illegal(); break;
1587 #endif
1588         case 0xf4: andb_ex(); break;
1589         case 0xf5: bitb_ex(); break;
1590         case 0xf6: ldb_ex(); break;
1591         case 0xf7: stb_ex(); break;
1592         case 0xf8: eorb_ex(); break;
1593         case 0xf9: adcb_ex(); break;
1594         case 0xfa: orb_ex(); break;
1595         case 0xfb: addb_ex(); break;
1596 #if defined(HAS_MC6801) || defined(HAS_HD6301)
1597         case 0xfc: ldd_ex(); break;
1598         case 0xfd: std_ex(); break;
1599 #elif defined(HAS_MB8861)
1600         case 0xfc: adx_ex(); break;
1601         case 0xfd: illegal(); break;
1602 #else
1603         case 0xfc: illegal(); break;
1604         case 0xfd: illegal(); break;
1605 #endif
1606         case 0xfe: ldx_ex(); break;
1607         case 0xff: stx_ex(); break;
1608 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
1609         default: __assume(0);
1610 #endif
1611         }
1612 }
1613
1614 /* operate one instruction for */
1615 #define ONE_MORE_INSN() { \
1616         uint8 ireg = M_RDOP(PCD); \
1617         prevpc = PC; \
1618         PC++; \
1619         insn(ireg); \
1620         increment_counter(cycles[ireg]); \
1621 }
1622
1623 /* $00 ILLEGAL */
1624 void MC6800::illegal()
1625 {
1626 #ifdef HAS_HD6301
1627         TAKE_TRAP;
1628 #endif
1629 }
1630
1631 /* $01 NOP */
1632 void MC6800::nop()
1633 {
1634
1635 }
1636
1637 /* $02 ILLEGAL */
1638
1639 /* $03 ILLEGAL */
1640
1641 /* $04 LSRD inherent -0*-* */
1642 void MC6800::lsrd()
1643 {
1644         uint16 t;
1645         CLR_NZC;
1646         t = D;
1647         CC |= (t & 0x0001);
1648         t >>= 1;
1649         SET_Z16(t);
1650         D = t;
1651 }
1652
1653 /* $05 ASLD inherent ?**** */
1654 void MC6800::asld()
1655 {
1656         int r;
1657         uint16 t;
1658         t = D;
1659         r = t << 1;
1660         CLR_NZVC;
1661         SET_FLAGS16(t, t, r);
1662         D = r;
1663 }
1664
1665 /* $06 TAP inherent ##### */
1666 void MC6800::tap()
1667 {
1668         CC = A;
1669         ONE_MORE_INSN();
1670 }
1671
1672 /* $07 TPA inherent ----- */
1673 void MC6800::tpa()
1674 {
1675         A = CC;
1676 }
1677
1678 /* $08 INX inherent --*-- */
1679 void MC6800::inx()
1680 {
1681         ++X;
1682         CLR_Z;
1683         SET_Z16(X);
1684 }
1685
1686 /* $09 DEX inherent --*-- */
1687 void MC6800::dex()
1688 {
1689         --X;
1690         CLR_Z;
1691         SET_Z16(X);
1692 }
1693
1694 /* $0a CLV */
1695 void MC6800::clv()
1696 {
1697         CLV;
1698 }
1699
1700 /* $0b SEV */
1701 void MC6800::sev()
1702 {
1703         SEV;
1704 }
1705
1706 /* $0c CLC */
1707 void MC6800::clc()
1708 {
1709         CLC;
1710 }
1711
1712 /* $0d SEC */
1713 void MC6800::sec()
1714 {
1715         SEC;
1716 }
1717
1718 /* $0e CLI */
1719 void MC6800::cli()
1720 {
1721         CLI;
1722         ONE_MORE_INSN();
1723 }
1724
1725 /* $0f SEI */
1726 void MC6800::sei()
1727 {
1728         SEI;
1729         ONE_MORE_INSN();
1730 }
1731
1732 /* $10 SBA inherent -**** */
1733 void MC6800::sba()
1734 {
1735         uint16 t;
1736         t = A - B;
1737         CLR_NZVC;
1738         SET_FLAGS8(A, B, t);
1739         A = (uint8)t;
1740 }
1741
1742 /* $11 CBA inherent -**** */
1743 void MC6800::cba()
1744 {
1745         uint16 t;
1746         t = A - B;
1747         CLR_NZVC;
1748         SET_FLAGS8(A, B, t);
1749 }
1750
1751 /* $12 ILLEGAL */
1752 void MC6800::undoc1()
1753 {
1754         X += RM(S + 1);
1755 }
1756
1757 /* $13 ILLEGAL */
1758 void MC6800::undoc2()
1759 {
1760         X += RM(S + 1);
1761 }
1762
1763 /* $14 ILLEGAL */
1764
1765 /* $15 ILLEGAL */
1766
1767 /* $16 TAB inherent -**0- */
1768 void MC6800::tab()
1769 {
1770         B=A;
1771         CLR_NZV;
1772         SET_NZ8(B);
1773 }
1774
1775 /* $17 TBA inherent -**0- */
1776 void MC6800::tba()
1777 {
1778         A = B;
1779         CLR_NZV;
1780         SET_NZ8(A);
1781 }
1782
1783 /* $18 XGDX inherent ----- */ /* HD6301 only */
1784 void MC6800::xgdx()
1785 {
1786         uint16 t = X;
1787         X = D;
1788         D = t;
1789 }
1790
1791 /* $19 DAA inherent (A) -**0* */
1792 void MC6800::daa()
1793 {
1794         uint8 msn, lsn;
1795         uint16 t, cf = 0;
1796         msn = A & 0xf0;
1797         lsn = A & 0x0f;
1798         if(lsn > 0x09 || CC & 0x20) {
1799                 cf |= 0x06;
1800         }
1801         if(msn > 0x80 && lsn > 0x09) {
1802                 cf |= 0x60;
1803         }
1804         if(msn > 0x90 || (CC & 0x01)) {
1805                 cf |= 0x60;
1806         }
1807         t = cf + A;
1808         CLR_NZV; /* keep carry from previous operation */
1809         SET_NZ8((uint8)t);
1810         SET_C8(t);
1811         A = (uint8)t;
1812 }
1813
1814 /* $1a ILLEGAL */
1815
1816 /* $1a SLP */ /* HD6301 only */
1817 void MC6800::slp()
1818 {
1819         /* wait for next IRQ (same as waiting of wai) */
1820         wai_state |= HD6301_SLP;
1821 }
1822
1823 /* $1b ABA inherent ***** */
1824 void MC6800::aba()
1825 {
1826         uint16 t;
1827         t = A + B;
1828         CLR_HNZVC;
1829         SET_FLAGS8(A, B, t);
1830         SET_H(A, B, t);
1831         A = (uint8)t;
1832 }
1833
1834 /* $1c ILLEGAL */
1835
1836 /* $1d ILLEGAL */
1837
1838 /* $1e ILLEGAL */
1839
1840 /* $1f ILLEGAL */
1841
1842 /* $20 BRA relative ----- */
1843 void MC6800::bra()
1844 {
1845         uint8 t;
1846         IMMBYTE(t);
1847         PC += SIGNED(t);
1848 }
1849
1850 /* $21 BRN relative ----- */
1851 void MC6800::brn()
1852 {
1853         uint8 t;
1854         IMMBYTE(t);
1855 }
1856
1857 /* $22 BHI relative ----- */
1858 void MC6800::bhi()
1859 {
1860         uint8 t;
1861         BRANCH(!(CC & 0x05));
1862 }
1863
1864 /* $23 BLS relative ----- */
1865 void MC6800::bls()
1866 {
1867         uint8 t;
1868         BRANCH(CC & 0x05);
1869 }
1870
1871 /* $24 BCC relative ----- */
1872 void MC6800::bcc()
1873 {
1874         uint8 t;
1875         BRANCH(!(CC & 0x01));
1876 }
1877
1878 /* $25 BCS relative ----- */
1879 void MC6800::bcs()
1880 {
1881         uint8 t;
1882         BRANCH(CC & 0x01);
1883 }
1884
1885 /* $26 BNE relative ----- */
1886 void MC6800::bne()
1887 {
1888         uint8 t;
1889         BRANCH(!(CC & 0x04));
1890 }
1891
1892 /* $27 BEQ relative ----- */
1893 void MC6800::beq()
1894 {
1895         uint8 t;
1896         BRANCH(CC & 0x04);
1897 }
1898
1899 /* $28 BVC relative ----- */
1900 void MC6800::bvc()
1901 {
1902         uint8 t;
1903         BRANCH(!(CC & 0x02));
1904 }
1905
1906 /* $29 BVS relative ----- */
1907 void MC6800::bvs()
1908 {
1909         uint8 t;
1910         BRANCH(CC & 0x02);
1911 }
1912
1913 /* $2a BPL relative ----- */
1914 void MC6800::bpl()
1915 {
1916         uint8 t;
1917         BRANCH(!(CC & 0x08));
1918 }
1919
1920 /* $2b BMI relative ----- */
1921 void MC6800::bmi()
1922 {
1923         uint8 t;
1924         BRANCH(CC & 0x08);
1925 }
1926
1927 /* $2c BGE relative ----- */
1928 void MC6800::bge()
1929 {
1930         uint8 t;
1931         BRANCH(!NXORV);
1932 }
1933
1934 /* $2d BLT relative ----- */
1935 void MC6800::blt()
1936 {
1937         uint8 t;
1938         BRANCH(NXORV);
1939 }
1940
1941 /* $2e BGT relative ----- */
1942 void MC6800::bgt()
1943 {
1944         uint8 t;
1945         BRANCH(!(NXORV||CC & 0x04));
1946 }
1947
1948 /* $2f BLE relative ----- */
1949 void MC6800::ble()
1950 {
1951         uint8 t;
1952         BRANCH(NXORV||CC & 0x04);
1953 }
1954
1955 /* $30 TSX inherent ----- */
1956 void MC6800::tsx()
1957 {
1958         X = (S + 1);
1959 }
1960
1961 /* $31 INS inherent ----- */
1962 void MC6800::ins()
1963 {
1964         ++S;
1965 }
1966
1967 /* $32 PULA inherent ----- */
1968 void MC6800::pula()
1969 {
1970         PULLBYTE(A);
1971 }
1972
1973 /* $33 PULB inherent ----- */
1974 void MC6800::pulb()
1975 {
1976         PULLBYTE(B);
1977 }
1978
1979 /* $34 DES inherent ----- */
1980 void MC6800::des()
1981 {
1982         --S;
1983 }
1984
1985 /* $35 TXS inherent ----- */
1986 void MC6800::txs()
1987 {
1988         S = (X - 1);
1989 }
1990
1991 /* $36 PSHA inherent ----- */
1992 void MC6800::psha()
1993 {
1994         PUSHBYTE(A);
1995 }
1996
1997 /* $37 PSHB inherent ----- */
1998 void MC6800::pshb()
1999 {
2000         PUSHBYTE(B);
2001 }
2002
2003 /* $38 PULX inherent ----- */
2004 void MC6800::pulx()
2005 {
2006         PULLWORD(pX);
2007 }
2008
2009 /* $39 RTS inherent ----- */
2010 void MC6800::rts()
2011 {
2012         PULLWORD(pPC);
2013 }
2014
2015 /* $3a ABX inherent ----- */
2016 void MC6800::abx()
2017 {
2018         X += B;
2019 }
2020
2021 /* $3b RTI inherent ##### */
2022 void MC6800::rti()
2023 {
2024         PULLBYTE(CC);
2025         PULLBYTE(B);
2026         PULLBYTE(A);
2027         PULLWORD(pX);
2028         PULLWORD(pPC);
2029 }
2030
2031 /* $3c PSHX inherent ----- */
2032 void MC6800::pshx()
2033 {
2034         PUSHWORD(pX);
2035 }
2036
2037 /* $3d MUL inherent --*-@ */
2038 void MC6800::mul()
2039 {
2040         uint16 t;
2041         t = A*B;
2042         CLR_C;
2043         if(t & 0x80) SEC;
2044         D = t;
2045 }
2046
2047 /* $3e WAI inherent ----- */
2048 void MC6800::wai()
2049 {
2050         /*
2051          * WAI stacks the entire machine state on the
2052          * hardware stack, then waits for an interrupt.
2053          */
2054         wai_state |= MC6800_WAI;
2055         PUSHWORD(pPC);
2056         PUSHWORD(pX);
2057         PUSHBYTE(A);
2058         PUSHBYTE(B);
2059         PUSHBYTE(CC);
2060 }
2061
2062 /* $3f SWI absolute indirect ----- */
2063 void MC6800::swi()
2064 {
2065         PUSHWORD(pPC);
2066         PUSHWORD(pX);
2067         PUSHBYTE(A);
2068         PUSHBYTE(B);
2069         PUSHBYTE(CC);
2070         SEI;
2071         PCD = RM16(0xfffa);
2072 }
2073
2074 /* $40 NEGA inherent ?**** */
2075 void MC6800::nega()
2076 {
2077         uint16 r;
2078         r = -A;
2079         CLR_NZVC;
2080         SET_FLAGS8(0, A, r);
2081         A = (uint8)r;
2082 }
2083
2084 /* $41 ILLEGAL */
2085
2086 /* $42 ILLEGAL */
2087
2088 /* $43 COMA inherent -**01 */
2089 void MC6800::coma()
2090 {
2091         A = ~A;
2092         CLR_NZV;
2093         SET_NZ8(A);
2094         SEC;
2095 }
2096
2097 /* $44 LSRA inherent -0*-* */
2098 void MC6800::lsra()
2099 {
2100         CLR_NZC;
2101         CC |= (A & 0x01);
2102         A >>= 1;
2103         SET_Z8(A);
2104 }
2105
2106 /* $45 ILLEGAL */
2107
2108 /* $46 RORA inherent -**-* */
2109 void MC6800::rora()
2110 {
2111         uint8 r;
2112         r = (CC & 0x01) << 7;
2113         CLR_NZC;
2114         CC |= (A & 0x01);
2115         r |= A >> 1;
2116         SET_NZ8(r);
2117         A = r;
2118 }
2119
2120 /* $47 ASRA inherent ?**-* */
2121 void MC6800::asra()
2122 {
2123         CLR_NZC;
2124         CC |= (A & 0x01);
2125         A >>= 1;
2126         A |= ((A & 0x40) << 1);
2127         SET_NZ8(A);
2128 }
2129
2130 /* $48 ASLA inherent ?**** */
2131 void MC6800::asla()
2132 {
2133         uint16 r;
2134         r = A << 1;
2135         CLR_NZVC;
2136         SET_FLAGS8(A, A, r);
2137         A = (uint8)r;
2138 }
2139
2140 /* $49 ROLA inherent -**** */
2141 void MC6800::rola()
2142 {
2143         uint16 t, r;
2144         t = A;
2145         r = CC & 0x01;
2146         r |= t << 1;
2147         CLR_NZVC;
2148         SET_FLAGS8(t, t, r);
2149         A = (uint8)r;
2150 }
2151
2152 /* $4a DECA inherent -***- */
2153 void MC6800::deca()
2154 {
2155         --A;
2156         CLR_NZV;
2157         SET_FLAGS8D(A);
2158 }
2159
2160 /* $4b ILLEGAL */
2161
2162 /* $4c INCA inherent -***- */
2163 void MC6800::inca()
2164 {
2165         ++A;
2166         CLR_NZV;
2167         SET_FLAGS8I(A);
2168 }
2169
2170 /* $4d TSTA inherent -**0- */
2171 void MC6800::tsta()
2172 {
2173         CLR_NZVC;
2174         SET_NZ8(A);
2175 }
2176
2177 /* $4e ILLEGAL */
2178
2179 /* $4f CLRA inherent -0100 */
2180 void MC6800::clra()
2181 {
2182         A = 0;
2183         CLR_NZVC;
2184         SEZ;
2185 }
2186
2187 /* $50 NEGB inherent ?**** */
2188 void MC6800::negb()
2189 {
2190         uint16 r;
2191         r = -B;
2192         CLR_NZVC;
2193         SET_FLAGS8(0, B, r);
2194         B = (uint8)r;
2195 }
2196
2197 /* $51 ILLEGAL */
2198
2199 /* $52 ILLEGAL */
2200
2201 /* $53 COMB inherent -**01 */
2202 void MC6800::comb()
2203 {
2204         B = ~B;
2205         CLR_NZV;
2206         SET_NZ8(B);
2207         SEC;
2208 }
2209
2210 /* $54 LSRB inherent -0*-* */
2211 void MC6800::lsrb()
2212 {
2213         CLR_NZC;
2214         CC |= (B & 0x01);
2215         B >>= 1;
2216         SET_Z8(B);
2217 }
2218
2219 /* $55 ILLEGAL */
2220
2221 /* $56 RORB inherent -**-* */
2222 void MC6800::rorb()
2223 {
2224         uint8 r;
2225         r = (CC & 0x01) << 7;
2226         CLR_NZC;
2227         CC |= (B & 0x01);
2228         r |= B >> 1;
2229         SET_NZ8(r);
2230         B = r;
2231 }
2232
2233 /* $57 ASRB inherent ?**-* */
2234 void MC6800::asrb()
2235 {
2236         CLR_NZC;
2237         CC |= (B & 0x01);
2238         B >>= 1;
2239         B |= ((B & 0x40) << 1);
2240         SET_NZ8(B);
2241 }
2242
2243 /* $58 ASLB inherent ?**** */
2244 void MC6800::aslb()
2245 {
2246         uint16 r;
2247         r = B << 1;
2248         CLR_NZVC;
2249         SET_FLAGS8(B, B, r);
2250         B = (uint8)r;
2251 }
2252
2253 /* $59 ROLB inherent -**** */
2254 void MC6800::rolb()
2255 {
2256         uint16 t, r;
2257         t = B;
2258         r = CC & 0x01;
2259         r |= t << 1;
2260         CLR_NZVC;
2261         SET_FLAGS8(t, t, r);
2262         B = (uint8)r;
2263 }
2264
2265 /* $5a DECB inherent -***- */
2266 void MC6800::decb()
2267 {
2268         --B;
2269         CLR_NZV;
2270         SET_FLAGS8D(B);
2271 }
2272
2273 /* $5b ILLEGAL */
2274
2275 /* $5c INCB inherent -***- */
2276 void MC6800::incb()
2277 {
2278         ++B;
2279         CLR_NZV;
2280         SET_FLAGS8I(B);
2281 }
2282
2283 /* $5d TSTB inherent -**0- */
2284 void MC6800::tstb()
2285 {
2286         CLR_NZVC;
2287         SET_NZ8(B);
2288 }
2289
2290 /* $5e ILLEGAL */
2291
2292 /* $5f CLRB inherent -0100 */
2293 void MC6800::clrb()
2294 {
2295         B=0;
2296         CLR_NZVC;
2297         SEZ;
2298 }
2299
2300 /* $60 NEG indexed ?**** */
2301 void MC6800::neg_ix()
2302 {
2303         uint16 r, t;
2304         IDXBYTE(t);
2305         r = -t;
2306         CLR_NZVC;
2307         SET_FLAGS8(0, t, r);
2308         WM(EAD, r);
2309 }
2310
2311 /* $61 AIM --**0- */ /* HD6301 only */
2312 void MC6800::aim_ix()
2313 {
2314         uint8 t, r;
2315         IMMBYTE(t);
2316         IDXBYTE(r);
2317         r &= t;
2318         CLR_NZV;
2319         SET_NZ8(r);
2320         WM(EAD, r);
2321 }
2322
2323 /* $62 OIM --**0- */ /* HD6301 only */
2324 void MC6800::oim_ix()
2325 {
2326         uint8 t, r;
2327         IMMBYTE(t);
2328         IDXBYTE(r);
2329         r |= t;
2330         CLR_NZV;
2331         SET_NZ8(r);
2332         WM(EAD, r);
2333 }
2334
2335 /* $63 COM indexed -**01 */
2336 void MC6800::com_ix()
2337 {
2338         uint8 t;
2339         IDXBYTE(t);
2340         t = ~t;
2341         CLR_NZV;
2342         SET_NZ8(t);
2343         SEC;
2344         WM(EAD, t);
2345 }
2346
2347 /* $64 LSR indexed -0*-* */
2348 void MC6800::lsr_ix()
2349 {
2350         uint8 t;
2351         IDXBYTE(t);
2352         CLR_NZC;
2353         CC |= (t & 0x01);
2354         t >>= 1;
2355         SET_Z8(t);
2356         WM(EAD, t);
2357 }
2358
2359 /* $65 EIM --**0- */ /* HD6301 only */
2360 void MC6800::eim_ix()
2361 {
2362         uint8 t, r;
2363         IMMBYTE(t);
2364         IDXBYTE(r);
2365         r ^= t;
2366         CLR_NZV;
2367         SET_NZ8(r);
2368         WM(EAD, r);
2369 }
2370
2371 /* $66 ROR indexed -**-* */
2372 void MC6800::ror_ix()
2373 {
2374         uint8 t, r;
2375         IDXBYTE(t);
2376         r = (CC & 0x01) << 7;
2377         CLR_NZC;
2378         CC |= (t & 0x01);
2379         r |= t >> 1;
2380         SET_NZ8(r);
2381         WM(EAD, r);
2382 }
2383
2384 /* $67 ASR indexed ?**-* */
2385 void MC6800::asr_ix()
2386 {
2387         uint8 t;
2388         IDXBYTE(t);
2389         CLR_NZC;
2390         CC |= (t & 0x01);
2391         t >>= 1;
2392         t |= ((t & 0x40) << 1);
2393         SET_NZ8(t);
2394         WM(EAD, t);
2395 }
2396
2397 /* $68 ASL indexed ?**** */
2398 void MC6800::asl_ix()
2399 {
2400         uint16 t, r;
2401         IDXBYTE(t);
2402         r = t << 1;
2403         CLR_NZVC;
2404         SET_FLAGS8(t, t, r);
2405         WM(EAD, r);
2406 }
2407
2408 /* $69 ROL indexed -**** */
2409 void MC6800::rol_ix()
2410 {
2411         uint16 t, r;
2412         IDXBYTE(t);
2413         r = CC & 0x01;
2414         r |= t << 1;
2415         CLR_NZVC;
2416         SET_FLAGS8(t, t, r);
2417         WM(EAD, r);
2418 }
2419
2420 /* $6a DEC indexed -***- */
2421 void MC6800::dec_ix()
2422 {
2423         uint8 t;
2424         IDXBYTE(t);
2425         --t;
2426         CLR_NZV;
2427         SET_FLAGS8D(t);
2428         WM(EAD, t);
2429 }
2430
2431 /* $6b TIM --**0- */ /* HD6301 only */
2432 void MC6800::tim_ix()
2433 {
2434         uint8 t, r;
2435         IMMBYTE(t);
2436         IDXBYTE(r);
2437         r &= t;
2438         CLR_NZV;
2439         SET_NZ8(r);
2440 }
2441
2442 /* $6c INC indexed -***- */
2443 void MC6800::inc_ix()
2444 {
2445         uint8 t;
2446         IDXBYTE(t);
2447         ++t;
2448         CLR_NZV;
2449         SET_FLAGS8I(t);
2450         WM(EAD, t);
2451 }
2452
2453 /* $6d TST indexed -**0- */
2454 void MC6800::tst_ix()
2455 {
2456         uint8 t;
2457         IDXBYTE(t);
2458         CLR_NZVC;
2459         SET_NZ8(t);
2460 }
2461
2462 /* $6e JMP indexed ----- */
2463 void MC6800::jmp_ix()
2464 {
2465         INDEXED;
2466         PC = EA;
2467 }
2468
2469 /* $6f CLR indexed -0100 */
2470 void MC6800::clr_ix()
2471 {
2472         INDEXED;
2473         WM(EAD, 0);
2474         CLR_NZVC;
2475         SEZ;
2476 }
2477
2478 /* $70 NEG extended ?**** */
2479 void MC6800::neg_ex()
2480 {
2481         uint16 r, t;
2482         EXTBYTE(t);
2483         r = -t;
2484         CLR_NZVC;
2485         SET_FLAGS8(0, t, r);
2486         WM(EAD, r);
2487 }
2488
2489 /* $71 AIM --**0- */ /* HD6301 only */
2490 void MC6800::aim_di()
2491 {
2492         uint8 t, r;
2493         IMMBYTE(t);
2494         DIRBYTE(r);
2495         r &= t;
2496         CLR_NZV;
2497         SET_NZ8(r);
2498         WM(EAD, r);
2499 }
2500
2501 /* $71 NIM --**0- */ /* MB8861 only */
2502 void MC6800::nim_ix()
2503 {
2504         uint8 t, r;
2505         IMMBYTE(t);
2506         IDXBYTE(r);
2507         r &= t;
2508         CLR_NZV;
2509         if(!r) {
2510                 SEZ;
2511         } else {
2512                 SEN;
2513         }
2514         WM(EAD, r);
2515 }
2516
2517 /* $72 OIM --**0- */ /* HD6301 only */
2518 void MC6800::oim_di()
2519 {
2520         uint8 t, r;
2521         IMMBYTE(t);
2522         DIRBYTE(r);
2523         r |= t;
2524         CLR_NZV;
2525         SET_NZ8(r);
2526         WM(EAD, r);
2527 }
2528
2529 /* $72 OIM --**0- */ /* MB8861 only */
2530 void MC6800::oim_ix_mb8861()
2531 {
2532         uint8 t, r;
2533         IMMBYTE(t);
2534         IDXBYTE(r);
2535         r |= t;
2536         CLR_NZV;
2537         if(!r) {
2538                 SEZ;
2539         } else {
2540                 SEN;
2541         }
2542         WM(EAD, r);
2543 }
2544
2545 /* $73 COM extended -**01 */
2546 void MC6800::com_ex()
2547 {
2548         uint8 t;
2549         EXTBYTE(t);
2550         t = ~t;
2551         CLR_NZV;
2552         SET_NZ8(t);
2553         SEC;
2554         WM(EAD, t);
2555 }
2556
2557 /* $74 LSR extended -0*-* */
2558 void MC6800::lsr_ex()
2559 {
2560         uint8 t;
2561         EXTBYTE(t);
2562         CLR_NZC;
2563         CC |= (t & 0x01);
2564         t >>= 1;
2565         SET_Z8(t);
2566         WM(EAD, t);
2567 }
2568
2569 /* $75 EIM --**0- */ /* HD6301 only */
2570 void MC6800::eim_di()
2571 {
2572         uint8 t, r;
2573         IMMBYTE(t);
2574         DIRBYTE(r);
2575         r ^= t;
2576         CLR_NZV;
2577         SET_NZ8(r);
2578         WM(EAD, r);
2579 }
2580
2581 /* $75 XIM --**-- */ /* MB8861 only */
2582 void MC6800::xim_ix()
2583 {
2584         uint8 t, r;
2585         IMMBYTE(t);
2586         IDXBYTE(r);
2587         r ^= t;
2588         CLR_NZ;
2589         if(!r) {
2590                 SEZ;
2591         } else {
2592                 SEN;
2593         }
2594         WM(EAD, r);
2595 }
2596
2597 /* $76 ROR extended -**-* */
2598 void MC6800::ror_ex()
2599 {
2600         uint8 t, r;
2601         EXTBYTE(t);
2602         r = (CC & 0x01) << 7;
2603         CLR_NZC;
2604         CC |= (t & 0x01);
2605         r |= t >> 1;
2606         SET_NZ8(r);
2607         WM(EAD, r);
2608 }
2609
2610 /* $77 ASR extended ?**-* */
2611 void MC6800::asr_ex()
2612 {
2613         uint8 t;
2614         EXTBYTE(t);
2615         CLR_NZC;
2616         CC |= (t & 0x01);
2617         t >>= 1;
2618         t |= ((t & 0x40) << 1);
2619         SET_NZ8(t);
2620         WM(EAD, t);
2621 }
2622
2623 /* $78 ASL extended ?**** */
2624 void MC6800::asl_ex()
2625 {
2626         uint16 t, r;
2627         EXTBYTE(t);
2628         r = t << 1;
2629         CLR_NZVC;
2630         SET_FLAGS8(t, t, r);
2631         WM(EAD, r);
2632 }
2633
2634 /* $79 ROL extended -**** */
2635 void MC6800::rol_ex()
2636 {
2637         uint16 t, r;
2638         EXTBYTE(t);
2639         r = CC & 0x01;
2640         r |= t << 1;
2641         CLR_NZVC;
2642         SET_FLAGS8(t, t, r);
2643         WM(EAD, r);
2644 }
2645
2646 /* $7a DEC extended -***- */
2647 void MC6800::dec_ex()
2648 {
2649         uint8 t;
2650         EXTBYTE(t);
2651         --t;
2652         CLR_NZV;
2653         SET_FLAGS8D(t);
2654         WM(EAD, t);
2655 }
2656
2657 /* $7b TIM --**0- */ /* HD6301 only */
2658 void MC6800::tim_di()
2659 {
2660         uint8 t, r;
2661         IMMBYTE(t);
2662         DIRBYTE(r);
2663         r &= t;
2664         CLR_NZV;
2665         SET_NZ8(r);
2666 }
2667
2668 /* $7b TMM --***- */ /* MB8861 only */
2669 void MC6800::tmm_ix()
2670 {
2671         uint8 t, r;
2672         IMMBYTE(t);
2673         IDXBYTE(r);
2674         r &= t;
2675         CLR_NZV;
2676         if(!t || !r) {
2677                 SEZ;
2678         } else if(r == t) {
2679                 SEV;
2680         } else {
2681                 SEN;
2682         }
2683 }
2684
2685 /* $7c INC extended -***- */
2686 void MC6800::inc_ex()
2687 {
2688         uint8 t;
2689         EXTBYTE(t);
2690         ++t;
2691         CLR_NZV;
2692         SET_FLAGS8I(t);
2693         WM(EAD, t);
2694 }
2695
2696 /* $7d TST extended -**0- */
2697 void MC6800::tst_ex()
2698 {
2699         uint8 t;
2700         EXTBYTE(t);
2701         CLR_NZVC;
2702         SET_NZ8(t);
2703 }
2704
2705 /* $7e JMP extended ----- */
2706 void MC6800::jmp_ex()
2707 {
2708         EXTENDED;
2709         PC = EA;
2710 }
2711
2712 /* $7f CLR extended -0100 */
2713 void MC6800::clr_ex()
2714 {
2715         EXTENDED;
2716         WM(EAD, 0);
2717         CLR_NZVC;
2718         SEZ;
2719 }
2720
2721 /* $80 SUBA immediate ?**** */
2722 void MC6800::suba_im()
2723 {
2724         uint16 t, r;
2725         IMMBYTE(t);
2726         r = A - t;
2727         CLR_NZVC;
2728         SET_FLAGS8(A, t, r);
2729         A = (uint8)r;
2730 }
2731
2732 /* $81 CMPA immediate ?**** */
2733 void MC6800::cmpa_im()
2734 {
2735         uint16 t, r;
2736         IMMBYTE(t);
2737         r = A - t;
2738         CLR_NZVC;
2739         SET_FLAGS8(A, t, r);
2740 }
2741
2742 /* $82 SBCA immediate ?**** */
2743 void MC6800::sbca_im()
2744 {
2745         uint16 t, r;
2746         IMMBYTE(t);
2747         r = A - t - (CC & 0x01);
2748         CLR_NZVC;
2749         SET_FLAGS8(A, t, r);
2750         A = (uint8)r;
2751 }
2752
2753 /* $83 SUBD immediate -**** */
2754 void MC6800::subd_im()
2755 {
2756         uint32 r, d;
2757         pair b;
2758         IMMWORD(b);
2759         d = D;
2760         r = d - b.d;
2761         CLR_NZVC;
2762         SET_FLAGS16(d, b.d, r);
2763         D = r;
2764 }
2765
2766 /* $84 ANDA immediate -**0- */
2767 void MC6800::anda_im()
2768 {
2769         uint8 t;
2770         IMMBYTE(t);
2771         A &= t;
2772         CLR_NZV;
2773         SET_NZ8(A);
2774 }
2775
2776 /* $85 BITA immediate -**0- */
2777 void MC6800::bita_im()
2778 {
2779         uint8 t, r;
2780         IMMBYTE(t);
2781         r = A & t;
2782         CLR_NZV;
2783         SET_NZ8(r);
2784 }
2785
2786 /* $86 LDA immediate -**0- */
2787 void MC6800::lda_im()
2788 {
2789         IMMBYTE(A);
2790         CLR_NZV;
2791         SET_NZ8(A);
2792 }
2793
2794 /* is this a legal instruction? */
2795 /* $87 STA immediate -**0- */
2796 void MC6800::sta_im()
2797 {
2798         CLR_NZV;
2799         SET_NZ8(A);
2800         IMM8;
2801         WM(EAD, A);
2802 }
2803
2804 /* $88 EORA immediate -**0- */
2805 void MC6800::eora_im()
2806 {
2807         uint8 t;
2808         IMMBYTE(t);
2809         A ^= t;
2810         CLR_NZV;
2811         SET_NZ8(A);
2812 }
2813
2814 /* $89 ADCA immediate ***** */
2815 void MC6800::adca_im()
2816 {
2817         uint16 t, r;
2818         IMMBYTE(t);
2819         r = A + t + (CC & 0x01);
2820         CLR_HNZVC;
2821         SET_FLAGS8(A, t, r);
2822         SET_H(A, t, r);
2823         A = (uint8)r;
2824 }
2825
2826 /* $8a ORA immediate -**0- */
2827 void MC6800::ora_im()
2828 {
2829         uint8 t;
2830         IMMBYTE(t);
2831         A |= t;
2832         CLR_NZV;
2833         SET_NZ8(A);
2834 }
2835
2836 /* $8b ADDA immediate ***** */
2837 void MC6800::adda_im()
2838 {
2839         uint16 t, r;
2840         IMMBYTE(t);
2841         r = A + t;
2842         CLR_HNZVC;
2843         SET_FLAGS8(A, t, r);
2844         SET_H(A, t, r);
2845         A = (uint8)r;
2846 }
2847
2848 /* $8c CMPX immediate -***- */
2849 void MC6800::cmpx_im()
2850 {
2851         uint32 r, d;
2852         pair b;
2853         IMMWORD(b);
2854         d = X;
2855         r = d - b.d;
2856         CLR_NZV;
2857         SET_NZ16(r);
2858         SET_V16(d, b.d, r);
2859 }
2860
2861 /* $8c CPX immediate -**** (6801) */
2862 void MC6800::cpx_im()
2863 {
2864         uint32 r, d;
2865         pair b;
2866         IMMWORD(b);
2867         d = X;
2868         r = d - b.d;
2869         CLR_NZVC;
2870         SET_FLAGS16(d, b.d, r);
2871 }
2872
2873
2874 /* $8d BSR ----- */
2875 void MC6800::bsr()
2876 {
2877         uint8 t;
2878         IMMBYTE(t);
2879         PUSHWORD(pPC);
2880         PC += SIGNED(t);
2881 }
2882
2883 /* $8e LDS immediate -**0- */
2884 void MC6800::lds_im()
2885 {
2886         IMMWORD(pS);
2887         CLR_NZV;
2888         SET_NZ16(S);
2889 }
2890
2891 /* $8f STS immediate -**0- */
2892 void MC6800::sts_im()
2893 {
2894         CLR_NZV;
2895         SET_NZ16(S);
2896         IMM16;
2897         WM16(EAD, &pS);
2898 }
2899
2900 /* $90 SUBA direct ?**** */
2901 void MC6800::suba_di()
2902 {
2903         uint16 t, r;
2904         DIRBYTE(t);
2905         r = A - t;
2906         CLR_NZVC;
2907         SET_FLAGS8(A, t, r);
2908         A = (uint8)r;
2909 }
2910
2911 /* $91 CMPA direct ?**** */
2912 void MC6800::cmpa_di()
2913 {
2914         uint16 t, r;
2915         DIRBYTE(t);
2916         r = A - t;
2917         CLR_NZVC;
2918         SET_FLAGS8(A, t, r);
2919 }
2920
2921 /* $92 SBCA direct ?**** */
2922 void MC6800::sbca_di()
2923 {
2924         uint16 t, r;
2925         DIRBYTE(t);
2926         r = A - t - (CC & 0x01);
2927         CLR_NZVC;
2928         SET_FLAGS8(A, t, r);
2929         A = (uint8)r;
2930 }
2931
2932 /* $93 SUBD direct -**** */
2933 void MC6800::subd_di()
2934 {
2935         uint32 r, d;
2936         pair b;
2937         DIRWORD(b);
2938         d = D;
2939         r = d - b.d;
2940         CLR_NZVC;
2941         SET_FLAGS16(d, b.d, r);
2942         D = r;
2943 }
2944
2945 /* $94 ANDA direct -**0- */
2946 void MC6800::anda_di()
2947 {
2948         uint8 t;
2949         DIRBYTE(t);
2950         A &= t;
2951         CLR_NZV;
2952         SET_NZ8(A);
2953 }
2954
2955 /* $95 BITA direct -**0- */
2956 void MC6800::bita_di()
2957 {
2958         uint8 t, r;
2959         DIRBYTE(t);
2960         r = A & t;
2961         CLR_NZV;
2962         SET_NZ8(r);
2963 }
2964
2965 /* $96 LDA direct -**0- */
2966 void MC6800::lda_di()
2967 {
2968         DIRBYTE(A);
2969         CLR_NZV;
2970         SET_NZ8(A);
2971 }
2972
2973 /* $97 STA direct -**0- */
2974 void MC6800::sta_di()
2975 {
2976         CLR_NZV;
2977         SET_NZ8(A);
2978         DIRECT;
2979         WM(EAD, A);
2980 }
2981
2982 /* $98 EORA direct -**0- */
2983 void MC6800::eora_di()
2984 {
2985         uint8 t;
2986         DIRBYTE(t);
2987         A ^= t;
2988         CLR_NZV;
2989         SET_NZ8(A);
2990 }
2991
2992 /* $99 ADCA direct ***** */
2993 void MC6800::adca_di()
2994 {
2995         uint16 t, r;
2996         DIRBYTE(t);
2997         r = A + t + (CC & 0x01);
2998         CLR_HNZVC;
2999         SET_FLAGS8(A, t, r);
3000         SET_H(A, t, r);
3001         A = (uint8)r;
3002 }
3003
3004 /* $9a ORA direct -**0- */
3005 void MC6800::ora_di()
3006 {
3007         uint8 t;
3008         DIRBYTE(t);
3009         A |= t;
3010         CLR_NZV;
3011         SET_NZ8(A);
3012 }
3013
3014 /* $9b ADDA direct ***** */
3015 void MC6800::adda_di()
3016 {
3017         uint16 t, r;
3018         DIRBYTE(t);
3019         r = A + t;
3020         CLR_HNZVC;
3021         SET_FLAGS8(A, t, r);
3022         SET_H(A, t, r);
3023         A = (uint8)r;
3024 }
3025
3026 /* $9c CMPX direct -***- */
3027 void MC6800::cmpx_di()
3028 {
3029         uint32 r, d;
3030         pair b;
3031         DIRWORD(b);
3032         d = X;
3033         r = d - b.d;
3034         CLR_NZV;
3035         SET_NZ16(r);
3036         SET_V16(d, b.d, r);
3037 }
3038
3039 /* $9c CPX direct -**** (6801) */
3040 void MC6800::cpx_di()
3041 {
3042         uint32 r, d;
3043         pair b;
3044         DIRWORD(b);
3045         d = X;
3046         r = d - b.d;
3047         CLR_NZVC;
3048         SET_FLAGS16(d, b.d, r);
3049 }
3050
3051 /* $9d JSR direct ----- */
3052 void MC6800::jsr_di()
3053 {
3054         DIRECT;
3055         PUSHWORD(pPC);
3056         PC = EA;
3057 }
3058
3059 /* $9e LDS direct -**0- */
3060 void MC6800::lds_di()
3061 {
3062         DIRWORD(pS);
3063         CLR_NZV;
3064         SET_NZ16(S);
3065 }
3066
3067 /* $9f STS direct -**0- */
3068 void MC6800::sts_di()
3069 {
3070         CLR_NZV;
3071         SET_NZ16(S);
3072         DIRECT;
3073         WM16(EAD, &pS);
3074 }
3075
3076 /* $a0 SUBA indexed ?**** */
3077 void MC6800::suba_ix()
3078 {
3079         uint16 t, r;
3080         IDXBYTE(t);
3081         r = A - t;
3082         CLR_NZVC;
3083         SET_FLAGS8(A, t, r);
3084         A = (uint8)r;
3085 }
3086
3087 /* $a1 CMPA indexed ?**** */
3088 void MC6800::cmpa_ix()
3089 {
3090         uint16 t, r;
3091         IDXBYTE(t);
3092         r = A - t;
3093         CLR_NZVC;
3094         SET_FLAGS8(A, t, r);
3095 }
3096
3097 /* $a2 SBCA indexed ?**** */
3098 void MC6800::sbca_ix()
3099 {
3100         uint16 t, r;
3101         IDXBYTE(t);
3102         r = A - t - (CC & 0x01);
3103         CLR_NZVC;
3104         SET_FLAGS8(A, t, r);
3105         A = (uint8)r;
3106 }
3107
3108 /* $a3 SUBD indexed -**** */
3109 void MC6800::subd_ix()
3110 {
3111         uint32 r, d;
3112         pair b;
3113         IDXWORD(b);
3114         d = D;
3115         r = d - b.d;
3116         CLR_NZVC;
3117         SET_FLAGS16(d, b.d, r);
3118         D = r;
3119 }
3120
3121 /* $a4 ANDA indexed -**0- */
3122 void MC6800::anda_ix()
3123 {
3124         uint8 t;
3125         IDXBYTE(t);
3126         A &= t;
3127         CLR_NZV;
3128         SET_NZ8(A);
3129 }
3130
3131 /* $a5 BITA indexed -**0- */
3132 void MC6800::bita_ix()
3133 {
3134         uint8 t, r;
3135         IDXBYTE(t);
3136         r = A & t;
3137         CLR_NZV;
3138         SET_NZ8(r);
3139 }
3140
3141 /* $a6 LDA indexed -**0- */
3142 void MC6800::lda_ix()
3143 {
3144         IDXBYTE(A);
3145         CLR_NZV;
3146         SET_NZ8(A);
3147 }
3148
3149 /* $a7 STA indexed -**0- */
3150 void MC6800::sta_ix()
3151 {
3152         CLR_NZV;
3153         SET_NZ8(A);
3154         INDEXED;
3155         WM(EAD, A);
3156 }
3157
3158 /* $a8 EORA indexed -**0- */
3159 void MC6800::eora_ix()
3160 {
3161         uint8 t;
3162         IDXBYTE(t);
3163         A ^= t;
3164         CLR_NZV;
3165         SET_NZ8(A);
3166 }
3167
3168 /* $a9 ADCA indexed ***** */
3169 void MC6800::adca_ix()
3170 {
3171         uint16 t, r;
3172         IDXBYTE(t);
3173         r = A + t + (CC & 0x01);
3174         CLR_HNZVC;
3175         SET_FLAGS8(A, t, r);
3176         SET_H(A, t, r);
3177         A = (uint8)r;
3178 }
3179
3180 /* $aa ORA indexed -**0- */
3181 void MC6800::ora_ix()
3182 {
3183         uint8 t;
3184         IDXBYTE(t);
3185         A |= t;
3186         CLR_NZV;
3187         SET_NZ8(A);
3188 }
3189
3190 /* $ab ADDA indexed ***** */
3191 void MC6800::adda_ix()
3192 {
3193         uint16 t, r;
3194         IDXBYTE(t);
3195         r = A + t;
3196         CLR_HNZVC;
3197         SET_FLAGS8(A, t, r);
3198         SET_H(A, t, r);
3199         A = (uint8)r;
3200 }
3201
3202 /* $ac CMPX indexed -***- */
3203 void MC6800::cmpx_ix()
3204 {
3205         uint32 r, d;
3206         pair b;
3207         IDXWORD(b);
3208         d = X;
3209         r = d - b.d;
3210         CLR_NZV;
3211         SET_NZ16(r);
3212         SET_V16(d, b.d, r);
3213 }
3214
3215 /* $ac CPX indexed -**** (6801)*/
3216 void MC6800::cpx_ix()
3217 {
3218         uint32 r, d;
3219         pair b;
3220         IDXWORD(b);
3221         d = X;
3222         r = d - b.d;
3223         CLR_NZVC;
3224         SET_FLAGS16(d, b.d, r);
3225 }
3226
3227 /* $ad JSR indexed ----- */
3228 void MC6800::jsr_ix()
3229 {
3230         INDEXED;
3231         PUSHWORD(pPC);
3232         PC = EA;
3233 }
3234
3235 /* $ae LDS indexed -**0- */
3236 void MC6800::lds_ix()
3237 {
3238         IDXWORD(pS);
3239         CLR_NZV;
3240         SET_NZ16(S);
3241 }
3242
3243 /* $af STS indexed -**0- */
3244 void MC6800::sts_ix()
3245 {
3246         CLR_NZV;
3247         SET_NZ16(S);
3248         INDEXED;
3249         WM16(EAD, &pS);
3250 }
3251
3252 /* $b0 SUBA extended ?**** */
3253 void MC6800::suba_ex()
3254 {
3255         uint16 t, r;
3256         EXTBYTE(t);
3257         r = A - t;
3258         CLR_NZVC;
3259         SET_FLAGS8(A, t, r);
3260         A = (uint8)r;
3261 }
3262
3263 /* $b1 CMPA extended ?**** */
3264 void MC6800::cmpa_ex()
3265 {
3266         uint16 t, r;
3267         EXTBYTE(t);
3268         r = A - t;
3269         CLR_NZVC;
3270         SET_FLAGS8(A, t, r);
3271 }
3272
3273 /* $b2 SBCA extended ?**** */
3274 void MC6800::sbca_ex()
3275 {
3276         uint16 t, r;
3277         EXTBYTE(t);
3278         r = A - t - (CC & 0x01);
3279         CLR_NZVC;
3280         SET_FLAGS8(A, t, r);
3281         A = (uint8)r;
3282 }
3283
3284 /* $b3 SUBD extended -**** */
3285 void MC6800::subd_ex()
3286 {
3287         uint32 r, d;
3288         pair b;
3289         EXTWORD(b);
3290         d = D;
3291         r = d - b.d;
3292         CLR_NZVC;
3293         SET_FLAGS16(d, b.d, r);
3294         D = r;
3295 }
3296
3297 /* $b4 ANDA extended -**0- */
3298 void MC6800::anda_ex()
3299 {
3300         uint8 t;
3301         EXTBYTE(t);
3302         A &= t;
3303         CLR_NZV;
3304         SET_NZ8(A);
3305 }
3306
3307 /* $b5 BITA extended -**0- */
3308 void MC6800::bita_ex()
3309 {
3310         uint8 t, r;
3311         EXTBYTE(t);
3312         r = A & t;
3313         CLR_NZV;
3314         SET_NZ8(r);
3315 }
3316
3317 /* $b6 LDA extended -**0- */
3318 void MC6800::lda_ex()
3319 {
3320         EXTBYTE(A);
3321         CLR_NZV;
3322         SET_NZ8(A);
3323 }
3324
3325 /* $b7 STA extended -**0- */
3326 void MC6800::sta_ex()
3327 {
3328         CLR_NZV;
3329         SET_NZ8(A);
3330         EXTENDED;
3331         WM(EAD, A);
3332 }
3333
3334 /* $b8 EORA extended -**0- */
3335 void MC6800::eora_ex()
3336 {
3337         uint8 t;
3338         EXTBYTE(t);
3339         A ^= t;
3340         CLR_NZV;
3341         SET_NZ8(A);
3342 }
3343
3344 /* $b9 ADCA extended ***** */
3345 void MC6800::adca_ex()
3346 {
3347         uint16 t, r;
3348         EXTBYTE(t);
3349         r = A + t + (CC & 0x01);
3350         CLR_HNZVC;
3351         SET_FLAGS8(A, t, r);
3352         SET_H(A, t, r);
3353         A = (uint8)r;
3354 }
3355
3356 /* $ba ORA extended -**0- */
3357 void MC6800::ora_ex()
3358 {
3359         uint8 t;
3360         EXTBYTE(t);
3361         A |= t;
3362         CLR_NZV;
3363         SET_NZ8(A);
3364 }
3365
3366 /* $bb ADDA extended ***** */
3367 void MC6800::adda_ex()
3368 {
3369         uint16 t, r;
3370         EXTBYTE(t);
3371         r = A + t;
3372         CLR_HNZVC;
3373         SET_FLAGS8(A, t, r);
3374         SET_H(A, t, r);
3375         A = (uint8)r;
3376 }
3377
3378 /* $bc CMPX extended -***- */
3379 void MC6800::cmpx_ex()
3380 {
3381         uint32 r, d;
3382         pair b;
3383         EXTWORD(b);
3384         d = X;
3385         r = d - b.d;
3386         CLR_NZV;
3387         SET_NZ16(r);
3388         SET_V16(d, b.d, r);
3389 }
3390
3391 /* $bc CPX extended -**** (6801) */
3392 void MC6800::cpx_ex()
3393 {
3394         uint32 r, d;
3395         pair b;
3396         EXTWORD(b);
3397         d = X;
3398         r = d - b.d;
3399         CLR_NZVC;
3400         SET_FLAGS16(d, b.d, r);
3401 }
3402
3403 /* $bd JSR extended ----- */
3404 void MC6800::jsr_ex()
3405 {
3406         EXTENDED;
3407         PUSHWORD(pPC);
3408         PC = EA;
3409 }
3410
3411 /* $be LDS extended -**0- */
3412 void MC6800::lds_ex()
3413 {
3414         EXTWORD(pS);
3415         CLR_NZV;
3416         SET_NZ16(S);
3417 }
3418
3419 /* $bf STS extended -**0- */
3420 void MC6800::sts_ex()
3421 {
3422         CLR_NZV;
3423         SET_NZ16(S);
3424         EXTENDED;
3425         WM16(EAD, &pS);
3426 }
3427
3428 /* $c0 SUBB immediate ?**** */
3429 void MC6800::subb_im()
3430 {
3431         uint16 t, r;
3432         IMMBYTE(t);
3433         r = B - t;
3434         CLR_NZVC;
3435         SET_FLAGS8(B, t, r);
3436         B = (uint8)r;
3437 }
3438
3439 /* $c1 CMPB immediate ?**** */
3440 void MC6800::cmpb_im()
3441 {
3442         uint16 t, r;
3443         IMMBYTE(t);
3444         r = B - t;
3445         CLR_NZVC;
3446         SET_FLAGS8(B, t, r);
3447 }
3448
3449 /* $c2 SBCB immediate ?**** */
3450 void MC6800::sbcb_im()
3451 {
3452         uint16 t, r;
3453         IMMBYTE(t);
3454         r = B - t - (CC & 0x01);
3455         CLR_NZVC;
3456         SET_FLAGS8(B, t, r);
3457         B = (uint8)r;
3458 }
3459
3460 /* $c3 ADDD immediate -**** */
3461 void MC6800::addd_im()
3462 {
3463         uint32 r, d;
3464         pair b;
3465         IMMWORD(b);
3466         d = D;
3467         r = d + b.d;
3468         CLR_NZVC;
3469         SET_FLAGS16(d, b.d, r);
3470         D = r;
3471 }
3472
3473 /* $c4 ANDB immediate -**0- */
3474 void MC6800::andb_im()
3475 {
3476         uint8 t;
3477         IMMBYTE(t);
3478         B &= t;
3479         CLR_NZV;
3480         SET_NZ8(B);
3481 }
3482
3483 /* $c5 BITB immediate -**0- */
3484 void MC6800::bitb_im()
3485 {
3486         uint8 t, r;
3487         IMMBYTE(t);
3488         r = B & t;
3489         CLR_NZV;
3490         SET_NZ8(r);
3491 }
3492
3493 /* $c6 LDB immediate -**0- */
3494 void MC6800::ldb_im()
3495 {
3496         IMMBYTE(B);
3497         CLR_NZV;
3498         SET_NZ8(B);
3499 }
3500
3501 /* is this a legal instruction? */
3502 /* $c7 STB immediate -**0- */
3503 void MC6800::stb_im()
3504 {
3505         CLR_NZV;
3506         SET_NZ8(B);
3507         IMM8;
3508         WM(EAD, B);
3509 }
3510
3511 /* $c8 EORB immediate -**0- */
3512 void MC6800::eorb_im()
3513 {
3514         uint8 t;
3515         IMMBYTE(t);
3516         B ^= t;
3517         CLR_NZV;
3518         SET_NZ8(B);
3519 }
3520
3521 /* $c9 ADCB immediate ***** */
3522 void MC6800::adcb_im()
3523 {
3524         uint16 t, r;
3525         IMMBYTE(t);
3526         r = B + t + (CC & 0x01);
3527         CLR_HNZVC;
3528         SET_FLAGS8(B, t, r);
3529         SET_H(B, t, r);
3530         B = (uint8)r;
3531 }
3532
3533 /* $ca ORB immediate -**0- */
3534 void MC6800::orb_im()
3535 {
3536         uint8 t;
3537         IMMBYTE(t);
3538         B |= t;
3539         CLR_NZV;
3540         SET_NZ8(B);
3541 }
3542
3543 /* $cb ADDB immediate ***** */
3544 void MC6800::addb_im()
3545 {
3546         uint16 t, r;
3547         IMMBYTE(t);
3548         r = B + t;
3549         CLR_HNZVC;
3550         SET_FLAGS8(B, t, r);
3551         SET_H(B, t, r);
3552         B = (uint8)r;
3553 }
3554
3555 /* $CC LDD immediate -**0- */
3556 void MC6800::ldd_im()
3557 {
3558         IMMWORD(pD);
3559         CLR_NZV;
3560         SET_NZ16(D);
3561 }
3562
3563 /* is this a legal instruction? */
3564 /* $cd STD immediate -**0- */
3565 void MC6800::std_im()
3566 {
3567         IMM16;
3568         CLR_NZV;
3569         SET_NZ16(D);
3570         WM16(EAD, &pD);
3571 }
3572
3573 /* $ce LDX immediate -**0- */
3574 void MC6800::ldx_im()
3575 {
3576         IMMWORD(pX);
3577         CLR_NZV;
3578         SET_NZ16(X);
3579 }
3580
3581 /* $cf STX immediate -**0- */
3582 void MC6800::stx_im()
3583 {
3584         CLR_NZV;
3585         SET_NZ16(X);
3586         IMM16;
3587         WM16(EAD, &pX);
3588 }
3589
3590 /* $d0 SUBB direct ?**** */
3591 void MC6800::subb_di()
3592 {
3593         uint16 t, r;
3594         DIRBYTE(t);
3595         r = B - t;
3596         CLR_NZVC;
3597         SET_FLAGS8(B, t, r);
3598         B = (uint8)r;
3599 }
3600
3601 /* $d1 CMPB direct ?**** */
3602 void MC6800::cmpb_di()
3603 {
3604         uint16 t, r;
3605         DIRBYTE(t);
3606         r = B - t;
3607         CLR_NZVC;
3608         SET_FLAGS8(B, t, r);
3609 }
3610
3611 /* $d2 SBCB direct ?**** */
3612 void MC6800::sbcb_di()
3613 {
3614         uint16 t, r;
3615         DIRBYTE(t);
3616         r = B - t - (CC & 0x01);
3617         CLR_NZVC;
3618         SET_FLAGS8(B, t, r);
3619         B = (uint8)r;
3620 }
3621
3622 /* $d3 ADDD direct -**** */
3623 void MC6800::addd_di()
3624 {
3625         uint32 r, d;
3626         pair b;
3627         DIRWORD(b);
3628         d = D;
3629         r = d + b.d;
3630         CLR_NZVC;
3631         SET_FLAGS16(d, b.d, r);
3632         D = r;
3633 }
3634
3635 /* $d4 ANDB direct -**0- */
3636 void MC6800::andb_di()
3637 {
3638         uint8 t;
3639         DIRBYTE(t);
3640         B &= t;
3641         CLR_NZV;
3642         SET_NZ8(B);
3643 }
3644
3645 /* $d5 BITB direct -**0- */
3646 void MC6800::bitb_di()
3647 {
3648         uint8 t, r;
3649         DIRBYTE(t);
3650         r = B & t;
3651         CLR_NZV;
3652         SET_NZ8(r);
3653 }
3654
3655 /* $d6 LDB direct -**0- */
3656 void MC6800::ldb_di()
3657 {
3658         DIRBYTE(B);
3659         CLR_NZV;
3660         SET_NZ8(B);
3661 }
3662
3663 /* $d7 STB direct -**0- */
3664 void MC6800::stb_di()
3665 {
3666         CLR_NZV;
3667         SET_NZ8(B);
3668         DIRECT;
3669         WM(EAD, B);
3670 }
3671
3672 /* $d8 EORB direct -**0- */
3673 void MC6800::eorb_di()
3674 {
3675         uint8 t;
3676         DIRBYTE(t);
3677         B ^= t;
3678         CLR_NZV;
3679         SET_NZ8(B);
3680 }
3681
3682 /* $d9 ADCB direct ***** */
3683 void MC6800::adcb_di()
3684 {
3685         uint16 t, r;
3686         DIRBYTE(t);
3687         r = B + t + (CC & 0x01);
3688         CLR_HNZVC;
3689         SET_FLAGS8(B, t, r);
3690         SET_H(B, t, r);
3691         B = (uint8)r;
3692 }
3693
3694 /* $da ORB direct -**0- */
3695 void MC6800::orb_di()
3696 {
3697         uint8 t;
3698         DIRBYTE(t);
3699         B |= t;
3700         CLR_NZV;
3701         SET_NZ8(B);
3702 }
3703
3704 /* $db ADDB direct ***** */
3705 void MC6800::addb_di()
3706 {
3707         uint16 t, r;
3708         DIRBYTE(t);
3709         r = B + t;
3710         CLR_HNZVC;
3711         SET_FLAGS8(B, t, r);
3712         SET_H(B, t, r);
3713         B = (uint8)r;
3714 }
3715
3716 /* $dc LDD direct -**0- */
3717 void MC6800::ldd_di()
3718 {
3719         DIRWORD(pD);
3720         CLR_NZV;
3721         SET_NZ16(D);
3722 }
3723
3724 /* $dd STD direct -**0- */
3725 void MC6800::std_di()
3726 {
3727         DIRECT;
3728         CLR_NZV;
3729         SET_NZ16(D);
3730         WM16(EAD, &pD);
3731 }
3732
3733 /* $de LDX direct -**0- */
3734 void MC6800::ldx_di()
3735 {
3736         DIRWORD(pX);
3737         CLR_NZV;
3738         SET_NZ16(X);
3739 }
3740
3741 /* $dF STX direct -**0- */
3742 void MC6800::stx_di()
3743 {
3744         CLR_NZV;
3745         SET_NZ16(X);
3746         DIRECT;
3747         WM16(EAD, &pX);
3748 }
3749
3750 /* $e0 SUBB indexed ?**** */
3751 void MC6800::subb_ix()
3752 {
3753         uint16 t, r;
3754         IDXBYTE(t);
3755         r = B - t;
3756         CLR_NZVC;
3757         SET_FLAGS8(B, t, r);
3758         B = (uint8)r;
3759 }
3760
3761 /* $e1 CMPB indexed ?**** */
3762 void MC6800::cmpb_ix()
3763 {
3764         uint16 t, r;
3765         IDXBYTE(t);
3766         r = B - t;
3767         CLR_NZVC;
3768         SET_FLAGS8(B, t, r);
3769 }
3770
3771 /* $e2 SBCB indexed ?**** */
3772 void MC6800::sbcb_ix()
3773 {
3774         uint16 t, r;
3775         IDXBYTE(t);
3776         r = B - t - (CC & 0x01);
3777         CLR_NZVC;
3778         SET_FLAGS8(B, t, r);
3779         B = (uint8)r;
3780 }
3781
3782 /* $e3 ADDD indexed -**** */
3783 void MC6800::addd_ix()
3784 {
3785         uint32 r, d;
3786         pair b;
3787         IDXWORD(b);
3788         d = D;
3789         r = d + b.d;
3790         CLR_NZVC;
3791         SET_FLAGS16(d, b.d, r);
3792         D = r;
3793 }
3794
3795 /* $e4 ANDB indexed -**0- */
3796 void MC6800::andb_ix()
3797 {
3798         uint8 t;
3799         IDXBYTE(t);
3800         B &= t;
3801         CLR_NZV;
3802         SET_NZ8(B);
3803 }
3804
3805 /* $e5 BITB indexed -**0- */
3806 void MC6800::bitb_ix()
3807 {
3808         uint8 t, r;
3809         IDXBYTE(t);
3810         r = B & t;
3811         CLR_NZV;
3812         SET_NZ8(r);
3813 }
3814
3815 /* $e6 LDB indexed -**0- */
3816 void MC6800::ldb_ix()
3817 {
3818         IDXBYTE(B);
3819         CLR_NZV;
3820         SET_NZ8(B);
3821 }
3822
3823 /* $e7 STB indexed -**0- */
3824 void MC6800::stb_ix()
3825 {
3826         CLR_NZV;
3827         SET_NZ8(B);
3828         INDEXED;
3829         WM(EAD, B);
3830 }
3831
3832 /* $e8 EORB indexed -**0- */
3833 void MC6800::eorb_ix()
3834 {
3835         uint8 t;
3836         IDXBYTE(t);
3837         B ^= t;
3838         CLR_NZV;
3839         SET_NZ8(B);
3840 }
3841
3842 /* $e9 ADCB indexed ***** */
3843 void MC6800::adcb_ix()
3844 {
3845         uint16 t, r;
3846         IDXBYTE(t);
3847         r = B + t + (CC & 0x01);
3848         CLR_HNZVC;
3849         SET_FLAGS8(B, t, r);
3850         SET_H(B, t, r);
3851         B = (uint8)r;
3852 }
3853
3854 /* $ea ORB indexed -**0- */
3855 void MC6800::orb_ix()
3856 {
3857         uint8 t;
3858         IDXBYTE(t);
3859         B |= t;
3860         CLR_NZV;
3861         SET_NZ8(B);
3862 }
3863
3864 /* $eb ADDB indexed ***** */
3865 void MC6800::addb_ix()
3866 {
3867         uint16 t, r;
3868         IDXBYTE(t);
3869         r = B + t;
3870         CLR_HNZVC;
3871         SET_FLAGS8(B, t, r);
3872         SET_H(B, t, r);
3873         B = (uint8)r;
3874 }
3875
3876 /* $ec LDD indexed -**0- */
3877 void MC6800::ldd_ix()
3878 {
3879         IDXWORD(pD);
3880         CLR_NZV;
3881         SET_NZ16(D);
3882 }
3883
3884 /* $ec ADX immediate -**** */ /* MB8861 only */
3885 void MC6800::adx_im()
3886 {
3887         uint32 r, d, t;
3888         IMMBYTE(t);
3889         d = X;
3890         r = d + t;
3891         CLR_NZVC;
3892         SET_FLAGS16(d, t, r);
3893         X = r;
3894 }
3895
3896 /* $ed STD indexed -**0- */
3897 void MC6800::std_ix()
3898 {
3899         INDEXED;
3900         CLR_NZV;
3901         SET_NZ16(D);
3902         WM16(EAD, &pD);
3903 }
3904
3905 /* $ee LDX indexed -**0- */
3906 void MC6800::ldx_ix()
3907 {
3908         IDXWORD(pX);
3909         CLR_NZV;
3910         SET_NZ16(X);
3911 }
3912
3913 /* $ef STX indexed -**0- */
3914 void MC6800::stx_ix()
3915 {
3916         CLR_NZV;
3917         SET_NZ16(X);
3918         INDEXED;
3919         WM16(EAD, &pX);
3920 }
3921
3922 /* $f0 SUBB extended ?**** */
3923 void MC6800::subb_ex()
3924 {
3925         uint16 t, r;
3926         EXTBYTE(t);
3927         r = B - t;
3928         CLR_NZVC;
3929         SET_FLAGS8(B, t, r);
3930         B = (uint8)r;
3931 }
3932
3933 /* $f1 CMPB extended ?**** */
3934 void MC6800::cmpb_ex()
3935 {
3936         uint16 t, r;
3937         EXTBYTE(t);
3938         r = B - t;
3939         CLR_NZVC;
3940         SET_FLAGS8(B, t, r);
3941 }
3942
3943 /* $f2 SBCB extended ?**** */
3944 void MC6800::sbcb_ex()
3945 {
3946         uint16 t, r;
3947         EXTBYTE(t);
3948         r = B - t - (CC & 0x01);
3949         CLR_NZVC;
3950         SET_FLAGS8(B, t, r);
3951         B = (uint8)r;
3952 }
3953
3954 /* $f3 ADDD extended -**** */
3955 void MC6800::addd_ex()
3956 {
3957         uint32 r, d;
3958         pair b;
3959         EXTWORD(b);
3960         d = D;
3961         r = d + b.d;
3962         CLR_NZVC;
3963         SET_FLAGS16(d, b.d, r);
3964         D = r;
3965 }
3966
3967 /* $f4 ANDB extended -**0- */
3968 void MC6800::andb_ex()
3969 {
3970         uint8 t;
3971         EXTBYTE(t);
3972         B &= t;
3973         CLR_NZV;
3974         SET_NZ8(B);
3975 }
3976
3977 /* $f5 BITB extended -**0- */
3978 void MC6800::bitb_ex()
3979 {
3980         uint8 t, r;
3981         EXTBYTE(t);
3982         r = B & t;
3983         CLR_NZV;
3984         SET_NZ8(r);
3985 }
3986
3987 /* $f6 LDB extended -**0- */
3988 void MC6800::ldb_ex()
3989 {
3990         EXTBYTE(B);
3991         CLR_NZV;
3992         SET_NZ8(B);
3993 }
3994
3995 /* $f7 STB extended -**0- */
3996 void MC6800::stb_ex()
3997 {
3998         CLR_NZV;
3999         SET_NZ8(B);
4000         EXTENDED;
4001         WM(EAD, B);
4002 }
4003
4004 /* $f8 EORB extended -**0- */
4005 void MC6800::eorb_ex()
4006 {
4007         uint8 t;
4008         EXTBYTE(t);
4009         B ^= t;
4010         CLR_NZV;
4011         SET_NZ8(B);
4012 }
4013
4014 /* $f9 ADCB extended ***** */
4015 void MC6800::adcb_ex()
4016 {
4017         uint16 t, r;
4018         EXTBYTE(t);
4019         r = B + t + (CC & 0x01);
4020         CLR_HNZVC;
4021         SET_FLAGS8(B, t, r);
4022         SET_H(B, t, r);
4023         B = (uint8)r;
4024 }
4025
4026 /* $fa ORB extended -**0- */
4027 void MC6800::orb_ex()
4028 {
4029         uint8 t;
4030         EXTBYTE(t);
4031         B |= t;
4032         CLR_NZV;
4033         SET_NZ8(B);
4034 }
4035
4036 /* $fb ADDB extended ***** */
4037 void MC6800::addb_ex()
4038 {
4039         uint16 t, r;
4040         EXTBYTE(t);
4041         r = B + t;
4042         CLR_HNZVC;
4043         SET_FLAGS8(B, t, r);
4044         SET_H(B, t, r);
4045         B = (uint8)r;
4046 }
4047
4048 /* $fc LDD extended -**0- */
4049 void MC6800::ldd_ex()
4050 {
4051         EXTWORD(pD);
4052         CLR_NZV;
4053         SET_NZ16(D);
4054 }
4055
4056 /* $fc ADX immediate -**** */ /* MB8861 only */
4057 void MC6800::adx_ex()
4058 {
4059         uint32 r, d;
4060         pair b;
4061         EXTWORD(b);
4062         d = X;
4063         r = d + b.d;
4064         CLR_NZVC;
4065         SET_FLAGS16(d, b.d, r);
4066         X = r;
4067 }
4068
4069 /* $fd STD extended -**0- */
4070 void MC6800::std_ex()
4071 {
4072         EXTENDED;
4073         CLR_NZV;
4074         SET_NZ16(D);
4075         WM16(EAD, &pD);
4076 }
4077
4078 /* $fe LDX extended -**0- */
4079 void MC6800::ldx_ex()
4080 {
4081         EXTWORD(pX);
4082         CLR_NZV;
4083         SET_NZ16(X);
4084 }
4085
4086 /* $ff STX extended -**0- */
4087 void MC6800::stx_ex()
4088 {
4089         CLR_NZV;
4090         SET_NZ16(X);
4091         EXTENDED;
4092         WM16(EAD, &pX);
4093 }
4094
4095 #define STATE_VERSION   1
4096
4097 void MC6800::save_state(FILEIO* state_fio)
4098 {
4099         state_fio->FputUint32(STATE_VERSION);
4100         state_fio->FputInt32(this_device_id);
4101
4102         state_fio->FputUint32(pc.d);
4103         state_fio->FputUint16(prevpc);
4104         state_fio->FputUint32(sp.d);
4105         state_fio->FputUint32(ix.d);
4106         state_fio->FputUint32(acc_d.d);
4107         state_fio->FputUint32(ea.d);
4108         state_fio->FputUint8(cc);
4109         state_fio->FputInt32(wai_state);
4110         state_fio->FputInt32(int_state);
4111         state_fio->FputInt32(icount);
4112 #if defined(HAS_MC6801) || defined(HAS_HD6301)
4113         for(int i = 0; i < 4; i++) {
4114                 state_fio->FputUint8(port[i].wreg);
4115                 state_fio->FputUint8(port[i].rreg);
4116                 state_fio->FputUint8(port[i].ddr);
4117                 state_fio->FputUint8(port[i].latched_data);
4118                 state_fio->FputBool(port[i].latched);
4119                 state_fio->FputBool(port[i].first_write);
4120         }
4121         state_fio->FputUint8(p3csr);
4122         state_fio->FputBool(p3csr_is3_flag_read);
4123         state_fio->FputBool(sc1_state);
4124         state_fio->FputBool(sc2_state);
4125         state_fio->FputUint32(counter.d);
4126         state_fio->FputUint32(output_compare.d);
4127         state_fio->FputUint32(timer_over.d);
4128         state_fio->FputUint8(tcsr);
4129         state_fio->FputUint8(pending_tcsr);
4130         state_fio->FputUint16(input_capture);
4131 #ifdef HAS_HD6301
4132         state_fio->FputUint16(latch09);
4133 #endif
4134         state_fio->FputUint32(timer_next);
4135         recv_buffer->save_state((void *)state_fio);
4136         state_fio->FputUint8(trcsr);
4137         state_fio->FputUint8(rdr);
4138         state_fio->FputUint8(tdr);
4139         state_fio->FputBool(trcsr_read_tdre);
4140         state_fio->FputBool(trcsr_read_orfe);
4141         state_fio->FputBool(trcsr_read_rdrf);
4142         state_fio->FputUint8(rmcr);
4143         state_fio->FputInt32(sio_counter);
4144         state_fio->FputUint8(ram_ctrl);
4145         state_fio->Fwrite(ram, sizeof(ram), 1);
4146 #endif
4147 }
4148
4149 bool MC6800::load_state(FILEIO* state_fio)
4150 {
4151         if(state_fio->FgetUint32() != STATE_VERSION) {
4152                 return false;
4153         }
4154         if(state_fio->FgetInt32() != this_device_id) {
4155                 return false;
4156         }
4157         pc.d = state_fio->FgetUint32();
4158         prevpc = state_fio->FgetUint16();
4159         sp.d = state_fio->FgetUint32();
4160         ix.d = state_fio->FgetUint32();
4161         acc_d.d = state_fio->FgetUint32();
4162         ea.d = state_fio->FgetUint32();
4163         cc = state_fio->FgetUint8();
4164         wai_state = state_fio->FgetInt32();
4165         int_state = state_fio->FgetInt32();
4166         icount = state_fio->FgetInt32();
4167 #if defined(HAS_MC6801) || defined(HAS_HD6301)
4168         for(int i = 0; i < 4; i++) {
4169                 port[i].wreg = state_fio->FgetUint8();
4170                 port[i].rreg = state_fio->FgetUint8();
4171                 port[i].ddr = state_fio->FgetUint8();
4172                 port[i].latched_data = state_fio->FgetUint8();
4173                 port[i].latched = state_fio->FgetBool();
4174                 port[i].first_write = state_fio->FgetBool();
4175         }
4176         p3csr = state_fio->FgetUint8();
4177         p3csr_is3_flag_read = state_fio->FgetBool();
4178         sc1_state = state_fio->FgetBool();
4179         sc2_state = state_fio->FgetBool();
4180         counter.d = state_fio->FgetUint32();
4181         output_compare.d = state_fio->FgetUint32();
4182         timer_over.d = state_fio->FgetUint32();
4183         tcsr = state_fio->FgetUint8();
4184         pending_tcsr = state_fio->FgetUint8();
4185         input_capture = state_fio->FgetUint16();
4186 #ifdef HAS_HD6301
4187         latch09 = state_fio->FgetUint16();
4188 #endif
4189         timer_next = state_fio->FgetUint32();
4190         if(!recv_buffer->load_state((void *)state_fio)) {
4191                 return false;
4192         }
4193         trcsr = state_fio->FgetUint8();
4194         rdr = state_fio->FgetUint8();
4195         tdr = state_fio->FgetUint8();
4196         trcsr_read_tdre = state_fio->FgetBool();
4197         trcsr_read_orfe = state_fio->FgetBool();
4198         trcsr_read_rdrf = state_fio->FgetBool();
4199         rmcr = state_fio->FgetUint8();
4200         sio_counter = state_fio->FgetInt32();
4201         ram_ctrl = state_fio->FgetUint8();
4202         state_fio->Fread(ram, sizeof(ram), 1);
4203 #endif
4204         return true;
4205 }
4206