sys/src/games/nes/cpu.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include "dat.h"
   4 #include "fns.h"
   5
   6 u16int pc, curpc;
   7 u8int rA, rX, rY, rS, rP;
   8 int nmi;
   9 extern int map;
  10
  11 static u8int
  12 fetch8(void)
  13 {
  14         return memread(pc++);
  15 }
  16
  17 static u16int
  18 fetch16(void)
  19 {
  20         u16int r;
  21
  22         r = memread(pc++);
  23         r |= memread(pc++) << 8;
  24         return r;
  25 }
  26
  27 static void
  28 push8(u8int v)
  29 {
  30         memwrite(0x100 | rS--, v);
  31 }
  32
  33 static void
  34 push16(u16int v)
  35 {
  36         memwrite(0x100 | rS--, v >> 8);
  37         memwrite(0x100 | rS--, v);
  38 }
  39
  40 static u8int
  41 pop8(void)
  42 {
  43         return memread(0x100 | ++rS);
  44 }
  45
  46 static u16int
  47 pop16(void)
  48 {
  49         u16int v;
  50
  51         v = memread(0x100 | ++rS);
  52         v |= memread(0x100 | ++rS) << 8;
  53         return v;
  54 }
  55
  56 #define imm() fetch8()
  57 #define zp() memread(fetch8())
  58 #define zpX() memread((u8int)(fetch8()+rX))
  59 #define zpY() memread((u8int)(fetch8()+rY))
  60 #define abso() memread(fetch16())
  61 #define absX() memread(a=fetch16()+rX)
  62 #define absY() memread(a=fetch16()+rY)
  63 #define indX() memread(aindX())
  64 #define indY(c) memread(aindY(c))
  65
  66 static u16int
  67 aindX(void)
  68 {
  69         u8int r;
  70         u16int a;
  71
  72         r = fetch8() + rX;
  73         a = memread(r++);
  74         a |= memread(r) << 8;
  75         return a;
  76 }
  77
  78 static u16int
  79 aindY(int *c)
  80 {
  81         u8int r;
  82         u16int a;
  83
  84         r = fetch8();
  85         a = memread(r++) + rY;
  86         *c = a > 0xFF;
  87         a += memread(r) << 8;
  88         return a;
  89 }
  90
  91 static void
  92 adc(u8int d)
  93 {
  94         int r;
  95
  96         r = rA + d + (rP & FLAGC);
  97         rP &= ~(FLAGN | FLAGZ | FLAGV | FLAGC);
  98         if(r > 0xFF) rP |= FLAGC;
  99         if(r & 0x80) rP |= FLAGN;
 100         if((~(rA ^ d) & (rA ^ r)) & 0x80) rP |= FLAGV;
 101         rA = r;
 102         if(rA == 0) rP |= FLAGZ;
 103 }
 104
 105 static u8int
 106 nz(u8int d)
 107 {
 108         rP &= ~(FLAGN | FLAGZ);
 109         if(d & 0x80) rP |= FLAGN;
 110         if(d == 0) rP |= FLAGZ;
 111         return d;
 112 }
 113
 114 static void
 115 asl(u16int a)
 116 {
 117         u8int v;
 118
 119         rP &= ~(FLAGN | FLAGZ | FLAGC);
 120         v = memread(a);
 121         if(v & 0x80) rP |= FLAGC;
 122         v <<= 1;
 123         if(v == 0) rP |= FLAGZ;
 124         if(v & 0x80) rP |= FLAGN;
 125         memwrite(a, v);
 126 }
 127
 128 static void
 129 lsr(u16int a)
 130 {
 131         u8int v;
 132
 133         rP &= ~(FLAGN | FLAGZ | FLAGC);
 134         v = memread(a);
 135         rP |= v & 1;
 136         v >>= 1;
 137         if(v == 0) rP |= FLAGZ;
 138         if(v & 0x80) rP |= FLAGN;
 139         memwrite(a, v);
 140 }
 141
 142 static int
 143 branch(void)
 144 {
 145         signed char t;
 146         u16int npc;
 147
 148         t = fetch8();
 149         npc = pc + t;
 150         if((npc ^ pc) >> 8){
 151                 pc = npc;
 152                 return 4;
 153         }
 154         pc = npc;
 155         return 3;
 156 }
 157
 158 static void
 159 cmp(u8int a, u8int d)
 160 {
 161         rP &= ~(FLAGN | FLAGZ | FLAGC);
 162         if(a == d) rP |= FLAGZ;
 163         if(a >= d) rP |= FLAGC;
 164         if((a - d) & 0x80) rP |= FLAGN;
 165 }
 166
 167 static void
 168 dec(u16int a)
 169 {
 170         memwrite(a, nz(memread(a) - 1));
 171 }
 172
 173 static void
 174 inc(u16int a)
 175 {
 176         u8int v;
 177
 178         v = memread(a);
 179         memwrite(a, v);
 180         v = nz(v + 1);
 181         if(!(map == 1 && a >= 0x8000))
 182                 memwrite(a, v);
 183 }
 184
 185 static void
 186 rol(u16int a)
 187 {
 188         u8int v, b;
 189
 190         v = memread(a);
 191         b = rP & FLAGC;
 192         rP &= ~(FLAGC | FLAGN | FLAGZ);
 193         if(v & 0x80) rP |= FLAGC;
 194         v = (v << 1) | b;
 195         if(v & 0x80) rP |= FLAGN;
 196         if(v == 0) rP |= FLAGZ;
 197         memwrite(a, v);
 198 }
 199
 200 static void
 201 ror(u16int a)
 202 {
 203         u8int v, b;
 204
 205         v = memread(a);
 206         b = rP & FLAGC;
 207         rP &= ~(FLAGC | FLAGN | FLAGZ);
 208         rP |= v & 1;
 209         v = (v >> 1) | (b << 7);
 210         if(v & 0x80) rP |= FLAGN;
 211         if(v == 0) rP |= FLAGZ;
 212         memwrite(a, v);
 213 }
 214
 215 static void
 216 sbc(u8int d)
 217 {
 218         int r;
 219
 220         r = rA + (u8int)~d + (rP & FLAGC);
 221         rP &= ~(FLAGZ | FLAGV | FLAGC | FLAGN);
 222         if(r > 0xFF) rP |= FLAGC;
 223         if(((rA ^ d) & (rA ^ r)) & 0x80) rP |= FLAGV;
 224         rA = r;
 225         if(rA == 0) rP |= FLAGZ;
 226         if(rA & 0x80) rP |= FLAGN;
 227 }
 228
 229 static void
 230 interrupt(int nmi, int brk)
 231 {
 232         push16(pc);
 233         push8(rP | 0x20 | (brk << 4));
 234         pc = memread(0xFFFA | (!nmi << 2));
 235         pc |= memread(0xFFFB | (!nmi << 2)) << 8;
 236         rP |= FLAGI;
 237 }
 238
 239 int trace;
 240
 241 int
 242 step(void)
 243 {
 244         u8int op;
 245         u16int a, v;
 246         int c;
 247
 248         if(nmi){
 249                 interrupt(1, 0);
 250                 nmi = 0;
 251                 return 7;
 252         }
 253         curpc = pc;
 254         op = fetch8();
 255         if(trace)
 256                 print("%x %x %x %x %x %x %x %x\n", curpc, op, rA, rX, rY, rS, rP, memread(0x2c));
 257         switch(op){
 258         case 0x00: pc++; interrupt(0, 1); return 7;
 259         case 0x01: nz(rA |= indX()); return 6;
 260         case 0x05: nz(rA |= zp()); return 3;
 261         case 0x06: asl(fetch8()); return 5;
 262         case 0x08: push8(rP | 0x30); return 3;
 263         case 0x09: nz(rA |= imm()); return 2;
 264         case 0x0A:
 265                 rP &= ~(FLAGN | FLAGZ | FLAGC);
 266                 if(rA & 0x80) rP |= FLAGC;
 267                 rA <<= 1;
 268                 if(rA == 0) rP |= FLAGZ;
 269                 if(rA & 0x80) rP |= FLAGN;
 270                 return 2;
 271         case 0x0D: nz(rA |= abso()); return 4;
 272         case 0x0E: asl(fetch16()); return 6;
 273         case 0x10: if((rP & FLAGN) == 0) return branch(); pc++; return 2;
 274         case 0x11: nz(rA |= indY(&c)); return 5+c;
 275         case 0x15: nz(rA |= zpX()); return 4;
 276         case 0x16: asl((u8int)(fetch8() + rX)); return 6;
 277         case 0x18: rP &= ~FLAGC; return 2;
 278         case 0x19: nz(rA |= absY()); return 4 + ((u8int)a < rY);
 279         case 0x1D: nz(rA |= absX()); return 4 + ((u8int)a < rX);
 280         case 0x1E: asl(fetch16() + rX); return 7;
 281         case 0x20: push16(pc+1); pc = fetch16(); return 6;
 282         case 0x21: nz(rA &= indX()); return 6;
 283         case 0x24:
 284                 a = memread(fetch8());
 285                 rP &= ~(FLAGN | FLAGZ | FLAGV);
 286                 rP |= a & 0xC0;
 287                 if((a & rA) == 0) rP |= FLAGZ;
 288                 return 3;
 289         case 0x25: nz(rA &= zp()); return 3;
 290         case 0x26: rol(fetch8()); return 5;
 291         case 0x28: rP = pop8() & 0xcf; return 4;
 292         case 0x29: nz(rA &= imm()); return 2;
 293         case 0x2A:
 294                 a = rP & FLAGC;
 295                 rP &= ~(FLAGC | FLAGZ | FLAGN);
 296                 if(rA & 0x80) rP |= FLAGC;
 297                 rA = (rA << 1) | a;
 298                 if(rA & 0x80) rP |= FLAGN;
 299                 if(rA == 0) rP |= FLAGZ;
 300                 return 2;
 301         case 0x2C:
 302                 a = memread(fetch16());
 303                 rP &= ~(FLAGN | FLAGZ | FLAGV);
 304                 rP |= a & 0xC0;
 305                 if((a & rA) == 0) rP |= FLAGZ;
 306                 return 4;
 307         case 0x2D: nz(rA &= abso()); return 4;
 308         case 0x2E: rol(fetch16()); return 6;
 309         case 0x30: if((rP & FLAGN) != 0) return branch(); pc++; return 3;
 310         case 0x31: nz(rA &= indY(&c)); return 5+c;
 311         case 0x35: nz(rA &= zpX()); return 4;
 312         case 0x36: rol((u8int)(fetch8() + rX)); return 6;
 313         case 0x38: rP |= FLAGC; return 2;
 314         case 0x39: nz(rA &= absY()); return 4 + ((u8int)a < rY);
 315         case 0x3E: rol(fetch16() + rX); return 7;
 316         case 0x3D: nz(rA &= absX()); return 4 + ((u8int)a < rX);
 317         case 0x40: rP = pop8() & 0xcf; pc = pop16(); return 6;
 318         case 0x41: nz(rA ^= indX()); return 6;
 319         case 0x45: nz(rA ^= zp()); return 3;
 320         case 0x46: lsr(fetch8()); return 5;
 321         case 0x48: push8(rA); return 3;
 322         case 0x49: nz(rA ^= imm()); return 2;
 323         case 0x4A:
 324                 rP &= ~(FLAGN | FLAGZ | FLAGC);
 325                 rP |= rA & 1;
 326                 rA >>= 1;
 327                 if(rA == 0) rP |= FLAGZ;
 328                 if(rA & 0x80) rP |= FLAGN;
 329                 return 2;
 330         case 0x4C: pc = fetch16(); return 3;
 331         case 0x4D: nz(rA ^= abso()); return 4;
 332         case 0x4E: lsr(fetch16()); return 6;
 333         case 0x51: nz(rA ^= indY(&c)); return 5+c;
 334         case 0x56: lsr((u8int)(fetch8() + rX)); return 6;
 335         case 0x58: rP &= ~FLAGI; return 2;
 336         case 0x50: if((rP & FLAGV) == 0) return branch(); pc++; return 3;
 337         case 0x55: nz(rA ^= zpX()); return 4;
 338         case 0x59: nz(rA ^= absY()); return 4 + ((u8int)a < rX);
 339         case 0x5D: nz(rA ^= absX()); return 4 + ((u8int)a < rX);
 340         case 0x5E: lsr(fetch16() + rX); return 7;
 341         case 0x60: pc = pop16() + 1; return 6;
 342         case 0x61: adc(indX()); return 6;
 343         case 0x65: adc(zp()); return 3;
 344         case 0x66: ror(fetch8()); return 5;
 345         case 0x68: nz(rA = pop8()); return 4;
 346         case 0x69: adc(imm()); return 2;
 347         case 0x6A:
 348                 a = rP & FLAGC;
 349                 rP &= ~(FLAGC | FLAGN | FLAGZ);
 350                 rP |= rA & 1;
 351                 rA = (rA >> 1) | (a << 7);
 352                 if(rA & 0x80) rP |= FLAGN;
 353                 if(rA == 0) rP |= FLAGZ;
 354                 return 2;
 355         case 0x6C: v = fetch16(); pc = memread(v) | (memread((v & 0xFF00) | (u8int)(v+1)) << 8); return 5;
 356         case 0x6D: adc(abso()); return 4;
 357         case 0x6E: ror(fetch16()); return 6;
 358         case 0x70: if((rP & FLAGV) != 0) return branch(); pc++; return 3;
 359         case 0x71: adc(indY(&c)); return 5+c;
 360         case 0x75: adc(zpX()); return 4;
 361         case 0x76: ror((u8int)(fetch8() + rX)); return 6;
 362         case 0x78: rP |= FLAGI; return 2;
 363         case 0x79: adc(absY()); return 4 + ((u8int)a < rY);
 364         case 0x7D: adc(absX()); return 4 + ((u8int)a < rX);
 365         case 0x7E: ror(fetch16() + rX); return 7;
 366         case 0x81: memwrite(aindX(), rA); return 6;
 367         case 0x84: memwrite(fetch8(), rY); return 3;
 368         case 0x85: memwrite(fetch8(), rA); return 3;
 369         case 0x86: memwrite(fetch8(), rX); return 3;
 370         case 0x88: nz(--rY); return 2;
 371         case 0x8A: nz(rA = rX); return 2;
 372         case 0x8C: memwrite(fetch16(), rY); return 4;
 373         case 0x8D: memwrite(fetch16(), rA); return 4;
 374         case 0x8E: memwrite(fetch16(), rX); return 4;
 375         case 0x90: if((rP & FLAGC) == 0) return branch(); pc++; return 3;
 376         case 0x91: memwrite(aindY(&c), rA); return 6;
 377         case 0x94: memwrite((u8int)(fetch8() + rX), rY); return 4;
 378         case 0x95: memwrite((u8int)(fetch8() + rX), rA); return 4;
 379         case 0x96: memwrite((u8int)(fetch8() + rY), rX); return 4;
 380         case 0x98: nz(rA = rY); return 2;
 381         case 0x99: memwrite(fetch16() + rY, rA); return 5;
 382         case 0x9A: rS = rX; return 2;
 383         case 0x9D: memwrite(fetch16() + rX, rA); return 5;
 384         case 0xA0: nz(rY = imm()); return 2;
 385         case 0xA1: nz(rA = indX()); return 6;
 386         case 0xA2: nz(rX = imm()); return 2;
 387         case 0xA4: nz(rY = zp()); return 3;
 388         case 0xA5: nz(rA = zp()); return 3;
 389         case 0xA6: nz(rX = zp()); return 3;
 390         case 0xA8: nz(rY = rA); return 2;
 391         case 0xA9: nz(rA = imm()); return 2;
 392         case 0xAA: nz(rX = rA); return 2;
 393         case 0xAC: nz(rY = abso()); return 4;
 394         case 0xAE: nz(rX = abso()); return 4;
 395         case 0xAD: nz(rA = abso()); return 4;
 396         case 0xB0: if((rP & FLAGC) != 0) return branch(); pc++; return 3;
 397         case 0xB1: nz(rA = indY(&c)); return 5+c;
 398         case 0xB4: nz(rY = zpX()); return 4;
 399         case 0xB5: nz(rA = zpX()); return 4;
 400         case 0xB6: nz(rX = zpY()); return 4;
 401         case 0xB8: rP &= ~FLAGV; return 2;
 402         case 0xB9: nz(rA = absY()); return 4 + ((u8int)a < rY);
 403         case 0xBA: nz(rX = rS); return 2;
 404         case 0xBC: nz(rY = absX()); return 4 + ((u8int)a < rX);
 405         case 0xBD: nz(rA = absX()); return 4 + ((u8int)a < rX);
 406         case 0xBE: nz(rX = absY()); return 4 + ((u8int)a < rY);
 407         case 0xC1: cmp(rA, indX()); return 6;
 408         case 0xC5: cmp(rA, zp()); return 3;
 409         case 0xC9: cmp(rA, imm()); return 2;
 410         case 0xCD: cmp(rA, abso()); return 4;
 411         case 0xD0: if((rP & FLAGZ) == 0) return branch(); pc++; return 3;
 412         case 0xD1: cmp(rA, indY(&c)); return 5 + c;
 413         case 0xD5: cmp(rA, zpX()); return 4;
 414         case 0xD8: rP &= ~FLAGD; return 2;
 415         case 0xD9: cmp(rA, absY()); return 4 + ((u8int)a < rY);
 416         case 0xDD: cmp(rA, absX()); return 4 + ((u8int)a < rX);
 417         case 0xC0: cmp(rY, imm()); return 2;
 418         case 0xC4: cmp(rY, zp()); return 3;
 419         case 0xC6: dec(fetch8()); return 5;
 420         case 0xC8: nz(++rY); return 2;
 421         case 0xCA: nz(--rX); return 2;
 422         case 0xCC: cmp(rY, abso()); return 4;
 423         case 0xCE: dec(fetch16()); return 6;
 424         case 0xD6: dec((u8int)(fetch8() + rX)); return 6;
 425         case 0xDE: dec(fetch16() + rX); return 7;
 426         case 0xE0: cmp(rX, imm()); return 2;
 427         case 0xE1: sbc(indX()); return 6;
 428         case 0xE4: cmp(rX, zp()); return 3;
 429         case 0xE5: sbc(zp()); return 3;
 430         case 0xE6: inc(fetch8()); return 5;
 431         case 0xE8: nz(++rX); return 2;
 432         case 0xE9: sbc(imm()); return 2;
 433         case 0xEA: return 2;
 434         case 0xEC: cmp(rX, abso()); return 4;
 435         case 0xED: sbc(abso()); return 4;
 436         case 0xEE: inc(fetch16()); return 6;
 437         case 0xF0: if((rP & FLAGZ) != 0) return branch(); pc++; return 3;
 438         case 0xF1: sbc(indY(&c)); return 5+c;
 439         case 0xF5: sbc(zpX()); return 4;
 440         case 0xF6: inc((u8int)(fetch8() + rX)); return 6;
 441         case 0xF8: rP |= FLAGD; return 2;
 442         case 0xF9: sbc(absY()); return 4 + ((u8int)a < rY);
 443         case 0xFD: sbc(absX()); return 4 + ((u8int)a < rX);
 444         case 0xFE: inc(fetch16() + rX); return 7;
 445         default:
 446                 print("undefined %#x (pc %#x)\n", op, curpc);
 447                 return 2;
 448         }
 449 }