ops.h

   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);