cz80.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485
  1. /******************************************************************************
  2. *
  3. * CZ80 (Z80 CPU emulator) version 0.9
  4. * Compiled with Dev-C++
  5. * Copyright 2004-2005 St駱hane Dallongeville
  6. *
  7. * (Modified by NJ)
  8. *
  9. *****************************************************************************/
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include "cz80.h"
  14. #if PICODRIVE_HACKS
  15. #include <pico/pico_int.h>
  16. #include <pico/memory.h>
  17. #endif
  18. #ifndef ALIGN_DATA
  19. #ifdef _MSC_VER
  20. #define ALIGN_DATA
  21. #define inline
  22. #undef CZ80_USE_JUMPTABLE
  23. #define CZ80_USE_JUMPTABLE 0
  24. #else
  25. #define ALIGN_DATA __attribute__((aligned(4)))
  26. #endif
  27. #endif
  28. #define CF 0x01
  29. #define NF 0x02
  30. #define PF 0x04
  31. #define VF PF
  32. #define XF 0x08
  33. #define HF 0x10
  34. #define YF 0x20
  35. #define ZF 0x40
  36. #define SF 0x80
  37. /******************************************************************************
  38. マクロ
  39. ******************************************************************************/
  40. #include "cz80macro.h"
  41. /******************************************************************************
  42. グローバル構造体
  43. ******************************************************************************/
  44. cz80_struc ALIGN_DATA CZ80;
  45. /******************************************************************************
  46. ローカル変数
  47. ******************************************************************************/
  48. static UINT8 ALIGN_DATA cz80_bad_address[1 << CZ80_FETCH_SFT];
  49. static UINT8 ALIGN_DATA SZ[256];
  50. static UINT8 ALIGN_DATA SZP[256];
  51. static UINT8 ALIGN_DATA SZ_BIT[256];
  52. static UINT8 ALIGN_DATA SZHV_inc[256];
  53. static UINT8 ALIGN_DATA SZHV_dec[256];
  54. #if CZ80_BIG_FLAGS_ARRAY
  55. static UINT8 ALIGN_DATA SZHVC_add[2*256*256];
  56. static UINT8 ALIGN_DATA SZHVC_sub[2*256*256];
  57. #endif
  58. /******************************************************************************
  59. ローカル関数
  60. ******************************************************************************/
  61. /*--------------------------------------------------------
  62. 割り込みコールバック
  63. --------------------------------------------------------*/
  64. static INT32 Cz80_Interrupt_Callback(INT32 line)
  65. {
  66. return 0xff;
  67. }
  68. /******************************************************************************
  69. CZ80インタフェース関数
  70. ******************************************************************************/
  71. /*--------------------------------------------------------
  72. CPU初期化
  73. --------------------------------------------------------*/
  74. void Cz80_Init(cz80_struc *CPU)
  75. {
  76. UINT32 i, j, p;
  77. #if CZ80_BIG_FLAGS_ARRAY
  78. int oldval, newval, val;
  79. UINT8 *padd, *padc, *psub, *psbc;
  80. #endif
  81. memset(CPU, 0, sizeof(cz80_struc));
  82. memset(cz80_bad_address, 0xff, sizeof(cz80_bad_address));
  83. for (i = 0; i < CZ80_FETCH_BANK; i++)
  84. {
  85. CPU->Fetch[i] = (FPTR)cz80_bad_address - (i << CZ80_FETCH_SFT);
  86. #if CZ80_ENCRYPTED_ROM
  87. CPU->OPFetch[i] = 0;
  88. #endif
  89. }
  90. // flags tables initialisation
  91. for (i = 0; i < 256; i++)
  92. {
  93. SZ[i] = i & (SF | YF | XF);
  94. if (!i) SZ[i] |= ZF;
  95. SZ_BIT[i] = i & (SF | YF | XF);
  96. if (!i) SZ_BIT[i] |= ZF | PF;
  97. for (j = 0, p = 0; j < 8; j++) if (i & (1 << j)) p++;
  98. SZP[i] = SZ[i];
  99. if (!(p & 1)) SZP[i] |= PF;
  100. SZHV_inc[i] = SZ[i];
  101. if(i == 0x80) SZHV_inc[i] |= VF;
  102. if((i & 0x0f) == 0x00) SZHV_inc[i] |= HF;
  103. SZHV_dec[i] = SZ[i] | NF;
  104. if (i == 0x7f) SZHV_dec[i] |= VF;
  105. if ((i & 0x0f) == 0x0f) SZHV_dec[i] |= HF;
  106. }
  107. #if CZ80_BIG_FLAGS_ARRAY
  108. padd = &SZHVC_add[ 0*256];
  109. padc = &SZHVC_add[256*256];
  110. psub = &SZHVC_sub[ 0*256];
  111. psbc = &SZHVC_sub[256*256];
  112. for (oldval = 0; oldval < 256; oldval++)
  113. {
  114. for (newval = 0; newval < 256; newval++)
  115. {
  116. /* add or adc w/o carry set */
  117. val = newval - oldval;
  118. *padd = (newval) ? ((newval & 0x80) ? SF : 0) : ZF;
  119. *padd |= (newval & (YF | XF)); /* undocumented flag bits 5+3 */
  120. if ((newval & 0x0f) < (oldval & 0x0f)) *padd |= HF;
  121. if (newval < oldval ) *padd |= CF;
  122. if ((val ^ oldval ^ 0x80) & (val ^ newval) & 0x80) *padd |= VF;
  123. padd++;
  124. /* adc with carry set */
  125. val = newval - oldval - 1;
  126. *padc = (newval) ? ((newval & 0x80) ? SF : 0) : ZF;
  127. *padc |= (newval & (YF | XF)); /* undocumented flag bits 5+3 */
  128. if ((newval & 0x0f) <= (oldval & 0x0f)) *padc |= HF;
  129. if (newval <= oldval) *padc |= CF;
  130. if ((val ^ oldval ^ 0x80) & (val ^ newval) & 0x80) *padc |= VF;
  131. padc++;
  132. /* cp, sub or sbc w/o carry set */
  133. val = oldval - newval;
  134. *psub = NF | ((newval) ? ((newval & 0x80) ? SF : 0) : ZF);
  135. *psub |= (newval & (YF | XF)); /* undocumented flag bits 5+3 */
  136. if ((newval & 0x0f) > (oldval & 0x0f)) *psub |= HF;
  137. if (newval > oldval) *psub |= CF;
  138. if ((val^oldval) & (oldval^newval) & 0x80) *psub |= VF;
  139. psub++;
  140. /* sbc with carry set */
  141. val = oldval - newval - 1;
  142. *psbc = NF | ((newval) ? ((newval & 0x80) ? SF : 0) : ZF);
  143. *psbc |= (newval & (YF | XF)); /* undocumented flag bits 5+3 */
  144. if ((newval & 0x0f) >= (oldval & 0x0f)) *psbc |= HF;
  145. if (newval >= oldval) *psbc |= CF;
  146. if ((val ^ oldval) & (oldval^newval) & 0x80) *psbc |= VF;
  147. psbc++;
  148. }
  149. }
  150. #endif
  151. CPU->pzR8[0] = &zB;
  152. CPU->pzR8[1] = &zC;
  153. CPU->pzR8[2] = &zD;
  154. CPU->pzR8[3] = &zE;
  155. CPU->pzR8[4] = &zH;
  156. CPU->pzR8[5] = &zL;
  157. CPU->pzR8[6] = &zF; // 処理の都合上、Aと入れ替え
  158. CPU->pzR8[7] = &zA; // 処理の都合上、Fと入れ替え
  159. CPU->pzR16[0] = pzBC;
  160. CPU->pzR16[1] = pzDE;
  161. CPU->pzR16[2] = pzHL;
  162. CPU->pzR16[3] = pzAF;
  163. zIX = zIY = 0xffff;
  164. CPU->Interrupt_Callback = Cz80_Interrupt_Callback;
  165. }
  166. /*--------------------------------------------------------
  167. CPUリセット
  168. --------------------------------------------------------*/
  169. void Cz80_Reset(cz80_struc *CPU)
  170. {
  171. // I, R, CPU and interrupts logic is reset, registers are untouched
  172. memset(&CPU->R, 0, (FPTR)&CPU->BasePC - (FPTR)&CPU->R);
  173. Cz80_Set_Reg(CPU, CZ80_PC, 0);
  174. }
  175. /* */
  176. #if PICODRIVE_HACKS
  177. static inline unsigned char picodrive_read(unsigned short a)
  178. {
  179. uptr v = z80_read_map[a >> Z80_MEM_SHIFT];
  180. if (map_flag_set(v))
  181. return ((z80_read_f *)(v << 1))(a);
  182. return *(unsigned char *)((v << 1) + a);
  183. }
  184. #endif
  185. /*--------------------------------------------------------
  186. CPU実行
  187. --------------------------------------------------------*/
  188. INT32 Cz80_Exec(cz80_struc *CPU, INT32 cycles)
  189. {
  190. #if CZ80_USE_JUMPTABLE
  191. #include "cz80jmp.c"
  192. #endif
  193. FPTR PC;
  194. #if CZ80_ENCRYPTED_ROM
  195. FPTR OPBase;
  196. #endif
  197. UINT32 Opcode;
  198. UINT32 adr = 0;
  199. UINT32 res;
  200. UINT32 val;
  201. union16 *data;
  202. PC = CPU->PC;
  203. #if CZ80_ENCRYPTED_ROM
  204. OPBase = CPU->OPBase;
  205. #endif
  206. CPU->ICount = cycles - CPU->ExtraCycles;
  207. CPU->ExtraCycles = 0;
  208. Cz80_Exec:
  209. if (CPU->Status)
  210. {
  211. if (CPU->Status & CZ80_HAS_NMI)
  212. {
  213. zIFF1 = 0;
  214. CPU->Status &= ~(CZ80_HALTED | CZ80_HAS_NMI);
  215. CPU->ExtraCycles += 11;
  216. PUSH_16(zRealPC);
  217. SET_PC(0x66);
  218. } else if (CPU->Status & CZ80_HAS_INT)
  219. {
  220. CHECK_INT
  221. } else if (CPU->Status & CZ80_HALTED)
  222. {
  223. goto Cz80_Exec_End;
  224. }
  225. CPU->ICount -= CPU->ExtraCycles;
  226. CPU->ExtraCycles = 0;
  227. }
  228. if (CPU->ICount > 0)
  229. {
  230. Cz80_Exec_nocheck:
  231. data = pzHL;
  232. Opcode = READ_OP();
  233. #if CZ80_EMULATE_R_EXACTLY
  234. zR++;
  235. #endif
  236. #include "cz80_op.c"
  237. }
  238. Cz80_Exec_End:
  239. CPU->PC = PC;
  240. #if CZ80_ENCRYPTED_ROM
  241. CPU->OPBase = OPBase;
  242. #endif
  243. if (!((CPU->Status & CZ80_HALTED) && CPU->ICount > 0))
  244. cycles -= CPU->ICount;
  245. CPU->ICount = 0;
  246. #if !CZ80_EMULATE_R_EXACTLY
  247. zR = (zR + (cycles >> 2)) & 0x7f;
  248. #endif
  249. return cycles;
  250. }
  251. /*--------------------------------------------------------
  252. 割り込み処理
  253. --------------------------------------------------------*/
  254. void Cz80_Set_IRQ(cz80_struc *CPU, INT32 line, INT32 state)
  255. {
  256. if (line == IRQ_LINE_NMI)
  257. {
  258. if (state)
  259. CPU->Status |= CZ80_HAS_NMI;
  260. else
  261. CPU->Status &= ~CZ80_HAS_NMI;
  262. } else
  263. {
  264. CPU->IRQLine = line;
  265. CPU->IRQState = state;
  266. if (state)
  267. {
  268. if (zIFF1)
  269. CPU->Status |= CZ80_HAS_INT;
  270. } else
  271. {
  272. CPU->Status &= ~CZ80_HAS_INT;
  273. }
  274. }
  275. }
  276. /*--------------------------------------------------------
  277. レジスタ取得
  278. --------------------------------------------------------*/
  279. UINT32 Cz80_Get_Reg(cz80_struc *CPU, INT32 regnum)
  280. {
  281. switch (regnum)
  282. {
  283. case CZ80_PC: return (CPU->PC - CPU->BasePC);
  284. case CZ80_SP: return zSP;
  285. case CZ80_AF: return zAF;
  286. case CZ80_BC: return zBC;
  287. case CZ80_DE: return zDE;
  288. case CZ80_HL: return zHL;
  289. case CZ80_IX: return zIX;
  290. case CZ80_IY: return zIY;
  291. case CZ80_AF2: return zAF2;
  292. case CZ80_BC2: return zBC2;
  293. case CZ80_DE2: return zDE2;
  294. case CZ80_HL2: return zHL2;
  295. case CZ80_R: return zR;
  296. case CZ80_I: return zI;
  297. case CZ80_IM: return zIM;
  298. case CZ80_IFF1: return zIFF1;
  299. case CZ80_IFF2: return zIFF2;
  300. case CZ80_HALT: return CPU->Status & CZ80_HALTED;
  301. case CZ80_IRQ: return CPU->IRQState;
  302. default: return 0;
  303. }
  304. }
  305. /*--------------------------------------------------------
  306. レジスタ設定
  307. --------------------------------------------------------*/
  308. void Cz80_Set_Reg(cz80_struc *CPU, INT32 regnum, UINT32 val)
  309. {
  310. switch (regnum)
  311. {
  312. case CZ80_PC:
  313. CPU->BasePC = CPU->Fetch[val >> CZ80_FETCH_SFT];
  314. #if CZ80_ENCRYPTED_ROM
  315. CPU->OPBase = CPU->OPFetch[val >> CZ80_FETCH_SFT];
  316. #endif
  317. CPU->PC = val + CPU->BasePC;
  318. break;
  319. case CZ80_SP: zSP = val; break;
  320. case CZ80_AF: zAF = val; break;
  321. case CZ80_BC: zBC = val; break;
  322. case CZ80_DE: zDE = val; break;
  323. case CZ80_HL: zHL = val; break;
  324. case CZ80_IX: zIX = val; break;
  325. case CZ80_IY: zIY = val; break;
  326. case CZ80_AF2: zAF2 = val; break;
  327. case CZ80_BC2: zBC2 = val; break;
  328. case CZ80_DE2: zDE2 = val; break;
  329. case CZ80_HL2: zHL2 = val; break;
  330. case CZ80_R: zR = val; break;
  331. case CZ80_I: zI = val; break;
  332. case CZ80_IM: zIM = val; break;
  333. case CZ80_IFF1: zIFF1 = val ? (1 << 2) : 0; break;
  334. case CZ80_IFF2: zIFF2 = val ? (1 << 2) : 0; break;
  335. case CZ80_HALT: CPU->Status = !!val * CZ80_HALTED; break;
  336. case CZ80_IRQ: CPU->IRQState = val; break;
  337. default: break;
  338. }
  339. }
  340. /*--------------------------------------------------------
  341. フェッチアドレス設定
  342. --------------------------------------------------------*/
  343. void Cz80_Set_Fetch(cz80_struc *CPU, UINT32 low_adr, UINT32 high_adr, FPTR fetch_adr)
  344. {
  345. int i, j;
  346. i = low_adr >> CZ80_FETCH_SFT;
  347. j = high_adr >> CZ80_FETCH_SFT;
  348. fetch_adr -= i << CZ80_FETCH_SFT;
  349. while (i <= j)
  350. {
  351. CPU->Fetch[i] = fetch_adr;
  352. #if CZ80_ENCRYPTED_ROM
  353. CPU->OPFetch[i] = 0;
  354. #endif
  355. i++;
  356. }
  357. }
  358. /*--------------------------------------------------------
  359. フェッチアドレス設定 (暗号化ROM対応)
  360. --------------------------------------------------------*/
  361. #if CZ80_ENCRYPTED_ROM
  362. void Cz80_Set_Encrypt_Range(cz80_struc *CPU, UINT32 low_adr, UINT32 high_adr, UINT32 decrypted_rom)
  363. {
  364. int i, j;
  365. i = low_adr >> CZ80_FETCH_SFT;
  366. j = high_adr >> CZ80_FETCH_SFT;
  367. decrypted_rom -= i << CZ80_FETCH_SFT;
  368. while (i <= j)
  369. {
  370. CPU->OPFetch[i] = (INT32)decrypted_rom - (INT32)CPU->Fetch[i];
  371. i++;
  372. }
  373. }
  374. #endif
  375. /*--------------------------------------------------------
  376. メモリリード/ライト関数設定
  377. --------------------------------------------------------*/
  378. void Cz80_Set_ReadB(cz80_struc *CPU, UINT8 (*Func)(UINT32 address))
  379. {
  380. CPU->Read_Byte = Func;
  381. }
  382. void Cz80_Set_WriteB(cz80_struc *CPU, void (*Func)(UINT32 address, UINT8 data))
  383. {
  384. CPU->Write_Byte = Func;
  385. }
  386. /*--------------------------------------------------------
  387. ポートリード/ライト関数設定
  388. --------------------------------------------------------*/
  389. void Cz80_Set_INPort(cz80_struc *CPU, UINT8 (*Func)(UINT16 port))
  390. {
  391. CPU->IN_Port = Func;
  392. }
  393. void Cz80_Set_OUTPort(cz80_struc *CPU, void (*Func)(UINT16 port, UINT8 value))
  394. {
  395. CPU->OUT_Port = Func;
  396. }
  397. /*--------------------------------------------------------
  398. コールバック関数設定
  399. --------------------------------------------------------*/
  400. void Cz80_Set_IRQ_Callback(cz80_struc *CPU, INT32 (*Func)(INT32 irqline))
  401. {
  402. CPU->Interrupt_Callback = Func;
  403. }