mirror of
https://github.com/KolibriOS/kolibrios.git
synced 2024-12-11 09:34:09 +03:00
2430 lines
51 KiB
Plaintext
2430 lines
51 KiB
Plaintext
(*
|
|
BSD 2-Clause License
|
|
|
|
Copyright (c) 2019-2020, Anton Krotov
|
|
All rights reserved.
|
|
*)
|
|
|
|
MODULE THUMB;
|
|
|
|
IMPORT PROG, LISTS, CHL := CHUNKLISTS, BIN, REG, IL, C := CONSOLE,
|
|
UTILS, WR := WRITER, HEX, ERRORS, TARGETS;
|
|
|
|
|
|
CONST
|
|
|
|
R0 = 0; R1 = 1; R2 = 2; R3 = 3; R4 = 4;
|
|
|
|
SP = 13; LR = 14; PC = 15;
|
|
|
|
ACC = R0;
|
|
|
|
je = 0; jne = 1; jnb = 2; jb = 3; jge = 10; jl = 11; jg = 12; jle = 13;
|
|
|
|
inf = 7F800000H;
|
|
|
|
STM32_minROM* = 16; STM32_maxROM* = 65536;
|
|
STM32_minRAM* = 4; STM32_maxRAM* = 65536;
|
|
|
|
maxIVT* = 1023;
|
|
|
|
|
|
TYPE
|
|
|
|
COMMAND = IL.COMMAND;
|
|
|
|
ANYCODE = POINTER TO RECORD (LISTS.ITEM)
|
|
|
|
offset: INTEGER
|
|
|
|
END;
|
|
|
|
CODE = POINTER TO RECORD (ANYCODE)
|
|
|
|
code: INTEGER
|
|
|
|
END;
|
|
|
|
LABEL = POINTER TO RECORD (ANYCODE)
|
|
|
|
label: INTEGER
|
|
|
|
END;
|
|
|
|
JUMP = POINTER TO RECORD (ANYCODE)
|
|
|
|
label, diff, len, cond: INTEGER;
|
|
short: BOOLEAN
|
|
|
|
END;
|
|
|
|
JMP = POINTER TO RECORD (JUMP)
|
|
|
|
END;
|
|
|
|
JCC = POINTER TO RECORD (JUMP)
|
|
|
|
END;
|
|
|
|
CBXZ = POINTER TO RECORD (JUMP)
|
|
|
|
reg: INTEGER
|
|
|
|
END;
|
|
|
|
CALL = POINTER TO RECORD (JUMP)
|
|
|
|
END;
|
|
|
|
RELOC = POINTER TO RECORD (ANYCODE)
|
|
|
|
reg, rel, value: INTEGER
|
|
|
|
END;
|
|
|
|
RELOCCODE = ARRAY 7 OF INTEGER;
|
|
|
|
|
|
VAR
|
|
|
|
R: REG.REGS;
|
|
|
|
tcount: INTEGER;
|
|
|
|
CodeList: LISTS.LIST;
|
|
|
|
program: BIN.PROGRAM;
|
|
|
|
StkCount: INTEGER;
|
|
|
|
Target: RECORD
|
|
FlashAdr,
|
|
SRAMAdr,
|
|
IVTLen,
|
|
MinStack,
|
|
Reserved: INTEGER;
|
|
InstrSet: RECORD thumb2, it, cbxz, sdiv: BOOLEAN END
|
|
END;
|
|
|
|
IVT: ARRAY maxIVT + 1 OF INTEGER;
|
|
|
|
sdivProc, trap, genTrap, entry, emptyProc, int0, genInt: INTEGER;
|
|
|
|
|
|
PROCEDURE Code (code: INTEGER);
|
|
VAR
|
|
c: CODE;
|
|
|
|
BEGIN
|
|
NEW(c);
|
|
c.code := code;
|
|
LISTS.push(CodeList, c)
|
|
END Code;
|
|
|
|
|
|
PROCEDURE Label (label: INTEGER);
|
|
VAR
|
|
L: LABEL;
|
|
|
|
BEGIN
|
|
NEW(L);
|
|
L.label := label;
|
|
LISTS.push(CodeList, L)
|
|
END Label;
|
|
|
|
|
|
PROCEDURE jcc (cond, label: INTEGER);
|
|
VAR
|
|
j: JCC;
|
|
|
|
BEGIN
|
|
NEW(j);
|
|
j.label := label;
|
|
j.cond := cond;
|
|
j.short := FALSE;
|
|
j.len := 3;
|
|
LISTS.push(CodeList, j)
|
|
END jcc;
|
|
|
|
|
|
PROCEDURE cbxz (cond, reg, label: INTEGER);
|
|
VAR
|
|
j: CBXZ;
|
|
|
|
BEGIN
|
|
NEW(j);
|
|
j.label := label;
|
|
j.cond := cond;
|
|
j.reg := reg;
|
|
j.short := FALSE;
|
|
j.len := 4;
|
|
LISTS.push(CodeList, j)
|
|
END cbxz;
|
|
|
|
|
|
PROCEDURE jmp (label: INTEGER);
|
|
VAR
|
|
j: JMP;
|
|
|
|
BEGIN
|
|
NEW(j);
|
|
j.label := label;
|
|
j.short := FALSE;
|
|
j.len := 2;
|
|
LISTS.push(CodeList, j)
|
|
END jmp;
|
|
|
|
|
|
PROCEDURE call (label: INTEGER);
|
|
VAR
|
|
c: CALL;
|
|
|
|
BEGIN
|
|
NEW(c);
|
|
c.label := label;
|
|
c.short := FALSE;
|
|
c.len := 2;
|
|
LISTS.push(CodeList, c)
|
|
END call;
|
|
|
|
|
|
PROCEDURE reloc (reg, rel, value: INTEGER);
|
|
VAR
|
|
r: RELOC;
|
|
|
|
BEGIN
|
|
NEW(r);
|
|
r.reg := reg;
|
|
r.rel := rel;
|
|
r.value := value;
|
|
LISTS.push(CodeList, r)
|
|
END reloc;
|
|
|
|
|
|
PROCEDURE NewLabel (): INTEGER;
|
|
BEGIN
|
|
BIN.NewLabel(program)
|
|
RETURN IL.NewLabel()
|
|
END NewLabel;
|
|
|
|
|
|
PROCEDURE range (x, n: INTEGER): BOOLEAN;
|
|
RETURN (0 <= x) & (x < LSL(1, n))
|
|
END range;
|
|
|
|
|
|
PROCEDURE srange (x, n: INTEGER): BOOLEAN;
|
|
RETURN (-LSL(1, n - 1) <= x) & (x < LSL(1, n - 1))
|
|
END srange;
|
|
|
|
|
|
PROCEDURE gen1 (op, imm, rs, rd: INTEGER);
|
|
BEGIN
|
|
ASSERT(op IN {0..2});
|
|
ASSERT(range(imm, 5));
|
|
ASSERT(range(rs, 3));
|
|
ASSERT(range(rd, 3));
|
|
Code(LSL(op, 11) + LSL(imm, 6) + LSL(rs, 3) + rd)
|
|
END gen1;
|
|
|
|
|
|
PROCEDURE gen2 (i, op: BOOLEAN; imm, rs, rd: INTEGER);
|
|
BEGIN
|
|
ASSERT(range(imm, 3));
|
|
ASSERT(range(rs, 3));
|
|
ASSERT(range(rd, 3));
|
|
Code(1800H + LSL(ORD(i), 10) + LSL(ORD(op), 9) + LSL(imm, 6) + LSL(rs, 3) + rd)
|
|
END gen2;
|
|
|
|
|
|
PROCEDURE gen3 (op, rd, imm: INTEGER);
|
|
BEGIN
|
|
ASSERT(range(op, 2));
|
|
ASSERT(range(rd, 3));
|
|
ASSERT(range(imm, 8));
|
|
Code(2000H + LSL(op, 11) + LSL(rd, 8) + imm)
|
|
END gen3;
|
|
|
|
|
|
PROCEDURE gen4 (op, rs, rd: INTEGER);
|
|
BEGIN
|
|
ASSERT(range(op, 4));
|
|
ASSERT(range(rs, 3));
|
|
ASSERT(range(rd, 3));
|
|
Code(4000H + LSL(op, 6) + LSL(rs, 3) + rd)
|
|
END gen4;
|
|
|
|
|
|
PROCEDURE gen5 (op: INTEGER; h1, h2: BOOLEAN; rs, rd: INTEGER);
|
|
BEGIN
|
|
ASSERT(range(op, 2));
|
|
ASSERT(range(rs, 3));
|
|
ASSERT(range(rd, 3));
|
|
Code(4400H + LSL(op, 8) + LSL(ORD(h1), 7) + LSL(ORD(h2), 6) + LSL(rs, 3) + rd)
|
|
END gen5;
|
|
|
|
|
|
PROCEDURE gen7 (l, b: BOOLEAN; ro, rb, rd: INTEGER);
|
|
BEGIN
|
|
ASSERT(range(ro, 3));
|
|
ASSERT(range(rb, 3));
|
|
ASSERT(range(rd, 3));
|
|
Code(5000H + LSL(ORD(l), 11) + LSL(ORD(b), 10) + LSL(ro, 6) + LSL(rb, 3) + rd)
|
|
END gen7;
|
|
|
|
|
|
PROCEDURE gen8 (h, s: BOOLEAN; ro, rb, rd: INTEGER);
|
|
BEGIN
|
|
ASSERT(range(ro, 3));
|
|
ASSERT(range(rb, 3));
|
|
ASSERT(range(rd, 3));
|
|
Code(5200H + LSL(ORD(h), 11) + LSL(ORD(s), 10) + LSL(ro, 6) + LSL(rb, 3) + rd)
|
|
END gen8;
|
|
|
|
|
|
PROCEDURE gen9 (b, l: BOOLEAN; imm, rb, rd: INTEGER);
|
|
BEGIN
|
|
ASSERT(range(imm, 5));
|
|
ASSERT(range(rb, 3));
|
|
ASSERT(range(rd, 3));
|
|
Code(6000H + LSL(ORD(b), 12) + LSL(ORD(l), 11) + LSL(imm, 6) + LSL(rb, 3) + rd)
|
|
END gen9;
|
|
|
|
|
|
PROCEDURE gen10 (l: BOOLEAN; imm, rb, rd: INTEGER);
|
|
BEGIN
|
|
ASSERT(range(imm, 5));
|
|
ASSERT(range(rb, 3));
|
|
ASSERT(range(rd, 3));
|
|
Code(8000H + LSL(ORD(l), 11) + LSL(imm, 6) + LSL(rb, 3) + rd)
|
|
END gen10;
|
|
|
|
|
|
PROCEDURE gen11 (l: BOOLEAN; rd, imm: INTEGER);
|
|
BEGIN
|
|
ASSERT(range(rd, 3));
|
|
ASSERT(range(imm, 8));
|
|
Code(9000H + LSL(ORD(l), 11) + LSL(rd, 8) + imm)
|
|
END gen11;
|
|
|
|
|
|
PROCEDURE gen12 (sp: BOOLEAN; rd, imm: INTEGER);
|
|
BEGIN
|
|
ASSERT(range(rd, 3));
|
|
ASSERT(range(imm, 8));
|
|
Code(0A000H + LSL(ORD(sp), 11) + LSL(rd, 8) + imm)
|
|
END gen12;
|
|
|
|
|
|
PROCEDURE gen14 (l, r: BOOLEAN; rlist: SET);
|
|
VAR
|
|
i, n: INTEGER;
|
|
|
|
BEGIN
|
|
ASSERT(range(ORD(rlist), 8));
|
|
|
|
n := ORD(r);
|
|
FOR i := 0 TO 7 DO
|
|
IF i IN rlist THEN
|
|
INC(n)
|
|
END
|
|
END;
|
|
|
|
IF l THEN
|
|
n := -n
|
|
END;
|
|
|
|
INC(StkCount, n);
|
|
|
|
Code(0B400H + LSL(ORD(l), 11) + LSL(ORD(r), 8) + ORD(rlist))
|
|
END gen14;
|
|
|
|
|
|
PROCEDURE split16 (imm16: INTEGER; VAR imm4, imm1, imm3, imm8: INTEGER);
|
|
BEGIN
|
|
ASSERT(range(imm16, 16));
|
|
imm8 := imm16 MOD 256;
|
|
imm4 := LSR(imm16, 12);
|
|
imm3 := LSR(imm16, 8) MOD 8;
|
|
imm1 := LSR(imm16, 11) MOD 2;
|
|
END split16;
|
|
|
|
|
|
PROCEDURE LslImm (r, imm5: INTEGER);
|
|
BEGIN
|
|
gen1(0, imm5, r, r)
|
|
END LslImm;
|
|
|
|
|
|
PROCEDURE LsrImm (r, imm5: INTEGER);
|
|
BEGIN
|
|
gen1(1, imm5, r, r)
|
|
END LsrImm;
|
|
|
|
|
|
PROCEDURE AsrImm (r, imm5: INTEGER);
|
|
BEGIN
|
|
gen1(2, imm5, r, r)
|
|
END AsrImm;
|
|
|
|
|
|
PROCEDURE AddReg (rd, rs, rn: INTEGER);
|
|
BEGIN
|
|
gen2(FALSE, FALSE, rn, rs, rd)
|
|
END AddReg;
|
|
|
|
|
|
PROCEDURE SubReg (rd, rs, rn: INTEGER);
|
|
BEGIN
|
|
gen2(FALSE, TRUE, rn, rs, rd)
|
|
END SubReg;
|
|
|
|
|
|
PROCEDURE AddImm8 (rd, imm8: INTEGER);
|
|
BEGIN
|
|
IF imm8 # 0 THEN
|
|
gen3(2, rd, imm8)
|
|
END
|
|
END AddImm8;
|
|
|
|
|
|
PROCEDURE SubImm8 (rd, imm8: INTEGER);
|
|
BEGIN
|
|
IF imm8 # 0 THEN
|
|
gen3(3, rd, imm8)
|
|
END
|
|
END SubImm8;
|
|
|
|
|
|
PROCEDURE AddSubImm12 (r, imm12: INTEGER; sub: BOOLEAN);
|
|
VAR
|
|
imm4, imm1, imm3, imm8: INTEGER;
|
|
|
|
BEGIN
|
|
split16(imm12, imm4, imm1, imm3, imm8);
|
|
Code(0F200H + LSL(imm1, 10) + r + 0A0H * ORD(sub)); (* addw/subw r, r, imm12 *)
|
|
Code(LSL(imm3, 12) + LSL(r, 8) + imm8)
|
|
END AddSubImm12;
|
|
|
|
|
|
PROCEDURE MovImm8 (rd, imm8: INTEGER);
|
|
BEGIN
|
|
gen3(0, rd, imm8)
|
|
END MovImm8;
|
|
|
|
|
|
PROCEDURE CmpImm8 (rd, imm8: INTEGER);
|
|
BEGIN
|
|
gen3(1, rd, imm8)
|
|
END CmpImm8;
|
|
|
|
|
|
PROCEDURE Neg (r: INTEGER);
|
|
BEGIN
|
|
gen4(9, r, r)
|
|
END Neg;
|
|
|
|
|
|
PROCEDURE Mul (rd, rs: INTEGER);
|
|
BEGIN
|
|
gen4(13, rs, rd)
|
|
END Mul;
|
|
|
|
|
|
PROCEDURE Str32 (rs, rb: INTEGER);
|
|
BEGIN
|
|
gen9(FALSE, FALSE, 0, rb, rs)
|
|
END Str32;
|
|
|
|
|
|
PROCEDURE Ldr32 (rd, rb: INTEGER);
|
|
BEGIN
|
|
gen9(FALSE, TRUE, 0, rb, rd)
|
|
END Ldr32;
|
|
|
|
|
|
PROCEDURE Str16 (rs, rb: INTEGER);
|
|
BEGIN
|
|
gen10(FALSE, 0, rb, rs)
|
|
END Str16;
|
|
|
|
|
|
PROCEDURE Ldr16 (rd, rb: INTEGER);
|
|
BEGIN
|
|
gen10(TRUE, 0, rb, rd)
|
|
END Ldr16;
|
|
|
|
|
|
PROCEDURE Str8 (rs, rb: INTEGER);
|
|
BEGIN
|
|
gen9(TRUE, FALSE, 0, rb, rs)
|
|
END Str8;
|
|
|
|
|
|
PROCEDURE Ldr8 (rd, rb: INTEGER);
|
|
BEGIN
|
|
gen9(TRUE, TRUE, 0, rb, rd)
|
|
END Ldr8;
|
|
|
|
|
|
PROCEDURE Cmp (r1, r2: INTEGER);
|
|
BEGIN
|
|
gen4(10, r2, r1)
|
|
END Cmp;
|
|
|
|
|
|
PROCEDURE Tst (r: INTEGER);
|
|
BEGIN
|
|
gen3(1, r, 0) (* cmp r, #0 *)
|
|
END Tst;
|
|
|
|
|
|
PROCEDURE LdrSp (r, offset: INTEGER);
|
|
BEGIN
|
|
gen11(TRUE, r, offset)
|
|
END LdrSp;
|
|
|
|
|
|
PROCEDURE MovImm32 (r, imm32: INTEGER);
|
|
BEGIN
|
|
MovImm8(r, LSR(imm32, 24) MOD 256);
|
|
LslImm(r, 8);
|
|
AddImm8(r, LSR(imm32, 16) MOD 256);
|
|
LslImm(r, 8);
|
|
AddImm8(r, LSR(imm32, 8) MOD 256);
|
|
LslImm(r, 8);
|
|
AddImm8(r, imm32 MOD 256)
|
|
END MovImm32;
|
|
|
|
|
|
PROCEDURE low (x: INTEGER): INTEGER;
|
|
RETURN x MOD 65536
|
|
END low;
|
|
|
|
|
|
PROCEDURE high (x: INTEGER): INTEGER;
|
|
RETURN (x DIV 65536) MOD 65536
|
|
END high;
|
|
|
|
|
|
PROCEDURE movwt (r, imm16, t: INTEGER);
|
|
VAR
|
|
imm1, imm3, imm4, imm8: INTEGER;
|
|
|
|
BEGIN
|
|
ASSERT(range(r, 3));
|
|
ASSERT(range(imm16, 16));
|
|
ASSERT(range(t, 1));
|
|
split16(imm16, imm4, imm1, imm3, imm8);
|
|
Code(0F240H + imm1 * 1024 + t * 128 + imm4);
|
|
Code(imm3 * 4096 + r * 256 + imm8);
|
|
END movwt;
|
|
|
|
|
|
PROCEDURE inv0 (cond: INTEGER): INTEGER;
|
|
RETURN ORD(BITS(cond) / {0})
|
|
END inv0;
|
|
|
|
|
|
PROCEDURE fixup (CodeAdr, DataAdr, BssAdr: INTEGER);
|
|
VAR
|
|
code: ANYCODE;
|
|
count: INTEGER;
|
|
shorted: BOOLEAN;
|
|
jump: JUMP;
|
|
|
|
first, second: INTEGER;
|
|
|
|
reloc, i, diff, len: INTEGER;
|
|
|
|
RelocCode: RELOCCODE;
|
|
|
|
|
|
PROCEDURE genjcc (cond, offset: INTEGER): INTEGER;
|
|
BEGIN
|
|
ASSERT(range(cond, 4));
|
|
ASSERT(srange(offset, 8))
|
|
RETURN 0D000H + cond * 256 + offset MOD 256
|
|
END genjcc;
|
|
|
|
|
|
PROCEDURE genjmp (offset: INTEGER): INTEGER;
|
|
BEGIN
|
|
ASSERT(srange(offset, 11))
|
|
RETURN 0E000H + offset MOD 2048
|
|
END genjmp;
|
|
|
|
|
|
PROCEDURE genlongjmp (offset: INTEGER; VAR first, second: INTEGER);
|
|
BEGIN
|
|
ASSERT(srange(offset, 22));
|
|
first := 0F000H + ASR(offset, 11) MOD 2048;
|
|
second := 0F800H + offset MOD 2048
|
|
END genlongjmp;
|
|
|
|
|
|
PROCEDURE movwt (r, imm16, t: INTEGER; VAR code: RELOCCODE);
|
|
VAR
|
|
imm1, imm3, imm4, imm8: INTEGER;
|
|
|
|
BEGIN
|
|
split16(imm16, imm4, imm1, imm3, imm8);
|
|
code[t * 2] := 0F240H + imm1 * 1024 + t * 128 + imm4;
|
|
code[t * 2 + 1] := imm3 * 4096 + r * 256 + imm8
|
|
END movwt;
|
|
|
|
|
|
PROCEDURE genmovimm32 (r, value: INTEGER; VAR code: RELOCCODE);
|
|
BEGIN
|
|
IF Target.InstrSet.thumb2 THEN
|
|
movwt(r, low(value), 0, code);
|
|
movwt(r, high(value), 1, code)
|
|
ELSE
|
|
code[0] := 2000H + r * 256 + UTILS.Byte(value, 3); (* mov r, #imm8 *)
|
|
code[1] := 0200H + r * 9; (* lsl r, r, #8 *)
|
|
code[2] := 3000H + r * 256 + UTILS.Byte(value, 2); (* add r, #imm8 *)
|
|
code[3] := code[1]; (* lsl r, r, #8 *)
|
|
code[4] := 3000H + r * 256 + UTILS.Byte(value, 1); (* add r, #imm8 *)
|
|
code[5] := code[1]; (* lsl r, r, #8 *)
|
|
code[6] := 3000H + r * 256 + UTILS.Byte(value, 0) (* add r, #imm8 *)
|
|
END
|
|
END genmovimm32;
|
|
|
|
|
|
PROCEDURE PutCode (code: INTEGER);
|
|
BEGIN
|
|
BIN.PutCode16LE(program, code)
|
|
END PutCode;
|
|
|
|
|
|
PROCEDURE genbc (code: JUMP);
|
|
VAR
|
|
first, second: INTEGER;
|
|
|
|
BEGIN
|
|
CASE code.len OF
|
|
|1: PutCode(genjcc(code.cond, code.diff))
|
|
|2: PutCode(genjcc(inv0(code.cond), 0));
|
|
PutCode(genjmp(code.diff))
|
|
|3: PutCode(genjcc(inv0(code.cond), 1));
|
|
genlongjmp(code.diff, first, second);
|
|
PutCode(first);
|
|
PutCode(second)
|
|
END
|
|
END genbc;
|
|
|
|
|
|
PROCEDURE SetIV (idx, label, CodeAdr: INTEGER);
|
|
VAR
|
|
l, h: ANYCODE;
|
|
|
|
BEGIN
|
|
l := CodeList.first(ANYCODE);
|
|
h := l.next(ANYCODE);
|
|
WHILE idx > 0 DO
|
|
l := h.next(ANYCODE);
|
|
h := l.next(ANYCODE);
|
|
DEC(idx)
|
|
END;
|
|
label := BIN.GetLabel(program, label) * 2 + CodeAdr + 1;
|
|
l(CODE).code := low(label);
|
|
h(CODE).code := high(label)
|
|
END SetIV;
|
|
|
|
|
|
BEGIN
|
|
|
|
REPEAT
|
|
|
|
shorted := FALSE;
|
|
count := 0;
|
|
|
|
code := CodeList.first(ANYCODE);
|
|
WHILE code # NIL DO
|
|
code.offset := count;
|
|
|
|
CASE code OF
|
|
|CODE: INC(count)
|
|
|LABEL: BIN.SetLabel(program, code.label, count)
|
|
|JUMP: INC(count, code.len); code.offset := count + ORD(code.short)
|
|
|RELOC: INC(count, 7 - ORD(Target.InstrSet.thumb2) * 3 + code.rel MOD 2)
|
|
END;
|
|
|
|
code := code.next(ANYCODE)
|
|
END;
|
|
|
|
code := CodeList.first(ANYCODE);
|
|
WHILE code # NIL DO
|
|
|
|
IF code IS JUMP THEN
|
|
jump := code(JUMP);
|
|
jump.diff := BIN.GetLabel(program, jump.label) - jump.offset;
|
|
len := jump.len;
|
|
diff := jump.diff;
|
|
CASE jump OF
|
|
|JMP:
|
|
IF (len = 2) & srange(diff, 11) THEN
|
|
len := 1
|
|
END
|
|
|
|
|JCC:
|
|
CASE len OF
|
|
|1:
|
|
|2: IF srange(diff, 8) THEN DEC(len) END
|
|
|3: IF srange(diff, 11) THEN DEC(len) END
|
|
END
|
|
|
|
|CBXZ:
|
|
CASE len OF
|
|
|1:
|
|
|2: IF range(diff, 6) THEN DEC(len) END
|
|
|3: IF srange(diff, 8) THEN DEC(len) END
|
|
|4: IF srange(diff, 11) THEN DEC(len) END
|
|
END
|
|
|
|
|CALL:
|
|
|
|
END;
|
|
IF len # jump.len THEN
|
|
jump.len := len;
|
|
jump.short := TRUE;
|
|
shorted := TRUE
|
|
END
|
|
END;
|
|
|
|
code := code.next(ANYCODE)
|
|
END
|
|
|
|
UNTIL ~shorted;
|
|
|
|
FOR i := 1 TO Target.IVTLen - 1 DO
|
|
SetIV(i, IVT[i], CodeAdr)
|
|
END;
|
|
|
|
code := CodeList.first(ANYCODE);
|
|
WHILE code # NIL DO
|
|
|
|
CASE code OF
|
|
|
|
|CODE: BIN.PutCode16LE(program, code.code)
|
|
|
|
|LABEL:
|
|
|
|
|JMP:
|
|
IF code.len = 1 THEN
|
|
PutCode(genjmp(code.diff))
|
|
ELSE
|
|
genlongjmp(code.diff, first, second);
|
|
PutCode(first);
|
|
PutCode(second)
|
|
END
|
|
|
|
|JCC: genbc(code)
|
|
|
|
|CBXZ:
|
|
IF code.len > 1 THEN
|
|
PutCode(2800H + code.reg * 256); (* cmp code.reg, #0 *)
|
|
DEC(code.len);
|
|
genbc(code)
|
|
ELSE
|
|
(* cb(n)z code.reg, L *)
|
|
PutCode(0B100H + 800H * ORD(code.cond = jne) + 200H * ORD(code.diff >= 32) + (code.diff MOD 32) * 8 + code.reg)
|
|
END
|
|
|
|
|CALL:
|
|
genlongjmp(code.diff, first, second);
|
|
PutCode(first);
|
|
PutCode(second)
|
|
|
|
|RELOC:
|
|
CASE code.rel OF
|
|
|BIN.RCODE, BIN.PICCODE: reloc := BIN.GetLabel(program, code.value) * 2 + CodeAdr
|
|
|BIN.RDATA, BIN.PICDATA: reloc := code.value + DataAdr
|
|
|BIN.RBSS, BIN.PICBSS: reloc := code.value + BssAdr
|
|
END;
|
|
IF code.rel IN {BIN.PICCODE, BIN.PICDATA, BIN.PICBSS} THEN
|
|
DEC(reloc, CodeAdr + 2 * (code.offset - 3 * ORD(Target.InstrSet.thumb2) + 9))
|
|
END;
|
|
genmovimm32(code.reg, reloc, RelocCode);
|
|
FOR i := 0 TO 6 - 3 * ORD(Target.InstrSet.thumb2) DO
|
|
PutCode(RelocCode[i])
|
|
END;
|
|
IF code.rel IN {BIN.PICCODE, BIN.PICDATA, BIN.PICBSS} THEN
|
|
PutCode(4478H + code.reg) (* add code.reg, PC *)
|
|
END
|
|
END;
|
|
|
|
code := code.next(ANYCODE)
|
|
END
|
|
|
|
END fixup;
|
|
|
|
|
|
PROCEDURE push (r: INTEGER);
|
|
BEGIN
|
|
gen14(FALSE, FALSE, {r})
|
|
END push;
|
|
|
|
|
|
PROCEDURE pop (r: INTEGER);
|
|
BEGIN
|
|
gen14(TRUE, FALSE, {r})
|
|
END pop;
|
|
|
|
|
|
PROCEDURE mov (r1, r2: INTEGER);
|
|
BEGIN
|
|
IF (r1 < 8) & (r2 < 8) THEN
|
|
gen1(0, 0, r2, r1)
|
|
ELSE
|
|
gen5(2, r1 >= 8, r2 >= 8, r2 MOD 8, r1 MOD 8)
|
|
END
|
|
END mov;
|
|
|
|
|
|
PROCEDURE xchg (r1, r2: INTEGER);
|
|
BEGIN
|
|
push(r1); push(r2);
|
|
pop(r1); pop(r2)
|
|
END xchg;
|
|
|
|
|
|
PROCEDURE drop;
|
|
BEGIN
|
|
REG.Drop(R)
|
|
END drop;
|
|
|
|
|
|
PROCEDURE GetAnyReg (): INTEGER;
|
|
RETURN REG.GetAnyReg(R)
|
|
END GetAnyReg;
|
|
|
|
|
|
PROCEDURE UnOp (VAR r: INTEGER);
|
|
BEGIN
|
|
REG.UnOp(R, r)
|
|
END UnOp;
|
|
|
|
|
|
PROCEDURE BinOp (VAR r1, r2: INTEGER);
|
|
BEGIN
|
|
REG.BinOp(R, r1, r2)
|
|
END BinOp;
|
|
|
|
|
|
PROCEDURE PushAll (NumberOfParameters: INTEGER);
|
|
BEGIN
|
|
REG.PushAll(R);
|
|
DEC(R.pushed, NumberOfParameters)
|
|
END PushAll;
|
|
|
|
|
|
PROCEDURE cond (op: INTEGER): INTEGER;
|
|
VAR
|
|
res: INTEGER;
|
|
|
|
BEGIN
|
|
CASE op OF
|
|
|IL.opGT, IL.opGTC: res := jg
|
|
|IL.opGE, IL.opGEC: res := jge
|
|
|IL.opLT, IL.opLTC: res := jl
|
|
|IL.opLE, IL.opLEC: res := jle
|
|
|IL.opEQ, IL.opEQC: res := je
|
|
|IL.opNE, IL.opNEC: res := jne
|
|
END
|
|
|
|
RETURN res
|
|
END cond;
|
|
|
|
|
|
PROCEDURE GetRegA;
|
|
BEGIN
|
|
ASSERT(REG.GetReg(R, ACC))
|
|
END GetRegA;
|
|
|
|
|
|
PROCEDURE MovConst (r, c: INTEGER);
|
|
BEGIN
|
|
IF (0 <= c) & (c <= 255) THEN
|
|
MovImm8(r, c)
|
|
ELSIF (-255 <= c) & (c < 0) THEN
|
|
MovImm8(r, -c);
|
|
Neg(r)
|
|
ELSIF UTILS.Log2(c) >= 0 THEN
|
|
MovImm8(r, 1);
|
|
LslImm(r, UTILS.Log2(c))
|
|
ELSIF c = UTILS.min32 THEN
|
|
MovImm8(r, 1);
|
|
LslImm(r, 31)
|
|
ELSE
|
|
IF Target.InstrSet.thumb2 THEN
|
|
movwt(r, low(c), 0);
|
|
IF (c < 0) OR (c > 65535) THEN
|
|
movwt(r, high(c), 1)
|
|
END
|
|
ELSE
|
|
MovImm32(r, c)
|
|
END
|
|
END
|
|
END MovConst;
|
|
|
|
|
|
PROCEDURE CmpConst (r, c: INTEGER);
|
|
VAR
|
|
r2: INTEGER;
|
|
|
|
BEGIN
|
|
IF (0 <= c) & (c <= 255) THEN
|
|
CmpImm8(r, c)
|
|
ELSE
|
|
r2 := GetAnyReg();
|
|
ASSERT(r2 # r);
|
|
MovConst(r2, c);
|
|
Cmp(r, r2);
|
|
drop
|
|
END
|
|
END CmpConst;
|
|
|
|
|
|
PROCEDURE LocalOffset (offset: INTEGER): INTEGER;
|
|
RETURN offset + StkCount - ORD(offset > 0)
|
|
END LocalOffset;
|
|
|
|
|
|
PROCEDURE SetCC (cc, r: INTEGER);
|
|
VAR
|
|
L1, L2: INTEGER;
|
|
|
|
BEGIN
|
|
IF Target.InstrSet.it THEN
|
|
Code(0BF00H + cc * 16 + ((cc + 1) MOD 2) * 8 + 4); (* ite cc *)
|
|
MovConst(r, 1);
|
|
MovConst(r, 0)
|
|
ELSE
|
|
L1 := NewLabel();
|
|
L2 := NewLabel();
|
|
jcc(cc, L1);
|
|
MovConst(r, 0);
|
|
jmp(L2);
|
|
Label(L1);
|
|
MovConst(r, 1);
|
|
Label(L2)
|
|
END
|
|
END SetCC;
|
|
|
|
|
|
PROCEDURE PushConst (n: INTEGER);
|
|
VAR
|
|
r: INTEGER;
|
|
|
|
BEGIN
|
|
r := GetAnyReg();
|
|
MovConst(r, n);
|
|
push(r);
|
|
drop
|
|
END PushConst;
|
|
|
|
|
|
PROCEDURE AddConst (r, n: INTEGER);
|
|
VAR
|
|
r2: INTEGER;
|
|
|
|
BEGIN
|
|
IF n # 0 THEN
|
|
IF (-255 <= n) & (n <= 255) THEN
|
|
IF n > 0 THEN
|
|
AddImm8(r, n)
|
|
ELSE
|
|
SubImm8(r, -n)
|
|
END
|
|
ELSIF Target.InstrSet.thumb2 & (-4095 <= n) & (n <= 4095) THEN
|
|
IF n > 0 THEN
|
|
AddSubImm12(r, n, FALSE)
|
|
ELSE
|
|
AddSubImm12(r, -n, TRUE)
|
|
END
|
|
ELSE
|
|
r2 := GetAnyReg();
|
|
ASSERT(r2 # r);
|
|
IF n > 0 THEN
|
|
MovConst(r2, n);
|
|
AddReg(r, r, r2)
|
|
ELSE
|
|
MovConst(r2, -n);
|
|
SubReg(r, r, r2)
|
|
END;
|
|
drop
|
|
END
|
|
END
|
|
END AddConst;
|
|
|
|
|
|
PROCEDURE AddHH (r1, r2: INTEGER);
|
|
BEGIN
|
|
ASSERT((r1 >= 8) OR (r2 >= 8));
|
|
gen5(0, r1 >= 8, r2 >= 8, r2 MOD 8, r1 MOD 8)
|
|
END AddHH;
|
|
|
|
|
|
PROCEDURE AddSP (n: INTEGER);
|
|
BEGIN
|
|
IF n > 0 THEN
|
|
IF n < 127 THEN
|
|
Code(0B000H + n) (* add sp, n*4 *)
|
|
ELSE
|
|
ASSERT(R2 IN R.regs);
|
|
MovConst(R2, n * 4);
|
|
AddHH(SP, R2)
|
|
END;
|
|
DEC(StkCount, n)
|
|
END
|
|
END AddSP;
|
|
|
|
|
|
PROCEDURE cbz (r, label: INTEGER);
|
|
BEGIN
|
|
IF Target.InstrSet.cbxz THEN
|
|
cbxz(je, r, label)
|
|
ELSE
|
|
Tst(r);
|
|
jcc(je, label)
|
|
END
|
|
END cbz;
|
|
|
|
|
|
PROCEDURE cbnz (r, label: INTEGER);
|
|
BEGIN
|
|
IF Target.InstrSet.cbxz THEN
|
|
cbxz(jne, r, label)
|
|
ELSE
|
|
Tst(r);
|
|
jcc(jne, label)
|
|
END
|
|
END cbnz;
|
|
|
|
|
|
PROCEDURE Shift (op, r1, r2: INTEGER);
|
|
VAR
|
|
L: INTEGER;
|
|
|
|
BEGIN
|
|
LslImm(r2, 27);
|
|
LsrImm(r2, 27);
|
|
L := NewLabel();
|
|
cbz(r2, L);
|
|
CASE op OF
|
|
|IL.opLSL, IL.opLSL1: gen4(2, r2, r1)
|
|
|IL.opLSR, IL.opLSR1: gen4(3, r2, r1)
|
|
|IL.opASR, IL.opASR1: gen4(4, r2, r1)
|
|
|IL.opROR, IL.opROR1: gen4(7, r2, r1)
|
|
END;
|
|
Label(L)
|
|
END Shift;
|
|
|
|
|
|
PROCEDURE LocAdr (offs: INTEGER);
|
|
VAR
|
|
r1, n: INTEGER;
|
|
|
|
BEGIN
|
|
r1 := GetAnyReg();
|
|
n := LocalOffset(offs);
|
|
IF n <= 255 THEN
|
|
gen12(TRUE, r1, n)
|
|
ELSE
|
|
MovConst(r1, n * 4);
|
|
AddHH(r1, SP)
|
|
END
|
|
END LocAdr;
|
|
|
|
|
|
PROCEDURE CallRTL (proc, par: INTEGER);
|
|
BEGIN
|
|
call(IL.codes.rtl[proc]);
|
|
AddSP(par)
|
|
END CallRTL;
|
|
|
|
|
|
PROCEDURE divmod;
|
|
BEGIN
|
|
call(sdivProc);
|
|
AddSP(2)
|
|
END divmod;
|
|
|
|
|
|
PROCEDURE translate (pic, stroffs: INTEGER);
|
|
VAR
|
|
cmd, next: COMMAND;
|
|
opcode, param1, param2: INTEGER;
|
|
|
|
r1, r2, r3: INTEGER;
|
|
|
|
a, n, cc, L, L2: INTEGER;
|
|
|
|
BEGIN
|
|
cmd := IL.codes.commands.first(COMMAND);
|
|
|
|
WHILE cmd # NIL DO
|
|
|
|
param1 := cmd.param1;
|
|
param2 := cmd.param2;
|
|
opcode := cmd.opcode;
|
|
|
|
CASE opcode OF
|
|
|
|
|IL.opJMP:
|
|
jmp(param1)
|
|
|
|
|IL.opLABEL:
|
|
Label(param1)
|
|
|
|
|IL.opHANDLER:
|
|
IF param2 = 0 THEN
|
|
int0 := param1
|
|
ELSIF param2 = 1 THEN
|
|
trap := param1
|
|
ELSE
|
|
IVT[param2] := param1
|
|
END
|
|
|
|
|IL.opCALL:
|
|
call(param1)
|
|
|
|
|IL.opCALLP:
|
|
UnOp(r1);
|
|
AddImm8(r1, 1);
|
|
gen5(3, TRUE, FALSE, r1, 0); (* blx r1 *)
|
|
drop;
|
|
ASSERT(R.top = -1)
|
|
|
|
|IL.opENTER:
|
|
ASSERT(R.top = -1);
|
|
|
|
Label(param1);
|
|
|
|
gen14(FALSE, TRUE, {}); (* push LR *)
|
|
|
|
n := param2;
|
|
IF n >= 5 THEN
|
|
MovConst(ACC, 0);
|
|
MovConst(R2, n);
|
|
L := NewLabel();
|
|
Label(L);
|
|
push(ACC);
|
|
SubImm8(R2, 1);
|
|
Tst(R2);
|
|
jcc(jne, L)
|
|
ELSIF n > 0 THEN
|
|
MovConst(ACC, 0);
|
|
WHILE n > 0 DO
|
|
push(ACC);
|
|
DEC(n)
|
|
END
|
|
END;
|
|
StkCount := param2
|
|
|
|
|IL.opLEAVE, IL.opLEAVER, IL.opLEAVEF:
|
|
IF opcode # IL.opLEAVE THEN
|
|
UnOp(r1);
|
|
IF r1 # ACC THEN
|
|
GetRegA;
|
|
ASSERT(REG.Exchange(R, r1, ACC));
|
|
drop
|
|
END;
|
|
drop
|
|
END;
|
|
|
|
ASSERT(R.top = -1);
|
|
ASSERT(StkCount = param1);
|
|
|
|
AddSP(param1);
|
|
gen14(TRUE, TRUE, {}) (* pop PC *)
|
|
|
|
|IL.opLEAVEC:
|
|
gen5(3, FALSE, TRUE, 6, 0) (* bx LR *)
|
|
|
|
|IL.opPRECALL:
|
|
PushAll(0)
|
|
|
|
|IL.opPARAM:
|
|
n := param2;
|
|
IF n = 1 THEN
|
|
UnOp(r1);
|
|
push(r1);
|
|
drop
|
|
ELSE
|
|
ASSERT(R.top + 1 <= n);
|
|
PushAll(n)
|
|
END
|
|
|
|
|IL.opCLEANUP:
|
|
AddSP(param2)
|
|
|
|
|IL.opRES, IL.opRESF:
|
|
ASSERT(R.top = -1);
|
|
GetRegA
|
|
|
|
|IL.opPUSHC:
|
|
PushConst(param2)
|
|
|
|
|IL.opONERR:
|
|
MovConst(R0, param2);
|
|
push(R0);
|
|
DEC(StkCount);
|
|
jmp(param1)
|
|
|
|
|IL.opERR:
|
|
call(genTrap)
|
|
|
|
|IL.opNOP:
|
|
|
|
|IL.opSADR:
|
|
reloc(GetAnyReg(), BIN.RDATA + pic, stroffs + param2)
|
|
|
|
|IL.opGADR:
|
|
reloc(GetAnyReg(), BIN.RBSS + pic, param2)
|
|
|
|
|IL.opLADR:
|
|
LocAdr(param2)
|
|
|
|
|IL.opGLOAD32:
|
|
r1 := GetAnyReg();
|
|
reloc(r1, BIN.RBSS + pic, param2);
|
|
Ldr32(r1, r1)
|
|
|
|
|IL.opGLOAD16:
|
|
r1 := GetAnyReg();
|
|
reloc(r1, BIN.RBSS + pic, param2);
|
|
Ldr16(r1, r1)
|
|
|
|
|IL.opGLOAD8:
|
|
r1 := GetAnyReg();
|
|
reloc(r1, BIN.RBSS + pic, param2);
|
|
Ldr8(r1, r1)
|
|
|
|
|IL.opLLOAD32, IL.opVADR, IL.opVLOAD32:
|
|
r1 := GetAnyReg();
|
|
n := LocalOffset(param2);
|
|
IF n <= 255 THEN
|
|
LdrSp(r1, n)
|
|
ELSE
|
|
drop;
|
|
LocAdr(param2);
|
|
UnOp(r1);
|
|
Ldr32(r1, r1)
|
|
END;
|
|
IF opcode = IL.opVLOAD32 THEN
|
|
Ldr32(r1, r1)
|
|
END
|
|
|
|
|IL.opLLOAD16:
|
|
LocAdr(param2);
|
|
UnOp(r1);
|
|
Ldr16(r1, r1)
|
|
|
|
|IL.opLLOAD8:
|
|
LocAdr(param2);
|
|
UnOp(r1);
|
|
Ldr8(r1, r1)
|
|
|
|
|IL.opLOAD32, IL.opLOADF:
|
|
UnOp(r1);
|
|
Ldr32(r1, r1)
|
|
|
|
|IL.opLOAD16:
|
|
UnOp(r1);
|
|
Ldr16(r1, r1)
|
|
|
|
|IL.opLOAD8:
|
|
UnOp(r1);
|
|
Ldr8(r1, r1)
|
|
|
|
|IL.opVLOAD16:
|
|
LocAdr(param2);
|
|
UnOp(r1);
|
|
Ldr32(r1, r1);
|
|
Ldr16(r1, r1)
|
|
|
|
|IL.opVLOAD8:
|
|
LocAdr(param2);
|
|
UnOp(r1);
|
|
Ldr32(r1, r1);
|
|
Ldr8(r1, r1)
|
|
|
|
|IL.opSBOOL:
|
|
BinOp(r2, r1);
|
|
Tst(r2);
|
|
SetCC(jne, r2);
|
|
Str8(r2, r1);
|
|
drop;
|
|
drop
|
|
|
|
|IL.opSBOOLC:
|
|
UnOp(r1);
|
|
r2 := GetAnyReg();
|
|
MovConst(r2, ORD(param2 # 0));
|
|
Str8(r2, r1);
|
|
drop;
|
|
drop
|
|
|
|
|IL.opSAVEC:
|
|
UnOp(r1);
|
|
r2 := GetAnyReg();
|
|
MovConst(r2, param2);
|
|
Str32(r2, r1);
|
|
drop;
|
|
drop
|
|
|
|
|IL.opSAVE16C:
|
|
UnOp(r1);
|
|
r2 := GetAnyReg();
|
|
MovConst(r2, low(param2));
|
|
Str16(r2, r1);
|
|
drop;
|
|
drop
|
|
|
|
|IL.opSAVE8C:
|
|
UnOp(r1);
|
|
r2 := GetAnyReg();
|
|
MovConst(r2, param2 MOD 256);
|
|
Str8(r2, r1);
|
|
drop;
|
|
drop
|
|
|
|
|IL.opSAVE, IL.opSAVE32, IL.opSAVEF:
|
|
BinOp(r2, r1);
|
|
Str32(r2, r1);
|
|
drop;
|
|
drop
|
|
|
|
|IL.opSAVEFI:
|
|
BinOp(r2, r1);
|
|
Str32(r1, r2);
|
|
drop;
|
|
drop
|
|
|
|
|IL.opSAVE16:
|
|
BinOp(r2, r1);
|
|
Str16(r2, r1);
|
|
drop;
|
|
drop
|
|
|
|
|IL.opSAVE8:
|
|
BinOp(r2, r1);
|
|
Str8(r2, r1);
|
|
drop;
|
|
drop
|
|
|
|
|IL.opSAVEP:
|
|
UnOp(r1);
|
|
r2 := GetAnyReg();
|
|
reloc(r2, BIN.RCODE + pic, param2);
|
|
Str32(r2, r1);
|
|
drop;
|
|
drop
|
|
|
|
|IL.opPUSHP:
|
|
reloc(GetAnyReg(), BIN.RCODE + pic, param2)
|
|
|
|
|IL.opEQB, IL.opNEB:
|
|
BinOp(r1, r2);
|
|
drop;
|
|
|
|
L := NewLabel();
|
|
cbz(r1, L);
|
|
MovConst(r1, 1);
|
|
Label(L);
|
|
|
|
L := NewLabel();
|
|
cbz(r2, L);
|
|
MovConst(r2, 1);
|
|
Label(L);
|
|
|
|
Cmp(r1, r2);
|
|
IF opcode = IL.opEQB THEN
|
|
SetCC(je, r1)
|
|
ELSE
|
|
SetCC(jne, r1)
|
|
END
|
|
|
|
|IL.opACC:
|
|
IF (R.top # 0) OR (R.stk[0] # ACC) THEN
|
|
PushAll(0);
|
|
GetRegA;
|
|
pop(ACC);
|
|
DEC(R.pushed)
|
|
END
|
|
|
|
|IL.opDROP:
|
|
UnOp(r1);
|
|
drop
|
|
|
|
|IL.opJNZ:
|
|
UnOp(r1);
|
|
cbnz(r1, param1)
|
|
|
|
|IL.opJZ:
|
|
UnOp(r1);
|
|
cbz(r1, param1)
|
|
|
|
|IL.opJG:
|
|
UnOp(r1);
|
|
Tst(r1);
|
|
jcc(jg, param1)
|
|
|
|
|IL.opJE:
|
|
UnOp(r1);
|
|
cbnz(r1, param1);
|
|
drop
|
|
|
|
|IL.opJNE:
|
|
UnOp(r1);
|
|
cbz(r1, param1);
|
|
drop
|
|
|
|
|IL.opSWITCH:
|
|
UnOp(r1);
|
|
IF param2 = 0 THEN
|
|
r2 := ACC
|
|
ELSE
|
|
r2 := R2
|
|
END;
|
|
IF r1 # r2 THEN
|
|
ASSERT(REG.GetReg(R, r2));
|
|
ASSERT(REG.Exchange(R, r1, r2));
|
|
drop
|
|
END;
|
|
drop
|
|
|
|
|IL.opENDSW:
|
|
|
|
|IL.opCASEL:
|
|
GetRegA;
|
|
CmpConst(ACC, param1);
|
|
jcc(jl, param2);
|
|
drop
|
|
|
|
|IL.opCASER:
|
|
GetRegA;
|
|
CmpConst(ACC, param1);
|
|
jcc(jg, param2);
|
|
drop
|
|
|
|
|IL.opCASELR:
|
|
GetRegA;
|
|
CmpConst(ACC, param1);
|
|
jcc(jl, param2);
|
|
jcc(jg, cmd.param3);
|
|
drop
|
|
|
|
|IL.opCODE:
|
|
Code(param2)
|
|
|
|
|IL.opEQ..IL.opGE,
|
|
IL.opEQC..IL.opGEC:
|
|
IF (IL.opEQ <= opcode) & (opcode <= IL.opGE) THEN
|
|
BinOp(r1, r2);
|
|
Cmp(r1, r2);
|
|
drop
|
|
ELSE
|
|
UnOp(r1);
|
|
CmpConst(r1, param2)
|
|
END;
|
|
|
|
drop;
|
|
cc := cond(opcode);
|
|
next := cmd.next(COMMAND);
|
|
|
|
IF next.opcode = IL.opJE THEN
|
|
jcc(cc, next.param1);
|
|
cmd := next
|
|
ELSIF next.opcode = IL.opJNE THEN
|
|
jcc(inv0(cc), next.param1);
|
|
cmd := next
|
|
ELSE
|
|
SetCC(cc, GetAnyReg())
|
|
END
|
|
|
|
|IL.opINCC:
|
|
UnOp(r1);
|
|
r2 := GetAnyReg();
|
|
Ldr32(r2, r1);
|
|
AddConst(r2, param2);
|
|
Str32(r2, r1);
|
|
drop;
|
|
drop
|
|
|
|
|IL.opINCCB, IL.opDECCB:
|
|
IF opcode = IL.opDECCB THEN
|
|
param2 := -param2
|
|
END;
|
|
UnOp(r1);
|
|
r2 := GetAnyReg();
|
|
Ldr8(r2, r1);
|
|
AddConst(r2, param2);
|
|
Str8(r2, r1);
|
|
drop;
|
|
drop
|
|
|
|
|IL.opUMINUS:
|
|
UnOp(r1);
|
|
Neg(r1)
|
|
|
|
|IL.opADD:
|
|
BinOp(r1, r2);
|
|
CASE cmd.next(COMMAND).opcode OF
|
|
|IL.opLOAD32, IL.opLOADF:
|
|
gen7(TRUE, FALSE, r2, r1, r1); (* ldr r1, [r1, r2] *)
|
|
cmd := cmd.next(COMMAND)
|
|
|IL.opLOAD8:
|
|
gen7(TRUE, TRUE, r2, r1, r1); (* ldrb r1, [r1, r2] *)
|
|
cmd := cmd.next(COMMAND)
|
|
|IL.opLOAD16:
|
|
gen8(TRUE, FALSE, r2, r1, r1); (* ldrh r1, [r1, r2] *)
|
|
cmd := cmd.next(COMMAND)
|
|
ELSE
|
|
AddReg(r1, r1, r2)
|
|
END;
|
|
drop
|
|
|
|
|IL.opADDL, IL.opADDR:
|
|
UnOp(r1);
|
|
AddConst(r1, param2)
|
|
|
|
|IL.opSUB:
|
|
BinOp(r1, r2);
|
|
SubReg(r1, r1, r2);
|
|
drop
|
|
|
|
|IL.opSUBL, IL.opSUBR:
|
|
UnOp(r1);
|
|
AddConst(r1, -param2);
|
|
IF opcode = IL.opSUBL THEN
|
|
Neg(r1)
|
|
END
|
|
|
|
|IL.opMUL:
|
|
BinOp(r1, r2);
|
|
Mul(r1, r2);
|
|
drop
|
|
|
|
|IL.opMULC:
|
|
UnOp(r1);
|
|
|
|
a := param2;
|
|
IF a > 1 THEN
|
|
n := UTILS.Log2(a)
|
|
ELSIF a < -1 THEN
|
|
n := UTILS.Log2(-a)
|
|
ELSE
|
|
n := -1
|
|
END;
|
|
|
|
IF a = 1 THEN
|
|
|
|
ELSIF a = -1 THEN
|
|
Neg(r1)
|
|
ELSIF a = 0 THEN
|
|
MovConst(r1, 0)
|
|
ELSE
|
|
IF n > 0 THEN
|
|
IF a < 0 THEN
|
|
Neg(r1)
|
|
END;
|
|
LslImm(r1, n)
|
|
ELSE
|
|
r2 := GetAnyReg();
|
|
MovConst(r2, a);
|
|
Mul(r1, r2);
|
|
drop
|
|
END
|
|
END
|
|
|
|
|IL.opABS:
|
|
UnOp(r1);
|
|
Tst(r1);
|
|
L := NewLabel();
|
|
jcc(jge, L);
|
|
Neg(r1);
|
|
Label(L)
|
|
|
|
|IL.opNOT:
|
|
UnOp(r1);
|
|
Tst(r1);
|
|
SetCC(je, r1)
|
|
|
|
|IL.opORD:
|
|
UnOp(r1);
|
|
Tst(r1);
|
|
SetCC(jne, r1)
|
|
|
|
|IL.opCHR:
|
|
UnOp(r1);
|
|
Code(0B2C0H + r1 * 9) (* uxtb r1 *)
|
|
|
|
|IL.opWCHR:
|
|
UnOp(r1);
|
|
Code(0B280H + r1 * 9) (* uxth r1 *)
|
|
|
|
|IL.opASR, IL.opROR, IL.opLSL, IL.opLSR:
|
|
BinOp(r1, r2);
|
|
Shift(opcode, r1, r2);
|
|
drop
|
|
|
|
|IL.opASR1, IL.opROR1, IL.opLSL1, IL.opLSR1:
|
|
MovConst(GetAnyReg(), param2);
|
|
BinOp(r2, r1);
|
|
Shift(opcode, r1, r2);
|
|
INCL(R.regs, r2);
|
|
DEC(R.top);
|
|
R.stk[R.top] := r1
|
|
|
|
|IL.opASR2, IL.opROR2, IL.opLSL2, IL.opLSR2:
|
|
n := param2 MOD 32;
|
|
IF n # 0 THEN
|
|
UnOp(r1);
|
|
CASE opcode OF
|
|
|IL.opASR2: AsrImm(r1, n)
|
|
|IL.opROR2: r2 := GetAnyReg(); MovConst(r2, n); Shift(IL.opROR, r1, r2); drop
|
|
|IL.opLSL2: LslImm(r1, n)
|
|
|IL.opLSR2: LsrImm(r1, n)
|
|
END
|
|
END
|
|
|
|
|IL.opCHKBYTE:
|
|
BinOp(r1, r2);
|
|
CmpConst(r1, 256);
|
|
jcc(jb, param1)
|
|
|
|
|IL.opCHKIDX:
|
|
UnOp(r1);
|
|
CmpConst(r1, param2);
|
|
jcc(jb, param1)
|
|
|
|
|IL.opCHKIDX2:
|
|
BinOp(r1, r2);
|
|
IF param2 # -1 THEN
|
|
Cmp(r2, r1);
|
|
jcc(jb, param1)
|
|
END;
|
|
INCL(R.regs, r1);
|
|
DEC(R.top);
|
|
R.stk[R.top] := r2
|
|
|
|
|IL.opLEN:
|
|
n := param2;
|
|
UnOp(r1);
|
|
drop;
|
|
EXCL(R.regs, r1);
|
|
|
|
WHILE n > 0 DO
|
|
UnOp(r2);
|
|
drop;
|
|
DEC(n)
|
|
END;
|
|
|
|
INCL(R.regs, r1);
|
|
ASSERT(REG.GetReg(R, r1))
|
|
|
|
|IL.opLOOP, IL.opENDLOOP:
|
|
|
|
|IL.opINF:
|
|
MovConst(GetAnyReg(), inf)
|
|
|
|
|IL.opPUSHF:
|
|
UnOp(r1);
|
|
push(r1);
|
|
drop
|
|
|
|
|IL.opCONST:
|
|
MovConst(GetAnyReg(), param2)
|
|
|
|
|IL.opEQP, IL.opNEP:
|
|
reloc(GetAnyReg(), BIN.RCODE + pic, param1);
|
|
BinOp(r1, r2);
|
|
Cmp(r1, r2);
|
|
drop;
|
|
IF opcode = IL.opEQP THEN
|
|
SetCC(je, r1)
|
|
ELSE
|
|
SetCC(jne, r1)
|
|
END
|
|
|
|
|IL.opPUSHT:
|
|
UnOp(r1);
|
|
r2 := GetAnyReg();
|
|
mov(r2, r1);
|
|
SubImm8(r2, 4);
|
|
Ldr32(r2, r2)
|
|
|
|
|IL.opGET, IL.opGETC:
|
|
IF opcode = IL.opGET THEN
|
|
BinOp(r1, r2)
|
|
ELSIF opcode = IL.opGETC THEN
|
|
UnOp(r2);
|
|
r1 := GetAnyReg();
|
|
MovConst(r1, param1)
|
|
END;
|
|
drop;
|
|
drop;
|
|
|
|
CASE param2 OF
|
|
|1: Ldr8(r1, r1); Str8(r1, r2)
|
|
|2: Ldr16(r1, r1); Str16(r1, r2)
|
|
|4: Ldr32(r1, r1); Str32(r1, r2)
|
|
END
|
|
|
|
|IL.opINC, IL.opDEC:
|
|
BinOp(r2, r1);
|
|
r3 := GetAnyReg();
|
|
Ldr32(r3, r1);
|
|
IF opcode = IL.opINC THEN
|
|
AddReg(r3, r3, r2)
|
|
ELSE
|
|
SubReg(r3, r3, r2)
|
|
END;
|
|
Str32(r3, r1);
|
|
drop;
|
|
drop;
|
|
drop
|
|
|
|
|IL.opINCB, IL.opDECB:
|
|
BinOp(r2, r1);
|
|
r3 := GetAnyReg();
|
|
Ldr8(r3, r1);
|
|
IF opcode = IL.opINCB THEN
|
|
AddReg(r3, r3, r2)
|
|
ELSE
|
|
SubReg(r3, r3, r2)
|
|
END;
|
|
Str8(r3, r1);
|
|
drop;
|
|
drop;
|
|
drop
|
|
|
|
|IL.opMIN, IL.opMAX:
|
|
BinOp(r1, r2);
|
|
Cmp(r1, r2);
|
|
L := NewLabel();
|
|
IF opcode = IL.opMIN THEN
|
|
cc := jle
|
|
ELSE
|
|
cc := jge
|
|
END;
|
|
jcc(cc, L);
|
|
mov(r1, r2);
|
|
Label(L);
|
|
drop
|
|
|
|
|IL.opMINC, IL.opMAXC:
|
|
UnOp(r1);
|
|
CmpConst(r1, param2);
|
|
L := NewLabel();
|
|
IF opcode = IL.opMINC THEN
|
|
cc := jle
|
|
ELSE
|
|
cc := jge
|
|
END;
|
|
jcc(cc, L);
|
|
MovConst(r1, param2);
|
|
Label(L)
|
|
|
|
|IL.opMULS:
|
|
BinOp(r1, r2);
|
|
gen4(0, r2, r1); (* and r1, r2 *)
|
|
drop
|
|
|
|
|IL.opMULSC:
|
|
MovConst(GetAnyReg(), param2);
|
|
BinOp(r1, r2);
|
|
gen4(0, r2, r1); (* and r1, r2 *)
|
|
drop
|
|
|
|
|IL.opDIVS:
|
|
BinOp(r1, r2);
|
|
gen4(1, r2, r1); (* eor r1, r2 *)
|
|
drop
|
|
|
|
|IL.opDIVSC:
|
|
MovConst(GetAnyReg(), param2);
|
|
BinOp(r1, r2);
|
|
gen4(1, r2, r1); (* eor r1, r2 *)
|
|
drop
|
|
|
|
|IL.opADDS:
|
|
BinOp(r1, r2);
|
|
gen4(12, r2, r1); (* orr r1, r2 *)
|
|
drop
|
|
|
|
|IL.opSUBS:
|
|
BinOp(r1, r2);
|
|
gen4(14, r2, r1); (* bic r1, r2 *)
|
|
drop
|
|
|
|
|IL.opADDSL, IL.opADDSR:
|
|
MovConst(GetAnyReg(), param2);
|
|
BinOp(r1, r2);
|
|
gen4(12, r2, r1); (* orr r1, r2 *)
|
|
drop
|
|
|
|
|IL.opSUBSL:
|
|
MovConst(GetAnyReg(), param2);
|
|
BinOp(r1, r2);
|
|
gen4(14, r1, r2); (* bic r2, r1 *)
|
|
INCL(R.regs, r1);
|
|
DEC(R.top);
|
|
R.stk[R.top] := r2
|
|
|
|
|IL.opSUBSR:
|
|
MovConst(GetAnyReg(), param2);
|
|
BinOp(r1, r2);
|
|
gen4(14, r2, r1); (* bic r1, r2 *)
|
|
drop
|
|
|
|
|IL.opUMINS:
|
|
UnOp(r1);
|
|
gen4(15, r1, r1) (* mvn r1, r1 *)
|
|
|
|
|IL.opINCL, IL.opEXCL:
|
|
BinOp(r1, r2);
|
|
r3 := GetAnyReg();
|
|
MovConst(r3, 1);
|
|
CmpConst(r1, 32);
|
|
L := NewLabel();
|
|
jcc(jnb, L);
|
|
gen4(2, r1, r3); (* lsl r3, r1 *)
|
|
Ldr32(r1, r2);
|
|
IF opcode = IL.opINCL THEN
|
|
gen4(12, r3, r1) (* orr r1, r3 *)
|
|
ELSE
|
|
gen4(14, r3, r1) (* bic r1, r3 *)
|
|
END;
|
|
Str32(r1, r2);
|
|
Label(L);
|
|
drop;
|
|
drop;
|
|
drop
|
|
|
|
|IL.opINCLC, IL.opEXCLC:
|
|
UnOp(r2);
|
|
r1 := GetAnyReg();
|
|
r3 := GetAnyReg();
|
|
MovConst(r3, 1);
|
|
LslImm(r3, param2);
|
|
Ldr32(r1, r2);
|
|
IF opcode = IL.opINCLC THEN
|
|
gen4(12, r3, r1) (* orr r1, r3 *)
|
|
ELSE
|
|
gen4(14, r3, r1) (* bic r1, r3 *)
|
|
END;
|
|
Str32(r1, r2);
|
|
drop;
|
|
drop;
|
|
drop
|
|
|
|
|IL.opLENGTH:
|
|
PushAll(2);
|
|
CallRTL(IL._length, 2);
|
|
GetRegA
|
|
|
|
|IL.opLENGTHW:
|
|
PushAll(2);
|
|
CallRTL(IL._lengthw, 2);
|
|
GetRegA
|
|
|
|
|IL.opSAVES:
|
|
UnOp(r2);
|
|
REG.PushAll_1(R);
|
|
r1 := GetAnyReg();
|
|
reloc(r1, BIN.RDATA + pic, stroffs + param2);
|
|
push(r1);
|
|
drop;
|
|
push(r2);
|
|
drop;
|
|
PushConst(param1);
|
|
CallRTL(IL._move, 3)
|
|
|
|
|IL.opEQS .. IL.opGES:
|
|
PushAll(4);
|
|
PushConst(opcode - IL.opEQS);
|
|
CallRTL(IL._strcmp, 5);
|
|
GetRegA
|
|
|
|
|IL.opEQSW .. IL.opGESW:
|
|
PushAll(4);
|
|
PushConst(opcode - IL.opEQSW);
|
|
CallRTL(IL._strcmpw, 5);
|
|
GetRegA
|
|
|
|
|IL.opCOPY:
|
|
PushAll(2);
|
|
PushConst(param2);
|
|
CallRTL(IL._move, 3)
|
|
|
|
|IL.opMOVE:
|
|
PushAll(3);
|
|
CallRTL(IL._move, 3)
|
|
|
|
|IL.opCOPYA:
|
|
PushAll(4);
|
|
PushConst(param2);
|
|
CallRTL(IL._arrcpy, 5);
|
|
GetRegA
|
|
|
|
|IL.opCOPYS:
|
|
PushAll(4);
|
|
PushConst(param2);
|
|
CallRTL(IL._strcpy, 5)
|
|
|
|
|IL.opDIV:
|
|
PushAll(2);
|
|
divmod;
|
|
GetRegA
|
|
|
|
|IL.opDIVL:
|
|
UnOp(r1);
|
|
REG.PushAll_1(R);
|
|
PushConst(param2);
|
|
push(r1);
|
|
drop;
|
|
divmod;
|
|
GetRegA
|
|
|
|
|IL.opDIVR:
|
|
n := UTILS.Log2(param2);
|
|
IF n > 0 THEN
|
|
UnOp(r1);
|
|
AsrImm(r1, n)
|
|
ELSIF n < 0 THEN
|
|
PushAll(1);
|
|
PushConst(param2);
|
|
divmod;
|
|
GetRegA
|
|
END
|
|
|
|
|IL.opMOD:
|
|
PushAll(2);
|
|
divmod;
|
|
mov(R0, R1);
|
|
GetRegA
|
|
|
|
|IL.opMODR:
|
|
n := UTILS.Log2(param2);
|
|
IF n > 0 THEN
|
|
UnOp(r1);
|
|
IF n = 8 THEN
|
|
Code(0B2C0H + r1 * 9) (* uxtb r1 *)
|
|
ELSIF n = 16 THEN
|
|
Code(0B280H + r1 * 9) (* uxth r1 *)
|
|
ELSE
|
|
LslImm(r1, 32 - n);
|
|
LsrImm(r1, 32 - n)
|
|
END
|
|
ELSIF n < 0 THEN
|
|
PushAll(1);
|
|
PushConst(param2);
|
|
divmod;
|
|
mov(R0, R1);
|
|
GetRegA
|
|
ELSE
|
|
UnOp(r1);
|
|
MovConst(r1, 0)
|
|
END
|
|
|
|
|IL.opMODL:
|
|
UnOp(r1);
|
|
REG.PushAll_1(R);
|
|
PushConst(param2);
|
|
push(r1);
|
|
drop;
|
|
divmod;
|
|
mov(R0, R1);
|
|
GetRegA
|
|
|
|
|IL.opIN, IL.opINR:
|
|
IF opcode = IL.opINR THEN
|
|
r2 := GetAnyReg();
|
|
MovConst(r2, param2)
|
|
END;
|
|
L := NewLabel();
|
|
L2 := NewLabel();
|
|
BinOp(r1, r2);
|
|
r3 := GetAnyReg();
|
|
CmpConst(r1, 32);
|
|
jcc(jb, L);
|
|
MovConst(r1, 0);
|
|
jmp(L2);
|
|
Label(L);
|
|
MovConst(r3, 1);
|
|
Shift(IL.opLSL, r3, r1);
|
|
gen4(0, r3, r2); (* and r2, r3 *)
|
|
SetCC(jne, r1);
|
|
Label(L2);
|
|
drop;
|
|
drop
|
|
|
|
|IL.opINL:
|
|
UnOp(r1);
|
|
r2 := GetAnyReg();
|
|
MovConst(r2, LSL(1, param2));
|
|
gen4(0, r2, r1); (* and r1, r2 *)
|
|
SetCC(jne, r1);
|
|
drop
|
|
|
|
|IL.opRSET:
|
|
PushAll(2);
|
|
CallRTL(IL._set, 2);
|
|
GetRegA
|
|
|
|
|IL.opRSETR:
|
|
PushAll(1);
|
|
PushConst(param2);
|
|
CallRTL(IL._set, 2);
|
|
GetRegA
|
|
|
|
|IL.opRSETL:
|
|
UnOp(r1);
|
|
REG.PushAll_1(R);
|
|
PushConst(param2);
|
|
push(r1);
|
|
drop;
|
|
CallRTL(IL._set, 2);
|
|
GetRegA
|
|
|
|
|IL.opRSET1:
|
|
PushAll(1);
|
|
CallRTL(IL._set1, 1);
|
|
GetRegA
|
|
|
|
|IL.opCONSTF:
|
|
MovConst(GetAnyReg(), UTILS.d2s(cmd.float))
|
|
|
|
|IL.opMULF:
|
|
PushAll(2);
|
|
CallRTL(IL._fmul, 2);
|
|
GetRegA
|
|
|
|
|IL.opDIVF:
|
|
PushAll(2);
|
|
CallRTL(IL._fdiv, 2);
|
|
GetRegA
|
|
|
|
|IL.opDIVFI:
|
|
PushAll(2);
|
|
CallRTL(IL._fdivi, 2);
|
|
GetRegA
|
|
|
|
|IL.opADDF, IL.opADDFI:
|
|
PushAll(2);
|
|
CallRTL(IL._fadd, 2);
|
|
GetRegA
|
|
|
|
|IL.opSUBFI:
|
|
PushAll(2);
|
|
CallRTL(IL._fsubi, 2);
|
|
GetRegA
|
|
|
|
|IL.opSUBF:
|
|
PushAll(2);
|
|
CallRTL(IL._fsub, 2);
|
|
GetRegA
|
|
|
|
|IL.opEQF..IL.opGEF:
|
|
PushAll(2);
|
|
PushConst(opcode - IL.opEQF);
|
|
CallRTL(IL._fcmp, 3);
|
|
GetRegA
|
|
|
|
|IL.opFLOOR:
|
|
PushAll(1);
|
|
CallRTL(IL._floor, 1);
|
|
GetRegA
|
|
|
|
|IL.opFLT:
|
|
PushAll(1);
|
|
CallRTL(IL._flt, 1);
|
|
GetRegA
|
|
|
|
|IL.opUMINF:
|
|
UnOp(r1);
|
|
r2 := GetAnyReg();
|
|
MovConst(r2, 1);
|
|
LslImm(r2, 31);
|
|
gen4(1, r2, r1); (* eor r1, r2 *)
|
|
drop
|
|
|
|
|IL.opFABS:
|
|
UnOp(r1);
|
|
r2 := GetAnyReg();
|
|
MovConst(r2, 1);
|
|
LslImm(r2, 31);
|
|
gen4(14, r2, r1); (* bic r1, r2 *)
|
|
drop
|
|
|
|
|IL.opNEW:
|
|
PushAll(1);
|
|
n := param2 + 8;
|
|
ASSERT(UTILS.Align(n, 32));
|
|
PushConst(n);
|
|
PushConst(param1);
|
|
CallRTL(IL._new, 3)
|
|
|
|
|IL.opTYPEGP:
|
|
UnOp(r1);
|
|
PushAll(0);
|
|
push(r1);
|
|
PushConst(param2);
|
|
CallRTL(IL._guard, 2);
|
|
GetRegA
|
|
|
|
|IL.opIS:
|
|
PushAll(1);
|
|
PushConst(param2);
|
|
CallRTL(IL._is, 2);
|
|
GetRegA
|
|
|
|
|IL.opISREC:
|
|
PushAll(2);
|
|
PushConst(param2);
|
|
CallRTL(IL._guardrec, 3);
|
|
GetRegA
|
|
|
|
|IL.opTYPEGR:
|
|
PushAll(1);
|
|
PushConst(param2);
|
|
CallRTL(IL._guardrec, 2);
|
|
GetRegA
|
|
|
|
|IL.opTYPEGD:
|
|
UnOp(r1);
|
|
PushAll(0);
|
|
SubImm8(r1, 4);
|
|
Ldr32(r1, r1);
|
|
push(r1);
|
|
PushConst(param2);
|
|
CallRTL(IL._guardrec, 2);
|
|
GetRegA
|
|
|
|
|IL.opCASET:
|
|
push(R2);
|
|
push(R2);
|
|
PushConst(param2);
|
|
CallRTL(IL._guardrec, 2);
|
|
pop(R2);
|
|
cbnz(ACC, param1)
|
|
|
|
|IL.opROT:
|
|
PushAll(0);
|
|
mov(R2, SP);
|
|
push(R2);
|
|
PushConst(param2);
|
|
CallRTL(IL._rot, 2)
|
|
|
|
|IL.opPACK:
|
|
PushAll(2);
|
|
CallRTL(IL._pack, 2)
|
|
|
|
|IL.opPACKC:
|
|
PushAll(1);
|
|
PushConst(param2);
|
|
CallRTL(IL._pack, 2)
|
|
|
|
|IL.opUNPK:
|
|
PushAll(2);
|
|
CallRTL(IL._unpk, 2)
|
|
|
|
END;
|
|
|
|
cmd := cmd.next(COMMAND)
|
|
END;
|
|
|
|
ASSERT(R.pushed = 0);
|
|
ASSERT(R.top = -1)
|
|
END translate;
|
|
|
|
|
|
PROCEDURE prolog (GlobSize, tcount, pic, FlashAdr, sp, ivt_len: INTEGER);
|
|
VAR
|
|
r1, r2, i, dcount: INTEGER;
|
|
|
|
BEGIN
|
|
entry := NewLabel();
|
|
emptyProc := NewLabel();
|
|
genInt := NewLabel();
|
|
genTrap := NewLabel();
|
|
sdivProc := NewLabel();
|
|
|
|
trap := emptyProc;
|
|
int0 := emptyProc;
|
|
|
|
IVT[0] := sp;
|
|
IVT[1] := entry;
|
|
FOR i := 2 TO ivt_len - 1 DO
|
|
IVT[i] := genInt
|
|
END;
|
|
|
|
FOR i := 0 TO ivt_len - 1 DO
|
|
Code(low(IVT[i]));
|
|
Code(high(IVT[i]))
|
|
END;
|
|
|
|
Label(entry);
|
|
|
|
r1 := GetAnyReg();
|
|
r2 := GetAnyReg();
|
|
reloc(r1, BIN.RDATA + pic, 0);
|
|
|
|
FOR i := 0 TO tcount - 1 DO
|
|
MovConst(r2, CHL.GetInt(IL.codes.types, i));
|
|
Str32(r2, r1);
|
|
AddImm8(r1, 4)
|
|
END;
|
|
|
|
dcount := CHL.Length(IL.codes.data);
|
|
FOR i := 0 TO dcount - 1 BY 4 DO
|
|
MovConst(r2, BIN.get32le(IL.codes.data, i));
|
|
Str32(r2, r1);
|
|
AddImm8(r1, 4)
|
|
END;
|
|
|
|
drop;
|
|
drop;
|
|
|
|
r1 := GetAnyReg();
|
|
MovConst(r1, sp);
|
|
mov(SP, r1);
|
|
reloc(r1, BIN.RDATA + pic, 0);
|
|
push(r1);
|
|
reloc(r1, BIN.RBSS + pic, 0);
|
|
r2 := GetAnyReg();
|
|
MovConst(r2, GlobSize);
|
|
AddReg(r1, r1, r2);
|
|
drop;
|
|
push(r1);
|
|
drop;
|
|
PushConst(tcount);
|
|
CallRTL(IL._init, 3)
|
|
END prolog;
|
|
|
|
|
|
PROCEDURE epilog;
|
|
VAR
|
|
L1, L2, L3, L4: INTEGER;
|
|
|
|
BEGIN
|
|
Code(0BF30H); (* L2: wfi *)
|
|
Code(0E7FDH); (* b L2 *)
|
|
|
|
Label(genInt);
|
|
Code(0F3EFH); Code(08105H); (* mrs r1, ipsr *)
|
|
gen14(FALSE, TRUE, {R1}); (* push {LR, R1} *)
|
|
call(int0);
|
|
gen14(TRUE, TRUE, {R1}); (* pop {PC, R1} *)
|
|
|
|
Label(emptyProc);
|
|
Code(04770H); (* bx lr *)
|
|
|
|
Label(genTrap);
|
|
call(trap);
|
|
call(entry);
|
|
|
|
Label(sdivProc);
|
|
IF Target.InstrSet.sdiv THEN
|
|
Code(09800H); (* ldr r0, [sp + #0] *)
|
|
Code(09901H); (* ldr r1, [sp + #4] *)
|
|
Code(0FB91H); (* sdiv r2, r1, r0 *)
|
|
Code(0F2F0H);
|
|
Code(00013H); (* mov r3, r2 *)
|
|
Code(04343H); (* mul r3, r0 *)
|
|
Code(01AC9H); (* sub r1, r3 *)
|
|
Code(0DA01H); (* bge L *)
|
|
Code(04401H); (* add r1, r0 *)
|
|
Code(03A01H); (* sub r2, #1 *)
|
|
(* L: *)
|
|
Code(00010H); (* mov r0, r2 *)
|
|
Code(04770H); (* bx lr *)
|
|
ELSE
|
|
(* a / b; a >= 0 *)
|
|
L1 := NewLabel();
|
|
L2 := NewLabel();
|
|
L3 := NewLabel();
|
|
L4 := NewLabel();
|
|
|
|
LdrSp(R1, 1);
|
|
LdrSp(R2, 0);
|
|
MovConst(R0, 0);
|
|
push(R4);
|
|
|
|
Label(L4);
|
|
Cmp(R1, R2);
|
|
jcc(jl, L1);
|
|
MovConst(R3, 2);
|
|
mov(R4, R2);
|
|
LslImm(R4, 1);
|
|
Label(L3);
|
|
Cmp(R1, R4);
|
|
jcc(jl, L2);
|
|
CmpConst(R4, 0);
|
|
jcc(jle, L2);
|
|
LslImm(R4, 1);
|
|
LslImm(R3, 1);
|
|
jmp(L3);
|
|
Label(L2);
|
|
LsrImm(R4, 1);
|
|
LsrImm(R3, 1);
|
|
SubReg(R1, R1, R4);
|
|
AddReg(R0, R0, R3);
|
|
jmp(L4);
|
|
Label(L1);
|
|
|
|
(* a / b; a < 0 *)
|
|
L1 := NewLabel();
|
|
L2 := NewLabel();
|
|
L3 := NewLabel();
|
|
L4 := NewLabel();
|
|
|
|
Label(L4);
|
|
CmpConst(R1, 0);
|
|
jcc(jge, L1);
|
|
MovConst(R3, 2);
|
|
mov(R4, R2);
|
|
LslImm(R4, 1);
|
|
Neg(R1);
|
|
Label(L3);
|
|
Cmp(R1, R4);
|
|
jcc(jl, L2);
|
|
CmpConst(R4, 0);
|
|
jcc(jle, L2);
|
|
LslImm(R4, 1);
|
|
LslImm(R3, 1);
|
|
jmp(L3);
|
|
Label(L2);
|
|
Neg(R1);
|
|
LsrImm(R4, 1);
|
|
LsrImm(R3, 1);
|
|
AddReg(R1, R1, R4);
|
|
SubReg(R0, R0, R3);
|
|
jmp(L4);
|
|
Label(L1);
|
|
|
|
pop(R4);
|
|
Code(04770H); (* bx lr *)
|
|
END
|
|
|
|
END epilog;
|
|
|
|
|
|
PROCEDURE CortexM3;
|
|
BEGIN
|
|
Target.FlashAdr := 08000000H;
|
|
Target.SRAMAdr := 20000000H;
|
|
Target.IVTLen := 256;
|
|
Target.Reserved := 0;
|
|
Target.MinStack := 512;
|
|
Target.InstrSet.thumb2 := TRUE;
|
|
Target.InstrSet.it := TRUE;
|
|
Target.InstrSet.sdiv := TRUE;
|
|
Target.InstrSet.cbxz := TRUE
|
|
END CortexM3;
|
|
|
|
|
|
PROCEDURE CodeGen* (outname: ARRAY OF CHAR; target: INTEGER; options: PROG.OPTIONS);
|
|
VAR
|
|
opt: PROG.OPTIONS;
|
|
|
|
ram, rom: INTEGER;
|
|
|
|
DataAdr, BssAdr, DataSize, BssSize, CodeSize: INTEGER;
|
|
|
|
File: WR.FILE;
|
|
|
|
BEGIN
|
|
IF target = TARGETS.STM32CM3 THEN
|
|
CortexM3
|
|
END;
|
|
|
|
ram := MIN(MAX(options.ram, STM32_minRAM), STM32_maxRAM) * 1024;
|
|
rom := MIN(MAX(options.rom, STM32_minROM), STM32_maxROM) * 1024;
|
|
|
|
tcount := CHL.Length(IL.codes.types);
|
|
|
|
opt := options;
|
|
CodeList := LISTS.create(NIL);
|
|
|
|
program := BIN.create(IL.codes.lcount);
|
|
|
|
REG.Init(R, push, pop, mov, xchg, NIL, NIL, {R0, R1, R2, R3}, {});
|
|
|
|
StkCount := 0;
|
|
|
|
DataAdr := Target.SRAMAdr + Target.Reserved;
|
|
DataSize := CHL.Length(IL.codes.data) + tcount * 4 + Target.Reserved;
|
|
WHILE DataSize MOD 4 # 0 DO
|
|
CHL.PushByte(IL.codes.data, 0);
|
|
INC(DataSize)
|
|
END;
|
|
BssAdr := DataAdr + DataSize - Target.Reserved;
|
|
|
|
IL.set_bss(MAX(IL.codes.bss, MAX(IL.codes.dmin - CHL.Length(IL.codes.data), 4)));
|
|
|
|
BssSize := IL.codes.bss;
|
|
ASSERT(UTILS.Align(BssSize, 4));
|
|
|
|
prolog(BssSize, tcount, ORD(opt.pic), Target.FlashAdr, Target.SRAMAdr + ram, Target.IVTLen);
|
|
translate(ORD(opt.pic), tcount * 4);
|
|
epilog;
|
|
|
|
fixup(Target.FlashAdr, DataAdr, BssAdr);
|
|
|
|
INC(DataSize, BssSize);
|
|
CodeSize := CHL.Length(program.code);
|
|
|
|
IF CodeSize > rom THEN
|
|
ERRORS.Error(203)
|
|
END;
|
|
|
|
IF DataSize > ram - Target.MinStack THEN
|
|
ERRORS.Error(204)
|
|
END;
|
|
|
|
File := WR.Create(outname);
|
|
|
|
HEX.Data2(File, program.code, 0, CodeSize, high(Target.FlashAdr));
|
|
HEX.End(File);
|
|
|
|
WR.Close(File);
|
|
|
|
C.StringLn("--------------------------------------------");
|
|
C.String( " rom: "); C.Int(CodeSize); C.String(" of "); C.Int(rom); C.String(" ("); C.Int(CodeSize * 100 DIV rom); C.StringLn("%)");
|
|
C.Ln;
|
|
C.String( " ram: "); C.Int(DataSize); C.String(" of "); C.Int(ram); C.String(" ("); C.Int(DataSize * 100 DIV ram); C.StringLn("%)")
|
|
|
|
END CodeGen;
|
|
|
|
|
|
PROCEDURE SetIV* (idx: INTEGER): BOOLEAN;
|
|
VAR
|
|
res: BOOLEAN;
|
|
|
|
BEGIN
|
|
res := IVT[idx] = 0;
|
|
IVT[idx] := 1
|
|
|
|
RETURN res
|
|
END SetIV;
|
|
|
|
|
|
PROCEDURE init;
|
|
VAR
|
|
i: INTEGER;
|
|
|
|
BEGIN
|
|
FOR i := 0 TO LEN(IVT) - 1 DO
|
|
IVT[i] := 0
|
|
END
|
|
END init;
|
|
|
|
|
|
BEGIN
|
|
init
|
|
END THUMB. |