source/src/vm/mc6809.cpp

   1 /*
   2         Skelton for retropc emulator
   3
   4         Origin : MAME 0.142
   5         Author : Takeda.Toshiya
   6         Date   : 2011.05.06-
   7
   8         [ MC6809 ]
   9         Notes from K.Ohta <whatisthis.sowhat _at_ gmail.com> at Jan 16, 2015:
  10               All of undocumented instructions (i.e. ngc, flag16) of MC6809(not HD6309) are written by me.
  11               These behaviors of undocumented insns are refered from "vm/cpu_x86.asm" (ia32 assembly codefor nasm) within XM7
  12               written by Ryu Takegami , and older article wrote in magazine, "I/O" at 1985.
  13               But, these C implements are written from scratch by me , and I tested many years at XM7/SDL.
  14               Perhaps, these insns. are not implement MAME/MESS yet.
  15 */
  16
  17 // Fixed IRQ/FIRQ by Mr.Sasaji at 2011.06.17
  18
  19 //#include "vm.h"
  20 //#include "../emu.h"
  21 #include "./mc6809.h"
  22 #include "./mc6809_consts.h"
  23 #include "common.h"
  24
  25 #include "debugger.h"
  26 #include "config.h"
  27
  28 #define OP_HANDLER(_name) void MC6809::_name (void)
  29
  30 void (__FASTCALL  MC6809::*MC6809::m6809_optable[0x100]) (void) =
  31 {
  32 /*          0xX0,   0xX1,     0xX2,    0xX3,    0xX4,    0xX5,    0xX6,    0xX7,
  33             0xX8,   0xX9,     0xXA,    0xXB,    0xXC,    0xXD,    0xXE,    0xXF   */
  34
  35 /* 0x0X */
  36         &MC6809::neg_di, &MC6809::neg_di, &MC6809::ngc_di, &MC6809::com_di,
  37         &MC6809::lsr_di, &MC6809::lsr_di, &MC6809::ror_di, &MC6809::asr_di,
  38         &MC6809::asl_di, &MC6809::rol_di, &MC6809::dec_di, &MC6809::dcc_di,
  39         &MC6809::inc_di, &MC6809::tst_di, &MC6809::jmp_di, &MC6809::clr_di,
  40 /* 0x1X */
  41         &MC6809::pref10, &MC6809::pref11, &MC6809::nop, &MC6809::sync_09,
  42         &MC6809::trap, &MC6809::trap, &MC6809::lbra, &MC6809::lbsr,
  43         &MC6809::aslcc_in, &MC6809::daa, &MC6809::orcc, &MC6809::nop,
  44         &MC6809::andcc, &MC6809::sex, &MC6809::exg, &MC6809::tfr,
  45 /* 0x2X */
  46         &MC6809::bra, &MC6809::brn, &MC6809::bhi, &MC6809::bls,
  47         &MC6809::bcc, &MC6809::bcs, &MC6809::bne, &MC6809::beq,
  48         &MC6809::bvc, &MC6809::bvs, &MC6809::bpl, &MC6809::bmi,
  49         &MC6809::bge, &MC6809::blt, &MC6809::bgt, &MC6809::ble,
  50 /* 0x3X */
  51         &MC6809::leax, &MC6809::leay, &MC6809::leas, &MC6809::leau,
  52         &MC6809::pshs, &MC6809::puls, &MC6809::pshu, &MC6809::pulu,
  53         &MC6809::andcc, &MC6809::rts, &MC6809::abx, &MC6809::rti,
  54         &MC6809::cwai, &MC6809::mul, &MC6809::rst, &MC6809::swi,
  55 /* 0x4X */
  56         &MC6809::nega, &MC6809::nega, &MC6809::ngca, &MC6809::coma,
  57         &MC6809::lsra, &MC6809::lsra, &MC6809::rora, &MC6809::asra,
  58         &MC6809::asla, &MC6809::rola, &MC6809::deca, &MC6809::dcca,
  59         &MC6809::inca, &MC6809::tsta, &MC6809::clca, &MC6809::clra,
  60 /* 0x5X */
  61         &MC6809::negb, &MC6809::negb, &MC6809::ngcb, &MC6809::comb,
  62         &MC6809::lsrb, &MC6809::lsrb, &MC6809::rorb, &MC6809::asrb,
  63         &MC6809::aslb, &MC6809::rolb, &MC6809::decb, &MC6809::dccb,
  64         &MC6809::incb, &MC6809::tstb, &MC6809::clcb, &MC6809::clrb,
  65 /* 0x6X */
  66         &MC6809::neg_ix, &MC6809::neg_ix, &MC6809::ngc_ix, &MC6809::com_ix,
  67         &MC6809::lsr_ix, &MC6809::lsr_ix, &MC6809::ror_ix, &MC6809::asr_ix,
  68         &MC6809::asl_ix, &MC6809::rol_ix, &MC6809::dec_ix, &MC6809::dcc_ix,
  69         &MC6809::inc_ix, &MC6809::tst_ix, &MC6809::jmp_ix, &MC6809::clr_ix,
  70 /* 0x7X */
  71         &MC6809::neg_ex, &MC6809::neg_ex, &MC6809::ngc_ex, &MC6809::com_ex,
  72         &MC6809::lsr_ex, &MC6809::lsr_ex, &MC6809::ror_ex, &MC6809::asr_ex,
  73         &MC6809::asl_ex, &MC6809::rol_ex, &MC6809::dec_ex, &MC6809::dcc_ex,
  74         &MC6809::inc_ex, &MC6809::tst_ex, &MC6809::jmp_ex, &MC6809::clr_ex,
  75 /* 0x8X */
  76         &MC6809::suba_im, &MC6809::cmpa_im, &MC6809::sbca_im, &MC6809::subd_im,
  77         &MC6809::anda_im, &MC6809::bita_im, &MC6809::lda_im, &MC6809::flag8_im,
  78         &MC6809::eora_im, &MC6809::adca_im, &MC6809::ora_im, &MC6809::adda_im,
  79         &MC6809::cmpx_im, &MC6809::bsr, &MC6809::ldx_im, &MC6809::flag16_im,
  80 /* 0x9X */
  81         &MC6809::suba_di, &MC6809::cmpa_di, &MC6809::sbca_di, &MC6809::subd_di,
  82         &MC6809::anda_di, &MC6809::bita_di, &MC6809::lda_di, &MC6809::sta_di,
  83         &MC6809::eora_di, &MC6809::adca_di, &MC6809::ora_di, &MC6809::adda_di,
  84         &MC6809::cmpx_di, &MC6809::jsr_di, &MC6809::ldx_di, &MC6809::stx_di,
  85 /* 0xAX */
  86         &MC6809::suba_ix, &MC6809::cmpa_ix, &MC6809::sbca_ix, &MC6809::subd_ix,
  87         &MC6809::anda_ix, &MC6809::bita_ix, &MC6809::lda_ix, &MC6809::sta_ix,
  88         &MC6809::eora_ix, &MC6809::adca_ix, &MC6809::ora_ix, &MC6809::adda_ix,
  89         &MC6809::cmpx_ix, &MC6809::jsr_ix, &MC6809::ldx_ix, &MC6809::stx_ix,
  90 /* 0xBX */
  91         &MC6809::suba_ex, &MC6809::cmpa_ex, &MC6809::sbca_ex, &MC6809::subd_ex,
  92         &MC6809::anda_ex, &MC6809::bita_ex, &MC6809::lda_ex, &MC6809::sta_ex,
  93         &MC6809::eora_ex, &MC6809::adca_ex, &MC6809::ora_ex, &MC6809::adda_ex,
  94         &MC6809::cmpx_ex, &MC6809::jsr_ex, &MC6809::ldx_ex, &MC6809::stx_ex,
  95 /* 0xCX */
  96         &MC6809::subb_im, &MC6809::cmpb_im, &MC6809::sbcb_im, &MC6809::addd_im,
  97         &MC6809::andb_im, &MC6809::bitb_im, &MC6809::ldb_im, &MC6809::flag8_im,
  98         &MC6809::eorb_im, &MC6809::adcb_im, &MC6809::orb_im, &MC6809::addb_im,
  99         &MC6809::ldd_im, &MC6809::trap, &MC6809::ldu_im, &MC6809::flag16_im,
 100 /* 0xDX */
 101         &MC6809::subb_di, &MC6809::cmpb_di, &MC6809::sbcb_di, &MC6809::addd_di,
 102         &MC6809::andb_di, &MC6809::bitb_di, &MC6809::ldb_di, &MC6809::stb_di,
 103         &MC6809::eorb_di, &MC6809::adcb_di, &MC6809::orb_di, &MC6809::addb_di,
 104         &MC6809::ldd_di, &MC6809::std_di, &MC6809::ldu_di, &MC6809::stu_di,
 105 /* 0xEX */
 106         &MC6809::subb_ix, &MC6809::cmpb_ix, &MC6809::sbcb_ix, &MC6809::addd_ix,
 107         &MC6809::andb_ix, &MC6809::bitb_ix, &MC6809::ldb_ix, &MC6809::stb_ix,
 108         &MC6809::eorb_ix, &MC6809::adcb_ix, &MC6809::orb_ix, &MC6809::addb_ix,
 109         &MC6809::ldd_ix, &MC6809::std_ix, &MC6809::ldu_ix, &MC6809::stu_ix,
 110 /* 0xFX */
 111         &MC6809::subb_ex, &MC6809::cmpb_ex, &MC6809::sbcb_ex, &MC6809::addd_ex,
 112         &MC6809::andb_ex, &MC6809::bitb_ex, &MC6809::ldb_ex, &MC6809::stb_ex,
 113         &MC6809::eorb_ex, &MC6809::adcb_ex, &MC6809::orb_ex, &MC6809::addb_ex,
 114         &MC6809::ldd_ex, &MC6809::std_ex, &MC6809::ldu_ex, &MC6809::stu_ex
 115 };
 116
 117 /* macros for branch instructions */
 118 inline void MC6809::BRANCH(bool cond)
 119 {
 120         uint8_t t;
 121         IMMBYTE(t);
 122         if(!cond) return;
 123         PC = PC + SIGNED(t);
 124         PC = PC & 0xffff;
 125 }
 126
 127 inline void MC6809::LBRANCH(bool cond)
 128 {
 129         pair32_t t;
 130         IMMWORD(t);
 131         if(!cond) return;
 132         icount -= 1;
 133         PC += t.w.l;
 134         PC = PC & 0xffff;
 135 }
 136
 137 /* macros for setting/getting registers in TFR/EXG instructions */
 138
 139 inline pair32_t MC6809::RM16_PAIR(uint32_t addr)
 140 {
 141         pair32_t b;
 142         b.d = 0;
 143         b.b.h = RM(addr);
 144         b.b.l = RM((addr + 1));
 145         return b;
 146 }
 147
 148 inline void MC6809::WM16(uint32_t Addr, pair32_t *p)
 149 {
 150         WM(Addr , p->b.h);
 151         WM((Addr + 1), p->b.l);
 152 }
 153
 154 void MC6809::reset()
 155 {
 156         //extar_tmp_count += extra_icount;
 157
 158         icount = 0;
 159         waitcount = 0;
 160         int_state &= MC6809_HALT_BIT;
 161         extra_icount = 0;
 162         //busreq = false;
 163
 164         DPD = 0;        /* Reset direct page register */
 165         CC = 0;
 166         D = 0;
 167         X = 0;
 168         Y = 0;
 169         U = 0;
 170         S = 0;
 171         EA = 0;
 172 //#if defined(_FM7) || defined(_FM8) || defined(_FM77_VARIANTS) || defined(_FM77AV_VARIANTS)
 173
 174         if((req_halt_on) && !(req_halt_off)) {
 175                 int_state |= MC6809_HALT_BIT;
 176         } else {
 177                 req_halt_on = req_halt_off = false;
 178         }
 179         if((int_state & MC6809_HALT_BIT) != 0) {
 180                 write_signals(&outputs_bus_ba, 0xffffffff);
 181                 write_signals(&outputs_bus_bs, 0xffffffff);
 182         } else {
 183                 write_signals(&outputs_bus_ba, 0x00000000);
 184                 write_signals(&outputs_bus_bs, 0x00000000);
 185         }
 186
 187 //#endif
 188         CC |= CC_II;    /* IRQ disabled */
 189         CC |= CC_IF;    /* FIRQ disabled */
 190
 191         pPC = RM16_PAIR(0xfffe);
 192 }
 193
 194
 195
 196 void MC6809::initialize()
 197 {
 198         DEVICE::initialize();
 199         int_state = 0;
 200         busreq = false;
 201         icount = 0;
 202         extra_icount = 0;
 203         req_halt_on = req_halt_off = false;
 204         cycles_tmp_count = 0;
 205         insns_count = 0;
 206
 207         insns_count = 0;
 208         frames_count = 0;
 209         cycles_tmp_count = 0;
 210         nmi_count = 0;
 211         firq_count = 0;
 212         irq_count = 0;
 213 //      if(config.print_statistics) {
 214                 register_frame_event(this);
 215 //      }
 216         waitfactor = 0;
 217         waitcount = 0;
 218         // Updata insn table
 219         void (__FASTCALL MC6809::*_op)(void);
 220         for(int i = 0; i < 0x100; i++) {
 221                 _op = (void (__FASTCALL MC6809::*)(void))m6809_optable[i];
 222                 m6809_main[i] = _op;
 223         }
 224         if(__USE_DEBUGGER) {
 225                 d_mem_stored = d_mem;
 226                 d_debugger->set_context_mem(d_mem);
 227         }
 228
 229 }
 230
 231 void MC6809::event_frame()
 232 {
 233         if(frames_count < 0) {
 234                 cycles_tmp_count = total_icount;
 235                 extra_tmp_count = 0;
 236                 insns_count = 0;
 237                 frames_count = 0;
 238                 nmi_count = 0;
 239                 firq_count = 0;
 240                 irq_count = 0;
 241         } else if(frames_count >= 16) {
 242                 uint64_t _icount = total_icount - cycles_tmp_count;
 243                 if(config.print_statistics) {
 244                         out_debug_log(_T("INFO: 16 frames done.\nINFO: CLOCKS = %ld INSNS = %d EXTRA_ICOUNT = %d \nINFO: NMI# = %d FIRQ# = %d IRQ# = %d"), _icount, insns_count, extra_tmp_count, nmi_count, firq_count, irq_count);
 245                 }
 246                 cycles_tmp_count = total_icount;
 247                 insns_count = 0;
 248                 extra_tmp_count = 0;
 249                 frames_count = 0;
 250                 nmi_count = 0;
 251                 firq_count = 0;
 252                 irq_count = 0;
 253         } else {
 254                 frames_count++;
 255         }
 256 }
 257
 258 void MC6809::write_signal(int id, uint32_t data, uint32_t mask)
 259 {
 260         if(id == SIG_CPU_IRQ) {
 261                 if(data & mask) {
 262                         int_state |= MC6809_IRQ_BIT;
 263                         irq_count++;
 264                 } else {
 265                         int_state &= ~MC6809_IRQ_BIT;
 266                 }
 267         } else if(id == SIG_CPU_FIRQ) {
 268                 if(data & mask) {
 269                         int_state |= MC6809_FIRQ_BIT;
 270                         firq_count++;
 271                 } else {
 272                         int_state &= ~MC6809_FIRQ_BIT;
 273                 }
 274         } else if(id == SIG_CPU_NMI) {
 275                 if(data & mask) {
 276                         int_state |= MC6809_NMI_BIT;
 277                         nmi_count++;
 278                 } else {
 279                         int_state &= ~MC6809_NMI_BIT;
 280                 }
 281         } else if(id == SIG_CPU_BUSREQ) {
 282                 if(data & mask) {
 283                         req_halt_on = false;
 284                         req_halt_off = false;
 285                         int_state |= MC6809_HALT_BIT;
 286                         busreq = false;
 287                 } else {
 288                         req_halt_on = false;
 289                         req_halt_off = false;
 290                         int_state &= ~MC6809_HALT_BIT;
 291                 }
 292         } else if(id == SIG_CPU_HALTREQ) {
 293                 if(data & mask) {
 294                         req_halt_on = true;
 295                         //int_state |= MC6809_HALT_BIT;
 296                 } else {
 297                         if(req_halt_on) {
 298                                 req_halt_off = true;
 299                         }
 300                         //int_state &= ~MC6809_HALT_BIT;
 301                 }
 302         } else if(id == SIG_CPU_WAIT_FACTOR) {
 303                 waitfactor = data; // 65536.
 304         }
 305 }
 306
 307 void MC6809::cpu_nmi_push(void)
 308 {
 309         if ((int_state & MC6809_CWAI_IN) == 0) {
 310                 CC |= CC_E;
 311                 PUSHWORD(pPC);
 312                 PUSHWORD(pU);
 313                 PUSHWORD(pY);
 314                 PUSHWORD(pX);
 315                 PUSHBYTE(DP);
 316                 PUSHBYTE(B);
 317                 PUSHBYTE(A);
 318                 PUSHBYTE(CC);
 319         }
 320         return;
 321 }
 322
 323 void MC6809::cpu_nmi_fetch_vector_address(void)
 324 {
 325         pPC = RM16_PAIR(0xfffc);
 326 //      printf("NMI occured PC=0x%04x VECTOR=%04x SP=%04x \n",rpc.w.l,pPC.w.l,S);
 327         int_state |= MC6809_CWAI_OUT;
 328         //int_state &= ~(MC6809_NMI_BIT | MC6809_SYNC_IN | MC6809_SYNC_OUT | MC6809_CWAI_IN);   // $FF1E
 329         return;
 330 }
 331
 332
 333
 334 void MC6809::cpu_firq_fetch_vector_address(void)
 335 {
 336         pPC = RM16_PAIR(0xfff6);
 337         int_state |= MC6809_CWAI_OUT;
 338         int_state &= ~(MC6809_SYNC_IN | MC6809_SYNC_OUT );
 339         return;
 340 }
 341
 342 void MC6809::cpu_firq_push(void)
 343 {
 344         //pair32_t rpc = pPC;
 345         if ((int_state & MC6809_CWAI_IN) == 0) {
 346                 /* NORMAL */
 347                 CC &= ~CC_E;
 348                 PUSHWORD(pPC);
 349                 PUSHBYTE(CC);
 350         }
 351 //      printf("Firq occured PC=0x%04x VECTOR=%04x SP=%04x \n",rpc.w.l,pPC.w.l,S);
 352 }
 353 void MC6809::cpu_irq_push(void)
 354 {
 355         if ((int_state & MC6809_CWAI_IN) == 0) {
 356                 CC |= CC_E;
 357                 PUSHWORD(pPC);
 358                 PUSHWORD(pU);
 359                 PUSHWORD(pY);
 360                 PUSHWORD(pX);
 361                 PUSHBYTE(DP);
 362                 PUSHBYTE(B);
 363                 PUSHBYTE(A);
 364                 PUSHBYTE(CC);
 365         }
 366 }
 367 void MC6809::cpu_irq_fetch_vector_address(void)
 368 {
 369         //pair32_t rpc = pPC;
 370         pPC = RM16_PAIR(0xfff8);
 371         int_state |= MC6809_CWAI_OUT;
 372         int_state &= ~(MC6809_SYNC_IN | MC6809_SYNC_OUT);
 373 }
 374
 375 void MC6809::cpu_wait(int clocks)
 376 {
 377         uint32_t ncount = 0;
 378         if(clocks < 0) return;
 379         if(waitfactor == 0) return;
 380         waitcount += (waitfactor * (uint32_t)clocks);
 381         if(waitcount >= 65536) {
 382                 ncount = waitcount >> 16;
 383                 waitcount = waitcount - (ncount << 16);
 384         }
 385         if(ncount > 0) extra_icount += ncount;
 386 }
 387
 388 int MC6809::run(int clock)
 389 {
 390         int cycle = 0;
 391         int first_icount = 0;
 392         int passed_icount = 0;
 393         first_icount = icount;
 394         if(extra_icount > 0) {
 395                 extra_tmp_count += extra_icount;
 396         }
 397
 398         if((req_halt_on) && !(req_halt_off)) {
 399                 int_state |= MC6809_HALT_BIT;
 400         } else  if(req_halt_on && req_halt_off) { // HALT OFF
 401                 int_state &= ~MC6809_HALT_BIT;
 402                 req_halt_on = req_halt_off = false;
 403         }
 404
 405         if ((int_state & MC6809_HALT_BIT) != 0) {       // 0x80
 406                 if(clock <= 0) {
 407                         clock = 1;
 408                 } else {
 409                         icount += clock;
 410                 }
 411                 first_icount = icount;
 412                 if(!busreq) {
 413                         write_signals(&outputs_bus_ba, 0);
 414                         write_signals(&outputs_bus_bs, 0);
 415                         busreq = true;
 416                         icount -= clock;
 417                         icount -= extra_icount;
 418                         extra_icount = 0;
 419                         passed_icount = first_icount - icount;
 420                         total_icount += passed_icount;
 421
 422                         write_signals(&outputs_bus_ba, 0xffffffff);
 423                         write_signals(&outputs_bus_bs, 0xffffffff);
 424                         debugger_hook();
 425                         cpu_wait(passed_icount);
 426                         return passed_icount;
 427                 } else {
 428                         icount -= clock;
 429                         icount -= extra_icount;
 430                         extra_icount = 0;
 431                         passed_icount = first_icount - icount;
 432                         total_icount += passed_icount;
 433                         debugger_hook();
 434                         cpu_wait(passed_icount);
 435                         return passed_icount;
 436                 }
 437         }
 438         if(busreq) { // Exit from BUSREQ state.
 439                 if((int_state & MC6809_SYNC_IN) != 0) {
 440                         write_signals(&outputs_bus_ba, 0xffffffff);
 441                 } else {
 442                         write_signals(&outputs_bus_ba, 0x00000000);
 443                 }
 444                 write_signals(&outputs_bus_bs, 0x00000000);
 445                 busreq = false;
 446         }
 447         if((int_state & MC6809_INSN_HALT) != 0) {       // 0x80
 448                 if(clock <= 1) clock = 1;
 449                 icount += clock;
 450                 first_icount = icount;
 451                 while(icount > 0) {
 452                         RM(PCD); //Will save.Need to keep.
 453                         icount -= 1;
 454                 }
 455                 icount -= extra_icount;
 456                 passed_icount = first_icount - icount;
 457                 extra_icount = 0;
 458                 PC++;
 459                 debugger_hook();
 460                 total_icount += passed_icount;
 461                 cpu_wait(passed_icount);
 462                 return passed_icount;
 463         }
 464         /*
 465          * Check Interrupt
 466          */
 467 check_nmi:
 468         if ((int_state & (MC6809_NMI_BIT | MC6809_FIRQ_BIT | MC6809_IRQ_BIT)) != 0) {   // 0x0007
 469                 if ((int_state & MC6809_NMI_BIT) == 0)
 470                         goto check_firq;
 471                 int_state &= ~MC6809_SYNC_IN; // Thanks to Ryu Takegami.
 472                 write_signals(&outputs_bus_ba, 0x00000000);
 473                 write_signals(&outputs_bus_bs, 0x00000000);
 474                 if((int_state & MC6809_CWAI_IN) == 0) {
 475                         CC = CC | CC_E;
 476                         cycle += 14;
 477                         cpu_nmi_push();
 478                 }
 479                 write_signals(&outputs_bus_bs, 0xffffffff);
 480                 CC = CC | CC_II | CC_IF;        // 0x50
 481                 cycle += 2;
 482                 cpu_nmi_fetch_vector_address();
 483                 cycle += 3;
 484                 write_signals(&outputs_bus_bs, 0x00000000);
 485                 int_state &= ~(MC6809_NMI_BIT | MC6809_SYNC_IN | MC6809_SYNC_OUT);      // $FF1E
 486                 goto int_cycle;
 487         } else {
 488                 // OK, none interrupts.
 489                 goto check_ok;
 490         }
 491 check_firq:
 492         if ((int_state & MC6809_FIRQ_BIT) != 0) {
 493                 int_state &= ~MC6809_SYNC_IN; // Moved to before checking MASK.Thanks to Ryu Takegami.
 494                 if ((CC & CC_IF) != 0)
 495                         goto check_irq;
 496                 write_signals(&outputs_bus_bs, 0x00000000);
 497                 write_signals(&outputs_bus_ba, 0x00000000);
 498                 if((int_state & MC6809_CWAI_IN) == 0) {
 499                         CC = CC & (uint8_t)(~CC_E);
 500                         cycle += 5;
 501                         cpu_firq_push();
 502                 }
 503                 write_signals(&outputs_bus_bs, 0xffffffff);
 504                 CC = CC | CC_II | CC_IF;        // 0x50
 505                 cycle += 2;
 506                 cpu_firq_fetch_vector_address();
 507                 cycle += 3;
 508                 write_signals(&outputs_bus_bs, 0x00000000);
 509                 int_state &= ~(MC6809_SYNC_IN | MC6809_SYNC_OUT);       // $FF1E
 510                 goto int_cycle;
 511
 512         }
 513 check_irq:
 514         if ((int_state & MC6809_IRQ_BIT) != 0) {
 515                 int_state &= ~MC6809_SYNC_IN; // Moved to before checking MASK.Thanks to Ryu Takegami.
 516                 if ((CC & CC_II) != 0)
 517                         goto check_ok;
 518                 write_signals(&outputs_bus_bs, 0x00000000);
 519                 write_signals(&outputs_bus_ba, 0x00000000);
 520                 if((int_state & MC6809_CWAI_IN) == 0) {
 521                         CC = CC | CC_E;
 522                         cycle += 14;
 523                         cpu_irq_push();
 524                 }
 525                 write_signals(&outputs_bus_bs, 0xffffffff);
 526                 cycle += 2;
 527                 CC = CC | CC_II;        // 0x50
 528                 cpu_irq_fetch_vector_address();
 529                 cycle += 3;
 530                 write_signals(&outputs_bus_bs, 0x00000000);
 531                 int_state &= ~(MC6809_SYNC_IN | MC6809_SYNC_OUT);       // $FF1E
 532                 goto int_cycle;
 533         }
 534         /*
 535          * NO INTERRUPT
 536          */
 537         goto check_ok;
 538         /*
 539          * INTERRUPT
 540          */
 541 int_cycle:
 542         if((int_state & MC6809_CWAI_IN) != 0) {
 543                 int_state &= ~MC6809_CWAI_IN;
 544         }
 545         if(clock >= 0) icount += clock;
 546         first_icount = icount;
 547         icount -= cycle;
 548         debugger_hook();
 549         icount -= extra_icount;
 550         passed_icount = first_icount - icount;
 551         extra_icount = 0;
 552         total_icount += (uint64_t)passed_icount;
 553         cpu_wait(passed_icount);
 554 #if 1
 555         if((icount <= 0) || (clock <= passed_icount)) return passed_icount;
 556         clock -= passed_icount;
 557 #else
 558         return passed_icount;
 559 #endif
 560         // goto check_ok;
 561         // run cpu
 562 check_ok:
 563         if((int_state & MC6809_SYNC_IN) != 0) {
 564                 int tmp_passed_icount = 0;
 565                 first_icount = icount;
 566                 if(clock < 1) clock = 1;
 567                 icount -= extra_icount;
 568                 icount -= clock;
 569                 extra_icount = 0;
 570                 debugger_hook();
 571                 tmp_passed_icount = first_icount - icount;
 572                 total_icount += (uint64_t)passed_icount;
 573                 cpu_wait(tmp_passed_icount);
 574                 return passed_icount + tmp_passed_icount;
 575         }
 576         if((int_state & MC6809_CWAI_IN) == 0) {
 577                 if(clock <= -1) {
 578                         // run only one opcode
 579                         int tmp_passed_icount = 0;
 580                         first_icount = icount;
 581                         insns_count++;
 582                         run_one_opecode();
 583                         tmp_passed_icount = first_icount - icount;
 584                         cpu_wait(tmp_passed_icount);
 585                         return passed_icount + tmp_passed_icount;;
 586                 } else {
 587                         // run cpu while given clocks
 588                         int tmp_passed_icount = 0;
 589                         icount += clock;
 590                         first_icount = icount;
 591                         while((icount > 0) && (!(req_halt_on) && !(req_halt_off)) && (!busreq)) {
 592                                 insns_count++;
 593                                 run_one_opecode();
 594                         }
 595                         tmp_passed_icount = first_icount - icount;
 596                         cpu_wait(tmp_passed_icount);
 597                         return tmp_passed_icount + passed_icount;
 598                 }
 599         } else { // CWAI_IN
 600                 int tmp_passed_icount = 0;
 601                 first_icount = icount;
 602                 if(clock < 1) clock = 1;
 603                 icount -= extra_icount;
 604                 icount -= clock;
 605                 extra_icount = 0;
 606                 debugger_hook();
 607                 tmp_passed_icount = first_icount - icount;
 608                 total_icount += tmp_passed_icount;
 609                 cpu_wait(tmp_passed_icount);
 610                 return passed_icount + tmp_passed_icount;
 611         }
 612
 613 }
 614
 615 void MC6809::run_one_opecode()
 616 {
 617         if(__USE_DEBUGGER) {
 618                 bool now_debugging = d_debugger->now_debugging;
 619                 if(now_debugging) {
 620                         d_debugger->check_break_points(PC);
 621                         if(d_debugger->now_suspended) {
 622                                 d_debugger->now_waiting = true;
 623                                 emu->start_waiting_in_debugger();
 624                                 while(d_debugger->now_debugging && d_debugger->now_suspended) {
 625                                         emu->process_waiting_in_debugger();
 626                                 }
 627                                 emu->finish_waiting_in_debugger();
 628                                 d_debugger->now_waiting = false;
 629                         }
 630                         if(d_debugger->now_debugging) {
 631                                 d_mem = d_debugger;
 632                         } else {
 633                                 now_debugging = false;
 634                         }
 635
 636                         d_debugger->add_cpu_trace(PC & 0xffff);
 637                         int first_icount = icount;
 638                         pPPC = pPC;
 639                         uint8_t ireg = ROP(PCD);
 640                         PC++;
 641                         icount -= cycles1[ireg];
 642                         icount -= extra_icount;
 643                         extra_icount = 0;
 644                         op(ireg);
 645                         total_icount += first_icount - icount;
 646
 647                         if(now_debugging) {
 648                                 if(!d_debugger->now_going) {
 649                                         d_debugger->now_suspended = true;
 650                                 }
 651                                 d_mem = d_mem_stored;
 652                         }
 653                 } else {
 654                         d_debugger->add_cpu_trace(PC & 0xffff);
 655                         int first_icount = icount;
 656                         pPPC = pPC;
 657                         uint8_t ireg = ROP(PCD);
 658                         PC++;
 659                         icount -= cycles1[ireg];
 660                         icount -= extra_icount;
 661                         extra_icount = 0;
 662                         op(ireg);
 663                         total_icount += first_icount - icount;
 664                 }
 665         } else {
 666                 pPPC = pPC;
 667                 d_debugger->add_cpu_trace(PC & 0xffff);
 668                 uint8_t ireg = ROP(PCD);
 669                 PC++;
 670                 icount -= cycles1[ireg];
 671                 icount -= extra_icount;
 672                 extra_icount = 0;
 673                 op(ireg);
 674         }
 675 }
 676
 677 void MC6809::debugger_hook()
 678 {
 679         if(__USE_DEBUGGER) {
 680                 bool now_debugging = d_debugger->now_debugging;
 681                 if(now_debugging) {
 682                         d_debugger->check_break_points(PC);
 683                         if(d_debugger->now_suspended) {
 684                                 d_debugger->now_waiting = true;
 685                                 emu->start_waiting_in_debugger();
 686                                 while(d_debugger->now_debugging && d_debugger->now_suspended) {
 687                                         emu->process_waiting_in_debugger();
 688                                 }
 689                                 emu->finish_waiting_in_debugger();
 690                                 d_debugger->now_waiting = false;
 691                         }
 692                         if(d_debugger->now_debugging) {
 693                                 d_mem = d_debugger;
 694                         } else {
 695                                 now_debugging = false;
 696                         }
 697
 698                         //d_debugger->add_cpu_trace(PC);
 699                         int first_icount = icount;
 700                         //pPPC = pPC;
 701                         if(now_debugging) {
 702                                 if(!d_debugger->now_going) {
 703                                         d_debugger->now_suspended = true;
 704                                 }
 705                                 d_mem = d_mem_stored;
 706                         }
 707                 }
 708         }
 709 }
 710
 711 void MC6809::op(uint8_t ireg)
 712 {
 713         //printf("CPU(%08x) PC=%04x OP=%02x %02x %02x %02x %02x\n", (void *)this, PC, ireg, RM(PC), RM(PC + 1), RM(PC + 2), RM(PC + 3));
 714
 715         (this->*m6809_main[ireg])();
 716 }
 717
 718
 719 void MC6809::write_debug_data8(uint32_t addr, uint32_t data)
 720 {
 721         if(__USE_DEBUGGER) d_mem_stored->write_data8(addr, data);
 722 }
 723
 724 uint32_t MC6809::read_debug_data8(uint32_t addr)
 725 {
 726         if(__USE_DEBUGGER) {
 727                 return d_mem_stored->read_data8(addr);
 728         }
 729         return 0xff;
 730 }
 731
 732 void MC6809::write_debug_io8(uint32_t addr, uint32_t data)
 733 {
 734         if(__USE_DEBUGGER) d_mem_stored->write_io8(addr, data);
 735 }
 736
 737 uint32_t MC6809::read_debug_io8(uint32_t addr)
 738 {
 739         if(__USE_DEBUGGER) {
 740                 uint8_t val = d_mem_stored->read_io8(addr);
 741                 return val;
 742         }
 743         return 0xff;
 744 }
 745
 746 inline void MC6809::fetch_effective_address()
 747 {
 748         uint8_t postbyte;
 749         uint8_t upper, lower;
 750
 751         IMMBYTE(postbyte);
 752
 753         upper = (postbyte >> 4) & 0x0f;
 754         lower = postbyte & 0x0f;
 755         switch (upper) {
 756                 case 0x00:
 757                         EA = X + lower;
 758                         break;
 759                 case 0x01:
 760                         EA = X - 16 + lower;
 761                         break;
 762                 case 0x02:
 763                         EA = Y + lower;
 764                         break;
 765                 case 0x03:
 766                         EA = Y - 16 + lower;
 767                         break;
 768                 case 0x04:
 769                         EA = U + lower;
 770                         break;
 771                 case 0x05:
 772                         EA = U - 16 + lower;
 773                         break;
 774                 case 0x06:
 775                         EA = S + lower;
 776                         break;
 777                 case 0x07:
 778                         EA = S - 16 + lower;
 779                         break;
 780                 default:
 781                         fetch_effective_address_IDX(upper, lower);
 782                         break;
 783         }
 784         EAD &= 0xffff;
 785         icount -= index_cycle_em[postbyte];
 786 }
 787
 788 inline void MC6809::fetch_effective_address_IDX(uint8_t upper, uint8_t lower)
 789 {
 790         bool indirect = false;
 791         uint16_t *reg;
 792         uint8_t bx_p;
 793         pair32_t pp;
 794
 795         indirect = ((upper & 0x01) != 0) ? true : false;
 796
 797         switch ((upper >> 1) & 0x03) {  // $8-$f >> 1 = $4 - $7 : delete bit2
 798                 case 0: // $8x,$9x
 799                         reg = &X;
 800                         break;
 801                 case 1: // $ax,$bx
 802                         reg = &Y;
 803                         break;
 804                 case 2: // $cx,$dx
 805                         reg = &U;
 806                         break;
 807                 case 3: // $ex,$fx
 808                         reg = &S;
 809                         break;
 810         }
 811
 812         switch (lower) {
 813                 case 0: // ,r+
 814                         EA = *reg;
 815                         *reg = *reg + 1;
 816                         *reg = *reg & 0xffff;
 817                         break;
 818                 case 1: // ,r++
 819                         EA = *reg;
 820                         *reg = *reg + 2;
 821                         *reg = *reg & 0xffff;
 822                         break;
 823                 case 2: // ,-r
 824                         *reg = *reg - 1;
 825                         *reg = *reg & 0xffff;
 826                         EA = *reg;
 827                         break;
 828                 case 3: // ,--r
 829                         *reg = *reg - 2;
 830                         *reg = *reg & 0xffff;
 831                         EA = *reg;
 832                         break;
 833                 case 4: // ,r
 834                         EA = *reg;
 835                         break;
 836                 case 5: // b,r
 837                         EA = *reg + SIGNED(B);
 838                         break;
 839                 case 6: // a,r
 840                 case 7:
 841                         EA = *reg + SIGNED(A);
 842                         break;
 843                 case 8: // $xx,r
 844                         IMMBYTE(bx_p);
 845                         EA = *reg + SIGNED(bx_p);
 846                         break;
 847                 case 9: // $xxxx, r
 848                         IMMWORD(EAP);
 849                         EA = EA + *reg;
 850                         break;
 851                 case 0x0a:      // Undocumented
 852                         EA = PC;
 853                         EA++;
 854                         EAP.w.l |= 0x00ff;
 855                         break;
 856                 case 0x0b:      // D,r
 857                         EA = *reg + D;
 858                         break;
 859                 case 0x0c:      // xx,pc
 860                         IMMBYTE(bx_p);
 861                         EA = PC + SIGNED(bx_p);
 862                         break;
 863                 case 0x0d:      // xxxx,pc
 864                         IMMWORD(EAP);
 865                         EA = EA + PC;
 866                         break;
 867                 case 0x0e:      // Undocumented
 868                         EA = 0xffff;
 869                         break;
 870                 case 0x0f:
 871                         IMMWORD(EAP);
 872                         break;
 873         }
 874         EAP.w.h = 0x0000;
 875         // $9x,$bx,$dx,$fx = INDIRECT
 876         if (indirect) {
 877                 pp = EAP;
 878                 EAP = RM16_PAIR(pp.d);
 879         }
 880 }
 881
 882 #define IIError() illegal()
 883
 884 OP_HANDLER(illegal)
 885 {
 886         //logerror("M6809: illegal opcode at %04x\n",PC);
 887         //printf("M6809: illegal opcode at %04x %02x %02x %02x %02x %02x \n",
 888         //       PC - 2, RM(PC - 2), RM(PC - 1), RM(PC), RM(PC + 1), RM(PC + 2));
 889 //        PC-=1;
 890 }
 891
 892 inline uint8_t MC6809::GET_INDEXED_DATA(void)
 893 {
 894         uint8_t t;
 895         fetch_effective_address();
 896         t = RM(EAD);
 897         return t;
 898 }
 899
 900 inline pair32_t MC6809::GET_INDEXED_DATA16(void)
 901 {
 902         pair32_t t;
 903         fetch_effective_address();
 904         t = RM16_PAIR(EAD);
 905         return t;
 906 }
 907
 908 // $x0, $x1
 909 inline void MC6809::NEG_MEM(uint8_t a_neg)
 910 {
 911         uint16_t r_neg;
 912         r_neg = 0 - (uint16_t)a_neg;
 913         CLR_NZVC;
 914         SET_FLAGS8(0, a_neg, r_neg);
 915         WM(EAD, r_neg);
 916 }
 917
 918 inline uint8_t MC6809::NEG_REG(uint8_t a_neg)
 919 {
 920         uint16_t r_neg;
 921         r_neg = 0 - (uint16_t)a_neg;
 922         CLR_NZVC;
 923         SET_FLAGS8(0, a_neg, r_neg);
 924         return (uint8_t)r_neg;
 925 }
 926
 927
 928 // $x2
 929 inline void MC6809::COM_MEM(uint8_t a_com)
 930 {
 931         uint8_t t_com;
 932         t_com = ~a_com;
 933         CLR_NZVC;
 934         SET_NZ8(t_com);
 935         SEC;
 936         WM(EAD, t_com);
 937 }
 938
 939 inline uint8_t MC6809::COM_REG(uint8_t r_com)
 940 {
 941         r_com = ~r_com;
 942         CLR_NZVC;
 943         SET_NZ8(r_com);
 944         SEC;
 945         return r_com;
 946 }
 947
 948 inline void MC6809::LSR_MEM(uint8_t t)
 949 {
 950         CLR_NZC;
 951         CC = CC | (t & CC_C);
 952         t >>= 1;
 953         SET_NZ8(t);
 954         WM(EAD, t);
 955 }
 956
 957 inline uint8_t MC6809::LSR_REG(uint8_t r)
 958 {
 959         CLR_NZC;
 960         CC |= (r & CC_C);
 961         r >>= 1;
 962         SET_NZ8(r);
 963         return r;
 964 }
 965
 966 inline void MC6809::ROR_MEM(uint8_t t)
 967 {
 968         uint8_t r;
 969         r = (CC & CC_C) << 7;
 970         CLR_NZC;
 971         CC |= (t & CC_C);
 972         t >>= 1;
 973         r |= t;
 974         SET_NZ8(r); //NZ8?
 975         WM(EAD, r);
 976 }
 977
 978 inline uint8_t MC6809::ROR_REG(uint8_t t)
 979 {
 980         uint8_t r;
 981         r = (CC & CC_C) << 7;
 982         CLR_NZC;
 983         CC |= (t & CC_C);
 984         t >>= 1;
 985         r |= t;
 986         SET_NZ8(r); //NZ8?
 987         return r;
 988 }
 989
 990
 991 inline void MC6809::ASR_MEM(uint8_t t)
 992 {
 993         uint8_t r;
 994         CLR_NZC;
 995         CC = CC | (t & CC_C);
 996         r = (t & 0x80) | (t >> 1);
 997         // H is undefined
 998         SET_NZ8(r);
 999         //SET_H(t, t, r);
1000         WM(EAD, r);
1001 }
1002
1003 inline uint8_t MC6809::ASR_REG(uint8_t t)
1004 {
1005         uint8_t r;
1006         CLR_NZC;
1007         CC = CC | (t & CC_C);
1008         r = (t & 0x80) | (t >> 1);
1009         // H is undefined
1010         SET_NZ8(r);
1011         //SET_H(t, t, r);
1012         return r;
1013 }
1014
1015 inline void MC6809::ASL_MEM(uint8_t t)
1016 {
1017         uint16_t r, tt;
1018         tt = (uint16_t)t & 0x00ff;
1019         r = tt << 1;
1020         CLR_NZVC;
1021         SET_FLAGS8(tt, tt, r);
1022         //SET_H(tt, tt, r);
1023         WM(EAD, (uint8_t)r);
1024 }
1025
1026 inline uint8_t MC6809::ASL_REG(uint8_t t)
1027 {
1028         uint16_t r, tt;
1029         tt = (uint16_t)t & 0x00ff;
1030         r = tt << 1;
1031         CLR_NZVC;
1032         SET_FLAGS8(tt, tt, r);
1033         //SET_H(tt, tt, r);
1034         return (uint8_t)r;
1035 }
1036
1037 inline void MC6809::ROL_MEM(uint8_t t)
1038 {
1039         uint16_t r, tt;
1040         tt = (uint16_t)t & 0x00ff;
1041         r = (CC & CC_C) | (tt << 1);
1042         CLR_NZVC;
1043         //SET_NZ8(r);
1044         //if(t & 0x80) {
1045         //      SEC;
1046         //      if((r & 0x80) == 0)SEV;
1047         //} else {
1048         //      if((r & 0x80) != 0) SEV;
1049         //}
1050         SET_FLAGS8(tt, tt, r);
1051         WM(EAD, (uint8_t)r);
1052 }
1053
1054 inline uint8_t MC6809::ROL_REG(uint8_t t)
1055 {
1056         uint16_t r, tt;
1057         tt = (uint16_t)t & 0x00ff;
1058         r = (CC & CC_C) | (tt << 1);
1059         CLR_NZVC;
1060         //SET_NZ8(r);
1061         //if(t & 0x80) {
1062         //      SEC;
1063         //      if((r & 0x80) == 0) SEV;
1064         //} else {
1065         //      if((r & 0x80) != 0) SEV;
1066         //}
1067         SET_FLAGS8(tt, tt, r);
1068         return (uint8_t)r;
1069 }
1070
1071 inline void MC6809::DEC_MEM(uint8_t t)
1072 {
1073         uint16_t tt;
1074         tt = t - 1;
1075         CLR_NZV;
1076         SET_FLAGS8D(tt);
1077         WM(EAD, tt);
1078 }
1079
1080 inline uint8_t MC6809::DEC_REG(uint8_t t)
1081 {
1082         uint8_t tt;
1083         tt = t - 1;
1084         CLR_NZV;
1085         SET_FLAGS8D(tt);
1086         return tt;
1087 }
1088
1089 inline void MC6809::DCC_MEM(uint8_t t)
1090 {
1091         uint16_t tt, ss;
1092         tt = t - 1;
1093         CLR_NZVC;
1094         SET_FLAGS8D(tt);
1095         ss = CC;
1096         ss >>= 2;
1097         ss = ~ss;
1098         ss = ss & CC_C;
1099         CC = ss | CC;
1100         WM(EAD, tt);
1101 }
1102
1103 inline uint8_t MC6809::DCC_REG(uint8_t t)
1104 {
1105         uint16_t tt, ss;
1106         tt = t - 1;
1107         CLR_NZVC;
1108         SET_FLAGS8D(tt);
1109         ss = CC;
1110         ss >>= 2;
1111         ss = ~ss;
1112         ss = ss & CC_C;
1113         CC = ss | CC;
1114         return (uint8_t)tt;
1115 }
1116
1117 inline void MC6809::INC_MEM(uint8_t t)
1118 {
1119         uint16_t tt = t + 1;
1120         CLR_NZV;
1121         SET_FLAGS8I(tt);
1122         WM(EAD, tt);
1123 }
1124
1125 inline uint8_t MC6809::INC_REG(uint8_t t)
1126 {
1127         uint16_t tt = t + 1;
1128         CLR_NZV;
1129         SET_FLAGS8I(tt);
1130         return (uint8_t)tt;
1131 }
1132
1133 inline void MC6809::TST_MEM(uint8_t t)
1134 {
1135         CLR_NZV;
1136         SET_NZ8(t);
1137 }
1138
1139 inline uint8_t MC6809::TST_REG(uint8_t t)
1140 {
1141         CLR_NZV;
1142         SET_NZ8(t);
1143         return t;
1144 }
1145
1146 inline uint8_t MC6809::CLC_REG(uint8_t t)
1147 {
1148         uint8_t r;
1149         r = 0;
1150         CLR_NZV;
1151         SEZ;
1152         return r;
1153 }
1154
1155
1156 inline void MC6809::CLR_MEM(uint8_t t)
1157 {
1158         WM(EAD, 0);
1159         CLR_NZVC;
1160         SEZ;
1161 }
1162
1163 inline uint8_t MC6809::CLR_REG(uint8_t t)
1164 {
1165         CLR_NZVC;
1166         SEZ;
1167         return 0;
1168 }
1169
1170 inline uint8_t MC6809::SUB8_REG(uint8_t reg, uint8_t data)
1171 {
1172         uint16_t r;
1173         r = (uint16_t)reg - (uint16_t)data;
1174         CLR_HNZVC;
1175         // H is undefined
1176         SET_FLAGS8(reg, data, r);
1177         return (uint8_t)r;
1178 }
1179
1180 inline uint8_t MC6809::CMP8_REG(uint8_t reg, uint8_t data)
1181 {
1182         uint16_t r;
1183         r = (uint16_t)reg - (uint16_t)data;
1184         CLR_NZVC;
1185         // H is undefined
1186         SET_FLAGS8(reg, data, r);
1187         return reg;
1188 }
1189
1190 inline uint8_t MC6809::SBC8_REG(uint8_t reg, uint8_t data)
1191 {
1192         uint16_t r;
1193         uint8_t cc_c = CC & CC_C;
1194         r = (uint16_t)reg - (uint16_t)data - (uint16_t)cc_c;
1195         CLR_HNZVC;
1196         SET_FLAGS8(reg, (data + cc_c) , r);
1197         return (uint8_t)r;
1198 }
1199
1200 inline uint8_t MC6809::AND8_REG(uint8_t reg, uint8_t data)
1201 {
1202         uint8_t r = reg;
1203         r &= data;
1204         CLR_NZV;
1205         SET_NZ8(r);
1206         return r;
1207 }
1208
1209 inline uint8_t MC6809::BIT8_REG(uint8_t reg, uint8_t data)
1210 {
1211         uint16_t r;
1212         r = reg & data;
1213         CLR_NZV;
1214         SET_NZ8(r);
1215         SET_V8(reg, data, r);
1216         return reg;
1217 }
1218
1219 inline uint8_t MC6809::EOR8_REG(uint8_t reg, uint8_t data)
1220 {
1221         uint8_t r = reg;
1222         r ^= data;
1223         CLR_NZV;
1224         SET_NZ8(r);
1225         return r;
1226 }
1227
1228 inline uint8_t MC6809::OR8_REG(uint8_t reg, uint8_t data)
1229 {
1230         uint8_t r = reg;
1231         r |= data;
1232         CLR_NZV;
1233         SET_NZ8(r);
1234         return r;
1235 }
1236
1237 inline uint8_t MC6809::ADD8_REG(uint8_t reg, uint8_t data)
1238 {
1239         uint16_t t, r;
1240         t = (uint16_t) data;
1241         t &= 0x00ff;
1242         r = reg + t;
1243         CLR_HNZVC;
1244         SET_HNZVC8(reg, t, r);
1245         return (uint8_t)r;
1246 }
1247
1248 inline uint8_t MC6809::ADC8_REG(uint8_t reg, uint8_t data)
1249 {
1250         uint16_t t, r;
1251         uint8_t c_cc = CC & CC_C;
1252         t = (uint16_t) data;
1253         t &= 0x00ff;
1254         r = reg + t + c_cc;
1255         CLR_HNZVC;
1256         SET_HNZVC8(reg, (t + c_cc), r);
1257         return (uint8_t)r;
1258 }
1259
1260 inline uint8_t MC6809::LOAD8_REG(uint8_t reg)
1261 {
1262         CLR_NZV;
1263         SET_NZ8(reg);
1264         return reg;
1265 }
1266
1267 inline void MC6809::STORE8_REG(uint8_t reg)
1268 {
1269         CLR_NZV;
1270         SET_NZ8(reg);
1271         WM(EAD, reg);
1272 }
1273
1274 inline uint16_t MC6809::LOAD16_REG(uint16_t reg)
1275 {
1276         CLR_NZV;
1277         SET_NZ16(reg);
1278         return reg;
1279 }
1280
1281
1282 inline uint16_t MC6809::SUB16_REG(uint16_t reg, uint16_t data)
1283 {
1284         uint32_t r, d;
1285         d = reg;
1286         r = d - data;
1287         CLR_NZVC;
1288         SET_FLAGS16(d, data, r);
1289         return (uint16_t)r;
1290 }
1291
1292 inline uint16_t MC6809::ADD16_REG(uint16_t reg, uint16_t data)
1293 {
1294         uint32_t r, d;
1295         d = reg;
1296         r = d + (uint32_t)data;
1297         CLR_HNZVC;
1298         SET_HNZVC16(d, data, r);
1299         return (uint16_t)r;
1300 }
1301
1302 inline uint16_t MC6809::CMP16_REG(uint16_t reg, uint16_t data)
1303 {
1304         uint32_t r, d;
1305         d = reg;
1306         r = d - data;
1307         CLR_NZVC;
1308         SET_FLAGS16(d, data, r);
1309         return reg;
1310 }
1311
1312 inline void MC6809::STORE16_REG(pair32_t *p)
1313 {
1314         CLR_NZV;
1315         SET_NZ16(p->w.l);
1316         WM16(EAD, p);
1317 }
1318
1319
1320 /* $00 NEG direct ?**** */
1321 OP_HANDLER(neg_di) {
1322         uint8_t t;
1323         DIRBYTE(t);
1324         NEG_MEM(t);
1325 }
1326
1327 /* $01 Undefined Neg */
1328 /* $03 COM direct -**01 */
1329 OP_HANDLER(com_di) {
1330         uint8_t t;
1331         DIRBYTE(t);
1332         COM_MEM(t);
1333 }
1334
1335 /* $02 NGC Direct (Undefined) */
1336 OP_HANDLER(ngc_di) {
1337         if ((CC & CC_C) == 0) {
1338                 neg_di();
1339         }
1340         else {
1341                 com_di();
1342         }
1343 }
1344
1345
1346 /* $04 LSR direct -0*-* */
1347 OP_HANDLER(lsr_di) {
1348         uint8_t t;
1349         DIRBYTE(t);
1350         LSR_MEM(t);
1351 }
1352
1353 /* $05 ILLEGAL */
1354
1355 /* $06 ROR direct -**-* */
1356 OP_HANDLER(ror_di) {
1357         uint8_t t;
1358         DIRBYTE(t);
1359         ROR_MEM(t);
1360 }
1361
1362 /* $07 ASR direct ?**-* */
1363 OP_HANDLER(asr_di) {
1364         uint8_t t;
1365         DIRBYTE(t);
1366         ASR_MEM(t);
1367 }
1368
1369 /* $08 ASL direct ?**** */
1370 OP_HANDLER(asl_di) {
1371         uint8_t t;
1372         DIRBYTE(t);
1373         ASL_MEM(t);
1374 }
1375
1376 /* $09 ROL direct -**** */
1377 OP_HANDLER(rol_di) {
1378         uint8_t t;
1379         DIRBYTE(t);
1380         ROL_MEM(t);
1381 }
1382
1383 /* $0A DEC direct -***- */
1384 OP_HANDLER(dec_di) {
1385         uint8_t t;
1386         DIRBYTE(t);
1387         DEC_MEM(t);
1388 }
1389
1390 /* $0B DCC direct */
1391 OP_HANDLER(dcc_di) {
1392         uint8_t t;
1393         DIRBYTE(t);
1394         DCC_MEM(t);
1395 }
1396
1397
1398 /* $OC INC direct -***- */
1399 OP_HANDLER(inc_di) {
1400         uint8_t t;
1401         DIRBYTE(t);
1402         INC_MEM(t);
1403 }
1404
1405 /* $OD TST direct -**0- */
1406 OP_HANDLER(tst_di) {
1407         uint8_t t;
1408         DIRBYTE(t);
1409         t = RM(EAD);
1410         TST_MEM(t);
1411 }
1412
1413 /* $0E JMP direct ----- */
1414 OP_HANDLER(jmp_di) {
1415         DIRECT;
1416         PC = EA;
1417 }
1418
1419 /* $0F CLR direct -0100 */
1420 OP_HANDLER(clr_di) {
1421         uint8_t dummy;
1422         DIRECT;
1423         dummy = RM(EAD);        // Dummy Read(Alpha etc...)
1424         CLR_MEM(dummy);
1425 }
1426
1427 /* $10 FLAG */
1428
1429 /* $11 FLAG */
1430
1431 /* $12 NOP inherent ----- */
1432 OP_HANDLER(nop) {
1433         ;
1434 }
1435
1436 /* $13 SYNC inherent ----- */
1437 OP_HANDLER(sync_09)     // Rename 20101110
1438 {
1439         int_state |= MC6809_SYNC_IN;
1440         write_signals(&outputs_bus_ba, 0xffffffff);
1441         write_signals(&outputs_bus_bs, 0x00000000);
1442 }
1443
1444
1445
1446 /* $14 trap(HALT) */
1447 OP_HANDLER(trap) {
1448         int_state |= MC6809_INSN_HALT;  // HALT繝輔Λ繧ｰ
1449         // Debug: 繝医Λ繝・・隕∝屏
1450         this->out_debug_log(_T("TRAP(HALT) @%04x %02x %02x\n"), PC - 1, RM((PC - 1)), RM(PC));
1451 }
1452
1453 /* $15 trap */
1454
1455 /* $16 LBRA relative ----- */
1456 OP_HANDLER(lbra) {
1457         LBRANCH(true);
1458 }
1459
1460 /* $17 LBSR relative ----- */
1461 OP_HANDLER(lbsr) {
1462         IMMWORD(EAP);
1463         PUSHWORD(pPC);
1464         PC += EAD;
1465 }
1466
1467 /* $18 ASLCC */
1468
1469 OP_HANDLER(aslcc_in) {
1470         uint8_t cc_r = CC;
1471         if ((cc_r & CC_Z) != 0x00) { //20100824 Fix
1472                 cc_r |= CC_C;
1473         }
1474         cc_r <<= 1;
1475         cc_r &= 0x3e;
1476         CC = cc_r;
1477 }
1478
1479 /* $19 DAA inherent (A) -**0* */
1480 OP_HANDLER(daa) {
1481         uint8_t msn, lsn;
1482         uint16_t t, cf = 0;
1483         msn = A & 0xf0;
1484         lsn = A & 0x0f;
1485         if (lsn > 0x09 || CC & CC_H)
1486                 cf |= 0x06;
1487         if (msn > 0x80 && lsn > 0x09)
1488                 cf |= 0x60;
1489         if (msn > 0x90 || CC & CC_C)
1490                 cf |= 0x60;
1491         t = cf + A;
1492         CLR_NZV;        /* keep carry from previous operation */
1493         SET_NZ8((uint8_t) t);
1494         SET_C8(t);
1495         A = (uint8_t)t;
1496 }
1497
1498
1499 /* $1A ORCC immediate ##### */
1500 OP_HANDLER(orcc) {
1501         uint8_t t;
1502         IMMBYTE(t);
1503         CC |= t;
1504 }
1505
1506 /* $1B ILLEGAL */
1507
1508
1509 /* $1C ANDCC immediate ##### */
1510 OP_HANDLER(andcc) {
1511         uint8_t t;
1512         IMMBYTE(t);
1513         CC &= t;
1514 //  check_irq_lines(); /* HJB 990116 */
1515 }
1516
1517 /* $1D SEX inherent -**-- */
1518 OP_HANDLER(sex) {
1519         uint16_t t;
1520         t = SIGNED(B);
1521         D = t; // Endian OK?
1522         //  CLR_NZV;    Tim Lindner 20020905: verified that V flag is not affected
1523         CLR_NZ;
1524         SET_NZ16(t);
1525 }
1526
1527         /* $1E EXG inherent ----- */// 20100825
1528 OP_HANDLER(exg) {
1529         pair32_t t1, t2;
1530         uint8_t tb;
1531         IMMBYTE(tb);
1532         t1.d = 0;
1533         t2.d = 0;
1534         /*
1535          * 20111011: 16bit vs 16Bit縺ｮ貍皮ｮ励↓縺吶ｋ(XM7/ cpu_x86.asm繧医ｊ
1536          */
1537         {
1538                 switch ((tb >> 4) & 15) {
1539                         case 0:
1540                                 t1.w.l = D;
1541                                 break;
1542                         case 1:
1543                                 t1.w.l = X;
1544                                 break;
1545                         case 2:
1546                                 t1.w.l = Y;
1547                                 break;
1548                         case 3:
1549                                 t1.w.l = U;
1550                                 break;
1551                         case 4:
1552                                 t1.w.l = S;
1553                                 break;
1554                         case 5:
1555                                 t1.w.l = PC;
1556                                 break;
1557                         case 8:
1558                                 t1.b.l = A;
1559                                 t1.b.h = 0xff;
1560                                 break;
1561                         case 9:
1562                                 t1.b.l = B;
1563                                 t1.b.h = 0xff;
1564                                 break;
1565                         case 10:
1566                                 t1.b.l = CC;
1567                                 t1.b.h = 0xff;
1568                                 break;
1569                         case 11:
1570                                 t1.b.l = DP;
1571                                 t1.b.h = 0xff;
1572                                 break;
1573                         default:
1574                                 t1.w.l = 0xffff;
1575                                 break;
1576                 }
1577                 switch (tb & 15) {
1578                         case 0:
1579                                 t2.w.l = D;
1580                                 break;
1581                         case 1:
1582                                 t2.w.l = X;
1583                                 break;
1584                         case 2:
1585                                 t2.w.l = Y;
1586                                 break;
1587                         case 3:
1588                                 t2.w.l = U;
1589                                 break;
1590                         case 4:
1591                                 t2.w.l = S;
1592                                 break;
1593                         case 5:
1594                                 t2.w.l = PC;
1595                                 break;
1596                         case 8:
1597                                 t2.b.l = A;
1598                                 t2.b.h = 0xff;
1599                                 break;
1600                         case 9:
1601                                 t2.b.l = B;
1602                                 t2.b.h = 0xff;
1603                                 break;
1604                         case 10:
1605                                 t2.b.l = CC;
1606                                 t2.b.h = 0xff;
1607                                 break;
1608                         case 11:
1609                                 t2.b.l = DP;
1610                                 t2.b.h = 0xff;
1611                                 break;
1612                         default:
1613                                 t2.w.l = 0xffff;
1614                                 break;
1615                 }
1616         }
1617         switch ((tb >> 4) & 15) {
1618                 case 0:
1619                         D = t2.w.l;
1620                         break;
1621                 case 1:
1622                         X = t2.w.l;
1623                         break;
1624                 case 2:
1625                         Y = t2.w.l;
1626                         break;
1627                 case 3:
1628                         U = t2.w.l;
1629                         break;
1630                 case 4:
1631                         S = t2.w.l;
1632                         int_state |= MC6809_LDS;
1633                         break;
1634                 case 5:
1635                         PC = t2.w.l;
1636                         break;
1637                 case 8:
1638                         A = t2.b.l;
1639                         break;
1640                 case 9:
1641                         B = t2.b.l;
1642                         break;
1643                 case 10:
1644                         CC = t2.b.l;
1645                         break;
1646                 case 11:
1647                         DP = t2.b.l;
1648                         break;
1649         }
1650         switch (tb & 15) {
1651                 case 0:
1652                         D = t1.w.l;
1653                         break;
1654                 case 1:
1655                         X = t1.w.l;
1656                         break;
1657                 case 2:
1658                         Y = t1.w.l;
1659                         break;
1660                 case 3:
1661                         U = t1.w.l;
1662                         break;
1663                 case 4:
1664                         S = t1.w.l;
1665                         int_state |= MC6809_LDS;
1666                         break;
1667                 case 5:
1668                         PC = t1.w.l;
1669                         break;
1670                 case 8:
1671                         A = t1.b.l;
1672                         break;
1673                 case 9:
1674                         B = t1.b.l;
1675                         break;
1676                 case 10:
1677                         CC = t1.b.l;
1678                         break;
1679                 case 11:
1680                         DP = t1.b.l;
1681                         break;
1682         }
1683 }
1684
1685 /* $1F TFR inherent ----- */
1686 OP_HANDLER(tfr) {
1687         uint8_t tb;
1688         pair32_t t;
1689         IMMBYTE(tb);
1690         t.d = 0;
1691         /*
1692          * 20111011: 16bit vs 16Bit縺ｮ貍皮ｮ励↓縺吶ｋ(XM7/ cpu_x86.asm繧医ｊ)
1693          */
1694         {
1695                 switch ((tb >> 4) & 15) {
1696                         case 0:
1697                                 t.w.l = D;
1698                                 break;
1699                         case 1:
1700                                 t.w.l = X;
1701                                 break;
1702                         case 2:
1703                                 t.w.l = Y;
1704                                 break;
1705                         case 3:
1706                                 t.w.l = U;
1707                                 break;
1708                         case 4:
1709                                 t.w.l = S;
1710                                 break;
1711                         case 5:
1712                                 t.w.l = PC;
1713                                 break;
1714                         case 8:
1715                                 t.b.l = A;
1716                                 t.b.h = 0xff;
1717                                 break;
1718                         case 9:
1719                                 t.b.l = B;
1720                                 t.b.h = 0xff;
1721                                 break;
1722                         case 10:
1723                                 t.b.l = CC;
1724                                 t.b.h = 0xff;
1725                                 break;
1726                         case 11:
1727                                 t.b.l = DP;
1728                                 t.b.h = 0xff;
1729                                 break;
1730                         default:
1731                                 t.w.l = 0xffff;
1732                                 break;
1733                 }
1734         }
1735         switch (tb & 15) {
1736                 case 0:
1737                         D = t.w.l;
1738                         break;
1739                 case 1:
1740                         X = t.w.l;
1741                         break;
1742                 case 2:
1743                         Y = t.w.l;
1744                         break;
1745                 case 3:
1746                         U = t.w.l;
1747                         break;
1748                 case 4:
1749                         S = t.w.l;
1750                         int_state |= MC6809_LDS;
1751                         break;
1752                 case 5:
1753                         PC = t.w.l;
1754                         break;
1755                 case 8:
1756                         A = t.b.l;
1757                         break;
1758                 case 9:
1759                         B = t.b.l;
1760                         break;
1761                 case 10:
1762                         CC = t.b.l;
1763                         break;
1764                 case 11:
1765                         DP = t.b.l;
1766                         break;
1767         }
1768 }
1769
1770 /* $20 BRA relative ----- */
1771 OP_HANDLER(bra) {
1772         BRANCH(true);
1773 }
1774
1775 /* $21 BRN relative ----- */
1776 OP_HANDLER(brn) {
1777         BRANCH(false);
1778 }
1779
1780 /* $1021 LBRN relative ----- */
1781 OP_HANDLER(lbrn) {
1782         LBRANCH(false);
1783 }
1784
1785 /* $22 BHI relative ----- */
1786 OP_HANDLER(bhi) {
1787         BRANCH(((CC & (CC_Z | CC_C)) == 0));
1788 }
1789
1790 /* $1022 LBHI relative ----- */
1791 OP_HANDLER(lbhi) {
1792         LBRANCH(((CC & (CC_Z | CC_C)) == 0));
1793 }
1794
1795 /* $23 BLS relative ----- */
1796 OP_HANDLER(bls) {
1797         BRANCH(((CC & (CC_Z | CC_C)) != 0));
1798 }
1799
1800 /* $1023 LBLS relative ----- */
1801 OP_HANDLER(lbls) {
1802         LBRANCH(((CC & (CC_Z | CC_C)) != 0));
1803         //LBRANCH((CC & (CC_Z | CC_C)));
1804 }
1805
1806 /* $24 BCC relative ----- */
1807 OP_HANDLER(bcc) {
1808         BRANCH((CC & CC_C) == 0);
1809 }
1810
1811 /* $1024 LBCC relative ----- */
1812 OP_HANDLER(lbcc) {
1813         LBRANCH((CC & CC_C) == 0);
1814 }
1815
1816 /* $25 BCS relative ----- */
1817 OP_HANDLER(bcs) {
1818         BRANCH((CC & CC_C) != 0);
1819 }
1820
1821 /* $1025 LBCS relative ----- */
1822 OP_HANDLER(lbcs) {
1823         LBRANCH((CC & CC_C) != 0);
1824 }
1825
1826 /* $26 BNE relative ----- */
1827 OP_HANDLER(bne) {
1828         BRANCH((CC & CC_Z) == 0);
1829 }
1830
1831 /* $1026 LBNE relative ----- */
1832 OP_HANDLER(lbne) {
1833         LBRANCH((CC & CC_Z) == 0);
1834 }
1835
1836 /* $27 BEQ relative ----- */
1837 OP_HANDLER(beq) {
1838         BRANCH((CC & CC_Z) != 0);
1839 }
1840
1841 /* $1027 LBEQ relative ----- */
1842 OP_HANDLER(lbeq) {
1843         LBRANCH((CC & CC_Z) != 0);
1844 }
1845
1846 /* $28 BVC relative ----- */
1847 OP_HANDLER(bvc) {
1848         BRANCH((CC & CC_V) == 0);
1849 }
1850
1851 /* $1028 LBVC relative ----- */
1852 OP_HANDLER(lbvc) {
1853         LBRANCH((CC & CC_V) == 0);
1854 }
1855
1856 /* $29 BVS relative ----- */
1857 OP_HANDLER(bvs) {
1858         BRANCH((CC & CC_V) != 0);
1859 }
1860
1861 /* $1029 LBVS relative ----- */
1862 OP_HANDLER(lbvs) {
1863         LBRANCH((CC & CC_V) != 0);
1864 }
1865
1866 /* $2A BPL relative ----- */
1867 OP_HANDLER(bpl) {
1868         BRANCH((CC & CC_N) == 0);
1869 }
1870
1871 /* $102A LBPL relative ----- */
1872 OP_HANDLER(lbpl) {
1873         LBRANCH((CC & CC_N) == 0);
1874 }
1875
1876 /* $2B BMI relative ----- */
1877 OP_HANDLER(bmi) {
1878         BRANCH((CC & CC_N) != 0);
1879 }
1880
1881 /* $102B LBMI relative ----- */
1882 OP_HANDLER(lbmi) {
1883         LBRANCH((CC & CC_N) != 0);
1884 }
1885
1886 /* $2C BGE relative ----- */
1887 OP_HANDLER(bge) {
1888         BRANCH(!NXORV);
1889 }
1890
1891 /* $102C LBGE relative ----- */
1892 OP_HANDLER(lbge) {
1893         LBRANCH(!NXORV);
1894 }
1895
1896 /* $2D BLT relative ----- */
1897 OP_HANDLER(blt) {
1898         BRANCH(NXORV);
1899 }
1900
1901 /* $102D LBLT relative ----- */
1902 OP_HANDLER(lblt) {
1903         LBRANCH(NXORV);
1904 }
1905
1906 /* $2E BGT relative ----- */
1907 OP_HANDLER(bgt) {
1908         BRANCH(!(NXORV || (CC & CC_Z)));
1909 }
1910
1911 /* $102E LBGT relative ----- */
1912 OP_HANDLER(lbgt) {
1913         LBRANCH(!(NXORV || (CC & CC_Z)));
1914 }
1915
1916 /* $2F BLE relative ----- */
1917 OP_HANDLER(ble) {
1918         BRANCH((NXORV || (CC & CC_Z)));
1919 }
1920
1921 /* $102F LBLE relative ----- */
1922 OP_HANDLER(lble) {
1923         LBRANCH((NXORV || (CC & CC_Z)));
1924 }
1925
1926 /* $30 LEAX indexed --*-- */
1927 OP_HANDLER(leax) {
1928         fetch_effective_address();
1929         X = EA;
1930         CLR_Z;
1931         SET_Z16(X);
1932 }
1933
1934 /* $31 LEAY indexed --*-- */
1935 OP_HANDLER(leay) {
1936         fetch_effective_address();
1937         Y = EA;
1938         CLR_Z;
1939         SET_Z16(Y);
1940 }
1941
1942 /* $32 LEAS indexed ----- */
1943 OP_HANDLER(leas) {
1944         fetch_effective_address();
1945         S = EA;
1946         int_state |= MC6809_LDS;
1947 }
1948
1949 /* $33 LEAU indexed ----- */
1950 OP_HANDLER(leau) {
1951         fetch_effective_address();
1952         U = EA;
1953 }
1954
1955 /* $34 PSHS inherent ----- */
1956 OP_HANDLER(pshs) {
1957                 uint8_t t;
1958                 IMMBYTE(t);
1959                 //dmy = RM(S);  // Add 20100825
1960                 RM(S);  // Add 20100825
1961                 if (t & 0x80) {
1962                         PUSHWORD(pPC);
1963                         icount -= 2;
1964                 }
1965                 if (t & 0x40) {
1966                         PUSHWORD(pU);
1967                         icount -= 2;
1968                 }
1969                 if (t & 0x20) {
1970                         PUSHWORD(pY);
1971                         icount -= 2;
1972                 }
1973                 if (t & 0x10) {
1974                         PUSHWORD(pX);
1975                         icount -= 2;
1976                 }
1977                 if (t & 0x08) {
1978                         PUSHBYTE(DP);
1979                         icount -= 1;
1980                 }
1981                 if (t & 0x04) {
1982                         PUSHBYTE(B);
1983                         icount -= 1;
1984                 }
1985                 if (t & 0x02) {
1986                         PUSHBYTE(A);
1987                         icount -= 1;
1988                 }
1989                 if (t & 0x01) {
1990                         PUSHBYTE(CC);
1991                         icount -= 1;
1992                 }
1993         }
1994
1995 /* 35 PULS inherent ----- */
1996 OP_HANDLER(puls) {
1997                 uint8_t t;
1998                 IMMBYTE(t);
1999                 if (t & 0x01) {
2000                         PULLBYTE(CC);
2001                         icount -= 1;
2002                 }
2003                 if (t & 0x02) {
2004                         PULLBYTE(A);
2005                         icount -= 1;
2006                 }
2007                 if (t & 0x04) {
2008                         PULLBYTE(B);
2009                         icount -= 1;
2010                 }
2011                 if (t & 0x08) {
2012                         PULLBYTE(DP);
2013                         icount -= 1;
2014                 }
2015                 if (t & 0x10) {
2016                         PULLWORD(pX);
2017                         icount -= 2;
2018                 }
2019                 if (t & 0x20) {
2020                         PULLWORD(pY);
2021                         icount -= 2;
2022                 }
2023                 if (t & 0x40) {
2024                         PULLWORD(pU);
2025                         icount -= 2;
2026                 }
2027                 if (t & 0x80) {
2028                         PULLWORD(pPC);
2029                         icount -= 2;
2030                 }
2031                 //dmy = RM(S);  // Add 20100825
2032                 RM(S);  // Add 20100825
2033                 /* HJB 990225: moved check after all PULLs */
2034 //  if( t&0x01 ) { check_irq_lines(); }
2035         }
2036
2037 /* $36 PSHU inherent ----- */
2038 OP_HANDLER(pshu) {
2039                 uint8_t t;
2040                 IMMBYTE(t);
2041                 //dmy = RM(U);  // Add 20100825
2042                 RM(U);  // Add 20100825
2043                 if (t & 0x80) {
2044                         PSHUWORD(pPC);
2045                         icount -= 2;
2046                 }
2047                 if (t & 0x40) {
2048                         PSHUWORD(pS);
2049                         icount -= 2;
2050                 }
2051                 if (t & 0x20) {
2052                         PSHUWORD(pY);
2053                         icount -= 2;
2054                 }
2055                 if (t & 0x10) {
2056                         PSHUWORD(pX);
2057                         icount -= 2;
2058                 }
2059                 if (t & 0x08) {
2060                         PSHUBYTE(DP);
2061                         icount -= 1;
2062                 }
2063                 if (t & 0x04) {
2064                         PSHUBYTE(B);
2065                         icount -= 1;
2066                 }
2067                 if (t & 0x02) {
2068                         PSHUBYTE(A);
2069                         icount -= 1;
2070                 }
2071                 if (t & 0x01) {
2072                         PSHUBYTE(CC);
2073                         icount -= 1;
2074                 }
2075         }
2076
2077 /* 37 PULU inherent ----- */
2078 OP_HANDLER(pulu) {
2079                 uint8_t t;
2080                 IMMBYTE(t);
2081                 if (t & 0x01) {
2082                         PULUBYTE(CC);
2083                         icount -= 1;
2084                 }
2085                 if (t & 0x02) {
2086                         PULUBYTE(A);
2087                         icount -= 1;
2088                 }
2089                 if (t & 0x04) {
2090                         PULUBYTE(B);
2091                         icount -= 1;
2092                 }
2093                 if (t & 0x08) {
2094                         PULUBYTE(DP);
2095                         icount -= 1;
2096                 }
2097                 if (t & 0x10) {
2098                         PULUWORD(pX);
2099                         icount -= 2;
2100                 }
2101                 if (t & 0x20) {
2102                         PULUWORD(pY);
2103                         icount -= 2;
2104                 }
2105                 if (t & 0x40) {
2106                         PULUWORD(pS);
2107                         icount -= 2;
2108                 }
2109                 if (t & 0x80) {
2110                         PULUWORD(pPC);
2111                         icount -= 2;
2112                 }
2113                 //dmy = RM(U);  // Add 20100825
2114                 RM(U);  // Add 20100825
2115                 /* HJB 990225: moved check after all PULLs */
2116                 //if( t&0x01 ) { check_irq_lines(); }
2117 }
2118
2119 /* $38 ILLEGAL */
2120
2121 /* $39 RTS inherent ----- */
2122 OP_HANDLER(rts) {
2123         //printf("RTS: Before PC=%04x", pPC.w.l);
2124         PULLWORD(pPC);
2125         //printf(" After PC=%04x\n", pPC.w.l);
2126 }
2127
2128 /* $3A ABX inherent ----- */
2129 OP_HANDLER(abx) {
2130         pair32_t bt;
2131         bt.d = 0;
2132         bt.b.l = B;
2133         X = X + bt.w.l;
2134 }
2135
2136 /* $3B RTI inherent ##### */
2137 OP_HANDLER(rti) {
2138                 PULLBYTE(CC);
2139 //  t = CC & CC_E;    /* HJB 990225: entire state saved? */
2140         if ((CC & CC_E) != 0) { // NMIIRQ
2141                 icount -= 9;
2142                 PULLBYTE(A);
2143                 PULLBYTE(B);
2144                 PULLBYTE(DP);
2145                 PULLWORD(pX);
2146                 PULLWORD(pY);
2147                 PULLWORD(pU);
2148         }
2149         PULLWORD(pPC);
2150 //  check_irq_lines(); /* HJB 990116 */
2151 }
2152
2153 /* $3C CWAI inherent ----1 */
2154 OP_HANDLER(cwai) {
2155         uint8_t t;
2156         IMMBYTE(t);
2157         CC = CC & t;
2158         CC |= CC_E;     /* HJB 990225: save entire state */
2159         PUSHWORD(pPC);
2160         PUSHWORD(pU);
2161         PUSHWORD(pY);
2162         PUSHWORD(pX);
2163         PUSHBYTE(DP);
2164         PUSHBYTE(B);
2165         PUSHBYTE(A);
2166         PUSHBYTE(CC);
2167
2168         int_state = int_state | MC6809_CWAI_IN;
2169         int_state &= ~MC6809_CWAI_OUT;  // 0xfeff
2170         return;
2171 }
2172
2173 /* $3D MUL inherent --*-@ */
2174 OP_HANDLER(mul) {
2175         pair32_t t, r;
2176         t.d = 0;
2177         r.d = 0;
2178         t.b.l = A;
2179         r.b.l = B;
2180         t.d = t.d * r.d;
2181         CLR_ZC;
2182         SET_Z16(t.w.l);
2183         if (t.b.l & 0x80) SEC;
2184         A = t.b.h;
2185         B = t.b.l;
2186 }
2187
2188 /* $3E RST */
2189 OP_HANDLER(rst) {
2190         this->reset();
2191 }
2192
2193
2194 /* $3F SWI (SWI2 SWI3) absolute indirect ----- */
2195 OP_HANDLER(swi) {
2196                 CC |= CC_E;     /* HJB 980225: save entire state */
2197                 PUSHWORD(pPC);
2198                 PUSHWORD(pU);
2199                 PUSHWORD(pY);
2200                 PUSHWORD(pX);
2201                 PUSHBYTE(DP);
2202                 PUSHBYTE(B);
2203                 PUSHBYTE(A);
2204                 PUSHBYTE(CC);
2205                 CC |= CC_IF | CC_II;    /* inhibit FIRQ and IRQ */
2206                 pPC = RM16_PAIR(0xfffa);
2207 }
2208
2209 /* $103F SWI2 absolute indirect ----- */
2210 OP_HANDLER(swi2) {
2211                 CC |= CC_E;     /* HJB 980225: save entire state */
2212                 PUSHWORD(pPC);
2213                 PUSHWORD(pU);
2214                 PUSHWORD(pY);
2215                 PUSHWORD(pX);
2216                 PUSHBYTE(DP);
2217                 PUSHBYTE(B);
2218                 PUSHBYTE(A);
2219                 PUSHBYTE(CC);
2220                 pPC = RM16_PAIR(0xfff4);
2221 }
2222
2223 /* $113F SWI3 absolute indirect ----- */
2224 OP_HANDLER(swi3) {
2225                 CC |= CC_E;     /* HJB 980225: save entire state */
2226                 PUSHWORD(pPC);
2227                 PUSHWORD(pU);
2228                 PUSHWORD(pY);
2229                 PUSHWORD(pX);
2230                 PUSHBYTE(DP);
2231                 PUSHBYTE(B);
2232                 PUSHBYTE(A);
2233                 PUSHBYTE(CC);
2234                 pPC = RM16_PAIR(0xfff2);
2235 }
2236
2237 /* $40 NEGA inherent ?**** */
2238 OP_HANDLER(nega) {
2239         A = NEG_REG(A);
2240 }
2241
2242 /* $41 NEGA */
2243
2244
2245 /* $43 COMA inherent -**01 */
2246 OP_HANDLER(coma) {
2247         A = COM_REG(A);
2248 }
2249
2250 /* $42 NGCA */
2251 OP_HANDLER(ngca) {
2252         if ((CC & CC_C) == 0) {
2253                 nega();
2254         } else {
2255                 coma();
2256         }
2257 }
2258
2259 /* $44 LSRA inherent -0*-* */
2260 OP_HANDLER(lsra) {
2261         A = LSR_REG(A);
2262 }
2263
2264 /* $45 LSRA */
2265
2266 /* $46 RORA inherent -**-* */
2267 OP_HANDLER(rora) {
2268         A = ROR_REG(A);
2269 }
2270
2271 /* $47 ASRA inherent ?**-* */
2272 OP_HANDLER(asra) {
2273         A = ASR_REG(A);
2274 }
2275
2276 /* $48 ASLA inherent ?**** */
2277 OP_HANDLER(asla) {
2278         A = ASL_REG(A);
2279 }
2280
2281 /* $49 ROLA inherent -**** */
2282 OP_HANDLER(rola) {
2283         A = ROL_REG(A);
2284 }
2285
2286 /* $4A DECA inherent -***- */
2287 OP_HANDLER(deca) {
2288         A = DEC_REG(A);
2289 }
2290
2291
2292 /* $4B DCCA */
2293 OP_HANDLER(dcca) {
2294         A = DCC_REG(A);
2295 }
2296
2297 /* $4C INCA inherent -***- */
2298 OP_HANDLER(inca) {
2299         A = INC_REG(A);
2300 }
2301
2302 /* $4D TSTA inherent -**0- */
2303 OP_HANDLER(tsta) {
2304         A = TST_REG(A);
2305 }
2306
2307 /* $4E ILLEGAL */
2308 OP_HANDLER(clca) {
2309         A = CLC_REG(A);
2310 }
2311
2312 /* $4F CLRA inherent -0100 */
2313 OP_HANDLER(clra) {
2314         A = CLR_REG(A);
2315 }
2316
2317 /* $50 NEGB inherent ?**** */
2318 OP_HANDLER(negb) {
2319         B = NEG_REG(B);
2320 }
2321
2322 /* $51 NEGB */
2323
2324 /* $52 NGCB */
2325
2326 /* $53 COMB inherent -**01 */
2327 OP_HANDLER(comb) {
2328         B = COM_REG(B);
2329 }
2330
2331 /* $52 NGCB */
2332 OP_HANDLER(ngcb) {
2333         if ((CC & CC_C) == 0) {
2334                 negb();
2335         } else {
2336                 comb();
2337         }
2338 }
2339
2340 /* $54 LSRB inherent -0*-* */
2341 OP_HANDLER(lsrb) {
2342         B = LSR_REG(B);
2343 }
2344
2345 /* $55 LSRB */
2346
2347 /* $56 RORB inherent -**-* */
2348 OP_HANDLER(rorb) {
2349         B = ROR_REG(B);
2350 }
2351
2352 /* $57 ASRB inherent ?**-* */
2353 OP_HANDLER(asrb) {
2354         B = ASR_REG(B);
2355 }
2356
2357 /* $58 ASLB inherent ?**** */
2358 OP_HANDLER(aslb) {
2359         B = ASL_REG(B);
2360 }
2361
2362 /* $59 ROLB inherent -**** */
2363 OP_HANDLER(rolb) {
2364         B = ROL_REG(B);
2365 }
2366
2367 /* $5A DECB inherent -***- */
2368 OP_HANDLER(decb) {
2369         B = DEC_REG(B);
2370 }
2371
2372 /* $5B DCCB */
2373 OP_HANDLER(dccb) {
2374         B = DCC_REG(B);
2375 }
2376
2377 /* $5C INCB inherent -***- */
2378 OP_HANDLER(incb) {
2379         B = INC_REG(B);
2380 }
2381
2382 /* $5D TSTB inherent -**0- */
2383 OP_HANDLER(tstb) {
2384         B = TST_REG(B);
2385 }
2386
2387 /* $5E ILLEGAL */
2388 OP_HANDLER(clcb) {
2389         B = CLC_REG(B);
2390 }
2391
2392 /* $5F CLRB inherent -0100 */
2393 OP_HANDLER(clrb) {
2394         B = CLR_REG(B);
2395 }
2396
2397 /* $60 NEG indexed ?**** */
2398 OP_HANDLER(neg_ix) {
2399         uint8_t t;
2400         t = GET_INDEXED_DATA();
2401         NEG_MEM(t);
2402 }
2403
2404 /* $61 ILLEGAL */
2405
2406
2407 /* $63 COM indexed -**01 */
2408 OP_HANDLER(com_ix) {
2409         uint8_t t;
2410         t = GET_INDEXED_DATA();
2411         COM_MEM(t);
2412 }
2413
2414 /* $62 ILLEGAL */
2415 OP_HANDLER(ngc_ix) {
2416         if ((CC & CC_C) == 0) {
2417                 neg_ix();
2418         } else {
2419                 com_ix();
2420         }
2421 }
2422
2423 /* $64 LSR indexed -0*-* */
2424 OP_HANDLER(lsr_ix) {
2425         uint8_t t;
2426         t = GET_INDEXED_DATA();
2427         LSR_MEM(t);
2428 }
2429
2430 /* $65 ILLEGAL */
2431
2432 /* $66 ROR indexed -**-* */
2433 OP_HANDLER(ror_ix) {
2434         uint8_t t;
2435         t = GET_INDEXED_DATA();
2436         ROR_MEM(t);
2437 }
2438
2439 /* $67 ASR indexed ?**-* */
2440 OP_HANDLER(asr_ix) {
2441         uint8_t t;
2442         t = GET_INDEXED_DATA();
2443         ASR_MEM(t);
2444 }
2445
2446 /* $68 ASL indexed ?**** */
2447 OP_HANDLER(asl_ix) {
2448         uint8_t t;
2449         t = GET_INDEXED_DATA();
2450         ASL_MEM(t);
2451 }
2452
2453 /* $69 ROL indexed -**** */
2454 OP_HANDLER(rol_ix) {
2455         uint8_t t;
2456         t = GET_INDEXED_DATA();
2457         ROL_MEM(t);
2458 }
2459
2460 /* $6A DEC indexed -***- */
2461 OP_HANDLER(dec_ix) {
2462         uint8_t t;
2463         t = GET_INDEXED_DATA();
2464         DEC_MEM(t);
2465 }
2466
2467 /* $6B DCC index */
2468 OP_HANDLER(dcc_ix) {
2469         uint8_t t;
2470         t = GET_INDEXED_DATA();
2471         DCC_MEM(t);
2472 }
2473
2474 /* $6C INC indexed -***- */
2475 OP_HANDLER(inc_ix) {
2476         uint8_t t;
2477         t = GET_INDEXED_DATA();
2478         INC_MEM(t);
2479 }
2480
2481 /* $6D TST indexed -**0- */
2482 OP_HANDLER(tst_ix) {
2483         uint8_t t;
2484         t = GET_INDEXED_DATA();
2485         TST_MEM(t);
2486 }
2487
2488 /* $6E JMP indexed ----- */
2489 OP_HANDLER(jmp_ix) {
2490         fetch_effective_address();
2491         PCD = EAD;
2492 }
2493
2494 /* $6F CLR indexed -0100 */
2495 OP_HANDLER(clr_ix) {
2496         uint8_t t;
2497         t = GET_INDEXED_DATA();
2498         //dummy = RM(EAD);      // Dummy Read(Alpha etc...)
2499         RM(EAD);        // Dummy Read(Alpha etc...)
2500         CLR_MEM(t);
2501 }
2502
2503 /* $70 NEG extended ?**** */
2504 OP_HANDLER(neg_ex) {
2505         uint8_t t;
2506         EXTBYTE(t);
2507         NEG_MEM(t);
2508 }
2509
2510
2511 /* $73 COM extended -**01 */
2512 OP_HANDLER(com_ex) {
2513         uint8_t t;
2514         EXTBYTE(t);
2515         COM_MEM(t);
2516 }
2517
2518 /* $72 NGC extended */
2519 OP_HANDLER(ngc_ex) {
2520         if ((CC & CC_C) == 0) {
2521                 neg_ex();
2522         } else {
2523                 com_ex();
2524         }
2525 }
2526
2527 /* $74 LSR extended -0*-* */
2528 OP_HANDLER(lsr_ex) {
2529         uint8_t t;
2530         EXTBYTE(t);
2531         LSR_MEM(t);
2532 }
2533
2534 /* $75 ILLEGAL */
2535
2536 /* $76 ROR extended -**-* */
2537 OP_HANDLER(ror_ex) {
2538         uint8_t t;
2539         EXTBYTE(t);
2540         ROR_MEM(t);
2541 }
2542
2543 /* $77 ASR extended ?**-* */
2544 OP_HANDLER(asr_ex) {
2545         uint8_t t;
2546         EXTBYTE(t);
2547         ASR_MEM(t);
2548 }
2549
2550 /* $78 ASL extended ?**** */
2551 OP_HANDLER(asl_ex) {
2552         uint8_t t;
2553         EXTBYTE(t);
2554         ASL_MEM(t);
2555 }
2556
2557 /* $79 ROL extended -**** */
2558 OP_HANDLER(rol_ex) {
2559         uint8_t t;
2560         EXTBYTE(t);
2561         ROL_MEM(t);
2562 }
2563
2564 /* $7A DEC extended -***- */
2565 OP_HANDLER(dec_ex) {
2566         uint8_t t;
2567         EXTBYTE(t);
2568         DEC_MEM(t);
2569 }
2570
2571 /* $7B ILLEGAL */
2572 /* $6B DCC index */
2573 OP_HANDLER(dcc_ex) {
2574         uint8_t t;
2575         EXTBYTE(t);
2576         DCC_MEM(t);
2577 }
2578
2579 /* $7C INC extended -***- */
2580 OP_HANDLER(inc_ex) {
2581         uint8_t t;
2582         EXTBYTE(t);
2583         INC_MEM(t);
2584 }
2585
2586 /* $7D TST extended -**0- */
2587 OP_HANDLER(tst_ex) {
2588         uint8_t t;
2589         EXTBYTE(t);
2590         TST_MEM(t);
2591 }
2592
2593 /* $7E JMP extended ----- */
2594 OP_HANDLER(jmp_ex) {
2595         EXTENDED;
2596         PCD = EAD;
2597 }
2598
2599 /* $7F CLR extended -0100 */
2600 OP_HANDLER(clr_ex) {
2601         uint8_t dummy;
2602         EXTENDED;
2603         dummy = RM(EAD);
2604         CLR_MEM(dummy);
2605 }
2606
2607 /* $80 SUBA immediate ?**** */
2608 OP_HANDLER(suba_im) {
2609         uint8_t t;
2610         IMMBYTE(t);
2611         A = SUB8_REG(A, t);
2612 }
2613
2614 /* $81 CMPA immediate ?**** */
2615 OP_HANDLER(cmpa_im) {
2616         uint8_t t;
2617         IMMBYTE(t);
2618         A = CMP8_REG(A, t);
2619 }
2620
2621 /* $82 SBCA immediate ?**** */
2622 OP_HANDLER(sbca_im) {
2623         uint8_t t;
2624         IMMBYTE(t);
2625         A = SBC8_REG(A, t);
2626 }
2627
2628 /* $83 SUBD (CMPD CMPU) immediate -**** */
2629 OP_HANDLER(subd_im) {
2630         pair32_t b;
2631         IMMWORD(b);
2632         D = SUB16_REG(D, b.w.l);
2633 }
2634
2635 /* $1083 CMPD immediate -**** */
2636 OP_HANDLER(cmpd_im) {
2637         pair32_t b;
2638         IMMWORD(b);
2639         D = CMP16_REG(D, b.w.l);
2640 }
2641
2642 /* $1183 CMPU immediate -**** */
2643 OP_HANDLER(cmpu_im) {
2644         pair32_t b;
2645         IMMWORD(b);
2646         U = CMP16_REG(U, b.w.l);
2647 }
2648
2649 /* $84 ANDA immediate -**0- */
2650 OP_HANDLER(anda_im) {
2651         uint8_t t;
2652         IMMBYTE(t);
2653         A = AND8_REG(A, t);
2654 }
2655
2656 /* $85 BITA immediate -**0- */
2657 OP_HANDLER(bita_im) {
2658         uint8_t t;
2659         IMMBYTE(t);
2660         A = BIT8_REG(A, t);
2661 }
2662
2663 /* $86 LDA immediate -**0- */
2664 OP_HANDLER(lda_im) {
2665         IMMBYTE(A);
2666         A = LOAD8_REG(A);
2667 }
2668
2669 /* is this a legal instruction? */
2670 /* $87 STA immediate -**0- */
2671 OP_HANDLER(sta_im) {
2672                 CLR_NZV;
2673                 SET_NZ8(A);
2674                 IMM8;
2675                 WM(EAD, A);
2676         }
2677
2678 /*
2679  * $87 , $C7: FLAG8
2680  */
2681 OP_HANDLER(flag8_im) {
2682                 // 20111117
2683                 //uint8_t t;
2684                 // IMMBYTE(t);
2685                 ROP_ARG(PCD);
2686                 PC++;
2687                 CLR_NZV;
2688                 CC |= CC_N;
2689         }
2690
2691
2692 /* $88 EORA immediate -**0- */
2693 OP_HANDLER(eora_im) {
2694                 uint8_t t;
2695                 IMMBYTE(t);
2696                 A = EOR8_REG(A, t);
2697 }
2698
2699 /* $89 ADCA immediate ***** */
2700 OP_HANDLER(adca_im) {
2701         uint8_t t;
2702         IMMBYTE(t);
2703         A = ADC8_REG(A, t);
2704 }
2705
2706 /* $8A ORA immediate -**0- */
2707 OP_HANDLER(ora_im) {
2708         uint8_t t;
2709         IMMBYTE(t);
2710         A = OR8_REG(A, t);
2711 }
2712
2713 /* $8B ADDA immediate ***** */
2714 OP_HANDLER(adda_im) {
2715         uint8_t t;
2716         IMMBYTE(t);
2717         A = ADD8_REG(A, t);
2718 }
2719
2720 /* $8C CMPX (CMPY CMPS) immediate -**** */
2721 OP_HANDLER(cmpx_im) {
2722         pair32_t b;
2723         IMMWORD(b);
2724         X = CMP16_REG(X, b.w.l);
2725 }
2726
2727 /* $108C CMPY immediate -**** */
2728 OP_HANDLER(cmpy_im) {
2729         pair32_t b;
2730         IMMWORD(b);
2731         Y = CMP16_REG(Y, b.w.l);
2732 }
2733
2734 /* $118C CMPS immediate -**** */
2735 OP_HANDLER(cmps_im) {
2736         pair32_t b;
2737         IMMWORD(b);
2738         S = CMP16_REG(S, b.w.l);
2739 }
2740
2741 /* $8D BSR ----- */
2742 OP_HANDLER(bsr) {
2743                 uint8_t t;
2744                 IMMBYTE(t);
2745                 PUSHWORD(pPC);
2746                 PC += SIGNED(t);
2747         }
2748
2749 /* $8E LDX (LDY) immediate -**0- */
2750 OP_HANDLER(ldx_im) {
2751         IMMWORD(pX);
2752         X = LOAD16_REG(X);
2753 }
2754
2755 /* $108E LDY immediate -**0- */
2756 OP_HANDLER(ldy_im) {
2757         IMMWORD(pY);
2758         Y = LOAD16_REG(Y);
2759 }
2760
2761 /* is this a legal instruction? */
2762 /* $8F STX (STY) immediate -**0- */
2763 OP_HANDLER(stx_im) {
2764                 CLR_NZV;
2765                 SET_NZ16(X);
2766                 IMM16;
2767                 WM16(EAD, &pX);
2768         }
2769
2770 /*
2771  * $8F , $CF: FLAG16
2772  */
2773 OP_HANDLER(flag16_im) {
2774                 pair32_t t;
2775                 IMMWORD(t);
2776                 CLR_NZV;
2777                 CC |= CC_N;
2778 }
2779
2780
2781 /* is this a legal instruction? */
2782 /* $108F STY immediate -**0- */
2783 OP_HANDLER(sty_im) {
2784                 CLR_NZV;
2785                 SET_NZ16(Y);
2786                 IMM16;
2787                 WM16(EAD, &pY);
2788         }
2789
2790 /* $90 SUBA direct ?**** */
2791 OP_HANDLER(suba_di) {
2792         uint8_t t;
2793         DIRBYTE(t);
2794         A = SUB8_REG(A, t);
2795 }
2796
2797 /* $91 CMPA direct ?**** */
2798 OP_HANDLER(cmpa_di) {
2799         uint8_t t;
2800         DIRBYTE(t);
2801         A = CMP8_REG(A, t);
2802 }
2803
2804 /* $92 SBCA direct ?**** */
2805 OP_HANDLER(sbca_di) {
2806         uint8_t t;
2807         DIRBYTE(t);
2808         A = SBC8_REG(A, t);
2809 }
2810
2811 /* $93 SUBD (CMPD CMPU) direct -**** */
2812 OP_HANDLER(subd_di) {
2813         pair32_t b;
2814         DIRWORD(b);
2815         D = SUB16_REG(D, b.w.l);
2816 }
2817
2818 /* $1093 CMPD direct -**** */
2819 OP_HANDLER(cmpd_di) {
2820         pair32_t b;
2821         DIRWORD(b);
2822         D = CMP16_REG(D, b.w.l);
2823 }
2824
2825 /* $1193 CMPU direct -**** */
2826 OP_HANDLER(cmpu_di) {
2827         pair32_t b;
2828         DIRWORD(b);
2829         U = CMP16_REG(U, b.w.l);
2830 }
2831
2832 /* $94 ANDA direct -**0- */
2833 OP_HANDLER(anda_di) {
2834         uint8_t t;
2835         DIRBYTE(t);
2836         A = AND8_REG(A, t);
2837 }
2838
2839 /* $95 BITA direct -**0- */
2840 OP_HANDLER(bita_di) {
2841         uint8_t t;
2842         DIRBYTE(t);
2843         A = BIT8_REG(A, t);
2844 }
2845
2846 /* $96 LDA direct -**0- */
2847 OP_HANDLER(lda_di) {
2848         DIRBYTE(A);
2849         A = LOAD8_REG(A);
2850 }
2851
2852 /* $97 STA direct -**0- */
2853 OP_HANDLER(sta_di) {
2854         DIRECT;
2855         STORE8_REG(A);
2856 }
2857
2858 /* $98 EORA direct -**0- */
2859 OP_HANDLER(eora_di) {
2860         uint8_t t;
2861         DIRBYTE(t);
2862         A = EOR8_REG(A, t);
2863 }
2864
2865 /* $99 ADCA direct ***** */
2866 OP_HANDLER(adca_di) {
2867         uint8_t t;
2868         DIRBYTE(t);
2869         A = ADC8_REG(A, t);
2870 }
2871
2872 /* $9A ORA direct -**0- */
2873 OP_HANDLER(ora_di) {
2874         uint8_t t;
2875         DIRBYTE(t);
2876         A = OR8_REG(A, t);
2877 }
2878
2879 /* $9B ADDA direct ***** */
2880 OP_HANDLER(adda_di) {
2881         uint8_t t;
2882         DIRBYTE(t);
2883         A = ADD8_REG(A, t);
2884 }
2885
2886 /* $9C CMPX (CMPY CMPS) direct -**** */
2887 OP_HANDLER(cmpx_di) {
2888         pair32_t b;
2889         DIRWORD(b);
2890         X = CMP16_REG(X, b.w.l);
2891 }
2892
2893 /* $109C CMPY direct -**** */
2894 OP_HANDLER(cmpy_di) {
2895         pair32_t b;
2896         DIRWORD(b);
2897         Y = CMP16_REG(Y, b.w.l);
2898 }
2899
2900 /* $119C CMPS direct -**** */
2901 OP_HANDLER(cmps_di) {
2902         pair32_t b;
2903         DIRWORD(b);
2904         S = CMP16_REG(S, b.w.l);
2905 }
2906
2907 /* $9D JSR direct ----- */
2908 OP_HANDLER(jsr_di) {
2909                 DIRECT;
2910                 PUSHWORD(pPC);
2911                 PCD = EAD;
2912         }
2913
2914 /* $9E LDX (LDY) direct -**0- */
2915 OP_HANDLER(ldx_di) {
2916         DIRWORD(pX);
2917         X = LOAD16_REG(X);
2918 }
2919
2920 /* $109E LDY direct -**0- */
2921 OP_HANDLER(ldy_di) {
2922         DIRWORD(pY);
2923         Y = LOAD16_REG(Y);
2924 }
2925
2926 /* $9F STX (STY) direct -**0- */
2927 OP_HANDLER(stx_di) {
2928         DIRECT;
2929         STORE16_REG(&pX);
2930 }
2931
2932 /* $109F STY direct -**0- */
2933 OP_HANDLER(sty_di) {
2934         DIRECT;
2935         STORE16_REG(&pY);
2936 }
2937
2938 /* $a0 SUBA indexed ?**** */
2939 OP_HANDLER(suba_ix) {
2940         uint8_t t;
2941         t = GET_INDEXED_DATA();
2942         A = SUB8_REG(A, t);
2943 }
2944
2945 /* $a1 CMPA indexed ?**** */
2946 OP_HANDLER(cmpa_ix) {
2947         uint8_t t;
2948         t = GET_INDEXED_DATA();
2949         A = CMP8_REG(A, t);
2950 }
2951
2952 /* $a2 SBCA indexed ?**** */
2953 OP_HANDLER(sbca_ix) {
2954         uint8_t t;
2955         t = GET_INDEXED_DATA();
2956         A = SBC8_REG(A, t);
2957 }
2958
2959 /* $a3 SUBD (CMPD CMPU) indexed -**** */
2960 OP_HANDLER(subd_ix) {
2961         pair32_t b;
2962         b = GET_INDEXED_DATA16();
2963         D = SUB16_REG(D, b.w.l);
2964 }
2965
2966 /* $10a3 CMPD indexed -**** */
2967 OP_HANDLER(cmpd_ix) {
2968         pair32_t b;
2969         b = GET_INDEXED_DATA16();
2970         D = CMP16_REG(D, b.w.l);
2971 }
2972
2973 /* $11a3 CMPU indexed -**** */
2974 OP_HANDLER(cmpu_ix) {
2975         pair32_t b;
2976         b = GET_INDEXED_DATA16();
2977         U = CMP16_REG(U, b.w.l);
2978 }
2979
2980 /* $a4 ANDA indexed -**0- */
2981 OP_HANDLER(anda_ix) {
2982         uint8_t t;
2983         t = GET_INDEXED_DATA();
2984         A = AND8_REG(A, t);
2985 }
2986
2987 /* $a5 BITA indexed -**0- */
2988 OP_HANDLER(bita_ix) {
2989         uint8_t t;
2990         t = GET_INDEXED_DATA();
2991         A = BIT8_REG(A, t);
2992 }
2993
2994 /* $a6 LDA indexed -**0- */
2995 OP_HANDLER(lda_ix) {
2996         A = GET_INDEXED_DATA();
2997         A = LOAD8_REG(A);
2998 }
2999
3000 /* $a7 STA indexed -**0- */
3001 OP_HANDLER(sta_ix) {
3002         fetch_effective_address();
3003         STORE8_REG(A);
3004 }
3005
3006 /* $a8 EORA indexed -**0- */
3007 OP_HANDLER(eora_ix) {
3008         uint8_t t;
3009         t = GET_INDEXED_DATA();
3010         A = EOR8_REG(A, t);
3011 }
3012
3013 /* $a9 ADCA indexed ***** */
3014 OP_HANDLER(adca_ix) {
3015         uint8_t t;
3016         t = GET_INDEXED_DATA();
3017         A = ADC8_REG(A, t);
3018 }
3019
3020 /* $aA ORA indexed -**0- */
3021 OP_HANDLER(ora_ix) {
3022         uint8_t t;
3023         t = GET_INDEXED_DATA();
3024         A = OR8_REG(A, t);
3025 }
3026
3027 /* $aB ADDA indexed ***** */
3028 OP_HANDLER(adda_ix) {
3029         uint8_t t;
3030         t = GET_INDEXED_DATA();
3031         A = ADD8_REG(A, t);
3032 }
3033
3034 /* $aC CMPX (CMPY CMPS) indexed -**** */
3035 OP_HANDLER(cmpx_ix) {
3036         pair32_t b;
3037         b = GET_INDEXED_DATA16();
3038         X = CMP16_REG(X, b.w.l);
3039 }
3040
3041 /* $10aC CMPY indexed -**** */
3042 OP_HANDLER(cmpy_ix) {
3043         pair32_t b;
3044         b = GET_INDEXED_DATA16();
3045         Y = CMP16_REG(Y, b.w.l);
3046 }
3047
3048 /* $11aC CMPS indexed -**** */
3049 OP_HANDLER(cmps_ix) {
3050         pair32_t b;
3051         b = GET_INDEXED_DATA16();
3052         S = CMP16_REG(S, b.w.l);
3053 }
3054
3055 /* $aD JSR indexed ----- */
3056 OP_HANDLER(jsr_ix) {
3057         fetch_effective_address();
3058         PUSHWORD(pPC);
3059         PCD = EAD;
3060 }
3061
3062 /* $aE LDX (LDY) indexed -**0- */
3063 OP_HANDLER(ldx_ix) {
3064         pair32_t t;
3065         t = GET_INDEXED_DATA16();
3066         X = t.w.l;
3067         X = LOAD16_REG(X);
3068 }
3069
3070 /* $10aE LDY indexed -**0- */
3071 OP_HANDLER(ldy_ix) {
3072         pair32_t t;
3073         t = GET_INDEXED_DATA16();
3074         Y = t.w.l;
3075         Y = LOAD16_REG(Y);
3076 }
3077
3078 /* $aF STX (STY) indexed -**0- */
3079 OP_HANDLER(stx_ix) {
3080         fetch_effective_address();
3081         STORE16_REG(&pX);
3082 }
3083
3084 /* $10aF STY indexed -**0- */
3085 OP_HANDLER(sty_ix) {
3086         fetch_effective_address();
3087         STORE16_REG(&pY);
3088 }
3089
3090 /* $b0 SUBA extended ?**** */
3091 OP_HANDLER(suba_ex) {
3092         uint8_t t;
3093         EXTBYTE(t);
3094         A = SUB8_REG(A, t);
3095 }
3096
3097 /* $b1 CMPA extended ?**** */
3098 OP_HANDLER(cmpa_ex) {
3099         uint8_t t;
3100         EXTBYTE(t);
3101         A = CMP8_REG(A, t);
3102 }
3103
3104 /* $b2 SBCA extended ?**** */
3105 OP_HANDLER(sbca_ex) {
3106         uint8_t t;
3107         EXTBYTE(t);
3108         A = SBC8_REG(A, t);
3109 }
3110
3111 /* $b3 SUBD (CMPD CMPU) extended -**** */
3112 OP_HANDLER(subd_ex) {
3113         pair32_t b;
3114         EXTWORD(b);
3115         D = SUB16_REG(D, b.w.l);
3116 }
3117
3118 /* $10b3 CMPD extended -**** */
3119 OP_HANDLER(cmpd_ex) {
3120         pair32_t b;
3121         EXTWORD(b);
3122         D = CMP16_REG(D, b.w.l);
3123 }
3124
3125 /* $11b3 CMPU extended -**** */
3126 OP_HANDLER(cmpu_ex) {
3127         pair32_t b;
3128         EXTWORD(b);
3129         U = CMP16_REG(U, b.w.l);
3130 }
3131
3132 /* $b4 ANDA extended -**0- */
3133 OP_HANDLER(anda_ex) {
3134         uint8_t t;
3135         EXTBYTE(t);
3136         A = AND8_REG(A, t);
3137 }
3138
3139 /* $b5 BITA extended -**0- */
3140 OP_HANDLER(bita_ex) {
3141         uint8_t t;
3142         EXTBYTE(t);
3143         A = BIT8_REG(A, t);
3144 }
3145
3146 /* $b6 LDA extended -**0- */
3147 OP_HANDLER(lda_ex) {
3148         EXTBYTE(A);
3149         A = LOAD8_REG(A);
3150 }
3151
3152 /* $b7 STA extended -**0- */
3153 OP_HANDLER(sta_ex) {
3154         EXTENDED;
3155         STORE8_REG(A);
3156 }
3157
3158 /* $b8 EORA extended -**0- */
3159 OP_HANDLER(eora_ex) {
3160         uint8_t t;
3161         EXTBYTE(t);
3162         A = EOR8_REG(A, t);
3163 }
3164
3165 /* $b9 ADCA extended ***** */
3166 OP_HANDLER(adca_ex) {
3167         uint8_t t;
3168         EXTBYTE(t);
3169         A = ADC8_REG(A, t);
3170 }
3171
3172 /* $bA ORA extended -**0- */
3173 OP_HANDLER(ora_ex) {
3174         uint8_t t;
3175         EXTBYTE(t);
3176         A = OR8_REG(A, t);
3177 }
3178
3179 /* $bB ADDA extended ***** */
3180 OP_HANDLER(adda_ex) {
3181         uint8_t t;
3182         EXTBYTE(t);
3183         A = ADD8_REG(A, t);
3184 }
3185
3186 /* $bC CMPX (CMPY CMPS) extended -**** */
3187 OP_HANDLER(cmpx_ex) {
3188         pair32_t b;
3189         EXTWORD(b);
3190         X = CMP16_REG(X, b.w.l);
3191 }
3192
3193 /* $10bC CMPY extended -**** */
3194 OP_HANDLER(cmpy_ex) {
3195         pair32_t b;
3196         EXTWORD(b);
3197         Y = CMP16_REG(Y, b.w.l);
3198 }
3199
3200 /* $11bC CMPS extended -**** */
3201 OP_HANDLER(cmps_ex) {
3202         pair32_t b;
3203         EXTWORD(b);
3204         S = CMP16_REG(S, b.w.l);
3205 }
3206
3207 /* $bD JSR extended ----- */
3208 OP_HANDLER(jsr_ex) {
3209                 EXTENDED;
3210                 PUSHWORD(pPC);
3211                 PCD = EAD;
3212 }
3213
3214 /* $bE LDX (LDY) extended -**0- */
3215 OP_HANDLER(ldx_ex) {
3216         EXTWORD(pX);
3217         X = LOAD16_REG(X);
3218 }
3219
3220 /* $10bE LDY extended -**0- */
3221 OP_HANDLER(ldy_ex) {
3222         EXTWORD(pY);
3223         Y = LOAD16_REG(Y);
3224 }
3225
3226 /* $bF STX (STY) extended -**0- */
3227 OP_HANDLER(stx_ex) {
3228         EXTENDED;
3229         STORE16_REG(&pX);
3230 }
3231
3232 /* $10bF STY extended -**0- */
3233 OP_HANDLER(sty_ex) {
3234         EXTENDED;
3235         STORE16_REG(&pY);
3236 }
3237
3238 /* $c0 SUBB immediate ?**** */
3239 OP_HANDLER(subb_im) {
3240         uint8_t t;
3241         IMMBYTE(t);
3242         B = SUB8_REG(B, t);
3243 }
3244
3245 /* $c1 CMPB immediate ?**** */
3246 OP_HANDLER(cmpb_im) {
3247         uint8_t t;
3248         IMMBYTE(t);
3249         B = CMP8_REG(B, t);
3250 }
3251
3252 /* $c2 SBCB immediate ?**** */
3253 OP_HANDLER(sbcb_im) {
3254         uint8_t t;
3255         IMMBYTE(t);
3256         B = SBC8_REG(B, t);
3257 }
3258
3259 /* $c3 ADDD immediate -**** */
3260 OP_HANDLER(addd_im) {
3261         pair32_t b;
3262         IMMWORD(b);
3263         D = ADD16_REG(D, b.w.l);
3264 }
3265
3266 /* $c4 ANDB immediate -**0- */
3267 OP_HANDLER(andb_im) {
3268         uint8_t t;
3269         IMMBYTE(t);
3270         B = AND8_REG(B, t);
3271 }
3272
3273 /* $c5 BITB immediate -**0- */
3274 OP_HANDLER(bitb_im) {
3275         uint8_t t;
3276         IMMBYTE(t);
3277         B = BIT8_REG(B, t);
3278 }
3279
3280 /* $c6 LDB immediate -**0- */
3281 OP_HANDLER(ldb_im) {
3282         IMMBYTE(B);
3283         B = LOAD8_REG(B);
3284 }
3285
3286 /* is this a legal instruction? */
3287 /* $c7 STB immediate -**0- */
3288 OP_HANDLER(stb_im) {
3289         CLR_NZV;
3290         SET_NZ8(B);
3291         IMM8;
3292         WM(EAD, B);
3293 }
3294
3295 /* $c8 EORB immediate -**0- */
3296 OP_HANDLER(eorb_im) {
3297         uint8_t t;
3298         IMMBYTE(t);
3299         B = EOR8_REG(B, t);
3300 }
3301
3302 /* $c9 ADCB immediate ***** */
3303 OP_HANDLER(adcb_im) {
3304         uint8_t t;
3305         IMMBYTE(t);
3306         B = ADC8_REG(B, t);
3307 }
3308
3309 /* $cA ORB immediate -**0- */
3310 OP_HANDLER(orb_im) {
3311         uint8_t t;
3312         IMMBYTE(t);
3313         B = OR8_REG(B, t);
3314 }
3315
3316 /* $cB ADDB immediate ***** */
3317 OP_HANDLER(addb_im) {
3318         uint8_t t;
3319         IMMBYTE(t);
3320         B = ADD8_REG(B, t);
3321 }
3322
3323 /* $cC LDD immediate -**0- */
3324 OP_HANDLER(ldd_im) {
3325         IMMWORD(pD);
3326         D = LOAD16_REG(D);
3327 }
3328
3329 /* is this a legal instruction? */
3330 /* $cD STD immediate -**0- */
3331 OP_HANDLER(std_im) {
3332                 CLR_NZV;
3333                 SET_NZ16(D);
3334                 IMM16;
3335                 WM(EAD, D);
3336 }
3337
3338 /* $cE LDU (LDS) immediate -**0- */
3339 OP_HANDLER(ldu_im) {
3340         IMMWORD(pU);
3341         U = LOAD16_REG(U);
3342 }
3343
3344 /* $10cE LDS immediate -**0- */
3345 OP_HANDLER(lds_im) {
3346         IMMWORD(pS);
3347         S = LOAD16_REG(S);
3348         int_state |= MC6809_LDS;
3349 }
3350
3351 /* is this a legal instruction? */
3352 /* $cF STU (STS) immediate -**0- */
3353 OP_HANDLER(stu_im) {
3354                 CLR_NZV;
3355                 SET_NZ16(U);
3356                 IMM16;
3357                 WM16(EAD, &pU);
3358         }
3359
3360 /* is this a legal instruction? */
3361 /* $10cF STS immediate -**0- */
3362 OP_HANDLER(sts_im) {
3363                 CLR_NZV;
3364                 SET_NZ16(S);
3365                 IMM16;
3366                 WM16(EAD, &pS);
3367         }
3368
3369 /* $d0 SUBB direct ?**** */
3370 OP_HANDLER(subb_di) {
3371         uint8_t t;
3372         DIRBYTE(t);
3373         B = SUB8_REG(B, t);
3374 }
3375 /* $d1 CMPB direct ?**** */
3376 OP_HANDLER(cmpb_di) {
3377         uint8_t t;
3378         DIRBYTE(t);
3379         B = CMP8_REG(B, t);
3380 }
3381
3382 /* $d2 SBCB direct ?**** */
3383 OP_HANDLER(sbcb_di) {
3384         uint8_t t;
3385         DIRBYTE(t);
3386         B = SBC8_REG(B, t);
3387 }
3388
3389 /* $d3 ADDD direct -**** */
3390 OP_HANDLER(addd_di) {
3391         pair32_t b;
3392         DIRWORD(b);
3393         D = ADD16_REG(D, b.w.l);
3394 }
3395
3396 /* $d4 ANDB direct -**0- */
3397 OP_HANDLER(andb_di) {
3398         uint8_t t;
3399         DIRBYTE(t);
3400         B = AND8_REG(B, t);
3401 }
3402
3403 /* $d5 BITB direct -**0- */
3404 OP_HANDLER(bitb_di) {
3405         uint8_t t;
3406         DIRBYTE(t);
3407         B = BIT8_REG(B, t);
3408 }
3409
3410 /* $d6 LDB direct -**0- */
3411 OP_HANDLER(ldb_di) {
3412         DIRBYTE(B);
3413         B = LOAD8_REG(B);
3414 }
3415
3416 /* $d7 STB direct -**0- */
3417 OP_HANDLER(stb_di) {
3418         DIRECT;
3419         STORE8_REG(B);
3420 }
3421
3422 /* $d8 EORB direct -**0- */
3423 OP_HANDLER(eorb_di) {
3424         uint8_t t;
3425         DIRBYTE(t);
3426         B = EOR8_REG(B, t);
3427 }
3428
3429 /* $d9 ADCB direct ***** */
3430 OP_HANDLER(adcb_di) {
3431         uint8_t t;
3432         DIRBYTE(t);
3433         B = ADC8_REG(B, t);
3434 }
3435
3436 /* $dA ORB direct -**0- */
3437 OP_HANDLER(orb_di) {
3438         uint8_t t;
3439         DIRBYTE(t);
3440         B = OR8_REG(B, t);
3441 }
3442
3443 /* $dB ADDB direct ***** */
3444 OP_HANDLER(addb_di) {
3445         uint8_t t;
3446         DIRBYTE(t);
3447         B = ADD8_REG(B, t);
3448 }
3449
3450 /* $dC LDD direct -**0- */
3451 OP_HANDLER(ldd_di) {
3452         DIRWORD(pD);
3453         D = LOAD16_REG(D);
3454 }
3455
3456 /* $dD STD direct -**0- */
3457 OP_HANDLER(std_di) {
3458         DIRECT;
3459         STORE16_REG(&pD);
3460 }
3461
3462 /* $dE LDU (LDS) direct -**0- */
3463 OP_HANDLER(ldu_di) {
3464         DIRWORD(pU);
3465         U = LOAD16_REG(U);
3466 }
3467
3468 /* $10dE LDS direct -**0- */
3469 OP_HANDLER(lds_di) {
3470         DIRWORD(pS);
3471         S = LOAD16_REG(S);
3472         int_state |= MC6809_LDS;
3473 }
3474
3475 /* $dF STU (STS) direct -**0- */
3476 OP_HANDLER(stu_di) {
3477         DIRECT;
3478         STORE16_REG(&pU);
3479 }
3480
3481 /* $10dF STS direct -**0- */
3482 OP_HANDLER(sts_di) {
3483         DIRECT;
3484         STORE16_REG(&pS);
3485 }
3486
3487 /* $e0 SUBB indexed ?**** */
3488 OP_HANDLER(subb_ix) {
3489         uint8_t t;
3490         t = GET_INDEXED_DATA();
3491         B = SUB8_REG(B, t);
3492 }
3493
3494 /* $e1 CMPB indexed ?**** */
3495 OP_HANDLER(cmpb_ix) {
3496         uint8_t t;
3497         t = GET_INDEXED_DATA();
3498         B = CMP8_REG(B, t);
3499 }
3500
3501 /* $e2 SBCB indexed ?**** */
3502 OP_HANDLER(sbcb_ix) {
3503         uint8_t t;
3504         t = GET_INDEXED_DATA();
3505         B = SBC8_REG(B, t);
3506 }
3507
3508 /* $e3 ADDD indexed -**** */
3509 OP_HANDLER(addd_ix) {
3510         pair32_t b;
3511         b = GET_INDEXED_DATA16();
3512         D = ADD16_REG(D, b.w.l);
3513 }
3514
3515 /* $e4 ANDB indexed -**0- */
3516 OP_HANDLER(andb_ix) {
3517         uint8_t t;
3518         t = GET_INDEXED_DATA();
3519         B = AND8_REG(B, t);
3520 }
3521
3522 /* $e5 BITB indexed -**0- */
3523 OP_HANDLER(bitb_ix) {
3524         uint8_t t;
3525         t = GET_INDEXED_DATA();
3526         B = BIT8_REG(B, t);
3527 }
3528
3529 /* $e6 LDB indexed -**0- */
3530 OP_HANDLER(ldb_ix) {
3531         B = GET_INDEXED_DATA();
3532         B = LOAD8_REG(B);
3533 }
3534
3535 /* $e7 STB indexed -**0- */
3536 OP_HANDLER(stb_ix) {
3537         fetch_effective_address();
3538         STORE8_REG(B);
3539 }
3540
3541 /* $e8 EORB indexed -**0- */
3542 OP_HANDLER(eorb_ix) {
3543         uint8_t t;
3544         t = GET_INDEXED_DATA();
3545         B = EOR8_REG(B, t);
3546 }
3547
3548 /* $e9 ADCB indexed ***** */
3549 OP_HANDLER(adcb_ix) {
3550         uint8_t t;
3551         t = GET_INDEXED_DATA();
3552         B = ADC8_REG(B, t);
3553 }
3554
3555 /* $eA ORB indexed -**0- */
3556 OP_HANDLER(orb_ix) {
3557         uint8_t t;
3558         t = GET_INDEXED_DATA();
3559         B = OR8_REG(B, t);
3560 }
3561
3562 /* $eB ADDB indexed ***** */
3563 OP_HANDLER(addb_ix) {
3564         uint8_t t;
3565         t = GET_INDEXED_DATA();
3566         B = ADD8_REG(B, t);
3567 }
3568
3569 /* $eC LDD indexed -**0- */
3570 OP_HANDLER(ldd_ix) {
3571         pair32_t t;
3572         t = GET_INDEXED_DATA16();
3573         D = t.w.l;
3574         D = LOAD16_REG(D);
3575 }
3576
3577 /* $eD STD indexed -**0- */
3578 OP_HANDLER(std_ix) {
3579         fetch_effective_address();
3580         STORE16_REG(&pD);
3581 }
3582
3583 /* $eE LDU (LDS) indexed -**0- */
3584 OP_HANDLER(ldu_ix) {
3585         pair32_t t;
3586         t = GET_INDEXED_DATA16();
3587         U = t.w.l;
3588         U = LOAD16_REG(U);
3589 }
3590
3591 /* $10eE LDS indexed -**0- */
3592 OP_HANDLER(lds_ix) {
3593         pair32_t t;
3594         t = GET_INDEXED_DATA16();
3595         S = t.w.l;
3596         S = LOAD16_REG(S);
3597         int_state |= MC6809_LDS;
3598 }
3599
3600 /* $eF STU (STS) indexed -**0- */
3601 OP_HANDLER(stu_ix) {
3602         fetch_effective_address();
3603         STORE16_REG(&pU);
3604 }
3605
3606 /* $10eF STS indexed -**0- */
3607 OP_HANDLER(sts_ix) {
3608         fetch_effective_address();
3609         STORE16_REG(&pS);
3610 }
3611
3612 /* $f0 SUBB extended ?**** */
3613 OP_HANDLER(subb_ex) {
3614         uint8_t t;
3615         EXTBYTE(t);
3616         B = SUB8_REG(B, t);
3617 }
3618
3619 /* $f1 CMPB extended ?**** */
3620 OP_HANDLER(cmpb_ex) {
3621         uint8_t t;
3622         EXTBYTE(t);
3623         B = CMP8_REG(B, t);
3624 }
3625
3626 /* $f2 SBCB extended ?**** */
3627 OP_HANDLER(sbcb_ex) {
3628         uint8_t t;
3629         EXTBYTE(t);
3630         B = SBC8_REG(B, t);
3631 }
3632
3633 /* $f3 ADDD extended -**** */
3634 OP_HANDLER(addd_ex) {
3635         pair32_t b;
3636         EXTWORD(b);
3637         D = ADD16_REG(D, b.w.l);
3638 }
3639
3640 /* $f4 ANDB extended -**0- */
3641 OP_HANDLER(andb_ex) {
3642         uint8_t t;
3643         EXTBYTE(t);
3644         B = AND8_REG(B, t);
3645 }
3646
3647 /* $f5 BITB extended -**0- */
3648 OP_HANDLER(bitb_ex) {
3649         uint8_t t;
3650         EXTBYTE(t);
3651         B = BIT8_REG(B, t);
3652 }
3653
3654 /* $f6 LDB extended -**0- */
3655 OP_HANDLER(ldb_ex) {
3656         EXTBYTE(B);
3657         B = LOAD8_REG(B);
3658 }
3659
3660 /* $f7 STB extended -**0- */
3661 OP_HANDLER(stb_ex) {
3662         EXTENDED;
3663         STORE8_REG(B);
3664 }
3665
3666 /* $f8 EORB extended -**0- */
3667 OP_HANDLER(eorb_ex) {
3668         uint8_t t;
3669         EXTBYTE(t);
3670         B = EOR8_REG(B, t);
3671 }
3672
3673 /* $f9 ADCB extended ***** */
3674 OP_HANDLER(adcb_ex) {
3675         uint8_t t;
3676         EXTBYTE(t);
3677         B = ADC8_REG(B, t);
3678 }
3679
3680 /* $fA ORB extended -**0- */
3681 OP_HANDLER(orb_ex) {
3682         uint8_t t;
3683         EXTBYTE(t);
3684         B = OR8_REG(B, t);
3685 }
3686
3687 /* $fB ADDB extended ***** */
3688 OP_HANDLER(addb_ex) {
3689         uint8_t t;
3690         EXTBYTE(t);
3691         B = ADD8_REG(B, t);
3692 }
3693
3694 /* $fC LDD extended -**0- */
3695 OP_HANDLER(ldd_ex) {
3696         EXTWORD(pD);
3697         D = LOAD16_REG(D);
3698 }
3699
3700 /* $fD STD extended -**0- */
3701 OP_HANDLER(std_ex) {
3702         EXTENDED;
3703         STORE16_REG(&pD);
3704 }
3705
3706 /* $fE LDU (LDS) extended -**0- */
3707 OP_HANDLER(ldu_ex) {
3708         EXTWORD(pU);
3709         U = LOAD16_REG(U);
3710 }
3711
3712 /* $10fE LDS extended -**0- */
3713 OP_HANDLER(lds_ex) {
3714         EXTWORD(pS);
3715         S = LOAD16_REG(S);
3716         int_state |= MC6809_LDS;
3717 }
3718
3719 /* $fF STU (STS) extended -**0- */
3720 OP_HANDLER(stu_ex) {
3721         EXTENDED;
3722         STORE16_REG(&pU);
3723 }
3724
3725 /* $10fF STS extended -**0- */
3726 OP_HANDLER(sts_ex) {
3727         EXTENDED;
3728         STORE16_REG(&pS);
3729 }
3730
3731
3732 /* $10xx opcodes */
3733 OP_HANDLER(pref10) {
3734         uint8_t ireg2 = ROP_ARG(PCD);
3735         PC++;
3736         switch (ireg2) {
3737                 case 0x20:
3738                         lbra();
3739                         icount -= 5;
3740                         break;  // 20111217
3741                 case 0x21:
3742                         lbrn();
3743                         icount -= 5;
3744                         break;
3745                 case 0x22:
3746                         lbhi();
3747                         icount -= 5;
3748                         break;
3749                 case 0x23:
3750                         lbls();
3751                         icount -= 5;
3752                         break;
3753                 case 0x24:
3754                         lbcc();
3755                         icount -= 5;
3756                         break;
3757                 case 0x25:
3758                         lbcs();
3759                         icount -= 5;
3760                         break;
3761                 case 0x26:
3762                         lbne();
3763                         icount -= 5;
3764                         break;
3765                 case 0x27:
3766                         lbeq();
3767                         icount -= 5;
3768                         break;
3769                 case 0x28:
3770                         lbvc();
3771                         icount -= 5;
3772                         break;
3773                 case 0x29:
3774                         lbvs();
3775                         icount -= 5;
3776                         break;
3777                 case 0x2a:
3778                         lbpl();
3779                         icount -= 5;
3780                         break;
3781                 case 0x2b:
3782                         lbmi();
3783                         icount -= 5;
3784                         break;
3785                 case 0x2c:
3786                         lbge();
3787                         icount -= 5;
3788                         break;
3789                 case 0x2d:
3790                         lblt();
3791                         icount -= 5;
3792                         break;
3793                 case 0x2e:
3794                         lbgt();
3795                         icount -= 5;
3796                         break;
3797                 case 0x2f:
3798                         lble();
3799                         icount -= 5;
3800                         break;
3801                 case 0x3f:
3802                         swi2();
3803                         icount -= 20;
3804                         break;
3805                 case 0x83:
3806                         cmpd_im();
3807                         icount -= 5;
3808                         break;
3809                 case 0x8c:
3810                         cmpy_im();
3811                         icount -= 5;
3812                         break;
3813                 case 0x8d:
3814                         lbsr();
3815                         icount -= 9;
3816                         break;
3817                 case 0x8e:
3818                         ldy_im();
3819                         icount -= 4;
3820                         break;
3821 //    case 0x8f: flag16_im();->cycle=4; break; // 20130417
3822                 case 0x93:
3823                         cmpd_di();
3824                         icount -= 7;
3825                         break;
3826                 case 0x9c:
3827                         cmpy_di();
3828                         icount -= 7;
3829                         break;
3830                 case 0x9e:
3831                         ldy_di();
3832                         icount -= 6;
3833                         break;
3834                 case 0x9f:
3835                         sty_di();
3836                         icount -= 6;
3837                         break;
3838                 case 0xa3:
3839                         cmpd_ix();
3840                         icount -= 7;
3841                         break;
3842                 case 0xac:
3843                         cmpy_ix();
3844                         icount -= 7;
3845                         break;
3846                 case 0xae:
3847                         ldy_ix();
3848                         icount -= 6;
3849                         break;
3850                 case 0xaf:
3851                         sty_ix();
3852                         icount -= 6;
3853                         break;
3854                 case 0xb3:
3855                         cmpd_ex();
3856                         icount -= 8;
3857                         break;
3858                 case 0xbc:
3859                         cmpy_ex();
3860                         icount -= 8;
3861                         break;
3862                 case 0xbe:
3863                         ldy_ex();
3864                         icount -= 7;
3865                         break;
3866                 case 0xbf:
3867                         sty_ex();
3868                         icount -= 7;
3869                         break;
3870                 case 0xce:
3871                         lds_im();
3872                         icount -= 4;
3873                         break;
3874 //    case 0xcf: flag16_im();->cycle=4; break;
3875                 case 0xde:
3876                         lds_di();
3877                         icount -= 6;
3878                         break;
3879                 case 0xdf:
3880                         sts_di();
3881                         icount -= 6;
3882                         break;
3883                 case 0xee:
3884                         lds_ix();
3885                         icount -= 6;
3886                         break;
3887                 case 0xef:
3888                         sts_ix();
3889                         icount -= 6;
3890                         break;
3891                 case 0xfe:
3892                         lds_ex();
3893                         icount -= 7;
3894                         break;
3895                 case 0xff:
3896                         sts_ex();
3897                         icount -= 7;
3898                         break;
3899                 default:
3900                         PC--;
3901                         IIError();
3902                         break;
3903         }
3904 }
3905
3906 /* $11xx opcodes */
3907 OP_HANDLER(pref11) {
3908                 uint8_t ireg2 = ROP_ARG(PCD);
3909                 PC++;
3910                 switch (ireg2) {
3911                         case 0x3f:
3912                                 swi3();
3913                                 icount -= 20;
3914                                 break;
3915
3916                         case 0x83:
3917                                 cmpu_im();
3918                                 icount -= 5;
3919                                 break;
3920                         case 0x8c:
3921                                 cmps_im();
3922                                 icount -= 5;
3923                                 break;
3924
3925                         case 0x93:
3926                                 cmpu_di();
3927                                 icount -= 7;
3928                                 break;
3929                         case 0x9c:
3930                                 cmps_di();
3931                                 icount -= 7;
3932                                 break;
3933
3934                         case 0xa3:
3935                                 cmpu_ix();
3936                                 icount -= 7;
3937                                 break;
3938                         case 0xac:
3939                                 cmps_ix();
3940                                 icount -= 7;
3941                                 break;
3942
3943                         case 0xb3:
3944                                 cmpu_ex();
3945                                 icount -= 8;
3946                                 break;
3947                         case 0xbc:
3948                                 cmps_ex();
3949                                 icount -= 8;
3950                                 break;
3951
3952                         default:
3953                                 PC--;
3954                                 IIError();
3955                                 break;
3956                 }
3957         }
3958
3959
3960 // from MAME 0.160
3961 //#ifdef USE_DEBUGGER
3962
3963 /*****************************************************************************
3964
3965     6809dasm.c - a 6809 opcode disassembler
3966     Version 1.4 1-MAR-95
3967     Copyright Sean Riddle
3968
3969     Thanks to Franklin Bowen for bug fixes, ideas
3970
3971     Freely distributable on any medium given all copyrights are retained
3972     by the author and no charge greater than $7.00 is made for obtaining
3973     this software
3974
3975     Please send all bug reports, update ideas and data files to:
3976     sriddle@ionet.net
3977
3978 *****************************************************************************/
3979 // Opcode structure
3980 struct opcodeinfo
3981 {
3982         uint8_t   opcode;     // 8-bit opcode value
3983         uint8_t   length;     // Opcode length in bytes
3984         _TCHAR  name[6];    // Opcode name
3985         uint8_t   mode;       // Addressing mode
3986 //      unsigned flags;     // Disassembly flags
3987 };
3988
3989 enum m6809_addressing_modes
3990 {
3991         INH,                // Inherent
3992         DIR,                // Direct
3993         IND,                // Indexed
3994         REL,                // Relative (8 bit)
3995         LREL,               // Long relative (16 bit)
3996         EXT,                // Extended
3997         IMM,                // Immediate
3998         IMM_RR,             // Register-to-register
3999         PG1,                // Switch to page 1 opcodes
4000         PG2                 // Switch to page 2 opcodes
4001 };
4002
4003 // Page 0 opcodes (single byte)
4004 static const opcodeinfo m6809_pg0opcodes[] =
4005 {
4006         { 0x00, 2, _T("NEG"),   DIR    },
4007         { 0x01, 2, _T("NEG"),   DIR    },
4008         { 0x02, 2, _T("NGC"),   DIR    },
4009         { 0x03, 2, _T("COM"),   DIR    },
4010         { 0x04, 2, _T("LSR"),   DIR    },
4011         { 0x05, 2, _T("LSR"),   DIR    },
4012         { 0x06, 2, _T("ROR"),   DIR    },
4013         { 0x07, 2, _T("ASR"),   DIR    },
4014         { 0x08, 2, _T("ASL"),   DIR    },
4015         { 0x09, 2, _T("ROL"),   DIR    },
4016         { 0x0A, 2, _T("DEC"),   DIR    },
4017         { 0x0B, 2, _T("DCC"),   DIR    },
4018         { 0x0C, 2, _T("INC"),   DIR    },
4019         { 0x0D, 2, _T("TST"),   DIR    },
4020         { 0x0E, 2, _T("JMP"),   DIR    },
4021         { 0x0F, 2, _T("CLR"),   DIR    },
4022
4023         { 0x10, 1, _T("page1"), PG1    },
4024         { 0x11, 1, _T("page2"), PG2    },
4025         { 0x12, 1, _T("NOP"),   INH    },
4026         { 0x13, 1, _T("SYNC"),  INH    },
4027         { 0x14, 1, _T("HALT"),  INH    },
4028         { 0x15, 1, _T("HALT"),  INH    },
4029         { 0x16, 3, _T("LBRA"),  LREL   },
4030         { 0x17, 3, _T("LBSR"),  LREL   },
4031         { 0x18, 1, _T("ASLCC"), INH    },
4032         { 0x19, 1, _T("DAA"),   INH    },
4033         { 0x1A, 2, _T("ORCC"),  IMM    },
4034         { 0x1B, 1, _T("NOP"),   INH    },
4035         { 0x1C, 2, _T("ANDCC"), IMM    },
4036         { 0x1D, 1, _T("SEX"),   INH    },
4037         { 0x1E, 2, _T("EXG"),   IMM_RR },
4038         { 0x1F, 2, _T("TFR"),   IMM_RR },
4039
4040         { 0x20, 2, _T("BRA"),   REL    },
4041         { 0x21, 2, _T("BRN"),   REL    },
4042         { 0x22, 2, _T("BHI"),   REL    },
4043         { 0x23, 2, _T("BLS"),   REL    },
4044         { 0x24, 2, _T("BCC"),   REL    },
4045         { 0x25, 2, _T("BCS"),   REL    },
4046         { 0x26, 2, _T("BNE"),   REL    },
4047         { 0x27, 2, _T("BEQ"),   REL    },
4048         { 0x28, 2, _T("BVC"),   REL    },
4049         { 0x29, 2, _T("BVS"),   REL    },
4050         { 0x2A, 2, _T("BPL"),   REL    },
4051         { 0x2B, 2, _T("BMI"),   REL    },
4052         { 0x2C, 2, _T("BGE"),   REL    },
4053         { 0x2D, 2, _T("BLT"),   REL    },
4054         { 0x2E, 2, _T("BGT"),   REL    },
4055         { 0x2F, 2, _T("BLE"),   REL    },
4056
4057         { 0x30, 2, _T("LEAX"),  IND    },
4058         { 0x31, 2, _T("LEAY"),  IND    },
4059         { 0x32, 2, _T("LEAS"),  IND    },
4060         { 0x33, 2, _T("LEAU"),  IND    },
4061         { 0x34, 2, _T("PSHS"),  INH    },
4062         { 0x35, 2, _T("PULS"),  INH    },
4063         { 0x36, 2, _T("PSHU"),  INH    },
4064         { 0x37, 2, _T("PULU"),  INH    },
4065         { 0x38, 2, _T("ANDCC"), IMM    },
4066         { 0x39, 1, _T("RTS"),   INH    },
4067         { 0x3A, 1, _T("ABX"),   INH    },
4068         { 0x3B, 1, _T("RTI"),   INH    },
4069         { 0x3C, 2, _T("CWAI"),  IMM    },
4070         { 0x3D, 1, _T("MUL"),   INH    },
4071         { 0x3F, 1, _T("SWI"),   INH    },
4072
4073         { 0x40, 1, _T("NEGA"),  INH    },
4074         { 0x41, 1, _T("NEGA"),  INH    },
4075         { 0x42, 1, _T("NGGA"),  INH    },
4076         { 0x43, 1, _T("COMA"),  INH    },
4077         { 0x44, 1, _T("LSRA"),  INH    },
4078         { 0x45, 1, _T("LSRA"),  INH    },
4079         { 0x46, 1, _T("RORA"),  INH    },
4080         { 0x47, 1, _T("ASRA"),  INH    },
4081         { 0x48, 1, _T("ASLA"),  INH    },
4082         { 0x49, 1, _T("ROLA"),  INH    },
4083         { 0x4A, 1, _T("DECA"),  INH    },
4084         { 0x4B, 1, _T("DCCA"),  INH    },
4085         { 0x4C, 1, _T("INCA"),  INH    },
4086         { 0x4D, 1, _T("TSTA"),  INH    },
4087         { 0x4E, 1, _T("CLCA"),  INH    },
4088         { 0x4F, 1, _T("CLRA"),  INH    },
4089
4090         { 0x50, 1, _T("NEGB"),  INH    },
4091         { 0x51, 1, _T("NEGB"),  INH    },
4092         { 0x52, 1, _T("NGGB"),  INH    },
4093         { 0x53, 1, _T("COMB"),  INH    },
4094         { 0x54, 1, _T("LSRB"),  INH    },
4095         { 0x55, 1, _T("LSRB"),  INH    },
4096         { 0x56, 1, _T("RORB"),  INH    },
4097         { 0x57, 1, _T("ASRB"),  INH    },
4098         { 0x58, 1, _T("ASLB"),  INH    },
4099         { 0x59, 1, _T("ROLB"),  INH    },
4100         { 0x5A, 1, _T("DECB"),  INH    },
4101         { 0x5B, 1, _T("DCCB"),  INH    },
4102         { 0x5C, 1, _T("INCB"),  INH    },
4103         { 0x5D, 1, _T("TSTB"),  INH    },
4104         { 0x5E, 1, _T("CLCB"),  INH    },
4105         { 0x5F, 1, _T("CLRB"),  INH    },
4106
4107         { 0x60, 2, _T("NEG"),   IND    },
4108         { 0x61, 2, _T("NEG"),   IND    },
4109         { 0x62, 2, _T("NGC"),   IND    },
4110         { 0x63, 2, _T("COM"),   IND    },
4111         { 0x64, 2, _T("LSR"),   IND    },
4112         { 0x65, 2, _T("LSR"),   IND    },
4113         { 0x66, 2, _T("ROR"),   IND    },
4114         { 0x67, 2, _T("ASR"),   IND    },
4115         { 0x68, 2, _T("ASL"),   IND    },
4116         { 0x69, 2, _T("ROL"),   IND    },
4117         { 0x6A, 2, _T("DEC"),   IND    },
4118         { 0x6B, 2, _T("DCC"),   IND    },
4119         { 0x6C, 2, _T("INC"),   IND    },
4120         { 0x6D, 2, _T("TST"),   IND    },
4121         { 0x6E, 2, _T("JMP"),   IND    },
4122         { 0x6F, 2, _T("CLR"),   IND    },
4123
4124         { 0x70, 3, _T("NEG"),   EXT    },
4125         { 0x71, 3, _T("NEG"),   EXT    },
4126         { 0x72, 3, _T("NGC"),   EXT    },
4127         { 0x73, 3, _T("COM"),   EXT    },
4128         { 0x74, 3, _T("LSR"),   EXT    },
4129         { 0x75, 3, _T("LSR"),   EXT    },
4130         { 0x76, 3, _T("ROR"),   EXT    },
4131         { 0x77, 3, _T("ASR"),   EXT    },
4132         { 0x78, 3, _T("ASL"),   EXT    },
4133         { 0x79, 3, _T("ROL"),   EXT    },
4134         { 0x7A, 3, _T("DEC"),   EXT    },
4135         { 0x7B, 3, _T("DCC"),   EXT    },
4136         { 0x7C, 3, _T("INC"),   EXT    },
4137         { 0x7D, 3, _T("TST"),   EXT    },
4138         { 0x7E, 3, _T("JMP"),   EXT    },
4139         { 0x7F, 3, _T("CLR"),   EXT    },
4140
4141         { 0x80, 2, _T("SUBA"),  IMM    },
4142         { 0x81, 2, _T("CMPA"),  IMM    },
4143         { 0x82, 2, _T("SBCA"),  IMM    },
4144         { 0x83, 3, _T("SUBD"),  IMM    },
4145         { 0x84, 2, _T("ANDA"),  IMM    },
4146         { 0x85, 2, _T("BITA"),  IMM    },
4147         { 0x86, 2, _T("LDA"),   IMM    },
4148         { 0x87, 2, _T("FLAG"),  IMM    },
4149         { 0x88, 2, _T("EORA"),  IMM    },
4150         { 0x89, 2, _T("ADCA"),  IMM    },
4151         { 0x8A, 2, _T("ORA"),   IMM    },
4152         { 0x8B, 2, _T("ADDA"),  IMM    },
4153         { 0x8C, 3, _T("CMPX"),  IMM    },
4154         { 0x8D, 2, _T("BSR"),   REL    },
4155         { 0x8E, 3, _T("LDX"),   IMM    },
4156         { 0x8F, 3, _T("FLAG"),  IMM    },
4157
4158         { 0x90, 2, _T("SUBA"),  DIR    },
4159         { 0x91, 2, _T("CMPA"),  DIR    },
4160         { 0x92, 2, _T("SBCA"),  DIR    },
4161         { 0x93, 2, _T("SUBD"),  DIR    },
4162         { 0x94, 2, _T("ANDA"),  DIR    },
4163         { 0x95, 2, _T("BITA"),  DIR    },
4164         { 0x96, 2, _T("LDA"),   DIR    },
4165         { 0x97, 2, _T("STA"),   DIR    },
4166         { 0x98, 2, _T("EORA"),  DIR    },
4167         { 0x99, 2, _T("ADCA"),  DIR    },
4168         { 0x9A, 2, _T("ORA"),   DIR    },
4169         { 0x9B, 2, _T("ADDA"),  DIR    },
4170         { 0x9C, 2, _T("CMPX"),  DIR    },
4171         { 0x9D, 2, _T("JSR"),   DIR    },
4172         { 0x9E, 2, _T("LDX"),   DIR    },
4173         { 0x9F, 2, _T("STX"),   DIR    },
4174
4175         { 0xA0, 2, _T("SUBA"),  IND    },
4176         { 0xA1, 2, _T("CMPA"),  IND    },
4177         { 0xA2, 2, _T("SBCA"),  IND    },
4178         { 0xA3, 2, _T("SUBD"),  IND    },
4179         { 0xA4, 2, _T("ANDA"),  IND    },
4180         { 0xA5, 2, _T("BITA"),  IND    },
4181         { 0xA6, 2, _T("LDA"),   IND    },
4182         { 0xA7, 2, _T("STA"),   IND    },
4183         { 0xA8, 2, _T("EORA"),  IND    },
4184         { 0xA9, 2, _T("ADCA"),  IND    },
4185         { 0xAA, 2, _T("ORA"),   IND    },
4186         { 0xAB, 2, _T("ADDA"),  IND    },
4187         { 0xAC, 2, _T("CMPX"),  IND    },
4188         { 0xAD, 2, _T("JSR"),   IND    },
4189         { 0xAE, 2, _T("LDX"),   IND    },
4190         { 0xAF, 2, _T("STX"),   IND    },
4191
4192         { 0xB0, 3, _T("SUBA"),  EXT    },
4193         { 0xB1, 3, _T("CMPA"),  EXT    },
4194         { 0xB2, 3, _T("SBCA"),  EXT    },
4195         { 0xB3, 3, _T("SUBD"),  EXT    },
4196         { 0xB4, 3, _T("ANDA"),  EXT    },
4197         { 0xB5, 3, _T("BITA"),  EXT    },
4198         { 0xB6, 3, _T("LDA"),   EXT    },
4199         { 0xB7, 3, _T("STA"),   EXT    },
4200         { 0xB8, 3, _T("EORA"),  EXT    },
4201         { 0xB9, 3, _T("ADCA"),  EXT    },
4202         { 0xBA, 3, _T("ORA"),   EXT    },
4203         { 0xBB, 3, _T("ADDA"),  EXT    },
4204         { 0xBC, 3, _T("CMPX"),  EXT    },
4205         { 0xBD, 3, _T("JSR"),   EXT    },
4206         { 0xBE, 3, _T("LDX"),   EXT    },
4207         { 0xBF, 3, _T("STX"),   EXT    },
4208
4209         { 0xC0, 2, _T("SUBB"),  IMM    },
4210         { 0xC1, 2, _T("CMPB"),  IMM    },
4211         { 0xC2, 2, _T("SBCB"),  IMM    },
4212         { 0xC3, 3, _T("ADDD"),  IMM    },
4213         { 0xC4, 2, _T("ANDB"),  IMM    },
4214         { 0xC5, 2, _T("BITB"),  IMM    },
4215         { 0xC6, 2, _T("LDB"),   IMM    },
4216         { 0xC7, 2, _T("FLAG"),  IMM    },
4217         { 0xC8, 2, _T("EORB"),  IMM    },
4218         { 0xC9, 2, _T("ADCB"),  IMM    },
4219         { 0xCA, 2, _T("ORB"),   IMM    },
4220         { 0xCB, 2, _T("ADDB"),  IMM    },
4221         { 0xCC, 3, _T("LDD"),   IMM    },
4222         { 0xCD, 1, _T("HALT"),  INH    },
4223         { 0xCE, 3, _T("LDU"),   IMM    },
4224         { 0xCF, 3, _T("FLAG"),  IMM    },
4225
4226         { 0xD0, 2, _T("SUBB"),  DIR    },
4227         { 0xD1, 2, _T("CMPB"),  DIR    },
4228         { 0xD2, 2, _T("SBCB"),  DIR    },
4229         { 0xD3, 2, _T("ADDD"),  DIR    },
4230         { 0xD4, 2, _T("ANDB"),  DIR    },
4231         { 0xD5, 2, _T("BITB"),  DIR    },
4232         { 0xD6, 2, _T("LDB"),   DIR    },
4233         { 0xD7, 2, _T("STB"),   DIR    },
4234         { 0xD8, 2, _T("EORB"),  DIR    },
4235         { 0xD9, 2, _T("ADCB"),  DIR    },
4236         { 0xDA, 2, _T("ORB"),   DIR    },
4237         { 0xDB, 2, _T("ADDB"),  DIR    },
4238         { 0xDC, 2, _T("LDD"),   DIR    },
4239         { 0xDD, 2, _T("STD"),   DIR    },
4240         { 0xDE, 2, _T("LDU"),   DIR    },
4241         { 0xDF, 2, _T("STU"),   DIR    },
4242
4243         { 0xE0, 2, _T("SUBB"),  IND    },
4244         { 0xE1, 2, _T("CMPB"),  IND    },
4245         { 0xE2, 2, _T("SBCB"),  IND    },
4246         { 0xE3, 2, _T("ADDD"),  IND    },
4247         { 0xE4, 2, _T("ANDB"),  IND    },
4248         { 0xE5, 2, _T("BITB"),  IND    },
4249         { 0xE6, 2, _T("LDB"),   IND    },
4250         { 0xE7, 2, _T("STB"),   IND    },
4251         { 0xE8, 2, _T("EORB"),  IND    },
4252         { 0xE9, 2, _T("ADCB"),  IND    },
4253         { 0xEA, 2, _T("ORB"),   IND    },
4254         { 0xEB, 2, _T("ADDB"),  IND    },
4255         { 0xEC, 2, _T("LDD"),   IND    },
4256         { 0xED, 2, _T("STD"),   IND    },
4257         { 0xEE, 2, _T("LDU"),   IND    },
4258         { 0xEF, 2, _T("STU"),   IND    },
4259
4260         { 0xF0, 3, _T("SUBB"),  EXT    },
4261         { 0xF1, 3, _T("CMPB"),  EXT    },
4262         { 0xF2, 3, _T("SBCB"),  EXT    },
4263         { 0xF3, 3, _T("ADDD"),  EXT    },
4264         { 0xF4, 3, _T("ANDB"),  EXT    },
4265         { 0xF5, 3, _T("BITB"),  EXT    },
4266         { 0xF6, 3, _T("LDB"),   EXT    },
4267         { 0xF7, 3, _T("STB"),   EXT    },
4268         { 0xF8, 3, _T("EORB"),  EXT    },
4269         { 0xF9, 3, _T("ADCB"),  EXT    },
4270         { 0xFA, 3, _T("ORB"),   EXT    },
4271         { 0xFB, 3, _T("ADDB"),  EXT    },
4272         { 0xFC, 3, _T("LDD"),   EXT    },
4273         { 0xFD, 3, _T("STD"),   EXT    },
4274         { 0xFE, 3, _T("LDU"),   EXT    },
4275         { 0xFF, 3, _T("STU"),   EXT    }
4276 };
4277
4278 // Page 1 opcodes (0x10 0x..)
4279 static const opcodeinfo m6809_pg1opcodes[] =
4280 {
4281         { 0x20, 4, _T("LBRA"),  LREL   },
4282         { 0x21, 4, _T("LBRN"),  LREL   },
4283         { 0x22, 4, _T("LBHI"),  LREL   },
4284         { 0x23, 4, _T("LBLS"),  LREL   },
4285         { 0x24, 4, _T("LBCC"),  LREL   },
4286         { 0x25, 4, _T("LBCS"),  LREL   },
4287         { 0x26, 4, _T("LBNE"),  LREL   },
4288         { 0x27, 4, _T("LBEQ"),  LREL   },
4289         { 0x28, 4, _T("LBVC"),  LREL   },
4290         { 0x29, 4, _T("LBVS"),  LREL   },
4291         { 0x2A, 4, _T("LBPL"),  LREL   },
4292         { 0x2B, 4, _T("LBMI"),  LREL   },
4293         { 0x2C, 4, _T("LBGE"),  LREL   },
4294         { 0x2D, 4, _T("LBLT"),  LREL   },
4295         { 0x2E, 4, _T("LBGT"),  LREL   },
4296         { 0x2F, 4, _T("LBLE"),  LREL   },
4297         { 0x3F, 2, _T("SWI2"),  INH    },
4298         { 0x83, 4, _T("CMPD"),  IMM    },
4299         { 0x8C, 4, _T("CMPY"),  IMM    },
4300         { 0x8D, 4, _T("LBSR"),  LREL   },
4301         { 0x8E, 4, _T("LDY"),   IMM    },
4302         { 0x93, 3, _T("CMPD"),  DIR    },
4303         { 0x9C, 3, _T("CMPY"),  DIR    },
4304         { 0x9E, 3, _T("LDY"),   DIR    },
4305         { 0x9F, 3, _T("STY"),   DIR    },
4306         { 0xA3, 3, _T("CMPD"),  IND    },
4307         { 0xAC, 3, _T("CMPY"),  IND    },
4308         { 0xAE, 3, _T("LDY"),   IND    },
4309         { 0xAF, 3, _T("STY"),   IND    },
4310         { 0xB3, 4, _T("CMPD"),  EXT    },
4311         { 0xBC, 4, _T("CMPY"),  EXT    },
4312         { 0xBE, 4, _T("LDY"),   EXT    },
4313         { 0xBF, 4, _T("STY"),   EXT    },
4314         { 0xCE, 4, _T("LDS"),   IMM    },
4315         { 0xDE, 3, _T("LDS"),   DIR    },
4316         { 0xDF, 3, _T("STS"),   DIR    },
4317         { 0xEE, 3, _T("LDS"),   IND    },
4318         { 0xEF, 3, _T("STS"),   IND    },
4319         { 0xFE, 4, _T("LDS"),   EXT    },
4320         { 0xFF, 4, _T("STS"),   EXT    }
4321 };
4322
4323 // Page 2 opcodes (0x11 0x..)
4324 static const opcodeinfo m6809_pg2opcodes[] =
4325 {
4326         { 0x3F, 2, _T("SWI3"),  INH    },
4327         { 0x83, 4, _T("CMPU"),  IMM    },
4328         { 0x8C, 4, _T("CMPS"),  IMM    },
4329         { 0x93, 3, _T("CMPU"),  DIR    },
4330         { 0x9C, 3, _T("CMPS"),  DIR    },
4331         { 0xA3, 3, _T("CMPU"),  IND    },
4332         { 0xAC, 3, _T("CMPS"),  IND    },
4333         { 0xB3, 4, _T("CMPU"),  EXT    },
4334         { 0xBC, 4, _T("CMPS"),  EXT    }
4335 };
4336
4337 static const opcodeinfo *const m6809_pgpointers[3] =
4338 {
4339         m6809_pg0opcodes, m6809_pg1opcodes, m6809_pg2opcodes
4340 };
4341
4342 static const int m6809_numops[3] =
4343 {
4344         array_length(m6809_pg0opcodes),
4345         array_length(m6809_pg1opcodes),
4346         array_length(m6809_pg2opcodes)
4347 };
4348
4349 static const _TCHAR *const m6809_regs[5] = { _T("X"), _T("Y"), _T("U"), _T("S"), _T("PC") };
4350
4351 static const _TCHAR *const m6809_regs_te[16] =
4352 {
4353         _T("D"), _T("X"),  _T("Y"),  _T("U"),   _T("S"),  _T("PC"), _T("inv"), _T("inv"),
4354         _T("A"), _T("B"), _T("CC"), _T("DP"), _T("inv"), _T("inv"), _T("inv"), _T("inv")
4355 };
4356 //#endif /* USE_DEBUGGER */
4357
4358 uint32_t MC6809::cpu_disassemble_m6809(_TCHAR *buffer, uint32_t pc, const uint8_t *oprom, const uint8_t *opram)
4359 {
4360         if(__USE_DEBUGGER) {
4361         uint8_t opcode, mode, pb, pbm, reg;
4362         const uint8_t *operandarray;
4363         unsigned int ea;//, flags;
4364         int numoperands, offset;
4365         int i, p = 0, page = 0;
4366         bool opcode_found = false;
4367         bool indirect;
4368         const _TCHAR *name = NULL;
4369
4370         do {
4371                 opcode = oprom[p++];
4372
4373                 for (i = 0; i < m6809_numops[page]; i++)
4374                         if (m6809_pgpointers[page][i].opcode == opcode)
4375                                 break;
4376
4377                 if (i < m6809_numops[page])
4378                         opcode_found = true;
4379                 else
4380                 {
4381                         _stprintf(buffer, _T("Illegal Opcode %02X"), opcode);
4382                         return p;
4383                 }
4384
4385                 if (m6809_pgpointers[page][i].mode >= PG1)
4386                 {
4387                         page = m6809_pgpointers[page][i].mode - PG1 + 1;
4388                         opcode_found = false;
4389                 }
4390         } while (!opcode_found);
4391
4392         if (page == 0)
4393                 numoperands = m6809_pgpointers[page][i].length - 1;
4394         else
4395                 numoperands = m6809_pgpointers[page][i].length - 2;
4396
4397         operandarray = &opram[p];
4398         p += numoperands;
4399         pc += p;
4400         mode = m6809_pgpointers[page][i].mode;
4401 //      flags = m6809_pgpointers[page][i].flags;
4402
4403         buffer += _stprintf(buffer, _T("%-6s"), m6809_pgpointers[page][i].name);
4404
4405         switch (mode)
4406         {
4407         case INH:
4408                 switch (opcode)
4409                 {
4410                 case 0x34:  // PSHS
4411                 case 0x36:  // PSHU
4412                         pb = operandarray[0];
4413                         if (pb & 0x80)
4414                                 buffer += _stprintf(buffer, _T("PC"));
4415                         if (pb & 0x40)
4416                                 buffer += _stprintf(buffer, _T("%s%s"), (pb&0x80)?_T(","):_T(""), (opcode==0x34)?"U":"S");
4417                         if (pb & 0x20)
4418                                 buffer += _stprintf(buffer, _T("%sY"),  (pb&0xc0)?_T(","):_T(""));
4419                         if (pb & 0x10)
4420                                 buffer += _stprintf(buffer, _T("%sX"),  (pb&0xe0)?_T(","):_T(""));
4421                         if (pb & 0x08)
4422                                 buffer += _stprintf(buffer, _T("%sDP"), (pb&0xf0)?_T(","):_T(""));
4423                         if (pb & 0x04)
4424                                 buffer += _stprintf(buffer, _T("%sB"),  (pb&0xf8)?_T(","):_T(""));
4425                         if (pb & 0x02)
4426                                 buffer += _stprintf(buffer, _T("%sA"),  (pb&0xfc)?_T(","):_T(""));
4427                         if (pb & 0x01)
4428                                 buffer += _stprintf(buffer, _T("%sCC"), (pb&0xfe)?_T(","):_T(""));
4429                         break;
4430                 case 0x35:  // PULS
4431                 case 0x37:  // PULU
4432                         pb = operandarray[0];
4433                         if (pb & 0x01)
4434                                 buffer += _stprintf(buffer, _T("CC"));
4435                         if (pb & 0x02)
4436                                 buffer += _stprintf(buffer, _T("%sA"),  (pb&0x01)?_T(","):_T(""));
4437                         if (pb & 0x04)
4438                                 buffer += _stprintf(buffer, _T("%sB"),  (pb&0x03)?_T(","):_T(""));
4439                         if (pb & 0x08)
4440                                 buffer += _stprintf(buffer, _T("%sDP"), (pb&0x07)?_T(","):_T(""));
4441                         if (pb & 0x10)
4442                                 buffer += _stprintf(buffer, _T("%sX"),  (pb&0x0f)?_T(","):_T(""));
4443                         if (pb & 0x20)
4444                                 buffer += _stprintf(buffer, _T("%sY"),  (pb&0x1f)?_T(","):_T(""));
4445                         if (pb & 0x40)
4446                                 buffer += _stprintf(buffer, _T("%s%s"), (pb&0x3f)?_T(","):_T(""), (opcode==0x35)?_T("U"):_T("S"));
4447                         if (pb & 0x80)
4448                                 buffer += _stprintf(buffer, _T("%sPC ; (PUL? PC=RTS)"), (pb&0x7f)?_T(","):_T(""));
4449                         break;
4450                 default:
4451                         // No operands
4452                         break;
4453                 }
4454                 break;
4455
4456         case DIR:
4457                 ea = operandarray[0];
4458                 buffer += _stprintf(buffer, _T("<$%02X"), ea);
4459                 break;
4460
4461         case REL:
4462                 offset = (int8_t)operandarray[0];
4463                 buffer += _stprintf(buffer, _T("%s"), get_value_or_symbol(d_debugger->first_symbol, _T("$%04X"), (pc + offset) & 0xffff));
4464                 break;
4465
4466         case LREL:
4467                 offset = (int16_t)((operandarray[0] << 8) + operandarray[1]);
4468                 buffer += _stprintf(buffer, _T("%s"), get_value_or_symbol(d_debugger->first_symbol, _T("$%04X"), (pc + offset) & 0xffff));
4469                 break;
4470
4471         case EXT:
4472                 ea = (operandarray[0] << 8) + operandarray[1];
4473                 buffer += _stprintf(buffer, _T("%s"), get_value_or_symbol(d_debugger->first_symbol, _T("$%04X"), ea));
4474                 break;
4475
4476         case IND:
4477                 pb = operandarray[0];
4478                 reg = (pb >> 5) & 3;
4479                 pbm = pb & 0x8f;
4480                 indirect = ((pb & 0x90) == 0x90 )? true : false;
4481
4482                 // open brackets if indirect
4483                 if (indirect /*&& pbm != 0x80 && pbm != 0x82*/)
4484                         buffer += _stprintf(buffer, _T("["));
4485
4486                 switch (pbm)
4487                 {
4488                 case 0x80:  // ,R+
4489                         //if (indirect)
4490                         //      _tcscpy(buffer, _T("Illegal Postbyte"));
4491                         //else
4492                         buffer += _stprintf(buffer, _T(",%s+"), m6809_regs[reg]); // Legal even INDIRECT
4493                         break;
4494
4495                 case 0x81:  // ,R++
4496                         buffer += _stprintf(buffer, _T(",%s++"), m6809_regs[reg]);
4497                         break;
4498
4499                 case 0x82:  // ,-R
4500                   //if (indirect)
4501                   //    _tcscpy(buffer, _T("Illegal Postbyte"));
4502                   //    else
4503                                 buffer += _stprintf(buffer, _T(",-%s"), m6809_regs[reg]); // Legal even INDIRECT
4504                         break;
4505
4506                 case 0x83:  // ,--R
4507                         buffer += _stprintf(buffer, _T(",--%s"), m6809_regs[reg]);
4508                         break;
4509
4510                 case 0x84:  // ,R
4511                         buffer += _stprintf(buffer, _T(",%s"), m6809_regs[reg]);
4512                         break;
4513
4514                 case 0x85:  // (+/- B),R
4515                         buffer += _stprintf(buffer, _T("B,%s"), m6809_regs[reg]);
4516                         break;
4517
4518                 case 0x86:  // (+/- A),R
4519                         buffer += _stprintf(buffer, _T("A,%s"), m6809_regs[reg]);
4520                         break;
4521
4522                 case 0x87:  // (+/- A),R // Also 0x*6.
4523                         buffer += _stprintf(buffer, _T("A,%s"), m6809_regs[reg]);
4524                         break;
4525                         //case 0x87:
4526                         //_tcscpy(buffer, _T("Illegal Postbyte"));
4527                         //break;
4528
4529                 case 0x88:  // (+/- 7 bit offset),R
4530                         offset = (int8_t)opram[p++];
4531                         buffer += _stprintf(buffer, _T("%s"), (offset < 0) ? "-" : "");
4532                         buffer += _stprintf(buffer, _T("$%02X,"), (offset < 0) ? -offset : offset);
4533                         buffer += _stprintf(buffer, _T("%s"), m6809_regs[reg]);
4534                         break;
4535
4536                 case 0x89:  // (+/- 15 bit offset),R
4537                         offset = (int16_t)((opram[p+0] << 8) + opram[p+1]);
4538                         p += 2;
4539                         buffer += _stprintf(buffer, _T("%s"), (offset < 0) ? "-" : "");
4540                         buffer += _stprintf(buffer, _T("$%04X,"), (offset < 0) ? -offset : offset);
4541                         buffer += _stprintf(buffer, _T("%s"), m6809_regs[reg]);
4542                         break;
4543
4544                 case 0x8a:
4545                         //_tcscpy(buffer, _T("Illegal Postbyte"));
4546                         {
4547                                 pair16_t __ea;
4548                                 __ea.w = pc & 0xffff;
4549                                 __ea.w++;
4550                                 __ea.b.l = 0xff;
4551                                 buffer += _stprintf(buffer, _T("%s"), get_value_or_symbol(d_debugger->first_symbol, _T("$%04X"), __ea.w));
4552                         }
4553
4554                         break;
4555
4556                 case 0x8b:  // (+/- D),R
4557                         buffer += _stprintf(buffer, _T("D,%s"), m6809_regs[reg]);
4558                         break;
4559
4560                 case 0x8c:  // (+/- 7 bit offset),PC
4561                         offset = (int8_t)opram[p++];
4562                         if((name = get_symbol(d_debugger->first_symbol, (pc + 1 + offset) & 0xffff)) != NULL) {
4563                                 buffer += _stprintf(buffer, _T("%s,PCR"), name);
4564                         } else {
4565                                 //buffer += _stprintf(buffer, _T("%s"), (offset < 0) ? "-" : "");
4566                                 //buffer += _stprintf(buffer, _T("$%02X,PC"), (offset < 0) ? -offset : offset);
4567                                 buffer += _stprintf(buffer, _T("$%04X,PCR"), get_relative_address_8bit(pc + 1, 0xffff, (int8_t)offset));
4568                         }
4569                         break;
4570
4571                 case 0x8d:  // (+/- 15 bit offset),PC
4572                         offset = (int16_t)((opram[p+0] << 8) + opram[p+1]);
4573                         p += 2;
4574                         if((name = get_symbol(d_debugger->first_symbol, (pc + 2 + offset) & 0xffff)) != NULL) {
4575                                 buffer += _stprintf(buffer, _T("%s,PCR"), name);
4576                         } else {
4577                                 //buffer += _stprintf(buffer, _T("%s"), (offset < 0) ? "-" : "");
4578                                 buffer += _stprintf(buffer, _T("$%04X,PCR"), get_relative_address_16bit(pc + 2, 0xffff, (int16_t)offset));
4579                         }
4580                         break;
4581
4582                 case 0x8e: // $FFFF
4583                   //_tcscpy(buffer, _T("Illegal Postbyte"));
4584                         offset = (int16_t)0xffff;
4585                         //p += 2;
4586                         buffer += _stprintf(buffer, _T("$%04X"), offset);
4587                         break;
4588
4589                 case 0x8f:  // address
4590                         ea = (uint16_t)((opram[p+0] << 8) + opram[p+1]);
4591                         p += 2;
4592                         buffer += _stprintf(buffer, _T("%s"), get_value_or_symbol(d_debugger->first_symbol, _T("$%04X"), ea));
4593                         break;
4594
4595                 default:    // (+/- 4 bit offset),R
4596                         offset = pb & 0x1f;
4597                         if (offset > 15)
4598                                 offset = offset - 32;
4599                         buffer += _stprintf(buffer, _T("%s"), (offset < 0) ? "-" : "");
4600                         buffer += _stprintf(buffer, _T("$%X,"), (offset < 0) ? -offset : offset);
4601                         buffer += _stprintf(buffer, _T("%s"), m6809_regs[reg]);
4602                         break;
4603                 }
4604
4605                 // close brackets if indirect
4606                 if (indirect && pbm != 0x80 && pbm != 0x82)
4607                         buffer += _stprintf(buffer, _T("]"));
4608                 break;
4609
4610         case IMM:
4611                 if (numoperands == 2)
4612                 {
4613                         ea = (operandarray[0] << 8) + operandarray[1];
4614                         buffer += _stprintf(buffer, _T("#%s"), get_value_or_symbol(d_debugger->first_symbol, _T("$%04X"), ea));
4615                 }
4616                 else
4617                 if (numoperands == 1)
4618                 {
4619                         ea = operandarray[0];
4620                         buffer += _stprintf(buffer, _T("#$%02X"), ea);
4621                 }
4622                 break;
4623
4624         case IMM_RR:
4625                 pb = operandarray[0];
4626                 buffer += _stprintf(buffer, _T("%s,%s"), m6809_regs_te[(pb >> 4) & 0xf], m6809_regs_te[pb & 0xf]);
4627                 break;
4628         }
4629
4630         return p;
4631         } else {
4632         return 0;
4633         }
4634 }
4635
4636 int MC6809::debug_dasm_with_userdata(uint32_t pc, _TCHAR *buffer, size_t buffer_len, uint32_t userdata)
4637 {
4638         if(__USE_DEBUGGER) {
4639                 _TCHAR buffer_tmp[1024]; // enough ???
4640                 uint8_t ops[4];
4641                 for(int i = 0; i < 4; i++) {
4642                         ops[i] = d_mem_stored->read_data8(pc + i);
4643                 }
4644                 int length = cpu_disassemble_m6809(buffer_tmp, pc, ops, ops);
4645                 my_tcscpy_s(buffer, buffer_len, buffer_tmp);
4646                 return length;
4647         }
4648         return 0;
4649 }
4650
4651
4652
4653 bool MC6809::write_debug_reg(const _TCHAR *reg, uint32_t data)
4654 {
4655 //#ifdef USE_DEBUGGER
4656         if(_tcsicmp(reg, _T("PC")) == 0) {
4657                 PC = data;
4658         } else if(_tcsicmp(reg, _T("DP")) == 0) {
4659                 DP = data;
4660         } else if(_tcsicmp(reg, _T("A")) == 0) {
4661                 A = data;
4662         } else if(_tcsicmp(reg, _T("B")) == 0) {
4663                 B = data;
4664         } else if(_tcsicmp(reg, _T("D")) == 0) {
4665                 D = data;
4666         } else if(_tcsicmp(reg, _T("U")) == 0) {
4667                 U = data;
4668         } else if(_tcsicmp(reg, _T("X")) == 0) {
4669                 X = data;
4670         } else if(_tcsicmp(reg, _T("Y")) == 0) {
4671                 Y = data;
4672         } else if(_tcsicmp(reg, _T("S")) == 0) {
4673                 S = data;
4674         } else if(_tcsicmp(reg, _T("CC")) == 0) {
4675                 CC = data;
4676         } else {
4677                 return false;
4678         }
4679 //#endif
4680         return true;
4681 }
4682
4683 bool MC6809::get_debug_regs_description(_TCHAR *buffer, size_t buffer_len)
4684 {
4685         my_stprintf_s(buffer, buffer_len,
4686                                   _T("PC  : PROGRAM COUNTER (16bit)\n")
4687                                   _T("CC  : CONDITION FLAGS (16bit)\n")
4688                                   _T("DP  : DIRECT POINTER  (8bit)\n")
4689                                   _T("S   : SYSTEM STACK POINTER (16bit)\n")
4690                                   _T("U   : USER   STACK POINTER (16bit)\n")
4691                                   _T("X   : INDEX REGISTER       (16bit)\n")
4692                                   _T("Y   : INDEX REGISTER       (16bit)\n")
4693                                   _T("A   : ACCUMLATOR           (8bit)\n")
4694                                   _T("B   : ACCUMLATOR           (8bit)\n")
4695                                   _T("D   : ACCUMLATOR           (16bit)\n")
4696                                   _T("NOTE: D is chain of A and B.D = (A << 8) | B.\n")
4697                                   _T("NOTE: ENDIANNESS is BIG.\n")
4698                                   _T("ADDRESSING:\n")
4699                                   _T("foo #bar  (16/8bit)        : immediate value of bar\n")
4700                                   _T("foo <bar  (8bit)           : direct addressing of bar; address = (DP << 8) | bar.\n")
4701                                   _T("foo bar   (16bit or index) : extended address.address = bar\n")
4702                                   _T("foo [bar] (16bit or index) : indirect addressing.address = VALUE16(bar)\n")
4703                                   _T("FLAGS:\n")
4704                                   _T("E: ENTIRE   / F: FAST INTERRUPT(FIRQ) / H: HALF CARRY / I: (STANDARD) INTERRUPT(IRQ/SWI)\n")
4705                                   _T("N: NEGATIVE / Z: ZERO                 / V: OVERFLOW   / C: CARRY")
4706                 );
4707         return true;
4708 }
4709
4710 /*
4711 PC = 0000 PPC = 0000
4712 INTR=[ IRQ FIRQ  NMI HALT][CI CO SI SO TRAP] CC =[EFHINZVC]
4713 A = 00 B = 00 DP = 00 X = 0000 Y = 0000 U = 0000 S = 0000 EA = 0000
4714 Clocks = 0 (0)  Since Scanline = 0/0 (0/0)
4715 */
4716 bool MC6809::get_debug_regs_info(_TCHAR *buffer, size_t buffer_len)
4717 {
4718 //#ifdef USE_DEBUGGER
4719         my_stprintf_s(buffer, buffer_len,
4720                  _T("PC = %04x PPC = %04x\n")
4721                  _T("INTR = [%s %s %s %s][%s %s %s %s %s] CC = [%c%c%c%c%c%c%c%c]\n")
4722                  _T("A = %02x B = %02x DP = %02x X = %04x Y = %04x U = %04x S = %04x EA = %04x\n")
4723                  _T("Clocks = %llu (%llu) Since Scanline = %d/%d (%d/%d)"),
4724                  PC,
4725                  PPC,
4726                  ((int_state & MC6809_IRQ_BIT) == 0)   ? _T("----") : _T(" IRQ"),
4727                  ((int_state & MC6809_FIRQ_BIT) == 0)  ? _T("----") : _T("FIRQ"),
4728                  ((int_state & MC6809_NMI_BIT) == 0)   ? _T("----") : _T(" NMI"),
4729                  ((int_state & MC6809_HALT_BIT) == 0)  ? _T("----") : _T("HALT"),
4730                  ((int_state & MC6809_CWAI_IN) == 0)   ? _T("--") : _T("CI"),
4731                  ((int_state & MC6809_CWAI_OUT) == 0)  ? _T("--") : _T("CO"),
4732                  ((int_state & MC6809_SYNC_IN) == 0)   ? _T("--") : _T("SI"),
4733                  ((int_state & MC6809_SYNC_OUT) == 0)  ? _T("--") : _T("SO"),
4734                  ((int_state & MC6809_INSN_HALT) == 0) ? _T("----") : _T("TRAP"),
4735                  ((CC & CC_E) == 0)  ? _T('-') : _T('E'),
4736                  ((CC & CC_IF) == 0) ? _T('-') : _T('F'),
4737                  ((CC & CC_H) == 0)  ? _T('-') : _T('H'),
4738                  ((CC & CC_II) == 0) ? _T('-') : _T('I'),
4739                  ((CC & CC_N) == 0)  ? _T('-') : _T('N'),
4740                  ((CC & CC_Z) == 0)  ? _T('-') : _T('Z'),
4741                  ((CC & CC_V) == 0)  ? _T('-') : _T('V'),
4742                  ((CC & CC_C) == 0)  ? _T('-') : _T('C'),
4743                  A, B, DP,
4744                  X, Y, U, S,
4745                  EAD,
4746                   total_icount, total_icount - prev_total_icount,
4747                  get_passed_clock_since_vline(), get_cur_vline_clocks(), get_cur_vline(), get_lines_per_frame()
4748                 );
4749         prev_total_icount = total_icount;
4750 //#endif
4751         return true;
4752 }
4753
4754 #define STATE_VERSION   5
4755
4756 bool MC6809::process_state(FILEIO* state_fio, bool loading)
4757 {
4758         if(!state_fio->StateCheckUint32(STATE_VERSION)) {
4759                 return false;
4760         }
4761         if(!state_fio->StateCheckInt32(this_device_id)) {
4762                 return false;
4763         }
4764         state_fio->StateValue(icount);
4765         state_fio->StateValue(extra_icount);
4766         state_fio->StateValue(int_state);
4767
4768         state_fio->StateValue(pc.d);
4769         state_fio->StateValue(ppc.d);
4770         state_fio->StateValue(acc.d);
4771         state_fio->StateValue(dp.d);
4772         state_fio->StateValue(u.d);
4773         state_fio->StateValue(s.d);
4774         state_fio->StateValue(x.d);
4775         state_fio->StateValue(y.d);
4776         state_fio->StateValue(cc);
4777         state_fio->StateValue(ea.d);
4778
4779         // V2
4780         state_fio->StateValue(req_halt_on);
4781         state_fio->StateValue(req_halt_off);
4782         state_fio->StateValue(busreq);
4783
4784         state_fio->StateValue(total_icount);
4785         state_fio->StateValue(waitfactor);
4786         state_fio->StateValue(waitcount);
4787
4788         // post process
4789         if(loading) {
4790                 prev_total_icount = total_icount;
4791                 // Post process for collecting statistics.
4792                 cycles_tmp_count = total_icount;
4793                 extra_tmp_count = 0;
4794                 insns_count = 0;
4795                 frames_count = 0;
4796                 nmi_count = 0;
4797                 firq_count = 0;
4798                 irq_count = 0;
4799         }
4800         return true;
4801 }