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

 (*
-    Copyright 2016, 2017, 2018 Anton Krotov
+    BSD 2-Clause License
-    This file is part of Compiler.
-    Compiler is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
+    Copyright (c) 2018, 2019, Anton Krotov
-    (at your option) any later version.
-    Compiler is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-    You should have received a copy of the GNU General Public License
-    along with Compiler. If not, see .
+    All rights reserved.
 *)
-MODULE X86;
+MODULE X86;
-IMPORT UTILS, sys := SYSTEM, SCAN, ELF;
-CONST
+IMPORT CODE, REG, UTILS, LISTS, BIN, PE32, KOS, MSCOFF, ELF, mConst := CONSTANTS, MACHINE, CHL := CHUNKLISTS, PATHS;
-  ADIM* = 5;
-  lxPlus = 51; lxMinus = 52; lxMult = 53; lxSlash = 54;
-  lxEQ = 71; lxNE = 72; lxLT = 73; lxGT = 74; lxLE = 75; lxGE = 76;
-  TINTEGER = 1; TREAL = 2; TLONGREAL = 3; TCHAR = 4; TSET = 5; TBOOLEAN = 6; TVOID = 7;
-  TNIL = 8; TCARD16 = 9; TSTRING = 10; TARRAY = 11; TRECORD = 12; TPOINTER = 13; TPROC = 14;
+CONST
-  stABS* = 1; stODD* = 2; stLEN* = 3; stLSL* = 4; stASR* = 5; stROR* = 6; stFLOOR* = 7;
-  stFLT* = 8; stORD* = 9; stCHR* = 10; stLONG* = 11; stSHORT* = 12; stINC* = 13;
-  stDEC* = 14; stINCL* = 15; stEXCL* = 16; stCOPY* = 17; stNEW* = 18; stASSERT* = 19;
+    eax = REG.R0; ecx = REG.R1; edx = REG.R2;
-  stPACK* = 20; stUNPK* = 21; stDISPOSE* = 22; stFABS* = 23; stINC1* = 24;
-  stDEC1* = 25; stASSERT1* = 26; stUNPK1* = 27; stPACK1* = 28; stLSR* = 29;
-  stLENGTH* = 30; stMIN* = 31; stMAX* = 32;
-  sysMOVE* = 108;
-  JMP* = 0E9X; CALL = 0E8X;
-  JE = 84X; JNE = 85X; JLE = 8EX; JGE = 8DX; JG = 8FX; JL = 8CX;
     al = eax; cl = ecx; dl = edx; ah = 4;
+    ax = eax; cx = ecx; dx = edx;
-  JCMD = 1; LCMD = 2; GCMD = 3; OCMD = 4; ECMD = 5;
+    esp = 4;
+    ebp = 5;
-  PUSHEAX = 6; PUSHECX = 7; PUSHEDX = 8; POPEAX = 9; POPECX = 10; POPEDX = 11;
+    sete = 94H; setne = 95H; setl = 9CH; setge = 9DH; setle = 9EH; setg = 9FH; setc = 92H; setnc = 93H;
   ICMP1 = 13; ICMP2 = 14;
+    je = 84H; jne = 85H; jl = 8CH; jge = 8DH; jle = 8EH; jg = 8FH; jb = 82H; jnb = 83H;
+    CODECHUNK = 8;
-  defcall = 0; stdcall = 1; cdecl = 2; winapi = 3;
+TYPE
-  _rset* = 0; _inset* = 1; _saverec* = 2; _length* = 3; _checktype* = 4; _strcmp* = 5;
-  _lstrcmp* = 6; _rstrcmp* = 7; _savearr* = 8; _newrec* = 9; _disprec* = 10; _arrayidx* = 11;
-  _arrayrot* = 12; _assrt* = 13; _strcopy* = 14; _arrayidx1* = 15; _init* = 16; _close* = 17; _halt* = 18;
-  ASSRT = 19; hInstance = 20; SELFNAME = 21; RTABLE = 22;LoadLibrary = 23; GetProcAddress = 24;
+    COMMAND = CODE.COMMAND;
-  Exports = 25; szSTART = 26; START = 27; szversion = 28; _floor = 29; HALT = 30;
-  FREGS = 8;
-TYPE
-  ASMLINE* = POINTER TO RECORD (UTILS.rITEM)
-    cmd, clen, varadr, adr, tcmd, codeadr: INTEGER; short: BOOLEAN
-  END;
+    ANYCODE = POINTER TO RECORD (LISTS.ITEM)
-  TFLT = ARRAY 2 OF INTEGER;
-  TIDX* = ARRAY ADIM OF INTEGER;
+        offset: INTEGER
-  SECTIONNAME = ARRAY 8 OF CHAR;
+    END;
-  SECTION = RECORD
-    name: SECTIONNAME;
-    size, adr, sizealign, OAPfile, reserved6, reserved7, reserved8, attrflags: INTEGER
-  END;
-  HEADER = RECORD
-    msdos: ARRAY 180 OF CHAR;
-    typecomp, seccount: sys.CARD16;
+    TCODE = POINTER TO RECORD (ANYCODE)
-    time, reserved1, reserved2: INTEGER;
+        code:    ARRAY CODECHUNK OF BYTE;
-    PEoptsize, infflags, PEfile, compver: sys.CARD16;
+        length:  INTEGER
-    codesize, datasize, initdatasize, startadr,
-    codeadr, rdataadr, loadadr, secalign, filealign,
+    END;
-    oldestver, version, oldestverNT, reserved3,
-    filesize, headersize, dllcrc: INTEGER;
-    UI, reserved4: sys.CARD16;
-    stksize, stkalloc, heapsize, heapalloc, reserved5, structcount: INTEGER;
-    structs: ARRAY 16 OF RECORD adr, size: INTEGER END;
-    sections: ARRAY 3 OF SECTION
-  END;
+    LABEL = POINTER TO RECORD (ANYCODE)
-  COFFHEADER = RECORD
+        label: INTEGER
-    Machine: sys.CARD16;
+    END;
-    NumberOfSections: sys.CARD16;
-    TimeDateStamp,
+    JUMP = POINTER TO RECORD (ANYCODE)
-    PointerToSymbolTable,
-    NumberOfSymbols: INTEGER;
-    SizeOfOptionalHeader,
-    Characteristics: sys.CARD16;
-    text, data, bss: SECTION
-  END;
-  KOSHEADER = RECORD
-    menuet01: ARRAY 8 OF CHAR;
-    ver, start, size, mem, sp, param, path: INTEGER
+        label, diff: INTEGER;
+        short: BOOLEAN
+    END;
+    JMP = POINTER TO RECORD (JUMP)
+    END;
+    JCC = POINTER TO RECORD (JUMP)
+        jmp: INTEGER
-  END;
+    END;
+    CALL = POINTER TO RECORD (JUMP)
+    END;
+    RELOC = POINTER TO RECORD (ANYCODE)
+        op, value: INTEGER
     END;
+VAR
+    R: REG.REGS;
+    program: BIN.PROGRAM;
+    CodeList: LISTS.LIST;
-  ETABLE = RECORD
+PROCEDURE Byte (n: INTEGER): BYTE;
+    RETURN MACHINE.Byte(n, 0)
-    reserved1, time, reserved2, dllnameoffset, firstnum, adrcount,
+END Byte;
-    namecount, arradroffset, arrnameptroffset, arrnumoffset: INTEGER;
-    arradr, arrnameptr: ARRAY 10000H OF INTEGER;
+PROCEDURE Word (n: INTEGER): INTEGER;
+    RETURN MACHINE.Byte(n, 0) + MACHINE.Byte(n, 1) * 256
+END Word;
-    arrnum: ARRAY 10000H OF sys.CARD16;
-    text: ARRAY 1000000 OF CHAR;
+PROCEDURE OutByte* (n: BYTE);
+VAR
-    textlen, size: INTEGER
+    c: TCODE;
-  END;
     last: ANYCODE;
-  RELOC = RECORD
-    Page, Size: INTEGER;
+BEGIN
-    reloc: ARRAY 1024 OF sys.CARD16
+    last := CodeList.last(ANYCODE);
-  END;
+    IF (last IS TCODE) & (last(TCODE).length < CODECHUNK) THEN
         c := last(TCODE);
-VAR asmlist: UTILS.LIST; start: ASMLINE; dll, con, gui, kos, elf, obj, kem: BOOLEAN;
-    Lcount, reccount, topstk: INTEGER; recarray: ARRAY 2048 OF INTEGER; current*: ASMLINE;
-    callstk: ARRAY 1024, 2 OF ASMLINE; OutFile: UTILS.STRING;
+        c.code[c.length] := n;
-    Code: ARRAY 4000000 OF CHAR; ccount: INTEGER; Data: ARRAY 1000000 OF CHAR; dcount: INTEGER;
-    Labels: ARRAY 200000 OF INTEGER; rdata: ARRAY 400H OF INTEGER; Header: HEADER; etable: ETABLE;
-    ExecName: UTILS.STRING; LoadAdr: INTEGER; Reloc: ARRAY 200000 OF CHAR; rcount: INTEGER;
-    RtlProc: ARRAY 20 OF INTEGER; OutFilePos: INTEGER; RelocSection: SECTION;
-    fpu*: INTEGER; isfpu: BOOLEAN; maxfpu: INTEGER; fpucmd: ASMLINE;
-    kosexp: ARRAY 65536 OF RECORD Name: SCAN.NODE; Adr, NameLabel: INTEGER END; kosexpcount: INTEGER;
-    maxstrlen*: INTEGER;
-PROCEDURE set_maxstrlen* (value: INTEGER);
-BEGIN
-    maxstrlen := value
-END set_maxstrlen;
-PROCEDURE AddRtlProc*(idx, proc: INTEGER);
-BEGIN
-  RtlProc[idx] := proc
-END AddRtlProc;
-PROCEDURE IntToCard16(i: INTEGER): sys.CARD16;
-VAR w: sys.CARD16;
-BEGIN
-  sys.GET(sys.ADR(i), w)
-  RETURN w
-END IntToCard16;
-PROCEDURE CopyStr(VAR Dest: ARRAY OF CHAR; Source: ARRAY OF CHAR; VAR di: INTEGER; si: INTEGER);
-BEGIN
-  DEC(di);
-  REPEAT
-    INC(di);
-    Dest[di] := Source[si];
-    INC(si)
-  UNTIL Dest[di] = 0X
+        INC(c.length)
-END CopyStr;
-PROCEDURE exch(VAR a, b: INTEGER);
+    ELSE
-VAR c: INTEGER;
-BEGIN
-  c := a;
-  a := b;
-  b := c
-END exch;
-PROCEDURE Sort(VAR NamePtr, Adr: ARRAY OF INTEGER; Text: ARRAY OF CHAR; LB, RB: INTEGER);
-VAR L, R: INTEGER;
-  PROCEDURE strle(s1, s2: INTEGER): BOOLEAN;
-  VAR S1, S2: ARRAY 256 OF CHAR; i: INTEGER;
-  BEGIN
-    i := 0;
+        NEW(c);
-    CopyStr(S1, Text, i, s1);
-    i := 0;
-    CopyStr(S2, Text, i, s2)
-    RETURN S1 <= S2
-  END strle;
-BEGIN
-  IF LB < RB THEN
-    L := LB;
-    R := RB;
-    REPEAT
-      WHILE (L < RB) & strle(NamePtr[L], NamePtr[LB]) DO
-        INC(L)
-      END;
-      WHILE (R > LB) & strle(NamePtr[LB], NamePtr[R]) DO
-        DEC(R)
-      END;
-      IF L < R THEN
-        exch(NamePtr[L], NamePtr[R]);
-        exch(Adr[L], Adr[R])
-      END
+        c.code[0] := n;
-    UNTIL L >= R;
-    IF R > LB THEN
-      exch(NamePtr[LB], NamePtr[R]);
-      exch(Adr[LB], Adr[R]);
-      Sort(NamePtr, Adr, Text, LB, R - 1)
-    END;
-    Sort(NamePtr, Adr, Text, R + 1, RB)
-  END
-END Sort;
-PROCEDURE PackExport(Name: ARRAY OF CHAR);
-VAR i: INTEGER;
-BEGIN
-  Sort(etable.arrnameptr, etable.arradr, etable.text, 0, etable.namecount - 1);
-  FOR i := 0 TO etable.namecount - 1 DO
-    etable.arrnum[i] := IntToCard16(i)
-  END;
+        c.length  := 1;
-  etable.size := 40 + etable.adrcount * 4 + etable.namecount * 6;
+        LISTS.push(CodeList, c)
+    END
-  etable.arradroffset := 40;
+END OutByte;
+PROCEDURE OutInt (n: INTEGER);
-  etable.arrnameptroffset := 40 + etable.adrcount * 4;
+BEGIN
+    OutByte(MACHINE.Byte(n, 0));
+    OutByte(MACHINE.Byte(n, 1));
+    OutByte(MACHINE.Byte(n, 2));
+    OutByte(MACHINE.Byte(n, 3))
+END OutInt;
+PROCEDURE OutByte2 (a, b: BYTE);
+BEGIN
-  etable.arrnumoffset := etable.arrnameptroffset + etable.namecount * 4;
+    OutByte(a);
+    OutByte(b)
+END OutByte2;
+PROCEDURE OutByte3 (a, b, c: BYTE);
+BEGIN
+    OutByte(a);
-  etable.dllnameoffset := etable.size + etable.textlen;
+    OutByte(b);
-  CopyStr(etable.text, Name, etable.textlen, 0);
-  INC(etable.textlen);
-  FOR i := 0 TO etable.namecount - 1 DO
-    etable.arrnameptr[i] := etable.arrnameptr[i] + etable.size
-  END;
-  etable.size := etable.size + etable.textlen
-END PackExport;
-PROCEDURE ProcExport*(Number: INTEGER; Name: SCAN.NODE; NameLabel: INTEGER);
-BEGIN
-  IF dll THEN
-    etable.arradr[etable.adrcount] := Number;
-    INC(etable.adrcount);
-    etable.arrnameptr[etable.namecount] := etable.textlen;
-    INC(etable.namecount);
-    CopyStr(etable.text, Name.Name, etable.textlen, 0);
-    INC(etable.textlen)
-  ELSIF obj THEN
-    kosexp[kosexpcount].Name := Name;
+    OutByte(c)
-    kosexp[kosexpcount].Adr := Number;
+END OutByte3;
-    kosexp[kosexpcount].NameLabel := NameLabel;
-    INC(kosexpcount)
-  END
-END ProcExport;
-PROCEDURE Err(code: INTEGER);
-BEGIN
-  CASE code OF
-  |1: UTILS.ErrMsg(67); UTILS.OutString(OutFile)
-  |2: UTILS.ErrMsg(69); UTILS.OutString(OutFile)
-  ELSE
-  END;
-  UTILS.Ln;
-  UTILS.HALT(1)
-END Err;
-PROCEDURE Align*(n, m: INTEGER): INTEGER;
-  RETURN n + (m - n MOD m) MOD m
-END Align;
-PROCEDURE PutReloc(R: RELOC);
-VAR i: INTEGER;
-BEGIN
-  sys.PUT(sys.ADR(Reloc[rcount]), R.Page);
-  INC(rcount, 4);
-  sys.PUT(sys.ADR(Reloc[rcount]), R.Size);
-  INC(rcount, 4);
-  FOR i := 0 TO ASR(R.Size - 8, 1) - 1 DO
-    sys.PUT(sys.ADR(Reloc[rcount]), R.reloc[i]);
-    INC(rcount, 2)
-  END
-END PutReloc;
-PROCEDURE InitArray(VAR adr: INTEGER; chars: UTILS.STRING);
-VAR i, x, n: INTEGER;
-BEGIN
-  n := LEN(chars) - 1;
-  i := 0;
-  WHILE (i < n) & (chars[i] # 0X) DO
-    x := SCAN.hex(chars[i]) * 16 + SCAN.hex(chars[i + 1]);
-    sys.PUT(adr, CHR(x));
-    INC(adr);
-    INC(i, 2)
-  END
-END InitArray;
-PROCEDURE WriteF(F, A, N: INTEGER);
-BEGIN
-  IF UTILS.Write(F, A, N) # N THEN
-    Err(2)
-  END
-END WriteF;
-PROCEDURE Write(A, N: INTEGER);
-BEGIN
-  sys.MOVE(A, OutFilePos, N);
-  OutFilePos := OutFilePos + N
-END Write;
-PROCEDURE Fill(n: INTEGER; c: CHAR);
-VAR i: INTEGER;
-BEGIN
-  FOR i := 1 TO n DO
-    Write(sys.ADR(c), 1)
-  END
-END Fill;
-PROCEDURE SetSection(VAR Section: SECTION; name: SECTIONNAME; size, adr, sizealign, OAPfile, attrflags: INTEGER);
-BEGIN
-  Section.name := name;
-  Section.size := size;
-  Section.adr := adr;
-  Section.sizealign := sizealign;
-  Section.OAPfile := OAPfile;
-  Section.attrflags := attrflags;
-END SetSection;
-PROCEDURE WritePE(FName: ARRAY OF CHAR; stksize, codesize, datasize, rdatasize, gsize: INTEGER);
-CONST textattr = 60000020H; rdataattr = 40000040H; dataattr = 0C0000040H; relocattr = 42000040H;
-VAR i, F, adr, acodesize, compver, version, stkalloc, heapsize, heapalloc, filesize, filebuf: INTEGER;
-    cur: ASMLINE;
-BEGIN
-  compver := 0;
-  version := 0;
-  stkalloc := stksize;
-  heapsize := 100000H;
-  heapalloc := 100000H;
-  acodesize := Align(codesize, 1000H) + 1000H;
-  adr := sys.ADR(rdata);
-  filesize := acodesize + Align(rdatasize, 1000H) + Align(datasize, 1000H) + Align(rcount, 1000H);
-  InitArray(adr, "5000000040000000000000003400000000000000000000006200000000000000");
-  InitArray(adr, "0000000000000000000000000000000000000000500000004000000000000000");
-  InitArray(adr, "A4014C6F61644C6962726172794100001F0147657450726F6341646472657373");
-  InitArray(adr, "00006B65726E656C33322E646C6C0000");
-  rdata[ 0] := acodesize + 50H;
-  rdata[ 1] := acodesize + 40H;
-  rdata[ 3] := acodesize + 34H;
-  rdata[ 6] := acodesize + 62H;
-  rdata[ 7] := acodesize;
-  rdata[13] := acodesize + 50H;
-  rdata[14] := acodesize + 40H;
-  adr := sys.ADR(Header.msdos);
-  InitArray(adr, "4D5A90000300000004000000FFFF0000B8000000000000004000000000000000");
-  InitArray(adr, "00000000000000000000000000000000000000000000000000000000B0000000");
-  InitArray(adr, "0E1FBA0E00B409CD21B8014CCD21546869732070726F6772616D2063616E6E6F");
-  InitArray(adr, "742062652072756E20696E20444F53206D6F64652E0D0D0A2400000000000000");
-  InitArray(adr, "5DCF9F8719AEF1D419AEF1D419AEF1D497B1E2D413AEF1D4E58EE3D418AEF1D4");
-  InitArray(adr, "5269636819AEF1D4000000000000000050450000");
-  Header.typecomp := IntToCard16(014CH);
-  IF dll THEN
-    Header.seccount := IntToCard16(0004H);
-    Header.infflags := IntToCard16(210EH)
-  ELSE
-    Header.seccount := IntToCard16(0003H);
-    Header.infflags := IntToCard16(010FH)
-  END;
-  Header.time := UTILS.Date;
-  Header.PEoptsize := IntToCard16(00E0H);
-  Header.PEfile := IntToCard16(010BH);
-  Header.compver := IntToCard16(compver);
-  Header.codesize := Align(codesize, 200H);
-  Header.datasize := Align(datasize + gsize, 200H) + Align(rdatasize, 200H) + Align(rcount, 200H);
-  Header.startadr := 1000H;
-  Header.codeadr := 1000H;
-  Header.rdataadr := Header.codeadr + Align(codesize, 1000H);
-  Header.loadadr := LoadAdr;
-  Header.secalign := 1000H;
-  Header.filealign := 0200H;
-  Header.oldestver := 0004H;
-  Header.version := version;
-  Header.oldestverNT := 0004H;
-  Header.filesize := Align(codesize, 1000H) + Align(datasize + gsize, 1000H) + Align(rdatasize, 1000H) + Align(rcount, 1000H) + 1000H;
-  Header.headersize := 0400H;
-  Header.UI := IntToCard16(ORD(con) + 2);
-  Header.stksize := stksize;
-  Header.stkalloc := stkalloc;
-  Header.heapsize := heapsize;
-  Header.heapalloc := heapalloc;
-  Header.structcount := 10H;
-  IF dll THEN
-    Header.structs[0].adr := Header.rdataadr + 0DAH;
-    Header.structs[0].size := etable.size
-  END;
-  Header.structs[1].adr := Header.rdataadr + 0CH;
-  Header.structs[1].size := 28H;
-  Header.structs[12].adr := Header.rdataadr;
-  Header.structs[12].size := 0CH;
-  SetSection(Header.sections[0], ".text", codesize, 1000H, Align(codesize, 200H), 400H, textattr);
-  SetSection(Header.sections[1], ".rdata", rdatasize, Align(codesize, 1000H) + 1000H, Align(rdatasize, 200H),
-    Align(codesize, 200H) + 400H, rdataattr);
-  SetSection(Header.sections[2], ".data", datasize + gsize, Align(codesize, 1000H) + Align(rdatasize, 1000H) + 1000H,
-    Align(datasize, 200H), Align(codesize, 200H) + Align(rdatasize, 200H) + 400H, dataattr);
-  IF dll THEN
-    SetSection(RelocSection, ".reloc", rcount, Header.sections[2].adr + Align(datasize + gsize, 1000H), Align(rcount, 200H),
-      Header.sections[2].OAPfile + Align(datasize, 200H), relocattr);
-    Header.structs[5].adr := RelocSection.adr;
-    Header.structs[5].size := rcount
-  END;
-  F := UTILS.CreateF(FName);
-  IF F = 0 THEN
-    Err(1)
-  END;
-  OutFilePos := UTILS.GetMem(filesize);
-  filebuf := OutFilePos;
-  UTILS.MemErr(OutFilePos = 0);
-  Write(sys.ADR(Header), sys.SIZE(HEADER));
-  IF dll THEN
-    Write(sys.ADR(RelocSection), sys.SIZE(SECTION));
-    Fill(Align(sys.SIZE(HEADER) + sys.SIZE(SECTION), 200H) - (sys.SIZE(HEADER) + sys.SIZE(SECTION)), 0X)
-  ELSE
-    Fill(Align(sys.SIZE(HEADER), 200H) - sys.SIZE(HEADER), 0X)
-  END;
-  cur := asmlist.First(ASMLINE);
-  WHILE cur # NIL DO
-    Write(sys.ADR(Code[cur.cmd]), cur.clen);
-    cur := cur.Next(ASMLINE)
-  END;
-  Fill(Align(codesize, 200H) - codesize, 0X);
-  Write(sys.ADR(rdata), 0DAH);
-  IF dll THEN
-    etable.time := Header.time;
-    Write(sys.ADR(etable), 40);
-    Write(sys.ADR(etable.arradr), etable.adrcount * 4);
-    Write(sys.ADR(etable.arrnameptr), etable.namecount * 4);
-    Write(sys.ADR(etable.arrnum), etable.namecount * 2);
-    Write(sys.ADR(etable.text), etable.textlen)
-  END;
-  Fill(Align(rdatasize, 200H) - rdatasize, 0X);
-  Write(sys.ADR(Data), datasize);
-  Fill(Align(datasize, 200H) - datasize, 0X);
-  IF dll THEN
-    Write(sys.ADR(Reloc), rcount);
-    Fill(Align(rcount, 200H) - rcount, 0X)
+PROCEDURE OutWord (n: INTEGER);
-  END;
+BEGIN
+    ASSERT((0 <= n) & (n <= 65535));
+    OutByte2(n MOD 256, n DIV 256)
+END OutWord;
-  WriteF(F, filebuf, OutFilePos - filebuf);
+PROCEDURE isByte (n: INTEGER): BOOLEAN;
-  UTILS.CloseF(F)
+    RETURN (-128 <= n) & (n <= 127)
+END isByte;
-END WritePE;
+PROCEDURE short (n: INTEGER): INTEGER;
+    RETURN 2 * ORD(isByte(n))
-PROCEDURE New;
+END short;
+PROCEDURE long (n: INTEGER): INTEGER;
+    RETURN 40H * ORD(~isByte(n))
+END long;
+PROCEDURE OutIntByte (n: INTEGER);
+BEGIN
+    IF isByte(n) THEN
+        OutByte(Byte(n))
+    ELSE
+        OutInt(n)
+    END
+END OutIntByte;
-VAR nov: ASMLINE;
+PROCEDURE shift* (op, reg: INTEGER);
 BEGIN
-  NEW(nov);
+    CASE op OF
-  UTILS.MemErr(nov = NIL);
-  nov.cmd := ccount;
+    |CODE.opASR, CODE.opASR1, CODE.opASR2: OutByte(0F8H + reg)
+    |CODE.opROR, CODE.opROR1, CODE.opROR2: OutByte(0C8H + reg)
-  UTILS.Insert(asmlist, nov, current);
+    |CODE.opLSL, CODE.opLSL1, CODE.opLSL2: OutByte(0E0H + reg)
-  current := current.Next(ASMLINE)
+    |CODE.opLSR, CODE.opLSR1, CODE.opLSR2: OutByte(0E8H + reg)
-END New;
+    END
-PROCEDURE Empty(varadr: INTEGER);
+END shift;
-BEGIN
-  New;
+PROCEDURE mov (reg1, reg2: INTEGER);
-  current.clen := 0;
+BEGIN
-  current.tcmd := ECMD;
+    OutByte2(89H, 0C0H + reg2 * 8 + reg1)  // mov reg1, reg2
-  current.varadr := varadr
+END mov;
-END Empty;
 PROCEDURE xchg (reg1, reg2: INTEGER);
-PROCEDURE OutByte(byte: INTEGER);
+VAR
-BEGIN
+    regs: SET;
-  New;
+BEGIN
-  current.clen := 1;
+    regs := {reg1, reg2};
-  Code[ccount] := CHR(byte);
+    IF regs = {eax, ecx} THEN
-  INC(ccount)
+        OutByte(91H)                // xchg eax, ecx
-END OutByte;
+    ELSIF regs = {eax, edx} THEN
+        OutByte(92H)                // xchg eax, edx
-PROCEDURE OutInt(int: INTEGER);
+    ELSIF regs = {ecx, edx} THEN
-BEGIN
+        OutByte2(87H, 0D1H)         // xchg ecx, edx
-  New;
+    END
-  current.clen := 4;
-  sys.PUT(sys.ADR(Code[ccount]), int);
+END xchg;
-  INC(ccount, 4)
-END OutInt;
 PROCEDURE pop (reg: INTEGER);
-PROCEDURE PushEAX;
-BEGIN
-  OutByte(50H);
-  current.tcmd := PUSHEAX
-END PushEAX;
+BEGIN
-PROCEDURE PushECX;
+    OutByte(58H + reg) // pop reg
+END pop;
-BEGIN
   OutByte(51H);
-  current.tcmd := PUSHECX
-END PushECX;
+PROCEDURE push (reg: INTEGER);
-PROCEDURE PushEDX;
-BEGIN
-  OutByte(52H);
+BEGIN
+    OutByte(50H + reg) // push reg
-  current.tcmd := PUSHEDX
+END push;
 END PushEDX;
-PROCEDURE PopEAX;
+PROCEDURE movrc (reg, n: INTEGER);
 BEGIN
+    OutByte(0B8H + reg); // mov reg, n
-  OutByte(58H);
+    OutInt(n)
-  current.tcmd := POPEAX
+END movrc;
-END PopEAX;
-PROCEDURE PopECX;
-BEGIN
-  OutByte(59H);
-  current.tcmd := POPECX
-END PopECX;
-PROCEDURE PopEDX;
-BEGIN
-  OutByte(5AH);
-  current.tcmd := POPEDX
-END PopEDX;
-PROCEDURE OutCode(cmd: UTILS.STRING);
-VAR a, b: INTEGER;
-BEGIN
-  New;
-  a := sys.ADR(Code[ccount]);
-  b := a;
-  InitArray(a, cmd);
-  ccount := a - b + ccount;
-  current.clen := a - b
-END OutCode;
-PROCEDURE Del*(last: ASMLINE);
-BEGIN
-  last.Next := current.Next;
-  IF current = asmlist.Last THEN
-    asmlist.Last := last
-  END;
-  current := last
-END Del;
-PROCEDURE NewLabel*(): INTEGER;
-BEGIN
-  INC(Lcount)
-  RETURN Lcount
-END NewLabel;
-PROCEDURE PushCall*(asmline: ASMLINE);
-BEGIN
-  New;
-  callstk[topstk][0] := asmline;
-  callstk[topstk][1] := current;
-  INC(topstk)
-END PushCall;
-PROCEDURE Param*;
-BEGIN
-  current := callstk[topstk - 1][0]
-END Param;
-PROCEDURE EndCall*;
-BEGIN
-  current := callstk[topstk - 1][1];
-  DEC(topstk)
-END EndCall;
-PROCEDURE Init*(UI: INTEGER);
-VAR nov: ASMLINE;
-BEGIN
-  dcount := 4;
-  dll := UI = 1;
-  gui := UI = 2;
-  con := UI = 3;
-  kos := UI = 4;
-  elf := UI = 5;
-  obj := UI = 6;
-  Lcount := HALT;
-  asmlist := UTILS.CreateList();
-  NEW(nov);
-  UTILS.MemErr(nov = NIL);
-  UTILS.Push(asmlist, nov);
-  current := nov
-END Init;
+PROCEDURE pushc (n: INTEGER);
+BEGIN
-PROCEDURE datastr(str: UTILS.STRING);
+    OutByte(68H + short(n)); // push n
-VAR i, n: INTEGER;
+    OutIntByte(n)
-BEGIN
+END pushc;
-  i := 0;
-  n := LEN(str);
+PROCEDURE test (reg: INTEGER);
-  WHILE (i < n) & (str[i] # 0X) DO
+BEGIN
-    Data[dcount] := str[i];
+    OutByte2(85H, 0C0H + reg * 9)  // test reg, reg
-    INC(dcount);
-    INC(i)
+END test;
-  END;
-  Data[dcount] := 0X;
+PROCEDURE neg (reg: INTEGER);
-  INC(dcount)
+BEGIN
-END datastr;
+    OutByte2(0F7H, 0D8H + reg)  // neg reg
-PROCEDURE dataint(n: INTEGER);
-BEGIN
-  sys.PUT(sys.ADR(Data[dcount]), n);
+END neg;
-  INC(dcount, 4)
-END dataint;
-PROCEDURE jmp*(jamp: CHAR; label: INTEGER);
+PROCEDURE not (reg: INTEGER);
-VAR n: INTEGER;
+BEGIN
-BEGIN
+    OutByte2(0F7H, 0D0H + reg)  // not reg
-  New;
-  CASE jamp OF
+END not;
-  |JMP, CALL:
-    n := 5
-  |JE, JLE, JGE, JG, JL, JNE:
-    Code[ccount] := 0FX;
-    INC(ccount);
-    n := 6
+PROCEDURE add (reg1, reg2: INTEGER);
-  ELSE
+BEGIN
-  END;
-  current.clen := n;
+    OutByte2(01H, 0C0H + reg2 * 8 + reg1)  // add reg1, reg2
-  Code[ccount] := jamp;
+END add;
-  INC(ccount);
-  current.codeadr := sys.ADR(Code[ccount]);
-  current.varadr := sys.ADR(Labels[label]);
-  current.tcmd := JCMD;
-  current.short := TRUE;
-  INC(ccount, 4)
+PROCEDURE andrc (reg, n: INTEGER);
+BEGIN
+    OutByte2(81H + short(n), 0E0H + reg);  // and reg, n
+    OutIntByte(n)
+END andrc;
+PROCEDURE orrc (reg, n: INTEGER);
+BEGIN
+    OutByte2(81H + short(n), 0C8H + reg);  // or reg, n
+    OutIntByte(n)
+END orrc;
-END jmp;
+PROCEDURE addrc (reg, n: INTEGER);
-PROCEDURE jmplong(jamp: CHAR; label: INTEGER);
+BEGIN
-BEGIN
+    OutByte2(81H + short(n), 0C0H + reg);  // add reg, n
-  jmp(jamp, label);
+    OutIntByte(n)
-  current.short := FALSE
+END addrc;
-END jmplong;
-PROCEDURE Label*(label: INTEGER);
 BEGIN
+PROCEDURE subrc (reg, n: INTEGER);
+BEGIN
+    OutByte2(81H + short(n), 0E8H + reg);  // sub reg, n
+    OutIntByte(n)
+END subrc;
+PROCEDURE cmprr (reg1, reg2: INTEGER);
+BEGIN
+    OutByte2(39H, 0C0H + reg2 * 8 + reg1)  // cmp reg1, reg2
+END cmprr;
+PROCEDURE cmprc (reg, n: INTEGER);
+BEGIN
+    OutByte2(81H + short(n), 0F8H + reg);  // cmp reg, n
+    OutIntByte(n)
-  New;
+END cmprc;
-  current.varadr := sys.ADR(Labels[label]);
-  current.tcmd := LCMD
+PROCEDURE setcc (cond, reg: INTEGER);
+BEGIN
-END Label;
+    OutByte3(0FH, cond, 0C0H + reg)  // setcc reg
 END setcc;
-PROCEDURE CmdN(Number: INTEGER);
-BEGIN
-  New;
+PROCEDURE drop;
-  current.clen := 4;
+BEGIN
-  current.codeadr := sys.ADR(Code[ccount]);
-  current.varadr := sys.ADR(Labels[Number]);
+    REG.Drop(R)
-  current.tcmd := OCMD;
-  INC(ccount, 4)
+END drop;
+PROCEDURE log2* (x: INTEGER): INTEGER;
+VAR
+    n: INTEGER;
+BEGIN
-END CmdN;
+    ASSERT(x > 0);
+    n := 0;
-PROCEDURE IntByte(bytecode, intcode: UTILS.STRING; n: INTEGER);
+    WHILE ~ODD(x) DO
-BEGIN
+        x := x DIV 2;
-  IF (n <= 127) & (n >= -128) THEN
+        INC(n)
+    END;
-    OutCode(bytecode);
+    IF x # 1 THEN
-    OutByte(n)
+        n := -1
-  ELSE
+    END
-    OutCode(intcode);
-    OutInt(n)
   END
+    RETURN n
+END log2;
-END IntByte;
+PROCEDURE cond* (op: INTEGER): INTEGER;
+VAR
+    res: INTEGER;
+BEGIN
+    CASE op OF
+    |CODE.opGT, CODE.opGTR, CODE.opLTL: res := jg
+    |CODE.opGE, CODE.opGER, CODE.opLEL: res := jge
+    |CODE.opLT, CODE.opLTR, CODE.opGTL: res := jl
+    |CODE.opLE, CODE.opLER, CODE.opGEL: res := jle
+    |CODE.opEQ, CODE.opEQR, CODE.opEQL: res := je
+    |CODE.opNE, CODE.opNER, CODE.opNEL: res := jne
+    END
+    RETURN res
+END cond;
+PROCEDURE inv1* (op: INTEGER): INTEGER;
+BEGIN
+    IF ODD(op) THEN
+        DEC(op)
+    ELSE
+        INC(op)
+    END
+    RETURN op
+END inv1;
+PROCEDURE Reloc* (op, value: INTEGER);
+VAR
+    reloc: RELOC;
+BEGIN
+    NEW(reloc);
+    reloc.op := op;
+    reloc.value := value;
+    LISTS.push(CodeList, reloc)
+END Reloc;
+PROCEDURE jcc* (cc, label: INTEGER);
-PROCEDURE DropFpu*(long: BOOLEAN);
+VAR
+    j: JCC;
 BEGIN
+    NEW(j);
+    j.label := label;
+    j.jmp   := cc;
+    j.short := FALSE;
+    LISTS.push(CodeList, j)
+END jcc;
-  IF long THEN
-    OutCode("83EC08DD1C24")
+PROCEDURE jmp* (label: INTEGER);
-  ELSE
+VAR
+    j: JMP;
+BEGIN
+    NEW(j);
+    j.label := label;
+    j.short := FALSE;
+    LISTS.push(CodeList, j)
+END jmp;
+PROCEDURE call* (label: INTEGER);
+VAR
+    c: CALL;
-    OutCode("83EC04D91C24")
+BEGIN
+    NEW(c);
+    c.label := label;
+    c.short := TRUE;
+    LISTS.push(CodeList, c)
+END call;
+PROCEDURE Pic (reg, opcode, value: INTEGER);
-  END;
-  DEC(fpu)
-END DropFpu;
+BEGIN
+    OutByte(0E8H); OutInt(0); // call L
+                              // L:
+    pop(reg);
+    OutByte2(081H, 0C0H + reg);  // add reg, ...
+    Reloc(opcode, value)
+END Pic;
+PROCEDURE CallRTL (pic: BOOLEAN; proc: INTEGER);
+VAR
+    label: INTEGER;
+    reg1:  INTEGER;
-PROCEDURE AfterRet(func, float: BOOLEAN; callconv, parsize: INTEGER);
+BEGIN
+    label := CODE.codes.rtl[proc];
-BEGIN
+    IF label < 0 THEN
+        label := -label;
+        IF pic THEN
+            reg1 := REG.GetAnyReg(R);
-  IF callconv = cdecl THEN
+            Pic(reg1, BIN.PICIMP, label);
+            OutByte2(0FFH, 010H + reg1);  // call dword[reg1]
+            drop
+        ELSE
+            OutByte2(0FFH, 015H);  // call dword[label]
-    OutCode("81C4");
+            Reloc(BIN.RIMP, label)
-    OutInt(parsize)
+        END
+    ELSE
+        call(label)
+    END
+END CallRTL;
   END;
   IF func THEN
-    IF float THEN
-      OutCode("83EC08DD1C24")
-    ELSE
-      PushEAX
-    END
+PROCEDURE SetLabel* (label: INTEGER);
+VAR
+    L: LABEL;
+BEGIN
+    NEW(L);
+    L.label := label;
+    LISTS.push(CodeList, L)
+END SetLabel;
+PROCEDURE fixup*;
+VAR
+    code:      ANYCODE;
+    count, i:  INTEGER;
+    shorted:   BOOLEAN;
+    jump:      JUMP;
+BEGIN
+    REPEAT
+        shorted := FALSE;
+        count := 0;
+        code := CodeList.first(ANYCODE);
+        WHILE code # NIL DO
+            code.offset := count;
+            CASE code OF
+            |TCODE:  INC(count, code.length)
+            |LABEL:  BIN.SetLabel(program, code.label, count)
+            |JMP:    IF code.short THEN INC(count, 2) ELSE INC(count, 5) END; code.offset := count
+            |JCC:    IF code.short THEN INC(count, 2) ELSE INC(count, 6) END; code.offset := count
+            |CALL:   INC(count, 5); code.offset := count
+            |RELOC:  INC(count, 4)
+            END;
+            code := code.next(ANYCODE)
+        END;
+        code := CodeList.first(ANYCODE);
+        WHILE code # NIL DO
+            IF code IS JUMP THEN
+                jump := code(JUMP);
+                jump.diff := BIN.GetLabel(program, jump.label) - code.offset;
+                IF ~jump.short & isByte(jump.diff) THEN
+                    jump.short := TRUE;
+                    shorted := TRUE
+                END
+            END;
-  END
+            code := code.next(ANYCODE)
-END AfterRet;
+        END
-PROCEDURE FpuSave(local: INTEGER);
-VAR i: INTEGER;
-BEGIN
-  IF fpu > maxfpu THEN
-    maxfpu := fpu
-  END;
-  FOR i := 1 TO fpu DO
-    IntByte("DD5D", "DD9D", -local - i * 8)
+    UNTIL ~shorted;
-  END
+    code := CodeList.first(ANYCODE);
-END FpuSave;
+    WHILE code # NIL DO
-PROCEDURE Incfpu;
-BEGIN
+        CASE code OF
-  IF fpu >= FREGS THEN
+        |TCODE:
-    UTILS.ErrMsgPos(SCAN.coord.line, SCAN.coord.col, 97);
+                FOR i := 0 TO code.length - 1 DO
-    UTILS.HALT(1)
-  END;
-  INC(fpu);
-  isfpu := TRUE
-END Incfpu;
-PROCEDURE FpuLoad(local: INTEGER; float: BOOLEAN);
-VAR i: INTEGER;
-BEGIN
+                    BIN.PutCode(program, code.code[i])
-  FOR i := fpu TO 1 BY -1 DO
+                END
-    IntByte("DD45", "DD85", -local - i * 8)
-  END;
-  IF float THEN
-    Incfpu;
-    OutCode("DD042483C408")
+        |LABEL:
-  END
+                BIN.SetLabel(program, code.label, code.offset)
+        |JMP:
+                IF code.short THEN
+                    BIN.PutCode(program, 0EBH);
+                    BIN.PutCode(program, Byte(code.diff))
+                ELSE
+                    BIN.PutCode(program, 0E9H);
-END FpuLoad;
+                    BIN.PutCode32LE(program, code.diff)
+                END
+        |JCC:
+                IF code.short THEN
+                    BIN.PutCode(program, code.jmp - 16);
+                    BIN.PutCode(program, Byte(code.diff))
+                ELSE
+                    BIN.PutCode(program, 0FH);
+                    BIN.PutCode(program, code.jmp);
+                    BIN.PutCode32LE(program, code.diff)
+                END
-PROCEDURE Call*(proc: INTEGER; func, float: BOOLEAN; callconv, ccall, bases, level, parsize, local: INTEGER);
+        |CALL:
+                BIN.PutCode(program, 0E8H);
-VAR i: INTEGER;
+                BIN.PutCode32LE(program, code.diff)
-BEGIN
-  IF ccall # 0 THEN
     FOR i := level TO level - bases + ORD(ccall = 1) + 1 BY -1 DO
-      IntByte("FF75", "FFB5", 4 * i + 4)
+        |RELOC:
+                BIN.PutReloc(program, code.op);
-    END;
+                BIN.PutCode32LE(program, code.value)
+        END;
+        code := code.next(ANYCODE)
+    END
-    IF ccall = 1 THEN
+END fixup;
-      OutByte(55H)
+PROCEDURE UnOp (VAR reg: INTEGER);
+BEGIN
+    REG.UnOp(R, reg)
+END UnOp;
+PROCEDURE BinOp (VAR reg1, reg2: INTEGER);
+BEGIN
+    REG.BinOp(R, reg1, reg2)
-    END
+END BinOp;
-  END;
-  FpuSave(local);
+PROCEDURE PushAll (NumberOfParameters: INTEGER);
+BEGIN
+    REG.PushAll(R);
+    R.pushed := R.pushed - NumberOfParameters
+END PushAll;
+PROCEDURE NewLabel (): INTEGER;
+BEGIN
+    BIN.NewLabel(program)
+    RETURN CODE.NewLabel()
+END NewLabel;
   jmplong(CALL, proc);
-  AfterRet(func, float, callconv, parsize);
-  FpuLoad(local, func & float)
-END Call;
+PROCEDURE GetRegA;
-PROCEDURE CallRTL(Proc: INTEGER);
+BEGIN
-BEGIN
+    ASSERT(REG.GetReg(R, eax))
-  New;
+END GetRegA;
-  current.clen := 5;
-  Code[ccount] := CALL;
-  INC(ccount);
-  current.codeadr := sys.ADR(Code[ccount]);
+PROCEDURE translate (code: CODE.CODES; pic: BOOLEAN; stroffs: INTEGER);
+VAR
+    cmd: COMMAND;
+    reg1, reg2: INTEGER;
-  current.varadr := sys.ADR(RtlProc[Proc]);
+    n, a, b, label, cc: INTEGER;
-  current.tcmd := JCMD;
+    param1, param2: INTEGER;
-  INC(ccount, 4)
+    float: REAL;
-END CallRTL;
+BEGIN
+    cmd := code.commands.first(COMMAND);
+    WHILE cmd # NIL DO
+        param1 := cmd.param1;
+        param2 := cmd.param2;
+        CASE cmd.opcode OF
+        |CODE.opJMP:
+            jmp(param1)
+        |CODE.opCALL:
+            call(param1)
+        |CODE.opCALLI:
+            IF pic THEN
-PROCEDURE PushInt*(n: INTEGER);
+                reg1 := REG.GetAnyReg(R);
+                Pic(reg1, BIN.PICIMP, param1);
+                OutByte2(0FFH, 010H + reg1);  // call dword[reg1]
+                drop
+            ELSE
+                OutByte2(0FFH, 015H);  // call dword[L]
+                Reloc(BIN.RIMP, param1)
+            END
+        |CODE.opCALLP:
+            UnOp(reg1);
+            OutByte2(0FFH, 0D0H + reg1);    // call reg1
+            drop;
+            ASSERT(R.top = -1)
+        |CODE.opPRECALL:
-BEGIN
+            n := param2;
+            IF (param1 # 0) & (n # 0) THEN
-  OutByte(68H);
+                subrc(esp, 8)
-  CmdN(n)
+            END;
-END PushInt;
+            WHILE n > 0 DO
                 subrc(esp, 8);
-PROCEDURE Prolog*(exename: UTILS.STRING);
+                OutByte3(0DDH, 01CH, 024H); // fstp qword[esp]
-BEGIN
+                DEC(n)
+            END;
-  ExecName := exename;
+            PushAll(0)
-  Labels[hInstance] := -dcount;
-  dataint(0);
+        |CODE.opALIGN16:
+            ASSERT(eax IN R.regs);
+            mov(eax, esp);
+            andrc(esp, -16);
-  Labels[SELFNAME] := -dcount;
+            n := (3 - param2 MOD 4) * 4;
-  datastr(exename);
+            IF n > 0 THEN
+                subrc(esp, n)
+            END;
+            push(eax)
+        |CODE.opRES:
+            ASSERT(R.top = -1);
+            GetRegA;
+            n := param2;
-  Label(START);
+            WHILE n > 0 DO
+                OutByte3(0DDH, 004H, 024H); // fld qword[esp]
+                addrc(esp, 8);
-  IF dll THEN
+                DEC(n)
+            END
+        |CODE.opRESF:
+            n := param2;
+            IF n > 0 THEN
+                OutByte3(0DDH, 5CH + long(n * 8), 24H);
+                OutIntByte(n * 8); // fstp qword[esp + n*8]
+                INC(n)
-    OutCode("558BEC837D0C007507");
+            END;
-    CallRTL(_close);
+            WHILE n > 0 DO
+                OutByte3(0DDH, 004H, 024H); // fld qword[esp]
+                addrc(esp, 8);
+                DEC(n)
+            END
+        |CODE.opENTER:
+            ASSERT(R.top = -1);
+            SetLabel(param1);
-    OutCode("EB06837D0C017409B801000000C9C20C00")
+            push(ebp);
+            mov(ebp, esp);
+            n := param2;
+            IF n > 4 THEN
+                movrc(ecx, n);
+                pushc(0);             // @@: push 0
+                OutByte2(0E2H, 0FCH)  // loop @b
+            ELSE
+                WHILE n > 0 DO
+                    pushc(0);
+                    DEC(n)
+                END
+            END
+        |CODE.opLEAVE, CODE.opLEAVER, CODE.opLEAVEF:
+            IF cmd.opcode = CODE.opLEAVER THEN
+                UnOp(reg1);
+                IF reg1 # eax THEN
+                    GetRegA;
+                    ASSERT(REG.Exchange(R, reg1, eax));
+                    drop
+                END;
+                drop
+            END;
+            ASSERT(R.top = -1);
+            mov(esp, ebp);
+            pop(ebp);
+            n := param2;
+            IF n > 0 THEN
+                n := n * 4;
+                OutByte(0C2H); OutWord(Word(n)) // ret n
+            ELSE
+                OutByte(0C3H) // ret
+            END
+        |CODE.opERRC:
+            pushc(param2)
+        |CODE.opPARAM:
+            n := param2;
+            IF n = 1 THEN
+                UnOp(reg1);
+                push(reg1);
-  ELSIF obj THEN
+                drop
+            ELSE
+                ASSERT(R.top + 1 <= n);
+                PushAll(n)
+            END
-    OutCode("558BEC")
+        |CODE.opCLEANUP:
+            n := param2 * 4;
+            IF n # 0 THEN
+                addrc(esp, n)
+            END
+        |CODE.opPOPSP:
+            pop(esp)
+        |CODE.opCONST:
+            reg1 := REG.GetAnyReg(R);
+            movrc(reg1, param2)
+        |CODE.opLABEL:
+            SetLabel(param2) // L:
+        |CODE.opNOP:
+        |CODE.opGADR:
+            reg1 := REG.GetAnyReg(R);
+            IF pic THEN
+                Pic(reg1, BIN.PICBSS, param2)
+            ELSE
+                OutByte(0B8H + reg1);  // mov reg1, _bss + param2
+                Reloc(BIN.RBSS, param2)
+            END
-  END;
+        |CODE.opLADR:
+            n := param2 * 4;
+            reg1 := REG.GetAnyReg(R);
+            OutByte2(8DH, 45H + reg1 * 8 + long(n));  // lea reg1, dword[ebp + n]
+            OutIntByte(n)
+        |CODE.opVADR:
+            n := param2 * 4;
+            reg1 := REG.GetAnyReg(R);
+            OutByte2(8BH, 45H + reg1 * 8 + long(n));  // mov reg1, dword[ebp + n]
+            OutIntByte(n)
+        |CODE.opSADR:
+            reg1 := REG.GetAnyReg(R);
+            IF pic THEN
-  start := asmlist.Last(ASMLINE)
+                Pic(reg1, BIN.PICDATA, stroffs + param2);
+            ELSE
+                OutByte(0B8H + reg1);  // mov reg1, _data + stroffs + param2
-END Prolog;
+                Reloc(BIN.RDATA, stroffs + param2)
+            END
+        |CODE.opSAVEC:
+            UnOp(reg1);
+            OutByte2(0C7H, reg1); OutInt(param2);  // mov dword[reg1], param2
+            drop
+        |CODE.opSAVE8C:
+            UnOp(reg1);
+            OutByte3(0C6H, reg1, Byte(param2));  // mov byte[reg1], param2
+            drop
+        |CODE.opSAVE16C:
+            UnOp(reg1);
+            OutByte3(66H, 0C7H, reg1); OutWord(Word(param2));  // mov word[reg1], param2
+            drop
+        |CODE.opVLOAD32:
+            n := param2 * 4;
+            reg1 := REG.GetAnyReg(R);
-PROCEDURE AddRec*(base: INTEGER);
+            OutByte2(8BH, 45H + reg1 * 8 + long(n));  // mov reg1, dword[ebp + n]
+            OutIntByte(n);
+            OutByte2(8BH, reg1 * 9)  // mov reg1, dword[reg1]
-BEGIN
+        |CODE.opGLOAD32:
+            reg1 := REG.GetAnyReg(R);
+            IF pic THEN
+                Pic(reg1, BIN.PICBSS, param2);
+                OutByte2(8BH, reg1 * 9)       // mov reg1, dword[reg1]
+            ELSE
+                OutByte2(08BH, 05H + reg1 * 8);  // mov reg1, dword[_bss + param2]
+                Reloc(BIN.RBSS, param2)
+            END
+        |CODE.opLLOAD32:
+            n := param2 * 4;
+            reg1 := REG.GetAnyReg(R);
+            OutByte2(8BH, 45H + reg1 * 8 + long(n));  // mov reg1, dword[ebp + n]
+            OutIntByte(n)
+        |CODE.opLOAD32:
+            UnOp(reg1);
+            OutByte2(8BH, reg1 * 9)  // mov reg1, dword[reg1]
+        |CODE.opVLOAD8:
+            n := param2 * 4;
+            reg1 := REG.GetAnyReg(R);
+            OutByte2(8BH, 45H + reg1 * 8 + long(n)); // mov reg1, dword[ebp + n]
+            OutIntByte(n);
+            OutByte3(0FH, 0B6H, reg1 * 9) // movzx reg1, byte[reg1]
+        |CODE.opGLOAD8:
+            reg1 := REG.GetAnyReg(R);
+            IF pic THEN
-  INC(reccount);
+                Pic(reg1, BIN.PICBSS, param2);
+                OutByte3(0FH, 0B6H, reg1 * 9) // movzx reg1, byte[reg1]
-  recarray[reccount] := base
+            ELSE
+                OutByte3(00FH, 0B6H, 05H + reg1 * 8);  // movzx reg1, byte[_bss + param2]
+                Reloc(BIN.RBSS, param2)
+            END
+        |CODE.opLLOAD8:
+            n := param2 * 4;
+            reg1 := REG.GetAnyReg(R);
+            OutByte3(0FH, 0B6H, 45H + reg1 * 8 + long(n)); // movzx reg1, byte[ebp + n]
+            OutIntByte(n)
+        |CODE.opLOAD8:
+            UnOp(reg1);
+            OutByte3(0FH, 0B6H, reg1 * 9) // movzx reg1, byte[reg1]
+        |CODE.opVLOAD16:
+            n := param2 * 4;
-END AddRec;
+            reg1 := REG.GetAnyReg(R);
+            OutByte2(8BH, 45H + reg1 * 8 + long(n)); // mov reg1, dword[ebp + n]
+            OutIntByte(n);
+            OutByte3(0FH, 0B7H, reg1 * 9) // movzx reg1, word[reg1]
+        |CODE.opGLOAD16:
+            reg1 := REG.GetAnyReg(R);
+            IF pic THEN
+                Pic(reg1, BIN.PICBSS, param2);
+                OutByte3(0FH, 0B7H, reg1 * 9) // movzx reg1, word[reg1]
+            ELSE
+                OutByte3(00FH, 0B7H, 05H + reg1 * 8);  // movzx reg1, word[_bss + param2]
+                Reloc(BIN.RBSS, param2)
+            END
-PROCEDURE CmpOpt(inv: BOOLEAN): INTEGER;
+        |CODE.opLLOAD16:
-VAR cur: ASMLINE; c: INTEGER;
-BEGIN
-  c := ORD(Code[current.Prev.Prev(ASMLINE).cmd]);
-  IF inv THEN
-    IF ODD(c) THEN
-      DEC(c)
+            n := param2 * 4;
-    ELSE
+            reg1 := REG.GetAnyReg(R);
-      INC(c)
+            OutByte3(0FH, 0B7H, 45H + reg1 * 8 + long(n)); // movzx reg1, word[ebp + n]
+            OutIntByte(n)
-    END
+        |CODE.opLOAD16:
+            UnOp(reg1);
+            OutByte3(0FH, 0B7H, reg1 * 9) // movzx reg1, word[reg1]
-  END;
-  cur := current;
+        |CODE.opUMINUS:
-  REPEAT
+            UnOp(reg1);
-    cur.tcmd := 0;
-    cur.clen := 0;
+            neg(reg1)
-    cur := cur.Prev(ASMLINE)
-  UNTIL cur.tcmd = ICMP1;
+        |CODE.opADD:
-  cur.tcmd := 0;
+            BinOp(reg1, reg2);
-  cur.clen := 0
-  RETURN c - 16
+            add(reg1, reg2);
+            drop
-END CmpOpt;
+        |CODE.opADDL, CODE.opADDR:
             IF param2 # 0 THEN
-PROCEDURE ifwh*(L: INTEGER);
+                UnOp(reg1);
+                IF param2 = 1 THEN
+                    OutByte(40H + reg1) // inc reg1
+                ELSIF param2 = -1 THEN
+                    OutByte(48H + reg1) // dec reg1
+                ELSE
-VAR c: INTEGER;
+                    addrc(reg1, param2)
+                END
-BEGIN
+            END
-  IF current.Prev(ASMLINE).tcmd = ICMP2 THEN
+        |CODE.opSUB:
+            BinOp(reg1, reg2);
+            OutByte2(29H, 0C0H + reg2 * 8 + reg1); // sub reg1, reg2
+            drop
-    c := CmpOpt(TRUE);
+        |CODE.opSUBR, CODE.opSUBL:
+            UnOp(reg1);
+            n := param2;
+            IF n = 1 THEN
+                OutByte(48H + reg1) // dec reg1
-    OutCode("5A583BC2");
+            ELSIF n = -1 THEN
+                OutByte(40H + reg1) // inc reg1
+            ELSIF n # 0 THEN
+                subrc(reg1, n)
-    jmp(CHR(c), L)
+            END;
-  ELSE
+            IF cmd.opcode = CODE.opSUBL THEN
+                neg(reg1)
+            END
-    PopECX;
+        |CODE.opMULC:
-    OutCode("85C9");
+            UnOp(reg1);
+            a := param2;
-    jmp(JE, L)
+            IF a > 1 THEN
-  END
-END ifwh;
+                n := log2(a)
-PROCEDURE PushConst*(Number: INTEGER);
-BEGIN
+            ELSIF a < -1 THEN
-  IntByte("6A", "68", Number);
+                n := log2(-a)
-  current.Prev(ASMLINE).varadr := Number
-END PushConst;
+            ELSE
+                n := -1
-PROCEDURE IfWhile*(L: INTEGER; orop: BOOLEAN);
+            END;
-VAR c, L1: INTEGER;
-BEGIN
+            IF a = 1 THEN
-  L1 := NewLabel();
-  IF current.Prev(ASMLINE).tcmd = ICMP2 THEN
+            ELSIF a = -1 THEN
+                neg(reg1)
-    c := CmpOpt(orop);
+            ELSIF a = 0 THEN
+                OutByte2(31H, 0C0H + reg1 * 9) // xor reg1, reg1
-    OutCode("5A583BC2");
+            ELSE
+                IF n > 0 THEN
+                    IF a < 0 THEN
-    jmp(CHR(c), L1);
+                        neg(reg1)
+                    END;
-    PushConst(ORD(orop))
-  ELSE
+                    IF n # 1 THEN
+                        OutByte3(0C1H, 0E0H + reg1, n)   // shl reg1, n
+                    ELSE
-    PopECX;
+                        OutByte2(0D1H, 0E0H + reg1)      // shl reg1, 1
+                    END
+                ELSE
-    OutCode("85C9");
+                    OutByte2(69H + short(a), 0C0H + reg1 * 9); // imul reg1, a
+                    OutIntByte(a)
-    IF orop THEN
+                END
+            END
-      jmp(JE, L1)
+        |CODE.opMUL:
-    ELSE
+            BinOp(reg1, reg2);
-      jmp(JNE, L1)
+            OutByte3(0FH, 0AFH, 0C0H + reg1 * 8 + reg2); // imul reg1, reg2
-    END;
+            drop
+        |CODE.opSAVE, CODE.opSAVE32:
+            BinOp(reg2, reg1);
+            OutByte2(89H, reg2 * 8 + reg1); // mov dword[reg1], reg2
+            drop;
+            drop
+        |CODE.opSAVE8:
+            BinOp(reg2, reg1);
+            OutByte2(88H, reg2 * 8 + reg1); // mov byte[reg1], reg2
+            drop;
+            drop
+        |CODE.opSAVE16:
+            BinOp(reg2, reg1);
+            OutByte3(66H, 89H, reg2 * 8 + reg1); // mov word[reg1], reg2
+            drop;
+            drop
+        |CODE.opSAVEP:
+            UnOp(reg1);
+            IF pic THEN
+                reg2 := REG.GetAnyReg(R);
+                Pic(reg2, BIN.PICCODE, param2);
+                OutByte2(089H, reg2 * 8 + reg1); // mov dword[reg1], reg2
+                drop
+            ELSE
+                OutByte2(0C7H, reg1);  // mov dword[reg1], L
+                Reloc(BIN.RCODE, param2)
+            END;
+            drop
+        |CODE.opSAVEIP:
+            UnOp(reg1);
+            IF pic THEN
+                reg2 := REG.GetAnyReg(R);
+                Pic(reg2, BIN.PICIMP, param2);
+                OutByte2(0FFH, 30H + reg2);   // push dword[reg2]
-    PushECX
+                OutByte2(08FH, reg1);         // pop dword[reg1]
-  END;
+                drop
-  jmp(JMP, L);
-  Label(L1)
-END IfWhile;
+            ELSE
+                OutByte2(0FFH, 035H);  // push dword[L]
-PROCEDURE newrec*;
+                Reloc(BIN.RIMP, param2);
-BEGIN
-  CallRTL(_newrec)
+                OutByte2(08FH, reg1)   // pop dword[reg1]
-END newrec;
+            END;
-PROCEDURE disprec*;
+            drop
+        |CODE.opPUSHP:
+            reg1 := REG.GetAnyReg(R);
+            IF pic THEN
+                Pic(reg1, BIN.PICCODE, param2)
+            ELSE
+                OutByte(0B8H + reg1);  // mov reg1, L
+                Reloc(BIN.RCODE, param2)
+            END
+        |CODE.opPUSHIP:
+            reg1 := REG.GetAnyReg(R);
+            IF pic THEN
+                Pic(reg1, BIN.PICIMP, param2);
+                OutByte2(08BH, reg1 * 9)         // mov reg1, dword[reg1]
+            ELSE
+                OutByte2(08BH, 05H + reg1 * 8);  // mov reg1, dword[L]
+                Reloc(BIN.RIMP, param2)
+            END
+        |CODE.opNOT:
+            UnOp(reg1);
+            test(reg1);
+            setcc(sete, reg1);
+            andrc(reg1, 1)
+        |CODE.opORD:
+            UnOp(reg1);
+            test(reg1);
+            setcc(setne, reg1);
+            andrc(reg1, 1)
+        |CODE.opSBOOL:
+            BinOp(reg2, reg1);
+            test(reg2);
+            setcc(setne, reg2);
+            OutByte2(88H, reg2 * 8 + reg1); // mov byte[reg1], reg2
+            drop;
-BEGIN
+            drop
+        |CODE.opSBOOLC:
+            UnOp(reg1);
+            OutByte3(0C6H, reg1, ORD(param2 # 0)); // mov byte[reg1], 0/1
-  CallRTL(_disprec)
+            drop
+        |CODE.opODD:
+            UnOp(reg1);
+            andrc(reg1, 1)
+        |CODE.opGTR, CODE.opLTL, CODE.opGER, CODE.opLEL,
+         CODE.opLER, CODE.opGEL, CODE.opLTR, CODE.opGTL,
+         CODE.opEQR, CODE.opEQL, CODE.opNER, CODE.opNEL:
-END disprec;
+            UnOp(reg1);
+            IF param2 = 0 THEN
                 test(reg1)
+            ELSE
+                cmprc(reg1, param2)
+            END;
+            drop;
+            cc := cond(cmd.opcode);
+            IF cmd.next(COMMAND).opcode = CODE.opJE THEN
+                label := cmd.next(COMMAND).param1;
-PROCEDURE String*(Number, Len: INTEGER; str: UTILS.STRING);
+                jcc(cc, label);
+                cmd := cmd.next(COMMAND)
+            ELSIF cmd.next(COMMAND).opcode = CODE.opJNE THEN
+                label := cmd.next(COMMAND).param1;
+                jcc(inv1(cc), label);
+                cmd := cmd.next(COMMAND)
+            ELSE
+                reg1 := REG.GetAnyReg(R);
+                setcc(cc + 16, reg1);
+                andrc(reg1, 1)
+            END;
+        |CODE.opGT, CODE.opGE, CODE.opLT,
+         CODE.opLE, CODE.opEQ, CODE.opNE:
+            BinOp(reg1, reg2);
+            cmprr(reg1, reg2);
+            drop;
+            drop;
+            cc := cond(cmd.opcode);
-BEGIN
+            IF cmd.next(COMMAND).opcode = CODE.opJE THEN
-  Labels[Number] := -dcount;
+                label := cmd.next(COMMAND).param1;
-  IF Len > 1 THEN
+                jcc(cc, label);
+                cmd := cmd.next(COMMAND)
-    datastr(str)
-  ELSIF Len = 1 THEN
+            ELSIF cmd.next(COMMAND).opcode = CODE.opJNE THEN
+                label := cmd.next(COMMAND).param1;
+                jcc(inv1(cc), label);
-    dataint(ORD(str[0]))
+                cmd := cmd.next(COMMAND)
   ELSE
-    dataint(0)
+            ELSE
-  END
-END String;
-PROCEDURE InsertFpuInit;
-VAR t: ASMLINE;
+                reg1 := REG.GetAnyReg(R);
-BEGIN
-  IF isfpu THEN
+                setcc(cc + 16, reg1);
-    t := current;
-    current := fpucmd;
+                andrc(reg1, 1)
-    IF maxfpu > 0 THEN
+            END
-      OutCode("83EC");
-      OutByte(maxfpu * 8)
-    END;
-    OutCode("DBE3");
-    current := t
+        |CODE.opEQB, CODE.opNEB:
-  END
+            BinOp(reg1, reg2);
-END InsertFpuInit;
-PROCEDURE ProcBeg*(Number, Local: INTEGER; Module: BOOLEAN);
+            drop;
-VAR i: INTEGER;
-BEGIN
+            drop;
-  IF Module THEN
-    OutCode("EB0C");
+            test(reg1);
-    Label(Number + 3);
+            OutByte2(74H, 5);  // je @f
-    PushInt(Number + 2);
-    jmplong(JMP, HALT);
-    Label(Number + 1)
+            movrc(reg1, 1);    // mov reg1, 1
-  ELSE
-    Label(Number)
-  END;
-  OutCode("558BEC");
-  IF Local > 12 THEN
+                               // @@:
-    IntByte("83EC", "81EC", Local);
+            test(reg2);
-    OutCode("8BD733C08BFCB9");
+            OutByte2(74H, 5);  // je @f
-    OutInt(ASR(Local, 2));
+            movrc(reg2, 1);    // mov reg2, 1
-    OutCode("9CFCF3AB8BFA9D")
+                               // @@:
-  ELSE
-    FOR i := 4 TO Local BY 4 DO
+            cmprr(reg1, reg2);
-      OutCode("6A00")
+            reg1 := REG.GetAnyReg(R);
+            IF cmd.opcode = CODE.opEQB THEN
+                setcc(sete, reg1)
+            ELSE
+                setcc(setne, reg1)
+            END;
+            andrc(reg1, 1)
+        |CODE.opDROP:
+            UnOp(reg1);
+            drop
-    END
+        |CODE.opJNZ:
+            UnOp(reg1);
+            test(reg1);
-  END;
+            jcc(jne, param1)
-  fpucmd := current;
+        |CODE.opJZ:
+            UnOp(reg1);
+            test(reg1);
-  fpu := 0;
+            jcc(je, param1)
-  maxfpu := 0;
-  isfpu := FALSE
+        |CODE.opJE:
+            UnOp(reg1);
-END ProcBeg;
+            test(reg1);
+            jcc(jne, param1);
+            drop;
+        |CODE.opJNE:
+            UnOp(reg1);
+            test(reg1);
+            jcc(je, param1);
+            drop;
+        |CODE.opSWITCH:
+            UnOp(reg1);
+            IF param2 = 0 THEN
+                reg2 := eax
+            ELSE
+                reg2 := ecx
+            END;
+            IF reg1 # reg2 THEN
+                ASSERT(REG.GetReg(R, reg2));
+                ASSERT(REG.Exchange(R, reg1, reg2));
+                drop
+            END;
+            drop
+        |CODE.opENDSW:
+        |CODE.opCASEL:
+            cmprc(eax, param1);
+            jcc(jl, param2)
+        |CODE.opCASER:
+            cmprc(eax, param1);
-PROCEDURE Leave*;
+            jcc(jg, param2)
-BEGIN
+        |CODE.opCASELR:
-  OutByte(0C9H);
+            cmprc(eax, param1);
+            jcc(jl, param2);
+            jcc(jg, cmd.param3)
-  InsertFpuInit
+        |CODE.opCODE:
+            OutByte(param2)
+        |CODE.opGET:
-END Leave;
+            BinOp(reg1, reg2);
+            drop;
+            drop;
+            CASE param2 OF
+            |1:
+                OutByte2(8AH, reg1 * 9);       // mov reg1, byte[reg1]
+                OutByte2(88H, reg1 * 8 + reg2) // mov byte[reg2], reg1
+            |2:
+                OutByte3(66H, 8BH, reg1 * 9);       // mov reg1, word[reg1]
+                OutByte3(66H, 89H, reg1 * 8 + reg2) // mov word[reg2], reg1
+            |4:
+                OutByte2(8BH, reg1 * 9);        // mov reg1, dword[reg1]
+                OutByte2(89H, reg1 * 8 + reg2)  // mov dword[reg2], reg1
+            |8:
+                PushAll(0);
-PROCEDURE ProcEnd*(Number, Param: INTEGER; func, float: BOOLEAN);
+                push(reg2);
+                push(reg1);
+                pushc(8);
-BEGIN
+                CallRTL(pic, CODE._move)
+            END
+        |CODE.opSAVES:
+            UnOp(reg1);
+            drop;
+            PushAll(0);
+            push(reg1);
+            IF pic THEN
+                Pic(reg1, BIN.PICDATA, stroffs + param2);
-  IF func & ~float THEN
+                push(reg1)
+            ELSE
+                OutByte(068H);  // push _data + stroffs + param2
+                Reloc(BIN.RDATA, stroffs + param2);
+            END;
+            pushc(param1);
+            CallRTL(pic, CODE._move)
+        |CODE.opCHKBYTE:
+            BinOp(reg1, reg2);
+            cmprc(reg1, 256);
+            jcc(jb, param1)
+        |CODE.opCHKIDX:
+            UnOp(reg1);
-    PopEAX
+            cmprc(reg1, param2);
+            jcc(jb, param1)
+        |CODE.opCHKIDX2:
+            BinOp(reg1, reg2);
-  END;
+            IF param2 # -1 THEN
+                cmprr(reg2, reg1);
+                mov(reg1, reg2);
+                drop;
+                jcc(jb, param1)
+            ELSE
+                INCL(R.regs, reg1);
+                DEC(R.top);
-  OutByte(0C9H);
+                R.stk[R.top] := reg2
+            END
   IF Param = 0 THEN
-    OutByte(0C3H)
+        |CODE.opLEN:
-  ELSE
+            n := param2;
-    OutByte(0C2H);
-    OutByte(Param MOD 256);
+            UnOp(reg1);
-    OutByte(ASR(Param, 8))
-  END;
+            drop;
+            EXCL(R.regs, reg1);
-  InsertFpuInit
+            WHILE n > 0 DO
+                UnOp(reg2);
+                drop;
+                DEC(n)
+            END;
+            INCL(R.regs, reg1);
+            ASSERT(REG.GetReg(R, reg1))
+        |CODE.opINC1:
+            UnOp(reg1);
+            OutByte2(0FFH, reg1); // inc dword[reg1]
+            drop
+        |CODE.opDEC1:
+            UnOp(reg1);
+            OutByte2(0FFH, 8 + reg1); // dec dword[reg1]
+            drop
+        |CODE.opINCC:
+            UnOp(reg1);
+            n := param2;
+            OutByte2(81H + short(n), reg1); OutIntByte(n); // add dword[reg1], n
+            drop
+        |CODE.opDECC:
+            UnOp(reg1);
+            n := param2;
+            OutByte2(81H + short(n), 28H + reg1); OutIntByte(n); // sub dword[reg1], n
+            drop
+        |CODE.opINC:
+            BinOp(reg1, reg2);
+            OutByte2(01H, reg1 * 8 + reg2); // add dword[reg2], reg1
+            drop;
+            drop
+        |CODE.opDEC:
+            BinOp(reg1, reg2);
+            OutByte2(29H, reg1 * 8 + reg2); // sub dword[reg2], reg1
+            drop;
+            drop
+        |CODE.opINC1B:
+            UnOp(reg1);
+            OutByte2(0FEH, reg1); // inc byte[reg1]
+            drop
-END ProcEnd;
+        |CODE.opDEC1B:
+            UnOp(reg1);
+            OutByte2(0FEH, 08H + reg1); // dec byte[reg1]
+            drop
+        |CODE.opINCCB:
+            UnOp(reg1);
+            OutByte3(80H, reg1, Byte(param2)); // add byte[reg1], n
+            drop
+        |CODE.opDECCB:
-PROCEDURE Module*(Name: UTILS.STRING; Number: INTEGER);
+            UnOp(reg1);
+            OutByte3(80H, 28H + reg1, Byte(param2)); // sub byte[reg1], n
-BEGIN
+            drop
+        |CODE.opINCB, CODE.opDECB:
+            BinOp(reg1, reg2);
+            IF cmd.opcode = CODE.opINCB THEN
-  String(Number + 2, LENGTH(Name), Name);
+                OutByte2(00H, reg1 * 8 + reg2) // add byte[reg2], reg1
+            ELSE
+                OutByte2(28H, reg1 * 8 + reg2) // sub byte[reg2], reg1
+            END;
+            drop;
+            drop
+        |CODE.opMULS:
+            BinOp(reg1, reg2);
+            OutByte2(21H, 0C0H + reg2 * 8 + reg1); // and reg1, reg2
+            drop
+        |CODE.opMULSC:
-  jmplong(JMP, Number + 1)
+            UnOp(reg1);
+            andrc(reg1, param2)
+        |CODE.opDIVS:
+            BinOp(reg1, reg2);
+            OutByte2(31H, 0C0H + reg2 * 8 + reg1); // xor reg1, reg2
+            drop
-END Module;
+        |CODE.opDIVSC:
+            UnOp(reg1);
+            OutByte2(81H + short(param2), 0F0H + reg1);  // xor reg1, n
+            OutIntByte(param2)
+        |CODE.opADDS:
+            BinOp(reg1, reg2);
+            OutByte2(9H, 0C0H + reg2 * 8 + reg1); // or reg1, reg2
+            drop
-PROCEDURE Asm*(s: UTILS.STRING);
-BEGIN
+        |CODE.opSUBS:
-  OutCode(s)
+            BinOp(reg1, reg2);
-END Asm;
+            not(reg2);
+            OutByte2(21H, 0C0H + reg2 * 8 + reg1); // and reg1, reg2
-PROCEDURE GlobalAdr*(offset: INTEGER);
+            drop
-BEGIN
-  OutByte(0BAH);
-  OutInt(offset);
-  current.codeadr := sys.ADR(Code[ccount - 4]);
+        |CODE.opADDSL, CODE.opADDSR:
-  current.tcmd := GCMD;
-PROCEDURE OutStringZ(str: ARRAY OF CHAR);
-VAR i: INTEGER;
-BEGIN
-  New;
-  current.clen := LENGTH(str);
-  FOR i := 0 TO current.clen - 1 DO
-    Code[ccount] := str[i];
+        BIN.PutData(program, CHL.GetByte(code.data, i))
-    INC(ccount)
+    END;

Subversion Repositories Kolibri OS

(root)/programs/develop/oberon07/Source/X86.ob07 – Rev 7209 → 7597