📄 cpu.c
字号:
/*
* cpu.c - 6502 CPU emulation
*
* Copyright (C) 1995-1998 David Firth
* Copyright (C) 1998-2005 Atari800 development team (see DOC/CREDITS)
*
* This file is part of the Atari800 emulator project which emulates
* the Atari 400, 800, 800XL, 130XE, and 5200 8-bit computers.
*
* Atari800 is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* Atari800 is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Atari800; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*
Configuration symbols
=====================
Define CPU65C02 if you don't want 6502 JMP() bug emulation.
Define CYCLES_PER_OPCODE to update xpos in each opcode's emulation.
Define MONITOR_BREAK if you want code breakpoints and execution history.
Define MONITOR_BREAKPOINTS if you want user-defined breakpoints.
Define MONITOR_PROFILE if you want 6502 opcode profiling.
Define MONITOR_TRACE if you want the code to be disassembled while it is executed.
Define NO_GOTO if you compile with GCC, but want switch() rather than goto *.
Define NO_V_FLAG_VARIABLE to don't use local (static) variable V for the V flag.
Define PC_PTR to emulate 6502 Program Counter using UBYTE *.
Define PREFETCH_CODE to always fetch 2 bytes after the opcode.
Define WRAP_64K to correctly emulate instructions that wrap at 64K.
Define WRAP_ZPAGE to prevent incorrect access to the address 0x0100 in zeropage
indirect mode.
Limitations & Known bugs
========================
There is no emulation of the bug in the BRK instruction executed simultaneously
with another interrupt.
The 6502 emulation ignores memory attributes for instruction fetch.
This is because the instruction must come from either RAM or ROM.
A program that executes instructions from within hardware addresses will fail
since there is never any usable code there.
The 6502 emulation also ignores memory attributes for accesses to page 0 and page 1.
*/
//#include <config.h>
#include <stdio.h>
#include <stdlib.h> /* exit() */
#include "cpu.h"
#ifdef ASAP /* external project, see http://asap.sf.net */
#include "asap_internal.h"
#else
#include "antic.h"
#include "atari.h"
#include "memory.h"
#include "monitor.h"
#ifndef BASIC
#include "statesav.h"
#ifndef __PLUS
#include "ui.h"
#endif
#endif /* BASIC */
#endif /* ASAP */
#ifdef FALCON_CPUASM
extern UBYTE IRQ;
#ifdef PAGED_MEM
#error cpu_m68k.asm cannot work with paged memory
#endif
void CPU_Initialise(void)
{
CPU_INIT();
}
void CPU_GetStatus(void)
{
CPUGET();
}
void CPU_PutStatus(void)
{
CPUPUT();
}
#else /* FALCON_CPUASM */
/* Windows headers define it */
#undef ABSOLUTE
#ifndef __GNUC__
#define NO_GOTO
#endif
/* #define CYCLES_PER_OPCODE */
/* #define MONITOR_PROFILE */
/* #define NO_V_FLAG_VARIABLE */
/* If PC_PTR is defined, local PC is "const UBYTE *", otherwise it's UWORD. */
/* #define PC_PTR */
/* If PREFETCH_CODE is defined, 2 bytes after the opcode are always fetched. */
/* #define PREFETCH_CODE */
/* 6502 stack handling */
#define PL dGetByte(0x0100 + ++S)
#define PH(x) dPutByte(0x0100 + S--, x)
#define PHW(x) PH((x) >> 8); PH((x) & 0xff)
/* 6502 code fetching */
#ifdef PC_PTR
#define GET_PC() (PC - memory)
#define SET_PC(newpc) (PC = memory + (newpc))
#define PHPC { UWORD tmp = PC - memory; PHW(tmp); }
#define GET_CODE_BYTE() (*PC++)
#define PEEK_CODE_BYTE() (*PC)
#if !defined(WORDS_BIGENDIAN) && defined(WORDS_UNALIGNED_OK)
#define PEEK_CODE_WORD() (*(const UWORD *) PC)
#else
#define PEEK_CODE_WORD() (*PC + (PC[1] << 8))
#endif
#else /* PC_PTR */
#define GET_PC() PC
#define SET_PC(newpc) (PC = (newpc))
#define PHPC PHW(PC)
#define GET_CODE_BYTE() dGetByte(PC++)
#define PEEK_CODE_BYTE() dGetByte(PC)
#define PEEK_CODE_WORD() dGetWord(PC)
#endif /* PC_PTR */
/* Cycle-exact Read-Modify-Write instructions.
RMW instructions: ASL, LSR, ROL, ROR, INC, DEC
(+ some undocumented) write to the specified address
*twice*: first the unmodified value, then the modified value.
This can be observed only with some hardware registers. */
/* XXX: we do this only for GTIA, because NEW_CYCLE_EXACT does not correctly
emulate INC $D400 (and INC $D40A wasn't tested) */
#ifdef NEW_CYCLE_EXACT
#ifndef PAGED_ATTRIB
#define RMW_GetByte(x, addr) \
if (attrib[addr] == HARDWARE) { \
x = Atari800_GetByte(addr); \
if ((addr & 0xef00) == 0xc000) { \
xpos--; \
Atari800_PutByte(addr, x); \
xpos++; \
} \
} else \
x = dGetByte(addr);
#else /* PAGED_ATTRIB */
#define RMW_GetByte(x, addr) \
x = GetByte(addr); \
if ((addr & 0xef00) == 0xc000) { \
xpos--; \
PutByte(addr, x); \
xpos++; \
}
#endif /* PAGED_ATTRIB */
#else /* NEW_CYCLE_EXACT */
/* Don't emulate the first write */
#define RMW_GetByte(x, addr) x = GetByte(addr);
#endif /* NEW_CYCLE_EXACT */
/* 6502 registers. */
UWORD regPC;
UBYTE regA;
UBYTE regX;
UBYTE regY;
UBYTE regP; /* Processor Status Byte (Partial) */
UBYTE regS;
UBYTE IRQ;
/* Transfer 6502 registers between global variables and local variables inside GO() */
#define UPDATE_GLOBAL_REGS regPC = GET_PC(); regS = S; regA = A; regX = X; regY = Y
#define UPDATE_LOCAL_REGS SET_PC(regPC); S = regS; A = regA; X = regX; Y = regY
/* 6502 flags local to this module */
static UBYTE N; /* bit7 set => N flag set */
#ifndef NO_V_FLAG_VARIABLE
static UBYTE V; /* non-zero => V flag set */
#endif
static UBYTE Z; /* zero => Z flag set */
static UBYTE C; /* must be 0 or 1 */
/* B, D, I are always in regP */
void CPU_GetStatus(void)
{
#ifndef NO_V_FLAG_VARIABLE
regP = (N & 0x80) + (V ? 0x40 : 0) + (regP & 0x3c) + ((Z == 0) ? 0x02 : 0) + C;
#else
regP = (N & 0x80) + (regP & 0x7c) + ((Z == 0) ? 0x02 : 0) + C;
#endif
}
void CPU_PutStatus(void)
{
N = regP;
#ifndef NO_V_FLAG_VARIABLE
V = (regP & 0x40);
#endif
Z = (regP & 0x02) ^ 0x02;
C = (regP & 0x01);
}
/* For Atari Basic loader */
void (*rts_handler)(void) = NULL;
/* 6502 instruction profiling */
#ifdef MONITOR_PROFILE
int instruction_count[256];
#endif
UBYTE cim_encountered = FALSE;
/* Execution history */
#ifdef MONITOR_BREAK
UWORD remember_PC[REMEMBER_PC_STEPS];
unsigned int remember_PC_curpos = 0;
int remember_xpos[REMEMBER_PC_STEPS];
UWORD remember_JMP[REMEMBER_JMP_STEPS];
unsigned int remember_jmp_curpos = 0;
#define INC_RET_NESTING ret_nesting++
#else /* MONITOR_BREAK */
#define INC_RET_NESTING
#endif /* MONITOR_BREAK */
/* Addressing modes */
#ifdef WRAP_ZPAGE
#define zGetWord(x) (dGetByte(x) + (dGetByte((UBYTE) ((x) + 1)) << 8))
#else
#define zGetWord(x) dGetWord(x)
#endif
#ifdef PREFETCH_CODE
#if defined(WORDS_BIGENDIAN) || !defined(WORDS_UNALIGNED_OK)
#warning PREFETCH_CODE is efficient only on little-endian machines with WORDS_UNALIGNED_OK
#endif
#define OP_BYTE ((UBYTE) addr)
#define OP_WORD addr
#define IMMEDIATE (PC++, (UBYTE) addr)
#define ABSOLUTE PC += 2
#define ZPAGE PC++; addr &= 0xff
#define ABSOLUTE_X addr += X; PC += 2
#define ABSOLUTE_Y addr += Y; PC += 2
#define INDIRECT_X PC++; addr = (UBYTE) (addr + X); addr = zGetWord(addr)
#define INDIRECT_Y PC++; addr &= 0xff; addr = zGetWord(addr) + Y
#define ZPAGE_X PC++; addr = (UBYTE) (addr + X)
#define ZPAGE_Y PC++; addr = (UBYTE) (addr + Y)
#else /* PREFETCH_CODE */
#define OP_BYTE PEEK_CODE_BYTE()
#define OP_WORD PEEK_CODE_WORD()
#define IMMEDIATE GET_CODE_BYTE()
#define ABSOLUTE addr = PEEK_CODE_WORD(); PC += 2
#define ZPAGE addr = GET_CODE_BYTE()
#define ABSOLUTE_X addr = PEEK_CODE_WORD() + X; PC += 2
#define ABSOLUTE_Y addr = PEEK_CODE_WORD() + Y; PC += 2
#define INDIRECT_X addr = (UBYTE) (GET_CODE_BYTE() + X); addr = zGetWord(addr)
#define INDIRECT_Y addr = GET_CODE_BYTE(); addr = zGetWord(addr) + Y
#define ZPAGE_X addr = (UBYTE) (GET_CODE_BYTE() + X)
#define ZPAGE_Y addr = (UBYTE) (GET_CODE_BYTE() + Y)
#endif /* PREFETCH_CODE */
/* Instructions */
#define AND(t_data) Z = N = A &= t_data
#define CMP(t_data) data = t_data; Z = N = A - data; C = (A >= data)
#define CPX(t_data) data = t_data; Z = N = X - data; C = (X >= data)
#define CPY(t_data) data = t_data; Z = N = Y - data; C = (Y >= data)
#define EOR(t_data) Z = N = A ^= t_data
#define LDA(t_data) Z = N = A = t_data
#define LDX(t_data) Z = N = X = t_data
#define LDY(t_data) Z = N = Y = t_data
#define ORA(t_data) Z = N = A |= t_data
#ifndef NO_V_FLAG_VARIABLE
#define PHP(x) data = (N & 0x80) + (V ? 0x40 : 0) + (regP & (x)) + ((Z == 0) ? 0x02 : 0) + C; PH(data)
#define PHPB0 PHP(0x2c) /* push flags with B flag clear (NMI, IRQ) */
#define PHPB1 PHP(0x3c) /* push flags with B flag set (PHP, BRK) */
#define PLP data = PL; N = data; V = (data & 0x40); Z = (data & 0x02) ^ 0x02; C = (data & 0x01); regP = (data & 0x0c) + 0x30
#else /* NO_V_FLAG_VARIABLE */
#define PHP(x) data = (N & 0x80) + (regP & (x)) + ((Z == 0) ? 0x02 : 0) + C; PH(data)
#define PHPB0 PHP(0x6c) /* push flags with B flag clear (NMI, IRQ) */
#define PHPB1 PHP(0x7c) /* push flags with B flag set (PHP, BRK) */
#define PLP data = PL; N = data; Z = (data & 0x02) ^ 0x02; C = (data & 0x01); regP = (data & 0x4c) + 0x30
#endif /* NO_V_FLAG_VARIABLE */
/* 1 or 2 extra cycles for conditional jumps */
#if 0
/* old, less efficient version */
#define BRANCH(cond) \
if (cond) { \
SWORD sdata = (SBYTE) GET_CODE_BYTE(); \
if ((sdata + (UBYTE) GET_PC()) & 0xff00) \
xpos++; \
xpos++; \
PC += sdata; \
DONE \
} \
PC++; \
DONE
#else
#define BRANCH(cond) \
if (cond) { \
addr = (UWORD) (SBYTE) IMMEDIATE; \
addr += GET_PC(); \
if ((addr ^ GET_PC()) & 0xff00) \
xpos++; \
xpos++; \
SET_PC(addr); \
DONE \
} \
PC++; \
DONE
#endif
/* 1 extra cycle for X (or Y) index overflow */
#define NCYCLES_X if ((UBYTE) addr < X) xpos++
#define NCYCLES_Y if ((UBYTE) addr < Y) xpos++
/* Triggers a Non-Maskable Interrupt */
void NMI(void)
{
UBYTE S = regS;
UBYTE data;
PHW(regPC);
PHPB0;
SetI;
regPC = dGetWordAligned(0xfffa);
regS = S;
xpos += 7; /* handling an interrupt by 6502 takes 7 cycles */
INC_RET_NESTING;
}
/* Check pending IRQ, helps in (not only) Lucasfilm games */
#define CPUCHECKIRQ \
if (IRQ && !(regP & I_FLAG) && xpos < xpos_limit) { \
PHPC; \
PHPB0; \
SetI; \
SET_PC(dGetWordAligned(0xfffe)); \
xpos += 7; \
INC_RET_NESTING; \
}
/* Enter monitor */
#ifdef __PLUS
#define ENTER_MONITOR Atari800_Exit(TRUE)
#else
#define ENTER_MONITOR if (!Atari800_Exit(TRUE)) exit(0)
#endif
#define DO_BREAK \
UPDATE_GLOBAL_REGS; \
CPU_GetStatus(); \
ENTER_MONITOR; \
CPU_PutStatus(); \
UPDATE_LOCAL_REGS;
/* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
static const int cycles[256] =
{
7, 6, 2, 8, 3, 3, 5, 5, 3, 2, 2, 2, 4, 4, 6, 6, /* 0x */
2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 1x */
6, 6, 2, 8, 3, 3, 5, 5, 4, 2, 2, 2, 4, 4, 6, 6, /* 2x */
2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 3x */
6, 6, 2, 8, 3, 3, 5, 5, 3, 2, 2, 2, 3, 4, 6, 6, /* 4x */
2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 5x */
6, 6, 2, 8, 3, 3, 5, 5, 4, 2, 2, 2, 5, 4, 6, 6, /* 6x */
2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 7x */
2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 2, 4, 4, 4, 4, /* 8x */
2, 6, 2, 6, 4, 4, 4, 4, 2, 5, 2, 5, 5, 5, 5, 5, /* 9x */
2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 2, 4, 4, 4, 4, /* Ax */
2, 5, 2, 5, 4, 4, 4, 4, 2, 4, 2, 4, 4, 4, 4, 4, /* Bx */
2, 6, 2, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 6, 6, /* Cx */
2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* Dx */
2, 6, 2, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 6, 6, /* Ex */
2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7 /* Fx */
};
/* 6502 emulation routine */
void GO(int limit)
{
#ifdef NO_GOTO
#define OPCODE_ALIAS(code) case 0x##code:
#define DONE break;
#else
#define OPCODE_ALIAS(code) opcode_##code:
#define DONE goto next;
static const void *opcode[256] =
{
&&opcode_00, &&opcode_01, &&opcode_02, &&opcode_03,
&&opcode_04, &&opcode_05, &&opcode_06, &&opcode_07,
&&opcode_08, &&opcode_09, &&opcode_0a, &&opcode_0b,
&&opcode_0c, &&opcode_0d, &&opcode_0e, &&opcode_0f,
&&opcode_10, &&opcode_11, &&opcode_12, &&opcode_13,
&&opcode_14, &&opcode_15, &&opcode_16, &&opcode_17,
&&opcode_18, &&opcode_19, &&opcode_1a, &&opcode_1b,
&&opcode_1c, &&opcode_1d, &&opcode_1e, &&opcode_1f,
&&opcode_20, &&opcode_21, &&opcode_22, &&opcode_23,
&&opcode_24, &&opcode_25, &&opcode_26, &&opcode_27,
&&opcode_28, &&opcode_29, &&opcode_2a, &&opcode_2b,
&&opcode_2c, &&opcode_2d, &&opcode_2e, &&opcode_2f,
&&opcode_30, &&opcode_31, &&opcode_32, &&opcode_33,
&&opcode_34, &&opcode_35, &&opcode_36, &&opcode_37,
&&opcode_38, &&opcode_39, &&opcode_3a, &&opcode_3b,
&&opcode_3c, &&opcode_3d, &&opcode_3e, &&opcode_3f,
&&opcode_40, &&opcode_41, &&opcode_42, &&opcode_43,
&&opcode_44, &&opcode_45, &&opcode_46, &&opcode_47,
&&opcode_48, &&opcode_49, &&opcode_4a, &&opcode_4b,
&&opcode_4c, &&opcode_4d, &&opcode_4e, &&opcode_4f,
&&opcode_50, &&opcode_51, &&opcode_52, &&opcode_53,
&&opcode_54, &&opcode_55, &&opcode_56, &&opcode_57,
&&opcode_58, &&opcode_59, &&opcode_5a, &&opcode_5b,
&&opcode_5c, &&opcode_5d, &&opcode_5e, &&opcode_5f,
&&opcode_60, &&opcode_61, &&opcode_62, &&opcode_63,
&&opcode_64, &&opcode_65, &&opcode_66, &&opcode_67,
&&opcode_68, &&opcode_69, &&opcode_6a, &&opcode_6b,
&&opcode_6c, &&opcode_6d, &&opcode_6e, &&opcode_6f,
&&opcode_70, &&opcode_71, &&opcode_72, &&opcode_73,
&&opcode_74, &&opcode_75, &&opcode_76, &&opcode_77,
&&opcode_78, &&opcode_79, &&opcode_7a, &&opcode_7b,
&&opcode_7c, &&opcode_7d, &&opcode_7e, &&opcode_7f,
&&opcode_80, &&opcode_81, &&opcode_82, &&opcode_83,
&&opcode_84, &&opcode_85, &&opcode_86, &&opcode_87,
&&opcode_88, &&opcode_89, &&opcode_8a, &&opcode_8b,
&&opcode_8c, &&opcode_8d, &&opcode_8e, &&opcode_8f,
&&opcode_90, &&opcode_91, &&opcode_92, &&opcode_93,
&&opcode_94, &&opcode_95, &&opcode_96, &&opcode_97,
&&opcode_98, &&opcode_99, &&opcode_9a, &&opcode_9b,
&&opcode_9c, &&opcode_9d, &&opcode_9e, &&opcode_9f,
&&opcode_a0, &&opcode_a1, &&opcode_a2, &&opcode_a3,
&&opcode_a4, &&opcode_a5, &&opcode_a6, &&opcode_a7,
&&opcode_a8, &&opcode_a9, &&opcode_aa, &&opcode_ab,
&&opcode_ac, &&opcode_ad, &&opcode_ae, &&opcode_af,
&&opcode_b0, &&opcode_b1, &&opcode_b2, &&opcode_b3,
&&opcode_b4, &&opcode_b5, &&opcode_b6, &&opcode_b7,
&&opcode_b8, &&opcode_b9, &&opcode_ba, &&opcode_bb,
&&opcode_bc, &&opcode_bd, &&opcode_be, &&opcode_bf,
&&opcode_c0, &&opcode_c1, &&opcode_c2, &&opcode_c3,
&&opcode_c4, &&opcode_c5, &&opcode_c6, &&opcode_c7,
&&opcode_c8, &&opcode_c9, &&opcode_ca, &&opcode_cb,
&&opcode_cc, &&opcode_cd, &&opcode_ce, &&opcode_cf,
&&opcode_d0, &&opcode_d1, &&opcode_d2, &&opcode_d3,
&&opcode_d4, &&opcode_d5, &&opcode_d6, &&opcode_d7,
&&opcode_d8, &&opcode_d9, &&opcode_da, &&opcode_db,
&&opcode_dc, &&opcode_dd, &&opcode_de, &&opcode_df,
&&opcode_e0, &&opcode_e1, &&opcode_e2, &&opcode_e3,
&&opcode_e4, &&opcode_e5, &&opcode_e6, &&opcode_e7,
&&opcode_e8, &&opcode_e9, &&opcode_ea, &&opcode_eb,
&&opcode_ec, &&opcode_ed, &&opcode_ee, &&opcode_ef,
&&opcode_f0, &&opcode_f1, &&opcode_f2, &&opcode_f3,
&&opcode_f4, &&opcode_f5, &&opcode_f6, &&opcode_f7,
&&opcode_f8, &&opcode_f9, &&opcode_fa, &&opcode_fb,
&&opcode_fc, &&opcode_fd, &&opcode_fe, &&opcode_ff,
};
#endif /* NO_GOTO */
#ifdef CYCLES_PER_OPCODE
#define OPCODE(code) OPCODE_ALIAS(code) xpos += cycles[0x##code];
#else
#define OPCODE(code) OPCODE_ALIAS(code)
#endif
#ifdef PC_PTR
const UBYTE *PC;
#else
UWORD PC;
#endif
UBYTE A;
UBYTE X;
UBYTE Y;
UBYTE S;
UWORD addr;
UBYTE data;
#define insn data
/*
This used to be in the main loop but has been removed to improve
execution speed. It does not seem to have any adverse effect on
the emulation for two reasons:
1. NMI's will can only be raised in antic.c - there is
no way an NMI can be generated whilst in this routine.
2. The timing of the IRQs are not that critical. */
if (wsync_halt) {
#ifdef NEW_CYCLE_EXACT
if (DRAWING_SCREEN) {
/* if WSYNC_C is a stolen cycle, antic2cpu_ptr will convert that to the nearest
cpu cycle before that cycle. The CPU will see this cycle, if WSYNC is not
delayed. (Actually this cycle is the first cycle of the instruction after
STA WSYNC, which was really executed one cycle after STA WSYNC because
of an internal antic delay ). delayed_wsync is added to this cycle to form
the limit in the case that WSYNC is not early (does not allow this extra cycle) */
if (limit < antic2cpu_ptr[WSYNC_C] + delayed_wsync)
return;
xpos = antic2cpu_ptr[WSYNC_C] + delayed_wsync;
}
else {
if (limit < (WSYNC_C + delayed_wsync))
return;
xpos = WSYNC_C;
}
delayed_wsync = 0;
#else /* NEW_CYCLE_EXACT */
if (limit < WSYNC_C)
return;
xpos = WSYNC_C;
#endif /* NEW_CYCLE_EXACT */
wsync_halt = 0;
}
xpos_limit = limit; /* needed for WSYNC store inside ANTIC */
UPDATE_LOCAL_REGS;
CPUCHECKIRQ;
while (xpos < limit) {
#ifdef MONITOR_BREAKPOINTS
breakpoint_return:
#endif
#ifdef PC_PTR
/* must handle 64k wrapping */
if (PC >= memory + 0xfffe) {
if (PC >= memory + 0x10000)
PC -= 0x10000;
else {
/* the opcode is before 0x10000, but the operand is past */
#ifdef WORDS_UNALIGNED_OK
*(UWORD *) (memory + 0x10000) = *(UWORD *) memory;
#else
memory[0x10000] = memory[0];
memory[0x10001] = memory[1];
#endif /* WORDS_UNALIGNED_OK */
}
}
#endif /* PC_PTR */
#ifdef MONITOR_TRACE
if (trace_file != NULL) {
show_state(trace_file, GET_PC(), A, X, Y, S,
(N & 0x80) ? 'N' : '-',
#ifndef NO_V_FLAG_VARIABLE
V ? 'V' : '-',
#else
(regP & V_FLAG) ? 'V' : '-',
#endif
(Z == 0) ? 'Z' : '-',
(C != 0) ? 'C' : '-');
}
#endif
#ifdef MONITOR_BREAK
remember_PC[remember_PC_curpos] = GET_PC();
#ifdef NEW_CYCLE_EXACT
if (DRAWING_SCREEN)
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -