Add GC tracking for APX EGPRs for LINUX AMD64

Author: khushal1996

src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/AsmOffsets.cs

@@ -16,7 +16,7 @@ class AsmOffsets
     // Debug build offsets
 #if TARGET_AMD64
 #if TARGET_UNIX
-    public const int SIZEOF__REGDISPLAY = 0x1b90;
+    public const int SIZEOF__REGDISPLAY = 0x1c10;
     public const int OFFSETOF__REGDISPLAY__SP = 0x1b78;
     public const int OFFSETOF__REGDISPLAY__ControlPC = 0x1b80;
 #else // TARGET_UNIX
@@ -82,7 +82,7 @@ class AsmOffsets
     // Release build offsets
 #if TARGET_AMD64
 #if TARGET_UNIX
-    public const int SIZEOF__REGDISPLAY = 0x1b80;
+    public const int SIZEOF__REGDISPLAY = 0x1c00;
     public const int OFFSETOF__REGDISPLAY__SP = 0x1b70;
     public const int OFFSETOF__REGDISPLAY__ControlPC = 0x1b78;
 #else // TARGET_UNIX

src/coreclr/debug/ee/debugger.cpp

@@ -16850,6 +16850,26 @@ void FuncEvalFrame::UpdateRegDisplay_Impl(const PREGDISPLAY pRD, bool updateFloa
     pRD->pCurrentContextPointers->R14 = &(pDE->m_context.R14);
     pRD->pCurrentContextPointers->R15 = &(pDE->m_context.R15);
 
+#if defined(TARGET_UNIX)
+    // This would mean we need to update winnt.h in windows sdk.
+    pRD->volatileCurrContextPointers.R16 = &(pDE->m_context.R16);
+    pRD->volatileCurrContextPointers.R17 = &(pDE->m_context.R17);
+    pRD->volatileCurrContextPointers.R18 = &(pDE->m_context.R18);
+    pRD->volatileCurrContextPointers.R19 = &(pDE->m_context.R19);
+    pRD->volatileCurrContextPointers.R20 = &(pDE->m_context.R20);
+    pRD->volatileCurrContextPointers.R21 = &(pDE->m_context.R21);
+    pRD->volatileCurrContextPointers.R22 = &(pDE->m_context.R22);
+    pRD->volatileCurrContextPointers.R23 = &(pDE->m_context.R23);
+    pRD->volatileCurrContextPointers.R24 = &(pDE->m_context.R24);
+    pRD->volatileCurrContextPointers.R25 = &(pDE->m_context.R25);
+    pRD->volatileCurrContextPointers.R26 = &(pDE->m_context.R26);
+    pRD->volatileCurrContextPointers.R27 = &(pDE->m_context.R27);
+    pRD->volatileCurrContextPointers.R28 = &(pDE->m_context.R28);
+    pRD->volatileCurrContextPointers.R29 = &(pDE->m_context.R29);
+    pRD->volatileCurrContextPointers.R30 = &(pDE->m_context.R30);
+    pRD->volatileCurrContextPointers.R31 = &(pDE->m_context.R31);
+#endif // TARGET_UNIX
+
     // SyncRegDisplayToCurrentContext() sets the pRD->SP and pRD->ControlPC on AMD64.
     SyncRegDisplayToCurrentContext(pRD);
 

src/coreclr/debug/inc/dbgtargetcontext.h

@@ -256,6 +256,31 @@ typedef struct DECLSPEC_ALIGN(16) {
     DWORD64 R14;
     DWORD64 R15;
 
+// #if defined(TARGET_UNIX)
+//     //EGPRs for APX
+//     union {
+//         struct {
+//             DWORD64 R16;
+//             DWORD64 R17;
+//             DWORD64 R18;
+//             DWORD64 R19;
+//             DWORD64 R20;
+//             DWORD64 R21;
+//             DWORD64 R22;
+//             DWORD64 R23;
+//             DWORD64 R24;
+//             DWORD64 R25;
+//             DWORD64 R26;
+//             DWORD64 R27;
+//             DWORD64 R28;
+//             DWORD64 R29;
+//             DWORD64 R30;
+//             DWORD64 R31;
+//         };
+//         DWORD64 R[16];
+//     };
+// #endif // TARGET_UNIX
+
     DWORD64 Rip;
 
     union {

src/coreclr/gcinfo/gcinfodumper.cpp

@@ -131,6 +131,28 @@ BOOL GcInfoDumper::ReportPointerRecord (
         REG(r13, R13),
         REG(r14, R14),
         REG(r15, R15),
+#if defined(TARGET_UNIX)
+#undef REG
+#define REG(reg, field) { offsetof(Amd64VolatileContextPointer, field) }
+        REG(r16, R16),
+        REG(r17, R17),
+        REG(r18, R18),
+        REG(r19, R19),
+        REG(r20, R20),
+        REG(r21, R21),
+        REG(r22, R22),
+        REG(r23, R23),
+        REG(r24, R24),
+        REG(r25, R25),
+        REG(r26, R26),
+        REG(r27, R27),
+        REG(r28, R28),
+        REG(r29, R29),
+        REG(r30, R30),
+        REG(r31, R31),
+        REG(r16, R16),
+        REG(r16, R16),
+#endif // TARGET_UNIX
 #elif defined(TARGET_ARM)
 #undef REG
 #define REG(reg, field) { offsetof(ArmVolatileContextPointer, field) }
@@ -294,7 +316,9 @@ PORTABILITY_ASSERT("GcInfoDumper::ReportPointerRecord is not implemented on this
 
 #if defined(TARGET_ARM) || defined(TARGET_ARM64) || defined(TARGET_RISCV64) || defined(TARGET_LOONGARCH64)
     BYTE* pContext = (BYTE*)&(pRD->volatileCurrContextPointers);
-#else
+#elif defined(TARGET_AMD64) && defined(TARGET_UNIX) // TARGET_ARM || TARGET_ARM64 ||TARGET_RISCV64 || TARGET_LOONGARCH64
+    BYTE* pContext = (BYTE*)&(pRD->volatileCurrContextPointers);
+#else // TARGET_AMD64 && TARGET_UNIX
     BYTE* pContext = (BYTE*)pRD->pCurrentContext;
 #endif
 
@@ -664,6 +688,13 @@ GcInfoDumper::EnumerateStateChangesResults GcInfoDumper::EnumerateStateChanges (
         *(ppCurrentRax + iReg) = &regdisp.pCurrentContext->Rax + iReg;
         *(ppCallerRax  + iReg) = &regdisp.pCallerContext ->Rax + iReg;
     }
+#if defined(TARGET_UNIX)
+    ULONG64 **ppVolatileReg = &regdisp.volatileCurrContextPointers.R16;
+    for (iReg = 0; iReg < 16; iReg++)
+    {
+        *(ppVolatileReg+iReg) = &regdisp.pCurrentContext->R16 + iReg;
+    }
+#endif // TARGET_UNIX
 #elif defined(TARGET_ARM)
     FILL_REGS(pCurrentContext->R0, 16);
     FILL_REGS(pCallerContext->R0, 16);

src/coreclr/inc/gcinfotypes.h

@@ -595,16 +595,16 @@ struct AMD64GcInfoEncoding {
     static const int SIZE_OF_STACK_AREA_ENCBASE = 3;
     static const int SIZE_OF_EDIT_AND_CONTINUE_PRESERVED_AREA_ENCBASE = 4;
     static const int REVERSE_PINVOKE_FRAME_ENCBASE = 6;
-    static const int NUM_REGISTERS_ENCBASE = 2;
+    static const int NUM_REGISTERS_ENCBASE = 3;
     static const int NUM_STACK_SLOTS_ENCBASE = 2;
     static const int NUM_UNTRACKED_SLOTS_ENCBASE = 1;
     static const int NORM_PROLOG_SIZE_ENCBASE = 5;
     static const int NORM_EPILOG_SIZE_ENCBASE = 3;
     static const int NORM_CODE_OFFSET_DELTA_ENCBASE = 3;
     static const int INTERRUPTIBLE_RANGE_DELTA1_ENCBASE = 6;
     static const int INTERRUPTIBLE_RANGE_DELTA2_ENCBASE = 6;
-    static const int REGISTER_ENCBASE = 3;
-    static const int REGISTER_DELTA_ENCBASE = 2;
+    static const int REGISTER_ENCBASE = 5;
+    static const int REGISTER_DELTA_ENCBASE = 5;
     static const int STACK_SLOT_ENCBASE = 6;
     static const int STACK_SLOT_DELTA_ENCBASE = 4;
     static const int NUM_SAFE_POINTS_ENCBASE = 2;

src/coreclr/inc/regdisp.h

@@ -197,6 +197,33 @@ typedef struct _Arm64VolatileContextPointer
 } Arm64VolatileContextPointer;
 #endif //TARGET_ARM64
 
+#if defined(TARGET_AMD64)
+typedef struct _Amd64VolatileContextPointer
+{
+    union {
+        struct {
+            PDWORD64 R16;
+            PDWORD64 R17;
+            PDWORD64 R18;
+            PDWORD64 R19;
+            PDWORD64 R20;
+            PDWORD64 R21;
+            PDWORD64 R22;
+            PDWORD64 R23;
+            PDWORD64 R24;
+            PDWORD64 R25;
+            PDWORD64 R26;
+            PDWORD64 R27;
+            PDWORD64 R28;
+            PDWORD64 R29;
+            PDWORD64 R30;
+            PDWORD64 R31;
+        };
+        PDWORD64 R[16];
+    };
+} Amd64VolatileContextPointer;
+#endif //TARGET_AMD64
+
 #if defined(TARGET_LOONGARCH64)
 typedef struct _LoongArch64VolatileContextPointer
 {
@@ -253,6 +280,10 @@ struct REGDISPLAY : public REGDISPLAY_BASE {
     LoongArch64VolatileContextPointer    volatileCurrContextPointers;
 #endif
 
+#if defined(TARGET_AMD64) && defined(TARGET_UNIX)
+    Amd64VolatileContextPointer    volatileCurrContextPointers;
+#endif
+
 #ifdef TARGET_RISCV64
     RiscV64VolatileContextPointer    volatileCurrContextPointers;
 #endif
@@ -563,7 +594,11 @@ inline void FillRegDisplay(const PREGDISPLAY pRD, PT_CONTEXT pctx, PT_CONTEXT pC
     // Fill volatile context pointers. They can be used by GC in the case of the leaf frame
     for (int i=0; i < 18; i++)
         pRD->volatileCurrContextPointers.X[i] = &pctx->X[i];
-#elif defined(TARGET_LOONGARCH64) // TARGET_ARM64
+#elif defined(TARGET_AMD64) && defined(TARGET_UNIX) // TARGET_ARM64
+    // Fill volatile context pointers. They can be used by GC in the case of the leaf frame
+    for (int i=0; i < 16; i++)
+        pRD->volatileCurrContextPointers.R[i] = &pctx->R[i];
+#elif defined(TARGET_LOONGARCH64) // TARGET_ADM64 && TARGET_UNIX
     pRD->volatileCurrContextPointers.A0 = &pctx->A0;
     pRD->volatileCurrContextPointers.A1 = &pctx->A1;
     pRD->volatileCurrContextPointers.A2 = &pctx->A2;
@@ -664,7 +699,7 @@ inline size_t * getRegAddr (unsigned regNum, PTR_CONTEXT regs)
 
     return (PTR_size_t)(PTR_BYTE(regs) + OFFSET_OF_REGISTERS[regNum]);
 #elif defined(TARGET_AMD64)
-    _ASSERTE(regNum < 16);
+    _ASSERTE(regNum < 32);
     return (size_t *)&regs->Rax + regNum;
 #elif defined(TARGET_ARM)
         _ASSERTE(regNum < 16);

src/coreclr/jit/compiler.h

@@ -9716,6 +9716,12 @@ class Compiler
     //
     bool canUseApxEncoding() const
     {
+#ifdef DEBUG
+        if (JitConfig.JitBypassApxCheck())
+        {
+            return true;
+        }
+#endif
         return compOpportunisticallyDependsOn(InstructionSet_APX);
     }
 

src/coreclr/jit/jitconfigvalues.h

@@ -372,6 +372,7 @@ RELEASE_CONFIG_INTEGER(JitNoInline, "JitNoInline", 0)
 
 #if defined(DEBUG)
 CONFIG_INTEGER(JitStressRex2Encoding, "JitStressRex2Encoding", 0) // Enable rex2 encoding for compatible instructions.
+CONFIG_INTEGER(JitBypassApxCheck,     "JitBypassApxCheck",     0) // Enable apx for testing
 CONFIG_INTEGER(JitStressPromotedEvexEncoding, "JitStressPromotedEvexEncoding", 0) // Enable promoted EVEX encoding for
                                                                                   // compatible instructions.
 #endif

src/coreclr/nativeaot/Runtime/amd64/AsmOffsetsCpu.h

@@ -73,28 +73,28 @@ PLAT_ASM_OFFSET(90, REGDISPLAY, Xmm)
 
 #else // !UNIX_AMD64_ABI
 
-PLAT_ASM_SIZEOF(190, ExInfo)
+PLAT_ASM_SIZEOF(210, ExInfo)
 PLAT_ASM_OFFSET(0, ExInfo, m_pPrevExInfo)
 PLAT_ASM_OFFSET(8, ExInfo, m_pExContext)
 PLAT_ASM_OFFSET(10, ExInfo, m_exception)
 PLAT_ASM_OFFSET(18, ExInfo, m_kind)
 PLAT_ASM_OFFSET(19, ExInfo, m_passNumber)
 PLAT_ASM_OFFSET(1c, ExInfo, m_idxCurClause)
 PLAT_ASM_OFFSET(20, ExInfo, m_frameIter)
-PLAT_ASM_OFFSET(188, ExInfo, m_notifyDebuggerSP)
+PLAT_ASM_OFFSET(208, ExInfo, m_notifyDebuggerSP)
 
 PLAT_ASM_OFFSET(0, PInvokeTransitionFrame, m_RIP)
 PLAT_ASM_OFFSET(8, PInvokeTransitionFrame, m_FramePointer)
 PLAT_ASM_OFFSET(10, PInvokeTransitionFrame, m_pThread)
 PLAT_ASM_OFFSET(18, PInvokeTransitionFrame, m_Flags)
 PLAT_ASM_OFFSET(20, PInvokeTransitionFrame, m_PreservedRegs)
 
-PLAT_ASM_SIZEOF(168, StackFrameIterator)
+PLAT_ASM_SIZEOF(1e8, StackFrameIterator)
 PLAT_ASM_OFFSET(10, StackFrameIterator, m_FramePointer)
 PLAT_ASM_OFFSET(18, StackFrameIterator, m_ControlPC)
 PLAT_ASM_OFFSET(20, StackFrameIterator, m_RegDisplay)
-PLAT_ASM_OFFSET(158, StackFrameIterator, m_OriginalControlPC)
-PLAT_ASM_OFFSET(160, StackFrameIterator, m_pPreviousTransitionFrame)
+PLAT_ASM_OFFSET(1d8, StackFrameIterator, m_OriginalControlPC)
+PLAT_ASM_OFFSET(1e0, StackFrameIterator, m_pPreviousTransitionFrame)
 
 PLAT_ASM_SIZEOF(50, PAL_LIMITED_CONTEXT)
 PLAT_ASM_OFFSET(0, PAL_LIMITED_CONTEXT, IP)
@@ -110,8 +110,8 @@ PLAT_ASM_OFFSET(38, PAL_LIMITED_CONTEXT, R13)
 PLAT_ASM_OFFSET(40, PAL_LIMITED_CONTEXT, R14)
 PLAT_ASM_OFFSET(48, PAL_LIMITED_CONTEXT, R15)
 
-PLAT_ASM_SIZEOF(88, REGDISPLAY)
-PLAT_ASM_OFFSET(78, REGDISPLAY, SP)
+PLAT_ASM_SIZEOF(108, REGDISPLAY)
+PLAT_ASM_OFFSET(f8, REGDISPLAY, SP)
 
 PLAT_ASM_OFFSET(18, REGDISPLAY, pRbx)
 PLAT_ASM_OFFSET(20, REGDISPLAY, pRbp)

src/coreclr/nativeaot/Runtime/regdisplay.h

@@ -27,6 +27,24 @@ struct REGDISPLAY
     PTR_uintptr_t pR13;
     PTR_uintptr_t pR14;
     PTR_uintptr_t pR15;
+#if defined(TARGET_UNIX)
+    PTR_uintptr_t pR16;
+    PTR_uintptr_t pR17;
+    PTR_uintptr_t pR18;
+    PTR_uintptr_t pR19;
+    PTR_uintptr_t pR20;
+    PTR_uintptr_t pR21;
+    PTR_uintptr_t pR22;
+    PTR_uintptr_t pR23;
+    PTR_uintptr_t pR24;
+    PTR_uintptr_t pR25;
+    PTR_uintptr_t pR26;
+    PTR_uintptr_t pR27;
+    PTR_uintptr_t pR28;
+    PTR_uintptr_t pR29;
+    PTR_uintptr_t pR30;
+    PTR_uintptr_t pR31;
+#endif //TARGET_UNIX
 #endif // TARGET_AMD64
 
     uintptr_t   SP;