| c62d2810 |
1 | /* FCE Ultra - NES/Famicom Emulator |
| 2 | * |
| 3 | * Copyright notice for this file: |
| 4 | * Copyright (C) 2002 Ben Parnell |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU General Public License |
| 17 | * along with this program; if not, write to the Free Software |
| 18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 19 | */ |
| 20 | |
| 21 | case 0x00: /* BRK */ |
| 22 | _PC++; |
| 23 | PUSH(_PC>>8); |
| 24 | PUSH(_PC); |
| 25 | PUSH(_P|U_FLAG|B_FLAG); |
| 26 | _P|=I_FLAG; |
| 27 | _PC=RdMem(0xFFFE); |
| 28 | _PC|=RdMem(0xFFFF)<<8; |
| 29 | break; |
| 30 | |
| 31 | case 0x40: /* RTI */ |
| 32 | _P=POP(); |
| 33 | _PI=_P; |
| 34 | _PC=POP(); |
| 35 | _PC|=POP()<<8; |
| 36 | break; |
| 37 | |
| 38 | case 0x60: /* RTS */ |
| 39 | _PC=POP(); |
| 40 | _PC|=POP()<<8; |
| 41 | _PC++; |
| 42 | break; |
| 43 | |
| 44 | case 0x48: /* PHA */ |
| 45 | PUSH(_A); |
| 46 | break; |
| 47 | case 0x08: /* PHP */ |
| 48 | PUSH(_P|U_FLAG|B_FLAG); |
| 49 | break; |
| 50 | case 0x68: /* PLA */ |
| 51 | _A=POP(); |
| 52 | X_ZN(_A); |
| 53 | break; |
| 54 | case 0x28: /* PLP */ |
| 55 | _P=POP(); |
| 56 | break; |
| 57 | case 0x4C: |
| 58 | { |
| 59 | uint16 ptmp=_PC; |
| 60 | unsigned int npc; |
| 61 | |
| 62 | npc=RdMem(ptmp); |
| 63 | ptmp++; |
| 64 | npc|=RdMem(ptmp)<<8; |
| 65 | _PC=npc; |
| 66 | } |
| 67 | break; /* JMP ABSOLUTE */ |
| 68 | case 0x6C: |
| 69 | { |
| 70 | uint32 tmp; |
| 71 | GetAB(tmp); |
| 72 | _PC=RdMem(tmp); |
| 73 | _PC|=RdMem( ((tmp+1)&0x00FF) | (tmp&0xFF00))<<8; |
| 74 | } |
| 75 | break; |
| 76 | case 0x20: /* JSR */ |
| 77 | { |
| 78 | uint8 npc; |
| 79 | npc=RdMem(_PC++); |
| 80 | PUSH(_PC>>8); |
| 81 | PUSH(_PC); |
| 82 | _PC=RdMem(_PC)<<8; |
| 83 | _PC|=npc; |
| 84 | } |
| 85 | break; |
| 86 | |
| 87 | case 0xAA: /* TAX */ |
| 88 | _X=_A; |
| 89 | X_ZN(_A); |
| 90 | break; |
| 91 | |
| 92 | case 0x8A: /* TXA */ |
| 93 | _A=_X; |
| 94 | X_ZN(_A); |
| 95 | break; |
| 96 | |
| 97 | case 0xA8: /* TAY */ |
| 98 | _Y=_A; |
| 99 | X_ZN(_A); |
| 100 | break; |
| 101 | case 0x98: /* TYA */ |
| 102 | _A=_Y; |
| 103 | X_ZN(_A); |
| 104 | break; |
| 105 | |
| 106 | case 0xBA: /* TSX */ |
| 107 | _X=_S; |
| 108 | X_ZN(_X); |
| 109 | break; |
| 110 | case 0x9A: /* TXS */ |
| 111 | _S=_X; |
| 112 | break; |
| 113 | |
| 114 | case 0xCA: /* DEX */ |
| 115 | _X--; |
| 116 | X_ZN(_X); |
| 117 | break; |
| 118 | case 0x88: /* DEY */ |
| 119 | _Y--; |
| 120 | X_ZN(_Y); |
| 121 | break; |
| 122 | |
| 123 | case 0xE8: /* INX */ |
| 124 | _X++; |
| 125 | X_ZN(_X); |
| 126 | break; |
| 127 | case 0xC8: /* INY */ |
| 128 | _Y++; |
| 129 | X_ZN(_Y); |
| 130 | break; |
| 131 | |
| 132 | case 0x18: /* CLC */ |
| 133 | _P&=~C_FLAG; |
| 134 | break; |
| 135 | case 0xD8: /* CLD */ |
| 136 | _P&=~D_FLAG; |
| 137 | break; |
| 138 | case 0x58: /* CLI */ |
| 139 | _P&=~I_FLAG; |
| 140 | break; |
| 141 | case 0xB8: /* CLV */ |
| 142 | _P&=~V_FLAG; |
| 143 | break; |
| 144 | |
| 145 | case 0x38: /* SEC */ |
| 146 | _P|=C_FLAG; |
| 147 | break; |
| 148 | case 0xF8: /* SED */ |
| 149 | _P|=D_FLAG; |
| 150 | break; |
| 151 | case 0x78: /* SEI */ |
| 152 | _P|=I_FLAG; |
| 153 | break; |
| 154 | |
| 155 | case 0xEA: /* NOP */ |
| 156 | break; |
| 157 | |
| 158 | case 0x0A: RMW_A(ASL); |
| 159 | case 0x06: RMW_ZP(ASL); |
| 160 | case 0x16: RMW_ZPX(ASL); |
| 161 | case 0x0E: RMW_AB(ASL); |
| 162 | case 0x1E: RMW_ABX(ASL); |
| 163 | |
| 164 | case 0xC6: RMW_ZP(DEC); |
| 165 | case 0xD6: RMW_ZPX(DEC); |
| 166 | case 0xCE: RMW_AB(DEC); |
| 167 | case 0xDE: RMW_ABX(DEC); |
| 168 | |
| 169 | case 0xE6: RMW_ZP(INC); |
| 170 | case 0xF6: RMW_ZPX(INC); |
| 171 | case 0xEE: RMW_AB(INC); |
| 172 | case 0xFE: RMW_ABX(INC); |
| 173 | |
| 174 | case 0x4A: RMW_A(LSR); |
| 175 | case 0x46: RMW_ZP(LSR); |
| 176 | case 0x56: RMW_ZPX(LSR); |
| 177 | case 0x4E: RMW_AB(LSR); |
| 178 | case 0x5E: RMW_ABX(LSR); |
| 179 | |
| 180 | case 0x2A: RMW_A(ROL); |
| 181 | case 0x26: RMW_ZP(ROL); |
| 182 | case 0x36: RMW_ZPX(ROL); |
| 183 | case 0x2E: RMW_AB(ROL); |
| 184 | case 0x3E: RMW_ABX(ROL); |
| 185 | |
| 186 | case 0x6A: RMW_A(ROR); |
| 187 | case 0x66: RMW_ZP(ROR); |
| 188 | case 0x76: RMW_ZPX(ROR); |
| 189 | case 0x6E: RMW_AB(ROR); |
| 190 | case 0x7E: RMW_ABX(ROR); |
| 191 | |
| 192 | case 0x69: LD_IM(ADC); |
| 193 | case 0x65: LD_ZP(ADC); |
| 194 | case 0x75: LD_ZPX(ADC); |
| 195 | case 0x6D: LD_AB(ADC); |
| 196 | case 0x7D: LD_ABX(ADC); |
| 197 | case 0x79: LD_ABY(ADC); |
| 198 | case 0x61: LD_IX(ADC); |
| 199 | case 0x71: LD_IY(ADC); |
| 200 | |
| 201 | case 0x29: LD_IM(AND); |
| 202 | case 0x25: LD_ZP(AND); |
| 203 | case 0x35: LD_ZPX(AND); |
| 204 | case 0x2D: LD_AB(AND); |
| 205 | case 0x3D: LD_ABX(AND); |
| 206 | case 0x39: LD_ABY(AND); |
| 207 | case 0x21: LD_IX(AND); |
| 208 | case 0x31: LD_IY(AND); |
| 209 | |
| 210 | case 0x24: LD_ZP(BIT); |
| 211 | case 0x2C: LD_AB(BIT); |
| 212 | |
| 213 | case 0xC9: LD_IM(CMP); |
| 214 | case 0xC5: LD_ZP(CMP); |
| 215 | case 0xD5: LD_ZPX(CMP); |
| 216 | case 0xCD: LD_AB(CMP); |
| 217 | case 0xDD: LD_ABX(CMP); |
| 218 | case 0xD9: LD_ABY(CMP); |
| 219 | case 0xC1: LD_IX(CMP); |
| 220 | case 0xD1: LD_IY(CMP); |
| 221 | |
| 222 | case 0xE0: LD_IM(CPX); |
| 223 | case 0xE4: LD_ZP(CPX); |
| 224 | case 0xEC: LD_AB(CPX); |
| 225 | |
| 226 | case 0xC0: LD_IM(CPY); |
| 227 | case 0xC4: LD_ZP(CPY); |
| 228 | case 0xCC: LD_AB(CPY); |
| 229 | |
| 230 | case 0x49: LD_IM(EOR); |
| 231 | case 0x45: LD_ZP(EOR); |
| 232 | case 0x55: LD_ZPX(EOR); |
| 233 | case 0x4D: LD_AB(EOR); |
| 234 | case 0x5D: LD_ABX(EOR); |
| 235 | case 0x59: LD_ABY(EOR); |
| 236 | case 0x41: LD_IX(EOR); |
| 237 | case 0x51: LD_IY(EOR); |
| 238 | |
| 239 | case 0xA9: LD_IM(LDA); |
| 240 | case 0xA5: LD_ZP(LDA); |
| 241 | case 0xB5: LD_ZPX(LDA); |
| 242 | case 0xAD: LD_AB(LDA); |
| 243 | case 0xBD: LD_ABX(LDA); |
| 244 | case 0xB9: LD_ABY(LDA); |
| 245 | case 0xA1: LD_IX(LDA); |
| 246 | case 0xB1: LD_IY(LDA); |
| 247 | |
| 248 | case 0xA2: LD_IM(LDX); |
| 249 | case 0xA6: LD_ZP(LDX); |
| 250 | case 0xB6: LD_ZPY(LDX); |
| 251 | case 0xAE: LD_AB(LDX); |
| 252 | case 0xBE: LD_ABY(LDX); |
| 253 | |
| 254 | case 0xA0: LD_IM(LDY); |
| 255 | case 0xA4: LD_ZP(LDY); |
| 256 | case 0xB4: LD_ZPX(LDY); |
| 257 | case 0xAC: LD_AB(LDY); |
| 258 | case 0xBC: LD_ABX(LDY); |
| 259 | |
| 260 | case 0x09: LD_IM(ORA); |
| 261 | case 0x05: LD_ZP(ORA); |
| 262 | case 0x15: LD_ZPX(ORA); |
| 263 | case 0x0D: LD_AB(ORA); |
| 264 | case 0x1D: LD_ABX(ORA); |
| 265 | case 0x19: LD_ABY(ORA); |
| 266 | case 0x01: LD_IX(ORA); |
| 267 | case 0x11: LD_IY(ORA); |
| 268 | |
| 269 | case 0xEB: /* (undocumented) */ |
| 270 | case 0xE9: LD_IM(SBC); |
| 271 | case 0xE5: LD_ZP(SBC); |
| 272 | case 0xF5: LD_ZPX(SBC); |
| 273 | case 0xED: LD_AB(SBC); |
| 274 | case 0xFD: LD_ABX(SBC); |
| 275 | case 0xF9: LD_ABY(SBC); |
| 276 | case 0xE1: LD_IX(SBC); |
| 277 | case 0xF1: LD_IY(SBC); |
| 278 | |
| 279 | case 0x85: ST_ZP(_A); |
| 280 | case 0x95: ST_ZPX(_A); |
| 281 | case 0x8D: ST_AB(_A); |
| 282 | case 0x9D: ST_ABX(_A); |
| 283 | case 0x99: ST_ABY(_A); |
| 284 | case 0x81: ST_IX(_A); |
| 285 | case 0x91: ST_IY(_A); |
| 286 | |
| 287 | case 0x86: ST_ZP(_X); |
| 288 | case 0x96: ST_ZPY(_X); |
| 289 | case 0x8E: ST_AB(_X); |
| 290 | |
| 291 | case 0x84: ST_ZP(_Y); |
| 292 | case 0x94: ST_ZPX(_Y); |
| 293 | case 0x8C: ST_AB(_Y); |
| 294 | |
| 295 | /* BCC */ |
| 296 | case 0x90: if(_P&C_FLAG) _PC++; else {JR();} break; |
| 297 | |
| 298 | /* BCS */ |
| 299 | case 0xB0: if(_P&C_FLAG) {JR();} else _PC++; break; |
| 300 | |
| 301 | /* BEQ */ |
| 302 | case 0xF0: if(_P&Z_FLAG) {JR();} else _PC++; break; |
| 303 | |
| 304 | /* BNE */ |
| 305 | case 0xD0: if(_P&Z_FLAG) _PC++; else {JR();} break; |
| 306 | |
| 307 | /* BMI */ |
| 308 | case 0x30: if(_P&N_FLAG) {JR();} else _PC++; break; |
| 309 | |
| 310 | /* BPL */ |
| 311 | case 0x10: if(_P&N_FLAG) _PC++; else {JR();} break; |
| 312 | |
| 313 | /* BVC */ |
| 314 | case 0x50: if(_P&V_FLAG) _PC++; else {JR();} break; |
| 315 | |
| 316 | /* BVS */ |
| 317 | case 0x70: if(_P&V_FLAG) {JR();} else _PC++; break; |
| 318 | |
| 319 | /* Here comes the undocumented instructions. Note that this implementation |
| 320 | may be "wrong". If so, please tell me. |
| 321 | */ |
| 322 | |
| 323 | /* AAC */ |
| 324 | case 0x2B: |
| 325 | case 0x0B: LD_IM(AND;_P&=~C_FLAG;_P|=_A>>7); |
| 326 | |
| 327 | /* AAX */ |
| 328 | case 0x87: ST_ZP(_A&_X); |
| 329 | case 0x97: ST_ZPY(_A&_X); |
| 330 | case 0x8F: ST_AB(_A&_X); |
| 331 | case 0x83: ST_IX(_A&_X); |
| 332 | |
| 333 | /* ARR - ARGH, MATEY! */ |
| 334 | case 0x6B: { |
| 335 | uint8 arrtmp; |
| 336 | LD_IM(AND;_P&=~V_FLAG;_P|=(_A^(_A>>1))&0x40;arrtmp=_A>>7;_A>>=1;_A|=(_P&C_FLAG)<<7;_P&=~C_FLAG;_P|=arrtmp;X_ZN(_A)); |
| 337 | } |
| 338 | /* ASR */ |
| 339 | case 0x4B: LD_IM(AND;LSRA); |
| 340 | |
| 341 | /* ATX(OAL) Is this(OR with $EE) correct? */ |
| 342 | case 0xAB: LD_IM(_A|=0xEE;AND;_X=_A); |
| 343 | |
| 344 | /* AXS */ |
| 345 | case 0xCB: LD_IM(AXS); |
| 346 | |
| 347 | /* DCP */ |
| 348 | case 0xC7: LD_ZP(DEC;CMP); |
| 349 | case 0xD7: LD_ZPX(DEC;CMP); |
| 350 | case 0xCF: LD_AB(DEC;CMP); |
| 351 | case 0xDF: LD_ABX(DEC;CMP); |
| 352 | case 0xDB: LD_ABY(DEC;CMP); |
| 353 | case 0xC3: LD_IX(DEC;CMP); |
| 354 | case 0xD3: LD_IY(DEC;CMP); |
| 355 | |
| 356 | /* ISC */ |
| 357 | case 0xE7: LD_ZP(INC;SBC); |
| 358 | case 0xF7: LD_ZPX(INC;SBC); |
| 359 | case 0xEF: LD_AB(INC;SBC); |
| 360 | case 0xFF: LD_ABX(INC;SBC); |
| 361 | case 0xFB: LD_ABY(INC;SBC); |
| 362 | case 0xE3: LD_IX(INC;SBC); |
| 363 | case 0xF3: LD_IY(INC;SBC); |
| 364 | |
| 365 | /* DOP */ |
| 366 | |
| 367 | case 0x04: _PC++;break; |
| 368 | case 0x14: _PC++;break; |
| 369 | case 0x34: _PC++;break; |
| 370 | case 0x44: _PC++;break; |
| 371 | case 0x54: _PC++;break; |
| 372 | case 0x64: _PC++;break; |
| 373 | case 0x74: _PC++;break; |
| 374 | |
| 375 | case 0x80: _PC++;break; |
| 376 | case 0x82: _PC++;break; |
| 377 | case 0x89: _PC++;break; |
| 378 | case 0xC2: _PC++;break; |
| 379 | case 0xD4: _PC++;break; |
| 380 | case 0xE2: _PC++;break; |
| 381 | case 0xF4: _PC++;break; |
| 382 | |
| 383 | /* KIL */ |
| 384 | |
| 385 | case 0x02: |
| 386 | case 0x12: |
| 387 | case 0x22: |
| 388 | case 0x32: |
| 389 | case 0x42: |
| 390 | case 0x52: |
| 391 | case 0x62: |
| 392 | case 0x72: |
| 393 | case 0x92: |
| 394 | case 0xB2: |
| 395 | case 0xD2: |
| 396 | case 0xF2:ADDCYC(0xFF); |
| 397 | _jammed=1; |
| 398 | _PC--; |
| 399 | break; |
| 400 | |
| 401 | /* LAR */ |
| 402 | case 0xBB: RMW_ABY(_S&=x;_A=_X=_S;X_ZN(_X)); |
| 403 | |
| 404 | /* LAX */ |
| 405 | case 0xA7: LD_ZP(LDA;LDX); |
| 406 | case 0xB7: LD_ZPY(LDA;LDX); |
| 407 | case 0xAF: LD_AB(LDA;LDX); |
| 408 | case 0xBF: LD_ABY(LDA;LDX); |
| 409 | case 0xA3: LD_IX(LDA;LDX); |
| 410 | case 0xB3: LD_IY(LDA;LDX); |
| 411 | |
| 412 | /* NOP */ |
| 413 | case 0x1A: |
| 414 | case 0x3A: |
| 415 | case 0x5A: |
| 416 | case 0x7A: |
| 417 | case 0xDA: |
| 418 | case 0xFA: break; |
| 419 | |
| 420 | /* RLA */ |
| 421 | case 0x27: RMW_ZP(ROL;AND); |
| 422 | case 0x37: RMW_ZPX(ROL;AND); |
| 423 | case 0x2F: RMW_AB(ROL;AND); |
| 424 | case 0x3F: RMW_ABX(ROL;AND); |
| 425 | case 0x3B: RMW_ABY(ROL;AND); |
| 426 | case 0x23: RMW_IX(ROL;AND); |
| 427 | case 0x33: RMW_IY(ROL;AND); |
| 428 | |
| 429 | /* RRA */ |
| 430 | case 0x67: RMW_ZP(ROR;ADC); |
| 431 | case 0x77: RMW_ZPX(ROR;ADC); |
| 432 | case 0x6F: RMW_AB(ROR;ADC); |
| 433 | case 0x7F: RMW_ABX(ROR;ADC); |
| 434 | case 0x7B: RMW_ABY(ROR;ADC); |
| 435 | case 0x63: RMW_IX(ROR;ADC); |
| 436 | case 0x73: RMW_IY(ROR;ADC); |
| 437 | |
| 438 | /* SLO */ |
| 439 | case 0x07: RMW_ZP(ASL;ORA); |
| 440 | case 0x17: RMW_ZPX(ASL;ORA); |
| 441 | case 0x0F: RMW_AB(ASL;ORA); |
| 442 | case 0x1F: RMW_ABX(ASL;ORA); |
| 443 | case 0x1B: RMW_ABY(ASL;ORA); |
| 444 | case 0x03: RMW_IX(ASL;ORA); |
| 445 | case 0x13: RMW_IY(ASL;ORA); |
| 446 | |
| 447 | /* SRE */ |
| 448 | case 0x47: RMW_ZP(LSR;EOR); |
| 449 | case 0x57: RMW_ZPX(LSR;EOR); |
| 450 | case 0x4F: RMW_AB(LSR;EOR); |
| 451 | case 0x5F: RMW_ABX(LSR;EOR); |
| 452 | case 0x5B: RMW_ABY(LSR;EOR); |
| 453 | case 0x43: RMW_IX(LSR;EOR); |
| 454 | case 0x53: RMW_IY(LSR;EOR); |
| 455 | |
| 456 | /* AXA - SHA */ |
| 457 | case 0x93: ST_IY(_A&_X&(((A-_Y)>>8)+1)); |
| 458 | case 0x9F: ST_ABY(_A&_X&(((A-_Y)>>8)+1)); |
| 459 | |
| 460 | /* SYA */ |
| 461 | case 0x9C: ST_ABX(_Y&(((A-_X)>>8)+1)); |
| 462 | |
| 463 | /* SXA */ |
| 464 | case 0x9E: ST_ABY(_X&(((A-_Y)>>8)+1)); |
| 465 | |
| 466 | /* XAS */ |
| 467 | case 0x9B: _S=_A&_X;ST_ABY(_S& (((A-_Y)>>8)+1) ); |
| 468 | |
| 469 | /* TOP */ |
| 470 | case 0x0C: LD_AB(;); |
| 471 | case 0x1C: |
| 472 | case 0x3C: |
| 473 | case 0x5C: |
| 474 | case 0x7C: |
| 475 | case 0xDC: |
| 476 | case 0xFC: LD_ABX(;); |
| 477 | |
| 478 | /* XAA - BIG QUESTION MARK HERE */ |
| 479 | case 0x8B: _A|=0xEE; _A&=_X; LD_IM(AND); |
notaz.gp2x.de / fceu.git / blame