![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to optestxp_gen.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Isaki's NoNo m68k/m88k emulator] / nono / exp / optestxp|
Return to optestxp_gen.cpp CVS log | Up to [Isaki's NoNo m68k/m88k emulator] / nono / exp / optestxp |
1.1 root 1: //
2: // nono
3: // Copyright (C) 2023 nono project
4: // Licensed under nono-license.txt
5: //
6:
7: #include "header.h"
8: #include "mystring.h"
9: #include <vector>
10:
11: class hd64180flag
12: {
13: public:
14: bool S {};
15: bool Z {};
16: bool H {};
17: bool PV {};
18: bool N {};
19: bool C {};
20:
21: uint8 Get() const {
22: uint8 data = 0;
23: if (S) data |= 0x80;
24: if (Z) data |= 0x40;
25: if (H) data |= 0x10;
26: if (PV) data |= 0x04;
27: if (N) data |= 0x02;
28: if (C) data |= 0x01;
29: return data;
30: }
31: };
32:
33: static void out(const char *, ...);
34:
35: static const char *name;
36: static int testpos;
37: static std::vector<std::string> testlist;
38:
39: static std::vector<uint8> values1 = {
40: 0x00,
41: 0x01,
42: 0x0f,
43: 0x10,
44: 0x7f,
45: 0x80,
46: 0xff,
47: };
48: static std::vector<uint8> values2 = {
49: 0x00,
50: 0x01,
51: 0x03,
52: 0x55,
53: 0x7f,
54: 0xaa,
55: 0xff,
56: };
57:
58: static inline bool
59: vflag_add(uint32 dst, uint32 src, uint32 res)
60: {
61: uint32 v = (src ^ res) & (dst ^ res);
62: return (v & 0x80);
63: }
64:
65: static inline bool
66: vflag_sub(uint32 dst, uint32 src, uint32 res)
67: {
68: uint32 v = (src ^ dst) & (dst ^ res);
69: return (v & 0x80);
70: }
71:
72: static bool
73: hflag_add(uint32 dst, uint32 src)
74: {
75: uint32 res = (dst & 0x0f) + (src & 0x0f);
76: return (res & 0x10);
77: }
78:
79: static bool
80: hflag_sub(uint32 dst, uint32 src)
81: {
82: uint32 res = (dst & 0x0f) - (src & 0x0f);
83: return (res & 0x10);
84: }
85:
86: static bool
87: pflag(uint32 res)
88: {
89: return ((__builtin_popcount(res) & 1) == 0);
90: }
91:
92: // gentest の最初で行うことまとめ。
93: static void
94: init(const char *name_, const char *method)
95: {
96: name = name_;
97: testlist.push_back(name);
98:
99: out("test_%s:\n", name);
100: out(" LD HL,testset_%s\n", name);
101: out(" JP %s\n", method);
102:
103: testpos = 0;
104: }
105:
106: // テストセットのテーブルを出力。
107: static void
108: out_testset(const char *name)
109: {
110: out("testset_%s:\n", name);
111: out(" defw testname_%s\n", name);
112: out(" defw testexec_%s\n", name);
113: out(" defw testdata_%s_00\n", name);
114:
115: out("testname_%s:\n", name);
116: std::string upper = string_toupper(name);
117: out(" defm \"%s $\"\n", upper.c_str());
118: out("\n");
119: }
120:
121: // testrun1 テスト用のデータテーブルを出力。
122: static void
123: out_testdata_run1(uint32 dst, const hd64180flag& inflag,
124: uint32 res, const hd64180flag& flag)
125: {
126: out("testdata_%s_%02x:", name, testpos++);
127: out(" defb 0%02xH,0%02xH,0%02xH,0%02xH\n",
128: dst, inflag.Get(), res, flag.Get());
129: }
130:
131: // testrun2 テスト用のデータテーブルを出力。
132: static void
133: out_testdata_run2(uint32 dst, const hd64180flag& inflag, uint32 src,
134: uint32 res, const hd64180flag& flag)
135: {
136: out("testdata_%s_%02x:", name, testpos++);
137: out(" defb 0%02xH,0%02xH,0%02xH,0%02xH,0%02xH\n",
138: dst, inflag.Get(), src, res, flag.Get());
139: }
140:
141: static void
142: gentest_add()
143: {
144: init("add", "testrun2");
145:
146: out("testexec_%s:\n", name);
147: out(" ADD A,D\n");
148: out(" RET\n");
149:
150: out_testset(name);
151:
152: for (auto dst : values1) {
153: for (auto src : values1) {
154: uint32 res32 = dst + src;
155: uint8 res = res32;
156: hd64180flag inflag;
157: inflag.N = true;
158: hd64180flag flag;
159: flag.Z = (res == 0);
160: flag.S = ((res & 0x80) != 0);
161: flag.C = ((res32 & 0x0100) != 0);
162: flag.PV = vflag_add(dst, src, res);
163: flag.H = hflag_add(dst, src);
164: flag.N = false;
165: out_testdata_run2(dst, inflag, src, res, flag);
166: }
167: }
168: out(" defb 0,0,0,0,0FFH\n");
169: out("\n");
170: }
171:
172: static void
173: gentest_adc()
174: {
175: init("adc", "testrun2");
176:
177: out("testexec_%s:\n", name);
178: out(" ADC A,D\n");
179: out(" RET\n");
180:
181: out_testset(name);
182:
183: for (auto dst : values1) {
184: for (auto src : values1) {
185: for (int cin = 0; cin <= 1; cin++) {
186: uint32 res32 = dst + src + cin;
187: uint8 res = res32;
188: hd64180flag inflag;
189: inflag.C = cin;
190: inflag.N = true;
191: hd64180flag flag;
192: flag.Z = (res == 0);
193: flag.S = ((res & 0x80) != 0);
194: flag.C = ((res32 & 0x0100) != 0);
195: flag.PV = vflag_add(dst, src, res);
196: flag.H = hflag_add(dst, src) | hflag_add(src + dst, cin);
197: flag.N = false;
198: out_testdata_run2(dst, inflag, src, res, flag);
199: }
200: }
201: }
202: out(" defb 0,0,0,0,0FFH\n");
203: out("\n");
204: }
205:
206: static void
207: gentest_sub()
208: {
209: init("sub", "testrun2");
210:
211: out("testexec_%s:\n", name);
212: out(" SUB D\n");
213: out(" RET\n");
214:
215: out_testset(name);
216:
217: for (auto dst : values1) {
218: for (auto src : values1) {
219: uint32 res32 = dst - src;
220: uint8 res = res32;
221: hd64180flag inflag;
222: inflag.N = false;
223: hd64180flag flag;
224: flag.Z = (res == 0);
225: flag.S = ((res & 0x80) != 0);
226: flag.C = ((res32 & 0x0100) != 0);
227: flag.PV = vflag_sub(dst, src, res);
228: flag.H = hflag_sub(dst, src);
229: flag.N = true;
230: out_testdata_run2(dst, inflag, src, res, flag);
231: }
232: }
233: out(" defb 0,0,0,0,0FFH\n");
234: out("\n");
235: }
236:
237: static void
238: gentest_sbc()
239: {
240: init("sbc", "testrun2");
241:
242: out("testexec_%s:\n", name);
243: out(" SBC A,D\n");
244: out(" RET\n");
245:
246: out_testset(name);
247:
248: for (auto dst : values1) {
249: for (auto src : values1) {
250: for (int cin = 0; cin <= 1; cin++) {
251: uint32 res32 = dst - src - cin;
252: uint8 res = res32;
253: hd64180flag inflag;
254: inflag.C = cin;
255: inflag.N = false;
256: hd64180flag flag;
257: flag.Z = (res == 0);
258: flag.S = ((res & 0x80) != 0);
259: flag.C = ((res32 & 0x0100) != 0);
260: flag.PV = vflag_sub(dst, src, res);
261: flag.H = hflag_sub(dst, src) | hflag_sub(dst - src, cin);
262: flag.N = true;
263: out_testdata_run2(dst, inflag, src, res, flag);
264: }
265: }
266: }
267: out(" defb 0,0,0,0,0FFH\n");
268: out("\n");
269: }
270:
271: static void
272: gentest_and()
273: {
274: init("and", "testrun2");
275:
276: out("testexec_%s:\n", name);
277: out(" AND D\n");
278: out(" RET\n");
279:
280: out_testset(name);
281:
282: for (auto dst : values2) {
283: for (auto src : values2) {
284: uint32 res32 = dst & src;
285: uint8 res = res32;
286: hd64180flag inflag;
287: inflag.H = false;
288: inflag.N = true;
289: inflag.C = true;
290: hd64180flag flag;
291: flag.Z = (res == 0);
292: flag.S = ((res & 0x80) != 0);
293: flag.C = false;
294: flag.PV = pflag(res);
295: flag.H = true;
296: flag.N = false;
297: out_testdata_run2(dst, inflag, src, res, flag);
298: }
299: }
300: out(" defb 0,0,0,0,0FFH\n");
301: out("\n");
302: }
303:
304: static void
305: gentest_or()
306: {
307: init("or", "testrun2");
308:
309: out("testexec_%s:\n", name);
310: out(" OR D\n");
311: out(" RET\n");
312:
313: out_testset(name);
314:
315: for (auto dst : values2) {
316: for (auto src : values2) {
317: uint32 res32 = dst | src;
318: uint8 res = res32;
319: hd64180flag inflag;
320: inflag.H = true;
321: inflag.N = true;
322: inflag.C = true;
323: hd64180flag flag;
324: flag.Z = (res == 0);
325: flag.S = ((res & 0x80) != 0);
326: flag.C = false;
327: flag.PV = pflag(res);
328: flag.H = false;
329: flag.N = false;
330: out_testdata_run2(dst, inflag, src, res, flag);
331: }
332: }
333: out(" defb 0,0,0,0,0FFH\n");
334: out("\n");
335: }
336:
337: static void
338: gentest_xor()
339: {
340: init("xor", "testrun2");
341:
342: out("testexec_%s:\n", name);
343: out(" XOR D\n");
344: out(" RET\n");
345:
346: out_testset(name);
347:
348: for (auto dst : values2) {
349: for (auto src : values2) {
350: uint32 res32 = dst ^ src;
351: uint8 res = res32;
352: hd64180flag inflag;
353: inflag.H = true;
354: inflag.N = true;
355: inflag.C = true;
356: hd64180flag flag;
357: flag.Z = (res == 0);
358: flag.S = ((res & 0x80) != 0);
359: flag.C = false;
360: flag.PV = pflag(res);
361: flag.H = false;
362: flag.N = false;
363: out_testdata_run2(dst, inflag, src, res, flag);
364: }
365: }
366: out(" defb 0,0,0,0,0FFH\n");
367: out("\n");
368: }
369:
370: static void
371: gentest_cp()
372: {
373: init("cp", "testrun2");
374:
375: out("testexec_%s:\n", name);
376: out(" CP D\n");
377: out(" RET\n");
378:
379: out_testset(name);
380:
381: for (auto dst : values1) {
382: for (auto src : values1) {
383: uint32 res32 = dst - src;
384: uint8 res = res32;
385: hd64180flag inflag;
386: inflag.N = false;
387: hd64180flag flag;
388: flag.Z = (res == 0);
389: flag.S = ((res & 0x80) != 0);
390: flag.C = ((res32 & 0x0100) != 0);
391: flag.PV = vflag_sub(dst, src, res);
392: flag.H = hflag_sub(dst, src);
393: flag.N = true;
394: out_testdata_run2(dst, inflag, src, dst, flag);
395: }
396: }
397: out(" defb 0,0,0,0,0FFH\n");
398: out("\n");
399: }
400:
401: static void
402: gentest_inc()
403: {
404: init("inc", "testrun1");
405:
406: out("testexec_%s:\n", name);
407: out(" INC A\n");
408: out(" RET\n");
409:
410: out_testset(name);
411:
412: for (auto dst : values1) {
413: for (int cin = 0; cin <= 1; cin++) {
414: uint32 res32 = dst + 1;
415: uint8 res = res32;
416: hd64180flag inflag;
417: inflag.C = cin;
418: inflag.N = true;
419: hd64180flag flag;
420: flag.Z = (res == 0);
421: flag.S = ((res & 0x80) != 0);
422: flag.C = cin;
423: flag.PV = vflag_add(dst, 1, res);
424: flag.H = hflag_add(dst, 1);
425: flag.N = false;
426: out_testdata_run1(dst, inflag, res, flag);
427: }
428: }
429: out(" defb 0,0,0,0FFH\n");
430: out("\n");
431: }
432:
433: static void
434: gentest_dec()
435: {
436: init("dec", "testrun1");
437:
438: out("testexec_%s:\n", name);
439: out(" DEC A\n");
440: out(" RET\n");
441:
442: out_testset(name);
443:
444: for (auto dst : values1) {
445: for (int cin = 0; cin <= 1; cin++) {
446: uint32 res32 = dst - 1;
447: uint8 res = res32;
448: hd64180flag inflag;
449: inflag.C = cin;
450: inflag.N = false;
451: hd64180flag flag;
452: flag.Z = (res == 0);
453: flag.S = ((res & 0x80) != 0);
454: flag.C = cin;
455: flag.PV = vflag_sub(dst, 1, res);
456: flag.H = hflag_sub(dst, 1);
457: flag.N = true;
458: out_testdata_run1(dst, inflag, res, flag);
459: }
460: }
461: out(" defb 0,0,0,0FFH\n");
462: out("\n");
463: }
464:
465: static void
466: gentest_neg()
467: {
468: init("neg", "testrun1");
469:
470: out("testexec_%s:\n", name);
471: out(" NEG\n");
472: out(" RET\n");
473:
474: out_testset(name);
475:
476: for (auto dst : values1) {
477: uint32 res32 = 0 - dst;
478: uint8 res = res32;
479: hd64180flag inflag;
480: inflag.N = false;
481: hd64180flag flag;
482: flag.Z = (res == 0);
483: flag.S = ((res & 0x80) != 0);
484: flag.C = ((res32 & 0x100) != 0);
485: flag.PV = vflag_sub(0, dst, res);
486: flag.H = hflag_sub(0, dst);
487: flag.N = true;
488: out_testdata_run1(dst, inflag, res, flag);
489: }
490: out(" defb 0,0,0,0FFH\n");
491: out("\n");
492: }
493:
494: static void
495: gentest_cpl()
496: {
497: init("cpl", "testrun1");
498:
499: out("testexec_%s:\n", name);
500: out(" CPL\n");
501: out(" RET\n");
502:
503: out_testset(name);
504:
505: bool fin = false;
506: for (auto dst : values2) {
507: fin = !fin;
508: uint32 res32 = ~dst;
509: uint8 res = res32;
510: hd64180flag inflag;
511: inflag.Z = fin;
512: inflag.S = fin;
513: inflag.C = fin;
514: inflag.PV = fin;
515: inflag.N = false;
516: inflag.H = false;
517: hd64180flag flag;
518: flag.Z = fin;
519: flag.S = fin;
520: flag.C = fin;
521: flag.PV = fin;
522: flag.H = true;
523: flag.N = true;
524: out_testdata_run1(dst, inflag, res, flag);
525: }
526: out(" defb 0,0,0,0FFH\n");
527: out("\n");
528: }
529:
530: static void
531: gentest_rla()
532: {
533: init("rla", "testrun1");
534:
535: out("testexec_%s:\n", name);
536: out(" RLA\n");
537: out(" RET\n");
538:
539: out_testset(name);
540:
541: bool fin = false;
542: for (auto dst : values2) {
543: fin = !fin;
544: for (int cin = 0; cin <= 1; cin++) {
545: uint32 res32 = dst << 1;
546: res32 |= cin;
547: uint8 res = res32;
548: hd64180flag inflag;
549: inflag.Z = fin;
550: inflag.S = fin;
551: inflag.C = cin;
552: inflag.PV = fin;
553: inflag.N = true;
554: inflag.H = true;
555: hd64180flag flag;
556: flag.Z = fin;
557: flag.S = fin;
558: flag.C = ((res32 & 0x100) != 0);
559: flag.PV = fin;
560: flag.H = false;
561: flag.N = false;
562: out_testdata_run1(dst, inflag, res, flag);
563: }
564: }
565: out(" defb 0,0,0,0FFH\n");
566: out("\n");
567: }
568:
569: static void
570: gentest_rra()
571: {
572: init("rra", "testrun1");
573:
574: out("testexec_%s:\n", name);
575: out(" RRA\n");
576: out(" RET\n");
577:
578: out_testset(name);
579:
580: bool fin = false;
581: for (auto dst : values2) {
582: fin = !fin;
583: for (int cin = 0; cin <= 1; cin++) {
584: uint32 res32 = dst >> 1;
585: res32 |= cin ? 0x80 : 0;
586: uint8 res = res32;
587: hd64180flag inflag;
588: inflag.Z = fin;
589: inflag.S = fin;
590: inflag.C = cin;
591: inflag.PV = fin;
592: inflag.N = true;
593: inflag.H = true;
594: hd64180flag flag;
595: flag.Z = fin;
596: flag.S = fin;
597: flag.C = ((dst & 1) != 0);
598: flag.PV = fin;
599: flag.H = false;
600: flag.N = false;
601: out_testdata_run1(dst, inflag, res, flag);
602: }
603: }
604: out(" defb 0,0,0,0FFH\n");
605: out("\n");
606: }
607:
608: static void
609: gentest_rlca()
610: {
611: init("rlca", "testrun1");
612:
613: out("testexec_%s:\n", name);
614: out(" RLCA\n");
615: out(" RET\n");
616:
617: out_testset(name);
618:
619: bool fin = false;
620: for (auto dst : values2) {
621: fin = !fin;
622: uint32 res32 = dst << 1;
623: res32 |= (res32 >> 8);
624: uint8 res = res32;
625: hd64180flag inflag;
626: inflag.Z = fin;
627: inflag.S = fin;
628: inflag.PV = fin;
629: inflag.N = true;
630: inflag.H = true;
631: hd64180flag flag;
632: flag.Z = fin;
633: flag.S = fin;
634: flag.C = ((res32 & 0x100) != 0);
635: flag.PV = fin;
636: flag.H = false;
637: flag.N = false;
638: out_testdata_run1(dst, inflag, res, flag);
639: }
640: out(" defb 0,0,0,0FFH\n");
641: out("\n");
642: }
643:
644: static void
645: gentest_rrca()
646: {
647: init("rrca", "testrun1");
648:
649: out("testexec_%s:\n", name);
650: out(" RRCA\n");
651: out(" RET\n");
652:
653: out_testset(name);
654:
655: bool fin = false;
656: for (auto dst : values2) {
657: fin = !fin;
658: uint32 res32 = dst >> 1;
659: res32 |= dst << 7;
660: uint8 res = res32;
661: hd64180flag inflag;
662: inflag.Z = fin;
663: inflag.S = fin;
664: inflag.PV = fin;
665: inflag.N = true;
666: inflag.H = true;
667: hd64180flag flag;
668: flag.Z = fin;
669: flag.S = fin;
670: flag.C = ((dst & 1) != 0);
671: flag.PV = fin;
672: flag.H = false;
673: flag.N = false;
674: out_testdata_run1(dst, inflag, res, flag);
675: }
676: out(" defb 0,0,0,0FFH\n");
677: out("\n");
678: }
679:
680: static void
681: gentest_rl()
682: {
683: init("rl", "testrun1");
684:
685: out("testexec_%s:\n", name);
686: out(" RL A\n");
687: out(" RET\n");
688:
689: out_testset(name);
690:
691: for (auto dst : values2) {
692: for (int cin = 0; cin <= 1; cin++) {
693: uint32 res32 = dst << 1;
694: res32 |= cin;
695: uint8 res = res32;
696: hd64180flag inflag;
697: inflag.C = cin;
698: inflag.N = true;
699: inflag.H = true;
700: hd64180flag flag;
701: flag.Z = (res == 0);
702: flag.S = ((res & 0x80) != 0);
703: flag.C = ((res32 & 0x100) != 0);
704: flag.PV = pflag(res);
705: flag.H = false;
706: flag.N = false;
707: out_testdata_run1(dst, inflag, res, flag);
708: }
709: }
710: out(" defb 0,0,0,0FFH\n");
711: out("\n");
712: }
713:
714: static void
715: gentest_rr()
716: {
717: init("rr", "testrun1");
718:
719: out("testexec_%s:\n", name);
720: out(" RR A\n");
721: out(" RET\n");
722:
723: out_testset(name);
724:
725: for (auto dst : values2) {
726: for (int cin = 0; cin <= 1; cin++) {
727: uint32 res32 = dst >> 1;
728: res32 |= cin ? 0x80 : 0;
729: uint8 res = res32;
730: hd64180flag inflag;
731: inflag.C = cin;
732: inflag.N = true;
733: inflag.H = true;
734: hd64180flag flag;
735: flag.Z = (res == 0);
736: flag.S = ((res & 0x80) != 0);
737: flag.C = ((dst & 1) != 0);
738: flag.PV = pflag(res);
739: flag.H = false;
740: flag.N = false;
741: out_testdata_run1(dst, inflag, res, flag);
742: }
743: }
744: out(" defb 0,0,0,0FFH\n");
745: out("\n");
746: }
747:
748: static void
749: gentest_rlc()
750: {
751: init("rlc", "testrun1");
752:
753: out("testexec_%s:\n", name);
754: out(" RLC A\n");
755: out(" RET\n");
756:
757: out_testset(name);
758:
759: for (auto dst : values2) {
760: uint32 res32 = dst << 1;
761: res32 |= (res32 >> 8);
762: uint8 res = res32;
763: hd64180flag inflag;
764: inflag.N = true;
765: inflag.H = true;
766: hd64180flag flag;
767: flag.Z = (res == 0);
768: flag.S = ((res & 0x80) != 0);
769: flag.C = ((res32 & 0x100) != 0);
770: flag.PV = pflag(res);
771: flag.H = false;
772: flag.N = false;
773: out_testdata_run1(dst, inflag, res, flag);
774: }
775: out(" defb 0,0,0,0FFH\n");
776: out("\n");
777: }
778:
779: static void
780: gentest_rrc()
781: {
782: init("rrc", "testrun1");
783:
784: out("testexec_%s:\n", name);
785: out(" RRC A\n");
786: out(" RET\n");
787:
788: out_testset(name);
789:
790: for (auto dst : values2) {
791: uint32 res32 = dst >> 1;
792: res32 |= dst << 7;
793: uint8 res = res32;
794: hd64180flag inflag;
795: inflag.N = true;
796: inflag.H = true;
797: hd64180flag flag;
798: flag.Z = (res == 0);
799: flag.S = ((res & 0x80) != 0);
800: flag.C = ((dst & 1) != 0);
801: flag.PV = pflag(res);
802: flag.H = false;
803: flag.N = false;
804: out_testdata_run1(dst, inflag, res, flag);
805: }
806: out(" defb 0,0,0,0FFH\n");
807: out("\n");
808: }
809:
810: static void
811: gentest_sla()
812: {
813: init("sla", "testrun1");
814:
815: out("testexec_%s:\n", name);
816: out(" SLA A\n");
817: out(" RET\n");
818:
819: out_testset(name);
820:
821: for (auto dst : values2) {
822: uint32 res32 = dst << 1;
823: uint8 res = res32;
824: hd64180flag inflag;
825: inflag.N = true;
826: inflag.H = true;
827: hd64180flag flag;
828: flag.Z = (res == 0);
829: flag.S = ((res & 0x80) != 0);
830: flag.C = ((res32 & 0x100) != 0);
831: flag.PV = pflag(res);
832: flag.H = false;
833: flag.N = false;
834: out_testdata_run1(dst, inflag, res, flag);
835: }
836: out(" defb 0,0,0,0FFH\n");
837: out("\n");
838: }
839:
840: static void
841: gentest_sra()
842: {
843: init("sra", "testrun1");
844:
845: out("testexec_%s:\n", name);
846: out(" SRA A\n");
847: out(" RET\n");
848:
849: out_testset(name);
850:
851: for (auto dst : values2) {
852: uint32 res32 = dst >> 1;
853: res32 |= (dst & 0x80);
854: uint8 res = res32;
855: hd64180flag inflag;
856: inflag.N = true;
857: inflag.H = true;
858: hd64180flag flag;
859: flag.Z = (res == 0);
860: flag.S = ((res & 0x80) != 0);
861: flag.C = ((dst & 1) != 0);
862: flag.PV = pflag(res);
863: flag.H = false;
864: flag.N = false;
865: out_testdata_run1(dst, inflag, res, flag);
866: }
867: out(" defb 0,0,0,0FFH\n");
868: out("\n");
869: }
870:
871: static void
872: gentest_srl()
873: {
874: init("srl", "testrun1");
875:
876: out("testexec_%s:\n", name);
877: out(" SRL A\n");
878: out(" RET\n");
879:
880: out_testset(name);
881:
882: for (auto dst : values2) {
883: uint32 res32 = dst >> 1;
884: uint8 res = res32;
885: hd64180flag inflag;
886: inflag.N = true;
887: inflag.H = true;
888: hd64180flag flag;
889: flag.Z = (res == 0);
890: flag.S = ((res & 0x80) != 0);
891: flag.C = ((dst & 1) != 0);
892: flag.PV = pflag(res);
893: flag.H = false;
894: flag.N = false;
895: out_testdata_run1(dst, inflag, res, flag);
896: }
897: out(" defb 0,0,0,0FFH\n");
898: out("\n");
899: }
900:
901: static void
902: out(const char *fmt, ...)
903: {
904: va_list ap;
905:
906: va_start(ap, fmt);
907: vprintf(fmt, ap);
908: va_end(ap);
909: }
910:
911: int
912: main(int ac, char *av[])
913: {
914: out(" org 0100H\n");
915: out(" JP main\n");
916: out("\n");
917:
918: gentest_add();
919: gentest_adc();
920: gentest_sub();
921: gentest_sbc();
922: gentest_and();
923: gentest_or();
924: gentest_xor();
925: gentest_cp();
926:
927: gentest_inc();
928: gentest_dec();
929: gentest_neg();
930: gentest_cpl();
931:
932: gentest_rla();
933: gentest_rra();
934: gentest_rlca();
935: gentest_rrca();
936:
937: gentest_rl();
938: gentest_rr();
939: gentest_rlc();
940: gentest_rrc();
941: gentest_sla();
942: gentest_sra();
943: gentest_srl();
944:
945: out("main:\n");
946: for (auto name : testlist) {
947: out(" CALL test_%s\n", name.c_str());
948: }
949: out(" RET\n");
950: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.