Weak interior handles (#100446)

- Implementation of weak interior handle
- Use new weak interior handle to make managed class object storage consistent between collectible and non-collectible types

Author: davidwrighton

src/coreclr/debug/daccess/daccess.cpp

@@ -7770,6 +7770,8 @@ void CALLBACK DacHandleWalker::EnumCallback(PTR_UNCHECKED_OBJECTREF handle, uint
     data.Type = param->Type;
     if (param->Type == HNDTYPE_DEPENDENT)
         data.Secondary = GetDependentHandleSecondary(handle.GetAddr()).GetAddr();
+    else if (param->Type == HNDTYPE_WEAK_INTERIOR_POINTER)
+        data.Secondary = TO_CDADDR(HndGetHandleExtraInfo(handle.GetAddr()));
     else
         data.Secondary = 0;
     data.AppDomain = param->AppDomain;

src/coreclr/debug/daccess/request.cpp

@@ -3290,7 +3290,7 @@ ClrDataAccess::GetThreadLocalModuleData(CLRDATA_ADDRESS thread, unsigned int ind
 HRESULT ClrDataAccess::GetHandleEnum(ISOSHandleEnum **ppHandleEnum)
 {
     unsigned int types[] = {HNDTYPE_WEAK_SHORT, HNDTYPE_WEAK_LONG, HNDTYPE_STRONG, HNDTYPE_PINNED, HNDTYPE_DEPENDENT,
-                            HNDTYPE_SIZEDREF,
+                            HNDTYPE_SIZEDREF, HNDTYPE_WEAK_INTERIOR_POINTER,
 #if defined(FEATURE_COMINTEROP) || defined(FEATURE_COMWRAPPERS) || defined(FEATURE_OBJCMARSHAL)
                             HNDTYPE_REFCOUNTED,
 #endif // FEATURE_COMINTEROP || FEATURE_COMWRAPPERS || FEATURE_OBJCMARSHAL

src/coreclr/gc/gchandletable.cpp

@@ -213,7 +213,7 @@ Object* GCHandleManager::InterlockedCompareExchangeObjectInHandle(OBJECTHANDLE h
 HandleType GCHandleManager::HandleFetchType(OBJECTHANDLE handle)
 {
     uint32_t type = ::HandleFetchType(handle);
-    assert(type >= HNDTYPE_WEAK_SHORT && type <= HNDTYPE_WEAK_NATIVE_COM);
+    assert(type >= HNDTYPE_WEAK_SHORT && type <= HNDTYPE_WEAK_INTERIOR_POINTER);
     return static_cast<HandleType>(type);
 }
 

src/coreclr/gc/gcinterface.h

@@ -502,7 +502,17 @@ typedef enum
      *       but we are keeping it here for backward compatibility purposes"
      *
      */
-    HNDTYPE_WEAK_NATIVE_COM   = 9
+    HNDTYPE_WEAK_NATIVE_COM   = 9,
+
+    /*
+     * INTERIOR POINTER HANDLES
+     *
+     * Interior pointer handles allow the vm to request that the GC keep an interior pointer to
+     * a given object updated to keep pointing at the same location within an object. These handles
+     * have an extra pointer which points at an interior pointer into the first object.
+     *
+     */
+    HNDTYPE_WEAK_INTERIOR_POINTER = 10
 } HandleType;
 
 typedef enum

src/coreclr/gc/gcscan.cpp

@@ -171,6 +171,7 @@ void GCScan::GcScanHandles (promote_func* fn,  int condemned, int max_gen,
         Ref_UpdatePointers(condemned, max_gen, sc, fn);
         Ref_UpdatePinnedPointers(condemned, max_gen, sc, fn);
         Ref_ScanDependentHandlesForRelocation(condemned, max_gen, sc, fn);
+        Ref_ScanWeakInteriorPointersForRelocation(condemned, max_gen, sc, fn);
     }
 }
 

src/coreclr/gc/handletablescan.cpp

@@ -931,6 +931,15 @@ static void VerifyObjectAndAge(_UNCHECKED_OBJECTREF from, _UNCHECKED_OBJECTREF o
     }
 }
 
+size_t my_get_size (_UNCHECKED_OBJECTREF ob)
+{
+    MethodTable* mT = ob->GetGCSafeMethodTable();
+
+    return (mT->GetBaseSize() +
+            (mT->HasComponentSize() ?
+             ((size_t)reinterpret_cast<ArrayBase*>(ob)->GetNumComponents() * mT->RawGetComponentSize()) : 0));
+}
+
 /*
  * BlockVerifyAgeMapForBlocksWorker
  *
@@ -992,6 +1001,23 @@ void BlockVerifyAgeMapForBlocksWorker(uint32_t *pdwGen, uint32_t dwClumpMask, Sc
                             }
                         }
                     }
+                    if (uType == HNDTYPE_WEAK_INTERIOR_POINTER)
+                    {
+                        PTR_uintptr_t pUserData = HandleQuickFetchUserDataPointer((OBJECTHANDLE)pValue);
+
+                        // if we did then copy the value
+                        if (pUserData)
+                        {
+                            uintptr_t pObjectInteriorPointer = **reinterpret_cast<uintptr_t**>(pUserData);
+                            _UNCHECKED_OBJECTREF pObjectPointerRef = *pValue;
+                            uintptr_t pObjectPointer = reinterpret_cast<uintptr_t>(pObjectPointerRef);
+                            if (pObjectInteriorPointer < pObjectPointer || pObjectInteriorPointer >= (pObjectPointer + my_get_size(pObjectPointerRef)))
+                            {
+                                _ASSERTE(!"Weak interior pointer has interior pointer which does not point at the object of the handle.");
+                                GCToEEInterface::HandleFatalError(COR_E_EXECUTIONENGINE);
+                            }
+                        }
+                    }
                 }
             }
         }

src/coreclr/gc/objecthandle.cpp

@@ -145,6 +145,47 @@ void CALLBACK TraceDependentHandle(_UNCHECKED_OBJECTREF *pObjRef, uintptr_t *pEx
     }
 }
 
+void CALLBACK UpdateWeakInteriorHandle(_UNCHECKED_OBJECTREF *pObjRef, uintptr_t *pExtraInfo, uintptr_t lp1, uintptr_t lp2)
+{
+    LIMITED_METHOD_CONTRACT;
+    _ASSERTE(pExtraInfo);
+
+    Object **pPrimaryRef = (Object **)pObjRef;
+    uintptr_t **ppInteriorPtrRef = (uintptr_t **)pExtraInfo;
+
+    LOG((LF_GC, LL_INFO10000, LOG_HANDLE_OBJECT("Querying for new location of ",
+            pPrimaryRef, "to ", *pPrimaryRef)));
+
+    Object *pOldPrimary = *pPrimaryRef;
+
+	_ASSERTE(lp2);
+	promote_func* callback = (promote_func*) lp2;
+	callback(pPrimaryRef, (ScanContext *)lp1, 0);
+
+    Object *pNewPrimary = *pPrimaryRef;
+    if (pNewPrimary != NULL)
+    {
+        uintptr_t pOldInterior = **ppInteriorPtrRef;
+        uintptr_t delta = ((uintptr_t)pNewPrimary) - ((uintptr_t)pOldPrimary);
+        uintptr_t pNewInterior = pOldInterior + delta;
+        **ppInteriorPtrRef = pNewInterior;
+#ifdef _DEBUG
+        if (pOldPrimary != *pPrimaryRef)
+            LOG((LF_GC, LL_INFO10000,  "Updating " FMT_HANDLE "from" FMT_ADDR "to " FMT_OBJECT "\n",
+                DBG_ADDR(pPrimaryRef), DBG_ADDR(pOldPrimary), DBG_ADDR(*pPrimaryRef)));
+        else
+            LOG((LF_GC, LL_INFO10000, "Updating " FMT_HANDLE "- " FMT_OBJECT "did not move\n",
+                DBG_ADDR(pPrimaryRef), DBG_ADDR(*pPrimaryRef)));
+        if (pOldInterior != pNewInterior)
+            LOG((LF_GC, LL_INFO10000,  "Updating " FMT_HANDLE "from" FMT_ADDR "to " FMT_OBJECT "\n",
+                DBG_ADDR(*ppInteriorPtrRef), DBG_ADDR(pOldInterior), DBG_ADDR(pNewInterior)));
+        else
+            LOG((LF_GC, LL_INFO10000, "Updating " FMT_HANDLE "- " FMT_OBJECT "did not move\n",
+                DBG_ADDR(*ppInteriorPtrRef), DBG_ADDR(pOldInterior)));
+#endif
+    }
+}
+
 void CALLBACK UpdateDependentHandle(_UNCHECKED_OBJECTREF *pObjRef, uintptr_t *pExtraInfo, uintptr_t lp1, uintptr_t lp2)
 {
     LIMITED_METHOD_CONTRACT;
@@ -427,6 +468,7 @@ void CALLBACK ScanPointerForProfilerAndETW(_UNCHECKED_OBJECTREF *pObjRef, uintpt
         break;
     case    HNDTYPE_WEAK_SHORT:
     case    HNDTYPE_WEAK_LONG:
+    case    HNDTYPE_WEAK_INTERIOR_POINTER:
 #ifdef FEATURE_WEAK_NATIVE_COM_HANDLES
     case    HNDTYPE_WEAK_NATIVE_COM:
 #endif // FEATURE_WEAK_NATIVE_COM_HANDLES
@@ -527,6 +569,7 @@ static const uint32_t s_rgTypeFlags[] =
     HNDF_NORMAL,    // HNDTYPE_ASYNCPINNED
     HNDF_EXTRAINFO, // HNDTYPE_SIZEDREF
     HNDF_EXTRAINFO, // HNDTYPE_WEAK_NATIVE_COM
+    HNDF_EXTRAINFO, // HNDTYPE_WEAK_INTERIOR_POINTER
 };
 
 int getNumberOfSlots()
@@ -1170,6 +1213,7 @@ void Ref_CheckReachable(uint32_t condemned, uint32_t maxgen, ScanContext *sc)
 #ifdef FEATURE_REFCOUNTED_HANDLES
         HNDTYPE_REFCOUNTED,
 #endif
+        HNDTYPE_WEAK_INTERIOR_POINTER
     };
 
     // check objects pointed to by short weak handles
@@ -1339,6 +1383,40 @@ void Ref_ScanDependentHandlesForClearing(uint32_t condemned, uint32_t maxgen, Sc
     }
 }
 
+// Perform a scan of weak interior pointers for the purpose of updating handles to track relocated objects.
+void Ref_ScanWeakInteriorPointersForRelocation(uint32_t condemned, uint32_t maxgen, ScanContext* sc, Ref_promote_func* fn)
+{
+    LOG((LF_GC, LL_INFO10000, "Relocating moved dependent handles in generation %u\n", condemned));
+    uint32_t type = HNDTYPE_WEAK_INTERIOR_POINTER;
+    uint32_t flags = (sc->concurrent) ? HNDGCF_ASYNC : HNDGCF_NORMAL;
+    flags |= HNDGCF_EXTRAINFO;
+
+    HandleTableMap *walk = &g_HandleTableMap;
+    while (walk)
+    {
+        for (uint32_t i = 0; i < INITIAL_HANDLE_TABLE_ARRAY_SIZE; i ++)
+        {
+            if (walk->pBuckets[i] != NULL)
+            {
+                int uCPUindex = getSlotNumber(sc);
+                int uCPUlimit = getNumberOfSlots();
+                assert(uCPUlimit > 0);
+                int uCPUstep = getThreadCount(sc);
+                HHANDLETABLE* pTable = walk->pBuckets[i]->pTable;
+                for ( ; uCPUindex < uCPUlimit; uCPUindex += uCPUstep)
+                {
+                    HHANDLETABLE hTable = pTable[uCPUindex];
+                    if (hTable)
+                    {
+                        HndScanHandlesForGC(hTable, UpdateWeakInteriorHandle, uintptr_t(sc), uintptr_t(fn), &type, 1, condemned, maxgen, flags );
+                    }
+                }
+            }
+        }
+        walk = walk->pNext;
+    }
+}
+
 // Perform a scan of dependent handles for the purpose of updating handles to track relocated objects.
 void Ref_ScanDependentHandlesForRelocation(uint32_t condemned, uint32_t maxgen, ScanContext* sc, Ref_promote_func* fn)
 {
@@ -1590,6 +1668,7 @@ void Ref_ScanHandlesForProfilerAndETW(uint32_t maxgen, uintptr_t lp1, handle_sca
         HNDTYPE_ASYNCPINNED,
 #endif
         HNDTYPE_SIZEDREF,
+        HNDTYPE_WEAK_INTERIOR_POINTER
     };
 
     uint32_t flags = HNDGCF_NORMAL;
@@ -1712,6 +1791,7 @@ void Ref_AgeHandles(uint32_t condemned, uint32_t maxgen, ScanContext* sc)
         HNDTYPE_ASYNCPINNED,
 #endif
         HNDTYPE_SIZEDREF,
+        HNDTYPE_WEAK_INTERIOR_POINTER
     };
 
     // perform a multi-type scan that ages the handles
@@ -1766,6 +1846,7 @@ void Ref_RejuvenateHandles(uint32_t condemned, uint32_t maxgen, ScanContext* sc)
         HNDTYPE_ASYNCPINNED,
 #endif
         HNDTYPE_SIZEDREF,
+        HNDTYPE_WEAK_INTERIOR_POINTER
     };
 
     // reset the ages of these handles
@@ -1819,6 +1900,7 @@ void Ref_VerifyHandleTable(uint32_t condemned, uint32_t maxgen, ScanContext* sc)
 #endif
         HNDTYPE_SIZEDREF,
         HNDTYPE_DEPENDENT,
+        HNDTYPE_WEAK_INTERIOR_POINTER
     };
 
     // verify these handles

src/coreclr/gc/objecthandle.h

@@ -102,6 +102,7 @@ DhContext *Ref_GetDependentHandleContext(ScanContext* sc);
 bool Ref_ScanDependentHandlesForPromotion(DhContext *pDhContext);
 void Ref_ScanDependentHandlesForClearing(uint32_t condemned, uint32_t maxgen, ScanContext* sc);
 void Ref_ScanDependentHandlesForRelocation(uint32_t condemned, uint32_t maxgen, ScanContext* sc, Ref_promote_func* fn);
+void Ref_ScanWeakInteriorPointersForRelocation(uint32_t condemned, uint32_t maxgen, ScanContext* sc, Ref_promote_func* fn);
 void Ref_ScanSizedRefHandles(uint32_t condemned, uint32_t maxgen, ScanContext* sc, Ref_promote_func* fn);
 
 void Ref_CheckReachable       (uint32_t uCondemnedGeneration, uint32_t uMaxGeneration, ScanContext* sc);

src/coreclr/vm/appdomain.hpp

@@ -1038,6 +1038,12 @@ class BaseDomain
         return ::CreatePinningHandle(m_handleStore, object);
     }
 
+    OBJECTHANDLE CreateWeakInteriorHandle(OBJECTREF object, void* pInteriorPointerLocation)
+    {
+        WRAPPER_NO_CONTRACT;
+        return ::CreateWeakInteriorHandle(m_handleStore, object, pInteriorPointerLocation);
+    }
+
     OBJECTHANDLE CreateSizedRefHandle(OBJECTREF object)
     {
         WRAPPER_NO_CONTRACT;

src/coreclr/vm/gchandleutilities.h

@@ -147,6 +147,18 @@ inline OBJECTHANDLE CreateDependentHandle(IGCHandleStore* store, OBJECTREF prima
     return hnd;
 }
 
+inline OBJECTHANDLE CreateWeakInteriorHandle(IGCHandleStore* store, OBJECTREF primary, void* interiorPointerLocation)
+{
+    OBJECTHANDLE hnd = store->CreateHandleWithExtraInfo(OBJECTREFToObject(primary), HNDTYPE_WEAK_INTERIOR_POINTER, interiorPointerLocation);
+    if (!hnd)
+    {
+        COMPlusThrowOM();
+    }
+
+    DiagHandleCreated(hnd, primary);
+    return hnd;
+}
+
 // Global handle creation convenience functions
 inline OBJECTHANDLE CreateGlobalHandleCommon(OBJECTREF object, HandleType type)
 {
@@ -321,6 +333,11 @@ inline void DestroyGlobalRefcountedHandle(OBJECTHANDLE handle)
     DestroyHandleCommon(handle, HNDTYPE_REFCOUNTED);
 }
 
+inline void DestroyWeakInteriorHandle(OBJECTHANDLE handle)
+{
+    DestroyHandleCommon(handle, HNDTYPE_WEAK_INTERIOR_POINTER);
+}
+
 inline void DestroyTypedHandle(OBJECTHANDLE handle)
 {
     DiagHandleDestroyed(handle);
@@ -338,6 +355,7 @@ typedef Wrapper<OBJECTHANDLE, DoNothing<OBJECTHANDLE>, DestroyRefcountedHandle>
 typedef Holder<OBJECTHANDLE, DoNothing<OBJECTHANDLE>, DestroyLongWeakHandle>            LongWeakHandleHolder;
 typedef Holder<OBJECTHANDLE, DoNothing<OBJECTHANDLE>, DestroyGlobalStrongHandle>        GlobalStrongHandleHolder;
 typedef Holder<OBJECTHANDLE, DoNothing<OBJECTHANDLE>, DestroyGlobalShortWeakHandle>     GlobalShortWeakHandleHolder;
+typedef Holder<OBJECTHANDLE, DoNothing<OBJECTHANDLE>, DestroyWeakInteriorHandle>        WeakInteriorHandleHolder;
 typedef Holder<OBJECTHANDLE, DoNothing<OBJECTHANDLE>, ResetOBJECTHANDLE>                ObjectInHandleHolder;
 
 class RCOBJECTHANDLEHolder : public RefCountedOHWrapper