Checkpoint support for byref and ref fields inside VT interpreter locals

Author: kg

src/coreclr/interpreter/CMakeLists.txt

@@ -4,7 +4,17 @@ set(INTERPRETER_SOURCES
   compileropt.cpp
   intops.cpp
   interpconfig.cpp
-  eeinterp.cpp)
+  eeinterp.cpp
+  stackmap.cpp
+  ../../native/containers/dn-simdhash.c
+  ../../native/containers/dn-simdhash-ptr-ptr.c)
+
+set_source_files_properties(
+    ../../native/containers/dn-simdhash.c
+    ../../native/containers/dn-simdhash-ptr-ptr.c
+    PROPERTIES COMPILE_FLAGS
+    /DNO_CONFIG_H
+)
 
 set(INTERPRETER_LINK_LIBRARIES
   gcinfo

src/coreclr/interpreter/compiler.cpp

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 #include "gcinfoencoder.h"
 #include "interpreter.h"
+#include "stackmap.h"
 
 #include <inttypes.h>
 
@@ -868,7 +869,7 @@ void InterpCompiler::BuildGCInfo(InterpMethod *pInterpMethod)
 
     gcInfoEncoder->SetCodeLength(ConvertOffset(m_methodCodeSize));
 
-    uint32_t stackSlotCount = m_totalVarsStackSize / INTERP_STACK_SLOT_SIZE,
+    uint32_t stackSlotCount = m_totalVarsStackSize / sizeof(void *),
         slotTableSize = stackSlotCount * sizeof(GcSlotId);
     // [pObjects, pByrefs]
     GcSlotId *slotTables[2] = {
@@ -879,86 +880,111 @@ void InterpCompiler::BuildGCInfo(InterpMethod *pInterpMethod)
     for (int i = 0; i < 2; i++)
         memset(slotTables[i], 0xFF, slotTableSize);
 
-    INTERP_DUMP("Allocating gcinfo slots for %u vars\n", m_varsSize);
-
-    // Request slot IDs for all our vars, not just IL vars
-    for (int i = 0; i < m_varsSize; i++)
+    auto allocateGcSlot = [&] (uint32_t offsetBytes, GcSlotFlags flags)
     {
-        GcSlotId *slotTable;
-        InterpVar *pVar = &m_pVars[i];
-        GcSlotFlags flags;
-        switch (pVar->interpType) {
-            case InterpTypeO:
-                slotTable = slotTables[0];
-                flags = (GcSlotFlags)0;
-                break;
-            case InterpTypeByRef:
-                slotTable = slotTables[1];
-                flags = (GcSlotFlags)GC_SLOT_INTERIOR;
-                break;
-            default:
-                continue;
-        }
+        // Select the appropriate slot table based on the flags
+        GcSlotId *slotTable = slotTables[(flags & GC_SLOT_INTERIOR) == GC_SLOT_INTERIOR];
+        uint32_t slotIndex = offsetBytes / sizeof(void *);
+        bool allocateNewSlot = slotTable[slotIndex] == ((GcSlotId)-1);
 
-        if (pVar->global)
-            flags = (GcSlotFlags)(flags | GC_SLOT_UNTRACKED);
-
-        uint32_t slotIndex = pVar->offset / INTERP_STACK_SLOT_SIZE;
-        uint8_t allocateNewSlot = slotTable[slotIndex] == ((GcSlotId)-1);
         if (allocateNewSlot)
         {
             // Important to pass GC_FRAMEREG_REL, the default is broken due to GET_CALLER_SP being unimplemented
-            slotTable[slotIndex] = gcInfoEncoder->GetStackSlotId(pVar->offset, flags, GC_FRAMEREG_REL);
+            slotTable[slotIndex] = gcInfoEncoder->GetStackSlotId(offsetBytes, flags, GC_FRAMEREG_REL);
         }
         else
         {
-            assert(!pVar->global);
+            assert((flags & GC_SLOT_UNTRACKED) == 0);
         }
 
         INTERP_DUMP(
-            "%s gcinfo slot %u for %s%svar #%d at offset %d\n",
+            "%s %s%sgcslot %u at %u\n",
             allocateNewSlot ? "Allocated" : "Reused",
+            (flags & GC_SLOT_UNTRACKED) ? "global " : "",
+            (flags & GC_SLOT_INTERIOR) ? "interior " : "",
             slotTable[slotIndex],
-            pVar->global ? "global " : "",
-            pVar->interpType == InterpTypeByRef ? "byref " : "",
-            i, pVar->offset
+            offsetBytes
         );
-    }
 
-    gcInfoEncoder->FinalizeSlotIds();
+        return slotTable[slotIndex];
+    };
 
-    // Now that slot IDs are finalized we want to record live ranges for every var that isn't global
-    for (int i = 0; i < m_varsSize; i++)
+    auto recordLiveRange = [&] (uint32_t offsetBytes, GcSlotFlags flags, int varIndex)
     {
-        InterpVar *pVar = &m_pVars[i];
-        // Even if we have a gc slot for this offset, this var might not be an object reference
-        if ((pVar->interpType != InterpTypeO) && (pVar->interpType != InterpTypeByRef))
-            continue;
-        // We don't need to report liveness ranges for untracked vars, the gc info decoder will report them
-        //  unconditionally.
+        // Select the appropriate slot table based on the flags
+        GcSlotId *slotTable = slotTables[(flags & GC_SLOT_INTERIOR) == GC_SLOT_INTERIOR];
+        uint32_t slotIndex = offsetBytes / sizeof(void *);
+
+        InterpVar *pVar = &m_pVars[varIndex];
         if (pVar->global)
-            continue;
+            return;
 
-        GcSlotId *slotTable = pVar->interpType == InterpTypeByRef
-            ? slotTables[1] : slotTables[0];
-        uint32_t slotIndex = pVar->offset / INTERP_STACK_SLOT_SIZE;
         GcSlotId slot = slotTable[slotIndex];
         assert(slot != ((GcSlotId)-1));
         assert(pVar->liveStart);
         assert(pVar->liveEnd);
-        uint32_t startOffset = ConvertOffset(GetLiveStartOffset(i)),
-            endOffset = ConvertOffset(GetLiveEndOffset(i));
+        uint32_t startOffset = ConvertOffset(GetLiveStartOffset(varIndex)),
+            endOffset = ConvertOffset(GetLiveEndOffset(varIndex));
         INTERP_DUMP(
-            "Recording gcinfo slot %u live range for var #%d at offset %u: [IR_%04x - IR_%04x] [%u - %u]\n",
-            slotTable[slotIndex], i, pVar->offset,
-            GetLiveStartOffset(i), GetLiveEndOffset(i),
+            "Recording slot %u (var #%d offset %u) live range [IR_%04x - IR_%04x] [%u - %u]\n",
+            slotTable[slotIndex], varIndex, pVar->offset,
+            GetLiveStartOffset(varIndex), GetLiveEndOffset(varIndex),
             startOffset, endOffset
         );
         gcInfoEncoder->SetSlotState(startOffset, slot, GC_SLOT_LIVE);
         gcInfoEncoder->SetSlotState(endOffset, slot, GC_SLOT_DEAD);
-    }
+    };
+
+    INTERP_DUMP("Allocating gcinfo slots for %u vars\n", m_varsSize);
 
-    gcInfoEncoder->Build();
+    for (int pass = 0; pass < 2; pass++)
+    {
+        for (int i = 0; i < m_varsSize; i++)
+        {
+            InterpVar *pVar = &m_pVars[i];
+            GcSlotFlags flags = pVar->global
+                ? (GcSlotFlags)GC_SLOT_UNTRACKED
+                : (GcSlotFlags)0;
+
+            switch (pVar->interpType) {
+                case InterpTypeO:
+                    break;
+                case InterpTypeByRef:
+                    flags = (GcSlotFlags)(flags | GC_SLOT_INTERIOR);
+                    break;
+                case InterpTypeVT:
+                {
+                    InterpreterStackMap *stackMap = getInterpreterStackMap(m_compHnd, pVar->clsHnd);
+                    for (unsigned j = 0; j < stackMap->m_slotCount; j++)
+                    {
+                        InterpreterStackMapSlot slotInfo = stackMap->m_slots[j];
+                        unsigned fieldOffset = pVar->offset + slotInfo.m_offsetBytes;
+                        GcSlotFlags fieldFlags = (GcSlotFlags)(flags | slotInfo.m_gcSlotFlags);
+                        if (pass == 0)
+                            allocateGcSlot(fieldOffset, fieldFlags);
+                        else
+                            recordLiveRange(fieldOffset, fieldFlags, i);
+                    }
+
+                    // Don't perform the regular allocateGcSlot call
+                    continue;
+                }
+                default:
+                    // Neither an object, interior pointer, or vt, so no slot needed
+                    continue;
+            }
+
+            if (pass == 0)
+                allocateGcSlot(pVar->offset, flags);
+            else
+                recordLiveRange(pVar->offset, flags, i);
+        }
+
+        if (pass == 0)
+            gcInfoEncoder->FinalizeSlotIds();
+        else
+            gcInfoEncoder->Build();
+    }
 
     // GC Encoder automatically puts the GC info in the right spot using ICorJitInfo::allocGCInfo(size_t)
     gcInfoEncoder->Emit();

src/coreclr/interpreter/stackmap.cpp

@@ -0,0 +1,72 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#include "gcinfoencoder.h" // for GcSlotFlags
+#include "interpreter.h"
+#include "stackmap.h"
+
+extern "C" {
+    #include "../../native/containers/dn-simdhash.h"
+    #include "../../native/containers/dn-simdhash-specializations.h"
+
+    void assertAbort(const char* why, const char* file, unsigned line);
+
+    void
+    dn_simdhash_assert_fail (const char *file, int line, const char *condition);
+
+    void
+    dn_simdhash_assert_fail (const char *file, int line, const char *condition) {
+        assertAbort(condition, file, line);
+    }
+}
+
+thread_local dn_simdhash_ptr_ptr_t *gSharedStackMapLookup = nullptr;
+
+InterpreterStackMap* getInterpreterStackMap(ICorJitInfo *jitInfo, CORINFO_CLASS_HANDLE classHandle)
+{
+    InterpreterStackMap* result = nullptr;
+    if (!gSharedStackMapLookup)
+        gSharedStackMapLookup = dn_simdhash_ptr_ptr_new(0, nullptr);
+    if (!dn_simdhash_ptr_ptr_try_get_value(gSharedStackMapLookup, classHandle, (void **)&result))
+    {
+        result = new InterpreterStackMap(jitInfo, classHandle);
+        dn_simdhash_ptr_ptr_try_add(gSharedStackMapLookup, classHandle, result);
+    }
+    return result;
+}
+
+void InterpreterStackMap::PopulateStackMap(ICorJitInfo *jitInfo, CORINFO_CLASS_HANDLE classHandle, uint32_t offset)
+{
+    unsigned size = jitInfo->getClassSize(classHandle);
+    unsigned maxGcPtrs = size / sizeof(void *);
+    if (maxGcPtrs < 1)
+        return;
+
+    uint8_t *gcPtrs = (uint8_t *)alloca(maxGcPtrs);
+    unsigned numGcPtrs = jitInfo->getClassGClayout(classHandle, gcPtrs),
+        newCapacity = m_slotCount + numGcPtrs;
+
+    m_slots = (InterpreterStackMapSlot *)realloc(m_slots, sizeof(InterpreterStackMapSlot) * newCapacity);
+
+    for (unsigned i = 0; i < numGcPtrs; i++) {
+        GcSlotFlags flags;
+
+        switch (gcPtrs[i]) {
+            case TYPE_GC_NONE:
+            case TYPE_GC_OTHER:
+                continue;
+            case TYPE_GC_BYREF:
+                flags = GC_SLOT_INTERIOR;
+                break;
+            case TYPE_GC_REF:
+                flags = GC_SLOT_BASE;
+                break;
+            default:
+                assert(false);
+                continue;
+        }
+
+        unsigned slotOffset = (sizeof(void *) * i) + offset;
+        m_slots[m_slotCount++] = { slotOffset, (unsigned)flags };
+    }
+}

src/coreclr/interpreter/stackmap.h

@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+struct InterpreterStackMapSlot
+{
+    unsigned m_offsetBytes;
+    unsigned m_gcSlotFlags;
+};
+
+class InterpreterStackMap
+{
+private:
+    void PopulateStackMap (ICorJitInfo *jitInfo, CORINFO_CLASS_HANDLE classHandle, uint32_t offset);
+
+public:
+    unsigned m_slotCount;
+    InterpreterStackMapSlot* m_slots;
+
+    InterpreterStackMap (ICorJitInfo *jitInfo, CORINFO_CLASS_HANDLE classHandle)
+        : m_slotCount(0)
+        , m_slots(nullptr)
+    {
+        PopulateStackMap(jitInfo, classHandle, 0);
+    }
+};
+
+InterpreterStackMap* getInterpreterStackMap(ICorJitInfo *jitInfo, CORINFO_CLASS_HANDLE classHandle);