Subversion Repositories Kolibri OS

(*

    BSD 2-Clause License

    Copyright (c) 2018, 2019, Anton Krotov

    All rights reserved.

*)

MODULE BIN;

IMPORT LISTS, MACHINE, CHL := CHUNKLISTS, ARITH, UTILS;

CONST

    RCODE*    = 1;

    RDATA*    = 2;

    RBSS*     = 3;

    RIMP*     = 4;

    PICCODE*  = 5;

    PICDATA*  = 6;

    PICBSS*   = 7;

    PICIMP*   = 8;

    IMPTAB*   = 9;

TYPE

    RELOC* = POINTER TO RECORD (LISTS.ITEM)

        opcode*: INTEGER;

        offset*: INTEGER

    END;

    IMPRT* = POINTER TO RECORD (LISTS.ITEM)

        nameoffs*: INTEGER;

        label*:    INTEGER;

        OriginalFirstThunk*,

        FirstThunk*: INTEGER

    END;

    EXPRT* = POINTER TO RECORD (LISTS.ITEM)

        nameoffs*: INTEGER;

        label*:    INTEGER

    END;

    PROGRAM* = POINTER TO RECORD

        code*:      CHL.BYTELIST;

        data*:      CHL.BYTELIST;

        labels:     CHL.INTLIST;

        bss*:       INTEGER;

        stack*:     INTEGER;

        vmajor*,

        vminor*:    WCHAR;

        modname*:   INTEGER;

        import*:    CHL.BYTELIST;

        export*:    CHL.BYTELIST;

        rel_list*:  LISTS.LIST;

        imp_list*:  LISTS.LIST;

        exp_list*:  LISTS.LIST

    END;

PROCEDURE create* (NumberOfLabels: INTEGER): PROGRAM;

VAR

    program:  PROGRAM;

    i:        INTEGER;

BEGIN

    NEW(program);

    program.bss := 0;

    program.labels := CHL.CreateIntList();

    FOR i := 0 TO NumberOfLabels - 1 DO

        CHL.PushInt(program.labels, 0)

    END;

    program.rel_list := LISTS.create(NIL);

    program.imp_list := LISTS.create(NIL);

    program.exp_list := LISTS.create(NIL);

    program.data   := CHL.CreateByteList();

    program.code   := CHL.CreateByteList();

    program.import := CHL.CreateByteList();

    program.export := CHL.CreateByteList()

    RETURN program

END create;

PROCEDURE SetParams* (program: PROGRAM; bss, stack: INTEGER; vmajor, vminor: WCHAR);

BEGIN

    program.bss    := bss;

    program.stack  := stack;

    program.vmajor := vmajor;

    program.vminor := vminor

END SetParams;

PROCEDURE PutReloc* (program: PROGRAM; opcode: INTEGER);

VAR

    cmd: RELOC;

BEGIN

    NEW(cmd);

    cmd.opcode := opcode;

    cmd.offset := CHL.Length(program.code);

    LISTS.push(program.rel_list, cmd)

END PutReloc;

PROCEDURE PutData* (program: PROGRAM; b: BYTE);

BEGIN

    CHL.PushByte(program.data, b)

END PutData;

PROCEDURE get32le* (array: CHL.BYTELIST; idx: INTEGER): INTEGER;

VAR

    i: INTEGER;

    x: INTEGER;

BEGIN

    x := 0;

    FOR i := 3 TO 0 BY -1 DO

        x := LSL(x, 8) + CHL.GetByte(array, idx + i)

    END;

    IF UTILS.bit_depth = 64 THEN

        x := MACHINE.Int32To64(x)

    END

    RETURN x

END get32le;

PROCEDURE put32le* (array: CHL.BYTELIST; idx: INTEGER; x: INTEGER);

VAR

    i: INTEGER;

BEGIN

    FOR i := 0 TO 3 DO

        CHL.SetByte(array, idx + i, MACHINE.Byte(x, i))

    END

END put32le;

PROCEDURE PutData32LE* (program: PROGRAM; x: INTEGER);

VAR

    i: INTEGER;

BEGIN

    FOR i := 0 TO 3 DO

        CHL.PushByte(program.data, MACHINE.Byte(x, i))

    END

END PutData32LE;

PROCEDURE PutData64LE* (program: PROGRAM; x: INTEGER);

VAR

    i: INTEGER;

BEGIN

    FOR i := 0 TO 7 DO

        CHL.PushByte(program.data, MACHINE.Byte(x, i))

    END

END PutData64LE;

PROCEDURE PutDataStr* (program: PROGRAM; s: ARRAY OF CHAR);

VAR

    i: INTEGER;

BEGIN

    i := 0;

    WHILE s[i] # 0X DO

        PutData(program, ORD(s[i]));

        INC(i)

    END

END PutDataStr;

PROCEDURE PutCode* (program: PROGRAM; b: BYTE);

BEGIN

    CHL.PushByte(program.code, b)

END PutCode;

PROCEDURE PutCode32LE* (program: PROGRAM; x: INTEGER);

VAR

    i: INTEGER;

BEGIN

    FOR i := 0 TO 3 DO

        CHL.PushByte(program.code, MACHINE.Byte(x, i))

    END

END PutCode32LE;

PROCEDURE SetLabel* (program: PROGRAM; label, offset: INTEGER);

BEGIN

    CHL.SetInt(program.labels, label, offset)

END SetLabel;

PROCEDURE Import* (program: PROGRAM; name: ARRAY OF CHAR; label: INTEGER);

VAR

    imp: IMPRT;

    i:   INTEGER;

BEGIN

    CHL.PushByte(program.import, 0);

    CHL.PushByte(program.import, 0);

    IF ODD(CHL.Length(program.import)) THEN

        CHL.PushByte(program.import, 0)

    END;

    NEW(imp);

    imp.nameoffs := CHL.Length(program.import);

    imp.label := label;

    LISTS.push(program.imp_list, imp);

    i := 0;

    WHILE name[i] # 0X DO

        CHL.PushByte(program.import, ORD(name[i]));

        INC(i)

    END;

    CHL.PushByte(program.import, 0)

END Import;

PROCEDURE less (bytes: CHL.BYTELIST; a, b: EXPRT): BOOLEAN;

VAR

    i, j: INTEGER;

BEGIN

    i := a.nameoffs;

    j := b.nameoffs;

    WHILE (CHL.GetByte(bytes, i) # 0) & (CHL.GetByte(bytes, j) # 0) &

          (CHL.GetByte(bytes, i) = CHL.GetByte(bytes, j)) DO

        INC(i);

        INC(j)

    END

    RETURN CHL.GetByte(bytes, i) < CHL.GetByte(bytes, j)

END less;

PROCEDURE Export* (program: PROGRAM; name: ARRAY OF CHAR; label: INTEGER);

VAR

    exp, cur: EXPRT;

    i: INTEGER;

BEGIN

    NEW(exp);

    exp.nameoffs := CHL.Length(program.export);

    exp.label := CHL.GetInt(program.labels, label);

    i := 0;

    WHILE name[i] # 0X DO

        CHL.PushByte(program.export, ORD(name[i]));

        INC(i)

    END;

    CHL.PushByte(program.export, 0);

    cur := program.exp_list.first(EXPRT);

    WHILE (cur # NIL) & less(program.export, cur, exp) DO

        cur := cur.next(EXPRT)

    END;

    IF cur # NIL THEN

        IF cur.prev # NIL THEN

            LISTS.insert(program.exp_list, cur.prev, exp)

        ELSE

            LISTS.insertL(program.exp_list, cur, exp)

        END

    ELSE

        LISTS.push(program.exp_list, exp)

    END

END Export;

PROCEDURE GetIProc* (program: PROGRAM; n: INTEGER): IMPRT;

VAR

    import: IMPRT;

    res:    IMPRT;

BEGIN

    import  := program.imp_list.first(IMPRT);

    res := NIL;

    WHILE (import # NIL) & (n >= 0) DO

        IF import.label # 0 THEN

            res := import;

            DEC(n)

        END;

        import := import.next(IMPRT)

    END;

    ASSERT(n = -1)

    RETURN res

END GetIProc;

PROCEDURE GetLabel* (program: PROGRAM; label: INTEGER): INTEGER;

    RETURN CHL.GetInt(program.labels, label)

END GetLabel;

PROCEDURE NewLabel* (program: PROGRAM);

BEGIN

    CHL.PushInt(program.labels, 0)

END NewLabel;

PROCEDURE fixup* (program: PROGRAM);

VAR

    rel:    RELOC;

    imp:    IMPRT;

    nproc:  INTEGER;

    L:      INTEGER;

BEGIN

    nproc := 0;

    imp := program.imp_list.first(IMPRT);

    WHILE imp # NIL DO

        IF imp.label # 0 THEN

            CHL.SetInt(program.labels, imp.label, nproc);

            INC(nproc)

        END;

        imp := imp.next(IMPRT)

    END;

    rel := program.rel_list.first(RELOC);

    WHILE rel # NIL DO

        IF rel.opcode IN {RIMP, PICIMP} THEN

            L := get32le(program.code, rel.offset);

            put32le(program.code, rel.offset, GetLabel(program, L))

        END;

        rel := rel.next(RELOC)

    END

END fixup;

PROCEDURE InitArray* (VAR array: ARRAY OF BYTE; VAR idx: INTEGER; hex: ARRAY OF CHAR);

VAR

    i, k: INTEGER;

    PROCEDURE hexdgt (dgt: CHAR): INTEGER;

    VAR

        res: INTEGER;

    BEGIN

        IF dgt < "A" THEN

            res := ORD(dgt) - ORD("0")

        ELSE

            res := ORD(dgt) - ORD("A") + 10

        END

        RETURN res

    END hexdgt;

BEGIN

    k := LENGTH(hex);

    ASSERT(~ODD(k));

    k := k DIV 2;

    FOR i := 0 TO k - 1 DO

        array[i + idx] := hexdgt(hex[2 * i]) * 16 + hexdgt(hex[2 * i + 1])

    END;

    idx := idx + k

END InitArray;

END BIN.