Implement Interop Type Map support in NativeAOT

eng/testing/linker/trimmingTests.targets

@@ -40,6 +40,7 @@
       <_SkippedAppSourceFiles Include="@(TestConsoleAppSourceFiles)" Condition="$([System.String]::Copy('%(TestConsoleAppSourceFiles.SkipOnTestRuntimes)').Contains('$(OutputRID)'))" />
 
       <_SkippedAppSourceFiles Include="@(TestConsoleAppSourceFiles)" Condition="'$(RunNativeAotTestApps)' == 'true' and '%(TestConsoleAppSourceFiles.NativeAotIncompatible)' == 'true'" />
+      <_SkippedAppSourceFiles Include="@(TestConsoleAppSourceFiles)" Condition="'$(RunNativeAotTestApps)' != 'true' and '%(TestConsoleAppSourceFiles.NativeAotOnly)' == 'true'" />
 
       <_AppSourceFiles Include="@(TestConsoleAppSourceFiles)" Exclude="@(_SkippedAppSourceFiles)" />
 
@@ -165,7 +166,7 @@
     </Exec>
 
     <Error Condition="'$(ExecutionExitCode)' != '100'" Text="Error: [Failed Test]: %(TestConsoleApps.ProjectCompileItems). The Command %(TestConsoleApps.TestCommand) return a non-success exit code $(ExecutionExitCode)." ContinueOnError="ErrorAndContinue" />
- 
+
     <!-- Remove test projects dir to save disk space if the test was successful. Ignore failures as this is best effort.
          Don't use Removedir as ContinueOnError on it doesn't work when using warnaserror/TreatWarningsAsErrors. -->
     <PropertyGroup>

src/coreclr/nativeaot/System.Private.CoreLib/src/CompatibilitySuppressions.xml

@@ -825,4 +825,8 @@
     <DiagnosticId>CP0002</DiagnosticId>
     <Target>M:System.Diagnostics.DiagnosticMethodInfo.#ctor(System.String,System.String,System.String)</Target>
   </Suppression>
-</Suppressions>
+  <Suppression>
+    <DiagnosticId>CP0001</DiagnosticId>
+    <Target>T:Internal.NativeFormat.TypeHashingAlgorithms</Target>
+  </Suppression>
+</Suppressions>

src/coreclr/nativeaot/System.Private.CoreLib/src/System.Private.CoreLib.csproj

@@ -196,6 +196,7 @@
     <Compile Include="System\Runtime\CompilerServices\StaticClassConstructionContext.cs" />
     <Compile Include="System\Runtime\ExceptionIDs.cs" />
     <Compile Include="System\Runtime\GCSettings.NativeAot.cs" />
+    <Compile Include="System\Runtime\InteropServices\TypeMapLazyDictionary.NativeAot.cs" />
     <Compile Include="System\Runtime\TypeLoaderExports.cs" />
     <Compile Include="System\Runtime\ThunkPool.cs" />
     <Compile Include="System\Runtime\InteropServices\ComEventsHelper.NativeAot.cs" Condition="'$(FeatureCominterop)' == 'true'" />
@@ -322,6 +323,9 @@
     <Compile Include="$(CompilerCommonPath)\TypeSystem\Common\Utilities\LockFreeReaderHashtableOfPointers.cs">
       <Link>Utilities\LockFreeReaderHashtableOfPointers.cs</Link>
     </Compile>
+    <Compile Include="$(CompilerCommonPath)\TypeSystem\Common\TypeHashingAlgorithms.cs">
+      <Link>Utilities\TypeHashingAlgorithms.cs</Link>
+    </Compile>
     <Compile Include="$(AotCommonPath)\System\Collections\Generic\LowLevelList.cs">
       <Link>System\Collections\Generic\LowLevelList.cs</Link>
     </Compile>

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.NativeAot.cs

@@ -0,0 +1,209 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Text;
+
+using Internal.NativeFormat;
+using Internal.Reflection.Core.Execution;
+using Internal.Runtime;
+using Internal.Runtime.Augments;
+using Internal.Runtime.TypeLoader;
+
+namespace System.Runtime.InteropServices
+{
+    internal static class TypeMapLazyDictionary
+    {
+        public static IReadOnlyDictionary<string, Type> CreateExternalTypeMap(RuntimeType typeMapGroup)
+        {
+            RuntimeTypeHandle typeMapGroupHandle = typeMapGroup.TypeHandle;
+            foreach (TypeManagerHandle module in RuntimeAugments.GetLoadedModules())
+            {
+                if (!TryGetNativeReaderForBlob(module, ReflectionMapBlob.ExternalTypeMap, out NativeReader externalTypeMapReader))
+                {
+                    continue;
+                }
+                NativeParser externalTypeMapParser = new NativeParser(externalTypeMapReader, 0);
+                NativeHashtable externalTypeMapTable = new NativeHashtable(externalTypeMapParser);
+
+                ExternalReferencesTable externalReferences = default;
+                externalReferences.InitializeCommonFixupsTable(module);
+
+                var lookup = externalTypeMapTable.Lookup(typeMapGroupHandle.GetHashCode());
+                NativeParser entryParser;
+                while (!(entryParser = lookup.GetNext()).IsNull)
+                {
+                    RuntimeTypeHandle foundTypeMapGroup = externalReferences.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned());
+                    if (!foundTypeMapGroup.Equals(typeMapGroupHandle))
+                    {
+                        continue;
+                    }
+                    bool isValid = entryParser.GetUnsigned() == 1;
+                    if (!isValid)
+                    {
+                        unsafe
+                        {
+                            delegate*<void> exceptionStub = (delegate*<void>)externalReferences.GetFunctionPointerFromIndex(entryParser.GetUnsigned());
+                            exceptionStub();
+                            Debug.Fail("Expected exception stub to throw an exception.");
+                            return null; // Should never reach here, as the exception stub should throw an exception.
+                        }
+                    }
+
+                    return new ExternalTypeMapDictionary(new NativeHashtable(entryParser), externalReferences);
+                }
+            }
+
+            throw ReflectionCoreExecution.ExecutionEnvironment.CreateMissingMetadataException(typeMapGroup);
+        }
+
+        public static IReadOnlyDictionary<Type, Type> CreateProxyTypeMap(RuntimeType typeMapGroup)
+        {
+            RuntimeTypeHandle typeMapGroupHandle = typeMapGroup.TypeHandle;
+            foreach (TypeManagerHandle module in RuntimeAugments.GetLoadedModules())
+            {
+                if (!TryGetNativeReaderForBlob(module, ReflectionMapBlob.ProxyTypeMap, out NativeReader externalTypeMapReader))
+                {
+                    continue;
+                }
+                NativeParser externalTypeMapParser = new NativeParser(externalTypeMapReader, 0);
+                NativeHashtable externalTypeMapTable = new NativeHashtable(externalTypeMapParser);
+
+                ExternalReferencesTable externalReferences = default;
+                externalReferences.InitializeCommonFixupsTable(module);
+
+                var lookup = externalTypeMapTable.Lookup(typeMapGroupHandle.GetHashCode());
+                NativeParser entryParser;
+                while (!(entryParser = lookup.GetNext()).IsNull)
+                {
+                    RuntimeTypeHandle foundTypeMapGroup = externalReferences.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned());
+                    if (!foundTypeMapGroup.Equals(typeMapGroupHandle))
+                    {
+                        continue;
+                    }
+                    bool isValid = entryParser.GetUnsigned() == 1;
+                    if (!isValid)
+                    {
+                        unsafe
+                        {
+                            delegate*<void> exceptionStub = (delegate*<void>)externalReferences.GetFunctionPointerFromIndex(entryParser.GetUnsigned());
+                            exceptionStub();
+                            Debug.Fail("Expected exception stub to throw an exception.");
+                            return null; // Should never reach here, as the exception stub should throw an exception.
+                        }
+                    }
+
+                    return new AssociatedTypeMapDictionary(new NativeHashtable(entryParser), externalReferences);
+                }
+            }
+
+            throw ReflectionCoreExecution.ExecutionEnvironment.CreateMissingMetadataException(typeMapGroup);
+        }
+
+        private static unsafe bool TryGetNativeReaderForBlob(TypeManagerHandle module, ReflectionMapBlob blob, out NativeReader reader)
+        {
+            byte* pBlob;
+            uint cbBlob;
+
+            if (RuntimeImports.RhFindBlob(module, (uint)blob, &pBlob, &cbBlob))
+            {
+                reader = new NativeReader(pBlob, cbBlob);
+                return true;
+            }
+
+            reader = default;
+            return false;
+        }
+
+        private abstract class TypeMapDictionaryBase<TKey> : IReadOnlyDictionary<TKey, Type>
+        {
+            public abstract Type this[TKey key] { get; }
+            public abstract bool TryGetValue(TKey key, [MaybeNullWhen(false)] out Type value);
+            // Not supported to avoid exposing TypeMap entries in a manner that
+            // would violate invariants the Trimmer is attempting to enforce.
+            public IEnumerable<TKey> Keys => throw new NotSupportedException();
+            public IEnumerable<Type> Values => throw new NotSupportedException();
+            public int Count => throw new NotSupportedException();
+            public bool ContainsKey(TKey key) => throw new NotSupportedException();
+            public IEnumerator<KeyValuePair<TKey, Type>> GetEnumerator() => throw new NotSupportedException();
+            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        }
+
+        private sealed class ExternalTypeMapDictionary(NativeHashtable table, ExternalReferencesTable externalReferences) : TypeMapDictionaryBase<string>
+        {
+            public override Type this[string key]
+            {
+                get
+                {
+                    if (!TryGetValue(key, out Type? value))
+                    {
+                        ThrowHelper.ThrowKeyNotFoundException(key);
+                    }
+                    return value;
+                }
+            }
+
+            public override  bool TryGetValue(string key, [MaybeNullWhen(false)] out Type value)
+            {
+                var lookup = table.Lookup(TypeHashingAlgorithms.ComputeNameHashCode(key));
+                NativeParser entryParser;
+                while (!(entryParser = lookup.GetNext()).IsNull)
+                {
+                    if (entryParser.StringEquals(key))
+                    {
+                        entryParser.SkipString();
+                        RuntimeTypeHandle typeHandle = externalReferences.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned());
+                        value = Type.GetTypeFromHandle(typeHandle)!;
+                        return true;
+                    }
+                }
+                value = null;
+                return false;
+            }
+        }
+
+        private sealed class AssociatedTypeMapDictionary(NativeHashtable table, ExternalReferencesTable externalReferences) : TypeMapDictionaryBase<Type>
+        {
+            public override Type this[Type key]
+            {
+                get
+                {
+                    if (!TryGetValue(key, out Type? value))
+                    {
+                        ThrowHelper.ThrowKeyNotFoundException(key);
+                    }
+                    return value;
+                }
+            }
+
+            public override bool TryGetValue(Type key, [MaybeNullWhen(false)] out Type value)
+            {
+                RuntimeTypeHandle handle = key.TypeHandle;
+                if (handle.IsNull)
+                {
+                    value = null;
+                    return false;
+                }
+
+                var lookup = table.Lookup(handle.GetHashCode());
+                NativeParser entryParser;
+                while (!(entryParser = lookup.GetNext()).IsNull)
+                {
+                    RuntimeTypeHandle foundHandle = externalReferences.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned());
+                    if (foundHandle.Equals(handle))
+                    {
+                        RuntimeTypeHandle targetHandle = externalReferences.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned());
+                        value = Type.GetTypeFromHandle(targetHandle)!;
+                        return true;
+                    }
+                }
+                value = null;
+                return false;
+            }
+        }
+    }
+}

src/coreclr/nativeaot/System.Private.TypeLoader/src/System.Private.TypeLoader.csproj

@@ -216,7 +216,6 @@
     <Compile Include="Internal\Runtime\TypeLoader\EETypeCreator.cs" />
     <Compile Include="Internal\Reflection\Execution\AssemblyBinderImplementation.cs" />
     <Compile Include="$(CompilerCommonPath)\Internal\Metadata\NativeFormat\MetadataTypeHashingAlgorithms.cs" />
-    <Compile Include="$(CompilerCommonPath)\TypeSystem\Common\TypeHashingAlgorithms.cs" />
     <Compile Include="$(AotCommonPath)\Internal\Runtime\TypeLoader\ExternalReferencesTable.cs" />
     <Compile Include="Internal\Runtime\TypeLoader\ExternalReferencesTable.NativeFormatModuleInfo.cs" />
     <Compile Include="Internal\Runtime\TypeLoader\GenericDictionary.cs" />

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

@@ -95,6 +95,8 @@ protected enum ObjectNodeOrder
             StaticsInfoHashtableNode,
             ReflectionVirtualInvokeMapNode,
             ArrayOfEmbeddedPointersNode,
+            ExternalTypeMapObjectNode,
+            ProxyTypeMapObjectNode,
             ExternalReferencesTableNode,
             StackTraceEmbeddedMetadataNode,
             StackTraceMethodMappingNode,

src/coreclr/tools/Common/Internal/NativeFormat/NativeFormatReader.String.cs

@@ -24,6 +24,11 @@ public void SkipString()
         {
             _offset = _reader.SkipString(_offset);
         }
+
+        public bool StringEquals(string str)
+        {
+            return _reader.StringEquals(_offset, str);
+        }
     }
 
     internal partial class NativeReader

src/coreclr/tools/Common/Internal/NativeFormat/NativeFormatWriter.cs

@@ -2041,15 +2041,5 @@ internal override void Save(NativeWriter writer)
                 }
             }
         }
-
-        public override bool Equals(object obj)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override int GetHashCode()
-        {
-            throw new NotImplementedException();
-        }
     }
 }

src/coreclr/tools/Common/Internal/Runtime/MetadataBlob.cs

@@ -42,5 +42,9 @@ internal enum ReflectionMapBlob
         StaticsInfoHashtable                        = 34,
         GenericMethodsHashtable                     = 35,
         ExactMethodInstantiationsHashtable          = 36,
+
+        // Type map blobs:
+        ExternalTypeMap                             = 40,
+        ProxyTypeMap                                = 41,
     }
 }

src/coreclr/tools/Common/TypeSystem/Common/TypeHashingAlgorithms.cs

@@ -5,12 +5,16 @@
 // Generic functions to compute the hashcode value of types
 // ---------------------------------------------------------------------------
 
+using System;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Text;
 
 namespace Internal.NativeFormat
 {
+#if SYSTEM_PRIVATE_CORELIB
+    [CLSCompliant(false)]
+#endif
     public static class TypeHashingAlgorithms
     {
         public struct HashCodeBuilder

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/CompilationBuilder.Aot.cs

@@ -26,6 +26,7 @@ public partial class CompilationBuilder
         protected SecurityMitigationOptions _mitigationOptions;
         protected bool _dehydrate;
         protected bool _useDwarf5;
+        protected TypeMapManager _typeMapManager = new UsageBasedTypeMapManager(TypeMapMetadata.Empty);
 
         partial void InitializePartial()
         {
@@ -129,6 +130,12 @@ public CompilationBuilder UseDwarf5(bool value)
             return this;
         }
 
+        public CompilationBuilder UseTypeMapManager(TypeMapManager typeMapManager)
+        {
+            _typeMapManager = typeMapManager;
+            return this;
+        }
+
         protected PreinitializationManager GetPreinitializationManager()
         {
             if (_preinitializationManager == null)

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/HandleCallAction.cs

@@ -488,6 +488,36 @@ private partial bool TryHandleIntrinsic (
                     _diagnosticContext.AddDiagnostic(DiagnosticId.AvoidAssemblyGetFilesInSingleFile, calledMethod.GetDisplayName());
                     break;
 
+                case IntrinsicId.TypeMapping_GetOrCreateExternalTypeMapping:
+                {
+                    if (calledMethod.Method.Instantiation[0].ContainsSignatureVariables(treatGenericParameterLikeSignatureVariable: true))
+                    {
+                        // We only support GetOrCreateExternalTypeMapping for a fully specified type.
+                        _diagnosticContext.AddDiagnostic(DiagnosticId.TypeMapGroupTypeCannotBeStaticallyDetermined,
+                            calledMethod.Method.Instantiation[0].GetDisplayName());
+                    }
+                    else
+                    {
+                        TypeDesc typeMapGroup = calledMethod.Method.Instantiation[0];
+                        _reflectionMarker.Dependencies.Add(_reflectionMarker.Factory.ExternalTypeMapRequest(typeMapGroup), "TypeMapping.GetOrCreateExternalTypeMapping called on type");
+                    }
+                    break;
+                }
+                case IntrinsicId.TypeMapping_GetOrCreateProxyTypeMapping:
+                {
+                    if (calledMethod.Method.Instantiation[0].ContainsSignatureVariables(treatGenericParameterLikeSignatureVariable: true))
+                    {
+                        // We only support GetOrCreateProxyTypeMapping for a fully specified type.
+                        _diagnosticContext.AddDiagnostic(DiagnosticId.TypeMapGroupTypeCannotBeStaticallyDetermined,
+                            calledMethod.Method.Instantiation[0].GetDisplayName());
+                    }
+                    else
+                    {
+                        TypeDesc typeMapGroup = calledMethod.Method.Instantiation[0];
+                        _reflectionMarker.Dependencies.Add(_reflectionMarker.Factory.ProxyTypeMapRequest(typeMapGroup), "TypeMapping.GetOrCreateProxyTypeMapping called on type");
+                    }
+                    break;
+                }
                 default:
                     return false;
             }