kolibrios/programs/develop/oberon07/source/THUMB.ob07

(*
    BSD 2-Clause License

    Copyright (c) 2019-2022, 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;

    minROM* = 16; maxROM* = 65536;
    minRAM* = 4;  maxRAM* = 65536;

    maxIVT* = 1023;

    _THUMB2 = 0; _IT = 1; _SDIV = 2; _CBXZ = 3;

    CortexM0  = {};
    CortexM1  = {};
    CortexM3  = {_THUMB2, _IT, _SDIV, _CBXZ};
    CortexM23 = {_SDIV, _CBXZ};


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;

    MEM = RECORD
        start, size, startReserve, endReserve: INTEGER
    END;


VAR

    R: REG.REGS;

    tcount: INTEGER;

    CodeList: LISTS.LIST;

    program: BIN.PROGRAM;

    StkCount: INTEGER;

    Target: RECORD
        flash, sram: MEM;
        IVTLen,
        MinStkSize: INTEGER;
        InstrSet: SET;
        isNXP: BOOLEAN
    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;

    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 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 _THUMB2 IN Target.InstrSet THEN
            movwt(r, low(value), 0, code);
            movwt(r, high(value), 1, code)
        ELSE
            code[0] := 2000H + r * 256 + UTILS.Byte(value, 3);  (* movs r, imm8 *)
            code[1] := 0200H + r * 9;                           (* lsls r, 8    *)
            code[2] := 3000H + r * 256 + UTILS.Byte(value, 2);  (* adds r, imm8 *)
            code[3] := code[1];                                 (* lsls r, 8    *)
            code[4] := 3000H + r * 256 + UTILS.Byte(value, 1);  (* adds r, imm8 *)
            code[5] := code[1];                                 (* lsls r, 8    *)
            code[6] := 3000H + r * 256 + UTILS.Byte(value, 0)   (* adds r, imm8 *)
        END
    END genmovimm32;


    PROCEDURE PutCode (code: INTEGER);
    BEGIN
        BIN.PutCode16LE(program, code)
    END PutCode;


    PROCEDURE genlongjmp (offset: INTEGER);
    BEGIN
        ASSERT(srange(offset, 22));
        PutCode(0F000H + ASR(offset, 11) MOD 2048);
        PutCode(0F800H + offset MOD 2048)
    END genlongjmp;


    PROCEDURE genbc (code: JUMP);
    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)
        END
    END genbc;


    PROCEDURE SetIV (idx, label, CodeAdr: INTEGER);
    VAR
        l, h: LISTS.ITEM;

    BEGIN
        l := CodeList.first;
        h := l.next;
        WHILE idx > 0 DO
            l := h.next;
            h := l.next;
            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(_THUMB2 IN Target.InstrSet) * 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)
                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 * (code.diff DIV 32) + (code.diff MOD 32) * 8 + code.reg)
                END

        |CALL:  genlongjmp(code.diff)

        |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(_THUMB2 IN Target.InstrSet) + 9))
                END;
                genmovimm32(code.reg, reloc, RelocCode);
                FOR i := 0 TO 6 - 3 * ORD(_THUMB2 IN Target.InstrSet) 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);
    mov(r1, r2);
    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 _THUMB2 IN Target.InstrSet 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 _IT IN Target.InstrSet 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 (_THUMB2 IN Target.InstrSet) & (-4095 <= n) & (n <= 4095) THEN
            AddSubImm12(r, ABS(n), n < 0)
        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 cbxz2 (c, r, label: INTEGER);
BEGIN
    IF _CBXZ IN Target.InstrSet THEN
        cbxz(c, r, label)
    ELSE
        Tst(r);
        jcc(c, label)
    END
END cbxz2;


PROCEDURE cbz (r, label: INTEGER);
BEGIN
    cbxz2(je, r, label)
END cbz;


PROCEDURE cbnz (r, label: INTEGER);
BEGIN
    cbxz2(jne, r, label)
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 cpsid_i;
BEGIN
    Code(0B672H)  (*  cpsid i  *)
END cpsid_i;


PROCEDURE cpsie_i;
BEGIN
    Code(0B662H)  (*  cpsie i  *)
END cpsie_i;


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); (* Thumb mode *)
            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
                    mov(ACC, r1)
                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:
            IF param2 = 1 THEN
                UnOp(r1);
                push(r1);
                drop
            ELSE
                ASSERT(R.top + 1 <= param2);
                PushAll(param2)
            END

        |IL.opCLEANUP:
            AddSP(param2)

        |IL.opRES, IL.opRESF:
            ASSERT(R.top = -1);
            GetRegA

        |IL.opPUSHC:
            PushConst(param2)

        |IL.opONERR:
            cpsid_i;
            MovConst(R0, param2);
            push(R0);
            DEC(StkCount);
            jmp(param1)

        |IL.opERR:
            call(genTrap)

        |IL.opNOP, IL.opAND, IL.opOR:

        |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.opLADR_SAVE:
            UnOp(r1);
            n := LocalOffset(param2);
            IF n <= 255 THEN
                gen11(FALSE, r1, n)  (* str r1, [sp, n*4] *)
            ELSE
                LocAdr(param2);
                BinOp(r1, r2);
                Str32(r1, r2);
                drop
            END;
            drop

        |IL.opLADR_INCC:
            n := LocalOffset(param1);
            IF n <= 255 THEN
                r1 := GetAnyReg();
                LdrSp(r1, n);
                AddConst(r1, param2);
                gen11(FALSE, r1, n)  (* str r1, [sp, n*4] *)
            ELSE
                LocAdr(param1);
                r1 := GetAnyReg();
                BinOp(r2, r1);
                Ldr32(r1, r2);
                AddConst(r1, param2);
                BinOp(r2, r1);
                Str32(r1, r2);
                drop
            END;
            drop

        |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.opDROP:
            UnOp(r1);
            drop

        |IL.opJNZ1:
            UnOp(r1);
            cbnz(r1, param1)

        |IL.opJG:
            UnOp(r1);
            Tst(r1);
            jcc(jg, param1)

        |IL.opJNZ:
            UnOp(r1);
            cbnz(r1, param1);
            drop

        |IL.opJZ:
            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);
            IF param2 = cmd.param3 THEN
                jcc(jne, param2)
            ELSE
                jcc(jl, param2);
                jcc(jg, cmd.param3)
            END;
            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.opJNZ THEN
                jcc(cc, next.param1);
                cmd := next
            ELSIF next.opcode = IL.opJZ 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.opADDC:
            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.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.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.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); (* ands r1, r2 *)
            drop

        |IL.opMULSC:
            MovConst(GetAnyReg(), param2);
            BinOp(r1, r2);
            gen4(0, r2, r1); (* ands r1, r2 *)
            drop

        |IL.opDIVS:
            BinOp(r1, r2);
            gen4(1, r2, r1); (* eors r1, r2 *)
            drop

        |IL.opDIVSC:
            MovConst(GetAnyReg(), param2);
            BinOp(r1, r2);
            gen4(1, r2, r1); (* eors r1, r2 *)
            drop

        |IL.opADDS:
            BinOp(r1, r2);
            gen4(12, r2, r1); (* orrs r1, r2 *)
            drop

        |IL.opSUBS:
            BinOp(r1, r2);
            gen4(14, r2, r1); (* bics r1, r2 *)
            drop

        |IL.opADDSC:
            MovConst(GetAnyReg(), param2);
            BinOp(r1, r2);
            gen4(12, r2, r1); (* orrs r1, r2 *)
            drop

        |IL.opSUBSL:
            MovConst(GetAnyReg(), param2);
            BinOp(r1, r2);
            gen4(14, r1, r2); (* bics 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); (* bics r1, r2 *)
            drop

        |IL.opUMINS:
            UnOp(r1);
            gen4(15, r1, r1) (* mvns 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); (* lsls r3, r1 *)
            Ldr32(r1, r2);
            IF opcode = IL.opINCL THEN
                gen4(12, r3, r1) (* orrs r1, r3 *)
            ELSE
                gen4(14, r3, r1) (* bics 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) (* orrs r1, r3 *)
            ELSE
                gen4(14, r3, r1) (* bics 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, r1 *)
                ELSIF n = 16 THEN
                    Code(0B280H + r1 * 9) (* uxth r1, 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); (* ands r2, r3 *)
            SetCC(jne, r1);
            Label(L2);
            drop;
            drop

        |IL.opINL:
            UnOp(r1);
            r2 := GetAnyReg();
            MovConst(r2, LSL(1, param2));
            gen4(0, r2, r1); (* ands 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:
            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); (* eors r1, r2 *)
            drop

        |IL.opFABS:
            UnOp(r1);
            r2 := GetAnyReg();
            MovConst(r2, 1);
            LslImm(r2, 31);
            gen4(14, r2, r1); (* bics r1, r2 *)
            drop

        |IL.opNEW:
            cpsid_i;
            PushAll(1);
            n := param2 + 4;
            ASSERT(UTILS.Align(n, 4));
            PushConst(n);
            PushConst(param1);
            CallRTL(IL._new, 3);
            cpsie_i

        |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, 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);
    cpsie_i;

    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
                   (* L2:  *)
    Code(0E7FEH);  (* b L2 *)

    Label(genInt);
    Code(0F3EFH); Code(08005H);  (* mrs r0, ipsr  *)
    gen14(FALSE, TRUE, {R0});    (* push {lr, r0} *)
    call(int0);
    gen14(TRUE, TRUE, {R0});     (* pop {pc, r0}  *)

    Label(emptyProc);
    Code(04770H);  (* bx lr *)

    Label(genTrap);
    call(trap);
    call(entry);

    Label(sdivProc);
    IF _SDIV IN Target.InstrSet THEN
        Code(09800H);  (* ldr  r0, [sp]    *)
        Code(09901H);  (* ldr  r1, [sp, 4] *)
        Code(0FB91H);  (* sdiv r2, r1, r0  *)
        Code(0F2F0H);
        Code(00013H);  (* movs r3, r2      *)
        Code(04343H);  (* muls r3, r0, r3  *)
        Code(01AC9H);  (* subs r1, r1, r3  *)
        Code(0DA01H);  (* bge  L           *)
        Code(01809H);  (* adds r1, r1, r0  *)
        Code(03A01H);  (* subs r2, 1       *)
                       (* L:               *)
        Code(00010H);  (* movs 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 SetTarget (FlashStart, FlashSize, FlashReserve, SRAMStart, SRAMSize, SRAMReserve: INTEGER; InstrSet: SET; isNXP: BOOLEAN);
BEGIN
    Target.flash.start := FlashStart;    
    Target.flash.size  := FlashSize;
    (*Target.flash.startReserve := 0;*)
    Target.flash.endReserve := FlashReserve;

    Target.sram.start := SRAMStart;
    Target.sram.size  := SRAMSize;
    Target.sram.startReserve := 0;
    Target.sram.endReserve   := SRAMReserve;

    Target.InstrSet := InstrSet;
    Target.isNXP    := isNXP;

    Target.IVTLen := 256; (* >= 192 *)
    Target.MinStkSize := 256;
END SetTarget;


PROCEDURE CodeGen* (outname: ARRAY OF CHAR; target: INTEGER; options: PROG.OPTIONS);
VAR
    opt: PROG.OPTIONS;
    i, j, DataAdr, BssAdr, DataSize, BssSize, CodeSize: INTEGER;

BEGIN
    IF target = TARGETS.STM32CM3 THEN
        SetTarget(08000000H, MIN(MAX(options.rom, minROM), maxROM) * 1024, 0,
                  20000000H, MIN(MAX(options.ram, minRAM), maxRAM) * 1024, 0,
                  CortexM3, FALSE)
    END;

    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, {R0, R1, R2, R3});

    StkCount := 0;

    DataAdr := Target.sram.start + Target.sram.startReserve;
    DataSize := CHL.Length(IL.codes.data) + tcount * 4 + Target.sram.startReserve;
    WHILE DataSize MOD 4 # 0 DO
        CHL.PushByte(IL.codes.data, 0);
        INC(DataSize)
    END;
    BssAdr := DataAdr + DataSize - Target.sram.startReserve;

    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.sram.start + Target.sram.size - Target.sram.endReserve, Target.IVTLen);
    translate(ORD(opt.pic), tcount * 4);
    epilog;

    fixup(Target.flash.start, DataAdr, BssAdr);

    INC(DataSize, BssSize);
    CodeSize := CHL.Length(program.code);

    IF CodeSize > Target.flash.size - Target.flash.endReserve THEN
        ERRORS.Error(203)
    END;

    IF DataSize > Target.sram.size - Target.MinStkSize - Target.sram.endReserve THEN
        ERRORS.Error(204)
    END;

    IF Target.isNXP THEN
        BIN.put32le(program.code, 2FCH, 0H); (* code read protection (CRP) *)
        (* NXP checksum *)
        j := 0;
        FOR i := 0 TO 6 DO
            INC(j, BIN.get32le(program.code, i * 4))
        END;
        BIN.put32le(program.code, 1CH, -j)
    END;

    WR.Create(outname);

    HEX.Data2(program.code, 0, CodeSize, high(Target.flash.start));
    HEX.End;

    WR.Close;

    C.Dashes;
    C.String(  "  rom:  "); C.Int(CodeSize); C.String(" of "); C.Int(Target.flash.size - Target.flash.endReserve);
        C.String("  ("); C.Int(CodeSize * 100 DIV (Target.flash.size - Target.flash.endReserve)); C.StringLn("%)");
    C.Ln;
    C.String(  "  ram:  "); C.Int(DataSize); C.String(" of "); C.Int(Target.sram.size - Target.sram.endReserve);
        C.String("  ("); C.Int(DataSize * 100 DIV (Target.sram.size - Target.sram.endReserve)); 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.