Make textual stack trace metadata smaller (#89377)

When we need to generate a textual stack trace in NativeAOT, we rely on two things - reflection metadata for methods, or a supplementary stack trace metadata format.

The reflection metadata case is simple - reflection keeps track of method addresses and the associated metadata like names and signatures. We ask for metadata handles (tokens, basically) and we get the handles back. We then walk the metadata and format textual strings.

When reflection metadata is not available, we have to emit some other metadata in the compiler. We use the same metadata format and conceptually the closest thing were unresolvable `MemberReference`s, so we basically generated a pair of method pointer + MemberReference handle for each method body that doesn't have reflection metadata. It's a lot less metadata than for a resolvable definition, but is still quite a bit wasteful.

This change avoids generating full `MemberReference` and instead inlines owning type/name/signature handle/token into the mapping table. We also do it in a way that avoids emitting owning type/name/signature if it's the same as the record before that.

Author: MichalStrehovsky

src/coreclr/nativeaot/System.Private.StackTraceMetadata/src/Internal/StackTraceMetadata/MethodNameFormatter.cs

@@ -35,10 +35,38 @@ private MethodNameFormatter(MetadataReader metadataReader, SigTypeContext typeCo
             _typeContext = typeContext;
         }
 
-        public static string FormatMethodName(MetadataReader metadataReader, Handle methodHandle)
+        public static string FormatMethodName(MetadataReader metadataReader, Handle owningType, ConstantStringValueHandle name, MethodSignatureHandle signature, ConstantStringArrayHandle genericArguments)
         {
-            MethodNameFormatter formatter = new MethodNameFormatter(metadataReader, SigTypeContext.FromMethod(metadataReader, methodHandle));
-            formatter.EmitMethodName(methodHandle);
+            MethodNameFormatter formatter = new MethodNameFormatter(metadataReader, SigTypeContext.FromMethod(metadataReader, owningType, genericArguments));
+            formatter.EmitTypeName(owningType, namespaceQualified: true);
+            formatter._outputBuilder.Append('.');
+            formatter.EmitString(name);
+
+            if (!genericArguments.IsNull(metadataReader))
+            {
+                var args = metadataReader.GetConstantStringArray(genericArguments);
+                bool first = true;
+                foreach (Handle handle in args.Value)
+                {
+                    if (first)
+                    {
+                        first = false;
+                        formatter._outputBuilder.Append('[');
+                    }
+                    else
+                    {
+                        formatter._outputBuilder.Append(',');
+                    }
+                    formatter.EmitString(handle.ToConstantStringValueHandle(metadataReader));
+                }
+                if (!first)
+                {
+                    formatter._outputBuilder.Append(']');
+                }
+            }
+
+            formatter.EmitMethodParameters(metadataReader.GetMethodSignature(signature));
+
             return formatter._outputBuilder.ToString();
         }
 
@@ -75,99 +103,6 @@ public static string FormatMethodName(MetadataReader metadataReader, TypeDefinit
             return formatter._outputBuilder.ToString();
         }
 
-        /// <summary>
-        /// Emit a given method signature to a specified string builder.
-        /// </summary>
-        /// <param name="methodHandle">Method reference or instantiation token</param>
-        private void EmitMethodName(Handle methodHandle)
-        {
-            switch (methodHandle.HandleType)
-            {
-                case HandleType.MemberReference:
-                    EmitMethodReferenceName(methodHandle.ToMemberReferenceHandle(_metadataReader));
-                    break;
-
-                case HandleType.MethodInstantiation:
-                    EmitMethodInstantiationName(methodHandle.ToMethodInstantiationHandle(_metadataReader));
-                    break;
-
-                case HandleType.QualifiedMethod:
-                    EmitMethodDefinitionName(methodHandle.ToQualifiedMethodHandle(_metadataReader));
-                    break;
-
-                default:
-                    Debug.Assert(false);
-                    _outputBuilder.Append("???");
-                    break;
-            }
-        }
-
-        /// <summary>
-        /// Emit method reference to the output string builder.
-        /// </summary>
-        /// <param name="memberRefHandle">Member reference handle</param>
-        private void EmitMethodReferenceName(MemberReferenceHandle memberRefHandle)
-        {
-            MemberReference methodRef = _metadataReader.GetMemberReference(memberRefHandle);
-            MethodSignature methodSignature;
-            EmitContainingTypeAndMethodName(methodRef, out methodSignature);
-            EmitMethodParameters(methodSignature);
-        }
-
-        /// <summary>
-        /// Emit generic method instantiation to the output string builder.
-        /// </summary>
-        /// <param name="methodInstHandle">Method instantiation handle</param>
-        private void EmitMethodInstantiationName(MethodInstantiationHandle methodInstHandle)
-        {
-            MethodInstantiation methodInst = _metadataReader.GetMethodInstantiation(methodInstHandle);
-
-            if (methodInst.Method.HandleType == HandleType.MemberReference)
-            {
-                MemberReferenceHandle methodRefHandle = methodInst.Method.ToMemberReferenceHandle(_metadataReader);
-                MemberReference methodRef = methodRefHandle.GetMemberReference(_metadataReader);
-                EmitContainingTypeAndMethodName(methodRef, out MethodSignature methodSignature);
-                EmitGenericArguments(methodInst.GenericTypeArguments);
-                EmitMethodParameters(methodSignature);
-            }
-            else
-            {
-                QualifiedMethodHandle qualifiedMethodHandle = methodInst.Method.ToQualifiedMethodHandle(_metadataReader);
-                QualifiedMethod qualifiedMethod = _metadataReader.GetQualifiedMethod(qualifiedMethodHandle);
-                EmitContainingTypeAndMethodName(qualifiedMethod);
-                EmitGenericArguments(methodInst.GenericTypeArguments);
-                EmitMethodParameters(qualifiedMethod.Method);
-            }
-        }
-
-        private void EmitMethodDefinitionName(QualifiedMethodHandle qualifiedMethodHandle)
-        {
-            QualifiedMethod qualifiedMethod = _metadataReader.GetQualifiedMethod(qualifiedMethodHandle);
-            EmitContainingTypeAndMethodName(qualifiedMethod);
-            EmitMethodParameters(qualifiedMethod.Method);
-        }
-
-        /// <summary>
-        /// Emit containing type and method name and extract the method signature from a method reference.
-        /// </summary>
-        /// <param name="methodRef">Method reference to format</param>
-        /// <param name="methodSignature">Output method signature</param>
-        private void EmitContainingTypeAndMethodName(MemberReference methodRef, out MethodSignature methodSignature)
-        {
-            methodSignature = _metadataReader.GetMethodSignature(methodRef.Signature.ToMethodSignatureHandle(_metadataReader));
-            EmitTypeName(methodRef.Parent, namespaceQualified: true);
-            _outputBuilder.Append('.');
-            EmitString(methodRef.Name);
-        }
-
-        private void EmitContainingTypeAndMethodName(QualifiedMethod qualifiedMethod)
-        {
-            Method method = _metadataReader.GetMethod(qualifiedMethod.Method);
-            EmitTypeName(qualifiedMethod.EnclosingType, namespaceQualified: true);
-            _outputBuilder.Append('.');
-            EmitString(method.Name);
-        }
-
         /// <summary>
         /// Emit parenthesized method argument type list.
         /// </summary>
@@ -308,6 +243,11 @@ private void EmitTypeName(Handle typeHandle, bool namespaceQualified)
                     EmitFunctionPointerTypeName();
                     break;
 
+                // This is not an actual type, but we don't always bother representing generic arguments on generic methods as types
+                case HandleType.ConstantStringValue:
+                    EmitString(typeHandle.ToConstantStringValueHandle(_metadataReader));
+                    break;
+
                 default:
                     Debug.Assert(false, $"Type handle {typeHandle.HandleType} was not handled");
                     _outputBuilder.Append("???");
@@ -588,35 +528,12 @@ private static object GetTypeContext(MetadataReader metadataReader, Handle handl
                 }
             }
 
-            public static SigTypeContext FromMethod(MetadataReader metadataReader, Handle methodHandle)
+            public static SigTypeContext FromMethod(MetadataReader metadataReader, Handle enclosingTypeHandle, ConstantStringArrayHandle methodInst)
             {
-                object typeContext;
-                object methodContext;
-
-                switch (methodHandle.HandleType)
-                {
-                    case HandleType.MemberReference:
-                        typeContext = GetTypeContext(metadataReader, methodHandle);
-                        methodContext = default(HandleCollection);
-                        break;
-
-                    case HandleType.MethodInstantiation:
-                        MethodInstantiation methodInst = methodHandle.ToMethodInstantiationHandle(metadataReader).GetMethodInstantiation(metadataReader);
-                        typeContext = GetTypeContext(metadataReader, methodInst.Method);
-                        methodContext = methodInst.GenericTypeArguments;
-                        break;
-
-                    case HandleType.QualifiedMethod:
-                        QualifiedMethod qualifiedMethod = methodHandle.ToQualifiedMethodHandle(metadataReader).GetQualifiedMethod(metadataReader);
-                        typeContext = GetTypeContext(metadataReader, qualifiedMethod.EnclosingType);
-                        methodContext = qualifiedMethod.Method.GetMethod(metadataReader).GenericParameters;
-                        break;
-                    default:
-                        Debug.Assert(false);
-                        return default(SigTypeContext);
-                }
-
-                return new SigTypeContext(typeContext, methodContext);
+                object methodContext = null;
+                if (!methodInst.IsNull(metadataReader))
+                    methodContext = methodInst.GetConstantStringArray(metadataReader).Value;
+                return new SigTypeContext(GetTypeContext(metadataReader, enclosingTypeHandle), methodContext);
             }
 
             public static SigTypeContext FromMethod(MetadataReader metadataReader, TypeDefinitionHandle enclosingTypeHandle, MethodHandle methodHandle)

src/coreclr/nativeaot/System.Private.StackTraceMetadata/src/Internal/StackTraceMetadata/StackTraceMetadata.cs

@@ -5,12 +5,14 @@
 using System.Collections.Generic;
 
 using Internal.Metadata.NativeFormat;
+using Internal.NativeFormat;
 using Internal.Runtime;
 using Internal.Runtime.Augments;
 using Internal.Runtime.TypeLoader;
 using Internal.TypeSystem;
 
 using ReflectionExecution = Internal.Reflection.Execution.ReflectionExecution;
+using Debug = System.Diagnostics.Debug;
 
 namespace Internal.StackTraceMetadata
 {
@@ -144,7 +146,7 @@ private sealed class PerModuleMethodNameResolver
             /// <summary>
             /// Dictionary mapping method RVA's to tokens within the metadata blob.
             /// </summary>
-            private readonly Dictionary<int, int> _methodRvaToTokenMap;
+            private readonly StackTraceData[] _stacktraceDatas;
 
             /// <summary>
             /// Metadata reader for the stack trace metadata.
@@ -195,10 +197,10 @@ public unsafe PerModuleMethodNameResolver(IntPtr moduleAddress)
                 {
                     _metadataReader = new MetadataReader(new IntPtr(metadataBlob), (int)metadataBlobSize);
 
-                    // RVA to token map consists of pairs of integers (method RVA - token)
-                    int rvaToTokenMapEntryCount = (int)(rvaToTokenMapBlobSize / (2 * sizeof(int)));
-                    _methodRvaToTokenMap = new Dictionary<int, int>(rvaToTokenMapEntryCount);
-                    PopulateRvaToTokenMap(handle, (int *)rvaToTokenMapBlob, rvaToTokenMapEntryCount);
+                    int entryCount = *(int*)rvaToTokenMapBlob;
+                    _stacktraceDatas = new StackTraceData[entryCount];
+
+                    PopulateRvaToTokenMap(handle, rvaToTokenMapBlob + sizeof(int), rvaToTokenMapBlobSize - sizeof(int));
                 }
             }
 
@@ -207,39 +209,99 @@ public unsafe PerModuleMethodNameResolver(IntPtr moduleAddress)
             /// within a single binary module.
             /// </summary>
             /// <param name="handle">Module to use to construct the mapping</param>
-            /// <param name="rvaToTokenMap">List of RVA - token pairs</param>
-            /// <param name="entryCount">Number of the RVA - token pairs in the list</param>
-            private unsafe void PopulateRvaToTokenMap(TypeManagerHandle handle, int *rvaToTokenMap, int entryCount)
+            /// <param name="pMap">List of RVA - token pairs</param>
+            /// <param name="length">Length of the blob</param>
+            private unsafe void PopulateRvaToTokenMap(TypeManagerHandle handle, byte* pMap, uint length)
             {
-                for (int entryIndex = 0; entryIndex < entryCount; entryIndex++)
+                Handle currentOwningType = default;
+                MethodSignatureHandle currentSignature = default;
+                ConstantStringValueHandle currentName = default;
+                ConstantStringArrayHandle currentMethodInst = default;
+
+                int current = 0;
+                byte* pCurrent = pMap;
+                while (pCurrent < pMap + length)
                 {
-                    int* pRelPtr32 = &rvaToTokenMap[2 * entryIndex + 0];
-                    byte* pointer = (byte*)pRelPtr32 + *pRelPtr32;
-                    int methodRva = (int)(pointer - (byte*)handle.OsModuleBase);
-                    int token = rvaToTokenMap[2 * entryIndex + 1];
-                    _methodRvaToTokenMap[methodRva] = token;
+                    byte command = *pCurrent++;
+
+                    if ((command & StackTraceDataCommand.UpdateOwningType) != 0)
+                    {
+                        currentOwningType = Handle.FromIntToken((int)NativePrimitiveDecoder.ReadUInt32(ref pCurrent));
+                        Debug.Assert(currentOwningType.HandleType is HandleType.TypeDefinition or HandleType.TypeReference or HandleType.TypeSpecification);
+                    }
+
+                    if ((command & StackTraceDataCommand.UpdateName) != 0)
+                    {
+                        currentName = new Handle(HandleType.ConstantStringValue, (int)NativePrimitiveDecoder.DecodeUnsigned(ref pCurrent)).ToConstantStringValueHandle(_metadataReader);
+                    }
+
+                    if ((command & StackTraceDataCommand.UpdateSignature) != 0)
+                    {
+                        currentSignature = new Handle(HandleType.MethodSignature, (int)NativePrimitiveDecoder.DecodeUnsigned(ref pCurrent)).ToMethodSignatureHandle(_metadataReader);
+                        currentMethodInst = default;
+                    }
+
+                    if ((command & StackTraceDataCommand.UpdateGenericSignature) != 0)
+                    {
+                        currentSignature = new Handle(HandleType.MethodSignature, (int)NativePrimitiveDecoder.DecodeUnsigned(ref pCurrent)).ToMethodSignatureHandle(_metadataReader);
+                        currentMethodInst = new Handle(HandleType.ConstantStringArray, (int)NativePrimitiveDecoder.DecodeUnsigned(ref pCurrent)).ToConstantStringArrayHandle(_metadataReader);
+                    }
+
+                    void* pMethod = ReadRelPtr32(pCurrent);
+                    pCurrent += sizeof(int);
+
+                    Debug.Assert((nint)pMethod > handle.OsModuleBase);
+                    int methodRva = (int)((nint)pMethod - handle.OsModuleBase);
+
+                    _stacktraceDatas[current++] = new StackTraceData
+                    {
+                        Rva = methodRva,
+                        OwningType = currentOwningType,
+                        Name = currentName,
+                        Signature = currentSignature,
+                        GenericArguments = currentMethodInst,
+                    };
+
+                    static void* ReadRelPtr32(byte* address)
+                        => address + *(int*)address;
                 }
+
+                Debug.Assert(current == _stacktraceDatas.Length);
+
+                Array.Sort(_stacktraceDatas);
             }
 
             /// <summary>
             /// Try to resolve method name based on its address using the stack trace metadata
             /// </summary>
             public string GetMethodNameFromRvaIfAvailable(int rva)
             {
-                if (_methodRvaToTokenMap == null)
+                if (_stacktraceDatas == null)
                 {
                     // No stack trace metadata for this module
                     return null;
                 }
 
-                int rawToken;
-                if (!_methodRvaToTokenMap.TryGetValue(rva, out rawToken))
+                int index = Array.BinarySearch(_stacktraceDatas, new StackTraceData() { Rva = rva });
+                if (index < 0)
                 {
                     // Method RVA not found in the map
                     return null;
                 }
 
-                return MethodNameFormatter.FormatMethodName(_metadataReader, Handle.FromIntToken(rawToken));
+                StackTraceData data = _stacktraceDatas[index];
+                return MethodNameFormatter.FormatMethodName(_metadataReader, data.OwningType, data.Name, data.Signature, data.GenericArguments);
+            }
+
+            private struct StackTraceData : IComparable<StackTraceData>
+            {
+                public int Rva { get; init; }
+                public Handle OwningType { get; init; }
+                public ConstantStringValueHandle Name { get; init; }
+                public MethodSignatureHandle Signature { get; init; }
+                public ConstantStringArrayHandle GenericArguments { get; init; }
+
+                public int CompareTo(StackTraceData other) => Rva.CompareTo(other.Rva);
             }
         }
     }

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

@@ -18,8 +18,14 @@
     <Compile Include="Internal\Runtime\CompilerHelpers\LibraryInitializer.cs" />
     <Compile Include="Internal\StackTraceMetadata\StackTraceMetadata.cs" />
     <Compile Include="Internal\StackTraceMetadata\MethodNameFormatter.cs" />
+    <Compile Include="$(CompilerCommonPath)\Internal\NativeFormat\NativeFormatReader.Primitives.cs">
+      <Link>Internal\NativeFormat\NativeFormatReader.Primitives.cs</Link>
+    </Compile>
     <Compile Include="$(CompilerCommonPath)\Internal\Runtime\MetadataBlob.cs">
       <Link>Internal\Runtime\MetadataBlob.cs</Link>
     </Compile>
+    <Compile Include="$(CompilerCommonPath)\Internal\Runtime\StackTraceData.cs">
+      <Link>Internal\Runtime\StackTraceData.cs</Link>
+    </Compile>
   </ItemGroup>
 </Project>

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

@@ -0,0 +1,13 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Internal.Runtime
+{
+    internal static class StackTraceDataCommand
+    {
+        public const byte UpdateOwningType = 0x01;
+        public const byte UpdateName = 0x02;
+        public const byte UpdateSignature = 0x04;
+        public const byte UpdateGenericSignature = 0x08; // Just a shortcut - sig metadata has the info
+    }
+}

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/AnalysisBasedMetadataManager.cs

@@ -136,7 +136,7 @@ protected override void ComputeMetadata(NodeFactory factory,
             out List<MetadataMapping<MetadataType>> typeMappings,
             out List<MetadataMapping<MethodDesc>> methodMappings,
             out List<MetadataMapping<FieldDesc>> fieldMappings,
-            out List<MetadataMapping<MethodDesc>> stackTraceMapping)
+            out List<StackTraceMapping> stackTraceMapping)
         {
             ComputeMetadata(new Policy(_blockingPolicy, this), factory,
                 out metadataBlob,