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