From 94e069fde1c555d34368104e019113df6495696c Mon Sep 17 00:00:00 2001 From: em Date: Tue, 9 Oct 1984 10:36:29 +0000 Subject: [PATCH] Initial revision --- lib/vax4/sedf | 104 ++ mach/vax4/cg/READ_ME | 8 + mach/vax4/cg/mach.c | 270 +++ mach/vax4/cg/mach.h | 23 + mach/vax4/cg/table | 4016 ++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 4421 insertions(+) create mode 100644 lib/vax4/sedf create mode 100644 mach/vax4/cg/READ_ME create mode 100644 mach/vax4/cg/mach.c create mode 100644 mach/vax4/cg/mach.h create mode 100644 mach/vax4/cg/table diff --git a/lib/vax4/sedf b/lib/vax4/sedf new file mode 100644 index 000000000..b26db01c9 --- /dev/null +++ b/lib/vax4/sedf @@ -0,0 +1,104 @@ +# $Header$ +/movab/ { +s/movab 1(\(.*\)),\1$/incl \1/ +s/movab -1(\(.*\)),\1$/decl \1/ +s/movab \([0-9]*\)(\(.*\)),\2$/addl2 $\1,\2/ +s/movab -\([0-9]*\)(\(.*\)),\2$/subl2 $\1,\2/ +s/movab 0(\(.*\)) \[\(.*\)\],\1$/addl2 \2,\1/ +s/movab 0(\(.*\)) \[\(.*\)\],\2$/addl2 \1,\2/ +} +/$0/ { +s/movz[bw]\([wl]\) $0,/clr\1 / +s/mov\([bwl]\) $0,/clr\1 / +s/cvt[bw]\([wl]\) $0,/clr\1 / +} +/add/ { +s/\(add[fdlw]\)3 \(.*\),\(.*\),\3$/\12 \2,\3/ +s/\(add[fdlw]\)3 \(.*\),\(.*\),\2$/\12 \3,\2/ +s/add\([wl]\)2 \$-\([0-9]*\),/sub\12 $\2,/ +s/add\([wl]\)3 \$-\([0-9]*\),/sub\13 $\2,/ +s/add\([wl]\)3 \(.*\),\$-\([0-9]*\),/sub\13 $\3,\2,/ +} +/mul/ { +s/\(mul[fdlw]\)3 \(.*\),\(.*\),\3$/\12 \2,\3/ +s/\(mul[fdlw]\)3 \(.*\),\(.*\),\2$/\12 \3,\2/ +} +/sub/ { +s/\(sub[fdlw]\)3 \(.*\),\(.*\),\3$/\12 \2,\3/ +s/sub\([wl]\)2 \$-\([0-9]*\),/add\12 $\2,/ +s/sub\([wl]\)3 \$-\([0-9]*\),/add\13 $\2,/ +} +/div/s/\(div[fdlw]\)3 \(.*\),\(.*\),\3$/\12 \2,\3/ +/bi/s/\(bi[cs][lw]\)3 \(.*\),\(.*\),\3$/\12 \2,\3/ +/bis/s/\(bis[lw]\)3 \(.*\),\(.*\),\2$/\12 \3,\2/ +/xor/ { +s/\(xor[lw]\)3 \(.*\),\(.*\),\3$/\12 \2,\3/ +s/\(xor[lw]\)3 \(.*\),\(.*\),\2$/\12 \3,\2/ +} +/$1/ { +s/add\([wl]\)2 \$1,/inc\1 / +s/sub\([wl]\)2 \$1,/dec\1 / +} +/$-1/ { +s/add\([wl]\)2 \$-1,/dec\1 / +s/sub\([wl]\)2 \$-1,/inc\1 / +} +/cmp[bwl].*$0/ { +N +s/cmp\([bwl]\) \(.*\),$0$/tst\1 \2/ +s/cmp\([bwl]\) $0,\(.*\)\njneq/tst\1 \2\ +jneq/ +s/cmp\([bwl]\) $0,\(.*\)\njeql/tst\1 \2\ +jeql/ +s/cmp\([bwl]\) $0,\(.*\)\njgtr/tst\1 \2\ +jlss/ +s/cmp\([bwl]\) $0,\(.*\)\njlss/tst\1 \2\ +jgtr/ +s/cmp\([bwl]\) $0,\(.*\)\njgeq/tst\1 \2\ +jleq/ +s/cmp\([bwl]\) $0,\(.*\)\njleq/tst\1 \2\ +jgeq/ +P +D +} +/(sp)+/ { +N +s/movl (sp)+,\(.*\)\npushl \1$/movl (sp),\1/ +s/tst[wl] (sp)+\nmovl fp,sp$/movl fp,sp/ +s/tst\([wl]\) (sp)+\nmov\1 \(.*\),-(sp)/mov\1 \2,(sp)/ +s/tst\([wl]\) (sp)+\nclr\1 -(sp)/clr\1 (sp)/ +s/tst\([wl]\) (sp)+\nmovzb\1 \(.*\),-(sp)/movzb\1 \2,(sp)/ +s/tst\([wl]\) (sp)+\ncvtb\1 \(.*\),-(sp)/cvtb\1 \2,(sp)/ +s/tst\([wl]\) (sp)+\ntst\1 \(.*\)$/mov\1 \2,(sp)+/ +s/tstl (sp)+\npushl \(.*\)$/movl \1,(sp)/ +s/tstl (sp)+\npusha\([bwlq]\) \(.*\)$/mova\1 \2,(sp)/ +P +D +} +/^addl2 .*,sp/ { +N +s/addl2 .*,sp\nmovl fp,sp$/movl fp,sp/ +s/^addl2 $6,sp\nmovw \(.*\),-(sp)/tstl (sp)+\ +movw \1,(sp)/ +s/^addl2 $6,sp\nclrw -(sp)/tstl (sp)+\ +clrw (sp)/ +s/^addl2 $8,sp\nmovq \(.*\),-(sp)/movq \1,(sp)/ +P +D +} +/clrw -(sp)/ { +N +s/clrw -(sp)\nmovw \($[0-9]*\),-(sp)/pushl \1/ +s/clrw -(sp)\nmnegw $\([0-9]*\),-(sp)/movzwl $-\1,-(sp)/ +s/clrw -(sp)\nmovw \(.*\),-(sp)/movzwl \1,-(sp)/ +s/clrw -(sp)\ncvtbw \(\$[0-9]*\),-(sp)/pushl \1/ +s/clrw -(sp)\ncvtbw \(\$.*\),-(sp)/movzwl \1,-(sp)/ +P +D +} +/mov/ { +N +s/mov\([wl]\) \(.*\),\(.*\)\ntst\1 \3$/mov\1 \2,\3/ +P +D +} diff --git a/mach/vax4/cg/READ_ME b/mach/vax4/cg/READ_ME new file mode 100644 index 000000000..6d6d36100 --- /dev/null +++ b/mach/vax4/cg/READ_ME @@ -0,0 +1,8 @@ +--------- $Header$ -------- +The file "table" is too large. The "cgg" program cannot generate +"tables.h" and "tables.c" on a PDP 11/44. +Therefore the distribution includes two files "tables1.c" and "tables1.h", +which you can copy to "tables.c" and "tables.h". +Make sure "tables.c" and "tables.h" are newer than "table", +before trying again. They also must be newer than the "cgg" program +(../../../lib/cgg). diff --git a/mach/vax4/cg/mach.c b/mach/vax4/cg/mach.c new file mode 100644 index 000000000..7d5a296de --- /dev/null +++ b/mach/vax4/cg/mach.c @@ -0,0 +1,270 @@ +#ifndef NORCSID +static char rcsid[] = "$Header$"; +#endif +/* + * (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands. + * + * This product is part of the Amsterdam Compiler Kit. + * + * Permission to use, sell, duplicate or disclose this software must be + * obtained in writing. Requests for such permissions may be sent to + * + * Dr. Andrew S. Tanenbaum + * Wiskundig Seminarium + * Vrije Universiteit + * Postbox 7161 + * 1007 MC Amsterdam + * The Netherlands + * + */ + +/* Machine dependent back end routines for the VAX using 4-byte words + */ + +con_part(sz,w) register sz; word w; { + + /* Byte order: | 3 | 2 | 1 | 0 | */ + + /* Align new bytes on boundary of its on size. */ + while (part_size % sz) part_size++; + + if (part_size == EM_WSIZE) + part_flush(); + if (sz == 1 || sz == 2) { + /* Smaller than a machineword. */ + w &= (sz == 1 ? 0xFF : 0xFFFF); + w <<= 8 * part_size; + part_word |= w; + } else { + assert(sz == 4); + part_word = w; + } + part_size += sz; +} /* con_part */ + +con_mult(sz) word sz; { + + if (sz != 4) + fatal("bad icon/ucon size"); + fprintf(codefile,".long\t%s\n",str); +} + +mes(mesno) word mesno ; { + while (getarg(any_ptyp) != sp_cend ); +} + +con_float() { + + /* Insert a dot at the right position, if it is not present, + * to make the floating point constant acceptable to the assembler. + */ + register char * c; + extern char * index(); + + if (argval != 4 && argval != 8) + fatal("bad fcon size"); + if (argval == 8) + fprintf(codefile,".double\t0d"); + else fprintf(codefile,".float\t0f"); + + if (index(str,'.') != (char *) 0) { + fprintf(codefile,"%s\n",str); + + /* There must be a dot after the `e' or - if the `e' is not present - + * at the end. + */ + } else if ((c = index(str,'e')) != (char *) 0) { + *c++ = '\0'; + fprintf(codefile,"%s.e%s\n",str,c--); + *c = 'e'; + } else fprintf(codefile,"%s.\n",str); +} /* con_float */ + +#ifndef REGVARS +prolog(nlocals) full nlocals; { + + fprintf(codefile,"\tpushl\tfp\n\tmovl\tsp,fp\n"); + if (nlocals == 0) + return; + if (nlocals == 4) + fprintf(codefile,"\tclrl\t-(sp)\n"); + else if (nlocals == 8) + fprintf(codefile,"\tclrq\t-(sp)\n"); + else + fprintf(codefile,"\tsubl2\t$%ld,sp\n",nlocals); +} + +#endif REGVARS + +char *segname[] = { + ".text", /* SEGTXT */ + ".data", /* SEGCON */ + ".data", /* SEGROM */ + ".data" /* SEGBSS */ +}; + +#ifdef REGVARS +int EM_BSIZE; /* Difference between AB and LB. */ +static int nlocals; /* Number of local variables. */ + +#define NR_REG 8 /* Number of registers. */ +#define FIRST_REG 4 +#define LAST_REG (FIRST_REG + NR_REG - 1) + +prolog(n) { /* Save number of locals. */ + nlocals = n; +} + +/* + * Structure to store information about the registers to be stored. + */ +static struct s_reg { + char * sr_str; /* Name of register used. */ + long sr_off; /* Offset from LB. */ + int sr_size;/* Size in bytes. */ +} a_reg[NR_REG + 1], *p_reg; + +i_regsave() { /* Initialize saving of registers. */ + EM_BSIZE = 0; + p_reg = a_reg; +} + +regsave(str, off, size) char * str; long off; int size; { + + /* Called for each register to be saved. */ + + p_reg->sr_str = str; + p_reg->sr_off = off; + (p_reg++)->sr_size = size; + fprintf(codefile, + "\t# Local %ld, size %d, to register %s\n", + off, size, str + ); +} + +f_regsave() { + + register struct s_reg * p; + register int mask; + register int i; + register int count; + + mask = 0; + count = p_reg - a_reg; + for (p = a_reg; p < p_reg; p++) { + /* For each register to be saved, set a bit in the + * mask corresponding to its number. + */ + i = atoi(p->sr_str + 1); + if (p->sr_size <= 4) + mask |= (1 << i); + else { + mask |= (3 << i); + count++; + } + } + + /* Generate code to save registers. */ + if (count > 2) + fprintf(codefile, "pushr\t$%d\n", mask); + else + for (i = FIRST_REG; i <= LAST_REG; i++) { + /* For all registers that can be used, + * see if it must be saved, and do that as cheap + * as possible. + */ + if (((mask >> i) & 03) == 03) { + fprintf(codefile, "movq\tr%d,-(sp)\n",i); + break; + } else if ((1 << i) & mask) { + if (count == 1) + fprintf(codefile,"pushl\tr%d\n",i); + else + fprintf(codefile,"pushr\t$%d\n",mask); + break; + } + } + + /* Save a word indicating which registers were saved. + * The count uniquely specifies which registers were saved, because + * registers are always allocated consecutively within a class, + * starting from FIRST_REG. I only have one class. + */ + fprintf(codefile, "pushl\t$%d\n", count); + + /* Compute AB - LB. */ + EM_BSIZE = 4 * count + 12; + + /* Now finish the procedure prolog. */ + fprintf(codefile, "pushl\tfp\nmovl\tsp,fp\n"); + + /* Emit code to initialize parameters in registers. */ + for (p = a_reg; p < p_reg; p++) { + if (p->sr_off >= 0) { + if (p->sr_size == 4) { + fprintf(codefile, + "movl\t%ld(fp),%s\n", + p->sr_off + EM_BSIZE, p->sr_str + ); + } else if (p->sr_size == 8) { + fprintf(codefile, + "movq\t%ld(fp),%s\n", + p->sr_off + EM_BSIZE, p->sr_str + ); + } + } + } + + /* Generate room for locals. */ + if (nlocals == 0) + return; + if (nlocals == 4) + fprintf(codefile,"clrl\t-(sp)\n"); + else if (nlocals == 8) + fprintf(codefile,"clrq\t-(sp)\n"); + else + fprintf(codefile,"subl2\t$%ld,sp\n",nlocals); + +} /* f_regsave */ + +regreturn() { + + fprintf(codefile, "jmp\t.return\n"); +} /* regreturn */ + +regscore(off, size, typ, score, totyp) long off; { + + register int i; + + i = score; /* Local/parameter is used score times. */ + + /* If the offset doesn't fit in a byte, word-offset is used, + * which is one byte more expensive. + */ + if (off > 109 || off < -128) i *= 2; /* Word offset. */ + + /* 109: guestimate. We don't know AB -LB yet. + * 109 is the number if there are two registervariables. + */ + + /* Compute cost of initialization for parameters. */ + if (off > 109) + i -= 5; + else if (off >= 0) + i -= 4; + + if (typ == reg_pointer) + i += score; /* Sometimes saves an instruction. */ + else if (typ == reg_loop) + i += 5; + + i -= 2; /* Cost of save. */ + + /* Actually the first registers are more expensive, but then + * the following registers are cheaper. + */ + + return (i); +} /* regscore */ + +#endif REGVARS diff --git a/mach/vax4/cg/mach.h b/mach/vax4/cg/mach.h new file mode 100644 index 000000000..1e62f746d --- /dev/null +++ b/mach/vax4/cg/mach.h @@ -0,0 +1,23 @@ +/* $Header$ */ +#define ex_ap(x) fprintf(codefile,".globl\t%s\n",x) +#define in_ap(x) /* nothing */ + +#define newilb(x) fprintf(codefile,"%s:\n",x) +#define newdlb(x) fprintf(codefile,"%s:\n",x) +#define dlbdlb(s1,s2) fprintf(codefile,"%s = %s\n",s1,s2) +#define newlbss(x,f) fprintf(codefile,"%s:.space\t%ld\n",x,f) + +#define cst_fmt "$%ld" +#define off_fmt "%ld" +#define ilb_fmt "I%03x%04x" +#define dlb_fmt "_%d" +#define hol_fmt "hol%d" + +#define hol_off "%ld+hol%d" + +#define con_cst(w) fprintf(codefile,".long\t%ld\n",w) +#define con_ilb(x) fprintf(codefile,".long\t%s\n",x) +#define con_dlb(x) fprintf(codefile,".long\t%s\n",x) + +#define id_first '_' +#define BSS_INIT 0 diff --git a/mach/vax4/cg/table b/mach/vax4/cg/table new file mode 100644 index 000000000..0d7504b42 --- /dev/null +++ b/mach/vax4/cg/table @@ -0,0 +1,4016 @@ +"$Header$" +#define SL 8 +#define SSL "8" +#define DL 0 +#define SDL "" + +#define LOCLABS /* define if target assembler recognizes local labels */ +#define REGVARS /* define for register variables */ + +/*#define DORCK /* define if you want RCK */ +/*#define FLOAT4 /* define if you want better 4-byte FP arithmetic */ + +EM_PSIZE = 4 +EM_WSIZE = 4 +#ifndef REGVARS +EM_BSIZE = SL +#endif REGVARS + +#define NC nocoercions : + +/**************************************************************** + * VAX 11 Back end table. * + * Author : Ceriel J.H. Jacobs, Duk Bekema * + * * + * Wordsize = 4 bytes * + * Pointersize = 4 bytes * + * * + * There is hardly any instruction timing information available * + * for the DEC-VAX machines. Timing of addressing modes was done* + * by counting the memory references and multiplying them by * + * 3. 300 nanosec seems to be a typical memory reference time.* + * However, the VAX can be much faster, if the "cache hit rate" * + * is high. * + * Assumed hardware : VAX-11/7?0 with Floating Point Acc. * + ****************************************************************/ + +REGISTERS: +LB = ("fp",4),LocaLBase. +R0 = ("r0",4),REG,RRET. +R1 = ("r1",4),REG. +R2 = ("r2",4),REG. +R3 = ("r3",4),REG. +#ifdef REGVARS +R4 = ("r4",4) regvar,RREG. +R5 = ("r5",4) regvar,RREG. +R6 = ("r6",4) regvar,RREG. +R7 = ("r7",4) regvar,RREG. +R8 = ("r8",4) regvar,RREG. +R9 = ("r9",4) regvar,RREG. +RA = ("r10",4) regvar,RREG. +RB = ("r11",4) regvar,RREG. +#else REGVARS +R4 = ("r4",4),REG. +R5 = ("r5",4),REG. +R6 = ("r6",4),REG. +R7 = ("r7",4),REG. +R8 = ("r8",4),REG. +R9 = ("r9",4),REG. +RA = ("r10",4),REG. +RB = ("r11",4),REG. +#endif REGVARS +QR0 = ("r0",8,R0,R1),QREG,QRET. +QR2 = ("r2",8,R2,R3),QREG. +QR4 = ("r4",8,R4,R5),QREG. +QR6 = ("r6",8,R6,R7),QREG. +QR8 = ("r8",8,R8,R9),QREG. +QRA = ("r10",8,RA,RB),QREG. +QR1 = ("r1",8,R1,R2),QREG. +QR3 = ("r3",8,R3,R4),QREG. +QR5 = ("r5",8,R5,R6),QREG. +QR7 = ("r7",8,R7,R8),QREG. +QR9 = ("r9",8,R9,RA),QREG. + +TOKENS: + +/* First some EM machine tokens */ +CONST1 = {INT num;} 4 cost=(4,3) "$%[num]" +CONST2 = {INT num;} 4 cost=(4,3) "$%[num]" +CONST4 = {INT num;} 4 cost=(4,3) "$%[num]" +CONST8 = {STRING ind;} 8 cost=(8,6) "$%[ind]" +FCONST8 = {INT num;} 8 cost=(8,6) "$0f%[num].0" +LOCAL1 = {INT num,size;} 4 cost=(2,6) "%[num](fp)" +LOCAL2 = {INT num,size;} 4 cost=(2,6) "%[num](fp)" +LOCAL4 = {INT num,size;} 4 cost=(2,6) "%[num](fp)" +LOCAL8 = {INT num,size;} 8 cost=(2,6) "%[num](fp)" +ADDR_LOCAL = {INT num;} 4 cost=(2,6) "%[num](fp)" +ADDR_EXTERNAL = {STRING ind;} 4 cost=(4,6) "%[ind]" +EXTERNAL1 = {STRING ind;} 4 cost=(4,6) "%[ind]" +EXTERNAL2 = {STRING ind;} 4 cost=(4,6) "%[ind]" +EXTERNAL4 = {STRING ind;} 4 cost=(4,6) "%[ind]" +EXTERNAL8 = {STRING ind;} 8 cost=(4,9) "%[ind]" +DOUBLE = {STRING ind;} 4 cost=(4,6) "$%[ind]" +/* Now tokens for the target machine */ +regdef1 = {REGISTER reg;} 4 cost=(0,3) "(%[reg])" +regdef2 = {REGISTER reg;} 4 cost=(0,3) "(%[reg])" +regdef4 = {REGISTER reg;} 4 cost=(0,3) "(%[reg])" +regdef8 = {REGISTER reg;} 8 cost=(0,6) "(%[reg])" +#ifdef REGVARS +reginc1 = {REGISTER reg;} 4 cost=(0,3) "(%[reg])+" +reginc2 = {REGISTER reg;} 4 cost=(0,3) "(%[reg])+" +reginc4 = {REGISTER reg;} 4 cost=(0,3) "(%[reg])+" +reginc8 = {REGISTER reg;} 8 cost=(0,6) "(%[reg])+" +regdec1 = {REGISTER reg;} 4 cost=(0,3) "-(%[reg])" +regdec2 = {REGISTER reg;} 4 cost=(0,3) "-(%[reg])" +regdec4 = {REGISTER reg;} 4 cost=(0,3) "-(%[reg])" +regdec8 = {REGISTER reg;} 8 cost=(0,6) "-(%[reg])" +#endif REGVARS +displ1 = {REGISTER reg; STRING ind;} 4 cost=(2,6) "%[ind](%[reg])" +displ2 = {REGISTER reg; STRING ind;} 4 cost=(2,6) "%[ind](%[reg])" +displ4 = {REGISTER reg; STRING ind;} 4 cost=(2,6) "%[ind](%[reg])" +displ8 = {REGISTER reg; STRING ind;} 8 cost=(2,9) "%[ind](%[reg])" +displdef1 = {REGISTER reg; STRING ind;} 4 cost=(2,9) "*%[ind](%[reg])" +displdef2 = {REGISTER reg; STRING ind;} 4 cost=(2,9) "*%[ind](%[reg])" +displdef4 = {REGISTER reg; STRING ind;} 4 cost=(2,9) "*%[ind](%[reg])" +displdef8 = {REGISTER reg; STRING ind;} 8 cost=(2,12) "*%[ind](%[reg])" +reldef1 = {STRING ind;} 4 cost=(4,9) "*%[ind]" +reldef2 = {STRING ind;} 4 cost=(4,9) "*%[ind]" +reldef4 = {STRING ind;} 4 cost=(4,9) "*%[ind]" +reldef8 = {STRING ind;} 8 cost=(4,12) "*%[ind]" +extind2 = {REGISTER ireg; STRING ind; } 4 cost=(5,10) "%[ind] [%[ireg]]" +extind4 = {REGISTER ireg; STRING ind; } 4 cost=(5,10) "%[ind] [%[ireg]]" +extind8 = {REGISTER ireg; STRING ind; } 8 cost=(5,13) "%[ind] [%[ireg]]" +displind1 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,10) + "%[ind](%[reg]) [%[ireg]]" +displind2 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,10) + "%[ind](%[reg]) [%[ireg]]" +displind4 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,10) + "%[ind](%[reg]) [%[ireg]]" +displind8 = {REGISTER ireg,reg; STRING ind;} 8 cost=(3,13) + "%[ind](%[reg]) [%[ireg]]" +extdefind1 = {REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]" +extdefind2 = {REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]" +extdefind4 = {REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]" +extdefind8 = {REGISTER ireg; STRING ind; } 8 cost=(5,16) "*%[ind] [%[ireg]]" +displdefind1 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,13) + "*%[ind](%[reg]) [%[ireg]]" +displdefind2 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,13) + "*%[ind](%[reg]) [%[ireg]]" +displdefind4 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,13) + "*%[ind](%[reg]) [%[ireg]]" +displdefind8 = {REGISTER ireg,reg; STRING ind;} 8 cost=(3,16) + "*%[ind](%[reg]) [%[ireg]]" + +/* Not really addressable modes */ +adispl = {REGISTER reg; STRING ind; } 4 cost=(4,6) "%[ind](%[reg])" +aextind2 = {REGISTER ireg; STRING ind; } 4 cost=(5,10) "%[ind] [%[ireg]]" +aextind4 = {REGISTER ireg; STRING ind; } 4 cost=(5,10) "%[ind] [%[ireg]]" +aextind8 = {REGISTER ireg; STRING ind; } 4 cost=(5,10) "%[ind] [%[ireg]]" +adisplind1 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,10) + "%[ind](%[reg]) [%[ireg]]" +adisplind2 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,10) + "%[ind](%[reg]) [%[ireg]]" +adisplind4 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,10) + "%[ind](%[reg]) [%[ireg]]" +adisplind8 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,10) + "%[ind](%[reg]) [%[ireg]]" +aextdefind1 = {REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]" +aextdefind2 = {REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]" +aextdefind4 = {REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]" +aextdefind8 = {REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]" +adispldefind1 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,13) + "*%[ind](%[reg]) [%[ireg]]" +adispldefind2 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,13) + "*%[ind](%[reg]) [%[ireg]]" +adispldefind4 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,13) + "*%[ind](%[reg]) [%[ireg]]" +adispldefind8 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,13) + "*%[ind](%[reg]) [%[ireg]]" + + +TOKENEXPRESSIONS: +CONST = CONST1 + CONST2 + CONST4 +source1 = regdef1 + displ1 + displdef1 + + EXTERNAL1 + reldef1 + CONST1 + LOCAL1 + + displind1 + extdefind1 + displdefind1 +#ifdef REGVARS + + reginc1 + regdec1 +#endif REGVARS +source2 = regdef2 + displ2 + displdef2 + + EXTERNAL2 + reldef2 + CONST2 + LOCAL2 + + extind2 + displind2 + extdefind2 + displdefind2 +#ifdef REGVARS + + reginc2 + regdec2 +#endif REGVARS +source4 = REG + regdef4 + displ4 + displdef4 + LocaLBase + + EXTERNAL4 + reldef4 + CONST + DOUBLE + LOCAL4 + + extind4 + displind4 + extdefind4 + displdefind4 +#ifdef REGVARS + + RREG + reginc4 + regdec4 +#endif REGVARS +noaddr4 = source4 - REG - displ4 - EXTERNAL4 +source8 = QREG + regdef8 + displ8 + displdef8 + + EXTERNAL8 + reldef8 + CONST8 + LOCAL8 + + extind8 + displind8 + extdefind8 + displdefind8 +#ifdef REGVARS + + reginc8 + regdec8 +#endif REGVARS +source1or2 = source1 + source2 +source1or2or4 = source1or2 + source4 +source2or4 = source2 + source4 +registers = QREG + REG +nonexist1 = adispl + ADDR_EXTERNAL + ADDR_LOCAL +aextind = aextind2 + aextind4 + aextind8 +adisplind = adisplind1 + adisplind2 + adisplind4 + adisplind8 +aextdefind = aextdefind1 + aextdefind2 + aextdefind4 + aextdefind8 +adispldefind = adispldefind1 + adispldefind2 + adispldefind4 + adispldefind8 +ind2 = extind2 + displind2 + extdefind2 + displdefind2 +ind4 = extind4 + displind4 + extdefind4 + displdefind4 +aind1 = adisplind1 + aextdefind1 + adispldefind1 +aind2 = aextind2 + adisplind2 + aextdefind2 + adispldefind2 +aind4 = aextind4 + adisplind4 + aextdefind4 + adispldefind4 +aind8 = aextind8 + adisplind8 + aextdefind8 + adispldefind8 +aind = aind1 + aind2 + aind4 + aind8 +nonexist = nonexist1 + aind +#ifdef REGVARS +regch4 = reginc1 + regdec1 + reginc2 + regdec2 + reginc4 + regdec4 +regch8 = reginc8 + regdec8 +regch = regch4 + regch8 +#endif REGVARS +displs = displ1 + displ2 + displ4 + displ8 + + regdef1 + regdef2 + regdef4 + regdef8 +#ifdef REGVARS + + regch +#endif REGVARS +displdefs = displdef1 + displdef2 + displdef4 + displdef8 +EXTERNALS = EXTERNAL1 + EXTERNAL2 + EXTERNAL4 + EXTERNAL8 +LOCALS = LOCAL1 + LOCAL2 + LOCAL4 + LOCAL8 +reldefs = reldef1 + reldef2 + reldef4 + reldef8 +displinds = displind1 + displind2 + displind4 + displind8 +extinds = extind2 + extind4 + extind8 +displdefinds = displdefind1 + displdefind2 + displdefind4 + displdefind8 +extdefinds = extdefind1 + extdefind2 + extdefind4 + extdefind8 +displaced = displs + displdefs + reldefs + + displinds + displdefinds + extdefinds +externals = EXTERNALS + displaced + extinds +extandloc = externals + LOCALS +#ifdef REGVARS +reg4 = REG + RREG +reg8 = QREG +#else REGVARS +reg4 = REG +reg8 = QREG +#endif REGVARS +sreg4 = REG * SCRATCH +nosreg4 = source4 - sreg4 +sreg8 = QREG * SCRATCH +nosreg8 = source8 - sreg8 +bigsource4 = source1or2or4 + nonexist +bigsource8 = source8 + FCONST8 +all = bigsource4 + bigsource8 +#ifdef REGVARS +#define REMEXTANDLOC remove(externals) remove(LOCALS,inreg(%[num])==0) +#define REMREG(x) remove(regch,%[reg]==regvar(x)) +#else REGVARS +#define REMEXTANDLOC remove(extandloc) +#endif REGVARS + +CODE: + +/******************************** + * Group 1 : Load instructions * + ********************************/ + +loc $1>=0 && $1<256 | | | {CONST1, $1} | | +loc $1>=256 && $1<65536 | | | {CONST2, $1} | | +loc | | | {CONST4, $1} | | +loc loc $1==0 && $2==0 | | | {FCONST8, 0} | | +ldc | | | {CONST8,$1} | | +#ifdef REGVARS +lol inreg($1)==2 | | | regvar($1) | | +#endif REGVARS +lol | | | {LOCAL4, $1, 4} | | +loe | | | {EXTERNAL4, $1} | | +#ifdef REGVARS +lil inreg($1)==2 | | REMREG($1) | {regdef4,regvar($1)} | | +#endif REGVARS +lil | | | {displdef4,LB, tostring($1)} | | +lof | | | | adp $1 loi 4 | +lal | | | {ADDR_LOCAL, $1} | | +lae | | | {ADDR_EXTERNAL, $1} | | +lxl $1==0 | | | LB | | +lxl $1>0 | | remove(ALL) + move({CONST4,$1},R0) + "jsb\t.lxl" + erase(R0) | R0 | | +lxa | | remove(ALL) + move({CONST4,$1},R0) + "jsb\t.lxa" + erase(R0) | R0 | | +loi $1==1 | NC adispl | + | {displ1,%[1.reg],%[1.ind]} | | +... | reg4 | | {regdef1,%[1]} | | +... | NC ADDR_LOCAL | | {LOCAL1, %[1.num],1} | | +... | displ4 | + | {displdef1,%[1.reg],%[1.ind]} | | +... | NC LOCAL4 | + | {displdef1, LB, tostring(%[1.num])} | | +... | NC ADDR_EXTERNAL | + | {EXTERNAL1,%[1.ind]} | | +... | NC EXTERNAL4 | + | {reldef1,%[1.ind]} | | +... | NC adisplind1 | + | {displind1,%[1.ireg],%[1.reg],%[1.ind]} | | +... | NC aextdefind1 | + | {extdefind1,%[1.ireg],%[1.ind]} | | +... | NC adispldefind1 | + | {displdefind1,%[1.ireg],%[1.reg],%[1.ind]} | | +loi $1==2 | NC adispl | + | {displ2,%[1.reg],%[1.ind]} | | +... | reg4 | | {regdef2,%[1]} | | +... | NC ADDR_LOCAL | | {LOCAL2, %[1.num],2} | | +... | displ4 | + | {displdef2,%[1.reg],%[1.ind]} | | +... | NC ADDR_EXTERNAL | + | {EXTERNAL2,%[1.ind]} | | +... | NC EXTERNAL4 | + | {reldef2,%[1.ind]} | | +... | NC aextind2 | + | {extind2,%[1.ireg],%[1.ind]} | | +... | NC adisplind2 | + | {displind2,%[1.ireg],%[1.reg],%[1.ind]} | | +... | NC aextdefind2 | + | {extdefind2,%[1.ireg],%[1.ind]} | | +... | NC adispldefind2 | + | {displdefind2,%[1.ireg],%[1.reg],%[1.ind]} | | +loi $1==4 | NC adispl | + | {displ4,%[1.reg],%[1.ind]} | | +... | reg4 | | {regdef4,%[1]} | | +... | NC ADDR_LOCAL | | {LOCAL4, %[1.num],4} | | +... | displ4 | + | {displdef4,%[1.reg],%[1.ind]} | | +... | NC ADDR_EXTERNAL | + | {EXTERNAL4,%[1.ind]} | | +... | NC EXTERNAL4 | + | {reldef4,%[1.ind]} | | +... | NC aextind4 | + | {extind4,%[1.ireg],%[1.ind]} | | +... | NC adisplind4 | + | {displind4,%[1.ireg],%[1.reg],%[1.ind]} | | +... | NC aextdefind4 | + | {extdefind4,%[1.ireg],%[1.ind]} | | +... | NC adispldefind4 | + | {displdefind4,%[1.ireg],%[1.reg],%[1.ind]} | | +loi $1==8 | NC adispl | + | {displ8,%[1.reg],%[1.ind]} | | +... | reg4 | | {regdef8,%[1]} | | +... | NC ADDR_LOCAL | | {LOCAL8, %[1.num],8} | | +... | displ4 | + | {displdef8,%[1.reg],%[1.ind]} | | +... | NC ADDR_EXTERNAL | + | {EXTERNAL8,%[1.ind]} | | +... | NC EXTERNAL4 | + | {reldef8,%[1.ind]} | | +... | NC aextind8 | + | {extind8,%[1.ireg],%[1.ind]} | | +... | NC adisplind8 | + | {displind8,%[1.ireg],%[1.reg],%[1.ind]} | | +... | NC aextdefind8 | + | {extdefind8,%[1.ireg],%[1.ind]} | | +... | NC adispldefind8 | + | {displdefind8,%[1.ireg],%[1.reg],%[1.ind]} | | +loi $1>8 && $1<=16 + | reg4 | | {displ8,%[1],tostring($1-8)} %[1] | loi $1-8 | +... | NC ADDR_EXTERNAL | + | {EXTERNAL8,%[1.ind]+"+"+tostring($1-8)} + %[1] | loi $1-8 | +... | NC ADDR_LOCAL | + | {LOCAL8,%[1.num]+$1-8,8} %[1] | loi $1-8 | +loi | sreg4 | + remove(ALL) + allocate(REG={CONST4,$1/4}) + "addl2\t$$$1,%[1]" +#ifdef LOCLABS + "1:\nmovl\t-(%[1]),-(sp)" + "sobgtr\t%[a],1b" +#else + "movl\t-(%[1]),-(sp)" + "sobgtr\t%[a],.-3" +#endif + erase(%[a]) | | | +los $1==4 | | remove(ALL) + move({CONST1,4},R0) + "jsb\t.los" + erase(R0) | | | +los !defined($1) | source1or2or4 | + remove(ALL) + move(%[1],R0) + "jsb\t.los" + erase(R0) | | | +ldl | | | {LOCAL8, $1, 8} | | +lde | | | {EXTERNAL8, $1} | | +ldf | | | | adp $1 loi 8 | +lpi | | | {ADDR_EXTERNAL, $1} | | + +/******************************** + * Group 2 : Store instructions * + ********************************/ + +#ifdef REGVARS +stl inreg($1)==2 | NC bigsource4 | + remove(regvar($1)) + move(%[1],regvar($1)) | | | +... | | remove(ALL) + "movl\t(sp)+,%(regvar($1)%)" | | | (3,7) +#endif REGVARS +stl | NC bigsource4 | + remove(displaced) + remove(LOCALS, %[num] <= $1+3 && %[num]+%[size] > $1) + move(%[1], {LOCAL4,$1, 4}) | | | +... | | remove(ALL) + "movl\t(sp)+,$1(fp)" | | | (5,14) +ste | NC bigsource4 | + remove(externals) + move(%[1],{EXTERNAL4, $1}) | | | +... | | remove(ALL) + "movl\t(sp)+,$1" | | | (7,14) +#ifdef REGVARS +sil inreg($1)==2 | NC bigsource4 | + REMEXTANDLOC + move(%[1],{regdef4,regvar($1)}) | | | +... | | remove(ALL) + "movl\t(sp)+,(%(regvar($1)%))" | | | (3,10) +#endif REGVARS +sil | NC bigsource4 | + REMEXTANDLOC + move(%[1],{displdef4,LB, tostring($1)}) | | | +... | | remove(ALL) + "movl\t(sp)+,*$1(fp)" | | | (5,17) +stf | | | | adp $1 sti 4 | +/*** C-problem: f(c) char c; { + write(1, &c, 1); + } + You don't know where the character is put in the word, + so the CEM-compiler generates: (shorts analogously) +***/ +lol lal sti $1==$2 && $3<4 | | | | | +/************************************************/ +sti $1==1 | NC adispl source1or2or4 | + REMEXTANDLOC + move(%[2],{displ1,%[1.reg],%[1.ind]}) | | | +... | NC ADDR_LOCAL source1or2or4 | + remove(displaced) + remove(LOCALS, + %[num]<=%[1.num] && %[num]+%[size]>%[1.num]) + move(%[2],{LOCAL1,%[1.num],1}) | | | +... | NC ADDR_LOCAL STACK | + "cvtlb\t(sp)+,%[1]" | | | (3,7)+%[1] +... | reg4 source1or2or4 | + REMEXTANDLOC + move(%[2],{regdef1,%[1]}) | | | +... | displ4 source1or2or4 | + REMEXTANDLOC + move(%[2],{displdef1,%[1.reg],%[1.ind]}) | | | +... | NC ADDR_EXTERNAL source1or2or4 | + remove(externals) + move(%[2],{EXTERNAL1,%[1.ind]}) | | | +... | NC EXTERNAL4 source1or2or4 | + REMEXTANDLOC + move(%[2],{reldef1,%[1.ind]}) | | | +... | NC adisplind1 source1or2or4 | + REMEXTANDLOC + move(%[2],{displind1,%[1.ireg],%[1.reg],%[1.ind]}) + | | | +... | NC aextdefind1 source1or2or4 | + REMEXTANDLOC + move(%[2],{extdefind1,%[1.ireg],%[1.ind]}) | | | +... | NC adispldefind1 source1or2or4 | + REMEXTANDLOC + move(%[2],{displdefind1,%[1.ireg],%[1.reg],%[1.ind]}) + | | | +sti $1==2 | NC adispl source1or2or4 | + REMEXTANDLOC + move(%[2],{displ2,%[1.reg],%[1.ind]}) | | | +... | reg4 source1or2or4 | + REMEXTANDLOC + move(%[2],{regdef2,%[1]}) | | | +... | NC ADDR_LOCAL source1or2or4 | + remove(displaced) + remove(LOCALS, + %[num]<=%[1.num] && %[num]+%[size]>%[1.num]) + move(%[2],{LOCAL2,%[1.num],2}) | | | +... | displ4 source1or2or4 | + REMEXTANDLOC + move(%[2],{displdef2,%[1.reg],%[1.ind]}) | | | +... | NC ADDR_EXTERNAL source1or2or4 | + remove(externals) + move(%[2],{EXTERNAL2,%[1.ind]}) | | | +... | NC EXTERNAL4 source1or2or4 | + REMEXTANDLOC + move(%[2],{reldef2,%[1.ind]}) | | | +... | NC aextind2 source1or2or4 | + remove(externals) + move(%[2],{extind2,%[1.ireg],%[1.ind]}) | | | +... | NC adisplind2 source1or2or4 | + REMEXTANDLOC + move(%[2],{displind2,%[1.ireg],%[1.reg],%[1.ind]}) | | | +... | NC aextdefind2 source1or2or4 | + REMEXTANDLOC + move(%[2],{extdefind2,%[1.ireg],%[1.ind]}) | | | +... | NC adispldefind2 source1or2or4 | + REMEXTANDLOC + move(%[2],{displdefind2,%[1.ireg],%[1.reg],%[1.ind]}) + | | | +sti $1==4 | NC adispl bigsource4 | + REMEXTANDLOC + move(%[2],{displ4,%[1.reg],%[1.ind]}) | | | +... | NC ADDR_LOCAL | | | stl %[1.num] | +... | NC ADDR_EXTERNAL | | | ste %[1.ind] | +... | adispl | + remove(ALL) + "movl\t(sp)+,%[1]" | | | (3,7)+%[1] +... | reg4 bigsource4 | + REMEXTANDLOC + move(%[2],{regdef4,%[1]}) | | | +... | displ4 bigsource4 | + REMEXTANDLOC + move(%[2],{displdef4,%[1.reg],%[1.ind]}) | | | +... | NC EXTERNAL4 bigsource4 | + REMEXTANDLOC + move(%[2],{reldef4,%[1.ind]}) | | | +... | NC aextind4 bigsource4 | + remove(externals) + move(%[2],{extind4,%[1.ireg],%[1.ind]}) | | | +... | NC adisplind4 bigsource4 | + REMEXTANDLOC + move(%[2],{displind4,%[1.ireg],%[1.reg],%[1.ind]}) | | | +... | NC aextdefind4 bigsource4 | + REMEXTANDLOC + move(%[2],{extdefind4,%[1.ireg],%[1.ind]}) | | | +... | NC adispldefind4 bigsource4 | + REMEXTANDLOC + move(%[2],{displdefind4,%[1.ireg],%[1.reg],%[1.ind]}) + | | | +sti $1==8 | NC adispl bigsource8 | + REMEXTANDLOC + move(%[2],{displ8,%[1.reg],%[1.ind]}) | | | +... | NC ADDR_LOCAL | | | sdl %[1.num] | +... | NC ADDR_EXTERNAL | | | sde %[1.ind] | +... | reg4 bigsource8 | + REMEXTANDLOC + move(%[2],{regdef8,%[1]}) | | | +... | displ4 bigsource8 | + REMEXTANDLOC + move(%[2],{displdef8,%[1.reg],%[1.ind]}) | | | +... | NC EXTERNAL4 bigsource8 | + REMEXTANDLOC + move(%[2],{reldef8,%[1.ind]}) | | | +... | NC aextind8 bigsource8 | + remove(externals) + move(%[2],{extind8,%[1.ireg],%[1.ind]}) | | | +... | NC adisplind8 bigsource8 | + REMEXTANDLOC + move(%[2],{displind8,%[1.ireg],%[1.reg],%[1.ind]}) | | | +... | NC aextdefind8 bigsource8 | + REMEXTANDLOC + move(%[2],{extdefind8,%[1.ireg],%[1.ind]}) | | | +... | NC adispldefind8 bigsource8 | + REMEXTANDLOC + move(%[2],{displdefind8,%[1.ireg],%[1.reg],%[1.ind]}) + | | | +sti | sreg4 | + remove(ALL) + allocate(REG={CONST4, $1/4}) +#ifdef LOCLABS + "1:\nmovl\t(sp)+,(%[1])+" + "sobgtr\t%[a],1b" +#else + "movl\t(sp)+,(%[1])+" + "sobgtr\t%[a],.-3" +#endif + erase(%[a]) | | | +sts $1==4 | STACK | + move({CONST1,4},R0) + "jsb\t.sts" + erase(R0) | | | +sts !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.sts" + erase(R0) | | | +sdl | NC bigsource8 | + remove(displaced) + remove(LOCALS, %[num]<=$1+7 && %[num]+%[size]>$1) + move(%[1],{LOCAL8,$1, 8}) | | | +... | NC bigsource4 bigsource4 | + remove(displaced) + remove(LOCALS, %[num]<=$1+7 && %[num]+%[size]>$1) + move(%[1], {LOCAL4,$1,4}) + move(%[2], {LOCAL4,$1+4,4}) | | | +... | | remove(ALL) + "movq\t(sp)+,$1(fp)" | | | (5,14) +sde | NC bigsource8 | + remove(externals) + move(%[1], {EXTERNAL8, $1}) | | | +... | bigsource4 bigsource4 | + remove(externals) + move(%[1], {EXTERNAL4, $1}) + move(%[2], {EXTERNAL4, $1+"+4"}) | | | +... | | remove(ALL) + "movq\t(sp)+,$1" | | | (7,14) +sdf | | | | adp $1 sti 8 | + +/******************************** + * Group 3 : Integer Arithmetic * + ********************************/ + +adi $1==4 | source4 sreg4 | + "addl2\t%[1],%[2]" + erase(%[2]) + setcc(%[2]) | %[2] | | (3,4) + %[1] +... | sreg4 source4 | + "addl2\t%[2],%[1]" + erase(%[1]) + setcc(%[1]) | %[1] | | (3,4) + %[2] +... | NC nosreg4 nosreg4 | + allocate(%[1],%[2],REG) + "addl3\t%[1],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,4)+%[1]+%[2] +#ifdef REGVARS +adi stl $1==4 && inreg($2)==2 + | source4 source4 | + remove(regvar($2)) + "addl3\t%[1],%[2],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | +#endif REGVARS +adi stl $1==4 | source4 source4 | + remove(displaced) + remove(LOCALS, %[num]<=$2+3 && %[num]+%[size]>$2) + "addl3\t%[1],%[2],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | +#ifdef REGVARS +adi sil $1==4 && inreg($2)==2 + | source4 source4 | + REMEXTANDLOC + "addl3\t%[1],%[2],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) | | | +#endif REGVARS +adi sil $1==4 | source4 source4 | + REMEXTANDLOC + "addl3\t%[1],%[2],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) | | | +adi ste $1==4 | source4 source4 | + remove(externals) + "addl3\t%[1],%[2],$2" + setcc({EXTERNAL4,$2}) | | | +adi !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.adi" | | | +sbi $1==4 | source4 sreg4 | + "subl2\t%[1],%[2]" + erase(%[2]) + setcc(%[2]) | %[2] | | (3,4) + %[1] +... | NC source4 nosreg4 | + allocate(%[1],%[2],REG) + "subl3\t%[1],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,4)+%[1]+%[2] +#ifdef REGVARS +sbi stl $1==4 && inreg($2)==2 + | source4 source4 | + remove(regvar($2)) + "subl3\t%[1],%[2],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | +#endif REGVARS +sbi stl $1==4 | source4 source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2)) + "subl3\t%[1],%[2],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | +#ifdef REGVARS +sbi sil $1==4 && inreg($2)==2 + | source4 source4 | + REMEXTANDLOC + "subl3\t%[1],%[2],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) | | | +#endif REGVARS +sbi sil $1==4 | source4 source4 | + REMEXTANDLOC + "subl3\t%[1],%[2],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) | | | +sbi ste $1==4 | source4 source4 | + remove(externals) + "subl3\t%[1],%[2],$2" + setcc({EXTERNAL4,$2}) | | | +sbi !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.sbi" | | | +mli $1==4 | source4 sreg4 | + "mull2\t%[1],%[2]" + erase(%[2]) + setcc(%[2]) | %[2] | | (3,16) + %[1] +... | sreg4 source4 | + "mull2\t%[2],%[1]" + erase(%[1]) + setcc(%[1]) | %[1] | | (3,16) + %[2] +... | NC nosreg4 nosreg4 | + allocate(%[1],%[2],REG) + "mull3\t%[1],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,16)+%[1]+%[2] +#ifdef REGVARS +mli stl $1==4 && inreg($2)==2 + | source4 source4 | + remove(regvar($2)) + "mull3\t%[1],%[2],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | +#endif REGVARS +mli stl $1==4 | source4 source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2)) + "mull3\t%[1],%[2],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | +#ifdef REGVARS +mli sil $1==4 && inreg($2)==2 + | source4 source4 | + REMEXTANDLOC + "mull3\t%[1],%[2],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) | | | +#endif REGVARS +mli sil $1==4 | source4 source4 | + REMEXTANDLOC + "mull3\t%[1],%[2],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) | | | +mli ste $1==4 | source4 source4 | + remove(externals) + "mull3\t%[1],%[2],$2" + setcc({EXTERNAL4,$2}) | | | +mli !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.mli" | | | +dvi $1==4 | source4 sreg4 | + "divl2\t%[1],%[2]" + erase(%[2]) + setcc(%[2]) | %[2] | | (3,98) + %[1] +... | NC source4 nosreg4 | + allocate(%[1],%[2],REG) + "divl3\t%[1],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,98)+%[1]+%[2] +#ifdef REGVARS +dvi stl $1==4 && inreg($2)==2 + | source4 source4 | + remove(regvar($2)) + "divl3\t%[1],%[2],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | +#endif REGVARS +dvi stl $1==4 | source4 source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2)) + "divl3\t%[1],%[2],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | +#ifdef REGVARS +dvi sil $1==4 && inreg($2)==2 + | source4 source4 | + REMEXTANDLOC + "divl3\t%[1],%[2],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) | | | +#endif REGVARS +dvi sil $1==4 | source4 source4 | + REMEXTANDLOC + "divl3\t%[1],%[2],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) | | | +dvi ste $1==4 | source4 source4 | + remove(externals) + "divl3\t%[1],%[2],$2" + setcc({EXTERNAL4,$2}) | | | +dvi !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.dvi" | | | +rmi $1==4 | source4 source4 | + allocate(REG) + "divl3\t%[1],%[2],%[a]" + "mull2\t%[1],%[a]" + "subl3\t%[a],%[2],%[a]" + setcc(%[a]) | %[a] | | +#ifdef REGVARS +rmi stl $1==4 && inreg($2)==2 + | source4 source4 | + remove(regvar($2)) + allocate(REG) + "divl3\t%[1],%[2],%[a]" + "mull2\t%[1],%[a]" + "subl3\t%[a],%[2],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | +#endif REGVARS +rmi stl $1==4 | source4 source4 | + remove(displaced) + remove(LOCALS, (%[num]<=$2+3 && %[num]+%[size]>$2)) + allocate(REG) + "divl3\t%[1],%[2],%[a]" + "mull2\t%[1],%[a]" + "subl3\t%[a],%[2],$2(fp)" + setcc({LOCAL4, $2, 4}) | | | +#ifdef REGVARS +rmi sil $1==4 && inreg($2)==2 + | source4 source4 | + REMEXTANDLOC + allocate(REG) + "divl3\t%[1],%[2],%[a]" + "mull2\t%[1],%[a]" + "subl3\t%[a],%[2],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) | | | +#endif REGVARS +rmi sil $1==4 | source4 source4 | + REMEXTANDLOC + allocate(REG) + "divl3\t%[1],%[2],%[a]" + "mull2\t%[1],%[a]" + "subl3\t%[a],%[2],*$2(fp)" + setcc({displdef4, LB, tostring($2)}) | | | +rmi ste $1==4 | source4 source4 | + remove(externals) + allocate(REG) + "divl3\t%[1],%[2],%[a]" + "mull2\t%[1],%[a]" + "subl3\t%[a],%[2],$2" + setcc({EXTERNAL4, $2}) | | | +rmi !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.rmi" + erase(R0) | | | +ngi $1==4 | source4 | + allocate(%[1],REG) + "mnegl\t%[1],%[a]" + setcc(%[a]) | %[a] | | +#ifdef REGVARS +ngi stl $1==4 && inreg($2)==2 + | source4 | + remove(regvar($2)) + "mnegl\t%[1],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | +#endif REGVARS +ngi stl $1==4 | source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2)) + "mnegl\t%[1],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | +#ifdef REGVARS +ngi sil $1==4 && inreg($2)==2 + | source4 | + REMEXTANDLOC + "mnegl\t%[1],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) | | | +#endif REGVARS +ngi sil $1==4 | source4 | + REMEXTANDLOC + "mnegl\t%[1],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) | | | +ngi ste $1==4 | source4 | + remove(externals) + "mnegl\t%[1],$2" + setcc({EXTERNAL4,$2}) | | | +ngi !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.ngi" | | | +sli $1==4 | source1or2or4 source1or2or4 | + allocate(%[1],%[2],REG) + "ashl\t%[1],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,4)+%[1]+%[2] +#ifdef REGVARS +sli stl $1==4 && inreg($2)==2 + | source4 source4 | + remove(regvar($2)) + "ashl\t%[1],%[2],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | +#endif REGVARS +sli stl $1==4 | source4 source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2)) + "ashl\t%[1],%[2],$2(fp)" + setcc({LOCAL4, $2, 4}) | | | +#ifdef REGVARS +sli sil $1==4 && inreg($2)==2 + | source4 source4 | + REMEXTANDLOC + "ashl\t%[1],%[2],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) | | | +#endif REGVARS +sli sil $1==4 | source4 source4 | + REMEXTANDLOC + "ashl\t%[1],%[2],*$2(fp)" + setcc({displdef4, LB, tostring($2)}) | | | +sli ste $1==4 | source4 source4 | + remove(externals) + "ashl\t%[1],%[2],$2" + setcc({EXTERNAL4, $2}) | | | (8,10)+%[1]+%[2] +sli !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.sli" + erase(R0) | | | +sri $1==4 | source4-CONST source4 | + allocate(%[1],REG) + "mnegl\t%[1],%[a]" + "ashl\t%[a],%[2],%[a]" + setcc(%[a]) | %[a] | | (7,8)+%[1]+%[2] +... | NC CONST source4 | + allocate(%[2],REG) + "ashl\t$$%(0-%[1.num]%),%[2],%[a]" + setcc(%[a]) | %[a] | | (4,4)+%[1]+%[2] +#ifdef REGVARS +sri stl $1==4 && inreg($2)==2 + | source4-CONST source4 | + remove(regvar($2)) + allocate(%[1], REG) + "mnegl\t%[1],%[a]" + "ashl\t%[a],%[2],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | (9,14)+%[1]+%[2] +... | CONST source4 | + remove(regvar($2)) + "ashl\t$$%(0-%[1.num]%),%[2],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | (6,10)+%[1]+%[2] +#endif REGVARS +sri stl $1==4 | source4-CONST source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2)) + allocate(%[1], REG) + "mnegl\t%[1],%[a]" + "ashl\t%[a],%[2],$2(fp)" + setcc({LOCAL4, $2, 4}) | | | (9,11)+%[1]+%[2] +... | CONST source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2)) + "ashl\t$$%(0-%[1.num]%),%[2],$2(fp)" + setcc({LOCAL4, $2, 4}) | | | (6,7)+%[1]+%[2] +#ifdef REGVARS +sri sil $1==4 && inreg($2)==2 + | source4-CONST source4 | + REMEXTANDLOC + allocate(%[1], REG) + "mnegl\t%[1],%[a]" + "ashl\t%[a],%[2],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) | | | (9,14)+%[1]+%[2] +... | CONST source4 | + REMEXTANDLOC + "ashl\t$$%(0-%[1.num]%),%[2],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) | | | (6,10)+%[1]+%[2] +#endif REGVARS +sri sil $1==4 | source4-CONST source4 | + REMEXTANDLOC + allocate(%[1], REG) + "mnegl\t%[1],%[a]" + "ashl\t%[a],%[2],*$2(fp)" + setcc({displdef4, LB, tostring($2)}) + | | | (9,17)+%[1]+%[2] +... | CONST source4 | + REMEXTANDLOC + "ashl\t$$%(0-%[1.num]%),%[2],*$2(fp)" + setcc({displdef4, LB, tostring($2)}) + | | | (6,13)+%[1]+%[2] +sri ste $1==4 | source4-CONST source4 | + remove(externals) + allocate(%[1], REG) + "mnegl\t%[1],%[a]" + "ashl\t%[a],%[2],$2" + setcc({EXTERNAL4, $2}) | | | (11,14)+%[1]+%[2] +... | CONST source4 | + remove(externals) + "ashl\t$$%(0-%[1.num]%),%[2],$2" + setcc({EXTERNAL4, $2}) | | | (8,10)+%[1]+%[2] +sri !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.sri" + erase(R0) | | | + +/************************************************ + * Group 4 : Unsigned arithmetic * + ************************************************/ + +adu | | | | adi $1 | +sbu | | | | sbi $1 | +mlu | | | | mli $1 | +dvu $1==4 | | remove(ALL) + "jsb\t.dvu4" | R0 | | +dvu !defined($1) | source1or2or4 | + remove(ALL) + move(%[1],R0) + "jsb\t.dvu" + erase(R0) | | | +rmu $1==4 | | remove(ALL) + "jsb\t.rmu4" | R0 | | +rmu !defined($1) | source1or2or4 | + remove(ALL) + move(%[1],R0) + "jsb\t.rmu" + erase(R0) | | | +slu | | | | sli $1 | +sru $1==4 | source4-CONST source4 | + allocate(%[1],REG,QREG) + "mnegl\t%[1],%[a]" + move(%[2],%[b.1]) + move({CONST4,0},%[b.2]) + "ashq\t%[a],%[b],%[b]" + erase(%[b]) | %[b.1] | | (10,12)+%[1] +... | NC CONST source4 | + allocate(%[2],QREG) + move(%[2],%[a.1]) + move({CONST4,0},%[a.2]) + "ashq\t$$%(0-%[1.num]%),%[a],%[a]" + erase(%[a]) | %[a.1] | | (4,4)+%[1] +sru !defined($1) | source1or2or4 | + remove(ALL) + move(%[1],R0) + "jsb\t.sru" + erase(R0) | | | + +/**************************************** + * Group 5 : Floating point arithmetic * + ****************************************/ + +adf $1==4 | source4 sreg4 | + "addf2\t%[1],%[2]" + erase(%[2]) + setcc(%[2]) | %[2] | | (3,8) + %[1] +... | sreg4 source4 | + "addf2\t%[2],%[1]" + erase(%[1]) + setcc(%[1]) | %[1] | | (3,8) + %[2] +... | NC nosreg4 nosreg4 | + allocate(%[1],%[2],REG) + "addf3\t%[1],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,8)+%[1]+%[2] +#ifdef FLOAT4 +adf stl $1==4 | source4 source4 | + remove(displaced) + remove(LOCALS, %[num] <= $2+3 && %[num]+%[size] > $2) + "addf3\t%[1],%[2],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | +adf sil $1==4 | source4 source4 | + REMEXTANDLOC + "addf3\t%[1],%[2],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) | | | +adf ste $1==4 | source4 source4 | + remove(externals) + "addf3\t%[1],%[2],$2" + setcc({EXTERNAL4,$2}) | | | +#endif +adf $1==8 | source8 sreg8 | + "addd2\t%[1],%[2]" + erase(%[2]) + setcc(%[2]) | %[2] | | (3,14) + %[1] +... | sreg8 source8 | + "addd2\t%[2],%[1]" + erase(%[1]) + setcc(%[1]) | %[1] | | (3,14) + %[2] +... | NC nosreg8 source8-sreg8 | + allocate(%[1],%[2],QREG) + "addd3\t%[1],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,14)+%[1]+%[2] +adf sdl $1==8 | source8 source8 | + remove(displaced) + remove(LOCALS, %[num] <= $2+7 && %[num]+%[size] > $2) + "addd3\t%[1],%[2],$2(fp)" + setcc({LOCAL8,$2, 8}) | | | +adf sde $1==8 | source8 source8 | + remove(externals) + "addd3\t%[1],%[2],$2" + setcc({EXTERNAL8,$2}) | | | +adf !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.adf" | | | +sbf $1==4 | source4 sreg4 | + "subf2\t%[1],%[2]" + erase(%[2]) + setcc(%[2]) | %[2] | | (3,8) + %[1] +... | NC source4 nosreg4 | + allocate(%[1],%[2],REG) + "subf3\t%[1],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,8)+%[1]+%[2] +#ifdef FLOAT4 +sbf stl $1==4 | source4 source4 | + remove(displaced) + remove(LOCALS, %[num] <= $2+3 && %[num]+%[size] > $2) + "subf3\t%[1],%[2],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | +sbf sil $1==4 | source4 source4 | + REMEXTANDLOC + "subf3\t%[1],%[2],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) | | | +sbf ste $1==4 | source4 source4 | + remove(externals) + "subf3\t%[1],%[2],$2" + setcc({EXTERNAL4,$2}) | | | +#endif +sbf $1==8 | source8 sreg8 | + "subd2\t%[1],%[2]" + erase(%[2]) + setcc(%[2]) | %[2] | | (3,14) + %[1] +... | NC source8 nosreg8 | + allocate(%[1],%[2],QREG) + "subd3\t%[1],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,14)+%[1]+%[2] +sbf sdl $1==8 | source8 source8 | + remove(displaced) + remove(LOCALS, %[num] <= $2+7 && %[num]+%[size] > $2) + "subd3\t%[1],%[2],$2(fp)" + setcc({LOCAL8,$2, 8}) | | | +sbf sde $1==8 | source8 source8 | + remove(externals) + "subd3\t%[1],%[2],$2" + setcc({EXTERNAL8,$2}) | | | +sbf !defined($1) | source1or2or4 | + remove(ALL) + move(%[1],R0) + "jsb\t.sbf" | | | +mlf $1==4 | source4 sreg4 | + "mulf2\t%[1],%[2]" + erase(%[2]) + setcc(%[2]) | %[2] | | (3,12) + %[1] +... | sreg4 source4 | + "mulf2\t%[2],%[1]" + erase(%[1]) + setcc(%[1]) | %[1] | | (3,12) + %[2] +... | NC nosreg4 nosreg4 | + allocate(%[1],%[2],REG) + "mulf3\t%[1],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,12)+%[1]+%[2] +#ifdef FLOAT4 +mlf stl $1==4 | source4 source4 | + remove(displaced) + remove(LOCALS, %[num] <= $2+3 && %[num]+%[size] > $2) + "mulf3\t%[1],%[2],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | +mlf sil $1==4 | source4 source4 | + REMEXTANDLOC + "mulf3\t%[1],%[2],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) | | | +mlf ste $1==4 | source4 source4 | + remove(externals) + "mulf3\t%[1],%[2],$2" + setcc({EXTERNAL4,$2}) | | | +#endif +mlf $1==8 | source8 sreg8 | + "muld2\t%[1],%[2]" + erase(%[2]) + setcc(%[2]) | %[2] | | (3,20) + %[1] +... | sreg8 source8 | + "muld2\t%[2],%[1]" + erase(%[1]) + setcc(%[1]) | %[1] | | (3,20) + %[2] +... | NC nosreg8 source8-sreg8 | + allocate(%[1],%[2],QREG) + "muld3\t%[1],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,20)+%[1]+%[2] +mlf sdl $1==8 | source8 source8 | + remove(displaced) + remove(LOCALS, %[num] <= $2+7 && %[num]+%[size] > $2) + "muld3\t%[1],%[2],$2(fp)" + setcc({LOCAL8,$2, 8}) | | | +mlf sde $1==8 | source8 source8 | + remove(externals) + "muld3\t%[1],%[2],$2" + setcc({EXTERNAL8,$2}) | | | +mlf !defined($1) | source1or2or4 | + remove(ALL) + move(%[1],R0) + "jsb\t.mlf" | | | +dvf $1==4 | source4 sreg4 | + "divf2\t%[1],%[2]" + erase(%[2]) + setcc(%[2]) | %[2] | | (3,46) + %[1] +... | NC source4 nosreg4 | + allocate(%[1],%[2],REG) + "divf3\t%[1],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,46)+%[1]+%[2] +#ifdef FLOAT4 +dvf stl $1==4 | source4 source4 | + remove(displaced) + remove(LOCALS, %[num] <= $2+3 && %[num]+%[size] > $2) + "divf3\t%[1],%[2],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | +dvf sil $1==4 | source4 source4 | + REMEXTANDLOC + "divf3\t%[1],%[2],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) | | | +dvf ste $1==4 | source4 source4 | + remove(externals) + "divf3\t%[1],%[2],$2" + setcc({EXTERNAL4,$2}) | | | +#endif +dvf $1==8 | source8 sreg8 | + "divd2\t%[1],%[2]" + erase(%[2]) + setcc(%[2]) | %[2] | | (3,80) + %[1] +... | NC source8 nosreg8 | + allocate(%[1],%[2],QREG) + "divd3\t%[1],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,80)+%[1]+%[2] +dvf sdl $1==8 | source8 source8 | + remove(displaced) + remove(LOCALS, %[num] <= $2+7 && %[num]+%[size] > $2) + "divd3\t%[1],%[2],$2(fp)" + setcc({LOCAL8,$2, 8}) | | | +dvf sde $1==8 | source8 source8 | + remove(externals) + "divd3\t%[1],%[2],$2" + setcc({EXTERNAL8,$2}) | | | +dvf !defined($1) | source1or2or4 | + remove(ALL) + move(%[1],R0) + "jsb\t.dvf" | | | +ngf $1==4 | source4 | + allocate(%[1],REG) + "mnegf\t%[1],%[a]" + setcc(%[a]) | %[a] | | +#ifdef FLOAT4 +ngf stl $1==4 | source4 | + remove(displaced) + remove(LOCALS, %[num] <= $2+3 && %[num]+%[size] > $2) + "mnegf\t%[1],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | +ngf sil $1==4 | source4 | + REMEXTANDLOC + "mnegf\t%[1],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) | | | +ngf ste $1==4 | source4 | + remove(externals) + "mnegf\t%[1],$2" + setcc({EXTERNAL4,$2}) | | | +#endif +ngf $1==8 | source8 | + allocate(%[1],QREG) + "mnegd\t%[1],%[a]" + setcc(%[a]) | %[a] | | +ngf sdl $1==8 | source8 | + remove(displaced) + remove(LOCALS, %[num] <= $2+7 && %[num]+%[size] > $2) + "mnegd\t%[1],$2(fp)" + setcc({LOCAL8,$2, 8}) | | | +ngf sde $1==8 | source8 | + remove(externals) + "mnegd\t%[1],$2" + setcc({EXTERNAL8,$2}) | | | +ngf !defined($1) | source1or2or4 | + remove(ALL) + move(%[1],R0) + "jsb\t.ngf" | | | +loc loc loc cif fif $1==1 && $2==4 && $3==4 && $5==4 + | source4 | + allocate(%[1],REG,REG) + "emodf\t%[1],$$0,$$0f1.0,%[b],%[a]" + /* Don't trust the integer part in %[b], * + * integer overflow might occur. */ + "subf3\t%[a],%[1],%[b]" | %[a] %[b] | | +loc loc loc cif fif $1==1 && $2==4 && $3==8 && $5==8 + | source8 | + allocate(%[1],QREG,QREG) + "emodd\t%[1],$$0,$$0f1.0,%[b],%[a]" + "subd3\t%[a],%[1],%[b]" | %[a] %[b] | | +fif $1==4 | source4 source4 | + allocate(%[1],%[2],REG,REG,REG) + "mulf3\t%[1],%[2],%[a]" + "emodf\t%[a],$$0,$$0f1.0,%[b],%[c]" + "subf2\t%[c],%[a]" | %[c] %[a] | | +fif $1==8 | source8 source8 | + allocate(%[1],%[2],QREG,QREG) + "muld3\t%[1],%[2],%[a]" + "emodd\t%[a],$$0,$$0f1.0,-(sp),%[b]" + "tstl\t(sp)+" + "subd2\t%[b],%[a]" | %[b] %[a] | | +fif !defined($1) | source1or2or4 | + remove(ALL) + move(%[1],R0) + "jsb\t.fif" + erase(R0) | | | +fef $1==4 | sreg4 | + allocate(REG) + "extzv\t$$7,$$8,%[1],%[a]" + "subl2\t$$128,%[a]" + "insv\t$$128,$$7,$$8,%[1]" + erase(%[1]) | %[1] %[a] | | +fef $1==8 | sreg8 | + allocate(REG) + "extzv\t$$7,$$8,%[1],%[a]" + "subl2\t$$128,%[a]" + "insv\t$$128,$$7,$$8,%[1]" + erase(%[1]) | %[1] %[a] | | +fef !defined($1) | source1or2or4 | + remove(ALL) + move(%[1],R0) + "jsb\t.fef" + erase(R0) | | | + +/******************************** + * Group 6 : pointer arithmetic * + ********************************/ + +adp $1==0 | | | | | +adp | NC adispl | + | {adispl,%[1.reg],%[1.ind]+"+"+tostring($1)} | | +... | NC ADDR_EXTERNAL | + | {ADDR_EXTERNAL,%[1.ind]+"+"+tostring($1)} | | +... | NC ADDR_LOCAL | | {ADDR_LOCAL,%[1.num]+$1} | | +... | reg4 | | {adispl,%[1],tostring($1)} | | +... | NC adisplind1 | + | {adisplind1,%[1.ireg],%[1.reg], + %[1.ind]+"+"+tostring($1)} | | +... | NC adisplind2 | + | {adisplind2,%[1.ireg],%[1.reg], + %[1.ind]+"+"+tostring($1)} | | +... | NC adisplind4 | + | {adisplind4,%[1.ireg],%[1.reg], + %[1.ind]+"+"+tostring($1)} | | +... | NC adisplind8 | + | {adisplind8,%[1.ireg],%[1.reg], + %[1.ind]+"+"+tostring($1)} | | +... | NC aextind2 | + | {aextind2,%[1.ireg],%[1.ind]+"+"+tostring($1)} | | +... | NC aextind4 | + | {aextind4,%[1.ireg],%[1.ind]+"+"+tostring($1)} | | +... | NC aextind8 | + | {aextind8,%[1.ireg],%[1.ind]+"+"+tostring($1)} | | +ads $1==4 | NC reg4 adispl | + | {adisplind1,%[1],%[2.reg],%[2.ind]} | | +... | NC reg4 ADDR_LOCAL | + | {adisplind1,%[1],LB,tostring(%[2.num])} | | +... | NC reg4 ADDR_EXTERNAL | + | {adispl,%[1],%[2.ind]} | | +... | NC reg4 displ4 | + | {adispldefind1,%[1],%[2.reg],%[2.ind]} | | +... | NC reg4 LOCAL4 | + | {adispldefind1,%[1],LB,tostring(%[2.num])} | | +... | NC reg4 EXTERNAL4 | + | {aextdefind1,%[1],%[2.ind]} | | +... | source4 source4 | + allocate(%[1],%[2],REG) + "addl3\t%[1],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,4)+%[1]+%[2] +ads | | | | loc $1 loc 4 cii ads 4 | +ads !defined($1) | | | | loc 4 cii ads 4 | +sbs $1==4 | | | | sbu $1 | +sbs $1!=4 | | | | sbu 4 loc 4 loc $1 cii | +sbs !defined($1) | source1or2or4 | + remove(ALL) + move(%[1],R0) + "jsb\t.sbs" + erase(R0) | | | +adp dup sil adp $1==(0-$4) && $2==4 + | reg4 | | %[1] %[1] | adp $1 sil $3 | +adp dup loe sti adp $1==(0-$5) && $2==4 && $4==4 + | reg4 | | %[1] %[1] | adp $1 loe $3 sti 4 | +#ifdef REGVARS +lol lol adp stl loi $1==$4 && $2==$1 && inreg($1)==2 && $3==1 && $5==1 + | | remove(regvar($1)) + | {reginc1,regvar($1)} | | +lol lol adp stl loi $1==$4 && $2==$1 && inreg($1)==2 && $3==2 && $5==2 + | | remove(regvar($1)) + | {reginc2,regvar($1)} | | +lol lol adp stl loi $1==$4 && $2==$1 && inreg($1)==2 && $3==4 && $5==4 + | | remove(regvar($1)) + | {reginc4,regvar($1)} | | +lol lol adp stl loi $1==$4 && $2==$1 && inreg($1)==2 && $3==8 && $5==8 + | | remove(regvar($1)) + | {reginc8,regvar($1)} | | +lol adp dup stl loi $1==$4 && $2==(0-1) && inreg($1)==2 && $3==4 && $5==1 + | | remove(regvar($1)) + | {regdec1,regvar($1)} | | +lol adp dup stl loi $1==$4 && $2==(0-2) && inreg($1)==2 && $3==4 && $5==2 + | | remove(regvar($1)) + | {regdec2,regvar($1)} | | +lol adp stl lil $1==$4 && $2==(0-4) && inreg($1)==2 && $3==$1 + | | remove(regvar($1)) + | {regdec4,regvar($1)} | | +lol adp dup stl loi $1==$4 && $2==(0-8) && inreg($1)==2 && $3==4 && $5==8 + | | remove(regvar($1)) + | {regdec8,regvar($1)} | | +lol lol adp stl sti $1==$4 && $2==$1 && inreg($1)==2 && $3==1 && $5==1 + | NC source1 | + REMEXTANDLOC + remove(regvar($1)) + "movb\t%[1],(%(regvar($1)%))+" + erase(regvar($1)) | | | (3,7)+%[1] +... | NC source2 | + REMEXTANDLOC + remove(regvar($1)) + "cvtwb\t%[1],(%(regvar($1)%))+" + erase(regvar($1)) | | | (3,7)+%[1] +... | source4 | + REMEXTANDLOC + remove(regvar($1)) + "cvtlb\t%[1],(%(regvar($1)%))+" + erase(regvar($1)) | | | (3,7)+%[1] +lol lol adp stl sti $1==$4 && $2==$1 && inreg($1)==2 && $3==2 && $5==2 + | NC source2 | + REMEXTANDLOC + remove(regvar($1)) + "movw\t%[1],(%(regvar($1)%))+" + erase(regvar($1)) | | | (3,7)+%[1] +... | source4 | + REMEXTANDLOC + remove(regvar($1)) + "cvtlw\t%[1],(%(regvar($1)%))+" + erase(regvar($1)) | | | (3,7)+%[1] +lol lol adp stl sti $1==$4 && $2==$1 && inreg($1)==2 && $3==4 && $5==4 + | source4 | + REMEXTANDLOC + remove(regvar($1)) + "movl\t%[1],(%(regvar($1)%))+" + erase(regvar($1)) | | | +lol lol adp stl sti $1==$4 && $2==$1 && inreg($1)==2 && $3==8 && $5==8 + | source8 | + REMEXTANDLOC + remove(regvar($1)) + "movq\t%[1],(%(regvar($1)%))+" + erase(regvar($1)) | | | +lol adp dup stl sti $1==$4 && inreg($1)==2 && $2==(0-1) && $3==4 && $5==1 + | NC source1 | + REMEXTANDLOC + remove(regvar($1)) + "movb\t%[1],-(%(regvar($1)%))" + erase(regvar($1)) | | | (3,7)+%[1] +... | NC source2 | + REMEXTANDLOC + remove(regvar($1)) + "cvtwb\t%[1],-(%(regvar($1)%))" + erase(regvar($1)) | | | (3,7)+%[1] +... | source4 | + REMEXTANDLOC + remove(regvar($1)) + "cvtlb\t%[1],-(%(regvar($1)%))" + erase(regvar($1)) | | | (3,7)+%[1] +lol adp dup stl sti $1==$4 && inreg($1)==2 && $2==(0-2) && $3==4 && $5==2 + | NC source2 | + REMEXTANDLOC + remove(regvar($1)) + "movw\t%[1],-(%(regvar($1)%))" + erase(regvar($1)) | | | (3,7)+%[1] +... | source4 | + REMEXTANDLOC + remove(regvar($1)) + "cvtlw\t%[1],-(%(regvar($1)%))" + erase(regvar($1)) | | | (3,7)+%[1] +lol adp stl sil $1==$4 && inreg($1)==2 && $2==(0-4) && $3==$4 + | source4 | + REMEXTANDLOC + remove(regvar($1)) + "movl\t%[1],-(%(regvar($1)%))" + erase(regvar($1)) | | | +lol adp dup stl sti $1==$4 && inreg($1)==2 && $2==(0-8) && $3==4 && $5==8 + | source8 | + REMEXTANDLOC + remove(regvar($1)) + "movq\t%[1],-(%(regvar($1)%))" + erase(regvar($1)) | | | +lol lol adp stl $1==$4 && $2==$4 && inreg($1)==2 + | | remove(regvar($1)) + allocate(REG=regvar($1)) + "addl2\t$$$3,%(regvar($1)%)" + erase(regvar($1)) | %[a] | | +lol adp stl $1==$3 && inreg($1)==2 + | | remove(regvar($1)) + "addl2\t$$$2,%(regvar($1)%)" + erase(regvar($1)) | | | +#endif REGVARS +lol adp stl $1==$3 + | | remove(displaced) + remove(LOCALS, %[num] <= $1+3 && %[num]+%[size] > $1) + "addl2\t$$$2,$1(fp)" + setcc({LOCAL4,$1,4}) | | | +lol lol adp stl $1==$4 && $2==$4 + | | remove(displaced) + remove(LOCALS, %[num] <= $1+3 && %[num]+%[size] > $1) + allocate(REG={LOCAL4,$1,4}) + "addl2\t$$$3,$1(fp)" + setcc({LOCAL4,$1,4}) | %[a] | | +#ifdef REGVARS +lil lil adp sil $1==$2 && $1==$4 && inreg($1)==2 + | | REMEXTANDLOC + allocate(REG={regdef4, regvar($1)}) + "addl2\t$$$3,(%(regvar($1)%))" | %[a] | | +#endif +loe adp ste $1==$3 + | | remove(externals) + "addl2\t$$$2,$1" | | | +loe loe adp ste $1==$4 && $2==$1 + | | remove(externals) + allocate(REG={EXTERNAL4,$1}) + "addl2\t$$$3,$1" | %[a] | | + +/**************************************** + * Group 7 : Increment/decrement/zero * + ****************************************/ + +lil inc dup sil $3==4 && $1==$4 | | | | lil $1 loc 1 adi 4 sil $1 lil $1 | +lil dec dup sil $3==4 && $1==$4 | | | | lil $1 loc 1 sbi 4 sil $1 lil $1 | +inc | | | {CONST1,1} | adi 4 | +dec | | | {CONST1,1} | sbi 4 | +#ifdef REGVARS +inl inreg($1)==2 | | remove(regvar($1)) + "incl\t%(regvar($1)%)" + erase(regvar($1)) + setcc(regvar($1)) | | | +#endif REGVARS +inl | | remove(displaced) + remove(LOCALS, %[num] <= $1+3 && %[num]+%[size] > $1) + "incl\t$1(fp)" + setcc({LOCAL4,$1, 4}) | | | +#ifdef REGVARS +lol inl $1==$2 && inreg($1)==2 + | | remove(regvar($1)) + allocate(REG=regvar($1)) + "incl\t%(regvar($1)%)" + erase(regvar($1)) + setcc(regvar($1)) | %[a] | | +#endif REGVARS +ine | | remove(externals) + "incl\t$1" + setcc({EXTERNAL4, $1}) | | | +#ifdef REGVARS +del inreg($1)==2 | | remove(regvar($1)) + "decl\t%(regvar($1)%)" + erase(regvar($1)) + setcc(regvar($1)) | | | +#endif REGVARS +del | | remove(displaced) + remove(LOCALS, %[num] <= $1+3 && %[num]+%[size] > $1) + "decl\t$1(fp)" + setcc({LOCAL4,$1, 4}) | | | +#ifdef REGVARS +lol del $1==$2 && inreg($1)==2 + | | remove(regvar($1)) + allocate(REG=regvar($1)) + "decl\t%(regvar($1)%)" + erase(regvar($1)) + setcc(regvar($1)) | %[a] | | +#endif REGVARS +dee | | remove(externals) + "decl\t$1" + setcc({EXTERNAL4, $1}) | | | +#ifdef REGVARS +zrl inreg($1)==2 | | remove(regvar($1)) + "clrl\t%(regvar($1)%)" + erase(regvar($1)) + setcc(regvar($1)) | | | +#endif REGVARS +zrl | | remove(displaced) + remove(LOCALS,%[num] <= $1+3 && %[num]+%[size] > $1) + "clrl\t$1(fp)" + setcc({LOCAL4,$1, 4}) | | | +zrl zrl $1==$2+4 +#ifdef REGVARS + && inreg($1)<2 && inreg($2)<2 +#endif REGVARS + | | remove(displaced) + remove(LOCALS, %[num] <= $2+7 && %[num]+%[size] > $2) + "clrq\t$2(fp)" + setcc({LOCAL8,$2, 8}) | | | +zrl zrl $1==$2-4 | | | | zrl $2 zrl $1 | +zre | | remove(externals) + "clrl\t$1" + setcc({EXTERNAL4, $1}) | | | +zrf $1==4 | | | {CONST4,0} | | +zrf $1==8 | | | {FCONST8,0} | | +zer $1==4 | | | {CONST4,0} | | +zer $1==8 | | allocate(QREG) + "clrq\t%[a]" | %[a] | | +zer $1<=32 | | remove(ALL) + "clrq\t-(sp)" | | zer $1-8 | +zer defined($1) | | remove(ALL) + move({CONST4,$1/4}, R0) +#ifdef LOCLABS + "1:\tclrl\t-(sp)" + "sobgtr\tr0,1b" +#else LOCLABS + "clrl\t-(sp)" + "sobgtr\tr0,.-2" +#endif LOCLABS + erase(R0) | | | +zer !defined($1) | source1or2or4 | + remove(ALL) + move(%[1],R0) +#ifdef LOCLABS + "1:\tclrl\t-(sp)" + "sobgtr\tr0,1b" +#else LOCLABS + "clrl\t-(sp)" + "sobgtr\tr0,.-2" +#endif LOCLABS + erase(R0) | | | + +/******************************** + * Group 8 : Convertions * + ********************************/ + +cii | | remove(ALL) + "jsb\t.cii" | | | +cfi | | remove(ALL) + "jsb\t.cfi" | | | +cfu | | remove(ALL) + "jsb\t.cfu" | | | +cuf | | remove(ALL) + "jsb\t.cuf" | | | +cif | | remove(ALL) + "jsb\t.cif" | | | +cff | | remove(ALL) + "jsb\t.cff" | | | +cuu | | remove(ALL) + "jsb\t.cuu" | | | +ciu | | | | cuu | +cui | | remove(ALL) + "jsb\t.cui" | | | +loc loc cii $1==1 && $2==2 | source1or2or4 | + allocate(%[1],REG) + "cvtbw\t%[1],%[a]" + setcc(%[a]) | %[a] | | +#ifdef REGVARS +loc loc cii stl $1==1 && $2==4 && inreg($4)==2 + | source1or2or4 | + remove(regvar($4)) + "cvtbl\t%[1],%(regvar($4)%)" + erase(regvar($1)) + setcc(regvar($4)) | | | +#endif REGVARS +loc loc cii stl $1==1 && $2==4 | source1or2or4 | + remove(displaced) + remove(LOCALS, (%[num] <= $4+3 && %[num]+%[size] > $4)) + "cvtbl\t%[1],$4(fp)" + setcc({LOCAL4,$4, 4}) | | | +loc loc cii ste $1==1 && $2==4 | source1or2or4 | + remove(externals) + "cvtbl\t%[1],$4" + setcc({EXTERNAL4, $4}) | | | +loc loc cii $1==1 && $2==4 | source1or2or4 | + allocate(%[1],REG) + "cvtbl\t%[1],%[a]" + setcc(%[a]) | %[a] | | +#ifdef REGVARS +loc loc cii stl $1==2 && $2==4 && inreg($4)==2 + | source2or4 | + remove(regvar($4)) + "cvtwl\t%[1],%(regvar($4)%)" + erase(regvar($4)) + setcc(regvar($4)) | | | +#endif REGVARS +loc loc cii stl $1==2 && $2==4 | source2or4 | + remove(displaced) + remove(LOCALS, (%[num] <= $4+3 && %[num]+%[size] > $4)) + "cvtwl\t%[1],$4(fp)" + setcc({LOCAL4,$4, 4}) | | | +loc loc cii ste $1==2 && $2==4 | source2or4 | + remove(externals) + "cvtwl\t%[1],$4" + setcc({EXTERNAL4, $4}) | | | +loc loc cii $1==2 && $2==4 | source2or4 | + allocate(%[1],REG) + "cvtwl\t%[1],%[a]" + setcc(%[a]) | %[a] | | +loc loc cii $1==2 && $2==1 | | | | | +loc loc cii $1==4 && $2==1 | | | | | +loc loc cii $1==4 && $2==2 | | | | | +loc loc cui $1==$2 | | | | | +loc loc ciu | | | | loc $1 loc $2 cuu | +#ifdef REGVARS +loc loc cfi stl $1==4 && $2==4 && inreg($4)==2 + | source4 | + remove(regvar($4)) + "cvtfl\t%[1],%(regvar($4)%)" + erase(regvar($4)) + setcc(regvar($4)) | | | +#endif REGVARS +loc loc cfi stl $1==4 && $2==4 | source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $4+3 && %[num]+%[size] > $4)) + "cvtfl\t%[1],$4(fp)" + setcc({LOCAL4,$4, 4}) | | | +loc loc cfi ste $1==4 && $2==4 | source4 | + remove(externals) + "cvtfl\t%[1],$4" + setcc({EXTERNAL4, $4}) | | | +loc loc cfi $1==4 && $2==4 | source4 | + allocate(%[1],REG) + "cvtfl\t%[1],%[a]" + setcc(%[a]) | %[a] | | (3,4) + %[1] +#ifdef REGVARS +loc loc cfi stl $1==8 && $2==4 && inreg($4)==2 + | source8 | + remove(regvar($4)) + "cvtdl\t%[1],%(regvar($4)%)" + erase(regvar($4)) + setcc(regvar($4)) | | | +#endif REGVARS +loc loc cfi stl $1==8 && $2==4 | source8 | + remove(displaced) + remove(LOCALS, (%[num] <= $4+3 && %[num]+%[size] > $4)) + "cvtdl\t%[1],$4(fp)" + setcc({LOCAL4,$4, 4}) | | | +loc loc cfi ste $1==8 && $2==4 | source8 | + remove(externals) + "cvtdl\t%[1],$4" + setcc({EXTERNAL4, $4}) | | | +loc loc cfi $1==8 && $2==4 | source8 | + allocate(%[1],REG) + "cvtdl\t%[1],%[a]" + setcc(%[a]) | %[a] | | +#ifdef REGVARS +loc loc cif stl $1==4 && $2==4 && inreg($4)==2 + | source4 | + remove(regvar($4)) + "cvtlf\t%[1],%(regvar($4)%)" + erase(regvar($4)) + setcc(regvar($4)) | | | +#endif REGVARS +loc loc cif stl $1==4 && $2==4 | source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $4+3 && %[num]+%[size] > $4)) + "cvtlf\t%[1],$4(fp)" | | | +loc loc cif ste $1==4 && $2==4 | source4 | + remove(externals) + "cvtlf\t%[1],$4" | | | +loc loc cif $1==4 && $2==4 | source4 | + allocate(%[1],REG) + "cvtlf\t%[1],%[a]" | %[a] | | +/* No double registervariables yet... +#ifdef REGVARS +loc loc cif sdl $1==4 && $2==8 && inreg($4)==2 + | source4 | + remove(regvar($4)) + "cvtld\t%[1],%(regvar($4)%)" + erase(regvar($4)) + setcc(regvar($4)) | | | +#endif REGVARS +*/ +loc loc cif sdl $1==4 && $2==8 | source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $4+3 && %[num]+%[size] > $4)) + "cvtld\t%[1],$4(fp)" | | | +loc loc cif sde $1==4 && $2==8 | source4 | + remove(externals) + "cvtld\t%[1],$4" | | | +loc loc loc cif $1!=0 && $2==4 && $3==8 | | | {FCONST8,$1} | | +/* $1!=0: kludge to avoid known bug in Vax assembler, that + * doesn't handle 0f0.0 (and other numbers that have the 0x4000 bit off + * in the exponent) right. + */ +loc loc cif $1==4 && $2==8 | source4 | + allocate(%[1],QREG) + "cvtld\t%[1],%[a]" | %[a] | | +loc loc cfu $1==4 | source4 | + allocate(%[1],REG=%[1]) + "bicl2\t$$32768,%[a]" | %[a] | loc $1 loc $2 cfi | +loc loc cfu $1==8 | source8 | + allocate(%[1],QREG=%[1]) + "bicl2\t$$32768,%[a]" | %[a] | loc $1 loc $2 cfi | +#ifdef REGVARS +loc loc cff sdl $1==4 && $2==8 && inreg($4)==2 + | source4 | + remove(regvar($4)) + "cvtfd\t%[1],%(regvar($4)%)" + erase(regvar($4)) + setcc(regvar($4)) | | | +#endif REGVARS +loc loc cff sdl $1==4 && $2==8 | source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $4+7 && %[num]+%[size] > $4)) + "cvtfd\t%[1],$4(fp)" | | | +loc loc cff sde $1==4 && $2==8 | source4 | + remove(externals) + "cvtfd\t%[1],$4" | | | +loc loc cff $1==4 && $2==8 | source4 | + allocate(%[1],QREG) + "cvtfd\t%[1],%[a]" | %[a] | | +#ifdef REGVARS +loc loc cff stl $1==8 && $2==4 && inreg($4)==2 + | source8 | + remove(regvar($4)) + "cvtdf\t%[1],%(regvar($4)%)" + erase(regvar($4)) + setcc(regvar($4)) | | | +#endif REGVARS +loc loc cff stl $1==8 && $2==4 | source8 | + remove(displaced) + remove(LOCALS, (%[num] <= $4+3 && %[num]+%[size] > $4)) + "cvtdf\t%[1],$4(fp)" | | | +loc loc cff ste $1==8 && $2==4 | source8 | + remove(externals) + "cvtdf\t%[1],$4" | | | +loc loc cff $1==8 && $2==4 | source8 | + allocate(%[1],REG) + "cvtdf\t%[1],%[a]" | %[a] | | +#ifdef REGVARS +loc loc cuu stl $1==2 && $2==4 && inreg($4)==2 + | source2or4 | + remove(regvar($4)) + "movzwl\t%[1],%(regvar($4)%)" + erase(regvar($4)) + setcc(regvar($4)) | | | +#endif REGVARS +loc loc cuu stl $1==2 && $2==4 | source2or4 | + remove(displaced) + remove(LOCALS, (%[num] <= $4+3 && %[num]+%[size] > $4)) + "movzwl\t%[1],$4(fp)" + setcc({LOCAL4,$4, 4}) | | | +loc loc cuu ste $1==2 && $2==4 | source2or4 | + remove(externals) + "movzwl\t%[1],$4" + setcc({EXTERNAL4, $4}) | | | +loc loc cuu $1==2 && $2==4 | source2or4 | + allocate(%[1],REG) + "movzwl\t%[1],%[a]" + setcc(%[a]) | %[a] | | + +/**************************************** + * Group 9 : Logical instructions * + ****************************************/ + +and $1==4 | source4 source4 | + allocate(%[1],REG) + "mcoml\t%[1],%[a]" + "bicl3\t%[a],%[2],%[a]" + setcc(%[a]) | %[a] | | (7,6)+%[1]+%[2] +... | CONST source4 | + allocate(%[2],REG) + "bicl3\t$$~%[1.num],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,3)+%[1]+%[2] +... | source4 CONST | + allocate(%[1],REG) + "bicl3\t$$~%[2.num],%[1],%[a]" + setcc(%[a]) | %[a] | | (4,3)+%[1]+%[2] +and zeq $1==4 | source1 source1 | + remove(ALL) + "bitb\t%[1],%[2]" + "jeql\t$2" | | | +... | source2 source2 | + remove(ALL) + "bitw\t%[1],%[2]" + "jeql\t$2" | | | +... | source4 source4 | + remove(ALL) + "bitl\t%[1],%[2]" + "jeql\t$2" | | | +and zne $1==4 | source1 source1 | + remove(ALL) + "bitb\t%[1],%[2]" + "jneq\t$2" | | | +... | source2 source2 | + remove(ALL) + "bitw\t%[1],%[2]" + "jneq\t$2" | | | +... | source4 source4 | + remove(ALL) + "bitl\t%[1],%[2]" + "jneq\t$2" | | | +and tne $1==4 | source4 source4 | + allocate(REG={CONST4,0}) + "bitl\t%[1],%[2]" +#ifdef LOCLABS + "jeql\t1f" + "incl\t%[a]\n1:" +#else + "jeql\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) | %[a] | | +#ifdef REGVARS +and stl $1==4 && inreg($2)==2 + | source4-CONST source4 | + remove(regvar($2)) + allocate(%[1],REG) + "mcoml\t%[1],%[a]" + "bicl3\t%[a],%[2],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | (8,8)+%[1]+%[2] +... | CONST source4 | + remove(regvar($2)) + "bicl3\t$$~%[1.num],%[2],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | (4,4)+%[1]+%[2] +... | source4 CONST | + remove(regvar($2)) + "bicl3\t$$~%[2.num],%[1],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | (4,4)+%[1]+%[2] +#endif REGVARS +and stl $1==4 | source4-CONST source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2)) + allocate(%[1],REG) + "mcoml\t%[1],%[a]" + "bicl3\t%[a],%[2],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | (9,12)+%[1]+%[2] +... | NC CONST source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2)) + "bicl3\t$$~%[1.num],%[2],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | (6,9)+%[1]+%[2] +... | NC source4 CONST | + remove(displaced) + remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2)) + "bicl3\t$$~%[2.num],%[1],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | (6,9)+%[1]+%[2] +#ifdef REGVARS +and sil $1==4 && inreg($2)==2 + | source4-CONST source4 | + REMEXTANDLOC + allocate(%[1],REG) + "mcoml\t%[1],%[a]" + "bicl3\t%[a],%[2],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) + | | | (9,15)+%[1]+%[2] +... | CONST source4 | + REMEXTANDLOC + "bicl3\t$$~%[1.num],%[2],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) + | | | (6,12)+%[1]+%[2] +... | source4 CONST | + REMEXTANDLOC + "bicl3\t$$~%[2.num],%[1],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) + | | | (6,12)+%[1]+%[2] +#endif REGVARS +and sil $1==4 | source4-CONST source4 | + REMEXTANDLOC + allocate(%[1],REG) + "mcoml\t%[1],%[a]" + "bicl3\t%[a],%[2],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) + | | | (9,15)+%[1]+%[2] +... | CONST source4 | + REMEXTANDLOC + "bicl3\t$$~%[1.num],%[2],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) + | | | (6,12)+%[1]+%[2] +... | source4 CONST | + REMEXTANDLOC + "bicl3\t$$~%[2.num],%[1],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) + | | | (6,12)+%[1]+%[2] +and ste $1==4 | source4-CONST source4 | + remove(externals) + allocate(%[1],REG) + "mcoml\t%[1],%[a]" + "bicl3\t%[a],%[2],$2" + setcc({EXTERNAL4,$2}) | | | (11,12)+%[1]+%[2] +... | CONST source4 | + remove(externals) + "bicl3\t$$~%[1.num],%[2],$2" + setcc({EXTERNAL4,$2}) | | | (8,9)+%[1]+%[2] +... | source4 CONST | + remove(externals) + "bicl3\t$$~%[2.num],%[1],$2" + setcc({EXTERNAL4,$2}) | | | (8,9)+%[1]+%[2] +and defined($1) | | remove(ALL) + move({CONST4,$1},R0) + "jsb\t.and" + erase(R0) | | | +and !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.and" + erase(R0) | | | +ior $1==4 | NC source4 source4 | + allocate(%[1],%[2],REG) + "bisl3\t%[1],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,4)+%[1]+%[2] +... | sreg4 source4 | + "bisl2\t%[2],%[1]" + erase(%[1]) + setcc(%[1]) | %[1] | | (3,4) + %[2] +... | source4 sreg4 | + "bisl2\t%[1],%[2]" + erase(%[2]) + setcc(%[2]) | %[2] | | (3,4) + %[1] +#ifdef REGVARS +ior stl $1==4 && inreg($2)==2 + | source4 source4 | + remove(regvar($2)) + "bisl3\t%[1],%[2],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | +#endif REGVARS +ior stl $1==4 | source4 source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2)) + "bisl3\t%[1],%[2],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | +#ifdef REGVARS +ior sil $1==4 && inreg($2)==2 + | source4 source4 | + REMEXTANDLOC + "bisl3\t%[1],%[2],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) | | | +#endif REGVARS +ior sil $1==4 | source4 source4 | + REMEXTANDLOC + "bisl3\t%[1],%[2],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) | | | +ior ste $1==4 | source4 source4 | + remove(externals) + "bisl3\t%[1],%[2],$2" + setcc({EXTERNAL4,$2}) | | | +ior defined($1) | | remove(ALL) + move({CONST4, $1},R0) + "jsb\t.ior" + erase(R0) | | | +ior !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.ior" + erase(R0) | | | +xor $1==4 | source4 source4 | + allocate(%[1],%[2],REG) + "xorl3\t%[1],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,4)+%[1]+%[2] +... | NC sreg4 source4 | + "xorl2\t%[2],%[1]" + erase(%[1]) + setcc(%[1]) | %[1] | | (3,4) + %[2] +... | NC source4 sreg4 | + "xorl2\t%[1],%[2]" + erase(%[2]) + setcc(%[2]) | %[2] | | (3,4) + %[1] +#ifdef REGVARS +xor stl $1==4 && inreg($2)==2 + | source4 source4 | + remove(regvar($2)) + "xorl3\t%[1],%[2],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | +#endif REGVARS +xor stl $1==4 | source4 source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2)) + "xorl3\t%[1],%[2],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | +#ifdef REGVARS +xor sil $1==4 && inreg($2)==2 + | source4 source4 | + REMEXTANDLOC + "xorl3\t%[1],%[2],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) | | | +#endif REGVARS +xor sil $1==4 | source4 source4 | + REMEXTANDLOC + "xorl3\t%[1],%[2],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) | | | +xor ste $1==4 | source4 source4 | + remove(externals) + "xorl3\t%[1],%[2],$2" + setcc({EXTERNAL4,$2}) | | | +xor defined($1) | | remove(ALL) + move({CONST4, $1},R0) + "jsb\t.xor" + erase(R0) | | | +xor !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.xor" + erase(R0) | | | +com $1==4 | source4 | + allocate(%[1],REG) + "mcoml\t%[1],%[a]" + setcc(%[a]) | %[a] | | +#ifdef REGVARS +com stl $1==4 && inreg($2)==2 + | source4 | + remove(regvar($2)) + "mcoml\t%[1],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | +#endif REGVARS +com stl $1==4 | source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2)) + "mcoml\t%[1],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | +#ifdef REGVARS +com sil $1==4 && inreg($2)==2 + | source4 | + REMEXTANDLOC + "mcoml\t%[1],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) | | | +#endif REGVARS +com sil $1==4 | source4 | + REMEXTANDLOC + "mcoml\t%[1],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) | | | +com ste $1==4 | source4 | + remove(externals) + "mcoml\t%[1],$2" + setcc({EXTERNAL4,$2}) | | | +com defined($1) | | remove(ALL) + move({CONST4,$1},R0) + "jsb\t.com" + erase(R0) | | | +com !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.com" + erase(R0) | | | +rol $1==4 | source4 source4 | + allocate(%[1],REG=%[1]) + "rotl\t%[a],%[2],%[a]" + erase(%[a]) + setcc(%[a]) | %[a] | | +#ifdef REGVARS +rol stl $1==4 && inreg($2)==2 + | source4 source4 | + remove(regvar($2)) + "rotl\t%[1],%[2],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | +#endif REGVARS +rol stl $1==4 | source4 source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2)) + "rotl\t%[1],%[2],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | +#ifdef REGVARS +rol sil $1==4 && inreg($2)==2 + | source4 source4 | + REMEXTANDLOC + "rotl\t%[1],%[2],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) | | | +#endif REGVARS +rol sil $1==4 | source4 source4 | + REMEXTANDLOC + "rotl\t%[1],%[2],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) | | | +rol ste $1==4 | source4 source4 | + remove(externals) + "rotl\t%[1],%[2],$2" + setcc({EXTERNAL4,$2}) | | | +rol !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.rol" + erase(R0) | | | +ror $1==4 | source4-CONST source4 | + allocate(%[1],REG) + "subl3\t%[1],$$32,%[a]" + "rotl\t%[a],%[2],%[a]" + setcc(%[a]) | %[a] | | +... | CONST source4 | + allocate(%[2],REG) + "rotl\t$$%(32-%[1.num]%),%[2],%[a]" + setcc(%[a]) | %[a] | | +#ifdef REGVARS +ror stl $1==4 && inreg($2)==2 + | source4-CONST source4 | + remove(regvar($2)) + allocate(%[1],REG) + "subl3\t%[1],$$32,%[a]" + "rotl\t%[a],%[2],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | +... | CONST source4 | + remove(regvar($2)) + "rotl\t$$%(32-%[1.num]%),%[2],%(regvar($2)%)" + erase(regvar($2)) + setcc(regvar($2)) | | | +#endif REGVARS +ror stl $1==4 | source4-CONST source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2)) + allocate(%[1],REG) + "subl3\t%[1],$$32,%[a]" + "rotl\t%[a],%[2],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | +... | CONST source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2)) + "rotl\t$$%(32-%[1.num]%),%[2],$2(fp)" + setcc({LOCAL4,$2, 4}) | | | +#ifdef REGVARS +ror sil $1==4 && inreg($2)==2 + | source4-CONST source4 | + REMEXTANDLOC + allocate(%[1],REG) + "subl3\t%[1],$$32,%[a]" + "rotl\t%[a],%[2],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) | | | +... | CONST source4 | + REMEXTANDLOC + "rotl\t$$%(32-%[1.num]%),%[2],(%(regvar($2)%))" + setcc({regdef4,regvar($2)}) | | | +#endif REGVARS +ror sil $1==4 | source4-CONST source4 | + REMEXTANDLOC + allocate(%[1],REG) + "subl3\t%[1],$$32,%[a]" + "rotl\t%[a],%[2],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) | | | +... | CONST source4 | + REMEXTANDLOC + "rotl\t$$%(32-%[1.num]%),%[2],*$2(fp)" + setcc({displdef4,LB,tostring($2)}) | | | +ror ste $1==4 | source4-CONST source4 | + remove(externals) + allocate(%[1],REG) + "subl3\t%[1],$$32,%[a]" + "rotl\t%[a],%[2],$2" + setcc({EXTERNAL4,$2}) | | | +... | CONST source4 | + remove(externals) + "rotl\t$$%(32-%[1.num]%),%[2],$2" + setcc({EXTERNAL4,$2}) | | | +ror !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.ror" + erase(R0) | | | +com and $1==4 && $2==4 | source4 source4 | + allocate(%[1],%[2],REG) + "bicl3\t%[1],%[2],%[a]" + setcc(%[a]) | %[a] | | (4,4)+%[1]+%[2] +... | NC source4 sreg4 | + "bicl2\t%[1],%[2]" + erase(%[2]) + setcc(%[2]) | %[2] | | (3,4) + %[1] +... | source4 source4 | + remove(ALL) + "bicl3\t%[1],%[2],(sp)+" | | | (4,7)+%[1]+%[2] +#ifdef REGVARS +com and stl $1==4 && $2==4 && inreg($3)==2 + | source4 source4 | + remove(regvar($3)) + "bicl3\t%[1],%[2],%(regvar($3)%)" + erase(regvar($3)) + setcc(regvar($3)) | | | +#endif REGVARS +com and stl $1==4 && $2==4 | source4 source4 | + remove(displaced) + remove(LOCALS, (%[num] <= $3+3 && %[num]+%[size] > $3)) + "bicl3\t%[1],%[2],$3(fp)" + setcc({LOCAL4,$3, 4}) | | | +#ifdef REGVARS +com and sil $1==4 && $2==4 && inreg($3)==2 + | source4 source4 | + REMEXTANDLOC + "bicl3\t%[1],%[2],(%(regvar($3)%))" + setcc({regdef4,regvar($3)}) | | | +#endif REGVARS +com and sil $1==4 && $2==4 | source4 source4 | + REMEXTANDLOC + "bicl3\t%[1],%[2],*$3(fp)" + setcc({displdef4,LB,tostring($3)}) | | | +com and ste $1==4 &&$2==4 | source4 source4 | + remove(externals) + "bicl3\t%[1],%[2],$3" + setcc({EXTERNAL4,$3}) | | | +com and $1==$2 | | remove(ALL) + move({CONST4, $1}, R0) + "jsb\t.cmand" + erase(R0) | | | + +/******************************** + * Group 10: Set instructions * + ********************************/ + +loc inn $1==0 && $2==4 | source4 | + allocate(%[1], REG) + "bicl3\t$$~1,%[1],%[a]" + setcc(%[a]) | %[a] | | +loc inn $2==4 | source4 | + allocate(%[1], REG) + "ashl\t$$%(0-$1%),%[1],%[a]" + "bicl2\t$$~1,%[a]" + setcc(%[a]) | %[a] | | +#ifdef LOCLABS +inn $1==4 | source4 source4 | + allocate(REG={CONST1,0}) + "cmpl\t%[1],$$31" + "bgtru\t1f" + "mnegl\t%[1],%[a]" + "ashl\t%[a],%[2],%[a]" + "bicl2\t$$~1,%[a]\n1:" + setcc(%[a]) + erase(%[a]) | %[a] | | +#endif +loc inn zeq $2==4 | source4 | + remove(ALL) + "bitl\t%[1],$$%(1<<$1%)" + "jeql\t$3" | | | +loc inn zne $2==4 | source4 | + remove(ALL) + "bitl\t%[1],$$%(1<<$1%)" + "jneq\t$3" | | | +inn zeq $1==4 | source4 source4 | + remove(ALL) + allocate(REG) + "cmpl\t%[1],$$31" + "jgtru\t$2" + "ashl\t%[1],$$1,%[a]" + "bitl\t%[2],%[a]" + "jeql\t$2" | | | +#ifdef LOCLABS +inn zne $1==4 | source4 source4 | + remove(ALL) + allocate(REG) + "cmpl\t%[1],$$31" + "bgtru\t1f" + "ashl\t%[1],$$1,%[a]" + "bitl\t%[2],%[a]" + "jneq\t$2\n1:" | | | +#endif +loc inn zeq $2==8 && $1<32 /* First half of set. */ + | REG REG | + remove(ALL) + "bitl\t%[1],$$%(1<<$1%)" + "jeql\t$3" | | | +loc inn zeq $2==8 && $1>=32 /* Second half. */ + | REG REG | + remove(ALL) + "bitl\t%[2],$$%(1<<($1-32)%)" + "jeql\t$3" | | | +loc inn zne $2==8 && $1<32 /* First half of set. */ + | REG REG | + remove(ALL) + "bitl\t%[1],$$%(1<<$1%)" + "jneq\t$3" | | | +loc inn zne $2==8 && $1>=32 /* Second half. */ + | REG REG | + remove(ALL) + "bitl\t%[2],$$%(1<<($1-32)%)" + "jneq\t$3" | | | +inn defined($1) | | remove(ALL) + move({CONST4, $1},R0) + "jsb\t.inn" + erase(R0) | R1 | | +inn !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.inn" + erase(R0) | R1 | | +set $1==4 | source4 | | {CONST4,1} %[1] | sli 4 | +set defined($1) | | remove(ALL) + move({CONST4, $1},R0) + "jsb\t.setx" + erase(R0) | | | +set !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.setx" + erase(R0) | | | + +/**************************************** + * Group 11 : Array instructions * + ****************************************/ + +lae aar $2==4 && rom(1,3)==1 | | | | ads 4 adp 0-rom(1,1) | +lae aar $2==4 && rom(1,3)==2 | | | | loc 1 sli 4 ads 4 adp 0-2*rom(1,1) | +lae aar $2==4 && rom(1,3)==4 | | | | loc 2 sli 4 ads 4 adp 0-4*rom(1,1) | +lae aar $2==4 && rom(1,3)==8 | | | | loc 3 sli 4 ads 4 adp 0-8*rom(1,1) | +lae aar $2==4 && defined(rom(1,3)) && rom(1,1)==0 + | source4 source4 | + allocate(%[1],REG) + "mull3\t$$%(rom(1,3)%),%[1],%[a]" + "addl2\t%[2],%[a]" + setcc(%[a]) | %[a] | | (10,20)+%[1]+%[2] +... | NC source4 adispl | + allocate(%[1],REG) + "mull3\t$$%(rom(1,3)%),%[1],%[a]" + "addl2\t%[2.reg],%[a]" + setcc(%[a]) + | {adispl,%[a],%[2.ind]} | | (10,20)+%[1] +... | NC source4 ADDR_LOCAL | + allocate(%[1],REG) + "mull3\t$$%(rom(1,3)%),%[1],%[a]" + "addl2\tfp,%[a]" + setcc(%[a]) + | {adispl,%[a],tostring(%[2.num])} | | (10,20)+%[1] +... | NC source4 ADDR_EXTERNAL | + allocate(%[1],REG) + "mull3\t$$%(rom(1,3)%),%[1],%[a]" + setcc(%[a]) + | {adispl,%[a],%[2.ind]} | | (7,16)+%[1] +lae aar $2==4 && defined(rom(1,3)) + | source4 adispl | + allocate(%[1],REG) + "mull3\t$$%(rom(1,3)%),%[1],%[a]" + "addl2\t%[2.reg],%[a]" + setcc(%[a]) + | {adispl,%[a], + %[2.ind]+"+"+tostring(0-rom(1,1)*rom(1,3))} + | | (10,20)+%[1] +... | NC source4 source4 | + allocate(%[1],REG) + "mull3\t$$%(rom(1,3)%),%[1],%[a]" + "addl2\t%[2],%[a]" + setcc(%[a]) + | {adispl,%[a],tostring(0-rom(1,1)*rom(1,3))} + | | (10,20)+%[1]+%[2] +... | NC source4 ADDR_EXTERNAL | + allocate(%[1],REG) + "mull3\t$$%(rom(1,3)%),%[1],%[a]" + setcc(%[a]) + | {adispl,%[a], + %[2.ind]+"+"+tostring(0-rom(1,1)*rom(1,3))} + | | (7,16)+%[1] +/* Sequence used by the CEM-compiler and the codegenerator. */ +loc sli ads $1==2 && $2==4 && $3==4 + | reg4 ADDR_EXTERNAL | + | {aextind4,%[1],%[2.ind]} | | +... | reg4 adispl | + | {adisplind4,%[1],%[2.reg],%[2.ind]} | | +... | reg4 displ4 | + | {adispldefind4,%[1],%[2.reg],%[2.ind]} | | +... | reg4 EXTERNAL4 | + | {aextdefind4,%[1],%[2.ind]} | | +loc sli ads $1==3 && $2==4 && $3==4 + | reg4 ADDR_EXTERNAL | + | {aextind8,%[1],%[2.ind]} | | +... | reg4 adispl | + | {adisplind8,%[1],%[2.reg],%[2.ind]} | | +... | reg4 displ4 | + | {adispldefind8,%[1],%[2.reg],%[2.ind]} | | +... | reg4 EXTERNAL4 | + | {aextdefind8,%[1],%[2.ind]} | | +aar $1==4 | | remove(ALL) + "jsb\t.aar4" | R0 | | +aar !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.aar" + erase(R0) | R0 | | +lae sar defined(rom(1,3)) | | | | lae $1 aar $2 sti rom(1,3) | +lae lar defined(rom(1,3)) | | | | lae $1 aar $2 loi rom(1,3) | +sar $1==4 | | remove(ALL) + "jsb\t.sar4" | | | +sar !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.sar" + erase(R0) | | | +lar $1==4 | | remove(ALL) + "jsb\t.lar4" | | | +lar !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.lar" + erase(R0) | | | + +/**************************************** + * Group 12 : Compare instructions * + ****************************************/ + +cmi $1==4 | source4 source4 | + allocate(REG={CONST1,0}) + "cmpl\t%[1],%[2]" +#ifdef LOCLABS + "beql\t2f" + "bgtr\t1f" +#else + "beql\t.+10" + "bgtr\t.+6" +#endif + "incl\t%[a]" +#ifdef LOCLABS + "brb\t2f\n1:" + "decl\t%[a]\n2:" +#else + "brb\t.+4" + "decl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmi !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.cmi" + setcc(R0) + erase(R0) | R0 | | +cmf $1==4 | source4 source4 | + allocate(REG={CONST1,0}) + "cmpf\t%[1],%[2]" +#ifdef LOCLABS + "beql\t2f" + "bgtr\t1f" +#else + "beql\t.+10" + "bgtr\t.+6" +#endif + "incl\t%[a]" +#ifdef LOCLABS + "brb\t2f\n1:" + "decl\t%[a]\n2:" +#else + "brb\t.+4" + "decl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmf $1==8 | source8 source8 | +/* trouble, possible lack of scratch registers */ + allocate(%[1],%[2],REG) + "cmpd\t%[1],%[2]" +#ifdef LOCLABS + "blss\t2f" + "bgtr\t1f" +#else + "blss\t.+8" + "bgtr\t.+11" +#endif + "clrl\t%[a]" +#ifdef LOCLABS + "brb\t3f\n2:" +#else + "brb\t.+10" +#endif + "movl\t$$1,%[a]" +#ifdef LOCLABS + "brb\t3f\n1:" + "mnegl\t$$1,%[a]\n3:" +#else + "brb\t.+5" + "mnegl\t$$1,%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmf !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.cmf" + setcc(R0) + erase(R0) | R0 | | +cmu $1==4 | | | | cmp | +cmu !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.cmu" + setcc(R0) + erase(R0) | R0 | | +cmp | source4 source4 | + allocate(REG={CONST1,0}) + "cmpl\t%[1],%[2]" +#ifdef LOCLABS + "beqlu\t2f" + "bgtru\t1f" +#else + "beqlu\t.+10" + "bgtru\t.+6" +#endif + "incl\t%[a]" +#ifdef LOCLABS + "brb\t2f\n1:" + "decl\t%[a]\n2:" +#else + "brb\t.+4" + "decl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cms $1==4 | source4 source4 | + allocate(REG={CONST4,0}) + "cmpl\t%[1],%[2]" +#ifdef LOCLABS + "bneq\t1f" + "incl\t%[a]\n1:" +#else + "bneq\t.+4" + "incl\t%[a]" +#endif + setcc(%[a]) + erase(%[a]) | %[a] | | +cms defined($1) | | remove(ALL) + move({CONST1,$1},R0) + "jsb\t.cms" + setcc(R0) + erase(R0) | R0 | | +cms !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.cms" + setcc(R0) + erase(R0) | R0 | | +tlt | source4 | + allocate(REG={CONST1,0}) + test(%[1]) +#ifdef LOCLABS + "bgeq\t1f" + "incl\t%[a]\n1:" +#else + "bgeq\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source1or2 | | {CONST1,0} | | +tlt and $2==4 | source4 sreg4 | + test(%[1]) +#ifdef LOCLABS + "blss\t1f" + "clrl\t%[2]\n1:" +#else + "blss\t.+4" + "clrl\t%[2]" +#endif + setcc(%[2]) + erase(%[2]) | %[2] | | +tlt ior $2==4 | source4 sreg4 | + test(%[1]) +#ifdef LOCLABS + "bgeq\t1f" + "bisl2\t$$1,%[2]\n1:" +#else + "bgeq\t.+4" + "bisl2\t$$1,%[2]" +#endif + setcc(%[2]) + erase(%[2]) | %[2] | | +tle | source4 | + allocate(REG={CONST1,0}) + test(%[1]) +#ifdef LOCLABS + "bgtr\t1f" + "incl\t%[a]\n1:" +#else + "bgtr\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source1or2 | | %[1] | teq | +tle and $2==4 | source4 sreg4 | + test(%[1]) +#ifdef LOCLABS + "bleq\t1f" + "clrl\t%[2]\n1:" +#else + "bleq\t.+4" + "clrl\t%[2]" +#endif + setcc(%[2]) + erase(%[2]) | %[2] | | +tle ior $2==4 | source4 sreg4 | + test(%[1]) +#ifdef LOCLABS + "bgtr\t1f" + "bisl2\t$$1,%[2]\n1:" +#else + "bgtr\t.+4" + "bisl2\t$$1,%[2]" +#endif + setcc(%[2]) + erase(%[2]) | %[2] | | +tge | source4 | + allocate(REG={CONST1,0}) + test(%[1]) +#ifdef LOCLABS + "blss\t1f" + "incl\t%[a]\n1:" +#else + "blss\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source1or2 | | {CONST1,1} | | +tge and $2==4 | source4 sreg4 | + test(%[1]) +#ifdef LOCLABS + "bgeq\t1f" + "clrl\t%[2]\n1:" +#else + "bgeq\t.+4" + "clrl\t%[2]" +#endif + setcc(%[2]) + erase(%[2]) | %[2] | | +tge ior $2==4 | source4 sreg4 | + test(%[1]) +#ifdef LOCLABS + "blss\t1f" + "bisl2\t$$1,%[2]\n1:" +#else + "blss\t.+4" + "bisl2\t$$1,%[2]" +#endif + setcc(%[2]) + erase(%[2]) | %[2] | | +tgt | source4 | + allocate(REG={CONST1,0}) + test(%[1]) +#ifdef LOCLABS + "bleq\t1f" + "incl\t%[a]\n1:" +#else + "bleq\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source1or2 | | %[1] | tne | +tgt and $2==4 | source4 sreg4 | + test(%[1]) +#ifdef LOCLABS + "bgtr\t1f" + "clrl\t%[2]\n1:" +#else + "bgtr\t.+4" + "clrl\t%[2]" +#endif + setcc(%[2]) + erase(%[2]) | %[2] | | +tgt ior $2==4 | source4 sreg4 | + test(%[1]) +#ifdef LOCLABS + "bleq\t1f" + "bisl2\t$$1,%[2]\n1:" +#else + "bleq\t.+4" + "bisl2\t$$1,%[2]" +#endif + setcc(%[2]) + erase(%[2]) | %[2] | | +teq | source1or2or4 | + allocate(REG={CONST1,0}) + test(%[1]) +#ifdef LOCLABS + "bneq\t1f" + "incl\t%[a]\n1:" +#else + "bneq\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +teq and $2==4 | source4 sreg4 | + test(%[1]) +#ifdef LOCLABS + "beql\t1f" + "clrl\t%[2]\n1:" +#else + "beql\t.+4" + "clrl\t%[2]" +#endif + setcc(%[2]) + erase(%[2]) | %[2] | | +teq ior $2==4 | source4 sreg4 | + test(%[1]) +#ifdef LOCLABS + "bneq\t1f" + "bisl2\t$$1,%[2]\n1:" +#else + "bneq\t.+4" + "bisl2\t$$1,%[2]" +#endif + setcc(%[2]) + erase(%[2]) | %[2] | | +tne | source1or2or4 | + allocate(REG={CONST1,0}) + test(%[1]) +#ifdef LOCLABS + "beql\t1f" + "incl\t%[a]\n1:" +#else + "beql\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +tne and $2==4 | source4 sreg4 | + test(%[1]) +#ifdef LOCLABS + "bneq\t1f" + "clrl\t%[2]\n1:" +#else + "bneq\t.+4" + "clrl\t%[2]" +#endif + setcc(%[2]) + erase(%[2]) | %[2] | | +tne ior $2==4 | source4 sreg4 | + test(%[1]) +#ifdef LOCLABS + "beql\t1f" + "bisl2\t$$1,%[2]\n1:" +#else + "beql\t.+4" + "bisl2\t$$1,%[2]" +#endif + setcc(%[2]) + erase(%[2]) | %[2] | | +cmi tlt $1==4 | source4 source4 | + allocate(REG={CONST4,0}) + "cmpl\t%[1],%[2]" +#ifdef LOCLABS + "bleq\t1f" + "incl\t%[a]\n1:" +#else + "bleq\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source1or2 source1or2 | + | %[2] %[1] | cmu 4 tlt | +cmi tle $1==4 | source4 source4 | + allocate(REG={CONST4,0}) + "cmpl\t%[1],%[2]" +#ifdef LOCLABS + "blss\t1f" + "incl\t%[a]\n1:" +#else + "blss\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source1or2 source1or2 | + | %[2] %[1] | cmu 4 tle | +cmi teq $1==4 | source4 source4 | + allocate(REG={CONST4,0}) + "cmpl\t%[1],%[2]" +#ifdef LOCLABS + "bneq\t1f" + "incl\t%[a]\n1:" +#else + "bneq\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source1or2 source1or2 | + | %[2] %[1] | cmu 4 teq | +cmi tne $1==4 | source4 source4 | + allocate(REG={CONST4,0}) + "cmpl\t%[1],%[2]" +#ifdef LOCLABS + "beql\t1f" + "incl\t%[a]\n1:" +#else + "beql\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source1or2 source1or2 | + | %[2] %[1] | cmu 4 tne | +cmi tge $1==4 | source4 source4 | + allocate(REG={CONST4,0}) + "cmpl\t%[1],%[2]" +#ifdef LOCLABS + "bgtr\t1f" + "incl\t%[a]\n1:" +#else + "bgtr\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source1or2 source1or2 | + | %[2] %[1] | cmu 4 tge | +cmi tgt $1==4 | source4 source4 | + allocate(REG={CONST4,0}) + "cmpl\t%[1],%[2]" +#ifdef LOCLABS + "bgeq\t1f" + "incl\t%[a]\n1:" +#else + "bgeq\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source1or2 source1or2 | + | %[2] %[1] | cmu 4 tgt | +cmi tlt and $1==4 && $3==4 + | source4 source4 sreg4 | + "cmpl\t%[2],%[1]" +#ifdef LOCLABS + "blss\t1f" + "clrl\t%[3]\n1:" +#else + "blss\t.+4" + "clrl\t%[3]" +#endif + setcc(%[3]) + erase(%[3]) | %[3] | | +cmi tle and $1==4 && $3==4 + | source4 source4 sreg4 | + "cmpl\t%[2],%[1]" +#ifdef LOCLABS + "bleq\t1f" + "clrl\t%[3]\n1:" +#else + "bleq\t.+4" + "clrl\t%[3]" +#endif + setcc(%[3]) + erase(%[3]) | %[3] | | +cmi teq and $1==4 && $3==4 + | source4 source4 sreg4 | + "cmpl\t%[2],%[1]" +#ifdef LOCLABS + "beql\t1f" + "clrl\t%[3]\n1:" +#else + "beql\t.+4" + "clrl\t%[3]" +#endif + setcc(%[3]) + erase(%[3]) | %[3] | | +cmi tne and $1==4 && $3==4 + | source4 source4 sreg4 | + "cmpl\t%[2],%[1]" +#ifdef LOCLABS + "bneq\t1f" + "clrl\t%[3]\n1:" +#else + "bneq\t.+4" + "clrl\t%[3]" +#endif + setcc(%[3]) + erase(%[3]) | %[3] | | +cmi tge and $1==4 && $3==4 + | source4 source4 sreg4 | + "cmpl\t%[2],%[1]" +#ifdef LOCLABS + "bgeq\t1f" + "clrl\t%[3]\n1:" +#else + "bgeq\t.+4" + "clrl\t%[3]" +#endif + setcc(%[3]) + erase(%[3]) | %[3] | | +cmi tgt and $1==4 && $3==4 + | source4 source4 sreg4 | + "cmpl\t%[2],%[1]" +#ifdef LOCLABS + "bgtr\t1f" + "clrl\t%[3]\n1:" +#else + "bgtr\t.+4" + "clrl\t%[3]" +#endif + setcc(%[3]) + erase(%[3]) | %[3] | | +cmi tlt ior $1==4 && $3==4 + | source4 source4 sreg4 | + "cmpl\t%[2],%[1]" +#ifdef LOCLABS + "bgeq\t1f" + "bisl2\t$$1,%[3]\n1:" +#else + "bgeq\t.+7" + "bisl2\t$$1,%[3]" +#endif + setcc(%[3]) + erase(%[3]) | %[3] | | +cmi tle ior $1==4 && $3==4 + | source4 source4 sreg4 | + "cmpl\t%[2],%[1]" +#ifdef LOCLABS + "bgtr\t1f" + "bisl2\t$$1,%[3]\n1:" +#else + "bgtr\t.+7" + "bisl2\t$$1,%[3]" +#endif + setcc(%[3]) + erase(%[3]) | %[3] | | +cmi teq ior $1==4 && $3==4 + | source4 source4 sreg4 | + "cmpl\t%[2],%[1]" +#ifdef LOCLABS + "bneq\t1f" + "bisl2\t$$1,%[3]\n1:" +#else + "bneq\t.+7" + "bisl2\t$$1,%[3]" +#endif + setcc(%[3]) + erase(%[3]) | %[3] | | +cmi tne ior $1==4 && $3==4 + | source4 source4 sreg4 | + "cmpl\t%[2],%[1]" +#ifdef LOCLABS + "beql\t1f" + "bisl2\t$$1,%[3]\n1:" +#else + "beql\t.+7" + "bisl2\t$$1,%[3]" +#endif + setcc(%[3]) + erase(%[3]) | %[3] | | +cmi tge ior $1==4 && $3==4 + | source4 source4 sreg4 | + "cmpl\t%[2],%[1]" +#ifdef LOCLABS + "blss\t1f" + "bisl2\t$$1,%[3]\n1:" +#else + "blss\t.+7" + "bisl2\t$$1,%[3]" +#endif + setcc(%[3]) + erase(%[3]) | %[3] | | +cmi tgt ior $1==4 && $3==4 + | source4 source4 sreg4 | + "cmpl\t%[2],%[1]" +#ifdef LOCLABS + "bleq\t1f" + "bisl2\t$$1,%[3]\n1:" +#else + "bleq\t.+7" + "bisl2\t$$1,%[3]" +#endif + setcc(%[3]) + erase(%[3]) | %[3] | | +cmf tlt $1==4 | source4 source4 | + allocate(REG={CONST1,0}) + "cmpf\t%[1],%[2]" +#ifdef LOCLABS + "bleq\t1f" + "incl\t%[a]\n1:" +#else + "bleq\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmf tle $1==4 | source4 source4 | + allocate(REG={CONST1,0}) + "cmpf\t%[1],%[2]" +#ifdef LOCLABS + "blss\t1f" + "incl\t%[a]\n1:" +#else + "blss\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmf teq $1==4 | source4 source4 | + allocate(REG={CONST1,0}) + "cmpf\t%[1],%[2]" +#ifdef LOCLABS + "bneq\t1f" + "incl\t%[a]\n1:" +#else + "bneq\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmf tne $1==4 | source4 source4 | + allocate(REG={CONST1,0}) + "cmpf\t%[1],%[2]" +#ifdef LOCLABS + "beql\t1f" + "incl\t%[a]\n1:" +#else + "beql\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmf tge $1==4 | source4 source4 | + allocate(REG={CONST1,0}) + "cmpf\t%[1],%[2]" +#ifdef LOCLABS + "bgtr\t1f" + "incl\t%[a]\n1:" +#else + "bgtr\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmf tgt $1==4 | source4 source4 | + allocate(REG={CONST1,0}) + "cmpf\t%[1],%[2]" +#ifdef LOCLABS + "bgeq\t1f" + "incl\t%[a]\n1:" +#else + "bgeq\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmf tlt $1==8 | source8 source8 | + allocate(%[1],%[2],REG) + "cmpd\t%[1],%[2]" +#ifdef LOCLABS + "bleq\t1f" + "movl\t$$1,%[a]" + "brb\t2f\n1:" + "clrl\t%[a]\n2:" +#else + "bleq\t.+9" + "movl\t$$1,%[a]" + "brb\t.+4" + "clrl\t%[a]" +#endif + + erase(%[a]) + setcc(%[a]) | %[a] | | +cmf tle $1==8 | source8 source8 | + allocate(%[1],%[2],REG) + "cmpd\t%[1],%[2]" +#ifdef LOCLABS + "blss\t1f" + "movl\t$$1,%[a]" + "brb\t2f\n1:" + "clrl\t%[a]\n2:" +#else + "blss\t.+9" + "movl\t$$1,%[a]" + "brb\t.+4" + "clrl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmf teq $1==8 | source8 source8 | + allocate(%[1],%[2],REG) + "cmpd\t%[1],%[2]" +#ifdef LOCLABS + "bneq\t1f" + "movl\t$$1,%[a]" + "brb\t2f\n1:" + "clrl\t%[a]\n2:" +#else + "bneq\t.+9" + "movl\t$$1,%[a]" + "brb\t.+4" + "clrl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmf tne $1==8 | source8 source8 | + allocate(%[1],%[2],REG) + "cmpd\t%[1],%[2]" +#ifdef LOCLABS + "beql\t1f" + "movl\t$$1,%[a]" + "brb\t2f\n1:" + "clrl\t%[a]\n2:" +#else + "beql\t.+9" + "movl\t$$1,%[a]" + "brb\t.+4" + "clrl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmf tge $1==8 | source8 source8 | + allocate(%[1],%[2],REG) + "cmpd\t%[1],%[2]" +#ifdef LOCLABS + "bgtr\t1f" + "movl\t$$1,%[a]" + "brb\t2f\n1:" + "clrl\t%[a]\n2:" +#else + "bgtr\t.+9" + "movl\t$$1,%[a]" + "brb\t.+4" + "clrl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmf tgt $1==8 | source8 source8 | + allocate(%[1],%[2],REG) + "cmpd\t%[1],%[2]" +#ifdef LOCLABS + "bgeq\t1f" + "movl\t$$1,%[a]" + "brb\t2f\n1:" + "clrl\t%[a]\n2:" +#else + "bgeq\t.+9" + "movl\t$$1,%[a]" + "brb\t.+4" + "clrl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +/* Remember that cmu was replaced by cmp. */ +cmp tlt | source4 source4 | + allocate(REG={CONST1,0}) + "cmpl\t%[1],%[2]" +#ifdef LOCLABS + "blequ\t1f" + "incl\t%[a]\n1:" +#else + "blequ\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source1 source1 | + allocate(REG={CONST1,0}) + "cmpb\t%[1],%[2]" +#ifdef LOCLABS + "blequ\t1f" + "incl\t%[a]\n1:" +#else + "blequ\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source2 source2 | + allocate(REG={CONST1,0}) + "cmpw\t%[1],%[2]" +#ifdef LOCLABS + "blequ\t1f" + "incl\t%[a]\n1:" +#else + "blequ\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmp tle | source4 source4 | + allocate(REG={CONST1,0}) + "cmpl\t%[1],%[2]" +#ifdef LOCLABS + "blssu\t1f" + "incl\t%[a]\n1:" +#else + "blssu\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source1 source1 | + allocate(REG={CONST1,0}) + "cmpb\t%[1],%[2]" +#ifdef LOCLABS + "blssu\t1f" + "incl\t%[a]\n1:" +#else + "blssu\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source2 source2 | + allocate(REG={CONST1,0}) + "cmpw\t%[1],%[2]" +#ifdef LOCLABS + "blssu\t1f" + "incl\t%[a]\n1:" +#else + "blssu\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmp teq | source4 source4 | + allocate(REG={CONST1,0}) + "cmpl\t%[1],%[2]" +#ifdef LOCLABS + "bnequ\t1f" + "incl\t%[a]\n1:" +#else + "bnequ\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source1 source1 | + allocate(REG={CONST1,0}) + "cmpb\t%[1],%[2]" +#ifdef LOCLABS + "bnequ\t1f" + "incl\t%[a]\n1:" +#else + "bnequ\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source2 source2 | + allocate(REG={CONST1,0}) + "cmpw\t%[1],%[2]" +#ifdef LOCLABS + "bnequ\t1f" + "incl\t%[a]\n1:" +#else + "bnequ\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmp tne | source4 source4 | + allocate(REG={CONST1,0}) + "cmpl\t%[1],%[2]" +#ifdef LOCLABS + "beqlu\t1f" + "incl\t%[a]\n1:" +#else + "beqlu\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source1 source1 | + allocate(REG={CONST1,0}) + "cmpb\t%[1],%[2]" +#ifdef LOCLABS + "beqlu\t1f" + "incl\t%[a]\n1:" +#else + "beqlu\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source2 source2 | + allocate(REG={CONST1,0}) + "cmpw\t%[1],%[2]" +#ifdef LOCLABS + "beqlu\t1f" + "incl\t%[a]\n1:" +#else + "beqlu\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmp tge | source4 source4 | + allocate(REG={CONST1,0}) + "cmpl\t%[1],%[2]" +#ifdef LOCLABS + "bgtru\t1f" + "incl\t%[a]\n1:" +#else + "bgtru\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source1 source1 | + allocate(REG={CONST1,0}) + "cmpb\t%[1],%[2]" +#ifdef LOCLABS + "bgtru\t1f" + "incl\t%[a]\n1:" +#else + "bgtru\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source2 source2 | + allocate(REG={CONST1,0}) + "cmpw\t%[1],%[2]" +#ifdef LOCLABS + "bgtru\t1f" + "incl\t%[a]\n1:" +#else + "bgtru\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmp tgt | source4 source4 | + allocate(REG={CONST1,0}) + "cmpl\t%[1],%[2]" +#ifdef LOCLABS + "bgequ\t1f" + "incl\t%[a]\n1:" +#else + "bgequ\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source1 source1 | + allocate(REG={CONST1,0}) + "cmpb\t%[1],%[2]" +#ifdef LOCLABS + "bgequ\t1f" + "incl\t%[a]\n1:" +#else + "bgequ\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +... | NC source2 source2 | + allocate(REG={CONST1,0}) + "cmpw\t%[1],%[2]" +#ifdef LOCLABS + "bgequ\t1f" + "incl\t%[a]\n1:" +#else + "bgequ\t.+4" + "incl\t%[a]" +#endif + erase(%[a]) + setcc(%[a]) | %[a] | | +cmp teq and $3==4 + | source4 source4 sreg4 | + "cmpl\t%[2],%[1]" +#ifdef LOCLABS + "beql\t1f" + "clrl\t%[3]\n1:" +#else + "beql\t.+4" + "clrl\t%[3]" +#endif + setcc(%[3]) + erase(%[3]) | %[3] | | +cmp tne and $3==4 + | source4 source4 sreg4 | + "cmpl\t%[2],%[1]" +#ifdef LOCLABS + "bneq\t1f" + "clrl\t%[3]\n1:" +#else + "bneq\t.+4" + "clrl\t%[3]" +#endif + setcc(%[3]) + erase(%[3]) | %[3] | | +cmp teq ior $3==4 + | source4 source4 sreg4 | + "cmpl\t%[2],%[1]" +#ifdef LOCLABS + "bneq\t1f" + "bisl2\t$$1,%[3]\n1:" +#else + "bneq\t.+7" + "bisl2\t$$1,%[3]" +#endif + setcc(%[3]) + erase(%[3]) | %[3] | | +cmp tne ior $3==4 + | source4 source4 sreg4 | + "cmpl\t%[2],%[1]" +#ifdef LOCLABS + "beql\t1f" + "bisl2\t$$1,%[3]\n1:" +#else + "beql\t.+7" + "bisl2\t$$1,%[3]" +#endif + setcc(%[3]) + erase(%[3]) | %[3] | | +cms teq $1==4 | | | | cmp teq | +cms tne $1==4 | | | | cmp tne | + +/**************************************** + * Group 13 : Branch instructions * + ****************************************/ + +bra | STACK | + "jbr\t$1" | | | +blt | source4 source4 STACK | + "cmpl\t%[1],%[2]" + "jgtr\t$1" | | | +... | NC source2 source2 STACK | + "cmpw\t%[1],%[2]" + "jgtru\t$1" | | | +... | NC source1 source1 STACK | + "cmpb\t%[1],%[2]" + "jgtru\t$1" | | | +... | NC source4 STACK | + "cmpl\t%[1],(sp)+" + "jgtr\t$1" | | | +... | STACK | + "cmpl\t(sp)+,(sp)+" + "jgtr\t$1" | | | +ble | source4 source4 STACK | + "cmpl\t%[1],%[2]" + "jgeq\t$1" | | | +... | NC source2 source2 STACK | + "cmpw\t%[1],%[2]" + "jgequ\t$1" | | | +... | NC source1 source1 STACK | + "cmpb\t%[1],%[2]" + "jgequ\t$1" | | | +... | NC source4 STACK | + "cmpl\t%[1],(sp)+" + "jgeq\t$1" | | | +... | STACK | + "cmpl\t(sp)+,(sp)+" + "jgeq\t$1" | | | +beq | source4 source4 STACK | + "cmpl\t%[1],%[2]" + "jeql\t$1" | | | +... | NC source2 source2 STACK | + "cmpw\t%[1],%[2]" + "jeqlu\t$1" | | | +... | NC source1 source1 STACK | + "cmpb\t%[1],%[2]" + "jeqlu\t$1" | | | +... | NC source4 STACK | + "cmpl\t%[1],(sp)+" + "jeql\t$1" | | | +... | STACK | + "cmpl\t(sp)+,(sp)+" + "jeql\t$1" | | | +bne | source4 source4 STACK | + "cmpl\t%[1],%[2]" + "jneq\t$1" | | | +... | NC source2 source2 STACK | + "cmpw\t%[1],%[2]" + "jnequ\t$1" | | | +... | NC source1 source1 STACK | + "cmpb\t%[1],%[2]" + "jnequ\t$1" | | | +... | NC source4 STACK | + "cmpl\t%[1],(sp)+" + "jneq\t$1" | | | +... | STACK | + "cmpl\t(sp)+,(sp)+" + "jneq\t$1" | | | +bge | source4 source4 STACK | + "cmpl\t%[1],%[2]" + "jleq\t$1" | | | +... | NC source2 source2 STACK | + "cmpw\t%[1],%[2]" + "jlequ\t$1" | | | +... | NC source1 source1 STACK | + "cmpb\t%[1],%[2]" + "jlequ\t$1" | | | +... | NC source4 STACK | + "cmpl\t%[1],(sp)+" + "jleq\t$1" | | | +... | STACK | + "cmpl\t(sp)+,(sp)+" + "jleq\t$1" | | | +bgt | source4 source4 STACK | + "cmpl\t%[1],%[2]" + "jlss\t$1" | | | +... | NC source2 source2 STACK | + "cmpw\t%[1],%[2]" + "jlssu\t$1" | | | +... | NC source1 source1 STACK | + "cmpb\t%[1],%[2]" + "jlssu\t$1" | | | +... | NC source4 STACK | + "cmpl\t%[1],(sp)+" + "jlss\t$1" | | | +... | STACK | + "cmpl\t(sp)+,(sp)+" + "jlss\t$1" | | | +zlt | source4 STACK | + test(%[1]) + "jlss\t$1" + samecc | | | +... | NC source1or2 | | | | +zle | source4 STACK | + test(%[1]) + "jleq\t$1" + samecc | | | +... | NC source1or2 | | %[1] | zeq $1 | +zeq | source1or2or4 STACK | + test(%[1]) + "jeql\t$1" + samecc | | | +zne | source1or2or4 STACK | + test(%[1]) + "jneq\t$1" + samecc | | | +zge | source4 STACK | + test(%[1]) + "jgeq\t$1" + samecc | | | +... | NC source1or2 | | | bra $1 | +zgt | source4 STACK | + test(%[1]) + "jgtr\t$1" + samecc | | | +... | NC source1or2 | | %[1] | zne $1 | +cmf zlt $1==4 | source4 source4 STACK | + "cmpf\t%[1],%[2]" + "jgtr\t$2" | | | +cmf zle $1==4 | source4 source4 STACK | + "cmpf\t%[1],%[2]" + "jgeq\t$2" | | | +cmf zne $1==4 | source4 source4 STACK | + "cmpf\t%[1],%[2]" + "jneq\t$2" | | | +cmf zeq $1==4 | source4 source4 STACK | + "cmpf\t%[1],%[2]" + "jeql\t$2" | | | +cmf zge $1==4 | source4 source4 STACK | + "cmpf\t%[1],%[2]" + "jleq\t$2" | | | +cmf zgt $1==4 | source4 source4 STACK | + "cmpf\t%[1],%[2]" + "jlss\t$2" | | | +cmf zlt $1==8 | source8 source8 | + remove(ALL) + "cmpd\t%[1],%[2]" + "jgtr\t$2" | | | +cmf zle $1==8 | source8 source8 | + remove(ALL) + "cmpd\t%[1],%[2]" + "jgeq\t$2" | | | +cmf zne $1==8 | source8 source8 | + remove(ALL) + "cmpd\t%[1],%[2]" + "jneq\t$2" | | | +cmf zeq $1==8 | source8 source8 | + remove(ALL) + "cmpd\t%[1],%[2]" + "jeql\t$2" | | | +cmf zge $1==8 | source8 source8 | + remove(ALL) + "cmpd\t%[1],%[2]" + "jleq\t$2" | | | +cmf zgt $1==8 | source8 source8 | + remove(ALL) + "cmpd\t%[1],%[2]" + "jlss\t$2" | | | +cmp zlt | source4 source4 STACK | + "cmpl\t%[1],%[2]" + "jgtru\t$2" | | | +... | NC source1or2 source1or2 | | %[2] %[1] | blt $2 | +cmp zle | source4 source4 STACK | + "cmpl\t%[1],%[2]" + "jgequ\t$2" | | | +... | NC source1or2 source1or2 | | %[2] %[1] | ble $2 | +cmp zne | | | | bne $2 | +cmp zeq | | | | beq $2 | +cmp zge | source4 source4 STACK | + "cmpl\t%[1],%[2]" + "jlequ\t$2" | | | +... | NC source1or2 source1or2 | | %[2] %[1] | bge $2 | +cmp zgt | source4 source4 STACK | + "cmpl\t%[1],%[2]" + "jlssu\t$2" | | | +... | NC source1or2 source1or2 | | %[2] %[1] | bgt $2 | +cms zeq $1==4 | | | | cmp zeq $2 | +cms zne $1==4 | | | | cmp zne $2 | + +/************************************************ + * Group 14 : Procedure call instructions * + ************************************************/ + +cai | | remove(ALL) + "jsb\t*(sp)+" | | | (2,10) +... | reg4 | + remove(ALL) + "jsb\t(%[1])" | | | (2,7) +cal | | remove(ALL) + "jsb\t$1" | | | +lfr $1==4 | | | R0 | | +lfr $1==8 | | | QR0 | | +asp ret $2==0 | | | | ret 0 | +ass ret $2==0 | | | | ret 0 | +asp lfr ret $2==$3 | | | | ret 0 | +ass lfr ret $2==$3 | | | | ret 0 | +lfr ret $1==$2 | | | | ret 0 | +#ifdef REGVARS +ret $1==0 | | remove(ALL) + return | | | +#else REGVARS +ret $1==0 | | remove(ALL) + "movl\tfp,sp" + "movl\t(sp)+,fp" + "rsb" | | | +#endif REGVARS +ret $1==4 | bigsource4 | + move(%[1],R0) | | ret 0 | +ret $1==8 | bigsource8 | + move(%[1],QR0) | | ret 0 | +... | bigsource4 bigsource4 | + move(%[1],R0) + move(%[2],R1) | | ret 0 | + +/******************************** + * Group 15 : Miscellaneous * + ********************************/ + +#ifdef REGVARS +asp $1==4 | bigsource4 - regch4 | | | | +#else REGVARS +asp $1==4 | NC bigsource4 | | | | +#endif REGVARS +... | | remove(ALL) + "tstl\t(sp)+" | | | (2,7) +asp $1>0 | | remove(ALL) + "addl2\t$$$1,sp" | | | +asp $1==(0-4) | | | {CONST4,0} | | +asp $1==(0-8) | | | {CONST8,"0"} | | +asp | | remove(ALL) + "subl2\t$$%(0-$1%),sp" | | | +ass $1==4 | source4 | + remove(ALL) + "addl2\t%[1],sp" | | | +ass !defined($1) | source4 | + remove(ALL) + move(%[1],R2) + "jsb\t.ass" + erase(R2) | | | +blm $1==4 | nonexist1 nonexist1 | + remove(ALL) + "movl\t%[2],%[1]" | | | +blm $1==8 | nonexist1 nonexist1 | + remove(ALL) + "movq\t%[2],%[1]" | | | +blm $1==12 | sreg4 sreg4 | + remove(ALL) + "movl\t(%[2])+,(%[1])+" + "movq\t(%[2]),(%[1])" + erase(%[1]) erase(%[2]) | | | +blm $1==16 | sreg4 sreg4 | + remove(ALL) + "movq\t(%[2])+,(%[1])+" + "movq\t(%[2]),(%[1])" + erase(%[1]) erase(%[2]) | | | +blm | sreg4 sreg4 | + remove(ALL) + allocate(REG={CONST1, $1/4}) +#ifdef LOCLABS + "1:\nmovl\t(%[2])+,(%[1])+" + "sobgtr\t%[a],1b" +#else + "\nmovl\t(%[2])+,(%[1])+" + "sobgtr\t%[a],.-3" +#endif + erase(%[1]) erase(%[2]) erase(%[a]) + | | | +bls $1==4 | | + remove(ALL) + move({CONST1,4},R0) + "jsb\t.bls" + erase(R0) | | | +bls !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.bls" + erase(R0) | | | +csa $1==4 | | remove(ALL) + "jmp\t.csa4" | | | +csa !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jmp\t.csa" + erase(R0) | | | +csb $1==4 | | remove(ALL) + "jmp\t.csb4" | | | +csb !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jmp\t.csb" + erase(R0) | | | +dch | | | | loi 4 | +dup stl $1==4 | | | | stl $2 lol $2 | +#ifdef REGVARS +dup sil $1==4 && inreg($2)==2 + | bigsource4 | + REMEXTANDLOC + move(%[1],{regdef4,regvar($2)}) + | {regdef4,regvar($2)} | | +#endif REGVARS +dup $1==4 | reg4+regdef4 | | %[1] %[1] | | +#ifdef REGVARS +dup $1==8 | bigsource8-regch8 | | %[1] %[1] | | +#else REGVARS +dup $1==8 | bigsource8 | | %[1] %[1] | | +#endif REGVARS +dup | | remove(ALL) + allocate(REG,REG={CONST1,$1/4}) + "addl3\tsp,$$$1,%[a]" +#ifdef LOCLABS + "1:\nmovl\t-(%[a]),-(sp)" + "sobgtr\t%[b],1b" +#else + "movl\t-(%[a]),-(sp)" + "sobgtr\t%[b],.-3" +#endif + erase(%[b]) | | | +dus $1==4 | source4 | + remove(ALL) + allocate(REG,REG) + "ashl\t$$-2,%[1],%[b]" + "addl3\tsp,%[1],%[a]" +#ifdef LOCLABS + "1:\nmovl\t-(%[a]),-(sp)" + "sobgtr\t%[b],1b" +#else + "movl\t-(%[a]),-(sp)" + "sobgtr\t%[b],.-3" +#endif + | | | +dus !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.dus" + erase(R0) | | | +exg $1==4 | bigsource4 bigsource4 | | %[1] %[2] | | +exg $1==8 | bigsource8 bigsource8 | | %[1] %[2] | | +exg defined($1) | | remove(ALL) + move({CONST4,$1},R0) + "jsb\t.exg" + erase(R0) | | | +exg !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.exg" + erase(R0) | | | +fil | | "movl\t$$$1,hol0+4" | | | +lim | | allocate(REG) + "movl\t.trpim,%[a]" | %[a] | | +lin | | "movl\t$$$1,hol0" | | | +lni | | "incl\thol0" | | | +gto | | remove(ALL) + "pushl\t$$$1" + "jmp\t.gto" | | | +lor $1==0 | | | LB | | +lor $1==1 | | remove(ALL) + allocate(REG) + "movl\tsp,%[a]" | %[a] | | +lor $1==2 | | allocate(REG) + "movl\t.reghp,%[a]" | %[a] | | +lpb | bigsource4 | + remove(ALL) + move(%[1],R0) + "jsb\t.lpb" + erase(R0) | R0 | | +mon | | remove(ALL) + "jsb\t.mon" | | | +nop | | remove(ALL) + "jsb\t.nop" | | | +#ifdef DORCK +rck $1==4 | | remove(ALL) + "jsb\t.rck4" | | | +rck !defined($1) | source4 | + remove(ALL) + move(%[1],R0) + "jsb\t.rck" + erase(R0) | | | +#else DORCK +#ifdef REGVARS +rck defined($1) | bigsource4-regch4 | | | | +rck !defined($1) | bigsource4-regch4 bigsource4-regch4 | | | | +#else REGVARS +rck defined($1) | bigsource4 | | | | +rck !defined($1) | bigsource4 bigsource4 | | | | +#endif REGVARS +#endif DORCK +rtt | | | | ret 0 | +sig | | remove(ALL) + "jsb\t.sig" | | | +sim | | remove(ALL) + "jsb\t.sim" | | | +str $1==0 | source4 | + remove(ALL) + "movl\t%[1],fp" | | | +str $1==1 | source4 | + remove(ALL) + "movl\t%[1],sp" | | | +str $1==2 | | remove(ALL) + "jsb\t.strhp" | | | +trp | | remove(ALL) + "jsb\t.trp" | | | + +/******************************** + * Coercions: * + * * + * A: From source to register, * + * from nonexist to source. * + ********************************/ + +| ADDR_EXTERNAL | | {DOUBLE,%[1.ind]} | | +| source1 | allocate(%[1],REG=%[1]) | %[a] | | +| source2 | allocate(%[1],REG=%[1]) | %[a] | | +| bigsource4 | allocate(%[1],REG=%[1]) | %[a] | | +| bigsource8 | allocate(%[1],QREG=%[1]) | %[a] | | + +/******************************** + * B: From STACK to register * + ********************************/ + +| STACK | allocate(REG) + "movl\t(sp)+,%[a]" + setcc(%[a]) | %[a] | | (3,7) +| STACK | allocate(QREG) + "movq\t(sp)+,%[a]" + setcc(%[a]) | %[a] | | (3,10) +| STACK | allocate(REG) + "movl\t(sp)+,%[a]" + setcc(%[a]) | {adispl,%[a],"0"} | | (3,7) + +/**************** + * C: General * + ****************/ + +| regdef8 | | {displ4,%[1.reg],"4"} {regdef4,%[1.reg]} | | +| displ8 | | {displ4,%[1.reg],%[1.ind]+"+4"} + {displ4,%[1.reg],%[1.ind]} | | +| LOCAL8 | | {LOCAL4,%[1.num]+4,4} {LOCAL4,%[1.num],4} | | +| EXTERNAL8 | | {EXTERNAL4,%[1.ind]+"+4"} {EXTERNAL4,%[1.ind]} | | +| QREG | | %[1.2] %[1.1] | | +| regdef4 | | {displ4,%[1.reg],"0"} | | +| ADDR_LOCAL | | {adispl,LB,tostring(%[1.num])} | | +| reg4 | | {adispl,%[1],"0"} | | +| LOCAL4 | | {displ4,LB,tostring(%[1.num])} | | +| nonexist+source4-reg4-adispl-ADDR_LOCAL | + allocate(%[1],REG=%[1]) | {adispl,%[a],"0"} | | + +MOVES: +(CONST %[num]==0, source1, "clrb\t%[2]", (2,4)+%[2]) +(CONST %[num]==0, source2, "clrw\t%[2]", (2,4)+%[2]) +(CONST %[num]==0, source4, "clrl\t%[2]" + setcc(%[2]), (2,4)+%[2]) +(CONST %[num]<0 && ufit(0-%[num],6), source2, + "mnegw\t$$%(0-%[1.num]%),%[2]" + setcc(%[2]), (2,4)+%[2]) +(CONST ufit(%[num],8) && !ufit(%[num],6), source2, + "movzbw\t%[1],%[2]" + setcc(%[2]), (2,4)+%[2]) +(CONST sfit(%[num],8) && !ufit(%[num],6), source2, + "cvtbw\t%[1],%[2]" + setcc(%[2]), (2,4)+%[2]) +(CONST %[num]<0 && ufit(0-%[num],6), source4, + "mnegl\t$$%(0-%[1.num]%),%[2]" + setcc(%[2]), (2,4)+%[2]) +(CONST ufit(%[num],8) && !ufit(%[num],6), source4, + "movzbl\t%[1],%[2]" + setcc(%[2]), (2,4)+%[2]) +(CONST sfit(%[num],8) && !ufit(%[num],6), source4, + "cvtbl\t%[1],%[2]" + setcc(%[2]), (2,4)+%[2]) +(CONST ufit(%[num],16) && !ufit(%[num],6), source4, + "movzwl\t%[1],%[2]" + setcc(%[2]), (2,4)+%[2]) +(CONST sfit(%[num],16) && !ufit(%[num],6), source4, + "cvtwl\t%[1],%[2]" + setcc(%[2]), (2,4)+%[2]) +(CONST8 %[ind]=="0", source8, "clrq\t%[2]" + setcc(%[2]), (2,4)+%[2]) +(FCONST8 %[num]==0, source8, "clrq\t%[2]" + setcc(%[2]), (2,4)+%[2]) +(FCONST8, source8, "movd\t%[1],%[2]" + setcc(%[2]), (3,4)+%[1]+%[2]) +#ifdef REGVARS +/* Tokens with side effects should not be remembered. */ +(reginc1+regdec1,reg4, "movzbl\t%[1],%[2]" + setcc(%[2]) erase(%[2]),(3,4)+%[1]) +(reginc2+regdec2,reg4, "movzwl\t%[1],%[2]" + setcc(%[2]) erase(%[2]),(3,4)+%[1]) +(reginc4+regdec4,reg4, "movl\t%[1],%[2]" + setcc(%[2]) erase(%[2]),(3,4)+%[1]) +(reginc8+regdec8,reg8, "movq\t%[1],%[2]" + setcc(%[2]) erase(%[2]),(3,7)+%[1]) +#endif REGVARS +(source8, source8, "movq\t%[1],%[2]" + setcc(%[2]), (3,4)+%[1]+%[2]) +(source4, source4, "movl\t%[1],%[2]" + setcc(%[2]), (3,4)+%[1]+%[2]) +(source2, source2, "movw\t%[1],%[2]" + setcc(%[2]), (3,4)+%[1]+%[2]) +(source1, source1, "movb\t%[1],%[2]" + setcc(%[2]), (3,4)+%[1]+%[2]) +(source1, source2, "movzbw\t%[1],%[2]" + setcc(%[2]), (3,4)+%[1]+%[2]) +(source1, source4, "movzbl\t%[1],%[2]" + setcc(%[2]), (3,4)+%[1]+%[2]) +(source2, source4, "movzwl\t%[1],%[2]" + setcc(%[2]), (3,4)+%[1]+%[2]) +(source2, source1, "cvtwb\t%[1],%[2]" + setcc(%[2]), (3,4)+%[1]+%[2]) +(source4, source1, "cvtlb\t%[1],%[2]" + setcc(%[2]), (3,4)+%[1]+%[2]) +(source4, source2, "cvtlw\t%[1],%[2]" + setcc(%[2]), (3,4)+%[1]+%[2]) +(aind1, source4, "movab\t%[1],%[2]" + setcc(%[2]), (3,4)+%[1]+%[2]) +(aind2, source4, "movaw\t%[1],%[2]" + setcc(%[2]), (3,4)+%[1]+%[2]) +(aind4, source4, "moval\t%[1],%[2]" + setcc(%[2]), (3,4)+%[1]+%[2]) +(aind8, source4, "movaq\t%[1],%[2]" + setcc(%[2]), (3,4)+%[1]+%[2]) +(nonexist1, source4, "movab\t%[1],%[2]" + setcc(%[2]), (3,4)+%[1]+%[2]) +TESTS: +(source1, "tstb\t%[1]" ,(2,4) + %[1]) +(source2, "tstw\t%[1]" ,(2,4) + %[1]) +(source4, "tstl\t%[1]" ,(2,4) + %[1]) + +STACKS: + +(CONST %[num]==0, , + "clrl\t-(sp)", (2,7)) +(CONST %[num]<0 && ufit(0-%[num],6), , + "mnegl\t$$%(0-%[1.num]%),-(sp)", + (2,7) + %[1]) +(CONST ufit(%[num],6), , + "pushl\t%[1]", (2,7) + %[1]) +(CONST8 %[ind]=="0", , + "clrq\t-(sp)", (2,10)) +(CONST sfit(%[num],8), , + "cvtbl\t%[1],-(sp)", (3,7) + %[1]) +(source1, , "movzbl\t%[1],-(sp)", (3,7) + %[1]) +(CONST sfit(%[num],16), , + "cvtwl\t%[1],-(sp)", (3,7) + %[1]) +(source2, , "movzwl\t%[1],-(sp)", (3,7) + %[1]) +(source4, , "pushl\t%[1]" + setcc(%[1]), (2,7) + %[1]) +(source8, , "movq\t%[1],-(sp)" + setcc(%[1]), (3,10)+ %[1]) +(nonexist1, , "pushal\t%[1]", (2,7) + %[1]) +(FCONST8 %[num]==0, , + "clrq\t-(sp)", (2,10)) +(FCONST8, , "movd\t%[1],-(sp)", (3,10) + %[1]) +(aind1, , "pushab\t%[1]", (2,7) + %[1]) +(aind2, , "pushaw\t%[1]", (2,7) + %[1]) +(aind4, , "pushal\t%[1]", (2,7) + %[1]) +(aind8, , "pushaq\t%[1]", (2,7) + %[1]) -- 2.34.1