d0p1/ack
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
ack/mach/z80/cg/table
ceriel dc2ab49b32 NOP does nothing but stacking
1991-08-30 15:48:10 +00:00

1451 lines
30 KiB
Plaintext
Raw Blame History

"$Header$"
/********************************************************************
**** ****
**** Z 8 0 B A C K E N D T A B L E S ****
**** ****
********************************************************************/
/*
* INTEGER SIZE: 16 bits
* POINTER SIZE: 16 bits
*/
/* We store LB in the iy index-register, because this results in the
* cheapest addressing schemes for instruction like lol and stl.
* For a lol with an argument that is too low (< 0-128) or too high
* (>= 127) there is an overhead, because the offset cannot be
* expressed in 8 bits. In these cases we copy the LB to the hl-register,
* compute the required address and use register indirect mode to do
* the load. These cases occur rarely (about 11.5 % in C and 5.5 %
* in Pascal.
*/
EM_WSIZE = 2
EM_PSIZE = 2
EM_BSIZE = 4
/**************************
** R E G I S T E R S **
**************************/
REGISTERS:
AA = ("a",1) REG1, AREG.
BB = ("b",1) REG1.
CC = ("c",1) REG1.
DD = ("d",1) REG1.
EE = ("e",1) REG1.
HH = ("h",1) REG1.
LL = ("l",1) REG1.
BC = ("bc",2,BB,CC) REG, GEN_REG, BC_REG, ANY_REG.
DE = ("de",2,DD,EE) REG, GEN_REG, DE_REG, ANY_REG.
HL = ("hl",2,HH,LL) GEN_REG, HL_REG, ANY_REG.
LB = ("iy",2) LOCALBASE.
IX = ("ix",2) INDEXREG, IX_REG, ANY_REG.
pseudo0 = ("",2,BC,DE).
pseudo1 = ("",2,HL,IX).
pseudo2 = ("",2,pseudo0,pseudo1).
pseudo3 = ("",2,pseudo2,AA) ALL_REG.
/*****************
** T O K E N S **
*****************/
TOKENS:
IMMEDIATE1 = {INT off;} 1 "%[off]"
IMMEDIATE = {INT off;} 2 "%[off]"
IREG1 = {REGISTER reg;} 1 "(%[reg])"
INDEXED = {REGISTER reg;
INT off; } 1 "(%[reg]+%[off])"
EXTENDED = {STRING off; } 2 "(%[off])"
LOCAL_ADDR = {INT off; } 2
EXTENDED_ADDR = {STRING off; } 2 "%[off]"
/*************************************
** T O K E N E X P R E S S I O N S **
*************************************/
TOKENEXPRESSIONS:
ANYTOK = IMMEDIATE + EXTENDED
ANY1 = REG1 + IMMEDIATE1 + IREG1 + INDEXED
ANY_ADDR = EXTENDED_ADDR + LOCAL_ADDR
ANY = ANYTOK + ANY_REG + ANY_ADDR
MEM_ALL = ANY - ANY_REG
REG_SCR = REG * SCRATCH
ANY_REG_SCR = ANY_REG * SCRATCH
GEN_REG_SCR = GEN_REG * SCRATCH
HL_REG_SCR = HL_REG * SCRATCH
BC_REG_SCR = BC_REG * SCRATCH
DE_REG_SCR = DE_REG * SCRATCH
IX_REG_SCR = IX_REG * SCRATCH
/*************
** C O D E **
*************/
CODE:
/* G R O U P I : L O A D S */
loc | | | {IMMEDIATE,$1} | |
ldc | | | {IMMEDIATE,highw(1)} {IMMEDIATE,loww(1)} | |
lol sfit($1,8) | | allocate(REG)
move({INDEXED,LB,$1} , %[a.2] )
move({INDEXED,LB,$1+1} , %[a.1] ) | %[a] | |
lol | | allocate(HL_REG,REG)
"push iy"
"pop %[b]"
move({IMMEDIATE,$1} , %[a] )
"add hl,%[b]"
"ld %[b.2],(hl)"
"inc hl"
"ld %[b.1],(hl)"
erase(HL)
erase(%[a]) | %[b] | |
ldl $1<126 && $1>0-128 | | allocate(REG,REG)
move({INDEXED,LB,$1} , %[a.2])
move({INDEXED,LB,$1+1},%[a.1])
move({INDEXED,LB,$1+2},%[b.2])
move({INDEXED,LB,$1+3},%[b.1]) | %[b] %[a] | |
ldl | |
remove(ALL)
allocate(BC_REG,DE_REG,HL_REG={IMMEDIATE,$1})
"push iy"
"pop bc"
"add hl,bc"
"ld e,(hl)"
"inc hl"
"ld d,(hl)"
"inc hl"
"ld c,(hl)"
"inc hl"
"ld b,(hl)"
| BC DE | |
loe | | | {EXTENDED,$1} | |
lde | | | {EXTENDED,$1+"+2"} {EXTENDED,$1} | |
lil sfit($1,8) | | allocate(HL_REG,REG)
move({INDEXED,LB,$1} , %[a.2])
move({INDEXED,LB,$1+1} , %[a.1])
"ld %[b.2],(hl)"
"inc hl"
"ld %[b.1],(hl)"
erase(HL)
erase(%[a]) | %[b] | |
lil | | allocate(HL_REG = {IMMEDIATE,$1} , REG)
"push iy"
"pop %[b]"
"add hl,%[b]"
"ld %[b.2],(hl)"
"inc hl"
"ld %[b.1],(hl)"
"ld h,%[b.1]"
"ld l,%[b.2]"
"ld %[b.2],(hl)"
"inc hl"
"ld %[b.1],(hl)"
erase(HL)
erase(%[a]) | %[b] | |
lof | HL_REG_SCR | allocate(REG = {IMMEDIATE,$1} )
"add hl,%[a]"
"ld %[a.2],(hl)"
"inc hl"
"ld %[a.1],(hl)"
erase(HL)
erase(%[a]) | %[a] | |
... | REG_SCR | allocate(HL_REG = {IMMEDIATE,$1} )
"add hl,%[1]"
"ld %[1.2],(hl)"
"inc hl"
"ld %[1.1],(hl)"
erase(HL)
erase(%[1]) | %[1] | |
ldf | HL_REG_SCR | allocate(REG = {IMMEDIATE,$1} , REG)
"add hl,%[a]"
"ld %[a.2],(hl)"
"inc hl"
"ld %[a.1],(hl)"
"inc hl"
"ld %[b.2],(hl)"
"inc hl"
"ld %[b.1],(hl)"
erase(HL)
erase(%[a]) | %[b] %[a] | |
... | REG_SCR | allocate(HL_REG = {IMMEDIATE,$1} , REG)
"add hl,%[1]"
"ld %[1.2],(hl)"
"inc hl"
"ld %[1.1],(hl)"
"inc hl"
"ld %[b.2],(hl)"
"inc hl"
"ld %[b.1],(hl)"
erase(HL)
erase(%[1]) | %[b] %[1] | |
lal | | remove(ALL)
allocate(HL_REG, REG = {IMMEDIATE,$1} )
"push iy"
"pop hl"
"add hl,%[b]"
erase(%[a]) | %[a] | |
lae | | | {EXTENDED_ADDR,$1} | |
lxl $1 == 0 | | remove(ALL)
"push iy"
| | |
lxl | | remove(ALL)
allocate(AREG = {IMMEDIATE1,$1} ,
HL_REG,BC_REG)
"push iy"
"pop %[c]"
"1:"
"ld hl,4"
"add hl,%[c]"
"ld %[c.2],(hl)"
"inc hl"
"ld %[c.1],(hl)"
"dec a"
"jr nz,1b"
"push %[c]"
erase(AA) | | |
lxa $1 == 0 | | | | lxl $1 adp 4 |
lxa $1 == 1 | | remove(ALL)
allocate(HL_REG,BC_REG)
"ld %[b],4"
"push iy"
"pop hl"
"add hl,%[b]"
"ld %[b.2],(hl)"
"inc hl"
"ld %[b.1],(hl)"
"ld hl,4"
"add hl,%[b]" | HL | |
lxa $1 > 1 | | remove (ANY)
allocate(AREG = {IMMEDIATE1,$1},
HL_REG,BC_REG)
"push iy"
"pop %[c]"
"1:"
"ld hl,4"
"add hl,%[c]"
"ld %[c.2],(hl)"
"inc hl"
"ld %[c.1],(hl)"
"inc hl"
"dec a"
"jr nz,1b"
"ld hl,4"
"add hl,%[c]"
erase(AA) | HL | |
dch | | | | loi 2 |
loi $1 == 1 | HL_REG | allocate(REG = {IMMEDIATE,0} )
"ld %[a.2],(hl)"
erase(%[a]) | %[a] | |
... | REG | allocate(REG,AREG)
move({IREG1,%[1]} , AA)
move(AA , %[a.2])
move({IMMEDIATE1,0} , %[a.1])
erase(AA) | %[a] | |
loi $1 == 2 | HL_REG_SCR | remove(ALL) allocate(REG)
"ld %[a.2],(hl)"
"inc hl"
"ld %[a.1],(hl)"
erase(%[1]) | %[a] | |
loi $1 == 4 | HL_REG_SCR | remove(ALL)
allocate(AREG,REG)
"ld %[b.2],(hl)"
"inc hl"
"ld %[b.1],(hl)"
"inc hl"
"ld a,(hl)"
"inc hl"
"ld h,(hl)"
"ld l,a"
erase(HL) | HL %[b] | |
loi $1 <= 511 && $1 > 4 | HL_REG_SCR |
remove(ALL)
allocate(AREG,REG)
move({IMMEDIATE,$1-1} , %[b])
"add hl,%[b]"
move({IMMEDIATE1,$1/2} , AA)
"1:"
"ld %[b.1],(hl)"
"dec hl"
"ld %[b.2],(hl)"
"dec hl"
"push %[b]"
"dec a"
"jr nz,1b"
erase(%[a])
erase(%[b]) | | |
loi $1 > 511 | STACK | remove(ALL) allocate(ALL_REG)
move({IMMEDIATE,$1}, HL)
"push hl"
"call .los"
erase(HL) | | |
los $1 == 2 | STACK | remove(ALL) allocate(ALL_REG)
"call .los" | | |
lpi | | | {EXTENDED_ADDR,$1} | |
/* G R O U P II : S T O R E S */
stl sfit($1,8) | REG + HL_REG |
remove(ALL)
move(%[1.2] , {INDEXED,LB,$1} )
move(%[1.1] , {INDEXED,LB,$1+1} )
| | |
stl | REG |
remove(ALL)
allocate(HL_REG = {IMMEDIATE,$1} , REG)
"push iy"
"pop %[b]"
"add hl,%[b]"
"ld (hl),%[1.2]"
"inc hl"
"ld (hl),%[1.1]"
erase(%[a]) | | |
ste | ANY_REG | remove(EXTENDED,%[off] == $1)
remove(ALL)
move(%[1] , {EXTENDED,$1} ) | | |
sil ($1 >= 0-128 && $1 < 127) | REG |
remove(ALL)
allocate(HL_REG)
move({INDEXED,LB,$1} , %[a.2])
move({INDEXED,LB,$1+1} , %[a.1])
"ld (hl),%[1.2]"
"inc hl"
"ld (hl),%[1.1]"
erase(%[a]) | | |
sil ($1 < 0-128 || $1 >= 127) | REG |
remove(ALL)
allocate(HL_REG,REG)
"push iy"
"pop %[b]"
move({IMMEDIATE,$1} , %[a])
"add hl,%[b]"
"ld %[b.2],(hl)"
"inc hl"
"ld %[b.1],(hl)"
"ld h,%[b.1]"
"ld l,%[b.2]"
"ld (hl),%[1.2]"
"inc hl"
"ld (hl),%[1.1]"
erase(%[a]) | | |
stf | HL_REG_SCR REG | remove(ALL)
allocate(REG = {IMMEDIATE,$1})
"add hl,%[a]"
"ld (hl),%[2.2]"
"inc hl"
"ld (hl),%[2.1]"
erase(%[1]) | | |
sti $1 == 1 | HL_REG REG | remove(ALL)
"ld (hl),%[2.2]" | | |
sti $1 == 2 | HL_REG_SCR REG | remove(ALL)
"ld (hl),%[2.2]"
"inc hl"
"ld (hl),%[2.1]"
erase(%[1]) | | |
sti $1 == 4 | HL_REG_SCR REG REG |
remove(ALL)
"ld (hl),%[2.2]"
"inc hl"
"ld (hl),%[2.1]"
"inc hl"
"ld (hl),%[3.2]"
"inc hl"
"ld (hl),%[3.1]"
erase(HL) | | |
sti $1 <= 511 && $1 > 4 | HL_REG_SCR |
remove(ALL)
allocate(AREG,REG)
move({IMMEDIATE1,$1/2} , AA)
"1:"
"pop %[b]"
"ld (hl),%[b.2]"
"inc hl"
"ld (hl),%[b.1]"
"inc hl"
"dec a"
"jr nz,1b"
erase(AA)
erase(HL) | | |
sti $1 > 511 | STACK | remove(ALL) allocate(ALL_REG)
move({IMMEDIATE,$1}, HL)
"push hl"
"call .sts"
erase(HL) | | |
sts $1 == 2 | STACK | remove(ALL) allocate(ALL_REG)
"call .sts" | | |
sdl ($1 >= 0-128 && $1 < 125) | REG REG |
remove(ALL)
move(%[1.2] , {INDEXED,LB,$1})
move(%[1.1] , {INDEXED,LB,$1+1})
move(%[2.2] , {INDEXED,LB,$1+2})
move(%[2.1] , {INDEXED,LB,$1+3}) | | |
sdl ($1 < 0-128 || $1 >= 125) | STACK |
remove(ALL)
allocate(HL_REG = {IMMEDIATE,$1} ,
BC_REG,DE_REG,IX_REG,AREG )
"call .sdl"
erase(HL) | | |
sde | ANY_REG ANY_REG |
remove(ALL)
move(%[1] , {EXTENDED,$1})
move(%[2] , {EXTENDED,$1+"+2"}) | | |
sdf | | remove(ALL)
allocate(ALL_REG)
move({IMMEDIATE,$1},DE)
"call .sdf"
| | |
/* G R O U P III & IV : I N T E G E R A R I T H M E T I C */
adi $1 == 2 | HL_REG_SCR GEN_REG |
"add hl,%[2]"
erase(HL) | HL | |
... | GEN_REG HL_REG_SCR |
"add hl,%[1]"
erase(HL) | HL | |
adi $1 == 4 | HL_REG_SCR DE_REG_SCR STACK | allocate(BC_REG)
"pop bc"
"add hl,bc"
"ex de,hl"
"pop bc"
"adc hl,bc"
erase(DE)
erase(HL) | HL DE | |
sbi $1 == 2 | GEN_REG HL_REG_SCR |
"or a"
"sbc hl,%[1]"
erase(HL) | HL | |
sbi $1 == 4 | BC_REG_SCR DE_REG_SCR STACK |
allocate(HL_REG)
"or a"
"pop hl"
"sbc hl,bc" /* least sign. */
"ex (sp),hl"
"sbc hl,de"
"pop de"
erase(DE)
erase(HL) | HL DE | |
mli $1 == 2 | DE_REG_SCR BC_REG STACK |
allocate(HL_REG,IX_REG,AREG)
"call .mli2"
erase(DE) | HL | |
mli $1 == 4 | STACK | allocate(ALL_REG)
"call .mli4" | | |
dvi $1 == 2 | BC_REG_SCR DE_REG_SCR STACK |
allocate(HL_REG,IX_REG,AREG)
"call .dvi2"
"push de"
erase(BC)
erase(DE) | | |
dvi $1 == 4 | STACK | allocate(ALL_REG)
"call .dvi4" | | |
dvu $1 == 2 | BC_REG_SCR DE_REG_SCR STACK |
allocate(HL_REG,IX_REG,AREG)
"call .dvu2"
erase(BC)
erase(DE) | DE | |
dvu $1 == 4 | STACK | allocate(ALL_REG)
"call .dvu4" | | |
rmi $1 == 2 | BC_REG_SCR DE_REG_SCR STACK |
allocate(HL_REG,IX_REG,AREG)
"call .rmi2"
erase(BC)
erase(DE) | DE | |
rmi $1 == 4 | STACK | allocate(ALL_REG)
"call .dvi4"
"pop hl"
"pop hl"
erase(HL)
| BC DE | |
rmu $1 == 2 | BC_REG_SCR DE_REG_SCR STACK |
allocate(HL_REG,IX_REG,AREG)
"call .dvu2"
erase(BC)
erase(DE) | HL | |
rmu $1 == 4 | STACK | allocate(ALL_REG)
"call .dvu4" | BC DE | |
ngi $1 == 2 | REG | allocate(HL_REG = {IMMEDIATE,0})
"or a"
"sbc hl,%[1]"
erase(HL) | HL | |
ngi $1 == 4 | DE_REG_SCR BC_REG_SCR |
allocate(HL_REG,AREG)
"xor a"
"ld h,a"
"ld l,a"
"sbc hl,de"
"ex de,hl"
"ld h,a"
"ld l,a"
"sbc hl,bc"
erase(DE) | HL DE | |
sli $1 == 2 | REG_SCR HL_REG_SCR |
"inc %[1.1]" /* see if count >> 15 */
"dec %[1.1]"
"jr z,1f"
"ld %[1.2],15"
"1:"
"dec %[1.2]"
"jp m,2f"
"add hl,hl"
"jr 1b"
"2:"
erase(%[1])
erase(HL) | HL | |
sli $1 == 4 | REG_SCR IX_REG_SCR HL_REG_SCR |
"inc %[1.1]"
"dec %[1.1]"
"jr z,1f"
"ld %[1.2],31"
"1:"
"dec %[1.2]"
"jp m,2f"
"add ix,ix"
"adc hl,hl"
"jr 1b"
"2:"
erase(%[1])
erase(HL)
erase(IX) | HL IX | |
sri $1 == 2 | GEN_REG_SCR GEN_REG_SCR |
"inc %[1.1]"
"dec %[1.1]"
"jr z,1f"
"ld %[1.2],15"
"1:"
"dec %[1.2]"
"jp m,2f"
"sra %[2.1]"
"rr %[2.2]"
"jr 1b"
"2:"
erase(%[1])
erase(%[2]) | %[2] | |
sri $1 == 4 | GEN_REG_SCR GEN_REG_SCR GEN_REG_SCR |
"inc %[1.1]"
"dec %[1.1]"
"jr z,1f"
"ld %[1.2],31"
"1:"
"dec %[1.2]"
"jp m,2f"
"sra %[3.1]"
"rr %[3.2]"
"rr %[2.1]"
"rr %[2.2]"
"jr 1b"
"2:"
erase(%[1])
erase(%[2])
erase(%[3]) | %[3] %[2] | |
mlu | | | | mli $1 |
sru $1 == 2 | GEN_REG_SCR GEN_REG_SCR |
"inc %[1.1]"
"dec %[1.1]"
"jr z,1f"
"ld %[1.2],15"
"1:"
"dec %[1.2]"
"jp m,2f"
"srl %[2.1]"
"rr %[2.2]"
"jr 1b"
"2:"
erase(%[1])
erase(%[2]) | %[2] | |
sru $1 == 4 | GEN_REG_SCR GEN_REG_SCR GEN_REG_SCR |
"inc %[1.1]"
"dec %[1.1]"
"jr z,1f"
"ld %[1.2],31"
"1:"
"dec %[1.2]"
"jp m,2f"
"srl %[3.1]"
"rr %[3.2]"
"rr %[2.1]"
"rr %[2.2]"
"jr 1b"
"2:"
erase(%[1])
erase(%[2])
erase(%[3]) | %[3] %[2] | |
adu | | | | adi $1 |
sbu | | | | sbi $1 |
slu | | | | sli $1 |
/* G R O U P V : F L O A T I N G P O I N T */
adf | |
"call .unimpld" | | |
sbf | |
"call .unimpld" | | |
mlf | |
"call .unimpld" | | |
dvf | |
"call .unimpld" | | |
ngf | |
"call .unimpld" | | |
fif | |
"call .unimpld" | | |
fef | |
"call .unimpld" | | |
/* G R O U P VI : P O I N T E R A R I T H M E T I C */
adp $1 == 0 | | | | |
adp $1 == 1 | ANY_REG_SCR | "inc %[1]"
erase(%[1]) | %[1] | |
adp $1 == 2 | ANY_REG_SCR | "inc %[1]"
"inc %[1]"
erase(%[1]) | %[1] | |
adp $1 == 0-1 | ANY_REG_SCR | "dec %[1]"
erase(%[1]) | %[1] | |
adp $1 == 0-2 | ANY_REG_SCR | "dec %[1]"
"dec %[1]"
erase(%[1]) | %[1] | |
adp $1 < 0-2 || $1 > 2 | HL_REG_SCR |
allocate(REG = {IMMEDIATE,$1} )
"add hl,%[a]"
erase(HL) | HL | |
... | REG |
allocate(HL_REG = {IMMEDIATE,$1} )
"add hl,%[1]"
erase(HL) | HL | |
... | LOCAL_ADDR | remove(ALL) | {LOCAL_ADDR, %[1.off]+$1} | |
ads $1 == 2 | HL_REG_SCR REG | remove(ALL) "add hl,%[2]"
erase(HL) | HL | |
... | REG HL_REG_SCR | "add hl,%[1]"
erase(HL) | HL | |
sbs $1 == 2 | REG HL_REG_SCR | "or a"
"sbc hl,%[1]"
erase(HL) | HL | |
/* G R O U P VII : I N C R E M E N T / D E C R E M E N T */
inc | ANY_REG_SCR | "inc %[1]"
erase(%[1]) | %[1] | |
/* There is no efficient way on the Z80 to increment or decrement
* a local or external. We first fetch the variable into a register,
* increment/decrement it and then store it.
*/
inl | | | | lol $1 inc stl $1 |
ine | | | | loe $1 inc ste $1 |
dec | ANY_REG_SCR | "dec %[1]"
erase(%[1]) | %[1] | |
del | | | | lol $1 dec stl $1 |
dee | | | | loe $1 dec ste $1 |
zrl ($1 >= 0-128 && $1 < 127) | |
remove(ALL)
allocate(AREG)
"xor a"
move(AA , {INDEXED,LB,$1})
move(AA , {INDEXED,LB,$1+1}) | | |
zrl ($1 < 0-128 || $1 >= 127) | |
remove(ALL)
allocate(HL_REG = {IMMEDIATE,$1} , REG, AREG)
"push iy"
"pop %[b]"
"add hl,%[b]"
"xor a"
"ld (hl),a"
"inc hl"
"ld (hl),a"
erase(HL) | | |
zrf | |
"call .unimpld" | | |
zre | | remove(EXTENDED,%[off] == $1)
remove(ALL)
allocate(ANY_REG = {IMMEDIATE,0} )
move(%[a] , {EXTENDED,$1}) | | |
zer $1 == 2 | | | {IMMEDIATE,0} | |
zer $1 == 4 | | | {IMMEDIATE,0} {IMMEDIATE,0} | |
zer $1 > 4 && $1 < 256 | STACK |
allocate(BC_REG , GEN_REG)
"ld b,$1"
"ld %[b],0"
"1:"
"push %[b]"
"djnz 1b"
| | |
/* G R O U P VIII : C O N V E R T */
cii | STACK | remove(ALL) allocate(ALL_REG)
"call .cii" | | |
cuu | STACK | remove(ALL) allocate(ALL_REG)
"call .cuu" | | |
cui | | | | cuu |
ciu | | | | cuu |
cfi | |
"call .unimpld" | | |
cif | |
"call .unimpld" | | |
cuf | |
"call .unimpld" | | |
cff | |
"call .unimpld" | | |
cfu | |
"call .unimpld" | | |
cmf | |
"call .unimpld" | | |
/* G R O U P IX : L O G I C A L */
and $1 == 2 | GEN_REG GEN_REG_SCR |
allocate(AREG)
"ld a,%[1.2]"
"and %[2.2]"
"ld %[2.2],a"
"ld a,%[1.1]"
"and %[2.1]"
"ld %[2.1],a"
erase(%[2]) | %[2] | |
and defined($1) && $1 > 2 | STACK |
allocate(DE_REG = {IMMEDIATE,$1},
BC_REG,HL_REG,IX_REG,AREG)
"call .and"
erase(DE) | | |
and ! defined($1) | DE_REG_SCR STACK |
allocate(BC_REG,HL_REG,IX_REG,AREG)
"call .and"
erase(DE) | | |
ior $1 == 2 | GEN_REG GEN_REG_SCR |
allocate(AREG)
"ld a,%[1.2]"
"or %[2.2]"
"ld %[2.2],a"
"ld a,%[1.1]"
"or %[2.1]"
"ld %[2.1],a"
erase(%[2]) | %[2] | |
ior defined($1) && $1 > 2 | STACK |
allocate(DE_REG = {IMMEDIATE,$1},
BC_REG,HL_REG,IX_REG,AREG)
"call .ior"
erase(DE) | | |
ior ! defined($1) | DE_REG_SCR STACK |
allocate(BC_REG,HL_REG,IX_REG,AREG)
"call .ior"
erase(DE) | | |
xor $1 == 2 | GEN_REG GEN_REG_SCR |
allocate(AREG)
"ld a,%[1.2]"
"xor %[2.2]"
"ld %[2.2],a"
"ld a,%[1.1]"
"xor %[2.1]"
"ld %[2.1],a"
erase(%[2]) | %[2] | |
xor defined($1) && $1 > 2 | STACK |
allocate(DE_REG = {IMMEDIATE,$1},
BC_REG,HL_REG,IX_REG,AREG)
"call .xor"
erase(DE) | | |
xor ! defined($1) | DE_REG_SCR STACK |
allocate(BC_REG,HL_REG,IX_REG,AREG)
"call .xor"
erase(DE) | | |
com $1 == 2 | GEN_REG_SCR | allocate(AREG)
"ld a,%[1.2]"
"cpl"
"ld %[1.2],a"
"ld a,%[1.1]"
"cpl"
"ld %[1.1],a"
erase(%[1]) | %[1] | |
com defined($1) && $1 > 2 | STACK |
allocate(AREG,
HL_REG = {IMMEDIATE,$1} )
"add hl,sp"
"1:"
"dec hl"
"ld a,(hl)"
"cpl"
"ld (hl),a"
"xor a"
"sbc hl,sp"
"jr z,2f"
"add hl,sp"
"jr 1b"
"2:"
erase(HL) | | |
com ! defined($1) | HL_REG_SCR STACK |
allocate(AREG)
"add hl,sp"
"1:"
"dec hl"
"ld a,(hl)"
"cpl"
"ld (hl),a"
"xor a"
"sbc hl,sp"
"jr z,2f"
"add hl,sp"
"jr 1b"
"2:"
erase(HL) | | |
rol $1 == 2 | REG_SCR HL_REG_SCR |
allocate(AREG)
"ld a,%[1.2]"
"and 15"
"jr z,2f"
"ld %[1],0"
"1:"
"add hl,hl"
"adc hl,%[1]"
"dec a"
"jr nz,1b"
"2:"
erase(%[1])
erase(%[2]) | HL | |
rol $1 == 4 | REG IX_REG_SCR HL_REG_SCR |
allocate(AREG)
"ld a,%[1.2]"
"and 31"
"jr z,3f"
"1:"
"add ix,ix"
"adc hl,hl"
"jr nc,2f"
"inc ix"
"2:"
"dec a"
"jr nz,1b"
"3:"
erase(HL)
erase(IX) | HL IX | |
ror $1 == 2 | GEN_REG_SCR GEN_REG_SCR |
allocate(AREG)
"ld a,%[1.2]"
"and 15"
"jr z,0f"
"1:"
"srl %[2.1]"
"rr %[2.2]"
"jr nc,2f"
"set 7,%[2.1]"
"2:"
"dec a"
"jr nz,1b"
"0:"
erase(%[1])
erase(%[2]) | %[2] | |
ror $1 == 4 | GEN_REG_SCR GEN_REG_SCR GEN_REG_SCR |
allocate(AREG)
"ld a,%[1.2]"
"and 31"
"jr z,0f"
"1:"
"srl %[3.1]"
"rr %[3.2]"
"rr %[2.1]"
"rr %[2.2]"
"jr nc,2f"
"set 7,%[3.1]"
"2:"
"dec a"
"jr nz,1b"
"0:"
erase(%[1])
erase(%[2])
erase(%[3]) | %[3] %[2] | |
/* G R O U P X : S E T S */
inn defined($1) | STACK | allocate(HL_REG = {IMMEDIATE,$1},
BC_REG,DE_REG,IX_REG,AREG)
"call .inn"
erase(HL) | | |
inn !defined($1) | HL_REG_SCR STACK |
allocate(BC_REG,DE_REG,IX_REG,AREG)
"call .inn"
erase(HL) | | |
set defined($1) | STACK | allocate(HL_REG = {IMMEDIATE,$1},
BC_REG,DE_REG,IX_REG,AREG)
"call .set"
erase(HL) | | |
set !defined($1) | HL_REG_SCR STACK |
allocate(BC_REG,DE_REG,IX_REG,AREG)
"call .set"
erase(HL) | | |
/* G R O U P XI : A R R A Y S */
lae aar $2 == 2 && rom(1,3) == 2 | STACK |
allocate(ALL_REG)
move({EXTENDED_ADDR,$1},BC)
"push bc"
"call .aar2" | | |
lae aar $2 == 2 && rom(1,3) != 2 | STACK |
allocate(ALL_REG)
move({EXTENDED_ADDR,$1},BC)
"push bc"
"call .aar" | | |
aar $1==2 | |
remove(ALL)
allocate(ALL_REG)
"call .aar"
| | |
aar !defined($1) | | remove(ALL)
allocate(ALL_REG)
"call .aaru" | | |
lae lar $2 == 2 && rom(1,3) == 2 | STACK |
remove(ALL) allocate(ALL_REG)
move({EXTENDED_ADDR,$1},BC)
"push bc"
"call .lar2" | | |
lae lar $2 == 2 && rom(1,3) != 2 | STACK |
remove(ALL) allocate(ALL_REG)
move({EXTENDED_ADDR,$1},BC)
"push bc"
"call .lar" | | |
lar $1==2 | | remove(ALL)
allocate(ALL_REG)
"call .lar" | | |
lar !defined($1) | | remove(ALL)
allocate(ALL_REG)
"call .laru" | | |
lae sar $2 == 2 && rom(1,3) == 2 | STACK |
remove(ALL) allocate(ALL_REG)
move({EXTENDED_ADDR, $1},BC)
"push bc"
"call .sar2" | | |
lae sar $2 == 2 && rom(1,3) != 2 | STACK |
remove(ALL) allocate(ALL_REG)
move({EXTENDED_ADDR, $1},BC)
"push bc"
"call .sar" | | |
sar $1==2 | | remove(ALL)
allocate(ALL_REG)
"call .sar" | | |
sar !defined($1) | | remove(ALL)
allocate(ALL_REG)
"call .saru" | | |
/* G R O U P XII : C O M P A R E */
cmi $1 == 2 | REG_SCR HL_REG_SCR |
remove(ALL) allocate(AREG)
"ld a,h"
"xor %[1.1]"
"jp m,1f"
"sbc hl,%[1]"
"jr 2f"
"1:"
"xor %[1.1]"
"jp m,2f"
"set 0,l"
"2:"
erase(%[1])
erase(%[2]) | HL | |
cmi $1 == 4 | STACK | remove(ALL) allocate(AREG = {IMMEDIATE1,1},
BC_REG,DE_REG,HL_REG,IX_REG)
"call .cmu4"
erase(AA) | DE | |
cmu $1 == 2 | REG_SCR HL_REG_SCR |
remove(ALL) allocate(AREG)
"ld a,h"
"xor %[1.1]" /* resets carry bit */
"jp m,1f"
"sbc hl,%[1]"
"jr 2f"
"1:"
"xor %[1.1]"
"cpl"
"set 0,l"
"2:"
erase(%[1])
erase(%[2]) | HL | |
cmu $1 == 4 | STACK | remove(ALL) allocate(AREG = {IMMEDIATE1,0},
BC_REG,DE_REG,HL_REG,IX_REG)
"call .cmu4"
erase(AA) | DE | |
cmp | | | | cmu 2 |
cms $1 == 2 | GEN_REG GEN_REG_SCR |
remove(ALL) allocate(AREG)
"ld a,%[1.1]"
"xor %[2.1]"
"ld %[2.1],a"
"ld a,%[1.2]"
"xor %[2.2]"
"ld %[2.2],a" | %[2] | |
/***
cmu defined($1) | STACK | allocate(HL_REG = {IMMEDIATE,$1},
BC_REG,DE_REG,IX_REG,AREG)
"call .cmu"
erase(HL) | | |
cmu ! defined($1) | HL_REG_SCR STACK |
allocate(BC_REG,DE_REG,IX_REG,AREG)
"call .cmu"
erase(HL) | | |
*/
cms defined($1) | STACK | remove(ALL) allocate(HL_REG = {IMMEDIATE,$1},
BC_REG,DE_REG,IX_REG,AREG)
"call .cms"
erase(HL) | | |
cms ! defined($1) | HL_REG_SCR STACK |
allocate(BC_REG,DE_REG,IX_REG,AREG)
"call .cms"
erase(HL) | | |
tlt | GEN_REG | remove(ALL)
allocate(GEN_REG = {IMMEDIATE,0})
"bit 7,%[1.1]"
"jr z,1f"
"inc %[a.2]"
"1:"
erase(%[a]) | %[a] | |
tle | GEN_REG | remove(ALL)
allocate(AREG, GEN_REG = {IMMEDIATE,1})
"xor a"
"add a,%[1.1]"
"jp m,2f"
"jr nz,1f"
"xor a"
"add a,%[1.2]"
"jr z,2f"
"1:"
"dec %[b.2]"
"2:"
erase(%[b]) | %[b] | |
teq | GEN_REG | remove(ALL)
allocate(AREG,GEN_REG = {IMMEDIATE,0})
"ld a,%[1.1]"
"or a"
"jp m,1f"
"xor %[1.2]"
"jr nz,1f"
"inc %[b.2]"
"1:"
erase(%[b]) | %[b] | |
tne | GEN_REG | remove(ALL)
allocate(AREG, GEN_REG = {IMMEDIATE,0})
"ld a,%[1.1]"
"or %[1.2]"
"jr z,1f"
"inc %[b.2]"
"1:"
erase(%[b]) | %[b] | |
tge | GEN_REG | remove(ALL)
allocate(GEN_REG = {IMMEDIATE,0})
"bit 7,%[1.1]"
"jr nz,1f"
"inc %[a.2]"
"1:"
erase(%[a]) | %[a] | |
tgt | GEN_REG | remove(ALL)
allocate(AREG, GEN_REG = {IMMEDIATE,0})
"xor a"
"add a,%[1.1]"
"jp m,2f"
"jr nz,1f"
"xor a"
"add a,%[1.2]"
"jr z,2f"
"1:"
"inc %[b.2]"
"2:"
erase(%[b]) | %[b] | |
/* G R O U P XIII : B R A N C H */
bra | | remove(ALL)
"jp $1" | | |
blt | GEN_REG GEN_REG | remove(ALL) allocate(AREG)
"ld a,%[2.2]"
"sub %[1.2]"
"ld a,%[2.1]"
"sbc a,%[1.1]"
"jp m,$1" | | |
ble | GEN_REG GEN_REG | remove(ALL) allocate(AREG)
"ld a,%[2.2]"
"sub %[1.2]"
"ld a,%[2.1]"
"sbc a,%[1.1]"
"jp m,$1"
"jr nz,1f"
"ld a,%[2.2]"
"cp %[1.2]"
"jr z,$1"
"1:" | | |
beq | GEN_REG GEN_REG | remove(ALL) allocate(AREG)
"ld a,%[2.2]"
"sub %[1.2]"
"jr nz,1f"
"ld a,%[2.1]"
"sbc a,%[1.1]"
"jr z,$1"
"1:" | | |
bne | GEN_REG GEN_REG | remove(ALL) allocate(AREG)
"ld a,%[2.2]"
"sub %[1.2]"
"jr nz,$1"
"ld a,%[2.1]"
"sbc a,%[1.1]"
"jr nz,$1"
erase(AA) | | |
bge | GEN_REG GEN_REG | remove(ALL) allocate(AREG)
"ld a,%[2.2]"
"sub %[1.2]"
"ld a,%[2.1]"
"sbc a,%[1.1]"
"jp p,$1" | | |
bgt | GEN_REG GEN_REG_SCR | remove(ALL) allocate(AREG)
"ld a,%[2.2]"
"sub %[1.2]"
"ld %[2.2],a"
"ld a,%[2.1]"
"sbc a,%[1.1]"
"jp m,1f"
"jr nz,$1"
"xor a"
"cp %[2.2]"
"jr nz,$1"
"1:"
erase(%[2]) | | |
zlt | GEN_REG | remove(ALL) "bit 7,%[1.1]"
"jr nz,$1" | | |
zle | GEN_REG | remove(ALL) allocate(AREG)
"xor a"
"add a,%[1.1]"
"jp m,$1"
"jr nz,1f"
"xor a"
"add a,%[1.2]"
"jr z,$1"
"1:" | | |
zeq | GEN_REG | remove(ALL) allocate(AREG)
"ld a,%[1.1]"
"or %[1.2]"
"jr z,$1" | | |
zne | GEN_REG | remove(ALL) allocate(AREG)
"ld a,%[1.1]"
"or %[1.2]"
"jr nz,$1" | | |
zge | GEN_REG | remove(ALL) "bit 7,%[1.1]"
"jr z,$1" | | |
zgt | GEN_REG | remove(ALL) allocate(AREG)
"xor a"
"add a,%[1.1]"
"jp m,1f"
"jr nz,$1"
"xor a"
"add a,%[1.2]"
"jr nz,$1"
"1:" | | |
/* G R O U P XIV : P R O C E D U R E C A L L S */
cai | HL_REG | remove(ALL)
allocate( GEN_REG )
"ld %[a],1f"
"push %[a]"
"jp (hl)"
"1:"
| | |
cal | | remove(ALL)
allocate(ALL_REG)
"call $1"
| | |
lfr $1 == 2 | | remove(ALL)
"push de"
| | |
lfr $1 == 4 | STACK | "push de"
"push bc" | | |
lfr | | remove(ALL)
move({IMMEDIATE,$1},DE)
"call .lfr"
| | |
ret $1 == 0 | STACK |
remove(ALL)
allocate(HL_REG,LOCALBASE)
"push iy"
"pop hl"
"ld sp,hl"
"pop iy"
"ret" | | |
ret $1 == 2 | STACK | remove(ALL)
allocate(HL_REG,DE_REG,LOCALBASE)
"pop de"
"push iy"
"pop hl"
"ld sp,hl"
"pop iy"
"ret" | | |
ret $1 == 4 | STACK |
remove(ALL)
allocate(BC_REG, DE_REG, HL_REG, LOCALBASE)
"pop bc"
"pop de"
"push iy"
"pop hl"
"ld sp,hl"
"pop iy"
"ret" | | |
ret | | remove(ALL)
move({IMMEDIATE,$1},DE)
"call .ret"
erase(BC) | | |
/* G R O U P XV : M I S C E L L A N E O U S */
asp $1 == 0 | | | | |
asp $1 != 0 | STACK | remove(ALL) allocate(HL_REG)
move({IMMEDIATE,$1} , HL)
"add hl,sp"
"ld sp,hl"
erase(HL) | | |
ass $1 == 2 | HL_REG_SCR STACK |
remove(ALL)
"add hl,sp"
"ld sp,hl"
erase(HL) | | |
blm $1 == 0 | | | | |
blm $1 > 0 |DE_REG_SCR HL_REG_SCR |
allocate(BC_REG = {IMMEDIATE,$1} )
"ldir"
erase(HL)
erase(BC)
erase(DE) | | |
bls $1 == 2 | BC_REG_SCR DE_REG_SCR HL_REG_SCR |
remove(MEM_ALL)
"ldir"
erase(HL)
erase(BC)
erase(DE) | | |
csa $1 == 2 | STACK | allocate(ALL_REG)
"jr .csa" | | |
csb $1 == 2 | STACK | allocate(ALL_REG)
"jr .csb" | | |
dus $1 == 2 | BC_REG_SCR | remove(MEM_ALL) allocate(HL_REG,DE_REG)
move({IMMEDIATE,0} , HL)
"add hl,sp"
"ld d,h"
"ld e,l" /* destination */
"sbc hl,bc" /* source */
"ld sp,hl"
"ex de,hl"
"ldir"
erase(HL)
erase(BC) | | |
dup $1 == 2 | ANY | | %[1] %[1] | |
dup $1 == 4 | ANY ANY | | %[2] %[1] %[2] %[1] | |
dup $1 == 6 | ANY ANY ANY | | %[3] %[2] %[1] %[3] %[2] %[1] | |
dup $1 > 6 | STACK | allocate(HL_REG,BC_REG,DE_REG)
move({IMMEDIATE,0} , HL)
"add hl,sp"
"ld d,h"
"ld e,l" /* destination */
move ({IMMEDIATE,$1},BC) /* count */
"sbc hl,bc" /* source */
"ld sp,hl"
"ex de,hl"
"ldir"
erase(HL)
erase(BC) | | |
lor $1 == 0 | | "push iy" | | |
fil | | allocate(HL_REG)
move({EXTENDED_ADDR,$1},HL)
"ld (hol0+4),hl"
erase(HL) | | |
lor $1 == 1 | STACK | allocate(HL_REG)
move({IMMEDIATE,0} , HL)
"add hl,sp"
erase(HL) | HL | |
lor $1 == 2 | STACK | | {EXTENDED,".reghp"} | |
exg $1 == 2 | ANY ANY | | %[1] %[2] | |
exg | STACK | remove(MEM_ALL)
allocate(HL_REG)
move({IMMEDIATE,$1},HL)
"push hl"
"call .exg" | | |
gto | | remove(ALL)
allocate(ALL_REG)
move({EXTENDED_ADDR,$1},HL)
"call .gto"
| | |
lim | | | {EXTENDED,"ignmask"} | |
lin | | remove(ALL) allocate(HL_REG)
move({IMMEDIATE,$1},HL)
"ld (hol0),hl"
erase(HL) | | |
lni | | allocate(HL_REG)
"ld hl,hol0"
"inc (hl)"
erase(HL) | | |
lpb | | | | adp 4 |
nop | STACK |
#ifdef DEBUG
allocate(ALL_REG)
"call .nop"
#endif
| | |
rck $1 == 2 | STACK | allocate(ALL_REG)
"call .rck"
| | |
rtt | | | | ret 0|
sig | HL_REG_SCR |
"ld (trapproc),hl"
"ld hl,trapproc"
| HL | |
sim | HL_REG | remove(MEM_ALL)
"pop hl"
"ld (ignmask),hl" | | |
str $1 == 0 | | "pop iy" | | |
str $1 == 1 | STACK | allocate(HL_REG)
"pop hl"
"ld sp,hl" | | |
str $1 == 2 | STACK | allocate(ALL_REG)
"call .strhp"
| | |
trp| | remove(ALL)
allocate(ALL_REG)
"call .trp.z" | | |
mon | | remove(MEM_ALL)
"call .mon" | | |
/* C O E R C I O N S */
/* from 4 bytes to 2 */
/* to a register */
| ANYTOK | allocate(ANY_REG)
move(%[1],%[a]) | %[a] | |
| STACK | allocate(ANY_REG)
"pop %[a]" | %[a] | |
| LOCAL_ADDR | allocate(ANY_REG)
move(LB,%[a])
"add %[a],%[1]"
| %[a] | |
| IMMEDIATE | allocate(ANY_REG)
move(%[1],%[a])
| %[a] | |
/* between registers */
| GEN_REG | allocate(GEN_REG)
"ld %[a.1],%[1.1]"
"ld %[a.2],%[1.2]" | %[a] | |
| LOCALBASE | allocate(ANY_REG)
"push iy"
"pop %[a]" | %[a] | |
/***********
** MOVES **
***********/
MOVES:
(ANY,ANY,"ld %[2],%[1]")
(ANY1,ANY1,"ld %[2],%[1]")
/************
* STACKS *
************/
STACKS:
(ANY_REG, , "push %[1]" )
(MEM_ALL, ANY_REG, move(%[1],%[a])
"push %[a]" )
(MEM_ALL, , "push hl"
move(%[1],HL)
"ex (sp),hl" )
Reference in a new issue View git blame Copy permalink