WebSVN – Kolibri OS – Diff – /programs/develop/oberon07/source/THUMB.ob07

 (*
     BSD 2-Clause License
-    Copyright (c) 2019-2020, Anton Krotov
+    Copyright (c) 2019-2021, Anton Krotov
     All rights reserved.
 *)
     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;
-    STM32_minROM* = 16; STM32_maxROM* = 65536;
+    CortexM0  = {};
-    STM32_minRAM* = 4;  STM32_maxRAM* = 65536;
+    CortexM1  = {};
         FlashAdr,
         SRAMAdr,
         IVTLen,
         MinStack,
         Reserved: INTEGER;
+        InstrSet: SET;
-        InstrSet: RECORD thumb2, it, cbxz, sdiv: BOOLEAN END
+        isNXP: BOOLEAN
     END;
     IVT: ARRAY maxIVT + 1 OF INTEGER;
 END Cmp;
 PROCEDURE Tst (r: INTEGER);
 BEGIN
-    gen3(1, r, 0) (* cmp r, #0 *)
+    gen3(1, r, 0) (* cmp r, 0 *)
 END Tst;
     code:    ANYCODE;
     count:   INTEGER;
     shorted: BOOLEAN;
     jump:    JUMP;
-    first, second: INTEGER;
     reloc, i, diff, len: INTEGER;
         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
     END movwt;
     PROCEDURE genmovimm32 (r, value: INTEGER; VAR code: RELOCCODE);
     BEGIN
-        IF Target.InstrSet.thumb2 THEN
+        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);  (* mov r, #imm8 *)
+            code[0] := 2000H + r * 256 + UTILS.Byte(value, 3);  (* movs r, imm8 *)
-            code[1] := 0200H + r * 9;                           (* lsl r, r, #8 *)
+            code[1] := 0200H + r * 9;                           (* lsls r, 8    *)
-            code[2] := 3000H + r * 256 + UTILS.Byte(value, 2);  (* add r, #imm8 *)
+            code[2] := 3000H + r * 256 + UTILS.Byte(value, 2);  (* adds r, imm8 *)
-            code[3] := code[1];                                 (* lsl r, r, #8 *)
+            code[3] := code[1];                                 (* lsls r, 8    *)
-            code[4] := 3000H + r * 256 + UTILS.Byte(value, 1);  (* add r, #imm8 *)
+            code[4] := 3000H + r * 256 + UTILS.Byte(value, 1);  (* adds r, imm8 *)
-            code[5] := code[1];                                 (* lsl r, r, #8 *)
+            code[5] := code[1];                                 (* lsls r, 8    *)
-            code[6] := 3000H + r * 256 + UTILS.Byte(value, 0)   (* add r, #imm8 *)
+            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
-    END PutCode;
+        ASSERT(srange(offset, 22));
         PutCode(0F000H + ASR(offset, 11) MOD 2048);
         PutCode(0F800H + offset MOD 2048)
-    PROCEDURE genbc (code: JUMP);
+    END genlongjmp;
     VAR
         first, second: INTEGER;
+    PROCEDURE genbc (code: JUMP);
-    BEGIN
-        CASE code.len OF
-        |1: PutCode(genjcc(code.cond, code.diff))
+    BEGIN
-        |2: PutCode(genjcc(inv0(code.cond), 0));
+        CASE code.len OF
-            PutCode(genjmp(code.diff))
+        |1: PutCode(genjcc(code.cond, code.diff))
             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)
+            |RELOC: INC(count, 7 - ORD(_THUMB2 IN Target.InstrSet) * 3 + code.rel MOD 2)
             END;
         |JMP:
                 IF code.len = 1 THEN
                     PutCode(genjmp(code.diff))
                 ELSE
-                    genlongjmp(code.diff, first, second);
-                    PutCode(first);
-                    PutCode(second)
+                    genlongjmp(code.diff)
                 END
         |JCC:   genbc(code)
         |CBXZ:
                 IF code.len > 1 THEN
-                    PutCode(2800H + code.reg * 256); (* cmp code.reg, #0 *)
+                    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)
+                    (* cb(n)z code.reg, L *)
-                END
-        |CALL:
+                    PutCode(0B100H + 800H * ORD(code.cond = jne) + 200H * (code.diff DIV 32) + (code.diff MOD 32) * 8 + code.reg)
-                genlongjmp(code.diff, first, second);
+                END
                 PutCode(first);
-                PutCode(second)
+        |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(Target.InstrSet.thumb2) + 9))
+                    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(Target.InstrSet.thumb2) DO
+                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
         LslImm(r, UTILS.Log2(c))
     ELSIF c = UTILS.min32 THEN
         MovImm8(r, 1);
         LslImm(r, 31)
     ELSE
-        IF Target.InstrSet.thumb2 THEN
+        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
 PROCEDURE SetCC (cc, r: INTEGER);
 VAR
     L1, L2: INTEGER;
 BEGIN
-    IF Target.InstrSet.it THEN
+    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
             IF n > 0 THEN
                 AddImm8(r, n)
             ELSE
                 SubImm8(r, -n)
             END
-        ELSIF Target.InstrSet.thumb2 & (-4095 <= n) & (n <= 4095) THEN
+        ELSIF (_THUMB2 IN Target.InstrSet) & (-4095 <= n) & (n <= 4095) THEN
-            IF n > 0 THEN
-                AddSubImm12(r, n, FALSE)
-            ELSE
-                AddSubImm12(r, -n, TRUE)
+            AddSubImm12(r, ABS(n), n < 0)
-            END
         ELSE
             r2 := GetAnyReg();
             ASSERT(r2 # r);
             IF n > 0 THEN
                 MovConst(r2, n);
         DEC(StkCount, n)
     END
 END AddSP;
-PROCEDURE cbz (r, label: INTEGER);
+PROCEDURE cbxz2 (c, r, label: INTEGER);
 BEGIN
-    IF Target.InstrSet.cbxz THEN
+    IF _CBXZ IN Target.InstrSet THEN
-        cbxz(je, r, label)
+        cbxz(c, r, label)
     ELSE
         Tst(r);
+        jcc(c, label)
+    END
+END cbxz2;
+PROCEDURE cbz (r, label: INTEGER);
-        jcc(je, label)
+BEGIN
-    END
+    cbxz2(je, r, label)
 END cbz;
-PROCEDURE cbnz (r, label: INTEGER);
-BEGIN
-    IF Target.InstrSet.cbxz THEN
-        cbxz(jne, r, label)
     ELSE
-        Tst(r);
+PROCEDURE cbnz (r, label: INTEGER);
-        jcc(jne, label)
+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
         |IL.opENTER:
             ASSERT(R.top = -1);
             Label(param1);
-            gen14(FALSE, TRUE, {}); (* push LR *)
+            gen14(FALSE, TRUE, {}); (* push {lr} *)
             n := 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));
+                IF r1 # ACC THEN
-                    drop
+                    mov(ACC, r1)
                 END;
                 drop
             END;
             ASSERT(R.top = -1);
             ASSERT(StkCount = param1);
             AddSP(param1);
-            gen14(TRUE, TRUE, {}) (* pop PC *)
+            gen14(TRUE, TRUE, {}) (* pop {pc} *)
         |IL.opLEAVEC:
         |IL.opPUSHC:
             PushConst(param2)
         |IL.opONERR:
-        |IL.opONERR:
+            cpsid_i;
             MovConst(R0, param2);
             push(R0);
         |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
             drop
         |IL.opCASELR:
             GetRegA;
+            CmpConst(ACC, param1);
+            IF param2 = cmd.param3 THEN
+                jcc(jne, param2)
-            CmpConst(ACC, param1);
+            ELSE
-            jcc(jl, param2);
+                jcc(jl, param2);
+                jcc(jg, cmd.param3)
-            jcc(jg, cmd.param3);
+            END;
             drop
             Tst(r1);
             SetCC(jne, r1)
         |IL.opCHR:
             UnOp(r1);
-            Code(0B2C0H + r1 * 9) (* uxtb r1 *)
+            Code(0B2C0H + r1 * 9) (* uxtb r1, r1 *)
         |IL.opWCHR:
             UnOp(r1);
-            Code(0B280H + r1 * 9) (* uxth r1 *)
+            Code(0B280H + r1 * 9) (* uxth r1, r1 *)
         |IL.opASR, IL.opROR, IL.opLSL, IL.opLSR:
             END;
             INCL(R.regs, r1);
-            ASSERT(REG.GetReg(R, r1))
-        |IL.opLOOP, IL.opENDLOOP:
+            ASSERT(REG.GetReg(R, r1))
         |IL.opINF:
             MovConst(GetAnyReg(), inf)
             MovConst(r1, param2);
             Label(L)
         |IL.opMULS:
             BinOp(r1, r2);
-            gen4(0, r2, r1); (* and r1, r2 *)
+            gen4(0, r2, r1); (* ands r1, r2 *)
             drop
         |IL.opMULSC:
             MovConst(GetAnyReg(), param2);
             BinOp(r1, r2);
-            gen4(0, r2, r1); (* and r1, r2 *)
+            gen4(0, r2, r1); (* ands r1, r2 *)
             drop
         |IL.opDIVS:
             BinOp(r1, r2);
-            gen4(1, r2, r1); (* eor r1, r2 *)
+            gen4(1, r2, r1); (* eors r1, r2 *)
             drop
         |IL.opDIVSC:
             MovConst(GetAnyReg(), param2);
             BinOp(r1, r2);
-            gen4(1, r2, r1); (* eor r1, r2 *)
+            gen4(1, r2, r1); (* eors r1, r2 *)
             drop
         |IL.opADDS:
             BinOp(r1, r2);
-            gen4(12, r2, r1); (* orr r1, r2 *)
+            gen4(12, r2, r1); (* orrs r1, r2 *)
             drop
         |IL.opSUBS:
             BinOp(r1, r2);
-            gen4(14, r2, r1); (* bic r1, r2 *)
+            gen4(14, r2, r1); (* bics r1, r2 *)
             drop
         |IL.opADDSC:
             MovConst(GetAnyReg(), param2);
             BinOp(r1, r2);
-            gen4(12, r2, r1); (* orr r1, r2 *)
+            gen4(12, r2, r1); (* orrs r1, r2 *)
             drop
         |IL.opSUBSL:
             MovConst(GetAnyReg(), param2);
             BinOp(r1, r2);
-            gen4(14, r1, r2); (* bic r2, r1 *)
+            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); (* bic r1, r2 *)
+            gen4(14, r2, r1); (* bics r1, r2 *)
             drop
         |IL.opUMINS:
             UnOp(r1);
-            gen4(15, r1, r1) (* mvn r1, 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);
             r3 := GetAnyReg();
             MovConst(r3, 1);
             LslImm(r3, param2);
             Ldr32(r1, r2);
             IF opcode = IL.opINCLC THEN
-                gen4(12, r3, r1) (* orr r1, r3 *)
+                gen4(12, r3, r1) (* orrs r1, r3 *)
             ELSE
-                gen4(14, r3, r1) (* bic r1, r3 *)
+                gen4(14, r3, r1) (* bics r1, r3 *)
             END;
             Str32(r1, r2);
             drop;
             drop;
             drop
         |IL.opMODR:
             n := UTILS.Log2(param2);
             IF n > 0 THEN
                 UnOp(r1);
                 IF n = 8 THEN
-                    Code(0B2C0H + r1 * 9) (* uxtb r1 *)
+                    Code(0B2C0H + r1 * 9) (* uxtb r1, r1 *)
                 ELSIF n = 16 THEN
-                    Code(0B280H + r1 * 9) (* uxth r1 *)
+                    Code(0B280H + r1 * 9) (* uxth r1, r1 *)
                 ELSE
                     LslImm(r1, 32 - n);
                     LsrImm(r1, 32 - n)
                 END
             ELSIF n < 0 THEN
             MovConst(r1, 0);
             jmp(L2);
             Label(L);
             MovConst(r3, 1);
             Shift(IL.opLSL, r3, r1);
-            gen4(0, r3, r2); (* and r2, r3 *)
+            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); (* and r1, r2 *)
+            gen4(0, r2, r1); (* ands r1, r2 *)
             SetCC(jne, r1);
             drop
         |IL.opUMINF:
             UnOp(r1);
             r2 := GetAnyReg();
             MovConst(r2, 1);
             LslImm(r2, 31);
-            gen4(1, r2, r1); (* eor r1, r2 *)
+            gen4(1, r2, r1); (* eors r1, r2 *)
             drop
         |IL.opFABS:
             UnOp(r1);
             r2 := GetAnyReg();
             MovConst(r2, 1);
             LslImm(r2, 31);
-            gen4(14, r2, r1); (* bic r1, r2 *)
+            gen4(14, r2, r1); (* bics r1, r2 *)
             drop
         |IL.opNEW:
-        |IL.opNEW:
+            cpsid_i;
             PushAll(1);
-            n := param2 + 8;
+            n := param2 + 4;
-            ASSERT(UTILS.Align(n, 32));
+            ASSERT(UTILS.Align(n, 4));
             PushConst(n);
+            PushConst(param1);
-            PushConst(param1);
+            CallRTL(IL._new, 3);
-            CallRTL(IL._new, 3)
+            cpsie_i
         |IL.opTYPEGP:
     ASSERT(R.pushed = 0);
     ASSERT(R.top = -1)
 END translate;
-PROCEDURE prolog (GlobSize, tcount, pic, FlashAdr, sp, ivt_len: INTEGER);
+PROCEDURE prolog (GlobSize, tcount, pic, sp, ivt_len: INTEGER);
 VAR
     r1, r2, i, dcount: INTEGER;
         Code(low(IVT[i]));
         Code(high(IVT[i]))
     END;
+    Label(entry);
-    Label(entry);
+    cpsie_i;
     r1 := GetAnyReg();
 PROCEDURE epilog;
 VAR
     L1, L2, L3, L4: INTEGER;
 BEGIN
-    Code(0BF30H);  (* L2: wfi *)
+                   (* L2:  *)
-    Code(0E7FDH);  (* b L2    *)
+    Code(0E7FEH);  (* b L2 *)
     Label(genInt);
-    Code(0F3EFH); Code(08105H);  (* mrs r1, ipsr  *)
+    Code(0F3EFH); Code(08005H);  (* mrs r0, ipsr  *)
-    gen14(FALSE, TRUE, {R1});    (* push {LR, R1} *)
+    gen14(FALSE, TRUE, {R0});    (* push {lr, r0} *)
     call(int0);
-    gen14(TRUE, TRUE, {R1});     (* pop {PC, R1}  *)
+    gen14(TRUE, TRUE, {R0});     (* pop {pc, r0}  *)
     Label(emptyProc);
     Code(04770H);  (* bx lr *)
     Label(genTrap);
     call(trap);
     call(entry);
     Label(sdivProc);
-    IF Target.InstrSet.sdiv THEN
+    IF _SDIV IN Target.InstrSet THEN
-        Code(09800H);  (* ldr  r0, [sp + #0] *)
+        Code(09800H);  (* ldr  r0, [sp]    *)
-        Code(09901H);  (* ldr  r1, [sp + #4] *)
+        Code(09901H);  (* ldr  r1, [sp, 4] *)
-        Code(0FB91H);  (* sdiv r2, r1, r0    *)
+        Code(0FB91H);  (* sdiv r2, r1, r0  *)
         Code(0F2F0H);
-        Code(00013H);  (* mov  r3, r2        *)
+        Code(00013H);  (* movs r3, r2      *)
-        Code(04343H);  (* mul  r3, r0        *)
+        Code(04343H);  (* muls r3, r0, r3  *)
-        Code(01AC9H);  (* sub  r1, r3        *)
+        Code(01AC9H);  (* subs r1, r1, r3  *)
-        Code(0DA01H);  (* bge  L             *)
+        Code(0DA01H);  (* bge  L           *)
-        Code(04401H);  (* add  r1, r0        *)
+        Code(01809H);  (* adds r1, r1, r0  *)
-        Code(03A01H);  (* sub  r2, #1        *)
+        Code(03A01H);  (* subs r2, 1       *)
-                       (* L:                 *)
+                       (* L:               *)
-        Code(00010H);  (* mov  r0, r2        *)
+        Code(00010H);  (* movs r0, r2      *)
     END
 END epilog;
-PROCEDURE CortexM3;
+PROCEDURE SetTarget (FlashStart, SRAMStart: INTEGER; InstrSet: SET; isNXP: BOOLEAN);
+BEGIN
+    Target.FlashAdr := FlashStart;
+    Target.SRAMAdr  := SRAMStart;
-BEGIN
+    Target.InstrSet := InstrSet;
-    Target.FlashAdr := 08000000H;
+    Target.isNXP    := isNXP;
     Target.SRAMAdr  := 20000000H;
-    Target.IVTLen   := 256;
-    Target.Reserved := 0;
-    Target.MinStack := 512;
-    Target.InstrSet.thumb2 := TRUE;
-    Target.InstrSet.it     := TRUE;
+    Target.IVTLen   := 256; (* >= 192 *)
-    Target.InstrSet.sdiv   := TRUE;
+    Target.Reserved := 0;
-    Target.InstrSet.cbxz   := TRUE
+    Target.MinStack := 512;
-END CortexM3;
+END SetTarget;
 PROCEDURE CodeGen* (outname: ARRAY OF CHAR; target: INTEGER; options: PROG.OPTIONS);
+VAR
+    opt: PROG.OPTIONS;
-VAR
+    ram, rom, i, j: INTEGER;
-    opt: PROG.OPTIONS;
     DataAdr, BssAdr, DataSize, BssSize, CodeSize: INTEGER;
-    ram, rom: INTEGER;
-    DataAdr, BssAdr, DataSize, BssSize, CodeSize: INTEGER;
 BEGIN
-    IF target = TARGETS.STM32CM3 THEN
+    ram := MIN(MAX(options.ram, minRAM), maxRAM) * 1024;
-        CortexM3
+    rom := MIN(MAX(options.rom, minROM), maxROM) * 1024;
-    END;
     IF target = TARGETS.STM32CM3 THEN
-    ram := MIN(MAX(options.ram, STM32_minRAM), STM32_maxRAM) * 1024;
+        SetTarget(08000000H, 20000000H, CortexM3, FALSE)
-    rom := MIN(MAX(options.rom, STM32_minROM), STM32_maxROM) * 1024;
+    END;
     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);
+    prolog(BssSize, tcount, ORD(opt.pic), Target.SRAMAdr + ram, Target.IVTLen);
     translate(ORD(opt.pic), tcount * 4);
     IF DataSize > ram - Target.MinStack 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.FlashAdr));
     HEX.End;
     WR.Close;
     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.Dashes;
-    C.Ln;
+    C.String(  "  rom:  "); C.Int(CodeSize); C.String(" of "); C.Int(rom); C.String("  ("); C.Int(CodeSize * 100 DIV rom); C.StringLn("%)");

Subversion Repositories Kolibri OS

(root)/programs/develop/oberon07/source/THUMB.ob07 – Rev 8097 → 8859