SayoriOS  0.3.3
cpu.c
1 #include "common.h"
2 #include "lib/stdio.h"
3 #include "mem.h"
4 #include "rom.h"
5 #include "interrupt.h"
6 #include "timer.h"
7 
8 #define set_HL(x) do {unsigned int macro = (x); c.L = macro&0xFF; c.H = macro>>8;} while(0)
9 #define set_BC(x) do {unsigned int macro = (x); c.C = macro&0xFF; c.B = macro>>8;} while(0)
10 #define set_DE(x) do {unsigned int macro = (x); c.E = macro&0xFF; c.D = macro>>8;} while(0)
11 #define set_AF(x) do {unsigned int macro = (x); c.F = macro&0xFF; c.A = macro>>8;} while(0)
12 
13 #define get_AF() ((c.A<<8) | c.F)
14 #define get_BC() ((c.B<<8) | c.C)
15 #define get_DE() ((c.D<<8) | c.E)
16 #define get_HL() ((c.H<<8) | c.L)
17 
18 /* Flags */
19 #define set_Z(x) c.F = ((c.F&0x7F) | ((x)<<7))
20 #define set_N(x) c.F = ((c.F&0xBF) | ((x)<<6))
21 #define set_H(x) c.F = ((c.F&0xDF) | ((x)<<5))
22 #define set_C(x) c.F = ((c.F&0xEF) | ((x)<<4))
23 
24 #define flag_Z !!((c.F & 0x80))
25 #define flag_N !!((c.F & 0x40))
26 #define flag_H !!((c.F & 0x20))
27 #define flag_C !!((c.F & 0x10))
28 
29 /* Opcodes */
30 #define INC(x) \
31  x++; \
32  set_Z(!x); \
33  set_H((x & 0xF) == 0); \
34  set_N(0); \
35  c.cycles += 1;
36 
37 #define DEC(x) \
38  x--; \
39  set_Z(!x); \
40  set_N(1); \
41  set_H((x & 0xF) == 0xF); \
42  c.cycles += 1;
43 
44 #define LDRR(x, y) \
45  x = y; \
46  c.cycles += 1;
47 
48 #define LDRIMM8(x) \
49  x = mem_get_byte(c.PC); \
50  c.PC += 1; \
51  c.cycles += 2;
52 
53 #define ANDR(x) \
54  c.A &= x; \
55  set_Z(!c.A); \
56  set_H(1); \
57  set_N(0); \
58  set_C(0); \
59  c.cycles += 1;
60 
61 #define XORR(x) \
62  c.A ^= x; \
63  set_Z(!c.A); \
64  set_H(0); \
65  set_N(0); \
66  set_C(0); \
67  c.cycles += 1;
68 
69 #define ORR(x) \
70  c.A |= x; \
71  set_Z(!c.A); \
72  set_H(0); \
73  set_N(0); \
74  set_C(0); \
75  c.cycles += 1;
76 
77 #define CPR(x) \
78  set_C((c.A - x) < 0); \
79  set_H(((c.A - x)&0xF) > (c.A&0xF)); \
80  set_Z(c.A == x); \
81  set_N(1); \
82  c.cycles += 1;
83 
84 #define SUBR(x) \
85  set_C((c.A - x) < 0); \
86  set_H(((c.A - x)&0xF) > (c.A&0xF)); \
87  c.A -= x; \
88  set_Z(!c.A); \
89  set_N(1); \
90  c.cycles += 1;
91 
92 struct CPU {
93  unsigned char H;
94  unsigned char L;
95 
96  unsigned char D;
97  unsigned char E;
98 
99  unsigned char B;
100  unsigned char C;
101 
102  unsigned char A;
103  unsigned char F;
104 
105  unsigned short SP;
106  unsigned short PC;
107  unsigned int cycles;
108 };
109 
110 static struct CPU c;
111 static int is_debugged;
112 static int halted;
113 static int ei_flag;
114 
115 void cpu_init(void)
116 {
117  set_AF(0x01B0);
118  set_BC(0x0013);
119  set_DE(0x00D8);
120  set_HL(0x014D);
121  c.SP = 0xFFFE;
122 #ifdef DEBUG
123  c.PC = 0x0100;
124 #else
125  c.PC = 0;
126 #endif
127  c.cycles = 0;
128  is_debugged = 0;
129 }
130 
131 static unsigned short get_word_ticked(unsigned short i)
132 {
133  unsigned short word;
134 
135  word = mem_get_byte(i);
136  c.cycles += 1;
137  timer_cycle();
138  word |= (mem_get_byte(i+1)<<8);
139  c.cycles += 1;
140  timer_cycle();
141 
142  return word;
143 }
144 
145 static void write_word_ticked(unsigned short d, unsigned short i)
146 {
147  mem_write_byte(d+1, i >> 8);
148  c.cycles += 1;
149  timer_cycle();
150  mem_write_byte(d, i & 0xFF);
151  c.cycles += 1;
152  timer_cycle();
153 }
154 
155 static void RLC(unsigned char reg)
156 {
157  unsigned char t, old;
158 
159  switch(reg)
160  {
161  case 0: /* B */
162  old = !!(c.B&0x80);
163  c.B = (c.B << 1) | old;
164  set_C(old);
165  set_Z(!c.B);
166  break;
167  case 1: /* C */
168  old = !!(c.C&0x80);
169  set_C(old);
170  c.C = c.C<<1 | old;
171  set_Z(!c.C);
172  break;
173  case 2: /* D */
174  old = !!(c.D&0x80);
175  set_C(old);
176  c.D = c.D<<1 | old;
177  set_Z(!c.D);
178  break;
179  case 3: /* E */
180  old = !!(c.E&0x80);
181  set_C(old);
182  c.E = c.E<<1 | old;
183  set_Z(!c.E);
184  break;
185  case 4: /* H */
186  old = !!(c.H&0x80);
187  set_C(old);
188  c.H = c.H<<1 | old;
189  set_Z(!c.H);
190  break;
191  case 5: /* L */
192  old = !!(c.L&0x80);
193  set_C(old);
194  c.L = c.L<<1 | old;
195  set_Z(!c.L);
196  break;
197  case 6: /* (HL) */
198  c.cycles += 1;
199  timer_cycle();
200  t = mem_get_byte(get_HL());
201  old = !!(t&0x80);
202  set_C(old);
203  t = t<<1 | old;
204  c.cycles += 1;
205  timer_cycle();
206  mem_write_byte(get_HL(), t);
207  set_Z(!t);
208  break;
209  case 7: /* A */
210  old = !!(c.A&0x80);
211  c.A = (c.A<<1) | old;
212  set_C(old);
213  set_Z(!c.A);
214  break;
215  }
216 
217  set_N(0);
218  set_H(0);
219 }
220 
221 static void RRC(unsigned char reg)
222 {
223  unsigned char t, old;
224 
225  switch(reg)
226  {
227  case 0: /* B */
228  old = c.B&1;
229  set_C(old);
230  c.B = c.B>>1 | old<<7;
231  set_Z(!c.B);
232  break;
233  case 1: /* C */
234  old = c.C&1;
235  set_C(old);
236  c.C = c.C>>1 | old<<7;
237  set_Z(!c.C);
238  break;
239  case 2: /* D */
240  old = c.D&1;
241  set_C(old);
242  c.D = c.D>>1 | old<<7;
243  set_Z(!c.D);
244  break;
245  case 3: /* E */
246  old = c.E&1;
247  set_C(old);
248  c.E = c.E>>1 | old<<7;
249  set_Z(!c.E);
250  break;
251  case 4: /* H */
252  old = c.H&1;
253  set_C(old);
254  c.H = c.H>>1 | old<<7;
255  set_Z(!c.H);
256  break;
257  case 5: /* L */
258  old = c.L&1;
259  set_C(old);
260  c.L = c.L>>1 | old<<7;
261  set_Z(!c.L);
262  break;
263  case 6: /* (HL) */
264  c.cycles += 1;
265  timer_cycle();
266  t = mem_get_byte(get_HL());
267  old = t;
268  set_C(old);
269  t = t>>1 | old<<7;
270  c.cycles += 1;
271  timer_cycle();
272  mem_write_byte(get_HL(), t);
273  set_Z(!t);
274  break;
275  case 7: /* A */
276  old = c.A&1;
277  set_C(old);
278  c.A = c.A>>1 | old<<7;
279  set_Z(!c.A);
280  break;
281  }
282 
283  set_N(0);
284  set_H(0);
285 }
286 
287 static void RL(unsigned char reg)
288 {
289  unsigned char t, t2;
290 
291  switch(reg)
292  {
293  case 0: /* B */
294  t2 = flag_C;
295  set_C(!!(c.B&0x80));
296  c.B = (c.B << 1) | !!(t2);
297  set_Z(!c.B);
298  break;
299  case 1: /* C */
300  t2 = flag_C;
301  set_C(!!(c.C&0x80));
302  c.C = (c.C << 1) | !!(t2);
303  set_Z(!c.C);
304  break;
305  case 2: /* D */
306  t2 = flag_C;
307  set_C(!!(c.D&0x80));
308  c.D = (c.D << 1) | !!(t2);
309  set_Z(!c.D);
310  break;
311  case 3: /* E */
312  t2 = flag_C;
313  set_C(!!(c.E&0x80));
314  c.E = (c.E << 1) | !!(t2);
315  set_Z(!c.E);
316  break;
317  case 4: /* H */
318  t2 = flag_C;
319  set_C(!!(c.H&0x80));
320  c.H = (c.H << 1) | !!(t2);
321  set_Z(!c.H);
322  break;
323  case 5: /* L */
324  t2 = flag_C;
325  set_C(!!(c.L&0x80));
326  c.L = (c.L << 1) | !!(t2);
327  set_Z(!c.L);
328  break;
329  case 6: /* (HL) */
330  c.cycles += 1;
331  timer_cycle();
332  t = mem_get_byte(get_HL());
333  t2 = flag_C;
334  set_C(!!(t&0x80));
335  t = (t << 1) | !!(t2);
336  c.cycles += 1;
337  timer_cycle();
338  mem_write_byte(get_HL(), t);
339  set_Z(!t);
340  break;
341  case 7: /* A */
342  t2 = flag_C;
343  set_C(!!(c.A&0x80));
344  c.A = (c.A << 1) | !!(t2);
345  set_Z(!c.A);
346  break;
347  }
348 
349  set_N(0);
350  set_H(0);
351 }
352 
353 static void RR(unsigned char reg)
354 {
355  unsigned char t, t2;
356 
357  switch(reg)
358  {
359  case 0: /* B */
360  t2 = flag_C;
361  set_C(c.B&1);
362  c.B = (c.B >> 1) | t2<<7;
363  set_Z(!c.B);
364  break;
365  case 1: /* C */
366  t2 = flag_C;
367  set_C(c.C&1);
368  c.C = (c.C >> 1) | t2<<7;
369  set_Z(!c.C);
370  break;
371  case 2: /* D */
372  t2 = flag_C;
373  set_C(c.D&1);
374  c.D = (c.D >> 1) | t2<<7;
375  set_Z(!c.D);
376  break;
377  case 3: /* E */
378  t2 = flag_C;
379  set_C(c.E&1);
380  c.E = (c.E >> 1) | t2<<7;
381  set_Z(!c.E);
382  break;
383  case 4: /* H */
384  t2 = flag_C;
385  set_C(c.H&1);
386  c.H = (c.H >> 1) | t2<<7;
387  set_Z(!c.H);
388  break;
389  case 5: /* L */
390  t2 = flag_C;
391  set_C(c.L&1);
392  c.L = (c.L >> 1) | t2<<7;
393  set_Z(!c.L);
394  break;
395  case 6: /* (HL) */
396  c.cycles += 1;
397  timer_cycle();
398  t = mem_get_byte(get_HL());
399  t2 = flag_C;
400  set_C(t&1);
401  t = (t >> 1) | t2<<7;
402  set_Z(!t);
403  c.cycles += 1;
404  timer_cycle();
405  mem_write_byte(get_HL(), t);
406  break;
407  case 7: /* A */
408  t2 = flag_C;
409  set_C(c.A&1);
410  c.A = (c.A >> 1) | (t2<<7);
411  set_Z(!c.A);
412  break;
413  }
414  set_N(0);
415  set_H(0);
416 }
417 
418 static void SLA(unsigned char reg)
419 {
420  unsigned char t;
421 
422  switch(reg)
423  {
424  case 0: /* B */
425  set_C(!!(c.B & 0x80));
426  c.B = c.B << 1;
427  set_Z(!c.B);
428  break;
429  case 1: /* C */
430  set_C(!!(c.C & 0x80));
431  c.C = c.C << 1;
432  set_Z(!c.C);
433  break;
434  case 2: /* D */
435  set_C(!!(c.D & 0x80));
436  c.D = c.D << 1;
437  set_Z(!c.D);
438  break;
439  case 3: /* E */
440  set_C(!!(c.E & 0x80));
441  c.E = c.E << 1;
442  set_Z(!c.E);
443  break;
444  case 4: /* H */
445  set_C(!!(c.H & 0x80));
446  c.H = c.H << 1;
447  set_Z(!c.H);
448  break;
449  case 5: /* L */
450  set_C(!!(c.L & 0x80));
451  c.L = c.L << 1;
452  set_Z(!c.L);
453  break;
454  case 6: /* (HL) */
455  c.cycles += 1;
456  timer_cycle();
457  t = mem_get_byte(get_HL());
458  set_C(!!(t & 0x80));
459  t = t << 1;
460  c.cycles += 1;
461  timer_cycle();
462  mem_write_byte(get_HL(), t);
463  set_Z(!t);
464  break;
465  case 7: /* A */
466  set_C(!!(c.A & 0x80));
467  c.A = c.A << 1;
468  set_Z(!c.A);
469  break;
470  }
471 
472  set_H(0);
473  set_N(0);
474 }
475 
476 static void SRA(unsigned char reg)
477 {
478  unsigned char old, t;
479 
480  switch(reg)
481  {
482  case 0: /* B */
483  set_C(c.B&1);
484  old = c.B&0x80;
485  c.B = c.B >> 1 | old;
486  set_Z(!c.B);
487  break;
488  case 1: /* C */
489  set_C(c.C&1);
490  old = c.C&0x80;
491  c.C = c.C >> 1 | old;
492  set_Z(!c.C);
493  break;
494  case 2: /* D */
495  set_C(c.D&1);
496  old = c.D&0x80;
497  c.D = c.D >> 1 | old;
498  set_Z(!c.D);
499  break;
500  case 3: /* E */
501  set_C(c.E&1);
502  old = c.E&0x80;
503  c.E = c.E >> 1 | old;
504  set_Z(!c.E);
505  break;
506  case 4: /* H */
507  set_C(c.H&1);
508  old = c.H&0x80;
509  c.H = c.H >> 1 | old;
510  set_Z(!c.H);
511  break;
512  case 5: /* L */
513  set_C(c.L&1);
514  old = c.L&0x80;
515  c.L = c.L >> 1 | old;
516  set_Z(!c.L);
517  break;
518  case 6: /* (HL) */
519  c.cycles += 1;
520  timer_cycle();
521  t = mem_get_byte(get_HL());
522  set_C(t&1);
523  old = t&0x80;
524  t = t >> 1 | old;
525  c.cycles += 1;
526  timer_cycle();
527  mem_write_byte(get_HL(), t);
528  set_Z(!t);
529  break;
530  case 7: /* A */
531  set_C(c.A&1);
532  old = c.A&0x80;
533  c.A = c.A >> 1 | old;
534  set_Z(!c.A);
535  break;
536  }
537 
538  set_H(0);
539  set_N(0);
540 }
541 
542 static void SRL(unsigned char reg)
543 {
544  unsigned char t;
545 
546  switch(reg)
547  {
548  case 0: /* B */
549  set_C(c.B & 1);
550  c.B = c.B >> 1;
551  set_Z(!c.B);
552  break;
553  case 1: /* C */
554  set_C(c.C & 1);
555  c.C = c.C >> 1;
556  set_Z(!c.C);
557  break;
558  case 2: /* D */
559  set_C(c.D & 1);
560  c.D = c.D >> 1;
561  set_Z(!c.D);
562  break;
563  case 3: /* E */
564  set_C(c.E & 1);
565  c.E = c.E >> 1;
566  set_Z(!c.E);
567  break;
568  case 4: /* H */
569  set_C(c.H & 1);
570  c.H = c.H >> 1;
571  set_Z(!c.H);
572  break;
573  case 5: /* L */
574  set_C(c.L & 1);
575  c.L = c.L >> 1;
576  set_Z(!c.L);
577  break;
578  case 6: /* (HL) */
579  c.cycles += 1;
580  timer_cycle();
581  t = mem_get_byte(get_HL());
582  set_C(t & 1);
583  t = t >> 1;
584  c.cycles += 1;
585  timer_cycle();
586  mem_write_byte(get_HL(), t);
587  set_Z(!t);
588  break;
589  case 7: /* A */
590  set_C(c.A & 1);
591  c.A = c.A >> 1;
592  set_Z(!c.A);
593  break;
594  }
595 
596  set_H(0);
597  set_N(0);
598 }
599 
600 static void SWAP(unsigned char reg)
601 {
602  unsigned char t;
603 
604  switch(reg)
605  {
606  case 0: /* B */
607  c.B = ((c.B&0xF)<<4) | ((c.B&0xF0)>>4);
608  c.F = (!c.B)<<7;
609  break;
610  case 1: /* C */
611  c.C = ((c.C&0xF)<<4) | ((c.C&0xF0)>>4);
612  c.F = (!c.C)<<7;
613  break;
614  case 2: /* D */
615  c.D = ((c.D&0xF)<<4) | ((c.D&0xF0)>>4);
616  c.F = (!c.D)<<7;
617  break;
618  case 3: /* E */
619  c.E = ((c.E&0xF)<<4) | ((c.E&0xF0)>>4);
620  c.F = (!c.E)<<7;
621  break;
622  case 4: /* H */
623  c.H = ((c.H&0xF)<<4) | ((c.H&0xF0)>>4);
624  c.F = (!c.H)<<7;
625  break;
626  case 5: /* L */
627  c.L = ((c.L&0xF)<<4) | ((c.L&0xF0)>>4);
628  c.F = (!c.L)<<7;
629  break;
630  case 6: /* (HL) */
631  c.cycles += 1;
632  timer_cycle();
633  t = mem_get_byte(get_HL());
634  t = ((t&0xF)<<4) | ((t&0xF0)>>4);
635  c.cycles += 1;
636  timer_cycle();
637  mem_write_byte(get_HL(), t);
638  c.F = (!t)<<7;
639  break;
640  case 7: /* A */
641  c.A = ((c.A&0xF)<<4) | ((c.A&0xF0)>>4);
642  c.F = (!c.A)<<7;
643  break;
644  }
645 }
646 
647 static void BIT(unsigned char bit, unsigned char reg)
648 {
649  unsigned char t, f = 0 /* Make GCC happy */;
650 
651  switch(reg)
652  {
653  case 0: /* B */
654  f = !(c.B & bit);
655  break;
656  case 1: /* C */
657  f = !(c.C & bit);
658  break;
659  case 2: /* D */
660  f = !(c.D & bit);
661  break;
662  case 3: /* E */
663  f = !(c.E & bit);
664  break;
665  case 4: /* H */
666  f = !(c.H & bit);
667  break;
668  case 5: /* L */
669  f = !(c.L & bit);
670  break;
671  case 6: /* (HL) */
672  c.cycles += 1;
673  timer_cycle();
674  t = mem_get_byte(get_HL());
675  f = !(t & bit);
676  break;
677  case 7: /* A */
678  f = !(c.A & bit);
679  break;
680  }
681 
682  set_Z(f);
683  set_N(0);
684  set_H(1);
685 }
686 
687 static void RES(unsigned char bit, unsigned char reg)
688 {
689  unsigned char t;
690 
691  switch(reg)
692  {
693  case 0: /* B */
694  c.B &= ~bit;
695  break;
696  case 1: /* C */
697  c.C &= ~bit;
698  break;
699  case 2: /* D */
700  c.D &= ~bit;
701  break;
702  case 3: /* E */
703  c.E &= ~bit;
704  break;
705  case 4: /* H */
706  c.H &= ~bit;
707  break;
708  case 5: /* L */
709  c.L &= ~bit;
710  break;
711  case 6: /* (HL) */
712  c.cycles += 1;
713  timer_cycle();
714  t = mem_get_byte(get_HL());
715  t &= ~bit;
716  c.cycles += 1;
717  timer_cycle();
718  mem_write_byte(get_HL(), t);
719  break;
720  case 7: /* A */
721  c.A &= ~bit;
722  break;
723  }
724 }
725 
726 static void SET(unsigned char bit, unsigned char reg)
727 {
728  unsigned char t;
729 
730  switch(reg)
731  {
732  case 0: /* B */
733  c.B |= bit;
734  break;
735  case 1: /* C */
736  c.C |= bit;
737  break;
738  case 2: /* D */
739  c.D |= bit;
740  break;
741  case 3: /* E */
742  c.E |= bit;
743  break;
744  case 4: /* H */
745  c.H |= bit;
746  break;
747  case 5: /* L */
748  c.L |= bit;
749  break;
750  case 6: /* (HL) */
751  c.cycles += 1;
752  timer_cycle();
753  t = mem_get_byte(get_HL());
754  t |= bit;
755  c.cycles += 1;
756  timer_cycle();
757  mem_write_byte(get_HL(), t);
758  break;
759  case 7: /* A */
760  c.A |= bit;
761  break;
762  }
763 }
764 
765 /*
766 00000xxx = RLC xxx
767 00001xxx = RRC xxx
768 00010xxx = RL xxx
769 00011xxx = RR xxx
770 00100xxx = SLA xxx
771 00101xxx = SRA xxx
772 00110xxx = SWAP xxx
773 00111xxx = SRL xxx
774 01yyyxxx = BIT yyy, xxx
775 10yyyxxx = RES yyy, xxx
776 11yyyxxx = SET yyy, xxx
777 */
778 static void decode_CB(unsigned char t)
779 {
780  unsigned char reg, opcode, bit;
781  void (*f[])(unsigned char) = {RLC, RRC, RL, RR, SLA, SRA, SWAP, SRL};
782  void (*f2[])(unsigned char, unsigned char) = {BIT, RES, SET};
783 
784  c.cycles += 1;
785 
786  reg = t&7;
787  opcode = t>>3;
788  if(opcode < 8)
789  {
790  f[opcode](reg);
791  c.cycles += 1;
792  return;
793  }
794 
795  bit = opcode&7;
796  opcode >>= 3;
797  f2[opcode-1](1<<bit, reg);
798  c.cycles += 1;
799 }
800 
801 int cpu_halted(void)
802 {
803  return halted;
804 }
805 
806 unsigned int cpu_get_cycles(void)
807 {
808  return c.cycles;
809 }
810 
811 static int halt_bug = 0;
812 
813 void cpu_unhalt(void)
814 {
815  halted = 0;
816 }
817 
818 void cpu_halt(void)
819 {
820  halted = 1;
821 }
822 
823 unsigned int cpu_getpc(void)
824 {
825  return c.PC;
826 }
827 
828 void cpu_interrupt_begin(void)
829 {
830  halted = 0;
831 
832  c.SP -= 2;
833  mem_write_word(c.SP, c.PC);
834  c.cycles += 2;
835 }
836 
837 void cpu_interrupt(unsigned short n)
838 {
839  c.PC = n;
840  c.cycles += 2;
841  interrupt_disable();
842  c.cycles += 1;
843 }
844 
845 void cpu_print_debug(void)
846 {
847  printf("PC: %04X AF: %02X%02X, BC: %02X%02X, DE: %02X%02X, HL: %02X%02X, SP: %04X, cycles: %d\n",
848  c.PC, c.A, c.F, c.B, c.C, c.D, c.E, c.H, c.L, c.SP, c.cycles);
849 }
850 
851 int cpu_cycle(void)
852 {
853  unsigned char b, t;
854  unsigned short s;
855  unsigned int i;
856 
857  /* If any interrupts are pending, do them now */
858  if(!ei_flag)
859  interrupt_flush();
860  else
861  {
862  ei_flag = 0;
863  interrupt_enable();
864  }
865 
866  /* If the cpu is halted, do nothing instead */
867  if(halted)
868  {
869  c.cycles += 1;
870  return 1;
871  }
872 
873 #ifdef DEBUG
874  if(c.PC == 0x100)
875  is_debugged = 1;
876  if(c.PC == 0xC0BD && is_debugged)
877  {is_debugged = 0; exit(0);}
878 #endif
879 
880  if(is_debugged)
881  cpu_print_debug();
882 
883  /* Otherwise, execute as normal */
884  b = mem_get_byte(c.PC);
885 
886  if(halt_bug)
887  halt_bug = 0;
888  else
889  c.PC++;
890 
891  switch(b)
892  {
893  case 0x00: /* NOP */
894  c.cycles += 1;
895  break;
896  case 0x01: /* LD BC, imm16 */
897  s = mem_get_word(c.PC);
898  set_BC(s);
899  c.PC += 2;
900  c.cycles += 3;
901  break;
902  case 0x02: /* LD (BC), A */
903  c.cycles += 1;
904  timer_cycle();
905  mem_write_byte(get_BC(), c.A);
906  c.cycles += 1;
907  break;
908  case 0x03: /* INC BC */
909  set_BC(get_BC()+1);
910  c.cycles += 2;
911  break;
912  case 0x04: /* INC B */
913  INC(c.B);
914  break;
915  case 0x05: /* DEC B */
916  DEC(c.B);
917  break;
918  case 0x06: /* LD B, imm8 */
919  LDRIMM8(c.B);
920  break;
921  case 0x07: /* RLCA */
922  RLC(7);
923  set_Z(0);
924  c.cycles += 1;
925  break;
926  case 0x08: /* LD (imm16), SP */
927  c.cycles += 3;
928  timer_cycle();
929  mem_write_word(mem_get_word(c.PC), c.SP);
930  c.PC += 2;
931  c.cycles += 2;
932  break;
933  case 0x09: /* ADD HL, BC */
934  i = get_HL() + get_BC();
935  set_N(0);
936  set_C(i >= 0x10000);
937  set_H((i&0xFFF) < (get_HL()&0xFFF));
938  set_HL(i&0xFFFF);
939  c.cycles += 2;
940  break;
941  case 0x0A: /* LD A, (BC) */
942  c.cycles += 1;
943  timer_cycle();
944  c.A = mem_get_byte(get_BC());
945  c.cycles += 1;
946  break;
947  case 0x0B: /* DEC BC */
948  s = get_BC();
949  s--;
950  set_BC(s);
951  c.cycles += 2;
952  break;
953  case 0x0C: /* INC C */
954  INC(c.C);
955  break;
956  case 0x0D: /* DEC C */
957  DEC(c.C);
958  break;
959  case 0x0E: /* LD C, imm8 */
960  LDRIMM8(c.C);
961  break;
962  case 0x0F: /* RRCA */
963  RRC(7);
964  set_Z(0);
965  c.cycles += 1;
966  break;
967  case 0x11: /* LD DE, imm16 */
968  s = mem_get_word(c.PC);
969  set_DE(s);
970  c.PC += 2;
971  c.cycles += 3;
972  break;
973  case 0x12: /* LD (DE), A */
974  c.cycles += 1;
975  timer_cycle();
976  mem_write_byte(get_DE(), c.A);
977  c.cycles += 1;
978  break;
979  case 0x13: /* INC DE */
980  s = get_DE();
981  s++;
982  set_DE(s);
983  c.cycles += 2;
984  break;
985  case 0x14: /* INC D */
986  INC(c.D);
987  break;
988  case 0x15: /* DEC D */
989  DEC(c.D);
990  break;
991  case 0x16: /* LD D, imm8 */
992  LDRIMM8(c.D);
993  break;
994  case 0x17: /* RLA */
995  RL(7);
996  set_Z(0);
997  c.cycles += 1;
998  break;
999  case 0x18: /* JR rel8 */
1000  c.PC += (signed char)mem_get_byte(c.PC) + 1;
1001  c.cycles += 3;
1002  break;
1003  case 0x19: /* ADD HL, DE */
1004  i = get_HL() + get_DE();
1005  set_H((i&0xFFF) < (get_HL()&0xFFF));
1006  set_HL(i);
1007  set_N(0);
1008  set_C(i > 0xFFFF);
1009  c.cycles += 2;
1010  break;
1011  case 0x1A: /* LD A, (DE) */
1012  c.cycles += 1;
1013  timer_cycle();
1014  c.A = mem_get_byte(get_DE());
1015  c.cycles += 1;
1016  break;
1017  case 0x1B: /* DEC DE */
1018  s = get_DE();
1019  s--;
1020  set_DE(s);
1021  c.cycles += 2;
1022  break;
1023  case 0x1C: /* INC E */
1024  INC(c.E);
1025  break;
1026  case 0x1D: /* DEC E */
1027  DEC(c.E);
1028  break;
1029  case 0x1E: /* LD E, imm8 */
1030  LDRIMM8(c.E);
1031  break;
1032  case 0x1F: /* RR A */
1033  RR(7);
1034  set_Z(0);
1035  c.cycles += 1;
1036  break;
1037  case 0x20: /* JR NZ, rel8 */
1038  if(flag_Z == 0)
1039  {
1040  c.PC += (signed char)mem_get_byte(c.PC) + 1;
1041  c.cycles += 3;
1042  } else {
1043  c.PC += 1;
1044  c.cycles += 2;
1045  }
1046  break;
1047  case 0x21: /* LD HL, imm16 */
1048  s = mem_get_word(c.PC);
1049  set_HL(s);
1050  c.PC += 2;
1051  c.cycles += 3;
1052  break;
1053  case 0x22: /* LDI (HL), A */
1054  c.cycles += 1;
1055  timer_cycle();
1056  i = get_HL();
1057  mem_write_byte(i, c.A);
1058  i++;
1059  set_HL(i);
1060  c.cycles += 1;
1061  break;
1062  case 0x23: /* INC HL */
1063  s = get_HL();
1064  s++;
1065  set_HL(s);
1066  c.cycles += 2;
1067  break;
1068  case 0x24: /* INC H */
1069  INC(c.H);
1070  break;
1071  case 0x25: /* DEC H */
1072  DEC(c.H);
1073  break;
1074  case 0x26: /* LD H, imm8 */
1075  LDRIMM8(c.H);
1076  break;
1077  case 0x27: /* DAA */
1078  s = c.A;
1079 
1080  if(flag_N)
1081  {
1082  if(flag_H)
1083  s = (s - 0x06)&0xFF;
1084  if(flag_C)
1085  s -= 0x60;
1086  }
1087  else
1088  {
1089  if(flag_H || (s & 0xF) > 9)
1090  s += 0x06;
1091  if(flag_C || s > 0x9F)
1092  s += 0x60;
1093  }
1094 
1095  c.A = s;
1096  set_H(0);
1097  set_Z(!c.A);
1098  if(s >= 0x100)
1099  set_C(1);
1100  c.cycles += 1;
1101  break;
1102  case 0x28: /* JR Z, rel8 */
1103  if(flag_Z == 1)
1104  {
1105  c.PC += (signed char)mem_get_byte(c.PC) + 1;
1106  c.cycles += 3;
1107  } else {
1108  c.PC += 1;
1109  c.cycles += 2;
1110  }
1111  break;
1112  case 0x29: /* ADD HL, HL */
1113  i = get_HL()*2;
1114  set_H((i&0xFFF) < (get_HL()&0xFFF));
1115  set_C(i > 0xFFFF);
1116  set_HL(i);
1117  set_N(0);
1118  c.cycles += 2;
1119  break;
1120  case 0x2A: /* LDI A, (HL) */
1121  c.cycles += 1;
1122  timer_cycle();
1123  s = get_HL();
1124  c.A = mem_get_byte(s);
1125  set_HL(s+1);
1126  c.cycles += 1;
1127  break;
1128  case 0x2B: /* DEC HL */
1129  set_HL(get_HL()-1);
1130  c.cycles += 2;
1131  break;
1132  case 0x2C: /* INC L */
1133  INC(c.L);
1134  break;
1135  case 0x2D: /* DEC L */
1136  DEC(c.L);
1137  break;
1138  case 0x2E: /* LD L, imm8 */
1139  LDRIMM8(c.L);
1140  break;
1141  case 0x2F: /* CPL */
1142  c.A = ~c.A;
1143  set_N(1);
1144  set_H(1);
1145  c.cycles += 1;
1146  break;
1147  case 0x30: /* JR NC, rel8 */
1148  if(flag_C == 0)
1149  {
1150  c.PC += (signed char)mem_get_byte(c.PC) + 1;
1151  c.cycles += 3;
1152  } else {
1153  c.PC += 1;
1154  c.cycles += 2;
1155  }
1156  break;
1157  case 0x31: /* LD SP, imm16 */
1158  c.SP = mem_get_word(c.PC);
1159  c.PC += 2;
1160  c.cycles += 3;
1161  break;
1162  case 0x32: /* LDD (HL), A */
1163  c.cycles += 1;
1164  timer_cycle();
1165  i = get_HL();
1166  mem_write_byte(i, c.A);
1167  set_HL(i-1);
1168  c.cycles += 1;
1169  break;
1170  case 0x33: /* INC SP */
1171  c.SP++;
1172  c.cycles += 2;
1173  break;
1174  case 0x34: /* INC (HL) */
1175  c.cycles += 1;
1176  timer_cycle();
1177  t = mem_get_byte(get_HL());
1178  t++;
1179  c.cycles += 1;
1180  timer_cycle();
1181  mem_write_byte(get_HL(), t);
1182  set_Z(!t);
1183  set_N(0);
1184  set_H((t & 0xF) == 0);
1185  c.cycles += 1;
1186  break;
1187  case 0x35: /* DEC (HL) */
1188  c.cycles += 1;
1189  timer_cycle();
1190  t = mem_get_byte(get_HL());
1191  t--;
1192  c.cycles += 1;
1193  timer_cycle();
1194  mem_write_byte(get_HL(), t);
1195  set_Z(!t);
1196  set_N(1);
1197  set_H((t & 0xF) == 0xF);
1198  c.cycles += 1;
1199  break;
1200  case 0x36: /* LD (HL), imm8 */
1201  c.cycles += 2;
1202  timer_cycle();
1203  t = mem_get_byte(c.PC);
1204  mem_write_byte(get_HL(), t);
1205  c.PC += 1;
1206  c.cycles += 1;
1207  break;
1208  case 0x37: /* SCF */
1209  set_N(0);
1210  set_H(0);
1211  set_C(1);
1212  c.cycles += 1;
1213  break;
1214  case 0x38: /* JR C, rel8 */
1215  if(flag_C)
1216  {
1217  c.PC += (signed char)mem_get_byte(c.PC) + 1;
1218  c.cycles += 3;
1219  } else {
1220  c.PC += 1;
1221  c.cycles += 2;
1222  }
1223  break;
1224  case 0x39: /* ADD HL, SP */
1225  i = get_HL() + c.SP;
1226  set_H((i&0x7FF) < (get_HL()&0x7FF));
1227  set_C(i > 0xFFFF);
1228  set_N(0);
1229  set_HL(i);
1230  c.cycles += 2;
1231  break;
1232  case 0x3A: /* LDD A, (HL) */
1233  c.cycles += 1;
1234  timer_cycle();
1235  c.A = mem_get_byte(get_HL());
1236  set_HL(get_HL()-1);
1237  c.cycles += 1;
1238  break;
1239  case 0x3B: /* DEC SP */
1240  c.SP--;
1241  c.cycles += 2;
1242  break;
1243  case 0x3C: /* INC A */
1244  INC(c.A);
1245  break;
1246  case 0x3D: /* DEC A */
1247  DEC(c.A);
1248  break;
1249  case 0x3E: /* LD A, imm8 */
1250  LDRIMM8(c.A);
1251  break;
1252  case 0x3F: /* CCF */
1253  set_N(0);
1254  set_H(0);
1255  set_C(!flag_C);
1256  c.cycles += 1;
1257  break;
1258  case 0x40: /* LD B, B */
1259  LDRR(c.B, c.B);
1260  break;
1261  case 0x41: /* LD B, C */
1262  LDRR(c.B, c.C);
1263  break;
1264  case 0x42: /* LD B, D */
1265  LDRR(c.B, c.D);
1266  break;
1267  case 0x43: /* LD B, E */
1268  LDRR(c.B, c.E);
1269  break;
1270  case 0x44: /* LD B, H */
1271  LDRR(c.B, c.H);
1272  break;
1273  case 0x45: /* LD B, L */
1274  LDRR(c.B, c.L);
1275  break;
1276  case 0x46: /* LD B, (HL) */
1277  c.cycles += 1;
1278  timer_cycle();
1279  c.B = mem_get_byte(get_HL());
1280  c.cycles += 1;
1281  break;
1282  case 0x47: /* LD B, A */
1283  LDRR(c.B, c.A);
1284  break;
1285  case 0x48: /* LD C, B */
1286  LDRR(c.C, c.B);
1287  break;
1288  case 0x49: /* LD C, C */
1289  LDRR(c.C, c.C);
1290  break;
1291  case 0x4A: /* LD C, D */
1292  LDRR(c.C, c.D);
1293  break;
1294  case 0x4B: /* LD C, E */
1295  LDRR(c.C, c.E);
1296  break;
1297  case 0x4C: /* LD C, H */
1298  LDRR(c.C, c.H);
1299  break;
1300  case 0x4D: /* LD C, L */
1301  LDRR(c.C, c.L);
1302  break;
1303  case 0x4E: /* LD C, (HL) */
1304  c.cycles += 1;
1305  timer_cycle();
1306  c.C = mem_get_byte(get_HL());
1307  c.cycles += 1;
1308  break;
1309  case 0x4F: /* LD C, A */
1310  LDRR(c.C, c.A);
1311  break;
1312  case 0x50: /* LD D, B */
1313  LDRR(c.D, c.B);
1314  break;
1315  case 0x51: /* LD D, C */
1316  LDRR(c.D, c.C);
1317  break;
1318  case 0x52: /* LD D, D */
1319  LDRR(c.D, c.D);
1320  break;
1321  case 0x53: /* LD D, E */
1322  LDRR(c.D, c.E);
1323  break;
1324  case 0x54: /* LD D, H */
1325  LDRR(c.D, c.H);
1326  break;
1327  case 0x55: /* LD D, L */
1328  LDRR(c.D, c.L);
1329  break;
1330  case 0x56: /* LD D, (HL) */
1331  c.cycles += 1;
1332  timer_cycle();
1333  c.D = mem_get_byte(get_HL());
1334  c.cycles += 1;
1335  break;
1336  case 0x57: /* LD D, A */
1337  LDRR(c.D, c.A);
1338  break;
1339  case 0x58: /* LD E, B */
1340  LDRR(c.E, c.B);
1341  break;
1342  case 0x59: /* LD E, C */
1343  LDRR(c.E, c.C);
1344  break;
1345  case 0x5A: /* LD E, D */
1346  LDRR(c.E, c.D);
1347  break;
1348  case 0x5B: /* LD E, E */
1349  LDRR(c.E, c.E);
1350  break;
1351  case 0x5C: /* LD E, H */
1352  LDRR(c.E, c.H);
1353  break;
1354  case 0x5D: /* LD E, L */
1355  LDRR(c.E, c.L);
1356  break;
1357  case 0x5E: /* LD E, (HL) */
1358  c.cycles += 1;
1359  timer_cycle();
1360  c.E = mem_get_byte(get_HL());
1361  c.cycles += 1;
1362  break;
1363  case 0x5F: /* LD E, A */
1364  LDRR(c.E, c.A);
1365  break;
1366  case 0x60: /* LD H, B */
1367  LDRR(c.H, c.B);
1368  break;
1369  case 0x61: /* LD H, C */
1370  LDRR(c.H, c.C);
1371  break;
1372  case 0x62: /* LD H, D */
1373  LDRR(c.H, c.D);
1374  break;
1375  case 0x63: /* LD H, E */
1376  LDRR(c.H, c.E);
1377  break;
1378  case 0x64: /* LD H, H */
1379  LDRR(c.H, c.H);
1380  break;
1381  case 0x65: /* LD H, L */
1382  LDRR(c.H, c.L);
1383  break;
1384  case 0x66: /* LD H, (HL) */
1385  c.cycles += 1;
1386  timer_cycle();
1387  c.H = mem_get_byte(get_HL());
1388  c.cycles += 1;
1389  break;
1390  case 0x67: /* LD H, A */
1391  LDRR(c.H, c.A);
1392  break;
1393  case 0x68: /* LD L, B */
1394  LDRR(c.L, c.B);
1395  break;
1396  case 0x69: /* LD L, C */
1397  LDRR(c.L, c.C);
1398  break;
1399  case 0x6A: /* LD L, D */
1400  LDRR(c.L, c.D);
1401  break;
1402  case 0x6B: /* LD L, E */
1403  LDRR(c.L, c.E);
1404  break;
1405  case 0x6C: /* LD L, H */
1406  LDRR(c.L, c.H);
1407  break;
1408  case 0x6D: /* LD L, L */
1409  LDRR(c.L, c.L);
1410  break;
1411  case 0x6E: /* LD L, (HL) */
1412  c.cycles += 1;
1413  timer_cycle();
1414  c.L = mem_get_byte(get_HL());
1415  c.cycles += 1;
1416  break;
1417  case 0x6F: /* LD L, A */
1418  LDRR(c.L, c.A);
1419  break;
1420  case 0x70: /* LD (HL), B */
1421  c.cycles += 1;
1422  timer_cycle();
1423  mem_write_byte(get_HL(), c.B);
1424  c.cycles += 1;
1425  break;
1426  case 0x71: /* LD (HL), C */
1427  c.cycles += 1;
1428  timer_cycle();
1429  mem_write_byte(get_HL(), c.C);
1430  c.cycles += 1;
1431  break;
1432  case 0x72: /* LD (HL), D */
1433  c.cycles += 1;
1434  timer_cycle();
1435  mem_write_byte(get_HL(), c.D);
1436  c.cycles += 1;
1437  break;
1438  case 0x73: /* LD (HL), E */
1439  c.cycles += 1;
1440  timer_cycle();
1441  mem_write_byte(get_HL(), c.E);
1442  c.cycles += 1;
1443  break;
1444  case 0x74: /* LD (HL), H */
1445  c.cycles += 1;
1446  timer_cycle();
1447  mem_write_byte(get_HL(), c.H);
1448  c.cycles += 1;
1449  break;
1450  case 0x75: /* LD (HL), L */
1451  c.cycles += 1;
1452  timer_cycle();
1453  mem_write_byte(get_HL(), c.L);
1454  c.cycles += 1;
1455  break;
1456  case 0x76: /* HALT */
1457  if(interrupt_get_enabled())
1458  {
1459  halted = 1;
1460  c.cycles += 1;
1461  break;
1462  }
1463 
1464  if(!interrupt_pending())
1465  halted = 1;
1466  else
1467  halt_bug = 1;
1468 
1469  c.cycles += 1;
1470  break;
1471  case 0x77: /* LD (HL), A */
1472  c.cycles += 1;
1473  timer_cycle();
1474  mem_write_byte(get_HL(), c.A);
1475  c.cycles += 1;
1476  break;
1477  case 0x78: /* LD A, B */
1478  LDRR(c.A, c.B);
1479  break;
1480  case 0x79: /* LD A, C */
1481  LDRR(c.A, c.C);
1482  break;
1483  case 0x7A: /* LD A, D */
1484  LDRR(c.A, c.D);
1485  break;
1486  case 0x7B: /* LD A, E */
1487  LDRR(c.A, c.E);
1488  break;
1489  case 0x7C: /* LD A, H */
1490  LDRR(c.A, c.H);
1491  break;
1492  case 0x7D: /* LD A, L */
1493  LDRR(c.A, c.L);
1494  break;
1495  case 0x7E: /* LD A, (HL) */
1496  c.cycles++;
1497  timer_cycle();
1498  c.A = mem_get_byte(get_HL());
1499  c.cycles++;
1500  break;
1501  case 0x7F: /* LD A, A */
1502  LDRR(c.A, c.A);
1503  break;
1504  case 0x80: /* ADD B */
1505  i = c.A + c.B;
1506  set_H((c.A&0xF)+(c.B&0xF) > 0xF);
1507  set_C(i > 0xFF);
1508  set_N(0);
1509  c.A = i;
1510  set_Z(!c.A);
1511  c.cycles += 1;
1512  break;
1513  case 0x81: /* ADD C */
1514  i = c.A + c.C;
1515  set_H((c.A&0xF)+(c.C&0xF) > 0xF);
1516  set_C(i > 0xFF);
1517  set_N(0);
1518  c.A = i;
1519  set_Z(!c.A);
1520  c.cycles += 1;
1521  break;
1522  case 0x82: /* ADD D */
1523  i = c.A + c.D;
1524  set_H((c.A&0xF)+(c.D&0xF) > 0xF);
1525  set_C(i > 0xFF);
1526  set_N(0);
1527  c.A = i;
1528  set_Z(!c.A);
1529  c.cycles += 1;
1530  break;
1531  case 0x83: /* ADD E */
1532  i = c.A + c.E;
1533  set_H((c.A&0xF)+(c.E&0xF) > 0xF);
1534  set_C(i > 0xFF);
1535  set_N(0);
1536  c.A = i;
1537  set_Z(!c.A);
1538  c.cycles += 1;
1539  break;
1540  case 0x84: /* ADD H */
1541  i = c.A + c.H;
1542  set_H((c.A&0xF)+(c.H&0xF) > 0xF);
1543  set_C(i > 0xFF);
1544  set_N(0);
1545  c.A = i;
1546  set_Z(!c.A);
1547  c.cycles += 1;
1548  break;
1549  case 0x85: /* ADD L */
1550  i = c.A + c.L;
1551  set_H((c.A&0xF)+(c.L&0xF) > 0xF);
1552  set_C(i > 0xFF);
1553  set_N(0);
1554  c.A = i;
1555  set_Z(!c.A);
1556  c.cycles += 1;
1557  break;
1558  case 0x86: /* ADD (HL) */
1559  c.cycles += 1;
1560  timer_cycle();
1561  i = c.A + mem_get_byte(get_HL());
1562  set_H((i&0xF) < (c.A&0xF));
1563  set_C(i > 0xFF);
1564  set_N(0);
1565  c.A = i;
1566  set_Z(!c.A);
1567  c.cycles += 1;
1568  break;
1569  case 0x87: /* ADD A */
1570  i = c.A + c.A;
1571  set_H((c.A&0xF)+(c.A&0xF) > 0xF);
1572  set_C(i > 0xFF);
1573  set_N(0);
1574  c.A = i;
1575  set_Z(!c.A);
1576  c.cycles += 1;
1577  break;
1578  case 0x88: /* ADC B */
1579  i = c.A + c.B + flag_C >= 0x100;
1580  set_N(0);
1581  set_H(((c.A&0xF) + (c.B&0xF) + flag_C) >= 0x10);
1582  c.A = c.A + c.B + flag_C;
1583  set_C(i);
1584  set_Z(!c.A);
1585  c.cycles += 1;
1586  break;
1587  case 0x89: /* ADC C */
1588  i = c.A + c.C + flag_C >= 0x100;
1589  set_N(0);
1590  set_H(((c.A&0xF) + (c.C&0xF) + flag_C) >= 0x10);
1591  c.A = c.A + c.C + flag_C;
1592  set_C(i);
1593  set_Z(!c.A);
1594  c.cycles += 1;
1595  break;
1596  case 0x8A: /* ADC D */
1597  i = c.A + c.D + flag_C >= 0x100;
1598  set_N(0);
1599  set_H(((c.A&0xF) + (c.D&0xF) + flag_C) >= 0x10);
1600  c.A = c.A + c.D + flag_C;
1601  set_C(i);
1602  set_Z(!c.A);
1603  c.cycles += 1;
1604  break;
1605  case 0x8B: /* ADC E */
1606  i = c.A + c.E + flag_C >= 0x100;
1607  set_N(0);
1608  set_H(((c.A&0xF) + (c.E&0xF) + flag_C) >= 0x10);
1609  c.A = c.A + c.E + flag_C;
1610  set_C(i);
1611  set_Z(!c.A);
1612  c.cycles += 1;
1613  break;
1614  case 0x8C: /* ADC H */
1615  i = c.A + c.H + flag_C >= 0x100;
1616  set_N(0);
1617  set_H(((c.A&0xF) + (c.H&0xF) + flag_C) >= 0x10);
1618  c.A = c.A + c.H + flag_C;
1619  set_C(i);
1620  set_Z(!c.A);
1621  c.cycles += 1;
1622  break;
1623  case 0x8D: /* ADC L */
1624  i = c.A + c.L + flag_C >= 0x100;
1625  set_N(0);
1626  set_H(((c.A&0xF) + (c.L&0xF) + flag_C) >= 0x10);
1627  c.A = c.A + c.L + flag_C;
1628  set_C(i);
1629  set_Z(!c.A);
1630  c.cycles += 1;
1631  break;
1632  case 0x8E: /* ADC (HL) */
1633  c.cycles += 1;
1634  timer_cycle();
1635  t = mem_get_byte(get_HL());
1636  i = c.A + t + flag_C >= 0x100;
1637  set_N(0);
1638  set_H(((c.A&0xF) + (t&0xF) + flag_C) >= 0x10);
1639  c.A = c.A + t + flag_C;
1640  set_C(i);
1641  set_Z(!c.A);
1642  c.cycles += 1;
1643  break;
1644  case 0x8F: /* ADC A */
1645  i = c.A + c.A + flag_C >= 0x100;
1646  set_N(0);
1647  set_H(((c.A&0xF) + (c.A&0xF) + flag_C) >= 0x10);
1648  c.A = c.A + c.A + flag_C;
1649  set_C(i);
1650  set_Z(!c.A);
1651  c.cycles += 1;
1652  break;
1653  case 0x90: /* SUB B */
1654  SUBR(c.B);
1655  break;
1656  case 0x91: /* SUB C */
1657  SUBR(c.C);
1658  break;
1659  case 0x92: /* SUB D */
1660  SUBR(c.D);
1661  break;
1662  case 0x93: /* SUB E */
1663  SUBR(c.E);
1664  break;
1665  case 0x94: /* SUB H */
1666  SUBR(c.H);
1667  break;
1668  case 0x95: /* SUB L */
1669  SUBR(c.L);
1670  break;
1671  case 0x96: /* SUB (HL) */
1672  c.cycles += 1;
1673  timer_cycle();
1674  t = mem_get_byte(get_HL());
1675  set_C((c.A - t) < 0);
1676  set_H(((c.A - t)&0xF) > (c.A&0xF));
1677  c.A -= t;
1678  set_Z(!c.A);
1679  set_N(1);
1680  c.cycles += 1;
1681  break;
1682  case 0x97: /* SUB A */
1683  SUBR(c.A);
1684  break;
1685  case 0x98: /* SBC B */
1686  t = flag_C + c.B;
1687  set_H(((c.A&0xF) - (c.B&0xF) - flag_C) < 0);
1688  set_C((c.A - c.B - flag_C) < 0);
1689  set_N(1);
1690  c.A -= t;
1691  set_Z(!c.A);
1692  c.cycles += 1;
1693  break;
1694  case 0x99: /* SBC C */
1695  t = flag_C + c.C;
1696  set_H(((c.A&0xF) - (c.C&0xF) - flag_C) < 0);
1697  set_C((c.A - c.C - flag_C) < 0);
1698  set_N(1);
1699  c.A -= t;
1700  set_Z(!c.A);
1701  c.cycles += 1;
1702  break;
1703  case 0x9A: /* SBC D */
1704  t = flag_C + c.D;
1705  set_H(((c.A&0xF) - (c.D&0xF) - flag_C) < 0);
1706  set_C((c.A - c.D - flag_C) < 0);
1707  set_N(1);
1708  c.A -= t;
1709  set_Z(!c.A);
1710  c.cycles += 1;
1711  break;
1712  case 0x9B: /* SBC E */
1713  t = flag_C + c.E;
1714  set_H(((c.A&0xF) - (c.E&0xF) - flag_C) < 0);
1715  set_C((c.A - c.E - flag_C) < 0);
1716  set_N(1);
1717  c.A -= t;
1718  set_Z(!c.A);
1719  c.cycles += 1;
1720  break;
1721  case 0x9C: /* SBC H */
1722  t = flag_C + c.H;
1723  set_H(((c.A&0xF) - (c.H&0xF) - flag_C) < 0);
1724  set_C((c.A - c.H - flag_C) < 0);
1725  set_N(1);
1726  c.A -= t;
1727  set_Z(!c.A);
1728  c.cycles += 1;
1729  break;
1730  case 0x9D: /* SBC L */
1731  t = flag_C + c.L;
1732  set_H(((c.A&0xF) - (c.L&0xF) - flag_C) < 0);
1733  set_C((c.A - c.L - flag_C) < 0);
1734  set_N(1);
1735  c.A -= t;
1736  set_Z(!c.A);
1737  c.cycles += 1;
1738  break;
1739  case 0x9E: /* SBC (HL) */
1740  c.cycles += 1;
1741  timer_cycle();
1742  t = mem_get_byte(get_HL());
1743  b = flag_C + t;
1744  set_H(((c.A&0xF) - (t&0xF) - flag_C) < 0);
1745  set_C((c.A - t - flag_C) < 0);
1746  set_N(1);
1747  c.A -= b;
1748  set_Z(!c.A);
1749  c.cycles += 1;
1750  break;
1751  case 0x9F: /* SBC A */
1752  t = flag_C + c.A;
1753  set_H(((c.A&0xF) - (c.A&0xF) - flag_C) < 0);
1754  set_C((c.A - c.A - flag_C) < 0);
1755  set_N(1);
1756  c.A -= t;
1757  set_Z(!c.A);
1758  c.cycles += 1;
1759  break;
1760  case 0xA0: /* AND B */
1761  ANDR(c.B);
1762  break;
1763  case 0xA1: /* AND C */
1764  ANDR(c.C);
1765  break;
1766  case 0xA2: /* AND D */
1767  ANDR(c.D);
1768  break;
1769  case 0xA3: /* AND E */
1770  ANDR(c.E);
1771  break;
1772  case 0xA4: /* AND H */
1773  ANDR(c.H);
1774  break;
1775  case 0xA5: /* AND L */
1776  ANDR(c.L);
1777  break;
1778  case 0xA6: /* AND (HL) */
1779  c.cycles += 1;
1780  timer_cycle();
1781  c.A &= mem_get_byte(get_HL());
1782  set_Z(!c.A);
1783  set_H(1);
1784  set_N(0);
1785  set_C(0);
1786  c.cycles += 1;
1787  break;
1788  case 0xA7: /* AND A */
1789  ANDR(c.A);
1790  break;
1791  case 0xA8: /* XOR B */
1792  XORR(c.B);
1793  break;
1794  case 0xA9: /* XOR C */
1795  XORR(c.C);
1796  break;
1797  case 0xAA: /* XOR D */
1798  XORR(c.D);
1799  break;
1800  case 0xAB: /* XOR E */
1801  XORR(c.E);
1802  break;
1803  case 0xAC: /* XOR H */
1804  XORR(c.H);
1805  break;
1806  case 0xAD: /* XOR L */
1807  XORR(c.L);
1808  break;
1809  case 0xAE: /* XOR (HL) */
1810  c.cycles += 1;
1811  timer_cycle();
1812  c.A ^= mem_get_byte(get_HL());
1813  c.F = (!c.A)<<7;
1814  c.cycles += 1;
1815  break;
1816  case 0xAF: /* XOR A */
1817  XORR(c.A);
1818  break;
1819  case 0xB0: /* OR B */
1820  ORR(c.B);
1821  break;
1822  case 0xB1: /* OR C */
1823  ORR(c.C);
1824  break;
1825  case 0xB2: /* OR D */
1826  ORR(c.D);
1827  break;
1828  case 0xB3: /* OR E */
1829  ORR(c.E);
1830  break;
1831  case 0xB4: /* OR H */
1832  ORR(c.H);
1833  break;
1834  case 0xB5: /* OR L */
1835  ORR(c.L);
1836  break;
1837  case 0xB6: /* OR (HL) */
1838  c.cycles += 1;
1839  timer_cycle();
1840  c.A |= mem_get_byte(get_HL());
1841  c.F = (!c.A)<<7;
1842  c.cycles += 1;
1843  break;
1844  case 0xB7: /* OR A */
1845  ORR(c.A);
1846  break;
1847  case 0xB8: /* CP B */
1848  CPR(c.B);
1849  break;
1850  case 0xB9: /* CP C */
1851  CPR(c.C);
1852  break;
1853  case 0xBA: /* CP D */
1854  CPR(c.D);
1855  break;
1856  case 0xBB: /* CP E */
1857  CPR(c.E);
1858  break;
1859  case 0xBC: /* CP H */
1860  CPR(c.H);
1861  break;
1862  case 0xBD: /* CP L */
1863  CPR(c.L);
1864  break;
1865  case 0xBE: /* CP (HL) */
1866  c.cycles++;
1867  timer_cycle();
1868  t = mem_get_byte(get_HL());
1869  set_Z(c.A == t);
1870  set_H(((c.A - t)&0xF) > (c.A&0xF));
1871  set_N(1);
1872  set_C((c.A - t) < 0);
1873  c.cycles += 1;
1874  break;
1875  case 0xBF: /* CP A */
1876  CPR(c.A);
1877  break;
1878  case 0xC0: /* RET NZ */
1879  if(flag_Z == 0)
1880  {
1881  c.cycles += 2;
1882  timer_cycle();
1883  c.PC = get_word_ticked(c.SP);
1884  c.SP += 2;
1885  c.cycles += 1;
1886  } else {
1887  c.cycles += 2;
1888  }
1889  break;
1890  case 0xC1: /* POP BC */
1891  c.cycles += 1;
1892  timer_cycle();
1893  s = get_word_ticked(c.SP);
1894  set_BC(s);
1895  c.SP += 2;
1896  break;
1897  case 0xC2: /* JP NZ, mem16 */
1898  if(flag_Z == 0)
1899  {
1900  c.cycles += 1;
1901  timer_cycle();
1902  c.PC = get_word_ticked(c.PC);
1903  c.cycles += 1;
1904  } else {
1905  c.PC += 2;
1906  c.cycles += 3;
1907  }
1908  break;
1909  case 0xC3: /* JP imm16 */
1910  c.cycles += 1;
1911  timer_cycle();
1912  c.PC = get_word_ticked(c.PC);
1913  c.cycles += 1;
1914  break;
1915  case 0xC4: /* CALL NZ, imm16 */
1916  c.cycles += 1;
1917  timer_cycle();
1918  if(flag_Z == 0)
1919  {
1920  i = get_word_ticked(c.PC);
1921  c.cycles += 1;
1922  timer_cycle();
1923  c.SP -= 2;
1924  write_word_ticked(c.SP, c.PC+2);
1925  c.PC = i;
1926  } else {
1927  c.PC += 2;
1928  c.cycles += 2;
1929  }
1930  break;
1931  case 0xC5: /* PUSH BC */
1932  c.SP -= 2;
1933  c.cycles += 2;
1934  timer_cycle();
1935  write_word_ticked(c.SP, get_BC());
1936  break;
1937  case 0xC6: /* ADD A, imm8 */
1938  t = mem_get_byte(c.PC);
1939  set_C((c.A + t) >= 0x100);
1940  set_H(((c.A + t)&0xF) < (c.A&0xF));
1941  c.A += t;
1942  set_N(0);
1943  set_Z(!c.A);
1944  c.PC += 1;
1945  c.cycles += 2;
1946  break;
1947  case 0xC7: /* RST 00 */
1948  c.cycles += 2;
1949  timer_cycle();
1950  c.SP -= 2;
1951  write_word_ticked(c.SP, c.PC);
1952  c.PC = 0x00;
1953  break;
1954  case 0xC8: /* RET Z */
1955  if(flag_Z == 1)
1956  {
1957  c.cycles += 2;
1958  timer_cycle();
1959  c.PC = get_word_ticked(c.SP);
1960  c.SP += 2;
1961  c.cycles += 1;
1962  } else {
1963  c.cycles += 2;
1964  }
1965  break;
1966  case 0xC9: /* RET */
1967  c.cycles += 1;
1968  timer_cycle();
1969  c.PC = get_word_ticked(c.SP);
1970  c.SP += 2;
1971  c.cycles += 1;
1972  break;
1973  case 0xCA: /* JP Z, mem16 */
1974  if(flag_Z == 1)
1975  {
1976  c.cycles += 1;
1977  timer_cycle();
1978  c.PC = get_word_ticked(c.PC);
1979  c.cycles += 1;
1980  } else {
1981  c.PC += 2;
1982  c.cycles += 3;
1983  }
1984  break;
1985  case 0xCB: /* RLC/RRC/RL/RR/SLA/SRA/SWAP/SRL/BIT/RES/SET */
1986  decode_CB(mem_get_byte(c.PC));
1987  c.PC += 1;
1988  break;
1989  case 0xCC: /* CALL Z, imm16 */
1990  c.cycles += 1;
1991  timer_cycle();
1992  if(flag_Z == 1)
1993  {
1994  i = get_word_ticked(c.PC);
1995  c.cycles += 1;
1996  timer_cycle();
1997  c.SP -= 2;
1998  write_word_ticked(c.SP, c.PC+2);
1999  c.PC = i;
2000  } else {
2001  c.PC += 2;
2002  c.cycles += 2;
2003  }
2004  break;
2005  case 0xCD: /* CALL imm16 */
2006  c.cycles += 1;
2007  timer_cycle();
2008 
2009  i = get_word_ticked(c.PC);
2010 
2011  c.cycles += 1;
2012  timer_cycle();
2013 
2014  c.SP -= 2;
2015  write_word_ticked(c.SP, c.PC+2);
2016  c.PC = i;
2017  break;
2018  case 0xCE: /* ADC a, imm8 */
2019  t = mem_get_byte(c.PC);
2020  i = c.A + t + flag_C >= 0x100;
2021  set_N(0);
2022  set_H(((c.A&0xF) + (t&0xF) + flag_C) >= 0x10);
2023  c.A = c.A + t + flag_C;
2024  set_C(i);
2025  set_Z(!c.A);
2026  c.PC += 1;
2027  c.cycles += 2;
2028  break;
2029  case 0xCF: /* RST 08 */
2030  c.cycles += 2;
2031  timer_cycle();
2032  c.SP -= 2;
2033  write_word_ticked(c.SP, c.PC);
2034  c.PC = 0x08;
2035  break;
2036  case 0xD0: /* RET NC */
2037  if(flag_C == 0)
2038  {
2039  c.cycles += 2;
2040  timer_cycle();
2041  c.PC = get_word_ticked(c.SP);
2042  c.SP += 2;
2043  c.cycles += 1;
2044  } else {
2045  c.cycles += 2;
2046  }
2047  break;
2048  case 0xD1: /* POP DE */
2049  c.cycles += 1;
2050  timer_cycle();
2051  s = get_word_ticked(c.SP);
2052  set_DE(s);
2053  c.SP += 2;
2054  break;
2055  case 0xD2: /* JP NC, mem16 */
2056  if(flag_C == 0)
2057  {
2058  c.cycles += 1;
2059  timer_cycle();
2060  c.PC = get_word_ticked(c.PC);
2061  c.cycles += 1;
2062  } else {
2063  c.PC += 2;
2064  c.cycles += 3;
2065  }
2066  break;
2067  case 0xD4: /* CALL NC, mem16 */
2068  c.cycles += 1;
2069  timer_cycle();
2070  if(flag_C == 0)
2071  {
2072  i = get_word_ticked(c.PC);
2073  c.cycles += 1;
2074  timer_cycle();
2075  c.SP -= 2;
2076  write_word_ticked(c.SP, c.PC+2);
2077  c.PC = i;
2078  } else {
2079  c.PC += 2;
2080  c.cycles += 2;
2081  }
2082  break;
2083  case 0xD5: /* PUSH DE */
2084  c.SP -= 2;
2085  c.cycles += 2;
2086  timer_cycle();
2087  write_word_ticked(c.SP, get_DE());
2088  break;
2089  case 0xD6: /* SUB A, imm8 */
2090  t = mem_get_byte(c.PC);
2091  set_C((c.A - t) < 0);
2092  set_H(((c.A - t)&0xF) > (c.A&0xF));
2093  c.A -= t;
2094  set_N(1);
2095  set_Z(!c.A);
2096  c.PC += 1;
2097  c.cycles += 2;
2098  break;
2099  case 0xD7: /* RST 10 */
2100  c.cycles += 2;
2101  timer_cycle();
2102  c.SP -= 2;
2103  write_word_ticked(c.SP, c.PC);
2104  c.PC = 0x10;
2105  break;
2106  case 0xD8: /* RET C */
2107  if(flag_C == 1)
2108  {
2109  c.cycles += 2;
2110  timer_cycle();
2111  c.PC = get_word_ticked(c.SP);
2112  c.SP += 2;
2113  c.cycles += 1;
2114  } else {
2115  c.cycles += 2;
2116  }
2117  break;
2118  case 0xD9: /* RETI */
2119  c.cycles += 1;
2120  timer_cycle();
2121  c.PC = get_word_ticked(c.SP);
2122  c.SP += 2;
2123  c.cycles += 1;
2124  interrupt_enable();
2125  break;
2126  case 0xDA: /* JP C, mem16 */
2127  if(flag_C == 1)
2128  {
2129  c.cycles += 1;
2130  timer_cycle();
2131  c.PC = get_word_ticked(c.PC);
2132  c.cycles += 1;
2133  } else {
2134  c.PC += 2;
2135  c.cycles += 3;
2136  }
2137  break;
2138  case 0xDC: /* CALL C, mem16 */
2139  c.cycles += 1;
2140  timer_cycle();
2141  if(flag_C == 1)
2142  {
2143  i = get_word_ticked(c.PC);
2144  c.cycles += 1;
2145  timer_cycle();
2146  c.SP -= 2;
2147  write_word_ticked(c.SP, c.PC+2);
2148  c.PC = i;
2149  } else {
2150  c.PC += 2;
2151  c.cycles += 2;
2152  }
2153  break;
2154  case 0xDE: /* SBC A, imm8 */
2155  t = mem_get_byte(c.PC);
2156  b = flag_C;
2157  set_H(((t&0xF) + flag_C) > (c.A&0xF));
2158  set_C(t + flag_C > c.A);
2159  set_N(1);
2160  c.A -= (b + t);
2161  set_Z(!c.A);
2162  c.PC += 1;
2163  c.cycles += 2;
2164  break;
2165  case 0xDF: /* RST 18 */
2166  c.cycles += 2;
2167  timer_cycle();
2168  c.SP -= 2;
2169  write_word_ticked(c.SP, c.PC);
2170  c.PC = 0x18;
2171  break;
2172  case 0xE0: /* LD (FF00 + imm8), A */
2173  t = mem_get_byte(c.PC);
2174  c.cycles += 2;
2175  timer_cycle();
2176  mem_write_byte(0xFF00 + t, c.A);
2177  c.PC += 1;
2178  c.cycles += 1;
2179  break;
2180  case 0xE1: /* POP HL */
2181  c.cycles += 1;
2182  timer_cycle();
2183  i = get_word_ticked(c.SP);
2184  set_HL(i);
2185  c.SP += 2;
2186  break;
2187  case 0xE2: /* LD (FF00 + C), A */
2188  c.cycles += 1;
2189  timer_cycle();
2190  s = 0xFF00 + c.C;
2191  mem_write_byte(s, c.A);
2192  c.cycles += 1;
2193  break;
2194  case 0xE5: /* PUSH HL */
2195  c.SP -= 2;
2196  c.cycles += 2;
2197  timer_cycle();
2198  write_word_ticked(c.SP, get_HL());
2199  break;
2200  case 0xE6: /* AND A, imm8 */
2201  t = mem_get_byte(c.PC);
2202  set_N(0);
2203  set_H(1);
2204  set_C(0);
2205  c.A = t & c.A;
2206  set_Z(!c.A);
2207  c.PC += 1;
2208  c.cycles += 2;
2209  break;
2210  case 0xE7: /* RST 20 */
2211  c.cycles += 2;
2212  timer_cycle();
2213  c.SP -= 2;
2214  write_word_ticked(c.SP, c.PC);
2215  c.PC = 0x20;
2216  break;
2217  case 0xE8: /* ADD SP, imm8 */
2218  c.cycles += 1;
2219  timer_cycle();
2220  i = mem_get_byte(c.PC);
2221  c.PC += 1;
2222  set_Z(0);
2223  set_N(0);
2224  set_C(((c.SP+i)&0xFF) < (c.SP&0xFF));
2225  set_H(((c.SP+i)&0xF) < (c.SP&0xF));
2226  c.SP += (signed char)i;
2227  c.cycles += 3;
2228  break;
2229  case 0xE9: /* JP HL */
2230  c.PC = get_HL();
2231  c.cycles += 1;
2232  break;
2233  case 0xEA: /* LD (mem16), a */
2234  c.cycles += 1;
2235  timer_cycle();
2236  s = get_word_ticked(c.PC);
2237  mem_write_byte(s, c.A);
2238  c.PC += 2;
2239  c.cycles += 1;
2240  break;
2241  case 0xEE: /* XOR A, imm8 */
2242  c.A ^= mem_get_byte(c.PC);
2243  c.F = (!c.A)<<7;
2244  c.PC += 1;
2245  c.cycles += 2;
2246  break;
2247  case 0xEF: /* RST 28 */
2248  c.cycles += 2;
2249  timer_cycle();
2250  c.SP -= 2;
2251  write_word_ticked(c.SP, c.PC);
2252  c.PC = 0x28;
2253  break;
2254  case 0xF0: /* LD A, (FF00 + imm8) */
2255  t = mem_get_byte(c.PC);
2256  c.cycles += 2;
2257  timer_cycle();
2258  c.A = mem_get_byte(0xFF00 + t);
2259  c.PC += 1;
2260  c.cycles += 1;
2261  break;
2262  case 0xF1: /* POP AF */
2263  c.cycles += 1;
2264  timer_cycle();
2265  s = get_word_ticked(c.SP);
2266  set_AF(s&0xFFF0);
2267  c.SP += 2;
2268  break;
2269  case 0xF2: /* LD A, (FF00 + c) */
2270  c.cycles += 1;
2271  timer_cycle();
2272  c.A = mem_get_byte(0xFF00 + c.C);
2273  c.cycles += 1;
2274  break;
2275  case 0xF3: /* DI */
2276  c.cycles += 1;
2277  interrupt_disable();
2278  break;
2279  case 0xF5: /* PUSH AF */
2280  c.SP -= 2;
2281  mem_write_word(c.SP, get_AF());
2282  c.cycles += 4;
2283  break;
2284  case 0xF6: /* OR A, imm8 */
2285  c.A |= mem_get_byte(c.PC);
2286  c.F = (!c.A)<<7;
2287  c.PC += 1;
2288  c.cycles += 2;
2289  break;
2290  case 0xF7: /* RST 30 */
2291  c.cycles += 2;
2292  timer_cycle();
2293  c.SP -= 2;
2294  write_word_ticked(c.SP, c.PC);
2295  c.PC = 0x30;
2296  break;
2297  case 0xF8: /* LD HL, SP + imm8 */
2298  c.cycles += 1;
2299  timer_cycle();
2300  i = mem_get_byte(c.PC);
2301  set_N(0);
2302  set_Z(0);
2303  set_C(((c.SP+i)&0xFF) < (c.SP&0xFF));
2304  set_H(((c.SP+i)&0xF) < (c.SP&0xF));
2305  set_HL(c.SP + (signed char)i);
2306  c.PC += 1;
2307  c.cycles += 2;
2308  break;
2309  case 0xF9: /* LD SP, HL */
2310  c.SP = get_HL();
2311  c.cycles += 2;
2312  break;
2313  case 0xFA: /* LD A, (mem16) */
2314  c.cycles += 1;
2315  timer_cycle();
2316  s = get_word_ticked(c.PC);
2317  c.A = mem_get_byte(s);
2318  c.PC += 2;
2319  c.cycles += 1;
2320  break;
2321  case 0xFB: /* EI */
2322  if(!interrupt_get_enabled())
2323  ei_flag = 1;
2324 
2325  interrupt_enable();
2326  c.cycles += 1;
2327  break;
2328  case 0xFE: /* CP a, imm8 */
2329  t = mem_get_byte(c.PC);
2330  set_Z(c.A == t);
2331  set_N(1);
2332  set_H(((c.A - t)&0xF) > (c.A&0xF));
2333  set_C(c.A < t);
2334  c.PC += 1;
2335  c.cycles += 2;
2336  break;
2337  case 0xFF: /* RST 38 */
2338  c.cycles += 2;
2339  timer_cycle();
2340  c.SP -= 2;
2341  write_word_ticked(c.SP, c.PC);
2342  c.PC = 0x38;
2343  break;
2344  default:
2345  printf("Unhandled opcode %02X at %04X\n", b, c.PC);
2346  printf("cycles: %d\n", c.cycles);
2347  return 0;
2348  break;
2349  }
2350 
2351  return 1;
2352 }
common.h
Основные определения ядра
CPU
Definition: cpu.c:92