448 lines
10 KiB
Plaintext
448 lines
10 KiB
Plaintext
REGISTERS
|
|
|
|
/* Registers are allocated top down; the order here is odd in order to make
|
|
* sure that non-volatile registers get allocated from r31 (or f31) down.
|
|
*
|
|
* Attributes ending in an exclamation mark must match exactly when copying
|
|
* a register into another register (e.g. for eviction).
|
|
*/
|
|
|
|
r12 "12" bytes4! int! volatile;
|
|
r11 "11" bytes4! int! volatile;
|
|
r10 "10" bytes4! int! volatile;
|
|
r9 "9" bytes4! int! volatile;
|
|
r8 "8" bytes4! int! volatile;
|
|
r7 "7" bytes4! int! volatile;
|
|
r6 "6" bytes4! int! volatile;
|
|
r5 "5" bytes4! int! volatile;
|
|
r4 "4" bytes4! int! volatile;
|
|
r3 "3" bytes4! int! ret volatile;
|
|
|
|
r31 "31" bytes4! int!;
|
|
r30 "30" bytes4! int!;
|
|
r29 "29" bytes4! int!;
|
|
r28 "28" bytes4! int!;
|
|
r27 "27" bytes4! int!;
|
|
r26 "26" bytes4! int!;
|
|
r25 "25" bytes4! int!;
|
|
r24 "24" bytes4! int!;
|
|
r23 "23" bytes4! int!;
|
|
r22 "22" bytes4! int!;
|
|
r21 "21" bytes4! int!;
|
|
r20 "20" bytes4! int!;
|
|
r19 "19" bytes4! int!;
|
|
r18 "18" bytes4! int!;
|
|
r17 "17" bytes4! int!;
|
|
r16 "16" bytes4! int!;
|
|
r15 "15" bytes4! int!;
|
|
r14 "14" bytes4! int!;
|
|
|
|
f14 "14" bytes4! float! volatile;
|
|
f13 "13" bytes4! float! volatile;
|
|
f12 "12" bytes4! float! volatile;
|
|
f11 "11" bytes4! float! volatile;
|
|
f10 "10" bytes4! float! volatile;
|
|
f9 "9" bytes4! float! volatile;
|
|
f8 "8" bytes4! float! volatile;
|
|
f7 "7" bytes4! float! volatile;
|
|
f6 "6" bytes4! float! volatile;
|
|
f5 "5" bytes4! float! volatile;
|
|
f4 "4" bytes4! float! volatile;
|
|
f3 "3" bytes4! float! volatile;
|
|
f2 "2" bytes4! float! volatile;
|
|
f1 "1" bytes4! float! volatile;
|
|
f0 "0" bytes4! float! volatile;
|
|
|
|
f31 "31" bytes4! float!;
|
|
f30 "30" bytes4! float!;
|
|
f29 "29" bytes4! float!;
|
|
f28 "28" bytes4! float!;
|
|
f27 "27" bytes4! float!;
|
|
f26 "26" bytes4! float!;
|
|
f25 "25" bytes4! float!;
|
|
f24 "24" bytes4! float!;
|
|
f23 "23" bytes4! float!;
|
|
f22 "22" bytes4! float!;
|
|
f21 "21" bytes4! float!;
|
|
f20 "20" bytes4! float!;
|
|
f19 "19" bytes4! float!;
|
|
f18 "18" bytes4! float!;
|
|
f17 "17" bytes4! float!;
|
|
f16 "16" bytes4! float!;
|
|
f15 "15" bytes4! float!;
|
|
|
|
cr0 "cr0" cr!;
|
|
|
|
|
|
DECLARATIONS
|
|
|
|
cr;
|
|
ubyteX; /* bottom 8 bits valid, the rest undefined */
|
|
ubyte0; /* bottom 8 bits valid, the rest 0 */
|
|
ushortX; /* bottom 16 bits valid, the rest undefined */
|
|
ushort0; /* bottom 16 bits valid, the rest 0 */
|
|
|
|
address fragment;
|
|
|
|
|
|
PATTERNS
|
|
|
|
/* Special */
|
|
|
|
PAIR(BLOCK4, BLOCK4);
|
|
|
|
|
|
|
|
/* Miscellaneous special things */
|
|
|
|
PUSH4(in:(int)reg)
|
|
emit "stwu %in, -4(sp)"
|
|
cost 4;
|
|
|
|
out:(int)reg = POP4
|
|
emit "lwz %out, 0(sp)"
|
|
emit "addi sp, sp, 4"
|
|
cost 8;
|
|
|
|
out:(float)reg = POPF4
|
|
emit "lfs %out, 0(sp)"
|
|
emit "addi sp, sp, 4"
|
|
cost 8;
|
|
|
|
RET
|
|
emit "ret"
|
|
cost 4;
|
|
|
|
SETRET4(in:(ret)reg)
|
|
emit "! setret4"
|
|
cost 4;
|
|
|
|
(ret)reg = GETRET4
|
|
emit "! getret4"
|
|
cost 1;
|
|
|
|
STACKADJUST4(delta:CONST4)
|
|
when signed_constant(%delta, 16)
|
|
emit "addi sp, sp, $delta"
|
|
cost 4;
|
|
|
|
|
|
|
|
/* Memory operations */
|
|
|
|
/* Stores */
|
|
|
|
STORE4(addr:address, value:(int)reg)
|
|
emit "stw %value, %addr"
|
|
cost 4;
|
|
|
|
STORE2(addr:address, value:(int)ushortX)
|
|
emit "sth %value, %addr"
|
|
cost 4;
|
|
|
|
STORE2(ADD4(left:(int)reg, right:(int)reg), value:(int)ushortX)
|
|
emit "sthx %value, %left, %right"
|
|
cost 4;
|
|
|
|
STORE1(addr:address, value:(int)ubyteX)
|
|
emit "stb %value, %addr"
|
|
cost 4;
|
|
|
|
STORE1(ADD4(left:(int)reg, right:(int)reg), value:(int)ubyteX)
|
|
emit "stbx %value, %left, %right"
|
|
cost 4;
|
|
|
|
/* Loads */
|
|
|
|
out:(int)reg = LOAD4(addr:address)
|
|
emit "lwz %out, %addr"
|
|
cost 4;
|
|
|
|
out:(int)ushort0 = LOAD2(addr:address)
|
|
emit "lhz %out, %addr"
|
|
cost 4;
|
|
|
|
out:(int)ubyte0 = LOAD1(addr:address)
|
|
emit "lbz %out, %addr"
|
|
cost 4;
|
|
|
|
/* ubyte intrinsics */
|
|
|
|
out:(int)ubyteX = in:(int)ubyte0
|
|
with %out == %in
|
|
emit "! ubyte0 -> ubyteX"
|
|
cost 1;
|
|
|
|
out:(int)ubyte0 = in:(int)ubyteX
|
|
emit "andi %out, %in, 0xff ! ubyteX -> ubyte0"
|
|
cost 4;
|
|
|
|
out:(int)reg = in:(int)ubyte0
|
|
with %out == %in
|
|
emit "! ubyte0 -> reg"
|
|
cost 4;
|
|
|
|
out:(int)ubyteX = in:(int)reg
|
|
with %out == %in
|
|
emit "! reg -> ubyteX"
|
|
cost 1;
|
|
|
|
/* ushort intrinsics */
|
|
|
|
out:(int)ushortX = in:(int)ushort0
|
|
with %out == %in
|
|
emit "! ushort0 -> ushortX"
|
|
cost 1;
|
|
|
|
out:(int)ushort0 = in:(int)ushortX
|
|
emit "andi %out, %in, 0xff ! ushortX -> ushort0"
|
|
cost 4;
|
|
|
|
out:(int)reg = in:(int)ushort0
|
|
with %out == %in
|
|
emit "! ushort0 -> reg"
|
|
cost 4;
|
|
|
|
out:(int)ushortX = in:(int)reg
|
|
with %out == %in
|
|
emit "! reg -> ushortX"
|
|
cost 1;
|
|
|
|
/* byte conversions */
|
|
|
|
out:(int)ubyte0 = CIU14(in:(int)ubyte0)
|
|
with %out == %in
|
|
emit "! CIU14(ubyte0) -> ubyte0"
|
|
cost 1;
|
|
|
|
out:(int)ubyte0 = CIU41(in:(int)ubyte0)
|
|
with %out == %in
|
|
emit "! CIU41(ubyte0) -> ubyte0"
|
|
cost 1;
|
|
|
|
out:(int)ubyteX = CIU41(in:(int)ubyteX)
|
|
with %out == %in
|
|
emit "! CIU41(ubyteX) -> ubyteX"
|
|
cost 1;
|
|
|
|
out:(int)reg = CII14(in:(int)ubyte0)
|
|
with %out == %in
|
|
emit "! CII14(ubyte0) -> reg"
|
|
cost 4;
|
|
|
|
out:(int)reg = CII14(in:(int)ubyteX)
|
|
emit "extsb %out, %in ! CII14(ubyteX) -> reg"
|
|
cost 4;
|
|
|
|
/* short conversions */
|
|
|
|
out:(int)ushort0 = CIU24(in:(int)ushort0)
|
|
with %out == %in
|
|
emit "! CIU24(ushort0) -> ushort0"
|
|
cost 1;
|
|
|
|
out:(int)ushort0 = CIU42(in:(int)ushort0)
|
|
with %out == %in
|
|
emit "! CIU42(ushort0) -> ushort0"
|
|
cost 1;
|
|
|
|
out:(int)ushortX = CIU42(in:(int)ushortX)
|
|
with %out == %in
|
|
emit "! CIU42(ushortX) -> ushortX"
|
|
cost 1;
|
|
|
|
out:(int)reg = CII24(in:(int)ushort0)
|
|
with %out == %in
|
|
emit "! CII24(ushort0) -> reg"
|
|
cost 4;
|
|
|
|
out:(int)reg = CII24(in:(int)ushortX)
|
|
emit "extsh %out, %in"
|
|
cost 4;
|
|
|
|
|
|
/* Locals */
|
|
|
|
out:(int)reg = in:LOCAL4
|
|
emit "addi %out, fp, #$in"
|
|
cost 4;
|
|
|
|
address = in:LOCAL4
|
|
emit "$in(fp)";
|
|
|
|
|
|
|
|
/* Memory addressing modes */
|
|
|
|
address = ADD4(addr:(int)reg, offset:CONST4)
|
|
when signed_constant(%offset, 16)
|
|
emit "$offset(%addr)";
|
|
|
|
address = addr:(int)reg
|
|
emit "0(%addr)";
|
|
|
|
|
|
|
|
/* Branches */
|
|
|
|
JUMP(addr:BLOCK4)
|
|
emit "b $addr"
|
|
cost 4;
|
|
|
|
CJUMPEQ(value:(cr)cr, PAIR(true:BLOCK4, false:BLOCK4))
|
|
emit "bc IFTRUE, EQ, $true"
|
|
emit "b $false"
|
|
cost 8;
|
|
|
|
CJUMPLE(value:(cr)cr, PAIR(true:BLOCK4, false:BLOCK4))
|
|
emit "bc IFTRUE, LE, $true"
|
|
emit "b $false"
|
|
cost 8;
|
|
|
|
CJUMPLT(value:(cr)cr, PAIR(true:BLOCK4, false:BLOCK4))
|
|
emit "bc IFTRUE, LT, $true"
|
|
emit "b $false"
|
|
cost 8;
|
|
|
|
CALL(dest:LABEL4)
|
|
with corrupted(volatile)
|
|
emit "bl $dest"
|
|
cost 4;
|
|
|
|
CALL(dest:(int)reg)
|
|
with corrupted(volatile)
|
|
emit "mtspr ctr, %dest"
|
|
emit "bcctrl ALWAYS, 0, 0"
|
|
cost 8;
|
|
|
|
JUMP(dest:LABEL4)
|
|
emit "b $dest"
|
|
cost 4;
|
|
|
|
|
|
|
|
/* Comparisons */
|
|
|
|
cr:(cr)cr = COMPARES4(left:(int)reg, right:(int)reg)
|
|
emit "cmp %cr, 0, %left, %right"
|
|
cost 4;
|
|
|
|
cr:(cr)cr = COMPARES4(left:(int)reg, right:CONST4)
|
|
when signed_constant(%right, 16)
|
|
emit "cmpi %cr, 0, %left, $right"
|
|
cost 4;
|
|
|
|
cr:(cr)cr = COMPAREU4(left:(int)reg, right:(int)reg)
|
|
emit "cmpl %cr, 0, %left, %right"
|
|
cost 4;
|
|
|
|
cr:(cr)cr = COMPAREU4(left:(int)reg, right:CONST4)
|
|
when signed_constant(%right, 16)
|
|
emit "cmpli %cr, 0, %left, $right"
|
|
cost 4;
|
|
|
|
cr:(cr)cr = COMPARES4(COMPARES4(left:(int)reg, right:(int)reg), result:CONST4)
|
|
when specific_constant(%result, 0)
|
|
emit "cmp %cr, 0, %left, %right"
|
|
cost 4;
|
|
|
|
cr:(cr)cr = COMPARES4(COMPARES4(left:(int)reg, right:CONST4), result:CONST4)
|
|
when specific_constant(%result, 0)
|
|
when signed_constant(%right, 16)
|
|
emit "cmpi %cr, 0, %left, $right"
|
|
cost 4;
|
|
|
|
cr:(cr)cr = COMPARES4(COMPAREU4(left:(int)reg, right:(int)reg), result:CONST4)
|
|
when specific_constant(%result, 0)
|
|
emit "cmpl %cr, 0, %left, %right"
|
|
cost 4;
|
|
|
|
|
|
|
|
/* Conversions */
|
|
|
|
out:(int)reg = CIU44(in:(int)reg)
|
|
emit "mr %out, %in ! ciu44"
|
|
cost 4;
|
|
|
|
out:(int)reg = CUI44(in:(int)reg)
|
|
emit "mr %out, %in ! cui44"
|
|
cost 4;
|
|
|
|
|
|
/* ALU operations */
|
|
|
|
out:(int)reg = ADD4(left:(int)reg, right:(int)reg)
|
|
emit "add %out, %left, %right"
|
|
cost 4;
|
|
|
|
out:(int)reg = ADD4(left:(int)reg, right:CONST4)
|
|
when signed_constant(%right, 16)
|
|
emit "addi %out, %left, $right"
|
|
cost 4;
|
|
|
|
out:(int)reg = SUB4(left:(int)reg, right:(int)reg)
|
|
emit "subf %out, %left, %right"
|
|
cost 4;
|
|
|
|
out:(int)reg = SUB4(left:(int)reg, right:CONST4)
|
|
emit "addi %out, %left, -($right)"
|
|
cost 4;
|
|
|
|
out:(int)reg = MUL4(left:(int)reg, right:(int)reg)
|
|
emit "mullw %out, %right, %left"
|
|
cost 4;
|
|
|
|
out:(int)reg = MOD4(left:(int)reg, right:(int)reg)
|
|
emit "divw %out, %left, %right"
|
|
emit "mullw %out, %out, %right"
|
|
emit "subf %out, %out, %left"
|
|
cost 12;
|
|
|
|
out:(int)reg = DIV4(left:(int)reg, right:(int)reg)
|
|
emit "divw %out, %left, %right"
|
|
cost 4;
|
|
|
|
out:(int)reg = ASL4(left:(int)reg, right:(int)reg)
|
|
emit "slw %out, %left, %right"
|
|
cost 4;
|
|
|
|
out:(int)reg = NEG4(left:(int)reg)
|
|
emit "neg %out, %left"
|
|
cost 4;
|
|
|
|
out:(int)reg = EOR4(left:(int)reg, right:(int)reg)
|
|
emit "xor %out, %right, %left"
|
|
cost 4;
|
|
|
|
out:(int)reg = value:LABEL4
|
|
emit "la %out, $value"
|
|
cost 4;
|
|
|
|
out:(int)reg = value:BLOCK4
|
|
emit "la %out, $value"
|
|
cost 4;
|
|
|
|
out:(int)reg = value:CONST4
|
|
emit "li %out, $value"
|
|
cost 8;
|
|
|
|
|
|
/* FPU operations */
|
|
|
|
out:(float)reg = value:CONSTF4
|
|
emit "lfs %out, address-containing-$value"
|
|
cost 8;
|
|
|
|
out:(float)reg = ADDF4(left:(float)reg, right:(float)reg)
|
|
emit "fadds %out, %left, %right"
|
|
cost 4;
|
|
|
|
out:(float)reg = SUBF4(left:(float)reg, right:(float)reg)
|
|
emit "fsubs %out, %left, %right"
|
|
cost 4;
|
|
|
|
|
|
/* vim: set sw=4 ts=4 expandtab : */
|
|
|