1 /* gencode.c -- Motorola 68HC11 & 68HC12 Emulator Generator 2 Copyright 1999-2020 Free Software Foundation, Inc. 3 Written by Stephane Carrez (stcarrez@nerim.fr) 4 5 This file is part of GDB, GAS, and the GNU binutils. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include <stdio.h> 21 #include <stdlib.h> 22 #include <string.h> 23 #include <stdarg.h> 24 #include <errno.h> 25 26 #include "ansidecl.h" 27 #include "libiberty.h" 28 #include "opcode/m68hc11.h" 29 30 /* Combination of CCR flags. */ 31 #define M6811_ZC_BIT M6811_Z_BIT|M6811_C_BIT 32 #define M6811_NZ_BIT M6811_N_BIT|M6811_Z_BIT 33 #define M6811_NZV_BIT M6811_N_BIT|M6811_Z_BIT|M6811_V_BIT 34 #define M6811_NZC_BIT M6811_N_BIT|M6811_Z_BIT|M6811_C_BIT 35 #define M6811_NVC_BIT M6811_N_BIT|M6811_V_BIT|M6811_C_BIT 36 #define M6811_ZVC_BIT M6811_Z_BIT|M6811_V_BIT|M6811_C_BIT 37 #define M6811_NZVC_BIT M6811_ZVC_BIT|M6811_N_BIT 38 #define M6811_HNZVC_BIT M6811_NZVC_BIT|M6811_H_BIT 39 #define M6811_HNVC_BIT M6811_NVC_BIT|M6811_H_BIT 40 #define M6811_VC_BIT M6811_V_BIT|M6811_C_BIT 41 42 /* Flags when the insn only changes some CCR flags. */ 43 #define CHG_NONE 0,0,0 44 #define CHG_Z 0,0,M6811_Z_BIT 45 #define CHG_C 0,0,M6811_C_BIT 46 #define CHG_ZVC 0,0,M6811_ZVC_BIT 47 #define CHG_NZC 0,0,M6811_NZC_BIT 48 #define CHG_NZV 0,0,M6811_NZV_BIT 49 #define CHG_NZVC 0,0,M6811_NZVC_BIT 50 #define CHG_HNZVC 0,0,M6811_HNZVC_BIT 51 #define CHG_ALL 0,0,0xff 52 53 /* The insn clears and changes some flags. */ 54 #define CLR_I 0,M6811_I_BIT,0 55 #define CLR_C 0,M6811_C_BIT,0 56 #define CLR_V 0,M6811_V_BIT,0 57 #define CLR_V_CHG_ZC 0,M6811_V_BIT,M6811_ZC_BIT 58 #define CLR_V_CHG_NZ 0,M6811_V_BIT,M6811_NZ_BIT 59 #define CLR_V_CHG_ZVC 0,M6811_V_BIT,M6811_ZVC_BIT 60 #define CLR_N_CHG_ZVC 0,M6811_N_BIT,M6811_ZVC_BIT /* Used by lsr */ 61 #define CLR_VC_CHG_NZ 0,M6811_VC_BIT,M6811_NZ_BIT 62 63 /* The insn sets some flags. */ 64 #define SET_I M6811_I_BIT,0,0 65 #define SET_C M6811_C_BIT,0,0 66 #define SET_V M6811_V_BIT,0,0 67 #define SET_Z_CLR_NVC M6811_Z_BIT,M6811_NVC_BIT,0 68 #define SET_C_CLR_V_CHG_NZ M6811_C_BIT,M6811_V_BIT,M6811_NZ_BIT 69 #define SET_Z_CHG_HNVC M6811_Z_BIT,0,M6811_HNVC_BIT 70 71 #define _M 0xff 72 73 static int cpu_type; 74 75 struct m6811_opcode_pattern 76 { 77 const char *name; 78 const char *pattern; 79 const char *ccr_update; 80 }; 81 82 /* 83 * { "test", M6811_OP_NONE, 1, 0x00, 5, _M, CHG_NONE }, 84 * Name -+ +---- Insn CCR changes 85 * Format ------+ +---------- Max # cycles 86 * Size -----------------+ +--------------- Min # cycles 87 * +-------------------- Opcode 88 */ 89 struct m6811_opcode_pattern m6811_opcode_patterns[] = { 90 /* Move 8 and 16 bits. We need two implementations: one that sets the 91 flags and one that preserve them. */ 92 { "movtst8", "dst8 = src8", "cpu_ccr_update_tst8 (cpu, dst8)" }, 93 { "movtst16", "dst16 = src16", "cpu_ccr_update_tst16 (cpu, dst16)" }, 94 { "mov8", "dst8 = src8" }, 95 { "mov16", "dst16 = src16" }, 96 { "lea16", "dst16 = addr" }, 97 98 /* Conditional branches. 'addr' is the address of the branch. */ 99 { "bra", "cpu_set_pc (cpu, addr)" }, 100 { "bhi", 101 "if ((cpu_get_ccr (cpu) & (M6811_C_BIT|M6811_Z_BIT)) == 0)\n@ \ 102 cpu_set_pc (cpu, addr)" }, 103 { "bls", 104 "if ((cpu_get_ccr (cpu) & (M6811_C_BIT|M6811_Z_BIT)))\n@ \ 105 cpu_set_pc (cpu, addr)" }, 106 { "bcc", "if (!cpu_get_ccr_C (cpu))\n@ cpu_set_pc (cpu, addr)" }, 107 { "bcs", "if (cpu_get_ccr_C (cpu))\n@ cpu_set_pc (cpu, addr)" }, 108 { "bne", "if (!cpu_get_ccr_Z (cpu))\n@ cpu_set_pc (cpu, addr)" }, 109 { "beq", "if (cpu_get_ccr_Z (cpu))\n@ cpu_set_pc (cpu, addr)" }, 110 { "bvc", "if (!cpu_get_ccr_V (cpu))\n@ cpu_set_pc (cpu, addr)" }, 111 { "bvs", "if (cpu_get_ccr_V (cpu))\n@ cpu_set_pc (cpu, addr)" }, 112 { "bpl", "if (!cpu_get_ccr_N (cpu))\n@ cpu_set_pc (cpu, addr)" }, 113 { "bmi", "if (cpu_get_ccr_N (cpu))\n@ cpu_set_pc (cpu, addr)" }, 114 { "bge", "if ((cpu_get_ccr_N (cpu) ^ cpu_get_ccr_V (cpu)) == 0)\n@ cpu_set_pc (cpu, addr)" }, 115 { "blt", "if ((cpu_get_ccr_N (cpu) ^ cpu_get_ccr_V (cpu)))\n@ cpu_set_pc (cpu, addr)" }, 116 { "bgt", 117 "if ((cpu_get_ccr_Z (cpu) | (cpu_get_ccr_N (cpu) ^ cpu_get_ccr_V (cpu))) == 0)\n@ \ 118 cpu_set_pc (cpu, addr)" }, 119 { "ble", 120 "if ((cpu_get_ccr_Z (cpu) | (cpu_get_ccr_N (cpu) ^ cpu_get_ccr_V (cpu))))\n@ \ 121 cpu_set_pc (cpu, addr)" }, 122 123 /* brclr and brset perform a test and a conditional jump at the same 124 time. Flags are not changed. */ 125 { "brclr8", 126 "if ((src8 & dst8) == 0)\n@ cpu_set_pc (cpu, addr)" }, 127 { "brset8", 128 "if (((~src8) & dst8) == 0)\n@ cpu_set_pc (cpu, addr)" }, 129 130 131 { "rts11", "addr = cpu_m68hc11_pop_uint16 (cpu); cpu_set_pc (cpu, addr); cpu_return (cpu)" }, 132 { "rts12", "addr = cpu_m68hc12_pop_uint16 (cpu); cpu_set_pc (cpu, addr); cpu_return (cpu)" }, 133 134 { "mul16", "dst16 = ((uint16) src8 & 0x0FF) * ((uint16) dst8 & 0x0FF)", 135 "cpu_set_ccr_C (cpu, src8 & 0x80)" }, 136 { "neg8", "dst8 = - src8", 137 "cpu_set_ccr_C (cpu, src8 == 0); cpu_ccr_update_tst8 (cpu, dst8)" }, 138 { "com8", "dst8 = ~src8", 139 "cpu_set_ccr_C (cpu, 1); cpu_ccr_update_tst8 (cpu, dst8);" }, 140 { "clr8", "dst8 = 0", 141 "cpu_set_ccr (cpu, (cpu_get_ccr (cpu) & (M6811_S_BIT|M6811_X_BIT|M6811_H_BIT| \ 142 M6811_I_BIT)) | M6811_Z_BIT)"}, 143 { "clr16","dst16 = 0", 144 "cpu_set_ccr (cpu, (cpu_get_ccr (cpu) & (M6811_S_BIT|M6811_X_BIT|M6811_H_BIT| \ 145 M6811_I_BIR)) | M6811_Z_BIT)"}, 146 147 /* 8-bits shift and rotation. */ 148 { "lsr8", "dst8 = src8 >> 1", 149 "cpu_set_ccr_C (cpu, src8 & 1); cpu_ccr_update_shift8 (cpu, dst8)" }, 150 { "lsl8", "dst8 = src8 << 1", 151 "cpu_set_ccr_C (cpu, (src8 & 0x80) >> 7); cpu_ccr_update_shift8 (cpu, dst8)" }, 152 { "asr8", "dst8 = (src8 >> 1) | (src8 & 0x80)", 153 "cpu_set_ccr_C (cpu, src8 & 1); cpu_ccr_update_shift8 (cpu, dst8)" }, 154 { "ror8", "dst8 = (src8 >> 1) | (cpu_get_ccr_C (cpu) << 7)", 155 "cpu_set_ccr_C (cpu, src8 & 1); cpu_ccr_update_shift8 (cpu, dst8)" }, 156 { "rol8", "dst8 = (src8 << 1) | (cpu_get_ccr_C (cpu))", 157 "cpu_set_ccr_C (cpu, (src8 & 0x80) >> 7); cpu_ccr_update_shift8 (cpu, dst8)" }, 158 159 /* 16-bits shift instructions. */ 160 { "lsl16", "dst16 = src16 << 1", 161 "cpu_set_ccr_C (cpu, (src16&0x8000) >> 15); cpu_ccr_update_shift16 (cpu, dst16)"}, 162 { "lsr16", "dst16 = src16 >> 1", 163 "cpu_set_ccr_C (cpu, src16 & 1); cpu_ccr_update_shift16 (cpu, dst16)"}, 164 165 { "dec8", "dst8 = src8 - 1", "cpu_ccr_update_tst8 (cpu, dst8)" }, 166 { "inc8", "dst8 = src8 + 1", "cpu_ccr_update_tst8 (cpu, dst8)" }, 167 { "tst8", 0, "cpu_set_ccr_C (cpu, 0); cpu_ccr_update_tst8 (cpu, src8)" }, 168 169 { "sub8", "cpu_ccr_update_sub8 (cpu, dst8 - src8, dst8, src8);\ 170 dst8 = dst8 - src8", 0 }, 171 { "add8", "cpu_ccr_update_add8 (cpu, dst8 + src8, dst8, src8);\ 172 dst8 = dst8 + src8", 0 }, 173 { "sbc8", "if (cpu_get_ccr_C (cpu))\n@ \ 174 {\n\ 175 cpu_ccr_update_sub8 (cpu, dst8 - src8 - 1, dst8, src8);\n\ 176 dst8 = dst8 - src8 - 1;\n\ 177 }\n\ 178 else\n\ 179 {\n\ 180 cpu_ccr_update_sub8 (cpu, dst8 - src8, dst8, src8);\n\ 181 dst8 = dst8 - src8;\n\ 182 }", 0 }, 183 { "adc8", "if (cpu_get_ccr_C (cpu))\n@ \ 184 {\n\ 185 cpu_ccr_update_add8 (cpu, dst8 + src8 + 1, dst8, src8);\n\ 186 dst8 = dst8 + src8 + 1;\n\ 187 }\n\ 188 else\n\ 189 {\n\ 190 cpu_ccr_update_add8 (cpu, dst8 + src8, dst8, src8);\n\ 191 dst8 = dst8 + src8;\n\ 192 }", 193 0 }, 194 195 /* 8-bits logical operations. */ 196 { "and8", "dst8 = dst8 & src8", "cpu_ccr_update_tst8 (cpu, dst8)" }, 197 { "eor8", "dst8 = dst8 ^ src8", "cpu_ccr_update_tst8 (cpu, dst8)" }, 198 { "or8", "dst8 = dst8 | src8", "cpu_ccr_update_tst8 (cpu, dst8)" }, 199 { "bclr8","dst8 = (~dst8) & src8", "cpu_ccr_update_tst8 (cpu, dst8)" }, 200 201 /* 16-bits add and subtract instructions. */ 202 { "sub16", "cpu_ccr_update_sub16 (cpu, dst16 - src16, dst16, src16);\ 203 dst16 = dst16 - src16", 0 }, 204 { "add16", "cpu_ccr_update_add16 (cpu, dst16 + src16, dst16, src16);\ 205 dst16 = dst16 + src16", 0 }, 206 { "inc16", "dst16 = src16 + 1", "cpu_set_ccr_Z (cpu, dst16 == 0)" }, 207 { "dec16", "dst16 = src16 - 1", "cpu_set_ccr_Z (cpu, dst16 == 0)" }, 208 209 /* Special increment/decrement for the stack pointer: 210 flags are not changed. */ 211 { "ins16", "dst16 = src16 + 1" }, 212 { "des16", "dst16 = src16 - 1" }, 213 214 { "jsr_11_16", "cpu_m68hc11_push_uint16 (cpu, cpu_get_pc (cpu)); cpu_call (cpu, addr)"}, 215 { "jsr_12_16", "cpu_m68hc12_push_uint16 (cpu, cpu_get_pc (cpu)); cpu_call (cpu, addr)"}, 216 217 /* xgdx and xgdx patterns. Flags are not changed. */ 218 { "xgdxy16", "dst16 = cpu_get_d (cpu); cpu_set_d (cpu, src16)"}, 219 { "stop", "cpu_special (cpu, M6811_STOP)"}, 220 221 /* tsx, tsy, txs, tys don't affect the flags. Sp value is corrected 222 by +/- 1. */ 223 { "tsxy16", "dst16 = src16 + 1;"}, 224 { "txys16", "dst16 = src16 - 1;"}, 225 226 /* Add b to X or Y with an unsigned extension 8->16. Flags not changed. */ 227 { "abxy16","dst16 = dst16 + (uint16) src8"}, 228 229 /* After 'daa', the Z flag is undefined. Mark it as changed. */ 230 { "daa8", "cpu_special (cpu, M6811_DAA)" }, 231 { "nop", 0 }, 232 233 234 /* Integer divide: 235 (parallel (set IX (div D IX)) 236 (set D (mod D IX))) */ 237 { "idiv16", "if (src16 == 0)\n{\n\ 238 dst16 = 0xffff;\ 239 }\nelse\n{\n\ 240 cpu_set_d (cpu, dst16 % src16);\ 241 dst16 = dst16 / src16;\ 242 }", 243 "cpu_set_ccr_Z (cpu, dst16 == 0); cpu_set_ccr_V (cpu, 0);\ 244 cpu_set_ccr_C (cpu, src16 == 0)" }, 245 246 /* Fractional divide: 247 (parallel (set IX (div (mul D 65536) IX) 248 (set D (mod (mul D 65536) IX)))) */ 249 { "fdiv16", "if (src16 <= dst16 )\n{\n\ 250 dst16 = 0xffff;\n\ 251 cpu_set_ccr_Z (cpu, 0);\n\ 252 cpu_set_ccr_V (cpu, 1);\n\ 253 cpu_set_ccr_C (cpu, dst16 == 0);\n\ 254 }\nelse\n{\n\ 255 unsigned long l = (unsigned long) (dst16) << 16;\n\ 256 cpu_set_d (cpu, (uint16) (l % (unsigned long) (src16)));\n\ 257 dst16 = (uint16) (l / (unsigned long) (src16));\n\ 258 cpu_set_ccr_V (cpu, 0);\n\ 259 cpu_set_ccr_C (cpu, 0);\n\ 260 cpu_set_ccr_Z (cpu, dst16 == 0);\n\ 261 }", 0 }, 262 263 /* Operations to get/set the CCR. */ 264 { "clv", 0, "cpu_set_ccr_V (cpu, 0)" }, 265 { "sev", 0, "cpu_set_ccr_V (cpu, 1)" }, 266 { "clc", 0, "cpu_set_ccr_C (cpu, 0)" }, 267 { "sec", 0, "cpu_set_ccr_C (cpu, 1)" }, 268 { "cli", 0, "cpu_set_ccr_I (cpu, 0)" }, 269 { "sei", 0, "cpu_set_ccr_I (cpu, 1)" }, 270 271 /* Some special instructions are implemented by 'cpu_special'. */ 272 { "rti11", "cpu_special (cpu, M6811_RTI)" }, 273 { "rti12", "cpu_special (cpu, M6812_RTI)" }, 274 { "wai", "cpu_special (cpu, M6811_WAI)" }, 275 { "test", "cpu_special (cpu, M6811_TEST)" }, 276 { "swi", "cpu_special (cpu, M6811_SWI)" }, 277 { "syscall","cpu_special (cpu, M6811_EMUL_SYSCALL)" }, 278 279 { "page2", "cpu_page2_interp (cpu)", 0 }, 280 { "page3", "cpu_page3_interp (cpu)", 0 }, 281 { "page4", "cpu_page4_interp (cpu)", 0 }, 282 283 /* 68HC12 special instructions. */ 284 { "bgnd", "cpu_special (cpu, M6812_BGND)" }, 285 { "call8", "cpu_special (cpu, M6812_CALL)" }, 286 { "call_ind", "cpu_special (cpu, M6812_CALL_INDIRECT)" }, 287 { "dbcc8", "cpu_dbcc (cpu)" }, 288 { "ediv", "cpu_special (cpu, M6812_EDIV)" }, 289 { "emul", "{ uint32 src1 = (uint32) cpu_get_d (cpu);\ 290 uint32 src2 = (uint32) cpu_get_y (cpu);\ 291 src1 *= src2;\ 292 cpu_set_d (cpu, src1);\ 293 cpu_set_y (cpu, src1 >> 16);\ 294 cpu_set_ccr_Z (cpu, src1 == 0);\ 295 cpu_set_ccr_C (cpu, src1 & 0x08000);\ 296 cpu_set_ccr_N (cpu, src1 & 0x80000000);}" }, 297 { "emuls", "cpu_special (cpu, M6812_EMULS)" }, 298 { "mem", "cpu_special (cpu, M6812_MEM)" }, 299 { "rtc", "cpu_special (cpu, M6812_RTC)" }, 300 { "emacs", "cpu_special (cpu, M6812_EMACS)" }, 301 { "idivs", "cpu_special (cpu, M6812_IDIVS)" }, 302 { "edivs", "cpu_special (cpu, M6812_EDIVS)" }, 303 { "exg8", "cpu_exg (cpu, src8)" }, 304 { "move8", "cpu_move8 (cpu, op)" }, 305 { "move16","cpu_move16 (cpu, op)" }, 306 307 { "max8", "cpu_ccr_update_sub8 (cpu, dst8 - src8, dst8, src8);\ 308 if (dst8 < src8) dst8 = src8" }, 309 { "min8", "cpu_ccr_update_sub8 (cpu, dst8 - src8, dst8, src8);\ 310 if (dst8 > src8) dst8 = src8" }, 311 { "max16", "cpu_ccr_update_sub16 (cpu, dst16 - src16, dst16, src16);\ 312 if (dst16 < src16) dst16 = src16" }, 313 { "min16", "cpu_ccr_update_sub16 (cpu, dst16 - src16, dst16, src16);\ 314 if (dst16 > src16) dst16 = src16" }, 315 316 { "rev", "cpu_special (cpu, M6812_REV);" }, 317 { "revw", "cpu_special (cpu, M6812_REVW);" }, 318 { "wav", "cpu_special (cpu, M6812_WAV);" }, 319 { "tbl8", "cpu_special (cpu, M6812_ETBL);" }, 320 { "tbl16", "cpu_special (cpu, M6812_ETBL);" } 321 }; 322 323 /* Definition of an opcode of the 68HC11. */ 324 struct m6811_opcode_def 325 { 326 const char *name; 327 const char *operands; 328 const char *insn_pattern; 329 unsigned char insn_size; 330 unsigned char insn_code; 331 unsigned char insn_min_cycles; 332 unsigned char insn_max_cycles; 333 unsigned char set_flags_mask; 334 unsigned char clr_flags_mask; 335 unsigned char chg_flags_mask; 336 }; 337 338 339 /* 340 * { "dex", "x->x", "dec16", 1, 0x00, 5, _M, CHG_NONE }, 341 * Name -+ +----- Insn CCR changes 342 * Operands ---+ +------------ Max # cycles 343 * Pattern -----------+ +--------------- Min # cycles 344 * Size -----------------+ +-------------------- Opcode 345 * 346 * Operands Fetch operand Save result 347 * ------- -------------- ------------ 348 * x->x src16 = x x = dst16 349 * d->d src16 = d d = dst16 350 * b,a->a src8 = b dst8 = a a = dst8 351 * sp->x src16 = sp x = dst16 352 * (sp)->a src8 = pop8 a = dst8 353 * a->(sp) src8 = a push8 dst8 354 * (x)->(x) src8 = (IND, X) (IND, X) = dst8 355 * (y)->a src8 = (IND, Y) a = dst8 356 * ()->b src8 = (EXT) b = dst8 357 */ 358 struct m6811_opcode_def m6811_page1_opcodes[] = { 359 { "test", 0, 0, 1, 0x00, 5, _M, CHG_NONE }, 360 { "nop", 0, 0, 1, 0x01, 2, 2, CHG_NONE }, 361 { "idiv", "x,d->x", "idiv16", 1, 0x02, 3, 41, CLR_V_CHG_ZC}, 362 { "fdiv", "x,d->x", "fdiv16", 1, 0x03, 3, 41, CHG_ZVC}, 363 { "lsrd", "d->d", "lsr16", 1, 0x04, 3, 3, CLR_N_CHG_ZVC }, 364 { "asld", "d->d", "lsl16", 1, 0x05, 3, 3, CHG_NZVC }, 365 { "tap", "a->ccr", "mov8", 1, 0x06, 2, 2, CHG_ALL}, 366 { "tpa", "ccr->a", "mov8", 1, 0x07, 2, 2, CHG_NONE }, 367 { "inx", "x->x", "inc16", 1, 0x08, 3, 3, CHG_Z }, 368 { "dex", "x->x", "dec16", 1, 0x09, 3, 3, CHG_Z }, 369 { "clv", 0, 0, 1, 0x0a, 2, 2, CLR_V }, 370 { "sev", 0, 0, 1, 0x0b, 2, 2, SET_V }, 371 { "clc", 0, 0, 1, 0x0c, 2, 2, CLR_C }, 372 { "sec", 0, 0, 1, 0x0d, 2, 2, SET_C }, 373 { "cli", 0, 0, 1, 0x0e, 2, 2, CLR_I }, 374 { "sei", 0, 0, 1, 0x0f, 2, 2, SET_I }, 375 { "sba", "b,a->a", "sub8", 1, 0x10, 2, 2, CHG_NZVC }, 376 { "cba", "b,a", "sub8", 1, 0x11, 2, 2, CHG_NZVC }, 377 { "brset","*,#,r", "brset8", 4, 0x12, 6, 6, CHG_NONE }, 378 { "brclr","*,#,r", "brclr8", 4, 0x13, 6, 6, CHG_NONE }, 379 { "bset", "*,#->*", "or8", 3, 0x14, 6, 6, CLR_V_CHG_NZ }, 380 { "bclr", "*,#->*", "bclr8", 3, 0x15, 6, 6, CLR_V_CHG_NZ }, 381 { "tab", "a->b", "movtst8", 1, 0x16, 2, 2, CLR_V_CHG_NZ }, 382 { "tba", "b->a", "movtst8", 1, 0x17, 2, 2, CLR_V_CHG_NZ }, 383 { "page2", 0, "page2", 1, 0x18, 0, 0, CHG_NONE }, 384 { "page3", 0, "page3", 1, 0x1a, 0, 0, CHG_NONE }, 385 386 /* After 'daa', the Z flag is undefined. Mark it as changed. */ 387 { "daa", "", "daa8", 1, 0x19, 2, 2, CHG_NZVC }, 388 { "aba", "b,a->a", "add8", 1, 0x1b, 2, 2, CHG_HNZVC}, 389 { "bset", "(x),#->(x)","or8", 3, 0x1c, 7, 7, CLR_V_CHG_NZ }, 390 { "bclr", "(x),#->(x)","bclr8", 3, 0x1d, 7, 7, CLR_V_CHG_NZ }, 391 { "brset","(x),#,r", "brset8", 4, 0x1e, 7, 7, CHG_NONE }, 392 { "brclr","(x),#,r", "brclr8", 4, 0x1f, 7, 7, CHG_NONE }, 393 394 /* Relative branch. All of them take 3 bytes. Flags not changed. */ 395 { "bra", "r", 0, 2, 0x20, 3, 3, CHG_NONE }, 396 { "brn", "r", "nop", 2, 0x21, 3, 3, CHG_NONE }, 397 { "bhi", "r", 0, 2, 0x22, 3, 3, CHG_NONE }, 398 { "bls", "r", 0, 2, 0x23, 3, 3, CHG_NONE }, 399 { "bcc", "r", 0, 2, 0x24, 3, 3, CHG_NONE }, 400 { "bcs", "r", 0, 2, 0x25, 3, 3, CHG_NONE }, 401 { "bne", "r", 0, 2, 0x26, 3, 3, CHG_NONE }, 402 { "beq", "r", 0, 2, 0x27, 3, 3, CHG_NONE }, 403 { "bvc", "r", 0, 2, 0x28, 3, 3, CHG_NONE }, 404 { "bvs", "r", 0, 2, 0x29, 3, 3, CHG_NONE }, 405 { "bpl", "r", 0, 2, 0x2a, 3, 3, CHG_NONE }, 406 { "bmi", "r", 0, 2, 0x2b, 3, 3, CHG_NONE }, 407 { "bge", "r", 0, 2, 0x2c, 3, 3, CHG_NONE }, 408 { "blt", "r", 0, 2, 0x2d, 3, 3, CHG_NONE }, 409 { "bgt", "r", 0, 2, 0x2e, 3, 3, CHG_NONE }, 410 { "ble", "r", 0, 2, 0x2f, 3, 3, CHG_NONE }, 411 412 { "tsx", "sp->x", "tsxy16", 1, 0x30, 3, 3, CHG_NONE }, 413 { "ins", "sp->sp", "ins16", 1, 0x31, 3, 3, CHG_NONE }, 414 { "pula", "(sp)->a", "mov8", 1, 0x32, 4, 4, CHG_NONE }, 415 { "pulb", "(sp)->b", "mov8", 1, 0x33, 4, 4, CHG_NONE }, 416 { "des", "sp->sp", "des16", 1, 0x34, 3, 3, CHG_NONE }, 417 { "txs", "x->sp", "txys16", 1, 0x35, 3, 3, CHG_NONE }, 418 { "psha", "a->(sp)", "mov8", 1, 0x36, 3, 3, CHG_NONE }, 419 { "pshb", "b->(sp)", "mov8", 1, 0x37, 3, 3, CHG_NONE }, 420 { "pulx", "(sp)->x", "mov16", 1, 0x38, 5, 5, CHG_NONE }, 421 { "rts", 0, "rts11", 1, 0x39, 5, 5, CHG_NONE }, 422 { "abx", "b,x->x", "abxy16", 1, 0x3a, 3, 3, CHG_NONE }, 423 { "rti", 0, "rti11", 1, 0x3b, 12, 12, CHG_ALL}, 424 { "pshx", "x->(sp)", "mov16", 1, 0x3c, 4, 4, CHG_NONE }, 425 { "mul", "b,a->d", "mul16", 1, 0x3d, 3, 10, CHG_C }, 426 { "wai", 0, 0, 1, 0x3e, 14, _M, CHG_NONE }, 427 { "swi", 0, 0, 1, 0x3f, 14, _M, CHG_NONE }, 428 { "nega", "a->a", "neg8", 1, 0x40, 2, 2, CHG_NZVC }, 429 { "syscall", "", "syscall", 1, 0x41, 2, 2, CHG_NONE }, 430 { "coma", "a->a", "com8", 1, 0x43, 2, 2, SET_C_CLR_V_CHG_NZ }, 431 { "lsra", "a->a", "lsr8", 1, 0x44, 2, 2, CLR_N_CHG_ZVC}, 432 { "rora", "a->a", "ror8", 1, 0x46, 2, 2, CHG_NZVC }, 433 { "asra", "a->a", "asr8", 1, 0x47, 2, 2, CHG_NZVC }, 434 { "asla", "a->a", "lsl8", 1, 0x48, 2, 2, CHG_NZVC }, 435 { "rola", "a->a", "rol8", 1, 0x49, 2, 2, CHG_NZVC }, 436 { "deca", "a->a", "dec8", 1, 0x4a, 2, 2, CHG_NZV }, 437 { "inca", "a->a", "inc8", 1, 0x4c, 2, 2, CHG_NZV }, 438 { "tsta", "a", "tst8", 1, 0x4d, 2, 2, CLR_V_CHG_NZ }, 439 { "clra", "->a", "clr8", 1, 0x4f, 2, 2, SET_Z_CLR_NVC }, 440 { "negb", "b->b", "neg8", 1, 0x50, 2, 2, CHG_NZVC }, 441 { "comb", "b->b", "com8", 1, 0x53, 2, 2, SET_C_CLR_V_CHG_NZ }, 442 { "lsrb", "b->b", "lsr8", 1, 0x54, 2, 2, CLR_N_CHG_ZVC }, 443 { "rorb", "b->b", "ror8", 1, 0x56, 2, 2, CHG_NZVC }, 444 { "asrb", "b->b", "asr8", 1, 0x57, 2, 2, CHG_NZVC }, 445 { "aslb", "b->b", "lsl8", 1, 0x58, 2, 2, CHG_NZVC }, 446 { "rolb", "b->b", "rol8", 1, 0x59, 2, 2, CHG_NZVC }, 447 { "decb", "b->b", "dec8", 1, 0x5a, 2, 2, CHG_NZV }, 448 { "incb", "b->b", "inc8", 1, 0x5c, 2, 2, CHG_NZV }, 449 { "tstb", "b", "tst8", 1, 0x5d, 2, 2, CLR_V_CHG_NZ }, 450 { "clrb", "->b", "clr8", 1, 0x5f, 2, 2, SET_Z_CLR_NVC }, 451 { "neg", "(x)->(x)", "neg8", 2, 0x60, 6, 6, CHG_NZVC }, 452 { "com", "(x)->(x)", "com8", 2, 0x63, 6, 6, SET_C_CLR_V_CHG_NZ }, 453 { "lsr", "(x)->(x)", "lsr8", 2, 0x64, 6, 6, CLR_N_CHG_ZVC }, 454 { "ror", "(x)->(x)", "ror8", 2, 0x66, 6, 6, CHG_NZVC }, 455 { "asr", "(x)->(x)", "asr8", 2, 0x67, 6, 6, CHG_NZVC }, 456 { "asl", "(x)->(x)", "lsl8", 2, 0x68, 6, 6, CHG_NZVC }, 457 { "rol", "(x)->(x)", "rol8", 2, 0x69, 6, 6, CHG_NZVC }, 458 { "dec", "(x)->(x)", "dec8", 2, 0x6a, 6, 6, CHG_NZV }, 459 { "inc", "(x)->(x)", "inc8", 2, 0x6c, 6, 6, CHG_NZV }, 460 { "tst", "(x)", "tst8", 2, 0x6d, 6, 6, CLR_V_CHG_NZ }, 461 { "jmp", "&(x)", "bra", 2, 0x6e, 3, 3, CHG_NONE }, 462 { "clr", "->(x)", "clr8", 2, 0x6f, 6, 6, SET_Z_CLR_NVC }, 463 { "neg", "()->()", "neg8", 3, 0x70, 6, 6, CHG_NZVC }, 464 { "com", "()->()", "com8", 3, 0x73, 6, 6, SET_C_CLR_V_CHG_NZ }, 465 { "lsr", "()->()", "lsr8", 3, 0x74, 6, 6, CLR_V_CHG_ZVC }, 466 { "ror", "()->()", "ror8", 3, 0x76, 6, 6, CHG_NZVC }, 467 { "asr", "()->()", "asr8", 3, 0x77, 6, 6, CHG_NZVC }, 468 { "asl", "()->()", "lsl8", 3, 0x78, 6, 6, CHG_NZVC }, 469 { "rol", "()->()", "rol8", 3, 0x79, 6, 6, CHG_NZVC }, 470 { "dec", "()->()", "dec8", 3, 0x7a, 6, 6, CHG_NZV }, 471 { "inc", "()->()", "inc8", 3, 0x7c, 6, 6, CHG_NZV }, 472 { "tst", "()", "tst8", 3, 0x7d, 6, 6, CLR_V_CHG_NZ }, 473 { "jmp", "&()", "bra", 3, 0x7e, 3, 3, CHG_NONE }, 474 { "clr", "->()", "clr8", 3, 0x7f, 6, 6, SET_Z_CLR_NVC }, 475 { "suba", "#,a->a", "sub8", 2, 0x80, 2, 2, CHG_NZVC }, 476 { "cmpa", "#,a", "sub8", 2, 0x81, 2, 2, CHG_NZVC }, 477 { "sbca", "#,a->a", "sbc8", 2, 0x82, 2, 2, CHG_NZVC }, 478 { "subd", "#,d->d", "sub16", 3, 0x83, 4, 4, CHG_NZVC }, 479 { "anda", "#,a->a", "and8", 2, 0x84, 2, 2, CLR_V_CHG_NZ }, 480 { "bita", "#,a", "and8", 2, 0x85, 2, 2, CLR_V_CHG_NZ }, 481 { "ldaa", "#->a", "movtst8", 2, 0x86, 2, 2, CLR_V_CHG_NZ }, 482 { "eora", "#,a->a", "eor8", 2, 0x88, 2, 2, CLR_V_CHG_NZ }, 483 { "adca", "#,a->a", "adc8", 2, 0x89, 2, 2, CHG_HNZVC }, 484 { "oraa", "#,a->a", "or8", 2, 0x8a, 2, 2, CLR_V_CHG_NZ }, 485 { "adda", "#,a->a", "add8", 2, 0x8b, 2, 2, CHG_HNZVC }, 486 { "cmpx", "#,x", "sub16", 3, 0x8c, 4, 4, CHG_NZVC }, 487 { "bsr", "r", "jsr_11_16", 2, 0x8d, 6, 6, CHG_NONE }, 488 { "lds", "#->sp", "movtst16", 3, 0x8e, 3, 3, CLR_V_CHG_NZ }, 489 { "xgdx", "x->x", "xgdxy16", 1, 0x8f, 3, 3, CHG_NONE }, 490 { "suba", "*,a->a", "sub8", 2, 0x90, 3, 3, CHG_NZVC }, 491 { "cmpa", "*,a", "sub8", 2, 0x91, 3, 3, CHG_NZVC }, 492 { "sbca", "*,a->a", "sbc8", 2, 0x92, 3, 3, CHG_NZVC }, 493 { "subd", "*,d->d", "sub16", 2, 0x93, 5, 5, CHG_NZVC }, 494 { "anda", "*,a->a", "and8", 2, 0x94, 3, 3, CLR_V_CHG_NZ }, 495 { "bita", "*,a", "and8", 2, 0x95, 3, 3, CLR_V_CHG_NZ }, 496 { "ldaa", "*->a", "movtst8", 2, 0x96, 3, 3, CLR_V_CHG_NZ }, 497 { "staa", "a->*", "movtst8", 2, 0x97, 3, 3, CLR_V_CHG_NZ }, 498 { "eora", "*,a->a", "eor8", 2, 0x98, 3, 3, CLR_V_CHG_NZ }, 499 { "adca", "*,a->a", "adc8", 2, 0x99, 3, 3, CHG_HNZVC }, 500 { "oraa", "*,a->a", "or8", 2, 0x9a, 3, 3, CLR_V_CHG_NZ }, 501 { "adda", "*,a->a", "add8", 2, 0x9b, 3, 3, CHG_HNZVC }, 502 { "cmpx", "*,x", "sub16", 2, 0x9c, 5, 5, CHG_NZVC }, 503 { "jsr", "*", "jsr_11_16", 2, 0x9d, 5, 5, CHG_NONE }, 504 { "lds", "*->sp", "movtst16", 2, 0x9e, 4, 4, CLR_V_CHG_NZ }, 505 { "sts", "sp->*", "movtst16", 2, 0x9f, 4, 4, CLR_V_CHG_NZ }, 506 { "suba", "(x),a->a", "sub8", 2, 0xa0, 4, 4, CHG_NZVC }, 507 { "cmpa", "(x),a", "sub8", 2, 0xa1, 4, 4, CHG_NZVC }, 508 { "sbca", "(x),a->a", "sbc8", 2, 0xa2, 4, 4, CHG_NZVC }, 509 { "subd", "(x),d->d", "sub16", 2, 0xa3, 6, 6, CHG_NZVC }, 510 { "anda", "(x),a->a", "and8", 2, 0xa4, 4, 4, CLR_V_CHG_NZ }, 511 { "bita", "(x),a", "and8", 2, 0xa5, 4, 4, CLR_V_CHG_NZ }, 512 { "ldaa", "(x)->a", "movtst8", 2, 0xa6, 4, 4, CLR_V_CHG_NZ }, 513 { "staa", "a->(x)", "movtst8", 2, 0xa7, 4, 4, CLR_V_CHG_NZ }, 514 { "eora", "(x),a->a", "eor8", 2, 0xa8, 4, 4, CLR_V_CHG_NZ }, 515 { "adca", "(x),a->a", "adc8", 2, 0xa9, 4, 4, CHG_HNZVC }, 516 { "oraa", "(x),a->a", "or8", 2, 0xaa, 4, 4, CLR_V_CHG_NZ }, 517 { "adda", "(x),a->a", "add8", 2, 0xab, 4, 4, CHG_HNZVC }, 518 { "cmpx", "(x),x", "sub16", 2, 0xac, 6, 6, CHG_NZVC }, 519 { "jsr", "&(x)", "jsr_11_16", 2, 0xad, 6, 6, CHG_NONE }, 520 { "lds", "(x)->sp", "movtst16", 2, 0xae, 5, 5, CLR_V_CHG_NZ }, 521 { "sts", "sp->(x)", "movtst16", 2, 0xaf, 5, 5, CLR_V_CHG_NZ }, 522 { "suba", "(),a->a", "sub8", 3, 0xb0, 4, 4, CHG_NZVC }, 523 { "cmpa", "(),a", "sub8", 3, 0xb1, 4, 4, CHG_NZVC }, 524 { "sbca", "(),a->a", "sbc8", 3, 0xb2, 4, 4, CHG_NZVC }, 525 { "subd", "(),d->d", "sub16", 3, 0xb3, 6, 6, CHG_NZVC }, 526 { "anda", "(),a->a", "and8", 3, 0xb4, 4, 4, CLR_V_CHG_NZ }, 527 { "bita", "(),a", "and8", 3, 0xb5, 4, 4, CLR_V_CHG_NZ }, 528 { "ldaa", "()->a", "movtst8", 3, 0xb6, 4, 4, CLR_V_CHG_NZ }, 529 { "staa", "a->()", "movtst8", 3, 0xb7, 4, 4, CLR_V_CHG_NZ }, 530 { "eora", "(),a->a", "eor8", 3, 0xb8, 4, 4, CLR_V_CHG_NZ }, 531 { "adca", "(),a->a", "adc8", 3, 0xb9, 4, 4, CHG_HNZVC }, 532 { "oraa", "(),a->a", "or8", 3, 0xba, 4, 4, CLR_V_CHG_NZ }, 533 { "adda", "(),a->a", "add8", 3, 0xbb, 4, 4, CHG_HNZVC }, 534 { "cmpx", "(),x", "sub16", 3, 0xbc, 5, 5, CHG_NZVC }, 535 { "jsr", "&()", "jsr_11_16", 3, 0xbd, 6, 6, CHG_NONE }, 536 { "lds", "()->sp", "movtst16", 3, 0xbe, 5, 5, CLR_V_CHG_NZ }, 537 { "sts", "sp->()", "movtst16", 3, 0xbf, 5, 5, CLR_V_CHG_NZ }, 538 { "subb", "#,b->b", "sub8", 2, 0xc0, 2, 2, CHG_NZVC }, 539 { "cmpb", "#,b", "sub8", 2, 0xc1, 2, 2, CHG_NZVC }, 540 { "sbcb", "#,b->b", "sbc8", 2, 0xc2, 2, 2, CHG_NZVC }, 541 { "addd", "#,d->d", "add16", 3, 0xc3, 4, 4, CHG_NZVC }, 542 { "andb", "#,b->b", "and8", 2, 0xc4, 2, 2, CLR_V_CHG_NZ }, 543 { "bitb", "#,b", "and8", 2, 0xc5, 2, 2, CLR_V_CHG_NZ }, 544 { "ldab", "#->b", "movtst8", 2, 0xc6, 2, 2, CLR_V_CHG_NZ }, 545 { "eorb", "#,b->b", "eor8", 2, 0xc8, 2, 2, CLR_V_CHG_NZ }, 546 { "adcb", "#,b->b", "adc8", 2, 0xc9, 2, 2, CHG_HNZVC }, 547 { "orab", "#,b->b", "or8", 2, 0xca, 2, 2, CLR_V_CHG_NZ }, 548 { "addb", "#,b->b", "add8", 2, 0xcb, 2, 2, CHG_HNZVC }, 549 { "ldd", "#->d", "movtst16", 3, 0xcc, 3, 3, CLR_V_CHG_NZ }, 550 { "page4",0, "page4", 1, 0xcd, 0, 0, CHG_NONE }, 551 { "ldx", "#->x", "movtst16", 3, 0xce, 3, 3, CLR_V_CHG_NZ }, 552 { "stop", 0, 0, 1, 0xcf, 2, 2, CHG_NONE }, 553 { "subb", "*,b->b", "sub8", 2, 0xd0, 3, 3, CHG_NZVC }, 554 { "cmpb", "*,b", "sub8", 2, 0xd1, 3, 3, CHG_NZVC }, 555 { "sbcb", "*,b->b", "sbc8", 2, 0xd2, 3, 3, CHG_NZVC }, 556 { "addd", "*,d->d", "add16", 2, 0xd3, 5, 5, CHG_NZVC }, 557 { "andb", "*,b->b", "and8", 2, 0xd4, 3, 3, CLR_V_CHG_NZ }, 558 { "bitb", "*,b", "and8", 2, 0xd5, 3, 3, CLR_V_CHG_NZ }, 559 { "ldab", "*->b", "movtst8", 2, 0xd6, 3, 3, CLR_V_CHG_NZ }, 560 { "stab", "b->*", "movtst8", 2, 0xd7, 3, 3, CLR_V_CHG_NZ }, 561 { "eorb", "*,b->b", "eor8", 2, 0xd8, 3, 3, CLR_V_CHG_NZ }, 562 { "adcb", "*,b->b", "adc8", 2, 0xd9, 3, 3, CHG_HNZVC }, 563 { "orab", "*,b->b", "or8", 2, 0xda, 3, 3, CLR_V_CHG_NZ }, 564 { "addb", "*,b->b", "add8", 2, 0xdb, 3, 3, CHG_HNZVC }, 565 { "ldd", "*->d", "movtst16", 2, 0xdc, 4, 4, CLR_V_CHG_NZ }, 566 { "std", "d->*", "movtst16", 2, 0xdd, 4, 4, CLR_V_CHG_NZ }, 567 { "ldx", "*->x", "movtst16", 2, 0xde, 4, 4, CLR_V_CHG_NZ }, 568 { "stx", "x->*", "movtst16", 2, 0xdf, 4, 4, CLR_V_CHG_NZ }, 569 { "subb", "(x),b->b", "sub8", 2, 0xe0, 4, 4, CHG_NZVC }, 570 { "cmpb", "(x),b", "sub8", 2, 0xe1, 4, 4, CHG_NZVC }, 571 { "sbcb", "(x),b->b", "sbc8", 2, 0xe2, 4, 4, CHG_NZVC }, 572 { "addd", "(x),d->d", "add16", 2, 0xe3, 6, 6, CHG_NZVC }, 573 { "andb", "(x),b->b", "and8", 2, 0xe4, 4, 4, CLR_V_CHG_NZ }, 574 { "bitb", "(x),b", "and8", 2, 0xe5, 4, 4, CLR_V_CHG_NZ }, 575 { "ldab", "(x)->b", "movtst8", 2, 0xe6, 4, 4, CLR_V_CHG_NZ }, 576 { "stab", "b->(x)", "movtst8", 2, 0xe7, 4, 4, CLR_V_CHG_NZ }, 577 { "eorb", "(x),b->b", "eor8", 2, 0xe8, 4, 4, CLR_V_CHG_NZ }, 578 { "adcb", "(x),b->b", "adc8", 2, 0xe9, 4, 4, CHG_HNZVC }, 579 { "orab", "(x),b->b", "or8", 2, 0xea, 4, 4, CLR_V_CHG_NZ }, 580 { "addb", "(x),b->b", "add8", 2, 0xeb, 4, 4, CHG_HNZVC }, 581 { "ldd", "(x)->d", "movtst16", 2, 0xec, 5, 5, CLR_V_CHG_NZ }, 582 { "std", "d->(x)", "movtst16", 2, 0xed, 5, 5, CLR_V_CHG_NZ }, 583 { "ldx", "(x)->x", "movtst16", 2, 0xee, 5, 5, CLR_V_CHG_NZ }, 584 { "stx", "x->(x)", "movtst16", 2, 0xef, 5, 5, CLR_V_CHG_NZ }, 585 { "subb", "(),b->b", "sub8", 3, 0xf0, 4, 4, CHG_NZVC }, 586 { "cmpb", "(),b", "sub8", 3, 0xf1, 4, 4, CHG_NZVC }, 587 { "sbcb", "(),b->b", "sbc8", 3, 0xf2, 4, 4, CHG_NZVC }, 588 { "addd", "(),d->d", "add16", 3, 0xf3, 6, 6, CHG_NZVC }, 589 { "andb", "(),b->b", "and8", 3, 0xf4, 4, 4, CLR_V_CHG_NZ }, 590 { "bitb", "(),b", "and8", 3, 0xf5, 4, 4, CLR_V_CHG_NZ }, 591 { "ldab", "()->b", "movtst8", 3, 0xf6, 4, 4, CLR_V_CHG_NZ }, 592 { "stab", "b->()", "movtst8", 3, 0xf7, 4, 4, CLR_V_CHG_NZ }, 593 { "eorb", "(),b->b", "eor8", 3, 0xf8, 4, 4, CLR_V_CHG_NZ }, 594 { "adcb", "(),b->b", "eor8", 3, 0xf9, 4, 4, CHG_HNZVC }, 595 { "orab", "(),b->b", "or8", 3, 0xfa, 4, 4, CLR_V_CHG_NZ }, 596 { "addb", "(),b->b", "add8", 3, 0xfb, 4, 4, CHG_HNZVC }, 597 { "ldd", "()->d", "movtst16", 3, 0xfc, 5, 5, CLR_V_CHG_NZ }, 598 { "std", "d->()", "movtst16", 3, 0xfd, 5, 5, CLR_V_CHG_NZ }, 599 { "ldx", "()->x", "movtst16", 3, 0xfe, 5, 5, CLR_V_CHG_NZ }, 600 { "stx", "x->()", "movtst16", 3, 0xff, 5, 5, CLR_V_CHG_NZ } 601 }; 602 603 604 /* Page 2 opcodes */ 605 /* 606 * { "dex", "x->x", "dec16", 1, 0x00, 5, _M, CHG_NONE }, 607 * Name -+ +----- Insn CCR changes 608 * Operands ---+ +------------ Max # cycles 609 * Pattern -----------+ +--------------- Min # cycles 610 * Size -----------------+ +-------------------- Opcode 611 */ 612 struct m6811_opcode_def m6811_page2_opcodes[] = { 613 { "iny", "y->y", "inc16", 2, 0x08, 4, 4, CHG_Z }, 614 { "dey", "y->y", "dec16", 2, 0x09, 4, 4, CHG_Z }, 615 { "bset", "(y),#->(y)","or8", 4, 0x1c, 8, 8, CLR_V_CHG_NZ }, 616 { "bclr", "(y),#->(y)","bclr8", 4, 0x1d, 8, 8, CLR_V_CHG_NZ }, 617 { "brset","(y),#,r", "brset8", 5, 0x1e, 8, 8, CHG_NONE }, 618 { "brclr","(y),#,r", "brclr8", 5, 0x1f, 8, 8, CHG_NONE }, 619 { "tsy", "sp->y", "tsxy16", 2, 0x30, 4, 4, CHG_NONE }, 620 { "tys", "y->sp", "txys16", 2, 0x35, 4, 4, CHG_NONE }, 621 { "puly", "(sp)->y", "mov16", 2, 0x38, 6, 6, CHG_NONE }, 622 { "aby", "b,y->y", "abxy16", 2, 0x3a, 4, 4, CHG_NONE }, 623 { "pshy", "y->(sp)", "mov16", 2, 0x3c, 5, 5, CHG_NONE }, 624 { "neg", "(y)->(y)", "neg8", 3, 0x60, 7, 7, CHG_NZVC }, 625 { "com", "(y)->(y)", "com8", 3, 0x63, 7, 7, SET_C_CLR_V_CHG_NZ}, 626 { "lsr", "(y)->(y)", "lsr8", 3, 0x64, 7, 7, CLR_V_CHG_ZVC }, 627 { "ror", "(y)->(y)", "ror8", 3, 0x66, 7, 7, CHG_NZVC }, 628 { "asr", "(y)->(y)", "asr8", 3, 0x67, 7, 7, CHG_NZVC }, 629 { "asl", "(y)->(y)", "lsl8", 3, 0x68, 7, 7, CHG_NZVC }, 630 { "rol", "(y)->(y)", "rol8", 3, 0x69, 7, 7, CHG_NZVC }, 631 { "dec", "(y)->(y)", "dec8", 3, 0x6a, 7, 7, CHG_NZV }, 632 { "inc", "(y)->(y)", "inc8", 3, 0x6c, 7, 7, CHG_NZV }, 633 { "tst", "(y)", "tst8", 3, 0x6d, 7, 7, CLR_V_CHG_NZ }, 634 { "jmp", "&(y)", "bra", 3, 0x6e, 4, 4, CHG_NONE }, 635 { "clr", "->(y)", "clr8", 3, 0x6f, 7, 7, SET_Z_CLR_NVC }, 636 { "cmpy", "#,y", "sub16", 4, 0x8c, 5, 5, CHG_NZVC }, 637 { "xgdy", "y->y", "xgdxy16", 2, 0x8f, 4, 4, CHG_NONE }, 638 { "cmpy", "*,y", "sub16", 3, 0x9c, 6, 6, CHG_NZVC }, 639 { "suba", "(y),a->a", "sub8", 3, 0xa0, 5, 5, CHG_NZVC }, 640 { "cmpa", "(y),a", "sub8", 3, 0xa1, 5, 5, CHG_NZVC }, 641 { "sbca", "(y),a->a", "sbc8", 3, 0xa2, 5, 5, CHG_NZVC }, 642 { "subd", "(y),d->d", "sub16", 3, 0xa3, 7, 7, CHG_NZVC }, 643 { "anda", "(y),a->a", "and8", 3, 0xa4, 5, 5, CLR_V_CHG_NZ }, 644 { "bita", "(y),a", "and8", 3, 0xa5, 5, 5, CLR_V_CHG_NZ }, 645 { "ldaa", "(y)->a", "movtst8", 3, 0xa6, 5, 5, CLR_V_CHG_NZ }, 646 { "staa", "a->(y)", "movtst8", 3, 0xa7, 5, 5, CLR_V_CHG_NZ }, 647 { "eora", "(y),a->a", "eor8", 3, 0xa8, 5, 5, CLR_V_CHG_NZ }, 648 { "adca", "(y),a->a", "adc8", 3, 0xa9, 5, 5, CHG_HNZVC }, 649 { "oraa", "(y),a->a", "or8", 3, 0xaa, 5, 5, CLR_V_CHG_NZ }, 650 { "adda", "(y),a->a", "add8", 3, 0xab, 5, 5, CHG_HNZVC }, 651 { "cmpy", "(y),y", "sub16", 3, 0xac, 7, 7, CHG_NZVC }, 652 { "jsr", "&(y)", "jsr_11_16", 3, 0xad, 6, 6, CHG_NONE }, 653 { "lds", "(y)->sp", "movtst16", 3, 0xae, 6, 6, CLR_V_CHG_NZ }, 654 { "sts", "sp->(y)", "movtst16", 3, 0xaf, 6, 6, CLR_V_CHG_NZ }, 655 { "cmpy", "(),y", "sub16", 4, 0xbc, 7, 7, CHG_NZVC }, 656 { "ldy", "#->y", "movtst16", 4, 0xce, 4, 4, CLR_V_CHG_NZ }, 657 { "ldy", "*->y", "movtst16", 3, 0xde, 5, 5, CLR_V_CHG_NZ }, 658 { "sty", "y->*", "movtst16", 3, 0xdf, 5, 5, CLR_V_CHG_NZ }, 659 { "subb", "(y),b->b", "sub8", 3, 0xe0, 5, 5, CHG_NZVC }, 660 { "cmpb", "(y),b", "sub8", 3, 0xe1, 5, 5, CHG_NZVC }, 661 { "sbcb", "(y),b->b", "sbc8", 3, 0xe2, 5, 5, CHG_NZVC }, 662 { "addd", "(y),d->d", "add16", 3, 0xe3, 7, 7, CHG_NZVC }, 663 { "andb", "(y),b->b", "and8", 3, 0xe4, 5, 5, CLR_V_CHG_NZ }, 664 { "bitb", "(y),b", "and8", 3, 0xe5, 5, 5, CLR_V_CHG_NZ }, 665 { "ldab", "(y)->b", "movtst8", 3, 0xe6, 5, 5, CLR_V_CHG_NZ }, 666 { "stab", "b->(y)", "movtst8", 3, 0xe7, 5, 5, CLR_V_CHG_NZ }, 667 { "eorb", "(y),b->b", "eor8", 3, 0xe8, 5, 5, CLR_V_CHG_NZ }, 668 { "adcb", "(y),b->b", "adc8", 3, 0xe9, 5, 5, CHG_HNZVC }, 669 { "orab", "(y),b->b", "or8", 3, 0xea, 5, 5, CLR_V_CHG_NZ }, 670 { "addb", "(y),b->b", "add8", 3, 0xeb, 5, 5, CHG_HNZVC }, 671 { "ldd", "(y)->d", "movtst16", 3, 0xec, 6, 6, CLR_V_CHG_NZ }, 672 { "std", "d->(y)", "movtst16", 3, 0xed, 6, 6, CLR_V_CHG_NZ }, 673 { "ldy", "(y)->y", "movtst16", 3, 0xee, 6, 6, CLR_V_CHG_NZ }, 674 { "sty", "y->(y)", "movtst16", 3, 0xef, 6, 6, CLR_V_CHG_NZ }, 675 { "ldy", "()->y", "movtst16", 4, 0xfe, 6, 6, CLR_V_CHG_NZ }, 676 { "sty", "y->()", "movtst16", 4, 0xff, 6, 6, CLR_V_CHG_NZ } 677 }; 678 679 /* Page 3 opcodes */ 680 /* 681 * { "dex", "x->x", "dec16", 1, 0x00, 5, _M, CHG_NONE }, 682 * Name -+ +----- Insn CCR changes 683 * Operands ---+ +------------ Max # cycles 684 * Pattern -----------+ +--------------- Min # cycles 685 * Size -----------------+ +-------------------- Opcode 686 */ 687 struct m6811_opcode_def m6811_page3_opcodes[] = { 688 { "cmpd", "#,d", "sub16", 4, 0x83, 5, 5, CHG_NZVC }, 689 { "cmpd", "*,d", "sub16", 3, 0x93, 6, 6, CHG_NZVC }, 690 { "cmpd", "(x),d", "sub16", 3, 0xa3, 7, 7, CHG_NZVC }, 691 { "cmpy", "(x),y", "sub16", 3, 0xac, 7, 7, CHG_NZVC }, 692 { "cmpd", "(),d", "sub16", 4, 0xb3, 7, 7, CHG_NZVC }, 693 { "ldy", "(x)->y", "movtst16", 3, 0xee, 6, 6, CLR_V_CHG_NZ }, 694 { "sty", "y->(x)", "movtst16", 3, 0xef, 6, 6, CLR_V_CHG_NZ } 695 }; 696 697 /* Page 4 opcodes */ 698 /* 699 * { "dex", "x->x", "dec16", 1, 0x00, 5, _M, CHG_NONE }, 700 * Name -+ +----- Insn CCR changes 701 * Operands ---+ +------------ Max # cycles 702 * Pattern -----------+ +--------------- Min # cycles 703 * Size -----------------+ +-------------------- Opcode 704 */ 705 struct m6811_opcode_def m6811_page4_opcodes[] = { 706 { "syscall", "", "syscall", 2, 0x03, 6, 6, CHG_NONE }, 707 { "cmpd", "(y),d", "sub16", 3, 0xa3, 7, 7, CHG_NZVC }, 708 { "cmpx", "(y),x", "sub16", 3, 0xac, 7, 7, CHG_NZVC }, 709 { "ldx", "(y)->x", "movtst16", 3, 0xee, 6, 6, CLR_V_CHG_NZ }, 710 { "stx", "x->(y)", "movtst16", 3, 0xef, 6, 6, CLR_V_CHG_NZ } 711 }; 712 713 /* 68HC12 opcodes */ 714 /* 715 * { "dex", "x->x", "dec16", 1, 0x00, 5, _M, CHG_NONE }, 716 * Name -+ +----- Insn CCR changes 717 * Operands ---+ +------------ Max # cycles 718 * Pattern -----------+ +--------------- Min # cycles 719 * Size -----------------+ +-------------------- Opcode 720 */ 721 struct m6811_opcode_def m6812_page1_opcodes[] = { 722 { "adca", "#,a->a", "adc8", 2, 0x89, 1, 1, CHG_HNZVC }, 723 { "adca", "*,a->a", "adc8", 2, 0x99, 3, 3, CHG_HNZVC }, 724 { "adca", "(),a->a", "adc8", 3, 0xb9, 3, 3, CHG_HNZVC }, 725 { "adca", "[],a->a", "adc8", 2, 0xa9, 3, 3, CHG_HNZVC }, 726 727 { "adcb", "#,b->b", "adc8", 2, 0xc9, 1, 1, CHG_HNZVC }, 728 { "adcb", "*,b->b", "adc8", 3, 0xd9, 3, 3, CHG_HNZVC }, 729 { "adcb", "(),b->b", "adc8", 3, 0xf9, 3, 3, CHG_HNZVC }, 730 { "adcb", "[],b->b", "adc8", 2, 0xe9, 3, 3, CHG_HNZVC }, 731 732 { "adda", "#,a->a", "add8", 2, 0x8b, 1, 1, CHG_HNZVC }, 733 { "adda", "*,a->a", "add8", 3, 0x9b, 3, 3, CHG_HNZVC }, 734 { "adda", "(),a->a", "add8", 3, 0xbb, 3, 3, CHG_HNZVC }, 735 { "adda", "[],a->a", "add8", 2, 0xab, 3, 3, CHG_HNZVC }, 736 737 { "addb", "#,b->b", "add8", 2, 0xcb, 1, 1, CHG_HNZVC }, 738 { "addb", "*,b->b", "add8", 3, 0xdb, 3, 3, CHG_HNZVC }, 739 { "addb", "(),b->b", "add8", 3, 0xfb, 3, 3, CHG_HNZVC }, 740 { "addb", "[],b->b", "add8", 2, 0xeb, 3, 3, CHG_HNZVC }, 741 742 { "addd", "#,d->d", "add16", 3, 0xc3, 2, 2, CHG_NZVC }, 743 { "addd", "*,d->d", "add16", 2, 0xd3, 3, 3, CHG_NZVC }, 744 { "addd", "(),d->d", "add16", 3, 0xf3, 3, 3, CHG_NZVC }, 745 { "addd", "[],d->d", "add16", 2, 0xe3, 3, 3, CHG_NZVC }, 746 747 { "anda", "#,a->a", "and8", 2, 0x84, 1, 1, CLR_V_CHG_NZ }, 748 { "anda", "*,a->a", "and8", 2, 0x94, 3, 3, CLR_V_CHG_NZ }, 749 { "anda", "(),a->a", "and8", 3, 0xb4, 3, 3, CLR_V_CHG_NZ }, 750 { "anda", "[],a->a", "and8", 2, 0xa4, 3, 3, CLR_V_CHG_NZ }, 751 752 { "andb", "#,b->b", "and8", 2, 0xc4, 1, 1, CLR_V_CHG_NZ }, 753 { "andb", "*,b->b", "and8", 2, 0xd4, 3, 3, CLR_V_CHG_NZ }, 754 { "andb", "(),b->b", "and8", 3, 0xf4, 3, 3, CLR_V_CHG_NZ }, 755 { "andb", "[],b->b", "and8", 2, 0xe4, 3, 3, CLR_V_CHG_NZ }, 756 757 { "andcc", "#,ccr->ccr", "and8", 2, 0x10, 1, 1, CHG_ALL }, 758 759 { "asl", "()->()", "lsl8", 3, 0x78, 4, 4, CHG_NZVC }, 760 { "asl", "[]->[]", "lsl8", 2, 0x68, 3, 3, CHG_NZVC }, 761 762 { "asla", "a->a", "lsl8", 1, 0x48, 1, 1, CHG_NZVC }, 763 { "aslb", "b->b", "lsl8", 1, 0x58, 1, 1, CHG_NZVC }, 764 { "asld", "d->d", "lsl16", 1, 0x59, 1, 1, CHG_NZVC }, 765 766 { "asr", "()->()", "asr8", 3, 0x77, 4, 4, CHG_NZVC }, 767 { "asr", "[]->[]", "asr8", 2, 0x67, 3, 3, CHG_NZVC }, 768 769 { "asra", "a->a", "asr8", 1, 0x47, 1, 1, CHG_NZVC }, 770 { "asrb", "b->b", "asr8", 1, 0x57, 1, 1, CHG_NZVC }, 771 772 { "bcc", "r", 0, 2, 0x24, 1, 3, CHG_NONE }, 773 774 { "bclr", "*,#->*", "bclr8", 3, 0x4d, 4, 4, CLR_V_CHG_NZ }, 775 { "bclr", "(),#->()", "bclr8", 4, 0x1d, 4, 4, CLR_V_CHG_NZ }, 776 { "bclr", "[],#->[]", "bclr8", 3, 0x0d, 4, 4, CLR_V_CHG_NZ }, 777 778 { "bcs", "r", 0, 2, 0x25, 1, 3, CHG_NONE }, 779 { "beq", "r", 0, 2, 0x27, 1, 3, CHG_NONE }, 780 { "bge", "r", 0, 2, 0x2c, 1, 3, CHG_NONE }, 781 782 { "bgnd", 0, 0, 1, 0x00, 5, 5, CHG_NONE }, 783 784 { "bgt", "r", 0, 2, 0x2e, 1, 3, CHG_NONE }, 785 { "bhi", "r", 0, 2, 0x22, 1, 3, CHG_NONE }, 786 787 { "bita", "#,a", "and8", 2, 0x85, 1, 1, CLR_V_CHG_NZ }, 788 { "bita", "*,a", "and8", 2, 0x95, 3, 3, CLR_V_CHG_NZ }, 789 { "bita", "(),a", "and8", 3, 0xb5, 3, 3, CLR_V_CHG_NZ }, 790 { "bita", "[],a", "and8", 2, 0xa5, 3, 3, CLR_V_CHG_NZ }, 791 792 { "bitb", "#,b", "and8", 2, 0xc5, 1, 1, CLR_V_CHG_NZ }, 793 { "bitb", "*,b", "and8", 2, 0xd5, 3, 3, CLR_V_CHG_NZ }, 794 { "bitb", "(),b", "and8", 3, 0xf5, 3, 3, CLR_V_CHG_NZ }, 795 { "bitb", "[],b", "and8", 2, 0xe5, 3, 3, CLR_V_CHG_NZ }, 796 797 { "ble", "r", 0, 2, 0x2f, 1, 3, CHG_NONE }, 798 { "bls", "r", 0, 2, 0x23, 1, 3, CHG_NONE }, 799 { "blt", "r", 0, 2, 0x2d, 1, 3, CHG_NONE }, 800 { "bmi", "r", 0, 2, 0x2b, 1, 3, CHG_NONE }, 801 { "bne", "r", 0, 2, 0x26, 1, 3, CHG_NONE }, 802 { "bpl", "r", 0, 2, 0x2a, 1, 3, CHG_NONE }, 803 { "bra", "r", 0, 2, 0x20, 1, 3, CHG_NONE }, 804 805 { "brclr", "*,#,r", "brclr8", 4, 0x4f, 4, 4, CHG_NONE }, 806 { "brclr", "(),#,r", "brclr8", 5, 0x1f, 5, 5, CHG_NONE }, 807 { "brclr", "[],#,r", "brclr8", 4, 0x0f, 4, 4, CHG_NONE }, 808 809 { "brn", "r", "nop", 2, 0x21, 1, 3, CHG_NONE }, 810 811 { "brset", "*,#,r", "brset8", 4, 0x4e, 4, 4, CHG_NONE }, 812 { "brset", "(),#,r", "brset8", 5, 0x1e, 5, 5, CHG_NONE }, 813 { "brset", "[],#,r", "brset8", 4, 0x0e, 4, 4, CHG_NONE }, 814 815 { "bset", "*,#->*", "or8", 3, 0x4c, 4, 4, CLR_V_CHG_NZ }, 816 { "bset", "(),#->()", "or8", 4, 0x1c, 4, 4, CLR_V_CHG_NZ }, 817 { "bset", "[],#->[]", "or8", 3, 0x0c, 4, 4, CLR_V_CHG_NZ }, 818 819 { "bsr", "r", "jsr_12_16", 2, 0x07, 4, 4, CHG_NONE }, 820 821 { "bvc", "r", 0, 2, 0x28, 1, 3, CHG_NONE }, 822 { "bvs", "r", 0, 2, 0x29, 1, 3, CHG_NONE }, 823 824 { "call", "", "call8", 4, 0x4a, 8, 8, CHG_NONE }, 825 { "call", "", "call_ind",2, 0x4b, 8, 8, CHG_NONE }, 826 827 { "clr", "->()", "clr8", 3, 0x79, 3, 3, SET_Z_CLR_NVC }, 828 { "clr", "->[]", "clr8", 2, 0x69, 2, 2, SET_Z_CLR_NVC }, 829 830 { "clra", "->a", "clr8", 1, 0x87, 1, 1, SET_Z_CLR_NVC }, 831 { "clrb", "->b", "clr8", 1, 0xc7, 1, 1, SET_Z_CLR_NVC }, 832 833 { "cpa", "#,a", "sub8", 2, 0x81, 1, 1, CHG_NZVC }, 834 { "cpa", "*,a", "sub8", 2, 0x91, 3, 3, CHG_NZVC }, 835 { "cpa", "(),a", "sub8", 3, 0xb1, 3, 3, CHG_NZVC }, 836 { "cpa", "[],a", "sub8", 2, 0xa1, 3, 3, CHG_NZVC }, 837 838 { "cpb", "#,b", "sub8", 2, 0xc1, 1, 1, CHG_NZVC }, 839 { "cpb", "*,b", "sub8", 2, 0xd1, 3, 3, CHG_NZVC }, 840 { "cpb", "(),b", "sub8", 3, 0xf1, 3, 3, CHG_NZVC }, 841 { "cpb", "[],b", "sub8", 2, 0xe1, 3, 3, CHG_NZVC }, 842 843 { "com", "()->()", "com8", 3, 0x71, 4, 4, SET_C_CLR_V_CHG_NZ }, 844 { "com", "[]->[]", "com8", 2, 0x61, 3, 3, SET_C_CLR_V_CHG_NZ }, 845 846 { "coma", "a->a", "com8", 1, 0x41, 1, 1, SET_C_CLR_V_CHG_NZ }, 847 { "comb", "b->b", "com8", 1, 0x51, 1, 1, SET_C_CLR_V_CHG_NZ }, 848 849 { "cpd", "#,d", "sub16", 3, 0x8c, 2, 2, CHG_NZVC }, 850 { "cpd", "*,d", "sub16", 2, 0x9c, 3, 3, CHG_NZVC }, 851 { "cpd", "(),d", "sub16", 3, 0xbc, 3, 3, CHG_NZVC }, 852 { "cpd", "[],d", "sub16", 2, 0xac, 3, 3, CHG_NZVC }, 853 854 { "cps", "#,sp", "sub16", 3, 0x8f, 2, 2, CHG_NZVC }, 855 { "cps", "*,sp", "sub16", 2, 0x9f, 3, 3, CHG_NZVC }, 856 { "cps", "(),sp", "sub16", 3, 0xbf, 3, 3, CHG_NZVC }, 857 { "cps", "[],sp", "sub16", 2, 0xaf, 3, 3, CHG_NZVC }, 858 859 { "cpx", "#,x", "sub16", 3, 0x8e, 2, 2, CHG_NZVC }, 860 { "cpx", "*,x", "sub16", 2, 0x9e, 3, 3, CHG_NZVC }, 861 { "cpx", "(),x", "sub16", 3, 0xbe, 3, 3, CHG_NZVC }, 862 { "cpx", "[],x", "sub16", 2, 0xae, 3, 3, CHG_NZVC }, 863 864 { "cpy", "#,y", "sub16", 3, 0x8d, 2, 2, CHG_NZVC }, 865 { "cpy", "*,y", "sub16", 2, 0x9d, 3, 3, CHG_NZVC }, 866 { "cpy", "(),y", "sub16", 3, 0xbd, 3, 3, CHG_NZVC }, 867 { "cpy", "[],y", "sub16", 2, 0xad, 3, 3, CHG_NZVC }, 868 869 /* dbeq, dbne, ibeq, ibne, tbeq, tbne */ 870 { "dbeq", 0, "dbcc8", 3, 0x04, 3, 3, CHG_NONE }, 871 872 { "dec", "()->()", "dec8", 3, 0x73, 4, 4, CHG_NZV }, 873 { "dec", "[]->[]", "dec8", 2, 0x63, 3, 3, CHG_NZV }, 874 875 { "deca", "a->a", "dec8", 1, 0x43, 1, 1, CHG_NZV }, 876 { "decb", "b->b", "dec8", 1, 0x53, 1, 1, CHG_NZV }, 877 878 { "dex", "x->x", "dec16", 1, 0x09, 1, 1, CHG_Z }, 879 { "dey", "y->y", "dec16", 1, 0x03, 1, 1, CHG_Z }, 880 881 { "ediv", 0, 0, 1, 0x11, 11, 11, CHG_NZVC }, 882 { "emul", 0, 0, 1, 0x13, 3, 3, CHG_NZC }, 883 884 { "eora", "#,a->a", "eor8", 2, 0x88, 1, 1, CLR_V_CHG_NZ }, 885 { "eora", "*,a->a", "eor8", 2, 0x98, 3, 3, CLR_V_CHG_NZ }, 886 { "eora", "(),a->a", "eor8", 3, 0xb8, 3, 3, CLR_V_CHG_NZ }, 887 { "eora", "[],a->a", "eor8", 2, 0xa8, 3, 3, CLR_V_CHG_NZ }, 888 889 { "eorb", "#,b->b", "eor8", 2, 0xc8, 1, 1, CLR_V_CHG_NZ }, 890 { "eorb", "*,b->b", "eor8", 2, 0xd8, 3, 3, CLR_V_CHG_NZ }, 891 { "eorb", "(),b->b", "eor8", 3, 0xf8, 3, 3, CLR_V_CHG_NZ }, 892 { "eorb", "[],b->b", "eor8", 2, 0xe8, 3, 3, CLR_V_CHG_NZ }, 893 894 /* exg, sex, tfr */ 895 { "exg", "#", "exg8", 2, 0xb7, 1, 1, CHG_NONE }, 896 897 { "inc", "()->()", "inc8", 3, 0x72, 4, 4, CHG_NZV }, 898 { "inc", "[]->[]", "inc8", 2, 0x62, 3, 3, CHG_NZV }, 899 900 { "inca", "a->a", "inc8", 1, 0x42, 1, 1, CHG_NZV }, 901 { "incb", "b->b", "inc8", 1, 0x52, 1, 1, CHG_NZV }, 902 903 { "inx", "x->x", "inc16", 1, 0x08, 1, 1, CHG_Z }, 904 { "iny", "y->y", "inc16", 1, 0x02, 1, 1, CHG_Z }, 905 906 { "jmp", "&()", "bra", 3, 0x06, 3, 3, CHG_NONE }, 907 { "jmp", "&[]", "bra", 2, 0x05, 3, 3, CHG_NONE }, 908 909 { "jsr", "*", "jsr_12_16", 2, 0x17, 4, 4, CHG_NONE }, 910 { "jsr", "&()", "jsr_12_16", 3, 0x16, 4, 4, CHG_NONE }, 911 { "jsr", "&[]", "jsr_12_16", 2, 0x15, 4, 4, CHG_NONE }, 912 913 { "ldaa", "#->a", "movtst8", 2, 0x86, 1, 1, CLR_V_CHG_NZ }, 914 { "ldaa", "*->a", "movtst8", 2, 0x96, 3, 3, CLR_V_CHG_NZ }, 915 { "ldaa", "()->a", "movtst8", 3, 0xb6, 3, 3, CLR_V_CHG_NZ }, 916 { "ldaa", "[]->a", "movtst8", 2, 0xa6, 3, 3, CLR_V_CHG_NZ }, 917 918 { "ldab", "#->b", "movtst8", 2, 0xc6, 1, 1, CLR_V_CHG_NZ }, 919 { "ldab", "*->b", "movtst8", 2, 0xd6, 3, 3, CLR_V_CHG_NZ }, 920 { "ldab", "()->b", "movtst8", 3, 0xf6, 3, 3, CLR_V_CHG_NZ }, 921 { "ldab", "[]->b", "movtst8", 2, 0xe6, 3, 3, CLR_V_CHG_NZ }, 922 923 { "ldd", "#->d", "movtst16", 3, 0xcc, 2, 2, CLR_V_CHG_NZ }, 924 { "ldd", "*->d", "movtst16", 2, 0xdc, 3, 3, CLR_V_CHG_NZ }, 925 { "ldd", "()->d", "movtst16", 3, 0xfc, 3, 3, CLR_V_CHG_NZ }, 926 { "ldd", "[]->d", "movtst16", 2, 0xec, 3, 3, CLR_V_CHG_NZ }, 927 928 { "lds", "#->sp", "movtst16", 3, 0xcf, 2, 2, CLR_V_CHG_NZ }, 929 { "lds", "*->sp", "movtst16", 2, 0xdf, 3, 3, CLR_V_CHG_NZ }, 930 { "lds", "()->sp", "movtst16", 3, 0xff, 3, 3, CLR_V_CHG_NZ }, 931 { "lds", "[]->sp", "movtst16", 2, 0xef, 3, 3, CLR_V_CHG_NZ }, 932 933 { "ldx", "#->x", "movtst16", 3, 0xce, 2, 2, CLR_V_CHG_NZ }, 934 { "ldx", "*->x", "movtst16", 2, 0xde, 3, 3, CLR_V_CHG_NZ }, 935 { "ldx", "()->x", "movtst16", 3, 0xfe, 3, 3, CLR_V_CHG_NZ }, 936 { "ldx", "[]->x", "movtst16", 2, 0xee, 3, 3, CLR_V_CHG_NZ }, 937 938 { "ldy", "#->y", "movtst16", 3, 0xcd, 2, 2, CLR_V_CHG_NZ }, 939 { "ldy", "*->y", "movtst16", 2, 0xdd, 3, 3, CLR_V_CHG_NZ }, 940 { "ldy", "()->y", "movtst16", 3, 0xfd, 3, 3, CLR_V_CHG_NZ }, 941 { "ldy", "[]->y", "movtst16", 2, 0xed, 3, 3, CLR_V_CHG_NZ }, 942 943 { "leas", "&[]->sp", "lea16", 2, 0x1b, 2, 2, CHG_NONE }, 944 { "leax", "&[]->x", "lea16", 2, 0x1a, 2, 2, CHG_NONE }, 945 { "leay", "&[]->y", "lea16", 2, 0x19, 2, 2, CHG_NONE }, 946 947 { "lsr", "()->()", "lsr8", 3, 0x74, 4, 4, CLR_N_CHG_ZVC }, 948 { "lsr", "[]->[]", "lsr8", 2, 0x64, 3, 3, CLR_N_CHG_ZVC }, 949 950 { "lsra", "a->a", "lsr8", 1, 0x44, 1, 1, CLR_N_CHG_ZVC }, 951 { "lsrb", "b->b", "lsr8", 1, 0x54, 1, 1, CLR_N_CHG_ZVC }, 952 { "lsrd", "d->d", "lsr16", 1, 0x49, 1, 1, CLR_N_CHG_ZVC }, 953 954 { "mem", 0, 0, 1, 0x01, 5, 5, CHG_HNZVC }, 955 956 { "mul", "b,a->d", "mul16", 1, 0x12, 3, 3, CHG_C }, 957 958 { "neg", "()->()", "neg8", 3, 0x70, 4, 4, CHG_NZVC }, 959 { "neg", "[]->[]", "neg8", 2, 0x60, 3, 3, CHG_NZVC }, 960 961 { "nega", "a->a", "neg8", 1, 0x40, 1, 1, CHG_NZVC }, 962 { "negb", "b->b", "neg8", 1, 0x50, 1, 1, CHG_NZVC }, 963 964 { "nop", "", "nop", 1, 0xa7, 1, 1, CHG_NONE }, 965 966 { "oraa", "#,a->a", "or8", 2, 0x8a, 1, 1, CLR_V_CHG_NZ }, 967 { "oraa", "*,a->a", "or8", 2, 0x9a, 3, 3, CLR_V_CHG_NZ }, 968 { "oraa", "(),a->a", "or8", 3, 0xba, 3, 3, CLR_V_CHG_NZ }, 969 { "oraa", "[],a->a", "or8", 2, 0xaa, 3, 3, CLR_V_CHG_NZ }, 970 971 { "orab", "#,b->b", "or8", 2, 0xca, 1, 1, CLR_V_CHG_NZ }, 972 { "orab", "*,b->b", "or8", 2, 0xda, 3, 3, CLR_V_CHG_NZ }, 973 { "orab", "(),b->b", "or8", 3, 0xfa, 3, 3, CLR_V_CHG_NZ }, 974 { "orab", "[],b->b", "or8", 2, 0xea, 3, 3, CLR_V_CHG_NZ }, 975 976 { "orcc", "#,ccr->ccr", "or8", 2, 0x14, 1, 1, CHG_ALL }, 977 978 { "page2", 0, "page2", 1, 0x18, 0, 0, CHG_NONE }, 979 980 { "psha", "a->(sp)", "mov8", 1, 0x36, 2, 2, CHG_NONE }, 981 { "pshb", "b->(sp)", "mov8", 1, 0x37, 2, 2, CHG_NONE }, 982 { "pshc", "ccr->(sp)", "mov8", 1, 0x39, 2, 2, CHG_NONE }, 983 { "pshd", "d->(sp)", "mov16", 1, 0x3b, 2, 2, CHG_NONE }, 984 { "pshx", "x->(sp)", "mov16", 1, 0x34, 2, 2, CHG_NONE }, 985 { "pshy", "y->(sp)", "mov16", 1, 0x35, 2, 2, CHG_NONE }, 986 987 { "pula", "(sp)->a", "mov8", 1, 0x32, 3, 3, CHG_NONE }, 988 { "pulb", "(sp)->b", "mov8", 1, 0x33, 3, 3, CHG_NONE }, 989 { "pulc", "(sp)->ccr", "mov8", 1, 0x38, 3, 3, CHG_ALL }, 990 { "puld", "(sp)->d", "mov16", 1, 0x3a, 3, 3, CHG_NONE }, 991 { "pulx", "(sp)->x", "mov16", 1, 0x30, 3, 3, CHG_NONE }, 992 { "puly", "(sp)->y", "mov16", 1, 0x31, 3, 3, CHG_NONE }, 993 994 { "rol", "()->()", "rol8", 3, 0x75, 4, 4, CHG_NZVC }, 995 { "rol", "[]->[]", "rol8", 2, 0x65, 3, 3, CHG_NZVC }, 996 997 { "rola", "a->a", "rol8", 1, 0x45, 1, 1, CHG_NZVC }, 998 { "rolb", "b->b", "rol8", 1, 0x55, 1, 1, CHG_NZVC }, 999 1000 { "ror", "()->()", "ror8", 3, 0x76, 4, 4, CHG_NZVC }, 1001 { "ror", "[]->[]", "ror8", 2, 0x66, 3, 3, CHG_NZVC }, 1002 1003 { "rora", "a->a", "ror8", 1, 0x46, 1, 1, CHG_NZVC }, 1004 { "rorb", "b->b", "ror8", 1, 0x56, 1, 1, CHG_NZVC }, 1005 1006 { "rtc", 0, 0, 1, 0x0a, 6, 6, CHG_NONE }, 1007 { "rti", 0, "rti12", 1, 0x0b, 8, 10, CHG_ALL}, 1008 { "rts", 0, "rts12", 1, 0x3d, 5, 5, CHG_NONE }, 1009 1010 { "sbca", "#,a->a", "sbc8", 2, 0x82, 1, 1, CHG_NZVC }, 1011 { "sbca", "*,a->a", "sbc8", 2, 0x92, 3, 3, CHG_NZVC }, 1012 { "sbca", "(),a->a", "sbc8", 3, 0xb2, 3, 3, CHG_NZVC }, 1013 { "sbca", "[],a->a", "sbc8", 2, 0xa2, 3, 3, CHG_NZVC }, 1014 1015 { "sbcb", "#,b->b", "sbc8", 2, 0xc2, 1, 1, CHG_NZVC }, 1016 { "sbcb", "*,b->b", "sbc8", 2, 0xd2, 3, 3, CHG_NZVC }, 1017 { "sbcb", "(),b->b", "sbc8", 3, 0xf2, 3, 3, CHG_NZVC }, 1018 { "sbcb", "[],b->b", "sbc8", 2, 0xe2, 3, 3, CHG_NZVC }, 1019 1020 { "staa", "a->*", "movtst8", 2, 0x5a, 2, 2, CLR_V_CHG_NZ }, 1021 { "staa", "a->()", "movtst8", 3, 0x7a, 3, 3, CLR_V_CHG_NZ }, 1022 { "staa", "a->[]", "movtst8", 2, 0x6a, 2, 2, CLR_V_CHG_NZ }, 1023 1024 { "stab", "b->*", "movtst8", 2, 0x5b, 2, 2, CLR_V_CHG_NZ }, 1025 { "stab", "b->()", "movtst8", 3, 0x7b, 3, 3, CLR_V_CHG_NZ }, 1026 { "stab", "b->[]", "movtst8", 2, 0x6b, 2, 2, CLR_V_CHG_NZ }, 1027 1028 { "std", "d->*", "movtst16", 2, 0x5c, 2, 2, CLR_V_CHG_NZ }, 1029 { "std", "d->()", "movtst16", 3, 0x7c, 3, 3, CLR_V_CHG_NZ }, 1030 { "std", "d->[]", "movtst16", 2, 0x6c, 2, 2, CLR_V_CHG_NZ }, 1031 1032 { "sts", "sp->*", "movtst16", 2, 0x5f, 2, 2, CLR_V_CHG_NZ }, 1033 { "sts", "sp->()", "movtst16", 3, 0x7f, 3, 3, CLR_V_CHG_NZ }, 1034 { "sts", "sp->[]", "movtst16", 2, 0x6f, 2, 2, CLR_V_CHG_NZ }, 1035 1036 { "stx", "x->*", "movtst16", 2, 0x5e, 2, 2, CLR_V_CHG_NZ }, 1037 { "stx", "x->()", "movtst16", 3, 0x7e, 3, 3, CLR_V_CHG_NZ }, 1038 { "stx", "x->[]", "movtst16", 2, 0x6e, 2, 2, CLR_V_CHG_NZ }, 1039 1040 { "sty", "y->*", "movtst16", 2, 0x5d, 2, 2, CLR_V_CHG_NZ }, 1041 { "sty", "y->()", "movtst16", 3, 0x7d, 3, 3, CLR_V_CHG_NZ }, 1042 { "sty", "y->[]", "movtst16", 2, 0x6d, 2, 2, CLR_V_CHG_NZ }, 1043 1044 { "suba", "#,a->a", "sub8", 2, 0x80, 1, 1, CHG_NZVC }, 1045 { "suba", "*,a->a", "sub8", 2, 0x90, 3, 3, CHG_NZVC }, 1046 { "suba", "(),a->a", "sub8", 3, 0xb0, 3, 3, CHG_NZVC }, 1047 { "suba", "[],a->a", "sub8", 2, 0xa0, 3, 3, CHG_NZVC }, 1048 1049 { "subb", "#,b->b", "sub8", 2, 0xc0, 1, 1, CHG_NZVC }, 1050 { "subb", "*,b->b", "sub8", 2, 0xd0, 3, 3, CHG_NZVC }, 1051 { "subb", "(),b->b", "sub8", 3, 0xf0, 3, 3, CHG_NZVC }, 1052 { "subb", "[],b->b", "sub8", 2, 0xe0, 3, 3, CHG_NZVC }, 1053 1054 { "subd", "#,d->d", "sub16", 3, 0x83, 2, 2, CHG_NZVC }, 1055 { "subd", "*,d->d", "sub16", 2, 0x93, 3, 3, CHG_NZVC }, 1056 { "subd", "(),d->d", "sub16", 3, 0xb3, 3, 3, CHG_NZVC }, 1057 { "subd", "[],d->d", "sub16", 2, 0xa3, 3, 3, CHG_NZVC }, 1058 1059 { "swi", 0, 0, 1, 0x3f, 9, 9, CHG_NONE }, 1060 1061 { "tst", "()", "tst8", 3, 0xf7, 3, 3, CLR_VC_CHG_NZ }, 1062 { "tst", "[]", "tst8", 2, 0xe7, 3, 3, CLR_VC_CHG_NZ }, 1063 1064 { "tsta", "a", "tst8", 1, 0x97, 1, 1, CLR_VC_CHG_NZ }, 1065 { "tstb", "b", "tst8", 1, 0xd7, 1, 1, CLR_VC_CHG_NZ }, 1066 1067 { "wai", 0, 0, 1, 0x3e, 8, _M, CHG_NONE } 1068 }; 1069 1070 struct m6811_opcode_def m6812_page2_opcodes[] = { 1071 { "cba", "b,a", "sub8", 2, 0x17, 2, 2, CHG_NZVC }, 1072 1073 /* After 'daa', the Z flag is undefined. Mark it as changed. */ 1074 { "daa", 0, "daa8", 2, 0x07, 3, 3, CHG_NZVC }, 1075 1076 { "edivs", 0, 0, 2, 0x14, 12, 12, CHG_NZVC }, 1077 { "emacs", 0, 0, 2, 0x12, 13, 13, CHG_NZVC }, 1078 1079 { "emaxd", "[],d->d", "max16", 3, 0x1a, 4, 4, CHG_NZVC }, 1080 { "emaxm", "[],d->[]", "max16", 3, 0x1e, 4, 4, CHG_NZVC }, 1081 { "emind", "[],d->d", "min16", 3, 0x1b, 4, 4, CHG_NZVC }, 1082 { "eminm", "[],d->[]", "min16", 3, 0x1f, 4, 4, CHG_NZVC }, 1083 1084 { "emuls", 0, 0, 2, 0x13, 3, 3, CHG_NZC }, 1085 { "etbl", "[]", "tbl16", 3, 0x3f, 10, 10, CHG_NZC }, 1086 { "fdiv", "x,d->x", "fdiv16", 2, 0x11, 12, 12, CHG_ZVC }, 1087 { "idiv", "x,d->x", "idiv16", 2, 0x10, 12, 12, CLR_V_CHG_ZC }, 1088 { "idivs", 0, 0, 2, 0x15, 12, 12, CHG_NZVC }, 1089 1090 { "lbcc", "R", "bcc", 4, 0x24, 3, 4, CHG_NONE }, 1091 { "lbcs", "R", "bcs", 4, 0x25, 3, 4, CHG_NONE }, 1092 { "lbeq", "R", "beq", 4, 0x27, 3, 4, CHG_NONE }, 1093 { "lbge", "R", "bge", 4, 0x2c, 3, 4, CHG_NONE }, 1094 { "lbgt", "R", "bgt", 4, 0x2e, 3, 4, CHG_NONE }, 1095 { "lbhi", "R", "bhi", 4, 0x22, 3, 4, CHG_NONE }, 1096 { "lble", "R", "ble", 4, 0x2f, 3, 4, CHG_NONE }, 1097 { "lbls", "R", "bls", 4, 0x23, 3, 4, CHG_NONE }, 1098 { "lblt", "R", "blt", 4, 0x2d, 3, 4, CHG_NONE }, 1099 { "lbmi", "R", "bmi", 4, 0x2b, 3, 4, CHG_NONE }, 1100 { "lbne", "R", "bne", 4, 0x26, 3, 4, CHG_NONE }, 1101 { "lbpl", "R", "bpl", 4, 0x2a, 3, 4, CHG_NONE }, 1102 { "lbra", "R", "bra", 4, 0x20, 4, 4, CHG_NONE }, 1103 { "lbrn", "R", "nop", 4, 0x21, 3, 3, CHG_NONE }, 1104 { "lbvc", "R", "bvc", 4, 0x28, 3, 4, CHG_NONE }, 1105 { "lbvs", "R", "bvs", 4, 0x29, 3, 4, CHG_NONE }, 1106 1107 { "maxa", "[],a->a", "max8", 3, 0x18, 4, 4, CHG_NZVC }, 1108 { "maxm", "[],a->[]", "max8", 3, 0x1c, 4, 4, CHG_NZVC }, 1109 { "mina", "[],a->a", "min8", 3, 0x19, 4, 4, CHG_NZVC }, 1110 { "minm", "[],a->[]", "min8", 3, 0x1d, 4, 4, CHG_NZVC }, 1111 1112 { "movb", 0, "move8", 5, 0x0b, 4, 4, CHG_NONE }, 1113 { "movb", 0, "move8", 4, 0x08, 4, 4, CHG_NONE }, 1114 { "movb", 0, "move8", 6, 0x0c, 6, 6, CHG_NONE }, 1115 { "movb", 0, "move8", 5, 0x09, 5, 5, CHG_NONE }, 1116 { "movb", 0, "move8", 5, 0x0d, 5, 5, CHG_NONE }, 1117 { "movb", 0, "move8", 4, 0x0a, 5, 5, CHG_NONE }, 1118 1119 { "movw", 0, "move16", 6, 0x03, 5, 5, CHG_NONE }, 1120 { "movw", 0, "move16", 5, 0x00, 4, 4, CHG_NONE }, 1121 { "movw", 0, "move16", 6, 0x04, 6, 6, CHG_NONE }, 1122 { "movw", 0, "move16", 5, 0x01, 5, 5, CHG_NONE }, 1123 { "movw", 0, "move16", 5, 0x05, 5, 5, CHG_NONE }, 1124 { "movw", 0, "move16", 4, 0x02, 5, 5, CHG_NONE }, 1125 1126 { "rev", 0, 0, 2, 0x3a, _M, _M, CHG_HNZVC }, 1127 { "revw", 0, 0, 2, 0x3b, _M, _M, CHG_HNZVC }, 1128 { "sba", "b,a->a", "sub8", 2, 0x16, 2, 2, CHG_NZVC }, 1129 1130 { "stop", 0, 0, 2, 0x3e, 2, 9, CHG_NONE }, 1131 1132 { "tab", "a->b", "movtst8", 2, 0x0e, 2, 2, CLR_V_CHG_NZ }, 1133 { "tba", "b->a", "movtst8", 2, 0x0f, 2, 2, CLR_V_CHG_NZ }, 1134 1135 { "wav", 0, 0, 2, 0x3c, 8, _M, SET_Z_CHG_HNVC } 1136 }; 1137 1138 void fatal_error (const struct m6811_opcode_def*, const char*, ...); 1139 void print (FILE*, int, const char*,...); 1140 int gen_fetch_operands (FILE*, int, const struct m6811_opcode_def*, 1141 const char*); 1142 void gen_save_result (FILE*, int, const struct m6811_opcode_def*, 1143 int, const char*); 1144 const struct m6811_opcode_pattern* 1145 find_opcode_pattern (const struct m6811_opcode_def*); 1146 void gen_interp (FILE*, int, const struct m6811_opcode_def*); 1147 void gen_interpreter_for_table (FILE*, int, 1148 const struct m6811_opcode_def*, 1149 int, const char*); 1150 void gen_interpreter (FILE*); 1151 1152 1153 static int indent_level = 2; 1154 static int current_insn_size = 0; 1155 1156 /* Fatal error message and exit. This method is called when an inconsistency 1157 is detected in the generation table. */ 1158 void 1159 fatal_error (const struct m6811_opcode_def *opcode, const char *msg, ...) 1160 { 1161 va_list argp; 1162 1163 fprintf (stderr, "Fatal error: "); 1164 va_start (argp, msg); 1165 vfprintf (stderr, msg, argp); 1166 va_end (argp); 1167 fprintf (stderr, "\n"); 1168 if (opcode) 1169 { 1170 fprintf (stderr, "Opcode: 0x%02x %s %s\n", 1171 opcode->insn_code, 1172 opcode->name ? opcode->name : "(null)", 1173 opcode->operands ? opcode->operands : "(null)"); 1174 } 1175 exit (1); 1176 } 1177 1178 1179 /* Format and pretty print for the code generation. (printf like format). */ 1180 void 1181 print (FILE *fp, int col, const char *msg, ...) 1182 { 1183 va_list argp; 1184 char buf[1024]; 1185 int cur_col = -1; 1186 int i; 1187 1188 /* Format in a buffer. */ 1189 va_start (argp, msg); 1190 vsprintf (buf, msg, argp); 1191 va_end (argp); 1192 1193 /* Basic pretty print: 1194 - Every line is indented at column 'col', 1195 - Indentation is updated when '{' and '}' are found, 1196 - Indentation is incremented by the special character '@' (not displayed). 1197 - New lines inserted automatically after ';' */ 1198 for (i = 0; buf[i]; i++) 1199 { 1200 if (buf[i] == '{') 1201 col += indent_level; 1202 else if (buf[i] == '}') 1203 col -= indent_level; 1204 else if (buf[i] == '@') 1205 { 1206 col += indent_level; 1207 continue; 1208 } 1209 if (cur_col == -1 && buf[i] != ' ' && buf[i] != '\t' && buf[i] != '\n') 1210 { 1211 cur_col = 0; 1212 while (cur_col < col) 1213 { 1214 fputc (' ', fp); 1215 cur_col++; 1216 } 1217 } 1218 if (buf[i] == '}') 1219 col -= indent_level; 1220 else if (buf[i] == '{') 1221 col += indent_level; 1222 else if (buf[i] == '\n') 1223 cur_col = -1; 1224 1225 if (cur_col != -1 || buf[i] == '\n') 1226 fputc (buf[i], fp); 1227 1228 if (buf[i] == ';') 1229 { 1230 fputc ('\n', fp); 1231 cur_col = -1; 1232 } 1233 } 1234 } 1235 1236 1237 /* Generate the code to obtain the operands before execution of the 1238 instruction. Operands are copied in local variables. This allows to 1239 have the same instruction pattern and different operand formats. 1240 There is a maximum of 3 variables: 1241 1242 8-bits 16-bits 1243 1st operand: src8 src16 1244 2nd operand: dst8 dst16 1245 alt operand: addr addr 1246 1247 The operand string is interpreted as follows: 1248 1249 a Copy A register in the local 8-bits variable. 1250 b " B " 1251 ccr " ccr " 1252 d " D " " " 16-bits variable. 1253 x " X " 1254 y " Y " 1255 sp " SP " 1256 pc " PC " 1257 * 68HC11 page0 memory pointer. 1258 Get 8-bits page0 offset from program, set up 'addr' local 1259 variable to refer to the location in page0. 1260 Copy the 8/16-bits value pointed to by 'addr' in a 8/16-bits variable. 1261 (x) 68HC11 indirect access with X register. 1262 Get 8-bits unsigned offset from program, set up 'addr' = X + offset. 1263 Copy the 8/16-bits value pointed to by 'addr' in a 8/16-bits variable. 1264 (y) Same as (x) with Y register. 1265 () 68HC11 extended address mode (global variable). 1266 Get 16-bits address from program and set 'addr'. 1267 Copy the 8/16-bits value pointed to by 'addr' in a 8/16-bits variable. 1268 [] 68HC12 indexed addressing mode 1269 (sp) Pop 1270 Pop a 8/16-bits value from stack and set in a 8/16-bits variable. 1271 r Relative branch 1272 Get 8-bits relative branch, compute absolute address and set 'addr' 1273 # 68HC11 immediate value 1274 Get a 8/16-bits value from program and set a 8/16-bits variable. 1275 &(x) 1276 &(y) 1277 &() Similar to (x), (y) and () except that we don't read the 1278 value pointed to by 'addr' (ie, only 'addr' is setup). Used by jmp/jsr. 1279 &[] Similar to [] but don't read the value pointed to by the address. 1280 , Operand separator. 1281 - End of input operands. 1282 1283 Example: 1284 (x),a->a addr = x + (uint16) (fetch8 (cpu)); 1285 src8 = a 1286 *,#,r addr = (uint16) (fetch8 (cpu)) <- Temporary 'addr' 1287 src8 = read_mem8 (cpu, addr) 1288 dst8 = fetch8 (cpu) 1289 addr = fetch_relbranch (cpu) <- Final 'addr' 1290 1291 Returns 1 if the 'addr' operand is set, 0 otherwise. */ 1292 int 1293 gen_fetch_operands (FILE *fp, int col, 1294 const struct m6811_opcode_def *opcode, 1295 const char *operand_size) 1296 { 1297 static char *vars[2] = { 1298 "src", 1299 "dst" 1300 }; 1301 char c; 1302 int addr_set = 0; 1303 int cur_var = 0; 1304 const char *operands = opcode->operands; 1305 1306 if (operands == 0) 1307 operands = ""; 1308 1309 while ((c = *operands++) != 0) 1310 { 1311 switch (c) 1312 { 1313 case 'a': 1314 if (cur_var >= 2) 1315 fatal_error (opcode, "Too many locals"); 1316 1317 print (fp, col, "%s8 = cpu_get_a (cpu);", vars[cur_var]); 1318 break; 1319 1320 case 'b': 1321 if (cur_var >= 2) 1322 fatal_error (opcode, "Too many locals"); 1323 1324 print (fp, col, "%s8 = cpu_get_b (cpu);", vars[cur_var]); 1325 break; 1326 1327 case 'd': 1328 if (cur_var >= 2) 1329 fatal_error (opcode, "Too many locals"); 1330 1331 print (fp, col, "%s16 = cpu_get_d (cpu);", vars[cur_var]); 1332 break; 1333 1334 case 'x': 1335 if (cur_var >= 2) 1336 fatal_error (opcode, "Too many locals"); 1337 1338 print (fp, col, "%s16 = cpu_get_x (cpu);", vars[cur_var]); 1339 break; 1340 1341 case 'y': 1342 if (cur_var >= 2) 1343 fatal_error (opcode, "Too many locals"); 1344 1345 print (fp, col, "%s16 = cpu_get_y (cpu);", vars[cur_var]); 1346 break; 1347 1348 case '*': 1349 if (cur_var >= 2) 1350 fatal_error (opcode, "Too many locals"); 1351 1352 if (addr_set) 1353 fatal_error (opcode, "Wrong use of '*', 'addr' already used"); 1354 1355 addr_set = 1; 1356 current_insn_size += 1; 1357 print (fp, col, "addr = (uint16) cpu_fetch8 (cpu);"); 1358 print (fp, col, "%s%s = memory_read%s (cpu, addr);", 1359 vars[cur_var], operand_size, operand_size); 1360 break; 1361 1362 case '&': 1363 if (addr_set) 1364 fatal_error (opcode, "Wrong use of '&', 'addr' already used"); 1365 1366 addr_set = 1; 1367 if (strncmp (operands, "(x)", 3) == 0) 1368 { 1369 current_insn_size += 1; 1370 print (fp, col, "addr = cpu_get_x (cpu) + (uint16) cpu_fetch8 (cpu);"); 1371 operands += 3; 1372 } 1373 else if (strncmp (operands, "(y)", 3) == 0) 1374 { 1375 current_insn_size += 1; 1376 print (fp, col, "addr = cpu_get_y (cpu) + (uint16) cpu_fetch8 (cpu);"); 1377 operands += 3; 1378 } 1379 else if (strncmp (operands, "()", 2) == 0) 1380 { 1381 current_insn_size += 2; 1382 print (fp, col, "addr = cpu_fetch16 (cpu);"); 1383 operands += 2; 1384 } 1385 else if (strncmp (operands, "[]", 2) == 0) 1386 { 1387 current_insn_size += 1; 1388 print (fp, col, "addr = cpu_get_indexed_operand_addr (cpu, 0);"); 1389 operands += 2; 1390 } 1391 else 1392 { 1393 fatal_error (opcode, "Unknown operand"); 1394 } 1395 break; 1396 1397 case '(': 1398 if (cur_var >= 2) 1399 fatal_error (opcode, "Too many locals"); 1400 1401 if (addr_set) 1402 fatal_error (opcode, "Wrong use of '(', 'addr' already used"); 1403 1404 if (strncmp (operands, "x)", 2) == 0) 1405 { 1406 addr_set = 1; 1407 current_insn_size += 1; 1408 print (fp, col, "addr = cpu_get_x (cpu) + (uint16) cpu_fetch8 (cpu);"); 1409 print (fp, col, "%s%s = memory_read%s (cpu, addr);", 1410 vars[cur_var], operand_size, operand_size); 1411 operands += 2; 1412 } 1413 else if (strncmp (operands, "y)", 2) == 0) 1414 { 1415 addr_set = 1; 1416 current_insn_size += 1; 1417 print (fp, col, "addr = cpu_get_y (cpu) + (uint16) cpu_fetch8 (cpu);"); 1418 print (fp, col, "%s%s = memory_read%s (cpu, addr);", 1419 vars[cur_var], operand_size, operand_size); 1420 operands += 2; 1421 } 1422 else if (strncmp (operands, ")", 1) == 0) 1423 { 1424 addr_set = 1; 1425 current_insn_size += 2; 1426 print (fp, col, "addr = cpu_fetch16 (cpu);"); 1427 print (fp, col, "%s%s = memory_read%s (cpu, addr);", 1428 vars[cur_var], operand_size, operand_size); 1429 operands++; 1430 } 1431 else if (strncmp (operands, "@)", 2) == 0) 1432 { 1433 current_insn_size += 2; 1434 print (fp, col, "addr = cpu_fetch16 (cpu);"); 1435 print (fp, col, "%s%s = memory_read%s (cpu, addr);", 1436 vars[cur_var], operand_size, operand_size); 1437 operands += 2; 1438 } 1439 else if (strncmp (operands, "sp)", 3) == 0) 1440 { 1441 print (fp, col, "%s%s = cpu_%s_pop_uint%s (cpu);", 1442 vars[cur_var], operand_size, 1443 cpu_type == cpu6811 ? "m68hc11" : "m68hc12", 1444 operand_size); 1445 operands += 3; 1446 } 1447 else 1448 { 1449 fatal_error (opcode, "Unknown operand"); 1450 } 1451 break; 1452 1453 case '[': 1454 if (cur_var >= 2) 1455 fatal_error (opcode, "Too many locals"); 1456 1457 if (addr_set) 1458 fatal_error (opcode, "Wrong use of '[', 'addr' already used"); 1459 1460 if (strncmp (operands, "]", 1) == 0) 1461 { 1462 addr_set = 1; 1463 current_insn_size += 1; 1464 print (fp, col, "addr = cpu_get_indexed_operand_addr (cpu,0);"); 1465 print (fp, col, "%s%s = memory_read%s (cpu, addr);", 1466 vars[cur_var], operand_size, operand_size); 1467 operands += 1; 1468 } 1469 #if 0 /* This code is never executed (see strncmp above), but it has not been 1470 removed because it may be that there is a typo in strncmp test below. */ 1471 else if (strncmp (operands, "]", 1) == 0) 1472 { 1473 current_insn_size += 1; 1474 print (fp, col, "%s%s = cpu_get_indexed_operand%s (cpu,0);", 1475 vars[cur_var], operand_size, operand_size); 1476 operands += 1; 1477 } 1478 #endif 1479 else 1480 { 1481 fatal_error (opcode, "Unknown operand"); 1482 } 1483 break; 1484 1485 case '{': 1486 if (cur_var >= 2) 1487 fatal_error (opcode, "Too many locals"); 1488 1489 if (addr_set) 1490 fatal_error (opcode, "Wrong use of '{', 'addr' already used"); 1491 1492 if (strncmp (operands, "}", 1) == 0) 1493 { 1494 current_insn_size += 1; 1495 print (fp, col, "%s%s = cpu_get_indexed_operand%s (cpu, 1);", 1496 vars[cur_var], operand_size, operand_size); 1497 operands += 1; 1498 } 1499 else 1500 { 1501 fatal_error (opcode, "Unknown operand"); 1502 } 1503 break; 1504 1505 case 's': 1506 if (cur_var >= 2) 1507 fatal_error (opcode, "Too many locals"); 1508 1509 if (strncmp (operands, "p", 1) == 0) 1510 { 1511 print (fp, col, "%s16 = cpu_get_sp (cpu);", vars[cur_var]); 1512 operands++; 1513 } 1514 else 1515 { 1516 fatal_error (opcode, "Unknown operands"); 1517 } 1518 break; 1519 1520 case 'c': 1521 if (strncmp (operands, "cr", 2) == 0) 1522 { 1523 print (fp, col, "%s8 = cpu_get_ccr (cpu);", vars[cur_var]); 1524 operands += 2; 1525 } 1526 else 1527 { 1528 fatal_error (opcode, "Unknown operands"); 1529 } 1530 break; 1531 1532 case 'r': 1533 if (addr_set && cur_var != 2) 1534 fatal_error (opcode, "Wrong use of 'r'"); 1535 1536 addr_set = 1; 1537 current_insn_size += 1; 1538 print (fp, col, "addr = cpu_fetch_relbranch (cpu);"); 1539 break; 1540 1541 case 'R': 1542 if (addr_set && cur_var != 2) 1543 fatal_error (opcode, "Wrong use of 'R'"); 1544 1545 addr_set = 1; 1546 current_insn_size += 2; 1547 print (fp, col, "addr = cpu_fetch_relbranch16 (cpu);"); 1548 break; 1549 1550 case '#': 1551 if (strcmp (operand_size, "8") == 0) 1552 { 1553 current_insn_size += 1; 1554 } 1555 else 1556 { 1557 current_insn_size += 2; 1558 } 1559 print (fp, col, "%s%s = cpu_fetch%s (cpu);", vars[cur_var], 1560 operand_size, operand_size); 1561 break; 1562 1563 case ',': 1564 cur_var ++; 1565 break; 1566 1567 case '-': 1568 return addr_set; 1569 1570 default: 1571 fatal_error (opcode, "Invalid operands"); 1572 break; 1573 } 1574 } 1575 return addr_set; 1576 } 1577 1578 1579 /* Generate the code to save the instruction result. The result is in 1580 a local variable: either 'dst8' or 'dst16'. 1581 There may be only one result. Instructions with 2 results (ie idiv 1582 and fdiv), take care of saving the first value. 1583 1584 The operand string is the same as for 'gen_fetch_operands'. 1585 Everything before '->' is ignored. If the '->' is not found, it 1586 is assumed that there is nothing to save. After '->', the operand 1587 string is interpreted as follows: 1588 1589 a Save 'dst8' in A register 1590 b " B " 1591 ccr " CCR " 1592 d " 'dst16' D " 1593 x " X " 1594 y " Y " 1595 sp " SP " 1596 * 68HC11 page0 memory pointer. 1597 (x) 68HC11 indirect access with X register. 1598 (y) Same as (x) with Y register. 1599 () 68HC11 extended address mode (global variable). 1600 For these modes, if they were used as an input operand, 1601 the 'addr' variable contains the address of memory where 1602 the result must be saved. 1603 If they were not used an input operand, 'addr' is computed 1604 (as in gen_fetch_operands()), and the result is saved. 1605 [] 68HC12 indexed indirect 1606 (sp) Push 1607 Push the 8/16-bits result on the stack. */ 1608 void 1609 gen_save_result (FILE *fp, int col, 1610 const struct m6811_opcode_def *opcode, 1611 int addr_set, 1612 const char *operand_size) 1613 { 1614 char c; 1615 const char *operands = opcode->operands; 1616 1617 /* When the result is saved, 'result_size' is a string which 1618 indicates the size of the saved result ("8" or "16"). This 1619 is a sanity check with 'operand_size' to detect inconsistencies 1620 in the different tables. */ 1621 const char *result_size = 0; 1622 1623 if (operands == 0) 1624 operands = ""; 1625 1626 operands = strchr (operands, '-'); 1627 if (operands == 0) 1628 return; 1629 1630 operands++; 1631 if (*operands++ != '>') 1632 { 1633 fatal_error (opcode, "Invalid operand"); 1634 } 1635 1636 c = *operands++; 1637 switch (c) 1638 { 1639 case 'a': 1640 result_size = "8"; 1641 print (fp, col, "cpu_set_a (cpu, dst8);"); 1642 break; 1643 1644 case 'b': 1645 result_size = "8"; 1646 print (fp, col, "cpu_set_b (cpu, dst8);"); 1647 break; 1648 1649 case 'd': 1650 result_size = "16"; 1651 print (fp, col, "cpu_set_d (cpu, dst16);"); 1652 break; 1653 1654 case 'x': 1655 result_size = "16"; 1656 print (fp, col, "cpu_set_x (cpu, dst16);"); 1657 break; 1658 1659 case 'y': 1660 result_size = "16"; 1661 print (fp, col, "cpu_set_y (cpu, dst16);"); 1662 break; 1663 1664 case '*': 1665 if (addr_set == 0) 1666 { 1667 current_insn_size += 1; 1668 print (fp, col, "addr = (uint16) cpu_fetch8 (cpu);"); 1669 } 1670 result_size = operand_size; 1671 print (fp, col, "memory_write%s (cpu, addr, dst%s);", 1672 operand_size, operand_size); 1673 break; 1674 1675 case '(': 1676 if (strncmp (operands, "x)", 2) == 0) 1677 { 1678 if (addr_set == 0) 1679 { 1680 current_insn_size += 1; 1681 print (fp, col, "addr = cpu_get_x (cpu) + cpu_fetch8 (cpu);"); 1682 } 1683 print (fp, col, "memory_write%s (cpu, addr, dst%s);", 1684 operand_size, operand_size); 1685 operands += 2; 1686 result_size = operand_size; 1687 } 1688 else if (strncmp (operands, "y)", 2) == 0) 1689 { 1690 if (addr_set == 0) 1691 { 1692 current_insn_size += 1; 1693 print (fp, col, "addr = cpu_get_y (cpu) + cpu_fetch8 (cpu);"); 1694 } 1695 print (fp, col, "memory_write%s (cpu, addr, dst%s);", 1696 operand_size, operand_size); 1697 operands += 2; 1698 result_size = operand_size; 1699 } 1700 else if (strncmp (operands, ")", 1) == 0) 1701 { 1702 if (addr_set == 0) 1703 { 1704 current_insn_size += 2; 1705 print (fp, col, "addr = cpu_fetch16 (cpu);"); 1706 } 1707 print (fp, col, "memory_write%s (cpu, addr, dst%s);", 1708 operand_size, operand_size); 1709 operands++; 1710 result_size = operand_size; 1711 } 1712 else if (strncmp (operands, "sp)", 3) == 0) 1713 { 1714 print (fp, col, "cpu_%s_push_uint%s (cpu, dst%s);", 1715 cpu_type == cpu6811 ? "m68hc11" : "m68hc12", 1716 operand_size, operand_size); 1717 operands += 3; 1718 result_size = operand_size; 1719 } 1720 else 1721 { 1722 fatal_error (opcode, "Invalid operand"); 1723 } 1724 break; 1725 1726 case '[': 1727 if (strncmp (operands, "]", 1) == 0) 1728 { 1729 if (addr_set == 0) 1730 { 1731 current_insn_size += 1; 1732 print (fp, col, "addr = cpu_get_indexed_operand_addr (cpu,0);"); 1733 } 1734 print (fp, col, "memory_write%s (cpu, addr, dst%s);", 1735 operand_size, operand_size); 1736 operands++; 1737 result_size = operand_size; 1738 } 1739 else 1740 { 1741 fatal_error (opcode, "Invalid operand"); 1742 } 1743 break; 1744 1745 case '{': 1746 if (strncmp (operands, "}", 1) == 0) 1747 { 1748 current_insn_size += 1; 1749 print (fp, col, "addr = cpu_get_indexed_operand_addr (cpu, 1);"); 1750 print (fp, col, "memory_write%s (cpu, addr, dst%s);", 1751 operand_size, operand_size); 1752 operands++; 1753 result_size = operand_size; 1754 } 1755 else 1756 { 1757 fatal_error (opcode, "Invalid operand"); 1758 } 1759 break; 1760 1761 case 's': 1762 if (strncmp (operands, "p", 1) == 0) 1763 { 1764 print (fp, col, "cpu_set_sp (cpu, dst16);"); 1765 operands++; 1766 result_size = "16"; 1767 } 1768 else 1769 { 1770 fatal_error (opcode, "Invalid operand"); 1771 } 1772 break; 1773 1774 case 'c': 1775 if (strncmp (operands, "cr", 2) == 0) 1776 { 1777 print (fp, col, "cpu_set_ccr (cpu, dst8);"); 1778 operands += 2; 1779 result_size = "8"; 1780 } 1781 else 1782 { 1783 fatal_error (opcode, "Invalid operand"); 1784 } 1785 break; 1786 1787 default: 1788 fatal_error (opcode, "Invalid operand"); 1789 break; 1790 } 1791 1792 if (*operands != 0) 1793 fatal_error (opcode, "Garbage at end of operand"); 1794 1795 if (result_size == 0) 1796 fatal_error (opcode, "? No result seems to be saved"); 1797 1798 if (strcmp (result_size, operand_size) != 0) 1799 fatal_error (opcode, "Result saved different than pattern size"); 1800 } 1801 1802 1803 /* Find the instruction pattern for a given instruction. */ 1804 const struct m6811_opcode_pattern* 1805 find_opcode_pattern (const struct m6811_opcode_def *opcode) 1806 { 1807 int i; 1808 const char *pattern = opcode->insn_pattern; 1809 1810 if (pattern == 0) 1811 { 1812 pattern = opcode->name; 1813 } 1814 for (i = 0; i < ARRAY_SIZE (m6811_opcode_patterns); i++) 1815 { 1816 if (strcmp (m6811_opcode_patterns[i].name, pattern) == 0) 1817 { 1818 return &m6811_opcode_patterns[i]; 1819 } 1820 } 1821 fatal_error (opcode, "Unknown instruction pattern"); 1822 return 0; 1823 } 1824 1825 /* Generate the code for interpretation of instruction 'opcode'. */ 1826 void 1827 gen_interp (FILE *fp, int col, const struct m6811_opcode_def *opcode) 1828 { 1829 const char *operands = opcode->operands; 1830 int addr_set; 1831 const char *pattern = opcode->insn_pattern; 1832 const struct m6811_opcode_pattern *op; 1833 const char *operand_size; 1834 1835 if (pattern == 0) 1836 { 1837 pattern = opcode->name; 1838 } 1839 1840 /* Find out the size of the operands: 8 or 16-bits. */ 1841 if (strcmp(&pattern[strlen(pattern) - 1], "8") == 0) 1842 { 1843 operand_size = "8"; 1844 } 1845 else if (strcmp (&pattern[strlen(pattern) - 2], "16") == 0) 1846 { 1847 operand_size = "16"; 1848 } 1849 else 1850 { 1851 operand_size = ""; 1852 } 1853 1854 if (operands == 0) 1855 operands = ""; 1856 1857 /* Generate entry point for the instruction. */ 1858 print (fp, col, "case 0x%02x: /* %s %s */\n", opcode->insn_code, 1859 opcode->name, operands); 1860 col += indent_level; 1861 1862 /* Generate the code to get the instruction operands. */ 1863 addr_set = gen_fetch_operands (fp, col, opcode, operand_size); 1864 1865 /* Generate instruction interpretation. */ 1866 op = find_opcode_pattern (opcode); 1867 if (op->pattern) 1868 { 1869 print (fp, col, "%s;", op->pattern); 1870 } 1871 1872 /* Generate the code to save the result. */ 1873 gen_save_result (fp, col, opcode, addr_set, operand_size); 1874 1875 /* For some instructions, generate the code to update the flags. */ 1876 if (op && op->ccr_update) 1877 { 1878 print (fp, col, "%s;", op->ccr_update); 1879 } 1880 print (fp, col, "break;"); 1881 } 1882 1883 1884 /* Generate the interpretor for a given 68HC11 page set. */ 1885 void 1886 gen_interpreter_for_table (FILE *fp, int col, 1887 const struct m6811_opcode_def *table, 1888 int size, 1889 const char *cycles_table_name) 1890 { 1891 int i; 1892 int init_size; 1893 1894 init_size = table == m6811_page1_opcodes 1895 || table == m6812_page1_opcodes? 1 : 2; 1896 1897 /* Get the opcode and dispatch directly. */ 1898 print (fp, col, "op = cpu_fetch8 (cpu);"); 1899 print (fp, col, "cpu_add_cycles (cpu, %s[op]);", cycles_table_name); 1900 1901 print (fp, col, "switch (op)\n"); 1902 col += indent_level; 1903 print (fp, col, "{\n"); 1904 1905 for (i = 0; i < size; i++) 1906 { 1907 /* The table contains duplicate entries (ie, instruction aliases). */ 1908 if (i > 0 && table[i].insn_code == table[i - 1].insn_code) 1909 continue; 1910 1911 current_insn_size = init_size; 1912 gen_interp (fp, col, &table[i]); 1913 #if 0 1914 if (current_insn_size != table[i].insn_size) 1915 { 1916 fatal_error (&table[i], "Insn size %ld inconsistent with %ld", 1917 current_insn_size, table[i].insn_size); 1918 } 1919 #endif 1920 } 1921 1922 print (fp, col, "default:\n"); 1923 print (fp, col + indent_level, "cpu_special (cpu, M6811_ILLEGAL);"); 1924 print (fp, col + indent_level, "break;"); 1925 print (fp, col, "}\n"); 1926 } 1927 1928 /* Generate the table of instruction cycle. These tables are indexed 1929 by the opcode number to allow a fast cycle time computation. */ 1930 void 1931 gen_cycle_table (FILE *fp, const char *name, 1932 const struct m6811_opcode_def *table, 1933 int size) 1934 { 1935 int i; 1936 char cycles[256]; 1937 int page1; 1938 1939 page1 = table == m6811_page1_opcodes; 1940 1941 /* Build the cycles table. The table is indexed by the opcode. */ 1942 memset (cycles, 0, sizeof (cycles)); 1943 while (--size >= 0) 1944 { 1945 if (table->insn_min_cycles > table->insn_max_cycles) 1946 fatal_error (table, "Wrong insn cycles"); 1947 1948 if (table->insn_max_cycles == _M) 1949 cycles[table->insn_code] = table->insn_min_cycles; 1950 else 1951 cycles[table->insn_code] = table->insn_max_cycles; 1952 1953 table++; 1954 } 1955 1956 /* Some check: for the page1 opcode, the cycle type of the page2/3/4 1957 opcode must be 0. */ 1958 if (page1 && (cycles[M6811_OPCODE_PAGE2] != 0 1959 || cycles[M6811_OPCODE_PAGE3] != 0 1960 || cycles[M6811_OPCODE_PAGE4] != 0)) 1961 fatal_error (0, "Invalid cycle table"); 1962 1963 /* Generates the cycles table. */ 1964 print (fp, 0, "static const unsigned char %s[256] = {\n", name); 1965 for (i = 0; i < 256; i++) 1966 { 1967 if ((i % 16) == 0) 1968 { 1969 print (fp, indent_level, "/* %3d */ ", i); 1970 } 1971 fprintf (fp, "%2d", cycles[i]); 1972 if (i != 255) 1973 fprintf (fp, ","); 1974 1975 if ((i % 16) != 15) 1976 fprintf (fp, " "); 1977 else 1978 fprintf (fp, "\n"); 1979 } 1980 print (fp, 0, "};\n\n"); 1981 } 1982 1983 #define USE_SRC8 1 1984 #define USE_DST8 2 1985 1986 void 1987 gen_function_entry (FILE *fp, const char *name, int locals) 1988 { 1989 /* Generate interpretor entry point. */ 1990 print (fp, 0, "%s (sim_cpu *cpu)\n", name); 1991 print (fp, indent_level, "{\n"); 1992 1993 /* Interpretor local variables. */ 1994 print (fp, indent_level, "unsigned char op;"); 1995 print (fp, indent_level, "uint16 addr, src16, dst16;"); 1996 if (locals & USE_SRC8) 1997 print (fp, indent_level, "uint8 src8;\n"); 1998 if (locals & USE_DST8) 1999 print (fp, indent_level, "uint8 dst8;\n"); 2000 } 2001 2002 void 2003 gen_function_close (FILE *fp) 2004 { 2005 print (fp, 0, "}\n"); 2006 } 2007 2008 int 2009 cmp_opcode (const void *e1, const void *e2) 2010 { 2011 struct m6811_opcode_def* op1 = (struct m6811_opcode_def*) e1; 2012 struct m6811_opcode_def* op2 = (struct m6811_opcode_def*) e2; 2013 2014 return (int) (op1->insn_code) - (int) (op2->insn_code); 2015 } 2016 2017 void 2018 prepare_table (struct m6811_opcode_def* table, int size) 2019 { 2020 int i; 2021 2022 qsort (table, size, sizeof (table[0]), cmp_opcode); 2023 for (i = 1; i < size; i++) 2024 { 2025 if (table[i].insn_code == table[i-1].insn_code) 2026 { 2027 fprintf (stderr, "Two insns with code 0x%02x\n", 2028 table[i].insn_code); 2029 } 2030 } 2031 } 2032 2033 void 2034 gen_interpreter (FILE *fp) 2035 { 2036 int col = 0; 2037 2038 prepare_table (m6811_page1_opcodes, ARRAY_SIZE (m6811_page1_opcodes)); 2039 prepare_table (m6811_page2_opcodes, ARRAY_SIZE (m6811_page2_opcodes)); 2040 prepare_table (m6811_page3_opcodes, ARRAY_SIZE (m6811_page3_opcodes)); 2041 prepare_table (m6811_page4_opcodes, ARRAY_SIZE (m6811_page4_opcodes)); 2042 2043 prepare_table (m6812_page1_opcodes, ARRAY_SIZE (m6812_page1_opcodes)); 2044 prepare_table (m6812_page2_opcodes, ARRAY_SIZE (m6812_page2_opcodes)); 2045 2046 /* Generate header of interpretor. */ 2047 print (fp, col, "/* File generated automatically by gencode. */\n"); 2048 print (fp, col, "#include \"sim-main.h\"\n\n"); 2049 2050 if (cpu_type & cpu6811) 2051 { 2052 gen_cycle_table (fp, "cycles_page1", m6811_page1_opcodes, 2053 ARRAY_SIZE (m6811_page1_opcodes)); 2054 gen_cycle_table (fp, "cycles_page2", m6811_page2_opcodes, 2055 ARRAY_SIZE (m6811_page2_opcodes)); 2056 gen_cycle_table (fp, "cycles_page3", m6811_page3_opcodes, 2057 ARRAY_SIZE (m6811_page3_opcodes)); 2058 gen_cycle_table (fp, "cycles_page4", m6811_page4_opcodes, 2059 ARRAY_SIZE (m6811_page4_opcodes)); 2060 2061 gen_function_entry (fp, "static void\ncpu_page3_interp", 0); 2062 gen_interpreter_for_table (fp, indent_level, 2063 m6811_page3_opcodes, 2064 ARRAY_SIZE (m6811_page3_opcodes), 2065 "cycles_page3"); 2066 gen_function_close (fp); 2067 2068 gen_function_entry (fp, "static void\ncpu_page4_interp", 0); 2069 gen_interpreter_for_table (fp, indent_level, 2070 m6811_page4_opcodes, 2071 ARRAY_SIZE (m6811_page4_opcodes), 2072 "cycles_page4"); 2073 gen_function_close (fp); 2074 2075 /* Generate the page 2, 3 and 4 handlers. */ 2076 gen_function_entry (fp, "static void\ncpu_page2_interp", 2077 USE_SRC8 | USE_DST8); 2078 gen_interpreter_for_table (fp, indent_level, 2079 m6811_page2_opcodes, 2080 ARRAY_SIZE (m6811_page2_opcodes), 2081 "cycles_page2"); 2082 gen_function_close (fp); 2083 2084 /* Generate the interpretor entry point. */ 2085 gen_function_entry (fp, "void\ncpu_interp_m6811", 2086 USE_SRC8 | USE_DST8); 2087 2088 gen_interpreter_for_table (fp, indent_level, m6811_page1_opcodes, 2089 ARRAY_SIZE (m6811_page1_opcodes), 2090 "cycles_page1"); 2091 gen_function_close (fp); 2092 } 2093 else 2094 { 2095 gen_cycle_table (fp, "cycles_page1", m6812_page1_opcodes, 2096 ARRAY_SIZE (m6812_page1_opcodes)); 2097 gen_cycle_table (fp, "cycles_page2", m6812_page2_opcodes, 2098 ARRAY_SIZE (m6812_page2_opcodes)); 2099 2100 gen_function_entry (fp, "static void\ncpu_page2_interp", 2101 USE_SRC8 | USE_DST8); 2102 gen_interpreter_for_table (fp, indent_level, 2103 m6812_page2_opcodes, 2104 ARRAY_SIZE (m6812_page2_opcodes), 2105 "cycles_page2"); 2106 gen_function_close (fp); 2107 2108 /* Generate the interpretor entry point. */ 2109 gen_function_entry (fp, "void\ncpu_interp_m6812", 2110 USE_SRC8 | USE_DST8); 2111 2112 gen_interpreter_for_table (fp, indent_level, m6812_page1_opcodes, 2113 ARRAY_SIZE (m6812_page1_opcodes), 2114 "cycles_page1"); 2115 gen_function_close (fp); 2116 } 2117 } 2118 2119 void 2120 usage (char* prog) 2121 { 2122 fprintf (stderr, "Usage: %s {-m6811|-m6812}\n", prog); 2123 exit (2); 2124 } 2125 2126 int 2127 main (int argc, char *argv[]) 2128 { 2129 int i; 2130 2131 for (i = 1; i < argc; i++) 2132 { 2133 if (strcmp (argv[i], "-m6811") == 0) 2134 cpu_type = cpu6811; 2135 else if (strcmp (argv[i], "-m6812") == 0) 2136 cpu_type = cpu6812; 2137 else 2138 { 2139 usage (argv[0]); 2140 } 2141 } 2142 if (cpu_type == 0) 2143 usage (argv[0]); 2144 2145 gen_interpreter (stdout); 2146 if (fclose (stdout) != 0) 2147 { 2148 fprintf (stderr, "Error while generating the interpreter: %d\n", 2149 errno); 2150 return 1; 2151 } 2152 return 0; 2153 } 2154