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

 (*
     BSD 2-Clause License
-    Copyright (c) 2019, Anton Krotov
+    Copyright (c) 2019-2020, Anton Krotov
     All rights reserved.
 *)
 MODULE MSP430;
-IMPORT IL, LISTS, REG, CHL := CHUNKLISTS, ERRORS, FILES, WRITER,
+IMPORT IL, LISTS, REG, CHL := CHUNKLISTS, ERRORS, WR := WRITER, HEX,
        UTILS, C := CONSOLE, PROG, RTL := MSP430RTL;
 CONST
-    minRAM* = 128;  maxRAM* = 10240;
+    minRAM* = 128;  maxRAM* = 2048;
-    minROM* = 2048; maxROM* = 49152;
+    minROM* = 2048; maxROM* = 24576;
     minStackSize = 64;
     IV: ARRAY RTL.LenIV OF INTEGER;
+    IdxWords: RECORD src, dst: INTEGER END;
-    IdxWords: RECORD src, dst: INTEGER END;
+    StkCnt: INTEGER;
     RETURN BW * ORD(b)
 END bw;
+PROCEDURE src_x (x, Rn: INTEGER): INTEGER;
+VAR
     res: INTEGER;
+BEGIN
+    IF (x = 0) & ~(Rn IN {PC, SR, CG}) THEN
-PROCEDURE src_x (x, Rn: INTEGER): INTEGER;
+        res := Rn * 256 + sINDIR
-BEGIN
+    ELSE
+        IdxWords.src := x;
+        res := Rn * 256 + sIDX
+    END
     IdxWords.src := x
-    RETURN Rn * 256 + sIDX
+    RETURN res
 END src_x;
     res: INTEGER;
 BEGIN
     CASE x OF
     | 0: res := CG * 256
-    | 1: res := src_x(0, CG); IdxWords.src := NOWORD
+    | 1: res := CG * 256 + sIDX
     | 2: res := indir(CG)
     | 4: res := indir(SR)
     | 8: res := incr(SR)
     |-1: res := incr(CG)
 END imm;
 PROCEDURE Op2 (op, src, dst: INTEGER);
 BEGIN
-    ASSERT(BITS(op) + {6, 12..15} = {6, 12..15});
+    ASSERT(BITS(op) - {6, 12..15} = {});
-    ASSERT(BITS(src) + {4, 5, 8..11} = {4, 5, 8..11});
+    ASSERT(BITS(src) - {4, 5, 8..11} = {});
-    ASSERT(BITS(dst) + {0..3, 7} = {0..3, 7});
+    ASSERT(BITS(dst) - {0..3, 7} = {});
     | 2: Op1(opPUSH, CG, sINDIR)
     |-1: Op1(opPUSH, CG, sINCR)
     ELSE
         Op1(opPUSH, PC, sINCR);
         EmitWord(imm)
-    END
+    END;
+    INC(StkCnt)
 END PushImm;
 END Fixup;
 PROCEDURE Push (reg: INTEGER);
+BEGIN
-BEGIN
+    Op1(opPUSH, reg, sREG);
-    Op1(opPUSH, reg, sREG)
+    INC(StkCnt)
 END Push;
 PROCEDURE Pop (reg: INTEGER);
-PROCEDURE Pop (reg: INTEGER);
+BEGIN
-BEGIN
+    Op2(opMOV, incr(SP), reg);
 PROCEDURE CallRTL (proc, params: INTEGER);
 BEGIN
     EmitCall(RTL.rtl[proc].label);
     RTL.Used(proc);
     IF params > 0 THEN
-        Op2(opADD, imm(params * 2), SP)
+        Op2(opADD, imm(params * 2), SP);
+        DEC(StkCnt, params)
     END
 END CallRTL;
     Op2(opXOR, imm(-1), reg);
     Op2(opADD, imm(1), reg)
 END Neg;
+PROCEDURE LocalOffset (offset: INTEGER): INTEGER;
+    RETURN (offset + StkCnt - ORD(offset > 0)) * 2
+END LocalOffset;
+PROCEDURE LocalDst (offset: INTEGER): INTEGER;
+    RETURN dst_x(LocalOffset(offset), SP)
+END LocalDst;
+PROCEDURE LocalSrc (offset: INTEGER): INTEGER;
+    RETURN src_x(LocalOffset(offset), SP)
+END LocalSrc;
 PROCEDURE translate;
 VAR
     cmd, next: COMMAND;
         |IL.opLABEL:
             EmitLabel(param1)
         |IL.opSADR_PARAM:
+            Op1(opPUSH, PC, sINCR);
-            Op1(opPUSH, PC, sINCR);
+            INC(StkCnt);
             EmitWord(param2);
             Reloc(RDATA)
         |IL.opERR:
             CallRTL(RTL._error, 2)
+        |IL.opPUSHC:
+            PushImm(param2)
+        |IL.opONERR:
             PushImm(param2);
-        |IL.opPUSHC:
+            DEC(StkCnt);
-            PushImm(param2)
+            EmitJmp(opJMP, param1)
-        |IL.opLEAVEC:
+        |IL.opLEAVEC:
             Pop(PC)
-        |IL.opENTER:
-            ASSERT(R.top = -1);
             EmitLabel(param1);
         |IL.opENTER:
-            Push(BP);
+            ASSERT(R.top = -1);
-            MovRR(SP, BP);
+            StkCnt := 0;
             EmitLabel(param1);
                     ASSERT(REG.Exchange(R, reg1, ACC));
                     drop
                 END;
                 drop
             END;
             ASSERT(R.top = -1);
+            ASSERT(StkCnt = param1);
             IF param1 > 0 THEN
-                MovRR(BP, SP)
+                Op2(opADD, imm(param1 * 2), SP)
             END;
-            Pop(BP);
             Pop(PC)
         |IL.opRES:
             ASSERT(R.top = -1);
             GetRegA
         |IL.opCLEANUP:
+            IF param2 # 0 THEN
-            IF param2 # 0 THEN
+                Op2(opADD, imm(param2 * 2), SP);
-                Op2(opADD, imm(param2 * 2), SP)
+                DEC(StkCnt, param2)
             END
             EmitWord(param2);
             Reloc(RBSS)
         |IL.opLADR:
+            reg1 := GetAnyReg();
-            reg1 := GetAnyReg();
+            n := LocalOffset(param2);
+            Op2(opMOV, SP * 256, reg1);
-            MovRR(BP, reg1);
+            IF n # 0 THEN
+                Op2(opADD, imm(n), reg1)
-            Op2(opADD, imm(param2 * 2), reg1)
+            END
         |IL.opLLOAD8:
-            Op2(opMOV + BW, src_x(param2 * 2, BP), GetAnyReg())
+            Op2(opMOV + BW, LocalSrc(param2), GetAnyReg())
         |IL.opLLOAD16, IL.opVADR:
-            Op2(opMOV, src_x(param2 * 2, BP), GetAnyReg())
+            Op2(opMOV, LocalSrc(param2), GetAnyReg())
             UnOp(reg1);
             Op2(opMOV, indir(reg1), reg1)
         |IL.opVLOAD8:
             reg1 := GetAnyReg();
-            Op2(opMOV, src_x(param2 * 2, BP), reg1);
+            Op2(opMOV, LocalSrc(param2), reg1);
             Op2(opMOV + BW, indir(reg1), reg1)
         |IL.opVLOAD16:
             reg1 := GetAnyReg();
-            Op2(opMOV, src_x(param2 * 2, BP), reg1);
+            Op2(opMOV, LocalSrc(param2), reg1);
             Op2(opMOV, indir(reg1), reg1)
             UnOp(reg1);
             IF param2 # 0 THEN
                 Op2(opSUB, imm(param2), reg1)
             END;
             IF opcode = IL.opSUBL THEN
-                reg2 := GetAnyReg();
-                Clear(reg2);
+                Neg(reg1)
-                Op2(opSUB, reg1 * 256, reg2);
-                drop;
-                drop;
-                ASSERT(REG.GetReg(R, reg2))
             END
         |IL.opLADR_SAVEC:
-            Op2(opMOV, imm(param2), dst_x(param1 * 2, BP))
+            Op2(opMOV, imm(param2), LocalDst(param1))
         |IL.opLADR_SAVE:
             UnOp(reg1);
-            Op2(opMOV, reg1 * 256, dst_x(param2 * 2, BP));
+            Op2(opMOV, reg1 * 256, LocalDst(param2));
             drop
                 Op2(opCMP, imm(param2), reg1)
             END;
             drop;
+            cc := cond(opcode);
-            cc := cond(opcode);
+            next := cmd.next(COMMAND);
-            IF cmd.next(COMMAND).opcode = IL.opJE THEN
-                label := cmd.next(COMMAND).param1;
+            IF next.opcode = IL.opJE THEN
-                jcc(cc, label);
-                cmd := cmd.next(COMMAND)
+                jcc(cc, next.param1);
-            ELSIF cmd.next(COMMAND).opcode = IL.opJNE THEN
+                cmd := next
-                label := cmd.next(COMMAND).param1;
+            ELSIF next.opcode = IL.opJNE THEN
-                jcc(ORD(BITS(cc) / {0}), label);
-                cmd := cmd.next(COMMAND)
+                jcc(ORD(BITS(cc) / {0}), next.param1);
                 cmd := next
             ELSE
                 setcc(cc, GetAnyReg())
         |IL.opCHKIDX2:
             BinOp(reg1, reg2);
             IF param2 # -1 THEN
-                Op2(opCMP, reg1 * 256, reg2);
-                MovRR(reg2, reg1);
-                drop;
+                Op2(opCMP, reg1 * 256, reg2);
                 jcc(jb, param1)
-            ELSE
+            END;
-                INCL(R.regs, reg1);
+            INCL(R.regs, reg1);
-                DEC(R.top);
+            DEC(R.top);
-                R.stk[R.top] := reg2
-            END
+            R.stk[R.top] := reg2
         |IL.opINCC, IL.opINCCB:
             UnOp(reg1);
             Op2(opSUB + bw(opcode = IL.opDECB), reg1 * 256, dst_x(0, reg2));
             drop;
             drop
         |IL.opLADR_INCC, IL.opLADR_INCCB:
-            Op2(opADD + bw(opcode = IL.opLADR_INCCB), imm(param2), dst_x(param1 * 2, BP))
+            Op2(opADD + bw(opcode = IL.opLADR_INCCB), imm(param2), LocalDst(param1))
         |IL.opLADR_DECCB:
-            Op2(opSUB + BW, imm(param2), dst_x(param1 * 2, BP))
+            Op2(opSUB + BW, imm(param2), LocalDst(param1))
         |IL.opLADR_INC, IL.opLADR_INCB:
             UnOp(reg1);
-            Op2(opADD + bw(opcode = IL.opLADR_INCB), reg1 * 256, dst_x(param2 * 2, BP));
+            Op2(opADD + bw(opcode = IL.opLADR_INCB), reg1 * 256, LocalDst(param2));
             drop
         |IL.opLADR_DEC, IL.opLADR_DECB:
             UnOp(reg1);
-            Op2(opSUB + bw(opcode = IL.opLADR_DECB), reg1 * 256, dst_x(param2 * 2, BP));
+            Op2(opSUB + bw(opcode = IL.opLADR_DECB), reg1 * 256, LocalDst(param2));
         |IL.opTYPEGD:
             UnOp(reg1);
             PushAll(0);
+            Op1(opPUSH, reg1, sIDX);
-            Op1(opPUSH, reg1, sIDX);
+            INC(StkCnt);
             EmitWord(-2);
             PushImm(param2);
             CallRTL(RTL._guardrec, 2);
         |IL.opLENGTH:
             PushAll(2);
             CallRTL(RTL._length, 2);
             GetRegA
-        |IL.opMIN:
+        |IL.opMAX,IL.opMIN:
             BinOp(reg1, reg2);
             Op2(opCMP, reg2 * 256, reg1);
-            EmitWord(opJL + 1); (* jl L *)
-            MovRR(reg2, reg1);
+            IF opcode = IL.opMIN THEN
-                                (* L: *)
+                cc := opJL + 1
-            drop
+            ELSE
-        |IL.opMAX:
+                cc := opJGE + 1
-            BinOp(reg1, reg2);
-            Op2(opCMP, reg2 * 256, reg1);
+            END;
-            EmitWord(opJGE + 1); (* jge L *)
+            EmitWord(cc);        (* jge/jl L *)
             MovRR(reg2, reg1);
                                  (* L: *)
             drop
-        |IL.opMINC:
+        |IL.opMAXC, IL.opMINC:
             UnOp(reg1);
-            Op2(opCMP, imm(param2), reg1);
-            L := NewLabel();
+            Op2(opCMP, imm(param2), reg1);
-            jcc(jl, L);
+            L := NewLabel();
-            Op2(opMOV, imm(param2), reg1);
-            EmitLabel(L)
+            IF opcode = IL.opMINC THEN
+                cc := jl
-        |IL.opMAXC:
-            UnOp(reg1);
+            ELSE
-            Op2(opCMP, imm(param2), reg1);
+                cc := jge
-            L := NewLabel();
+            END;
-            jcc(jge, L);
+            jcc(cc, L);
             Op2(opMOV, imm(param2), reg1);
             EmitLabel(L)
         |IL.opSBOOLC:
             UnOp(reg1);
             Op2(opMOV + BW, imm(param2), dst_x(0, reg1));
             drop
-        |IL.opODD:
-            UnOp(reg1);
-            Op2(opAND, imm(1), reg1)
         |IL.opEQS .. IL.opGES:
             PushAll(4);
             PushImm((opcode - IL.opEQS) * 12);
             CallRTL(RTL._strcmp, 5);
         |IL.opSAVES:
             UnOp(reg1);
             PushAll_1;
+            Op1(opPUSH, PC, sINCR);
-            Op1(opPUSH, PC, sINCR);
+            INC(StkCnt);
             EmitWord(param2);
             Reloc(RDATA);
             Push(reg1);
             drop;
             ELSIF opcode = IL.opNEP THEN
                 setcc(jne, reg1)
             END
         |IL.opVADR_PARAM:
-            Op1(opPUSH, BP, sIDX);
+            reg1 := GetAnyReg();
+            Op2(opMOV, LocalSrc(param2), reg1);
+            Push(reg1);
-            EmitWord(param2 * 2)
+            drop
         |IL.opNEW:
             PushAll(1);
             PushAll(2);
             CallRTL(RTL._excl, 2)
         |IL.opLADR_INCL, IL.opLADR_EXCL:
             PushAll(1);
+            MovRR(SP, ACC);
+            n := LocalOffset(param2);
-            MovRR(BP, ACC);
+            IF n # 0 THEN
+                Op2(opADD, imm(n), ACC)
-            Op2(opADD, imm(param2 * 2), ACC);
+            END;
             Push(ACC);
             IF opcode = IL.opLADR_INCL THEN
                 CallRTL(RTL._incl, 2)
             ELSIF opcode = IL.opLADR_EXCL THEN
                 CallRTL(RTL._excl, 2)
             END
         |IL.opLADR_INCLC:
-            Op2(opBIS, imm(ORD({param2})), dst_x(param1 * 2, BP))
+            Op2(opBIS, imm(ORD({param2})), LocalDst(param1))
         |IL.opLADR_EXCLC:
-            Op2(opBIC, imm(ORD({param2})), dst_x(param1 * 2, BP))
+            Op2(opBIC, imm(ORD({param2})), LocalDst(param1))
     RTL.Gen
-END epilog;
-PROCEDURE hexdgt (n: BYTE): BYTE;
-BEGIN
-    IF n < 10 THEN
-        n := n + ORD("0")
-    ELSE
-        n := n - 10 + ORD("A")
-    END
-    RETURN n
-END hexdgt;
-PROCEDURE WriteHexByte (file: FILES.FILE; byte: BYTE);
-BEGIN
-    WRITER.WriteByte(file, hexdgt(byte DIV 16));
-    WRITER.WriteByte(file, hexdgt(byte MOD 16));
-END WriteHexByte;
-PROCEDURE WriteHex (file: FILES.FILE; mem: ARRAY OF BYTE; idx, cnt: INTEGER);
-VAR
-    i, len, chksum: INTEGER;
-BEGIN
-    WHILE cnt > 0 DO
-        len := MIN(cnt, 16);
-        chksum := len + idx DIV 256 + idx MOD 256;
-        WRITER.WriteByte(file, ORD(":"));
-        WriteHexByte(file, len);
-        WriteHexByte(file, idx DIV 256);
-        WriteHexByte(file, idx MOD 256);
-        WriteHexByte(file, 0);
-        FOR i := 1 TO len DO
-            WriteHexByte(file, mem[idx]);
-            INC(chksum, mem[idx]);
-            INC(idx)
-        END;
-        WriteHexByte(file, (-chksum) MOD 256);
-        DEC(cnt, len);
-        WRITER.WriteByte(file, 0DH);
-        WRITER.WriteByte(file, 0AH)
-    END
-END WriteHex;
+END epilog;
 PROCEDURE CodeGen* (outname: ARRAY OF CHAR; target: INTEGER; options: PROG.OPTIONS);
 VAR
     i, adr, heap, stack, TextSize, TypesSize, bits, n: INTEGER;
     Code, Data, Bss, Free: RECORD address, size: INTEGER END;
     ram, rom: INTEGER;
     Code.address := 10000H - rom;
     Code.size := Fixup(Code.address, IntVectorSize + TypesSize);
     Data.address := Code.address + Code.size;
     Data.size := CHL.Length(IL.codes.data);
-    Data.size := Data.size + ORD(ODD(Data.size));
+    Data.size := Data.size + Data.size MOD 2;
     TextSize  := Code.size + Data.size;
     IF Code.address + TextSize + MAX(IL.codes.dmin - Data.size, IntVectorSize + TypesSize) > 10000H  THEN
         ERRORS.Error(203)
     END;
     Bss.address := RTL.ram + RTL.VarSize;
-    Bss.size := IL.codes.bss + ORD(ODD(IL.codes.bss));
+    Bss.size := IL.codes.bss + IL.codes.bss MOD 2;
     heap := Bss.address + Bss.size;
     stack := RTL.ram + ram;
     PutWord(Free.address, adr);
     PutWord(Free.size, adr);
     PutWord(4130H, adr); (* RET *)
+    PutWord(stack, adr);
-    PutWord(stack, adr);
+    PutWord(0001H, adr); (* bsl signature (adr 0FFBEH) *)
     FOR i := 0 TO LEN(IV) - 1 DO
         PutWord(LabelOffs(IV[i]) * 2, adr)
+    END;
-    END;
+    file := WR.Create(outname);
-    file := FILES.create(outname);
-    WriteHex(file, mem, Code.address, TextSize);
-    WriteHex(file, mem, 10000H - IntVectorSize - TypesSize, IntVectorSize + TypesSize);
-    WRITER.WriteByte(file, ORD(":"));
-    WriteHexByte(file, 0);
-    WriteHexByte(file, 0);
-    WriteHexByte(file, 0);
-    WriteHexByte(file, 1);
-    WriteHexByte(file, 255);
+    HEX.Data(file, mem, Code.address, TextSize);
-    WRITER.WriteByte(file, 0DH);
+    HEX.Data(file, mem, 10000H - IntVectorSize - TypesSize, IntVectorSize + TypesSize);
-    WRITER.WriteByte(file, 0AH);
+    HEX.End(file);
     IF Free.size > 0 THEN
         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.Ln;
-    C.String(  "  ram:  "); C.Int(Bss.size); C.String(" of "); C.Int(ram); C.String("  ("); C.Int(Bss.size * 100 DIV ram); C.StringLn("%)");
+    C.String(  "  ram:  "); C.Int(Bss.size); C.String(" of "); C.Int(ram); C.String("  ("); C.Int(Bss.size * 100 DIV ram); C.StringLn("%)")
-    C.StringLn("--------------------------------------------")
 END CodeGen;

Subversion Repositories Kolibri OS

(root)/programs/develop/oberon07/Source/MSP430.ob07 – Rev 7696 → 7983