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

 (*
     BSD 2-Clause License
-    Copyright (c) 2019-2020, Anton Krotov
+    Copyright (c) 2019-2021, Anton Krotov
     All rights reserved.
 *)
        UTILS, C := CONSOLE, PROG, RTL := MSP430RTL;
+CONST
-CONST
+    chkSTK* = 6;
     minRAM* = 128;  maxRAM* = 2048;
     minROM* = 2048; maxROM* = 24576;
-    minStackSize = 64;
+    StkReserve = RTL.StkReserve;
     IntVectorSize* = RTL.IntVectorSize;
     IV: ARRAY RTL.LenIV OF INTEGER;
+    IdxWords: RECORD src, dst: INTEGER END;
+    StkCnt, MaxStkCnt: INTEGER;
-    IdxWords: RECORD src, dst: INTEGER END;
+PROCEDURE CheckProcDataSize* (VarSize, RamSize: INTEGER): BOOLEAN;
     RETURN (VarSize + 1) * 2 + StkReserve + RTL.VarSize < RamSize
-    StkCnt: INTEGER;
+END CheckProcDataSize;
     call.label := label;
     LISTS.push(CodeList, call)
 END EmitCall;
+PROCEDURE IncStk;
+BEGIN
+    INC(StkCnt);
+    MaxStkCnt := MAX(StkCnt, MaxStkCnt)
+END IncStk;
 PROCEDURE bw (b: BOOLEAN): INTEGER;
     |-1: Op1(opPUSH, CG, sINCR)
     ELSE
         Op1(opPUSH, PC, sINCR);
         EmitWord(imm)
     END;
-    INC(StkCnt)
+    IncStk
 END PushImm;
 PROCEDURE Push (reg: INTEGER);
 BEGIN
     Op1(opPUSH, reg, sREG);
-    INC(StkCnt)
+    IncStk
 END Push;
 END Reloc;
+PROCEDURE CallRTL (proc, params: INTEGER);
+BEGIN
-PROCEDURE CallRTL (proc, params: INTEGER);
+    IncStk;
-BEGIN
+    DEC(StkCnt);
     EmitCall(RTL.rtl[proc].label);
     RTL.Used(proc);
     IF params > 0 THEN
 PROCEDURE LocalSrc (offset: INTEGER): INTEGER;
     RETURN src_x(LocalOffset(offset), SP)
 END LocalSrc;
-PROCEDURE translate;
+PROCEDURE translate (chk_stk: BOOLEAN);
 VAR
     cmd, next: COMMAND;
+    opcode, param1, param2, L, a, n, c1, c2: INTEGER;
-    opcode, param1, param2, L, a, n, c1, c2: INTEGER;
+    reg1, reg2: INTEGER;
-    reg1, reg2: INTEGER;
+    cc: INTEGER;
         CASE opcode OF
         |IL.opJMP:
             EmitJmp(opJMP, param1)
+        |IL.opCALL:
+            IncStk;
-        |IL.opCALL:
+            DEC(StkCnt);
             EmitCall(param1)
+        |IL.opCALLP:
             IncStk;
-        |IL.opCALLP:
+            DEC(StkCnt);
             UnOp(reg1);
             Op1(opCALL, reg1, sREG);
         |IL.opLABEL:
             EmitLabel(param1)
         |IL.opSADR_PARAM:
             Op1(opPUSH, PC, sINCR);
-            INC(StkCnt);
+            IncStk;
             EmitWord(param2);
             Reloc(RDATA)
         |IL.opERR:
             CallRTL(RTL._error, 2)
-        |IL.opPUSHC:
-            PushImm(param2)
+        |IL.opPUSHC:
+            PushImm(param2)
+        |IL.opONERR:
             DEC(StkCnt);
-        |IL.opONERR:
+            EmitWord(0C232H); (*  BIC   #8, SR; DINT  *)
-            PushImm(param2);
+            EmitWord(4303H);  (*  MOV   R3, R3; NOP   *)
-            DEC(StkCnt);
+            PushImm(param2);
             EmitJmp(opJMP, param1)
         |IL.opLEAVEC:
+        |IL.opLEAVEC:
+            Pop(PC)
+        |IL.opENTER:
+            ASSERT(R.top = -1);
+            EmitLabel(param1);
+            n := param2 MOD 65536;
+            param2 := param2 DIV 65536;
+            StkCnt := 0;
+            IF chk_stk THEN
+                L := NewLabel();
+                Op2(opMOV, SP * 256, R4);
+                Op2(opSUB, HP * 256, R4);
+                Op2(opCMP, imm(StkReserve), R4);
+                word := CodeList.last(WORD);
+                jcc(jge, L);
+                DEC(StkCnt);
+                EmitWord(0C232H); (*  BIC   #8, SR; DINT  *)
-            Pop(PC)
+                EmitWord(4303H);  (*  MOV   R3, R3; NOP   *)
                 PushImm(n);
-        |IL.opENTER:
+                EmitJmp(opJMP, cmd.param3);
-            ASSERT(R.top = -1);
+                EmitLabel(L)
-            StkCnt := 0;
+            END;
             EmitLabel(param1);
             IF param2 > 8 THEN
                 Op2(opMOV, imm(param2), R4);
                 L := NewLabel();
                 EmitLabel(L);
-                Push(CG);
-                Op2(opSUB, imm(1), R4);
-                jcc(jne, L)
+                Push(CG);
+                Op2(opSUB, imm(1), R4);
+                jcc(jne, L)
+            ELSE
-            ELSIF param2 > 0 THEN
+                FOR n := 1 TO param2 DO
-                WHILE param2 > 0 DO
+                    Push(CG)
-                    Push(CG);
+                END
-                    DEC(param2)
+            END;
-                END
+            StkCnt := param2;
-            END
+            MaxStkCnt := StkCnt
-        |IL.opLEAVE, IL.opLEAVER:
             ASSERT(param2 = 0);
-            IF opcode = IL.opLEAVER THEN
+        |IL.opLEAVE, IL.opLEAVER:
-                UnOp(reg1);
+            ASSERT(param2 = 0);
-                IF reg1 # ACC THEN
+            IF opcode = IL.opLEAVER THEN
-                    GetRegA;
+                UnOp(reg1);
+                IF reg1 # ACC THEN
+                    mov(ACC, reg1)
+                END;
-                    ASSERT(REG.Exchange(R, reg1, ACC));
+                drop
-                    drop
+            END;
-                END;
+            ASSERT(R.top = -1);
-                drop
+            ASSERT(StkCnt = param1);
         |IL.opORD:
             UnOp(reg1);
             Test(reg1);
             setcc(jne, reg1)
-        |IL.opLOOP:
-        |IL.opENDLOOP:
         |IL.opGET:
             BinOp(reg1, reg2);
             drop;
             drop;
         |IL.opTYPEGD:
             UnOp(reg1);
             PushAll(0);
             Op1(opPUSH, reg1, sIDX);
-            INC(StkCnt);
+            IncStk;
             EmitWord(-2);
             PushImm(param2);
             CallRTL(RTL._guardrec, 2);
             Op2(opCMP, imm(param1), ACC);
             jcc(jg, param2)
         |IL.opCASELR:
+            Op2(opCMP, imm(param1), ACC);
+            IF param2 = cmd.param3 THEN
+                jcc(jne, param2)
-            Op2(opCMP, imm(param1), ACC);
+            ELSE
-            jcc(jl, param2);
+                jcc(jl, param2);
+                jcc(jg, cmd.param3)
-            jcc(jg, cmd.param3)
+            END
         |IL.opSBOOL:
             BinOp(reg2, reg1);
         |IL.opSAVES:
             UnOp(reg1);
             PushAll_1;
             Op1(opPUSH, PC, sINCR);
-            INC(StkCnt);
+            IncStk;
             EmitWord(param2);
             Reloc(RDATA);
             Push(reg1);
             drop;
     ASSERT(R.pushed = 0);
     ASSERT(R.top = -1)
 END translate;
-PROCEDURE prolog (ramSize: INTEGER);
+PROCEDURE prolog;
 VAR
     i: INTEGER;
 BEGIN
-    RTL.Init(EmitLabel, EmitWord, EmitCall, ramSize);
+    RTL.Init(EmitLabel, EmitWord, EmitCall);
     FOR i := 0 TO LEN(RTL.rtl) - 1 DO
     Op2(opMOV, incr(PC), SP);
     EmitWord(0);
     Op2(opMOV, incr(PC), HP);
     EmitWord(0);
     Op2(opMOV, imm(5A80H), dst_x(0120H, SR)); (* stop WDT *)
-    Op2(opMOV, imm(RTL.empty_proc), dst_x(RTL.int, SR));
+    Op2(opMOV, imm(RTL.empty_proc), dst_x(0, SP));
-    Op2(opMOV, imm(0), dst_x(RTL.trap, SR))
+    Op2(opMOV, imm(RTL.empty_proc), dst_x(2, SP));
 END prolog;
 PROCEDURE epilog;
 VAR
-    L1, i: INTEGER;
+    L1, i, n: INTEGER;
         END
     END;
     EmitLabel(L1);
     MovRR(SP, IR);
+    n := 0;
     FOR i := 0 TO 15 DO
+        IF i IN R.regs THEN
-        IF i IN R.regs + R.vregs THEN
+            Push(i);
-            Push(i)
+            INC(n)
         END
     END;
+    MovRR(SP, R4);
+    Op2(opADD, imm(n * 2), R4);
-    Push(IR);
-    Op1(opPUSH, IR, sINDIR);
+    Push(R4);
-    Op1(opCALL, SR, sIDX);
+    Op1(opPUSH, R4, sINDIR);
-    EmitWord(RTL.int);
+    Op1(opCALL, SR, sIDX); EmitWord(-RTL.VarSize); Reloc(RBSS); (* call int *)
     Op2(opADD, imm(4), SP);
     FOR i := 15 TO 0 BY -1 DO
-        IF i IN R.regs + R.vregs THEN
+        IF i IN R.regs THEN
 PROCEDURE CodeGen* (outname: ARRAY OF CHAR; target: INTEGER; options: PROG.OPTIONS);
 VAR
     i, adr, heap, stack, TextSize, TypesSize, bits, n, val: INTEGER;
-    Code, Data, Bss, Free: RECORD address, size: INTEGER END;
+    Code, Data, Bss: RECORD address, size: INTEGER END;
     IF ODD(rom) THEN DEC(rom) END;
     ram := MIN(MAX(ram, minRAM), maxRAM);
     rom := MIN(MAX(rom, minROM), maxROM);
-    IF IL.codes.bss > ram - minStackSize - RTL.VarSize THEN
+    IF IL.codes.bss > ram - StkReserve - RTL.VarSize THEN
         ERRORS.Error(204)
     END;
     Labels := CHL.CreateIntList();
-    FOR i := 1 TO IL.codes.lcount DO
-        CHL.PushInt(Labels, 0)
-    END;
-    FOR i := 0 TO LEN(mem) - 1 DO
-        mem[i] := 0
+    FOR i := 1 TO IL.codes.lcount DO
-    END;
+        CHL.PushInt(Labels, 0)
+    END;
-    TypesSize := CHL.Length(IL.codes.types) * 2;
     CodeList := LISTS.create(NIL);
     RelList  := LISTS.create(NIL);
-    REG.Init(R, Push, Pop, mov, xchg, NIL, NIL, {R4, R5, R6, R7}, {});
+    REG.Init(R, Push, Pop, mov, xchg, {R4, R5, R6, R7});
-    prolog(ram);
     translate;
+    prolog;
+    translate(chkSTK IN options.checking);
+    epilog;
+    TypesSize := CHL.Length(IL.codes.types) * 2;
+    Data.size := CHL.Length(IL.codes.data);
+    IF ODD(Data.size) THEN
+        CHL.PushByte(IL.codes.data, 0);
+        INC(Data.size)
+    END;
-    epilog;
+    Code.size := Fixup(0, IntVectorSize + TypesSize + Data.size);
     Code.address := 10000H - (IntVectorSize + TypesSize + Data.size + Code.size);
-    Code.address := 10000H - rom;
+    IF Code.address < 10000H - rom THEN
-    Code.size := Fixup(Code.address, IntVectorSize + TypesSize);
+        ERRORS.Error(203)
-    Data.address := Code.address + Code.size;
+    END;
-    Data.size := CHL.Length(IL.codes.data);
-    Data.size := Data.size + Data.size MOD 2;
-    TextSize  := Code.size + Data.size;
     Code.size := Fixup(Code.address, IntVectorSize + TypesSize + Data.size);
+    Data.address := Code.address + Code.size;
+    TextSize := Code.size + Data.size;
+    IF Code.address + TextSize + MAX(IL.codes.dmin - Data.size, IntVectorSize + TypesSize) > 10000H THEN
+        ERRORS.Error(203)
-    IF Code.address + TextSize + MAX(IL.codes.dmin - Data.size, IntVectorSize + TypesSize) > 10000H  THEN
+    END;
         ERRORS.Error(203)
-    END;
+    stack := RTL.ram + ram;
     Bss.size := IL.codes.bss + IL.codes.bss MOD 2;
-    Bss.address := RTL.ram + RTL.VarSize;
+    DEC(stack, Bss.size);
         adr := reloc.WordPtr.offset * 2;
         val := reloc.WordPtr.val;
         CASE reloc.section OF
         |RCODE: PutWord(LabelOffs(val) * 2, adr)
         |RDATA: PutWord(val + Data.address, adr)
-        |RBSS:  PutWord(val + Bss.address, adr)
+        |RBSS:  PutWord((val + Bss.address) MOD 65536, adr)
         END;
         reloc := reloc.next(RELOC)
     END;
     adr := Data.address;
-    FOR i := 0 TO CHL.Length(IL.codes.data) - 1 DO
+    FOR i := 0 TO Data.size - 1 DO
         mem[adr] := CHL.GetByte(IL.codes.data, i);
-        INC(adr)
-    END;
         INC(adr)
-    adr := 10000H - IntVectorSize - TypesSize;
+    END;
     FOR i := TypesSize DIV 2 - 1 TO 0 BY -1 DO
             PutWord(bits, adr);
             bits := LSL(bits, 1)
         END
     END;
-    Free.address := Code.address + TextSize;
-    Free.size := rom - (IntVectorSize + TypesSize + TextSize);
-    PutWord(Free.address, adr);
     PutWord(Free.size, adr);
     PutWord(4130H, adr); (* RET *)
     PutWord(stack, adr);
     PutWord(0001H, adr); (* bsl signature (adr 0FFBEH) *)
     FOR i := 0 TO LEN(IV) - 1 DO
+        PutWord(LabelOffs(IV[i]) * 2, adr)
-        PutWord(LabelOffs(IV[i]) * 2, adr)
+    END;
-    END;
+    INC(TextSize, IntVectorSize + TypesSize + Code.address MOD 16);
-    WR.Create(outname);
+    INC(Bss.size, StkReserve + RTL.VarSize);
     HEX.Data(mem, Code.address, TextSize);
-    HEX.Data(mem, 10000H - IntVectorSize - TypesSize, IntVectorSize + TypesSize);
-    HEX.End;
+    WR.Create(outname);
-    WR.Close;
     HEX.Data(mem, Code.address - Code.address MOD 16, TextSize);
-    INC(TextSize, IntVectorSize + TypesSize);
-    INC(Bss.size, minStackSize + RTL.VarSize);
-    C.StringLn("--------------------------------------------");
-    C.String(  "  rom:  "); C.Int(TextSize); C.String(" of "); C.Int(rom); C.String("  ("); C.Int(TextSize * 100 DIV rom); C.StringLn("%)");
+    HEX.End;
-    IF Free.size > 0 THEN
+    WR.Close;
-        C.String(  "        "); C.Int(Free.size); C.String(" bytes free (0");
             C.Hex(Free.address, 4); C.String("H..0"); C.Hex(Free.address + Free.size - 1, 4); C.StringLn("H)")
-    END;
+    C.Dashes;
-    C.Ln;
+    C.String("  rom:  "); C.Int(TextSize); C.String(" of "); C.Int(rom); C.String("  ("); C.Int(TextSize * 100 DIV rom); C.StringLn("%)");

Subversion Repositories Kolibri OS

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