[RISC-V] Use common CodeGen::genHomeRegisterParams

src/coreclr/jit/abi.cpp

@@ -258,14 +258,16 @@ bool ABIPassingInformation::HasExactlyOneStackSegment() const
 //
 bool ABIPassingInformation::IsSplitAcrossRegistersAndStack() const
 {
-    bool anyReg   = false;
-    bool anyStack = false;
-    for (unsigned i = 0; i < NumSegments; i++)
+    if (NumSegments < 2)
+        return false;
+
+    bool isFirstInReg = Segments[0].IsPassedInRegister();
+    for (unsigned i = 1; i < NumSegments; i++)
     {
-        anyReg |= Segments[i].IsPassedInRegister();
-        anyStack |= Segments[i].IsPassedOnStack();
+        if (isFirstInReg != Segments[i].IsPassedInRegister())
+            return true;
     }
-    return anyReg && anyStack;
+    return false;
 }
 
 //-----------------------------------------------------------------------------

src/coreclr/jit/abi.h

@@ -51,8 +51,8 @@ struct ABIPassingInformation
     // - On loongarch64/riscv64, structs can be passed in two registers or
     // can be split out over register and stack, giving
     // multiple register segments and a struct segment.
-    unsigned           NumSegments = 0;
-    ABIPassingSegment* Segments    = nullptr;
+    unsigned           NumSegments;
+    ABIPassingSegment* Segments;
 
     ABIPassingInformation(unsigned numSegments = 0, ABIPassingSegment* segments = nullptr)
         : NumSegments(numSegments)

src/coreclr/jit/codegen.h

@@ -284,7 +284,7 @@ class CodeGen final : public CodeGenInterface
     void genEnregisterOSRArgsAndLocals();
 #endif
 
-    void genHomeSwiftStructParameters(bool handleStack);
+    void genHomeStackParams(bool handleStack);
 
     void genCheckUseBlockInit();
 #if defined(UNIX_AMD64_ABI) && defined(FEATURE_SIMD)

src/coreclr/jit/codegencommon.cpp

@@ -2802,7 +2802,6 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 */
 
-#if !defined(TARGET_RISCV64)
 struct RegNode;
 
 struct RegNodeEdge
@@ -3346,8 +3345,6 @@ void CodeGen::genHomeRegisterParams(regNumber initReg, bool* initRegStillZeroed)
     }
 }
 
-#endif
-
 // -----------------------------------------------------------------------------
 // genGetParameterHomingTempRegisterCandidates: Get the registers that are
 // usable during register homing.
@@ -4122,32 +4119,34 @@ void CodeGen::genEnregisterOSRArgsAndLocals()
     }
 }
 
-#ifdef SWIFT_SUPPORT
+#if defined(SWIFT_SUPPORT) || defined(TARGET_RISCV64)
 
 //-----------------------------------------------------------------------------
-// genHomeSwiftStructParameters:
-//  Reassemble Swift struct parameters if necessary.
+// genHomeStackParams:
+//  Reassemble parameters if necessary.
 //
 // Parameters:
 //   handleStack - If true, reassemble the segments that were passed on the stack.
 //                 If false, reassemble the segments that were passed in registers.
 //
-void CodeGen::genHomeSwiftStructParameters(bool handleStack)
+void CodeGen::genHomeStackParams(bool handleStack)
 {
     for (unsigned lclNum = 0; lclNum < compiler->info.compArgsCount; lclNum++)
     {
+#ifdef SWIFT_SUPPORT
         if (lclNum == compiler->lvaSwiftSelfArg)
         {
             continue;
         }
+#endif
 
         LclVarDsc* dsc = compiler->lvaGetDesc(lclNum);
         if ((dsc->TypeGet() != TYP_STRUCT) || compiler->lvaIsImplicitByRefLocal(lclNum) || !dsc->lvOnFrame)
         {
             continue;
         }
 
-        JITDUMP("Homing Swift parameter V%02u: ", lclNum);
+        JITDUMP("Homing reassembled parameter V%02u: ", lclNum);
         const ABIPassingInformation& abiInfo = compiler->lvaGetParameterABIInfo(lclNum);
         DBEXEC(VERBOSE, abiInfo.Dump());
 
@@ -4185,9 +4184,13 @@ void CodeGen::genHomeSwiftStructParameters(bool handleStack)
                     case 2:
                         loadType = TYP_USHORT;
                         break;
+                    case 3:
                     case 4:
                         loadType = TYP_INT;
                         break;
+                    case 5:
+                    case 6:
+                    case 7:
                     case 8:
                         loadType = TYP_LONG;
                         break;
@@ -4224,7 +4227,7 @@ void CodeGen::genHomeSwiftStructParameters(bool handleStack)
         }
     }
 }
-#endif
+#endif // defined(SWIFT_SUPPORT) || defined(TARGET_RISCV64)
 
 /*-----------------------------------------------------------------------------
  *
@@ -5516,7 +5519,7 @@ void CodeGen::genFnProlog()
             intRegState.rsCalleeRegArgMaskLiveIn &= ~RBM_SWIFT_ERROR;
         }
 
-        genHomeSwiftStructParameters(/* handleStack */ false);
+        genHomeStackParams(/* handleStack */ false);
     }
 #endif
 
@@ -5552,6 +5555,13 @@ void CodeGen::genFnProlog()
         genEnregisterIncomingStackArgs();
     }
 
+#ifdef TARGET_RISCV64
+    if (compiler->fgFirstBBisScratch() && compiler->lvaHasAnyStackParamToReassemble())
+    {
+        genHomeStackParams(/* handleStack */ true);
+    }
+#endif
+
     /* Initialize any must-init registers variables now */
 
     if (initRegs)

src/coreclr/jit/codegenlinear.cpp

@@ -387,12 +387,12 @@ void CodeGen::genCodeForBBlist()
         compiler->compCurLifeTree = nullptr;
 
 #ifdef SWIFT_SUPPORT
-        // Reassemble Swift struct parameters on the local stack frame in the
+        // Reassemble split struct parameters on the local stack frame in the
         // scratch BB right after the prolog. There can be arbitrary amounts of
         // codegen related to doing this, so it cannot be done in the prolog.
-        if (compiler->fgBBisScratch(block) && compiler->lvaHasAnySwiftStackParamToReassemble())
+        if (compiler->fgBBisScratch(block) && compiler->lvaHasAnyStackParamToReassemble())
         {
-            genHomeSwiftStructParameters(/* handleStack */ true);
+            genHomeStackParams(/* handleStack */ true);
         }
 #endif