1 /* Code generator for the Hitachi H8/300 architecture simulator.
2
3 Written by Steve Chamberlain of Cygnus Support.
4 sac@cygnus.com
5
6 This file is part of H8/300 sim
7
8
9 THIS SOFTWARE IS NOT COPYRIGHTED
10
11 Cygnus offers the following for use in the public domain. Cygnus
12 makes no warranty with regard to the software or it's performance
13 and the user accepts the software "AS IS" with all faults.
14
15 CYGNUS DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO
16 THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18
19 */
20
21 /* This program reads the H8/300 opcode table and writes out
22 a large switch statement to understand the opcodes (with ifs if
23 there is more than one opcode per case) and code to do the stuff */
24
25 #include <stdio.h>
26
27 #define DEFINE_TABLE
28 #define INSIM
29 #include"opcode/h8300.h"
30
31 #define MAXSAME 140
32
33 #define PTWO 256
34 static struct h8_opcode *h8_opcodes_sorted[PTWO][MAXSAME];
35
36 char *cs = "/*";
37 char *ce = "*/";
38
39 /* How to get at nibble n from the instruction */
40 char *nibs[] =
41 {
42 "foo",
43 "(b0&0xf)",
44 "((b1>>4)&0xf)",
45 "((b1)&0xf)",
46 "((pc[1]>>12)&0xf)",
47 "((pc[1]>>8)&0xf)",
48 "((pc[1]>>4)&0xf)",
49 "((pc[1])&0xf)",
50 0, 0};
51
52 /* how to get at the 3 bit immediate in the instruction */
53 char *imm3[] =
54 {"foo",
55 "foo",
56 "((b1>>4)&0x7)",
57 "foo",
58 "foo",
59 "foo",
60 "(pc[1]>>4)&0x7"};
61
62 /* How to get at a byte register from an index in the instruction at
63 nibble n */
64 char *breg[] =
65 {"foo",
66 "*(blow[b0])",
67 "*(bhigh[b1])",
68 "*(blow[b1])",
69 0, 0,
70 "*(bhigh[pc[1]>>8])"};
71
72 /* How to get at a word register from an index in the instruction at
73 nibble n */
74
75 char *wreg[] =
76 {"foo",
77 "*(wlow[b0])",
78 "*(whigh[b1])",
79 "*(wlow[b1])"};
80
81 #define sorted_key noperands
82
83 /* sort the opcode table into h8_opcodes_sorted[0..255] */
84 static void
init()85 init ()
86 {
87 unsigned int i;
88 struct h8_opcode *p;
89
90 for (p = h8_opcodes; p->name; p++)
91 {
92 int n1 = 0;
93 int n2 = 0;
94 int j;
95 #if 0
96 for (j = 0; p->data.nib[j] != E; j++)
97 {
98 if ((int) p->data.nib[j] == ABS16ORREL8SRC)
99 p->data.nib[j] = ABS16SRC;
100 if ((int) p->data.nib[j] == ABS16OR8SRC)
101 p->data.nib[j] = ABS16SRC;
102 if ((int) p->data.nib[j] == ABS16OR8DST)
103 p->data.nib[j] = ABS16DST;
104 }
105 #endif
106
107 if ((int) p->data.nib[0] < 16)
108 {
109 n1 = (int) p->data.nib[0];
110 }
111 else
112 n1 = 0;
113 if ((int) p->data.nib[1] < 16)
114 {
115 n2 = (int) p->data.nib[1];
116 }
117 else
118 n2 = 0;
119 for (i = 0; i < MAXSAME; i++)
120 {
121 int j = /* ((n3 >> 3) * 512) + ((n4 >> 3) * 256) + */ n1 * 16 + n2;
122
123 if (h8_opcodes_sorted[j][i] == (struct h8_opcode *) NULL)
124 {
125 h8_opcodes_sorted[j][i] = p;
126 p->sorted_key = j;
127 break;
128 }
129 }
130
131 if (i == MAXSAME)
132 abort ();
133
134 /* Just make sure there are an even number of nibbles in it, and
135 that the count is the same s the length */
136 for (i = 0; p->data.nib[i] != E; i++)
137 /*EMPTY*/ ;
138 if (i & 1)
139 abort ();
140 p->length = i / 2;
141 }
142 for (i = 0; i < PTWO; i++)
143 {
144 if (h8_opcodes_sorted[i][0])
145 p = h8_opcodes_sorted[i][0];
146 else
147 h8_opcodes_sorted[i][0] = p;
148 }
149 }
150
151 /* decode the lvalues, creating a pointer in real space to object -
152 remember if the thing has to be swapped out of where it is */
153
154
155 int swap[2];
156
157 lval (p)
158 struct h8_opcode *p;
159 {
160 int i;
161
162 for (i = 0; p->data.nib[i] != E; i++)
163 {
164 int x = p->data.nib[i];
165 int size;
166 int op;
167 op = (x & DST) ? 1 : 0;
168
169 switch (x & SIZE)
170 {
171 case L_32:
172 size = 32;
173 break;
174 case L_16:
175 size = 16;
176 break;
177 case L_8:
178 size = 8;
179 break;
180 default:
181 size = 1234;
182 }
183
184 if (x & REG)
185 {
186 printf ("ir%d = GET_LVAL_%d_REG(%d);\n", op, size, i);
187 }
188 else if (x & IMM)
189 {
190 printf ("/* Imm has no lvalue */\n");
191 }
192
193 }
194
195
196
197 }
198
199 void
decode(p,fetch,size)200 decode (p, fetch, size)
201 struct h8_opcode *p;
202 int fetch;
203 int size;
204 {
205 if (fetch)
206 {
207 lval (p);
208 }
209
210 }
211
212
213
214 static void
esleep()215 esleep ()
216 {
217 printf ("saved_state.exception = SIGSTOP;\n");
218 }
219
220 static void
mov(p,s,sz)221 mov (p, s, sz)
222 struct h8_opcode *p;
223 char *s;
224 int sz;
225 {
226 printf ("dst = srca;\n");
227 }
228
229 static void
andc(p)230 andc (p)
231 struct h8_opcode *p;
232 {
233 printf ("SET_CCR(GET_CCR() & srca);\n");
234 }
235
236 static void
addx(p)237 addx (p)
238 struct h8_opcode *p;
239 {
240 printf ("dst = srca + srcb+ (c != 0);\n");
241 }
242
243 static void
subx(p)244 subx (p)
245 struct h8_opcode *p;
246 {
247 printf ("dst = srcb - srca - (c != 0);\n");
248 }
249
250 static void
add(p,s,sz)251 add (p, s, sz)
252 struct h8_opcode *p;
253 char *s;
254 int sz;
255 {
256 printf ("%s;\n", s);
257 }
258
259 static void
adds(p,s)260 adds (p, s)
261 struct h8_opcode *p;
262 char *s;
263 {
264 printf ("%s;\n", s);
265 }
266
267 static void
bra(p,a)268 bra (p, a)
269 struct h8_opcode *p;
270 char *a;
271 {
272 printf ("if (%s) npc += ((char )b1)>>1;\n", a);
273 }
274
275 static void
bsr(p,a)276 bsr (p, a)
277 struct h8_opcode *p;
278 char *a;
279 {
280 printf ("reg[7]-=2;\n");
281 printf ("tmp = reg[7];\n");
282 printf ("SET_WORD_MEM(tmp, (npc-saved_state.mem)*2);\n");
283 printf ("npc += ((char)b1)>>1;\n");
284 }
285
286 static void
cmp(p,a,s)287 cmp (p, a, s)
288 struct h8_opcode *p;
289 char *a;
290 int s;
291 {
292 decode (p, 1, s);
293 printf ("srca = -srca;\n");
294 printf ("dst = srca + srcb;\n");
295 }
296
297 static
298 void
jsr(p,a,s)299 jsr (p, a, s)
300 struct h8_opcode *p;
301 char *a;
302 int s;
303 {
304 printf ("if (b1 == 0xc4) {\n");
305 printf ("printf(\"%%c\", reg[2]);\n");
306 printf ("}\n");
307 printf ("else {\n");
308 printf ("reg[7]-=2;\n");
309 printf ("tmp = reg[7];\n");
310 printf ("SET_WORD_MEM(tmp, (npc-saved_state.mem)*2);\n");
311 printf ("npc = (lval>>1) + saved_state.mem;\n");
312 printf ("}");
313 }
314
315 static void
jmp(p,a,s)316 jmp (p, a, s)
317 struct h8_opcode *p;
318 char *a;
319 int s;
320 {
321 printf ("npc = (lval>>1) + saved_state.mem;\n");
322 }
323
324 static void
rts(p,a,s)325 rts (p, a, s)
326 struct h8_opcode *p;
327 char *a;
328 int s;
329 {
330 printf ("tmp = reg[7];\n");
331 printf ("reg[7]+=2;\n");
332 printf ("npc = saved_state.mem + (WORD_MEM(tmp)>>1);\n");
333 }
334
335 static void
rte(p,a,s)336 rte (p, a, s)
337 struct h8_opcode *p;
338 char *a;
339 int s;
340 {
341 printf ("reg[7]+=2;\n");
342 printf ("tmp = reg[7];\n");
343 printf ("reg[7]+=2;\n");
344 printf ("SET_CCR(tmp);\n");
345 printf ("npc = saved_state.mem + (WORD_MEM(tmp)>>1);\n");
346 }
347
348 static void
setf(p,a,s)349 setf (p, a, s)
350 struct h8_opcode *p;
351 char *a;
352 int s;
353 {
354 printf ("tmp = GET_CCR();\n");
355 printf ("tmp %s= srca;\n", a);
356 }
357
358 static void
bpt(p,a,s)359 bpt (p, a, s)
360 struct h8_opcode *p;
361 char *a;
362 int s;
363 {
364 printf ("saved_state.exception = SIGTRAP;\n");
365 printf ("npc = pc;\n");
366 }
367
368 static void
log(p,a,s)369 log (p, a, s)
370 struct h8_opcode *p;
371 char *a;
372 int s;
373 {
374 printf ("dst = srcb %s srca;\n", a);
375 }
376
377 static void
ulog(p,a,s)378 ulog (p, a, s)
379 struct h8_opcode *p;
380 char *a;
381 int s;
382 {
383 printf ("dst = %s srcb ;\n", a);
384 }
385
386 static void
nop()387 nop ()
388 {
389 }
390
391 static void
rotl()392 rotl ()
393 {
394 printf ("c = srcb & 0x80;\n");
395 printf ("dst = srcb << 1;\n");
396 printf ("if (c) dst|=1;\n");
397 }
398
399 static void
rotr()400 rotr ()
401 {
402 printf ("c = srcb & 1;\n");
403 printf ("dst = srcb >> 1;\n");
404 printf ("if (c) dst|=0x80;\n");
405 }
406
407 static void
rotxl()408 rotxl ()
409 {
410 printf ("tmp = srcb & 0x80;\n");
411 printf ("dst = srcb << 1;\n");
412 printf ("if (c) dst|=1;\n");
413 printf ("c = tmp;\n");
414 }
415
416 static void
rotxr()417 rotxr ()
418 {
419 printf ("tmp = srcb & 1;\n");
420 printf ("dst = srcb >> 1;\n");
421 printf ("if (c) dst|=0x80;\n");
422 printf ("c = tmp;\n");
423 }
424
425 static void
shal()426 shal ()
427 {
428 printf ("c = srcb&0x80;\n");
429 printf ("dst = srcb << 1;\n");
430 }
431
432 static
433 void
shar()434 shar ()
435 {
436 printf ("c = srcb&0x1;\n");
437 printf ("if (srcb&0x80) dst = (srcb>>1) | 0x80;\n");
438 printf ("else dst = (srcb>>1) &~ 0x80;\n");
439 }
440
441 static
442 void
shll()443 shll ()
444 {
445 printf ("c = srcb&0x80;\n");
446 printf ("dst = srcb << 1;\n");
447 }
448
449 static
450 void
shlr()451 shlr ()
452 {
453 printf ("c = srcb&0x1;\n");
454 printf ("dst = (srcb>>1) &~ 0x80;\n");
455 }
456
457 static
458 void
divxu()459 divxu ()
460 {
461 printf ("srca = %s;\n", breg[2]);
462 printf ("srcb = %s;\n", wreg[3]);
463 printf ("n = srca & 0x80;\n");
464 printf ("z = !srca;\n");
465 printf ("if (srca) dst = srcb / srca;tmp = srcb %% srca;\n");
466 printf ("%s = (dst & 0xff) | (tmp << 8);\n", wreg[3]);
467 }
468
469 static
470 void
mulxu()471 mulxu ()
472 {
473 printf ("srca = %s;\n", breg[2]);
474 printf ("srcb = %s;\n", wreg[3]);
475
476 printf ("dst = (srcb&0xff) * srca;\n");
477 printf ("%s = dst;\n", wreg[3]);
478 }
479
480 static
481 void
inc()482 inc ()
483 {
484 printf ("dst = %s;\n", breg[3]);
485 printf ("v = (dst==0x7f);\n");
486 printf ("dst++;\n");
487 printf ("%s= dst;\n", breg[3]);
488 }
489
490 static
491 void
bit(p,a,s)492 bit (p, a, s)
493 struct h8_opcode *p;
494 char *a;
495 int s;
496 {
497 printf ("%s\n", a);
498 }
499
500 static
501 void
dec()502 dec ()
503 {
504 printf ("dst = %s;\n", breg[3]);
505 printf ("v = (dst==0x80);\n");
506 printf ("dst--;\n");
507 printf ("%s = dst;\n", breg[3]);
508 }
509
510 char saf[] = "goto setflags;";
511 char sf[] = "goto shiftflags;";
512 char af8[] = "goto aluflags8;";
513 char af16[] = "goto aluflags16;";
514 char lf[] = "goto logflags;";
515 char icf[] = "goto incflags;";
516 char mf8[] = "goto movflags8;";
517 char mf16[] = "goto movflags16;";
518 char nx[] = "goto next;";
519
520 struct
521 {
522 char *ftype;
523 int decode;
524 char *name;
525 void (*func) ();
526 char *arg;
527 int size;
528
529 }
530
531 table[] =
532 {
533 {
534 nx, 1, "bld", bit, "dst = srcb; c = (srcb>>srca)&1;", 8
535 }
536 ,
537 {
538 nx, 1, "bild", bit, "dst = srcb; c = !((srcb>>srca)&1);", 8
539 }
540 ,
541 {
542 nx, 1, "band", bit, "dst = srcb; c = C &&((srcb>>srca)&1);", 8
543 }
544 ,
545 {
546 nx, 1, "biand", bit, "dst = srcb; c = C &&(!((srcb>>srca)&1));", 8
547 }
548 ,
549 {
550 nx, 1, "bior", bit, "dst = srcb; c = C ||(!((srcb>>srca)&1));", 8
551 }
552 ,
553 {
554 nx, 1, "bor", bit, "dst = srcb; c = C ||(((srcb>>srca)&1));", 8
555 }
556 ,
557 {
558 nx, 1, "bixor", bit, "dst = srcb; c = C ^(!((srcb>>srca)&1));", 8
559 }
560 ,
561 {
562 nx, 1, "bxor", bit, "dst = srcb; c = C ^(((srcb>>srca)&1));", 8
563 }
564 ,
565 {
566 nx, 1, "bnot", bit, "dst = srcb ^ (1<<srca);", 8
567 }
568 ,
569 {
570 nx, 1, "bclr", bit, "dst = srcb & ~(1<<srca);", 8
571 }
572 ,
573 {
574 nx, 1, "bset", bit, "dst = srcb | (1<<srca);", 8
575 }
576 ,
577 {
578 nx, 1, "bst", bit, "dst = (srcb & ~(1<<srca))| ((C)<<srca);", 8
579 }
580 ,
581 {
582 nx, 1, "bist", bit, "dst = (srcb & ~(1<<srca))| ((!C)<<srca);", 8
583 }
584 ,
585 {
586 nx, 1, "btst", bit, "dst = srcb; z = !((srcb>>srca)&1);", 8
587 }
588 ,
589 {
590 icf, 0, "dec", dec, 0, 0
591 }
592 ,
593 {
594 icf, 0, "inc", inc, 0, 0
595 }
596 ,
597 {
598 saf, 1, "orc", setf, "|", 0
599 }
600 ,
601 {
602 saf, 1, "xorc", setf, "^", 0
603 }
604 ,
605 {
606 saf, 1, "andc", setf, "&", 0
607 }
608 ,
609 {
610 nx, 1, "nop", nop, 0, 0
611 }
612 ,
613 {
614 nx, 1, "bra", bra, "1", 0
615 }
616 ,
617 {
618 nx, 1, "brn", bra, "0", 0
619 }
620 ,
621 {
622 nx, 1, "bhi", bra, "(C||Z)==0", 0
623 }
624 ,
625 {
626 nx, 1, "bls", bra, "(C||Z)==1", 0
627 }
628 ,
629 {
630 nx, 1, "bcs", bra, "C==1", 0
631 }
632 ,
633 {
634 nx, 1, "bcc", bra, "C==0", 0
635 }
636 ,
637 {
638 nx, 1, "bpl", bra, "N==0", 0
639 }
640 ,
641 {
642 nx, 1, "bmi", bra, "N==1", 0
643 }
644 ,
645 {
646 nx, 1, "bvs", bra, "V==1", 0
647 }
648 ,
649 {
650 nx, 1, "bvc", bra, "V==0", 0
651 }
652 ,
653 {
654 nx, 1, "bge", bra, "(N^V)==0", 0
655 }
656 ,
657 {
658 nx, 1, "bgt", bra, "(Z|(N^V))==0", 0
659 }
660 ,
661 {
662 nx, 1, "blt", bra, "(N^V)==1", 0
663 }
664 ,
665 {
666 nx, 1, "ble", bra, "(Z|(N^V))==1", 0
667 }
668 ,
669 {
670 nx, 1, "beq", bra, "Z==1", 0
671 }
672 ,
673 {
674 nx, 1, "bne", bra, "Z==0", 0
675 }
676 ,
677 {
678 nx, 1, "bsr", bsr, "", 0
679 }
680 ,
681 {
682 nx, 1, "jsr", jsr, 0, 0
683 }
684 ,
685 {
686 nx, 1, "jmp", jmp, 0, 0
687 }
688 ,
689 {
690 nx, 0, "rts", rts, 0, 0
691 }
692 ,
693 {
694 nx, 0, "rte", rte, 0, 0
695 }
696 ,
697 {
698 nx, 1, "andc", andc, 0, 0
699 }
700 ,
701 {
702 sf, 1, "shal", shal, 0, 0
703 }
704 ,
705 {
706 sf, 1, "shar", shar, 0, 0
707 }
708 ,
709 {
710 sf, 1, "shll", shll, 0, 0
711 }
712 ,
713 {
714 sf, 1, "shlr", shlr, 0, 0
715 }
716 ,
717 {
718 sf, 1, "rotxl", rotxl, 0, 0
719 }
720 ,
721 {
722 sf, 1, "rotxr", rotxr, 0, 0
723 }
724 ,
725 {
726 sf, 1, "rotl", rotl, 0, 0
727 }
728 ,
729 {
730 sf, 1, "rotr", rotr, 0, 0
731 }
732 ,
733 {
734 lf, 1, "xor", log, "^", 0
735 }
736 ,
737 {
738 lf, 1, "and", log, "&", 0
739 }
740 ,
741 {
742 lf, 1, "or", log, "|", 0
743 }
744 ,
745 {
746 lf, 1, "not", ulog, " ~", 0
747 }
748 ,
749 {
750 lf, 1, "neg", ulog, " - ", 0
751 }
752 ,
753 {
754 nx, 1, "adds", adds, "dst = srca + srcb", 0
755 }
756 ,
757 {
758 nx, 1, "subs", adds, "srca = -srca; dst = srcb + srca", 0
759 }
760 ,
761 {
762 af8, 1, "add.b", add, "dst = srca + srcb", 8
763 }
764 ,
765 {
766 af16, 1, "add.w", add, "dst = srca + srcb", 16
767 }
768 ,
769 {
770 af16, 1, "sub.w", add, "srca = -srca; dst = srcb + srca", 16
771 }
772 ,
773 {
774 af8, 1, "sub.b", add, "srca = -srca; dst = srcb + srca", 8
775 }
776 ,
777 {
778 af8, 1, "addx", addx, 0, 8
779 }
780 ,
781 {
782 af8, 1, "subx", subx, 0, 8
783 }
784 ,
785 {
786 af8, 0, "cmp.b", cmp, 0, 8
787 }
788 ,
789 {
790 af16, 0, "cmp.w", cmp, 0, 16
791 }
792 ,
793 {
794 nx, 1, "sleep", esleep, 0, 0
795 }
796 ,
797 {
798 nx, 0, "bpt", bpt, 0, 8
799 }
800 ,
801 {
802 nx, 0, "divxu", divxu, 0, 0
803 }
804 ,
805 {
806 nx, 0, "mulxu", mulxu, 0, 0
807 }
808 ,
809 {
810 mf8, 1, "mov.b", mov, 0, 8
811 }
812 ,
813 {
814 mf8, 1, "movtpe", mov, 0, 8
815 }
816 ,
817 {
818 mf8, 1, "movfpe", mov, 0, 8
819 }
820 ,
821 {
822 mf16, 1, "mov.w", mov, 0, 16
823 }
824 ,
825 {
826 0
827 }
828 };
829
830 static
831 void
edo(p)832 edo (p)
833 struct h8_opcode *p;
834 {
835 int i;
836
837 printf ("%s %s %s\n", cs, p->name, ce);
838
839 for (i = 0; table[i].name; i++)
840 {
841 if (strcmp (table[i].name, p->name) == 0)
842 {
843 printf ("{\n");
844 if (table[i].decode)
845 decode (p, 1, table[i].size);
846 printf ("cycles += %d;\n", p->time);
847 printf ("npc = pc + %d;\n", p->length / 2);
848 table[i].func (p, table[i].arg, table[i].size);
849 if (table[i].decode)
850 decode (p, 0, table[i].size);
851 if (table[i].ftype)
852 printf (table[i].ftype);
853 else
854 printf ("goto next;\n");
855 printf ("}\n");
856 return;
857 }
858 }
859 printf ("%s not found %s\n", cs, ce);
860 printf ("saved_state.exception = SIGILL;\n");
861 printf ("break;\n");
862 }
863
864 static
865 int
owrite(i)866 owrite (i)
867 int i;
868 {
869 /* write if statements to select the right opcode */
870 struct h8_opcode **p;
871 int needand = 1;
872
873 p = h8_opcodes_sorted[i];
874 printf ("case 0x%03x:\n", i);
875
876 if (p[1] == 0)
877 {
878 /* See if the next few also match */
879 while (h8_opcodes_sorted[i + 1][0] == *p)
880 {
881 i++;
882 printf ("case 0x%03x:\n", i);
883 }
884
885 /* Don't need any if's this is the only one */
886 edo (*p);
887 }
888 else
889 {
890 while (*p)
891 {
892 /* start two nibbles in since we know we match in the first byte */
893 int c;
894 int nib = 2;
895 int byte = 1;
896 int mask1[5];
897 int mask0[5];
898 int nibshift = 4;
899 int any = 0;
900
901 for (c = 0; c < 5; c++)
902 {
903 mask1[c] = 0;
904 mask0[c] = 0;
905 }
906 printf ("%s %x%x", cs, (*p)->data.nib[0], (*p)->data.nib[1]);
907 while ((c = (*p)->data.nib[nib]) != E)
908 {
909 if (c & B30)
910 {
911 /* bit 3 must be zero */
912 mask0[byte] |= 0x8 << nibshift;
913 printf ("0");
914 any = 1;
915 }
916 else if (c & B31)
917 {
918 /* bit 3 must be one */
919 mask1[byte] |= 0x8 << nibshift;
920 printf ("8");
921 any = 1;
922 }
923 else if (c <= HexF)
924 {
925 mask0[byte] |= ((~c) & 0xf) << nibshift;
926 mask1[byte] |= (c & 0xf) << nibshift;
927 printf ("%x", c);
928 any = 1;
929 }
930 else
931 {
932 printf ("x");
933 }
934 nib++;
935 if (nibshift == 4)
936 {
937 nibshift = 0;
938 }
939 else
940 {
941 byte++;
942 nibshift = 4;
943 }
944 }
945 printf ("*/\n");
946 if (any)
947 {
948 printf ("if (");
949 needand = 0;
950 for (c = 1; c < byte; c++)
951 {
952 if (mask0[c] | mask1[c])
953 {
954 int sh;
955
956 if (needand)
957 printf ("\n&&");
958 if (c & 1)
959 sh = 0;
960 else
961 sh = 8;
962 if (c / 2 == 0 && sh == 0)
963 printf ("((b1&0x%x)==0x%x)", mask0[c] | mask1[c],
964 mask1[c]);
965 else
966 {
967 printf ("((pc[%d]&(0x%02x<<%d))==(0x%x<<%d))",
968 c / 2, mask0[c] | mask1[c], sh,
969 mask1[c], sh);
970 }
971
972 needand = 1;
973 }
974 }
975 printf (")\n");
976 }
977 edo (*p);
978 p++;
979
980 }
981 }
982 return i;
983 }
984
985 static
986 void
remove_dups()987 remove_dups ()
988 {
989 struct h8_opcode *s;
990 struct h8_opcode *d;
991
992 for (d = s = h8_opcodes; s->name; s++)
993 {
994 int doit = 1;
995
996 if (strcmp (s->name, "push") == 0)
997 doit = 0;
998 if (strcmp (s->name, "bhs") == 0)
999 doit = 0;
1000 if (strcmp (s->name, "blo") == 0)
1001 doit = 0;
1002 if (strcmp (s->name, "bt") == 0)
1003 doit = 0;
1004 if (strcmp (s->name, "bf") == 0)
1005 doit = 0;
1006 if (strcmp (s->name, "pop") == 0)
1007 doit = 0;
1008 if (doit)
1009 {
1010 *d++ = *s;
1011 }
1012 }
1013 *d++ = *s++;
1014 }
1015
1016 int
main()1017 main ()
1018 {
1019 int i;
1020
1021 remove_dups ();
1022 init ();
1023
1024 printf ("%s do the operation %s\n", cs, ce);
1025 printf ("switch (b0) \n{\n");
1026 for (i = 0; i < PTWO; i++)
1027 {
1028 i = owrite (i);
1029 }
1030 printf ("}\n");
1031
1032 return 0;
1033 }
1034