[RISC-V] Implement replacing safe-point call instructions under GC_STRESS (#97818)

tomeksowi · yurai007 · web-flow · commit c3940f603a42 · 2024-02-04T17:17:50.000-08:00
* [RISC-V] Fix the System.NullReferenceException: Object reference not set to an instance of an object. in Methodical_r2.sh-deep_array_nz_r.dll when DOTNET_GCStress=4.

* [RISC-V] Implement correctly replacing safe-point instructions under GC_STRESS and getting the target of call instructions jal and jalr

* Add missing assign to shift

---------

Co-authored-by: Dawid Jurczak &lt;dawid_jurek@vp.pl&gt;
diff --git a/src/coreclr/vm/gccover.cpp b/src/coreclr/vm/gccover.cpp
@@ -343,14 +343,12 @@ void ReplaceInstrAfterCall(PBYTE instrToReplace, MethodDesc* callMD)
     {
         *instrToReplace = INTERRUPT_INSTR;
     }
-#elif defined(TARGET_LOONGARCH64)
+#elif defined(TARGET_LOONGARCH64) || defined(TARGET_RISCV64)
     bool protectReturn = ispointerKind;
     if (protectReturn)
         *(DWORD*)instrToReplace = INTERRUPT_INSTR_PROTECT_RET;
     else
         *(DWORD*)instrToReplace = INTERRUPT_INSTR;
-#elif defined(TARGET_RISCV64)
-    _ASSERTE(!"not implemented for RISCV64 NYI");
 #else
     _ASSERTE(!"not implemented for platform");
 #endif
@@ -680,6 +678,15 @@ void GCCoverageInfo::SprinkleBreakpoints(
 
 #if defined(TARGET_ARM) || defined(TARGET_ARM64) || defined(TARGET_LOONGARCH64) || defined(TARGET_RISCV64)
 
+#ifdef TARGET_RISCV64
+enum
+{
+    REG_RA = 1,
+    JAL = 0x6f,
+    JALR = 0x67,
+};
+#endif
+
 #ifdef PARTIALLY_INTERRUPTIBLE_GC_SUPPORTED
 
 void replaceSafePointInstructionWithGcStressInstr(UINT32 safePointOffset, LPVOID pGCCover)
@@ -780,7 +787,15 @@ void replaceSafePointInstructionWithGcStressInstr(UINT32 safePointOffset, LPVOID
         instructionIsACallThroughRegister = TRUE;
     }
 #elif defined(TARGET_RISCV64)
-    _ASSERTE(!"not implemented for RISCV64 NYI");
+    const INT32 instr = *((INT32*)savedInstrPtr - 1);
+
+    int opcode = instr & ~(-1 << 7);
+    int linkReg = (instr >> 7) & ~(-1 << 5);
+
+    if ((opcode == JAL) && (linkReg == REG_RA))
+        instructionIsACallThroughImmediate = TRUE;
+    else if ((opcode == JALR) && (linkReg == REG_RA))
+        instructionIsACallThroughRegister = TRUE;
 #endif  // _TARGET_XXXX_
 
     // safe point must always be after a call instruction
@@ -1028,7 +1043,38 @@ static PBYTE getTargetOfCall(PBYTE instrPtr, PCONTEXT regs, PBYTE* nextInstr) {
         return 0; // Fail
     }
 #elif defined(TARGET_RISCV64)
-    _ASSERTE(!"not implemented for RISCV64 NYI");
+    INT32 instr = *reinterpret_cast<INT32*>(instrPtr);
+    int opcode = instr & ~(-1 << 7);
+    int linkReg = (instr >> 7) & ~(-1 << 5);
+
+    if ((opcode == JAL) && (linkReg == REG_RA))
+    {
+        // call through immediate
+        int imm = (instr >> 12);
+
+        int bits12to19 = imm & ~(-1 << 8);
+        imm >>= 8;
+        int bit11 = imm & ~(-1 << 1);
+        imm >>= 1;
+        int bits1to10 = imm & ~(-1 << 10);
+        imm >>= 10;
+        int signBits = imm;
+
+        int offset = (bits1to10 << 1) | (bit11 << 11) | (bits12to19 << 12) | (signBits << 20);
+
+        *nextInstr = instrPtr + 4;
+        return PC + offset;
+    }
+    else if ((opcode == JALR) && (linkReg == REG_RA))
+    {
+        // call through register
+        *nextInstr = instrPtr + 4;  // TODO: adjust once we support "C" (compressed instructions)
+
+        int offset = (instr >> 20);
+        int jumpBaseReg = (instr >> 15) & ~(-1 << 5);
+        size_t value = (getRegVal(jumpBaseReg, regs) + offset) & ~(size_t)1;
+        return (BYTE *)value;
+    }
 #endif
 
 #ifdef TARGET_AMD64
@@ -1495,7 +1541,7 @@ void DoGcStress (PCONTEXT regs, NativeCodeVersion nativeCodeVersion)
     atCall = (instrVal == INTERRUPT_INSTR_CALL);
     afterCallProtect[0] = (instrVal == INTERRUPT_INSTR_PROTECT_RET);
 #elif defined(TARGET_RISCV64)
-    _ASSERTE(!"not implemented for RISCV64 NYI");
+
     DWORD instrVal = *(DWORD *)instrPtr;
     forceStack[6] = &instrVal;            // This is so I can see it fastchecked
 
diff --git a/src/coreclr/vm/gccover.h b/src/coreclr/vm/gccover.h
@@ -113,10 +113,10 @@ typedef DPTR(GCCoverageInfo) PTR_GCCoverageInfo; // see code:GCCoverageInfo::sav
 #define INTERRUPT_INSTR_PROTECT_RET     0xffffff0d
 
 #elif defined(TARGET_RISCV64)
-// TODO-RISCV64: Confirm the following encodings are undefined
-#define INTERRUPT_INSTR                 0x20000000
-#define INTERRUPT_INSTR_CALL            0x20010000
-#define INTERRUPT_INSTR_PROTECT_RET     0x20020000
+// The following encodings are undefined.
+#define INTERRUPT_INSTR                 0x20000000  // unimp, fld
+#define INTERRUPT_INSTR_CALL            0x20010000  // unimp, jal
+#define INTERRUPT_INSTR_PROTECT_RET     0x20020000  // unimp, fld
 
 #endif // _TARGET_*
 
@@ -181,8 +181,15 @@ inline bool IsGcCoverageInterruptInstructionVal(UINT32 instrVal)
         }
     }
 #elif defined(TARGET_RISCV64)
-    _ASSERTE(!"RISCV64:NYI");
-    return false;
+    switch (instrVal)
+    {
+    case INTERRUPT_INSTR:
+    case INTERRUPT_INSTR_CALL:
+    case INTERRUPT_INSTR_PROTECT_RET:
+        return true;
+    default:
+        return false;
+    }
 
 #else // x64 and x86
 
