![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hd6301_cpu.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src|
Return to hd6301_cpu.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src |
1.1 root 1: /*
2: Hatari - hd6301_cpu.c
3: Copyright Laurent Sallafranque 2009
4:
5: This file is distributed under the GNU Public License, version 2 or at
6: your option any later version. Read the file gpl.txt for details.
7:
8: hd6301_cpu.c - this is the cpu core emulation for hd 6301 processor
9: */
10:
11: #ifdef HAVE_CONFIG_H
12: #include "config.h"
13: #endif
14:
15: #include <string.h>
16: #include <SDL.h>
17:
18: #include "hd6301_cpu.h"
19:
20:
21: /**********************************
22: * Defines
23: **********************************/
24: #define HD6301_DISASM 1
25: #define HD6301_DISPLAY_REGS 1
26:
27: /* HD6301 Disasm and debug code */
28: #define HD6301_DISASM_UNDEFINED 0
29: #define HD6301_DISASM_NONE 1
30: #define HD6301_DISASM_MEMORY8 2
31: #define HD6301_DISASM_MEMORY16 3
32: #define HD6301_DISASM_XIM 4
33:
34: /* CCR bits for clearing */
35:
36: #define HD6301_CLR_HNZVC hd6301_reg_CCR &= 0xd0
37: #define HD6301_CLR_HNZC hd6301_reg_CCR &= 0xd2
38: #define HD6301_CLR_NZVC hd6301_reg_CCR &= 0xf0
39: #define HD6301_CLR_NZV hd6301_reg_CCR &= 0xf1
40: #define HD6301_CLR_NZC hd6301_reg_CCR &= 0xf2
41: #define HD6301_CLR_ZC hd6301_reg_CCR &= 0xfa
42: #define HD6301_CLR_I hd6301_reg_CCR &= 0xef
43: #define HD6301_CLR_Z hd6301_reg_CCR &= 0xfb
44: #define HD6301_CLR_V hd6301_reg_CCR &= 0xfd
45: #define HD6301_CLR_C hd6301_reg_CCR &= 0xfe
46:
47:
48: /**********************************
49: * macros for CCR processing
50: * adapted from mame project
51: **********************************/
52: #define HD6301_SET_Z8(a) hd6301_reg_CCR |= (((Uint8)(a) == 0) << 1)
53: #define HD6301_SET_Z16(a) hd6301_reg_CCR |= (((Uint16)(a) == 0) << 1)
54: #define HD6301_SET_N8(a) hd6301_reg_CCR |= (((a) & 0x80) >> 4)
55: #define HD6301_SET_N16(a) hd6301_reg_CCR |= (((a) & 0x8000) >> 12)
56: #define HD6301_SET_C8(a) hd6301_reg_CCR |= (((a) & 0x100) >> 8)
57: #define HD6301_SET_C16(a) hd6301_reg_CCR |= (((a) & 0x10000) >> 16)
58: #define HD6301_SET_V8(a,b,r) hd6301_reg_CCR |= ((((a)^(b)^(r)^((r)>>1)) & 0x80) >> 6)
59: #define HD6301_SET_V16(a,b,r) hd6301_reg_CCR |= ((((a)^(b)^(r)^((r)>>1)) & 0x8000) >> 14)
60: #define HD6301_SET_H(a,b,r) hd6301_reg_CCR |= ((((a)^(b)^(r)) & 0x10) << 1)
61:
62:
63: #define HD6301_SET_NZ8(a) {HD6301_SET_N8(a);HD6301_SET_Z8(a);}
64: #define HD6301_SET_NZ16(a) {HD6301_SET_N16(a);HD6301_SET_Z16(a);}
65: #define HD6301_SET_FLAGS8(a,b,r) {HD6301_SET_N8(r);HD6301_SET_Z8(r);HD6301_SET_V8(a,b,r);HD6301_SET_C8(r);}
66: #define HD6301_SET_FLAGS16(a,b,r) {HD6301_SET_N16(r);HD6301_SET_Z16(r);HD6301_SET_V16(a,b,r);HD6301_SET_C16(r);}
67:
68:
69: /**********************************
70: * Functions
71: **********************************/
72:
73: /* HD6301 internal functions */
74: static Uint8 hd6301_read_memory(Uint16 addr);
75: static void hd6301_write_memory (Uint16 addr, Uint8 value);
76: static Uint16 hd6301_get_memory_ext(void);
77:
78: /* HD6301 opcodes functions */
79: static void hd6301_undefined(void);
80: static void hd6301_nop(void);
81: static void hd6301_lsrd(void);
82: static void hd6301_asld(void);
83: static void hd6301_tap(void);
84: static void hd6301_tpa(void);
85: static void hd6301_inx(void);
86: static void hd6301_dex(void);
87: static void hd6301_clv(void);
88: static void hd6301_sev(void);
89: static void hd6301_clc(void);
90: static void hd6301_sec(void);
91: static void hd6301_cli(void);
92: static void hd6301_sei(void);
93: static void hd6301_sba(void);
94: static void hd6301_cba(void);
95: static void hd6301_tab(void);
96: static void hd6301_tba(void);
97: static void hd6301_xgdx(void);
98: static void hd6301_daa(void);
99: static void hd6301_slp(void);
100: static void hd6301_aba(void);
101: static void hd6301_bra(void);
102: static void hd6301_brn(void);
103: static void hd6301_bhi(void);
104: static void hd6301_bls(void);
105: static void hd6301_bcc(void);
106: static void hd6301_bcs(void);
107: static void hd6301_bne(void);
108: static void hd6301_beq(void);
109: static void hd6301_bvc(void);
110: static void hd6301_bvs(void);
111: static void hd6301_bpl(void);
112: static void hd6301_bmi(void);
113: static void hd6301_bge(void);
114: static void hd6301_blt(void);
115: static void hd6301_bgt(void);
116: static void hd6301_ble(void);
117: static void hd6301_tsx(void);
118: static void hd6301_ins(void);
119: static void hd6301_pula(void);
120: static void hd6301_pulb(void);
121: static void hd6301_des(void);
122: static void hd6301_txs(void);
123: static void hd6301_psha(void);
124: static void hd6301_pshb(void);
125: static void hd6301_pulx(void);
126: static void hd6301_rts(void);
127: static void hd6301_abx(void);
128: static void hd6301_rti(void);
129: static void hd6301_pshx(void);
130: static void hd6301_mul(void);
131: static void hd6301_wai(void);
132: static void hd6301_swi(void);
133: static void hd6301_nega(void);
134: static void hd6301_coma(void);
135: static void hd6301_lsra(void);
136: static void hd6301_rora(void);
137: static void hd6301_asra(void);
138: static void hd6301_asla(void);
139: static void hd6301_rola(void);
140: static void hd6301_deca(void);
141: static void hd6301_inca(void);
142: static void hd6301_tsta(void);
143: static void hd6301_clra(void);
144: static void hd6301_negb(void);
145: static void hd6301_comb(void);
146: static void hd6301_lsrb(void);
147: static void hd6301_rorb(void);
148: static void hd6301_asrb(void);
149: static void hd6301_aslb(void);
150: static void hd6301_rolb(void);
151: static void hd6301_decb(void);
152: static void hd6301_incb(void);
153: static void hd6301_tstb(void);
154: static void hd6301_clrb(void);
155: static void hd6301_neg_ind(void);
156: static void hd6301_aim_ind(void);
157: static void hd6301_oim_ind(void);
158: static void hd6301_com_ind(void);
159: static void hd6301_lsr_ind(void);
160: static void hd6301_eim_ind(void);
161: static void hd6301_ror_ind(void);
162: static void hd6301_asr_ind(void);
163: static void hd6301_asl_ind(void);
164: static void hd6301_rol_ind(void);
165: static void hd6301_dec_ind(void);
166: static void hd6301_tim_ind(void);
167: static void hd6301_inc_ind(void);
168: static void hd6301_tst_ind(void);
169: static void hd6301_jmp_ind(void);
170: static void hd6301_clr_ind(void);
171: static void hd6301_neg_ext(void);
172: static void hd6301_aim_dir(void);
173: static void hd6301_oim_dir(void);
174: static void hd6301_com_ext(void);
175: static void hd6301_lsr_ext(void);
176: static void hd6301_eim_dir(void);
177: static void hd6301_ror_ext(void);
178: static void hd6301_asr_ext(void);
179: static void hd6301_asl_ext(void);
180: static void hd6301_rol_ext(void);
181: static void hd6301_dec_ext(void);
182: static void hd6301_tim_dir(void);
183: static void hd6301_inc_ext(void);
184: static void hd6301_tst_ext(void);
185: static void hd6301_jmp_ext(void);
186: static void hd6301_clr_ext(void);
187: static void hd6301_suba_imm(void);
188: static void hd6301_cmpa_imm(void);
189: static void hd6301_sbca_imm(void);
190: static void hd6301_subd_imm(void);
191: static void hd6301_anda_imm(void);
192: static void hd6301_bita_imm(void);
193: static void hd6301_ldaa_imm(void);
194: static void hd6301_eora_imm(void);
195: static void hd6301_adca_imm(void);
196: static void hd6301_oraa_imm(void);
197: static void hd6301_adda_imm(void);
198: static void hd6301_cpx_imm(void);
199: static void hd6301_bsr(void);
200: static void hd6301_lds_imm(void);
201: static void hd6301_suba_dir(void);
202: static void hd6301_cmpa_dir(void);
203: static void hd6301_sbca_dir(void);
204: static void hd6301_subd_dir(void);
205: static void hd6301_anda_dir(void);
206: static void hd6301_bita_dir(void);
207: static void hd6301_ldaa_dir(void);
208: static void hd6301_staa_dir(void);
209: static void hd6301_eora_dir(void);
210: static void hd6301_adca_dir(void);
211: static void hd6301_oraa_dir(void);
212: static void hd6301_adda_dir(void);
213: static void hd6301_cpx_dir(void);
214: static void hd6301_jsr_dir(void);
215: static void hd6301_lds_dir(void);
216: static void hd6301_sts_dir(void);
217: static void hd6301_suba_ind(void);
218: static void hd6301_cmpa_ind(void);
219: static void hd6301_sbca_ind(void);
220: static void hd6301_subd_ind(void);
221: static void hd6301_anda_ind(void);
222: static void hd6301_bita_ind(void);
223: static void hd6301_ldaa_ind(void);
224: static void hd6301_staa_ind(void);
225: static void hd6301_eora_ind(void);
226: static void hd6301_adca_ind(void);
227: static void hd6301_oraa_ind(void);
228: static void hd6301_adda_ind(void);
229: static void hd6301_cpx_ind(void);
230: static void hd6301_jsr_ind(void);
231: static void hd6301_lds_ind(void);
232: static void hd6301_sts_ind(void);
233: static void hd6301_suba_ext(void);
234: static void hd6301_cmpa_ext(void);
235: static void hd6301_sbca_ext(void);
236: static void hd6301_subd_ext(void);
237: static void hd6301_anda_ext(void);
238: static void hd6301_bita_ext(void);
239: static void hd6301_ldaa_ext(void);
240: static void hd6301_staa_ext(void);
241: static void hd6301_eora_ext(void);
242: static void hd6301_adca_ext(void);
243: static void hd6301_oraa_ext(void);
244: static void hd6301_adda_ext(void);
245: static void hd6301_cpx_ext(void);
246: static void hd6301_jsr_ext(void);
247: static void hd6301_lds_ext(void);
248: static void hd6301_sts_ext(void);
249: static void hd6301_subb_imm(void);
250: static void hd6301_cmpb_imm(void);
251: static void hd6301_sbcb_imm(void);
252: static void hd6301_addd_imm(void);
253: static void hd6301_andb_imm(void);
254: static void hd6301_bitb_imm(void);
255: static void hd6301_ldab_imm(void);
256: static void hd6301_eorb_imm(void);
257: static void hd6301_adcb_imm(void);
258: static void hd6301_orab_imm(void);
259: static void hd6301_addb_imm(void);
260: static void hd6301_ldd_imm(void);
261: static void hd6301_ldx_imm(void);
262: static void hd6301_subb_dir(void);
263: static void hd6301_cmpb_dir(void);
264: static void hd6301_sbcb_dir(void);
265: static void hd6301_addd_dir(void);
266: static void hd6301_andb_dir(void);
267: static void hd6301_bitb_dir(void);
268: static void hd6301_ldab_dir(void);
269: static void hd6301_stab_dir(void);
270: static void hd6301_eorb_dir(void);
271: static void hd6301_adcb_dir(void);
272: static void hd6301_orab_dir(void);
273: static void hd6301_addb_dir(void);
274: static void hd6301_ldd_dir(void);
275: static void hd6301_std_dir(void);
276: static void hd6301_ldx_dir(void);
277: static void hd6301_stx_dir(void);
278: static void hd6301_subb_ind(void);
279: static void hd6301_cmpb_ind(void);
280: static void hd6301_sbcb_ind(void);
281: static void hd6301_addd_ind(void);
282: static void hd6301_andb_ind(void);
283: static void hd6301_bitb_ind(void);
284: static void hd6301_ldab_ind(void);
285: static void hd6301_stab_ind(void);
286: static void hd6301_eorb_ind(void);
287: static void hd6301_adcb_ind(void);
288: static void hd6301_orab_ind(void);
289: static void hd6301_addb_ind(void);
290: static void hd6301_ldd_ind(void);
291: static void hd6301_std_ind(void);
292: static void hd6301_ldx_ind(void);
293: static void hd6301_stx_ind(void);
294: static void hd6301_subb_ext(void);
295: static void hd6301_cmpb_ext(void);
296: static void hd6301_sbcb_ext(void);
297: static void hd6301_addd_ext(void);
298: static void hd6301_andb_ext(void);
299: static void hd6301_bitb_ext(void);
300: static void hd6301_ldab_ext(void);
301: static void hd6301_stab_ext(void);
302: static void hd6301_eorb_ext(void);
303: static void hd6301_adcb_ext(void);
304: static void hd6301_orab_ext(void);
305: static void hd6301_addb_ext(void);
306: static void hd6301_ldd_ext(void);
307: static void hd6301_std_ext(void);
308: static void hd6301_ldx_ext(void);
309: static void hd6301_stx_ext(void);
310:
311:
312: /**********************************
313: * Variables
314: **********************************/
315: static char hd6301_str_instr[50];
316:
317: static struct hd6301_opcode_t hd6301_opcode;
318:
319: static struct hd6301_opcode_t hd6301_opcode_table[256] = {
320:
321: {0x00, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
322: {0x01, 1, hd6301_nop, 1, "nop", HD6301_DISASM_NONE},
323: {0x02, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
324: {0x03, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
325: {0x04, 1, hd6301_lsrd, 1, "lsrd", HD6301_DISASM_NONE},
326: {0x05, 1, hd6301_asld, 1, "asld", HD6301_DISASM_NONE},
327: {0x06, 1, hd6301_tap, 1, "tap", HD6301_DISASM_NONE},
328: {0x07, 1, hd6301_tpa, 1, "tpa", HD6301_DISASM_NONE},
329: {0x08, 1, hd6301_inx, 1, "inx", HD6301_DISASM_NONE},
330: {0x09, 1, hd6301_dex, 1, "dex", HD6301_DISASM_NONE},
331: {0x0a, 1, hd6301_clv, 1, "clv", HD6301_DISASM_NONE},
332: {0x0b, 1, hd6301_sev, 1, "sev", HD6301_DISASM_NONE},
333: {0x0c, 1, hd6301_clc, 1, "clc", HD6301_DISASM_NONE},
334: {0x0d, 1, hd6301_sec, 1, "sec", HD6301_DISASM_NONE},
335: {0x0e, 1, hd6301_cli, 1, "cli", HD6301_DISASM_NONE},
336: {0x0f, 1, hd6301_sei, 1, "sei", HD6301_DISASM_NONE},
337:
338: {0x10, 1, hd6301_sba, 1, "sba", HD6301_DISASM_NONE},
339: {0x11, 1, hd6301_cba, 1, "cba", HD6301_DISASM_NONE},
340: {0x12, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
341: {0x13, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
342: {0x14, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
343: {0x15, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
344: {0x16, 1, hd6301_tab, 1, "tab", HD6301_DISASM_NONE},
345: {0x17, 1, hd6301_tba, 1, "tba", HD6301_DISASM_NONE},
346: {0x18, 1, hd6301_xgdx, 2, "xgdx", HD6301_DISASM_NONE},
347: {0x19, 1, hd6301_daa, 2, "daa", HD6301_DISASM_NONE},
348: {0x1a, 1, hd6301_slp, 4, "slp", HD6301_DISASM_NONE},
349: {0x1b, 1, hd6301_aba, 1, "aba", HD6301_DISASM_NONE},
350: {0x1c, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
351: {0x1d, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
352: {0x1e, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
353: {0x1f, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
354:
355: {0x20, 0, hd6301_bra, 3, "bra $%02x", HD6301_DISASM_MEMORY8},
356: {0x21, 0, hd6301_brn, 3, "brn $%02x", HD6301_DISASM_MEMORY8},
357: {0x22, 0, hd6301_bhi, 3, "bhi $%02x", HD6301_DISASM_MEMORY8},
358: {0x23, 0, hd6301_bls, 3, "bls $%02x", HD6301_DISASM_MEMORY8},
359: {0x24, 0, hd6301_bcc, 3, "bcc $%02x", HD6301_DISASM_MEMORY8},
360: {0x25, 0, hd6301_bcs, 3, "bcs $%02x", HD6301_DISASM_MEMORY8},
361: {0x26, 0, hd6301_bne, 3, "bne $%02x", HD6301_DISASM_MEMORY8},
362: {0x27, 0, hd6301_beq, 3, "beq $%02x", HD6301_DISASM_MEMORY8},
363: {0x28, 0, hd6301_bvc, 3, "bvc $%02x", HD6301_DISASM_MEMORY8},
364: {0x29, 0, hd6301_bvs, 3, "bvs $%02x", HD6301_DISASM_MEMORY8},
365: {0x2a, 0, hd6301_bpl, 3, "bpl $%02x", HD6301_DISASM_MEMORY8},
366: {0x2b, 0, hd6301_bmi, 3, "bmi $%02x", HD6301_DISASM_MEMORY8},
367: {0x2c, 0, hd6301_bge, 3, "bge $%02x", HD6301_DISASM_MEMORY8},
368: {0x2d, 0, hd6301_blt, 3, "blt $%02x", HD6301_DISASM_MEMORY8},
369: {0x2e, 0, hd6301_bgt, 3, "bgt $%02x", HD6301_DISASM_MEMORY8},
370: {0x2f, 0, hd6301_ble, 3, "ble $%02x", HD6301_DISASM_MEMORY8},
371:
372: {0x30, 1, hd6301_tsx, 1, "tsx", HD6301_DISASM_NONE},
373: {0x31, 1, hd6301_ins, 1, "ins", HD6301_DISASM_NONE},
374: {0x32, 1, hd6301_pula, 3, "pula", HD6301_DISASM_NONE},
375: {0x33, 1, hd6301_pulb, 3, "pulb", HD6301_DISASM_NONE},
376: {0x34, 1, hd6301_des, 1, "des", HD6301_DISASM_NONE},
377: {0x35, 1, hd6301_txs, 1, "txs", HD6301_DISASM_NONE},
378: {0x36, 1, hd6301_psha, 4, "psha", HD6301_DISASM_NONE},
379: {0x37, 1, hd6301_pshb, 4, "pshb", HD6301_DISASM_NONE},
380: {0x38, 1, hd6301_pulx, 4, "pulx", HD6301_DISASM_NONE},
381: {0x39, 0, hd6301_rts, 5, "rts", HD6301_DISASM_NONE},
382: {0x3a, 1, hd6301_abx, 1, "abx", HD6301_DISASM_NONE},
383: {0x3b, 0, hd6301_rti, 10, "rti", HD6301_DISASM_NONE},
384: {0x3c, 1, hd6301_pshx, 5 , "pshx", HD6301_DISASM_NONE},
385: {0x3d, 1, hd6301_mul, 7, "mul", HD6301_DISASM_NONE},
386: {0x3e, 0, hd6301_wai, 9, "wai", HD6301_DISASM_NONE},
387: {0x3f, 0, hd6301_swi, 12, "swi", HD6301_DISASM_NONE},
388:
389: {0x40, 1, hd6301_nega, 1, "nega", HD6301_DISASM_NONE},
390: {0x41, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
391: {0x42, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
392: {0x43, 1, hd6301_coma, 1, "coma", HD6301_DISASM_NONE},
393: {0x44, 1, hd6301_lsra, 1, "lsra", HD6301_DISASM_NONE},
394: {0x45, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
395: {0x46, 1, hd6301_rora, 1, "rora", HD6301_DISASM_NONE},
396: {0x47, 1, hd6301_asra, 1, "asra", HD6301_DISASM_NONE},
397: {0x48, 1, hd6301_asla, 1, "lsla", HD6301_DISASM_NONE},
398: {0x49, 1, hd6301_rola, 1, "rola", HD6301_DISASM_NONE},
399: {0x4a, 1, hd6301_deca, 1, "deca", HD6301_DISASM_NONE},
400: {0x4b, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
401: {0x4c, 1, hd6301_inca, 1, "inca", HD6301_DISASM_NONE},
402: {0x4d, 1, hd6301_tsta, 1, "tsta", HD6301_DISASM_NONE},
403: {0x4e, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
404: {0x4f, 1, hd6301_clra, 1, "clra", HD6301_DISASM_NONE},
405:
406: {0x50, 1, hd6301_negb, 1, "negb", HD6301_DISASM_NONE},
407: {0x51, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
408: {0x52, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
409: {0x53, 1, hd6301_comb, 1, "comb", HD6301_DISASM_NONE},
410: {0x54, 1, hd6301_lsrb, 1, "lsrb", HD6301_DISASM_NONE},
411: {0x55, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
412: {0x56, 1, hd6301_rorb, 1, "rorb", HD6301_DISASM_NONE},
413: {0x57, 1, hd6301_asrb, 1, "asrb", HD6301_DISASM_NONE},
414: {0x58, 1, hd6301_aslb, 1, "lslb", HD6301_DISASM_NONE},
415: {0x59, 1, hd6301_rolb, 1, "rolb", HD6301_DISASM_NONE},
416: {0x5a, 1, hd6301_decb, 1, "decb", HD6301_DISASM_NONE},
417: {0x5b, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
418: {0x5c, 1, hd6301_incb, 1, "incb", HD6301_DISASM_NONE},
419: {0x5d, 1, hd6301_tstb, 1, "tstb", HD6301_DISASM_NONE},
420: {0x5e, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
421: {0x5f, 1, hd6301_clrb, 1, "clrb", HD6301_DISASM_NONE},
422:
423: {0x60, 2, hd6301_neg_ind, 6, "neg $%02x,x", HD6301_DISASM_MEMORY8},
424: {0x61, 3, hd6301_aim_ind, 7, "aim #$%02x,$%02x x", HD6301_DISASM_XIM},
425: {0x62, 3, hd6301_oim_ind, 7, "oim #$%02x,$%02x x", HD6301_DISASM_XIM},
426: {0x63, 2, hd6301_com_ind, 6, "com $%02x,x", HD6301_DISASM_MEMORY8},
427: {0x64, 2, hd6301_lsr_ind, 6, "lsr $%02x,x", HD6301_DISASM_MEMORY8},
428: {0x65, 3, hd6301_eim_ind, 7, "eim #$%02x,$%02x x", HD6301_DISASM_XIM},
429: {0x66, 2, hd6301_ror_ind, 6, "ror $%02x,x", HD6301_DISASM_MEMORY8},
430: {0x67, 2, hd6301_asr_ind, 6, "asr $%02x,x", HD6301_DISASM_MEMORY8},
431: {0x68, 2, hd6301_asl_ind, 6, "lsl $%02x,x", HD6301_DISASM_MEMORY8},
432: {0x69, 2, hd6301_rol_ind, 6, "rol $%02x,x", HD6301_DISASM_MEMORY8},
433: {0x6a, 2, hd6301_dec_ind, 6, "dec $%02x,x", HD6301_DISASM_MEMORY8},
434: {0x6b, 3, hd6301_tim_ind, 5, "tim #$%02x,$%02x x", HD6301_DISASM_XIM},
435: {0x6c, 2, hd6301_inc_ind, 6, "inc $%02x,x", HD6301_DISASM_MEMORY8},
436: {0x6d, 2, hd6301_tst_ind, 4, "tst $%02x,x", HD6301_DISASM_MEMORY8},
437: {0x6e, 0, hd6301_jmp_ind, 3, "jmp $%02x,x", HD6301_DISASM_MEMORY8},
438: {0x6f, 2, hd6301_clr_ind, 5, "clr $%02x,x", HD6301_DISASM_MEMORY8},
439:
440: {0x70, 3, hd6301_neg_ext, 6, "neg $%04x", HD6301_DISASM_MEMORY16},
441: {0x71, 3, hd6301_aim_dir, 6, "aim #$%02x,$%02x", HD6301_DISASM_XIM},
442: {0x72, 3, hd6301_oim_dir, 6, "oim #$%02x,$%02x", HD6301_DISASM_XIM},
443: {0x73, 3, hd6301_com_ext, 6, "com $%04x", HD6301_DISASM_MEMORY16},
444: {0x74, 3, hd6301_lsr_ext, 6, "lsr $%04x", HD6301_DISASM_MEMORY16},
445: {0x75, 3, hd6301_eim_dir, 6, "eim #$%02x,$%02x", HD6301_DISASM_XIM},
446: {0x76, 3, hd6301_ror_ext, 6, "ror $%04x", HD6301_DISASM_MEMORY16},
447: {0x77, 3, hd6301_asr_ext, 6, "asr $%04x", HD6301_DISASM_MEMORY16},
448: {0x78, 3, hd6301_asl_ext, 6, "lsl $%04x", HD6301_DISASM_MEMORY16},
449: {0x79, 3, hd6301_rol_ext, 6, "rol $%04x", HD6301_DISASM_MEMORY16},
450: {0x7a, 3, hd6301_dec_ext, 6, "dec $%04x", HD6301_DISASM_MEMORY16},
451: {0x7b, 3, hd6301_tim_dir, 4, "tim #$%02x,$%02x", HD6301_DISASM_XIM},
452: {0x7c, 3, hd6301_inc_ext, 6, "inc $%04x", HD6301_DISASM_MEMORY16},
453: {0x7d, 3, hd6301_tst_ext, 4, "tst $%04x", HD6301_DISASM_MEMORY16},
454: {0x7e, 0, hd6301_jmp_ext, 3, "jmp $%04x", HD6301_DISASM_MEMORY16},
455: {0x7f, 3, hd6301_clr_ext, 5, "clr $%04x", HD6301_DISASM_MEMORY16},
456:
457: {0x80, 2, hd6301_suba_imm, 2, "suba #$%02x", HD6301_DISASM_MEMORY8},
458: {0x81, 2, hd6301_cmpa_imm, 2, "cmpa #$%02x", HD6301_DISASM_MEMORY8},
459: {0x82, 2, hd6301_sbca_imm, 2, "sbca #$%02x", HD6301_DISASM_MEMORY8},
460: {0x83, 3, hd6301_subd_imm, 3, "subd #$%04x", HD6301_DISASM_MEMORY16},
461: {0x84, 2, hd6301_anda_imm, 2, "anda #$%02x", HD6301_DISASM_MEMORY8},
462: {0x85, 2, hd6301_bita_imm, 2, "bita #$%02x", HD6301_DISASM_MEMORY8},
463: {0x86, 2, hd6301_ldaa_imm, 2, "ldaa #$%02x", HD6301_DISASM_MEMORY8},
464: {0x87, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
465: {0x88, 2, hd6301_eora_imm, 2, "eora #$%02x", HD6301_DISASM_MEMORY8},
466: {0x89, 2, hd6301_adca_imm, 2, "adca #$%02x", HD6301_DISASM_MEMORY8},
467: {0x8a, 2, hd6301_oraa_imm, 2, "oraa #$%02x", HD6301_DISASM_MEMORY8},
468: {0x8b, 2, hd6301_adda_imm, 2, "adda #$%02x", HD6301_DISASM_MEMORY8},
469: {0x8c, 3, hd6301_cpx_imm, 3, "cpx #$%04x", HD6301_DISASM_MEMORY16},
470: {0x8d, 0, hd6301_bsr, 5, "bsr $%02x", HD6301_DISASM_MEMORY8},
471: {0x8e, 3, hd6301_lds_imm, 3, "lds #$%04x", HD6301_DISASM_MEMORY16},
472: {0x8f, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
473:
474: {0x90, 2, hd6301_suba_dir, 3, "suba $%02x", HD6301_DISASM_MEMORY8},
475: {0x91, 2, hd6301_cmpa_dir, 3, "cmpa $%02x", HD6301_DISASM_MEMORY8},
476: {0x92, 2, hd6301_sbca_dir, 3, "sbca $%02x", HD6301_DISASM_MEMORY8},
477: {0x93, 2, hd6301_subd_dir, 4, "subd $%02x", HD6301_DISASM_MEMORY8},
478: {0x94, 2, hd6301_anda_dir, 3, "anda $%02x", HD6301_DISASM_MEMORY8},
479: {0x95, 2, hd6301_bita_dir, 3, "bita $%02x", HD6301_DISASM_MEMORY8},
480: {0x96, 2, hd6301_ldaa_dir, 3, "ldaa $%02x", HD6301_DISASM_MEMORY8},
481: {0x97, 2, hd6301_staa_dir, 3, "staa $%02x", HD6301_DISASM_MEMORY8},
482: {0x98, 2, hd6301_eora_dir, 3, "eora $%02x", HD6301_DISASM_MEMORY8},
483: {0x99, 2, hd6301_adca_dir, 3, "adca $%02x", HD6301_DISASM_MEMORY8},
484: {0x9a, 2, hd6301_oraa_dir, 3, "oraa $%02x", HD6301_DISASM_MEMORY8},
485: {0x9b, 2, hd6301_adda_dir, 3, "adda $%02x", HD6301_DISASM_MEMORY8},
486: {0x9c, 2, hd6301_cpx_dir, 4, "cpx $%02x", HD6301_DISASM_MEMORY8},
487: {0x9d, 0, hd6301_jsr_dir, 5, "jsr $%02x", HD6301_DISASM_MEMORY8},
488: {0x9e, 2, hd6301_lds_dir, 4, "lds $%02x", HD6301_DISASM_MEMORY8},
489: {0x9f, 2, hd6301_sts_dir, 4, "sts $%02x", HD6301_DISASM_MEMORY8},
490:
491: {0xa0, 2, hd6301_suba_ind, 4, "suba $%02x,x", HD6301_DISASM_MEMORY8},
492: {0xa1, 2, hd6301_cmpa_ind, 4, "cmpa $%02x,x", HD6301_DISASM_MEMORY8},
493: {0xa2, 2, hd6301_sbca_ind, 4, "sbca $%02x,x", HD6301_DISASM_MEMORY8},
494: {0xa3, 2, hd6301_subd_ind, 5, "subd $%02x,x", HD6301_DISASM_MEMORY8},
495: {0xa4, 2, hd6301_anda_ind, 4, "anda $%02x,x", HD6301_DISASM_MEMORY8},
496: {0xa5, 2, hd6301_bita_ind, 4, "bita $%02x,x", HD6301_DISASM_MEMORY8},
497: {0xa6, 2, hd6301_ldaa_ind, 4, "ldaa $%02x,x", HD6301_DISASM_MEMORY8},
498: {0xa7, 2, hd6301_staa_ind, 4, "staa $%02x,x", HD6301_DISASM_MEMORY8},
499: {0xa8, 2, hd6301_eora_ind, 4, "eora $%02x,x", HD6301_DISASM_MEMORY8},
500: {0xa9, 2, hd6301_adca_ind, 4, "adca $%02x,x", HD6301_DISASM_MEMORY8},
501: {0xaa, 2, hd6301_oraa_ind, 4, "oraa $%02x,x", HD6301_DISASM_MEMORY8},
502: {0xab, 2, hd6301_adda_ind, 4, "adda $%02x,x", HD6301_DISASM_MEMORY8},
503: {0xac, 2, hd6301_cpx_ind, 5, "cpx $%02x,x", HD6301_DISASM_MEMORY8},
504: {0xad, 0, hd6301_jsr_ind, 5, "jsr $%02x,x", HD6301_DISASM_MEMORY8},
505: {0xae, 2, hd6301_lds_ind, 5, "lds $%02x,x", HD6301_DISASM_MEMORY8},
506: {0xaf, 2, hd6301_sts_ind, 5, "sts $%02x,x", HD6301_DISASM_MEMORY8},
507:
508: {0xb0, 3, hd6301_suba_ext, 4, "suba $%04x", HD6301_DISASM_MEMORY16},
509: {0xb1, 3, hd6301_cmpa_ext, 4, "cmpa $%04x", HD6301_DISASM_MEMORY16},
510: {0xb2, 3, hd6301_sbca_ext, 4, "sbca $%04x", HD6301_DISASM_MEMORY16},
511: {0xb3, 3, hd6301_subd_ext, 5, "subd $%04x", HD6301_DISASM_MEMORY16},
512: {0xb4, 3, hd6301_anda_ext, 4, "anda $%04x", HD6301_DISASM_MEMORY16},
513: {0xb5, 3, hd6301_bita_ext, 4, "bita $%04x", HD6301_DISASM_MEMORY16},
514: {0xb6, 3, hd6301_ldaa_ext, 4, "ldaa $%04x", HD6301_DISASM_MEMORY16},
515: {0xb7, 3, hd6301_staa_ext, 4, "staa $%04x", HD6301_DISASM_MEMORY16},
516: {0xb8, 3, hd6301_eora_ext, 4, "eora $%04x", HD6301_DISASM_MEMORY16},
517: {0xb9, 3, hd6301_adca_ext, 4, "adca $%04x", HD6301_DISASM_MEMORY16},
518: {0xba, 3, hd6301_oraa_ext, 4, "oraa $%04x", HD6301_DISASM_MEMORY16},
519: {0xbb, 3, hd6301_adda_ext, 4, "adda $%04x", HD6301_DISASM_MEMORY16},
520: {0xbc, 3, hd6301_cpx_ext, 5, "cpx $%04x", HD6301_DISASM_MEMORY16},
521: {0xbd, 0, hd6301_jsr_ext, 6, "jsr $%04x", HD6301_DISASM_MEMORY16},
522: {0xbe, 3, hd6301_lds_ext, 5, "lds $%04x", HD6301_DISASM_MEMORY16},
523: {0xbf, 3, hd6301_sts_ext, 5, "sts $%04x", HD6301_DISASM_MEMORY16},
524:
525: {0xc0, 2, hd6301_subb_imm, 2, "subb #$%02x", HD6301_DISASM_MEMORY8},
526: {0xc1, 2, hd6301_cmpb_imm, 2, "cmpb #$%02x", HD6301_DISASM_MEMORY8},
527: {0xc2, 2, hd6301_sbcb_imm, 2, "sbcb #$%02x", HD6301_DISASM_MEMORY8},
528: {0xc3, 3, hd6301_addd_imm, 3, "addd #$%04x", HD6301_DISASM_MEMORY16},
529: {0xc4, 2, hd6301_andb_imm, 2, "andb #$%02x", HD6301_DISASM_MEMORY8},
530: {0xc5, 2, hd6301_bitb_imm, 2, "bitb #$%02x", HD6301_DISASM_MEMORY8},
531: {0xc6, 2, hd6301_ldab_imm, 2, "ldab #$%02x", HD6301_DISASM_MEMORY8},
532: {0xc7, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
533: {0xc8, 2, hd6301_eorb_imm, 2, "eorb #$%02x", HD6301_DISASM_MEMORY8},
534: {0xc9, 2, hd6301_adcb_imm, 2, "adcb #$%02x", HD6301_DISASM_MEMORY8},
535: {0xca, 2, hd6301_orab_imm, 2, "orab #$%02x", HD6301_DISASM_MEMORY8},
536: {0xcb, 2, hd6301_addb_imm, 2, "addb #$%02x", HD6301_DISASM_MEMORY8},
537: {0xcc, 3, hd6301_ldd_imm, 3, "ldd #$%04x", HD6301_DISASM_MEMORY16},
538: {0xcd, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
539: {0xce, 3, hd6301_ldx_imm, 3, "ldx #$%04x", HD6301_DISASM_MEMORY16},
540: {0xcf, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
541:
542: {0xd0, 2, hd6301_subb_dir, 3, "subb $%02x", HD6301_DISASM_MEMORY8},
543: {0xd1, 2, hd6301_cmpb_dir, 3, "cmpb $%02x", HD6301_DISASM_MEMORY8},
544: {0xd2, 2, hd6301_sbcb_dir, 3, "sbcb $%02x", HD6301_DISASM_MEMORY8},
545: {0xd3, 2, hd6301_addd_dir, 4, "addd $%02x", HD6301_DISASM_MEMORY8},
546: {0xd4, 2, hd6301_andb_dir, 3, "andb $%02x", HD6301_DISASM_MEMORY8},
547: {0xd5, 2, hd6301_bitb_dir, 3, "bitb $%02x", HD6301_DISASM_MEMORY8},
548: {0xd6, 2, hd6301_ldab_dir, 3, "ldab $%02x", HD6301_DISASM_MEMORY8},
549: {0xd7, 2, hd6301_stab_dir, 3, "stab $%02x", HD6301_DISASM_MEMORY8},
550: {0xd8, 2, hd6301_eorb_dir, 3, "eorb $%02x", HD6301_DISASM_MEMORY8},
551: {0xd9, 2, hd6301_adcb_dir, 3, "adcb $%02x", HD6301_DISASM_MEMORY8},
552: {0xda, 2, hd6301_orab_dir, 3, "orab $%02x", HD6301_DISASM_MEMORY8},
553: {0xdb, 2, hd6301_addb_dir, 3, "addb $%02x", HD6301_DISASM_MEMORY8},
554: {0xdc, 2, hd6301_ldd_dir, 4, "ldd $%02x", HD6301_DISASM_MEMORY8},
555: {0xdd, 2, hd6301_std_dir, 4, "std $%02x", HD6301_DISASM_MEMORY8},
556: {0xde, 2, hd6301_ldx_dir, 4, "ldx $%02x", HD6301_DISASM_MEMORY8},
557: {0xdf, 2, hd6301_stx_dir, 4, "stx $%02x", HD6301_DISASM_MEMORY8},
558:
559: {0xe0, 2, hd6301_subb_ind, 4, "subb $%02x,x", HD6301_DISASM_MEMORY8},
560: {0xe1, 2, hd6301_cmpb_ind, 4, "cmpb $%02x,x", HD6301_DISASM_MEMORY8},
561: {0xe2, 2, hd6301_sbcb_ind, 4, "sbcb $%02x,x", HD6301_DISASM_MEMORY8},
562: {0xe3, 2, hd6301_addd_ind, 5, "addd $%02x,x", HD6301_DISASM_MEMORY8},
563: {0xe4, 2, hd6301_andb_ind, 4, "andb $%02x,x", HD6301_DISASM_MEMORY8},
564: {0xe5, 2, hd6301_bitb_ind, 4, "bitb $%02x,x", HD6301_DISASM_MEMORY8},
565: {0xe6, 2, hd6301_ldab_ind, 4, "ldab $%02x,x", HD6301_DISASM_MEMORY8},
566: {0xe7, 2, hd6301_stab_ind, 4, "stab $%02x,x", HD6301_DISASM_MEMORY8},
567: {0xe8, 2, hd6301_eorb_ind, 4, "eorb $%02x,x", HD6301_DISASM_MEMORY8},
568: {0xe9, 2, hd6301_adcb_ind, 4, "adcb $%02x,x", HD6301_DISASM_MEMORY8},
569: {0xea, 2, hd6301_orab_ind, 4, "orab $%02x,x", HD6301_DISASM_MEMORY8},
570: {0xeb, 2, hd6301_addb_ind, 4, "addb $%02x,x", HD6301_DISASM_MEMORY8},
571: {0xec, 2, hd6301_ldd_ind, 5, "ldd $%02x,x", HD6301_DISASM_MEMORY8},
572: {0xed, 2, hd6301_std_ind, 5, "std $%02x,x", HD6301_DISASM_MEMORY8},
573: {0xee, 2, hd6301_ldx_ind, 5, "ldx $%02x,x", HD6301_DISASM_MEMORY8},
574: {0xef, 2, hd6301_stx_ind, 5, "stx $%02x,x", HD6301_DISASM_MEMORY8},
575:
576: {0xf0, 3, hd6301_subb_ext, 4, "subb $%04x", HD6301_DISASM_MEMORY16},
577: {0xf1, 3, hd6301_cmpb_ext, 4, "cmpb $%04x", HD6301_DISASM_MEMORY16},
578: {0xf2, 3, hd6301_sbcb_ext, 4, "sbcb $%04x", HD6301_DISASM_MEMORY16},
579: {0xf3, 3, hd6301_addd_ext, 5, "addd $%04x", HD6301_DISASM_MEMORY16},
580: {0xf4, 3, hd6301_andb_ext, 4, "andb $%04x", HD6301_DISASM_MEMORY16},
581: {0xf5, 3, hd6301_bitb_ext, 4, "bitb $%04x", HD6301_DISASM_MEMORY16},
582: {0xf6, 3, hd6301_ldab_ext, 4, "ldab $%04x", HD6301_DISASM_MEMORY16},
583: {0xf7, 3, hd6301_stab_ext, 4, "stab $%04x", HD6301_DISASM_MEMORY16},
584: {0xf8, 3, hd6301_eorb_ext, 4, "eorb $%04x", HD6301_DISASM_MEMORY16},
585: {0xf9, 3, hd6301_adcb_ext, 4, "adcb $%04x", HD6301_DISASM_MEMORY16},
586: {0xfa, 3, hd6301_orab_ext, 4, "orab $%04x", HD6301_DISASM_MEMORY16},
587: {0xfb, 3, hd6301_addb_ext, 4, "addb $%04x", HD6301_DISASM_MEMORY16},
588: {0xfc, 3, hd6301_ldd_ext, 5, "ldd $%04x", HD6301_DISASM_MEMORY16},
589: {0xfd, 3, hd6301_std_ext, 5, "std $%04x", HD6301_DISASM_MEMORY16},
590: {0xfe, 3, hd6301_ldx_ext, 5, "ldx $%04x", HD6301_DISASM_MEMORY16},
591: {0xff, 3, hd6301_stx_ext, 5, "stx $%04x", HD6301_DISASM_MEMORY16}
592: };
593:
594:
595: /* Variables */
596: static Uint8 hd6301_cycles;
597: static Uint8 hd6301_cur_inst;
598:
599: static Sint8 hd6301_reg_A;
600: static Sint8 hd6301_reg_B;
601: static Sint16 hd6301_reg_X;
602: static Uint16 hd6301_reg_SP;
603: static Uint16 hd6301_reg_PC;
604: static Uint8 hd6301_reg_CCR;
605:
606: //Uint8 hd6301_reg_RMCR;
607:
608: static Uint8 hd6301_intREG[32];
609: static Uint8 hd6301_intRAM[128];
610: static Uint8 hd6301_intROM[4096];
611:
612:
613: /**********************************
614: * Emulator kernel
615: **********************************/
616:
617: /**
618: * Initialise hd6301 cpu
619: */
620: void hd6301_init_cpu(void)
621: {
622: hd6301_reg_CCR = 0xc0;
623: }
624:
625: /**
626: * Execute 1 hd6301 instruction
627: */
628: void hd6301_execute_one_instruction(void)
629: {
630: hd6301_cur_inst = hd6301_read_memory(hd6301_reg_PC);
631:
632: /* Get opcode to execute */
633: hd6301_opcode = hd6301_opcode_table[hd6301_cur_inst];
634:
635: /* disasm opcode ? */
636: #ifdef HD6301_DISASM
637: hd6301_disasm();
638: #endif
639: /* execute opcode */
640: hd6301_opcode.op_func();
641:
642: #ifdef HD6301_DISPLAY_REGS
643: hd6301_display_registers();
644: #endif
645:
646: /* Increment instruction cycles */
647: hd6301_cycles += hd6301_opcode.op_n_cycles;
648:
649: /* Increment PC register */
650: hd6301_reg_PC += hd6301_opcode.op_bytes;
651:
652: /* post process interrupts */
653:
654: /* post process timers */
655:
656: /* post process SCI */
657: }
658:
659: /**
660: * Read hd6301 memory (Ram, Rom, Internal registers)
661: */
662: static Uint8 hd6301_read_memory(Uint16 addr)
663: {
664: /* Internal registers */
665: if (addr <= 0x1f) {
666: return hd6301_intREG[addr];
667: }
668:
669: /* Internal RAM */
670: if ((addr >= 0x80) && (addr <= 0xff)) {
671: return hd6301_intRAM[addr-0x80];
672: }
673:
674: /* Internal ROM */
675: if (addr >= 0xf000) {
676: return hd6301_intROM[addr-0xf000];
677: }
678:
679: fprintf(stderr, "hd6301: 0x%04x: 0x%04x illegal memory address\n", hd6301_reg_PC, addr);
680: exit(-1);
681: }
682:
683: /**
684: * Write hd6301 memory (Ram, Internal registers)
685: */
686: static void hd6301_write_memory (Uint16 addr, Uint8 value)
687: {
688: /* Internal registers */
689: if (addr <= 0x1f) {
690: hd6301_intREG[addr] = value;
691: }
692:
693: /* Internal RAM */
694: else if ((addr >= 0x80) && (addr <= 0xff)) {
695: hd6301_intRAM[addr-0x80] = value;
696: }
697:
698: /* Internal ROM */
699: else if (addr >= 0xf000) {
700: fprintf(stderr, "hd6301: 0x%04x: attempt to write to rom\n", addr);
701: }
702:
703: /* Illegal address */
704: else {
705: fprintf(stderr, "hd6301: 0x%04x: write to illegal address\n", addr);
706: exit(-1);
707: }
708: }
709:
710: /**
711: * Get extended memory (16 bits)
712: */
713: static Uint16 hd6301_get_memory_ext(void)
714: {
715: Uint16 addr;
716:
717: addr = hd6301_read_memory(hd6301_reg_PC+1)<<8;
718: addr += hd6301_read_memory(hd6301_reg_PC+2);
719: return addr;
720: }
721:
722: /**
723: * Undefined opcode
724: */
725: static void hd6301_undefined(void)
726: {
727: fprintf(stderr, "hd6301: 0x%04x: 0x%02x unknown instruction\n", hd6301_reg_PC, hd6301_cur_inst);
728: exit(-1); /* TODO: Trap the error correctly */
729: }
730:
731: /**
732: * NOP : no operation
733: *
734: * HINZVC
735: * ......
736: */
737: static void hd6301_nop(void)
738: {
739: }
740:
741: /**
742: * LSRD : logical Shift Right, accumulator D : D=D>>1
743: *
744: * HINZVC
745: * ..0***
746: */
747: static void hd6301_lsrd(void)
748: {
749: Uint16 regD;
750: Uint8 carry;
751:
752: regD = (hd6301_reg_A<<8) + hd6301_reg_B;
753: carry = regD & 1;
754: regD >>= 1;
755:
756: hd6301_reg_A = regD >> 8;
757: hd6301_reg_B = regD;
758:
759: HD6301_CLR_NZVC;
760: hd6301_reg_CCR |= carry;
761: HD6301_SET_Z16(regD);
762: hd6301_reg_CCR |= ((0 ^ carry) == 1) << hd6301_REG_CCR_V;
763: }
764:
765: /**
766: * ASLD : arythmetic Shift left, accumulator D : D=D<<1
767: *
768: * HINZVC
769: * ..****
770: */
771: static void hd6301_asld(void)
772: {
773: Uint16 regD;
774: Uint8 carry, bitN;
775:
776: regD = (hd6301_reg_A<<8) + hd6301_reg_B;
777: carry = (regD >> 15) & 1;
778: regD <<= 1;
779:
780: hd6301_reg_A = regD >> 8;
781: hd6301_reg_B = regD;
782:
783: HD6301_CLR_NZVC;
784: hd6301_reg_CCR |= carry;
785: HD6301_SET_NZ16(regD);
786: bitN = (hd6301_reg_CCR & 0x8) >> 3;
787: hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
788: }
789:
790:
791: /**
792: * TAP : transfer accumulator A into register CCR : CCR=A
793: *
794: * HINZVC
795: * ******
796: */
797: static void hd6301_tap(void)
798: {
799: hd6301_reg_CCR = hd6301_reg_A;
800: hd6301_reg_CCR |= 0xc0;
801: }
802:
803: /**
804: * TPA : transfer register CCR into accumulator A : A=CCR
805: *
806: * HINZVC
807: * ......
808: */
809: static void hd6301_tpa(void)
810: {
811: hd6301_reg_A = hd6301_reg_CCR;
812: }
813:
814: /**
815: * INX : increment register X : X=X+1
816: *
817: * HINZVC
818: * ...*..
819: */
820: static void hd6301_inx(void)
821: {
822: ++ hd6301_reg_X;
823:
824: HD6301_CLR_Z;
825: HD6301_SET_Z16(hd6301_reg_X);
826: }
827:
828: /**
829: * DEX : decrement register X : X=X-1
830: *
831: * HINZVC
832: * ...*..
833: */
834: static void hd6301_dex(void)
835: {
836: -- hd6301_reg_X;
837:
838: HD6301_CLR_Z;
839: HD6301_SET_Z16(hd6301_reg_X);
840: }
841:
842: /**
843: * CLV : clear register CCR bit V : V=0
844: *
845: * HINZVC
846: * ....0.
847: */
848: static void hd6301_clv(void)
849: {
850: HD6301_CLR_V;
851: }
852:
853: /**
854: * SEV : set register CCR bit V : V=1
855: *
856: * HINZVC
857: * ....1.
858: */
859: static void hd6301_sev(void)
860: {
861: hd6301_reg_CCR |= 1<<hd6301_REG_CCR_V;
862: }
863:
864: /**
865: * CLC : clear register CCR bit C : C=0
866: *
867: * HINZVC
868: * .....0
869: */
870: static void hd6301_clc(void)
871: {
872: HD6301_CLR_C;
873: }
874:
875: /**
876: * SEC : set register CCR bit C : C=1
877: *
878: * HINZVC
879: * .....1
880: */
881: static void hd6301_sec(void)
882: {
883: hd6301_reg_CCR |= 1<<hd6301_REG_CCR_C;
884: }
885:
886: /**
887: * CLI : clear register CCR bit I : I=0
888: *
889: * HINZVC
890: * .0....
891: */
892: static void hd6301_cli(void)
893: {
894: HD6301_CLR_I;
895: }
896:
897: /**
898: * SEI : set register CCR bit I : I=1
899: *
900: * HINZVC
901: * .1....
902: */
903: static void hd6301_sei(void)
904: {
905: hd6301_reg_CCR |= 1<<hd6301_REG_CCR_I;
906: }
907:
908: /**
909: * SBA : substract accumulator B from accumulator A : A=A-B
910: *
911: * HINZVC
912: * ..****
913: */
914: static void hd6301_sba(void)
915: {
916: Uint16 result;
917:
918: result = hd6301_reg_A - hd6301_reg_B;
919:
920: HD6301_CLR_NZVC;
921: HD6301_SET_FLAGS8(hd6301_reg_A, hd6301_reg_B, result);
922:
923: hd6301_reg_A = result;
924: }
925:
926: /**
927: * CBA : compare accumulator A and accumulator B : A-B
928: *
929: * HINZVC
930: * ..****
931: */
932: static void hd6301_cba(void)
933: {
934: Uint16 result;
935:
936: result = hd6301_reg_A - hd6301_reg_B;
937:
938: HD6301_CLR_NZVC;
939: HD6301_SET_FLAGS8(hd6301_reg_A, hd6301_reg_B, result);
940: }
941:
942: /**
943: * TAB : transfer accumulator A into accumulator B : B=A
944: *
945: * HINZVC
946: * ..**0.
947: */
948: static void hd6301_tab(void)
949: {
950: hd6301_reg_B = hd6301_reg_A;
951:
952: HD6301_CLR_NZV;
953: HD6301_SET_NZ8(hd6301_reg_B);
954: }
955:
956: /**
957: * TBA : transfer accumulator B into accumulator A : A=B
958: *
959: * HINZVC
960: * ..**0.
961: */
962: static void hd6301_tba(void)
963: {
964: hd6301_reg_A = hd6301_reg_B;
965:
966: HD6301_CLR_NZV;
967: HD6301_SET_NZ8(hd6301_reg_A);
968: }
969:
970: /**
971: * XGDX : exchange register X and accumulator D : X<->D
972: *
973: * HINZVC
974: * ......
975: */
976: static void hd6301_xgdx(void)
977: {
978: Uint16 temp;
979:
980: temp = hd6301_reg_X;
981: hd6301_reg_X = (hd6301_reg_A << 8) + hd6301_reg_B;
982: hd6301_reg_A = temp >> 8;
983: hd6301_reg_B = temp;
984: }
985:
986: /**
987: * DAA : converts binary add of BCD characters into BCD format : A=BCD(A)
988: *
989: * HINZVC
990: * ..****
991: */
992: static void hd6301_daa(void)
993: {
994: /* Todo */
995: }
996:
997: /**
998: * SLP : sleep
999: *
1000: * HINZVC
1001: * ......
1002: */
1003: static void hd6301_slp(void)
1004: {
1005: /* Todo */
1006: }
1007:
1008: /**
1009: * ABA : add accumulator A and accumulator B into accumulator A : A=A+B
1010: *
1011: * HINZVC
1012: * *.****
1013: */
1014: static void hd6301_aba(void)
1015: {
1016: Uint16 result;
1017:
1018: result = hd6301_reg_A + hd6301_reg_B;
1019:
1020: HD6301_CLR_HNZVC;
1021: HD6301_SET_FLAGS8(hd6301_reg_A, hd6301_reg_B, result);
1022: HD6301_SET_H(hd6301_reg_A, hd6301_reg_B, result);
1023:
1024: hd6301_reg_A = result;
1025: }
1026:
1027: /**
1028: * BRA : branch always
1029: *
1030: * HINZVC
1031: * ......
1032: */
1033: static void hd6301_bra(void)
1034: {
1035: Sint8 addr;
1036:
1037: addr = hd6301_read_memory(hd6301_reg_PC + 1);
1038: hd6301_reg_PC += addr + 2;
1039: }
1040:
1041: /**
1042: * BRN : branch never
1043: *
1044: * HINZVC
1045: * ......
1046: */
1047: static void hd6301_brn(void)
1048: {
1049: hd6301_reg_PC += 2;
1050: }
1051:
1052: /**
1053: * BHI : branch if higher : C|Z=0
1054: *
1055: * HINZVC
1056: * ......
1057: */
1058: static void hd6301_bhi(void)
1059: {
1060: Sint8 addr;
1061: Uint8 bitC, bitZ;
1062:
1063: bitC = (hd6301_reg_CCR >> hd6301_REG_CCR_C) & 1;
1064: bitZ = (hd6301_reg_CCR >> hd6301_REG_CCR_Z) & 1;
1065: addr = 2;
1066: if ((bitC | bitZ) == 0) {
1067: addr += hd6301_read_memory(hd6301_reg_PC + 1);
1068: }
1069: hd6301_reg_PC += addr;
1070: }
1071:
1072: /**
1073: * BLS : branch if lower or same : C|Z=1
1074: *
1075: * HINZVC
1076: * ......
1077: */
1078: static void hd6301_bls(void)
1079: {
1080: Sint8 addr;
1081: Uint8 bitC, bitZ;
1082:
1083: bitC = (hd6301_reg_CCR >> hd6301_REG_CCR_C) & 1;
1084: bitZ = (hd6301_reg_CCR >> hd6301_REG_CCR_Z) & 1;
1085: addr = 2;
1086: if ((bitC | bitZ) == 1) {
1087: addr += hd6301_read_memory(hd6301_reg_PC + 1);
1088: }
1089: hd6301_reg_PC += addr;
1090: }
1091:
1092: /**
1093: * BCC : branch if carry clear : C=0
1094: *
1095: * HINZVC
1096: * ......
1097: */
1098: static void hd6301_bcc(void)
1099: {
1100: Sint8 addr;
1101: Uint8 bitC;
1102:
1103: bitC = (hd6301_reg_CCR >> hd6301_REG_CCR_C) & 1;
1104: addr = 2;
1105: if (bitC == 0) {
1106: addr += hd6301_read_memory(hd6301_reg_PC + 1);
1107: }
1108: hd6301_reg_PC += addr;
1109: }
1110:
1111: /**
1112: * BCS : branch if carry set : C=1
1113: *
1114: * HINZVC
1115: * ......
1116: */
1117: static void hd6301_bcs(void)
1118: {
1119: Sint8 addr;
1120: Uint8 bitC;
1121:
1122: bitC = (hd6301_reg_CCR >> hd6301_REG_CCR_C) & 1;
1123: addr = 2;
1124: if (bitC == 1) {
1125: addr += hd6301_read_memory(hd6301_reg_PC + 1);
1126: }
1127: hd6301_reg_PC += addr;
1128: }
1129:
1130: /**
1131: * BNE : branch if not equal 0 : Z=0
1132: *
1133: * HINZVC
1134: * ......
1135: */
1136: static void hd6301_bne(void)
1137: {
1138: Sint8 addr;
1139: Uint8 bitZ;
1140:
1141: bitZ = (hd6301_reg_CCR >> hd6301_REG_CCR_Z) & 1;
1142: addr = 2;
1143: if (bitZ == 0) {
1144: addr += hd6301_read_memory(hd6301_reg_PC + 1);
1145: }
1146: hd6301_reg_PC += addr;
1147: }
1148:
1149: /**
1150: * BEQ : branch if equal 0 : Z=1
1151: *
1152: * HINZVC
1153: * ......
1154: */
1155: static void hd6301_beq(void)
1156: {
1157: Sint8 addr;
1158: Uint8 bitZ;
1159:
1160: bitZ = (hd6301_reg_CCR >> hd6301_REG_CCR_Z) & 1;
1161: addr = 2;
1162: if (bitZ == 1) {
1163: addr += hd6301_read_memory(hd6301_reg_PC + 1);
1164: }
1165: hd6301_reg_PC += addr;
1166: }
1167:
1168: /**
1169: * BVC : branch if overflow clear : V=0
1170: *
1171: * HINZVC
1172: * ......
1173: */
1174: static void hd6301_bvc(void)
1175: {
1176: Sint8 addr;
1177: Uint8 bitV;
1178:
1179: bitV = (hd6301_reg_CCR >> hd6301_REG_CCR_V) & 1;
1180: addr = 2;
1181: if (bitV == 0) {
1182: addr += hd6301_read_memory(hd6301_reg_PC + 1);
1183: }
1184: hd6301_reg_PC += addr;
1185: }
1186:
1187: /**
1188: * BVS : branch if overflow set : V=1
1189: *
1190: * HINZVC
1191: * ......
1192: */
1193: static void hd6301_bvs(void)
1194: {
1195: Sint8 addr;
1196: Uint8 bitV;
1197:
1198: bitV = (hd6301_reg_CCR >> hd6301_REG_CCR_V) & 1;
1199: addr = 2;
1200: if (bitV == 1) {
1201: addr += hd6301_read_memory(hd6301_reg_PC + 1);
1202: }
1203: hd6301_reg_PC += addr;
1204: }
1205:
1206: /**
1207: * BPL : branch if plus : N=0
1208: *
1209: * HINZVC
1210: * ......
1211: */
1212: static void hd6301_bpl(void)
1213: {
1214: Sint8 addr;
1215: Uint8 bitN;
1216:
1217: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
1218: addr = 2;
1219: if (bitN == 0) {
1220: addr += hd6301_read_memory(hd6301_reg_PC + 1);
1221: }
1222: hd6301_reg_PC += addr;
1223: }
1224:
1225: /**
1226: * BMI : branch if minus : N=1
1227: *
1228: * HINZVC
1229: * ......
1230: */
1231: static void hd6301_bmi(void)
1232: {
1233: Sint8 addr;
1234: Uint8 bitN;
1235:
1236: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
1237: addr = 2;
1238: if (bitN == 1) {
1239: addr += hd6301_read_memory(hd6301_reg_PC + 1);
1240: }
1241: hd6301_reg_PC += addr;
1242: }
1243:
1244: /**
1245: * BGE : branch if greater or equal to zero : N^V=0
1246: *
1247: * HINZVC
1248: * ......
1249: */
1250: static void hd6301_bge(void)
1251: {
1252: Sint8 addr;
1253: Uint8 bitN, bitV;
1254:
1255: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
1256: bitV = (hd6301_reg_CCR >> hd6301_REG_CCR_V) & 1;
1257: addr = 2;
1258: if ((bitN ^ bitV) == 0) {
1259: addr += hd6301_read_memory(hd6301_reg_PC + 1);
1260: }
1261: hd6301_reg_PC += addr;
1262: }
1263:
1264: /**
1265: * BLT : branch if lower to zero : N^V=1
1266: *
1267: * HINZVC
1268: * ......
1269: */
1270: static void hd6301_blt(void)
1271: {
1272: Sint8 addr;
1273: Uint8 bitN, bitV;
1274:
1275: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
1276: bitV = (hd6301_reg_CCR >> hd6301_REG_CCR_V) & 1;
1277: addr = 2;
1278: if ((bitN ^ bitV) == 1) {
1279: addr += hd6301_read_memory(hd6301_reg_PC + 1);
1280: }
1281: hd6301_reg_PC += addr;
1282: }
1283:
1284: /**
1285: * BGT : branch if greater to zero : Z|(N^V)=0
1286: *
1287: * HINZVC
1288: * ......
1289: */
1290: static void hd6301_bgt(void)
1291: {
1292: Sint8 addr;
1293: Uint8 bitN, bitV, bitZ;
1294:
1295: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
1296: bitV = (hd6301_reg_CCR >> hd6301_REG_CCR_V) & 1;
1297: bitZ = (hd6301_reg_CCR >> hd6301_REG_CCR_Z) & 1;
1298: addr = 2;
1299: if ((bitZ | (bitN ^ bitV)) == 0) {
1300: addr += hd6301_read_memory(hd6301_reg_PC + 1);
1301: }
1302: hd6301_reg_PC += addr;
1303: }
1304:
1305: /**
1306: * BLE : branch if lower or equal to zero : Z|(N^V)=1
1307: *
1308: * HINZVC
1309: * ......
1310: */
1311: static void hd6301_ble(void)
1312: {
1313: Sint8 addr;
1314: Uint8 bitN, bitV, bitZ;
1315:
1316: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
1317: bitV = (hd6301_reg_CCR >> hd6301_REG_CCR_V) & 1;
1318: bitZ = (hd6301_reg_CCR >> hd6301_REG_CCR_Z) & 1;
1319: addr = 2;
1320: if ((bitZ | (bitN ^ bitV)) == 1) {
1321: addr += hd6301_read_memory(hd6301_reg_PC + 1);
1322: }
1323: hd6301_reg_PC += addr;
1324: }
1325:
1326: /**
1327: * TSX : transfer stack pointer to register X : X=SP+1
1328: *
1329: * HINZVC
1330: * ......
1331: */
1332: static void hd6301_tsx(void)
1333: {
1334: hd6301_reg_X = hd6301_reg_SP + 1;
1335: }
1336:
1337: /**
1338: * INS : increment stack pointer : SP=SP+1
1339: *
1340: * HINZVC
1341: * ......
1342: */
1343: static void hd6301_ins(void)
1344: {
1345: ++ hd6301_reg_SP;
1346: }
1347:
1348: /**
1349: * PULA : pull accumulator A from stack : SP=SP+1 ; A=(SP)
1350: *
1351: * HINZVC
1352: * ......
1353: */
1354: static void hd6301_pula(void)
1355: {
1356: ++ hd6301_reg_SP;
1357: hd6301_reg_A = hd6301_read_memory(hd6301_reg_SP);
1358: }
1359:
1360: /**
1361: * PULB : pull accumulator B from stack : SP=SP+1 ; B=(SP)
1362: *
1363: * HINZVC
1364: * ......
1365: */
1366: static void hd6301_pulb(void)
1367: {
1368: ++ hd6301_reg_SP;
1369: hd6301_reg_B = hd6301_read_memory(hd6301_reg_SP);
1370: }
1371:
1372: /**
1373: * DES : decrement stack pointer : SP=SP-1
1374: *
1375: * HINZVC
1376: * ......
1377: */
1378: static void hd6301_des(void)
1379: {
1380: -- hd6301_reg_SP;
1381: }
1382:
1383: /**
1384: * TXS : transfer register X to stack pointer : SP=X-1
1385: *
1386: * HINZVC
1387: * ......
1388: */
1389: static void hd6301_txs(void)
1390: {
1391: hd6301_reg_SP = hd6301_reg_X - 1;
1392: }
1393:
1394: /**
1395: * PSHA : push accumulator A to stack : (SP)=A ; SP=SP-1
1396: *
1397: * HINZVC
1398: * ......
1399: */
1400: static void hd6301_psha(void)
1401: {
1402: hd6301_write_memory(hd6301_reg_SP, hd6301_reg_A);
1403: -- hd6301_reg_SP;
1404: }
1405:
1406: /**
1407: * PSHB : push accumulator B to stack : (SP)=B ; SP=SP-1
1408: *
1409: * HINZVC
1410: * ......
1411: */
1412: static void hd6301_pshb(void)
1413: {
1414: hd6301_write_memory(hd6301_reg_SP, hd6301_reg_B);
1415: -- hd6301_reg_SP;
1416: }
1417:
1418: /**
1419: * PULX : pull register X from stack : SP=SP+1 ; X=(SP)
1420: *
1421: * HINZVC
1422: * ......
1423: */
1424: static void hd6301_pulx(void)
1425: {
1426: hd6301_reg_X = hd6301_read_memory(++hd6301_reg_SP)<<8;
1427: hd6301_reg_X += hd6301_read_memory(++hd6301_reg_SP);
1428: }
1429:
1430: /**
1431: * RTS : return from subroutine
1432: *
1433: * HINZVC
1434: * ......
1435: */
1436: static void hd6301_rts(void)
1437: {
1438: hd6301_reg_PC = hd6301_read_memory(++hd6301_reg_SP)<<8;
1439: hd6301_reg_PC += hd6301_read_memory(++hd6301_reg_SP);
1440: }
1441:
1442: /**
1443: * ABX : add accumulator B to register X : X=X+B
1444: *
1445: * HINZVC
1446: * ......
1447: */
1448: static void hd6301_abx(void)
1449: {
1450: hd6301_reg_X += hd6301_reg_B;
1451: }
1452:
1453: /**
1454: * RTI : return from interrupt
1455: *
1456: * HINZVC
1457: * ******
1458: */
1459: static void hd6301_rti(void)
1460: {
1461: hd6301_reg_CCR = hd6301_read_memory(++hd6301_reg_SP);
1462: hd6301_reg_B = hd6301_read_memory(++hd6301_reg_SP);
1463: hd6301_reg_A = hd6301_read_memory(++hd6301_reg_SP);
1464: hd6301_reg_X = hd6301_read_memory(++hd6301_reg_SP)<<8;
1465: hd6301_reg_X += hd6301_read_memory(++hd6301_reg_SP);
1466: hd6301_reg_PC = hd6301_read_memory(++hd6301_reg_SP)<<8;
1467: hd6301_reg_PC += hd6301_read_memory(++hd6301_reg_SP);
1468: }
1469:
1470: /**
1471: * PSHX : push register X to stack : (SP)=X ; SP=SP-1
1472: *
1473: * HINZVC
1474: * ......
1475: */
1476: static void hd6301_pshx(void)
1477: {
1478: hd6301_write_memory(hd6301_reg_SP--, hd6301_reg_X & 0xff);
1479: hd6301_write_memory(hd6301_reg_SP--, hd6301_reg_X >> 8);
1480: }
1481:
1482: /**
1483: * MUL : multiply unsigned : D=A*B
1484: *
1485: * HINZVC
1486: * .....*
1487: */
1488: static void hd6301_mul(void)
1489: {
1490: Uint16 regD;
1491:
1492: regD = hd6301_reg_B * hd6301_reg_A;
1493: hd6301_reg_A = regD >> 8;
1494: hd6301_reg_B = regD;
1495:
1496: HD6301_CLR_C;
1497: hd6301_reg_CCR |= hd6301_reg_B >> 7;
1498: }
1499:
1500: /**
1501: * WAI : wait for interrupt
1502: *
1503: * HINZVC
1504: * .*....
1505: */
1506: static void hd6301_wai(void)
1507: {
1508: /* Todo */
1509: }
1510:
1511: /**
1512: * SWI : software interrupt
1513: *
1514: * HINZVC
1515: * .1....
1516: */
1517: static void hd6301_swi(void)
1518: {
1519: hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC+1) & 0xff);
1520: hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC+1) >> 8);
1521: hd6301_write_memory(hd6301_reg_SP--, hd6301_reg_X & 0xff);
1522: hd6301_write_memory(hd6301_reg_SP--, hd6301_reg_X >> 8);
1523: hd6301_write_memory(hd6301_reg_SP--, hd6301_reg_A);
1524: hd6301_write_memory(hd6301_reg_SP--, hd6301_reg_B);
1525: hd6301_write_memory(hd6301_reg_SP--, hd6301_reg_CCR);
1526:
1527: hd6301_reg_PC = hd6301_read_memory(0xfffa) << 8;
1528: hd6301_reg_PC += hd6301_read_memory(0xfffb);
1529:
1530: hd6301_reg_CCR |= 1 << hd6301_REG_CCR_I;
1531: }
1532:
1533: /**
1534: * NEGA : negate accumulator A : A=0-A
1535: *
1536: * HINZVC
1537: * ..****
1538: */
1539: static void hd6301_nega(void)
1540: {
1541: Uint8 value;
1542:
1543: value = 0 - hd6301_reg_A;
1544: hd6301_reg_A = value;
1545:
1546: HD6301_CLR_NZVC;
1547: HD6301_SET_NZ8(value);
1548: hd6301_reg_CCR |= (value != 0x0);
1549: hd6301_reg_CCR |= (value == 0x80) << hd6301_REG_CCR_V;
1550: }
1551:
1552: /**
1553: * COMA : complement 1 accumulator A : A=~A
1554: *
1555: * HINZVC
1556: * ..**01
1557: */
1558: static void hd6301_coma(void)
1559: {
1560: hd6301_reg_A = ~hd6301_reg_A;
1561:
1562: HD6301_CLR_NZV;
1563: hd6301_reg_CCR |= 1;
1564: HD6301_SET_NZ8(hd6301_reg_A);
1565: }
1566:
1567: /**
1568: * LSRA : logical shift right, accumulator A : A=A>>1
1569: *
1570: * HINZVC
1571: * ..0***
1572: */
1573: static void hd6301_lsra(void)
1574: {
1575: Uint8 carry;
1576:
1577: carry = hd6301_reg_A & 1;
1578: hd6301_reg_A >>= 1;
1579:
1580: HD6301_CLR_NZVC;
1581: hd6301_reg_CCR |= carry;
1582: HD6301_SET_Z8(hd6301_reg_A);
1583: hd6301_reg_CCR |= ((0 ^ carry) == 1) << hd6301_REG_CCR_V;
1584: }
1585:
1586: /**
1587: * RORA : rotate right, accumulator A : A=A>>1 + carry<<8
1588: *
1589: * HINZVC
1590: * ..****
1591: */
1592: static void hd6301_rora(void)
1593: {
1594: Uint8 carry, result, bitN;
1595:
1596: carry = hd6301_reg_A & 1;
1597: result = (hd6301_reg_CCR & 1) << 7;
1598: result += hd6301_reg_A >> 1;
1599: hd6301_reg_A = result;
1600:
1601: HD6301_CLR_NZVC;
1602: hd6301_reg_CCR |= carry;
1603: HD6301_SET_NZ8(hd6301_reg_A);
1604: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
1605: hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
1606: }
1607:
1608: /**
1609: * ASRA : arithmetic shift right, accumulator A : A=A>>1
1610: *
1611: * HINZVC
1612: * ..****
1613: */
1614: static void hd6301_asra(void)
1615: {
1616: Uint8 carry, bitN;
1617:
1618: carry = hd6301_reg_A & 1;
1619: hd6301_reg_A >>= 1;
1620: hd6301_reg_A |= (hd6301_reg_A & 0x40) << 1;
1621:
1622: HD6301_CLR_NZVC;
1623: hd6301_reg_CCR |= carry;
1624: HD6301_SET_NZ8(hd6301_reg_A);
1625: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
1626: hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
1627: }
1628:
1629: /**
1630: * ASLA : arithmetic shift left, accumulator A : A=A<<1
1631: *
1632: * HINZVC
1633: * ..****
1634: */
1635: static void hd6301_asla(void)
1636: {
1637: Uint8 carry, bitN;
1638:
1639: carry = (hd6301_reg_A & 0X80) >> 7;
1640: hd6301_reg_A <<= 1;
1641:
1642: HD6301_CLR_NZVC;
1643: hd6301_reg_CCR |= carry;
1644: HD6301_SET_NZ8(hd6301_reg_A);
1645: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
1646: hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
1647: }
1648:
1649: /**
1650: * ROLA : rotate left, accumulator A : A=A<<1 +C
1651: *
1652: * HINZVC
1653: * ..****
1654: */
1655: static void hd6301_rola(void)
1656: {
1657: Uint8 carry, result, bitN;
1658:
1659: carry = (hd6301_reg_A & 0x80) >> 7;
1660: result = hd6301_reg_CCR & 1;
1661: result += hd6301_reg_A << 1;
1662: hd6301_reg_A = result;
1663:
1664: HD6301_CLR_NZVC;
1665: hd6301_reg_CCR |= carry;
1666: HD6301_SET_NZ8(hd6301_reg_A);
1667: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
1668: hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
1669: }
1670:
1671: /**
1672: * DECA : decrement accumulator A : A=A-1
1673: *
1674: * HINZVC
1675: * ..***.
1676: */
1677: static void hd6301_deca(void)
1678: {
1679: Uint8 overflow;
1680:
1681: overflow = (hd6301_reg_A == (Sint8)0x80) << hd6301_REG_CCR_V;
1682: -- hd6301_reg_A;
1683:
1684: HD6301_CLR_NZV;
1685: hd6301_reg_CCR |= overflow;
1686: HD6301_SET_NZ8(hd6301_reg_A);
1687: }
1688:
1689: /**
1690: * INCA : increment accumulator A : A=A+1
1691: *
1692: * HINZVC
1693: * ..***.
1694: */
1695: static void hd6301_inca(void)
1696: {
1697: Uint8 overflow;
1698:
1699: overflow = (hd6301_reg_A == 0x7f) << hd6301_REG_CCR_V;
1700: hd6301_reg_A ++;
1701:
1702: HD6301_CLR_NZV;
1703: hd6301_reg_CCR |= overflow;
1704: HD6301_SET_NZ8(hd6301_reg_A);
1705: }
1706:
1707: /**
1708: * TSTA : test zero or minus, accumulator A : A-0
1709: *
1710: * HINZVC
1711: * ..**00
1712: */
1713: static void hd6301_tsta(void)
1714: {
1715: HD6301_CLR_NZVC;
1716: HD6301_SET_NZ8(hd6301_reg_A);
1717: }
1718:
1719: /**
1720: * CLRA : clear accumulator A : A=0
1721: *
1722: * HINZVC
1723: * ..0100
1724: */
1725: static void hd6301_clra(void)
1726: {
1727: hd6301_reg_A = 0;
1728: HD6301_CLR_NZVC;
1729: hd6301_reg_CCR |= 1 << hd6301_REG_CCR_Z;
1730: }
1731:
1732: /**
1733: * NEGB : negate accumulator B : B=0-B
1734: *
1735: * HINZVC
1736: * ..****
1737: */
1738: static void hd6301_negb(void)
1739: {
1740: Uint8 value;
1741:
1742: value = 0 - hd6301_reg_B;
1743: hd6301_reg_B = value;
1744:
1745: HD6301_CLR_NZVC;
1746: HD6301_SET_NZ8(value);
1747: hd6301_reg_CCR |= (value != 0x0);
1748: hd6301_reg_CCR |= (value == 0x80) << hd6301_REG_CCR_V;
1749: }
1750:
1751: /**
1752: * COMB : complement 1 accumulator B : B=~B
1753: *
1754: * HINZVC
1755: * ..**01
1756: */
1757: static void hd6301_comb(void)
1758: {
1759: hd6301_reg_B = ~hd6301_reg_B;
1760: HD6301_CLR_NZVC;
1761: hd6301_reg_CCR |= 1;
1762: HD6301_SET_NZ8(hd6301_reg_B);
1763: }
1764:
1765: /**
1766: * LSRB : logical shift right, accumulator B : B=B>>1
1767: *
1768: * HINZVC
1769: * ..0***
1770: */
1771: static void hd6301_lsrb(void)
1772: {
1773: Uint8 carry;
1774:
1775: carry = hd6301_reg_B & 1;
1776: hd6301_reg_B >>= 1;
1777:
1778: HD6301_CLR_NZVC;
1779: hd6301_reg_CCR |= carry;
1780: HD6301_SET_Z8(hd6301_reg_B);
1781: hd6301_reg_CCR |= ((0 ^ carry) == 1) << hd6301_REG_CCR_V;
1782: }
1783:
1784: /**
1785: * RORB : rotate right, accumulator B : B=B>>1 + carry<<8
1786: *
1787: * HINZVC
1788: * ..****
1789: */
1790: static void hd6301_rorb(void)
1791: {
1792: Uint8 carry, result, bitN;
1793:
1794: carry = hd6301_reg_B & 1;
1795: result = (hd6301_reg_CCR & 1) << 7;
1796: result += hd6301_reg_B >> 1;
1797: hd6301_reg_B = result;
1798:
1799: HD6301_CLR_NZVC;
1800: hd6301_reg_CCR |= carry;
1801: HD6301_SET_NZ8(hd6301_reg_B);
1802: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
1803: hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
1804: }
1805:
1806: /**
1807: * ASRB : arithmetic shift right, accumulator B : B=B>>1
1808: *
1809: * HINZVC
1810: * ..****
1811: */
1812: static void hd6301_asrb(void)
1813: {
1814: Uint8 carry, bitN;
1815:
1816: carry = hd6301_reg_B & 1;
1817: hd6301_reg_B >>= 1;
1818: hd6301_reg_B |= (hd6301_reg_B & 0x40) << 1;
1819:
1820: HD6301_CLR_NZVC;
1821: hd6301_reg_CCR |= carry;
1822: HD6301_SET_NZ8(hd6301_reg_B);
1823: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
1824: hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
1825: }
1826:
1827: /**
1828: * ASLB : arithmetic shift left, accumulator B : B=B<<1
1829: *
1830: * HINZVC
1831: * ..****
1832: */
1833: static void hd6301_aslb(void)
1834: {
1835: Uint8 carry, bitN;
1836:
1837: carry = (hd6301_reg_B & 0x80) >> 7;
1838: hd6301_reg_B <<= 1;
1839:
1840: HD6301_CLR_NZVC;
1841: hd6301_reg_CCR |= carry;
1842: HD6301_SET_NZ8(hd6301_reg_B);
1843: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
1844: hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
1845: }
1846:
1847: /**
1848: * ROLB : rotate left, accumulator B : B=B<<1 +C
1849: *
1850: * HINZVC
1851: * ..****
1852: */
1853: static void hd6301_rolb(void)
1854: {
1855: Uint8 carry, result, bitN;
1856:
1857: carry = (hd6301_reg_B & 0x80) >> 7;
1858: result = hd6301_reg_CCR & 1;
1859: result += hd6301_reg_B << 1;
1860: hd6301_reg_B = result;
1861:
1862: HD6301_CLR_NZVC;
1863: hd6301_reg_CCR |= carry;
1864: HD6301_SET_NZ8(hd6301_reg_B);
1865: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
1866: hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
1867: }
1868:
1869: /**
1870: * DECB : decrement accumulator B : B=B-1
1871: *
1872: * HINZVC
1873: * ..***.
1874: */
1875: static void hd6301_decb(void)
1876: {
1877: Uint8 overflow;
1878:
1879: overflow = (hd6301_reg_B == (Sint8)0x80) << hd6301_REG_CCR_V;
1880: -- hd6301_reg_B;
1881:
1882: HD6301_CLR_NZV;
1883: hd6301_reg_CCR |= overflow;
1884: HD6301_SET_NZ8(hd6301_reg_B);
1885: }
1886:
1887: /**
1888: * INCB : increment accumulator B : B=B+1
1889: *
1890: * HINZVC
1891: * ..***.
1892: */
1893: static void hd6301_incb(void)
1894: {
1895: Uint8 overflow;
1896:
1897: overflow = (hd6301_reg_B == 0x7f) << hd6301_REG_CCR_V;
1898: hd6301_reg_B ++;
1899:
1900: HD6301_CLR_NZV;
1901: hd6301_reg_CCR |= overflow;
1902: HD6301_SET_NZ8(hd6301_reg_B);
1903: }
1904:
1905: /**
1906: * TSTB : test zero or minus, accumulator B : B-0
1907: *
1908: * HINZVC
1909: * ..**00
1910: */
1911: static void hd6301_tstb(void)
1912: {
1913: HD6301_CLR_NZVC;
1914: HD6301_SET_NZ8(hd6301_reg_B);
1915: }
1916:
1917: /**
1918: * CLRB : clear accumulator B : B=0
1919: *
1920: * HINZVC
1921: * ..0100
1922: */
1923: static void hd6301_clrb(void)
1924: {
1925: hd6301_reg_B = 0;
1926: HD6301_CLR_NZVC;
1927: hd6301_reg_CCR |= 1 << hd6301_REG_CCR_Z;
1928: }
1929:
1930: /**
1931: * NEG_IND : negate indexed memory : M=0-M
1932: *
1933: * HINZVC
1934: * ..****
1935: */
1936: static void hd6301_neg_ind(void)
1937: {
1938: Uint8 value;
1939: Uint16 addr;
1940:
1941: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
1942: value = -hd6301_read_memory(addr);
1943: hd6301_write_memory(addr, value);
1944:
1945: HD6301_CLR_NZVC;
1946: hd6301_reg_CCR |= (value != 0x0);
1947: hd6301_reg_CCR |= (value == 0x80) << hd6301_REG_CCR_V;
1948: HD6301_SET_NZ8(value);
1949: }
1950:
1951: /**
1952: * AIM_IND : and immediate indexed memory : M=M&IMM
1953: *
1954: * HINZVC
1955: * ..**0.
1956: */
1957: static void hd6301_aim_ind(void)
1958: {
1959: Uint8 value;
1960: Uint16 addr;
1961:
1962: value = hd6301_read_memory(hd6301_reg_PC+1);
1963: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+2);
1964: value &= hd6301_read_memory(addr);
1965: hd6301_write_memory(addr, value);
1966:
1967: HD6301_CLR_NZV;
1968: HD6301_SET_NZ8(value);
1969: }
1970:
1971: /**
1972: * OIM_IND : or immediate indexed memory : M=M|IMM
1973: *
1974: * HINZVC
1975: * ..**0.
1976: */
1977: static void hd6301_oim_ind(void)
1978: {
1979: Uint8 value;
1980: Uint16 addr;
1981:
1982: value = hd6301_read_memory(hd6301_reg_PC+1);
1983: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+2);
1984: value |= hd6301_read_memory(addr);
1985: hd6301_write_memory(addr, value);
1986:
1987: HD6301_CLR_NZV;
1988: HD6301_SET_NZ8(value);
1989: }
1990:
1991: /**
1992: * COM_IND : complement 1 indexed memory : M=~M
1993: *
1994: * HINZVC
1995: * ..**01
1996: */
1997: static void hd6301_com_ind(void)
1998: {
1999: Uint8 value;
2000: Uint16 addr;
2001:
2002: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
2003: value = ~hd6301_read_memory(addr);
2004: hd6301_write_memory(addr, value);
2005:
2006: HD6301_CLR_NZV;
2007: hd6301_reg_CCR |= 1;
2008: HD6301_SET_NZ8(value);
2009: }
2010:
2011: /**
2012: * LSR_IND : logical shift right indexed memory : M=M>>1
2013: *
2014: * HINZVC
2015: * ..0***
2016: */
2017: static void hd6301_lsr_ind(void)
2018: {
2019: Uint8 value, carry;
2020: Uint16 addr;
2021:
2022: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
2023: value = hd6301_read_memory(addr);
2024:
2025: carry = value & 1;
2026: value >>= 1;
2027: hd6301_write_memory(addr, value);
2028:
2029: HD6301_CLR_NZVC;
2030: hd6301_reg_CCR |= carry;
2031: HD6301_SET_Z8(value);
2032: hd6301_reg_CCR |= ((0 ^ carry) == 1) << hd6301_REG_CCR_V;
2033: }
2034:
2035: /**
2036: * EIM_IND : eor immediate indexed memory : M=M^IMM
2037: *
2038: * HINZVC
2039: * ..**0.
2040: */
2041: static void hd6301_eim_ind(void)
2042: {
2043: Uint8 value;
2044: Uint16 addr;
2045:
2046: value = hd6301_read_memory(hd6301_reg_PC+1);
2047: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+2);
2048: value ^= hd6301_read_memory(addr);
2049: hd6301_write_memory(addr, value);
2050:
2051: HD6301_CLR_NZV;
2052: HD6301_SET_NZ8(value);
2053: }
2054:
2055: /**
2056: * ROR_IND : rotate right indexed memory : M=M>>1 + carry<<8
2057: *
2058: * HINZVC
2059: * ..****
2060: */
2061: static void hd6301_ror_ind(void)
2062: {
2063: Uint8 value, carry, result, bitN;
2064: Uint16 addr;
2065:
2066: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
2067: value = hd6301_read_memory(addr);
2068:
2069: carry = value & 1;
2070: result = (hd6301_reg_CCR & 1) << 7;
2071: result += value >> 1;
2072: hd6301_write_memory(addr, result);
2073:
2074: HD6301_CLR_NZVC;
2075: hd6301_reg_CCR |= carry;
2076: HD6301_SET_NZ8(result);
2077: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
2078: hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
2079: }
2080:
2081: /**
2082: * ASR_IND : arithmetic shift right indexed memory : M=M>>1
2083: *
2084: * HINZVC
2085: * ..****
2086: */
2087: static void hd6301_asr_ind(void)
2088: {
2089: Uint8 value, carry, bitN;
2090: Uint16 addr;
2091:
2092: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
2093: value = hd6301_read_memory(addr);
2094:
2095: carry = value & 1;
2096: value >>= 1;
2097: value |= (value & 0x40) << 1;
2098: hd6301_write_memory(addr, value);
2099:
2100: HD6301_CLR_NZVC;
2101: hd6301_reg_CCR |= carry;
2102: HD6301_SET_NZ8(value);
2103: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
2104: hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
2105: }
2106:
2107: /**
2108: * ASL_IND : arithmetic shift left indexed memory : M=M<<1
2109: *
2110: * HINZVC
2111: * ..****
2112: */
2113: static void hd6301_asl_ind(void)
2114: {
2115: Uint8 value, carry, bitN;
2116: Uint16 addr;
2117:
2118: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
2119: value = hd6301_read_memory(addr);
2120:
2121: carry = (value & 0X80) >> 7;
2122: value <<= 1;
2123: hd6301_write_memory(addr, value);
2124:
2125: HD6301_CLR_NZVC;
2126: hd6301_reg_CCR |= carry;
2127: HD6301_SET_NZ8(value);
2128: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
2129: hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
2130: }
2131:
2132: /**
2133: * ROL_IND : rotate left indexed memory : M=M<<1 + carry
2134: *
2135: * HINZVC
2136: * ..****
2137: */
2138: static void hd6301_rol_ind(void)
2139: {
2140: Uint8 value, carry, result, bitN;
2141: Uint16 addr;
2142:
2143: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
2144: value = hd6301_read_memory(addr);
2145:
2146: result = hd6301_reg_CCR & 1;
2147: carry = (value & 0x80) >> 7;
2148: result += value << 1;
2149: hd6301_write_memory(addr, result);
2150:
2151: HD6301_CLR_NZVC;
2152: hd6301_reg_CCR |= carry;
2153: HD6301_SET_NZ8(result);
2154: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
2155: hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
2156: }
2157:
2158: /**
2159: * DEC_IND : decrement indexed memory : M=M-1
2160: *
2161: * HINZVC
2162: * ..***.
2163: */
2164: static void hd6301_dec_ind(void)
2165: {
2166: Uint8 value, overflow;
2167: Uint16 addr;
2168:
2169: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
2170: value = hd6301_read_memory(addr);
2171:
2172: overflow = (value == 0x80) << hd6301_REG_CCR_V;
2173: --value;
2174: hd6301_write_memory(addr, value);
2175:
2176: HD6301_CLR_NZV;
2177: hd6301_reg_CCR |= overflow;
2178: HD6301_SET_NZ8(value);
2179: }
2180:
2181: /**
2182: * TIM_IND : test immediate indexed memory : M&IMM
2183: *
2184: * HINZVC
2185: * ..**0.
2186: */
2187: static void hd6301_tim_ind(void)
2188: {
2189: Uint8 value;
2190: Uint16 addr;
2191:
2192: value = hd6301_read_memory(hd6301_reg_PC+1);
2193: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+2);
2194: value &= hd6301_read_memory(addr);
2195: hd6301_write_memory(addr, value);
2196:
2197: HD6301_CLR_NZV;
2198: HD6301_SET_NZ8(value);
2199: }
2200:
2201: /**
2202: * INC_IND : increment indexed memory : M=M+1
2203: *
2204: * HINZVC
2205: * ..***.
2206: */
2207: static void hd6301_inc_ind(void)
2208: {
2209: Uint8 value, overflow;
2210: Uint16 addr;
2211:
2212: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
2213: value = hd6301_read_memory(addr);
2214:
2215: overflow = (value == 0x7f) << hd6301_REG_CCR_V;
2216: value ++;
2217: hd6301_write_memory(addr, value);
2218:
2219: HD6301_CLR_NZV;
2220: hd6301_reg_CCR |= overflow;
2221: HD6301_SET_NZ8(value);
2222: }
2223:
2224: /**
2225: * TST_IND : test indexed memory : M-0
2226: *
2227: * HINZVC
2228: * ..**00
2229: */
2230: static void hd6301_tst_ind(void)
2231: {
2232: Uint8 value;
2233: Uint16 addr;
2234:
2235: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
2236: value = hd6301_read_memory(addr);
2237:
2238: HD6301_CLR_NZVC;
2239: HD6301_SET_NZ8(value);
2240: }
2241:
2242: /**
2243: * JMP_IND : jump to indexed memory address : PC=M
2244: *
2245: * HINZVC
2246: * ......
2247: */
2248: static void hd6301_jmp_ind(void)
2249: {
2250: Uint8 value;
2251: Uint16 addr;
2252:
2253: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
2254: value = hd6301_read_memory(addr);
2255: hd6301_reg_PC = value;
2256: }
2257:
2258: /**
2259: * CLR_IND : clear indexed memory : M=0
2260: *
2261: * HINZVC
2262: * ..0100
2263: */
2264: static void hd6301_clr_ind(void)
2265: {
2266: Uint16 addr;
2267:
2268: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
2269: hd6301_write_memory(addr, 0);
2270:
2271: HD6301_CLR_NZVC;
2272: hd6301_reg_CCR |= 1 << hd6301_REG_CCR_Z;
2273: }
2274:
2275: /**
2276: * NEG_EXT : negate extended memory : M=0-M
2277: *
2278: * HINZVC
2279: * ..****
2280: */
2281: static void hd6301_neg_ext(void)
2282: {
2283: Uint8 value;
2284: Uint16 addr;
2285:
2286: addr = hd6301_get_memory_ext();
2287: value = -hd6301_read_memory(addr);
2288: hd6301_write_memory(addr, value);
2289:
2290: HD6301_CLR_NZVC;
2291: hd6301_reg_CCR |= (value != 0x0);
2292: hd6301_reg_CCR |= (value == 0x80) << hd6301_REG_CCR_V;
2293: HD6301_SET_NZ8(value);
2294: }
2295:
2296: /**
2297: * AIM_DIR : and immediate direct memory address : M=M&IMM
2298: *
2299: * HINZVC
2300: * ..**0.
2301: */
2302: static void hd6301_aim_dir(void)
2303: {
2304: Uint8 value;
2305: Uint16 addr;
2306:
2307: value = hd6301_read_memory(hd6301_reg_PC+1);
2308: addr = hd6301_read_memory(hd6301_reg_PC+2);
2309: value &= hd6301_read_memory(addr);
2310: hd6301_write_memory(addr, value);
2311:
2312: HD6301_CLR_NZV;
2313: HD6301_SET_NZ8(value);
2314: }
2315:
2316: /**
2317: * OIM_DIR : or immediate direct memory address : M=M|IMM
2318: *
2319: * HINZVC
2320: * ..**0.
2321: */
2322: static void hd6301_oim_dir(void)
2323: {
2324: Uint8 value;
2325: Uint16 addr;
2326:
2327: value = hd6301_read_memory(hd6301_reg_PC+1);
2328: addr = hd6301_read_memory(hd6301_reg_PC+2);
2329: value |= hd6301_read_memory(addr);
2330: hd6301_write_memory(addr, value);
2331:
2332: HD6301_CLR_NZV;
2333: HD6301_SET_NZ8(value);
2334: }
2335:
2336: /**
2337: * COM_EXT : complement 1 extended memory : M=~M
2338: *
2339: * HINZVC
2340: * ..**01
2341: */
2342: static void hd6301_com_ext(void)
2343: {
2344: Uint8 value;
2345: Uint16 addr;
2346:
2347: addr = hd6301_get_memory_ext();
2348: value = ~hd6301_read_memory(addr);
2349: hd6301_write_memory(addr, value);
2350:
2351: HD6301_CLR_NZV;
2352: hd6301_reg_CCR |= 1;
2353: HD6301_SET_NZ8(value);
2354: }
2355:
2356: /**
2357: * LSR_EXT : logical shift right extended memory : M=M>>1
2358: *
2359: * HINZVC
2360: * ..0***
2361: */
2362: static void hd6301_lsr_ext(void)
2363: {
2364: Uint8 value, carry;
2365: Uint16 addr;
2366:
2367: addr = hd6301_get_memory_ext();
2368: value = hd6301_read_memory(addr);
2369:
2370: carry = value & 1;
2371: value >>= 1;
2372: hd6301_write_memory(addr, value);
2373:
2374: HD6301_CLR_NZVC;
2375: hd6301_reg_CCR |= carry;
2376: HD6301_SET_Z8(value);
2377: hd6301_reg_CCR |= ((0 ^ carry) == 1) << hd6301_REG_CCR_V;
2378: }
2379:
2380: /**
2381: * EIM_DIR : eor immediate direct memory address : M=M^IMM
2382: *
2383: * HINZVC
2384: * ..**0.
2385: */
2386: static void hd6301_eim_dir(void)
2387: {
2388: Uint8 value;
2389: Uint16 addr;
2390:
2391: value = hd6301_read_memory(hd6301_reg_PC+1);
2392: addr = hd6301_read_memory(hd6301_reg_PC+2);
2393: value ^= hd6301_read_memory(addr);
2394: hd6301_write_memory(addr, value);
2395:
2396: HD6301_CLR_NZV;
2397: HD6301_SET_NZ8(value);
2398: }
2399:
2400: /**
2401: * ROR_EXT : rotate right extended memory : M=M>>1 + carry<<8
2402: *
2403: * HINZVC
2404: * ..****
2405: */
2406: static void hd6301_ror_ext(void)
2407: {
2408: Uint8 value, carry, result, bitN;
2409: Uint16 addr;
2410:
2411: addr = hd6301_get_memory_ext();
2412: value = hd6301_read_memory(addr);
2413:
2414: result = (hd6301_reg_CCR & 1) << 7;
2415: carry = value & 1;
2416: result += value >> 1;
2417: hd6301_write_memory(addr, result);
2418:
2419: HD6301_CLR_NZVC;
2420: hd6301_reg_CCR |= carry;
2421: HD6301_SET_NZ8(value);
2422: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
2423: hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
2424: }
2425:
2426: /**
2427: * ASR_EXT : arithmetic shift right extended memory : M=M>>1
2428: *
2429: * HINZVC
2430: * ..****
2431: */
2432: static void hd6301_asr_ext(void)
2433: {
2434: Uint8 value, carry, bitN;
2435: Uint16 addr;
2436:
2437: addr = hd6301_get_memory_ext();
2438: value = hd6301_read_memory(addr);
2439:
2440: carry = value & 1;
2441: value >>= 1;
2442: value |= (value & 0x40) << 1;
2443: hd6301_write_memory(addr, value);
2444:
2445: HD6301_CLR_NZVC;
2446: hd6301_reg_CCR |= carry;
2447: HD6301_SET_NZ8(value);
2448: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
2449: hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
2450: }
2451:
2452: /**
2453: * ASL_EXT : arithmetic shift left extended memory : M=M<<1
2454: *
2455: * HINZVC
2456: * ..****
2457: */
2458: static void hd6301_asl_ext(void)
2459: {
2460: Uint8 value, carry, bitN;
2461: Uint16 addr;
2462:
2463: addr = hd6301_get_memory_ext();
2464: value = hd6301_read_memory(addr);
2465:
2466: carry = (value & 0X80) >> 7;
2467: value <<= 1;
2468: hd6301_write_memory(addr, value);
2469:
2470: HD6301_CLR_NZVC;
2471: hd6301_reg_CCR |= carry;
2472: HD6301_SET_NZ8(value);
2473: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
2474: hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
2475: }
2476:
2477: /**
2478: * ROL_EXT : rotate left extended memory : M=M<<1 + carry
2479: *
2480: * HINZVC
2481: * ..****
2482: */
2483: static void hd6301_rol_ext(void)
2484: {
2485: Uint8 value, carry, result, bitN;
2486: Uint16 addr;
2487:
2488: addr = hd6301_get_memory_ext();
2489: value = hd6301_read_memory(addr);
2490:
2491: result = hd6301_reg_CCR & 1;
2492: carry = (value & 0x80) >> 7;
2493: result += value << 1;
2494: hd6301_write_memory(addr, result);
2495:
2496: HD6301_CLR_NZVC;
2497: hd6301_reg_CCR |= carry;
2498: HD6301_SET_NZ8(value);
2499: bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
2500: hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
2501: }
2502:
2503: /**
2504: * DEC_EXT : decrement extended memory : M=M-1
2505: *
2506: * HINZVC
2507: * ..***.
2508: */
2509: static void hd6301_dec_ext(void)
2510: {
2511: Uint8 value, overflow;
2512: Uint16 addr;
2513:
2514: addr = hd6301_get_memory_ext();
2515: value = hd6301_read_memory(addr);
2516:
2517: overflow = (value == 0x80) << hd6301_REG_CCR_V;
2518: --value;
2519: hd6301_write_memory(addr, value);
2520:
2521: HD6301_CLR_NZV;
2522: hd6301_reg_CCR |= overflow;
2523: HD6301_SET_NZ8(value);
2524: }
2525:
2526: /**
2527: * TIM_DIR : test direct memory address value : M&IMM
2528: *
2529: * HINZVC
2530: * ..**0.
2531: */
2532: static void hd6301_tim_dir(void)
2533: {
2534: Uint8 value;
2535: Uint16 addr;
2536:
2537: value = hd6301_read_memory(hd6301_reg_PC+1);
2538: addr = hd6301_read_memory(hd6301_reg_PC+2);
2539: value &= hd6301_read_memory(addr);
2540: hd6301_write_memory(addr, value);
2541:
2542: HD6301_CLR_NZV;
2543: HD6301_SET_NZ8(value);
2544: }
2545:
2546: /**
2547: * INC_EXT : increment extended memory : M=M+1
2548: *
2549: * HINZVC
2550: * ..***.
2551: */
2552: static void hd6301_inc_ext(void)
2553: {
2554: Uint8 value, overflow;
2555: Uint16 addr;
2556:
2557: addr = hd6301_get_memory_ext();
2558: value = hd6301_read_memory(addr);
2559:
2560: overflow = (value == 0x7f) << hd6301_REG_CCR_V;
2561: value ++;
2562: hd6301_write_memory(addr, value);
2563:
2564: HD6301_CLR_NZV;
2565: hd6301_reg_CCR |= overflow;
2566: HD6301_SET_NZ8(value);
2567: }
2568:
2569: /**
2570: * TST_EXT : test extended memory : M-0
2571: *
2572: * HINZVC
2573: * ..**00
2574: */
2575: static void hd6301_tst_ext(void)
2576: {
2577: Uint8 value;
2578: Uint16 addr;
2579:
2580: addr = hd6301_get_memory_ext();
2581: value = hd6301_read_memory(addr);
2582:
2583: HD6301_CLR_NZVC;
2584: HD6301_SET_NZ8(value);
2585: }
2586:
2587: /**
2588: * JMP_EXT : jump to extended memory address : PC=M
2589: *
2590: * HINZVC
2591: * ......
2592: */
2593: static void hd6301_jmp_ext(void)
2594: {
2595: Uint8 value;
2596: Uint16 addr;
2597:
2598: addr = hd6301_get_memory_ext();
2599: value = hd6301_read_memory(addr);
2600:
2601: hd6301_reg_PC = value;
2602: }
2603:
2604: /**
2605: * CLR_EXT : clear extended memory : M=0
2606: *
2607: * HINZVC
2608: * ..0100
2609: */
2610: static void hd6301_clr_ext(void)
2611: {
2612: Uint16 addr;
2613:
2614: addr = hd6301_get_memory_ext();
2615: hd6301_write_memory(addr, 0);
2616:
2617: HD6301_CLR_NZVC;
2618: hd6301_reg_CCR |= 1 << hd6301_REG_CCR_Z;
2619: }
2620:
2621: /**
2622: * SUBA_IMM : substract immediate value from accumulator A : A=A-M
2623: *
2624: * HINZVC
2625: * ..****
2626: */
2627: static void hd6301_suba_imm(void)
2628: {
2629: Uint8 value;
2630: Uint16 result;
2631:
2632: value = hd6301_read_memory(hd6301_reg_PC+1);
2633: result = hd6301_reg_A - value;
2634:
2635: HD6301_CLR_NZVC;
2636: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
2637:
2638: hd6301_reg_A = result;
2639: }
2640:
2641: /**
2642: * CMPA_IMM : compare immediate value to accumulator A : A-M
2643: *
2644: * HINZVC
2645: * ..****
2646: */
2647: static void hd6301_cmpa_imm(void)
2648: {
2649: Uint8 value;
2650: Uint16 result;
2651:
2652: value = hd6301_read_memory(hd6301_reg_PC+1);
2653: result = hd6301_reg_A - value;
2654:
2655: HD6301_CLR_NZVC;
2656: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
2657: }
2658:
2659: /**
2660: * SBCA_IMM : substract with carry immediate value from accumulator A : A=A-M-C
2661: *
2662: * HINZVC
2663: * ..****
2664: */
2665: static void hd6301_sbca_imm(void)
2666: {
2667: Uint8 value, carry;
2668: Uint16 result;
2669:
2670: carry = hd6301_REG_CCR_C & 1;
2671: value = hd6301_read_memory(hd6301_reg_PC+1);
2672: result = hd6301_reg_A - value - carry;
2673:
2674: HD6301_CLR_NZVC;
2675: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
2676:
2677: hd6301_reg_A = result;
2678: }
2679:
2680: /**
2681: * SUBD_IMM : substract immediate value from accumulator D : D=D-MM
2682: *
2683: * HINZVC
2684: * ..****
2685: */
2686: static void hd6301_subd_imm(void)
2687: {
2688: Uint16 value, regD;
2689: Uint32 result;
2690:
2691: value = hd6301_read_memory(hd6301_reg_PC+1) << 8;
2692: value += hd6301_read_memory(hd6301_reg_PC+2);
2693: regD = (hd6301_reg_A << 8) + hd6301_reg_B;
2694: result = regD - value;
2695:
2696: hd6301_reg_A = (result >> 8) & 0xff;
2697: hd6301_reg_B = result & 0xff;
2698:
2699: HD6301_CLR_NZVC;
2700: HD6301_SET_FLAGS16(regD, value, result);
2701: }
2702:
2703: /**
2704: * ANDA_IMM : and immediate value with accumulator A : A=A&M
2705: *
2706: * HINZVC
2707: * ..**0.
2708: */
2709: static void hd6301_anda_imm(void)
2710: {
2711: hd6301_reg_A &= hd6301_read_memory(hd6301_reg_PC+1);
2712:
2713: HD6301_CLR_NZV;
2714: HD6301_SET_NZ8(hd6301_reg_A);
2715: }
2716:
2717: /**
2718: * BITA_IMM : bit test immediate value with accumulator A : A&M
2719: *
2720: * HINZVC
2721: * ..**0.
2722: */
2723: static void hd6301_bita_imm(void)
2724: {
2725: Uint8 value;
2726:
2727: value = hd6301_reg_A & hd6301_read_memory(hd6301_reg_PC+1);
2728:
2729: HD6301_CLR_NZV;
2730: HD6301_SET_NZ8(value);
2731: }
2732:
2733: /**
2734: * LDAA_IMM : load accumulator A with immediate value : A=M
2735: *
2736: * HINZVC
2737: * ..**0.
2738: */
2739: static void hd6301_ldaa_imm(void)
2740: {
2741: hd6301_reg_A = hd6301_read_memory(hd6301_reg_PC+1);
2742:
2743: HD6301_CLR_NZV;
2744: HD6301_SET_NZ8(hd6301_reg_A);
2745: }
2746:
2747: /**
2748: * EORA_IMM : exclusive or immediate value with accumulator A : A=A^M
2749: *
2750: * HINZVC
2751: * ..**0.
2752: */
2753: static void hd6301_eora_imm(void)
2754: {
2755: hd6301_reg_A ^= hd6301_read_memory(hd6301_reg_PC+1);
2756:
2757: HD6301_CLR_NZV;
2758: HD6301_SET_NZ8(hd6301_reg_A);
2759: }
2760:
2761: /**
2762: * ADCA_IMM : add with carry immediate value to accumulator A : A=A+M+C
2763: *
2764: * HINZVC
2765: * *.****
2766: */
2767: static void hd6301_adca_imm(void)
2768: {
2769: Uint8 value, carry;
2770: Uint16 result;
2771:
2772: carry = hd6301_REG_CCR_C & 1;
2773: value = hd6301_read_memory(hd6301_reg_PC+1);
2774: result = hd6301_reg_A + value + carry;
2775:
2776: HD6301_CLR_HNZVC;
2777: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
2778: HD6301_SET_H(hd6301_reg_A, value, result);
2779:
2780: hd6301_reg_A = result;
2781: }
2782:
2783: /**
2784: * ORAA_IMM : inclusive or accumulator A with immediate value : A=A|M
2785: *
2786: * HINZVC
2787: * ..**0.
2788: */
2789: static void hd6301_oraa_imm(void)
2790: {
2791: hd6301_reg_A |= hd6301_read_memory(hd6301_reg_PC+1);
2792:
2793: HD6301_CLR_NZV;
2794: HD6301_SET_NZ8(hd6301_reg_A);
2795: }
2796:
2797: /**
2798: * ADDA_IMM : add immediate value with accumulator A : A=A+M
2799: *
2800: * HINZVC
2801: * *.****
2802: */
2803: static void hd6301_adda_imm(void)
2804: {
2805: Uint8 value;
2806: Uint16 result;
2807:
2808: value = hd6301_read_memory(hd6301_reg_PC+1);
2809: result = hd6301_reg_A + value;
2810:
2811: HD6301_CLR_HNZVC;
2812: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
2813: HD6301_SET_H(hd6301_reg_A, value, result);
2814:
2815: hd6301_reg_A = result;
2816: }
2817:
2818: /**
2819: * CPX_IMM : compare index register with immediate value : X-MM
2820: *
2821: * HINZVC
2822: * ..****
2823: */
2824: static void hd6301_cpx_imm(void)
2825: {
2826: Uint16 value;
2827: Uint32 result;
2828:
2829: value = hd6301_read_memory(hd6301_reg_PC+1) << 8;
2830: value += hd6301_read_memory(hd6301_reg_PC+2);
2831: result = hd6301_reg_X - value;
2832:
2833: HD6301_CLR_NZVC;
2834: HD6301_SET_FLAGS16(hd6301_reg_X, value, result);
2835: }
2836:
2837: /**
2838: * BSR : branch to subroutine
2839: *
2840: * HINZVC
2841: * ......
2842: */
2843: static void hd6301_bsr(void)
2844: {
2845: Sint8 addr;
2846:
2847: hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC + 2) & 0xff);
2848: hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC + 2) >> 8);
2849:
2850: addr = hd6301_read_memory(hd6301_reg_PC + 1);
2851: hd6301_reg_PC += addr + 2;
2852: }
2853:
2854: /**
2855: * LDS_IMM : load stack pointer with immediate value : SP=MM
2856: *
2857: * HINZVC
2858: * ..**0.
2859: */
2860: static void hd6301_lds_imm(void)
2861: {
2862: Uint16 value;
2863:
2864: value = hd6301_read_memory(hd6301_reg_PC+1) << 8;
2865: value += hd6301_read_memory(hd6301_reg_PC+2);
2866: hd6301_reg_SP = value;
2867:
2868: HD6301_CLR_NZV;
2869: HD6301_SET_NZ16(value);
2870: }
2871:
2872: /**
2873: * SUBA_DIR : substract direct memory address value from accumulator A : A=A-M
2874: *
2875: * HINZVC
2876: * ..****
2877: */
2878: static void hd6301_suba_dir(void)
2879: {
2880: Uint8 value;
2881: Uint16 result, addr;
2882:
2883: addr = hd6301_read_memory(hd6301_reg_PC+1);
2884: value = hd6301_read_memory(addr);
2885: result = hd6301_reg_A - value;
2886:
2887: HD6301_CLR_NZVC;
2888: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
2889:
2890: hd6301_reg_A = result;
2891: }
2892:
2893: /**
2894: * CMPA_DIR : compare direct memory address value to accumulator A : A-M
2895: *
2896: * HINZVC
2897: * ..****
2898: */
2899: static void hd6301_cmpa_dir(void)
2900: {
2901: Uint8 value;
2902: Uint16 addr, result;
2903:
2904: addr = hd6301_read_memory(hd6301_reg_PC+1);
2905: value = hd6301_read_memory(addr);
2906: result = hd6301_reg_A - value;
2907:
2908: HD6301_CLR_NZVC;
2909: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
2910: }
2911:
2912: /**
2913: * SBCA_DIR : substract with carry direct memory address value from accumulator A : A=A-M-C
2914: *
2915: * HINZVC
2916: * ..****
2917: */
2918: static void hd6301_sbca_dir(void)
2919: {
2920: Uint8 value, carry;
2921: Uint16 addr, result;
2922:
2923: carry = hd6301_REG_CCR_C & 1;
2924: addr = hd6301_read_memory(hd6301_reg_PC+1);
2925: value = hd6301_read_memory(addr);
2926: result = hd6301_reg_A - value - carry;
2927:
2928: HD6301_CLR_NZVC;
2929: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
2930:
2931: hd6301_reg_A = result;
2932: }
2933:
2934: /**
2935: * SUBD_DIR : substract direct memory address value from accumulator D : D=D-MM
2936: *
2937: * HINZVC
2938: * ..****
2939: */
2940: static void hd6301_subd_dir(void)
2941: {
2942: Uint16 addr, value, regD;
2943: Uint32 result;
2944:
2945: addr = hd6301_read_memory(hd6301_reg_PC+1);
2946: value = hd6301_read_memory(addr) << 8;
2947: value += hd6301_read_memory(addr+1);
2948: regD = (hd6301_reg_A << 8) + hd6301_reg_B;
2949: result = regD - value;
2950:
2951: hd6301_reg_A = (result >> 8) & 0xff;
2952: hd6301_reg_B = result & 0xff;
2953:
2954: HD6301_CLR_NZVC;
2955: HD6301_SET_FLAGS16(regD, value, result);
2956: }
2957:
2958: /**
2959: * ANDA_DIR : and direct memory address value with accumulator A : A=A&M
2960: *
2961: * HINZVC
2962: * ..**0.
2963: */
2964: static void hd6301_anda_dir(void)
2965: {
2966: Uint16 addr;
2967:
2968: addr = hd6301_read_memory(hd6301_reg_PC+1);
2969: hd6301_reg_A &= hd6301_read_memory(addr);
2970:
2971: HD6301_CLR_NZV;
2972: HD6301_SET_NZ8(hd6301_reg_A);
2973: }
2974:
2975: /**
2976: * BITA_DIR : bit test direct memory address value with accumulator A : A&M
2977: *
2978: * HINZVC
2979: * ..**0.
2980: */
2981: static void hd6301_bita_dir(void)
2982: {
2983: Uint8 value;
2984: Uint16 addr;
2985:
2986: addr = hd6301_read_memory(hd6301_reg_PC+1);
2987: value = hd6301_reg_A & hd6301_read_memory(addr);
2988:
2989: HD6301_CLR_NZV;
2990: HD6301_SET_NZ8(value);
2991: }
2992:
2993: /**
2994: * LDAA_DIR : load accumulator A with direct memory address value : A=M
2995: *
2996: * HINZVC
2997: * ..**0.
2998: */
2999: static void hd6301_ldaa_dir(void)
3000: {
3001: Uint16 addr;
3002:
3003: addr = hd6301_read_memory(hd6301_reg_PC+1);
3004: hd6301_reg_A = hd6301_read_memory(addr);
3005:
3006: HD6301_CLR_NZV;
3007: HD6301_SET_NZ8(hd6301_reg_A);
3008: }
3009:
3010: /**
3011: * STAA_DIR : store accumulator A into direct memory address value : M=A
3012: *
3013: * HINZVC
3014: * ..**0.
3015: */
3016: static void hd6301_staa_dir(void)
3017: {
3018: Uint16 addr;
3019:
3020: addr = hd6301_read_memory(hd6301_reg_PC+1);
3021: hd6301_write_memory(addr, hd6301_reg_A);
3022:
3023: HD6301_CLR_NZV;
3024: HD6301_SET_NZ8(hd6301_reg_A);
3025: }
3026:
3027: /**
3028: * EORA_DIR : exclusive or direct memory address value with accumulator A : A=A^M
3029: *
3030: * HINZVC
3031: * ..**0.
3032: */
3033: static void hd6301_eora_dir(void)
3034: {
3035: Uint16 addr;
3036:
3037: addr = hd6301_read_memory(hd6301_reg_PC+1);
3038: hd6301_reg_A ^= hd6301_read_memory(addr);
3039:
3040: HD6301_CLR_NZV;
3041: HD6301_SET_NZ8(hd6301_reg_A);
3042: }
3043:
3044: /**
3045: * ADCA_DIR : add with carry direct memory address value to accumulator A : A=A+M+C
3046: *
3047: * HINZVC
3048: * *.****
3049: */
3050: static void hd6301_adca_dir(void)
3051: {
3052: Uint8 value, carry;
3053: Uint16 addr, result;
3054:
3055: carry = hd6301_REG_CCR_C & 1;
3056: addr = hd6301_read_memory(hd6301_reg_PC+1);
3057: value = hd6301_read_memory(addr);
3058: result = hd6301_reg_A + value + carry;
3059:
3060: HD6301_CLR_HNZVC;
3061: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
3062: HD6301_SET_H(hd6301_reg_A, value, result);
3063:
3064: hd6301_reg_A = result;
3065: }
3066:
3067: /**
3068: * ORAA_DIR : inclusive or accumulator A with direct memory address value : A=A|M
3069: *
3070: * HINZVC
3071: * ..**0.
3072: */
3073: static void hd6301_oraa_dir(void)
3074: {
3075: Uint16 addr;
3076:
3077: addr = hd6301_read_memory(hd6301_reg_PC+1);
3078: hd6301_reg_A |= hd6301_read_memory(addr);
3079:
3080: HD6301_CLR_NZV;
3081: HD6301_SET_NZ8(hd6301_reg_A);
3082: }
3083:
3084: /**
3085: * ADDA_DIR : add direct memory address value with accumulator A : A=A+M
3086: *
3087: * HINZVC
3088: * *.****
3089: */
3090: static void hd6301_adda_dir(void)
3091: {
3092: Uint8 value;
3093: Uint16 addr, result;
3094:
3095: addr = hd6301_read_memory(hd6301_reg_PC+1);
3096: value = hd6301_read_memory(addr);
3097: result = hd6301_reg_A + value;
3098:
3099: HD6301_CLR_NZVC;
3100: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
3101: HD6301_SET_H(hd6301_reg_A, value, result);
3102:
3103: hd6301_reg_A = result;
3104: }
3105:
3106: /**
3107: * CPX_DIR : compare index register with direct memory address value : X-MM
3108: *
3109: * HINZVC
3110: * ..****
3111: */
3112: static void hd6301_cpx_dir(void)
3113: {
3114: Uint16 addr, value;
3115: Uint32 result;
3116:
3117: addr = hd6301_read_memory(hd6301_reg_PC+1);
3118: value = hd6301_read_memory(addr) << 8;
3119: value += hd6301_read_memory(addr+1);
3120: result = hd6301_reg_X - value;
3121:
3122: HD6301_CLR_NZVC;
3123: HD6301_SET_FLAGS16(hd6301_reg_X, value, result);
3124: }
3125:
3126: /**
3127: * JSR_DIR : jump to subroutine at direct memory address
3128: *
3129: * HINZVC
3130: * ......
3131: */
3132: static void hd6301_jsr_dir(void)
3133: {
3134: Uint16 addr;
3135:
3136: hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC + 2) & 0xff);
3137: hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC + 2) >> 8);
3138:
3139: addr = hd6301_read_memory(hd6301_reg_PC + 1);
3140: hd6301_reg_PC += addr + 2;
3141: }
3142:
3143: /**
3144: * LDS_DIR : load stack pointer with direct memory address value : SP=MM
3145: *
3146: * HINZVC
3147: * ..**0.
3148: */
3149: static void hd6301_lds_dir(void)
3150: {
3151: Uint16 addr;
3152:
3153: addr = hd6301_read_memory(hd6301_reg_PC+1);
3154: hd6301_reg_SP = hd6301_read_memory(addr) << 8;
3155: hd6301_reg_SP += hd6301_read_memory(addr+1);
3156:
3157: HD6301_CLR_NZV;
3158: HD6301_SET_NZ16(hd6301_reg_SP);
3159: }
3160:
3161: /**
3162: * STS_DIR : store stack pointer into direct memory address value : MM=SP
3163: *
3164: * HINZVC
3165: * ..**0.
3166: */
3167: static void hd6301_sts_dir(void)
3168: {
3169: Uint16 addr;
3170:
3171: addr = hd6301_read_memory(hd6301_reg_PC+1);
3172: hd6301_write_memory(addr, hd6301_reg_SP >> 8);
3173: hd6301_write_memory(addr+1, hd6301_reg_SP & 8);
3174:
3175: HD6301_CLR_NZV;
3176: HD6301_SET_NZ16(hd6301_reg_SP);
3177: }
3178:
3179: /**
3180: * SUBA_IND : substract indexed memory address value from accumulator A : A=A-M
3181: *
3182: * HINZVC
3183: * ..****
3184: */
3185: static void hd6301_suba_ind(void)
3186: {
3187: Uint8 value;
3188: Uint16 result, addr;
3189:
3190: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
3191: value = hd6301_read_memory(addr);
3192: result = hd6301_reg_A - value;
3193:
3194: HD6301_CLR_NZVC;
3195: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
3196:
3197: hd6301_reg_A = result;
3198: }
3199:
3200: /**
3201: * CMPA_IND : compare indexed memory address value to accumulator A : A-M
3202: *
3203: * HINZVC
3204: * ..****
3205: */
3206: static void hd6301_cmpa_ind(void)
3207: {
3208: Uint8 value;
3209: Uint16 addr, result;
3210:
3211: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
3212: value = hd6301_read_memory(addr);
3213: result = hd6301_reg_A - value;
3214:
3215: HD6301_CLR_NZVC;
3216: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
3217: }
3218:
3219: /**
3220: * SBCA_IND : substract with carry indexed memory address value from accumulator A : A=A-M-C
3221: *
3222: * HINZVC
3223: * ..****
3224: */
3225: static void hd6301_sbca_ind(void)
3226: {
3227: Uint8 value, carry;
3228: Uint16 addr, result;
3229:
3230: carry = hd6301_REG_CCR_C & 1;
3231: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
3232: value = hd6301_read_memory(addr);
3233: result = hd6301_reg_A - value - carry;
3234:
3235: HD6301_CLR_NZVC;
3236: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
3237:
3238: hd6301_reg_A = result;
3239: }
3240:
3241: /**
3242: * SUBD_IND : substract indexed memory address value from accumulator D : D=D-MM
3243: *
3244: * HINZVC
3245: * ..****
3246: */
3247: static void hd6301_subd_ind(void)
3248: {
3249: Uint16 addr, value, regD;
3250: Uint32 result;
3251:
3252: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
3253: value = hd6301_read_memory(addr) << 8;
3254: value += hd6301_read_memory(addr+1);
3255: regD = (hd6301_reg_A << 8) + hd6301_reg_B;
3256: result = regD - value;
3257:
3258: hd6301_reg_A = (result >> 8) & 0xff;
3259: hd6301_reg_B = result & 0xff;
3260:
3261: HD6301_CLR_NZVC;
3262: HD6301_SET_FLAGS16(regD, value, result);
3263: }
3264:
3265: /**
3266: * ANDA_IND : and indexed memory address value with accumulator A : A=A&M
3267: *
3268: * HINZVC
3269: * ..**0.
3270: */
3271: static void hd6301_anda_ind(void)
3272: {
3273: Uint16 addr;
3274:
3275: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
3276: hd6301_reg_A &= hd6301_read_memory(addr);
3277:
3278: HD6301_CLR_NZV;
3279: HD6301_SET_NZ8(hd6301_reg_A);
3280: }
3281:
3282: /**
3283: * BITA_IND : bit test indexed memory address value with accumulator A : A&M
3284: *
3285: * HINZVC
3286: * ..**0.
3287: */
3288: static void hd6301_bita_ind(void)
3289: {
3290: Uint8 value;
3291: Uint16 addr;
3292:
3293: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
3294: value = hd6301_reg_A & hd6301_read_memory(addr);
3295:
3296: HD6301_CLR_NZV;
3297: HD6301_SET_NZ8(value);
3298: }
3299:
3300: /**
3301: * LDAA_IND : load accumulator A with indexed memory address value : A=M
3302: *
3303: * HINZVC
3304: * ..**0.
3305: */
3306: static void hd6301_ldaa_ind(void)
3307: {
3308: Uint16 addr;
3309:
3310: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
3311: hd6301_reg_A = hd6301_read_memory(addr);
3312:
3313: HD6301_CLR_NZV;
3314: HD6301_SET_NZ8(hd6301_reg_A);
3315: }
3316:
3317: /**
3318: * STAA_IND : store accumulator A into indexed memory address value : M=A
3319: *
3320: * HINZVC
3321: * ..**0.
3322: */
3323: static void hd6301_staa_ind(void)
3324: {
3325: Uint16 addr;
3326:
3327: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
3328: hd6301_write_memory(addr, hd6301_reg_A);
3329:
3330: HD6301_CLR_NZV;
3331: HD6301_SET_NZ8(hd6301_reg_A);
3332: }
3333:
3334: /**
3335: * EORA_IND : exclusive or indexed memory address value with accumulator A : A=A^M
3336: *
3337: * HINZVC
3338: * ..**0.
3339: */
3340: static void hd6301_eora_ind(void)
3341: {
3342: Uint16 addr;
3343:
3344: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
3345: hd6301_reg_A ^= hd6301_read_memory(addr);
3346:
3347: HD6301_CLR_NZV;
3348: HD6301_SET_NZ8(hd6301_reg_A);
3349: }
3350:
3351: /**
3352: * ADCA_IND : add with carry indexed memory address value to accumulator A : A=A+M+C
3353: *
3354: * HINZVC
3355: * *.****
3356: */
3357: static void hd6301_adca_ind(void)
3358: {
3359: Uint8 value, carry;
3360: Uint16 addr, result;
3361:
3362: carry = hd6301_REG_CCR_C & 1;
3363: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
3364: value = hd6301_read_memory(addr);
3365: result = hd6301_reg_A + value + carry;
3366:
3367: HD6301_CLR_HNZVC;
3368: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
3369: HD6301_SET_H(hd6301_reg_A, value, result);
3370:
3371: hd6301_reg_A = result;
3372: }
3373:
3374: /**
3375: * ORAA_IND : inclusive or accumulator A with indexed memory address value : A=A|M
3376: *
3377: * HINZVC
3378: * ..**0.
3379: */
3380: static void hd6301_oraa_ind(void)
3381: {
3382: Uint16 addr;
3383:
3384: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
3385: hd6301_reg_A |= hd6301_read_memory(addr);
3386:
3387: HD6301_CLR_NZV;
3388: HD6301_SET_NZ8(hd6301_reg_A);
3389: }
3390:
3391: /**
3392: * ADDA_IND : add indexed memory address value with accumulator A : A=A+M
3393: *
3394: * HINZVC
3395: * *.****
3396: */
3397: static void hd6301_adda_ind(void)
3398: {
3399: Uint8 value;
3400: Uint16 addr, result;
3401:
3402: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
3403: value = hd6301_read_memory(addr);
3404: result = hd6301_reg_A + value;
3405:
3406: HD6301_CLR_HNZVC;
3407: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
3408: HD6301_SET_H(hd6301_reg_A, value, result);
3409:
3410: hd6301_reg_A = result;
3411: }
3412:
3413: /**
3414: * CPX_IND : compare index register with indexed memory address value : X-MM
3415: *
3416: * HINZVC
3417: * ..****
3418: */
3419: static void hd6301_cpx_ind(void)
3420: {
3421: Uint16 addr, value;
3422: Uint32 result;
3423:
3424: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
3425: value = hd6301_read_memory(addr) << 8;
3426: value += hd6301_read_memory(addr+1);
3427: result = hd6301_reg_X - value;
3428:
3429: HD6301_CLR_NZVC;
3430: HD6301_SET_FLAGS16(hd6301_reg_X, value, result);
3431: }
3432:
3433: /**
3434: * JSR_IND : jump to subroutine at indexed address
3435: *
3436: * HINZVC
3437: * ......
3438: */
3439: static void hd6301_jsr_ind(void)
3440: {
3441: Uint16 addr;
3442:
3443: hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC + 2) & 0xff);
3444: hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC + 2) >> 8);
3445:
3446: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
3447: hd6301_reg_PC += addr + 2;
3448: }
3449:
3450: /**
3451: * LDS_IND : load stack pointer with indexed memory address value : SP=MM
3452: *
3453: * HINZVC
3454: * ..**0.
3455: */
3456: static void hd6301_lds_ind(void)
3457: {
3458: Uint16 addr;
3459:
3460: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
3461: hd6301_reg_SP = hd6301_read_memory(addr) << 8;
3462: hd6301_reg_SP += hd6301_read_memory(addr+1);
3463:
3464: HD6301_CLR_NZV;
3465: HD6301_SET_NZ16(hd6301_reg_SP);
3466: }
3467:
3468: /**
3469: * STS_IND : store stack pointer into indexed memory address value : MM=SP
3470: *
3471: * HINZVC
3472: * ..**0.
3473: */
3474: static void hd6301_sts_ind(void)
3475: {
3476: Uint16 addr;
3477:
3478: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
3479: hd6301_write_memory(addr, hd6301_reg_SP >> 8);
3480: hd6301_write_memory(addr+1, hd6301_reg_SP & 8);
3481:
3482: HD6301_CLR_NZV;
3483: HD6301_SET_NZ16(hd6301_reg_SP);
3484: }
3485:
3486: /**
3487: * SUBA_EXT : substract extented memory address value from accumulator A : A=A-M
3488: *
3489: * HINZVC
3490: * ..****
3491: */
3492: static void hd6301_suba_ext(void)
3493: {
3494: Uint8 value;
3495: Uint16 result, addr;
3496:
3497: addr = hd6301_get_memory_ext();
3498: value = hd6301_read_memory(addr);
3499: result = hd6301_reg_A - value;
3500:
3501: HD6301_CLR_NZVC;
3502: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
3503:
3504: hd6301_reg_A = result;
3505: }
3506:
3507: /**
3508: * CMPA_EXT : compare extented memory address value to accumulator A : A-M
3509: *
3510: * HINZVC
3511: * ..****
3512: */
3513: static void hd6301_cmpa_ext(void)
3514: {
3515: Uint8 value;
3516: Uint16 addr, result;
3517:
3518: addr = hd6301_get_memory_ext();
3519: value = hd6301_read_memory(addr);
3520: result = hd6301_reg_A - value;
3521:
3522: HD6301_CLR_NZVC;
3523: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
3524: }
3525:
3526: /**
3527: * SBCA_EXT : substract with carry extented memory address value from accumulator A : A=A-M-C
3528: *
3529: * HINZVC
3530: * ..****
3531: */
3532: static void hd6301_sbca_ext(void)
3533: {
3534: Uint8 value, carry;
3535: Uint16 addr, result;
3536:
3537: carry = hd6301_REG_CCR_C & 1;
3538: addr = hd6301_get_memory_ext();
3539: value = hd6301_read_memory(addr);
3540: result = hd6301_reg_A - value - carry;
3541:
3542: HD6301_CLR_NZVC;
3543: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
3544:
3545: hd6301_reg_A = result;
3546: }
3547:
3548: /**
3549: * SUBD_EXT : substract extented memory address value from accumulator D : D=D-MM
3550: *
3551: * HINZVC
3552: * ..****
3553: */
3554: static void hd6301_subd_ext(void)
3555: {
3556: Uint16 addr, value, regD;
3557: Uint32 result;
3558:
3559: addr = hd6301_get_memory_ext();
3560: value = hd6301_read_memory(addr) << 8;
3561: value += hd6301_read_memory(addr+1);
3562: regD = (hd6301_reg_A << 8) + hd6301_reg_B;
3563: result = regD - value;
3564:
3565: hd6301_reg_A = (result >> 8) & 0xff;
3566: hd6301_reg_B = result & 0xff;
3567:
3568: HD6301_CLR_NZVC;
3569: HD6301_SET_FLAGS16(regD, value, result);
3570: }
3571:
3572: /**
3573: * ANDA_EXT : and extented memory address value with accumulator A : A=A&M
3574: *
3575: * HINZVC
3576: * ..**0.
3577: */
3578: static void hd6301_anda_ext(void)
3579: {
3580: Uint16 addr;
3581:
3582: addr = hd6301_get_memory_ext();
3583: hd6301_reg_A &= hd6301_read_memory(addr);
3584:
3585: HD6301_CLR_NZV;
3586: HD6301_SET_NZ8(hd6301_reg_A);
3587: }
3588:
3589: /**
3590: * BITA_EXT : bit test extented memory address value with accumulator A : A&M
3591: *
3592: * HINZVC
3593: * ..**0.
3594: */
3595: static void hd6301_bita_ext(void)
3596: {
3597: Uint8 value;
3598: Uint16 addr;
3599:
3600: addr = hd6301_get_memory_ext();
3601: value = hd6301_reg_A & hd6301_read_memory(addr);
3602:
3603: HD6301_CLR_NZV;
3604: HD6301_SET_NZ8(value);
3605: }
3606:
3607: /**
3608: * LDAA_EXT : load accumulator A with extented memory address value : A=M
3609: *
3610: * HINZVC
3611: * ..**0.
3612: */
3613: static void hd6301_ldaa_ext(void)
3614: {
3615: Uint16 addr;
3616:
3617: addr = hd6301_get_memory_ext();
3618: hd6301_reg_A = hd6301_read_memory(addr);
3619:
3620: HD6301_CLR_NZV;
3621: HD6301_SET_NZ8(hd6301_reg_A);
3622: }
3623:
3624: /**
3625: * STAA_EXT : store accumulator A into extented memory address value : M=A
3626: *
3627: * HINZVC
3628: * ..**0.
3629: */
3630: static void hd6301_staa_ext(void)
3631: {
3632: Uint16 addr;
3633:
3634: addr = hd6301_get_memory_ext();
3635: hd6301_write_memory(addr, hd6301_reg_A);
3636:
3637: HD6301_CLR_NZV;
3638: HD6301_SET_NZ8(hd6301_reg_A);
3639: }
3640:
3641: /**
3642: * EORA_EXT : exclusive or extented memory address value with accumulator A : A=A^M
3643: *
3644: * HINZVC
3645: * ..**0.
3646: */
3647: static void hd6301_eora_ext(void)
3648: {
3649: Uint16 addr;
3650:
3651: addr = hd6301_get_memory_ext();
3652: hd6301_reg_A ^= hd6301_read_memory(addr);
3653:
3654: HD6301_CLR_NZV;
3655: HD6301_SET_NZ8(hd6301_reg_A);
3656: }
3657:
3658: /**
3659: * ADCA_EXT : add with carry extented memory address value to accumulator A : A=A+M+C
3660: *
3661: * HINZVC
3662: * *.****
3663: */
3664: static void hd6301_adca_ext(void)
3665: {
3666: Uint8 value, carry;
3667: Uint16 addr, result;
3668:
3669: carry = hd6301_REG_CCR_C & 1;
3670: addr = hd6301_get_memory_ext();
3671: value = hd6301_read_memory(addr);
3672: result = hd6301_reg_A + value + carry;
3673:
3674: HD6301_CLR_HNZVC;
3675: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
3676: HD6301_SET_H(hd6301_reg_A, value, result);
3677:
3678: hd6301_reg_A = result;
3679: }
3680:
3681: /**
3682: * ORAA_EXT : inclusive or accumulator A with extented memory address value : A=A|M
3683: *
3684: * HINZVC
3685: * ..**0.
3686: */
3687: static void hd6301_oraa_ext(void)
3688: {
3689: Uint16 addr;
3690:
3691: addr = hd6301_get_memory_ext();
3692: hd6301_reg_A |= hd6301_read_memory(addr);
3693:
3694: HD6301_CLR_NZV;
3695: HD6301_SET_NZ8(hd6301_reg_A);
3696: }
3697:
3698: /**
3699: * ADDA_EXT : add extented memory address value with accumulator A : A=A+M
3700: *
3701: * HINZVC
3702: * *.****
3703: */
3704: static void hd6301_adda_ext(void)
3705: {
3706: Uint8 value;
3707: Uint16 addr, result;
3708:
3709: addr = hd6301_get_memory_ext();
3710: value = hd6301_read_memory(addr);
3711: result = hd6301_reg_A + value;
3712:
3713: HD6301_CLR_HNZVC;
3714: HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
3715: HD6301_SET_H(hd6301_reg_A, value, result);
3716:
3717: hd6301_reg_A = result;
3718: }
3719:
3720: /**
3721: * CPX_EXT : compare index register with extented memory address value : X-MM
3722: *
3723: * HINZVC
3724: * ..****
3725: */
3726: static void hd6301_cpx_ext(void)
3727: {
3728: Uint16 addr, value;
3729: Uint32 result;
3730:
3731: addr = hd6301_get_memory_ext();
3732: value = hd6301_read_memory(addr) << 8;
3733: value += hd6301_read_memory(addr+1);
3734: result = hd6301_reg_X - value;
3735:
3736: HD6301_CLR_NZVC;
3737: HD6301_SET_FLAGS16(hd6301_reg_X, value, result);
3738: }
3739:
3740: /**
3741: * JSR_EXT : jump to subroutine at extented address
3742: *
3743: * HINZVC
3744: * ......
3745: */
3746: static void hd6301_jsr_ext(void)
3747: {
3748: Uint16 addr;
3749:
3750: hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC + 2) & 0xff);
3751: hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC + 2) >> 8);
3752:
3753: addr = hd6301_get_memory_ext();
3754: hd6301_reg_PC += addr + 2;
3755: }
3756:
3757: /**
3758: * LDS_EXT : load stack pointer with extented memory address value : SP=MM
3759: *
3760: * HINZVC
3761: * ..**0.
3762: */
3763: static void hd6301_lds_ext(void)
3764: {
3765: Uint16 addr;
3766:
3767: addr = hd6301_get_memory_ext();
3768: hd6301_reg_SP = hd6301_read_memory(addr) << 8;
3769: hd6301_reg_SP += hd6301_read_memory(addr+1);
3770:
3771: HD6301_CLR_NZV;
3772: HD6301_SET_NZ16(hd6301_reg_SP);
3773: }
3774:
3775: /**
3776: * STS_EXT : store stack pointer into extented memory address value : MM=SP
3777: *
3778: * HINZVC
3779: * ..**0.
3780: */
3781: static void hd6301_sts_ext(void)
3782: {
3783: Uint16 addr;
3784:
3785: addr = hd6301_get_memory_ext();
3786: hd6301_write_memory(addr, hd6301_reg_SP >> 8);
3787: hd6301_write_memory(addr+1, hd6301_reg_SP & 8);
3788:
3789: HD6301_CLR_NZV;
3790: HD6301_SET_NZ16(hd6301_reg_SP);
3791: }
3792:
3793: /**
3794: * SUBB_IMM : substract immediate value from accumulator B : B=B-M
3795: *
3796: * HINZVC
3797: * ..****
3798: */
3799: static void hd6301_subb_imm(void)
3800: {
3801: Uint8 value;
3802: Uint16 result;
3803:
3804: value = hd6301_read_memory(hd6301_reg_PC+1);
3805: result = hd6301_reg_B - value;
3806:
3807: HD6301_CLR_NZVC;
3808: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
3809:
3810: hd6301_reg_B = result;
3811: }
3812:
3813: /**
3814: * CMPB_IMM : compare immediate value to accumulator B : B-M
3815: *
3816: * HINZVC
3817: * ..****
3818: */
3819: static void hd6301_cmpb_imm(void)
3820: {
3821: Uint8 value;
3822: Uint16 result;
3823:
3824: value = hd6301_read_memory(hd6301_reg_PC+1);
3825: result = hd6301_reg_B - value;
3826:
3827: HD6301_CLR_NZVC;
3828: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
3829: }
3830:
3831: /**
3832: * SBCB_IMM : substract with carry immediate value from accumulator B : B=B-M-C
3833: *
3834: * HINZVC
3835: * ..****
3836: */
3837: static void hd6301_sbcb_imm(void)
3838: {
3839: Uint8 value, carry;
3840: Uint16 result;
3841:
3842: carry = hd6301_REG_CCR_C & 1;
3843: value = hd6301_read_memory(hd6301_reg_PC+1);
3844: result = hd6301_reg_B - value - carry;
3845:
3846: HD6301_CLR_NZVC;
3847: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
3848:
3849: hd6301_reg_B = result;
3850: }
3851:
3852: /**
3853: * ADDD_IMM : add immediate value from accumulator D : D=D+MM
3854: *
3855: * HINZVC
3856: * ..****
3857: */
3858: static void hd6301_addd_imm(void)
3859: {
3860: Uint16 value, regD;
3861: Uint32 result;
3862:
3863: value = hd6301_read_memory(hd6301_reg_PC+1) << 8;
3864: value += hd6301_read_memory(hd6301_reg_PC+2);
3865: regD = (hd6301_reg_A << 8) + hd6301_reg_B;
3866: result = regD + value;
3867:
3868: hd6301_reg_A = (result >> 8) & 0xff;
3869: hd6301_reg_B = result & 0xff;
3870:
3871: HD6301_CLR_NZVC;
3872: HD6301_SET_FLAGS16(regD, value, result);
3873: }
3874:
3875: /**
3876: * ANDB_IMM : and immediate value with accumulator B : B=B&M
3877: *
3878: * HINZVC
3879: * ..**0.
3880: */
3881: static void hd6301_andb_imm(void)
3882: {
3883: hd6301_reg_B &= hd6301_read_memory(hd6301_reg_PC+1);
3884:
3885: HD6301_CLR_NZV;
3886: HD6301_SET_NZ8(hd6301_reg_B);
3887: }
3888:
3889: /**
3890: * BITB_IMM : bit test immediate value with accumulator B : B&M
3891: *
3892: * HINZVC
3893: * ..**0.
3894: */
3895: static void hd6301_bitb_imm(void)
3896: {
3897: Uint8 value;
3898:
3899: value = hd6301_reg_B & hd6301_read_memory(hd6301_reg_PC+1);
3900:
3901: HD6301_CLR_NZV;
3902: HD6301_SET_NZ8(value);
3903: }
3904:
3905: /**
3906: * LDAB_IMM : load accumulator B with immediate value : B=M
3907: *
3908: * HINZVC
3909: * ..**0.
3910: */
3911: static void hd6301_ldab_imm(void)
3912: {
3913: hd6301_reg_B = hd6301_read_memory(hd6301_reg_PC+1);
3914:
3915: HD6301_CLR_NZV;
3916: HD6301_SET_NZ8(hd6301_reg_B);
3917: }
3918:
3919: /**
3920: * EORB_IMM : exclusive or immediate value with accumulator B : B=B^M
3921: *
3922: * HINZVC
3923: * ..**0.
3924: */
3925: static void hd6301_eorb_imm(void)
3926: {
3927: hd6301_reg_B ^= hd6301_read_memory(hd6301_reg_PC+1);
3928:
3929: HD6301_CLR_NZV;
3930: HD6301_SET_NZ8(hd6301_reg_B);
3931: }
3932:
3933: /**
3934: * ADCB_IMM : add with carry immediate value to accumulator B : B=B+M+C
3935: *
3936: * HINZVC
3937: * *.****
3938: */
3939: static void hd6301_adcb_imm(void)
3940: {
3941: Uint8 value, carry;
3942: Uint16 result;
3943:
3944: carry = hd6301_REG_CCR_C & 1;
3945: value = hd6301_read_memory(hd6301_reg_PC+1);
3946: result = hd6301_reg_B + value + carry;
3947:
3948: HD6301_CLR_HNZVC;
3949: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
3950: HD6301_SET_H(hd6301_reg_B, value, result);
3951:
3952: hd6301_reg_B = result;
3953: }
3954:
3955: /**
3956: * ORAB_IMM : inclusive or accumulator B with immediate value : B=B|M
3957: *
3958: * HINZVC
3959: * ..**0.
3960: */
3961: static void hd6301_orab_imm(void)
3962: {
3963: hd6301_reg_B |= hd6301_read_memory(hd6301_reg_PC+1);
3964:
3965: HD6301_CLR_NZV;
3966: HD6301_SET_NZ8(hd6301_reg_B);
3967: }
3968:
3969: /**
3970: * ADDB_IMM : add immediate value with accumulator B : B=B+M
3971: *
3972: * HINZVC
3973: * ..****
3974: */
3975: static void hd6301_addb_imm(void)
3976: {
3977: Uint8 value;
3978: Uint16 result;
3979:
3980: value = hd6301_read_memory(hd6301_reg_PC+1);
3981: result = hd6301_reg_B + value;
3982:
3983: HD6301_CLR_HNZVC;
3984: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
3985: HD6301_SET_H(hd6301_reg_B, value, result);
3986:
3987: hd6301_reg_B = result;
3988: }
3989:
3990: /**
3991: * LDD_IMM : load accumulator D with immediate value : D=MM
3992: *
3993: * HINZVC
3994: * ..**0.
3995: */
3996: static void hd6301_ldd_imm(void)
3997: {
3998: hd6301_reg_A = hd6301_read_memory(hd6301_reg_PC+1);
3999: hd6301_reg_B = hd6301_read_memory(hd6301_reg_PC+2);
4000:
4001: HD6301_CLR_NZV;
4002: hd6301_reg_CCR |= ((hd6301_reg_A == 0) && (hd6301_reg_B == 0)) << hd6301_REG_CCR_Z;
4003: hd6301_reg_CCR |= (hd6301_reg_A >> 7) << hd6301_REG_CCR_N;
4004: }
4005:
4006: /**
4007: * LDX_IMM : load register X with immediate value : X=MM
4008: *
4009: * HINZVC
4010: * ..**0.
4011: */
4012: static void hd6301_ldx_imm(void)
4013: {
4014: Uint16 value;
4015:
4016: value = hd6301_read_memory(hd6301_reg_PC+1) << 8;
4017: value += hd6301_read_memory(hd6301_reg_PC+2);
4018: hd6301_reg_X = value;
4019:
4020: HD6301_CLR_NZV;
4021: HD6301_SET_NZ16(hd6301_reg_X);
4022: }
4023:
4024: /**
4025: * SUBB_DIR : substract direct memory address value from accumulator B : B=B-M
4026: *
4027: * HINZVC
4028: * ..****
4029: */
4030: static void hd6301_subb_dir(void)
4031: {
4032: Uint8 value;
4033: Uint16 result, addr;
4034:
4035: addr = hd6301_read_memory(hd6301_reg_PC+1);
4036: value = hd6301_read_memory(addr);
4037: result = hd6301_reg_B - value;
4038:
4039: HD6301_CLR_NZVC;
4040: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
4041:
4042: hd6301_reg_B = result;
4043: }
4044:
4045: /**
4046: * CMPB_DIR : compare direct memory address value to accumulator B : B-M
4047: *
4048: * HINZVC
4049: * ..****
4050: */
4051: static void hd6301_cmpb_dir(void)
4052: {
4053: Uint8 value;
4054: Uint16 addr, result;
4055:
4056: addr = hd6301_read_memory(hd6301_reg_PC+1);
4057: value = hd6301_read_memory(addr);
4058: result = hd6301_reg_B - value;
4059:
4060: HD6301_CLR_NZVC;
4061: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
4062: }
4063:
4064: /**
4065: * SBCB_DIR : substract with carry direct memory address value from accumulator B : B=B-M-C
4066: *
4067: * HINZVC
4068: * ..****
4069: */
4070: static void hd6301_sbcb_dir(void)
4071: {
4072: Uint8 value, carry;
4073: Uint16 addr, result;
4074:
4075: carry = hd6301_REG_CCR_C & 1;
4076: addr = hd6301_read_memory(hd6301_reg_PC+1);
4077: value = hd6301_read_memory(addr);
4078: result = hd6301_reg_B - value - carry;
4079:
4080: HD6301_CLR_NZVC;
4081: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
4082:
4083: hd6301_reg_B = result;
4084: }
4085:
4086: /**
4087: * ADDD_DIR : add direct memory address value from accumulator D : D=D+MM
4088: *
4089: * HINZVC
4090: * ..****
4091: */
4092: static void hd6301_addd_dir(void)
4093: {
4094: Uint16 addr, value, regD;
4095: Uint32 result;
4096:
4097: addr = hd6301_read_memory(hd6301_reg_PC+1);
4098: value = hd6301_read_memory(addr) << 8;
4099: value += hd6301_read_memory(addr+1);
4100: regD = (hd6301_reg_A << 8) + hd6301_reg_B;
4101: result = regD + value;
4102:
4103: hd6301_reg_A = (result >> 8) & 0xff;
4104: hd6301_reg_B = result & 0xff;
4105:
4106: HD6301_CLR_NZVC;
4107: HD6301_SET_FLAGS16(regD, value, result);
4108: }
4109:
4110: /**
4111: * ANDB_DIR : and direct memory address value with accumulator B : B=B&M
4112: *
4113: * HINZVC
4114: * ..**0.
4115: */
4116: static void hd6301_andb_dir(void)
4117: {
4118: Uint16 addr;
4119:
4120: addr = hd6301_read_memory(hd6301_reg_PC+1);
4121: hd6301_reg_B &= hd6301_read_memory(addr);
4122:
4123: HD6301_CLR_NZV;
4124: HD6301_SET_NZ8(hd6301_reg_B);
4125: }
4126:
4127: /**
4128: * BITB_DIR : bit test direct memory address value with accumulator B : B&M
4129: *
4130: * HINZVC
4131: * ..**0.
4132: */
4133: static void hd6301_bitb_dir(void)
4134: {
4135: Uint8 value;
4136: Uint16 addr;
4137:
4138: addr = hd6301_read_memory(hd6301_reg_PC+1);
4139: value = hd6301_reg_B & hd6301_read_memory(addr);
4140:
4141: HD6301_CLR_NZV;
4142: HD6301_SET_NZ8(value);
4143: }
4144:
4145: /**
4146: * LDAB_DIR : load accumulator B with direct memory address value : B=M
4147: *
4148: * HINZVC
4149: * ..**0.
4150: */
4151: static void hd6301_ldab_dir(void)
4152: {
4153: Uint16 addr;
4154:
4155: addr = hd6301_read_memory(hd6301_reg_PC+1);
4156: hd6301_reg_B = hd6301_read_memory(addr);
4157:
4158: HD6301_CLR_NZV;
4159: HD6301_SET_NZ8(hd6301_reg_B);
4160: }
4161:
4162: /**
4163: * STAB_DIR : store accumulator B into direct memory address value : M=B
4164: *
4165: * HINZVC
4166: * ..**0.
4167: */
4168: static void hd6301_stab_dir(void)
4169: {
4170: Uint16 addr;
4171:
4172: addr = hd6301_read_memory(hd6301_reg_PC+1);
4173: hd6301_write_memory(addr, hd6301_reg_B);
4174:
4175: HD6301_CLR_NZV;
4176: HD6301_SET_NZ8(hd6301_reg_B);
4177: }
4178:
4179: /**
4180: * EORB_DIR : exclusive or direct memory address value with accumulator B : B=B^M
4181: *
4182: * HINZVC
4183: * ..**0.
4184: */
4185: static void hd6301_eorb_dir(void)
4186: {
4187: Uint16 addr;
4188:
4189: addr = hd6301_read_memory(hd6301_reg_PC+1);
4190: hd6301_reg_B ^= hd6301_read_memory(addr);
4191:
4192: HD6301_CLR_NZV;
4193: HD6301_SET_NZ8(hd6301_reg_B);
4194: }
4195:
4196: /**
4197: * ADCB_DIR : add with carry direct memory address value to accumulator B : B=B+M+C
4198: *
4199: * HINZVC
4200: * *.****
4201: */
4202: static void hd6301_adcb_dir(void)
4203: {
4204: Uint8 value, carry;
4205: Uint16 addr, result;
4206:
4207: carry = hd6301_REG_CCR_C & 1;
4208: addr = hd6301_read_memory(hd6301_reg_PC+1);
4209: value = hd6301_read_memory(addr);
4210: result = hd6301_reg_B + value + carry;
4211:
4212: HD6301_CLR_HNZVC;
4213: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
4214: HD6301_SET_H(hd6301_reg_B, value, result);
4215:
4216: hd6301_reg_B = result;
4217: }
4218:
4219: /**
4220: * ORAB_DIR : inclusive or accumulator B with direct memory address value : B=B|M
4221: *
4222: * HINZVC
4223: * ..**0.
4224: */
4225: static void hd6301_orab_dir(void)
4226: {
4227: Uint16 addr;
4228:
4229: addr = hd6301_read_memory(hd6301_reg_PC+1);
4230: hd6301_reg_B |= hd6301_read_memory(addr);
4231:
4232: HD6301_CLR_NZV;
4233: HD6301_SET_NZ8(hd6301_reg_B);
4234: }
4235:
4236: /**
4237: * ADDB_DIR : add direct memory address value with accumulator B : B=B+M
4238: *
4239: * HINZVC
4240: * *.****
4241: */
4242: static void hd6301_addb_dir(void)
4243: {
4244: Uint8 value;
4245: Uint16 addr, result;
4246:
4247: addr = hd6301_read_memory(hd6301_reg_PC+1);
4248: value = hd6301_read_memory(addr);
4249: result = hd6301_reg_B + value;
4250:
4251: HD6301_CLR_HNZVC;
4252: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
4253: HD6301_SET_H(hd6301_reg_B, value, result);
4254:
4255: hd6301_reg_B = result;
4256: }
4257:
4258: /**
4259: * LDD_DIR : load accumulator D with direct memory address value : D=MM
4260: *
4261: * HINZVC
4262: * ..**0.
4263: */
4264: static void hd6301_ldd_dir(void)
4265: {
4266: Uint16 addr;
4267:
4268: addr = hd6301_read_memory(hd6301_reg_PC+1);
4269:
4270: hd6301_reg_A = hd6301_read_memory(addr);
4271: hd6301_reg_B = hd6301_read_memory(addr+1);
4272:
4273: HD6301_CLR_NZV;
4274: hd6301_reg_CCR |= ((hd6301_reg_A == 0) && (hd6301_reg_B == 0)) << hd6301_REG_CCR_Z;
4275: hd6301_reg_CCR |= (hd6301_reg_A >> 7) << hd6301_REG_CCR_N;
4276: }
4277:
4278: /**
4279: * STD_DIR : store accumulator D into direct memory address value : MM=D
4280: *
4281: * HINZVC
4282: * ..**0.
4283: */
4284: static void hd6301_std_dir(void)
4285: {
4286: Uint16 addr;
4287:
4288: addr = hd6301_read_memory(hd6301_reg_PC+1);
4289:
4290: hd6301_write_memory(addr, hd6301_reg_A);
4291: hd6301_write_memory(addr+1, hd6301_reg_B);
4292:
4293: HD6301_CLR_NZV;
4294: hd6301_reg_CCR |= ((hd6301_reg_A == 0) && (hd6301_reg_B == 0)) << hd6301_REG_CCR_Z;
4295: hd6301_reg_CCR |= (hd6301_reg_A >> 7) << hd6301_REG_CCR_N;
4296: }
4297:
4298: /**
4299: * LDX_DIR : load register X with direct memory address value : X=MM
4300: *
4301: * HINZVC
4302: * ..**0.
4303: */
4304: static void hd6301_ldx_dir(void)
4305: {
4306: Uint16 addr;
4307:
4308: addr = hd6301_read_memory(hd6301_reg_PC+1);
4309:
4310: hd6301_reg_X = hd6301_read_memory(addr) << 8;
4311: hd6301_reg_X += hd6301_read_memory(addr+1);
4312:
4313: HD6301_CLR_NZV;
4314: HD6301_SET_NZ16(hd6301_reg_X);
4315: }
4316:
4317: /**
4318: * STX_DIR : store register X into direct memory address value : MM=X
4319: *
4320: * HINZVC
4321: * ..**0.
4322: */
4323: static void hd6301_stx_dir(void)
4324: {
4325: Uint16 addr;
4326:
4327: addr = hd6301_read_memory(hd6301_reg_PC+1);
4328:
4329: hd6301_write_memory(addr, hd6301_reg_X >> 8);
4330: hd6301_write_memory(addr+1, hd6301_reg_X & 0xff);
4331:
4332: HD6301_CLR_NZV;
4333: HD6301_SET_NZ16(hd6301_reg_X);
4334: }
4335:
4336: /**
4337: * SUBB_IND : substract indexed memory address value from accumulator B : B=B-M
4338: *
4339: * HINZVC
4340: * ..****
4341: */
4342: static void hd6301_subb_ind(void)
4343: {
4344: Uint8 value;
4345: Uint16 result, addr;
4346:
4347: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
4348: value = hd6301_read_memory(addr);
4349: result = hd6301_reg_B - value;
4350:
4351: HD6301_CLR_NZVC;
4352: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
4353:
4354: hd6301_reg_B = result;
4355: }
4356:
4357: /**
4358: * CMPB_IND : compare indexed memory address value to accumulator B : B-M
4359: *
4360: * HINZVC
4361: * ..****
4362: */
4363: static void hd6301_cmpb_ind(void)
4364: {
4365: Uint8 value;
4366: Uint16 addr, result;
4367:
4368: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
4369: value = hd6301_read_memory(addr);
4370: result = hd6301_reg_B - value;
4371:
4372: HD6301_CLR_NZVC;
4373: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
4374: }
4375:
4376: /**
4377: * SBCB_IND : substract with carry indexed memory address value from accumulator B : B=B-M-C
4378: *
4379: * HINZVC
4380: * ..****
4381: */
4382: static void hd6301_sbcb_ind(void)
4383: {
4384: Uint8 value, carry;
4385: Uint16 addr, result;
4386:
4387: carry = hd6301_REG_CCR_C & 1;
4388: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
4389: value = hd6301_read_memory(addr);
4390: result = hd6301_reg_B - value - carry;
4391:
4392: HD6301_CLR_NZVC;
4393: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
4394:
4395: hd6301_reg_B = result;
4396: }
4397:
4398: /**
4399: * ADDD_IND : add indexed memory address value from accumulator D : D=D+MM
4400: *
4401: * HINZVC
4402: * ..****
4403: */
4404: static void hd6301_addd_ind(void)
4405: {
4406: Uint16 addr, value, regD;
4407: Uint32 result;
4408:
4409: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
4410: value = hd6301_read_memory(addr) << 8;
4411: value += hd6301_read_memory(addr+1);
4412: regD = (hd6301_reg_A << 8) + hd6301_reg_B;
4413: result = regD + value;
4414:
4415: hd6301_reg_A = (result >> 8) & 0xff;
4416: hd6301_reg_B = result & 0xff;
4417:
4418: HD6301_CLR_NZVC;
4419: HD6301_SET_FLAGS16(regD, value, result);
4420: }
4421:
4422: /**
4423: * ANDB_IND : and indexed memory address value with accumulator B : B=B&M
4424: *
4425: * HINZVC
4426: * ..**0.
4427: */
4428: static void hd6301_andb_ind(void)
4429: {
4430: Uint16 addr;
4431:
4432: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
4433: hd6301_reg_B &= hd6301_read_memory(addr);
4434:
4435: HD6301_CLR_NZV;
4436: HD6301_SET_NZ8(hd6301_reg_B);
4437: }
4438:
4439: /**
4440: * BITB_IND : bit test indexed memory address value with accumulator B : B&M
4441: *
4442: * HINZVC
4443: * ..**0.
4444: */
4445: static void hd6301_bitb_ind(void)
4446: {
4447: Uint8 value;
4448: Uint16 addr;
4449:
4450: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
4451: value = hd6301_reg_B & hd6301_read_memory(addr);
4452:
4453: HD6301_CLR_NZV;
4454: HD6301_SET_NZ8(value);
4455: }
4456:
4457: /**
4458: * LDAB_IND : load accumulator B with indexed memory address value : B=M
4459: *
4460: * HINZVC
4461: * ..**0.
4462: */
4463: static void hd6301_ldab_ind(void)
4464: {
4465: Uint16 addr;
4466:
4467: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
4468: hd6301_reg_B = hd6301_read_memory(addr);
4469:
4470: HD6301_CLR_NZV;
4471: HD6301_SET_NZ8(hd6301_reg_B);
4472: }
4473:
4474: /**
4475: * STAB_IND : store accumulator B into indexed memory address value : M=B
4476: *
4477: * HINZVC
4478: * ..**0.
4479: */
4480: static void hd6301_stab_ind(void)
4481: {
4482: Uint16 addr;
4483:
4484: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
4485: hd6301_write_memory(addr, hd6301_reg_B);
4486:
4487: HD6301_CLR_NZV;
4488: HD6301_SET_NZ8(hd6301_reg_B);
4489: }
4490:
4491: /**
4492: * EORB_IND : exclusive or indexed memory address value with accumulator B : B=B^M
4493: *
4494: * HINZVC
4495: * ..**0.
4496: */
4497: static void hd6301_eorb_ind(void)
4498: {
4499: Uint16 addr;
4500:
4501: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
4502: hd6301_reg_B ^= hd6301_read_memory(addr);
4503:
4504: HD6301_CLR_NZV;
4505: HD6301_SET_NZ8(hd6301_reg_B);
4506: }
4507:
4508: /**
4509: * ADCB_IND : add with carry indexed memory address value to accumulator B : B=B+M+C
4510: *
4511: * HINZVC
4512: * *.****
4513: */
4514: static void hd6301_adcb_ind(void)
4515: {
4516: Uint8 value, carry;
4517: Uint16 addr, result;
4518:
4519: carry = hd6301_REG_CCR_C & 1;
4520: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
4521: value = hd6301_read_memory(addr);
4522: result = hd6301_reg_B + value + carry;
4523:
4524: HD6301_CLR_HNZVC;
4525: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
4526: HD6301_SET_H(hd6301_reg_B, value, result);
4527:
4528: hd6301_reg_B = result;
4529: }
4530:
4531: /**
4532: * ORAB_IND : inclusive or accumulator B with indexed memory address value : B=B|M
4533: *
4534: * HINZVC
4535: * ..**0.
4536: */
4537: static void hd6301_orab_ind(void)
4538: {
4539: Uint16 addr;
4540:
4541: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
4542: hd6301_reg_B |= hd6301_read_memory(addr);
4543:
4544: HD6301_CLR_NZV;
4545: HD6301_SET_NZ8(hd6301_reg_B);
4546: }
4547:
4548: /**
4549: * ADDB_IND : add indexed memory address value with accumulator B : B=B+M
4550: *
4551: * HINZVC
4552: * *.****
4553: */
4554: static void hd6301_addb_ind(void)
4555: {
4556: Uint8 value;
4557: Uint16 addr, result;
4558:
4559: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
4560: value = hd6301_read_memory(addr);
4561: result = hd6301_reg_B + value;
4562:
4563: HD6301_CLR_HNZVC;
4564: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
4565: HD6301_SET_H(hd6301_reg_B, value, result);
4566:
4567: hd6301_reg_B = result;
4568: }
4569:
4570: /**
4571: * LDD_IND : load accumulator D with indexed memory address value : D=MM
4572: *
4573: * HINZVC
4574: * ..**0.
4575: */
4576: static void hd6301_ldd_ind(void)
4577: {
4578: Uint16 addr;
4579:
4580: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
4581:
4582: hd6301_reg_A = hd6301_read_memory(addr);
4583: hd6301_reg_B = hd6301_read_memory(addr+1);
4584:
4585: HD6301_CLR_NZV;
4586: hd6301_reg_CCR |= ((hd6301_reg_A == 0) && (hd6301_reg_B == 0)) << hd6301_REG_CCR_Z;
4587: hd6301_reg_CCR |= (hd6301_reg_A >> 7) << hd6301_REG_CCR_N;
4588: }
4589:
4590: /**
4591: * STD_IND : store accumulator D into indexed memory address value : MM=D
4592: *
4593: * HINZVC
4594: * ..**0.
4595: */
4596: static void hd6301_std_ind(void)
4597: {
4598: Uint16 addr;
4599:
4600: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
4601:
4602: hd6301_write_memory(addr, hd6301_reg_A);
4603: hd6301_write_memory(addr+1, hd6301_reg_B);
4604:
4605: HD6301_CLR_NZV;
4606: hd6301_reg_CCR |= ((hd6301_reg_A == 0) && (hd6301_reg_B == 0)) << hd6301_REG_CCR_Z;
4607: hd6301_reg_CCR |= (hd6301_reg_A >> 7) << hd6301_REG_CCR_N;
4608: }
4609:
4610: /**
4611: * LDX_IND : load register X with indexed memory address value : X=MM
4612: *
4613: * HINZVC
4614: * ..**0.
4615: */
4616: static void hd6301_ldx_ind(void)
4617: {
4618: Uint16 addr;
4619:
4620: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
4621:
4622: hd6301_reg_X = hd6301_read_memory(addr) << 8;
4623: hd6301_reg_X += hd6301_read_memory(addr+1);
4624:
4625: HD6301_CLR_NZV;
4626: HD6301_SET_NZ16(hd6301_reg_X);
4627: }
4628:
4629: /**
4630: * STX_IND : store register X into indexed memory address value : MM=X
4631: *
4632: * HINZVC
4633: * ..**0.
4634: */
4635: static void hd6301_stx_ind(void)
4636: {
4637: Uint16 addr;
4638:
4639: addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
4640:
4641: hd6301_write_memory(addr, hd6301_reg_X >> 8);
4642: hd6301_write_memory(addr+1, hd6301_reg_X & 0xff);
4643:
4644: HD6301_CLR_NZV;
4645: HD6301_SET_NZ16(hd6301_reg_X);
4646: }
4647:
4648: /**
4649: * SUBB_EXT : substract extended memory address value from accumulator B : B=B-M
4650: *
4651: * HINZVC
4652: * ..****
4653: */
4654: static void hd6301_subb_ext(void)
4655: {
4656: Uint8 value;
4657: Uint16 result, addr;
4658:
4659: addr = hd6301_get_memory_ext();
4660: value = hd6301_read_memory(addr);
4661: result = hd6301_reg_B - value;
4662:
4663: HD6301_CLR_NZVC;
4664: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
4665:
4666: hd6301_reg_B = result;
4667: }
4668:
4669: /**
4670: * CMPB_EXT : compare extended memory address value to accumulator B : B-M
4671: *
4672: * HINZVC
4673: * ..****
4674: */
4675: static void hd6301_cmpb_ext(void)
4676: {
4677: Uint8 value;
4678: Uint16 addr, result;
4679:
4680: addr = hd6301_get_memory_ext();
4681: value = hd6301_read_memory(addr);
4682: result = hd6301_reg_B - value;
4683:
4684: HD6301_CLR_NZVC;
4685: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
4686: }
4687:
4688: /**
4689: * SBCB_EXT : substract with carry extended memory address value from accumulator B : B=B-M-C
4690: *
4691: * HINZVC
4692: * ..****
4693: */
4694: static void hd6301_sbcb_ext(void)
4695: {
4696: Uint8 value, carry;
4697: Uint16 addr, result;
4698:
4699: carry = hd6301_REG_CCR_C & 1;
4700: addr = hd6301_get_memory_ext();
4701: value = hd6301_read_memory(addr);
4702: result = hd6301_reg_B - value - carry;
4703:
4704: HD6301_CLR_NZVC;
4705: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
4706:
4707: hd6301_reg_B = result;
4708: }
4709:
4710: /**
4711: * ADDD_EXT : add extended memory address value from accumulator D : D=D+MM
4712: *
4713: * HINZVC
4714: * ..****
4715: */
4716: static void hd6301_addd_ext(void)
4717: {
4718: Uint16 addr, value, regD;
4719: Uint32 result;
4720:
4721: addr = hd6301_get_memory_ext();
4722: value = hd6301_read_memory(addr) << 8;
4723: value += hd6301_read_memory(addr+1);
4724: regD = (hd6301_reg_A << 8) + hd6301_reg_B;
4725: result = regD + value;
4726:
4727: hd6301_reg_A = (result >> 8) & 0xff;
4728: hd6301_reg_B = result & 0xff;
4729:
4730: HD6301_CLR_NZVC;
4731: HD6301_SET_FLAGS16(regD, value, result);
4732: }
4733:
4734: /**
4735: * ANDB_EXT : and extended memory address value with accumulator B : B=B&M
4736: *
4737: * HINZVC
4738: * ..**0.
4739: */
4740: static void hd6301_andb_ext(void)
4741: {
4742: Uint16 addr;
4743:
4744: addr = hd6301_get_memory_ext();
4745: hd6301_reg_B &= hd6301_read_memory(addr);
4746:
4747: HD6301_CLR_NZV;
4748: HD6301_SET_NZ8(hd6301_reg_B);
4749: }
4750:
4751: /**
4752: * BITB_EXT : bit test extended memory address value with accumulator B : B&M
4753: *
4754: * HINZVC
4755: * ..**0.
4756: */
4757: static void hd6301_bitb_ext(void)
4758: {
4759: Uint8 value;
4760: Uint16 addr;
4761:
4762: addr = hd6301_get_memory_ext();
4763: value = hd6301_reg_B & hd6301_read_memory(addr);
4764:
4765: HD6301_CLR_NZV;
4766: HD6301_SET_NZ8(value);
4767: }
4768:
4769: /**
4770: * LDAB_EXT : load accumulator B with extended memory address value : B=M
4771: *
4772: * HINZVC
4773: * ..**0.
4774: */
4775: static void hd6301_ldab_ext(void)
4776: {
4777: Uint16 addr;
4778:
4779: addr = hd6301_get_memory_ext();
4780: hd6301_reg_B = hd6301_read_memory(addr);
4781:
4782: HD6301_CLR_NZV;
4783: HD6301_SET_NZ8(hd6301_reg_B);
4784: }
4785:
4786: /**
4787: * STAB_EXT : store accumulator B into extended memory address value : M=B
4788: *
4789: * HINZVC
4790: * ..**0.
4791: */
4792: static void hd6301_stab_ext(void)
4793: {
4794: Uint16 addr;
4795:
4796: addr = hd6301_get_memory_ext();
4797: hd6301_write_memory(addr, hd6301_reg_B);
4798:
4799: HD6301_CLR_NZV;
4800: HD6301_SET_NZ8(hd6301_reg_B);
4801: }
4802:
4803: /**
4804: * EORB_EXT : exclusive or extended memory address value with accumulator B : B=B^M
4805: *
4806: * HINZVC
4807: * ..**0.
4808: */
4809: static void hd6301_eorb_ext(void)
4810: {
4811: Uint16 addr;
4812:
4813: addr = hd6301_get_memory_ext();
4814: hd6301_reg_B ^= hd6301_read_memory(addr);
4815:
4816: HD6301_CLR_NZV;
4817: HD6301_SET_NZ8(hd6301_reg_B);
4818: }
4819:
4820: /**
4821: * ADCB_EXT : add with carry extended memory address value to accumulator B : B=B+M+C
4822: *
4823: * HINZVC
4824: * *.****
4825: */
4826: static void hd6301_adcb_ext(void)
4827: {
4828: Uint8 value, carry;
4829: Uint16 addr, result;
4830:
4831: carry = hd6301_REG_CCR_C & 1;
4832: addr = hd6301_get_memory_ext();
4833: value = hd6301_read_memory(addr);
4834: result = hd6301_reg_B + value + carry;
4835:
4836: HD6301_CLR_HNZVC;
4837: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
4838: HD6301_SET_H(hd6301_reg_B, value, result);
4839:
4840: hd6301_reg_B = result;
4841: }
4842:
4843: /**
4844: * ORAB_EXT : inclusive or accumulator B with extended memory address value : B=B|M
4845: *
4846: * HINZVC
4847: * ..**0.
4848: */
4849: static void hd6301_orab_ext(void)
4850: {
4851: Uint16 addr;
4852:
4853: addr = hd6301_get_memory_ext();
4854: hd6301_reg_B |= hd6301_read_memory(addr);
4855:
4856: HD6301_CLR_NZV;
4857: HD6301_SET_NZ8(hd6301_reg_B);
4858: }
4859:
4860: /**
4861: * ADDB_EXT : add extended memory address value with accumulator B : B=B+M
4862: *
4863: * HINZVC
4864: * *.****
4865: */
4866: static void hd6301_addb_ext(void)
4867: {
4868: Uint8 value;
4869: Uint16 addr, result;
4870:
4871: addr = hd6301_get_memory_ext();
4872: value = hd6301_read_memory(addr);
4873: result = hd6301_reg_B + value;
4874:
4875: HD6301_CLR_HNZVC;
4876: HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
4877: HD6301_SET_H(hd6301_reg_B, value, result);
4878:
4879: hd6301_reg_B = result;
4880: }
4881:
4882: /**
4883: * LDD_EXT : load accumulator D with extended memory address value : D=MM
4884: *
4885: * HINZVC
4886: * ..**0.
4887: */
4888: static void hd6301_ldd_ext(void)
4889: {
4890: Uint16 addr;
4891:
4892: addr = hd6301_get_memory_ext();
4893:
4894: hd6301_reg_A = hd6301_read_memory(addr);
4895: hd6301_reg_B = hd6301_read_memory(addr+1);
4896:
4897: HD6301_CLR_NZV;
4898: hd6301_reg_CCR |= ((hd6301_reg_A == 0) && (hd6301_reg_B == 0)) << hd6301_REG_CCR_Z;
4899: hd6301_reg_CCR |= (hd6301_reg_A >> 7) << hd6301_REG_CCR_N;
4900: }
4901:
4902: /**
4903: * STD_EXT : store accumulator D into extended memory address value : MM=D
4904: *
4905: * HINZVC
4906: * ..**0.
4907: */
4908: static void hd6301_std_ext(void)
4909: {
4910: Uint16 addr;
4911:
4912: addr = hd6301_get_memory_ext();
4913:
4914: hd6301_write_memory(addr, hd6301_reg_A);
4915: hd6301_write_memory(addr+1, hd6301_reg_B);
4916:
4917: HD6301_CLR_NZV;
4918: hd6301_reg_CCR |= ((hd6301_reg_A == 0) && (hd6301_reg_B == 0)) << hd6301_REG_CCR_Z;
4919: hd6301_reg_CCR |= (hd6301_reg_A >> 7) << hd6301_REG_CCR_N;
4920: }
4921:
4922: /**
4923: * LDX_EXT : load register X with extended memory address value : X=MM
4924: *
4925: * HINZVC
4926: * ..**0.
4927: */
4928: static void hd6301_ldx_ext(void)
4929: {
4930: Uint16 addr;
4931:
4932: addr = hd6301_get_memory_ext();
4933:
4934: hd6301_reg_X = hd6301_read_memory(addr) << 8;
4935: hd6301_reg_X += hd6301_read_memory(addr+1);
4936:
4937: HD6301_CLR_NZV;
4938: HD6301_SET_NZ16(hd6301_reg_X);
4939: }
4940:
4941: /**
4942: * STX_EXT : store register X into extended memory address value : MM=X
4943: *
4944: * HINZVC
4945: * ..**0.
4946: */
4947: static void hd6301_stx_ext(void)
4948: {
4949: Uint16 addr;
4950:
4951: addr = hd6301_get_memory_ext();
4952:
4953: hd6301_write_memory(addr, hd6301_reg_X >> 8);
4954: hd6301_write_memory(addr+1, hd6301_reg_X & 0xff);
4955:
4956: HD6301_CLR_NZV;
4957: HD6301_SET_NZ16(hd6301_reg_X);
4958: }
4959:
4960:
4961:
4962: /**
4963: * hd6301_disasm : disasm hd6301 memory
4964: */
4965: void hd6301_disasm(void)
4966: {
4967: switch(hd6301_opcode.op_disasm) {
4968: case HD6301_DISASM_UNDEFINED:
4969: sprintf(hd6301_str_instr, "0x%02x : unknown instruction", hd6301_cur_inst);
4970: break;
4971: case HD6301_DISASM_NONE:
4972: sprintf(hd6301_str_instr, hd6301_opcode.op_mnemonic, 0);
4973: break;
4974: case HD6301_DISASM_MEMORY8:
4975: sprintf(hd6301_str_instr, hd6301_opcode.op_mnemonic, hd6301_read_memory(hd6301_reg_PC+1));
4976: break;
4977: case HD6301_DISASM_MEMORY16:
4978: sprintf(hd6301_str_instr, hd6301_opcode.op_mnemonic, hd6301_get_memory_ext());
4979: break;
4980: case HD6301_DISASM_XIM:
4981: sprintf(hd6301_str_instr, hd6301_opcode.op_mnemonic,
4982: hd6301_read_memory(hd6301_reg_PC+1),
4983: hd6301_read_memory(hd6301_reg_PC+2));
4984: break;
4985: }
4986:
4987: fprintf(stderr, "%02x: %s\n", hd6301_reg_PC, hd6301_str_instr);
4988:
4989: }
4990:
4991: /**
4992: * hd6301_display_registers : display hd6301 registers state
4993: */
4994: void hd6301_display_registers(void)
4995: {
4996: fprintf(stderr, "A: %02x B: %02x\n", hd6301_reg_A, hd6301_reg_B);
4997: fprintf(stderr, "X: %04x CCR: %02x\n", hd6301_reg_X, hd6301_reg_CCR);
4998: fprintf(stderr, "SP: %04x PC: %04x\n", hd6301_reg_SP, hd6301_reg_PC);
4999: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.