Attempt to get ogcoff to work on CPU with opposite endianness

compiler/ogcoff.pas

@@ -571,6 +571,317 @@ implementation
          zero_fill_size : dword;
          flags : dword;
        end;
+       { MaybeSwap procedures 
+       tcoffpedatadir = packed record
+         vaddr : longword;
+         size  : longword;
+       end; }
+   procedure MaybeSwap(var v : tcoffpedatadir);
+      begin
+        if source_info.endian<>target_info.endian then
+          begin
+            v.vaddr:=SwapEndian(v.vaddr);
+            v.size:=SwapEndian(v.size);
+          end;
+      end;
+ (*
+       tcoffheader = packed record
+         mach   : word;
+         nsects : word;
+         time   : longword;
+         sympos : longword;
+         syms   : longword;
+         opthdr : word;
+         flag   : word;
+       end; *)
+   procedure MaybeSwap(var v : tcoffheader);
+      begin
+        if source_info.endian<>target_info.endian then
+          begin
+            v.mach:=SwapEndian(v.mach);
+            v.nsects:=SwapEndian(v.nsects);
+            v.time:=SwapEndian(v.time);
+            v.sympos:=SwapEndian(v.sympos);
+            v.syms:=SwapEndian(v.syms);
+            v.opthdr:=SwapEndian(v.opthdr);
+            v.flag:=SwapEndian(v.flag);
+          end;
+      end;
+(*
+       tcoffbigobjheader = packed record
+         Sig1 : word;
+         Sig2 : word;
+         Version : word;
+         Machine : word;
+         TimeDateStame : longword;
+         UUID : array[0..15] of byte;
+         unused : array[0..3] of longword;
+         NumberOfSections : longword;
+         PointerToSymbolTable : longword;
+         NumberOfSymbols : longword;
+       end; *)
+   procedure MaybeSwap(var v : tcoffbigobjheader);
+      begin
+        if source_info.endian<>target_info.endian then
+          begin
+            v.Sig1:=SwapEndian(v.Sig1);
+            v.Sig2:=SwapEndian(v.Sig2);
+            v.Version:=SwapEndian(v.Version);
+            v.Machine:=SwapEndian(v.Machine);
+            v.TimeDateStame:=SwapEndian(v.TimeDateStame);
+	    { UUID byte array no swap neeeded }
+	    { Assume unused fields are indeed really unused }
+            v.NumberOfSections:=SwapEndian(v.NumberOfSections);
+            v.PointerToSymbolTable:=SwapEndian(v.PointerToSymbolTable);
+            v.NumberOfSymbols:=SwapEndian(v.NumberOfSymbols);
+          end;
+      end;
+
+(*       tcoffpeoptheader = packed record
+         Magic : word;
+         MajorLinkerVersion : byte;
+         MinorLinkerVersion : byte;
+         tsize : longword;
+         dsize : longword;
+         bsize : longword;
+         entry : longword;
+         text_start : longword;
+{$ifndef cpu64bitaddr}
+         data_start : longword;
+{$endif cpu64bitaddr}
+         ImageBase : aword;
+         SectionAlignment : longword;
+         FileAlignment : longword;
+         MajorOperatingSystemVersion : word;
+         MinorOperatingSystemVersion : word;
+         MajorImageVersion : word;
+         MinorImageVersion : word;
+         MajorSubsystemVersion : word;
+         MinorSubsystemVersion : word;
+         Win32Version : longword;
+         SizeOfImage : longword;
+         SizeOfHeaders : longword;
+         CheckSum : longword;
+         Subsystem : word;
+         DllCharacteristics : word;
+         SizeOfStackReserve : aword;
+         SizeOfStackCommit : aword;
+         SizeOfHeapReserve : aword;
+         SizeOfHeapCommit : aword;
+         LoaderFlags : longword;          { This field is obsolete }
+         NumberOfRvaAndSizes : longword;
+         DataDirectory : array[0..PE_DATADIR_ENTRIES-1] of tcoffpedatadir;
+       end; *)
+    procedure MaybeSwap(var v : tcoffpeoptheader);
+      var
+        i : longint;
+      begin
+        if source_info.endian<>target_info.endian then
+          begin
+            v.Magic:=SwapEndian(v.Magic);
+            v.tsize:=SwapEndian(v.tsize);
+            v.dsize:=SwapEndian(v.dsize);
+            v.bsize:=SwapEndian(v.bsize);
+            v.entry:=SwapEndian(v.entry);
+            v.text_start:=SwapEndian(v.text_start);
+{$ifndef cpu64bitaddr}
+            v.data_start:SwapEndian(v.data_start);
+{$endif cpu64bitaddr}
+            v.ImageBase:=SwapEndian(v.ImageBase);
+            v.SectionAlignment:=SwapEndian(v.SectionAlignment);
+            v.FileAlignment:=SwapEndian(v.FileAlignment);
+            v.MajorOperatingSystemVersion:=SwapEndian(v.MajorOperatingSystemVersion);
+            v.MinorOperatingSystemVersion:=SwapEndian(v.MinorOperatingSystemVersion);
+            v.MajorImageVersion:=SwapEndian(v.MajorImageVersion);
+            v.MinorImageVersion:=SwapEndian(v.MinorImageVersion);
+            v.MajorSubsystemVersion:=SwapEndian(v.MajorSubsystemVersion);
+            v.MinorSubsystemVersion:=SwapEndian(v.MinorSubsystemVersion);
+            v.Win32Version:=SwapEndian(v.Win32Version);
+            v.SizeOfImage:=SwapEndian(v.SizeOfImage);
+            v.SizeOfHeaders:=SwapEndian(v.SizeOfHeaders);
+            v.CheckSum:=SwapEndian(v.CheckSum);
+            v.Subsystem:=SwapEndian(v.Subsystem);
+            v.DllCharacteristics:=SwapEndian(v.DllCharacteristics);
+            v.SizeOfStackReserve:=SwapEndian(v.SizeOfStackReserve);
+            v.SizeOfStackCommit:=SwapEndian(v.SizeOfStackCommit);
+            v.SizeOfHeapReserve:=SwapEndian(v.SizeOfHeapReserve);
+            v.SizeOfHeapCommit:=SwapEndian(v.SizeOfHeapCommit);
+            v.LoaderFlags:=SwapEndian(v.LoaderFlags);
+            v.NumberOfRvaAndSizes:=SwapEndian(v.NumberOfRvaAndSizes);
+	    for i:=0 to PE_DATADIR_ENTRIES-1 do
+              MaybeSwap(v.DataDirectory[i]);
+          end;
+      end;
+
+(*
+       tcoffsechdr = packed record
+         name     : array[0..7] of char;
+         vsize    : longword;
+         rvaofs   : longword;
+         datasize : longword;
+         datapos  : longword;
+         relocpos : longword;
+         lineno1  : longword;
+         nrelocs  : word;
+         lineno2  : word;
+         flags    : longword;
+       end; *)
+    procedure MaybeSwap(var v : tcoffsechdr);
+      begin
+        if source_info.endian<>target_info.endian then
+          begin
+            v.vsize:=SwapEndian(v.vsize);
+            v.rvaofs:=SwapEndian(v.rvaofs);
+            v.datasize:=SwapEndian(v.datasize);
+            v.datapos:=SwapEndian(v.datapos);
+            v.relocpos:=SwapEndian(v.relocpos);
+            v.lineno1:=SwapEndian(v.lineno1);
+            v.nrelocs:=SwapEndian(v.nrelocs);
+            v.lineno2:=SwapEndian(v.lineno2);
+            v.flags:=SwapEndian(v.flags);
+          end;
+      end;
+(*
+      coffdjoptheader=packed record
+         magic  : word;
+         vstamp : word;
+         tsize  : longint;
+         dsize  : longint;
+         bsize  : longint;
+         entry  : longint;
+         text_start : longint;
+         data_start : longint;
+       end; *)
+    procedure MaybeSwap(var v : coffdjoptheader);
+      begin
+        if source_info.endian<>target_info.endian then
+          begin
+            v.magic:=SwapEndian(v.magic);
+            v.vstamp:=SwapEndian(v.vstamp);
+            v.tsize:=SwapEndian(v.tsize);
+            v.dsize:=SwapEndian(v.dsize);
+            v.bsize:=SwapEndian(v.bsize);
+            v.entry:=SwapEndian(v.entry);
+            v.text_start:=SwapEndian(v.text_start);
+            v.data_start:=SwapEndian(v.data_start);
+          end;
+      end;
+(*
+       coffsectionrec=packed record
+         len     : longword;
+         nrelocs : word;
+         nlines  : word;
+         checksum: longword;
+         assoc   : word;
+         select  : byte;
+         empty   : array[0..2] of char;
+       end; *)
+    procedure MaybeSwap(var v : coffsectionrec);
+      begin
+        if source_info.endian<>target_info.endian then
+          begin
+            v.len:=SwapEndian(v.len);
+            v.nrelocs:=SwapEndian(v.nrelocs);
+            v.nlines:=SwapEndian(v.nlines);
+            v.checksum:=SwapEndian(v.checksum);
+            v.assoc:=SwapEndian(v.assoc);
+          end;
+      end;
+(*
+       coffreloc=packed record
+         address  : longword;
+         sym      : longword;
+         reloctype : word;
+       end; *)
+    procedure MaybeSwap(var v : coffreloc);
+      begin
+        if source_info.endian<>target_info.endian then
+          begin
+            v.address:=SwapEndian(v.address);
+            v.sym:=SwapEndian(v.sym);
+            v.reloctype:=SwapEndian(v.reloctype);
+          end;
+      end;
+(*
+       strtableoffset=packed record
+         Zeroes : longword;
+         Offset : longword;
+       end;*)
+    procedure MaybeSwap(var v : strtableoffset);
+      begin
+        if source_info.endian<>target_info.endian then
+          begin
+            v.Zeroes:=SwapEndian(v.Zeroes);
+            v.Offset:=SwapEndian(v.Offset);
+          end;
+      end;
+(*
+       coffsymbol=packed record
+         name    : array[0..3] of char; { real is [0..7], which overlaps the strpos ! }
+         strpos  : longword;
+         value   : longword;
+         section : smallint;
+         empty   : word;                { actually type, $20: function, 0: not a function }
+         typ     : byte;
+         aux     : byte;
+       end; *)
+    procedure MaybeSwap(var v : coffsymbol);
+      begin
+        if source_info.endian<>target_info.endian then
+          begin
+            if v.name[0]=#0 then
+              v.strpos:=SwapEndian(v.strpos);
+            v.value:=SwapEndian(v.value);
+            v.section:=SwapEndian(v.section);
+            v.empty:=SwapEndian(v.empty);
+          end;
+      end;
+(*
+       coffbigobjsymbol=packed record
+         Name               : record
+                                case boolean of
+                                  True: (ShortName : array[0..7] of char);
+                                  False: (Offset : strtableoffset)
+                              end;
+         Value              : longword;
+         SectionNumber      : longword;
+         _Type              : word;
+         StorageClass       : byte;
+         NumberOfAuxSymbols : byte;
+       end; *)
+
+    procedure MaybeSwap(var v : coffbigobjsymbol);
+      begin
+        if source_info.endian<>target_info.endian then
+          begin
+            if (true) then
+              MaybeSwap(v.Name.Offset);
+            v.Value:=SwapEndian(v.Value);
+            v.SectionNumber:=SwapEndian(v.SectionNumber);
+            v._Type:=SwapEndian(v._Type);
+          end;
+      end;
+(*
+       { This is defined in rtl/win/sysos.inc source }
+       tlsdirectory=packed record
+         data_start, data_end : PUInt;
+         index_pointer, callbacks_pointer : PUInt;
+         zero_fill_size : dword;
+         flags : dword;
+       end;
+     *)
+    procedure MaybeSwap(var v : tlsdirectory);
+      begin
+        if source_info.endian<>target_info.endian then
+          begin
+            v.data_start:=SwapEndian(v.data_start);
+            v.data_end:=SwapEndian(v.data_end);
+            v.index_pointer:=SwapEndian(v.index_pointer);
+            v.callbacks_pointer:=SwapEndian(v.callbacks_pointer);
+            v.zero_fill_size:=SwapEndian(v.zero_fill_size);
+            v.flags:=SwapEndian(v.flags);
+          end;
+      end;
 
      const
        SymbolMaxGrow = 200*sizeof(coffsymbol);
@@ -1437,6 +1748,7 @@ const pemagic : array[0..3] of byte = (
             bosym.StorageClass:=typ;
             bosym.NumberOfAuxSymbols:=aux;
             inc(symidx);
+	    MaybeSwap(bosym);
             FCoffSyms.write(bosym,sizeof(bosym));
           end
         else
@@ -1453,6 +1765,7 @@ const pemagic : array[0..3] of byte = (
             sym.typ:=typ;
             sym.aux:=aux;
             inc(symidx);
+	    MaybeSwap(sym);
             FCoffSyms.write(sym,sizeof(sym));
           end;
       end;
@@ -1503,6 +1816,7 @@ const pemagic : array[0..3] of byte = (
             rel.address:=TObjSection(p).ObjRelocations.Count+1;
             rel.sym:=0;
             rel.reloctype:=0;
+	    MaybeSwap(rel);
             FWriter.Write(rel,sizeof(rel));
           end;
         for i:=0 to TObjSection(p).ObjRelocations.Count-1 do
@@ -1614,6 +1928,7 @@ const pemagic : array[0..3] of byte = (
               else
                 internalerror(200905071);
             end;
+	    MaybeSwap(rel);
             FWriter.write(rel,sizeof(rel));
           end;
       end;
@@ -1745,6 +2060,7 @@ const pemagic : array[0..3] of byte = (
               end
             else
               sechdr.flags:=djencodesechdrflags(secoptions);
+            MaybeSwap(sechdr);
             FWriter.write(sechdr,sizeof(sechdr));
           end;
       end;
@@ -1794,6 +2110,7 @@ const pemagic : array[0..3] of byte = (
                boheader.NumberOfSymbols:=longword(symidx);
                boheader.PointerToSymbolTable:=sympos;
                Move(COFF_BIG_OBJ_MAGIC,boheader.UUID,length(boheader.UUID));
+	       MaybeSwap(boheader);
                FWriter.write(boheader,sizeof(boheader));
              end
            else
@@ -1814,6 +2131,7 @@ const pemagic : array[0..3] of byte = (
                  end
                else
                  header.flag:=COFF_FLAG_AR32WR or COFF_FLAG_NOLINES or COFF_FLAG_NOLSYMS;
+	       MaybeSwap(header);
                FWriter.write(header,sizeof(header));
              end;
            { Section headers }
@@ -1910,6 +2228,7 @@ const pemagic : array[0..3] of byte = (
             { If number of relocations exceeds 65535, it is stored in address field
               of the first record, and includes this first fake relocation. }
             FReader.read(rel,sizeof(rel));
+	    MaybeSwap(rel);
             s.coffrelocs:=rel.address-1;
             if s.coffrelocs<=65535 then
               InternalError(2013012503);
@@ -1917,6 +2236,7 @@ const pemagic : array[0..3] of byte = (
         for i:=1 to s.coffrelocs do
          begin
            FReader.read(rel,sizeof(rel));
+	   MaybeSwap(rel);
            case rel.reloctype of
 {$ifdef arm}
              IMAGE_REL_ARM_ABSOLUTE:
@@ -2061,6 +2381,7 @@ const pemagic : array[0..3] of byte = (
               if bigobj then
                 begin
                   FCoffSyms.Read(bosym,sizeof(bosym));
+		  MaybeSwap(bosym);
                   if bosym.Name.Offset.Zeroes<>0 then
                     begin
                       { Added for sake of global data analysis }
@@ -2081,6 +2402,7 @@ const pemagic : array[0..3] of byte = (
               else
                 begin
                   FCoffSyms.Read(sym,sizeof(sym));
+		  MaybeSwap(sym);
                   if plongint(@sym.name)^<>0 then
                     begin
                       { Added for sake of global data analysis }
@@ -2293,6 +2615,7 @@ const pemagic : array[0..3] of byte = (
                InputError('Can''t read COFF Header');
                exit;
              end;
+           MaybeSwap(header);
            if (header.mach=0) and (header.nsects=$ffff) then
              begin
                { either a library or big obj COFF }
@@ -2302,6 +2625,7 @@ const pemagic : array[0..3] of byte = (
                    InputError('Can''t read Big Obj COFF Header');
                    exit;
                  end;
+               MaybeSwap(boheader);
                if CompareByte(boheader.UUID,COFF_BIG_OBJ_MAGIC,length(boheader.uuid))<>0 then
                  begin
                    { ToDo: this should be treated as a library }
@@ -2385,6 +2709,7 @@ const pemagic : array[0..3] of byte = (
                   InputError('Error reading COFF Section Headers');
                   exit;
                 end;
+               MaybeSwap(sechdr);
                move(sechdr.name,secnamebuf,8);
                secnamebuf[8]:=#0;
                secname:=strpas(secnamebuf);
@@ -2513,6 +2838,7 @@ const pemagic : array[0..3] of byte = (
         sym.section:=section;
         sym.typ:=typ;
         sym.aux:=aux;
+	MaybeSwap(sym);
         FWriter.write(sym,sizeof(sym));
       end;
 
@@ -2612,6 +2938,7 @@ const pemagic : array[0..3] of byte = (
               end
             else
               sechdr.flags:=djencodesechdrflags(SecOptions);
+            MaybeSwap(sechdr);
             FWriter.write(sechdr,sizeof(sechdr));
           end;
       end;
@@ -2843,6 +3170,7 @@ const pemagic : array[0..3] of byte = (
           end
         else
           header.flag:=COFF_FLAG_AR32WR or COFF_FLAG_EXE or COFF_FLAG_NORELOCS or COFF_FLAG_NOLINES;
+        MaybeSwap(header);
         FWriter.write(header,sizeof(header));
         { Optional COFF Header }
         if win32 then
@@ -2938,6 +3266,7 @@ const pemagic : array[0..3] of byte = (
             UpdateDataDir('.rsrc',PE_DATADIR_RSRC);
             UpdateDataDir('.pdata',PE_DATADIR_PDATA);
             UpdateDataDir('.reloc',PE_DATADIR_RELOC);
+	    MaybeSwap(peoptheader);
             FWriter.write(peoptheader,sizeof(peoptheader));
           end
         else
@@ -2951,6 +3280,7 @@ const pemagic : array[0..3] of byte = (
             djoptheader.text_start:=TextExeSec.mempos;
             djoptheader.data_start:=DataExeSec.mempos;
             djoptheader.entry:=EntrySym.Address;
+	    MaybeSwap(djoptheader);
             FWriter.write(djoptheader,sizeof(djoptheader));
           end;
 
@@ -3440,6 +3770,7 @@ const pemagic : array[0..3] of byte = (
         expdir    : TPECoffExpDir;
         i         : longint;
         found     : boolean;
+	header_ok : boolean;
         sechdr    : tCoffSecHdr;
 {$ifdef win32}
         p : pointer;
@@ -3473,7 +3804,9 @@ const pemagic : array[0..3] of byte = (
             Comment(V_Error,'Invalid DLL '+dllname+': invalid magic code');
             exit;
           end;
-        if not DLLReader.Read(Header,sizeof(TCoffHeader)) or
+	header_ok:=DLLReader.Read(Header,sizeof(TCoffHeader));
+	MaybeSwap(Header);
+        if not header_ok or
            (Header.mach<>COFF_MAGIC) or
            (Header.opthdr<>sizeof(tcoffpeoptheader)) then
           begin
@@ -3482,6 +3815,7 @@ const pemagic : array[0..3] of byte = (
           end;
         { Read optheader }
         DLLreader.Read(peheader,sizeof(tcoffpeoptheader));
+	MaybeSwap(peheader);
         { Section headers }
         found:=false;
         for i:=1 to header.nsects do
@@ -3491,6 +3825,7 @@ const pemagic : array[0..3] of byte = (
                 Comment(V_Error,'Error reading coff file '+DLLName);
                 exit;
               end;
+            MaybeSwap(sechdr);
             if (sechdr.rvaofs<=peheader.DataDirectory[PE_DATADIR_EDATA].vaddr) and
                (peheader.DataDirectory[PE_DATADIR_EDATA].vaddr<sechdr.rvaofs+sechdr.vsize) then
               begin
@@ -3506,6 +3841,7 @@ const pemagic : array[0..3] of byte = (
         { Process edata }
         DLLReader.Seek(sechdr.datapos+peheader.DataDirectory[PE_DATADIR_EDATA].vaddr-sechdr.rvaofs);
         DLLReader.Read(expdir,sizeof(expdir));
+	MaybeSwap(expdir);
         for i:=0 to expdir.NumNames-1 do
           begin
             DLLReader.Seek(sechdr.datapos+expdir.AddrNames-sechdr.rvaofs+i*4);