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

     All rights reserved.
 *)
 MODULE AMD64;
-IMPORT CODE, BIN, WR := WRITER, CHL := CHUNKLISTS, MACHINE, LISTS, PATHS,
+IMPORT IL, BIN, WR := WRITER, CHL := CHUNKLISTS, LISTS, PATHS, PROG,
     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;
+    shl = IL.opLSL2; shr = IL.opLSR2; sar = IL.opASR2; ror = IL.opROR2;
     sCODE = BIN.PICCODE;
     sDATA = BIN.PICDATA;
     sBSS  = BIN.PICBSS;
     sIMP  = BIN.PICIMP;
     Numbers_Count: INTEGER;
     Numbers_Offs: INTEGER;
     prog: BIN.PROGRAM;
+    tcount: INTEGER;
-    dllret: INTEGER;
+    dllret, sofinit: INTEGER;
 END OutByte3;
 PROCEDURE OutInt (n: INTEGER);
 BEGIN
-    OutByte(MACHINE.Byte(n, 0));
+    OutByte(UTILS.Byte(n, 0));
-    OutByte(MACHINE.Byte(n, 1));
+    OutByte(UTILS.Byte(n, 1));
-    OutByte(MACHINE.Byte(n, 2));
+    OutByte(UTILS.Byte(n, 2));
-    OutByte(MACHINE.Byte(n, 3))
+    OutByte(UTILS.Byte(n, 3))
 END OutInt;
 PROCEDURE OutIntByte (n: INTEGER);
 BEGIN
     IF isByte(n) THEN
-        OutByte(MACHINE.Byte(n, 0))
+        OutByte(UTILS.Byte(n, 0))
     ELSE
         OutInt(n)
     END
 END OutIntByte;
 PROCEDURE isLong (n: INTEGER): BOOLEAN;
 PROCEDURE NewLabel (): INTEGER;
 BEGIN
     BIN.NewLabel(prog)
-    RETURN CODE.NewLabel()
+    RETURN IL.NewLabel()
 END NewLabel;
 BEGIN
     REG.Drop(R)
 END drop;
+PROCEDURE GetAnyReg (): INTEGER;
+    RETURN REG.GetAnyReg(R)
+END GetAnyReg;
+PROCEDURE GetVarReg (offs: INTEGER): INTEGER;
+    RETURN REG.GetVarReg(R, offs)
+END GetVarReg;
 PROCEDURE callimp (label: INTEGER);
 VAR
     reg: INTEGER;
 BEGIN
-    reg := REG.GetAnyReg(R);
+    reg := GetAnyReg();
     lea(reg, label, sIMP);
     IF reg >= 8 THEN // call qword[reg]
 PROCEDURE pushDA (offs: INTEGER);
 VAR
     reg: INTEGER;
 BEGIN
-    reg := REG.GetAnyReg(R);
+    reg := GetAnyReg();
     lea(reg, offs, sDATA);
     push(reg);
     drop
 VAR
     label: INTEGER;
 BEGIN
     REG.Store(R);
-    label := CODE.codes.rtl[proc];
+    label := IL.codes.rtl[proc];
     IF label < 0 THEN
         callimp(-label)
     ELSE
         X86.call(label)
 PROCEDURE PushAll (NumberOfParameters: INTEGER);
 BEGIN
     REG.PushAll(R);
-    R.pushed := R.pushed - NumberOfParameters
+    DEC(R.pushed, NumberOfParameters)
 END PushAll;
 BEGIN
     Rex(reg, 0);
     OutByte(0B8H + reg MOD 8);  // movabs reg, n
     FOR i := 0 TO 7 DO
-        OutByte(MACHINE.Byte(n, i))
+        OutByte(UTILS.Byte(n, i))
     END
 END movabs;
 PROCEDURE movrc (reg, n: INTEGER); // mov reg, n
+BEGIN
+    IF isLong(n) THEN
-BEGIN
+        movabs(reg, n)
-    IF isLong(n) THEN
+    ELSIF n = 0 THEN
-        movabs(reg, n)
+        xor(reg, reg)
     ELSE
         Rex(reg, 0);
 PROCEDURE oprlongc (reg, n: INTEGER; oprr: OPRR);
 VAR
     reg2: INTEGER;
 BEGIN
-    reg2 := REG.GetAnyReg(R);
+    reg2 := GetAnyReg();
     movabs(reg2, n);
     oprr(reg, reg2);
     drop
 VAR
     reg2: INTEGER;
 BEGIN
     IF isLong(n) THEN
-        reg2 := REG.GetAnyReg(R);
+        reg2 := GetAnyReg();
         movabs(reg2, n);
         push(reg2);
         drop
     ELSE
         OutByte(n)
     END
 END shiftrc;
-PROCEDURE getVar (variables: LISTS.LIST; offset: INTEGER): CODE.LOCALVAR;
+PROCEDURE getVar (variables: LISTS.LIST; offset: INTEGER): IL.LOCALVAR;
 VAR
-    cur: CODE.LOCALVAR;
+    cur: IL.LOCALVAR;
 BEGIN
-    cur := variables.first(CODE.LOCALVAR);
+    cur := variables.first(IL.LOCALVAR);
     WHILE (cur # NIL) & (cur.offset # offset) DO
-        cur := cur.next(CODE.LOCALVAR)
+        cur := cur.next(IL.LOCALVAR)
 VAR
     leave:      BOOLEAN;
     leaf:       BOOLEAN;
     cur:        COMMAND;
     variables:  LISTS.LIST;
-    lvar, rvar: CODE.LOCALVAR;
+    lvar, rvar: IL.LOCALVAR;
     reg:        INTEGER;
     max:        INTEGER;
     loop:       INTEGER;
     param2:     INTEGER;
     leaf := TRUE;
     cur := cmd.next(COMMAND);
     REPEAT
         CASE cur.opcode OF
-        |CODE.opLLOAD64,
+        |IL.opLLOAD64,
-         CODE.opLLOAD8,
+         IL.opLLOAD8,
-         CODE.opLLOAD16,
+         IL.opLLOAD16,
-         CODE.opLLOAD32,
+         IL.opLLOAD32,
-         CODE.opLLOAD64_PARAM,
+         IL.opLLOAD64_PARAM,
-         CODE.opLLOAD32_PARAM,
+         IL.opLLOAD32_PARAM,
-         CODE.opLADR_SAVE,
-         CODE.opLADR_INC1,
-         CODE.opLADR_DEC1,
+         IL.opLADR_SAVE,
-         CODE.opLADR_INC,
+         IL.opLADR_INC,
-         CODE.opLADR_DEC,
-         CODE.opLADR_INC1B,
-         CODE.opLADR_DEC1B,
+         IL.opLADR_DEC,
-         CODE.opLADR_INCB,
+         IL.opLADR_INCB,
-         CODE.opLADR_DECB,
+         IL.opLADR_DECB,
-         CODE.opLADR_INCL,
+         IL.opLADR_INCL,
-         CODE.opLADR_EXCL,
+         IL.opLADR_EXCL,
-         CODE.opLADR_UNPK:
+         IL.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,
+        |IL.opLADR_SAVEC,
-         CODE.opLADR_DECC,
+         IL.opLADR_INCC,
-         CODE.opLADR_INCCB,
+         IL.opLADR_INCCB,
-         CODE.opLADR_DECCB,
+         IL.opLADR_DECCB,
-         CODE.opLADR_INCLC,
+         IL.opLADR_INCLC,
-         CODE.opLADR_EXCLC:
+         IL.opLADR_EXCLC:
             lvar := getVar(variables, cur.param1);
             IF (lvar # NIL) & (lvar.count # -1) THEN
                 INC(lvar.count, loop)
             END
-        |CODE.opLADR:
+        |IL.opLADR:
             lvar := getVar(variables, cur.param2);
             IF (lvar # NIL) & (lvar.count # -1) THEN
                 lvar.count := -1
             END
-        |CODE.opLOOP:
+        |IL.opLOOP:
             INC(loop, 10)
-        |CODE.opENDLOOP:
+        |IL.opENDLOOP:
             DEC(loop, 10)
-        |CODE.opLEAVE,
+        |IL.opLEAVE,
-         CODE.opLEAVER,
+         IL.opLEAVER,
-         CODE.opLEAVEF:
+         IL.opLEAVEF:
             leave := TRUE
-        |CODE.opCALL, CODE.opCALLP, CODE.opCALLI,
-         CODE.opWIN64CALL, CODE.opWIN64CALLP, CODE.opWIN64CALLI,
+        |IL.opCALL, IL.opCALLP, IL.opCALLI,
-         CODE.opSYSVCALL, CODE.opSYSVCALLP, CODE.opSYSVCALLI,
+         IL.opWIN64CALL, IL.opWIN64CALLP, IL.opWIN64CALLI,
-         CODE.opSAVES, CODE.opRSET, CODE.opRSETR,
+         IL.opSYSVCALL, IL.opSYSVCALLP, IL.opSYSVCALLI,
-         CODE.opRSETL, CODE.opRSET1,
-         CODE.opEQS .. CODE.opGES,
+         IL.opSAVES, IL.opRSET, IL.opRSETR,
-         CODE.opEQS2 .. CODE.opGES2,
+         IL.opRSETL, IL.opRSET1,
-         CODE.opEQSW .. CODE.opGESW,
+         IL.opEQS .. IL.opGES,
-         CODE.opEQSW2 .. CODE.opGESW2,
+         IL.opEQSW .. IL.opGESW,
-         CODE.opCOPY, CODE.opMOVE, CODE.opCOPYA,
+         IL.opCOPY, IL.opMOVE, IL.opCOPYA,
-         CODE.opCOPYS, CODE.opCOPYS2, CODE.opROT,
+         IL.opCOPYS, IL.opROT,
-         CODE.opNEW, CODE.opDISP, CODE.opISREC,
+         IL.opNEW, IL.opDISP, IL.opISREC,
-         CODE.opIS, CODE.opTYPEGR, CODE.opTYPEGP,
+         IL.opIS, IL.opTYPEGR, IL.opTYPEGP,
-         CODE.opCASET, CODE.opDIV,
+         IL.opCASET, IL.opDIV,
-         CODE.opDIVL, CODE.opMOD,
+         IL.opDIVL, IL.opMOD,
-         CODE.opMODL, CODE.opLENGTH, CODE.opLENGTHW:
+         IL.opMODL, IL.opLENGTH, IL.opLENGTHW:
             leaf := FALSE
-        |CODE.opDIVR, CODE.opMODR:
+        |IL.opDIVR, IL.opMODR:
             param2 := cur.param2;
             IF param2 >= 1 THEN
     IF leaf THEN
         REPEAT
             reg := -1;
             max := -1;
             rvar := NIL;
-            lvar := variables.first(CODE.LOCALVAR);
+            lvar := variables.first(IL.LOCALVAR);
             WHILE lvar # NIL DO
                 IF lvar.count > max THEN
                     max := lvar.count;
                     rvar := lvar
                 END;
-                lvar := lvar.next(CODE.LOCALVAR)
+                lvar := lvar.next(IL.LOCALVAR)
             END;
             IF rvar # NIL THEN
                 reg := REG.GetAnyVarReg(R);
 PROCEDURE fcmp (op: INTEGER; xmm: INTEGER);
 VAR
     cc, reg: INTEGER;
 BEGIN
-    reg := REG.GetAnyReg(R);
+    reg := GetAnyReg();
     xor(reg, reg);
     CASE op OF
-    |CODE.opEQF, CODE.opEQFI:
+    |IL.opEQF:
         comisd(xmm - 1, xmm);
         cc := sete
-    |CODE.opNEF, CODE.opNEFI:
+    |IL.opNEF:
         comisd(xmm - 1, xmm);
         cc := setne
-    |CODE.opLTF, CODE.opGTFI:
+    |IL.opLTF:
         comisd(xmm - 1, xmm);
         cc := setc
-    |CODE.opGTF, CODE.opLTFI:
+    |IL.opGTF:
         comisd(xmm, xmm - 1);
         cc := setc
-    |CODE.opLEF, CODE.opGEFI:
+    |IL.opLEF:
         comisd(xmm, xmm - 1);
         cc := setnc
 PROCEDURE translate (commands: LISTS.LIST; stroffs: INTEGER);
 VAR
     cmd, next: COMMAND;
-    param1, param2, param3, a, b, c, n, label, L, i, cc: INTEGER;
+    opcode, param1, param2, param3, a, b, c, n, label, L, i, cc: INTEGER;
     WHILE cmd # NIL DO
         param1 := cmd.param1;
+        param2 := cmd.param2;
-        param2 := cmd.param2;
+        opcode := cmd.opcode;
-        CASE cmd.opcode OF
+        CASE opcode OF
-        |CODE.opJMP:
+        |IL.opJMP:
             jmp(param1)
-        |CODE.opCALL, CODE.opWIN64CALL, CODE.opSYSVCALL:
+        |IL.opCALL, IL.opWIN64CALL, IL.opSYSVCALL:
             REG.Store(R);
-            CASE cmd.opcode OF
+            CASE opcode OF
-            |CODE.opCALL:
+            |IL.opCALL:
-            |CODE.opWIN64CALL: Win64Passing(param2)
+            |IL.opWIN64CALL: Win64Passing(param2)
-            |CODE.opSYSVCALL:  SysVPassing(param2)
+            |IL.opSYSVCALL:  SysVPassing(param2)
             END;
             X86.call(param1);
             REG.Restore(R)
-        |CODE.opCALLP, CODE.opWIN64CALLP, CODE.opSYSVCALLP:
+        |IL.opCALLP, IL.opWIN64CALLP, IL.opSYSVCALLP:
             UnOp(reg1);
             IF reg1 # rax THEN
                 GetRegA;
                 ASSERT(REG.Exchange(R, reg1, rax));
                 drop
             END;
             drop;
             REG.Store(R);
-            CASE cmd.opcode OF
+            CASE opcode OF
-            |CODE.opCALLP:
+            |IL.opCALLP:
-            |CODE.opWIN64CALLP: Win64Passing(param2)
+            |IL.opWIN64CALLP: Win64Passing(param2)
-            |CODE.opSYSVCALLP:  SysVPassing(param2)
+            |IL.opSYSVCALLP:  SysVPassing(param2)
             END;
             OutByte2(0FFH, 0D0H); // call rax
             REG.Restore(R);
             ASSERT(R.top = -1)
-        |CODE.opCALLI, CODE.opWIN64CALLI, CODE.opSYSVCALLI:
+        |IL.opCALLI, IL.opWIN64CALLI, IL.opSYSVCALLI:
             REG.Store(R);
-            CASE cmd.opcode OF
+            CASE opcode OF
-            |CODE.opCALLI:
+            |IL.opCALLI:
-            |CODE.opWIN64CALLI: Win64Passing(param2)
+            |IL.opWIN64CALLI: Win64Passing(param2)
-            |CODE.opSYSVCALLI:  SysVPassing(param2)
+            |IL.opSYSVCALLI:  SysVPassing(param2)
             END;
             callimp(param1);
             REG.Restore(R)
-        |CODE.opLABEL:
+        |IL.opLABEL:
-            X86.SetLabel(param2)
+            X86.SetLabel(param1)
-        |CODE.opERR:
+        |IL.opERR:
-            CallRTL(CODE._error)
+            CallRTL(IL._error)
                 DEC(n)
             END;
             ASSERT(xmm = -1);
             PushAll(0)
-        |CODE.opWIN64ALIGN16:
+        |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)
-        |CODE.opSYSVALIGN16:
+        |IL.opSYSVALIGN16:
             ASSERT(rax IN R.regs);
             mov(rax, rsp);
             andrc(rsp, -16);
             push(rax);
             IF ~ODD(param2) THEN
                 push(rax)
             END
-        |CODE.opRESF:
+        |IL.opRESF:
             ASSERT(xmm = -1);
             INC(xmm);
                 movsdrm(xmm, rsp, 0);
                 addrc(rsp, 8);
                 DEC(n)
             END
-        |CODE.opRES:
+        |IL.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:
+        |IL.opENTER:
             ASSERT(R.top = -1);
             IF cmd.allocReg THEN
                 allocReg(cmd)
             END
-        |CODE.opLEAVE, CODE.opLEAVER, CODE.opLEAVEF:
+        |IL.opLEAVE, IL.opLEAVER, IL.opLEAVEF:
-            IF cmd.opcode = CODE.opLEAVER THEN
+            IF opcode = IL.opLEAVER THEN
                 UnOp(reg1);
                 IF reg1 # rax THEN
                     GetRegA;
                 drop
             END;
             ASSERT(R.top = -1);
-            IF cmd.opcode = CODE.opLEAVEF THEN
+            IF opcode = IL.opLEAVEF THEN
                 DEC(xmm)
+            END;
-            END;
+            ASSERT(xmm = -1);
             IF param1 > 0 THEN
-            ASSERT(xmm = -1);
+                mov(rsp, rbp)
             END;
             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)
+                OutByte(0C3H) // ret
-        |CODE.opSAVES:
+            END;
-            UnOp(reg1);
+            REG.Reset(R)
-            drop;
-            PushAll(0);
+        |IL.opSAVES:
-            push(reg1);
-            pushDA(stroffs + param2);
+            PushAll(1);
-            pushc(param1);
+            pushDA(stroffs + param2);
-            CallRTL(CODE._move)
+            pushc(param1);
             CallRTL(IL._move)
-        |CODE.opSADR:
-            reg1 := REG.GetAnyReg(R);
+        |IL.opSADR:
-            lea(reg1, stroffs + param2, sDATA)
+            lea(GetAnyReg(), stroffs + param2, sDATA)
-        |CODE.opLOAD8:
+        |IL.opLOAD8:
             UnOp(reg1);
             movzx(reg1, reg1, 0, FALSE)
-        |CODE.opLOAD16:
+        |IL.opLOAD16:
             UnOp(reg1);
             movzx(reg1, reg1, 0, TRUE)
-        |CODE.opLOAD32:
+        |IL.opLOAD32:
             UnOp(reg1);
             movrm32(reg1, reg1, 0);
             shiftrc(shl, reg1, 32);
             shiftrc(shr, reg1, 32)
-        |CODE.opLOAD64:
+        |IL.opLOAD64:
             UnOp(reg1);
             movrm(reg1, reg1, 0)
-        |CODE.opLLOAD64:
+        |IL.opLLOAD64:
-            reg1 := REG.GetAnyReg(R);
+            reg1 := GetAnyReg();
-            reg2 := REG.GetVarReg(R, param2);
+            reg2 := GetVarReg(param2);
             IF reg2 # -1 THEN
                 mov(reg1, reg2)
             ELSE
                 movrm(reg1, rbp, param2 * 8)
             END
-        |CODE.opLLOAD8,
+        |IL.opLLOAD8,
-         CODE.opLLOAD16:
+         IL.opLLOAD16:
-            reg1 := REG.GetAnyReg(R);
+            reg1 := GetAnyReg();
-            reg2 := REG.GetVarReg(R, param2);
+            reg2 := GetVarReg(param2);
             IF reg2 # -1 THEN
                 mov(reg1, reg2)
             ELSE
-                movzx(reg1, rbp, param2 * 8, cmd.opcode = CODE.opLLOAD16)
+                movzx(reg1, rbp, param2 * 8, opcode = IL.opLLOAD16)
             END
-        |CODE.opLLOAD32:
+        |IL.opLLOAD32:
-            reg1 := REG.GetAnyReg(R);
+            reg1 := GetAnyReg();
-            reg2 := REG.GetVarReg(R, param2);
+            reg2 := GetVarReg(param2);
             IF reg2 # -1 THEN
                 mov(reg1, reg2)
             ELSE
                 n := param2 * 8;
                 xor(reg1, reg1);
                 movrm32(reg1, rbp, n)
             END
-        |CODE.opGLOAD64:
+        |IL.opGLOAD64:
-            reg1 := REG.GetAnyReg(R);
+            reg1 := GetAnyReg();
             lea(reg1, param2, sBSS);
             movrm(reg1, reg1, 0)
-        |CODE.opGLOAD8:
+        |IL.opGLOAD8:
-            reg1 := REG.GetAnyReg(R);
+            reg1 := GetAnyReg();
             lea(reg1, param2, sBSS);
             movzx(reg1, reg1, 0, FALSE)
-        |CODE.opGLOAD16:
+        |IL.opGLOAD16:
-            reg1 := REG.GetAnyReg(R);
+            reg1 := GetAnyReg();
             lea(reg1, param2, sBSS);
             movzx(reg1, reg1, 0, TRUE)
-        |CODE.opGLOAD32:
+        |IL.opGLOAD32:
-            reg1 := REG.GetAnyReg(R);
+            reg1 := GetAnyReg();
             xor(reg1, reg1);
             lea(reg1, param2, sBSS);
             movrm32(reg1, reg1, 0)
-        |CODE.opVLOAD64:
+        |IL.opVLOAD64:
-            reg1 := REG.GetAnyReg(R);
+            reg1 := GetAnyReg();
             movrm(reg1, rbp, param2 * 8);
             movrm(reg1, reg1, 0)
-        |CODE.opVLOAD8,
+        |IL.opVLOAD8,
-         CODE.opVLOAD16:
+         IL.opVLOAD16:
-            reg1 := REG.GetAnyReg(R);
+            reg1 := GetAnyReg();
             movrm(reg1, rbp, param2 * 8);
-            movzx(reg1, reg1, 0, cmd.opcode = CODE.opVLOAD16)
+            movzx(reg1, reg1, 0, opcode = IL.opVLOAD16)
-        |CODE.opVLOAD32:
+        |IL.opVLOAD32:
-            reg1 := REG.GetAnyReg(R);
+            reg1 := GetAnyReg();
-            reg2 := REG.GetAnyReg(R);
+            reg2 := GetAnyReg();
             xor(reg1, reg1);
             movrm(reg2, rbp, param2 * 8);
-            movrm32(reg1, reg2, 0);
-            drop
+            movrm32(reg1, reg2, 0);
+            drop
-        |CODE.opLADR:
-            n := param2 * 8;
-            next := cmd.next(COMMAND);
+        |IL.opLADR:
-            IF next.opcode = CODE.opSAVEF THEN
+            n := param2 * 8;
-                movsdmr(rbp, n, xmm);
+            next := cmd.next(COMMAND);
-                DEC(xmm);
+            IF next.opcode = IL.opSAVEF THEN
-                cmd := next
+                movsdmr(rbp, n, xmm);
-            ELSIF next.opcode = CODE.opLOADF THEN
+                DEC(xmm);
-                INC(xmm);
+                cmd := next
-                movsdrm(xmm, rbp, n);
+            ELSIF next.opcode = IL.opLOADF THEN
-                cmd := next
+                INC(xmm);
-            ELSE
+                movsdrm(xmm, rbp, n);
-                reg1 := REG.GetAnyReg(R);
+                cmd := next
-                Rex(0, reg1);
+            ELSE
-                OutByte2(8DH, 45H + long(n) + (reg1 MOD 8) * 8);  // lea reg1, qword[rbp+n]
+                reg1 := GetAnyReg();
-                OutIntByte(n)
+                Rex(0, reg1);
-            END
+                OutByte2(8DH, 45H + long(n) + (reg1 MOD 8) * 8);  // lea reg1, qword[rbp+n]
                 OutIntByte(n)
-        |CODE.opGADR:
+            END
             reg1 := REG.GetAnyReg(R);
-            lea(reg1, param2, sBSS)
+        |IL.opGADR:
+            lea(GetAnyReg(), param2, sBSS)
         |CODE.opVADR:
-            reg1 := REG.GetAnyReg(R);
+        |IL.opVADR:
-            movrm(reg1, rbp, param2 * 8)
+            movrm(GetAnyReg(), rbp, param2 * 8)
-        |CODE.opSAVE8C:
+        |IL.opSAVE8C:
             UnOp(reg1);
             IF reg1 >= 8 THEN
                 OutByte(41H)
             END;
             OutByte3(0C6H, reg1 MOD 8, param2); // mov byte[reg1], param2
             drop
-        |CODE.opSAVE16C:
+        |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
-        |CODE.opSAVEC:
+        |IL.opSAVEC:
             UnOp(reg1);
             IF isLong(param2) THEN
-                reg2 := REG.GetAnyReg(R);
+                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
-        |CODE.opRSET:
+        |IL.opRSET:
             PushAll(2);
-            CallRTL(CODE._set);
+            CallRTL(IL._set);
             GetRegA
-        |CODE.opRSETR:
+        |IL.opRSETR:
             PushAll(1);
             pushc(param2);
-            CallRTL(CODE._set);
+            CallRTL(IL._set);
-            GetRegA
-        |CODE.opRSETL:
-            PushAll(1);
-            pushc(param2);
-            CallRTL(CODE._set2);
-            GetRegA
-        |CODE.opRSET1:
-            UnOp(reg1);
-            PushAll(1);
-            push(reg1);
-            CallRTL(CODE._set);
+            GetRegA
-            GetRegA
+        |IL.opRSETL:
-        |CODE.opINCL, CODE.opEXCL:
+            PushAll(1);
-            BinOp(reg1, reg2);
+            pushc(param2);
-            cmprc(reg1, 64);
+            CallRTL(IL._set2);
-            OutByte2(73H, 04H); // jnb L
+            GetRegA
-            Rex(reg2, reg1);
-            OutByte3(0FH, 0ABH + 8 * ORD(cmd.opcode = CODE.opEXCL), 8 * (reg1 MOD 8) + reg2 MOD 8); // bts/btr qword[reg2], reg1
+        |IL.opRSET1:
-            // L:
-            drop;
+            UnOp(reg1);
-            drop
+            PushAll(1);
-        |CODE.opINCLC, CODE.opEXCLC:
-            UnOp(reg1);
+            push(reg1);
-            Rex(reg1, 0);
-            OutByte2(0FH, 0BAH);  // bts/btr qword[reg1], param2
+            CallRTL(IL._set);
-            OutByte2(28H + 8 * ORD(cmd.opcode = CODE.opEXCLC) + reg1 MOD 8, param2);
-            drop
+            GetRegA
-        |CODE.opEQS .. CODE.opGES:
+        |IL.opINCL, IL.opEXCL:
-            PushAll(4);
-            pushc(cmd.opcode - CODE.opEQS);
+            BinOp(reg1, reg2);
-            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);
+            cmprc(reg1, 64);
-            GetRegA
-        |CODE.opEQSW2 .. CODE.opGESW2:
-            PushAll(4);
-            pushc(cmd.opcode - CODE.opEQSW2);
-            CallRTL(CODE._strcmpw2);
-            GetRegA
-        |CODE.opINC1, CODE.opDEC1:
+            OutByte2(73H, 04H); // jnb L
-            UnOp(reg1);
+            Rex(reg2, reg1);
-            Rex(reg1, 0);
+            OutByte3(0FH, 0ABH + 8 * ORD(opcode = IL.opEXCL), 8 * (reg1 MOD 8) + reg2 MOD 8); // bts/btr qword[reg2], reg1
-            OutByte2(0FFH, reg1 MOD 8 + 8 * ORD(cmd.opcode = CODE.opDEC1));
+            // L:
-            drop
+            drop;
+            drop
+        |IL.opINCLC, IL.opEXCLC:
-        |CODE.opCONST:
+            UnOp(reg1);
-            reg1 := REG.GetAnyReg(R);
+            Rex(reg1, 0);
-            movrc(reg1, param2)
+            OutByte2(0FH, 0BAH);  // bts/btr qword[reg1], param2
             OutByte2(28H + 8 * ORD(opcode = IL.opEXCLC) + reg1 MOD 8, param2);
-        |CODE.opGT, CODE.opGE, CODE.opLT,
+            drop
          CODE.opLE, CODE.opEQ, CODE.opNE:
-            BinOp(reg1, reg2);
+        |IL.opEQS .. IL.opGES:
-            cmprr(reg1, reg2);
+            PushAll(4);
-            drop;
+            pushc(opcode - IL.opEQS);
-            drop;
+            CallRTL(IL._strcmp);
-            cc := X86.cond(cmd.opcode);
+            GetRegA
-            IF cmd.next(COMMAND).opcode = CODE.opJE THEN
+        |IL.opEQSW .. IL.opGESW:
-                label := cmd.next(COMMAND).param1;
+            PushAll(4);
-                jcc(cc, label);
+            pushc(opcode - IL.opEQSW);
-                cmd := cmd.next(COMMAND)
+            CallRTL(IL._strcmpw);
             GetRegA
-            ELSIF cmd.next(COMMAND).opcode = CODE.opJNE THEN
-                label := cmd.next(COMMAND).param1;
+        |IL.opCONST:
-                jcc(X86.inv1(cc), label);
+            movrc(GetAnyReg(), param2)
                 cmd := cmd.next(COMMAND)
+        |IL.opEQ..IL.opGE,
-            ELSE
+         IL.opEQC..IL.opGEC:
                 reg1 := REG.GetAnyReg(R);
-                setcc(cc + 16, reg1);
+            IF (IL.opEQ <= opcode) & (opcode <= IL.opGE) THEN
-                andrc(reg1, 1)
+                BinOp(reg1, reg2);
-            END
+                cmprr(reg1, reg2);
                 drop
-        |CODE.opGTR, CODE.opLTL, CODE.opGER, CODE.opLEL,
+            ELSE
-         CODE.opLER, CODE.opGEL, CODE.opLTR, CODE.opGTL,
+                UnOp(reg1);
-         CODE.opEQR, CODE.opEQL, CODE.opNER, CODE.opNEL:
+                IF param2 = 0 THEN
-            UnOp(reg1);
+                    test(reg1)
-            IF param2 = 0 THEN
+                ELSE
-                test(reg1)
+                    cmprc(reg1, param2)
-            ELSE
+                END
-                cmprc(reg1, param2)
+            END;
             END;
             drop;
-            cc := X86.cond(cmd.opcode);
+            cc := X86.cond(opcode);
-            IF cmd.next(COMMAND).opcode = CODE.opJE THEN
+            IF cmd.next(COMMAND).opcode = IL.opJE THEN
                 label := cmd.next(COMMAND).param1;
                 jcc(cc, label);
                 cmd := cmd.next(COMMAND)
-            ELSIF cmd.next(COMMAND).opcode = CODE.opJNE THEN
+            ELSIF cmd.next(COMMAND).opcode = IL.opJNE THEN
                 label := cmd.next(COMMAND).param1;
-                jcc(X86.inv1(cc), label);
+                jcc(X86.inv0(cc), label);
                 cmd := cmd.next(COMMAND)
             ELSE
-                reg1 := REG.GetAnyReg(R);
+                reg1 := GetAnyReg();
                 setcc(cc + 16, reg1);
                 andrc(reg1, 1)
             END
-        |CODE.opCODE:
+        |IL.opCODE:
             OutByte(param2)
-        |CODE.opPUSHIP:
+        |IL.opPUSHIP:
-            reg1 := REG.GetAnyReg(R);
+            reg1 := GetAnyReg();
             lea(reg1, param2, sIMP);
             setcc(setc, reg1);
             andrc(reg1, 1);
             X86.SetLabel(label);
             drop
-        |CODE.opINR:
+        |IL.opINR:
             label := NewLabel();
             L := NewLabel();
             UnOp(reg1);
-            reg2 := REG.GetAnyReg(R);
+            reg2 := GetAnyReg();
             cmprc(reg1, 64);
             jcc(jb, L);
             xor(reg1, reg1);
             jmp(label);
             setcc(setc, reg1);
             andrc(reg1, 1);
             X86.SetLabel(label);
             drop
-        |CODE.opINL:
+        |IL.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:
+        |IL.opNOT:
             UnOp(reg1);
             test(reg1);
             setcc(sete, reg1);
             andrc(reg1, 1)
-        |CODE.opORD:
+        |IL.opORD:
             UnOp(reg1);
             test(reg1);
             setcc(setne, reg1);
             andrc(reg1, 1)
-        |CODE.opABS:
+        |IL.opABS:
             UnOp(reg1);
             test(reg1);
             OutByte2(7DH, 03H); // jge L
             neg(reg1)
-            // L:
-        |CODE.opEQB, CODE.opNEB:
+            // L:
-            BinOp(reg1, reg2);
+        |IL.opEQB, IL.opNEB:
-            drop;
+            BinOp(reg1, reg2);
             drop;
             test(reg1);
+            label := NewLabel();
-            test(reg1);
+            jcc(je, label);
-            OutByte2(74H, 07H); // je L1
+            movrc(reg1, 1);
-            movrc(reg1, 1);
+            X86.SetLabel(label);
-            // L1:
+            test(reg2);
-            test(reg2);
-            OutByte2(74H, 07H); // je L2
+            label := NewLabel();
-            movrc(reg2, 1);
+            jcc(je, label);
-            // L2:
+            movrc(reg2, 1);
-            cmprr(reg1, reg2);
+            X86.SetLabel(label);
-            reg1 := REG.GetAnyReg(R);
+            cmprr(reg1, reg2);
-            IF cmd.opcode = CODE.opEQB THEN
+            IF opcode = IL.opEQB THEN
                 setcc(sete, reg1)
             ELSE
                 setcc(setne, reg1)
             END;
             andrc(reg1, 1)
-        |CODE.opMULSC:
+        |IL.opMULSC:
             UnOp(reg1);
             andrc(reg1, param2)
-        |CODE.opDIVSC, CODE.opADDSL, CODE.opADDSR:
+        |IL.opDIVSC, IL.opADDSL, IL.opADDSR:
             UnOp(reg1);
             Rex(reg1, 0);
-            OutByte2(81H + short(param2), 0C8H + 28H * ORD(cmd.opcode = CODE.opDIVSC) + reg1 MOD 8); // or/xor reg1, param2
+            OutByte2(81H + short(param2), 0C8H + 28H * ORD(opcode = IL.opDIVSC) + reg1 MOD 8); // or/xor reg1, param2
             OutIntByte(param2)
-        |CODE.opSUBSL:
+        |IL.opSUBSL:
             UnOp(reg1);
             not(reg1);
             andrc(reg1, param2)
-        |CODE.opSUBSR:
+        |IL.opSUBSR:
             UnOp(reg1);
             andrc(reg1, ORD(-BITS(param2)))
-        |CODE.opMULS:
+        |IL.opMULS:
             BinOp(reg1, reg2);
             and(reg1, reg2);
             drop
-        |CODE.opDIVS:
+        |IL.opDIVS:
             BinOp(reg1, reg2);
             xor(reg1, reg2);
             drop
-        |CODE.opUMINS:
+        |IL.opUMINS:
             UnOp(reg1);
             not(reg1)
-        |CODE.opCOPY:
-            PushAll(2);
-            pushc(param2);
-            CallRTL(CODE._move2)
-        |CODE.opMOVE:
+        |IL.opCOPY:
-            PushAll(3);
+            PushAll(2);
-            CallRTL(CODE._move2)
+            pushc(param2);
+            CallRTL(IL._move2)
         |CODE.opCOPYA:
-            PushAll(4);
+        |IL.opMOVE:
-            pushc(param2);
+            PushAll(3);
-            CallRTL(CODE._arrcpy);
+            CallRTL(IL._move2)
-            GetRegA
         |IL.opCOPYA:
-        |CODE.opCOPYS:
+            PushAll(4);
-            PushAll(4);
+            pushc(param2);
-            pushc(param2);
+            CallRTL(IL._arrcpy);
-            CallRTL(CODE._strcpy)
+            GetRegA
-        |CODE.opCOPYS2:
+        |IL.opCOPYS:
             PushAll(4);
             pushc(param2);
-            CallRTL(CODE._strcpy2)
+            CallRTL(IL._strcpy)
-        |CODE.opROT:
+        |IL.opROT:
             PushAll(0);
             push(rsp);
             pushc(param2);
-            CallRTL(CODE._rot)
+            CallRTL(IL._rot)
-        |CODE.opNEW:
+        |IL.opNEW:
             PushAll(1);
             n := param2 + 16;
-            ASSERT(MACHINE.Align(n, 64));
+            ASSERT(UTILS.Align(n, 64));
             pushc(n);
             pushc(param1);
-            CallRTL(CODE._new)
+            CallRTL(IL._new)
-        |CODE.opDISP:
+        |IL.opDISP:
             PushAll(1);
-            CallRTL(CODE._dispose)
+            CallRTL(IL._dispose)
-        |CODE.opPUSHT:
+        |IL.opPUSHT:
             UnOp(reg1);
-            reg2 := REG.GetAnyReg(R);
+            reg2 := GetAnyReg();
             movrm(reg2, reg1, -8)
-        |CODE.opISREC:
+        |IL.opISREC:
             PushAll(2);
-            pushc(param2);
+            pushc(param2 * tcount);
-            CallRTL(CODE._isrec);
+            CallRTL(IL._isrec);
             GetRegA
-        |CODE.opIS:
+        |IL.opIS:
             PushAll(1);
-            pushc(param2);
+            pushc(param2 * tcount);
-            CallRTL(CODE._is);
+            CallRTL(IL._is);
             GetRegA
-        |CODE.opTYPEGR:
+        |IL.opTYPEGR:
             PushAll(1);
-            pushc(param2);
+            pushc(param2 * tcount);
-            CallRTL(CODE._guardrec);
+            CallRTL(IL._guardrec);
             GetRegA
-        |CODE.opTYPEGP:
+        |IL.opTYPEGP:
             UnOp(reg1);
             PushAll(0);
             push(reg1);
-            pushc(param2);
+            pushc(param2 * tcount);
-            CallRTL(CODE._guard);
+            CallRTL(IL._guard);
-            GetRegA
+            GetRegA
-        |CODE.opTYPEGD:
-            UnOp(reg1);
+        |IL.opTYPEGD:
-            PushAll(0);
+            UnOp(reg1);
-            pushm(reg1, -8);
+            PushAll(0);
-            pushc(param2);
+            pushm(reg1, -8);
-            CallRTL(CODE._guardrec);
+            pushc(param2 * tcount);
-            GetRegA
+            CallRTL(IL._guardrec);
+            GetRegA
         |CODE.opCASET:
-            push(r10);
+        |IL.opCASET:
             push(r10);
-            pushc(param2);
+            push(r10);
-            CallRTL(CODE._guardrec);
+            pushc(param2 * tcount);
-            pop(r10);
+            CallRTL(IL._guardrec);
-            test(rax);
+            pop(r10);
-            jcc(jne, param1)
+            test(rax);
+            jcc(jne, param1)
+        |IL.opSAVEP:
             UnOp(reg1);
-        |CODE.opSAVEP:
+            reg2 := GetAnyReg();
-            UnOp(reg1);
+            lea(reg2, param2, sCODE);
-            reg2 := REG.GetAnyReg(R);
+            movmr(reg1, 0, reg2);
-            lea(reg2, param2, sCODE);
+            drop;
-            movmr(reg1, 0, reg2);
+            drop
             drop;
-            drop
+        |IL.opPUSHP:
             lea(GetAnyReg(), param2, sCODE)
         |CODE.opPUSHP:
-            reg1 := REG.GetAnyReg(R);
+        |IL.opINC, IL.opDEC:
-            lea(reg1, param2, sCODE)
+            BinOp(reg1, reg2);
             // add/sub qword[reg2], reg1
-        |CODE.opINC, CODE.opDEC:
+            Rex(reg2, reg1);
-            BinOp(reg1, reg2);
+            OutByte2(01H + 28H * ORD(opcode = IL.opDEC), reg2 MOD 8 + (reg1 MOD 8) * 8);
-            // add/sub qword[reg2], reg1
+            drop;
-            Rex(reg2, reg1);
+            drop
             OutByte2(01H + 28H * ORD(cmd.opcode = CODE.opDEC), reg2 MOD 8 + (reg1 MOD 8) * 8);
-            drop;
+        |IL.opINCC:
-            drop
+            UnOp(reg1);
+            IF isLong(param2) THEN
-        |CODE.opINCC, CODE.opDECC:
+                reg2 := GetAnyReg();
-            UnOp(reg1);
+                movrc(reg2, param2);
-            IF isLong(param2) THEN
+                // add qword[reg1], reg2
-                reg2 := REG.GetAnyReg(R);
+                Rex(reg1, reg2);
-                movrc(reg2, param2);
+                OutByte2(01H, reg1 MOD 8 + (reg2 MOD 8) * 8);
-                // add/sub qword[reg1], reg2
+                drop
-                Rex(reg1, reg2);
+            ELSIF ABS(param2) = 1 THEN
-                OutByte2(01H + 28H * ORD(cmd.opcode = CODE.opDECC), reg1 MOD 8 + (reg2 MOD 8) * 8);
+                Rex(reg1, 0);
-                drop
+                OutByte2(0FFH, reg1 MOD 8 + 8 * ORD(param2 = -1)) // inc/dec qword[reg1]
             ELSE
-                // add/sub qword[reg1], param2
+                // add qword[reg1], param2
                 Rex(reg1, 0);
-                OutByte2(81H + short(param2), 28H * ORD(cmd.opcode = CODE.opDECC) + reg1 MOD 8);
+                OutByte2(81H + short(param2), reg1 MOD 8);
                 OutIntByte(param2)
             END;
             drop
-        |CODE.opDROP:
+        |IL.opDROP:
             UnOp(reg1);
             drop
-        |CODE.opSAVE, CODE.opSAVE64:
+        |IL.opSAVE, IL.opSAVE64:
             BinOp(reg2, reg1);
             movmr(reg1, 0, reg2);
             drop;
             drop
-        |CODE.opSAVE8:
+        |IL.opSAVE8:
             BinOp(reg2, reg1);
             movmr8(reg1, 0, reg2);
             drop;
             drop
-        |CODE.opSAVE16:
+        |IL.opSAVE16:
             BinOp(reg2, reg1);
             movmr16(reg1, 0, reg2);
             drop;
             drop
-        |CODE.opSAVE32:
+        |IL.opSAVE32:
             BinOp(reg2, reg1);
             movmr32(reg1, 0, reg2);
+            drop;
+            drop
             drop;
-            drop
+        |IL.opMIN:
+            BinOp(reg1, reg2);
-        |CODE.opMIN:
+            cmprr(reg1, reg2);
-            BinOp(reg1, reg2);
+            OutByte2(7EH, 3); // jle L
-            cmprr(reg1, reg2);
+            mov(reg1, reg2);
-            OutByte2(7EH, 3); // jle L
+            // L:
-            mov(reg1, reg2);
+            drop
             // L:
-            drop
+        |IL.opMAX:
             BinOp(reg1, reg2);
-        |CODE.opMAX:
+            cmprr(reg1, reg2);
-            BinOp(reg1, reg2);
+            OutByte2(7DH, 3);  // jge L
-            cmprr(reg1, reg2);
+            mov(reg1, reg2);
-            OutByte2(7DH, 3);  // jge L
+            // L:
-            mov(reg1, reg2);
+            drop
             // L:
-            drop
+        |IL.opMINC:
             UnOp(reg1);
-        |CODE.opMINC:
+            cmprc(reg1, param2);
-            UnOp(reg1);
+            label := NewLabel();
-            cmprc(reg1, param2);
+            jcc(jle, label);
-            label := NewLabel();
+            movrc(reg1, param2);
-            jcc(jle, label);
+            X86.SetLabel(label)
             movrc(reg1, param2);
-            X86.SetLabel(label)
+        |IL.opMAXC:
             UnOp(reg1);
-        |CODE.opMAXC:
+            cmprc(reg1, param2);
-            UnOp(reg1);
+            label := NewLabel();
-            cmprc(reg1, param2);
+            jcc(jge, label);
-            label := NewLabel();
+            movrc(reg1, param2);
-            jcc(jge, label);
+            X86.SetLabel(label)
             movrc(reg1, param2);
-            X86.SetLabel(label)
+        |IL.opSBOOL:
             BinOp(reg2, reg1);
-        |CODE.opSBOOL:
+            test(reg2);
-            BinOp(reg2, reg1);
+            IF reg1 >= 8 THEN
-            test(reg2);
+                OutByte(41H)
-            setcc(setne, reg2);
+            END;
-            movmr8(reg1, 0, reg2);
+            OutByte3(0FH, 95H, reg1 MOD 8); // setne byte[reg1]
             drop;
             drop
                 ELSE
                     addrc(reg1, param2)
                 END
             END
-        |CODE.opDIV:
+        |IL.opDIV:
             PushAll(2);
-            CallRTL(CODE._div);
+            CallRTL(IL._div);
             GetRegA
-        |CODE.opDIVR:
+        |IL.opDIVR:
             a := param2;
             IF a > 1 THEN
-                n := X86.log2(a)
+                n := UTILS.Log2(a)
             ELSIF a < -1 THEN
-                n := X86.log2(-a)
+                n := UTILS.Log2(-a)
             ELSE
                 n := -1
             ELSE
                 IF n > 0 THEN
                     UnOp(reg1);
                     IF a < 0 THEN
-                        reg2 := REG.GetAnyReg(R);
+                        reg2 := GetAnyReg();
                         mov(reg2, reg1);
                         shiftrc(sar, reg1, n);
                         sub(reg1, reg2);
                         drop
                     END
                 ELSE
                     PushAll(1);
                     pushc(param2);
-                    CallRTL(CODE._div);
+                    CallRTL(IL._div);
                     GetRegA
                 END
             END
-        |CODE.opDIVL:
+        |IL.opDIVL:
             PushAll(1);
             pushc(param2);
-            CallRTL(CODE._div2);
+            CallRTL(IL._div2);
             GetRegA
-        |CODE.opMOD:
+        |IL.opMOD:
             PushAll(2);
-            CallRTL(CODE._mod);
+            CallRTL(IL._mod);
             GetRegA
-        |CODE.opMODR:
+        |IL.opMODR:
             a := param2;
             IF a > 1 THEN
-                n := X86.log2(a)
+                n := UTILS.Log2(a)
             ELSIF a < -1 THEN
-                n := X86.log2(-a)
+                n := UTILS.Log2(-a)
                     END
                 ELSE
                     PushAll(1);
                     pushc(param2);
-                    CallRTL(CODE._mod);
+                    CallRTL(IL._mod);
                     GetRegA
                 END
             END
-        |CODE.opMODL:
+        |IL.opMODL:
             PushAll(1);
             pushc(param2);
-            CallRTL(CODE._mod2);
+            CallRTL(IL._mod2);
             GetRegA
-        |CODE.opMUL:
+        |IL.opMUL:
             BinOp(reg1, reg2);
             oprr2(0FH, 0AFH, reg2, reg1); // imul reg1, reg2
             drop
-        |CODE.opMULC:
+        |IL.opMULC:
             UnOp(reg1);
             a := param2;
             IF a > 1 THEN
-                n := X86.log2(a)
+                n := UTILS.Log2(a)
             ELSIF a < -1 THEN
                     OutByte2(69H + short(a), 0C0H + (reg1 MOD 8) * 9);
                     OutIntByte(a)
                 END
             END
-        |CODE.opADDS:
+        |IL.opADDS:
             BinOp(reg1, reg2);
             or(reg1, reg2);
             drop
-        |CODE.opSUBS:
+        |IL.opSUBS:
             BinOp(reg1, reg2);
             not(reg2);
             and(reg1, reg2);
             drop
-        |CODE.opNOP:
+        |IL.opNOP:
-        |CODE.opSWITCH:
+        |IL.opSWITCH:
             UnOp(reg1);
                 ASSERT(REG.Exchange(R, reg1, reg2));
                 drop
             END;
             drop
-        |CODE.opENDSW:
+        |IL.opENDSW:
-        |CODE.opCASEL:
+        |IL.opCASEL:
             cmprc(rax, param1);
             jcc(jl, param2)
-        |CODE.opCASER:
+        |IL.opCASER:
             cmprc(rax, param1);
             jcc(jg, param2)
-        |CODE.opCASELR:
+        |IL.opCASELR:
             cmprc(rax, param1);
             jcc(jl, param2);
             jcc(jg, cmd.param3)
-        |CODE.opASR, CODE.opROR, CODE.opLSL, CODE.opLSR:
+        |IL.opASR, IL.opROR, IL.opLSL, IL.opLSR:
             BinOp(reg1, reg2);
             xchg(reg2, rcx);
             Rex(reg1, 0);
             OutByte(0D3H);
-            X86.shift(cmd.opcode, reg1 MOD 8); // shift reg1, cl
+            X86.shift(opcode, reg1 MOD 8); // shift reg1, cl
             xchg(reg2, rcx);
             drop
-        |CODE.opASR1, CODE.opROR1, CODE.opLSL1, CODE.opLSR1:
+        |IL.opASR1, IL.opROR1, IL.opLSL1, IL.opLSR1:
-            reg1 := REG.GetAnyReg(R);
+            reg1 := GetAnyReg();
             movrc(reg1, param2);
             BinOp(reg1, reg2);
             xchg(reg1, rcx);
             Rex(reg2, 0);
             OutByte(0D3H);
-            X86.shift(cmd.opcode, reg2 MOD 8); // shift reg2, cl
+            X86.shift(opcode, reg2 MOD 8); // shift reg2, cl
             xchg(reg1, rcx);
             drop;
+            drop;
-            drop;
+            ASSERT(REG.GetReg(R, reg2))
+        |IL.opASR2, IL.opROR2, IL.opLSL2, IL.opLSR2:
+            UnOp(reg1);
+            shiftrc(opcode, reg1, param2 MOD 64)
-            ASSERT(REG.GetReg(R, reg2))
+        |IL.opGET, IL.opGETC:
             IF opcode = IL.opGET THEN
-        |CODE.opASR2, CODE.opROR2, CODE.opLSL2, CODE.opLSR2:
+                BinOp(reg1, reg2)
-            UnOp(reg1);
+            ELSIF opcode = IL.opGETC THEN
-            shiftrc(cmd.opcode, reg1, ORD(BITS(param2) * {0..5}))
+                UnOp(reg2);
                 reg1 := GetAnyReg();
-        |CODE.opGET:
+                movrc(reg1, param1)
-            BinOp(reg1, reg2);
+            END;
             drop;
             drop;
             _movrm(reg1, reg1, 0, param2 * 8, FALSE);
             _movrm(reg1, reg2, 0, param2 * 8, TRUE)
-        |CODE.opCHKBYTE:
+        |IL.opCHKBYTE:
             BinOp(reg1, reg2);
             cmprc(reg1, 256);
             jcc(jb, param1)
                 INCL(R.regs, reg1);
                 DEC(R.top);
                 R.stk[R.top] := reg2
             END
-        |CODE.opLENGTH:
+        |IL.opLENGTH:
             PushAll(2);
-            CallRTL(CODE._length);
+            CallRTL(IL._length);
             GetRegA
-        |CODE.opLENGTHW:
+        |IL.opLENGTHW:
             PushAll(2);
-            CallRTL(CODE._lengthw);
+            CallRTL(IL._lengthw);
             GetRegA
-        |CODE.opLEN:
+        |IL.opLEN:
             n := param2;
             END;
             INCL(R.regs, reg1);
             ASSERT(REG.GetReg(R, reg1))
-        |CODE.opCHR:
+        |IL.opCHR:
             UnOp(reg1);
             andrc(reg1, 255)
-        |CODE.opWCHR:
+        |IL.opWCHR:
             UnOp(reg1);
             andrc(reg1, 65535)
-        |CODE.opEQP, CODE.opNEP, CODE.opEQIP, CODE.opNEIP:
+        |IL.opEQP, IL.opNEP, IL.opEQIP, IL.opNEIP:
             UnOp(reg1);
-            reg2 := REG.GetAnyReg(R);
+            reg2 := GetAnyReg();
-            CASE cmd.opcode OF
+            CASE opcode OF
-            |CODE.opEQP, CODE.opNEP:
+            |IL.opEQP, IL.opNEP:
                 lea(reg2, param1, sCODE)
-            |CODE.opEQIP, CODE.opNEIP:
+            |IL.opEQIP, IL.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)
+            drop;
             reg1 := GetAnyReg();
         |CODE.opINC1B, CODE.opDEC1B:
-            UnOp(reg1);
+            CASE opcode OF
-            IF reg1 >= 8 THEN
+            |IL.opEQP, IL.opEQIP: setcc(sete,  reg1)
-                OutByte(41H)
+            |IL.opNEP, IL.opNEIP: setcc(setne, reg1)
             END;
-            OutByte2(0FEH, 8 * ORD(cmd.opcode = CODE.opDEC1B) + reg1 MOD 8); // inc/dec byte[reg1]
-            drop
+            andrc(reg1, 1)
-        |CODE.opINCCB, CODE.opDECCB:
+        |IL.opINCCB, IL.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
+            OutByte3(80H, 28H * ORD(opcode = IL.opDECCB) + reg1 MOD 8, param2 MOD 256); // add/sub byte[reg1], param2 MOD 256
             drop
-        |CODE.opINCB, CODE.opDECB:
+        |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(cmd.opcode = CODE.opDECB), reg2 MOD 8 + 8 * (reg1 MOD 8)); // add/sub byte[reg2], reg1_8
+            OutByte2(28H * ORD(opcode = IL.opDECB), reg2 MOD 8 + 8 * (reg1 MOD 8)); // add/sub byte[reg2], reg1_8
             drop;
             drop
-        |CODE.opSAVEIP:
+        |IL.opSAVEIP:
             UnOp(reg1);
-            reg2 := REG.GetAnyReg(R);
+            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
-        |CODE.opCLEANUP:
+        |IL.opCLEANUP:
             n := param2 * 8;
             IF n # 0 THEN
                 addrc(rsp, n)
             END
-        |CODE.opPOPSP:
+        |IL.opPOPSP:
             pop(rsp)
-        |CODE.opLOADF:
+        |IL.opLOADF:
             UnOp(reg1);
             INC(xmm);
             movsdrm(xmm, reg1, 0);
             drop
-        |CODE.opPUSHF:
+        |IL.opPUSHF:
             subrc(rsp, 8);
             movsdmr(rsp, 0, xmm);
             DEC(xmm)
-        |CODE.opCONSTF:
+        |IL.opCONSTF:
             float := cmd.float;
             INC(xmm);
-            reg1 := REG.GetAnyReg(R);
+            reg1 := GetAnyReg();
             lea(reg1, Numbers_Offs + Numbers_Count * 8, sDATA);
             movsdrm(xmm, reg1, 0);
             drop;
             NewNumber(UTILS.splitf(float, a, b))
-        |CODE.opSAVEF:
+        |IL.opSAVEF:
             UnOp(reg1);
             movsdmr(reg1, 0, xmm);
             DEC(xmm);
             drop
-        |CODE.opADDF, CODE.opADDFI:
+        |IL.opADDF, IL.opADDFI:
             opxx(58H, xmm - 1, xmm);
             DEC(xmm)
-        |CODE.opSUBF:
+        |IL.opSUBF:
             opxx(5CH, xmm - 1, xmm);
             DEC(xmm)
-        |CODE.opSUBFI:
+        |IL.opSUBFI:
             opxx(5CH, xmm, xmm - 1);
             opxx(10H, xmm - 1, xmm);
             DEC(xmm)
-        |CODE.opMULF:
+        |IL.opMULF:
             opxx(59H, xmm - 1, xmm);
             DEC(xmm)
-        |CODE.opDIVF:
+        |IL.opDIVF:
             opxx(5EH, xmm - 1, xmm);
             DEC(xmm)
-        |CODE.opDIVFI:
+        |IL.opDIVFI:
             opxx(5EH, xmm, xmm - 1);
             opxx(10H, xmm - 1, xmm);
             DEC(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:
+        |IL.opEQF .. IL.opGEF:
-            fcmp(cmd.opcode, xmm);
+            fcmp(opcode, xmm);
             DEC(xmm, 2)
-        |CODE.opINF:
+        |IL.opINF:
             INC(xmm);
-            reg1 := REG.GetAnyReg(R);
+            reg1 := GetAnyReg();
             lea(reg1, Numbers_Offs + 32, sDATA);
             movsdrm(xmm, reg1, 0);
             drop
-        |CODE.opPACK, CODE.opPACKC:
+        |IL.opPACK, IL.opPACKC:
-            IF cmd.opcode = CODE.opPACK THEN
+            IF opcode = IL.opPACK THEN
                 BinOp(reg1, reg2)
             ELSE
                 UnOp(reg1);
-                reg2 := REG.GetAnyReg(R);
+                reg2 := GetAnyReg();
                 movrc(reg2, param2)
             END;
             pop(reg1);
             movmr(reg1, 0, reg2);
             drop;
             drop
-        |CODE.opUNPK, CODE.opLADR_UNPK:
+        |IL.opUNPK, IL.opLADR_UNPK:
-            IF cmd.opcode = CODE.opLADR_UNPK THEN
+            IF opcode = IL.opLADR_UNPK THEN
                 n := param2 * 8;
                 UnOp(reg1);
-                reg2 := REG.GetVarReg(R, param2);
+                reg2 := GetVarReg(param2);
                 regVar := reg2 # -1;
                 IF ~regVar THEN
-                    reg2 := REG.GetAnyReg(R);
+                    reg2 := GetAnyReg();
                     Rex(0, reg2);
                     OutByte2(8DH, 45H + long(n) + (reg2 MOD 8) * 8);  // lea reg2, qword[rbp+n]
                     OutIntByte(n)
             shiftrc(shr, reg1, 53);
             subrc(reg1, 1023);
             IF regVar THEN
                 mov(reg2, reg1);
-                reg2 := REG.GetAnyReg(R)
+                reg2 := GetAnyReg()
             ELSE
                 movmr(reg2, 0, reg1)
             END;
             OutByte2(0F0H + reg1 MOD 8, 3EH); // btr reg1, 62
             movmr(reg2, 0, reg1);
             drop;
             drop
-        |CODE.opSADR_PARAM:
+        |IL.opSADR_PARAM:
             pushDA(stroffs + param2)
-        |CODE.opVADR_PARAM:
+        |IL.opVADR_PARAM:
             pushm(rbp, param2 * 8)
-        |CODE.opLOAD64_PARAM:
+        |IL.opLOAD64_PARAM:
             UnOp(reg1);
             pushm(reg1, 0);
             drop
-        |CODE.opLLOAD64_PARAM:
+        |IL.opLLOAD64_PARAM:
-            reg1 := REG.GetVarReg(R, param2);
+            reg1 := GetVarReg(param2);
             IF reg1 # -1 THEN
                 push(reg1)
             ELSE
                 pushm(rbp, param2 * 8)
             END
-        |CODE.opGLOAD64_PARAM:
+        |IL.opGLOAD64_PARAM:
-            reg2 := REG.GetAnyReg(R);
+            reg2 := GetAnyReg();
             lea(reg2, param2, sBSS);
             movrm(reg2, reg2, 0);
             push(reg2);
             drop
-        |CODE.opCONST_PARAM:
+        |IL.opCONST_PARAM:
             pushc(param2)
-        |CODE.opGLOAD32_PARAM:
+        |IL.opGLOAD32_PARAM:
-            reg1 := REG.GetAnyReg(R);
+            reg1 := GetAnyReg();
             xor(reg1, reg1);
             lea(reg1, param2, sBSS);
             movrm32(reg1, reg1, 0);
             push(reg1);
             drop
-        |CODE.opLOAD32_PARAM:
+        |IL.opLOAD32_PARAM:
             UnOp(reg1);
             movrm32(reg1, reg1, 0);
             shiftrc(shl, reg1, 32);
             shiftrc(shr, reg1, 32);
             push(reg1);
             drop
-        |CODE.opLLOAD32_PARAM:
+        |IL.opLLOAD32_PARAM:
-            reg1 := REG.GetAnyReg(R);
+            reg1 := GetAnyReg();
             xor(reg1, reg1);
-            reg2 := REG.GetVarReg(R, param2);
+            reg2 := GetVarReg(param2);
             IF reg2 # -1 THEN
                 mov(reg1, reg2)
             ELSE
                 movrm32(reg1, rbp, param2 * 8)
             END;
             push(reg1);
             drop
-        |CODE.opLADR_SAVEC:
+        |IL.opLADR_SAVEC:
             n := param1 * 8;
-            reg1 := REG.GetVarReg(R, param1);
+            reg1 := GetVarReg(param1);
             IF reg1 # -1 THEN
                 movrc(reg1, param2)
             ELSE
                 IF isLong(param2) THEN
-                    reg2 := REG.GetAnyReg(R);
+                    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
             END
-        |CODE.opGADR_SAVEC:
+        |IL.opGADR_SAVEC:
             IF isLong(param2) THEN
-                reg1 := REG.GetAnyReg(R);
+                reg1 := GetAnyReg();
                 movrc(reg1, param2);
-                reg2 := REG.GetAnyReg(R);
+                reg2 := GetAnyReg();
                 lea(reg2, param1, sBSS);
                 movmr(reg2, 0, reg1);
                 drop;
                 drop
             ELSE
-                reg2 := REG.GetAnyReg(R);
+                reg2 := GetAnyReg();
                 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:
+        |IL.opLADR_SAVE:
-            reg1 := REG.GetVarReg(R, param2);
+            UnOp(reg1);
-            IF reg1 # -1 THEN
+            reg2 := GetVarReg(param2);
-                decr(reg1)
-            ELSE
-                n := param2 * 8;
-                OutByte3(48H, 0FFH, 4DH + long(n)); // dec qword[rbp+n]
+            IF reg2 # -1 THEN
-                OutIntByte(n)
-            END
+                mov(reg2, reg1)
             ELSE
-        |CODE.opLADR_INCC, CODE.opLADR_DECC:
+                movmr(rbp, param2 * 8, reg1)
-            reg1 := REG.GetVarReg(R, param1);
+            END;
-            IF isLong(param2) THEN
+            drop
                 reg2 := REG.GetAnyReg(R);
-                movrc(reg2, param2);
+        |IL.opLADR_INCC:
-                IF reg1 # -1 THEN
+            reg1 := GetVarReg(param1);
-                    IF cmd.opcode = CODE.opLADR_DECC THEN
+            IF isLong(param2) THEN
-                        sub(reg1, reg2)
+                reg2 := GetAnyReg();
-                    ELSE
+                movrc(reg2, param2);
-                        add(reg1, reg2)
+                IF reg1 # -1 THEN
-                    END
+                    add(reg1, reg2)
                 ELSE
                     n := param1 * 8;
                     Rex(0, reg2);
-                    OutByte2(01H + 28H * ORD(cmd.opcode = CODE.opLADR_DECC), 45H + long(n) + (reg2 MOD 8) * 8);
+                    OutByte2(01H, 45H + long(n) + (reg2 MOD 8) * 8);
-                    OutIntByte(n) // add/sub qword[rbp+n],reg2
+                    OutIntByte(n) // add qword[rbp+n],reg2
-                END;
-                drop
-            ELSE
+                END;
-                IF reg1 # -1 THEN
-                    IF cmd.opcode = CODE.opLADR_DECC THEN
-                        subrc(reg1, param2)
-                    ELSE
-                        addrc(reg1, param2)
-                    END
-                ELSE
+                drop
-                    n := param1 * 8;
+            ELSIF ABS(param2) = 1 THEN
-                    OutByte3(48H, 81H + short(param2), 45H + long(n) + 28H * ORD(cmd.opcode = CODE.opLADR_DECC));
-                    OutIntByte(n);
+                IF reg1 # -1 THEN
-                    OutIntByte(param2) // add/sub qword[rbp+n],param2
+                    IF param2 = 1 THEN
-                END
+                        incr(reg1)
-            END
+                    ELSE
+                        decr(reg1)
+                    END
+                ELSE
-        |CODE.opLADR_INC1B, CODE.opLADR_DEC1B:
+                    n := param1 * 8;
-            reg1 := REG.GetVarReg(R, param2);
+                    OutByte3(48H, 0FFH, 45H + 8 * ORD(param2 = -1) + long(n)); // inc/dec qword[rbp+n]
-            IF reg1 # -1 THEN
+                    OutIntByte(n)
-                IF cmd.opcode = CODE.opLADR_DEC1B THEN
+                END
-                    decr(reg1)
+            ELSE
-                ELSE
+                IF reg1 # -1 THEN
-                    incr(reg1)
+                    addrc(reg1, param2)
-                END;
+                ELSE
-                andrc(reg1, 255)
+                    n := param1 * 8;
-            ELSE
+                    OutByte3(48H, 81H + short(param2), 45H + long(n));
-                n := param2 * 8;
+                    OutIntByte(n);
-                OutByte2(0FEH, 45H + long(n) + 8 * ORD(cmd.opcode = CODE.opLADR_DEC1B));
+                    OutIntByte(param2) // add qword[rbp+n],param2
-                OutIntByte(n)  // inc/dec byte[rbp+n]
+                END
             END
-        |CODE.opLADR_INCCB, CODE.opLADR_DECCB:
+        |IL.opLADR_INCCB, IL.opLADR_DECCB:
-            reg1 := REG.GetVarReg(R, param1);
+            reg1 := GetVarReg(param1);
             param2 := param2 MOD 256;
             IF reg1 # -1 THEN
-                IF cmd.opcode = CODE.opLADR_DECCB THEN
+                IF opcode = IL.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));
+                OutByte2(80H, 45H + long(n) + 28H * ORD(opcode = IL.opLADR_DECCB));
                 OutIntByte(n);
                 OutByte(param2) // add/sub byte[rbp+n],param2
             END
-        |CODE.opLADR_INC, CODE.opLADR_DEC:
+        |IL.opLADR_INC, IL.opLADR_DEC:
             UnOp(reg1);
-            reg2 := REG.GetVarReg(R, param2);
+            reg2 := GetVarReg(param2);
             IF reg2 # -1 THEN
-                IF cmd.opcode = CODE.opLADR_DEC THEN
+                IF opcode = IL.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);
+                OutByte2(01H + 28H * ORD(opcode = IL.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:
+        |IL.opLADR_INCB, IL.opLADR_DECB:
             UnOp(reg1);
-            reg2 := REG.GetVarReg(R, param2);
+            reg2 := GetVarReg(param2);
             IF reg2 # -1 THEN
-                IF cmd.opcode = CODE.opLADR_DECB THEN
+                IF opcode = IL.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));
+                OutByte2(28H * ORD(opcode = IL.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:
+        |IL.opLADR_INCL, IL.opLADR_EXCL:
             UnOp(reg1);
             cmprc(reg1, 64);
-            reg2 := REG.GetVarReg(R, param2);
+            reg2 := GetVarReg(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
+                oprr2(0FH, 0ABH + 8 * ORD(opcode = IL.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));
+                OutByte3(0FH, 0ABH + 8 * ORD(opcode = IL.opLADR_EXCL), 45H + long(n) + 8 * (reg1 MOD 8));
                 OutIntByte(n) // bts/btr qword[rbp+n], reg1
             END;
             // L:
             drop
     ASSERT(R.top = -1);
     ASSERT(xmm = -1)
 END translate;
-PROCEDURE prolog (code: CODE.CODES; modname: ARRAY OF CHAR; target, stack_size: INTEGER);
+PROCEDURE prolog (code: IL.CODES; modname: ARRAY OF CHAR; target, stack_size: INTEGER);
 VAR
-    ModName_Offs, entry: INTEGER;
+    ModName_Offs, entry, L: INTEGER;
 BEGIN
-    ModName_Offs := CHL.Length(code.types) * 8 + CHL.Length(code.data);
+    ModName_Offs := tcount * 8 + CHL.Length(code.data);
     Numbers_Offs := ModName_Offs + LENGTH(modname) + 1;
-    ASSERT(MACHINE.Align(Numbers_Offs, 16));
+    ASSERT(UTILS.Align(Numbers_Offs, 16));
     entry := NewLabel();
     X86.SetLabel(entry);
     IF target = mConst.Target_iDLL64 THEN
         dllret := NewLabel();
         push(r8);
         push(rdx);
+        push(rcx);
-        push(rcx);
+        CallRTL(IL._dllentry);
+        test(rax);
+        jcc(je, dllret)
+    END;
-        CallRTL(CODE._dllentry);
+    IF target = mConst.Target_iELF64 THEN
-        test(rax);
+        push(rsp)
-        jcc(je, dllret)
+    ELSE
-    END;
+        pushc(0)
     END;
-    push(rsp);
+    lea(rax, entry, sCODE);
+    push(rax);
+    pushDA(0); //TYPES
+    pushc(tcount);
+    pushDA(ModName_Offs); //MODNAME
+    CallRTL(IL._init);
+    IF target IN {mConst.Target_iConsole64, mConst.Target_iGUI64} THEN
+        L := NewLabel();
+        pushc(0);
+        push(rsp);
+        pushc(1024 * 1024 * stack_size);
+        pushc(0);
+        CallRTL(IL._new);
+        pop(rax);
-    lea(rax, entry, sCODE);
+        test(rax);
-    push(rax);
+        jcc(je, L);
-    pushDA(0); //TYPES
+        addrc(rax, 1024 * 1024 * stack_size - 8);
-    pushc(CHL.Length(code.types));
+        mov(rsp, rax);
-    pushDA(ModName_Offs); //MODNAME
+        X86.SetLabel(L)
-    CallRTL(CODE._init)
+    END
 END prolog;
-PROCEDURE epilog (code: CODE.CODES; modname: ARRAY OF CHAR; target: INTEGER);
+PROCEDURE epilog (code: IL.CODES; modname: ARRAY OF CHAR; target: INTEGER);
 VAR
     i, n: INTEGER;
     number: Number;
-    exp: CODE.EXPORT_PROC;
+    exp: IL.EXPORT_PROC;
     PROCEDURE import (imp: LISTS.LIST);
     VAR
-        lib:  CODE.IMPORT_LIB;
+        lib:  IL.IMPORT_LIB;
-        proc: CODE.IMPORT_PROC;
+        proc: IL.IMPORT_PROC;
     BEGIN
-        lib := imp.first(CODE.IMPORT_LIB);
+        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)
-            proc := lib.procs.first(CODE.IMPORT_PROC);
+        END
             WHILE proc # NIL DO
-                BIN.Import(prog, proc.name, proc.label);
+    END import;
                 proc := proc.next(CODE.IMPORT_PROC)
             END;
-            lib := lib.next(CODE.IMPORT_LIB)
+BEGIN
-        END
+    IF target = mConst.Target_iDLL64 THEN
         X86.SetLabel(dllret);
-    END import;
+        OutByte(0C3H) // ret
     ELSIF target = mConst.Target_iELFSO64 THEN
         sofinit := NewLabel();
     END;
     BIN.PutDataStr(prog, modname);
     BIN.PutData(prog, 0);
     n := CHL.Length(prog.data);
-    ASSERT(MACHINE.Align(n, 16));
+    ASSERT(UTILS.Align(n, 16));
     i := n - CHL.Length(prog.data);
     WHILE i > 0 DO
         BIN.PutData(prog, 0);
         DEC(i)
     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);
+    exp := code.export.first(IL.EXPORT_PROC);
     WHILE exp # NIL DO
         BIN.Export(prog, exp.name, exp.label);
-        exp := exp.next(CODE.EXPORT_PROC)
+        exp := exp.next(IL.EXPORT_PROC)
     END;
     |8: movmr(rbp, offs, reg)
     END
 END rsave;
-PROCEDURE CodeGen* (code: CODE.CODES; outname: ARRAY OF CHAR; target, stack, base: INTEGER);
+PROCEDURE CodeGen* (code: IL.CODES; outname: ARRAY OF CHAR; target: INTEGER; options: PROG.OPTIONS);
-VAR
-    path, modname, ext: PATHS.PATH;
+VAR
+    path, modname, ext: PATHS.PATH;
-    n: INTEGER;
+BEGIN
     tcount := CHL.Length(code.types);
 BEGIN
     Win64RegPar[0] := rcx;
     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)
+    REG.Init(R, push, pop, mov, xchg, rload, rsave, {rax, r10, r11}, {rcx, rdx, r8, r9});
     END;
-    code.bss := MAX(code.bss, 8);
+    code.bss := MAX(code.bss, MAX(code.dmin - CHL.Length(code.data), 8));
     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));
+    BIN.SetParams(prog, code.bss, 1, WCHR(1), WCHR(0));
     X86.SetProgram(prog);
-    prolog(code, modname, target, stack);
+    prolog(code, modname, target, options.stack);
-    translate(code.commands, CHL.Length(code.types) * 8);
+    translate(code.commands, tcount * 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)
+        PE32.write(prog, outname, options.base, target = mConst.Target_iConsole64, target = mConst.Target_iDLL64, TRUE)
-    ELSIF target = mConst.Target_iELF64 THEN
+    ELSIF target IN {mConst.Target_iELF64, mConst.Target_iELFSO64} THEN
-        ELF.write(prog, outname, TRUE)
+        ELF.write(prog, outname, sofinit, target = mConst.Target_iELFSO64, TRUE)

Subversion Repositories Kolibri OS

(root)/programs/develop/oberon07/Source/AMD64.ob07 – Rev 7667 → 7693