Make it possible to order methods by specifying symbolic names

src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets

@@ -303,6 +303,8 @@ The .NET Foundation licenses this file to you under the MIT license.
       <IlcArg Condition="'$(TrimmerDefaultAction)' == 'copyused' or '$(TrimmerDefaultAction)' == 'copy' or '$(TrimMode)' == 'partial'" Include="--defaultrooting" />
       <IlcArg Condition="$(IlcResilient) != 'false'" Include="--resilient" />
       <IlcArg Include="@(UnmanagedEntryPointsAssembly->'--generateunmanagedentrypoints:%(Identity)')" />
+      <IlcArg Condition="$(IlcOrderFile) != ''" Include="--order:$(IlcOrderFile)" />
+      <IlcArg Condition="$(IlcOrderFile) != ''" Include="--method-layout:explicit" />
 
       <!-- The managed debugging support in libraries is unused - trim it -->
       <IlcArg Condition="'$(DebuggerSupport)' != 'true'" Include="--feature:System.Diagnostics.Debugger.IsSupported=false" />
@@ -322,7 +324,7 @@ The .NET Foundation licenses this file to you under the MIT license.
   </Target>
 
   <Target Name="IlcCompile"
-      Inputs="@(IlcCompileInput);@(IlcReference);@(IlcSatelliteAssembly);@(RdXmlFile);%(ManagedBinary.IlcRspFile)"
+      Inputs="@(IlcCompileInput);@(IlcReference);@(IlcSatelliteAssembly);@(RdXmlFile);$(IlcOrderFile);%(ManagedBinary.IlcRspFile)"
       Outputs="%(ManagedBinary.IlcOutputFile)"
       DependsOnTargets="WriteIlcRspFileForCompilation;$(IlcCompileDependsOn)">
     <Message Text="Generating native code" Importance="high" />

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/FileLayoutOptimizer.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO;
 
 using Internal.TypeSystem;
 
@@ -36,6 +37,7 @@ public enum MethodLayoutAlgorithm
 #endif
         PettisHansen,
         Random,
+        Explicit,
     }
 
     public enum FileLayoutAlgorithm
@@ -50,20 +52,23 @@ public FileLayoutOptimizer (Logger logger,
                                               MethodLayoutAlgorithm methodAlgorithm,
                                               FileLayoutAlgorithm fileAlgorithm,
                                               ProfileDataManager profileData,
-                                              NodeFactory nodeFactory)
+                                              NodeFactory nodeFactory,
+                                              string orderFile = null)
         {
             _logger = logger;
             _methodLayoutAlgorithm = methodAlgorithm;
             _fileLayoutAlgorithm = fileAlgorithm;
             _profileData = profileData;
             _nodeFactory = nodeFactory;
+            _orderFile = orderFile;
         }
 
         private Logger _logger;
         private MethodLayoutAlgorithm _methodLayoutAlgorithm = MethodLayoutAlgorithm.DefaultSort;
         private FileLayoutAlgorithm _fileLayoutAlgorithm = FileLayoutAlgorithm.DefaultSort;
         private ProfileDataManager _profileData;
         private NodeFactory _nodeFactory;
+        private string _orderFile;
 
         public ImmutableArray<DependencyNodeCore<NodeFactory>> ApplyProfilerGuidedMethodSort(ImmutableArray<DependencyNodeCore<NodeFactory>> nodes)
         {
@@ -200,6 +205,33 @@ int ComputeHotWarmColdRegion(MethodWithGCInfo method)
                     }
                     break;
 
+                case MethodLayoutAlgorithm.Explicit:
+                    var nameMap = new Dictionary<string, MethodWithGCInfo>(methods.Count);
+                    var order = new Dictionary<MethodWithGCInfo, int>(methods.Count);
+
+                    for (int i = 0; i < methods.Count; i++)
+                    {
+                        nameMap[methods[i].GetMangledName(_nodeFactory.NameMangler)] = methods[i];
+                        order[methods[i]] = int.MaxValue;
+                    }
+
+                    using (StreamReader sr = new StreamReader(_orderFile))
+                    {
+                        int line = 0;
+                        while (!sr.EndOfStream)
+                        {
+                            string symbolName = sr.ReadLine();
+                            if (string.IsNullOrEmpty(symbolName)
+                                || !nameMap.TryGetValue(symbolName, out MethodWithGCInfo m))
+                                continue;
+
+                            order[m] = line++;
+                        }
+                    }
+
+                    methods.MergeSortAllowDuplicates((MethodWithGCInfo left, MethodWithGCInfo right) => order[left].CompareTo(order[right]));
+                    break;
+
                 default:
                     throw new NotImplementedException(_methodLayoutAlgorithm.ToString());
             }

src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilation.cs

@@ -47,7 +47,8 @@ internal RyuJitCompilation(
             RyuJitCompilationOptions options,
             MethodLayoutAlgorithm methodLayoutAlgorithm,
             FileLayoutAlgorithm fileLayoutAlgorithm,
-            int parallelism)
+            int parallelism,
+            string orderFile)
             : base(dependencyGraph, nodeFactory, roots, ilProvider, debugInformationProvider, inliningPolicy, logger)
         {
             _compilationOptions = options;
@@ -61,7 +62,7 @@ internal RyuJitCompilation(
 
             _parallelism = parallelism;
 
-            _fileLayoutOptimizer = new FileLayoutOptimizer(logger, methodLayoutAlgorithm, fileLayoutAlgorithm, profileDataManager, nodeFactory);
+            _fileLayoutOptimizer = new FileLayoutOptimizer(logger, methodLayoutAlgorithm, fileLayoutAlgorithm, profileDataManager, nodeFactory, orderFile);
         }
 
         public ProfileDataManager ProfileData => _profileDataManager;

src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilationBuilder.cs

@@ -21,6 +21,7 @@ public sealed class RyuJitCompilationBuilder : CompilationBuilder
         private FileLayoutAlgorithm _fileLayoutAlgorithm;
         private ILProvider _ilProvider = new NativeAotILProvider();
         private ProfileDataManager _profileDataManager;
+        private string _orderFile;
         private string _jitPath;
 
         public RyuJitCompilationBuilder(CompilerTypeSystemContext context, CompilationModuleGroup group)
@@ -35,6 +36,12 @@ public RyuJitCompilationBuilder UseProfileData(IEnumerable<string> mibcFiles)
             return this;
         }
 
+        public RyuJitCompilationBuilder UseSymbolOrder(string filePath)
+        {
+            _orderFile = filePath;
+            return this;
+        }
+
         public RyuJitCompilationBuilder UseJitPath(string jitPath)
         {
             _jitPath = jitPath;
@@ -149,7 +156,8 @@ public override ICompilation ToCompilation()
                 options,
                 _methodLayoutAlgorithm,
                 _fileLayoutAlgorithm,
-                _parallelism);
+                _parallelism,
+                _orderFile);
         }
     }
 }

src/coreclr/tools/aot/ILCompiler/ILCompilerRootCommand.cs

@@ -31,6 +31,8 @@ internal sealed class ILCompilerRootCommand : RootCommand
             new("--method-layout") { CustomParser = MakeMethodLayoutAlgorithm, DefaultValueFactory = MakeMethodLayoutAlgorithm, Description = "Layout algorithm used by profile-driven optimization for arranging methods in a file.", HelpName = "arg" };
         public Option<FileLayoutAlgorithm> FileLayout { get; } =
             new("--file-layout") { CustomParser = MakeFileLayoutAlgorithm, DefaultValueFactory = MakeFileLayoutAlgorithm, Description = "Layout algorithm used by profile-driven optimization for arranging non-method contents in a file.", HelpName = "arg" };
+        public Option<string> OrderFile { get; } =
+            new("--order") { Description = "File that specifies order of symbols within the generated object file" };
         public Option<string[]> SatelliteFilePaths { get; } =
             new("--satellite") { DefaultValueFactory = _ => Array.Empty<string>(), Description = "Satellite assemblies associated with inputs/references" };
         public Option<bool> EnableDebugInfo { get; } =
@@ -193,6 +195,7 @@ public ILCompilerRootCommand(string[] args) : base(".NET Native IL Compiler")
             Options.Add(MibcFilePaths);
             Options.Add(MethodLayout);
             Options.Add(FileLayout);
+            Options.Add(OrderFile);
             Options.Add(SatelliteFilePaths);
             Options.Add(EnableDebugInfo);
             Options.Add(UseDwarf5);
@@ -300,7 +303,7 @@ public ILCompilerRootCommand(string[] args) : base(".NET Native IL Compiler")
 
 #pragma warning disable CA1861 // Avoid constant arrays as arguments. Only executed once during the execution of the program.
                         Helpers.MakeReproPackage(makeReproPath, result.GetValue(OutputFilePath), args, result,
-                            inputOptions : new[] { "-r", "--reference", "-m", "--mibc", "--rdxml", "--directpinvokelist", "--descriptor", "--satellite" },
+                            inputOptions : new[] { "-r", "--reference", "-m", "--mibc", "--rdxml", "--directpinvokelist", "--descriptor", "--satellite", "--order" },
                             outputOptions : new[] { "-o", "--out", "--exportsfile", "--dgmllog", "--scandgmllog", "--mstat", "--sourcelink" });
 #pragma warning restore CA1861 // Avoid constant arrays as arguments
                     }
@@ -424,6 +427,7 @@ private static MethodLayoutAlgorithm MakeMethodLayoutAlgorithm(ArgumentResult re
                 "hotwarmcold" => MethodLayoutAlgorithm.HotWarmCold,
                 "pettishansen" => MethodLayoutAlgorithm.PettisHansen,
                 "random" => MethodLayoutAlgorithm.Random,
+                "explicit" => MethodLayoutAlgorithm.Explicit,
                 _ => throw new CommandLineException(result.Tokens[0].Value)
             };
         }

src/coreclr/tools/aot/ILCompiler/Program.cs

@@ -361,6 +361,7 @@ public int Run()
             string compilationUnitPrefix = multiFile ? Path.GetFileNameWithoutExtension(outputFilePath) : "";
             var builder = new RyuJitCompilationBuilder(typeSystemContext, compilationGroup)
                 .FileLayoutAlgorithms(Get(_command.MethodLayout), Get(_command.FileLayout))
+                .UseSymbolOrder(Get(_command.OrderFile))
                 .UseCompilationUnitPrefix(compilationUnitPrefix);
 
             string[] mibcFilePaths = Get(_command.MibcFilePaths);

src/tests/nativeaot/SmokeTests/UnitTests/Main.cs

@@ -11,6 +11,7 @@
 success &= RunTest(Threading.Run);
 success &= RunTest(Devirtualization.Run);
 success &= RunTest(StackTraces.Run);
+success &= RunTest(Ordering.Run);
 
 return success ? 100 : 1;
 

src/tests/nativeaot/SmokeTests/UnitTests/Ordering.cs

@@ -0,0 +1,42 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+class Ordering
+{
+    internal static unsafe int Run()
+    {
+        // Method addresses are not observable in WASM
+        if (OperatingSystem.IsWasi() || OperatingSystem.IsBrowser())
+            return 100;
+
+        var keys = new nint[]
+        {
+            (nint)(delegate*<Guid>)&Method4,
+            (nint)(delegate*<Guid>)&Method3,
+            (nint)(delegate*<Guid>)&Method2,
+            (nint)(delegate*<Guid>)&Method1,
+            (nint)(delegate*<Guid>)&Method0,
+        };
+
+        var items = new int[] { 4, 3, 2, 1, 0 };
+
+        Array.Sort(keys, items);
+
+        // the order specified in the order.txt file
+        var expectedOrder = new int[] { 2, 1, 3, 0, 4 };
+
+        for (int i = 0; i < items.Length; i++)
+            if (items[i] != expectedOrder[i])
+                throw new Exception(i.ToString());
+
+        return 100;
+    }
+
+    static Guid Method0() => new Guid(0xb20e3a5f, 0x4aad, 0x4225, 0x98, 0x26, 0xac, 0xe8, 0xe0, 0xf7, 0x64, 0x56);
+    static Guid Method1() => new Guid(0x13464316, 0xb19c, 0x4e1c, 0x95, 0x2e, 0x22, 0xb4, 0xa, 0x21, 0x7d, 0xd5);
+    static Guid Method2() => new Guid(0x510f2c1e, 0x7715, 0x4aee, 0x8d, 0xd5, 0x16, 0xf8, 0xd5, 0x70, 0x5, 0x90);
+    static Guid Method3() => new Guid(0x4cc6e597, 0x875e, 0x4cb0, 0x90, 0x88, 0xcb, 0x4e, 0xd8, 0x8, 0x91, 0xb8);
+    static Guid Method4() => new Guid(0x2d2e2b87, 0x75f5, 0x4c16, 0x93, 0xa9, 0xbe, 0xbd, 0x6b, 0x58, 0xbd, 0xd6);
+}

src/tests/nativeaot/SmokeTests/UnitTests/UnitTests.csproj

@@ -10,13 +10,16 @@
 
     <RequiresProcessIsolation>true</RequiresProcessIsolation>
     <ReferenceXUnitWrapperGenerator>false</ReferenceXUnitWrapperGenerator>
+
+    <IlcOrderFile>order.txt</IlcOrderFile>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="BasicThreading.cs" />
     <Compile Include="Delegates.cs" />
     <Compile Include="Devirtualization.cs" />
     <Compile Include="Generics.cs" />
     <Compile Include="Interfaces.cs" />
+    <Compile Include="Ordering.cs" />
     <Compile Include="Threading.cs" />
     <Compile Include="StackTraces.cs" />
     <Compile Include="Main.cs" />

src/tests/nativeaot/SmokeTests/UnitTests/order.txt

@@ -0,0 +1,5 @@
+UnitTests_Ordering__Method2
+UnitTests_Ordering__Method1
+UnitTests_Ordering__Method3
+UnitTests_Ordering__Method0
+UnitTests_Ordering__Method4