5002 lines
106 KiB
C
5002 lines
106 KiB
C
/*
|
|
Hatari - hd6301_cpu.c
|
|
Copyright Laurent Sallafranque 2009
|
|
|
|
This file is distributed under the GNU General Public License, version 2
|
|
or at your option any later version. Read the file gpl.txt for details.
|
|
|
|
hd6301_cpu.c - this is the cpu core emulation for hd 6301 processor
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <SDL.h>
|
|
|
|
#include "hd6301_cpu.h"
|
|
|
|
|
|
/**********************************
|
|
* Defines
|
|
**********************************/
|
|
#define HD6301_DISASM 1
|
|
#define HD6301_DISPLAY_REGS 1
|
|
|
|
/* HD6301 Disasm and debug code */
|
|
#define HD6301_DISASM_UNDEFINED 0
|
|
#define HD6301_DISASM_NONE 1
|
|
#define HD6301_DISASM_MEMORY8 2
|
|
#define HD6301_DISASM_MEMORY16 3
|
|
#define HD6301_DISASM_XIM 4
|
|
|
|
/* CCR bits for clearing */
|
|
|
|
#define HD6301_CLR_HNZVC hd6301_reg_CCR &= 0xd0
|
|
#define HD6301_CLR_HNZC hd6301_reg_CCR &= 0xd2
|
|
#define HD6301_CLR_NZVC hd6301_reg_CCR &= 0xf0
|
|
#define HD6301_CLR_NZV hd6301_reg_CCR &= 0xf1
|
|
#define HD6301_CLR_NZC hd6301_reg_CCR &= 0xf2
|
|
#define HD6301_CLR_ZC hd6301_reg_CCR &= 0xfa
|
|
#define HD6301_CLR_I hd6301_reg_CCR &= 0xef
|
|
#define HD6301_CLR_Z hd6301_reg_CCR &= 0xfb
|
|
#define HD6301_CLR_V hd6301_reg_CCR &= 0xfd
|
|
#define HD6301_CLR_C hd6301_reg_CCR &= 0xfe
|
|
|
|
|
|
/**********************************
|
|
* macros for CCR processing
|
|
* adapted from mame project
|
|
**********************************/
|
|
#define HD6301_SET_Z8(a) hd6301_reg_CCR |= (((Uint8)(a) == 0) << 1)
|
|
#define HD6301_SET_Z16(a) hd6301_reg_CCR |= (((Uint16)(a) == 0) << 1)
|
|
#define HD6301_SET_N8(a) hd6301_reg_CCR |= (((a) & 0x80) >> 4)
|
|
#define HD6301_SET_N16(a) hd6301_reg_CCR |= (((a) & 0x8000) >> 12)
|
|
#define HD6301_SET_C8(a) hd6301_reg_CCR |= (((a) & 0x100) >> 8)
|
|
#define HD6301_SET_C16(a) hd6301_reg_CCR |= (((a) & 0x10000) >> 16)
|
|
#define HD6301_SET_V8(a,b,r) hd6301_reg_CCR |= ((((a)^(b)^(r)^((r)>>1)) & 0x80) >> 6)
|
|
#define HD6301_SET_V16(a,b,r) hd6301_reg_CCR |= ((((a)^(b)^(r)^((r)>>1)) & 0x8000) >> 14)
|
|
#define HD6301_SET_H(a,b,r) hd6301_reg_CCR |= ((((a)^(b)^(r)) & 0x10) << 1)
|
|
|
|
|
|
#define HD6301_SET_NZ8(a) {HD6301_SET_N8(a);HD6301_SET_Z8(a);}
|
|
#define HD6301_SET_NZ16(a) {HD6301_SET_N16(a);HD6301_SET_Z16(a);}
|
|
#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);}
|
|
#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);}
|
|
|
|
|
|
/**********************************
|
|
* Functions
|
|
**********************************/
|
|
|
|
/* HD6301 internal functions */
|
|
static Uint8 hd6301_read_memory(Uint16 addr);
|
|
static void hd6301_write_memory (Uint16 addr, Uint8 value);
|
|
static Uint16 hd6301_get_memory_ext(void);
|
|
|
|
/* HD6301 opcodes functions */
|
|
static void hd6301_undefined(void);
|
|
static void hd6301_nop(void);
|
|
static void hd6301_lsrd(void);
|
|
static void hd6301_asld(void);
|
|
static void hd6301_tap(void);
|
|
static void hd6301_tpa(void);
|
|
static void hd6301_inx(void);
|
|
static void hd6301_dex(void);
|
|
static void hd6301_clv(void);
|
|
static void hd6301_sev(void);
|
|
static void hd6301_clc(void);
|
|
static void hd6301_sec(void);
|
|
static void hd6301_cli(void);
|
|
static void hd6301_sei(void);
|
|
static void hd6301_sba(void);
|
|
static void hd6301_cba(void);
|
|
static void hd6301_tab(void);
|
|
static void hd6301_tba(void);
|
|
static void hd6301_xgdx(void);
|
|
static void hd6301_daa(void);
|
|
static void hd6301_slp(void);
|
|
static void hd6301_aba(void);
|
|
static void hd6301_bra(void);
|
|
static void hd6301_brn(void);
|
|
static void hd6301_bhi(void);
|
|
static void hd6301_bls(void);
|
|
static void hd6301_bcc(void);
|
|
static void hd6301_bcs(void);
|
|
static void hd6301_bne(void);
|
|
static void hd6301_beq(void);
|
|
static void hd6301_bvc(void);
|
|
static void hd6301_bvs(void);
|
|
static void hd6301_bpl(void);
|
|
static void hd6301_bmi(void);
|
|
static void hd6301_bge(void);
|
|
static void hd6301_blt(void);
|
|
static void hd6301_bgt(void);
|
|
static void hd6301_ble(void);
|
|
static void hd6301_tsx(void);
|
|
static void hd6301_ins(void);
|
|
static void hd6301_pula(void);
|
|
static void hd6301_pulb(void);
|
|
static void hd6301_des(void);
|
|
static void hd6301_txs(void);
|
|
static void hd6301_psha(void);
|
|
static void hd6301_pshb(void);
|
|
static void hd6301_pulx(void);
|
|
static void hd6301_rts(void);
|
|
static void hd6301_abx(void);
|
|
static void hd6301_rti(void);
|
|
static void hd6301_pshx(void);
|
|
static void hd6301_mul(void);
|
|
static void hd6301_wai(void);
|
|
static void hd6301_swi(void);
|
|
static void hd6301_nega(void);
|
|
static void hd6301_coma(void);
|
|
static void hd6301_lsra(void);
|
|
static void hd6301_rora(void);
|
|
static void hd6301_asra(void);
|
|
static void hd6301_asla(void);
|
|
static void hd6301_rola(void);
|
|
static void hd6301_deca(void);
|
|
static void hd6301_inca(void);
|
|
static void hd6301_tsta(void);
|
|
static void hd6301_clra(void);
|
|
static void hd6301_negb(void);
|
|
static void hd6301_comb(void);
|
|
static void hd6301_lsrb(void);
|
|
static void hd6301_rorb(void);
|
|
static void hd6301_asrb(void);
|
|
static void hd6301_aslb(void);
|
|
static void hd6301_rolb(void);
|
|
static void hd6301_decb(void);
|
|
static void hd6301_incb(void);
|
|
static void hd6301_tstb(void);
|
|
static void hd6301_clrb(void);
|
|
static void hd6301_neg_ind(void);
|
|
static void hd6301_aim_ind(void);
|
|
static void hd6301_oim_ind(void);
|
|
static void hd6301_com_ind(void);
|
|
static void hd6301_lsr_ind(void);
|
|
static void hd6301_eim_ind(void);
|
|
static void hd6301_ror_ind(void);
|
|
static void hd6301_asr_ind(void);
|
|
static void hd6301_asl_ind(void);
|
|
static void hd6301_rol_ind(void);
|
|
static void hd6301_dec_ind(void);
|
|
static void hd6301_tim_ind(void);
|
|
static void hd6301_inc_ind(void);
|
|
static void hd6301_tst_ind(void);
|
|
static void hd6301_jmp_ind(void);
|
|
static void hd6301_clr_ind(void);
|
|
static void hd6301_neg_ext(void);
|
|
static void hd6301_aim_dir(void);
|
|
static void hd6301_oim_dir(void);
|
|
static void hd6301_com_ext(void);
|
|
static void hd6301_lsr_ext(void);
|
|
static void hd6301_eim_dir(void);
|
|
static void hd6301_ror_ext(void);
|
|
static void hd6301_asr_ext(void);
|
|
static void hd6301_asl_ext(void);
|
|
static void hd6301_rol_ext(void);
|
|
static void hd6301_dec_ext(void);
|
|
static void hd6301_tim_dir(void);
|
|
static void hd6301_inc_ext(void);
|
|
static void hd6301_tst_ext(void);
|
|
static void hd6301_jmp_ext(void);
|
|
static void hd6301_clr_ext(void);
|
|
static void hd6301_suba_imm(void);
|
|
static void hd6301_cmpa_imm(void);
|
|
static void hd6301_sbca_imm(void);
|
|
static void hd6301_subd_imm(void);
|
|
static void hd6301_anda_imm(void);
|
|
static void hd6301_bita_imm(void);
|
|
static void hd6301_ldaa_imm(void);
|
|
static void hd6301_eora_imm(void);
|
|
static void hd6301_adca_imm(void);
|
|
static void hd6301_oraa_imm(void);
|
|
static void hd6301_adda_imm(void);
|
|
static void hd6301_cpx_imm(void);
|
|
static void hd6301_bsr(void);
|
|
static void hd6301_lds_imm(void);
|
|
static void hd6301_suba_dir(void);
|
|
static void hd6301_cmpa_dir(void);
|
|
static void hd6301_sbca_dir(void);
|
|
static void hd6301_subd_dir(void);
|
|
static void hd6301_anda_dir(void);
|
|
static void hd6301_bita_dir(void);
|
|
static void hd6301_ldaa_dir(void);
|
|
static void hd6301_staa_dir(void);
|
|
static void hd6301_eora_dir(void);
|
|
static void hd6301_adca_dir(void);
|
|
static void hd6301_oraa_dir(void);
|
|
static void hd6301_adda_dir(void);
|
|
static void hd6301_cpx_dir(void);
|
|
static void hd6301_jsr_dir(void);
|
|
static void hd6301_lds_dir(void);
|
|
static void hd6301_sts_dir(void);
|
|
static void hd6301_suba_ind(void);
|
|
static void hd6301_cmpa_ind(void);
|
|
static void hd6301_sbca_ind(void);
|
|
static void hd6301_subd_ind(void);
|
|
static void hd6301_anda_ind(void);
|
|
static void hd6301_bita_ind(void);
|
|
static void hd6301_ldaa_ind(void);
|
|
static void hd6301_staa_ind(void);
|
|
static void hd6301_eora_ind(void);
|
|
static void hd6301_adca_ind(void);
|
|
static void hd6301_oraa_ind(void);
|
|
static void hd6301_adda_ind(void);
|
|
static void hd6301_cpx_ind(void);
|
|
static void hd6301_jsr_ind(void);
|
|
static void hd6301_lds_ind(void);
|
|
static void hd6301_sts_ind(void);
|
|
static void hd6301_suba_ext(void);
|
|
static void hd6301_cmpa_ext(void);
|
|
static void hd6301_sbca_ext(void);
|
|
static void hd6301_subd_ext(void);
|
|
static void hd6301_anda_ext(void);
|
|
static void hd6301_bita_ext(void);
|
|
static void hd6301_ldaa_ext(void);
|
|
static void hd6301_staa_ext(void);
|
|
static void hd6301_eora_ext(void);
|
|
static void hd6301_adca_ext(void);
|
|
static void hd6301_oraa_ext(void);
|
|
static void hd6301_adda_ext(void);
|
|
static void hd6301_cpx_ext(void);
|
|
static void hd6301_jsr_ext(void);
|
|
static void hd6301_lds_ext(void);
|
|
static void hd6301_sts_ext(void);
|
|
static void hd6301_subb_imm(void);
|
|
static void hd6301_cmpb_imm(void);
|
|
static void hd6301_sbcb_imm(void);
|
|
static void hd6301_addd_imm(void);
|
|
static void hd6301_andb_imm(void);
|
|
static void hd6301_bitb_imm(void);
|
|
static void hd6301_ldab_imm(void);
|
|
static void hd6301_eorb_imm(void);
|
|
static void hd6301_adcb_imm(void);
|
|
static void hd6301_orab_imm(void);
|
|
static void hd6301_addb_imm(void);
|
|
static void hd6301_ldd_imm(void);
|
|
static void hd6301_ldx_imm(void);
|
|
static void hd6301_subb_dir(void);
|
|
static void hd6301_cmpb_dir(void);
|
|
static void hd6301_sbcb_dir(void);
|
|
static void hd6301_addd_dir(void);
|
|
static void hd6301_andb_dir(void);
|
|
static void hd6301_bitb_dir(void);
|
|
static void hd6301_ldab_dir(void);
|
|
static void hd6301_stab_dir(void);
|
|
static void hd6301_eorb_dir(void);
|
|
static void hd6301_adcb_dir(void);
|
|
static void hd6301_orab_dir(void);
|
|
static void hd6301_addb_dir(void);
|
|
static void hd6301_ldd_dir(void);
|
|
static void hd6301_std_dir(void);
|
|
static void hd6301_ldx_dir(void);
|
|
static void hd6301_stx_dir(void);
|
|
static void hd6301_subb_ind(void);
|
|
static void hd6301_cmpb_ind(void);
|
|
static void hd6301_sbcb_ind(void);
|
|
static void hd6301_addd_ind(void);
|
|
static void hd6301_andb_ind(void);
|
|
static void hd6301_bitb_ind(void);
|
|
static void hd6301_ldab_ind(void);
|
|
static void hd6301_stab_ind(void);
|
|
static void hd6301_eorb_ind(void);
|
|
static void hd6301_adcb_ind(void);
|
|
static void hd6301_orab_ind(void);
|
|
static void hd6301_addb_ind(void);
|
|
static void hd6301_ldd_ind(void);
|
|
static void hd6301_std_ind(void);
|
|
static void hd6301_ldx_ind(void);
|
|
static void hd6301_stx_ind(void);
|
|
static void hd6301_subb_ext(void);
|
|
static void hd6301_cmpb_ext(void);
|
|
static void hd6301_sbcb_ext(void);
|
|
static void hd6301_addd_ext(void);
|
|
static void hd6301_andb_ext(void);
|
|
static void hd6301_bitb_ext(void);
|
|
static void hd6301_ldab_ext(void);
|
|
static void hd6301_stab_ext(void);
|
|
static void hd6301_eorb_ext(void);
|
|
static void hd6301_adcb_ext(void);
|
|
static void hd6301_orab_ext(void);
|
|
static void hd6301_addb_ext(void);
|
|
static void hd6301_ldd_ext(void);
|
|
static void hd6301_std_ext(void);
|
|
static void hd6301_ldx_ext(void);
|
|
static void hd6301_stx_ext(void);
|
|
|
|
|
|
/**********************************
|
|
* Variables
|
|
**********************************/
|
|
static char hd6301_str_instr[50];
|
|
|
|
static struct hd6301_opcode_t hd6301_opcode;
|
|
|
|
static struct hd6301_opcode_t hd6301_opcode_table[256] = {
|
|
|
|
{0x00, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x01, 1, hd6301_nop, 1, "nop", HD6301_DISASM_NONE},
|
|
{0x02, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x03, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x04, 1, hd6301_lsrd, 1, "lsrd", HD6301_DISASM_NONE},
|
|
{0x05, 1, hd6301_asld, 1, "asld", HD6301_DISASM_NONE},
|
|
{0x06, 1, hd6301_tap, 1, "tap", HD6301_DISASM_NONE},
|
|
{0x07, 1, hd6301_tpa, 1, "tpa", HD6301_DISASM_NONE},
|
|
{0x08, 1, hd6301_inx, 1, "inx", HD6301_DISASM_NONE},
|
|
{0x09, 1, hd6301_dex, 1, "dex", HD6301_DISASM_NONE},
|
|
{0x0a, 1, hd6301_clv, 1, "clv", HD6301_DISASM_NONE},
|
|
{0x0b, 1, hd6301_sev, 1, "sev", HD6301_DISASM_NONE},
|
|
{0x0c, 1, hd6301_clc, 1, "clc", HD6301_DISASM_NONE},
|
|
{0x0d, 1, hd6301_sec, 1, "sec", HD6301_DISASM_NONE},
|
|
{0x0e, 1, hd6301_cli, 1, "cli", HD6301_DISASM_NONE},
|
|
{0x0f, 1, hd6301_sei, 1, "sei", HD6301_DISASM_NONE},
|
|
|
|
{0x10, 1, hd6301_sba, 1, "sba", HD6301_DISASM_NONE},
|
|
{0x11, 1, hd6301_cba, 1, "cba", HD6301_DISASM_NONE},
|
|
{0x12, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x13, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x14, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x15, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x16, 1, hd6301_tab, 1, "tab", HD6301_DISASM_NONE},
|
|
{0x17, 1, hd6301_tba, 1, "tba", HD6301_DISASM_NONE},
|
|
{0x18, 1, hd6301_xgdx, 2, "xgdx", HD6301_DISASM_NONE},
|
|
{0x19, 1, hd6301_daa, 2, "daa", HD6301_DISASM_NONE},
|
|
{0x1a, 1, hd6301_slp, 4, "slp", HD6301_DISASM_NONE},
|
|
{0x1b, 1, hd6301_aba, 1, "aba", HD6301_DISASM_NONE},
|
|
{0x1c, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x1d, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x1e, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x1f, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
|
|
{0x20, 0, hd6301_bra, 3, "bra $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x21, 0, hd6301_brn, 3, "brn $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x22, 0, hd6301_bhi, 3, "bhi $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x23, 0, hd6301_bls, 3, "bls $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x24, 0, hd6301_bcc, 3, "bcc $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x25, 0, hd6301_bcs, 3, "bcs $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x26, 0, hd6301_bne, 3, "bne $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x27, 0, hd6301_beq, 3, "beq $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x28, 0, hd6301_bvc, 3, "bvc $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x29, 0, hd6301_bvs, 3, "bvs $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x2a, 0, hd6301_bpl, 3, "bpl $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x2b, 0, hd6301_bmi, 3, "bmi $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x2c, 0, hd6301_bge, 3, "bge $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x2d, 0, hd6301_blt, 3, "blt $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x2e, 0, hd6301_bgt, 3, "bgt $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x2f, 0, hd6301_ble, 3, "ble $%02x", HD6301_DISASM_MEMORY8},
|
|
|
|
{0x30, 1, hd6301_tsx, 1, "tsx", HD6301_DISASM_NONE},
|
|
{0x31, 1, hd6301_ins, 1, "ins", HD6301_DISASM_NONE},
|
|
{0x32, 1, hd6301_pula, 3, "pula", HD6301_DISASM_NONE},
|
|
{0x33, 1, hd6301_pulb, 3, "pulb", HD6301_DISASM_NONE},
|
|
{0x34, 1, hd6301_des, 1, "des", HD6301_DISASM_NONE},
|
|
{0x35, 1, hd6301_txs, 1, "txs", HD6301_DISASM_NONE},
|
|
{0x36, 1, hd6301_psha, 4, "psha", HD6301_DISASM_NONE},
|
|
{0x37, 1, hd6301_pshb, 4, "pshb", HD6301_DISASM_NONE},
|
|
{0x38, 1, hd6301_pulx, 4, "pulx", HD6301_DISASM_NONE},
|
|
{0x39, 0, hd6301_rts, 5, "rts", HD6301_DISASM_NONE},
|
|
{0x3a, 1, hd6301_abx, 1, "abx", HD6301_DISASM_NONE},
|
|
{0x3b, 0, hd6301_rti, 10, "rti", HD6301_DISASM_NONE},
|
|
{0x3c, 1, hd6301_pshx, 5 , "pshx", HD6301_DISASM_NONE},
|
|
{0x3d, 1, hd6301_mul, 7, "mul", HD6301_DISASM_NONE},
|
|
{0x3e, 0, hd6301_wai, 9, "wai", HD6301_DISASM_NONE},
|
|
{0x3f, 0, hd6301_swi, 12, "swi", HD6301_DISASM_NONE},
|
|
|
|
{0x40, 1, hd6301_nega, 1, "nega", HD6301_DISASM_NONE},
|
|
{0x41, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x42, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x43, 1, hd6301_coma, 1, "coma", HD6301_DISASM_NONE},
|
|
{0x44, 1, hd6301_lsra, 1, "lsra", HD6301_DISASM_NONE},
|
|
{0x45, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x46, 1, hd6301_rora, 1, "rora", HD6301_DISASM_NONE},
|
|
{0x47, 1, hd6301_asra, 1, "asra", HD6301_DISASM_NONE},
|
|
{0x48, 1, hd6301_asla, 1, "lsla", HD6301_DISASM_NONE},
|
|
{0x49, 1, hd6301_rola, 1, "rola", HD6301_DISASM_NONE},
|
|
{0x4a, 1, hd6301_deca, 1, "deca", HD6301_DISASM_NONE},
|
|
{0x4b, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x4c, 1, hd6301_inca, 1, "inca", HD6301_DISASM_NONE},
|
|
{0x4d, 1, hd6301_tsta, 1, "tsta", HD6301_DISASM_NONE},
|
|
{0x4e, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x4f, 1, hd6301_clra, 1, "clra", HD6301_DISASM_NONE},
|
|
|
|
{0x50, 1, hd6301_negb, 1, "negb", HD6301_DISASM_NONE},
|
|
{0x51, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x52, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x53, 1, hd6301_comb, 1, "comb", HD6301_DISASM_NONE},
|
|
{0x54, 1, hd6301_lsrb, 1, "lsrb", HD6301_DISASM_NONE},
|
|
{0x55, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x56, 1, hd6301_rorb, 1, "rorb", HD6301_DISASM_NONE},
|
|
{0x57, 1, hd6301_asrb, 1, "asrb", HD6301_DISASM_NONE},
|
|
{0x58, 1, hd6301_aslb, 1, "lslb", HD6301_DISASM_NONE},
|
|
{0x59, 1, hd6301_rolb, 1, "rolb", HD6301_DISASM_NONE},
|
|
{0x5a, 1, hd6301_decb, 1, "decb", HD6301_DISASM_NONE},
|
|
{0x5b, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x5c, 1, hd6301_incb, 1, "incb", HD6301_DISASM_NONE},
|
|
{0x5d, 1, hd6301_tstb, 1, "tstb", HD6301_DISASM_NONE},
|
|
{0x5e, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x5f, 1, hd6301_clrb, 1, "clrb", HD6301_DISASM_NONE},
|
|
|
|
{0x60, 2, hd6301_neg_ind, 6, "neg $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0x61, 3, hd6301_aim_ind, 7, "aim #$%02x,$%02x x", HD6301_DISASM_XIM},
|
|
{0x62, 3, hd6301_oim_ind, 7, "oim #$%02x,$%02x x", HD6301_DISASM_XIM},
|
|
{0x63, 2, hd6301_com_ind, 6, "com $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0x64, 2, hd6301_lsr_ind, 6, "lsr $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0x65, 3, hd6301_eim_ind, 7, "eim #$%02x,$%02x x", HD6301_DISASM_XIM},
|
|
{0x66, 2, hd6301_ror_ind, 6, "ror $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0x67, 2, hd6301_asr_ind, 6, "asr $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0x68, 2, hd6301_asl_ind, 6, "lsl $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0x69, 2, hd6301_rol_ind, 6, "rol $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0x6a, 2, hd6301_dec_ind, 6, "dec $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0x6b, 3, hd6301_tim_ind, 5, "tim #$%02x,$%02x x", HD6301_DISASM_XIM},
|
|
{0x6c, 2, hd6301_inc_ind, 6, "inc $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0x6d, 2, hd6301_tst_ind, 4, "tst $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0x6e, 0, hd6301_jmp_ind, 3, "jmp $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0x6f, 2, hd6301_clr_ind, 5, "clr $%02x,x", HD6301_DISASM_MEMORY8},
|
|
|
|
{0x70, 3, hd6301_neg_ext, 6, "neg $%04x", HD6301_DISASM_MEMORY16},
|
|
{0x71, 3, hd6301_aim_dir, 6, "aim #$%02x,$%02x", HD6301_DISASM_XIM},
|
|
{0x72, 3, hd6301_oim_dir, 6, "oim #$%02x,$%02x", HD6301_DISASM_XIM},
|
|
{0x73, 3, hd6301_com_ext, 6, "com $%04x", HD6301_DISASM_MEMORY16},
|
|
{0x74, 3, hd6301_lsr_ext, 6, "lsr $%04x", HD6301_DISASM_MEMORY16},
|
|
{0x75, 3, hd6301_eim_dir, 6, "eim #$%02x,$%02x", HD6301_DISASM_XIM},
|
|
{0x76, 3, hd6301_ror_ext, 6, "ror $%04x", HD6301_DISASM_MEMORY16},
|
|
{0x77, 3, hd6301_asr_ext, 6, "asr $%04x", HD6301_DISASM_MEMORY16},
|
|
{0x78, 3, hd6301_asl_ext, 6, "lsl $%04x", HD6301_DISASM_MEMORY16},
|
|
{0x79, 3, hd6301_rol_ext, 6, "rol $%04x", HD6301_DISASM_MEMORY16},
|
|
{0x7a, 3, hd6301_dec_ext, 6, "dec $%04x", HD6301_DISASM_MEMORY16},
|
|
{0x7b, 3, hd6301_tim_dir, 4, "tim #$%02x,$%02x", HD6301_DISASM_XIM},
|
|
{0x7c, 3, hd6301_inc_ext, 6, "inc $%04x", HD6301_DISASM_MEMORY16},
|
|
{0x7d, 3, hd6301_tst_ext, 4, "tst $%04x", HD6301_DISASM_MEMORY16},
|
|
{0x7e, 0, hd6301_jmp_ext, 3, "jmp $%04x", HD6301_DISASM_MEMORY16},
|
|
{0x7f, 3, hd6301_clr_ext, 5, "clr $%04x", HD6301_DISASM_MEMORY16},
|
|
|
|
{0x80, 2, hd6301_suba_imm, 2, "suba #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0x81, 2, hd6301_cmpa_imm, 2, "cmpa #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0x82, 2, hd6301_sbca_imm, 2, "sbca #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0x83, 3, hd6301_subd_imm, 3, "subd #$%04x", HD6301_DISASM_MEMORY16},
|
|
{0x84, 2, hd6301_anda_imm, 2, "anda #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0x85, 2, hd6301_bita_imm, 2, "bita #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0x86, 2, hd6301_ldaa_imm, 2, "ldaa #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0x87, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0x88, 2, hd6301_eora_imm, 2, "eora #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0x89, 2, hd6301_adca_imm, 2, "adca #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0x8a, 2, hd6301_oraa_imm, 2, "oraa #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0x8b, 2, hd6301_adda_imm, 2, "adda #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0x8c, 3, hd6301_cpx_imm, 3, "cpx #$%04x", HD6301_DISASM_MEMORY16},
|
|
{0x8d, 0, hd6301_bsr, 5, "bsr $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x8e, 3, hd6301_lds_imm, 3, "lds #$%04x", HD6301_DISASM_MEMORY16},
|
|
{0x8f, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
|
|
{0x90, 2, hd6301_suba_dir, 3, "suba $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x91, 2, hd6301_cmpa_dir, 3, "cmpa $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x92, 2, hd6301_sbca_dir, 3, "sbca $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x93, 2, hd6301_subd_dir, 4, "subd $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x94, 2, hd6301_anda_dir, 3, "anda $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x95, 2, hd6301_bita_dir, 3, "bita $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x96, 2, hd6301_ldaa_dir, 3, "ldaa $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x97, 2, hd6301_staa_dir, 3, "staa $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x98, 2, hd6301_eora_dir, 3, "eora $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x99, 2, hd6301_adca_dir, 3, "adca $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x9a, 2, hd6301_oraa_dir, 3, "oraa $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x9b, 2, hd6301_adda_dir, 3, "adda $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x9c, 2, hd6301_cpx_dir, 4, "cpx $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x9d, 0, hd6301_jsr_dir, 5, "jsr $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x9e, 2, hd6301_lds_dir, 4, "lds $%02x", HD6301_DISASM_MEMORY8},
|
|
{0x9f, 2, hd6301_sts_dir, 4, "sts $%02x", HD6301_DISASM_MEMORY8},
|
|
|
|
{0xa0, 2, hd6301_suba_ind, 4, "suba $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xa1, 2, hd6301_cmpa_ind, 4, "cmpa $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xa2, 2, hd6301_sbca_ind, 4, "sbca $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xa3, 2, hd6301_subd_ind, 5, "subd $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xa4, 2, hd6301_anda_ind, 4, "anda $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xa5, 2, hd6301_bita_ind, 4, "bita $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xa6, 2, hd6301_ldaa_ind, 4, "ldaa $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xa7, 2, hd6301_staa_ind, 4, "staa $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xa8, 2, hd6301_eora_ind, 4, "eora $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xa9, 2, hd6301_adca_ind, 4, "adca $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xaa, 2, hd6301_oraa_ind, 4, "oraa $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xab, 2, hd6301_adda_ind, 4, "adda $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xac, 2, hd6301_cpx_ind, 5, "cpx $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xad, 0, hd6301_jsr_ind, 5, "jsr $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xae, 2, hd6301_lds_ind, 5, "lds $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xaf, 2, hd6301_sts_ind, 5, "sts $%02x,x", HD6301_DISASM_MEMORY8},
|
|
|
|
{0xb0, 3, hd6301_suba_ext, 4, "suba $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xb1, 3, hd6301_cmpa_ext, 4, "cmpa $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xb2, 3, hd6301_sbca_ext, 4, "sbca $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xb3, 3, hd6301_subd_ext, 5, "subd $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xb4, 3, hd6301_anda_ext, 4, "anda $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xb5, 3, hd6301_bita_ext, 4, "bita $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xb6, 3, hd6301_ldaa_ext, 4, "ldaa $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xb7, 3, hd6301_staa_ext, 4, "staa $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xb8, 3, hd6301_eora_ext, 4, "eora $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xb9, 3, hd6301_adca_ext, 4, "adca $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xba, 3, hd6301_oraa_ext, 4, "oraa $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xbb, 3, hd6301_adda_ext, 4, "adda $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xbc, 3, hd6301_cpx_ext, 5, "cpx $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xbd, 0, hd6301_jsr_ext, 6, "jsr $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xbe, 3, hd6301_lds_ext, 5, "lds $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xbf, 3, hd6301_sts_ext, 5, "sts $%04x", HD6301_DISASM_MEMORY16},
|
|
|
|
{0xc0, 2, hd6301_subb_imm, 2, "subb #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0xc1, 2, hd6301_cmpb_imm, 2, "cmpb #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0xc2, 2, hd6301_sbcb_imm, 2, "sbcb #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0xc3, 3, hd6301_addd_imm, 3, "addd #$%04x", HD6301_DISASM_MEMORY16},
|
|
{0xc4, 2, hd6301_andb_imm, 2, "andb #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0xc5, 2, hd6301_bitb_imm, 2, "bitb #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0xc6, 2, hd6301_ldab_imm, 2, "ldab #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0xc7, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0xc8, 2, hd6301_eorb_imm, 2, "eorb #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0xc9, 2, hd6301_adcb_imm, 2, "adcb #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0xca, 2, hd6301_orab_imm, 2, "orab #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0xcb, 2, hd6301_addb_imm, 2, "addb #$%02x", HD6301_DISASM_MEMORY8},
|
|
{0xcc, 3, hd6301_ldd_imm, 3, "ldd #$%04x", HD6301_DISASM_MEMORY16},
|
|
{0xcd, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
{0xce, 3, hd6301_ldx_imm, 3, "ldx #$%04x", HD6301_DISASM_MEMORY16},
|
|
{0xcf, 0, hd6301_undefined, 0, "", HD6301_DISASM_UNDEFINED},
|
|
|
|
{0xd0, 2, hd6301_subb_dir, 3, "subb $%02x", HD6301_DISASM_MEMORY8},
|
|
{0xd1, 2, hd6301_cmpb_dir, 3, "cmpb $%02x", HD6301_DISASM_MEMORY8},
|
|
{0xd2, 2, hd6301_sbcb_dir, 3, "sbcb $%02x", HD6301_DISASM_MEMORY8},
|
|
{0xd3, 2, hd6301_addd_dir, 4, "addd $%02x", HD6301_DISASM_MEMORY8},
|
|
{0xd4, 2, hd6301_andb_dir, 3, "andb $%02x", HD6301_DISASM_MEMORY8},
|
|
{0xd5, 2, hd6301_bitb_dir, 3, "bitb $%02x", HD6301_DISASM_MEMORY8},
|
|
{0xd6, 2, hd6301_ldab_dir, 3, "ldab $%02x", HD6301_DISASM_MEMORY8},
|
|
{0xd7, 2, hd6301_stab_dir, 3, "stab $%02x", HD6301_DISASM_MEMORY8},
|
|
{0xd8, 2, hd6301_eorb_dir, 3, "eorb $%02x", HD6301_DISASM_MEMORY8},
|
|
{0xd9, 2, hd6301_adcb_dir, 3, "adcb $%02x", HD6301_DISASM_MEMORY8},
|
|
{0xda, 2, hd6301_orab_dir, 3, "orab $%02x", HD6301_DISASM_MEMORY8},
|
|
{0xdb, 2, hd6301_addb_dir, 3, "addb $%02x", HD6301_DISASM_MEMORY8},
|
|
{0xdc, 2, hd6301_ldd_dir, 4, "ldd $%02x", HD6301_DISASM_MEMORY8},
|
|
{0xdd, 2, hd6301_std_dir, 4, "std $%02x", HD6301_DISASM_MEMORY8},
|
|
{0xde, 2, hd6301_ldx_dir, 4, "ldx $%02x", HD6301_DISASM_MEMORY8},
|
|
{0xdf, 2, hd6301_stx_dir, 4, "stx $%02x", HD6301_DISASM_MEMORY8},
|
|
|
|
{0xe0, 2, hd6301_subb_ind, 4, "subb $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xe1, 2, hd6301_cmpb_ind, 4, "cmpb $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xe2, 2, hd6301_sbcb_ind, 4, "sbcb $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xe3, 2, hd6301_addd_ind, 5, "addd $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xe4, 2, hd6301_andb_ind, 4, "andb $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xe5, 2, hd6301_bitb_ind, 4, "bitb $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xe6, 2, hd6301_ldab_ind, 4, "ldab $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xe7, 2, hd6301_stab_ind, 4, "stab $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xe8, 2, hd6301_eorb_ind, 4, "eorb $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xe9, 2, hd6301_adcb_ind, 4, "adcb $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xea, 2, hd6301_orab_ind, 4, "orab $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xeb, 2, hd6301_addb_ind, 4, "addb $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xec, 2, hd6301_ldd_ind, 5, "ldd $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xed, 2, hd6301_std_ind, 5, "std $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xee, 2, hd6301_ldx_ind, 5, "ldx $%02x,x", HD6301_DISASM_MEMORY8},
|
|
{0xef, 2, hd6301_stx_ind, 5, "stx $%02x,x", HD6301_DISASM_MEMORY8},
|
|
|
|
{0xf0, 3, hd6301_subb_ext, 4, "subb $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xf1, 3, hd6301_cmpb_ext, 4, "cmpb $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xf2, 3, hd6301_sbcb_ext, 4, "sbcb $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xf3, 3, hd6301_addd_ext, 5, "addd $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xf4, 3, hd6301_andb_ext, 4, "andb $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xf5, 3, hd6301_bitb_ext, 4, "bitb $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xf6, 3, hd6301_ldab_ext, 4, "ldab $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xf7, 3, hd6301_stab_ext, 4, "stab $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xf8, 3, hd6301_eorb_ext, 4, "eorb $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xf9, 3, hd6301_adcb_ext, 4, "adcb $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xfa, 3, hd6301_orab_ext, 4, "orab $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xfb, 3, hd6301_addb_ext, 4, "addb $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xfc, 3, hd6301_ldd_ext, 5, "ldd $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xfd, 3, hd6301_std_ext, 5, "std $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xfe, 3, hd6301_ldx_ext, 5, "ldx $%04x", HD6301_DISASM_MEMORY16},
|
|
{0xff, 3, hd6301_stx_ext, 5, "stx $%04x", HD6301_DISASM_MEMORY16}
|
|
};
|
|
|
|
|
|
/* Variables */
|
|
static Uint8 hd6301_cycles;
|
|
static Uint8 hd6301_cur_inst;
|
|
|
|
static Sint8 hd6301_reg_A;
|
|
static Sint8 hd6301_reg_B;
|
|
static Sint16 hd6301_reg_X;
|
|
static Uint16 hd6301_reg_SP;
|
|
static Uint16 hd6301_reg_PC;
|
|
static Uint8 hd6301_reg_CCR;
|
|
|
|
//Uint8 hd6301_reg_RMCR;
|
|
|
|
static Uint8 hd6301_intREG[32];
|
|
static Uint8 hd6301_intRAM[128];
|
|
static Uint8 hd6301_intROM[4096];
|
|
|
|
|
|
/**********************************
|
|
* Emulator kernel
|
|
**********************************/
|
|
|
|
/**
|
|
* Initialise hd6301 cpu
|
|
*/
|
|
void hd6301_init_cpu(void)
|
|
{
|
|
hd6301_reg_CCR = 0xc0;
|
|
}
|
|
|
|
/**
|
|
* Execute 1 hd6301 instruction
|
|
*/
|
|
void hd6301_execute_one_instruction(void)
|
|
{
|
|
hd6301_cur_inst = hd6301_read_memory(hd6301_reg_PC);
|
|
|
|
/* Get opcode to execute */
|
|
hd6301_opcode = hd6301_opcode_table[hd6301_cur_inst];
|
|
|
|
/* disasm opcode ? */
|
|
#ifdef HD6301_DISASM
|
|
hd6301_disasm();
|
|
#endif
|
|
/* execute opcode */
|
|
hd6301_opcode.op_func();
|
|
|
|
#ifdef HD6301_DISPLAY_REGS
|
|
hd6301_display_registers();
|
|
#endif
|
|
|
|
/* Increment instruction cycles */
|
|
hd6301_cycles += hd6301_opcode.op_n_cycles;
|
|
|
|
/* Increment PC register */
|
|
hd6301_reg_PC += hd6301_opcode.op_bytes;
|
|
|
|
/* post process interrupts */
|
|
|
|
/* post process timers */
|
|
|
|
/* post process SCI */
|
|
}
|
|
|
|
/**
|
|
* Read hd6301 memory (Ram, Rom, Internal registers)
|
|
*/
|
|
static Uint8 hd6301_read_memory(Uint16 addr)
|
|
{
|
|
/* Internal registers */
|
|
if (addr <= 0x1f) {
|
|
return hd6301_intREG[addr];
|
|
}
|
|
|
|
/* Internal RAM */
|
|
if ((addr >= 0x80) && (addr <= 0xff)) {
|
|
return hd6301_intRAM[addr-0x80];
|
|
}
|
|
|
|
/* Internal ROM */
|
|
if (addr >= 0xf000) {
|
|
return hd6301_intROM[addr-0xf000];
|
|
}
|
|
|
|
fprintf(stderr, "hd6301: 0x%04x: 0x%04x illegal memory address\n", hd6301_reg_PC, addr);
|
|
exit(-1);
|
|
}
|
|
|
|
/**
|
|
* Write hd6301 memory (Ram, Internal registers)
|
|
*/
|
|
static void hd6301_write_memory (Uint16 addr, Uint8 value)
|
|
{
|
|
/* Internal registers */
|
|
if (addr <= 0x1f) {
|
|
hd6301_intREG[addr] = value;
|
|
}
|
|
|
|
/* Internal RAM */
|
|
else if ((addr >= 0x80) && (addr <= 0xff)) {
|
|
hd6301_intRAM[addr-0x80] = value;
|
|
}
|
|
|
|
/* Internal ROM */
|
|
else if (addr >= 0xf000) {
|
|
fprintf(stderr, "hd6301: 0x%04x: attempt to write to rom\n", addr);
|
|
}
|
|
|
|
/* Illegal address */
|
|
else {
|
|
fprintf(stderr, "hd6301: 0x%04x: write to illegal address\n", addr);
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get extended memory (16 bits)
|
|
*/
|
|
static Uint16 hd6301_get_memory_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1)<<8;
|
|
addr += hd6301_read_memory(hd6301_reg_PC+2);
|
|
return addr;
|
|
}
|
|
|
|
/**
|
|
* Undefined opcode
|
|
*/
|
|
static void hd6301_undefined(void)
|
|
{
|
|
fprintf(stderr, "hd6301: 0x%04x: 0x%02x unknown instruction\n", hd6301_reg_PC, hd6301_cur_inst);
|
|
exit(-1); /* TODO: Trap the error correctly */
|
|
}
|
|
|
|
/**
|
|
* NOP : no operation
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_nop(void)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* LSRD : logical Shift Right, accumulator D : D=D>>1
|
|
*
|
|
* HINZVC
|
|
* ..0***
|
|
*/
|
|
static void hd6301_lsrd(void)
|
|
{
|
|
Uint16 regD;
|
|
Uint8 carry;
|
|
|
|
regD = (hd6301_reg_A<<8) + hd6301_reg_B;
|
|
carry = regD & 1;
|
|
regD >>= 1;
|
|
|
|
hd6301_reg_A = regD >> 8;
|
|
hd6301_reg_B = regD;
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_Z16(regD);
|
|
hd6301_reg_CCR |= ((0 ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* ASLD : arythmetic Shift left, accumulator D : D=D<<1
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_asld(void)
|
|
{
|
|
Uint16 regD;
|
|
Uint8 carry, bitN;
|
|
|
|
regD = (hd6301_reg_A<<8) + hd6301_reg_B;
|
|
carry = (regD >> 15) & 1;
|
|
regD <<= 1;
|
|
|
|
hd6301_reg_A = regD >> 8;
|
|
hd6301_reg_B = regD;
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_NZ16(regD);
|
|
bitN = (hd6301_reg_CCR & 0x8) >> 3;
|
|
hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
|
|
/**
|
|
* TAP : transfer accumulator A into register CCR : CCR=A
|
|
*
|
|
* HINZVC
|
|
* ******
|
|
*/
|
|
static void hd6301_tap(void)
|
|
{
|
|
hd6301_reg_CCR = hd6301_reg_A;
|
|
hd6301_reg_CCR |= 0xc0;
|
|
}
|
|
|
|
/**
|
|
* TPA : transfer register CCR into accumulator A : A=CCR
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_tpa(void)
|
|
{
|
|
hd6301_reg_A = hd6301_reg_CCR;
|
|
}
|
|
|
|
/**
|
|
* INX : increment register X : X=X+1
|
|
*
|
|
* HINZVC
|
|
* ...*..
|
|
*/
|
|
static void hd6301_inx(void)
|
|
{
|
|
++ hd6301_reg_X;
|
|
|
|
HD6301_CLR_Z;
|
|
HD6301_SET_Z16(hd6301_reg_X);
|
|
}
|
|
|
|
/**
|
|
* DEX : decrement register X : X=X-1
|
|
*
|
|
* HINZVC
|
|
* ...*..
|
|
*/
|
|
static void hd6301_dex(void)
|
|
{
|
|
-- hd6301_reg_X;
|
|
|
|
HD6301_CLR_Z;
|
|
HD6301_SET_Z16(hd6301_reg_X);
|
|
}
|
|
|
|
/**
|
|
* CLV : clear register CCR bit V : V=0
|
|
*
|
|
* HINZVC
|
|
* ....0.
|
|
*/
|
|
static void hd6301_clv(void)
|
|
{
|
|
HD6301_CLR_V;
|
|
}
|
|
|
|
/**
|
|
* SEV : set register CCR bit V : V=1
|
|
*
|
|
* HINZVC
|
|
* ....1.
|
|
*/
|
|
static void hd6301_sev(void)
|
|
{
|
|
hd6301_reg_CCR |= 1<<hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* CLC : clear register CCR bit C : C=0
|
|
*
|
|
* HINZVC
|
|
* .....0
|
|
*/
|
|
static void hd6301_clc(void)
|
|
{
|
|
HD6301_CLR_C;
|
|
}
|
|
|
|
/**
|
|
* SEC : set register CCR bit C : C=1
|
|
*
|
|
* HINZVC
|
|
* .....1
|
|
*/
|
|
static void hd6301_sec(void)
|
|
{
|
|
hd6301_reg_CCR |= 1<<hd6301_REG_CCR_C;
|
|
}
|
|
|
|
/**
|
|
* CLI : clear register CCR bit I : I=0
|
|
*
|
|
* HINZVC
|
|
* .0....
|
|
*/
|
|
static void hd6301_cli(void)
|
|
{
|
|
HD6301_CLR_I;
|
|
}
|
|
|
|
/**
|
|
* SEI : set register CCR bit I : I=1
|
|
*
|
|
* HINZVC
|
|
* .1....
|
|
*/
|
|
static void hd6301_sei(void)
|
|
{
|
|
hd6301_reg_CCR |= 1<<hd6301_REG_CCR_I;
|
|
}
|
|
|
|
/**
|
|
* SBA : subtract accumulator B from accumulator A : A=A-B
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_sba(void)
|
|
{
|
|
Uint16 result;
|
|
|
|
result = hd6301_reg_A - hd6301_reg_B;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, hd6301_reg_B, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* CBA : compare accumulator A and accumulator B : A-B
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_cba(void)
|
|
{
|
|
Uint16 result;
|
|
|
|
result = hd6301_reg_A - hd6301_reg_B;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, hd6301_reg_B, result);
|
|
}
|
|
|
|
/**
|
|
* TAB : transfer accumulator A into accumulator B : B=A
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_tab(void)
|
|
{
|
|
hd6301_reg_B = hd6301_reg_A;
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* TBA : transfer accumulator B into accumulator A : A=B
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_tba(void)
|
|
{
|
|
hd6301_reg_A = hd6301_reg_B;
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* XGDX : exchange register X and accumulator D : X<->D
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_xgdx(void)
|
|
{
|
|
Uint16 temp;
|
|
|
|
temp = hd6301_reg_X;
|
|
hd6301_reg_X = (hd6301_reg_A << 8) + hd6301_reg_B;
|
|
hd6301_reg_A = temp >> 8;
|
|
hd6301_reg_B = temp;
|
|
}
|
|
|
|
/**
|
|
* DAA : converts binary add of BCD characters into BCD format : A=BCD(A)
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_daa(void)
|
|
{
|
|
/* Todo */
|
|
}
|
|
|
|
/**
|
|
* SLP : sleep
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_slp(void)
|
|
{
|
|
/* Todo */
|
|
}
|
|
|
|
/**
|
|
* ABA : add accumulator A and accumulator B into accumulator A : A=A+B
|
|
*
|
|
* HINZVC
|
|
* *.****
|
|
*/
|
|
static void hd6301_aba(void)
|
|
{
|
|
Uint16 result;
|
|
|
|
result = hd6301_reg_A + hd6301_reg_B;
|
|
|
|
HD6301_CLR_HNZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, hd6301_reg_B, result);
|
|
HD6301_SET_H(hd6301_reg_A, hd6301_reg_B, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* BRA : branch always
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_bra(void)
|
|
{
|
|
Sint8 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC + 1);
|
|
hd6301_reg_PC += addr + 2;
|
|
}
|
|
|
|
/**
|
|
* BRN : branch never
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_brn(void)
|
|
{
|
|
hd6301_reg_PC += 2;
|
|
}
|
|
|
|
/**
|
|
* BHI : branch if higher : C|Z=0
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_bhi(void)
|
|
{
|
|
Sint8 addr;
|
|
Uint8 bitC, bitZ;
|
|
|
|
bitC = (hd6301_reg_CCR >> hd6301_REG_CCR_C) & 1;
|
|
bitZ = (hd6301_reg_CCR >> hd6301_REG_CCR_Z) & 1;
|
|
addr = 2;
|
|
if ((bitC | bitZ) == 0) {
|
|
addr += hd6301_read_memory(hd6301_reg_PC + 1);
|
|
}
|
|
hd6301_reg_PC += addr;
|
|
}
|
|
|
|
/**
|
|
* BLS : branch if lower or same : C|Z=1
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_bls(void)
|
|
{
|
|
Sint8 addr;
|
|
Uint8 bitC, bitZ;
|
|
|
|
bitC = (hd6301_reg_CCR >> hd6301_REG_CCR_C) & 1;
|
|
bitZ = (hd6301_reg_CCR >> hd6301_REG_CCR_Z) & 1;
|
|
addr = 2;
|
|
if ((bitC | bitZ) == 1) {
|
|
addr += hd6301_read_memory(hd6301_reg_PC + 1);
|
|
}
|
|
hd6301_reg_PC += addr;
|
|
}
|
|
|
|
/**
|
|
* BCC : branch if carry clear : C=0
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_bcc(void)
|
|
{
|
|
Sint8 addr;
|
|
Uint8 bitC;
|
|
|
|
bitC = (hd6301_reg_CCR >> hd6301_REG_CCR_C) & 1;
|
|
addr = 2;
|
|
if (bitC == 0) {
|
|
addr += hd6301_read_memory(hd6301_reg_PC + 1);
|
|
}
|
|
hd6301_reg_PC += addr;
|
|
}
|
|
|
|
/**
|
|
* BCS : branch if carry set : C=1
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_bcs(void)
|
|
{
|
|
Sint8 addr;
|
|
Uint8 bitC;
|
|
|
|
bitC = (hd6301_reg_CCR >> hd6301_REG_CCR_C) & 1;
|
|
addr = 2;
|
|
if (bitC == 1) {
|
|
addr += hd6301_read_memory(hd6301_reg_PC + 1);
|
|
}
|
|
hd6301_reg_PC += addr;
|
|
}
|
|
|
|
/**
|
|
* BNE : branch if not equal 0 : Z=0
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_bne(void)
|
|
{
|
|
Sint8 addr;
|
|
Uint8 bitZ;
|
|
|
|
bitZ = (hd6301_reg_CCR >> hd6301_REG_CCR_Z) & 1;
|
|
addr = 2;
|
|
if (bitZ == 0) {
|
|
addr += hd6301_read_memory(hd6301_reg_PC + 1);
|
|
}
|
|
hd6301_reg_PC += addr;
|
|
}
|
|
|
|
/**
|
|
* BEQ : branch if equal 0 : Z=1
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_beq(void)
|
|
{
|
|
Sint8 addr;
|
|
Uint8 bitZ;
|
|
|
|
bitZ = (hd6301_reg_CCR >> hd6301_REG_CCR_Z) & 1;
|
|
addr = 2;
|
|
if (bitZ == 1) {
|
|
addr += hd6301_read_memory(hd6301_reg_PC + 1);
|
|
}
|
|
hd6301_reg_PC += addr;
|
|
}
|
|
|
|
/**
|
|
* BVC : branch if overflow clear : V=0
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_bvc(void)
|
|
{
|
|
Sint8 addr;
|
|
Uint8 bitV;
|
|
|
|
bitV = (hd6301_reg_CCR >> hd6301_REG_CCR_V) & 1;
|
|
addr = 2;
|
|
if (bitV == 0) {
|
|
addr += hd6301_read_memory(hd6301_reg_PC + 1);
|
|
}
|
|
hd6301_reg_PC += addr;
|
|
}
|
|
|
|
/**
|
|
* BVS : branch if overflow set : V=1
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_bvs(void)
|
|
{
|
|
Sint8 addr;
|
|
Uint8 bitV;
|
|
|
|
bitV = (hd6301_reg_CCR >> hd6301_REG_CCR_V) & 1;
|
|
addr = 2;
|
|
if (bitV == 1) {
|
|
addr += hd6301_read_memory(hd6301_reg_PC + 1);
|
|
}
|
|
hd6301_reg_PC += addr;
|
|
}
|
|
|
|
/**
|
|
* BPL : branch if plus : N=0
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_bpl(void)
|
|
{
|
|
Sint8 addr;
|
|
Uint8 bitN;
|
|
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
addr = 2;
|
|
if (bitN == 0) {
|
|
addr += hd6301_read_memory(hd6301_reg_PC + 1);
|
|
}
|
|
hd6301_reg_PC += addr;
|
|
}
|
|
|
|
/**
|
|
* BMI : branch if minus : N=1
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_bmi(void)
|
|
{
|
|
Sint8 addr;
|
|
Uint8 bitN;
|
|
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
addr = 2;
|
|
if (bitN == 1) {
|
|
addr += hd6301_read_memory(hd6301_reg_PC + 1);
|
|
}
|
|
hd6301_reg_PC += addr;
|
|
}
|
|
|
|
/**
|
|
* BGE : branch if greater or equal to zero : N^V=0
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_bge(void)
|
|
{
|
|
Sint8 addr;
|
|
Uint8 bitN, bitV;
|
|
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
bitV = (hd6301_reg_CCR >> hd6301_REG_CCR_V) & 1;
|
|
addr = 2;
|
|
if ((bitN ^ bitV) == 0) {
|
|
addr += hd6301_read_memory(hd6301_reg_PC + 1);
|
|
}
|
|
hd6301_reg_PC += addr;
|
|
}
|
|
|
|
/**
|
|
* BLT : branch if lower to zero : N^V=1
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_blt(void)
|
|
{
|
|
Sint8 addr;
|
|
Uint8 bitN, bitV;
|
|
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
bitV = (hd6301_reg_CCR >> hd6301_REG_CCR_V) & 1;
|
|
addr = 2;
|
|
if ((bitN ^ bitV) == 1) {
|
|
addr += hd6301_read_memory(hd6301_reg_PC + 1);
|
|
}
|
|
hd6301_reg_PC += addr;
|
|
}
|
|
|
|
/**
|
|
* BGT : branch if greater to zero : Z|(N^V)=0
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_bgt(void)
|
|
{
|
|
Sint8 addr;
|
|
Uint8 bitN, bitV, bitZ;
|
|
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
bitV = (hd6301_reg_CCR >> hd6301_REG_CCR_V) & 1;
|
|
bitZ = (hd6301_reg_CCR >> hd6301_REG_CCR_Z) & 1;
|
|
addr = 2;
|
|
if ((bitZ | (bitN ^ bitV)) == 0) {
|
|
addr += hd6301_read_memory(hd6301_reg_PC + 1);
|
|
}
|
|
hd6301_reg_PC += addr;
|
|
}
|
|
|
|
/**
|
|
* BLE : branch if lower or equal to zero : Z|(N^V)=1
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_ble(void)
|
|
{
|
|
Sint8 addr;
|
|
Uint8 bitN, bitV, bitZ;
|
|
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
bitV = (hd6301_reg_CCR >> hd6301_REG_CCR_V) & 1;
|
|
bitZ = (hd6301_reg_CCR >> hd6301_REG_CCR_Z) & 1;
|
|
addr = 2;
|
|
if ((bitZ | (bitN ^ bitV)) == 1) {
|
|
addr += hd6301_read_memory(hd6301_reg_PC + 1);
|
|
}
|
|
hd6301_reg_PC += addr;
|
|
}
|
|
|
|
/**
|
|
* TSX : transfer stack pointer to register X : X=SP+1
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_tsx(void)
|
|
{
|
|
hd6301_reg_X = hd6301_reg_SP + 1;
|
|
}
|
|
|
|
/**
|
|
* INS : increment stack pointer : SP=SP+1
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_ins(void)
|
|
{
|
|
++ hd6301_reg_SP;
|
|
}
|
|
|
|
/**
|
|
* PULA : pull accumulator A from stack : SP=SP+1 ; A=(SP)
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_pula(void)
|
|
{
|
|
++ hd6301_reg_SP;
|
|
hd6301_reg_A = hd6301_read_memory(hd6301_reg_SP);
|
|
}
|
|
|
|
/**
|
|
* PULB : pull accumulator B from stack : SP=SP+1 ; B=(SP)
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_pulb(void)
|
|
{
|
|
++ hd6301_reg_SP;
|
|
hd6301_reg_B = hd6301_read_memory(hd6301_reg_SP);
|
|
}
|
|
|
|
/**
|
|
* DES : decrement stack pointer : SP=SP-1
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_des(void)
|
|
{
|
|
-- hd6301_reg_SP;
|
|
}
|
|
|
|
/**
|
|
* TXS : transfer register X to stack pointer : SP=X-1
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_txs(void)
|
|
{
|
|
hd6301_reg_SP = hd6301_reg_X - 1;
|
|
}
|
|
|
|
/**
|
|
* PSHA : push accumulator A to stack : (SP)=A ; SP=SP-1
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_psha(void)
|
|
{
|
|
hd6301_write_memory(hd6301_reg_SP, hd6301_reg_A);
|
|
-- hd6301_reg_SP;
|
|
}
|
|
|
|
/**
|
|
* PSHB : push accumulator B to stack : (SP)=B ; SP=SP-1
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_pshb(void)
|
|
{
|
|
hd6301_write_memory(hd6301_reg_SP, hd6301_reg_B);
|
|
-- hd6301_reg_SP;
|
|
}
|
|
|
|
/**
|
|
* PULX : pull register X from stack : SP=SP+1 ; X=(SP)
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_pulx(void)
|
|
{
|
|
hd6301_reg_X = hd6301_read_memory(++hd6301_reg_SP)<<8;
|
|
hd6301_reg_X += hd6301_read_memory(++hd6301_reg_SP);
|
|
}
|
|
|
|
/**
|
|
* RTS : return from subroutine
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_rts(void)
|
|
{
|
|
hd6301_reg_PC = hd6301_read_memory(++hd6301_reg_SP)<<8;
|
|
hd6301_reg_PC += hd6301_read_memory(++hd6301_reg_SP);
|
|
}
|
|
|
|
/**
|
|
* ABX : add accumulator B to register X : X=X+B
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_abx(void)
|
|
{
|
|
hd6301_reg_X += hd6301_reg_B;
|
|
}
|
|
|
|
/**
|
|
* RTI : return from interrupt
|
|
*
|
|
* HINZVC
|
|
* ******
|
|
*/
|
|
static void hd6301_rti(void)
|
|
{
|
|
hd6301_reg_CCR = hd6301_read_memory(++hd6301_reg_SP);
|
|
hd6301_reg_B = hd6301_read_memory(++hd6301_reg_SP);
|
|
hd6301_reg_A = hd6301_read_memory(++hd6301_reg_SP);
|
|
hd6301_reg_X = hd6301_read_memory(++hd6301_reg_SP)<<8;
|
|
hd6301_reg_X += hd6301_read_memory(++hd6301_reg_SP);
|
|
hd6301_reg_PC = hd6301_read_memory(++hd6301_reg_SP)<<8;
|
|
hd6301_reg_PC += hd6301_read_memory(++hd6301_reg_SP);
|
|
}
|
|
|
|
/**
|
|
* PSHX : push register X to stack : (SP)=X ; SP=SP-1
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_pshx(void)
|
|
{
|
|
hd6301_write_memory(hd6301_reg_SP--, hd6301_reg_X & 0xff);
|
|
hd6301_write_memory(hd6301_reg_SP--, hd6301_reg_X >> 8);
|
|
}
|
|
|
|
/**
|
|
* MUL : multiply unsigned : D=A*B
|
|
*
|
|
* HINZVC
|
|
* .....*
|
|
*/
|
|
static void hd6301_mul(void)
|
|
{
|
|
Uint16 regD;
|
|
|
|
regD = hd6301_reg_B * hd6301_reg_A;
|
|
hd6301_reg_A = regD >> 8;
|
|
hd6301_reg_B = regD;
|
|
|
|
HD6301_CLR_C;
|
|
hd6301_reg_CCR |= hd6301_reg_B >> 7;
|
|
}
|
|
|
|
/**
|
|
* WAI : wait for interrupt
|
|
*
|
|
* HINZVC
|
|
* .*....
|
|
*/
|
|
static void hd6301_wai(void)
|
|
{
|
|
/* Todo */
|
|
}
|
|
|
|
/**
|
|
* SWI : software interrupt
|
|
*
|
|
* HINZVC
|
|
* .1....
|
|
*/
|
|
static void hd6301_swi(void)
|
|
{
|
|
hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC+1) & 0xff);
|
|
hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC+1) >> 8);
|
|
hd6301_write_memory(hd6301_reg_SP--, hd6301_reg_X & 0xff);
|
|
hd6301_write_memory(hd6301_reg_SP--, hd6301_reg_X >> 8);
|
|
hd6301_write_memory(hd6301_reg_SP--, hd6301_reg_A);
|
|
hd6301_write_memory(hd6301_reg_SP--, hd6301_reg_B);
|
|
hd6301_write_memory(hd6301_reg_SP--, hd6301_reg_CCR);
|
|
|
|
hd6301_reg_PC = hd6301_read_memory(0xfffa) << 8;
|
|
hd6301_reg_PC += hd6301_read_memory(0xfffb);
|
|
|
|
hd6301_reg_CCR |= 1 << hd6301_REG_CCR_I;
|
|
}
|
|
|
|
/**
|
|
* NEGA : negate accumulator A : A=0-A
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_nega(void)
|
|
{
|
|
Uint8 value;
|
|
|
|
value = 0 - hd6301_reg_A;
|
|
hd6301_reg_A = value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_NZ8(value);
|
|
hd6301_reg_CCR |= (value != 0x0);
|
|
hd6301_reg_CCR |= (value == 0x80) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* COMA : complement 1 accumulator A : A=~A
|
|
*
|
|
* HINZVC
|
|
* ..**01
|
|
*/
|
|
static void hd6301_coma(void)
|
|
{
|
|
hd6301_reg_A = ~hd6301_reg_A;
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= 1;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* LSRA : logical shift right, accumulator A : A=A>>1
|
|
*
|
|
* HINZVC
|
|
* ..0***
|
|
*/
|
|
static void hd6301_lsra(void)
|
|
{
|
|
Uint8 carry;
|
|
|
|
carry = hd6301_reg_A & 1;
|
|
hd6301_reg_A >>= 1;
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_Z8(hd6301_reg_A);
|
|
hd6301_reg_CCR |= ((0 ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* RORA : rotate right, accumulator A : A=A>>1 + carry<<8
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_rora(void)
|
|
{
|
|
Uint8 carry, result, bitN;
|
|
|
|
carry = hd6301_reg_A & 1;
|
|
result = (hd6301_reg_CCR & 1) << 7;
|
|
result += hd6301_reg_A >> 1;
|
|
hd6301_reg_A = result;
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* ASRA : arithmetic shift right, accumulator A : A=A>>1
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_asra(void)
|
|
{
|
|
Uint8 carry, bitN;
|
|
|
|
carry = hd6301_reg_A & 1;
|
|
hd6301_reg_A >>= 1;
|
|
hd6301_reg_A |= (hd6301_reg_A & 0x40) << 1;
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* ASLA : arithmetic shift left, accumulator A : A=A<<1
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_asla(void)
|
|
{
|
|
Uint8 carry, bitN;
|
|
|
|
carry = (hd6301_reg_A & 0X80) >> 7;
|
|
hd6301_reg_A <<= 1;
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* ROLA : rotate left, accumulator A : A=A<<1 +C
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_rola(void)
|
|
{
|
|
Uint8 carry, result, bitN;
|
|
|
|
carry = (hd6301_reg_A & 0x80) >> 7;
|
|
result = hd6301_reg_CCR & 1;
|
|
result += hd6301_reg_A << 1;
|
|
hd6301_reg_A = result;
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* DECA : decrement accumulator A : A=A-1
|
|
*
|
|
* HINZVC
|
|
* ..***.
|
|
*/
|
|
static void hd6301_deca(void)
|
|
{
|
|
Uint8 overflow;
|
|
|
|
overflow = (hd6301_reg_A == (Sint8)0x80) << hd6301_REG_CCR_V;
|
|
-- hd6301_reg_A;
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= overflow;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* INCA : increment accumulator A : A=A+1
|
|
*
|
|
* HINZVC
|
|
* ..***.
|
|
*/
|
|
static void hd6301_inca(void)
|
|
{
|
|
Uint8 overflow;
|
|
|
|
overflow = (hd6301_reg_A == 0x7f) << hd6301_REG_CCR_V;
|
|
hd6301_reg_A ++;
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= overflow;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* TSTA : test zero or minus, accumulator A : A-0
|
|
*
|
|
* HINZVC
|
|
* ..**00
|
|
*/
|
|
static void hd6301_tsta(void)
|
|
{
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* CLRA : clear accumulator A : A=0
|
|
*
|
|
* HINZVC
|
|
* ..0100
|
|
*/
|
|
static void hd6301_clra(void)
|
|
{
|
|
hd6301_reg_A = 0;
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= 1 << hd6301_REG_CCR_Z;
|
|
}
|
|
|
|
/**
|
|
* NEGB : negate accumulator B : B=0-B
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_negb(void)
|
|
{
|
|
Uint8 value;
|
|
|
|
value = 0 - hd6301_reg_B;
|
|
hd6301_reg_B = value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_NZ8(value);
|
|
hd6301_reg_CCR |= (value != 0x0);
|
|
hd6301_reg_CCR |= (value == 0x80) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* COMB : complement 1 accumulator B : B=~B
|
|
*
|
|
* HINZVC
|
|
* ..**01
|
|
*/
|
|
static void hd6301_comb(void)
|
|
{
|
|
hd6301_reg_B = ~hd6301_reg_B;
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= 1;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* LSRB : logical shift right, accumulator B : B=B>>1
|
|
*
|
|
* HINZVC
|
|
* ..0***
|
|
*/
|
|
static void hd6301_lsrb(void)
|
|
{
|
|
Uint8 carry;
|
|
|
|
carry = hd6301_reg_B & 1;
|
|
hd6301_reg_B >>= 1;
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_Z8(hd6301_reg_B);
|
|
hd6301_reg_CCR |= ((0 ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* RORB : rotate right, accumulator B : B=B>>1 + carry<<8
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_rorb(void)
|
|
{
|
|
Uint8 carry, result, bitN;
|
|
|
|
carry = hd6301_reg_B & 1;
|
|
result = (hd6301_reg_CCR & 1) << 7;
|
|
result += hd6301_reg_B >> 1;
|
|
hd6301_reg_B = result;
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* ASRB : arithmetic shift right, accumulator B : B=B>>1
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_asrb(void)
|
|
{
|
|
Uint8 carry, bitN;
|
|
|
|
carry = hd6301_reg_B & 1;
|
|
hd6301_reg_B >>= 1;
|
|
hd6301_reg_B |= (hd6301_reg_B & 0x40) << 1;
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* ASLB : arithmetic shift left, accumulator B : B=B<<1
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_aslb(void)
|
|
{
|
|
Uint8 carry, bitN;
|
|
|
|
carry = (hd6301_reg_B & 0x80) >> 7;
|
|
hd6301_reg_B <<= 1;
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* ROLB : rotate left, accumulator B : B=B<<1 +C
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_rolb(void)
|
|
{
|
|
Uint8 carry, result, bitN;
|
|
|
|
carry = (hd6301_reg_B & 0x80) >> 7;
|
|
result = hd6301_reg_CCR & 1;
|
|
result += hd6301_reg_B << 1;
|
|
hd6301_reg_B = result;
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* DECB : decrement accumulator B : B=B-1
|
|
*
|
|
* HINZVC
|
|
* ..***.
|
|
*/
|
|
static void hd6301_decb(void)
|
|
{
|
|
Uint8 overflow;
|
|
|
|
overflow = (hd6301_reg_B == (Sint8)0x80) << hd6301_REG_CCR_V;
|
|
-- hd6301_reg_B;
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= overflow;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* INCB : increment accumulator B : B=B+1
|
|
*
|
|
* HINZVC
|
|
* ..***.
|
|
*/
|
|
static void hd6301_incb(void)
|
|
{
|
|
Uint8 overflow;
|
|
|
|
overflow = (hd6301_reg_B == 0x7f) << hd6301_REG_CCR_V;
|
|
hd6301_reg_B ++;
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= overflow;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* TSTB : test zero or minus, accumulator B : B-0
|
|
*
|
|
* HINZVC
|
|
* ..**00
|
|
*/
|
|
static void hd6301_tstb(void)
|
|
{
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* CLRB : clear accumulator B : B=0
|
|
*
|
|
* HINZVC
|
|
* ..0100
|
|
*/
|
|
static void hd6301_clrb(void)
|
|
{
|
|
hd6301_reg_B = 0;
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= 1 << hd6301_REG_CCR_Z;
|
|
}
|
|
|
|
/**
|
|
* NEG_IND : negate indexed memory : M=0-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_neg_ind(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = -hd6301_read_memory(addr);
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= (value != 0x0);
|
|
hd6301_reg_CCR |= (value == 0x80) << hd6301_REG_CCR_V;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* AIM_IND : and immediate indexed memory : M=M&IMM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_aim_ind(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+2);
|
|
value &= hd6301_read_memory(addr);
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* OIM_IND : or immediate indexed memory : M=M|IMM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_oim_ind(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+2);
|
|
value |= hd6301_read_memory(addr);
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* COM_IND : complement 1 indexed memory : M=~M
|
|
*
|
|
* HINZVC
|
|
* ..**01
|
|
*/
|
|
static void hd6301_com_ind(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = ~hd6301_read_memory(addr);
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= 1;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* LSR_IND : logical shift right indexed memory : M=M>>1
|
|
*
|
|
* HINZVC
|
|
* ..0***
|
|
*/
|
|
static void hd6301_lsr_ind(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
|
|
carry = value & 1;
|
|
value >>= 1;
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_Z8(value);
|
|
hd6301_reg_CCR |= ((0 ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* EIM_IND : eor immediate indexed memory : M=M^IMM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_eim_ind(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+2);
|
|
value ^= hd6301_read_memory(addr);
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* ROR_IND : rotate right indexed memory : M=M>>1 + carry<<8
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_ror_ind(void)
|
|
{
|
|
Uint8 value, carry, result, bitN;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
|
|
carry = value & 1;
|
|
result = (hd6301_reg_CCR & 1) << 7;
|
|
result += value >> 1;
|
|
hd6301_write_memory(addr, result);
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_NZ8(result);
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* ASR_IND : arithmetic shift right indexed memory : M=M>>1
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_asr_ind(void)
|
|
{
|
|
Uint8 value, carry, bitN;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
|
|
carry = value & 1;
|
|
value >>= 1;
|
|
value |= (value & 0x40) << 1;
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_NZ8(value);
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* ASL_IND : arithmetic shift left indexed memory : M=M<<1
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_asl_ind(void)
|
|
{
|
|
Uint8 value, carry, bitN;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
|
|
carry = (value & 0X80) >> 7;
|
|
value <<= 1;
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_NZ8(value);
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* ROL_IND : rotate left indexed memory : M=M<<1 + carry
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_rol_ind(void)
|
|
{
|
|
Uint8 value, carry, result, bitN;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
|
|
result = hd6301_reg_CCR & 1;
|
|
carry = (value & 0x80) >> 7;
|
|
result += value << 1;
|
|
hd6301_write_memory(addr, result);
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_NZ8(result);
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* DEC_IND : decrement indexed memory : M=M-1
|
|
*
|
|
* HINZVC
|
|
* ..***.
|
|
*/
|
|
static void hd6301_dec_ind(void)
|
|
{
|
|
Uint8 value, overflow;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
|
|
overflow = (value == 0x80) << hd6301_REG_CCR_V;
|
|
--value;
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= overflow;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* TIM_IND : test immediate indexed memory : M&IMM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_tim_ind(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+2);
|
|
value &= hd6301_read_memory(addr);
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* INC_IND : increment indexed memory : M=M+1
|
|
*
|
|
* HINZVC
|
|
* ..***.
|
|
*/
|
|
static void hd6301_inc_ind(void)
|
|
{
|
|
Uint8 value, overflow;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
|
|
overflow = (value == 0x7f) << hd6301_REG_CCR_V;
|
|
value ++;
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= overflow;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* TST_IND : test indexed memory : M-0
|
|
*
|
|
* HINZVC
|
|
* ..**00
|
|
*/
|
|
static void hd6301_tst_ind(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* JMP_IND : jump to indexed memory address : PC=M
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_jmp_ind(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
hd6301_reg_PC = value;
|
|
}
|
|
|
|
/**
|
|
* CLR_IND : clear indexed memory : M=0
|
|
*
|
|
* HINZVC
|
|
* ..0100
|
|
*/
|
|
static void hd6301_clr_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_write_memory(addr, 0);
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= 1 << hd6301_REG_CCR_Z;
|
|
}
|
|
|
|
/**
|
|
* NEG_EXT : negate extended memory : M=0-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_neg_ext(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = -hd6301_read_memory(addr);
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= (value != 0x0);
|
|
hd6301_reg_CCR |= (value == 0x80) << hd6301_REG_CCR_V;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* AIM_DIR : and immediate direct memory address : M=M&IMM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_aim_dir(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
addr = hd6301_read_memory(hd6301_reg_PC+2);
|
|
value &= hd6301_read_memory(addr);
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* OIM_DIR : or immediate direct memory address : M=M|IMM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_oim_dir(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
addr = hd6301_read_memory(hd6301_reg_PC+2);
|
|
value |= hd6301_read_memory(addr);
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* COM_EXT : complement 1 extended memory : M=~M
|
|
*
|
|
* HINZVC
|
|
* ..**01
|
|
*/
|
|
static void hd6301_com_ext(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = ~hd6301_read_memory(addr);
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= 1;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* LSR_EXT : logical shift right extended memory : M=M>>1
|
|
*
|
|
* HINZVC
|
|
* ..0***
|
|
*/
|
|
static void hd6301_lsr_ext(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
|
|
carry = value & 1;
|
|
value >>= 1;
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_Z8(value);
|
|
hd6301_reg_CCR |= ((0 ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* EIM_DIR : eor immediate direct memory address : M=M^IMM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_eim_dir(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
addr = hd6301_read_memory(hd6301_reg_PC+2);
|
|
value ^= hd6301_read_memory(addr);
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* ROR_EXT : rotate right extended memory : M=M>>1 + carry<<8
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_ror_ext(void)
|
|
{
|
|
Uint8 value, carry, result, bitN;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
|
|
result = (hd6301_reg_CCR & 1) << 7;
|
|
carry = value & 1;
|
|
result += value >> 1;
|
|
hd6301_write_memory(addr, result);
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_NZ8(value);
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* ASR_EXT : arithmetic shift right extended memory : M=M>>1
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_asr_ext(void)
|
|
{
|
|
Uint8 value, carry, bitN;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
|
|
carry = value & 1;
|
|
value >>= 1;
|
|
value |= (value & 0x40) << 1;
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_NZ8(value);
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* ASL_EXT : arithmetic shift left extended memory : M=M<<1
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_asl_ext(void)
|
|
{
|
|
Uint8 value, carry, bitN;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
|
|
carry = (value & 0X80) >> 7;
|
|
value <<= 1;
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_NZ8(value);
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* ROL_EXT : rotate left extended memory : M=M<<1 + carry
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_rol_ext(void)
|
|
{
|
|
Uint8 value, carry, result, bitN;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
|
|
result = hd6301_reg_CCR & 1;
|
|
carry = (value & 0x80) >> 7;
|
|
result += value << 1;
|
|
hd6301_write_memory(addr, result);
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= carry;
|
|
HD6301_SET_NZ8(value);
|
|
bitN = (hd6301_reg_CCR >> hd6301_REG_CCR_N) & 1;
|
|
hd6301_reg_CCR |= ((bitN ^ carry) == 1) << hd6301_REG_CCR_V;
|
|
}
|
|
|
|
/**
|
|
* DEC_EXT : decrement extended memory : M=M-1
|
|
*
|
|
* HINZVC
|
|
* ..***.
|
|
*/
|
|
static void hd6301_dec_ext(void)
|
|
{
|
|
Uint8 value, overflow;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
|
|
overflow = (value == 0x80) << hd6301_REG_CCR_V;
|
|
--value;
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= overflow;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* TIM_DIR : test direct memory address value : M&IMM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_tim_dir(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
addr = hd6301_read_memory(hd6301_reg_PC+2);
|
|
value &= hd6301_read_memory(addr);
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* INC_EXT : increment extended memory : M=M+1
|
|
*
|
|
* HINZVC
|
|
* ..***.
|
|
*/
|
|
static void hd6301_inc_ext(void)
|
|
{
|
|
Uint8 value, overflow;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
|
|
overflow = (value == 0x7f) << hd6301_REG_CCR_V;
|
|
value ++;
|
|
hd6301_write_memory(addr, value);
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= overflow;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* TST_EXT : test extended memory : M-0
|
|
*
|
|
* HINZVC
|
|
* ..**00
|
|
*/
|
|
static void hd6301_tst_ext(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* JMP_EXT : jump to extended memory address : PC=M
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_jmp_ext(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
|
|
hd6301_reg_PC = value;
|
|
}
|
|
|
|
/**
|
|
* CLR_EXT : clear extended memory : M=0
|
|
*
|
|
* HINZVC
|
|
* ..0100
|
|
*/
|
|
static void hd6301_clr_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
hd6301_write_memory(addr, 0);
|
|
|
|
HD6301_CLR_NZVC;
|
|
hd6301_reg_CCR |= 1 << hd6301_REG_CCR_Z;
|
|
}
|
|
|
|
/**
|
|
* SUBA_IMM : subtract immediate value from accumulator A : A=A-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_suba_imm(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 result;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
result = hd6301_reg_A - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* CMPA_IMM : compare immediate value to accumulator A : A-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_cmpa_imm(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 result;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
result = hd6301_reg_A - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
}
|
|
|
|
/**
|
|
* SBCA_IMM : subtract with carry immediate value from accumulator A : A=A-M-C
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_sbca_imm(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 result;
|
|
|
|
carry = hd6301_REG_CCR_C & 1;
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
result = hd6301_reg_A - value - carry;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* SUBD_IMM : subtract immediate value from accumulator D : D=D-MM
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_subd_imm(void)
|
|
{
|
|
Uint16 value, regD;
|
|
Uint32 result;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1) << 8;
|
|
value += hd6301_read_memory(hd6301_reg_PC+2);
|
|
regD = (hd6301_reg_A << 8) + hd6301_reg_B;
|
|
result = regD - value;
|
|
|
|
hd6301_reg_A = (result >> 8) & 0xff;
|
|
hd6301_reg_B = result & 0xff;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS16(regD, value, result);
|
|
}
|
|
|
|
/**
|
|
* ANDA_IMM : and immediate value with accumulator A : A=A&M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_anda_imm(void)
|
|
{
|
|
hd6301_reg_A &= hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* BITA_IMM : bit test immediate value with accumulator A : A&M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_bita_imm(void)
|
|
{
|
|
Uint8 value;
|
|
|
|
value = hd6301_reg_A & hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* LDAA_IMM : load accumulator A with immediate value : A=M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_ldaa_imm(void)
|
|
{
|
|
hd6301_reg_A = hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* EORA_IMM : exclusive or immediate value with accumulator A : A=A^M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_eora_imm(void)
|
|
{
|
|
hd6301_reg_A ^= hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* ADCA_IMM : add with carry immediate value to accumulator A : A=A+M+C
|
|
*
|
|
* HINZVC
|
|
* *.****
|
|
*/
|
|
static void hd6301_adca_imm(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 result;
|
|
|
|
carry = hd6301_REG_CCR_C & 1;
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
result = hd6301_reg_A + value + carry;
|
|
|
|
HD6301_CLR_HNZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
HD6301_SET_H(hd6301_reg_A, value, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* ORAA_IMM : inclusive or accumulator A with immediate value : A=A|M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_oraa_imm(void)
|
|
{
|
|
hd6301_reg_A |= hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* ADDA_IMM : add immediate value with accumulator A : A=A+M
|
|
*
|
|
* HINZVC
|
|
* *.****
|
|
*/
|
|
static void hd6301_adda_imm(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 result;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
result = hd6301_reg_A + value;
|
|
|
|
HD6301_CLR_HNZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
HD6301_SET_H(hd6301_reg_A, value, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* CPX_IMM : compare index register with immediate value : X-MM
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_cpx_imm(void)
|
|
{
|
|
Uint16 value;
|
|
Uint32 result;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1) << 8;
|
|
value += hd6301_read_memory(hd6301_reg_PC+2);
|
|
result = hd6301_reg_X - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS16(hd6301_reg_X, value, result);
|
|
}
|
|
|
|
/**
|
|
* BSR : branch to subroutine
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_bsr(void)
|
|
{
|
|
Sint8 addr;
|
|
|
|
hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC + 2) & 0xff);
|
|
hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC + 2) >> 8);
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC + 1);
|
|
hd6301_reg_PC += addr + 2;
|
|
}
|
|
|
|
/**
|
|
* LDS_IMM : load stack pointer with immediate value : SP=MM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_lds_imm(void)
|
|
{
|
|
Uint16 value;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1) << 8;
|
|
value += hd6301_read_memory(hd6301_reg_PC+2);
|
|
hd6301_reg_SP = value;
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ16(value);
|
|
}
|
|
|
|
/**
|
|
* SUBA_DIR : subtract direct memory address value from accumulator A : A=A-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_suba_dir(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 result, addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_A - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* CMPA_DIR : compare direct memory address value to accumulator A : A-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_cmpa_dir(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr, result;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_A - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
}
|
|
|
|
/**
|
|
* SBCA_DIR : subtract with carry direct memory address value from accumulator A : A=A-M-C
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_sbca_dir(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 addr, result;
|
|
|
|
carry = hd6301_REG_CCR_C & 1;
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_A - value - carry;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* SUBD_DIR : subtract direct memory address value from accumulator D : D=D-MM
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_subd_dir(void)
|
|
{
|
|
Uint16 addr, value, regD;
|
|
Uint32 result;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr) << 8;
|
|
value += hd6301_read_memory(addr+1);
|
|
regD = (hd6301_reg_A << 8) + hd6301_reg_B;
|
|
result = regD - value;
|
|
|
|
hd6301_reg_A = (result >> 8) & 0xff;
|
|
hd6301_reg_B = result & 0xff;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS16(regD, value, result);
|
|
}
|
|
|
|
/**
|
|
* ANDA_DIR : and direct memory address value with accumulator A : A=A&M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_anda_dir(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_A &= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* BITA_DIR : bit test direct memory address value with accumulator A : A&M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_bita_dir(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_reg_A & hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* LDAA_DIR : load accumulator A with direct memory address value : A=M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_ldaa_dir(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_A = hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* STAA_DIR : store accumulator A into direct memory address value : M=A
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_staa_dir(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_write_memory(addr, hd6301_reg_A);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* EORA_DIR : exclusive or direct memory address value with accumulator A : A=A^M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_eora_dir(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_A ^= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* ADCA_DIR : add with carry direct memory address value to accumulator A : A=A+M+C
|
|
*
|
|
* HINZVC
|
|
* *.****
|
|
*/
|
|
static void hd6301_adca_dir(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 addr, result;
|
|
|
|
carry = hd6301_REG_CCR_C & 1;
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_A + value + carry;
|
|
|
|
HD6301_CLR_HNZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
HD6301_SET_H(hd6301_reg_A, value, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* ORAA_DIR : inclusive or accumulator A with direct memory address value : A=A|M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_oraa_dir(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_A |= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* ADDA_DIR : add direct memory address value with accumulator A : A=A+M
|
|
*
|
|
* HINZVC
|
|
* *.****
|
|
*/
|
|
static void hd6301_adda_dir(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr, result;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_A + value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
HD6301_SET_H(hd6301_reg_A, value, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* CPX_DIR : compare index register with direct memory address value : X-MM
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_cpx_dir(void)
|
|
{
|
|
Uint16 addr, value;
|
|
Uint32 result;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr) << 8;
|
|
value += hd6301_read_memory(addr+1);
|
|
result = hd6301_reg_X - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS16(hd6301_reg_X, value, result);
|
|
}
|
|
|
|
/**
|
|
* JSR_DIR : jump to subroutine at direct memory address
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_jsr_dir(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC + 2) & 0xff);
|
|
hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC + 2) >> 8);
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC + 1);
|
|
hd6301_reg_PC += addr + 2;
|
|
}
|
|
|
|
/**
|
|
* LDS_DIR : load stack pointer with direct memory address value : SP=MM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_lds_dir(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_SP = hd6301_read_memory(addr) << 8;
|
|
hd6301_reg_SP += hd6301_read_memory(addr+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ16(hd6301_reg_SP);
|
|
}
|
|
|
|
/**
|
|
* STS_DIR : store stack pointer into direct memory address value : MM=SP
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_sts_dir(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_write_memory(addr, hd6301_reg_SP >> 8);
|
|
hd6301_write_memory(addr+1, hd6301_reg_SP & 8);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ16(hd6301_reg_SP);
|
|
}
|
|
|
|
/**
|
|
* SUBA_IND : subtract indexed memory address value from accumulator A : A=A-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_suba_ind(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 result, addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_A - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* CMPA_IND : compare indexed memory address value to accumulator A : A-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_cmpa_ind(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr, result;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_A - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
}
|
|
|
|
/**
|
|
* SBCA_IND : subtract with carry indexed memory address value from accumulator A : A=A-M-C
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_sbca_ind(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 addr, result;
|
|
|
|
carry = hd6301_REG_CCR_C & 1;
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_A - value - carry;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* SUBD_IND : subtract indexed memory address value from accumulator D : D=D-MM
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_subd_ind(void)
|
|
{
|
|
Uint16 addr, value, regD;
|
|
Uint32 result;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr) << 8;
|
|
value += hd6301_read_memory(addr+1);
|
|
regD = (hd6301_reg_A << 8) + hd6301_reg_B;
|
|
result = regD - value;
|
|
|
|
hd6301_reg_A = (result >> 8) & 0xff;
|
|
hd6301_reg_B = result & 0xff;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS16(regD, value, result);
|
|
}
|
|
|
|
/**
|
|
* ANDA_IND : and indexed memory address value with accumulator A : A=A&M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_anda_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_A &= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* BITA_IND : bit test indexed memory address value with accumulator A : A&M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_bita_ind(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_reg_A & hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* LDAA_IND : load accumulator A with indexed memory address value : A=M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_ldaa_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_A = hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* STAA_IND : store accumulator A into indexed memory address value : M=A
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_staa_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_write_memory(addr, hd6301_reg_A);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* EORA_IND : exclusive or indexed memory address value with accumulator A : A=A^M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_eora_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_A ^= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* ADCA_IND : add with carry indexed memory address value to accumulator A : A=A+M+C
|
|
*
|
|
* HINZVC
|
|
* *.****
|
|
*/
|
|
static void hd6301_adca_ind(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 addr, result;
|
|
|
|
carry = hd6301_REG_CCR_C & 1;
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_A + value + carry;
|
|
|
|
HD6301_CLR_HNZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
HD6301_SET_H(hd6301_reg_A, value, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* ORAA_IND : inclusive or accumulator A with indexed memory address value : A=A|M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_oraa_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_A |= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* ADDA_IND : add indexed memory address value with accumulator A : A=A+M
|
|
*
|
|
* HINZVC
|
|
* *.****
|
|
*/
|
|
static void hd6301_adda_ind(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr, result;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_A + value;
|
|
|
|
HD6301_CLR_HNZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
HD6301_SET_H(hd6301_reg_A, value, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* CPX_IND : compare index register with indexed memory address value : X-MM
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_cpx_ind(void)
|
|
{
|
|
Uint16 addr, value;
|
|
Uint32 result;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr) << 8;
|
|
value += hd6301_read_memory(addr+1);
|
|
result = hd6301_reg_X - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS16(hd6301_reg_X, value, result);
|
|
}
|
|
|
|
/**
|
|
* JSR_IND : jump to subroutine at indexed address
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_jsr_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC + 2) & 0xff);
|
|
hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC + 2) >> 8);
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_PC += addr + 2;
|
|
}
|
|
|
|
/**
|
|
* LDS_IND : load stack pointer with indexed memory address value : SP=MM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_lds_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_SP = hd6301_read_memory(addr) << 8;
|
|
hd6301_reg_SP += hd6301_read_memory(addr+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ16(hd6301_reg_SP);
|
|
}
|
|
|
|
/**
|
|
* STS_IND : store stack pointer into indexed memory address value : MM=SP
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_sts_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_write_memory(addr, hd6301_reg_SP >> 8);
|
|
hd6301_write_memory(addr+1, hd6301_reg_SP & 8);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ16(hd6301_reg_SP);
|
|
}
|
|
|
|
/**
|
|
* SUBA_EXT : subtract extented memory address value from accumulator A : A=A-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_suba_ext(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 result, addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_A - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* CMPA_EXT : compare extented memory address value to accumulator A : A-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_cmpa_ext(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr, result;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_A - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
}
|
|
|
|
/**
|
|
* SBCA_EXT : subtract with carry extented memory address value from accumulator A : A=A-M-C
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_sbca_ext(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 addr, result;
|
|
|
|
carry = hd6301_REG_CCR_C & 1;
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_A - value - carry;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* SUBD_EXT : subtract extented memory address value from accumulator D : D=D-MM
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_subd_ext(void)
|
|
{
|
|
Uint16 addr, value, regD;
|
|
Uint32 result;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr) << 8;
|
|
value += hd6301_read_memory(addr+1);
|
|
regD = (hd6301_reg_A << 8) + hd6301_reg_B;
|
|
result = regD - value;
|
|
|
|
hd6301_reg_A = (result >> 8) & 0xff;
|
|
hd6301_reg_B = result & 0xff;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS16(regD, value, result);
|
|
}
|
|
|
|
/**
|
|
* ANDA_EXT : and extented memory address value with accumulator A : A=A&M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_anda_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
hd6301_reg_A &= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* BITA_EXT : bit test extented memory address value with accumulator A : A&M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_bita_ext(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_reg_A & hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* LDAA_EXT : load accumulator A with extented memory address value : A=M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_ldaa_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
hd6301_reg_A = hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* STAA_EXT : store accumulator A into extented memory address value : M=A
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_staa_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
hd6301_write_memory(addr, hd6301_reg_A);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* EORA_EXT : exclusive or extented memory address value with accumulator A : A=A^M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_eora_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
hd6301_reg_A ^= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* ADCA_EXT : add with carry extented memory address value to accumulator A : A=A+M+C
|
|
*
|
|
* HINZVC
|
|
* *.****
|
|
*/
|
|
static void hd6301_adca_ext(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 addr, result;
|
|
|
|
carry = hd6301_REG_CCR_C & 1;
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_A + value + carry;
|
|
|
|
HD6301_CLR_HNZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
HD6301_SET_H(hd6301_reg_A, value, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* ORAA_EXT : inclusive or accumulator A with extented memory address value : A=A|M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_oraa_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
hd6301_reg_A |= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_A);
|
|
}
|
|
|
|
/**
|
|
* ADDA_EXT : add extented memory address value with accumulator A : A=A+M
|
|
*
|
|
* HINZVC
|
|
* *.****
|
|
*/
|
|
static void hd6301_adda_ext(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr, result;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_A + value;
|
|
|
|
HD6301_CLR_HNZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_A, value, result);
|
|
HD6301_SET_H(hd6301_reg_A, value, result);
|
|
|
|
hd6301_reg_A = result;
|
|
}
|
|
|
|
/**
|
|
* CPX_EXT : compare index register with extented memory address value : X-MM
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_cpx_ext(void)
|
|
{
|
|
Uint16 addr, value;
|
|
Uint32 result;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr) << 8;
|
|
value += hd6301_read_memory(addr+1);
|
|
result = hd6301_reg_X - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS16(hd6301_reg_X, value, result);
|
|
}
|
|
|
|
/**
|
|
* JSR_EXT : jump to subroutine at extented address
|
|
*
|
|
* HINZVC
|
|
* ......
|
|
*/
|
|
static void hd6301_jsr_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC + 2) & 0xff);
|
|
hd6301_write_memory(hd6301_reg_SP--, (hd6301_reg_PC + 2) >> 8);
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
hd6301_reg_PC += addr + 2;
|
|
}
|
|
|
|
/**
|
|
* LDS_EXT : load stack pointer with extented memory address value : SP=MM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_lds_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
hd6301_reg_SP = hd6301_read_memory(addr) << 8;
|
|
hd6301_reg_SP += hd6301_read_memory(addr+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ16(hd6301_reg_SP);
|
|
}
|
|
|
|
/**
|
|
* STS_EXT : store stack pointer into extented memory address value : MM=SP
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_sts_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
hd6301_write_memory(addr, hd6301_reg_SP >> 8);
|
|
hd6301_write_memory(addr+1, hd6301_reg_SP & 8);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ16(hd6301_reg_SP);
|
|
}
|
|
|
|
/**
|
|
* SUBB_IMM : subtract immediate value from accumulator B : B=B-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_subb_imm(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 result;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
result = hd6301_reg_B - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
|
|
hd6301_reg_B = result;
|
|
}
|
|
|
|
/**
|
|
* CMPB_IMM : compare immediate value to accumulator B : B-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_cmpb_imm(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 result;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
result = hd6301_reg_B - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
}
|
|
|
|
/**
|
|
* SBCB_IMM : subtract with carry immediate value from accumulator B : B=B-M-C
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_sbcb_imm(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 result;
|
|
|
|
carry = hd6301_REG_CCR_C & 1;
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
result = hd6301_reg_B - value - carry;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
|
|
hd6301_reg_B = result;
|
|
}
|
|
|
|
/**
|
|
* ADDD_IMM : add immediate value from accumulator D : D=D+MM
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_addd_imm(void)
|
|
{
|
|
Uint16 value, regD;
|
|
Uint32 result;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1) << 8;
|
|
value += hd6301_read_memory(hd6301_reg_PC+2);
|
|
regD = (hd6301_reg_A << 8) + hd6301_reg_B;
|
|
result = regD + value;
|
|
|
|
hd6301_reg_A = (result >> 8) & 0xff;
|
|
hd6301_reg_B = result & 0xff;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS16(regD, value, result);
|
|
}
|
|
|
|
/**
|
|
* ANDB_IMM : and immediate value with accumulator B : B=B&M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_andb_imm(void)
|
|
{
|
|
hd6301_reg_B &= hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* BITB_IMM : bit test immediate value with accumulator B : B&M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_bitb_imm(void)
|
|
{
|
|
Uint8 value;
|
|
|
|
value = hd6301_reg_B & hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* LDAB_IMM : load accumulator B with immediate value : B=M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_ldab_imm(void)
|
|
{
|
|
hd6301_reg_B = hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* EORB_IMM : exclusive or immediate value with accumulator B : B=B^M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_eorb_imm(void)
|
|
{
|
|
hd6301_reg_B ^= hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* ADCB_IMM : add with carry immediate value to accumulator B : B=B+M+C
|
|
*
|
|
* HINZVC
|
|
* *.****
|
|
*/
|
|
static void hd6301_adcb_imm(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 result;
|
|
|
|
carry = hd6301_REG_CCR_C & 1;
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
result = hd6301_reg_B + value + carry;
|
|
|
|
HD6301_CLR_HNZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
HD6301_SET_H(hd6301_reg_B, value, result);
|
|
|
|
hd6301_reg_B = result;
|
|
}
|
|
|
|
/**
|
|
* ORAB_IMM : inclusive or accumulator B with immediate value : B=B|M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_orab_imm(void)
|
|
{
|
|
hd6301_reg_B |= hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* ADDB_IMM : add immediate value with accumulator B : B=B+M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_addb_imm(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 result;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1);
|
|
result = hd6301_reg_B + value;
|
|
|
|
HD6301_CLR_HNZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
HD6301_SET_H(hd6301_reg_B, value, result);
|
|
|
|
hd6301_reg_B = result;
|
|
}
|
|
|
|
/**
|
|
* LDD_IMM : load accumulator D with immediate value : D=MM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_ldd_imm(void)
|
|
{
|
|
hd6301_reg_A = hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_B = hd6301_read_memory(hd6301_reg_PC+2);
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= ((hd6301_reg_A == 0) && (hd6301_reg_B == 0)) << hd6301_REG_CCR_Z;
|
|
hd6301_reg_CCR |= (hd6301_reg_A >> 7) << hd6301_REG_CCR_N;
|
|
}
|
|
|
|
/**
|
|
* LDX_IMM : load register X with immediate value : X=MM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_ldx_imm(void)
|
|
{
|
|
Uint16 value;
|
|
|
|
value = hd6301_read_memory(hd6301_reg_PC+1) << 8;
|
|
value += hd6301_read_memory(hd6301_reg_PC+2);
|
|
hd6301_reg_X = value;
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ16(hd6301_reg_X);
|
|
}
|
|
|
|
/**
|
|
* SUBB_DIR : subtract direct memory address value from accumulator B : B=B-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_subb_dir(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 result, addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_B - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
|
|
hd6301_reg_B = result;
|
|
}
|
|
|
|
/**
|
|
* CMPB_DIR : compare direct memory address value to accumulator B : B-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_cmpb_dir(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr, result;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_B - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
}
|
|
|
|
/**
|
|
* SBCB_DIR : subtract with carry direct memory address value from accumulator B : B=B-M-C
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_sbcb_dir(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 addr, result;
|
|
|
|
carry = hd6301_REG_CCR_C & 1;
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_B - value - carry;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
|
|
hd6301_reg_B = result;
|
|
}
|
|
|
|
/**
|
|
* ADDD_DIR : add direct memory address value from accumulator D : D=D+MM
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_addd_dir(void)
|
|
{
|
|
Uint16 addr, value, regD;
|
|
Uint32 result;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr) << 8;
|
|
value += hd6301_read_memory(addr+1);
|
|
regD = (hd6301_reg_A << 8) + hd6301_reg_B;
|
|
result = regD + value;
|
|
|
|
hd6301_reg_A = (result >> 8) & 0xff;
|
|
hd6301_reg_B = result & 0xff;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS16(regD, value, result);
|
|
}
|
|
|
|
/**
|
|
* ANDB_DIR : and direct memory address value with accumulator B : B=B&M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_andb_dir(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_B &= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* BITB_DIR : bit test direct memory address value with accumulator B : B&M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_bitb_dir(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_reg_B & hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* LDAB_DIR : load accumulator B with direct memory address value : B=M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_ldab_dir(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_B = hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* STAB_DIR : store accumulator B into direct memory address value : M=B
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_stab_dir(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_write_memory(addr, hd6301_reg_B);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* EORB_DIR : exclusive or direct memory address value with accumulator B : B=B^M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_eorb_dir(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_B ^= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* ADCB_DIR : add with carry direct memory address value to accumulator B : B=B+M+C
|
|
*
|
|
* HINZVC
|
|
* *.****
|
|
*/
|
|
static void hd6301_adcb_dir(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 addr, result;
|
|
|
|
carry = hd6301_REG_CCR_C & 1;
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_B + value + carry;
|
|
|
|
HD6301_CLR_HNZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
HD6301_SET_H(hd6301_reg_B, value, result);
|
|
|
|
hd6301_reg_B = result;
|
|
}
|
|
|
|
/**
|
|
* ORAB_DIR : inclusive or accumulator B with direct memory address value : B=B|M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_orab_dir(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_B |= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* ADDB_DIR : add direct memory address value with accumulator B : B=B+M
|
|
*
|
|
* HINZVC
|
|
* *.****
|
|
*/
|
|
static void hd6301_addb_dir(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr, result;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_B + value;
|
|
|
|
HD6301_CLR_HNZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
HD6301_SET_H(hd6301_reg_B, value, result);
|
|
|
|
hd6301_reg_B = result;
|
|
}
|
|
|
|
/**
|
|
* LDD_DIR : load accumulator D with direct memory address value : D=MM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_ldd_dir(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
hd6301_reg_A = hd6301_read_memory(addr);
|
|
hd6301_reg_B = hd6301_read_memory(addr+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= ((hd6301_reg_A == 0) && (hd6301_reg_B == 0)) << hd6301_REG_CCR_Z;
|
|
hd6301_reg_CCR |= (hd6301_reg_A >> 7) << hd6301_REG_CCR_N;
|
|
}
|
|
|
|
/**
|
|
* STD_DIR : store accumulator D into direct memory address value : MM=D
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_std_dir(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
hd6301_write_memory(addr, hd6301_reg_A);
|
|
hd6301_write_memory(addr+1, hd6301_reg_B);
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= ((hd6301_reg_A == 0) && (hd6301_reg_B == 0)) << hd6301_REG_CCR_Z;
|
|
hd6301_reg_CCR |= (hd6301_reg_A >> 7) << hd6301_REG_CCR_N;
|
|
}
|
|
|
|
/**
|
|
* LDX_DIR : load register X with direct memory address value : X=MM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_ldx_dir(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
hd6301_reg_X = hd6301_read_memory(addr) << 8;
|
|
hd6301_reg_X += hd6301_read_memory(addr+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ16(hd6301_reg_X);
|
|
}
|
|
|
|
/**
|
|
* STX_DIR : store register X into direct memory address value : MM=X
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_stx_dir(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
hd6301_write_memory(addr, hd6301_reg_X >> 8);
|
|
hd6301_write_memory(addr+1, hd6301_reg_X & 0xff);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ16(hd6301_reg_X);
|
|
}
|
|
|
|
/**
|
|
* SUBB_IND : subtract indexed memory address value from accumulator B : B=B-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_subb_ind(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 result, addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_B - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
|
|
hd6301_reg_B = result;
|
|
}
|
|
|
|
/**
|
|
* CMPB_IND : compare indexed memory address value to accumulator B : B-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_cmpb_ind(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr, result;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_B - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
}
|
|
|
|
/**
|
|
* SBCB_IND : subtract with carry indexed memory address value from accumulator B : B=B-M-C
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_sbcb_ind(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 addr, result;
|
|
|
|
carry = hd6301_REG_CCR_C & 1;
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_B - value - carry;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
|
|
hd6301_reg_B = result;
|
|
}
|
|
|
|
/**
|
|
* ADDD_IND : add indexed memory address value from accumulator D : D=D+MM
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_addd_ind(void)
|
|
{
|
|
Uint16 addr, value, regD;
|
|
Uint32 result;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr) << 8;
|
|
value += hd6301_read_memory(addr+1);
|
|
regD = (hd6301_reg_A << 8) + hd6301_reg_B;
|
|
result = regD + value;
|
|
|
|
hd6301_reg_A = (result >> 8) & 0xff;
|
|
hd6301_reg_B = result & 0xff;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS16(regD, value, result);
|
|
}
|
|
|
|
/**
|
|
* ANDB_IND : and indexed memory address value with accumulator B : B=B&M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_andb_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_B &= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* BITB_IND : bit test indexed memory address value with accumulator B : B&M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_bitb_ind(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_reg_B & hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* LDAB_IND : load accumulator B with indexed memory address value : B=M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_ldab_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_B = hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* STAB_IND : store accumulator B into indexed memory address value : M=B
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_stab_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_write_memory(addr, hd6301_reg_B);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* EORB_IND : exclusive or indexed memory address value with accumulator B : B=B^M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_eorb_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_B ^= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* ADCB_IND : add with carry indexed memory address value to accumulator B : B=B+M+C
|
|
*
|
|
* HINZVC
|
|
* *.****
|
|
*/
|
|
static void hd6301_adcb_ind(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 addr, result;
|
|
|
|
carry = hd6301_REG_CCR_C & 1;
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_B + value + carry;
|
|
|
|
HD6301_CLR_HNZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
HD6301_SET_H(hd6301_reg_B, value, result);
|
|
|
|
hd6301_reg_B = result;
|
|
}
|
|
|
|
/**
|
|
* ORAB_IND : inclusive or accumulator B with indexed memory address value : B=B|M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_orab_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
hd6301_reg_B |= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* ADDB_IND : add indexed memory address value with accumulator B : B=B+M
|
|
*
|
|
* HINZVC
|
|
* *.****
|
|
*/
|
|
static void hd6301_addb_ind(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr, result;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_B + value;
|
|
|
|
HD6301_CLR_HNZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
HD6301_SET_H(hd6301_reg_B, value, result);
|
|
|
|
hd6301_reg_B = result;
|
|
}
|
|
|
|
/**
|
|
* LDD_IND : load accumulator D with indexed memory address value : D=MM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_ldd_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
hd6301_reg_A = hd6301_read_memory(addr);
|
|
hd6301_reg_B = hd6301_read_memory(addr+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= ((hd6301_reg_A == 0) && (hd6301_reg_B == 0)) << hd6301_REG_CCR_Z;
|
|
hd6301_reg_CCR |= (hd6301_reg_A >> 7) << hd6301_REG_CCR_N;
|
|
}
|
|
|
|
/**
|
|
* STD_IND : store accumulator D into indexed memory address value : MM=D
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_std_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
hd6301_write_memory(addr, hd6301_reg_A);
|
|
hd6301_write_memory(addr+1, hd6301_reg_B);
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= ((hd6301_reg_A == 0) && (hd6301_reg_B == 0)) << hd6301_REG_CCR_Z;
|
|
hd6301_reg_CCR |= (hd6301_reg_A >> 7) << hd6301_REG_CCR_N;
|
|
}
|
|
|
|
/**
|
|
* LDX_IND : load register X with indexed memory address value : X=MM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_ldx_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
hd6301_reg_X = hd6301_read_memory(addr) << 8;
|
|
hd6301_reg_X += hd6301_read_memory(addr+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ16(hd6301_reg_X);
|
|
}
|
|
|
|
/**
|
|
* STX_IND : store register X into indexed memory address value : MM=X
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_stx_ind(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_reg_X + hd6301_read_memory(hd6301_reg_PC+1);
|
|
|
|
hd6301_write_memory(addr, hd6301_reg_X >> 8);
|
|
hd6301_write_memory(addr+1, hd6301_reg_X & 0xff);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ16(hd6301_reg_X);
|
|
}
|
|
|
|
/**
|
|
* SUBB_EXT : subtract extended memory address value from accumulator B : B=B-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_subb_ext(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 result, addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_B - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
|
|
hd6301_reg_B = result;
|
|
}
|
|
|
|
/**
|
|
* CMPB_EXT : compare extended memory address value to accumulator B : B-M
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_cmpb_ext(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr, result;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_B - value;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
}
|
|
|
|
/**
|
|
* SBCB_EXT : subtract with carry extended memory address value from accumulator B : B=B-M-C
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_sbcb_ext(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 addr, result;
|
|
|
|
carry = hd6301_REG_CCR_C & 1;
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_B - value - carry;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
|
|
hd6301_reg_B = result;
|
|
}
|
|
|
|
/**
|
|
* ADDD_EXT : add extended memory address value from accumulator D : D=D+MM
|
|
*
|
|
* HINZVC
|
|
* ..****
|
|
*/
|
|
static void hd6301_addd_ext(void)
|
|
{
|
|
Uint16 addr, value, regD;
|
|
Uint32 result;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr) << 8;
|
|
value += hd6301_read_memory(addr+1);
|
|
regD = (hd6301_reg_A << 8) + hd6301_reg_B;
|
|
result = regD + value;
|
|
|
|
hd6301_reg_A = (result >> 8) & 0xff;
|
|
hd6301_reg_B = result & 0xff;
|
|
|
|
HD6301_CLR_NZVC;
|
|
HD6301_SET_FLAGS16(regD, value, result);
|
|
}
|
|
|
|
/**
|
|
* ANDB_EXT : and extended memory address value with accumulator B : B=B&M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_andb_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
hd6301_reg_B &= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* BITB_EXT : bit test extended memory address value with accumulator B : B&M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_bitb_ext(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_reg_B & hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(value);
|
|
}
|
|
|
|
/**
|
|
* LDAB_EXT : load accumulator B with extended memory address value : B=M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_ldab_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
hd6301_reg_B = hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* STAB_EXT : store accumulator B into extended memory address value : M=B
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_stab_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
hd6301_write_memory(addr, hd6301_reg_B);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* EORB_EXT : exclusive or extended memory address value with accumulator B : B=B^M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_eorb_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
hd6301_reg_B ^= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* ADCB_EXT : add with carry extended memory address value to accumulator B : B=B+M+C
|
|
*
|
|
* HINZVC
|
|
* *.****
|
|
*/
|
|
static void hd6301_adcb_ext(void)
|
|
{
|
|
Uint8 value, carry;
|
|
Uint16 addr, result;
|
|
|
|
carry = hd6301_REG_CCR_C & 1;
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_B + value + carry;
|
|
|
|
HD6301_CLR_HNZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
HD6301_SET_H(hd6301_reg_B, value, result);
|
|
|
|
hd6301_reg_B = result;
|
|
}
|
|
|
|
/**
|
|
* ORAB_EXT : inclusive or accumulator B with extended memory address value : B=B|M
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_orab_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
hd6301_reg_B |= hd6301_read_memory(addr);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ8(hd6301_reg_B);
|
|
}
|
|
|
|
/**
|
|
* ADDB_EXT : add extended memory address value with accumulator B : B=B+M
|
|
*
|
|
* HINZVC
|
|
* *.****
|
|
*/
|
|
static void hd6301_addb_ext(void)
|
|
{
|
|
Uint8 value;
|
|
Uint16 addr, result;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
value = hd6301_read_memory(addr);
|
|
result = hd6301_reg_B + value;
|
|
|
|
HD6301_CLR_HNZVC;
|
|
HD6301_SET_FLAGS8(hd6301_reg_B, value, result);
|
|
HD6301_SET_H(hd6301_reg_B, value, result);
|
|
|
|
hd6301_reg_B = result;
|
|
}
|
|
|
|
/**
|
|
* LDD_EXT : load accumulator D with extended memory address value : D=MM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_ldd_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
|
|
hd6301_reg_A = hd6301_read_memory(addr);
|
|
hd6301_reg_B = hd6301_read_memory(addr+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= ((hd6301_reg_A == 0) && (hd6301_reg_B == 0)) << hd6301_REG_CCR_Z;
|
|
hd6301_reg_CCR |= (hd6301_reg_A >> 7) << hd6301_REG_CCR_N;
|
|
}
|
|
|
|
/**
|
|
* STD_EXT : store accumulator D into extended memory address value : MM=D
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_std_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
|
|
hd6301_write_memory(addr, hd6301_reg_A);
|
|
hd6301_write_memory(addr+1, hd6301_reg_B);
|
|
|
|
HD6301_CLR_NZV;
|
|
hd6301_reg_CCR |= ((hd6301_reg_A == 0) && (hd6301_reg_B == 0)) << hd6301_REG_CCR_Z;
|
|
hd6301_reg_CCR |= (hd6301_reg_A >> 7) << hd6301_REG_CCR_N;
|
|
}
|
|
|
|
/**
|
|
* LDX_EXT : load register X with extended memory address value : X=MM
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_ldx_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
|
|
hd6301_reg_X = hd6301_read_memory(addr) << 8;
|
|
hd6301_reg_X += hd6301_read_memory(addr+1);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ16(hd6301_reg_X);
|
|
}
|
|
|
|
/**
|
|
* STX_EXT : store register X into extended memory address value : MM=X
|
|
*
|
|
* HINZVC
|
|
* ..**0.
|
|
*/
|
|
static void hd6301_stx_ext(void)
|
|
{
|
|
Uint16 addr;
|
|
|
|
addr = hd6301_get_memory_ext();
|
|
|
|
hd6301_write_memory(addr, hd6301_reg_X >> 8);
|
|
hd6301_write_memory(addr+1, hd6301_reg_X & 0xff);
|
|
|
|
HD6301_CLR_NZV;
|
|
HD6301_SET_NZ16(hd6301_reg_X);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* hd6301_disasm : disasm hd6301 memory
|
|
*/
|
|
void hd6301_disasm(void)
|
|
{
|
|
switch(hd6301_opcode.op_disasm) {
|
|
case HD6301_DISASM_UNDEFINED:
|
|
sprintf(hd6301_str_instr, "0x%02x : unknown instruction", hd6301_cur_inst);
|
|
break;
|
|
case HD6301_DISASM_NONE:
|
|
sprintf(hd6301_str_instr, hd6301_opcode.op_mnemonic, 0);
|
|
break;
|
|
case HD6301_DISASM_MEMORY8:
|
|
sprintf(hd6301_str_instr, hd6301_opcode.op_mnemonic, hd6301_read_memory(hd6301_reg_PC+1));
|
|
break;
|
|
case HD6301_DISASM_MEMORY16:
|
|
sprintf(hd6301_str_instr, hd6301_opcode.op_mnemonic, hd6301_get_memory_ext());
|
|
break;
|
|
case HD6301_DISASM_XIM:
|
|
sprintf(hd6301_str_instr, hd6301_opcode.op_mnemonic,
|
|
hd6301_read_memory(hd6301_reg_PC+1),
|
|
hd6301_read_memory(hd6301_reg_PC+2));
|
|
break;
|
|
}
|
|
|
|
fprintf(stderr, "%02x: %s\n", hd6301_reg_PC, hd6301_str_instr);
|
|
|
|
}
|
|
|
|
/**
|
|
* hd6301_display_registers : display hd6301 registers state
|
|
*/
|
|
void hd6301_display_registers(void)
|
|
{
|
|
fprintf(stderr, "A: %02x B: %02x\n", hd6301_reg_A, hd6301_reg_B);
|
|
fprintf(stderr, "X: %04x CCR: %02x\n", hd6301_reg_X, hd6301_reg_CCR);
|
|
fprintf(stderr, "SP: %04x PC: %04x\n", hd6301_reg_SP, hd6301_reg_PC);
|
|
}
|