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

 (*
     BSD 2-Clause License
-    Copyright (c) 2018, 2019, Anton Krotov
+    Copyright (c) 2018-2019, Anton Krotov
     All rights reserved.
 *)
          IL.opEQSW .. IL.opGESW,
          IL.opCOPY, IL.opMOVE, IL.opCOPYA,
          IL.opCOPYS, IL.opROT,
          IL.opNEW, IL.opDISP, IL.opISREC,
          IL.opIS, IL.opTYPEGR, IL.opTYPEGP,
-         IL.opCASET, IL.opDIV,
+         IL.opTYPEGD, IL.opCASET, IL.opDIV,
          IL.opDIVL, IL.opMOD,
          IL.opMODL, IL.opLENGTH, IL.opLENGTHW:
             leaf := FALSE
                 OutByte(0C3H) // ret
             END;
             REG.Reset(R)
+        |IL.opSAVES:
-        |IL.opSAVES:
+            UnOp(reg1);
-            PushAll(1);
+            REG.PushAll_1(R);
+            pushDA(stroffs + param2);
+            push(reg1);
-            pushDA(stroffs + param2);
+            drop;
             pushc(param1);
             CallRTL(IL._move)
             pushc(param2);
             CallRTL(IL._set);
             GetRegA
+        |IL.opRSETL:
-        |IL.opRSETL:
+            UnOp(reg1);
-            PushAll(1);
+            REG.PushAll_1(R);
+            pushc(param2);
+            push(reg1);
-            pushc(param2);
+            drop;
-            CallRTL(IL._set2);
+            CallRTL(IL._set);
             GetRegA
         |IL.opRSET1:
-            UnOp(reg1);
-            PushAll(1);
+        |IL.opRSET1:
-            push(reg1);
+            PushAll(1);
-            CallRTL(IL._set);
+            CallRTL(IL._set1);
             GetRegA
             not(reg1)
         |IL.opCOPY:
             PushAll(2);
             pushc(param2);
-            CallRTL(IL._move2)
+            CallRTL(IL._move)
         |IL.opMOVE:
             PushAll(3);
-            CallRTL(IL._move2)
+            CallRTL(IL._move)
         |IL.opCOPYA:
                 END
             END
         |IL.opDIV:
             PushAll(2);
-            CallRTL(IL._div);
+            CallRTL(IL._divmod);
             GetRegA
         |IL.opDIVR:
                     END
                 ELSE
                     PushAll(1);
                     pushc(param2);
-                    CallRTL(IL._div);
+                    CallRTL(IL._divmod);
                     GetRegA
                 END
             END
+        |IL.opDIVL:
-        |IL.opDIVL:
+            UnOp(reg1);
+            REG.PushAll_1(R);
+            pushc(param2);
-            PushAll(1);
+            push(reg1);
-            pushc(param2);
+            drop;
-            CallRTL(IL._div2);
+            CallRTL(IL._divmod);
             GetRegA
+        |IL.opMOD:
-        |IL.opMOD:
+            PushAll(2);
-            PushAll(2);
+            CallRTL(IL._divmod);
-            CallRTL(IL._mod);
+            mov(rax, rdx);
             GetRegA
                     END
                 ELSE
                     PushAll(1);
                     pushc(param2);
+                    CallRTL(IL._divmod);
-                    CallRTL(IL._mod);
+                    mov(rax, rdx);
                     GetRegA
                 END
             END
+        |IL.opMODL:
-        |IL.opMODL:
+            UnOp(reg1);
+            REG.PushAll_1(R);
+            pushc(param2);
-            PushAll(1);
+            push(reg1);
+            drop;
-            pushc(param2);
+            CallRTL(IL._divmod);
-            CallRTL(IL._mod2);
+            mov(rax, rdx);
             GetRegA
     ASSERT(R.top = -1);
     ASSERT(xmm = -1)
 END translate;
-PROCEDURE prolog (code: IL.CODES; modname: ARRAY OF CHAR; target, stack_size: INTEGER);
+PROCEDURE prolog (modname: ARRAY OF CHAR; target, stack_size: INTEGER);
 VAR
     ModName_Offs, entry, L: INTEGER;
 BEGIN
-    ModName_Offs := tcount * 8 + CHL.Length(code.data);
+    ModName_Offs := tcount * 8 + CHL.Length(IL.codes.data);
     Numbers_Offs := ModName_Offs + LENGTH(modname) + 1;
     pushDA(0); //TYPES
     pushc(tcount);
     pushDA(ModName_Offs); //MODNAME
     CallRTL(IL._init);
-    IF target IN {mConst.Target_iConsole64, mConst.Target_iGUI64} THEN
+    IF target IN {mConst.Target_iConsole64, mConst.Target_iGUI64, mConst.Target_iELF64} THEN
         L := NewLabel();
         pushc(0);
         push(rsp);
         pushc(1024 * 1024 * stack_size);
         X86.SetLabel(L)
     END
 END prolog;
-PROCEDURE epilog (code: IL.CODES; modname: ARRAY OF CHAR; target: INTEGER);
+PROCEDURE epilog (modname: ARRAY OF CHAR; target: INTEGER);
 VAR
     i, n: INTEGER;
     X86.fixup;
     i := 0;
     WHILE i < tcount DO
-        BIN.PutData64LE(prog, CHL.GetInt(code.types, i));
+        BIN.PutData64LE(prog, CHL.GetInt(IL.codes.types, i));
         INC(i)
     END;
     i := 0;
-    WHILE i < CHL.Length(code.data) DO
+    WHILE i < CHL.Length(IL.codes.data) DO
-        BIN.PutData(prog, CHL.GetByte(code.data, i));
+        BIN.PutData(prog, CHL.GetByte(IL.codes.data, i));
         INC(i)
     FOR i := 0 TO Numbers_Count - 1 DO
         BIN.PutData64LE(prog, number.value);
         number := number.next(Number)
     END;
-    exp := code.export.first(IL.EXPORT_PROC);
+    exp := IL.codes.export.first(IL.EXPORT_PROC);
     WHILE exp # NIL DO
         BIN.Export(prog, exp.name, exp.label);
         exp := exp.next(IL.EXPORT_PROC)
     END;
-    import(code.import)
+    import(IL.codes.import)
 END epilog;
     |8: movmr(rbp, offs, reg)
     END
 END rsave;
-PROCEDURE CodeGen* (code: IL.CODES; outname: ARRAY OF CHAR; target: INTEGER; options: PROG.OPTIONS);
+PROCEDURE CodeGen* (outname: ARRAY OF CHAR; target: INTEGER; options: PROG.OPTIONS);
 VAR
     path, modname, ext: PATHS.PATH;
 BEGIN
-    tcount := CHL.Length(code.types);
+    tcount := CHL.Length(IL.codes.types);
     PATHS.split(outname, path, modname, ext);
     S.append(modname, ext);
     REG.Init(R, push, pop, mov, xchg, rload, rsave, {rax, r10, r11}, {rcx, rdx, r8, r9});
-    code.bss := MAX(code.bss, MAX(code.dmin - CHL.Length(code.data), 8));
+    IL.set_bss(MAX(IL.codes.bss, MAX(IL.codes.dmin - CHL.Length(IL.codes.data), 8)));
     Numbers := LISTS.create(NIL);
     NewNumber(-1);
     NewNumber(ROR(7FFH, 12));  (* +Infinity *)
     NewNumber(ORD(-BITS(LSR(ASR(ROR(1, 1), 10), 1))));  (* {0..51, 63} *)
     NewNumber(LSR(ASR(ROR(1, 1), 9), 2));  (* {52..61} *)
-    prog := BIN.create(code.lcount);
+    prog := BIN.create(IL.codes.lcount);
-    BIN.SetParams(prog, code.bss, 1, WCHR(1), WCHR(0));
+    BIN.SetParams(prog, IL.codes.bss, 1, WCHR(1), WCHR(0));
     X86.SetProgram(prog);
-    prolog(code, modname, target, options.stack);
+    prolog(modname, target, options.stack);
-    translate(code.commands, tcount * 8);
+    translate(IL.codes.commands, tcount * 8);
-    epilog(code, modname, target);
+    epilog(modname, target);
     BIN.fixup(prog);
     IF target IN {mConst.Target_iConsole64, mConst.Target_iGUI64, mConst.Target_iDLL64} THEN
-        PE32.write(prog, outname, options.base, target = mConst.Target_iConsole64, target = mConst.Target_iDLL64, TRUE)
+        PE32.write(prog, outname, target = mConst.Target_iConsole64, target = mConst.Target_iDLL64, TRUE)

Subversion Repositories Kolibri OS

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