Subversion Repositories Kolibri OS

(*

    BSD 2-Clause License

    Copyright (c) 2019-2020, Anton Krotov

    All rights reserved.

*)

MODULE MSP430;

IMPORT IL, LISTS, REG, CHL := CHUNKLISTS, ERRORS, WR := WRITER, HEX,

       UTILS, C := CONSOLE, PROG, RTL := MSP430RTL;

CONST

    minRAM* = 128;  maxRAM* = 2048;

    minROM* = 2048; maxROM* = 24576;

    minStackSize = 64;

    IntVectorSize* = RTL.IntVectorSize;

    PC = 0; SP = 1; SR = 2; CG = 3;

    R4 = 4; R5 = 5; R6 = 6; R7 = 7;

    HP = 14; IR = 15;

    ACC = R4;

    opRRC  = 1000H;  opSWPB = 1080H;  opRRA  = 1100H;  opSXT = 1180H;

    opPUSH = 1200H;  opCALL = 1280H;  opRETI = 1300H;

    opMOV = 04000H;  opADD = 05000H;  opADDC = 06000H;  opSUBC = 07000H;

    opSUB = 08000H;  opCMP = 09000H;  opDADD = 0A000H;  opBIT  = 0B000H;

    opBIC = 0C000H;  opBIS = 0D000H;  opXOR  = 0E000H;  opAND  = 0F000H;

    opJNE = 2000H;  opJEQ = 2400H;  opJNC = 2800H;  opJC  = 2C00H;

    opJN  = 3000H;  opJGE = 3400H;  opJL  = 3800H;  opJMP = 3C00H;

    sREG = 0; sIDX = 16; sINDIR = 32; sINCR = 48; BW = 64; dIDX = 128;

    NOWORD = 10000H;

    RCODE = 0; RDATA = 1; RBSS = 2;

    je  = 0;  jne = je  + 1;

    jge = 2;  jl  = jge + 1;

    jle = 4;  jg  = jle + 1;

    jb  = 6;

TYPE

    ANYCODE = POINTER TO RECORD (LISTS.ITEM)

        offset: INTEGER

    END;

    WORD = POINTER TO RECORD (ANYCODE)

        val: INTEGER

    END;

    LABEL = POINTER TO RECORD (ANYCODE)

        num: INTEGER

    END;

    JMP = POINTER TO RECORD (ANYCODE)

        cc, label: INTEGER;

        short: BOOLEAN

    END;

    CALL = POINTER TO RECORD (ANYCODE)

        label: INTEGER

    END;

    COMMAND = IL.COMMAND;

    RELOC = POINTER TO RECORD (LISTS.ITEM)

        section: INTEGER;

        WordPtr: WORD

    END;

VAR

    R: REG.REGS;

    CodeList: LISTS.LIST;

    RelList:  LISTS.LIST;

    mem: ARRAY 65536 OF BYTE;

    Labels: CHL.INTLIST;

    IV: ARRAY RTL.LenIV OF INTEGER;

    IdxWords: RECORD src, dst: INTEGER END;

    StkCnt: INTEGER;

PROCEDURE EmitLabel (L: INTEGER);

VAR

    label: LABEL;

BEGIN

    NEW(label);

    label.num := L;

    LISTS.push(CodeList, label)

END EmitLabel;

PROCEDURE EmitWord (val: INTEGER);

VAR

    word: WORD;

BEGIN

    IF val < 0 THEN

        ASSERT(val >= -32768);

        val := val MOD 65536

    ELSE

        ASSERT(val <= 65535)

    END;

    NEW(word);

    word.val := val;

    LISTS.push(CodeList, word)

END EmitWord;

PROCEDURE EmitJmp (cc, label: INTEGER);

VAR

    jmp: JMP;

BEGIN

    NEW(jmp);

    jmp.cc := cc;

    jmp.label := label;

    jmp.short := FALSE;

    LISTS.push(CodeList, jmp)

END EmitJmp;

PROCEDURE EmitCall (label: INTEGER);

VAR

    call: CALL;

BEGIN

    NEW(call);

    call.label := label;

    LISTS.push(CodeList, call)

END EmitCall;

PROCEDURE bw (b: BOOLEAN): 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

        res := Rn * 256 + sINDIR

    ELSE

        IdxWords.src := x;

        res := Rn * 256 + sIDX

    END

    RETURN res

END src_x;

PROCEDURE dst_x (x, Rn: INTEGER): INTEGER;

BEGIN

    IdxWords.dst := x

    RETURN Rn + dIDX

END dst_x;

PROCEDURE indir (Rn: INTEGER): INTEGER;

    RETURN Rn * 256 + sINDIR

END indir;

PROCEDURE incr (Rn: INTEGER): INTEGER;

    RETURN Rn * 256 + sINCR

END incr;

PROCEDURE imm (x: INTEGER): INTEGER;

VAR

    res: INTEGER;

BEGIN

    CASE x OF

    | 0: res := CG * 256

    | 1: res := CG * 256 + sIDX

    | 2: res := indir(CG)

    | 4: res := indir(SR)

    | 8: res := incr(SR)

    |-1: res := incr(CG)

    ELSE

        res := incr(PC);

        IdxWords.src := x

    END

    RETURN res

END imm;

PROCEDURE Op2 (op, src, dst: INTEGER);

BEGIN

    ASSERT(BITS(op) - {6, 12..15} = {});

    ASSERT(BITS(src) - {4, 5, 8..11} = {});

    ASSERT(BITS(dst) - {0..3, 7} = {});

    EmitWord(op + src + dst);

    IF IdxWords.src # NOWORD THEN

        EmitWord(IdxWords.src);

        IdxWords.src := NOWORD

    END;

    IF IdxWords.dst # NOWORD THEN

        EmitWord(IdxWords.dst);

        IdxWords.dst := NOWORD

    END

END Op2;

PROCEDURE Op1 (op, reg, As: INTEGER);

BEGIN

    EmitWord(op + reg + As)

END Op1;

PROCEDURE MovRR (src, dst: INTEGER);

BEGIN

    Op2(opMOV, src * 256, dst)

END MovRR;

PROCEDURE PushImm (imm: INTEGER);

BEGIN

    imm := UTILS.Long(imm);

    CASE imm OF

    | 0: Op1(opPUSH, CG, sREG)

    | 1: Op1(opPUSH, CG, sIDX)

    | 2: Op1(opPUSH, CG, sINDIR)

    |-1: Op1(opPUSH, CG, sINCR)

    ELSE

        Op1(opPUSH, PC, sINCR);

        EmitWord(imm)

    END;

    INC(StkCnt)

END PushImm;

PROCEDURE PutWord (word: INTEGER; VAR adr: INTEGER);

BEGIN

    ASSERT(~ODD(adr));

    ASSERT((0 <= word) & (word <= 65535));

    mem[adr] := word MOD 256;

    mem[adr + 1] := word DIV 256;

    INC(adr, 2)

END PutWord;

PROCEDURE NewLabel (): INTEGER;

BEGIN

    CHL.PushInt(Labels, 0)