Check HFA alignment for valuetype fields

docs/workflow/testing/coreclr/running-arm32-tests.md

@@ -0,0 +1,36 @@
+# Running ARM32 tests on modern hardware
+
+One of our supported targets is 32-bit ARM. It can be quite challenging to construct a realistic ARM32 environment where you can build or run tests in a reasonable amount of time. Thankfully, it's possible to configure an ARM64 linux environment so that you can cross-build from ARM64 to ARM32, and run tests there using native hardware support instead of software emulation. This is not possible on ARM64-based Windows (this functionality is not offered by the OS).
+
+## Configuring your ARM64 environment to run ARM32 binaries
+
+By default your ARM64 Linux install probably doesn't have support for ARM32 binaries enabled, which will cause running the binaries to fail with a cryptic error. So you'll need to add the architecture to dpkg and install some core userspace libraries that CoreCLR will need to actually run your tests, which on Debian or Ubuntu will look like:
+
+```bash
+$ sudo dpkg --add-architecture armhf
+
+$ sudo apt-get update
+Reading package lists... Done
+
+$ sudo apt-get install libc6:armhf libstdc++6:armhf libicu74:armhf
+The following additional packages will be installed:
+```
+
+Note that when installing a package for another architecture, you need to suffix the package name with the architecture name. For me, the three packages above were sufficient to run an ARM32 JIT test.
+
+## Cross-building for ARM32 on ARM64
+
+Follow the steps from https://github.com/dotnet/runtime/blob/main/docs/workflow/building/coreclr/cross-building.md#linux-cross-building as-is. You should end up with a `linux.arm` `Core_Root` and test artifacts.
+
+## Running an ARM32 test in your ARM64 environment
+
+We're finally ready to go, probably. Export an environment variable to point to your ARM32 core root, and then run your test, i.e.:
+
+```bash
+$ export CORE_ROOT=/home/kg/runtime/artifacts/tests/coreclr/linux.arm.Release/Tests/Core_Root/
+
+$ bash artifacts/tests/coreclr/linux.arm.Release/JIT/Directed/StructABI/StructABI/StructABI.sh
+BEGIN EXECUTION
+/home/kg/runtime/artifacts/tests/coreclr/linux.arm.Release/Tests/Core_Root//corerun -p System.Reflection.Metadata.MetadataUpdater.IsSupported=false -p System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization=true StructABI.dll ''
+Issue80393_HFA failed. Retval: f1=1 f3=3
+```

src/coreclr/vm/class.cpp

@@ -1863,6 +1863,29 @@ EEClass::CheckForHFA()
                     fieldHFAType = pFD->LookupApproxFieldTypeHandle().AsMethodTable()->GetHFAType();
 #endif
                 }
+
+                int requiredAlignment;
+                switch (fieldHFAType)
+                {
+                case CORINFO_HFA_ELEM_FLOAT:
+                    requiredAlignment = 4;
+                    break;
+                case CORINFO_HFA_ELEM_VECTOR64:
+                case CORINFO_HFA_ELEM_DOUBLE:
+                    requiredAlignment = 8;
+                    break;
+                case CORINFO_HFA_ELEM_VECTOR128:
+                    requiredAlignment = 16;
+                    break;
+                default:
+                    // VT without a valid HFA type inside of this struct means this struct is not an HFA
+                    return false;
+                }
+
+                if (requiredAlignment && (pFD->GetOffset() % requiredAlignment != 0)) // HFAs don't have unaligned fields.
+                {
+                    return false;
+                }
             }
             break;
 

src/tests/JIT/Directed/StructABI/StructABI.c

@@ -221,6 +221,49 @@ struct Nested9
 	struct InlineArray4 Field2;
 };
 
+struct Issue80393_S_Doubles
+{
+    double f1;
+    double f3;
+};
+
+// We need to apply 1-byte packing to these structs to get the exact alignment we want, but we
+//  don't want to apply packing to the union or 2-doubles struct because it will change the natural
+//  alignment of the union and as a result alter which registers it's assigned to by clang, which
+//  won't match what CoreCLR does.
+#pragma pack(push, 1)
+struct Issue80393_F2
+{
+    double value;
+};
+
+struct Issue80393_F2_Offset {
+    // 3 padding bytes to approximate C# FieldOffset of 3.
+    // This padding prevents the outer union from being treated as an HVA/HFA by clang for either arm32 or arm64.
+    char padding[3];
+    struct Issue80393_F2 F2;
+};
+#pragma pack(pop)
+
+union Issue80393_S {
+    struct Issue80393_S_Doubles f1_f3;
+    struct Issue80393_F2_Offset f2;
+};
+
+// NOTE: If investigating this in isolation, make sure you set -mfloat-abi=hard -mfpu=neon when building for arm32
+DLLEXPORT union Issue80393_S Issue80393_HFA(union Issue80393_S value)
+{
+    // Simply doing 'return value' like most of these other functions isn't enough to exercise everything, because
+    //  depending on the calling convention it can turn the whole function into a no-op, where 'value' flows in
+    //  via the same registers that the result flows out through.
+    union Issue80393_S result;
+    // Use the value argument as part of the result so we can tell whether it was passed in correctly, in addition
+    //  to checking whether the return value was passed correctly back to C#.
+    result.f1_f3.f1 = 1.0 + value.f1_f3.f1;
+    result.f1_f3.f3 = 3.0 + value.f1_f3.f3;
+    return result;
+}
+
 DLLEXPORT struct SingleByte EchoSingleByte(struct SingleByte value)
 {
 	return value;