Preserve IL for CoreCLR interpreter fallback on Apple mobile

src/coreclr/tools/Common/InstructionSetHelpers.cs

@@ -11,6 +11,7 @@
 using Internal.TypeSystem;
 
 using InstructionSet = Internal.JitInterface.InstructionSet;
+using InstructionSetFlags = Internal.JitInterface.InstructionSetFlags;
 
 namespace System.CommandLine
 {
@@ -353,5 +354,35 @@ public static InstructionSetSupport ConfigureInstructionSetSupport(string instru
                 InstructionSetSupportBuilder.GetNonSpecifiableInstructionSetsForArch(targetArchitecture),
                 targetArchitecture);
         }
+
+        // Produces an InstructionSetSupport where the instruction sets are fixed at compile time: every
+        // specifiable instruction set that is not already supported is marked explicitly unsupported, and the
+        // supported sets are also treated as optimistic. This is used for targets without runtime code generation
+        // (for example Apple mobile and WASM), where the pre-compiled code must hard code its ISA usage because
+        // there is no JIT to recover from an instruction set mismatch.
+        public static InstructionSetSupport GetFixedInstructionSetSupport(InstructionSetSupport instructionSetSupport)
+        {
+            InstructionSetFlags unsupportedInstructionSets = instructionSetSupport.ExplicitlyUnsupportedFlags;
+            foreach (var instructionSetInfo in InstructionSetFlags.ArchitectureToValidInstructionSets(instructionSetSupport.Architecture))
+            {
+                if (instructionSetInfo.Specifiable &&
+                    !instructionSetSupport.IsInstructionSetSupported(instructionSetInfo.InstructionSet))
+                {
+                    unsupportedInstructionSets.AddInstructionSet(instructionSetInfo.InstructionSet);
+                }
+            }
+            unsupportedInstructionSets.ExpandInstructionSetByReverseImplication(instructionSetSupport.Architecture);
+            unsupportedInstructionSets.Set64BitInstructionSetVariants(instructionSetSupport.Architecture);
+
+            if (instructionSetSupport.Architecture is TargetArchitecture.X86 or TargetArchitecture.ARM)
+                unsupportedInstructionSets.Set64BitInstructionSetVariantsUnconditionally(instructionSetSupport.Architecture);
+
+            return new InstructionSetSupport(
+                instructionSetSupport.SupportedFlags,
+                unsupportedInstructionSets,
+                instructionSetSupport.SupportedFlags,
+                instructionSetSupport.NonSpecifiableFlags,
+                instructionSetSupport.Architecture);
+        }
     }
 }

src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCases/R2RTestSuites.cs

@@ -570,6 +570,7 @@ public void RuntimeAsyncStripILBodiesPreservesTaskReturningIL()
                 new(nameof(RuntimeAsyncStripILBodiesPreservesTaskReturningIL), [new CrossgenAssembly(stripILBodies)])
                 {
                     Options = [Crossgen2Option.Composite, Crossgen2Option.Optimize, Crossgen2Option.StripILBodies],
+                    AdditionalArgs = ["--targetarch:x64"],
                     Validate = Validate,
                 },
             ]));
@@ -593,6 +594,7 @@ static void Validate(ReadyToRunReader reader)
             Assert.True(R2RAssert.MethodILIsStripped(componentFile, "StripILBodies", "PlainStrippableMethod", out diag), diag);
             Assert.True(R2RAssert.MethodILIsStripped(componentFile, "StripILBodies", "ComputeTag", out diag), diag);
             Assert.True(R2RAssert.MethodILIsStripped(componentFile, "StripILBodies", "Root", out diag), diag);
+            Assert.True(R2RAssert.MethodILIsStripped(componentFile, "StripILBodies", "UsesRuntimeCheckedInstructionSet", out diag), diag);
 
             Assert.True(R2RAssert.MethodILIsStripped(componentFile, "StripILBodies", "AsyncTaskMethod", out diag), diag);
             Assert.True(R2RAssert.MethodILIsStripped(componentFile, "StripILBodies", "AsyncValueTaskMethod", out diag), diag);
@@ -604,6 +606,50 @@ static void Validate(ReadyToRunReader reader)
         }
     }
 
+    [Fact]
+    public void AppleMobileStripILBodiesUsesFixedInstructionSet()
+    {
+        var stripILBodies = new CompiledAssembly
+        {
+            AssemblyName = nameof(AppleMobileStripILBodiesUsesFixedInstructionSet),
+            SourceResourceNames =
+            [
+                "RuntimeAsync/StripILBodies.cs",
+                "RuntimeAsync/RuntimeAsyncMethodGenerationAttribute.cs",
+            ],
+            Features = { RuntimeAsyncFeature },
+        };
+
+        new R2RTestRunner(_output).Run(new R2RTestCase(
+            nameof(AppleMobileStripILBodiesUsesFixedInstructionSet),
+            [
+                new(nameof(AppleMobileStripILBodiesUsesFixedInstructionSet), [new CrossgenAssembly(stripILBodies)])
+                {
+                    Options = [Crossgen2Option.Composite, Crossgen2Option.Optimize, Crossgen2Option.StripILBodies],
+                    AdditionalArgs = ["--targetos:ios", "--targetarch:arm64"],
+                    Validate = Validate,
+                },
+            ]));
+
+        static void Validate(ReadyToRunReader reader)
+        {
+            string componentFile = Path.Combine(
+                Path.GetDirectoryName(reader.Filename)!,
+                nameof(AppleMobileStripILBodiesUsesFixedInstructionSet) + ".dll");
+
+            Assert.True(R2RAssert.MethodILIsStripped(componentFile, "StripILBodies", "PlainStrippableMethod", out string diag), diag);
+            Assert.True(R2RAssert.MethodILIsStripped(componentFile, "StripILBodies", "UsesRuntimeCheckedInstructionSet", out diag), diag);
+            Assert.False(
+                R2RAssert.HasFixupKindOnMethod(
+                    reader,
+                    ReadyToRunFixupKind.Check_InstructionSetSupport,
+                    ".UsesRuntimeCheckedInstructionSet(",
+                    out diag),
+                diag);
+            Assert.True(R2RAssert.EagerInstructionSetSupportHasNoUnsupportedEntries(reader, out diag), diag);
+        }
+    }
+
     /// <summary>
     /// PR #123643: Async methods capturing GC refs across await points
     /// produce ContinuationLayout fixups encoding the GC ref map.

src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCases/RuntimeAsync/StripILBodies.cs

@@ -8,6 +8,9 @@
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 
+using ArmAes = System.Runtime.Intrinsics.Arm.Aes;
+using X86Aes = System.Runtime.Intrinsics.X86.Aes;
+
 public static class StripILBodies
 {
     [MethodImpl(MethodImplOptions.NoInlining)]
@@ -82,6 +85,12 @@ public static int PlainStrippableMethod(int a, int b)
         return a + b + ComputeTag();
     }
 
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static bool UsesRuntimeCheckedInstructionSet()
+    {
+        return X86Aes.IsSupported || ArmAes.IsSupported || ArmAes.Arm64.IsSupported;
+    }
+
     [MethodImpl(MethodImplOptions.NoInlining)]
     private static int ComputeTag()
     {

src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/R2RResultChecker.cs

@@ -954,6 +954,47 @@ public static bool HasFixupKindCountOnMethod(ReadyToRunReader reader, ReadyToRun
         return true;
     }
 
+    /// <summary>
+    /// Returns true if the global eager baseline <see cref="ReadyToRunFixupKind.Check_InstructionSetSupport"/>
+    /// fixup does not assert that any instruction set must be absent at runtime ("must be absent" entries render
+    /// with a <c>-</c> suffix; supported entries use <c>+</c>). Targets that cannot generate code at runtime must
+    /// not encode these assertions, as a failing eager fixup fatally disables all ReadyToRun code with no JIT fallback.
+    /// </summary>
+    public static bool EagerInstructionSetSupportHasNoUnsupportedEntries(ReadyToRunReader reader, out string diagnostic)
+    {
+        var options = new SignatureFormattingOptions();
+        var signatures = new List<string>();
+        foreach (ReadyToRunImportSection section in reader.ImportSections)
+        {
+            if (section.Entries is null)
+                continue;
+
+            foreach (ReadyToRunImportSection.ImportSectionEntry entry in section.Entries)
+            {
+                if (entry.Signature is not null && entry.Signature.FixupKind == ReadyToRunFixupKind.Check_InstructionSetSupport)
+                    signatures.Add(entry.Signature.ToString(options));
+            }
+        }
+
+        if (signatures.Count == 0)
+        {
+            diagnostic = "Expected a global Check_InstructionSetSupport eager fixup, but none was found.";
+            return false;
+        }
+
+        var withUnsupported = signatures.Where(s => s.Contains('-')).ToList();
+        if (withUnsupported.Count > 0)
+        {
+            diagnostic =
+                "Global Check_InstructionSetSupport fixup must not assert any instruction set is absent " +
+                $"on no-JIT targets, but found: [{string.Join(", ", withUnsupported)}]";
+            return false;
+        }
+
+        diagnostic = $"Global Check_InstructionSetSupport fixup asserts only supported instruction sets: [{string.Join(", ", signatures)}]";
+        return true;
+    }
+
     /// <summary>
     /// Returns true if the R2R image contains at least one fixup of the given kind.
     /// </summary>

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ReadyToRunInstructionSetSupportSignature.cs

@@ -15,13 +15,11 @@ public class ReadyToRunInstructionSetSupportSignature : Signature
     {
         string _instructionSetsSupport;
 
-        public static string ToInstructionSetSupportString(InstructionSetSupport instructionSetSupport)
+        public static string ToInstructionSetSupportString(InstructionSetSupport instructionSetSupport, bool emitExplicitlyUnsupported = true)
         {
             StringBuilder builder = new StringBuilder();
             InstructionSet[] supportedInstructionSets = instructionSetSupport.SupportedFlags.ToArray();
             Array.Sort(supportedInstructionSets);
-            InstructionSet[] explicitlyUnsupportedInstructionSets = instructionSetSupport.ExplicitlyUnsupportedFlags.ToArray();
-            Array.Sort(explicitlyUnsupportedInstructionSets);
 
             bool addDelimiter = false;
             var r2rAlreadyEmitted = new HashSet<ReadyToRunInstructionSet>();
@@ -43,19 +41,25 @@ public static string ToInstructionSetSupportString(InstructionSetSupport instruc
             builder.Append(',');
             r2rAlreadyEmitted.Clear();
 
-            addDelimiter = false;
-            foreach (var instructionSetUnsupported in explicitlyUnsupportedInstructionSets)
+            if (emitExplicitlyUnsupported)
             {
-                var r2rInstructionSet = instructionSetUnsupported.R2RInstructionSet(instructionSetSupport.Architecture);
-                if (r2rInstructionSet == null)
-                    continue;
+                InstructionSet[] explicitlyUnsupportedInstructionSets = instructionSetSupport.ExplicitlyUnsupportedFlags.ToArray();
+                Array.Sort(explicitlyUnsupportedInstructionSets);
 
-                if (r2rAlreadyEmitted.Add(r2rInstructionSet.Value))
+                addDelimiter = false;
+                foreach (var instructionSetUnsupported in explicitlyUnsupportedInstructionSets)
                 {
-                    if (addDelimiter)
-                        builder.Append('-');
-                    addDelimiter = true;
-                    builder.Append(r2rInstructionSet.Value.ToString());
+                    var r2rInstructionSet = instructionSetUnsupported.R2RInstructionSet(instructionSetSupport.Architecture);
+                    if (r2rInstructionSet == null)
+                        continue;
+
+                    if (r2rAlreadyEmitted.Add(r2rInstructionSet.Value))
+                    {
+                        if (addDelimiter)
+                            builder.Append('-');
+                        addDelimiter = true;
+                        builder.Append(r2rInstructionSet.Value.ToString());
+                    }
                 }
             }
 

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

@@ -382,8 +382,11 @@ internal ReadyToRunCodegenCompilation(
             CompilationModuleGroup = (ReadyToRunCompilationModuleGroupBase)nodeFactory.CompilationModuleGroup;
 
             // Generate baseline support specification for InstructionSetSupport. This will prevent usage of the generated
-            // code if the runtime environment doesn't support the specified instruction set
-            string instructionSetSupportString = ReadyToRunInstructionSetSupportSignature.ToInstructionSetSupportString(instructionSetSupport);
+            // code if the runtime environment doesn't support the specified instruction set. Targets that cannot generate
+            // code at runtime must not encode "must be absent" assertions, since a failing eager fixup is a fatal startup
+            // error with no JIT fallback (see ToInstructionSetSupportString).
+            bool targetAllowsRuntimeCodeGeneration = ((ReadyToRunCompilerContext)nodeFactory.TypeSystemContext).TargetAllowsRuntimeCodeGeneration;
+            string instructionSetSupportString = ReadyToRunInstructionSetSupportSignature.ToInstructionSetSupportString(instructionSetSupport, emitExplicitlyUnsupported: targetAllowsRuntimeCodeGeneration);
             ReadyToRunInstructionSetSupportSignature instructionSetSupportSig = new ReadyToRunInstructionSetSupportSignature(instructionSetSupportString);
             _dependencyGraph.AddRoot(new Import(NodeFactory.EagerImports, instructionSetSupportSig), "Baseline instruction set support");
 

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

@@ -58,11 +58,13 @@ public ReadyToRunCompilerContext(
             TargetDetails details,
             SharedGenericsMode genericsMode,
             bool bubbleIncludesCoreModule,
+            bool targetAllowsRuntimeCodeGeneration,
             InstructionSetSupport instructionSetSupport,
             CompilerTypeSystemContext oldTypeSystemContext)
             : base(details, genericsMode)
         {
             BubbleIncludesCoreModule = bubbleIncludesCoreModule;
+            TargetAllowsRuntimeCodeGeneration = targetAllowsRuntimeCodeGeneration;
             InstructionSetSupport = instructionSetSupport;
             _r2rFieldLayoutAlgorithm = new ReadyToRunMetadataFieldLayoutAlgorithm();
             _systemObjectFieldLayoutAlgorithm = new SystemObjectFieldLayoutAlgorithm(_r2rFieldLayoutAlgorithm);
@@ -99,27 +101,7 @@ public ReadyToRunCompilerContext(
 
         public InstructionSetSupport InstructionSetSupport { get; }
 
-        public bool TargetAllowsRuntimeCodeGeneration
-        {
-            get
-            {
-#if FEATURE_DYNAMIC_CODE_COMPILED
-                if (Target.OperatingSystem is TargetOS.iOS or TargetOS.iOSSimulator or TargetOS.MacCatalyst or TargetOS.tvOS or TargetOS.tvOSSimulator)
-                {
-                    return false;
-                }
-
-                if (Target.Architecture is TargetArchitecture.Wasm32)
-                {
-                    return false;
-                }
-
-                return true;
-#else
-                return false;
-#endif
-            }
-        }
+        public bool TargetAllowsRuntimeCodeGeneration { get; }
 
         public override FieldLayoutAlgorithm GetLayoutAlgorithmForType(DefType type)
         {

src/coreclr/tools/aot/ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj

@@ -5,7 +5,6 @@
     <TargetFramework>$(NetCoreAppToolCurrent)</TargetFramework>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <DefineConstants>READYTORUN;$(DefineConstants)</DefineConstants>
-    <DefineConstants Condition="'$(FeatureDynamicCodeCompiled)' == 'true'">$(DefineConstants);FEATURE_DYNAMIC_CODE_COMPILED</DefineConstants>
     <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
     <Platforms>x64;x86;arm;arm64</Platforms>
     <PlatformTarget>AnyCPU</PlatformTarget>

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

@@ -76,29 +76,34 @@ public int Run()
 
             var logger = new Logger(Console.Out, Get(_command.IsVerbose));
 
-            // Crossgen2 is partial AOT and its pre-compiled methods can be
-            // thrown away at runtime if they mismatch in required ISAs or
-            // computed layouts of structs. Thus we want to ensure that usage
-            // of Vector<T> is only optimistic and doesn't hard code a dependency
-            // that would cause the entire image to be invalidated.
-            bool isVectorTOptimistic = true;
-
             (TargetArchitecture targetArchitecture, TargetOS targetOS, TargetAbi targetAbi) =
                 Helpers.GetTargetSpec(Get(_command.TargetArchitecture), Get(_command.TargetOS));
+            bool targetAllowsRuntimeCodeGeneration = GetTargetAllowsRuntimeCodeGeneration(targetOS, targetArchitecture);
+
+            // Crossgen2 is partial AOT and its pre-compiled methods can be thrown away at runtime if
+            // they mismatch in required ISAs or computed layouts of structs. On targets that allow
+            // runtime code generation we keep Vector<T> usage optimistic so we never hard code a
+            // dependency that could invalidate the entire image. On targets that do not allow
+            // runtime code generation, we do not want an ISA mismatch to invalidate any code
+            // in the image. There we make Vector<T> non-optimistic and hard code the ISA support
+            // to avoid falling back to the interpreter.
+            bool isVectorTOptimistic = targetAllowsRuntimeCodeGeneration;
             bool allowOptimistic = _command.OptimizationMode != OptimizationMode.PreferSize;
 
-            if (targetOS is TargetOS.iOS or TargetOS.tvOS or TargetOS.iOSSimulator or TargetOS.tvOSSimulator or TargetOS.MacCatalyst or TargetOS.Browser or TargetOS.Wasi)
+            if (!targetAllowsRuntimeCodeGeneration)
             {
-                // These platforms do not support jitted code, so we want to ensure that we don't
-                // need to fall back to the interpreter for any hardware-intrinsic optimizations.
-                // Disable optimistic instruction sets by default.
                 allowOptimistic = false;
             }
 
             InstructionSetSupport instructionSetSupport = Helpers.ConfigureInstructionSetSupport(Get(_command.InstructionSet), Get(_command.MaxVectorTBitWidth), isVectorTOptimistic, targetArchitecture, targetOS,
                 SR.InstructionSetMustNotBe, SR.InstructionSetInvalidImplication, logger,
                 allowOptimistic: allowOptimistic,
                 isReadyToRun: true);
+            if (!targetAllowsRuntimeCodeGeneration)
+            {
+                instructionSetSupport = Helpers.GetFixedInstructionSetSupport(instructionSetSupport);
+            }
+
             SharedGenericsMode genericsMode = SharedGenericsMode.CanonicalReferenceTypes;
             var targetDetails = new TargetDetails(targetArchitecture, targetOS, targetAbi, instructionSetSupport.GetVectorTSimdVector());
 
@@ -142,6 +147,7 @@ public int Run()
             // Initialize type system context
             //
             _typeSystemContext = new ReadyToRunCompilerContext(targetDetails, genericsMode, versionBubbleIncludesCoreLib,
+                targetAllowsRuntimeCodeGeneration,
                 instructionSetSupport,
                 oldTypeSystemContext: null);
 
@@ -286,6 +292,7 @@ public int Run()
                         bool singleCompilationVersionBubbleIncludesCoreLib = versionBubbleIncludesCoreLib || (String.Compare(inputFile.Key, "System.Private.CoreLib", StringComparison.OrdinalIgnoreCase) == 0);
 
                         typeSystemContext = new ReadyToRunCompilerContext(targetDetails, genericsMode, singleCompilationVersionBubbleIncludesCoreLib,
+                            targetAllowsRuntimeCodeGeneration,
                             _typeSystemContext.InstructionSetSupport,
                             _typeSystemContext);
                         typeSystemContext.InputFilePaths = singleCompilationInputFilePaths;
@@ -700,6 +707,12 @@ private void RunSingleCompilation(Dictionary<string, string> inFilePaths, Instru
             }
         }
 
+        private static bool GetTargetAllowsRuntimeCodeGeneration(TargetOS operatingSystem, TargetArchitecture architecture)
+        {
+            return operatingSystem is not (TargetOS.iOS or TargetOS.iOSSimulator or TargetOS.MacCatalyst or TargetOS.tvOS or TargetOS.tvOSSimulator or TargetOS.Browser or TargetOS.Wasi)
+                && architecture is not TargetArchitecture.Wasm32;
+        }
+
         private void CheckManagedCppInputFiles(IEnumerable<string> inputPaths)
         {
             foreach (string inputFilePath in inputPaths)