cz80.c 12 KB

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