[RISC-V][x64] WiP: Passing empty struct fields

src/coreclr/inc/corinfo.h

@@ -356,6 +356,111 @@ enum StructFloatFieldInfoFlags
     STRUCT_HAS_8BYTES_FIELDS_MASK = (STRUCT_FIRST_FIELD_SIZE_IS8 | STRUCT_SECOND_FIELD_SIZE_IS8),
 };
 
+// Bitfields for FpStructInRegistersInfo::flags
+namespace FpStruct
+{
+    enum Flags
+    {
+        // Positions of bitfields
+        PosOnlyOne      = 0,
+        PosBothFloat    = 1,
+        PosFloat1st     = 2,
+        PosSizeShift1st = 3, // 2 bits
+        PosFloat2nd     = 5,
+        PosSizeShift2nd = 6, // 2 bits
+        PosGcRef        = 8,
+        PosGcByRef      = 9,
+
+        UseIntCallConv = 0, // struct is passed according to integer calling convention
+
+        // The bitfields
+        OnlyOne      =    1 << PosOnlyOne,      // has only one field, which is floating-point
+        BothFloat    =    1 << PosBothFloat,    // has two fields, both are floating-point
+        Float1st     =    1 << PosFloat1st,     // has two fields, 1st is floating (and 2nd is integer)
+        SizeShift1st = 0b11 << PosSizeShift1st, // log2(size) of 1st field
+        Float2nd     =    1 << PosFloat2nd,     // has two fields, 2nd is floating (and 1st is integer)
+        SizeShift2nd = 0b11 << PosSizeShift2nd, // log2(size) of 2nd field
+        GcRef        =    1 << PosGcRef,        // the integer field is a GC object reference
+        GcByRef      =    1 << PosGcByRef,      // the integer field is a GC interior pointer
+        // Note: flags OnlyOne, BothFloat, Float1st, and Float2nd are mutually exclusive
+        // Note: flags GcRef, and ByRef are mutually exclusive and may only co-exist with either Float1st or Float2nd
+    };
+}
+
+// On RISC-V and LoongArch a struct with up to two non-empty fields, at least one of them floating-point,
+// can be passed in registers according to hardware FP calling convention. FpStructInRegistersInfo represents
+// passing information for such parameters.
+struct FpStructInRegistersInfo
+{
+    FpStruct::Flags flags;
+    uint32_t offset1st;
+    uint32_t offset2nd;
+
+    unsigned GetSizeShift1st() const
+    {
+        return (flags >> FpStruct::PosSizeShift1st) & 0b11;
+    }
+
+    unsigned GetSizeShift2nd() const
+    {
+        return (flags >> FpStruct::PosSizeShift2nd) & 0b11;
+    }
+
+    unsigned GetSize1st() const
+    {
+        return 1u << GetSizeShift1st();
+    }
+
+    unsigned GetSize2nd() const
+    {
+        return 1u << GetSizeShift2nd();
+    }
+
+    bool IsSize1st8() const
+    {
+        return (flags & FpStruct::SizeShift1st) == (3 << FpStruct::PosSizeShift1st);
+    }
+
+    bool IsSize2nd8() const
+    {
+        return (flags & FpStruct::SizeShift2nd) == (3 << FpStruct::PosSizeShift2nd);
+    }
+
+    StructFloatFieldInfoFlags ToOldFlags() const
+    {
+        return StructFloatFieldInfoFlags(
+            ((flags & FpStruct::OnlyOne) ? STRUCT_FLOAT_FIELD_ONLY_ONE : 0) |
+            ((flags & FpStruct::BothFloat) ? STRUCT_FLOAT_FIELD_ONLY_TWO : 0) |
+            ((flags & FpStruct::Float1st) ? STRUCT_FLOAT_FIELD_FIRST : 0) |
+            ((flags & FpStruct::Float2nd) ? STRUCT_FLOAT_FIELD_SECOND : 0) |
+            (IsSize1st8() ? STRUCT_FIRST_FIELD_SIZE_IS8 : 0) |
+            (IsSize2nd8() ? STRUCT_SECOND_FIELD_SIZE_IS8 : 0));
+    }
+
+    static FpStructInRegistersInfo FromOldFlags(StructFloatFieldInfoFlags flags)
+    {
+        unsigned sizeShift1st = (flags & STRUCT_FIRST_FIELD_SIZE_IS8) ? 3 : 2;
+        unsigned sizeShift2nd = (flags & STRUCT_SECOND_FIELD_SIZE_IS8) ? 3 : 2;
+        bool hasTwo = !(flags & STRUCT_FLOAT_FIELD_ONLY_ONE);
+        return {
+            FpStruct::Flags(
+                ((flags & STRUCT_FLOAT_FIELD_ONLY_ONE) ? FpStruct::OnlyOne : 0) |
+                ((flags & STRUCT_FLOAT_FIELD_ONLY_TWO) ? FpStruct::BothFloat : 0) |
+                ((flags & STRUCT_FLOAT_FIELD_FIRST) ? FpStruct::Float1st : 0) |
+                ((flags & STRUCT_FLOAT_FIELD_SECOND) ? FpStruct::Float2nd : 0) |
+                (sizeShift1st << FpStruct::PosSizeShift1st) |
+                (hasTwo ? (sizeShift2nd << FpStruct::PosSizeShift2nd) : 0)
+                // No GC ref info in old flags
+            ),
+            // Lacking actual field offsets, assume fields are naturally aligned without empty fields or padding
+            0,
+            hasTwo ? (1u << (sizeShift1st > sizeShift2nd ? sizeShift1st : sizeShift2nd)) : 0,
+        };
+    }
+};
+
+static_assert(sizeof(FpStructInRegistersInfo) == 3 * sizeof(uint32_t), "");
+
 #include "corinfoinstructionset.h"
 
 // CorInfoHelpFunc defines the set of helpers (accessed via the ICorDynamicInfo::getHelperFtn())
@@ -3075,7 +3180,7 @@ class ICorStaticInfo
     virtual void getSwiftLowering(CORINFO_CLASS_HANDLE structHnd, CORINFO_SWIFT_LOWERING* pLowering) = 0;
 
     virtual uint32_t getLoongArch64PassStructInRegisterFlags(CORINFO_CLASS_HANDLE cls) = 0;
-    virtual uint32_t getRISCV64PassStructInRegisterFlags(CORINFO_CLASS_HANDLE cls) = 0;
+    virtual FpStructInRegistersInfo getRiscV64PassFpStructInRegistersInfo(CORINFO_CLASS_HANDLE cls) = 0;
 };
 
 /*****************************************************************************

src/coreclr/inc/icorjitinfoimpl_generated.h

@@ -520,7 +520,7 @@ void getSwiftLowering(
 uint32_t getLoongArch64PassStructInRegisterFlags(
           CORINFO_CLASS_HANDLE structHnd) override;
 
-uint32_t getRISCV64PassStructInRegisterFlags(
+FpStructInRegistersInfo getRiscV64PassFpStructInRegistersInfo(
           CORINFO_CLASS_HANDLE structHnd) override;
 
 uint32_t getThreadTLSIndex(

src/coreclr/inc/jiteeversionguid.h

@@ -43,11 +43,11 @@ typedef const GUID *LPCGUID;
 #define GUID_DEFINED
 #endif // !GUID_DEFINED
 
-constexpr GUID JITEEVersionIdentifier = { /* e428e66d-5e0e-4320-ad8a-fa5a50f6da07 */
-    0xe428e66d,
-    0x5e0e,
-    0x4320,
-    {0xad, 0x8a, 0xfa, 0x5a, 0x50, 0xf6, 0xda, 0x07}
+constexpr GUID JITEEVersionIdentifier = { /* 1907f831-d9c8-4b42-a549-0cdce990d1c6 */
+    0x1907f831,
+    0xd9c8,
+    0x4b42,
+    {0xa5, 0x49, 0x0c, 0xdc, 0xe9, 0x90, 0xd1, 0xc6}
   };
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////

src/coreclr/jit/ICorJitInfo_names_generated.h

@@ -130,7 +130,7 @@ DEF_CLR_API(getMethodHash)
 DEF_CLR_API(getSystemVAmd64PassStructInRegisterDescriptor)
 DEF_CLR_API(getSwiftLowering)
 DEF_CLR_API(getLoongArch64PassStructInRegisterFlags)
-DEF_CLR_API(getRISCV64PassStructInRegisterFlags)
+DEF_CLR_API(getRiscV64PassFpStructInRegistersInfo)
 DEF_CLR_API(getThreadTLSIndex)
 DEF_CLR_API(getAddrOfCaptureThreadGlobal)
 DEF_CLR_API(getHelperFtn)

src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp

@@ -1238,12 +1238,12 @@ uint32_t WrapICorJitInfo::getLoongArch64PassStructInRegisterFlags(
     return temp;
 }
 
-uint32_t WrapICorJitInfo::getRISCV64PassStructInRegisterFlags(
+FpStructInRegistersInfo WrapICorJitInfo::getRiscV64PassFpStructInRegistersInfo(
           CORINFO_CLASS_HANDLE structHnd)
 {
-    API_ENTER(getRISCV64PassStructInRegisterFlags);
-    uint32_t temp = wrapHnd->getRISCV64PassStructInRegisterFlags(structHnd);
-    API_LEAVE(getRISCV64PassStructInRegisterFlags);
+    API_ENTER(getRiscV64PassFpStructInRegistersInfo);
+    FpStructInRegistersInfo temp = wrapHnd->getRiscV64PassFpStructInRegistersInfo(structHnd);
+    API_LEAVE(getRiscV64PassFpStructInRegistersInfo);
     return temp;
 }
 

src/coreclr/jit/codegencommon.cpp

@@ -3170,6 +3170,10 @@ var_types CodeGen::genParamStackType(LclVarDsc* dsc, const ABIPassingSegment& se
             // can always use the full register size here. This allows us to
             // use stp more often.
             return TYP_I_IMPL;
+#elif defined(TARGET_RISCV64) || defined(TARGET_LOONGARCH64)
+            // On RISC-V/LoongArch struct { struct{} e1,e2,e3; byte b; float f; } is passed in 2 registers so the
+            // load/store instruction for 'b' needs to be exact in size or it will overlap 'f'.
+            return seg.GetRegisterType();
 #else
             return genActualType(seg.GetRegisterType());
 #endif
@@ -7351,16 +7355,17 @@ void CodeGen::genStructReturn(GenTree* treeNode)
 #if defined(TARGET_LOONGARCH64) || defined(TARGET_RISCV64)
         // On LoongArch64, for a struct like "{ int, double }", "retTypeDesc" will be "{ TYP_INT, TYP_DOUBLE }",
         // i. e. not include the padding for the first field, and so the general loop below won't work.
-        var_types type  = retTypeDesc.GetReturnRegType(0);
-        regNumber toReg = retTypeDesc.GetABIReturnReg(0, compiler->info.compCallConv);
-        GetEmitter()->emitIns_R_S(ins_Load(type), emitTypeSize(type), toReg, lclNode->GetLclNum(), 0);
+        var_types type   = retTypeDesc.GetReturnRegType(0);
+        regNumber toReg  = retTypeDesc.GetABIReturnReg(0, compiler->info.compCallConv);
+        unsigned  offset = retTypeDesc.GetReturnFieldOffset(0);
+        GetEmitter()->emitIns_R_S(ins_Load(type), emitTypeSize(type), toReg, lclNode->GetLclNum(), offset);
         if (regCount > 1)
         {
             assert(regCount == 2);
-            int offset = genTypeSize(type);
-            type       = retTypeDesc.GetReturnRegType(1);
-            offset     = (int)((unsigned int)offset < genTypeSize(type) ? genTypeSize(type) : offset);
-            toReg      = retTypeDesc.GetABIReturnReg(1, compiler->info.compCallConv);
+            assert(offset + genTypeSize(type) <= retTypeDesc.GetReturnFieldOffset(1));
+            type   = retTypeDesc.GetReturnRegType(1);
+            toReg  = retTypeDesc.GetABIReturnReg(1, compiler->info.compCallConv);
+            offset = retTypeDesc.GetReturnFieldOffset(1);
             GetEmitter()->emitIns_R_S(ins_Load(type), emitTypeSize(type), toReg, lclNode->GetLclNum(), offset);
         }
 #else // !TARGET_LOONGARCH64 && !TARGET_RISCV64
@@ -7635,6 +7640,11 @@ void CodeGen::genMultiRegStoreToLocal(GenTreeLclVar* lclNode)
         assert(regCount == varDsc->lvFieldCnt);
     }
 
+#if defined(TARGET_LOONGARCH64) || defined(TARGET_RISCV64)
+    // genMultiRegStoreToLocal is only used for calls on RISC-V and LoongArch
+    const ReturnTypeDesc* returnTypeDesc = actualOp1->AsCall()->GetReturnTypeDesc();
+#endif
+
 #ifdef SWIFT_SUPPORT
     const uint32_t* offsets = nullptr;
     if (actualOp1->IsCall() && (actualOp1->AsCall()->GetUnmanagedCallConv() == CorInfoCallConvExtension::Swift))
@@ -7685,8 +7695,8 @@ void CodeGen::genMultiRegStoreToLocal(GenTreeLclVar* lclNode)
         else
         {
 #if defined(TARGET_LOONGARCH64) || defined(TARGET_RISCV64)
-            // should consider the padding field within a struct.
-            offset = (offset % genTypeSize(srcType)) ? AlignUp(offset, genTypeSize(srcType)) : offset;
+            // Should consider the padding, empty struct fields, etc within a struct.
+            offset = returnTypeDesc->GetReturnFieldOffset(i);
 #endif
 #ifdef SWIFT_SUPPORT
             if (offsets != nullptr)

src/coreclr/jit/compiler.cpp

@@ -743,7 +743,7 @@ var_types Compiler::getArgTypeForStruct(CORINFO_CLASS_HANDLE clsHnd,
 
                 // Otherwise we pass this struct by value on the stack
                 // setup wbPassType and useType indicate that this is passed by value according to the X86/ARM32 ABI
-                // On LOONGARCH64 struct that is 1-16 bytes is passed by value in one/two register(s)
+                // On LOONGARCH64 and RISCV64 struct that is 1-16 bytes is returned by value in one/two register(s)
                 howToPassStruct = SPK_ByValue;
                 useType         = TYP_STRUCT;
 
@@ -757,7 +757,6 @@ var_types Compiler::getArgTypeForStruct(CORINFO_CLASS_HANDLE clsHnd,
         else // (structSize > MAX_PASS_MULTIREG_BYTES)
         {
             // We have a (large) struct that can't be replaced with a "primitive" type
-            // and can't be passed in multiple registers
 
 #if defined(TARGET_X86) || defined(TARGET_ARM) || defined(UNIX_AMD64_ABI)
 
@@ -767,11 +766,23 @@ var_types Compiler::getArgTypeForStruct(CORINFO_CLASS_HANDLE clsHnd,
             useType         = TYP_STRUCT;
 
 #elif defined(TARGET_AMD64) || defined(TARGET_ARM64) || defined(TARGET_LOONGARCH64) || defined(TARGET_RISCV64)
-
-            // Otherwise we pass this struct by reference to a copy
-            // setup wbPassType and useType indicate that this is passed using one register (by reference to a copy)
-            howToPassStruct = SPK_ByReference;
-            useType         = TYP_UNKNOWN;
+#ifdef TARGET_RISCV64
+            // Struct larger than 16 can still be passed in registers according to FP call conv if it has empty fields
+            // or more padding
+            uint32_t flags = info.compCompHnd->getRiscV64PassFpStructInRegistersInfo(clsHnd).ToOldFlags();
+            if (flags != STRUCT_NO_FLOAT_FIELD)
+            {
+                howToPassStruct = SPK_ByValue;
+                useType         = TYP_STRUCT;
+            }
+            else
+#endif
+            {
+                // Otherwise we pass this struct by reference to a copy
+                // setup wbPassType and useType indicate that this is passed using one register (by reference to a copy)
+                howToPassStruct = SPK_ByReference;
+                useType         = TYP_UNKNOWN;
+            }
 
 #else //  TARGET_XXX
 
@@ -945,20 +956,17 @@ var_types Compiler::getReturnTypeForStruct(CORINFO_CLASS_HANDLE     clsHnd,
     }
 
 #elif defined(TARGET_RISCV64)
-    if (structSize <= (TARGET_POINTER_SIZE * 2))
+    uint32_t floatFieldFlags = (uint32_t)info.compCompHnd->getRiscV64PassFpStructInRegistersInfo(clsHnd).ToOldFlags();
+    if ((floatFieldFlags & STRUCT_FLOAT_FIELD_ONLY_ONE) != 0)
     {
-        uint32_t floatFieldFlags = info.compCompHnd->getRISCV64PassStructInRegisterFlags(clsHnd);
-
-        if ((floatFieldFlags & STRUCT_FLOAT_FIELD_ONLY_ONE) != 0)
-        {
-            howToReturnStruct = SPK_PrimitiveType;
-            useType           = (structSize > 4) ? TYP_DOUBLE : TYP_FLOAT;
-        }
-        else if (floatFieldFlags & (STRUCT_HAS_FLOAT_FIELDS_MASK ^ STRUCT_FLOAT_FIELD_ONLY_ONE))
-        {
-            howToReturnStruct = SPK_ByValue;
-            useType           = TYP_STRUCT;
-        }
+        howToReturnStruct = SPK_PrimitiveType;
+        useType           = ((floatFieldFlags & STRUCT_FIRST_FIELD_SIZE_IS8) != 0) ? TYP_DOUBLE : TYP_FLOAT;
+    }
+    else if (floatFieldFlags != STRUCT_NO_FLOAT_FIELD)
+    {
+        assert((floatFieldFlags & (STRUCT_HAS_FLOAT_FIELDS_MASK ^ STRUCT_FLOAT_FIELD_ONLY_ONE)) != 0);
+        howToReturnStruct = SPK_ByValue;
+        useType           = TYP_STRUCT;
     }
 
 #endif
@@ -1105,7 +1113,8 @@ var_types Compiler::getReturnTypeForStruct(CORINFO_CLASS_HANDLE     clsHnd,
 
 #elif defined(TARGET_LOONGARCH64) || defined(TARGET_RISCV64)
 
-                // On LOONGARCH64/RISCV64 struct that is 1-16 bytes is returned by value in one/two register(s)
+                // On LOONGARCH64 (always) and RISCV64 (integer calling convention) struct that is 1-16 bytes is
+                // returned by value in one/two register(s)
                 howToReturnStruct = SPK_ByValue;
                 useType           = TYP_STRUCT;
 
@@ -8288,6 +8297,59 @@ void Compiler::GetStructTypeOffset(
     GetStructTypeOffset(structDesc, type0, type1, offset0, offset1);
 }
 
+#elif defined(TARGET_RISCV64) || defined(TARGET_LOONGARCH64)
+//------------------------------------------------------------------------
+// GetTypesFromFpStructInRegistersInfo: Gets the field types of a struct passed in registers according to hardware
+// floating-point calling convention.
+//
+// Arguments:
+//      info - the structure contaning information about how the struct is passed
+//      type1st - out param; type of the first field
+//      type2nd - out param; type of the second field (written to iff the struct has two fields)
+//
+// Return value:
+//      None
+//
+// Notes:
+//      If the struct should be passed according to integer calling convention, none of the output pararmeters are
+//      written to.
+//
+void Compiler::GetTypesFromFpStructInRegistersInfo(FpStructInRegistersInfo info, var_types* type1st, var_types* type2nd)
+{
+    if ((info.flags & (FpStruct::BothFloat | FpStruct::Float1st | FpStruct::OnlyOne)) != 0)
+        *type1st = info.IsSize1st8() ? TYP_DOUBLE : TYP_FLOAT;
+
+    if ((info.flags & (FpStruct::BothFloat | FpStruct::Float2nd)) != 0)
+        *type2nd = info.IsSize2nd8() ? TYP_DOUBLE : TYP_FLOAT;
+
+    if ((info.flags & (FpStruct::Float1st | FpStruct::Float2nd)) != 0)
+    {
+        bool      isInt1st = ((info.flags & FpStruct::Float1st) == 0);
+        var_types intType;
+        if ((info.flags & FpStruct::GcRef) != 0)
+        {
+            intType = TYP_REF;
+        }
+        else if ((info.flags & FpStruct::GcByRef) != 0)
+        {
+            intType = TYP_BYREF;
+        }
+        else
+        {
+            static const var_types intTypesLookUpTable[] = {
+                /*[0] =*/TYP_BYTE,
+                /*[1] =*/TYP_SHORT,
+                /*[2] =*/TYP_INT,
+                /*[3] =*/TYP_LONG,
+            };
+            unsigned sizeShift = isInt1st ? info.GetSizeShift1st() : info.GetSizeShift2nd();
+            intType            = intTypesLookUpTable[sizeShift];
+        }
+        var_types* typePtr = isInt1st ? type1st : type2nd;
+        *typePtr           = intType;
+    }
+}
+
 #endif // defined(UNIX_AMD64_ABI)
 
 /*****************************************************************************/