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

 (*
     BSD 2-Clause License
-    Copyright (c) 2018-2019, Anton Krotov
+    Copyright (c) 2018-2020, Anton Krotov
     All rights reserved.
 *)
         Characteristics*:       WORD
-    END;
-    IMAGE_NT_HEADERS = RECORD
-        Signature:       ARRAY 4 OF BYTE;
-        FileHeader:      IMAGE_FILE_HEADER;
-        OptionalHeader:  IMAGE_OPTIONAL_HEADER
     END;
         AddressOfNameOrdinals: DWORD
     END;
-    VIRTUAL_ADDR = RECORD
-        Code, Data, Bss, Import: INTEGER
     VIRTUAL_ADDR* = RECORD
+        Code*, Data*, Bss*, Import*: INTEGER
+    END;
     END;
-    FILE = WR.FILE;
 VAR
 VAR
+    Signature:       ARRAY 4 OF BYTE;
-    msdos:           ARRAY 128 OF BYTE;
+    FileHeader:      IMAGE_FILE_HEADER;
-    PEHeader:        IMAGE_NT_HEADERS;
+    OptionalHeader:  IMAGE_OPTIONAL_HEADER;
-    SectionHeaders:  ARRAY 16 OF IMAGE_SECTION_HEADER;
-    Relocations:     LISTS.LIST;
+    msdos:           ARRAY 128 OF BYTE;
-    bit64:           BOOLEAN;
+    SectionHeaders:  ARRAY 16 OF IMAGE_SECTION_HEADER;
     libcnt:          INTEGER;
     SizeOfWord:      INTEGER;
-PROCEDURE Export (program: BIN.PROGRAM; DataRVA: INTEGER; VAR ExportDir: IMAGE_EXPORT_DIRECTORY): INTEGER;
+PROCEDURE Export (program: BIN.PROGRAM; name: INTEGER; VAR ExportDir: IMAGE_EXPORT_DIRECTORY): INTEGER;
 BEGIN
     RETURN SIZE_OF_IMAGE_EXPORT_DIRECTORY + ExportDir.NumberOfFunctions * (2 * SIZE_OF_DWORD + SIZE_OF_WORD)
-END Export;
-PROCEDURE align (n, _align: INTEGER): INTEGER;
-BEGIN
-    IF n MOD _align # 0 THEN
-        n := n + _align - (n MOD _align)
-    END
-    RETURN n
-END align;
+END Export;
 PROCEDURE GetProcCount (lib: BIN.IMPRT): INTEGER;
 VAR
-    import: BIN.IMPRT;
+    imp: BIN.IMPRT;
-    res:    INTEGER;
+    res: INTEGER;
 BEGIN
     res := 0;
-    import := lib.next(BIN.IMPRT);
+    imp := lib.next(BIN.IMPRT);
-    WHILE (import # NIL) & (import.label # 0) DO
+    WHILE (imp # NIL) & (imp.label # 0) DO
         INC(res);
-        import := import.next(BIN.IMPRT)
+        imp := imp.next(BIN.IMPRT)
     END
     RETURN res
 END GetProcCount;
 PROCEDURE GetImportSize (imp_list: LISTS.LIST): INTEGER;
 VAR
-    import: BIN.IMPRT;
+    imp: BIN.IMPRT;
     proccnt: INTEGER;
     procoffs: INTEGER;
     OriginalCurrentThunk,
     CurrentThunk: INTEGER;
 BEGIN
     libcnt  := 0;
     proccnt := 0;
-    import  := imp_list.first(BIN.IMPRT);
+    imp  := imp_list.first(BIN.IMPRT);
-    WHILE import # NIL DO
+    WHILE imp # NIL DO
-        IF import.label = 0 THEN
+        IF imp.label = 0 THEN
             INC(libcnt)
         ELSE
             INC(proccnt)
         END;
-        import := import.next(BIN.IMPRT)
+        imp := imp.next(BIN.IMPRT)
     END;
     procoffs := 0;
-    import  := imp_list.first(BIN.IMPRT);
+    imp  := imp_list.first(BIN.IMPRT);
-    WHILE import # NIL DO
+    WHILE imp # NIL DO
-        IF import.label = 0 THEN
+        IF imp.label = 0 THEN
-            import.OriginalFirstThunk := procoffs;
+            imp.OriginalFirstThunk := procoffs;
-            import.FirstThunk := procoffs + (GetProcCount(import) + 1);
+            imp.FirstThunk := procoffs + (GetProcCount(imp) + 1);
-            OriginalCurrentThunk := import.OriginalFirstThunk;
+            OriginalCurrentThunk := imp.OriginalFirstThunk;
-            CurrentThunk := import.FirstThunk;
+            CurrentThunk := imp.FirstThunk;
-            procoffs := procoffs + (GetProcCount(import) + 1) * 2
+            INC(procoffs, (GetProcCount(imp) + 1) * 2)
         ELSE
-            import.OriginalFirstThunk := OriginalCurrentThunk;
+            imp.OriginalFirstThunk := OriginalCurrentThunk;
-            import.FirstThunk := CurrentThunk;
+            imp.FirstThunk := CurrentThunk;
             INC(OriginalCurrentThunk);
             INC(CurrentThunk)
         END;
-        import := import.next(BIN.IMPRT)
+        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);
-PROCEDURE fixup (program: BIN.PROGRAM; Address: VIRTUAL_ADDR);
+VAR
-VAR
+    reloc: BIN.RELOC;
-    reloc: BIN.RELOC;
     iproc: BIN.IMPRT;
     code:  CHL.BYTELIST;
-    L, delta, delta0, AdrImp: INTEGER;
+    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(bit64);
+    delta0 := 3 - 7 * ORD(amd64) - Address.Code;
     WHILE reloc # NIL DO
+    WHILE reloc # NIL DO
-        L := BIN.get32le(code, reloc.offset);
+        offset := reloc.offset;
-        delta := delta0 - reloc.offset - Address.Code;
+        L := BIN.get32le(code, offset);
+        delta := delta0 - offset;
         CASE reloc.opcode OF
+        CASE reloc.opcode OF
         |BIN.PICDATA:
-              BIN.put32le(code, reloc.offset, L + Address.Data + delta)
+            INC(delta, L + Address.Data)
         |BIN.PICCODE:
-              BIN.put32le(code, reloc.offset, BIN.GetLabel(program, L) + Address.Code + delta)
+            INC(delta, BIN.GetLabel(program, L) + Address.Code)
         |BIN.PICBSS:
-              BIN.put32le(code, reloc.offset, L + Address.Bss + delta)
+            INC(delta, L + Address.Bss)
         |BIN.PICIMP:
-              iproc := BIN.GetIProc(program, L);
+            iproc := BIN.GetIProc(program, L);
-              BIN.put32le(code, reloc.offset, iproc.FirstThunk * SizeOfWord + AdrImp + delta)
+            INC(delta, iproc.FirstThunk * SizeOfWord + AdrImp)
         END;
-        END;
+        BIN.put32le(code, offset, delta);
         reloc := reloc.next(BIN.RELOC)
     END
 END fixup;
-PROCEDURE WriteWord (file: FILE; w: WORD);
+PROCEDURE WriteWord (w: WORD);
 BEGIN
-    WR.Write16LE(file, ORD(w))
+    WR.Write16LE(ORD(w))
 END WriteWord;
-PROCEDURE WriteName* (File: FILE; name: NAME);
+PROCEDURE WriteName* (name: NAME);
 VAR
     i, nameLen: INTEGER;
 BEGIN
     nameLen := LENGTH(name);
     FOR i := 0 TO nameLen - 1 DO
-        WR.WriteByte(File, ORD(name[i]))
+        WR.WriteByte(ORD(name[i]))
     END;
     i := LEN(name) - nameLen;
     WHILE i > 0 DO
-        WR.WriteByte(File, 0);
+        WR.WriteByte(0);
         DEC(i)
     END
 END WriteName;
-PROCEDURE WriteSectionHeader* (file: FILE; h: IMAGE_SECTION_HEADER);
+PROCEDURE WriteSectionHeader* (h: IMAGE_SECTION_HEADER);
 VAR
     i, nameLen: INTEGER;
 BEGIN
     nameLen := LENGTH(h.Name);
     FOR i := 0 TO nameLen - 1 DO
-        WR.WriteByte(file, ORD(h.Name[i]))
+        WR.WriteByte(ORD(h.Name[i]))
     END;
-    i := LEN(h.Name) - nameLen;
-    WHILE i > 0 DO
-        WR.WriteByte(file, 0);
+    i := LEN(h.Name) - nameLen;
-        DEC(i)
+    WHILE i > 0 DO
-    END;
+        WR.WriteByte(0);
+        DEC(i)
-    WR.Write32LE(file, h.VirtualSize);
+    END;
-    WR.Write32LE(file, h.VirtualAddress);
-    WR.Write32LE(file, h.SizeOfRawData);
+    WR.Write32LE(h.VirtualSize);
-    WR.Write32LE(file, h.PointerToRawData);
+    WR.Write32LE(h.VirtualAddress);
-    WR.Write32LE(file, h.PointerToRelocations);
+    WR.Write32LE(h.SizeOfRawData);
-    WR.Write32LE(file, h.PointerToLinenumbers);
+    WR.Write32LE(h.PointerToRawData);
+    WR.Write32LE(h.PointerToRelocations);
-    WriteWord(file, h.NumberOfRelocations);
+    WR.Write32LE(h.PointerToLinenumbers);
-    WriteWord(file, h.NumberOfLinenumbers);
+    WriteWord(h.NumberOfRelocations);
-    WR.Write32LE(file, h.Characteristics)
+    WriteWord(h.NumberOfLinenumbers);
-END WriteSectionHeader;
     WR.Write32LE(h.Characteristics)
+END WriteSectionHeader;
 PROCEDURE WriteFileHeader* (file: FILE; h: IMAGE_FILE_HEADER);
 BEGIN
-    WriteWord(file, h.Machine);
+PROCEDURE WriteFileHeader* (h: IMAGE_FILE_HEADER);
-    WriteWord(file, h.NumberOfSections);
+BEGIN
+    WriteWord(h.Machine);
-    WR.Write32LE(file, h.TimeDateStamp);
+    WriteWord(h.NumberOfSections);
-    WR.Write32LE(file, h.PointerToSymbolTable);
-    WR.Write32LE(file, h.NumberOfSymbols);
+    WR.Write32LE(h.TimeDateStamp);
+    WR.Write32LE(h.PointerToSymbolTable);
-    WriteWord(file, h.SizeOfOptionalHeader);
+    WR.Write32LE(h.NumberOfSymbols);
-    WriteWord(file, h.Characteristics)
-END WriteFileHeader;
+    WriteWord(h.SizeOfOptionalHeader);
+    WriteWord(h.Characteristics)
 END WriteFileHeader;
-PROCEDURE write* (program: BIN.PROGRAM; FileName: ARRAY OF CHAR; console, dll, amd64: BOOLEAN);
-VAR
-    i, n: INTEGER;
+PROCEDURE write* (program: BIN.PROGRAM; FileName: ARRAY OF CHAR; console, dll, amd64: BOOLEAN);
+VAR
-    Size: RECORD
+    i, n, temp: INTEGER;
+    Size: RECORD
+        Code, Data, Bss, Import, Reloc, Export: INTEGER
+    END;
+    BaseAddress: INTEGER;
+    Address: VIRTUAL_ADDR;
+    _import:      BIN.IMPRT;
-        Code, Data, Bss, Stack, Import, Reloc, Export: INTEGER
-    END;
-    BaseAddress: INTEGER;
-    Address: VIRTUAL_ADDR;
-    File: FILE;
-    import:       BIN.IMPRT;
     ImportTable:  CHL.INTLIST;
     ExportDir:  IMAGE_EXPORT_DIRECTORY;
     export:     BIN.EXPRT;
-    PROCEDURE WriteExportDir (file: FILE; e: IMAGE_EXPORT_DIRECTORY);
+    PROCEDURE WriteExportDir (e: IMAGE_EXPORT_DIRECTORY);
     BEGIN
-        WR.Write32LE(file, e.Characteristics);
+        WR.Write32LE(e.Characteristics);
-        WR.Write32LE(file, e.TimeDateStamp);
+        WR.Write32LE(e.TimeDateStamp);
-        WriteWord(file, e.MajorVersion);
+        WriteWord(e.MajorVersion);
-        WriteWord(file, e.MinorVersion);
+        WriteWord(e.MinorVersion);
-        WR.Write32LE(file, e.Name);
+        WR.Write32LE(e.Name);
-        WR.Write32LE(file, e.Base);
+        WR.Write32LE(e.Base);
-        WR.Write32LE(file, e.NumberOfFunctions);
+        WR.Write32LE(e.NumberOfFunctions);
-        WR.Write32LE(file, e.NumberOfNames);
+        WR.Write32LE(e.NumberOfNames);
-        WR.Write32LE(file, e.AddressOfFunctions);
+        WR.Write32LE(e.AddressOfFunctions);
-        WR.Write32LE(file, e.AddressOfNames);
+        WR.Write32LE(e.AddressOfNames);
-        WR.Write32LE(file, e.AddressOfNameOrdinals)
+        WR.Write32LE(e.AddressOfNameOrdinals)
-    END WriteExportDir;
-    PROCEDURE WriteOptHeader (file: FILE; h: IMAGE_OPTIONAL_HEADER);
-    VAR
-        i: INTEGER;
-    BEGIN
-        WriteWord(file, h.Magic);
+    END WriteExportDir;
         WR.WriteByte(file, h.MajorLinkerVersion);
+    PROCEDURE WriteOptHeader (h: IMAGE_OPTIONAL_HEADER; amd64: BOOLEAN);
+    VAR
-        WR.WriteByte(file, h.MinorLinkerVersion);
+        i: INTEGER;
-        WR.Write32LE(file, h.SizeOfCode);
+    BEGIN
-        WR.Write32LE(file, h.SizeOfInitializedData);
+        WriteWord(h.Magic);
         WR.Write32LE(file, h.SizeOfUninitializedData);
-        WR.Write32LE(file, h.AddressOfEntryPoint);
+        WR.WriteByte(h.MajorLinkerVersion);
-        WR.Write32LE(file, h.BaseOfCode);
+        WR.WriteByte(h.MinorLinkerVersion);
-        IF bit64 THEN
-            WR.Write64LE(file, h.ImageBase)
-        ELSE
+        WR.Write32LE(h.SizeOfCode);
-            WR.Write32LE(file, h.BaseOfData);
+        WR.Write32LE(h.SizeOfInitializedData);
-            WR.Write32LE(file, h.ImageBase)
+        WR.Write32LE(h.SizeOfUninitializedData);
-        END;
         WR.Write32LE(h.AddressOfEntryPoint);
-        WR.Write32LE(file, h.SectionAlignment);
+        WR.Write32LE(h.BaseOfCode);
         WR.Write32LE(file, h.FileAlignment);
         IF amd64 THEN
-        WriteWord(file, h.MajorOperatingSystemVersion);
+            WR.Write64LE(h.ImageBase)
-        WriteWord(file, h.MinorOperatingSystemVersion);
+        ELSE
-        WriteWord(file, h.MajorImageVersion);
+            WR.Write32LE(h.BaseOfData);
-        WriteWord(file, h.MinorImageVersion);
+            WR.Write32LE(h.ImageBase)
-        WriteWord(file, h.MajorSubsystemVersion);
+        END;
         WriteWord(file, h.MinorSubsystemVersion);
+        WR.Write32LE(h.SectionAlignment);
-        WR.Write32LE(file, h.Win32VersionValue);
+        WR.Write32LE(h.FileAlignment);
-        WR.Write32LE(file, h.SizeOfImage);
-        WR.Write32LE(file, h.SizeOfHeaders);
+        WriteWord(h.MajorOperatingSystemVersion);
-        WR.Write32LE(file, h.CheckSum);
+        WriteWord(h.MinorOperatingSystemVersion);
+        WriteWord(h.MajorImageVersion);
-        WriteWord(file, h.Subsystem);
+        WriteWord(h.MinorImageVersion);
-        WriteWord(file, h.DllCharacteristics);
+        WriteWord(h.MajorSubsystemVersion);
+        WriteWord(h.MinorSubsystemVersion);
-        IF bit64 THEN
-            WR.Write64LE(file, h.SizeOfStackReserve);
+        WR.Write32LE(h.Win32VersionValue);
-            WR.Write64LE(file, h.SizeOfStackCommit);
+        WR.Write32LE(h.SizeOfImage);
-            WR.Write64LE(file, h.SizeOfHeapReserve);
+        WR.Write32LE(h.SizeOfHeaders);
-            WR.Write64LE(file, h.SizeOfHeapCommit)
+        WR.Write32LE(h.CheckSum);
-        ELSE
-            WR.Write32LE(file, h.SizeOfStackReserve);
+        WriteWord(h.Subsystem);
-            WR.Write32LE(file, h.SizeOfStackCommit);
+        WriteWord(h.DllCharacteristics);
-            WR.Write32LE(file, h.SizeOfHeapReserve);
-            WR.Write32LE(file, h.SizeOfHeapCommit)
+        IF amd64 THEN
-        END;
+            WR.Write64LE(h.SizeOfStackReserve);
+            WR.Write64LE(h.SizeOfStackCommit);
-        WR.Write32LE(file, h.LoaderFlags);
+            WR.Write64LE(h.SizeOfHeapReserve);
-        WR.Write32LE(file, h.NumberOfRvaAndSizes);
+            WR.Write64LE(h.SizeOfHeapCommit)
+        ELSE
-        FOR i := 0 TO LEN(h.DataDirectory) - 1 DO
+            WR.Write32LE(h.SizeOfStackReserve);
-            WR.Write32LE(file, h.DataDirectory[i].VirtualAddress);
+            WR.Write32LE(h.SizeOfStackCommit);
-            WR.Write32LE(file, h.DataDirectory[i].Size)
+            WR.Write32LE(h.SizeOfHeapReserve);
-        END
+            WR.Write32LE(h.SizeOfHeapCommit)
+        END;
-    END WriteOptHeader;
+        WR.Write32LE(h.LoaderFlags);
+        WR.Write32LE(h.NumberOfRvaAndSizes);
-    PROCEDURE WritePEHeader (file: FILE; h: IMAGE_NT_HEADERS);
-    BEGIN
+        FOR i := 0 TO LEN(h.DataDirectory) - 1 DO
-        WR.Write(file, h.Signature, LEN(h.Signature));
+            WR.Write32LE(h.DataDirectory[i].VirtualAddress);
-        WriteFileHeader(file, h.FileHeader);
+            WR.Write32LE(h.DataDirectory[i].Size)
-        WriteOptHeader(file, h.OptionalHeader)
+        END
-    END WritePEHeader;
+    END WriteOptHeader;
-    PROCEDURE InitSection (VAR section: IMAGE_SECTION_HEADER; Name: NAME; Characteristics: DWORD);
+    PROCEDURE InitSection (VAR section: IMAGE_SECTION_HEADER; Name: NAME; VirtualSize: INTEGER; Characteristics: DWORD);
+    BEGIN
-    BEGIN
+        section.Name                  :=  Name;
+        section.VirtualSize           :=  VirtualSize;
+        section.SizeOfRawData         :=  WR.align(VirtualSize, FileAlignment);
-        section.Name                  :=  Name;
+        section.PointerToRelocations  :=  0;
-        section.PointerToRelocations  :=  0;
+        section.PointerToLinenumbers  :=  0;
-        section.PointerToLinenumbers  :=  0;
         section.NumberOfRelocations   :=  0X;
         section.NumberOfLinenumbers   :=  0X;
-        section.Characteristics       :=  Characteristics
-    END InitSection;
+        section.Characteristics       :=  Characteristics
     END InitSection;
-BEGIN
-    bit64 := amd64;
-    SizeOfWord := SIZE_OF_DWORD * (ORD(bit64) + 1);
-    Relocations := LISTS.create(NIL);
 BEGIN
+    SizeOfWord := SIZE_OF_DWORD * (ORD(amd64) + 1);
     Size.Code  := CHL.Length(program.code);
-    Size.Data  := CHL.Length(program.data);
-    Size.Bss   := program.bss;
+    Size.Code  := CHL.Length(program.code);
-    Size.Stack := program.stack;
+    Size.Data  := CHL.Length(program.data);
-    IF dll THEN
+    Size.Bss   := program.bss;
-        BaseAddress := 10000000H
-    ELSE
+    IF dll THEN
-        BaseAddress := 400000H
+        BaseAddress := 10000000H
-    END;
+    ELSE
+        BaseAddress := 400000H
-    PEHeader.Signature[0] := 50H;
+    END;
-    PEHeader.Signature[1] := 45H;
-    PEHeader.Signature[2] := 0;
-    PEHeader.Signature[3] := 0;
+    Signature[0] := 50H;
+    Signature[1] := 45H;
-    IF amd64 THEN
-        PEHeader.FileHeader.Machine := 08664X
+    Signature[2] := 0;
-    ELSE
-        PEHeader.FileHeader.Machine := 014CX
-    END;
+    Signature[3] := 0;
-    PEHeader.FileHeader.NumberOfSections := WCHR(4 + ORD(dll));
+    IF amd64 THEN
-    PEHeader.FileHeader.TimeDateStamp         :=  UTILS.UnixTime();
+        FileHeader.Machine := 08664X
-    PEHeader.FileHeader.PointerToSymbolTable  :=  0H;
+    ELSE
-    PEHeader.FileHeader.NumberOfSymbols       :=  0H;
-    PEHeader.FileHeader.SizeOfOptionalHeader  :=  WCHR(0E0H + 10H * ORD(amd64));
-    PEHeader.FileHeader.Characteristics       :=  WCHR(010EH + (20H - 100H) * ORD(amd64) + 2000H * ORD(dll));
-    PEHeader.OptionalHeader.Magic                        :=  WCHR(010BH + 100H * ORD(amd64));
+        FileHeader.Machine := 014CX
-    PEHeader.OptionalHeader.MajorLinkerVersion           :=  UTILS.vMajor;
+    END;
     PEHeader.OptionalHeader.MinorLinkerVersion           :=  UTILS.vMinor;
-    PEHeader.OptionalHeader.SizeOfCode                   :=  align(Size.Code, FileAlignment);
-    PEHeader.OptionalHeader.SizeOfInitializedData        :=  0;
-    PEHeader.OptionalHeader.SizeOfUninitializedData      :=  0;
-    PEHeader.OptionalHeader.AddressOfEntryPoint          :=  SectionAlignment;
+    FileHeader.NumberOfSections := WCHR(4 + ORD(dll));
-    PEHeader.OptionalHeader.BaseOfCode                   :=  SectionAlignment;
-    PEHeader.OptionalHeader.BaseOfData                   :=  PEHeader.OptionalHeader.BaseOfCode + align(Size.Code, SectionAlignment);
+    FileHeader.TimeDateStamp         :=  UTILS.UnixTime();
-    PEHeader.OptionalHeader.ImageBase                    :=  BaseAddress;
+    FileHeader.PointerToSymbolTable  :=  0H;
-    PEHeader.OptionalHeader.SectionAlignment             :=  SectionAlignment;
+    FileHeader.NumberOfSymbols       :=  0H;
-    PEHeader.OptionalHeader.FileAlignment                :=  FileAlignment;
+    FileHeader.SizeOfOptionalHeader  :=  WCHR(0E0H + 10H * ORD(amd64));
-    PEHeader.OptionalHeader.MajorOperatingSystemVersion  :=  1X;
+    FileHeader.Characteristics       :=  WCHR(010EH + (20H - 100H) * ORD(amd64) + 2000H * ORD(dll));
     PEHeader.OptionalHeader.MinorOperatingSystemVersion  :=  0X;
-    PEHeader.OptionalHeader.MajorImageVersion            :=  0X;
+    OptionalHeader.Magic                        :=  WCHR(010BH + 100H * ORD(amd64));
-    PEHeader.OptionalHeader.MinorImageVersion            :=  0X;
+    OptionalHeader.MajorLinkerVersion           :=  UTILS.vMajor;
-    PEHeader.OptionalHeader.MajorSubsystemVersion        :=  4X;
+    OptionalHeader.MinorLinkerVersion           :=  UTILS.vMinor;
+    OptionalHeader.SizeOfCode                   :=  WR.align(Size.Code, FileAlignment);
-    PEHeader.OptionalHeader.MinorSubsystemVersion        :=  0X;
+    OptionalHeader.SizeOfInitializedData        :=  0;
+    OptionalHeader.SizeOfUninitializedData      :=  0;
-    PEHeader.OptionalHeader.Win32VersionValue            :=  0H;
+    OptionalHeader.AddressOfEntryPoint          :=  SectionAlignment;
-    PEHeader.OptionalHeader.SizeOfImage                  :=  SectionAlignment;
+    OptionalHeader.BaseOfCode                   :=  SectionAlignment;
-    PEHeader.OptionalHeader.SizeOfHeaders                :=  400H;
+    OptionalHeader.BaseOfData                   :=  OptionalHeader.BaseOfCode + WR.align(Size.Code, SectionAlignment);
-    PEHeader.OptionalHeader.CheckSum                     :=  0;
+    OptionalHeader.ImageBase                    :=  BaseAddress;
-    PEHeader.OptionalHeader.Subsystem                    :=  WCHR((2 + ORD(console)) * ORD(~dll));
+    OptionalHeader.SectionAlignment             :=  SectionAlignment;
-    PEHeader.OptionalHeader.DllCharacteristics           :=  0040X;
+    OptionalHeader.FileAlignment                :=  FileAlignment;
-    PEHeader.OptionalHeader.SizeOfStackReserve           :=  Size.Stack;
+    OptionalHeader.MajorOperatingSystemVersion  :=  1X;
-    PEHeader.OptionalHeader.SizeOfStackCommit            :=  Size.Stack DIV 16;
+    OptionalHeader.MinorOperatingSystemVersion  :=  0X;
-    PEHeader.OptionalHeader.SizeOfHeapReserve            :=  100000H;
+    OptionalHeader.MajorImageVersion            :=  0X;
-    PEHeader.OptionalHeader.SizeOfHeapCommit             :=  10000H;
+    OptionalHeader.MinorImageVersion            :=  0X;
-    PEHeader.OptionalHeader.LoaderFlags                  :=  0;
+    OptionalHeader.MajorSubsystemVersion        :=  4X;
-    PEHeader.OptionalHeader.NumberOfRvaAndSizes          :=  IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
+    OptionalHeader.MinorSubsystemVersion        :=  0X;
     OptionalHeader.Win32VersionValue            :=  0H;
-    InitSection(SectionHeaders[0], ".text", SHC_text);
+    OptionalHeader.SizeOfImage                  :=  SectionAlignment;
-    SectionHeaders[0].VirtualSize      := Size.Code;
+    OptionalHeader.SizeOfHeaders                :=  400H;
-    SectionHeaders[0].VirtualAddress   := SectionAlignment;
+    OptionalHeader.CheckSum                     :=  0;
-    SectionHeaders[0].SizeOfRawData    := align(Size.Code, FileAlignment);
+    OptionalHeader.Subsystem                    :=  WCHR((2 + ORD(console)) * ORD(~dll));
-    SectionHeaders[0].PointerToRawData := PEHeader.OptionalHeader.SizeOfHeaders;
+    OptionalHeader.DllCharacteristics           :=  0040X;
     OptionalHeader.SizeOfStackReserve           :=  100000H;
-    InitSection(SectionHeaders[1], ".data", SHC_data);
+    OptionalHeader.SizeOfStackCommit            :=  10000H;
-    SectionHeaders[1].VirtualSize      := Size.Data;
+    OptionalHeader.SizeOfHeapReserve            :=  100000H;
-    SectionHeaders[1].VirtualAddress   := align(SectionHeaders[0].VirtualAddress + SectionHeaders[0].VirtualSize, SectionAlignment);
+    OptionalHeader.SizeOfHeapCommit             :=  10000H;
-    SectionHeaders[1].SizeOfRawData    := align(Size.Data, FileAlignment);
+    OptionalHeader.LoaderFlags                  :=  0;
-    SectionHeaders[1].PointerToRawData := SectionHeaders[0].PointerToRawData + SectionHeaders[0].SizeOfRawData;
+    OptionalHeader.NumberOfRvaAndSizes          :=  IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
-    InitSection(SectionHeaders[2], ".bss", SHC_bss);
+    FOR i := 0 TO IMAGE_NUMBEROF_DIRECTORY_ENTRIES - 1 DO
-    SectionHeaders[2].VirtualSize      := Size.Bss;
+        OptionalHeader.DataDirectory[i].VirtualAddress := 0;
-    SectionHeaders[2].VirtualAddress   := align(SectionHeaders[1].VirtualAddress + SectionHeaders[1].VirtualSize, SectionAlignment);
+        OptionalHeader.DataDirectory[i].Size := 0
-    SectionHeaders[2].SizeOfRawData    := 0;
+    END;
     SectionHeaders[2].PointerToRawData := SectionHeaders[1].PointerToRawData + SectionHeaders[1].SizeOfRawData;
     InitSection(SectionHeaders[0], ".text", Size.Code, SHC_text);
-    Size.Import := GetImportSize(program.imp_list);
+    SectionHeaders[0].VirtualAddress   := SectionAlignment;
+    SectionHeaders[0].PointerToRawData := OptionalHeader.SizeOfHeaders;
-    InitSection(SectionHeaders[3], ".idata", SHC_data);
-    SectionHeaders[3].VirtualSize      := Size.Import + CHL.Length(program.import);
+    InitSection(SectionHeaders[1], ".data", Size.Data, SHC_data);
+    SectionHeaders[1].VirtualAddress   := WR.align(SectionHeaders[0].VirtualAddress + SectionHeaders[0].VirtualSize, SectionAlignment);
-    SectionHeaders[3].VirtualAddress   := align(SectionHeaders[2].VirtualAddress + SectionHeaders[2].VirtualSize, SectionAlignment);
+    SectionHeaders[1].PointerToRawData := SectionHeaders[0].PointerToRawData + SectionHeaders[0].SizeOfRawData;
     SectionHeaders[3].SizeOfRawData    := align(SectionHeaders[3].VirtualSize, FileAlignment);
-    SectionHeaders[3].PointerToRawData := SectionHeaders[2].PointerToRawData + SectionHeaders[2].SizeOfRawData;
+    InitSection(SectionHeaders[2], ".bss", Size.Bss, SHC_bss);
     SectionHeaders[2].VirtualAddress   := WR.align(SectionHeaders[1].VirtualAddress + SectionHeaders[1].VirtualSize, SectionAlignment);
-    Address.Code   := SectionHeaders[0].VirtualAddress + PEHeader.OptionalHeader.ImageBase;
+    SectionHeaders[2].PointerToRawData := SectionHeaders[1].PointerToRawData + SectionHeaders[1].SizeOfRawData;
-    Address.Data   := SectionHeaders[1].VirtualAddress + PEHeader.OptionalHeader.ImageBase;
+    SectionHeaders[2].SizeOfRawData    := 0;
     Address.Bss    := SectionHeaders[2].VirtualAddress + PEHeader.OptionalHeader.ImageBase;
-    Address.Import := SectionHeaders[3].VirtualAddress + PEHeader.OptionalHeader.ImageBase;
+    Size.Import := GetImportSize(program.imp_list);
-    fixup(program, Address);
+    InitSection(SectionHeaders[3], ".idata", Size.Import + CHL.Length(program._import), SHC_data);
     SectionHeaders[3].VirtualAddress   := WR.align(SectionHeaders[2].VirtualAddress + SectionHeaders[2].VirtualSize, SectionAlignment);
-    IF dll THEN
+    SectionHeaders[3].PointerToRawData := SectionHeaders[2].PointerToRawData + SectionHeaders[2].SizeOfRawData;
         Size.Export := Export(program, SectionHeaders[1].VirtualAddress, ExportDir);
     Address.Code   := SectionHeaders[0].VirtualAddress + OptionalHeader.ImageBase;
-        InitSection(SectionHeaders[4], ".edata", SHC_data);
+    Address.Data   := SectionHeaders[1].VirtualAddress + OptionalHeader.ImageBase;
-        SectionHeaders[4].VirtualSize      := Size.Export + CHL.Length(program.export);
+    Address.Bss    := SectionHeaders[2].VirtualAddress + OptionalHeader.ImageBase;
-        SectionHeaders[4].VirtualAddress   := align(SectionHeaders[3].VirtualAddress + SectionHeaders[3].VirtualSize, SectionAlignment);
+    Address.Import := SectionHeaders[3].VirtualAddress + OptionalHeader.ImageBase;
         SectionHeaders[4].SizeOfRawData    := align(SectionHeaders[4].VirtualSize, FileAlignment);
-        SectionHeaders[4].PointerToRawData := SectionHeaders[3].PointerToRawData + SectionHeaders[3].SizeOfRawData;
+    fixup(program, Address, amd64);
     END;
+    IF dll THEN
-    FOR i := 0 TO IMAGE_NUMBEROF_DIRECTORY_ENTRIES - 1 DO
+        Size.Export := Export(program, SectionHeaders[1].VirtualAddress + program.modname, ExportDir);
         PEHeader.OptionalHeader.DataDirectory[i].VirtualAddress := 0;
-        PEHeader.OptionalHeader.DataDirectory[i].Size := 0
+        InitSection(SectionHeaders[4], ".edata", Size.Export + CHL.Length(program.export), SHC_data);
-    END;
+        SectionHeaders[4].VirtualAddress   := WR.align(SectionHeaders[3].VirtualAddress + SectionHeaders[3].VirtualSize, SectionAlignment);
         SectionHeaders[4].PointerToRawData := SectionHeaders[3].PointerToRawData + SectionHeaders[3].SizeOfRawData;
     IF dll THEN
-        PEHeader.OptionalHeader.DataDirectory[0].VirtualAddress := SectionHeaders[4].VirtualAddress;
+        OptionalHeader.DataDirectory[0].VirtualAddress := SectionHeaders[4].VirtualAddress;
-        PEHeader.OptionalHeader.DataDirectory[0].Size := SectionHeaders[4].VirtualSize
+        OptionalHeader.DataDirectory[0].Size := SectionHeaders[4].VirtualSize
     END;
-    PEHeader.OptionalHeader.DataDirectory[1].VirtualAddress := SectionHeaders[3].VirtualAddress;
+    OptionalHeader.DataDirectory[1].VirtualAddress := SectionHeaders[3].VirtualAddress;
-    PEHeader.OptionalHeader.DataDirectory[1].Size := SectionHeaders[3].VirtualSize;
+    OptionalHeader.DataDirectory[1].Size := SectionHeaders[3].VirtualSize;
-    FOR i := 0 TO ORD(PEHeader.FileHeader.NumberOfSections) - 1 DO
+    FOR i := 1 TO ORD(FileHeader.NumberOfSections) - 1 DO
-        INC(PEHeader.OptionalHeader.SizeOfInitializedData, SectionHeaders[i].SizeOfRawData)
+        INC(OptionalHeader.SizeOfInitializedData, SectionHeaders[i].SizeOfRawData)
     END;
-    DEC(PEHeader.OptionalHeader.SizeOfInitializedData, SectionHeaders[0].SizeOfRawData);
+    OptionalHeader.SizeOfUninitializedData := WR.align(SectionHeaders[2].VirtualSize, FileAlignment);
     DEC(PEHeader.OptionalHeader.SizeOfInitializedData, SectionHeaders[2].SizeOfRawData);
     FOR i := 0 TO ORD(FileHeader.NumberOfSections) - 1 DO

Subversion Repositories Kolibri OS

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