cpu/cz80/cz80.c

   1 /******************************************************************************\r
   2  *\r
   3  * CZ80 (Z80 CPU emulator) version 0.9\r
   4  * Compiled with Dev-C++\r
   5  * Copyright 2004-2005 Stéphane Dallongeville\r
   6  *\r
   7  * (Modified by NJ)\r
   8  *\r
   9  *****************************************************************************/\r
  10 \r
  11 #include <stdio.h>\r
  12 #include <stdlib.h>\r
  13 #include <string.h>\r
  14 #include "cz80.h"\r
  15 \r
  16 #ifndef ALIGN_DATA\r
  17 #define ALIGN_DATA      __attribute__((aligned(4)))\r
  18 #endif\r
  19 \r
  20 #define CF                                      0x01\r
  21 #define NF                                      0x02\r
  22 #define PF                                      0x04\r
  23 #define VF                                      PF\r
  24 #define XF                                      0x08\r
  25 #define HF                                      0x10\r
  26 #define YF                                      0x20\r
  27 #define ZF                                      0x40\r
  28 #define SF                                      0x80\r
  29 \r
  30 \r
  31 /******************************************************************************\r
  32         \83}\83N\83\8d\r
  33 ******************************************************************************/\r
  34 \r
  35 #include "cz80macro.h"\r
  36 \r
  37 \r
  38 /******************************************************************************\r
  39         \83O\83\8d\81[\83o\83\8b\8d\\91¢\91Ì\r
  40 ******************************************************************************/\r
  41 \r
  42 cz80_struc ALIGN_DATA CZ80;\r
  43 \r
  44 \r
  45 /******************************************************************************\r
  46         \83\8d\81[\83J\83\8b\95Ï\90\94\r
  47 ******************************************************************************/\r
  48 \r
  49 static UINT8 ALIGN_DATA cz80_bad_address[1 << CZ80_FETCH_SFT];\r
  50 \r
  51 static UINT8 ALIGN_DATA SZ[256];\r
  52 static UINT8 ALIGN_DATA SZP[256];\r
  53 static UINT8 ALIGN_DATA SZ_BIT[256];\r
  54 static UINT8 ALIGN_DATA SZHV_inc[256];\r
  55 static UINT8 ALIGN_DATA SZHV_dec[256];\r
  56 #if CZ80_BIG_FLAGS_ARRAY\r
  57 static UINT8 ALIGN_DATA SZHVC_add[2*256*256];\r
  58 static UINT8 ALIGN_DATA SZHVC_sub[2*256*256];\r
  59 #endif\r
  60 \r
  61 \r
  62 /******************************************************************************\r
  63         \83\8d\81[\83J\83\8b\8aÖ\90\94\r
  64 ******************************************************************************/\r
  65 \r
  66 /*--------------------------------------------------------\r
  67         \8a\84\82è\8d\9e\82Ý\83R\81[\83\8b\83o\83b\83N\r
  68 --------------------------------------------------------*/\r
  69 \r
  70 static INT32 Cz80_Interrupt_Callback(INT32 line)\r
  71 {\r
  72         return 0xff;\r
  73 }\r
  74 \r
  75 \r
  76 /******************************************************************************\r
  77         CZ80\83C\83\93\83^\83t\83F\81[\83X\8aÖ\90\94\r
  78 ******************************************************************************/\r
  79 \r
  80 /*--------------------------------------------------------\r
  81         CPU\8f\89\8aú\89»\r
  82 --------------------------------------------------------*/\r
  83 \r
  84 void Cz80_Init(cz80_struc *CPU)\r
  85 {\r
  86         UINT32 i, j, p;\r
  87 #if CZ80_BIG_FLAGS_ARRAY\r
  88         int oldval, newval, val;\r
  89         UINT8 *padd, *padc, *psub, *psbc;\r
  90 #endif\r
  91 \r
  92         memset(CPU, 0, sizeof(cz80_struc));\r
  93 \r
  94         memset(cz80_bad_address, 0xff, sizeof(cz80_bad_address));\r
  95 \r
  96         for (i = 0; i < CZ80_FETCH_BANK; i++)\r
  97         {\r
  98                 CPU->Fetch[i] = (UINT32)cz80_bad_address;\r
  99 #if CZ80_ENCRYPTED_ROM\r
 100                 CPU->OPFetch[i] = 0;\r
 101 #endif\r
 102         }\r
 103 \r
 104         // flags tables initialisation\r
 105         for (i = 0; i < 256; i++)\r
 106         {\r
 107                 SZ[i] = i & (SF | YF | XF);\r
 108                 if (!i) SZ[i] |= ZF;\r
 109 \r
 110                 SZ_BIT[i] = i & (SF | YF | XF);\r
 111                 if (!i) SZ_BIT[i] |= ZF | PF;\r
 112 \r
 113                 for (j = 0, p = 0; j < 8; j++) if (i & (1 << j)) p++;\r
 114                 SZP[i] = SZ[i];\r
 115                 if (!(p & 1)) SZP[i] |= PF;\r
 116 \r
 117                 SZHV_inc[i] = SZ[i];\r
 118                 if(i == 0x80) SZHV_inc[i] |= VF;\r
 119                 if((i & 0x0f) == 0x00) SZHV_inc[i] |= HF;\r
 120 \r
 121                 SZHV_dec[i] = SZ[i] | NF;\r
 122                 if (i == 0x7f) SZHV_dec[i] |= VF;\r
 123                 if ((i & 0x0f) == 0x0f) SZHV_dec[i] |= HF;\r
 124         }\r
 125 \r
 126 #if CZ80_BIG_FLAGS_ARRAY\r
 127         padd = &SZHVC_add[  0*256];\r
 128         padc = &SZHVC_add[256*256];\r
 129         psub = &SZHVC_sub[  0*256];\r
 130         psbc = &SZHVC_sub[256*256];\r
 131 \r
 132         for (oldval = 0; oldval < 256; oldval++)\r
 133         {\r
 134                 for (newval = 0; newval < 256; newval++)\r
 135                 {\r
 136                         /* add or adc w/o carry set */\r
 137                         val = newval - oldval;\r
 138                         *padd = (newval) ? ((newval & 0x80) ? SF : 0) : ZF;\r
 139                         *padd |= (newval & (YF | XF));  /* undocumented flag bits 5+3 */\r
 140                         if ((newval & 0x0f) < (oldval & 0x0f)) *padd |= HF;\r
 141                         if (newval < oldval ) *padd |= CF;\r
 142                         if ((val ^ oldval ^ 0x80) & (val ^ newval) & 0x80) *padd |= VF;\r
 143                         padd++;\r
 144 \r
 145                         /* adc with carry set */\r
 146                         val = newval - oldval - 1;\r
 147                         *padc = (newval) ? ((newval & 0x80) ? SF : 0) : ZF;\r
 148                         *padc |= (newval & (YF | XF));  /* undocumented flag bits 5+3 */\r
 149                         if ((newval & 0x0f) <= (oldval & 0x0f)) *padc |= HF;\r
 150                         if (newval <= oldval) *padc |= CF;\r
 151                         if ((val ^ oldval ^ 0x80) & (val ^ newval) & 0x80) *padc |= VF;\r
 152                         padc++;\r
 153 \r
 154                         /* cp, sub or sbc w/o carry set */\r
 155                         val = oldval - newval;\r
 156                         *psub = NF | ((newval) ? ((newval & 0x80) ? SF : 0) : ZF);\r
 157                         *psub |= (newval & (YF | XF));  /* undocumented flag bits 5+3 */\r
 158                         if ((newval & 0x0f) > (oldval & 0x0f)) *psub |= HF;\r
 159                         if (newval > oldval) *psub |= CF;\r
 160                         if ((val^oldval) & (oldval^newval) & 0x80) *psub |= VF;\r
 161                         psub++;\r
 162 \r
 163                         /* sbc with carry set */\r
 164                         val = oldval - newval - 1;\r
 165                         *psbc = NF | ((newval) ? ((newval & 0x80) ? SF : 0) : ZF);\r
 166                         *psbc |= (newval & (YF | XF));  /* undocumented flag bits 5+3 */\r
 167                         if ((newval & 0x0f) >= (oldval & 0x0f)) *psbc |= HF;\r
 168                         if (newval >= oldval) *psbc |= CF;\r
 169                         if ((val ^ oldval) & (oldval^newval) & 0x80) *psbc |= VF;\r
 170                         psbc++;\r
 171                 }\r
 172         }\r
 173 #endif\r
 174 \r
 175         CPU->pzR8[0] = &zB;\r
 176         CPU->pzR8[1] = &zC;\r
 177         CPU->pzR8[2] = &zD;\r
 178         CPU->pzR8[3] = &zE;\r
 179         CPU->pzR8[4] = &zH;\r
 180         CPU->pzR8[5] = &zL;\r
 181         CPU->pzR8[6] = &zF;     // \8f\88\97\9d\82Ì\93s\8d\87\8fã\81AA\82Æ\93ü\82ê\91Ö\82¦\r
 182         CPU->pzR8[7] = &zA;     // \8f\88\97\9d\82Ì\93s\8d\87\8fã\81AF\82Æ\93ü\82ê\91Ö\82¦\r
 183 \r
 184         CPU->pzR16[0] = pzBC;\r
 185         CPU->pzR16[1] = pzDE;\r
 186         CPU->pzR16[2] = pzHL;\r
 187         CPU->pzR16[3] = pzAF;\r
 188 \r
 189         zIX = zIY = 0xffff;\r
 190         zF = ZF;\r
 191 \r
 192         CPU->Interrupt_Callback = Cz80_Interrupt_Callback;\r
 193 }\r
 194 \r
 195 \r
 196 /*--------------------------------------------------------\r
 197         CPU\83\8a\83Z\83b\83g\r
 198 --------------------------------------------------------*/\r
 199 \r
 200 void Cz80_Reset(cz80_struc *CPU)\r
 201 {\r
 202         memset(CPU, 0, (INT32)&CPU->BasePC - (INT32)CPU);\r
 203         Cz80_Set_Reg(CPU, CZ80_PC, 0);\r
 204 }\r
 205 \r
 206 \r
 207 /*--------------------------------------------------------\r
 208         CPU\8eÀ\8ds\r
 209 --------------------------------------------------------*/\r
 210 \r
 211 INT32 Cz80_Exec(cz80_struc *CPU, INT32 cycles)\r
 212 {\r
 213 #if CZ80_USE_JUMPTABLE\r
 214 #include "cz80jmp.c"\r
 215 #endif\r
 216 \r
 217         UINT32 PC;\r
 218 #if CZ80_ENCRYPTED_ROM\r
 219         INT32 OPBase;\r
 220 #endif\r
 221         UINT32 Opcode;\r
 222         UINT32 adr = 0;\r
 223         UINT32 res;\r
 224         UINT32 val;\r
 225         int afterEI = 0;\r
 226 \r
 227         PC = CPU->PC;\r
 228 #if CZ80_ENCRYPTED_ROM\r
 229         OPBase = CPU->OPBase;\r
 230 #endif\r
 231         CPU->ICount = cycles - CPU->ExtraCycles;\r
 232         CPU->ExtraCycles = 0;\r
 233 \r
 234         if (!CPU->HaltState)\r
 235         {\r
 236 Cz80_Exec:\r
 237                 if (CPU->ICount > 0)\r
 238                 {\r
 239                         union16 *data = pzHL;\r
 240                         Opcode = READ_OP();\r
 241 #if CZ80_EMULATE_R_EXACTLY\r
 242                         zR++;\r
 243 #endif\r
 244                         #include "cz80_op.c"\r
 245                 }\r
 246 \r
 247                 if (afterEI)\r
 248                 {\r
 249                         afterEI = 0;\r
 250 Cz80_Check_Interrupt:\r
 251                         CHECK_INT\r
 252                         goto Cz80_Exec;\r
 253                 }\r
 254         }\r
 255         else CPU->ICount = 0;\r
 256 \r
 257 Cz80_Exec_End:\r
 258         CPU->PC = PC;\r
 259 #if CZ80_ENCRYPTED_ROM\r
 260         CPU->OPBase = OPBase;\r
 261 #endif\r
 262         cycles -= CPU->ICount;\r
 263 #if !CZ80_EMULATE_R_EXACTLY\r
 264         zR = (zR + (cycles >> 2)) & 0x7f;\r
 265 #endif\r
 266 \r
 267         return cycles;\r
 268 }\r
 269 \r
 270 \r
 271 /*--------------------------------------------------------\r
 272         \8a\84\82è\8d\9e\82Ý\8f\88\97\9d\r
 273 --------------------------------------------------------*/\r
 274 \r
 275 void Cz80_Set_IRQ(cz80_struc *CPU, INT32 line, INT32 state)\r
 276 {\r
 277         if (line == IRQ_LINE_NMI)\r
 278         {\r
 279                 zIFF1 = 0;\r
 280                 CPU->ExtraCycles += 11;\r
 281                 CPU->HaltState = 0;\r
 282                 PUSH_16(CPU->PC - CPU->BasePC)\r
 283                 Cz80_Set_Reg(CPU, CZ80_PC, 0x66);\r
 284         }\r
 285         else\r
 286         {\r
 287                 CPU->IRQState = state;\r
 288 \r
 289                 if (state != CLEAR_LINE)\r
 290                 {\r
 291                         UINT32 PC = CPU->PC;\r
 292 #if CZ80_ENCRYPTED_ROM\r
 293                         INT32 OPBase = CPU->OPBase;\r
 294 #endif\r
 295 \r
 296                         CPU->IRQLine = line;\r
 297                         CHECK_INT\r
 298                         CPU->PC = PC;\r
 299 #if CZ80_ENCRYPTED_ROM\r
 300                         CPU->OPBase = OPBase;\r
 301 #endif\r
 302                 }\r
 303         }\r
 304 }\r
 305 \r
 306 \r
 307 /*--------------------------------------------------------\r
 308         \83\8c\83W\83X\83^\8eæ\93¾\r
 309 --------------------------------------------------------*/\r
 310 \r
 311 UINT32 Cz80_Get_Reg(cz80_struc *CPU, INT32 regnum)\r
 312 {\r
 313         switch (regnum)\r
 314         {\r
 315         case CZ80_PC:   return (CPU->PC - CPU->BasePC);\r
 316         case CZ80_SP:   return zSP;\r
 317         case CZ80_AF:   return zAF;\r
 318         case CZ80_BC:   return zBC;\r
 319         case CZ80_DE:   return zDE;\r
 320         case CZ80_HL:   return zHL;\r
 321         case CZ80_IX:   return zIX;\r
 322         case CZ80_IY:   return zIY;\r
 323         case CZ80_AF2:  return zAF2;\r
 324         case CZ80_BC2:  return zBC2;\r
 325         case CZ80_DE2:  return zDE2;\r
 326         case CZ80_HL2:  return zHL2;\r
 327         case CZ80_R:    return zR;\r
 328         case CZ80_I:    return zI;\r
 329         case CZ80_IM:   return zIM;\r
 330         case CZ80_IFF1: return zIFF1;\r
 331         case CZ80_IFF2: return zIFF2;\r
 332         case CZ80_HALT: return CPU->HaltState;\r
 333         case CZ80_IRQ:  return CPU->IRQState;\r
 334         default: return 0;\r
 335         }\r
 336 }\r
 337 \r
 338 \r
 339 /*--------------------------------------------------------\r
 340         \83\8c\83W\83X\83^\90Ý\92è\r
 341 --------------------------------------------------------*/\r
 342 \r
 343 void Cz80_Set_Reg(cz80_struc *CPU, INT32 regnum, UINT32 val)\r
 344 {\r
 345         switch (regnum)\r
 346         {\r
 347         case CZ80_PC:\r
 348                 CPU->BasePC = CPU->Fetch[val >> CZ80_FETCH_SFT];\r
 349 #if CZ80_ENCRYPTED_ROM\r
 350                 CPU->OPBase = CPU->OPFetch[val >> CZ80_FETCH_SFT];\r
 351 #endif\r
 352                 CPU->PC = val + CPU->BasePC;\r
 353                 break;\r
 354 \r
 355         case CZ80_SP:   zSP = val; break;\r
 356         case CZ80_AF:   zAF = val; break;\r
 357         case CZ80_BC:   zBC = val; break;\r
 358         case CZ80_DE:   zDE = val; break;\r
 359         case CZ80_HL:   zHL = val; break;\r
 360         case CZ80_IX:   zIX = val; break;\r
 361         case CZ80_IY:   zIY = val; break;\r
 362         case CZ80_AF2:  zAF2 = val; break;\r
 363         case CZ80_BC2:  zBC2 = val; break;\r
 364         case CZ80_DE2:  zDE2 = val; break;\r
 365         case CZ80_HL2:  zHL2 = val; break;\r
 366         case CZ80_R:    zR = val; break;\r
 367         case CZ80_I:    zI = val; break;\r
 368         case CZ80_IM:   zIM = val; break;\r
 369         case CZ80_IFF1: zIFF1 = val; break;\r
 370         case CZ80_IFF2: zIFF2 = val; break;\r
 371         case CZ80_HALT: CPU->HaltState = val; break;\r
 372         case CZ80_IRQ:  CPU->IRQState = val; break;\r
 373         default: break;\r
 374         }\r
 375 }\r
 376 \r
 377 \r
 378 /*--------------------------------------------------------\r
 379         \83t\83F\83b\83`\83A\83h\83\8c\83X\90Ý\92è\r
 380 --------------------------------------------------------*/\r
 381 \r
 382 void Cz80_Set_Fetch(cz80_struc *CPU, UINT32 low_adr, UINT32 high_adr, UINT32 fetch_adr)\r
 383 {\r
 384         int i, j;\r
 385 \r
 386         i = low_adr >> CZ80_FETCH_SFT;\r
 387         j = high_adr >> CZ80_FETCH_SFT;\r
 388         fetch_adr -= i << CZ80_FETCH_SFT;\r
 389 \r
 390         while (i <= j)\r
 391         {\r
 392                 CPU->Fetch[i] = fetch_adr;\r
 393 #if CZ80_ENCRYPTED_ROM\r
 394                 CPU->OPFetch[i] = 0;\r
 395 #endif\r
 396                 i++;\r
 397         }\r
 398 }\r
 399 \r
 400 \r
 401 /*--------------------------------------------------------\r
 402         \83t\83F\83b\83`\83A\83h\83\8c\83X\90Ý\92è (\88Ã\8d\86\89»ROM\91Î\89\9e)\r
 403 --------------------------------------------------------*/\r
 404 \r
 405 #if CZ80_ENCRYPTED_ROM\r
 406 void Cz80_Set_Encrypt_Range(cz80_struc *CPU, UINT32 low_adr, UINT32 high_adr, UINT32 decrypted_rom)\r
 407 {\r
 408         int i, j;\r
 409 \r
 410         i = low_adr >> CZ80_FETCH_SFT;\r
 411         j = high_adr >> CZ80_FETCH_SFT;\r
 412         decrypted_rom -= i << CZ80_FETCH_SFT;\r
 413 \r
 414         while (i <= j)\r
 415         {\r
 416                 CPU->OPFetch[i] = (INT32)decrypted_rom - (INT32)CPU->Fetch[i];\r
 417                 i++;\r
 418         }\r
 419 }\r
 420 #endif\r
 421 \r
 422 \r
 423 /*--------------------------------------------------------\r
 424         \83\81\83\82\83\8a\83\8a\81[\83h/\83\89\83C\83g\8aÖ\90\94\90Ý\92è\r
 425 --------------------------------------------------------*/\r
 426 \r
 427 void Cz80_Set_ReadB(cz80_struc *CPU, UINT8 (*Func)(UINT32 address))\r
 428 {\r
 429         CPU->Read_Byte = Func;\r
 430 }\r
 431 \r
 432 void Cz80_Set_WriteB(cz80_struc *CPU, void (*Func)(UINT32 address, UINT8 data))\r
 433 {\r
 434         CPU->Write_Byte = Func;\r
 435 }\r
 436 \r
 437 \r
 438 /*--------------------------------------------------------\r
 439         \83|\81[\83g\83\8a\81[\83h/\83\89\83C\83g\8aÖ\90\94\90Ý\92è\r
 440 --------------------------------------------------------*/\r
 441 \r
 442 void Cz80_Set_INPort(cz80_struc *CPU, UINT8 (*Func)(UINT16 port))\r
 443 {\r
 444         CPU->IN_Port = Func;\r
 445 }\r
 446 \r
 447 void Cz80_Set_OUTPort(cz80_struc *CPU, void (*Func)(UINT16 port, UINT8 value))\r
 448 {\r
 449         CPU->OUT_Port = Func;\r
 450 }\r
 451 \r
 452 \r
 453 /*--------------------------------------------------------\r
 454         \83R\81[\83\8b\83o\83b\83N\8aÖ\90\94\90Ý\92è\r
 455 --------------------------------------------------------*/\r
 456 \r
 457 void Cz80_Set_IRQ_Callback(cz80_struc *CPU, INT32 (*Func)(INT32 irqline))\r
 458 {\r
 459         CPU->Interrupt_Callback = Func;\r
 460 }\r