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

src/coreclr/tools/Common/JitInterface/RISCV64PassStructInRegister.cs

@@ -11,9 +11,7 @@ namespace Internal.JitInterface
 {
     internal static class RISCV64PassStructInRegister
     {
-        private const int
-            ENREGISTERED_PARAMTYPE_MAXSIZE = 16,
-            TARGET_POINTER_SIZE = 8;
+        private const int TARGET_POINTER_SIZE = 8;
 
         private static bool HandleInlineArray(int elementTypeIndex, int nElements, Span<StructFloatFieldInfoFlags> types, ref int typeIndex)
         {
@@ -90,9 +88,6 @@ private static bool FlattenFieldTypes(TypeDesc td, Span<StructFloatFieldInfoFlag
 
         public static uint GetRISCV64PassStructInRegisterFlags(TypeDesc td)
         {
-            if (td.GetElementSize().AsInt > ENREGISTERED_PARAMTYPE_MAXSIZE)
-                return (uint)STRUCT_NO_FLOAT_FIELD;
-
             Span<StructFloatFieldInfoFlags> types = stackalloc StructFloatFieldInfoFlags[] {
                 STRUCT_NO_FLOAT_FIELD, STRUCT_NO_FLOAT_FIELD
             };

src/coreclr/tools/Common/JitInterface/SystemVStructClassificator.cs

@@ -5,6 +5,7 @@
 using System.Diagnostics;
 using ILCompiler;
 using Internal.TypeSystem;
+using System.Runtime.CompilerServices;
 using static Internal.JitInterface.SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR;
 using static Internal.JitInterface.SystemVClassificationType;
 
@@ -207,7 +208,10 @@ private static bool ClassifyEightBytes(TypeDesc typeDesc,
 
             if (numIntroducedFields == 0)
             {
-                return false;
+                // Classify empty struct like padding
+                helper.LargestFieldOffset = startOffsetOfStruct;
+                AssignClassifiedEightByteTypes(ref helper);
+                return true;
             }
 
             // The SIMD and Int128 Intrinsic types are meant to be handled specially and should not be passed as struct registers
@@ -375,8 +379,12 @@ private static void AssignClassifiedEightByteTypes(ref SystemVStructRegisterPass
                 // Calculate the eightbytes and their types.
 
                 int lastFieldOrdinal = sortedFieldOrder[largestFieldOffset];
-                int offsetAfterLastFieldByte = largestFieldOffset + helper.FieldSizes[lastFieldOrdinal];
-                SystemVClassificationType lastFieldClassification = helper.FieldClassifications[lastFieldOrdinal];
+                int lastFieldSize = (lastFieldOrdinal >= 0) ? helper.FieldSizes[lastFieldOrdinal] : 0;
+                int offsetAfterLastFieldByte = largestFieldOffset + lastFieldSize;
+                Debug.Assert(offsetAfterLastFieldByte <= helper.StructSize);
+                SystemVClassificationType lastFieldClassification = (lastFieldOrdinal >= 0)
+                    ? helper.FieldClassifications[lastFieldOrdinal]
+                    : SystemVClassificationTypeNoClass;
 
                 int usedEightBytes = 0;
                 int accumulatedSizeForEightBytes = 0;
@@ -403,6 +411,8 @@ private static void AssignClassifiedEightByteTypes(ref SystemVStructRegisterPass
                         // the SysV ABI spec.
                         fieldSize = 1;
                         fieldClassificationType = offset < offsetAfterLastFieldByte ? SystemVClassificationTypeNoClass : lastFieldClassification;
+                        if (offset % SYSTEMV_EIGHT_BYTE_SIZE_IN_BYTES == 0) // new eightbyte
+                            foundFieldInEightByte = false;
                     }
                     else
                     {
@@ -455,7 +465,8 @@ private static void AssignClassifiedEightByteTypes(ref SystemVStructRegisterPass
                         }
                     }
 
-                    if ((offset + 1) % SYSTEMV_EIGHT_BYTE_SIZE_IN_BYTES == 0) // If we just finished checking the last byte of an eightbyte
+                    // If we just finished checking the last byte of an eightbyte or the entire struct
+                    if ((offset + 1) % SYSTEMV_EIGHT_BYTE_SIZE_IN_BYTES == 0 || (offset + 1) == helper.StructSize)
                     {
                         if (!foundFieldInEightByte)
                         {

src/coreclr/vm/methodtable.cpp

@@ -2212,11 +2212,14 @@ bool MethodTable::ClassifyEightBytesWithManagedLayout(SystemVStructRegisterPassi
 
     DWORD numIntroducedFields = GetNumIntroducedInstanceFields();
 
-    // It appears the VM gives a struct with no fields of size 1.
-    // Don't pass in register such structure.
     if (numIntroducedFields == 0)
     {
-        return false;
+        helperPtr->largestFieldOffset = startOffsetOfStruct;
+        LOG((LF_JIT, LL_EVERYTHING, "%*s**** Classify empty struct %s (%p) like padding, startOffset %d, total struct size %d\n",
+            nestingLevel * 5, "", this->GetDebugClassName(), this, startOffsetOfStruct, helperPtr->structSize));
+
+        AssignClassifiedEightByteTypes(helperPtr, nestingLevel);
+        return true;
     }
 
     // The SIMD Intrinsic types are meant to be handled specially and should not be passed as struct registers
@@ -2432,7 +2435,12 @@ bool MethodTable::ClassifyEightBytesWithNativeLayout(SystemVStructRegisterPassin
     // No fields.
     if (numIntroducedFields == 0)
     {
-        return false;
+        helperPtr->largestFieldOffset = startOffsetOfStruct;
+        LOG((LF_JIT, LL_EVERYTHING, "%*s**** Classify empty struct %s (%p) like padding, startOffset %d, total struct size %d\n",
+            nestingLevel * 5, "", this->GetDebugClassName(), this, startOffsetOfStruct, helperPtr->structSize));
+
+        AssignClassifiedEightByteTypes(helperPtr, nestingLevel);
+        return true;
     }
 
     bool hasImpliedRepeatedFields = HasImpliedRepeatedFields(this);
@@ -2684,8 +2692,12 @@ void  MethodTable::AssignClassifiedEightByteTypes(SystemVStructRegisterPassingHe
         // Calculate the eightbytes and their types.
 
         int lastFieldOrdinal = sortedFieldOrder[largestFieldOffset];
-        unsigned int offsetAfterLastFieldByte = largestFieldOffset + helperPtr->fieldSizes[lastFieldOrdinal];
-        SystemVClassificationType lastFieldClassification = helperPtr->fieldClassifications[lastFieldOrdinal];
+        unsigned int lastFieldSize = (lastFieldOrdinal >= 0) ? helperPtr->fieldSizes[lastFieldOrdinal] : 0;
+        unsigned int offsetAfterLastFieldByte = largestFieldOffset + lastFieldSize;
+        _ASSERTE(offsetAfterLastFieldByte <= helperPtr->structSize);
+        SystemVClassificationType lastFieldClassification = (lastFieldOrdinal >= 0)
+            ? helperPtr->fieldClassifications[lastFieldOrdinal]
+            : SystemVClassificationTypeNoClass;
 
         unsigned int usedEightBytes = 0;
         unsigned int accumulatedSizeForEightBytes = 0;
@@ -2712,6 +2724,8 @@ void  MethodTable::AssignClassifiedEightByteTypes(SystemVStructRegisterPassingHe
                 // the SysV ABI spec.
                 fieldSize = 1;
                 fieldClassificationType = offset < offsetAfterLastFieldByte ? SystemVClassificationTypeNoClass : lastFieldClassification;
+                if (offset % SYSTEMV_EIGHT_BYTE_SIZE_IN_BYTES == 0) // new eightbyte
+                    foundFieldInEightByte = false;
             }
             else
             {
@@ -2764,7 +2778,8 @@ void  MethodTable::AssignClassifiedEightByteTypes(SystemVStructRegisterPassingHe
                 }
             }
 
-            if ((offset + 1) % SYSTEMV_EIGHT_BYTE_SIZE_IN_BYTES == 0) // If we just finished checking the last byte of an eightbyte
+            //  If we just finished checking the last byte of an eightbyte or the entire struct
+            if ((offset + 1) % SYSTEMV_EIGHT_BYTE_SIZE_IN_BYTES == 0 || (offset + 1) == helperPtr->structSize)
             {
                 if (!foundFieldInEightByte)
                 {
@@ -2803,9 +2818,9 @@ void  MethodTable::AssignClassifiedEightByteTypes(SystemVStructRegisterPassingHe
         LOG((LF_JIT, LL_EVERYTHING, "     **** Number EightBytes: %d\n", helperPtr->eightByteCount));
         for (unsigned i = 0; i < helperPtr->eightByteCount; i++)
         {
-            _ASSERTE(helperPtr->eightByteClassifications[i] != SystemVClassificationTypeNoClass);
             LOG((LF_JIT, LL_EVERYTHING, "     **** eightByte %d -- classType: %s, eightByteOffset: %d, eightByteSize: %d\n",
                 i, GetSystemVClassificationTypeName(helperPtr->eightByteClassifications[i]), helperPtr->eightByteOffsets[i], helperPtr->eightByteSizes[i]));
+            _ASSERTE(helperPtr->eightByteClassifications[i] != SystemVClassificationTypeNoClass);
         }
 #endif // _DEBUG
     }
@@ -3567,9 +3582,6 @@ static bool FlattenFieldTypes(TypeHandle th, StructFloatFieldInfoFlags types[2],
 
 int MethodTable::GetRiscV64PassStructInRegisterFlags(TypeHandle th)
 {
-    if (th.GetSize() > ENREGISTERED_PARAMTYPE_MAXSIZE)
-        return STRUCT_NO_FLOAT_FIELD;
-
     StructFloatFieldInfoFlags types[2] = {STRUCT_NO_FLOAT_FIELD, STRUCT_NO_FLOAT_FIELD};
     int nFields = 0;
     if (!FlattenFieldTypes(th, types, nFields) || nFields == 0)

src/tests/JIT/Directed/StructABI/CMakeLists.txt

@@ -2,13 +2,14 @@ project (StructABILib)
 include_directories(${INC_PLATFORM_DIR})
 
 if(CLR_CMAKE_HOST_WIN32)
-    add_compile_options(/TC) # compile all files as C
+    set_source_files_properties(StructABI.c PROPERTIES COMPILE_OPTIONS /TC) # compile as C
 else()
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
+    set(CMAKE_CPP_FLAGS "${CMAKE_CPP_FLAGS} -fvisibility=hidden -Wno-return-type-c-linkage")
 endif()
 
 # add the executable
-add_library (StructABILib SHARED StructABI.c)
+add_library (StructABILib SHARED StructABI.c StructABI.cpp)
 
 # add the install targets
 install (TARGETS StructABILib DESTINATION bin)

src/tests/JIT/Directed/StructABI/StructABI.cpp

@@ -0,0 +1,159 @@
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+#include <stdint.h>
+#include <stddef.h>
+
+#ifdef _MSC_VER
+#define DLLEXPORT __declspec(dllexport)
+#else
+#define DLLEXPORT __attribute__((visibility("default")))
+#endif // _MSC_VER
+
+struct Empty
+{
+};
+static_assert(sizeof(Empty) == 1, "Empty struct must be sized like in .NET");
+
+struct LongEmptyDouble
+{
+	int64_t FieldL;
+	Empty FieldE;
+	double FieldD;
+};
+
+struct NestedEmpty
+{
+	struct InnerEmpty
+	{
+		Empty e;
+	} e;
+};
+static_assert(sizeof(NestedEmpty) == 1, "Nested empty struct must be sized like in .NET");
+
+struct NestedEmptyFloatDouble
+{
+	NestedEmpty FieldNE;
+	float FieldF;
+	double FieldD;
+};
+
+struct EmptyIntAndFloat
+{	
+	struct EmptyInt
+	{
+		Empty FieldE;
+		int32_t FieldI;
+	};
+	EmptyInt FieldEI;
+	float FieldF;
+};
+
+struct LongEmptyAndFloat
+{
+	struct LongEmpty
+	{
+		int64_t FieldL;
+		Empty FieldE;
+	};
+	LongEmpty FieldLE;
+	float FieldF;
+};
+
+struct ArrayOfEmpties
+{
+	Empty e[1];
+};
+
+struct ArrayOfEmptiesFloatDouble
+{
+	ArrayOfEmpties FieldAoE;
+	float FieldF;
+	double FieldD;
+};
+
+template<typename T>
+struct Eight
+{
+	T e1, e2, e3, e4, e5, e6, e7, e8;
+};
+
+struct FloatEmpty32kInt
+{
+	float FieldF;
+	Eight<Eight<Eight<Eight<Eight<Empty>>>>> FieldEmpty32k;
+	int32_t FieldI;
+};
+
+#pragma pack(push, 1)
+struct PackedEmptyFloatLong
+{
+	Empty FieldE;
+	float FieldF;
+	int64_t FieldL;
+};
+#pragma pack(pop)
+
+struct ExplicitFloatLong
+{
+	PackedEmptyFloatLong s;
+};
+static_assert(offsetof(ExplicitFloatLong, s.FieldE) == 0, "");
+static_assert(offsetof(ExplicitFloatLong, s.FieldF) == 1, "");
+static_assert(offsetof(ExplicitFloatLong, s.FieldL) == 5, "");
+
+extern "C"
+{
+
+DLLEXPORT LongEmptyDouble EchoLongEmptyDoubleRiscV(LongEmptyDouble a0_fa0)
+{
+	return a0_fa0;
+}
+
+DLLEXPORT LongEmptyDouble EchoLongEmptyDoubleByImplicitRefRiscV(
+	float fa0, float fa1, float fa2, float fa3, float fa4, float fa5, float fa6, float fa7, LongEmptyDouble byRef)
+{
+	return byRef;
+}
+
+DLLEXPORT NestedEmptyFloatDouble EchoNestedEmptyFloatDoubleRiscV(NestedEmptyFloatDouble fa0_fa1)
+{
+	return fa0_fa1;
+}
+
+DLLEXPORT NestedEmptyFloatDouble EchoNestedEmptyFloatDoubleInIntegerRegsRiscV(
+	float fa0, float fa1, float fa2, float fa3, float fa4, float fa5, float fa6, NestedEmptyFloatDouble a0_a1)
+{
+	return a0_a1;
+}
+
+DLLEXPORT EmptyIntAndFloat EchoEmptyIntAndFloatRiscV(EmptyIntAndFloat a0_fa0)
+{
+	return a0_fa0;
+}
+
+DLLEXPORT LongEmptyAndFloat EchoLongEmptyAndFloatRiscV(LongEmptyAndFloat a0_fa0)
+{
+	return a0_fa0;
+}
+
+DLLEXPORT ArrayOfEmptiesFloatDouble EchoArrayOfEmptiesFloatDoubleInIntegerRegsRiscV(ArrayOfEmptiesFloatDouble a0_a1)
+{
+	return a0_a1;
+}
+
+DLLEXPORT FloatEmpty32kInt EchoFloatEmpty32kIntRiscV(FloatEmpty32kInt fa0_a0)
+{
+	return fa0_a0;
+}
+
+DLLEXPORT PackedEmptyFloatLong EchoPackedEmptyFloatLongRiscV(PackedEmptyFloatLong fa0_a0)
+{
+	return fa0_a0;
+}
+
+DLLEXPORT ExplicitFloatLong EchoExplicitFloatLongRiscV(ExplicitFloatLong fa0_a0)
+{
+	return fa0_a0;
+}
+
+} // extern "C"