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

 (*
     BSD 2-Clause License
-    Copyright (c) 2018, 2019, Anton Krotov
+    Copyright (c) 2018-2019, Anton Krotov
     All rights reserved.
 *)
 BEGIN
     ASSERT(REG.GetReg(R, eax))
 END GetRegA;
-PROCEDURE translate (code: IL.CODES; pic: BOOLEAN; stroffs: INTEGER);
+PROCEDURE translate (pic: BOOLEAN; stroffs: INTEGER);
 VAR
     opcode, param1, param2: INTEGER;
     float: REAL;
 BEGIN
-    cmd := code.commands.first(COMMAND);
+    cmd := IL.codes.commands.first(COMMAND);
                 OutByte2(8BH, reg1 * 9);        // mov reg1, dword[reg1]
                 OutByte2(89H, reg1 * 8 + reg2)  // mov dword[reg2], reg1
             |8:
-                PushAll(0);
-                push(reg2);
+                PushAll(0);
+                push(reg1);
-                push(reg1);
+                push(reg2);
                 pushc(8);
                 CallRTL(pic, IL._move)
             END
-        |IL.opSAVES:
-            UnOp(reg1);
-            drop;
+        |IL.opSAVES:
+            UnOp(reg2);
-            PushAll(0);
+            REG.PushAll_1(R);
-            push(reg1);
+            IF pic THEN
                 reg1 := GetAnyReg();
-            IF pic THEN
+                Pic(reg1, BIN.PICDATA, stroffs + param2);
-                Pic(reg1, BIN.PICDATA, stroffs + param2);
+                push(reg1);
-                push(reg1)
+                drop
+            ELSE
+                OutByte(068H);  // push _data + stroffs + param2
-            ELSE
+                Reloc(BIN.RDATA, stroffs + param2);
-                OutByte(068H);  // push _data + stroffs + param2
+            END;
                 Reloc(BIN.RDATA, stroffs + param2);
-            END;
+            push(reg2);
             pushc(param2);
             CallRTL(pic, IL._set);
             GetRegA
+        |IL.opRSETL:
-        |IL.opRSETL:
+            UnOp(reg1);
-            PushAll(1);
+            REG.PushAll_1(R);
+            pushc(param2);
+            push(reg1);
-            pushc(param2);
+            drop;
-            CallRTL(pic, IL._set2);
+            CallRTL(pic, IL._set);
             GetRegA
         |IL.opRSET1:
-            UnOp(reg1);
-            PushAll(1);
+        |IL.opRSET1:
-            push(reg1);
+            PushAll(1);
-            CallRTL(pic, IL._set);
+            CallRTL(pic, IL._set1);
             GetRegA
             OutByte3(0FH, 0BAH, 30H + reg1); OutByte(param2); //btr dword[reg1],param2
             drop
         |IL.opDIV:
             PushAll(2);
-            CallRTL(pic, IL._div);
+            CallRTL(pic, IL._divmod);
             GetRegA
         |IL.opDIVR:
                     END
                 ELSE
                     PushAll(1);
                     pushc(param2);
-                    CallRTL(pic, IL._div);
+                    CallRTL(pic, 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(pic, IL._div2);
+            CallRTL(pic, IL._divmod);
             GetRegA
+        |IL.opMOD:
-        |IL.opMOD:
+            PushAll(2);
-            PushAll(2);
+            CallRTL(pic, IL._divmod);
-            CallRTL(pic, IL._mod);
+            mov(eax, edx);
             GetRegA
                     END
                 ELSE
                     PushAll(1);
                     pushc(param2);
+                    CallRTL(pic, IL._divmod);
-                    CallRTL(pic, IL._mod);
+                    mov(eax, edx);
                     GetRegA
                 END
             END
+        |IL.opMODL:
-        |IL.opMODL:
+            UnOp(reg1);
+            REG.PushAll_1(R);
+            pushc(param2);
-            PushAll(1);
+            push(reg1);
+            drop;
-            pushc(param2);
+            CallRTL(pic, IL._divmod);
-            CallRTL(pic, IL._mod2);
+            mov(eax, edx);
             GetRegA
                                   // @@:
         |IL.opCOPY:
             PushAll(2);
             pushc(param2);
-            CallRTL(pic, IL._move2)
+            CallRTL(pic, IL._move)
         |IL.opMOVE:
             PushAll(3);
-            CallRTL(pic, IL._move2)
+            CallRTL(pic, IL._move)
         |IL.opCOPYA:
     ASSERT(R.top = -1)
 END translate;
-PROCEDURE prolog (code: IL.CODES; pic: BOOLEAN; target, stack, dllinit, dllret: INTEGER);
+PROCEDURE prolog (pic: BOOLEAN; target, stack, dllinit, dllret: INTEGER);
 VAR
-    reg1, entry, dcount: INTEGER;
+    reg1, entry, L, dcount: INTEGER;
     ELSE
         OutByte(68H);  // push _data
         Reloc(BIN.RDATA, 0)
     END;
-    dcount := CHL.Length(code.data);
+    dcount := CHL.Length(IL.codes.data);
     pushc(tcount);
     ELSE
         OutByte(68H);  // push _data
         Reloc(BIN.RDATA, tcount * 4 + dcount)
     END;
+    CallRTL(pic, IL._init);
+    IF target = mConst.Target_iELF32 THEN
+        L := NewLabel();
+        pushc(0);
+        push(esp);
+        pushc(1024 * 1024 * stack);
+        pushc(0);
+        CallRTL(pic, IL._new);
+        pop(eax);
+        test(eax);
+        jcc(je, L);
+        addrc(eax, 1024 * 1024 * stack - 4);
+        mov(esp, eax);
+        SetLabel(L)
-    CallRTL(pic, IL._init)
+    END
 END prolog;
-PROCEDURE epilog (code: IL.CODES; pic: BOOLEAN; modname: ARRAY OF CHAR; target, stack, ver, dllinit, dllret, sofinit: INTEGER);
+PROCEDURE epilog (pic: BOOLEAN; modname: ARRAY OF CHAR; target, stack, ver, dllinit, dllret, sofinit: INTEGER);
 VAR
         OutByte(0C3H)   // ret
     END;
     fixup;
-    dcount := CHL.Length(code.data);
+    dcount := CHL.Length(IL.codes.data);
     FOR i := 0 TO tcount - 1 DO
-        BIN.PutData32LE(program, CHL.GetInt(code.types, i))
+        BIN.PutData32LE(program, CHL.GetInt(IL.codes.types, i))
     END;
     FOR i := 0 TO dcount - 1 DO
     IF target = mConst.Target_iObject THEN
         BIN.Export(program, "lib_init", dllinit);
     END;
-    exp := code.export.first(IL.EXPORT_PROC);
+    exp := IL.codes.export.first(IL.EXPORT_PROC);
     WHILE exp # NIL DO
         BIN.Export(program, exp.name, exp.label);
         exp := exp.next(IL.EXPORT_PROC)
     END;
-    import(code.import);
+    import(IL.codes.import);
-    code.bss := MAX(code.bss, MAX(code.dmin - CHL.Length(code.data), 4));
+    IL.set_bss(MAX(IL.codes.bss, MAX(IL.codes.dmin - CHL.Length(IL.codes.data), 4)));
-    BIN.SetParams(program, code.bss, stack * (1024 * 1024), WCHR(ver DIV 65536), WCHR(ver MOD 65536));
+    BIN.SetParams(program, IL.codes.bss, stack * (1024 * 1024), WCHR(ver DIV 65536), WCHR(ver MOD 65536));
 END epilog;
-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
     dllret, dllinit, sofinit: INTEGER;
     opt: PROG.OPTIONS;
         opt.pic := TRUE
     END;
     REG.Init(R, push, pop, mov, xchg, NIL, NIL, {eax, ecx, edx}, {});
-    prolog(code, opt.pic, target, opt.stack, dllinit, dllret);
+    prolog(opt.pic, target, opt.stack, dllinit, dllret);
-    translate(code, opt.pic, tcount * 4);
+    translate(opt.pic, tcount * 4);
-    epilog(code, opt.pic, outname, target, opt.stack, opt.version, dllinit, dllret, sofinit);
+    epilog(opt.pic, outname, target, opt.stack, opt.version, dllinit, dllret, sofinit);
     BIN.fixup(program);
     IF target IN {mConst.Target_iConsole, mConst.Target_iGUI, mConst.Target_iDLL} THEN
-        PE32.write(program, outname, opt.base, target = mConst.Target_iConsole, target = mConst.Target_iDLL, FALSE)
+        PE32.write(program, outname, target = mConst.Target_iConsole, target = mConst.Target_iDLL, FALSE)
     ELSIF target = mConst.Target_iKolibri THEN

Subversion Repositories Kolibri OS

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