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

 *)
 MODULE X86;
 IMPORT IL, REG, UTILS, LISTS, BIN, PE32, KOS, MSCOFF, ELF, PROG,
-       CHL := CHUNKLISTS, PATHS, TARGETS;
+       CHL := CHUNKLISTS, PATHS, TARGETS, ERRORS;
     ax = eax; cx = ecx; dx = edx;
     esp = 4;
+    ebp = 5;
-    ebp = 5;
+    MAX_FR = 7;
     sete = 94H; setne = 95H; setl = 9CH; setge = 9DH; setle = 9EH; setg = 9FH; setc = 92H; setnc = 93H;
+    je = 84H; jne = 85H; jl = 8CH; jge = 8DH; jle = 8EH; jg = 8FH; jb = 82H; jnb = 83H;
     je = 84H; jne = 85H; jl = 8CH; jge = 8DH; jle = 8EH; jg = 8FH; jb = 82H; jnb = 83H;
     CodeList: LISTS.LIST;
+    tcount: INTEGER;
+    FR: ARRAY 1000 OF INTEGER;
-    tcount: INTEGER;
+    fname: PATHS.PATH;
     ASSERT((0 <= n) & (n <= 65535));
     OutByte2(n MOD 256, n DIV 256)
 END OutWord;
-PROCEDURE isByte (n: INTEGER): BOOLEAN;
+PROCEDURE isByte* (n: INTEGER): BOOLEAN;
     RETURN (-128 <= n) & (n <= 127)
     |IL.opLSR, IL.opLSR1, IL.opLSR2: OutByte(0E8H + reg)
     END
 END shift;
-PROCEDURE mov (reg1, reg2: INTEGER);
+PROCEDURE oprr (op: BYTE; reg1, reg2: INTEGER); (* op reg1, reg2 *)
 BEGIN
-    OutByte2(89H, 0C0H + reg2 * 8 + reg1)  (* mov reg1, reg2 *)
+    OutByte2(op, 0C0H + 8 * reg2 + reg1)
-END mov;
+END oprr;
+PROCEDURE mov (reg1, reg2: INTEGER); (* mov reg1, reg2 *)
+BEGIN
     oprr(89H, reg1, reg2)
-PROCEDURE xchg (reg1, reg2: INTEGER);
-VAR
+END mov;
-    regs: SET;
-BEGIN
-    regs := {reg1, reg2};
+PROCEDURE xchg (reg1, reg2: INTEGER); (* xchg reg1, reg2 *)
-    IF regs = {eax, ecx} THEN
-        OutByte(91H)                (* xchg eax, ecx *)
+BEGIN
-    ELSIF regs = {eax, edx} THEN
+    IF eax IN {reg1, reg2} THEN
-        OutByte(92H)                (* xchg eax, edx *)
+        OutByte(90H + reg1 + reg2)
 BEGIN
     OutByte(50H + reg) (* push reg *)
 END push;
+PROCEDURE xor (reg1, reg2: INTEGER); (* xor reg1, reg2 *)
+BEGIN
+    oprr(31H, reg1, reg2)
+END xor;
+PROCEDURE movrc (reg, n: INTEGER);
+BEGIN
+    IF n = 0 THEN
-PROCEDURE movrc (reg, n: INTEGER);
+        xor(reg, reg)
-BEGIN
+    ELSE
+        OutByte(0B8H + reg); (* mov reg, n *)
-    OutByte(0B8H + reg); (* mov reg, n *)
+        OutInt(n)
-    OutInt(n)
+    END
 END movrc;
-PROCEDURE pushc (n: INTEGER);
+PROCEDURE pushc* (n: INTEGER);
 BEGIN
     OutByte2(0F7H, 0D0H + reg)  (* not reg *)
 END not;
-PROCEDURE add (reg1, reg2: INTEGER);
+PROCEDURE add (reg1, reg2: INTEGER); (* add reg1, reg2 *)
 BEGIN
-    OutByte2(01H, 0C0H + reg2 * 8 + reg1)  (* add reg1, reg2 *)
+    oprr(01H, reg1, reg2)
 END add;
+PROCEDURE oprc* (op, reg, n: INTEGER);
+BEGIN
+    IF (reg = eax) & ~isByte(n) THEN
+        CASE op OF
+        |0C0H: op := 05H (* add *)
+        |0E8H: op := 2DH (* sub *)
+        |0F8H: op := 3DH (* cmp *)
+        |0E0H: op := 25H (* and *)
+        |0C8H: op := 0DH (* or  *)
+        |0F0H: op := 35H (* xor *)
+        END;
         OutByte(op);
+        OutInt(n)
+    ELSE
+        OutByte2(81H + short(n), op + reg MOD 8);
+        OutIntByte(n)
+    END
+END oprc;
 PROCEDURE andrc (reg, n: INTEGER);
-BEGIN
+PROCEDURE andrc (reg, n: INTEGER); (* and reg, n *)
-    OutByte2(81H + short(n), 0E0H + reg);  (* and reg, n *)
+BEGIN
-    OutIntByte(n)
-END andrc;
+    oprc(0E0H, reg, n)
 END andrc;
 PROCEDURE orrc (reg, n: INTEGER);
-BEGIN
-    OutByte2(81H + short(n), 0C8H + reg);  (* or reg, n *)
+PROCEDURE orrc (reg, n: INTEGER); (* or reg, n *)
-    OutIntByte(n)
+BEGIN
-END orrc;
+    oprc(0C8H, reg, n)
 END orrc;
-PROCEDURE addrc (reg, n: INTEGER);
-BEGIN
-    OutByte2(81H + short(n), 0C0H + reg);  (* add reg, n *)
+PROCEDURE xorrc (reg, n: INTEGER); (* xor reg, n *)
-    OutIntByte(n)
+BEGIN
-END addrc;
+    oprc(0F0H, reg, n)
+END xorrc;
 PROCEDURE subrc (reg, n: INTEGER);
-BEGIN
+PROCEDURE addrc (reg, n: INTEGER); (* add reg, n *)
-    OutByte2(81H + short(n), 0E8H + reg);  (* sub reg, n *)
+BEGIN
-    OutIntByte(n)
+    oprc(0C0H, reg, n)
-END subrc;
+END addrc;
 PROCEDURE cmprr (reg1, reg2: INTEGER);
-BEGIN
+PROCEDURE subrc (reg, n: INTEGER); (* sub reg, n *)
-    OutByte2(39H, 0C0H + reg2 * 8 + reg1)  (* cmp reg1, reg2 *)
+BEGIN
-END cmprr;
+    oprc(0E8H, reg, n)
+END subrc;
 PROCEDURE cmprc (reg, n: INTEGER);
+PROCEDURE cmprc (reg, n: INTEGER); (* cmp reg, n *)
+BEGIN
+    IF n = 0 THEN
-BEGIN
+        test(reg)
-    IF n = 0 THEN
+    ELSE
-        test(reg)
+        oprc(0F8H, reg, n)
-    ELSE
+    END
-        OutByte2(81H + short(n), 0F8H + reg);  (* cmp reg, n *)
+END cmprc;
 BEGIN
     GetRegA;
     OutByte2(0DAH, 0E9H);       (* fucompp *)
     OutByte3(09BH, 0DFH, 0E0H); (* fstsw ax *)
     OutByte(09EH);              (* sahf *)
-    movrc(eax, 0)
+    OutByte(0B8H); OutInt(0)    (* mov eax, 0 *)
 END fcmp;
 PROCEDURE translate (pic: BOOLEAN; stroffs: INTEGER);
 VAR
     cmd, next: COMMAND;
-    reg1, reg2: INTEGER;
+    reg1, reg2, fr: INTEGER;
     n, a, b, label, cc: INTEGER;
+    opcode, param1, param2: INTEGER;
-    opcode, param1, param2: INTEGER;
+    float: REAL;
-    float: REAL;
+BEGIN
             OutByte2(0FFH, 0D0H + reg1);  (* call reg1 *)
             drop;
             ASSERT(R.top = -1)
         |IL.opPRECALL:
-            n := param2;
+            PushAll(0);
-            IF (param1 # 0) & (n # 0) THEN
+            IF (param2 # 0) & (fr >= 0) THEN
                 subrc(esp, 8)
+            END;
+            INC(FR[0]);
-            END;
+            FR[FR[0]] := fr + 1;
-            WHILE n > 0 DO
+            WHILE fr >= 0 DO
                 subrc(esp, 8);
                 OutByte3(0DDH, 01CH, 024H); (* fstp qword[esp] *)
-                DEC(n)
+                DEC(fr)
             END;
-            PushAll(0)
+            ASSERT(fr = -1)
         |IL.opALIGN16:
             ASSERT(eax IN R.regs);
             IF n > 0 THEN
                 subrc(esp, n)
             END;
             push(eax)
-        |IL.opRES:
+        |IL.opRESF, IL.opRES:
-            ASSERT(R.top = -1);
-            GetRegA;
-            n := param2;
+            ASSERT(R.top = -1);
-            WHILE n > 0 DO
-                OutByte3(0DDH, 004H, 024H); (* fld qword[esp] *)
-                addrc(esp, 8);
+            ASSERT(fr = -1);
-                DEC(n)
-            END
+            n := FR[FR[0]]; DEC(FR[0]);
-        |IL.opRESF:
+            IF opcode = IL.opRESF THEN
-            n := param2;
+                INC(fr);
-            IF n > 0 THEN
+                IF n > 0 THEN
+                    OutByte3(0DDH, 5CH + long(n * 8), 24H);
-                OutByte3(0DDH, 5CH + long(n * 8), 24H);
+                    OutIntByte(n * 8); (* fstp qword[esp + n*8] *)
-                OutIntByte(n * 8); (* fstp qword[esp + n*8] *)
+                    DEC(fr);
+                    INC(n)
+                END;
+                IF fr + n > MAX_FR THEN
+                    ERRORS.ErrorMsg(fname, param1, param2, FPR_ERR)
+                END
+            ELSE
-                INC(n)
+                GetRegA
             END;
+            WHILE n > 0 DO
-            WHILE n > 0 DO
+                OutByte3(0DDH, 004H, 024H); (* fld qword[esp] *)
-                OutByte3(0DDH, 004H, 024H); (* fld qword[esp] *)
+                addrc(esp, 8);
-                addrc(esp, 8);
+                INC(fr);
                 DEC(n)
                 drop
             END;
+            ASSERT(R.top = -1);
+            IF opcode = IL.opLEAVEF THEN
+                DEC(fr)
+            END;
-            ASSERT(R.top = -1);
+            ASSERT(fr = -1);
             IF param1 > 0 THEN
                 mov(esp, ebp)
                 ASSERT(R.top + 1 <= n);
                 PushAll(n)
             END
-        |IL.opCLEANUP:
-            n := param2 * 4;
+        |IL.opCLEANUP:
-            IF n # 0 THEN
+            IF param2 # 0 THEN
-                addrc(esp, n)
+                addrc(esp, param2 * 4)
             END
             movrc(GetAnyReg(), param2)
         |IL.opLABEL:
             SetLabel(param1) (* L: *)
+        |IL.opNOP, IL.opAND, IL.opOR:
+        |IL.opGADR:
+            next := cmd.next(COMMAND);
+            IF next.opcode = IL.opADDC THEN
-        |IL.opNOP:
+                INC(param2, next.param2);
                 cmd := next
-        |IL.opGADR:
+            END;
             reg1 := GetAnyReg();
             IF pic THEN
                 Pic(reg1, BIN.PICBSS, param2)
             ELSE
                 OutByte(0B8H + reg1);  (* mov reg1, _bss + param2 *)
+                Reloc(BIN.RBSS, param2)
-                Reloc(BIN.RBSS, param2)
+            END
+        |IL.opLADR:
+            next := cmd.next(COMMAND);
+            n := param2 * 4;
-            END
+            IF next.opcode = IL.opADDC THEN
                 INC(n, next.param2);
-        |IL.opLADR:
+                cmd := next
-            n := param2 * 4;
+            END;
             UnOp(reg1);
             OutByte3(66H, 0C7H, reg1); OutWord(param2 MOD 65536);  (* mov word[reg1], param2 *)
             drop
-        |IL.opVLOAD32:
-            n := param2 * 4;
+        |IL.opVLOAD32:
             reg1 := GetAnyReg();
             movrm(reg1, ebp, param2 * 4);
             movrm(reg1, reg1, 0)
         |IL.opADD:
             BinOp(reg1, reg2);
             add(reg1, reg2);
             drop
-        |IL.opADDL, IL.opADDR:
+        |IL.opADDC:
             IF param2 # 0 THEN
                 UnOp(reg1);
                 next := cmd.next(COMMAND);
                 CASE next.opcode OF
                 END
             END
         |IL.opSUB:
             BinOp(reg1, reg2);
-            OutByte2(29H, 0C0H + reg2 * 8 + reg1); (* sub reg1, reg2 *)
+            oprr(29H, reg1, reg2); (* sub reg1, reg2 *)
             drop
-        |IL.opSUBR, IL.opSUBL:
-            UnOp(reg1);
+        |IL.opSUBR, IL.opSUBL:
-            n := param2;
+            UnOp(reg1);
-            IF n = 1 THEN
+            IF param2 = 1 THEN
                 OutByte(48H + reg1) (* dec reg1 *)
-            ELSIF n = -1 THEN
+            ELSIF param2 = -1 THEN
                 OutByte(40H + reg1) (* inc reg1 *)
-            ELSIF n # 0 THEN
+            ELSIF param2 # 0 THEN
-                subrc(reg1, n)
+                subrc(reg1, param2)
             END;
             IF opcode = IL.opSUBL THEN
             drop;
             cc := 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(inv0(cc), next.param1);
                 cmd := next
             ELSE
             ELSE
                 setcc(setne, reg1)
             END;
             andrc(reg1, 1)
-        |IL.opACC:
-            IF (R.top # 0) OR (R.stk[0] # eax) THEN
-                PushAll(0);
-                GetRegA;
-                pop(eax);
-                DEC(R.pushed)
-            END
         |IL.opDROP:
             UnOp(reg1);
             drop
-        |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
             drop;
             drop
         |IL.opMULS:
             BinOp(reg1, reg2);
-            OutByte2(21H, 0C0H + reg2 * 8 + reg1); (* and reg1, reg2 *)
+            oprr(21H, reg1, reg2); (* and reg1, reg2 *)
             drop
         |IL.opMULSC:
             xor(reg1, reg2);
             drop
         |IL.opDIVSC:
-            UnOp(reg1);
-            OutByte2(81H + short(param2), 0F0H + reg1);  (* xor reg1, n *)
+            UnOp(reg1);
-            OutIntByte(param2)
+            xorrc(reg1, param2)
         |IL.opADDS:
             BinOp(reg1, reg2);
-            OutByte2(9H, 0C0H + reg2 * 8 + reg1); (* or reg1, reg2 *)
+            oprr(9H, reg1, reg2); (* or reg1, reg2 *)
             drop
         |IL.opSUBS:
             BinOp(reg1, reg2);
             not(reg2);
-            OutByte2(21H, 0C0H + reg2 * 8 + reg1); (* and reg1, reg2 *)
+            oprr(21H, reg1, reg2); (* and reg1, reg2 *)
             drop
-        |IL.opADDSL, IL.opADDSR:
+        |IL.opADDSC:
             drop
         |IL.opMAXC, IL.opMINC:
             UnOp(reg1);
+            cmprc(reg1, param2);
-            cmprc(reg1, param2);
+            label := NewLabel();
+            IF opcode = IL.opMINC THEN
+                cc := jle
+            ELSE
+                cc := jge
+            END;
-            OutByte2(07DH + ORD(opcode = IL.opMINC), 5);  (* jge/jle L *)
+            jcc(cc, label);
-            movrc(reg1, param2)
+            movrc(reg1, param2);
-            (* L: *)
+            SetLabel(label)
         |IL.opIN, IL.opINR:
             IF opcode = IL.opINR THEN
             OutByte2(0DBH, 018H + reg2);  (* fistp dword[reg2] *)
             drop;
             drop
+        |IL.opPUSHF:
+            ASSERT(fr >= 0);
-        |IL.opPUSHF:
+            DEC(fr);
             subrc(esp, 8);
             OutByte3(0DDH, 01CH, 024H)    (* fstp qword[esp] *)
+        |IL.opLOADF:
+            INC(fr);
+            IF fr > MAX_FR THEN
                 ERRORS.ErrorMsg(fname, param1, param2, FPR_ERR)
-        |IL.opLOADF:
+            END;
             UnOp(reg1);
             OutByte2(0DDH, reg1);         (* fld qword[reg1] *)
+            drop
+        |IL.opCONSTF:
+            INC(fr);
-            drop
+            IF fr > MAX_FR THEN
                 ERRORS.ErrorMsg(fname, param1, param2, FPR_ERR)
-        |IL.opCONSTF:
+            END;
             float := cmd.float;
             IF float = 0.0 THEN
                 OutByte3(0DDH, 004H, 024H); (* fld qword[esp] *)
                 addrc(esp, 8)
             END
+        |IL.opSAVEF, IL.opSAVEFI:
+            ASSERT(fr >= 0);
-        |IL.opSAVEF, IL.opSAVEFI:
+            DEC(fr);
             UnOp(reg1);
             OutByte2(0DDH, 018H + reg1); (* fstp qword[reg1] *)
             drop
+        |IL.opADDF:
             ASSERT(fr >= 1);
-        |IL.opADDF, IL.opADDFI:
+            DEC(fr);
+            OutByte2(0DEH, 0C1H)  (* faddp st1, st *)
-            OutByte2(0DEH, 0C1H)  (* faddp st1, st *)
+        |IL.opSUBF:
             ASSERT(fr >= 1);
+            DEC(fr);
+            OutByte2(0DEH, 0E9H)  (* fsubp st1, st *)
         |IL.opSUBF:
-            OutByte2(0DEH, 0E9H)  (* fsubp st1, st *)
+        |IL.opSUBFI:
+            ASSERT(fr >= 1);
+            DEC(fr);
             OutByte2(0DEH, 0E1H)  (* fsubrp st1, st *)
         |IL.opSUBFI:
+        |IL.opMULF:
+            ASSERT(fr >= 1);
-            OutByte2(0DEH, 0E1H)  (* fsubrp st1, st *)
+            DEC(fr);
             OutByte2(0DEH, 0C9H)  (* fmulp st1, st *)
+        |IL.opDIVF:
-        |IL.opMULF:
+            ASSERT(fr >= 1);
-            OutByte2(0DEH, 0C9H)  (* fmulp st1, st *)
+            DEC(fr);
+            OutByte2(0DEH, 0F9H)  (* fdivp st1, st *)
-        |IL.opDIVF:
+        |IL.opDIVFI:
+            ASSERT(fr >= 1);
-            OutByte2(0DEH, 0F9H)  (* fdivp st1, st *)
+            DEC(fr);
             OutByte2(0DEH, 0F1H)  (* fdivrp st1, st *)
+        |IL.opUMINF:
+            ASSERT(fr >= 0);
+            OutByte2(0D9H, 0E0H)  (* fchs *)
         |IL.opDIVFI:
-            OutByte2(0DEH, 0F1H)  (* fdivrp st1, st *)
+        |IL.opFABS:
             ASSERT(fr >= 0);
-        |IL.opUMINF:
+            OutByte2(0D9H, 0E1H)  (* fabs *)
             OutByte2(0D9H, 0E0H)  (* fchs *)
         |IL.opFLT:
+            INC(fr);
+            IF fr > MAX_FR THEN
-        |IL.opFABS:
+                ERRORS.ErrorMsg(fname, param1, param2, FPR_ERR)
-            OutByte2(0D9H, 0E1H)  (* fabs *)
+            END;
             UnOp(reg1);
-        |IL.opFLT:
+            push(reg1);
-            UnOp(reg1);
+            OutByte3(0DBH, 004H, 024H); (* fild dword[esp] *)
             pop(GetAnyReg());
             OutByte2(0D9H, 06CH); OutByte2(024H, 002H);                         (* fldcw word[esp+2]                    *)
             addrc(esp, 4)
+        |IL.opEQF:
+            ASSERT(fr >= 1);
-        |IL.opEQF:
+            DEC(fr, 2);
             fcmp;
             OutByte2(07AH, 003H);       (* jp L *)
             setcc(sete, al)
                                         (* L: *)
+        |IL.opNEF:
             ASSERT(fr >= 1);
-        |IL.opNEF:
+            DEC(fr, 2);
             fcmp;
             OutByte2(07AH, 003H);       (* jp L *)
             setcc(setne, al)
+                                        (* L: *)
-                                        (* L: *)
+        |IL.opLTF:
             ASSERT(fr >= 1);
-        |IL.opLTF:
+            DEC(fr, 2);
             fcmp;
             OutByte2(07AH, 00EH);       (* jp L *)
             setcc(setc, al);
             setcc(sete, ah);
             test(eax);
             setcc(sete, al);
+            andrc(eax, 1)
+                                        (* L: *)
             andrc(eax, 1)
-                                        (* L: *)
+        |IL.opGTF:
             ASSERT(fr >= 1);
-        |IL.opGTF:
+            DEC(fr, 2);
             fcmp;
             OutByte2(07AH, 00FH);       (* jp L *)
             setcc(setc, al);
             setcc(sete, ah);
             cmprc(eax, 1);
+            setcc(sete, al);
+            andrc(eax, 1)
-            setcc(sete, al);
+                                        (* L: *)
             andrc(eax, 1)
-                                        (* L: *)
+        |IL.opLEF:
             ASSERT(fr >= 1);
-        |IL.opLEF:
+            DEC(fr, 2);
+            fcmp;
+            OutByte2(07AH, 003H);       (* jp L *)
-            fcmp;
+            setcc(setnc, al)
-            OutByte2(07AH, 003H);       (* jp L *)
+                                        (* L: *)
             setcc(setnc, al)
-                                        (* L: *)
+        |IL.opGEF:
             ASSERT(fr >= 1);
             setcc(sete, al);
             andrc(eax, 1)
                                         (* L: *)
+        |IL.opINF:
+            INC(fr);
+            IF fr > MAX_FR THEN
+                ERRORS.ErrorMsg(fname, param1, param2, FPR_ERR)
-        |IL.opINF:
+            END;
             pushc(7FF00000H);
             pushc(0);
             OutByte3(0DDH, 004H, 024H);  (* fld qword[esp] *)
             n := param1 * 4;
             OutByte3(0FH, 0BAH, 6DH + long(n) + 8 * ORD(opcode = IL.opLADR_EXCLC)); (* bts(r) dword[ebp + n], param2 *)
             OutIntByte(n);
             OutByte(param2)
+        |IL.opFNAME:
+            fname := cmd(IL.FNAMECMD).fname
         |IL.opLOOP, IL.opENDLOOP:
         END;
         cmd := cmd.next(COMMAND)
-    END;
+    END;
     ASSERT(R.pushed = 0);
-    ASSERT(R.top = -1)
+    ASSERT(R.top = -1);
     ASSERT(fr = -1)
 END translate;
 PROCEDURE prolog (pic: BOOLEAN; target, stack, dllinit, dllret: INTEGER);
+PROCEDURE prolog (pic: BOOLEAN; target, stack, dllinit, dllret: INTEGER);
 VAR
     reg1, entry, L, dcount: INTEGER;
 BEGIN
     entry := NewLabel();
-    entry := NewLabel();
+    SetLabel(entry);
-    SetLabel(entry);
+    dcount := CHL.Length(IL.codes.data);
     IF target = TARGETS.Win32DLL THEN
+        push(ebp);
-        push(ebp);
+        mov(ebp, esp);
-        mov(ebp, esp);
+        pushm(ebp, 16);
+        pushm(ebp, 12);
-        pushm(ebp, 16);
+        pushm(ebp, 8);
-        pushm(ebp, 12);
-        pushm(ebp, 8);
+        CallRTL(pic, IL._dllentry);
-        CallRTL(pic, IL._dllentry);
+        test(eax);
-        test(eax);
+        jcc(je, dllret);
-        jcc(je, dllret)
+        pushc(0)
     ELSIF target = TARGETS.KolibriOSDLL THEN
-        SetLabel(dllinit)
-    END;
-    IF target = TARGETS.KolibriOS THEN
+        SetLabel(dllinit);
-        reg1 := GetAnyReg();
+        OutByte(68H);  (* push IMPORT *)
-        Pic(reg1, BIN.IMPTAB, 0);
+        Reloc(BIN.IMPTAB, 0)
-        push(reg1);    (* push IMPORT *)
+    ELSIF target = TARGETS.KolibriOS THEN
-        drop
+        reg1 := GetAnyReg();
-    ELSIF target = TARGETS.KolibriOSDLL THEN
+        Pic(reg1, BIN.IMPTAB, 0);
-        OutByte(68H);  (* push IMPORT *)
+        push(reg1);    (* push IMPORT *)
-        Reloc(BIN.IMPTAB, 0)
+        drop
     ELSIF target = TARGETS.Linux32 THEN
-        push(esp)
-    ELSE
-        pushc(0)
-    END;
-    IF pic THEN
-        reg1 := GetAnyReg();
-        Pic(reg1, BIN.PICCODE, entry);
-        push(reg1);     (* push CODE *)
+        push(esp)
-        drop
+    ELSE
-    ELSE
-        OutByte(68H);  (* push CODE *)
-        Reloc(BIN.RCODE, entry)
-    END;
-    IF pic THEN
-        reg1 := GetAnyReg();
-        Pic(reg1, BIN.PICDATA, 0);
-        push(reg1);    (* push _data *)
+        pushc(0)
-        drop
-    ELSE
-        OutByte(68H);  (* push _data *)
-        Reloc(BIN.RDATA, 0)
+    END;
     END;
     IF pic THEN
-    dcount := CHL.Length(IL.codes.data);
+        reg1 := GetAnyReg();
+        Pic(reg1, BIN.PICCODE, entry);
+        push(reg1);    (* push CODE *)
         Pic(reg1, BIN.PICDATA, 0);
+        push(reg1);    (* push _data *)
+        pushc(tcount);
+        Pic(reg1, BIN.PICDATA, tcount * 4 + dcount);
-    pushc(tcount);
+        push(reg1);    (* push _data + tcount * 4 + dcount *)
         drop
-    IF pic THEN
+    ELSE
-        reg1 := GetAnyReg();
+        OutByte(68H);  (* push CODE *)
-        Pic(reg1, BIN.PICDATA, tcount * 4 + dcount);
+        Reloc(BIN.RCODE, entry);
-        push(reg1);    (* push _data + tcount * 4 + dcount *)
+        OutByte(68H);  (* push _data *)
-        drop
+        Reloc(BIN.RDATA, 0);
-    ELSE
+        pushc(tcount);
-        OutByte(68H);  (* push _data *)
+        OutByte(68H);  (* push _data + tcount * 4 + dcount *)
     path, name, ext: PATHS.PATH;
     dcount, i: INTEGER;
-    PROCEDURE import (imp: LISTS.LIST);
+    PROCEDURE _import (imp: LISTS.LIST);
     VAR
                 proc := proc.next(IL.IMPORT_PROC)
             END;
             lib := lib.next(IL.IMPORT_LIB)
         END
-    END import;
+    END _import;
     WHILE exp # NIL DO
         BIN.Export(program, exp.name, exp.label);
         exp := exp.next(IL.EXPORT_PROC)
     END;
-    import(IL.codes.import);
+    _import(IL.codes._import);
-    IL.set_bss(MAX(IL.codes.bss, MAX(IL.codes.dmin - CHL.Length(IL.codes.data), 4)));
     IL.set_bss(MAX(IL.codes.bss, MAX(IL.codes.dmin - CHL.Length(IL.codes.data), 4)));
     BIN.SetParams(program, IL.codes.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* (outname: ARRAY OF CHAR; target: INTEGER; options: PROG.OPTIONS);
-PROCEDURE CodeGen* (outname: ARRAY OF CHAR; target: INTEGER; options: PROG.OPTIONS);
+VAR
-VAR
+    dllret, dllinit, sofinit: INTEGER;
-    dllret, dllinit, sofinit: INTEGER;
+    opt: PROG.OPTIONS;

Subversion Repositories Kolibri OS

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