(*
    BSD 2-Clause License

    Copyright (c) 2018, 2019, Anton Krotov
    All rights reserved.
*)

MODULE AMD64;

IMPORT CODE, BIN, WR := WRITER, CHL := CHUNKLISTS, MACHINE, LISTS, PATHS,
       REG, C := CONSOLE, UTILS, mConst := CONSTANTS, S := STRINGS, PE32, ELF, X86;


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;

    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 = CODE.opLSL2; shr = CODE.opLSR2; sar = CODE.opASR2; ror = CODE.opROR2;

    sCODE = BIN.PICCODE;
    sDATA = BIN.PICDATA;
    sBSS  = BIN.PICBSS;
    sIMP  = BIN.PICIMP;


TYPE

    COMMAND = CODE.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;

    dllret: INTEGER;

    Win64RegPar: ARRAY 4 OF INTEGER;
    SystemVRegPar: ARRAY 6 OF INTEGER;


PROCEDURE OutByte (b: BYTE);
BEGIN
    X86.OutByte(b)
END OutByte;


PROCEDURE OutByte2 (a, b: BYTE);
BEGIN
    OutByte(a);
    OutByte(b)
END OutByte2;


PROCEDURE OutByte3 (a, b, c: BYTE);
BEGIN
    OutByte(a);
    OutByte(b);
    OutByte(c)
END OutByte3;


PROCEDURE OutInt (n: INTEGER);
BEGIN
    OutByte(MACHINE.Byte(n, 0));
    OutByte(MACHINE.Byte(n, 1));
    OutByte(MACHINE.Byte(n, 2));
    OutByte(MACHINE.Byte(n, 3))
END OutInt;


PROCEDURE isByte (n: INTEGER): BOOLEAN;
    RETURN (-128 <= n) & (n <= 127)
END isByte;


PROCEDURE short (n: INTEGER): INTEGER;
    RETURN 2 * ORD(isByte(n))
END short;


PROCEDURE long (n: INTEGER): INTEGER;
    RETURN 40H * ORD(~isByte(n))
END long;


PROCEDURE OutIntByte (n: INTEGER);
BEGIN
    IF isByte(n) THEN
        OutByte(MACHINE.Byte(n, 0))
    ELSE
        OutInt(n)
    END
END OutIntByte;


PROCEDURE isLong (n: INTEGER): BOOLEAN;
    RETURN (n > MACHINE.max32) OR (n < MACHINE.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 CODE.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); // and 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
    oprr(87H, reg1, reg2)
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 callimp (label: INTEGER);
VAR
    reg: INTEGER;

BEGIN
    reg := REG.GetAnyReg(R);
    lea(reg, label, sIMP);
    IF reg >= 8 THEN // call qword[reg]
        OutByte(41H)
    END;
    OutByte2(0FFH, 10H + reg MOD 8);
    drop
END callimp;


PROCEDURE pushDA (offs: INTEGER);
VAR
    reg: INTEGER;

BEGIN
    reg := REG.GetAnyReg(R);
    lea(reg, offs, sDATA);
    push(reg);
    drop
END pushDA;


PROCEDURE CallRTL (proc: INTEGER);
VAR
    label: INTEGER;

BEGIN
    REG.Store(R);
    label := CODE.codes.rtl[proc];
    IF label < 0 THEN
        callimp(-label)
    ELSE
        X86.call(label)
    END;
    REG.Restore(R)
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);
    R.pushed := 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(MACHINE.Byte(n, i))
    END
END movabs;


PROCEDURE movrc (reg, n: INTEGER); // mov reg, n
BEGIN
    IF isLong(n) THEN
        movabs(reg, n)
    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 := REG.GetAnyReg(R);
    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);
        OutByte2(81H + short(n), op + reg MOD 8);
        OutIntByte(n)
    END
END oprc;


PROCEDURE cmprc (reg, n: INTEGER); // cmp reg, n
BEGIN
    oprc(0F8H, reg, n, cmprr)
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 pushc (n: INTEGER);
VAR
    reg2: INTEGER;

BEGIN
    IF isLong(n) THEN
        reg2 := REG.GetAnyReg(R);
        movabs(reg2, n);
        push(reg2);
        drop
    ELSE
        OutByte(68H + short(n)); OutIntByte(n) // push 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]
VAR
    b: BYTE;

BEGIN
    Rex(reg2, reg1);
    OutByte2(0FH, 0B6H + ORD(word));
    IF (offs = 0) & (reg2 # rbp) THEN
        b := 0
    ELSE
        b := 40H + long(offs)
    END;
    OutByte(b + (reg1 MOD 8) * 8 + reg2 MOD 8);
    IF reg2 = rsp THEN
        OutByte(24H)
    END;
    IF b # 0 THEN
        OutIntByte(offs)
    END
END movzx;


PROCEDURE _movrm (reg1, reg2, offs, size: INTEGER; mr: BOOLEAN);
VAR
    b: BYTE;

BEGIN
    IF size = 16 THEN
        OutByte(66H)
    END;
    IF (reg1 >= 8) OR (reg2 >= 8) OR (size = 64) THEN
        OutByte(40H + reg2 DIV 8 + 4 * (reg1 DIV 8) + 8 * ORD(size = 64))
    END;
    OutByte(8BH - 2 * ORD(mr) - ORD(size = 8));
    IF (offs = 0) & (reg2 # rbp) THEN
        b := 0
    ELSE
        b := 40H + long(offs)
    END;
    OutByte(b + (reg1 MOD 8) * 8 + reg2 MOD 8);
    IF reg2 = rsp THEN
        OutByte(24H)
    END;
    IF b # 0 THEN
        OutIntByte(offs)
    END
END _movrm;


PROCEDURE movmr32 (reg1, offs, reg2: INTEGER); // mov dword[reg1+offs], reg2_32
BEGIN
    _movrm(reg2, reg1, offs, 32, TRUE)
END movmr32;


PROCEDURE movrm32 (reg1, reg2, offs: INTEGER); // mov reg1_32, dword[reg2+offs]
BEGIN
    _movrm(reg1, reg2, offs, 32, FALSE)
END movrm32;


PROCEDURE movmr8 (reg1, offs, reg2: INTEGER); // mov byte[reg1+offs], reg2_8
BEGIN
    _movrm(reg2, reg1, offs, 8, TRUE)
END movmr8;


PROCEDURE movrm8 (reg1, reg2, offs: INTEGER); // mov reg1_8, byte[reg2+offs]
BEGIN
    _movrm(reg1, reg2, offs, 8, FALSE)
END movrm8;


PROCEDURE movmr16 (reg1, offs, reg2: INTEGER); // mov word[reg1+offs], reg2_16
BEGIN
    _movrm(reg2, reg1, offs, 16, TRUE)
END movmr16;


PROCEDURE movrm16 (reg1, reg2, offs: INTEGER); // mov reg1_16, word[reg2+offs]
BEGIN
    _movrm(reg1, reg2, offs, 16, FALSE)
END movrm16;


PROCEDURE movmr (reg1, offs, reg2: INTEGER); // mov qword[reg1+offs], reg2
BEGIN
    _movrm(reg2, reg1, offs, 64, TRUE)
END movmr;


PROCEDURE movrm (reg1, reg2, offs: INTEGER); // mov reg1, qword[reg2+offs]
BEGIN
    _movrm(reg1, reg2, offs, 64, FALSE)
END movrm;


PROCEDURE pushm (reg, offs: INTEGER); // push qword[reg+offs]
VAR
    b: BYTE;

BEGIN
    IF reg >= 8 THEN
        OutByte(41H)
    END;
    OutByte(0FFH);
    IF (offs = 0) & (reg # rbp) THEN
        b := 30H
    ELSE
        b := 70H + long(offs)
    END;
    OutByte(b + reg MOD 8);
    IF reg = rsp THEN
        OutByte(24H)
    END;
    IF b # 30H THEN
        OutIntByte(offs)
    END
END pushm;


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 jmp (label: INTEGER); // jmp label
BEGIN
    X86.jmp(label)
END jmp;


PROCEDURE setcc (cc, reg: INTEGER); //setcc reg8
BEGIN
    IF reg >= 8 THEN
        OutByte(41H)
    END;
    OutByte3(0FH, cc, 0C0H + reg MOD 8)
END setcc;


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 getVar (variables: LISTS.LIST; offset: INTEGER): CODE.LOCALVAR;
VAR
    cur: CODE.LOCALVAR;

BEGIN
    cur := variables.first(CODE.LOCALVAR);
    WHILE (cur # NIL) & (cur.offset # offset) DO
        cur := cur.next(CODE.LOCALVAR)
    END

    RETURN cur
END getVar;


PROCEDURE allocReg (cmd: COMMAND);
VAR
    leave:      BOOLEAN;
    leaf:       BOOLEAN;
    cur:        COMMAND;
    variables:  LISTS.LIST;
    lvar, rvar: CODE.LOCALVAR;
    reg:        INTEGER;
    max:        INTEGER;
    loop:       INTEGER;
    param2:     INTEGER;

BEGIN
    loop := 1;
    variables := cmd.variables;
    leave := FALSE;
    leaf := TRUE;

    cur := cmd.next(COMMAND);
    REPEAT
        CASE cur.opcode OF
        |CODE.opLLOAD64,
         CODE.opLLOAD8,
         CODE.opLLOAD16,
         CODE.opLLOAD32,
         CODE.opLLOAD64_PARAM,
         CODE.opLLOAD32_PARAM,
         CODE.opLADR_SAVE,
         CODE.opLADR_INC1,
         CODE.opLADR_DEC1,
         CODE.opLADR_INC,
         CODE.opLADR_DEC,
         CODE.opLADR_INC1B,
         CODE.opLADR_DEC1B,
         CODE.opLADR_INCB,
         CODE.opLADR_DECB,
         CODE.opLADR_INCL,
         CODE.opLADR_EXCL,
         CODE.opLADR_UNPK:
            lvar := getVar(variables, cur.param2);
            IF (lvar # NIL) & (lvar.count # -1) THEN
                INC(lvar.count, loop)
            END

        |CODE.opLADR_SAVEC,
         CODE.opLADR_INCC,
         CODE.opLADR_DECC,
         CODE.opLADR_INCCB,
         CODE.opLADR_DECCB,
         CODE.opLADR_INCLC,
         CODE.opLADR_EXCLC:
            lvar := getVar(variables, cur.param1);
            IF (lvar # NIL) & (lvar.count # -1) THEN
                INC(lvar.count, loop)
            END

        |CODE.opLADR:
            lvar := getVar(variables, cur.param2);
            IF (lvar # NIL) & (lvar.count # -1) THEN
                lvar.count := -1
            END

        |CODE.opLOOP:
            INC(loop, 10)

        |CODE.opENDLOOP:
            DEC(loop, 10)

        |CODE.opLEAVE,
         CODE.opLEAVER,
         CODE.opLEAVEF:
            leave := TRUE

        |CODE.opCALL, CODE.opCALLP, CODE.opCALLI,
         CODE.opWIN64CALL, CODE.opWIN64CALLP, CODE.opWIN64CALLI,
         CODE.opSYSVCALL, CODE.opSYSVCALLP, CODE.opSYSVCALLI,

         CODE.opSAVES, CODE.opRSET, CODE.opRSETR,
         CODE.opRSETL, CODE.opRSET1,
         CODE.opEQS .. CODE.opGES,
         CODE.opEQS2 .. CODE.opGES2,
         CODE.opEQSW .. CODE.opGESW,
         CODE.opEQSW2 .. CODE.opGESW2,
         CODE.opCOPY, CODE.opMOVE, CODE.opCOPYA,
         CODE.opCOPYS, CODE.opCOPYS2, CODE.opROT,
         CODE.opNEW, CODE.opDISP, CODE.opISREC,
         CODE.opIS, CODE.opTYPEGR, CODE.opTYPEGP,
         CODE.opCASET, CODE.opDIV,
         CODE.opDIVL, CODE.opMOD,
         CODE.opMODL, CODE.opLENGTH, CODE.opLENGTHW:
            leaf := FALSE

        |CODE.opDIVR, CODE.opMODR:
            param2 := cur.param2;
            IF param2 >= 1 THEN
                param2 := X86.log2(param2)
            ELSIF param2 <= -1 THEN
                param2 := X86.log2(-param2)
            ELSE
                param2 := -1
            END;
            IF param2 < 0 THEN
                leaf := FALSE
            END

        ELSE

        END;
        cur := cur.next(COMMAND)
    UNTIL leave OR ~leaf;

    IF leaf THEN
        REPEAT
            reg := -1;
            max := -1;
            rvar := NIL;
            lvar := variables.first(CODE.LOCALVAR);
            WHILE lvar # NIL DO
                IF lvar.count > max THEN
                    max := lvar.count;
                    rvar := lvar
                END;
                lvar := lvar.next(CODE.LOCALVAR)
            END;

            IF rvar # NIL THEN
                reg := REG.GetAnyVarReg(R);
                IF reg # -1 THEN
                    REG.Lock(R, reg, rvar.offset, rvar.size);
                    REG.Load(R, reg);
                    rvar.count := -1
                END
            END

        UNTIL (rvar = NIL) OR (reg = -1)
    END

END allocReg;


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(r10 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(r10, rsp, ofs);
            movmr(rsp, p, r10);
            INC(p, 8)
        END
    END
END SysVPassing;


PROCEDURE fcmp (op: INTEGER; xmm: INTEGER);
VAR
    cc, reg: INTEGER;

BEGIN
    reg := REG.GetAnyReg(R);
    xor(reg, reg);
    CASE op OF
    |CODE.opEQF, CODE.opEQFI:
        comisd(xmm - 1, xmm);
        cc := sete

    |CODE.opNEF, CODE.opNEFI:
        comisd(xmm - 1, xmm);
        cc := setne

    |CODE.opLTF, CODE.opGTFI:
        comisd(xmm - 1, xmm);
        cc := setc

    |CODE.opGTF, CODE.opLTFI:
        comisd(xmm, xmm - 1);
        cc := setc

    |CODE.opLEF, CODE.opGEFI:
        comisd(xmm, xmm - 1);
        cc := setnc

    |CODE.opGEF, CODE.opLEFI:
        comisd(xmm - 1, xmm);
        cc := setnc
    END;
    OutByte2(7AH, 3 + reg DIV 8); // jp L
    setcc(cc, reg);
    //L:
END fcmp;


PROCEDURE translate (commands: LISTS.LIST; stroffs: INTEGER);
VAR
    cmd, next: COMMAND;

    param1, param2, param3, a, b, c, n, label, L, i, cc: INTEGER;

    reg1, reg2, xmm: INTEGER;

    float: REAL;

    regVar: BOOLEAN;

BEGIN
    xmm := -1;
    cmd := commands.first(COMMAND);
    WHILE cmd # NIL DO

        param1 := cmd.param1;
        param2 := cmd.param2;

        CASE cmd.opcode OF

        |CODE.opJMP:
            jmp(param1)

        |CODE.opCALL, CODE.opWIN64CALL, CODE.opSYSVCALL:
            REG.Store(R);
            CASE cmd.opcode OF
            |CODE.opCALL:
            |CODE.opWIN64CALL: Win64Passing(param2)
            |CODE.opSYSVCALL:  SysVPassing(param2)
            END;
            X86.call(param1);
            REG.Restore(R)

        |CODE.opCALLP, CODE.opWIN64CALLP, CODE.opSYSVCALLP:
            UnOp(reg1);
            IF reg1 # rax THEN
                GetRegA;
                ASSERT(REG.Exchange(R, reg1, rax));
                drop
            END;
            drop;
            REG.Store(R);
            CASE cmd.opcode OF
            |CODE.opCALLP:
            |CODE.opWIN64CALLP: Win64Passing(param2)
            |CODE.opSYSVCALLP:  SysVPassing(param2)
            END;
            OutByte2(0FFH, 0D0H); // call rax
            REG.Restore(R);
            ASSERT(R.top = -1)

        |CODE.opCALLI, CODE.opWIN64CALLI, CODE.opSYSVCALLI:
            REG.Store(R);
            CASE cmd.opcode OF
            |CODE.opCALLI:
            |CODE.opWIN64CALLI: Win64Passing(param2)
            |CODE.opSYSVCALLI:  SysVPassing(param2)
            END;
            callimp(param1);
            REG.Restore(R)

        |CODE.opLABEL:
            X86.SetLabel(param2)

        |CODE.opERR:
            CallRTL(CODE._error)

        |CODE.opERRC:
            pushc(param2)

        |CODE.opPRECALL:
            n := param2;
            IF (param1 # 0) & (n # 0) THEN
                subrc(rsp, 8)
            END;
            WHILE n > 0 DO
                subrc(rsp, 8);
                movsdmr(rsp, 0, xmm);
                DEC(xmm);
                DEC(n)
            END;
            ASSERT(xmm = -1);
            PushAll(0)

        |CODE.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)

        |CODE.opSYSVALIGN16:
            ASSERT(rax IN R.regs);
            mov(rax, rsp);
            andrc(rsp, -16);
            push(rax);
            IF ~ODD(param2) THEN
                push(rax)
            END

        |CODE.opRESF:
            ASSERT(xmm = -1);
            INC(xmm);
            n := param2;
            IF n > 0 THEN
                movsdmr(rsp, n * 8, xmm);
                DEC(xmm);
                INC(n)
            END;

            WHILE n > 0 DO
                INC(xmm);
                movsdrm(xmm, rsp, 0);
                addrc(rsp, 8);
                DEC(n)
            END

        |CODE.opRES:
            ASSERT(R.top = -1);
            GetRegA;
            n := param2;
            WHILE n > 0 DO
                INC(xmm);
                movsdrm(xmm, rsp, 0);
                addrc(rsp, 8);
                DEC(n)
            END

        |CODE.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(r10);
                subrc(rsp, n);
                push(r10);
                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(r10, rbp, n + c);
                            movmr(rbp, i, r10);
                            INC(c, 8)
                        END
                    ELSE
                        IF a <= 5 THEN
                            movmr(rbp, i, SystemVRegPar[a]);
                            INC(a)
                        ELSE
                            movrm(r10, rbp, n + c);
                            movmr(rbp, i, r10);
                            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;

            IF cmd.allocReg THEN
                allocReg(cmd)
            END

        |CODE.opLEAVE, CODE.opLEAVER, CODE.opLEAVEF:
            IF cmd.opcode = CODE.opLEAVER THEN
                UnOp(reg1);
                IF reg1 # rax THEN
                    GetRegA;
                    ASSERT(REG.Exchange(R, reg1, rax));
                    drop
                END;
                drop
            END;

            ASSERT(R.top = -1);

            IF cmd.opcode = CODE.opLEAVEF THEN
                DEC(xmm)
            END;

            ASSERT(xmm = -1);

            mov(rsp, rbp);
            pop(rbp);
            IF param2 > 0 THEN
                OutByte3(0C2H, (param2 * 8) MOD 256, (param2 * 8) DIV 256)  // ret param2
            ELSE
                OutByte(0C3H) // ret
            END;
            REG.Reset(R)

        |CODE.opSAVES:
            UnOp(reg1);
            drop;
            PushAll(0);
            push(reg1);
            pushDA(stroffs + param2);
            pushc(param1);
            CallRTL(CODE._move)

        |CODE.opSADR:
            reg1 := REG.GetAnyReg(R);
            lea(reg1, stroffs + param2, sDATA)

        |CODE.opLOAD8:
            UnOp(reg1);
            movzx(reg1, reg1, 0, FALSE)

        |CODE.opLOAD16:
            UnOp(reg1);
            movzx(reg1, reg1, 0, TRUE)

        |CODE.opLOAD32:
            UnOp(reg1);
            movrm32(reg1, reg1, 0);
            shiftrc(shl, reg1, 32);
            shiftrc(shr, reg1, 32)

        |CODE.opLOAD64:
            UnOp(reg1);
            movrm(reg1, reg1, 0)

        |CODE.opLLOAD64:
            reg1 := REG.GetAnyReg(R);
            reg2 := REG.GetVarReg(R, param2);
            IF reg2 # -1 THEN
                mov(reg1, reg2)
            ELSE
                movrm(reg1, rbp, param2 * 8)
            END

        |CODE.opLLOAD8,
         CODE.opLLOAD16:
            reg1 := REG.GetAnyReg(R);
            reg2 := REG.GetVarReg(R, param2);
            IF reg2 # -1 THEN
                mov(reg1, reg2)
            ELSE
                movzx(reg1, rbp, param2 * 8, cmd.opcode = CODE.opLLOAD16)
            END

        |CODE.opLLOAD32:
            reg1 := REG.GetAnyReg(R);
            reg2 := REG.GetVarReg(R, param2);
            IF reg2 # -1 THEN
                mov(reg1, reg2)
            ELSE
                n := param2 * 8;
                xor(reg1, reg1);
                movrm32(reg1, rbp, n)
            END

        |CODE.opGLOAD64:
            reg1 := REG.GetAnyReg(R);
            lea(reg1, param2, sBSS);
            movrm(reg1, reg1, 0)

        |CODE.opGLOAD8:
            reg1 := REG.GetAnyReg(R);
            lea(reg1, param2, sBSS);
            movzx(reg1, reg1, 0, FALSE)

        |CODE.opGLOAD16:
            reg1 := REG.GetAnyReg(R);
            lea(reg1, param2, sBSS);
            movzx(reg1, reg1, 0, TRUE)

        |CODE.opGLOAD32:
            reg1 := REG.GetAnyReg(R);
            xor(reg1, reg1);
            lea(reg1, param2, sBSS);
            movrm32(reg1, reg1, 0)

        |CODE.opVLOAD64:
            reg1 := REG.GetAnyReg(R);
            movrm(reg1, rbp, param2 * 8);
            movrm(reg1, reg1, 0)

        |CODE.opVLOAD8,
         CODE.opVLOAD16:
            reg1 := REG.GetAnyReg(R);
            movrm(reg1, rbp, param2 * 8);
            movzx(reg1, reg1, 0, cmd.opcode = CODE.opVLOAD16)

        |CODE.opVLOAD32:
            reg1 := REG.GetAnyReg(R);
            reg2 := REG.GetAnyReg(R);
            xor(reg1, reg1);
            movrm(reg2, rbp, param2 * 8);
            movrm32(reg1, reg2, 0);
            drop

        |CODE.opLADR:
            n := param2 * 8;
            next := cmd.next(COMMAND);
            IF next.opcode = CODE.opSAVEF THEN
                movsdmr(rbp, n, xmm);
                DEC(xmm);
                cmd := next
            ELSIF next.opcode = CODE.opLOADF THEN
                INC(xmm);
                movsdrm(xmm, rbp, n);
                cmd := next
            ELSE
                reg1 := REG.GetAnyReg(R);
                Rex(0, reg1);
                OutByte2(8DH, 45H + long(n) + (reg1 MOD 8) * 8);  // lea reg1, qword[rbp+n]
                OutIntByte(n)
            END

        |CODE.opGADR:
            reg1 := REG.GetAnyReg(R);
            lea(reg1, param2, sBSS)

        |CODE.opVADR:
            reg1 := REG.GetAnyReg(R);
            movrm(reg1, rbp, param2 * 8)

        |CODE.opSAVE8C:
            UnOp(reg1);
            IF reg1 >= 8 THEN
                OutByte(41H)
            END;
            OutByte3(0C6H, reg1 MOD 8, param2); // mov byte[reg1], param2
            drop

        |CODE.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

        |CODE.opSAVEC:
            UnOp(reg1);
            IF isLong(param2) THEN
                reg2 := REG.GetAnyReg(R);
                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

        |CODE.opRSET:
            PushAll(2);
            CallRTL(CODE._set);
            GetRegA

        |CODE.opRSETR:
            PushAll(1);
            pushc(param2);
            CallRTL(CODE._set);
            GetRegA

        |CODE.opRSETL:
            PushAll(1);
            pushc(param2);
            CallRTL(CODE._set2);
            GetRegA

        |CODE.opRSET1:
            UnOp(reg1);
            PushAll(1);
            push(reg1);
            CallRTL(CODE._set);
            GetRegA

        |CODE.opINCL, CODE.opEXCL:
            BinOp(reg1, reg2);
            cmprc(reg1, 64);
            OutByte2(73H, 04H); // jnb L
            Rex(reg2, reg1);
            OutByte3(0FH, 0ABH + 8 * ORD(cmd.opcode = CODE.opEXCL), 8 * (reg1 MOD 8) + reg2 MOD 8); // bts/btr qword[reg2], reg1
            // L:
            drop;
            drop

        |CODE.opINCLC, CODE.opEXCLC:
            UnOp(reg1);
            Rex(reg1, 0);
            OutByte2(0FH, 0BAH);  // bts/btr qword[reg1], param2
            OutByte2(28H + 8 * ORD(cmd.opcode = CODE.opEXCLC) + reg1 MOD 8, param2);
            drop

        |CODE.opEQS .. CODE.opGES:
            PushAll(4);
            pushc(cmd.opcode - CODE.opEQS);
            CallRTL(CODE._strcmp);
            GetRegA

        |CODE.opEQS2 .. CODE.opGES2:
            PushAll(4);
            pushc(cmd.opcode - CODE.opEQS2);
            CallRTL(CODE._strcmp2);
            GetRegA

        |CODE.opEQSW .. CODE.opGESW:
            PushAll(4);
            pushc(cmd.opcode - CODE.opEQSW);
            CallRTL(CODE._strcmpw);
            GetRegA

        |CODE.opEQSW2 .. CODE.opGESW2:
            PushAll(4);
            pushc(cmd.opcode - CODE.opEQSW2);
            CallRTL(CODE._strcmpw2);
            GetRegA

        |CODE.opINC1, CODE.opDEC1:
            UnOp(reg1);
            Rex(reg1, 0);
            OutByte2(0FFH, reg1 MOD 8 + 8 * ORD(cmd.opcode = CODE.opDEC1));
            drop

        |CODE.opCONST:
            reg1 := REG.GetAnyReg(R);
            movrc(reg1, param2)

        |CODE.opGT, CODE.opGE, CODE.opLT,
         CODE.opLE, CODE.opEQ, CODE.opNE:
            BinOp(reg1, reg2);
            cmprr(reg1, reg2);
            drop;
            drop;
            cc := X86.cond(cmd.opcode);

            IF cmd.next(COMMAND).opcode = CODE.opJE THEN
                label := cmd.next(COMMAND).param1;
                jcc(cc, label);
                cmd := cmd.next(COMMAND)

            ELSIF cmd.next(COMMAND).opcode = CODE.opJNE THEN
                label := cmd.next(COMMAND).param1;
                jcc(X86.inv1(cc), label);
                cmd := cmd.next(COMMAND)

            ELSE
                reg1 := REG.GetAnyReg(R);
                setcc(cc + 16, reg1);
                andrc(reg1, 1)
            END

        |CODE.opGTR, CODE.opLTL, CODE.opGER, CODE.opLEL,
         CODE.opLER, CODE.opGEL, CODE.opLTR, CODE.opGTL,
         CODE.opEQR, CODE.opEQL, CODE.opNER, CODE.opNEL:
            UnOp(reg1);
            IF param2 = 0 THEN
                test(reg1)
            ELSE
                cmprc(reg1, param2)
            END;
            drop;
            cc := X86.cond(cmd.opcode);

            IF cmd.next(COMMAND).opcode = CODE.opJE THEN
                label := cmd.next(COMMAND).param1;
                jcc(cc, label);
                cmd := cmd.next(COMMAND)

            ELSIF cmd.next(COMMAND).opcode = CODE.opJNE THEN
                label := cmd.next(COMMAND).param1;
                jcc(X86.inv1(cc), label);
                cmd := cmd.next(COMMAND)

            ELSE
                reg1 := REG.GetAnyReg(R);
                setcc(cc + 16, reg1);
                andrc(reg1, 1)
            END

        |CODE.opCODE:
            OutByte(param2)

        |CODE.opPUSHIP:
            reg1 := REG.GetAnyReg(R);
            lea(reg1, param2, sIMP);
            movrm(reg1, reg1, 0)

        |CODE.opPARAM:
            n := param2;
            IF n = 1 THEN
                UnOp(reg1);
                push(reg1);
                drop
            ELSE
                ASSERT(R.top + 1 <= n);
                PushAll(n)
            END   
            
        |CODE.opACC:
            IF (R.top # 0) OR (R.stk[0] # rax) THEN
                PushAll(0);
                GetRegA;
                pop(rax);
                DEC(R.pushed)
            END

        |CODE.opJNZ:
            UnOp(reg1);
            test(reg1);
            jcc(jne, param1)

        |CODE.opJZ:
            UnOp(reg1);
            test(reg1);
            jcc(je, param1)

        |CODE.opJE:
            UnOp(reg1);
            test(reg1);
            jcc(jne, param1);
            drop

        |CODE.opJNE:
            UnOp(reg1);
            test(reg1);
            jcc(je, param1);
            drop

        |CODE.opIN:
            label := NewLabel();
            L := NewLabel();
            BinOp(reg1, reg2);
            cmprc(reg1, 64);
            jcc(jb, L);
            xor(reg1, reg1);
            jmp(label);
            X86.SetLabel(L);
            Rex(reg2, reg1);
            OutByte3(0FH, 0A3H, 0C0H + 8 * (reg1 MOD 8) + reg2 MOD 8); // bt reg2, reg1
            setcc(setc, reg1);
            andrc(reg1, 1);
            X86.SetLabel(label);
            drop

        |CODE.opINR:
            label := NewLabel();
            L := NewLabel();
            UnOp(reg1);
            reg2 := REG.GetAnyReg(R);
            cmprc(reg1, 64);
            jcc(jb, L);
            xor(reg1, reg1);
            jmp(label);
            X86.SetLabel(L);
            movrc(reg2, param2);
            Rex(reg2, reg1);
            OutByte3(0FH, 0A3H, 0C0H + 8 * (reg1 MOD 8) + reg2 MOD 8); // bt reg2, reg1
            setcc(setc, reg1);
            andrc(reg1, 1);
            X86.SetLabel(label);
            drop

        |CODE.opINL:
            UnOp(reg1);
            Rex(reg1, 0);
            OutByte2(0FH, 0BAH);  // bt reg1, param2
            OutByte2(0E0H + reg1 MOD 8, param2);
            setcc(setc, reg1);
            andrc(reg1, 1)

        |CODE.opNOT:
            UnOp(reg1);
            test(reg1);
            setcc(sete, reg1);
            andrc(reg1, 1)

        |CODE.opORD:
            UnOp(reg1);
            test(reg1);
            setcc(setne, reg1);
            andrc(reg1, 1)

        |CODE.opABS:
            UnOp(reg1);
            test(reg1);
            OutByte2(7DH, 03H); // jge L
            neg(reg1)
            // L:

        |CODE.opEQB, CODE.opNEB:
            BinOp(reg1, reg2);
            drop;
            drop;

            test(reg1);
            OutByte2(74H, 07H); // je L1
            movrc(reg1, 1);
            // L1:
            test(reg2);
            OutByte2(74H, 07H); // je L2
            movrc(reg2, 1);
            // L2:
            cmprr(reg1, reg2);
            reg1 := REG.GetAnyReg(R);
            IF cmd.opcode = CODE.opEQB THEN
                setcc(sete, reg1)
            ELSE
                setcc(setne, reg1)
            END;
            andrc(reg1, 1)

        |CODE.opMULSC:
            UnOp(reg1);
            andrc(reg1, param2)

        |CODE.opDIVSC, CODE.opADDSL, CODE.opADDSR:
            UnOp(reg1);
            Rex(reg1, 0);
            OutByte2(81H + short(param2), 0C8H + 28H * ORD(cmd.opcode = CODE.opDIVSC) + reg1 MOD 8); // or/xor reg1, param2
            OutIntByte(param2)

        |CODE.opSUBSL:
            UnOp(reg1);
            not(reg1);
            andrc(reg1, param2)

        |CODE.opSUBSR:
            UnOp(reg1);
            andrc(reg1, ORD(-BITS(param2)))

        |CODE.opMULS:
            BinOp(reg1, reg2);
            and(reg1, reg2);
            drop

        |CODE.opDIVS:
            BinOp(reg1, reg2);
            xor(reg1, reg2);
            drop

        |CODE.opUMINS:
            UnOp(reg1);
            not(reg1)

        |CODE.opCOPY:
            PushAll(2);
            pushc(param2);
            CallRTL(CODE._move2)

        |CODE.opMOVE:
            PushAll(3);
            CallRTL(CODE._move2)

        |CODE.opCOPYA:
            PushAll(4);
            pushc(param2);
            CallRTL(CODE._arrcpy);
            GetRegA

        |CODE.opCOPYS:
            PushAll(4);
            pushc(param2);
            CallRTL(CODE._strcpy)

        |CODE.opCOPYS2:
            PushAll(4);
            pushc(param2);
            CallRTL(CODE._strcpy2)

        |CODE.opROT:
            PushAll(0);
            push(rsp);
            pushc(param2);
            CallRTL(CODE._rot)

        |CODE.opNEW:
            PushAll(1);
            n := param2 + 16;
            ASSERT(MACHINE.Align(n, 64));
            pushc(n);
            pushc(param1);
            CallRTL(CODE._new)

        |CODE.opDISP:
            PushAll(1);
            CallRTL(CODE._dispose)

        |CODE.opPUSHT:
            UnOp(reg1);
            reg2 := REG.GetAnyReg(R);
            movrm(reg2, reg1, -8)

        |CODE.opISREC:
            PushAll(2);
            pushc(param2);
            CallRTL(CODE._isrec);
            GetRegA

        |CODE.opIS:
            PushAll(1);
            pushc(param2);
            CallRTL(CODE._is);
            GetRegA

        |CODE.opTYPEGR:
            PushAll(1);
            pushc(param2);
            CallRTL(CODE._guardrec);
            GetRegA

        |CODE.opTYPEGP:
            UnOp(reg1);
            PushAll(0);
            push(reg1);
            pushc(param2);
            CallRTL(CODE._guard);
            GetRegA

        |CODE.opTYPEGD:
            UnOp(reg1);
            PushAll(0);
            pushm(reg1, -8);
            pushc(param2);
            CallRTL(CODE._guardrec);
            GetRegA

        |CODE.opCASET:
            push(r10);
            push(r10);
            pushc(param2);
            CallRTL(CODE._guardrec);
            pop(r10);
            test(rax);
            jcc(jne, param1)

        |CODE.opSAVEP:
            UnOp(reg1);
            reg2 := REG.GetAnyReg(R);
            lea(reg2, param2, sCODE);
            movmr(reg1, 0, reg2);
            drop;
            drop

        |CODE.opPUSHP:
            reg1 := REG.GetAnyReg(R);
            lea(reg1, param2, sCODE)

        |CODE.opINC, CODE.opDEC:
            BinOp(reg1, reg2);
            // add/sub qword[reg2], reg1
            Rex(reg2, reg1);
            OutByte2(01H + 28H * ORD(cmd.opcode = CODE.opDEC), reg2 MOD 8 + (reg1 MOD 8) * 8);
            drop;
            drop

        |CODE.opINCC, CODE.opDECC:
            UnOp(reg1);
            IF isLong(param2) THEN
                reg2 := REG.GetAnyReg(R);
                movrc(reg2, param2);
                // add/sub qword[reg1], reg2
                Rex(reg1, reg2);
                OutByte2(01H + 28H * ORD(cmd.opcode = CODE.opDECC), reg1 MOD 8 + (reg2 MOD 8) * 8);
                drop
            ELSE
                // add/sub qword[reg1], param2
                Rex(reg1, 0);
                OutByte2(81H + short(param2), 28H * ORD(cmd.opcode = CODE.opDECC) + reg1 MOD 8);
                OutIntByte(param2)
            END;
            drop

        |CODE.opDROP:
            UnOp(reg1);
            drop

        |CODE.opSAVE, CODE.opSAVE64:
            BinOp(reg2, reg1);
            movmr(reg1, 0, reg2);
            drop;
            drop

        |CODE.opSAVE8:
            BinOp(reg2, reg1);
            movmr8(reg1, 0, reg2);
            drop;
            drop

        |CODE.opSAVE16:
            BinOp(reg2, reg1);
            movmr16(reg1, 0, reg2);
            drop;
            drop

        |CODE.opSAVE32:
            BinOp(reg2, reg1);
            movmr32(reg1, 0, reg2);
            drop;
            drop

        |CODE.opMIN:
            BinOp(reg1, reg2);
            cmprr(reg1, reg2);
            OutByte2(7EH, 3); // jle L
            mov(reg1, reg2);
            // L:
            drop

        |CODE.opMAX:
            BinOp(reg1, reg2);
            cmprr(reg1, reg2);
            OutByte2(7DH, 3);  // jge L
            mov(reg1, reg2);
            // L:
            drop

        |CODE.opMINC:
            UnOp(reg1);
            cmprc(reg1, param2);
            label := NewLabel();
            jcc(jle, label);
            movrc(reg1, param2);
            X86.SetLabel(label)

        |CODE.opMAXC:
            UnOp(reg1);
            cmprc(reg1, param2);
            label := NewLabel();
            jcc(jge, label);
            movrc(reg1, param2);
            X86.SetLabel(label)

        |CODE.opSBOOL:
            BinOp(reg2, reg1);
            test(reg2);
            setcc(setne, reg2);
            movmr8(reg1, 0, reg2);
            drop;
            drop

        |CODE.opSBOOLC:
            UnOp(reg1);
            IF reg1 >= 8 THEN
                OutByte(41H)
            END;
            OutByte3(0C6H, reg1 MOD 8, ORD(param2 # 0));
            drop

        |CODE.opODD:
            UnOp(reg1);
            andrc(reg1, 1)

        |CODE.opUMINUS:
            UnOp(reg1);
            neg(reg1)

        |CODE.opADD:
            BinOp(reg1, reg2);
            add(reg1, reg2);
            drop

        |CODE.opSUB:
            BinOp(reg1, reg2);
            sub(reg1, reg2);
            drop

        |CODE.opSUBR, CODE.opSUBL:
            UnOp(reg1);
            n := param2;
            IF n = 1 THEN
                decr(reg1)
            ELSIF n = -1 THEN
                incr(reg1)
            ELSIF n # 0 THEN
                subrc(reg1, n)
            END;
            IF cmd.opcode = CODE.opSUBL THEN
                neg(reg1)
            END

        |CODE.opADDL, CODE.opADDR:
            IF param2 # 0 THEN
                UnOp(reg1);
                IF param2 = 1 THEN
                    incr(reg1)
                ELSIF param2 = -1 THEN
                    decr(reg1)
                ELSE
                    addrc(reg1, param2)
                END
            END

        |CODE.opDIV:
            PushAll(2);
            CallRTL(CODE._div);
            GetRegA

        |CODE.opDIVR:
            a := param2;
            IF a > 1 THEN
                n := X86.log2(a)
            ELSIF a < -1 THEN
                n := X86.log2(-a)
            ELSE
                n := -1
            END;

            IF a = 1 THEN

            ELSIF a = -1 THEN
                UnOp(reg1);
                neg(reg1)
            ELSE
                IF n > 0 THEN
                    UnOp(reg1);

                    IF a < 0 THEN
                        reg2 := REG.GetAnyReg(R);
                        mov(reg2, reg1);
                        shiftrc(sar, reg1, n);
                        sub(reg1, reg2);
                        drop
                    ELSE
                        shiftrc(sar, reg1, n)
                    END

                ELSE
                    PushAll(1);
                    pushc(param2);
                    CallRTL(CODE._div);
                    GetRegA
                END
            END

        |CODE.opDIVL:
            PushAll(1);
            pushc(param2);
            CallRTL(CODE._div2);
            GetRegA

        |CODE.opMOD:
            PushAll(2);
            CallRTL(CODE._mod);
            GetRegA

        |CODE.opMODR:
            a := param2;
            IF a > 1 THEN
                n := X86.log2(a)
            ELSIF a < -1 THEN
                n := X86.log2(-a)
            ELSE
                n := -1
            END;

            IF ABS(a) = 1 THEN
                UnOp(reg1);
                xor(reg1, reg1)
            ELSE
                IF n > 0 THEN
                    UnOp(reg1);
                    andrc(reg1, ABS(a) - 1);

                    IF a < 0 THEN
                        test(reg1);
                        label := NewLabel();
                        jcc(je, label);
                        addrc(reg1, a);
                        X86.SetLabel(label)
                    END

                ELSE
                    PushAll(1);
                    pushc(param2);
                    CallRTL(CODE._mod);
                    GetRegA
                END
            END

        |CODE.opMODL:
            PushAll(1);
            pushc(param2);
            CallRTL(CODE._mod2);
            GetRegA

        |CODE.opMUL:
            BinOp(reg1, reg2);
            oprr2(0FH, 0AFH, reg2, reg1); // imul reg1, reg2
            drop

        |CODE.opMULC:
            UnOp(reg1);

            a := param2;
            IF a > 1 THEN
                n := X86.log2(a)
            ELSIF a < -1 THEN
                n := X86.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
                    // imul reg1, a
                    Rex(reg1, reg1);
                    OutByte2(69H + short(a), 0C0H + (reg1 MOD 8) * 9);
                    OutIntByte(a)
                END
            END

        |CODE.opADDS:
            BinOp(reg1, reg2);
            or(reg1, reg2);
            drop

        |CODE.opSUBS:
            BinOp(reg1, reg2);
            not(reg2);
            and(reg1, reg2);
            drop

        |CODE.opNOP:

        |CODE.opSWITCH:
            UnOp(reg1);
            IF param2 = 0 THEN
                reg2 := rax
            ELSE
                reg2 := r10
            END;
            IF reg1 # reg2 THEN
                ASSERT(REG.GetReg(R, reg2));
                ASSERT(REG.Exchange(R, reg1, reg2));
                drop
            END;
            drop

        |CODE.opENDSW:

        |CODE.opCASEL:
            cmprc(rax, param1);
            jcc(jl, param2)

        |CODE.opCASER:
            cmprc(rax, param1);
            jcc(jg, param2)

        |CODE.opCASELR:
            cmprc(rax, param1);
            jcc(jl, param2);
            jcc(jg, cmd.param3)

        |CODE.opASR, CODE.opROR, CODE.opLSL, CODE.opLSR:
            BinOp(reg1, reg2);
            xchg(reg2, rcx);
            Rex(reg1, 0);
            OutByte(0D3H);
            X86.shift(cmd.opcode, reg1 MOD 8); // shift reg1, cl
            xchg(reg2, rcx);
            drop

        |CODE.opASR1, CODE.opROR1, CODE.opLSL1, CODE.opLSR1:
            reg1 := REG.GetAnyReg(R);
            movrc(reg1, param2);
            BinOp(reg1, reg2);
            xchg(reg1, rcx);
            Rex(reg2, 0);
            OutByte(0D3H);
            X86.shift(cmd.opcode, reg2 MOD 8); // shift reg2, cl
            xchg(reg1, rcx);
            drop;
            drop;
            ASSERT(REG.GetReg(R, reg2))

        |CODE.opASR2, CODE.opROR2, CODE.opLSL2, CODE.opLSR2:
            UnOp(reg1);
            shiftrc(cmd.opcode, reg1, ORD(BITS(param2) * {0..5}))

        |CODE.opGET:
            BinOp(reg1, reg2);
            drop;
            drop;
            _movrm(reg1, reg1, 0, param2 * 8, FALSE);
            _movrm(reg1, reg2, 0, param2 * 8, TRUE)

        |CODE.opCHKBYTE:
            BinOp(reg1, reg2);
            cmprc(reg1, 256);
            jcc(jb, param1)

        |CODE.opCHKIDX:
            UnOp(reg1);
            cmprc(reg1, param2);
            jcc(jb, param1)

        |CODE.opCHKIDX2:
            BinOp(reg1, reg2);
            IF param2 # -1 THEN
                cmprr(reg2, reg1);
                mov(reg1, reg2);
                drop;
                jcc(jb, param1)
            ELSE
                INCL(R.regs, reg1);
                DEC(R.top);
                R.stk[R.top] := reg2
            END

        |CODE.opLENGTH:
            PushAll(2);
            CallRTL(CODE._length);
            GetRegA

        |CODE.opLENGTHW:
            PushAll(2);
            CallRTL(CODE._lengthw);
            GetRegA

        |CODE.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))

        |CODE.opCHR:
            UnOp(reg1);
            andrc(reg1, 255)

        |CODE.opWCHR:
            UnOp(reg1);
            andrc(reg1, 65535)

        |CODE.opEQP, CODE.opNEP, CODE.opEQIP, CODE.opNEIP:
            UnOp(reg1);
            reg2 := REG.GetAnyReg(R);

            CASE cmd.opcode OF
            |CODE.opEQP, CODE.opNEP:
                lea(reg2, param1, sCODE)

            |CODE.opEQIP, CODE.opNEIP:
                lea(reg2, param1, sIMP);
                movrm(reg2, reg2, 0)
            END;

            cmprr(reg1, reg2);
            drop;
            drop;
            reg1 := REG.GetAnyReg(R);

            CASE cmd.opcode OF
            |CODE.opEQP, CODE.opEQIP: setcc(sete,  reg1)
            |CODE.opNEP, CODE.opNEIP: setcc(setne, reg1)
            END;

            andrc(reg1, 1)

        |CODE.opINC1B, CODE.opDEC1B:
            UnOp(reg1);
            IF reg1 >= 8 THEN
                OutByte(41H)
            END;
            OutByte2(0FEH, 8 * ORD(cmd.opcode = CODE.opDEC1B) + reg1 MOD 8); // inc/dec byte[reg1]
            drop

        |CODE.opINCCB, CODE.opDECCB:
            UnOp(reg1);
            IF reg1 >= 8 THEN
                OutByte(41H)
            END;
            OutByte3(80H, 28H * ORD(cmd.opcode = CODE.opDECCB) + reg1 MOD 8, param2 MOD 256); // add/sub byte[reg1], param2 MOD 256
            drop

        |CODE.opINCB, CODE.opDECB:
            BinOp(reg1, reg2);
            IF (reg1 >= 8) OR (reg2 >= 8) THEN
                OutByte(40H + reg2 DIV 8 + 4 * (reg1 DIV 8))
            END;
            OutByte2(28H * ORD(cmd.opcode = CODE.opDECB), reg2 MOD 8 + 8 * (reg1 MOD 8)); // add/sub byte[reg2], reg1_8
            drop;
            drop

        |CODE.opSAVEIP:
            UnOp(reg1);
            reg2 := REG.GetAnyReg(R);
            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

        |CODE.opCLEANUP:
            n := param2 * 8;
            IF n # 0 THEN
                addrc(rsp, n)
            END

        |CODE.opPOPSP:
            pop(rsp)

        |CODE.opLOADF:
            UnOp(reg1);
            INC(xmm);
            movsdrm(xmm, reg1, 0);
            drop

        |CODE.opPUSHF:
            subrc(rsp, 8);
            movsdmr(rsp, 0, xmm);
            DEC(xmm)

        |CODE.opCONSTF:
            float := cmd.float;
            INC(xmm);
            reg1 := REG.GetAnyReg(R);
            lea(reg1, Numbers_Offs + Numbers_Count * 8, sDATA);
            movsdrm(xmm, reg1, 0);
            drop;
            NewNumber(UTILS.splitf(float, a, b))

        |CODE.opSAVEF:
            UnOp(reg1);
            movsdmr(reg1, 0, xmm);
            DEC(xmm);
            drop

        |CODE.opADDF, CODE.opADDFI:
            opxx(58H, xmm - 1, xmm);
            DEC(xmm)

        |CODE.opSUBF:
            opxx(5CH, xmm - 1, xmm);
            DEC(xmm)

        |CODE.opSUBFI:
            opxx(5CH, xmm, xmm - 1);
            opxx(10H, xmm - 1, xmm);
            DEC(xmm)

        |CODE.opMULF:
            opxx(59H, xmm - 1, xmm);
            DEC(xmm)

        |CODE.opDIVF:
            opxx(5EH, xmm - 1, xmm);
            DEC(xmm)

        |CODE.opDIVFI:
            opxx(5EH, xmm, xmm - 1);
            opxx(10H, xmm - 1, xmm);
            DEC(xmm)

        |CODE.opUMINF:
            reg1 := REG.GetAnyReg(R);
            lea(reg1, Numbers_Offs, sDATA);
            OutByte3(66H, 40H + reg1 DIV 8 + (xmm DIV 8) * 4, 0FH); // xorpd xmm, xmmword[reg1]
            OutByte2(57H, reg1 MOD 8 + (xmm MOD 8) * 8);
            drop

        |CODE.opFABS:
            reg1 := REG.GetAnyReg(R);
            lea(reg1, Numbers_Offs + 16, sDATA);
            OutByte3(66H, 40H + reg1 DIV 8 + (xmm DIV 8) * 4, 0FH); // andpd xmm, xmmword[reg1]
            OutByte2(54H, reg1 MOD 8 + (xmm MOD 8) * 8);
            drop

        |CODE.opFLT:
            UnOp(reg1);
            INC(xmm);
            OutByte(0F2H); Rex(reg1, xmm); OutByte(0FH); // cvtsi2sd xmm, reg1
            OutByte2(2AH, 0C0H + (xmm MOD 8) * 8 + reg1 MOD 8);
            drop

        |CODE.opFLOOR:
            reg1 := REG.GetAnyReg(R);
            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)

        |CODE.opEQF .. CODE.opGEFI:
            fcmp(cmd.opcode, xmm);
            DEC(xmm, 2)

        |CODE.opINF:
            INC(xmm);
            reg1 := REG.GetAnyReg(R);
            lea(reg1, Numbers_Offs + 32, sDATA);
            movsdrm(xmm, reg1, 0);
            drop

        |CODE.opPACK, CODE.opPACKC:
            IF cmd.opcode = CODE.opPACK THEN
                BinOp(reg1, reg2)
            ELSE
                UnOp(reg1);
                reg2 := REG.GetAnyReg(R);
                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

        |CODE.opUNPK, CODE.opLADR_UNPK:

            IF cmd.opcode = CODE.opLADR_UNPK THEN
                n := param2 * 8;
                UnOp(reg1);
                reg2 := REG.GetVarReg(R, param2);
                regVar := reg2 # -1;
                IF ~regVar THEN
                    reg2 := REG.GetAnyReg(R);
                    Rex(0, reg2);
                    OutByte2(8DH, 45H + long(n) + (reg2 MOD 8) * 8);  // lea reg2, qword[rbp+n]
                    OutIntByte(n)
                END
            ELSE
                BinOp(reg1, reg2);
                regVar := FALSE
            END;

            push(reg1);
            movrm(reg1, reg1, 0);
            shiftrc(shl, reg1, 1);
            shiftrc(shr, reg1, 53);
            subrc(reg1, 1023);

            IF regVar THEN
                mov(reg2, reg1);
                reg2 := REG.GetAnyReg(R)
            ELSE
                movmr(reg2, 0, reg1)
            END;

            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

        |CODE.opSADR_PARAM:
            pushDA(stroffs + param2)

        |CODE.opVADR_PARAM:
            pushm(rbp, param2 * 8)

        |CODE.opLOAD64_PARAM:
            UnOp(reg1);
            pushm(reg1, 0);
            drop

        |CODE.opLLOAD64_PARAM:
            reg1 := REG.GetVarReg(R, param2);
            IF reg1 # -1 THEN
                push(reg1)
            ELSE
                pushm(rbp, param2 * 8)
            END

        |CODE.opGLOAD64_PARAM:
            reg2 := REG.GetAnyReg(R);
            lea(reg2, param2, sBSS);
            movrm(reg2, reg2, 0);
            push(reg2);
            drop

        |CODE.opCONST_PARAM:
            pushc(param2)

        |CODE.opGLOAD32_PARAM:
            reg1 := REG.GetAnyReg(R);
            xor(reg1, reg1);
            lea(reg1, param2, sBSS);
            movrm32(reg1, reg1, 0);
            push(reg1);
            drop

        |CODE.opLOAD32_PARAM:
            UnOp(reg1);
            movrm32(reg1, reg1, 0);
            shiftrc(shl, reg1, 32);
            shiftrc(shr, reg1, 32);
            push(reg1);
            drop

        |CODE.opLLOAD32_PARAM:
            reg1 := REG.GetAnyReg(R);
            xor(reg1, reg1);
            reg2 := REG.GetVarReg(R, param2);
            IF reg2 # -1 THEN
                mov(reg1, reg2)
            ELSE
                movrm32(reg1, rbp, param2 * 8)
            END;
            push(reg1);
            drop

        |CODE.opLADR_SAVEC:
            n := param1 * 8;
            reg1 := REG.GetVarReg(R, param1);
            IF reg1 # -1 THEN
                movrc(reg1, param2)
            ELSE
                IF isLong(param2) THEN
                    reg2 := REG.GetAnyReg(R);
                    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
            END

        |CODE.opGADR_SAVEC:
            IF isLong(param2) THEN
                reg1 := REG.GetAnyReg(R);
                movrc(reg1, param2);
                reg2 := REG.GetAnyReg(R);
                lea(reg2, param1, sBSS);
                movmr(reg2, 0, reg1);
                drop;
                drop
            ELSE
                reg2 := REG.GetAnyReg(R);
                lea(reg2, param1, sBSS);
                Rex(reg2, 0);
                OutByte2(0C7H, reg2 MOD 8); // mov qword[reg2], param2
                OutInt(param2);
                drop
            END

        |CODE.opLADR_SAVE:
            UnOp(reg1);
            reg2 := REG.GetVarReg(R, param2);
            IF reg2 # -1 THEN
                mov(reg2, reg1)
            ELSE
                movmr(rbp, param2 * 8, reg1)
            END;
            drop

        |CODE.opLADR_INC1:
            reg1 := REG.GetVarReg(R, param2);
            IF reg1 # -1 THEN
                incr(reg1)
            ELSE
                n := param2 * 8;
                OutByte3(48H, 0FFH, 45H + long(n)); // inc qword[rbp+n]
                OutIntByte(n)
            END

        |CODE.opLADR_DEC1:
            reg1 := REG.GetVarReg(R, param2);
            IF reg1 # -1 THEN
                decr(reg1)
            ELSE
                n := param2 * 8;
                OutByte3(48H, 0FFH, 4DH + long(n)); // dec qword[rbp+n]
                OutIntByte(n)
            END

        |CODE.opLADR_INCC, CODE.opLADR_DECC:
            reg1 := REG.GetVarReg(R, param1);
            IF isLong(param2) THEN
                reg2 := REG.GetAnyReg(R);
                movrc(reg2, param2);
                IF reg1 # -1 THEN
                    IF cmd.opcode = CODE.opLADR_DECC THEN
                        sub(reg1, reg2)
                    ELSE
                        add(reg1, reg2)
                    END
                ELSE
                    n := param1 * 8;
                    Rex(0, reg2);
                    OutByte2(01H + 28H * ORD(cmd.opcode = CODE.opLADR_DECC), 45H + long(n) + (reg2 MOD 8) * 8);
                    OutIntByte(n) // add/sub qword[rbp+n],reg2
                END;
                drop
            ELSE
                IF reg1 # -1 THEN
                    IF cmd.opcode = CODE.opLADR_DECC THEN
                        subrc(reg1, param2)
                    ELSE
                        addrc(reg1, param2)
                    END
                ELSE
                    n := param1 * 8;
                    OutByte3(48H, 81H + short(param2), 45H + long(n) + 28H * ORD(cmd.opcode = CODE.opLADR_DECC));
                    OutIntByte(n);
                    OutIntByte(param2) // add/sub qword[rbp+n],param2
                END
            END

        |CODE.opLADR_INC1B, CODE.opLADR_DEC1B:
            reg1 := REG.GetVarReg(R, param2);
            IF reg1 # -1 THEN
                IF cmd.opcode = CODE.opLADR_DEC1B THEN
                    decr(reg1)
                ELSE
                    incr(reg1)
                END;
                andrc(reg1, 255)
            ELSE
                n := param2 * 8;
                OutByte2(0FEH, 45H + long(n) + 8 * ORD(cmd.opcode = CODE.opLADR_DEC1B));
                OutIntByte(n)  // inc/dec byte[rbp+n]
            END

        |CODE.opLADR_INCCB, CODE.opLADR_DECCB:
            reg1 := REG.GetVarReg(R, param1);
            param2 := param2 MOD 256;
            IF reg1 # -1 THEN
                IF cmd.opcode = CODE.opLADR_DECCB THEN
                    subrc(reg1, param2)
                ELSE
                    addrc(reg1, param2)
                END;
                andrc(reg1, 255)
            ELSE
                n := param1 * 8;
                OutByte2(80H, 45H + long(n) + 28H * ORD(cmd.opcode = CODE.opLADR_DECCB));
                OutIntByte(n);
                OutByte(param2) // add/sub byte[rbp+n],param2
            END

        |CODE.opLADR_INC, CODE.opLADR_DEC:
            UnOp(reg1);
            reg2 := REG.GetVarReg(R, param2);
            IF reg2 # -1 THEN
                IF cmd.opcode = CODE.opLADR_DEC THEN
                    sub(reg2, reg1)
                ELSE
                    add(reg2, reg1)
                END
            ELSE
                n := param2 * 8;
                Rex(0, reg1);
                OutByte2(01H + 28H * ORD(cmd.opcode = CODE.opLADR_DEC), 45H + long(n) + (reg1 MOD 8) * 8);
                OutIntByte(n) // add/sub qword[rbp+n],reg1
            END;
            drop

        |CODE.opLADR_INCB, CODE.opLADR_DECB:
            UnOp(reg1);
            reg2 := REG.GetVarReg(R, param2);
            IF reg2 # -1 THEN
                IF cmd.opcode = CODE.opLADR_DECB THEN
                    sub(reg2, reg1)
                ELSE
                    add(reg2, reg1)
                END;
                andrc(reg2, 255)
            ELSE
                n := param2 * 8;
                IF reg1 >= 8 THEN
                    OutByte(44H)
                END;
                OutByte2(28H * ORD(cmd.opcode = CODE.opLADR_DECB), 45H + long(n) + 8 * (reg1 MOD 8));
                OutIntByte(n) // add/sub byte[rbp+n], reg1_8
            END;
            drop

        |CODE.opLADR_INCL, CODE.opLADR_EXCL:
            UnOp(reg1);
            cmprc(reg1, 64);
            reg2 := REG.GetVarReg(R, param2);
            IF reg2 # -1 THEN
                OutByte2(73H, 4); // jnb L
                oprr2(0FH, 0ABH + 8 * ORD(cmd.opcode = CODE.opLADR_EXCL), reg2, reg1) // bts/btr reg2, reg1
            ELSE
                n := param2 * 8;
                OutByte2(73H, 5 + 3 * ORD(~isByte(n))); // jnb L
                Rex(0, reg1);
                OutByte3(0FH, 0ABH + 8 * ORD(cmd.opcode = CODE.opLADR_EXCL), 45H + long(n) + 8 * (reg1 MOD 8));
                OutIntByte(n) // bts/btr qword[rbp+n], reg1
            END;
            // L:
            drop

        |CODE.opLADR_INCLC, CODE.opLADR_EXCLC:
            reg1 := REG.GetVarReg(R, param1);
            IF reg1 # -1 THEN
                Rex(reg1, 0);
                OutByte3(0FH, 0BAH, 0E8H);  // bts/btr reg1, param2
                OutByte2(reg1 MOD 8 + 8 * ORD(cmd.opcode = CODE.opLADR_EXCLC), param2)
            ELSE
                n := param1 * 8;
                OutByte3(48H, 0FH, 0BAH);  // bts/btr qword[rbp+n], param2
                OutByte(6DH + long(n) + 8 * ORD(cmd.opcode = CODE.opLADR_EXCLC));
                OutIntByte(n);
                OutByte(param2)
            END

        |CODE.opLOOP, CODE.opENDLOOP:

        END;

        cmd := cmd.next(COMMAND)
    END;

    ASSERT(R.pushed = 0);
    ASSERT(R.top = -1);
    ASSERT(xmm = -1)
END translate;


PROCEDURE prolog (code: CODE.CODES; modname: ARRAY OF CHAR; target, stack_size: INTEGER);
VAR
    ModName_Offs, entry: INTEGER;

BEGIN
    ModName_Offs := CHL.Length(code.types) * 8 + CHL.Length(code.data);
    Numbers_Offs := ModName_Offs + LENGTH(modname) + 1;
    ASSERT(MACHINE.Align(Numbers_Offs, 16));

    entry := NewLabel();
    X86.SetLabel(entry);

    IF target = mConst.Target_iDLL64 THEN
        dllret := NewLabel();
        push(r8);
        push(rdx);
        push(rcx);
        CallRTL(CODE._dllentry);
        test(rax);
        jcc(je, dllret)
    END;

    push(rsp);
    lea(rax, entry, sCODE);
    push(rax);
    pushDA(0); //TYPES
    pushc(CHL.Length(code.types));
    pushDA(ModName_Offs); //MODNAME
    CallRTL(CODE._init)
END prolog;


PROCEDURE epilog (code: CODE.CODES; modname: ARRAY OF CHAR; target: INTEGER);
VAR
    i, n: INTEGER;
    number: Number;
    exp: CODE.EXPORT_PROC;


    PROCEDURE import (imp: LISTS.LIST);
    VAR
        lib:  CODE.IMPORT_LIB;
        proc: CODE.IMPORT_PROC;

    BEGIN

        lib := imp.first(CODE.IMPORT_LIB);
        WHILE lib # NIL DO
            BIN.Import(prog, lib.name, 0);
            proc := lib.procs.first(CODE.IMPORT_PROC);
            WHILE proc # NIL DO
                BIN.Import(prog, proc.name, proc.label);
                proc := proc.next(CODE.IMPORT_PROC)
            END;
            lib := lib.next(CODE.IMPORT_LIB)
        END

    END import;


BEGIN
    IF target = mConst.Target_iDLL64 THEN
        X86.SetLabel(dllret);
        OutByte(0C3H) // ret
    ELSE
        pushc(0);
        CallRTL(CODE._exit)
    END;

    X86.fixup;

    i := 0;
    WHILE i < CHL.Length(code.types) DO
        BIN.PutData64LE(prog, CHL.GetInt(code.types, i));
        INC(i)
    END;

    i := 0;
    WHILE i < CHL.Length(code.data) DO
        BIN.PutData(prog, CHL.GetByte(code.data, i));
        INC(i)
    END;

    BIN.PutDataStr(prog, modname);
    BIN.PutData(prog, 0);
    n := CHL.Length(prog.data);
    ASSERT(MACHINE.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 := code.export.first(CODE.EXPORT_PROC);
    WHILE exp # NIL DO
        BIN.Export(prog, exp.name, exp.label);
        exp := exp.next(CODE.EXPORT_PROC)
    END;

    import(code.import)
END epilog;


PROCEDURE rload (reg, offs, size: INTEGER);
BEGIN
    offs := offs * 8;
    CASE size OF
    |1: movzx(reg, rbp, offs, FALSE)
    |2: movzx(reg, rbp, offs, TRUE)
    |4: xor(reg, reg); movrm32(reg, rbp, offs)
    |8: movrm(reg, rbp, offs)
    END
END rload;


PROCEDURE rsave (reg, offs, size: INTEGER);
BEGIN
    offs := offs * 8;
    CASE size OF
    |1: movmr8(rbp, offs, reg)
    |2: movmr16(rbp, offs, reg)
    |4: movmr32(rbp, offs, reg)
    |8: movmr(rbp, offs, reg)
    END
END rsave;


PROCEDURE CodeGen* (code: CODE.CODES; outname: ARRAY OF CHAR; target, stack, base: INTEGER);
VAR
    path, modname, ext: PATHS.PATH;
    n: INTEGER;

BEGIN
    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);

    R := REG.Create(push, pop, mov, xchg, rload, rsave, {rax, r10, r11}, {rcx, rdx, r8, r9});

    n := code.dmin - CHL.Length(code.data);
    IF n > 0 THEN
        INC(code.bss, n)
    END;
    code.bss := MAX(code.bss, 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(code.lcount);
    BIN.SetParams(prog, code.bss, stack, WCHR(1), WCHR(0));

    X86.SetProgram(prog);

    prolog(code, modname, target, stack);
    translate(code.commands, CHL.Length(code.types) * 8);
    epilog(code, modname, target);

    BIN.fixup(prog);
    IF target IN {mConst.Target_iConsole64, mConst.Target_iGUI64, mConst.Target_iDLL64} THEN
        PE32.write(prog, outname, base, target = mConst.Target_iConsole64, target = mConst.Target_iDLL64, TRUE)
    ELSIF target = mConst.Target_iELF64 THEN
        ELF.write(prog, outname, TRUE)
    END
END CodeGen;


END AMD64.