[NativeAOT] Implementation Proposal for AOT-friendly IIRReader API

Src/ILGPU.Analyzers/ReaderDelegatesGenerator.cs

@@ -0,0 +1,87 @@
+// ---------------------------------------------------------------------------------------
+//                                        ILGPU
+//                        Copyright (c) 2024 ILGPU Project
+//                                    www.ilgpu.net
+//
+// File: ReaderDelegatesGenerator.cs
+//
+// This file is part of ILGPU and is distributed under the University of Illinois Open
+// Source License. See LICENSE.txt for details.
+// ---------------------------------------------------------------------------------------
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ILGPU.Analyzers
+{
+    [Generator]
+    public class ReaderDelegatesGenerator : ISourceGenerator
+    {
+        private class ValueKindReciever : ISyntaxReceiver
+        {
+            private readonly ConcurrentDictionary<string, string> valueKinds;
+
+            public IReadOnlyDictionary<string, string> ValueKinds => valueKinds;
+
+            public ValueKindReciever()
+            {
+                valueKinds = new ConcurrentDictionary<string, string>();
+            }
+
+            public void OnVisitSyntaxNode(SyntaxNode node)
+            {
+                AttributeSyntax? attribute;
+                if (node is ClassDeclarationSyntax cl &&
+                    cl.Parent is NamespaceDeclarationSyntax ns &&
+                    ns.Name.ToString().StartsWith("ILGPU.IR.Values") &&
+                    (attribute = cl.AttributeLists.SelectMany(x => x.Attributes)
+                    .SingleOrDefault(attr => attr.Name.ToString() == "ValueKind"))
+                    is not null)
+                {
+                    var valueKind = attribute.ArgumentList?
+                        .Arguments.SingleOrDefault()
+                        .Expression.ToString() ?? throw new InvalidOperationException("Malformed input syntax.");
+                    var valueClass = cl.Identifier.ToString();
+                    valueKinds.TryAdd(valueKind, valueClass);
+                }
+            }
+        }
+
+        public void Initialize(GeneratorInitializationContext context)
+        {
+            context.RegisterForSyntaxNotifications(() => new ValueKindReciever());
+        }
+
+        public void Execute(GeneratorExecutionContext context)
+        {
+            var valueKindReciever = context.SyntaxReceiver as ValueKindReciever;
+            if (valueKindReciever is not null)
+            {
+                var builder = new StringBuilder();
+
+                builder.AppendLine("using ILGPU.IR.Values;");
+                builder.AppendLine();
+                builder.AppendLine("namespace ILGPU.IR");
+                builder.AppendLine("{");
+                builder.AppendLine("    public static partial class ValueKinds");
+                builder.AppendLine("    {");
+                builder.AppendLine("        static ValueKinds()");
+                builder.AppendLine("        {");
+                foreach (var kv in valueKindReciever.ValueKinds)
+                {
+                    builder.AppendLine($"            _readerDelegates.TryAdd({kv.Key}, {kv.Value}.Read);");
+                }
+                builder.AppendLine("        }");
+                builder.AppendLine("    }");
+                builder.AppendLine("}");
+
+                context.AddSource("ValueKinds.g.cs", builder.ToString());
+            }
+        }
+    }
+}

Src/ILGPU/ILGPU.csproj

@@ -52,6 +52,12 @@
     <PackageReference Include="T4.Build" Version="0.2.4" PrivateAssets="All" />
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\ILGPU.Analyzers\ILGPU.Analyzers.csproj"
+                      OutputItemType="Analyzer"
+                      ReferenceOutputAssembly="false" />
+  </ItemGroup>
+
   <ItemGroup>
     <None Include="AtomicFunctions.cs">
       <DesignTime>True</DesignTime>

Src/ILGPU/IR/IRContext.cs

@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------------------------
 //                                        ILGPU
-//                        Copyright (c) 2018-2023 ILGPU Project
+//                        Copyright (c) 2018-2024 ILGPU Project
 //                                    www.ilgpu.net
 //
 // File: IRContext.cs
@@ -12,6 +12,7 @@
 using ILGPU.Frontend;
 using ILGPU.IR.Analyses;
 using ILGPU.IR.Construction;
+using ILGPU.IR.Serialization;
 using ILGPU.IR.Transformations;
 using ILGPU.IR.Types;
 using ILGPU.IR.Values;
@@ -498,6 +499,33 @@ public void Transform(in Transformer transformer)
             Parallel.ForEach(toTransform, gcDelegate);
         }
 
+        /// <summary>
+        /// Serializes this instance using the given <see cref="IIRWriter"/>.
+        /// </summary>
+        /// <typeparam name="T">
+        /// The specific type of <see cref="IIRWriter"/>.
+        /// </typeparam>
+        /// <param name="writer">
+        /// The writer to use for serialization.
+        /// </param>
+        public void Write<T>(T writer) where T : IIRWriter
+        {
+            var allMethods = GetMethodCollection(new MethodCollections.AllMethods());
+            foreach (var method in allMethods)
+            {
+                foreach (var param in method.Parameters)
+                    param.Write(writer);
+
+                foreach (var block in method.Blocks)
+                {
+                    foreach (var entry in block)
+                        entry.Value.Write(writer);
+
+                    block.Terminator?.Write(writer);
+                }
+            }
+        }
+
         /// <summary>
         /// Dumps the IR context to the given text writer.
         /// </summary>

Src/ILGPU/IR/Serialization/BinaryIRReader.cs

@@ -0,0 +1,116 @@
+// ---------------------------------------------------------------------------------------
+//                                        ILGPU
+//                        Copyright (c) 2024 ILGPU Project
+//                                    www.ilgpu.net
+//
+// File: BinaryIRReader.cs
+//
+// This file is part of ILGPU and is distributed under the University of Illinois Open
+// Source License. See LICENSE.txt for details.
+// ---------------------------------------------------------------------------------------
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Text;
+
+namespace ILGPU.IR.Serialization
+{
+    /// <summary>
+    /// Wrapper class around <see cref="BinaryReader"/> for deserializing IR types and values. 
+    /// </summary>
+    public sealed class BinaryIRReader : IIRReader
+    {
+        private readonly BinaryReader reader;
+
+        /// <inheritdoc/>
+        public IIRMappingContext Context { get; }
+
+        /// <summary>
+        /// Wraps an instance of <see cref="BinaryIRReader"/>
+        /// around a given <see cref="Stream"/>.
+        /// </summary>
+        /// <param name="stream">
+        /// The <see cref="Stream"/> instance to wrap.
+        /// </param>
+        /// <param name="encoding">
+        /// The <see cref="Encoding"/> to use for
+        /// deserializing <see cref="string"/> values.
+        /// </param>
+        /// <param name="context">
+        /// A mapping context instance to use for deserialization. 
+        /// </param>
+        public BinaryIRReader(Stream stream, Encoding encoding, IIRMappingContext context)
+        {
+            reader = new BinaryReader(stream, encoding);
+            Context = context;
+        }
+
+
+        /// <inheritdoc/>
+        public bool Read(out int value)
+        {
+            try
+            {
+                value = reader.ReadInt32();
+                return true;
+            }
+            catch (EndOfStreamException)
+            {
+                value = default;
+                return false;
+            }
+        }
+
+        /// <inheritdoc/>
+        public bool Read(out long value)
+        {
+            try
+            {
+                value = reader.ReadInt64();
+                return true;
+            }
+            catch (EndOfStreamException)
+            {
+                value = default;
+                return false;
+            }
+        }
+
+        /// <inheritdoc/>
+        public bool Read([NotNullWhen(true)] out string? value)
+        {
+            try
+            {
+                value = reader.ReadString();
+                return true;
+            }
+            catch (EndOfStreamException)
+            {
+                value = default;
+                return false;
+            }
+        }
+
+        /// <inheritdoc/>
+        public bool Read<T>(out T value)
+            where T : unmanaged, Enum
+        {
+            try
+            {
+                value = (T)Enum.ToObject(typeof(T), reader.ReadInt32());
+                return true;
+            }
+            catch (EndOfStreamException)
+            {
+                value = default;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Disposes of the wrapped <see cref="BinaryReader"/> instance.
+        /// </summary>
+        public void Dispose() => ((IDisposable)reader).Dispose();
+    }
+}

Src/ILGPU/IR/Serialization/BinaryIRWriter.cs

@@ -0,0 +1,68 @@
+// ---------------------------------------------------------------------------------------
+//                                        ILGPU
+//                           Copyright (c) 2024 ILGPU Project
+//                                    www.ilgpu.net
+//
+// File: BinaryIRWriter.cs
+//
+// This file is part of ILGPU and is distributed under the University of Illinois Open
+// Source License. See LICENSE.txt for details.
+// ---------------------------------------------------------------------------------------
+
+using ILGPU.Util;
+using System;
+using System.IO;
+using System.Text;
+
+namespace ILGPU.IR.Serialization
+{
+    /// <summary>
+    /// Wrapper class around <see cref="BinaryWriter"/>
+    /// for serializing IR types and values. 
+    /// </summary>
+    public sealed class BinaryIRWriter : DisposeBase, IIRWriter
+    {
+        private readonly BinaryWriter writer;
+
+        /// <summary>
+        /// Wraps an instance of <see cref="BinaryIRWriter"/>
+        /// around a given <see cref="Stream"/>.
+        /// </summary>
+        /// <param name="stream">
+        /// The <see cref="Stream"/> instance to wrap.
+        /// </param>
+        /// <param name="encoding">
+        /// The <see cref="Encoding"/> to use for
+        /// serializing <see cref="string"/> values.
+        /// </param>
+        public BinaryIRWriter(Stream stream, Encoding encoding)
+        {
+            writer = new BinaryWriter(stream, encoding);
+        }
+
+        /// <inheritdoc/>
+        public void Write(string tag, int value) =>
+            writer.Write(value);
+
+        /// <inheritdoc/>
+        public void Write(string tag, long value) =>
+            writer.Write(value);
+
+        /// <inheritdoc/>
+        public void Write(string tag, string value) =>
+            writer.Write(value);
+
+        /// <inheritdoc/>
+        public void Write<T>(string tag, T value)
+            where T : unmanaged, Enum =>
+            writer.Write(Convert.ToInt32(value));
+
+        /// <inheritdoc/>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+                writer.Dispose();
+            base.Dispose(disposing);
+        }
+    }
+}