[main] Source code updates from dotnet/runtime (#504)

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>

Author: dotnet-maestro[bot]

prereqs/git-info/runtime.props

@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project>
   <PropertyGroup>
-    <GitCommitHash>e67e997094b65c8ed7289b00f2304288d8f75a12</GitCommitHash>
-    <OfficialBuildId>20250509.6</OfficialBuildId>
-    <OutputPackageVersion>10.0.0-preview.5.25259.6</OutputPackageVersion>
+    <GitCommitHash>8b80947425177e7b500e13ec66d1b9936a67e5a5</GitCommitHash>
+    <OfficialBuildId>20250511.2</OfficialBuildId>
+    <OutputPackageVersion>10.0.0-preview.5.25261.2</OutputPackageVersion>
   </PropertyGroup>
 </Project>

src/runtime/docs/design/coreclr/botr/clr-abi.md

@@ -376,15 +376,17 @@ When an exception occurs, the VM is invoked to do some processing. If the except
 
 The VM sets the frame register to be the same as the parent function. This allows the funclets to access local variables using frame-relative addresses.
 
-For filter funclets and on CoreCLR/AMD64 for all funclets, all other register values that existed at the exception point in the corresponding "try" region are trashed on entry to the funclet. That is, the only registers that have known values are those of the funclet parameters and the frame register.
+For filter funclets, all other register values that existed at the exception point in the corresponding "try" region are trashed on entry to the funclet. That is, the only registers that have known values are those of the funclet parameters and the frame register.
 
-For other funclets on all platforms except CoreCLR/AMD64, all non-volatile registers are restored to their values at the exception point. The JIT codegen [does not take advantage of it currently](https://github.com/dotnet/runtime/pull/114630#issuecomment-2810210759).
+For other funclets, all non-volatile registers are restored to their values at the exception point. The JIT codegen [does not take advantage of it currently](https://github.com/dotnet/runtime/pull/114630#issuecomment-2810210759).
 
 ### Registers on return from a funclet
 
 When a funclet finishes execution, and the VM returns execution to the function (or an enclosing funclet, if there is EH clause nesting), the non-volatile registers are restored to the values they held at the exception point. Note that the volatile registers have been trashed.
 
-Any register value changes made in the funclet are lost. If a funclet wants to make a variable change known to the main function (or the funclet that contains the "try" region), that variable change needs to be made to the shared main function stack frame.
+Any register value changes made in the funclet are lost. If a funclet wants to make a variable change known to the main function (or the funclet that contains the "try" region), that variable change needs to be made to the shared main function stack frame. This not a fundamental limitation. If necessary, the runtime can be updated to preserve non-volatile register changes made in funclets.
+
+Funclets are not required to preserve non-volatile registers.
 
 ## Windows/x86 EH considerations
 

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

@@ -254,7 +254,8 @@
     <Compile Include="src\System\RuntimeType.GenericCache.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(FeatureComWrappers)' == 'true'">
-    <Compile Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComWrappers.cs" />
+    <Compile Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComWrappers.CoreCLR.cs" />
+    <Compile Include="$(BclSourcesRoot)\System\Runtime\InteropServices\TrackerObjectManager.CoreCLR.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(FeatureCominterop)' == 'true'">
     <Compile Include="$(CommonPath)System\Runtime\InteropServices\IDispatch.cs">

src/runtime/src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs

@@ -10,46 +10,56 @@ namespace System
     internal sealed partial class ComAwareWeakReference
     {
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWeakRefToObject")]
-        private static partial void ComWeakRefToObject(IntPtr pComWeakRef, long wrapperId, ObjectHandleOnStack retRcw);
+        private static partial void ComWeakRefToObject(IntPtr pComWeakRef, ObjectHandleOnStack retRcw);
 
-        internal static object? ComWeakRefToObject(IntPtr pComWeakRef, long wrapperId)
+        internal static object? ComWeakRefToObject(IntPtr pComWeakRef, object? context)
         {
-            object? retRcw = null;
-            ComWeakRefToObject(pComWeakRef, wrapperId, ObjectHandleOnStack.Create(ref retRcw));
-            return retRcw;
+#if FEATURE_COMINTEROP
+            if (context is null)
+            {
+                // This wrapper was not created by ComWrappers, so we try to rehydrate using built-in COM.
+                object? retRcw = null;
+                ComWeakRefToObject(pComWeakRef, ObjectHandleOnStack.Create(ref retRcw));
+                return retRcw;
+            }
+#endif // FEATURE_COMINTEROP
+
+            return ComWeakRefToComWrappersObject(pComWeakRef, context);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static unsafe bool PossiblyComObject(object target)
         {
-            // see: syncblk.h
-            const int IS_HASHCODE_BIT_NUMBER = 26;
-            const int BIT_SBLK_IS_HASHCODE = 1 << IS_HASHCODE_BIT_NUMBER;
-            const int BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX = 0x08000000;
-
-            fixed (byte* pRawData = &target.GetRawData())
-            {
-                // The header is 4 bytes before MT field on all architectures
-                int header = *(int*)(pRawData - sizeof(IntPtr) - sizeof(int));
-                // common case: target does not have a syncblock, so there is no interop info
-                return (header & (BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX | BIT_SBLK_IS_HASHCODE)) == BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX;
-            }
+#if FEATURE_COMINTEROP
+            return target is __ComObject || PossiblyComWrappersObject(target);
+#else // !FEATURE_COMINTEROP
+            // If we are not using built-in COM, then we can only be a ComWrappers object.
+            return PossiblyComWrappersObject(target);
+#endif // FEATURE_COMINTEROP
         }
 
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal static extern bool HasInteropInfo(object target);
-
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectToComWeakRef")]
-        private static partial IntPtr ObjectToComWeakRef(ObjectHandleOnStack retRcw, out long wrapperId);
+        private static partial IntPtr ObjectToComWeakRef(ObjectHandleOnStack retRcw);
 
-        internal static nint ObjectToComWeakRef(object target, out long wrapperId)
+        internal static nint ObjectToComWeakRef(object target, out object? context)
         {
-            if (HasInteropInfo(target))
+#if FEATURE_COMINTEROP
+            if (target is __ComObject)
+            {
+                // This object is using built-in COM, so use built-in COM to create the weak reference.
+                context = null;
+                return ObjectToComWeakRef(ObjectHandleOnStack.Create(ref target));
+            }
+#endif // FEATURE_COMINTEROP
+
+            if (PossiblyComWrappersObject(target))
             {
-                return ObjectToComWeakRef(ObjectHandleOnStack.Create(ref target), out wrapperId);
+                return ComWrappersObjectToComWeakRef(target, out context);
             }
 
-            wrapperId = 0;
+            // This object is not produced using built-in COM or ComWrappers
+            // or is an aggregated object, so we cannot create a weak reference.
+            context = null;
             return IntPtr.Zero;
         }
     }

src/runtime/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs

@@ -65,16 +65,6 @@ static void NotifyOfCrossThreadDependencySlow()
         [SuppressGCTransition]
         private static partial int IsManagedDebuggerAttached();
 
-        // Constants representing the importance level of messages to be logged.
-        //
-        // An attached debugger can enable or disable which messages will
-        // actually be reported to the user through the debugger
-        // services API.  This info is communicated to the runtime so only
-        // desired events are actually reported to the debugger.
-        //
-        // Constant representing the default category
-        public static readonly string? DefaultCategory;
-
         // Posts a message for the attached debugger.  If there is no
         // debugger attached, has no effect.  The debugger may or may not
         // report the message depending on its settings.

src/runtime/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs

@@ -106,7 +106,7 @@ internal enum GC_ALLOC_FLAGS
         private static partial long GetTotalMemory();
 
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_Collect")]
-        private static partial void _Collect(int generation, int mode);
+        private static partial void _Collect(int generation, int mode, [MarshalAs(UnmanagedType.U1)] bool lowMemoryPressure);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern int GetMaxGeneration();
@@ -174,7 +174,7 @@ public static void Collect(int generation)
         public static void Collect()
         {
             // -1 says to GC all generations.
-            _Collect(-1, (int)InternalGCCollectionMode.Blocking);
+            _Collect(-1, (int)InternalGCCollectionMode.Blocking, lowMemoryPressure: false);
         }
 
         public static void Collect(int generation, GCCollectionMode mode)
@@ -189,6 +189,11 @@ public static void Collect(int generation, GCCollectionMode mode, bool blocking)
         }
 
         public static void Collect(int generation, GCCollectionMode mode, bool blocking, bool compacting)
+        {
+            Collect(generation, mode, blocking, compacting, lowMemoryPressure: false);
+        }
+
+        internal static void Collect(int generation, GCCollectionMode mode, bool blocking, bool compacting, bool lowMemoryPressure)
         {
             ArgumentOutOfRangeException.ThrowIfNegative(generation);
 
@@ -197,7 +202,6 @@ public static void Collect(int generation, GCCollectionMode mode, bool blocking,
                 throw new ArgumentOutOfRangeException(nameof(mode), SR.ArgumentOutOfRange_Enum);
             }
 
-
             int iInternalModes = 0;
 
             if (mode == GCCollectionMode.Optimized)
@@ -222,7 +226,9 @@ public static void Collect(int generation, GCCollectionMode mode, bool blocking,
             }
 
             if (compacting)
+            {
                 iInternalModes |= (int)InternalGCCollectionMode.Compacting;
+            }
 
             if (blocking)
             {
@@ -233,7 +239,7 @@ public static void Collect(int generation, GCCollectionMode mode, bool blocking,
                 iInternalModes |= (int)InternalGCCollectionMode.NonBlocking;
             }
 
-            _Collect(generation, iInternalModes);
+            _Collect(generation, (int)iInternalModes, lowMemoryPressure);
         }
 
         public static int CollectionCount(int generation)

src/runtime/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs

@@ -0,0 +1,119 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Threading;
+using System.Runtime.CompilerServices;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+
+namespace System.Runtime.InteropServices
+{
+    /// <summary>
+    /// Class for managing wrappers of COM IUnknown types.
+    /// </summary>
+    public abstract partial class ComWrappers
+    {
+        /// <summary>
+        /// Get the runtime provided IUnknown implementation.
+        /// </summary>
+        /// <param name="fpQueryInterface">Function pointer to QueryInterface.</param>
+        /// <param name="fpAddRef">Function pointer to AddRef.</param>
+        /// <param name="fpRelease">Function pointer to Release.</param>
+        public static unsafe void GetIUnknownImpl(out IntPtr fpQueryInterface, out IntPtr fpAddRef, out IntPtr fpRelease)
+            => GetIUnknownImplInternal(out fpQueryInterface, out fpAddRef, out fpRelease);
+
+        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWrappers_GetIUnknownImpl")]
+        [SuppressGCTransition]
+        private static partial void GetIUnknownImplInternal(out IntPtr fpQueryInterface, out IntPtr fpAddRef, out IntPtr fpRelease);
+
+        internal static IntPtr DefaultIUnknownVftblPtr { get; } = CreateDefaultIUnknownVftbl();
+        internal static IntPtr TaggedImplVftblPtr { get; } = CreateTaggedImplVftbl();
+        internal static IntPtr DefaultIReferenceTrackerTargetVftblPtr { get; } = CreateDefaultIReferenceTrackerTargetVftbl();
+
+        private static unsafe IntPtr CreateDefaultIUnknownVftbl()
+        {
+            IntPtr* vftbl = (IntPtr*)RuntimeHelpers.AllocateTypeAssociatedMemory(typeof(ComWrappers), 3 * sizeof(IntPtr));
+            GetIUnknownImpl(out vftbl[0], out vftbl[1], out vftbl[2]);
+            return (IntPtr)vftbl;
+        }
+
+        private static unsafe IntPtr CreateTaggedImplVftbl()
+        {
+            IntPtr* vftbl = (IntPtr*)RuntimeHelpers.AllocateTypeAssociatedMemory(typeof(ComWrappers), 4 * sizeof(IntPtr));
+            GetIUnknownImpl(out vftbl[0], out vftbl[1], out vftbl[2]);
+            vftbl[3] = GetTaggedImplCurrentVersion();
+            return (IntPtr)vftbl;
+        }
+
+        internal static int CallICustomQueryInterface(ManagedObjectWrapperHolder holder, ref Guid iid, out IntPtr ppObject)
+        {
+            if (holder.WrappedObject is ICustomQueryInterface customQueryInterface)
+            {
+                return (int)customQueryInterface.GetInterface(ref iid, out ppObject);
+            }
+
+            ppObject = IntPtr.Zero;
+            return -1; // See TryInvokeICustomQueryInterfaceResult
+        }
+
+        internal static IntPtr GetOrCreateComInterfaceForObjectWithGlobalMarshallingInstance(object obj)
+        {
+            try
+            {
+                return s_globalInstanceForMarshalling is null
+                    ? IntPtr.Zero
+                    : s_globalInstanceForMarshalling.GetOrCreateComInterfaceForObject(obj, CreateComInterfaceFlags.TrackerSupport);
+            }
+            catch (ArgumentException)
+            {
+                // We've failed to create a COM interface for the object.
+                // Fallback to built-in COM.
+                return IntPtr.Zero;
+            }
+        }
+
+        internal static object? GetOrCreateObjectForComInstanceWithGlobalMarshallingInstance(IntPtr comObject, CreateObjectFlags flags)
+        {
+            try
+            {
+                return s_globalInstanceForMarshalling?.GetOrCreateObjectForComInstance(comObject, flags);
+            }
+            catch (ArgumentNullException)
+            {
+                // We've failed to create a managed object for the COM instance.
+                // Fallback to built-in COM.
+                return null;
+            }
+        }
+
+        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWrappers_GetIReferenceTrackerTargetVftbl")]
+        [SuppressGCTransition]
+        private static partial IntPtr GetDefaultIReferenceTrackerTargetVftbl();
+
+        private static IntPtr CreateDefaultIReferenceTrackerTargetVftbl()
+            => GetDefaultIReferenceTrackerTargetVftbl();
+
+        private static IntPtr GetTaggedImplCurrentVersion()
+        {
+            return GetTaggedImpl();
+        }
+
+        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWrappers_GetTaggedImpl")]
+        [SuppressGCTransition]
+        private static partial IntPtr GetTaggedImpl();
+
+        internal sealed partial class ManagedObjectWrapperHolder
+        {
+            [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWrappers_RegisterIsRootedCallback")]
+            private static partial void RegisterIsRootedCallback();
+
+            private static IntPtr AllocateRefCountedHandle(ManagedObjectWrapperHolder holder)
+            {
+                return AllocateRefCountedHandle(ObjectHandleOnStack.Create(ref holder));
+            }
+
+            [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWrappers_AllocateRefCountedHandle")]
+            private static partial IntPtr AllocateRefCountedHandle(ObjectHandleOnStack obj);
+        }
+    }
+}