Rename DependentHandle FCalls

src/coreclr/System.Private.CoreLib/src/System/Runtime/DependentHandle.cs

@@ -56,7 +56,7 @@ public struct DependentHandle : IDisposable
         public DependentHandle(object? target, object? dependent)
         {
             // no need to check for null result: nInitialize expected to throw OOM.
-            _handle = nInitialize(target, dependent);
+            _handle = InternalInitialize(target, dependent);
         }
 
         /// <summary>
@@ -79,7 +79,7 @@ public object? Target
                     ThrowHelper.ThrowInvalidOperationException();
                 }
 
-                return nGetPrimary(handle);
+                return InternalGetTarget(handle);
             }
             set
             {
@@ -90,7 +90,7 @@ public object? Target
                     ThrowHelper.ThrowInvalidOperationException();
                 }
 
-                nSetPrimary(handle, value);
+                InternalSetTarget(handle, value);
             }
         }
 
@@ -114,7 +114,7 @@ public object? Dependent
                     ThrowHelper.ThrowInvalidOperationException();
                 }
 
-                return nGetSecondary(handle);
+                return InternalGetDependent(handle);
             }
             set
             {
@@ -125,7 +125,7 @@ public object? Dependent
                     ThrowHelper.ThrowInvalidOperationException();
                 }
 
-                nSetSecondary(handle, value);
+                InternalSetDependent(handle, value);
             }
         }
 
@@ -143,8 +143,8 @@ public object? Dependent
                 ThrowHelper.ThrowInvalidOperationException();
             }
 
-            object? target = nGetPrimary(handle);
-            object? secondary = nGetSecondary(handle);
+            object? target = InternalGetTarget(handle);
+            object? secondary = InternalGetDependent(handle);
 
             return (target, secondary);
         }
@@ -156,7 +156,7 @@ public object? Dependent
         /// <remarks>This method mirrors <see cref="Target"/>, but without the allocation check.</remarks>
         internal object? UnsafeGetTarget()
         {
-            return nGetPrimary(_handle);
+            return InternalGetTarget(_handle);
         }
 
         /// <summary>
@@ -165,7 +165,7 @@ public object? Dependent
         /// <remarks>This method mirrors <see cref="Target"/>, but without the allocation check.</remarks>
         internal void UnsafeSetTarget(object? target)
         {
-            nSetPrimary(_handle, target);
+            InternalSetTarget(_handle, target);
         }
 
         /// <summary>
@@ -174,7 +174,7 @@ internal void UnsafeSetTarget(object? target)
         /// <remarks>This method mirrors <see cref="Dependent"/>, but without the allocation check.</remarks>
         internal void UnsafeSetDependent(object? dependent)
         {
-            nSetSecondary(_handle, dependent);
+            InternalSetDependent(_handle, dependent);
         }
 
         /// <summary>
@@ -190,9 +190,9 @@ internal void UnsafeSetDependent(object? dependent)
         {
             IntPtr handle = _handle;
 
-            object? target = nGetPrimary(handle);
+            object? target = InternalGetTarget(handle);
 
-            dependent = nGetSecondary(handle);
+            dependent = InternalGetDependent(handle);
 
             return target;
         }
@@ -207,18 +207,18 @@ public void Dispose()
             {
                 IntPtr handle = _handle;
                 _handle = IntPtr.Zero;
-                nFree(handle);
+                InternalFree(handle);
             }
         }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern IntPtr nInitialize(object? primary, object? secondary);
+        private static extern IntPtr InternalInitialize(object? target, object? dependent);
 
 #if DEBUG
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern object? nGetPrimary(IntPtr dependentHandle);
+        private static extern object? InternalGetTarget(IntPtr dependentHandle);
 #else
-        private static unsafe object? nGetPrimary(IntPtr dependentHandle)
+        private static unsafe object? InternalGetTarget(IntPtr dependentHandle)
         {
             // This optimization is the same that is used in GCHandle in RELEASE mode.
             // This is not used in DEBUG builds as the runtime performs additional checks.
@@ -228,15 +228,15 @@ public void Dispose()
 #endif
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern object? nGetSecondary(IntPtr dependentHandle);
+        private static extern object? InternalGetDependent(IntPtr dependentHandle);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void nSetPrimary(IntPtr dependentHandle, object? primary);
+        private static extern void InternalSetTarget(IntPtr dependentHandle, object? target);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void nSetSecondary(IntPtr dependentHandle, object? secondary);
+        private static extern void InternalSetDependent(IntPtr dependentHandle, object? dependent);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void nFree(IntPtr dependentHandle);
+        private static extern void InternalFree(IntPtr dependentHandle);
     }
 }

src/coreclr/vm/comdependenthandle.cpp

@@ -14,71 +14,64 @@
 #include "common.h"
 #include "comdependenthandle.h"
 
-
-
-FCIMPL2(OBJECTHANDLE, DependentHandle::nInitialize, Object *_primary, Object *_secondary)
+FCIMPL2(OBJECTHANDLE, DependentHandle::InternalInitialize, Object *_target, Object *_dependent)
 {
     FCALL_CONTRACT;
 
-    OBJECTREF primary(_primary);
-    OBJECTREF secondary(_secondary);
+    OBJECTREF target(_target);
+    OBJECTREF dependent(_dependent);
     OBJECTHANDLE result = NULL;
 
     HELPER_METHOD_FRAME_BEGIN_RET_NOPOLL();
 
     // Create the handle.
-    result = GetAppDomain()->CreateDependentHandle(primary, secondary);
+    result = GetAppDomain()->CreateDependentHandle(target, dependent);
 
     HELPER_METHOD_FRAME_END_POLL();
 
     return result;
 }
 FCIMPLEND
 
-
-
-FCIMPL1(VOID, DependentHandle::nFree, OBJECTHANDLE handle)
+FCIMPL1(Object*, DependentHandle::InternalGetTarget, OBJECTHANDLE handle)
 {
     FCALL_CONTRACT;
-
+    FCUnique(0x54);
     _ASSERTE(handle != NULL);
-
-    HELPER_METHOD_FRAME_BEGIN_0();
-
-    DestroyDependentHandle(handle);
-
-    HELPER_METHOD_FRAME_END();
-
+    return OBJECTREFToObject(ObjectFromHandle(handle));
 }
 FCIMPLEND
 
-
-
-FCIMPL1(Object*, DependentHandle::nGetPrimary, OBJECTHANDLE handle)
+FCIMPL1(Object*, DependentHandle::InternalGetDependent, OBJECTHANDLE handle)
 {
     FCALL_CONTRACT;
-    FCUnique(0x54);
+
     _ASSERTE(handle != NULL);
-    return OBJECTREFToObject(ObjectFromHandle(handle));
-}
-FCIMPLEND
 
+    OBJECTREF target = ObjectFromHandle(handle);
 
+    IGCHandleManager *mgr = GCHandleUtilities::GetGCHandleManager();
 
-FCIMPL1(Object*, DependentHandle::nGetSecondary, OBJECTHANDLE handle)
+    // The dependent is tracked only if target is non-null
+    return (target != NULL) ? mgr->GetDependentHandleSecondary(handle) : NULL;
+}
+FCIMPLEND
+
+FCIMPL1(VOID, DependentHandle::InternalFree, OBJECTHANDLE handle)
 {
     FCALL_CONTRACT;
+
     _ASSERTE(handle != NULL);
 
-    OBJECTREF primary = ObjectFromHandle(handle);
+    HELPER_METHOD_FRAME_BEGIN_0();
 
-    IGCHandleManager *mgr = GCHandleUtilities::GetGCHandleManager();
-    // Secondary is tracked only if primary is non-null
-    return (primary != NULL) ? mgr->GetDependentHandleSecondary(handle) : NULL;
+    DestroyDependentHandle(handle);
+
+    HELPER_METHOD_FRAME_END();
 }
 FCIMPLEND
 
-FCIMPL2(VOID, DependentHandle::nSetPrimary, OBJECTHANDLE handle, Object *_primary)
+FCIMPL2(VOID, DependentHandle::InternalSetTarget, OBJECTHANDLE handle, Object *_target)
 {
     FCALL_CONTRACT;
 
@@ -88,17 +81,17 @@ FCIMPL2(VOID, DependentHandle::nSetPrimary, OBJECTHANDLE handle, Object *_primar
     FCUnique(0x12);
 
     IGCHandleManager *mgr = GCHandleUtilities::GetGCHandleManager();
-    mgr->StoreObjectInHandle(handle, _primary);
+    mgr->StoreObjectInHandle(handle, _target);
 }
 FCIMPLEND
 
-FCIMPL2(VOID, DependentHandle::nSetSecondary, OBJECTHANDLE handle, Object *_secondary)
+FCIMPL2(VOID, DependentHandle::InternalSetDependent, OBJECTHANDLE handle, Object *_dependent)
 {
     FCALL_CONTRACT;
 
     _ASSERTE(handle != NULL);
 
     IGCHandleManager *mgr = GCHandleUtilities::GetGCHandleManager();
-    mgr->SetDependentHandleSecondary(handle, _secondary);
+    mgr->SetDependentHandleSecondary(handle, _dependent);
 }
 FCIMPLEND

src/coreclr/vm/comdependenthandle.h

@@ -16,16 +16,16 @@
 
 // A dependent handle is conceputally a tuple containing two object reference
 //
-//     * A Primary object (think key)
-//     * A Secondary Object (think value)
+//     * A Target object (think key)
+//     * A Dependent Object (think value)
 //
-// The reference to both the primary object is (long) weak (will not keep the object alive). However the
-// reference to the secondary object is (long) weak if the primary object is dead, and strong if the primary
-// object is alive. (Hence it is a 'Dependent' handle since the strength of the secondary reference depends
-// on the primary).
+// The reference to both the target object is (long) weak (will not keep the object alive). However the
+// reference to the dependent object is (long) weak if the target object is dead, and strong if the target
+// object is alive. (Hence it is a 'Dependent' handle since the strength of the dependent reference depends
+// on the target).
 //
 // The effect of this semantics is that it seems that while the DependentHandle exists, the system behaves as
-// if there was a normal strong reference from the primary object to the secondary one.
+// if there was a normal strong reference from the target object to the dependent one.
 //
 // The usefulness of a DependentHandle is to allow other objects to be 'attached' to a given object. By
 // having a hash table where the entries are dependent handles you can attach arbitrary objects to another
@@ -40,13 +40,12 @@
 class DependentHandle
 {
 public:
-    static FCDECL2(OBJECTHANDLE, nInitialize, Object *primary, Object *secondary);
-    static FCDECL1(Object *, nGetPrimary, OBJECTHANDLE handle);
-    static FCDECL1(Object *, nGetSecondary, OBJECTHANDLE handle);
-    static FCDECL1(VOID, nFree, OBJECTHANDLE handle);
-    static FCDECL2(VOID, nSetPrimary, OBJECTHANDLE handle, Object *primary);
-    static FCDECL2(VOID, nSetSecondary, OBJECTHANDLE handle, Object *secondary);
+    static FCDECL2(OBJECTHANDLE, InternalInitialize, Object *target, Object *dependent);
+    static FCDECL1(Object *, InternalGetTarget, OBJECTHANDLE handle);
+    static FCDECL1(Object *, InternalGetDependent, OBJECTHANDLE handle);
+    static FCDECL1(VOID, InternalFree, OBJECTHANDLE handle);
+    static FCDECL2(VOID, InternalSetTarget, OBJECTHANDLE handle, Object *target);
+    static FCDECL2(VOID, InternalSetDependent, OBJECTHANDLE handle, Object *dependent);
 };
 
 #endif
-

src/coreclr/vm/ecalllist.h

@@ -61,12 +61,12 @@
 
 
 FCFuncStart(gDependentHandleFuncs)
-    FCFuncElement("nInitialize",   DependentHandle::nInitialize)
-    FCFuncElement("nGetPrimary",   DependentHandle::nGetPrimary)
-    FCFuncElement("nGetSecondary", DependentHandle::nGetSecondary)
-    FCFuncElement("nFree",         DependentHandle::nFree)
-    FCFuncElement("nSetPrimary",   DependentHandle::nSetPrimary)
-    FCFuncElement("nSetSecondary", DependentHandle::nSetSecondary)
+    FCFuncElement("InternalInitialize",   DependentHandle::InternalInitialize)
+    FCFuncElement("InternalGetTarget",    DependentHandle::InternalGetTarget)
+    FCFuncElement("InternalGetDependent", DependentHandle::InternalGetDependent)
+    FCFuncElement("InternalFree",         DependentHandle::InternalFree)
+    FCFuncElement("InternalSetTarget",    DependentHandle::InternalSetTarget)
+    FCFuncElement("InternalSetDependent", DependentHandle::InternalSetDependent)
 FCFuncEnd()