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