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

 (*
     BSD 2-Clause License
-    Copyright (c) 2018-2019, Anton Krotov
+    Copyright (c) 2018-2020, Anton Krotov
     All rights reserved.
 *)
 MODULE AMD64;
-IMPORT IL, BIN, WR := WRITER, CHL := CHUNKLISTS, LISTS, PATHS, PROG,
+IMPORT IL, BIN, WR := WRITER, CHL := CHUNKLISTS, LISTS, PATHS, PROG, TARGETS,
 END OutByte;
 PROCEDURE OutByte2 (a, b: BYTE);
 BEGIN
-    OutByte(a);
+    X86.OutByte(a);
-    OutByte(b)
+    X86.OutByte(b)
 END OutByte2;
 PROCEDURE OutByte3 (a, b, c: BYTE);
 BEGIN
-    OutByte(a);
+    X86.OutByte(a);
-    OutByte(b);
+    X86.OutByte(b);
-    OutByte(c)
+    X86.OutByte(c)
 END OutByte3;
 PROCEDURE OutInt (n: INTEGER);
 BEGIN
-    OutByte(UTILS.Byte(n, 0));
+    X86.OutByte(n MOD 256);
 PROCEDURE OutIntByte (n: INTEGER);
 BEGIN
     IF isByte(n) THEN
-        OutByte(UTILS.Byte(n, 0))
+        OutByte(n MOD 256)
     ELSE
         OutInt(n)
 PROCEDURE lea (reg, offset, section: INTEGER);
 BEGIN
     Rex(0, reg);
-    OutByte2(8DH, 05H + 8 * (reg MOD 8)); // lea reg, [rip + offset]
+    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
+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
+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
+PROCEDURE mov (reg1, reg2: INTEGER); (* mov reg1, reg2 *)
 BEGIN
     oprr(89H, reg1, reg2)
 END mov;
-PROCEDURE xor (reg1, reg2: INTEGER); // xor reg1, reg2
+PROCEDURE xor (reg1, reg2: INTEGER); (* xor reg1, reg2 *)
 BEGIN
     oprr(31H, reg1, reg2)
 END xor;
-PROCEDURE and (reg1, reg2: INTEGER); // and reg1, reg2
+PROCEDURE and (reg1, reg2: INTEGER); (* and reg1, reg2 *)
 BEGIN
     oprr(21H, reg1, reg2)
 END and;
-PROCEDURE or (reg1, reg2: INTEGER); // and reg1, reg2
+PROCEDURE or (reg1, reg2: INTEGER); (* or reg1, reg2 *)
 BEGIN
     oprr(09H, reg1, reg2)
 END or;
-PROCEDURE add (reg1, reg2: INTEGER); // add reg1, reg2
+PROCEDURE add (reg1, reg2: INTEGER); (* add reg1, reg2 *)
 BEGIN
     oprr(01H, reg1, reg2)
 END add;
-PROCEDURE sub (reg1, reg2: INTEGER); // sub reg1, reg2
+PROCEDURE sub (reg1, reg2: INTEGER); (* sub reg1, reg2 *)
 BEGIN
     oprr(29H, reg1, reg2)
 END sub;
-PROCEDURE xchg (reg1, reg2: INTEGER); // xchg reg1, reg2
+PROCEDURE xchg (reg1, reg2: INTEGER); (* xchg reg1, reg2 *)
 PROCEDURE decr (reg: INTEGER);
 BEGIN
     Rex(reg, 0);
-    OutByte2(0FFH, 0C8H + reg MOD 8) // dec reg1
+    OutByte2(0FFH, 0C8H + reg MOD 8) (* dec reg1 *)
 END decr;
 PROCEDURE incr (reg: INTEGER);
 BEGIN
     Rex(reg, 0);
     reg: INTEGER;
 BEGIN
     reg := GetAnyReg();
     lea(reg, label, sIMP);
-    IF reg >= 8 THEN // call qword[reg]
+    IF reg >= 8 THEN (* call qword[reg] *)
         OutByte(41H)
     END;
     OutByte2(0FFH, 10H + reg MOD 8);
     drop
 VAR
     i: INTEGER;
 BEGIN
     Rex(reg, 0);
-    OutByte(0B8H + reg MOD 8);  // movabs reg, n
+    OutByte(0B8H + reg MOD 8); (* movabs reg, n *)
     FOR i := 0 TO 7 DO
         OutByte(UTILS.Byte(n, i))
     END
 END movabs;
-PROCEDURE movrc (reg, n: INTEGER); // mov reg, n
+PROCEDURE movrc (reg, n: INTEGER); (* mov reg, n *)
 BEGIN
     IF isLong(n) THEN
         OutInt(n)
     END
 END movrc;
-PROCEDURE test (reg: INTEGER); // test reg, reg
+PROCEDURE test (reg: INTEGER); (* test reg, reg *)
 BEGIN
 VAR
     reg2: INTEGER;
 BEGIN
+    reg2 := GetAnyReg();
-    reg2 := GetAnyReg();
+    ASSERT(reg2 # reg);
     movabs(reg2, n);
     oprr(reg, reg2);
     drop
         OutIntByte(n)
     END
 END oprc;
+PROCEDURE cmprc (reg, n: INTEGER); (* cmp reg, n *)
+BEGIN
+    IF n = 0 THEN
-PROCEDURE cmprc (reg, n: INTEGER); // cmp reg, n
+        test(reg)
+    ELSE
-BEGIN
+        oprc(0F8H, reg, n, cmprr)
-    oprc(0F8H, reg, n, cmprr)
+    END
 END cmprc;
-PROCEDURE addrc (reg, n: INTEGER); // add reg, n
+PROCEDURE addrc (reg, n: INTEGER); (* add reg, n *)
 BEGIN
     oprc(0C0H, reg, n, add)
 END addrc;
-PROCEDURE subrc (reg, n: INTEGER); // sub reg, n
+PROCEDURE subrc (reg, n: INTEGER); (* sub reg, n *)
 BEGIN
+    oprc(0E8H, reg, n, sub)
+END subrc;
+PROCEDURE andrc (reg, n: INTEGER); (* and reg, n *)
+BEGIN
+    oprc(0E0H, reg, n, and)
+END andrc;
+PROCEDURE orrc (reg, n: INTEGER); (* or reg, n *)
+BEGIN
-    oprc(0E8H, reg, n, sub)
+    oprc(0C8H, reg, n, or)
-END subrc;
+END orrc;
         reg2 := GetAnyReg();
         movabs(reg2, n);
         push(reg2);
         drop
     ELSE
-        OutByte(68H + short(n)); OutIntByte(n) // push n
+        OutByte(68H + short(n)); OutIntByte(n) (* push n *)
     END
 END pushc;
-PROCEDURE not (reg: INTEGER); // not reg
+PROCEDURE not (reg: INTEGER); (* not reg *)
 BEGIN
     Rex(reg, 0);
     OutByte2(0F7H, 0D0H + reg MOD 8)
 END not;
-PROCEDURE neg (reg: INTEGER); // neg reg
+PROCEDURE neg (reg: INTEGER); (* neg reg *)
 BEGIN
-    Rex(reg, 0);
-    OutByte2(0F7H, 0D8H + reg MOD 8)
-END neg;
     Rex(reg, 0);
     OutByte2(0F7H, 0D8H + reg MOD 8)
-PROCEDURE movzx (reg1, reg2, offs: INTEGER; word: BOOLEAN);  // movzx reg1, byte/word[reg2 + offs]
+END neg;
-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
+PROCEDURE movzx (reg1, reg2, offs: INTEGER; word: BOOLEAN); (* movzx reg1, byte/word[reg2 + offs] *)
-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
+BEGIN
-        OutIntByte(offs)
+    Rex(reg2, reg1);
-    END
+    X86.movzx(reg1, reg2, offs, word)
-END _movrm;
+END movzx;
-PROCEDURE movmr32 (reg1, offs, reg2: INTEGER); // mov dword[reg1+offs], reg2_32
+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)
+    X86._movrm(reg2, reg1, offs, 32, TRUE)
-END movmr16;
+END movmr32;
-PROCEDURE movrm16 (reg1, reg2, offs: INTEGER); // mov reg1_16, word[reg2+offs]
+PROCEDURE movrm32 (reg1, reg2, offs: INTEGER); (* mov reg1_32, dword[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);
+    X86._movrm(reg1, reg2, offs, 32, FALSE)
-    IF (offs = 0) & (reg # rbp) THEN
+END movrm32;
         b := 30H
     ELSE
-        b := 70H + long(offs)
+PROCEDURE movmr (reg1, offs, reg2: INTEGER); (* mov qword[reg1+offs], reg2 *)
-    END;
+BEGIN
         OutIntByte(offs)
     END
 END _movsdrm;
-PROCEDURE movsdrm (xmm, reg, offs: INTEGER); // movsd xmm, qword[reg+offs]
+PROCEDURE movsdrm (xmm, reg, offs: INTEGER); (* movsd xmm, qword[reg+offs] *)
 BEGIN
     _movsdrm(xmm, reg, offs, FALSE)
 END movsdrm;
     END;
     OutByte3(0FH, op, 0C0H + (xmm1 MOD 8) * 8 + xmm2 MOD 8)
 END opxx;
-PROCEDURE jcc (cc, label: INTEGER); // jcc label
+PROCEDURE jcc (cc, label: INTEGER); (* jcc label *)
 BEGIN
     X86.jcc(cc, label)
 END jcc;
-PROCEDURE jmp (label: INTEGER); // jmp label
+PROCEDURE jmp (label: INTEGER); (* jmp label *)
 BEGIN
     X86.jmp(label)
 END jmp;
     variables:  LISTS.LIST;
     lvar, rvar: IL.LOCALVAR;
     reg:        INTEGER;
     max:        INTEGER;
     loop:       INTEGER;
-    param2:     INTEGER;
 BEGIN
     loop := 1;
     variables := cmd.variables;
          IL.opDIVL, IL.opMOD,
          IL.opMODL, IL.opLENGTH, IL.opLENGTHW:
             leaf := FALSE
-        |IL.opDIVR, IL.opMODR:
-            param2 := cur.param2;
-            IF param2 >= 1 THEN
-                param2 := UTILS.Log2(param2)
-            ELSIF param2 <= -1 THEN
+        |IL.opDIVR, IL.opMODR:
-                param2 := UTILS.Log2(-param2)
-            ELSE
-                param2 := -1
-            END;
-            IF param2 < 0 THEN
-                leaf := FALSE
-            END
+            leaf := UTILS.Log2(cur.param2) >= 0
         ELSE
     |IL.opGEF:
         comisd(xmm - 1, xmm);
         cc := setnc
     END;
-    OutByte2(7AH, 3 + reg DIV 8); // jp L
+    OutByte2(7AH, 3 + reg DIV 8); (* jp L *)
     setcc(cc, reg);
-    //L:
+    (* L: *)
 END fcmp;
             CASE opcode OF
             |IL.opCALLP:
             |IL.opWIN64CALLP: Win64Passing(param2)
             |IL.opSYSVCALLP:  SysVPassing(param2)
             END;
-            OutByte2(0FFH, 0D0H); // call rax
+            OutByte2(0FFH, 0D0H); (* call rax *)
             REG.Restore(R);
             ASSERT(R.top = -1)
         |IL.opCALLI, IL.opWIN64CALLI, IL.opSYSVCALLI:
             X86.SetLabel(param1)
         |IL.opERR:
+            CallRTL(IL._error)
+        |IL.opONERR:
+            pushc(param2);
-            CallRTL(IL._error)
+            jmp(param1)
         |IL.opPUSHC:
             pushc(param2)
             END;
             n := param2;
             IF n > 4 THEN
                 movrc(rcx, n);
-                                      // L:
+                                     (* L: *)
                 pushc(0);
-                OutByte2(0E2H, 0FCH) // loop L
+                OutByte2(0E2H, 0FCH) (* loop L *)
             ELSE
                 WHILE n > 0 DO
                     pushc(0);
                     DEC(n)
                 mov(rsp, rbp)
             END;
             pop(rbp);
             IF param2 > 0 THEN
-                OutByte3(0C2H, (param2 * 8) MOD 256, (param2 * 8) DIV 256)  // ret param2
+                OutByte3(0C2H, (param2 * 8) MOD 256, (param2 * 8) DIV 256) (* ret param2 *)
             ELSE
-                OutByte(0C3H) // ret
+                X86.ret
             END;
             REG.Reset(R)
             drop
         |IL.opLADR:
             n := param2 * 8;
             next := cmd.next(COMMAND);
-            IF next.opcode = IL.opSAVEF THEN
+            IF (next.opcode = IL.opSAVEF) OR (next.opcode = IL.opSAVEFI) THEN
                 movsdmr(rbp, n, xmm);
                 DEC(xmm);
                 cmd := next
             ELSIF next.opcode = IL.opLOADF THEN
                 INC(xmm);
                 movsdrm(xmm, rbp, n);
                 cmd := next
             ELSE
                 reg1 := GetAnyReg();
                 Rex(0, reg1);
-                OutByte2(8DH, 45H + long(n) + (reg1 MOD 8) * 8);  // lea reg1, qword[rbp+n]
+                OutByte2(8DH, 45H + long(n) + (reg1 MOD 8) * 8); (* lea reg1, qword[rbp+n] *)
                 OutIntByte(n)
             END
         |IL.opSAVE8C:
             UnOp(reg1);
             IF reg1 >= 8 THEN
                 OutByte(41H)
             END;
-            OutByte3(0C6H, reg1 MOD 8, param2); // mov byte[reg1], param2
+            OutByte3(0C6H, reg1 MOD 8, param2); (* mov byte[reg1], param2 *)
             drop
         |IL.opSAVE16C:
             UnOp(reg1);
             OutByte(66H);
             IF reg1 >= 8 THEN
                 OutByte(41H)
             END;
             OutByte2(0C7H, reg1 MOD 8);
-            OutByte2(param2 MOD 256, param2 DIV 256); // mov word[reg1], param2
+            OutByte2(param2 MOD 256, param2 DIV 256); (* mov word[reg1], param2 *)
             drop
         |IL.opSAVEC:
                 movrc(reg2, param2);
                 movmr(reg1, 0, reg2);
                 drop
             ELSE
                 Rex(reg1, 0);
-                OutByte2(0C7H, reg1 MOD 8); // mov qword[reg1], param2
+                OutByte2(0C7H, reg1 MOD 8); (* mov qword[reg1], param2 *)
                 OutInt(param2)
             END;
             drop
             GetRegA
         |IL.opINCL, IL.opEXCL:
             BinOp(reg1, reg2);
             cmprc(reg1, 64);
-            OutByte2(73H, 04H); // jnb L
+            OutByte2(73H, 04H); (* jnb L *)
             Rex(reg2, reg1);
-            OutByte3(0FH, 0ABH + 8 * ORD(opcode = IL.opEXCL), 8 * (reg1 MOD 8) + reg2 MOD 8); // bts/btr qword[reg2], reg1
+            OutByte3(0FH, 0ABH + 8 * ORD(opcode = IL.opEXCL), 8 * (reg1 MOD 8) + reg2 MOD 8); (* bts/btr qword[reg2], reg1 *)
-            // L:
+            (* L: *)
             drop;
             drop
         |IL.opINCLC, IL.opEXCLC:
             UnOp(reg1);
             Rex(reg1, 0);
-            OutByte2(0FH, 0BAH);  // bts/btr qword[reg1], param2
+            OutByte2(0FH, 0BAH); (* bts/btr qword[reg1], param2 *)
             OutByte2(28H + 8 * ORD(opcode = IL.opEXCLC) + reg1 MOD 8, param2);
             drop
                 BinOp(reg1, reg2);
                 cmprr(reg1, reg2);
                 drop
             ELSE
                 UnOp(reg1);
-                IF param2 = 0 THEN
-                    test(reg1)
-                ELSE
-                    cmprc(reg1, param2)
+                cmprc(reg1, param2)
-                END
             END;
             drop;
             cc := X86.cond(opcode);
-            IF cmd.next(COMMAND).opcode = IL.opJE THEN
+            next := cmd.next(COMMAND);
-                label := cmd.next(COMMAND).param1;
+            IF next.opcode = IL.opJE THEN
-                jcc(cc, label);
-                cmd := cmd.next(COMMAND)
+                jcc(cc, next.param1);
-            ELSIF cmd.next(COMMAND).opcode = IL.opJNE THEN
+                cmd := next
-                label := cmd.next(COMMAND).param1;
+            ELSIF next.opcode = IL.opJNE THEN
-                jcc(X86.inv0(cc), label);
-                cmd := cmd.next(COMMAND)
+                jcc(X86.inv0(cc), next.param1);
                 cmd := next
             ELSE
                 reg1 := GetAnyReg();
                 setcc(cc + 16, reg1);
         |IL.opJZ:
             UnOp(reg1);
             test(reg1);
             jcc(je, param1)
+        |IL.opJG:
+            UnOp(reg1);
+            test(reg1);
+            jcc(jg, param1)
         |IL.opJE:
             UnOp(reg1);
             test(reg1);
             jcc(jne, param1);
             UnOp(reg1);
             test(reg1);
             jcc(je, param1);
             drop
+        |IL.opIN, IL.opINR:
+            IF opcode = IL.opINR THEN
+                reg2 := GetAnyReg();
+                movrc(reg2, param2)
-        |IL.opIN:
+            END;
             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
-        |IL.opINR:
-            label := NewLabel();
-            L := NewLabel();
-            UnOp(reg1);
-            reg2 := GetAnyReg();
-            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
+            OutByte3(0FH, 0A3H, 0C0H + 8 * (reg1 MOD 8) + reg2 MOD 8); (* bt reg2, reg1 *)
             setcc(setc, reg1);
             andrc(reg1, 1);
             X86.SetLabel(label);
             drop
         |IL.opINL:
             UnOp(reg1);
             Rex(reg1, 0);
-            OutByte2(0FH, 0BAH);  // bt reg1, param2
+            OutByte2(0FH, 0BAH); (* bt reg1, param2 *)
             OutByte2(0E0H + reg1 MOD 8, param2);
             setcc(setc, reg1);
             andrc(reg1, 1)
         |IL.opABS:
             UnOp(reg1);
             test(reg1);
-            OutByte2(7DH, 03H); // jge L
+            OutByte2(7DH, 03H); (* jge L *)
             neg(reg1)
-            // L:
+            (* L: *)
         |IL.opEQB, IL.opNEB:
             BinOp(reg1, reg2);
         |IL.opMULSC:
             UnOp(reg1);
             andrc(reg1, param2)
-        |IL.opDIVSC, IL.opADDSL, IL.opADDSR:
+        |IL.opDIVSC:
+            UnOp(reg1);
-            UnOp(reg1);
+            xorrc(reg1, param2)
-            Rex(reg1, 0);
+        |IL.opADDSL, IL.opADDSR:
-            OutByte2(81H + short(param2), 0C8H + 28H * ORD(opcode = IL.opDIVSC) + reg1 MOD 8); // or/xor reg1, param2
+            UnOp(reg1);
-            OutIntByte(param2)
+            orrc(reg1, param2)
         |IL.opSUBSL:
             GetRegA
         |IL.opTYPEGD:
             UnOp(reg1);
             PushAll(0);
-            pushm(reg1, -8);
+            X86.pushm(reg1, -8);
             pushc(param2 * tcount);
             CallRTL(IL._guardrec);
             GetRegA
         |IL.opPUSHP:
             lea(GetAnyReg(), param2, sCODE)
         |IL.opINC, IL.opDEC:
             BinOp(reg1, reg2);
-            // add/sub qword[reg2], reg1
+            (* add/sub qword[reg2], reg1 *)
             Rex(reg2, reg1);
             OutByte2(01H + 28H * ORD(opcode = IL.opDEC), reg2 MOD 8 + (reg1 MOD 8) * 8);
             drop;
             drop
         |IL.opINCC:
             UnOp(reg1);
             IF isLong(param2) THEN
                 reg2 := GetAnyReg();
                 movrc(reg2, param2);
-                // add qword[reg1], reg2
+                (* add qword[reg1], reg2 *)
                 Rex(reg1, reg2);
                 OutByte2(01H, reg1 MOD 8 + (reg2 MOD 8) * 8);
                 drop
             ELSIF ABS(param2) = 1 THEN
                 Rex(reg1, 0);
-                OutByte2(0FFH, reg1 MOD 8 + 8 * ORD(param2 = -1)) // inc/dec qword[reg1]
+                OutByte2(0FFH, reg1 MOD 8 + 8 * ORD(param2 = -1)) (* inc/dec qword[reg1] *)
             ELSE
-                // add qword[reg1], param2
+                (* add qword[reg1], param2 *)
                 Rex(reg1, 0);
                 OutByte2(81H + short(param2), reg1 MOD 8);
                 OutIntByte(param2)
             drop;
             drop
         |IL.opSAVE8:
             BinOp(reg2, reg1);
-            movmr8(reg1, 0, reg2);
+            X86.movmr8(reg1, 0, reg2);
             drop;
             drop
         |IL.opSAVE16:
             BinOp(reg2, reg1);
-            movmr16(reg1, 0, reg2);
+            X86.movmr16(reg1, 0, reg2);
             drop;
             drop
         |IL.opSAVE32:
             BinOp(reg2, reg1);
             movmr32(reg1, 0, reg2);
             drop;
             drop
-        |IL.opMIN:
+        |IL.opMAX, IL.opMIN:
             BinOp(reg1, reg2);
             cmprr(reg1, reg2);
-            OutByte2(7EH, 3); // jle L
-            mov(reg1, reg2);
-            // L:
-            drop
-        |IL.opMAX:
-            BinOp(reg1, reg2);
-            cmprr(reg1, reg2);
-            OutByte2(7DH, 3);  // jge L
+            OutByte2(7DH + ORD(opcode = IL.opMIN), 3); (* jge/jle L *)
-            mov(reg1, reg2);
-            // L:
-            drop
-        |IL.opMINC:
-            UnOp(reg1);
-            cmprc(reg1, param2);
-            label := NewLabel();
-            jcc(jle, label);
+            mov(reg1, reg2);
-            movrc(reg1, param2);
+            (* L: *)
-            X86.SetLabel(label)
+            drop
+        |IL.opMAXC, IL.opMINC:
+            UnOp(reg1);
+            cmprc(reg1, param2);
+            label := NewLabel();
+            IF opcode = IL.opMINC THEN
-        |IL.opMAXC:
+                cc := jle
-            UnOp(reg1);
+            ELSE
-            cmprc(reg1, param2);
+                cc := jge
-            label := NewLabel();
+            END;
-            jcc(jge, label);
+            jcc(cc, label);
             movrc(reg1, param2);
             X86.SetLabel(label)
         |IL.opSBOOL:
             BinOp(reg2, reg1);
             test(reg2);
             IF reg1 >= 8 THEN
                 OutByte(41H)
             END;
-            OutByte3(0FH, 95H, reg1 MOD 8); // setne byte[reg1]
+            OutByte3(0FH, 95H, reg1 MOD 8); (* setne byte[reg1] *)
             drop;
             drop
-        |IL.opSBOOLC:
-            UnOp(reg1);
-            IF reg1 >= 8 THEN
-                OutByte(41H)
-            END;
+        |IL.opSBOOLC:
-            OutByte3(0C6H, reg1 MOD 8, ORD(param2 # 0)); // mov byte[reg1], 0/1
+            UnOp(reg1);
-            drop
+            IF reg1 >= 8 THEN
                 OutByte(41H)
             IF opcode = IL.opSUBL THEN
                 neg(reg1)
             END
         |IL.opADDL, IL.opADDR:
-            IF param2 # 0 THEN
+            IF (param2 # 0) & ~isLong(param2) THEN
+                UnOp(reg1);
+                next := cmd.next(COMMAND);
+                CASE next.opcode OF
+                |IL.opLOAD64:
+                    movrm(reg1, reg1, param2);
+                    cmd := next
+                |IL.opLOAD32:
+                    movrm32(reg1, reg1, param2);
+                    shiftrc(shl, reg1, 32);
+                    shiftrc(shr, reg1, 32);
+                    cmd := next
+                |IL.opLOAD16:
+                    movzx(reg1, reg1, param2, TRUE);
+                    cmd := next
+                |IL.opLOAD8:
+                    movzx(reg1, reg1, param2, FALSE);
+                    cmd := next
+                |IL.opLOAD64_PARAM:
+                    X86.pushm(reg1, param2);
+                    drop;
+                    cmd := next
-                UnOp(reg1);
+                ELSE
-                IF param2 = 1 THEN
+                    IF param2 = 1 THEN
-                    incr(reg1)
+                        incr(reg1)
-                ELSIF param2 = -1 THEN
+                    ELSIF param2 = -1 THEN
-                    decr(reg1)
+                        decr(reg1)
-                ELSE
+                    ELSE
-                    addrc(reg1, param2)
+                        addrc(reg1, param2)
-                END
+                    END
+                END
+            ELSIF isLong(param2) THEN
+                addrc(reg1, param2)
             END
         |IL.opDIV:
             PushAll(2);
             CallRTL(IL._divmod);
-            GetRegA
-        |IL.opDIVR:
-            a := param2;
-            IF a > 1 THEN
+            GetRegA
-                n := UTILS.Log2(a)
-            ELSIF a < -1 THEN
-                n := UTILS.Log2(-a)
-            ELSE
-                n := -1
-            END;
-            IF a = 1 THEN
-            ELSIF a = -1 THEN
                 UnOp(reg1);
-                neg(reg1)
+        |IL.opDIVR:
-            ELSE
-                IF n > 0 THEN
-                    UnOp(reg1);
-                    IF a < 0 THEN
-                        reg2 := GetAnyReg();
-                        mov(reg2, reg1);
-                        shiftrc(sar, reg1, n);
-                        sub(reg1, reg2);
+            n := UTILS.Log2(param2);
-                        drop
+            IF n > 0 THEN
-                    ELSE
-                        shiftrc(sar, reg1, n)
-                    END
+                UnOp(reg1);
                 shiftrc(sar, reg1, n)
-                ELSE
+            ELSIF n < 0 THEN
-                    PushAll(1);
+                PushAll(1);
-                    pushc(param2);
+                pushc(param2);
-                    CallRTL(IL._divmod);
-                    GetRegA
+                CallRTL(IL._divmod);
-                END
+                GetRegA
             END
             CallRTL(IL._divmod);
             mov(rax, rdx);
             GetRegA
-        |IL.opMODR:
-            a := param2;
-            IF a > 1 THEN
-                n := UTILS.Log2(a)
-            ELSIF a < -1 THEN
+        |IL.opMODR:
-                n := UTILS.Log2(-a)
-            ELSE
-                n := -1
-            END;
-            IF ABS(a) = 1 THEN
-                UnOp(reg1);
-                xor(reg1, reg1)
-            ELSE
+            n := UTILS.Log2(param2);
-                IF n > 0 THEN
+            IF n > 0 THEN
-                    UnOp(reg1);
+                UnOp(reg1);
-                    andrc(reg1, ABS(a) - 1);
+                andrc(reg1, param2 - 1);
-                    IF a < 0 THEN
-                        test(reg1);
-                        label := NewLabel();
-                        jcc(je, label);
-                        addrc(reg1, a);
-                        X86.SetLabel(label)
-                    END
-                ELSE
+            ELSIF n < 0 THEN
-                    PushAll(1);
+                PushAll(1);
-                    pushc(param2);
+                pushc(param2);
-                    CallRTL(IL._divmod);
+                CallRTL(IL._divmod);
-                    mov(rax, rdx);
+                mov(rax, rdx);
-                    GetRegA
+                GetRegA
+            ELSE
+                UnOp(reg1);
-                END
+                xor(reg1, reg1)
             END
         |IL.opMODL:
             mov(rax, rdx);
             GetRegA
         |IL.opMUL:
             BinOp(reg1, reg2);
-            oprr2(0FH, 0AFH, reg2, reg1); // imul reg1, reg2
+            oprr2(0FH, 0AFH, reg2, reg1); (* imul reg1, reg2 *)
             drop
+        |IL.opMULC:
+            IF (cmd.next(COMMAND).opcode = IL.opADD) & ((param2 = 2) OR (param2 = 4) OR (param2 = 8)) THEN
+                BinOp(reg1, reg2);
+                OutByte2(48H + 5 * (reg1 DIV 8) + 2 * (reg2 DIV 8), 8DH); (* lea reg1, [reg1 + reg2 * param2] *)
+                reg1 := reg1 MOD 8;
+                reg2 := reg2 MOD 8;
+                OutByte2(04H + reg1 * 8, reg1 + reg2 * 8 + 40H * UTILS.Log2(param2));
+                drop;
                 cmd := cmd.next(COMMAND)
-        |IL.opMULC:
+            ELSE
-            UnOp(reg1);
+                UnOp(reg1);
-                    IF a < 0 THEN
+                        IF a < 0 THEN
-                        neg(reg1)
+                            neg(reg1)
-                    END;
+                        END;
-                    shiftrc(shl, reg1, n)
+                        shiftrc(shl, reg1, n)
-                ELSE
+                    ELSE
+                        IF isLong(a) THEN
+                            reg2 := GetAnyReg();
+                            movabs(reg2, a);
+                            ASSERT(reg1 # reg2);
+                            oprr2(0FH, 0AFH, reg2, reg1); (* imul reg1, reg2 *)
+                            drop
+                        ELSE
-                    // imul reg1, a
+                            (* imul reg1, a *)
-                    Rex(reg1, reg1);
+                            Rex(reg1, reg1);
-                    OutByte2(69H + short(a), 0C0H + (reg1 MOD 8) * 9);
+                            OutByte2(69H + short(a), 0C0H + (reg1 MOD 8) * 9);
-                    OutIntByte(a)
+                            OutIntByte(a)
-                END
+                        END
-            END
+                    END
+                END
+            END
         |IL.opADDS:
             BinOp(reg1, reg2);
             or(reg1, reg2);
             drop
         |IL.opENDSW:
         |IL.opCASEL:
-        |IL.opCASEL:
+            GetRegA;
+            cmprc(rax, param1);
-            cmprc(rax, param1);
+            jcc(jl, param2);
+            drop
             jcc(jl, param2)
+        |IL.opCASER:
+            GetRegA;
-        |IL.opCASER:
+            cmprc(rax, param1);
+            jcc(jg, param2);
-            cmprc(rax, param1);
+            drop
             jcc(jg, param2)
+        |IL.opCASELR:
+            GetRegA;
-        |IL.opCASELR:
+            cmprc(rax, param1);
-            cmprc(rax, param1);
+            jcc(jl, param2);
-            jcc(jl, param2);
+            jcc(jg, cmd.param3);
-            jcc(jg, cmd.param3)
+            drop
         |IL.opASR, IL.opROR, IL.opLSL, IL.opLSR:
             BinOp(reg1, reg2);
             xchg(reg2, rcx);
             Rex(reg1, 0);
             OutByte(0D3H);
-            X86.shift(opcode, reg1 MOD 8); // shift reg1, cl
+            X86.shift(opcode, reg1 MOD 8); (* shift reg1, cl *)
             xchg(reg2, rcx);
             drop
         |IL.opASR1, IL.opROR1, IL.opLSL1, IL.opLSR1:
             reg1 := GetAnyReg();
             movrc(reg1, param2);
             BinOp(reg1, reg2);
             xchg(reg1, rcx);
             Rex(reg2, 0);
                 reg1 := GetAnyReg();
                 movrc(reg1, param1)
             END;
             drop;
             drop;
-            _movrm(reg1, reg1, 0, param2 * 8, FALSE);
+            X86._movrm(reg1, reg1, 0, param2 * 8, FALSE);
-            _movrm(reg1, reg2, 0, param2 * 8, TRUE)
+            X86._movrm(reg1, reg2, 0, param2 * 8, TRUE)
         |IL.opCHKBYTE:
             BinOp(reg1, reg2);
             cmprc(reg1, 256);
         |IL.opCHKIDX2:
             BinOp(reg1, reg2);
             IF param2 # -1 THEN
-                cmprr(reg2, reg1);
-                mov(reg1, reg2);
-                drop;
+                cmprr(reg2, reg1);
-                jcc(jb, param1)
+                jcc(jb, param1);
-            ELSE
+            END;
-                INCL(R.regs, reg1);
+            INCL(R.regs, reg1);
-                DEC(R.top);
+            DEC(R.top);
-                R.stk[R.top] := reg2
-            END
+            R.stk[R.top] := reg2
         |IL.opLENGTH:
             PushAll(2);
         |IL.opINCCB, IL.opDECCB:
             UnOp(reg1);
             IF reg1 >= 8 THEN
                 OutByte(41H)
             END;
-            OutByte3(80H, 28H * ORD(opcode = IL.opDECCB) + reg1 MOD 8, param2 MOD 256); // add/sub byte[reg1], param2 MOD 256
+            OutByte3(80H, 28H * ORD(opcode = IL.opDECCB) + reg1 MOD 8, param2 MOD 256); (* add/sub byte[reg1], param2 MOD 256 *)
             drop
         |IL.opINCB, IL.opDECB:
             BinOp(reg1, reg2);
             IF (reg1 >= 8) OR (reg2 >= 8) THEN
                 OutByte(40H + reg2 DIV 8 + 4 * (reg1 DIV 8))
             END;
-            OutByte2(28H * ORD(opcode = IL.opDECB), reg2 MOD 8 + 8 * (reg1 MOD 8)); // add/sub byte[reg2], reg1_8
+            OutByte2(28H * ORD(opcode = IL.opDECB), reg2 MOD 8 + 8 * (reg1 MOD 8)); (* add/sub byte[reg2], reg1_8 *)
             drop;
             drop
             push(reg2);
             drop;
             IF reg1 >= 8 THEN
                 OutByte(41H)
             END;
-            OutByte2(8FH, reg1 MOD 8); // pop qword[reg1]
+            OutByte2(8FH, reg1 MOD 8); (* pop qword[reg1] *)
             drop
         |IL.opCLEANUP:
             n := param2 * 8;
             lea(reg1, Numbers_Offs + Numbers_Count * 8, sDATA);
             movsdrm(xmm, reg1, 0);
             drop;
             NewNumber(UTILS.splitf(float, a, b))
-        |IL.opSAVEF:
+        |IL.opSAVEF, IL.opSAVEFI:
             UnOp(reg1);
             movsdmr(reg1, 0, xmm);
             DEC(xmm);
             DEC(xmm)
         |IL.opUMINF:
             reg1 := GetAnyReg();
             lea(reg1, Numbers_Offs, sDATA);
-            OutByte3(66H, 40H + reg1 DIV 8 + (xmm DIV 8) * 4, 0FH); // xorpd xmm, xmmword[reg1]
+            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
         |IL.opFABS:
             reg1 := GetAnyReg();
             lea(reg1, Numbers_Offs + 16, sDATA);
-            OutByte3(66H, 40H + reg1 DIV 8 + (xmm DIV 8) * 4, 0FH); // andpd xmm, xmmword[reg1]
+            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
         |IL.opFLT:
             UnOp(reg1);
             INC(xmm);
-            OutByte(0F2H); Rex(reg1, xmm); OutByte(0FH); // cvtsi2sd xmm, reg1
+            OutByte(0F2H); Rex(reg1, xmm); OutByte(0FH); (* cvtsi2sd xmm, reg1 *)
             OutByte2(2AH, 0C0H + (xmm MOD 8) * 8 + reg1 MOD 8);
             drop
         |IL.opFLOOR:
             reg1 := GetAnyReg();
             subrc(rsp, 8);
-            OutByte3(00FH, 0AEH, 05CH); OutByte2(024H, 004H); // stmxcsr dword[rsp+4];
+            OutByte3(00FH, 0AEH, 05CH); OutByte2(024H, 004H);                       (* stmxcsr dword[rsp+4];                              *)
-            OutByte2(00FH, 0AEH); OutByte2(01CH, 024H);       // stmxcsr dword[rsp];
+            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, 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;
+            OutByte3(081H, 00CH, 024H); OutByte2(000H, 020H); OutByte2(000H, 000H); (* or dword[rsp],00000000000000000010000000000000b;   *)
-            OutByte2(00FH, 0AEH); OutByte2(014H, 024H); // ldmxcsr dword[rsp];
+            OutByte2(00FH, 0AEH); OutByte2(014H, 024H);                             (* ldmxcsr dword[rsp];                                *)
-            OutByte(0F2H); Rex(xmm, reg1); OutByte(0FH); // cvtsd2si reg1, xmm
+            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];
+            OutByte3(00FH, 0AEH, 054H); OutByte2(024H, 004H);                       (* ldmxcsr dword[rsp+4];                              *)
             shiftrc(shl, reg1, 52);
             movrm(reg2, rsp, 0);
             movrm(reg2, reg2, 0);
             push(reg1);
-            lea(reg1, Numbers_Offs + 40, sDATA); // {0..51, 63}
+            lea(reg1, Numbers_Offs + 40, sDATA); (* {0..51, 63} *)
             movrm(reg1, reg1, 0);
             and(reg2, reg1);
             pop(reg1);
                 reg2 := GetVarReg(param2);
                 regVar := reg2 # -1;
                 IF ~regVar THEN
                     reg2 := GetAnyReg();
                     Rex(0, reg2);
-                    OutByte2(8DH, 45H + long(n) + (reg2 MOD 8) * 8);  // lea reg2, qword[rbp+n]
+                    OutByte2(8DH, 45H + long(n) + (reg2 MOD 8) * 8); (* lea reg2, qword[rbp+n] *)
                     OutIntByte(n)
                 END
             ELSE
                 BinOp(reg1, reg2);
                 regVar := FALSE
             pop(reg2);
             movrm(reg1, reg2, 0);
             push(reg2);
-            lea(reg2, Numbers_Offs + 48, sDATA); // {52..61}
+            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
+            OutByte2(0F0H + reg1 MOD 8, 3EH); (* btr reg1, 62 *)
             movmr(reg2, 0, reg1);
             drop;
             drop
         |IL.opSADR_PARAM:
             pushDA(stroffs + param2)
         |IL.opVADR_PARAM:
-            pushm(rbp, param2 * 8)
+            X86.pushm(rbp, param2 * 8)
         |IL.opLOAD64_PARAM:
             UnOp(reg1);
-            pushm(reg1, 0);
+            X86.pushm(reg1, 0);
             drop
         |IL.opLLOAD64_PARAM:
             reg1 := GetVarReg(param2);
             IF reg1 # -1 THEN
                     reg2 := GetAnyReg();
                     movrc(reg2, param2);
                     movmr(rbp, n, reg2);
                     drop
                 ELSE
-                    OutByte3(48H, 0C7H, 45H + long(n)); // mov qword[rbp+n],param2
+                    OutByte3(48H, 0C7H, 45H + long(n)); (* mov qword[rbp+n], param2 *)
                     OutIntByte(n);
                     OutInt(param2)
                 END
             END
                 drop
             ELSE
                 reg2 := GetAnyReg();
                 lea(reg2, param1, sBSS);
                 Rex(reg2, 0);
-                OutByte2(0C7H, reg2 MOD 8); // mov qword[reg2], param2
+                OutByte2(0C7H, reg2 MOD 8); (* mov qword[reg2], param2 *)
                 OutInt(param2);
                 drop
             END
                     add(reg1, reg2)
                 ELSE
                     n := param1 * 8;
                     Rex(0, reg2);
                     OutByte2(01H, 45H + long(n) + (reg2 MOD 8) * 8);
-                    OutIntByte(n) // add qword[rbp+n],reg2
+                    OutIntByte(n) (* add qword[rbp+n], reg2 *)
                 END;
                 drop
             ELSIF ABS(param2) = 1 THEN
                 IF reg1 # -1 THEN
                     IF param2 = 1 THEN
                     ELSE
                         decr(reg1)
                     END
                 ELSE
                     n := param1 * 8;
-                    OutByte3(48H, 0FFH, 45H + 8 * ORD(param2 = -1) + long(n)); // inc/dec qword[rbp+n]
+                    OutByte3(48H, 0FFH, 45H + 8 * ORD(param2 = -1) + long(n)); (* inc/dec qword[rbp+n] *)
                     OutIntByte(n)
                 END
             ELSE
                 IF reg1 # -1 THEN
                     addrc(reg1, param2)
                 ELSE
                     n := param1 * 8;
                     OutByte3(48H, 81H + short(param2), 45H + long(n));
                     OutIntByte(n);
-                    OutIntByte(param2) // add qword[rbp+n],param2
+                    OutIntByte(param2) (* add qword[rbp+n], param2 *)
                 END
             END
         |IL.opLADR_INCCB, IL.opLADR_DECCB:
                 andrc(reg1, 255)
             ELSE
                 n := param1 * 8;
                 OutByte2(80H, 45H + long(n) + 28H * ORD(opcode = IL.opLADR_DECCB));
                 OutIntByte(n);
-                OutByte(param2) // add/sub byte[rbp+n],param2
+                OutByte(param2) (* add/sub byte[rbp+n], param2 *)
             END
         |IL.opLADR_INC, IL.opLADR_DEC:
             UnOp(reg1);
                 END
             ELSE
                 n := param2 * 8;
                 Rex(0, reg1);
                 OutByte2(01H + 28H * ORD(opcode = IL.opLADR_DEC), 45H + long(n) + (reg1 MOD 8) * 8);
-                OutIntByte(n) // add/sub qword[rbp+n],reg1
+                OutIntByte(n) (* add/sub qword[rbp+n], reg1 *)
             END;
             drop
         |IL.opLADR_INCB, IL.opLADR_DECB:
                 n := param2 * 8;
                 IF reg1 >= 8 THEN
                     OutByte(44H)
                 END;
                 OutByte2(28H * ORD(opcode = IL.opLADR_DECB), 45H + long(n) + 8 * (reg1 MOD 8));
-                OutIntByte(n) // add/sub byte[rbp+n], reg1_8
+                OutIntByte(n) (* add/sub byte[rbp+n], reg1_8 *)
             END;
             drop
         |IL.opLADR_INCL, IL.opLADR_EXCL:
             UnOp(reg1);
             cmprc(reg1, 64);
             reg2 := GetVarReg(param2);
             IF reg2 # -1 THEN
-                OutByte2(73H, 4); // jnb L
+                OutByte2(73H, 4); (* jnb L *)
-                oprr2(0FH, 0ABH + 8 * ORD(opcode = IL.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
+                OutByte2(73H, 5 + 3 * ORD(~isByte(n))); (* jnb L *)
                 Rex(0, reg1);
                 OutByte3(0FH, 0ABH + 8 * ORD(opcode = IL.opLADR_EXCL), 45H + long(n) + 8 * (reg1 MOD 8));
-                OutIntByte(n) // bts/btr qword[rbp+n], reg1
+                OutIntByte(n) (* bts/btr qword[rbp+n], reg1 *)
             END;
-            // L:
+            (* L: *)
             drop
         |IL.opLADR_INCLC, IL.opLADR_EXCLC:
             reg1 := GetVarReg(param1);
             IF reg1 # -1 THEN
                 Rex(reg1, 0);
-                OutByte3(0FH, 0BAH, 0E8H);  // bts/btr reg1, param2
+                OutByte3(0FH, 0BAH, 0E8H); (* bts/btr reg1, param2 *)
                 OutByte2(reg1 MOD 8 + 8 * ORD(opcode = IL.opLADR_EXCLC), param2)
             ELSE
                 n := param1 * 8;
-                OutByte3(48H, 0FH, 0BAH);  // bts/btr qword[rbp+n], param2
+                OutByte3(48H, 0FH, 0BAH); (* bts/btr qword[rbp+n], param2 *)
                 OutByte(6DH + long(n) + 8 * ORD(opcode = IL.opLADR_EXCLC));
                 OutIntByte(n);
     ASSERT(UTILS.Align(Numbers_Offs, 16));
     entry := NewLabel();
     X86.SetLabel(entry);
-    IF target = mConst.Target_iDLL64 THEN
+    IF target = TARGETS.Win64DLL THEN
         dllret := NewLabel();
         push(r8);
         push(rdx);
         push(rcx);
         CallRTL(IL._dllentry);
         test(rax);
         jcc(je, dllret)
     END;
-    IF target = mConst.Target_iELF64 THEN
+    IF target = TARGETS.Linux64 THEN
         push(rsp)
     ELSE
         pushc(0)
     END;
     lea(rax, entry, sCODE);
     push(rax);
-    pushDA(0); //TYPES
+    pushDA(0); (* TYPES *)
     pushc(tcount);
-    pushDA(ModName_Offs); //MODNAME
+    pushDA(ModName_Offs); (* MODNAME *)
     CallRTL(IL._init);
-    IF target IN {mConst.Target_iConsole64, mConst.Target_iGUI64, mConst.Target_iELF64} THEN
+    IF target IN {TARGETS.Win64C, TARGETS.Win64GUI, TARGETS.Linux64} THEN
         L := NewLabel();
         pushc(0);
         push(rsp);
         pushc(1024 * 1024 * stack_size);
+        pushc(0);
-        pushc(0);
+        CallRTL(IL._new);
+        pop(rax);
-        CallRTL(IL._new);
+        test(rax);
-        pop(rax);
+        jcc(je, L);
-        test(rax);
+        GetRegA;
-        jcc(je, L);
+        addrc(rax, 1024 * 1024 * stack_size - 8);
     END import;
 BEGIN
-    IF target = mConst.Target_iDLL64 THEN
+    IF target = TARGETS.Win64DLL THEN
         X86.SetLabel(dllret);
-        OutByte(0C3H) // ret
+        X86.ret
-    ELSIF target = mConst.Target_iELFSO64 THEN
+    ELSIF target = TARGETS.Linux64SO THEN
         sofinit := NewLabel();
-        OutByte(0C3H);  // ret
+        X86.ret;
         X86.SetLabel(sofinit);
         CallRTL(IL._sofinit);
-        OutByte(0C3H)   // ret
+        X86.ret
     ELSE
 PROCEDURE rsave (reg, offs, size: INTEGER);
 BEGIN
     offs := offs * 8;
     CASE size OF
-    |1: movmr8(rbp, offs, reg)
+    |1: X86.movmr8(rbp, offs, reg)
-    |2: movmr16(rbp, offs, reg)
+    |2: X86.movmr16(rbp, offs, reg)
     |4: movmr32(rbp, offs, reg)
     |8: movmr(rbp, offs, reg)
     END
     prolog(modname, target, options.stack);
     translate(IL.codes.commands, tcount * 8);
     epilog(modname, target);
     BIN.fixup(prog);
-    IF target IN {mConst.Target_iConsole64, mConst.Target_iGUI64, mConst.Target_iDLL64} THEN
+    IF TARGETS.OS = TARGETS.osWIN64 THEN
-        PE32.write(prog, outname, target = mConst.Target_iConsole64, target = mConst.Target_iDLL64, TRUE)
+        PE32.write(prog, outname, target = TARGETS.Win64C, target = TARGETS.Win64DLL, TRUE)
-    ELSIF target IN {mConst.Target_iELF64, mConst.Target_iELFSO64} THEN
+    ELSIF TARGETS.OS = TARGETS.osLINUX64 THEN
-        ELF.write(prog, outname, sofinit, target = mConst.Target_iELFSO64, TRUE)
+        ELF.write(prog, outname, sofinit, target = TARGETS.Linux64SO, TRUE)
     END
 END CodeGen;

Subversion Repositories Kolibri OS

(root)/programs/develop/oberon07/Source/AMD64.ob07 – Rev 7696 → 7983