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

 *)
 MODULE AMD64;
 IMPORT IL, BIN, WR := WRITER, CHL := CHUNKLISTS, LISTS, PATHS, PROG, TARGETS,
-       REG, C := CONSOLE, UTILS, S := STRINGS, PE32, ELF, X86;
+       REG, UTILS, S := STRINGS, PE32, ELF, X86, ERRORS;
     rsp = 4;
     rbp = 5;
     rsi = 6;
     rdi = 7;
+    MAX_XMM = 5;
     je = 84H; jne = 85H; jl = 8CH; jge = 8DH; jle = 8EH; jg = 8FH; jb = 82H;
     sCODE = BIN.PICCODE;
     sDATA = BIN.PICDATA;
     sBSS  = BIN.PICBSS;
     sIMP  = BIN.PICIMP;
+    FPR_ERR = 41;
     dllret, sofinit: INTEGER;
     Win64RegPar: ARRAY 4 OF INTEGER;
+    SystemVRegPar: ARRAY 6 OF INTEGER;
+    Xmm: ARRAY 1000 OF INTEGER;
-    SystemVRegPar: ARRAY 6 OF INTEGER;
+    fname: PATHS.PATH;
 PROCEDURE OutByte (b: BYTE);
     X86.OutByte(UTILS.Byte(n, 2));
     X86.OutByte(UTILS.Byte(n, 3))
 END OutInt;
-PROCEDURE isByte (n: INTEGER): BOOLEAN;
-    RETURN (-128 <= n) & (n <= 127)
-END isByte;
 PROCEDURE short (n: INTEGER): INTEGER;
-    RETURN 2 * ORD(isByte(n))
+    RETURN 2 * ORD(X86.isByte(n))
 END short;
 PROCEDURE long (n: INTEGER): INTEGER;
-    RETURN 40H * ORD(~isByte(n))
+    RETURN 40H * ORD(~X86.isByte(n))
 END long;
 PROCEDURE OutIntByte (n: INTEGER);
 BEGIN
 BEGIN
     oprr(21H, reg1, reg2)
 END and;
-PROCEDURE or (reg1, reg2: INTEGER); (* or reg1, reg2 *)
+PROCEDURE _or (reg1, reg2: INTEGER); (* or reg1, reg2 *)
 BEGIN
     oprr(09H, reg1, reg2)
-END or;
+END _or;
 END sub;
+PROCEDURE xchg (reg1, reg2: INTEGER); (* xchg reg1, reg2 *)
+BEGIN
+    IF rax IN {reg1, reg2} THEN
+        Rex(reg1 + reg2, 0);
-PROCEDURE xchg (reg1, reg2: INTEGER); (* xchg reg1, reg2 *)
+        OutByte(90H + (reg1 + reg2) MOD 8)
+    ELSE
-BEGIN
+        oprr(87H, reg1, reg2)
-    oprr(87H, reg1, reg2)
+    END
 END xchg;
     RETURN REG.GetVarReg(R, offs)
 END GetVarReg;
-PROCEDURE callimp (label: INTEGER);
-VAR
     reg: INTEGER;
-BEGIN
-    reg := GetAnyReg();
+PROCEDURE callimp (label: INTEGER);
-    lea(reg, label, sIMP);
+BEGIN
-    IF reg >= 8 THEN (* call qword[reg] *)
-        OutByte(41H)
-    END;
-    OutByte2(0FFH, 10H + reg MOD 8);
+    OutByte2(0FFH, 15H);    (* call qword[rip + label + IMP] *)
-    drop
+    X86.Reloc(sIMP, label)
 END callimp;
 BEGIN
     IF isLong(n) THEN
         oprlongc(reg, n, oprr)
     ELSE
         Rex(reg, 0);
-        OutByte2(81H + short(n), op + reg MOD 8);
-        OutIntByte(n)
+        X86.oprc(op, reg, n)
     END
 END oprc;
 END andrc;
 PROCEDURE orrc (reg, n: INTEGER); (* or reg, n *)
 BEGIN
-    oprc(0C8H, reg, n, or)
+    oprc(0C8H, reg, n, _or)
 END orrc;
         reg2 := GetAnyReg();
         movabs(reg2, n);
         push(reg2);
         drop
     ELSE
-        OutByte(68H + short(n)); OutIntByte(n) (* push n *)
+        X86.pushc(n)
     END
 END pushc;
 BEGIN
     X86.jcc(cc, label)
 END jcc;
-PROCEDURE jmp (label: INTEGER); (* jmp label *)
-BEGIN
-    X86.jmp(label)
-END jmp;
-PROCEDURE setcc (cc, reg: INTEGER); (* setcc reg8 *)
-BEGIN
-    IF reg >= 8 THEN
-        OutByte(41H)
-    END;
-    OutByte3(0FH, cc, 0C0H + reg MOD 8)
-END setcc;
 PROCEDURE shiftrc (op, reg, n: INTEGER);
 BEGIN
     Rex(reg, 0);
     |IL.opGEF:
         comisd(xmm - 1, xmm);
         cc := setnc
     END;
     OutByte2(7AH, 3 + reg DIV 8); (* jp L *)
-    setcc(cc, reg);
+    X86.setcc(cc, reg)
     (* L: *)
 END fcmp;
         opcode := cmd.opcode;
         CASE opcode OF
         |IL.opJMP:
-            jmp(param1)
+            X86.jmp(param1)
         |IL.opCALL, IL.opWIN64CALL, IL.opSYSVCALL:
         |IL.opERR:
             CallRTL(IL._error)
         |IL.opONERR:
             pushc(param2);
-            jmp(param1)
+            X86.jmp(param1)
         |IL.opPUSHC:
             pushc(param2)
         |IL.opPRECALL:
-            n := param2;
+            PushAll(0);
+            IF (param2 # 0) & (xmm >= 0) THEN
+                subrc(rsp, 8)
-            IF (param1 # 0) & (n # 0) THEN
+            END;
-                subrc(rsp, 8)
+            INC(Xmm[0]);
-            END;
+            Xmm[Xmm[0]] := xmm + 1;
-            WHILE n > 0 DO
+            WHILE xmm >= 0 DO
-                subrc(rsp, 8);
-                movsdmr(rsp, 0, xmm);
+                subrc(rsp, 8);
-                DEC(xmm);
+                movsdmr(rsp, 0, xmm);
-                DEC(n)
-            END;
+                DEC(xmm)
-            ASSERT(xmm = -1);
+            END;
-            PushAll(0)
+            ASSERT(xmm = -1)
             push(rax);
             IF ~ODD(param2) THEN
                 push(rax)
             END
+        |IL.opRESF, IL.opRES:
-        |IL.opRESF:
+            ASSERT(R.top = -1);
+            ASSERT(xmm = -1);
+            n := Xmm[Xmm[0]]; DEC(Xmm[0]);
-            ASSERT(xmm = -1);
+            IF opcode = IL.opRESF THEN
-            INC(xmm);
-            n := param2;
+                INC(xmm);
-            IF n > 0 THEN
+                IF n > 0 THEN
-                movsdmr(rsp, n * 8, xmm);
+                    movsdmr(rsp, n * 8, 0);
-                DEC(xmm);
+                    DEC(xmm);
-                INC(n)
+                    INC(n)
-            END;
+                END;
-            WHILE n > 0 DO
-                INC(xmm);
-                movsdrm(xmm, rsp, 0);
-                addrc(rsp, 8);
+                IF xmm + n > MAX_XMM THEN
+                    ERRORS.ErrorMsg(fname, param1, param2, FPR_ERR)
+                END
+            ELSE
-                DEC(n)
-            END
-        |IL.opRES:
-            ASSERT(R.top = -1);
+                GetRegA
-            GetRegA;
+            END;
             n := param2;
             WHILE n > 0 DO
                 INC(xmm);
             reg1 := GetAnyReg();
             reg2 := GetVarReg(param2);
             IF reg2 # -1 THEN
                 mov(reg1, reg2)
             ELSE
-                n := param2 * 8;
+                movrm32(reg1, rbp, param2 * 8)
-                xor(reg1, reg1);
+            END;
-                movrm32(reg1, rbp, n)
+            shiftrc(shl, reg1, 32);
-            END
+            shiftrc(shr, reg1, 32)
         |IL.opGLOAD64:
             reg1 := GetAnyReg();
-            lea(reg1, param2, sBSS);
+            Rex(0, reg1);  (* mov reg1, qword[rip + param2 + BSS] *)
-            movrm(reg1, reg1, 0)
-        |IL.opGLOAD8:
-            reg1 := GetAnyReg();
+            OutByte2(8BH, 05H + 8 * (reg1 MOD 8));
-            lea(reg1, param2, sBSS);
-            movzx(reg1, reg1, 0, FALSE)
+            X86.Reloc(sBSS, param2)
-        |IL.opGLOAD16:
+        |IL.opGLOAD8, IL.opGLOAD16:
             reg1 := GetAnyReg();
+            Rex(0, reg1);  (* movzx reg1, byte/word[rip + param2 + BSS] *)
-            lea(reg1, param2, sBSS);
+            OutByte3(0FH, 0B6H + ORD(opcode = IL.opGLOAD16), 05H + 8 * (reg1 MOD 8));
-            movzx(reg1, reg1, 0, TRUE)
+            X86.Reloc(sBSS, param2)
-        |IL.opGLOAD32:
-            reg1 := GetAnyReg();
+        |IL.opGLOAD32:
-            xor(reg1, reg1);
+            reg1 := GetAnyReg();
+            lea(reg1, param2, sBSS);
+            movrm32(reg1, reg1, 0);
-            lea(reg1, param2, sBSS);
+            shiftrc(shl, reg1, 32);
-            movrm32(reg1, reg1, 0)
+            shiftrc(shr, reg1, 32)
         |IL.opVLOAD64:
             movzx(reg1, reg1, 0, opcode = IL.opVLOAD16)
         |IL.opVLOAD32:
             reg1 := GetAnyReg();
-            reg2 := GetAnyReg();
-            xor(reg1, reg1);
+            reg2 := GetAnyReg();
             movrm(reg2, rbp, param2 * 8);
+            movrm32(reg1, reg2, 0);
+            shiftrc(shl, reg1, 32);
-            movrm32(reg1, reg2, 0);
+            shiftrc(shr, reg1, 32);
             drop
         |IL.opLADR:
             n := param2 * 8;
+            next := cmd.next(COMMAND);
-            next := cmd.next(COMMAND);
+            IF (next.opcode = IL.opSAVEF) OR (next.opcode = IL.opSAVEFI) THEN
-            IF (next.opcode = IL.opSAVEF) OR (next.opcode = IL.opSAVEFI) THEN
+                ASSERT(xmm >= 0);
                 movsdmr(rbp, n, xmm);
                 DEC(xmm);
                 cmd := next
+            ELSIF next.opcode = IL.opLOADF THEN
+                INC(xmm);
+                IF xmm > MAX_XMM THEN
-            ELSIF next.opcode = IL.opLOADF THEN
+                    ERRORS.ErrorMsg(fname, next.param1, next.param2, FPR_ERR)
-                INC(xmm);
+                END;
                 movsdrm(xmm, rbp, n);
+                cmd := next
+            ELSE
+                IF (next.opcode = IL.opADDC) & ~isLong(n + next.param2) THEN
+                    INC(n, next.param2);
-                cmd := next
+                    cmd := next
-            ELSE
+                END;
                 reg1 := GetAnyReg();
                 Rex(0, reg1);
                 OutByte2(8DH, 45H + long(n) + (reg1 MOD 8) * 8); (* lea reg1, qword[rbp+n] *)
                 OutIntByte(n)
+            END
+        |IL.opGADR:
+            next := cmd.next(COMMAND);
+            IF (next.opcode = IL.opADDC) & ~isLong(param2 + next.param2) THEN
-            END
+                INC(param2, next.param2);
                 cmd := next
-        |IL.opGADR:
+            END;
             drop;
             cc := X86.cond(opcode);
             next := cmd.next(COMMAND);
-            IF next.opcode = IL.opJE THEN
+            IF next.opcode = IL.opJNZ THEN
                 jcc(cc, next.param1);
                 cmd := next
-            ELSIF next.opcode = IL.opJNE THEN
+            ELSIF next.opcode = IL.opJZ THEN
                 jcc(X86.inv0(cc), next.param1);
                 cmd := next
             ELSE
                 reg1 := GetAnyReg();
-                setcc(cc + 16, reg1);
+                X86.setcc(cc + 16, reg1);
                 andrc(reg1, 1)
             END
             ELSE
                 ASSERT(R.top + 1 <= n);
                 PushAll(n)
             END
-        |IL.opACC:
-            IF (R.top # 0) OR (R.stk[0] # rax) THEN
-                PushAll(0);
-                GetRegA;
-                pop(rax);
-                DEC(R.pushed)
-            END
-        |IL.opJNZ:
+        |IL.opJNZ1:
             UnOp(reg1);
             test(reg1);
-            jcc(jne, param1)
-        |IL.opJZ:
-            UnOp(reg1);
-            test(reg1);
-            jcc(je, param1)
+            jcc(jne, param1)
         |IL.opJG:
             UnOp(reg1);
             test(reg1);
             jcc(jg, param1)
-        |IL.opJE:
+        |IL.opJNZ:
             UnOp(reg1);
             test(reg1);
             jcc(jne, param1);
             drop
-        |IL.opJNE:
+        |IL.opJZ:
             L := NewLabel();
             BinOp(reg1, reg2);
             cmprc(reg1, 64);
             jcc(jb, L);
             xor(reg1, reg1);
-            jmp(label);
+            X86.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);
+            X86.setcc(setc, reg1);
             andrc(reg1, 1);
             X86.SetLabel(label);
             drop
         |IL.opINL:
             UnOp(reg1);
             Rex(reg1, 0);
             OutByte2(0FH, 0BAH); (* bt reg1, param2 *)
             OutByte2(0E0H + reg1 MOD 8, param2);
-            setcc(setc, reg1);
+            X86.setcc(setc, reg1);
             andrc(reg1, 1)
         |IL.opNOT:
             UnOp(reg1);
             test(reg1);
-            setcc(sete, reg1);
+            X86.setcc(sete, reg1);
             andrc(reg1, 1)
         |IL.opORD:
             UnOp(reg1);
             test(reg1);
-            setcc(setne, reg1);
+            X86.setcc(setne, reg1);
             andrc(reg1, 1)
             jcc(je, label);
             movrc(reg2, 1);
             X86.SetLabel(label);
             cmprr(reg1, reg2);
             IF opcode = IL.opEQB THEN
-                setcc(sete, reg1)
+                X86.setcc(sete, reg1)
             ELSE
-                setcc(setne, reg1)
+                X86.setcc(setne, reg1)
             END;
             andrc(reg1, 1)
         |IL.opMULSC:
         |IL.opDIVSC:
             UnOp(reg1);
             xorrc(reg1, param2)
-        |IL.opADDSL, IL.opADDSR:
+        |IL.opADDSC:
             UnOp(reg1);
             orrc(reg1, param2)
             sub(reg1, reg2);
             drop
         |IL.opSUBR, IL.opSUBL:
-            UnOp(reg1);
-            n := param2;
+            UnOp(reg1);
-            IF n = 1 THEN
+            IF param2 = 1 THEN
                 decr(reg1)
-            ELSIF n = -1 THEN
+            ELSIF param2 = -1 THEN
                 incr(reg1)
-            ELSIF n # 0 THEN
+            ELSIF param2 # 0 THEN
-                subrc(reg1, n)
+                subrc(reg1, param2)
             END;
             IF opcode = IL.opSUBL THEN
                 neg(reg1)
             END
-        |IL.opADDL, IL.opADDR:
+        |IL.opADDC:
             IF (param2 # 0) & ~isLong(param2) THEN
                 UnOp(reg1);
                 next := cmd.next(COMMAND);
                 END
             END
         |IL.opADDS:
             BinOp(reg1, reg2);
-            or(reg1, reg2);
+            _or(reg1, reg2);
             drop
         |IL.opSUBS:
             BinOp(reg1, reg2);
             not(reg2);
             and(reg1, reg2);
             drop
-        |IL.opNOP:
+        |IL.opNOP, IL.opAND, IL.opOR:
             drop;
             drop;
             reg1 := GetAnyReg();
             CASE opcode OF
-            |IL.opEQP, IL.opEQIP: setcc(sete,  reg1)
+            |IL.opEQP, IL.opEQIP: X86.setcc(sete,  reg1)
-            |IL.opNEP, IL.opNEIP: setcc(setne, reg1)
+            |IL.opNEP, IL.opNEIP: X86.setcc(setne, reg1)
             END;
             END;
             OutByte2(8FH, reg1 MOD 8); (* pop qword[reg1] *)
             drop
-        |IL.opCLEANUP:
-            n := param2 * 8;
+        |IL.opCLEANUP:
-            IF n # 0 THEN
+            IF param2 # 0 THEN
-                addrc(rsp, n)
+                addrc(rsp, param2 * 8)
             END
         |IL.opPOPSP:
             pop(rsp)
+        |IL.opLOADF:
+            UnOp(reg1);
+            INC(xmm);
-        |IL.opLOADF:
+            IF xmm > MAX_XMM THEN
-            UnOp(reg1);
+                ERRORS.ErrorMsg(fname, param1, param2, FPR_ERR)
-            INC(xmm);
+            END;
+            movsdrm(xmm, reg1, 0);
-            movsdrm(xmm, reg1, 0);
+            drop
             drop
         |IL.opPUSHF:
-        |IL.opPUSHF:
+            ASSERT(xmm >= 0);
             subrc(rsp, 8);
             movsdmr(rsp, 0, xmm);
             DEC(xmm)
+        |IL.opCONSTF:
+            float := cmd.float;
+            INC(xmm);
-        |IL.opCONSTF:
+            IF xmm > MAX_XMM THEN
+                ERRORS.ErrorMsg(fname, param1, param2, FPR_ERR)
-            float := cmd.float;
+            END;
+            (* movsd xmm, qword ptr [rip + Numbers_Offs + Numbers_Count * 8 + DATA] *)
+            OutByte(0F2H);
-            INC(xmm);
+            IF xmm >= 8 THEN
-            reg1 := GetAnyReg();
+                OutByte(44H)
+            END;
-            lea(reg1, Numbers_Offs + Numbers_Count * 8, sDATA);
+            OutByte3(0FH, 10H, 05H + 8 * (xmm MOD 8));
-            movsdrm(xmm, reg1, 0);
+            X86.Reloc(sDATA, Numbers_Offs + Numbers_Count * 8);
-            drop;
+            NewNumber(UTILS.splitf(float, a, b))
             NewNumber(UTILS.splitf(float, a, b))
+        |IL.opSAVEF, IL.opSAVEFI:
+            ASSERT(xmm >= 0);
-        |IL.opSAVEF, IL.opSAVEFI:
+            UnOp(reg1);
-            UnOp(reg1);
+            movsdmr(reg1, 0, xmm);
-            movsdmr(reg1, 0, xmm);
+            DEC(xmm);
+            drop
             DEC(xmm);
-            drop
+        |IL.opADDF:
             ASSERT(xmm >= 1);
+            opxx(58H, xmm - 1, xmm);
-        |IL.opADDF, IL.opADDFI:
+            DEC(xmm)
             opxx(58H, xmm - 1, xmm);
-            DEC(xmm)
+        |IL.opSUBF:
             ASSERT(xmm >= 1);
+            opxx(5CH, xmm - 1, xmm);
-        |IL.opSUBF:
+            DEC(xmm)
             opxx(5CH, xmm - 1, xmm);
-            DEC(xmm)
+        |IL.opSUBFI:
+            ASSERT(xmm >= 1);
             opxx(5CH, xmm, xmm - 1);
-        |IL.opSUBFI:
+            opxx(10H, xmm - 1, xmm);
-            opxx(5CH, xmm, xmm - 1);
+            DEC(xmm)
-            opxx(10H, xmm - 1, xmm);
+        |IL.opMULF:
-            DEC(xmm)
+            ASSERT(xmm >= 1);
             opxx(59H, xmm - 1, xmm);
-        |IL.opMULF:
-            opxx(59H, xmm - 1, xmm);
-            DEC(xmm)
+            DEC(xmm)
-        |IL.opDIVF:
-            opxx(5EH, xmm - 1, xmm);
+        |IL.opDIVF:
-            DEC(xmm)
+            ASSERT(xmm >= 1);
-        |IL.opDIVFI:
+            opxx(5EH, xmm - 1, xmm);
-            opxx(5EH, xmm, xmm - 1);
+            DEC(xmm)
-            opxx(10H, xmm - 1, xmm);
-            DEC(xmm)
+        |IL.opDIVFI:
-        |IL.opUMINF:
+            ASSERT(xmm >= 1);
-            reg1 := GetAnyReg();
+            opxx(5EH, xmm, xmm - 1);
-            lea(reg1, Numbers_Offs, sDATA);
+            opxx(10H, xmm - 1, xmm);
+            DEC(xmm)
+        |IL.opFABS, IL.opUMINF: (* andpd/xorpd xmm, xmmword[rip + Numbers_Offs + (16) + DATA] *)
-            OutByte3(66H, 40H + reg1 DIV 8 + (xmm DIV 8) * 4, 0FH); (* xorpd xmm, xmmword[reg1] *)
+            ASSERT(xmm >= 0);
-            OutByte2(57H, reg1 MOD 8 + (xmm MOD 8) * 8);
+            OutByte(66H);
-            drop
+            IF xmm >= 8 THEN
                 OutByte(44H)
+            END;
-        |IL.opFABS:
+            OutByte3(0FH, 54H + 3 * ORD(opcode = IL.opUMINF), 05H + (xmm MOD 8) * 8);
-            reg1 := GetAnyReg();
+            X86.Reloc(sDATA, Numbers_Offs + 16 * ORD(opcode = IL.opFABS))
             lea(reg1, Numbers_Offs + 16, sDATA);
-            OutByte3(66H, 40H + reg1 DIV 8 + (xmm DIV 8) * 4, 0FH); (* andpd xmm, xmmword[reg1] *)
+        |IL.opFLT:
-            OutByte2(54H, reg1 MOD 8 + (xmm MOD 8) * 8);
+            UnOp(reg1);
             OutByte3(00FH, 0AEH, 054H); OutByte2(024H, 004H);                       (* ldmxcsr dword[rsp+4];                              *)
             addrc(rsp, 8);
             DEC(xmm)
+        |IL.opEQF .. IL.opGEF:
-        |IL.opEQF .. IL.opGEF:
+            ASSERT(xmm >= 1);
             fcmp(opcode, xmm);
             DEC(xmm, 2)
         |IL.opINF:
+            INC(xmm);
+            IF xmm > MAX_XMM THEN
-            INC(xmm);
+                ERRORS.ErrorMsg(fname, param1, param2, FPR_ERR)
+            END;
-            reg1 := GetAnyReg();
+            (* movsd xmm, qword ptr [rip + Numbers_Offs + 32 + DATA] *)
+            OutByte(0F2H);
-            lea(reg1, Numbers_Offs + 32, sDATA);
+            IF xmm >= 8 THEN
+                OutByte(44H)
+            END;
-            movsdrm(xmm, reg1, 0);
+            OutByte3(0FH, 10H, 05H + 8 * (xmm MOD 8));
-            drop
+            X86.Reloc(sDATA, Numbers_Offs + 32)
         |IL.opPACK, IL.opPACKC:
             lea(reg1, Numbers_Offs + 40, sDATA); (* {0..51, 63} *)
             movrm(reg1, reg1, 0);
             and(reg2, reg1);
             pop(reg1);
-            or(reg2, reg1);
+            _or(reg2, reg1);
             pop(reg1);
             movmr(reg1, 0, reg2);
             drop;
             movrm(reg1, reg2, 0);
             push(reg2);
             lea(reg2, Numbers_Offs + 48, sDATA); (* {52..61} *)
             movrm(reg2, reg2, 0);
-            or(reg1, reg2);
+            _or(reg1, reg2);
             pop(reg2);
             Rex(reg1, 0);
             ELSE
                 X86.pushm(rbp, param2 * 8)
             END
-        |IL.opGLOAD64_PARAM:
-            reg2 := GetAnyReg();
+        |IL.opGLOAD64_PARAM:
-            lea(reg2, param2, sBSS);
+            OutByte2(0FFH, 35H); (* push qword[rip + param2 + BSS] *)
-            movrm(reg2, reg2, 0);
-            push(reg2);
-            drop
+            X86.Reloc(sBSS, param2)
         |IL.opCONST_PARAM:
+            pushc(param2)
             pushc(param2)
-        |IL.opGLOAD32_PARAM:
+        |IL.opGLOAD32_PARAM, IL.opLOAD32_PARAM:
-            reg1 := GetAnyReg();
-            xor(reg1, reg1);
-            lea(reg1, param2, sBSS);
+            IF opcode = IL.opGLOAD32_PARAM THEN
-            movrm32(reg1, reg1, 0);
-            push(reg1);
+                reg1 := GetAnyReg();
-            drop
+                lea(reg1, param2, sBSS)
             ELSE
-        |IL.opLOAD32_PARAM:
+                UnOp(reg1)
-            UnOp(reg1);
+            END;
             movrm32(reg1, reg1, 0);
             shiftrc(shl, reg1, 32);
             shiftrc(shr, reg1, 32);
             push(reg1);
-            drop
             drop
         |IL.opLLOAD32_PARAM:
-            reg1 := GetAnyReg();
+        |IL.opLLOAD32_PARAM:
-            xor(reg1, reg1);
+            reg1 := GetAnyReg();
             reg2 := GetVarReg(param2);
             IF reg2 # -1 THEN
+                mov(reg1, reg2)
+            ELSE
-                mov(reg1, reg2)
+                movrm32(reg1, rbp, param2 * 8)
-            ELSE
+            END;
-                movrm32(reg1, rbp, param2 * 8)
+            shiftrc(shl, reg1, 32);
-            END;
+            shiftrc(shr, reg1, 32);
                 lea(reg2, param1, sBSS);
                 movmr(reg2, 0, reg1);
                 drop;
                 drop
             ELSE
-                reg2 := GetAnyReg();
+                (* mov qword[rip + param1 - 4 + BSS], param2 *)
-                lea(reg2, param1, sBSS);
+                OutByte3(48H, 0C7H, 05H);
-                Rex(reg2, 0);
+                X86.Reloc(sBSS, param1 - 4);
-                OutByte2(0C7H, reg2 MOD 8); (* mov qword[reg2], param2 *)
-                OutInt(param2);
+                OutInt(param2)
-                drop
             END
         |IL.opLADR_SAVE:
             UnOp(reg1);
             IF reg2 # -1 THEN
                 OutByte2(73H, 4); (* jnb L *)
                 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(~X86.isByte(n))); (* jnb L *)
                 Rex(0, reg1);
                 OutByte3(0FH, 0ABH + 8 * ORD(opcode = IL.opLADR_EXCL), 45H + long(n) + 8 * (reg1 MOD 8));
                 OutIntByte(n) (* bts/btr qword[rbp+n], reg1 *)
             END;
             (* L: *)
                 OutByte(6DH + long(n) + 8 * ORD(opcode = IL.opLADR_EXCLC));
                 OutIntByte(n);
                 OutByte(param2)
             END
+        |IL.opFNAME:
+            fname := cmd(IL.FNAMECMD).fname
         |IL.opLOOP, IL.opENDLOOP:
         push(r8);
         push(rdx);
         push(rcx);
         CallRTL(IL._dllentry);
         test(rax);
-        jcc(je, dllret)
+        jcc(je, dllret);
-    END;
+        pushc(0)
-    IF target = TARGETS.Linux64 THEN
+    ELSIF target = TARGETS.Linux64 THEN
         push(rsp)
     ELSE
         pushc(0)
     END;
     i, n: INTEGER;
     number: Number;
     exp: IL.EXPORT_PROC;
-    PROCEDURE import (imp: LISTS.LIST);
+    PROCEDURE _import (imp: LISTS.LIST);
     VAR
         lib:  IL.IMPORT_LIB;
                 proc := proc.next(IL.IMPORT_PROC)
             END;
             lib := lib.next(IL.IMPORT_LIB)
         END
-    END import;
+    END _import;
     WHILE exp # NIL DO
         BIN.Export(prog, exp.name, exp.label);
         exp := exp.next(IL.EXPORT_PROC)
     END;
-    import(IL.codes.import)
+    _import(IL.codes._import)
 END epilog;
 PROCEDURE CodeGen* (outname: ARRAY OF CHAR; target: INTEGER; options: PROG.OPTIONS);
 VAR
     path, modname, ext: PATHS.PATH;
+BEGIN
-BEGIN
+    Xmm[0] := 0;
     tcount := CHL.Length(IL.codes.types);
     Win64RegPar[0] := rcx;

Subversion Repositories Kolibri OS

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