4649 lines
121 KiB
Plaintext
4649 lines
121 KiB
Plaintext
"$Id$"
|
|
#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 */
|
|
#define FLOAT8 /* define if you want better 8-byte FP arithmetic */
|
|
/* #define ASBUG_AVOID /* define if you want to avoid a bug in the BSD 4.1 VAX
|
|
assembler, that sometimes generates "*1" for
|
|
(r1). This is avoided by generating 0(r1), which is
|
|
optimized by the assembler to (r1).
|
|
*/
|
|
#ifdef ASBUG_AVOID
|
|
#define REGDEFFORMAT "0(%[reg])"
|
|
#else
|
|
#define REGDEFFORMAT "(%[reg])"
|
|
#endif
|
|
|
|
#define NC nocoercions :
|
|
#define BSIZE 4
|
|
|
|
EM_PSIZE = 4
|
|
EM_WSIZE = 4
|
|
EM_BSIZE = BSIZE
|
|
|
|
/****************************************************************
|
|
* 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:
|
|
AP = ("ap",4),ArgumentPointer.
|
|
LB = ("fp",4),LocaLBase.
|
|
R0 = ("r0",4),REG.
|
|
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.
|
|
QR2 = ("r2",8,R2,R3),QREG.
|
|
#ifndef REGVARS
|
|
QR4 = ("r4",8,R4,R5),QREG.
|
|
QR6 = ("r6",8,R6,R7),QREG.
|
|
QR8 = ("r8",8,R8,R9),QREG.
|
|
QRA = ("r10",8,RA,RB),QREG.
|
|
#endif /* REGVARS */
|
|
QR1 = ("r1",8,R1,R2),QREG.
|
|
#ifndef REGVARS
|
|
QR3 = ("r3",8,R3,R4),QREG.
|
|
QR5 = ("r5",8,R5,R6),QREG.
|
|
QR7 = ("r7",8,R7,R8),QREG.
|
|
QR9 = ("r9",8,R9,RA),QREG.
|
|
#endif /* REGVARS */
|
|
|
|
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]"
|
|
LOCAL1 = {REGISTER reg; INT num,size;} 4 cost=(2,6) "%[num](%[reg])"
|
|
LOCAL2 = {REGISTER reg; INT num,size;} 4 cost=(2,6) "%[num](%[reg])"
|
|
LOCAL4 = {REGISTER reg; INT num,size;} 4 cost=(2,6) "%[num](%[reg])"
|
|
LOCAL8 = {REGISTER reg; INT num,size;} 8 cost=(2,9) "%[num](%[reg])"
|
|
ADDR_LOCAL = {REGISTER reg; INT num;} 4 cost=(2,6) "%[num](%[reg])"
|
|
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) REGDEFFORMAT
|
|
regdef2 = {REGISTER reg;} 4 cost=(0,3) REGDEFFORMAT
|
|
regdef4 = {REGISTER reg;} 4 cost=(0,3) REGDEFFORMAT
|
|
regdef8 = {REGISTER reg;} 8 cost=(0,6) REGDEFFORMAT
|
|
#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
|
|
ind2 = extind2 + displind2 + extdefind2 + displdefind2
|
|
ind4 = extind4 + displind4 + extdefind4 + displdefind4
|
|
Xsource1 = regdef1 + displ1 + displdef1 +
|
|
EXTERNAL1 + reldef1 + CONST1 + LOCAL1
|
|
+ displind1 + extdefind1 + displdefind1
|
|
source1 = Xsource1
|
|
#ifdef REGVARS
|
|
+ reginc1 + regdec1
|
|
#endif /* REGVARS */
|
|
Xsource2 = regdef2 + displ2 + displdef2 +
|
|
EXTERNAL2 + reldef2 + CONST2 + LOCAL2 + ind2
|
|
source2 = Xsource2
|
|
#ifdef REGVARS
|
|
+ reginc2 + regdec2
|
|
#endif /* REGVARS */
|
|
Xsource4 = REG + regdef4 + displ4 + displdef4 + LocaLBase +
|
|
EXTERNAL4 + reldef4 + CONST + DOUBLE + LOCAL4 + ind4
|
|
source4 = Xsource4
|
|
#ifdef REGVARS
|
|
+ RREG + reginc4 + regdec4
|
|
#endif /* REGVARS */
|
|
dups4 = CONST + regdef1 + displ1 + LOCAL1 +
|
|
REG + regdef2 + displ2 + LOCAL2 +
|
|
RREG + regdef4 + displ4 + LOCAL4 + DOUBLE
|
|
Xsource8 = QREG + regdef8 + displ8 + displdef8 +
|
|
EXTERNAL8 + reldef8 + CONST8 + LOCAL8
|
|
+ extind8 + displind8 + extdefind8 + displdefind8
|
|
source8 = Xsource8
|
|
#ifdef REGVARS
|
|
+ reginc8 + regdec8
|
|
#endif /* REGVARS */
|
|
source1or2 = source1 + source2 - ind2
|
|
source1or2or4 = source1or2 + source4 - (ind2 + ind4)
|
|
source2or4 = source2 + source4 - ind4
|
|
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
|
|
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 + LocaLBase
|
|
reg8 = QREG
|
|
#else /* REGVARS */
|
|
reg4 = REG
|
|
reg8 = QREG
|
|
#endif /* REGVARS */
|
|
sreg4 = REG * SCRATCH
|
|
sreg8 = QREG * SCRATCH
|
|
bigsource4 = source1or2or4 + nonexist + ind2 + ind4
|
|
bigsource8 = source8
|
|
all = bigsource4 + bigsource8
|
|
scr = ALL - (EXTERNALS + LOCALS + ADDR_LOCAL + ADDR_EXTERNAL + CONST
|
|
+ DOUBLE)
|
|
#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} | |
|
|
ldc | | | {CONST8,$1} | |
|
|
#ifdef REGVARS
|
|
lol inreg($1)==2 | | REMREG($1) | regvar($1) | |
|
|
#endif /* REGVARS */
|
|
lol $1 < 0 | | | {LOCAL4,LB,$1,4} | |
|
|
lol $1 >= 0 | | | {LOCAL4,AP,$1,4} | |
|
|
loe | | | {EXTERNAL4,$1} | |
|
|
#ifdef REGVARS
|
|
lil inreg($1)==2 | | REMREG($1) | {regdef4,regvar($1)} | |
|
|
#endif /* REGVARS */
|
|
lil $1 < 0 | | | {displdef4,LB,tostring($1)} | |
|
|
lil $1 >= 0 | | | {displdef4,AP,tostring($1)} | |
|
|
lof | | | | adp $1 loi 4 |
|
|
lal $1 < 0 | | | {ADDR_LOCAL,LB,$1} | |
|
|
lal $1 >= 0 | | | {ADDR_LOCAL,AP,$1} | |
|
|
lae | | | {ADDR_EXTERNAL,$1} | |
|
|
lxl $1==0 | | | LB | |
|
|
lxl $1==1 | | | {LOCAL4,AP,BSIZE,4} | |
|
|
lxl $1 > 1 | | remove(scr)
|
|
move({CONST4,$1},R0)
|
|
"jsb\t.lxl"
|
|
erase(R0) | R0 | |
|
|
lxa $1==0 | | | {ADDR_LOCAL,AP,BSIZE} | |
|
|
lxa $1==1 | | | {LOCAL4,AP,BSIZE,4} | lpb |
|
|
lxa $1 > 1 | | remove(scr)
|
|
move({CONST4,$1},R0)
|
|
"jsb\t.lxa"
|
|
erase(R0) | R0 | |
|
|
loi $1==1 | NC adispl | | {displ1,%[1.reg],%[1.ind]} | |
|
|
... | NC ADDR_LOCAL | | {LOCAL1,%[1.reg],%[1.num],1} | |
|
|
... | NC LOCAL4 | | {displdef1,%[1.reg],tostring(%[1.num])} | |
|
|
... | NC regdef4 | | {displdef1,%[1.reg],"0"} | |
|
|
... | NC displ4 | | {displdef1,%[1.reg],%[1.ind]} | |
|
|
... | 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]} | |
|
|
... | reg4 | | {regdef1,%[1]} | |
|
|
loi $1==2 | NC adispl | | {displ2,%[1.reg],%[1.ind]} | |
|
|
... | NC ADDR_LOCAL | | {LOCAL2,%[1.reg],%[1.num],2} | |
|
|
... | NC LOCAL4 | | {displdef2,%[1.reg],tostring(%[1.num])} | |
|
|
... | NC regdef4 | | {displdef2,%[1.reg],"0"} | |
|
|
... | NC 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]} | |
|
|
... | reg4 | | {regdef2,%[1]} | |
|
|
loi $1==4 | NC adispl | | {displ4,%[1.reg],%[1.ind]} | |
|
|
... | NC ADDR_LOCAL | | {LOCAL4,%[1.reg],%[1.num],4} | |
|
|
... | NC LOCAL4 | | {displdef4,%[1.reg],tostring(%[1.num])} | |
|
|
... | NC regdef4 | | {displdef4,%[1.reg],"0"} | |
|
|
... | NC 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]} | |
|
|
... | reg4 | | {regdef4,%[1]} | |
|
|
loi $1==8 | NC adispl | | {displ8,%[1.reg],%[1.ind]} | |
|
|
... | NC ADDR_LOCAL | | {LOCAL8,%[1.reg],%[1.num],8} | |
|
|
... | NC LOCAL4 | | {displdef8,%[1.reg],tostring(%[1.num])} | |
|
|
... | NC regdef4 | | {displdef8,%[1.reg],"0"} | |
|
|
... | NC 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]} | |
|
|
... | reg4 | | {regdef8,%[1]} | |
|
|
loi $1>8 && $1<=16
|
|
| NC ADDR_EXTERNAL |
|
|
| {EXTERNAL8,%[1.ind]+"+"+tostring($1-8)}
|
|
%[1] | loi $1-8 |
|
|
... | NC ADDR_LOCAL |
|
|
| {LOCAL8,%[1.reg],%[1.num]+$1-8,8} %[1]
|
|
| loi $1-8 |
|
|
... | reg4 | | {displ8,%[1],tostring($1-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 | STACK |
|
|
move({CONST1,4},R0)
|
|
"jsb\t.los"
|
|
erase(R0) | | |
|
|
los !defined($1) | source1or2or4 |
|
|
remove(ALL)
|
|
move(%[1],R0)
|
|
"jsb\t.los"
|
|
erase(R0) | | |
|
|
ldl $1<0 | | | {LOCAL8,LB,$1,8} | |
|
|
ldl $1>=0 | | | {LOCAL8,AP,$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)) | | |
|
|
... | STACK |
|
|
"movl\t(sp)+,%(regvar($1)%)" | | | (3,7)
|
|
#endif /* REGVARS */
|
|
stl $1 < 0 | NC bigsource4 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $1+3 && %[num]+%[size] > $1)
|
|
move(%[1],{LOCAL4,LB,$1,4}) | | |
|
|
... | STACK |
|
|
"movl\t(sp)+,$1(fp)" | | | (5,14)
|
|
stl $1 >= 0 | NC bigsource4 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $1+3 && %[num]+%[size] > $1)
|
|
move(%[1],{LOCAL4,AP,$1,4}) | | |
|
|
... | STACK |
|
|
"movl\t(sp)+,$1(ap)" | | | (5,14)
|
|
ste | NC bigsource4 |
|
|
remove(externals)
|
|
move(%[1],{EXTERNAL4,$1}) | | |
|
|
... | STACK |
|
|
"movl\t(sp)+,$1" | | | (7,14)
|
|
#ifdef REGVARS
|
|
sil inreg($1)==2 | NC bigsource4 |
|
|
REMEXTANDLOC
|
|
move(%[1],{regdef4,regvar($1)}) | | |
|
|
... | STACK |
|
|
"movl\t(sp)+,(%(regvar($1)%))" | | | (3,10)
|
|
#endif /* REGVARS */
|
|
sil $1 < 0 | NC bigsource4 |
|
|
REMEXTANDLOC
|
|
move(%[1],{displdef4,LB,tostring($1)}) | | |
|
|
... | STACK |
|
|
"movl\t(sp)+,*$1(fp)" | | | (5,17)
|
|
sil $1 >= 0 | NC bigsource4 |
|
|
REMEXTANDLOC
|
|
move(%[1],{displdef4,AP,tostring($1)}) | | |
|
|
... | STACK |
|
|
"movl\t(sp)+,*$1(ap)" | | | (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.reg],%[1.num],1}) | | |
|
|
... | NC 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]})
|
|
| | |
|
|
... | reg4 source1or2or4 |
|
|
REMEXTANDLOC
|
|
move(%[2],{regdef1,%[1]}) | | |
|
|
... | NC nonexist1+aind1 STACK |
|
|
"cvtlb\t(sp)+,%[1]" | | | (3,7)+%[1]
|
|
sti $1==2 | NC adispl source1or2or4 |
|
|
REMEXTANDLOC
|
|
move(%[2],{displ2,%[1.reg],%[1.ind]}) | | |
|
|
... | NC ADDR_LOCAL source1or2or4 |
|
|
remove(displaced)
|
|
remove(LOCALS,
|
|
%[num]<=%[1.num] && %[num]+%[size]>%[1.num])
|
|
move(%[2],{LOCAL2,%[1.reg],%[1.num],2}) | | |
|
|
... | NC 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]})
|
|
| | |
|
|
... | reg4 source1or2or4 |
|
|
REMEXTANDLOC
|
|
move(%[2],{regdef2,%[1]}) | | |
|
|
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] |
|
|
... | NC LOCAL4 bigsource4 |
|
|
REMEXTANDLOC
|
|
move(%[2],{displdef4,%[1.reg],tostring(%[1.num])}) | | |
|
|
... | NC regdef4 bigsource4 |
|
|
REMEXTANDLOC
|
|
move(%[2],{displdef4,%[1.reg],"0"}) | | |
|
|
... | NC 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]})
|
|
| | |
|
|
... | NC nonexist1+aind4 STACK |
|
|
"movl\t(sp)+,%[1]" | | | (3,7)+%[1]
|
|
... | reg4 bigsource4 |
|
|
REMEXTANDLOC
|
|
move(%[2],{regdef4,%[1]}) | | |
|
|
... | reg4 STACK |
|
|
"movl\t(sp)+,(%[1])" | | | (3,10)
|
|
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] |
|
|
... | NC displ4 bigsource8 |
|
|
REMEXTANDLOC
|
|
move(%[2],{displdef8,%[1.reg],%[1.ind]}) | | |
|
|
... | NC LOCAL4 bigsource8 |
|
|
REMEXTANDLOC
|
|
move(%[2],{displdef8,%[1.reg],tostring(%[1.num])}) | | |
|
|
... | NC regdef4 bigsource8 |
|
|
REMEXTANDLOC
|
|
move(%[2],{displdef8,%[1.reg],"0"}) | | |
|
|
... | 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]})
|
|
| | |
|
|
... | reg4 bigsource8 |
|
|
REMEXTANDLOC
|
|
move(%[2],{regdef8,%[1]}) | | |
|
|
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 $1 < 0 | NC bigsource8 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num]<=$1+7 && %[num]+%[size]>$1)
|
|
move(%[1],{LOCAL8,LB,$1,8}) | | |
|
|
... | NC bigsource4 bigsource4 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num]<=$1+7 && %[num]+%[size]>$1)
|
|
move(%[1],{LOCAL4,LB,$1,4})
|
|
move(%[2],{LOCAL4,LB,$1+4,4}) | | |
|
|
... | STACK |
|
|
"movq\t(sp)+,$1(fp)" | | | (5,14)
|
|
sdl $1 >= 0 | NC bigsource8 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num]<=$1+7 && %[num]+%[size]>$1)
|
|
move(%[1],{LOCAL8,AP,$1,8}) | | |
|
|
... | NC bigsource4 bigsource4 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num]<=$1+7 && %[num]+%[size]>$1)
|
|
move(%[1],{LOCAL4,AP,$1,4})
|
|
move(%[2],{LOCAL4,AP,$1+4,4}) | | |
|
|
... | STACK |
|
|
"movq\t(sp)+,$1(ap)" | | | (5,14)
|
|
sde | NC bigsource8 |
|
|
remove(externals)
|
|
move(%[1],{EXTERNAL8,$1}) | | |
|
|
... | bigsource4 bigsource4 |
|
|
remove(externals)
|
|
move(%[1],{EXTERNAL4,$1})
|
|
move(%[2],{EXTERNAL4,$1+"+4"}) | | |
|
|
... | STACK |
|
|
"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]
|
|
... | source4 source4 |
|
|
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 && $2<0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num]<=$2+3 && %[num]+%[size]>$2)
|
|
"addl3\t%[1],%[2],$2(fp)"
|
|
setcc({LOCAL4,LB,$2,4}) | | |
|
|
adi stl $1==4 && $2>=0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num]<=$2+3 && %[num]+%[size]>$2)
|
|
"addl3\t%[1],%[2],$2(ap)"
|
|
setcc({LOCAL4,AP,$2,4}) | | |
|
|
#ifdef REGVARS
|
|
adi sil $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"addl3\t%[1],%[2],(%(regvar($2)%))"
|
|
setcc({regdef4,regvar($2)}) | | |
|
|
adi lol stf $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"addl3\t%[1],%[2],$3(%(regvar($2)%))"
|
|
setcc({displ4,regvar($2),tostring($3)}) | | |
|
|
#endif /* REGVARS */
|
|
adi sil $1==4 && $2<0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"addl3\t%[1],%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
adi sil $1==4 && $2>=0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"addl3\t%[1],%[2],*$2(ap)"
|
|
setcc({displdef4,AP,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]
|
|
... | source4 source4 |
|
|
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 && $2<0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"subl3\t%[1],%[2],$2(fp)"
|
|
setcc({LOCAL4,LB,$2,4}) | | |
|
|
sbi stl $1==4 && $2>=0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"subl3\t%[1],%[2],$2(ap)"
|
|
setcc({LOCAL4,AP,$2,4}) | | |
|
|
#ifdef REGVARS
|
|
sbi sil $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"subl3\t%[1],%[2],(%(regvar($2)%))"
|
|
setcc({regdef4,regvar($2)}) | | |
|
|
sbi lol stf $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"subl3\t%[1],%[2],$3(%(regvar($2)%))"
|
|
setcc({displ4,regvar($2),tostring($3)}) | | |
|
|
#endif /* REGVARS */
|
|
sbi sil $1==4 && $2<0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"subl3\t%[1],%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
sbi sil $1==4 && $2>=0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"subl3\t%[1],%[2],*$2(ap)"
|
|
setcc({displdef4,AP,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]
|
|
... | source4 source4 |
|
|
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 && $2<0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"mull3\t%[1],%[2],$2(fp)"
|
|
setcc({LOCAL4,LB,$2,4}) | | |
|
|
mli stl $1==4 && $2>=0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"mull3\t%[1],%[2],$2(ap)"
|
|
setcc({LOCAL4,AP,$2,4}) | | |
|
|
#ifdef REGVARS
|
|
mli sil $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"mull3\t%[1],%[2],(%(regvar($2)%))"
|
|
setcc({regdef4,regvar($2)}) | | |
|
|
mli lol stf $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"mull3\t%[1],%[2],$3(%(regvar($2)%))"
|
|
setcc({displ4,regvar($2),tostring($3)}) | | |
|
|
#endif /* REGVARS */
|
|
mli sil $1==4 && $2<0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"mull3\t%[1],%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
mli sil $1==4 && $2>=0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"mull3\t%[1],%[2],*$2(ap)"
|
|
setcc({displdef4,AP,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]
|
|
... | source4 source4 |
|
|
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 && $2<0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"divl3\t%[1],%[2],$2(fp)"
|
|
setcc({LOCAL4,LB,$2,4}) | | |
|
|
dvi stl $1==4 && $2>=0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"divl3\t%[1],%[2],$2(ap)"
|
|
setcc({LOCAL4,AP,$2,4}) | | |
|
|
#ifdef REGVARS
|
|
dvi sil $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"divl3\t%[1],%[2],(%(regvar($2)%))"
|
|
setcc({regdef4,regvar($2)}) | | |
|
|
dvi lol stf $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"divl3\t%[1],%[2],$3(%(regvar($2)%))"
|
|
setcc({displ4,regvar($2),tostring($3)}) | | |
|
|
#endif /* REGVARS */
|
|
dvi sil $1==4 && $2<0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"divl3\t%[1],%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
dvi sil $1==4 && $2>=0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"divl3\t%[1],%[2],*$2(ap)"
|
|
setcc({displdef4,AP,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 | Xsource4 Xsource4 |
|
|
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
|
|
| Xsource4 Xsource4 |
|
|
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 && $2<0
|
|
| Xsource4 Xsource4 |
|
|
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,LB,$2,4}) | | |
|
|
rmi stl $1==4 && $2>=0
|
|
| Xsource4 Xsource4 |
|
|
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(ap)"
|
|
setcc({LOCAL4,AP,$2,4}) | | |
|
|
#ifdef REGVARS
|
|
rmi sil $1==4 && inreg($2)==2
|
|
| Xsource4 Xsource4 |
|
|
REMEXTANDLOC
|
|
allocate(REG)
|
|
"divl3\t%[1],%[2],%[a]"
|
|
"mull2\t%[1],%[a]"
|
|
"subl3\t%[a],%[2],(%(regvar($2)%))"
|
|
setcc({regdef4,regvar($2)}) | | |
|
|
rmi lol stf $1==4 && inreg($2)==2
|
|
| Xsource4 Xsource4 |
|
|
REMEXTANDLOC
|
|
allocate(REG)
|
|
"divl3\t%[1],%[2],%[a]"
|
|
"mull2\t%[1],%[a]"
|
|
"subl3\t%[a],%[2],$3(%(regvar($2)%))"
|
|
setcc({displ4,regvar($2),tostring($3)}) | | |
|
|
#endif /* REGVARS */
|
|
rmi sil $1==4 && $2<0
|
|
| Xsource4 Xsource4 |
|
|
REMEXTANDLOC
|
|
allocate(REG)
|
|
"divl3\t%[1],%[2],%[a]"
|
|
"mull2\t%[1],%[a]"
|
|
"subl3\t%[a],%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
rmi sil $1==4 && $2>=0
|
|
| Xsource4 Xsource4 |
|
|
REMEXTANDLOC
|
|
allocate(REG)
|
|
"divl3\t%[1],%[2],%[a]"
|
|
"mull2\t%[1],%[a]"
|
|
"subl3\t%[a],%[2],*$2(ap)"
|
|
setcc({displdef4,AP,tostring($2)}) | | |
|
|
rmi ste $1==4 | Xsource4 Xsource4 |
|
|
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 && $2<0
|
|
| source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"mnegl\t%[1],$2(fp)"
|
|
setcc({LOCAL4,LB,$2,4}) | | |
|
|
ngi stl $1==4 && $2>=0
|
|
| source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"mnegl\t%[1],$2(ap)"
|
|
setcc({LOCAL4,AP,$2,4}) | | |
|
|
#ifdef REGVARS
|
|
ngi sil $1==4 && inreg($2)==2
|
|
| source4 |
|
|
REMEXTANDLOC
|
|
"mnegl\t%[1],(%(regvar($2)%))"
|
|
setcc({regdef4,regvar($2)}) | | |
|
|
ngi lol stf $1==4 && inreg($2)==2
|
|
| source4 |
|
|
REMEXTANDLOC
|
|
"mnegl\t%[1],$3(%(regvar($2)%))"
|
|
setcc({displ4,regvar($2),tostring($3)}) | | |
|
|
#endif /* REGVARS */
|
|
ngi sil $1==4 && $2<0
|
|
| source4 |
|
|
REMEXTANDLOC
|
|
"mnegl\t%[1],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
ngi sil $1==4 && $2>=0
|
|
| source4 |
|
|
REMEXTANDLOC
|
|
"mnegl\t%[1],*$2(ap)"
|
|
setcc({displdef4,AP,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 source4 |
|
|
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
|
|
| source1or2or4 source4 |
|
|
remove(regvar($2))
|
|
"ashl\t%[1],%[2],%(regvar($2)%)"
|
|
erase(regvar($2))
|
|
setcc(regvar($2)) | | |
|
|
#endif /* REGVARS */
|
|
sli stl $1==4 && $2<0
|
|
| source1or2or4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"ashl\t%[1],%[2],$2(fp)"
|
|
setcc({LOCAL4,LB,$2,4}) | | |
|
|
sli stl $1==4 && $2>=0
|
|
| source1or2or4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"ashl\t%[1],%[2],$2(ap)"
|
|
setcc({LOCAL4,AP,$2,4}) | | |
|
|
#ifdef REGVARS
|
|
sli sil $1==4 && inreg($2)==2
|
|
| source1or2or4 source4 |
|
|
REMEXTANDLOC
|
|
"ashl\t%[1],%[2],(%(regvar($2)%))"
|
|
setcc({regdef4,regvar($2)}) | | |
|
|
sli lol stf $1==4 && inreg($2)==2
|
|
| source1or2or4 source4 |
|
|
REMEXTANDLOC
|
|
"ashl\t%[1],%[2],$3(%(regvar($2)%))"
|
|
setcc({displ4,regvar($2),tostring($3)}) | | |
|
|
#endif /* REGVARS */
|
|
sli sil $1==4 && $2<0
|
|
| source1or2or4 source4 |
|
|
REMEXTANDLOC
|
|
"ashl\t%[1],%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
sli sil $1==4 && $2>=0
|
|
| source1or2or4 source4 |
|
|
REMEXTANDLOC
|
|
"ashl\t%[1],%[2],*$2(ap)"
|
|
setcc({displdef4,AP,tostring($2)}) | | |
|
|
sli ste $1==4 | source1or2or4 source4 |
|
|
remove(externals)
|
|
"ashl\t%[1],%[2],$2"
|
|
setcc({EXTERNAL4,$2}) | | | (8,10)+%[1]+%[2]
|
|
sli !defined($1) | source1or2or4 |
|
|
remove(ALL)
|
|
move(%[1],R0)
|
|
"jsb\t.sli"
|
|
erase(R0) | | |
|
|
sri $1==4 | source4 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 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]
|
|
... | NC 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 && $2<0
|
|
| source4 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,LB,$2,4}) | | | (9,11)+%[1]+%[2]
|
|
... | NC CONST source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"ashl\t$$%(0-%[1.num]%),%[2],$2(fp)"
|
|
setcc({LOCAL4,LB,$2,4}) | | | (6,7)+%[1]+%[2]
|
|
sri stl $1==4 && $2>=0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
allocate(%[1],REG)
|
|
"mnegl\t%[1],%[a]"
|
|
"ashl\t%[a],%[2],$2(ap)"
|
|
setcc({LOCAL4,AP,$2,4}) | | | (9,11)+%[1]+%[2]
|
|
... | NC CONST source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"ashl\t$$%(0-%[1.num]%),%[2],$2(ap)"
|
|
setcc({LOCAL4,AP,$2,4}) | | | (6,7)+%[1]+%[2]
|
|
#ifdef REGVARS
|
|
sri sil $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
allocate(%[1],REG)
|
|
"mnegl\t%[1],%[a]"
|
|
"ashl\t%[a],%[2],(%(regvar($2)%))"
|
|
setcc({regdef4,regvar($2)}) | | | (9,14)+%[1]+%[2]
|
|
... | NC CONST source4 |
|
|
REMEXTANDLOC
|
|
"ashl\t$$%(0-%[1.num]%),%[2],(%(regvar($2)%))"
|
|
setcc({regdef4,regvar($2)}) | | | (6,10)+%[1]+%[2]
|
|
sri lol stf $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
allocate(%[1], REG)
|
|
"mnegl\t%[1],%[a]"
|
|
"ashl\t%[a],%[2],$3(%(regvar($2)%))"
|
|
setcc({displ4,regvar($2),tostring($3)}) | | | (9,14)+%[1]+%[2]
|
|
... | NC CONST source4 |
|
|
REMEXTANDLOC
|
|
"ashl\t$$%(0-%[1.num]%),%[2],$3(%(regvar($2)%))"
|
|
setcc({displ4,regvar($2),tostring($3)}) | | | (6,10)+%[1]+%[2]
|
|
#endif /* REGVARS */
|
|
sri sil $1==4 && $2<0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
allocate(%[1],REG)
|
|
"mnegl\t%[1],%[a]"
|
|
"ashl\t%[a],%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)})
|
|
| | | (9,17)+%[1]+%[2]
|
|
... | NC CONST source4 |
|
|
REMEXTANDLOC
|
|
"ashl\t$$%(0-%[1.num]%),%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)})
|
|
| | | (6,13)+%[1]+%[2]
|
|
sri sil $1==4 && $2>=0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
allocate(%[1],REG)
|
|
"mnegl\t%[1],%[a]"
|
|
"ashl\t%[a],%[2],*$2(ap)"
|
|
setcc({displdef4,AP,tostring($2)})
|
|
| | | (9,17)+%[1]+%[2]
|
|
... | NC CONST source4 |
|
|
REMEXTANDLOC
|
|
"ashl\t$$%(0-%[1.num]%),%[2],*$2(ap)"
|
|
setcc({displdef4,AP,tostring($2)})
|
|
| | | (6,13)+%[1]+%[2]
|
|
sri ste $1==4 | source4 source4 |
|
|
remove(externals)
|
|
allocate(%[1],REG)
|
|
"mnegl\t%[1],%[a]"
|
|
"ashl\t%[a],%[2],$2"
|
|
setcc({EXTERNAL4,$2}) | | | (11,14)+%[1]+%[2]
|
|
... | NC 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 | STACK |
|
|
"jsb\t.dvu4" | R0 | |
|
|
dvu !defined($1) | source1or2or4 |
|
|
remove(ALL)
|
|
move(%[1],R0)
|
|
"jsb\t.dvu"
|
|
erase(R0) | | |
|
|
rmu $1==4 | STACK |
|
|
"jsb\t.rmu4" | R0 | |
|
|
rmu !defined($1) | source1or2or4 |
|
|
remove(ALL)
|
|
move(%[1],R0)
|
|
"jsb\t.rmu"
|
|
erase(R0) | | |
|
|
slu | | | | sli $1 |
|
|
loc slu | | | | loc $1 sli $2 |
|
|
sru $1==4 | source4 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 source4 |
|
|
allocate(%[1],%[2],REG)
|
|
"addf3\t%[1],%[2],%[a]"
|
|
setcc(%[a]) | %[a] | | (4,8)+%[1]+%[2]
|
|
#ifdef FLOAT4
|
|
... | 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]
|
|
#ifdef REGVARS
|
|
adf stl $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
remove(regvar($2))
|
|
"addf3\t%[1],%[2],%(regvar($2)%)"
|
|
erase(regvar($2)) | | |
|
|
#endif /* REGVARS */
|
|
adf stl $1==4 && $2<0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
|
|
"addf3\t%[1],%[2],$2(fp)"
|
|
setcc({LOCAL4,LB,$2,4}) | | |
|
|
adf stl $1==4 && $2>=0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
|
|
"addf3\t%[1],%[2],$2(ap)"
|
|
setcc({LOCAL4,AP,$2,4}) | | |
|
|
#ifdef REGVARS
|
|
adf sil $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
remove(regvar($2))
|
|
"addf3\t%[1],%[2],(%(regvar($2)%))"
|
|
setcc(regvar($2)) | | |
|
|
#endif /* REGVARS */
|
|
adf sil $1==4 && $2<0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"addf3\t%[1],%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
adf sil $1==4 && $2>=0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"addf3\t%[1],%[2],*$2(ap)"
|
|
setcc({displdef4,AP,tostring($2)}) | | |
|
|
adf ste $1==4 | source4 source4 |
|
|
remove(externals)
|
|
"addf3\t%[1],%[2],$2"
|
|
setcc({EXTERNAL4,$2}) | | |
|
|
#endif /* FLOAT4 */
|
|
adf $1==8 | source8 source8 |
|
|
allocate(%[1],%[2],QREG)
|
|
"addd3\t%[1],%[2],%[a]"
|
|
setcc(%[a]) | %[a] | | (4,14)+%[1]+%[2]
|
|
#ifdef FLOAT8
|
|
... | 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]
|
|
adf sdl $1==8 && $2<0
|
|
| source8 source8 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
|
|
"addd3\t%[1],%[2],$2(fp)"
|
|
setcc({LOCAL8,LB,$2,8}) | | |
|
|
adf sdl $1==8 && $2>=0
|
|
| source8 source8 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
|
|
"addd3\t%[1],%[2],$2(ap)"
|
|
setcc({LOCAL8,AP,$2,8}) | | |
|
|
adf sde $1==8 | source8 source8 |
|
|
remove(externals)
|
|
"addd3\t%[1],%[2],$2"
|
|
setcc({EXTERNAL8,$2}) | | |
|
|
#endif /* FLOAT8 */
|
|
adf !defined($1) | source4 |
|
|
remove(ALL)
|
|
move(%[1],R0)
|
|
"jsb\t.adf" | | |
|
|
sbf $1==4 | source4 source4 |
|
|
allocate(%[1],%[2],REG)
|
|
"subf3\t%[1],%[2],%[a]"
|
|
setcc(%[a]) | %[a] | | (4,8)+%[1]+%[2]
|
|
#ifdef FLOAT4
|
|
... | NC source4 sreg4 |
|
|
"subf2\t%[1],%[2]"
|
|
erase(%[2])
|
|
setcc(%[2]) | %[2] | | (3,8) + %[1]
|
|
#ifdef REGVARS
|
|
sbf stl $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
remove(regvar($2))
|
|
"subf3\t%[1],%[2],%(regvar($2)%)"
|
|
erase(regvar($2))
|
|
setcc(regvar($2)) | | |
|
|
#endif /* REGVARS */
|
|
sbf stl $1==4 && $2<0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
|
|
"subf3\t%[1],%[2],$2(fp)"
|
|
setcc({LOCAL4,LB,$2,4}) | | |
|
|
sbf stl $1==4 && $2>=0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
|
|
"subf3\t%[1],%[2],$2(ap)"
|
|
setcc({LOCAL4,AP,$2,4}) | | |
|
|
#ifdef REGVARS
|
|
sbf sil $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
remove(regvar($2))
|
|
"subf3\t%[1],%[2],(%(regvar($2)%))"
|
|
setcc(regvar($2)) | | |
|
|
#endif /* REGVARS */
|
|
sbf sil $1==4 && $2<0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"subf3\t%[1],%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
sbf sil $1==4 && $2>=0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"subf3\t%[1],%[2],*$2(ap)"
|
|
setcc({displdef4,AP,tostring($2)}) | | |
|
|
sbf ste $1==4 | source4 source4 |
|
|
remove(externals)
|
|
"subf3\t%[1],%[2],$2"
|
|
setcc({EXTERNAL4,$2}) | | |
|
|
#endif /* FLOAT4 */
|
|
sbf $1==8 | source8 source8 |
|
|
allocate(%[1],%[2],QREG)
|
|
"subd3\t%[1],%[2],%[a]"
|
|
setcc(%[a]) | %[a] | | (4,14)+%[1]+%[2]
|
|
#ifdef FLOAT8
|
|
... | source8 sreg8 |
|
|
"subd2\t%[1],%[2]"
|
|
erase(%[2])
|
|
setcc(%[2]) | %[2] | | (3,14) + %[1]
|
|
sbf sdl $1==8 && $2<0
|
|
| source8 source8 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
|
|
"subd3\t%[1],%[2],$2(fp)"
|
|
setcc({LOCAL8,LB,$2,8}) | | |
|
|
sbf sdl $1==8 && $2>=0
|
|
| source8 source8 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
|
|
"subd3\t%[1],%[2],$2(ap)"
|
|
setcc({LOCAL8,AP,$2,8}) | | |
|
|
sbf sde $1==8 | source8 source8 |
|
|
remove(externals)
|
|
"subd3\t%[1],%[2],$2"
|
|
setcc({EXTERNAL8,$2}) | | |
|
|
#endif /* FLOAT8 */
|
|
sbf !defined($1) | source1or2or4 |
|
|
remove(ALL)
|
|
move(%[1],R0)
|
|
"jsb\t.sbf" | | |
|
|
mlf $1==4 | source4 source4 |
|
|
allocate(%[1],%[2],REG)
|
|
"mulf3\t%[1],%[2],%[a]"
|
|
setcc(%[a]) | %[a] | | (4,12)+%[1]+%[2]
|
|
#ifdef FLOAT4
|
|
... | 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]
|
|
#ifdef REGVARS
|
|
mlf stl $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
remove(regvar($2))
|
|
"mulf3\t%[1],%[2],%(regvar($2)%)"
|
|
erase(regvar($2)) | | |
|
|
#endif /* REGVARS */
|
|
mlf stl $1==4 && $2<0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
|
|
"mulf3\t%[1],%[2],$2(fp)"
|
|
setcc({LOCAL4,LB,$2,4}) | | |
|
|
mlf stl $1==4 && $2>=0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
|
|
"mulf3\t%[1],%[2],$2(ap)"
|
|
setcc({LOCAL4,AP,$2,4}) | | |
|
|
#ifdef REGVARS
|
|
mlf sil $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
remove(regvar($2))
|
|
"mulf3\t%[1],%[2],(%(regvar($2)%))"
|
|
setcc(regvar($2)) | | |
|
|
#endif /* REGVARS */
|
|
mlf sil $1==4 && $2<0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"mulf3\t%[1],%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
mlf sil $1==4 && $2>=0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"mulf3\t%[1],%[2],*$2(ap)"
|
|
setcc({displdef4,AP,tostring($2)}) | | |
|
|
mlf ste $1==4 | source4 source4 |
|
|
remove(externals)
|
|
"mulf3\t%[1],%[2],$2"
|
|
setcc({EXTERNAL4,$2}) | | |
|
|
#endif /* FLOAT4 */
|
|
mlf $1==8 | source8 source8 |
|
|
allocate(%[1],%[2],QREG)
|
|
"muld3\t%[1],%[2],%[a]"
|
|
setcc(%[a]) | %[a] | | (4,20)+%[1]+%[2]
|
|
#ifdef FLOAT8
|
|
... | 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]
|
|
mlf sdl $1==8 && $2<0
|
|
| source8 source8 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
|
|
"muld3\t%[1],%[2],$2(fp)"
|
|
setcc({LOCAL8,LB,$2,8}) | | |
|
|
mlf sdl $1==8 && $2>=0
|
|
| source8 source8 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
|
|
"muld3\t%[1],%[2],$2(ap)"
|
|
setcc({LOCAL8,AP,$2,8}) | | |
|
|
mlf sde $1==8 | source8 source8 |
|
|
remove(externals)
|
|
"muld3\t%[1],%[2],$2"
|
|
setcc({EXTERNAL8,$2}) | | |
|
|
#endif /* FLOAT8 */
|
|
mlf !defined($1) | source1or2or4 |
|
|
remove(ALL)
|
|
move(%[1],R0)
|
|
"jsb\t.mlf" | | |
|
|
dvf $1==4 | source4 source4 |
|
|
allocate(%[1],%[2],REG)
|
|
"divf3\t%[1],%[2],%[a]"
|
|
setcc(%[a]) | %[a] | | (4,46)+%[1]+%[2]
|
|
#ifdef FLOAT4
|
|
... | source4 sreg4 |
|
|
"divf2\t%[1],%[2]"
|
|
erase(%[2])
|
|
setcc(%[2]) | %[2] | | (3,46) + %[1]
|
|
#ifdef REGVARS
|
|
dvf stl $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
remove(regvar($2))
|
|
"divf3\t%[1],%[2],%(regvar($2)%)"
|
|
erase(regvar($2))
|
|
setcc(regvar($2)) | | |
|
|
#endif /* REGVARS */
|
|
dvf stl $1==4 && $2<0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
|
|
"divf3\t%[1],%[2],$2(fp)"
|
|
setcc({LOCAL4,LB,$2,4}) | | |
|
|
dvf stl $1==4 && $2>=0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
|
|
"divf3\t%[1],%[2],$2(ap)"
|
|
setcc({LOCAL4,AP,$2,4}) | | |
|
|
#ifdef REGVARS
|
|
dvf sil $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
remove(regvar($2))
|
|
"divf3\t%[1],%[2],(%(regvar($2)%))"
|
|
setcc(regvar($2)) | | |
|
|
#endif /* REGVARS */
|
|
dvf sil $1==4 && $2<0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"divf3\t%[1],%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
dvf sil $1==4 &&$2>=0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"divf3\t%[1],%[2],*$2(ap)"
|
|
setcc({displdef4,AP,tostring($2)}) | | |
|
|
dvf ste $1==4 | source4 source4 |
|
|
remove(externals)
|
|
"divf3\t%[1],%[2],$2"
|
|
setcc({EXTERNAL4,$2}) | | |
|
|
#endif /* FLOAT4 */
|
|
dvf $1==8 | source8 source8 |
|
|
allocate(%[1],%[2],QREG)
|
|
"divd3\t%[1],%[2],%[a]"
|
|
setcc(%[a]) | %[a] | | (4,80)+%[1]+%[2]
|
|
#ifdef FLOAT8
|
|
... | source8 sreg8 |
|
|
"divd2\t%[1],%[2]"
|
|
erase(%[2])
|
|
setcc(%[2]) | %[2] | | (3,80) + %[1]
|
|
dvf sdl $1==8 && $2<0
|
|
| source8 source8 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
|
|
"divd3\t%[1],%[2],$2(fp)"
|
|
setcc({LOCAL8,LB,$2,8}) | | |
|
|
dvf sdl $1==8 && $2>=0
|
|
| source8 source8 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
|
|
"divd3\t%[1],%[2],$2(ap)"
|
|
setcc({LOCAL8,AP,$2,8}) | | |
|
|
dvf sde $1==8 | source8 source8 |
|
|
remove(externals)
|
|
"divd3\t%[1],%[2],$2"
|
|
setcc({EXTERNAL8,$2}) | | |
|
|
#endif /* FLOAT8 */
|
|
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
|
|
#ifdef REGVARS
|
|
ngf stl $1==4 && inreg($2)==2
|
|
| source4 |
|
|
remove(regvar($2))
|
|
"mnegf\t%[1],%(regvar($2)%)"
|
|
erase(regvar($2))
|
|
setcc(regvar($2)) | | |
|
|
#endif /* REGVARS */
|
|
ngf stl $1==4 && $2<0
|
|
| source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
|
|
"mnegf\t%[1],$2(fp)"
|
|
setcc({LOCAL4,LB,$2,4}) | | |
|
|
ngf stl $1==4 && $2>=0
|
|
| source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
|
|
"mnegf\t%[1],$2(ap)"
|
|
setcc({LOCAL4,AP,$2,4}) | | |
|
|
#ifdef REGVARS
|
|
ngf sil $1==4 && inreg($2)==2
|
|
| source4 |
|
|
remove(regvar($2))
|
|
"mnegf\t%[1],(%(regvar($2)%))"
|
|
setcc(regvar($2)) | | |
|
|
#endif /* REGVARS */
|
|
ngf sil $1==4 && $2<0
|
|
| source4 |
|
|
REMEXTANDLOC
|
|
"mnegf\t%[1],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
ngf sil $1==4 && $2>=0
|
|
| source4 |
|
|
REMEXTANDLOC
|
|
"mnegf\t%[1],*$2(ap)"
|
|
setcc({displdef4,AP,tostring($2)}) | | |
|
|
ngf ste $1==4 | source4 |
|
|
remove(externals)
|
|
"mnegf\t%[1],$2"
|
|
setcc({EXTERNAL4,$2}) | | |
|
|
#endif /* FLOAT4 */
|
|
ngf $1==8 | source8 |
|
|
allocate(%[1],QREG)
|
|
"mnegd\t%[1],%[a]"
|
|
setcc(%[a]) | %[a] | |
|
|
#ifdef FLOAT8
|
|
ngf sdl $1==8 && $2<0
|
|
| source8 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
|
|
"mnegd\t%[1],$2(fp)"
|
|
setcc({LOCAL8,LB,$2,8}) | | |
|
|
ngf sdl $1==8 && $2>=0
|
|
| source8 |
|
|
remove(displaced)
|
|
remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
|
|
"mnegd\t%[1],$2(ap)"
|
|
setcc({LOCAL8,AP,$2,8}) | | |
|
|
ngf sde $1==8 | source8 |
|
|
remove(externals)
|
|
"mnegd\t%[1],$2"
|
|
setcc({EXTERNAL8,$2}) | | |
|
|
#endif /* FLOAT8 */
|
|
ngf !defined($1) | source1or2or4 |
|
|
remove(ALL)
|
|
move(%[1],R0)
|
|
"jsb\t.ngf" | | |
|
|
fif $1==4 | source4 source4 |
|
|
allocate(%[1],%[2],REG,REG)
|
|
"mulf3\t%[1],%[2],%[a]"
|
|
/* the assembler does not do immediate floating point */
|
|
"cvtlf $$1,%[b]"
|
|
"emodf\t%[a],$$0,%[b],-(sp),%[b]"
|
|
/*
|
|
* Don't trust the integer part.
|
|
* Overflow could occur.
|
|
*/
|
|
"tstl\t(sp)+"
|
|
"subf2\t%[b],%[a]" | %[b] %[a] | |
|
|
fif $1==8 | source8 source8 |
|
|
allocate(%[1],%[2],QREG,QREG)
|
|
"muld3\t%[1],%[2],%[a]"
|
|
"cvtld $$1,%[b]"
|
|
"emodd\t%[a],$$0,%[b],-(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 defined($1) | |
|
|
remove(ALL)
|
|
move({CONST4, $1}, R0)
|
|
"jsb\t.fef"
|
|
erase(R0) | | |
|
|
fef !defined($1) | source1or2or4 |
|
|
remove(ALL)
|
|
move(%[1],R0)
|
|
"jsb\t.fef"
|
|
erase(R0) | | |
|
|
|
|
/********************************
|
|
* Group 6 : pointer arithmetic *
|
|
********************************/
|
|
|
|
adp $1==0 | | | | |
|
|
adp | NC ADDR_EXTERNAL |
|
|
| {ADDR_EXTERNAL,%[1.ind]+"+"+tostring($1)} | |
|
|
... | NC ADDR_LOCAL |
|
|
| {ADDR_LOCAL,%[1.reg],%[1.num]+$1} | |
|
|
... | NC adisplind1 |
|
|
| {adisplind1,%[1.ireg],%[1.reg],
|
|
%[1.ind]+"+"+tostring($1)} | |
|
|
... | NC adispldefind1 |
|
|
allocate(%[1.ireg],REG)
|
|
"addl3\t$$$1,%[1.ireg],%[a]"
|
|
| {adispldefind1,%[a],%[1.reg],%[1.ind]} | |
|
|
... | NC aextdefind1 |
|
|
allocate(%[1],REG)
|
|
"addl3\t$$$1,%[1.ireg],%[a]"
|
|
| {aextdefind1,%[a],%[1.ind]} | |
|
|
... | NC adispl | | {adispl,%[1.reg],%[1.ind]+"+"+tostring($1)} | |
|
|
... | reg4 | | {adispl,%[1],tostring($1)} | |
|
|
adp sil | | | {CONST4,$1} | adi 4 sil $2 |
|
|
adp stl | | | {CONST4,$1} | adi 4 stl $2 |
|
|
adp ste | | | {CONST4,$1} | adi 4 ste $2 |
|
|
adp dup $2==4 | | | {CONST4,$1} | adi 4 dup 4 |
|
|
adp lol stf | | | {CONST4,$1} | adi 4 lol $2 stf $3 |
|
|
adp lol sti $3==4
|
|
| | | {CONST4,$1} | adi 4 lol $2 sti 4 |
|
|
adp loe sti $3==4
|
|
| | | {CONST4,$1} | adi 4 loe $2 sti 4 |
|
|
adp cms $2==4 | | | {CONST4,$1} | adi 4 cms 4 |
|
|
loe lof adp loe stf $1==$4 && $2==$5
|
|
| | REMEXTANDLOC
|
|
allocate(REG={EXTERNAL4,$1})
|
|
"addl2\t$$$3,$2(%[a])" | | |
|
|
lol lof adp lol stf $1<0 && $1==$4 && inreg($1)!=2 && $2==$5
|
|
| | REMEXTANDLOC
|
|
allocate(REG={LOCAL4,LB,$1,4})
|
|
"addl2\t$$$3,$2(%[a])" | | |
|
|
lol lof adp lol stf $1>=0 && $1==$4 && inreg($1)!=2 && $2==$5
|
|
| | REMEXTANDLOC
|
|
allocate(REG={LOCAL4,AP,$1,4})
|
|
"addl2\t$$$3,$2(%[a])" | | |
|
|
ads $1==4 | NC reg4 adispl |
|
|
| {adisplind1,%[1],%[2.reg],%[2.ind]} | |
|
|
... | NC reg4 ADDR_LOCAL |
|
|
| {adisplind1,%[1],%[2.reg],tostring(%[2.num])} | |
|
|
... | NC reg4 ADDR_EXTERNAL |
|
|
| {adispl,%[1],%[2.ind]} | |
|
|
... | NC reg4 aextind2 |
|
|
| {adisplind2,%[2.ireg],%[1],%[2.ind]} | |
|
|
... | NC reg4 aextind4 |
|
|
| {adisplind4,%[2.ireg],%[1],%[2.ind]} | |
|
|
... | NC reg4 aextind8 |
|
|
| {adisplind8,%[2.ireg],%[1],%[2.ind]} | |
|
|
... | NC reg4 displ4 |
|
|
| {adispldefind1,%[1],%[2.reg],%[2.ind]} | |
|
|
... | NC reg4 LOCAL4 |
|
|
| {adispldefind1,%[1],%[2.reg],tostring(%[2.num])} | |
|
|
... | NC reg4 regdef4 |
|
|
| {adispldefind1,%[1],%[2.reg],"0"} | |
|
|
... | NC reg4 EXTERNAL4 |
|
|
| {aextdefind1,%[1],%[2.ind]} | |
|
|
... | NC reg4 reg4 | | {adisplind1,%[1],%[2],"0"} | |
|
|
... | | | | adi 4 |
|
|
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 |
|
|
dup adp lol sti $1==4 && $4==4
|
|
| bigsource4-regch4 |
|
|
allocate(REG=%[1])
|
|
| %[a] %[1] {CONST4,$2}
|
|
| adi 4 lol $3 sti 4 |
|
|
dup adp loe sti $1==4 && $4==4
|
|
| bigsource4-regch4 |
|
|
allocate(REG=%[1])
|
|
| %[a] %[1] {CONST4,$2}
|
|
| adi 4 loe $3 sti 4 |
|
|
#ifdef REGVARS
|
|
lol dup adp stl loi $1==$4 && $2==4 && inreg($1)==2 && $3==1 && $5==1
|
|
| | remove(regvar($1))
|
|
erase(regvar($1))
|
|
| {reginc1,regvar($1)} | |
|
|
lol dup adp stl loi $1==$4 && $2==4 && inreg($1)==2 && $3==2 && $5==2
|
|
| | remove(regvar($1))
|
|
erase(regvar($1))
|
|
| {reginc2,regvar($1)} | |
|
|
lol dup adp stl loi $1==$4 && $2==4 && inreg($1)==2 && $3==4 && $5==4
|
|
| | remove(regvar($1))
|
|
erase(regvar($1))
|
|
| {reginc4,regvar($1)} | |
|
|
lol dup adp stl loi $1==$4 && $2==4 && inreg($1)==2 && $3==8 && $5==8
|
|
| | remove(regvar($1))
|
|
erase(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))
|
|
erase(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))
|
|
erase(regvar($1))
|
|
| {regdec2,regvar($1)} | |
|
|
lol adp stl lil $1==$4 && $2==(0-4) && inreg($1)==2 && $3==$1
|
|
| | remove(regvar($1))
|
|
erase(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))
|
|
erase(regvar($1))
|
|
| {regdec8,regvar($1)} | |
|
|
lol dup adp stl sti $1==$4 && $2==4 && 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 dup adp stl sti $1==$4 && $2==4 && 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 dup adp stl sti $1==$4 && $2==4 && inreg($1)==2 && $3==4 && $5==4
|
|
| source4 |
|
|
REMEXTANDLOC
|
|
remove(regvar($1))
|
|
move(%[1],{reginc4,regvar($1)})
|
|
erase(regvar($1)) | | |
|
|
lol dup adp stl sti $1==$4 && $2==4 && inreg($1)==2 && $3==8 && $5==8
|
|
| source8 |
|
|
REMEXTANDLOC
|
|
remove(regvar($1))
|
|
move(%[1],{reginc8,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))
|
|
move(%[1],{regdec4,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))
|
|
move(%[1],{regdec8,regvar($1)})
|
|
erase(regvar($1)) | | |
|
|
lol dup 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 && $1<0
|
|
| | remove(displaced)
|
|
remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
|
|
"addl2\t$$$2,$1(fp)"
|
|
setcc({LOCAL4,LB,$1,4}) | | |
|
|
lol adp stl $1==$3 && $1>=0
|
|
| | remove(displaced)
|
|
remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
|
|
"addl2\t$$$2,$1(ap)"
|
|
setcc({LOCAL4,AP,$1,4}) | | |
|
|
lol dup adp stl $1==$4 && $2==4 && $1<0
|
|
| | remove(displaced)
|
|
remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
|
|
allocate(REG={LOCAL4,LB,$1,4})
|
|
"addl2\t$$$3,$1(fp)"
|
|
setcc({LOCAL4,LB,$1,4}) | %[a] | |
|
|
lol dup adp stl $1==$4 && $2==4
|
|
| | remove(displaced)
|
|
remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
|
|
allocate(REG={LOCAL4,AP,$1,4})
|
|
"addl2\t$$$3,$1(ap)"
|
|
setcc({LOCAL4,AP,$1,4}) | %[a] | |
|
|
#ifdef REGVARS
|
|
lil dup adp sil $1==$4 && $2==4 && inreg($1)==2
|
|
| | REMEXTANDLOC
|
|
allocate(REG={regdef4,regvar($1)})
|
|
"addl2\t$$$3,(%(regvar($1)%))"
|
|
setcc(regvar($1)) | %[a] | |
|
|
lol lof dup adp lol stf $1==$5 && $2==$6 && $3==4 && inreg($1)==2
|
|
| | REMEXTANDLOC
|
|
allocate(REG={displ4,regvar($1),tostring($2)})
|
|
"addl2\t$$$4,$2(%(regvar($1)%))"
|
|
| %[a] | |
|
|
#endif
|
|
loe adp ste $1==$3
|
|
| | remove(externals)
|
|
"addl2\t$$$2,$1" | | |
|
|
loe dup adp ste $1==$4 && $2==4
|
|
| | 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 |
|
|
loe lof inc loe stf $1==$4 && $2==$5
|
|
| | REMEXTANDLOC
|
|
allocate(REG={EXTERNAL4,$1})
|
|
"incl\t$2(%[a])"
|
|
setcc({displ4,%[a],tostring($2)}) | | |
|
|
lol lof inc lol stf $1<0 && $1==$4 && inreg($1)!=2 && $2==$5
|
|
| | REMEXTANDLOC
|
|
allocate(REG={LOCAL4,LB,$1,4})
|
|
"incl\t$2(%[a])"
|
|
setcc({displ4,%[a],tostring($2)}) | | |
|
|
lol lof inc lol stf $1>=0 && $1==$4 && inreg($1)!=2 && $2==$5
|
|
| | REMEXTANDLOC
|
|
allocate(REG={LOCAL4,AP,$1,4})
|
|
"incl\t$2(%[a])"
|
|
setcc({displ4,%[a],tostring($2)}) | | |
|
|
dec | | | {CONST1,1} | sbi 4 |
|
|
loe lof dec loe stf $1==$4 && $2==$5
|
|
| | REMEXTANDLOC
|
|
allocate(REG={EXTERNAL4,$1})
|
|
"decl\t$2(%[a])"
|
|
setcc({displ4,%[a],tostring($2)}) | | |
|
|
lol lof dec lol stf $1<0 && $1==$4 && inreg($1)!=2 && $2==$5
|
|
| | REMEXTANDLOC
|
|
allocate(REG={LOCAL4,LB,$1,4})
|
|
"decl\t$2(%[a])"
|
|
setcc({displ4,%[a],tostring($2)}) | | |
|
|
lol lof dec lol stf $1>=0 && $1==$4 && inreg($1)!=2 && $2==$5
|
|
| | REMEXTANDLOC
|
|
allocate(REG={LOCAL4,AP,$1,4})
|
|
"decl\t$2(%[a])"
|
|
setcc({displ4,%[a],tostring($2)}) | | |
|
|
#ifdef REGVARS
|
|
inl inreg($1)==2 | | remove(regvar($1))
|
|
"incl\t%(regvar($1)%)"
|
|
erase(regvar($1))
|
|
setcc(regvar($1)) | | |
|
|
#endif /* REGVARS */
|
|
inl $1<0 | | remove(displaced)
|
|
remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
|
|
"incl\t$1(fp)"
|
|
setcc({LOCAL4,LB,$1,4}) | | |
|
|
inl $1>=0 | | remove(displaced)
|
|
remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
|
|
"incl\t$1(ap)"
|
|
setcc({LOCAL4,AP,$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 $1<0 | | remove(displaced)
|
|
remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
|
|
"decl\t$1(fp)"
|
|
setcc({LOCAL4,LB,$1,4}) | | |
|
|
del $1>=0 | | remove(displaced)
|
|
remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
|
|
"decl\t$1(ap)"
|
|
setcc({LOCAL4,AP,$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 $1<0 | | remove(displaced)
|
|
remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
|
|
"clrl\t$1(fp)"
|
|
setcc({LOCAL4,LB,$1,4}) | | |
|
|
zrl $1>=0 | | remove(displaced)
|
|
remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
|
|
"clrl\t$1(ap)"
|
|
setcc({LOCAL4,AP,$1,4}) | | |
|
|
zrl zrl $1==$2+4 && $1<0
|
|
#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,LB,$2,8}) | | |
|
|
zrl zrl $1==$2+4 && $1>=0
|
|
#ifdef REGVARS
|
|
&& inreg($1)<2 && inreg($2)<2
|
|
#endif /* REGVARS */
|
|
| | remove(displaced)
|
|
remove(LOCALS,%[num]<=$2+7 && %[num]+%[size]>$2)
|
|
"clrq\t$2(ap)"
|
|
setcc({LOCAL8,AP,$2,8}) | | |
|
|
zrl zrl $1==$2-4 | | | | zrl $2 zrl $1 |
|
|
zre | | remove(externals)
|
|
"clrl\t$1"
|
|
setcc({EXTERNAL4,$1}) | | |
|
|
zrf $1==4 | | allocate(REG)
|
|
"clrl\t%[a]" | %[a] | |
|
|
zrf $1==8 | | allocate(QREG)
|
|
"clrq\t%[a]" | %[a] | |
|
|
zer $1==4 | | | {CONST4,0} | |
|
|
zer $1==8 | | allocate(QREG)
|
|
"clrq\t%[a]" | %[a] | |
|
|
zer $1>8&&$1<=32 | STACK |
|
|
"clrq\t-(sp)" | | zer $1-8 |
|
|
zer defined($1) | STACK |
|
|
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 | STACK |
|
|
"jsb\t.cii" | | |
|
|
cfi | STACK |
|
|
"jsb\t.cfi" | | |
|
|
cfu | STACK |
|
|
"jsb\t.cfu" | | |
|
|
cuf | STACK |
|
|
"jsb\t.cuf" | | |
|
|
cif | STACK |
|
|
"jsb\t.cif" | | |
|
|
cff | STACK |
|
|
"jsb\t.cff" | | |
|
|
cuu | STACK |
|
|
"jsb\t.cuu" | | |
|
|
ciu | | | | cuu |
|
|
cui | STACK |
|
|
"jsb\t.cui" | | |
|
|
#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 && $4<0
|
|
| source1or2or4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
|
|
"cvtbl\t%[1],$4(fp)"
|
|
setcc({LOCAL4,LB,$4,4}) | | |
|
|
loc loc cii stl $1==1 && $2==4 && $4>=0
|
|
| source1or2or4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
|
|
"cvtbl\t%[1],$4(ap)"
|
|
setcc({LOCAL4,AP,$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 && $4<0
|
|
| source2or4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
|
|
"cvtwl\t%[1],$4(fp)"
|
|
setcc({LOCAL4,LB,$4,4}) | | |
|
|
loc loc cii stl $1==2 && $2==4 && $4>=0
|
|
| source2or4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
|
|
"cvtwl\t%[1],$4(ap)"
|
|
setcc({LOCAL4,AP,$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 cui $1==$2 | | | | |
|
|
loc loc ciu $1==$2 | | | | |
|
|
#ifdef FLOAT4
|
|
#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 && $4<0
|
|
| source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
|
|
"cvtfl\t%[1],$4(fp)"
|
|
setcc({LOCAL4,AP,$4,4}) | | |
|
|
loc loc cfi stl $1==4 && $2==4 && $4>=0
|
|
| source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
|
|
"cvtfl\t%[1],$4(ap)"
|
|
setcc({LOCAL4,AP,$4,4}) | | |
|
|
loc loc cfi ste $1==4 && $2==4 | source4 |
|
|
remove(externals)
|
|
"cvtfl\t%[1],$4"
|
|
setcc({EXTERNAL4,$4}) | | |
|
|
#endif /* FLOAT4 */
|
|
loc loc cfi $1==4 && $2==4 | source4 |
|
|
allocate(%[1],REG)
|
|
"cvtfl\t%[1],%[a]"
|
|
setcc(%[a]) | %[a] | | (3,4) + %[1]
|
|
#ifdef FLOAT8
|
|
#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 && $4<0
|
|
| source8 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
|
|
"cvtdl\t%[1],$4(fp)"
|
|
setcc({LOCAL4,LB,$4,4}) | | |
|
|
loc loc cfi stl $1==8 && $2==4 && $4>=0
|
|
| source8 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
|
|
"cvtdl\t%[1],$4(ap)"
|
|
setcc({LOCAL4,AP,$4,4}) | | |
|
|
loc loc cfi ste $1==8 && $2==4 | source8 |
|
|
remove(externals)
|
|
"cvtdl\t%[1],$4"
|
|
setcc({EXTERNAL4,$4}) | | |
|
|
#endif /* FLOAT8 */
|
|
loc loc cfi $1==8 && $2==4 | source8 |
|
|
allocate(%[1],REG)
|
|
"cvtdl\t%[1],%[a]"
|
|
setcc(%[a]) | %[a] | |
|
|
#ifdef FLOAT4
|
|
#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 && $4<0
|
|
| source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
|
|
"cvtlf\t%[1],$4(fp)" | | |
|
|
loc loc cif stl $1==4 && $2==4 && $4>=0
|
|
| source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
|
|
"cvtlf\t%[1],$4(ap)" | | |
|
|
loc loc cif ste $1==4 && $2==4 | source4 |
|
|
remove(externals)
|
|
"cvtlf\t%[1],$4" | | |
|
|
#endif /* FLOAT4 */
|
|
loc loc cif $1==4 && $2==4 | source4 |
|
|
allocate(%[1],REG)
|
|
"cvtlf\t%[1],%[a]" | %[a] | |
|
|
#ifdef FLOAT8
|
|
/* No double registervariables
|
|
#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
|
|
*/
|
|
loc loc cif sdl $1==4 && $2==8 && $4<0
|
|
| source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
|
|
"cvtld\t%[1],$4(fp)" | | |
|
|
loc loc cif sdl $1==4 && $2==8 && $4>=0
|
|
| source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
|
|
"cvtld\t%[1],$4(ap)" | | |
|
|
loc loc cif sde $1==4 && $2==8 | source4 |
|
|
remove(externals)
|
|
"cvtld\t%[1],$4" | | |
|
|
#endif /* FLOAT8 */
|
|
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 FLOAT8
|
|
/* No double registervariables
|
|
#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
|
|
*/
|
|
loc loc cff sdl $1==4 && $2==8 && $4<0
|
|
| source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $4+7 && %[num]+%[size] > $4))
|
|
"cvtfd\t%[1],$4(fp)" | | |
|
|
loc loc cff sdl $1==4 && $2==8 && $4>=0
|
|
| source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $4+7 && %[num]+%[size] > $4))
|
|
"cvtfd\t%[1],$4(ap)" | | |
|
|
loc loc cff sde $1==4 && $2==8 | source4 |
|
|
remove(externals)
|
|
"cvtfd\t%[1],$4" | | |
|
|
#endif /* FLOAT8 */
|
|
loc loc cff $1==4 && $2==8 | source4 |
|
|
allocate(%[1],QREG)
|
|
"cvtfd\t%[1],%[a]" | %[a] | |
|
|
#ifdef FLOAT4
|
|
#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 && $4<0
|
|
| source8 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
|
|
"cvtdf\t%[1],$4(fp)" | | |
|
|
loc loc cff stl $1==8 && $2==4 && $4>=0
|
|
| source8 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
|
|
"cvtdf\t%[1],$4(ap)" | | |
|
|
loc loc cff ste $1==8 && $2==4 | source8 |
|
|
remove(externals)
|
|
"cvtdf\t%[1],$4" | | |
|
|
#endif /* FLOAT4 */
|
|
loc loc cff $1==8 && $2==4 | source8 |
|
|
allocate(%[1],REG)
|
|
"cvtdf\t%[1],%[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]
|
|
... | NC CONST source4 |
|
|
allocate(%[2],REG)
|
|
"bicl3\t$$~%[1.num],%[2],%[a]"
|
|
setcc(%[a]) | %[a] | | (4,3)+%[1]+%[2]
|
|
... | NC source4 CONST |
|
|
allocate(%[1],REG)
|
|
"bicl3\t$$~%[2.num],%[1],%[a]"
|
|
setcc(%[a]) | %[a] | | (4,3)+%[1]+%[2]
|
|
and zeq $1==4 | source4 source4 |
|
|
remove(ALL)
|
|
"bitl\t%[1],%[2]"
|
|
"jeql\t$2" | | |
|
|
and zne $1==4 | 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 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]
|
|
... | NC CONST source4 |
|
|
remove(regvar($2))
|
|
"bicl3\t$$~%[1.num],%[2],%(regvar($2)%)"
|
|
erase(regvar($2))
|
|
setcc(regvar($2)) | | | (4,4)+%[1]+%[2]
|
|
... | NC 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 && $2<0
|
|
| source4 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,LB,$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,LB,$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,LB,$2,4}) | | | (6,9)+%[1]+%[2]
|
|
and stl $1==4 && $2>=0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
allocate(%[1],REG)
|
|
"mcoml\t%[1],%[a]"
|
|
"bicl3\t%[a],%[2],$2(ap)"
|
|
setcc({LOCAL4,AP,$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(ap)"
|
|
setcc({LOCAL4,AP,$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(ap)"
|
|
setcc({LOCAL4,AP,$2,4}) | | | (6,9)+%[1]+%[2]
|
|
#ifdef REGVARS
|
|
and sil $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
allocate(%[1],REG)
|
|
"mcoml\t%[1],%[a]"
|
|
"bicl3\t%[a],%[2],(%(regvar($2)%))"
|
|
setcc({regdef4,regvar($2)})
|
|
| | | (9,15)+%[1]+%[2]
|
|
... | NC CONST source4 |
|
|
REMEXTANDLOC
|
|
"bicl3\t$$~%[1.num],%[2],(%(regvar($2)%))"
|
|
setcc({regdef4,regvar($2)})
|
|
| | | (6,12)+%[1]+%[2]
|
|
... | NC source4 CONST |
|
|
REMEXTANDLOC
|
|
"bicl3\t$$~%[2.num],%[1],(%(regvar($2)%))"
|
|
setcc({regdef4,regvar($2)})
|
|
| | | (6,12)+%[1]+%[2]
|
|
#endif /* REGVARS */
|
|
and sil $1==4 && $2<0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
allocate(%[1],REG)
|
|
"mcoml\t%[1],%[a]"
|
|
"bicl3\t%[a],%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)})
|
|
| | | (9,15)+%[1]+%[2]
|
|
... | NC CONST source4 |
|
|
REMEXTANDLOC
|
|
"bicl3\t$$~%[1.num],%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)})
|
|
| | | (6,12)+%[1]+%[2]
|
|
... | NC source4 CONST |
|
|
REMEXTANDLOC
|
|
"bicl3\t$$~%[2.num],%[1],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)})
|
|
| | | (6,12)+%[1]+%[2]
|
|
and sil $1==4 && $2>=0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
allocate(%[1],REG)
|
|
"mcoml\t%[1],%[a]"
|
|
"bicl3\t%[a],%[2],*$2(ap)"
|
|
setcc({displdef4,AP,tostring($2)})
|
|
| | | (9,15)+%[1]+%[2]
|
|
... | NC CONST source4 |
|
|
REMEXTANDLOC
|
|
"bicl3\t$$~%[1.num],%[2],*$2(ap)"
|
|
setcc({displdef4,AP,tostring($2)})
|
|
| | | (6,12)+%[1]+%[2]
|
|
... | NC source4 CONST |
|
|
REMEXTANDLOC
|
|
"bicl3\t$$~%[2.num],%[1],*$2(ap)"
|
|
setcc({displdef4,AP,tostring($2)})
|
|
| | | (6,12)+%[1]+%[2]
|
|
and ste $1==4 | source4 source4 |
|
|
remove(externals)
|
|
allocate(%[1],REG)
|
|
"mcoml\t%[1],%[a]"
|
|
"bicl3\t%[a],%[2],$2"
|
|
setcc({EXTERNAL4,$2}) | | | (11,12)+%[1]+%[2]
|
|
... | NC CONST source4 |
|
|
remove(externals)
|
|
"bicl3\t$$~%[1.num],%[2],$2"
|
|
setcc({EXTERNAL4,$2}) | | | (8,9)+%[1]+%[2]
|
|
... | NC source4 CONST |
|
|
remove(externals)
|
|
"bicl3\t$$~%[2.num],%[1],$2"
|
|
setcc({EXTERNAL4,$2}) | | | (8,9)+%[1]+%[2]
|
|
and $1==8 | sreg8 sreg8 |
|
|
"mcoml\t%[1.1],%[1.1]"
|
|
"mcoml\t%[1.2],%[1.2]"
|
|
"bicl2\t%[1.1],%[2.1]"
|
|
"bicl2\t%[1.2],%[2.2]"
|
|
erase(%[1]) erase(%[2]) | %[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 | source4 source4 |
|
|
allocate(%[1],%[2],REG)
|
|
"bisl3\t%[1],%[2],%[a]"
|
|
setcc(%[a]) | %[a] | | (4,4)+%[1]+%[2]
|
|
... | NC sreg4 source4 |
|
|
"bisl2\t%[2],%[1]"
|
|
erase(%[1])
|
|
setcc(%[1]) | %[1] | | (3,4) + %[2]
|
|
... | NC 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 && $2<0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"bisl3\t%[1],%[2],$2(fp)"
|
|
setcc({LOCAL4,LB,$2,4}) | | |
|
|
ior stl $1==4 && $2>=0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"bisl3\t%[1],%[2],$2(ap)"
|
|
setcc({LOCAL4,AP,$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 && $2<0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"bisl3\t%[1],%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
ior sil $1==4 && $2>=0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"bisl3\t%[1],%[2],*$2(ap)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
ior ste $1==4 | source4 source4 |
|
|
remove(externals)
|
|
"bisl3\t%[1],%[2],$2"
|
|
setcc({EXTERNAL4,$2}) | | |
|
|
ior $1==8 | sreg8 sreg8 |
|
|
"bisl2\t%[1.1],%[2.1]"
|
|
"bisl2\t%[1.2],%[2.2]"
|
|
erase(%[2]) | %[2] | |
|
|
ior defined($1) | STACK |
|
|
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 && $2<0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"xorl3\t%[1],%[2],$2(fp)"
|
|
setcc({LOCAL4,LB,$2,4}) | | |
|
|
xor stl $1==4 && $2>=0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"xorl3\t%[1],%[2],$2(ap)"
|
|
setcc({LOCAL4,AP,$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 && $2<0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"xorl3\t%[1],%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
xor sil $1==4 && $2>=0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"xorl3\t%[1],%[2],*$2(ap)"
|
|
setcc({displdef4,AP,tostring($2)}) | | |
|
|
xor ste $1==4 | source4 source4 |
|
|
remove(externals)
|
|
"xorl3\t%[1],%[2],$2"
|
|
setcc({EXTERNAL4,$2}) | | |
|
|
xor defined($1) | STACK |
|
|
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 && $2<0
|
|
| source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"mcoml\t%[1],$2(fp)"
|
|
setcc({LOCAL4,LB,$2,4}) | | |
|
|
com stl $1==4 && $2>=0
|
|
| source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"mcoml\t%[1],$2(ap)"
|
|
setcc({LOCAL4,AP,$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 && $2<0
|
|
| source4 |
|
|
REMEXTANDLOC
|
|
"mcoml\t%[1],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
com sil $1==4 && $2>=0
|
|
| source4 |
|
|
REMEXTANDLOC
|
|
"mcoml\t%[1],*$2(ap)"
|
|
setcc({displdef4,AP,tostring($2)}) | | |
|
|
com ste $1==4 | source4 |
|
|
remove(externals)
|
|
"mcoml\t%[1],$2"
|
|
setcc({EXTERNAL4,$2}) | | |
|
|
com defined($1) | STACK |
|
|
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 && $2<0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"rotl\t%[1],%[2],$2(fp)"
|
|
setcc({LOCAL4,LB,$2,4}) | | |
|
|
rol stl $1==4 && $2>=0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"rotl\t%[1],%[2],$2(ap)"
|
|
setcc({LOCAL4,AP,$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 && $2<0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"rotl\t%[1],%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
rol sil $1==4 && $2>=0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"rotl\t%[1],%[2],*$2(ap)"
|
|
setcc({displdef4,AP,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 source4 |
|
|
allocate(%[1],REG)
|
|
"subl3\t%[1],$$32,%[a]"
|
|
"rotl\t%[a],%[2],%[a]"
|
|
setcc(%[a]) | %[a] | |
|
|
... | NC 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 source4 |
|
|
remove(regvar($2))
|
|
allocate(%[1],REG)
|
|
"subl3\t%[1],$$32,%[a]"
|
|
"rotl\t%[a],%[2],%(regvar($2)%)"
|
|
erase(regvar($2))
|
|
setcc(regvar($2)) | | |
|
|
... | NC 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 && $2<0
|
|
| source4 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,LB,$2,4}) | | |
|
|
... | NC CONST source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"rotl\t$$%(32-%[1.num]%),%[2],$2(fp)"
|
|
setcc({LOCAL4,LB,$2,4}) | | |
|
|
ror stl $1==4 && $2>=0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
allocate(%[1],REG)
|
|
"subl3\t%[1],$$32,%[a]"
|
|
"rotl\t%[a],%[2],$2(ap)"
|
|
setcc({LOCAL4,AP,$2,4}) | | |
|
|
... | NC CONST source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
|
|
"rotl\t$$%(32-%[1.num]%),%[2],$2(ap)"
|
|
setcc({LOCAL4,AP,$2,4}) | | |
|
|
#ifdef REGVARS
|
|
ror sil $1==4 && inreg($2)==2
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
allocate(%[1],REG)
|
|
"subl3\t%[1],$$32,%[a]"
|
|
"rotl\t%[a],%[2],(%(regvar($2)%))"
|
|
setcc({regdef4,regvar($2)}) | | |
|
|
... | NC CONST source4 |
|
|
REMEXTANDLOC
|
|
"rotl\t$$%(32-%[1.num]%),%[2],(%(regvar($2)%))"
|
|
setcc({regdef4,regvar($2)}) | | |
|
|
#endif /* REGVARS */
|
|
ror sil $1==4 && $2<0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
allocate(%[1],REG)
|
|
"subl3\t%[1],$$32,%[a]"
|
|
"rotl\t%[a],%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
... | NC CONST source4 |
|
|
REMEXTANDLOC
|
|
"rotl\t$$%(32-%[1.num]%),%[2],*$2(fp)"
|
|
setcc({displdef4,LB,tostring($2)}) | | |
|
|
ror sil $1==4 && $2>=0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
allocate(%[1],REG)
|
|
"subl3\t%[1],$$32,%[a]"
|
|
"rotl\t%[a],%[2],*$2(ap)"
|
|
setcc({displdef4,AP,tostring($2)}) | | |
|
|
... | NC CONST source4 |
|
|
REMEXTANDLOC
|
|
"rotl\t$$%(32-%[1.num]%),%[2],*$2(ap)"
|
|
setcc({displdef4,AP,tostring($2)}) | | |
|
|
ror ste $1==4 | source4 source4 |
|
|
remove(externals)
|
|
allocate(%[1],REG)
|
|
"subl3\t%[1],$$32,%[a]"
|
|
"rotl\t%[a],%[2],$2"
|
|
setcc({EXTERNAL4,$2}) | | |
|
|
... | NC 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]
|
|
#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 && $3<0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $3+3 && %[num]+%[size] > $3))
|
|
"bicl3\t%[1],%[2],$3(fp)"
|
|
setcc({LOCAL4,AP,$3,4}) | | |
|
|
com and stl $1==4 && $2==4 && $3>=0
|
|
| source4 source4 |
|
|
remove(displaced)
|
|
remove(LOCALS,(%[num] <= $3+3 && %[num]+%[size] > $3))
|
|
"bicl3\t%[1],%[2],$3(ap)"
|
|
setcc({LOCAL4,AP,$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 && $3<0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"bicl3\t%[1],%[2],*$3(fp)"
|
|
setcc({displdef4,LB,tostring($3)}) | | |
|
|
com and sil $1==4 && $2==4 && $3>=0
|
|
| source4 source4 |
|
|
REMEXTANDLOC
|
|
"bicl3\t%[1],%[2],*$3(ap)"
|
|
setcc({displdef4,AP,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 | STACK |
|
|
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-(reginc4+regdec4+ind4) source4 |
|
|
remove(ALL)
|
|
allocate(REG)
|
|
"cmpl\t%[1],$$31"
|
|
"jgtru\t$2"
|
|
"ashl\t%[1],$$1,%[a]"
|
|
"bitl\t%[2],%[a]"
|
|
"jeql\t$2" | | |
|
|
... | NC source1 source4 |
|
|
remove(ALL)
|
|
allocate(REG)
|
|
"cmpb\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-(reginc4+regdec4+ind4) source4 |
|
|
remove(ALL)
|
|
allocate(REG)
|
|
"cmpl\t%[1],$$31"
|
|
"bgtru\t1f"
|
|
"ashl\t%[1],$$1,%[a]"
|
|
"bitl\t%[2],%[a]"
|
|
"jneq\t$2\n1:" | | |
|
|
... | NC source1 source4 |
|
|
remove(ALL)
|
|
allocate(REG)
|
|
"cmpb\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) | STACK |
|
|
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) | STACK |
|
|
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 adispl |
|
|
allocate(%[1],REG)
|
|
"mull3\t$$%(rom(1,3)%),%[1],%[a]"
|
|
| {adisplind1,%[a],%[2.reg],%[2.ind]} | | (8,10)+%[1]
|
|
... | NC source4 ADDR_EXTERNAL |
|
|
allocate(%[1],REG)
|
|
"mull3\t$$%(rom(1,3)%),%[1],%[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]"
|
|
| {adisplind1,%[a],%[2.reg],
|
|
%[2.ind]+"+"+tostring(0-rom(1,1)*rom(1,3))}
|
|
| | (8,10)+%[1]
|
|
... | NC source4 ADDR_EXTERNAL |
|
|
allocate(%[1],REG)
|
|
"mull3\t$$%(rom(1,3)%),%[1],%[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 | STACK |
|
|
"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 | STACK |
|
|
"jsb\t.sar4" | | |
|
|
sar !defined($1) | source4 |
|
|
remove(ALL)
|
|
move(%[1],R0)
|
|
"jsb\t.sar"
|
|
erase(R0) | | |
|
|
lar $1==4 | STACK |
|
|
"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(%[1],%[2],REG)
|
|
"xorl3\t%[1],%[2],%[a]"
|
|
setcc(%[a])
|
|
erase(%[a]) | %[a] | |
|
|
cms defined($1) | STACK |
|
|
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-regch4 | | {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-regch4 | | {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] | |
|
|
#ifdef FLOAT4
|
|
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] | |
|
|
#endif /* FLOAT4 */
|
|
#ifdef FLOAT8
|
|
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] | |
|
|
#endif /* FLOAT8 */
|
|
/* 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 | | %[1] | asp 4 |
|
|
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 | | %[1] | asp 4 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 asp $2%4 == 0 && $2>=0 && $2 < 1024
|
|
| reg4 |
|
|
remove(ALL)
|
|
"calls\t$$%($2/4%),(%[1])" | | |
|
|
cai | reg4 |
|
|
remove(ALL)
|
|
"calls\t$$0,(%[1])" | | |
|
|
cal asp $2%4 == 0 && $2>=0 && $2 < 1024
|
|
| | remove(ALL)
|
|
"calls\t$$%($2/4%),$1" | | |
|
|
cal | | remove(ALL)
|
|
"calls\t$$0,$1" | | |
|
|
lfr $1==4 | | | R0 | |
|
|
lfr $1==8 | | | QR0 | |
|
|
asp ret $2==0 | | "ret" | | |
|
|
ass ret $2==0 | | "ret" | | |
|
|
asp lfr ret $2==$3 | | "ret" | | |
|
|
ass lfr ret $2==$3 | | "ret" | | |
|
|
lfr ret $1==$2 | | "ret" | | |
|
|
ret $1==0 | | "ret" | | |
|
|
ret $1==4 | NC bigsource4 |
|
|
move(%[1],R0)
|
|
"ret" | | |
|
|
... | STACK |
|
|
"movl\t(sp)+,r0"
|
|
"ret" | | |
|
|
ret $1==8 | NC bigsource8 |
|
|
move(%[1],QR0)
|
|
"ret" | | |
|
|
... | STACK |
|
|
"movq\t(sp)+,r0"
|
|
"ret" | | |
|
|
|
|
/********************************
|
|
* Group 15 : Miscellaneous *
|
|
********************************/
|
|
|
|
#ifdef REGVARS
|
|
asp $1==4 | bigsource4 - regch4 | | | |
|
|
#else /* REGVARS */
|
|
asp $1==4 | NC bigsource4 | | | |
|
|
#endif /* REGVARS */
|
|
... | STACK |
|
|
"tstl\t(sp)+" | | | (2,7)
|
|
asp $1>0 | STACK |
|
|
"addl2\t$$$1,sp" | | |
|
|
asp $1==(0-4) | | | {CONST4,0} | |
|
|
asp $1==(0-8) | | | {CONST8,"0"} | |
|
|
asp | STACK |
|
|
"subl2\t$$%(0-$1%),sp" | | |
|
|
ass $1==4 | source4 |
|
|
remove(ALL)
|
|
"addl2\t%[1],sp" | | |
|
|
ass !defined($1) | source4 |
|
|
remove(ALL)
|
|
move(%[1],R2) /* R2 <= leave return area intact. */
|
|
"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 | STACK |
|
|
"jmp\t.csa4" | | |
|
|
csa !defined($1) | source4 |
|
|
remove(ALL)
|
|
move(%[1],R0)
|
|
"jmp\t.csa"
|
|
erase(R0) | | |
|
|
csb $1==4 | STACK |
|
|
"jmp\t.csb4" | | |
|
|
csb !defined($1) | source4 |
|
|
remove(ALL)
|
|
move(%[1],R0)
|
|
"jmp\t.csb"
|
|
erase(R0) | | |
|
|
dch | reg4 | | {displ4,%[1],"12"} | |
|
|
dup stl $1==4 | | | | stl $2 lol $2 |
|
|
dup $1==4 | dups4 | | %[1] %[1] | |
|
|
#ifdef REGVARS
|
|
dup $1==8 | bigsource8-regch8 | | %[1] %[1] | |
|
|
#else /* REGVARS */
|
|
dup $1==8 | bigsource8 | | %[1] %[1] | |
|
|
#endif /* REGVARS */
|
|
... | dups4 dups4 | | %[2] %[1] %[2] %[1] | |
|
|
dup | STACK |
|
|
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-regch4 bigsource4-regch4 | | %[1] %[2] | |
|
|
exg $1==8 | bigsource8-regch8 bigsource8-regch8 | | %[1] %[2] | |
|
|
exg defined($1) | STACK |
|
|
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 | STACK |
|
|
"pushl\t$$$1"
|
|
"jmp\t.gto" | | |
|
|
lor $1==0 | | | LB | |
|
|
lor $1==1 | STACK |
|
|
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 | STACK |
|
|
"jsb\t.mon" | | |
|
|
nop | STACK |
|
|
#ifdef DEBUG
|
|
"jsb\t.nop"
|
|
#endif
|
|
| | |
|
|
|
|
#ifdef DORCK
|
|
rck $1==4 | STACK |
|
|
"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" | | |
|
|
sig | STACK |
|
|
"jsb\t.sig" | | |
|
|
sim | STACK |
|
|
"jsb\t.sim" | | |
|
|
str $1==0 | STACK |
|
|
"jsb\t.strlb" | | |
|
|
str $1==1 | source4 |
|
|
remove(ALL)
|
|
"movl\t%[1],sp" | | |
|
|
str $1==2 | STACK |
|
|
"jsb\t.strhp" | | |
|
|
trp | STACK |
|
|
"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] | |
|
|
| reg4 | | {adispl,%[1],"0"} | |
|
|
| ADDR_LOCAL | | {adispl,%[1.reg],tostring(%[1.num])} | |
|
|
| bigsource4-adispl-reg4-ADDR_LOCAL |
|
|
allocate(%[1],REG=%[1]) | {adispl,%[a],"0"} | |
|
|
|
|
/********************************
|
|
* 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.reg],%[1.num]+4,4} {LOCAL4,%[1.reg],%[1.num],4}| |
|
|
| EXTERNAL8 | | {EXTERNAL4,%[1.ind]+"+4"} {EXTERNAL4,%[1.ind]} | |
|
|
| QREG | | %[1.2] %[1.1] | |
|
|
| regdef4 | | {displ4,%[1.reg],"0"} | |
|
|
| LOCAL4 | | {displ4,%[1.reg],tostring(%[1.num])} | |
|
|
|
|
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])
|
|
#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, reg4, "movzbl\t%[1],%[2]"
|
|
setcc(%[2]) erase(%[2]),(3,4)+%[1])
|
|
(source2, reg4, "movzwl\t%[1],%[2]"
|
|
setcc(%[2]) erase(%[2]),(3,4)+%[1])
|
|
(reg4, source1, "cvtlb\t%[1],%[2]"
|
|
setcc(%[2]) erase(%[1]),(3,4)+%[2])
|
|
(reg4, source2, "cvtlw\t%[1],%[2]"
|
|
setcc(%[2]) erase(%[1]),(3,4)+%[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])
|
|
(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])
|