diff -rc --new-file lcc35/src/bind.c lcc/src/bind.c *** lcc35/src/bind.c Fri Feb 2 20:18:55 1996 --- lcc/src/bind.c Thu Feb 29 19:15:30 1996 *************** *** 3,8 **** --- 3,9 ---- extern Interface mipsebIR, mipselIR; extern Interface sparcIR, solarisIR; extern Interface x86IR; + extern Interface m68kIR, amigaosIR; Binding bindings[] = { "symbolic", &symbolicIR, "mips-irix", &mipsebIR, *************** *** 10,15 **** --- 11,17 ---- "sparc-sun", &sparcIR, "sparc-solaris", &solarisIR, "x86-dos", &x86IR, + "m68k-amigaos", &m68kIR, "null", &nullIR, NULL, NULL }; diff -rc --new-file lcc35/src/c.h lcc/src/c.h *** lcc35/src/c.h Fri Feb 2 20:19:44 1996 --- lcc/src/c.h Mon Mar 4 23:54:36 1996 *************** *** 97,102 **** --- 97,105 ---- typedef struct coord { char *file; unsigned x, y; + #ifdef AMIGA + char *source_line; + #endif } Coordinate; typedef struct table *Table; *************** *** 518,523 **** --- 521,529 ---- extern unsigned char *cp; extern unsigned char *limit; extern int infd; + #ifdef AMIGA + extern char *input_file; + #endif extern char *firstfile; extern char *file; extern char *line; *************** *** 533,538 **** --- 539,547 ---- extern Symbol YYcheck; extern int glevel; extern int xref; + #ifdef AMIGA + extern int annotate; + #endif extern int outfd; extern int errfd; *************** *** 752,757 **** --- 761,770 ---- /* limits */ #ifdef __STDC__ #include + #ifdef AMIGA + #undef SCHAR_MIN + #define SCHAR_MIN -128 + #endif #include #else /* *************** *** 803,807 **** extern int strncmp ARGS((const char *, const char *, size_t)); extern char *strncpy ARGS((char *, const char *, size_t)); extern int write ARGS((int, char *, int)); ! --- 816,820 ---- extern int strncmp ARGS((const char *, const char *, size_t)); extern char *strncpy ARGS((char *, const char *, size_t)); extern int write ARGS((int, char *, int)); ! extern char *strrchr ARGS((const char *, int)); diff -rc --new-file lcc35/src/config.h lcc/src/config.h *** lcc35/src/config.h Fri Feb 2 20:19:21 1996 --- lcc/src/config.h Thu Feb 8 00:21:16 1996 *************** *** 57,63 **** unsigned mayrecalc:1; void *state; short inst; ! Node kids[3]; Node prev, next; Node prevuse; short argno; --- 57,63 ---- unsigned mayrecalc:1; void *state; short inst; ! Node kids[4]; Node prev, next; Node prevuse; short argno; diff -rc --new-file lcc35/src/main.c lcc/src/main.c *** lcc35/src/main.c Fri Feb 2 20:19:09 1996 --- lcc/src/main.c Mon Mar 4 21:35:32 1996 *************** *** 17,22 **** --- 17,25 ---- int xref; /* != 0 for cross-reference data */ Symbol YYnull; /* _YYnull symbol if -n or -nvalidate specified */ Symbol YYcheck; /* _YYcheck symbol if -nvalidate,check specified */ + #ifdef AMIGA + int annotate=0; /* if set specifies to output C-source to the assembler file */ + #endif int main(argc, argv) int argc; char *argv[]; { { *************** *** 47,52 **** --- 50,64 ---- typeInit(); argc = doargs(argc, argv); if (infile && strcmp(infile, "-") != 0) + #ifdef AMIGA + /* We need the name of the source file for the IDNT and DBUG assembler + directives. This is generally stored in "firstfile", except when + rcc is run directly on the unpreprocessed C source, when + firstfile=0. In this case, we can use the name of the input file as + the source file name. + */ + input_file = infile; + #endif if ((infd = open(infile, 0)) < 0) { fprint(2, "%s: can't read `%s'\n", argv[0], infile); *************** *** 120,125 **** --- 132,144 ---- xref++; else if (strcmp(argv[i], "-A") == 0) ++Aflag; + #ifdef AMIGA + /* annotate flag is exported to other modules (mc68030.c) which use it */ + else if (strcmp(argv[i], "-annotate") == 0) { + annotate = 1; + glevel = 1; + } + #endif else if (strcmp(argv[i], "-P") == 0) Pflag++; else if (strcmp(argv[i], "-w") == 0) diff -rc --new-file lcc35/src/makefile lcc/src/makefile *** lcc35/src/makefile Fri Feb 2 20:19:49 1996 --- lcc/src/makefile Thu Jan 1 00:00:00 1970 *************** *** 1,103 **** - SHELL=/bin/sh - SRC=../../src - - OBJS=alloc.o bind.o dag.o decl.o enode.o error.o expr.o event.o \ - init.o input.o lex.o list.o main.o output.o prof.o profio.o simp.o \ - stmt.o string.o sym.o trace.o tree.o types.o \ - null.o symbolic.o gen.o mips.o sparc.o x86.o - - rcc: $(OBJS) - $(CC) $(CFLAGS) -o $@ $(LDFLAGS) $(OBJS) - - $(OBJS): $(SRC)/c.h $(SRC)/token.h $(SRC)/config.h - - alloc.o: $(SRC)/alloc.c; $(CC) -c $(CFLAGS) $(SRC)/alloc.c - bind.o: $(SRC)/bind.c; $(CC) -c $(CFLAGS) $(SRC)/bind.c - dag.o: $(SRC)/dag.c; $(CC) -c $(CFLAGS) $(SRC)/dag.c - decl.o: $(SRC)/decl.c; $(CC) -c $(CFLAGS) $(SRC)/decl.c - enode.o: $(SRC)/enode.c; $(CC) -c $(CFLAGS) $(SRC)/enode.c - error.o: $(SRC)/error.c; $(CC) -c $(CFLAGS) $(SRC)/error.c - event.o: $(SRC)/event.c; $(CC) -c $(CFLAGS) $(SRC)/event.c - expr.o: $(SRC)/expr.c; $(CC) -c $(CFLAGS) $(SRC)/expr.c - gen.o: $(SRC)/gen.c; $(CC) -c $(CFLAGS) $(SRC)/gen.c - init.o: $(SRC)/init.c; $(CC) -c $(CFLAGS) $(SRC)/init.c - input.o: $(SRC)/input.c; $(CC) -c $(CFLAGS) $(SRC)/input.c - lex.o: $(SRC)/lex.c; $(CC) -c $(CFLAGS) $(SRC)/lex.c - list.o: $(SRC)/list.c; $(CC) -c $(CFLAGS) $(SRC)/list.c - main.o: $(SRC)/main.c; $(CC) -c $(CFLAGS) $(SRC)/main.c - mips.o: $(SRC)/mips.c; $(CC) -c $(CFLAGS) $(SRC)/mips.c - null.o: $(SRC)/null.c; $(CC) -c $(CFLAGS) $(SRC)/null.c - output.o: $(SRC)/output.c; $(CC) -c $(CFLAGS) $(SRC)/output.c - prof.o: $(SRC)/prof.c; $(CC) -c $(CFLAGS) $(SRC)/prof.c - profio.o: $(SRC)/profio.c; $(CC) -c $(CFLAGS) $(SRC)/profio.c - simp.o: $(SRC)/simp.c; $(CC) -c $(CFLAGS) $(SRC)/simp.c - sparc.o: $(SRC)/sparc.c; $(CC) -c $(CFLAGS) $(SRC)/sparc.c - stmt.o: $(SRC)/stmt.c; $(CC) -c $(CFLAGS) $(SRC)/stmt.c - string.o: $(SRC)/string.c; $(CC) -c $(CFLAGS) $(SRC)/string.c - sym.o: $(SRC)/sym.c; $(CC) -c $(CFLAGS) $(SRC)/sym.c - symbolic.o: $(SRC)/symbolic.c; $(CC) -c $(CFLAGS) $(SRC)/symbolic.c - trace.o: $(SRC)/trace.c; $(CC) -c $(CFLAGS) $(SRC)/trace.c - tree.o: $(SRC)/tree.c; $(CC) -c $(CFLAGS) $(SRC)/tree.c - types.o: $(SRC)/types.c; $(CC) -c $(CFLAGS) $(SRC)/types.c - x86.o: $(SRC)/x86.c; $(CC) -c $(CFLAGS) $(SRC)/x86.c - - #$(SRC)/mips.c: $(SRC)/mips.md; lburg <$(SRC)/mips.md >$(SRC)/mips.c - #$(SRC)/sparc.c: $(SRC)/sparc.md;lburg <$(SRC)/sparc.md >$(SRC)/sparc.c - #$(SRC)/x86.c: $(SRC)/x86.md; lburg <$(SRC)/x86.md >$(SRC)/x86.c - - test: tst/8q.s tst/array.s tst/cf.s tst/cq.s tst/cvt.s tst/fields.s \ - tst/front.s tst/incr.s tst/init.s tst/limits.s tst/paranoia.s \ - tst/sort.s tst/spill.s tst/stdarg.s tst/struct.s tst/switch.s \ - tst/wf1.s tst/yacc.s - - T=$(SRC)/../tst - RUN=$(SRC)/run - RCC=rcc - LCC=lcc - CMD=@$(RUN) $(TARGET) - - tst/8q.s: $(RUN) $(RCC) $(T)/8q.c $(T)/8q.0; $(CMD) 8q - tst/array.s: $(RUN) $(RCC) $(T)/array.c $(T)/array.0; $(CMD) array - tst/cf.s: $(RUN) $(RCC) $(T)/cf.c $(T)/cf.0; $(CMD) cf - tst/cq.s: $(RUN) $(RCC) $(T)/cq.c $(T)/cq.0; $(CMD) cq - tst/cvt.s: $(RUN) $(RCC) $(T)/cvt.c $(T)/cvt.0; $(CMD) cvt - tst/fields.s: $(RUN) $(RCC) $(T)/fields.c $(T)/fields.0; $(CMD) fields - tst/front.s: $(RUN) $(RCC) $(T)/front.c $(T)/front.0; $(CMD) front - tst/incr.s: $(RUN) $(RCC) $(T)/incr.c $(T)/incr.0; $(CMD) incr - tst/init.s: $(RUN) $(RCC) $(T)/init.c $(T)/init.0; $(CMD) init - tst/limits.s: $(RUN) $(RCC) $(T)/limits.c $(T)/limits.0; $(CMD) limits - tst/paranoia.s: $(RUN) $(RCC) $(T)/paranoia.c $(T)/paranoia.0;$(CMD) paranoia - tst/sort.s: $(RUN) $(RCC) $(T)/sort.c $(T)/sort.0; $(CMD) sort - tst/spill.s: $(RUN) $(RCC) $(T)/spill.c $(T)/spill.0; $(CMD) spill - tst/stdarg.s: $(RUN) $(RCC) $(T)/stdarg.c $(T)/stdarg.0; $(CMD) stdarg - tst/struct.s: $(RUN) $(RCC) $(T)/struct.c $(T)/struct.0; $(CMD) struct - tst/switch.s: $(RUN) $(RCC) $(T)/switch.c $(T)/switch.0; $(CMD) switch - tst/wf1.s: $(RUN) $(RCC) $(T)/wf1.c $(T)/wf1.0; $(CMD) wf1 - tst/yacc.s: $(RUN) $(RCC) $(T)/yacc.c $(T)/yacc.0; $(CMD) yacc - - OPTS=CC='$(LCC) -B./ -d0.1 -A' \ - CFLAGS='-Wf-target=$(TARGET) -I$(SRC)/../include/`echo $(TARGET)|tr - /` \ - -I$(SRC)' LDFLAGS='$(LDFLAGS)' - - triple: rcc - rm -f *.o - make -f $(SRC)/makefile $(OPTS) - -strip rcc - -od rcc +8 >od2 - rm -f *.o - make -f $(SRC)/makefile $(OPTS) - -strip rcc - -od rcc +8 >od3 - cmp od[23] && rm od[23] - - testclean: - -rm -f tst/*.[12so] - -cd tst; rm -f 8q array cf cq cvt fields front incr init \ - limits paranoia sort spill stdarg struct switch wf1 yacc - - clean: testclean - -rm -f *.o - - clobber: clean - rm -f rcc lburg - # rm -f $(SRC)/mips.c $(SRC)/sparc.c $(SRC)/x86.c --- 0 ---- diff -rc --new-file lcc35/src/makefile.gcc lcc/src/makefile.gcc *** lcc35/src/makefile.gcc Thu Jan 1 00:00:00 1970 --- lcc/src/makefile.gcc Fri Mar 22 17:46:02 1996 *************** *** 0 **** --- 1,116 ---- + SHELL=/bin/sh + SRC=../../src + CC=gcc + CFLAGS=-O2 -fno-builtin + LDFLAGS=-noixemul -s + + OBJS=alloc.o bind.o dag.o decl.o enode.o error.o expr.o event.o \ + init.o input.o lex.o list.o main.o output.o prof.o profio.o simp.o \ + stmt.o string.o sym.o trace.o tree.o types.o \ + null.o symbolic.o gen.o mips.o sparc.o x86.o mc68030.o + + .c.o: + $(CC) $(CFLAGS) $< + + rcc: $(OBJS) + $(CC) -o $@ $(LDFLAGS) $(OBJS) -lm + + $(OBJS): $(SRC)/c.h $(SRC)/token.h $(SRC)/config.h + + alloc.o: $(SRC)/alloc.c; $(CC) -c $(CFLAGS) $(SRC)/alloc.c + bind.o: $(SRC)/bind.c; $(CC) -c $(CFLAGS) $(SRC)/bind.c + dag.o: $(SRC)/dag.c; $(CC) -c $(CFLAGS) $(SRC)/dag.c + decl.o: $(SRC)/decl.c; $(CC) -c $(CFLAGS) $(SRC)/decl.c + enode.o: $(SRC)/enode.c; $(CC) -c $(CFLAGS) $(SRC)/enode.c + error.o: $(SRC)/error.c; $(CC) -c $(CFLAGS) $(SRC)/error.c + event.o: $(SRC)/event.c; $(CC) -c $(CFLAGS) $(SRC)/event.c + expr.o: $(SRC)/expr.c; $(CC) -c $(CFLAGS) $(SRC)/expr.c + gen.o: $(SRC)/gen.c; $(CC) -c $(CFLAGS) $(SRC)/gen.c + init.o: $(SRC)/init.c; $(CC) -c $(CFLAGS) $(SRC)/init.c + input.o: $(SRC)/input.c; $(CC) -c $(CFLAGS) $(SRC)/input.c + lex.o: $(SRC)/lex.c; $(CC) -c $(CFLAGS) $(SRC)/lex.c + list.o: $(SRC)/list.c; $(CC) -c $(CFLAGS) $(SRC)/list.c + main.o: $(SRC)/main.c; $(CC) -c $(CFLAGS) $(SRC)/main.c + mips.o: $(SRC)/mips.c; $(CC) -c $(CFLAGS) $(SRC)/mips.c + null.o: $(SRC)/null.c; $(CC) -c $(CFLAGS) $(SRC)/null.c + output.o: $(SRC)/output.c; $(CC) -c $(CFLAGS) $(SRC)/output.c + prof.o: $(SRC)/prof.c; $(CC) -c $(CFLAGS) $(SRC)/prof.c + profio.o: $(SRC)/profio.c; $(CC) -c $(CFLAGS) $(SRC)/profio.c + simp.o: $(SRC)/simp.c; $(CC) -c $(CFLAGS) $(SRC)/simp.c + sparc.o: $(SRC)/sparc.c; $(CC) -c $(CFLAGS) $(SRC)/sparc.c + stmt.o: $(SRC)/stmt.c; $(CC) -c $(CFLAGS) $(SRC)/stmt.c + string.o: $(SRC)/string.c; $(CC) -c $(CFLAGS) $(SRC)/string.c + sym.o: $(SRC)/sym.c; $(CC) -c $(CFLAGS) $(SRC)/sym.c + symbolic.o: $(SRC)/symbolic.c; $(CC) -c $(CFLAGS) $(SRC)/symbolic.c + trace.o: $(SRC)/trace.c; $(CC) -c $(CFLAGS) $(SRC)/trace.c + tree.o: $(SRC)/tree.c; $(CC) -c $(CFLAGS) $(SRC)/tree.c + types.o: $(SRC)/types.c; $(CC) -c $(CFLAGS) $(SRC)/types.c + x86.o: $(SRC)/x86.c; $(CC) -c $(CFLAGS) $(SRC)/x86.c + #m68k.o: $(SRC)/m68k.c; $(CC) -c $(CFLAGS) $(SRC)/m68k.c + mc68030.o: $(SRC)/mc68030.c; $(CC) -c $(CFLAGS) $(SRC)/mc68030.c + strtod.o: $(SRC)/strtod.c; $(CC) -c $(CFLAGS) $(SRC)/strtod.c + atof.o: $(SRC)/atof.c; $(CC) -c $(CFLAGS) $(SRC)/atof.c + ldexp.o: $(SRC)/ldexp.c; $(CC) -c $(CFLAGS) $(SRC)/ldexp.c + + #$(SRC)/mips.c: $(SRC)/mips.md; lburg <$(SRC)/mips.md >$(SRC)/mips.c + #$(SRC)/sparc.c: $(SRC)/sparc.md;lburg <$(SRC)/sparc.md >$(SRC)/sparc.c + #$(SRC)/x86.c: $(SRC)/x86.md; lburg <$(SRC)/x86.md >$(SRC)/x86.c + #$(SRC)/m68k.c: $(SRC)/m68k.md; ../../lburg/lburg <$(SRC)/m68k.md >$(SRC)/m68k.c + $(SRC)/mc68030.c: $(SRC)/mc68030.md; ../../lburg/lburg <$(SRC)/mc68030.md >$(SRC)/mc68030.c + + test: tst/8q.s tst/array.s tst/cf.s tst/cq.s tst/cvt.s tst/fields.s \ + tst/front.s tst/incr.s tst/init.s tst/limits.s tst/paranoia.s \ + tst/sort.s tst/spill.s tst/stdarg.s tst/struct.s tst/switch.s \ + tst/wf1.s tst/yacc.s + + T=$(SRC)/../tst + RUN=$(SRC)/run + RCC=rcc + LCC=lcc + CMD=@$(RUN) $(TARGET) + + tst/8q.s: $(RUN) $(RCC) $(T)/8q.c $(T)/8q.0; $(CMD) 8q + tst/array.s: $(RUN) $(RCC) $(T)/array.c $(T)/array.0; $(CMD) array + tst/cf.s: $(RUN) $(RCC) $(T)/cf.c $(T)/cf.0; $(CMD) cf + tst/cq.s: $(RUN) $(RCC) $(T)/cq.c $(T)/cq.0; $(CMD) cq + tst/cvt.s: $(RUN) $(RCC) $(T)/cvt.c $(T)/cvt.0; $(CMD) cvt + tst/fields.s: $(RUN) $(RCC) $(T)/fields.c $(T)/fields.0; $(CMD) fields + tst/front.s: $(RUN) $(RCC) $(T)/front.c $(T)/front.0; $(CMD) front + tst/incr.s: $(RUN) $(RCC) $(T)/incr.c $(T)/incr.0; $(CMD) incr + tst/init.s: $(RUN) $(RCC) $(T)/init.c $(T)/init.0; $(CMD) init + tst/limits.s: $(RUN) $(RCC) $(T)/limits.c $(T)/limits.0; $(CMD) limits + tst/paranoia.s: $(RUN) $(RCC) $(T)/paranoia.c $(T)/paranoia.0;$(CMD) paranoia + tst/sort.s: $(RUN) $(RCC) $(T)/sort.c $(T)/sort.0; $(CMD) sort + tst/spill.s: $(RUN) $(RCC) $(T)/spill.c $(T)/spill.0; $(CMD) spill + tst/stdarg.s: $(RUN) $(RCC) $(T)/stdarg.c $(T)/stdarg.0; $(CMD) stdarg + tst/struct.s: $(RUN) $(RCC) $(T)/struct.c $(T)/struct.0; $(CMD) struct + tst/switch.s: $(RUN) $(RCC) $(T)/switch.c $(T)/switch.0; $(CMD) switch + tst/wf1.s: $(RUN) $(RCC) $(T)/wf1.c $(T)/wf1.0; $(CMD) wf1 + tst/yacc.s: $(RUN) $(RCC) $(T)/yacc.c $(T)/yacc.0; $(CMD) yacc + + OPTS=CC='$(LCC) -B./ -d0.1 -A' \ + CFLAGS='-Wf-target=$(TARGET) -I$(SRC)/../include/`echo $(TARGET)|tr - /` \ + -I$(SRC)' LDFLAGS='$(LDFLAGS)' + + triple: rcc + rm -f *.o + make -f $(SRC)/makefile $(OPTS) + -strip rcc + -od rcc +8 >od2 + rm -f *.o + make -f $(SRC)/makefile $(OPTS) + -strip rcc + -od rcc +8 >od3 + cmp od[23] && rm od[23] + + testclean: + -rm -f tst/*.[12so] + -cd tst; rm -f 8q array cf cq cvt fields front incr init \ + limits paranoia sort spill stdarg struct switch wf1 yacc + + clean: testclean + -rm -f *.o + + clobber: clean + rm -f rcc lburg + # rm -f $(SRC)/mips.c $(SRC)/sparc.c $(SRC)/x86.c diff -rc --new-file lcc35/src/makefile.rcc lcc/src/makefile.rcc *** lcc35/src/makefile.rcc Thu Jan 1 00:00:00 1970 --- lcc/src/makefile.rcc Fri Mar 8 00:17:12 1996 *************** *** 0 **** --- 1,108 ---- + SHELL=/bin/sh + SRC=//src + CC=lcc:bin/lcc + CFLAGS= + LDFLAGS=-lm + + OBJS=alloc.o bind.o dag.o decl.o enode.o error.o expr.o event.o \ + init.o input.o lex.o list.o main.o output.o prof.o profio.o simp.o \ + stmt.o string.o sym.o trace.o tree.o types.o \ + null.o symbolic.o gen.o mips.o sparc.o x86.o mc68030.o + + rcc: $(OBJS) + $(CC) -o $@ $(LDFLAGS) $(OBJS) + + $(OBJS): c.h token.h config.h + + alloc.o: alloc.c; $(CC) -c $(CFLAGS) alloc.c + bind.o: bind.c; $(CC) -c $(CFLAGS) bind.c + dag.o: dag.c; $(CC) -c $(CFLAGS) dag.c + decl.o: decl.c; $(CC) -c $(CFLAGS) decl.c + enode.o: enode.c; $(CC) -c $(CFLAGS) enode.c + error.o: error.c; $(CC) -c $(CFLAGS) error.c + event.o: event.c; $(CC) -c $(CFLAGS) event.c + expr.o: expr.c; $(CC) -c $(CFLAGS) expr.c + gen.o: gen.c; $(CC) -c $(CFLAGS) gen.c + init.o: init.c; $(CC) -c $(CFLAGS) init.c + input.o: input.c; $(CC) -c $(CFLAGS) input.c + lex.o: lex.c; $(CC) -c $(CFLAGS) lex.c + list.o: list.c; $(CC) -c $(CFLAGS) list.c + main.o: main.c; $(CC) -c $(CFLAGS) main.c + mips.o: mips.c; $(CC) -c $(CFLAGS) mips.c + null.o: null.c; $(CC) -c $(CFLAGS) null.c + output.o: output.c; $(CC) -c $(CFLAGS) output.c + prof.o: prof.c; $(CC) -c $(CFLAGS) prof.c + profio.o: profio.c; $(CC) -c $(CFLAGS) profio.c + simp.o: simp.c; $(CC) -c $(CFLAGS) simp.c + sparc.o: sparc.c; $(CC) -c $(CFLAGS) sparc.c + stmt.o: stmt.c; $(CC) -c $(CFLAGS) stmt.c + string.o: string.c; $(CC) -c $(CFLAGS) string.c + sym.o: sym.c; $(CC) -c $(CFLAGS) sym.c + symbolic.o: symbolic.c; $(CC) -c $(CFLAGS) symbolic.c + trace.o: trace.c; $(CC) -c $(CFLAGS) trace.c + tree.o: tree.c; $(CC) -c $(CFLAGS) tree.c + types.o: types.c; $(CC) -c $(CFLAGS) types.c + x86.o: x86.c; $(CC) -c $(CFLAGS) x86.c + mc68030.o: mc68030.c; $(CC) -c $(CFLAGS) mc68030.c + + #$(SRC)/mips.c: $(SRC)/mips.md; lburg <$(SRC)/mips.md >$(SRC)/mips.c + #$(SRC)/sparc.c: $(SRC)/sparc.md;lburg <$(SRC)/sparc.md >$(SRC)/sparc.c + #$(SRC)/x86.c: $(SRC)/x86.md; lburg <$(SRC)/x86.md >$(SRC)/x86.c + #$(SRC)/mc68030.c: $(SRC)/mc68030.md; lburg <$(SRC)/mc68030.md >$(SRC)/mc68030.c + + test: tst/8q.s tst/array.s tst/cf.s tst/cq.s tst/cvt.s tst/fields.s \ + tst/front.s tst/incr.s tst/init.s tst/limits.s tst/paranoia.s \ + tst/sort.s tst/spill.s tst/stdarg.s tst/struct.s tst/switch.s \ + tst/wf1.s tst/yacc.s + + T=$(SRC)/../tst + RUN=$(SRC)/run + RCC=rcc + LCC=gcc + CMD=@$(RUN) $(TARGET) + + tst/8q.s: $(RUN) $(RCC) $(T)/8q.c $(T)/8q.0; $(CMD) 8q + tst/array.s: $(RUN) $(RCC) $(T)/array.c $(T)/array.0; $(CMD) array + tst/cf.s: $(RUN) $(RCC) $(T)/cf.c $(T)/cf.0; $(CMD) cf + tst/cq.s: $(RUN) $(RCC) $(T)/cq.c $(T)/cq.0; $(CMD) cq + tst/cvt.s: $(RUN) $(RCC) $(T)/cvt.c $(T)/cvt.0; $(CMD) cvt + tst/fields.s: $(RUN) $(RCC) $(T)/fields.c $(T)/fields.0; $(CMD) fields + tst/front.s: $(RUN) $(RCC) $(T)/front.c $(T)/front.0; $(CMD) front + tst/incr.s: $(RUN) $(RCC) $(T)/incr.c $(T)/incr.0; $(CMD) incr + tst/init.s: $(RUN) $(RCC) $(T)/init.c $(T)/init.0; $(CMD) init + tst/limits.s: $(RUN) $(RCC) $(T)/limits.c $(T)/limits.0; $(CMD) limits + tst/paranoia.s: $(RUN) $(RCC) $(T)/paranoia.c $(T)/paranoia.0;$(CMD) paranoia + tst/sort.s: $(RUN) $(RCC) $(T)/sort.c $(T)/sort.0; $(CMD) sort + tst/spill.s: $(RUN) $(RCC) $(T)/spill.c $(T)/spill.0; $(CMD) spill + tst/stdarg.s: $(RUN) $(RCC) $(T)/stdarg.c $(T)/stdarg.0; $(CMD) stdarg + tst/struct.s: $(RUN) $(RCC) $(T)/struct.c $(T)/struct.0; $(CMD) struct + tst/switch.s: $(RUN) $(RCC) $(T)/switch.c $(T)/switch.0; $(CMD) switch + tst/wf1.s: $(RUN) $(RCC) $(T)/wf1.c $(T)/wf1.0; $(CMD) wf1 + tst/yacc.s: $(RUN) $(RCC) $(T)/yacc.c $(T)/yacc.0; $(CMD) yacc + + OPTS=CC='$(LCC) -B./ -d0.1 -A' \ + CFLAGS='-Wf-target=$(TARGET) -I$(SRC)/../include/`echo $(TARGET)|tr - /` \ + -I$(SRC)' LDFLAGS='$(LDFLAGS)' + + triple: rcc + rm -f *.o + make -f $(SRC)/makefile $(OPTS) + -strip rcc + -od rcc +8 >od2 + rm -f *.o + make -f $(SRC)/makefile $(OPTS) + -strip rcc + -od rcc +8 >od3 + cmp od[23] && rm od[23] + + testclean: + -rm -f tst/*.[12so] + -cd tst; rm -f 8q array cf cq cvt fields front incr init \ + limits paranoia sort spill stdarg struct switch wf1 yacc + + clean: testclean + -rm -f *.o + + clobber: clean + rm -f rcc lburg + # rm -f $(SRC)/mips.c $(SRC)/sparc.c $(SRC)/x86.c diff -rc --new-file lcc35/src/mc68030.c lcc/src/mc68030.c *** lcc35/src/mc68030.c Thu Jan 1 00:00:00 1970 --- lcc/src/mc68030.c Thu Feb 29 17:32:26 1996 *************** *** 0 **** --- 1,5975 ---- + /* + This file is an almost complete machine description file of the MC68000 + family for the lburg code generator generator. What's missing can be + easily filled in for a specific MC68k assembler. A change must be made to + config.h in order to use this file. The Xnode struct's kids field must be + enlarged to 4. A completed version of this file forms the basis for the + MPW version of the lcc compiler targeted for the Apple Macintosh. The code + emitted by this specification is for the Apple MPW Assembler which has a + syntax similar to Motorola's assembler. A major difference between this + lburg specification and the examples in the lcc distribution is that switch + statement tables are stored in the code segment and are addressed by the pc + relative addressing mode. + + Registers A2-A7,D3-D7,FP4-FP7 are preserved across function calls. + Registers D0 and FP0 store function results. Parameters are passed from + right to left on the stack. All floating point values are first promoted + to Motorola extended format before being pushed on the stack. + + Here are some benchmark results of some compilers available for the Apple + Macintosh. The programs are similar to those found in the Hennessy suite. + MPW C is the Apple C compiler. Gcc is the MPW port of gcc version + 1.37.1r15. SC is the Symantec C compiler (ex-Zortech with m68k backend). + SCG is the Symantec C compiler with all optimizations on. This compiler + does global optimizations. LCC is the lcc compiler produced with this + machine description file. MW is the Metrowerks 68k C compiler from Code + Warrior. All tests were run on a Macintosh Centris 650 with MC68040 @25MHz + using 020 addressing modes and FPU. + + MPW C gcc gcc -O SC SCG LCC MW opt + Perm 13 13 11 17 19 12 22 + Towers 12 15 10 17 16 12 11 + Queens 6 7 5 7 8 8 4 + Intmm 19 18 16 18 11 19 17 + Mm 17 19 16 18 10 20 18 + Puzzle 68 86 48 74 35 74 47 + Quick 8 10 5 13 11 8 14 + Bubble 11 16 7 19 10 12 11 + FFT 25 28 16 24 20 25 19 + + Hopefully this file will prove useful to those wishing to target lcc to + Atari's, Amiga's, Sun's and Next's. Let me know if you retarget lcc to any + other m68k machines using this file. + Please report any bugs to: + + Woodrow Yeung + yeung@reed.edu + + */ + enum { D0, D1, D2, D3, D4, D5, D6, D7 }; + enum { A0, A1, A2, A3, A4, A5, A6, A7 }; + enum { FP0, FP1, FP2, FP3, FP4, FP5, FP6, FP7 }; + #if 0 + #define realparamsize 12 + #endif + #ifndef AMIGA + #include "c.h" + #include + #else + /* Work around some incompatibilities between system/lcc header files and + */ + #define SHORT _SHORT + #define LONG _LONG + #define FLOAT _FLOAT + #define DOUBLE _DOUBLE + #include "c.h" + #undef SHORT + #undef LONG + #undef FLOAT + #undef DOUBLE + #include + #ifdef BITSPERBYTE + #undef BITSPERBYTE + #endif + #ifdef MAXINT + #undef MAXINT + #endif + #ifdef MININT + #undef MININT + #endif + #ifdef LONGBITS + #undef LONGBITS + #endif + #include + #include + #undef STATIC + #undef GLOBAL + #endif + #define NODEPTR_TYPE Node + #define OP_LABEL(p) ((p)->op) + #define LEFT_CHILD(p) ((p)->kids[0]) + #define RIGHT_CHILD(p) ((p)->kids[1]) + #define STATE_LABEL(p) ((p)->x.state) + #define FILEPART(x) (strrchr((x),'/') ? strrchr((x),'/')+1 : \ + (strrchr((x),':') ? strrchr((x),':')+1 : (x))) + static void address ARGS((Symbol, Symbol, int)); + static void blkfetch ARGS((int, int, int, int)); + static void blkloop ARGS((int, int, int, int, int, int[])); + static void blkstore ARGS((int, int, int, int)); + static void defaddress ARGS((Symbol)); + static void defconst ARGS((int, Value)); + static void defstring ARGS((int, char *)); + static void defsymbol ARGS((Symbol)); + static void doarg ARGS((Node)); + static void emit2 ARGS((Node)); + static void export ARGS((Symbol)); + static void clobber ARGS((Node)); + static void function ARGS((Symbol, Symbol [], Symbol [], int)); + static void global ARGS((Symbol)); + static void import ARGS((Symbol)); + static void local ARGS((Symbol)); + static void progbeg ARGS((int, char **)); + static void progend ARGS((void)); + static void segment ARGS((int)); + static void space ARGS((int)); + static void target ARGS((Node)); + + static int sametree ARGS((Node, Node)); + static int memop ARGS((Node)); + + static void symname ARGS((Symbol p)); + static void stabend ARGS((Coordinate *, Symbol, Coordinate **, Symbol *, Symbol *)); + static void stabline ARGS((Coordinate *)); + + static Symbol ireg[32], *dreg = &ireg[0], areg[32], freg[32]; + + static int cseg; + + /* + generated at Thu Feb 29 17:32:21 1996 + by $Id: lburg.c,v 2.2.1.2 1995/12/20 19:09:53 drh Exp $ + */ + static void _kids ARGS((NODEPTR_TYPE, int, NODEPTR_TYPE[])); + static void _label ARGS((NODEPTR_TYPE)); + static int _rule ARGS((void*, int)); + + #define _stmt_NT 1 + #define _reg_NT 2 + #define _con_NT 3 + #define _disp16_NT 4 + #define _disp8_NT 5 + #define _base_NT 6 + #define _basei_NT 7 + #define _addr_NT 8 + #define _acon_NT 9 + #define _table_NT 10 + #define _index_NT 11 + #define _scf_NT 12 + #define _case_NT 13 + #define _avar_NT 14 + #define _con0_NT 15 + #define _con3_NT 16 + #define _mem_NT 17 + #define _pcrel_NT 18 + #define _ri_NT 19 + #define _ri3_NT 20 + #define _ea0_NT 21 + #define _ea1_NT 22 + #define _ea3_NT 23 + + static char *_ntname[] = { + 0, + "stmt", + "reg", + "con", + "disp16", + "disp8", + "base", + "basei", + "addr", + "acon", + "table", + "index", + "scf", + "case", + "avar", + "con0", + "con3", + "mem", + "pcrel", + "ri", + "ri3", + "ea0", + "ea1", + "ea3", + 0 + }; + + struct _state { + short cost[24]; + struct { + unsigned int _stmt:7; + unsigned int _reg:7; + unsigned int _con:3; + unsigned int _disp16:1; + unsigned int _disp8:1; + unsigned int _base:3; + unsigned int _basei:3; + unsigned int _addr:2; + unsigned int _acon:1; + unsigned int _table:1; + unsigned int _index:2; + unsigned int _scf:2; + unsigned int _case:1; + unsigned int _avar:2; + unsigned int _con0:2; + unsigned int _con3:2; + unsigned int _mem:3; + unsigned int _pcrel:1; + unsigned int _ri:2; + unsigned int _ri3:2; + unsigned int _ea0:2; + unsigned int _ea1:2; + unsigned int _ea3:2; + } rule; + }; + + static short _nts_0[] = { 0 }; + static short _nts_1[] = { _reg_NT, 0 }; + static short _nts_2[] = { _reg_NT, _disp16_NT, 0 }; + static short _nts_3[] = { _basei_NT, 0 }; + static short _nts_4[] = { _reg_NT, _disp8_NT, 0 }; + static short _nts_5[] = { _reg_NT, _scf_NT, 0 }; + static short _nts_6[] = { _base_NT, 0 }; + static short _nts_7[] = { _index_NT, _basei_NT, 0 }; + static short _nts_8[] = { _index_NT, _table_NT, 0 }; + static short _nts_9[] = { _acon_NT, 0 }; + static short _nts_10[] = { _addr_NT, 0 }; + static short _nts_11[] = { _case_NT, 0 }; + static short _nts_12[] = { _con_NT, 0 }; + static short _nts_13[] = { _con3_NT, 0 }; + static short _nts_14[] = { _mem_NT, 0 }; + static short _nts_15[] = { _ri_NT, 0 }; + static short _nts_16[] = { _reg_NT, _con3_NT, 0 }; + static short _nts_17[] = { _reg_NT, _ea1_NT, 0 }; + static short _nts_18[] = { _addr_NT, _mem_NT, _ri_NT, 0 }; + static short _nts_19[] = { _reg_NT, _reg_NT, 0 }; + static short _nts_20[] = { _addr_NT, _mem_NT, _reg_NT, 0 }; + static short _nts_21[] = { _addr_NT, _mem_NT, 0 }; + static short _nts_22[] = { _reg_NT, _ri3_NT, 0 }; + static short _nts_23[] = { _reg_NT, _ea3_NT, 0 }; + static short _nts_24[] = { _ea0_NT, 0 }; + static short _nts_25[] = { _addr_NT, _ea1_NT, 0 }; + static short _nts_26[] = { _addr_NT, _con0_NT, 0 }; + static short _nts_27[] = { _addr_NT, _reg_NT, 0 }; + static short _nts_28[] = { _pcrel_NT, 0 }; + static short _nts_29[] = { _ea0_NT, _con0_NT, 0 }; + static short _nts_30[] = { _avar_NT, 0 }; + + static short *_nts[] = { + 0, /* 0 */ + _nts_0, /* 1 */ + _nts_0, /* 2 */ + _nts_0, /* 3 */ + _nts_0, /* 4 */ + _nts_0, /* 5 */ + _nts_0, /* 6 */ + _nts_1, /* 7 */ + _nts_1, /* 8 */ + _nts_1, /* 9 */ + _nts_1, /* 10 */ + _nts_1, /* 11 */ + _nts_1, /* 12 */ + _nts_1, /* 13 */ + _nts_0, /* 14 */ + _nts_0, /* 15 */ + _nts_0, /* 16 */ + _nts_0, /* 17 */ + _nts_0, /* 18 */ + _nts_1, /* 19 */ + _nts_1, /* 20 */ + _nts_1, /* 21 */ + _nts_0, /* 22 */ + _nts_0, /* 23 */ + _nts_2, /* 24 */ + _nts_0, /* 25 */ + _nts_0, /* 26 */ + _nts_3, /* 27 */ + _nts_1, /* 28 */ + _nts_4, /* 29 */ + _nts_0, /* 30 */ + _nts_0, /* 31 */ + _nts_0, /* 32 */ + _nts_0, /* 33 */ + _nts_0, /* 34 */ + _nts_0, /* 35 */ + _nts_0, /* 36 */ + _nts_1, /* 37 */ + _nts_5, /* 38 */ + _nts_6, /* 39 */ + _nts_7, /* 40 */ + _nts_8, /* 41 */ + _nts_9, /* 42 */ + _nts_1, /* 43 */ + _nts_10, /* 44 */ + _nts_0, /* 45 */ + _nts_0, /* 46 */ + _nts_0, /* 47 */ + _nts_0, /* 48 */ + _nts_0, /* 49 */ + _nts_0, /* 50 */ + _nts_0, /* 51 */ + _nts_0, /* 52 */ + _nts_10, /* 53 */ + _nts_10, /* 54 */ + _nts_11, /* 55 */ + _nts_1, /* 56 */ + _nts_12, /* 57 */ + _nts_13, /* 58 */ + _nts_1, /* 59 */ + _nts_14, /* 60 */ + _nts_15, /* 61 */ + _nts_14, /* 62 */ + _nts_15, /* 63 */ + _nts_14, /* 64 */ + _nts_15, /* 65 */ + _nts_10, /* 66 */ + _nts_15, /* 67 */ + _nts_10, /* 68 */ + _nts_10, /* 69 */ + _nts_10, /* 70 */ + _nts_10, /* 71 */ + _nts_1, /* 72 */ + _nts_1, /* 73 */ + _nts_1, /* 74 */ + _nts_1, /* 75 */ + _nts_1, /* 76 */ + _nts_16, /* 77 */ + _nts_16, /* 78 */ + _nts_17, /* 79 */ + _nts_17, /* 80 */ + _nts_17, /* 81 */ + _nts_17, /* 82 */ + _nts_17, /* 83 */ + _nts_17, /* 84 */ + _nts_18, /* 85 */ + _nts_18, /* 86 */ + _nts_18, /* 87 */ + _nts_18, /* 88 */ + _nts_17, /* 89 */ + _nts_17, /* 90 */ + _nts_19, /* 91 */ + _nts_18, /* 92 */ + _nts_18, /* 93 */ + _nts_20, /* 94 */ + _nts_1, /* 95 */ + _nts_1, /* 96 */ + _nts_21, /* 97 */ + _nts_21, /* 98 */ + _nts_22, /* 99 */ + _nts_22, /* 100 */ + _nts_22, /* 101 */ + _nts_22, /* 102 */ + _nts_23, /* 103 */ + _nts_23, /* 104 */ + _nts_23, /* 105 */ + _nts_23, /* 106 */ + _nts_23, /* 107 */ + _nts_19, /* 108 */ + _nts_1, /* 109 */ + _nts_1, /* 110 */ + _nts_1, /* 111 */ + _nts_1, /* 112 */ + _nts_10, /* 113 */ + _nts_10, /* 114 */ + _nts_10, /* 115 */ + _nts_10, /* 116 */ + _nts_1, /* 117 */ + _nts_1, /* 118 */ + _nts_1, /* 119 */ + _nts_1, /* 120 */ + _nts_1, /* 121 */ + _nts_1, /* 122 */ + _nts_1, /* 123 */ + _nts_1, /* 124 */ + _nts_1, /* 125 */ + _nts_1, /* 126 */ + _nts_1, /* 127 */ + _nts_1, /* 128 */ + _nts_1, /* 129 */ + _nts_1, /* 130 */ + _nts_1, /* 131 */ + _nts_1, /* 132 */ + _nts_24, /* 133 */ + _nts_1, /* 134 */ + _nts_25, /* 135 */ + _nts_26, /* 136 */ + _nts_25, /* 137 */ + _nts_26, /* 138 */ + _nts_27, /* 139 */ + _nts_25, /* 140 */ + _nts_26, /* 141 */ + _nts_25, /* 142 */ + _nts_26, /* 143 */ + _nts_24, /* 144 */ + _nts_10, /* 145 */ + _nts_24, /* 146 */ + _nts_10, /* 147 */ + _nts_19, /* 148 */ + _nts_1, /* 149 */ + _nts_1, /* 150 */ + _nts_1, /* 151 */ + _nts_10, /* 152 */ + _nts_10, /* 153 */ + _nts_10, /* 154 */ + _nts_10, /* 155 */ + _nts_27, /* 156 */ + _nts_21, /* 157 */ + _nts_27, /* 158 */ + _nts_21, /* 159 */ + _nts_1, /* 160 */ + _nts_1, /* 161 */ + _nts_19, /* 162 */ + _nts_19, /* 163 */ + _nts_19, /* 164 */ + _nts_19, /* 165 */ + _nts_19, /* 166 */ + _nts_19, /* 167 */ + _nts_19, /* 168 */ + _nts_19, /* 169 */ + _nts_1, /* 170 */ + _nts_1, /* 171 */ + _nts_9, /* 172 */ + _nts_28, /* 173 */ + _nts_0, /* 174 */ + _nts_29, /* 175 */ + _nts_29, /* 176 */ + _nts_17, /* 177 */ + _nts_17, /* 178 */ + _nts_17, /* 179 */ + _nts_17, /* 180 */ + _nts_17, /* 181 */ + _nts_17, /* 182 */ + _nts_17, /* 183 */ + _nts_17, /* 184 */ + _nts_17, /* 185 */ + _nts_17, /* 186 */ + _nts_19, /* 187 */ + _nts_19, /* 188 */ + _nts_19, /* 189 */ + _nts_19, /* 190 */ + _nts_19, /* 191 */ + _nts_19, /* 192 */ + _nts_19, /* 193 */ + _nts_19, /* 194 */ + _nts_19, /* 195 */ + _nts_19, /* 196 */ + _nts_19, /* 197 */ + _nts_19, /* 198 */ + _nts_30, /* 199 */ + _nts_30, /* 200 */ + _nts_30, /* 201 */ + _nts_30, /* 202 */ + _nts_1, /* 203 */ + _nts_1, /* 204 */ + _nts_1, /* 205 */ + }; + + static char _arity[] = { + 0, /* 0 */ + 0, /* 1 */ + 0, /* 2 */ + 0, /* 3 */ + 0, /* 4 */ + 0, /* 5 */ + 0, /* 6 */ + 0, /* 7 */ + 0, /* 8 */ + 0, /* 9 */ + 0, /* 10 */ + 0, /* 11 */ + 0, /* 12 */ + 0, /* 13 */ + 0, /* 14 */ + 0, /* 15 */ + 0, /* 16 */ + 0, /* 17=CNSTF */ + 0, /* 18=CNSTD */ + 0, /* 19=CNSTC */ + 0, /* 20=CNSTS */ + 0, /* 21=CNSTI */ + 0, /* 22=CNSTU */ + 0, /* 23=CNSTP */ + 0, /* 24 */ + 0, /* 25 */ + 0, /* 26 */ + 0, /* 27 */ + 0, /* 28 */ + 0, /* 29 */ + 0, /* 30 */ + 0, /* 31 */ + 0, /* 32 */ + 1, /* 33=ARGF */ + 1, /* 34=ARGD */ + 0, /* 35 */ + 0, /* 36 */ + 1, /* 37=ARGI */ + 0, /* 38 */ + 1, /* 39=ARGP */ + 0, /* 40 */ + 1, /* 41=ARGB */ + 0, /* 42 */ + 0, /* 43 */ + 0, /* 44 */ + 0, /* 45 */ + 0, /* 46 */ + 0, /* 47 */ + 0, /* 48 */ + 2, /* 49=ASGNF */ + 2, /* 50=ASGND */ + 2, /* 51=ASGNC */ + 2, /* 52=ASGNS */ + 2, /* 53=ASGNI */ + 0, /* 54=ASGNU */ + 2, /* 55=ASGNP */ + 0, /* 56 */ + 2, /* 57=ASGNB */ + 0, /* 58 */ + 0, /* 59 */ + 0, /* 60 */ + 0, /* 61 */ + 0, /* 62 */ + 0, /* 63 */ + 0, /* 64 */ + 1, /* 65=INDIRF */ + 1, /* 66=INDIRD */ + 1, /* 67=INDIRC */ + 1, /* 68=INDIRS */ + 1, /* 69=INDIRI */ + 0, /* 70 */ + 1, /* 71=INDIRP */ + 0, /* 72 */ + 1, /* 73=INDIRB */ + 0, /* 74 */ + 0, /* 75 */ + 0, /* 76 */ + 0, /* 77 */ + 0, /* 78 */ + 0, /* 79 */ + 0, /* 80 */ + 0, /* 81 */ + 0, /* 82 */ + 0, /* 83 */ + 0, /* 84 */ + 1, /* 85=CVCI */ + 1, /* 86=CVCU */ + 0, /* 87 */ + 0, /* 88 */ + 0, /* 89 */ + 0, /* 90 */ + 0, /* 91 */ + 0, /* 92 */ + 0, /* 93 */ + 0, /* 94 */ + 0, /* 95 */ + 0, /* 96 */ + 1, /* 97=CVDF */ + 0, /* 98 */ + 0, /* 99 */ + 0, /* 100 */ + 1, /* 101=CVDI */ + 0, /* 102 */ + 0, /* 103 */ + 0, /* 104 */ + 0, /* 105 */ + 0, /* 106 */ + 0, /* 107 */ + 0, /* 108 */ + 0, /* 109 */ + 0, /* 110 */ + 0, /* 111 */ + 0, /* 112 */ + 0, /* 113 */ + 1, /* 114=CVFD */ + 0, /* 115 */ + 0, /* 116 */ + 0, /* 117 */ + 0, /* 118 */ + 0, /* 119 */ + 0, /* 120 */ + 0, /* 121 */ + 0, /* 122 */ + 0, /* 123 */ + 0, /* 124 */ + 0, /* 125 */ + 0, /* 126 */ + 0, /* 127 */ + 0, /* 128 */ + 0, /* 129 */ + 1, /* 130=CVID */ + 1, /* 131=CVIC */ + 1, /* 132=CVIS */ + 0, /* 133 */ + 1, /* 134=CVIU */ + 0, /* 135 */ + 0, /* 136 */ + 0, /* 137 */ + 0, /* 138 */ + 0, /* 139 */ + 0, /* 140 */ + 0, /* 141 */ + 0, /* 142 */ + 0, /* 143 */ + 0, /* 144 */ + 0, /* 145 */ + 0, /* 146 */ + 0, /* 147 */ + 0, /* 148 */ + 0, /* 149 */ + 1, /* 150=CVPU */ + 0, /* 151 */ + 0, /* 152 */ + 0, /* 153 */ + 0, /* 154 */ + 0, /* 155 */ + 0, /* 156 */ + 0, /* 157 */ + 0, /* 158 */ + 0, /* 159 */ + 0, /* 160 */ + 0, /* 161 */ + 0, /* 162 */ + 0, /* 163 */ + 0, /* 164 */ + 1, /* 165=CVSI */ + 1, /* 166=CVSU */ + 0, /* 167 */ + 0, /* 168 */ + 0, /* 169 */ + 0, /* 170 */ + 0, /* 171 */ + 0, /* 172 */ + 0, /* 173 */ + 0, /* 174 */ + 0, /* 175 */ + 0, /* 176 */ + 0, /* 177 */ + 0, /* 178 */ + 1, /* 179=CVUC */ + 1, /* 180=CVUS */ + 1, /* 181=CVUI */ + 0, /* 182 */ + 1, /* 183=CVUP */ + 0, /* 184 */ + 0, /* 185 */ + 0, /* 186 */ + 0, /* 187 */ + 0, /* 188 */ + 0, /* 189 */ + 0, /* 190 */ + 0, /* 191 */ + 0, /* 192 */ + 1, /* 193=NEGF */ + 1, /* 194=NEGD */ + 0, /* 195 */ + 0, /* 196 */ + 1, /* 197=NEGI */ + 0, /* 198 */ + 0, /* 199 */ + 0, /* 200 */ + 0, /* 201 */ + 0, /* 202 */ + 0, /* 203 */ + 0, /* 204 */ + 0, /* 205 */ + 0, /* 206 */ + 0, /* 207 */ + 0, /* 208 */ + 1, /* 209=CALLF */ + 1, /* 210=CALLD */ + 0, /* 211 */ + 0, /* 212 */ + 1, /* 213=CALLI */ + 0, /* 214 */ + 0, /* 215 */ + 1, /* 216=CALLV */ + 0, /* 217=CALLB */ + 0, /* 218 */ + 0, /* 219 */ + 0, /* 220 */ + 0, /* 221 */ + 0, /* 222 */ + 0, /* 223 */ + 0, /* 224 */ + 1, /* 225=LOADF */ + 1, /* 226=LOADD */ + 1, /* 227=LOADC */ + 1, /* 228=LOADS */ + 1, /* 229=LOADI */ + 1, /* 230=LOADU */ + 1, /* 231=LOADP */ + 0, /* 232 */ + 0, /* 233=LOADB */ + 0, /* 234 */ + 0, /* 235 */ + 0, /* 236 */ + 0, /* 237 */ + 0, /* 238 */ + 0, /* 239 */ + 0, /* 240 */ + 1, /* 241=RETF */ + 1, /* 242=RETD */ + 0, /* 243 */ + 0, /* 244 */ + 1, /* 245=RETI */ + 0, /* 246 */ + 0, /* 247 */ + 0, /* 248 */ + 0, /* 249 */ + 0, /* 250 */ + 0, /* 251 */ + 0, /* 252 */ + 0, /* 253 */ + 0, /* 254 */ + 0, /* 255 */ + 0, /* 256 */ + 0, /* 257 */ + 0, /* 258 */ + 0, /* 259 */ + 0, /* 260 */ + 0, /* 261 */ + 0, /* 262 */ + 0, /* 263=ADDRGP */ + 0, /* 264 */ + 0, /* 265 */ + 0, /* 266 */ + 0, /* 267 */ + 0, /* 268 */ + 0, /* 269 */ + 0, /* 270 */ + 0, /* 271 */ + 0, /* 272 */ + 0, /* 273 */ + 0, /* 274 */ + 0, /* 275 */ + 0, /* 276 */ + 0, /* 277 */ + 0, /* 278 */ + 0, /* 279=ADDRFP */ + 0, /* 280 */ + 0, /* 281 */ + 0, /* 282 */ + 0, /* 283 */ + 0, /* 284 */ + 0, /* 285 */ + 0, /* 286 */ + 0, /* 287 */ + 0, /* 288 */ + 0, /* 289 */ + 0, /* 290 */ + 0, /* 291 */ + 0, /* 292 */ + 0, /* 293 */ + 0, /* 294 */ + 0, /* 295=ADDRLP */ + 0, /* 296 */ + 0, /* 297 */ + 0, /* 298 */ + 0, /* 299 */ + 0, /* 300 */ + 0, /* 301 */ + 0, /* 302 */ + 0, /* 303 */ + 0, /* 304 */ + 2, /* 305=ADDF */ + 2, /* 306=ADDD */ + 0, /* 307=ADDC */ + 0, /* 308=ADDS */ + 2, /* 309=ADDI */ + 2, /* 310=ADDU */ + 2, /* 311=ADDP */ + 0, /* 312 */ + 0, /* 313 */ + 0, /* 314 */ + 0, /* 315 */ + 0, /* 316 */ + 0, /* 317 */ + 0, /* 318 */ + 0, /* 319 */ + 0, /* 320 */ + 2, /* 321=SUBF */ + 2, /* 322=SUBD */ + 0, /* 323=SUBC */ + 0, /* 324=SUBS */ + 2, /* 325=SUBI */ + 2, /* 326=SUBU */ + 2, /* 327=SUBP */ + 0, /* 328 */ + 0, /* 329 */ + 0, /* 330 */ + 0, /* 331 */ + 0, /* 332 */ + 0, /* 333 */ + 0, /* 334 */ + 0, /* 335 */ + 0, /* 336 */ + 0, /* 337 */ + 0, /* 338 */ + 0, /* 339 */ + 0, /* 340 */ + 2, /* 341=LSHI */ + 2, /* 342=LSHU */ + 0, /* 343 */ + 0, /* 344 */ + 0, /* 345 */ + 0, /* 346 */ + 0, /* 347 */ + 0, /* 348 */ + 0, /* 349 */ + 0, /* 350 */ + 0, /* 351 */ + 0, /* 352 */ + 0, /* 353 */ + 0, /* 354 */ + 0, /* 355 */ + 0, /* 356 */ + 2, /* 357=MODI */ + 2, /* 358=MODU */ + 0, /* 359 */ + 0, /* 360 */ + 0, /* 361 */ + 0, /* 362 */ + 0, /* 363 */ + 0, /* 364 */ + 0, /* 365 */ + 0, /* 366 */ + 0, /* 367 */ + 0, /* 368 */ + 0, /* 369 */ + 0, /* 370 */ + 0, /* 371 */ + 0, /* 372 */ + 2, /* 373=RSHI */ + 2, /* 374=RSHU */ + 0, /* 375 */ + 0, /* 376 */ + 0, /* 377 */ + 0, /* 378 */ + 0, /* 379 */ + 0, /* 380 */ + 0, /* 381 */ + 0, /* 382 */ + 0, /* 383 */ + 0, /* 384 */ + 0, /* 385 */ + 0, /* 386 */ + 0, /* 387 */ + 0, /* 388 */ + 0, /* 389 */ + 2, /* 390=BANDU */ + 0, /* 391 */ + 0, /* 392 */ + 0, /* 393 */ + 0, /* 394 */ + 0, /* 395 */ + 0, /* 396 */ + 0, /* 397 */ + 0, /* 398 */ + 0, /* 399 */ + 0, /* 400 */ + 0, /* 401 */ + 0, /* 402 */ + 0, /* 403 */ + 0, /* 404 */ + 0, /* 405 */ + 1, /* 406=BCOMU */ + 0, /* 407 */ + 0, /* 408 */ + 0, /* 409 */ + 0, /* 410 */ + 0, /* 411 */ + 0, /* 412 */ + 0, /* 413 */ + 0, /* 414 */ + 0, /* 415 */ + 0, /* 416 */ + 0, /* 417 */ + 0, /* 418 */ + 0, /* 419 */ + 0, /* 420 */ + 0, /* 421 */ + 2, /* 422=BORU */ + 0, /* 423 */ + 0, /* 424 */ + 0, /* 425 */ + 0, /* 426 */ + 0, /* 427 */ + 0, /* 428 */ + 0, /* 429 */ + 0, /* 430 */ + 0, /* 431 */ + 0, /* 432 */ + 0, /* 433 */ + 0, /* 434 */ + 0, /* 435 */ + 0, /* 436 */ + 0, /* 437 */ + 2, /* 438=BXORU */ + 0, /* 439 */ + 0, /* 440 */ + 0, /* 441 */ + 0, /* 442 */ + 0, /* 443 */ + 0, /* 444 */ + 0, /* 445 */ + 0, /* 446 */ + 0, /* 447 */ + 0, /* 448 */ + 2, /* 449=DIVF */ + 2, /* 450=DIVD */ + 0, /* 451 */ + 0, /* 452 */ + 2, /* 453=DIVI */ + 2, /* 454=DIVU */ + 0, /* 455 */ + 0, /* 456 */ + 0, /* 457 */ + 0, /* 458 */ + 0, /* 459 */ + 0, /* 460 */ + 0, /* 461 */ + 0, /* 462 */ + 0, /* 463 */ + 0, /* 464 */ + 2, /* 465=MULF */ + 2, /* 466=MULD */ + 0, /* 467 */ + 0, /* 468 */ + 2, /* 469=MULI */ + 2, /* 470=MULU */ + 0, /* 471 */ + 0, /* 472 */ + 0, /* 473 */ + 0, /* 474 */ + 0, /* 475 */ + 0, /* 476 */ + 0, /* 477 */ + 0, /* 478 */ + 0, /* 479 */ + 0, /* 480 */ + 2, /* 481=EQF */ + 2, /* 482=EQD */ + 0, /* 483 */ + 0, /* 484 */ + 2, /* 485=EQI */ + 0, /* 486 */ + 0, /* 487 */ + 0, /* 488 */ + 0, /* 489 */ + 0, /* 490 */ + 0, /* 491 */ + 0, /* 492 */ + 0, /* 493 */ + 0, /* 494 */ + 0, /* 495 */ + 0, /* 496 */ + 2, /* 497=GEF */ + 2, /* 498=GED */ + 0, /* 499 */ + 0, /* 500 */ + 2, /* 501=GEI */ + 2, /* 502=GEU */ + 0, /* 503 */ + 0, /* 504 */ + 0, /* 505 */ + 0, /* 506 */ + 0, /* 507 */ + 0, /* 508 */ + 0, /* 509 */ + 0, /* 510 */ + 0, /* 511 */ + 0, /* 512 */ + 2, /* 513=GTF */ + 2, /* 514=GTD */ + 0, /* 515 */ + 0, /* 516 */ + 2, /* 517=GTI */ + 2, /* 518=GTU */ + 0, /* 519 */ + 0, /* 520 */ + 0, /* 521 */ + 0, /* 522 */ + 0, /* 523 */ + 0, /* 524 */ + 0, /* 525 */ + 0, /* 526 */ + 0, /* 527 */ + 0, /* 528 */ + 2, /* 529=LEF */ + 2, /* 530=LED */ + 0, /* 531 */ + 0, /* 532 */ + 2, /* 533=LEI */ + 2, /* 534=LEU */ + 0, /* 535 */ + 0, /* 536 */ + 0, /* 537 */ + 0, /* 538 */ + 0, /* 539 */ + 0, /* 540 */ + 0, /* 541 */ + 0, /* 542 */ + 0, /* 543 */ + 0, /* 544 */ + 2, /* 545=LTF */ + 2, /* 546=LTD */ + 0, /* 547 */ + 0, /* 548 */ + 2, /* 549=LTI */ + 2, /* 550=LTU */ + 0, /* 551 */ + 0, /* 552 */ + 0, /* 553 */ + 0, /* 554 */ + 0, /* 555 */ + 0, /* 556 */ + 0, /* 557 */ + 0, /* 558 */ + 0, /* 559 */ + 0, /* 560 */ + 2, /* 561=NEF */ + 2, /* 562=NED */ + 0, /* 563 */ + 0, /* 564 */ + 2, /* 565=NEI */ + 0, /* 566 */ + 0, /* 567 */ + 0, /* 568 */ + 0, /* 569 */ + 0, /* 570 */ + 0, /* 571 */ + 0, /* 572 */ + 0, /* 573 */ + 0, /* 574 */ + 0, /* 575 */ + 0, /* 576 */ + 0, /* 577 */ + 0, /* 578 */ + 0, /* 579 */ + 0, /* 580 */ + 0, /* 581 */ + 0, /* 582 */ + 0, /* 583 */ + 1, /* 584=JUMPV */ + 0, /* 585 */ + 0, /* 586 */ + 0, /* 587 */ + 0, /* 588 */ + 0, /* 589 */ + 0, /* 590 */ + 0, /* 591 */ + 0, /* 592 */ + 0, /* 593 */ + 0, /* 594 */ + 0, /* 595 */ + 0, /* 596 */ + 0, /* 597 */ + 0, /* 598 */ + 0, /* 599 */ + 0, /* 600=LABELV */ + 0, /* 601 */ + 0, /* 602 */ + 0, /* 603 */ + 0, /* 604 */ + 0, /* 605 */ + 0, /* 606 */ + 0, /* 607 */ + 0, /* 608 */ + 0, /* 609 */ + 0, /* 610 */ + 0, /* 611 */ + 0, /* 612 */ + 0, /* 613 */ + 0, /* 614 */ + 0, /* 615=VREGP */ + }; + + static char *_opname[] = { + /* 0 */ 0, + /* 1 */ 0, + /* 2 */ 0, + /* 3 */ 0, + /* 4 */ 0, + /* 5 */ 0, + /* 6 */ 0, + /* 7 */ 0, + /* 8 */ 0, + /* 9 */ 0, + /* 10 */ 0, + /* 11 */ 0, + /* 12 */ 0, + /* 13 */ 0, + /* 14 */ 0, + /* 15 */ 0, + /* 16 */ 0, + /* 17 */ "CNSTF", + /* 18 */ "CNSTD", + /* 19 */ "CNSTC", + /* 20 */ "CNSTS", + /* 21 */ "CNSTI", + /* 22 */ "CNSTU", + /* 23 */ "CNSTP", + /* 24 */ 0, + /* 25 */ 0, + /* 26 */ 0, + /* 27 */ 0, + /* 28 */ 0, + /* 29 */ 0, + /* 30 */ 0, + /* 31 */ 0, + /* 32 */ 0, + /* 33 */ "ARGF", + /* 34 */ "ARGD", + /* 35 */ 0, + /* 36 */ 0, + /* 37 */ "ARGI", + /* 38 */ 0, + /* 39 */ "ARGP", + /* 40 */ 0, + /* 41 */ "ARGB", + /* 42 */ 0, + /* 43 */ 0, + /* 44 */ 0, + /* 45 */ 0, + /* 46 */ 0, + /* 47 */ 0, + /* 48 */ 0, + /* 49 */ "ASGNF", + /* 50 */ "ASGND", + /* 51 */ "ASGNC", + /* 52 */ "ASGNS", + /* 53 */ "ASGNI", + /* 54 */ "ASGNU", + /* 55 */ "ASGNP", + /* 56 */ 0, + /* 57 */ "ASGNB", + /* 58 */ 0, + /* 59 */ 0, + /* 60 */ 0, + /* 61 */ 0, + /* 62 */ 0, + /* 63 */ 0, + /* 64 */ 0, + /* 65 */ "INDIRF", + /* 66 */ "INDIRD", + /* 67 */ "INDIRC", + /* 68 */ "INDIRS", + /* 69 */ "INDIRI", + /* 70 */ 0, + /* 71 */ "INDIRP", + /* 72 */ 0, + /* 73 */ "INDIRB", + /* 74 */ 0, + /* 75 */ 0, + /* 76 */ 0, + /* 77 */ 0, + /* 78 */ 0, + /* 79 */ 0, + /* 80 */ 0, + /* 81 */ 0, + /* 82 */ 0, + /* 83 */ 0, + /* 84 */ 0, + /* 85 */ "CVCI", + /* 86 */ "CVCU", + /* 87 */ 0, + /* 88 */ 0, + /* 89 */ 0, + /* 90 */ 0, + /* 91 */ 0, + /* 92 */ 0, + /* 93 */ 0, + /* 94 */ 0, + /* 95 */ 0, + /* 96 */ 0, + /* 97 */ "CVDF", + /* 98 */ 0, + /* 99 */ 0, + /* 100 */ 0, + /* 101 */ "CVDI", + /* 102 */ 0, + /* 103 */ 0, + /* 104 */ 0, + /* 105 */ 0, + /* 106 */ 0, + /* 107 */ 0, + /* 108 */ 0, + /* 109 */ 0, + /* 110 */ 0, + /* 111 */ 0, + /* 112 */ 0, + /* 113 */ 0, + /* 114 */ "CVFD", + /* 115 */ 0, + /* 116 */ 0, + /* 117 */ 0, + /* 118 */ 0, + /* 119 */ 0, + /* 120 */ 0, + /* 121 */ 0, + /* 122 */ 0, + /* 123 */ 0, + /* 124 */ 0, + /* 125 */ 0, + /* 126 */ 0, + /* 127 */ 0, + /* 128 */ 0, + /* 129 */ 0, + /* 130 */ "CVID", + /* 131 */ "CVIC", + /* 132 */ "CVIS", + /* 133 */ 0, + /* 134 */ "CVIU", + /* 135 */ 0, + /* 136 */ 0, + /* 137 */ 0, + /* 138 */ 0, + /* 139 */ 0, + /* 140 */ 0, + /* 141 */ 0, + /* 142 */ 0, + /* 143 */ 0, + /* 144 */ 0, + /* 145 */ 0, + /* 146 */ 0, + /* 147 */ 0, + /* 148 */ 0, + /* 149 */ 0, + /* 150 */ "CVPU", + /* 151 */ 0, + /* 152 */ 0, + /* 153 */ 0, + /* 154 */ 0, + /* 155 */ 0, + /* 156 */ 0, + /* 157 */ 0, + /* 158 */ 0, + /* 159 */ 0, + /* 160 */ 0, + /* 161 */ 0, + /* 162 */ 0, + /* 163 */ 0, + /* 164 */ 0, + /* 165 */ "CVSI", + /* 166 */ "CVSU", + /* 167 */ 0, + /* 168 */ 0, + /* 169 */ 0, + /* 170 */ 0, + /* 171 */ 0, + /* 172 */ 0, + /* 173 */ 0, + /* 174 */ 0, + /* 175 */ 0, + /* 176 */ 0, + /* 177 */ 0, + /* 178 */ 0, + /* 179 */ "CVUC", + /* 180 */ "CVUS", + /* 181 */ "CVUI", + /* 182 */ 0, + /* 183 */ "CVUP", + /* 184 */ 0, + /* 185 */ 0, + /* 186 */ 0, + /* 187 */ 0, + /* 188 */ 0, + /* 189 */ 0, + /* 190 */ 0, + /* 191 */ 0, + /* 192 */ 0, + /* 193 */ "NEGF", + /* 194 */ "NEGD", + /* 195 */ 0, + /* 196 */ 0, + /* 197 */ "NEGI", + /* 198 */ 0, + /* 199 */ 0, + /* 200 */ 0, + /* 201 */ 0, + /* 202 */ 0, + /* 203 */ 0, + /* 204 */ 0, + /* 205 */ 0, + /* 206 */ 0, + /* 207 */ 0, + /* 208 */ 0, + /* 209 */ "CALLF", + /* 210 */ "CALLD", + /* 211 */ 0, + /* 212 */ 0, + /* 213 */ "CALLI", + /* 214 */ 0, + /* 215 */ 0, + /* 216 */ "CALLV", + /* 217 */ "CALLB", + /* 218 */ 0, + /* 219 */ 0, + /* 220 */ 0, + /* 221 */ 0, + /* 222 */ 0, + /* 223 */ 0, + /* 224 */ 0, + /* 225 */ "LOADF", + /* 226 */ "LOADD", + /* 227 */ "LOADC", + /* 228 */ "LOADS", + /* 229 */ "LOADI", + /* 230 */ "LOADU", + /* 231 */ "LOADP", + /* 232 */ 0, + /* 233 */ "LOADB", + /* 234 */ 0, + /* 235 */ 0, + /* 236 */ 0, + /* 237 */ 0, + /* 238 */ 0, + /* 239 */ 0, + /* 240 */ 0, + /* 241 */ "RETF", + /* 242 */ "RETD", + /* 243 */ 0, + /* 244 */ 0, + /* 245 */ "RETI", + /* 246 */ 0, + /* 247 */ 0, + /* 248 */ 0, + /* 249 */ 0, + /* 250 */ 0, + /* 251 */ 0, + /* 252 */ 0, + /* 253 */ 0, + /* 254 */ 0, + /* 255 */ 0, + /* 256 */ 0, + /* 257 */ 0, + /* 258 */ 0, + /* 259 */ 0, + /* 260 */ 0, + /* 261 */ 0, + /* 262 */ 0, + /* 263 */ "ADDRGP", + /* 264 */ 0, + /* 265 */ 0, + /* 266 */ 0, + /* 267 */ 0, + /* 268 */ 0, + /* 269 */ 0, + /* 270 */ 0, + /* 271 */ 0, + /* 272 */ 0, + /* 273 */ 0, + /* 274 */ 0, + /* 275 */ 0, + /* 276 */ 0, + /* 277 */ 0, + /* 278 */ 0, + /* 279 */ "ADDRFP", + /* 280 */ 0, + /* 281 */ 0, + /* 282 */ 0, + /* 283 */ 0, + /* 284 */ 0, + /* 285 */ 0, + /* 286 */ 0, + /* 287 */ 0, + /* 288 */ 0, + /* 289 */ 0, + /* 290 */ 0, + /* 291 */ 0, + /* 292 */ 0, + /* 293 */ 0, + /* 294 */ 0, + /* 295 */ "ADDRLP", + /* 296 */ 0, + /* 297 */ 0, + /* 298 */ 0, + /* 299 */ 0, + /* 300 */ 0, + /* 301 */ 0, + /* 302 */ 0, + /* 303 */ 0, + /* 304 */ 0, + /* 305 */ "ADDF", + /* 306 */ "ADDD", + /* 307 */ "ADDC", + /* 308 */ "ADDS", + /* 309 */ "ADDI", + /* 310 */ "ADDU", + /* 311 */ "ADDP", + /* 312 */ 0, + /* 313 */ 0, + /* 314 */ 0, + /* 315 */ 0, + /* 316 */ 0, + /* 317 */ 0, + /* 318 */ 0, + /* 319 */ 0, + /* 320 */ 0, + /* 321 */ "SUBF", + /* 322 */ "SUBD", + /* 323 */ "SUBC", + /* 324 */ "SUBS", + /* 325 */ "SUBI", + /* 326 */ "SUBU", + /* 327 */ "SUBP", + /* 328 */ 0, + /* 329 */ 0, + /* 330 */ 0, + /* 331 */ 0, + /* 332 */ 0, + /* 333 */ 0, + /* 334 */ 0, + /* 335 */ 0, + /* 336 */ 0, + /* 337 */ 0, + /* 338 */ 0, + /* 339 */ 0, + /* 340 */ 0, + /* 341 */ "LSHI", + /* 342 */ "LSHU", + /* 343 */ 0, + /* 344 */ 0, + /* 345 */ 0, + /* 346 */ 0, + /* 347 */ 0, + /* 348 */ 0, + /* 349 */ 0, + /* 350 */ 0, + /* 351 */ 0, + /* 352 */ 0, + /* 353 */ 0, + /* 354 */ 0, + /* 355 */ 0, + /* 356 */ 0, + /* 357 */ "MODI", + /* 358 */ "MODU", + /* 359 */ 0, + /* 360 */ 0, + /* 361 */ 0, + /* 362 */ 0, + /* 363 */ 0, + /* 364 */ 0, + /* 365 */ 0, + /* 366 */ 0, + /* 367 */ 0, + /* 368 */ 0, + /* 369 */ 0, + /* 370 */ 0, + /* 371 */ 0, + /* 372 */ 0, + /* 373 */ "RSHI", + /* 374 */ "RSHU", + /* 375 */ 0, + /* 376 */ 0, + /* 377 */ 0, + /* 378 */ 0, + /* 379 */ 0, + /* 380 */ 0, + /* 381 */ 0, + /* 382 */ 0, + /* 383 */ 0, + /* 384 */ 0, + /* 385 */ 0, + /* 386 */ 0, + /* 387 */ 0, + /* 388 */ 0, + /* 389 */ 0, + /* 390 */ "BANDU", + /* 391 */ 0, + /* 392 */ 0, + /* 393 */ 0, + /* 394 */ 0, + /* 395 */ 0, + /* 396 */ 0, + /* 397 */ 0, + /* 398 */ 0, + /* 399 */ 0, + /* 400 */ 0, + /* 401 */ 0, + /* 402 */ 0, + /* 403 */ 0, + /* 404 */ 0, + /* 405 */ 0, + /* 406 */ "BCOMU", + /* 407 */ 0, + /* 408 */ 0, + /* 409 */ 0, + /* 410 */ 0, + /* 411 */ 0, + /* 412 */ 0, + /* 413 */ 0, + /* 414 */ 0, + /* 415 */ 0, + /* 416 */ 0, + /* 417 */ 0, + /* 418 */ 0, + /* 419 */ 0, + /* 420 */ 0, + /* 421 */ 0, + /* 422 */ "BORU", + /* 423 */ 0, + /* 424 */ 0, + /* 425 */ 0, + /* 426 */ 0, + /* 427 */ 0, + /* 428 */ 0, + /* 429 */ 0, + /* 430 */ 0, + /* 431 */ 0, + /* 432 */ 0, + /* 433 */ 0, + /* 434 */ 0, + /* 435 */ 0, + /* 436 */ 0, + /* 437 */ 0, + /* 438 */ "BXORU", + /* 439 */ 0, + /* 440 */ 0, + /* 441 */ 0, + /* 442 */ 0, + /* 443 */ 0, + /* 444 */ 0, + /* 445 */ 0, + /* 446 */ 0, + /* 447 */ 0, + /* 448 */ 0, + /* 449 */ "DIVF", + /* 450 */ "DIVD", + /* 451 */ 0, + /* 452 */ 0, + /* 453 */ "DIVI", + /* 454 */ "DIVU", + /* 455 */ 0, + /* 456 */ 0, + /* 457 */ 0, + /* 458 */ 0, + /* 459 */ 0, + /* 460 */ 0, + /* 461 */ 0, + /* 462 */ 0, + /* 463 */ 0, + /* 464 */ 0, + /* 465 */ "MULF", + /* 466 */ "MULD", + /* 467 */ 0, + /* 468 */ 0, + /* 469 */ "MULI", + /* 470 */ "MULU", + /* 471 */ 0, + /* 472 */ 0, + /* 473 */ 0, + /* 474 */ 0, + /* 475 */ 0, + /* 476 */ 0, + /* 477 */ 0, + /* 478 */ 0, + /* 479 */ 0, + /* 480 */ 0, + /* 481 */ "EQF", + /* 482 */ "EQD", + /* 483 */ 0, + /* 484 */ 0, + /* 485 */ "EQI", + /* 486 */ 0, + /* 487 */ 0, + /* 488 */ 0, + /* 489 */ 0, + /* 490 */ 0, + /* 491 */ 0, + /* 492 */ 0, + /* 493 */ 0, + /* 494 */ 0, + /* 495 */ 0, + /* 496 */ 0, + /* 497 */ "GEF", + /* 498 */ "GED", + /* 499 */ 0, + /* 500 */ 0, + /* 501 */ "GEI", + /* 502 */ "GEU", + /* 503 */ 0, + /* 504 */ 0, + /* 505 */ 0, + /* 506 */ 0, + /* 507 */ 0, + /* 508 */ 0, + /* 509 */ 0, + /* 510 */ 0, + /* 511 */ 0, + /* 512 */ 0, + /* 513 */ "GTF", + /* 514 */ "GTD", + /* 515 */ 0, + /* 516 */ 0, + /* 517 */ "GTI", + /* 518 */ "GTU", + /* 519 */ 0, + /* 520 */ 0, + /* 521 */ 0, + /* 522 */ 0, + /* 523 */ 0, + /* 524 */ 0, + /* 525 */ 0, + /* 526 */ 0, + /* 527 */ 0, + /* 528 */ 0, + /* 529 */ "LEF", + /* 530 */ "LED", + /* 531 */ 0, + /* 532 */ 0, + /* 533 */ "LEI", + /* 534 */ "LEU", + /* 535 */ 0, + /* 536 */ 0, + /* 537 */ 0, + /* 538 */ 0, + /* 539 */ 0, + /* 540 */ 0, + /* 541 */ 0, + /* 542 */ 0, + /* 543 */ 0, + /* 544 */ 0, + /* 545 */ "LTF", + /* 546 */ "LTD", + /* 547 */ 0, + /* 548 */ 0, + /* 549 */ "LTI", + /* 550 */ "LTU", + /* 551 */ 0, + /* 552 */ 0, + /* 553 */ 0, + /* 554 */ 0, + /* 555 */ 0, + /* 556 */ 0, + /* 557 */ 0, + /* 558 */ 0, + /* 559 */ 0, + /* 560 */ 0, + /* 561 */ "NEF", + /* 562 */ "NED", + /* 563 */ 0, + /* 564 */ 0, + /* 565 */ "NEI", + /* 566 */ 0, + /* 567 */ 0, + /* 568 */ 0, + /* 569 */ 0, + /* 570 */ 0, + /* 571 */ 0, + /* 572 */ 0, + /* 573 */ 0, + /* 574 */ 0, + /* 575 */ 0, + /* 576 */ 0, + /* 577 */ 0, + /* 578 */ 0, + /* 579 */ 0, + /* 580 */ 0, + /* 581 */ 0, + /* 582 */ 0, + /* 583 */ 0, + /* 584 */ "JUMPV", + /* 585 */ 0, + /* 586 */ 0, + /* 587 */ 0, + /* 588 */ 0, + /* 589 */ 0, + /* 590 */ 0, + /* 591 */ 0, + /* 592 */ 0, + /* 593 */ 0, + /* 594 */ 0, + /* 595 */ 0, + /* 596 */ 0, + /* 597 */ 0, + /* 598 */ 0, + /* 599 */ 0, + /* 600 */ "LABELV", + /* 601 */ 0, + /* 602 */ 0, + /* 603 */ 0, + /* 604 */ 0, + /* 605 */ 0, + /* 606 */ 0, + /* 607 */ 0, + /* 608 */ 0, + /* 609 */ 0, + /* 610 */ 0, + /* 611 */ 0, + /* 612 */ 0, + /* 613 */ 0, + /* 614 */ 0, + /* 615 */ "VREGP", + }; + + static char *_templates[] = { + /* 0 */ 0, + /* 1 */ "# read register\n", /* reg: INDIRC(VREGP) */ + /* 2 */ "# read register\n", /* reg: INDIRD(VREGP) */ + /* 3 */ "# read register\n", /* reg: INDIRF(VREGP) */ + /* 4 */ "# read register\n", /* reg: INDIRI(VREGP) */ + /* 5 */ "# read register\n", /* reg: INDIRP(VREGP) */ + /* 6 */ "# read register\n", /* reg: INDIRS(VREGP) */ + /* 7 */ "# write register\n", /* stmt: ASGNC(VREGP,reg) */ + /* 8 */ "# write register\n", /* stmt: ASGND(VREGP,reg) */ + /* 9 */ "# write register\n", /* stmt: ASGNF(VREGP,reg) */ + /* 10 */ "# write register\n", /* stmt: ASGNI(VREGP,reg) */ + /* 11 */ "# write register\n", /* stmt: ASGND(VREGP,reg) */ + /* 12 */ "# write register\n", /* stmt: ASGNP(VREGP,reg) */ + /* 13 */ "# write register\n", /* stmt: ASGNS(VREGP,reg) */ + /* 14 */ "%#%a", /* con: CNSTC */ + /* 15 */ "%#%a", /* con: CNSTI */ + /* 16 */ "%#%a", /* con: CNSTP */ + /* 17 */ "%#%a", /* con: CNSTS */ + /* 18 */ "%#%a", /* con: CNSTU */ + /* 19 */ "", /* stmt: reg */ + /* 20 */ "%0", /* reg: CVIU(reg) */ + /* 21 */ "%0", /* reg: CVUI(reg) */ + /* 22 */ "%a", /* disp16: CNSTI */ + /* 23 */ "%a", /* disp8: CNSTI */ + /* 24 */ "%1(%0", /* base: ADDP(reg,disp16) */ + /* 25 */ "%a(A5", /* base: ADDRFP */ + /* 26 */ "%a(A5", /* base: ADDRLP */ + /* 27 */ "%0", /* base: basei */ + /* 28 */ "0(%0", /* basei: reg */ + /* 29 */ "%1(%0", /* basei: ADDP(reg,disp8) */ + /* 30 */ "%a(A5", /* basei: ADDRFP */ + /* 31 */ "%a(A5", /* basei: ADDRLP */ + /* 32 */ "0(%a,A5", /* basei: ADDRFP */ + /* 33 */ "0(%a,A5", /* basei: ADDRLP */ + /* 34 */ "%a", /* addr: ADDRGP */ + /* 35 */ "%a", /* acon: ADDRGP */ + /* 36 */ "\tLEA %a,%c\n", /* table: ADDRGP */ + /* 37 */ "%0", /* index: reg */ + /* 38 */ "%0*%1", /* index: LSHI(reg,scf) */ + /* 39 */ "%0)", /* addr: base */ + /* 40 */ "%1,%0)", /* addr: ADDP(index,basei) */ + /* 41 */ "0(%1,%0)", /* case: ADDP(index,table) */ + /* 42 */ "%0", /* avar: acon */ + /* 43 */ "(%0)", /* avar: reg */ + /* 44 */ "%0", /* avar: addr */ + /* 45 */ "%#0", /* con0: CNSTI */ + /* 46 */ "%#0", /* con0: CNSTP */ + /* 47 */ "%#0", /* con0: CNSTU */ + /* 48 */ "%#%a", /* con3: CNSTI */ + /* 49 */ "%#%a", /* con3: CNSTP */ + /* 50 */ "2", /* scf: CNSTI */ + /* 51 */ "4", /* scf: CNSTI */ + /* 52 */ "8", /* scf: CNSTI */ + /* 53 */ "%0", /* mem: INDIRI(addr) */ + /* 54 */ "%0", /* mem: INDIRP(addr) */ + /* 55 */ "\tMOVE.L %0,%c\n", /* pcrel: INDIRP(case) */ + /* 56 */ "%0", /* ri: reg */ + /* 57 */ "%0", /* ri: con */ + /* 58 */ "%0", /* ri3: con3 */ + /* 59 */ "%0", /* ri3: reg */ + /* 60 */ "%0", /* ea0: mem */ + /* 61 */ "%0", /* ea0: ri */ + /* 62 */ "%0", /* ea1: mem */ + /* 63 */ "%0", /* ea1: ri */ + /* 64 */ "%0", /* ea3: mem */ + /* 65 */ "%0", /* ea3: ri */ + /* 66 */ "\tLEA %0,%c\n", /* reg: addr */ + /* 67 */ "\tMOVE.L %0,%c\n", /* reg: ri */ + /* 68 */ "\tMOVE.B %0,%c\n", /* reg: INDIRC(addr) */ + /* 69 */ "\tMOVE.L %0,%c\n", /* reg: INDIRI(addr) */ + /* 70 */ "\tMOVE.L %0,%c\n", /* reg: INDIRP(addr) */ + /* 71 */ "\tMOVE.W %0,%c\n", /* reg: INDIRS(addr) */ + /* 72 */ "\tMOVE.L %0,%c\n", /* reg: LOADC(reg) */ + /* 73 */ "\tMOVE.L %0,%c\n", /* reg: LOADI(reg) */ + /* 74 */ "\tMOVE.L %0,%c\n", /* reg: LOADP(reg) */ + /* 75 */ "\tMOVE.L %0,%c\n", /* reg: LOADS(reg) */ + /* 76 */ "\tMOVE.L %0,%c\n", /* reg: LOADU(reg) */ + /* 77 */ "?\tMOVE.L %0,%c\n\tADDQ.L %1,%c\n", /* reg: ADDI(reg,con3) */ + /* 78 */ "?\tMOVE.L %0,%c\n\tSUBQ.L %1,%c\n", /* reg: SUBI(reg,con3) */ + /* 79 */ "?\tMOVE.L %0,%c\n\tADD.L %1,%c\n", /* reg: ADDI(reg,ea1) */ + /* 80 */ "?\tMOVE.L %0,%c\n\tADDA.L %1,%c\n", /* reg: ADDP(reg,ea1) */ + /* 81 */ "?\tMOVE.L %0,%c\n\tADD.L %1,%c\n", /* reg: ADDU(reg,ea1) */ + /* 82 */ "?\tMOVE.L %0,%c\n\tSUB.L %1,%c\n", /* reg: SUBI(reg,ea1) */ + /* 83 */ "?\tMOVE.L %0,%c\n\tSUBA.L %1,%c\n", /* reg: SUBP(reg,ea1) */ + /* 84 */ "?\tMOVE.L %0,%c\n\tSUB.L %1,%c\n", /* reg: SUBU(reg,ea1) */ + /* 85 */ "\tADD.L %2,%1\n", /* stmt: ASGNI(addr,ADDI(mem,ri)) */ + /* 86 */ "\tADD.L %2,%1\n", /* stmt: ASGNI(addr,ADDU(mem,ri)) */ + /* 87 */ "\tSUB.L %2,%1\n", /* stmt: ASGNI(addr,SUBI(mem,ri)) */ + /* 88 */ "\tSUB.L %2,%1\n", /* stmt: ASGNI(addr,SUBU(mem,ri)) */ + /* 89 */ "?\tMOVE.L %0,%c\n\tAND.L %1,%c\n", /* reg: BANDU(reg,ea1) */ + /* 90 */ "?\tMOVE.L %0,%c\n\tOR.L %1,%c\n", /* reg: BORU(reg,ea1) */ + /* 91 */ "?\tMOVE.L %0,%c\n\tEOR.L %1,%c\n", /* reg: BXORU(reg,reg) */ + /* 92 */ "\tAND.L %2,%1\n", /* stmt: ASGNI(addr,BANDU(mem,ri)) */ + /* 93 */ "\tOR.L %2,%1\n", /* stmt: ASGNI(addr,BORU(mem,ri)) */ + /* 94 */ "\tEOR.L %2,%1\n", /* stmt: ASGNI(addr,BXORU(mem,reg)) */ + /* 95 */ "?\tMOVE.L %0,%c\n\tNOT.L %c\n", /* reg: BCOMU(reg) */ + /* 96 */ "?\tMOVE.L %0,%c\n\tNEG.L %c\n", /* reg: NEGI(reg) */ + /* 97 */ "\tNOT.L %1\n", /* stmt: ASGNI(addr,BCOMU(mem)) */ + /* 98 */ "\tNEG.L %1\n", /* stmt: ASGNI(addr,NEGI(mem)) */ + /* 99 */ "?\tMOVE.L %0,%c\n\tASL.L %1,%c\n", /* reg: LSHI(reg,ri3) */ + /* 100 */ "?\tMOVE.L %0,%c\n\tLSL.L %1,%c\n", /* reg: LSHU(reg,ri3) */ + /* 101 */ "?\tMOVE.L %0,%c\n\tASR.L %1,%c\n", /* reg: RSHI(reg,ri3) */ + /* 102 */ "?\tMOVE.L %0,%c\n\tLSR.L %1,%c\n", /* reg: RSHU(reg,ri3) */ + /* 103 */ "?\tMOVE.L %0,%c\n\tMULS.L %1,%c\n", /* reg: MULI(reg,ea3) */ + /* 104 */ "?\tMOVE.L %0,%c\n\tMULU.L %1,%c\n", /* reg: MULU(reg,ea3) */ + /* 105 */ "?\tMOVE.L %0,%c\n\tDIVU.L %1,%c\n", /* reg: DIVU(reg,ea3) */ + /* 106 */ "?\tMOVE.L %0,%c\n\tDIVS.L %1,%c\n", /* reg: DIVI(reg,ea3) */ + /* 107 */ "\tMOVE.L %0,D1\n\tCLR.L %c\n\tDIVU.L %1,%c:D1\n", /* reg: MODU(reg,ea3) */ + /* 108 */ "#\tCLR.L %c\n\tDIVS.L %1,%0\n", /* reg: MODI(reg,reg) */ + /* 109 */ "\tMOVE.B %0,%c\n\tEXT.W %c\n\tEXT.L %c\n", /* reg: CVCI(reg) */ + /* 110 */ "\tMOVE.B %0,%c\n\tAND.L #$FF,%0\n", /* reg: CVCU(reg) */ + /* 111 */ "\tMOVE.W %0,%c\n\tEXT.L %c\n", /* reg: CVSI(reg) */ + /* 112 */ "\tMOVE.W %0,%c\n\tAND.L #$FFFF,%0\n", /* reg: CVSU(reg) */ + /* 113 */ "\tMOVE.B %0,%c\n\tEXT.W %c\n\tEXT.L %c\n", /* reg: CVCI(INDIRC(addr)) */ + /* 114 */ "\tMOVE.B %0,%c\n\tANDI.L #$ff,%c\n", /* reg: CVCU(INDIRC(addr)) */ + /* 115 */ "\tMOVE.W %0,%c\n\tEXT.L %c\n", /* reg: CVSI(INDIRS(addr)) */ + /* 116 */ "\tMOVE.W %0,%c\n\tANDI.L #$ffff,%c\n", /* reg: CVSU(INDIRS(addr)) */ + /* 117 */ "%0", /* reg: CVIC(reg) */ + /* 118 */ "%0", /* reg: CVIS(reg) */ + /* 119 */ "%0", /* reg: CVUC(reg) */ + /* 120 */ "%0", /* reg: CVUS(reg) */ + /* 121 */ "\tMOVE.L %0,%c\n", /* reg: CVIC(reg) */ + /* 122 */ "\tMOVE.L %0,%c\n", /* reg: CVIS(reg) */ + /* 123 */ "\tMOVE.L %0,%c\n", /* reg: CVIU(reg) */ + /* 124 */ "\tMOVE.L %0,%c\n", /* reg: CVPU(reg) */ + /* 125 */ "\tMOVE.L %0,%c\n", /* reg: CVUC(reg) */ + /* 126 */ "\tMOVE.L %0,%c\n", /* reg: CVUI(reg) */ + /* 127 */ "\tMOVE.L %0,%c\n", /* reg: CVUP(reg) */ + /* 128 */ "\tMOVE.L %0,%c\n", /* reg: CVUS(reg) */ + /* 129 */ "%0", /* reg: CVDF(reg) */ + /* 130 */ "%0", /* reg: CVFD(reg) */ + /* 131 */ "\tFMOVE.D %0,%c\n", /* reg: CVDF(reg) */ + /* 132 */ "\tFMOVE.D %0,%c\n", /* reg: CVFD(reg) */ + /* 133 */ "\tFMOVE.L %0,%c\n", /* reg: CVID(ea0) */ + /* 134 */ "\tFMOVE.L %0,%c\n", /* reg: CVDI(reg) */ + /* 135 */ "\tMOVE.B %1,%0\n", /* stmt: ASGNC(addr,ea1) */ + /* 136 */ "\tCLR.L %0\n", /* stmt: ASGNC(addr,con0) */ + /* 137 */ "\tMOVE.L %1,%0\n", /* stmt: ASGNI(addr,ea1) */ + /* 138 */ "\tCLR.L %0\n", /* stmt: ASGNI(addr,con0) */ + /* 139 */ "\tFMOVE.L %1,%0\n", /* stmt: ASGNI(addr,CVDI(reg)) */ + /* 140 */ "\tMOVE.L %1,%0\n", /* stmt: ASGNP(addr,ea1) */ + /* 141 */ "\tCLR.L %0\n", /* stmt: ASGNP(addr,con0) */ + /* 142 */ "\tMOVE.W %1,%0\n", /* stmt: ASGNS(addr,ea1) */ + /* 143 */ "\tCLR.W %0\n", /* stmt: ASGNS(addr,con0) */ + /* 144 */ "\tMOVE.L %0,-(SP)\n", /* stmt: ARGI(ea0) */ + /* 145 */ "\tPEA.L %0\n", /* stmt: ARGI(addr) */ + /* 146 */ "\tMOVE.L %0,-(SP)\n", /* stmt: ARGP(ea0) */ + /* 147 */ "\tPEA.L %0\n", /* stmt: ARGP(addr) */ + /* 148 */ "# MOVE (src)+,(dst)+\n", /* stmt: ASGNB(reg,INDIRB(reg)) */ + /* 149 */ "# Copy to stack\n", /* stmt: ARGB(INDIRB(reg)) */ + /* 150 */ "\tFMOVE.D %0,%c\n", /* reg: LOADD(reg) */ + /* 151 */ "\tFMOVE.D %0,%c\n", /* reg: LOADF(reg) */ + /* 152 */ "\tFMOVE.D %0,%c\n", /* reg: INDIRD(addr) */ + /* 153 */ "\tFMOVE.S %0,%c\n", /* reg: INDIRF(addr) */ + /* 154 */ "%0", /* mem: INDIRD(addr) */ + /* 155 */ "%0", /* mem: INDIRF(addr) */ + /* 156 */ "\tFMOVE.D %1,%0\n", /* stmt: ASGND(addr,reg) */ + /* 157 */ "\tLEA.L %1,A0\n\tLEA.L %0,A1\n\tMOVE.L (A0)+,(A1)+\n\tMOVE.L (A0),(A1)\n", /* stmt: ASGND(addr,mem) */ + /* 158 */ "\tFMOVE.S %1,%0\n", /* stmt: ASGNF(addr,reg) */ + /* 159 */ "\tMOVE.L %1,%0\n", /* stmt: ASGNF(addr,mem) */ + /* 160 */ "\tFMOVE.D %0,-(SP)\n", /* stmt: ARGD(reg) */ + /* 161 */ "\tFMOVE.D %0,-(SP)\n", /* stmt: ARGF(reg) */ + /* 162 */ "?\tFMOVE.D %0,%c\n\tFADD.D %1,%c\n", /* reg: ADDD(reg,reg) */ + /* 163 */ "?\tFMOVE.D %0,%c\n\tFADD.D %1,%c\n", /* reg: ADDF(reg,reg) */ + /* 164 */ "?\tFMOVE.D %0,%c\n\tFSUB.D %1,%c\n", /* reg: SUBD(reg,reg) */ + /* 165 */ "?\tFMOVE.D %0,%c\n\tFSUB.D %1,%c\n", /* reg: SUBF(reg,reg) */ + /* 166 */ "?\tFMOVE.D %0,%c\n\tFMUL.D %1,%c\n", /* reg: MULD(reg,reg) */ + /* 167 */ "?\tFMOVE.D %0,%c\n\tFMUL.D %1,%c\n", /* reg: MULF(reg,reg) */ + /* 168 */ "?\tFMOVE.D %0,%c\n\tFDIV.D %1,%c\n", /* reg: DIVD(reg,reg) */ + /* 169 */ "?\tFMOVE.D %0,%c\n\tFDIV.D %1,%c\n", /* reg: DIVF(reg,reg) */ + /* 170 */ "\tFNEG.D %c\n", /* reg: NEGD(reg) */ + /* 171 */ "\tFNEG.D %c\n", /* reg: NEGF(reg) */ + /* 172 */ "\tBRA.L %0\n", /* stmt: JUMPV(acon) */ + /* 173 */ "\tJMP 0(%0)\n", /* stmt: JUMPV(pcrel) */ + /* 174 */ "%a:\n", /* stmt: LABELV */ + /* 175 */ "\tTST.L %0\n\tBEQ.L %a\n", /* stmt: EQI(ea0,con0) */ + /* 176 */ "\tTST.L %0\n\tBNE.L %a\n", /* stmt: NEI(ea0,con0) */ + /* 177 */ "\tCMP.L %1,%0\n\tBEQ.L %a\n", /* stmt: EQI(reg,ea1) */ + /* 178 */ "\tCMP.L %1,%0\n\tBGE.L %a\n", /* stmt: GEI(reg,ea1) */ + /* 179 */ "\tCMP.L %1,%0\n\tBGT.L %a\n", /* stmt: GTI(reg,ea1) */ + /* 180 */ "\tCMP.L %1,%0\n\tBLE.L %a\n", /* stmt: LEI(reg,ea1) */ + /* 181 */ "\tCMP.L %1,%0\n\tBLT.L %a\n", /* stmt: LTI(reg,ea1) */ + /* 182 */ "\tCMP.L %1,%0\n\tBNE.L %a\n", /* stmt: NEI(reg,ea1) */ + /* 183 */ "\tCMP.L %1,%0\n\tBHS.L %a\n", /* stmt: GEU(reg,ea1) */ + /* 184 */ "\tCMP.L %1,%0\n\tBHI.L %a\n", /* stmt: GTU(reg,ea1) */ + /* 185 */ "\tCMP.L %1,%0\n\tBLS.L %a\n", /* stmt: LEU(reg,ea1) */ + /* 186 */ "\tCMP.L %1,%0\n\tBLO.L %a\n", /* stmt: LTU(reg,ea1) */ + /* 187 */ "\tFCMP.D %1,%0\n\tFBEQ.W %a\n", /* stmt: EQD(reg,reg) */ + /* 188 */ "\tFCMP.D %1,%0\n\tFBGE.W %a\n", /* stmt: GED(reg,reg) */ + /* 189 */ "\tFCMP.D %1,%0\n\tFBGT.W %a\n", /* stmt: GTD(reg,reg) */ + /* 190 */ "\tFCMP.D %1,%0\n\tFBLE.W %a\n", /* stmt: LED(reg,reg) */ + /* 191 */ "\tFCMP.D %1,%0\n\tFBLT.W %a\n", /* stmt: LTD(reg,reg) */ + /* 192 */ "\tFCMP.D %1,%0\n\tFBNE.W %a\n", /* stmt: NED(reg,reg) */ + /* 193 */ "\tFCMP.D %1,%0\n\tFBEQ.W %a\n", /* stmt: EQF(reg,reg) */ + /* 194 */ "\tFCMP.D %1,%0\n\tFBGE.W %a\n", /* stmt: GEF(reg,reg) */ + /* 195 */ "\tFCMP.D %1,%0\n\tFBGT.W %a\n", /* stmt: GTF(reg,reg) */ + /* 196 */ "\tFCMP.D %1,%0\n\tFBLE.W %a\n", /* stmt: LEF(reg,reg) */ + /* 197 */ "\tFCMP.D %1,%0\n\tFBLT.W %a\n", /* stmt: LTF(reg,reg) */ + /* 198 */ "\tFCMP.D %1,%0\n\tFBNE.W %a\n", /* stmt: NEF(reg,reg) */ + /* 199 */ "\tJSR %0\n\tADDA.L %#%a,SP\n", /* reg: CALLI(avar) */ + /* 200 */ "\tJSR %0\n\tADDA.L %#%a,SP\n", /* stmt: CALLV(avar) */ + /* 201 */ "\tJSR %0\n\tADDA.L %#%a,SP\n", /* reg: CALLF(avar) */ + /* 202 */ "\tJSR %0\n\tADDA.L %#%a,SP\n", /* reg: CALLD(avar) */ + /* 203 */ "# RTS\n", /* stmt: RETI(reg) */ + /* 204 */ "# RTS\n", /* stmt: RETF(reg) */ + /* 205 */ "# RTS\n", /* stmt: RETD(reg) */ + }; + + static char _isinstruction[] = { + /* 0 */ 0, + /* 1 */ 1, /* # read register\n */ + /* 2 */ 1, /* # read register\n */ + /* 3 */ 1, /* # read register\n */ + /* 4 */ 1, /* # read register\n */ + /* 5 */ 1, /* # read register\n */ + /* 6 */ 1, /* # read register\n */ + /* 7 */ 1, /* # write register\n */ + /* 8 */ 1, /* # write register\n */ + /* 9 */ 1, /* # write register\n */ + /* 10 */ 1, /* # write register\n */ + /* 11 */ 1, /* # write register\n */ + /* 12 */ 1, /* # write register\n */ + /* 13 */ 1, /* # write register\n */ + /* 14 */ 0, /* %#%a */ + /* 15 */ 0, /* %#%a */ + /* 16 */ 0, /* %#%a */ + /* 17 */ 0, /* %#%a */ + /* 18 */ 0, /* %#%a */ + /* 19 */ 0, /* */ + /* 20 */ 0, /* %0 */ + /* 21 */ 0, /* %0 */ + /* 22 */ 0, /* %a */ + /* 23 */ 0, /* %a */ + /* 24 */ 0, /* %1(%0 */ + /* 25 */ 0, /* %a(A5 */ + /* 26 */ 0, /* %a(A5 */ + /* 27 */ 0, /* %0 */ + /* 28 */ 0, /* 0(%0 */ + /* 29 */ 0, /* %1(%0 */ + /* 30 */ 0, /* %a(A5 */ + /* 31 */ 0, /* %a(A5 */ + /* 32 */ 0, /* 0(%a,A5 */ + /* 33 */ 0, /* 0(%a,A5 */ + /* 34 */ 0, /* %a */ + /* 35 */ 0, /* %a */ + /* 36 */ 1, /* \tLEA %a,%c\n */ + /* 37 */ 0, /* %0 */ + /* 38 */ 0, /* %0*%1 */ + /* 39 */ 0, /* %0) */ + /* 40 */ 0, /* %1,%0) */ + /* 41 */ 0, /* 0(%1,%0) */ + /* 42 */ 0, /* %0 */ + /* 43 */ 0, /* (%0) */ + /* 44 */ 0, /* %0 */ + /* 45 */ 0, /* %#0 */ + /* 46 */ 0, /* %#0 */ + /* 47 */ 0, /* %#0 */ + /* 48 */ 0, /* %#%a */ + /* 49 */ 0, /* %#%a */ + /* 50 */ 0, /* 2 */ + /* 51 */ 0, /* 4 */ + /* 52 */ 0, /* 8 */ + /* 53 */ 0, /* %0 */ + /* 54 */ 0, /* %0 */ + /* 55 */ 1, /* \tMOVE.L %0,%c\n */ + /* 56 */ 0, /* %0 */ + /* 57 */ 0, /* %0 */ + /* 58 */ 0, /* %0 */ + /* 59 */ 0, /* %0 */ + /* 60 */ 0, /* %0 */ + /* 61 */ 0, /* %0 */ + /* 62 */ 0, /* %0 */ + /* 63 */ 0, /* %0 */ + /* 64 */ 0, /* %0 */ + /* 65 */ 0, /* %0 */ + /* 66 */ 1, /* \tLEA %0,%c\n */ + /* 67 */ 1, /* \tMOVE.L %0,%c\n */ + /* 68 */ 1, /* \tMOVE.B %0,%c\n */ + /* 69 */ 1, /* \tMOVE.L %0,%c\n */ + /* 70 */ 1, /* \tMOVE.L %0,%c\n */ + /* 71 */ 1, /* \tMOVE.W %0,%c\n */ + /* 72 */ 1, /* \tMOVE.L %0,%c\n */ + /* 73 */ 1, /* \tMOVE.L %0,%c\n */ + /* 74 */ 1, /* \tMOVE.L %0,%c\n */ + /* 75 */ 1, /* \tMOVE.L %0,%c\n */ + /* 76 */ 1, /* \tMOVE.L %0,%c\n */ + /* 77 */ 1, /* ?\tMOVE.L %0,%c\n\tADDQ.L %1,%c\n */ + /* 78 */ 1, /* ?\tMOVE.L %0,%c\n\tSUBQ.L %1,%c\n */ + /* 79 */ 1, /* ?\tMOVE.L %0,%c\n\tADD.L %1,%c\n */ + /* 80 */ 1, /* ?\tMOVE.L %0,%c\n\tADDA.L %1,%c\n */ + /* 81 */ 1, /* ?\tMOVE.L %0,%c\n\tADD.L %1,%c\n */ + /* 82 */ 1, /* ?\tMOVE.L %0,%c\n\tSUB.L %1,%c\n */ + /* 83 */ 1, /* ?\tMOVE.L %0,%c\n\tSUBA.L %1,%c\n */ + /* 84 */ 1, /* ?\tMOVE.L %0,%c\n\tSUB.L %1,%c\n */ + /* 85 */ 1, /* \tADD.L %2,%1\n */ + /* 86 */ 1, /* \tADD.L %2,%1\n */ + /* 87 */ 1, /* \tSUB.L %2,%1\n */ + /* 88 */ 1, /* \tSUB.L %2,%1\n */ + /* 89 */ 1, /* ?\tMOVE.L %0,%c\n\tAND.L %1,%c\n */ + /* 90 */ 1, /* ?\tMOVE.L %0,%c\n\tOR.L %1,%c\n */ + /* 91 */ 1, /* ?\tMOVE.L %0,%c\n\tEOR.L %1,%c\n */ + /* 92 */ 1, /* \tAND.L %2,%1\n */ + /* 93 */ 1, /* \tOR.L %2,%1\n */ + /* 94 */ 1, /* \tEOR.L %2,%1\n */ + /* 95 */ 1, /* ?\tMOVE.L %0,%c\n\tNOT.L %c\n */ + /* 96 */ 1, /* ?\tMOVE.L %0,%c\n\tNEG.L %c\n */ + /* 97 */ 1, /* \tNOT.L %1\n */ + /* 98 */ 1, /* \tNEG.L %1\n */ + /* 99 */ 1, /* ?\tMOVE.L %0,%c\n\tASL.L %1,%c\n */ + /* 100 */ 1, /* ?\tMOVE.L %0,%c\n\tLSL.L %1,%c\n */ + /* 101 */ 1, /* ?\tMOVE.L %0,%c\n\tASR.L %1,%c\n */ + /* 102 */ 1, /* ?\tMOVE.L %0,%c\n\tLSR.L %1,%c\n */ + /* 103 */ 1, /* ?\tMOVE.L %0,%c\n\tMULS.L %1,%c\n */ + /* 104 */ 1, /* ?\tMOVE.L %0,%c\n\tMULU.L %1,%c\n */ + /* 105 */ 1, /* ?\tMOVE.L %0,%c\n\tDIVU.L %1,%c\n */ + /* 106 */ 1, /* ?\tMOVE.L %0,%c\n\tDIVS.L %1,%c\n */ + /* 107 */ 1, /* \tMOVE.L %0,D1\n\tCLR.L %c\n\tDIVU.L %1,%c:D1\n */ + /* 108 */ 1, /* #\tCLR.L %c\n\tDIVS.L %1,%0\n */ + /* 109 */ 1, /* \tMOVE.B %0,%c\n\tEXT.W %c\n\tEXT.L %c\n */ + /* 110 */ 1, /* \tMOVE.B %0,%c\n\tAND.L #$FF,%0\n */ + /* 111 */ 1, /* \tMOVE.W %0,%c\n\tEXT.L %c\n */ + /* 112 */ 1, /* \tMOVE.W %0,%c\n\tAND.L #$FFFF,%0\n */ + /* 113 */ 1, /* \tMOVE.B %0,%c\n\tEXT.W %c\n\tEXT.L %c\n */ + /* 114 */ 1, /* \tMOVE.B %0,%c\n\tANDI.L #$ff,%c\n */ + /* 115 */ 1, /* \tMOVE.W %0,%c\n\tEXT.L %c\n */ + /* 116 */ 1, /* \tMOVE.W %0,%c\n\tANDI.L #$ffff,%c\n */ + /* 117 */ 0, /* %0 */ + /* 118 */ 0, /* %0 */ + /* 119 */ 0, /* %0 */ + /* 120 */ 0, /* %0 */ + /* 121 */ 1, /* \tMOVE.L %0,%c\n */ + /* 122 */ 1, /* \tMOVE.L %0,%c\n */ + /* 123 */ 1, /* \tMOVE.L %0,%c\n */ + /* 124 */ 1, /* \tMOVE.L %0,%c\n */ + /* 125 */ 1, /* \tMOVE.L %0,%c\n */ + /* 126 */ 1, /* \tMOVE.L %0,%c\n */ + /* 127 */ 1, /* \tMOVE.L %0,%c\n */ + /* 128 */ 1, /* \tMOVE.L %0,%c\n */ + /* 129 */ 0, /* %0 */ + /* 130 */ 0, /* %0 */ + /* 131 */ 1, /* \tFMOVE.D %0,%c\n */ + /* 132 */ 1, /* \tFMOVE.D %0,%c\n */ + /* 133 */ 1, /* \tFMOVE.L %0,%c\n */ + /* 134 */ 1, /* \tFMOVE.L %0,%c\n */ + /* 135 */ 1, /* \tMOVE.B %1,%0\n */ + /* 136 */ 1, /* \tCLR.L %0\n */ + /* 137 */ 1, /* \tMOVE.L %1,%0\n */ + /* 138 */ 1, /* \tCLR.L %0\n */ + /* 139 */ 1, /* \tFMOVE.L %1,%0\n */ + /* 140 */ 1, /* \tMOVE.L %1,%0\n */ + /* 141 */ 1, /* \tCLR.L %0\n */ + /* 142 */ 1, /* \tMOVE.W %1,%0\n */ + /* 143 */ 1, /* \tCLR.W %0\n */ + /* 144 */ 1, /* \tMOVE.L %0,-(SP)\n */ + /* 145 */ 1, /* \tPEA.L %0\n */ + /* 146 */ 1, /* \tMOVE.L %0,-(SP)\n */ + /* 147 */ 1, /* \tPEA.L %0\n */ + /* 148 */ 1, /* # MOVE (src)+,(dst)+\n */ + /* 149 */ 1, /* # Copy to stack\n */ + /* 150 */ 1, /* \tFMOVE.D %0,%c\n */ + /* 151 */ 1, /* \tFMOVE.D %0,%c\n */ + /* 152 */ 1, /* \tFMOVE.D %0,%c\n */ + /* 153 */ 1, /* \tFMOVE.S %0,%c\n */ + /* 154 */ 0, /* %0 */ + /* 155 */ 0, /* %0 */ + /* 156 */ 1, /* \tFMOVE.D %1,%0\n */ + /* 157 */ 1, /* \tLEA.L %1,A0\n\tLEA.L %0,A1\n\tMOVE.L (A0)+,(A1)+\n\tMOVE.L (A0),(A1)\n */ + /* 158 */ 1, /* \tFMOVE.S %1,%0\n */ + /* 159 */ 1, /* \tMOVE.L %1,%0\n */ + /* 160 */ 1, /* \tFMOVE.D %0,-(SP)\n */ + /* 161 */ 1, /* \tFMOVE.D %0,-(SP)\n */ + /* 162 */ 1, /* ?\tFMOVE.D %0,%c\n\tFADD.D %1,%c\n */ + /* 163 */ 1, /* ?\tFMOVE.D %0,%c\n\tFADD.D %1,%c\n */ + /* 164 */ 1, /* ?\tFMOVE.D %0,%c\n\tFSUB.D %1,%c\n */ + /* 165 */ 1, /* ?\tFMOVE.D %0,%c\n\tFSUB.D %1,%c\n */ + /* 166 */ 1, /* ?\tFMOVE.D %0,%c\n\tFMUL.D %1,%c\n */ + /* 167 */ 1, /* ?\tFMOVE.D %0,%c\n\tFMUL.D %1,%c\n */ + /* 168 */ 1, /* ?\tFMOVE.D %0,%c\n\tFDIV.D %1,%c\n */ + /* 169 */ 1, /* ?\tFMOVE.D %0,%c\n\tFDIV.D %1,%c\n */ + /* 170 */ 1, /* \tFNEG.D %c\n */ + /* 171 */ 1, /* \tFNEG.D %c\n */ + /* 172 */ 1, /* \tBRA.L %0\n */ + /* 173 */ 1, /* \tJMP 0(%0)\n */ + /* 174 */ 1, /* %a:\n */ + /* 175 */ 1, /* \tTST.L %0\n\tBEQ.L %a\n */ + /* 176 */ 1, /* \tTST.L %0\n\tBNE.L %a\n */ + /* 177 */ 1, /* \tCMP.L %1,%0\n\tBEQ.L %a\n */ + /* 178 */ 1, /* \tCMP.L %1,%0\n\tBGE.L %a\n */ + /* 179 */ 1, /* \tCMP.L %1,%0\n\tBGT.L %a\n */ + /* 180 */ 1, /* \tCMP.L %1,%0\n\tBLE.L %a\n */ + /* 181 */ 1, /* \tCMP.L %1,%0\n\tBLT.L %a\n */ + /* 182 */ 1, /* \tCMP.L %1,%0\n\tBNE.L %a\n */ + /* 183 */ 1, /* \tCMP.L %1,%0\n\tBHS.L %a\n */ + /* 184 */ 1, /* \tCMP.L %1,%0\n\tBHI.L %a\n */ + /* 185 */ 1, /* \tCMP.L %1,%0\n\tBLS.L %a\n */ + /* 186 */ 1, /* \tCMP.L %1,%0\n\tBLO.L %a\n */ + /* 187 */ 1, /* \tFCMP.D %1,%0\n\tFBEQ.W %a\n */ + /* 188 */ 1, /* \tFCMP.D %1,%0\n\tFBGE.W %a\n */ + /* 189 */ 1, /* \tFCMP.D %1,%0\n\tFBGT.W %a\n */ + /* 190 */ 1, /* \tFCMP.D %1,%0\n\tFBLE.W %a\n */ + /* 191 */ 1, /* \tFCMP.D %1,%0\n\tFBLT.W %a\n */ + /* 192 */ 1, /* \tFCMP.D %1,%0\n\tFBNE.W %a\n */ + /* 193 */ 1, /* \tFCMP.D %1,%0\n\tFBEQ.W %a\n */ + /* 194 */ 1, /* \tFCMP.D %1,%0\n\tFBGE.W %a\n */ + /* 195 */ 1, /* \tFCMP.D %1,%0\n\tFBGT.W %a\n */ + /* 196 */ 1, /* \tFCMP.D %1,%0\n\tFBLE.W %a\n */ + /* 197 */ 1, /* \tFCMP.D %1,%0\n\tFBLT.W %a\n */ + /* 198 */ 1, /* \tFCMP.D %1,%0\n\tFBNE.W %a\n */ + /* 199 */ 1, /* \tJSR %0\n\tADDA.L %#%a,SP\n */ + /* 200 */ 1, /* \tJSR %0\n\tADDA.L %#%a,SP\n */ + /* 201 */ 1, /* \tJSR %0\n\tADDA.L %#%a,SP\n */ + /* 202 */ 1, /* \tJSR %0\n\tADDA.L %#%a,SP\n */ + /* 203 */ 1, /* # RTS\n */ + /* 204 */ 1, /* # RTS\n */ + /* 205 */ 1, /* # RTS\n */ + }; + + static char *_string[] = { + /* 0 */ 0, + /* 1 */ "reg: INDIRC(VREGP)", + /* 2 */ "reg: INDIRD(VREGP)", + /* 3 */ "reg: INDIRF(VREGP)", + /* 4 */ "reg: INDIRI(VREGP)", + /* 5 */ "reg: INDIRP(VREGP)", + /* 6 */ "reg: INDIRS(VREGP)", + /* 7 */ "stmt: ASGNC(VREGP,reg)", + /* 8 */ "stmt: ASGND(VREGP,reg)", + /* 9 */ "stmt: ASGNF(VREGP,reg)", + /* 10 */ "stmt: ASGNI(VREGP,reg)", + /* 11 */ "stmt: ASGND(VREGP,reg)", + /* 12 */ "stmt: ASGNP(VREGP,reg)", + /* 13 */ "stmt: ASGNS(VREGP,reg)", + /* 14 */ "con: CNSTC", + /* 15 */ "con: CNSTI", + /* 16 */ "con: CNSTP", + /* 17 */ "con: CNSTS", + /* 18 */ "con: CNSTU", + /* 19 */ "stmt: reg", + /* 20 */ "reg: CVIU(reg)", + /* 21 */ "reg: CVUI(reg)", + /* 22 */ "disp16: CNSTI", + /* 23 */ "disp8: CNSTI", + /* 24 */ "base: ADDP(reg,disp16)", + /* 25 */ "base: ADDRFP", + /* 26 */ "base: ADDRLP", + /* 27 */ "base: basei", + /* 28 */ "basei: reg", + /* 29 */ "basei: ADDP(reg,disp8)", + /* 30 */ "basei: ADDRFP", + /* 31 */ "basei: ADDRLP", + /* 32 */ "basei: ADDRFP", + /* 33 */ "basei: ADDRLP", + /* 34 */ "addr: ADDRGP", + /* 35 */ "acon: ADDRGP", + /* 36 */ "table: ADDRGP", + /* 37 */ "index: reg", + /* 38 */ "index: LSHI(reg,scf)", + /* 39 */ "addr: base", + /* 40 */ "addr: ADDP(index,basei)", + /* 41 */ "case: ADDP(index,table)", + /* 42 */ "avar: acon", + /* 43 */ "avar: reg", + /* 44 */ "avar: addr", + /* 45 */ "con0: CNSTI", + /* 46 */ "con0: CNSTP", + /* 47 */ "con0: CNSTU", + /* 48 */ "con3: CNSTI", + /* 49 */ "con3: CNSTP", + /* 50 */ "scf: CNSTI", + /* 51 */ "scf: CNSTI", + /* 52 */ "scf: CNSTI", + /* 53 */ "mem: INDIRI(addr)", + /* 54 */ "mem: INDIRP(addr)", + /* 55 */ "pcrel: INDIRP(case)", + /* 56 */ "ri: reg", + /* 57 */ "ri: con", + /* 58 */ "ri3: con3", + /* 59 */ "ri3: reg", + /* 60 */ "ea0: mem", + /* 61 */ "ea0: ri", + /* 62 */ "ea1: mem", + /* 63 */ "ea1: ri", + /* 64 */ "ea3: mem", + /* 65 */ "ea3: ri", + /* 66 */ "reg: addr", + /* 67 */ "reg: ri", + /* 68 */ "reg: INDIRC(addr)", + /* 69 */ "reg: INDIRI(addr)", + /* 70 */ "reg: INDIRP(addr)", + /* 71 */ "reg: INDIRS(addr)", + /* 72 */ "reg: LOADC(reg)", + /* 73 */ "reg: LOADI(reg)", + /* 74 */ "reg: LOADP(reg)", + /* 75 */ "reg: LOADS(reg)", + /* 76 */ "reg: LOADU(reg)", + /* 77 */ "reg: ADDI(reg,con3)", + /* 78 */ "reg: SUBI(reg,con3)", + /* 79 */ "reg: ADDI(reg,ea1)", + /* 80 */ "reg: ADDP(reg,ea1)", + /* 81 */ "reg: ADDU(reg,ea1)", + /* 82 */ "reg: SUBI(reg,ea1)", + /* 83 */ "reg: SUBP(reg,ea1)", + /* 84 */ "reg: SUBU(reg,ea1)", + /* 85 */ "stmt: ASGNI(addr,ADDI(mem,ri))", + /* 86 */ "stmt: ASGNI(addr,ADDU(mem,ri))", + /* 87 */ "stmt: ASGNI(addr,SUBI(mem,ri))", + /* 88 */ "stmt: ASGNI(addr,SUBU(mem,ri))", + /* 89 */ "reg: BANDU(reg,ea1)", + /* 90 */ "reg: BORU(reg,ea1)", + /* 91 */ "reg: BXORU(reg,reg)", + /* 92 */ "stmt: ASGNI(addr,BANDU(mem,ri))", + /* 93 */ "stmt: ASGNI(addr,BORU(mem,ri))", + /* 94 */ "stmt: ASGNI(addr,BXORU(mem,reg))", + /* 95 */ "reg: BCOMU(reg)", + /* 96 */ "reg: NEGI(reg)", + /* 97 */ "stmt: ASGNI(addr,BCOMU(mem))", + /* 98 */ "stmt: ASGNI(addr,NEGI(mem))", + /* 99 */ "reg: LSHI(reg,ri3)", + /* 100 */ "reg: LSHU(reg,ri3)", + /* 101 */ "reg: RSHI(reg,ri3)", + /* 102 */ "reg: RSHU(reg,ri3)", + /* 103 */ "reg: MULI(reg,ea3)", + /* 104 */ "reg: MULU(reg,ea3)", + /* 105 */ "reg: DIVU(reg,ea3)", + /* 106 */ "reg: DIVI(reg,ea3)", + /* 107 */ "reg: MODU(reg,ea3)", + /* 108 */ "reg: MODI(reg,reg)", + /* 109 */ "reg: CVCI(reg)", + /* 110 */ "reg: CVCU(reg)", + /* 111 */ "reg: CVSI(reg)", + /* 112 */ "reg: CVSU(reg)", + /* 113 */ "reg: CVCI(INDIRC(addr))", + /* 114 */ "reg: CVCU(INDIRC(addr))", + /* 115 */ "reg: CVSI(INDIRS(addr))", + /* 116 */ "reg: CVSU(INDIRS(addr))", + /* 117 */ "reg: CVIC(reg)", + /* 118 */ "reg: CVIS(reg)", + /* 119 */ "reg: CVUC(reg)", + /* 120 */ "reg: CVUS(reg)", + /* 121 */ "reg: CVIC(reg)", + /* 122 */ "reg: CVIS(reg)", + /* 123 */ "reg: CVIU(reg)", + /* 124 */ "reg: CVPU(reg)", + /* 125 */ "reg: CVUC(reg)", + /* 126 */ "reg: CVUI(reg)", + /* 127 */ "reg: CVUP(reg)", + /* 128 */ "reg: CVUS(reg)", + /* 129 */ "reg: CVDF(reg)", + /* 130 */ "reg: CVFD(reg)", + /* 131 */ "reg: CVDF(reg)", + /* 132 */ "reg: CVFD(reg)", + /* 133 */ "reg: CVID(ea0)", + /* 134 */ "reg: CVDI(reg)", + /* 135 */ "stmt: ASGNC(addr,ea1)", + /* 136 */ "stmt: ASGNC(addr,con0)", + /* 137 */ "stmt: ASGNI(addr,ea1)", + /* 138 */ "stmt: ASGNI(addr,con0)", + /* 139 */ "stmt: ASGNI(addr,CVDI(reg))", + /* 140 */ "stmt: ASGNP(addr,ea1)", + /* 141 */ "stmt: ASGNP(addr,con0)", + /* 142 */ "stmt: ASGNS(addr,ea1)", + /* 143 */ "stmt: ASGNS(addr,con0)", + /* 144 */ "stmt: ARGI(ea0)", + /* 145 */ "stmt: ARGI(addr)", + /* 146 */ "stmt: ARGP(ea0)", + /* 147 */ "stmt: ARGP(addr)", + /* 148 */ "stmt: ASGNB(reg,INDIRB(reg))", + /* 149 */ "stmt: ARGB(INDIRB(reg))", + /* 150 */ "reg: LOADD(reg)", + /* 151 */ "reg: LOADF(reg)", + /* 152 */ "reg: INDIRD(addr)", + /* 153 */ "reg: INDIRF(addr)", + /* 154 */ "mem: INDIRD(addr)", + /* 155 */ "mem: INDIRF(addr)", + /* 156 */ "stmt: ASGND(addr,reg)", + /* 157 */ "stmt: ASGND(addr,mem)", + /* 158 */ "stmt: ASGNF(addr,reg)", + /* 159 */ "stmt: ASGNF(addr,mem)", + /* 160 */ "stmt: ARGD(reg)", + /* 161 */ "stmt: ARGF(reg)", + /* 162 */ "reg: ADDD(reg,reg)", + /* 163 */ "reg: ADDF(reg,reg)", + /* 164 */ "reg: SUBD(reg,reg)", + /* 165 */ "reg: SUBF(reg,reg)", + /* 166 */ "reg: MULD(reg,reg)", + /* 167 */ "reg: MULF(reg,reg)", + /* 168 */ "reg: DIVD(reg,reg)", + /* 169 */ "reg: DIVF(reg,reg)", + /* 170 */ "reg: NEGD(reg)", + /* 171 */ "reg: NEGF(reg)", + /* 172 */ "stmt: JUMPV(acon)", + /* 173 */ "stmt: JUMPV(pcrel)", + /* 174 */ "stmt: LABELV", + /* 175 */ "stmt: EQI(ea0,con0)", + /* 176 */ "stmt: NEI(ea0,con0)", + /* 177 */ "stmt: EQI(reg,ea1)", + /* 178 */ "stmt: GEI(reg,ea1)", + /* 179 */ "stmt: GTI(reg,ea1)", + /* 180 */ "stmt: LEI(reg,ea1)", + /* 181 */ "stmt: LTI(reg,ea1)", + /* 182 */ "stmt: NEI(reg,ea1)", + /* 183 */ "stmt: GEU(reg,ea1)", + /* 184 */ "stmt: GTU(reg,ea1)", + /* 185 */ "stmt: LEU(reg,ea1)", + /* 186 */ "stmt: LTU(reg,ea1)", + /* 187 */ "stmt: EQD(reg,reg)", + /* 188 */ "stmt: GED(reg,reg)", + /* 189 */ "stmt: GTD(reg,reg)", + /* 190 */ "stmt: LED(reg,reg)", + /* 191 */ "stmt: LTD(reg,reg)", + /* 192 */ "stmt: NED(reg,reg)", + /* 193 */ "stmt: EQF(reg,reg)", + /* 194 */ "stmt: GEF(reg,reg)", + /* 195 */ "stmt: GTF(reg,reg)", + /* 196 */ "stmt: LEF(reg,reg)", + /* 197 */ "stmt: LTF(reg,reg)", + /* 198 */ "stmt: NEF(reg,reg)", + /* 199 */ "reg: CALLI(avar)", + /* 200 */ "stmt: CALLV(avar)", + /* 201 */ "reg: CALLF(avar)", + /* 202 */ "reg: CALLD(avar)", + /* 203 */ "stmt: RETI(reg)", + /* 204 */ "stmt: RETF(reg)", + /* 205 */ "stmt: RETD(reg)", + }; + + static short _decode_stmt[] = { + 0, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 19, + 85, + 86, + 87, + 88, + 92, + 93, + 94, + 97, + 98, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 156, + 157, + 158, + 159, + 160, + 161, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 200, + 203, + 204, + 205, + }; + + static short _decode_reg[] = { + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 20, + 21, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 89, + 90, + 91, + 95, + 96, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 150, + 151, + 152, + 153, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 199, + 201, + 202, + }; + + static short _decode_con[] = { + 0, + 14, + 15, + 16, + 17, + 18, + }; + + static short _decode_disp16[] = { + 0, + 22, + }; + + static short _decode_disp8[] = { + 0, + 23, + }; + + static short _decode_base[] = { + 0, + 24, + 25, + 26, + 27, + }; + + static short _decode_basei[] = { + 0, + 28, + 29, + 30, + 31, + 32, + 33, + }; + + static short _decode_addr[] = { + 0, + 34, + 39, + 40, + }; + + static short _decode_acon[] = { + 0, + 35, + }; + + static short _decode_table[] = { + 0, + 36, + }; + + static short _decode_index[] = { + 0, + 37, + 38, + }; + + static short _decode_scf[] = { + 0, + 50, + 51, + 52, + }; + + static short _decode_case[] = { + 0, + 41, + }; + + static short _decode_avar[] = { + 0, + 42, + 43, + 44, + }; + + static short _decode_con0[] = { + 0, + 45, + 46, + 47, + }; + + static short _decode_con3[] = { + 0, + 48, + 49, + }; + + static short _decode_mem[] = { + 0, + 53, + 54, + 154, + 155, + }; + + static short _decode_pcrel[] = { + 0, + 55, + }; + + static short _decode_ri[] = { + 0, + 56, + 57, + }; + + static short _decode_ri3[] = { + 0, + 58, + 59, + }; + + static short _decode_ea0[] = { + 0, + 60, + 61, + }; + + static short _decode_ea1[] = { + 0, + 62, + 63, + }; + + static short _decode_ea3[] = { + 0, + 64, + 65, + }; + + static int _rule(state, goalnt) void *state; int goalnt; { + if (goalnt < 1 || goalnt > 23) + fatal("_rule", "Bad goal nonterminal %d\n", goalnt); + if (!state) + return 0; + switch (goalnt) { + case _stmt_NT: return _decode_stmt[((struct _state *)state)->rule._stmt]; + case _reg_NT: return _decode_reg[((struct _state *)state)->rule._reg]; + case _con_NT: return _decode_con[((struct _state *)state)->rule._con]; + case _disp16_NT: return _decode_disp16[((struct _state *)state)->rule._disp16]; + case _disp8_NT: return _decode_disp8[((struct _state *)state)->rule._disp8]; + case _base_NT: return _decode_base[((struct _state *)state)->rule._base]; + case _basei_NT: return _decode_basei[((struct _state *)state)->rule._basei]; + case _addr_NT: return _decode_addr[((struct _state *)state)->rule._addr]; + case _acon_NT: return _decode_acon[((struct _state *)state)->rule._acon]; + case _table_NT: return _decode_table[((struct _state *)state)->rule._table]; + case _index_NT: return _decode_index[((struct _state *)state)->rule._index]; + case _scf_NT: return _decode_scf[((struct _state *)state)->rule._scf]; + case _case_NT: return _decode_case[((struct _state *)state)->rule._case]; + case _avar_NT: return _decode_avar[((struct _state *)state)->rule._avar]; + case _con0_NT: return _decode_con0[((struct _state *)state)->rule._con0]; + case _con3_NT: return _decode_con3[((struct _state *)state)->rule._con3]; + case _mem_NT: return _decode_mem[((struct _state *)state)->rule._mem]; + case _pcrel_NT: return _decode_pcrel[((struct _state *)state)->rule._pcrel]; + case _ri_NT: return _decode_ri[((struct _state *)state)->rule._ri]; + case _ri3_NT: return _decode_ri3[((struct _state *)state)->rule._ri3]; + case _ea0_NT: return _decode_ea0[((struct _state *)state)->rule._ea0]; + case _ea1_NT: return _decode_ea1[((struct _state *)state)->rule._ea1]; + case _ea3_NT: return _decode_ea3[((struct _state *)state)->rule._ea3]; + default: + fatal("_rule", "Bad goal nonterminal %d\n", goalnt); + return 0; + } + } + + static void _closure_reg ARGS((NODEPTR_TYPE, int)); + static void _closure_con ARGS((NODEPTR_TYPE, int)); + static void _closure_base ARGS((NODEPTR_TYPE, int)); + static void _closure_basei ARGS((NODEPTR_TYPE, int)); + static void _closure_addr ARGS((NODEPTR_TYPE, int)); + static void _closure_acon ARGS((NODEPTR_TYPE, int)); + static void _closure_con3 ARGS((NODEPTR_TYPE, int)); + static void _closure_mem ARGS((NODEPTR_TYPE, int)); + static void _closure_ri ARGS((NODEPTR_TYPE, int)); + + static void _closure_reg(a, c) NODEPTR_TYPE a; int c; { + struct _state *p = STATE_LABEL(a); + if (c + 0 < p->cost[_ri3_NT]) { + p->cost[_ri3_NT] = c + 0; + p->rule._ri3 = 2; + } + if (c + 0 < p->cost[_ri_NT]) { + p->cost[_ri_NT] = c + 0; + p->rule._ri = 1; + _closure_ri(a, c + 0); + } + if (c + 1 < p->cost[_avar_NT]) { + p->cost[_avar_NT] = c + 1; + p->rule._avar = 2; + } + if (c + 0 < p->cost[_index_NT]) { + p->cost[_index_NT] = c + 0; + p->rule._index = 1; + } + if (c + 0 < p->cost[_basei_NT]) { + p->cost[_basei_NT] = c + 0; + p->rule._basei = 1; + _closure_basei(a, c + 0); + } + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 8; + } + } + + static void _closure_con(a, c) NODEPTR_TYPE a; int c; { + struct _state *p = STATE_LABEL(a); + if (c + 0 < p->cost[_ri_NT]) { + p->cost[_ri_NT] = c + 0; + p->rule._ri = 2; + _closure_ri(a, c + 0); + } + } + + static void _closure_base(a, c) NODEPTR_TYPE a; int c; { + struct _state *p = STATE_LABEL(a); + if (c + 0 < p->cost[_addr_NT]) { + p->cost[_addr_NT] = c + 0; + p->rule._addr = 2; + _closure_addr(a, c + 0); + } + } + + static void _closure_basei(a, c) NODEPTR_TYPE a; int c; { + struct _state *p = STATE_LABEL(a); + if (c + 0 < p->cost[_base_NT]) { + p->cost[_base_NT] = c + 0; + p->rule._base = 4; + _closure_base(a, c + 0); + } + } + + static void _closure_addr(a, c) NODEPTR_TYPE a; int c; { + struct _state *p = STATE_LABEL(a); + if (c + 1 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 1; + p->rule._reg = 9; + _closure_reg(a, c + 1); + } + if (c + 2 < p->cost[_avar_NT]) { + p->cost[_avar_NT] = c + 2; + p->rule._avar = 3; + } + } + + static void _closure_acon(a, c) NODEPTR_TYPE a; int c; { + struct _state *p = STATE_LABEL(a); + if (c + 0 < p->cost[_avar_NT]) { + p->cost[_avar_NT] = c + 0; + p->rule._avar = 1; + } + } + + static void _closure_con3(a, c) NODEPTR_TYPE a; int c; { + struct _state *p = STATE_LABEL(a); + if (c + 0 < p->cost[_ri3_NT]) { + p->cost[_ri3_NT] = c + 0; + p->rule._ri3 = 1; + } + } + + static void _closure_mem(a, c) NODEPTR_TYPE a; int c; { + struct _state *p = STATE_LABEL(a); + if (c + 3 < p->cost[_ea3_NT]) { + p->cost[_ea3_NT] = c + 3; + p->rule._ea3 = 1; + } + if (c + 1 < p->cost[_ea1_NT]) { + p->cost[_ea1_NT] = c + 1; + p->rule._ea1 = 1; + } + if (c + 0 < p->cost[_ea0_NT]) { + p->cost[_ea0_NT] = c + 0; + p->rule._ea0 = 1; + } + } + + static void _closure_ri(a, c) NODEPTR_TYPE a; int c; { + struct _state *p = STATE_LABEL(a); + if (c + 1 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 1; + p->rule._reg = 10; + _closure_reg(a, c + 1); + } + if (c + 0 < p->cost[_ea3_NT]) { + p->cost[_ea3_NT] = c + 0; + p->rule._ea3 = 2; + } + if (c + 0 < p->cost[_ea1_NT]) { + p->cost[_ea1_NT] = c + 0; + p->rule._ea1 = 2; + } + if (c + 0 < p->cost[_ea0_NT]) { + p->cost[_ea0_NT] = c + 0; + p->rule._ea0 = 2; + } + } + + static void _label(a) NODEPTR_TYPE a; { + int c; + struct _state *p; + + if (!a) + fatal("_label", "Null tree\n", 0); + STATE_LABEL(a) = p = allocate(sizeof *p, FUNC); + p->rule._stmt = 0; + p->cost[1] = + p->cost[2] = + p->cost[3] = + p->cost[4] = + p->cost[5] = + p->cost[6] = + p->cost[7] = + p->cost[8] = + p->cost[9] = + p->cost[10] = + p->cost[11] = + p->cost[12] = + p->cost[13] = + p->cost[14] = + p->cost[15] = + p->cost[16] = + p->cost[17] = + p->cost[18] = + p->cost[19] = + p->cost[20] = + p->cost[21] = + p->cost[22] = + p->cost[23] = + 0x7fff; + switch (OP_LABEL(a)) { + case 17: /* CNSTF */ + break; + case 18: /* CNSTD */ + break; + case 19: /* CNSTC */ + /* con: CNSTC */ + if (0 + 0 < p->cost[_con_NT]) { + p->cost[_con_NT] = 0 + 0; + p->rule._con = 1; + _closure_con(a, 0 + 0); + } + break; + case 20: /* CNSTS */ + /* con: CNSTS */ + if (0 + 0 < p->cost[_con_NT]) { + p->cost[_con_NT] = 0 + 0; + p->rule._con = 4; + _closure_con(a, 0 + 0); + } + break; + case 21: /* CNSTI */ + /* con: CNSTI */ + if (0 + 0 < p->cost[_con_NT]) { + p->cost[_con_NT] = 0 + 0; + p->rule._con = 2; + _closure_con(a, 0 + 0); + } + /* disp16: CNSTI */ + c = (range(a, -32768, 32767)); + if (c + 0 < p->cost[_disp16_NT]) { + p->cost[_disp16_NT] = c + 0; + p->rule._disp16 = 1; + } + /* disp8: CNSTI */ + c = (range(a, -128, 127)); + if (c + 0 < p->cost[_disp8_NT]) { + p->cost[_disp8_NT] = c + 0; + p->rule._disp8 = 1; + } + /* con0: CNSTI */ + c = (range(a, 0, 0)); + if (c + 0 < p->cost[_con0_NT]) { + p->cost[_con0_NT] = c + 0; + p->rule._con0 = 1; + } + /* con3: CNSTI */ + c = (range(a, 1, 8)); + if (c + 0 < p->cost[_con3_NT]) { + p->cost[_con3_NT] = c + 0; + p->rule._con3 = 1; + _closure_con3(a, c + 0); + } + /* scf: CNSTI */ + c = (range(a, 1, 1)); + if (c + 0 < p->cost[_scf_NT]) { + p->cost[_scf_NT] = c + 0; + p->rule._scf = 1; + } + /* scf: CNSTI */ + c = (range(a, 2, 2)); + if (c + 0 < p->cost[_scf_NT]) { + p->cost[_scf_NT] = c + 0; + p->rule._scf = 2; + } + /* scf: CNSTI */ + c = (range(a, 3, 3)); + if (c + 0 < p->cost[_scf_NT]) { + p->cost[_scf_NT] = c + 0; + p->rule._scf = 3; + } + break; + case 22: /* CNSTU */ + /* con: CNSTU */ + if (0 + 0 < p->cost[_con_NT]) { + p->cost[_con_NT] = 0 + 0; + p->rule._con = 5; + _closure_con(a, 0 + 0); + } + /* con0: CNSTU */ + c = (range(a, 0, 0)); + if (c + 0 < p->cost[_con0_NT]) { + p->cost[_con0_NT] = c + 0; + p->rule._con0 = 3; + } + break; + case 23: /* CNSTP */ + /* con: CNSTP */ + if (0 + 0 < p->cost[_con_NT]) { + p->cost[_con_NT] = 0 + 0; + p->rule._con = 3; + _closure_con(a, 0 + 0); + } + /* con0: CNSTP */ + c = (range(a, 0, 0)); + if (c + 0 < p->cost[_con0_NT]) { + p->cost[_con0_NT] = c + 0; + p->rule._con0 = 2; + } + /* con3: CNSTP */ + c = (range(a, 1, 8)); + if (c + 0 < p->cost[_con3_NT]) { + p->cost[_con3_NT] = c + 0; + p->rule._con3 = 2; + _closure_con3(a, c + 0); + } + break; + case 33: /* ARGF */ + _label(LEFT_CHILD(a)); + /* stmt: ARGF(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 3; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 38; + } + break; + case 34: /* ARGD */ + _label(LEFT_CHILD(a)); + /* stmt: ARGD(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 3; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 37; + } + break; + case 37: /* ARGI */ + _label(LEFT_CHILD(a)); + /* stmt: ARGI(ea0) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_ea0_NT] + 1; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 27; + } + /* stmt: ARGI(addr) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 1; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 28; + } + break; + case 39: /* ARGP */ + _label(LEFT_CHILD(a)); + /* stmt: ARGP(ea0) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_ea0_NT] + 1; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 29; + } + /* stmt: ARGP(addr) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 1; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 30; + } + break; + case 41: /* ARGB */ + _label(LEFT_CHILD(a)); + if ( /* stmt: ARGB(INDIRB(reg)) */ + LEFT_CHILD(a)->op == 73 /* INDIRB */ + ) { + c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + 2; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 32; + } + } + break; + case 49: /* ASGNF */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + if ( /* stmt: ASGNF(VREGP,reg) */ + LEFT_CHILD(a)->op == 615 /* VREGP */ + ) { + c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 3; + } + } + /* stmt: ASGNF(addr,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 4; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 35; + } + /* stmt: ASGNF(addr,mem) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mem_NT] + 1; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 36; + } + break; + case 50: /* ASGND */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + if ( /* stmt: ASGND(VREGP,reg) */ + LEFT_CHILD(a)->op == 615 /* VREGP */ + ) { + c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 2; + } + } + if ( /* stmt: ASGND(VREGP,reg) */ + LEFT_CHILD(a)->op == 615 /* VREGP */ + ) { + c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 5; + } + } + /* stmt: ASGND(addr,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 4; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 33; + } + /* stmt: ASGND(addr,mem) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mem_NT] + 3; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 34; + } + break; + case 51: /* ASGNC */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + if ( /* stmt: ASGNC(VREGP,reg) */ + LEFT_CHILD(a)->op == 615 /* VREGP */ + ) { + c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 1; + } + } + /* stmt: ASGNC(addr,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 1; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 18; + } + /* stmt: ASGNC(addr,con0) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con0_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 19; + } + break; + case 52: /* ASGNS */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + if ( /* stmt: ASGNS(VREGP,reg) */ + LEFT_CHILD(a)->op == 615 /* VREGP */ + ) { + c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 7; + } + } + /* stmt: ASGNS(addr,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 1; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 25; + } + /* stmt: ASGNS(addr,con0) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con0_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 26; + } + break; + case 53: /* ASGNI */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + if ( /* stmt: ASGNI(VREGP,reg) */ + LEFT_CHILD(a)->op == 615 /* VREGP */ + ) { + c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 4; + } + } + if ( /* stmt: ASGNI(addr,ADDI(mem,ri)) */ + RIGHT_CHILD(a)->op == 309 /* ADDI */ + ) { + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_ri_NT] + (memop(a)); + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 9; + } + } + if ( /* stmt: ASGNI(addr,ADDU(mem,ri)) */ + RIGHT_CHILD(a)->op == 310 /* ADDU */ + ) { + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_ri_NT] + (memop(a)); + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 10; + } + } + if ( /* stmt: ASGNI(addr,SUBI(mem,ri)) */ + RIGHT_CHILD(a)->op == 325 /* SUBI */ + ) { + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_ri_NT] + (memop(a)); + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 11; + } + } + if ( /* stmt: ASGNI(addr,SUBU(mem,ri)) */ + RIGHT_CHILD(a)->op == 326 /* SUBU */ + ) { + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_ri_NT] + (memop(a)); + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 12; + } + } + if ( /* stmt: ASGNI(addr,BANDU(mem,ri)) */ + RIGHT_CHILD(a)->op == 390 /* BANDU */ + ) { + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_ri_NT] + (memop(a)); + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 13; + } + } + if ( /* stmt: ASGNI(addr,BORU(mem,ri)) */ + RIGHT_CHILD(a)->op == 422 /* BORU */ + ) { + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_ri_NT] + (memop(a)); + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 14; + } + } + if ( /* stmt: ASGNI(addr,BXORU(mem,reg)) */ + RIGHT_CHILD(a)->op == 438 /* BXORU */ + ) { + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_reg_NT] + (memop(a)); + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 15; + } + } + if ( /* stmt: ASGNI(addr,BCOMU(mem)) */ + RIGHT_CHILD(a)->op == 406 /* BCOMU */ + ) { + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + (memop(a)); + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 16; + } + } + if ( /* stmt: ASGNI(addr,NEGI(mem)) */ + RIGHT_CHILD(a)->op == 197 /* NEGI */ + ) { + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + (memop(a)); + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 17; + } + } + /* stmt: ASGNI(addr,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 1; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 20; + } + /* stmt: ASGNI(addr,con0) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con0_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 21; + } + if ( /* stmt: ASGNI(addr,CVDI(reg)) */ + RIGHT_CHILD(a)->op == 101 /* CVDI */ + ) { + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 22; + } + } + break; + case 54: /* ASGNU */ + break; + case 55: /* ASGNP */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + if ( /* stmt: ASGNP(VREGP,reg) */ + LEFT_CHILD(a)->op == 615 /* VREGP */ + ) { + c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 6; + } + } + /* stmt: ASGNP(addr,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 1; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 23; + } + /* stmt: ASGNP(addr,con0) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con0_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 24; + } + break; + case 57: /* ASGNB */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + if ( /* stmt: ASGNB(reg,INDIRB(reg)) */ + RIGHT_CHILD(a)->op == 73 /* INDIRB */ + ) { + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_reg_NT] + 2; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 31; + } + } + break; + case 65: /* INDIRF */ + _label(LEFT_CHILD(a)); + if ( /* reg: INDIRF(VREGP) */ + LEFT_CHILD(a)->op == 615 /* VREGP */ + ) { + if (mayrecalc(a)) { + struct _state *q = a->syms[RX]->u.t.cse->x.state; + if (q->cost[_stmt_NT] == 0) { + p->cost[_stmt_NT] = 0; + p->rule._stmt = q->rule._stmt; + } + if (q->cost[_reg_NT] == 0) { + p->cost[_reg_NT] = 0; + p->rule._reg = q->rule._reg; + } + if (q->cost[_con_NT] == 0) { + p->cost[_con_NT] = 0; + p->rule._con = q->rule._con; + } + if (q->cost[_disp16_NT] == 0) { + p->cost[_disp16_NT] = 0; + p->rule._disp16 = q->rule._disp16; + } + if (q->cost[_disp8_NT] == 0) { + p->cost[_disp8_NT] = 0; + p->rule._disp8 = q->rule._disp8; + } + if (q->cost[_base_NT] == 0) { + p->cost[_base_NT] = 0; + p->rule._base = q->rule._base; + } + if (q->cost[_basei_NT] == 0) { + p->cost[_basei_NT] = 0; + p->rule._basei = q->rule._basei; + } + if (q->cost[_addr_NT] == 0) { + p->cost[_addr_NT] = 0; + p->rule._addr = q->rule._addr; + } + if (q->cost[_acon_NT] == 0) { + p->cost[_acon_NT] = 0; + p->rule._acon = q->rule._acon; + } + if (q->cost[_table_NT] == 0) { + p->cost[_table_NT] = 0; + p->rule._table = q->rule._table; + } + if (q->cost[_index_NT] == 0) { + p->cost[_index_NT] = 0; + p->rule._index = q->rule._index; + } + if (q->cost[_scf_NT] == 0) { + p->cost[_scf_NT] = 0; + p->rule._scf = q->rule._scf; + } + if (q->cost[_case_NT] == 0) { + p->cost[_case_NT] = 0; + p->rule._case = q->rule._case; + } + if (q->cost[_avar_NT] == 0) { + p->cost[_avar_NT] = 0; + p->rule._avar = q->rule._avar; + } + if (q->cost[_con0_NT] == 0) { + p->cost[_con0_NT] = 0; + p->rule._con0 = q->rule._con0; + } + if (q->cost[_con3_NT] == 0) { + p->cost[_con3_NT] = 0; + p->rule._con3 = q->rule._con3; + } + if (q->cost[_mem_NT] == 0) { + p->cost[_mem_NT] = 0; + p->rule._mem = q->rule._mem; + } + if (q->cost[_pcrel_NT] == 0) { + p->cost[_pcrel_NT] = 0; + p->rule._pcrel = q->rule._pcrel; + } + if (q->cost[_ri_NT] == 0) { + p->cost[_ri_NT] = 0; + p->rule._ri = q->rule._ri; + } + if (q->cost[_ri3_NT] == 0) { + p->cost[_ri3_NT] = 0; + p->rule._ri3 = q->rule._ri3; + } + if (q->cost[_ea0_NT] == 0) { + p->cost[_ea0_NT] = 0; + p->rule._ea0 = q->rule._ea0; + } + if (q->cost[_ea1_NT] == 0) { + p->cost[_ea1_NT] = 0; + p->rule._ea1 = q->rule._ea1; + } + if (q->cost[_ea3_NT] == 0) { + p->cost[_ea3_NT] = 0; + p->rule._ea3 = q->rule._ea3; + } + } + c = 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 3; + _closure_reg(a, c + 0); + } + } + /* reg: INDIRF(addr) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 3; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 72; + _closure_reg(a, c + 0); + } + /* mem: INDIRF(addr) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 0; + if (c + 0 < p->cost[_mem_NT]) { + p->cost[_mem_NT] = c + 0; + p->rule._mem = 4; + _closure_mem(a, c + 0); + } + break; + case 66: /* INDIRD */ + _label(LEFT_CHILD(a)); + if ( /* reg: INDIRD(VREGP) */ + LEFT_CHILD(a)->op == 615 /* VREGP */ + ) { + if (mayrecalc(a)) { + struct _state *q = a->syms[RX]->u.t.cse->x.state; + if (q->cost[_stmt_NT] == 0) { + p->cost[_stmt_NT] = 0; + p->rule._stmt = q->rule._stmt; + } + if (q->cost[_reg_NT] == 0) { + p->cost[_reg_NT] = 0; + p->rule._reg = q->rule._reg; + } + if (q->cost[_con_NT] == 0) { + p->cost[_con_NT] = 0; + p->rule._con = q->rule._con; + } + if (q->cost[_disp16_NT] == 0) { + p->cost[_disp16_NT] = 0; + p->rule._disp16 = q->rule._disp16; + } + if (q->cost[_disp8_NT] == 0) { + p->cost[_disp8_NT] = 0; + p->rule._disp8 = q->rule._disp8; + } + if (q->cost[_base_NT] == 0) { + p->cost[_base_NT] = 0; + p->rule._base = q->rule._base; + } + if (q->cost[_basei_NT] == 0) { + p->cost[_basei_NT] = 0; + p->rule._basei = q->rule._basei; + } + if (q->cost[_addr_NT] == 0) { + p->cost[_addr_NT] = 0; + p->rule._addr = q->rule._addr; + } + if (q->cost[_acon_NT] == 0) { + p->cost[_acon_NT] = 0; + p->rule._acon = q->rule._acon; + } + if (q->cost[_table_NT] == 0) { + p->cost[_table_NT] = 0; + p->rule._table = q->rule._table; + } + if (q->cost[_index_NT] == 0) { + p->cost[_index_NT] = 0; + p->rule._index = q->rule._index; + } + if (q->cost[_scf_NT] == 0) { + p->cost[_scf_NT] = 0; + p->rule._scf = q->rule._scf; + } + if (q->cost[_case_NT] == 0) { + p->cost[_case_NT] = 0; + p->rule._case = q->rule._case; + } + if (q->cost[_avar_NT] == 0) { + p->cost[_avar_NT] = 0; + p->rule._avar = q->rule._avar; + } + if (q->cost[_con0_NT] == 0) { + p->cost[_con0_NT] = 0; + p->rule._con0 = q->rule._con0; + } + if (q->cost[_con3_NT] == 0) { + p->cost[_con3_NT] = 0; + p->rule._con3 = q->rule._con3; + } + if (q->cost[_mem_NT] == 0) { + p->cost[_mem_NT] = 0; + p->rule._mem = q->rule._mem; + } + if (q->cost[_pcrel_NT] == 0) { + p->cost[_pcrel_NT] = 0; + p->rule._pcrel = q->rule._pcrel; + } + if (q->cost[_ri_NT] == 0) { + p->cost[_ri_NT] = 0; + p->rule._ri = q->rule._ri; + } + if (q->cost[_ri3_NT] == 0) { + p->cost[_ri3_NT] = 0; + p->rule._ri3 = q->rule._ri3; + } + if (q->cost[_ea0_NT] == 0) { + p->cost[_ea0_NT] = 0; + p->rule._ea0 = q->rule._ea0; + } + if (q->cost[_ea1_NT] == 0) { + p->cost[_ea1_NT] = 0; + p->rule._ea1 = q->rule._ea1; + } + if (q->cost[_ea3_NT] == 0) { + p->cost[_ea3_NT] = 0; + p->rule._ea3 = q->rule._ea3; + } + } + c = 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 2; + _closure_reg(a, c + 0); + } + } + /* reg: INDIRD(addr) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 3; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 71; + _closure_reg(a, c + 0); + } + /* mem: INDIRD(addr) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 0; + if (c + 0 < p->cost[_mem_NT]) { + p->cost[_mem_NT] = c + 0; + p->rule._mem = 3; + _closure_mem(a, c + 0); + } + break; + case 67: /* INDIRC */ + _label(LEFT_CHILD(a)); + if ( /* reg: INDIRC(VREGP) */ + LEFT_CHILD(a)->op == 615 /* VREGP */ + ) { + if (mayrecalc(a)) { + struct _state *q = a->syms[RX]->u.t.cse->x.state; + if (q->cost[_stmt_NT] == 0) { + p->cost[_stmt_NT] = 0; + p->rule._stmt = q->rule._stmt; + } + if (q->cost[_reg_NT] == 0) { + p->cost[_reg_NT] = 0; + p->rule._reg = q->rule._reg; + } + if (q->cost[_con_NT] == 0) { + p->cost[_con_NT] = 0; + p->rule._con = q->rule._con; + } + if (q->cost[_disp16_NT] == 0) { + p->cost[_disp16_NT] = 0; + p->rule._disp16 = q->rule._disp16; + } + if (q->cost[_disp8_NT] == 0) { + p->cost[_disp8_NT] = 0; + p->rule._disp8 = q->rule._disp8; + } + if (q->cost[_base_NT] == 0) { + p->cost[_base_NT] = 0; + p->rule._base = q->rule._base; + } + if (q->cost[_basei_NT] == 0) { + p->cost[_basei_NT] = 0; + p->rule._basei = q->rule._basei; + } + if (q->cost[_addr_NT] == 0) { + p->cost[_addr_NT] = 0; + p->rule._addr = q->rule._addr; + } + if (q->cost[_acon_NT] == 0) { + p->cost[_acon_NT] = 0; + p->rule._acon = q->rule._acon; + } + if (q->cost[_table_NT] == 0) { + p->cost[_table_NT] = 0; + p->rule._table = q->rule._table; + } + if (q->cost[_index_NT] == 0) { + p->cost[_index_NT] = 0; + p->rule._index = q->rule._index; + } + if (q->cost[_scf_NT] == 0) { + p->cost[_scf_NT] = 0; + p->rule._scf = q->rule._scf; + } + if (q->cost[_case_NT] == 0) { + p->cost[_case_NT] = 0; + p->rule._case = q->rule._case; + } + if (q->cost[_avar_NT] == 0) { + p->cost[_avar_NT] = 0; + p->rule._avar = q->rule._avar; + } + if (q->cost[_con0_NT] == 0) { + p->cost[_con0_NT] = 0; + p->rule._con0 = q->rule._con0; + } + if (q->cost[_con3_NT] == 0) { + p->cost[_con3_NT] = 0; + p->rule._con3 = q->rule._con3; + } + if (q->cost[_mem_NT] == 0) { + p->cost[_mem_NT] = 0; + p->rule._mem = q->rule._mem; + } + if (q->cost[_pcrel_NT] == 0) { + p->cost[_pcrel_NT] = 0; + p->rule._pcrel = q->rule._pcrel; + } + if (q->cost[_ri_NT] == 0) { + p->cost[_ri_NT] = 0; + p->rule._ri = q->rule._ri; + } + if (q->cost[_ri3_NT] == 0) { + p->cost[_ri3_NT] = 0; + p->rule._ri3 = q->rule._ri3; + } + if (q->cost[_ea0_NT] == 0) { + p->cost[_ea0_NT] = 0; + p->rule._ea0 = q->rule._ea0; + } + if (q->cost[_ea1_NT] == 0) { + p->cost[_ea1_NT] = 0; + p->rule._ea1 = q->rule._ea1; + } + if (q->cost[_ea3_NT] == 0) { + p->cost[_ea3_NT] = 0; + p->rule._ea3 = q->rule._ea3; + } + } + c = 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 1; + _closure_reg(a, c + 0); + } + } + /* reg: INDIRC(addr) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 11; + _closure_reg(a, c + 0); + } + break; + case 68: /* INDIRS */ + _label(LEFT_CHILD(a)); + if ( /* reg: INDIRS(VREGP) */ + LEFT_CHILD(a)->op == 615 /* VREGP */ + ) { + if (mayrecalc(a)) { + struct _state *q = a->syms[RX]->u.t.cse->x.state; + if (q->cost[_stmt_NT] == 0) { + p->cost[_stmt_NT] = 0; + p->rule._stmt = q->rule._stmt; + } + if (q->cost[_reg_NT] == 0) { + p->cost[_reg_NT] = 0; + p->rule._reg = q->rule._reg; + } + if (q->cost[_con_NT] == 0) { + p->cost[_con_NT] = 0; + p->rule._con = q->rule._con; + } + if (q->cost[_disp16_NT] == 0) { + p->cost[_disp16_NT] = 0; + p->rule._disp16 = q->rule._disp16; + } + if (q->cost[_disp8_NT] == 0) { + p->cost[_disp8_NT] = 0; + p->rule._disp8 = q->rule._disp8; + } + if (q->cost[_base_NT] == 0) { + p->cost[_base_NT] = 0; + p->rule._base = q->rule._base; + } + if (q->cost[_basei_NT] == 0) { + p->cost[_basei_NT] = 0; + p->rule._basei = q->rule._basei; + } + if (q->cost[_addr_NT] == 0) { + p->cost[_addr_NT] = 0; + p->rule._addr = q->rule._addr; + } + if (q->cost[_acon_NT] == 0) { + p->cost[_acon_NT] = 0; + p->rule._acon = q->rule._acon; + } + if (q->cost[_table_NT] == 0) { + p->cost[_table_NT] = 0; + p->rule._table = q->rule._table; + } + if (q->cost[_index_NT] == 0) { + p->cost[_index_NT] = 0; + p->rule._index = q->rule._index; + } + if (q->cost[_scf_NT] == 0) { + p->cost[_scf_NT] = 0; + p->rule._scf = q->rule._scf; + } + if (q->cost[_case_NT] == 0) { + p->cost[_case_NT] = 0; + p->rule._case = q->rule._case; + } + if (q->cost[_avar_NT] == 0) { + p->cost[_avar_NT] = 0; + p->rule._avar = q->rule._avar; + } + if (q->cost[_con0_NT] == 0) { + p->cost[_con0_NT] = 0; + p->rule._con0 = q->rule._con0; + } + if (q->cost[_con3_NT] == 0) { + p->cost[_con3_NT] = 0; + p->rule._con3 = q->rule._con3; + } + if (q->cost[_mem_NT] == 0) { + p->cost[_mem_NT] = 0; + p->rule._mem = q->rule._mem; + } + if (q->cost[_pcrel_NT] == 0) { + p->cost[_pcrel_NT] = 0; + p->rule._pcrel = q->rule._pcrel; + } + if (q->cost[_ri_NT] == 0) { + p->cost[_ri_NT] = 0; + p->rule._ri = q->rule._ri; + } + if (q->cost[_ri3_NT] == 0) { + p->cost[_ri3_NT] = 0; + p->rule._ri3 = q->rule._ri3; + } + if (q->cost[_ea0_NT] == 0) { + p->cost[_ea0_NT] = 0; + p->rule._ea0 = q->rule._ea0; + } + if (q->cost[_ea1_NT] == 0) { + p->cost[_ea1_NT] = 0; + p->rule._ea1 = q->rule._ea1; + } + if (q->cost[_ea3_NT] == 0) { + p->cost[_ea3_NT] = 0; + p->rule._ea3 = q->rule._ea3; + } + } + c = 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 6; + _closure_reg(a, c + 0); + } + } + /* reg: INDIRS(addr) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 14; + _closure_reg(a, c + 0); + } + break; + case 69: /* INDIRI */ + _label(LEFT_CHILD(a)); + if ( /* reg: INDIRI(VREGP) */ + LEFT_CHILD(a)->op == 615 /* VREGP */ + ) { + if (mayrecalc(a)) { + struct _state *q = a->syms[RX]->u.t.cse->x.state; + if (q->cost[_stmt_NT] == 0) { + p->cost[_stmt_NT] = 0; + p->rule._stmt = q->rule._stmt; + } + if (q->cost[_reg_NT] == 0) { + p->cost[_reg_NT] = 0; + p->rule._reg = q->rule._reg; + } + if (q->cost[_con_NT] == 0) { + p->cost[_con_NT] = 0; + p->rule._con = q->rule._con; + } + if (q->cost[_disp16_NT] == 0) { + p->cost[_disp16_NT] = 0; + p->rule._disp16 = q->rule._disp16; + } + if (q->cost[_disp8_NT] == 0) { + p->cost[_disp8_NT] = 0; + p->rule._disp8 = q->rule._disp8; + } + if (q->cost[_base_NT] == 0) { + p->cost[_base_NT] = 0; + p->rule._base = q->rule._base; + } + if (q->cost[_basei_NT] == 0) { + p->cost[_basei_NT] = 0; + p->rule._basei = q->rule._basei; + } + if (q->cost[_addr_NT] == 0) { + p->cost[_addr_NT] = 0; + p->rule._addr = q->rule._addr; + } + if (q->cost[_acon_NT] == 0) { + p->cost[_acon_NT] = 0; + p->rule._acon = q->rule._acon; + } + if (q->cost[_table_NT] == 0) { + p->cost[_table_NT] = 0; + p->rule._table = q->rule._table; + } + if (q->cost[_index_NT] == 0) { + p->cost[_index_NT] = 0; + p->rule._index = q->rule._index; + } + if (q->cost[_scf_NT] == 0) { + p->cost[_scf_NT] = 0; + p->rule._scf = q->rule._scf; + } + if (q->cost[_case_NT] == 0) { + p->cost[_case_NT] = 0; + p->rule._case = q->rule._case; + } + if (q->cost[_avar_NT] == 0) { + p->cost[_avar_NT] = 0; + p->rule._avar = q->rule._avar; + } + if (q->cost[_con0_NT] == 0) { + p->cost[_con0_NT] = 0; + p->rule._con0 = q->rule._con0; + } + if (q->cost[_con3_NT] == 0) { + p->cost[_con3_NT] = 0; + p->rule._con3 = q->rule._con3; + } + if (q->cost[_mem_NT] == 0) { + p->cost[_mem_NT] = 0; + p->rule._mem = q->rule._mem; + } + if (q->cost[_pcrel_NT] == 0) { + p->cost[_pcrel_NT] = 0; + p->rule._pcrel = q->rule._pcrel; + } + if (q->cost[_ri_NT] == 0) { + p->cost[_ri_NT] = 0; + p->rule._ri = q->rule._ri; + } + if (q->cost[_ri3_NT] == 0) { + p->cost[_ri3_NT] = 0; + p->rule._ri3 = q->rule._ri3; + } + if (q->cost[_ea0_NT] == 0) { + p->cost[_ea0_NT] = 0; + p->rule._ea0 = q->rule._ea0; + } + if (q->cost[_ea1_NT] == 0) { + p->cost[_ea1_NT] = 0; + p->rule._ea1 = q->rule._ea1; + } + if (q->cost[_ea3_NT] == 0) { + p->cost[_ea3_NT] = 0; + p->rule._ea3 = q->rule._ea3; + } + } + c = 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 4; + _closure_reg(a, c + 0); + } + } + /* mem: INDIRI(addr) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 0; + if (c + 0 < p->cost[_mem_NT]) { + p->cost[_mem_NT] = c + 0; + p->rule._mem = 1; + _closure_mem(a, c + 0); + } + /* reg: INDIRI(addr) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 12; + _closure_reg(a, c + 0); + } + break; + case 71: /* INDIRP */ + _label(LEFT_CHILD(a)); + if ( /* reg: INDIRP(VREGP) */ + LEFT_CHILD(a)->op == 615 /* VREGP */ + ) { + if (mayrecalc(a)) { + struct _state *q = a->syms[RX]->u.t.cse->x.state; + if (q->cost[_stmt_NT] == 0) { + p->cost[_stmt_NT] = 0; + p->rule._stmt = q->rule._stmt; + } + if (q->cost[_reg_NT] == 0) { + p->cost[_reg_NT] = 0; + p->rule._reg = q->rule._reg; + } + if (q->cost[_con_NT] == 0) { + p->cost[_con_NT] = 0; + p->rule._con = q->rule._con; + } + if (q->cost[_disp16_NT] == 0) { + p->cost[_disp16_NT] = 0; + p->rule._disp16 = q->rule._disp16; + } + if (q->cost[_disp8_NT] == 0) { + p->cost[_disp8_NT] = 0; + p->rule._disp8 = q->rule._disp8; + } + if (q->cost[_base_NT] == 0) { + p->cost[_base_NT] = 0; + p->rule._base = q->rule._base; + } + if (q->cost[_basei_NT] == 0) { + p->cost[_basei_NT] = 0; + p->rule._basei = q->rule._basei; + } + if (q->cost[_addr_NT] == 0) { + p->cost[_addr_NT] = 0; + p->rule._addr = q->rule._addr; + } + if (q->cost[_acon_NT] == 0) { + p->cost[_acon_NT] = 0; + p->rule._acon = q->rule._acon; + } + if (q->cost[_table_NT] == 0) { + p->cost[_table_NT] = 0; + p->rule._table = q->rule._table; + } + if (q->cost[_index_NT] == 0) { + p->cost[_index_NT] = 0; + p->rule._index = q->rule._index; + } + if (q->cost[_scf_NT] == 0) { + p->cost[_scf_NT] = 0; + p->rule._scf = q->rule._scf; + } + if (q->cost[_case_NT] == 0) { + p->cost[_case_NT] = 0; + p->rule._case = q->rule._case; + } + if (q->cost[_avar_NT] == 0) { + p->cost[_avar_NT] = 0; + p->rule._avar = q->rule._avar; + } + if (q->cost[_con0_NT] == 0) { + p->cost[_con0_NT] = 0; + p->rule._con0 = q->rule._con0; + } + if (q->cost[_con3_NT] == 0) { + p->cost[_con3_NT] = 0; + p->rule._con3 = q->rule._con3; + } + if (q->cost[_mem_NT] == 0) { + p->cost[_mem_NT] = 0; + p->rule._mem = q->rule._mem; + } + if (q->cost[_pcrel_NT] == 0) { + p->cost[_pcrel_NT] = 0; + p->rule._pcrel = q->rule._pcrel; + } + if (q->cost[_ri_NT] == 0) { + p->cost[_ri_NT] = 0; + p->rule._ri = q->rule._ri; + } + if (q->cost[_ri3_NT] == 0) { + p->cost[_ri3_NT] = 0; + p->rule._ri3 = q->rule._ri3; + } + if (q->cost[_ea0_NT] == 0) { + p->cost[_ea0_NT] = 0; + p->rule._ea0 = q->rule._ea0; + } + if (q->cost[_ea1_NT] == 0) { + p->cost[_ea1_NT] = 0; + p->rule._ea1 = q->rule._ea1; + } + if (q->cost[_ea3_NT] == 0) { + p->cost[_ea3_NT] = 0; + p->rule._ea3 = q->rule._ea3; + } + } + c = 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 5; + _closure_reg(a, c + 0); + } + } + /* mem: INDIRP(addr) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 0; + if (c + 0 < p->cost[_mem_NT]) { + p->cost[_mem_NT] = c + 0; + p->rule._mem = 2; + _closure_mem(a, c + 0); + } + /* pcrel: INDIRP(case) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_case_NT] + 0; + if (c + 0 < p->cost[_pcrel_NT]) { + p->cost[_pcrel_NT] = c + 0; + p->rule._pcrel = 1; + } + /* reg: INDIRP(addr) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 13; + _closure_reg(a, c + 0); + } + break; + case 73: /* INDIRB */ + _label(LEFT_CHILD(a)); + break; + case 85: /* CVCI */ + _label(LEFT_CHILD(a)); + /* reg: CVCI(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 2; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 43; + _closure_reg(a, c + 0); + } + if ( /* reg: CVCI(INDIRC(addr)) */ + LEFT_CHILD(a)->op == 67 /* INDIRC */ + ) { + c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_addr_NT] + 2; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 47; + _closure_reg(a, c + 0); + } + } + break; + case 86: /* CVCU */ + _label(LEFT_CHILD(a)); + /* reg: CVCU(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 3; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 44; + _closure_reg(a, c + 0); + } + if ( /* reg: CVCU(INDIRC(addr)) */ + LEFT_CHILD(a)->op == 67 /* INDIRC */ + ) { + c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_addr_NT] + 2; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 48; + _closure_reg(a, c + 0); + } + } + break; + case 97: /* CVDF */ + _label(LEFT_CHILD(a)); + /* reg: CVDF(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (notarget(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 63; + _closure_reg(a, c + 0); + } + /* reg: CVDF(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 65; + _closure_reg(a, c + 0); + } + break; + case 101: /* CVDI */ + _label(LEFT_CHILD(a)); + /* reg: CVDI(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 68; + _closure_reg(a, c + 0); + } + break; + case 114: /* CVFD */ + _label(LEFT_CHILD(a)); + /* reg: CVFD(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (notarget(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 64; + _closure_reg(a, c + 0); + } + /* reg: CVFD(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 66; + _closure_reg(a, c + 0); + } + break; + case 130: /* CVID */ + _label(LEFT_CHILD(a)); + /* reg: CVID(ea0) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_ea0_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 67; + _closure_reg(a, c + 0); + } + break; + case 131: /* CVIC */ + _label(LEFT_CHILD(a)); + /* reg: CVIC(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (notarget(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 51; + _closure_reg(a, c + 0); + } + /* reg: CVIC(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 55; + _closure_reg(a, c + 0); + } + break; + case 132: /* CVIS */ + _label(LEFT_CHILD(a)); + /* reg: CVIS(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (notarget(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 52; + _closure_reg(a, c + 0); + } + /* reg: CVIS(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 56; + _closure_reg(a, c + 0); + } + break; + case 134: /* CVIU */ + _label(LEFT_CHILD(a)); + /* reg: CVIU(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (notarget(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 7; + _closure_reg(a, c + 0); + } + /* reg: CVIU(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 57; + _closure_reg(a, c + 0); + } + break; + case 150: /* CVPU */ + _label(LEFT_CHILD(a)); + /* reg: CVPU(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 58; + _closure_reg(a, c + 0); + } + break; + case 165: /* CVSI */ + _label(LEFT_CHILD(a)); + /* reg: CVSI(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 45; + _closure_reg(a, c + 0); + } + if ( /* reg: CVSI(INDIRS(addr)) */ + LEFT_CHILD(a)->op == 68 /* INDIRS */ + ) { + c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_addr_NT] + 2; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 49; + _closure_reg(a, c + 0); + } + } + break; + case 166: /* CVSU */ + _label(LEFT_CHILD(a)); + /* reg: CVSU(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 3; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 46; + _closure_reg(a, c + 0); + } + if ( /* reg: CVSU(INDIRS(addr)) */ + LEFT_CHILD(a)->op == 68 /* INDIRS */ + ) { + c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_addr_NT] + 2; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 50; + _closure_reg(a, c + 0); + } + } + break; + case 179: /* CVUC */ + _label(LEFT_CHILD(a)); + /* reg: CVUC(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (notarget(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 53; + _closure_reg(a, c + 0); + } + /* reg: CVUC(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 59; + _closure_reg(a, c + 0); + } + break; + case 180: /* CVUS */ + _label(LEFT_CHILD(a)); + /* reg: CVUS(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (notarget(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 54; + _closure_reg(a, c + 0); + } + /* reg: CVUS(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 62; + _closure_reg(a, c + 0); + } + break; + case 181: /* CVUI */ + _label(LEFT_CHILD(a)); + /* reg: CVUI(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (notarget(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 8; + _closure_reg(a, c + 0); + } + /* reg: CVUI(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 60; + _closure_reg(a, c + 0); + } + break; + case 183: /* CVUP */ + _label(LEFT_CHILD(a)); + /* reg: CVUP(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 61; + _closure_reg(a, c + 0); + } + break; + case 193: /* NEGF */ + _label(LEFT_CHILD(a)); + /* reg: NEGF(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 82; + _closure_reg(a, c + 0); + } + break; + case 194: /* NEGD */ + _label(LEFT_CHILD(a)); + /* reg: NEGD(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 81; + _closure_reg(a, c + 0); + } + break; + case 197: /* NEGI */ + _label(LEFT_CHILD(a)); + /* reg: NEGI(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 32; + _closure_reg(a, c + 0); + } + break; + case 209: /* CALLF */ + _label(LEFT_CHILD(a)); + /* reg: CALLF(avar) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_avar_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 84; + _closure_reg(a, c + 0); + } + break; + case 210: /* CALLD */ + _label(LEFT_CHILD(a)); + /* reg: CALLD(avar) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_avar_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 85; + _closure_reg(a, c + 0); + } + break; + case 213: /* CALLI */ + _label(LEFT_CHILD(a)); + /* reg: CALLI(avar) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_avar_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 83; + _closure_reg(a, c + 0); + } + break; + case 216: /* CALLV */ + _label(LEFT_CHILD(a)); + /* stmt: CALLV(avar) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_avar_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 66; + } + break; + case 217: /* CALLB */ + break; + case 225: /* LOADF */ + _label(LEFT_CHILD(a)); + /* reg: LOADF(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 70; + _closure_reg(a, c + 0); + } + break; + case 226: /* LOADD */ + _label(LEFT_CHILD(a)); + /* reg: LOADD(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 69; + _closure_reg(a, c + 0); + } + break; + case 227: /* LOADC */ + _label(LEFT_CHILD(a)); + /* reg: LOADC(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 15; + _closure_reg(a, c + 0); + } + break; + case 228: /* LOADS */ + _label(LEFT_CHILD(a)); + /* reg: LOADS(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 18; + _closure_reg(a, c + 0); + } + break; + case 229: /* LOADI */ + _label(LEFT_CHILD(a)); + /* reg: LOADI(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 16; + _closure_reg(a, c + 0); + } + break; + case 230: /* LOADU */ + _label(LEFT_CHILD(a)); + /* reg: LOADU(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 19; + _closure_reg(a, c + 0); + } + break; + case 231: /* LOADP */ + _label(LEFT_CHILD(a)); + /* reg: LOADP(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a)); + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 17; + _closure_reg(a, c + 0); + } + break; + case 233: /* LOADB */ + break; + case 241: /* RETF */ + _label(LEFT_CHILD(a)); + /* stmt: RETF(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 68; + } + break; + case 242: /* RETD */ + _label(LEFT_CHILD(a)); + /* stmt: RETD(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 69; + } + break; + case 245: /* RETI */ + _label(LEFT_CHILD(a)); + /* stmt: RETI(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 67; + } + break; + case 263: /* ADDRGP */ + /* addr: ADDRGP */ + if (0 + 0 < p->cost[_addr_NT]) { + p->cost[_addr_NT] = 0 + 0; + p->rule._addr = 1; + _closure_addr(a, 0 + 0); + } + /* acon: ADDRGP */ + if (0 + 0 < p->cost[_acon_NT]) { + p->cost[_acon_NT] = 0 + 0; + p->rule._acon = 1; + _closure_acon(a, 0 + 0); + } + /* table: ADDRGP */ + if (0 + 0 < p->cost[_table_NT]) { + p->cost[_table_NT] = 0 + 0; + p->rule._table = 1; + } + break; + case 279: /* ADDRFP */ + /* base: ADDRFP */ + c = (range(a, -32768, 32767)); + if (c + 0 < p->cost[_base_NT]) { + p->cost[_base_NT] = c + 0; + p->rule._base = 2; + _closure_base(a, c + 0); + } + /* basei: ADDRFP */ + c = (range(a, -128, 127)); + if (c + 0 < p->cost[_basei_NT]) { + p->cost[_basei_NT] = c + 0; + p->rule._basei = 3; + _closure_basei(a, c + 0); + } + /* basei: ADDRFP */ + if (1 + 0 < p->cost[_basei_NT]) { + p->cost[_basei_NT] = 1 + 0; + p->rule._basei = 5; + _closure_basei(a, 1 + 0); + } + break; + case 295: /* ADDRLP */ + /* base: ADDRLP */ + c = (range(a, -32768, 32767)); + if (c + 0 < p->cost[_base_NT]) { + p->cost[_base_NT] = c + 0; + p->rule._base = 3; + _closure_base(a, c + 0); + } + /* basei: ADDRLP */ + c = (range(a, -128, 127)); + if (c + 0 < p->cost[_basei_NT]) { + p->cost[_basei_NT] = c + 0; + p->rule._basei = 4; + _closure_basei(a, c + 0); + } + /* basei: ADDRLP */ + if (1 + 0 < p->cost[_basei_NT]) { + p->cost[_basei_NT] = 1 + 0; + p->rule._basei = 6; + _closure_basei(a, 1 + 0); + } + break; + case 305: /* ADDF */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: ADDF(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 74; + _closure_reg(a, c + 0); + } + break; + case 306: /* ADDD */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: ADDD(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 73; + _closure_reg(a, c + 0); + } + break; + case 307: /* ADDC */ + break; + case 308: /* ADDS */ + break; + case 309: /* ADDI */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: ADDI(reg,con3) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con3_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 20; + _closure_reg(a, c + 0); + } + /* reg: ADDI(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 22; + _closure_reg(a, c + 0); + } + break; + case 310: /* ADDU */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: ADDU(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 24; + _closure_reg(a, c + 0); + } + break; + case 311: /* ADDP */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* base: ADDP(reg,disp16) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_disp16_NT] + 0; + if (c + 0 < p->cost[_base_NT]) { + p->cost[_base_NT] = c + 0; + p->rule._base = 1; + _closure_base(a, c + 0); + } + /* basei: ADDP(reg,disp8) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_disp8_NT] + 0; + if (c + 0 < p->cost[_basei_NT]) { + p->cost[_basei_NT] = c + 0; + p->rule._basei = 2; + _closure_basei(a, c + 0); + } + /* addr: ADDP(index,basei) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_index_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_basei_NT] + 0; + if (c + 0 < p->cost[_addr_NT]) { + p->cost[_addr_NT] = c + 0; + p->rule._addr = 3; + _closure_addr(a, c + 0); + } + /* case: ADDP(index,table) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_index_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_table_NT] + 0; + if (c + 0 < p->cost[_case_NT]) { + p->cost[_case_NT] = c + 0; + p->rule._case = 1; + } + /* reg: ADDP(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 23; + _closure_reg(a, c + 0); + } + break; + case 321: /* SUBF */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: SUBF(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 76; + _closure_reg(a, c + 0); + } + break; + case 322: /* SUBD */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: SUBD(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 75; + _closure_reg(a, c + 0); + } + break; + case 323: /* SUBC */ + break; + case 324: /* SUBS */ + break; + case 325: /* SUBI */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: SUBI(reg,con3) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con3_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 21; + _closure_reg(a, c + 0); + } + /* reg: SUBI(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 25; + _closure_reg(a, c + 0); + } + break; + case 326: /* SUBU */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: SUBU(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 27; + _closure_reg(a, c + 0); + } + break; + case 327: /* SUBP */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: SUBP(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 26; + _closure_reg(a, c + 0); + } + break; + case 341: /* LSHI */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* index: LSHI(reg,scf) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_scf_NT] + 0; + if (c + 0 < p->cost[_index_NT]) { + p->cost[_index_NT] = c + 0; + p->rule._index = 2; + } + /* reg: LSHI(reg,ri3) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ri3_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 33; + _closure_reg(a, c + 0); + } + break; + case 342: /* LSHU */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: LSHU(reg,ri3) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ri3_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 34; + _closure_reg(a, c + 0); + } + break; + case 357: /* MODI */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: MODI(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 42; + _closure_reg(a, c + 0); + } + break; + case 358: /* MODU */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: MODU(reg,ea3) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea3_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 41; + _closure_reg(a, c + 0); + } + break; + case 373: /* RSHI */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: RSHI(reg,ri3) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ri3_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 35; + _closure_reg(a, c + 0); + } + break; + case 374: /* RSHU */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: RSHU(reg,ri3) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ri3_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 36; + _closure_reg(a, c + 0); + } + break; + case 390: /* BANDU */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: BANDU(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 28; + _closure_reg(a, c + 0); + } + break; + case 406: /* BCOMU */ + _label(LEFT_CHILD(a)); + /* reg: BCOMU(reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 31; + _closure_reg(a, c + 0); + } + break; + case 422: /* BORU */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: BORU(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 29; + _closure_reg(a, c + 0); + } + break; + case 438: /* BXORU */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: BXORU(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 30; + _closure_reg(a, c + 0); + } + break; + case 449: /* DIVF */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: DIVF(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 80; + _closure_reg(a, c + 0); + } + break; + case 450: /* DIVD */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: DIVD(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 79; + _closure_reg(a, c + 0); + } + break; + case 453: /* DIVI */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: DIVI(reg,ea3) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea3_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 40; + _closure_reg(a, c + 0); + } + break; + case 454: /* DIVU */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: DIVU(reg,ea3) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea3_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 39; + _closure_reg(a, c + 0); + } + break; + case 465: /* MULF */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: MULF(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 78; + _closure_reg(a, c + 0); + } + break; + case 466: /* MULD */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: MULD(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 77; + _closure_reg(a, c + 0); + } + break; + case 469: /* MULI */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: MULI(reg,ea3) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea3_NT] + 12; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 37; + _closure_reg(a, c + 0); + } + break; + case 470: /* MULU */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* reg: MULU(reg,ea3) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea3_NT] + 12; + if (c + 0 < p->cost[_reg_NT]) { + p->cost[_reg_NT] = c + 0; + p->rule._reg = 38; + _closure_reg(a, c + 0); + } + break; + case 481: /* EQF */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: EQF(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 60; + } + break; + case 482: /* EQD */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: EQD(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 54; + } + break; + case 485: /* EQI */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: EQI(ea0,con0) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_ea0_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con0_NT] + 2; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 42; + } + /* stmt: EQI(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 3; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 44; + } + break; + case 497: /* GEF */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: GEF(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 61; + } + break; + case 498: /* GED */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: GED(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 55; + } + break; + case 501: /* GEI */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: GEI(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 3; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 45; + } + break; + case 502: /* GEU */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: GEU(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 3; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 50; + } + break; + case 513: /* GTF */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: GTF(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 62; + } + break; + case 514: /* GTD */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: GTD(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 56; + } + break; + case 517: /* GTI */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: GTI(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 3; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 46; + } + break; + case 518: /* GTU */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: GTU(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 3; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 51; + } + break; + case 529: /* LEF */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: LEF(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 63; + } + break; + case 530: /* LED */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: LED(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 57; + } + break; + case 533: /* LEI */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: LEI(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 3; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 47; + } + break; + case 534: /* LEU */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: LEU(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 3; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 52; + } + break; + case 545: /* LTF */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: LTF(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 64; + } + break; + case 546: /* LTD */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: LTD(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 58; + } + break; + case 549: /* LTI */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: LTI(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 3; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 48; + } + break; + case 550: /* LTU */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: LTU(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 3; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 53; + } + break; + case 561: /* NEF */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: NEF(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 65; + } + break; + case 562: /* NED */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: NED(reg,reg) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 59; + } + break; + case 565: /* NEI */ + _label(LEFT_CHILD(a)); + _label(RIGHT_CHILD(a)); + /* stmt: NEI(ea0,con0) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_ea0_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con0_NT] + 2; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 43; + } + /* stmt: NEI(reg,ea1) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ea1_NT] + 3; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 49; + } + break; + case 584: /* JUMPV */ + _label(LEFT_CHILD(a)); + /* stmt: JUMPV(acon) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_acon_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 39; + } + /* stmt: JUMPV(pcrel) */ + c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_pcrel_NT] + 0; + if (c + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = c + 0; + p->rule._stmt = 40; + } + break; + case 600: /* LABELV */ + /* stmt: LABELV */ + if (0 + 0 < p->cost[_stmt_NT]) { + p->cost[_stmt_NT] = 0 + 0; + p->rule._stmt = 41; + } + break; + case 615: /* VREGP */ + break; + default: + fatal("_label", "Bad terminal %d\n", OP_LABEL(a)); + } + } + + static void _kids(p, eruleno, kids) NODEPTR_TYPE p, kids[]; int eruleno; { + if (!p) + fatal("_kids", "Null tree\n", 0); + if (!kids) + fatal("_kids", "Null kids\n", 0); + switch (eruleno) { + case 174: /* stmt: LABELV */ + case 52: /* scf: CNSTI */ + case 51: /* scf: CNSTI */ + case 50: /* scf: CNSTI */ + case 49: /* con3: CNSTP */ + case 48: /* con3: CNSTI */ + case 47: /* con0: CNSTU */ + case 46: /* con0: CNSTP */ + case 45: /* con0: CNSTI */ + case 36: /* table: ADDRGP */ + case 35: /* acon: ADDRGP */ + case 34: /* addr: ADDRGP */ + case 33: /* basei: ADDRLP */ + case 32: /* basei: ADDRFP */ + case 31: /* basei: ADDRLP */ + case 30: /* basei: ADDRFP */ + case 26: /* base: ADDRLP */ + case 25: /* base: ADDRFP */ + case 23: /* disp8: CNSTI */ + case 22: /* disp16: CNSTI */ + case 18: /* con: CNSTU */ + case 17: /* con: CNSTS */ + case 16: /* con: CNSTP */ + case 15: /* con: CNSTI */ + case 14: /* con: CNSTC */ + case 6: /* reg: INDIRS(VREGP) */ + case 5: /* reg: INDIRP(VREGP) */ + case 4: /* reg: INDIRI(VREGP) */ + case 3: /* reg: INDIRF(VREGP) */ + case 2: /* reg: INDIRD(VREGP) */ + case 1: /* reg: INDIRC(VREGP) */ + break; + case 13: /* stmt: ASGNS(VREGP,reg) */ + case 12: /* stmt: ASGNP(VREGP,reg) */ + case 11: /* stmt: ASGND(VREGP,reg) */ + case 10: /* stmt: ASGNI(VREGP,reg) */ + case 9: /* stmt: ASGNF(VREGP,reg) */ + case 8: /* stmt: ASGND(VREGP,reg) */ + case 7: /* stmt: ASGNC(VREGP,reg) */ + kids[0] = RIGHT_CHILD(p); + break; + case 67: /* reg: ri */ + case 66: /* reg: addr */ + case 65: /* ea3: ri */ + case 64: /* ea3: mem */ + case 63: /* ea1: ri */ + case 62: /* ea1: mem */ + case 61: /* ea0: ri */ + case 60: /* ea0: mem */ + case 59: /* ri3: reg */ + case 58: /* ri3: con3 */ + case 57: /* ri: con */ + case 56: /* ri: reg */ + case 44: /* avar: addr */ + case 43: /* avar: reg */ + case 42: /* avar: acon */ + case 39: /* addr: base */ + case 37: /* index: reg */ + case 28: /* basei: reg */ + case 27: /* base: basei */ + case 19: /* stmt: reg */ + kids[0] = p; + break; + case 205: /* stmt: RETD(reg) */ + case 204: /* stmt: RETF(reg) */ + case 203: /* stmt: RETI(reg) */ + case 202: /* reg: CALLD(avar) */ + case 201: /* reg: CALLF(avar) */ + case 200: /* stmt: CALLV(avar) */ + case 199: /* reg: CALLI(avar) */ + case 173: /* stmt: JUMPV(pcrel) */ + case 172: /* stmt: JUMPV(acon) */ + case 171: /* reg: NEGF(reg) */ + case 170: /* reg: NEGD(reg) */ + case 161: /* stmt: ARGF(reg) */ + case 160: /* stmt: ARGD(reg) */ + case 155: /* mem: INDIRF(addr) */ + case 154: /* mem: INDIRD(addr) */ + case 153: /* reg: INDIRF(addr) */ + case 152: /* reg: INDIRD(addr) */ + case 151: /* reg: LOADF(reg) */ + case 150: /* reg: LOADD(reg) */ + case 147: /* stmt: ARGP(addr) */ + case 146: /* stmt: ARGP(ea0) */ + case 145: /* stmt: ARGI(addr) */ + case 144: /* stmt: ARGI(ea0) */ + case 134: /* reg: CVDI(reg) */ + case 133: /* reg: CVID(ea0) */ + case 132: /* reg: CVFD(reg) */ + case 131: /* reg: CVDF(reg) */ + case 130: /* reg: CVFD(reg) */ + case 129: /* reg: CVDF(reg) */ + case 128: /* reg: CVUS(reg) */ + case 127: /* reg: CVUP(reg) */ + case 126: /* reg: CVUI(reg) */ + case 125: /* reg: CVUC(reg) */ + case 124: /* reg: CVPU(reg) */ + case 123: /* reg: CVIU(reg) */ + case 122: /* reg: CVIS(reg) */ + case 121: /* reg: CVIC(reg) */ + case 120: /* reg: CVUS(reg) */ + case 119: /* reg: CVUC(reg) */ + case 118: /* reg: CVIS(reg) */ + case 117: /* reg: CVIC(reg) */ + case 112: /* reg: CVSU(reg) */ + case 111: /* reg: CVSI(reg) */ + case 110: /* reg: CVCU(reg) */ + case 109: /* reg: CVCI(reg) */ + case 96: /* reg: NEGI(reg) */ + case 95: /* reg: BCOMU(reg) */ + case 76: /* reg: LOADU(reg) */ + case 75: /* reg: LOADS(reg) */ + case 74: /* reg: LOADP(reg) */ + case 73: /* reg: LOADI(reg) */ + case 72: /* reg: LOADC(reg) */ + case 71: /* reg: INDIRS(addr) */ + case 70: /* reg: INDIRP(addr) */ + case 69: /* reg: INDIRI(addr) */ + case 68: /* reg: INDIRC(addr) */ + case 55: /* pcrel: INDIRP(case) */ + case 54: /* mem: INDIRP(addr) */ + case 53: /* mem: INDIRI(addr) */ + case 21: /* reg: CVUI(reg) */ + case 20: /* reg: CVIU(reg) */ + kids[0] = LEFT_CHILD(p); + break; + case 198: /* stmt: NEF(reg,reg) */ + case 197: /* stmt: LTF(reg,reg) */ + case 196: /* stmt: LEF(reg,reg) */ + case 195: /* stmt: GTF(reg,reg) */ + case 194: /* stmt: GEF(reg,reg) */ + case 193: /* stmt: EQF(reg,reg) */ + case 192: /* stmt: NED(reg,reg) */ + case 191: /* stmt: LTD(reg,reg) */ + case 190: /* stmt: LED(reg,reg) */ + case 189: /* stmt: GTD(reg,reg) */ + case 188: /* stmt: GED(reg,reg) */ + case 187: /* stmt: EQD(reg,reg) */ + case 186: /* stmt: LTU(reg,ea1) */ + case 185: /* stmt: LEU(reg,ea1) */ + case 184: /* stmt: GTU(reg,ea1) */ + case 183: /* stmt: GEU(reg,ea1) */ + case 182: /* stmt: NEI(reg,ea1) */ + case 181: /* stmt: LTI(reg,ea1) */ + case 180: /* stmt: LEI(reg,ea1) */ + case 179: /* stmt: GTI(reg,ea1) */ + case 178: /* stmt: GEI(reg,ea1) */ + case 177: /* stmt: EQI(reg,ea1) */ + case 176: /* stmt: NEI(ea0,con0) */ + case 175: /* stmt: EQI(ea0,con0) */ + case 169: /* reg: DIVF(reg,reg) */ + case 168: /* reg: DIVD(reg,reg) */ + case 167: /* reg: MULF(reg,reg) */ + case 166: /* reg: MULD(reg,reg) */ + case 165: /* reg: SUBF(reg,reg) */ + case 164: /* reg: SUBD(reg,reg) */ + case 163: /* reg: ADDF(reg,reg) */ + case 162: /* reg: ADDD(reg,reg) */ + case 159: /* stmt: ASGNF(addr,mem) */ + case 158: /* stmt: ASGNF(addr,reg) */ + case 157: /* stmt: ASGND(addr,mem) */ + case 156: /* stmt: ASGND(addr,reg) */ + case 143: /* stmt: ASGNS(addr,con0) */ + case 142: /* stmt: ASGNS(addr,ea1) */ + case 141: /* stmt: ASGNP(addr,con0) */ + case 140: /* stmt: ASGNP(addr,ea1) */ + case 138: /* stmt: ASGNI(addr,con0) */ + case 137: /* stmt: ASGNI(addr,ea1) */ + case 136: /* stmt: ASGNC(addr,con0) */ + case 135: /* stmt: ASGNC(addr,ea1) */ + case 108: /* reg: MODI(reg,reg) */ + case 107: /* reg: MODU(reg,ea3) */ + case 106: /* reg: DIVI(reg,ea3) */ + case 105: /* reg: DIVU(reg,ea3) */ + case 104: /* reg: MULU(reg,ea3) */ + case 103: /* reg: MULI(reg,ea3) */ + case 102: /* reg: RSHU(reg,ri3) */ + case 101: /* reg: RSHI(reg,ri3) */ + case 100: /* reg: LSHU(reg,ri3) */ + case 99: /* reg: LSHI(reg,ri3) */ + case 91: /* reg: BXORU(reg,reg) */ + case 90: /* reg: BORU(reg,ea1) */ + case 89: /* reg: BANDU(reg,ea1) */ + case 84: /* reg: SUBU(reg,ea1) */ + case 83: /* reg: SUBP(reg,ea1) */ + case 82: /* reg: SUBI(reg,ea1) */ + case 81: /* reg: ADDU(reg,ea1) */ + case 80: /* reg: ADDP(reg,ea1) */ + case 79: /* reg: ADDI(reg,ea1) */ + case 78: /* reg: SUBI(reg,con3) */ + case 77: /* reg: ADDI(reg,con3) */ + case 41: /* case: ADDP(index,table) */ + case 40: /* addr: ADDP(index,basei) */ + case 38: /* index: LSHI(reg,scf) */ + case 29: /* basei: ADDP(reg,disp8) */ + case 24: /* base: ADDP(reg,disp16) */ + kids[0] = LEFT_CHILD(p); + kids[1] = RIGHT_CHILD(p); + break; + case 94: /* stmt: ASGNI(addr,BXORU(mem,reg)) */ + case 93: /* stmt: ASGNI(addr,BORU(mem,ri)) */ + case 92: /* stmt: ASGNI(addr,BANDU(mem,ri)) */ + case 88: /* stmt: ASGNI(addr,SUBU(mem,ri)) */ + case 87: /* stmt: ASGNI(addr,SUBI(mem,ri)) */ + case 86: /* stmt: ASGNI(addr,ADDU(mem,ri)) */ + case 85: /* stmt: ASGNI(addr,ADDI(mem,ri)) */ + kids[0] = LEFT_CHILD(p); + kids[1] = LEFT_CHILD(RIGHT_CHILD(p)); + kids[2] = RIGHT_CHILD(RIGHT_CHILD(p)); + break; + case 148: /* stmt: ASGNB(reg,INDIRB(reg)) */ + case 139: /* stmt: ASGNI(addr,CVDI(reg)) */ + case 98: /* stmt: ASGNI(addr,NEGI(mem)) */ + case 97: /* stmt: ASGNI(addr,BCOMU(mem)) */ + kids[0] = LEFT_CHILD(p); + kids[1] = LEFT_CHILD(RIGHT_CHILD(p)); + break; + case 149: /* stmt: ARGB(INDIRB(reg)) */ + case 116: /* reg: CVSU(INDIRS(addr)) */ + case 115: /* reg: CVSI(INDIRS(addr)) */ + case 114: /* reg: CVCU(INDIRC(addr)) */ + case 113: /* reg: CVCI(INDIRC(addr)) */ + kids[0] = LEFT_CHILD(LEFT_CHILD(p)); + break; + default: + fatal("_kids", "Bad rule number %d\n", eruleno); + } + } + + static void progend() { + print( "\tend\n" ) ; + } + + static void segment(n) { + switch( n ) { + case CODE : print( "\tSECTION text,code\n" ) ; break ; + case BSS : print( "\tSECTION udata,bss\n" ) ; break ; + case DATA : print( "\tSECTION data,data\n" ) ; break ; + case LIT : print( "\tSECTION data,data\n" ) ; break ; + } + } + + /* Mark nodes that must be evaluated into a specific register (p. 357) + */ + static void target(p) Node p; { + assert(p); + switch (p->op) { + case ASGNB: + rtarget(p, 1, areg[A0+8]); /* A0 Source */ + rtarget(p, 0, areg[A1+8]); /* A1 Destination */ + break; + case ARGB: + rtarget(p->kids[0], 0, areg[A0+8]); /* A0 Source */ + break; + case CALLI: case CALLV: + setreg(p, dreg[D0]); + break; + case CALLD: case CALLF: + setreg(p, freg[FP0]); + break; + case RETI: + rtarget(p, 0, ireg[D0]); + break; + case RETF: case RETD: + rtarget(p, 0, freg[FP0]); + break; + } + } + + /* spills to memory and later reloads all registers destroyed by a + * given function (p. 357) + */ + static void clobber(p) Node p; { + assert(p); + switch (p->op) { + case MULI: case MULU: + break; + case DIVI: case DIVU: + break; + case MODI: case MODU: + spill(1<op == q->op && p->syms[0] == q->syms[0] + && sametree(p->kids[0], q->kids[0]) && sametree(p->kids[1], q->kids[1]); + + } + + /* confirms that the tree has the form ASGNa( x, b(INDIR(x), c)) (p. 507) + */ + static int memop(p) Node p; { + assert(p); + assert(generic(p->op) == ASGN); + assert(p->kids[0]); + assert(p->kids[1]); + if (generic(p->kids[1]->kids[0]->op) == INDIR) { + assert(p->kids[1]->kids[0]); + return sametree(p->kids[0], p->kids[1]->kids[0]->kids[0]) ? 2 : SHRT_MAX + ; + } else + return SHRT_MAX; + } + + /* Deals with instructions that cannot be handled with simple templates. + * (p. 356) + */ + static void emit2(p) Node p; { + switch(p->op) { + case ASGNB: { + int lab1 = genlabel(1), lab2 = genlabel(1); + int src = getregnum(p->x.kids[1]), dst = getregnum(p->x.kids[0]); + int size = p->syms[0]->u.c.v.i; + + if(size % 2) + print("\tMOVE.L %#%d,D0\n", size); + else + print("\tMOVE.L %#%d,D0\n", size / 2); + print("\tBRA.S .%d\n", lab2); + print(".%d:\n", lab1); + if(size % 2) + print("\tMOVE.B (A%d)+,(A%d)+\n", src, dst); + else + print("\tMOVE.W (A%d)+,(A%d)+\n", src, dst); + print(".%d:\n", lab2); + print("\tDBF.W D0,.%d\n", lab1); + break; + } + case ARGB: { + int lab1 = genlabel(1), lab2 = genlabel(1); + int size = p->syms[0]->u.c.v.i, src = getregnum(p->x.kids[0]); + + if(size % 2) ++size; + print("\tSUBA.L %#%d,SP\n", size); + print("\tMOVE.L SP,A1\n"); + print("\tMOVE.L %#%d,D0\n", size / 2); + print("\tBRA.S .%d\n", lab2); + print(".%d:\n", lab1); + print("\tMOVE.W (A%d)+,(A1)+\n", src); + print(".%d:\n", lab2); + print("\tDBF.W D0,.%d\n", lab1); + } + break; + case MODI: { + int lab1 = genlabel(1); + int rem = getregnum(p), quo = getregnum(p->x.kids[0]); + int divisor = getregnum(p->x.kids[1]); + print("\tMOVEQ.L #-1,D%d\n", D1); + print("\tMOVE.L #31,D%d\n", D2); + print("\tBTST.L D%d,D%d\n", D2, quo); + print("\tBNE.S .%d\n", lab1); + print("\tCLR.L D%d\n", D1); + print(".%d:\n", lab1); + #if 0 + print("\tDIVS.L D%d,D%d:D%d\n", divisor, D1, rem); + #else + print("\tDIVS.L D%d,D%d:D%d\n", divisor, D1, quo); + #endif + print("\tMOVE.L D%d,D%d\n", D1, rem); + break; + } + } + } + + + /* Compute the register or stack cell assigned to the next argument (p. 356) + */ + static void doarg(p) Node p; { + assert(p && p->syms[0]); + switch(p->op) { + #if 0 + case ARGD: case ARGF: + mkactual(2,realparamsize); /* pass all floats as extended which are 96-bits */ + break; + #endif + default: + mkactual(2, p->syms[0]->u.c.v.i); + } + } + + /* load register tmp with k bytes from off(reg) (p. 356) */ + static void blkfetch(k, off, reg, tmp) { + assert(0) ; + } + + /* store k bytes from register tmp at off(reg) (p. 356) */ + static void blkstore(k, off, reg, tmp) { + assert(0) ; + } + + /* emit a loop to copy size bytes from soff(sreg) to doff(dreg) using the + * 3 temporary registers in tmps (p. 356) + */ + static void blkloop(dreg, doff, sreg, soff, size, tmps) + int tmps[]; { + assert(0) ; + } + + /* called by the front end to announce a local variable (p. 90) */ + static void local(p) Symbol p; { + if (askregvar(p, rmap[ttob(p->type)]) == 0) + mkauto(p); + } + + /* initialize prolog and epilog code (p. 93) */ + static void function(f, caller, callee, n) + Symbol f, callee[], caller[]; { + int i, count, acount, inseq; + char reglist[256]; + char temp[4]; + + print("%s:\n", f->x.name); + #ifdef AMIGA + if (glevel > 1) { + print("\tDEBUG\t%d\n",f->src.y); + } + #endif + + usedmask[0] = usedmask[1] = 0; + freemask[0] = freemask[1] = ~(unsigned)0; + offset = 4 + 4; /* FP and return address */ + for (i = 0; callee[i]; i++) { + Symbol p = callee[i]; + Symbol q = caller[i]; + assert(q); + p->x.offset = q->x.offset = offset; + p->x.name = q->x.name = stringf("%d", p->x.offset); + p->sclass = q->sclass = AUTO; + #if 0 + if( p->type == floattype || p->type == doubletype) + offset += roundup(realparamsize, 2); + else + #endif + offset += roundup(q->type->size, 2); + } + assert(caller[i] == 0); + offset = maxoffset = 0; + gencode(caller, callee); + framesize = roundup(maxoffset, 2); + + if (framesize > 0) + print("\tLINK A5,#%d\n", -framesize); + else + print("\tLINK A5,#0\n"); + + /* format save register mask */ + reglist[0]= 0; + count = acount = inseq = 0; + for(i=D3;i<=D7;++i) { + if(usedmask[IREG] & (1<1) { + temp[0] = '-'; + temp[1] = 'D'; + temp[2] = i - 1 + '0'; + temp[3] = 0; + strcat(reglist,temp); + } + inseq = 0; + } + } + if(inseq>1) { + temp[0] = '-'; + temp[1] = 'D'; + temp[2] = '7'; + temp[3] = 0; + strcat(reglist,temp); + } + + if(usedmask[IREG] & ((1<1) { + temp[0] = '-'; + temp[1] = 'A'; + temp[2] = i - 1 + '0'; + temp[3] = 0; + strcat(reglist,temp); + } + inseq = 0; + } + } + if(inseq>1) { + temp[0] = '-'; + temp[1] = 'A'; + temp[2] = '4'; + temp[3] = 0; + strcat(reglist,temp); + } + } + + count += acount; + if(count > 1) + print("\tMOVEM.L %s,-(SP)\n", reglist); + else if(count == 1) + print("\tMOVE.L %s,-(SP)\n", reglist); + + /* save floating point regs */ + for(i=FP4;i<=FP7;++i) + if(usedmask[FREG] & (1<type == floattype) { + print("\tFMOVE.X %d(A5),FP1\n", p->x.offset); + print("\tFMOVE.S FP1,%d(A5)\n", p->x.offset); + } + else if(p->type == doubletype) { + print("\tFMOVE.X %d(A5),FP1\n", p->x.offset); + print("\tFMOVE.D FP1,%d(A5)\n", p->x.offset); + } + } + #endif + + emitcode(); + + for(i=FP7;i>=FP4;--i) + if(usedmask[FREG] & (1< 1) + print("\tMOVEM.L (SP)+,%s\n", reglist); + else if(count == 1) + print("\tMOVE.L (SP)+,%s\n", reglist); + + print("\tUNLK A5\n"); + print("\tRTS\n"); + } + + /* called by the front end when a symbol is defined, so that the Xsymbol + * field can be initialized (p. 89) + * + * JOOP: added cfunc->name to label construction, to aid debugging + * 27-12-95: found a horrible bug and fixed it! + */ + static void defsymbol(p) Symbol p; { + if (p->scope >= LOCAL && p->sclass == STATIC) + p->x.name = stringf("%s_L.%d", cfunc->name, genlabel(1)); + else if (p->generated) + if(cfunc) + p->x.name = stringf("%s_L.%s", cfunc->name, p->name); + else + p->x.name = stringf("L.%s", p->name); + else if (p->scope == GLOBAL || p->sclass == EXTERN) + p->x.name = stringf("_%s", p->name); + else if (p->scope == CONSTANTS + && (isint(p->type) || isptr(p->type)) + && p->name[0] == '0' && p->name[1] == 'x') + p->x.name = stringf("$%s", &p->name[2]); /* hex */ + else + p->x.name = p->name; + } + + static void address(q, p, n) Symbol q, p; int n; { + if (p->scope == GLOBAL + || p->sclass == STATIC || p->sclass == EXTERN) + q->x.name = stringf("%s%s%d", + p->x.name, n >= 0 ? "+" : "", n); + else { + q->x.offset = p->x.offset + n; + q->x.name = stringd(q->x.offset); + } + } + static void defconst(ty, v) Value v; { + switch (ty) { + case C: print("\tDC.B %d\n", v.uc); return; + case S: print("\tDC.W %d\n", v.ss); return; + case I: print("\tDC.L %d\n", v.i ); return; + case U: print("\tDC.L $%x\n", v.u ); return; + case P: print("\tDC.L $%x\n", v.p ); return; + case F: + print("\tDC.L $%x\n", *(unsigned *)&v.f); + return; + case D: { + unsigned *p = (unsigned *)&v.d; + print("\tDC.L $%x\n", p[swap]); + print("\tDC.L $%x\n", p[1 - swap]); + return; + } + } + assert(0); + } + static void defaddress(p) Symbol p; { + print( "\tdc.l\t%s\t; defaddress\n", p->x.name ) ; + } + + static void defstring(n, str) int n; char *str; { + char *s; int count = 0, instr = 0 ; + + print( "*\tdefstring\n" ) ; + print( "\tdc.b\t" ) ; + for (s = str; s < str + n; s++) { + int c = (*s) & 0377 ; + if( count == 40 ) { + print( instr ? "'\n\tdc.b\t" : "\n\tdc.b\t" ) ; instr = count = 0 ; + } + if( isprint(c) && c != '\'' && c != '\\' && c!= '"') { + if( !instr && count > 0 ) print( "," ) ; + print( instr ? "%c" : "'%c", c ) ; instr = 1 ; + } + else { + if( instr ) print( "'" ) ; + if( count > 0 ) print( "," ) ; + print( "%d", c ) ; + instr = 0 ; + } + count++ ; + } + print( instr ? "'\n" : "\n" ) ; + } + + static void export(p) Symbol p; { + print( "\txdef\t%s\n", p->x.name ) ; + } + static void import(p) Symbol p; { + if( p->ref > 0 ) + print( "\txref\t%s\n", p->x.name ) ; + } + static void global(p) Symbol p; { + if( p->type->align > 1 ) + print( "\tcnop\t0,%d\n", p->type->align ) ; + print( "%s:\n", p->x.name ) ; + } + + static void space(n) { + #if 0 + int i ; + + print( "*\tspace(%d)\n", n ) ; + while( n >= 16 ) { + print( "\tdc.b\t0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n" ) ; + n -= 16 ; + } + + if( n == 0 ) return ; + print( "\tdc.b\t0" ) ; n-- ; + while( n > 0 ) + { print( ",0" ) ; n-- ; } + print( "\n" ) ; + #else + print( "*\tspace(%d)\n", n ) ; + print( "\tDS.B %d\n", n); + #endif + } + + Interface m68kIR = { + 1, 1, 0, /* char */ + 2, 2, 0, /* short */ + 4, 2, 0, /* int */ + 4, 2, 1, /* float */ + 8, 2, 1, /* double */ + 4, 2, 0, /* T * */ + 0, 2, 0, /* struct so that ARGB keeps stack aligned */ + 0, /* little_endian */ + 0, /* mulops_calls */ + 0, /* wants_callb */ + 1, /* wants_argb */ + 0, /* left_to_right */ + 0, /* wants_dag */ + address, + blockbeg, + blockend, + defaddress, + defconst, + defstring, + defsymbol, + emit, + export, + function, + gen, + global, + import, + local, + progbeg, + progend, + segment, + space, + 0, + stabend, + 0, + 0, + stabline, + 0, + 0, + {1, blkfetch, blkstore, blkloop, + _label, + _rule, + _nts, + _kids, + _opname, + _arity, + _string, + _templates, + _isinstruction, + _ntname, + emit2, + doarg, + target, + clobber, + } + }; + + /* symname - print prefix, p's name, declaration source coordinate, suffix */ + static void symname(p) Symbol p; { + if (p) + print("%s@%w.%d", p->name, &p->src, p->src.x); + else + print("0"); + } + + /* stabend - finalize stab output */ + /* JOOP: currently not needed ??? */ + static void stabend(cp, p, cpp, sp, stab) Coordinate *cp, **cpp; Symbol p, *sp, *stab; { + #if 0 + int i; + + symname(p); + print("\n"); + if (cpp && sp) + for (i = 0; cpp[i] && sp[i]; i++) { + print("%w.%d: ", cpp[i], cpp[i]->x); + symname(sp[i]); + print("\n"); + } + #endif + } + + /* stabline - emit line number information for source coordinate *cp */ + /* JOOP: example output this generates when '-g' is used + * ;mod.c:14.1: printf("second case %d\n",c%b); + * Suggestions whether or not the line info should stay are welcome + * + * Source level debugging now works! with Bdebug from Barfly atleast + * If only -g is specified then only source level debug is active + * if you specify -g9 then the C-source will also be printed to the + * assembler file. + */ + static void stabline(cp) Coordinate *cp; { + if(glevel == 1 && annotate == 1) + print(";%s\n",cp->source_line); + else if (glevel>1 && annotate) { + print("\tDEBUG\t%d\n",cp->y); + print(";%s\n",cp->source_line); + } + else + print("\tDEBUG\t%d\n",cp->y); + } + + char *input_file = ""; + + static void progbeg(argc, argv) char *argv[]; { + int i; + + { + union { + char c; + int i; + } u; + u.i = 0; + u.c = 1; + swap = (u.i == 1) != IR->little_endian; + } + parseflags(argc, argv); + + for(i=0;i 1) { + #ifdef AMIGA + + BPTR fh_lock; + char namebuffer[256]; /* FILENAME_MAX=4096 in stdio.h, way too big ? */ + + fh_lock=Lock((unsigned char *)firstfile, ACCESS_READ); + if(fh_lock) /* got the lock, now get the complete path/filename */ + { /* should never fail but better safe then sorry */ + NameFromLock(fh_lock, (unsigned char *)namebuffer, + sizeof(namebuffer)); + print("\tDSOURCE\t%s\n", namebuffer); + UnLock(fh_lock); + } + else /* in case it fails, use the file name currently being compiled */ + #endif /* AMIGA */ + print("\tDSOURCE\t%s\n", firstfile); + } + cseg = 0; + } diff -rc --new-file lcc35/src/mc68030.md lcc/src/mc68030.md *** lcc35/src/mc68030.md Thu Jan 1 00:00:00 1970 --- lcc/src/mc68030.md Thu Feb 29 17:31:12 1996 *************** *** 0 **** --- 1,1069 ---- + %{ + /* + This file is an almost complete machine description file of the MC68000 + family for the lburg code generator generator. What's missing can be + easily filled in for a specific MC68k assembler. A change must be made to + config.h in order to use this file. The Xnode struct's kids field must be + enlarged to 4. A completed version of this file forms the basis for the + MPW version of the lcc compiler targeted for the Apple Macintosh. The code + emitted by this specification is for the Apple MPW Assembler which has a + syntax similar to Motorola's assembler. A major difference between this + lburg specification and the examples in the lcc distribution is that switch + statement tables are stored in the code segment and are addressed by the pc + relative addressing mode. + + Registers A2-A7,D3-D7,FP4-FP7 are preserved across function calls. + Registers D0 and FP0 store function results. Parameters are passed from + right to left on the stack. All floating point values are first promoted + to Motorola extended format before being pushed on the stack. + + Here are some benchmark results of some compilers available for the Apple + Macintosh. The programs are similar to those found in the Hennessy suite. + MPW C is the Apple C compiler. Gcc is the MPW port of gcc version + 1.37.1r15. SC is the Symantec C compiler (ex-Zortech with m68k backend). + SCG is the Symantec C compiler with all optimizations on. This compiler + does global optimizations. LCC is the lcc compiler produced with this + machine description file. MW is the Metrowerks 68k C compiler from Code + Warrior. All tests were run on a Macintosh Centris 650 with MC68040 @25MHz + using 020 addressing modes and FPU. + + MPW C gcc gcc -O SC SCG LCC MW opt + Perm 13 13 11 17 19 12 22 + Towers 12 15 10 17 16 12 11 + Queens 6 7 5 7 8 8 4 + Intmm 19 18 16 18 11 19 17 + Mm 17 19 16 18 10 20 18 + Puzzle 68 86 48 74 35 74 47 + Quick 8 10 5 13 11 8 14 + Bubble 11 16 7 19 10 12 11 + FFT 25 28 16 24 20 25 19 + + Hopefully this file will prove useful to those wishing to target lcc to + Atari's, Amiga's, Sun's and Next's. Let me know if you retarget lcc to any + other m68k machines using this file. + Please report any bugs to: + + Woodrow Yeung + yeung@reed.edu + + */ + enum { D0, D1, D2, D3, D4, D5, D6, D7 }; + enum { A0, A1, A2, A3, A4, A5, A6, A7 }; + enum { FP0, FP1, FP2, FP3, FP4, FP5, FP6, FP7 }; + #if 0 + #define realparamsize 12 + #endif + #ifndef AMIGA + #include "c.h" + #include + #else + /* Work around some incompatibilities between system/lcc header files and + */ + #define SHORT _SHORT + #define LONG _LONG + #define FLOAT _FLOAT + #define DOUBLE _DOUBLE + #include "c.h" + #undef SHORT + #undef LONG + #undef FLOAT + #undef DOUBLE + #include + #ifdef BITSPERBYTE + #undef BITSPERBYTE + #endif + #ifdef MAXINT + #undef MAXINT + #endif + #ifdef MININT + #undef MININT + #endif + #ifdef LONGBITS + #undef LONGBITS + #endif + #include + #include + #undef STATIC + #undef GLOBAL + #endif + #define NODEPTR_TYPE Node + #define OP_LABEL(p) ((p)->op) + #define LEFT_CHILD(p) ((p)->kids[0]) + #define RIGHT_CHILD(p) ((p)->kids[1]) + #define STATE_LABEL(p) ((p)->x.state) + #define FILEPART(x) (strrchr((x),'/') ? strrchr((x),'/')+1 : \ + (strrchr((x),':') ? strrchr((x),':')+1 : (x))) + static void address ARGS((Symbol, Symbol, int)); + static void blkfetch ARGS((int, int, int, int)); + static void blkloop ARGS((int, int, int, int, int, int[])); + static void blkstore ARGS((int, int, int, int)); + static void defaddress ARGS((Symbol)); + static void defconst ARGS((int, Value)); + static void defstring ARGS((int, char *)); + static void defsymbol ARGS((Symbol)); + static void doarg ARGS((Node)); + static void emit2 ARGS((Node)); + static void export ARGS((Symbol)); + static void clobber ARGS((Node)); + static void function ARGS((Symbol, Symbol [], Symbol [], int)); + static void global ARGS((Symbol)); + static void import ARGS((Symbol)); + static void local ARGS((Symbol)); + static void progbeg ARGS((int, char **)); + static void progend ARGS((void)); + static void segment ARGS((int)); + static void space ARGS((int)); + static void target ARGS((Node)); + + static int sametree ARGS((Node, Node)); + static int memop ARGS((Node)); + + static void symname ARGS((Symbol p)); + static void stabend ARGS((Coordinate *, Symbol, Coordinate **, Symbol *, Symbol *)); + static void stabline ARGS((Coordinate *)); + + static Symbol ireg[32], *dreg = &ireg[0], areg[32], freg[32]; + + static int cseg; + + %} + %start stmt + %term ADDD=306 ADDF=305 ADDI=309 ADDP=311 ADDU=310 ADDC=307 ADDS=308 + %term ADDRFP=279 + %term ADDRGP=263 + %term ADDRLP=295 + %term ARGB=41 ARGD=34 ARGF=33 ARGI=37 ARGP=39 + %term ASGNB=57 ASGNC=51 ASGND=50 ASGNF=49 ASGNI=53 ASGNP=55 ASGNS=52 ASGNU=54 + %term BANDU=390 + %term BCOMU=406 + %term BORU=422 + %term BXORU=438 + %term CALLB=217 CALLD=210 CALLF=209 CALLI=213 CALLV=216 + %term CNSTC=19 CNSTD=18 CNSTF=17 CNSTI=21 CNSTP=23 CNSTS=20 CNSTU=22 + %term CVCI=85 CVCU=86 + %term CVDF=97 CVDI=101 + %term CVFD=114 + %term CVIC=131 CVID=130 CVIS=132 CVIU=134 + %term CVPU=150 + %term CVSI=165 CVSU=166 + %term CVUC=179 CVUI=181 CVUP=183 CVUS=180 + %term DIVD=450 DIVF=449 DIVI=453 DIVU=454 + %term EQD=482 EQF=481 EQI=485 + %term GED=498 GEF=497 GEI=501 GEU=502 + %term GTD=514 GTF=513 GTI=517 GTU=518 + %term INDIRB=73 INDIRC=67 INDIRD=66 INDIRF=65 INDIRI=69 INDIRP=71 INDIRS=68 + %term JUMPV=584 + %term LABELV=600 + %term LED=530 LEF=529 LEI=533 LEU=534 + %term LOADB=233 LOADC=227 LOADD=226 LOADF=225 LOADI=229 LOADP=231 LOADS=228 LOADU=230 + %term LSHI=341 LSHU=342 + %term LTD=546 LTF=545 LTI=549 LTU=550 + %term MODI=357 MODU=358 + %term MULD=466 MULF=465 MULI=469 MULU=470 + %term NED=562 NEF=561 NEI=565 + %term NEGD=194 NEGF=193 NEGI=197 + %term RETD=242 RETF=241 RETI=245 + %term RSHI=373 RSHU=374 + %term SUBD=322 SUBF=321 SUBI=325 SUBP=327 SUBU=326 SUBC=323 SUBS=324 + %term VREGP=615 + %% + reg: INDIRC(VREGP) "# read register\n" + reg: INDIRD(VREGP) "# read register\n" + reg: INDIRF(VREGP) "# read register\n" + reg: INDIRI(VREGP) "# read register\n" + reg: INDIRP(VREGP) "# read register\n" + reg: INDIRS(VREGP) "# read register\n" + stmt: ASGNC(VREGP,reg) "# write register\n" + stmt: ASGND(VREGP,reg) "# write register\n" + stmt: ASGNF(VREGP,reg) "# write register\n" + stmt: ASGNI(VREGP,reg) "# write register\n" + stmt: ASGND(VREGP,reg) "# write register\n" + stmt: ASGNP(VREGP,reg) "# write register\n" + stmt: ASGNS(VREGP,reg) "# write register\n" + con: CNSTC "%#%a" + con: CNSTI "%#%a" + con: CNSTP "%#%a" + con: CNSTS "%#%a" + con: CNSTU "%#%a" + stmt: reg "" + reg: CVIU(reg) "%0" notarget(a) + reg: CVUI(reg) "%0" notarget(a) + + disp16: CNSTI "%a" range(a, -32768, 32767) + disp8: CNSTI "%a" range(a, -128, 127) + + base: ADDP(reg,disp16) "%1(%0" + base: ADDRFP "%a(A5" range(a, -32768, 32767) + base: ADDRLP "%a(A5" range(a, -32768, 32767) + base: basei "%0" + basei: reg "0(%0" + basei: ADDP(reg,disp8) "%1(%0" + basei: ADDRFP "%a(A5" range(a, -128, 127) + basei: ADDRLP "%a(A5" range(a, -128, 127) + basei: ADDRFP "0(%a,A5" 1 + basei: ADDRLP "0(%a,A5" 1 + + addr: ADDRGP "%a" + acon: ADDRGP "%a" + table: ADDRGP "\tLEA %a,%c\n" + + index: reg "%0" + index: LSHI(reg,scf) "%0*%1" + + addr: base "%0)" + + addr: ADDP(index,basei) "%1,%0)" + case: ADDP(index,table) "0(%1,%0)" + + avar: acon "%0" + avar: reg "(%0)" 1 + avar: addr "%0" 2 + + con0: CNSTI "%#0" range(a, 0, 0) + con0: CNSTP "%#0" range(a, 0, 0) + con0: CNSTU "%#0" range(a, 0, 0) + con3: CNSTI "%#%a" range(a, 1, 8) + con3: CNSTP "%#%a" range(a, 1, 8) + + scf: CNSTI "2" range(a, 1, 1) + scf: CNSTI "4" range(a, 2, 2) + scf: CNSTI "8" range(a, 3, 3) + + mem: INDIRI(addr) "%0" + mem: INDIRP(addr) "%0" + + pcrel: INDIRP(case) "\tMOVE.L %0,%c\n" + + ri: reg "%0" + ri: con "%0" + ri3: con3 "%0" + ri3: reg "%0" + + ea0: mem "%0" + ea0: ri "%0" + ea1: mem "%0" 1 + ea1: ri "%0" + ea3: mem "%0" 3 + ea3: ri "%0" + + reg: addr "\tLEA %0,%c\n" 1 + reg: ri "\tMOVE.L %0,%c\n" 1 + reg: INDIRC(addr) "\tMOVE.B %0,%c\n" 1 + reg: INDIRI(addr) "\tMOVE.L %0,%c\n" 1 + reg: INDIRP(addr) "\tMOVE.L %0,%c\n" 1 + reg: INDIRS(addr) "\tMOVE.W %0,%c\n" 1 + + reg: LOADC(reg) "\tMOVE.L %0,%c\n" move(a) + reg: LOADI(reg) "\tMOVE.L %0,%c\n" move(a) + reg: LOADP(reg) "\tMOVE.L %0,%c\n" move(a) + reg: LOADS(reg) "\tMOVE.L %0,%c\n" move(a) + reg: LOADU(reg) "\tMOVE.L %0,%c\n" move(a) + + reg: ADDI(reg,con3) "?\tMOVE.L %0,%c\n\tADDQ.L %1,%c\n" + reg: SUBI(reg,con3) "?\tMOVE.L %0,%c\n\tSUBQ.L %1,%c\n" + + reg: ADDI(reg,ea1) "?\tMOVE.L %0,%c\n\tADD.L %1,%c\n" 1 + reg: ADDP(reg,ea1) "?\tMOVE.L %0,%c\n\tADDA.L %1,%c\n" 1 + reg: ADDU(reg,ea1) "?\tMOVE.L %0,%c\n\tADD.L %1,%c\n" 1 + reg: SUBI(reg,ea1) "?\tMOVE.L %0,%c\n\tSUB.L %1,%c\n" 1 + reg: SUBP(reg,ea1) "?\tMOVE.L %0,%c\n\tSUBA.L %1,%c\n" 1 + reg: SUBU(reg,ea1) "?\tMOVE.L %0,%c\n\tSUB.L %1,%c\n" 1 + + stmt: ASGNI(addr,ADDI(mem,ri)) "\tADD.L %2,%1\n" memop(a) + stmt: ASGNI(addr,ADDU(mem,ri)) "\tADD.L %2,%1\n" memop(a) + stmt: ASGNI(addr,SUBI(mem,ri)) "\tSUB.L %2,%1\n" memop(a) + stmt: ASGNI(addr,SUBU(mem,ri)) "\tSUB.L %2,%1\n" memop(a) + + reg: BANDU(reg,ea1) "?\tMOVE.L %0,%c\n\tAND.L %1,%c\n" 1 + reg: BORU(reg,ea1) "?\tMOVE.L %0,%c\n\tOR.L %1,%c\n" 1 + reg: BXORU(reg,reg) "?\tMOVE.L %0,%c\n\tEOR.L %1,%c\n" 1 + + stmt: ASGNI(addr,BANDU(mem,ri)) "\tAND.L %2,%1\n" memop(a) + stmt: ASGNI(addr,BORU(mem,ri)) "\tOR.L %2,%1\n" memop(a) + stmt: ASGNI(addr,BXORU(mem,reg)) "\tEOR.L %2,%1\n" memop(a) + + reg: BCOMU(reg) "?\tMOVE.L %0,%c\n\tNOT.L %c\n" 1 + reg: NEGI(reg) "?\tMOVE.L %0,%c\n\tNEG.L %c\n" 1 + + stmt: ASGNI(addr,BCOMU(mem)) "\tNOT.L %1\n" memop(a) + stmt: ASGNI(addr,NEGI(mem)) "\tNEG.L %1\n" memop(a) + + reg: LSHI(reg,ri3) "?\tMOVE.L %0,%c\n\tASL.L %1,%c\n" 1 + reg: LSHU(reg,ri3) "?\tMOVE.L %0,%c\n\tLSL.L %1,%c\n" 1 + reg: RSHI(reg,ri3) "?\tMOVE.L %0,%c\n\tASR.L %1,%c\n" 1 + reg: RSHU(reg,ri3) "?\tMOVE.L %0,%c\n\tLSR.L %1,%c\n" 1 + + reg: MULI(reg,ea3) "?\tMOVE.L %0,%c\n\tMULS.L %1,%c\n" 12 + reg: MULU(reg,ea3) "?\tMOVE.L %0,%c\n\tMULU.L %1,%c\n" 12 + + reg: DIVU(reg,ea3) "?\tMOVE.L %0,%c\n\tDIVU.L %1,%c\n" + reg: DIVI(reg,ea3) "?\tMOVE.L %0,%c\n\tDIVS.L %1,%c\n" + reg: MODU(reg,ea3) "\tMOVE.L %0,D1\n\tCLR.L %c\n\tDIVU.L %1,%c:D1\n" + reg: MODI(reg,reg) "#\tCLR.L %c\n\tDIVS.L %1,%0\n" + + reg: CVCI(reg) "\tMOVE.B %0,%c\n\tEXT.W %c\n\tEXT.L %c\n" 2 + reg: CVCU(reg) "\tMOVE.B %0,%c\n\tAND.L #$FF,%0\n" 3 + reg: CVSI(reg) "\tMOVE.W %0,%c\n\tEXT.L %c\n" 1 + reg: CVSU(reg) "\tMOVE.W %0,%c\n\tAND.L #$FFFF,%0\n" 3 + reg: CVCI(INDIRC(addr)) "\tMOVE.B %0,%c\n\tEXT.W %c\n\tEXT.L %c\n" 2 + reg: CVCU(INDIRC(addr)) "\tMOVE.B %0,%c\n\tANDI.L #$ff,%c\n" 2 + reg: CVSI(INDIRS(addr)) "\tMOVE.W %0,%c\n\tEXT.L %c\n" 2 + reg: CVSU(INDIRS(addr)) "\tMOVE.W %0,%c\n\tANDI.L #$ffff,%c\n" 2 + reg: CVIC(reg) "%0" notarget(a) + reg: CVIS(reg) "%0" notarget(a) + reg: CVUC(reg) "%0" notarget(a) + reg: CVUS(reg) "%0" notarget(a) + reg: CVIC(reg) "\tMOVE.L %0,%c\n" move(a) + reg: CVIS(reg) "\tMOVE.L %0,%c\n" move(a) + reg: CVIU(reg) "\tMOVE.L %0,%c\n" move(a) + reg: CVPU(reg) "\tMOVE.L %0,%c\n" + reg: CVUC(reg) "\tMOVE.L %0,%c\n" move(a) + reg: CVUI(reg) "\tMOVE.L %0,%c\n" move(a) + reg: CVUP(reg) "\tMOVE.L %0,%c\n" + reg: CVUS(reg) "\tMOVE.L %0,%c\n" move(a) + + reg: CVDF(reg) "%0" notarget(a) + reg: CVFD(reg) "%0" notarget(a) + reg: CVDF(reg) "\tFMOVE.D %0,%c\n" move(a) + reg: CVFD(reg) "\tFMOVE.D %0,%c\n" move(a) + reg: CVID(ea0) "\tFMOVE.L %0,%c\n" + reg: CVDI(reg) "\tFMOVE.L %0,%c\n" + + stmt: ASGNC(addr,ea1) "\tMOVE.B %1,%0\n" 1 + stmt: ASGNC(addr,con0) "\tCLR.L %0\n" + stmt: ASGNI(addr,ea1) "\tMOVE.L %1,%0\n" 1 + stmt: ASGNI(addr,con0) "\tCLR.L %0\n" + stmt: ASGNI(addr,CVDI(reg)) "\tFMOVE.L %1,%0\n" + stmt: ASGNP(addr,ea1) "\tMOVE.L %1,%0\n" 1 + stmt: ASGNP(addr,con0) "\tCLR.L %0\n" + stmt: ASGNS(addr,ea1) "\tMOVE.W %1,%0\n" 1 + stmt: ASGNS(addr,con0) "\tCLR.W %0\n" + + stmt: ARGI(ea0) "\tMOVE.L %0,-(SP)\n" 1 + stmt: ARGI(addr) "\tPEA.L %0\n" 1 + stmt: ARGP(ea0) "\tMOVE.L %0,-(SP)\n" 1 + stmt: ARGP(addr) "\tPEA.L %0\n" 1 + stmt: ASGNB(reg, INDIRB(reg)) "# MOVE (src)+,(dst)+\n" 2 + stmt: ARGB(INDIRB(reg)) "# Copy to stack\n" 2 + + reg: LOADD(reg) "\tFMOVE.D %0,%c\n" move(a) + reg: LOADF(reg) "\tFMOVE.D %0,%c\n" move(a) + + reg: INDIRD(addr) "\tFMOVE.D %0,%c\n" 3 + reg: INDIRF(addr) "\tFMOVE.S %0,%c\n" 3 + mem: INDIRD(addr) "%0" + mem: INDIRF(addr) "%0" + + stmt: ASGND(addr,reg) "\tFMOVE.D %1,%0\n" 4 + stmt: ASGND(addr,mem) "\tLEA.L %1,A0\n\tLEA.L %0,A1\n\tMOVE.L (A0)+,(A1)+\n\tMOVE.L (A0),(A1)\n" 3 + stmt: ASGNF(addr,reg) "\tFMOVE.S %1,%0\n" 4 + stmt: ASGNF(addr,mem) "\tMOVE.L %1,%0\n" 1 + stmt: ARGD(reg) "\tFMOVE.D %0,-(SP)\n" 3 + stmt: ARGF(reg) "\tFMOVE.D %0,-(SP)\n" 3 + + reg: ADDD(reg,reg) "?\tFMOVE.D %0,%c\n\tFADD.D %1,%c\n" + reg: ADDF(reg,reg) "?\tFMOVE.D %0,%c\n\tFADD.D %1,%c\n" + reg: SUBD(reg,reg) "?\tFMOVE.D %0,%c\n\tFSUB.D %1,%c\n" + reg: SUBF(reg,reg) "?\tFMOVE.D %0,%c\n\tFSUB.D %1,%c\n" + reg: MULD(reg,reg) "?\tFMOVE.D %0,%c\n\tFMUL.D %1,%c\n" + reg: MULF(reg,reg) "?\tFMOVE.D %0,%c\n\tFMUL.D %1,%c\n" + reg: DIVD(reg,reg) "?\tFMOVE.D %0,%c\n\tFDIV.D %1,%c\n" + reg: DIVF(reg,reg) "?\tFMOVE.D %0,%c\n\tFDIV.D %1,%c\n" + + reg: NEGD(reg) "\tFNEG.D %c\n" + reg: NEGF(reg) "\tFNEG.D %c\n" + + stmt: JUMPV(acon) "\tBRA.L %0\n" + stmt: JUMPV(pcrel) "\tJMP 0(%0)\n" + stmt: LABELV "%a:\n" + + stmt: EQI(ea0,con0) "\tTST.L %0\n\tBEQ.L %a\n" 2 + stmt: NEI(ea0,con0) "\tTST.L %0\n\tBNE.L %a\n" 2 + + stmt: EQI(reg,ea1) "\tCMP.L %1,%0\n\tBEQ.L %a\n" 3 + stmt: GEI(reg,ea1) "\tCMP.L %1,%0\n\tBGE.L %a\n" 3 + stmt: GTI(reg,ea1) "\tCMP.L %1,%0\n\tBGT.L %a\n" 3 + stmt: LEI(reg,ea1) "\tCMP.L %1,%0\n\tBLE.L %a\n" 3 + stmt: LTI(reg,ea1) "\tCMP.L %1,%0\n\tBLT.L %a\n" 3 + stmt: NEI(reg,ea1) "\tCMP.L %1,%0\n\tBNE.L %a\n" 3 + + stmt: GEU(reg,ea1) "\tCMP.L %1,%0\n\tBHS.L %a\n" 3 + stmt: GTU(reg,ea1) "\tCMP.L %1,%0\n\tBHI.L %a\n" 3 + stmt: LEU(reg,ea1) "\tCMP.L %1,%0\n\tBLS.L %a\n" 3 + stmt: LTU(reg,ea1) "\tCMP.L %1,%0\n\tBLO.L %a\n" 3 + + stmt: EQD(reg,reg) "\tFCMP.D %1,%0\n\tFBEQ.W %a\n" + stmt: GED(reg,reg) "\tFCMP.D %1,%0\n\tFBGE.W %a\n" + stmt: GTD(reg,reg) "\tFCMP.D %1,%0\n\tFBGT.W %a\n" + stmt: LED(reg,reg) "\tFCMP.D %1,%0\n\tFBLE.W %a\n" + stmt: LTD(reg,reg) "\tFCMP.D %1,%0\n\tFBLT.W %a\n" + stmt: NED(reg,reg) "\tFCMP.D %1,%0\n\tFBNE.W %a\n" + + stmt: EQF(reg,reg) "\tFCMP.D %1,%0\n\tFBEQ.W %a\n" + stmt: GEF(reg,reg) "\tFCMP.D %1,%0\n\tFBGE.W %a\n" + stmt: GTF(reg,reg) "\tFCMP.D %1,%0\n\tFBGT.W %a\n" + stmt: LEF(reg,reg) "\tFCMP.D %1,%0\n\tFBLE.W %a\n" + stmt: LTF(reg,reg) "\tFCMP.D %1,%0\n\tFBLT.W %a\n" + stmt: NEF(reg,reg) "\tFCMP.D %1,%0\n\tFBNE.W %a\n" + + reg: CALLI(avar) "\tJSR %0\n\tADDA.L %#%a,SP\n" + stmt: CALLV(avar) "\tJSR %0\n\tADDA.L %#%a,SP\n" + reg: CALLF(avar) "\tJSR %0\n\tADDA.L %#%a,SP\n" + reg: CALLD(avar) "\tJSR %0\n\tADDA.L %#%a,SP\n" + + stmt: RETI(reg) "# RTS\n" + stmt: RETF(reg) "# RTS\n" + stmt: RETD(reg) "# RTS\n" + + %% + static void progend() { + print( "\tend\n" ) ; + } + + static void segment(n) { + switch( n ) { + case CODE : print( "\tSECTION text,code\n" ) ; break ; + case BSS : print( "\tSECTION udata,bss\n" ) ; break ; + case DATA : print( "\tSECTION data,data\n" ) ; break ; + case LIT : print( "\tSECTION data,data\n" ) ; break ; + } + } + + /* Mark nodes that must be evaluated into a specific register (p. 357) + */ + static void target(p) Node p; { + assert(p); + switch (p->op) { + case ASGNB: + rtarget(p, 1, areg[A0+8]); /* A0 Source */ + rtarget(p, 0, areg[A1+8]); /* A1 Destination */ + break; + case ARGB: + rtarget(p->kids[0], 0, areg[A0+8]); /* A0 Source */ + break; + case CALLI: case CALLV: + setreg(p, dreg[D0]); + break; + case CALLD: case CALLF: + setreg(p, freg[FP0]); + break; + case RETI: + rtarget(p, 0, ireg[D0]); + break; + case RETF: case RETD: + rtarget(p, 0, freg[FP0]); + break; + } + } + + /* spills to memory and later reloads all registers destroyed by a + * given function (p. 357) + */ + static void clobber(p) Node p; { + assert(p); + switch (p->op) { + case MULI: case MULU: + break; + case DIVI: case DIVU: + break; + case MODI: case MODU: + spill(1<op == q->op && p->syms[0] == q->syms[0] + && sametree(p->kids[0], q->kids[0]) && sametree(p->kids[1], q->kids[1]); + + } + + /* confirms that the tree has the form ASGNa( x, b(INDIR(x), c)) (p. 507) + */ + static int memop(p) Node p; { + assert(p); + assert(generic(p->op) == ASGN); + assert(p->kids[0]); + assert(p->kids[1]); + if (generic(p->kids[1]->kids[0]->op) == INDIR) { + assert(p->kids[1]->kids[0]); + return sametree(p->kids[0], p->kids[1]->kids[0]->kids[0]) ? 2 : SHRT_MAX + ; + } else + return SHRT_MAX; + } + + /* Deals with instructions that cannot be handled with simple templates. + * (p. 356) + */ + static void emit2(p) Node p; { + switch(p->op) { + case ASGNB: { + int lab1 = genlabel(1), lab2 = genlabel(1); + int src = getregnum(p->x.kids[1]), dst = getregnum(p->x.kids[0]); + int size = p->syms[0]->u.c.v.i; + + if(size % 2) + print("\tMOVE.L %#%d,D0\n", size); + else + print("\tMOVE.L %#%d,D0\n", size / 2); + print("\tBRA.S .%d\n", lab2); + print(".%d:\n", lab1); + if(size % 2) + print("\tMOVE.B (A%d)+,(A%d)+\n", src, dst); + else + print("\tMOVE.W (A%d)+,(A%d)+\n", src, dst); + print(".%d:\n", lab2); + print("\tDBF.W D0,.%d\n", lab1); + break; + } + case ARGB: { + int lab1 = genlabel(1), lab2 = genlabel(1); + int size = p->syms[0]->u.c.v.i, src = getregnum(p->x.kids[0]); + + if(size % 2) ++size; + print("\tSUBA.L %#%d,SP\n", size); + print("\tMOVE.L SP,A1\n"); + print("\tMOVE.L %#%d,D0\n", size / 2); + print("\tBRA.S .%d\n", lab2); + print(".%d:\n", lab1); + print("\tMOVE.W (A%d)+,(A1)+\n", src); + print(".%d:\n", lab2); + print("\tDBF.W D0,.%d\n", lab1); + } + break; + case MODI: { + int lab1 = genlabel(1); + int rem = getregnum(p), quo = getregnum(p->x.kids[0]); + int divisor = getregnum(p->x.kids[1]); + print("\tMOVEQ.L #-1,D%d\n", D1); + print("\tMOVE.L #31,D%d\n", D2); + print("\tBTST.L D%d,D%d\n", D2, quo); + print("\tBNE.S .%d\n", lab1); + print("\tCLR.L D%d\n", D1); + print(".%d:\n", lab1); + #if 0 + print("\tDIVS.L D%d,D%d:D%d\n", divisor, D1, rem); + #else + print("\tDIVS.L D%d,D%d:D%d\n", divisor, D1, quo); + #endif + print("\tMOVE.L D%d,D%d\n", D1, rem); + break; + } + } + } + + + /* Compute the register or stack cell assigned to the next argument (p. 356) + */ + static void doarg(p) Node p; { + assert(p && p->syms[0]); + switch(p->op) { + #if 0 + case ARGD: case ARGF: + mkactual(2,realparamsize); /* pass all floats as extended which are 96-bits */ + break; + #endif + default: + mkactual(2, p->syms[0]->u.c.v.i); + } + } + + /* load register tmp with k bytes from off(reg) (p. 356) */ + static void blkfetch(k, off, reg, tmp) { + assert(0) ; + } + + /* store k bytes from register tmp at off(reg) (p. 356) */ + static void blkstore(k, off, reg, tmp) { + assert(0) ; + } + + /* emit a loop to copy size bytes from soff(sreg) to doff(dreg) using the + * 3 temporary registers in tmps (p. 356) + */ + static void blkloop(dreg, doff, sreg, soff, size, tmps) + int tmps[]; { + assert(0) ; + } + + /* called by the front end to announce a local variable (p. 90) */ + static void local(p) Symbol p; { + if (askregvar(p, rmap[ttob(p->type)]) == 0) + mkauto(p); + } + + /* initialize prolog and epilog code (p. 93) */ + static void function(f, caller, callee, n) + Symbol f, callee[], caller[]; { + int i, count, acount, inseq; + char reglist[256]; + char temp[4]; + + print("%s:\n", f->x.name); + #ifdef AMIGA + if (glevel > 1) { + print("\tDEBUG\t%d\n",f->src.y); + } + #endif + + usedmask[0] = usedmask[1] = 0; + freemask[0] = freemask[1] = ~(unsigned)0; + offset = 4 + 4; /* FP and return address */ + for (i = 0; callee[i]; i++) { + Symbol p = callee[i]; + Symbol q = caller[i]; + assert(q); + p->x.offset = q->x.offset = offset; + p->x.name = q->x.name = stringf("%d", p->x.offset); + p->sclass = q->sclass = AUTO; + #if 0 + if( p->type == floattype || p->type == doubletype) + offset += roundup(realparamsize, 2); + else + #endif + offset += roundup(q->type->size, 2); + } + assert(caller[i] == 0); + offset = maxoffset = 0; + gencode(caller, callee); + framesize = roundup(maxoffset, 2); + + if (framesize > 0) + print("\tLINK A5,#%d\n", -framesize); + else + print("\tLINK A5,#0\n"); + + /* format save register mask */ + reglist[0]= 0; + count = acount = inseq = 0; + for(i=D3;i<=D7;++i) { + if(usedmask[IREG] & (1<1) { + temp[0] = '-'; + temp[1] = 'D'; + temp[2] = i - 1 + '0'; + temp[3] = 0; + strcat(reglist,temp); + } + inseq = 0; + } + } + if(inseq>1) { + temp[0] = '-'; + temp[1] = 'D'; + temp[2] = '7'; + temp[3] = 0; + strcat(reglist,temp); + } + + if(usedmask[IREG] & ((1<1) { + temp[0] = '-'; + temp[1] = 'A'; + temp[2] = i - 1 + '0'; + temp[3] = 0; + strcat(reglist,temp); + } + inseq = 0; + } + } + if(inseq>1) { + temp[0] = '-'; + temp[1] = 'A'; + temp[2] = '4'; + temp[3] = 0; + strcat(reglist,temp); + } + } + + count += acount; + if(count > 1) + print("\tMOVEM.L %s,-(SP)\n", reglist); + else if(count == 1) + print("\tMOVE.L %s,-(SP)\n", reglist); + + /* save floating point regs */ + for(i=FP4;i<=FP7;++i) + if(usedmask[FREG] & (1<type == floattype) { + print("\tFMOVE.X %d(A5),FP1\n", p->x.offset); + print("\tFMOVE.S FP1,%d(A5)\n", p->x.offset); + } + else if(p->type == doubletype) { + print("\tFMOVE.X %d(A5),FP1\n", p->x.offset); + print("\tFMOVE.D FP1,%d(A5)\n", p->x.offset); + } + } + #endif + + emitcode(); + + for(i=FP7;i>=FP4;--i) + if(usedmask[FREG] & (1< 1) + print("\tMOVEM.L (SP)+,%s\n", reglist); + else if(count == 1) + print("\tMOVE.L (SP)+,%s\n", reglist); + + print("\tUNLK A5\n"); + print("\tRTS\n"); + } + + /* called by the front end when a symbol is defined, so that the Xsymbol + * field can be initialized (p. 89) + * + * JOOP: added cfunc->name to label construction, to aid debugging + * 27-12-95: found a horrible bug and fixed it! + */ + static void defsymbol(p) Symbol p; { + if (p->scope >= LOCAL && p->sclass == STATIC) + p->x.name = stringf("%s_L.%d", cfunc->name, genlabel(1)); + else if (p->generated) + if(cfunc) + p->x.name = stringf("%s_L.%s", cfunc->name, p->name); + else + p->x.name = stringf("L.%s", p->name); + else if (p->scope == GLOBAL || p->sclass == EXTERN) + p->x.name = stringf("_%s", p->name); + else if (p->scope == CONSTANTS + && (isint(p->type) || isptr(p->type)) + && p->name[0] == '0' && p->name[1] == 'x') + p->x.name = stringf("$%s", &p->name[2]); /* hex */ + else + p->x.name = p->name; + } + + static void address(q, p, n) Symbol q, p; int n; { + if (p->scope == GLOBAL + || p->sclass == STATIC || p->sclass == EXTERN) + q->x.name = stringf("%s%s%d", + p->x.name, n >= 0 ? "+" : "", n); + else { + q->x.offset = p->x.offset + n; + q->x.name = stringd(q->x.offset); + } + } + static void defconst(ty, v) Value v; { + switch (ty) { + case C: print("\tDC.B %d\n", v.uc); return; + case S: print("\tDC.W %d\n", v.ss); return; + case I: print("\tDC.L %d\n", v.i ); return; + case U: print("\tDC.L $%x\n", v.u ); return; + case P: print("\tDC.L $%x\n", v.p ); return; + case F: + print("\tDC.L $%x\n", *(unsigned *)&v.f); + return; + case D: { + unsigned *p = (unsigned *)&v.d; + print("\tDC.L $%x\n", p[swap]); + print("\tDC.L $%x\n", p[1 - swap]); + return; + } + } + assert(0); + } + static void defaddress(p) Symbol p; { + print( "\tdc.l\t%s\t; defaddress\n", p->x.name ) ; + } + + static void defstring(n, str) int n; char *str; { + char *s; int count = 0, instr = 0 ; + + print( "*\tdefstring\n" ) ; + print( "\tdc.b\t" ) ; + for (s = str; s < str + n; s++) { + int c = (*s) & 0377 ; + if( count == 40 ) { + print( instr ? "'\n\tdc.b\t" : "\n\tdc.b\t" ) ; instr = count = 0 ; + } + if( isprint(c) && c != '\'' && c != '\\' && c!= '"') { + if( !instr && count > 0 ) print( "," ) ; + print( instr ? "%c" : "'%c", c ) ; instr = 1 ; + } + else { + if( instr ) print( "'" ) ; + if( count > 0 ) print( "," ) ; + print( "%d", c ) ; + instr = 0 ; + } + count++ ; + } + print( instr ? "'\n" : "\n" ) ; + } + + static void export(p) Symbol p; { + print( "\txdef\t%s\n", p->x.name ) ; + } + static void import(p) Symbol p; { + if( p->ref > 0 ) + print( "\txref\t%s\n", p->x.name ) ; + } + static void global(p) Symbol p; { + if( p->type->align > 1 ) + print( "\tcnop\t0,%d\n", p->type->align ) ; + print( "%s:\n", p->x.name ) ; + } + + static void space(n) { + #if 0 + int i ; + + print( "*\tspace(%d)\n", n ) ; + while( n >= 16 ) { + print( "\tdc.b\t0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n" ) ; + n -= 16 ; + } + + if( n == 0 ) return ; + print( "\tdc.b\t0" ) ; n-- ; + while( n > 0 ) + { print( ",0" ) ; n-- ; } + print( "\n" ) ; + #else + print( "*\tspace(%d)\n", n ) ; + print( "\tDS.B %d\n", n); + #endif + } + + Interface m68kIR = { + 1, 1, 0, /* char */ + 2, 2, 0, /* short */ + 4, 2, 0, /* int */ + 4, 2, 1, /* float */ + 8, 2, 1, /* double */ + 4, 2, 0, /* T * */ + 0, 2, 0, /* struct so that ARGB keeps stack aligned */ + 0, /* little_endian */ + 0, /* mulops_calls */ + 0, /* wants_callb */ + 1, /* wants_argb */ + 0, /* left_to_right */ + 0, /* wants_dag */ + address, + blockbeg, + blockend, + defaddress, + defconst, + defstring, + defsymbol, + emit, + export, + function, + gen, + global, + import, + local, + progbeg, + progend, + segment, + space, + 0, + stabend, + 0, + 0, + stabline, + 0, + 0, + {1, blkfetch, blkstore, blkloop, + _label, + _rule, + _nts, + _kids, + _opname, + _arity, + _string, + _templates, + _isinstruction, + _ntname, + emit2, + doarg, + target, + clobber, + } + }; + + /* symname - print prefix, p's name, declaration source coordinate, suffix */ + static void symname(p) Symbol p; { + if (p) + print("%s@%w.%d", p->name, &p->src, p->src.x); + else + print("0"); + } + + /* stabend - finalize stab output */ + /* JOOP: currently not needed ??? */ + static void stabend(cp, p, cpp, sp, stab) Coordinate *cp, **cpp; Symbol p, *sp, *stab; { + #if 0 + int i; + + symname(p); + print("\n"); + if (cpp && sp) + for (i = 0; cpp[i] && sp[i]; i++) { + print("%w.%d: ", cpp[i], cpp[i]->x); + symname(sp[i]); + print("\n"); + } + #endif + } + + /* stabline - emit line number information for source coordinate *cp */ + /* JOOP: example output this generates when '-g' is used + * ;mod.c:14.1: printf("second case %d\n",c%b); + * Suggestions whether or not the line info should stay are welcome + * + * Source level debugging now works! with Bdebug from Barfly atleast + * If only -g is specified then only source level debug is active + * if you specify -g9 then the C-source will also be printed to the + * assembler file. + */ + static void stabline(cp) Coordinate *cp; { + if(glevel == 1 && annotate == 1) + print(";%s\n",cp->source_line); + else if (glevel>1 && annotate) { + print("\tDEBUG\t%d\n",cp->y); + print(";%s\n",cp->source_line); + } + else + print("\tDEBUG\t%d\n",cp->y); + } + + char *input_file = ""; + + static void progbeg(argc, argv) char *argv[]; { + int i; + + { + union { + char c; + int i; + } u; + u.i = 0; + u.c = 1; + swap = (u.i == 1) != IR->little_endian; + } + parseflags(argc, argv); + + for(i=0;i 1) { + #ifdef AMIGA + + BPTR fh_lock; + char namebuffer[256]; /* FILENAME_MAX=4096 in stdio.h, way too big ? */ + + fh_lock=Lock((unsigned char *)firstfile, ACCESS_READ); + if(fh_lock) /* got the lock, now get the complete path/filename */ + { /* should never fail but better safe then sorry */ + NameFromLock(fh_lock, (unsigned char *)namebuffer, + sizeof(namebuffer)); + print("\tDSOURCE\t%s\n", namebuffer); + UnLock(fh_lock); + } + else /* in case it fails, use the file name currently being compiled */ + #endif /* AMIGA */ + print("\tDSOURCE\t%s\n", firstfile); + } + cseg = 0; + } diff -rc --new-file lcc35/src/output.c lcc/src/output.c *** lcc35/src/output.c Fri Feb 2 20:19:10 1996 --- lcc/src/output.c Thu Feb 29 18:38:02 1996 *************** *** 1,5 **** --- 1,10 ---- #include "c.h" + #if defined(AMIGA) && defined(__SASC) + #include + FILE *so = stdout; /* by-pass SAS/C autoinitializer bug */ + #endif + int outfd = 1; int errfd = 2; static char buf1[4*1024], buf2[512]; /* output buffers */ *************** *** 21,27 **** char *bp = buf1; /* current output buffer pointer */ ! void outs(s) char *s; { char *p; for (p = bp; (*p = *s++) != 0; p++) --- 26,34 ---- char *bp = buf1; /* current output buffer pointer */ ! static void outs80 ARGS((char *)); ! ! static void outs80(s) char *s; { char *p; for (p = bp; (*p = *s++) != 0; p++) *************** *** 30,35 **** --- 37,52 ---- if (bp > io[fd]->limit) outflush(); } + + void outs(s) char *s; { + char buf[80]; + + for (buf[79]=0; *s; s+=strlen(buf)) { + strncpy(buf, s, 79); + outs80(buf); + } + } + void print VARARGS((char *fmt, ...), (fmt, va_alist),char *fmt; va_dcl) { va_list ap; diff -rc --new-file lcc35/src/run lcc/src/run *** lcc35/src/run Fri Feb 2 20:19:49 1996 --- lcc/src/run Fri Feb 9 23:53:44 1996 *************** *** 18,25 **** BUILDDIR=${BUILDDIR-../} echo ${BUILDDIR}rcc -target=$target $2: 1>&2 ! $LCC -N -S -B${BUILDDIR} -I../../../include/$include -Ualpha -Usun -Uvax -Umips -Ux86 \ ! -Wf-errout=$2.2 -D`expr "$1" : '\(.*\)-'` -Wf-g0 -Wf-target=$target ../../../tst/$2.c if [ $? != 0 ]; then remotehost=noexecute; fi sed 's|\.\./\.\./\.\./tst/||g' <$2.2 >$2.tmp; mv $2.tmp $2.2 diff ../../../tst/$2.2 $2.2 --- 18,25 ---- BUILDDIR=${BUILDDIR-../} echo ${BUILDDIR}rcc -target=$target $2: 1>&2 ! $LCC -S -B${BUILDDIR} -I///include/$include -Ualpha -Usun -Uvax -Umips -Ux86 \ ! -Wf-errout=$2.2 -Wf-g0 -Wf-target=$target ///tst/$2.c if [ $? != 0 ]; then remotehost=noexecute; fi sed 's|\.\./\.\./\.\./tst/||g' <$2.2 >$2.tmp; mv $2.tmp $2.2 diff ../../../tst/$2.2 $2.2 *************** *** 27,39 **** mv $2.s $2.sbk cp $2.sbk $2.s else ! if diff $2.sbk $2.s; then exit 0; fi fi case "$remotehost" in noexecute) exit 0 ;; ""|"-") echo " executing" $2: 1>&2 ! $LCC -o $2 $2.s -lm; ./$2 <../../../tst/$2.0 >$2.1 ;; *) echo " executing" $2 on $remotehost: 1>&2 rcp $2.s $remotehost: if expr "$remotehost" : '.*@' >/dev/null ; then --- 27,39 ---- mv $2.s $2.sbk cp $2.sbk $2.s else ! if diff $2.sbk $2.s | tail -100; then exit 0; fi fi case "$remotehost" in noexecute) exit 0 ;; ""|"-") echo " executing" $2: 1>&2 ! $LCC -o $2 $2.s ; ./$2 <../../../tst/$2.0 >$2.1 ;; *) echo " executing" $2 on $remotehost: 1>&2 rcp $2.s $remotehost: if expr "$remotehost" : '.*@' >/dev/null ; then diff -rc --new-file lcc35/src/simp.c lcc/src/simp.c *** lcc35/src/simp.c Fri Feb 2 20:19:13 1996 --- lcc/src/simp.c Sun Feb 11 16:53:24 1996 *************** *** 20,25 **** --- 20,26 ---- p = tree(CNST+ttob(TTYPE), TTYPE, NULL, NULL);\ EXPR;\ return p; } + #if 0 #define xcvtcnst(FTYPE,TTYPE,VAR,MIN,MAX,EXPR) \ if (l->op == CNST+FTYPE) {\ if (needconst && (VAR < MIN || VAR > MAX))\ *************** *** 28,33 **** --- 29,44 ---- p = tree(CNST+ttob(TTYPE), TTYPE, NULL, NULL);\ EXPR;\ return p; } } + #else + #define xcvtcnst(FTYPE,TTYPE,VAR,MIN,MAX,EXPR) \ + if (l->op == CNST+FTYPE) {\ + if (needconst && (VAR > MAX || VAR < MIN))\ + warning("overflow in constant expression\n");\ + if (needconst || VAR >= MIN && VAR <= MAX) {\ + p = tree(CNST+ttob(TTYPE), TTYPE, NULL, NULL);\ + EXPR;\ + return p; } } + #endif #define identity(X,Y,TYPE,VAR,VAL) \ if (X->op == CNST+TYPE && X->u.v.VAR == VAL)\ return Y diff -rc --new-file lcc35/src/stmt.c lcc/src/stmt.c *** lcc35/src/stmt.c Fri Feb 2 20:19:14 1996 --- lcc/src/stmt.c Thu Feb 22 18:26:54 1996 *************** *** 62,67 **** --- 62,73 ---- cp->u.point.src = p ? *p : src; cp->u.point.point = npoints; + + #ifdef AMIGA + if(annotate) + cp->u.point.src.source_line = stringn(line, strchr(line,'\n')-line); + #endif + if (ncalled > 0) { int n = findcount(cp->u.point.src.file, cp->u.point.src.x, cp->u.point.src.y); *************** *** 203,209 **** --- 209,219 ---- listnodes(e, 0, 0); if (nodecount == 0 || nodecount > 200) walk(NULL, 0, 0); + #ifdef AMIGA + else if (glevel>1) walk(NULL, 0, 0); + #else else if (glevel) walk(NULL, 0, 0); + #endif deallocate(STMT); } expect(';'); break; diff -rc --new-file lcc35/src/symbolic.c lcc/src/symbolic.c *** lcc35/src/symbolic.c Fri Feb 2 20:18:57 1996 --- lcc/src/symbolic.c Sat Mar 16 18:11:22 1996 *************** *** 348,351 **** --- 348,357 ---- if (cp->file) print("%s:", cp->file); print("%d.%d:\n", cp->y, cp->x); + #ifdef AMIGA + /* JOOP: to keep in the spirit of mc68030.md. Only activate C-sourceline */ + /* printing when annotate is requested */ + if(annotate) + print("*%s\n",cp->source_line); + #endif }