[release/10.0.1xx] Source code updates from dotnet/runtime (#2155)

dotnet-maestro[bot] · web-flow · commit 7ac1ca67bb1f · 2025-08-27T10:21:00.000Z
[release/10.0.1xx] Source code updates from dotnet/runtime
diff --git a/src/runtime/src/coreclr/jit/hwintrinsiclistarm64.h b/src/runtime/src/coreclr/jit/hwintrinsiclistarm64.h
diff --git a/src/runtime/src/coreclr/jit/hwintrinsiclistxarch.h b/src/runtime/src/coreclr/jit/hwintrinsiclistxarch.h
diff --git a/src/runtime/src/coreclr/jit/importercalls.cpp b/src/runtime/src/coreclr/jit/importercalls.cpp
@@ -10762,6 +10762,10 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method)
                                     lookupMethodName = nullptr;
                                 }
                             }
+                            else if (strcmp(methodName, "SquareRoot") == 0)
+                            {
+                                lookupMethodName = "Sqrt";
+                            }
 
                             if (lookupMethodName != nullptr)
                             {
diff --git a/src/runtime/src/coreclr/nativeaot/Bootstrap/main.cpp b/src/runtime/src/coreclr/nativeaot/Bootstrap/main.cpp
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 #include <stdint.h>
+#include <stddef.h>
 
 #if defined(DEBUG) && defined(_WIN32)
 #include <process.h>
@@ -138,10 +139,16 @@ MANAGED_RUNTIME_EXPORT(ObjectiveCMarshalGetUnhandledExceptionPropagationHandler)
 
 typedef void (MANAGED_RUNTIME_EXPORT_CALLCONV *pfn)();
 
+#if defined(_WIN32)
+extern "C" int ThreadEntryPoint(void* pContext);
+#else
+extern "C" size_t ThreadEntryPoint(void* pContext);
+#endif
+
 static const pfn c_classlibFunctions[] = {
     &MANAGED_RUNTIME_EXPORT_NAME(GetRuntimeException),
     &MANAGED_RUNTIME_EXPORT_NAME(RuntimeFailFast),
-    nullptr, // &UnhandledExceptionHandler,
+    (pfn)&ThreadEntryPoint,
     &MANAGED_RUNTIME_EXPORT_NAME(AppendExceptionStackFrame),
     nullptr, // &CheckStaticClassConstruction,
     &MANAGED_RUNTIME_EXPORT_NAME(GetSystemArrayEEType),
diff --git a/src/runtime/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/InternalCalls.cs b/src/runtime/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/InternalCalls.cs
@@ -38,7 +38,7 @@ internal enum ClassLibFunctionId
     {
         GetRuntimeException = 0,
         FailFast = 1,
-        // UnhandledExceptionHandler = 2, // unused
+        ThreadEntryPoint = 2,
         AppendExceptionStackFrame = 3,
         // unused = 4,
         GetSystemArrayEEType = 5,
diff --git a/src/runtime/src/coreclr/nativeaot/Runtime/ICodeManager.h b/src/runtime/src/coreclr/nativeaot/Runtime/ICodeManager.h
@@ -99,7 +99,7 @@ enum class ClasslibFunctionId
 {
     GetRuntimeException = 0,
     FailFast = 1,
-    UnhandledExceptionHandler = 2,
+    ThreadEntryPoint = 2,
     AppendExceptionStackFrame = 3,
     // unused = 4,
     GetSystemArrayEEType = 5,
diff --git a/src/runtime/src/coreclr/nativeaot/Runtime/thread.cpp b/src/runtime/src/coreclr/nativeaot/Runtime/thread.cpp
@@ -4,6 +4,7 @@
 #include "common.h"
 #include "gcenv.h"
 #include "gcheaputilities.h"
+#include "gchandleutilities.h"
 
 #include "CommonTypes.h"
 #include "CommonMacros.h"
@@ -1278,6 +1279,49 @@ FCIMPL0(Object**, RhGetThreadStaticStorage)
 }
 FCIMPLEND
 
+#ifdef TARGET_UNIX
+#define NEWTHREAD_RETURN_TYPE size_t
+#else
+#define NEWTHREAD_RETURN_TYPE uint32_t
+#endif
+
+static NEWTHREAD_RETURN_TYPE RhThreadEntryPoint(void* pContext)
+{
+    // We will attach the thread early so that when the managed thread entrypoint
+    // starts running and performs its reverse p/invoke transition, the thread is
+    // already attached.
+    //
+    // This avoids potential deadlocks with module initializers that may be running
+    // as part of runtime initialization (in non-EXE scenario) and creating new
+    // threads. When RhThreadEntryPoint runs, the runtime must already be initialized
+    // enough to be able to run managed code so we don't need to wait for it to
+    // finish.
+
+    ThreadStore::AttachCurrentThread();
+
+    Thread * pThread = ThreadStore::GetCurrentThread();
+    pThread->SetDeferredTransitionFrameForNativeHelperThread();
+    pThread->DisablePreemptiveMode();
+
+    Object * pThreadObject = ObjectFromHandle((OBJECTHANDLE)pContext);
+    MethodTable* pMT = pThreadObject->GetMethodTable();
+
+    pThread->EnablePreemptiveMode();
+
+    NEWTHREAD_RETURN_TYPE (*pFn)(void*) = (NEWTHREAD_RETURN_TYPE (*)(void*))
+        pMT->GetTypeManagerPtr()
+        ->AsTypeManager()
+        ->GetClasslibFunction(ClasslibFunctionId::ThreadEntryPoint);
+
+    return pFn(pContext);
+}
+
+FCIMPL0(void*, RhGetThreadEntryPointAddress)
+{
+    return (void*)&RhThreadEntryPoint;
+}
+FCIMPLEND
+
 InlinedThreadStaticRoot* Thread::GetInlinedThreadStaticList()
 {
     return m_pInlinedThreadLocalStatics;
diff --git a/src/runtime/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.NativeAot.cs b/src/runtime/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.NativeAot.cs
@@ -27,18 +27,6 @@ public static void InitializeArray(Array array, RuntimeFieldHandle fldHandle)
             throw new PlatformNotSupportedException();
         }
 
-        private static unsafe ref byte GetSpanDataFrom(
-            RuntimeFieldHandle fldHandle,
-            RuntimeTypeHandle targetTypeHandle,
-            out int count)
-        {
-            // We only support this intrinsic when it occurs within a well-defined IL sequence.
-            // If a call to this method occurs within the recognized sequence, codegen must expand the IL sequence completely.
-            // For any other purpose, the API is currently unsupported.
-            // https://github.com/dotnet/corert/issues/364
-            throw new PlatformNotSupportedException();
-        }
-
         [RequiresUnreferencedCode("Trimmer can't guarantee existence of class constructor")]
         public static void RunClassConstructor(RuntimeTypeHandle type)
         {
diff --git a/src/runtime/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/RuntimeImports.cs b/src/runtime/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/RuntimeImports.cs
@@ -26,6 +26,14 @@ internal static partial class RuntimeImports
     {
         internal const string RuntimeLibrary = "*";
 
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        [RuntimeImport(RuntimeLibrary, "RhGetThreadEntryPointAddress")]
+#if TARGET_UNIX
+        internal static extern unsafe delegate* unmanaged<nint, nint> RhGetThreadEntryPointAddress();
+#else
+        internal static extern unsafe delegate* unmanaged<nint, uint> RhGetThreadEntryPointAddress();
+#endif
+
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         [RuntimeImport(RuntimeLibrary, "RhGetCrashInfoBuffer")]
         internal static extern unsafe byte* RhGetCrashInfoBuffer(out int cbMaxSize);
diff --git a/src/runtime/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Thread.NativeAot.Unix.cs b/src/runtime/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Thread.NativeAot.Unix.cs
@@ -101,7 +101,7 @@ private unsafe bool CreateThread(GCHandle<Thread> thisThreadHandle)
                 stackSize = RuntimeImports.RhGetDefaultStackSize();
             }
 
-            if (!Interop.Sys.CreateThread(stackSize, &ThreadEntryPoint, GCHandle<Thread>.ToIntPtr(thisThreadHandle)))
+            if (!Interop.Sys.CreateThread(stackSize, RuntimeImports.RhGetThreadEntryPointAddress(), GCHandle<Thread>.ToIntPtr(thisThreadHandle)))
             {
                 return false;
             }
@@ -115,7 +115,7 @@ private unsafe bool CreateThread(GCHandle<Thread> thisThreadHandle)
         /// <summary>
         /// This is an entry point for managed threads created by application
         /// </summary>
-        [UnmanagedCallersOnly]
+        [UnmanagedCallersOnly(EntryPoint = "ThreadEntryPoint")]
         private static IntPtr ThreadEntryPoint(IntPtr parameter)
         {
             StartThread(parameter);
diff --git a/src/runtime/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Thread.NativeAot.Windows.cs b/src/runtime/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Thread.NativeAot.Windows.cs
@@ -200,7 +200,7 @@ private unsafe bool CreateThread(GCHandle<Thread> thisThreadHandle)
             }
 
             _osHandle = Interop.Kernel32.CreateThread(IntPtr.Zero, (IntPtr)stackSize,
-                &ThreadEntryPoint, GCHandle<Thread>.ToIntPtr(thisThreadHandle),
+                RuntimeImports.RhGetThreadEntryPointAddress(), GCHandle<Thread>.ToIntPtr(thisThreadHandle),
                 Interop.Kernel32.CREATE_SUSPENDED | Interop.Kernel32.STACK_SIZE_PARAM_IS_A_RESERVATION,
                 out _);
 
@@ -219,7 +219,7 @@ private unsafe bool CreateThread(GCHandle<Thread> thisThreadHandle)
         /// <summary>
         /// This is an entry point for managed threads created by application
         /// </summary>
-        [UnmanagedCallersOnly]
+        [UnmanagedCallersOnly(EntryPoint = "ThreadEntryPoint")]
         private static uint ThreadEntryPoint(IntPtr parameter)
         {
             StartThread(parameter);
diff --git a/src/runtime/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.cs b/src/runtime/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.cs
@@ -151,7 +151,15 @@ internal static bool CanPrimitiveWiden(CorElementType srcET, CorElementType dstE
         /// <remarks>This method is intended for compiler use rather than use directly in code. T must be one of byte, sbyte, bool, char, short, ushort, int, uint, long, ulong, float, or double.</remarks>
         [Intrinsic]
         public static ReadOnlySpan<T> CreateSpan<T>(RuntimeFieldHandle fldHandle)
+#if NATIVEAOT
+            // We only support this intrinsic when it occurs within a well-defined IL sequence.
+            // If a call to this method occurs within the recognized sequence, codegen must expand the IL sequence completely.
+            // For any other purpose, the API is currently unsupported.
+            // We shortcut this here instead of in `GetSpanDataFrom` to avoid `typeof(T)` below marking T target of reflection.
+            => throw new PlatformNotSupportedException();
+#else
             => new ReadOnlySpan<T>(ref Unsafe.As<byte, T>(ref GetSpanDataFrom(fldHandle, typeof(T).TypeHandle, out int length)), length);
+#endif
 
 
         // The following intrinsics return true if input is a compile-time constant
diff --git a/src/runtime/src/mono/browser/runtime/web-socket.ts b/src/runtime/src/mono/browser/runtime/web-socket.ts
@@ -5,7 +5,7 @@ import WasmEnableThreads from "consts:wasmEnableThreads";
 
 import { prevent_timer_throttling } from "./scheduling";
 import { Queue } from "./queue";
-import { ENVIRONMENT_IS_NODE, ENVIRONMENT_IS_SHELL, createPromiseController, loaderHelpers, mono_assert } from "./globals";
+import { ENVIRONMENT_IS_NODE, ENVIRONMENT_IS_SHELL, createPromiseController, loaderHelpers, mono_assert, Module } from "./globals";
 import { setI32, localHeapViewU8, forceThreadMemoryViewRefresh } from "./memory";
 import { VoidPtr } from "./types/emscripten";
 import { PromiseController } from "./types/internal";
@@ -51,7 +51,7 @@ export function ws_get_state (ws: WebSocketExtension): number {
     const queued_events_count = receive_event_queue.getLength();
     if (queued_events_count == 0)
         return ws.readyState ?? -1;
-    return WebSocket.OPEN;
+    return ws[wasm_ws_close_sent] ? WebSocket.CLOSING : WebSocket.OPEN;
 }
 
 export function ws_wasm_create (uri: string, sub_protocols: string[] | null, receive_status_ptr: VoidPtr): WebSocketExtension {
@@ -116,13 +116,15 @@ export function ws_wasm_create (uri: string, sub_protocols: string[] | null, rec
             }
 
             // send close to any pending receivers, to wake them
-            const receive_promise_queue = ws[wasm_ws_pending_receive_promise_queue];
-            receive_promise_queue.drain((receive_promise_control) => {
-                setI32(receive_status_ptr, 0); // count
-                setI32(<any>receive_status_ptr + 4, 2); // type:close
-                setI32(<any>receive_status_ptr + 8, 1);// end_of_message: true
-                receive_promise_control.resolve();
-            });
+            Module.safeSetTimeout(() => {
+                const receive_promise_queue = ws[wasm_ws_pending_receive_promise_queue];
+                receive_promise_queue.drain((receive_promise_control) => {
+                    setI32(receive_status_ptr, 0); // count
+                    setI32(<any>receive_status_ptr + 4, 2); // type:close
+                    setI32(<any>receive_status_ptr + 8, 1);// end_of_message: true
+                    receive_promise_control.resolve();
+                });
+            }, 0);
         } catch (error: any) {
             mono_log_warn("failed to propagate WebSocket close event: " + error.toString());
         }
diff --git a/src/runtime/src/mono/mono/mini/mini-arm64-gsharedvt.c b/src/runtime/src/mono/mono/mini/mini-arm64-gsharedvt.c
@@ -222,6 +222,7 @@ mono_arch_get_gsharedvt_call_info (MonoMemoryManager *mem_manager, gpointer addr
 				arg_marshal = GSHAREDVT_ARG_BYREF_TO_BYREF;
 			else
 				arg_marshal = GSHAREDVT_ARG_BYREF_TO_BYVAL;
+			g_free (dst);
 		} else {
 			nsrc = get_arg_slots (ainfo, &src);
 		}
@@ -404,6 +405,9 @@ mono_arch_get_gsharedvt_call_info (MonoMemoryManager *mem_manager, gpointer addr
 
 	info->stack_usage = ALIGN_TO (info->stack_usage, MONO_ARCH_FRAME_ALIGNMENT);
 
+	g_free (caller_cinfo);
+	g_free (callee_cinfo);
+
 	return info;
 }
 
diff --git a/src/runtime/src/native/libs/System.Security.Cryptography.Native.Android/pal_rsa.c b/src/runtime/src/native/libs/System.Security.Cryptography.Native.Android/pal_rsa.c
@@ -327,14 +327,21 @@ PALEXPORT int32_t AndroidCryptoNative_RsaVerificationPrimitive(int32_t flen, uin
     }
 
     jsize decryptedBytesLen = (*env)->GetArrayLength(env, decryptedBytes);
-    (*env)->GetByteArrayRegion(env, decryptedBytes, 0, decryptedBytesLen, (jbyte*) to);
+    abort_unless(decryptedBytesLen <= flen, "Decrypted bytes length %d exceeds expected length %d", decryptedBytesLen, flen);
+
+    // In some versions of the Android crypto libraries, the leading 0x00 bytes are missing.
+    // Left-pad with 0x00 so EM is always k bytes (k = modulus), as expected by .NET.
+    int32_t leading_zero_padding_length = flen - decryptedBytesLen;
+    memset(to, 0x00, (size_t)leading_zero_padding_length);
+
+    (*env)->GetByteArrayRegion(env, decryptedBytes, 0, decryptedBytesLen, (jbyte*)to + leading_zero_padding_length);
 
     (*env)->DeleteLocalRef(env, cipher);
     (*env)->DeleteLocalRef(env, fromBytes);
     (*env)->DeleteLocalRef(env, decryptedBytes);
     (*env)->DeleteLocalRef(env, algName);
 
-    return (int32_t)decryptedBytesLen;
+    return (int32_t)decryptedBytesLen + leading_zero_padding_length;
 }
 
 PALEXPORT int32_t AndroidCryptoNative_RsaGenerateKeyEx(RSA* rsa, int32_t bits)
diff --git a/src/runtime/src/tests/JIT/Regression/JitBlue/Runtime_119008/Runtime_119008.cs b/src/runtime/src/tests/JIT/Regression/JitBlue/Runtime_119008/Runtime_119008.cs
@@ -0,0 +1,19 @@
+// 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.Numerics;
+using Xunit;
+
+public class Runtime_119008
+{
+    [Fact]
+    public static void TestEntryPoint()
+    {
+        Vector<float> left = Vector.Create(-65f);
+        Vector<float> right = Vector.Create(-1264f);
+
+        Assert.Equal(Vector<int>.Zero, Vector.LessThan(left, right));
+        Assert.Equal(Vector<int>.AllBitsSet, Vector.LessThan(right, left));
+    }
+}
diff --git a/src/runtime/src/tests/JIT/Regression/JitBlue/Runtime_119008/Runtime_119008.csproj b/src/runtime/src/tests/JIT/Regression/JitBlue/Runtime_119008/Runtime_119008.csproj
@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <DebugType>None</DebugType>
+    <Optimize>True</Optimize>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildProjectName).cs" />
+  </ItemGroup>
+</Project>
diff --git a/src/runtime/src/tests/nativeaot/SmokeTests/SharedLibrary/SharedLibrary.cs b/src/runtime/src/tests/nativeaot/SmokeTests/SharedLibrary/SharedLibrary.cs
@@ -4,15 +4,29 @@
 using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Threading;
 
 namespace SharedLibrary
 {
     public class ClassLibrary
     {
+        static Thread s_setterThread;
+        static int s_primitiveInt;
+
+        [ModuleInitializer]
+        public static void CreateThreadInModuleInitializer()
+        {
+            // Regression test for https://github.com/dotnet/runtime/issues/107699
+            // where creating threads in module initializer would lead to a deadlock.
+            s_setterThread = new Thread(() => { s_primitiveInt = 10; });
+            s_setterThread.Start();
+        }
+
         [UnmanagedCallersOnly(EntryPoint = "ReturnsPrimitiveInt", CallConvs = new Type[] { typeof(CallConvStdcall) })]
         public static int ReturnsPrimitiveInt()
         {
-            return 10;
+            s_setterThread.Join();
+            return s_primitiveInt;
         }
 
         [UnmanagedCallersOnly(EntryPoint = "ReturnsPrimitiveBool", CallConvs = new Type[] { typeof(CallConvStdcall) })]
diff --git a/src/source-manifest.json b/src/source-manifest.json
@@ -79,10 +79,10 @@
       "commitSha": "5fc047512d198314d57faf6bc74f41745646888a"
     },
     {
-      "barId": 280774,
+      "barId": 280952,
       "path": "runtime",
       "remoteUri": "https://github.com/dotnet/runtime",
-      "commitSha": "d934b8cab19f53c42e4e5cda98d1816914704764"
+      "commitSha": "4cf369ee051d845236c5dab9b2074490d33242b6"
     },
     {
       "barId": 277711,

Original file line number	Diff line number	Diff line change
`@@ -10762,6 +10762,10 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method)`
`10762`	`10762`	`lookupMethodName = nullptr;`
`10763`	`10763`	`}`
`10764`	`10764`	`}`
	`10765`	`+ else if (strcmp(methodName, "SquareRoot") == 0)`
	`10766`	`+ {`
	`10767`	`+ lookupMethodName = "Sqrt";`
	`10768`	`+ }`
`10765`	`10769`
`10766`	`10770`	`if (lookupMethodName != nullptr)`
`10767`	`10771`	`{`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ internal enum ClassLibFunctionId`
`38`	`38`	`{`
`39`	`39`	`GetRuntimeException = 0,`
`40`	`40`	`FailFast = 1,`
`41`		`- // UnhandledExceptionHandler = 2, // unused`
	`41`	`+ ThreadEntryPoint = 2,`
`42`	`42`	`AppendExceptionStackFrame = 3,`
`43`	`43`	`// unused = 4,`
`44`	`44`	`GetSystemArrayEEType = 5,`
Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ enum class ClasslibFunctionId`
`99`	`99`	`{`
`100`	`100`	`GetRuntimeException = 0,`
`101`	`101`	`FailFast = 1,`
`102`		`- UnhandledExceptionHandler = 2,`
	`102`	`+ ThreadEntryPoint = 2,`
`103`	`103`	`AppendExceptionStackFrame = 3,`
`104`	`104`	`// unused = 4,`
`105`	`105`	`GetSystemArrayEEType = 5,`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ private unsafe bool CreateThread(GCHandle<Thread> thisThreadHandle)`
`101`	`101`	`stackSize = RuntimeImports.RhGetDefaultStackSize();`
`102`	`102`	`}`
`103`	`103`
`104`		`- if (!Interop.Sys.CreateThread(stackSize, &ThreadEntryPoint, GCHandle<Thread>.ToIntPtr(thisThreadHandle)))`
	`104`	`+ if (!Interop.Sys.CreateThread(stackSize, RuntimeImports.RhGetThreadEntryPointAddress(), GCHandle<Thread>.ToIntPtr(thisThreadHandle)))`
`105`	`105`	`{`
`106`	`106`	`return false;`
`107`	`107`	`}`
`@@ -115,7 +115,7 @@ private unsafe bool CreateThread(GCHandle<Thread> thisThreadHandle)`
`115`	`115`	`/// <summary>`
`116`	`116`	`/// This is an entry point for managed threads created by application`
`117`	`117`	`/// </summary>`
`118`		`- [UnmanagedCallersOnly]`
	`118`	`+ [UnmanagedCallersOnly(EntryPoint = "ThreadEntryPoint")]`
`119`	`119`	`private static IntPtr ThreadEntryPoint(IntPtr parameter)`
`120`	`120`	`{`
`121`	`121`	`StartThread(parameter);`