Fix small struct passing to calls by reflection: CopyStructToRegister…

…s is now aware of field offsets and widths
dotnet · tomeksowi · May 2, 2024 · May 6, 2024 · May 6, 2024 · May 8, 2024
commit ac2670ba9cfa5693ae159b5e4c81c2bd77f67de2
diff --git a/src/coreclr/vm/argdestination.h b/src/coreclr/vm/argdestination.h
@@ -106,72 +106,46 @@ class ArgDestination
         #endif // TARGET_RISCV64
 
         _ASSERTE(IsStructPassedInRegs());
-        _ASSERTE(fieldBytes <= 16);
+        _ASSERTE(destOffset == 0);
+        LOONGARCH64_ONLY(_ASSERTE(fieldBytes <= 16);)
 
-        int argOfs = TransitionBlock::GetOffsetOfFloatArgumentRegisters() + m_argLocDescForStructInRegs->m_idxFloatReg * 8;
+        using namespace FpStruct;
+        FpStructInRegistersInfo info = m_argLocDescForStructInRegs->m_structFields;
+        _ASSERTE(m_argLocDescForStructInRegs->m_cFloatReg == ((info.flags & BothFloat) ? 2 : 1));
+        _ASSERTE(m_argLocDescForStructInRegs->m_cGenReg == ((info.flags & (Float1st | Float2nd)) ? 1 : 0));
 
-        if (m_argLocDescForStructInRegs->m_structFields == STRUCT_FLOAT_FIELD_ONLY_TWO)
-        { // struct with two floats.
-            _ASSERTE(m_argLocDescForStructInRegs->m_cFloatReg == 2);
-            _ASSERTE(m_argLocDescForStructInRegs->m_cGenReg == 0);
-            *(INT64*)((char*)m_base + argOfs) = NanBox | *(INT32*)src;
-            *(INT64*)((char*)m_base + argOfs + 8) = NanBox | *((INT32*)src + 1);
-        }
-        else if ((m_argLocDescForStructInRegs->m_structFields & STRUCT_FLOAT_FIELD_FIRST) != 0)
-        { // the first field is float or double.
-            _ASSERTE(m_argLocDescForStructInRegs->m_cFloatReg == 1);
-            _ASSERTE(m_argLocDescForStructInRegs->m_cGenReg == 1);
-            _ASSERTE((m_argLocDescForStructInRegs->m_structFields & STRUCT_FLOAT_FIELD_SECOND) == 0);//the second field is integer.
+        int floatRegOffset = TransitionBlock::GetOffsetOfFloatArgumentRegisters() +
+            m_argLocDescForStructInRegs->m_idxFloatReg * FLOAT_REGISTER_SIZE;
+        INT64* floatReg = (INT64*)((char*)m_base + floatRegOffset);
 
-            if ((m_argLocDescForStructInRegs->m_structFields & STRUCT_FIRST_FIELD_SIZE_IS8) == 0)
-            {
-                *(INT64*)((char*)m_base + argOfs) = NanBox | *(INT32*)src; // the first field is float
-            }
-            else
-            {
-                *(UINT64*)((char*)m_base + argOfs) = *(UINT64*)src; // the first field is double.
-            }
+        if (info.flags & (OnlyOne | BothFloat | Float1st)) // copy first floating field
+        {
+            void* field = (char*)src + info.offset1st;
+            *floatReg++ = info.IsSize1st8() ? *(INT64*)field : NanBox | *(INT32*)field;
+        }
 
-            argOfs = TransitionBlock::GetOffsetOfArgumentRegisters() + m_argLocDescForStructInRegs->m_idxGenReg * 8;
-            if ((m_argLocDescForStructInRegs->m_structFields & STRUCT_HAS_8BYTES_FIELDS_MASK) != 0)
-            {
-                *(UINT64*)((char*)m_base + argOfs) = *((UINT64*)src + 1);
-            }
-            else
-            {
-                *(INT64*)((char*)m_base + argOfs) = *((INT32*)src + 1); // the second field is int32.
-            }
+        if (info.flags & (BothFloat | Float2nd)) // copy second floating field
+        {
+            void* field = (char*)src + info.offset2nd;
+            *floatReg = info.IsSize2nd8() ? *(INT64*)field : NanBox | *(INT32*)field;
         }
-        else if ((m_argLocDescForStructInRegs->m_structFields & STRUCT_FLOAT_FIELD_SECOND) != 0)
-        { // the second field is float or double.
-            _ASSERTE(m_argLocDescForStructInRegs->m_cFloatReg == 1);
-            _ASSERTE(m_argLocDescForStructInRegs->m_cGenReg == 1);
-            _ASSERTE((m_argLocDescForStructInRegs->m_structFields & STRUCT_FLOAT_FIELD_FIRST) == 0);//the first field is integer.
-
-            // destOffset - nonzero when copying values into Nullable<T>, it is the offset of the T value inside of the Nullable<T>.
-            // here the first field maybe Nullable.
-            if ((m_argLocDescForStructInRegs->m_structFields & STRUCT_HAS_8BYTES_FIELDS_MASK) == 0)
-            {
-                // the second field is float.
-                *(INT64*)((char*)m_base + argOfs) = NanBox | (destOffset == 0 ? *((INT32*)src + 1) : *(INT32*)src);
-            }
-            else
-            {
-                // the second field is double.
-                *(UINT64*)((char*)m_base + argOfs) = destOffset == 0 ? *((UINT64*)src + 1) : *(UINT64*)src;
-            }
 
-            if (0 == destOffset)
+        if (info.flags & (Float1st | Float2nd)) // copy integer field
+        {
+            int intRegOffset = TransitionBlock::GetOffsetOfArgumentRegisters() +
+                m_argLocDescForStructInRegs->m_idxGenReg * TARGET_POINTER_SIZE;
+            INT64* intReg = (INT64*)((char*)m_base + intRegOffset);
+
+            void* field = (char*)src + ((info.flags & Float2nd) ? info.offset1st : info.offset2nd);
+            switch ((info.flags & Float2nd) ? info.GetSizeShift1st() : info.GetSizeShift2nd())
             {
-                // NOTE: here ignoring the first size.
-                argOfs = TransitionBlock::GetOffsetOfArgumentRegisters() + m_argLocDescForStructInRegs->m_idxGenReg * 8;
-                *(UINT64*)((char*)m_base + argOfs) = *(UINT64*)src;
+                case 0: *intReg = *(INT8* )field; break;
+                case 1: *intReg = *(INT16*)field; break;
+                case 2: *intReg = *(INT32*)field; break;
+                case 3: *intReg = *(INT64*)field; break;
+                default: _ASSERTE(false);
             }
         }
-        else
-        {
-            _ASSERTE(!"---------UNReachable-------LoongArch64/RISC-V64!!!");
-        }
     }
 #endif // !DACCESS_COMPILE
 

diff --git a/src/coreclr/vm/callingconvention.h b/src/coreclr/vm/callingconvention.h
@@ -42,7 +42,7 @@ struct ArgLocDesc
     int     m_byteStackIndex;     // Stack offset in bytes (or -1)
     int     m_byteStackSize;      // Stack size in bytes
 #if defined(TARGET_LOONGARCH64) || defined(TARGET_RISCV64)
-    int     m_structFields;       // Struct field info when using Float-register except two-doubles case.
+    FpStructInRegistersInfo m_structFields; // Struct field info when using floating-point register(s)
 #endif
 
 #if defined(UNIX_AMD64_ABI)
@@ -97,7 +97,7 @@ struct ArgLocDesc
         m_hfaFieldSize = 0;
 #endif // defined(TARGET_ARM64)
 #if defined(TARGET_LOONGARCH64) || defined(TARGET_RISCV64)
-        m_structFields = STRUCT_NO_FLOAT_FIELD;
+        m_structFields = {};
 #endif
 #if defined(UNIX_AMD64_ABI)
         m_eeClass = NULL;
@@ -1844,7 +1844,7 @@ int ArgIteratorTemplate<ARGITERATOR_BASE>::GetNextOffset()
                 m_argLocDescForStructInRegs.m_idxGenReg = m_idxGenReg;
                 m_argLocDescForStructInRegs.m_cGenReg = 1;
 
-                m_argLocDescForStructInRegs.m_structFields = info.ToOldFlags();
+                m_argLocDescForStructInRegs.m_structFields = info;
                 m_hasArgLocDescForStructInRegs = true;
 
                 int regOffset = (info.flags & FpStruct::Float2nd)
@@ -1858,18 +1858,16 @@ int ArgIteratorTemplate<ARGITERATOR_BASE>::GetNextOffset()
         else if (cFPRegs + m_idxFPReg <= NUM_ARGUMENT_REGISTERS)
         {
             int regOffset = TransitionBlock::GetOffsetOfFloatArgumentRegisters() + m_idxFPReg * FLOAT_REGISTER_SIZE;
-            if (info.flags == (FpStruct::BothFloat | (2 << FpStruct::PosSizeShift1st) | (2 << FpStruct::PosSizeShift2nd)))
+
+            if ((info.flags & (FpStruct::BothFloat | FpStruct::OnlyOne))
+                && (info.offset1st != 0 || info.offset2nd != FLOAT_REGISTER_SIZE))
             {
-                // Struct with two single-float fields
-                assert(info.GetSize1st() == sizeof(float));
-                assert(info.GetSize2nd() == sizeof(float));
+                // Struct with one or two floating-point fields laid out differently than in TransitionBlock::FloatArgumentRegisters
                 m_argLocDescForStructInRegs.Init();
                 m_argLocDescForStructInRegs.m_idxFloatReg = m_idxFPReg;
-                m_argLocDescForStructInRegs.m_cFloatReg = 2;
-                assert(cFPRegs == 2);
-                assert(argSize == 2 * sizeof(float));
+                m_argLocDescForStructInRegs.m_cFloatReg = cFPRegs;
 
-                m_argLocDescForStructInRegs.m_structFields = info.ToOldFlags();
+                m_argLocDescForStructInRegs.m_structFields = info;
                 m_hasArgLocDescForStructInRegs = true;
             }
             m_idxFPReg += cFPRegs;

diff --git a/src/coreclr/vm/comdelegate.cpp b/src/coreclr/vm/comdelegate.cpp
@@ -172,7 +172,7 @@ class ShuffleIterator
         if (m_currentFloatRegIndex < m_argLocDesc->m_cFloatReg)
         {
 #if defined(TARGET_LOONGARCH64) || defined(TARGET_RISCV64)
-            if ((m_argLocDesc->m_structFields & STRUCT_FLOAT_FIELD_SECOND) && (m_currentGenRegIndex < m_argLocDesc->m_cGenReg))
+            if ((m_argLocDesc->m_structFields.flags & FpStruct::Float2nd) && (m_currentGenRegIndex < m_argLocDesc->m_cGenReg))
             {
                 // the first field is integer so just skip this.
             }

diff --git a/src/coreclr/vm/riscv64/profiler.cpp b/src/coreclr/vm/riscv64/profiler.cpp
@@ -111,13 +111,14 @@ LPVOID ProfileArgIterator::CopyStructFromRegisters(const ArgLocDesc* sir)
     _ASSERTE(m_handle);
     PROFILE_PLATFORM_SPECIFIC_DATA* pData = reinterpret_cast<PROFILE_PLATFORM_SPECIFIC_DATA*>(m_handle);
 
+    StructFloatFieldInfoFlags flags = sir->m_structFields.ToOldFlags();
     struct { bool isFloat, is8; } fields[] = {
-        { (bool) (sir->m_structFields & (STRUCT_FLOAT_FIELD_FIRST | STRUCT_FLOAT_FIELD_ONLY_TWO | STRUCT_FLOAT_FIELD_ONLY_ONE)),
-          (bool) (sir->m_structFields & STRUCT_FIRST_FIELD_SIZE_IS8) },
-        { (bool) (sir->m_structFields & (STRUCT_FLOAT_FIELD_SECOND | STRUCT_FLOAT_FIELD_ONLY_TWO)),
-          (bool) (sir->m_structFields & STRUCT_SECOND_FIELD_SIZE_IS8) },
+        { (bool) (flags & (STRUCT_FLOAT_FIELD_FIRST | STRUCT_FLOAT_FIELD_ONLY_TWO | STRUCT_FLOAT_FIELD_ONLY_ONE)),
+          (bool) (flags & STRUCT_FIRST_FIELD_SIZE_IS8) },
+        { (bool) (flags & (STRUCT_FLOAT_FIELD_SECOND | STRUCT_FLOAT_FIELD_ONLY_TWO)),
+          (bool) (flags & STRUCT_SECOND_FIELD_SIZE_IS8) },
     };
-    int fieldCount = (sir->m_structFields & STRUCT_FLOAT_FIELD_ONLY_ONE) ? 1 : 2;
+    int fieldCount = (flags & STRUCT_FLOAT_FIELD_ONLY_ONE) ? 1 : 2;
     UINT64 bufferPosBegin = m_bufferPos;
     const double *fRegBegin = &pData->floatArgumentRegisters.f[sir->m_idxFloatReg], *fReg = fRegBegin;
     const double *fRegEnd = &pData->floatArgumentRegisters.f[0] + NUM_FLOAT_ARGUMENT_REGISTERS;
@@ -185,7 +186,7 @@ LPVOID ProfileArgIterator::GetNextArgAddr()
         // If both fields are in registers of same kind (either float or general) and both are 8 bytes, no need to copy.
         // We can get away with returning a ptr to argumentRegisters since the struct would have the same layout.
         if ((sir->m_cFloatReg ^ sir->m_cGenReg) != 2 ||
-            (sir->m_structFields & STRUCT_HAS_8BYTES_FIELDS_MASK) != STRUCT_HAS_8BYTES_FIELDS_MASK)
+            (sir->m_structFields.ToOldFlags() & STRUCT_HAS_8BYTES_FIELDS_MASK) != STRUCT_HAS_8BYTES_FIELDS_MASK)
         {
             return CopyStructFromRegisters(sir);
         }
@@ -317,7 +318,7 @@ LPVOID ProfileArgIterator::GetReturnBufferAddr(void)
         sir.m_cGenReg = -1;
         sir.m_byteStackIndex = 0;
         sir.m_byteStackSize = -1;
-        sir.m_structFields = fpReturnSize;
+        sir.m_structFields = FpStructInRegistersInfo::FromOldFlags((StructFloatFieldInfoFlags)fpReturnSize);
         return CopyStructFromRegisters(&sir);
     }