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


﻿(*
    BSD 2-Clause License
 
    Copyright (c) 2018-2021, Anton Krotov
    All rights reserved.
*)
 
MODULE AMD64;
 
IMPORT IL, BIN, WR := WRITER, CHL := CHUNKLISTS, LISTS, PATHS, PROG, TARGETS,
       REG, UTILS, S := STRINGS, PE32, ELF, X86, ERRORS;
 
 
CONST
 
    rax = REG.R0;
    r10 = REG.R10;
    r11 = REG.R11;
 
    rcx = REG.R1;
    rdx = REG.R2;
    r8  = REG.R8;
    r9  = REG.R9;
 
    rsp = 4;
    rbp = 5;
    rsi = 6;
    rdi = 7;
 
    MAX_XMM = 5;
 
    je = 84H; jne = 85H; jl = 8CH; jge = 8DH; jle = 8EH; jg = 8FH; jb = 82H;
 
    sete = 94H; setne = 95H; setl = 9CH; setge = 9DH; setle = 9EH; setg = 9FH; setc = 92H; setnc = 93H;
 
    shl = IL.opLSL2; shr = IL.opLSR2; sar = IL.opASR2; ror = IL.opROR2;
 
    sCODE = BIN.PICCODE;
    sDATA = BIN.PICDATA;
    sBSS  = BIN.PICBSS;
    sIMP  = BIN.PICIMP;
 
    FPR_ERR = 41;
 
 
TYPE
 
    COMMAND = IL.COMMAND;
 
    Number = POINTER TO RECORD (LISTS.ITEM) value: INTEGER END;
 
    OPRR = PROCEDURE (reg1, reg2: INTEGER);
 
 
VAR
 
    R: REG.REGS;
 
    Numbers: LISTS.LIST;
    Numbers_Count: INTEGER;
    Numbers_Offs: INTEGER;
 
    prog: BIN.PROGRAM;
 
    tcount: INTEGER;
 
    dllret, sofinit: INTEGER;
 
    Win64RegPar: ARRAY 4 OF INTEGER;
    SystemVRegPar: ARRAY 6 OF INTEGER;
 
    Xmm: ARRAY 1000 OF INTEGER;
 
    fname: PATHS.PATH;
 
 
PROCEDURE OutByte (b: BYTE);
BEGIN
    X86.OutByte(b)
END OutByte;
 
 
PROCEDURE OutByte2 (a, b: BYTE);
BEGIN
    X86.OutByte(a);
    X86.OutByte(b)
END OutByte2;
 
 
PROCEDURE OutByte3 (a, b, c: BYTE);
BEGIN
    X86.OutByte(a);
    X86.OutByte(b);
    X86.OutByte(c)
END OutByte3;
 
 
PROCEDURE OutInt (n: INTEGER);
BEGIN
    X86.OutByte(n MOD 256);
    X86.OutByte(UTILS.Byte(n, 1));
    X86.OutByte(UTILS.Byte(n, 2));
    X86.OutByte(UTILS.Byte(n, 3))
END OutInt;
 
 
PROCEDURE short (n: INTEGER): INTEGER;
    RETURN 2 * ORD(X86.isByte(n))
END short;
 
 
PROCEDURE long (n: INTEGER): INTEGER;
    RETURN 40H * ORD(~X86.isByte(n))
END long;
 
 
PROCEDURE OutIntByte (n: INTEGER);
BEGIN
    IF X86.isByte(n) THEN
        OutByte(n MOD 256)
    ELSE
        OutInt(n)
    END
END OutIntByte;
 
 
PROCEDURE isLong (n: INTEGER): BOOLEAN;
    RETURN (n > UTILS.max32) OR (n < UTILS.min32)
END isLong;
 
 
PROCEDURE NewNumber (value: INTEGER);
VAR
    number: Number;
 
BEGIN
    NEW(number);
    number.value := value;
    LISTS.push(Numbers, number);
    INC(Numbers_Count)
END NewNumber;
 
 
PROCEDURE NewLabel (): INTEGER;
BEGIN
    BIN.NewLabel(prog)
    RETURN IL.NewLabel()
END NewLabel;
 
 
PROCEDURE Rex (reg1, reg2: INTEGER);
BEGIN
    OutByte(48H + reg1 DIV 8 + 4 * (reg2 DIV 8))
END Rex;
 
 
PROCEDURE lea (reg, offset, section: INTEGER);
BEGIN
    Rex(0, reg);
    OutByte2(8DH, 05H + 8 * (reg MOD 8)); (* lea reg, [rip + offset] *)
    X86.Reloc(section, offset)
END lea;
 
 
PROCEDURE oprr (op: BYTE; reg1, reg2: INTEGER); (* op reg1, reg2 *)
BEGIN
    Rex(reg1, reg2);
    OutByte2(op, 0C0H + 8 * (reg2 MOD 8) + reg1 MOD 8)
END oprr;
 
 
PROCEDURE oprr2 (op1, op2: BYTE; reg1, reg2: INTEGER); (* op reg1, reg2 *)
BEGIN
    Rex(reg1, reg2);
    OutByte3(op1, op2, 0C0H + 8 * (reg2 MOD 8) + reg1 MOD 8)
END oprr2;
 
 
PROCEDURE mov (reg1, reg2: INTEGER); (* mov reg1, reg2 *)
BEGIN
    oprr(89H, reg1, reg2)
END mov;
 
 
PROCEDURE xor (reg1, reg2: INTEGER); (* xor reg1, reg2 *)
BEGIN
    oprr(31H, reg1, reg2)
END xor;
 
 
PROCEDURE and (reg1, reg2: INTEGER); (* and reg1, reg2 *)
BEGIN
    oprr(21H, reg1, reg2)
END and;
 
 
PROCEDURE _or (reg1, reg2: INTEGER); (* or reg1, reg2 *)
BEGIN
    oprr(09H, reg1, reg2)
END _or;
 
 
PROCEDURE add (reg1, reg2: INTEGER); (* add reg1, reg2 *)
BEGIN
    oprr(01H, reg1, reg2)
END add;
 
 
PROCEDURE sub (reg1, reg2: INTEGER); (* sub reg1, reg2 *)
BEGIN
    oprr(29H, reg1, reg2)
END sub;
 
 
PROCEDURE xchg (reg1, reg2: INTEGER); (* xchg reg1, reg2 *)
BEGIN
    IF rax IN {reg1, reg2} THEN
        Rex(reg1 + reg2, 0);
        OutByte(90H + (reg1 + reg2) MOD 8)
    ELSE
        oprr(87H, reg1, reg2)
    END
END xchg;
 
 
PROCEDURE cmprr (reg1, reg2: INTEGER);  (* cmp reg1, reg2 *)
BEGIN
    oprr(39H, reg1, reg2)
END cmprr;
 
 
PROCEDURE pop (reg: INTEGER); (* pop reg *)
BEGIN
    IF reg >= 8 THEN
        OutByte(41H)
    END;
    OutByte(58H + reg MOD 8)
END pop;
 
 
PROCEDURE push (reg: INTEGER); (* push reg *)
BEGIN
    IF reg >= 8 THEN
        OutByte(41H)
    END;
    OutByte(50H + reg MOD 8)
END push;
 
 
PROCEDURE decr (reg: INTEGER);
BEGIN
    Rex(reg, 0);
    OutByte2(0FFH, 0C8H + reg MOD 8) (* dec reg1 *)
END decr;
 
 
PROCEDURE incr (reg: INTEGER);
BEGIN
    Rex(reg, 0);
    OutByte2(0FFH, 0C0H + reg MOD 8) (* inc reg1 *)
END incr;
 
 
PROCEDURE drop;
BEGIN
    REG.Drop(R)
END drop;
 
 
PROCEDURE GetAnyReg (): INTEGER;
    RETURN REG.GetAnyReg(R)
END GetAnyReg;
 
 
 
 
 
 
 
PROCEDURE callimp (label: INTEGER);
BEGIN
    OutByte2(0FFH, 15H);    (* call qword[rip + label + IMP] *)
    X86.Reloc(sIMP, label)
END callimp;
 
 
PROCEDURE pushDA (offs: INTEGER);
VAR
    reg: INTEGER;
 
BEGIN
    reg := GetAnyReg();
    lea(reg, offs, sDATA);
    push(reg);
    drop
END pushDA;
 
 
PROCEDURE CallRTL (proc: INTEGER);
VAR
    label: INTEGER;
 
BEGIN
 
    label := IL.codes.rtl[proc];
    IF label < 0 THEN
        callimp(-label)
    ELSE
        X86.call(label)
    END
 
END CallRTL;
 
 
PROCEDURE UnOp (VAR reg: INTEGER);
BEGIN
    REG.UnOp(R, reg)
END UnOp;
 
 
PROCEDURE BinOp (VAR reg1, reg2: INTEGER);
BEGIN
    REG.BinOp(R, reg1, reg2)
END BinOp;
 
 
PROCEDURE PushAll (NumberOfParameters: INTEGER);
BEGIN
    REG.PushAll(R);
    DEC(R.pushed, NumberOfParameters)
END PushAll;
 
 
PROCEDURE movabs (reg, n: INTEGER);
VAR
    i: INTEGER;
 
BEGIN
    Rex(reg, 0);
    OutByte(0B8H + reg MOD 8); (* movabs reg, n *)
    FOR i := 0 TO 7 DO
        OutByte(UTILS.Byte(n, i))
    END
END movabs;
 
 
PROCEDURE movrc (reg, n: INTEGER); (* mov reg, n *)
BEGIN
    IF isLong(n) THEN
        movabs(reg, n)
    ELSIF n = 0 THEN
        xor(reg, reg)
    ELSE
        Rex(reg, 0);
        OutByte2(0C7H, 0C0H + reg MOD 8);
        OutInt(n)
    END
END movrc;
 
 
PROCEDURE test (reg: INTEGER); (* test reg, reg *)
BEGIN
    oprr(85H, reg, reg)
END test;
 
 
PROCEDURE oprlongc (reg, n: INTEGER; oprr: OPRR);
VAR
    reg2: INTEGER;
 
BEGIN
    reg2 := GetAnyReg();
    ASSERT(reg2 # reg);
    movabs(reg2, n);
    oprr(reg, reg2);
    drop
END oprlongc;
 
 
PROCEDURE oprc (op, reg, n: INTEGER; oprr: OPRR);
BEGIN
    IF isLong(n) THEN
        oprlongc(reg, n, oprr)
    ELSE
        Rex(reg, 0);
        X86.oprc(op, reg, n)
    END
END oprc;
 
 
PROCEDURE cmprc (reg, n: INTEGER); (* cmp reg, n *)
BEGIN
    IF n = 0 THEN
        test(reg)
    ELSE
        oprc(0F8H, reg, n, cmprr)
    END
END cmprc;
 
 
PROCEDURE addrc (reg, n: INTEGER); (* add reg, n *)
BEGIN
    oprc(0C0H, reg, n, add)
END addrc;
 
 
PROCEDURE subrc (reg, n: INTEGER); (* sub reg, n *)
BEGIN
    oprc(0E8H, reg, n, sub)
END subrc;
 
 
PROCEDURE andrc (reg, n: INTEGER); (* and reg, n *)
BEGIN
    oprc(0E0H, reg, n, and)
END andrc;
 
 
PROCEDURE orrc (reg, n: INTEGER); (* or reg, n *)
BEGIN
    oprc(0C8H, reg, n, _or)
END orrc;
 
 
PROCEDURE xorrc (reg, n: INTEGER); (* xor reg, n *)
BEGIN
    oprc(0F0H, reg, n, xor)
END xorrc;
 
 
PROCEDURE pushc (n: INTEGER);
VAR
    reg2: INTEGER;
 
BEGIN
    IF isLong(n) THEN
        reg2 := GetAnyReg();
        movabs(reg2, n);
        push(reg2);
        drop
    ELSE
        X86.pushc(n)
    END
END pushc;
 
 
PROCEDURE not (reg: INTEGER); (* not reg *)
BEGIN
    Rex(reg, 0);
    OutByte2(0F7H, 0D0H + reg MOD 8)
END not;
 
 
PROCEDURE neg (reg: INTEGER); (* neg reg *)
BEGIN
    Rex(reg, 0);
    OutByte2(0F7H, 0D8H + reg MOD 8)
END neg;
 
 
PROCEDURE movzx (reg1, reg2, offs: INTEGER; word: BOOLEAN); (* movzx reg1, byte/word[reg2 + offs] *)
BEGIN
    Rex(reg2, reg1);
    X86.movzx(reg1, reg2, offs, word)
END movzx;
 
 
PROCEDURE movmr32 (reg1, offs, reg2: INTEGER); (* mov dword[reg1+offs], reg2_32 *)
BEGIN
    X86._movrm(reg2, reg1, offs, 32, TRUE)
END movmr32;
 
 
PROCEDURE movrm32 (reg1, reg2, offs: INTEGER); (* mov reg1_32, dword[reg2+offs] *)
BEGIN
    X86._movrm(reg1, reg2, offs, 32, FALSE)
END movrm32;
 
 
PROCEDURE movmr (reg1, offs, reg2: INTEGER); (* mov qword[reg1+offs], reg2 *)
BEGIN
    X86._movrm(reg2, reg1, offs, 64, TRUE)
END movmr;
 
 
PROCEDURE movrm (reg1, reg2, offs: INTEGER); (* mov reg1, qword[reg2+offs] *)
BEGIN
    X86._movrm(reg1, reg2, offs, 64, FALSE)
END movrm;
 
 
PROCEDURE comisd (xmm1, xmm2: INTEGER); (* comisd xmm1, xmm2 *)
BEGIN
    OutByte(66H);
    IF (xmm1 >= 8) OR (xmm2 >= 8) THEN
        OutByte(40H + (xmm1 DIV 8) * 4 + xmm2 DIV 8)
    END;
    OutByte3(0FH, 2FH, 0C0H + (xmm1 MOD 8) * 8 + xmm2 MOD 8)
END comisd;
 
 
PROCEDURE _movsdrm (xmm, reg, offs: INTEGER; mr: BOOLEAN);
VAR
    b: BYTE;
 
BEGIN
    OutByte(0F2H);
    IF (xmm >= 8) OR (reg >= 8) THEN
        OutByte(40H + (xmm DIV 8) * 4 + reg DIV 8)
    END;
    OutByte2(0FH, 10H + ORD(mr));
    IF (offs = 0) & (reg # rbp) THEN
        b := 0
    ELSE
        b := 40H + long(offs)
    END;
    OutByte(b + (xmm MOD 8) * 8 + reg MOD 8);
    IF reg = rsp THEN
        OutByte(24H)
    END;
    IF b # 0 THEN
        OutIntByte(offs)
    END
END _movsdrm;
 
 
PROCEDURE movsdrm (xmm, reg, offs: INTEGER); (* movsd xmm, qword[reg+offs] *)
BEGIN
    _movsdrm(xmm, reg, offs, FALSE)
END movsdrm;
 
 
PROCEDURE movsdmr (reg, offs, xmm: INTEGER); (* movsd qword[reg+offs], xmm *)
BEGIN
    _movsdrm(xmm, reg, offs, TRUE)
END movsdmr;
 
 
PROCEDURE opxx (op, xmm1, xmm2: INTEGER);
BEGIN
    OutByte(0F2H);
    IF (xmm1 >= 8) OR (xmm2 >= 8) THEN
        OutByte(40H + (xmm1 DIV 8) * 4 + xmm2 DIV 8)
    END;
    OutByte3(0FH, op, 0C0H + (xmm1 MOD 8) * 8 + xmm2 MOD 8)
END opxx;
 
 
PROCEDURE jcc (cc, label: INTEGER); (* jcc label *)
BEGIN
    X86.jcc(cc, label)
END jcc;
 
 
PROCEDURE shiftrc (op, reg, n: INTEGER);
BEGIN
    Rex(reg, 0);
    IF n = 1 THEN
        OutByte(0D1H)
    ELSE
        OutByte(0C1H)
    END;
    X86.shift(op, reg MOD 8);
    IF n # 1 THEN
        OutByte(n)
    END
END shiftrc;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
PROCEDURE GetRegA;
BEGIN
    ASSERT(REG.GetReg(R, rax))
END GetRegA;
 
 
PROCEDURE Win64Passing (params: INTEGER);
VAR
    n, i: INTEGER;
 
BEGIN
    n := params MOD 32;
    params := params DIV 32;
    FOR i := 0 TO n - 1 DO
        IF i IN BITS(params) THEN
            movsdrm(i, rsp, i * 8)
        ELSE
            movrm(Win64RegPar[i], rsp, i * 8)
        END
    END
END Win64Passing;
 
 
PROCEDURE SysVPassing (params: INTEGER);
VAR
    n, i, s, p, ofs: INTEGER;
    i_count, f_count: INTEGER;
    reg: BOOLEAN;
 
BEGIN
    ASSERT(r11 IN R.regs);
    n := params MOD 32;
    params := params DIV 32;
    s := 0;
 
    i_count := 0;
    f_count := 0;
    FOR i := 0 TO n - 1 DO
        IF i IN BITS(params) THEN
            INC(f_count)
        ELSE
            INC(i_count)
        END
    END;
 
    s := MAX(0, f_count - 8) + MAX(0, i_count - 6);
    p := 0;
 
    subrc(rsp, s * 8);
 
    i_count := 0;
    f_count := 0;
    FOR i := 0 TO n - 1 DO
        ofs := (i + s) * 8;
        IF i IN BITS(params) THEN
            reg := f_count <= 7;
            IF reg THEN
                movsdrm(f_count, rsp, ofs);
                INC(f_count)
            END
        ELSE
            reg := i_count <= 5;
            IF reg THEN
                movrm(SystemVRegPar[i_count], rsp, ofs);
                INC(i_count)
            END
        END;
 
        IF ~reg THEN
            movrm(r11, rsp, ofs);
            movmr(rsp, p, r11);
            INC(p, 8)
        END
    END
END SysVPassing;
 
 
PROCEDURE fcmp (op: INTEGER; xmm: INTEGER);
VAR
    cc, reg: INTEGER;
 
BEGIN
    reg := GetAnyReg();
    xor(reg, reg);
    CASE op OF
    |IL.opEQF:
        comisd(xmm - 1, xmm);
        cc := sete
 
    |IL.opNEF:
        comisd(xmm - 1, xmm);
        cc := setne
 
    |IL.opLTF:
        comisd(xmm - 1, xmm);
        cc := setc
 
    |IL.opGTF:
        comisd(xmm, xmm - 1);
        cc := setc
 
    |IL.opLEF:
        comisd(xmm, xmm - 1);
        cc := setnc
 
    |IL.opGEF:
        comisd(xmm - 1, xmm);
        cc := setnc
    END;
    OutByte2(7AH, 3 + reg DIV 8); (* jp L *)
    X86.setcc(cc, reg)
    (* L: *)
END fcmp;
 
 
PROCEDURE translate (commands: LISTS.LIST; stroffs: INTEGER);
VAR
    cmd, next: COMMAND;
 
    opcode, param1, param2, param3, a, b, c, n, label, L, i, cc: INTEGER;
 
    reg1, reg2, xmm: INTEGER;
 
    float: REAL;
 
 
 
BEGIN
    xmm := -1;
    cmd := commands.first(COMMAND);
    WHILE cmd # NIL DO
 
        param1 := cmd.param1;
        param2 := cmd.param2;
 
        opcode := cmd.opcode;
 
        CASE opcode OF
 
        |IL.opJMP:
            X86.jmp(param1)
 
        |IL.opCALL, IL.opWIN64CALL, IL.opSYSVCALL:
 
            CASE opcode OF
            |IL.opCALL:
            |IL.opWIN64CALL: Win64Passing(param2)
            |IL.opSYSVCALL:  SysVPassing(param2)
            END;
            X86.call(param1)
 
 
        |IL.opCALLP, IL.opWIN64CALLP, IL.opSYSVCALLP:
            UnOp(reg1);
            IF reg1 # rax THEN
                mov(rax, reg1)
 
 
            END;
            drop;
 
            CASE opcode OF
            |IL.opCALLP:
            |IL.opWIN64CALLP: Win64Passing(param2)
            |IL.opSYSVCALLP:  SysVPassing(param2)
            END;
            OutByte2(0FFH, 0D0H); (* call rax *)
 
            ASSERT(R.top = -1)
 
        |IL.opCALLI, IL.opWIN64CALLI, IL.opSYSVCALLI:
 
            CASE opcode OF
            |IL.opCALLI:
            |IL.opWIN64CALLI: Win64Passing(param2)
            |IL.opSYSVCALLI:  SysVPassing(param2)
            END;
            callimp(param1)
 
 
        |IL.opLABEL:
            X86.SetLabel(param1)
 
        |IL.opERR:
            CallRTL(IL._error)
 
        |IL.opONERR:
            pushc(param2);
            X86.jmp(param1)
 
        |IL.opPUSHC:
            pushc(param2)
 
        |IL.opPRECALL:
            PushAll(0);
            IF (param2 # 0) & (xmm >= 0) THEN
                subrc(rsp, 8)
            END;
            INC(Xmm[0]);
            Xmm[Xmm[0]] := xmm + 1;
            WHILE xmm >= 0 DO
                subrc(rsp, 8);
                movsdmr(rsp, 0, xmm);
                DEC(xmm)
            END;
            ASSERT(xmm = -1)
 
        |IL.opWIN64ALIGN16:
            ASSERT(rax IN R.regs);
            mov(rax, rsp);
            andrc(rsp, -16);
            push(rax);
            subrc(rsp, (MAX(param2 - 4, 0) MOD 2 + MAX(4 - param2, 0) + 1) * 8)
 
        |IL.opSYSVALIGN16:
            ASSERT(rax IN R.regs);
            mov(rax, rsp);
            andrc(rsp, -16);
            push(rax);
            IF ~ODD(param2) THEN
                push(rax)
            END
 
        |IL.opRESF, IL.opRES:
            ASSERT(R.top = -1);
            ASSERT(xmm = -1);
            n := Xmm[Xmm[0]]; DEC(Xmm[0]);
 
            IF opcode = IL.opRESF THEN
                INC(xmm);
                IF n > 0 THEN
                    movsdmr(rsp, n * 8, 0);
                    DEC(xmm);
                    INC(n)
                END;
 
                IF xmm + n > MAX_XMM THEN
                    ERRORS.ErrorMsg(fname, param1, param2, FPR_ERR)
                END
            ELSE
                GetRegA
            END;
 
            WHILE n > 0 DO
                INC(xmm);
                movsdrm(xmm, rsp, 0);
                addrc(rsp, 8);
                DEC(n)
            END
 
        |IL.opENTER:
            ASSERT(R.top = -1);
 
            X86.SetLabel(param1);
 
            param3 := cmd.param3;
 
            IF param3 > 0 THEN
                push(rbp);
                mov(rbp, rsp);
 
                n := param3 MOD 32;
                param3 := param3 DIV 32;
 
                FOR i := 0 TO n - 1 DO
                    IF i IN BITS(param3) THEN
                        movsdmr(rbp, i * 8 + 16, i)
                    ELSE
                        movmr(rbp, i * 8 + 16, Win64RegPar[i])
                    END
                END
            ELSIF param3 < 0 THEN
                param3 := -param3;
                n := (param3 MOD 32) * 8;
                param3 := param3 DIV 32;
                pop(r11);
                subrc(rsp, n);
                push(r11);
                push(rbp);
                mov(rbp, rsp);
 
                a := 0;
                b := 0;
                c := 0;
 
                INC(n, 16);
 
                FOR i := 16 TO n - 8 BY 8 DO
                    IF ODD(param3) THEN
                        IF b <= 7 THEN
                            movsdmr(rbp, i, b);
                            INC(b)
                        ELSE
                            movrm(r11, rbp, n + c);
                            movmr(rbp, i, r11);
                            INC(c, 8)
                        END
                    ELSE
                        IF a <= 5 THEN
                            movmr(rbp, i, SystemVRegPar[a]);
                            INC(a)
                        ELSE
                            movrm(r11, rbp, n + c);
                            movmr(rbp, i, r11);
                            INC(c, 8)
                        END
                    END;
                    param3 := param3 DIV 2
                END
            ELSE
                push(rbp);
                mov(rbp, rsp)
            END;
 
            n := param2;
            IF n > 4 THEN
                movrc(rcx, n);
                                     (* L: *)
                pushc(0);
                OutByte2(0E2H, 0FCH) (* loop L *)
            ELSE
                WHILE n > 0 DO
                    pushc(0);
                    DEC(n)
                END
 
 
 
 
            END
 
        |IL.opLEAVE, IL.opLEAVER, IL.opLEAVEF:
            IF opcode = IL.opLEAVER THEN
                UnOp(reg1);
                IF reg1 # rax THEN
                    mov(rax, reg1)
 
 
                END;
                drop
            END;
 
            ASSERT(R.top = -1);
 
            IF opcode = IL.opLEAVEF THEN
                DEC(xmm)
            END;
 
            ASSERT(xmm = -1);
 
            IF param1 > 0 THEN
                mov(rsp, rbp)
            END;
 
            pop(rbp);
            IF param2 > 0 THEN
                OutByte3(0C2H, (param2 * 8) MOD 256, (param2 * 8) DIV 256) (* ret param2*8 *)
            ELSE
                X86.ret
            END
 
 
        |IL.opSAVES:
            UnOp(reg1);
            REG.PushAll_1(R);
            pushDA(stroffs + param2);
            push(reg1);
            drop;
            pushc(param1);
            CallRTL(IL._move)
 
        |IL.opSADR:
            lea(GetAnyReg(), stroffs + param2, sDATA)
 
        |IL.opLOAD8:
            UnOp(reg1);
            movzx(reg1, reg1, 0, FALSE)
 
        |IL.opLOAD16:
            UnOp(reg1);
            movzx(reg1, reg1, 0, TRUE)
 
        |IL.opLOAD32:
            UnOp(reg1);
            movrm32(reg1, reg1, 0);
            shiftrc(shl, reg1, 32);
            shiftrc(shr, reg1, 32)
 
        |IL.opLOAD64:
            UnOp(reg1);
            movrm(reg1, reg1, 0)
 
        |IL.opLLOAD64:
            reg1 := GetAnyReg();
 
 
 
 
            movrm(reg1, rbp, param2 * 8)
 
 
        |IL.opLLOAD8,
         IL.opLLOAD16:
            reg1 := GetAnyReg();
 
 
 
 
            movzx(reg1, rbp, param2 * 8, opcode = IL.opLLOAD16)
 
 
        |IL.opLLOAD32:
            reg1 := GetAnyReg();
 
 
 
 
            movrm32(reg1, rbp, param2 * 8);
 
            shiftrc(shl, reg1, 32);
            shiftrc(shr, reg1, 32)
 
        |IL.opGLOAD64:
            reg1 := GetAnyReg();
            Rex(0, reg1);  (* mov reg1, qword[rip + param2 + BSS] *)
            OutByte2(8BH, 05H + 8 * (reg1 MOD 8));
            X86.Reloc(sBSS, param2)
 
        |IL.opGLOAD8, IL.opGLOAD16:
            reg1 := GetAnyReg();
            Rex(0, reg1);  (* movzx reg1, byte/word[rip + param2 + BSS] *)
            OutByte3(0FH, 0B6H + ORD(opcode = IL.opGLOAD16), 05H + 8 * (reg1 MOD 8));
            X86.Reloc(sBSS, param2)
 
        |IL.opGLOAD32:
            reg1 := GetAnyReg();
            lea(reg1, param2, sBSS);
            movrm32(reg1, reg1, 0);
            shiftrc(shl, reg1, 32);
            shiftrc(shr, reg1, 32)
 
        |IL.opVLOAD64:
            reg1 := GetAnyReg();
            movrm(reg1, rbp, param2 * 8);
            movrm(reg1, reg1, 0)
 
        |IL.opVLOAD8,
         IL.opVLOAD16:
            reg1 := GetAnyReg();
            movrm(reg1, rbp, param2 * 8);
            movzx(reg1, reg1, 0, opcode = IL.opVLOAD16)
 
        |IL.opVLOAD32:
            reg1 := GetAnyReg();
            reg2 := GetAnyReg();
            movrm(reg2, rbp, param2 * 8);
            movrm32(reg1, reg2, 0);
            shiftrc(shl, reg1, 32);
            shiftrc(shr, reg1, 32);
            drop
 
        |IL.opLADR:
            n := param2 * 8;
            next := cmd.next(COMMAND);
            IF (next.opcode = IL.opSAVEF) OR (next.opcode = IL.opSAVEFI) THEN
                ASSERT(xmm >= 0);
                movsdmr(rbp, n, xmm);
                DEC(xmm);
                cmd := next
            ELSIF next.opcode = IL.opLOADF THEN
                INC(xmm);
                IF xmm > MAX_XMM THEN
                    ERRORS.ErrorMsg(fname, next.param1, next.param2, FPR_ERR)
                END;
                movsdrm(xmm, rbp, n);
                cmd := next
            ELSE
                IF (next.opcode = IL.opADDC) & ~isLong(n + next.param2) THEN
                    INC(n, next.param2);
                    cmd := next
                END;
                reg1 := GetAnyReg();
                Rex(0, reg1);
                OutByte2(8DH, 45H + long(n) + (reg1 MOD 8) * 8); (* lea reg1, qword[rbp+n] *)
                OutIntByte(n)
            END
 
        |IL.opGADR:
            next := cmd.next(COMMAND);
            IF (next.opcode = IL.opADDC) & ~isLong(param2 + next.param2) THEN
                INC(param2, next.param2);
                cmd := next
            END;
            lea(GetAnyReg(), param2, sBSS)
 
        |IL.opVADR:
            movrm(GetAnyReg(), rbp, param2 * 8)
 
        |IL.opSAVE8C:
            UnOp(reg1);
            IF reg1 >= 8 THEN
                OutByte(41H)
            END;
            OutByte3(0C6H, reg1 MOD 8, param2); (* mov byte[reg1], param2 *)
            drop
 
        |IL.opSAVE16C:
            UnOp(reg1);
            OutByte(66H);
            IF reg1 >= 8 THEN
                OutByte(41H)
            END;
            OutByte2(0C7H, reg1 MOD 8);
            OutByte2(param2 MOD 256, param2 DIV 256); (* mov word[reg1], param2 *)
            drop
 
        |IL.opSAVEC:
            UnOp(reg1);
            IF isLong(param2) THEN
                reg2 := GetAnyReg();
                movrc(reg2, param2);
                movmr(reg1, 0, reg2);
                drop
            ELSE
                Rex(reg1, 0);
                OutByte2(0C7H, reg1 MOD 8); (* mov qword[reg1], param2 *)
                OutInt(param2)
            END;
            drop
 
        |IL.opRSET:
            PushAll(2);
            CallRTL(IL._set);
            GetRegA
 
        |IL.opRSETR:
            PushAll(1);
            pushc(param2);
            CallRTL(IL._set);
            GetRegA
 
        |IL.opRSETL:
            UnOp(reg1);
            REG.PushAll_1(R);
            pushc(param2);
            push(reg1);
            drop;
            CallRTL(IL._set);
            GetRegA
 
        |IL.opRSET1:
            PushAll(1);
            CallRTL(IL._set1);
            GetRegA
 
        |IL.opINCL, IL.opEXCL:
            BinOp(reg1, reg2);
            cmprc(reg1, 64);
            OutByte2(73H, 04H); (* jnb L *)
            Rex(reg2, reg1);
            OutByte3(0FH, 0ABH + 8 * ORD(opcode = IL.opEXCL), 8 * (reg1 MOD 8) + reg2 MOD 8); (* bts/btr qword[reg2], reg1 *)
            (* L: *)
            drop;
            drop
 
        |IL.opINCLC, IL.opEXCLC:
            UnOp(reg1);
            Rex(reg1, 0);
            OutByte2(0FH, 0BAH); (* bts/btr qword[reg1], param2 *)
            OutByte2(28H + 8 * ORD(opcode = IL.opEXCLC) + reg1 MOD 8, param2);
            drop
 
        |IL.opEQS .. IL.opGES:
            PushAll(4);
            pushc(opcode - IL.opEQS);
            CallRTL(IL._strcmp);
            GetRegA
 
        |IL.opEQSW .. IL.opGESW:
            PushAll(4);
            pushc(opcode - IL.opEQSW);
            CallRTL(IL._strcmpw);
            GetRegA
 
        |IL.opCONST:
            movrc(GetAnyReg(), param2)
 
        |IL.opEQ..IL.opGE,
         IL.opEQC..IL.opGEC:
 
            IF (IL.opEQ <= opcode) & (opcode <= IL.opGE) THEN
                BinOp(reg1, reg2);
                cmprr(reg1, reg2);
                drop
            ELSE
                UnOp(reg1);
                cmprc(reg1, param2)
            END;
 
            drop;
            cc := X86.cond(opcode);
 
            next := cmd.next(COMMAND);
            IF next.opcode = IL.opJNZ THEN
                jcc(cc, next.param1);
                cmd := next
            ELSIF next.opcode = IL.opJZ THEN
                jcc(X86.inv0(cc), next.param1);
                cmd := next
            ELSE
                reg1 := GetAnyReg();
                X86.setcc(cc + 16, reg1);
                andrc(reg1, 1)
            END
 
        |IL.opCODE:
            OutByte(param2)
 
        |IL.opPUSHIP:
            reg1 := GetAnyReg();
            lea(reg1, param2, sIMP);
            movrm(reg1, reg1, 0)
 
        |IL.opPARAM:
            n := param2;
            IF n = 1 THEN
                UnOp(reg1);
                push(reg1);
                drop
            ELSE
                ASSERT(R.top + 1 <= n);
                PushAll(n)
            END
 
        |IL.opJNZ1:
            UnOp(reg1);
            test(reg1);
            jcc(jne, param1)
 
        |IL.opJG:
            UnOp(reg1);
            test(reg1);
            jcc(jg, param1)
 
        |IL.opJNZ:
            UnOp(reg1);
            test(reg1);
            jcc(jne, param1);
            drop
 
        |IL.opJZ:
            UnOp(reg1);
            test(reg1);
            jcc(je, param1);
            drop
 
        |IL.opIN, IL.opINR:
            IF opcode = IL.opINR THEN
                reg2 := GetAnyReg();
                movrc(reg2, param2)
            END;
            label := NewLabel();
            L := NewLabel();
            BinOp(reg1, reg2);
            cmprc(reg1, 64);
            jcc(jb, L);
            xor(reg1, reg1);
            X86.jmp(label);
            X86.SetLabel(L);
            Rex(reg2, reg1);
            OutByte3(0FH, 0A3H, 0C0H + 8 * (reg1 MOD 8) + reg2 MOD 8); (* bt reg2, reg1 *)
            X86.setcc(setc, reg1);
            andrc(reg1, 1);
            X86.SetLabel(label);
            drop
 
        |IL.opINL:
            UnOp(reg1);
            Rex(reg1, 0);
            OutByte2(0FH, 0BAH); (* bt reg1, param2 *)
            OutByte2(0E0H + reg1 MOD 8, param2);
            X86.setcc(setc, reg1);
            andrc(reg1, 1)
 
        |IL.opNOT:
            UnOp(reg1);
            test(reg1);
            X86.setcc(sete, reg1);
            andrc(reg1, 1)
 
        |IL.opORD:
            UnOp(reg1);
            test(reg1);
            X86.setcc(setne, reg1);
            andrc(reg1, 1)
 
        |IL.opABS:
            UnOp(reg1);
            test(reg1);
            OutByte2(7DH, 03H); (* jge L *)
            neg(reg1)
            (* L: *)
 
        |IL.opEQB, IL.opNEB:
            BinOp(reg1, reg2);
            drop;
            test(reg1);
            label := NewLabel();
            jcc(je, label);
            movrc(reg1, 1);
            X86.SetLabel(label);
            test(reg2);
            label := NewLabel();
            jcc(je, label);
            movrc(reg2, 1);
            X86.SetLabel(label);
            cmprr(reg1, reg2);
            IF opcode = IL.opEQB THEN
                X86.setcc(sete, reg1)
            ELSE
                X86.setcc(setne, reg1)
            END;
            andrc(reg1, 1)
 
        |IL.opMULSC:
            UnOp(reg1);
            andrc(reg1, param2)
 
        |IL.opDIVSC:
            UnOp(reg1);
            xorrc(reg1, param2)
 
        |IL.opADDSC:
            UnOp(reg1);
            orrc(reg1, param2)
 
        |IL.opSUBSL:
            UnOp(reg1);
            not(reg1);
            andrc(reg1, param2)
 
        |IL.opSUBSR:
            UnOp(reg1);
            andrc(reg1, ORD(-BITS(param2)))
 
        |IL.opMULS:
            BinOp(reg1, reg2);
            and(reg1, reg2);
            drop
 
        |IL.opDIVS:
            BinOp(reg1, reg2);
            xor(reg1, reg2);
            drop
 
        |IL.opUMINS:
            UnOp(reg1);
            not(reg1)
 
        |IL.opCOPY:
            PushAll(2);
            pushc(param2);
            CallRTL(IL._move)
 
        |IL.opMOVE:
            PushAll(3);
            CallRTL(IL._move)
 
        |IL.opCOPYA:
            PushAll(4);
            pushc(param2);
            CallRTL(IL._arrcpy);
            GetRegA
 
        |IL.opCOPYS:
            PushAll(4);
            pushc(param2);
            CallRTL(IL._strcpy)
 
        |IL.opROT:
            PushAll(0);
            push(rsp);
            pushc(param2);
            CallRTL(IL._rot)
 
        |IL.opNEW:
            PushAll(1);
            n := param2 + 8;
            ASSERT(UTILS.Align(n, 8));
            pushc(n);
            pushc(param1);
            CallRTL(IL._new)
 
        |IL.opDISP:
            PushAll(1);
            CallRTL(IL._dispose)
 
        |IL.opPUSHT:
            UnOp(reg1);
 
            movrm(GetAnyReg(), reg1, -8)
 
        |IL.opISREC:
            PushAll(2);
            pushc(param2 * tcount);
            CallRTL(IL._isrec);
            GetRegA
 
        |IL.opIS:
            PushAll(1);
            pushc(param2 * tcount);
            CallRTL(IL._is);
            GetRegA
 
        |IL.opTYPEGR:
            PushAll(1);
            pushc(param2 * tcount);
            CallRTL(IL._guardrec);
            GetRegA
 
        |IL.opTYPEGP:
            UnOp(reg1);
            PushAll(0);
            push(reg1);
            pushc(param2 * tcount);
            CallRTL(IL._guard);
            GetRegA
 
        |IL.opTYPEGD:
            UnOp(reg1);
            PushAll(0);
            X86.pushm(reg1, -8);
            pushc(param2 * tcount);
            CallRTL(IL._guardrec);
            GetRegA
 
        |IL.opCASET:
            push(rcx);
            push(rcx);
            pushc(param2 * tcount);
            CallRTL(IL._guardrec);
            pop(rcx);
            test(rax);
            jcc(jne, param1)
 
        |IL.opSAVEP:
            UnOp(reg1);
            reg2 := GetAnyReg();
            lea(reg2, param2, sCODE);
            movmr(reg1, 0, reg2);
            drop;
            drop
 
        |IL.opPUSHP:
            lea(GetAnyReg(), param2, sCODE)
 
        |IL.opINC, IL.opDEC:
            BinOp(reg1, reg2);
            (* add/sub qword[reg2], reg1 *)
            Rex(reg2, reg1);
            OutByte2(01H + 28H * ORD(opcode = IL.opDEC), reg2 MOD 8 + (reg1 MOD 8) * 8);
            drop;
            drop
 
        |IL.opINCC:
            UnOp(reg1);
            IF isLong(param2) THEN
                reg2 := GetAnyReg();
                movrc(reg2, param2);
                (* add qword[reg1], reg2 *)
                Rex(reg1, reg2);
                OutByte2(01H, reg1 MOD 8 + (reg2 MOD 8) * 8);
                drop
            ELSIF ABS(param2) = 1 THEN
                Rex(reg1, 0);
                OutByte2(0FFH, reg1 MOD 8 + 8 * ORD(param2 = -1)) (* inc/dec qword[reg1] *)
            ELSE
                (* add qword[reg1], param2 *)
                Rex(reg1, 0);
                OutByte2(81H + short(param2), reg1 MOD 8);
                OutIntByte(param2)
            END;
            drop
 
        |IL.opDROP:
            UnOp(reg1);
            drop
 
        |IL.opSAVE, IL.opSAVE64:
            BinOp(reg2, reg1);
            movmr(reg1, 0, reg2);
            drop;
            drop
 
        |IL.opSAVE8:
            BinOp(reg2, reg1);
            X86.movmr8(reg1, 0, reg2);
            drop;
            drop
 
        |IL.opSAVE16:
            BinOp(reg2, reg1);
            X86.movmr16(reg1, 0, reg2);
            drop;
            drop
 
        |IL.opSAVE32:
            BinOp(reg2, reg1);
            movmr32(reg1, 0, reg2);
            drop;
            drop
 
        |IL.opMAX, IL.opMIN:
            BinOp(reg1, reg2);
            cmprr(reg1, reg2);
            OutByte2(7DH + ORD(opcode = IL.opMIN), 3); (* jge/jle L *)
            mov(reg1, reg2);
            (* L: *)
            drop
 
        |IL.opMAXC, IL.opMINC:
            UnOp(reg1);
            cmprc(reg1, param2);
            label := NewLabel();
            IF opcode = IL.opMINC THEN
                cc := jle
            ELSE
                cc := jge
            END;
            jcc(cc, label);
            movrc(reg1, param2);
            X86.SetLabel(label)
 
        |IL.opSBOOL:
            BinOp(reg2, reg1);
            test(reg2);
            IF reg1 >= 8 THEN
                OutByte(41H)
            END;
            OutByte3(0FH, 95H, reg1 MOD 8); (* setne byte[reg1] *)
            drop;
            drop
 
        |IL.opSBOOLC:
            UnOp(reg1);
            IF reg1 >= 8 THEN
                OutByte(41H)
            END;
            OutByte3(0C6H, reg1 MOD 8, ORD(param2 # 0)); (* mov byte[reg1], 0/1 *)
            drop
 
        |IL.opUMINUS:
            UnOp(reg1);
            neg(reg1)
 
        |IL.opADD:
            BinOp(reg1, reg2);
            add(reg1, reg2);
            drop
 
        |IL.opSUB:
            BinOp(reg1, reg2);
            sub(reg1, reg2);
            drop
 
        |IL.opSUBR, IL.opSUBL:
            UnOp(reg1);
            IF param2 = 1 THEN
                decr(reg1)
            ELSIF param2 = -1 THEN
                incr(reg1)
            ELSIF param2 # 0 THEN
                subrc(reg1, param2)
            END;
            IF opcode = IL.opSUBL THEN
                neg(reg1)
            END
 
        |IL.opADDC:
            IF (param2 # 0) & ~isLong(param2) THEN
                UnOp(reg1);
                next := cmd.next(COMMAND);
                CASE next.opcode OF
                |IL.opLOAD64:
                    movrm(reg1, reg1, param2);
                    cmd := next
                |IL.opLOAD32:
                    movrm32(reg1, reg1, param2);
                    shiftrc(shl, reg1, 32);
                    shiftrc(shr, reg1, 32);
                    cmd := next
                |IL.opLOAD16:
                    movzx(reg1, reg1, param2, TRUE);
                    cmd := next
                |IL.opLOAD8:
                    movzx(reg1, reg1, param2, FALSE);
                    cmd := next
                |IL.opLOAD64_PARAM:
                    X86.pushm(reg1, param2);
                    drop;
                    cmd := next
                ELSE
                    IF param2 = 1 THEN
                        incr(reg1)
                    ELSIF param2 = -1 THEN
                        decr(reg1)
                    ELSE
                        addrc(reg1, param2)
                    END
                END
            ELSIF isLong(param2) THEN
                UnOp(reg1);
                addrc(reg1, param2)
            END
 
        |IL.opDIV:
            PushAll(2);
            CallRTL(IL._divmod);
            GetRegA
 
        |IL.opDIVR:
            n := UTILS.Log2(param2);
            IF n > 0 THEN
                UnOp(reg1);
                shiftrc(sar, reg1, n)
            ELSIF n < 0 THEN
                PushAll(1);
                pushc(param2);
                CallRTL(IL._divmod);
                GetRegA
            END
 
        |IL.opDIVL:
            UnOp(reg1);
            REG.PushAll_1(R);
            pushc(param2);
            push(reg1);
            drop;
            CallRTL(IL._divmod);
            GetRegA
 
        |IL.opMOD:
            PushAll(2);
            CallRTL(IL._divmod);
            mov(rax, rdx);
            GetRegA
 
        |IL.opMODR:
            n := UTILS.Log2(param2);
            IF n > 0 THEN
                UnOp(reg1);
                andrc(reg1, param2 - 1);
            ELSIF n < 0 THEN
                PushAll(1);
                pushc(param2);
                CallRTL(IL._divmod);
                mov(rax, rdx);
                GetRegA
            ELSE
                UnOp(reg1);
                xor(reg1, reg1)
            END
 
        |IL.opMODL:
            UnOp(reg1);
            REG.PushAll_1(R);
            pushc(param2);
            push(reg1);
            drop;
            CallRTL(IL._divmod);
            mov(rax, rdx);
            GetRegA
 
        |IL.opMUL:
            BinOp(reg1, reg2);
            oprr2(0FH, 0AFH, reg2, reg1); (* imul reg1, reg2 *)
            drop
 
        |IL.opMULC:
            IF (cmd.next(COMMAND).opcode = IL.opADD) & ((param2 = 2) OR (param2 = 4) OR (param2 = 8)) THEN
                BinOp(reg1, reg2);
                OutByte2(48H + 5 * (reg1 DIV 8) + 2 * (reg2 DIV 8), 8DH); (* lea reg1, [reg1 + reg2 * param2] *)
                reg1 := reg1 MOD 8;
                reg2 := reg2 MOD 8;
                OutByte2(04H + reg1 * 8, reg1 + reg2 * 8 + 40H * UTILS.Log2(param2));
                drop;
                cmd := cmd.next(COMMAND)
            ELSE
                UnOp(reg1);
 
                a := param2;
                IF a > 1 THEN
                    n := UTILS.Log2(a)
                ELSIF a < -1 THEN
                    n := UTILS.Log2(-a)
                ELSE
                    n := -1
                END;
 
                IF a = 1 THEN
 
                ELSIF a = -1 THEN
                    neg(reg1)
                ELSIF a = 0 THEN
                    xor(reg1, reg1)
                ELSE
                    IF n > 0 THEN
                        IF a < 0 THEN
                            neg(reg1)
                        END;
                        shiftrc(shl, reg1, n)
                    ELSE
                        IF isLong(a) THEN
                            reg2 := GetAnyReg();
                            movabs(reg2, a);
                            ASSERT(reg1 # reg2);
                            oprr2(0FH, 0AFH, reg2, reg1); (* imul reg1, reg2 *)
                            drop
                        ELSE
                            (* imul reg1, a *)
                            Rex(reg1, reg1);
                            OutByte2(69H + short(a), 0C0H + (reg1 MOD 8) * 9);
                            OutIntByte(a)
                        END
                    END
                END
            END
 
        |IL.opADDS:
            BinOp(reg1, reg2);
            _or(reg1, reg2);
            drop
 
        |IL.opSUBS:
            BinOp(reg1, reg2);
            not(reg2);
            and(reg1, reg2);
            drop
 
        |IL.opNOP, IL.opAND, IL.opOR:
 
        |IL.opSWITCH:
            UnOp(reg1);
            IF param2 = 0 THEN
                reg2 := rax
            ELSE
                reg2 := rcx
            END;
            IF reg1 # reg2 THEN
                ASSERT(REG.GetReg(R, reg2));
                ASSERT(REG.Exchange(R, reg1, reg2));
                drop
            END;
            drop
 
        |IL.opENDSW:
 
        |IL.opCASEL:
            GetRegA;
            cmprc(rax, param1);
            jcc(jl, param2);
            drop
 
        |IL.opCASER:
            GetRegA;
            cmprc(rax, param1);
            jcc(jg, param2);
            drop
 
        |IL.opCASELR:
            GetRegA;
            cmprc(rax, param1);
            IF param2 = cmd.param3 THEN
                jcc(jne, param2)
            ELSE
                jcc(jl, param2);
                jcc(jg, cmd.param3)
            END;
            drop
 
        |IL.opASR, IL.opROR, IL.opLSL, IL.opLSR:
            UnOp(reg1);
            IF reg1 # rcx THEN
                ASSERT(REG.GetReg(R, rcx));
                ASSERT(REG.Exchange(R, reg1, rcx));
                drop
            END;
 
            BinOp(reg1, reg2);
            ASSERT(reg2 = rcx);
            Rex(reg1, 0);
            OutByte(0D3H);
            X86.shift(opcode, reg1 MOD 8); (* shift reg1, cl *)
 
            drop
 
        |IL.opASR1, IL.opROR1, IL.opLSL1, IL.opLSR1:
            UnOp(reg1);
            IF reg1 # rcx THEN
                ASSERT(REG.GetReg(R, rcx));
                ASSERT(REG.Exchange(R, reg1, rcx));
                drop
            END;
 
            reg1 := GetAnyReg();
            movrc(reg1, param2);
            BinOp(reg1, reg2);
            ASSERT(reg1 = rcx);
            Rex(reg2, 0);
            OutByte(0D3H);
            X86.shift(opcode, reg2 MOD 8); (* shift reg2, cl *)
 
            drop;
            drop;
            ASSERT(REG.GetReg(R, reg2))
 
        |IL.opASR2, IL.opROR2, IL.opLSL2, IL.opLSR2:
            UnOp(reg1);
            shiftrc(opcode, reg1, param2 MOD 64)
 
        |IL.opGET, IL.opGETC:
            IF opcode = IL.opGET THEN
                BinOp(reg1, reg2)
            ELSIF opcode = IL.opGETC THEN
                UnOp(reg2);
                reg1 := GetAnyReg();
                movrc(reg1, param1)
            END;
            drop;
            drop;
            X86._movrm(reg1, reg1, 0, param2 * 8, FALSE);
            X86._movrm(reg1, reg2, 0, param2 * 8, TRUE)
 
        |IL.opCHKBYTE:
            BinOp(reg1, reg2);
            cmprc(reg1, 256);
            jcc(jb, param1)
 
        |IL.opCHKIDX:
            UnOp(reg1);
            cmprc(reg1, param2);
            jcc(jb, param1)
 
        |IL.opCHKIDX2:
            BinOp(reg1, reg2);
            IF param2 # -1 THEN
                cmprr(reg2, reg1);
                jcc(jb, param1);
            END;
            INCL(R.regs, reg1);
            DEC(R.top);
            R.stk[R.top] := reg2
 
        |IL.opLENGTH:
            PushAll(2);
            CallRTL(IL._length);
            GetRegA
 
        |IL.opLENGTHW:
            PushAll(2);
            CallRTL(IL._lengthw);
            GetRegA
 
        |IL.opLEN:
            n := param2;
            UnOp(reg1);
            drop;
            EXCL(R.regs, reg1);
 
            WHILE n > 0 DO
                UnOp(reg2);
                drop;
                DEC(n)
            END;
 
            INCL(R.regs, reg1);
            ASSERT(REG.GetReg(R, reg1))
 
        |IL.opCHR:
            UnOp(reg1);
            andrc(reg1, 255)
 
        |IL.opWCHR:
            UnOp(reg1);
            andrc(reg1, 65535)
 
        |IL.opEQP, IL.opNEP, IL.opEQIP, IL.opNEIP:
            UnOp(reg1);
            reg2 := GetAnyReg();
 
            CASE opcode OF
            |IL.opEQP, IL.opNEP:
                lea(reg2, param1, sCODE)
 
            |IL.opEQIP, IL.opNEIP:
                lea(reg2, param1, sIMP);
                movrm(reg2, reg2, 0)
            END;
 
            cmprr(reg1, reg2);
            drop;
            drop;
            reg1 := GetAnyReg();
 
            CASE opcode OF
            |IL.opEQP, IL.opEQIP: X86.setcc(sete,  reg1)
            |IL.opNEP, IL.opNEIP: X86.setcc(setne, reg1)
            END;
 
            andrc(reg1, 1)
 
        |IL.opINCCB, IL.opDECCB:
            UnOp(reg1);
            IF reg1 >= 8 THEN
                OutByte(41H)
            END;
            OutByte3(80H, 28H * ORD(opcode = IL.opDECCB) + reg1 MOD 8, param2 MOD 256); (* add/sub byte[reg1], param2 MOD 256 *)
            drop
 
        |IL.opINCB, IL.opDECB:
            BinOp(reg1, reg2);
            IF (reg1 >= 8) OR (reg2 >= 8) THEN
                OutByte(40H + reg2 DIV 8 + 4 * (reg1 DIV 8))
            END;
            OutByte2(28H * ORD(opcode = IL.opDECB), reg2 MOD 8 + 8 * (reg1 MOD 8)); (* add/sub byte[reg2], reg1_8 *)
            drop;
            drop
 
        |IL.opSAVEIP:
            UnOp(reg1);
            reg2 := GetAnyReg();
            lea(reg2, param2, sIMP);
            movrm(reg2, reg2, 0);
            push(reg2);
            drop;
            IF reg1 >= 8 THEN
                OutByte(41H)
            END;
            OutByte2(8FH, reg1 MOD 8); (* pop qword[reg1] *)
            drop
 
        |IL.opCLEANUP:
            IF param2 # 0 THEN
                addrc(rsp, param2 * 8)
            END
 
        |IL.opPOPSP:
            pop(rsp)
 
        |IL.opLOADF:
            UnOp(reg1);
            INC(xmm);
            IF xmm > MAX_XMM THEN
                ERRORS.ErrorMsg(fname, param1, param2, FPR_ERR)
            END;
            movsdrm(xmm, reg1, 0);
            drop
 
        |IL.opPUSHF:
            ASSERT(xmm >= 0);
            subrc(rsp, 8);
            movsdmr(rsp, 0, xmm);
            DEC(xmm)
 
        |IL.opCONSTF:
            float := cmd.float;
            INC(xmm);
            IF xmm > MAX_XMM THEN
                ERRORS.ErrorMsg(fname, param1, param2, FPR_ERR)
            END;
            (* movsd xmm, qword ptr [rip + Numbers_Offs + Numbers_Count * 8 + DATA] *)
            OutByte(0F2H);
            IF xmm >= 8 THEN
                OutByte(44H)
            END;
            OutByte3(0FH, 10H, 05H + 8 * (xmm MOD 8));
            X86.Reloc(sDATA, Numbers_Offs + Numbers_Count * 8);
            NewNumber(UTILS.splitf(float, a, b))
 
        |IL.opSAVEF, IL.opSAVEFI:
            ASSERT(xmm >= 0);
            UnOp(reg1);
            movsdmr(reg1, 0, xmm);
            DEC(xmm);
            drop
 
        |IL.opADDF:
            ASSERT(xmm >= 1);
            opxx(58H, xmm - 1, xmm);
            DEC(xmm)
 
        |IL.opSUBF:
            ASSERT(xmm >= 1);
            opxx(5CH, xmm - 1, xmm);
            DEC(xmm)
 
        |IL.opSUBFI:
            ASSERT(xmm >= 1);
            opxx(5CH, xmm, xmm - 1);
            opxx(10H, xmm - 1, xmm);
            DEC(xmm)
 
        |IL.opMULF:
            ASSERT(xmm >= 1);
            opxx(59H, xmm - 1, xmm);
            DEC(xmm)
 
        |IL.opDIVF:
            ASSERT(xmm >= 1);
            opxx(5EH, xmm - 1, xmm);
            DEC(xmm)
 
        |IL.opDIVFI:
            ASSERT(xmm >= 1);
            opxx(5EH, xmm, xmm - 1);
            opxx(10H, xmm - 1, xmm);
            DEC(xmm)
 
        |IL.opFABS, IL.opUMINF: (* andpd/xorpd xmm, xmmword[rip + Numbers_Offs + (16) + DATA] *)
            ASSERT(xmm >= 0);
            OutByte(66H);
            IF xmm >= 8 THEN
                OutByte(44H)
            END;
            OutByte3(0FH, 54H + 3 * ORD(opcode = IL.opUMINF), 05H + (xmm MOD 8) * 8);
            X86.Reloc(sDATA, Numbers_Offs + 16 * ORD(opcode = IL.opFABS))
 
        |IL.opFLT:
            UnOp(reg1);
            INC(xmm);
            IF xmm > MAX_XMM THEN
                ERRORS.ErrorMsg(fname, param1, param2, FPR_ERR)
            END;
            OutByte(0F2H); Rex(reg1, xmm); OutByte(0FH); (* cvtsi2sd xmm, reg1 *)
            OutByte2(2AH, 0C0H + (xmm MOD 8) * 8 + reg1 MOD 8);
            drop
 
        |IL.opFLOOR:
            ASSERT(xmm >= 0);
            reg1 := GetAnyReg();
            subrc(rsp, 8);
            OutByte3(00FH, 0AEH, 05CH); OutByte2(024H, 004H);                       (* stmxcsr dword[rsp+4];                              *)
            OutByte2(00FH, 0AEH); OutByte2(01CH, 024H);                             (* stmxcsr dword[rsp];                                *)
            OutByte3(081H, 024H, 024H); OutByte2(0FFH, 09FH); OutByte2(0FFH, 0FFH); (* and dword[rsp],11111111111111111001111111111111b;  *)
            OutByte3(081H, 00CH, 024H); OutByte2(000H, 020H); OutByte2(000H, 000H); (* or dword[rsp],00000000000000000010000000000000b;   *)
            OutByte2(00FH, 0AEH); OutByte2(014H, 024H);                             (* ldmxcsr dword[rsp];                                *)
            OutByte(0F2H); Rex(xmm, reg1); OutByte(0FH);                            (* cvtsd2si reg1, xmm                                 *)
            OutByte2(2DH, 0C0H + xmm MOD 8 + (reg1 MOD 8) * 8);
            OutByte3(00FH, 0AEH, 054H); OutByte2(024H, 004H);                       (* ldmxcsr dword[rsp+4];                              *)
            addrc(rsp, 8);
            DEC(xmm)
 
        |IL.opEQF .. IL.opGEF:
            ASSERT(xmm >= 1);
            fcmp(opcode, xmm);
            DEC(xmm, 2)
 
        |IL.opINF:
            INC(xmm);
            IF xmm > MAX_XMM THEN
                ERRORS.ErrorMsg(fname, param1, param2, FPR_ERR)
            END;
            (* movsd xmm, qword ptr [rip + Numbers_Offs + 32 + DATA] *)
            OutByte(0F2H);
            IF xmm >= 8 THEN
                OutByte(44H)
            END;
            OutByte3(0FH, 10H, 05H + 8 * (xmm MOD 8));
            X86.Reloc(sDATA, Numbers_Offs + 32)
 
        |IL.opPACK, IL.opPACKC:
            IF opcode = IL.opPACK THEN
                BinOp(reg1, reg2)
            ELSE
                UnOp(reg1);
                reg2 := GetAnyReg();
                movrc(reg2, param2)
            END;
            push(reg1);
            movrm(reg1, reg1, 0);
            shiftrc(shl, reg1, 1);
            shiftrc(shr, reg1, 53);
            add(reg1, reg2);
            andrc(reg1, ORD({0..10}));
            shiftrc(shl, reg1, 52);
            movrm(reg2, rsp, 0);
            movrm(reg2, reg2, 0);
 
            push(reg1);
            lea(reg1, Numbers_Offs + 40, sDATA); (* {0..51, 63} *)
            movrm(reg1, reg1, 0);
            and(reg2, reg1);
            pop(reg1);
 
            _or(reg2, reg1);
            pop(reg1);
            movmr(reg1, 0, reg2);
            drop;
            drop
 
        |IL.opUNPK, IL.opLADR_UNPK:
 
            IF opcode = IL.opLADR_UNPK THEN
                n := param2 * 8;
                UnOp(reg1);
 
 
 
                reg2 := GetAnyReg();
                Rex(0, reg2);
                OutByte2(8DH, 45H + long(n) + (reg2 MOD 8) * 8); (* lea reg2, qword[rbp+n] *)
                OutIntByte(n)
 
            ELSE
                BinOp(reg1, reg2)
 
            END;
 
            push(reg1);
            movrm(reg1, reg1, 0);
            shiftrc(shl, reg1, 1);
            shiftrc(shr, reg1, 53);
            subrc(reg1, 1023);
 
 
 
 
 
 
            movmr(reg2, 0, reg1);
 
            pop(reg2);
            movrm(reg1, reg2, 0);
 
            push(reg2);
            lea(reg2, Numbers_Offs + 48, sDATA); (* {52..61} *)
            movrm(reg2, reg2, 0);
            _or(reg1, reg2);
            pop(reg2);
 
            Rex(reg1, 0);
            OutByte2(0FH, 0BAH);
            OutByte2(0F0H + reg1 MOD 8, 3EH); (* btr reg1, 62 *)
            movmr(reg2, 0, reg1);
            drop;
            drop
 
        |IL.opSADR_PARAM:
            pushDA(stroffs + param2)
 
        |IL.opVADR_PARAM:
            X86.pushm(rbp, param2 * 8)
 
        |IL.opLOAD64_PARAM:
            UnOp(reg1);
            X86.pushm(reg1, 0);
            drop
 
        |IL.opLLOAD64_PARAM:
 
 
 
 
            X86.pushm(rbp, param2 * 8)
 
 
        |IL.opGLOAD64_PARAM:
            OutByte2(0FFH, 35H); (* push qword[rip + param2 + BSS] *)
            X86.Reloc(sBSS, param2)
 
        |IL.opCONST_PARAM:
            pushc(param2)
 
        |IL.opGLOAD32_PARAM, IL.opLOAD32_PARAM:
            IF opcode = IL.opGLOAD32_PARAM THEN
                reg1 := GetAnyReg();
                lea(reg1, param2, sBSS)
            ELSE
                UnOp(reg1)
            END;
            movrm32(reg1, reg1, 0);
            shiftrc(shl, reg1, 32);
            shiftrc(shr, reg1, 32);
            push(reg1);
            drop
 
        |IL.opLLOAD32_PARAM:
            reg1 := GetAnyReg();
 
 
 
 
            movrm32(reg1, rbp, param2 * 8);
 
            shiftrc(shl, reg1, 32);
            shiftrc(shr, reg1, 32);
            push(reg1);
            drop
 
        |IL.opLADR_SAVEC:
            n := param1 * 8;
 
 
 
 
            IF isLong(param2) THEN
                reg2 := GetAnyReg();
                movrc(reg2, param2);
                movmr(rbp, n, reg2);
                drop
            ELSE
                OutByte3(48H, 0C7H, 45H + long(n)); (* mov qword[rbp+n], param2 *)
                OutIntByte(n);
                OutInt(param2)
            END
 
 
        |IL.opGADR_SAVEC:
            IF isLong(param2) THEN
                reg1 := GetAnyReg();
                movrc(reg1, param2);
                reg2 := GetAnyReg();
                lea(reg2, param1, sBSS);
                movmr(reg2, 0, reg1);
                drop;
                drop
            ELSE
                (* mov qword[rip + param1 - 4 + BSS], param2 *)
                OutByte3(48H, 0C7H, 05H);
                X86.Reloc(sBSS, param1 - 4);
                OutInt(param2)
            END
 
        |IL.opLADR_SAVE:
            UnOp(reg1);
 
 
 
 
            movmr(rbp, param2 * 8, reg1);
 
            drop
 
        |IL.opLADR_INCC:
 
            IF isLong(param2) THEN
                reg2 := GetAnyReg();
                movrc(reg2, param2);
 
 
 
                n := param1 * 8;
                Rex(0, reg2);
                OutByte2(01H, 45H + long(n) + (reg2 MOD 8) * 8);
                OutIntByte(n); (* add qword[rbp+n], reg2 *)
 
                drop
            ELSIF ABS(param2) = 1 THEN
 
 
 
 
 
 
 
                n := param1 * 8;
                OutByte3(48H, 0FFH, 45H + 8 * ORD(param2 = -1) + long(n)); (* inc/dec qword[rbp+n] *)
                OutIntByte(n)
 
 
 
 
            ELSE
                n := param1 * 8;
                OutByte3(48H, 81H + short(param2), 45H + long(n));
                OutIntByte(n);
                OutIntByte(param2) (* add qword[rbp+n], param2 *)
            END
 
 
 
        |IL.opLADR_INCCB, IL.opLADR_DECCB:
 
 
 
 
 
 
 
 
            param2 := param2 MOD 256;
            n := param1 * 8;
            OutByte2(80H, 45H + long(n) + 28H * ORD(opcode = IL.opLADR_DECCB));
            OutIntByte(n);
            OutByte(param2) (* add/sub byte[rbp+n], param2 *)
 
 
        |IL.opLADR_INC, IL.opLADR_DEC:
            UnOp(reg1);
 
 
 
 
 
 
 
 
            n := param2 * 8;
            Rex(0, reg1);
            OutByte2(01H + 28H * ORD(opcode = IL.opLADR_DEC), 45H + long(n) + (reg1 MOD 8) * 8);
            OutIntByte(n); (* add/sub qword[rbp+n], reg1 *)
 
            drop
 
        |IL.opLADR_INCB, IL.opLADR_DECB:
            UnOp(reg1);
 
 
 
 
 
 
 
 
 
            n := param2 * 8;
            IF reg1 >= 8 THEN
                OutByte(44H)
            END;
            OutByte2(28H * ORD(opcode = IL.opLADR_DECB), 45H + long(n) + 8 * (reg1 MOD 8));
            OutIntByte(n); (* add/sub byte[rbp+n], reg1_8 *)
 
            drop
 
        |IL.opLADR_INCL, IL.opLADR_EXCL:
            UnOp(reg1);
            cmprc(reg1, 64);
 
 
 
 
 
            n := param2 * 8;
            OutByte2(73H, 5 + 3 * ORD(~X86.isByte(n))); (* jnb L *)
            Rex(0, reg1);
            OutByte3(0FH, 0ABH + 8 * ORD(opcode = IL.opLADR_EXCL), 45H + long(n) + 8 * (reg1 MOD 8));
            OutIntByte(n); (* bts/btr qword[rbp+n], reg1 *)
 
            (* L: *)
            drop
 
        |IL.opLADR_INCLC, IL.opLADR_EXCLC:
 
 
 
 
 
 
            n := param1 * 8;
            OutByte3(48H, 0FH, 0BAH); (* bts/btr qword[rbp+n], param2 *)
            OutByte(6DH + long(n) + 8 * ORD(opcode = IL.opLADR_EXCLC));
            OutIntByte(n);
            OutByte(param2)
 
 
        |IL.opFNAME:
            fname := cmd(IL.FNAMECMD).fname
 
 
 
        END;
 
        cmd := cmd.next(COMMAND)
    END;
 
    ASSERT(R.pushed = 0);
    ASSERT(R.top = -1);
    ASSERT(xmm = -1)
END translate;
 
 
PROCEDURE prolog (modname: ARRAY OF CHAR; target, stack_size: INTEGER);
VAR
    ModName_Offs, entry, L: INTEGER;
 
BEGIN
    ModName_Offs := tcount * 8 + CHL.Length(IL.codes.data);
    Numbers_Offs := ModName_Offs + LENGTH(modname) + 1;
    ASSERT(UTILS.Align(Numbers_Offs, 16));
 
    entry := NewLabel();
    X86.SetLabel(entry);
 
    IF target = TARGETS.Win64DLL THEN
        dllret := NewLabel();
        push(r8);
        push(rdx);
        push(rcx);
        CallRTL(IL._dllentry);
        test(rax);
        jcc(je, dllret);
        pushc(0)
    ELSIF target = TARGETS.Linux64 THEN
        push(rsp)
    ELSE
        pushc(0)
    END;
 
    lea(rax, entry, sCODE);
    push(rax);
    pushDA(0); (* TYPES *)
    pushc(tcount);
    pushDA(ModName_Offs); (* MODNAME *)
    CallRTL(IL._init);
 
    IF target IN {TARGETS.Win64C, TARGETS.Win64GUI, TARGETS.Linux64} THEN
        L := NewLabel();
        pushc(0);
        push(rsp);
        pushc(1024 * 1024 * stack_size);
        pushc(0);
        CallRTL(IL._new);
        pop(rax);
        test(rax);
        jcc(je, L);
        GetRegA;
        addrc(rax, 1024 * 1024 * stack_size - 8);
        drop;
        mov(rsp, rax);
        X86.SetLabel(L)
    END
END prolog;
 
 
PROCEDURE epilog (modname: ARRAY OF CHAR; target: INTEGER);
VAR
    i, n: INTEGER;
    number: Number;
    exp: IL.EXPORT_PROC;
 
 
    PROCEDURE _import (imp: LISTS.LIST);
    VAR
        lib:  IL.IMPORT_LIB;
        proc: IL.IMPORT_PROC;
 
    BEGIN
 
        lib := imp.first(IL.IMPORT_LIB);
        WHILE lib # NIL DO
            BIN.Import(prog, lib.name, 0);
            proc := lib.procs.first(IL.IMPORT_PROC);
            WHILE proc # NIL DO
                BIN.Import(prog, proc.name, proc.label);
                proc := proc.next(IL.IMPORT_PROC)
            END;
            lib := lib.next(IL.IMPORT_LIB)
        END
 
    END _import;
 
 
BEGIN
    IF target = TARGETS.Win64DLL THEN
        X86.SetLabel(dllret);
        X86.ret
    ELSIF target = TARGETS.Linux64SO THEN
        sofinit := NewLabel();
        X86.ret;
        X86.SetLabel(sofinit);
        CallRTL(IL._sofinit);
        X86.ret
    ELSE
        pushc(0);
        CallRTL(IL._exit)
    END;
 
    X86.fixup;
 
    i := 0;
    WHILE i < tcount DO
        BIN.PutData64LE(prog, CHL.GetInt(IL.codes.types, i));
        INC(i)
    END;
 
    i := 0;
    WHILE i < CHL.Length(IL.codes.data) DO
        BIN.PutData(prog, CHL.GetByte(IL.codes.data, i));
        INC(i)
    END;
 
    BIN.PutDataStr(prog, modname);
    BIN.PutData(prog, 0);
    n := CHL.Length(prog.data);
    ASSERT(UTILS.Align(n, 16));
    i := n - CHL.Length(prog.data);
    WHILE i > 0 DO
        BIN.PutData(prog, 0);
        DEC(i)
    END;
    number := Numbers.first(Number);
    FOR i := 0 TO Numbers_Count - 1 DO
        BIN.PutData64LE(prog, number.value);
        number := number.next(Number)
    END;
 
    exp := IL.codes.export.first(IL.EXPORT_PROC);
    WHILE exp # NIL DO
        BIN.Export(prog, exp.name, exp.label);
        exp := exp.next(IL.EXPORT_PROC)
    END;
 
    _import(IL.codes._import)
END epilog;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
PROCEDURE CodeGen* (outname: ARRAY OF CHAR; target: INTEGER; options: PROG.OPTIONS);
VAR
    path, modname, ext: PATHS.PATH;
 
BEGIN
    Xmm[0] := 0;
    tcount := CHL.Length(IL.codes.types);
 
    Win64RegPar[0] := rcx;
    Win64RegPar[1] := rdx;
    Win64RegPar[2] := r8;
    Win64RegPar[3] := r9;
 
    SystemVRegPar[0] := rdi;
    SystemVRegPar[1] := rsi;
    SystemVRegPar[2] := rdx;
    SystemVRegPar[3] := rcx;
    SystemVRegPar[4] := r8;
    SystemVRegPar[5] := r9;
 
    PATHS.split(outname, path, modname, ext);
    S.append(modname, ext);
 
    REG.Init(R, push, pop, mov, xchg, {rax, rcx, rdx, r8, r9, r10, r11});
 
    IL.set_bss(MAX(IL.codes.bss, MAX(IL.codes.dmin - CHL.Length(IL.codes.data), 8)));
 
    Numbers := LISTS.create(NIL);
    Numbers_Count := 0;
    NewNumber(ROR(1, 1));      (* 8000000000000000H *)
    NewNumber(0);
    NewNumber(ROR(-2, 1));     (* 7FFFFFFFFFFFFFFFH *)
    NewNumber(-1);
    NewNumber(ROR(7FFH, 12));  (* +Infinity *)
    NewNumber(ORD(-BITS(LSR(ASR(ROR(1, 1), 10), 1))));  (* {0..51, 63} *)
    NewNumber(LSR(ASR(ROR(1, 1), 9), 2));  (* {52..61} *)
 
    prog := BIN.create(IL.codes.lcount);
    BIN.SetParams(prog, IL.codes.bss, 1, WCHR(1), WCHR(0));
 
    X86.SetProgram(prog);
 
    prolog(modname, target, options.stack);
    translate(IL.codes.commands, tcount * 8);
    epilog(modname, target);
 
    BIN.fixup(prog);
    IF TARGETS.OS = TARGETS.osWIN64 THEN
        PE32.write(prog, outname, target = TARGETS.Win64C, target = TARGETS.Win64DLL, TRUE)
    ELSIF TARGETS.OS = TARGETS.osLINUX64 THEN
        ELF.write(prog, outname, sofinit, target = TARGETS.Linux64SO, TRUE)
    END
END CodeGen;
 
 
END AMD64.

Rev 8097	Rev 8859
1	(*	1	(*
2	BSD 2-Clause License	2	BSD 2-Clause License
3		3
4	Copyright (c) 2018-2020, Anton Krotov	4	Copyright (c) 2018-2021, Anton Krotov
5	All rights reserved.	5	All rights reserved.
6	*)	6	*)
7		7
8	MODULE AMD64;	8	MODULE AMD64;
9		9
10	IMPORT IL, BIN, WR := WRITER, CHL := CHUNKLISTS, LISTS, PATHS, PROG, TARGETS,	10	IMPORT IL, BIN, WR := WRITER, CHL := CHUNKLISTS, LISTS, PATHS, PROG, TARGETS,
11	REG, UTILS, S := STRINGS, PE32, ELF, X86, ERRORS;	11	REG, UTILS, S := STRINGS, PE32, ELF, X86, ERRORS;
12		12
13		13
14	CONST	14	CONST
15		15
16	rax = REG.R0;	16	rax = REG.R0;
17	r10 = REG.R10;	17	r10 = REG.R10;
18	r11 = REG.R11;	18	r11 = REG.R11;
19		19
20	rcx = REG.R1;	20	rcx = REG.R1;
21	rdx = REG.R2;	21	rdx = REG.R2;
22	r8 = REG.R8;	22	r8 = REG.R8;
23	r9 = REG.R9;	23	r9 = REG.R9;
24		24
25	rsp = 4;	25	rsp = 4;
26	rbp = 5;	26	rbp = 5;
27	rsi = 6;	27	rsi = 6;
28	rdi = 7;	28	rdi = 7;
29		29
30	MAX_XMM = 5;	30	MAX_XMM = 5;
31		31
32	je = 84H; jne = 85H; jl = 8CH; jge = 8DH; jle = 8EH; jg = 8FH; jb = 82H;	32	je = 84H; jne = 85H; jl = 8CH; jge = 8DH; jle = 8EH; jg = 8FH; jb = 82H;
33		33
34	sete = 94H; setne = 95H; setl = 9CH; setge = 9DH; setle = 9EH; setg = 9FH; setc = 92H; setnc = 93H;	34	sete = 94H; setne = 95H; setl = 9CH; setge = 9DH; setle = 9EH; setg = 9FH; setc = 92H; setnc = 93H;
35		35
36	shl = IL.opLSL2; shr = IL.opLSR2; sar = IL.opASR2; ror = IL.opROR2;	36	shl = IL.opLSL2; shr = IL.opLSR2; sar = IL.opASR2; ror = IL.opROR2;
37		37
38	sCODE = BIN.PICCODE;	38	sCODE = BIN.PICCODE;
39	sDATA = BIN.PICDATA;	39	sDATA = BIN.PICDATA;
40	sBSS = BIN.PICBSS;	40	sBSS = BIN.PICBSS;
41	sIMP = BIN.PICIMP;	41	sIMP = BIN.PICIMP;
42		42
43	FPR_ERR = 41;	43	FPR_ERR = 41;
44		44
45		45
46	TYPE	46	TYPE
47		47
48	COMMAND = IL.COMMAND;	48	COMMAND = IL.COMMAND;
49		49
50	Number = POINTER TO RECORD (LISTS.ITEM) value: INTEGER END;	50	Number = POINTER TO RECORD (LISTS.ITEM) value: INTEGER END;
51		51
52	OPRR = PROCEDURE (reg1, reg2: INTEGER);	52	OPRR = PROCEDURE (reg1, reg2: INTEGER);
53		53
54		54
55	VAR	55	VAR
56		56
57	R: REG.REGS;	57	R: REG.REGS;
58		58
59	Numbers: LISTS.LIST;	59	Numbers: LISTS.LIST;
60	Numbers_Count: INTEGER;	60	Numbers_Count: INTEGER;
61	Numbers_Offs: INTEGER;	61	Numbers_Offs: INTEGER;
62		62
63	prog: BIN.PROGRAM;	63	prog: BIN.PROGRAM;
64		64
65	tcount: INTEGER;	65	tcount: INTEGER;
66		66
67	dllret, sofinit: INTEGER;	67	dllret, sofinit: INTEGER;
68		68
69	Win64RegPar: ARRAY 4 OF INTEGER;	69	Win64RegPar: ARRAY 4 OF INTEGER;
70	SystemVRegPar: ARRAY 6 OF INTEGER;	70	SystemVRegPar: ARRAY 6 OF INTEGER;
71		71
72	Xmm: ARRAY 1000 OF INTEGER;	72	Xmm: ARRAY 1000 OF INTEGER;
73		73
74	fname: PATHS.PATH;	74	fname: PATHS.PATH;
75		75
76		76
77	PROCEDURE OutByte (b: BYTE);	77	PROCEDURE OutByte (b: BYTE);
78	BEGIN	78	BEGIN
79	X86.OutByte(b)	79	X86.OutByte(b)
80	END OutByte;	80	END OutByte;
81		81
82		82
83	PROCEDURE OutByte2 (a, b: BYTE);	83	PROCEDURE OutByte2 (a, b: BYTE);
84	BEGIN	84	BEGIN
85	X86.OutByte(a);	85	X86.OutByte(a);
86	X86.OutByte(b)	86	X86.OutByte(b)
87	END OutByte2;	87	END OutByte2;
88		88
89		89
90	PROCEDURE OutByte3 (a, b, c: BYTE);	90	PROCEDURE OutByte3 (a, b, c: BYTE);
91	BEGIN	91	BEGIN
92	X86.OutByte(a);	92	X86.OutByte(a);
93	X86.OutByte(b);	93	X86.OutByte(b);
94	X86.OutByte(c)	94	X86.OutByte(c)
95	END OutByte3;	95	END OutByte3;
96		96
97		97
98	PROCEDURE OutInt (n: INTEGER);	98	PROCEDURE OutInt (n: INTEGER);
99	BEGIN	99	BEGIN
100	X86.OutByte(n MOD 256);	100	X86.OutByte(n MOD 256);
101	X86.OutByte(UTILS.Byte(n, 1));	101	X86.OutByte(UTILS.Byte(n, 1));
102	X86.OutByte(UTILS.Byte(n, 2));	102	X86.OutByte(UTILS.Byte(n, 2));
103	X86.OutByte(UTILS.Byte(n, 3))	103	X86.OutByte(UTILS.Byte(n, 3))
104	END OutInt;	104	END OutInt;
105		105
106		106
107	PROCEDURE short (n: INTEGER): INTEGER;	107	PROCEDURE short (n: INTEGER): INTEGER;
108	RETURN 2 * ORD(X86.isByte(n))	108	RETURN 2 * ORD(X86.isByte(n))
109	END short;	109	END short;
110		110
111		111
112	PROCEDURE long (n: INTEGER): INTEGER;	112	PROCEDURE long (n: INTEGER): INTEGER;
113	RETURN 40H * ORD(~X86.isByte(n))	113	RETURN 40H * ORD(~X86.isByte(n))
114	END long;	114	END long;
115		115
116		116
117	PROCEDURE OutIntByte (n: INTEGER);	117	PROCEDURE OutIntByte (n: INTEGER);
118	BEGIN	118	BEGIN
119	IF X86.isByte(n) THEN	119	IF X86.isByte(n) THEN
120	OutByte(n MOD 256)	120	OutByte(n MOD 256)
121	ELSE	121	ELSE
122	OutInt(n)	122	OutInt(n)
123	END	123	END
124	END OutIntByte;	124	END OutIntByte;
125		125
126		126
127	PROCEDURE isLong (n: INTEGER): BOOLEAN;	127	PROCEDURE isLong (n: INTEGER): BOOLEAN;
128	RETURN (n > UTILS.max32) OR (n < UTILS.min32)	128	RETURN (n > UTILS.max32) OR (n < UTILS.min32)
129	END isLong;	129	END isLong;
130		130
131		131
132	PROCEDURE NewNumber (value: INTEGER);	132	PROCEDURE NewNumber (value: INTEGER);
133	VAR	133	VAR
134	number: Number;	134	number: Number;
135		135
136	BEGIN	136	BEGIN
137	NEW(number);	137	NEW(number);
138	number.value := value;	138	number.value := value;
139	LISTS.push(Numbers, number);	139	LISTS.push(Numbers, number);
140	INC(Numbers_Count)	140	INC(Numbers_Count)
141	END NewNumber;	141	END NewNumber;
142		142
143		143
144	PROCEDURE NewLabel (): INTEGER;	144	PROCEDURE NewLabel (): INTEGER;
145	BEGIN	145	BEGIN
146	BIN.NewLabel(prog)	146	BIN.NewLabel(prog)
147	RETURN IL.NewLabel()	147	RETURN IL.NewLabel()
148	END NewLabel;	148	END NewLabel;
149		149
150		150
151	PROCEDURE Rex (reg1, reg2: INTEGER);	151	PROCEDURE Rex (reg1, reg2: INTEGER);
152	BEGIN	152	BEGIN
153	OutByte(48H + reg1 DIV 8 + 4 * (reg2 DIV 8))	153	OutByte(48H + reg1 DIV 8 + 4 * (reg2 DIV 8))
154	END Rex;	154	END Rex;
155		155
156		156
157	PROCEDURE lea (reg, offset, section: INTEGER);	157	PROCEDURE lea (reg, offset, section: INTEGER);
158	BEGIN	158	BEGIN
159	Rex(0, reg);	159	Rex(0, reg);
160	OutByte2(8DH, 05H + 8 * (reg MOD 8)); (* lea reg, [rip + offset] *)	160	OutByte2(8DH, 05H + 8 * (reg MOD 8)); (* lea reg, [rip + offset] *)
161	X86.Reloc(section, offset)	161	X86.Reloc(section, offset)
162	END lea;	162	END lea;
163		163
164		164
165	PROCEDURE oprr (op: BYTE; reg1, reg2: INTEGER); (* op reg1, reg2 *)	165	PROCEDURE oprr (op: BYTE; reg1, reg2: INTEGER); (* op reg1, reg2 *)
166	BEGIN	166	BEGIN
167	Rex(reg1, reg2);	167	Rex(reg1, reg2);
168	OutByte2(op, 0C0H + 8 * (reg2 MOD 8) + reg1 MOD 8)	168	OutByte2(op, 0C0H + 8 * (reg2 MOD 8) + reg1 MOD 8)
169	END oprr;	169	END oprr;
170		170
171		171
172	PROCEDURE oprr2 (op1, op2: BYTE; reg1, reg2: INTEGER); (* op reg1, reg2 *)	172	PROCEDURE oprr2 (op1, op2: BYTE; reg1, reg2: INTEGER); (* op reg1, reg2 *)
173	BEGIN	173	BEGIN
174	Rex(reg1, reg2);	174	Rex(reg1, reg2);
175	OutByte3(op1, op2, 0C0H + 8 * (reg2 MOD 8) + reg1 MOD 8)	175	OutByte3(op1, op2, 0C0H + 8 * (reg2 MOD 8) + reg1 MOD 8)
176	END oprr2;	176	END oprr2;
177		177
178		178
179	PROCEDURE mov (reg1, reg2: INTEGER); (* mov reg1, reg2 *)	179	PROCEDURE mov (reg1, reg2: INTEGER); (* mov reg1, reg2 *)
180	BEGIN	180	BEGIN
181	oprr(89H, reg1, reg2)	181	oprr(89H, reg1, reg2)
182	END mov;	182	END mov;
183		183
184		184
185	PROCEDURE xor (reg1, reg2: INTEGER); (* xor reg1, reg2 *)	185	PROCEDURE xor (reg1, reg2: INTEGER); (* xor reg1, reg2 *)
186	BEGIN	186	BEGIN
187	oprr(31H, reg1, reg2)	187	oprr(31H, reg1, reg2)
188	END xor;	188	END xor;
189		189
190		190
191	PROCEDURE and (reg1, reg2: INTEGER); (* and reg1, reg2 *)	191	PROCEDURE and (reg1, reg2: INTEGER); (* and reg1, reg2 *)
192	BEGIN	192	BEGIN
193	oprr(21H, reg1, reg2)	193	oprr(21H, reg1, reg2)
194	END and;	194	END and;
195		195
196		196
197	PROCEDURE _or (reg1, reg2: INTEGER); (* or reg1, reg2 *)	197	PROCEDURE _or (reg1, reg2: INTEGER); (* or reg1, reg2 *)
198	BEGIN	198	BEGIN
199	oprr(09H, reg1, reg2)	199	oprr(09H, reg1, reg2)
200	END _or;	200	END _or;
201		201
202		202
203	PROCEDURE add (reg1, reg2: INTEGER); (* add reg1, reg2 *)	203	PROCEDURE add (reg1, reg2: INTEGER); (* add reg1, reg2 *)
204	BEGIN	204	BEGIN
205	oprr(01H, reg1, reg2)	205	oprr(01H, reg1, reg2)
206	END add;	206	END add;
207		207
208		208
209	PROCEDURE sub (reg1, reg2: INTEGER); (* sub reg1, reg2 *)	209	PROCEDURE sub (reg1, reg2: INTEGER); (* sub reg1, reg2 *)
210	BEGIN	210	BEGIN
211	oprr(29H, reg1, reg2)	211	oprr(29H, reg1, reg2)
212	END sub;	212	END sub;
213		213
214		214
215	PROCEDURE xchg (reg1, reg2: INTEGER); (* xchg reg1, reg2 *)	215	PROCEDURE xchg (reg1, reg2: INTEGER); (* xchg reg1, reg2 *)
216	BEGIN	216	BEGIN
217	IF rax IN {reg1, reg2} THEN	217	IF rax IN {reg1, reg2} THEN
218	Rex(reg1 + reg2, 0);	218	Rex(reg1 + reg2, 0);
219	OutByte(90H + (reg1 + reg2) MOD 8)	219	OutByte(90H + (reg1 + reg2) MOD 8)
220	ELSE	220	ELSE
221	oprr(87H, reg1, reg2)	221	oprr(87H, reg1, reg2)
222	END	222	END
223	END xchg;	223	END xchg;
224		224
225		225
226	PROCEDURE cmprr (reg1, reg2: INTEGER); (* cmp reg1, reg2 *)	226	PROCEDURE cmprr (reg1, reg2: INTEGER); (* cmp reg1, reg2 *)
227	BEGIN	227	BEGIN
228	oprr(39H, reg1, reg2)	228	oprr(39H, reg1, reg2)
229	END cmprr;	229	END cmprr;
230		230
231		231
232	PROCEDURE pop (reg: INTEGER); (* pop reg *)	232	PROCEDURE pop (reg: INTEGER); (* pop reg *)
233	BEGIN	233	BEGIN
234	IF reg >= 8 THEN	234	IF reg >= 8 THEN
235	OutByte(41H)	235	OutByte(41H)
236	END;	236	END;
237	OutByte(58H + reg MOD 8)	237	OutByte(58H + reg MOD 8)
238	END pop;	238	END pop;
239		239
240		240
241	PROCEDURE push (reg: INTEGER); (* push reg *)	241	PROCEDURE push (reg: INTEGER); (* push reg *)
242	BEGIN	242	BEGIN
243	IF reg >= 8 THEN	243	IF reg >= 8 THEN
244	OutByte(41H)	244	OutByte(41H)
245	END;	245	END;
246	OutByte(50H + reg MOD 8)	246	OutByte(50H + reg MOD 8)
247	END push;	247	END push;
248		248
249		249
250	PROCEDURE decr (reg: INTEGER);	250	PROCEDURE decr (reg: INTEGER);
251	BEGIN	251	BEGIN
252	Rex(reg, 0);	252	Rex(reg, 0);
253	OutByte2(0FFH, 0C8H + reg MOD 8) (* dec reg1 *)	253	OutByte2(0FFH, 0C8H + reg MOD 8) (* dec reg1 *)
254	END decr;	254	END decr;
255		255
256		256
257	PROCEDURE incr (reg: INTEGER);	257	PROCEDURE incr (reg: INTEGER);
258	BEGIN	258	BEGIN
259	Rex(reg, 0);	259	Rex(reg, 0);
260	OutByte2(0FFH, 0C0H + reg MOD 8) (* inc reg1 *)	260	OutByte2(0FFH, 0C0H + reg MOD 8) (* inc reg1 *)
261	END incr;	261	END incr;
262		262
263		263
264	PROCEDURE drop;	264	PROCEDURE drop;
265	BEGIN	265	BEGIN
266	REG.Drop(R)	266	REG.Drop(R)
267	END drop;	267	END drop;
268		268
269		269
270	PROCEDURE GetAnyReg (): INTEGER;	270	PROCEDURE GetAnyReg (): INTEGER;
271	RETURN REG.GetAnyReg(R)	271	RETURN REG.GetAnyReg(R)
272	END GetAnyReg;	272	END GetAnyReg;
273		273
274		-
275	PROCEDURE GetVarReg (offs: INTEGER): INTEGER;	-
276	RETURN REG.GetVarReg(R, offs)	-
277	END GetVarReg;	-
278		-
279		274
280	PROCEDURE callimp (label: INTEGER);	275	PROCEDURE callimp (label: INTEGER);
281	BEGIN	276	BEGIN
282	OutByte2(0FFH, 15H); (* call qword[rip + label + IMP] *)	277	OutByte2(0FFH, 15H); (* call qword[rip + label + IMP] *)
283	X86.Reloc(sIMP, label)	278	X86.Reloc(sIMP, label)
284	END callimp;	279	END callimp;
285		280
286		281
287	PROCEDURE pushDA (offs: INTEGER);	282	PROCEDURE pushDA (offs: INTEGER);
288	VAR	283	VAR
289	reg: INTEGER;	284	reg: INTEGER;
290		285
291	BEGIN	286	BEGIN
292	reg := GetAnyReg();	287	reg := GetAnyReg();
293	lea(reg, offs, sDATA);	288	lea(reg, offs, sDATA);
294	push(reg);	289	push(reg);
295	drop	290	drop
296	END pushDA;	291	END pushDA;
297		292
298		293
299	PROCEDURE CallRTL (proc: INTEGER);	294	PROCEDURE CallRTL (proc: INTEGER);
300	VAR	295	VAR
301	label: INTEGER;	296	label: INTEGER;
302		297
303	BEGIN	298	BEGIN
304	REG.Store(R);	-
305	label := IL.codes.rtl[proc];	299	label := IL.codes.rtl[proc];
306	IF label < 0 THEN	300	IF label < 0 THEN
307	callimp(-label)	301	callimp(-label)
308	ELSE	302	ELSE
309	X86.call(label)	303	X86.call(label)
310	END;	304	END
311	REG.Restore(R)	-
312	END CallRTL;	305	END CallRTL;
313		306
314		307
315	PROCEDURE UnOp (VAR reg: INTEGER);	308	PROCEDURE UnOp (VAR reg: INTEGER);
316	BEGIN	309	BEGIN
317	REG.UnOp(R, reg)	310	REG.UnOp(R, reg)
318	END UnOp;	311	END UnOp;
319		312
320		313
321	PROCEDURE BinOp (VAR reg1, reg2: INTEGER);	314	PROCEDURE BinOp (VAR reg1, reg2: INTEGER);
322	BEGIN	315	BEGIN
323	REG.BinOp(R, reg1, reg2)	316	REG.BinOp(R, reg1, reg2)
324	END BinOp;	317	END BinOp;
325		318
326		319
327	PROCEDURE PushAll (NumberOfParameters: INTEGER);	320	PROCEDURE PushAll (NumberOfParameters: INTEGER);
328	BEGIN	321	BEGIN
329	REG.PushAll(R);	322	REG.PushAll(R);
330	DEC(R.pushed, NumberOfParameters)	323	DEC(R.pushed, NumberOfParameters)
331	END PushAll;	324	END PushAll;
332		325
333		326
334	PROCEDURE movabs (reg, n: INTEGER);	327	PROCEDURE movabs (reg, n: INTEGER);
335	VAR	328	VAR
336	i: INTEGER;	329	i: INTEGER;
337		330
338	BEGIN	331	BEGIN
339	Rex(reg, 0);	332	Rex(reg, 0);
340	OutByte(0B8H + reg MOD 8); (* movabs reg, n *)	333	OutByte(0B8H + reg MOD 8); (* movabs reg, n *)
341	FOR i := 0 TO 7 DO	334	FOR i := 0 TO 7 DO
342	OutByte(UTILS.Byte(n, i))	335	OutByte(UTILS.Byte(n, i))
343	END	336	END
344	END movabs;	337	END movabs;
345		338
346		339
347	PROCEDURE movrc (reg, n: INTEGER); (* mov reg, n *)	340	PROCEDURE movrc (reg, n: INTEGER); (* mov reg, n *)
348	BEGIN	341	BEGIN
349	IF isLong(n) THEN	342	IF isLong(n) THEN
350	movabs(reg, n)	343	movabs(reg, n)
351	ELSIF n = 0 THEN	344	ELSIF n = 0 THEN
352	xor(reg, reg)	345	xor(reg, reg)
353	ELSE	346	ELSE
354	Rex(reg, 0);	347	Rex(reg, 0);
355	OutByte2(0C7H, 0C0H + reg MOD 8);	348	OutByte2(0C7H, 0C0H + reg MOD 8);
356	OutInt(n)	349	OutInt(n)
357	END	350	END
358	END movrc;	351	END movrc;
359		352
360		353
361	PROCEDURE test (reg: INTEGER); (* test reg, reg *)	354	PROCEDURE test (reg: INTEGER); (* test reg, reg *)
362	BEGIN	355	BEGIN
363	oprr(85H, reg, reg)	356	oprr(85H, reg, reg)
364	END test;	357	END test;
365		358
366		359
367	PROCEDURE oprlongc (reg, n: INTEGER; oprr: OPRR);	360	PROCEDURE oprlongc (reg, n: INTEGER; oprr: OPRR);
368	VAR	361	VAR
369	reg2: INTEGER;	362	reg2: INTEGER;
370		363
371	BEGIN	364	BEGIN
372	reg2 := GetAnyReg();	365	reg2 := GetAnyReg();
373	ASSERT(reg2 # reg);	366	ASSERT(reg2 # reg);
374	movabs(reg2, n);	367	movabs(reg2, n);
375	oprr(reg, reg2);	368	oprr(reg, reg2);
376	drop	369	drop
377	END oprlongc;	370	END oprlongc;
378		371
379		372
380	PROCEDURE oprc (op, reg, n: INTEGER; oprr: OPRR);	373	PROCEDURE oprc (op, reg, n: INTEGER; oprr: OPRR);
381	BEGIN	374	BEGIN
382	IF isLong(n) THEN	375	IF isLong(n) THEN
383	oprlongc(reg, n, oprr)	376	oprlongc(reg, n, oprr)
384	ELSE	377	ELSE
385	Rex(reg, 0);	378	Rex(reg, 0);
386	X86.oprc(op, reg, n)	379	X86.oprc(op, reg, n)
387	END	380	END
388	END oprc;	381	END oprc;
389		382
390		383
391	PROCEDURE cmprc (reg, n: INTEGER); (* cmp reg, n *)	384	PROCEDURE cmprc (reg, n: INTEGER); (* cmp reg, n *)
392	BEGIN	385	BEGIN
393	IF n = 0 THEN	386	IF n = 0 THEN
394	test(reg)	387	test(reg)
395	ELSE	388	ELSE
396	oprc(0F8H, reg, n, cmprr)	389	oprc(0F8H, reg, n, cmprr)
397	END	390	END
398	END cmprc;	391	END cmprc;
399		392
400		393
401	PROCEDURE addrc (reg, n: INTEGER); (* add reg, n *)	394	PROCEDURE addrc (reg, n: INTEGER); (* add reg, n *)
402	BEGIN	395	BEGIN
403	oprc(0C0H, reg, n, add)	396	oprc(0C0H, reg, n, add)
404	END addrc;	397	END addrc;
405		398
406		399
407	PROCEDURE subrc (reg, n: INTEGER); (* sub reg, n *)	400	PROCEDURE subrc (reg, n: INTEGER); (* sub reg, n *)
408	BEGIN	401	BEGIN
409	oprc(0E8H, reg, n, sub)	402	oprc(0E8H, reg, n, sub)
410	END subrc;	403	END subrc;
411		404
412		405
413	PROCEDURE andrc (reg, n: INTEGER); (* and reg, n *)	406	PROCEDURE andrc (reg, n: INTEGER); (* and reg, n *)
414	BEGIN	407	BEGIN
415	oprc(0E0H, reg, n, and)	408	oprc(0E0H, reg, n, and)
416	END andrc;	409	END andrc;
417		410
418		411
419	PROCEDURE orrc (reg, n: INTEGER); (* or reg, n *)	412	PROCEDURE orrc (reg, n: INTEGER); (* or reg, n *)
420	BEGIN	413	BEGIN
421	oprc(0C8H, reg, n, _or)	414	oprc(0C8H, reg, n, _or)
422	END orrc;	415	END orrc;
423		416
424		417
425	PROCEDURE xorrc (reg, n: INTEGER); (* xor reg, n *)	418	PROCEDURE xorrc (reg, n: INTEGER); (* xor reg, n *)
426	BEGIN	419	BEGIN
427	oprc(0F0H, reg, n, xor)	420	oprc(0F0H, reg, n, xor)
428	END xorrc;	421	END xorrc;
429		422
430		423
431	PROCEDURE pushc (n: INTEGER);	424	PROCEDURE pushc (n: INTEGER);
432	VAR	425	VAR
433	reg2: INTEGER;	426	reg2: INTEGER;
434		427
435	BEGIN	428	BEGIN
436	IF isLong(n) THEN	429	IF isLong(n) THEN
437	reg2 := GetAnyReg();	430	reg2 := GetAnyReg();
438	movabs(reg2, n);	431	movabs(reg2, n);
439	push(reg2);	432	push(reg2);
440	drop	433	drop
441	ELSE	434	ELSE
442	X86.pushc(n)	435	X86.pushc(n)
443	END	436	END
444	END pushc;	437	END pushc;
445		438
446		439
447	PROCEDURE not (reg: INTEGER); (* not reg *)	440	PROCEDURE not (reg: INTEGER); (* not reg *)
448	BEGIN	441	BEGIN
449	Rex(reg, 0);	442	Rex(reg, 0);
450	OutByte2(0F7H, 0D0H + reg MOD 8)	443	OutByte2(0F7H, 0D0H + reg MOD 8)
451	END not;	444	END not;
452		445
453		446
454	PROCEDURE neg (reg: INTEGER); (* neg reg *)	447	PROCEDURE neg (reg: INTEGER); (* neg reg *)
455	BEGIN	448	BEGIN
456	Rex(reg, 0);	449	Rex(reg, 0);
457	OutByte2(0F7H, 0D8H + reg MOD 8)	450	OutByte2(0F7H, 0D8H + reg MOD 8)
458	END neg;	451	END neg;
459		452
460		453
461	PROCEDURE movzx (reg1, reg2, offs: INTEGER; word: BOOLEAN); (* movzx reg1, byte/word[reg2 + offs] *)	454	PROCEDURE movzx (reg1, reg2, offs: INTEGER; word: BOOLEAN); (* movzx reg1, byte/word[reg2 + offs] *)
462	BEGIN	455	BEGIN
463	Rex(reg2, reg1);	456	Rex(reg2, reg1);
464	X86.movzx(reg1, reg2, offs, word)	457	X86.movzx(reg1, reg2, offs, word)
465	END movzx;	458	END movzx;
466		459
467		460
468	PROCEDURE movmr32 (reg1, offs, reg2: INTEGER); (* mov dword[reg1+offs], reg2_32 *)	461	PROCEDURE movmr32 (reg1, offs, reg2: INTEGER); (* mov dword[reg1+offs], reg2_32 *)
469	BEGIN	462	BEGIN
470	X86._movrm(reg2, reg1, offs, 32, TRUE)	463	X86._movrm(reg2, reg1, offs, 32, TRUE)
471	END movmr32;	464	END movmr32;
472		465
473		466
474	PROCEDURE movrm32 (reg1, reg2, offs: INTEGER); (* mov reg1_32, dword[reg2+offs] *)	467	PROCEDURE movrm32 (reg1, reg2, offs: INTEGER); (* mov reg1_32, dword[reg2+offs] *)
475	BEGIN	468	BEGIN
476	X86._movrm(reg1, reg2, offs, 32, FALSE)	469	X86._movrm(reg1, reg2, offs, 32, FALSE)
477	END movrm32;	470	END movrm32;
478		471
479		472
480	PROCEDURE movmr (reg1, offs, reg2: INTEGER); (* mov qword[reg1+offs], reg2 *)	473	PROCEDURE movmr (reg1, offs, reg2: INTEGER); (* mov qword[reg1+offs], reg2 *)
481	BEGIN	474	BEGIN
482	X86._movrm(reg2, reg1, offs, 64, TRUE)	475	X86._movrm(reg2, reg1, offs, 64, TRUE)
483	END movmr;	476	END movmr;
484		477
485		478
486	PROCEDURE movrm (reg1, reg2, offs: INTEGER); (* mov reg1, qword[reg2+offs] *)	479	PROCEDURE movrm (reg1, reg2, offs: INTEGER); (* mov reg1, qword[reg2+offs] *)
487	BEGIN	480	BEGIN
488	X86._movrm(reg1, reg2, offs, 64, FALSE)	481	X86._movrm(reg1, reg2, offs, 64, FALSE)
489	END movrm;	482	END movrm;
490		483
491		484
492	PROCEDURE comisd (xmm1, xmm2: INTEGER); (* comisd xmm1, xmm2 *)	485	PROCEDURE comisd (xmm1, xmm2: INTEGER); (* comisd xmm1, xmm2 *)
493	BEGIN	486	BEGIN
494	OutByte(66H);	487	OutByte(66H);
495	IF (xmm1 >= 8) OR (xmm2 >= 8) THEN	488	IF (xmm1 >= 8) OR (xmm2 >= 8) THEN
496	OutByte(40H + (xmm1 DIV 8) * 4 + xmm2 DIV 8)	489	OutByte(40H + (xmm1 DIV 8) * 4 + xmm2 DIV 8)
497	END;	490	END;
498	OutByte3(0FH, 2FH, 0C0H + (xmm1 MOD 8) * 8 + xmm2 MOD 8)	491	OutByte3(0FH, 2FH, 0C0H + (xmm1 MOD 8) * 8 + xmm2 MOD 8)
499	END comisd;	492	END comisd;
500		493

Subversion Repositories Kolibri OS

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