Add GCHandle<T>

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

@@ -673,7 +673,7 @@ private unsafe struct NoGCRegionCallbackFinalizerWorkItem
             public bool scheduled;
             public bool abandoned;
 
-            public GCHandle action;
+            public GCHandle<Action> action;
         }
 
         internal enum EnableNoGCRegionCallbackStatus
@@ -709,7 +709,7 @@ public static unsafe void RegisterNoGCRegionCallback(long totalSize, Action call
             try
             {
                 pWorkItem = (NoGCRegionCallbackFinalizerWorkItem*)NativeMemory.AllocZeroed((nuint)sizeof(NoGCRegionCallbackFinalizerWorkItem));
-                pWorkItem->action = GCHandle.Alloc(callback);
+                pWorkItem->action = new GCHandle<Action>(callback);
                 pWorkItem->callback = &Callback;
 
                 EnableNoGCRegionCallbackStatus status = (EnableNoGCRegionCallbackStatus)_EnableNoGCRegionCallback(pWorkItem, totalSize);
@@ -739,14 +739,13 @@ static void Callback(NoGCRegionCallbackFinalizerWorkItem* pWorkItem)
             {
                 Debug.Assert(pWorkItem->scheduled);
                 if (!pWorkItem->abandoned)
-                    ((Action)(pWorkItem->action.Target!))();
+                    pWorkItem->action.Target();
                 Free(pWorkItem);
             }
 
             static void Free(NoGCRegionCallbackFinalizerWorkItem* pWorkItem)
             {
-                if (pWorkItem->action.IsAllocated)
-                    pWorkItem->action.Free();
+                pWorkItem->action.Dispose();
                 NativeMemory.Free(pWorkItem);
             }
         }

src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/InteropHelpers.cs

@@ -452,7 +452,7 @@ public static IntPtr GetCurrentCalleeOpenStaticDelegateFunctionPointer()
         /// <summary>
         /// Retrieves the current delegate that is being called
         /// </summary>
-        public static T GetCurrentCalleeDelegate<T>() where T : class // constraint can't be System.Delegate
+        public static T GetCurrentCalleeDelegate<T>() where T : Delegate
         {
             return PInvokeMarshal.GetCurrentCalleeDelegate<T>();
         }

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

@@ -213,7 +213,6 @@
     <Compile Include="System\Runtime\InteropServices\MemoryMarshal.NativeAot.cs" />
     <Compile Include="System\Runtime\InteropServices\TrackerObjectManager.NativeAot.cs" Condition="'$(FeatureComWrappers)' == 'true'" />
     <Compile Include="System\Runtime\InteropServices\ObjectiveCMarshal.NativeAot.cs" Condition="'$(FeatureObjCMarshal)' == 'true'" />
-    <Compile Include="System\Runtime\InteropServices\UnsafeGCHandle.cs" />
     <Compile Include="System\Runtime\Intrinsics\X86\X86Base.NativeAot.cs" Condition="'$(SupportsX86Intrinsics)' == 'true'" />
     <Compile Include="System\Runtime\JitInfo.NativeAot.cs" />
     <Compile Include="System\Runtime\Loader\AssemblyLoadContext.NativeAot.cs" />

src/coreclr/nativeaot/System.Private.CoreLib/src/System/GC.NativeAot.cs

@@ -305,7 +305,7 @@ private unsafe struct NoGCRegionCallbackFinalizerWorkItem
             public bool scheduled;
             public bool abandoned;
 
-            public GCHandle action;
+            public GCHandle<Action> action;
         }
 
         public static unsafe void RegisterNoGCRegionCallback(long totalSize, Action callback)
@@ -317,7 +317,7 @@ public static unsafe void RegisterNoGCRegionCallback(long totalSize, Action call
             try
             {
                 pWorkItem = (NoGCRegionCallbackFinalizerWorkItem*)NativeMemory.AllocZeroed((nuint)sizeof(NoGCRegionCallbackFinalizerWorkItem));
-                pWorkItem->action = GCHandle.Alloc(callback);
+                pWorkItem->action = new GCHandle<Action>(callback);
                 pWorkItem->callback = &Callback;
 
                 EnableNoGCRegionCallbackStatus status = (EnableNoGCRegionCallbackStatus)RuntimeImports.RhEnableNoGCRegionCallback(pWorkItem, totalSize);
@@ -347,14 +347,13 @@ static void Callback(NoGCRegionCallbackFinalizerWorkItem* pWorkItem)
             {
                 Debug.Assert(pWorkItem->scheduled);
                 if (!pWorkItem->abandoned)
-                    ((Action)(pWorkItem->action.Target!))();
+                    pWorkItem->action.Target();
                 Free(pWorkItem);
             }
 
             static void Free(NoGCRegionCallbackFinalizerWorkItem* pWorkItem)
             {
-                if (pWorkItem->action.IsAllocated)
-                    pWorkItem->action.Free();
+                pWorkItem->action.Dispose();
                 NativeMemory.Free(pWorkItem);
             }
         }

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/InteropServices/PInvokeMarshal.cs

@@ -100,7 +100,7 @@ private static ConditionalWeakTable<Delegate, PInvokeDelegateThunk> GetPInvokeDe
         [StructLayout(LayoutKind.Sequential, Pack = 1)]
         internal unsafe struct ThunkContextData
         {
-            public GCHandle Handle;        //  A weak GCHandle to the delegate
+            public WeakGCHandle<Delegate> Handle;        //  A weak GCHandle to the delegate
             public IntPtr FunctionPtr;     // Function pointer for open static delegates
         }
 
@@ -133,7 +133,7 @@ public PInvokeDelegateThunk(Delegate del)
                     ThunkContextData* thunkData = (ThunkContextData*)ContextData;
 
                     // allocate a weak GChandle for the delegate
-                    thunkData->Handle = GCHandle.Alloc(del, GCHandleType.WeakTrackResurrection);
+                    thunkData->Handle = new WeakGCHandle<Delegate>(del, trackResurrection: true);
                     thunkData->FunctionPtr = openStaticFunctionPointer;
                 }
 
@@ -148,17 +148,17 @@ public PInvokeDelegateThunk(Delegate del)
                 if (ContextData != IntPtr.Zero)
                 {
                     // free the GCHandle
-                    GCHandle handle = ((ThunkContextData*)ContextData)->Handle;
+                    WeakGCHandle<Delegate> handle = ((ThunkContextData*)ContextData)->Handle;
                     if (handle.IsAllocated)
                     {
                         // If the delegate is still alive, defer finalization.
-                        if (handle.Target != null)
+                        if (handle.TryGetTarget(out _))
                         {
                             GC.ReRegisterForFinalize(this);
                             return;
                         }
 
-                        handle.Free();
+                        handle.Dispose();
                     }
 
                     // Free the allocated context data memory
@@ -205,21 +205,20 @@ private static unsafe PInvokeDelegateThunk AllocateThunk(Delegate del)
             IntPtr pTarget;
             if (s_thunkPoolHeap != null && RuntimeAugments.TryGetThunkData(s_thunkPoolHeap, ptr, out pContext, out pTarget))
             {
-                GCHandle handle;
+                WeakGCHandle<Delegate> handle;
                 unsafe
                 {
                     // Pull out Handle from context
                     handle = ((ThunkContextData*)pContext)->Handle;
                 }
-                Delegate target = Unsafe.As<Delegate>(handle.Target);
 
-                //
-                // The delegate might already been garbage collected
-                // User should use GC.KeepAlive or whatever ways necessary to keep the delegate alive
-                // until they are done with the native function pointer
-                //
-                if (target == null)
+                if (!handle.TryGetTarget(out Delegate? target))
                 {
+                    //
+                    // The delegate might already been garbage collected
+                    // User should use GC.KeepAlive or whatever ways necessary to keep the delegate alive
+                    // until they are done with the native function pointer
+                    //
                     Environment.FailFast(SR.Delegate_GarbageCollected);
                 }
 
@@ -269,7 +268,7 @@ public static IntPtr GetCurrentCalleeOpenStaticDelegateFunctionPointer()
         /// <summary>
         /// Retrieves the current delegate that is being called
         /// </summary>
-        public static T GetCurrentCalleeDelegate<T>() where T : class // constraint can't be System.Delegate
+        public static T GetCurrentCalleeDelegate<T>() where T : Delegate
         {
             //
             // RH keeps track of the current thunk that is being called through a secret argument / thread
@@ -280,26 +279,25 @@ public static T GetCurrentCalleeDelegate<T>() where T : class // constraint can'
 
             Debug.Assert(pContext != IntPtr.Zero);
 
-            GCHandle handle;
+            WeakGCHandle<Delegate> handle;
             unsafe
             {
                 // Pull out Handle from context
                 handle = ((ThunkContextData*)pContext)->Handle;
 
             }
 
-            T target = Unsafe.As<T>(handle.Target);
-
-            //
-            // The delegate might already been garbage collected
-            // User should use GC.KeepAlive or whatever ways necessary to keep the delegate alive
-            // until they are done with the native function pointer
-            //
-            if (target == null)
+            if (!handle.TryGetTarget(out Delegate? target))
             {
+                //
+                // The delegate might already been garbage collected
+                // User should use GC.KeepAlive or whatever ways necessary to keep the delegate alive
+                // until they are done with the native function pointer
+                //
                 Environment.FailFast(SR.Delegate_GarbageCollected);
             }
-            return target;
+
+            return Unsafe.As<T>(target);
         }
         #endregion
 

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Thread.NativeAot.Unix.cs

@@ -87,14 +87,14 @@ private bool JoinInternal(int millisecondsTimeout)
             }
         }
 
-        private unsafe bool CreateThread(GCHandle thisThreadHandle)
+        private unsafe bool CreateThread(GCHandle<Thread> thisThreadHandle)
         {
             // Create the Stop event before starting the thread to make sure
             // it is ready to be signaled at thread shutdown time.
             // This also avoids OOM after creating the thread.
             _stopped = new ManualResetEvent(false);
 
-            if (!Interop.Sys.CreateThread((IntPtr)_startHelper!._maxStackSize, &ThreadEntryPoint, (IntPtr)thisThreadHandle))
+            if (!Interop.Sys.CreateThread((IntPtr)_startHelper!._maxStackSize, &ThreadEntryPoint, GCHandle<Thread>.ToIntPtr(thisThreadHandle)))
             {
                 return false;
             }

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Thread.NativeAot.Windows.cs

@@ -175,7 +175,7 @@ private bool JoinInternal(int millisecondsTimeout)
             }
         }
 
-        private unsafe bool CreateThread(GCHandle thisThreadHandle)
+        private unsafe bool CreateThread(GCHandle<Thread> thisThreadHandle)
         {
             const int AllocationGranularity = 0x10000;  // 64 KiB
 
@@ -197,7 +197,7 @@ private unsafe bool CreateThread(GCHandle thisThreadHandle)
             }
 
             _osHandle = Interop.Kernel32.CreateThread(IntPtr.Zero, (IntPtr)stackSize,
-                &ThreadEntryPoint, (IntPtr)thisThreadHandle,
+                &ThreadEntryPoint, GCHandle<Thread>.ToIntPtr(thisThreadHandle),
                 Interop.Kernel32.CREATE_SUSPENDED | Interop.Kernel32.STACK_SIZE_PARAM_IS_A_RESERVATION,
                 out _);
 

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Thread.NativeAot.cs

@@ -379,7 +379,7 @@ private void StartCore()
                 }
 
                 bool waitingForThreadStart = false;
-                GCHandle threadHandle = GCHandle.Alloc(this);
+                GCHandle<Thread> threadHandle = new GCHandle<Thread>(this);
 
                 try
                 {
@@ -404,7 +404,7 @@ private void StartCore()
                     Debug.Assert(!waitingForThreadStart, "Leaked threadHandle");
                     if (!waitingForThreadStart)
                     {
-                        threadHandle.Free();
+                        threadHandle.Dispose();
                     }
                 }
 
@@ -422,8 +422,7 @@ private void StartCore()
 
         private static void StartThread(IntPtr parameter)
         {
-            GCHandle threadHandle = (GCHandle)parameter;
-            Thread thread = (Thread)threadHandle.Target!;
+            Thread thread = GCHandle<Thread>.FromIntPtr(parameter).Target;
 
             try
             {

src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeSystemContextFactory.cs

@@ -16,18 +16,17 @@ public static class TypeSystemContextFactory
     {
         // Cache the most recent instance of TypeSystemContext in a weak handle, and reuse it if possible
         // This allows us to avoid recreating the type resolution context again and again, but still allows it to go away once the types are no longer being built
-        private static GCHandle s_cachedContext = GCHandle.Alloc(null, GCHandleType.Weak);
+        private static WeakGCHandle<TypeSystemContext?> s_cachedContext = new WeakGCHandle<TypeSystemContext?>(null);
 
         private static readonly Lock s_lock = new Lock(useTrivialWaits: true);
 
         public static TypeSystemContext Create()
         {
             using (s_lock.EnterScope())
             {
-                TypeSystemContext context = (TypeSystemContext)s_cachedContext.Target;
-                if (context != null)
+                if (s_cachedContext.TryGetTarget(out TypeSystemContext? context))
                 {
-                    s_cachedContext.Target = null;
+                    s_cachedContext.SetTarget(null);
                     return context;
                 }
             }
@@ -63,7 +62,7 @@ public static void Recycle(TypeSystemContext context)
             context.FlushTypeBuilderStates();
 
             // No lock needed here - the reference assignment is atomic
-            s_cachedContext.Target = context;
+            s_cachedContext.SetTarget(context);
         }
     }
 }