开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
cpu.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：50k
源码类别：

Windows CE

开发平台：

C/C++

cpu.c：源码内容
  1. /*
  2.  * cpu.c - 6502 CPU emulation
  3.  *
  4.  * Copyright (C) 1995-1998 David Firth
  5.  * Copyright (C) 1998-2005 Atari800 development team (see DOC/CREDITS)
  6.  *
  7.  * This file is part of the Atari800 emulator project which emulates
  8.  * the Atari 400, 800, 800XL, 130XE, and 5200 8-bit computers.
  9.  *
  10.  * Atari800 is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * Atari800 is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with Atari800; if not, write to the Free Software
  22.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23. */
  25. /*
  26. Configuration symbols
  27. =====================
  29. Define CPU65C02 if you don't want 6502 JMP() bug emulation.
  30. Define CYCLES_PER_OPCODE to update xpos in each opcode's emulation.
  31. Define MONITOR_BREAK if you want code breakpoints and execution history.
  32. Define MONITOR_BREAKPOINTS if you want user-defined breakpoints.
  33. Define MONITOR_PROFILE if you want 6502 opcode profiling.
  34. Define MONITOR_TRACE if you want the code to be disassembled while it is executed.
  35. Define NO_GOTO if you compile with GCC, but want switch() rather than goto *.
  36. Define NO_V_FLAG_VARIABLE to don't use local (static) variable V for the V flag.
  37. Define PC_PTR to emulate 6502 Program Counter using UBYTE *.
  38. Define PREFETCH_CODE to always fetch 2 bytes after the opcode.
  39. Define WRAP_64K to correctly emulate instructions that wrap at 64K.
  40. Define WRAP_ZPAGE to prevent incorrect access to the address 0x0100 in zeropage
  41. indirect mode.
  44. Limitations & Known bugs
  45. ========================
  47. There is no emulation of the bug in the BRK instruction executed simultaneously
  48. with another interrupt.
  50. The 6502 emulation ignores memory attributes for instruction fetch.
  51. This is because the instruction must come from either RAM or ROM.
  52. A program that executes instructions from within hardware addresses will fail
  53. since there is never any usable code there.
  55. The 6502 emulation also ignores memory attributes for accesses to page 0 and page 1.
  56.  */
  58. #include "config.h"
  59. #include <stdio.h>
  60. #include <stdlib.h> /* exit() */
  62. #include "cpu.h"
  63. #ifdef ASAP /* external project, see http://asap.sf.net */
  64. #include "asap_internal.h"
  65. #else
  66. #include "antic.h"
  67. #include "atari.h"
  68. #include "memory.h"
  69. #include "monitor.h"
  70. #ifndef BASIC
  71. #include "statesav.h"
  72. #ifndef __PLUS
  73. #include "ui.h"
  74. #endif
  75. #endif /* BASIC */
  76. #endif /* ASAP */
  78. #ifdef FALCON_CPUASM
  80. extern UBYTE IRQ;
  82. #ifdef PAGED_MEM
  83. #error cpu_m68k.asm cannot work with paged memory
  84. #endif
  86. void CPU_Initialise(void)
  87. {
  88. CPU_INIT();
  89. }
  91. void CPU_GetStatus(void)
  92. {
  93. CPUGET();
  94. }
  96. void CPU_PutStatus(void)
  97. {
  98. CPUPUT();
  99. }
  101. #else /* FALCON_CPUASM */
  103. /* Windows headers define it */
  104. #undef ABSOLUTE
  106. #ifndef __GNUC__
  107. #define NO_GOTO
  108. #endif
  110. /* #define CYCLES_PER_OPCODE */
  112. /* #define MONITOR_PROFILE */
  114. /* #define NO_V_FLAG_VARIABLE */
  116. /* If PC_PTR is defined, local PC is "const UBYTE *", otherwise it's UWORD. */
  117. /* #define PC_PTR */
  119. /* If PREFETCH_CODE is defined, 2 bytes after the opcode are always fetched. */
  120. /* #define PREFETCH_CODE */
  123. /* 6502 stack handling */
  124. #define PL                  dGetByte(0x0100 + ++S)
  125. #define PH(x)               dPutByte(0x0100 + S--, x)
  126. #define PHW(x)              PH((x) >> 8); PH((x) & 0xff)
  128. /* 6502 code fetching */
  129. #ifdef PC_PTR
  130. #define GET_PC()            (PC - memory)
  131. #define SET_PC(newpc)       (PC = memory + (newpc))
  132. #define PHPC                { UWORD tmp = PC - memory; PHW(tmp); }
  133. #define GET_CODE_BYTE()     (*PC++)
  134. #define PEEK_CODE_BYTE()    (*PC)
  135. #if !defined(WORDS_BIGENDIAN) && defined(WORDS_UNALIGNED_OK)
  136. #define PEEK_CODE_WORD()    (*(const UWORD *) PC)
  137. #else
  138. #define PEEK_CODE_WORD()    (*PC + (PC[1] << 8))
  139. #endif
  140. #else /* PC_PTR */
  141. #define GET_PC()            PC
  142. #define SET_PC(newpc)       (PC = (newpc))
  143. #define PHPC                PHW(PC)
  144. #define GET_CODE_BYTE()     dGetByte(PC++)
  145. #define PEEK_CODE_BYTE()    dGetByte(PC)
  146. #define PEEK_CODE_WORD()    dGetWord(PC)
  147. #endif /* PC_PTR */
  149. /* Cycle-exact Read-Modify-Write instructions.
  150.    RMW instructions: ASL, LSR, ROL, ROR, INC, DEC
  151.    (+ some undocumented) write to the specified address
  152.    *twice*: first the unmodified value, then the modified value.
  153.    This can be observed only with some hardware registers. */
  154. /* XXX: we do this only for GTIA, because NEW_CYCLE_EXACT does not correctly
  155.    emulate INC $D400 (and INC $D40A wasn't tested) */
  156. #ifdef NEW_CYCLE_EXACT
  157. #ifndef PAGED_ATTRIB
  158. #define RMW_GetByte(x, addr) 
  159. if (attrib[addr] == HARDWARE) { 
  160. x = Atari800_GetByte(addr); 
  161. if ((addr & 0xef00) == 0xc000) { 
  162. xpos--; 
  163. Atari800_PutByte(addr, x); 
  164. xpos++; 
  165. } 
  166. } else 
  167. x = dGetByte(addr);
  168. #else /* PAGED_ATTRIB */
  169. #define RMW_GetByte(x, addr) 
  170. x = GetByte(addr); 
  171. if ((addr & 0xef00) == 0xc000) { 
  172. xpos--; 
  173. PutByte(addr, x); 
  174. xpos++; 
  175. }
  176. #endif /* PAGED_ATTRIB */
  177. #else /* NEW_CYCLE_EXACT */
  178. /* Don't emulate the first write */
  179. #define RMW_GetByte(x, addr) x = GetByte(addr);
  180. #endif /* NEW_CYCLE_EXACT */
  182. /* 6502 registers. */
  183. UWORD regPC;
  184. UBYTE regA;
  185. UBYTE regX;
  186. UBYTE regY;
  187. UBYTE regP; /* Processor Status Byte (Partial) */
  188. UBYTE regS;
  189. UBYTE IRQ;
  191. /* Transfer 6502 registers between global variables and local variables inside GO() */
  192. #define UPDATE_GLOBAL_REGS  regPC = GET_PC(); regS = S; regA = A; regX = X; regY = Y
  193. #define UPDATE_LOCAL_REGS   SET_PC(regPC); S = regS; A = regA; X = regX; Y = regY
  195. /* 6502 flags local to this module */
  196. static UBYTE N; /* bit7 set => N flag set */
  197. #ifndef NO_V_FLAG_VARIABLE
  198. static UBYTE V;                 /* non-zero => V flag set */
  199. #endif
  200. static UBYTE Z; /* zero     => Z flag set */
  201. static UBYTE C; /* must be 0 or 1 */
  202. /* B, D, I are always in regP */
  204. void CPU_GetStatus(void)
  205. {
  206. #ifndef NO_V_FLAG_VARIABLE
  207. regP = (N & 0x80) + (V ? 0x40 : 0) + (regP & 0x3c) + ((Z == 0) ? 0x02 : 0) + C;
  208. #else
  209. regP = (N & 0x80) + (regP & 0x7c) + ((Z == 0) ? 0x02 : 0) + C;
  210. #endif
  211. }
  213. void CPU_PutStatus(void)
  214. {
  215. N = regP;
  216. #ifndef NO_V_FLAG_VARIABLE
  217. V = (regP & 0x40);
  218. #endif
  219. Z = (regP & 0x02) ^ 0x02;
  220. C = (regP & 0x01);
  221. }
  223. /* For Atari Basic loader */
  224. void (*rts_handler)(void) = NULL;
  226. /* 6502 instruction profiling */
  227. #ifdef MONITOR_PROFILE
  228. int instruction_count[256];
  229. #endif
  231. UBYTE cim_encountered = FALSE;
  233. /* Execution history */
  234. #ifdef MONITOR_BREAK
  235. UWORD remember_PC[REMEMBER_PC_STEPS];
  236. unsigned int remember_PC_curpos = 0;
  237. int remember_xpos[REMEMBER_PC_STEPS];
  238. UWORD remember_JMP[REMEMBER_JMP_STEPS];
  239. unsigned int remember_jmp_curpos = 0;
  240. #define INC_RET_NESTING ret_nesting++
  241. #else /* MONITOR_BREAK */
  242. #define INC_RET_NESTING
  243. #endif /* MONITOR_BREAK */
  245. /* Addressing modes */
  246. #ifdef WRAP_ZPAGE
  247. #define zGetWord(x) (dGetByte(x) + (dGetByte((UBYTE) ((x) + 1)) << 8))
  248. #else
  249. #define zGetWord(x) dGetWord(x)
  250. #endif
  251. #ifdef PREFETCH_CODE
  252. #if defined(WORDS_BIGENDIAN) || !defined(WORDS_UNALIGNED_OK)
  253. #warning PREFETCH_CODE is efficient only on little-endian machines with WORDS_UNALIGNED_OK
  254. #endif
  255. #define OP_BYTE     ((UBYTE) addr)
  256. #define OP_WORD     addr
  257. #define IMMEDIATE   (PC++, (UBYTE) addr)
  258. #define ABSOLUTE    PC += 2
  259. #define ZPAGE       PC++; addr &= 0xff
  260. #define ABSOLUTE_X  addr += X; PC += 2
  261. #define ABSOLUTE_Y  addr += Y; PC += 2
  262. #define INDIRECT_X  PC++; addr = (UBYTE) (addr + X); addr = zGetWord(addr)
  263. #define INDIRECT_Y  PC++; addr &= 0xff; addr = zGetWord(addr) + Y
  264. #define ZPAGE_X     PC++; addr = (UBYTE) (addr + X)
  265. #define ZPAGE_Y     PC++; addr = (UBYTE) (addr + Y)
  266. #else /* PREFETCH_CODE */
  267. #define OP_BYTE     PEEK_CODE_BYTE()
  268. #define OP_WORD     PEEK_CODE_WORD()
  269. #define IMMEDIATE   GET_CODE_BYTE()
  270. #define ABSOLUTE    addr = PEEK_CODE_WORD(); PC += 2
  271. #define ZPAGE       addr = GET_CODE_BYTE()
  272. #define ABSOLUTE_X  addr = PEEK_CODE_WORD() + X; PC += 2
  273. #define ABSOLUTE_Y  addr = PEEK_CODE_WORD() + Y; PC += 2
  274. #define INDIRECT_X  addr = (UBYTE) (GET_CODE_BYTE() + X); addr = zGetWord(addr)
  275. #define INDIRECT_Y  addr = GET_CODE_BYTE(); addr = zGetWord(addr) + Y
  276. #define ZPAGE_X     addr = (UBYTE) (GET_CODE_BYTE() + X)
  277. #define ZPAGE_Y     addr = (UBYTE) (GET_CODE_BYTE() + Y)
  278. #endif /* PREFETCH_CODE */
  280. /* Instructions */
  281. #define AND(t_data) Z = N = A &= t_data
  282. #define CMP(t_data) data = t_data; Z = N = A - data; C = (A >= data)
  283. #define CPX(t_data) data = t_data; Z = N = X - data; C = (X >= data)
  284. #define CPY(t_data) data = t_data; Z = N = Y - data; C = (Y >= data)
  285. #define EOR(t_data) Z = N = A ^= t_data
  286. #define LDA(t_data) Z = N = A = t_data
  287. #define LDX(t_data) Z = N = X = t_data
  288. #define LDY(t_data) Z = N = Y = t_data
  289. #define ORA(t_data) Z = N = A |= t_data
  290. #ifndef NO_V_FLAG_VARIABLE
  291. #define PHP(x)      data = (N & 0x80) + (V ? 0x40 : 0) + (regP & (x)) + ((Z == 0) ? 0x02 : 0) + C; PH(data)
  292. #define PHPB0       PHP(0x2c)  /* push flags with B flag clear (NMI, IRQ) */
  293. #define PHPB1       PHP(0x3c)  /* push flags with B flag set (PHP, BRK) */
  294. #define PLP         data = PL; N = data; V = (data & 0x40); Z = (data & 0x02) ^ 0x02; C = (data & 0x01); regP = (data & 0x0c) + 0x30
  295. #else /* NO_V_FLAG_VARIABLE */
  296. #define PHP(x)      data = (N & 0x80) + (regP & (x)) + ((Z == 0) ? 0x02 : 0) + C; PH(data)
  297. #define PHPB0       PHP(0x6c)  /* push flags with B flag clear (NMI, IRQ) */
  298. #define PHPB1       PHP(0x7c)  /* push flags with B flag set (PHP, BRK) */
  299. #define PLP         data = PL; N = data; Z = (data & 0x02) ^ 0x02; C = (data & 0x01); regP = (data & 0x4c) + 0x30
  300. #endif /* NO_V_FLAG_VARIABLE */
  301. /* 1 or 2 extra cycles for conditional jumps */
  302. #if 0
  303. /* old, less efficient version */
  304. #define BRANCH(cond) 
  305. if (cond) { 
  306. SWORD sdata = (SBYTE) GET_CODE_BYTE(); 
  307. if ((sdata + (UBYTE) GET_PC()) & 0xff00) 
  308. xpos++; 
  309. xpos++; 
  310. PC += sdata; 
  311. DONE 
  312. } 
  313. PC++; 
  314. DONE
  315. #else
  316. #define BRANCH(cond) 
  317. if (cond) { 
  318. addr = (UWORD) (SBYTE) IMMEDIATE; 
  319. addr += GET_PC(); 
  320. if ((addr ^ GET_PC()) & 0xff00) 
  321. xpos++; 
  322. xpos++; 
  323. SET_PC(addr); 
  324. DONE 
  325. } 
  326. PC++; 
  327. DONE
  328. #endif
  330. /* 1 extra cycle for X (or Y) index overflow */
  331. #define NCYCLES_X   if ((UBYTE) addr < X) xpos++
  332. #define NCYCLES_Y   if ((UBYTE) addr < Y) xpos++
  334. /* Triggers a Non-Maskable Interrupt */
  335. void NMI(void)
  336. {
  337. UBYTE S = regS;
  338. UBYTE data;
  340. PHW(regPC);
  341. PHPB0;
  342. SetI;
  343. regPC = dGetWordAligned(0xfffa);
  344. regS = S;
  345. xpos += 7; /* handling an interrupt by 6502 takes 7 cycles */
  346. INC_RET_NESTING;
  347. }
  349. /* Check pending IRQ, helps in (not only) Lucasfilm games */
  350. #define CPUCHECKIRQ 
  351. if (IRQ && !(regP & I_FLAG) && xpos < xpos_limit) { 
  352. PHPC; 
  353. PHPB0; 
  354. SetI; 
  355. SET_PC(dGetWordAligned(0xfffe)); 
  356. xpos += 7; 
  357. INC_RET_NESTING; 
  358. }
  360. /* Enter monitor */
  361. #ifdef __PLUS
  362. #define ENTER_MONITOR  Atari800_Exit(TRUE)
  363. #else
  364. #define ENTER_MONITOR  if (!Atari800_Exit(TRUE)) exit(0)
  365. #endif
  366. #define DO_BREAK 
  367. UPDATE_GLOBAL_REGS; 
  368. CPU_GetStatus(); 
  369. ENTER_MONITOR; 
  370. CPU_PutStatus(); 
  371. UPDATE_LOCAL_REGS;
  374. /* 0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F */
  375. static const int cycles[256] =
  376. {
  377. 7, 6, 2, 8, 3, 3, 5, 5, 3, 2, 2, 2, 4, 4, 6, 6, /* 0x */
  378. 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 1x */
  379. 6, 6, 2, 8, 3, 3, 5, 5, 4, 2, 2, 2, 4, 4, 6, 6, /* 2x */
  380. 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 3x */
  382. 6, 6, 2, 8, 3, 3, 5, 5, 3, 2, 2, 2, 3, 4, 6, 6, /* 4x */
  383. 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 5x */
  384. 6, 6, 2, 8, 3, 3, 5, 5, 4, 2, 2, 2, 5, 4, 6, 6, /* 6x */
  385. 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 7x */
  387. 2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 2, 4, 4, 4, 4, /* 8x */
  388. 2, 6, 2, 6, 4, 4, 4, 4, 2, 5, 2, 5, 5, 5, 5, 5, /* 9x */
  389. 2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 2, 4, 4, 4, 4, /* Ax */
  390. 2, 5, 2, 5, 4, 4, 4, 4, 2, 4, 2, 4, 4, 4, 4, 4, /* Bx */
  392. 2, 6, 2, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 6, 6, /* Cx */
  393. 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* Dx */
  394. 2, 6, 2, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 6, 6, /* Ex */
  395. 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7 /* Fx */
  396. };
  398. /* 6502 emulation routine */
  399. void GO(int limit)
  400. {
  401. #ifdef NO_GOTO
  402. #define OPCODE_ALIAS(code) case 0x##code:
  403. #define DONE break;
  404. #else
  405. #define OPCODE_ALIAS(code) opcode_##code:
  406. #define DONE goto next;
  407. static const void *opcode[256] =
  408. {
  409. &&opcode_00, &&opcode_01, &&opcode_02, &&opcode_03,
  410. &&opcode_04, &&opcode_05, &&opcode_06, &&opcode_07,
  411. &&opcode_08, &&opcode_09, &&opcode_0a, &&opcode_0b,
  412. &&opcode_0c, &&opcode_0d, &&opcode_0e, &&opcode_0f,
  414. &&opcode_10, &&opcode_11, &&opcode_12, &&opcode_13,
  415. &&opcode_14, &&opcode_15, &&opcode_16, &&opcode_17,
  416. &&opcode_18, &&opcode_19, &&opcode_1a, &&opcode_1b,
  417. &&opcode_1c, &&opcode_1d, &&opcode_1e, &&opcode_1f,
  419. &&opcode_20, &&opcode_21, &&opcode_22, &&opcode_23,
  420. &&opcode_24, &&opcode_25, &&opcode_26, &&opcode_27,
  421. &&opcode_28, &&opcode_29, &&opcode_2a, &&opcode_2b,
  422. &&opcode_2c, &&opcode_2d, &&opcode_2e, &&opcode_2f,
  424. &&opcode_30, &&opcode_31, &&opcode_32, &&opcode_33,
  425. &&opcode_34, &&opcode_35, &&opcode_36, &&opcode_37,
  426. &&opcode_38, &&opcode_39, &&opcode_3a, &&opcode_3b,
  427. &&opcode_3c, &&opcode_3d, &&opcode_3e, &&opcode_3f,
  429. &&opcode_40, &&opcode_41, &&opcode_42, &&opcode_43,
  430. &&opcode_44, &&opcode_45, &&opcode_46, &&opcode_47,
  431. &&opcode_48, &&opcode_49, &&opcode_4a, &&opcode_4b,
  432. &&opcode_4c, &&opcode_4d, &&opcode_4e, &&opcode_4f,
  434. &&opcode_50, &&opcode_51, &&opcode_52, &&opcode_53,
  435. &&opcode_54, &&opcode_55, &&opcode_56, &&opcode_57,
  436. &&opcode_58, &&opcode_59, &&opcode_5a, &&opcode_5b,
  437. &&opcode_5c, &&opcode_5d, &&opcode_5e, &&opcode_5f,
  439. &&opcode_60, &&opcode_61, &&opcode_62, &&opcode_63,
  440. &&opcode_64, &&opcode_65, &&opcode_66, &&opcode_67,
  441. &&opcode_68, &&opcode_69, &&opcode_6a, &&opcode_6b,
  442. &&opcode_6c, &&opcode_6d, &&opcode_6e, &&opcode_6f,
  444. &&opcode_70, &&opcode_71, &&opcode_72, &&opcode_73,
  445. &&opcode_74, &&opcode_75, &&opcode_76, &&opcode_77,
  446. &&opcode_78, &&opcode_79, &&opcode_7a, &&opcode_7b,
  447. &&opcode_7c, &&opcode_7d, &&opcode_7e, &&opcode_7f,
  449. &&opcode_80, &&opcode_81, &&opcode_82, &&opcode_83,
  450. &&opcode_84, &&opcode_85, &&opcode_86, &&opcode_87,
  451. &&opcode_88, &&opcode_89, &&opcode_8a, &&opcode_8b,
  452. &&opcode_8c, &&opcode_8d, &&opcode_8e, &&opcode_8f,
  454. &&opcode_90, &&opcode_91, &&opcode_92, &&opcode_93,
  455. &&opcode_94, &&opcode_95, &&opcode_96, &&opcode_97,
  456. &&opcode_98, &&opcode_99, &&opcode_9a, &&opcode_9b,
  457. &&opcode_9c, &&opcode_9d, &&opcode_9e, &&opcode_9f,
  459. &&opcode_a0, &&opcode_a1, &&opcode_a2, &&opcode_a3,
  460. &&opcode_a4, &&opcode_a5, &&opcode_a6, &&opcode_a7,
  461. &&opcode_a8, &&opcode_a9, &&opcode_aa, &&opcode_ab,
  462. &&opcode_ac, &&opcode_ad, &&opcode_ae, &&opcode_af,
  464. &&opcode_b0, &&opcode_b1, &&opcode_b2, &&opcode_b3,
  465. &&opcode_b4, &&opcode_b5, &&opcode_b6, &&opcode_b7,
  466. &&opcode_b8, &&opcode_b9, &&opcode_ba, &&opcode_bb,
  467. &&opcode_bc, &&opcode_bd, &&opcode_be, &&opcode_bf,
  469. &&opcode_c0, &&opcode_c1, &&opcode_c2, &&opcode_c3,
  470. &&opcode_c4, &&opcode_c5, &&opcode_c6, &&opcode_c7,
  471. &&opcode_c8, &&opcode_c9, &&opcode_ca, &&opcode_cb,
  472. &&opcode_cc, &&opcode_cd, &&opcode_ce, &&opcode_cf,
  474. &&opcode_d0, &&opcode_d1, &&opcode_d2, &&opcode_d3,
  475. &&opcode_d4, &&opcode_d5, &&opcode_d6, &&opcode_d7,
  476. &&opcode_d8, &&opcode_d9, &&opcode_da, &&opcode_db,
  477. &&opcode_dc, &&opcode_dd, &&opcode_de, &&opcode_df,
  479. &&opcode_e0, &&opcode_e1, &&opcode_e2, &&opcode_e3,
  480. &&opcode_e4, &&opcode_e5, &&opcode_e6, &&opcode_e7,
  481. &&opcode_e8, &&opcode_e9, &&opcode_ea, &&opcode_eb,
  482. &&opcode_ec, &&opcode_ed, &&opcode_ee, &&opcode_ef,
  484. &&opcode_f0, &&opcode_f1, &&opcode_f2, &&opcode_f3,
  485. &&opcode_f4, &&opcode_f5, &&opcode_f6, &&opcode_f7,
  486. &&opcode_f8, &&opcode_f9, &&opcode_fa, &&opcode_fb,
  487. &&opcode_fc, &&opcode_fd, &&opcode_fe, &&opcode_ff,
  488. };
  489. #endif /* NO_GOTO */
  491. #ifdef CYCLES_PER_OPCODE
  492. #define OPCODE(code) OPCODE_ALIAS(code) xpos += cycles[0x##code];
  493. #else
  494. #define OPCODE(code) OPCODE_ALIAS(code)
  495. #endif
  497. #ifdef PC_PTR
  498. const UBYTE *PC;
  499. #else
  500. UWORD PC;
  501. #endif
  502. UBYTE A;
  503. UBYTE X;
  504. UBYTE Y;
  505. UBYTE S;
  507. UWORD addr;
  508. UBYTE data;
  509. #define insn data
  511. /*
  512.    This used to be in the main loop but has been removed to improve
  513.    execution speed. It does not seem to have any adverse effect on
  514.    the emulation for two reasons:
  516.    1. NMI's will can only be raised in antic.c - there is
  517.       no way an NMI can be generated whilst in this routine.
  519.    2. The timing of the IRQs are not that critical. */
  521. if (wsync_halt) {
  523. #ifdef NEW_CYCLE_EXACT
  524. if (DRAWING_SCREEN) {
  525. /* if WSYNC_C is a stolen cycle, antic2cpu_ptr will convert that to the nearest
  526.    cpu cycle before that cycle.  The CPU will see this cycle, if WSYNC is not
  527.    delayed. (Actually this cycle is the first cycle of the instruction after
  528.    STA WSYNC, which was really executed one cycle after STA WSYNC because
  529.    of an internal antic delay ).   delayed_wsync is added to this cycle to form
  530.    the limit in the case that WSYNC is not early (does not allow this extra cycle) */
  532. if (limit < antic2cpu_ptr[WSYNC_C] + delayed_wsync)
  533. return;
  534. xpos = antic2cpu_ptr[WSYNC_C] + delayed_wsync;
  535. }
  536. else {
  537. if (limit < (WSYNC_C + delayed_wsync))
  538. return;
  539. xpos = WSYNC_C;
  540. }
  541. delayed_wsync = 0;
  543. #else /* NEW_CYCLE_EXACT */
  545. if (limit < WSYNC_C)
  546. return;
  547. xpos = WSYNC_C;
  549. #endif /* NEW_CYCLE_EXACT */
  551. wsync_halt = 0;
  552. }
  553. xpos_limit = limit; /* needed for WSYNC store inside ANTIC */
  555. UPDATE_LOCAL_REGS;
  557. CPUCHECKIRQ;
  559. while (xpos < limit) {
  561. #ifdef MONITOR_BREAKPOINTS
  562. breakpoint_return:
  563. #endif
  565. #ifdef PC_PTR
  566. /* must handle 64k wrapping */
  567. if (PC >= memory + 0xfffe) {
  568. if (PC >= memory + 0x10000)
  569. PC -= 0x10000;
  570. else {
  571. /* the opcode is before 0x10000, but the operand is past */
  572. #ifdef WORDS_UNALIGNED_OK
  573. *(UWORD *) (memory + 0x10000) = *(UWORD *) memory;
  574. #else
  575. memory[0x10000] = memory[0];
  576. memory[0x10001] = memory[1];
  577. #endif /* WORDS_UNALIGNED_OK */
  578. }
  579. }
  580. #endif /* PC_PTR */
  582. #ifdef MONITOR_TRACE
  583. if (trace_file != NULL) {
  584. show_state(trace_file, GET_PC(), A, X, Y, S,
  585. (N & 0x80) ? 'N' : '-',
  586. #ifndef NO_V_FLAG_VARIABLE
  587. V ? 'V' : '-',
  588. #else
  589. (regP & V_FLAG) ? 'V' : '-',
  590. #endif
  591. (Z == 0) ? 'Z' : '-',
  592. (C != 0) ? 'C' : '-');
  593. }
  594. #endif
  596. #ifdef MONITOR_BREAK
  597. remember_PC[remember_PC_curpos] = GET_PC();
  598. #ifdef NEW_CYCLE_EXACT
  599. if (DRAWING_SCREEN)
  600. remember_xpos[remember_PC_curpos] = cpu2antic_ptr[xpos] + (ypos << 8);
  601. else
  602. #endif
  603. remember_xpos[remember_PC_curpos] = xpos + (ypos << 8);
  604. remember_PC_curpos = (remember_PC_curpos + 1) % REMEMBER_PC_STEPS;
  606. if (break_addr == GET_PC() || break_ypos == ypos) {
  607. DO_BREAK;
  608. }
  609. #endif /* MONITOR_BREAK */
  611. #if defined(WRAP_64K) && !defined(PC_PTR)
  612. memory[0x10000] = memory[0];
  613. #endif
  615. insn = GET_CODE_BYTE();
  617. #ifdef MONITOR_BREAKPOINTS
  618. if (breakpoint_table_size > 0 && breakpoints_enabled) {
  619. UBYTE optype = optype6502[insn];
  620. int i;
  621. switch (optype >> 4) {
  622. case 1:
  623. addr = PEEK_CODE_WORD();
  624. break;
  625. case 2:
  626. addr = PEEK_CODE_BYTE();
  627. break;
  628. case 3:
  629. addr = PEEK_CODE_WORD() + X;
  630. break;
  631. case 4:
  632. addr = PEEK_CODE_WORD() + Y;
  633. break;
  634. case 5:
  635. addr = (UBYTE) (PEEK_CODE_BYTE() + X);
  636. addr = zGetWord(addr);
  637. break;
  638. case 6:
  639. addr = PEEK_CODE_BYTE();
  640. addr = zGetWord(addr) + Y;
  641. break;
  642. case 7:
  643. addr = (UBYTE) (PEEK_CODE_BYTE() + X);
  644. break;
  645. case 8:
  646. addr = (UBYTE) (PEEK_CODE_BYTE() + Y);
  647. break;
  648. /* XXX: case 13 */
  649. default:
  650. addr = 0;
  651. break;
  652. }
  653. for (i = 0; i < breakpoint_table_size; i++) {
  654. int cond;
  655. int value;
  656. if (!breakpoint_table[i].enabled)
  657. continue; /* skip */
  658. cond = breakpoint_table[i].condition;
  659. if (cond == BREAKPOINT_OR)
  660. break; /* fire */
  661. value = breakpoint_table[i].value;
  662. if (cond == BREAKPOINT_FLAG_CLEAR) {
  663. switch (value) {
  664. case N_FLAG:
  665. if ((N & 0x80) == 0)
  666. continue;
  667. break;
  668. #ifndef NO_V_FLAG_VARIABLE
  669. case V_FLAG:
  670. if (V == 0)
  671. continue;
  672. break;
  673. #endif
  674. case Z_FLAG:
  675. if (Z != 0)
  676. continue;
  677. break;
  678. case C_FLAG:
  679. if (C == 0)
  680. continue;
  681. break;
  682. default:
  683. if ((regP & value) == 0)
  684. continue;
  685. break;
  686. }
  687. }
  688. else if (cond == BREAKPOINT_FLAG_SET) {
  689. switch (value) {
  690. case N_FLAG:
  691. if ((N & 0x80) != 0)
  692. continue;
  693. break;
  694. #ifndef NO_V_FLAG_VARIABLE
  695. case V_FLAG:
  696. if (V != 0)
  697. continue;
  698. break;
  699. #endif
  700. case Z_FLAG:
  701. if (Z == 0)
  702. continue;
  703. break;
  704. case C_FLAG:
  705. if (C != 0)
  706. continue;
  707. break;
  708. default:
  709. if ((regP & value) != 0)
  710. continue;
  711. break;
  712. }
  713. }
  714. else {
  715. int val;
  716. switch (cond >> 3) {
  717. case BREAKPOINT_PC >> 3:
  718. val = GET_PC() - 1;
  719. break;
  720. case BREAKPOINT_A >> 3:
  721. val = A;
  722. break;
  723. case BREAKPOINT_X >> 3:
  724. val = X;
  725. break;
  726. case BREAKPOINT_Y >> 3:
  727. val = Y;
  728. break;
  729. case BREAKPOINT_S >> 3:
  730. val = S;
  731. break;
  732. case BREAKPOINT_READ >> 3:
  733. if ((optype & 4) == 0)
  734. goto cond_failed;
  735. val = addr;
  736. break;
  737. case BREAKPOINT_WRITE >> 3:
  738. if ((optype & 8) == 0)
  739. goto cond_failed;
  740. val = addr;
  741. break;
  742. case BREAKPOINT_ACCESS >> 3:
  743. if ((optype & 12) == 0)
  744. goto cond_failed;
  745. val = addr;
  746. break;
  747. default:
  748. /* shouldn't happen */
  749. continue;
  750. }
  751. if ((cond & BREAKPOINT_LESS) != 0 && val < value)
  752. continue;
  753. if ((cond & BREAKPOINT_EQUAL) != 0 && val == value)
  754. continue;
  755. if ((cond & BREAKPOINT_GREATER) != 0 && val > value)
  756. continue;
  757. cond_failed:
  758. ;
  759. }
  760. /* a condition failed */
  761. /* quickly skip AND-connected conditions */
  762. do {
  763. if (++i >= breakpoint_table_size)
  764. goto no_breakpoint;
  765. } while (breakpoint_table[i].condition != BREAKPOINT_OR || !breakpoint_table[i].enabled);
  766. }
  767. /* fire breakpoint */
  768. PC--;
  769. DO_BREAK;
  770. goto breakpoint_return;
  771. no_breakpoint:
  772. ;
  773. }
  774. #endif /* MONITOR_BREAKPOINTS */
  776. #ifndef CYCLES_PER_OPCODE
  777. xpos += cycles[insn];
  778. #endif
  780. #ifdef MONITOR_PROFILE
  781. instruction_count[insn]++;
  782. #endif
  784. #ifdef PREFETCH_CODE
  785. addr = PEEK_CODE_WORD();
  786. #endif
  788. #ifdef NO_GOTO
  789. switch (insn) {
  790. #else
  791. goto *opcode[insn];
  792. #endif
  794. OPCODE(00) /* BRK */
  795. #ifdef MONITOR_BREAK
  796. if (break_brk) {
  797. DO_BREAK;
  798. }
  799. else
  800. #endif
  801. {
  802. PC++;
  803. PHPC;
  804. PHPB1;
  805. SetI;
  806. SET_PC(dGetWordAligned(0xfffe));
  807. INC_RET_NESTING;
  808. }
  809. DONE
  811. OPCODE(01) /* ORA (ab,x) */
  812. INDIRECT_X;
  813. ORA(GetByte(addr));
  814. DONE
  816. OPCODE(03) /* ASO (ab,x) [unofficial - ASL then ORA with Acc] */
  817. INDIRECT_X;
  819. aso:
  820. RMW_GetByte(data, addr);
  821. C = (data & 0x80) ? 1 : 0;
  822. data <<= 1;
  823. PutByte(addr, data);
  824. Z = N = A |= data;
  825. DONE
  827. OPCODE_ALIAS(04) /* NOP ab [unofficial - skip byte] */
  828. OPCODE_ALIAS(44)
  829. OPCODE(64)
  830. PC++;
  831. DONE
  833. OPCODE_ALIAS(14) /* NOP ab,x [unofficial - skip byte] */
  834. OPCODE_ALIAS(34)
  835. OPCODE_ALIAS(54)
  836. OPCODE_ALIAS(74)
  837. OPCODE_ALIAS(d4)
  838. OPCODE(f4)
  839. PC++;
  840. DONE
  842. OPCODE_ALIAS(80) /* NOP #ab [unofficial - skip byte] */
  843. OPCODE_ALIAS(82)
  844. OPCODE_ALIAS(89)
  845. OPCODE_ALIAS(c2)
  846. OPCODE(e2)
  847. PC++;
  848. DONE
  850. OPCODE(05) /* ORA ab */
  851. ZPAGE;
  852. ORA(dGetByte(addr));
  853. DONE
  855. OPCODE(06) /* ASL ab */
  856. ZPAGE;
  857. data = dGetByte(addr);
  858. C = (data & 0x80) ? 1 : 0;
  859. Z = N = data << 1;
  860. dPutByte(addr, Z);
  861. DONE
  863. OPCODE(07) /* ASO ab [unofficial - ASL then ORA with Acc] */
  864. ZPAGE;
  866. aso_zpage:
  867. data = dGetByte(addr);
  868. C = (data & 0x80) ? 1 : 0;
  869. data <<= 1;
  870. dPutByte(addr, data);
  871. Z = N = A |= data;
  872. DONE
  874. OPCODE(08) /* PHP */
  875. PHPB1;
  876. DONE
  878. OPCODE(09) /* ORA #ab */
  879. ORA(IMMEDIATE);
  880. DONE
  882. OPCODE(0a) /* ASL */
  883. C = (A & 0x80) ? 1 : 0;
  884. Z = N = A <<= 1;
  885. DONE
  887. OPCODE_ALIAS(0b) /* ANC #ab [unofficial - AND then copy N to C (Fox) */
  888. OPCODE(2b)
  889. AND(IMMEDIATE);
  890. C = N >= 0x80;
  891. DONE
  893. OPCODE(0c) /* NOP abcd [unofficial - skip word] */
  894. PC += 2;
  895. DONE
  897. OPCODE(0d) /* ORA abcd */
  898. ABSOLUTE;
  899. ORA(GetByte(addr));
  900. DONE
  902. OPCODE(0e) /* ASL abcd */
  903. ABSOLUTE;
  904. RMW_GetByte(data, addr);
  905. C = (data & 0x80) ? 1 : 0;
  906. Z = N = data << 1;
  907. PutByte(addr, Z);
  908. DONE
  910. OPCODE(0f) /* ASO abcd [unofficial - ASL then ORA with Acc] */
  911. ABSOLUTE;
  912. goto aso;
  914. OPCODE(10) /* BPL */
  915. BRANCH(!(N & 0x80))
  917. OPCODE(11) /* ORA (ab),y */
  918. INDIRECT_Y;
  919. NCYCLES_Y;
  920. ORA(GetByte(addr));
  921. DONE
  923. OPCODE(13) /* ASO (ab),y [unofficial - ASL then ORA with Acc] */
  924. INDIRECT_Y;
  925. goto aso;
  927. OPCODE(15) /* ORA ab,x */
  928. ZPAGE_X;
  929. ORA(dGetByte(addr));
  930. DONE
  932. OPCODE(16) /* ASL ab,x */
  933. ZPAGE_X;
  934. data = dGetByte(addr);
  935. C = (data & 0x80) ? 1 : 0;
  936. Z = N = data << 1;
  937. dPutByte(addr, Z);
  938. DONE
  940. OPCODE(17) /* ASO ab,x [unofficial - ASL then ORA with Acc] */
  941. ZPAGE_X;
  942. goto aso_zpage;
  944. OPCODE(18) /* CLC */
  945. C = 0;
  946. DONE
  948. OPCODE(19) /* ORA abcd,y */
  949. ABSOLUTE_Y;
  950. NCYCLES_Y;
  951. ORA(GetByte(addr));
  952. DONE
  954. OPCODE(1b) /* ASO abcd,y [unofficial - ASL then ORA with Acc] */
  955. ABSOLUTE_Y;
  956. goto aso;
  958. OPCODE_ALIAS(1c) /* NOP abcd,x [unofficial - skip word] */
  959. OPCODE_ALIAS(3c)
  960. OPCODE_ALIAS(5c)
  961. OPCODE_ALIAS(7c)
  962. OPCODE_ALIAS(dc)
  963. OPCODE(fc)
  964. if (OP_BYTE + X >= 0x100)
  965. xpos++;
  966. PC += 2;
  967. DONE
  969. OPCODE(1d) /* ORA abcd,x */
  970. ABSOLUTE_X;
  971. NCYCLES_X;
  972. ORA(GetByte(addr));
  973. DONE
  975. OPCODE(1e) /* ASL abcd,x */
  976. ABSOLUTE_X;
  977. RMW_GetByte(data, addr);
  978. C = (data & 0x80) ? 1 : 0;
  979. Z = N = data << 1;
  980. PutByte(addr, Z);
  981. DONE
  983. OPCODE(1f) /* ASO abcd,x [unofficial - ASL then ORA with Acc] */
  984. ABSOLUTE_X;
  985. goto aso;
  987. OPCODE(20) /* JSR abcd */
  988. {
  989. UWORD retaddr = GET_PC() + 1;
  990. #ifdef MONITOR_BREAK
  991. remember_JMP[remember_jmp_curpos] = GET_PC() - 1;
  992. remember_jmp_curpos = (remember_jmp_curpos + 1) % REMEMBER_JMP_STEPS;
  993. ret_nesting++;
  994. #endif
  995. PHW(retaddr);
  996. }
  997. SET_PC(OP_WORD);
  998. DONE
  1000. OPCODE(21) /* AND (ab,x) */
  1001. INDIRECT_X;
  1002. AND(GetByte(addr));
  1003. DONE
  1005. OPCODE(23) /* RLA (ab,x) [unofficial - ROL Mem, then AND with A] */
  1006. INDIRECT_X;
  1008. rla:
  1009. RMW_GetByte(data, addr);
  1010. if (C) {
  1011. C = (data & 0x80) ? 1 : 0;
  1012. data = (data << 1) + 1;
  1013. }
  1014. else {
  1015. C = (data & 0x80) ? 1 : 0;
  1016. data = (data << 1);
  1017. }
  1018. PutByte(addr, data);
  1019. Z = N = A &= data;
  1020. DONE
  1022. OPCODE(24) /* BIT ab */
  1023. ZPAGE;
  1024. N = dGetByte(addr);
  1025. #ifndef NO_V_FLAG_VARIABLE
  1026. V = N & 0x40;
  1027. #else
  1028. regP = (regP & 0xbf) + (N & 0x40);
  1029. #endif
  1030. Z = (A & N);
  1031. DONE
  1033. OPCODE(25) /* AND ab */
  1034. ZPAGE;
  1035. AND(dGetByte(addr));
  1036. DONE
  1038. OPCODE(26) /* ROL ab */
  1039. ZPAGE;
  1040. data = dGetByte(addr);
  1041. Z = N = (data << 1) + C;
  1042. C = (data & 0x80) ? 1 : 0;
  1043. dPutByte(addr, Z);
  1044. DONE
  1046. OPCODE(27) /* RLA ab [unofficial - ROL Mem, then AND with A] */
  1047. ZPAGE;
  1049. rla_zpage:
  1050. data = dGetByte(addr);
  1051. if (C) {
  1052. C = (data & 0x80) ? 1 : 0;
  1053. data = (data << 1) + 1;
  1054. }
  1055. else {
  1056. C = (data & 0x80) ? 1 : 0;
  1057. data = (data << 1);
  1058. }
  1059. dPutByte(addr, data);
  1060. Z = N = A &= data;
  1061. DONE
  1063. OPCODE(28) /* PLP */
  1064. PLP;
  1065. CPUCHECKIRQ;
  1066. DONE
  1068. OPCODE(29) /* AND #ab */
  1069. AND(IMMEDIATE);
  1070. DONE
  1072. OPCODE(2a) /* ROL */
  1073. Z = N = (A << 1) + C;
  1074. C = (A & 0x80) ? 1 : 0;
  1075. A = Z;
  1076. DONE
  1078. OPCODE(2c) /* BIT abcd */
  1079. ABSOLUTE;
  1080. N = GetByte(addr);
  1081. #ifndef NO_V_FLAG_VARIABLE
  1082. V = N & 0x40;
  1083. #else
  1084. regP = (regP & 0xbf) + (N & 0x40);
  1085. #endif
  1086. Z = (A & N);
  1087. DONE
  1089. OPCODE(2d) /* AND abcd */
  1090. ABSOLUTE;
  1091. AND(GetByte(addr));
  1092. DONE
  1094. OPCODE(2e) /* ROL abcd */
  1095. ABSOLUTE;
  1096. RMW_GetByte(data, addr);
  1097. Z = N = (data << 1) + C;
  1098. C = (data & 0x80) ? 1 : 0;
  1099. PutByte(addr, Z);
  1100. DONE
  1102. OPCODE(2f) /* RLA abcd [unofficial - ROL Mem, then AND with A] */
  1103. ABSOLUTE;
  1104. goto rla;
  1106. OPCODE(30) /* BMI */
  1107. BRANCH(N & 0x80)
  1109. OPCODE(31) /* AND (ab),y */
  1110. INDIRECT_Y;
  1111. NCYCLES_Y;
  1112. AND(GetByte(addr));
  1113. DONE
  1115. OPCODE(33) /* RLA (ab),y [unofficial - ROL Mem, then AND with A] */
  1116. INDIRECT_Y;
  1117. goto rla;
  1119. OPCODE(35) /* AND ab,x */
  1120. ZPAGE_X;
  1121. AND(dGetByte(addr));
  1122. DONE
  1124. OPCODE(36) /* ROL ab,x */
  1125. ZPAGE_X;
  1126. data = dGetByte(addr);
  1127. Z = N = (data << 1) + C;
  1128. C = (data & 0x80) ? 1 : 0;
  1129. dPutByte(addr, Z);
  1130. DONE
  1132. OPCODE(37) /* RLA ab,x [unofficial - ROL Mem, then AND with A] */
  1133. ZPAGE_X;
  1134. goto rla_zpage;
  1136. OPCODE(38) /* SEC */
  1137. C = 1;
  1138. DONE
  1140. OPCODE(39) /* AND abcd,y */
  1141. ABSOLUTE_Y;
  1142. NCYCLES_Y;
  1143. AND(GetByte(addr));
  1144. DONE
  1146. OPCODE(3b) /* RLA abcd,y [unofficial - ROL Mem, then AND with A] */
  1147. ABSOLUTE_Y;
  1148. goto rla;
  1150. OPCODE(3d) /* AND abcd,x */
  1151. ABSOLUTE_X;
  1152. NCYCLES_X;
  1153. AND(GetByte(addr));
  1154. DONE
  1156. OPCODE(3e) /* ROL abcd,x */
  1157. ABSOLUTE_X;
  1158. RMW_GetByte(data, addr);
  1159. Z = N = (data << 1) + C;
  1160. C = (data & 0x80) ? 1 : 0;
  1161. PutByte(addr, Z);
  1162. DONE
  1164. OPCODE(3f) /* RLA abcd,x [unofficial - ROL Mem, then AND with A] */
  1165. ABSOLUTE_X;
  1166. goto rla;
  1168. OPCODE(40) /* RTI */
  1169. PLP;
  1170. data = PL;
  1171. SET_PC((PL << 8) + data);
  1172. CPUCHECKIRQ;
  1173. #ifdef MONITOR_BREAK
  1174. if (break_ret && --ret_nesting <= 0)
  1175. break_step = TRUE;
  1176. #endif
  1177. DONE
  1179. OPCODE(41) /* EOR (ab,x) */
  1180. INDIRECT_X;
  1181. EOR(GetByte(addr));
  1182. DONE
  1184. OPCODE(43) /* LSE (ab,x) [unofficial - LSR then EOR result with A] */
  1185. INDIRECT_X;
  1187. lse:
  1188. RMW_GetByte(data, addr);
  1189. C = data & 1;
  1190. data >>= 1;
  1191. PutByte(addr, data);
  1192. Z = N = A ^= data;
  1193. DONE
  1195. OPCODE(45) /* EOR ab */
  1196. ZPAGE;
  1197. EOR(dGetByte(addr));
  1198. DONE
  1200. OPCODE(46) /* LSR ab */
  1201. ZPAGE;
  1202. data = dGetByte(addr);
  1203. C = data & 1;
  1204. Z = data >> 1;
  1205. N = 0;
  1206. dPutByte(addr, Z);
  1207. DONE
  1209. OPCODE(47) /* LSE ab [unofficial - LSR then EOR result with A] */
  1210. ZPAGE;
  1212. lse_zpage:
  1213. data = dGetByte(addr);
  1214. C = data & 1;
  1215. data >>= 1;
  1216. dPutByte(addr, data);
  1217. Z = N = A ^= data;
  1218. DONE
  1220. OPCODE(48) /* PHA */
  1221. PH(A);
  1222. DONE
  1224. OPCODE(49) /* EOR #ab */
  1225. EOR(IMMEDIATE);
  1226. DONE
  1228. OPCODE(4a) /* LSR */
  1229. C = A & 1;
  1230. Z = N = A >>= 1;
  1231. DONE
  1233. OPCODE(4b) /* ALR #ab [unofficial - Acc AND Data, LSR result] */
  1234. data = A & IMMEDIATE;
  1235. C = data & 1;
  1236. Z = N = A = (data >> 1);
  1237. DONE
  1239. OPCODE(4c) /* JMP abcd */
  1240. #ifdef MONITOR_BREAK
  1241. remember_JMP[remember_jmp_curpos] = GET_PC() - 1;
  1242. remember_jmp_curpos = (remember_jmp_curpos + 1) % REMEMBER_JMP_STEPS;
  1243. #endif
  1244. SET_PC(OP_WORD);
  1245. DONE
  1247. OPCODE(4d) /* EOR abcd */
  1248. ABSOLUTE;
  1249. EOR(GetByte(addr));
  1250. DONE
  1252. OPCODE(4e) /* LSR abcd */
  1253. ABSOLUTE;
  1254. RMW_GetByte(data, addr);
  1255. C = data & 1;
  1256. Z = data >> 1;
  1257. N = 0;
  1258. PutByte(addr, Z);
  1259. DONE
  1261. OPCODE(4f) /* LSE abcd [unofficial - LSR then EOR result with A] */
  1262. ABSOLUTE;
  1263. goto lse;
  1265. OPCODE(50) /* BVC */
  1266. #ifndef NO_V_FLAG_VARIABLE
  1267. BRANCH(!V)
  1268. #else
  1269. BRANCH(!(regP & 0x40))
  1270. #endif
  1272. OPCODE(51) /* EOR (ab),y */
  1273. INDIRECT_Y;
  1274. NCYCLES_Y;
  1275. EOR(GetByte(addr));
  1276. DONE
  1278. OPCODE(53) /* LSE (ab),y [unofficial - LSR then EOR result with A] */
  1279. INDIRECT_Y;
  1280. goto lse;
  1282. OPCODE(55) /* EOR ab,x */
  1283. ZPAGE_X;
  1284. EOR(dGetByte(addr));
  1285. DONE
  1287. OPCODE(56) /* LSR ab,x */
  1288. ZPAGE_X;
  1289. data = dGetByte(addr);
  1290. C = data & 1;
  1291. Z = data >> 1;
  1292. N = 0;
  1293. dPutByte(addr, Z);
  1294. DONE
  1296. OPCODE(57) /* LSE ab,x [unofficial - LSR then EOR result with A] */
  1297. ZPAGE_X;
  1298. goto lse_zpage;
  1300. OPCODE(58) /* CLI */
  1301. ClrI;
  1302. CPUCHECKIRQ;
  1303. DONE
  1305. OPCODE(59) /* EOR abcd,y */
  1306. ABSOLUTE_Y;
  1307. NCYCLES_Y;
  1308. EOR(GetByte(addr));
  1309. DONE
  1311. OPCODE(5b) /* LSE abcd,y [unofficial - LSR then EOR result with A] */
  1312. ABSOLUTE_Y;
  1313. goto lse;
  1315. OPCODE(5d) /* EOR abcd,x */
  1316. ABSOLUTE_X;
  1317. NCYCLES_X;
  1318. EOR(GetByte(addr));
  1319. DONE
  1321. OPCODE(5e) /* LSR abcd,x */
  1322. ABSOLUTE_X;
  1323. RMW_GetByte(data, addr);
  1324. C = data & 1;
  1325. Z = data >> 1;
  1326. N = 0;
  1327. PutByte(addr, Z);
  1328. DONE
  1330. OPCODE(5f) /* LSE abcd,x [unofficial - LSR then EOR result with A] */
  1331. ABSOLUTE_X;
  1332. goto lse;
  1334. OPCODE(60) /* RTS */
  1335. data = PL;
  1336. SET_PC((PL << 8) + data + 1);
  1337. #ifdef MONITOR_BREAK
  1338. if (break_ret && --ret_nesting <= 0)
  1339. break_step = TRUE;
  1340. #endif
  1341. if (rts_handler != NULL) {
  1342. rts_handler();
  1343. rts_handler = NULL;
  1344. }
  1345. DONE
  1347. OPCODE(61) /* ADC (ab,x) */
  1348. INDIRECT_X;
  1349. data = GetByte(addr);
  1350. goto adc;
  1352. OPCODE(63) /* RRA (ab,x) [unofficial - ROR Mem, then ADC to Acc] */
  1353. INDIRECT_X;
  1355. rra:
  1356. RMW_GetByte(data, addr);
  1357. if (C) {
  1358. C = data & 1;
  1359. data = (data >> 1) + 0x80;
  1360. }
  1361. else {
  1362. C = data & 1;
  1363. data >>= 1;
  1364. }
  1365. PutByte(addr, data);
  1366. goto adc;
  1368. OPCODE(65) /* ADC ab */
  1369. ZPAGE;
  1370. data = dGetByte(addr);
  1371. goto adc;
  1373. OPCODE(66) /* ROR ab */
  1374. ZPAGE;
  1375. data = dGetByte(addr);
  1376. Z = N = (C << 7) + (data >> 1);
  1377. C = data & 1;
  1378. dPutByte(addr, Z);
  1379. DONE
  1381. OPCODE(67) /* RRA ab [unofficial - ROR Mem, then ADC to Acc] */
  1382. ZPAGE;
  1384. rra_zpage:
  1385. data = dGetByte(addr);
  1386. if (C) {
  1387. C = data & 1;
  1388. data = (data >> 1) + 0x80;
  1389. }
  1390. else {
  1391. C = data & 1;
  1392. data >>= 1;
  1393. }
  1394. dPutByte(addr, data);
  1395. goto adc;
  1397. OPCODE(68) /* PLA */
  1398. Z = N = A = PL;
  1399. DONE
  1401. OPCODE(69) /* ADC #ab */
  1402. data = IMMEDIATE;
  1403. goto adc;
  1405. OPCODE(6a) /* ROR */
  1406. Z = N = (C << 7) + (A >> 1);
  1407. C = A & 1;
  1408. A = Z;
  1409. DONE
  1411. OPCODE(6b) /* ARR #ab [unofficial - Acc AND Data, ROR result] */
  1412. /* It does some 'BCD fixup' if D flag is set */
  1413. /* MPC 05/24/00 */
  1414. data = A & IMMEDIATE;
  1415. if (regP & D_FLAG) {
  1416. UBYTE temp = (data >> 1) + (C << 7);
  1417. Z = N = temp;
  1418. #ifndef NO_V_FLAG_VARIABLE
  1419. V = ((temp ^ data) & 0x40);
  1420. #else
  1421. regP = (regP & 0xbf) + ((temp ^ data) & 0x40);
  1422. #endif
  1423. if ((data & 0x0F) + (data & 0x01) > 5)
  1424. temp = (temp & 0xF0) + ((temp + 0x6) & 0x0F);
  1425. if (data + (data & 0x10) >= 0x60) {
  1426. temp += 0x60;
  1427. C = 1;
  1428. }
  1429. else
  1430. C = 0;
  1431. A = (UBYTE) temp;
  1432. }
  1433. else {
  1434. Z = N = A = (data >> 1) + (C << 7);
  1435. C = data >> 7;
  1436. #ifndef NO_V_FLAG_VARIABLE
  1437. V = C ^ ((A >> 5) & 1);
  1438. #else
  1439. regP = (regP & 0xbf) + ((A ^ data) & 0x40);
  1440. #endif
  1441. }
  1442. DONE
  1444. OPCODE(6c) /* JMP (abcd) */
  1445. #ifdef MONITOR_BREAK
  1446. remember_JMP[remember_jmp_curpos] = GET_PC() - 1;
  1447. remember_jmp_curpos = (remember_jmp_curpos + 1) % REMEMBER_JMP_STEPS;
  1448. #endif
  1449. ABSOLUTE;
  1450. #ifdef CPU65C02
  1451. /* XXX: if ((UBYTE) addr == 0xff) xpos++; */
  1452. SET_PC(dGetWord(addr));
  1453. #else
  1454. /* original 6502 had a bug in JMP (addr) when addr crossed page boundary */
  1455. if ((UBYTE) addr == 0xff)
  1456. SET_PC((dGetByte(addr - 0xff) << 8) + dGetByte(addr));
  1457. else
  1458. SET_PC(dGetWord(addr));
  1459. #endif
  1460. DONE
  1462. OPCODE(6d) /* ADC abcd */
  1463. ABSOLUTE;
  1464. data = GetByte(addr);
  1465. goto adc;
  1467. OPCODE(6e) /* ROR abcd */
  1468. ABSOLUTE;
  1469. RMW_GetByte(data, addr);
  1470. Z = N = (C << 7) + (data >> 1);
  1471. C = data & 1;
  1472. PutByte(addr, Z);
  1473. DONE
  1475. OPCODE(6f) /* RRA abcd [unofficial - ROR Mem, then ADC to Acc] */
  1476. ABSOLUTE;
  1477. goto rra;
  1479. OPCODE(70) /* BVS */
  1480. #ifndef NO_V_FLAG_VARIABLE
  1481. BRANCH(V)
  1482. #else
  1483. BRANCH(regP & 0x40)
  1484. #endif
  1486. OPCODE(71) /* ADC (ab),y */
  1487. INDIRECT_Y;
  1488. NCYCLES_Y;
  1489. data = GetByte(addr);
  1490. goto adc;
  1492. OPCODE(73) /* RRA (ab),y [unofficial - ROR Mem, then ADC to Acc] */
  1493. INDIRECT_Y;
  1494. goto rra;
  1496. OPCODE(75) /* ADC ab,x */
  1497. ZPAGE_X;
  1498. data = dGetByte(addr);
  1499. goto adc;
  1501. OPCODE(76) /* ROR ab,x */
  1502. ZPAGE_X;
  1503. data = dGetByte(addr);
  1504. Z = N = (C << 7) + (data >> 1);
  1505. C = data & 1;
  1506. dPutByte(addr, Z);
  1507. DONE
  1509. OPCODE(77) /* RRA ab,x [unofficial - ROR Mem, then ADC to Acc] */
  1510. ZPAGE_X;
  1511. goto rra_zpage;
  1513. OPCODE(78) /* SEI */
  1514. SetI;
  1515. DONE
  1517. OPCODE(79) /* ADC abcd,y */
  1518. ABSOLUTE_Y;
  1519. NCYCLES_Y;
  1520. data = GetByte(addr);
  1521. goto adc;
  1523. OPCODE(7b) /* RRA abcd,y [unofficial - ROR Mem, then ADC to Acc] */
  1524. ABSOLUTE_Y;
  1525. goto rra;
  1527. OPCODE(7d) /* ADC abcd,x */
  1528. ABSOLUTE_X;
  1529. NCYCLES_X;
  1530. data = GetByte(addr);
  1531. goto adc;
  1533. OPCODE(7e) /* ROR abcd,x */
  1534. ABSOLUTE_X;
  1535. RMW_GetByte(data, addr);
  1536. Z = N = (C << 7) + (data >> 1);
  1537. C = data & 1;
  1538. PutByte(addr, Z);
  1539. DONE
  1541. OPCODE(7f) /* RRA abcd,x [unofficial - ROR Mem, then ADC to Acc] */
  1542. ABSOLUTE_X;
  1543. goto rra;
  1545. OPCODE(81) /* STA (ab,x) */
  1546. INDIRECT_X;
  1547. PutByte(addr, A);
  1548. DONE
  1550. /* AXS doesn't change flags and SAX is better name for it (Fox) */
  1551. OPCODE(83) /* SAX (ab,x) [unofficial - Store result A AND X */
  1552. INDIRECT_X;
  1553. data = A & X;
  1554. PutByte(addr, data);
  1555. DONE
  1557. OPCODE(84) /* STY ab */
  1558. ZPAGE;
  1559. dPutByte(addr, Y);
  1560. DONE
  1562. OPCODE(85) /* STA ab */
  1563. ZPAGE;
  1564. dPutByte(addr, A);
  1565. DONE
  1567. OPCODE(86) /* STX ab */
  1568. ZPAGE;
  1569. dPutByte(addr, X);
  1570. DONE
  1572. OPCODE(87) /* SAX ab [unofficial - Store result A AND X] */
  1573. ZPAGE;
  1574. data = A & X;
  1575. dPutByte(addr, data);
  1576. DONE
  1578. OPCODE(88) /* DEY */
  1579. Z = N = --Y;
  1580. DONE
  1582. OPCODE(8a) /* TXA */
  1583. Z = N = A = X;
  1584. DONE
  1586. OPCODE(8b) /* ANE #ab [unofficial - A AND X AND (Mem OR $EF) to Acc] (Fox) */
  1587. data = IMMEDIATE;
  1588. N = Z = A & X & data;
  1589. A &= X & (data | 0xef);
  1590. DONE
  1592. OPCODE(8c) /* STY abcd */
  1593. ABSOLUTE;
  1594. PutByte(addr, Y);
  1595. DONE
  1597. OPCODE(8d) /* STA abcd */
  1598. ABSOLUTE;
  1599. PutByte(addr, A);
  1600. DONE
  1602. OPCODE(8e) /* STX abcd */
  1603. ABSOLUTE;
  1604. PutByte(addr, X);
  1605. DONE
  1607. OPCODE(8f) /* SAX abcd [unofficial - Store result A AND X] */
  1608. ABSOLUTE;
  1609. data = A & X;
  1610. PutByte(addr, data);
  1611. DONE
  1613. OPCODE(90) /* BCC */
  1614. BRANCH(!C)
  1616. OPCODE(91) /* STA (ab),y */
  1617. INDIRECT_Y;
  1618. PutByte(addr, A);
  1619. DONE
  1621. OPCODE(93) /* SHA (ab),y [unofficial, UNSTABLE - Store A AND X AND (H+1) ?] (Fox) */
  1622. /* It seems previous memory value is important - also in 9f */
  1623. ZPAGE;
  1624. data = dGetByte((UBYTE) (addr + 1)); /* Get high byte from zpage */
  1625. data = A & X & (data + 1);
  1626. addr = dGetWord(addr) + Y;
  1627. PutByte(addr, data);
  1628. DONE
  1630. OPCODE(94) /* STY ab,x */
  1631. ZPAGE_X;
  1632. dPutByte(addr, Y);
  1633. DONE
  1635. OPCODE(95) /* STA ab,x */
  1636. ZPAGE_X;
  1637. dPutByte(addr, A);
  1638. DONE
  1640. OPCODE(96) /* STX ab,y */
  1641. ZPAGE_Y;
  1642. PutByte(addr, X);
  1643. DONE
  1645. OPCODE(97) /* SAX ab,y [unofficial - Store result A AND X] */
  1646. ZPAGE_Y;
  1647. data = A & X;
  1648. dPutByte(addr, data);
  1649. DONE
  1651. OPCODE(98) /* TYA */
  1652. Z = N = A = Y;
  1653. DONE
  1655. OPCODE(99) /* STA abcd,y */
  1656. ABSOLUTE_Y;
  1657. PutByte(addr, A);
  1658. DONE
  1660. OPCODE(9a) /* TXS */
  1661. S = X;
  1662. DONE
  1664. OPCODE(9b) /* SHS abcd,y [unofficial, UNSTABLE] (Fox) */
  1665. /* Transfer A AND X to S, then store S AND (H+1)] */
  1666. /* S seems to be stable, only memory values vary */
  1667. ABSOLUTE;
  1668. S = A & X;
  1669. data = S & ((addr >> 8) + 1);
  1670. addr += Y;
  1671. PutByte(addr, data);
  1672. DONE
  1674. OPCODE(9c) /* SHY abcd,x [unofficial - Store Y and (H+1)] (Fox) */
  1675. /* Seems to be stable */
  1676. ABSOLUTE;
  1677. /* MPC 05/24/00 */
  1678. data = Y & ((UBYTE) ((addr >> 8) + 1));
  1679. addr += X;
  1680. PutByte(addr, data);
  1681. DONE
  1683. OPCODE(9d) /* STA abcd,x */
  1684. ABSOLUTE_X;
  1685. PutByte(addr, A);
  1686. DONE
  1688. OPCODE(9e) /* SHX abcd,y [unofficial - Store X and (H+1)] (Fox) */
  1689. /* Seems to be stable */
  1690. ABSOLUTE;
  1691. /* MPC 05/24/00 */
  1692. data = X & ((UBYTE) ((addr >> 8) + 1));
  1693. addr += Y;
  1694. PutByte(addr, data);
  1695. DONE
  1697. OPCODE(9f) /* SHA abcd,y [unofficial, UNSTABLE - Store A AND X AND (H+1) ?] (Fox) */
  1698. ABSOLUTE;
  1699. data = A & X & ((addr >> 8) + 1);
  1700. addr += Y;
  1701. PutByte(addr, data);
  1702. DONE
  1704. OPCODE(a0) /* LDY #ab */
  1705. LDY(IMMEDIATE);
  1706. DONE
  1708. OPCODE(a1) /* LDA (ab,x) */
  1709. INDIRECT_X;
  1710. LDA(GetByte(addr));
  1711. DONE
  1713. OPCODE(a2) /* LDX #ab */
  1714. LDX(IMMEDIATE);
  1715. DONE
  1717. OPCODE(a3) /* LAX (ab,x) [unofficial] */
  1718. INDIRECT_X;
  1719. Z = N = X = A = GetByte(addr);
  1720. DONE
  1722. OPCODE(a4) /* LDY ab */
  1723. ZPAGE;
  1724. LDY(dGetByte(addr));
  1725. DONE
  1727. OPCODE(a5) /* LDA ab */
  1728. ZPAGE;
  1729. LDA(dGetByte(addr));
  1730. DONE
  1732. OPCODE(a6) /* LDX ab */
  1733. ZPAGE;
  1734. LDX(dGetByte(addr));
  1735. DONE
  1737. OPCODE(a7) /* LAX ab [unofficial] */
  1738. ZPAGE;
  1739. Z = N = X = A = GetByte(addr);
  1740. DONE
  1742. OPCODE(a8) /* TAY */
  1743. Z = N = Y = A;
  1744. DONE
  1746. OPCODE(a9) /* LDA #ab */
  1747. LDA(IMMEDIATE);
  1748. DONE
  1750. OPCODE(aa) /* TAX */
  1751. Z = N = X = A;
  1752. DONE
  1754. OPCODE(ab) /* ANX #ab [unofficial - AND #ab, then TAX] */
  1755. Z = N = X = A &= IMMEDIATE;
  1756. DONE
  1758. OPCODE(ac) /* LDY abcd */
  1759. ABSOLUTE;
  1760. LDY(GetByte(addr));
  1761. DONE
  1763. OPCODE(ad) /* LDA abcd */
  1764. ABSOLUTE;
  1765. LDA(GetByte(addr));
  1766. DONE
  1768. OPCODE(ae) /* LDX abcd */
  1769. ABSOLUTE;
  1770. LDX(GetByte(addr));
  1771. DONE
  1773. OPCODE(af) /* LAX abcd [unofficial] */
  1774. ABSOLUTE;
  1775. Z = N = X = A = GetByte(addr);
  1776. DONE
  1778. OPCODE(b0) /* BCS */
  1779. BRANCH(C)
  1781. OPCODE(b1) /* LDA (ab),y */
  1782. INDIRECT_Y;
  1783. NCYCLES_Y;
  1784. LDA(GetByte(addr));
  1785. DONE
  1787. OPCODE(b3) /* LAX (ab),y [unofficial] */
  1788. INDIRECT_Y;
  1789. NCYCLES_Y;
  1790. Z = N = X = A = GetByte(addr);
  1791. DONE
  1793. OPCODE(b4) /* LDY ab,x */
  1794. ZPAGE_X;
  1795. LDY(dGetByte(addr));
  1796. DONE
  1798. OPCODE(b5) /* LDA ab,x */
  1799. ZPAGE_X;
  1800. LDA(dGetByte(addr));
  1801. DONE
  1803. OPCODE(b6) /* LDX ab,y */
  1804. ZPAGE_Y;
  1805. LDX(GetByte(addr));
  1806. DONE
  1808. OPCODE(b7) /* LAX ab,y [unofficial] */
  1809. ZPAGE_Y;
  1810. Z = N = X = A = GetByte(addr);
  1811. DONE
  1813. OPCODE(b8) /* CLV */
  1814. #ifndef NO_V_FLAG_VARIABLE
  1815. V = 0;
  1816. #else
  1817. ClrV;
  1818. #endif
  1819. DONE
  1821. OPCODE(b9) /* LDA abcd,y */
  1822. ABSOLUTE_Y;
  1823. NCYCLES_Y;
  1824. LDA(GetByte(addr));
  1825. DONE
  1827. OPCODE(ba) /* TSX */
  1828. Z = N = X = S;
  1829. DONE
  1831. /* AXA [unofficial - original decode by R.Sterba and R.Petruzela 15.1.1998 :-)]
  1832.    AXA - this is our new imaginative name for instruction with opcode hex BB.
  1833.    AXA - Store Mem AND #$FD to Acc and X, then set stackpoint to value (Acc - 4)
  1834.    It's cool! :-)
  1835.    LAS - this is better name for this :) (Fox)
  1836.    It simply ANDs stack pointer with Mem, then transfers result to A and X
  1837.  */
  1839. OPCODE(bb) /* LAS abcd,y [unofficial - AND S with Mem, transfer to A and X (Fox) */
  1840. ABSOLUTE_Y;
  1841. NCYCLES_Y;
  1842. Z = N = A = X = S &= GetByte(addr);
  1843. DONE
  1845. OPCODE(bc) /* LDY abcd,x */
  1846. ABSOLUTE_X;
  1847. NCYCLES_X;
  1848. LDY(GetByte(addr));
  1849. DONE
  1851. OPCODE(bd) /* LDA abcd,x */
  1852. ABSOLUTE_X;
  1853. NCYCLES_X;
  1854. LDA(GetByte(addr));
  1855. DONE
  1857. OPCODE(be) /* LDX abcd,y */
  1858. ABSOLUTE_Y;
  1859. NCYCLES_Y;
  1860. LDX(GetByte(addr));
  1861. DONE
  1863. OPCODE(bf) /* LAX abcd,y [unofficial] */
  1864. ABSOLUTE_Y;
  1865. NCYCLES_Y;
  1866. Z = N = X = A = GetByte(addr);
  1867. DONE
  1869. OPCODE(c0) /* CPY #ab */
  1870. CPY(IMMEDIATE);
  1871. DONE
  1873. OPCODE(c1) /* CMP (ab,x) */
  1874. INDIRECT_X;
  1875. CMP(GetByte(addr));
  1876. DONE
  1878. OPCODE(c3) /* DCM (ab,x) [unofficial - DEC Mem then CMP with Acc] */
  1879. INDIRECT_X;
  1881. dcm:
  1882. RMW_GetByte(data, addr);
  1883. data--;
  1884. PutByte(addr, data);
  1885. CMP(data);
  1886. DONE
  1888. OPCODE(c4) /* CPY ab */
  1889. ZPAGE;
  1890. CPY(dGetByte(addr));
  1891. DONE
  1893. OPCODE(c5) /* CMP ab */
  1894. ZPAGE;
  1895. CMP(dGetByte(addr));
  1896. DONE
  1898. OPCODE(c6) /* DEC ab */
  1899. ZPAGE;
  1900. Z = N = dGetByte(addr) - 1;
  1901. dPutByte(addr, Z);
  1902. DONE
  1904. OPCODE(c7) /* DCM ab [unofficial - DEC Mem then CMP with Acc] */
  1905. ZPAGE;
  1907. dcm_zpage:
  1908. data = dGetByte(addr) - 1;
  1909. dPutByte(addr, data);
  1910. CMP(data);
  1911. DONE
  1913. OPCODE(c8) /* INY */
  1914. Z = N = ++Y;
  1915. DONE
  1917. OPCODE(c9) /* CMP #ab */
  1918. CMP(IMMEDIATE);
  1919. DONE
  1921. OPCODE(ca) /* DEX */
  1922. Z = N = --X;
  1923. DONE
  1925. OPCODE(cb) /* SBX #ab [unofficial - store ((A AND X) - Mem) in X] (Fox) */
  1926. X &= A;
  1927. data = IMMEDIATE;
  1928. C = X >= data;
  1929. /* MPC 05/24/00 */
  1930. Z = N = X -= data;
  1931. DONE
  1933. OPCODE(cc) /* CPY abcd */
  1934. ABSOLUTE;
  1935. CPY(GetByte(addr));
  1936. DONE
  1938. OPCODE(cd) /* CMP abcd */
  1939. ABSOLUTE;
  1940. CMP(GetByte(addr));
  1941. DONE
  1943. OPCODE(ce) /* DEC abcd */
  1944. ABSOLUTE;
  1945. RMW_GetByte(Z, addr);
  1946. N = --Z;
  1947. PutByte(addr, Z);
  1948. DONE
  1950. OPCODE(cf) /* DCM abcd [unofficial - DEC Mem then CMP with Acc] */
  1951. ABSOLUTE;
  1952. goto dcm;
  1954. OPCODE(d0) /* BNE */
  1955. BRANCH(Z)
  1957. OPCODE(d1) /* CMP (ab),y */
  1958. INDIRECT_Y;
  1959. NCYCLES_Y;
  1960. CMP(GetByte(addr));
  1961. DONE
  1963. OPCODE(d3) /* DCM (ab),y [unofficial - DEC Mem then CMP with Acc] */
  1964. INDIRECT_Y;
  1965. goto dcm;
  1967. OPCODE(d5) /* CMP ab,x */
  1968. ZPAGE_X;
  1969. CMP(dGetByte(addr));
  1970. Z = N = A - data;
  1971. C = (A >= data);
  1972. DONE
  1974. OPCODE(d6) /* DEC ab,x */
  1975. ZPAGE_X;
  1976. Z = N = dGetByte(addr) - 1;
  1977. dPutByte(addr, Z);
  1978. DONE
  1980. OPCODE(d7) /* DCM ab,x [unofficial - DEC Mem then CMP with Acc] */
  1981. ZPAGE_X;
  1982. goto dcm_zpage;
  1984. OPCODE(d8) /* CLD */
  1985. ClrD;
  1986. DONE
  1988. OPCODE(d9) /* CMP abcd,y */
  1989. ABSOLUTE_Y;
  1990. NCYCLES_Y;
  1991. CMP(GetByte(addr));
  1992. DONE
  1994. OPCODE(db) /* DCM abcd,y [unofficial - DEC Mem then CMP with Acc] */
  1995. ABSOLUTE_Y;
  1996. goto dcm;
  1998. OPCODE(dd) /* CMP abcd,x */
  1999. ABSOLUTE_X;
  2000. NCYCLES_X;
  2001. CMP(GetByte(addr));
  2002. DONE
  2004. OPCODE(de) /* DEC abcd,x */
  2005. ABSOLUTE_X;
  2006. RMW_GetByte(Z, addr);
  2007. N = --Z;
  2008. PutByte(addr, Z);
  2009. DONE
  2011. OPCODE(df) /* DCM abcd,x [unofficial - DEC Mem then CMP with Acc] */
  2012. ABSOLUTE_X;
  2013. goto dcm;
  2015. OPCODE(e0) /* CPX #ab */
  2016. CPX(IMMEDIATE);
  2017. DONE
  2019. OPCODE(e1) /* SBC (ab,x) */
  2020. INDIRECT_X;
  2021. data = GetByte(addr);
  2022. goto sbc;
  2024. OPCODE(e3) /* INS (ab,x) [unofficial - INC Mem then SBC with Acc] */
  2025. INDIRECT_X;
  2027. ins:
  2028. RMW_GetByte(data, addr);
  2029. ++data;
  2030. PutByte(addr, data);
  2031. goto sbc;
  2033. OPCODE(e4) /* CPX ab */
  2034. ZPAGE;
  2035. CPX(dGetByte(addr));
  2036. DONE
  2038. OPCODE(e5) /* SBC ab */
  2039. ZPAGE;
  2040. data = dGetByte(addr);
  2041. goto sbc;
  2043. OPCODE(e6) /* INC ab */
  2044. ZPAGE;
  2045. Z = N = dGetByte(addr) + 1;
  2046. dPutByte(addr, Z);
  2047. DONE
  2049. OPCODE(e7) /* INS ab [unofficial - INC Mem then SBC with Acc] */
  2050. ZPAGE;
  2052. ins_zpage:
  2053. data = dGetByte(addr) + 1;
  2054. dPutByte(addr, data);
  2055. goto sbc;
  2057. OPCODE(e8) /* INX */
  2058. Z = N = ++X;
  2059. DONE
  2061. OPCODE_ALIAS(e9) /* SBC #ab */
  2062. OPCODE(eb) /* SBC #ab [unofficial] */
  2063. data = IMMEDIATE;
  2064. goto sbc;
  2066. OPCODE_ALIAS(ea) /* NOP */
  2067. OPCODE_ALIAS(1a) /* NOP [unofficial] */
  2068. OPCODE_ALIAS(3a)
  2069. OPCODE_ALIAS(5a)
  2070. OPCODE_ALIAS(7a)
  2071. OPCODE_ALIAS(da)
  2072. OPCODE(fa)
  2073. DONE
  2075. OPCODE(ec) /* CPX abcd */
  2076. ABSOLUTE;
  2077. CPX(GetByte(addr));
  2078. DONE
  2080. OPCODE(ed) /* SBC abcd */
  2081. ABSOLUTE;
  2082. data = GetByte(addr);
  2083. goto sbc;
  2085. OPCODE(ee) /* INC abcd */
  2086. ABSOLUTE;
  2087. RMW_GetByte(Z, addr);
  2088. N = ++Z;
  2089. PutByte(addr, Z);
  2090. DONE
  2092. OPCODE(ef) /* INS abcd [unofficial - INC Mem then SBC with Acc] */
  2093. ABSOLUTE;
  2094. goto ins;
  2096. OPCODE(f0) /* BEQ */
  2097. BRANCH(!Z)
  2099. OPCODE(f1) /* SBC (ab),y */
  2100. INDIRECT_Y;
  2101. NCYCLES_Y;
  2102. data = GetByte(addr);
  2103. goto sbc;
  2105. OPCODE(f3) /* INS (ab),y [unofficial - INC Mem then SBC with Acc] */
  2106. INDIRECT_Y;
  2107. goto ins;
  2109. OPCODE(f5) /* SBC ab,x */
  2110. ZPAGE_X;
  2111. data = dGetByte(addr);
  2112. goto sbc;
  2114. OPCODE(f6) /* INC ab,x */
  2115. ZPAGE_X;
  2116. Z = N = dGetByte(addr) + 1;
  2117. dPutByte(addr, Z);
  2118. DONE
  2120. OPCODE(f7) /* INS ab,x [unofficial - INC Mem then SBC with Acc] */
  2121. ZPAGE_X;
  2122. goto ins_zpage;
  2124. OPCODE(f8) /* SED */
  2125. SetD;
  2126. DONE
  2128. OPCODE(f9) /* SBC abcd,y */
  2129. ABSOLUTE_Y;
  2130. NCYCLES_Y;
  2131. data = GetByte(addr);
  2132. goto sbc;
  2134. OPCODE(fb) /* INS abcd,y [unofficial - INC Mem then SBC with Acc] */
  2135. ABSOLUTE_Y;
  2136. goto ins;
  2138. OPCODE(fd) /* SBC abcd,x */
  2139. ABSOLUTE_X;
  2140. NCYCLES_X;
  2141. data = GetByte(addr);
  2142. goto sbc;
  2144. OPCODE(fe) /* INC abcd,x */
  2145. ABSOLUTE_X;
  2146. RMW_GetByte(Z, addr);
  2147. N = ++Z;
  2148. PutByte(addr, Z);
  2149. DONE
  2151. OPCODE(ff) /* INS abcd,x [unofficial - INC Mem then SBC with Acc] */
  2152. ABSOLUTE_X;
  2153. goto ins;
  2155. #ifdef ASAP
  2157. OPCODE_ALIAS(d2)
  2158. OPCODE_ALIAS(f2)
  2160. #else
  2162. OPCODE(d2) /* ESCRTS #ab (CIM) - on Atari is here instruction CIM [unofficial] !RS! */
  2163. data = IMMEDIATE;
  2164. UPDATE_GLOBAL_REGS;
  2165. CPU_GetStatus();
  2166. Atari800_RunEsc(data);
  2167. CPU_PutStatus();
  2168. UPDATE_LOCAL_REGS;
  2169. data = PL;
  2170. SET_PC((PL << 8) + data + 1);
  2171. #ifdef MONITOR_BREAK
  2172. if (break_ret && --ret_nesting <= 0)
  2173. break_step = TRUE;
  2174. #endif
  2175. DONE
  2177. OPCODE(f2) /* ESC #ab (CIM) - on Atari is here instruction CIM [unofficial] !RS! */
  2178. /* OPCODE(ff: ESC #ab - opcode FF is now used for INS [unofficial] instruction !RS! */
  2179. data = IMMEDIATE;
  2180. UPDATE_GLOBAL_REGS;
  2181. CPU_GetStatus();
  2182. Atari800_RunEsc(data);
  2183. CPU_PutStatus();
  2184. UPDATE_LOCAL_REGS;
  2185. DONE
  2187. #endif /* ASAP */
  2189. OPCODE_ALIAS(02) /* CIM [unofficial - crash intermediate] */
  2190. OPCODE_ALIAS(12)
  2191. OPCODE_ALIAS(22)
  2192. OPCODE_ALIAS(32)
  2193. OPCODE_ALIAS(42)
  2194. OPCODE_ALIAS(52)
  2195. OPCODE_ALIAS(62)
  2196. OPCODE_ALIAS(72)
  2197. OPCODE_ALIAS(92)
  2198. OPCODE(b2)
  2200. #ifdef ASAP
  2202. ASAP_CIM();
  2203. DONE
  2205. #else
  2207. /* OPCODE(d2) Used for ESCRTS #ab (CIM) */
  2208. /* OPCODE(f2) Used for ESC #ab (CIM) */
  2209. PC--;
  2210. UPDATE_GLOBAL_REGS;
  2211. CPU_GetStatus();
  2213. #ifdef CRASH_MENU
  2214. crash_address = GET_PC();
  2215. crash_afterCIM = GET_PC() + 1;
  2216. crash_code = insn;
  2217. ui();
  2218. #else
  2219. cim_encountered = TRUE;
  2220. ENTER_MONITOR;
  2221. #endif /* CRASH_MENU */
  2223. CPU_PutStatus();
  2224. UPDATE_LOCAL_REGS;
  2225. DONE
  2227. #endif /* ASAP */
  2229. /* ---------------------------------------------- */
  2230. /* ADC and SBC routines */
  2232. adc:
  2233. if (!(regP & D_FLAG)) {
  2234. /* Binary mode */
  2235. unsigned int tmp;
  2236. tmp = A + data + C;
  2237. C = tmp > 0xff;
  2238. /* C = tmp >> 8; */
  2239. #ifndef NO_V_FLAG_VARIABLE
  2240. V = !((A ^ data) & 0x80) && ((data ^ tmp) & 0x80);
  2241. #else
  2242. ClrV;
  2243. if (!((A ^ data) & 0x80) && ((data ^ tmp) & 0x80))
  2244. SetV;
  2245. #endif
  2246. Z = N = A = (UBYTE) tmp;
  2247.     }
  2248. else {
  2249. /* Decimal mode */
  2250. unsigned int tmp;
  2251. tmp = (A & 0x0f) + (data & 0x0f) + C;
  2252. if (tmp >= 10)
  2253. tmp = (tmp - 10) | 0x10;
  2254. tmp += (A & 0xf0) + (data & 0xf0);
  2256. Z = A + data + C;
  2257. N = (UBYTE) tmp;
  2258. #ifndef NO_V_FLAG_VARIABLE
  2259. V = !((A ^ data) & 0x80) && ((data ^ tmp) & 0x80);
  2260. #else
  2261. ClrV;
  2262. if (!((A ^ data) & 0x80) && ((data ^ tmp) & 0x80))
  2263. SetV;
  2264. #endif
  2266. if (tmp > 0x9f)
  2267. tmp += 0x60;
  2268. C = tmp > 0xff;
  2269. A = (UBYTE) tmp;
  2270. }
  2271. DONE
  2273. sbc:
  2274. if (!(regP & D_FLAG)) {
  2275. /* Binary mode */
  2276. unsigned int tmp;
  2277. /* tmp = A - data - !C; */
  2278. tmp = A - data - 1 + C;
  2279. C = tmp < 0x100;
  2280. #ifndef NO_V_FLAG_VARIABLE
  2281. V = ((A ^ tmp) & 0x80) && ((A ^ data) & 0x80);
  2282. #else
  2283. ClrV;
  2284. if (((A ^ tmp) & 0x80) && ((A ^ data) & 0x80))
  2285. SetV;
  2286. #endif
  2287. Z = N = A = (UBYTE) tmp;
  2288. }
  2289. else {
  2290. /* Decimal mode */
  2291. unsigned int al, ah, tmp;
  2292. /* tmp = A - data - !C; */
  2293. tmp = A - data - 1 + C;
  2294. /* al = (A & 0x0f) - (data & 0x0f) - !C; */
  2295. al = (A & 0x0f) - (data & 0x0f) - 1 + C; /* Calculate lower nybble */
  2296. ah = (A >> 4) - (data >> 4); /* Calculate upper nybble */
  2297. if (al & 0x10) {
  2298. al -= 6; /* BCD fixup for lower nybble */
  2299. ah--;
  2300. }
  2301. if (ah & 0x10)
  2302. ah -= 6; /* BCD fixup for upper nybble */
  2304. C = tmp < 0x100; /* Set flags */
  2305. #ifndef NO_V_FLAG_VARIABLE
  2306. V = ((A ^ tmp) & 0x80) && ((A ^ data) & 0x80);
  2307. #else
  2308. ClrV;
  2309. if (((A ^ tmp) & 0x80) && ((A ^ data) & 0x80))
  2310. SetV;
  2311. #endif
  2312. Z = N = (UBYTE) tmp;
  2314. A = (ah << 4) + (al & 0x0f); /* Compose result */
  2315. }
  2316. DONE
  2318. #ifdef NO_GOTO
  2319. }
  2320. #else
  2321. next:
  2322. #endif
  2324. #ifdef MONITOR_BREAK
  2325. if (break_step) {
  2326. DO_BREAK;
  2327. }
  2328. #endif
  2329. /* This "continue" does nothing here.
  2330.    But it is necessary because, if we're not using NO_GOTO nor MONITOR_BREAK,
  2331.    gcc can complain: "error: label at end of compound statement". */
  2332. continue;
  2333. }
  2335. UPDATE_GLOBAL_REGS;
  2336. }
  2338. void CPU_Initialise(void)
  2339. {
  2340. }
  2342. #endif /* FALCON_CPUASM */
  2344. void CPU_Reset(void)
  2345. {
  2346. #ifdef MONITOR_PROFILE
  2347. memset(instruction_count, 0, sizeof(instruction_count));
  2348. #endif
  2350. IRQ = 0;
  2352. regP = 0x34; /* The unused bit is always 1, I flag set! */
  2353. CPU_PutStatus(); /* Make sure flags are all updated */
  2354. regS = 0xff;
  2355. regPC = dGetWordAligned(0xfffc);
  2356. }
  2358. #if !defined(BASIC) && !defined(ASAP)
  2360. void CpuStateSave(UBYTE SaveVerbose)
  2361. {
  2362. SaveUBYTE(&regA, 1);
  2364. CPU_GetStatus(); /* Make sure flags are all updated */
  2365. SaveUBYTE(&regP, 1);
  2367. SaveUBYTE(&regS, 1);
  2368. SaveUBYTE(&regX, 1);
  2369. SaveUBYTE(&regY, 1);
  2370. SaveUBYTE(&IRQ, 1);
  2372. MemStateSave(SaveVerbose);
  2374. SaveUWORD(&regPC, 1);
  2375. }
  2377. void CpuStateRead(UBYTE SaveVerbose)
  2378. {
  2379. ReadUBYTE(&regA, 1);
  2381. ReadUBYTE(&regP, 1);
  2382. CPU_PutStatus(); /* Make sure flags are all updated */
  2384. ReadUBYTE(&regS, 1);
  2385. ReadUBYTE(&regX, 1);
  2386. ReadUBYTE(&regY, 1);
  2387. ReadUBYTE(&IRQ, 1);
  2389. MemStateRead( SaveVerbose );
  2391. ReadUWORD(&regPC, 1);
  2392. }
  2394. #endif