Use an ObjectWriter-based PE writer for crossgen2

src/coreclr/tools/Common/Compiler/DependencyAnalysis/ISymbolNode.cs

@@ -73,6 +73,40 @@ public interface ISymbolDefinitionNode : ISymbolNode
         new int Offset { get; }
     }
 
+    /// <summary>
+    /// Represents a symbol that should encompass the full range between the start and end symbols specified.
+    /// </summary>
+    public interface ISymbolRangeNode : ISymbolNode
+    {
+        /// <summary>
+        /// Return a node that determines the start of the range.
+        /// This node will be used for linkage.
+        /// </summary>
+        ISymbolNode StartNode(NodeFactory factory);
+
+        /// <summary>
+        /// Return a node that is used to determine the symbol size.
+        /// </summary>
+        ISymbolNode EndNode(NodeFactory factory);
+    }
+
+    /// <summary>
+    /// Represents a node that generates a checksum for the resulting output blob.
+    /// </summary>
+    public interface IChecksumNode : ISymbolNode
+    {
+        int ChecksumSize { get; }
+
+        void EmitChecksum(ReadOnlySpan<byte> outputBlob, Span<byte> checksumLocation);
+    }
+
+    /// <summary>
+    /// Represents a symbol that should not be shared with another symbol during writing of the object file.
+    /// </summary>
+    public interface IUniqueSymbolNode : ISymbolNode
+    {
+    }
+
     public static class ISymbolNodeExtensions
     {
         [ThreadStatic]

src/coreclr/tools/Common/Compiler/DependencyAnalysis/ObjectDataBuilder.cs

@@ -305,6 +305,10 @@ public void EmitReloc(ISymbolNode symbol, RelocType relocType, int delta = 0)
                     // Do not vacate space for this kind of relocation, because
                     // the space is embedded in the instruction.
                     break;
+
+                case RelocType.IMAGE_REL_FILE_CHECKSUM_CALLBACK:
+                    EmitZeros(delta);
+                    break;
                 default:
                     throw new NotImplementedException();
             }
@@ -315,6 +319,11 @@ public void EmitPointerReloc(ISymbolNode symbol, int delta = 0)
             EmitReloc(symbol, (_target.PointerSize == 8) ? RelocType.IMAGE_REL_BASED_DIR64 : RelocType.IMAGE_REL_BASED_HIGHLOW, delta);
         }
 
+        public void EmitChecksumReloc(IChecksumNode checksum)
+        {
+            EmitReloc(checksum, RelocType.IMAGE_REL_FILE_CHECKSUM_CALLBACK, checksum.ChecksumSize);
+        }
+
         public ObjectNode.ObjectData ToObjectData()
         {
 #if DEBUG

src/coreclr/tools/Common/Compiler/DependencyAnalysis/ObjectNodeSection.cs

@@ -51,5 +51,10 @@ public ObjectNodeSection(string name, SectionType type) : this(name, type, null)
 
         public static readonly ObjectNodeSection ModulesWindowsContentSection = new ObjectNodeSection(".modules$I", SectionType.ReadOnly);
         public static readonly ObjectNodeSection ModulesUnixContentSection = new ObjectNodeSection("__modules", SectionType.Writeable);
+
+        public static readonly ObjectNodeSection DebugDirectorySection = new ObjectNodeSection("debug", SectionType.Debug);
+        public static readonly ObjectNodeSection CorMetaSection = new ObjectNodeSection("cormeta", SectionType.ReadOnly);
+        public static readonly ObjectNodeSection Win32ResourcesSection = new ObjectNodeSection("rsrc", SectionType.ReadOnly);
+        public static readonly ObjectNodeSection PDataSection = new ObjectNodeSection("pdata", SectionType.ReadOnly);
     }
 }

src/coreclr/tools/Common/Compiler/DependencyAnalysis/Relocation.cs

@@ -8,11 +8,16 @@ namespace ILCompiler.DependencyAnalysis
 {
     public enum RelocType
     {
+        // PE base relocation types.
         IMAGE_REL_BASED_ABSOLUTE             = 0x00,   // No relocation required
-        IMAGE_REL_BASED_ADDR32NB             = 0x02,   // The 32-bit address without an image base (RVA)
         IMAGE_REL_BASED_HIGHLOW              = 0x03,   // 32 bit address base
         IMAGE_REL_BASED_THUMB_MOV32          = 0x07,   // Thumb2: based MOVW/MOVT
         IMAGE_REL_BASED_DIR64                = 0x0A,   // 64 bit address base
+
+        // COFF relocation types
+        IMAGE_REL_BASED_ADDR32NB             = 0x0B,   // The 32-bit address without an image base (RVA)
+
+        // General relocation types
         IMAGE_REL_BASED_REL32                = 0x10,   // 32-bit relative address from byte following reloc
         IMAGE_REL_BASED_THUMB_BRANCH24       = 0x13,   // Thumb2: based B, BL
         IMAGE_REL_BASED_THUMB_MOV32_PCREL    = 0x14,   // Thumb2: based MOVW/MOVT
@@ -24,6 +29,7 @@ public enum RelocType
                                                        // This is a special NGEN-specific relocation type
                                                        // for relative pointer (used to make NGen relocation
                                                        // section smaller)
+
         IMAGE_REL_SECTION                    = 0x79,   // 16 bit section index containing target
 
         IMAGE_REL_BASED_ARM64_PAGEBASE_REL21 = 0x81,   // ADRP
@@ -63,9 +69,12 @@ public enum RelocType
 
         //
         // Relocations for R2R image production
+        // None of these are "real" relocations that map to an object file's relocation.
+        // All must be emulated by the object writer.
         //
         IMAGE_REL_SYMBOL_SIZE                = 0x1000, // The size of data in the image represented by the target symbol node
         IMAGE_REL_FILE_ABSOLUTE              = 0x1001, // 32 bit offset from beginning of image
+        IMAGE_REL_FILE_CHECKSUM_CALLBACK     = 0x1002, // After the image has been emitted, call the IChecksumNode.EmitChecksum method on the target symbol to emit the checksum data.
     }
 
     public struct Relocation
@@ -560,7 +569,20 @@ public static int GetSize(RelocType relocType)
             {
                 RelocType.IMAGE_REL_BASED_DIR64 => 8,
                 RelocType.IMAGE_REL_BASED_HIGHLOW => 4,
+                RelocType.IMAGE_REL_BASED_ADDR32NB => 4,
+                RelocType.IMAGE_REL_BASED_REL32 => 4,
                 RelocType.IMAGE_REL_BASED_RELPTR32 => 4,
+                RelocType.IMAGE_REL_FILE_ABSOLUTE => 4,
+                // The relocation itself aren't these sizes, but their values
+                // are immediates in instructions within
+                // a span of this many bytes.
+                RelocType.IMAGE_REL_BASED_ARM64_PAGEBASE_REL21 => 4,
+                RelocType.IMAGE_REL_BASED_ARM64_PAGEOFFSET_12A => 4,
+                RelocType.IMAGE_REL_BASED_THUMB_MOV32 => 8,
+                RelocType.IMAGE_REL_BASED_THUMB_MOV32_PCREL => 8,
+                RelocType.IMAGE_REL_BASED_LOONGARCH64_PC => 16,
+                RelocType.IMAGE_REL_BASED_LOONGARCH64_JIR => 16,
+                RelocType.IMAGE_REL_BASED_RISCV64_PC => 16,
                 _ => throw new NotSupportedException(),
             };
         }

src/coreclr/tools/Common/Compiler/DependencyAnalysis/Target_ARM64/ARM64Emitter.cs

@@ -150,14 +150,22 @@ public void EmitJMP(ISymbolNode symbol)
         {
             if (symbol.RepresentsIndirectionCell)
             {
+                Builder.RequireInitialPointerAlignment();
+
+                if (Builder.CountBytes % Builder.TargetPointerSize == 0)
+                {
+                    // Emit a NOP instruction to align the 64-bit reloc below.
+                    EmitNOP();
+                }
+
                 // ldr x12, [PC+0xc]
                 EmitLDR(Register.X12, 0xc);
 
                 // ldr x12, [x12]
                 EmitLDR(Register.X12, Register.X12);
 
                 // br x12
-                Builder.EmitUInt(0xd61f0180);
+                EmitJMP(Register.X12);
 
                 Builder.EmitReloc(symbol, RelocType.IMAGE_REL_BASED_DIR64);
             }
@@ -215,6 +223,11 @@ public void EmitJNE(ISymbolNode symbol)
             EmitJMP(symbol);
         }
 
+        public void EmitNOP()
+        {
+            Builder.EmitUInt(0xD503201F);
+        }
+
         private static bool InSignedByteRange(int i)
         {
             return i == (int)(sbyte)i;

src/coreclr/tools/Common/Compiler/DependencyAnalysis/Target_LoongArch64/LoongArch64Emitter.cs

@@ -107,6 +107,14 @@ public void EmitJMP(ISymbolNode symbol)
         {
             if (symbol.RepresentsIndirectionCell)
             {
+                Builder.RequireInitialPointerAlignment();
+
+                if (Builder.CountBytes % Builder.TargetPointerSize != 0)
+                {
+                    // Emit a NOP instruction to align the 64-bit reloc below.
+                    EmitNOP();
+                }
+
                 // pcaddi R21, 0
                 EmitPCADDI(Register.R21);
 
@@ -150,5 +158,11 @@ public void EmitDBAR()
         {
             Builder.EmitUInt(0x38720000);
         }
+
+        // nop
+        public void EmitNOP()
+        {
+            Builder.EmitUInt(0x03400000);
+        }
     }
 }

src/coreclr/tools/Common/Compiler/DependencyAnalysis/Target_RiscV64/RiscV64Emitter.cs

@@ -103,6 +103,14 @@ public void EmitJMP(ISymbolNode symbol)
         {
             if (symbol.RepresentsIndirectionCell)
             {
+                Builder.RequireInitialPointerAlignment();
+
+                if (Builder.CountBytes % Builder.TargetPointerSize != 0)
+                {
+                    // Emit a NOP instruction to align the 64-bit reloc below.
+                    EmitNOP();
+                }
+
                 // auipc x29, 0
                 EmitPC(Register.X29);
                 // ld x29,16(x29)
@@ -137,5 +145,10 @@ public void EmitJMPIfZero(Register regSrc, ISymbolNode symbol)
             Builder.EmitUInt((uint)(0x00001063 | ((uint)regSrc << 15) | encodedOffset));
             EmitJMP(symbol);
         }
+
+        public void EmitNOP()
+        {
+            Builder.EmitUInt(0x00000013);
+        }
     }
 }