cz80.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497
  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. zF = ZF;
  165. CPU->Interrupt_Callback = Cz80_Interrupt_Callback;
  166. }
  167. /*--------------------------------------------------------
  168. CPUリセット
  169. --------------------------------------------------------*/
  170. void Cz80_Reset(cz80_struc *CPU)
  171. {
  172. // I, R, CPU and interrupts logic is reset, registers are untouched
  173. memset(&CPU->R, 0, (FPTR)&CPU->BasePC - (FPTR)&CPU->R);
  174. Cz80_Set_Reg(CPU, CZ80_PC, 0);
  175. }
  176. /* */
  177. #if PICODRIVE_HACKS
  178. static inline unsigned char picodrive_read(unsigned short a)
  179. {
  180. uptr v = z80_read_map[a >> Z80_MEM_SHIFT];
  181. if (map_flag_set(v))
  182. return ((z80_read_f *)(v << 1))(a);
  183. return *(unsigned char *)((v << 1) + a);
  184. }
  185. #endif
  186. /*--------------------------------------------------------
  187. CPU実行
  188. --------------------------------------------------------*/
  189. INT32 Cz80_Exec(cz80_struc *CPU, INT32 cycles)
  190. {
  191. #if CZ80_USE_JUMPTABLE
  192. #include "cz80jmp.c"
  193. #endif
  194. FPTR PC;
  195. #if CZ80_ENCRYPTED_ROM
  196. FPTR OPBase;
  197. #endif
  198. UINT32 Opcode;
  199. UINT32 adr = 0;
  200. UINT32 res;
  201. UINT32 val;
  202. int afterEI = 0;
  203. union16 *data;
  204. PC = CPU->PC;
  205. #if CZ80_ENCRYPTED_ROM
  206. OPBase = CPU->OPBase;
  207. #endif
  208. CPU->ICount = cycles - CPU->ExtraCycles;
  209. CPU->ExtraCycles = 0;
  210. if (!CPU->HaltState)
  211. {
  212. Cz80_Exec:
  213. if (CPU->ICount > 0)
  214. {
  215. Cz80_Exec_nocheck:
  216. data = pzHL;
  217. Opcode = READ_OP();
  218. #if CZ80_EMULATE_R_EXACTLY
  219. zR++;
  220. #endif
  221. #include "cz80_op.c"
  222. }
  223. if (afterEI)
  224. {
  225. afterEI = 0;
  226. Cz80_Check_Interrupt:
  227. if (CPU->IRQState != CLEAR_LINE)
  228. {
  229. CHECK_INT
  230. }
  231. CPU->ICount -= CPU->ExtraCycles;
  232. CPU->ExtraCycles = 0;
  233. if (!CPU->HaltState)
  234. goto Cz80_Exec;
  235. }
  236. }
  237. Cz80_Exec_End:
  238. CPU->PC = PC;
  239. #if CZ80_ENCRYPTED_ROM
  240. CPU->OPBase = OPBase;
  241. #endif
  242. if (!(CPU->HaltState && CPU->ICount > 0))
  243. cycles -= CPU->ICount;
  244. CPU->ICount = 0;
  245. #if !CZ80_EMULATE_R_EXACTLY
  246. zR = (zR + (cycles >> 2)) & 0x7f;
  247. #endif
  248. return cycles;
  249. }
  250. /*--------------------------------------------------------
  251. 割り込み処理
  252. --------------------------------------------------------*/
  253. void Cz80_Set_IRQ(cz80_struc *CPU, INT32 line, INT32 state)
  254. {
  255. if (line == IRQ_LINE_NMI)
  256. {
  257. zIFF1 = 0;
  258. CPU->ExtraCycles += 11;
  259. CPU->HaltState = 0;
  260. PUSH_16(CPU->PC - CPU->BasePC)
  261. Cz80_Set_Reg(CPU, CZ80_PC, 0x66);
  262. }
  263. else
  264. {
  265. CPU->IRQState = state;
  266. if (state != CLEAR_LINE)
  267. {
  268. FPTR PC = CPU->PC;
  269. #if CZ80_ENCRYPTED_ROM
  270. FPTR OPBase = CPU->OPBase;
  271. #endif
  272. CPU->IRQLine = line;
  273. CHECK_INT
  274. CPU->PC = PC;
  275. #if CZ80_ENCRYPTED_ROM
  276. CPU->OPBase = OPBase;
  277. #endif
  278. }
  279. }
  280. if (CPU->ICount > 0)
  281. {
  282. CPU->ICount -= CPU->ExtraCycles;
  283. CPU->ExtraCycles = 0;
  284. }
  285. }
  286. /*--------------------------------------------------------
  287. レジスタ取得
  288. --------------------------------------------------------*/
  289. UINT32 Cz80_Get_Reg(cz80_struc *CPU, INT32 regnum)
  290. {
  291. switch (regnum)
  292. {
  293. case CZ80_PC: return (CPU->PC - CPU->BasePC);
  294. case CZ80_SP: return zSP;
  295. case CZ80_AF: return zAF;
  296. case CZ80_BC: return zBC;
  297. case CZ80_DE: return zDE;
  298. case CZ80_HL: return zHL;
  299. case CZ80_IX: return zIX;
  300. case CZ80_IY: return zIY;
  301. case CZ80_AF2: return zAF2;
  302. case CZ80_BC2: return zBC2;
  303. case CZ80_DE2: return zDE2;
  304. case CZ80_HL2: return zHL2;
  305. case CZ80_R: return zR;
  306. case CZ80_I: return zI;
  307. case CZ80_IM: return zIM;
  308. case CZ80_IFF1: return zIFF1;
  309. case CZ80_IFF2: return zIFF2;
  310. case CZ80_HALT: return CPU->HaltState;
  311. case CZ80_IRQ: return CPU->IRQState;
  312. default: return 0;
  313. }
  314. }
  315. /*--------------------------------------------------------
  316. レジスタ設定
  317. --------------------------------------------------------*/
  318. void Cz80_Set_Reg(cz80_struc *CPU, INT32 regnum, UINT32 val)
  319. {
  320. switch (regnum)
  321. {
  322. case CZ80_PC:
  323. CPU->BasePC = CPU->Fetch[val >> CZ80_FETCH_SFT];
  324. #if CZ80_ENCRYPTED_ROM
  325. CPU->OPBase = CPU->OPFetch[val >> CZ80_FETCH_SFT];
  326. #endif
  327. CPU->PC = val + CPU->BasePC;
  328. break;
  329. case CZ80_SP: zSP = val; break;
  330. case CZ80_AF: zAF = val; break;
  331. case CZ80_BC: zBC = val; break;
  332. case CZ80_DE: zDE = val; break;
  333. case CZ80_HL: zHL = val; break;
  334. case CZ80_IX: zIX = val; break;
  335. case CZ80_IY: zIY = val; break;
  336. case CZ80_AF2: zAF2 = val; break;
  337. case CZ80_BC2: zBC2 = val; break;
  338. case CZ80_DE2: zDE2 = val; break;
  339. case CZ80_HL2: zHL2 = val; break;
  340. case CZ80_R: zR = val; break;
  341. case CZ80_I: zI = val; break;
  342. case CZ80_IM: zIM = val; break;
  343. case CZ80_IFF1: zIFF1 = val ? (1 << 2) : 0; break;
  344. case CZ80_IFF2: zIFF2 = val ? (1 << 2) : 0; break;
  345. case CZ80_HALT: CPU->HaltState = val; break;
  346. case CZ80_IRQ: CPU->IRQState = val; break;
  347. default: break;
  348. }
  349. }
  350. /*--------------------------------------------------------
  351. フェッチアドレス設定
  352. --------------------------------------------------------*/
  353. void Cz80_Set_Fetch(cz80_struc *CPU, UINT32 low_adr, UINT32 high_adr, FPTR fetch_adr)
  354. {
  355. int i, j;
  356. i = low_adr >> CZ80_FETCH_SFT;
  357. j = high_adr >> CZ80_FETCH_SFT;
  358. fetch_adr -= i << CZ80_FETCH_SFT;
  359. while (i <= j)
  360. {
  361. CPU->Fetch[i] = fetch_adr;
  362. #if CZ80_ENCRYPTED_ROM
  363. CPU->OPFetch[i] = 0;
  364. #endif
  365. i++;
  366. }
  367. }
  368. /*--------------------------------------------------------
  369. フェッチアドレス設定 (暗号化ROM対応)
  370. --------------------------------------------------------*/
  371. #if CZ80_ENCRYPTED_ROM
  372. void Cz80_Set_Encrypt_Range(cz80_struc *CPU, UINT32 low_adr, UINT32 high_adr, UINT32 decrypted_rom)
  373. {
  374. int i, j;
  375. i = low_adr >> CZ80_FETCH_SFT;
  376. j = high_adr >> CZ80_FETCH_SFT;
  377. decrypted_rom -= i << CZ80_FETCH_SFT;
  378. while (i <= j)
  379. {
  380. CPU->OPFetch[i] = (INT32)decrypted_rom - (INT32)CPU->Fetch[i];
  381. i++;
  382. }
  383. }
  384. #endif
  385. /*--------------------------------------------------------
  386. メモリリード/ライト関数設定
  387. --------------------------------------------------------*/
  388. void Cz80_Set_ReadB(cz80_struc *CPU, UINT8 (*Func)(UINT32 address))
  389. {
  390. CPU->Read_Byte = Func;
  391. }
  392. void Cz80_Set_WriteB(cz80_struc *CPU, void (*Func)(UINT32 address, UINT8 data))
  393. {
  394. CPU->Write_Byte = Func;
  395. }
  396. /*--------------------------------------------------------
  397. ポートリード/ライト関数設定
  398. --------------------------------------------------------*/
  399. void Cz80_Set_INPort(cz80_struc *CPU, UINT8 (*Func)(UINT16 port))
  400. {
  401. CPU->IN_Port = Func;
  402. }
  403. void Cz80_Set_OUTPort(cz80_struc *CPU, void (*Func)(UINT16 port, UINT8 value))
  404. {
  405. CPU->OUT_Port = Func;
  406. }
  407. /*--------------------------------------------------------
  408. コールバック関数設定
  409. --------------------------------------------------------*/
  410. void Cz80_Set_IRQ_Callback(cz80_struc *CPU, INT32 (*Func)(INT32 irqline))
  411. {
  412. CPU->Interrupt_Callback = Func;
  413. }