Subversion Repositories Kolibri OS

(*

    BSD 2-Clause License

    Copyright (c) 2018-2020, Anton Krotov

    All rights reserved.

*)

MODULE PE32;

IMPORT BIN, LISTS, UTILS, WR := WRITER, CHL := CHUNKLISTS;

CONST

    SIZE_OF_DWORD = 4;

    SIZE_OF_WORD  = 2;

    SIZE_OF_IMAGE_EXPORT_DIRECTORY = 40;

    IMAGE_NUMBEROF_DIRECTORY_ENTRIES = 16;

    IMAGE_SIZEOF_SHORT_NAME = 8;

    SIZE_OF_IMAGE_FILE_HEADER* = 20;

    SIZE_OF_IMAGE_SECTION_HEADER* = 40;

    (* SectionHeader.Characteristics *)

    SHC_text  = 060000020H;

    SHC_data  = 040000040H;

    SHC_bss   = 0C0000080H;

    SectionAlignment = 1000H;

    FileAlignment    =  200H;

TYPE

    WORD  = WCHAR;

    DWORD = INTEGER;

    NAME* = ARRAY IMAGE_SIZEOF_SHORT_NAME OF CHAR;

    IMAGE_DATA_DIRECTORY = RECORD

        VirtualAddress:  DWORD;

        Size:            DWORD

    END;

    IMAGE_OPTIONAL_HEADER = RECORD

        Magic:                        WORD;

        MajorLinkerVersion:           BYTE;

        MinorLinkerVersion:           BYTE;

        SizeOfCode:                   DWORD;

        SizeOfInitializedData:        DWORD;

        SizeOfUninitializedData:      DWORD;

        AddressOfEntryPoint:          DWORD;

        BaseOfCode:                   DWORD;

        BaseOfData:                   DWORD;

        ImageBase:                    DWORD;

        SectionAlignment:             DWORD;

        FileAlignment:                DWORD;

        MajorOperatingSystemVersion:  WORD;

        MinorOperatingSystemVersion:  WORD;

        MajorImageVersion:            WORD;

        MinorImageVersion:            WORD;

        MajorSubsystemVersion:        WORD;

        MinorSubsystemVersion:        WORD;

        Win32VersionValue:            DWORD;

        SizeOfImage:                  DWORD;

        SizeOfHeaders:                DWORD;

        CheckSum:                     DWORD;

        Subsystem:                    WORD;

        DllCharacteristics:           WORD;

        SizeOfStackReserve:           DWORD;

        SizeOfStackCommit:            DWORD;

        SizeOfHeapReserve:            DWORD;

        SizeOfHeapCommit:             DWORD;

        LoaderFlags:                  DWORD;

        NumberOfRvaAndSizes:          DWORD;

        DataDirectory: ARRAY IMAGE_NUMBEROF_DIRECTORY_ENTRIES OF IMAGE_DATA_DIRECTORY

    END;

    IMAGE_FILE_HEADER* = RECORD

        Machine*:               WORD;

        NumberOfSections*:      WORD;

        TimeDateStamp*:         DWORD;

        PointerToSymbolTable*:  DWORD;

        NumberOfSymbols*:       DWORD;

        SizeOfOptionalHeader*:  WORD;

        Characteristics*:       WORD

    END;

    IMAGE_SECTION_HEADER* = RECORD

        Name*: NAME;

        VirtualSize*,

        VirtualAddress*,

        SizeOfRawData*,

        PointerToRawData*,

        PointerToRelocations*,

        PointerToLinenumbers*:   DWORD;

        NumberOfRelocations*,

        NumberOfLinenumbers*:    WORD;

        Characteristics*:        DWORD

    END;

    IMAGE_EXPORT_DIRECTORY = RECORD

        Characteristics:       DWORD;

        TimeDateStamp:         DWORD;

        MajorVersion:          WORD;

        MinorVersion:          WORD;

        Name,

        Base,

        NumberOfFunctions,

        NumberOfNames,

        AddressOfFunctions,

        AddressOfNames,

        AddressOfNameOrdinals: DWORD

    END;

    VIRTUAL_ADDR* = RECORD

        Code*, Data*, Bss*, Import*: INTEGER

    END;

VAR

    Signature:       ARRAY 4 OF BYTE;

    FileHeader:      IMAGE_FILE_HEADER;

    OptionalHeader:  IMAGE_OPTIONAL_HEADER;

    msdos:           ARRAY 128 OF BYTE;

    SectionHeaders:  ARRAY 16 OF IMAGE_SECTION_HEADER;

    libcnt:          INTEGER;

    SizeOfWord:      INTEGER;

PROCEDURE Export (program: BIN.PROGRAM; name: INTEGER; VAR ExportDir: IMAGE_EXPORT_DIRECTORY): INTEGER;

BEGIN

    ExportDir.Characteristics        :=  0;

    ExportDir.TimeDateStamp          :=  FileHeader.TimeDateStamp;

    ExportDir.MajorVersion           :=  0X;

    ExportDir.MinorVersion           :=  0X;

    ExportDir.Name                   :=  name;

    ExportDir.Base                   :=  0;

    ExportDir.NumberOfFunctions      :=  LISTS.count(program.exp_list);

    ExportDir.NumberOfNames          :=  ExportDir.NumberOfFunctions;

    ExportDir.AddressOfFunctions     :=  SIZE_OF_IMAGE_EXPORT_DIRECTORY;

    ExportDir.AddressOfNames         :=  ExportDir.AddressOfFunctions + ExportDir.NumberOfFunctions * SIZE_OF_DWORD;

    ExportDir.AddressOfNameOrdinals  :=  ExportDir.AddressOfNames     + ExportDir.NumberOfFunctions * SIZE_OF_DWORD

    RETURN SIZE_OF_IMAGE_EXPORT_DIRECTORY + ExportDir.NumberOfFunctions * (2 * SIZE_OF_DWORD + SIZE_OF_WORD)

END Export;

PROCEDURE GetProcCount (lib: BIN.IMPRT): INTEGER;

VAR

    imp: BIN.IMPRT;

    res: INTEGER;

BEGIN

    res := 0;

    imp := lib.next(BIN.IMPRT);

    WHILE (imp # NIL) & (imp.label # 0) DO

        INC(res);

        imp := imp.next(BIN.IMPRT)

    END

    RETURN res

END GetProcCount;

PROCEDURE GetImportSize (imp_list: LISTS.LIST): INTEGER;

VAR

    imp: BIN.IMPRT;

    proccnt: INTEGER;

    procoffs: INTEGER;

    OriginalCurrentThunk,

    CurrentThunk: INTEGER;

BEGIN

    libcnt  := 0;

    proccnt := 0;

    imp  := imp_list.first(BIN.IMPRT);

    WHILE imp # NIL DO

        IF imp.label = 0 THEN

            INC(libcnt)

        ELSE

            INC(proccnt)

        END;

        imp := imp.next(BIN.IMPRT)

    END;

    procoffs := 0;

    imp  := imp_list.first(BIN.IMPRT);

    WHILE imp # NIL DO

        IF imp.label = 0 THEN

            imp.OriginalFirstThunk := procoffs;

            imp.FirstThunk := procoffs + (GetProcCount(imp) + 1);

            OriginalCurrentThunk := imp.OriginalFirstThunk;

            CurrentThunk := imp.FirstThunk;

            INC(procoffs, (GetProcCount(imp) + 1) * 2)

        ELSE

            imp.OriginalFirstThunk := OriginalCurrentThunk;

            imp.FirstThunk := CurrentThunk;

            INC(OriginalCurrentThunk);

            INC(CurrentThunk)

        END;

        imp := imp.next(BIN.IMPRT)

    END

    RETURN (libcnt + 1) * 5 * SIZE_OF_DWORD + (proccnt + libcnt) * 2 * SizeOfWord

END GetImportSize;

PROCEDURE fixup* (program: BIN.PROGRAM; Address: VIRTUAL_ADDR; amd64: BOOLEAN);

VAR

    reloc: BIN.RELOC;

    iproc: BIN.IMPRT;

    code:  CHL.BYTELIST;

    L, delta, delta0, AdrImp, offset: INTEGER;

BEGIN

    AdrImp := Address.Import + (libcnt + 1) * 5 * SIZE_OF_DWORD;

    code := program.code;

    reloc := program.rel_list.first(BIN.RELOC);

    delta0 := 3 - 7 * ORD(amd64) - Address.Code;

    WHILE reloc # NIL DO

        offset := reloc.offset;

        L := BIN.get32le(code, offset);

        delta := delta0 - offset;

        CASE reloc.opcode OF

        |BIN.PICDATA:

            INC(delta, L + Address.Data)

        |BIN.PICCODE:

            INC(delta, BIN.GetLabel(program, L) + Address.Code)

        |BIN.PICBSS:

            INC(delta, L + Address.Bss)

        |BIN.PICIMP:

            iproc := BIN.GetIProc(program, L);

            INC(delta, iproc.FirstThunk * SizeOfWord + AdrImp)

        END;

        BIN.put32le(code, offset, delta);

        reloc := reloc.next(BIN.RELOC)

    END

END fixup;

PROCEDURE WriteWord (w: WORD);

BEGIN

    WR.Write16LE(ORD(w))

END WriteWord;

PROCEDURE WriteName* (name: NAME);

VAR

    i, nameLen: INTEGER;

BEGIN

    nameLen := LENGTH(name);

    FOR i := 0 TO nameLen - 1 DO

        WR.WriteByte(ORD(name[i]))

    END;

    i := LEN(name) - nameLen;

    WHILE i > 0 DO

        WR.WriteByte(0);

        DEC(i)

    END

END WriteName;

PROCEDURE WriteSectionHeader* (h: IMAGE_SECTION_HEADER);

VAR

    i, nameLen: INTEGER;

BEGIN

    nameLen := LENGTH(h.Name);

    FOR i := 0 TO nameLen - 1 DO

        WR.WriteByte(ORD(h.Name[i]))

    END;

    i := LEN(h.Name) - nameLen;

    WHILE i > 0 DO

        WR.WriteByte(0);

        DEC(i)

    END;

    WR.Write32LE(h.VirtualSize);

    WR.Write32LE(h.VirtualAddress);

    WR.Write32LE(h.SizeOfRawData);

    WR.Write32LE(h.PointerToRawData);

    WR.Write32LE(h.PointerToRelocations);

    WR.Write32LE(h.PointerToLinenumbers);

    WriteWord(h.NumberOfRelocations);

    WriteWord(h.NumberOfLinenumbers);

    WR.Write32LE(h.Characteristics)

END WriteSectionHeader;

PROCEDURE WriteFileHeader* (h: IMAGE_FILE_HEADER);

BEGIN

    WriteWord(h.Machine);

    WriteWord(h.NumberOfSections);

    WR.Write32LE(h.TimeDateStamp);

    WR.Write32LE(h.PointerToSymbolTable);

    WR.Write32LE(h.NumberOfSymbols);

    WriteWord(h.SizeOfOptionalHeader);

    WriteWord(h.Characteristics)

END WriteFileHeader;

PROCEDURE write* (program: BIN.PROGRAM; FileName: ARRAY OF CHAR; console, dll, amd64: BOOLEAN);

VAR

    i, n, temp: INTEGER;

    Size: RECORD

        Code, Data, Bss, Import, Reloc, Export: INTEGER

    END;

    BaseAddress: INTEGER;

    Address: VIRTUAL_ADDR;

    _import:      BIN.IMPRT;

    ImportTable:  CHL.INTLIST;

    ExportDir:  IMAGE_EXPORT_DIRECTORY;

    export:     BIN.EXPRT;

    PROCEDURE WriteExportDir (e: IMAGE_EXPORT_DIRECTORY);

    BEGIN

        WR.Write32LE(e.Characteristics);

        WR.Write32LE(e.TimeDateStamp);

        WriteWord(e.MajorVersion);

        WriteWord(e.MinorVersion);

        WR.Write32LE(e.Name);

        WR.Write32LE(e.Base);

        WR.Write32LE(e.NumberOfFunctions);

        WR.Write32LE(e.NumberOfNames);

        WR.Write32LE(e.AddressOfFunctions);

        WR.Write32LE(e.AddressOfNames);

        WR.Write32LE(e.AddressOfNameOrdinals)

    END WriteExportDir;

    PROCEDURE WriteOptHeader (h: IMAGE_OPTIONAL_HEADER; amd64: BOOLEAN);

    VAR

        i: INTEGER;

    BEGIN

        WriteWord(h.Magic);

        WR.WriteByte(h.MajorLinkerVersion);

        WR.WriteByte(h.MinorLinkerVersion);

        WR.Write32LE(h.SizeOfCode);

        WR.Write32LE(h.SizeOfInitializedData);

        WR.Write32LE(h.SizeOfUninitializedData);

        WR.Write32LE(h.AddressOfEntryPoint);

        WR.Write32LE(h.BaseOfCode);

        IF amd64 THEN

            WR.Write64LE(h.ImageBase)

        ELSE

            WR.Write32LE(h.BaseOfData);

            WR.Write32LE(h.ImageBase)

        END;

        WR.Write32LE(h.SectionAlignment);

        WR.Write32LE(h.FileAlignment);

        WriteWord(h.MajorOperatingSystemVersion);

        WriteWord(h.MinorOperatingSystemVersion);

        WriteWord(h.MajorImageVersion);

        WriteWord(h.MinorImageVersion);

        WriteWord(h.MajorSubsystemVersion);

        WriteWord(h.MinorSubsystemVersion);

        WR.Write32LE(h.Win32VersionValue);

        WR.Write32LE(h.SizeOfImage);

        WR.Write32LE(h.SizeOfHeaders);

        WR.Write32LE(h.CheckSum);

        WriteWord(h.Subsystem);

        WriteWord(h.DllCharacteristics);

        IF amd64 THEN

            WR.Write64LE(h.SizeOfStackReserve);

            WR.Write64LE(h.SizeOfStackCommit);

            WR.Write64LE(h.SizeOfHeapReserve);

            WR.Write64LE(h.SizeOfHeapCommit)

        ELSE

            WR.Write32LE(h.SizeOfStackReserve);

            WR.Write32LE(h.SizeOfStackCommit);

            WR.Write32LE(h.SizeOfHeapReserve);

            WR.Write32LE(h.SizeOfHeapCommit)

        END;

        WR.Write32LE(h.LoaderFlags);

        WR.Write32LE(h.NumberOfRvaAndSizes);

        FOR i := 0 TO LEN(h.DataDirectory) - 1 DO

            WR.Write32LE(h.DataDirectory[i].VirtualAddress);

            WR.Write32LE(h.DataDirectory[i].Size)

        END

    END WriteOptHeader;

    PROCEDURE InitSection (VAR section: IMAGE_SECTION_HEADER; Name: NAME; VirtualSize: INTEGER; Characteristics: DWORD);

    BEGIN

        section.Name                  :=  Name;

        section.VirtualSize           :=  VirtualSize;

        section.SizeOfRawData         :=  WR.align(VirtualSize, FileAlignment);

        section.PointerToRelocations  :=  0;

        section.PointerToLinenumbers  :=  0;

        section.NumberOfRelocations   :=  0X;

        section.NumberOfLinenumbers   :=  0X;

        section.Characteristics       :=  Characteristics

    END InitSection;

BEGIN

    SizeOfWord := SIZE_OF_DWORD * (ORD(amd64) + 1);

    Size.Code  := CHL.Length(program.code);

    Size.Data  := CHL.Length(program.data);

    Size.Bss   := program.bss;

    IF dll THEN

        BaseAddress := 10000000H

    ELSE

        BaseAddress := 400000H

    END;

    Signature[0] := 50H;

    Signature[1] := 45H;

    Signature[2] := 0;

    Signature[3] := 0;

    IF amd64 THEN

        FileHeader.Machine := 08664X

    ELSE

        FileHeader.Machine := 014CX

    END;

    FileHeader.NumberOfSections := WCHR(4 + ORD(dll));

    FileHeader.TimeDateStamp         :=  UTILS.UnixTime();

    FileHeader.PointerToSymbolTable  :=  0H;

    FileHeader.NumberOfSymbols       :=  0H;

    FileHeader.SizeOfOptionalHeader  :=  WCHR(0E0H + 10H * ORD(amd64));

    FileHeader.Characteristics       :=  WCHR(010EH + (20H - 100H) * ORD(amd64) + 2000H * ORD(dll));

    OptionalHeader.Magic                        :=  WCHR(010BH + 100H * ORD(amd64));

    OptionalHeader.MajorLinkerVersion           :=  UTILS.vMajor;

    OptionalHeader.MinorLinkerVersion           :=  UTILS.vMinor;

    OptionalHeader.SizeOfCode                   :=  WR.align(Size.Code, FileAlignment);

    OptionalHeader.SizeOfInitializedData        :=  0;

    OptionalHeader.SizeOfUninitializedData      :=  0;

    OptionalHeader.AddressOfEntryPoint          :=  SectionAlignment;

    OptionalHeader.BaseOfCode                   :=  SectionAlignment;

    OptionalHeader.BaseOfData                   :=  OptionalHeader.BaseOfCode + WR.align(Size.Code, SectionAlignment);

    OptionalHeader.ImageBase                    :=  BaseAddress;

    OptionalHeader.SectionAlignment             :=  SectionAlignment;

    OptionalHeader.FileAlignment                :=  FileAlignment;

    OptionalHeader.MajorOperatingSystemVersion  :=  1X;

    OptionalHeader.MinorOperatingSystemVersion  :=  0X;

    OptionalHeader.MajorImageVersion            :=  0X;

    OptionalHeader.MinorImageVersion            :=  0X;

    OptionalHeader.MajorSubsystemVersion        :=  4X;

    OptionalHeader.MinorSubsystemVersion        :=  0X;

    OptionalHeader.Win32VersionValue            :=  0H;

    OptionalHeader.SizeOfImage                  :=  SectionAlignment;

    OptionalHeader.SizeOfHeaders                :=  400H;

    OptionalHeader.CheckSum                     :=  0;

    OptionalHeader.Subsystem                    :=  WCHR((2 + ORD(console)) * ORD(~dll));

    OptionalHeader.DllCharacteristics           :=  0040X;

    OptionalHeader.SizeOfStackReserve           :=  100000H;

    OptionalHeader.SizeOfStackCommit            :=  10000H;

    OptionalHeader.SizeOfHeapReserve            :=  100000H;

    OptionalHeader.SizeOfHeapCommit             :=  10000H;

    OptionalHeader.LoaderFlags                  :=  0;

    OptionalHeader.NumberOfRvaAndSizes          :=  IMAGE_NUMBEROF_DIRECTORY_ENTRIES;

    FOR i := 0 TO IMAGE_NUMBEROF_DIRECTORY_ENTRIES - 1 DO

        OptionalHeader.DataDirectory[i].VirtualAddress := 0;

        OptionalHeader.DataDirectory[i].Size := 0

    END;

    InitSection(SectionHeaders[0], ".text", Size.Code, SHC_text);

    SectionHeaders[0].VirtualAddress   := SectionAlignment;

    SectionHeaders[0].PointerToRawData := OptionalHeader.SizeOfHeaders;

    InitSection(SectionHeaders[1], ".data", Size.Data, SHC_data);

    SectionHeaders[1].VirtualAddress   := WR.align(SectionHeaders[0].VirtualAddress + SectionHeaders[0].VirtualSize, SectionAlignment);

    SectionHeaders[1].PointerToRawData := SectionHeaders[0].PointerToRawData + SectionHeaders[0].SizeOfRawData;

    InitSection(SectionHeaders[2], ".bss", Size.Bss, SHC_bss);

    SectionHeaders[2].VirtualAddress   := WR.align(SectionHeaders[1].VirtualAddress + SectionHeaders[1].VirtualSize, SectionAlignment);

    SectionHeaders[2].PointerToRawData := SectionHeaders[1].PointerToRawData + SectionHeaders[1].SizeOfRawData;

    SectionHeaders[2].SizeOfRawData    := 0;

    Size.Import := GetImportSize(program.imp_list);

    InitSection(SectionHeaders[3], ".idata", Size.Import + CHL.Length(program._import), SHC_data);

    SectionHeaders[3].VirtualAddress   := WR.align(SectionHeaders[2].VirtualAddress + SectionHeaders[2].VirtualSize, SectionAlignment);

    SectionHeaders[3].PointerToRawData := SectionHeaders[2].PointerToRawData + SectionHeaders[2].SizeOfRawData;

    Address.Code   := SectionHeaders[0].VirtualAddress + OptionalHeader.ImageBase;

    Address.Data   := SectionHeaders[1].VirtualAddress + OptionalHeader.ImageBase;

    Address.Bss    := SectionHeaders[2].VirtualAddress + OptionalHeader.ImageBase;

    Address.Import := SectionHeaders[3].VirtualAddress + OptionalHeader.ImageBase;

    fixup(program, Address, amd64);

    IF dll THEN

        Size.Export := Export(program, SectionHeaders[1].VirtualAddress + program.modname, ExportDir);

        InitSection(SectionHeaders[4], ".edata", Size.Export + CHL.Length(program.export), SHC_data);

        SectionHeaders[4].VirtualAddress   := WR.align(SectionHeaders[3].VirtualAddress + SectionHeaders[3].VirtualSize, SectionAlignment);

        SectionHeaders[4].PointerToRawData := SectionHeaders[3].PointerToRawData + SectionHeaders[3].SizeOfRawData;

        OptionalHeader.DataDirectory[0].VirtualAddress := SectionHeaders[4].VirtualAddress;

        OptionalHeader.DataDirectory[0].Size := SectionHeaders[4].VirtualSize

    END;

    OptionalHeader.DataDirectory[1].VirtualAddress := SectionHeaders[3].VirtualAddress;

    OptionalHeader.DataDirectory[1].Size := SectionHeaders[3].VirtualSize;

    FOR i := 1 TO ORD(FileHeader.NumberOfSections) - 1 DO

        INC(OptionalHeader.SizeOfInitializedData, SectionHeaders[i].SizeOfRawData)

    END;

    OptionalHeader.SizeOfUninitializedData := WR.align(SectionHeaders[2].VirtualSize, FileAlignment);

    FOR i := 0 TO ORD(FileHeader.NumberOfSections) - 1 DO

        INC(OptionalHeader.SizeOfImage, WR.align(SectionHeaders[i].VirtualSize, SectionAlignment))

    END;

    n := 0;

    BIN.InitArray(msdos, n, "4D5A80000100000004001000FFFF000040010000000000004000000000000000");

    BIN.InitArray(msdos, n, "0000000000000000000000000000000000000000000000000000000080000000");

    BIN.InitArray(msdos, n, "0E1FBA0E00B409CD21B8014CCD21546869732070726F6772616D2063616E6E6F");

    BIN.InitArray(msdos, n, "742062652072756E20696E20444F53206D6F64652E0D0A240000000000000000");

    WR.Create(FileName);

    WR.Write(msdos, LEN(msdos));

    WR.Write(Signature, LEN(Signature));

    WriteFileHeader(FileHeader);

    WriteOptHeader(OptionalHeader, amd64);

    FOR i := 0 TO ORD(FileHeader.NumberOfSections) - 1 DO

        WriteSectionHeader(SectionHeaders[i])

    END;

    WR.Padding(FileAlignment);

    CHL.WriteToFile(program.code);

    WR.Padding(FileAlignment);

    CHL.WriteToFile(program.data);

    WR.Padding(FileAlignment);

    n := (libcnt + 1) * 5;

    ImportTable := CHL.CreateIntList();

    FOR i := 0 TO (Size.Import - n * SIZE_OF_DWORD) DIV SizeOfWord + n - 1 DO

        CHL.PushInt(ImportTable, 0)

    END;

    i := 0;

    _import := program.imp_list.first(BIN.IMPRT);

    WHILE _import # NIL DO

        IF _import.label = 0 THEN

            CHL.SetInt(ImportTable, i + 0, _import.OriginalFirstThunk * SizeOfWord + SectionHeaders[3].VirtualAddress + n * SIZE_OF_DWORD);

            CHL.SetInt(ImportTable, i + 1, 0);

            CHL.SetInt(ImportTable, i + 2, 0);

            CHL.SetInt(ImportTable, i + 3, _import.nameoffs + Size.Import + SectionHeaders[3].VirtualAddress);

            CHL.SetInt(ImportTable, i + 4, _import.FirstThunk * SizeOfWord + SectionHeaders[3].VirtualAddress + n * SIZE_OF_DWORD);

            INC(i, 5)

        END;

        _import := _import.next(BIN.IMPRT)

    END;

    CHL.SetInt(ImportTable, i + 0, 0);

    CHL.SetInt(ImportTable, i + 1, 0);

    CHL.SetInt(ImportTable, i + 2, 0);

    CHL.SetInt(ImportTable, i + 3, 0);

    CHL.SetInt(ImportTable, i + 4, 0);

    _import := program.imp_list.first(BIN.IMPRT);

    WHILE _import # NIL DO

        IF _import.label # 0 THEN

            temp := _import.nameoffs + Size.Import + SectionHeaders[3].VirtualAddress - 2;

            CHL.SetInt(ImportTable, _import.OriginalFirstThunk + n, temp);

            CHL.SetInt(ImportTable, _import.FirstThunk + n,         temp)

        END;

        _import := _import.next(BIN.IMPRT)

    END;

    FOR i := 0 TO n - 1 DO

        WR.Write32LE(CHL.GetInt(ImportTable, i))

    END;

    FOR i := n TO CHL.Length(ImportTable) - 1 DO

        IF amd64 THEN

            WR.Write64LE(CHL.GetInt(ImportTable, i))

        ELSE

            WR.Write32LE(CHL.GetInt(ImportTable, i))

        END

    END;

    CHL.WriteToFile(program._import);

    WR.Padding(FileAlignment);

    IF dll THEN

        INC(ExportDir.AddressOfFunctions,    SectionHeaders[4].VirtualAddress);

        INC(ExportDir.AddressOfNames,        SectionHeaders[4].VirtualAddress);

        INC(ExportDir.AddressOfNameOrdinals, SectionHeaders[4].VirtualAddress);

        WriteExportDir(ExportDir);

        export := program.exp_list.first(BIN.EXPRT);

        WHILE export # NIL DO

            WR.Write32LE(export.label + SectionHeaders[0].VirtualAddress);

            export := export.next(BIN.EXPRT)

        END;

        export := program.exp_list.first(BIN.EXPRT);

        WHILE export # NIL DO

            WR.Write32LE(export.nameoffs + Size.Export + SectionHeaders[4].VirtualAddress);

            export := export.next(BIN.EXPRT)

        END;

        FOR i := 0 TO ExportDir.NumberOfFunctions - 1 DO

            WriteWord(WCHR(i))

        END;

        CHL.WriteToFile(program.export);

        WR.Padding(FileAlignment)

    END;

    WR.Close

END write;

END PE32.